proc.c 18 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707
  1. /*
  2. * linux/fs/nfs/proc.c
  3. *
  4. * Copyright (C) 1992, 1993, 1994 Rick Sladkey
  5. *
  6. * OS-independent nfs remote procedure call functions
  7. *
  8. * Tuned by Alan Cox <A.Cox@swansea.ac.uk> for >3K buffers
  9. * so at last we can have decent(ish) throughput off a
  10. * Sun server.
  11. *
  12. * Coding optimized and cleaned up by Florian La Roche.
  13. * Note: Error returns are optimized for NFS_OK, which isn't translated via
  14. * nfs_stat_to_errno(), but happens to be already the right return code.
  15. *
  16. * Also, the code currently doesn't check the size of the packet, when
  17. * it decodes the packet.
  18. *
  19. * Feel free to fix it and mail me the diffs if it worries you.
  20. *
  21. * Completely rewritten to support the new RPC call interface;
  22. * rewrote and moved the entire XDR stuff to xdr.c
  23. * --Olaf Kirch June 1996
  24. *
  25. * The code below initializes all auto variables explicitly, otherwise
  26. * it will fail to work as a module (gcc generates a memset call for an
  27. * incomplete struct).
  28. */
  29. #include <linux/types.h>
  30. #include <linux/param.h>
  31. #include <linux/slab.h>
  32. #include <linux/time.h>
  33. #include <linux/mm.h>
  34. #include <linux/errno.h>
  35. #include <linux/string.h>
  36. #include <linux/in.h>
  37. #include <linux/pagemap.h>
  38. #include <linux/sunrpc/clnt.h>
  39. #include <linux/nfs.h>
  40. #include <linux/nfs2.h>
  41. #include <linux/nfs_fs.h>
  42. #include <linux/nfs_page.h>
  43. #include <linux/lockd/bind.h>
  44. #include "internal.h"
  45. #define NFSDBG_FACILITY NFSDBG_PROC
  46. /*
  47. * wrapper to handle the -EKEYEXPIRED error message. This should generally
  48. * only happen if using krb5 auth and a user's TGT expires. NFSv2 doesn't
  49. * support the NFSERR_JUKEBOX error code, but we handle this situation in the
  50. * same way that we handle that error with NFSv3.
  51. */
  52. static int
  53. nfs_rpc_wrapper(struct rpc_clnt *clnt, struct rpc_message *msg, int flags)
  54. {
  55. int res;
  56. do {
  57. res = rpc_call_sync(clnt, msg, flags);
  58. if (res != -EKEYEXPIRED)
  59. break;
  60. schedule_timeout_killable(NFS_JUKEBOX_RETRY_TIME);
  61. res = -ERESTARTSYS;
  62. } while (!fatal_signal_pending(current));
  63. return res;
  64. }
  65. #define rpc_call_sync(clnt, msg, flags) nfs_rpc_wrapper(clnt, msg, flags)
  66. static int
  67. nfs_async_handle_expired_key(struct rpc_task *task)
  68. {
  69. if (task->tk_status != -EKEYEXPIRED)
  70. return 0;
  71. task->tk_status = 0;
  72. rpc_restart_call(task);
  73. rpc_delay(task, NFS_JUKEBOX_RETRY_TIME);
  74. return 1;
  75. }
  76. /*
  77. * Bare-bones access to getattr: this is for nfs_read_super.
  78. */
  79. static int
  80. nfs_proc_get_root(struct nfs_server *server, struct nfs_fh *fhandle,
  81. struct nfs_fsinfo *info)
  82. {
  83. struct nfs_fattr *fattr = info->fattr;
  84. struct nfs2_fsstat fsinfo;
  85. struct rpc_message msg = {
  86. .rpc_proc = &nfs_procedures[NFSPROC_GETATTR],
  87. .rpc_argp = fhandle,
  88. .rpc_resp = fattr,
  89. };
  90. int status;
  91. dprintk("%s: call getattr\n", __func__);
  92. nfs_fattr_init(fattr);
  93. status = rpc_call_sync(server->client, &msg, 0);
  94. /* Retry with default authentication if different */
  95. if (status && server->nfs_client->cl_rpcclient != server->client)
  96. status = rpc_call_sync(server->nfs_client->cl_rpcclient, &msg, 0);
  97. dprintk("%s: reply getattr: %d\n", __func__, status);
  98. if (status)
  99. return status;
  100. dprintk("%s: call statfs\n", __func__);
  101. msg.rpc_proc = &nfs_procedures[NFSPROC_STATFS];
  102. msg.rpc_resp = &fsinfo;
  103. status = rpc_call_sync(server->client, &msg, 0);
  104. /* Retry with default authentication if different */
  105. if (status && server->nfs_client->cl_rpcclient != server->client)
  106. status = rpc_call_sync(server->nfs_client->cl_rpcclient, &msg, 0);
  107. dprintk("%s: reply statfs: %d\n", __func__, status);
  108. if (status)
  109. return status;
  110. info->rtmax = NFS_MAXDATA;
  111. info->rtpref = fsinfo.tsize;
  112. info->rtmult = fsinfo.bsize;
  113. info->wtmax = NFS_MAXDATA;
  114. info->wtpref = fsinfo.tsize;
  115. info->wtmult = fsinfo.bsize;
  116. info->dtpref = fsinfo.tsize;
  117. info->maxfilesize = 0x7FFFFFFF;
  118. info->lease_time = 0;
  119. return 0;
  120. }
  121. /*
  122. * One function for each procedure in the NFS protocol.
  123. */
  124. static int
  125. nfs_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle,
  126. struct nfs_fattr *fattr)
  127. {
  128. struct rpc_message msg = {
  129. .rpc_proc = &nfs_procedures[NFSPROC_GETATTR],
  130. .rpc_argp = fhandle,
  131. .rpc_resp = fattr,
  132. };
  133. int status;
  134. dprintk("NFS call getattr\n");
  135. nfs_fattr_init(fattr);
  136. status = rpc_call_sync(server->client, &msg, 0);
  137. dprintk("NFS reply getattr: %d\n", status);
  138. return status;
  139. }
  140. static int
  141. nfs_proc_setattr(struct dentry *dentry, struct nfs_fattr *fattr,
  142. struct iattr *sattr)
  143. {
  144. struct inode *inode = dentry->d_inode;
  145. struct nfs_sattrargs arg = {
  146. .fh = NFS_FH(inode),
  147. .sattr = sattr
  148. };
  149. struct rpc_message msg = {
  150. .rpc_proc = &nfs_procedures[NFSPROC_SETATTR],
  151. .rpc_argp = &arg,
  152. .rpc_resp = fattr,
  153. };
  154. int status;
  155. /* Mask out the non-modebit related stuff from attr->ia_mode */
  156. sattr->ia_mode &= S_IALLUGO;
  157. dprintk("NFS call setattr\n");
  158. if (sattr->ia_valid & ATTR_FILE)
  159. msg.rpc_cred = nfs_file_cred(sattr->ia_file);
  160. nfs_fattr_init(fattr);
  161. status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0);
  162. if (status == 0)
  163. nfs_setattr_update_inode(inode, sattr);
  164. dprintk("NFS reply setattr: %d\n", status);
  165. return status;
  166. }
  167. static int
  168. nfs_proc_lookup(struct inode *dir, struct qstr *name,
  169. struct nfs_fh *fhandle, struct nfs_fattr *fattr)
  170. {
  171. struct nfs_diropargs arg = {
  172. .fh = NFS_FH(dir),
  173. .name = name->name,
  174. .len = name->len
  175. };
  176. struct nfs_diropok res = {
  177. .fh = fhandle,
  178. .fattr = fattr
  179. };
  180. struct rpc_message msg = {
  181. .rpc_proc = &nfs_procedures[NFSPROC_LOOKUP],
  182. .rpc_argp = &arg,
  183. .rpc_resp = &res,
  184. };
  185. int status;
  186. dprintk("NFS call lookup %s\n", name->name);
  187. nfs_fattr_init(fattr);
  188. status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
  189. dprintk("NFS reply lookup: %d\n", status);
  190. return status;
  191. }
  192. static int nfs_proc_readlink(struct inode *inode, struct page *page,
  193. unsigned int pgbase, unsigned int pglen)
  194. {
  195. struct nfs_readlinkargs args = {
  196. .fh = NFS_FH(inode),
  197. .pgbase = pgbase,
  198. .pglen = pglen,
  199. .pages = &page
  200. };
  201. struct rpc_message msg = {
  202. .rpc_proc = &nfs_procedures[NFSPROC_READLINK],
  203. .rpc_argp = &args,
  204. };
  205. int status;
  206. dprintk("NFS call readlink\n");
  207. status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0);
  208. dprintk("NFS reply readlink: %d\n", status);
  209. return status;
  210. }
  211. static int
  212. nfs_proc_create(struct inode *dir, struct dentry *dentry, struct iattr *sattr,
  213. int flags, struct nameidata *nd)
  214. {
  215. struct nfs_fh fhandle;
  216. struct nfs_fattr fattr;
  217. struct nfs_createargs arg = {
  218. .fh = NFS_FH(dir),
  219. .name = dentry->d_name.name,
  220. .len = dentry->d_name.len,
  221. .sattr = sattr
  222. };
  223. struct nfs_diropok res = {
  224. .fh = &fhandle,
  225. .fattr = &fattr
  226. };
  227. struct rpc_message msg = {
  228. .rpc_proc = &nfs_procedures[NFSPROC_CREATE],
  229. .rpc_argp = &arg,
  230. .rpc_resp = &res,
  231. };
  232. int status;
  233. nfs_fattr_init(&fattr);
  234. dprintk("NFS call create %s\n", dentry->d_name.name);
  235. status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
  236. nfs_mark_for_revalidate(dir);
  237. if (status == 0)
  238. status = nfs_instantiate(dentry, &fhandle, &fattr);
  239. dprintk("NFS reply create: %d\n", status);
  240. return status;
  241. }
  242. /*
  243. * In NFSv2, mknod is grafted onto the create call.
  244. */
  245. static int
  246. nfs_proc_mknod(struct inode *dir, struct dentry *dentry, struct iattr *sattr,
  247. dev_t rdev)
  248. {
  249. struct nfs_fh fhandle;
  250. struct nfs_fattr fattr;
  251. struct nfs_createargs arg = {
  252. .fh = NFS_FH(dir),
  253. .name = dentry->d_name.name,
  254. .len = dentry->d_name.len,
  255. .sattr = sattr
  256. };
  257. struct nfs_diropok res = {
  258. .fh = &fhandle,
  259. .fattr = &fattr
  260. };
  261. struct rpc_message msg = {
  262. .rpc_proc = &nfs_procedures[NFSPROC_CREATE],
  263. .rpc_argp = &arg,
  264. .rpc_resp = &res,
  265. };
  266. int status, mode;
  267. dprintk("NFS call mknod %s\n", dentry->d_name.name);
  268. mode = sattr->ia_mode;
  269. if (S_ISFIFO(mode)) {
  270. sattr->ia_mode = (mode & ~S_IFMT) | S_IFCHR;
  271. sattr->ia_valid &= ~ATTR_SIZE;
  272. } else if (S_ISCHR(mode) || S_ISBLK(mode)) {
  273. sattr->ia_valid |= ATTR_SIZE;
  274. sattr->ia_size = new_encode_dev(rdev);/* get out your barf bag */
  275. }
  276. nfs_fattr_init(&fattr);
  277. status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
  278. nfs_mark_for_revalidate(dir);
  279. if (status == -EINVAL && S_ISFIFO(mode)) {
  280. sattr->ia_mode = mode;
  281. nfs_fattr_init(&fattr);
  282. status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
  283. }
  284. if (status == 0)
  285. status = nfs_instantiate(dentry, &fhandle, &fattr);
  286. dprintk("NFS reply mknod: %d\n", status);
  287. return status;
  288. }
  289. static int
  290. nfs_proc_remove(struct inode *dir, struct qstr *name)
  291. {
  292. struct nfs_removeargs arg = {
  293. .fh = NFS_FH(dir),
  294. .name.len = name->len,
  295. .name.name = name->name,
  296. };
  297. struct rpc_message msg = {
  298. .rpc_proc = &nfs_procedures[NFSPROC_REMOVE],
  299. .rpc_argp = &arg,
  300. };
  301. int status;
  302. dprintk("NFS call remove %s\n", name->name);
  303. status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
  304. nfs_mark_for_revalidate(dir);
  305. dprintk("NFS reply remove: %d\n", status);
  306. return status;
  307. }
  308. static void
  309. nfs_proc_unlink_setup(struct rpc_message *msg, struct inode *dir)
  310. {
  311. msg->rpc_proc = &nfs_procedures[NFSPROC_REMOVE];
  312. }
  313. static int nfs_proc_unlink_done(struct rpc_task *task, struct inode *dir)
  314. {
  315. if (nfs_async_handle_expired_key(task))
  316. return 0;
  317. nfs_mark_for_revalidate(dir);
  318. return 1;
  319. }
  320. static int
  321. nfs_proc_rename(struct inode *old_dir, struct qstr *old_name,
  322. struct inode *new_dir, struct qstr *new_name)
  323. {
  324. struct nfs_renameargs arg = {
  325. .fromfh = NFS_FH(old_dir),
  326. .fromname = old_name->name,
  327. .fromlen = old_name->len,
  328. .tofh = NFS_FH(new_dir),
  329. .toname = new_name->name,
  330. .tolen = new_name->len
  331. };
  332. struct rpc_message msg = {
  333. .rpc_proc = &nfs_procedures[NFSPROC_RENAME],
  334. .rpc_argp = &arg,
  335. };
  336. int status;
  337. dprintk("NFS call rename %s -> %s\n", old_name->name, new_name->name);
  338. status = rpc_call_sync(NFS_CLIENT(old_dir), &msg, 0);
  339. nfs_mark_for_revalidate(old_dir);
  340. nfs_mark_for_revalidate(new_dir);
  341. dprintk("NFS reply rename: %d\n", status);
  342. return status;
  343. }
  344. static int
  345. nfs_proc_link(struct inode *inode, struct inode *dir, struct qstr *name)
  346. {
  347. struct nfs_linkargs arg = {
  348. .fromfh = NFS_FH(inode),
  349. .tofh = NFS_FH(dir),
  350. .toname = name->name,
  351. .tolen = name->len
  352. };
  353. struct rpc_message msg = {
  354. .rpc_proc = &nfs_procedures[NFSPROC_LINK],
  355. .rpc_argp = &arg,
  356. };
  357. int status;
  358. dprintk("NFS call link %s\n", name->name);
  359. status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0);
  360. nfs_mark_for_revalidate(inode);
  361. nfs_mark_for_revalidate(dir);
  362. dprintk("NFS reply link: %d\n", status);
  363. return status;
  364. }
  365. static int
  366. nfs_proc_symlink(struct inode *dir, struct dentry *dentry, struct page *page,
  367. unsigned int len, struct iattr *sattr)
  368. {
  369. struct nfs_fh fhandle;
  370. struct nfs_fattr fattr;
  371. struct nfs_symlinkargs arg = {
  372. .fromfh = NFS_FH(dir),
  373. .fromname = dentry->d_name.name,
  374. .fromlen = dentry->d_name.len,
  375. .pages = &page,
  376. .pathlen = len,
  377. .sattr = sattr
  378. };
  379. struct rpc_message msg = {
  380. .rpc_proc = &nfs_procedures[NFSPROC_SYMLINK],
  381. .rpc_argp = &arg,
  382. };
  383. int status;
  384. if (len > NFS2_MAXPATHLEN)
  385. return -ENAMETOOLONG;
  386. dprintk("NFS call symlink %s\n", dentry->d_name.name);
  387. status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
  388. nfs_mark_for_revalidate(dir);
  389. /*
  390. * V2 SYMLINK requests don't return any attributes. Setting the
  391. * filehandle size to zero indicates to nfs_instantiate that it
  392. * should fill in the data with a LOOKUP call on the wire.
  393. */
  394. if (status == 0) {
  395. nfs_fattr_init(&fattr);
  396. fhandle.size = 0;
  397. status = nfs_instantiate(dentry, &fhandle, &fattr);
  398. }
  399. dprintk("NFS reply symlink: %d\n", status);
  400. return status;
  401. }
  402. static int
  403. nfs_proc_mkdir(struct inode *dir, struct dentry *dentry, struct iattr *sattr)
  404. {
  405. struct nfs_fh fhandle;
  406. struct nfs_fattr fattr;
  407. struct nfs_createargs arg = {
  408. .fh = NFS_FH(dir),
  409. .name = dentry->d_name.name,
  410. .len = dentry->d_name.len,
  411. .sattr = sattr
  412. };
  413. struct nfs_diropok res = {
  414. .fh = &fhandle,
  415. .fattr = &fattr
  416. };
  417. struct rpc_message msg = {
  418. .rpc_proc = &nfs_procedures[NFSPROC_MKDIR],
  419. .rpc_argp = &arg,
  420. .rpc_resp = &res,
  421. };
  422. int status;
  423. dprintk("NFS call mkdir %s\n", dentry->d_name.name);
  424. nfs_fattr_init(&fattr);
  425. status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
  426. nfs_mark_for_revalidate(dir);
  427. if (status == 0)
  428. status = nfs_instantiate(dentry, &fhandle, &fattr);
  429. dprintk("NFS reply mkdir: %d\n", status);
  430. return status;
  431. }
  432. static int
  433. nfs_proc_rmdir(struct inode *dir, struct qstr *name)
  434. {
  435. struct nfs_diropargs arg = {
  436. .fh = NFS_FH(dir),
  437. .name = name->name,
  438. .len = name->len
  439. };
  440. struct rpc_message msg = {
  441. .rpc_proc = &nfs_procedures[NFSPROC_RMDIR],
  442. .rpc_argp = &arg,
  443. };
  444. int status;
  445. dprintk("NFS call rmdir %s\n", name->name);
  446. status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
  447. nfs_mark_for_revalidate(dir);
  448. dprintk("NFS reply rmdir: %d\n", status);
  449. return status;
  450. }
  451. /*
  452. * The READDIR implementation is somewhat hackish - we pass a temporary
  453. * buffer to the encode function, which installs it in the receive
  454. * the receive iovec. The decode function just parses the reply to make
  455. * sure it is syntactically correct; the entries itself are decoded
  456. * from nfs_readdir by calling the decode_entry function directly.
  457. */
  458. static int
  459. nfs_proc_readdir(struct dentry *dentry, struct rpc_cred *cred,
  460. u64 cookie, struct page *page, unsigned int count, int plus)
  461. {
  462. struct inode *dir = dentry->d_inode;
  463. struct nfs_readdirargs arg = {
  464. .fh = NFS_FH(dir),
  465. .cookie = cookie,
  466. .count = count,
  467. .pages = &page,
  468. };
  469. struct rpc_message msg = {
  470. .rpc_proc = &nfs_procedures[NFSPROC_READDIR],
  471. .rpc_argp = &arg,
  472. .rpc_cred = cred,
  473. };
  474. int status;
  475. dprintk("NFS call readdir %d\n", (unsigned int)cookie);
  476. status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
  477. nfs_invalidate_atime(dir);
  478. dprintk("NFS reply readdir: %d\n", status);
  479. return status;
  480. }
  481. static int
  482. nfs_proc_statfs(struct nfs_server *server, struct nfs_fh *fhandle,
  483. struct nfs_fsstat *stat)
  484. {
  485. struct nfs2_fsstat fsinfo;
  486. struct rpc_message msg = {
  487. .rpc_proc = &nfs_procedures[NFSPROC_STATFS],
  488. .rpc_argp = fhandle,
  489. .rpc_resp = &fsinfo,
  490. };
  491. int status;
  492. dprintk("NFS call statfs\n");
  493. nfs_fattr_init(stat->fattr);
  494. status = rpc_call_sync(server->client, &msg, 0);
  495. dprintk("NFS reply statfs: %d\n", status);
  496. if (status)
  497. goto out;
  498. stat->tbytes = (u64)fsinfo.blocks * fsinfo.bsize;
  499. stat->fbytes = (u64)fsinfo.bfree * fsinfo.bsize;
  500. stat->abytes = (u64)fsinfo.bavail * fsinfo.bsize;
  501. stat->tfiles = 0;
  502. stat->ffiles = 0;
  503. stat->afiles = 0;
  504. out:
  505. return status;
  506. }
  507. static int
  508. nfs_proc_fsinfo(struct nfs_server *server, struct nfs_fh *fhandle,
  509. struct nfs_fsinfo *info)
  510. {
  511. struct nfs2_fsstat fsinfo;
  512. struct rpc_message msg = {
  513. .rpc_proc = &nfs_procedures[NFSPROC_STATFS],
  514. .rpc_argp = fhandle,
  515. .rpc_resp = &fsinfo,
  516. };
  517. int status;
  518. dprintk("NFS call fsinfo\n");
  519. nfs_fattr_init(info->fattr);
  520. status = rpc_call_sync(server->client, &msg, 0);
  521. dprintk("NFS reply fsinfo: %d\n", status);
  522. if (status)
  523. goto out;
  524. info->rtmax = NFS_MAXDATA;
  525. info->rtpref = fsinfo.tsize;
  526. info->rtmult = fsinfo.bsize;
  527. info->wtmax = NFS_MAXDATA;
  528. info->wtpref = fsinfo.tsize;
  529. info->wtmult = fsinfo.bsize;
  530. info->dtpref = fsinfo.tsize;
  531. info->maxfilesize = 0x7FFFFFFF;
  532. info->lease_time = 0;
  533. out:
  534. return status;
  535. }
  536. static int
  537. nfs_proc_pathconf(struct nfs_server *server, struct nfs_fh *fhandle,
  538. struct nfs_pathconf *info)
  539. {
  540. info->max_link = 0;
  541. info->max_namelen = NFS2_MAXNAMLEN;
  542. return 0;
  543. }
  544. static int nfs_read_done(struct rpc_task *task, struct nfs_read_data *data)
  545. {
  546. if (nfs_async_handle_expired_key(task))
  547. return -EAGAIN;
  548. nfs_invalidate_atime(data->inode);
  549. if (task->tk_status >= 0) {
  550. nfs_refresh_inode(data->inode, data->res.fattr);
  551. /* Emulate the eof flag, which isn't normally needed in NFSv2
  552. * as it is guaranteed to always return the file attributes
  553. */
  554. if (data->args.offset + data->args.count >= data->res.fattr->size)
  555. data->res.eof = 1;
  556. }
  557. return 0;
  558. }
  559. static void nfs_proc_read_setup(struct nfs_read_data *data, struct rpc_message *msg)
  560. {
  561. msg->rpc_proc = &nfs_procedures[NFSPROC_READ];
  562. }
  563. static int nfs_write_done(struct rpc_task *task, struct nfs_write_data *data)
  564. {
  565. if (nfs_async_handle_expired_key(task))
  566. return -EAGAIN;
  567. if (task->tk_status >= 0)
  568. nfs_post_op_update_inode_force_wcc(data->inode, data->res.fattr);
  569. return 0;
  570. }
  571. static void nfs_proc_write_setup(struct nfs_write_data *data, struct rpc_message *msg)
  572. {
  573. /* Note: NFSv2 ignores @stable and always uses NFS_FILE_SYNC */
  574. data->args.stable = NFS_FILE_SYNC;
  575. msg->rpc_proc = &nfs_procedures[NFSPROC_WRITE];
  576. }
  577. static void
  578. nfs_proc_commit_setup(struct nfs_write_data *data, struct rpc_message *msg)
  579. {
  580. BUG();
  581. }
  582. static int
  583. nfs_proc_lock(struct file *filp, int cmd, struct file_lock *fl)
  584. {
  585. struct inode *inode = filp->f_path.dentry->d_inode;
  586. return nlmclnt_proc(NFS_SERVER(inode)->nlm_host, cmd, fl);
  587. }
  588. /* Helper functions for NFS lock bounds checking */
  589. #define NFS_LOCK32_OFFSET_MAX ((__s32)0x7fffffffUL)
  590. static int nfs_lock_check_bounds(const struct file_lock *fl)
  591. {
  592. __s32 start, end;
  593. start = (__s32)fl->fl_start;
  594. if ((loff_t)start != fl->fl_start)
  595. goto out_einval;
  596. if (fl->fl_end != OFFSET_MAX) {
  597. end = (__s32)fl->fl_end;
  598. if ((loff_t)end != fl->fl_end)
  599. goto out_einval;
  600. } else
  601. end = NFS_LOCK32_OFFSET_MAX;
  602. if (start < 0 || start > end)
  603. goto out_einval;
  604. return 0;
  605. out_einval:
  606. return -EINVAL;
  607. }
  608. const struct nfs_rpc_ops nfs_v2_clientops = {
  609. .version = 2, /* protocol version */
  610. .dentry_ops = &nfs_dentry_operations,
  611. .dir_inode_ops = &nfs_dir_inode_operations,
  612. .file_inode_ops = &nfs_file_inode_operations,
  613. .getroot = nfs_proc_get_root,
  614. .getattr = nfs_proc_getattr,
  615. .setattr = nfs_proc_setattr,
  616. .lookup = nfs_proc_lookup,
  617. .access = NULL, /* access */
  618. .readlink = nfs_proc_readlink,
  619. .create = nfs_proc_create,
  620. .remove = nfs_proc_remove,
  621. .unlink_setup = nfs_proc_unlink_setup,
  622. .unlink_done = nfs_proc_unlink_done,
  623. .rename = nfs_proc_rename,
  624. .link = nfs_proc_link,
  625. .symlink = nfs_proc_symlink,
  626. .mkdir = nfs_proc_mkdir,
  627. .rmdir = nfs_proc_rmdir,
  628. .readdir = nfs_proc_readdir,
  629. .mknod = nfs_proc_mknod,
  630. .statfs = nfs_proc_statfs,
  631. .fsinfo = nfs_proc_fsinfo,
  632. .pathconf = nfs_proc_pathconf,
  633. .decode_dirent = nfs_decode_dirent,
  634. .read_setup = nfs_proc_read_setup,
  635. .read_done = nfs_read_done,
  636. .write_setup = nfs_proc_write_setup,
  637. .write_done = nfs_write_done,
  638. .commit_setup = nfs_proc_commit_setup,
  639. .lock = nfs_proc_lock,
  640. .lock_check_bounds = nfs_lock_check_bounds,
  641. .close_context = nfs_close_context,
  642. };