blob: 01d4ec1c88e0ff064ed2b5de697257766945c412 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * linux/fs/nfsd/nfs3xdr.c
3 *
4 * XDR support for nfsd/protocol version 3.
5 *
6 * Copyright (C) 1995, 1996, 1997 Olaf Kirch <okir@monad.swb.de>
7 *
8 * 2003-08-09 Jamie Lokier: Use htonl() for nanoseconds, not htons()!
9 */
10
11#include <linux/types.h>
12#include <linux/time.h>
13#include <linux/nfs3.h>
14#include <linux/list.h>
15#include <linux/spinlock.h>
16#include <linux/dcache.h>
17#include <linux/namei.h>
18#include <linux/mm.h>
19#include <linux/vfs.h>
20#include <linux/sunrpc/xdr.h>
21#include <linux/sunrpc/svc.h>
22#include <linux/nfsd/nfsd.h>
23#include <linux/nfsd/xdr3.h>
J. Bruce Fields2e8138a2007-11-15 17:05:43 -050024#include "auth.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070025
26#define NFSDDBG_FACILITY NFSDDBG_XDR
27
Linus Torvalds1da177e2005-04-16 15:20:36 -070028
29/*
30 * Mapping of S_IF* types to NFS file types
31 */
32static u32 nfs3_ftypes[] = {
33 NF3NON, NF3FIFO, NF3CHR, NF3BAD,
34 NF3DIR, NF3BAD, NF3BLK, NF3BAD,
35 NF3REG, NF3BAD, NF3LNK, NF3BAD,
36 NF3SOCK, NF3BAD, NF3LNK, NF3BAD,
37};
38
39/*
40 * XDR functions for basic NFS types
41 */
Adrian Bunk3ee6f612006-12-06 20:40:23 -080042static __be32 *
Al Viro91f07162006-10-19 23:28:57 -070043encode_time3(__be32 *p, struct timespec *time)
Linus Torvalds1da177e2005-04-16 15:20:36 -070044{
45 *p++ = htonl((u32) time->tv_sec); *p++ = htonl(time->tv_nsec);
46 return p;
47}
48
Adrian Bunk3ee6f612006-12-06 20:40:23 -080049static __be32 *
Al Viro91f07162006-10-19 23:28:57 -070050decode_time3(__be32 *p, struct timespec *time)
Linus Torvalds1da177e2005-04-16 15:20:36 -070051{
52 time->tv_sec = ntohl(*p++);
53 time->tv_nsec = ntohl(*p++);
54 return p;
55}
56
Adrian Bunk3ee6f612006-12-06 20:40:23 -080057static __be32 *
Al Viro91f07162006-10-19 23:28:57 -070058decode_fh(__be32 *p, struct svc_fh *fhp)
Linus Torvalds1da177e2005-04-16 15:20:36 -070059{
60 unsigned int size;
61 fh_init(fhp, NFS3_FHSIZE);
62 size = ntohl(*p++);
63 if (size > NFS3_FHSIZE)
64 return NULL;
65
66 memcpy(&fhp->fh_handle.fh_base, p, size);
67 fhp->fh_handle.fh_size = size;
68 return p + XDR_QUADLEN(size);
69}
70
Andreas Gruenbachera257cdd2005-06-22 17:16:26 +000071/* Helper function for NFSv3 ACL code */
Al Viro91f07162006-10-19 23:28:57 -070072__be32 *nfs3svc_decode_fh(__be32 *p, struct svc_fh *fhp)
Andreas Gruenbachera257cdd2005-06-22 17:16:26 +000073{
74 return decode_fh(p, fhp);
75}
76
Adrian Bunk3ee6f612006-12-06 20:40:23 -080077static __be32 *
Al Viro91f07162006-10-19 23:28:57 -070078encode_fh(__be32 *p, struct svc_fh *fhp)
Linus Torvalds1da177e2005-04-16 15:20:36 -070079{
80 unsigned int size = fhp->fh_handle.fh_size;
81 *p++ = htonl(size);
82 if (size) p[XDR_QUADLEN(size)-1]=0;
83 memcpy(p, &fhp->fh_handle.fh_base, size);
84 return p + XDR_QUADLEN(size);
85}
86
87/*
88 * Decode a file name and make sure that the path contains
89 * no slashes or null bytes.
90 */
Adrian Bunk3ee6f612006-12-06 20:40:23 -080091static __be32 *
Chuck Leveree1a95b2007-11-01 16:56:58 -040092decode_filename(__be32 *p, char **namp, unsigned int *lenp)
Linus Torvalds1da177e2005-04-16 15:20:36 -070093{
94 char *name;
Chuck Leveree1a95b2007-11-01 16:56:58 -040095 unsigned int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -070096
97 if ((p = xdr_decode_string_inplace(p, namp, lenp, NFS3_MAXNAMLEN)) != NULL) {
98 for (i = 0, name = *namp; i < *lenp; i++, name++) {
99 if (*name == '\0' || *name == '/')
100 return NULL;
101 }
102 }
103
104 return p;
105}
106
Adrian Bunk3ee6f612006-12-06 20:40:23 -0800107static __be32 *
Al Viro91f07162006-10-19 23:28:57 -0700108decode_sattr3(__be32 *p, struct iattr *iap)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700109{
110 u32 tmp;
111
112 iap->ia_valid = 0;
113
114 if (*p++) {
115 iap->ia_valid |= ATTR_MODE;
116 iap->ia_mode = ntohl(*p++);
117 }
118 if (*p++) {
119 iap->ia_valid |= ATTR_UID;
120 iap->ia_uid = ntohl(*p++);
121 }
122 if (*p++) {
123 iap->ia_valid |= ATTR_GID;
124 iap->ia_gid = ntohl(*p++);
125 }
126 if (*p++) {
127 u64 newsize;
128
129 iap->ia_valid |= ATTR_SIZE;
130 p = xdr_decode_hyper(p, &newsize);
131 if (newsize <= NFS_OFFSET_MAX)
132 iap->ia_size = newsize;
133 else
134 iap->ia_size = NFS_OFFSET_MAX;
135 }
136 if ((tmp = ntohl(*p++)) == 1) { /* set to server time */
137 iap->ia_valid |= ATTR_ATIME;
138 } else if (tmp == 2) { /* set to client time */
139 iap->ia_valid |= ATTR_ATIME | ATTR_ATIME_SET;
140 iap->ia_atime.tv_sec = ntohl(*p++);
141 iap->ia_atime.tv_nsec = ntohl(*p++);
142 }
143 if ((tmp = ntohl(*p++)) == 1) { /* set to server time */
144 iap->ia_valid |= ATTR_MTIME;
145 } else if (tmp == 2) { /* set to client time */
146 iap->ia_valid |= ATTR_MTIME | ATTR_MTIME_SET;
147 iap->ia_mtime.tv_sec = ntohl(*p++);
148 iap->ia_mtime.tv_nsec = ntohl(*p++);
149 }
150 return p;
151}
152
NeilBrownaf6a4e22007-02-14 00:33:12 -0800153static __be32 *encode_fsid(__be32 *p, struct svc_fh *fhp)
154{
155 u64 f;
156 switch(fsid_source(fhp)) {
157 default:
158 case FSIDSOURCE_DEV:
159 p = xdr_encode_hyper(p, (u64)huge_encode_dev
160 (fhp->fh_dentry->d_inode->i_sb->s_dev));
161 break;
162 case FSIDSOURCE_FSID:
163 p = xdr_encode_hyper(p, (u64) fhp->fh_export->ex_fsid);
164 break;
165 case FSIDSOURCE_UUID:
166 f = ((u64*)fhp->fh_export->ex_uuid)[0];
167 f ^= ((u64*)fhp->fh_export->ex_uuid)[1];
168 p = xdr_encode_hyper(p, f);
169 break;
170 }
171 return p;
172}
173
Adrian Bunk3ee6f612006-12-06 20:40:23 -0800174static __be32 *
Al Viro91f07162006-10-19 23:28:57 -0700175encode_fattr3(struct svc_rqst *rqstp, __be32 *p, struct svc_fh *fhp,
David Shawa334de22006-01-06 00:19:58 -0800176 struct kstat *stat)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700177{
David Shawa334de22006-01-06 00:19:58 -0800178 *p++ = htonl(nfs3_ftypes[(stat->mode & S_IFMT) >> 12]);
179 *p++ = htonl((u32) stat->mode);
180 *p++ = htonl((u32) stat->nlink);
181 *p++ = htonl((u32) nfsd_ruid(rqstp, stat->uid));
182 *p++ = htonl((u32) nfsd_rgid(rqstp, stat->gid));
183 if (S_ISLNK(stat->mode) && stat->size > NFS3_MAXPATHLEN) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700184 p = xdr_encode_hyper(p, (u64) NFS3_MAXPATHLEN);
185 } else {
David Shawa334de22006-01-06 00:19:58 -0800186 p = xdr_encode_hyper(p, (u64) stat->size);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700187 }
David Shawa334de22006-01-06 00:19:58 -0800188 p = xdr_encode_hyper(p, ((u64)stat->blocks) << 9);
189 *p++ = htonl((u32) MAJOR(stat->rdev));
190 *p++ = htonl((u32) MINOR(stat->rdev));
NeilBrownaf6a4e22007-02-14 00:33:12 -0800191 p = encode_fsid(p, fhp);
Peter Staubach40ee5dc2007-08-16 12:10:07 -0400192 p = xdr_encode_hyper(p, stat->ino);
David Shawa334de22006-01-06 00:19:58 -0800193 p = encode_time3(p, &stat->atime);
Peter Staubach40ee5dc2007-08-16 12:10:07 -0400194 p = encode_time3(p, &stat->mtime);
David Shawa334de22006-01-06 00:19:58 -0800195 p = encode_time3(p, &stat->ctime);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700196
197 return p;
198}
199
Adrian Bunk3ee6f612006-12-06 20:40:23 -0800200static __be32 *
Al Viro91f07162006-10-19 23:28:57 -0700201encode_saved_post_attr(struct svc_rqst *rqstp, __be32 *p, struct svc_fh *fhp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700202{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700203 /* Attributes to follow */
204 *p++ = xdr_one;
Peter Staubach40ee5dc2007-08-16 12:10:07 -0400205 return encode_fattr3(rqstp, p, fhp, &fhp->fh_post_attr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700206}
207
208/*
209 * Encode post-operation attributes.
210 * The inode may be NULL if the call failed because of a stale file
211 * handle. In this case, no attributes are returned.
212 */
Al Viro91f07162006-10-19 23:28:57 -0700213static __be32 *
214encode_post_op_attr(struct svc_rqst *rqstp, __be32 *p, struct svc_fh *fhp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700215{
216 struct dentry *dentry = fhp->fh_dentry;
NeilBrown072f62e2007-05-09 02:34:57 -0700217 if (dentry && dentry->d_inode) {
David Shawa334de22006-01-06 00:19:58 -0800218 int err;
219 struct kstat stat;
220
Jan Blunck54775492008-02-14 19:38:39 -0800221 err = vfs_getattr(fhp->fh_export->ex_path.mnt, dentry, &stat);
David Shawa334de22006-01-06 00:19:58 -0800222 if (!err) {
223 *p++ = xdr_one; /* attributes follow */
Peter Staubach40ee5dc2007-08-16 12:10:07 -0400224 lease_get_mtime(dentry->d_inode, &stat.mtime);
David Shawa334de22006-01-06 00:19:58 -0800225 return encode_fattr3(rqstp, p, fhp, &stat);
226 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700227 }
228 *p++ = xdr_zero;
229 return p;
230}
231
Andreas Gruenbachera257cdd2005-06-22 17:16:26 +0000232/* Helper for NFSv3 ACLs */
Al Viro91f07162006-10-19 23:28:57 -0700233__be32 *
234nfs3svc_encode_post_op_attr(struct svc_rqst *rqstp, __be32 *p, struct svc_fh *fhp)
Andreas Gruenbachera257cdd2005-06-22 17:16:26 +0000235{
236 return encode_post_op_attr(rqstp, p, fhp);
237}
238
Linus Torvalds1da177e2005-04-16 15:20:36 -0700239/*
240 * Enocde weak cache consistency data
241 */
Al Viro91f07162006-10-19 23:28:57 -0700242static __be32 *
243encode_wcc_data(struct svc_rqst *rqstp, __be32 *p, struct svc_fh *fhp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700244{
245 struct dentry *dentry = fhp->fh_dentry;
246
247 if (dentry && dentry->d_inode && fhp->fh_post_saved) {
248 if (fhp->fh_pre_saved) {
249 *p++ = xdr_one;
250 p = xdr_encode_hyper(p, (u64) fhp->fh_pre_size);
251 p = encode_time3(p, &fhp->fh_pre_mtime);
252 p = encode_time3(p, &fhp->fh_pre_ctime);
253 } else {
254 *p++ = xdr_zero;
255 }
256 return encode_saved_post_attr(rqstp, p, fhp);
257 }
258 /* no pre- or post-attrs */
259 *p++ = xdr_zero;
260 return encode_post_op_attr(rqstp, p, fhp);
261}
262
Peter Staubach40ee5dc2007-08-16 12:10:07 -0400263/*
264 * Fill in the post_op attr for the wcc data
265 */
266void fill_post_wcc(struct svc_fh *fhp)
267{
268 int err;
269
270 if (fhp->fh_post_saved)
271 printk("nfsd: inode locked twice during operation.\n");
272
Jan Blunck54775492008-02-14 19:38:39 -0800273 err = vfs_getattr(fhp->fh_export->ex_path.mnt, fhp->fh_dentry,
Peter Staubach40ee5dc2007-08-16 12:10:07 -0400274 &fhp->fh_post_attr);
J. Bruce Fieldsc654b8a2009-04-16 17:33:25 -0400275 fhp->fh_post_change = fhp->fh_dentry->d_inode->i_version;
Peter Staubach40ee5dc2007-08-16 12:10:07 -0400276 if (err)
277 fhp->fh_post_saved = 0;
278 else
279 fhp->fh_post_saved = 1;
280}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700281
282/*
283 * XDR decode functions
284 */
285int
Al Viro91f07162006-10-19 23:28:57 -0700286nfs3svc_decode_fhandle(struct svc_rqst *rqstp, __be32 *p, struct nfsd_fhandle *args)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700287{
288 if (!(p = decode_fh(p, &args->fh)))
289 return 0;
290 return xdr_argsize_check(rqstp, p);
291}
292
293int
Al Viro91f07162006-10-19 23:28:57 -0700294nfs3svc_decode_sattrargs(struct svc_rqst *rqstp, __be32 *p,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700295 struct nfsd3_sattrargs *args)
296{
NeilBrown072f62e2007-05-09 02:34:57 -0700297 if (!(p = decode_fh(p, &args->fh)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700298 return 0;
NeilBrown072f62e2007-05-09 02:34:57 -0700299 p = decode_sattr3(p, &args->attrs);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700300
301 if ((args->check_guard = ntohl(*p++)) != 0) {
302 struct timespec time;
303 p = decode_time3(p, &time);
304 args->guardtime = time.tv_sec;
305 }
306
307 return xdr_argsize_check(rqstp, p);
308}
309
310int
Al Viro91f07162006-10-19 23:28:57 -0700311nfs3svc_decode_diropargs(struct svc_rqst *rqstp, __be32 *p,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700312 struct nfsd3_diropargs *args)
313{
314 if (!(p = decode_fh(p, &args->fh))
315 || !(p = decode_filename(p, &args->name, &args->len)))
316 return 0;
317
318 return xdr_argsize_check(rqstp, p);
319}
320
321int
Al Viro91f07162006-10-19 23:28:57 -0700322nfs3svc_decode_accessargs(struct svc_rqst *rqstp, __be32 *p,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700323 struct nfsd3_accessargs *args)
324{
325 if (!(p = decode_fh(p, &args->fh)))
326 return 0;
327 args->access = ntohl(*p++);
328
329 return xdr_argsize_check(rqstp, p);
330}
331
332int
Al Viro91f07162006-10-19 23:28:57 -0700333nfs3svc_decode_readargs(struct svc_rqst *rqstp, __be32 *p,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700334 struct nfsd3_readargs *args)
335{
336 unsigned int len;
337 int v,pn;
Greg Banks7adae482006-10-04 02:15:47 -0700338 u32 max_blocksize = svc_max_payload(rqstp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700339
NeilBrown072f62e2007-05-09 02:34:57 -0700340 if (!(p = decode_fh(p, &args->fh)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700341 return 0;
NeilBrown072f62e2007-05-09 02:34:57 -0700342 p = xdr_decode_hyper(p, &args->offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700343
344 len = args->count = ntohl(*p++);
345
Greg Banks7adae482006-10-04 02:15:47 -0700346 if (len > max_blocksize)
347 len = max_blocksize;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700348
349 /* set up the kvec */
350 v=0;
351 while (len > 0) {
NeilBrown44524352006-10-04 02:15:46 -0700352 pn = rqstp->rq_resused++;
NeilBrown3cc03b12006-10-04 02:15:47 -0700353 rqstp->rq_vec[v].iov_base = page_address(rqstp->rq_respages[pn]);
354 rqstp->rq_vec[v].iov_len = len < PAGE_SIZE? len : PAGE_SIZE;
355 len -= rqstp->rq_vec[v].iov_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700356 v++;
357 }
358 args->vlen = v;
359 return xdr_argsize_check(rqstp, p);
360}
361
362int
Al Viro91f07162006-10-19 23:28:57 -0700363nfs3svc_decode_writeargs(struct svc_rqst *rqstp, __be32 *p,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700364 struct nfsd3_writeargs *args)
365{
Peter Staubachf34b9562007-05-09 02:34:48 -0700366 unsigned int len, v, hdr, dlen;
Greg Banks7adae482006-10-04 02:15:47 -0700367 u32 max_blocksize = svc_max_payload(rqstp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700368
NeilBrown072f62e2007-05-09 02:34:57 -0700369 if (!(p = decode_fh(p, &args->fh)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700370 return 0;
NeilBrown072f62e2007-05-09 02:34:57 -0700371 p = xdr_decode_hyper(p, &args->offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700372
373 args->count = ntohl(*p++);
374 args->stable = ntohl(*p++);
375 len = args->len = ntohl(*p++);
Peter Staubachf34b9562007-05-09 02:34:48 -0700376 /*
377 * The count must equal the amount of data passed.
378 */
379 if (args->count != args->len)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700380 return 0;
381
Peter Staubachf34b9562007-05-09 02:34:48 -0700382 /*
383 * Check to make sure that we got the right number of
384 * bytes.
Peter Staubachf34b9562007-05-09 02:34:48 -0700385 */
386 hdr = (void*)p - rqstp->rq_arg.head[0].iov_base;
NeilBrown072f62e2007-05-09 02:34:57 -0700387 dlen = rqstp->rq_arg.head[0].iov_len + rqstp->rq_arg.page_len
388 - hdr;
Peter Staubachf34b9562007-05-09 02:34:48 -0700389 /*
390 * Round the length of the data which was specified up to
391 * the next multiple of XDR units and then compare that
392 * against the length which was actually received.
NeilBrownba67a392008-01-11 17:06:52 -0500393 * Note that when RPCSEC/GSS (for example) is used, the
394 * data buffer can be padded so dlen might be larger
395 * than required. It must never be smaller.
Peter Staubachf34b9562007-05-09 02:34:48 -0700396 */
NeilBrownba67a392008-01-11 17:06:52 -0500397 if (dlen < XDR_QUADLEN(len)*4)
Peter Staubachf34b9562007-05-09 02:34:48 -0700398 return 0;
399
400 if (args->count > max_blocksize) {
401 args->count = max_blocksize;
402 len = args->len = max_blocksize;
403 }
NeilBrown3cc03b12006-10-04 02:15:47 -0700404 rqstp->rq_vec[0].iov_base = (void*)p;
405 rqstp->rq_vec[0].iov_len = rqstp->rq_arg.head[0].iov_len - hdr;
Peter Staubachf34b9562007-05-09 02:34:48 -0700406 v = 0;
NeilBrown3cc03b12006-10-04 02:15:47 -0700407 while (len > rqstp->rq_vec[v].iov_len) {
408 len -= rqstp->rq_vec[v].iov_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700409 v++;
NeilBrown3cc03b12006-10-04 02:15:47 -0700410 rqstp->rq_vec[v].iov_base = page_address(rqstp->rq_pages[v]);
411 rqstp->rq_vec[v].iov_len = PAGE_SIZE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700412 }
NeilBrown3cc03b12006-10-04 02:15:47 -0700413 rqstp->rq_vec[v].iov_len = len;
Peter Staubachf34b9562007-05-09 02:34:48 -0700414 args->vlen = v + 1;
415 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700416}
417
418int
Al Viro91f07162006-10-19 23:28:57 -0700419nfs3svc_decode_createargs(struct svc_rqst *rqstp, __be32 *p,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700420 struct nfsd3_createargs *args)
421{
422 if (!(p = decode_fh(p, &args->fh))
423 || !(p = decode_filename(p, &args->name, &args->len)))
424 return 0;
425
426 switch (args->createmode = ntohl(*p++)) {
427 case NFS3_CREATE_UNCHECKED:
428 case NFS3_CREATE_GUARDED:
NeilBrown072f62e2007-05-09 02:34:57 -0700429 p = decode_sattr3(p, &args->attrs);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700430 break;
431 case NFS3_CREATE_EXCLUSIVE:
432 args->verf = p;
433 p += 2;
434 break;
435 default:
436 return 0;
437 }
438
439 return xdr_argsize_check(rqstp, p);
440}
441int
Al Viro91f07162006-10-19 23:28:57 -0700442nfs3svc_decode_mkdirargs(struct svc_rqst *rqstp, __be32 *p,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700443 struct nfsd3_createargs *args)
444{
NeilBrown072f62e2007-05-09 02:34:57 -0700445 if (!(p = decode_fh(p, &args->fh)) ||
446 !(p = decode_filename(p, &args->name, &args->len)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700447 return 0;
NeilBrown072f62e2007-05-09 02:34:57 -0700448 p = decode_sattr3(p, &args->attrs);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700449
450 return xdr_argsize_check(rqstp, p);
451}
452
453int
Al Viro91f07162006-10-19 23:28:57 -0700454nfs3svc_decode_symlinkargs(struct svc_rqst *rqstp, __be32 *p,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700455 struct nfsd3_symlinkargs *args)
456{
Chuck Levera628f662007-11-01 16:57:20 -0400457 unsigned int len, avail;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700458 char *old, *new;
459 struct kvec *vec;
460
NeilBrown072f62e2007-05-09 02:34:57 -0700461 if (!(p = decode_fh(p, &args->ffh)) ||
462 !(p = decode_filename(p, &args->fname, &args->flen))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700463 )
464 return 0;
NeilBrown072f62e2007-05-09 02:34:57 -0700465 p = decode_sattr3(p, &args->attrs);
466
Linus Torvalds1da177e2005-04-16 15:20:36 -0700467 /* now decode the pathname, which might be larger than the first page.
468 * As we have to check for nul's anyway, we copy it into a new page
469 * This page appears in the rq_res.pages list, but as pages_len is always
470 * 0, it won't get in the way
471 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700472 len = ntohl(*p++);
473 if (len == 0 || len > NFS3_MAXPATHLEN || len >= PAGE_SIZE)
474 return 0;
NeilBrown44524352006-10-04 02:15:46 -0700475 args->tname = new =
476 page_address(rqstp->rq_respages[rqstp->rq_resused++]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700477 args->tlen = len;
478 /* first copy and check from the first page */
479 old = (char*)p;
480 vec = &rqstp->rq_arg.head[0];
481 avail = vec->iov_len - (old - (char*)vec->iov_base);
482 while (len && avail && *old) {
483 *new++ = *old++;
484 len--;
485 avail--;
486 }
487 /* now copy next page if there is one */
488 if (len && !avail && rqstp->rq_arg.page_len) {
489 avail = rqstp->rq_arg.page_len;
Chuck Levera628f662007-11-01 16:57:20 -0400490 if (avail > PAGE_SIZE)
491 avail = PAGE_SIZE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700492 old = page_address(rqstp->rq_arg.pages[0]);
493 }
494 while (len && avail && *old) {
495 *new++ = *old++;
496 len--;
497 avail--;
498 }
499 *new = '\0';
500 if (len)
501 return 0;
502
503 return 1;
504}
505
506int
Al Viro91f07162006-10-19 23:28:57 -0700507nfs3svc_decode_mknodargs(struct svc_rqst *rqstp, __be32 *p,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700508 struct nfsd3_mknodargs *args)
509{
510 if (!(p = decode_fh(p, &args->fh))
511 || !(p = decode_filename(p, &args->name, &args->len)))
512 return 0;
513
514 args->ftype = ntohl(*p++);
515
516 if (args->ftype == NF3BLK || args->ftype == NF3CHR
NeilBrown072f62e2007-05-09 02:34:57 -0700517 || args->ftype == NF3SOCK || args->ftype == NF3FIFO)
518 p = decode_sattr3(p, &args->attrs);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700519
520 if (args->ftype == NF3BLK || args->ftype == NF3CHR) {
521 args->major = ntohl(*p++);
522 args->minor = ntohl(*p++);
523 }
524
525 return xdr_argsize_check(rqstp, p);
526}
527
528int
Al Viro91f07162006-10-19 23:28:57 -0700529nfs3svc_decode_renameargs(struct svc_rqst *rqstp, __be32 *p,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700530 struct nfsd3_renameargs *args)
531{
532 if (!(p = decode_fh(p, &args->ffh))
533 || !(p = decode_filename(p, &args->fname, &args->flen))
534 || !(p = decode_fh(p, &args->tfh))
535 || !(p = decode_filename(p, &args->tname, &args->tlen)))
536 return 0;
537
538 return xdr_argsize_check(rqstp, p);
539}
540
541int
Al Viro91f07162006-10-19 23:28:57 -0700542nfs3svc_decode_readlinkargs(struct svc_rqst *rqstp, __be32 *p,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700543 struct nfsd3_readlinkargs *args)
544{
545 if (!(p = decode_fh(p, &args->fh)))
546 return 0;
NeilBrown44524352006-10-04 02:15:46 -0700547 args->buffer =
548 page_address(rqstp->rq_respages[rqstp->rq_resused++]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700549
550 return xdr_argsize_check(rqstp, p);
551}
552
553int
Al Viro91f07162006-10-19 23:28:57 -0700554nfs3svc_decode_linkargs(struct svc_rqst *rqstp, __be32 *p,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700555 struct nfsd3_linkargs *args)
556{
557 if (!(p = decode_fh(p, &args->ffh))
558 || !(p = decode_fh(p, &args->tfh))
559 || !(p = decode_filename(p, &args->tname, &args->tlen)))
560 return 0;
561
562 return xdr_argsize_check(rqstp, p);
563}
564
565int
Al Viro91f07162006-10-19 23:28:57 -0700566nfs3svc_decode_readdirargs(struct svc_rqst *rqstp, __be32 *p,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700567 struct nfsd3_readdirargs *args)
568{
569 if (!(p = decode_fh(p, &args->fh)))
570 return 0;
571 p = xdr_decode_hyper(p, &args->cookie);
572 args->verf = p; p += 2;
573 args->dircount = ~0;
574 args->count = ntohl(*p++);
575
576 if (args->count > PAGE_SIZE)
577 args->count = PAGE_SIZE;
578
NeilBrown44524352006-10-04 02:15:46 -0700579 args->buffer =
580 page_address(rqstp->rq_respages[rqstp->rq_resused++]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700581
582 return xdr_argsize_check(rqstp, p);
583}
584
585int
Al Viro91f07162006-10-19 23:28:57 -0700586nfs3svc_decode_readdirplusargs(struct svc_rqst *rqstp, __be32 *p,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700587 struct nfsd3_readdirargs *args)
588{
589 int len, pn;
Greg Banks7adae482006-10-04 02:15:47 -0700590 u32 max_blocksize = svc_max_payload(rqstp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700591
592 if (!(p = decode_fh(p, &args->fh)))
593 return 0;
594 p = xdr_decode_hyper(p, &args->cookie);
595 args->verf = p; p += 2;
596 args->dircount = ntohl(*p++);
597 args->count = ntohl(*p++);
598
Greg Banks7adae482006-10-04 02:15:47 -0700599 len = (args->count > max_blocksize) ? max_blocksize :
Linus Torvalds1da177e2005-04-16 15:20:36 -0700600 args->count;
601 args->count = len;
602
603 while (len > 0) {
NeilBrown44524352006-10-04 02:15:46 -0700604 pn = rqstp->rq_resused++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700605 if (!args->buffer)
606 args->buffer = page_address(rqstp->rq_respages[pn]);
607 len -= PAGE_SIZE;
608 }
609
610 return xdr_argsize_check(rqstp, p);
611}
612
613int
Al Viro91f07162006-10-19 23:28:57 -0700614nfs3svc_decode_commitargs(struct svc_rqst *rqstp, __be32 *p,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700615 struct nfsd3_commitargs *args)
616{
617 if (!(p = decode_fh(p, &args->fh)))
618 return 0;
619 p = xdr_decode_hyper(p, &args->offset);
620 args->count = ntohl(*p++);
621
622 return xdr_argsize_check(rqstp, p);
623}
624
625/*
626 * XDR encode functions
627 */
628/*
629 * There must be an encoding function for void results so svc_process
630 * will work properly.
631 */
632int
Al Viro91f07162006-10-19 23:28:57 -0700633nfs3svc_encode_voidres(struct svc_rqst *rqstp, __be32 *p, void *dummy)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700634{
635 return xdr_ressize_check(rqstp, p);
636}
637
638/* GETATTR */
639int
Al Viro91f07162006-10-19 23:28:57 -0700640nfs3svc_encode_attrstat(struct svc_rqst *rqstp, __be32 *p,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700641 struct nfsd3_attrstat *resp)
642{
Peter Staubach40ee5dc2007-08-16 12:10:07 -0400643 if (resp->status == 0) {
644 lease_get_mtime(resp->fh.fh_dentry->d_inode,
645 &resp->stat.mtime);
David Shawa334de22006-01-06 00:19:58 -0800646 p = encode_fattr3(rqstp, p, &resp->fh, &resp->stat);
Peter Staubach40ee5dc2007-08-16 12:10:07 -0400647 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700648 return xdr_ressize_check(rqstp, p);
649}
650
651/* SETATTR, REMOVE, RMDIR */
652int
Al Viro91f07162006-10-19 23:28:57 -0700653nfs3svc_encode_wccstat(struct svc_rqst *rqstp, __be32 *p,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700654 struct nfsd3_attrstat *resp)
655{
656 p = encode_wcc_data(rqstp, p, &resp->fh);
657 return xdr_ressize_check(rqstp, p);
658}
659
660/* LOOKUP */
661int
Al Viro91f07162006-10-19 23:28:57 -0700662nfs3svc_encode_diropres(struct svc_rqst *rqstp, __be32 *p,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700663 struct nfsd3_diropres *resp)
664{
665 if (resp->status == 0) {
666 p = encode_fh(p, &resp->fh);
667 p = encode_post_op_attr(rqstp, p, &resp->fh);
668 }
669 p = encode_post_op_attr(rqstp, p, &resp->dirfh);
670 return xdr_ressize_check(rqstp, p);
671}
672
673/* ACCESS */
674int
Al Viro91f07162006-10-19 23:28:57 -0700675nfs3svc_encode_accessres(struct svc_rqst *rqstp, __be32 *p,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700676 struct nfsd3_accessres *resp)
677{
678 p = encode_post_op_attr(rqstp, p, &resp->fh);
679 if (resp->status == 0)
680 *p++ = htonl(resp->access);
681 return xdr_ressize_check(rqstp, p);
682}
683
684/* READLINK */
685int
Al Viro91f07162006-10-19 23:28:57 -0700686nfs3svc_encode_readlinkres(struct svc_rqst *rqstp, __be32 *p,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700687 struct nfsd3_readlinkres *resp)
688{
689 p = encode_post_op_attr(rqstp, p, &resp->fh);
690 if (resp->status == 0) {
691 *p++ = htonl(resp->len);
692 xdr_ressize_check(rqstp, p);
693 rqstp->rq_res.page_len = resp->len;
694 if (resp->len & 3) {
695 /* need to pad the tail */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700696 rqstp->rq_res.tail[0].iov_base = p;
697 *p = 0;
698 rqstp->rq_res.tail[0].iov_len = 4 - (resp->len&3);
699 }
700 return 1;
701 } else
702 return xdr_ressize_check(rqstp, p);
703}
704
705/* READ */
706int
Al Viro91f07162006-10-19 23:28:57 -0700707nfs3svc_encode_readres(struct svc_rqst *rqstp, __be32 *p,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700708 struct nfsd3_readres *resp)
709{
710 p = encode_post_op_attr(rqstp, p, &resp->fh);
711 if (resp->status == 0) {
712 *p++ = htonl(resp->count);
713 *p++ = htonl(resp->eof);
714 *p++ = htonl(resp->count); /* xdr opaque count */
715 xdr_ressize_check(rqstp, p);
716 /* now update rqstp->rq_res to reflect data aswell */
717 rqstp->rq_res.page_len = resp->count;
718 if (resp->count & 3) {
719 /* need to pad the tail */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700720 rqstp->rq_res.tail[0].iov_base = p;
721 *p = 0;
722 rqstp->rq_res.tail[0].iov_len = 4 - (resp->count & 3);
723 }
724 return 1;
725 } else
726 return xdr_ressize_check(rqstp, p);
727}
728
729/* WRITE */
730int
Al Viro91f07162006-10-19 23:28:57 -0700731nfs3svc_encode_writeres(struct svc_rqst *rqstp, __be32 *p,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700732 struct nfsd3_writeres *resp)
733{
734 p = encode_wcc_data(rqstp, p, &resp->fh);
735 if (resp->status == 0) {
736 *p++ = htonl(resp->count);
737 *p++ = htonl(resp->committed);
738 *p++ = htonl(nfssvc_boot.tv_sec);
739 *p++ = htonl(nfssvc_boot.tv_usec);
740 }
741 return xdr_ressize_check(rqstp, p);
742}
743
744/* CREATE, MKDIR, SYMLINK, MKNOD */
745int
Al Viro91f07162006-10-19 23:28:57 -0700746nfs3svc_encode_createres(struct svc_rqst *rqstp, __be32 *p,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700747 struct nfsd3_diropres *resp)
748{
749 if (resp->status == 0) {
750 *p++ = xdr_one;
751 p = encode_fh(p, &resp->fh);
752 p = encode_post_op_attr(rqstp, p, &resp->fh);
753 }
754 p = encode_wcc_data(rqstp, p, &resp->dirfh);
755 return xdr_ressize_check(rqstp, p);
756}
757
758/* RENAME */
759int
Al Viro91f07162006-10-19 23:28:57 -0700760nfs3svc_encode_renameres(struct svc_rqst *rqstp, __be32 *p,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700761 struct nfsd3_renameres *resp)
762{
763 p = encode_wcc_data(rqstp, p, &resp->ffh);
764 p = encode_wcc_data(rqstp, p, &resp->tfh);
765 return xdr_ressize_check(rqstp, p);
766}
767
768/* LINK */
769int
Al Viro91f07162006-10-19 23:28:57 -0700770nfs3svc_encode_linkres(struct svc_rqst *rqstp, __be32 *p,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700771 struct nfsd3_linkres *resp)
772{
773 p = encode_post_op_attr(rqstp, p, &resp->fh);
774 p = encode_wcc_data(rqstp, p, &resp->tfh);
775 return xdr_ressize_check(rqstp, p);
776}
777
778/* READDIR */
779int
Al Viro91f07162006-10-19 23:28:57 -0700780nfs3svc_encode_readdirres(struct svc_rqst *rqstp, __be32 *p,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700781 struct nfsd3_readdirres *resp)
782{
783 p = encode_post_op_attr(rqstp, p, &resp->fh);
784
785 if (resp->status == 0) {
786 /* stupid readdir cookie */
787 memcpy(p, resp->verf, 8); p += 2;
788 xdr_ressize_check(rqstp, p);
789 if (rqstp->rq_res.head[0].iov_len + (2<<2) > PAGE_SIZE)
790 return 1; /*No room for trailer */
791 rqstp->rq_res.page_len = (resp->count) << 2;
792
793 /* add the 'tail' to the end of the 'head' page - page 0. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700794 rqstp->rq_res.tail[0].iov_base = p;
795 *p++ = 0; /* no more entries */
796 *p++ = htonl(resp->common.err == nfserr_eof);
797 rqstp->rq_res.tail[0].iov_len = 2<<2;
798 return 1;
799 } else
800 return xdr_ressize_check(rqstp, p);
801}
802
Adrian Bunk3ee6f612006-12-06 20:40:23 -0800803static __be32 *
Al Viro91f07162006-10-19 23:28:57 -0700804encode_entry_baggage(struct nfsd3_readdirres *cd, __be32 *p, const char *name,
Peter Staubach40ee5dc2007-08-16 12:10:07 -0400805 int namlen, u64 ino)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700806{
807 *p++ = xdr_one; /* mark entry present */
808 p = xdr_encode_hyper(p, ino); /* file id */
809 p = xdr_encode_array(p, name, namlen);/* name length & name */
810
811 cd->offset = p; /* remember pointer */
812 p = xdr_encode_hyper(p, NFS_OFFSET_MAX);/* offset of next entry */
813
814 return p;
815}
816
Adrian Bunk3ee6f612006-12-06 20:40:23 -0800817static __be32 *
Al Viro91f07162006-10-19 23:28:57 -0700818encode_entryplus_baggage(struct nfsd3_readdirres *cd, __be32 *p,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700819 struct svc_fh *fhp)
820{
J. Bruce Fields99d965e2007-11-21 14:10:07 -0500821 p = encode_post_op_attr(cd->rqstp, p, fhp);
822 *p++ = xdr_one; /* yes, a file handle follows */
823 p = encode_fh(p, fhp);
824 fh_put(fhp);
825 return p;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700826}
827
828static int
829compose_entry_fh(struct nfsd3_readdirres *cd, struct svc_fh *fhp,
830 const char *name, int namlen)
831{
832 struct svc_export *exp;
833 struct dentry *dparent, *dchild;
834 int rv = 0;
835
836 dparent = cd->fh.fh_dentry;
837 exp = cd->fh.fh_export;
838
839 fh_init(fhp, NFS3_FHSIZE);
840 if (isdotent(name, namlen)) {
841 if (namlen == 2) {
842 dchild = dget_parent(dparent);
843 if (dchild == dparent) {
844 /* filesystem root - cannot return filehandle for ".." */
845 dput(dchild);
846 return 1;
847 }
848 } else
849 dchild = dget(dparent);
850 } else
851 dchild = lookup_one_len(name, dparent, namlen);
852 if (IS_ERR(dchild))
853 return 1;
854 if (d_mountpoint(dchild) ||
855 fh_compose(fhp, exp, dchild, &cd->fh) != 0 ||
856 !dchild->d_inode)
857 rv = 1;
858 dput(dchild);
859 return rv;
860}
861
862/*
863 * Encode a directory entry. This one works for both normal readdir
864 * and readdirplus.
865 * The normal readdir reply requires 2 (fileid) + 1 (stringlen)
866 * + string + 2 (cookie) + 1 (next) words, i.e. 6 + strlen.
867 *
868 * The readdirplus baggage is 1+21 words for post_op_attr, plus the
869 * file handle.
870 */
871
872#define NFS3_ENTRY_BAGGAGE (2 + 1 + 2 + 1)
873#define NFS3_ENTRYPLUS_BAGGAGE (1 + 21 + 1 + (NFS3_FHSIZE >> 2))
874static int
NeilBrown598b9a52007-03-26 21:32:08 -0800875encode_entry(struct readdir_cd *ccd, const char *name, int namlen,
Peter Staubach40ee5dc2007-08-16 12:10:07 -0400876 loff_t offset, u64 ino, unsigned int d_type, int plus)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700877{
878 struct nfsd3_readdirres *cd = container_of(ccd, struct nfsd3_readdirres,
879 common);
Al Viro91f07162006-10-19 23:28:57 -0700880 __be32 *p = cd->buffer;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700881 caddr_t curr_page_addr = NULL;
882 int pn; /* current page number */
883 int slen; /* string (name) length */
884 int elen; /* estimated entry length in words */
885 int num_entry_words = 0; /* actual number of words */
886
887 if (cd->offset) {
888 u64 offset64 = offset;
889
890 if (unlikely(cd->offset1)) {
891 /* we ended up with offset on a page boundary */
892 *cd->offset = htonl(offset64 >> 32);
893 *cd->offset1 = htonl(offset64 & 0xffffffff);
894 cd->offset1 = NULL;
895 } else {
NeilBrown598b9a52007-03-26 21:32:08 -0800896 xdr_encode_hyper(cd->offset, offset64);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700897 }
898 }
899
900 /*
901 dprintk("encode_entry(%.*s @%ld%s)\n",
902 namlen, name, (long) offset, plus? " plus" : "");
903 */
904
905 /* truncate filename if too long */
906 if (namlen > NFS3_MAXNAMLEN)
907 namlen = NFS3_MAXNAMLEN;
908
909 slen = XDR_QUADLEN(namlen);
910 elen = slen + NFS3_ENTRY_BAGGAGE
911 + (plus? NFS3_ENTRYPLUS_BAGGAGE : 0);
912
913 if (cd->buflen < elen) {
914 cd->common.err = nfserr_toosmall;
915 return -EINVAL;
916 }
917
918 /* determine which page in rq_respages[] we are currently filling */
919 for (pn=1; pn < cd->rqstp->rq_resused; pn++) {
920 curr_page_addr = page_address(cd->rqstp->rq_respages[pn]);
921
922 if (((caddr_t)cd->buffer >= curr_page_addr) &&
923 ((caddr_t)cd->buffer < curr_page_addr + PAGE_SIZE))
924 break;
925 }
926
927 if ((caddr_t)(cd->buffer + elen) < (curr_page_addr + PAGE_SIZE)) {
928 /* encode entry in current page */
929
930 p = encode_entry_baggage(cd, p, name, namlen, ino);
931
932 /* throw in readdirplus baggage */
933 if (plus) {
934 struct svc_fh fh;
935
936 if (compose_entry_fh(cd, &fh, name, namlen) > 0) {
937 *p++ = 0;
938 *p++ = 0;
939 } else
940 p = encode_entryplus_baggage(cd, p, &fh);
941 }
942 num_entry_words = p - cd->buffer;
943 } else if (cd->rqstp->rq_respages[pn+1] != NULL) {
944 /* temporarily encode entry into next page, then move back to
945 * current and next page in rq_respages[] */
Al Viro91f07162006-10-19 23:28:57 -0700946 __be32 *p1, *tmp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700947 int len1, len2;
948
949 /* grab next page for temporary storage of entry */
950 p1 = tmp = page_address(cd->rqstp->rq_respages[pn+1]);
951
952 p1 = encode_entry_baggage(cd, p1, name, namlen, ino);
953
954 /* throw in readdirplus baggage */
955 if (plus) {
956 struct svc_fh fh;
957
958 if (compose_entry_fh(cd, &fh, name, namlen) > 0) {
959 /* zero out the filehandle */
960 *p1++ = 0;
961 *p1++ = 0;
962 } else
963 p1 = encode_entryplus_baggage(cd, p1, &fh);
964 }
965
966 /* determine entry word length and lengths to go in pages */
967 num_entry_words = p1 - tmp;
968 len1 = curr_page_addr + PAGE_SIZE - (caddr_t)cd->buffer;
969 if ((num_entry_words << 2) < len1) {
970 /* the actual number of words in the entry is less
971 * than elen and can still fit in the current page
972 */
973 memmove(p, tmp, num_entry_words << 2);
974 p += num_entry_words;
975
976 /* update offset */
977 cd->offset = cd->buffer + (cd->offset - tmp);
978 } else {
979 unsigned int offset_r = (cd->offset - tmp) << 2;
980
981 /* update pointer to offset location.
982 * This is a 64bit quantity, so we need to
983 * deal with 3 cases:
984 * - entirely in first page
985 * - entirely in second page
986 * - 4 bytes in each page
987 */
988 if (offset_r + 8 <= len1) {
989 cd->offset = p + (cd->offset - tmp);
990 } else if (offset_r >= len1) {
991 cd->offset -= len1 >> 2;
992 } else {
993 /* sitting on the fence */
994 BUG_ON(offset_r != len1 - 4);
995 cd->offset = p + (cd->offset - tmp);
996 cd->offset1 = tmp;
997 }
998
999 len2 = (num_entry_words << 2) - len1;
1000
1001 /* move from temp page to current and next pages */
1002 memmove(p, tmp, len1);
1003 memmove(tmp, (caddr_t)tmp+len1, len2);
1004
1005 p = tmp + (len2 >> 2);
1006 }
1007 }
1008 else {
1009 cd->common.err = nfserr_toosmall;
1010 return -EINVAL;
1011 }
1012
1013 cd->buflen -= num_entry_words;
1014 cd->buffer = p;
1015 cd->common.err = nfs_ok;
1016 return 0;
1017
1018}
1019
1020int
NeilBrowna0ad13e2007-01-26 00:57:10 -08001021nfs3svc_encode_entry(void *cd, const char *name,
1022 int namlen, loff_t offset, u64 ino, unsigned int d_type)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001023{
1024 return encode_entry(cd, name, namlen, offset, ino, d_type, 0);
1025}
1026
1027int
NeilBrowna0ad13e2007-01-26 00:57:10 -08001028nfs3svc_encode_entry_plus(void *cd, const char *name,
1029 int namlen, loff_t offset, u64 ino,
1030 unsigned int d_type)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001031{
1032 return encode_entry(cd, name, namlen, offset, ino, d_type, 1);
1033}
1034
1035/* FSSTAT */
1036int
Al Viro91f07162006-10-19 23:28:57 -07001037nfs3svc_encode_fsstatres(struct svc_rqst *rqstp, __be32 *p,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001038 struct nfsd3_fsstatres *resp)
1039{
1040 struct kstatfs *s = &resp->stats;
1041 u64 bs = s->f_bsize;
1042
1043 *p++ = xdr_zero; /* no post_op_attr */
1044
1045 if (resp->status == 0) {
1046 p = xdr_encode_hyper(p, bs * s->f_blocks); /* total bytes */
1047 p = xdr_encode_hyper(p, bs * s->f_bfree); /* free bytes */
1048 p = xdr_encode_hyper(p, bs * s->f_bavail); /* user available bytes */
1049 p = xdr_encode_hyper(p, s->f_files); /* total inodes */
1050 p = xdr_encode_hyper(p, s->f_ffree); /* free inodes */
1051 p = xdr_encode_hyper(p, s->f_ffree); /* user available inodes */
1052 *p++ = htonl(resp->invarsec); /* mean unchanged time */
1053 }
1054 return xdr_ressize_check(rqstp, p);
1055}
1056
1057/* FSINFO */
1058int
Al Viro91f07162006-10-19 23:28:57 -07001059nfs3svc_encode_fsinfores(struct svc_rqst *rqstp, __be32 *p,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001060 struct nfsd3_fsinfores *resp)
1061{
1062 *p++ = xdr_zero; /* no post_op_attr */
1063
1064 if (resp->status == 0) {
1065 *p++ = htonl(resp->f_rtmax);
1066 *p++ = htonl(resp->f_rtpref);
1067 *p++ = htonl(resp->f_rtmult);
1068 *p++ = htonl(resp->f_wtmax);
1069 *p++ = htonl(resp->f_wtpref);
1070 *p++ = htonl(resp->f_wtmult);
1071 *p++ = htonl(resp->f_dtpref);
1072 p = xdr_encode_hyper(p, resp->f_maxfilesize);
1073 *p++ = xdr_one;
1074 *p++ = xdr_zero;
1075 *p++ = htonl(resp->f_properties);
1076 }
1077
1078 return xdr_ressize_check(rqstp, p);
1079}
1080
1081/* PATHCONF */
1082int
Al Viro91f07162006-10-19 23:28:57 -07001083nfs3svc_encode_pathconfres(struct svc_rqst *rqstp, __be32 *p,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001084 struct nfsd3_pathconfres *resp)
1085{
1086 *p++ = xdr_zero; /* no post_op_attr */
1087
1088 if (resp->status == 0) {
1089 *p++ = htonl(resp->p_link_max);
1090 *p++ = htonl(resp->p_name_max);
1091 *p++ = htonl(resp->p_no_trunc);
1092 *p++ = htonl(resp->p_chown_restricted);
1093 *p++ = htonl(resp->p_case_insensitive);
1094 *p++ = htonl(resp->p_case_preserving);
1095 }
1096
1097 return xdr_ressize_check(rqstp, p);
1098}
1099
1100/* COMMIT */
1101int
Al Viro91f07162006-10-19 23:28:57 -07001102nfs3svc_encode_commitres(struct svc_rqst *rqstp, __be32 *p,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001103 struct nfsd3_commitres *resp)
1104{
1105 p = encode_wcc_data(rqstp, p, &resp->fh);
1106 /* Write verifier */
1107 if (resp->status == 0) {
1108 *p++ = htonl(nfssvc_boot.tv_sec);
1109 *p++ = htonl(nfssvc_boot.tv_usec);
1110 }
1111 return xdr_ressize_check(rqstp, p);
1112}
1113
1114/*
1115 * XDR release functions
1116 */
1117int
Al Viro91f07162006-10-19 23:28:57 -07001118nfs3svc_release_fhandle(struct svc_rqst *rqstp, __be32 *p,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001119 struct nfsd3_attrstat *resp)
1120{
1121 fh_put(&resp->fh);
1122 return 1;
1123}
1124
1125int
Al Viro91f07162006-10-19 23:28:57 -07001126nfs3svc_release_fhandle2(struct svc_rqst *rqstp, __be32 *p,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001127 struct nfsd3_fhandle_pair *resp)
1128{
1129 fh_put(&resp->fh1);
1130 fh_put(&resp->fh2);
1131 return 1;
1132}