4 * Copyright (C) 1995, 1996 Olaf Kirch <okir@monad.swb.de>
11 #define NFSDDBG_FACILITY NFSDDBG_XDR
14 * Mapping of S_IF* types to NFS file types
16 static u32 nfs_ftypes
[] = {
17 NFNON
, NFCHR
, NFCHR
, NFBAD
,
18 NFDIR
, NFBAD
, NFBLK
, NFBAD
,
19 NFREG
, NFBAD
, NFLNK
, NFBAD
,
20 NFSOCK
, NFBAD
, NFLNK
, NFBAD
,
25 * XDR functions for basic NFS types
28 decode_fh(__be32
*p
, struct svc_fh
*fhp
)
30 fh_init(fhp
, NFS_FHSIZE
);
31 memcpy(&fhp
->fh_handle
.fh_base
, p
, NFS_FHSIZE
);
32 fhp
->fh_handle
.fh_size
= NFS_FHSIZE
;
34 /* FIXME: Look up export pointer here and verify
35 * Sun Secure RPC if requested */
36 return p
+ (NFS_FHSIZE
>> 2);
39 /* Helper function for NFSv2 ACL code */
40 __be32
*nfs2svc_decode_fh(__be32
*p
, struct svc_fh
*fhp
)
42 return decode_fh(p
, fhp
);
46 encode_fh(__be32
*p
, struct svc_fh
*fhp
)
48 memcpy(p
, &fhp
->fh_handle
.fh_base
, NFS_FHSIZE
);
49 return p
+ (NFS_FHSIZE
>> 2);
53 * Decode a file name and make sure that the path contains
54 * no slashes or null bytes.
57 decode_filename(__be32
*p
, char **namp
, unsigned int *lenp
)
62 if ((p
= xdr_decode_string_inplace(p
, namp
, lenp
, NFS_MAXNAMLEN
)) != NULL
) {
63 for (i
= 0, name
= *namp
; i
< *lenp
; i
++, name
++) {
64 if (*name
== '\0' || *name
== '/')
73 decode_pathname(__be32
*p
, char **namp
, unsigned int *lenp
)
78 if ((p
= xdr_decode_string_inplace(p
, namp
, lenp
, NFS_MAXPATHLEN
)) != NULL
) {
79 for (i
= 0, name
= *namp
; i
< *lenp
; i
++, name
++) {
89 decode_sattr(__be32
*p
, struct iattr
*iap
)
95 /* Sun client bug compatibility check: some sun clients seem to
96 * put 0xffff in the mode field when they mean 0xffffffff.
97 * Quoting the 4.4BSD nfs server code: Nah nah nah nah na nah.
99 if ((tmp
= ntohl(*p
++)) != (u32
)-1 && tmp
!= 0xffff) {
100 iap
->ia_valid
|= ATTR_MODE
;
103 if ((tmp
= ntohl(*p
++)) != (u32
)-1) {
104 iap
->ia_uid
= make_kuid(&init_user_ns
, tmp
);
105 if (uid_valid(iap
->ia_uid
))
106 iap
->ia_valid
|= ATTR_UID
;
108 if ((tmp
= ntohl(*p
++)) != (u32
)-1) {
109 iap
->ia_gid
= make_kgid(&init_user_ns
, tmp
);
110 if (gid_valid(iap
->ia_gid
))
111 iap
->ia_valid
|= ATTR_GID
;
113 if ((tmp
= ntohl(*p
++)) != (u32
)-1) {
114 iap
->ia_valid
|= ATTR_SIZE
;
117 tmp
= ntohl(*p
++); tmp1
= ntohl(*p
++);
118 if (tmp
!= (u32
)-1 && tmp1
!= (u32
)-1) {
119 iap
->ia_valid
|= ATTR_ATIME
| ATTR_ATIME_SET
;
120 iap
->ia_atime
.tv_sec
= tmp
;
121 iap
->ia_atime
.tv_nsec
= tmp1
* 1000;
123 tmp
= ntohl(*p
++); tmp1
= ntohl(*p
++);
124 if (tmp
!= (u32
)-1 && tmp1
!= (u32
)-1) {
125 iap
->ia_valid
|= ATTR_MTIME
| ATTR_MTIME_SET
;
126 iap
->ia_mtime
.tv_sec
= tmp
;
127 iap
->ia_mtime
.tv_nsec
= tmp1
* 1000;
129 * Passing the invalid value useconds=1000000 for mtime
130 * is a Sun convention for "set both mtime and atime to
131 * current server time". It's needed to make permissions
132 * checks for the "touch" program across v2 mounts to
133 * Solaris and Irix boxes work correctly. See description of
134 * sattr in section 6.1 of "NFS Illustrated" by
135 * Brent Callaghan, Addison-Wesley, ISBN 0-201-32750-5
138 iap
->ia_valid
&= ~(ATTR_ATIME_SET
|ATTR_MTIME_SET
);
144 encode_fattr(struct svc_rqst
*rqstp
, __be32
*p
, struct svc_fh
*fhp
,
147 struct dentry
*dentry
= fhp
->fh_dentry
;
149 struct timespec time
;
152 type
= (stat
->mode
& S_IFMT
);
154 *p
++ = htonl(nfs_ftypes
[type
>> 12]);
155 *p
++ = htonl((u32
) stat
->mode
);
156 *p
++ = htonl((u32
) stat
->nlink
);
157 *p
++ = htonl((u32
) from_kuid(&init_user_ns
, stat
->uid
));
158 *p
++ = htonl((u32
) from_kgid(&init_user_ns
, stat
->gid
));
160 if (S_ISLNK(type
) && stat
->size
> NFS_MAXPATHLEN
) {
161 *p
++ = htonl(NFS_MAXPATHLEN
);
163 *p
++ = htonl((u32
) stat
->size
);
165 *p
++ = htonl((u32
) stat
->blksize
);
166 if (S_ISCHR(type
) || S_ISBLK(type
))
167 *p
++ = htonl(new_encode_dev(stat
->rdev
));
169 *p
++ = htonl(0xffffffff);
170 *p
++ = htonl((u32
) stat
->blocks
);
171 switch (fsid_source(fhp
)) {
174 *p
++ = htonl(new_encode_dev(stat
->dev
));
176 case FSIDSOURCE_FSID
:
177 *p
++ = htonl((u32
) fhp
->fh_export
->ex_fsid
);
179 case FSIDSOURCE_UUID
:
180 f
= ((u32
*)fhp
->fh_export
->ex_uuid
)[0];
181 f
^= ((u32
*)fhp
->fh_export
->ex_uuid
)[1];
182 f
^= ((u32
*)fhp
->fh_export
->ex_uuid
)[2];
183 f
^= ((u32
*)fhp
->fh_export
->ex_uuid
)[3];
187 *p
++ = htonl((u32
) stat
->ino
);
188 *p
++ = htonl((u32
) stat
->atime
.tv_sec
);
189 *p
++ = htonl(stat
->atime
.tv_nsec
? stat
->atime
.tv_nsec
/ 1000 : 0);
190 lease_get_mtime(d_inode(dentry
), &time
);
191 *p
++ = htonl((u32
) time
.tv_sec
);
192 *p
++ = htonl(time
.tv_nsec
? time
.tv_nsec
/ 1000 : 0);
193 *p
++ = htonl((u32
) stat
->ctime
.tv_sec
);
194 *p
++ = htonl(stat
->ctime
.tv_nsec
? stat
->ctime
.tv_nsec
/ 1000 : 0);
199 /* Helper function for NFSv2 ACL code */
200 __be32
*nfs2svc_encode_fattr(struct svc_rqst
*rqstp
, __be32
*p
, struct svc_fh
*fhp
, struct kstat
*stat
)
202 return encode_fattr(rqstp
, p
, fhp
, stat
);
206 * XDR decode functions
209 nfssvc_decode_void(struct svc_rqst
*rqstp
, __be32
*p
, void *dummy
)
211 return xdr_argsize_check(rqstp
, p
);
215 nfssvc_decode_fhandle(struct svc_rqst
*rqstp
, __be32
*p
, struct nfsd_fhandle
*args
)
217 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 p
= decode_fh(p
, &args
->fh
);
256 args
->offset
= ntohl(*p
++);
257 len
= args
->count
= ntohl(*p
++);
258 p
++; /* totalcount - unused */
260 len
= min_t(unsigned int, 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
= min_t(unsigned int, 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 p
= decode_fh(p
, &args
->fh
);
289 p
++; /* beginoffset */
290 args
->offset
= ntohl(*p
++); /* offset */
291 p
++; /* totalcount */
292 len
= args
->len
= ntohl(*p
++);
294 * The protocol specifies a maximum of 8192 bytes.
296 if (len
> NFSSVC_MAXBLKSIZE_V2
)
300 * Check to make sure that we got the right number of
303 hdr
= (void*)p
- rqstp
->rq_arg
.head
[0].iov_base
;
304 dlen
= rqstp
->rq_arg
.head
[0].iov_len
+ rqstp
->rq_arg
.page_len
308 * Round the length of the data which was specified up to
309 * the next multiple of XDR units and then compare that
310 * against the length which was actually received.
311 * Note that when RPCSEC/GSS (for example) is used, the
312 * data buffer can be padded so dlen might be larger
313 * than required. It must never be smaller.
315 if (dlen
< XDR_QUADLEN(len
)*4)
318 rqstp
->rq_vec
[0].iov_base
= (void*)p
;
319 rqstp
->rq_vec
[0].iov_len
= rqstp
->rq_arg
.head
[0].iov_len
- hdr
;
321 while (len
> rqstp
->rq_vec
[v
].iov_len
) {
322 len
-= rqstp
->rq_vec
[v
].iov_len
;
324 rqstp
->rq_vec
[v
].iov_base
= page_address(rqstp
->rq_pages
[v
]);
325 rqstp
->rq_vec
[v
].iov_len
= PAGE_SIZE
;
327 rqstp
->rq_vec
[v
].iov_len
= len
;
333 nfssvc_decode_createargs(struct svc_rqst
*rqstp
, __be32
*p
,
334 struct nfsd_createargs
*args
)
336 if ( !(p
= decode_fh(p
, &args
->fh
))
337 || !(p
= decode_filename(p
, &args
->name
, &args
->len
)))
339 p
= decode_sattr(p
, &args
->attrs
);
341 return xdr_argsize_check(rqstp
, p
);
345 nfssvc_decode_renameargs(struct svc_rqst
*rqstp
, __be32
*p
,
346 struct nfsd_renameargs
*args
)
348 if (!(p
= decode_fh(p
, &args
->ffh
))
349 || !(p
= decode_filename(p
, &args
->fname
, &args
->flen
))
350 || !(p
= decode_fh(p
, &args
->tfh
))
351 || !(p
= decode_filename(p
, &args
->tname
, &args
->tlen
)))
354 return xdr_argsize_check(rqstp
, p
);
358 nfssvc_decode_readlinkargs(struct svc_rqst
*rqstp
, __be32
*p
, struct nfsd_readlinkargs
*args
)
360 p
= decode_fh(p
, &args
->fh
);
363 args
->buffer
= page_address(*(rqstp
->rq_next_page
++));
365 return xdr_argsize_check(rqstp
, p
);
369 nfssvc_decode_linkargs(struct svc_rqst
*rqstp
, __be32
*p
,
370 struct nfsd_linkargs
*args
)
372 if (!(p
= decode_fh(p
, &args
->ffh
))
373 || !(p
= decode_fh(p
, &args
->tfh
))
374 || !(p
= decode_filename(p
, &args
->tname
, &args
->tlen
)))
377 return xdr_argsize_check(rqstp
, p
);
381 nfssvc_decode_symlinkargs(struct svc_rqst
*rqstp
, __be32
*p
,
382 struct nfsd_symlinkargs
*args
)
384 if ( !(p
= decode_fh(p
, &args
->ffh
))
385 || !(p
= decode_filename(p
, &args
->fname
, &args
->flen
))
386 || !(p
= decode_pathname(p
, &args
->tname
, &args
->tlen
)))
388 p
= decode_sattr(p
, &args
->attrs
);
390 return xdr_argsize_check(rqstp
, p
);
394 nfssvc_decode_readdirargs(struct svc_rqst
*rqstp
, __be32
*p
,
395 struct nfsd_readdirargs
*args
)
397 p
= decode_fh(p
, &args
->fh
);
400 args
->cookie
= ntohl(*p
++);
401 args
->count
= ntohl(*p
++);
402 args
->count
= min_t(u32
, args
->count
, PAGE_SIZE
);
403 args
->buffer
= page_address(*(rqstp
->rq_next_page
++));
405 return xdr_argsize_check(rqstp
, p
);
409 * XDR encode functions
412 nfssvc_encode_void(struct svc_rqst
*rqstp
, __be32
*p
, void *dummy
)
414 return xdr_ressize_check(rqstp
, p
);
418 nfssvc_encode_attrstat(struct svc_rqst
*rqstp
, __be32
*p
,
419 struct nfsd_attrstat
*resp
)
421 p
= encode_fattr(rqstp
, p
, &resp
->fh
, &resp
->stat
);
422 return xdr_ressize_check(rqstp
, p
);
426 nfssvc_encode_diropres(struct svc_rqst
*rqstp
, __be32
*p
,
427 struct nfsd_diropres
*resp
)
429 p
= encode_fh(p
, &resp
->fh
);
430 p
= encode_fattr(rqstp
, p
, &resp
->fh
, &resp
->stat
);
431 return xdr_ressize_check(rqstp
, p
);
435 nfssvc_encode_readlinkres(struct svc_rqst
*rqstp
, __be32
*p
,
436 struct nfsd_readlinkres
*resp
)
438 *p
++ = htonl(resp
->len
);
439 xdr_ressize_check(rqstp
, p
);
440 rqstp
->rq_res
.page_len
= resp
->len
;
442 /* need to pad the tail */
443 rqstp
->rq_res
.tail
[0].iov_base
= p
;
445 rqstp
->rq_res
.tail
[0].iov_len
= 4 - (resp
->len
&3);
451 nfssvc_encode_readres(struct svc_rqst
*rqstp
, __be32
*p
,
452 struct nfsd_readres
*resp
)
454 p
= encode_fattr(rqstp
, p
, &resp
->fh
, &resp
->stat
);
455 *p
++ = htonl(resp
->count
);
456 xdr_ressize_check(rqstp
, p
);
458 /* now update rqstp->rq_res to reflect data as well */
459 rqstp
->rq_res
.page_len
= resp
->count
;
460 if (resp
->count
& 3) {
461 /* need to pad the tail */
462 rqstp
->rq_res
.tail
[0].iov_base
= p
;
464 rqstp
->rq_res
.tail
[0].iov_len
= 4 - (resp
->count
&3);
470 nfssvc_encode_readdirres(struct svc_rqst
*rqstp
, __be32
*p
,
471 struct nfsd_readdirres
*resp
)
473 xdr_ressize_check(rqstp
, p
);
475 *p
++ = 0; /* no more entries */
476 *p
++ = htonl((resp
->common
.err
== nfserr_eof
));
477 rqstp
->rq_res
.page_len
= (((unsigned long)p
-1) & ~PAGE_MASK
)+1;
483 nfssvc_encode_statfsres(struct svc_rqst
*rqstp
, __be32
*p
,
484 struct nfsd_statfsres
*resp
)
486 struct kstatfs
*stat
= &resp
->stats
;
488 *p
++ = htonl(NFSSVC_MAXBLKSIZE_V2
); /* max transfer size */
489 *p
++ = htonl(stat
->f_bsize
);
490 *p
++ = htonl(stat
->f_blocks
);
491 *p
++ = htonl(stat
->f_bfree
);
492 *p
++ = htonl(stat
->f_bavail
);
493 return xdr_ressize_check(rqstp
, p
);
497 nfssvc_encode_entry(void *ccdv
, const char *name
,
498 int namlen
, loff_t offset
, u64 ino
, unsigned int d_type
)
500 struct readdir_cd
*ccd
= ccdv
;
501 struct nfsd_readdirres
*cd
= container_of(ccd
, struct nfsd_readdirres
, common
);
502 __be32
*p
= cd
->buffer
;
506 dprintk("nfsd: entry(%.*s off %ld ino %ld)\n",
507 namlen, name, offset, ino);
510 if (offset
> ~((u32
) 0)) {
511 cd
->common
.err
= nfserr_fbig
;
515 *cd
->offset
= htonl(offset
);
517 /* truncate filename */
518 namlen
= min(namlen
, NFS2_MAXNAMLEN
);
519 slen
= XDR_QUADLEN(namlen
);
521 if ((buflen
= cd
->buflen
- slen
- 4) < 0) {
522 cd
->common
.err
= nfserr_toosmall
;
525 if (ino
> ~((u32
) 0)) {
526 cd
->common
.err
= nfserr_fbig
;
529 *p
++ = xdr_one
; /* mark entry present */
530 *p
++ = htonl((u32
) ino
); /* file id */
531 p
= xdr_encode_array(p
, name
, namlen
);/* name length & name */
532 cd
->offset
= p
; /* remember pointer */
533 *p
++ = htonl(~0U); /* offset of next entry */
537 cd
->common
.err
= nfs_ok
;
542 * XDR release functions
545 nfssvc_release_fhandle(struct svc_rqst
*rqstp
, __be32
*p
,
546 struct nfsd_fhandle
*resp
)
This page took 0.043272 seconds and 5 git commands to generate.