Doug / smarc-fsl-linux-kernel

1

/*

1

/*

2

* Server-side XDR for NFSv4

2

* Server-side XDR for NFSv4

3

*

3

*

4

5

6

*

6

*

7

* Kendrick Smith <kmsmith@umich.edu>

7

* Kendrick Smith <kmsmith@umich.edu>

8

* Andy Adamson <andros@umich.edu>

8

* Andy Adamson <andros@umich.edu>

9

*

9

*

10

* Redistribution and use in source and binary forms, with or without

10

* Redistribution and use in source and binary forms, with or without

11

* modification, are permitted provided that the following conditions

11

* modification, are permitted provided that the following conditions

12

* are met:

12

* are met:

13

*

13

*

14

* 1. Redistributions of source code must retain the above copyright

14

* 1. Redistributions of source code must retain the above copyright

15

* notice, this list of conditions and the following disclaimer.

15

* notice, this list of conditions and the following disclaimer.

16

* 2. Redistributions in binary form must reproduce the above copyright

16

* 2. Redistributions in binary form must reproduce the above copyright

17

* notice, this list of conditions and the following disclaimer in the

17

* notice, this list of conditions and the following disclaimer in the

18

* documentation and/or other materials provided with the distribution.

18

* documentation and/or other materials provided with the distribution.

19

* 3. Neither the name of the University nor the names of its

19

* 3. Neither the name of the University nor the names of its

20

* contributors may be used to endorse or promote products derived

20

* contributors may be used to endorse or promote products derived

21

* from this software without specific prior written permission.

21

* from this software without specific prior written permission.

22

*

22

*

23

* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED

23

* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED

24

* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF

24

* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF

25

* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE

25

* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE

26

* DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE

26

* DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE

27

* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR

27

* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR

28

* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF

28

* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF

29

* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR

29

* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR

30

* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF

30

* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF

31

* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING

31

* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING

32

* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS

32

* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS

33

* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

33

* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

34

*

34

*

35

* TODO: Neil Brown made the following observation: We currently

35

* TODO: Neil Brown made the following observation: We currently

36

* initially reserve NFSD_BUFSIZE space on the transmit queue and

36

* initially reserve NFSD_BUFSIZE space on the transmit queue and

37

* never release any of that until the request is complete.

37

* never release any of that until the request is complete.

38

* It would be good to calculate a new maximum response size while

38

* It would be good to calculate a new maximum response size while

39

* decoding the COMPOUND, and call svc_reserve with this number

39

* decoding the COMPOUND, and call svc_reserve with this number

40

* at the end of nfs4svc_decode_compoundargs.

40

* at the end of nfs4svc_decode_compoundargs.

41

*/

41

*/

42

43

#include <linux/slab.h>

43

#include <linux/slab.h>

44

#include <linux/namei.h>

44

#include <linux/namei.h>

45

#include <linux/statfs.h>

45

#include <linux/statfs.h>

46

#include <linux/utsname.h>

46

#include <linux/utsname.h>

47

#include <linux/pagemap.h>

47

#include <linux/pagemap.h>

48

#include <linux/sunrpc/svcauth_gss.h>

48

#include <linux/sunrpc/svcauth_gss.h>

49

50

#include "idmap.h"

50

#include "idmap.h"

51

#include "acl.h"

51

#include "acl.h"

52

#include "xdr4.h"

52

#include "xdr4.h"

53

#include "vfs.h"

53

#include "vfs.h"

54

#include "state.h"

54

#include "state.h"

55

#include "cache.h"

55

#include "cache.h"

56

57

#define NFSDDBG_FACILITY NFSDDBG_XDR

57

#define NFSDDBG_FACILITY NFSDDBG_XDR

58

59

/*

59

/*

60

* As per referral draft, the fsid for a referral MUST be different from the fsid of the containing

60

* As per referral draft, the fsid for a referral MUST be different from the fsid of the containing

61

* directory in order to indicate to the client that a filesystem boundary is present

61

* directory in order to indicate to the client that a filesystem boundary is present

62

* We use a fixed fsid for a referral

62

* We use a fixed fsid for a referral

63

*/

63

*/

64

#define NFS4_REFERRAL_FSID_MAJOR 0x8000000ULL

64

#define NFS4_REFERRAL_FSID_MAJOR 0x8000000ULL

65

#define NFS4_REFERRAL_FSID_MINOR 0x8000000ULL

65

#define NFS4_REFERRAL_FSID_MINOR 0x8000000ULL

66

67

static __be32

67

static __be32

68

check_filename(char *str, int len, __be32 err)

68

check_filename(char *str, int len, __be32 err)

69

{

69

{

70

int i;

70

int i;

71

72

if (len == 0)

72

if (len == 0)

73

return nfserr_inval;

73

return nfserr_inval;

74

if (isdotent(str, len))

74

if (isdotent(str, len))

75

return err;

75

return err;

76

for (i = 0; i < len; i++)

76

for (i = 0; i < len; i++)

77

if (str[i] == '/')

77

if (str[i] == '/')

78

return err;

78

return err;

79

return 0;

79

return 0;

80

}

80

}

81

82

#define DECODE_HEAD \

82

#define DECODE_HEAD \

83

__be32 *p; \

83

__be32 *p; \

84

__be32 status

84

__be32 status

85

#define DECODE_TAIL \

85

#define DECODE_TAIL \

86

status = 0; \

86

status = 0; \

87

out: \

87

out: \

88

return status; \

88

return status; \

89

xdr_error: \

89

xdr_error: \

90

dprintk("NFSD: xdr error (%s:%d)\n", \

90

dprintk("NFSD: xdr error (%s:%d)\n", \

91

__FILE__, __LINE__); \

91

__FILE__, __LINE__); \

92

status = nfserr_bad_xdr; \

92

status = nfserr_bad_xdr; \

93

goto out

93

goto out

94

95

#define READ32(x) (x) = ntohl(*p++)

95

#define READ32(x) (x) = ntohl(*p++)

96

#define READ64(x) do { \

96

#define READ64(x) do { \

97

(x) = (u64)ntohl(*p++) << 32; \

97

(x) = (u64)ntohl(*p++) << 32; \

98

(x) |= ntohl(*p++); \

98

(x) |= ntohl(*p++); \

99

} while (0)

99

} while (0)

100

#define READTIME(x) do { \

100

#define READTIME(x) do { \

101

p++; \

101

p++; \

102

(x) = ntohl(*p++); \

102

(x) = ntohl(*p++); \

103

p++; \

103

p++; \

104

} while (0)

104

} while (0)

105

#define READMEM(x,nbytes) do { \

105

#define READMEM(x,nbytes) do { \

106

x = (char *)p; \

106

x = (char *)p; \

107

p += XDR_QUADLEN(nbytes); \

107

p += XDR_QUADLEN(nbytes); \

108

} while (0)

108

} while (0)

109

#define SAVEMEM(x,nbytes) do { \

109

#define SAVEMEM(x,nbytes) do { \

110

if (!(x = (p==argp->tmp || p == argp->tmpp) ? \

110

if (!(x = (p==argp->tmp || p == argp->tmpp) ? \

111

savemem(argp, p, nbytes) : \

111

savemem(argp, p, nbytes) : \

112

(char *)p)) { \

112

(char *)p)) { \

113

dprintk("NFSD: xdr error (%s:%d)\n", \

113

dprintk("NFSD: xdr error (%s:%d)\n", \

114

__FILE__, __LINE__); \

114

__FILE__, __LINE__); \

115

goto xdr_error; \

115

goto xdr_error; \

116

} \

116

} \

117

p += XDR_QUADLEN(nbytes); \

117

p += XDR_QUADLEN(nbytes); \

118

} while (0)

118

} while (0)

119

#define COPYMEM(x,nbytes) do { \

119

#define COPYMEM(x,nbytes) do { \

120

memcpy((x), p, nbytes); \

120

memcpy((x), p, nbytes); \

121

p += XDR_QUADLEN(nbytes); \

121

p += XDR_QUADLEN(nbytes); \

122

} while (0)

122

} while (0)

123

124

/* READ_BUF, read_buf(): nbytes must be <= PAGE_SIZE */

124

/* READ_BUF, read_buf(): nbytes must be <= PAGE_SIZE */

125

#define READ_BUF(nbytes) do { \

125

#define READ_BUF(nbytes) do { \

126

if (nbytes <= (u32)((char *)argp->end - (char *)argp->p)) { \

126

if (nbytes <= (u32)((char *)argp->end - (char *)argp->p)) { \

127

p = argp->p; \

127

p = argp->p; \

128

argp->p += XDR_QUADLEN(nbytes); \

128

argp->p += XDR_QUADLEN(nbytes); \

129

} else if (!(p = read_buf(argp, nbytes))) { \

129

} else if (!(p = read_buf(argp, nbytes))) { \

130

dprintk("NFSD: xdr error (%s:%d)\n", \

130

dprintk("NFSD: xdr error (%s:%d)\n", \

131

__FILE__, __LINE__); \

131

__FILE__, __LINE__); \

132

goto xdr_error; \

132

goto xdr_error; \

133

} \

133

} \

134

} while (0)

134

} while (0)

135

136

static __be32 *read_buf(struct nfsd4_compoundargs *argp, u32 nbytes)

136

static __be32 *read_buf(struct nfsd4_compoundargs *argp, u32 nbytes)

137

{

137

{

138

/* We want more bytes than seem to be available.

138

/* We want more bytes than seem to be available.

139

* Maybe we need a new page, maybe we have just run out

139

* Maybe we need a new page, maybe we have just run out

140

*/

140

*/

141

unsigned int avail = (char *)argp->end - (char *)argp->p;

141

unsigned int avail = (char *)argp->end - (char *)argp->p;

142

__be32 *p;

142

__be32 *p;

143

if (avail + argp->pagelen < nbytes)

143

if (avail + argp->pagelen < nbytes)

144

return NULL;

144

return NULL;

145

if (avail + PAGE_SIZE < nbytes) /* need more than a page !! */

145

if (avail + PAGE_SIZE < nbytes) /* need more than a page !! */

146

return NULL;

146

return NULL;

147

/* ok, we can do it with the current plus the next page */

147

/* ok, we can do it with the current plus the next page */

148

if (nbytes <= sizeof(argp->tmp))

148

if (nbytes <= sizeof(argp->tmp))

149

p = argp->tmp;

149

p = argp->tmp;

150

else {

150

else {

151

kfree(argp->tmpp);

151

kfree(argp->tmpp);

152

p = argp->tmpp = kmalloc(nbytes, GFP_KERNEL);

152

p = argp->tmpp = kmalloc(nbytes, GFP_KERNEL);

153

if (!p)

153

if (!p)

154

return NULL;

154

return NULL;

155

156

}

156

}

157

/*

157

/*

158

* The following memcpy is safe because read_buf is always

158

* The following memcpy is safe because read_buf is always

159

* called with nbytes > avail, and the two cases above both

159

* called with nbytes > avail, and the two cases above both

160

* guarantee p points to at least nbytes bytes.

160

* guarantee p points to at least nbytes bytes.

161

*/

161

*/

162

memcpy(p, argp->p, avail);

162

memcpy(p, argp->p, avail);

163

/* step to next page */

163

/* step to next page */

164

argp->p = page_address(argp->pagelist[0]);

164

argp->p = page_address(argp->pagelist[0]);

165

argp->pagelist++;

165

argp->pagelist++;

166

if (argp->pagelen < PAGE_SIZE) {

166

if (argp->pagelen < PAGE_SIZE) {

167

argp->end = argp->p + (argp->pagelen>>2);

167

argp->end = argp->p + (argp->pagelen>>2);

168

argp->pagelen = 0;

168

argp->pagelen = 0;

169

} else {

169

} else {

170

argp->end = argp->p + (PAGE_SIZE>>2);

170

argp->end = argp->p + (PAGE_SIZE>>2);

171

argp->pagelen -= PAGE_SIZE;

171

argp->pagelen -= PAGE_SIZE;

172

}

172

}

173

memcpy(((char*)p)+avail, argp->p, (nbytes - avail));

173

memcpy(((char*)p)+avail, argp->p, (nbytes - avail));

174

argp->p += XDR_QUADLEN(nbytes - avail);

174

argp->p += XDR_QUADLEN(nbytes - avail);

175

return p;

175

return p;

176

}

176

}

177

178

static int zero_clientid(clientid_t *clid)

178

static int zero_clientid(clientid_t *clid)

179

{

179

{

180

return (clid->cl_boot == 0) && (clid->cl_id == 0);

180

return (clid->cl_boot == 0) && (clid->cl_id == 0);

181

}

181

}

182

183

static int

183

static int

184

defer_free(struct nfsd4_compoundargs *argp,

184

defer_free(struct nfsd4_compoundargs *argp,

185

void (*release)(const void *), void *p)

185

void (*release)(const void *), void *p)

186

{

186

{

187

struct tmpbuf *tb;

187

struct tmpbuf *tb;

188

189

tb = kmalloc(sizeof(*tb), GFP_KERNEL);

189

tb = kmalloc(sizeof(*tb), GFP_KERNEL);

190

if (!tb)

190

if (!tb)

191

return -ENOMEM;

191

return -ENOMEM;

192

tb->buf = p;

192

tb->buf = p;

193

tb->release = release;

193

tb->release = release;

194

tb->next = argp->to_free;

194

tb->next = argp->to_free;

195

argp->to_free = tb;

195

argp->to_free = tb;

196

return 0;

196

return 0;

197

}

197

}

198

199

static char *savemem(struct nfsd4_compoundargs *argp, __be32 *p, int nbytes)

199

static char *savemem(struct nfsd4_compoundargs *argp, __be32 *p, int nbytes)

200

{

200

{

201

if (p == argp->tmp) {

201

if (p == argp->tmp) {

202

p = kmemdup(argp->tmp, nbytes, GFP_KERNEL);

202

p = kmemdup(argp->tmp, nbytes, GFP_KERNEL);

203

if (!p)

203

if (!p)

204

return NULL;

204

return NULL;

205

} else {

205

} else {

206

BUG_ON(p != argp->tmpp);

206

BUG_ON(p != argp->tmpp);

207

argp->tmpp = NULL;

207

argp->tmpp = NULL;

208

}

208

}

209

if (defer_free(argp, kfree, p)) {

209

if (defer_free(argp, kfree, p)) {

210

kfree(p);

210

kfree(p);

211

return NULL;

211

return NULL;

212

} else

212

} else

213

return (char *)p;

213

return (char *)p;

214

}

214

}

215

216

static __be32

216

static __be32

217

nfsd4_decode_bitmap(struct nfsd4_compoundargs *argp, u32 *bmval)

217

nfsd4_decode_bitmap(struct nfsd4_compoundargs *argp, u32 *bmval)

218

{

218

{

219

u32 bmlen;

219

u32 bmlen;

220

DECODE_HEAD;

220

DECODE_HEAD;

221

222

bmval[0] = 0;

222

bmval[0] = 0;

223

bmval[1] = 0;

223

bmval[1] = 0;

224

bmval[2] = 0;

224

bmval[2] = 0;

225

226

READ_BUF(4);

226

READ_BUF(4);

227

READ32(bmlen);

227

READ32(bmlen);

228

if (bmlen > 1000)

228

if (bmlen > 1000)

229

goto xdr_error;

229

goto xdr_error;

230

231

READ_BUF(bmlen << 2);

231

READ_BUF(bmlen << 2);

232

if (bmlen > 0)

232

if (bmlen > 0)

233

READ32(bmval[0]);

233

READ32(bmval[0]);

234

if (bmlen > 1)

234

if (bmlen > 1)

235

READ32(bmval[1]);

235

READ32(bmval[1]);

236

if (bmlen > 2)

236

if (bmlen > 2)

237

READ32(bmval[2]);

237

READ32(bmval[2]);

238

239

DECODE_TAIL;

239

DECODE_TAIL;

240

}

240

}

241

242

static __be32

242

static __be32

243

nfsd4_decode_fattr(struct nfsd4_compoundargs *argp, u32 *bmval,

243

nfsd4_decode_fattr(struct nfsd4_compoundargs *argp, u32 *bmval,

244

struct iattr *iattr, struct nfs4_acl **acl)

244

struct iattr *iattr, struct nfs4_acl **acl)

245

{

245

{

246

int expected_len, len = 0;

246

int expected_len, len = 0;

247

u32 dummy32;

247

u32 dummy32;

248

char *buf;

248

char *buf;

249

int host_err;

249

int host_err;

250

251

DECODE_HEAD;

251

DECODE_HEAD;

252

iattr->ia_valid = 0;

252

iattr->ia_valid = 0;

253

if ((status = nfsd4_decode_bitmap(argp, bmval)))

253

if ((status = nfsd4_decode_bitmap(argp, bmval)))

254

return status;

254

return status;

255

256

READ_BUF(4);

256

READ_BUF(4);

257

READ32(expected_len);

257

READ32(expected_len);

258

259

if (bmval[0] & FATTR4_WORD0_SIZE) {

259

if (bmval[0] & FATTR4_WORD0_SIZE) {

260

READ_BUF(8);

260

READ_BUF(8);

261

len += 8;

261

len += 8;

262

READ64(iattr->ia_size);

262

READ64(iattr->ia_size);

263

iattr->ia_valid |= ATTR_SIZE;

263

iattr->ia_valid |= ATTR_SIZE;

264

}

264

}

265

if (bmval[0] & FATTR4_WORD0_ACL) {

265

if (bmval[0] & FATTR4_WORD0_ACL) {

266

int nace;

266

int nace;

267

struct nfs4_ace *ace;

267

struct nfs4_ace *ace;

268

269

READ_BUF(4); len += 4;

269

READ_BUF(4); len += 4;

270

READ32(nace);

270

READ32(nace);

271

272

if (nace > NFS4_ACL_MAX)

272

if (nace > NFS4_ACL_MAX)

273

return nfserr_resource;

273

return nfserr_resource;

274

275

*acl = nfs4_acl_new(nace);

275

*acl = nfs4_acl_new(nace);

276

if (*acl == NULL) {

276

if (*acl == NULL) {

277

host_err = -ENOMEM;

277

host_err = -ENOMEM;

278

goto out_nfserr;

278

goto out_nfserr;

279

}

279

}

280

defer_free(argp, kfree, *acl);

280

defer_free(argp, kfree, *acl);

281

282

(*acl)->naces = nace;

282

(*acl)->naces = nace;

283

for (ace = (*acl)->aces; ace < (*acl)->aces + nace; ace++) {

283

for (ace = (*acl)->aces; ace < (*acl)->aces + nace; ace++) {

284

READ_BUF(16); len += 16;

284

READ_BUF(16); len += 16;

285

READ32(ace->type);

285

READ32(ace->type);

286

READ32(ace->flag);

286

READ32(ace->flag);

287

READ32(ace->access_mask);

287

READ32(ace->access_mask);

288

READ32(dummy32);

288

READ32(dummy32);

289

READ_BUF(dummy32);

289

READ_BUF(dummy32);

290

len += XDR_QUADLEN(dummy32) << 2;

290

len += XDR_QUADLEN(dummy32) << 2;

291

READMEM(buf, dummy32);

291

READMEM(buf, dummy32);

292

ace->whotype = nfs4_acl_get_whotype(buf, dummy32);

292

ace->whotype = nfs4_acl_get_whotype(buf, dummy32);

293

status = nfs_ok;

293

status = nfs_ok;

294

if (ace->whotype != NFS4_ACL_WHO_NAMED)

294

if (ace->whotype != NFS4_ACL_WHO_NAMED)

295

ace->who = 0;

295

ace->who = 0;

296

else if (ace->flag & NFS4_ACE_IDENTIFIER_GROUP)

296

else if (ace->flag & NFS4_ACE_IDENTIFIER_GROUP)

297

status = nfsd_map_name_to_gid(argp->rqstp,

297

status = nfsd_map_name_to_gid(argp->rqstp,

298

buf, dummy32, &ace->who);

298

buf, dummy32, &ace->who);

299

else

299

else

300

status = nfsd_map_name_to_uid(argp->rqstp,

300

status = nfsd_map_name_to_uid(argp->rqstp,

301

buf, dummy32, &ace->who);

301

buf, dummy32, &ace->who);

302

if (status)

302

if (status)

303

return status;

303

return status;

304

}

304

}

305

} else

305

} else

306

*acl = NULL;

306

*acl = NULL;

307

if (bmval[1] & FATTR4_WORD1_MODE) {

307

if (bmval[1] & FATTR4_WORD1_MODE) {

308

READ_BUF(4);

308

READ_BUF(4);

309

len += 4;

309

len += 4;

310

READ32(iattr->ia_mode);

310

READ32(iattr->ia_mode);

311

iattr->ia_mode &= (S_IFMT | S_IALLUGO);

311

iattr->ia_mode &= (S_IFMT | S_IALLUGO);

312

iattr->ia_valid |= ATTR_MODE;

312

iattr->ia_valid |= ATTR_MODE;

313

}

313

}

314

if (bmval[1] & FATTR4_WORD1_OWNER) {

314

if (bmval[1] & FATTR4_WORD1_OWNER) {

315

READ_BUF(4);

315

READ_BUF(4);

316

len += 4;

316

len += 4;

317

READ32(dummy32);

317

READ32(dummy32);

318

READ_BUF(dummy32);

318

READ_BUF(dummy32);

319

len += (XDR_QUADLEN(dummy32) << 2);

319

len += (XDR_QUADLEN(dummy32) << 2);

320

READMEM(buf, dummy32);

320

READMEM(buf, dummy32);

321

if ((status = nfsd_map_name_to_uid(argp->rqstp, buf, dummy32, &iattr->ia_uid)))

321

if ((status = nfsd_map_name_to_uid(argp->rqstp, buf, dummy32, &iattr->ia_uid)))

322

return status;

322

return status;

323

iattr->ia_valid |= ATTR_UID;

323

iattr->ia_valid |= ATTR_UID;

324

}

324

}

325

if (bmval[1] & FATTR4_WORD1_OWNER_GROUP) {

325

if (bmval[1] & FATTR4_WORD1_OWNER_GROUP) {

326

READ_BUF(4);

326

READ_BUF(4);

327

len += 4;

327

len += 4;

328

READ32(dummy32);

328

READ32(dummy32);

329

READ_BUF(dummy32);

329

READ_BUF(dummy32);

330

len += (XDR_QUADLEN(dummy32) << 2);

330

len += (XDR_QUADLEN(dummy32) << 2);

331

READMEM(buf, dummy32);

331

READMEM(buf, dummy32);

332

if ((status = nfsd_map_name_to_gid(argp->rqstp, buf, dummy32, &iattr->ia_gid)))

332

if ((status = nfsd_map_name_to_gid(argp->rqstp, buf, dummy32, &iattr->ia_gid)))

333

return status;

333

return status;

334

iattr->ia_valid |= ATTR_GID;

334

iattr->ia_valid |= ATTR_GID;

335

}

335

}

336

if (bmval[1] & FATTR4_WORD1_TIME_ACCESS_SET) {

336

if (bmval[1] & FATTR4_WORD1_TIME_ACCESS_SET) {

337

READ_BUF(4);

337

READ_BUF(4);

338

len += 4;

338

len += 4;

339

READ32(dummy32);

339

READ32(dummy32);

340

switch (dummy32) {

340

switch (dummy32) {

341

case NFS4_SET_TO_CLIENT_TIME:

341

case NFS4_SET_TO_CLIENT_TIME:

342

/* We require the high 32 bits of 'seconds' to be 0, and we ignore

342

/* We require the high 32 bits of 'seconds' to be 0, and we ignore

343

all 32 bits of 'nseconds'. */

343

all 32 bits of 'nseconds'. */

344

READ_BUF(12);

344

READ_BUF(12);

345

len += 12;

345

len += 12;

346

READ32(dummy32);

346

READ32(dummy32);

347

if (dummy32)

347

if (dummy32)

348

return nfserr_inval;

348

return nfserr_inval;

349

READ32(iattr->ia_atime.tv_sec);

349

READ32(iattr->ia_atime.tv_sec);

350

READ32(iattr->ia_atime.tv_nsec);

350

READ32(iattr->ia_atime.tv_nsec);

351

if (iattr->ia_atime.tv_nsec >= (u32)1000000000)

351

if (iattr->ia_atime.tv_nsec >= (u32)1000000000)

352

return nfserr_inval;

352

return nfserr_inval;

353

iattr->ia_valid |= (ATTR_ATIME | ATTR_ATIME_SET);

353

iattr->ia_valid |= (ATTR_ATIME | ATTR_ATIME_SET);

354

break;

354

break;

355

case NFS4_SET_TO_SERVER_TIME:

355

case NFS4_SET_TO_SERVER_TIME:

356

iattr->ia_valid |= ATTR_ATIME;

356

iattr->ia_valid |= ATTR_ATIME;

357

break;

357

break;

358

default:

358

default:

359

goto xdr_error;

359

goto xdr_error;

360

}

360

}

361

}

361

}

362

if (bmval[1] & FATTR4_WORD1_TIME_MODIFY_SET) {

362

if (bmval[1] & FATTR4_WORD1_TIME_MODIFY_SET) {

363

READ_BUF(4);

363

READ_BUF(4);

364

len += 4;

364

len += 4;

365

READ32(dummy32);

365

READ32(dummy32);

366

switch (dummy32) {

366

switch (dummy32) {

367

case NFS4_SET_TO_CLIENT_TIME:

367

case NFS4_SET_TO_CLIENT_TIME:

368

/* We require the high 32 bits of 'seconds' to be 0, and we ignore

368

/* We require the high 32 bits of 'seconds' to be 0, and we ignore

369

all 32 bits of 'nseconds'. */

369

all 32 bits of 'nseconds'. */

370

READ_BUF(12);

370

READ_BUF(12);

371

len += 12;

371

len += 12;

372

READ32(dummy32);

372

READ32(dummy32);

373

if (dummy32)

373

if (dummy32)

374

return nfserr_inval;

374

return nfserr_inval;

375

READ32(iattr->ia_mtime.tv_sec);

375

READ32(iattr->ia_mtime.tv_sec);

376

READ32(iattr->ia_mtime.tv_nsec);

376

READ32(iattr->ia_mtime.tv_nsec);

377

if (iattr->ia_mtime.tv_nsec >= (u32)1000000000)

377

if (iattr->ia_mtime.tv_nsec >= (u32)1000000000)

378

return nfserr_inval;

378

return nfserr_inval;

379

iattr->ia_valid |= (ATTR_MTIME | ATTR_MTIME_SET);

379

iattr->ia_valid |= (ATTR_MTIME | ATTR_MTIME_SET);

380

break;

380

break;

381

case NFS4_SET_TO_SERVER_TIME:

381

case NFS4_SET_TO_SERVER_TIME:

382

iattr->ia_valid |= ATTR_MTIME;

382

iattr->ia_valid |= ATTR_MTIME;

383

break;

383

break;

384

default:

384

default:

385

goto xdr_error;

385

goto xdr_error;

386

}

386

}

387

}

387

}

388

if (bmval[0] & ~NFSD_WRITEABLE_ATTRS_WORD0

388

if (bmval[0] & ~NFSD_WRITEABLE_ATTRS_WORD0

389

|| bmval[1] & ~NFSD_WRITEABLE_ATTRS_WORD1

389

|| bmval[1] & ~NFSD_WRITEABLE_ATTRS_WORD1

390

|| bmval[2] & ~NFSD_WRITEABLE_ATTRS_WORD2)

390

|| bmval[2] & ~NFSD_WRITEABLE_ATTRS_WORD2)

391

READ_BUF(expected_len - len);

391

READ_BUF(expected_len - len);

392

else if (len != expected_len)

392

else if (len != expected_len)

393

goto xdr_error;

393

goto xdr_error;

394

395

DECODE_TAIL;

395

DECODE_TAIL;

396

397

out_nfserr:

397

out_nfserr:

398

status = nfserrno(host_err);

398

status = nfserrno(host_err);

399

goto out;

399

goto out;

400

}

400

}

401

402

static __be32

402

static __be32

403

nfsd4_decode_stateid(struct nfsd4_compoundargs *argp, stateid_t *sid)

403

nfsd4_decode_stateid(struct nfsd4_compoundargs *argp, stateid_t *sid)

404

{

404

{

405

DECODE_HEAD;

405

DECODE_HEAD;

406

407

READ_BUF(sizeof(stateid_t));

407

READ_BUF(sizeof(stateid_t));

408

READ32(sid->si_generation);

408

READ32(sid->si_generation);

409

COPYMEM(&sid->si_opaque, sizeof(stateid_opaque_t));

409

COPYMEM(&sid->si_opaque, sizeof(stateid_opaque_t));

410

411

DECODE_TAIL;

411

DECODE_TAIL;

412

}

412

}

413

414

static __be32

414

static __be32

415

nfsd4_decode_access(struct nfsd4_compoundargs *argp, struct nfsd4_access *access)

415

nfsd4_decode_access(struct nfsd4_compoundargs *argp, struct nfsd4_access *access)

416

{

416

{

417

DECODE_HEAD;

417

DECODE_HEAD;

418

419

READ_BUF(4);

419

READ_BUF(4);

420

READ32(access->ac_req_access);

420

READ32(access->ac_req_access);

421

422

DECODE_TAIL;

422

DECODE_TAIL;

423

}

423

}

424

425

static __be32 nfsd4_decode_cb_sec(struct nfsd4_compoundargs *argp, struct nfsd4_cb_sec *cbs)

425

static __be32 nfsd4_decode_cb_sec(struct nfsd4_compoundargs *argp, struct nfsd4_cb_sec *cbs)

426

{

426

{

427

DECODE_HEAD;

427

DECODE_HEAD;

428

u32 dummy, uid, gid;

428

u32 dummy, uid, gid;

429

char *machine_name;

429

char *machine_name;

430

int i;

430

int i;

431

int nr_secflavs;

431

int nr_secflavs;

432

433

/* callback_sec_params4 */

433

/* callback_sec_params4 */

434

READ_BUF(4);

434

READ_BUF(4);

435

READ32(nr_secflavs);

435

READ32(nr_secflavs);

436

cbs->flavor = (u32)(-1);

436

cbs->flavor = (u32)(-1);

437

for (i = 0; i < nr_secflavs; ++i) {

437

for (i = 0; i < nr_secflavs; ++i) {

438

READ_BUF(4);

438

READ_BUF(4);

439

READ32(dummy);

439

READ32(dummy);

440

switch (dummy) {

440

switch (dummy) {

441

case RPC_AUTH_NULL:

441

case RPC_AUTH_NULL:

442

/* Nothing to read */

442

/* Nothing to read */

443

if (cbs->flavor == (u32)(-1))

443

if (cbs->flavor == (u32)(-1))

444

cbs->flavor = RPC_AUTH_NULL;

444

cbs->flavor = RPC_AUTH_NULL;

445

break;

445

break;

446

case RPC_AUTH_UNIX:

446

case RPC_AUTH_UNIX:

447

READ_BUF(8);

447

READ_BUF(8);

448

/* stamp */

448

/* stamp */

449

READ32(dummy);

449

READ32(dummy);

450

451

/* machine name */

451

/* machine name */

452

READ32(dummy);

452

READ32(dummy);

453

READ_BUF(dummy);

453

READ_BUF(dummy);

454

SAVEMEM(machine_name, dummy);

454

SAVEMEM(machine_name, dummy);

455

456

/* uid, gid */

456

/* uid, gid */

457

READ_BUF(8);

457

READ_BUF(8);

458

READ32(uid);

458

READ32(uid);

459

READ32(gid);

459

READ32(gid);

460

461

/* more gids */

461

/* more gids */

462

READ_BUF(4);

462

READ_BUF(4);

463

READ32(dummy);

463

READ32(dummy);

464

READ_BUF(dummy * 4);

464

READ_BUF(dummy * 4);

465

if (cbs->flavor == (u32)(-1)) {

465

if (cbs->flavor == (u32)(-1)) {

466

cbs->uid = uid;

466

cbs->uid = uid;

467

cbs->gid = gid;

467

cbs->gid = gid;

468

cbs->flavor = RPC_AUTH_UNIX;

468

cbs->flavor = RPC_AUTH_UNIX;

469

}

469

}

470

break;

470

break;

471

case RPC_AUTH_GSS:

471

case RPC_AUTH_GSS:

472

dprintk("RPC_AUTH_GSS callback secflavor "

472

dprintk("RPC_AUTH_GSS callback secflavor "

473

"not supported!\n");

473

"not supported!\n");

474

READ_BUF(8);

474

READ_BUF(8);

475

/* gcbp_service */

475

/* gcbp_service */

476

READ32(dummy);

476

READ32(dummy);

477

/* gcbp_handle_from_server */

477

/* gcbp_handle_from_server */

478

READ32(dummy);

478

READ32(dummy);

479

READ_BUF(dummy);

479

READ_BUF(dummy);

480

p += XDR_QUADLEN(dummy);

480

p += XDR_QUADLEN(dummy);

481

/* gcbp_handle_from_client */

481

/* gcbp_handle_from_client */

482

READ_BUF(4);

482

READ_BUF(4);

483

READ32(dummy);

483

READ32(dummy);

484

READ_BUF(dummy);

484

READ_BUF(dummy);

485

break;

485

break;

486

default:

486

default:

487

dprintk("Illegal callback secflavor\n");

487

dprintk("Illegal callback secflavor\n");

488

return nfserr_inval;

488

return nfserr_inval;

489

}

489

}

490

}

490

}

491

DECODE_TAIL;

491

DECODE_TAIL;

492

}

492

}

493

494

static __be32 nfsd4_decode_backchannel_ctl(struct nfsd4_compoundargs *argp, struct nfsd4_backchannel_ctl *bc)

494

static __be32 nfsd4_decode_backchannel_ctl(struct nfsd4_compoundargs *argp, struct nfsd4_backchannel_ctl *bc)

495

{

495

{

496

DECODE_HEAD;

496

DECODE_HEAD;

497

498

READ_BUF(4);

498

READ_BUF(4);

499

READ32(bc->bc_cb_program);

499

READ32(bc->bc_cb_program);

500

nfsd4_decode_cb_sec(argp, &bc->bc_cb_sec);

500

nfsd4_decode_cb_sec(argp, &bc->bc_cb_sec);

501

502

DECODE_TAIL;

502

DECODE_TAIL;

503

}

503

}

504

505

static __be32 nfsd4_decode_bind_conn_to_session(struct nfsd4_compoundargs *argp, struct nfsd4_bind_conn_to_session *bcts)

505

static __be32 nfsd4_decode_bind_conn_to_session(struct nfsd4_compoundargs *argp, struct nfsd4_bind_conn_to_session *bcts)

506

{

506

{

507

DECODE_HEAD;

507

DECODE_HEAD;

508

509

READ_BUF(NFS4_MAX_SESSIONID_LEN + 8);

509

READ_BUF(NFS4_MAX_SESSIONID_LEN + 8);

510

COPYMEM(bcts->sessionid.data, NFS4_MAX_SESSIONID_LEN);

510

COPYMEM(bcts->sessionid.data, NFS4_MAX_SESSIONID_LEN);

511

READ32(bcts->dir);

511

READ32(bcts->dir);

512

/* XXX: skipping ctsa_use_conn_in_rdma_mode. Perhaps Tom Tucker

512

/* XXX: skipping ctsa_use_conn_in_rdma_mode. Perhaps Tom Tucker

513

* could help us figure out we should be using it. */

513

* could help us figure out we should be using it. */

514

DECODE_TAIL;

514

DECODE_TAIL;

515

}

515

}

516

517

static __be32

517

static __be32

518

nfsd4_decode_close(struct nfsd4_compoundargs *argp, struct nfsd4_close *close)

518

nfsd4_decode_close(struct nfsd4_compoundargs *argp, struct nfsd4_close *close)

519

{

519

{

520

DECODE_HEAD;

520

DECODE_HEAD;

521

522

READ_BUF(4);

522

READ_BUF(4);

523

READ32(close->cl_seqid);

523

READ32(close->cl_seqid);

524

return nfsd4_decode_stateid(argp, &close->cl_stateid);

524

return nfsd4_decode_stateid(argp, &close->cl_stateid);

525

526

DECODE_TAIL;

526

DECODE_TAIL;

527

}

527

}

528

529

530

static __be32

530

static __be32

531

nfsd4_decode_commit(struct nfsd4_compoundargs *argp, struct nfsd4_commit *commit)

531

nfsd4_decode_commit(struct nfsd4_compoundargs *argp, struct nfsd4_commit *commit)

532

{

532

{

533

DECODE_HEAD;

533

DECODE_HEAD;

534

535

READ_BUF(12);

535

READ_BUF(12);

536

READ64(commit->co_offset);

536

READ64(commit->co_offset);

537

READ32(commit->co_count);

537

READ32(commit->co_count);

538

539

DECODE_TAIL;

539

DECODE_TAIL;

540

}

540

}

