开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
nfs3xdr.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：25k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

nfs3xdr.c：源码内容
  1. /*
  2.  * linux/fs/nfs/nfs3xdr.c
  3.  *
  4.  * XDR functions to encode/decode NFSv3 RPC arguments and results.
  5.  *
  6.  * Copyright (C) 1996, 1997 Olaf Kirch
  7.  */
  9. #include <linux/param.h>
  10. #include <linux/sched.h>
  11. #include <linux/mm.h>
  12. #include <linux/slab.h>
  13. #include <linux/utsname.h>
  14. #include <linux/errno.h>
  15. #include <linux/string.h>
  16. #include <linux/in.h>
  17. #include <linux/pagemap.h>
  18. #include <linux/proc_fs.h>
  19. #include <linux/kdev_t.h>
  20. #include <linux/sunrpc/clnt.h>
  21. #include <linux/nfs.h>
  22. #include <linux/nfs3.h>
  23. #include <linux/nfs_fs.h>
  25. /* Uncomment this to support servers requiring longword lengths */
  26. #define NFS_PAD_WRITES 1
  28. #define NFSDBG_FACILITY NFSDBG_XDR
  30. /* Mapping from NFS error code to "errno" error code. */
  31. #define errno_NFSERR_IO EIO
  33. extern int nfs_stat_to_errno(int);
  35. /*
  36.  * Declare the space requirements for NFS arguments and replies as
  37.  * number of 32bit-words
  38.  */
  39. #define NFS3_fhandle_sz 1+16
  40. #define NFS3_fh_sz NFS3_fhandle_sz /* shorthand */
  41. #define NFS3_sattr_sz 15
  42. #define NFS3_filename_sz 1+(NFS3_MAXNAMLEN>>2)
  43. #define NFS3_path_sz 1+(NFS3_MAXPATHLEN>>2)
  44. #define NFS3_fattr_sz 21
  45. #define NFS3_wcc_attr_sz 6
  46. #define NFS3_pre_op_attr_sz 1+NFS3_wcc_attr_sz
  47. #define NFS3_post_op_attr_sz 1+NFS3_fattr_sz
  48. #define NFS3_wcc_data_sz NFS3_pre_op_attr_sz+NFS3_post_op_attr_sz
  49. #define NFS3_fsstat_sz
  50. #define NFS3_fsinfo_sz
  51. #define NFS3_pathconf_sz
  52. #define NFS3_entry_sz NFS3_filename_sz+3
  54. #define NFS3_enc_void_sz 0
  55. #define NFS3_sattrargs_sz NFS3_fh_sz+NFS3_sattr_sz+3
  56. #define NFS3_diropargs_sz NFS3_fh_sz+NFS3_filename_sz
  57. #define NFS3_accessargs_sz NFS3_fh_sz+1
  58. #define NFS3_readlinkargs_sz NFS3_fh_sz
  59. #define NFS3_readargs_sz NFS3_fh_sz+3
  60. #define NFS3_writeargs_sz NFS3_fh_sz+5
  61. #define NFS3_createargs_sz NFS3_diropargs_sz+NFS3_sattr_sz
  62. #define NFS3_mkdirargs_sz NFS3_diropargs_sz+NFS3_sattr_sz
  63. #define NFS3_symlinkargs_sz NFS3_diropargs_sz+NFS3_path_sz+NFS3_sattr_sz
  64. #define NFS3_mknodargs_sz NFS3_diropargs_sz+2+NFS3_sattr_sz
  65. #define NFS3_renameargs_sz NFS3_diropargs_sz+NFS3_diropargs_sz
  66. #define NFS3_linkargs_sz NFS3_fh_sz+NFS3_diropargs_sz
  67. #define NFS3_readdirargs_sz NFS3_fh_sz+2
  68. #define NFS3_commitargs_sz NFS3_fh_sz+3
  70. #define NFS3_dec_void_sz 0
  71. #define NFS3_attrstat_sz 1+NFS3_fattr_sz
  72. #define NFS3_wccstat_sz 1+NFS3_wcc_data_sz
  73. #define NFS3_lookupres_sz 1+NFS3_fh_sz+(2 * NFS3_post_op_attr_sz)
  74. #define NFS3_accessres_sz 1+NFS3_post_op_attr_sz+1
  75. #define NFS3_readlinkres_sz 1+NFS3_post_op_attr_sz
  76. #define NFS3_readres_sz 1+NFS3_post_op_attr_sz+3
  77. #define NFS3_writeres_sz 1+NFS3_wcc_data_sz+4
  78. #define NFS3_createres_sz 1+NFS3_fh_sz+NFS3_post_op_attr_sz+NFS3_wcc_data_sz
  79. #define NFS3_renameres_sz 1+(2 * NFS3_wcc_data_sz)
  80. #define NFS3_linkres_sz 1+NFS3_post_op_attr_sz+NFS3_wcc_data_sz
  81. #define NFS3_readdirres_sz 1+NFS3_post_op_attr_sz+2
  82. #define NFS3_fsstatres_sz 1+NFS3_post_op_attr_sz+13
  83. #define NFS3_fsinfores_sz 1+NFS3_post_op_attr_sz+12
  84. #define NFS3_pathconfres_sz 1+NFS3_post_op_attr_sz+6
  85. #define NFS3_commitres_sz 1+NFS3_wcc_data_sz+2
  87. /*
  88.  * Map file type to S_IFMT bits
  89.  */
  90. static struct {
  91. unsigned int mode;
  92. unsigned int nfs2type;
  93. } nfs_type2fmt[] = {
  94.       { 0, NFNON },
  95.       { S_IFREG, NFREG },
  96.       { S_IFDIR, NFDIR },
  97.       { S_IFBLK, NFBLK },
  98.       { S_IFCHR, NFCHR },
  99.       { S_IFLNK, NFLNK },
  100.       { S_IFSOCK, NFSOCK },
  101.       { S_IFIFO, NFFIFO },
  102.       { 0, NFBAD }
  103. };
  105. /*
  106.  * Common NFS XDR functions as inlines
  107.  */
  108. static inline u32 *
  109. xdr_encode_fhandle(u32 *p, struct nfs_fh *fh)
  110. {
  111. *p++ = htonl(fh->size);
  112. memcpy(p, fh->data, fh->size);
  113. return p + XDR_QUADLEN(fh->size);
  114. }
  116. static inline u32 *
  117. xdr_decode_fhandle(u32 *p, struct nfs_fh *fh)
  118. {
  119. /*
  120.  * Zero all nonused bytes
  121.  */
  122. memset((u8 *)fh, 0, sizeof(*fh));
  123. if ((fh->size = ntohl(*p++)) <= NFS3_FHSIZE) {
  124. memcpy(fh->data, p, fh->size);
  125. return p + XDR_QUADLEN(fh->size);
  126. }
  127. return NULL;
  128. }
  130. /*
  131.  * Encode/decode time.
  132.  * Since the VFS doesn't care for fractional times, we ignore the
  133.  * nanosecond field.
  134.  */
  135. static inline u32 *
  136. xdr_encode_time(u32 *p, time_t time)
  137. {
  138. *p++ = htonl(time);
  139. *p++ = 0;
  140. return p;
  141. }
  143. static inline u32 *
  144. xdr_decode_time3(u32 *p, u64 *timep)
  145. {
  146. u64 tmp = (u64)ntohl(*p++) << 32;
  147. *timep = tmp + (u64)ntohl(*p++);
  148. return p;
  149. }
  151. static inline u32 *
  152. xdr_encode_time3(u32 *p, u64 time)
  153. {
  154. *p++ = htonl(time >> 32);
  155. *p++ = htonl(time & 0xFFFFFFFF);
  156. return p;
  157. }
  159. static inline u32 *
  160. xdr_decode_string2(u32 *p, char **string, unsigned int *len,
  161. unsigned int maxlen)
  162. {
  163. *len = ntohl(*p++);
  164. if (*len > maxlen)
  165. return NULL;
  166. *string = (char *) p;
  167. return p + XDR_QUADLEN(*len);
  168. }
  170. static inline u32 *
  171. xdr_decode_fattr(u32 *p, struct nfs_fattr *fattr)
  172. {
  173. unsigned int type;
  174. int fmode;
  176. type = ntohl(*p++);
  177. if (type >= NF3BAD)
  178. type = NF3BAD;
  179. fmode = nfs_type2fmt[type].mode;
  180. fattr->type = nfs_type2fmt[type].nfs2type;
  181. fattr->mode = (ntohl(*p++) & ~S_IFMT) | fmode;
  182. fattr->nlink = ntohl(*p++);
  183. fattr->uid = ntohl(*p++);
  184. fattr->gid = ntohl(*p++);
  185. p = xdr_decode_hyper(p, &fattr->size);
  186. p = xdr_decode_hyper(p, &fattr->du.nfs3.used);
  187. /* Turn remote device info into Linux-specific dev_t */
  188. fattr->rdev = ntohl(*p++) << MINORBITS;
  189. fattr->rdev |= ntohl(*p++) & MINORMASK;
  190. p = xdr_decode_hyper(p, &fattr->fsid);
  191. p = xdr_decode_hyper(p, &fattr->fileid);
  192. p = xdr_decode_time3(p, &fattr->atime);
  193. p = xdr_decode_time3(p, &fattr->mtime);
  194. p = xdr_decode_time3(p, &fattr->ctime);
  196. /* Update the mode bits */
  197. fattr->valid |= (NFS_ATTR_FATTR | NFS_ATTR_FATTR_V3);
  198. return p;
  199. }
  201. static inline u32 *
  202. xdr_encode_sattr(u32 *p, struct iattr *attr)
  203. {
  204. if (attr->ia_valid & ATTR_MODE) {
  205. *p++ = xdr_one;
  206. *p++ = htonl(attr->ia_mode);
  207. } else {
  208. *p++ = xdr_zero;
  209. }
  210. if (attr->ia_valid & ATTR_UID) {
  211. *p++ = xdr_one;
  212. *p++ = htonl(attr->ia_uid);
  213. } else {
  214. *p++ = xdr_zero;
  215. }
  216. if (attr->ia_valid & ATTR_GID) {
  217. *p++ = xdr_one;
  218. *p++ = htonl(attr->ia_gid);
  219. } else {
  220. *p++ = xdr_zero;
  221. }
  222. if (attr->ia_valid & ATTR_SIZE) {
  223. *p++ = xdr_one;
  224. p = xdr_encode_hyper(p, (__u64) attr->ia_size);
  225. } else {
  226. *p++ = xdr_zero;
  227. }
  228. if (attr->ia_valid & ATTR_ATIME_SET) {
  229. *p++ = xdr_two;
  230. p = xdr_encode_time(p, attr->ia_atime);
  231. } else if (attr->ia_valid & ATTR_ATIME) {
  232. *p++ = xdr_one;
  233. } else {
  234. *p++ = xdr_zero;
  235. }
  236. if (attr->ia_valid & ATTR_MTIME_SET) {
  237. *p++ = xdr_two;
  238. p = xdr_encode_time(p, attr->ia_mtime);
  239. } else if (attr->ia_valid & ATTR_MTIME) {
  240. *p++ = xdr_one;
  241. } else {
  242. *p++ = xdr_zero;
  243. }
  244. return p;
  245. }
  247. static inline u32 *
  248. xdr_decode_wcc_attr(u32 *p, struct nfs_fattr *fattr)
  249. {
  250. p = xdr_decode_hyper(p, &fattr->pre_size);
  251. p = xdr_decode_time3(p, &fattr->pre_mtime);
  252. p = xdr_decode_time3(p, &fattr->pre_ctime);
  253. fattr->valid |= NFS_ATTR_WCC;
  254. return p;
  255. }
  257. static inline u32 *
  258. xdr_decode_post_op_attr(u32 *p, struct nfs_fattr *fattr)
  259. {
  260. if (*p++)
  261. p = xdr_decode_fattr(p, fattr);
  262. return p;
  263. }
  265. static inline u32 *
  266. xdr_decode_pre_op_attr(u32 *p, struct nfs_fattr *fattr)
  267. {
  268. if (*p++)
  269. return xdr_decode_wcc_attr(p, fattr);
  270. return p;
  271. }
  274. static inline u32 *
  275. xdr_decode_wcc_data(u32 *p, struct nfs_fattr *fattr)
  276. {
  277. p = xdr_decode_pre_op_attr(p, fattr);
  278. return xdr_decode_post_op_attr(p, fattr);
  279. }
  281. /*
  282.  * NFS encode functions
  283.  */
  284. /*
  285.  * Encode void argument
  286.  */
  287. static int
  288. nfs3_xdr_enc_void(struct rpc_rqst *req, u32 *p, void *dummy)
  289. {
  290. req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
  291. return 0;
  292. }
  294. /*
  295.  * Encode file handle argument
  296.  */
  297. static int
  298. nfs3_xdr_fhandle(struct rpc_rqst *req, u32 *p, struct nfs_fh *fh)
  299. {
  300. p = xdr_encode_fhandle(p, fh);
  301. req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
  302. return 0;
  303. }
  305. /*
  306.  * Encode SETATTR arguments
  307.  */
  308. static int
  309. nfs3_xdr_sattrargs(struct rpc_rqst *req, u32 *p, struct nfs3_sattrargs *args)
  310. {
  311. p = xdr_encode_fhandle(p, args->fh);
  312. p = xdr_encode_sattr(p, args->sattr);
  313. *p++ = htonl(args->guard);
  314. if (args->guard)
  315. p = xdr_encode_time3(p, args->guardtime);
  316. req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
  317. return 0;
  318. }
  320. /*
  321.  * Encode directory ops argument
  322.  */
  323. static int
  324. nfs3_xdr_diropargs(struct rpc_rqst *req, u32 *p, struct nfs3_diropargs *args)
  325. {
  326. p = xdr_encode_fhandle(p, args->fh);
  327. p = xdr_encode_array(p, args->name, args->len);
  328. req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
  329. return 0;
  330. }
  332. /*
  333.  * Encode access() argument
  334.  */
  335. static int
  336. nfs3_xdr_accessargs(struct rpc_rqst *req, u32 *p, struct nfs3_accessargs *args)
  337. {
  338. p = xdr_encode_fhandle(p, args->fh);
  339. *p++ = htonl(args->access);
  340. req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
  341. return 0;
  342. }
  344. /*
  345.  * Arguments to a READ call. Since we read data directly into the page
  346.  * cache, we also set up the reply iovec here so that iov[1] points
  347.  * exactly to the page we want to fetch.
  348.  */
  349. static int
  350. nfs3_xdr_readargs(struct rpc_rqst *req, u32 *p, struct nfs_readargs *args)
  351. {
  352. struct rpc_auth *auth = req->rq_task->tk_auth;
  353. int buflen, replen;
  354. unsigned int nr;
  356. p = xdr_encode_fhandle(p, args->fh);
  357. p = xdr_encode_hyper(p, args->offset);
  358. *p++ = htonl(args->count);
  359. req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
  361. /* Get the number of buffers in the receive iovec */
  362. nr = args->nriov;
  364. if (nr+2 > MAX_IOVEC) {
  365. printk(KERN_ERR "NFS: Bad number of iov's in xdr_readargsn");
  366. return -EINVAL;
  367. }
  369. /* set up reply iovec */
  370. replen = (RPC_REPHDRSIZE + auth->au_rslack + NFS3_readres_sz) << 2;
  371. buflen = req->rq_rvec[0].iov_len;
  372. req->rq_rvec[0].iov_len  = replen;
  374. /* Copy the iovec */
  375. memcpy(req->rq_rvec + 1, args->iov, nr * sizeof(struct iovec));
  377. req->rq_rvec[nr+1].iov_base = (u8 *) req->rq_rvec[0].iov_base + replen;
  378. req->rq_rvec[nr+1].iov_len  = buflen - replen;
  379. req->rq_rlen = args->count + buflen;
  380. req->rq_rnr += nr+1;
  382. return 0;
  383. }
  385. /*
  386.  * Write arguments. Splice the buffer to be written into the iovec.
  387.  */
  388. static int
  389. nfs3_xdr_writeargs(struct rpc_rqst *req, u32 *p, struct nfs_writeargs *args)
  390. {
  391. unsigned int nr;
  392. u32 count = args->count;
  394. p = xdr_encode_fhandle(p, args->fh);
  395. p = xdr_encode_hyper(p, args->offset);
  396. *p++ = htonl(count);
  397. *p++ = htonl(args->stable);
  398. *p++ = htonl(count);
  399. req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
  401. /* Get the number of buffers in the send iovec */
  402. nr = args->nriov;
  404. if (nr+2 > MAX_IOVEC) {
  405. printk(KERN_ERR "NFS: Bad number of iov's in xdr_writeargsn");
  406. return -EINVAL;
  407. }
  409. /* Copy the iovec */
  410. memcpy(req->rq_svec + 1, args->iov, nr * sizeof(struct iovec));
  412. #ifdef NFS_PAD_WRITES
  413. /*
  414.  * Some old servers require that the message length
  415.  * be a multiple of 4, so we pad it here if needed.
  416.  */
  417. if (count & 3) {
  418. struct iovec *iov = req->rq_svec + nr + 1;
  419. int pad = 4 - (count & 3);
  421. iov->iov_base = (void *) "";
  422. iov->iov_len  = pad;
  423. count += pad;
  424. nr++;
  425. }
  426. #endif
  427. req->rq_slen += count;
  428. req->rq_snr  += nr;
  430. return 0;
  431. }
  433. /*
  434.  * Encode CREATE arguments
  435.  */
  436. static int
  437. nfs3_xdr_createargs(struct rpc_rqst *req, u32 *p, struct nfs3_createargs *args)
  438. {
  439. p = xdr_encode_fhandle(p, args->fh);
  440. p = xdr_encode_array(p, args->name, args->len);
  442. *p++ = htonl(args->createmode);
  443. if (args->createmode == NFS3_CREATE_EXCLUSIVE) {
  444. *p++ = args->verifier[0];
  445. *p++ = args->verifier[1];
  446. } else
  447. p = xdr_encode_sattr(p, args->sattr);
  449. req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
  450. return 0;
  451. }
  453. /*
  454.  * Encode MKDIR arguments
  455.  */
  456. static int
  457. nfs3_xdr_mkdirargs(struct rpc_rqst *req, u32 *p, struct nfs3_mkdirargs *args)
  458. {
  459. p = xdr_encode_fhandle(p, args->fh);
  460. p = xdr_encode_array(p, args->name, args->len);
  461. p = xdr_encode_sattr(p, args->sattr);
  462. req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
  463. return 0;
  464. }
  466. /*
  467.  * Encode SYMLINK arguments
  468.  */
  469. static int
  470. nfs3_xdr_symlinkargs(struct rpc_rqst *req, u32 *p, struct nfs3_symlinkargs *args)
  471. {
  472. p = xdr_encode_fhandle(p, args->fromfh);
  473. p = xdr_encode_array(p, args->fromname, args->fromlen);
  474. p = xdr_encode_sattr(p, args->sattr);
  475. p = xdr_encode_array(p, args->topath, args->tolen);
  476. req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
  477. return 0;
  478. }
  480. /*
  481.  * Encode MKNOD arguments
  482.  */
  483. static int
  484. nfs3_xdr_mknodargs(struct rpc_rqst *req, u32 *p, struct nfs3_mknodargs *args)
  485. {
  486. p = xdr_encode_fhandle(p, args->fh);
  487. p = xdr_encode_array(p, args->name, args->len);
  488. *p++ = htonl(args->type);
  489. p = xdr_encode_sattr(p, args->sattr);
  490. if (args->type == NF3CHR || args->type == NF3BLK) {
  491. *p++ = htonl(args->rdev >> MINORBITS);
  492. *p++ = htonl(args->rdev & MINORMASK);
  493. }
  495. req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
  496. return 0;
  497. }
  499. /*
  500.  * Encode RENAME arguments
  501.  */
  502. static int
  503. nfs3_xdr_renameargs(struct rpc_rqst *req, u32 *p, struct nfs3_renameargs *args)
  504. {
  505. p = xdr_encode_fhandle(p, args->fromfh);
  506. p = xdr_encode_array(p, args->fromname, args->fromlen);
  507. p = xdr_encode_fhandle(p, args->tofh);
  508. p = xdr_encode_array(p, args->toname, args->tolen);
  509. req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
  510. return 0;
  511. }
  513. /*
  514.  * Encode LINK arguments
  515.  */
  516. static int
  517. nfs3_xdr_linkargs(struct rpc_rqst *req, u32 *p, struct nfs3_linkargs *args)
  518. {
  519. p = xdr_encode_fhandle(p, args->fromfh);
  520. p = xdr_encode_fhandle(p, args->tofh);
  521. p = xdr_encode_array(p, args->toname, args->tolen);
  522. req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
  523. return 0;
  524. }
  526. /*
  527.  * Encode arguments to readdir call
  528.  */
  529. static int
  530. nfs3_xdr_readdirargs(struct rpc_rqst *req, u32 *p, struct nfs3_readdirargs *args)
  531. {
  532. struct rpc_auth *auth = req->rq_task->tk_auth;
  533. int buflen, replen;
  535. p = xdr_encode_fhandle(p, args->fh);
  536. p = xdr_encode_hyper(p, args->cookie);
  537. *p++ = args->verf[0];
  538. *p++ = args->verf[1];
  539. if (args->plus) {
  540. /* readdirplus: need dircount + buffer size.
  541.  * We just make sure we make dircount big enough */
  542. *p++ = htonl(args->bufsiz >> 3);
  543. }
  544. *p++ = htonl(args->bufsiz);
  545. req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
  547. /* set up reply iovec */
  548. replen = (RPC_REPHDRSIZE + auth->au_rslack + NFS3_readdirres_sz) << 2;
  549. buflen = req->rq_rvec[0].iov_len;
  550. req->rq_rvec[0].iov_len  = replen;
  551. req->rq_rvec[1].iov_base = args->buffer;
  552. req->rq_rvec[1].iov_len  = args->bufsiz;
  553. req->rq_rvec[2].iov_base = (u8 *) req->rq_rvec[0].iov_base + replen;
  554. req->rq_rvec[2].iov_len  = buflen - replen;
  555. req->rq_rlen = buflen + args->bufsiz;
  556. req->rq_rnr += 2;
  558. return 0;
  559. }
  561. /*
  562.  * Decode the result of a readdir call.
  563.  * We just check for syntactical correctness.
  564.  */
  565. static int
  566. nfs3_xdr_readdirres(struct rpc_rqst *req, u32 *p, struct nfs3_readdirres *res)
  567. {
  568. struct iovec *iov = req->rq_rvec;
  569. int hdrlen;
  570. int status, nr;
  571. unsigned int len;
  572. u32 *entry, *end;
  574. status = ntohl(*p++);
  575. /* Decode post_op_attrs */
  576. p = xdr_decode_post_op_attr(p, res->dir_attr);
  577. if (status)
  578. return -nfs_stat_to_errno(status);
  579. /* Decode verifier cookie */
  580. if (res->verf) {
  581. res->verf[0] = *p++;
  582. res->verf[1] = *p++;
  583. } else {
  584. p += 2;
  585. }
  587. hdrlen = (u8 *) p - (u8 *) iov->iov_base;
  588. if (iov->iov_len > hdrlen) {
  589. dprintk("NFS: READDIR header is short. iovec will be shifted.n");
  590. xdr_shift_iovec(iov, req->rq_rnr, iov->iov_len - hdrlen);
  591. }
  593. p   = (u32 *) iov[1].iov_base;
  594. end = (u32 *) ((u8 *) p + iov[1].iov_len);
  595. for (nr = 0; *p++; nr++) {
  596. entry = p - 1;
  597. if (p + 3 > end)
  598. goto short_pkt;
  599. p += 2; /* inode # */
  600. len = ntohl(*p++); /* string length */
  601. p += XDR_QUADLEN(len) + 2; /* name + cookie */
  602. if (len > NFS3_MAXNAMLEN) {
  603. printk(KERN_WARNING "NFS: giant filename in readdir (len %x)!n",
  604. len);
  605. return -errno_NFSERR_IO;
  606. }
  608. if (res->plus) {
  609. /* post_op_attr */
  610. if (p > end)
  611. goto short_pkt;
  612. if (*p++) {
  613. p += 21;
  614. if (p > end)
  615. goto short_pkt;
  616. }
  617. /* post_op_fh3 */
  618. if (*p++) {
  619. if (p > end)
  620. goto short_pkt;
  621. len = ntohl(*p++);
  622. if (len > NFS3_FHSIZE) {
  623. printk(KERN_WARNING "NFS: giant filehandle in "
  624. "readdir (len %x)!n", len);
  625. return -errno_NFSERR_IO;
  626. }
  627. p += XDR_QUADLEN(len);
  628. }
  629. }
  631. if (p + 2 > end)
  632. goto short_pkt;
  633. }
  635. return nr;
  636.  short_pkt:
  637. printk(KERN_NOTICE "NFS: short packet in readdir reply!n");
  638. /* truncate listing */
  639. entry[0] = entry[1] = 0;
  640. return nr;
  641. }
  643. u32 *
  644. nfs3_decode_dirent(u32 *p, struct nfs_entry *entry, int plus)
  645. {
  646. struct nfs_entry old = *entry;
  648. if (!*p++) {
  649. if (!*p)
  650. return ERR_PTR(-EAGAIN);
  651. entry->eof = 1;
  652. return ERR_PTR(-EBADCOOKIE);
  653. }
  655. p = xdr_decode_hyper(p, &entry->ino);
  656. entry->len  = ntohl(*p++);
  657. entry->name = (const char *) p;
  658. p += XDR_QUADLEN(entry->len);
  659. entry->prev_cookie = entry->cookie;
  660. p = xdr_decode_hyper(p, &entry->cookie);
  662. if (plus) {
  663. p = xdr_decode_post_op_attr(p, &entry->fattr);
  664. /* In fact, a post_op_fh3: */
  665. if (*p++) {
  666. p = xdr_decode_fhandle(p, &entry->fh);
  667. /* Ugh -- server reply was truncated */
  668. if (p == NULL) {
  669. dprintk("NFS: FH truncatedn");
  670. *entry = old;
  671. return ERR_PTR(-EAGAIN);
  672. }
  673. } else {
  674. /* If we don't get a file handle, the attrs
  675.  * aren't worth a lot. */
  676. entry->fattr.valid = 0;
  677. }
  678. }
  680. entry->eof = !p[0] && p[1];
  681. return p;
  682. }
  684. /*
  685.  * Encode COMMIT arguments
  686.  */
  687. static int
  688. nfs3_xdr_commitargs(struct rpc_rqst *req, u32 *p, struct nfs_writeargs *args)
  689. {
  690. p = xdr_encode_fhandle(p, args->fh);
  691. p = xdr_encode_hyper(p, args->offset);
  692. *p++ = htonl(args->count);
  693. req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
  694. return 0;
  695. }
  697. /*
  698.  * NFS XDR decode functions
  699.  */
  700. /*
  701.  * Decode void reply
  702.  */
  703. static int
  704. nfs3_xdr_dec_void(struct rpc_rqst *req, u32 *p, void *dummy)
  705. {
  706. return 0;
  707. }
  709. /*
  710.  * Decode attrstat reply.
  711.  */
  712. static int
  713. nfs3_xdr_attrstat(struct rpc_rqst *req, u32 *p, struct nfs_fattr *fattr)
  714. {
  715. int status;
  717. if ((status = ntohl(*p++)))
  718. return -nfs_stat_to_errno(status);
  719. xdr_decode_fattr(p, fattr);
  720. return 0;
  721. }
  723. /*
  724.  * Decode status+wcc_data reply
  725.  * SATTR, REMOVE, RMDIR
  726.  */
  727. static int
  728. nfs3_xdr_wccstat(struct rpc_rqst *req, u32 *p, struct nfs_fattr *fattr)
  729. {
  730. int status;
  732. if ((status = ntohl(*p++)))
  733. status = -nfs_stat_to_errno(status);
  734. xdr_decode_wcc_data(p, fattr);
  735. return status;
  736. }
  738. /*
  739.  * Decode LOOKUP reply
  740.  */
  741. static int
  742. nfs3_xdr_lookupres(struct rpc_rqst *req, u32 *p, struct nfs3_diropres *res)
  743. {
  744. int status;
  746. if ((status = ntohl(*p++))) {
  747. status = -nfs_stat_to_errno(status);
  748. } else {
  749. if (!(p = xdr_decode_fhandle(p, res->fh)))
  750. return -errno_NFSERR_IO;
  751. p = xdr_decode_post_op_attr(p, res->fattr);
  752. }
  753. xdr_decode_post_op_attr(p, res->dir_attr);
  754. return status;
  755. }
  757. /*
  758.  * Decode ACCESS reply
  759.  */
  760. static int
  761. nfs3_xdr_accessres(struct rpc_rqst *req, u32 *p, struct nfs3_accessres *res)
  762. {
  763. int status = ntohl(*p++);
  765. p = xdr_decode_post_op_attr(p, res->fattr);
  766. if (status)
  767. return -nfs_stat_to_errno(status);
  768. res->access = ntohl(*p++);
  769. return 0;
  770. }
  772. static int
  773. nfs3_xdr_readlinkargs(struct rpc_rqst *req, u32 *p, struct nfs3_readlinkargs *args)
  774. {
  775. struct rpc_task *task = req->rq_task;
  776. struct rpc_auth *auth = task->tk_auth;
  777. int buflen, replen;
  779. p = xdr_encode_fhandle(p, args->fh);
  780. req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
  781. replen = (RPC_REPHDRSIZE + auth->au_rslack + NFS3_readlinkres_sz) << 2;
  782. buflen = req->rq_rvec[0].iov_len;
  783. req->rq_rvec[0].iov_len  = replen;
  784. req->rq_rvec[1].iov_base = args->buffer;
  785. req->rq_rvec[1].iov_len  = args->bufsiz;
  786. req->rq_rvec[2].iov_base = (u8 *) req->rq_rvec[0].iov_base + replen;
  787. req->rq_rvec[2].iov_len  = buflen - replen;
  788. req->rq_rlen = buflen + args->bufsiz;
  789. req->rq_rnr += 2;
  790. return 0;
  791. }
  793. /*
  794.  * Decode READLINK reply
  795.  */
  796. static int
  797. nfs3_xdr_readlinkres(struct rpc_rqst *req, u32 *p, struct nfs3_readlinkres *res)
  798. {
  799. struct iovec *iov = req->rq_rvec;
  800. int hdrlen;
  801. u32 *strlen;
  802. char *string;
  803. int status;
  804. unsigned int len;
  806. status = ntohl(*p++);
  807. p = xdr_decode_post_op_attr(p, res->fattr);
  809. if (status != 0)
  810. return -nfs_stat_to_errno(status);
  812. hdrlen = (u8 *) p - (u8 *) iov->iov_base;
  813. if (iov->iov_len > hdrlen) {
  814. dprintk("NFS: READLINK header is short. iovec will be shifted.n");
  815. xdr_shift_iovec(iov, req->rq_rnr, iov->iov_len - hdrlen);
  816. }
  818. strlen = (u32*)res->buffer;
  819. /* Convert length of symlink */
  820. len = ntohl(*strlen);
  821. if (len > res->bufsiz - 5)
  822. len = res->bufsiz - 5;
  823. *strlen = len;
  824. /* NULL terminate the string we got */
  825. string = (char *)(strlen + 1);
  826. string[len] = 0;
  827. return 0;
  828. }
  830. /*
  831.  * Decode READ reply
  832.  */
  833. static int
  834. nfs3_xdr_readres(struct rpc_rqst *req, u32 *p, struct nfs_readres *res)
  835. {
  836. struct iovec *iov = req->rq_rvec;
  837. int status, count, ocount, recvd, hdrlen;
  839. status = ntohl(*p++);
  840. p = xdr_decode_post_op_attr(p, res->fattr);
  842. if (status != 0)
  843. return -nfs_stat_to_errno(status);
  845. /* Decode reply could and EOF flag. NFSv3 is somewhat redundant
  846.  * in that it puts the count both in the res struct and in the
  847.  * opaque data count. */
  848. count    = ntohl(*p++);
  849. res->eof = ntohl(*p++);
  850. ocount   = ntohl(*p++);
  852. if (ocount != count) {
  853. printk(KERN_WARNING "NFS: READ count doesn't match RPC opaque count.n");
  854. return -errno_NFSERR_IO;
  855. }
  857. hdrlen = (u8 *) p - (u8 *) iov->iov_base;
  858. if (iov->iov_len > hdrlen) {
  859. dprintk("NFS: READ header is short. iovec will be shifted.n");
  860. xdr_shift_iovec(iov, req->rq_rnr, iov->iov_len - hdrlen);
  861. }
  863. recvd = req->rq_rlen - hdrlen;
  864. if (count > recvd) {
  865. printk(KERN_WARNING "NFS: server cheating in read reply: "
  866. "count %d > recvd %dn", count, recvd);
  867. count = recvd;
  868. }
  870. if (count < res->count) {
  871. xdr_zero_iovec(iov+1, req->rq_rnr-2, res->count - count);
  872. res->count = count;
  873. }
  875. return count;
  876. }
  878. /*
  879.  * Decode WRITE response
  880.  */
  881. static int
  882. nfs3_xdr_writeres(struct rpc_rqst *req, u32 *p, struct nfs_writeres *res)
  883. {
  884. int status;
  886. status = ntohl(*p++);
  887. p = xdr_decode_wcc_data(p, res->fattr);
  889. if (status != 0)
  890. return -nfs_stat_to_errno(status);
  892. res->count = ntohl(*p++);
  893. res->verf->committed = (enum nfs3_stable_how)ntohl(*p++);
  894. res->verf->verifier[0] = *p++;
  895. res->verf->verifier[1] = *p++;
  897. return res->count;
  898. }
  900. /*
  901.  * Decode a CREATE response
  902.  */
  903. static int
  904. nfs3_xdr_createres(struct rpc_rqst *req, u32 *p, struct nfs3_diropres *res)
  905. {
  906. int status;
  908. status = ntohl(*p++);
  909. if (status == 0) {
  910. if (*p++) {
  911. if (!(p = xdr_decode_fhandle(p, res->fh)))
  912. return -errno_NFSERR_IO;
  913. p = xdr_decode_post_op_attr(p, res->fattr);
  914. } else {
  915. memset(res->fh, 0, sizeof(*res->fh));
  916. /* Do decode post_op_attr but set it to NULL */
  917. p = xdr_decode_post_op_attr(p, res->fattr);
  918. res->fattr->valid = 0;
  919. }
  920. } else {
  921. status = -nfs_stat_to_errno(status);
  922. }
  923. p = xdr_decode_wcc_data(p, res->dir_attr);
  924. return status;
  925. }
  927. /*
  928.  * Decode RENAME reply
  929.  */
  930. static int
  931. nfs3_xdr_renameres(struct rpc_rqst *req, u32 *p, struct nfs3_renameres *res)
  932. {
  933. int status;
  935. if ((status = ntohl(*p++)) != 0)
  936. status = -nfs_stat_to_errno(status);
  937. p = xdr_decode_wcc_data(p, res->fromattr);
  938. p = xdr_decode_wcc_data(p, res->toattr);
  939. return status;
  940. }
  942. /*
  943.  * Decode LINK reply
  944.  */
  945. static int
  946. nfs3_xdr_linkres(struct rpc_rqst *req, u32 *p, struct nfs3_linkres *res)
  947. {
  948. int status;
  950. if ((status = ntohl(*p++)) != 0)
  951. status = -nfs_stat_to_errno(status);
  952. p = xdr_decode_post_op_attr(p, res->fattr);
  953. p = xdr_decode_wcc_data(p, res->dir_attr);
  954. return status;
  955. }
  957. /*
  958.  * Decode FSSTAT reply
  959.  */
  960. static int
  961. nfs3_xdr_fsstatres(struct rpc_rqst *req, u32 *p, struct nfs_fsinfo *res)
  962. {
  963. struct nfs_fattr dummy;
  964. int status;
  966. status = ntohl(*p++);
  968. p = xdr_decode_post_op_attr(p, &dummy);
  969. if (status != 0)
  970. return -nfs_stat_to_errno(status);
  972. p = xdr_decode_hyper(p, &res->tbytes);
  973. p = xdr_decode_hyper(p, &res->fbytes);
  974. p = xdr_decode_hyper(p, &res->abytes);
  975. p = xdr_decode_hyper(p, &res->tfiles);
  976. p = xdr_decode_hyper(p, &res->ffiles);
  977. p = xdr_decode_hyper(p, &res->afiles);
  979. /* ignore invarsec */
  980. return 0;
  981. }
  983. /*
  984.  * Decode FSINFO reply
  985.  */
  986. static int
  987. nfs3_xdr_fsinfores(struct rpc_rqst *req, u32 *p, struct nfs_fsinfo *res)
  988. {
  989. struct nfs_fattr dummy;
  990. int status;
  992. status = ntohl(*p++);
  994. p = xdr_decode_post_op_attr(p, &dummy);
  995. if (status != 0)
  996. return -nfs_stat_to_errno(status);
  998. res->rtmax  = ntohl(*p++);
  999. res->rtpref = ntohl(*p++);
  1000. res->rtmult = ntohl(*p++);
  1001. res->wtmax  = ntohl(*p++);
  1002. res->wtpref = ntohl(*p++);
  1003. res->wtmult = ntohl(*p++);
  1004. res->dtpref = ntohl(*p++);
  1005. p = xdr_decode_hyper(p, &res->maxfilesize);
  1007. /* ignore time_delta and properties */
  1008. return 0;
  1009. }
  1011. /*
  1012.  * Decode PATHCONF reply
  1013.  */
  1014. static int
  1015. nfs3_xdr_pathconfres(struct rpc_rqst *req, u32 *p, struct nfs_fsinfo *res)
  1016. {
  1017. struct nfs_fattr dummy;
  1018. int status;
  1020. status = ntohl(*p++);
  1022. p = xdr_decode_post_op_attr(p, &dummy);
  1023. if (status != 0)
  1024. return -nfs_stat_to_errno(status);
  1025. res->linkmax = ntohl(*p++);
  1026. res->namelen = ntohl(*p++);
  1028. /* ignore remaining fields */
  1029. return 0;
  1030. }
  1032. /*
  1033.  * Decode COMMIT reply
  1034.  */
  1035. static int
  1036. nfs3_xdr_commitres(struct rpc_rqst *req, u32 *p, struct nfs_writeres *res)
  1037. {
  1038. int status;
  1040. status = ntohl(*p++);
  1041. p = xdr_decode_wcc_data(p, res->fattr);
  1042. if (status != 0)
  1043. return -nfs_stat_to_errno(status);
  1045. res->verf->verifier[0] = *p++;
  1046. res->verf->verifier[1] = *p++;
  1047. return 0;
  1048. }
  1050. #ifndef MAX
  1051. # define MAX(a, b) (((a) > (b))? (a) : (b))
  1052. #endif
  1054. #define PROC(proc, argtype, restype)
  1055.     { "nfs3_" #proc,
  1056.       (kxdrproc_t) nfs3_xdr_##argtype,
  1057.       (kxdrproc_t) nfs3_xdr_##restype,
  1058.       MAX(NFS3_##argtype##_sz,NFS3_##restype##_sz) << 2,
  1059.       0
  1060.     }
  1062. static struct rpc_procinfo nfs3_procedures[22] = {
  1063.   PROC(null, enc_void, dec_void),
  1064.   PROC(getattr, fhandle, attrstat),
  1065.   PROC(setattr,  sattrargs, wccstat),
  1066.   PROC(lookup, diropargs, lookupres),
  1067.   PROC(access, accessargs, accessres),
  1068.   PROC(readlink, readlinkargs, readlinkres),
  1069.   PROC(read, readargs, readres),
  1070.   PROC(write, writeargs, writeres),
  1071.   PROC(create, createargs, createres),
  1072.   PROC(mkdir, mkdirargs, createres),
  1073.   PROC(symlink, symlinkargs, createres),
  1074.   PROC(mknod, mknodargs, createres),
  1075.   PROC(remove, diropargs, wccstat),
  1076.   PROC(rmdir, diropargs, wccstat),
  1077.   PROC(rename, renameargs, renameres),
  1078.   PROC(link, linkargs, linkres),
  1079.   PROC(readdir, readdirargs, readdirres),
  1080.   PROC(readdirplus, readdirargs, readdirres),
  1081.   PROC(fsstat, fhandle, fsstatres),
  1082.   PROC(fsinfo,   fhandle, fsinfores),
  1083.   PROC(pathconf, fhandle, pathconfres),
  1084.   PROC(commit, commitargs, commitres),
  1085. };
  1087. struct rpc_version nfs_version3 = {
  1088. 3,
  1089. sizeof(nfs3_procedures)/sizeof(nfs3_procedures[0]),
  1090. nfs3_procedures
  1091. };