4 * Copyright (C) 1995, 1996 Olaf Kirch <okir@monad.swb.de>
10 #define NFSDDBG_FACILITY NFSDDBG_XDR
13 * Mapping of S_IF* types to NFS file types
15 static u32 nfs_ftypes[] = {
16 NFNON, NFCHR, NFCHR, NFBAD,
17 NFDIR, NFBAD, NFBLK, NFBAD,
18 NFREG, NFBAD, NFLNK, NFBAD,
19 NFSOCK, NFBAD, NFLNK, NFBAD,
24 * XDR functions for basic NFS types
27 decode_fh(__be32 *p, struct svc_fh *fhp)
29 fh_init(fhp, NFS_FHSIZE);
30 memcpy(&fhp->fh_handle.fh_base, p, NFS_FHSIZE);
31 fhp->fh_handle.fh_size = NFS_FHSIZE;
33 /* FIXME: Look up export pointer here and verify
34 * Sun Secure RPC if requested */
35 return p + (NFS_FHSIZE >> 2);
38 /* Helper function for NFSv2 ACL code */
39 __be32 *nfs2svc_decode_fh(__be32 *p, struct svc_fh *fhp)
41 return decode_fh(p, fhp);
45 encode_fh(__be32 *p, struct svc_fh *fhp)
47 memcpy(p, &fhp->fh_handle.fh_base, NFS_FHSIZE);
48 return p + (NFS_FHSIZE>> 2);
52 * Decode a file name and make sure that the path contains
53 * no slashes or null bytes.
56 decode_filename(__be32 *p, char **namp, unsigned int *lenp)
61 if ((p = xdr_decode_string_inplace(p, namp, lenp, NFS_MAXNAMLEN)) != NULL) {
62 for (i = 0, name = *namp; i < *lenp; i++, name++) {
63 if (*name == '\0' || *name == '/')
72 decode_pathname(__be32 *p, char **namp, unsigned int *lenp)
77 if ((p = xdr_decode_string_inplace(p, namp, lenp, NFS_MAXPATHLEN)) != NULL) {
78 for (i = 0, name = *namp; i < *lenp; i++, name++) {
88 decode_sattr(__be32 *p, struct iattr *iap)
94 /* Sun client bug compatibility check: some sun clients seem to
95 * put 0xffff in the mode field when they mean 0xffffffff.
96 * Quoting the 4.4BSD nfs server code: Nah nah nah nah na nah.
98 if ((tmp = ntohl(*p++)) != (u32)-1 && tmp != 0xffff) {
99 iap->ia_valid |= ATTR_MODE;
102 if ((tmp = ntohl(*p++)) != (u32)-1) {
103 iap->ia_uid = make_kuid(&init_user_ns, tmp);
104 if (uid_valid(iap->ia_uid))
105 iap->ia_valid |= ATTR_UID;
107 if ((tmp = ntohl(*p++)) != (u32)-1) {
108 iap->ia_gid = make_kgid(&init_user_ns, tmp);
109 if (gid_valid(iap->ia_gid))
110 iap->ia_valid |= ATTR_GID;
112 if ((tmp = ntohl(*p++)) != (u32)-1) {
113 iap->ia_valid |= ATTR_SIZE;
116 tmp = ntohl(*p++); tmp1 = ntohl(*p++);
117 if (tmp != (u32)-1 && tmp1 != (u32)-1) {
118 iap->ia_valid |= ATTR_ATIME | ATTR_ATIME_SET;
119 iap->ia_atime.tv_sec = tmp;
120 iap->ia_atime.tv_nsec = tmp1 * 1000;
122 tmp = ntohl(*p++); tmp1 = ntohl(*p++);
123 if (tmp != (u32)-1 && tmp1 != (u32)-1) {
124 iap->ia_valid |= ATTR_MTIME | ATTR_MTIME_SET;
125 iap->ia_mtime.tv_sec = tmp;
126 iap->ia_mtime.tv_nsec = tmp1 * 1000;
128 * Passing the invalid value useconds=1000000 for mtime
129 * is a Sun convention for "set both mtime and atime to
130 * current server time". It's needed to make permissions
131 * checks for the "touch" program across v2 mounts to
132 * Solaris and Irix boxes work correctly. See description of
133 * sattr in section 6.1 of "NFS Illustrated" by
134 * Brent Callaghan, Addison-Wesley, ISBN 0-201-32750-5
137 iap->ia_valid &= ~(ATTR_ATIME_SET|ATTR_MTIME_SET);
143 encode_fattr(struct svc_rqst *rqstp, __be32 *p, struct svc_fh *fhp,
146 struct dentry *dentry = fhp->fh_dentry;
148 struct timespec time;
151 type = (stat->mode & S_IFMT);
153 *p++ = htonl(nfs_ftypes[type >> 12]);
154 *p++ = htonl((u32) stat->mode);
155 *p++ = htonl((u32) stat->nlink);
156 *p++ = htonl((u32) from_kuid(&init_user_ns, stat->uid));
157 *p++ = htonl((u32) from_kgid(&init_user_ns, stat->gid));
159 if (S_ISLNK(type) && stat->size > NFS_MAXPATHLEN) {
160 *p++ = htonl(NFS_MAXPATHLEN);
162 *p++ = htonl((u32) stat->size);
164 *p++ = htonl((u32) stat->blksize);
165 if (S_ISCHR(type) || S_ISBLK(type))
166 *p++ = htonl(new_encode_dev(stat->rdev));
168 *p++ = htonl(0xffffffff);
169 *p++ = htonl((u32) stat->blocks);
170 switch (fsid_source(fhp)) {
173 *p++ = htonl(new_encode_dev(stat->dev));
175 case FSIDSOURCE_FSID:
176 *p++ = htonl((u32) fhp->fh_export->ex_fsid);
178 case FSIDSOURCE_UUID:
179 f = ((u32*)fhp->fh_export->ex_uuid)[0];
180 f ^= ((u32*)fhp->fh_export->ex_uuid)[1];
181 f ^= ((u32*)fhp->fh_export->ex_uuid)[2];
182 f ^= ((u32*)fhp->fh_export->ex_uuid)[3];
186 *p++ = htonl((u32) stat->ino);
187 *p++ = htonl((u32) stat->atime.tv_sec);
188 *p++ = htonl(stat->atime.tv_nsec ? stat->atime.tv_nsec / 1000 : 0);
189 lease_get_mtime(dentry->d_inode, &time);
190 *p++ = htonl((u32) time.tv_sec);
191 *p++ = htonl(time.tv_nsec ? time.tv_nsec / 1000 : 0);
192 *p++ = htonl((u32) stat->ctime.tv_sec);
193 *p++ = htonl(stat->ctime.tv_nsec ? stat->ctime.tv_nsec / 1000 : 0);
198 /* Helper function for NFSv2 ACL code */
199 __be32 *nfs2svc_encode_fattr(struct svc_rqst *rqstp, __be32 *p, struct svc_fh *fhp)
202 vfs_getattr(fhp->fh_export->ex_path.mnt, fhp->fh_dentry, &stat);
203 return encode_fattr(rqstp, p, fhp, &stat);
207 * XDR decode functions
210 nfssvc_decode_void(struct svc_rqst *rqstp, __be32 *p, void *dummy)
212 return xdr_argsize_check(rqstp, p);
216 nfssvc_decode_fhandle(struct svc_rqst *rqstp, __be32 *p, struct nfsd_fhandle *args)
218 if (!(p = decode_fh(p, &args->fh)))
220 return xdr_argsize_check(rqstp, p);
224 nfssvc_decode_sattrargs(struct svc_rqst *rqstp, __be32 *p,
225 struct nfsd_sattrargs *args)
227 p = decode_fh(p, &args->fh);
230 p = decode_sattr(p, &args->attrs);
232 return xdr_argsize_check(rqstp, p);
236 nfssvc_decode_diropargs(struct svc_rqst *rqstp, __be32 *p,
237 struct nfsd_diropargs *args)
239 if (!(p = decode_fh(p, &args->fh))
240 || !(p = decode_filename(p, &args->name, &args->len)))
243 return xdr_argsize_check(rqstp, p);
247 nfssvc_decode_readargs(struct svc_rqst *rqstp, __be32 *p,
248 struct nfsd_readargs *args)
252 if (!(p = decode_fh(p, &args->fh)))
255 args->offset = ntohl(*p++);
256 len = args->count = ntohl(*p++);
257 p++; /* totalcount - unused */
259 if (len > NFSSVC_MAXBLKSIZE_V2)
260 len = NFSSVC_MAXBLKSIZE_V2;
262 /* set up somewhere to store response.
263 * We take pages, put them on reslist and include in iovec
267 struct page *p = *(rqstp->rq_next_page++);
269 rqstp->rq_vec[v].iov_base = page_address(p);
270 rqstp->rq_vec[v].iov_len = len < PAGE_SIZE?len:PAGE_SIZE;
271 len -= rqstp->rq_vec[v].iov_len;
275 return xdr_argsize_check(rqstp, p);
279 nfssvc_decode_writeargs(struct svc_rqst *rqstp, __be32 *p,
280 struct nfsd_writeargs *args)
282 unsigned int len, hdr, dlen;
285 if (!(p = decode_fh(p, &args->fh)))
288 p++; /* beginoffset */
289 args->offset = ntohl(*p++); /* offset */
290 p++; /* totalcount */
291 len = args->len = ntohl(*p++);
293 * The protocol specifies a maximum of 8192 bytes.
295 if (len > NFSSVC_MAXBLKSIZE_V2)
299 * Check to make sure that we got the right number of
302 hdr = (void*)p - rqstp->rq_arg.head[0].iov_base;
303 dlen = rqstp->rq_arg.head[0].iov_len + rqstp->rq_arg.page_len
307 * Round the length of the data which was specified up to
308 * the next multiple of XDR units and then compare that
309 * against the length which was actually received.
310 * Note that when RPCSEC/GSS (for example) is used, the
311 * data buffer can be padded so dlen might be larger
312 * than required. It must never be smaller.
314 if (dlen < XDR_QUADLEN(len)*4)
317 rqstp->rq_vec[0].iov_base = (void*)p;
318 rqstp->rq_vec[0].iov_len = rqstp->rq_arg.head[0].iov_len - hdr;
320 while (len > rqstp->rq_vec[v].iov_len) {
321 len -= rqstp->rq_vec[v].iov_len;
323 rqstp->rq_vec[v].iov_base = page_address(rqstp->rq_pages[v]);
324 rqstp->rq_vec[v].iov_len = PAGE_SIZE;
326 rqstp->rq_vec[v].iov_len = len;
332 nfssvc_decode_createargs(struct svc_rqst *rqstp, __be32 *p,
333 struct nfsd_createargs *args)
335 if ( !(p = decode_fh(p, &args->fh))
336 || !(p = decode_filename(p, &args->name, &args->len)))
338 p = decode_sattr(p, &args->attrs);
340 return xdr_argsize_check(rqstp, p);
344 nfssvc_decode_renameargs(struct svc_rqst *rqstp, __be32 *p,
345 struct nfsd_renameargs *args)
347 if (!(p = decode_fh(p, &args->ffh))
348 || !(p = decode_filename(p, &args->fname, &args->flen))
349 || !(p = decode_fh(p, &args->tfh))
350 || !(p = decode_filename(p, &args->tname, &args->tlen)))
353 return xdr_argsize_check(rqstp, p);
357 nfssvc_decode_readlinkargs(struct svc_rqst *rqstp, __be32 *p, struct nfsd_readlinkargs *args)
359 if (!(p = decode_fh(p, &args->fh)))
361 args->buffer = page_address(*(rqstp->rq_next_page++));
363 return xdr_argsize_check(rqstp, p);
367 nfssvc_decode_linkargs(struct svc_rqst *rqstp, __be32 *p,
368 struct nfsd_linkargs *args)
370 if (!(p = decode_fh(p, &args->ffh))
371 || !(p = decode_fh(p, &args->tfh))
372 || !(p = decode_filename(p, &args->tname, &args->tlen)))
375 return xdr_argsize_check(rqstp, p);
379 nfssvc_decode_symlinkargs(struct svc_rqst *rqstp, __be32 *p,
380 struct nfsd_symlinkargs *args)
382 if ( !(p = decode_fh(p, &args->ffh))
383 || !(p = decode_filename(p, &args->fname, &args->flen))
384 || !(p = decode_pathname(p, &args->tname, &args->tlen)))
386 p = decode_sattr(p, &args->attrs);
388 return xdr_argsize_check(rqstp, p);
392 nfssvc_decode_readdirargs(struct svc_rqst *rqstp, __be32 *p,
393 struct nfsd_readdirargs *args)
395 if (!(p = decode_fh(p, &args->fh)))
397 args->cookie = ntohl(*p++);
398 args->count = ntohl(*p++);
399 if (args->count > PAGE_SIZE)
400 args->count = PAGE_SIZE;
402 args->buffer = page_address(*(rqstp->rq_next_page++));
404 return xdr_argsize_check(rqstp, p);
408 * XDR encode functions
411 nfssvc_encode_void(struct svc_rqst *rqstp, __be32 *p, void *dummy)
413 return xdr_ressize_check(rqstp, p);
417 nfssvc_encode_attrstat(struct svc_rqst *rqstp, __be32 *p,
418 struct nfsd_attrstat *resp)
420 p = encode_fattr(rqstp, p, &resp->fh, &resp->stat);
421 return xdr_ressize_check(rqstp, p);
425 nfssvc_encode_diropres(struct svc_rqst *rqstp, __be32 *p,
426 struct nfsd_diropres *resp)
428 p = encode_fh(p, &resp->fh);
429 p = encode_fattr(rqstp, p, &resp->fh, &resp->stat);
430 return xdr_ressize_check(rqstp, p);
434 nfssvc_encode_readlinkres(struct svc_rqst *rqstp, __be32 *p,
435 struct nfsd_readlinkres *resp)
437 *p++ = htonl(resp->len);
438 xdr_ressize_check(rqstp, p);
439 rqstp->rq_res.page_len = resp->len;
441 /* need to pad the tail */
442 rqstp->rq_res.tail[0].iov_base = p;
444 rqstp->rq_res.tail[0].iov_len = 4 - (resp->len&3);
450 nfssvc_encode_readres(struct svc_rqst *rqstp, __be32 *p,
451 struct nfsd_readres *resp)
453 p = encode_fattr(rqstp, p, &resp->fh, &resp->stat);
454 *p++ = htonl(resp->count);
455 xdr_ressize_check(rqstp, p);
457 /* now update rqstp->rq_res to reflect data as well */
458 rqstp->rq_res.page_len = resp->count;
459 if (resp->count & 3) {
460 /* need to pad the tail */
461 rqstp->rq_res.tail[0].iov_base = p;
463 rqstp->rq_res.tail[0].iov_len = 4 - (resp->count&3);
469 nfssvc_encode_readdirres(struct svc_rqst *rqstp, __be32 *p,
470 struct nfsd_readdirres *resp)
472 xdr_ressize_check(rqstp, p);
474 *p++ = 0; /* no more entries */
475 *p++ = htonl((resp->common.err == nfserr_eof));
476 rqstp->rq_res.page_len = (((unsigned long)p-1) & ~PAGE_MASK)+1;
482 nfssvc_encode_statfsres(struct svc_rqst *rqstp, __be32 *p,
483 struct nfsd_statfsres *resp)
485 struct kstatfs *stat = &resp->stats;
487 *p++ = htonl(NFSSVC_MAXBLKSIZE_V2); /* max transfer size */
488 *p++ = htonl(stat->f_bsize);
489 *p++ = htonl(stat->f_blocks);
490 *p++ = htonl(stat->f_bfree);
491 *p++ = htonl(stat->f_bavail);
492 return xdr_ressize_check(rqstp, p);
496 nfssvc_encode_entry(void *ccdv, const char *name,
497 int namlen, loff_t offset, u64 ino, unsigned int d_type)
499 struct readdir_cd *ccd = ccdv;
500 struct nfsd_readdirres *cd = container_of(ccd, struct nfsd_readdirres, common);
501 __be32 *p = cd->buffer;
505 dprintk("nfsd: entry(%.*s off %ld ino %ld)\n",
506 namlen, name, offset, ino);
509 if (offset > ~((u32) 0)) {
510 cd->common.err = nfserr_fbig;
514 *cd->offset = htonl(offset);
515 if (namlen > NFS2_MAXNAMLEN)
516 namlen = NFS2_MAXNAMLEN;/* truncate filename */
518 slen = XDR_QUADLEN(namlen);
519 if ((buflen = cd->buflen - slen - 4) < 0) {
520 cd->common.err = nfserr_toosmall;
523 if (ino > ~((u32) 0)) {
524 cd->common.err = nfserr_fbig;
527 *p++ = xdr_one; /* mark entry present */
528 *p++ = htonl((u32) ino); /* file id */
529 p = xdr_encode_array(p, name, namlen);/* name length & name */
530 cd->offset = p; /* remember pointer */
531 *p++ = htonl(~0U); /* offset of next entry */
535 cd->common.err = nfs_ok;
540 * XDR release functions
543 nfssvc_release_fhandle(struct svc_rqst *rqstp, __be32 *p,
544 struct nfsd_fhandle *resp)