541

542

static __be32

542

static __be32

543

nfsd4_decode_create(struct nfsd4_compoundargs *argp, struct nfsd4_create *create)

543

nfsd4_decode_create(struct nfsd4_compoundargs *argp, struct nfsd4_create *create)

544

{

544

{

545

DECODE_HEAD;

545

DECODE_HEAD;

546

547

READ_BUF(4);

547

READ_BUF(4);

548

READ32(create->cr_type);

548

READ32(create->cr_type);

549

switch (create->cr_type) {

549

switch (create->cr_type) {

550

case NF4LNK:

550

case NF4LNK:

551

READ_BUF(4);

551

READ_BUF(4);

552

READ32(create->cr_linklen);

552

READ32(create->cr_linklen);

553

READ_BUF(create->cr_linklen);

553

READ_BUF(create->cr_linklen);

554

SAVEMEM(create->cr_linkname, create->cr_linklen);

554

SAVEMEM(create->cr_linkname, create->cr_linklen);

555

break;

555

break;

556

case NF4BLK:

556

case NF4BLK:

557

case NF4CHR:

557

case NF4CHR:

558

READ_BUF(8);

558

READ_BUF(8);

559

READ32(create->cr_specdata1);

559

READ32(create->cr_specdata1);

560

READ32(create->cr_specdata2);

560

READ32(create->cr_specdata2);

561

break;

561

break;

562

case NF4SOCK:

562

case NF4SOCK:

563

case NF4FIFO:

563

case NF4FIFO:

564

case NF4DIR:

564

case NF4DIR:

565

default:

565

default:

566

break;

566

break;

567

}

567

}

568

569

READ_BUF(4);

569

READ_BUF(4);

570

READ32(create->cr_namelen);

570

READ32(create->cr_namelen);

571

READ_BUF(create->cr_namelen);

571

READ_BUF(create->cr_namelen);

572

SAVEMEM(create->cr_name, create->cr_namelen);

572

SAVEMEM(create->cr_name, create->cr_namelen);

573

if ((status = check_filename(create->cr_name, create->cr_namelen, nfserr_inval)))

573

if ((status = check_filename(create->cr_name, create->cr_namelen, nfserr_inval)))

574

return status;

574

return status;

575

576

status = nfsd4_decode_fattr(argp, create->cr_bmval, &create->cr_iattr,

576

status = nfsd4_decode_fattr(argp, create->cr_bmval, &create->cr_iattr,

577

&create->cr_acl);

577

&create->cr_acl);

578

if (status)

578

if (status)

579

goto out;

579

goto out;

580

581

DECODE_TAIL;

581

DECODE_TAIL;

582

}

582

}

583

584

static inline __be32

584

static inline __be32

585

nfsd4_decode_delegreturn(struct nfsd4_compoundargs *argp, struct nfsd4_delegreturn *dr)

585

nfsd4_decode_delegreturn(struct nfsd4_compoundargs *argp, struct nfsd4_delegreturn *dr)

586

{

586

{

587

return nfsd4_decode_stateid(argp, &dr->dr_stateid);

587

return nfsd4_decode_stateid(argp, &dr->dr_stateid);

588

}

588

}

589

590

static inline __be32

590

static inline __be32

591

nfsd4_decode_getattr(struct nfsd4_compoundargs *argp, struct nfsd4_getattr *getattr)

591

nfsd4_decode_getattr(struct nfsd4_compoundargs *argp, struct nfsd4_getattr *getattr)

592

{

592

{

593

return nfsd4_decode_bitmap(argp, getattr->ga_bmval);

593

return nfsd4_decode_bitmap(argp, getattr->ga_bmval);

594

}

594

}

595

596

static __be32

596

static __be32

597

nfsd4_decode_link(struct nfsd4_compoundargs *argp, struct nfsd4_link *link)

597

nfsd4_decode_link(struct nfsd4_compoundargs *argp, struct nfsd4_link *link)

598

{

598

{

599

DECODE_HEAD;

599

DECODE_HEAD;

600

601

READ_BUF(4);

601

READ_BUF(4);

602

READ32(link->li_namelen);

602

READ32(link->li_namelen);

603

READ_BUF(link->li_namelen);

603

READ_BUF(link->li_namelen);

604

SAVEMEM(link->li_name, link->li_namelen);

604

SAVEMEM(link->li_name, link->li_namelen);

605

if ((status = check_filename(link->li_name, link->li_namelen, nfserr_inval)))

605

if ((status = check_filename(link->li_name, link->li_namelen, nfserr_inval)))

606

return status;

606

return status;

607

608

DECODE_TAIL;

608

DECODE_TAIL;

609

}

609

}

610

611

static __be32

611

static __be32

612

nfsd4_decode_lock(struct nfsd4_compoundargs *argp, struct nfsd4_lock *lock)

612

nfsd4_decode_lock(struct nfsd4_compoundargs *argp, struct nfsd4_lock *lock)

613

{

613

{

614

DECODE_HEAD;

614

DECODE_HEAD;

615

616

/*

616

/*

617

* type, reclaim(boolean), offset, length, new_lock_owner(boolean)

617

* type, reclaim(boolean), offset, length, new_lock_owner(boolean)

618

*/

618

*/

619

READ_BUF(28);

619

READ_BUF(28);

620

READ32(lock->lk_type);

620

READ32(lock->lk_type);

621

if ((lock->lk_type < NFS4_READ_LT) || (lock->lk_type > NFS4_WRITEW_LT))

621

if ((lock->lk_type < NFS4_READ_LT) || (lock->lk_type > NFS4_WRITEW_LT))

622

goto xdr_error;

622

goto xdr_error;

623

READ32(lock->lk_reclaim);

623

READ32(lock->lk_reclaim);

624

READ64(lock->lk_offset);

624

READ64(lock->lk_offset);

625

READ64(lock->lk_length);

625

READ64(lock->lk_length);

626

READ32(lock->lk_is_new);

626

READ32(lock->lk_is_new);

627

628

if (lock->lk_is_new) {

628

if (lock->lk_is_new) {

629

READ_BUF(4);

629

READ_BUF(4);

630

READ32(lock->lk_new_open_seqid);

630

READ32(lock->lk_new_open_seqid);

631

status = nfsd4_decode_stateid(argp, &lock->lk_new_open_stateid);

631

status = nfsd4_decode_stateid(argp, &lock->lk_new_open_stateid);

632

if (status)

632

if (status)

633

return status;

633

return status;

634

READ_BUF(8 + sizeof(clientid_t));

634

READ_BUF(8 + sizeof(clientid_t));

635

READ32(lock->lk_new_lock_seqid);

635

READ32(lock->lk_new_lock_seqid);

636

COPYMEM(&lock->lk_new_clientid, sizeof(clientid_t));

636

COPYMEM(&lock->lk_new_clientid, sizeof(clientid_t));

637

READ32(lock->lk_new_owner.len);

637

READ32(lock->lk_new_owner.len);

638

READ_BUF(lock->lk_new_owner.len);

638

READ_BUF(lock->lk_new_owner.len);

639

READMEM(lock->lk_new_owner.data, lock->lk_new_owner.len);

639

READMEM(lock->lk_new_owner.data, lock->lk_new_owner.len);

640

} else {

640

} else {

641

status = nfsd4_decode_stateid(argp, &lock->lk_old_lock_stateid);

641

status = nfsd4_decode_stateid(argp, &lock->lk_old_lock_stateid);

642

if (status)

642

if (status)

643

return status;

643

return status;

644

READ_BUF(4);

644

READ_BUF(4);

645

READ32(lock->lk_old_lock_seqid);

645

READ32(lock->lk_old_lock_seqid);

646

}

646

}

647

648

DECODE_TAIL;

648

DECODE_TAIL;

649

}

649

}

650

651

static __be32

651

static __be32

652

nfsd4_decode_lockt(struct nfsd4_compoundargs *argp, struct nfsd4_lockt *lockt)

652

nfsd4_decode_lockt(struct nfsd4_compoundargs *argp, struct nfsd4_lockt *lockt)

653

{

653

{

654

DECODE_HEAD;

654

DECODE_HEAD;

655

656

READ_BUF(32);

656

READ_BUF(32);

657

READ32(lockt->lt_type);

657

READ32(lockt->lt_type);

658

if((lockt->lt_type < NFS4_READ_LT) || (lockt->lt_type > NFS4_WRITEW_LT))

658

if((lockt->lt_type < NFS4_READ_LT) || (lockt->lt_type > NFS4_WRITEW_LT))

659

goto xdr_error;

659

goto xdr_error;

660

READ64(lockt->lt_offset);

660

READ64(lockt->lt_offset);

661

READ64(lockt->lt_length);

661

READ64(lockt->lt_length);

662

COPYMEM(&lockt->lt_clientid, 8);

662

COPYMEM(&lockt->lt_clientid, 8);

663

READ32(lockt->lt_owner.len);

663

READ32(lockt->lt_owner.len);

664

READ_BUF(lockt->lt_owner.len);

664

READ_BUF(lockt->lt_owner.len);

665

READMEM(lockt->lt_owner.data, lockt->lt_owner.len);

665

READMEM(lockt->lt_owner.data, lockt->lt_owner.len);

666

667

DECODE_TAIL;

667

DECODE_TAIL;

668

}

668

}

669

670

static __be32

670

static __be32

671

nfsd4_decode_locku(struct nfsd4_compoundargs *argp, struct nfsd4_locku *locku)

671

nfsd4_decode_locku(struct nfsd4_compoundargs *argp, struct nfsd4_locku *locku)

672

{

672

{

673

DECODE_HEAD;

673

DECODE_HEAD;

674

675

READ_BUF(8);

675

READ_BUF(8);

676

READ32(locku->lu_type);

676

READ32(locku->lu_type);

677

if ((locku->lu_type < NFS4_READ_LT) || (locku->lu_type > NFS4_WRITEW_LT))

677

if ((locku->lu_type < NFS4_READ_LT) || (locku->lu_type > NFS4_WRITEW_LT))

678

goto xdr_error;

678

goto xdr_error;

679

READ32(locku->lu_seqid);

679

READ32(locku->lu_seqid);

680

status = nfsd4_decode_stateid(argp, &locku->lu_stateid);

680

status = nfsd4_decode_stateid(argp, &locku->lu_stateid);

681

if (status)

681

if (status)

682

return status;

682

return status;

683

READ_BUF(16);

683

READ_BUF(16);

684

READ64(locku->lu_offset);

684

READ64(locku->lu_offset);

685

READ64(locku->lu_length);

685

READ64(locku->lu_length);

686

687

DECODE_TAIL;

687

DECODE_TAIL;

688

}

688

}

689

690

static __be32

690

static __be32

691

nfsd4_decode_lookup(struct nfsd4_compoundargs *argp, struct nfsd4_lookup *lookup)

691

nfsd4_decode_lookup(struct nfsd4_compoundargs *argp, struct nfsd4_lookup *lookup)

692

{

692

{

693

DECODE_HEAD;

693

DECODE_HEAD;

694

695

READ_BUF(4);

695

READ_BUF(4);

696

READ32(lookup->lo_len);

696

READ32(lookup->lo_len);

697

READ_BUF(lookup->lo_len);

697

READ_BUF(lookup->lo_len);

698

SAVEMEM(lookup->lo_name, lookup->lo_len);

698

SAVEMEM(lookup->lo_name, lookup->lo_len);

699

if ((status = check_filename(lookup->lo_name, lookup->lo_len, nfserr_noent)))

699

if ((status = check_filename(lookup->lo_name, lookup->lo_len, nfserr_noent)))

700

return status;

700

return status;

701

702

DECODE_TAIL;

702

DECODE_TAIL;

703

}

703

}

704

705

static __be32 nfsd4_decode_share_access(struct nfsd4_compoundargs *argp, u32 *share_access, u32 *deleg_want, u32 *deleg_when)

705

static __be32 nfsd4_decode_share_access(struct nfsd4_compoundargs *argp, u32 *share_access, u32 *deleg_want, u32 *deleg_when)

706

{

706

{

707

__be32 *p;

707

__be32 *p;

708

u32 w;

708

u32 w;

709

710

READ_BUF(4);

710

READ_BUF(4);

711

READ32(w);

711

READ32(w);

712

*share_access = w & NFS4_SHARE_ACCESS_MASK;

712

*share_access = w & NFS4_SHARE_ACCESS_MASK;

713

*deleg_want = w & NFS4_SHARE_WANT_MASK;

713

*deleg_want = w & NFS4_SHARE_WANT_MASK;

714

if (deleg_when)

714

if (deleg_when)

715

*deleg_when = w & NFS4_SHARE_WHEN_MASK;

715

*deleg_when = w & NFS4_SHARE_WHEN_MASK;

716

717

switch (w & NFS4_SHARE_ACCESS_MASK) {

717

switch (w & NFS4_SHARE_ACCESS_MASK) {

718

case NFS4_SHARE_ACCESS_READ:

718

case NFS4_SHARE_ACCESS_READ:

719

case NFS4_SHARE_ACCESS_WRITE:

719

case NFS4_SHARE_ACCESS_WRITE:

720

case NFS4_SHARE_ACCESS_BOTH:

720

case NFS4_SHARE_ACCESS_BOTH:

721

break;

721

break;

722

default:

722

default:

723

return nfserr_bad_xdr;

723

return nfserr_bad_xdr;

724

}

724

}

725

w &= ~NFS4_SHARE_ACCESS_MASK;

725

w &= ~NFS4_SHARE_ACCESS_MASK;

726

if (!w)

726

if (!w)

727

return nfs_ok;

727

return nfs_ok;

728

if (!argp->minorversion)

728

if (!argp->minorversion)

729

return nfserr_bad_xdr;

729

return nfserr_bad_xdr;

730

switch (w & NFS4_SHARE_WANT_MASK) {

730

switch (w & NFS4_SHARE_WANT_MASK) {

731

case NFS4_SHARE_WANT_NO_PREFERENCE:

731

case NFS4_SHARE_WANT_NO_PREFERENCE:

732

case NFS4_SHARE_WANT_READ_DELEG:

732

case NFS4_SHARE_WANT_READ_DELEG:

733

case NFS4_SHARE_WANT_WRITE_DELEG:

733

case NFS4_SHARE_WANT_WRITE_DELEG:

734

case NFS4_SHARE_WANT_ANY_DELEG:

734

case NFS4_SHARE_WANT_ANY_DELEG:

735

case NFS4_SHARE_WANT_NO_DELEG:

735

case NFS4_SHARE_WANT_NO_DELEG:

736

case NFS4_SHARE_WANT_CANCEL:

736

case NFS4_SHARE_WANT_CANCEL:

737

break;

737

break;

738

default:

738

default:

739

return nfserr_bad_xdr;

739

return nfserr_bad_xdr;

740

}

740

}

741

w &= ~NFS4_SHARE_WANT_MASK;

741

w &= ~NFS4_SHARE_WANT_MASK;

742

if (!w)

742

if (!w)

743

return nfs_ok;

743

return nfs_ok;

744

745

if (!deleg_when) /* open_downgrade */

745

if (!deleg_when) /* open_downgrade */

746

return nfserr_inval;

746

return nfserr_inval;

747

switch (w) {

747

switch (w) {

748

case NFS4_SHARE_SIGNAL_DELEG_WHEN_RESRC_AVAIL:

748

case NFS4_SHARE_SIGNAL_DELEG_WHEN_RESRC_AVAIL:

749

case NFS4_SHARE_PUSH_DELEG_WHEN_UNCONTENDED:

749

case NFS4_SHARE_PUSH_DELEG_WHEN_UNCONTENDED:

750

case (NFS4_SHARE_SIGNAL_DELEG_WHEN_RESRC_AVAIL |

750

case (NFS4_SHARE_SIGNAL_DELEG_WHEN_RESRC_AVAIL |

751

NFS4_SHARE_PUSH_DELEG_WHEN_UNCONTENDED):

751

NFS4_SHARE_PUSH_DELEG_WHEN_UNCONTENDED):

752

return nfs_ok;

752

return nfs_ok;

753

}

753

}

754

xdr_error:

754

xdr_error:

755

return nfserr_bad_xdr;

755

return nfserr_bad_xdr;

756

}

756

}

757

758

static __be32 nfsd4_decode_share_deny(struct nfsd4_compoundargs *argp, u32 *x)

758

static __be32 nfsd4_decode_share_deny(struct nfsd4_compoundargs *argp, u32 *x)

759

{

759

{

760

__be32 *p;

760

__be32 *p;

761

762

READ_BUF(4);

762

READ_BUF(4);

763

READ32(*x);

763

READ32(*x);

764

/* Note: unlinke access bits, deny bits may be zero. */

764

/* Note: unlinke access bits, deny bits may be zero. */

765

if (*x & ~NFS4_SHARE_DENY_BOTH)

765

if (*x & ~NFS4_SHARE_DENY_BOTH)

766

return nfserr_bad_xdr;

766

return nfserr_bad_xdr;

767

return nfs_ok;

767

return nfs_ok;

768

xdr_error:

768

xdr_error:

769

return nfserr_bad_xdr;

769

return nfserr_bad_xdr;

770

}

770

}

771

772

static __be32 nfsd4_decode_opaque(struct nfsd4_compoundargs *argp, struct xdr_netobj *o)

772

static __be32 nfsd4_decode_opaque(struct nfsd4_compoundargs *argp, struct xdr_netobj *o)

773

{

773

{

774

__be32 *p;

774

__be32 *p;

775

776

READ_BUF(4);

776

READ_BUF(4);

777

READ32(o->len);

777

READ32(o->len);

778

779

if (o->len == 0 || o->len > NFS4_OPAQUE_LIMIT)

779

if (o->len == 0 || o->len > NFS4_OPAQUE_LIMIT)

780

return nfserr_bad_xdr;

780

return nfserr_bad_xdr;

781

782

READ_BUF(o->len);

782

READ_BUF(o->len);

783

SAVEMEM(o->data, o->len);

783

SAVEMEM(o->data, o->len);

784

return nfs_ok;

784

return nfs_ok;

785

xdr_error:

785

xdr_error:

786

return nfserr_bad_xdr;

786

return nfserr_bad_xdr;

787

}

787

}

788

789

static __be32

789

static __be32

790

nfsd4_decode_open(struct nfsd4_compoundargs *argp, struct nfsd4_open *open)

790

nfsd4_decode_open(struct nfsd4_compoundargs *argp, struct nfsd4_open *open)

791

{

791

{

792

DECODE_HEAD;

792

DECODE_HEAD;

793

u32 dummy;

793

u32 dummy;

794

795

memset(open->op_bmval, 0, sizeof(open->op_bmval));

795

memset(open->op_bmval, 0, sizeof(open->op_bmval));

796

open->op_iattr.ia_valid = 0;

796

open->op_iattr.ia_valid = 0;

797

open->op_openowner = NULL;

797

open->op_openowner = NULL;

798

799

/* seqid, share_access, share_deny, clientid, ownerlen */

799

/* seqid, share_access, share_deny, clientid, ownerlen */

800

READ_BUF(4);

800

READ_BUF(4);

801

READ32(open->op_seqid);

801

READ32(open->op_seqid);

802

/* decode, yet ignore deleg_when until supported */

802

/* decode, yet ignore deleg_when until supported */

803

status = nfsd4_decode_share_access(argp, &open->op_share_access,

803

status = nfsd4_decode_share_access(argp, &open->op_share_access,

804

&open->op_deleg_want, &dummy);

804

&open->op_deleg_want, &dummy);

805

if (status)

805

if (status)

806

goto xdr_error;

806

goto xdr_error;

807

status = nfsd4_decode_share_deny(argp, &open->op_share_deny);

807

status = nfsd4_decode_share_deny(argp, &open->op_share_deny);

808

if (status)

808

if (status)

809

goto xdr_error;

809

goto xdr_error;

810

READ_BUF(sizeof(clientid_t));

810

READ_BUF(sizeof(clientid_t));

811

COPYMEM(&open->op_clientid, sizeof(clientid_t));

811

COPYMEM(&open->op_clientid, sizeof(clientid_t));

812

status = nfsd4_decode_opaque(argp, &open->op_owner);

812

status = nfsd4_decode_opaque(argp, &open->op_owner);

813

if (status)

813

if (status)

814

goto xdr_error;

814

goto xdr_error;

815

READ_BUF(4);

815

READ_BUF(4);

816

READ32(open->op_create);

816

READ32(open->op_create);

817

switch (open->op_create) {

817

switch (open->op_create) {

818

case NFS4_OPEN_NOCREATE:

818

case NFS4_OPEN_NOCREATE:

819

break;

819

break;

820

case NFS4_OPEN_CREATE:

820

case NFS4_OPEN_CREATE:

821

READ_BUF(4);

821

READ_BUF(4);

822

READ32(open->op_createmode);

822

READ32(open->op_createmode);

823

switch (open->op_createmode) {

823

switch (open->op_createmode) {

824

case NFS4_CREATE_UNCHECKED:

824

case NFS4_CREATE_UNCHECKED:

825

case NFS4_CREATE_GUARDED:

825

case NFS4_CREATE_GUARDED:

826

status = nfsd4_decode_fattr(argp, open->op_bmval,

826

status = nfsd4_decode_fattr(argp, open->op_bmval,

827

&open->op_iattr, &open->op_acl);

827

&open->op_iattr, &open->op_acl);

828

if (status)

828

if (status)

829

goto out;

829

goto out;

830

break;

830

break;

831

case NFS4_CREATE_EXCLUSIVE:

831

case NFS4_CREATE_EXCLUSIVE:

832

READ_BUF(NFS4_VERIFIER_SIZE);

832

READ_BUF(NFS4_VERIFIER_SIZE);

833

COPYMEM(open->op_verf.data, NFS4_VERIFIER_SIZE);

833

COPYMEM(open->op_verf.data, NFS4_VERIFIER_SIZE);

834

break;

834

break;

835

case NFS4_CREATE_EXCLUSIVE4_1:

835

case NFS4_CREATE_EXCLUSIVE4_1:

836

if (argp->minorversion < 1)

836

if (argp->minorversion < 1)

837

goto xdr_error;

837

goto xdr_error;

838

READ_BUF(NFS4_VERIFIER_SIZE);

838

READ_BUF(NFS4_VERIFIER_SIZE);

839

COPYMEM(open->op_verf.data, NFS4_VERIFIER_SIZE);

839

COPYMEM(open->op_verf.data, NFS4_VERIFIER_SIZE);

840

status = nfsd4_decode_fattr(argp, open->op_bmval,

840

status = nfsd4_decode_fattr(argp, open->op_bmval,

841

&open->op_iattr, &open->op_acl);

841

&open->op_iattr, &open->op_acl);

842

if (status)

842

if (status)

843

goto out;

843

goto out;

844

break;

844

break;

845

default:

845

default:

846

goto xdr_error;

846

goto xdr_error;

847

}

847

}

848

break;

848

break;

849

default:

849

default:

850

goto xdr_error;

850

goto xdr_error;

851

}

851

}

852

853

/* open_claim */

853

/* open_claim */

854

READ_BUF(4);

854

READ_BUF(4);

855

READ32(open->op_claim_type);

855

READ32(open->op_claim_type);

856

switch (open->op_claim_type) {

856

switch (open->op_claim_type) {

857

case NFS4_OPEN_CLAIM_NULL:

857

case NFS4_OPEN_CLAIM_NULL:

858

case NFS4_OPEN_CLAIM_DELEGATE_PREV:

858

case NFS4_OPEN_CLAIM_DELEGATE_PREV:

859

READ_BUF(4);

859

READ_BUF(4);

860

READ32(open->op_fname.len);

860

READ32(open->op_fname.len);

861

READ_BUF(open->op_fname.len);

861

READ_BUF(open->op_fname.len);

862

SAVEMEM(open->op_fname.data, open->op_fname.len);

862

SAVEMEM(open->op_fname.data, open->op_fname.len);

863

if ((status = check_filename(open->op_fname.data, open->op_fname.len, nfserr_inval)))

863

if ((status = check_filename(open->op_fname.data, open->op_fname.len, nfserr_inval)))

864

return status;

864

return status;

865

break;

865

break;

866

case NFS4_OPEN_CLAIM_PREVIOUS:

866

case NFS4_OPEN_CLAIM_PREVIOUS:

867

READ_BUF(4);

867

READ_BUF(4);

868

READ32(open->op_delegate_type);

868

READ32(open->op_delegate_type);

869

break;

869

break;

870

case NFS4_OPEN_CLAIM_DELEGATE_CUR:

870

case NFS4_OPEN_CLAIM_DELEGATE_CUR:

871

status = nfsd4_decode_stateid(argp, &open->op_delegate_stateid);

871

status = nfsd4_decode_stateid(argp, &open->op_delegate_stateid);

872

if (status)

872

if (status)

873

return status;

873

return status;

874

READ_BUF(4);

874

READ_BUF(4);

875

READ32(open->op_fname.len);

875

READ32(open->op_fname.len);

876

READ_BUF(open->op_fname.len);

876

READ_BUF(open->op_fname.len);

877

SAVEMEM(open->op_fname.data, open->op_fname.len);

877

SAVEMEM(open->op_fname.data, open->op_fname.len);

878

if ((status = check_filename(open->op_fname.data, open->op_fname.len, nfserr_inval)))

878

if ((status = check_filename(open->op_fname.data, open->op_fname.len, nfserr_inval)))

879

return status;

879

return status;

880

break;

880

break;

881

case NFS4_OPEN_CLAIM_FH:

881

case NFS4_OPEN_CLAIM_FH:

882

case NFS4_OPEN_CLAIM_DELEG_PREV_FH:

882

case NFS4_OPEN_CLAIM_DELEG_PREV_FH:

883

if (argp->minorversion < 1)

883

if (argp->minorversion < 1)

884

goto xdr_error;

884

goto xdr_error;

885

/* void */

885

/* void */

886

break;

886

break;

887

case NFS4_OPEN_CLAIM_DELEG_CUR_FH:

887

case NFS4_OPEN_CLAIM_DELEG_CUR_FH:

888

if (argp->minorversion < 1)

888

if (argp->minorversion < 1)

889

goto xdr_error;

889

goto xdr_error;

890

status = nfsd4_decode_stateid(argp, &open->op_delegate_stateid);

890

status = nfsd4_decode_stateid(argp, &open->op_delegate_stateid);

891

if (status)

891

if (status)

892

return status;

892

return status;

893

break;

893

break;

894

default:

894

default:

895

goto xdr_error;

895

goto xdr_error;

896

}

896

}

897

898

DECODE_TAIL;

898

DECODE_TAIL;

899

}

899

}

900

901

static __be32

901

static __be32

902

nfsd4_decode_open_confirm(struct nfsd4_compoundargs *argp, struct nfsd4_open_confirm *open_conf)

902

nfsd4_decode_open_confirm(struct nfsd4_compoundargs *argp, struct nfsd4_open_confirm *open_conf)

903

{

903

{

904

DECODE_HEAD;

904

DECODE_HEAD;

905

906

status = nfsd4_decode_stateid(argp, &open_conf->oc_req_stateid);

906

status = nfsd4_decode_stateid(argp, &open_conf->oc_req_stateid);

907

if (status)

907

if (status)

908

return status;

908

return status;

909

READ_BUF(4);

909

READ_BUF(4);

910

READ32(open_conf->oc_seqid);

910

READ32(open_conf->oc_seqid);

911

912

DECODE_TAIL;

912

DECODE_TAIL;

913

}

913

}

914

915

static __be32

915

static __be32

916

nfsd4_decode_open_downgrade(struct nfsd4_compoundargs *argp, struct nfsd4_open_downgrade *open_down)

916

nfsd4_decode_open_downgrade(struct nfsd4_compoundargs *argp, struct nfsd4_open_downgrade *open_down)

917

{

917

{

918

DECODE_HEAD;

918

DECODE_HEAD;

919

920

status = nfsd4_decode_stateid(argp, &open_down->od_stateid);

920

status = nfsd4_decode_stateid(argp, &open_down->od_stateid);

921

if (status)

921

if (status)

922

return status;

922

return status;

923

READ_BUF(4);

923

READ_BUF(4);

924

READ32(open_down->od_seqid);

924

READ32(open_down->od_seqid);

925

status = nfsd4_decode_share_access(argp, &open_down->od_share_access,

925

status = nfsd4_decode_share_access(argp, &open_down->od_share_access,

926

&open_down->od_deleg_want, NULL);

926

&open_down->od_deleg_want, NULL);

927

if (status)

927

if (status)

928

return status;

928

return status;

929

status = nfsd4_decode_share_deny(argp, &open_down->od_share_deny);

929

status = nfsd4_decode_share_deny(argp, &open_down->od_share_deny);

930

if (status)

930

if (status)

931

return status;

931

return status;

932

DECODE_TAIL;

932

DECODE_TAIL;

933

}

933

}

934

935

static __be32

935

static __be32

936

nfsd4_decode_putfh(struct nfsd4_compoundargs *argp, struct nfsd4_putfh *putfh)

936

nfsd4_decode_putfh(struct nfsd4_compoundargs *argp, struct nfsd4_putfh *putfh)

937

{

937

{

938

DECODE_HEAD;

938

DECODE_HEAD;

939

940

READ_BUF(4);

940

READ_BUF(4);

941

READ32(putfh->pf_fhlen);

941

READ32(putfh->pf_fhlen);

942

if (putfh->pf_fhlen > NFS4_FHSIZE)

942

if (putfh->pf_fhlen > NFS4_FHSIZE)

943

goto xdr_error;

943

goto xdr_error;

944

READ_BUF(putfh->pf_fhlen);

944

READ_BUF(putfh->pf_fhlen);

945

SAVEMEM(putfh->pf_fhval, putfh->pf_fhlen);

945

SAVEMEM(putfh->pf_fhval, putfh->pf_fhlen);

946

947

DECODE_TAIL;

947

DECODE_TAIL;

948

}

948

}

949

950

static __be32

950

static __be32

951

nfsd4_decode_read(struct nfsd4_compoundargs *argp, struct nfsd4_read *read)

951

nfsd4_decode_read(struct nfsd4_compoundargs *argp, struct nfsd4_read *read)

952

{

952

{

953

DECODE_HEAD;

953

DECODE_HEAD;

954

955

status = nfsd4_decode_stateid(argp, &read->rd_stateid);

955

status = nfsd4_decode_stateid(argp, &read->rd_stateid);

956

if (status)

956

if (status)

957

return status;

957

return status;

958

READ_BUF(12);

958

READ_BUF(12);

959

READ64(read->rd_offset);

959

READ64(read->rd_offset);

960

READ32(read->rd_length);

960

READ32(read->rd_length);

961

962

DECODE_TAIL;

962

DECODE_TAIL;

963

}

963

}

964

965

static __be32

965

static __be32

966

nfsd4_decode_readdir(struct nfsd4_compoundargs *argp, struct nfsd4_readdir *readdir)

966

nfsd4_decode_readdir(struct nfsd4_compoundargs *argp, struct nfsd4_readdir *readdir)

967

{

967

{

968

DECODE_HEAD;

968

DECODE_HEAD;

969

970

READ_BUF(24);

970

READ_BUF(24);

971

READ64(readdir->rd_cookie);

971

READ64(readdir->rd_cookie);

972

COPYMEM(readdir->rd_verf.data, sizeof(readdir->rd_verf.data));

972

COPYMEM(readdir->rd_verf.data, sizeof(readdir->rd_verf.data));

973

READ32(readdir->rd_dircount); /* just in case you needed a useless field... */

973

READ32(readdir->rd_dircount); /* just in case you needed a useless field... */

974

READ32(readdir->rd_maxcount);

974

READ32(readdir->rd_maxcount);

975

if ((status = nfsd4_decode_bitmap(argp, readdir->rd_bmval)))

975

if ((status = nfsd4_decode_bitmap(argp, readdir->rd_bmval)))

976

goto out;

976

goto out;

977

978

DECODE_TAIL;

978

DECODE_TAIL;

979

}

979

}

980

981

static __be32

981

static __be32

982

nfsd4_decode_remove(struct nfsd4_compoundargs *argp, struct nfsd4_remove *remove)

982

nfsd4_decode_remove(struct nfsd4_compoundargs *argp, struct nfsd4_remove *remove)

983

{

983

{

984

DECODE_HEAD;

984

DECODE_HEAD;

985

986

READ_BUF(4);

986

READ_BUF(4);

987

READ32(remove->rm_namelen);

987

READ32(remove->rm_namelen);

988

READ_BUF(remove->rm_namelen);

988

READ_BUF(remove->rm_namelen);

989

SAVEMEM(remove->rm_name, remove->rm_namelen);

989

SAVEMEM(remove->rm_name, remove->rm_namelen);

990

if ((status = check_filename(remove->rm_name, remove->rm_namelen, nfserr_noent)))

990

if ((status = check_filename(remove->rm_name, remove->rm_namelen, nfserr_noent)))

991

return status;

991

return status;

992

993

DECODE_TAIL;

993

DECODE_TAIL;

994

}

994

}

995

996

static __be32

996

static __be32

997

nfsd4_decode_rename(struct nfsd4_compoundargs *argp, struct nfsd4_rename *rename)

997

nfsd4_decode_rename(struct nfsd4_compoundargs *argp, struct nfsd4_rename *rename)

998

{

998

{

999

DECODE_HEAD;

999

DECODE_HEAD;

1000

1001

READ_BUF(4);

1001

READ_BUF(4);

1002

READ32(rename->rn_snamelen);

1002

READ32(rename->rn_snamelen);

1003

READ_BUF(rename->rn_snamelen + 4);

1003

READ_BUF(rename->rn_snamelen + 4);

1004

SAVEMEM(rename->rn_sname, rename->rn_snamelen);

1004

SAVEMEM(rename->rn_sname, rename->rn_snamelen);

1005

READ32(rename->rn_tnamelen);

1005

READ32(rename->rn_tnamelen);

1006

READ_BUF(rename->rn_tnamelen);

1006

READ_BUF(rename->rn_tnamelen);

1007

SAVEMEM(rename->rn_tname, rename->rn_tnamelen);

1007

SAVEMEM(rename->rn_tname, rename->rn_tnamelen);

1008

if ((status = check_filename(rename->rn_sname, rename->rn_snamelen, nfserr_noent)))

1008

if ((status = check_filename(rename->rn_sname, rename->rn_snamelen, nfserr_noent)))

1009

return status;

1009

return status;

1010

if ((status = check_filename(rename->rn_tname, rename->rn_tnamelen, nfserr_inval)))

1010

if ((status = check_filename(rename->rn_tname, rename->rn_tnamelen, nfserr_inval)))

1011

return status;

1011

return status;

1012

1013

DECODE_TAIL;

1013

DECODE_TAIL;

1014

}

1014

}

1015

1016

static __be32

1016

static __be32

1017

nfsd4_decode_renew(struct nfsd4_compoundargs *argp, clientid_t *clientid)

1017

nfsd4_decode_renew(struct nfsd4_compoundargs *argp, clientid_t *clientid)

1018

{

1018

{

1019

DECODE_HEAD;

1019

DECODE_HEAD;

1020

1021

READ_BUF(sizeof(clientid_t));

1021

READ_BUF(sizeof(clientid_t));

1022

COPYMEM(clientid, sizeof(clientid_t));

1022

COPYMEM(clientid, sizeof(clientid_t));

1023

1024

DECODE_TAIL;

1024

DECODE_TAIL;

1025

}

1025

}

1026

1027

static __be32

1027

static __be32

1028

nfsd4_decode_secinfo(struct nfsd4_compoundargs *argp,

1028

nfsd4_decode_secinfo(struct nfsd4_compoundargs *argp,

1029

struct nfsd4_secinfo *secinfo)

1029

struct nfsd4_secinfo *secinfo)

1030

{

1030

{

1031

DECODE_HEAD;

1031

DECODE_HEAD;

1032

1033

READ_BUF(4);

1033

READ_BUF(4);

1034

READ32(secinfo->si_namelen);

1034

READ32(secinfo->si_namelen);

1035

READ_BUF(secinfo->si_namelen);

1035

READ_BUF(secinfo->si_namelen);

1036

SAVEMEM(secinfo->si_name, secinfo->si_namelen);

1036

SAVEMEM(secinfo->si_name, secinfo->si_namelen);

1037

status = check_filename(secinfo->si_name, secinfo->si_namelen,

1037

status = check_filename(secinfo->si_name, secinfo->si_namelen,

1038

nfserr_noent);

1038

nfserr_noent);

1039

if (status)

1039

if (status)

1040

return status;

1040

return status;

1041

DECODE_TAIL;

1041

DECODE_TAIL;

1042

}

1042

}

1043

1044

static __be32

1044

