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

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

嵌入式Linux

开发平台：

Unix_Linux

nfs2xdr.c：源码内容
  1. /*
  2.  * linux/fs/nfs/nfs2xdr.c
  3.  *
  4.  * XDR functions to encode/decode NFS RPC arguments and results.
  5.  *
  6.  * Copyright (C) 1992, 1993, 1994  Rick Sladkey
  7.  * Copyright (C) 1996 Olaf Kirch
  8.  * 04 Aug 1998  Ion Badulescu <ionut@cs.columbia.edu>
  9.  *  FIFO's need special handling in NFSv2
  10.  */
  12. #include <linux/param.h>
  13. #include <linux/sched.h>
  14. #include <linux/mm.h>
  15. #include <linux/slab.h>
  16. #include <linux/utsname.h>
  17. #include <linux/errno.h>
  18. #include <linux/string.h>
  19. #include <linux/in.h>
  20. #include <linux/pagemap.h>
  21. #include <linux/proc_fs.h>
  22. #include <linux/sunrpc/clnt.h>
  23. #include <linux/nfs.h>
  24. #include <linux/nfs2.h>
  25. #include <linux/nfs_fs.h>
  27. /* Uncomment this to support servers requiring longword lengths */
  28. #define NFS_PAD_WRITES 1
  30. #define NFSDBG_FACILITY NFSDBG_XDR
  31. /* #define NFS_PARANOIA 1 */
  33. extern int nfs_stat_to_errno(int stat);
  35. /* Mapping from NFS error code to "errno" error code. */
  36. #define errno_NFSERR_IO EIO
  38. /*
  39.  * Declare the space requirements for NFS arguments and replies as
  40.  * number of 32bit-words
  41.  */
  42. #define NFS_fhandle_sz 8
  43. #define NFS_sattr_sz 8
  44. #define NFS_filename_sz 1+(NFS2_MAXNAMLEN>>2)
  45. #define NFS_path_sz 1+(NFS2_MAXPATHLEN>>2)
  46. #define NFS_fattr_sz 17
  47. #define NFS_info_sz 5
  48. #define NFS_entry_sz NFS_filename_sz+3
  50. #define NFS_enc_void_sz 0
  51. #define NFS_diropargs_sz NFS_fhandle_sz+NFS_filename_sz
  52. #define NFS_sattrargs_sz NFS_fhandle_sz+NFS_sattr_sz
  53. #define NFS_readlinkargs_sz NFS_fhandle_sz
  54. #define NFS_readargs_sz NFS_fhandle_sz+3
  55. #define NFS_writeargs_sz NFS_fhandle_sz+4
  56. #define NFS_createargs_sz NFS_diropargs_sz+NFS_sattr_sz
  57. #define NFS_renameargs_sz NFS_diropargs_sz+NFS_diropargs_sz
  58. #define NFS_linkargs_sz NFS_fhandle_sz+NFS_diropargs_sz
  59. #define NFS_symlinkargs_sz NFS_diropargs_sz+NFS_path_sz+NFS_sattr_sz
  60. #define NFS_readdirargs_sz NFS_fhandle_sz+2
  62. #define NFS_dec_void_sz 0
  63. #define NFS_attrstat_sz 1+NFS_fattr_sz
  64. #define NFS_diropres_sz 1+NFS_fhandle_sz+NFS_fattr_sz
  65. #define NFS_readlinkres_sz 1
  66. #define NFS_readres_sz 1+NFS_fattr_sz+1
  67. #define NFS_writeres_sz         NFS_attrstat_sz
  68. #define NFS_stat_sz 1
  69. #define NFS_readdirres_sz 1
  70. #define NFS_statfsres_sz 1+NFS_info_sz
  72. /*
  73.  * Common NFS XDR functions as inlines
  74.  */
  75. static inline u32 *
  76. xdr_encode_fhandle(u32 *p, struct nfs_fh *fhandle)
  77. {
  78. memcpy(p, fhandle->data, NFS2_FHSIZE);
  79. return p + XDR_QUADLEN(NFS2_FHSIZE);
  80. }
  82. static inline u32 *
  83. xdr_decode_fhandle(u32 *p, struct nfs_fh *fhandle)
  84. {
  85. /* Zero handle first to allow comparisons */
  86. memset(fhandle, 0, sizeof(*fhandle));
  87. /* NFSv2 handles have a fixed length */
  88. fhandle->size = NFS2_FHSIZE;
  89. memcpy(fhandle->data, p, NFS2_FHSIZE);
  90. return p + XDR_QUADLEN(NFS2_FHSIZE);
  91. }
  93. static inline u32 *
  94. xdr_decode_string2(u32 *p, char **string, unsigned int *len,
  95. unsigned int maxlen)
  96. {
  97. *len = ntohl(*p++);
  98. if (*len > maxlen)
  99. return NULL;
  100. *string = (char *) p;
  101. return p + XDR_QUADLEN(*len);
  102. }
  104. static inline u32*
  105. xdr_decode_time(u32 *p, u64 *timep)
  106. {
  107. u64 tmp = (u64)ntohl(*p++) << 32;
  108. *timep = tmp + (u64)ntohl(*p++);
  109. return p;
  110. }
  112. static inline u32 *
  113. xdr_decode_fattr(u32 *p, struct nfs_fattr *fattr)
  114. {
  115. fattr->type = (enum nfs_ftype) ntohl(*p++);
  116. fattr->mode = ntohl(*p++);
  117. fattr->nlink = ntohl(*p++);
  118. fattr->uid = ntohl(*p++);
  119. fattr->gid = ntohl(*p++);
  120. fattr->size = ntohl(*p++);
  121. fattr->du.nfs2.blocksize = ntohl(*p++);
  122. fattr->rdev = ntohl(*p++);
  123. fattr->du.nfs2.blocks = ntohl(*p++);
  124. fattr->fsid = ntohl(*p++);
  125. fattr->fileid = ntohl(*p++);
  126. p = xdr_decode_time(p, &fattr->atime);
  127. p = xdr_decode_time(p, &fattr->mtime);
  128. p = xdr_decode_time(p, &fattr->ctime);
  129. fattr->valid |= NFS_ATTR_FATTR;
  130. if (fattr->type == NFCHR && fattr->rdev == NFS2_FIFO_DEV) {
  131. fattr->type = NFFIFO;
  132. fattr->mode = (fattr->mode & ~S_IFMT) | S_IFIFO;
  133. fattr->rdev = 0;
  134. }
  135. return p;
  136. }
  138. #define SATTR(p, attr, flag, field) 
  139.         *p++ = (attr->ia_valid & flag) ? htonl(attr->field) : ~(u32) 0
  140. static inline u32 *
  141. xdr_encode_sattr(u32 *p, struct iattr *attr)
  142. {
  143. SATTR(p, attr, ATTR_MODE, ia_mode);
  144. SATTR(p, attr, ATTR_UID, ia_uid);
  145. SATTR(p, attr, ATTR_GID, ia_gid);
  146. SATTR(p, attr, ATTR_SIZE, ia_size);
  148. if (attr->ia_valid & (ATTR_ATIME|ATTR_ATIME_SET)) {
  149. *p++ = htonl(attr->ia_atime);
  150. *p++ = 0;
  151. } else {
  152. *p++ = ~(u32) 0;
  153. *p++ = ~(u32) 0;
  154. }
  156. if (attr->ia_valid & (ATTR_MTIME|ATTR_MTIME_SET)) {
  157. *p++ = htonl(attr->ia_mtime);
  158. *p++ = 0;
  159. } else {
  160. *p++ = ~(u32) 0;
  161. *p++ = ~(u32) 0;
  162. }
  163.    return p;
  164. }
  165. #undef SATTR
  167. /*
  168.  * NFS encode functions
  169.  */
  170. /*
  171.  * Encode void argument
  172.  */
  173. static int
  174. nfs_xdr_enc_void(struct rpc_rqst *req, u32 *p, void *dummy)
  175. {
  176. req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
  177. return 0;
  178. }
  180. /*
  181.  * Encode file handle argument
  182.  * GETATTR, READLINK, STATFS
  183.  */
  184. static int
  185. nfs_xdr_fhandle(struct rpc_rqst *req, u32 *p, struct nfs_fh *fh)
  186. {
  187. p = xdr_encode_fhandle(p, fh);
  188. req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
  189. return 0;
  190. }
  192. /*
  193.  * Encode SETATTR arguments
  194.  */
  195. static int
  196. nfs_xdr_sattrargs(struct rpc_rqst *req, u32 *p, struct nfs_sattrargs *args)
  197. {
  198. p = xdr_encode_fhandle(p, args->fh);
  199. p = xdr_encode_sattr(p, args->sattr);
  200. req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
  201. return 0;
  202. }
  204. /*
  205.  * Encode directory ops argument
  206.  * LOOKUP, REMOVE, RMDIR
  207.  */
  208. static int
  209. nfs_xdr_diropargs(struct rpc_rqst *req, u32 *p, struct nfs_diropargs *args)
  210. {
  211. p = xdr_encode_fhandle(p, args->fh);
  212. p = xdr_encode_array(p, args->name, args->len);
  213. req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
  214. return 0;
  215. }
  217. /*
  218.  * Arguments to a READ call. Since we read data directly into the page
  219.  * cache, we also set up the reply iovec here so that iov[1] points
  220.  * exactly to the page we want to fetch.
  221.  */
  222. static int
  223. nfs_xdr_readargs(struct rpc_rqst *req, u32 *p, struct nfs_readargs *args)
  224. {
  225. struct rpc_auth *auth = req->rq_task->tk_auth;
  226. int buflen, replen;
  227. unsigned int nr;
  229. p = xdr_encode_fhandle(p, args->fh);
  230. *p++ = htonl(args->offset);
  231. *p++ = htonl(args->count);
  232. *p++ = htonl(args->count);
  233. req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
  235. /* Get the number of buffers in the receive iovec */
  236.         nr = args->nriov;
  238.         if (nr+2 > MAX_IOVEC) {
  239.                 printk(KERN_ERR "NFS: Bad number of iov's in xdr_readargsn");
  240.                 return -EINVAL;
  241.         }
  243. /* set up reply iovec */
  244. replen = (RPC_REPHDRSIZE + auth->au_rslack + NFS_readres_sz) << 2;
  245. buflen = req->rq_rvec[0].iov_len;
  246. req->rq_rvec[0].iov_len  = replen;
  247.         /* Copy the iovec */
  248.         memcpy(req->rq_rvec + 1, args->iov, nr * sizeof(struct iovec));
  250. req->rq_rvec[nr+1].iov_base = (u8 *) req->rq_rvec[0].iov_base + replen;
  251. req->rq_rvec[nr+1].iov_len  = buflen - replen;
  252. req->rq_rlen = args->count + buflen;
  253. req->rq_rnr += nr+1;
  255. return 0;
  256. }
  258. /*
  259.  * Decode READ reply
  260.  */
  261. static int
  262. nfs_xdr_readres(struct rpc_rqst *req, u32 *p, struct nfs_readres *res)
  263. {
  264. struct iovec *iov = req->rq_rvec;
  265. int status, count, recvd, hdrlen;
  267. if ((status = ntohl(*p++)))
  268. return -nfs_stat_to_errno(status);
  269. p = xdr_decode_fattr(p, res->fattr);
  271. count = ntohl(*p++);
  272. hdrlen = (u8 *) p - (u8 *) iov->iov_base;
  273. if (iov->iov_len > hdrlen) {
  274. dprintk("NFS: READ header is short. iovec will be shifted.n");
  275. xdr_shift_iovec(iov, req->rq_rnr, iov->iov_len - hdrlen);
  276. }
  278. recvd = req->rq_rlen - hdrlen;
  279. if (count > recvd) {
  280. printk(KERN_WARNING "NFS: server cheating in read reply: "
  281. "count %d > recvd %dn", count, recvd);
  282. count = recvd;
  283. }
  285. dprintk("RPC:      readres OK count %dn", count);
  286. if (count < res->count) {
  287. xdr_zero_iovec(iov+1, req->rq_rnr-2, res->count - count);
  288. res->count = count;
  289. res->eof = 1;  /* Silly NFSv3ism which can't be helped */
  290. } else
  291. res->eof = 0;
  293. return count;
  294. }
  297. /*
  298.  * Write arguments. Splice the buffer to be written into the iovec.
  299.  */
  300. static int
  301. nfs_xdr_writeargs(struct rpc_rqst *req, u32 *p, struct nfs_writeargs *args)
  302. {
  303. unsigned int nr;
  304. u32 count = args->count;
  306. p = xdr_encode_fhandle(p, args->fh);
  307. *p++ = htonl(args->offset);
  308. *p++ = htonl(args->offset);
  309. *p++ = htonl(count);
  310. *p++ = htonl(count);
  311. req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
  313. /* Get the number of buffers in the send iovec */
  314. nr = args->nriov;
  316. if (nr+2 > MAX_IOVEC) {
  317.                 printk(KERN_ERR "NFS: Bad number of iov's in xdr_writeargs "
  318.                         "(nr %d max %d)n", nr, MAX_IOVEC);
  319.                 return -EINVAL;
  320.         }
  322. /* Copy the iovec */
  323.         memcpy(req->rq_svec + 1, args->iov, nr * sizeof(struct iovec));
  325. #ifdef NFS_PAD_WRITES
  326. /*
  327.  * Some old servers require that the message length
  328.  * be a multiple of 4, so we pad it here if needed.
  329.  */
  330. if (count & 3) {
  331. struct iovec *iov = req->rq_svec + nr + 1;
  332. int pad = 4 - (count & 3);
  334. iov->iov_base = (void *) "";
  335. iov->iov_len  = pad;
  336. count += pad;
  337. nr++;
  338. }
  339. #endif
  340. req->rq_slen += count;
  341. req->rq_snr += nr;
  343. return 0;
  344. }
  346. /*
  347.  * Encode create arguments
  348.  * CREATE, MKDIR
  349.  */
  350. static int
  351. nfs_xdr_createargs(struct rpc_rqst *req, u32 *p, struct nfs_createargs *args)
  352. {
  353. p = xdr_encode_fhandle(p, args->fh);
  354. p = xdr_encode_array(p, args->name, args->len);
  355. p = xdr_encode_sattr(p, args->sattr);
  356. req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
  357. return 0;
  358. }
  360. /*
  361.  * Encode RENAME arguments
  362.  */
  363. static int
  364. nfs_xdr_renameargs(struct rpc_rqst *req, u32 *p, struct nfs_renameargs *args)
  365. {
  366. p = xdr_encode_fhandle(p, args->fromfh);
  367. p = xdr_encode_array(p, args->fromname, args->fromlen);
  368. p = xdr_encode_fhandle(p, args->tofh);
  369. p = xdr_encode_array(p, args->toname, args->tolen);
  370. req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
  371. return 0;
  372. }
  374. /*
  375.  * Encode LINK arguments
  376.  */
  377. static int
  378. nfs_xdr_linkargs(struct rpc_rqst *req, u32 *p, struct nfs_linkargs *args)
  379. {
  380. p = xdr_encode_fhandle(p, args->fromfh);
  381. p = xdr_encode_fhandle(p, args->tofh);
  382. p = xdr_encode_array(p, args->toname, args->tolen);
  383. req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
  384. return 0;
  385. }
  387. /*
  388.  * Encode SYMLINK arguments
  389.  */
  390. static int
  391. nfs_xdr_symlinkargs(struct rpc_rqst *req, u32 *p, struct nfs_symlinkargs *args)
  392. {
  393. p = xdr_encode_fhandle(p, args->fromfh);
  394. p = xdr_encode_array(p, args->fromname, args->fromlen);
  395. p = xdr_encode_array(p, args->topath, args->tolen);
  396. p = xdr_encode_sattr(p, args->sattr);
  397. req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
  398. return 0;
  399. }
  401. /*
  402.  * Encode arguments to readdir call
  403.  */
  404. static int
  405. nfs_xdr_readdirargs(struct rpc_rqst *req, u32 *p, struct nfs_readdirargs *args)
  406. {
  407. struct rpc_task *task = req->rq_task;
  408. struct rpc_auth *auth = task->tk_auth;
  409. u32 bufsiz = args->bufsiz;
  410. int buflen, replen;
  412. /*
  413.  * Some servers (e.g. HP OS 9.5) seem to expect the buffer size
  414.  * to be in longwords ... check whether to convert the size.
  415.  */
  416. if (task->tk_client->cl_flags & NFS_CLNTF_BUFSIZE)
  417. bufsiz = bufsiz >> 2;
  419. p = xdr_encode_fhandle(p, args->fh);
  420. *p++ = htonl(args->cookie);
  421. *p++ = htonl(bufsiz); /* see above */
  422. req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
  424. /* set up reply iovec */
  425. replen = (RPC_REPHDRSIZE + auth->au_rslack + NFS_readdirres_sz) << 2;
  426. buflen = req->rq_rvec[0].iov_len;
  427. req->rq_rvec[0].iov_len  = replen;
  428. req->rq_rvec[1].iov_base = args->buffer;
  429. req->rq_rvec[1].iov_len  = args->bufsiz;
  430. req->rq_rvec[2].iov_base = (u8 *) req->rq_rvec[0].iov_base + replen;
  431. req->rq_rvec[2].iov_len  = buflen - replen;
  432. req->rq_rlen = buflen + args->bufsiz;
  433. req->rq_rnr += 2;
  435. return 0;
  436. }
  438. /*
  439.  * Decode the result of a readdir call.
  440.  * We're not really decoding anymore, we just leave the buffer untouched
  441.  * and only check that it is syntactically correct.
  442.  * The real decoding happens in nfs_decode_entry below, called directly
  443.  * from nfs_readdir for each entry.
  444.  */
  445. static int
  446. nfs_xdr_readdirres(struct rpc_rqst *req, u32 *p, struct nfs_readdirres *res)
  447. {
  448. struct iovec *iov = req->rq_rvec;
  449. int  hdrlen;
  450. int  status, nr;
  451. u32 *end, *entry, len;
  453. if ((status = ntohl(*p++)))
  454. return -nfs_stat_to_errno(status);
  456. hdrlen = (u8 *) p - (u8 *) iov->iov_base;
  457. if (iov->iov_len > hdrlen) {
  458. dprintk("NFS: READDIR header is short. iovec will be shifted.n");
  459. xdr_shift_iovec(iov, req->rq_rnr, iov->iov_len - hdrlen);
  460. }
  463. /* Get start and end address of XDR data */
  464. p   = (u32 *) iov[1].iov_base;
  465. end = (u32 *) ((u8 *) p + iov[1].iov_len);
  466. for (nr = 0; *p++; nr++) {
  467. entry = p - 1;
  468. if (p + 2 > end)
  469. goto short_pkt;
  470. p++; /* fileid */
  471. len = ntohl(*p++);
  472. p += XDR_QUADLEN(len) + 1; /* name plus cookie */
  473. if (len > NFS2_MAXNAMLEN) {
  474. printk(KERN_WARNING "NFS: giant filename in readdir (len 0x%x)!n",
  475. len);
  476. return -errno_NFSERR_IO;
  477. }
  478. if (p + 2 > end)
  479. goto short_pkt;
  480. }
  481. return nr;
  482.  short_pkt:
  483. printk(KERN_NOTICE "NFS: short packet in readdir reply!n");
  484. entry[0] = entry[1] = 0;
  485. return nr;
  486. }
  488. u32 *
  489. nfs_decode_dirent(u32 *p, struct nfs_entry *entry, int plus)
  490. {
  491. if (!*p++) {
  492. if (!*p)
  493. return ERR_PTR(-EAGAIN);
  494. entry->eof = 1;
  495. return ERR_PTR(-EBADCOOKIE);
  496. }
  498. entry->ino   = ntohl(*p++);
  499. entry->len   = ntohl(*p++);
  500. entry->name   = (const char *) p;
  501. p  += XDR_QUADLEN(entry->len);
  502. entry->prev_cookie   = entry->cookie;
  503. entry->cookie   = ntohl(*p++);
  504. entry->eof   = !p[0] && p[1];
  506. return p;
  507. }
  509. /*
  510.  * NFS XDR decode functions
  511.  */
  512. /*
  513.  * Decode void reply
  514.  */
  515. static int
  516. nfs_xdr_dec_void(struct rpc_rqst *req, u32 *p, void *dummy)
  517. {
  518. return 0;
  519. }
  521. /*
  522.  * Decode simple status reply
  523.  */
  524. static int
  525. nfs_xdr_stat(struct rpc_rqst *req, u32 *p, void *dummy)
  526. {
  527. int status;
  529. if ((status = ntohl(*p++)) != 0)
  530. status = -nfs_stat_to_errno(status);
  531. return status;
  532. }
  534. /*
  535.  * Decode attrstat reply
  536.  * GETATTR, SETATTR, WRITE
  537.  */
  538. static int
  539. nfs_xdr_attrstat(struct rpc_rqst *req, u32 *p, struct nfs_fattr *fattr)
  540. {
  541. int status;
  543. if ((status = ntohl(*p++)))
  544. return -nfs_stat_to_errno(status);
  545. xdr_decode_fattr(p, fattr);
  546. return 0;
  547. }
  549. /*
  550.  * Decode diropres reply
  551.  * LOOKUP, CREATE, MKDIR
  552.  */
  553. static int
  554. nfs_xdr_diropres(struct rpc_rqst *req, u32 *p, struct nfs_diropok *res)
  555. {
  556. int status;
  558. if ((status = ntohl(*p++)))
  559. return -nfs_stat_to_errno(status);
  560. p = xdr_decode_fhandle(p, res->fh);
  561. xdr_decode_fattr(p, res->fattr);
  562. return 0;
  563. }
  565. /*
  566.  * Encode READLINK args
  567.  */
  568. static int
  569. nfs_xdr_readlinkargs(struct rpc_rqst *req, u32 *p, struct nfs_readlinkargs *args)
  570. {
  571. struct rpc_task *task = req->rq_task;
  572. struct rpc_auth *auth = task->tk_auth;
  573. int buflen, replen;
  575. p = xdr_encode_fhandle(p, args->fh);
  576. req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
  577. replen = (RPC_REPHDRSIZE + auth->au_rslack + NFS_readlinkres_sz) << 2;
  578. buflen = req->rq_rvec[0].iov_len;
  579. req->rq_rvec[0].iov_len  = replen;
  580. req->rq_rvec[1].iov_base = args->buffer;
  581. req->rq_rvec[1].iov_len  = args->bufsiz;
  582. req->rq_rvec[2].iov_base = (u8 *) req->rq_rvec[0].iov_base + replen;
  583. req->rq_rvec[2].iov_len  = buflen - replen;
  584. req->rq_rlen = buflen + args->bufsiz;
  585. req->rq_rnr += 2;
  586. return 0;
  587. }
  589. /*
  590.  * Decode READLINK reply
  591.  */
  592. static int
  593. nfs_xdr_readlinkres(struct rpc_rqst *req, u32 *p, struct nfs_readlinkres *res)
  594. {
  595. struct iovec *iov = req->rq_rvec;
  596. u32 *strlen;
  597. char *string;
  598. int hdrlen;
  599. int status;
  600. unsigned int len;
  602. if ((status = ntohl(*p++)))
  603. return -nfs_stat_to_errno(status);
  604. hdrlen = (u8 *) p - (u8 *) iov->iov_base;
  605. if (iov->iov_len > hdrlen) {
  606. dprintk("NFS: READLINK header is short. iovec will be shifted.n");
  607. xdr_shift_iovec(iov, req->rq_rnr, iov->iov_len - hdrlen);
  608. }
  610. strlen = (u32*)res->buffer;
  611. /* Convert length of symlink */
  612. len = ntohl(*strlen);
  613. if (len > res->bufsiz - 5)
  614. len = res->bufsiz - 5;
  615. *strlen = len;
  616. /* NULL terminate the string we got */
  617. string = (char *)(strlen + 1);
  618. string[len] = 0;
  619. return 0;
  620. }
  622. /*
  623.  * Decode WRITE reply
  624.  */
  625. static int
  626. nfs_xdr_writeres(struct rpc_rqst *req, u32 *p, struct nfs_writeres *res)
  627. {
  628. res->verf->committed = NFS_FILE_SYNC;
  629. return nfs_xdr_attrstat(req, p, res->fattr);
  630. }
  632. /*
  633.  * Decode STATFS reply
  634.  */
  635. static int
  636. nfs_xdr_statfsres(struct rpc_rqst *req, u32 *p, struct nfs_fsinfo *res)
  637. {
  638. int status;
  639. u32 xfer_size;
  641. if ((status = ntohl(*p++)))
  642. return -nfs_stat_to_errno(status);
  644. /* For NFSv2, we more or less have to guess the preferred
  645.  * read/write/readdir sizes from the single 'transfer size'
  646.  * value.
  647.  */
  648. xfer_size = ntohl(*p++); /* tsize */
  649. res->rtmax  = 8 * 1024;
  650. res->rtpref = xfer_size;
  651. res->rtmult = xfer_size;
  652. res->wtmax  = 8 * 1024;
  653. res->wtpref = xfer_size;
  654. res->wtmult = xfer_size;
  655. res->dtpref = PAGE_CACHE_SIZE;
  656. res->maxfilesize = 0x7FFFFFFF; /* just a guess */
  657. res->bsize  = ntohl(*p++);
  659. res->tbytes = ntohl(*p++) * res->bsize;
  660. res->fbytes = ntohl(*p++) * res->bsize;
  661. res->abytes = ntohl(*p++) * res->bsize;
  662. res->tfiles = 0;
  663. res->ffiles = 0;
  664. res->afiles = 0;
  665. res->namelen = 0;
  667. return 0;
  668. }
  670. /*
  671.  * We need to translate between nfs status return values and
  672.  * the local errno values which may not be the same.
  673.  */
  674. static struct {
  675. int stat;
  676. int errno;
  677. } nfs_errtbl[] = {
  678. { NFS_OK, 0 },
  679. { NFSERR_PERM, EPERM },
  680. { NFSERR_NOENT, ENOENT },
  681. { NFSERR_IO, errno_NFSERR_IO },
  682. { NFSERR_NXIO, ENXIO },
  683. /* { NFSERR_EAGAIN, EAGAIN }, */
  684. { NFSERR_ACCES, EACCES },
  685. { NFSERR_EXIST, EEXIST },
  686. { NFSERR_XDEV, EXDEV },
  687. { NFSERR_NODEV, ENODEV },
  688. { NFSERR_NOTDIR, ENOTDIR },
  689. { NFSERR_ISDIR, EISDIR },
  690. { NFSERR_INVAL, EINVAL },
  691. { NFSERR_FBIG, EFBIG },
  692. { NFSERR_NOSPC, ENOSPC },
  693. { NFSERR_ROFS, EROFS },
  694. { NFSERR_MLINK, EMLINK },
  695. { NFSERR_NAMETOOLONG, ENAMETOOLONG },
  696. { NFSERR_NOTEMPTY, ENOTEMPTY },
  697. { NFSERR_DQUOT, EDQUOT },
  698. { NFSERR_STALE, ESTALE },
  699. { NFSERR_REMOTE, EREMOTE },
  700. #ifdef EWFLUSH
  701. { NFSERR_WFLUSH, EWFLUSH },
  702. #endif
  703. { NFSERR_BADHANDLE, EBADHANDLE },
  704. { NFSERR_NOT_SYNC, ENOTSYNC },
  705. { NFSERR_BAD_COOKIE, EBADCOOKIE },
  706. { NFSERR_NOTSUPP, ENOTSUPP },
  707. { NFSERR_TOOSMALL, ETOOSMALL },
  708. { NFSERR_SERVERFAULT, ESERVERFAULT },
  709. { NFSERR_BADTYPE, EBADTYPE },
  710. { NFSERR_JUKEBOX, EJUKEBOX },
  711. { -1, EIO }
  712. };
  714. /*
  715.  * Convert an NFS error code to a local one.
  716.  * This one is used jointly by NFSv2 and NFSv3.
  717.  */
  718. int
  719. nfs_stat_to_errno(int stat)
  720. {
  721. int i;
  723. for (i = 0; nfs_errtbl[i].stat != -1; i++) {
  724. if (nfs_errtbl[i].stat == stat)
  725. return nfs_errtbl[i].errno;
  726. }
  727. printk(KERN_ERR "nfs_stat_to_errno: bad nfs status return value: %dn", stat);
  728. return nfs_errtbl[i].errno;
  729. }
  731. #ifndef MAX
  732. # define MAX(a, b) (((a) > (b))? (a) : (b))
  733. #endif
  735. #define PROC(proc, argtype, restype)
  736.     { "nfs_" #proc,
  737.       (kxdrproc_t) nfs_xdr_##argtype,
  738.       (kxdrproc_t) nfs_xdr_##restype,
  739.       MAX(NFS_##argtype##_sz,NFS_##restype##_sz) << 2,
  740.       0
  741.     }
  743. static struct rpc_procinfo nfs_procedures[18] = {
  744.     PROC(null, enc_void, dec_void),
  745.     PROC(getattr, fhandle, attrstat),
  746.     PROC(setattr, sattrargs, attrstat),
  747.     PROC(root, enc_void, dec_void),
  748.     PROC(lookup, diropargs, diropres),
  749.     PROC(readlink, readlinkargs, readlinkres),
  750.     PROC(read, readargs, readres),
  751.     PROC(writecache, enc_void, dec_void),
  752.     PROC(write, writeargs, writeres),
  753.     PROC(create, createargs, diropres),
  754.     PROC(remove, diropargs, stat),
  755.     PROC(rename, renameargs, stat),
  756.     PROC(link, linkargs, stat),
  757.     PROC(symlink, symlinkargs, stat),
  758.     PROC(mkdir, createargs, diropres),
  759.     PROC(rmdir, diropargs, stat),
  760.     PROC(readdir, readdirargs, readdirres),
  761.     PROC(statfs, fhandle, statfsres),
  762. };
  764. struct rpc_version nfs_version2 = {
  765. 2,
  766. sizeof(nfs_procedures)/sizeof(nfs_procedures[0]),
  767. nfs_procedures
  768. };