nfs4filelayout.c 36 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342
  1. /*
  2. * Module for the pnfs nfs4 file layout driver.
  3. * Defines all I/O and Policy interface operations, plus code
  4. * to register itself with the pNFS client.
  5. *
  6. * Copyright (c) 2002
  7. * The Regents of the University of Michigan
  8. * All Rights Reserved
  9. *
  10. * Dean Hildebrand <dhildebz@umich.edu>
  11. *
  12. * Permission is granted to use, copy, create derivative works, and
  13. * redistribute this software and such derivative works for any purpose,
  14. * so long as the name of the University of Michigan is not used in
  15. * any advertising or publicity pertaining to the use or distribution
  16. * of this software without specific, written prior authorization. If
  17. * the above copyright notice or any other identification of the
  18. * University of Michigan is included in any copy of any portion of
  19. * this software, then the disclaimer below must also be included.
  20. *
  21. * This software is provided as is, without representation or warranty
  22. * of any kind either express or implied, including without limitation
  23. * the implied warranties of merchantability, fitness for a particular
  24. * purpose, or noninfringement. The Regents of the University of
  25. * Michigan shall not be liable for any damages, including special,
  26. * indirect, incidental, or consequential damages, with respect to any
  27. * claim arising out of or in connection with the use of the software,
  28. * even if it has been or is hereafter advised of the possibility of
  29. * such damages.
  30. */
  31. #include <linux/nfs_fs.h>
  32. #include <linux/nfs_page.h>
  33. #include <linux/module.h>
  34. #include <linux/sunrpc/metrics.h>
  35. #include "nfs4session.h"
  36. #include "internal.h"
  37. #include "delegation.h"
  38. #include "nfs4filelayout.h"
  39. #define NFSDBG_FACILITY NFSDBG_PNFS_LD
  40. MODULE_LICENSE("GPL");
  41. MODULE_AUTHOR("Dean Hildebrand <dhildebz@umich.edu>");
  42. MODULE_DESCRIPTION("The NFSv4 file layout driver");
  43. #define FILELAYOUT_POLL_RETRY_MAX (15*HZ)
  44. static loff_t
  45. filelayout_get_dense_offset(struct nfs4_filelayout_segment *flseg,
  46. loff_t offset)
  47. {
  48. u32 stripe_width = flseg->stripe_unit * flseg->dsaddr->stripe_count;
  49. u64 stripe_no;
  50. u32 rem;
  51. offset -= flseg->pattern_offset;
  52. stripe_no = div_u64(offset, stripe_width);
  53. div_u64_rem(offset, flseg->stripe_unit, &rem);
  54. return stripe_no * flseg->stripe_unit + rem;
  55. }
  56. /* This function is used by the layout driver to calculate the
  57. * offset of the file on the dserver based on whether the
  58. * layout type is STRIPE_DENSE or STRIPE_SPARSE
  59. */
  60. static loff_t
  61. filelayout_get_dserver_offset(struct pnfs_layout_segment *lseg, loff_t offset)
  62. {
  63. struct nfs4_filelayout_segment *flseg = FILELAYOUT_LSEG(lseg);
  64. switch (flseg->stripe_type) {
  65. case STRIPE_SPARSE:
  66. return offset;
  67. case STRIPE_DENSE:
  68. return filelayout_get_dense_offset(flseg, offset);
  69. }
  70. BUG();
  71. }
  72. static void filelayout_reset_write(struct nfs_write_data *data)
  73. {
  74. struct nfs_pgio_header *hdr = data->header;
  75. struct rpc_task *task = &data->task;
  76. if (!test_and_set_bit(NFS_IOHDR_REDO, &hdr->flags)) {
  77. dprintk("%s Reset task %5u for i/o through MDS "
  78. "(req %s/%lld, %u bytes @ offset %llu)\n", __func__,
  79. data->task.tk_pid,
  80. hdr->inode->i_sb->s_id,
  81. (long long)NFS_FILEID(hdr->inode),
  82. data->args.count,
  83. (unsigned long long)data->args.offset);
  84. task->tk_status = pnfs_write_done_resend_to_mds(hdr->inode,
  85. &hdr->pages,
  86. hdr->completion_ops,
  87. hdr->dreq);
  88. }
  89. }
  90. static void filelayout_reset_read(struct nfs_read_data *data)
  91. {
  92. struct nfs_pgio_header *hdr = data->header;
  93. struct rpc_task *task = &data->task;
  94. if (!test_and_set_bit(NFS_IOHDR_REDO, &hdr->flags)) {
  95. dprintk("%s Reset task %5u for i/o through MDS "
  96. "(req %s/%lld, %u bytes @ offset %llu)\n", __func__,
  97. data->task.tk_pid,
  98. hdr->inode->i_sb->s_id,
  99. (long long)NFS_FILEID(hdr->inode),
  100. data->args.count,
  101. (unsigned long long)data->args.offset);
  102. task->tk_status = pnfs_read_done_resend_to_mds(hdr->inode,
  103. &hdr->pages,
  104. hdr->completion_ops,
  105. hdr->dreq);
  106. }
  107. }
  108. static void filelayout_fenceme(struct inode *inode, struct pnfs_layout_hdr *lo)
  109. {
  110. if (!test_and_clear_bit(NFS_LAYOUT_RETURN, &lo->plh_flags))
  111. return;
  112. clear_bit(NFS_INO_LAYOUTCOMMIT, &NFS_I(inode)->flags);
  113. pnfs_return_layout(inode);
  114. }
  115. static int filelayout_async_handle_error(struct rpc_task *task,
  116. struct nfs4_state *state,
  117. struct nfs_client *clp,
  118. struct pnfs_layout_segment *lseg)
  119. {
  120. struct pnfs_layout_hdr *lo = lseg->pls_layout;
  121. struct inode *inode = lo->plh_inode;
  122. struct nfs_server *mds_server = NFS_SERVER(inode);
  123. struct nfs4_deviceid_node *devid = FILELAYOUT_DEVID_NODE(lseg);
  124. struct nfs_client *mds_client = mds_server->nfs_client;
  125. struct nfs4_slot_table *tbl = &clp->cl_session->fc_slot_table;
  126. if (task->tk_status >= 0)
  127. return 0;
  128. switch (task->tk_status) {
  129. /* MDS state errors */
  130. case -NFS4ERR_DELEG_REVOKED:
  131. case -NFS4ERR_ADMIN_REVOKED:
  132. case -NFS4ERR_BAD_STATEID:
  133. if (state == NULL)
  134. break;
  135. nfs_remove_bad_delegation(state->inode);
  136. case -NFS4ERR_OPENMODE:
  137. if (state == NULL)
  138. break;
  139. nfs4_schedule_stateid_recovery(mds_server, state);
  140. goto wait_on_recovery;
  141. case -NFS4ERR_EXPIRED:
  142. if (state != NULL)
  143. nfs4_schedule_stateid_recovery(mds_server, state);
  144. nfs4_schedule_lease_recovery(mds_client);
  145. goto wait_on_recovery;
  146. /* DS session errors */
  147. case -NFS4ERR_BADSESSION:
  148. case -NFS4ERR_BADSLOT:
  149. case -NFS4ERR_BAD_HIGH_SLOT:
  150. case -NFS4ERR_DEADSESSION:
  151. case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION:
  152. case -NFS4ERR_SEQ_FALSE_RETRY:
  153. case -NFS4ERR_SEQ_MISORDERED:
  154. dprintk("%s ERROR %d, Reset session. Exchangeid "
  155. "flags 0x%x\n", __func__, task->tk_status,
  156. clp->cl_exchange_flags);
  157. nfs4_schedule_session_recovery(clp->cl_session, task->tk_status);
  158. break;
  159. case -NFS4ERR_DELAY:
  160. case -NFS4ERR_GRACE:
  161. rpc_delay(task, FILELAYOUT_POLL_RETRY_MAX);
  162. break;
  163. case -NFS4ERR_RETRY_UNCACHED_REP:
  164. break;
  165. /* Invalidate Layout errors */
  166. case -NFS4ERR_PNFS_NO_LAYOUT:
  167. case -ESTALE: /* mapped NFS4ERR_STALE */
  168. case -EBADHANDLE: /* mapped NFS4ERR_BADHANDLE */
  169. case -EISDIR: /* mapped NFS4ERR_ISDIR */
  170. case -NFS4ERR_FHEXPIRED:
  171. case -NFS4ERR_WRONG_TYPE:
  172. dprintk("%s Invalid layout error %d\n", __func__,
  173. task->tk_status);
  174. /*
  175. * Destroy layout so new i/o will get a new layout.
  176. * Layout will not be destroyed until all current lseg
  177. * references are put. Mark layout as invalid to resend failed
  178. * i/o and all i/o waiting on the slot table to the MDS until
  179. * layout is destroyed and a new valid layout is obtained.
  180. */
  181. pnfs_destroy_layout(NFS_I(inode));
  182. rpc_wake_up(&tbl->slot_tbl_waitq);
  183. goto reset;
  184. /* RPC connection errors */
  185. case -ECONNREFUSED:
  186. case -EHOSTDOWN:
  187. case -EHOSTUNREACH:
  188. case -ENETUNREACH:
  189. case -EIO:
  190. case -ETIMEDOUT:
  191. case -EPIPE:
  192. dprintk("%s DS connection error %d\n", __func__,
  193. task->tk_status);
  194. nfs4_mark_deviceid_unavailable(devid);
  195. set_bit(NFS_LAYOUT_RETURN, &lo->plh_flags);
  196. rpc_wake_up(&tbl->slot_tbl_waitq);
  197. /* fall through */
  198. default:
  199. reset:
  200. dprintk("%s Retry through MDS. Error %d\n", __func__,
  201. task->tk_status);
  202. return -NFS4ERR_RESET_TO_MDS;
  203. }
  204. out:
  205. task->tk_status = 0;
  206. return -EAGAIN;
  207. wait_on_recovery:
  208. rpc_sleep_on(&mds_client->cl_rpcwaitq, task, NULL);
  209. if (test_bit(NFS4CLNT_MANAGER_RUNNING, &mds_client->cl_state) == 0)
  210. rpc_wake_up_queued_task(&mds_client->cl_rpcwaitq, task);
  211. goto out;
  212. }
  213. /* NFS_PROTO call done callback routines */
  214. static int filelayout_read_done_cb(struct rpc_task *task,
  215. struct nfs_read_data *data)
  216. {
  217. struct nfs_pgio_header *hdr = data->header;
  218. int err;
  219. err = filelayout_async_handle_error(task, data->args.context->state,
  220. data->ds_clp, hdr->lseg);
  221. switch (err) {
  222. case -NFS4ERR_RESET_TO_MDS:
  223. filelayout_reset_read(data);
  224. return task->tk_status;
  225. case -EAGAIN:
  226. rpc_restart_call_prepare(task);
  227. return -EAGAIN;
  228. }
  229. return 0;
  230. }
  231. /*
  232. * We reference the rpc_cred of the first WRITE that triggers the need for
  233. * a LAYOUTCOMMIT, and use it to send the layoutcommit compound.
  234. * rfc5661 is not clear about which credential should be used.
  235. */
  236. static void
  237. filelayout_set_layoutcommit(struct nfs_write_data *wdata)
  238. {
  239. struct nfs_pgio_header *hdr = wdata->header;
  240. if (FILELAYOUT_LSEG(hdr->lseg)->commit_through_mds ||
  241. wdata->res.verf->committed == NFS_FILE_SYNC)
  242. return;
  243. pnfs_set_layoutcommit(wdata);
  244. dprintk("%s ionde %lu pls_end_pos %lu\n", __func__, hdr->inode->i_ino,
  245. (unsigned long) NFS_I(hdr->inode)->layout->plh_lwb);
  246. }
  247. bool
  248. filelayout_test_devid_unavailable(struct nfs4_deviceid_node *node)
  249. {
  250. return filelayout_test_devid_invalid(node) ||
  251. nfs4_test_deviceid_unavailable(node);
  252. }
  253. static bool
  254. filelayout_reset_to_mds(struct pnfs_layout_segment *lseg)
  255. {
  256. struct nfs4_deviceid_node *node = FILELAYOUT_DEVID_NODE(lseg);
  257. return filelayout_test_devid_unavailable(node);
  258. }
  259. /*
  260. * Call ops for the async read/write cases
  261. * In the case of dense layouts, the offset needs to be reset to its
  262. * original value.
  263. */
  264. static void filelayout_read_prepare(struct rpc_task *task, void *data)
  265. {
  266. struct nfs_read_data *rdata = data;
  267. if (filelayout_reset_to_mds(rdata->header->lseg)) {
  268. dprintk("%s task %u reset io to MDS\n", __func__, task->tk_pid);
  269. filelayout_reset_read(rdata);
  270. rpc_exit(task, 0);
  271. return;
  272. }
  273. rdata->read_done_cb = filelayout_read_done_cb;
  274. nfs41_setup_sequence(rdata->ds_clp->cl_session,
  275. &rdata->args.seq_args,
  276. &rdata->res.seq_res,
  277. task);
  278. }
  279. static void filelayout_read_call_done(struct rpc_task *task, void *data)
  280. {
  281. struct nfs_read_data *rdata = data;
  282. dprintk("--> %s task->tk_status %d\n", __func__, task->tk_status);
  283. if (test_bit(NFS_IOHDR_REDO, &rdata->header->flags) &&
  284. task->tk_status == 0)
  285. return;
  286. /* Note this may cause RPC to be resent */
  287. rdata->header->mds_ops->rpc_call_done(task, data);
  288. }
  289. static void filelayout_read_count_stats(struct rpc_task *task, void *data)
  290. {
  291. struct nfs_read_data *rdata = data;
  292. rpc_count_iostats(task, NFS_SERVER(rdata->header->inode)->client->cl_metrics);
  293. }
  294. static void filelayout_read_release(void *data)
  295. {
  296. struct nfs_read_data *rdata = data;
  297. struct pnfs_layout_hdr *lo = rdata->header->lseg->pls_layout;
  298. filelayout_fenceme(lo->plh_inode, lo);
  299. nfs_put_client(rdata->ds_clp);
  300. rdata->header->mds_ops->rpc_release(data);
  301. }
  302. static int filelayout_write_done_cb(struct rpc_task *task,
  303. struct nfs_write_data *data)
  304. {
  305. struct nfs_pgio_header *hdr = data->header;
  306. int err;
  307. err = filelayout_async_handle_error(task, data->args.context->state,
  308. data->ds_clp, hdr->lseg);
  309. switch (err) {
  310. case -NFS4ERR_RESET_TO_MDS:
  311. filelayout_reset_write(data);
  312. return task->tk_status;
  313. case -EAGAIN:
  314. rpc_restart_call_prepare(task);
  315. return -EAGAIN;
  316. }
  317. filelayout_set_layoutcommit(data);
  318. return 0;
  319. }
  320. /* Fake up some data that will cause nfs_commit_release to retry the writes. */
  321. static void prepare_to_resend_writes(struct nfs_commit_data *data)
  322. {
  323. struct nfs_page *first = nfs_list_entry(data->pages.next);
  324. data->task.tk_status = 0;
  325. memcpy(&data->verf.verifier, &first->wb_verf,
  326. sizeof(data->verf.verifier));
  327. data->verf.verifier.data[0]++; /* ensure verifier mismatch */
  328. }
  329. static int filelayout_commit_done_cb(struct rpc_task *task,
  330. struct nfs_commit_data *data)
  331. {
  332. int err;
  333. err = filelayout_async_handle_error(task, NULL, data->ds_clp,
  334. data->lseg);
  335. switch (err) {
  336. case -NFS4ERR_RESET_TO_MDS:
  337. prepare_to_resend_writes(data);
  338. return -EAGAIN;
  339. case -EAGAIN:
  340. rpc_restart_call_prepare(task);
  341. return -EAGAIN;
  342. }
  343. return 0;
  344. }
  345. static void filelayout_write_prepare(struct rpc_task *task, void *data)
  346. {
  347. struct nfs_write_data *wdata = data;
  348. if (filelayout_reset_to_mds(wdata->header->lseg)) {
  349. dprintk("%s task %u reset io to MDS\n", __func__, task->tk_pid);
  350. filelayout_reset_write(wdata);
  351. rpc_exit(task, 0);
  352. return;
  353. }
  354. nfs41_setup_sequence(wdata->ds_clp->cl_session,
  355. &wdata->args.seq_args,
  356. &wdata->res.seq_res,
  357. task);
  358. }
  359. static void filelayout_write_call_done(struct rpc_task *task, void *data)
  360. {
  361. struct nfs_write_data *wdata = data;
  362. if (test_bit(NFS_IOHDR_REDO, &wdata->header->flags) &&
  363. task->tk_status == 0)
  364. return;
  365. /* Note this may cause RPC to be resent */
  366. wdata->header->mds_ops->rpc_call_done(task, data);
  367. }
  368. static void filelayout_write_count_stats(struct rpc_task *task, void *data)
  369. {
  370. struct nfs_write_data *wdata = data;
  371. rpc_count_iostats(task, NFS_SERVER(wdata->header->inode)->client->cl_metrics);
  372. }
  373. static void filelayout_write_release(void *data)
  374. {
  375. struct nfs_write_data *wdata = data;
  376. struct pnfs_layout_hdr *lo = wdata->header->lseg->pls_layout;
  377. filelayout_fenceme(lo->plh_inode, lo);
  378. nfs_put_client(wdata->ds_clp);
  379. wdata->header->mds_ops->rpc_release(data);
  380. }
  381. static void filelayout_commit_prepare(struct rpc_task *task, void *data)
  382. {
  383. struct nfs_commit_data *wdata = data;
  384. nfs41_setup_sequence(wdata->ds_clp->cl_session,
  385. &wdata->args.seq_args,
  386. &wdata->res.seq_res,
  387. task);
  388. }
  389. static void filelayout_write_commit_done(struct rpc_task *task, void *data)
  390. {
  391. struct nfs_commit_data *wdata = data;
  392. /* Note this may cause RPC to be resent */
  393. wdata->mds_ops->rpc_call_done(task, data);
  394. }
  395. static void filelayout_commit_count_stats(struct rpc_task *task, void *data)
  396. {
  397. struct nfs_commit_data *cdata = data;
  398. rpc_count_iostats(task, NFS_SERVER(cdata->inode)->client->cl_metrics);
  399. }
  400. static void filelayout_commit_release(void *calldata)
  401. {
  402. struct nfs_commit_data *data = calldata;
  403. data->completion_ops->completion(data);
  404. pnfs_put_lseg(data->lseg);
  405. nfs_put_client(data->ds_clp);
  406. nfs_commitdata_release(data);
  407. }
  408. static const struct rpc_call_ops filelayout_read_call_ops = {
  409. .rpc_call_prepare = filelayout_read_prepare,
  410. .rpc_call_done = filelayout_read_call_done,
  411. .rpc_count_stats = filelayout_read_count_stats,
  412. .rpc_release = filelayout_read_release,
  413. };
  414. static const struct rpc_call_ops filelayout_write_call_ops = {
  415. .rpc_call_prepare = filelayout_write_prepare,
  416. .rpc_call_done = filelayout_write_call_done,
  417. .rpc_count_stats = filelayout_write_count_stats,
  418. .rpc_release = filelayout_write_release,
  419. };
  420. static const struct rpc_call_ops filelayout_commit_call_ops = {
  421. .rpc_call_prepare = filelayout_commit_prepare,
  422. .rpc_call_done = filelayout_write_commit_done,
  423. .rpc_count_stats = filelayout_commit_count_stats,
  424. .rpc_release = filelayout_commit_release,
  425. };
  426. static enum pnfs_try_status
  427. filelayout_read_pagelist(struct nfs_read_data *data)
  428. {
  429. struct nfs_pgio_header *hdr = data->header;
  430. struct pnfs_layout_segment *lseg = hdr->lseg;
  431. struct nfs4_pnfs_ds *ds;
  432. loff_t offset = data->args.offset;
  433. u32 j, idx;
  434. struct nfs_fh *fh;
  435. dprintk("--> %s ino %lu pgbase %u req %Zu@%llu\n",
  436. __func__, hdr->inode->i_ino,
  437. data->args.pgbase, (size_t)data->args.count, offset);
  438. /* Retrieve the correct rpc_client for the byte range */
  439. j = nfs4_fl_calc_j_index(lseg, offset);
  440. idx = nfs4_fl_calc_ds_index(lseg, j);
  441. ds = nfs4_fl_prepare_ds(lseg, idx);
  442. if (!ds)
  443. return PNFS_NOT_ATTEMPTED;
  444. dprintk("%s USE DS: %s cl_count %d\n", __func__,
  445. ds->ds_remotestr, atomic_read(&ds->ds_clp->cl_count));
  446. /* No multipath support. Use first DS */
  447. atomic_inc(&ds->ds_clp->cl_count);
  448. data->ds_clp = ds->ds_clp;
  449. fh = nfs4_fl_select_ds_fh(lseg, j);
  450. if (fh)
  451. data->args.fh = fh;
  452. data->args.offset = filelayout_get_dserver_offset(lseg, offset);
  453. data->mds_offset = offset;
  454. /* Perform an asynchronous read to ds */
  455. nfs_initiate_read(ds->ds_clp->cl_rpcclient, data,
  456. &filelayout_read_call_ops, RPC_TASK_SOFTCONN);
  457. return PNFS_ATTEMPTED;
  458. }
  459. /* Perform async writes. */
  460. static enum pnfs_try_status
  461. filelayout_write_pagelist(struct nfs_write_data *data, int sync)
  462. {
  463. struct nfs_pgio_header *hdr = data->header;
  464. struct pnfs_layout_segment *lseg = hdr->lseg;
  465. struct nfs4_pnfs_ds *ds;
  466. loff_t offset = data->args.offset;
  467. u32 j, idx;
  468. struct nfs_fh *fh;
  469. /* Retrieve the correct rpc_client for the byte range */
  470. j = nfs4_fl_calc_j_index(lseg, offset);
  471. idx = nfs4_fl_calc_ds_index(lseg, j);
  472. ds = nfs4_fl_prepare_ds(lseg, idx);
  473. if (!ds)
  474. return PNFS_NOT_ATTEMPTED;
  475. dprintk("%s ino %lu sync %d req %Zu@%llu DS: %s cl_count %d\n",
  476. __func__, hdr->inode->i_ino, sync, (size_t) data->args.count,
  477. offset, ds->ds_remotestr, atomic_read(&ds->ds_clp->cl_count));
  478. data->write_done_cb = filelayout_write_done_cb;
  479. atomic_inc(&ds->ds_clp->cl_count);
  480. data->ds_clp = ds->ds_clp;
  481. fh = nfs4_fl_select_ds_fh(lseg, j);
  482. if (fh)
  483. data->args.fh = fh;
  484. /*
  485. * Get the file offset on the dserver. Set the write offset to
  486. * this offset and save the original offset.
  487. */
  488. data->args.offset = filelayout_get_dserver_offset(lseg, offset);
  489. /* Perform an asynchronous write */
  490. nfs_initiate_write(ds->ds_clp->cl_rpcclient, data,
  491. &filelayout_write_call_ops, sync,
  492. RPC_TASK_SOFTCONN);
  493. return PNFS_ATTEMPTED;
  494. }
  495. /*
  496. * filelayout_check_layout()
  497. *
  498. * Make sure layout segment parameters are sane WRT the device.
  499. * At this point no generic layer initialization of the lseg has occurred,
  500. * and nothing has been added to the layout_hdr cache.
  501. *
  502. */
  503. static int
  504. filelayout_check_layout(struct pnfs_layout_hdr *lo,
  505. struct nfs4_filelayout_segment *fl,
  506. struct nfs4_layoutget_res *lgr,
  507. struct nfs4_deviceid *id,
  508. gfp_t gfp_flags)
  509. {
  510. struct nfs4_deviceid_node *d;
  511. struct nfs4_file_layout_dsaddr *dsaddr;
  512. int status = -EINVAL;
  513. struct nfs_server *nfss = NFS_SERVER(lo->plh_inode);
  514. dprintk("--> %s\n", __func__);
  515. /* FIXME: remove this check when layout segment support is added */
  516. if (lgr->range.offset != 0 ||
  517. lgr->range.length != NFS4_MAX_UINT64) {
  518. dprintk("%s Only whole file layouts supported. Use MDS i/o\n",
  519. __func__);
  520. goto out;
  521. }
  522. if (fl->pattern_offset > lgr->range.offset) {
  523. dprintk("%s pattern_offset %lld too large\n",
  524. __func__, fl->pattern_offset);
  525. goto out;
  526. }
  527. if (!fl->stripe_unit || fl->stripe_unit % PAGE_SIZE) {
  528. dprintk("%s Invalid stripe unit (%u)\n",
  529. __func__, fl->stripe_unit);
  530. goto out;
  531. }
  532. /* find and reference the deviceid */
  533. d = nfs4_find_get_deviceid(NFS_SERVER(lo->plh_inode)->pnfs_curr_ld,
  534. NFS_SERVER(lo->plh_inode)->nfs_client, id);
  535. if (d == NULL) {
  536. dsaddr = filelayout_get_device_info(lo->plh_inode, id, gfp_flags);
  537. if (dsaddr == NULL)
  538. goto out;
  539. } else
  540. dsaddr = container_of(d, struct nfs4_file_layout_dsaddr, id_node);
  541. /* Found deviceid is unavailable */
  542. if (filelayout_test_devid_unavailable(&dsaddr->id_node))
  543. goto out_put;
  544. fl->dsaddr = dsaddr;
  545. if (fl->first_stripe_index >= dsaddr->stripe_count) {
  546. dprintk("%s Bad first_stripe_index %u\n",
  547. __func__, fl->first_stripe_index);
  548. goto out_put;
  549. }
  550. if ((fl->stripe_type == STRIPE_SPARSE &&
  551. fl->num_fh > 1 && fl->num_fh != dsaddr->ds_num) ||
  552. (fl->stripe_type == STRIPE_DENSE &&
  553. fl->num_fh != dsaddr->stripe_count)) {
  554. dprintk("%s num_fh %u not valid for given packing\n",
  555. __func__, fl->num_fh);
  556. goto out_put;
  557. }
  558. if (fl->stripe_unit % nfss->rsize || fl->stripe_unit % nfss->wsize) {
  559. dprintk("%s Stripe unit (%u) not aligned with rsize %u "
  560. "wsize %u\n", __func__, fl->stripe_unit, nfss->rsize,
  561. nfss->wsize);
  562. }
  563. status = 0;
  564. out:
  565. dprintk("--> %s returns %d\n", __func__, status);
  566. return status;
  567. out_put:
  568. nfs4_fl_put_deviceid(dsaddr);
  569. goto out;
  570. }
  571. static void filelayout_free_fh_array(struct nfs4_filelayout_segment *fl)
  572. {
  573. int i;
  574. for (i = 0; i < fl->num_fh; i++) {
  575. if (!fl->fh_array[i])
  576. break;
  577. kfree(fl->fh_array[i]);
  578. }
  579. kfree(fl->fh_array);
  580. fl->fh_array = NULL;
  581. }
  582. static void
  583. _filelayout_free_lseg(struct nfs4_filelayout_segment *fl)
  584. {
  585. filelayout_free_fh_array(fl);
  586. kfree(fl);
  587. }
  588. static int
  589. filelayout_decode_layout(struct pnfs_layout_hdr *flo,
  590. struct nfs4_filelayout_segment *fl,
  591. struct nfs4_layoutget_res *lgr,
  592. struct nfs4_deviceid *id,
  593. gfp_t gfp_flags)
  594. {
  595. struct xdr_stream stream;
  596. struct xdr_buf buf;
  597. struct page *scratch;
  598. __be32 *p;
  599. uint32_t nfl_util;
  600. int i;
  601. dprintk("%s: set_layout_map Begin\n", __func__);
  602. scratch = alloc_page(gfp_flags);
  603. if (!scratch)
  604. return -ENOMEM;
  605. xdr_init_decode_pages(&stream, &buf, lgr->layoutp->pages, lgr->layoutp->len);
  606. xdr_set_scratch_buffer(&stream, page_address(scratch), PAGE_SIZE);
  607. /* 20 = ufl_util (4), first_stripe_index (4), pattern_offset (8),
  608. * num_fh (4) */
  609. p = xdr_inline_decode(&stream, NFS4_DEVICEID4_SIZE + 20);
  610. if (unlikely(!p))
  611. goto out_err;
  612. memcpy(id, p, sizeof(*id));
  613. p += XDR_QUADLEN(NFS4_DEVICEID4_SIZE);
  614. nfs4_print_deviceid(id);
  615. nfl_util = be32_to_cpup(p++);
  616. if (nfl_util & NFL4_UFLG_COMMIT_THRU_MDS)
  617. fl->commit_through_mds = 1;
  618. if (nfl_util & NFL4_UFLG_DENSE)
  619. fl->stripe_type = STRIPE_DENSE;
  620. else
  621. fl->stripe_type = STRIPE_SPARSE;
  622. fl->stripe_unit = nfl_util & ~NFL4_UFLG_MASK;
  623. fl->first_stripe_index = be32_to_cpup(p++);
  624. p = xdr_decode_hyper(p, &fl->pattern_offset);
  625. fl->num_fh = be32_to_cpup(p++);
  626. dprintk("%s: nfl_util 0x%X num_fh %u fsi %u po %llu\n",
  627. __func__, nfl_util, fl->num_fh, fl->first_stripe_index,
  628. fl->pattern_offset);
  629. /* Note that a zero value for num_fh is legal for STRIPE_SPARSE.
  630. * Futher checking is done in filelayout_check_layout */
  631. if (fl->num_fh >
  632. max(NFS4_PNFS_MAX_STRIPE_CNT, NFS4_PNFS_MAX_MULTI_CNT))
  633. goto out_err;
  634. if (fl->num_fh > 0) {
  635. fl->fh_array = kcalloc(fl->num_fh, sizeof(fl->fh_array[0]),
  636. gfp_flags);
  637. if (!fl->fh_array)
  638. goto out_err;
  639. }
  640. for (i = 0; i < fl->num_fh; i++) {
  641. /* Do we want to use a mempool here? */
  642. fl->fh_array[i] = kmalloc(sizeof(struct nfs_fh), gfp_flags);
  643. if (!fl->fh_array[i])
  644. goto out_err_free;
  645. p = xdr_inline_decode(&stream, 4);
  646. if (unlikely(!p))
  647. goto out_err_free;
  648. fl->fh_array[i]->size = be32_to_cpup(p++);
  649. if (sizeof(struct nfs_fh) < fl->fh_array[i]->size) {
  650. printk(KERN_ERR "NFS: Too big fh %d received %d\n",
  651. i, fl->fh_array[i]->size);
  652. goto out_err_free;
  653. }
  654. p = xdr_inline_decode(&stream, fl->fh_array[i]->size);
  655. if (unlikely(!p))
  656. goto out_err_free;
  657. memcpy(fl->fh_array[i]->data, p, fl->fh_array[i]->size);
  658. dprintk("DEBUG: %s: fh len %d\n", __func__,
  659. fl->fh_array[i]->size);
  660. }
  661. __free_page(scratch);
  662. return 0;
  663. out_err_free:
  664. filelayout_free_fh_array(fl);
  665. out_err:
  666. __free_page(scratch);
  667. return -EIO;
  668. }
  669. static void
  670. filelayout_free_lseg(struct pnfs_layout_segment *lseg)
  671. {
  672. struct nfs4_filelayout_segment *fl = FILELAYOUT_LSEG(lseg);
  673. dprintk("--> %s\n", __func__);
  674. nfs4_fl_put_deviceid(fl->dsaddr);
  675. /* This assumes a single RW lseg */
  676. if (lseg->pls_range.iomode == IOMODE_RW) {
  677. struct nfs4_filelayout *flo;
  678. flo = FILELAYOUT_FROM_HDR(lseg->pls_layout);
  679. flo->commit_info.nbuckets = 0;
  680. kfree(flo->commit_info.buckets);
  681. flo->commit_info.buckets = NULL;
  682. }
  683. _filelayout_free_lseg(fl);
  684. }
  685. static int
  686. filelayout_alloc_commit_info(struct pnfs_layout_segment *lseg,
  687. struct nfs_commit_info *cinfo,
  688. gfp_t gfp_flags)
  689. {
  690. struct nfs4_filelayout_segment *fl = FILELAYOUT_LSEG(lseg);
  691. struct pnfs_commit_bucket *buckets;
  692. int size;
  693. if (fl->commit_through_mds)
  694. return 0;
  695. if (cinfo->ds->nbuckets != 0) {
  696. /* This assumes there is only one IOMODE_RW lseg. What
  697. * we really want to do is have a layout_hdr level
  698. * dictionary of <multipath_list4, fh> keys, each
  699. * associated with a struct list_head, populated by calls
  700. * to filelayout_write_pagelist().
  701. * */
  702. return 0;
  703. }
  704. size = (fl->stripe_type == STRIPE_SPARSE) ?
  705. fl->dsaddr->ds_num : fl->dsaddr->stripe_count;
  706. buckets = kcalloc(size, sizeof(struct pnfs_commit_bucket),
  707. gfp_flags);
  708. if (!buckets)
  709. return -ENOMEM;
  710. else {
  711. int i;
  712. spin_lock(cinfo->lock);
  713. if (cinfo->ds->nbuckets != 0)
  714. kfree(buckets);
  715. else {
  716. cinfo->ds->buckets = buckets;
  717. cinfo->ds->nbuckets = size;
  718. for (i = 0; i < size; i++) {
  719. INIT_LIST_HEAD(&buckets[i].written);
  720. INIT_LIST_HEAD(&buckets[i].committing);
  721. }
  722. }
  723. spin_unlock(cinfo->lock);
  724. return 0;
  725. }
  726. }
  727. static struct pnfs_layout_segment *
  728. filelayout_alloc_lseg(struct pnfs_layout_hdr *layoutid,
  729. struct nfs4_layoutget_res *lgr,
  730. gfp_t gfp_flags)
  731. {
  732. struct nfs4_filelayout_segment *fl;
  733. int rc;
  734. struct nfs4_deviceid id;
  735. dprintk("--> %s\n", __func__);
  736. fl = kzalloc(sizeof(*fl), gfp_flags);
  737. if (!fl)
  738. return NULL;
  739. rc = filelayout_decode_layout(layoutid, fl, lgr, &id, gfp_flags);
  740. if (rc != 0 || filelayout_check_layout(layoutid, fl, lgr, &id, gfp_flags)) {
  741. _filelayout_free_lseg(fl);
  742. return NULL;
  743. }
  744. return &fl->generic_hdr;
  745. }
  746. /*
  747. * filelayout_pg_test(). Called by nfs_can_coalesce_requests()
  748. *
  749. * return true : coalesce page
  750. * return false : don't coalesce page
  751. */
  752. static bool
  753. filelayout_pg_test(struct nfs_pageio_descriptor *pgio, struct nfs_page *prev,
  754. struct nfs_page *req)
  755. {
  756. u64 p_stripe, r_stripe;
  757. u32 stripe_unit;
  758. if (!pnfs_generic_pg_test(pgio, prev, req) ||
  759. !nfs_generic_pg_test(pgio, prev, req))
  760. return false;
  761. p_stripe = (u64)req_offset(prev);
  762. r_stripe = (u64)req_offset(req);
  763. stripe_unit = FILELAYOUT_LSEG(pgio->pg_lseg)->stripe_unit;
  764. do_div(p_stripe, stripe_unit);
  765. do_div(r_stripe, stripe_unit);
  766. return (p_stripe == r_stripe);
  767. }
  768. static void
  769. filelayout_pg_init_read(struct nfs_pageio_descriptor *pgio,
  770. struct nfs_page *req)
  771. {
  772. WARN_ON_ONCE(pgio->pg_lseg != NULL);
  773. if (req->wb_offset != req->wb_pgbase) {
  774. /*
  775. * Handling unaligned pages is difficult, because have to
  776. * somehow split a req in two in certain cases in the
  777. * pg.test code. Avoid this by just not using pnfs
  778. * in this case.
  779. */
  780. nfs_pageio_reset_read_mds(pgio);
  781. return;
  782. }
  783. pgio->pg_lseg = pnfs_update_layout(pgio->pg_inode,
  784. req->wb_context,
  785. 0,
  786. NFS4_MAX_UINT64,
  787. IOMODE_READ,
  788. GFP_KERNEL);
  789. /* If no lseg, fall back to read through mds */
  790. if (pgio->pg_lseg == NULL)
  791. nfs_pageio_reset_read_mds(pgio);
  792. }
  793. static void
  794. filelayout_pg_init_write(struct nfs_pageio_descriptor *pgio,
  795. struct nfs_page *req)
  796. {
  797. struct nfs_commit_info cinfo;
  798. int status;
  799. WARN_ON_ONCE(pgio->pg_lseg != NULL);
  800. if (req->wb_offset != req->wb_pgbase)
  801. goto out_mds;
  802. pgio->pg_lseg = pnfs_update_layout(pgio->pg_inode,
  803. req->wb_context,
  804. 0,
  805. NFS4_MAX_UINT64,
  806. IOMODE_RW,
  807. GFP_NOFS);
  808. /* If no lseg, fall back to write through mds */
  809. if (pgio->pg_lseg == NULL)
  810. goto out_mds;
  811. nfs_init_cinfo(&cinfo, pgio->pg_inode, pgio->pg_dreq);
  812. status = filelayout_alloc_commit_info(pgio->pg_lseg, &cinfo, GFP_NOFS);
  813. if (status < 0) {
  814. pnfs_put_lseg(pgio->pg_lseg);
  815. pgio->pg_lseg = NULL;
  816. goto out_mds;
  817. }
  818. return;
  819. out_mds:
  820. nfs_pageio_reset_write_mds(pgio);
  821. }
  822. static const struct nfs_pageio_ops filelayout_pg_read_ops = {
  823. .pg_init = filelayout_pg_init_read,
  824. .pg_test = filelayout_pg_test,
  825. .pg_doio = pnfs_generic_pg_readpages,
  826. };
  827. static const struct nfs_pageio_ops filelayout_pg_write_ops = {
  828. .pg_init = filelayout_pg_init_write,
  829. .pg_test = filelayout_pg_test,
  830. .pg_doio = pnfs_generic_pg_writepages,
  831. };
  832. static u32 select_bucket_index(struct nfs4_filelayout_segment *fl, u32 j)
  833. {
  834. if (fl->stripe_type == STRIPE_SPARSE)
  835. return nfs4_fl_calc_ds_index(&fl->generic_hdr, j);
  836. else
  837. return j;
  838. }
  839. /* The generic layer is about to remove the req from the commit list.
  840. * If this will make the bucket empty, it will need to put the lseg reference.
  841. */
  842. static void
  843. filelayout_clear_request_commit(struct nfs_page *req,
  844. struct nfs_commit_info *cinfo)
  845. {
  846. struct pnfs_layout_segment *freeme = NULL;
  847. spin_lock(cinfo->lock);
  848. if (!test_and_clear_bit(PG_COMMIT_TO_DS, &req->wb_flags))
  849. goto out;
  850. cinfo->ds->nwritten--;
  851. if (list_is_singular(&req->wb_list)) {
  852. struct pnfs_commit_bucket *bucket;
  853. bucket = list_first_entry(&req->wb_list,
  854. struct pnfs_commit_bucket,
  855. written);
  856. freeme = bucket->wlseg;
  857. bucket->wlseg = NULL;
  858. }
  859. out:
  860. nfs_request_remove_commit_list(req, cinfo);
  861. spin_unlock(cinfo->lock);
  862. pnfs_put_lseg(freeme);
  863. }
  864. static struct list_head *
  865. filelayout_choose_commit_list(struct nfs_page *req,
  866. struct pnfs_layout_segment *lseg,
  867. struct nfs_commit_info *cinfo)
  868. {
  869. struct nfs4_filelayout_segment *fl = FILELAYOUT_LSEG(lseg);
  870. u32 i, j;
  871. struct list_head *list;
  872. struct pnfs_commit_bucket *buckets;
  873. if (fl->commit_through_mds)
  874. return &cinfo->mds->list;
  875. /* Note that we are calling nfs4_fl_calc_j_index on each page
  876. * that ends up being committed to a data server. An attractive
  877. * alternative is to add a field to nfs_write_data and nfs_page
  878. * to store the value calculated in filelayout_write_pagelist
  879. * and just use that here.
  880. */
  881. j = nfs4_fl_calc_j_index(lseg, req_offset(req));
  882. i = select_bucket_index(fl, j);
  883. buckets = cinfo->ds->buckets;
  884. list = &buckets[i].written;
  885. if (list_empty(list)) {
  886. /* Non-empty buckets hold a reference on the lseg. That ref
  887. * is normally transferred to the COMMIT call and released
  888. * there. It could also be released if the last req is pulled
  889. * off due to a rewrite, in which case it will be done in
  890. * filelayout_clear_request_commit
  891. */
  892. buckets[i].wlseg = pnfs_get_lseg(lseg);
  893. }
  894. set_bit(PG_COMMIT_TO_DS, &req->wb_flags);
  895. cinfo->ds->nwritten++;
  896. return list;
  897. }
  898. static void
  899. filelayout_mark_request_commit(struct nfs_page *req,
  900. struct pnfs_layout_segment *lseg,
  901. struct nfs_commit_info *cinfo)
  902. {
  903. struct list_head *list;
  904. list = filelayout_choose_commit_list(req, lseg, cinfo);
  905. nfs_request_add_commit_list(req, list, cinfo);
  906. }
  907. static u32 calc_ds_index_from_commit(struct pnfs_layout_segment *lseg, u32 i)
  908. {
  909. struct nfs4_filelayout_segment *flseg = FILELAYOUT_LSEG(lseg);
  910. if (flseg->stripe_type == STRIPE_SPARSE)
  911. return i;
  912. else
  913. return nfs4_fl_calc_ds_index(lseg, i);
  914. }
  915. static struct nfs_fh *
  916. select_ds_fh_from_commit(struct pnfs_layout_segment *lseg, u32 i)
  917. {
  918. struct nfs4_filelayout_segment *flseg = FILELAYOUT_LSEG(lseg);
  919. if (flseg->stripe_type == STRIPE_SPARSE) {
  920. if (flseg->num_fh == 1)
  921. i = 0;
  922. else if (flseg->num_fh == 0)
  923. /* Use the MDS OPEN fh set in nfs_read_rpcsetup */
  924. return NULL;
  925. }
  926. return flseg->fh_array[i];
  927. }
  928. static int filelayout_initiate_commit(struct nfs_commit_data *data, int how)
  929. {
  930. struct pnfs_layout_segment *lseg = data->lseg;
  931. struct nfs4_pnfs_ds *ds;
  932. u32 idx;
  933. struct nfs_fh *fh;
  934. idx = calc_ds_index_from_commit(lseg, data->ds_commit_index);
  935. ds = nfs4_fl_prepare_ds(lseg, idx);
  936. if (!ds) {
  937. prepare_to_resend_writes(data);
  938. filelayout_commit_release(data);
  939. return -EAGAIN;
  940. }
  941. dprintk("%s ino %lu, how %d cl_count %d\n", __func__,
  942. data->inode->i_ino, how, atomic_read(&ds->ds_clp->cl_count));
  943. data->commit_done_cb = filelayout_commit_done_cb;
  944. atomic_inc(&ds->ds_clp->cl_count);
  945. data->ds_clp = ds->ds_clp;
  946. fh = select_ds_fh_from_commit(lseg, data->ds_commit_index);
  947. if (fh)
  948. data->args.fh = fh;
  949. return nfs_initiate_commit(ds->ds_clp->cl_rpcclient, data,
  950. &filelayout_commit_call_ops, how,
  951. RPC_TASK_SOFTCONN);
  952. }
  953. static int
  954. transfer_commit_list(struct list_head *src, struct list_head *dst,
  955. struct nfs_commit_info *cinfo, int max)
  956. {
  957. struct nfs_page *req, *tmp;
  958. int ret = 0;
  959. list_for_each_entry_safe(req, tmp, src, wb_list) {
  960. if (!nfs_lock_request(req))
  961. continue;
  962. kref_get(&req->wb_kref);
  963. if (cond_resched_lock(cinfo->lock))
  964. list_safe_reset_next(req, tmp, wb_list);
  965. nfs_request_remove_commit_list(req, cinfo);
  966. clear_bit(PG_COMMIT_TO_DS, &req->wb_flags);
  967. nfs_list_add_request(req, dst);
  968. ret++;
  969. if ((ret == max) && !cinfo->dreq)
  970. break;
  971. }
  972. return ret;
  973. }
  974. static int
  975. filelayout_scan_ds_commit_list(struct pnfs_commit_bucket *bucket,
  976. struct nfs_commit_info *cinfo,
  977. int max)
  978. {
  979. struct list_head *src = &bucket->written;
  980. struct list_head *dst = &bucket->committing;
  981. int ret;
  982. ret = transfer_commit_list(src, dst, cinfo, max);
  983. if (ret) {
  984. cinfo->ds->nwritten -= ret;
  985. cinfo->ds->ncommitting += ret;
  986. bucket->clseg = bucket->wlseg;
  987. if (list_empty(src))
  988. bucket->wlseg = NULL;
  989. else
  990. pnfs_get_lseg(bucket->clseg);
  991. }
  992. return ret;
  993. }
  994. /* Move reqs from written to committing lists, returning count of number moved.
  995. * Note called with cinfo->lock held.
  996. */
  997. static int filelayout_scan_commit_lists(struct nfs_commit_info *cinfo,
  998. int max)
  999. {
  1000. int i, rv = 0, cnt;
  1001. for (i = 0; i < cinfo->ds->nbuckets && max != 0; i++) {
  1002. cnt = filelayout_scan_ds_commit_list(&cinfo->ds->buckets[i],
  1003. cinfo, max);
  1004. max -= cnt;
  1005. rv += cnt;
  1006. }
  1007. return rv;
  1008. }
  1009. /* Pull everything off the committing lists and dump into @dst */
  1010. static void filelayout_recover_commit_reqs(struct list_head *dst,
  1011. struct nfs_commit_info *cinfo)
  1012. {
  1013. struct pnfs_commit_bucket *b;
  1014. int i;
  1015. /* NOTE cinfo->lock is NOT held, relying on fact that this is
  1016. * only called on single thread per dreq.
  1017. * Can't take the lock because need to do pnfs_put_lseg
  1018. */
  1019. for (i = 0, b = cinfo->ds->buckets; i < cinfo->ds->nbuckets; i++, b++) {
  1020. if (transfer_commit_list(&b->written, dst, cinfo, 0)) {
  1021. pnfs_put_lseg(b->wlseg);
  1022. b->wlseg = NULL;
  1023. }
  1024. }
  1025. cinfo->ds->nwritten = 0;
  1026. }
  1027. static unsigned int
  1028. alloc_ds_commits(struct nfs_commit_info *cinfo, struct list_head *list)
  1029. {
  1030. struct pnfs_ds_commit_info *fl_cinfo;
  1031. struct pnfs_commit_bucket *bucket;
  1032. struct nfs_commit_data *data;
  1033. int i, j;
  1034. unsigned int nreq = 0;
  1035. fl_cinfo = cinfo->ds;
  1036. bucket = fl_cinfo->buckets;
  1037. for (i = 0; i < fl_cinfo->nbuckets; i++, bucket++) {
  1038. if (list_empty(&bucket->committing))
  1039. continue;
  1040. data = nfs_commitdata_alloc();
  1041. if (!data)
  1042. break;
  1043. data->ds_commit_index = i;
  1044. data->lseg = bucket->clseg;
  1045. bucket->clseg = NULL;
  1046. list_add(&data->pages, list);
  1047. nreq++;
  1048. }
  1049. /* Clean up on error */
  1050. for (j = i; j < fl_cinfo->nbuckets; j++, bucket++) {
  1051. if (list_empty(&bucket->committing))
  1052. continue;
  1053. nfs_retry_commit(&bucket->committing, bucket->clseg, cinfo);
  1054. pnfs_put_lseg(bucket->clseg);
  1055. bucket->clseg = NULL;
  1056. }
  1057. /* Caller will clean up entries put on list */
  1058. return nreq;
  1059. }
  1060. /* This follows nfs_commit_list pretty closely */
  1061. static int
  1062. filelayout_commit_pagelist(struct inode *inode, struct list_head *mds_pages,
  1063. int how, struct nfs_commit_info *cinfo)
  1064. {
  1065. struct nfs_commit_data *data, *tmp;
  1066. LIST_HEAD(list);
  1067. unsigned int nreq = 0;
  1068. if (!list_empty(mds_pages)) {
  1069. data = nfs_commitdata_alloc();
  1070. if (data != NULL) {
  1071. data->lseg = NULL;
  1072. list_add(&data->pages, &list);
  1073. nreq++;
  1074. } else
  1075. nfs_retry_commit(mds_pages, NULL, cinfo);
  1076. }
  1077. nreq += alloc_ds_commits(cinfo, &list);
  1078. if (nreq == 0) {
  1079. cinfo->completion_ops->error_cleanup(NFS_I(inode));
  1080. goto out;
  1081. }
  1082. atomic_add(nreq, &cinfo->mds->rpcs_out);
  1083. list_for_each_entry_safe(data, tmp, &list, pages) {
  1084. list_del_init(&data->pages);
  1085. if (!data->lseg) {
  1086. nfs_init_commit(data, mds_pages, NULL, cinfo);
  1087. nfs_initiate_commit(NFS_CLIENT(inode), data,
  1088. data->mds_ops, how, 0);
  1089. } else {
  1090. struct pnfs_commit_bucket *buckets;
  1091. buckets = cinfo->ds->buckets;
  1092. nfs_init_commit(data, &buckets[data->ds_commit_index].committing, data->lseg, cinfo);
  1093. filelayout_initiate_commit(data, how);
  1094. }
  1095. }
  1096. out:
  1097. cinfo->ds->ncommitting = 0;
  1098. return PNFS_ATTEMPTED;
  1099. }
  1100. static void
  1101. filelayout_free_deveiceid_node(struct nfs4_deviceid_node *d)
  1102. {
  1103. nfs4_fl_free_deviceid(container_of(d, struct nfs4_file_layout_dsaddr, id_node));
  1104. }
  1105. static struct pnfs_layout_hdr *
  1106. filelayout_alloc_layout_hdr(struct inode *inode, gfp_t gfp_flags)
  1107. {
  1108. struct nfs4_filelayout *flo;
  1109. flo = kzalloc(sizeof(*flo), gfp_flags);
  1110. return &flo->generic_hdr;
  1111. }
  1112. static void
  1113. filelayout_free_layout_hdr(struct pnfs_layout_hdr *lo)
  1114. {
  1115. kfree(FILELAYOUT_FROM_HDR(lo));
  1116. }
  1117. static struct pnfs_ds_commit_info *
  1118. filelayout_get_ds_info(struct inode *inode)
  1119. {
  1120. struct pnfs_layout_hdr *layout = NFS_I(inode)->layout;
  1121. if (layout == NULL)
  1122. return NULL;
  1123. else
  1124. return &FILELAYOUT_FROM_HDR(layout)->commit_info;
  1125. }
  1126. static struct pnfs_layoutdriver_type filelayout_type = {
  1127. .id = LAYOUT_NFSV4_1_FILES,
  1128. .name = "LAYOUT_NFSV4_1_FILES",
  1129. .owner = THIS_MODULE,
  1130. .alloc_layout_hdr = filelayout_alloc_layout_hdr,
  1131. .free_layout_hdr = filelayout_free_layout_hdr,
  1132. .alloc_lseg = filelayout_alloc_lseg,
  1133. .free_lseg = filelayout_free_lseg,
  1134. .pg_read_ops = &filelayout_pg_read_ops,
  1135. .pg_write_ops = &filelayout_pg_write_ops,
  1136. .get_ds_info = &filelayout_get_ds_info,
  1137. .mark_request_commit = filelayout_mark_request_commit,
  1138. .clear_request_commit = filelayout_clear_request_commit,
  1139. .scan_commit_lists = filelayout_scan_commit_lists,
  1140. .recover_commit_reqs = filelayout_recover_commit_reqs,
  1141. .commit_pagelist = filelayout_commit_pagelist,
  1142. .read_pagelist = filelayout_read_pagelist,
  1143. .write_pagelist = filelayout_write_pagelist,
  1144. .free_deviceid_node = filelayout_free_deveiceid_node,
  1145. };
  1146. static int __init nfs4filelayout_init(void)
  1147. {
  1148. printk(KERN_INFO "%s: NFSv4 File Layout Driver Registering...\n",
  1149. __func__);
  1150. return pnfs_register_layoutdriver(&filelayout_type);
  1151. }
  1152. static void __exit nfs4filelayout_exit(void)
  1153. {
  1154. printk(KERN_INFO "%s: NFSv4 File Layout Driver Unregistering...\n",
  1155. __func__);
  1156. pnfs_unregister_layoutdriver(&filelayout_type);
  1157. }
  1158. MODULE_ALIAS("nfs-layouttype4-1");
  1159. module_init(nfs4filelayout_init);
  1160. module_exit(nfs4filelayout_exit);