static __be32

1045

nfsd4_decode_secinfo_no_name(struct nfsd4_compoundargs *argp,

1045

nfsd4_decode_secinfo_no_name(struct nfsd4_compoundargs *argp,

1046

struct nfsd4_secinfo_no_name *sin)

1046

struct nfsd4_secinfo_no_name *sin)

1047

{

1047

{

1048

DECODE_HEAD;

1048

DECODE_HEAD;

1049

1050

READ_BUF(4);

1050

READ_BUF(4);

1051

READ32(sin->sin_style);

1051

READ32(sin->sin_style);

1052

DECODE_TAIL;

1052

DECODE_TAIL;

1053

}

1053

}

1054

1055

static __be32

1055

static __be32

1056

nfsd4_decode_setattr(struct nfsd4_compoundargs *argp, struct nfsd4_setattr *setattr)

1056

nfsd4_decode_setattr(struct nfsd4_compoundargs *argp, struct nfsd4_setattr *setattr)

1057

{

1057

{

1058

__be32 status;

1058

__be32 status;

1059

1060

status = nfsd4_decode_stateid(argp, &setattr->sa_stateid);

1060

status = nfsd4_decode_stateid(argp, &setattr->sa_stateid);

1061

if (status)

1061

if (status)

1062

return status;

1062

return status;

1063

return nfsd4_decode_fattr(argp, setattr->sa_bmval, &setattr->sa_iattr,

1063

return nfsd4_decode_fattr(argp, setattr->sa_bmval, &setattr->sa_iattr,

1064

&setattr->sa_acl);

1064

&setattr->sa_acl);

1065

}

1065

}

1066

1067

static __be32

1067

static __be32

1068

nfsd4_decode_setclientid(struct nfsd4_compoundargs *argp, struct nfsd4_setclientid *setclientid)

1068

nfsd4_decode_setclientid(struct nfsd4_compoundargs *argp, struct nfsd4_setclientid *setclientid)

1069

{

1069

{

1070

DECODE_HEAD;

1070

DECODE_HEAD;

1071

1072

READ_BUF(NFS4_VERIFIER_SIZE);

1072

READ_BUF(NFS4_VERIFIER_SIZE);

1073

COPYMEM(setclientid->se_verf.data, NFS4_VERIFIER_SIZE);

1073

COPYMEM(setclientid->se_verf.data, NFS4_VERIFIER_SIZE);

1074

1075

status = nfsd4_decode_opaque(argp, &setclientid->se_name);

1075

status = nfsd4_decode_opaque(argp, &setclientid->se_name);

1076

if (status)

1076

if (status)

1077

return nfserr_bad_xdr;

1077

return nfserr_bad_xdr;

1078

READ_BUF(8);

1078

READ_BUF(8);

1079

READ32(setclientid->se_callback_prog);

1079

READ32(setclientid->se_callback_prog);

1080

READ32(setclientid->se_callback_netid_len);

1080

READ32(setclientid->se_callback_netid_len);

1081

1082

READ_BUF(setclientid->se_callback_netid_len + 4);

1082

READ_BUF(setclientid->se_callback_netid_len + 4);

1083

SAVEMEM(setclientid->se_callback_netid_val, setclientid->se_callback_netid_len);

1083

SAVEMEM(setclientid->se_callback_netid_val, setclientid->se_callback_netid_len);

1084

READ32(setclientid->se_callback_addr_len);

1084

READ32(setclientid->se_callback_addr_len);

1085

1086

READ_BUF(setclientid->se_callback_addr_len + 4);

1086

READ_BUF(setclientid->se_callback_addr_len + 4);

1087

SAVEMEM(setclientid->se_callback_addr_val, setclientid->se_callback_addr_len);

1087

SAVEMEM(setclientid->se_callback_addr_val, setclientid->se_callback_addr_len);

1088

READ32(setclientid->se_callback_ident);

1088

READ32(setclientid->se_callback_ident);

1089

1090

DECODE_TAIL;

1090

DECODE_TAIL;

1091

}

1091

}

1092

1093

static __be32

1093

static __be32

1094

nfsd4_decode_setclientid_confirm(struct nfsd4_compoundargs *argp, struct nfsd4_setclientid_confirm *scd_c)

1094

nfsd4_decode_setclientid_confirm(struct nfsd4_compoundargs *argp, struct nfsd4_setclientid_confirm *scd_c)

1095

{

1095

{

1096

DECODE_HEAD;

1096

DECODE_HEAD;

1097

1098

READ_BUF(8 + NFS4_VERIFIER_SIZE);

1098

READ_BUF(8 + NFS4_VERIFIER_SIZE);

1099

COPYMEM(&scd_c->sc_clientid, 8);

1099

COPYMEM(&scd_c->sc_clientid, 8);

1100

COPYMEM(&scd_c->sc_confirm, NFS4_VERIFIER_SIZE);

1100

COPYMEM(&scd_c->sc_confirm, NFS4_VERIFIER_SIZE);

1101

1102

DECODE_TAIL;

1102

DECODE_TAIL;

1103

}

1103

}

1104

1105

/* Also used for NVERIFY */

1105

/* Also used for NVERIFY */

1106

static __be32

1106

static __be32

1107

nfsd4_decode_verify(struct nfsd4_compoundargs *argp, struct nfsd4_verify *verify)

1107

nfsd4_decode_verify(struct nfsd4_compoundargs *argp, struct nfsd4_verify *verify)

1108

{

1108

{

1109

#if 0

1109

#if 0

1110

struct nfsd4_compoundargs save = {

1110

struct nfsd4_compoundargs save = {

1111

.p = argp->p,

1111

.p = argp->p,

1112

.end = argp->end,

1112

.end = argp->end,

1113

.rqstp = argp->rqstp,

1113

.rqstp = argp->rqstp,

1114

};

1114

};

1115

u32 ve_bmval[2];

1115

u32 ve_bmval[2];

1116

struct iattr ve_iattr; /* request */

1116

struct iattr ve_iattr; /* request */

1117

struct nfs4_acl *ve_acl; /* request */

1117

struct nfs4_acl *ve_acl; /* request */

1118

#endif

1118

#endif

1119

DECODE_HEAD;

1119

DECODE_HEAD;

1120

1121

if ((status = nfsd4_decode_bitmap(argp, verify->ve_bmval)))

1121

if ((status = nfsd4_decode_bitmap(argp, verify->ve_bmval)))

1122

goto out;

1122

goto out;

1123

1124

/* For convenience's sake, we compare raw xdr'd attributes in

1124

/* For convenience's sake, we compare raw xdr'd attributes in

1125

* nfsd4_proc_verify; however we still decode here just to return

1125

* nfsd4_proc_verify; however we still decode here just to return

1126

* correct error in case of bad xdr. */

1126

* correct error in case of bad xdr. */

1127

#if 0

1127

#if 0

1128

status = nfsd4_decode_fattr(ve_bmval, &ve_iattr, &ve_acl);

1128

status = nfsd4_decode_fattr(ve_bmval, &ve_iattr, &ve_acl);

1129

if (status == nfserr_inval) {

1129

if (status == nfserr_inval) {

1130

status = nfserrno(status);

1130

status = nfserrno(status);

1131

goto out;

1131

goto out;

1132

}

1132

}

1133

#endif

1133

#endif

1134

READ_BUF(4);

1134

READ_BUF(4);

1135

READ32(verify->ve_attrlen);

1135

READ32(verify->ve_attrlen);

1136

READ_BUF(verify->ve_attrlen);

1136

READ_BUF(verify->ve_attrlen);

1137

SAVEMEM(verify->ve_attrval, verify->ve_attrlen);

1137

SAVEMEM(verify->ve_attrval, verify->ve_attrlen);

1138

1139

DECODE_TAIL;

1139

DECODE_TAIL;

1140

}

1140

}

1141

1142

static int fill_in_write_vector(struct kvec *vec, struct kvec *head, struct page **pagelist, int buflen)

1143

{

1144

int i = 1;

1145

1146

vec[0].iov_base = head->iov_base;

1147

vec[0].iov_len = min_t(int, buflen, head->iov_len);

1148

buflen -= vec[0].iov_len;

1149

1150

while (buflen) {

1151

vec[i].iov_base = page_address(pagelist[i - 1]);

1152

vec[i].iov_len = min_t(int, PAGE_SIZE, buflen);

1153

buflen -= vec[i].iov_len;

1154

i++;

1155

}

1156

return i;

1157

}

1158

1142

static __be32

1159

static __be32

1143

nfsd4_decode_write(struct nfsd4_compoundargs *argp, struct nfsd4_write *write)

1160

nfsd4_decode_write(struct nfsd4_compoundargs *argp, struct nfsd4_write *write)

1144

{

1161

{

1145

int avail;

1162

int avail;

1146

int v;

1147

int len;

1163

int len;

1164

struct page **pagelist;

1165

struct kvec head;

1148

DECODE_HEAD;

1166

DECODE_HEAD;

1149

1167

1150

status = nfsd4_decode_stateid(argp, &write->wr_stateid);

1168

status = nfsd4_decode_stateid(argp, &write->wr_stateid);

1151

if (status)

1169

if (status)

1152

return status;

1170

return status;

1153

READ_BUF(16);

1171

READ_BUF(16);

1154

READ64(write->wr_offset);

1172

READ64(write->wr_offset);

1155

READ32(write->wr_stable_how);

1173

READ32(write->wr_stable_how);

1156

if (write->wr_stable_how > 2)

1174

if (write->wr_stable_how > 2)

1157

goto xdr_error;

1175

goto xdr_error;

1158

READ32(write->wr_buflen);

1176

READ32(write->wr_buflen);

1159

1177

1160

/* Sorry .. no magic macros for this.. *

1178

/* Sorry .. no magic macros for this.. *

1161

* READ_BUF(write->wr_buflen);

1179

* READ_BUF(write->wr_buflen);

1162

* SAVEMEM(write->wr_buf, write->wr_buflen);

1180

* SAVEMEM(write->wr_buf, write->wr_buflen);

1163

*/

1181

*/

1164

avail = (char*)argp->end - (char*)argp->p;

1182

avail = (char*)argp->end - (char*)argp->p;

1165

if (avail + argp->pagelen < write->wr_buflen) {

1183

if (avail + argp->pagelen < write->wr_buflen) {

1166

dprintk("NFSD: xdr error (%s:%d)\n",

1184

dprintk("NFSD: xdr error (%s:%d)\n",

1167

__FILE__, __LINE__);

1185

__FILE__, __LINE__);

1168

goto xdr_error;

1186

goto xdr_error;

1169

}

1187

}

1170

argp->rqstp->rq_vec[0].iov_base = p;

1188

head.iov_base = p;

1171

argp->rqstp->rq_vec[0].iov_len = avail;

1189

head.iov_len = avail;

1172

v = 0;

1190

WARN_ON(avail != (XDR_QUADLEN(avail) << 2));

1173

len = write->wr_buflen;

1191

pagelist = argp->pagelist;

1174

while (len > argp->rqstp->rq_vec[v].iov_len) {

1192

1175

len -= argp->rqstp->rq_vec[v].iov_len;

1193

len = XDR_QUADLEN(write->wr_buflen) << 2;

1176

v++;

1194

if (len >= avail) {

1177

argp->rqstp->rq_vec[v].iov_base = page_address(argp->pagelist[0]);

1195

int pages;

1178

argp->pagelist++;

1196

1179

if (argp->pagelen >= PAGE_SIZE) {

1197

len -= avail;

1180

argp->rqstp->rq_vec[v].iov_len = PAGE_SIZE;

1198

1181

argp->pagelen -= PAGE_SIZE;

1199

pages = len >> PAGE_SHIFT;

1182

} else {

1200

argp->pagelist += pages;

1183

argp->rqstp->rq_vec[v].iov_len = argp->pagelen;

1201

argp->pagelen -= pages * PAGE_SIZE;

1184

argp->pagelen -= len;

1202

len -= pages * PAGE_SIZE;

1185

}

1203

1204

argp->p = (__be32 *)page_address(argp->pagelist[0]);

1205

argp->end = argp->p + XDR_QUADLEN(PAGE_SIZE);

1186

}

1206

}

1187

argp->end = (__be32*) (argp->rqstp->rq_vec[v].iov_base + argp->rqstp->rq_vec[v].iov_len);

1207

argp->p += XDR_QUADLEN(len);

1188

argp->p = (__be32*) (argp->rqstp->rq_vec[v].iov_base + (XDR_QUADLEN(len) << 2));

1208

write->wr_vlen = fill_in_write_vector(argp->rqstp->rq_vec,

1189

argp->rqstp->rq_vec[v].iov_len = len;

1209

&head, pagelist, write->wr_buflen);

1190

write->wr_vlen = v+1;

1210

WARN_ON_ONCE(write->wr_vlen > ARRAY_SIZE(argp->rqstp->rq_vec));

1191

1211

1192

DECODE_TAIL;

1212

DECODE_TAIL;

1193

}

1213

}

1194

1214

1195

static __be32

1215

static __be32

1196

nfsd4_decode_release_lockowner(struct nfsd4_compoundargs *argp, struct nfsd4_release_lockowner *rlockowner)

1216

nfsd4_decode_release_lockowner(struct nfsd4_compoundargs *argp, struct nfsd4_release_lockowner *rlockowner)

1197

{

1217

{

1198

DECODE_HEAD;

1218

DECODE_HEAD;

1199

1219

1200

READ_BUF(12);

1220

READ_BUF(12);

1201

COPYMEM(&rlockowner->rl_clientid, sizeof(clientid_t));

1221

COPYMEM(&rlockowner->rl_clientid, sizeof(clientid_t));

1202

READ32(rlockowner->rl_owner.len);

1222

READ32(rlockowner->rl_owner.len);

1203

READ_BUF(rlockowner->rl_owner.len);

1223

READ_BUF(rlockowner->rl_owner.len);

1204

READMEM(rlockowner->rl_owner.data, rlockowner->rl_owner.len);

1224

READMEM(rlockowner->rl_owner.data, rlockowner->rl_owner.len);

1205

1225

1206

if (argp->minorversion && !zero_clientid(&rlockowner->rl_clientid))

1226

if (argp->minorversion && !zero_clientid(&rlockowner->rl_clientid))

1207

return nfserr_inval;

1227

return nfserr_inval;

1208

DECODE_TAIL;

1228

DECODE_TAIL;

1209

}

1229

}

1210

1230

1211

static __be32

1231

static __be32

1212

nfsd4_decode_exchange_id(struct nfsd4_compoundargs *argp,

1232

nfsd4_decode_exchange_id(struct nfsd4_compoundargs *argp,

1213

struct nfsd4_exchange_id *exid)

1233

struct nfsd4_exchange_id *exid)

1214

{

1234

{

1215

int dummy, tmp;

1235

int dummy, tmp;

1216

DECODE_HEAD;

1236

DECODE_HEAD;

1217

1237

1218

READ_BUF(NFS4_VERIFIER_SIZE);

1238

READ_BUF(NFS4_VERIFIER_SIZE);

1219

COPYMEM(exid->verifier.data, NFS4_VERIFIER_SIZE);

1239

COPYMEM(exid->verifier.data, NFS4_VERIFIER_SIZE);

1220

1240

1221

status = nfsd4_decode_opaque(argp, &exid->clname);

1241

status = nfsd4_decode_opaque(argp, &exid->clname);

1222

if (status)

1242

if (status)

1223

return nfserr_bad_xdr;

1243

return nfserr_bad_xdr;

1224

1244

1225

READ_BUF(4);

1245

READ_BUF(4);

1226

READ32(exid->flags);

1246

READ32(exid->flags);

1227

1247

1228

/* Ignore state_protect4_a */

1248

/* Ignore state_protect4_a */

1229

READ_BUF(4);

1249

READ_BUF(4);

1230

READ32(exid->spa_how);

1250

READ32(exid->spa_how);

1231

switch (exid->spa_how) {

1251

switch (exid->spa_how) {

1232

case SP4_NONE:

1252

case SP4_NONE:

1233

break;

1253

break;

1234

case SP4_MACH_CRED:

1254

case SP4_MACH_CRED:

1235

/* spo_must_enforce */

1255

/* spo_must_enforce */

1236

READ_BUF(4);

1256

READ_BUF(4);

1237

READ32(dummy);

1257

READ32(dummy);

1238

READ_BUF(dummy * 4);

1258

READ_BUF(dummy * 4);

1239

p += dummy;

1259

p += dummy;

1240

1260

1241

/* spo_must_allow */

1261

/* spo_must_allow */

1242

READ_BUF(4);

1262

READ_BUF(4);

1243

READ32(dummy);

1263

READ32(dummy);

1244

READ_BUF(dummy * 4);

1264

READ_BUF(dummy * 4);

1245

p += dummy;

1265

p += dummy;

1246

break;

1266

break;

1247

case SP4_SSV:

1267

case SP4_SSV:

1248

/* ssp_ops */

1268

/* ssp_ops */

1249

READ_BUF(4);

1269

READ_BUF(4);

1250

READ32(dummy);

1270

READ32(dummy);

1251

READ_BUF(dummy * 4);

1271

READ_BUF(dummy * 4);

1252

p += dummy;

1272

p += dummy;

1253

1273

1254

READ_BUF(4);

1274

READ_BUF(4);

1255

READ32(dummy);

1275

READ32(dummy);

1256

READ_BUF(dummy * 4);

1276

READ_BUF(dummy * 4);

1257

p += dummy;

1277

p += dummy;

1258

1278

1259

/* ssp_hash_algs<> */

1279

/* ssp_hash_algs<> */

1260

READ_BUF(4);

1280

READ_BUF(4);

1261

READ32(tmp);

1281

READ32(tmp);

1262

while (tmp--) {

1282

while (tmp--) {

1263

READ_BUF(4);

1283

READ_BUF(4);

1264

READ32(dummy);

1284

READ32(dummy);

1265

READ_BUF(dummy);

1285

READ_BUF(dummy);

1266

p += XDR_QUADLEN(dummy);

1286

p += XDR_QUADLEN(dummy);

1267

}

1287

}

1268

1288

1269

/* ssp_encr_algs<> */

1289

/* ssp_encr_algs<> */

1270

READ_BUF(4);

1290

READ_BUF(4);

1271

READ32(tmp);

1291

READ32(tmp);

1272

while (tmp--) {

1292

while (tmp--) {

1273

READ_BUF(4);

1293

READ_BUF(4);

1274

READ32(dummy);

1294

READ32(dummy);

1275

READ_BUF(dummy);

1295

READ_BUF(dummy);

1276

p += XDR_QUADLEN(dummy);

1296

p += XDR_QUADLEN(dummy);

1277

}

1297

}

1278

1298

1279

/* ssp_window and ssp_num_gss_handles */

1299

/* ssp_window and ssp_num_gss_handles */

1280

READ_BUF(8);

1300

READ_BUF(8);

1281

READ32(dummy);

1301

READ32(dummy);

1282

READ32(dummy);

1302

READ32(dummy);

1283

break;

1303

break;

1284

default:

1304

default:

1285

goto xdr_error;

1305

goto xdr_error;

1286

}

1306

}

1287

1307

1288

/* Ignore Implementation ID */

1308

/* Ignore Implementation ID */

1289

READ_BUF(4); /* nfs_impl_id4 array length */

1309

READ_BUF(4); /* nfs_impl_id4 array length */

1290

READ32(dummy);

1310

READ32(dummy);

1291

1311

1292

if (dummy > 1)

1312

if (dummy > 1)

1293

goto xdr_error;

1313

goto xdr_error;

1294

1314

1295

if (dummy == 1) {

1315

if (dummy == 1) {

1296

/* nii_domain */

1316

/* nii_domain */

1297

READ_BUF(4);

1317

READ_BUF(4);

1298

READ32(dummy);

1318

READ32(dummy);

1299

READ_BUF(dummy);

1319

READ_BUF(dummy);

1300

p += XDR_QUADLEN(dummy);

1320

p += XDR_QUADLEN(dummy);

1301

1321

1302

/* nii_name */

1322

/* nii_name */

1303

READ_BUF(4);

1323

READ_BUF(4);

1304

READ32(dummy);

1324

READ32(dummy);

1305

READ_BUF(dummy);

1325

READ_BUF(dummy);

1306

p += XDR_QUADLEN(dummy);

1326

p += XDR_QUADLEN(dummy);

1307

1327

1308

/* nii_date */

1328

/* nii_date */

1309

READ_BUF(12);

1329

READ_BUF(12);

1310

p += 3;

1330

p += 3;

1311

}

1331

}

1312

DECODE_TAIL;

1332

DECODE_TAIL;

1313

}

1333

}

1314

1334

1315

static __be32

1335

static __be32

1316

nfsd4_decode_create_session(struct nfsd4_compoundargs *argp,

1336

nfsd4_decode_create_session(struct nfsd4_compoundargs *argp,

1317

struct nfsd4_create_session *sess)

1337

struct nfsd4_create_session *sess)

1318

{

1338

{

1319

DECODE_HEAD;

1339

DECODE_HEAD;

1320

u32 dummy;

1340

u32 dummy;

1321

1341

1322

READ_BUF(16);

1342

READ_BUF(16);

1323

COPYMEM(&sess->clientid, 8);

1343

COPYMEM(&sess->clientid, 8);

1324

READ32(sess->seqid);

1344

READ32(sess->seqid);

1325

READ32(sess->flags);

1345

READ32(sess->flags);

1326

1346

1327

/* Fore channel attrs */

1347

/* Fore channel attrs */

1328

READ_BUF(28);

1348

READ_BUF(28);

1329

READ32(dummy); /* headerpadsz is always 0 */

1349

READ32(dummy); /* headerpadsz is always 0 */

1330

READ32(sess->fore_channel.maxreq_sz);

1350

READ32(sess->fore_channel.maxreq_sz);

1331

READ32(sess->fore_channel.maxresp_sz);

1351

READ32(sess->fore_channel.maxresp_sz);

1332

READ32(sess->fore_channel.maxresp_cached);

1352

READ32(sess->fore_channel.maxresp_cached);

1333

READ32(sess->fore_channel.maxops);

1353

READ32(sess->fore_channel.maxops);

1334

READ32(sess->fore_channel.maxreqs);

1354

READ32(sess->fore_channel.maxreqs);

1335

READ32(sess->fore_channel.nr_rdma_attrs);

1355

READ32(sess->fore_channel.nr_rdma_attrs);

1336

if (sess->fore_channel.nr_rdma_attrs == 1) {

1356

if (sess->fore_channel.nr_rdma_attrs == 1) {

1337

READ_BUF(4);

1357

READ_BUF(4);

1338

READ32(sess->fore_channel.rdma_attrs);

1358

READ32(sess->fore_channel.rdma_attrs);

1339

} else if (sess->fore_channel.nr_rdma_attrs > 1) {

1359

} else if (sess->fore_channel.nr_rdma_attrs > 1) {

1340

dprintk("Too many fore channel attr bitmaps!\n");

1360

dprintk("Too many fore channel attr bitmaps!\n");

1341

goto xdr_error;

1361

goto xdr_error;

1342

}

1362

}

1343

1363

1344

/* Back channel attrs */

1364

/* Back channel attrs */

1345

READ_BUF(28);

1365

READ_BUF(28);

1346

READ32(dummy); /* headerpadsz is always 0 */

1366

READ32(dummy); /* headerpadsz is always 0 */

1347

READ32(sess->back_channel.maxreq_sz);

1367

READ32(sess->back_channel.maxreq_sz);

1348

READ32(sess->back_channel.maxresp_sz);

1368

READ32(sess->back_channel.maxresp_sz);

1349

READ32(sess->back_channel.maxresp_cached);

1369

READ32(sess->back_channel.maxresp_cached);

1350

READ32(sess->back_channel.maxops);

1370

READ32(sess->back_channel.maxops);

1351

READ32(sess->back_channel.maxreqs);

1371

READ32(sess->back_channel.maxreqs);

1352

READ32(sess->back_channel.nr_rdma_attrs);

1372

READ32(sess->back_channel.nr_rdma_attrs);

1353

if (sess->back_channel.nr_rdma_attrs == 1) {

1373

if (sess->back_channel.nr_rdma_attrs == 1) {

1354

READ_BUF(4);

1374

READ_BUF(4);

1355

READ32(sess->back_channel.rdma_attrs);

1375

READ32(sess->back_channel.rdma_attrs);

1356

} else if (sess->back_channel.nr_rdma_attrs > 1) {

1376

} else if (sess->back_channel.nr_rdma_attrs > 1) {

1357

dprintk("Too many back channel attr bitmaps!\n");

1377

dprintk("Too many back channel attr bitmaps!\n");

1358

goto xdr_error;

1378

goto xdr_error;

1359

}

1379

}

1360

1380

1361

READ_BUF(4);

1381

READ_BUF(4);

1362

READ32(sess->callback_prog);

1382

READ32(sess->callback_prog);

1363

nfsd4_decode_cb_sec(argp, &sess->cb_sec);

1383

nfsd4_decode_cb_sec(argp, &sess->cb_sec);

1364

DECODE_TAIL;

1384

DECODE_TAIL;

1365

}

1385

}

1366

1386

1367

static __be32

1387

static __be32

1368

nfsd4_decode_destroy_session(struct nfsd4_compoundargs *argp,

1388

nfsd4_decode_destroy_session(struct nfsd4_compoundargs *argp,

1369

struct nfsd4_destroy_session *destroy_session)

1389

struct nfsd4_destroy_session *destroy_session)

1370

{

1390

{

1371

DECODE_HEAD;

1391

DECODE_HEAD;

1372

READ_BUF(NFS4_MAX_SESSIONID_LEN);

1392

READ_BUF(NFS4_MAX_SESSIONID_LEN);

1373

COPYMEM(destroy_session->sessionid.data, NFS4_MAX_SESSIONID_LEN);

1393

COPYMEM(destroy_session->sessionid.data, NFS4_MAX_SESSIONID_LEN);

1374

1394

1375

DECODE_TAIL;

1395

DECODE_TAIL;

1376

}

1396

}

1377

1397

1378

static __be32

1398

static __be32

1379

nfsd4_decode_free_stateid(struct nfsd4_compoundargs *argp,

1399

nfsd4_decode_free_stateid(struct nfsd4_compoundargs *argp,

1380

struct nfsd4_free_stateid *free_stateid)

1400

struct nfsd4_free_stateid *free_stateid)

1381

{

1401

{

1382

DECODE_HEAD;

1402

DECODE_HEAD;

1383

1403

1384

READ_BUF(sizeof(stateid_t));

1404

READ_BUF(sizeof(stateid_t));

1385

READ32(free_stateid->fr_stateid.si_generation);

1405

READ32(free_stateid->fr_stateid.si_generation);

1386

COPYMEM(&free_stateid->fr_stateid.si_opaque, sizeof(stateid_opaque_t));

1406

COPYMEM(&free_stateid->fr_stateid.si_opaque, sizeof(stateid_opaque_t));

1387

1407

1388

DECODE_TAIL;

1408

DECODE_TAIL;

1389

}

1409

}

1390

1410

1391

static __be32

1411

static __be32

1392

nfsd4_decode_sequence(struct nfsd4_compoundargs *argp,

1412

nfsd4_decode_sequence(struct nfsd4_compoundargs *argp,

1393

struct nfsd4_sequence *seq)

1413

struct nfsd4_sequence *seq)

1394

{

1414

{

1395

DECODE_HEAD;

1415

DECODE_HEAD;

1396

1416

1397

READ_BUF(NFS4_MAX_SESSIONID_LEN + 16);

1417

READ_BUF(NFS4_MAX_SESSIONID_LEN + 16);

1398

COPYMEM(seq->sessionid.data, NFS4_MAX_SESSIONID_LEN);

1418

COPYMEM(seq->sessionid.data, NFS4_MAX_SESSIONID_LEN);

1399

READ32(seq->seqid);

1419

READ32(seq->seqid);

1400

READ32(seq->slotid);

1420

READ32(seq->slotid);

1401

READ32(seq->maxslots);

1421

READ32(seq->maxslots);

1402

READ32(seq->cachethis);

1422

READ32(seq->cachethis);

1403

1423

1404

DECODE_TAIL;

1424

DECODE_TAIL;

1405

}

1425

}

1406

1426

1407

static __be32

1427

static __be32

1408

nfsd4_decode_test_stateid(struct nfsd4_compoundargs *argp, struct nfsd4_test_stateid *test_stateid)

1428

nfsd4_decode_test_stateid(struct nfsd4_compoundargs *argp, struct nfsd4_test_stateid *test_stateid)

1409

{

1429

{

1410

int i;

1430

int i;

1411

__be32 *p, status;

1431

__be32 *p, status;

1412

struct nfsd4_test_stateid_id *stateid;

1432

struct nfsd4_test_stateid_id *stateid;

1413

1433

1414

READ_BUF(4);

1434

READ_BUF(4);

1415

test_stateid->ts_num_ids = ntohl(*p++);

1435

test_stateid->ts_num_ids = ntohl(*p++);

1416

1436

1417

INIT_LIST_HEAD(&test_stateid->ts_stateid_list);

1437

INIT_LIST_HEAD(&test_stateid->ts_stateid_list);

1418

1438

1419

for (i = 0; i < test_stateid->ts_num_ids; i++) {

1439

for (i = 0; i < test_stateid->ts_num_ids; i++) {

1420

stateid = kmalloc(sizeof(struct nfsd4_test_stateid_id), GFP_KERNEL);

1440

stateid = kmalloc(sizeof(struct nfsd4_test_stateid_id), GFP_KERNEL);

1421

if (!stateid) {

1441

if (!stateid) {

1422

status = nfserrno(-ENOMEM);

1442

status = nfserrno(-ENOMEM);

1423

goto out;

1443

goto out;

1424

}

1444

}

1425

1445

1426

defer_free(argp, kfree, stateid);

1446

defer_free(argp, kfree, stateid);

1427

INIT_LIST_HEAD(&stateid->ts_id_list);

1447

INIT_LIST_HEAD(&stateid->ts_id_list);

1428

list_add_tail(&stateid->ts_id_list, &test_stateid->ts_stateid_list);

1448

list_add_tail(&stateid->ts_id_list, &test_stateid->ts_stateid_list);

1429

1449

1430

status = nfsd4_decode_stateid(argp, &stateid->ts_id_stateid);

1450

status = nfsd4_decode_stateid(argp, &stateid->ts_id_stateid);

1431

if (status)

1451

if (status)

1432

goto out;

1452

goto out;

1433

}

1453

}

1434

1454

1435

status = 0;

1455

status = 0;

1436

out:

1456

out:

1437

return status;

1457

return status;

1438

xdr_error:

1458

xdr_error:

1439

dprintk("NFSD: xdr error (%s:%d)\n", __FILE__, __LINE__);

1459

dprintk("NFSD: xdr error (%s:%d)\n", __FILE__, __LINE__);

1440

status = nfserr_bad_xdr;

1460

status = nfserr_bad_xdr;

1441

goto out;

1461

goto out;

1442

}

1462

}

1443

1463

1444

static __be32 nfsd4_decode_destroy_clientid(struct nfsd4_compoundargs *argp, struct nfsd4_destroy_clientid *dc)

1464

static __be32 nfsd4_decode_destroy_clientid(struct nfsd4_compoundargs *argp, struct nfsd4_destroy_clientid *dc)

1445

{

1465

{

1446

DECODE_HEAD;

1466

DECODE_HEAD;

1447

1467

1448

READ_BUF(8);

1468

READ_BUF(8);

1449

COPYMEM(&dc->clientid, 8);

1469

COPYMEM(&dc->clientid, 8);

1450

1470

1451

DECODE_TAIL;

1471

DECODE_TAIL;

1452

}

1472

}

1453

1473

1454

static __be32 nfsd4_decode_reclaim_complete(struct nfsd4_compoundargs *argp, struct nfsd4_reclaim_complete *rc)

1474

static __be32 nfsd4_decode_reclaim_complete(struct nfsd4_compoundargs *argp, struct nfsd4_reclaim_complete *rc)

1455

{

1475

{

1456

DECODE_HEAD;

1476

DECODE_HEAD;

1457

1477

1458

READ_BUF(4);

1478

READ_BUF(4);

1459

READ32(rc->rca_one_fs);

1479

READ32(rc->rca_one_fs);

1460

1480

1461

DECODE_TAIL;

1481

DECODE_TAIL;

1462

}

1482

}

1463

1483

1464

static __be32

1484

static __be32

1465

nfsd4_decode_noop(struct nfsd4_compoundargs *argp, void *p)

1485

nfsd4_decode_noop(struct nfsd4_compoundargs *argp, void *p)

1466

{

1486

{

1467

return nfs_ok;

1487

return nfs_ok;

1468

}

1488

}

1469

1489

1470

static __be32

1490

static __be32

1471

nfsd4_decode_notsupp(struct nfsd4_compoundargs *argp, void *p)

1491

nfsd4_decode_notsupp(struct nfsd4_compoundargs *argp, void *p)

1472

{

1492

{

1473

return nfserr_notsupp;

1493

return nfserr_notsupp;

1474

}

1494

}

1475

1495

1476

typedef __be32(*nfsd4_dec)(struct nfsd4_compoundargs *argp, void *);

1496

typedef __be32(*nfsd4_dec)(struct nfsd4_compoundargs *argp, void *);

1477

1497

1478

static nfsd4_dec nfsd4_dec_ops[] = {

1498

static nfsd4_dec nfsd4_dec_ops[] = {

1479

[OP_ACCESS] = (nfsd4_dec)nfsd4_decode_access,

1499

[OP_ACCESS] = (nfsd4_dec)nfsd4_decode_access,

1480

[OP_CLOSE] = (nfsd4_dec)nfsd4_decode_close,

1500

[OP_CLOSE] = (nfsd4_dec)nfsd4_decode_close,

1481

[OP_COMMIT] = (nfsd4_dec)nfsd4_decode_commit,

1501

[OP_COMMIT] = (nfsd4_dec)nfsd4_decode_commit,

1482

[OP_CREATE] = (nfsd4_dec)nfsd4_decode_create,

1502

[OP_CREATE] = (nfsd4_dec)nfsd4_decode_create,

1483

[OP_DELEGPURGE] = (nfsd4_dec)nfsd4_decode_notsupp,

1503

[OP_DELEGPURGE] = (nfsd4_dec)nfsd4_decode_notsupp,

1484

[OP_DELEGRETURN] = (nfsd4_dec)nfsd4_decode_delegreturn,

1504

[OP_DELEGRETURN] = (nfsd4_dec)nfsd4_decode_delegreturn,

1485

[OP_GETATTR] = (nfsd4_dec)nfsd4_decode_getattr,

1505

[OP_GETATTR] = (nfsd4_dec)nfsd4_decode_getattr,

1486

[OP_GETFH] = (nfsd4_dec)nfsd4_decode_noop,

1506

[OP_GETFH] = (nfsd4_dec)nfsd4_decode_noop,

1487

[OP_LINK] = (nfsd4_dec)nfsd4_decode_link,

1507

[OP_LINK] = (nfsd4_dec)nfsd4_decode_link,

1488

[OP_LOCK] = (nfsd4_dec)nfsd4_decode_lock,

1508

[OP_LOCK] = (nfsd4_dec)nfsd4_decode_lock,

1489

[OP_LOCKT] = (nfsd4_dec)nfsd4_decode_lockt,

1509

[OP_LOCKT] = (nfsd4_dec)nfsd4_decode_lockt,

1490

[OP_LOCKU] = (nfsd4_dec)nfsd4_decode_locku,

1510

[OP_LOCKU] = (nfsd4_dec)nfsd4_decode_locku,

1491

[OP_LOOKUP] = (nfsd4_dec)nfsd4_decode_lookup,

1511

[OP_LOOKUP] = (nfsd4_dec)nfsd4_decode_lookup,

1492

[OP_LOOKUPP] = (nfsd4_dec)nfsd4_decode_noop,

1512

[OP_LOOKUPP] = (nfsd4_dec)nfsd4_decode_noop,

1493

[OP_NVERIFY] = (nfsd4_dec)nfsd4_decode_verify,

1513

[OP_NVERIFY] = (nfsd4_dec)nfsd4_decode_verify,

1494

[OP_OPEN] = (nfsd4_dec)nfsd4_decode_open,

1514

[OP_OPEN] = (nfsd4_dec)nfsd4_decode_open,

1495

[OP_OPENATTR] = (nfsd4_dec)nfsd4_decode_notsupp,

1515

[OP_OPENATTR] = (nfsd4_dec)nfsd4_decode_notsupp,

1496

[OP_OPEN_CONFIRM] = (nfsd4_dec)nfsd4_decode_open_confirm,

1516

[OP_OPEN_CONFIRM] = (nfsd4_dec)nfsd4_decode_open_confirm,

1497

[OP_OPEN_DOWNGRADE] = (nfsd4_dec)nfsd4_decode_open_downgrade,

1517

[OP_OPEN_DOWNGRADE] = (nfsd4_dec)nfsd4_decode_open_downgrade,

1498

[OP_PUTFH] = (nfsd4_dec)nfsd4_decode_putfh,

1518

[OP_PUTFH] = (nfsd4_dec)nfsd4_decode_putfh,

1499

[OP_PUTPUBFH] = (nfsd4_dec)nfsd4_decode_noop,

1519

[OP_PUTPUBFH] = (nfsd4_dec)nfsd4_decode_noop,

1500

[OP_PUTROOTFH] = (nfsd4_dec)nfsd4_decode_noop,

1520

[OP_PUTROOTFH] = (nfsd4_dec)nfsd4_decode_noop,

1501

[OP_READ] = (nfsd4_dec)nfsd4_decode_read,

1521

[OP_READ] = (nfsd4_dec)nfsd4_decode_read,

1502

[OP_READDIR] = (nfsd4_dec)nfsd4_decode_readdir,

1522

[OP_READDIR] = (nfsd4_dec)nfsd4_decode_readdir,

1503

[OP_READLINK] = (nfsd4_dec)nfsd4_decode_noop,

1523

[OP_READLINK] = (nfsd4_dec)nfsd4_decode_noop,

1504

[OP_REMOVE] = (nfsd4_dec)nfsd4_decode_remove,

1524

[OP_REMOVE] = (nfsd4_dec)nfsd4_decode_remove,

1505

[OP_RENAME] = (nfsd4_dec)nfsd4_decode_rename,

1525

[OP_RENAME] = (nfsd4_dec)nfsd4_decode_rename,

1506

[OP_RENEW] = (nfsd4_dec)nfsd4_decode_renew,

1526

[OP_RENEW] = (nfsd4_dec)nfsd4_decode_renew,

1507

[OP_RESTOREFH] = (nfsd4_dec)nfsd4_decode_noop,

1527

[OP_RESTOREFH] = (nfsd4_dec)nfsd4_decode_noop,

1508

[OP_SAVEFH] = (nfsd4_dec)nfsd4_decode_noop,

1528

[OP_SAVEFH] = (nfsd4_dec)nfsd4_decode_noop,

1509

[OP_SECINFO] = (nfsd4_dec)nfsd4_decode_secinfo,

1529

[OP_SECINFO] = (nfsd4_dec)nfsd4_decode_secinfo,

1510

[OP_SETATTR] = (nfsd4_dec)nfsd4_decode_setattr,

1530

[OP_SETATTR] = (nfsd4_dec)nfsd4_decode_setattr,

1511

[OP_SETCLIENTID] = (nfsd4_dec)nfsd4_decode_setclientid,

1531

[OP_SETCLIENTID] = (nfsd4_dec)nfsd4_decode_setclientid,

1512

[OP_SETCLIENTID_CONFIRM] = (nfsd4_dec)nfsd4_decode_setclientid_confirm,

1532

[OP_SETCLIENTID_CONFIRM] = (nfsd4_dec)nfsd4_decode_setclientid_confirm,

1513

[OP_VERIFY] = (nfsd4_dec)nfsd4_decode_verify,

1533

[OP_VERIFY] = (nfsd4_dec)nfsd4_decode_verify,

1514

[OP_WRITE] = (nfsd4_dec)nfsd4_decode_write,

1534

[OP_WRITE] = (nfsd4_dec)nfsd4_decode_write,

1515

[OP_RELEASE_LOCKOWNER] = (nfsd4_dec)nfsd4_decode_release_lockowner,

1535

[OP_RELEASE_LOCKOWNER] = (nfsd4_dec)nfsd4_decode_release_lockowner,

1516

};

1536

};

1517

1537

1518

static nfsd4_dec nfsd41_dec_ops[] = {

1538

static nfsd4_dec nfsd41_dec_ops[] = {

1519

[OP_ACCESS] = (nfsd4_dec)nfsd4_decode_access,

1539

[OP_ACCESS] = (nfsd4_dec)nfsd4_decode_access,

1520

[OP_CLOSE] = (nfsd4_dec)nfsd4_decode_close,

1540

[OP_CLOSE] = (nfsd4_dec)nfsd4_decode_close,

1521

[OP_COMMIT] = (nfsd4_dec)nfsd4_decode_commit,

1541

[OP_COMMIT] = (nfsd4_dec)nfsd4_decode_commit,

1522

[OP_CREATE] = (nfsd4_dec)nfsd4_decode_create,

1542

[OP_CREATE] = (nfsd4_dec)nfsd4_decode_create,

1523

[OP_DELEGPURGE] = (nfsd4_dec)nfsd4_decode_notsupp,

1543

[OP_DELEGPURGE] = (nfsd4_dec)nfsd4_decode_notsupp,

1524

[OP_DELEGRETURN] = (nfsd4_dec)nfsd4_decode_delegreturn,

1544

[OP_DELEGRETURN] = (nfsd4_dec)nfsd4_decode_delegreturn,

1525

[OP_GETATTR] = (nfsd4_dec)nfsd4_decode_getattr,

1545

[OP_GETATTR] = (nfsd4_dec)nfsd4_decode_getattr,

1526

[OP_GETFH] = (nfsd4_dec)nfsd4_decode_noop,

1546

[OP_GETFH] = (nfsd4_dec)nfsd4_decode_noop,

1527

[OP_LINK] = (nfsd4_dec)nfsd4_decode_link,

1547

[OP_LINK] = (nfsd4_dec)nfsd4_decode_link,

1528

[OP_LOCK] = (nfsd4_dec)nfsd4_decode_lock,

1548

[OP_LOCK] = (nfsd4_dec)nfsd4_decode_lock,

1529

[OP_LOCKT] = (nfsd4_dec)nfsd4_decode_lockt,

1549

[OP_LOCKT] = (nfsd4_dec)nfsd4_decode_lockt,

1530

[OP_LOCKU] = (nfsd4_dec)nfsd4_decode_locku,

1550

[OP_LOCKU] = (nfsd4_dec)nfsd4_decode_locku,

1531

[OP_LOOKUP] = (nfsd4_dec)nfsd4_decode_lookup,

1551

[OP_LOOKUP] = (nfsd4_dec)nfsd4_decode_lookup,

1532

[OP_LOOKUPP] = (nfsd4_dec)nfsd4_decode_noop,

1552

[OP_LOOKUPP] = (nfsd4_dec)nfsd4_decode_noop,

1533

[OP_NVERIFY] = (nfsd4_dec)nfsd4_decode_verify,

1553

[OP_NVERIFY] = (nfsd4_dec)nfsd4_decode_verify,

1534

[OP_OPEN] = (nfsd4_dec)nfsd4_decode_open,

1554

[OP_OPEN] = (nfsd4_dec)nfsd4_decode_open,

1535

[OP_OPENATTR] = (nfsd4_dec)nfsd4_decode_notsupp,

1555

[OP_OPENATTR] = (nfsd4_dec)nfsd4_decode_notsupp,

1536

[OP_OPEN_CONFIRM] = (nfsd4_dec)nfsd4_decode_notsupp,

1556

[OP_OPEN_CONFIRM] = (nfsd4_dec)nfsd4_decode_notsupp,

1537

[OP_OPEN_DOWNGRADE] = (nfsd4_dec)nfsd4_decode_open_downgrade,

1557

[OP_OPEN_DOWNGRADE] = (nfsd4_dec)nfsd4_decode_open_downgrade,

1538

[OP_PUTFH] = (nfsd4_dec)nfsd4_decode_putfh,

1558

[OP_PUTFH] = (nfsd4_dec)nfsd4_decode_putfh,

1539

[OP_PUTPUBFH] = (nfsd4_dec)nfsd4_decode_notsupp,

1559

[OP_PUTPUBFH] = (nfsd4_dec)nfsd4_decode_notsupp,

1540

[OP_PUTROOTFH] = (nfsd4_dec)nfsd4_decode_noop,

1560

[OP_PUTROOTFH] = (nfsd4_dec)nfsd4_decode_noop,

1541

[OP_READ] = (nfsd4_dec)nfsd4_decode_read,

1561

[OP_READ] = (nfsd4_dec)nfsd4_decode_read,

1542

[OP_READDIR] = (nfsd4_dec)nfsd4_decode_readdir,

1562

[OP_READDIR] = (nfsd4_dec)nfsd4_decode_readdir,

1543

[OP_READLINK] = (nfsd4_dec)nfsd4_decode_noop,

1563

[OP_READLINK] = (nfsd4_dec)nfsd4_decode_noop,

1544

[OP_REMOVE] = (nfsd4_dec)nfsd4_decode_remove,

1564

[OP_REMOVE] = (nfsd4_dec)nfsd4_decode_remove,

1545

[OP_RENAME] = (nfsd4_dec)nfsd4_decode_rename,

1565

[OP_RENAME] = (nfsd4_dec)nfsd4_decode_rename,

1546

[OP_RENEW] = (nfsd4_dec)nfsd4_decode_notsupp,

1566

[OP_RENEW] = (nfsd4_dec)nfsd4_decode_notsupp,

1547

[OP_RESTOREFH] = (nfsd4_dec)nfsd4_decode_noop,

1567

[OP_RESTOREFH] = (nfsd4_dec)nfsd4_decode_noop,

1548

[OP_SAVEFH] = (nfsd4_dec)nfsd4_decode_noop,

1568

[OP_SAVEFH] = (nfsd4_dec)nfsd4_decode_noop,

1549

[OP_SECINFO] = (nfsd4_dec)nfsd4_decode_secinfo,

1569

[OP_SECINFO] = (nfsd4_dec)nfsd4_decode_secinfo,

1550

[OP_SETATTR] = (nfsd4_dec)nfsd4_decode_setattr,

1570

[OP_SETATTR] = (nfsd4_dec)nfsd4_decode_setattr,

1551

[OP_SETCLIENTID] = (nfsd4_dec)nfsd4_decode_notsupp,

1571

[OP_SETCLIENTID] = (nfsd4_dec)nfsd4_decode_notsupp,

1552

[OP_SETCLIENTID_CONFIRM]= (nfsd4_dec)nfsd4_decode_notsupp,

1572

[OP_SETCLIENTID_CONFIRM]= (nfsd4_dec)nfsd4_decode_notsupp,

1553

[OP_VERIFY] = (nfsd4_dec)nfsd4_decode_verify,

1573

[OP_VERIFY] = (nfsd4_dec)nfsd4_decode_verify,

1554

[OP_WRITE] = (nfsd4_dec)nfsd4_decode_write,

1574

[OP_WRITE] = (nfsd4_dec)nfsd4_decode_write,

1555

[OP_RELEASE_LOCKOWNER] = (nfsd4_dec)nfsd4_decode_notsupp,

1575

[OP_RELEASE_LOCKOWNER] = (nfsd4_dec)nfsd4_decode_notsupp,

1556

1576

1557

/* new operations for NFSv4.1 */

1577

/* new operations for NFSv4.1 */

1558

[OP_BACKCHANNEL_CTL] = (nfsd4_dec)nfsd4_decode_backchannel_ctl,

1578

[OP_BACKCHANNEL_CTL] = (nfsd4_dec)nfsd4_decode_backchannel_ctl,

1559

[OP_BIND_CONN_TO_SESSION]= (nfsd4_dec)nfsd4_decode_bind_conn_to_session,

1579

[OP_BIND_CONN_TO_SESSION]= (nfsd4_dec)nfsd4_decode_bind_conn_to_session,

1560

[OP_EXCHANGE_ID] = (nfsd4_dec)nfsd4_decode_exchange_id,

1580

[OP_EXCHANGE_ID] = (nfsd4_dec)nfsd4_decode_exchange_id,

1561

[OP_CREATE_SESSION] = (nfsd4_dec)nfsd4_decode_create_session,

1581

[OP_CREATE_SESSION] = (nfsd4_dec)nfsd4_decode_create_session,

1562

[OP_DESTROY_SESSION] = (nfsd4_dec)nfsd4_decode_destroy_session,

1582

[OP_DESTROY_SESSION] = (nfsd4_dec)nfsd4_decode_destroy_session,

1563

[OP_FREE_STATEID] = (nfsd4_dec)nfsd4_decode_free_stateid,

1583

[OP_FREE_STATEID] = (nfsd4_dec)nfsd4_decode_free_stateid,

1564

[OP_GET_DIR_DELEGATION] = (nfsd4_dec)nfsd4_decode_notsupp,

1584

[OP_GET_DIR_DELEGATION] = (nfsd4_dec)nfsd4_decode_notsupp,

1565

[OP_GETDEVICEINFO] = (nfsd4_dec)nfsd4_decode_notsupp,

1585

[OP_GETDEVICEINFO] = (nfsd4_dec)nfsd4_decode_notsupp,

1566

[OP_GETDEVICELIST] = (nfsd4_dec)nfsd4_decode_notsupp,

1586

[OP_GETDEVICELIST] = (nfsd4_dec)nfsd4_decode_notsupp,

1567

[OP_LAYOUTCOMMIT] = (nfsd4_dec)nfsd4_decode_notsupp,

1587

[OP_LAYOUTCOMMIT] = (nfsd4_dec)nfsd4_decode_notsupp,

1568

[OP_LAYOUTGET] = (nfsd4_dec)nfsd4_decode_notsupp,

1588

[OP_LAYOUTGET] = (nfsd4_dec)nfsd4_decode_notsupp,

1569

[OP_LAYOUTRETURN] = (nfsd4_dec)nfsd4_decode_notsupp,

1589

[OP_LAYOUTRETURN] = (nfsd4_dec)nfsd4_decode_notsupp,

1570

[OP_SECINFO_NO_NAME] = (nfsd4_dec)nfsd4_decode_secinfo_no_name,

1590

[OP_SECINFO_NO_NAME] = (nfsd4_dec)nfsd4_decode_secinfo_no_name,

1571

[OP_SEQUENCE] = (nfsd4_dec)nfsd4_decode_sequence,

1591

[OP_SEQUENCE] = (nfsd4_dec)nfsd4_decode_sequence,

1572

[OP_SET_SSV] = (nfsd4_dec)nfsd4_decode_notsupp,

1592

[OP_SET_SSV] = (nfsd4_dec)nfsd4_decode_notsupp,

1573

[OP_TEST_STATEID] = (nfsd4_dec)nfsd4_decode_test_stateid,

1593

[OP_TEST_STATEID] = (nfsd4_dec)nfsd4_decode_test_stateid,

1574

[OP_WANT_DELEGATION] = (nfsd4_dec)nfsd4_decode_notsupp,

1594

[OP_WANT_DELEGATION] = (nfsd4_dec)nfsd4_decode_notsupp,

1575

[OP_DESTROY_CLIENTID] = (nfsd4_dec)nfsd4_decode_destroy_clientid,

1595

[OP_DESTROY_CLIENTID] = (nfsd4_dec)nfsd4_decode_destroy_clientid,

1576

[OP_RECLAIM_COMPLETE] = (nfsd4_dec)nfsd4_decode_reclaim_complete,

1596

[OP_RECLAIM_COMPLETE] = (nfsd4_dec)nfsd4_decode_reclaim_complete,

1577

};

1597

};

1578

1598

1579

struct nfsd4_minorversion_ops {

1599

struct nfsd4_minorversion_ops {

1580

nfsd4_dec *decoders;

1600

nfsd4_dec *decoders;

1581

int nops;

1601

int nops;

1582

};

1602

};

1583

1603

1584

static struct nfsd4_minorversion_ops nfsd4_minorversion[] = {

1604

static struct nfsd4_minorversion_ops nfsd4_minorversion[] = {

1585

[0] = { nfsd4_dec_ops, ARRAY_SIZE(nfsd4_dec_ops) },

1605

[0] = { nfsd4_dec_ops, ARRAY_SIZE(nfsd4_dec_ops) },

1586

[1] = { nfsd41_dec_ops, ARRAY_SIZE(nfsd41_dec_ops) },

1606

[1] = { nfsd41_dec_ops, ARRAY_SIZE(nfsd41_dec_ops) },

1587

};

1607

};

1588

1608

1589

static __be32

1609

static __be32

1590

nfsd4_decode_compound(struct nfsd4_compoundargs *argp)

1610

nfsd4_decode_compound(struct nfsd4_compoundargs *argp)

1591

{

1611

{

1592

DECODE_HEAD;

1612

DECODE_HEAD;

1593

struct nfsd4_op *op;

1613

struct nfsd4_op *op;

1594

struct nfsd4_minorversion_ops *ops;

1614

struct nfsd4_minorversion_ops *ops;

1595

bool cachethis = false;

1615

bool cachethis = false;

1596

int i;

1616

int i;

1597

1617

1598

READ_BUF(4);

1618

READ_BUF(4);

1599

READ32(argp->taglen);

1619

READ32(argp->taglen);

1600

READ_BUF(argp->taglen + 8);

1620

READ_BUF(argp->taglen + 8);

1601

SAVEMEM(argp->tag, argp->taglen);

1621

SAVEMEM(argp->tag, argp->taglen);

1602

READ32(argp->minorversion);

1622

READ32(argp->minorversion);

1603

READ32(argp->opcnt);

1623

READ32(argp->opcnt);

1604

1624

1605

if (argp->taglen > NFSD4_MAX_TAGLEN)

1625

if (argp->taglen > NFSD4_MAX_TAGLEN)

1606

goto xdr_error;

1626

goto xdr_error;

1607

if (argp->opcnt > 100)

1627

if (argp->opcnt > 100)

1608

goto xdr_error;

1628

goto xdr_error;

1609

1629

1610

if (argp->opcnt > ARRAY_SIZE(argp->iops)) {

1630

if (argp->opcnt > ARRAY_SIZE(argp->iops)) {

1611

argp->ops = kmalloc(argp->opcnt * sizeof(*argp->ops), GFP_KERNEL);

1631

argp->ops = kmalloc(argp->opcnt * sizeof(*argp->ops), GFP_KERNEL);

1612

if (!argp->ops) {

1632

if (!argp->ops) {

1613

argp->ops = argp->iops;

1633

argp->ops = argp->iops;

1614

dprintk("nfsd: couldn't allocate room for COMPOUND\n");

1634

dprintk("nfsd: couldn't allocate room for COMPOUND\n");

1615

goto xdr_error;

1635

goto xdr_error;

1616

}

1636

}

1617

}

1637

}

1618

1638

1619

if (argp->minorversion >= ARRAY_SIZE(nfsd4_minorversion))

1639

if (argp->minorversion >= ARRAY_SIZE(nfsd4_minorversion))

1620

argp->opcnt = 0;

1640

argp->opcnt = 0;

1621

1641

1622

ops = &nfsd4_minorversion[argp->minorversion];

1642

ops = &nfsd4_minorversion[argp->minorversion];

1623

for (i = 0; i < argp->opcnt; i++) {

1643

for (i = 0; i < argp->opcnt; i++) {

1624

op = &argp->ops[i];

1644

op = &argp->ops[i];

1625

op->replay = NULL;

1645

op->replay = NULL;

1626

1646

1627

READ_BUF(4);

1647

READ_BUF(4);

1628

READ32(op->opnum);

1648

READ32(op->opnum);

1629

1649

1630

if (op->opnum >= FIRST_NFS4_OP && op->opnum <= LAST_NFS4_OP)

1650

if (op->opnum >= FIRST_NFS4_OP && op->opnum <= LAST_NFS4_OP)

1631

op->status = ops->decoders[op->opnum](argp, &op->u);

1651

op->status = ops->decoders[op->opnum](argp, &op->u);

1632

else {

1652

else {

1633

op->opnum = OP_ILLEGAL;

1653

op->opnum = OP_ILLEGAL;

1634

op->status = nfserr_op_illegal;

1654

op->status = nfserr_op_illegal;

1635

}

1655

}

1636

1656

1637

if (op->status) {

1657

if (op->status) {

1638

argp->opcnt = i+1;

1658

argp->opcnt = i+1;

1639

break;

1659

break;

1640

}

1660

}

1641

/*

1661

/*

1642

* We'll try to cache the result in the DRC if any one

1662

* We'll try to cache the result in the DRC if any one

1643

* op in the compound wants to be cached:

1663

* op in the compound wants to be cached:

1644

*/

1664

*/

1645

cachethis |= nfsd4_cache_this_op(op);

1665

cachethis |= nfsd4_cache_this_op(op);

1646

}

1666

}

1647

/* Sessions make the DRC unnecessary: */

1667

/* Sessions make the DRC unnecessary: */

1648

if (argp->minorversion)

1668

if (argp->minorversion)

1649

cachethis = false;

1669

cachethis = false;

1650

argp->rqstp->rq_cachetype = cachethis ? RC_REPLBUFF : RC_NOCACHE;

1670

argp->rqstp->rq_cachetype = cachethis ? RC_REPLBUFF : RC_NOCACHE;

1651

1671

1652

DECODE_TAIL;

1672

DECODE_TAIL;

1653

}

1673

}

1654

1674

1655

#define WRITE32(n) *p++ = htonl(n)

1675

#define WRITE32(n) *p++ = htonl(n)

1656

#define WRITE64(n) do { \

1676

#define WRITE64(n) do { \

1657

*p++ = htonl((u32)((n) >> 32)); \

1677

*p++ = htonl((u32)((n) >> 32)); \

1658

*p++ = htonl((u32)(n)); \

1678

*p++ = htonl((u32)(n)); \

1659

} while (0)

1679

} while (0)

1660

#define WRITEMEM(ptr,nbytes) do { if (nbytes > 0) { \

1680

#define WRITEMEM(ptr,nbytes) do { if (nbytes > 0) { \

1661

*(p + XDR_QUADLEN(nbytes) -1) = 0; \

1681

*(p + XDR_QUADLEN(nbytes) -1) = 0; \

1662

memcpy(p, ptr, nbytes); \

1682

memcpy(p, ptr, nbytes); \

1663

p += XDR_QUADLEN(nbytes); \

1683

p += XDR_QUADLEN(nbytes); \

1664

}} while (0)

1684

}} while (0)

1665

1685

1666

static void write32(__be32 **p, u32 n)

1686

static void write32(__be32 **p, u32 n)

1667

{

1687

{

1668

*(*p)++ = htonl(n);

1688

*(*p)++ = htonl(n);

1669

}

1689

}

1670

1690

1671

static void write64(__be32 **p, u64 n)

1691

static void write64(__be32 **p, u64 n)

1672

{

1692

{

1673

write32(p, (n >> 32));

1693

write32(p, (n >> 32));

1674

write32(p, (u32)n);

1694

write32(p, (u32)n);

1675

}

1695

}

1676

1696

1677

static void write_change(__be32 **p, struct kstat *stat, struct inode *inode)

1697

static void write_change(__be32 **p, struct kstat *stat, struct inode *inode)

1678

{

1698

{

1679

if (IS_I_VERSION(inode)) {

1699

if (IS_I_VERSION(inode)) {

1680

write64(p, inode->i_version);

1700

write64(p, inode->i_version);

1681

} else {

1701

} else {

1682

write32(p, stat->ctime.tv_sec);

1702

write32(p, stat->ctime.tv_sec);

1683

write32(p, stat->ctime.tv_nsec);

1703

write32(p, stat->ctime.tv_nsec);

1684

}

1704

}

1685

}

1705

}

1686

1706

1687

static void write_cinfo(__be32 **p, struct nfsd4_change_info *c)

1707

static void write_cinfo(__be32 **p, struct nfsd4_change_info *c)

1688

{

1708

{

1689

write32(p, c->atomic);

1709

write32(p, c->atomic);

1690

if (c->change_supported) {

1710

if (c->change_supported) {

1691

write64(p, c->before_change);

1711

write64(p, c->before_change);

1692

write64(p, c->after_change);

1712

write64(p, c->after_change);

1693

} else {

1713

} else {

1694

write32(p, c->before_ctime_sec);

1714

write32(p, c->before_ctime_sec);

1695

write32(p, c->before_ctime_nsec);

1715

write32(p, c->before_ctime_nsec);

1696

write32(p, c->after_ctime_sec);

1716

write32(p, c->after_ctime_sec);

1697

write32(p, c->after_ctime_nsec);

1717

write32(p, c->after_ctime_nsec);

1698

}

1718

}

1699

}

1719

}

1700

1720

1701

#define RESERVE_SPACE(nbytes) do { \

1721

#define RESERVE_SPACE(nbytes) do { \

1702

p = resp->p; \

1722

p = resp->p; \

1703

BUG_ON(p + XDR_QUADLEN(nbytes) > resp->end); \

1723

BUG_ON(p + XDR_QUADLEN(nbytes) > resp->end); \

1704

} while (0)

1724

} while (0)

1705

#define ADJUST_ARGS() resp->p = p

1725

#define ADJUST_ARGS() resp->p = p

1706

1726

1707

/*

1727

/*

1708

* Header routine to setup seqid operation replay cache

1728

* Header routine to setup seqid operation replay cache

1709

*/

1729

*/

1710

#define ENCODE_SEQID_OP_HEAD \

1730

#define ENCODE_SEQID_OP_HEAD \

1711

__be32 *save; \

1731

__be32 *save; \

1712

\

1732

\

1713

save = resp->p;

1733

save = resp->p;

1714

1734

1715

/*

1735

/*

1716

* Routine for encoding the result of a "seqid-mutating" NFSv4 operation. This

1736

* Routine for encoding the result of a "seqid-mutating" NFSv4 operation. This

1717

* is where sequence id's are incremented, and the replay cache is filled.

1737

* is where sequence id's are incremented, and the replay cache is filled.

1718

* Note that we increment sequence id's here, at the last moment, so we're sure

1738

* Note that we increment sequence id's here, at the last moment, so we're sure

1719

* we know whether the error to be returned is a sequence id mutating error.

1739

* we know whether the error to be returned is a sequence id mutating error.

1720

*/

1740

*/

1721

1741

1722

static void encode_seqid_op_tail(struct nfsd4_compoundres *resp, __be32 *save, __be32 nfserr)

1742

static void encode_seqid_op_tail(struct nfsd4_compoundres *resp, __be32 *save, __be32 nfserr)

1723

{

1743

{

1724

struct nfs4_stateowner *stateowner = resp->cstate.replay_owner;

1744

struct nfs4_stateowner *stateowner = resp->cstate.replay_owner;

1725

1745

1726

if (seqid_mutating_err(ntohl(nfserr)) && stateowner) {

1746

if (seqid_mutating_err(ntohl(nfserr)) && stateowner) {

1727

stateowner->so_seqid++;

1747

stateowner->so_seqid++;

1728

stateowner->so_replay.rp_status = nfserr;

1748

stateowner->so_replay.rp_status = nfserr;

1729

stateowner->so_replay.rp_buflen =

1749

stateowner->so_replay.rp_buflen =

1730

(char *)resp->p - (char *)save;

1750

(char *)resp->p - (char *)save;

1731

memcpy(stateowner->so_replay.rp_buf, save,

1751

memcpy(stateowner->so_replay.rp_buf, save,

1732

stateowner->so_replay.rp_buflen);

1752

stateowner->so_replay.rp_buflen);

1733

nfsd4_purge_closed_stateid(stateowner);

1753

nfsd4_purge_closed_stateid(stateowner);

1734

}

1754

}

1735

}

1755

}

1736

1756

1737

/* Encode as an array of strings the string given with components

1757

/* Encode as an array of strings the string given with components

1738

* separated @sep, escaped with esc_enter and esc_exit.

1758

* separated @sep, escaped with esc_enter and esc_exit.

1739

*/

1759

*/

1740

static __be32 nfsd4_encode_components_esc(char sep, char *components,

1760

static __be32 nfsd4_encode_components_esc(char sep, char *components,

1741

__be32 **pp, int *buflen,

1761

__be32 **pp, int *buflen,

1742

char esc_enter, char esc_exit)

1762

char esc_enter, char esc_exit)

1743

{

1763

{

1744

__be32 *p = *pp;

1764

__be32 *p = *pp;

1745

__be32 *countp = p;

1765

__be32 *countp = p;

1746

int strlen, count=0;

1766

int strlen, count=0;

1747

char *str, *end, *next;

1767

char *str, *end, *next;

1748

1768

1749

dprintk("nfsd4_encode_components(%s)\n", components);

1769

dprintk("nfsd4_encode_components(%s)\n", components);

1750

if ((*buflen -= 4) < 0)

1770

if ((*buflen -= 4) < 0)

1751

return nfserr_resource;

1771

return nfserr_resource;

1752

WRITE32(0); /* We will fill this in with @count later */

1772

WRITE32(0); /* We will fill this in with @count later */

1753

end = str = components;

1773

end = str = components;

1754

while (*end) {

1774

while (*end) {

1755

bool found_esc = false;

1775

bool found_esc = false;

1756

1776

1757

/* try to parse as esc_start, ..., esc_end, sep */

1777

/* try to parse as esc_start, ..., esc_end, sep */

1758

if (*str == esc_enter) {

1778

if (*str == esc_enter) {

1759

for (; *end && (*end != esc_exit); end++)

1779

for (; *end && (*end != esc_exit); end++)

1760

/* find esc_exit or end of string */;

1780

/* find esc_exit or end of string */;

1761

next = end + 1;

1781

next = end + 1;

1762

if (*end && (!*next || *next == sep)) {

1782

if (*end && (!*next || *next == sep)) {

1763

str++;

1783

str++;

1764

found_esc = true;

1784

found_esc = true;

1765

}

1785

}

1766

}

1786

}

1767

1787

1768

if (!found_esc)

1788

if (!found_esc)

1769

for (; *end && (*end != sep); end++)

1789

for (; *end && (*end != sep); end++)

1770

/* find sep or end of string */;

1790

/* find sep or end of string */;

1771

1791

1772

strlen = end - str;

1792

strlen = end - str;

1773

if (strlen) {

1793

if (strlen) {

1774

if ((*buflen -= ((XDR_QUADLEN(strlen) << 2) + 4)) < 0)

1794

if ((*buflen -= ((XDR_QUADLEN(strlen) << 2) + 4)) < 0)

1775

return nfserr_resource;

1795

return nfserr_resource;

1776

WRITE32(strlen);

1796

WRITE32(strlen);

1777

WRITEMEM(str, strlen);

1797

WRITEMEM(str, strlen);

1778

count++;

1798

count++;

1779

}

1799

}

1780

else

1800

else

1781

end++;

1801

end++;

1782

str = end;

1802

str = end;

1783

}

1803

}

1784

*pp = p;

1804

*pp = p;

1785

p = countp;

1805

p = countp;

1786

WRITE32(count);

1806

WRITE32(count);

1787

return 0;

1807

return 0;

1788

}

1808

}

1789

1809

1790

/* Encode as an array of strings the string given with components

1810

/* Encode as an array of strings the string given with components

1791

* separated @sep.

1811

* separated @sep.

1792

*/

1812

*/

1793

static __be32 nfsd4_encode_components(char sep, char *components,

1813

static __be32 nfsd4_encode_components(char sep, char *components,

1794

__be32 **pp, int *buflen)

1814

__be32 **pp, int *buflen)

1795

{

1815

{

1796

return nfsd4_encode_components_esc(sep, components, pp, buflen, 0, 0);

1816

return nfsd4_encode_components_esc(sep, components, pp, buflen, 0, 0);

1797

}

1817

}

1798

1818

1799

/*

1819

/*

1800

* encode a location element of a fs_locations structure

1820

* encode a location element of a fs_locations structure

1801

*/

1821

*/

1802

static __be32 nfsd4_encode_fs_location4(struct nfsd4_fs_location *location,

1822

static __be32 nfsd4_encode_fs_location4(struct nfsd4_fs_location *location,

1803

__be32 **pp, int *buflen)

1823

__be32 **pp, int *buflen)

1804

{

1824

{

1805

__be32 status;

1825

__be32 status;

1806

__be32 *p = *pp;

1826

__be32 *p = *pp;

1807

1827

1808

status = nfsd4_encode_components_esc(':', location->hosts, &p, buflen,

1828

status = nfsd4_encode_components_esc(':', location->hosts, &p, buflen,

1809

'[', ']');

1829

'[', ']');

1810

if (status)

1830

if (status)

1811

return status;

1831

return status;

1812

status = nfsd4_encode_components('/', location->path, &p, buflen);

1832

status = nfsd4_encode_components('/', location->path, &p, buflen);

1813

if (status)

1833

if (status)

1814

return status;

1834

return status;

1815

*pp = p;

1835

*pp = p;

1816

return 0;

1836

return 0;

1817

}

1837

}

1818

1838

1819

/*

1839

/*

1820

* Encode a path in RFC3530 'pathname4' format

1840

* Encode a path in RFC3530 'pathname4' format

1821

*/

1841

*/

1822

static __be32 nfsd4_encode_path(const struct path *root,

1842

static __be32 nfsd4_encode_path(const struct path *root,

1823

const struct path *path, __be32 **pp, int *buflen)

1843

const struct path *path, __be32 **pp, int *buflen)

1824

{

1844

{

1825

struct path cur = {

1845

struct path cur = {

1826

.mnt = path->mnt,

1846

.mnt = path->mnt,

1827

.dentry = path->dentry,

1847

.dentry = path->dentry,

1828

};

1848

};

1829

__be32 *p = *pp;

1849

__be32 *p = *pp;

1830

struct dentry **components = NULL;

1850

struct dentry **components = NULL;

1831

unsigned int ncomponents = 0;

1851

unsigned int ncomponents = 0;

1832

__be32 err = nfserr_jukebox;

1852

__be32 err = nfserr_jukebox;

1833

1853

1834

dprintk("nfsd4_encode_components(");

1854

dprintk("nfsd4_encode_components(");

1835

1855

1836

path_get(&cur);

1856

path_get(&cur);

1837

/* First walk the path up to the nfsd root, and store the

1857

/* First walk the path up to the nfsd root, and store the

1838

* dentries/path components in an array.

1858

* dentries/path components in an array.

1839

*/

1859

*/

1840

for (;;) {

1860

for (;;) {

1841

if (cur.dentry == root->dentry && cur.mnt == root->mnt)

1861

if (cur.dentry == root->dentry && cur.mnt == root->mnt)

1842

break;

1862

break;

1843

if (cur.dentry == cur.mnt->mnt_root) {

1863

if (cur.dentry == cur.mnt->mnt_root) {

1844

if (follow_up(&cur))

1864

if (follow_up(&cur))

1845

continue;

1865

continue;

1846

goto out_free;

1866

goto out_free;

1847

}

1867

}

1848

if ((ncomponents & 15) == 0) {

1868

if ((ncomponents & 15) == 0) {

1849

struct dentry **new;

1869

struct dentry **new;

1850

new = krealloc(components,

1870

new = krealloc(components,

1851

sizeof(*new) * (ncomponents + 16),

1871

sizeof(*new) * (ncomponents + 16),

1852

GFP_KERNEL);

1872

GFP_KERNEL);

1853

if (!new)

1873

if (!new)

1854

goto out_free;

1874

goto out_free;

1855

components = new;

1875

components = new;

1856

}

1876

}

1857

components[ncomponents++] = cur.dentry;

1877

components[ncomponents++] = cur.dentry;

1858

cur.dentry = dget_parent(cur.dentry);

1878

cur.dentry = dget_parent(cur.dentry);

1859

}

1879

}

1860

1880

1861

*buflen -= 4;

1881

*buflen -= 4;

1862

if (*buflen < 0)

1882

if (*buflen < 0)

1863

goto out_free;

1883

goto out_free;

1864

WRITE32(ncomponents);

1884

WRITE32(ncomponents);

1865

1885

1866

while (ncomponents) {

1886

while (ncomponents) {

1867

struct dentry *dentry = components[ncomponents - 1];

1887

struct dentry *dentry = components[ncomponents - 1];

1868

unsigned int len = dentry->d_name.len;

1888

unsigned int len = dentry->d_name.len;

1869

1889

1870

*buflen -= 4 + (XDR_QUADLEN(len) << 2);

1890

*buflen -= 4 + (XDR_QUADLEN(len) << 2);

1871

if (*buflen < 0)

1891

if (*buflen < 0)

1872

goto out_free;

1892

goto out_free;

1873

WRITE32(len);

1893

WRITE32(len);

1874

WRITEMEM(dentry->d_name.name, len);

1894

WRITEMEM(dentry->d_name.name, len);

1875

dprintk("/%s", dentry->d_name.name);

1895

dprintk("/%s", dentry->d_name.name);

1876

dput(dentry);

1896

dput(dentry);

1877

ncomponents--;

1897

ncomponents--;

1878

}

1898

}

1879

1899

1880

*pp = p;

1900

*pp = p;

1881

err = 0;

1901

err = 0;

1882

out_free:

1902

out_free:

1883

dprintk(")\n");

1903

dprintk(")\n");

1884

while (ncomponents)

1904

while (ncomponents)

1885

dput(components[--ncomponents]);

1905

dput(components[--ncomponents]);

1886

kfree(components);

1906

kfree(components);

1887

path_put(&cur);

1907

path_put(&cur);

1888

return err;

1908

return err;

1889

}

1909

}

1890

1910

1891

static __be32 nfsd4_encode_fsloc_fsroot(struct svc_rqst *rqstp,

1911

static __be32 nfsd4_encode_fsloc_fsroot(struct svc_rqst *rqstp,

1892

const struct path *path, __be32 **pp, int *buflen)

1912

const struct path *path, __be32 **pp, int *buflen)

1893

{

1913

{

1894

struct svc_export *exp_ps;

1914

struct svc_export *exp_ps;

1895

__be32 res;

1915

__be32 res;

1896

1916

1897

exp_ps = rqst_find_fsidzero_export(rqstp);

1917

exp_ps = rqst_find_fsidzero_export(rqstp);

1898

if (IS_ERR(exp_ps))

1918

if (IS_ERR(exp_ps))

1899

return nfserrno(PTR_ERR(exp_ps));

1919

return nfserrno(PTR_ERR(exp_ps));

1900

res = nfsd4_encode_path(&exp_ps->ex_path, path, pp, buflen);

1920

res = nfsd4_encode_path(&exp_ps->ex_path, path, pp, buflen);

1901

exp_put(exp_ps);

1921

exp_put(exp_ps);

1902

return res;

1922

return res;

1903

}

1923

}

1904

1924

1905

/*

1925

/*

1906

* encode a fs_locations structure

1926

* encode a fs_locations structure

1907

*/

1927

*/

1908

static __be32 nfsd4_encode_fs_locations(struct svc_rqst *rqstp,

1928

static __be32 nfsd4_encode_fs_locations(struct svc_rqst *rqstp,

1909

struct svc_export *exp,

1929

struct svc_export *exp,

1910

__be32 **pp, int *buflen)

1930

__be32 **pp, int *buflen)

1911

{

1931

{

1912

__be32 status;

1932

__be32 status;

1913

int i;

1933

int i;

1914

__be32 *p = *pp;

1934

__be32 *p = *pp;

1915

struct nfsd4_fs_locations *fslocs = &exp->ex_fslocs;

1935

struct nfsd4_fs_locations *fslocs = &exp->ex_fslocs;

1916

1936

1917

status = nfsd4_encode_fsloc_fsroot(rqstp, &exp->ex_path, &p, buflen);

1937

status = nfsd4_encode_fsloc_fsroot(rqstp, &exp->ex_path, &p, buflen);

1918

if (status)

1938

if (status)

1919

return status;

1939

return status;

1920

if ((*buflen -= 4) < 0)

1940

if ((*buflen -= 4) < 0)

1921

return nfserr_resource;

1941

return nfserr_resource;

1922

WRITE32(fslocs->locations_count);

1942

WRITE32(fslocs->locations_count);

1923

for (i=0; i<fslocs->locations_count; i++) {

1943

for (i=0; i<fslocs->locations_count; i++) {

1924

status = nfsd4_encode_fs_location4(&fslocs->locations[i],

1944

status = nfsd4_encode_fs_location4(&fslocs->locations[i],

1925

&p, buflen);

1945

&p, buflen);

1926

if (status)

1946

if (status)

1927

return status;

1947

return status;

1928

}

1948

}

1929

*pp = p;

1949

*pp = p;

1930

return 0;

1950

return 0;

1931

}

1951

}

1932

1952

1933

static u32 nfs4_file_type(umode_t mode)

1953

static u32 nfs4_file_type(umode_t mode)

1934

{

1954

{

1935

switch (mode & S_IFMT) {

1955

switch (mode & S_IFMT) {

1936

case S_IFIFO: return NF4FIFO;

1956

case S_IFIFO: return NF4FIFO;

1937

case S_IFCHR: return NF4CHR;

1957

case S_IFCHR: return NF4CHR;

1938

case S_IFDIR: return NF4DIR;

1958

case S_IFDIR: return NF4DIR;

1939

case S_IFBLK: return NF4BLK;

1959

case S_IFBLK: return NF4BLK;

1940

case S_IFLNK: return NF4LNK;

1960

case S_IFLNK: return NF4LNK;

1941

case S_IFREG: return NF4REG;

1961

case S_IFREG: return NF4REG;

1942

case S_IFSOCK: return NF4SOCK;

1962

case S_IFSOCK: return NF4SOCK;

1943

default: return NF4BAD;

1963

default: return NF4BAD;

1944

};

1964

};

1945

}

1965

}

1946

1966

1947

static __be32

1967

static __be32

1948

nfsd4_encode_name(struct svc_rqst *rqstp, int whotype, uid_t id, int group,

1968

nfsd4_encode_name(struct svc_rqst *rqstp, int whotype, uid_t id, int group,

1949

__be32 **p, int *buflen)

1969

__be32 **p, int *buflen)

1950

{

1970

{

1951

int status;

1971

int status;

1952

1972

1953

if (*buflen < (XDR_QUADLEN(IDMAP_NAMESZ) << 2) + 4)

1973

if (*buflen < (XDR_QUADLEN(IDMAP_NAMESZ) << 2) + 4)

1954

return nfserr_resource;

1974

return nfserr_resource;

1955

if (whotype != NFS4_ACL_WHO_NAMED)

1975

if (whotype != NFS4_ACL_WHO_NAMED)

1956

status = nfs4_acl_write_who(whotype, (u8 *)(*p + 1));

1976

status = nfs4_acl_write_who(whotype, (u8 *)(*p + 1));

1957

else if (group)

1977

else if (group)

1958

status = nfsd_map_gid_to_name(rqstp, id, (u8 *)(*p + 1));

1978

status = nfsd_map_gid_to_name(rqstp, id, (u8 *)(*p + 1));

1959

else

1979

else

1960

status = nfsd_map_uid_to_name(rqstp, id, (u8 *)(*p + 1));

1980

status = nfsd_map_uid_to_name(rqstp, id, (u8 *)(*p + 1));

1961

if (status < 0)

1981

if (status < 0)

1962

return nfserrno(status);

1982

return nfserrno(status);

1963

*p = xdr_encode_opaque(*p, NULL, status);

1983

*p = xdr_encode_opaque(*p, NULL, status);

1964

*buflen -= (XDR_QUADLEN(status) << 2) + 4;

1984

*buflen -= (XDR_QUADLEN(status) << 2) + 4;

1965

BUG_ON(*buflen < 0);

1985

BUG_ON(*buflen < 0);

1966

return 0;

1986

return 0;

1967

}

1987

}

1968

1988

1969

static inline __be32

1989

static inline __be32

1970

nfsd4_encode_user(struct svc_rqst *rqstp, uid_t uid, __be32 **p, int *buflen)

1990

nfsd4_encode_user(struct svc_rqst *rqstp, uid_t uid, __be32 **p, int *buflen)

1971

{

1991

{

1972

return nfsd4_encode_name(rqstp, NFS4_ACL_WHO_NAMED, uid, 0, p, buflen);

1992

return nfsd4_encode_name(rqstp, NFS4_ACL_WHO_NAMED, uid, 0, p, buflen);

1973

}

1993

}

1974

1994

1975

static inline __be32

1995

static inline __be32

1976

nfsd4_encode_group(struct svc_rqst *rqstp, uid_t gid, __be32 **p, int *buflen)

1996

nfsd4_encode_group(struct svc_rqst *rqstp, uid_t gid, __be32 **p, int *buflen)

1977

{

1997

{

1978

return nfsd4_encode_name(rqstp, NFS4_ACL_WHO_NAMED, gid, 1, p, buflen);

1998

return nfsd4_encode_name(rqstp, NFS4_ACL_WHO_NAMED, gid, 1, p, buflen);

1979

}

1999

}

1980

2000

1981

static inline __be32

2001

static inline __be32

1982

nfsd4_encode_aclname(struct svc_rqst *rqstp, int whotype, uid_t id, int group,

2002

nfsd4_encode_aclname(struct svc_rqst *rqstp, int whotype, uid_t id, int group,

1983

__be32 **p, int *buflen)

2003

__be32 **p, int *buflen)

1984

{

2004

{

1985

return nfsd4_encode_name(rqstp, whotype, id, group, p, buflen);

2005

return nfsd4_encode_name(rqstp, whotype, id, group, p, buflen);

1986

}

2006

}

1987

2007

1988

#define WORD0_ABSENT_FS_ATTRS (FATTR4_WORD0_FS_LOCATIONS | FATTR4_WORD0_FSID | \

2008

#define WORD0_ABSENT_FS_ATTRS (FATTR4_WORD0_FS_LOCATIONS | FATTR4_WORD0_FSID | \

1989

FATTR4_WORD0_RDATTR_ERROR)

2009

FATTR4_WORD0_RDATTR_ERROR)

1990

#define WORD1_ABSENT_FS_ATTRS FATTR4_WORD1_MOUNTED_ON_FILEID

2010

#define WORD1_ABSENT_FS_ATTRS FATTR4_WORD1_MOUNTED_ON_FILEID

1991

2011

1992

static __be32 fattr_handle_absent_fs(u32 *bmval0, u32 *bmval1, u32 *rdattr_err)

2012

static __be32 fattr_handle_absent_fs(u32 *bmval0, u32 *bmval1, u32 *rdattr_err)

1993

{

2013

{

1994

/* As per referral draft: */

2014

/* As per referral draft: */

1995

if (*bmval0 & ~WORD0_ABSENT_FS_ATTRS ||

2015

if (*bmval0 & ~WORD0_ABSENT_FS_ATTRS ||

1996

*bmval1 & ~WORD1_ABSENT_FS_ATTRS) {

2016

*bmval1 & ~WORD1_ABSENT_FS_ATTRS) {

1997

if (*bmval0 & FATTR4_WORD0_RDATTR_ERROR ||

2017

if (*bmval0 & FATTR4_WORD0_RDATTR_ERROR ||

1998

*bmval0 & FATTR4_WORD0_FS_LOCATIONS)

2018

*bmval0 & FATTR4_WORD0_FS_LOCATIONS)

1999

*rdattr_err = NFSERR_MOVED;

2019

*rdattr_err = NFSERR_MOVED;

2000

else

2020

else

2001

return nfserr_moved;

2021

return nfserr_moved;

2002

}

2022

}

2003

*bmval0 &= WORD0_ABSENT_FS_ATTRS;

2023

*bmval0 &= WORD0_ABSENT_FS_ATTRS;

2004

*bmval1 &= WORD1_ABSENT_FS_ATTRS;

2024

*bmval1 &= WORD1_ABSENT_FS_ATTRS;

2005

return 0;

2025

return 0;

2006

}

2026

}

2007

2027

2008

2028

2009

static int get_parent_attributes(struct svc_export *exp, struct kstat *stat)

2029

static int get_parent_attributes(struct svc_export *exp, struct kstat *stat)

2010

{

2030

{

2011

struct path path = exp->ex_path;

2031

struct path path = exp->ex_path;

2012

int err;

2032

int err;

2013

2033

2014

path_get(&path);

2034

path_get(&path);

2015

while (follow_up(&path)) {

2035

while (follow_up(&path)) {

2016

if (path.dentry != path.mnt->mnt_root)

2036

if (path.dentry != path.mnt->mnt_root)

2017

break;

2037

break;

2018

}

2038

}

2019

err = vfs_getattr(path.mnt, path.dentry, stat);

2039

err = vfs_getattr(path.mnt, path.dentry, stat);

2020

path_put(&path);

2040

path_put(&path);

2021

return err;

2041

return err;

2022

}

2042

}

2023

2043

2024

/*

2044

/*

2025

* Note: @fhp can be NULL; in this case, we might have to compose the filehandle

2045

* Note: @fhp can be NULL; in this case, we might have to compose the filehandle

2026

* ourselves.

2046

* ourselves.

2027

*

2047

*

2028

* @countp is the buffer size in _words_; upon successful return this becomes

2048

* @countp is the buffer size in _words_; upon successful return this becomes

2029

* replaced with the number of words written.

2049

* replaced with the number of words written.

2030

*/

2050

*/

2031

__be32

2051

__be32

2032

nfsd4_encode_fattr(struct svc_fh *fhp, struct svc_export *exp,

2052

nfsd4_encode_fattr(struct svc_fh *fhp, struct svc_export *exp,

2033

struct dentry *dentry, __be32 *buffer, int *countp, u32 *bmval,

2053

struct dentry *dentry, __be32 *buffer, int *countp, u32 *bmval,

2034

struct svc_rqst *rqstp, int ignore_crossmnt)

2054

struct svc_rqst *rqstp, int ignore_crossmnt)

2035

{

2055

{

2036

u32 bmval0 = bmval[0];

2056

u32 bmval0 = bmval[0];

2037

u32 bmval1 = bmval[1];

2057

u32 bmval1 = bmval[1];

2038

u32 bmval2 = bmval[2];

2058

u32 bmval2 = bmval[2];

2039

struct kstat stat;

2059

struct kstat stat;

2040

struct svc_fh tempfh;

2060

struct svc_fh tempfh;

2041

struct kstatfs statfs;

2061

struct kstatfs statfs;

2042

int buflen = *countp << 2;

2062

int buflen = *countp << 2;

2043

__be32 *attrlenp;

2063

__be32 *attrlenp;

2044

u32 dummy;

2064

u32 dummy;

2045

u64 dummy64;

2065

u64 dummy64;

2046

u32 rdattr_err = 0;

2066

u32 rdattr_err = 0;

2047

__be32 *p = buffer;

2067

__be32 *p = buffer;

2048

__be32 status;

2068

__be32 status;

2049

int err;

2069

int err;

2050

int aclsupport = 0;

2070

int aclsupport = 0;

2051

struct nfs4_acl *acl = NULL;

2071

struct nfs4_acl *acl = NULL;

2052

struct nfsd4_compoundres *resp = rqstp->rq_resp;

2072

struct nfsd4_compoundres *resp = rqstp->rq_resp;

2053

u32 minorversion = resp->cstate.minorversion;

2073

u32 minorversion = resp->cstate.minorversion;

2054

struct path path = {

2074

struct path path = {

2055

.mnt = exp->ex_path.mnt,

2075

.mnt = exp->ex_path.mnt,

2056

.dentry = dentry,

2076

.dentry = dentry,

2057

};

2077

};

2058

2078

2059

BUG_ON(bmval1 & NFSD_WRITEONLY_ATTRS_WORD1);

2079

BUG_ON(bmval1 & NFSD_WRITEONLY_ATTRS_WORD1);

2060

BUG_ON(bmval0 & ~nfsd_suppattrs0(minorversion));

2080

BUG_ON(bmval0 & ~nfsd_suppattrs0(minorversion));

2061

BUG_ON(bmval1 & ~nfsd_suppattrs1(minorversion));

2081

BUG_ON(bmval1 & ~nfsd_suppattrs1(minorversion));

2062

BUG_ON(bmval2 & ~nfsd_suppattrs2(minorversion));

2082

BUG_ON(bmval2 & ~nfsd_suppattrs2(minorversion));

2063

2083

2064

if (exp->ex_fslocs.migrated) {

2084

if (exp->ex_fslocs.migrated) {

2065

BUG_ON(bmval[2]);

2085

BUG_ON(bmval[2]);

2066

status = fattr_handle_absent_fs(&bmval0, &bmval1, &rdattr_err);

2086

status = fattr_handle_absent_fs(&bmval0, &bmval1, &rdattr_err);

2067

if (status)

2087

if (status)

2068

goto out;

2088

goto out;

2069

}

2089

}

2070

2090

2071

err = vfs_getattr(exp->ex_path.mnt, dentry, &stat);

2091

err = vfs_getattr(exp->ex_path.mnt, dentry, &stat);

2072

if (err)

2092

if (err)

2073

goto out_nfserr;

2093

goto out_nfserr;

2074

if ((bmval0 & (FATTR4_WORD0_FILES_FREE | FATTR4_WORD0_FILES_TOTAL |

2094

if ((bmval0 & (FATTR4_WORD0_FILES_FREE | FATTR4_WORD0_FILES_TOTAL |

2075

FATTR4_WORD0_MAXNAME)) ||

2095

FATTR4_WORD0_MAXNAME)) ||

2076

(bmval1 & (FATTR4_WORD1_SPACE_AVAIL | FATTR4_WORD1_SPACE_FREE |

2096

(bmval1 & (FATTR4_WORD1_SPACE_AVAIL | FATTR4_WORD1_SPACE_FREE |

2077

FATTR4_WORD1_SPACE_TOTAL))) {

2097

FATTR4_WORD1_SPACE_TOTAL))) {

2078

err = vfs_statfs(&path, &statfs);

2098

err = vfs_statfs(&path, &statfs);

2079

if (err)

2099

if (err)

2080

goto out_nfserr;

2100

goto out_nfserr;

2081

}

2101

}

2082

if ((bmval0 & (FATTR4_WORD0_FILEHANDLE | FATTR4_WORD0_FSID)) && !fhp) {

2102

if ((bmval0 & (FATTR4_WORD0_FILEHANDLE | FATTR4_WORD0_FSID)) && !fhp) {

2083

fh_init(&tempfh, NFS4_FHSIZE);

2103

fh_init(&tempfh, NFS4_FHSIZE);

2084

status = fh_compose(&tempfh, exp, dentry, NULL);

2104

status = fh_compose(&tempfh, exp, dentry, NULL);

2085

if (status)

2105

if (status)

2086

goto out;

2106

goto out;

2087

fhp = &tempfh;

2107

fhp = &tempfh;

2088

}

2108

}

2089

if (bmval0 & (FATTR4_WORD0_ACL | FATTR4_WORD0_ACLSUPPORT

2109

if (bmval0 & (FATTR4_WORD0_ACL | FATTR4_WORD0_ACLSUPPORT

2090

| FATTR4_WORD0_SUPPORTED_ATTRS)) {

2110

| FATTR4_WORD0_SUPPORTED_ATTRS)) {

2091

err = nfsd4_get_nfs4_acl(rqstp, dentry, &acl);

2111

err = nfsd4_get_nfs4_acl(rqstp, dentry, &acl);

2092

aclsupport = (err == 0);

2112

aclsupport = (err == 0);

2093

if (bmval0 & FATTR4_WORD0_ACL) {

2113

if (bmval0 & FATTR4_WORD0_ACL) {

2094

if (err == -EOPNOTSUPP)

2114

if (err == -EOPNOTSUPP)

2095

bmval0 &= ~FATTR4_WORD0_ACL;

2115

bmval0 &= ~FATTR4_WORD0_ACL;

2096

else if (err == -EINVAL) {

2116

else if (err == -EINVAL) {

2097

status = nfserr_attrnotsupp;

2117

status = nfserr_attrnotsupp;

2098

goto out;

2118

goto out;

2099

} else if (err != 0)

2119

} else if (err != 0)

2100

goto out_nfserr;

2120

goto out_nfserr;

2101

}

2121

}

2102

}

2122

}

2103

2123

2104

if (bmval2) {

2124

if (bmval2) {

2105

if ((buflen -= 16) < 0)

2125

if ((buflen -= 16) < 0)

2106

goto out_resource;

2126

goto out_resource;

2107

WRITE32(3);

2127

WRITE32(3);

2108

WRITE32(bmval0);

2128

WRITE32(bmval0);

2109

WRITE32(bmval1);

2129

WRITE32(bmval1);

2110

WRITE32(bmval2);

2130

WRITE32(bmval2);

2111

} else if (bmval1) {

2131

} else if (bmval1) {

2112

if ((buflen -= 12) < 0)

2132

if ((buflen -= 12) < 0)

2113

goto out_resource;

2133

goto out_resource;

2114

WRITE32(2);

2134

WRITE32(2);

2115

WRITE32(bmval0);

2135

WRITE32(bmval0);

2116

WRITE32(bmval1);

2136

WRITE32(bmval1);

2117

} else {

2137

} else {

2118

if ((buflen -= 8) < 0)

2138

if ((buflen -= 8) < 0)

2119

goto out_resource;

2139

goto out_resource;

2120

WRITE32(1);

2140

WRITE32(1);

2121

WRITE32(bmval0);

2141

WRITE32(bmval0);

2122

}

2142

}

2123

attrlenp = p++; /* to be backfilled later */

2143

attrlenp = p++; /* to be backfilled later */

2124

2144

2125

if (bmval0 & FATTR4_WORD0_SUPPORTED_ATTRS) {

2145

if (bmval0 & FATTR4_WORD0_SUPPORTED_ATTRS) {

2126

u32 word0 = nfsd_suppattrs0(minorversion);

2146

u32 word0 = nfsd_suppattrs0(minorversion);

2127

u32 word1 = nfsd_suppattrs1(minorversion);

2147

u32 word1 = nfsd_suppattrs1(minorversion);

2128

u32 word2 = nfsd_suppattrs2(minorversion);

2148

u32 word2 = nfsd_suppattrs2(minorversion);

2129

2149

2130

if (!aclsupport)

2150

if (!aclsupport)

2131

word0 &= ~FATTR4_WORD0_ACL;

2151

word0 &= ~FATTR4_WORD0_ACL;

2132

if (!word2) {

2152

if (!word2) {

2133

if ((buflen -= 12) < 0)

2153

if ((buflen -= 12) < 0)

2134

goto out_resource;

2154

goto out_resource;

2135

WRITE32(2);

2155

WRITE32(2);

2136

WRITE32(word0);

2156

WRITE32(word0);

2137

WRITE32(word1);

2157

WRITE32(word1);

2138

} else {

2158

} else {

2139

if ((buflen -= 16) < 0)

2159

if ((buflen -= 16) < 0)

2140

goto out_resource;

2160

goto out_resource;

2141

WRITE32(3);

2161

WRITE32(3);

2142

WRITE32(word0);

2162

WRITE32(word0);

2143

WRITE32(word1);

2163

WRITE32(word1);

2144

WRITE32(word2);

2164

WRITE32(word2);

2145

}

2165

}

2146

}

2166

}

2147

if (bmval0 & FATTR4_WORD0_TYPE) {

2167

if (bmval0 & FATTR4_WORD0_TYPE) {

2148

if ((buflen -= 4) < 0)

2168

if ((buflen -= 4) < 0)

2149

goto out_resource;

2169

goto out_resource;

2150

dummy = nfs4_file_type(stat.mode);

2170

dummy = nfs4_file_type(stat.mode);

2151

if (dummy == NF4BAD)

2171

if (dummy == NF4BAD)

2152

goto out_serverfault;

2172

goto out_serverfault;

2153

WRITE32(dummy);

2173

WRITE32(dummy);

2154

}

2174

}

2155

if (bmval0 & FATTR4_WORD0_FH_EXPIRE_TYPE) {

2175

if (bmval0 & FATTR4_WORD0_FH_EXPIRE_TYPE) {

2156

if ((buflen -= 4) < 0)

2176

if ((buflen -= 4) < 0)

2157

goto out_resource;

2177

goto out_resource;

2158

if (exp->ex_flags & NFSEXP_NOSUBTREECHECK)

2178

if (exp->ex_flags & NFSEXP_NOSUBTREECHECK)

2159

WRITE32(NFS4_FH_PERSISTENT);

2179

WRITE32(NFS4_FH_PERSISTENT);

2160

else

2180

else

2161

WRITE32(NFS4_FH_PERSISTENT|NFS4_FH_VOL_RENAME);

2181

WRITE32(NFS4_FH_PERSISTENT|NFS4_FH_VOL_RENAME);

2162

}

2182

}

2163

if (bmval0 & FATTR4_WORD0_CHANGE) {

2183

if (bmval0 & FATTR4_WORD0_CHANGE) {

2164

if ((buflen -= 8) < 0)

2184

if ((buflen -= 8) < 0)

2165

goto out_resource;

2185

goto out_resource;

2166

write_change(&p, &stat, dentry->d_inode);

2186

write_change(&p, &stat, dentry->d_inode);

2167

}

2187

}

2168

if (bmval0 & FATTR4_WORD0_SIZE) {

2188

if (bmval0 & FATTR4_WORD0_SIZE) {

2169

if ((buflen -= 8) < 0)

2189

if ((buflen -= 8) < 0)

2170

goto out_resource;

2190

goto out_resource;

2171

WRITE64(stat.size);

2191

WRITE64(stat.size);

2172

}

2192

}

2173

if (bmval0 & FATTR4_WORD0_LINK_SUPPORT) {

2193

if (bmval0 & FATTR4_WORD0_LINK_SUPPORT) {

2174

if ((buflen -= 4) < 0)

2194

if ((buflen -= 4) < 0)

2175

goto out_resource;

2195

goto out_resource;

2176

WRITE32(1);

2196

WRITE32(1);

2177

}

2197

}

2178

if (bmval0 & FATTR4_WORD0_SYMLINK_SUPPORT) {

2198

if (bmval0 & FATTR4_WORD0_SYMLINK_SUPPORT) {

2179

if ((buflen -= 4) < 0)

2199

if ((buflen -= 4) < 0)

2180

goto out_resource;

2200

goto out_resource;

2181

WRITE32(1);

2201

WRITE32(1);

2182

}

2202

}

2183

if (bmval0 & FATTR4_WORD0_NAMED_ATTR) {

2203

if (bmval0 & FATTR4_WORD0_NAMED_ATTR) {

2184

if ((buflen -= 4) < 0)

2204

if ((buflen -= 4) < 0)

2185

goto out_resource;

2205

goto out_resource;

2186

WRITE32(0);

2206

WRITE32(0);

2187

}

2207

}

2188

if (bmval0 & FATTR4_WORD0_FSID) {

2208

if (bmval0 & FATTR4_WORD0_FSID) {

2189

if ((buflen -= 16) < 0)

2209

if ((buflen -= 16) < 0)

2190

goto out_resource;

2210

goto out_resource;

2191

if (exp->ex_fslocs.migrated) {

2211

if (exp->ex_fslocs.migrated) {

2192

WRITE64(NFS4_REFERRAL_FSID_MAJOR);

2212

WRITE64(NFS4_REFERRAL_FSID_MAJOR);

2193

WRITE64(NFS4_REFERRAL_FSID_MINOR);

2213

WRITE64(NFS4_REFERRAL_FSID_MINOR);

2194

} else switch(fsid_source(fhp)) {

2214

} else switch(fsid_source(fhp)) {

2195

case FSIDSOURCE_FSID:

2215

case FSIDSOURCE_FSID:

2196

WRITE64((u64)exp->ex_fsid);

2216

WRITE64((u64)exp->ex_fsid);

2197

WRITE64((u64)0);

2217

WRITE64((u64)0);

2198

break;

2218

break;

2199

case FSIDSOURCE_DEV:

2219

case FSIDSOURCE_DEV:

2200

WRITE32(0);

2220

WRITE32(0);

2201

WRITE32(MAJOR(stat.dev));

2221

WRITE32(MAJOR(stat.dev));

2202

WRITE32(0);

2222

WRITE32(0);

2203

WRITE32(MINOR(stat.dev));

2223

WRITE32(MINOR(stat.dev));

2204

break;

2224

break;

2205

case FSIDSOURCE_UUID:

2225

case FSIDSOURCE_UUID:

2206

WRITEMEM(exp->ex_uuid, 16);

2226

WRITEMEM(exp->ex_uuid, 16);

2207

break;

2227

break;

2208

}

2228

}

2209

}

2229

}

2210

if (bmval0 & FATTR4_WORD0_UNIQUE_HANDLES) {

2230

if (bmval0 & FATTR4_WORD0_UNIQUE_HANDLES) {

2211

if ((buflen -= 4) < 0)

2231

if ((buflen -= 4) < 0)

2212

goto out_resource;

2232

goto out_resource;

2213

WRITE32(0);

2233

WRITE32(0);

2214

}

2234

}

2215

if (bmval0 & FATTR4_WORD0_LEASE_TIME) {

2235

if (bmval0 & FATTR4_WORD0_LEASE_TIME) {

2216

if ((buflen -= 4) < 0)

2236

if ((buflen -= 4) < 0)

2217

goto out_resource;

2237

goto out_resource;

2218

WRITE32(nfsd4_lease);

2238

WRITE32(nfsd4_lease);

2219

}

2239

}

2220

if (bmval0 & FATTR4_WORD0_RDATTR_ERROR) {

2240

if (bmval0 & FATTR4_WORD0_RDATTR_ERROR) {

2221

if ((buflen -= 4) < 0)

2241

if ((buflen -= 4) < 0)

2222

goto out_resource;

2242

goto out_resource;

2223

WRITE32(rdattr_err);

2243

WRITE32(rdattr_err);

2224

}

2244

}

2225

if (bmval0 & FATTR4_WORD0_ACL) {

2245

if (bmval0 & FATTR4_WORD0_ACL) {

2226

struct nfs4_ace *ace;

2246

struct nfs4_ace *ace;

2227

2247

2228

if (acl == NULL) {

2248

if (acl == NULL) {

2229

if ((buflen -= 4) < 0)

2249

if ((buflen -= 4) < 0)

2230

goto out_resource;

2250

goto out_resource;

2231

2251

2232

WRITE32(0);

2252

WRITE32(0);

2233

goto out_acl;

2253

goto out_acl;

2234

}

2254

}

2235

if ((buflen -= 4) < 0)

2255

if ((buflen -= 4) < 0)

2236

goto out_resource;

2256

goto out_resource;

2237

WRITE32(acl->naces);

2257

WRITE32(acl->naces);

2238

2258

2239

for (ace = acl->aces; ace < acl->aces + acl->naces; ace++) {

2259

for (ace = acl->aces; ace < acl->aces + acl->naces; ace++) {

2240

if ((buflen -= 4*3) < 0)

2260

if ((buflen -= 4*3) < 0)

2241

goto out_resource;

2261

goto out_resource;

2242

WRITE32(ace->type);

2262

WRITE32(ace->type);

2243

WRITE32(ace->flag);

2263

WRITE32(ace->flag);

2244

WRITE32(ace->access_mask & NFS4_ACE_MASK_ALL);

2264

WRITE32(ace->access_mask & NFS4_ACE_MASK_ALL);

2245

status = nfsd4_encode_aclname(rqstp, ace->whotype,

2265

status = nfsd4_encode_aclname(rqstp, ace->whotype,

2246

ace->who, ace->flag & NFS4_ACE_IDENTIFIER_GROUP,

2266

ace->who, ace->flag & NFS4_ACE_IDENTIFIER_GROUP,

2247

&p, &buflen);

2267

&p, &buflen);

2248

if (status == nfserr_resource)

2268

if (status == nfserr_resource)

2249

goto out_resource;

2269

goto out_resource;

2250

if (status)

2270

if (status)

2251

goto out;

2271

goto out;

2252

}

2272

}

2253

}

2273

}

2254

out_acl:

2274

out_acl:

2255

if (bmval0 & FATTR4_WORD0_ACLSUPPORT) {

2275

if (bmval0 & FATTR4_WORD0_ACLSUPPORT) {

2256

if ((buflen -= 4) < 0)

2276

if ((buflen -= 4) < 0)

2257

goto out_resource;

2277

goto out_resource;

2258

WRITE32(aclsupport ?

2278

WRITE32(aclsupport ?

2259

ACL4_SUPPORT_ALLOW_ACL|ACL4_SUPPORT_DENY_ACL : 0);

2279

ACL4_SUPPORT_ALLOW_ACL|ACL4_SUPPORT_DENY_ACL : 0);

2260

}

2280

}

2261

if (bmval0 & FATTR4_WORD0_CANSETTIME) {

2281

if (bmval0 & FATTR4_WORD0_CANSETTIME) {

2262

if ((buflen -= 4) < 0)

2282

if ((buflen -= 4) < 0)

2263

goto out_resource;

2283

goto out_resource;

2264

WRITE32(1);

2284

WRITE32(1);

2265

}

2285

}

2266

if (bmval0 & FATTR4_WORD0_CASE_INSENSITIVE) {

2286

if (bmval0 & FATTR4_WORD0_CASE_INSENSITIVE) {

2267

if ((buflen -= 4) < 0)

2287

if ((buflen -= 4) < 0)

2268

goto out_resource;

2288

goto out_resource;

2269

WRITE32(0);

2289

WRITE32(0);

2270

}

2290

}

2271

if (bmval0 & FATTR4_WORD0_CASE_PRESERVING) {

2291

if (bmval0 & FATTR4_WORD0_CASE_PRESERVING) {

2272

if ((buflen -= 4) < 0)

2292

if ((buflen -= 4) < 0)

2273

goto out_resource;

2293

goto out_resource;

2274

WRITE32(1);

2294

WRITE32(1);

2275

}

2295

}

2276

if (bmval0 & FATTR4_WORD0_CHOWN_RESTRICTED) {

2296

if (bmval0 & FATTR4_WORD0_CHOWN_RESTRICTED) {

2277

if ((buflen -= 4) < 0)

2297

if ((buflen -= 4) < 0)

2278

goto out_resource;

2298

goto out_resource;

2279

WRITE32(1);

2299

WRITE32(1);

2280

}

2300

}

2281

if (bmval0 & FATTR4_WORD0_FILEHANDLE) {

2301

if (bmval0 & FATTR4_WORD0_FILEHANDLE) {

2282

buflen -= (XDR_QUADLEN(fhp->fh_handle.fh_size) << 2) + 4;

2302

buflen -= (XDR_QUADLEN(fhp->fh_handle.fh_size) << 2) + 4;

2283

if (buflen < 0)

2303

if (buflen < 0)

2284

goto out_resource;

2304

goto out_resource;

2285

WRITE32(fhp->fh_handle.fh_size);

2305

WRITE32(fhp->fh_handle.fh_size);

2286

WRITEMEM(&fhp->fh_handle.fh_base, fhp->fh_handle.fh_size);

2306

WRITEMEM(&fhp->fh_handle.fh_base, fhp->fh_handle.fh_size);

2287

}

2307

}

2288

if (bmval0 & FATTR4_WORD0_FILEID) {

2308

if (bmval0 & FATTR4_WORD0_FILEID) {

2289

if ((buflen -= 8) < 0)

2309

if ((buflen -= 8) < 0)

2290

goto out_resource;

2310

goto out_resource;

2291

WRITE64(stat.ino);

2311

WRITE64(stat.ino);

2292

}

2312

}

2293

if (bmval0 & FATTR4_WORD0_FILES_AVAIL) {

2313

if (bmval0 & FATTR4_WORD0_FILES_AVAIL) {

2294

if ((buflen -= 8) < 0)

2314

if ((buflen -= 8) < 0)

2295

goto out_resource;

2315

goto out_resource;

2296

WRITE64((u64) statfs.f_ffree);

2316

WRITE64((u64) statfs.f_ffree);

2297

}

2317

}

2298

if (bmval0 & FATTR4_WORD0_FILES_FREE) {

2318

if (bmval0 & FATTR4_WORD0_FILES_FREE) {

2299

if ((buflen -= 8) < 0)

2319

if ((buflen -= 8) < 0)

2300

goto out_resource;

2320

goto out_resource;

2301

WRITE64((u64) statfs.f_ffree);

2321

WRITE64((u64) statfs.f_ffree);

2302

}

2322

}

2303

if (bmval0 & FATTR4_WORD0_FILES_TOTAL) {

2323

if (bmval0 & FATTR4_WORD0_FILES_TOTAL) {

2304

if ((buflen -= 8) < 0)

2324

if ((buflen -= 8) < 0)

2305

goto out_resource;

2325

goto out_resource;

2306

WRITE64((u64) statfs.f_files);

2326

WRITE64((u64) statfs.f_files);

2307

}

2327

}

2308

if (bmval0 & FATTR4_WORD0_FS_LOCATIONS) {

2328

if (bmval0 & FATTR4_WORD0_FS_LOCATIONS) {

2309

status = nfsd4_encode_fs_locations(rqstp, exp, &p, &buflen);

2329

status = nfsd4_encode_fs_locations(rqstp, exp, &p, &buflen);

2310

if (status == nfserr_resource)

2330

if (status == nfserr_resource)

2311

goto out_resource;

2331

goto out_resource;

2312

if (status)

2332

if (status)

2313

goto out;

2333

goto out;

2314

}

2334

}

2315

if (bmval0 & FATTR4_WORD0_HOMOGENEOUS) {

2335

if (bmval0 & FATTR4_WORD0_HOMOGENEOUS) {

2316

if ((buflen -= 4) < 0)

2336

if ((buflen -= 4) < 0)

2317

goto out_resource;

2337

goto out_resource;

2318

WRITE32(1);

2338

WRITE32(1);

2319

}

2339

}

2320

if (bmval0 & FATTR4_WORD0_MAXFILESIZE) {

2340

if (bmval0 & FATTR4_WORD0_MAXFILESIZE) {

2321

if ((buflen -= 8) < 0)

2341

if ((buflen -= 8) < 0)

2322

goto out_resource;

2342

goto out_resource;

2323

WRITE64(~(u64)0);

2343

WRITE64(~(u64)0);

2324

}

2344

}

2325

if (bmval0 & FATTR4_WORD0_MAXLINK) {

2345

if (bmval0 & FATTR4_WORD0_MAXLINK) {

2326

if ((buflen -= 4) < 0)

2346

if ((buflen -= 4) < 0)

2327

goto out_resource;

2347

goto out_resource;

2328

WRITE32(255);

2348

WRITE32(255);

2329

}

2349

}

2330

if (bmval0 & FATTR4_WORD0_MAXNAME) {

2350

if (bmval0 & FATTR4_WORD0_MAXNAME) {

2331

if ((buflen -= 4) < 0)

2351

if ((buflen -= 4) < 0)

2332

goto out_resource;

2352

goto out_resource;

2333

WRITE32(statfs.f_namelen);

2353

WRITE32(statfs.f_namelen);

2334

}

2354

}

2335

if (bmval0 & FATTR4_WORD0_MAXREAD) {

2355

if (bmval0 & FATTR4_WORD0_MAXREAD) {

2336

if ((buflen -= 8) < 0)

2356

if ((buflen -= 8) < 0)

2337

goto out_resource;

2357

goto out_resource;

2338

WRITE64((u64) svc_max_payload(rqstp));

2358

WRITE64((u64) svc_max_payload(rqstp));

2339

}

2359

}

2340

if (bmval0 & FATTR4_WORD0_MAXWRITE) {

2360

if (bmval0 & FATTR4_WORD0_MAXWRITE) {

2341

if ((buflen -= 8) < 0)

2361

if ((buflen -= 8) < 0)

2342

goto out_resource;

2362

goto out_resource;

2343

WRITE64((u64) svc_max_payload(rqstp));

2363

WRITE64((u64) svc_max_payload(rqstp));

2344

}

2364

}

2345

if (bmval1 & FATTR4_WORD1_MODE) {

2365

if (bmval1 & FATTR4_WORD1_MODE) {

2346

if ((buflen -= 4) < 0)

2366

if ((buflen -= 4) < 0)

2347

goto out_resource;

2367

goto out_resource;

2348

WRITE32(stat.mode & S_IALLUGO);

2368

WRITE32(stat.mode & S_IALLUGO);

2349

}

2369

}

2350

if (bmval1 & FATTR4_WORD1_NO_TRUNC) {

2370

if (bmval1 & FATTR4_WORD1_NO_TRUNC) {

2351

if ((buflen -= 4) < 0)

2371

if ((buflen -= 4) < 0)

2352

goto out_resource;

2372

goto out_resource;

2353

WRITE32(1);

2373

WRITE32(1);

2354

}

2374

}

2355

if (bmval1 & FATTR4_WORD1_NUMLINKS) {

2375

if (bmval1 & FATTR4_WORD1_NUMLINKS) {

2356

if ((buflen -= 4) < 0)

2376

if ((buflen -= 4) < 0)

2357

goto out_resource;

2377

goto out_resource;

2358

WRITE32(stat.nlink);

2378

WRITE32(stat.nlink);

2359

}

2379

}

2360

if (bmval1 & FATTR4_WORD1_OWNER) {

2380

if (bmval1 & FATTR4_WORD1_OWNER) {

2361

status = nfsd4_encode_user(rqstp, stat.uid, &p, &buflen);

2381

status = nfsd4_encode_user(rqstp, stat.uid, &p, &buflen);

2362

if (status == nfserr_resource)

2382

if (status == nfserr_resource)

2363

goto out_resource;

2383

goto out_resource;

2364

if (status)

2384

if (status)

2365

goto out;

2385

goto out;

2366

}

2386

}

2367

if (bmval1 & FATTR4_WORD1_OWNER_GROUP) {

2387

if (bmval1 & FATTR4_WORD1_OWNER_GROUP) {

2368

status = nfsd4_encode_group(rqstp, stat.gid, &p, &buflen);

2388

status = nfsd4_encode_group(rqstp, stat.gid, &p, &buflen);

2369

if (status == nfserr_resource)

2389

if (status == nfserr_resource)

2370

goto out_resource;

2390

goto out_resource;

2371

if (status)

2391

if (status)

2372

goto out;

2392

goto out;

2373

}

2393

}

2374

if (bmval1 & FATTR4_WORD1_RAWDEV) {

2394

if (bmval1 & FATTR4_WORD1_RAWDEV) {

2375

if ((buflen -= 8) < 0)

2395

if ((buflen -= 8) < 0)

2376

goto out_resource;

2396

goto out_resource;

2377

WRITE32((u32) MAJOR(stat.rdev));

2397

WRITE32((u32) MAJOR(stat.rdev));

2378

WRITE32((u32) MINOR(stat.rdev));

2398

WRITE32((u32) MINOR(stat.rdev));

2379

}

2399

}

2380

if (bmval1 & FATTR4_WORD1_SPACE_AVAIL) {

2400

if (bmval1 & FATTR4_WORD1_SPACE_AVAIL) {

2381

if ((buflen -= 8) < 0)

2401

if ((buflen -= 8) < 0)

2382

goto out_resource;

2402

goto out_resource;

2383

dummy64 = (u64)statfs.f_bavail * (u64)statfs.f_bsize;

2403

dummy64 = (u64)statfs.f_bavail * (u64)statfs.f_bsize;

2384

WRITE64(dummy64);

2404

WRITE64(dummy64);

2385

}

2405

}

2386

if (bmval1 & FATTR4_WORD1_SPACE_FREE) {

2406

if (bmval1 & FATTR4_WORD1_SPACE_FREE) {

2387

if ((buflen -= 8) < 0)

2407

if ((buflen -= 8) < 0)

2388

goto out_resource;

2408

goto out_resource;

2389

dummy64 = (u64)statfs.f_bfree * (u64)statfs.f_bsize;

2409

dummy64 = (u64)statfs.f_bfree * (u64)statfs.f_bsize;

2390

WRITE64(dummy64);

2410

WRITE64(dummy64);

2391

}

2411

}

2392

if (bmval1 & FATTR4_WORD1_SPACE_TOTAL) {

2412

if (bmval1 & FATTR4_WORD1_SPACE_TOTAL) {

2393

if ((buflen -= 8) < 0)

2413

if ((buflen -= 8) < 0)

2394

goto out_resource;

2414

goto out_resource;

2395

dummy64 = (u64)statfs.f_blocks * (u64)statfs.f_bsize;

2415

dummy64 = (u64)statfs.f_blocks * (u64)statfs.f_bsize;

2396

WRITE64(dummy64);

2416

WRITE64(dummy64);

2397

}

2417

}

2398

if (bmval1 & FATTR4_WORD1_SPACE_USED) {

2418

if (bmval1 & FATTR4_WORD1_SPACE_USED) {

2399

if ((buflen -= 8) < 0)

2419

if ((buflen -= 8) < 0)

2400

goto out_resource;

2420

goto out_resource;

2401

dummy64 = (u64)stat.blocks << 9;

2421

dummy64 = (u64)stat.blocks << 9;

2402

WRITE64(dummy64);

2422

WRITE64(dummy64);

2403

}

2423

}

2404

if (bmval1 & FATTR4_WORD1_TIME_ACCESS) {

2424

if (bmval1 & FATTR4_WORD1_TIME_ACCESS) {

2405

if ((buflen -= 12) < 0)

2425

if ((buflen -= 12) < 0)

2406

goto out_resource;

2426

goto out_resource;

2407

WRITE32(0);

2427

WRITE32(0);

2408

WRITE32(stat.atime.tv_sec);

2428

WRITE32(stat.atime.tv_sec);

2409

WRITE32(stat.atime.tv_nsec);

2429

WRITE32(stat.atime.tv_nsec);

2410

}

2430

}

2411

if (bmval1 & FATTR4_WORD1_TIME_DELTA) {

2431

if (bmval1 & FATTR4_WORD1_TIME_DELTA) {

2412

if ((buflen -= 12) < 0)

2432

if ((buflen -= 12) < 0)

2413

goto out_resource;

2433

goto out_resource;

2414

WRITE32(0);

2434

WRITE32(0);

2415

WRITE32(1);

2435

WRITE32(1);

2416

WRITE32(0);

2436

WRITE32(0);

2417

}

2437

}

2418

if (bmval1 & FATTR4_WORD1_TIME_METADATA) {

2438

if (bmval1 & FATTR4_WORD1_TIME_METADATA) {

2419

if ((buflen -= 12) < 0)

2439

if ((buflen -= 12) < 0)

2420

goto out_resource;

2440

goto out_resource;

2421

WRITE32(0);

2441

WRITE32(0);

2422

WRITE32(stat.ctime.tv_sec);

2442

WRITE32(stat.ctime.tv_sec);

2423

WRITE32(stat.ctime.tv_nsec);

2443

WRITE32(stat.ctime.tv_nsec);

2424

}

2444

}

2425

if (bmval1 & FATTR4_WORD1_TIME_MODIFY) {

2445

if (bmval1 & FATTR4_WORD1_TIME_MODIFY) {

2426

if ((buflen -= 12) < 0)

2446

if ((buflen -= 12) < 0)

2427

goto out_resource;

2447

goto out_resource;

2428

WRITE32(0);

2448

WRITE32(0);

2429

WRITE32(stat.mtime.tv_sec);

2449

WRITE32(stat.mtime.tv_sec);

2430

WRITE32(stat.mtime.tv_nsec);

2450

WRITE32(stat.mtime.tv_nsec);

2431

}

2451

}

2432

if (bmval1 & FATTR4_WORD1_MOUNTED_ON_FILEID) {

2452

if (bmval1 & FATTR4_WORD1_MOUNTED_ON_FILEID) {

2433

if ((buflen -= 8) < 0)

2453

if ((buflen -= 8) < 0)

2434

goto out_resource;

2454

goto out_resource;

2435

/*

2455

/*

2436

* Get parent's attributes if not ignoring crossmount

2456

* Get parent's attributes if not ignoring crossmount

2437

* and this is the root of a cross-mounted filesystem.

2457

* and this is the root of a cross-mounted filesystem.

2438

*/

2458

*/

2439

if (ignore_crossmnt == 0 &&

2459

if (ignore_crossmnt == 0 &&

2440

dentry == exp->ex_path.mnt->mnt_root)

2460

dentry == exp->ex_path.mnt->mnt_root)

2441

get_parent_attributes(exp, &stat);

2461

get_parent_attributes(exp, &stat);

2442

WRITE64(stat.ino);

2462

WRITE64(stat.ino);

2443

}

2463

}

2444

if (bmval2 & FATTR4_WORD2_SUPPATTR_EXCLCREAT) {

2464

if (bmval2 & FATTR4_WORD2_SUPPATTR_EXCLCREAT) {

2445

WRITE32(3);

2465

WRITE32(3);

2446

WRITE32(NFSD_SUPPATTR_EXCLCREAT_WORD0);

2466

WRITE32(NFSD_SUPPATTR_EXCLCREAT_WORD0);

2447

WRITE32(NFSD_SUPPATTR_EXCLCREAT_WORD1);

2467

WRITE32(NFSD_SUPPATTR_EXCLCREAT_WORD1);

2448

WRITE32(NFSD_SUPPATTR_EXCLCREAT_WORD2);

2468

WRITE32(NFSD_SUPPATTR_EXCLCREAT_WORD2);

2449

}

2469

}

2450

2470

2451

*attrlenp = htonl((char *)p - (char *)attrlenp - 4);

2471

*attrlenp = htonl((char *)p - (char *)attrlenp - 4);

2452

*countp = p - buffer;

2472

*countp = p - buffer;

2453

status = nfs_ok;

2473

status = nfs_ok;

2454

2474

2455

out:

2475

out:

2456

kfree(acl);

2476

kfree(acl);

2457

if (fhp == &tempfh)

2477

if (fhp == &tempfh)

2458

fh_put(&tempfh);

2478

fh_put(&tempfh);

2459

return status;

2479

return status;

2460

out_nfserr:

2480

out_nfserr:

2461

status = nfserrno(err);

2481

status = nfserrno(err);

2462

goto out;

2482

goto out;

2463

out_resource:

2483

out_resource:

2464

*countp = 0;

2484

*countp = 0;

2465

status = nfserr_resource;

2485

status = nfserr_resource;

2466

goto out;

2486

goto out;

2467

out_serverfault:

2487

out_serverfault:

2468

status = nfserr_serverfault;

2488

status = nfserr_serverfault;

2469

goto out;

2489

goto out;

2470

}

2490

}

2471

2491

2472

static inline int attributes_need_mount(u32 *bmval)

2492

static inline int attributes_need_mount(u32 *bmval)

2473

{

2493

{

2474

if (bmval[0] & ~(FATTR4_WORD0_RDATTR_ERROR | FATTR4_WORD0_LEASE_TIME))

2494

if (bmval[0] & ~(FATTR4_WORD0_RDATTR_ERROR | FATTR4_WORD0_LEASE_TIME))

2475

return 1;

2495

return 1;

2476

if (bmval[1] & ~FATTR4_WORD1_MOUNTED_ON_FILEID)

2496

if (bmval[1] & ~FATTR4_WORD1_MOUNTED_ON_FILEID)

2477

return 1;

2497

return 1;

2478

return 0;

2498

return 0;

2479

}

2499

}

2480

2500

2481

static __be32

2501

static __be32

2482

nfsd4_encode_dirent_fattr(struct nfsd4_readdir *cd,

2502

nfsd4_encode_dirent_fattr(struct nfsd4_readdir *cd,

2483

const char *name, int namlen, __be32 *p, int *buflen)

2503

const char *name, int namlen, __be32 *p, int *buflen)

2484

{

2504

{

2485

struct svc_export *exp = cd->rd_fhp->fh_export;

2505

struct svc_export *exp = cd->rd_fhp->fh_export;

2486

struct dentry *dentry;

2506

struct dentry *dentry;

2487

__be32 nfserr;

2507

__be32 nfserr;

2488

int ignore_crossmnt = 0;

2508

int ignore_crossmnt = 0;

2489

2509

2490

dentry = lookup_one_len(name, cd->rd_fhp->fh_dentry, namlen);

2510

dentry = lookup_one_len(name, cd->rd_fhp->fh_dentry, namlen);

2491

if (IS_ERR(dentry))

2511

if (IS_ERR(dentry))

2492

return nfserrno(PTR_ERR(dentry));

2512

return nfserrno(PTR_ERR(dentry));

2493

if (!dentry->d_inode) {

2513

if (!dentry->d_inode) {

2494

/*

2514

/*

2495

* nfsd_buffered_readdir drops the i_mutex between

2515

* nfsd_buffered_readdir drops the i_mutex between

2496

* readdir and calling this callback, leaving a window

2516

* readdir and calling this callback, leaving a window

2497

* where this directory entry could have gone away.

2517

* where this directory entry could have gone away.

2498

*/

2518

*/

2499

dput(dentry);

2519

dput(dentry);

2500

return nfserr_noent;

2520

return nfserr_noent;

2501

}

2521

}

2502

2522

2503

exp_get(exp);

2523

exp_get(exp);

2504

/*

2524

/*

2505

* In the case of a mountpoint, the client may be asking for

2525

* In the case of a mountpoint, the client may be asking for

2506

* attributes that are only properties of the underlying filesystem

2526

* attributes that are only properties of the underlying filesystem

2507

* as opposed to the cross-mounted file system. In such a case,

2527

* as opposed to the cross-mounted file system. In such a case,

2508

* we will not follow the cross mount and will fill the attribtutes

2528

* we will not follow the cross mount and will fill the attribtutes

2509

* directly from the mountpoint dentry.

2529

* directly from the mountpoint dentry.

2510

*/

2530

*/

2511

if (nfsd_mountpoint(dentry, exp)) {

2531

if (nfsd_mountpoint(dentry, exp)) {

2512

int err;

2532

int err;

2513

2533

2514

if (!(exp->ex_flags & NFSEXP_V4ROOT)

2534

if (!(exp->ex_flags & NFSEXP_V4ROOT)

2515

&& !attributes_need_mount(cd->rd_bmval)) {

2535

&& !attributes_need_mount(cd->rd_bmval)) {

2516

ignore_crossmnt = 1;

2536

ignore_crossmnt = 1;

2517

goto out_encode;

2537

goto out_encode;

2518

}

2538

}

2519

/*

2539

/*

2520

* Why the heck aren't we just using nfsd_lookup??

2540

* Why the heck aren't we just using nfsd_lookup??

2521

* Different "."/".." handling? Something else?

2541

* Different "."/".." handling? Something else?

2522

* At least, add a comment here to explain....

2542

* At least, add a comment here to explain....

2523

*/

2543

*/

2524

err = nfsd_cross_mnt(cd->rd_rqstp, &dentry, &exp);

2544

err = nfsd_cross_mnt(cd->rd_rqstp, &dentry, &exp);

2525

if (err) {

2545

if (err) {

2526

nfserr = nfserrno(err);

2546

nfserr = nfserrno(err);

2527

goto out_put;

2547

goto out_put;

2528

}

2548

}

2529

nfserr = check_nfsd_access(exp, cd->rd_rqstp);

2549

nfserr = check_nfsd_access(exp, cd->rd_rqstp);

2530

if (nfserr)

2550

if (nfserr)

2531

goto out_put;

2551

goto out_put;

2532

2552

2533

}

2553

}

2534

out_encode:

2554

out_encode:

2535

nfserr = nfsd4_encode_fattr(NULL, exp, dentry, p, buflen, cd->rd_bmval,

2555

nfserr = nfsd4_encode_fattr(NULL, exp, dentry, p, buflen, cd->rd_bmval,

2536

cd->rd_rqstp, ignore_crossmnt);

2556

cd->rd_rqstp, ignore_crossmnt);

2537

out_put:

2557

out_put:

2538

dput(dentry);

2558

dput(dentry);

2539

exp_put(exp);

2559

exp_put(exp);

2540

return nfserr;

2560

return nfserr;

2541

}

2561

}

2542

2562

2543

static __be32 *

2563

static __be32 *

2544

nfsd4_encode_rdattr_error(__be32 *p, int buflen, __be32 nfserr)

2564

nfsd4_encode_rdattr_error(__be32 *p, int buflen, __be32 nfserr)

2545

{

2565

{

2546

__be32 *attrlenp;

2566

__be32 *attrlenp;

2547

2567

2548

if (buflen < 6)

2568

if (buflen < 6)

2549

return NULL;

2569

return NULL;

2550

*p++ = htonl(2);

2570

*p++ = htonl(2);

2551

*p++ = htonl(FATTR4_WORD0_RDATTR_ERROR); /* bmval0 */

2571

*p++ = htonl(FATTR4_WORD0_RDATTR_ERROR); /* bmval0 */

2552

*p++ = htonl(0); /* bmval1 */

2572

*p++ = htonl(0); /* bmval1 */

2553

2573

2554

attrlenp = p++;

2574

attrlenp = p++;

2555

*p++ = nfserr; /* no htonl */

2575

*p++ = nfserr; /* no htonl */

2556

*attrlenp = htonl((char *)p - (char *)attrlenp - 4);

2576

*attrlenp = htonl((char *)p - (char *)attrlenp - 4);

2557

return p;

2577

return p;

2558

}

2578

}

2559

2579

2560

static int

2580

static int

2561

nfsd4_encode_dirent(void *ccdv, const char *name, int namlen,

2581

nfsd4_encode_dirent(void *ccdv, const char *name, int namlen,

2562

loff_t offset, u64 ino, unsigned int d_type)

2582

loff_t offset, u64 ino, unsigned int d_type)

2563

{

2583

{

2564

struct readdir_cd *ccd = ccdv;

2584

struct readdir_cd *ccd = ccdv;

2565

struct nfsd4_readdir *cd = container_of(ccd, struct nfsd4_readdir, common);

2585

struct nfsd4_readdir *cd = container_of(ccd, struct nfsd4_readdir, common);

2566

int buflen;

2586

int buflen;

2567

__be32 *p = cd->buffer;

2587

__be32 *p = cd->buffer;

2568

__be32 *cookiep;

2588

__be32 *cookiep;

2569

__be32 nfserr = nfserr_toosmall;

2589

__be32 nfserr = nfserr_toosmall;

2570

2590

2571

/* In nfsv4, "." and ".." never make it onto the wire.. */

2591

/* In nfsv4, "." and ".." never make it onto the wire.. */

2572

if (name && isdotent(name, namlen)) {

2592

if (name && isdotent(name, namlen)) {

2573

cd->common.err = nfs_ok;

2593

cd->common.err = nfs_ok;

2574

return 0;

2594

return 0;

2575

}

2595

}

2576

2596

2577

if (cd->offset)

2597

if (cd->offset)

2578

xdr_encode_hyper(cd->offset, (u64) offset);

2598

xdr_encode_hyper(cd->offset, (u64) offset);

2579

2599

2580

buflen = cd->buflen - 4 - XDR_QUADLEN(namlen);

2600

buflen = cd->buflen - 4 - XDR_QUADLEN(namlen);

2581

if (buflen < 0)

2601

if (buflen < 0)

2582

goto fail;

2602

goto fail;

2583

2603

2584

*p++ = xdr_one; /* mark entry present */

2604

*p++ = xdr_one; /* mark entry present */

2585

cookiep = p;

2605

cookiep = p;

2586

p = xdr_encode_hyper(p, NFS_OFFSET_MAX); /* offset of next entry */

2606

p = xdr_encode_hyper(p, NFS_OFFSET_MAX); /* offset of next entry */

2587

p = xdr_encode_array(p, name, namlen); /* name length & name */

2607

p = xdr_encode_array(p, name, namlen); /* name length & name */

2588

2608

2589

nfserr = nfsd4_encode_dirent_fattr(cd, name, namlen, p, &buflen);

2609

nfserr = nfsd4_encode_dirent_fattr(cd, name, namlen, p, &buflen);

2590

switch (nfserr) {

2610

switch (nfserr) {

2591

case nfs_ok:

2611

case nfs_ok:

2592

p += buflen;

2612

p += buflen;

2593

break;

2613

break;

2594

case nfserr_resource:

2614

case nfserr_resource:

2595

nfserr = nfserr_toosmall;

2615

nfserr = nfserr_toosmall;

2596

goto fail;

2616

goto fail;

2597

case nfserr_noent:

2617

case nfserr_noent:

2598

goto skip_entry;

2618

goto skip_entry;

2599

default:

2619

default:

2600

/*

2620

/*

2601

* If the client requested the RDATTR_ERROR attribute,

2621

* If the client requested the RDATTR_ERROR attribute,

2602

* we stuff the error code into this attribute

2622

* we stuff the error code into this attribute

2603

* and continue. If this attribute was not requested,

2623

* and continue. If this attribute was not requested,

2604

* then in accordance with the spec, we fail the

2624

* then in accordance with the spec, we fail the

2605

* entire READDIR operation(!)

2625

* entire READDIR operation(!)

2606

*/

2626

*/

2607

if (!(cd->rd_bmval[0] & FATTR4_WORD0_RDATTR_ERROR))

2627

if (!(cd->rd_bmval[0] & FATTR4_WORD0_RDATTR_ERROR))

2608

goto fail;

2628

goto fail;

2609

p = nfsd4_encode_rdattr_error(p, buflen, nfserr);

2629

p = nfsd4_encode_rdattr_error(p, buflen, nfserr);

2610

if (p == NULL) {

2630

if (p == NULL) {

2611

nfserr = nfserr_toosmall;

2631

nfserr = nfserr_toosmall;

2612

goto fail;

2632

goto fail;

2613

}

2633

}

2614

}

2634

}

2615

cd->buflen -= (p - cd->buffer);

2635

cd->buflen -= (p - cd->buffer);

2616

cd->buffer = p;

2636

cd->buffer = p;

2617

cd->offset = cookiep;

2637

cd->offset = cookiep;

2618

skip_entry:

2638

skip_entry:

2619

cd->common.err = nfs_ok;

2639

cd->common.err = nfs_ok;

2620

return 0;

2640

return 0;

2621

fail:

2641

fail:

2622

cd->common.err = nfserr;

2642

cd->common.err = nfserr;

2623

return -EINVAL;

2643

return -EINVAL;

2624

}

2644

}

2625

2645

2626

static void

2646

static void

2627

nfsd4_encode_stateid(struct nfsd4_compoundres *resp, stateid_t *sid)

2647

nfsd4_encode_stateid(struct nfsd4_compoundres *resp, stateid_t *sid)

2628

{

2648

{

2629

__be32 *p;

2649

__be32 *p;

2630

2650

2631

RESERVE_SPACE(sizeof(stateid_t));

2651

RESERVE_SPACE(sizeof(stateid_t));

2632

WRITE32(sid->si_generation);

2652

WRITE32(sid->si_generation);

2633

WRITEMEM(&sid->si_opaque, sizeof(stateid_opaque_t));

2653

WRITEMEM(&sid->si_opaque, sizeof(stateid_opaque_t));

2634

ADJUST_ARGS();

2654

ADJUST_ARGS();

2635

}

2655

}

2636

2656

2637

static __be32

2657

static __be32

2638

nfsd4_encode_access(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_access *access)

2658

nfsd4_encode_access(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_access *access)

2639

{

2659

{

2640

__be32 *p;

2660

__be32 *p;

2641

2661

2642

if (!nfserr) {

2662

if (!nfserr) {

2643

RESERVE_SPACE(8);

2663

RESERVE_SPACE(8);

2644

WRITE32(access->ac_supported);

2664

WRITE32(access->ac_supported);

2645

WRITE32(access->ac_resp_access);

2665

WRITE32(access->ac_resp_access);

2646

ADJUST_ARGS();

2666

ADJUST_ARGS();

2647

}

2667

}

2648

return nfserr;

2668

return nfserr;

2649

}

2669

}

2650

2670

2651

static __be32 nfsd4_encode_bind_conn_to_session(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_bind_conn_to_session *bcts)

2671

static __be32 nfsd4_encode_bind_conn_to_session(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_bind_conn_to_session *bcts)

2652

{

2672

{

2653

__be32 *p;

2673

__be32 *p;

2654

2674

2655

if (!nfserr) {

2675

if (!nfserr) {

2656

RESERVE_SPACE(NFS4_MAX_SESSIONID_LEN + 8);

2676

RESERVE_SPACE(NFS4_MAX_SESSIONID_LEN + 8);

2657

WRITEMEM(bcts->sessionid.data, NFS4_MAX_SESSIONID_LEN);

2677

WRITEMEM(bcts->sessionid.data, NFS4_MAX_SESSIONID_LEN);

2658

WRITE32(bcts->dir);

2678

WRITE32(bcts->dir);

2659

/* Sorry, we do not yet support RDMA over 4.1: */

2679

/* Sorry, we do not yet support RDMA over 4.1: */

2660

WRITE32(0);

2680

WRITE32(0);

2661

ADJUST_ARGS();

2681

ADJUST_ARGS();

2662

}

2682

}

2663

return nfserr;

2683

return nfserr;

2664

}

2684

}

2665

2685

2666

static __be32

2686

static __be32

2667

nfsd4_encode_close(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_close *close)

2687

nfsd4_encode_close(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_close *close)

2668

{

2688

{

2669

ENCODE_SEQID_OP_HEAD;

2689

ENCODE_SEQID_OP_HEAD;

2670

2690

2671

if (!nfserr)

2691

if (!nfserr)

2672

nfsd4_encode_stateid(resp, &close->cl_stateid);

2692

nfsd4_encode_stateid(resp, &close->cl_stateid);

2673

2693

2674

encode_seqid_op_tail(resp, save, nfserr);

2694

encode_seqid_op_tail(resp, save, nfserr);

2675

return nfserr;

2695

return nfserr;

2676

}

2696

}

2677

2697

2678

2698

2679

static __be32

2699

static __be32

2680

nfsd4_encode_commit(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_commit *commit)

2700

nfsd4_encode_commit(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_commit *commit)

2681

{

2701

{

2682

__be32 *p;

2702

__be32 *p;

2683

2703

2684

if (!nfserr) {

2704

if (!nfserr) {

2685

RESERVE_SPACE(NFS4_VERIFIER_SIZE);

2705

RESERVE_SPACE(NFS4_VERIFIER_SIZE);

2686

WRITEMEM(commit->co_verf.data, NFS4_VERIFIER_SIZE);

2706

WRITEMEM(commit->co_verf.data, NFS4_VERIFIER_SIZE);

2687

ADJUST_ARGS();

2707

ADJUST_ARGS();

2688

}

2708

}

2689

return nfserr;

2709

return nfserr;

2690

}

2710

}

2691

2711

2692

static __be32

2712

static __be32

2693

nfsd4_encode_create(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_create *create)

2713

nfsd4_encode_create(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_create *create)

2694

{

2714

{

2695

__be32 *p;

2715

__be32 *p;

2696

2716

2697

if (!nfserr) {

2717

if (!nfserr) {

2698

RESERVE_SPACE(32);

2718

RESERVE_SPACE(32);

2699

write_cinfo(&p, &create->cr_cinfo);

2719

write_cinfo(&p, &create->cr_cinfo);

2700

WRITE32(2);

2720

WRITE32(2);

2701

WRITE32(create->cr_bmval[0]);

2721

WRITE32(create->cr_bmval[0]);

2702

WRITE32(create->cr_bmval[1]);

2722

WRITE32(create->cr_bmval[1]);

2703

ADJUST_ARGS();

2723

ADJUST_ARGS();

2704

}

2724

}

2705

return nfserr;

2725

return nfserr;

2706

}

2726

}

2707

2727

2708

static __be32

2728

static __be32

2709

nfsd4_encode_getattr(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_getattr *getattr)

2729

nfsd4_encode_getattr(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_getattr *getattr)

2710

{

2730

{

2711

struct svc_fh *fhp = getattr->ga_fhp;

2731

struct svc_fh *fhp = getattr->ga_fhp;

2712

int buflen;

2732

int buflen;

2713

2733

2714

if (nfserr)

2734

if (nfserr)

2715

return nfserr;

2735

return nfserr;

2716

2736

2717

buflen = resp->end - resp->p - (COMPOUND_ERR_SLACK_SPACE >> 2);

2737

buflen = resp->end - resp->p - (COMPOUND_ERR_SLACK_SPACE >> 2);

2718

nfserr = nfsd4_encode_fattr(fhp, fhp->fh_export, fhp->fh_dentry,

2738

nfserr = nfsd4_encode_fattr(fhp, fhp->fh_export, fhp->fh_dentry,

2719

resp->p, &buflen, getattr->ga_bmval,

2739

resp->p, &buflen, getattr->ga_bmval,

2720

resp->rqstp, 0);

2740

resp->rqstp, 0);

2721

if (!nfserr)

2741

if (!nfserr)

2722

resp->p += buflen;

2742

resp->p += buflen;

2723

return nfserr;

2743

return nfserr;

2724

}

2744

}

2725

2745

2726

static __be32

2746

static __be32

2727

nfsd4_encode_getfh(struct nfsd4_compoundres *resp, __be32 nfserr, struct svc_fh **fhpp)

2747

nfsd4_encode_getfh(struct nfsd4_compoundres *resp, __be32 nfserr, struct svc_fh **fhpp)

2728

{

2748

{

2729

struct svc_fh *fhp = *fhpp;

2749

struct svc_fh *fhp = *fhpp;

2730

unsigned int len;

2750

unsigned int len;

2731

__be32 *p;

2751

__be32 *p;

2732

2752

2733

if (!nfserr) {

2753

if (!nfserr) {

2734

len = fhp->fh_handle.fh_size;

2754

len = fhp->fh_handle.fh_size;

2735

RESERVE_SPACE(len + 4);

2755

RESERVE_SPACE(len + 4);

2736

WRITE32(len);

2756

WRITE32(len);

2737

WRITEMEM(&fhp->fh_handle.fh_base, len);

2757

WRITEMEM(&fhp->fh_handle.fh_base, len);

2738

ADJUST_ARGS();

2758

ADJUST_ARGS();

2739

}

2759

}

2740

return nfserr;

2760

return nfserr;

2741

}

2761

}

2742

2762

2743

/*

2763

/*

2744

* Including all fields other than the name, a LOCK4denied structure requires

2764

* Including all fields other than the name, a LOCK4denied structure requires

2745

* 8(clientid) + 4(namelen) + 8(offset) + 8(length) + 4(type) = 32 bytes.

2765

* 8(clientid) + 4(namelen) + 8(offset) + 8(length) + 4(type) = 32 bytes.

2746

*/

2766

*/

2747

static void

2767

static void

2748

nfsd4_encode_lock_denied(struct nfsd4_compoundres *resp, struct nfsd4_lock_denied *ld)

2768

nfsd4_encode_lock_denied(struct nfsd4_compoundres *resp, struct nfsd4_lock_denied *ld)

2749

{

2769

{

2750

struct xdr_netobj *conf = &ld->ld_owner;

2770

struct xdr_netobj *conf = &ld->ld_owner;

2751

__be32 *p;

2771

__be32 *p;

2752

2772

2753

RESERVE_SPACE(32 + XDR_LEN(conf->len));

2773

RESERVE_SPACE(32 + XDR_LEN(conf->len));

2754

WRITE64(ld->ld_start);

2774

WRITE64(ld->ld_start);

2755

WRITE64(ld->ld_length);

2775

WRITE64(ld->ld_length);

2756

WRITE32(ld->ld_type);

2776

WRITE32(ld->ld_type);

2757

if (conf->len) {

2777

if (conf->len) {

2758

WRITEMEM(&ld->ld_clientid, 8);

2778

WRITEMEM(&ld->ld_clientid, 8);

2759

WRITE32(conf->len);

2779

WRITE32(conf->len);

2760

WRITEMEM(conf->data, conf->len);

2780

WRITEMEM(conf->data, conf->len);

2761

kfree(conf->data);

2781

kfree(conf->data);

2762

} else { /* non - nfsv4 lock in conflict, no clientid nor owner */

2782

} else { /* non - nfsv4 lock in conflict, no clientid nor owner */

2763

WRITE64((u64)0); /* clientid */

2783

WRITE64((u64)0); /* clientid */

2764

WRITE32(0); /* length of owner name */

2784

WRITE32(0); /* length of owner name */

2765

}

2785

}

2766

ADJUST_ARGS();

2786

ADJUST_ARGS();

2767

}

2787

}

2768

2788

2769

static __be32

2789

static __be32

2770

nfsd4_encode_lock(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_lock *lock)

2790

nfsd4_encode_lock(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_lock *lock)

2771

{

2791

{

2772

ENCODE_SEQID_OP_HEAD;

2792

ENCODE_SEQID_OP_HEAD;

2773

2793

2774

if (!nfserr)

2794

if (!nfserr)

2775

nfsd4_encode_stateid(resp, &lock->lk_resp_stateid);

2795

nfsd4_encode_stateid(resp, &lock->lk_resp_stateid);

2776

else if (nfserr == nfserr_denied)

2796

else if (nfserr == nfserr_denied)

2777

nfsd4_encode_lock_denied(resp, &lock->lk_denied);

2797

nfsd4_encode_lock_denied(resp, &lock->lk_denied);

2778

2798

2779

encode_seqid_op_tail(resp, save, nfserr);

2799

encode_seqid_op_tail(resp, save, nfserr);

2780

return nfserr;

2800

return nfserr;

2781

}

2801

}

2782

2802

2783

static __be32

2803

static __be32

2784

nfsd4_encode_lockt(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_lockt *lockt)

2804

nfsd4_encode_lockt(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_lockt *lockt)

2785

{

2805

{

2786

if (nfserr == nfserr_denied)

2806

if (nfserr == nfserr_denied)

2787

nfsd4_encode_lock_denied(resp, &lockt->lt_denied);

2807

nfsd4_encode_lock_denied(resp, &lockt->lt_denied);

2788

return nfserr;

2808

return nfserr;

2789

}

2809

}

2790

2810

2791

static __be32

2811

static __be32

2792

nfsd4_encode_locku(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_locku *locku)

2812

nfsd4_encode_locku(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_locku *locku)

2793

{

2813

{

2794

ENCODE_SEQID_OP_HEAD;

2814

ENCODE_SEQID_OP_HEAD;

2795

2815

2796

if (!nfserr)

2816

if (!nfserr)

2797

nfsd4_encode_stateid(resp, &locku->lu_stateid);

2817

nfsd4_encode_stateid(resp, &locku->lu_stateid);

2798

2818

2799

encode_seqid_op_tail(resp, save, nfserr);

2819

encode_seqid_op_tail(resp, save, nfserr);

2800

return nfserr;

2820

return nfserr;

2801

}

2821

}

2802

2822

2803

2823

2804

static __be32

2824

static __be32

2805

nfsd4_encode_link(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_link *link)

2825

nfsd4_encode_link(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_link *link)

2806

{

2826

{

2807

__be32 *p;

2827

__be32 *p;

2808

2828

2809

if (!nfserr) {

2829

if (!nfserr) {

2810

RESERVE_SPACE(20);

2830

RESERVE_SPACE(20);

2811

write_cinfo(&p, &link->li_cinfo);

2831

write_cinfo(&p, &link->li_cinfo);

2812

ADJUST_ARGS();

2832

ADJUST_ARGS();

2813

}

2833

}

2814

return nfserr;

2834

return nfserr;

2815

}

2835

}

2816

2836

2817

2837

2818

static __be32

2838

static __be32

2819

nfsd4_encode_open(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_open *open)

2839

nfsd4_encode_open(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_open *open)

2820

{

2840

{

2821

__be32 *p;

2841

__be32 *p;

2822

ENCODE_SEQID_OP_HEAD;

2842

ENCODE_SEQID_OP_HEAD;

2823

2843

2824

if (nfserr)

2844

if (nfserr)

2825

goto out;

2845

goto out;

2826

2846

2827

nfsd4_encode_stateid(resp, &open->op_stateid);

2847

nfsd4_encode_stateid(resp, &open->op_stateid);

2828

RESERVE_SPACE(40);

2848

RESERVE_SPACE(40);

2829

write_cinfo(&p, &open->op_cinfo);

2849

write_cinfo(&p, &open->op_cinfo);

2830

WRITE32(open->op_rflags);

2850

WRITE32(open->op_rflags);

2831

WRITE32(2);

2851

WRITE32(2);

2832

WRITE32(open->op_bmval[0]);

2852

WRITE32(open->op_bmval[0]);

2833

WRITE32(open->op_bmval[1]);

2853

WRITE32(open->op_bmval[1]);

2834

WRITE32(open->op_delegate_type);

2854

WRITE32(open->op_delegate_type);

2835

ADJUST_ARGS();

2855

ADJUST_ARGS();

2836

2856

2837

switch (open->op_delegate_type) {

2857

switch (open->op_delegate_type) {

2838

case NFS4_OPEN_DELEGATE_NONE:

2858

case NFS4_OPEN_DELEGATE_NONE:

2839

break;

2859

break;

2840

case NFS4_OPEN_DELEGATE_READ:

2860

case NFS4_OPEN_DELEGATE_READ:

2841

nfsd4_encode_stateid(resp, &open->op_delegate_stateid);

2861

nfsd4_encode_stateid(resp, &open->op_delegate_stateid);

2842

RESERVE_SPACE(20);

2862

RESERVE_SPACE(20);

2843

WRITE32(open->op_recall);

2863

WRITE32(open->op_recall);

2844

2864

2845

/*

2865

/*

2846

* TODO: ACE's in delegations

2866

* TODO: ACE's in delegations

2847

*/

2867

*/

2848

WRITE32(NFS4_ACE_ACCESS_ALLOWED_ACE_TYPE);

2868

WRITE32(NFS4_ACE_ACCESS_ALLOWED_ACE_TYPE);

2849

WRITE32(0);

2869

WRITE32(0);

2850

WRITE32(0);

2870

WRITE32(0);

2851

WRITE32(0); /* XXX: is NULL principal ok? */

2871

WRITE32(0); /* XXX: is NULL principal ok? */

2852

ADJUST_ARGS();

2872

ADJUST_ARGS();

2853

break;

2873

break;

2854

case NFS4_OPEN_DELEGATE_WRITE:

2874

case NFS4_OPEN_DELEGATE_WRITE:

2855

nfsd4_encode_stateid(resp, &open->op_delegate_stateid);

2875

nfsd4_encode_stateid(resp, &open->op_delegate_stateid);

2856

RESERVE_SPACE(32);

2876

RESERVE_SPACE(32);

2857

WRITE32(0);

2877

WRITE32(0);

2858

2878

2859

/*

2879

/*

2860

* TODO: space_limit's in delegations

2880

* TODO: space_limit's in delegations

2861

*/

2881

*/

2862

WRITE32(NFS4_LIMIT_SIZE);

2882

WRITE32(NFS4_LIMIT_SIZE);

2863

WRITE32(~(u32)0);

2883

WRITE32(~(u32)0);

2864

WRITE32(~(u32)0);

2884

WRITE32(~(u32)0);

2865

2885

2866

/*

2886

/*

2867

* TODO: ACE's in delegations

2887

* TODO: ACE's in delegations

2868

*/

2888

*/

2869

WRITE32(NFS4_ACE_ACCESS_ALLOWED_ACE_TYPE);

2889

WRITE32(NFS4_ACE_ACCESS_ALLOWED_ACE_TYPE);

2870

WRITE32(0);

2890

WRITE32(0);

2871

WRITE32(0);

2891

WRITE32(0);

2872

WRITE32(0); /* XXX: is NULL principal ok? */

2892

WRITE32(0); /* XXX: is NULL principal ok? */

2873

ADJUST_ARGS();

2893

ADJUST_ARGS();

2874

break;

2894

break;

2875

case NFS4_OPEN_DELEGATE_NONE_EXT: /* 4.1 */

2895

case NFS4_OPEN_DELEGATE_NONE_EXT: /* 4.1 */

2876

switch (open->op_why_no_deleg) {

2896

switch (open->op_why_no_deleg) {

2877

case WND4_CONTENTION:

2897

case WND4_CONTENTION:

2878

case WND4_RESOURCE:

2898

case WND4_RESOURCE:

2879

RESERVE_SPACE(8);

2899

RESERVE_SPACE(8);

2880

WRITE32(open->op_why_no_deleg);

2900

WRITE32(open->op_why_no_deleg);

2881

WRITE32(0); /* deleg signaling not supported yet */

2901

WRITE32(0); /* deleg signaling not supported yet */

2882

break;

2902

break;

2883

default:

2903

default:

2884

RESERVE_SPACE(4);

2904

RESERVE_SPACE(4);

2885

WRITE32(open->op_why_no_deleg);

2905

WRITE32(open->op_why_no_deleg);

2886

}

2906

}

2887

ADJUST_ARGS();

2907

ADJUST_ARGS();

2888

break;

2908

break;

2889

default:

2909

default:

2890

BUG();

2910

BUG();

2891

}

2911

}

2892

/* XXX save filehandle here */

2912

/* XXX save filehandle here */

2893

out:

2913

out:

2894

encode_seqid_op_tail(resp, save, nfserr);

2914

encode_seqid_op_tail(resp, save, nfserr);

2895

return nfserr;

2915

return nfserr;

2896

}

2916

}

2897

2917

2898

static __be32

2918

static __be32

2899

nfsd4_encode_open_confirm(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_open_confirm *oc)

2919

nfsd4_encode_open_confirm(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_open_confirm *oc)

2900

{

2920

{

2901

ENCODE_SEQID_OP_HEAD;

2921

ENCODE_SEQID_OP_HEAD;

2902

2922

2903

if (!nfserr)

2923

if (!nfserr)

2904

nfsd4_encode_stateid(resp, &oc->oc_resp_stateid);

2924

nfsd4_encode_stateid(resp, &oc->oc_resp_stateid);

2905

2925

2906

encode_seqid_op_tail(resp, save, nfserr);

2926

encode_seqid_op_tail(resp, save, nfserr);

2907

return nfserr;

2927

return nfserr;

2908

}

2928

}

2909

2929

2910

static __be32

2930

static __be32

2911

nfsd4_encode_open_downgrade(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_open_downgrade *od)

2931

nfsd4_encode_open_downgrade(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_open_downgrade *od)

2912

{

2932

{

2913

ENCODE_SEQID_OP_HEAD;

2933

ENCODE_SEQID_OP_HEAD;

2914

2934

2915

if (!nfserr)

2935

if (!nfserr)

2916

nfsd4_encode_stateid(resp, &od->od_stateid);

2936

nfsd4_encode_stateid(resp, &od->od_stateid);

2917

2937

2918

encode_seqid_op_tail(resp, save, nfserr);

2938

encode_seqid_op_tail(resp, save, nfserr);

2919

return nfserr;

2939

return nfserr;

2920

}

2940

}

2921

2941

2922

static __be32

2942

static __be32

2923

nfsd4_encode_read(struct nfsd4_compoundres *resp, __be32 nfserr,

2943

nfsd4_encode_read(struct nfsd4_compoundres *resp, __be32 nfserr,

2924

struct nfsd4_read *read)

2944

struct nfsd4_read *read)

2925

{

2945

{

2926

u32 eof;

2946

u32 eof;

2927

int v, pn;

2947

int v, pn;

2928

unsigned long maxcount;

2948

unsigned long maxcount;

2929

long len;

2949

long len;

2930

__be32 *p;

2950

__be32 *p;

2931

2951

2932

if (nfserr)

2952

if (nfserr)

2933

return nfserr;

2953

return nfserr;

2934

if (resp->xbuf->page_len)

2954

if (resp->xbuf->page_len)

2935

return nfserr_resource;

2955

return nfserr_resource;

2936

2956

2937

RESERVE_SPACE(8); /* eof flag and byte count */

2957

RESERVE_SPACE(8); /* eof flag and byte count */

2938

2958

2939

maxcount = svc_max_payload(resp->rqstp);

2959

maxcount = svc_max_payload(resp->rqstp);

2940

if (maxcount > read->rd_length)

2960

if (maxcount > read->rd_length)

2941

maxcount = read->rd_length;

2961

maxcount = read->rd_length;

2942

2962

2943

len = maxcount;

2963

len = maxcount;

2944

v = 0;

2964

v = 0;

2945

while (len > 0) {

2965

while (len > 0) {

2946

pn = resp->rqstp->rq_resused++;

2966

pn = resp->rqstp->rq_resused++;

2947

resp->rqstp->rq_vec[v].iov_base =

2967

resp->rqstp->rq_vec[v].iov_base =

2948

page_address(resp->rqstp->rq_respages[pn]);

2968

page_address(resp->rqstp->rq_respages[pn]);

2949

resp->rqstp->rq_vec[v].iov_len =

2969

resp->rqstp->rq_vec[v].iov_len =

2950

len < PAGE_SIZE ? len : PAGE_SIZE;

2970

len < PAGE_SIZE ? len : PAGE_SIZE;

2951

v++;

2971

v++;

2952

len -= PAGE_SIZE;

2972

len -= PAGE_SIZE;

2953

}

2973

}

2954

read->rd_vlen = v;

2974

read->rd_vlen = v;

2955

2975

2956

nfserr = nfsd_read_file(read->rd_rqstp, read->rd_fhp, read->rd_filp,

2976

nfserr = nfsd_read_file(read->rd_rqstp, read->rd_fhp, read->rd_filp,

2957

read->rd_offset, resp->rqstp->rq_vec, read->rd_vlen,

2977

read->rd_offset, resp->rqstp->rq_vec, read->rd_vlen,

2958

&maxcount);

2978

&maxcount);

2959

2979

2960

if (nfserr)

2980

if (nfserr)

2961

return nfserr;

2981

return nfserr;

2962

eof = (read->rd_offset + maxcount >=

2982

eof = (read->rd_offset + maxcount >=

2963

read->rd_fhp->fh_dentry->d_inode->i_size);

2983

read->rd_fhp->fh_dentry->d_inode->i_size);

2964

2984

2965

WRITE32(eof);

2985

WRITE32(eof);

2966

WRITE32(maxcount);

2986

WRITE32(maxcount);

2967

ADJUST_ARGS();

2987

ADJUST_ARGS();

2968

resp->xbuf->head[0].iov_len = (char*)p

2988

resp->xbuf->head[0].iov_len = (char*)p

2969

- (char*)resp->xbuf->head[0].iov_base;

2989

- (char*)resp->xbuf->head[0].iov_base;

2970

resp->xbuf->page_len = maxcount;

2990

resp->xbuf->page_len = maxcount;

2971

2991

2972

/* Use rest of head for padding and remaining ops: */

2992

/* Use rest of head for padding and remaining ops: */

2973

resp->xbuf->tail[0].iov_base = p;

2993

resp->xbuf->tail[0].iov_base = p;

2974

resp->xbuf->tail[0].iov_len = 0;

2994

resp->xbuf->tail[0].iov_len = 0;

2975

if (maxcount&3) {

2995

if (maxcount&3) {

2976

RESERVE_SPACE(4);

2996

RESERVE_SPACE(4);

2977

WRITE32(0);

2997

WRITE32(0);

2978

resp->xbuf->tail[0].iov_base += maxcount&3;

2998

resp->xbuf->tail[0].iov_base += maxcount&3;

2979

resp->xbuf->tail[0].iov_len = 4 - (maxcount&3);

2999

resp->xbuf->tail[0].iov_len = 4 - (maxcount&3);

2980

ADJUST_ARGS();

3000

ADJUST_ARGS();

2981

}

3001

}

2982

return 0;

3002

return 0;

2983

}

3003

}

2984

3004

2985

static __be32

3005

static __be32

2986

nfsd4_encode_readlink(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_readlink *readlink)

3006

nfsd4_encode_readlink(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_readlink *readlink)

2987

{

3007

{

2988

int maxcount;

3008

int maxcount;

2989

char *page;

3009

char *page;

2990

__be32 *p;

3010

__be32 *p;

2991

3011

2992

if (nfserr)

3012

if (nfserr)

2993

return nfserr;

3013

return nfserr;

2994

if (resp->xbuf->page_len)

3014

if (resp->xbuf->page_len)

2995

return nfserr_resource;

3015

return nfserr_resource;

2996

3016

2997

page = page_address(resp->rqstp->rq_respages[resp->rqstp->rq_resused++]);

3017

page = page_address(resp->rqstp->rq_respages[resp->rqstp->rq_resused++]);

2998

3018

2999

maxcount = PAGE_SIZE;

3019

maxcount = PAGE_SIZE;

3000

RESERVE_SPACE(4);

3020

RESERVE_SPACE(4);

3001

3021

3002

/*

3022

/*

3003

* XXX: By default, the ->readlink() VFS op will truncate symlinks

3023

* XXX: By default, the ->readlink() VFS op will truncate symlinks

3004

* if they would overflow the buffer. Is this kosher in NFSv4? If

3024

* if they would overflow the buffer. Is this kosher in NFSv4? If

3005

* not, one easy fix is: if ->readlink() precisely fills the buffer,

3025

* not, one easy fix is: if ->readlink() precisely fills the buffer,

3006

* assume that truncation occurred, and return NFS4ERR_RESOURCE.

3026

* assume that truncation occurred, and return NFS4ERR_RESOURCE.

3007

*/

3027

*/

3008

nfserr = nfsd_readlink(readlink->rl_rqstp, readlink->rl_fhp, page, &maxcount);

3028

nfserr = nfsd_readlink(readlink->rl_rqstp, readlink->rl_fhp, page, &maxcount);

3009

if (nfserr == nfserr_isdir)

3029

if (nfserr == nfserr_isdir)

3010

return nfserr_inval;

3030

return nfserr_inval;

3011

if (nfserr)

3031

if (nfserr)

3012

return nfserr;

3032

return nfserr;

3013

3033

3014

WRITE32(maxcount);

3034

WRITE32(maxcount);

3015

ADJUST_ARGS();

3035

ADJUST_ARGS();

3016

resp->xbuf->head[0].iov_len = (char*)p

3036

resp->xbuf->head[0].iov_len = (char*)p

3017

- (char*)resp->xbuf->head[0].iov_base;

3037

- (char*)resp->xbuf->head[0].iov_base;

3018

resp->xbuf->page_len = maxcount;

3038

resp->xbuf->page_len = maxcount;

3019

3039

3020

/* Use rest of head for padding and remaining ops: */

3040

/* Use rest of head for padding and remaining ops: */

3021

resp->xbuf->tail[0].iov_base = p;

3041

resp->xbuf->tail[0].iov_base = p;

3022

resp->xbuf->tail[0].iov_len = 0;

3042

resp->xbuf->tail[0].iov_len = 0;

3023

if (maxcount&3) {

3043

if (maxcount&3) {

3024

RESERVE_SPACE(4);

3044

RESERVE_SPACE(4);

3025

WRITE32(0);

3045

WRITE32(0);

3026

resp->xbuf->tail[0].iov_base += maxcount&3;

3046

resp->xbuf->tail[0].iov_base += maxcount&3;

3027

resp->xbuf->tail[0].iov_len = 4 - (maxcount&3);

3047

resp->xbuf->tail[0].iov_len = 4 - (maxcount&3);

3028

ADJUST_ARGS();

3048

ADJUST_ARGS();

3029

}

3049

}

3030

return 0;

3050

return 0;

3031

}

3051

}

3032

3052

3033

static __be32

3053

static __be32

3034

nfsd4_encode_readdir(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_readdir *readdir)

3054

nfsd4_encode_readdir(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_readdir *readdir)

3035

{

3055

{

3036

int maxcount;

3056

int maxcount;

3037

loff_t offset;

3057

loff_t offset;

3038

__be32 *page, *savep, *tailbase;

3058

__be32 *page, *savep, *tailbase;

3039

__be32 *p;

3059

__be32 *p;

3040

3060

3041

if (nfserr)

3061

if (nfserr)

3042

return nfserr;

3062

return nfserr;

3043

if (resp->xbuf->page_len)

3063

if (resp->xbuf->page_len)

3044

return nfserr_resource;

3064

return nfserr_resource;

3045

3065

3046

RESERVE_SPACE(NFS4_VERIFIER_SIZE);

3066

RESERVE_SPACE(NFS4_VERIFIER_SIZE);

3047

savep = p;

3067

savep = p;

3048

3068

3049

/* XXX: Following NFSv3, we ignore the READDIR verifier for now. */

3069

/* XXX: Following NFSv3, we ignore the READDIR verifier for now. */

3050

WRITE32(0);

3070

WRITE32(0);

3051

WRITE32(0);

3071

WRITE32(0);

3052

ADJUST_ARGS();

3072

ADJUST_ARGS();

3053

resp->xbuf->head[0].iov_len = ((char*)resp->p) - (char*)resp->xbuf->head[0].iov_base;

3073

resp->xbuf->head[0].iov_len = ((char*)resp->p) - (char*)resp->xbuf->head[0].iov_base;

3054

tailbase = p;

3074

tailbase = p;

3055

3075

3056

maxcount = PAGE_SIZE;

3076

maxcount = PAGE_SIZE;

3057

if (maxcount > readdir->rd_maxcount)

3077

if (maxcount > readdir->rd_maxcount)

3058

maxcount = readdir->rd_maxcount;

3078

maxcount = readdir->rd_maxcount;

3059

3079

3060

/*

3080

/*

3061

* Convert from bytes to words, account for the two words already

3081

* Convert from bytes to words, account for the two words already

3062

* written, make sure to leave two words at the end for the next

3082

* written, make sure to leave two words at the end for the next

3063

* pointer and eof field.

3083

* pointer and eof field.

3064

*/

3084

*/

3065

maxcount = (maxcount >> 2) - 4;

3085

maxcount = (maxcount >> 2) - 4;

3066

if (maxcount < 0) {

3086

if (maxcount < 0) {

3067

nfserr = nfserr_toosmall;

3087

nfserr = nfserr_toosmall;

3068

goto err_no_verf;

3088

goto err_no_verf;

3069

}

3089

}

3070

3090

3071

page = page_address(resp->rqstp->rq_respages[resp->rqstp->rq_resused++]);

3091

page = page_address(resp->rqstp->rq_respages[resp->rqstp->rq_resused++]);

3072

readdir->common.err = 0;

3092

readdir->common.err = 0;

3073

readdir->buflen = maxcount;

3093

readdir->buflen = maxcount;

3074

readdir->buffer = page;

3094

readdir->buffer = page;

3075

readdir->offset = NULL;

3095

readdir->offset = NULL;

3076

3096

3077

offset = readdir->rd_cookie;

3097

offset = readdir->rd_cookie;

3078

nfserr = nfsd_readdir(readdir->rd_rqstp, readdir->rd_fhp,

3098

nfserr = nfsd_readdir(readdir->rd_rqstp, readdir->rd_fhp,

3079

&offset,

3099

&offset,

3080

&readdir->common, nfsd4_encode_dirent);

3100

&readdir->common, nfsd4_encode_dirent);

3081

if (nfserr == nfs_ok &&

3101

if (nfserr == nfs_ok &&

3082

readdir->common.err == nfserr_toosmall &&

3102

readdir->common.err == nfserr_toosmall &&

3083

readdir->buffer == page)

3103

readdir->buffer == page)

3084

nfserr = nfserr_toosmall;

3104

nfserr = nfserr_toosmall;

3085

if (nfserr)

3105

if (nfserr)

3086

goto err_no_verf;

3106

goto err_no_verf;

3087

3107

3088

if (readdir->offset)

3108

if (readdir->offset)

3089

xdr_encode_hyper(readdir->offset, offset);

3109

xdr_encode_hyper(readdir->offset, offset);

3090

3110

3091

p = readdir->buffer;

3111

p = readdir->buffer;

3092

*p++ = 0; /* no more entries */

3112

*p++ = 0; /* no more entries */

3093

*p++ = htonl(readdir->common.err == nfserr_eof);

3113

*p++ = htonl(readdir->common.err == nfserr_eof);

3094

resp->xbuf->page_len = ((char*)p) - (char*)page_address(

3114

resp->xbuf->page_len = ((char*)p) - (char*)page_address(

3095

resp->rqstp->rq_respages[resp->rqstp->rq_resused-1]);

3115

resp->rqstp->rq_respages[resp->rqstp->rq_resused-1]);

3096

3116

3097

/* Use rest of head for padding and remaining ops: */

3117

/* Use rest of head for padding and remaining ops: */

3098

resp->xbuf->tail[0].iov_base = tailbase;

3118

resp->xbuf->tail[0].iov_base = tailbase;

3099

resp->xbuf->tail[0].iov_len = 0;

3119

resp->xbuf->tail[0].iov_len = 0;

3100

resp->p = resp->xbuf->tail[0].iov_base;

3120

resp->p = resp->xbuf->tail[0].iov_base;

3101

resp->end = resp->p + (PAGE_SIZE - resp->xbuf->head[0].iov_len)/4;

3121

resp->end = resp->p + (PAGE_SIZE - resp->xbuf->head[0].iov_len)/4;

3102

3122

3103

return 0;

3123

return 0;

3104

err_no_verf:

3124

err_no_verf:

3105

p = savep;

3125

p = savep;

3106

ADJUST_ARGS();

3126

ADJUST_ARGS();

3107

return nfserr;

3127

return nfserr;

3108

}

3128

}

3109

3129

3110

static __be32

3130

static __be32

3111

nfsd4_encode_remove(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_remove *remove)

3131

nfsd4_encode_remove(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_remove *remove)

3112

{

3132

{

3113

__be32 *p;

3133

__be32 *p;

3114

3134

3115

if (!nfserr) {

3135

if (!nfserr) {

3116

RESERVE_SPACE(20);

3136

RESERVE_SPACE(20);

3117

write_cinfo(&p, &remove->rm_cinfo);

3137

write_cinfo(&p, &remove->rm_cinfo);

3118

ADJUST_ARGS();

3138

ADJUST_ARGS();

3119

}

3139

}

3120

return nfserr;

3140

return nfserr;

3121

}

3141

}

3122

3142

3123

static __be32

3143

static __be32

3124

nfsd4_encode_rename(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_rename *rename)

3144

nfsd4_encode_rename(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_rename *rename)

3125

{

3145

{

3126

__be32 *p;

3146

__be32 *p;

3127

3147

3128

if (!nfserr) {

3148

if (!nfserr) {

3129

RESERVE_SPACE(40);

3149

RESERVE_SPACE(40);

3130

write_cinfo(&p, &rename->rn_sinfo);

3150

write_cinfo(&p, &rename->rn_sinfo);

3131

write_cinfo(&p, &rename->rn_tinfo);

3151

write_cinfo(&p, &rename->rn_tinfo);

3132

ADJUST_ARGS();

3152

ADJUST_ARGS();

3133

}

3153

}

3134

return nfserr;

3154

return nfserr;

3135

}

3155

}

3136

3156

3137

static __be32

3157

static __be32

3138

nfsd4_do_encode_secinfo(struct nfsd4_compoundres *resp,

3158

nfsd4_do_encode_secinfo(struct nfsd4_compoundres *resp,

3139

__be32 nfserr,struct svc_export *exp)

3159

__be32 nfserr,struct svc_export *exp)

3140

{

3160

{

3141

int i = 0;

3161

int i = 0;

3142

u32 nflavs;

3162

u32 nflavs;

3143

struct exp_flavor_info *flavs;

3163

struct exp_flavor_info *flavs;

3144

struct exp_flavor_info def_flavs[2];

3164

struct exp_flavor_info def_flavs[2];

3145

__be32 *p;

3165

__be32 *p;

3146

3166

3147

if (nfserr)

3167

if (nfserr)

3148

goto out;

3168

goto out;

3149

if (exp->ex_nflavors) {

3169

if (exp->ex_nflavors) {

3150

flavs = exp->ex_flavors;

3170

flavs = exp->ex_flavors;

3151

nflavs = exp->ex_nflavors;

3171

nflavs = exp->ex_nflavors;

3152

} else { /* Handling of some defaults in absence of real secinfo: */

3172

} else { /* Handling of some defaults in absence of real secinfo: */

3153

flavs = def_flavs;

3173

flavs = def_flavs;

3154

if (exp->ex_client->flavour->flavour == RPC_AUTH_UNIX) {

3174

if (exp->ex_client->flavour->flavour == RPC_AUTH_UNIX) {

3155

nflavs = 2;

3175

nflavs = 2;

3156

flavs[0].pseudoflavor = RPC_AUTH_UNIX;

3176

flavs[0].pseudoflavor = RPC_AUTH_UNIX;

3157

flavs[1].pseudoflavor = RPC_AUTH_NULL;

3177

flavs[1].pseudoflavor = RPC_AUTH_NULL;

3158

} else if (exp->ex_client->flavour->flavour == RPC_AUTH_GSS) {

3178

} else if (exp->ex_client->flavour->flavour == RPC_AUTH_GSS) {

3159

nflavs = 1;

3179

nflavs = 1;

3160

flavs[0].pseudoflavor

3180

flavs[0].pseudoflavor

3161

= svcauth_gss_flavor(exp->ex_client);

3181

= svcauth_gss_flavor(exp->ex_client);

3162

} else {

3182

} else {

3163

nflavs = 1;

3183

nflavs = 1;

3164

flavs[0].pseudoflavor

3184

flavs[0].pseudoflavor

3165

= exp->ex_client->flavour->flavour;

3185

= exp->ex_client->flavour->flavour;

3166

}

3186

}

3167

}

3187

}

3168

3188

3169

RESERVE_SPACE(4);

3189

RESERVE_SPACE(4);

3170

WRITE32(nflavs);

3190

WRITE32(nflavs);

3171

ADJUST_ARGS();

3191

ADJUST_ARGS();

3172

for (i = 0; i < nflavs; i++) {

3192

for (i = 0; i < nflavs; i++) {

3173

u32 flav = flavs[i].pseudoflavor;

3193

u32 flav = flavs[i].pseudoflavor;

3174

struct gss_api_mech *gm = gss_mech_get_by_pseudoflavor(flav);

3194

struct gss_api_mech *gm = gss_mech_get_by_pseudoflavor(flav);

3175

3195

3176

if (gm) {

3196

if (gm) {

3177

RESERVE_SPACE(4);

3197

RESERVE_SPACE(4);

3178

WRITE32(RPC_AUTH_GSS);

3198

WRITE32(RPC_AUTH_GSS);

3179

ADJUST_ARGS();

3199

ADJUST_ARGS();

3180

RESERVE_SPACE(4 + gm->gm_oid.len);

3200

RESERVE_SPACE(4 + gm->gm_oid.len);

3181

WRITE32(gm->gm_oid.len);

3201

WRITE32(gm->gm_oid.len);

3182

WRITEMEM(gm->gm_oid.data, gm->gm_oid.len);

3202

WRITEMEM(gm->gm_oid.data, gm->gm_oid.len);

3183

ADJUST_ARGS();

3203

ADJUST_ARGS();

3184

RESERVE_SPACE(4);

3204

RESERVE_SPACE(4);

3185

WRITE32(0); /* qop */

3205

WRITE32(0); /* qop */

3186

ADJUST_ARGS();

3206

ADJUST_ARGS();

3187

RESERVE_SPACE(4);

3207

RESERVE_SPACE(4);

3188

WRITE32(gss_pseudoflavor_to_service(gm, flav));

3208

WRITE32(gss_pseudoflavor_to_service(gm, flav));

3189

ADJUST_ARGS();

3209

ADJUST_ARGS();

3190

gss_mech_put(gm);

3210

gss_mech_put(gm);

3191

} else {

3211

} else {

3192

RESERVE_SPACE(4);

3212

RESERVE_SPACE(4);

3193

WRITE32(flav);

3213

WRITE32(flav);

3194

ADJUST_ARGS();

3214

ADJUST_ARGS();

3195

}

3215

}

3196

}

3216

}

3197

out:

3217

out:

3198

if (exp)

3218

if (exp)

3199

exp_put(exp);

3219

exp_put(exp);

3200

return nfserr;

3220

return nfserr;

3201

}

3221

}

3202

3222

3203

static __be32

3223

static __be32

3204

nfsd4_encode_secinfo(struct nfsd4_compoundres *resp, __be32 nfserr,

3224

nfsd4_encode_secinfo(struct nfsd4_compoundres *resp, __be32 nfserr,

3205

struct nfsd4_secinfo *secinfo)

3225

struct nfsd4_secinfo *secinfo)

3206

{

3226

{

3207

return nfsd4_do_encode_secinfo(resp, nfserr, secinfo->si_exp);

3227

return nfsd4_do_encode_secinfo(resp, nfserr, secinfo->si_exp);

3208

}

3228

}

3209

3229

3210

static __be32

3230

static __be32

3211

nfsd4_encode_secinfo_no_name(struct nfsd4_compoundres *resp, __be32 nfserr,

3231

nfsd4_encode_secinfo_no_name(struct nfsd4_compoundres *resp, __be32 nfserr,

3212

struct nfsd4_secinfo_no_name *secinfo)

3232

struct nfsd4_secinfo_no_name *secinfo)

3213

{

3233

{

3214

return nfsd4_do_encode_secinfo(resp, nfserr, secinfo->sin_exp);

3234

return nfsd4_do_encode_secinfo(resp, nfserr, secinfo->sin_exp);

3215

}

3235

}

3216

3236

3217

/*

3237

/*

3218

* The SETATTR encode routine is special -- it always encodes a bitmap,

3238

* The SETATTR encode routine is special -- it always encodes a bitmap,

3219

* regardless of the error status.

3239

* regardless of the error status.

3220

*/

3240

*/

3221

static __be32

3241

static __be32

3222

nfsd4_encode_setattr(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_setattr *setattr)

3242

nfsd4_encode_setattr(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_setattr *setattr)

3223

{

3243

{

3224

__be32 *p;

3244

__be32 *p;

3225

3245

3226

RESERVE_SPACE(12);

3246

RESERVE_SPACE(12);

3227

if (nfserr) {

3247

if (nfserr) {

3228

WRITE32(2);

3248

WRITE32(2);

3229

WRITE32(0);

3249

WRITE32(0);

3230

WRITE32(0);

3250

WRITE32(0);

3231

}

3251

}

3232

else {

3252

else {

3233

WRITE32(2);

3253

WRITE32(2);

3234

WRITE32(setattr->sa_bmval[0]);

3254

WRITE32(setattr->sa_bmval[0]);

3235

WRITE32(setattr->sa_bmval[1]);

3255

WRITE32(setattr->sa_bmval[1]);

3236

}

3256

}

3237

ADJUST_ARGS();

3257

ADJUST_ARGS();

3238

return nfserr;

3258

return nfserr;

3239

}

3259

}

3240

3260

3241

static __be32

3261

static __be32

3242

nfsd4_encode_setclientid(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_setclientid *scd)

3262

nfsd4_encode_setclientid(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_setclientid *scd)

3243

{

3263

{

3244

__be32 *p;

3264

__be32 *p;

3245

3265

3246

if (!nfserr) {

3266

if (!nfserr) {

3247

RESERVE_SPACE(8 + NFS4_VERIFIER_SIZE);

3267

RESERVE_SPACE(8 + NFS4_VERIFIER_SIZE);

3248

WRITEMEM(&scd->se_clientid, 8);

3268

WRITEMEM(&scd->se_clientid, 8);

3249

WRITEMEM(&scd->se_confirm, NFS4_VERIFIER_SIZE);

3269

WRITEMEM(&scd->se_confirm, NFS4_VERIFIER_SIZE);

3250

ADJUST_ARGS();

3270

ADJUST_ARGS();

3251

}

3271

}

3252

else if (nfserr == nfserr_clid_inuse) {

3272

else if (nfserr == nfserr_clid_inuse) {

3253

RESERVE_SPACE(8);

3273

RESERVE_SPACE(8);

3254

WRITE32(0);

3274

WRITE32(0);

3255

WRITE32(0);

3275

WRITE32(0);

3256

ADJUST_ARGS();

3276

ADJUST_ARGS();

3257

}

3277

}

3258

return nfserr;

3278

return nfserr;

3259

}

3279

}

3260

3280

3261

static __be32

3281

static __be32

3262

nfsd4_encode_write(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_write *write)

3282

nfsd4_encode_write(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_write *write)

3263

{

3283

{

3264

__be32 *p;

3284

__be32 *p;

3265

3285

3266

if (!nfserr) {

3286

if (!nfserr) {

3267

RESERVE_SPACE(16);

3287

RESERVE_SPACE(16);

3268

WRITE32(write->wr_bytes_written);

3288

WRITE32(write->wr_bytes_written);

3269

WRITE32(write->wr_how_written);

3289

WRITE32(write->wr_how_written);

3270

WRITEMEM(write->wr_verifier.data, NFS4_VERIFIER_SIZE);

3290

WRITEMEM(write->wr_verifier.data, NFS4_VERIFIER_SIZE);

3271

ADJUST_ARGS();

3291

ADJUST_ARGS();

3272

}

3292

}

3273

return nfserr;

3293

return nfserr;

3274

}

3294

}

3275

3295

3276

static __be32

3296

static __be32

3277

nfsd4_encode_exchange_id(struct nfsd4_compoundres *resp, __be32 nfserr,

3297

nfsd4_encode_exchange_id(struct nfsd4_compoundres *resp, __be32 nfserr,

3278

struct nfsd4_exchange_id *exid)

3298

struct nfsd4_exchange_id *exid)

3279

{

3299

{

3280

__be32 *p;

3300

__be32 *p;

3281

char *major_id;

3301

char *major_id;

3282

char *server_scope;

3302

char *server_scope;

3283

int major_id_sz;

3303

int major_id_sz;

3284

int server_scope_sz;

3304

int server_scope_sz;

3285

uint64_t minor_id = 0;

3305

uint64_t minor_id = 0;

3286

3306

3287

if (nfserr)

3307

if (nfserr)

3288

return nfserr;

3308

return nfserr;

3289

3309

3290

major_id = utsname()->nodename;

3310

major_id = utsname()->nodename;

3291

major_id_sz = strlen(major_id);

3311

major_id_sz = strlen(major_id);

3292

server_scope = utsname()->nodename;

3312

server_scope = utsname()->nodename;

3293

server_scope_sz = strlen(server_scope);

3313

server_scope_sz = strlen(server_scope);

3294

3314

3295

RESERVE_SPACE(

3315

RESERVE_SPACE(

3296

8 /* eir_clientid */ +

3316

8 /* eir_clientid */ +

3297

4 /* eir_sequenceid */ +

3317

4 /* eir_sequenceid */ +

3298

4 /* eir_flags */ +

3318

4 /* eir_flags */ +

3299

4 /* spr_how (SP4_NONE) */ +

3319

4 /* spr_how (SP4_NONE) */ +

3300

8 /* so_minor_id */ +

3320

8 /* so_minor_id */ +

3301

4 /* so_major_id.len */ +

3321

4 /* so_major_id.len */ +

3302

(XDR_QUADLEN(major_id_sz) * 4) +

3322

(XDR_QUADLEN(major_id_sz) * 4) +

3303

4 /* eir_server_scope.len */ +

3323

4 /* eir_server_scope.len */ +

3304

(XDR_QUADLEN(server_scope_sz) * 4) +

3324

(XDR_QUADLEN(server_scope_sz) * 4) +

3305

4 /* eir_server_impl_id.count (0) */);

3325

4 /* eir_server_impl_id.count (0) */);

3306

3326

3307

WRITEMEM(&exid->clientid, 8);

3327

WRITEMEM(&exid->clientid, 8);

3308

WRITE32(exid->seqid);

3328

WRITE32(exid->seqid);

3309

WRITE32(exid->flags);

3329

WRITE32(exid->flags);

3310

3330

3311

/* state_protect4_r. Currently only support SP4_NONE */

3331

/* state_protect4_r. Currently only support SP4_NONE */

3312

BUG_ON(exid->spa_how != SP4_NONE);

3332

BUG_ON(exid->spa_how != SP4_NONE);

3313

WRITE32(exid->spa_how);

3333

WRITE32(exid->spa_how);

3314

3334

3315

/* The server_owner struct */

3335

/* The server_owner struct */

3316

WRITE64(minor_id); /* Minor id */

3336

WRITE64(minor_id); /* Minor id */

3317

/* major id */

3337

/* major id */

3318

WRITE32(major_id_sz);

3338

WRITE32(major_id_sz);

3319

WRITEMEM(major_id, major_id_sz);

3339

WRITEMEM(major_id, major_id_sz);

3320

3340

3321

/* Server scope */

3341

/* Server scope */

3322

WRITE32(server_scope_sz);

3342

WRITE32(server_scope_sz);

3323

WRITEMEM(server_scope, server_scope_sz);

3343

WRITEMEM(server_scope, server_scope_sz);

3324

3344

3325

/* Implementation id */

3345

/* Implementation id */

3326

WRITE32(0); /* zero length nfs_impl_id4 array */

3346

WRITE32(0); /* zero length nfs_impl_id4 array */

3327

ADJUST_ARGS();

3347

ADJUST_ARGS();

3328

return 0;

3348

return 0;

3329

}

3349

}

3330

3350

3331

static __be32

3351

static __be32

3332

nfsd4_encode_create_session(struct nfsd4_compoundres *resp, __be32 nfserr,

3352

nfsd4_encode_create_session(struct nfsd4_compoundres *resp, __be32 nfserr,

3333

struct nfsd4_create_session *sess)

3353

struct nfsd4_create_session *sess)

3334

{

3354

{

3335

__be32 *p;

3355

__be32 *p;

3336

3356

3337

if (nfserr)

3357

if (nfserr)

3338

return nfserr;

3358

return nfserr;

3339

3359

3340

RESERVE_SPACE(24);

3360

RESERVE_SPACE(24);

3341

WRITEMEM(sess->sessionid.data, NFS4_MAX_SESSIONID_LEN);

3361

WRITEMEM(sess->sessionid.data, NFS4_MAX_SESSIONID_LEN);

3342

WRITE32(sess->seqid);

3362

WRITE32(sess->seqid);

3343

WRITE32(sess->flags);

3363

WRITE32(sess->flags);

3344

ADJUST_ARGS();

3364

ADJUST_ARGS();

3345

3365

3346

RESERVE_SPACE(28);

3366

RESERVE_SPACE(28);

3347

WRITE32(0); /* headerpadsz */

3367

WRITE32(0); /* headerpadsz */

3348

WRITE32(sess->fore_channel.maxreq_sz);

3368

WRITE32(sess->fore_channel.maxreq_sz);

3349

WRITE32(sess->fore_channel.maxresp_sz);

3369

WRITE32(sess->fore_channel.maxresp_sz);

3350

WRITE32(sess->fore_channel.maxresp_cached);

3370

WRITE32(sess->fore_channel.maxresp_cached);

3351

WRITE32(sess->fore_channel.maxops);

3371

WRITE32(sess->fore_channel.maxops);

3352

WRITE32(sess->fore_channel.maxreqs);

3372

WRITE32(sess->fore_channel.maxreqs);

3353

WRITE32(sess->fore_channel.nr_rdma_attrs);

3373

WRITE32(sess->fore_channel.nr_rdma_attrs);

3354

ADJUST_ARGS();

3374

ADJUST_ARGS();

3355

3375

3356

if (sess->fore_channel.nr_rdma_attrs) {

3376

if (sess->fore_channel.nr_rdma_attrs) {

3357

RESERVE_SPACE(4);

3377

RESERVE_SPACE(4);

3358

WRITE32(sess->fore_channel.rdma_attrs);

3378

WRITE32(sess->fore_channel.rdma_attrs);

3359

ADJUST_ARGS();

3379

ADJUST_ARGS();

3360

}

3380

}

3361

3381

3362

RESERVE_SPACE(28);

3382

RESERVE_SPACE(28);

3363

WRITE32(0); /* headerpadsz */

3383

WRITE32(0); /* headerpadsz */

3364

WRITE32(sess->back_channel.maxreq_sz);

3384

WRITE32(sess->back_channel.maxreq_sz);

3365

WRITE32(sess->back_channel.maxresp_sz);

3385

WRITE32(sess->back_channel.maxresp_sz);

3366

WRITE32(sess->back_channel.maxresp_cached);

3386

WRITE32(sess->back_channel.maxresp_cached);

3367

WRITE32(sess->back_channel.maxops);

3387

WRITE32(sess->back_channel.maxops);

3368

WRITE32(sess->back_channel.maxreqs);

3388

WRITE32(sess->back_channel.maxreqs);

3369

WRITE32(sess->back_channel.nr_rdma_attrs);

3389

WRITE32(sess->back_channel.nr_rdma_attrs);

3370

ADJUST_ARGS();

3390

ADJUST_ARGS();

3371

3391

3372

if (sess->back_channel.nr_rdma_attrs) {

3392

if (sess->back_channel.nr_rdma_attrs) {

3373

RESERVE_SPACE(4);

3393

RESERVE_SPACE(4);

3374

WRITE32(sess->back_channel.rdma_attrs);

3394

WRITE32(sess->back_channel.rdma_attrs);

3375

ADJUST_ARGS();

3395

ADJUST_ARGS();

3376

}

3396

}

3377

return 0;

3397

return 0;

3378

}

3398

}

3379

3399

3380

static __be32

3400

static __be32

3381

nfsd4_encode_destroy_session(struct nfsd4_compoundres *resp, __be32 nfserr,

3401

nfsd4_encode_destroy_session(struct nfsd4_compoundres *resp, __be32 nfserr,

3382

struct nfsd4_destroy_session *destroy_session)

3402

struct nfsd4_destroy_session *destroy_session)

3383

{

3403

{

3384

return nfserr;

3404

return nfserr;

3385

}

3405

}

3386

3406

3387

static __be32

3407

static __be32

3388

nfsd4_encode_free_stateid(struct nfsd4_compoundres *resp, __be32 nfserr,

3408

nfsd4_encode_free_stateid(struct nfsd4_compoundres *resp, __be32 nfserr,

3389

struct nfsd4_free_stateid *free_stateid)

3409

struct nfsd4_free_stateid *free_stateid)

3390

{

3410

{

3391

__be32 *p;

3411

__be32 *p;

3392

3412

3393

if (nfserr)

3413

if (nfserr)

3394

return nfserr;

3414

return nfserr;

3395

3415

3396

RESERVE_SPACE(4);

3416

RESERVE_SPACE(4);

3397

*p++ = nfserr;

3417

*p++ = nfserr;

3398

ADJUST_ARGS();

3418

ADJUST_ARGS();

3399

return nfserr;

3419

return nfserr;

3400

}

3420

}

3401

3421

3402

static __be32

3422

static __be32

3403

nfsd4_encode_sequence(struct nfsd4_compoundres *resp, __be32 nfserr,

3423

nfsd4_encode_sequence(struct nfsd4_compoundres *resp, __be32 nfserr,

3404

struct nfsd4_sequence *seq)

3424

struct nfsd4_sequence *seq)

3405

{

3425

{

3406

__be32 *p;

3426

__be32 *p;

3407

3427

3408

if (nfserr)

3428

if (nfserr)

3409

return nfserr;

3429

return nfserr;

3410

3430

3411

RESERVE_SPACE(NFS4_MAX_SESSIONID_LEN + 20);

3431

RESERVE_SPACE(NFS4_MAX_SESSIONID_LEN + 20);

3412

WRITEMEM(seq->sessionid.data, NFS4_MAX_SESSIONID_LEN);

3432

WRITEMEM(seq->sessionid.data, NFS4_MAX_SESSIONID_LEN);

3413

WRITE32(seq->seqid);

3433

WRITE32(seq->seqid);

3414

WRITE32(seq->slotid);

3434

WRITE32(seq->slotid);

3415

/* Note slotid's are numbered from zero: */

3435

/* Note slotid's are numbered from zero: */

3416

WRITE32(seq->maxslots - 1); /* sr_highest_slotid */

3436

WRITE32(seq->maxslots - 1); /* sr_highest_slotid */

3417

WRITE32(seq->maxslots - 1); /* sr_target_highest_slotid */

3437

WRITE32(seq->maxslots - 1); /* sr_target_highest_slotid */

3418

WRITE32(seq->status_flags);

3438

WRITE32(seq->status_flags);

3419

3439

3420

ADJUST_ARGS();

3440

ADJUST_ARGS();

3421

resp->cstate.datap = p; /* DRC cache data pointer */

3441

resp->cstate.datap = p; /* DRC cache data pointer */

3422

return 0;

3442

return 0;

3423

}

3443

}

3424

3444

3425

static __be32

3445

static __be32

3426

nfsd4_encode_test_stateid(struct nfsd4_compoundres *resp, __be32 nfserr,

3446

nfsd4_encode_test_stateid(struct nfsd4_compoundres *resp, __be32 nfserr,

3427

struct nfsd4_test_stateid *test_stateid)

3447

struct nfsd4_test_stateid *test_stateid)

3428

{

3448

{

3429

struct nfsd4_test_stateid_id *stateid, *next;

3449

struct nfsd4_test_stateid_id *stateid, *next;

3430

__be32 *p;

3450

__be32 *p;

3431

3451

3432

RESERVE_SPACE(4 + (4 * test_stateid->ts_num_ids));

3452

RESERVE_SPACE(4 + (4 * test_stateid->ts_num_ids));

3433

*p++ = htonl(test_stateid->ts_num_ids);

3453

*p++ = htonl(test_stateid->ts_num_ids);

3434

3454

3435

list_for_each_entry_safe(stateid, next, &test_stateid->ts_stateid_list, ts_id_list) {

3455

list_for_each_entry_safe(stateid, next, &test_stateid->ts_stateid_list, ts_id_list) {

3436

*p++ = stateid->ts_id_status;

3456

*p++ = stateid->ts_id_status;

3437

}

3457

}

3438

3458

3439

ADJUST_ARGS();

3459

ADJUST_ARGS();

3440

return nfserr;

3460

return nfserr;

3441

}

3461

}

3442

3462

3443

static __be32

3463

static __be32

3444

nfsd4_encode_noop(struct nfsd4_compoundres *resp, __be32 nfserr, void *p)

3464

nfsd4_encode_noop(struct nfsd4_compoundres *resp, __be32 nfserr, void *p)

3445

{

3465

{

3446

return nfserr;

3466

return nfserr;

3447

}

3467

}

3448

3468

3449

typedef __be32(* nfsd4_enc)(struct nfsd4_compoundres *, __be32, void *);

3469

typedef __be32(* nfsd4_enc)(struct nfsd4_compoundres *, __be32, void *);

3450

3470

3451

/*

3471

/*

3452

* Note: nfsd4_enc_ops vector is shared for v4.0 and v4.1

3472

* Note: nfsd4_enc_ops vector is shared for v4.0 and v4.1

3453

* since we don't need to filter out obsolete ops as this is

3473

* since we don't need to filter out obsolete ops as this is

3454

* done in the decoding phase.

3474

* done in the decoding phase.

3455

*/

3475

*/

3456

static nfsd4_enc nfsd4_enc_ops[] = {

3476

static nfsd4_enc nfsd4_enc_ops[] = {

3457

[OP_ACCESS] = (nfsd4_enc)nfsd4_encode_access,

3477

[OP_ACCESS] = (nfsd4_enc)nfsd4_encode_access,

3458

[OP_CLOSE] = (nfsd4_enc)nfsd4_encode_close,

3478

[OP_CLOSE] = (nfsd4_enc)nfsd4_encode_close,

3459

[OP_COMMIT] = (nfsd4_enc)nfsd4_encode_commit,

3479

[OP_COMMIT] = (nfsd4_enc)nfsd4_encode_commit,

3460

[OP_CREATE] = (nfsd4_enc)nfsd4_encode_create,

3480

[OP_CREATE] = (nfsd4_enc)nfsd4_encode_create,

3461

[OP_DELEGPURGE] = (nfsd4_enc)nfsd4_encode_noop,

3481

[OP_DELEGPURGE] = (nfsd4_enc)nfsd4_encode_noop,

3462

[OP_DELEGRETURN] = (nfsd4_enc)nfsd4_encode_noop,

3482

[OP_DELEGRETURN] = (nfsd4_enc)nfsd4_encode_noop,

3463

[OP_GETATTR] = (nfsd4_enc)nfsd4_encode_getattr,

3483

[OP_GETATTR] = (nfsd4_enc)nfsd4_encode_getattr,

3464

[OP_GETFH] = (nfsd4_enc)nfsd4_encode_getfh,

3484

[OP_GETFH] = (nfsd4_enc)nfsd4_encode_getfh,

3465

[OP_LINK] = (nfsd4_enc)nfsd4_encode_link,

3485

[OP_LINK] = (nfsd4_enc)nfsd4_encode_link,

3466

[OP_LOCK] = (nfsd4_enc)nfsd4_encode_lock,

3486

[OP_LOCK] = (nfsd4_enc)nfsd4_encode_lock,

3467

[OP_LOCKT] = (nfsd4_enc)nfsd4_encode_lockt,

3487

[OP_LOCKT] = (nfsd4_enc)nfsd4_encode_lockt,

3468

[OP_LOCKU] = (nfsd4_enc)nfsd4_encode_locku,

3488

[OP_LOCKU] = (nfsd4_enc)nfsd4_encode_locku,

3469

[OP_LOOKUP] = (nfsd4_enc)nfsd4_encode_noop,

3489

[OP_LOOKUP] = (nfsd4_enc)nfsd4_encode_noop,

3470

[OP_LOOKUPP] = (nfsd4_enc)nfsd4_encode_noop,

3490

[OP_LOOKUPP] = (nfsd4_enc)nfsd4_encode_noop,

3471

[OP_NVERIFY] = (nfsd4_enc)nfsd4_encode_noop,

3491

[OP_NVERIFY] = (nfsd4_enc)nfsd4_encode_noop,

3472

[OP_OPEN] = (nfsd4_enc)nfsd4_encode_open,

3492

[OP_OPEN] = (nfsd4_enc)nfsd4_encode_open,

3473

[OP_OPENATTR] = (nfsd4_enc)nfsd4_encode_noop,

3493

[OP_OPENATTR] = (nfsd4_enc)nfsd4_encode_noop,

3474

[OP_OPEN_CONFIRM] = (nfsd4_enc)nfsd4_encode_open_confirm,

3494

[OP_OPEN_CONFIRM] = (nfsd4_enc)nfsd4_encode_open_confirm,

3475

[OP_OPEN_DOWNGRADE] = (nfsd4_enc)nfsd4_encode_open_downgrade,

3495

[OP_OPEN_DOWNGRADE] = (nfsd4_enc)nfsd4_encode_open_downgrade,

3476

[OP_PUTFH] = (nfsd4_enc)nfsd4_encode_noop,

3496

[OP_PUTFH] = (nfsd4_enc)nfsd4_encode_noop,

3477

[OP_PUTPUBFH] = (nfsd4_enc)nfsd4_encode_noop,

3497

[OP_PUTPUBFH] = (nfsd4_enc)nfsd4_encode_noop,

3478

[OP_PUTROOTFH] = (nfsd4_enc)nfsd4_encode_noop,

3498

[OP_PUTROOTFH] = (nfsd4_enc)nfsd4_encode_noop,

3479

[OP_READ] = (nfsd4_enc)nfsd4_encode_read,

3499

[OP_READ] = (nfsd4_enc)nfsd4_encode_read,

3480

[OP_READDIR] = (nfsd4_enc)nfsd4_encode_readdir,

3500

[OP_READDIR] = (nfsd4_enc)nfsd4_encode_readdir,

3481

[OP_READLINK] = (nfsd4_enc)nfsd4_encode_readlink,

3501

[OP_READLINK] = (nfsd4_enc)nfsd4_encode_readlink,

3482

[OP_REMOVE] = (nfsd4_enc)nfsd4_encode_remove,

3502

[OP_REMOVE] = (nfsd4_enc)nfsd4_encode_remove,

3483

[OP_RENAME] = (nfsd4_enc)nfsd4_encode_rename,

3503

[OP_RENAME] = (nfsd4_enc)nfsd4_encode_rename,

3484

[OP_RENEW] = (nfsd4_enc)nfsd4_encode_noop,

3504

[OP_RENEW] = (nfsd4_enc)nfsd4_encode_noop,

3485

[OP_RESTOREFH] = (nfsd4_enc)nfsd4_encode_noop,

3505

[OP_RESTOREFH] = (nfsd4_enc)nfsd4_encode_noop,

3486

[OP_SAVEFH] = (nfsd4_enc)nfsd4_encode_noop,

3506

[OP_SAVEFH] = (nfsd4_enc)nfsd4_encode_noop,

3487

[OP_SECINFO] = (nfsd4_enc)nfsd4_encode_secinfo,

3507

[OP_SECINFO] = (nfsd4_enc)nfsd4_encode_secinfo,

3488

[OP_SETATTR] = (nfsd4_enc)nfsd4_encode_setattr,

3508

[OP_SETATTR] = (nfsd4_enc)nfsd4_encode_setattr,

3489

[OP_SETCLIENTID] = (nfsd4_enc)nfsd4_encode_setclientid,

3509

[OP_SETCLIENTID] = (nfsd4_enc)nfsd4_encode_setclientid,

3490

[OP_SETCLIENTID_CONFIRM] = (nfsd4_enc)nfsd4_encode_noop,

3510

[OP_SETCLIENTID_CONFIRM] = (nfsd4_enc)nfsd4_encode_noop,

3491

[OP_VERIFY] = (nfsd4_enc)nfsd4_encode_noop,

3511

[OP_VERIFY] = (nfsd4_enc)nfsd4_encode_noop,

3492

[OP_WRITE] = (nfsd4_enc)nfsd4_encode_write,

3512

[OP_WRITE] = (nfsd4_enc)nfsd4_encode_write,

3493

[OP_RELEASE_LOCKOWNER] = (nfsd4_enc)nfsd4_encode_noop,

3513

[OP_RELEASE_LOCKOWNER] = (nfsd4_enc)nfsd4_encode_noop,

3494

3514

3495

/* NFSv4.1 operations */

3515

/* NFSv4.1 operations */

3496

[OP_BACKCHANNEL_CTL] = (nfsd4_enc)nfsd4_encode_noop,

3516

[OP_BACKCHANNEL_CTL] = (nfsd4_enc)nfsd4_encode_noop,

3497

[OP_BIND_CONN_TO_SESSION] = (nfsd4_enc)nfsd4_encode_bind_conn_to_session,

3517

[OP_BIND_CONN_TO_SESSION] = (nfsd4_enc)nfsd4_encode_bind_conn_to_session,

3498

[OP_EXCHANGE_ID] = (nfsd4_enc)nfsd4_encode_exchange_id,

3518

[OP_EXCHANGE_ID] = (nfsd4_enc)nfsd4_encode_exchange_id,

3499

[OP_CREATE_SESSION] = (nfsd4_enc)nfsd4_encode_create_session,

3519

[OP_CREATE_SESSION] = (nfsd4_enc)nfsd4_encode_create_session,

3500

[OP_DESTROY_SESSION] = (nfsd4_enc)nfsd4_encode_destroy_session,

3520

[OP_DESTROY_SESSION] = (nfsd4_enc)nfsd4_encode_destroy_session,

3501

[OP_FREE_STATEID] = (nfsd4_enc)nfsd4_encode_free_stateid,

3521

[OP_FREE_STATEID] = (nfsd4_enc)nfsd4_encode_free_stateid,

3502

[OP_GET_DIR_DELEGATION] = (nfsd4_enc)nfsd4_encode_noop,

3522

[OP_GET_DIR_DELEGATION] = (nfsd4_enc)nfsd4_encode_noop,

3503

[OP_GETDEVICEINFO] = (nfsd4_enc)nfsd4_encode_noop,

3523

[OP_GETDEVICEINFO] = (nfsd4_enc)nfsd4_encode_noop,

3504

[OP_GETDEVICELIST] = (nfsd4_enc)nfsd4_encode_noop,

3524

[OP_GETDEVICELIST] = (nfsd4_enc)nfsd4_encode_noop,

3505

[OP_LAYOUTCOMMIT] = (nfsd4_enc)nfsd4_encode_noop,

3525

[OP_LAYOUTCOMMIT] = (nfsd4_enc)nfsd4_encode_noop,

3506

[OP_LAYOUTGET] = (nfsd4_enc)nfsd4_encode_noop,

3526

[OP_LAYOUTGET] = (nfsd4_enc)nfsd4_encode_noop,

3507

[OP_LAYOUTRETURN] = (nfsd4_enc)nfsd4_encode_noop,

3527

[OP_LAYOUTRETURN] = (nfsd4_enc)nfsd4_encode_noop,

3508

[OP_SECINFO_NO_NAME] = (nfsd4_enc)nfsd4_encode_secinfo_no_name,

3528

[OP_SECINFO_NO_NAME] = (nfsd4_enc)nfsd4_encode_secinfo_no_name,

3509

[OP_SEQUENCE] = (nfsd4_enc)nfsd4_encode_sequence,

3529

[OP_SEQUENCE] = (nfsd4_enc)nfsd4_encode_sequence,

3510

[OP_SET_SSV] = (nfsd4_enc)nfsd4_encode_noop,

3530

[OP_SET_SSV] = (nfsd4_enc)nfsd4_encode_noop,

3511

[OP_TEST_STATEID] = (nfsd4_enc)nfsd4_encode_test_stateid,

3531

[OP_TEST_STATEID] = (nfsd4_enc)nfsd4_encode_test_stateid,

3512

[OP_WANT_DELEGATION] = (nfsd4_enc)nfsd4_encode_noop,

3532

[OP_WANT_DELEGATION] = (nfsd4_enc)nfsd4_encode_noop,

3513

[OP_DESTROY_CLIENTID] = (nfsd4_enc)nfsd4_encode_noop,

3533

[OP_DESTROY_CLIENTID] = (nfsd4_enc)nfsd4_encode_noop,

3514

[OP_RECLAIM_COMPLETE] = (nfsd4_enc)nfsd4_encode_noop,

3534

[OP_RECLAIM_COMPLETE] = (nfsd4_enc)nfsd4_encode_noop,

3515

};

3535

};

3516

3536

3517

/*

3537

/*

3518

* Calculate the total amount of memory that the compound response has taken

3538

* Calculate the total amount of memory that the compound response has taken

3519

* after encoding the current operation with pad.

3539

* after encoding the current operation with pad.

3520

*

3540

*

3521

* pad: if operation is non-idempotent, pad was calculate by op_rsize_bop()

3541

* pad: if operation is non-idempotent, pad was calculate by op_rsize_bop()

3522

* which was specified at nfsd4_operation, else pad is zero.

3542

* which was specified at nfsd4_operation, else pad is zero.

3523

*

3543

*

3524

* Compare this length to the session se_fmaxresp_sz and se_fmaxresp_cached.

3544

* Compare this length to the session se_fmaxresp_sz and se_fmaxresp_cached.

3525

*

3545

*

3526

* Our se_fmaxresp_cached will always be a multiple of PAGE_SIZE, and so

3546

* Our se_fmaxresp_cached will always be a multiple of PAGE_SIZE, and so

3527

* will be at least a page and will therefore hold the xdr_buf head.

3547

* will be at least a page and will therefore hold the xdr_buf head.

3528

*/

3548

*/

3529

__be32 nfsd4_check_resp_size(struct nfsd4_compoundres *resp, u32 pad)

3549

__be32 nfsd4_check_resp_size(struct nfsd4_compoundres *resp, u32 pad)

3530

{

3550

{

3531

struct xdr_buf *xb = &resp->rqstp->rq_res;

3551

struct xdr_buf *xb = &resp->rqstp->rq_res;

3532

struct nfsd4_session *session = NULL;

3552

struct nfsd4_session *session = NULL;

3533

struct nfsd4_slot *slot = resp->cstate.slot;

3553

struct nfsd4_slot *slot = resp->cstate.slot;

3534

u32 length, tlen = 0;

3554

u32 length, tlen = 0;

3535

3555

3536

if (!nfsd4_has_session(&resp->cstate))

3556

if (!nfsd4_has_session(&resp->cstate))

3537

return 0;

3557

return 0;

3538

3558

3539

session = resp->cstate.session;

3559

session = resp->cstate.session;

3540

if (session == NULL)

3560

if (session == NULL)

3541

return 0;

3561

return 0;

3542

3562

3543

if (xb->page_len == 0) {

3563

if (xb->page_len == 0) {

3544

length = (char *)resp->p - (char *)xb->head[0].iov_base + pad;

3564

length = (char *)resp->p - (char *)xb->head[0].iov_base + pad;

3545

} else {

3565

} else {

3546

if (xb->tail[0].iov_base && xb->tail[0].iov_len > 0)

3566

if (xb->tail[0].iov_base && xb->tail[0].iov_len > 0)

3547

tlen = (char *)resp->p - (char *)xb->tail[0].iov_base;

3567

tlen = (char *)resp->p - (char *)xb->tail[0].iov_base;

3548

3568

3549

length = xb->head[0].iov_len + xb->page_len + tlen + pad;

3569

length = xb->head[0].iov_len + xb->page_len + tlen + pad;

3550

}

3570

}

3551

dprintk("%s length %u, xb->page_len %u tlen %u pad %u\n", __func__,

3571

dprintk("%s length %u, xb->page_len %u tlen %u pad %u\n", __func__,

3552

length, xb->page_len, tlen, pad);

3572

length, xb->page_len, tlen, pad);

3553

3573

3554

if (length > session->se_fchannel.maxresp_sz)

3574

if (length > session->se_fchannel.maxresp_sz)

3555

return nfserr_rep_too_big;

3575

return nfserr_rep_too_big;

3556

3576

3557

if ((slot->sl_flags & NFSD4_SLOT_CACHETHIS) &&

3577

if ((slot->sl_flags & NFSD4_SLOT_CACHETHIS) &&

3558

length > session->se_fchannel.maxresp_cached)

3578

length > session->se_fchannel.maxresp_cached)

3559

return nfserr_rep_too_big_to_cache;

3579

return nfserr_rep_too_big_to_cache;

3560

3580

3561

return 0;

3581

return 0;

3562

}

3582

}

3563

3583

3564

void

3584

void

3565

nfsd4_encode_operation(struct nfsd4_compoundres *resp, struct nfsd4_op *op)

3585

nfsd4_encode_operation(struct nfsd4_compoundres *resp, struct nfsd4_op *op)

3566

{

3586

{

3567

__be32 *statp;

3587

__be32 *statp;

3568

__be32 *p;

3588

__be32 *p;

3569

3589

3570

RESERVE_SPACE(8);

3590

RESERVE_SPACE(8);

3571

WRITE32(op->opnum);

3591

WRITE32(op->opnum);

3572

statp = p++; /* to be backfilled at the end */

3592

statp = p++; /* to be backfilled at the end */

3573

ADJUST_ARGS();

3593

ADJUST_ARGS();

3574

3594

3575

if (op->opnum == OP_ILLEGAL)

3595

if (op->opnum == OP_ILLEGAL)

3576

goto status;

3596

goto status;

3577

BUG_ON(op->opnum < 0 || op->opnum >= ARRAY_SIZE(nfsd4_enc_ops) ||

3597

BUG_ON(op->opnum < 0 || op->opnum >= ARRAY_SIZE(nfsd4_enc_ops) ||

3578

!nfsd4_enc_ops[op->opnum]);

3598

!nfsd4_enc_ops[op->opnum]);

3579

op->status = nfsd4_enc_ops[op->opnum](resp, op->status, &op->u);

3599

op->status = nfsd4_enc_ops[op->opnum](resp, op->status, &op->u);

3580

/* nfsd4_check_drc_limit guarantees enough room for error status */

3600

/* nfsd4_check_drc_limit guarantees enough room for error status */

3581

if (!op->status)

3601

if (!op->status)

3582

op->status = nfsd4_check_resp_size(resp, 0);

3602

op->status = nfsd4_check_resp_size(resp, 0);

3583

status:

3603

status:

3584

/*

3604

/*

3585

* Note: We write the status directly, instead of using WRITE32(),

3605

* Note: We write the status directly, instead of using WRITE32(),

3586

* since it is already in network byte order.

3606

* since it is already in network byte order.

3587

*/

3607

*/

3588

*statp = op->status;

3608

*statp = op->status;

3589

}

3609

}

3590

3610

3591

/*

3611

/*

3592

* Encode the reply stored in the stateowner reply cache

3612

* Encode the reply stored in the stateowner reply cache

3593

*

3613

*

3594

* XDR note: do not encode rp->rp_buflen: the buffer contains the

3614

* XDR note: do not encode rp->rp_buflen: the buffer contains the

3595

* previously sent already encoded operation.

3615

* previously sent already encoded operation.

3596

*

3616

*

3597

* called with nfs4_lock_state() held

3617

* called with nfs4_lock_state() held

3598

*/

3618

*/

3599

void

3619

void

3600

nfsd4_encode_replay(struct nfsd4_compoundres *resp, struct nfsd4_op *op)

3620

nfsd4_encode_replay(struct nfsd4_compoundres *resp, struct nfsd4_op *op)

3601

{

3621

{

3602

__be32 *p;

3622

__be32 *p;

3603

struct nfs4_replay *rp = op->replay;

3623

struct nfs4_replay *rp = op->replay;

3604

3624

3605

BUG_ON(!rp);

3625

BUG_ON(!rp);

3606

3626

3607

RESERVE_SPACE(8);

3627

RESERVE_SPACE(8);

3608

WRITE32(op->opnum);

3628

WRITE32(op->opnum);

3609

*p++ = rp->rp_status; /* already xdr'ed */

3629

*p++ = rp->rp_status; /* already xdr'ed */

3610

ADJUST_ARGS();

3630

ADJUST_ARGS();

3611

3631

3612

RESERVE_SPACE(rp->rp_buflen);

3632

RESERVE_SPACE(rp->rp_buflen);

3613

WRITEMEM(rp->rp_buf, rp->rp_buflen);

3633

WRITEMEM(rp->rp_buf, rp->rp_buflen);

3614

ADJUST_ARGS();

3634

ADJUST_ARGS();

3615

}

3635

}

3616

3636

3617

int

3637

int

3618

nfs4svc_encode_voidres(struct svc_rqst *rqstp, __be32 *p, void *dummy)

3638

nfs4svc_encode_voidres(struct svc_rqst *rqstp, __be32 *p, void *dummy)

3619

{

3639

{

3620

return xdr_ressize_check(rqstp, p);

3640

return xdr_ressize_check(rqstp, p);

3621

}

3641

}

3622

3642

3623

int nfsd4_release_compoundargs(void *rq, __be32 *p, void *resp)

3643

int nfsd4_release_compoundargs(void *rq, __be32 *p, void *resp)

3624

{

3644

{

3625

struct svc_rqst *rqstp = rq;

3645

struct svc_rqst *rqstp = rq;

3626

struct nfsd4_compoundargs *args = rqstp->rq_argp;

3646

struct nfsd4_compoundargs *args = rqstp->rq_argp;

3627

3647

3628

if (args->ops != args->iops) {

3648

if (args->ops != args->iops) {

3629

kfree(args->ops);

3649

kfree(args->ops);

3630

args->ops = args->iops;

3650

args->ops = args->iops;

3631

}

3651

}

3632

kfree(args->tmpp);

3652

kfree(args->tmpp);

3633

args->tmpp = NULL;

3653

args->tmpp = NULL;

3634

while (args->to_free) {

3654

while (args->to_free) {

3635

struct tmpbuf *tb = args->to_free;

3655

struct tmpbuf *tb = args->to_free;

3636

args->to_free = tb->next;

3656

args->to_free = tb->next;

3637

tb->release(tb->buf);

3657

tb->release(tb->buf);

3638

kfree(tb);

3658

kfree(tb);

3639

}

3659

}

3640

return 1;

3660

return 1;

3641

}

3661

}

3642

3662

3643

int

3663

int

3644

nfs4svc_decode_compoundargs(struct svc_rqst *rqstp, __be32 *p, struct nfsd4_compoundargs *args)

3664

nfs4svc_decode_compoundargs(struct svc_rqst *rqstp, __be32 *p, struct nfsd4_compoundargs *args)

3645

{

3665

{

3646

args->p = p;

3666

args->p = p;

3647

args->end = rqstp->rq_arg.head[0].iov_base + rqstp->rq_arg.head[0].iov_len;

3667

args->end = rqstp->rq_arg.head[0].iov_base + rqstp->rq_arg.head[0].iov_len;

3648

args->pagelist = rqstp->rq_arg.pages;

3668

args->pagelist = rqstp->rq_arg.pages;

3649

args->pagelen = rqstp->rq_arg.page_len;

3669

args->pagelen = rqstp->rq_arg.page_len;

3650

args->tmpp = NULL;

3670

args->tmpp = NULL;

3651

args->to_free = NULL;

3671

args->to_free = NULL;

3652

args->ops = args->iops;

3672

args->ops = args->iops;

3653

args->rqstp = rqstp;

3673

args->rqstp = rqstp;

3654

3674

3655

return !nfsd4_decode_compound(args);

3675

return !nfsd4_decode_compound(args);

3656

}

3676

}

3657

3677

3658

int

3678

int

3659

nfs4svc_encode_compoundres(struct svc_rqst *rqstp, __be32 *p, struct nfsd4_compoundres *resp)

3679

nfs4svc_encode_compoundres(struct svc_rqst *rqstp, __be32 *p, struct nfsd4_compoundres *resp)

3660

{

3680

{

3661

/*

3681

/*

3662

* All that remains is to write the tag and operation count...

3682

* All that remains is to write the tag and operation count...

3663

*/

3683

*/

3664

struct nfsd4_compound_state *cs = &resp->cstate;

3684

struct nfsd4_compound_state *cs = &resp->cstate;

3665

struct kvec *iov;

3685

struct kvec *iov;

3666

p = resp->tagp;

3686

p = resp->tagp;

3667

*p++ = htonl(resp->taglen);

3687

*p++ = htonl(resp->taglen);

3668

memcpy(p, resp->tag, resp->taglen);

3688

memcpy(p, resp->tag, resp->taglen);

3669

p += XDR_QUADLEN(resp->taglen);

3689

p += XDR_QUADLEN(resp->taglen);

3670

*p++ = htonl(resp->opcnt);

3690

*p++ = htonl(resp->opcnt);

3671

3691

3672

if (rqstp->rq_res.page_len)

3692

if (rqstp->rq_res.page_len)

3673

iov = &rqstp->rq_res.tail[0];

3693

iov = &rqstp->rq_res.tail[0];

3674

else

3694

else

3675

iov = &rqstp->rq_res.head[0];

3695

iov = &rqstp->rq_res.head[0];

3676

iov->iov_len = ((char*)resp->p) - (char*)iov->iov_base;

3696

iov->iov_len = ((char*)resp->p) - (char*)iov->iov_base;

3677

BUG_ON(iov->iov_len > PAGE_SIZE);

3697

BUG_ON(iov->iov_len > PAGE_SIZE);

3678

if (nfsd4_has_session(cs)) {

3698

if (nfsd4_has_session(cs)) {

3679

if (cs->status != nfserr_replay_cache) {

3699

if (cs->status != nfserr_replay_cache) {

3680

nfsd4_store_cache_entry(resp);

3700

nfsd4_store_cache_entry(resp);

3681

cs->slot->sl_flags &= ~NFSD4_SLOT_INUSE;

3701

cs->slot->sl_flags &= ~NFSD4_SLOT_INUSE;

3682

}

3702

}

3683

/* Renew the clientid on success and on replay */

3703

/* Renew the clientid on success and on replay */

3684

release_session_client(cs->session);

3704

release_session_client(cs->session);

3685

nfsd4_put_session(cs->session);

3705

nfsd4_put_session(cs->session);

3686

}

3706

}

3687

return 1;

3707

return 1;

3688

}

3708

}

3689

3709

3690

/*

3710

/*

3691

* Local variables:

3711

* Local variables:

3692

* c-basic-offset: 8

3712

* c-basic-offset: 8

3693

* End:

3713

* End:

3694

*/

3714

*/

GITLAB

nfsd4: reorganize write decoding