pnfs.h 28 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932
  1. /*
  2. * pNFS client data structures.
  3. *
  4. * Copyright (c) 2002
  5. * The Regents of the University of Michigan
  6. * All Rights Reserved
  7. *
  8. * Dean Hildebrand <[email protected]>
  9. *
  10. * Permission is granted to use, copy, create derivative works, and
  11. * redistribute this software and such derivative works for any purpose,
  12. * so long as the name of the University of Michigan is not used in
  13. * any advertising or publicity pertaining to the use or distribution
  14. * of this software without specific, written prior authorization. If
  15. * the above copyright notice or any other identification of the
  16. * University of Michigan is included in any copy of any portion of
  17. * this software, then the disclaimer below must also be included.
  18. *
  19. * This software is provided as is, without representation or warranty
  20. * of any kind either express or implied, including without limitation
  21. * the implied warranties of merchantability, fitness for a particular
  22. * purpose, or noninfringement. The Regents of the University of
  23. * Michigan shall not be liable for any damages, including special,
  24. * indirect, incidental, or consequential damages, with respect to any
  25. * claim arising out of or in connection with the use of the software,
  26. * even if it has been or is hereafter advised of the possibility of
  27. * such damages.
  28. */
  29. #ifndef FS_NFS_PNFS_H
  30. #define FS_NFS_PNFS_H
  31. #include <linux/refcount.h>
  32. #include <linux/nfs_fs.h>
  33. #include <linux/nfs_page.h>
  34. #include <linux/workqueue.h>
  35. struct nfs4_opendata;
  36. enum {
  37. NFS_LSEG_VALID = 0, /* cleared when lseg is recalled/returned */
  38. NFS_LSEG_ROC, /* roc bit received from server */
  39. NFS_LSEG_LAYOUTCOMMIT, /* layoutcommit bit set for layoutcommit */
  40. NFS_LSEG_LAYOUTRETURN, /* layoutreturn bit set for layoutreturn */
  41. NFS_LSEG_UNAVAILABLE, /* unavailable bit set for temporary problem */
  42. };
  43. /* Individual ip address */
  44. struct nfs4_pnfs_ds_addr {
  45. struct sockaddr_storage da_addr;
  46. size_t da_addrlen;
  47. struct list_head da_node; /* nfs4_pnfs_dev_hlist dev_dslist */
  48. char *da_remotestr; /* human readable addr+port */
  49. const char *da_netid;
  50. int da_transport;
  51. };
  52. struct nfs4_pnfs_ds {
  53. struct list_head ds_node; /* nfs4_pnfs_dev_hlist dev_dslist */
  54. char *ds_remotestr; /* comma sep list of addrs */
  55. struct list_head ds_addrs;
  56. struct nfs_client *ds_clp;
  57. refcount_t ds_count;
  58. unsigned long ds_state;
  59. #define NFS4DS_CONNECTING 0 /* ds is establishing connection */
  60. };
  61. struct pnfs_layout_segment {
  62. struct list_head pls_list;
  63. struct list_head pls_lc_list;
  64. struct list_head pls_commits;
  65. struct pnfs_layout_range pls_range;
  66. refcount_t pls_refcount;
  67. u32 pls_seq;
  68. unsigned long pls_flags;
  69. struct pnfs_layout_hdr *pls_layout;
  70. };
  71. enum pnfs_try_status {
  72. PNFS_ATTEMPTED = 0,
  73. PNFS_NOT_ATTEMPTED = 1,
  74. PNFS_TRY_AGAIN = 2,
  75. };
  76. #ifdef CONFIG_NFS_V4_1
  77. #define LAYOUT_NFSV4_1_MODULE_PREFIX "nfs-layouttype4"
  78. /*
  79. * Default data server connection timeout and retrans vaules.
  80. * Set by module parameters dataserver_timeo and dataserver_retrans.
  81. */
  82. #define NFS4_DEF_DS_TIMEO 600 /* in tenths of a second */
  83. #define NFS4_DEF_DS_RETRANS 5
  84. #define PNFS_DEVICE_RETRY_TIMEOUT (120*HZ)
  85. enum {
  86. NFS_LAYOUT_RO_FAILED = 0, /* get ro layout failed stop trying */
  87. NFS_LAYOUT_RW_FAILED, /* get rw layout failed stop trying */
  88. NFS_LAYOUT_BULK_RECALL, /* bulk recall affecting layout */
  89. NFS_LAYOUT_RETURN, /* layoutreturn in progress */
  90. NFS_LAYOUT_RETURN_LOCK, /* Serialise layoutreturn */
  91. NFS_LAYOUT_RETURN_REQUESTED, /* Return this layout ASAP */
  92. NFS_LAYOUT_INVALID_STID, /* layout stateid id is invalid */
  93. NFS_LAYOUT_FIRST_LAYOUTGET, /* Serialize first layoutget */
  94. NFS_LAYOUT_INODE_FREEING, /* The inode is being freed */
  95. NFS_LAYOUT_HASHED, /* The layout visible */
  96. NFS_LAYOUT_DRAIN,
  97. };
  98. enum layoutdriver_policy_flags {
  99. /* Should the pNFS client commit and return the layout upon truncate to
  100. * a smaller size */
  101. PNFS_LAYOUTRET_ON_SETATTR = 1 << 0,
  102. PNFS_LAYOUTRET_ON_ERROR = 1 << 1,
  103. PNFS_READ_WHOLE_PAGE = 1 << 2,
  104. PNFS_LAYOUTGET_ON_OPEN = 1 << 3,
  105. };
  106. struct nfs4_deviceid_node;
  107. /* Per-layout driver specific registration structure */
  108. struct pnfs_layoutdriver_type {
  109. struct list_head pnfs_tblid;
  110. const u32 id;
  111. const char *name;
  112. struct module *owner;
  113. unsigned flags;
  114. unsigned max_deviceinfo_size;
  115. unsigned max_layoutget_response;
  116. int (*set_layoutdriver) (struct nfs_server *, const struct nfs_fh *);
  117. int (*clear_layoutdriver) (struct nfs_server *);
  118. struct pnfs_layout_hdr * (*alloc_layout_hdr) (struct inode *inode, gfp_t gfp_flags);
  119. void (*free_layout_hdr) (struct pnfs_layout_hdr *);
  120. struct pnfs_layout_segment * (*alloc_lseg) (struct pnfs_layout_hdr *layoutid, struct nfs4_layoutget_res *lgr, gfp_t gfp_flags);
  121. void (*free_lseg) (struct pnfs_layout_segment *lseg);
  122. void (*add_lseg) (struct pnfs_layout_hdr *layoutid,
  123. struct pnfs_layout_segment *lseg,
  124. struct list_head *free_me);
  125. void (*return_range) (struct pnfs_layout_hdr *lo,
  126. struct pnfs_layout_range *range);
  127. /* test for nfs page cache coalescing */
  128. const struct nfs_pageio_ops *pg_read_ops;
  129. const struct nfs_pageio_ops *pg_write_ops;
  130. struct pnfs_ds_commit_info *(*get_ds_info) (struct inode *inode);
  131. int (*sync)(struct inode *inode, bool datasync);
  132. /*
  133. * Return PNFS_ATTEMPTED to indicate the layout code has attempted
  134. * I/O, else return PNFS_NOT_ATTEMPTED to fall back to normal NFS
  135. */
  136. enum pnfs_try_status (*read_pagelist)(struct nfs_pgio_header *);
  137. enum pnfs_try_status (*write_pagelist)(struct nfs_pgio_header *, int);
  138. void (*free_deviceid_node) (struct nfs4_deviceid_node *);
  139. struct nfs4_deviceid_node * (*alloc_deviceid_node)
  140. (struct nfs_server *server, struct pnfs_device *pdev,
  141. gfp_t gfp_flags);
  142. int (*prepare_layoutreturn) (struct nfs4_layoutreturn_args *);
  143. void (*cleanup_layoutcommit) (struct nfs4_layoutcommit_data *data);
  144. int (*prepare_layoutcommit) (struct nfs4_layoutcommit_args *args);
  145. int (*prepare_layoutstats) (struct nfs42_layoutstat_args *args);
  146. void (*cancel_io)(struct pnfs_layout_segment *lseg);
  147. };
  148. struct pnfs_commit_ops {
  149. void (*setup_ds_info)(struct pnfs_ds_commit_info *,
  150. struct pnfs_layout_segment *);
  151. void (*release_ds_info)(struct pnfs_ds_commit_info *,
  152. struct inode *inode);
  153. int (*commit_pagelist)(struct inode *inode,
  154. struct list_head *mds_pages,
  155. int how,
  156. struct nfs_commit_info *cinfo);
  157. void (*mark_request_commit) (struct nfs_page *req,
  158. struct pnfs_layout_segment *lseg,
  159. struct nfs_commit_info *cinfo,
  160. u32 ds_commit_idx);
  161. void (*clear_request_commit) (struct nfs_page *req,
  162. struct nfs_commit_info *cinfo);
  163. int (*scan_commit_lists) (struct nfs_commit_info *cinfo,
  164. int max);
  165. void (*recover_commit_reqs) (struct list_head *list,
  166. struct nfs_commit_info *cinfo);
  167. struct nfs_page * (*search_commit_reqs)(struct nfs_commit_info *cinfo,
  168. struct page *page);
  169. };
  170. struct pnfs_layout_hdr {
  171. refcount_t plh_refcount;
  172. atomic_t plh_outstanding; /* number of RPCs out */
  173. struct list_head plh_layouts; /* other client layouts */
  174. struct list_head plh_bulk_destroy;
  175. struct list_head plh_segs; /* layout segments list */
  176. struct list_head plh_return_segs; /* invalid layout segments */
  177. unsigned long plh_block_lgets; /* block LAYOUTGET if >0 */
  178. unsigned long plh_retry_timestamp;
  179. unsigned long plh_flags;
  180. nfs4_stateid plh_stateid;
  181. u32 plh_barrier; /* ignore lower seqids */
  182. u32 plh_return_seq;
  183. enum pnfs_iomode plh_return_iomode;
  184. loff_t plh_lwb; /* last write byte for layoutcommit */
  185. const struct cred *plh_lc_cred; /* layoutcommit cred */
  186. struct inode *plh_inode;
  187. struct rcu_head plh_rcu;
  188. };
  189. struct pnfs_device {
  190. struct nfs4_deviceid dev_id;
  191. unsigned int layout_type;
  192. unsigned int mincount;
  193. unsigned int maxcount; /* gdia_maxcount */
  194. struct page **pages;
  195. unsigned int pgbase;
  196. unsigned int pglen; /* reply buffer length */
  197. unsigned char nocache : 1;/* May not be cached */
  198. };
  199. #define NFS4_PNFS_GETDEVLIST_MAXNUM 16
  200. struct pnfs_devicelist {
  201. unsigned int eof;
  202. unsigned int num_devs;
  203. struct nfs4_deviceid dev_id[NFS4_PNFS_GETDEVLIST_MAXNUM];
  204. };
  205. extern int pnfs_register_layoutdriver(struct pnfs_layoutdriver_type *);
  206. extern void pnfs_unregister_layoutdriver(struct pnfs_layoutdriver_type *);
  207. extern const struct pnfs_layoutdriver_type *pnfs_find_layoutdriver(u32 id);
  208. extern void pnfs_put_layoutdriver(const struct pnfs_layoutdriver_type *ld);
  209. /* nfs4proc.c */
  210. extern size_t max_response_pages(struct nfs_server *server);
  211. extern int nfs4_proc_getdeviceinfo(struct nfs_server *server,
  212. struct pnfs_device *dev,
  213. const struct cred *cred);
  214. extern struct pnfs_layout_segment* nfs4_proc_layoutget(struct nfs4_layoutget *lgp, long *timeout);
  215. extern int nfs4_proc_layoutreturn(struct nfs4_layoutreturn *lrp, bool sync);
  216. /* pnfs.c */
  217. void pnfs_get_layout_hdr(struct pnfs_layout_hdr *lo);
  218. void pnfs_put_lseg(struct pnfs_layout_segment *lseg);
  219. void set_pnfs_layoutdriver(struct nfs_server *, const struct nfs_fh *, struct nfs_fsinfo *);
  220. void unset_pnfs_layoutdriver(struct nfs_server *);
  221. void pnfs_generic_pg_check_layout(struct nfs_pageio_descriptor *pgio);
  222. void pnfs_generic_pg_check_range(struct nfs_pageio_descriptor *pgio, struct nfs_page *req);
  223. void pnfs_generic_pg_init_read(struct nfs_pageio_descriptor *, struct nfs_page *);
  224. int pnfs_generic_pg_readpages(struct nfs_pageio_descriptor *desc);
  225. void pnfs_generic_pg_init_write(struct nfs_pageio_descriptor *pgio,
  226. struct nfs_page *req, u64 wb_size);
  227. void pnfs_generic_pg_cleanup(struct nfs_pageio_descriptor *);
  228. int pnfs_generic_pg_writepages(struct nfs_pageio_descriptor *desc);
  229. size_t pnfs_generic_pg_test(struct nfs_pageio_descriptor *pgio,
  230. struct nfs_page *prev, struct nfs_page *req);
  231. void pnfs_set_lo_fail(struct pnfs_layout_segment *lseg);
  232. struct pnfs_layout_segment *pnfs_layout_process(struct nfs4_layoutget *lgp);
  233. void pnfs_layoutget_free(struct nfs4_layoutget *lgp);
  234. void pnfs_free_lseg_list(struct list_head *tmp_list);
  235. void pnfs_destroy_layout(struct nfs_inode *);
  236. void pnfs_destroy_layout_final(struct nfs_inode *);
  237. void pnfs_destroy_all_layouts(struct nfs_client *);
  238. int pnfs_destroy_layouts_byfsid(struct nfs_client *clp,
  239. struct nfs_fsid *fsid,
  240. bool is_recall);
  241. int pnfs_destroy_layouts_byclid(struct nfs_client *clp,
  242. bool is_recall);
  243. bool nfs4_layout_refresh_old_stateid(nfs4_stateid *dst,
  244. struct pnfs_layout_range *dst_range,
  245. struct inode *inode);
  246. void pnfs_put_layout_hdr(struct pnfs_layout_hdr *lo);
  247. void pnfs_set_layout_stateid(struct pnfs_layout_hdr *lo,
  248. const nfs4_stateid *new,
  249. const struct cred *cred,
  250. bool update_barrier);
  251. int pnfs_mark_matching_lsegs_invalid(struct pnfs_layout_hdr *lo,
  252. struct list_head *tmp_list,
  253. const struct pnfs_layout_range *recall_range,
  254. u32 seq);
  255. int pnfs_mark_matching_lsegs_return(struct pnfs_layout_hdr *lo,
  256. struct list_head *tmp_list,
  257. const struct pnfs_layout_range *recall_range,
  258. u32 seq);
  259. int pnfs_mark_layout_stateid_invalid(struct pnfs_layout_hdr *lo,
  260. struct list_head *lseg_list);
  261. bool pnfs_roc(struct inode *ino,
  262. struct nfs4_layoutreturn_args *args,
  263. struct nfs4_layoutreturn_res *res,
  264. const struct cred *cred);
  265. int pnfs_roc_done(struct rpc_task *task, struct nfs4_layoutreturn_args **argpp,
  266. struct nfs4_layoutreturn_res **respp, int *ret);
  267. void pnfs_roc_release(struct nfs4_layoutreturn_args *args,
  268. struct nfs4_layoutreturn_res *res,
  269. int ret);
  270. bool pnfs_wait_on_layoutreturn(struct inode *ino, struct rpc_task *task);
  271. void pnfs_set_layoutcommit(struct inode *, struct pnfs_layout_segment *, loff_t);
  272. void pnfs_cleanup_layoutcommit(struct nfs4_layoutcommit_data *data);
  273. int pnfs_layoutcommit_inode(struct inode *inode, bool sync);
  274. int pnfs_generic_sync(struct inode *inode, bool datasync);
  275. int pnfs_nfs_generic_sync(struct inode *inode, bool datasync);
  276. int _pnfs_return_layout(struct inode *);
  277. int pnfs_commit_and_return_layout(struct inode *);
  278. void pnfs_ld_write_done(struct nfs_pgio_header *);
  279. void pnfs_ld_read_done(struct nfs_pgio_header *);
  280. void pnfs_read_resend_pnfs(struct nfs_pgio_header *, unsigned int mirror_idx);
  281. struct pnfs_layout_segment *pnfs_update_layout(struct inode *ino,
  282. struct nfs_open_context *ctx,
  283. loff_t pos,
  284. u64 count,
  285. enum pnfs_iomode iomode,
  286. bool strict_iomode,
  287. gfp_t gfp_flags);
  288. void pnfs_layoutreturn_free_lsegs(struct pnfs_layout_hdr *lo,
  289. const nfs4_stateid *arg_stateid,
  290. const struct pnfs_layout_range *range,
  291. const nfs4_stateid *stateid);
  292. void pnfs_generic_layout_insert_lseg(struct pnfs_layout_hdr *lo,
  293. struct pnfs_layout_segment *lseg,
  294. bool (*is_after)(const struct pnfs_layout_range *lseg_range,
  295. const struct pnfs_layout_range *old),
  296. bool (*do_merge)(struct pnfs_layout_segment *lseg,
  297. struct pnfs_layout_segment *old),
  298. struct list_head *free_me);
  299. void nfs4_deviceid_mark_client_invalid(struct nfs_client *clp);
  300. int pnfs_read_done_resend_to_mds(struct nfs_pgio_header *);
  301. int pnfs_write_done_resend_to_mds(struct nfs_pgio_header *);
  302. struct nfs4_threshold *pnfs_mdsthreshold_alloc(void);
  303. void pnfs_error_mark_layout_for_return(struct inode *inode,
  304. struct pnfs_layout_segment *lseg);
  305. void pnfs_layout_return_unused_byclid(struct nfs_client *clp,
  306. enum pnfs_iomode iomode);
  307. /* nfs4_deviceid_flags */
  308. enum {
  309. NFS_DEVICEID_INVALID = 0, /* set when MDS clientid recalled */
  310. NFS_DEVICEID_UNAVAILABLE, /* device temporarily unavailable */
  311. NFS_DEVICEID_NOCACHE, /* device may not be cached */
  312. };
  313. /* pnfs_dev.c */
  314. struct nfs4_deviceid_node {
  315. struct hlist_node node;
  316. struct hlist_node tmpnode;
  317. const struct pnfs_layoutdriver_type *ld;
  318. const struct nfs_client *nfs_client;
  319. unsigned long flags;
  320. unsigned long timestamp_unavailable;
  321. struct nfs4_deviceid deviceid;
  322. struct rcu_head rcu;
  323. atomic_t ref;
  324. };
  325. struct nfs4_deviceid_node *
  326. nfs4_find_get_deviceid(struct nfs_server *server,
  327. const struct nfs4_deviceid *id, const struct cred *cred,
  328. gfp_t gfp_mask);
  329. void nfs4_delete_deviceid(const struct pnfs_layoutdriver_type *, const struct nfs_client *, const struct nfs4_deviceid *);
  330. void nfs4_init_deviceid_node(struct nfs4_deviceid_node *, struct nfs_server *,
  331. const struct nfs4_deviceid *);
  332. bool nfs4_put_deviceid_node(struct nfs4_deviceid_node *);
  333. void nfs4_mark_deviceid_available(struct nfs4_deviceid_node *node);
  334. void nfs4_mark_deviceid_unavailable(struct nfs4_deviceid_node *node);
  335. bool nfs4_test_deviceid_unavailable(struct nfs4_deviceid_node *node);
  336. void nfs4_deviceid_purge_client(const struct nfs_client *);
  337. /* pnfs_nfs.c */
  338. struct pnfs_commit_array *pnfs_alloc_commit_array(size_t n, gfp_t gfp_flags);
  339. void pnfs_free_commit_array(struct pnfs_commit_array *p);
  340. struct pnfs_commit_array *pnfs_add_commit_array(struct pnfs_ds_commit_info *,
  341. struct pnfs_commit_array *,
  342. struct pnfs_layout_segment *);
  343. void pnfs_generic_ds_cinfo_release_lseg(struct pnfs_ds_commit_info *fl_cinfo,
  344. struct pnfs_layout_segment *lseg);
  345. void pnfs_generic_ds_cinfo_destroy(struct pnfs_ds_commit_info *fl_cinfo);
  346. void pnfs_generic_clear_request_commit(struct nfs_page *req,
  347. struct nfs_commit_info *cinfo);
  348. void pnfs_generic_commit_release(void *calldata);
  349. void pnfs_generic_prepare_to_resend_writes(struct nfs_commit_data *data);
  350. void pnfs_generic_rw_release(void *data);
  351. void pnfs_generic_recover_commit_reqs(struct list_head *dst,
  352. struct nfs_commit_info *cinfo);
  353. struct nfs_page *pnfs_generic_search_commit_reqs(struct nfs_commit_info *cinfo,
  354. struct page *page);
  355. int pnfs_generic_commit_pagelist(struct inode *inode,
  356. struct list_head *mds_pages,
  357. int how,
  358. struct nfs_commit_info *cinfo,
  359. int (*initiate_commit)(struct nfs_commit_data *data,
  360. int how));
  361. int pnfs_generic_scan_commit_lists(struct nfs_commit_info *cinfo, int max);
  362. void pnfs_generic_write_commit_done(struct rpc_task *task, void *data);
  363. void nfs4_pnfs_ds_put(struct nfs4_pnfs_ds *ds);
  364. struct nfs4_pnfs_ds *nfs4_pnfs_ds_add(struct list_head *dsaddrs,
  365. gfp_t gfp_flags);
  366. void nfs4_pnfs_v3_ds_connect_unload(void);
  367. int nfs4_pnfs_ds_connect(struct nfs_server *mds_srv, struct nfs4_pnfs_ds *ds,
  368. struct nfs4_deviceid_node *devid, unsigned int timeo,
  369. unsigned int retrans, u32 version, u32 minor_version);
  370. struct nfs4_pnfs_ds_addr *nfs4_decode_mp_ds_addr(struct net *net,
  371. struct xdr_stream *xdr,
  372. gfp_t gfp_flags);
  373. void pnfs_layout_mark_request_commit(struct nfs_page *req,
  374. struct pnfs_layout_segment *lseg,
  375. struct nfs_commit_info *cinfo,
  376. u32 ds_commit_idx);
  377. void pnfs_lgopen_prepare(struct nfs4_opendata *data,
  378. struct nfs_open_context *ctx);
  379. void pnfs_parse_lgopen(struct inode *ino, struct nfs4_layoutget *lgp,
  380. struct nfs_open_context *ctx);
  381. void nfs4_lgopen_release(struct nfs4_layoutget *lgp);
  382. static inline bool nfs_have_layout(struct inode *inode)
  383. {
  384. return NFS_I(inode)->layout != NULL;
  385. }
  386. static inline bool pnfs_layout_is_valid(const struct pnfs_layout_hdr *lo)
  387. {
  388. return test_bit(NFS_LAYOUT_INVALID_STID, &lo->plh_flags) == 0;
  389. }
  390. static inline struct nfs4_deviceid_node *
  391. nfs4_get_deviceid(struct nfs4_deviceid_node *d)
  392. {
  393. atomic_inc(&d->ref);
  394. return d;
  395. }
  396. static inline struct pnfs_layout_segment *
  397. pnfs_get_lseg(struct pnfs_layout_segment *lseg)
  398. {
  399. if (lseg) {
  400. refcount_inc(&lseg->pls_refcount);
  401. smp_mb__after_atomic();
  402. }
  403. return lseg;
  404. }
  405. static inline bool
  406. pnfs_is_valid_lseg(struct pnfs_layout_segment *lseg)
  407. {
  408. return test_bit(NFS_LSEG_VALID, &lseg->pls_flags) != 0;
  409. }
  410. /* Return true if a layout driver is being used for this mountpoint */
  411. static inline int pnfs_enabled_sb(struct nfs_server *nfss)
  412. {
  413. return nfss->pnfs_curr_ld != NULL;
  414. }
  415. static inline int
  416. pnfs_commit_list(struct inode *inode, struct list_head *mds_pages, int how,
  417. struct nfs_commit_info *cinfo)
  418. {
  419. struct pnfs_ds_commit_info *fl_cinfo = cinfo->ds;
  420. if (fl_cinfo == NULL || fl_cinfo->ncommitting == 0)
  421. return PNFS_NOT_ATTEMPTED;
  422. return fl_cinfo->ops->commit_pagelist(inode, mds_pages, how, cinfo);
  423. }
  424. static inline struct pnfs_ds_commit_info *
  425. pnfs_get_ds_info(struct inode *inode)
  426. {
  427. struct pnfs_layoutdriver_type *ld = NFS_SERVER(inode)->pnfs_curr_ld;
  428. if (ld == NULL || ld->get_ds_info == NULL)
  429. return NULL;
  430. return ld->get_ds_info(inode);
  431. }
  432. static inline void
  433. pnfs_init_ds_commit_info_ops(struct pnfs_ds_commit_info *fl_cinfo, struct inode *inode)
  434. {
  435. struct pnfs_ds_commit_info *inode_cinfo = pnfs_get_ds_info(inode);
  436. if (inode_cinfo != NULL)
  437. fl_cinfo->ops = inode_cinfo->ops;
  438. }
  439. static inline void
  440. pnfs_init_ds_commit_info(struct pnfs_ds_commit_info *fl_cinfo)
  441. {
  442. INIT_LIST_HEAD(&fl_cinfo->commits);
  443. fl_cinfo->ops = NULL;
  444. }
  445. static inline void
  446. pnfs_release_ds_info(struct pnfs_ds_commit_info *fl_cinfo, struct inode *inode)
  447. {
  448. if (fl_cinfo->ops != NULL && fl_cinfo->ops->release_ds_info != NULL)
  449. fl_cinfo->ops->release_ds_info(fl_cinfo, inode);
  450. }
  451. static inline void
  452. pnfs_generic_mark_devid_invalid(struct nfs4_deviceid_node *node)
  453. {
  454. set_bit(NFS_DEVICEID_INVALID, &node->flags);
  455. }
  456. static inline bool
  457. pnfs_mark_request_commit(struct nfs_page *req, struct pnfs_layout_segment *lseg,
  458. struct nfs_commit_info *cinfo, u32 ds_commit_idx)
  459. {
  460. struct pnfs_ds_commit_info *fl_cinfo = cinfo->ds;
  461. if (!lseg || !fl_cinfo->ops || !fl_cinfo->ops->mark_request_commit)
  462. return false;
  463. fl_cinfo->ops->mark_request_commit(req, lseg, cinfo, ds_commit_idx);
  464. return true;
  465. }
  466. static inline bool
  467. pnfs_clear_request_commit(struct nfs_page *req, struct nfs_commit_info *cinfo)
  468. {
  469. struct pnfs_ds_commit_info *fl_cinfo = cinfo->ds;
  470. if (!fl_cinfo || !fl_cinfo->ops || !fl_cinfo->ops->clear_request_commit)
  471. return false;
  472. fl_cinfo->ops->clear_request_commit(req, cinfo);
  473. return true;
  474. }
  475. static inline int
  476. pnfs_scan_commit_lists(struct inode *inode, struct nfs_commit_info *cinfo,
  477. int max)
  478. {
  479. struct pnfs_ds_commit_info *fl_cinfo = cinfo->ds;
  480. if (!fl_cinfo || fl_cinfo->nwritten == 0)
  481. return 0;
  482. return fl_cinfo->ops->scan_commit_lists(cinfo, max);
  483. }
  484. static inline void
  485. pnfs_recover_commit_reqs(struct list_head *head, struct nfs_commit_info *cinfo)
  486. {
  487. struct pnfs_ds_commit_info *fl_cinfo = cinfo->ds;
  488. if (fl_cinfo && fl_cinfo->nwritten != 0)
  489. fl_cinfo->ops->recover_commit_reqs(head, cinfo);
  490. }
  491. static inline struct nfs_page *
  492. pnfs_search_commit_reqs(struct inode *inode, struct nfs_commit_info *cinfo,
  493. struct page *page)
  494. {
  495. struct pnfs_ds_commit_info *fl_cinfo = cinfo->ds;
  496. if (!fl_cinfo->ops || !fl_cinfo->ops->search_commit_reqs)
  497. return NULL;
  498. return fl_cinfo->ops->search_commit_reqs(cinfo, page);
  499. }
  500. /* Should the pNFS client commit and return the layout upon a setattr */
  501. static inline bool
  502. pnfs_ld_layoutret_on_setattr(struct inode *inode)
  503. {
  504. if (!pnfs_enabled_sb(NFS_SERVER(inode)))
  505. return false;
  506. return NFS_SERVER(inode)->pnfs_curr_ld->flags &
  507. PNFS_LAYOUTRET_ON_SETATTR;
  508. }
  509. static inline bool
  510. pnfs_ld_read_whole_page(struct inode *inode)
  511. {
  512. if (!pnfs_enabled_sb(NFS_SERVER(inode)))
  513. return false;
  514. return NFS_SERVER(inode)->pnfs_curr_ld->flags & PNFS_READ_WHOLE_PAGE;
  515. }
  516. static inline int
  517. pnfs_sync_inode(struct inode *inode, bool datasync)
  518. {
  519. if (!pnfs_enabled_sb(NFS_SERVER(inode)))
  520. return 0;
  521. return NFS_SERVER(inode)->pnfs_curr_ld->sync(inode, datasync);
  522. }
  523. static inline bool
  524. pnfs_layoutcommit_outstanding(struct inode *inode)
  525. {
  526. struct nfs_inode *nfsi = NFS_I(inode);
  527. return test_bit(NFS_INO_LAYOUTCOMMIT, &nfsi->flags) != 0 ||
  528. test_bit(NFS_INO_LAYOUTCOMMITTING, &nfsi->flags) != 0;
  529. }
  530. static inline int pnfs_return_layout(struct inode *ino)
  531. {
  532. struct nfs_inode *nfsi = NFS_I(ino);
  533. struct nfs_server *nfss = NFS_SERVER(ino);
  534. if (pnfs_enabled_sb(nfss) && nfsi->layout) {
  535. set_bit(NFS_LAYOUT_RETURN_REQUESTED, &nfsi->layout->plh_flags);
  536. return _pnfs_return_layout(ino);
  537. }
  538. return 0;
  539. }
  540. static inline bool
  541. pnfs_use_threshold(struct nfs4_threshold **dst, struct nfs4_threshold *src,
  542. struct nfs_server *nfss)
  543. {
  544. return (dst && src && src->bm != 0 && nfss->pnfs_curr_ld &&
  545. nfss->pnfs_curr_ld->id == src->l_type);
  546. }
  547. static inline u64
  548. pnfs_calc_offset_end(u64 offset, u64 len)
  549. {
  550. if (len == NFS4_MAX_UINT64 || len >= NFS4_MAX_UINT64 - offset)
  551. return NFS4_MAX_UINT64;
  552. return offset + len - 1;
  553. }
  554. static inline u64
  555. pnfs_calc_offset_length(u64 offset, u64 end)
  556. {
  557. if (end == NFS4_MAX_UINT64 || end <= offset)
  558. return NFS4_MAX_UINT64;
  559. return 1 + end - offset;
  560. }
  561. static inline void
  562. pnfs_copy_range(struct pnfs_layout_range *dst,
  563. const struct pnfs_layout_range *src)
  564. {
  565. memcpy(dst, src, sizeof(*dst));
  566. }
  567. static inline u64
  568. pnfs_end_offset(u64 start, u64 len)
  569. {
  570. if (NFS4_MAX_UINT64 - start <= len)
  571. return NFS4_MAX_UINT64;
  572. return start + len;
  573. }
  574. /*
  575. * Are 2 ranges intersecting?
  576. * start1 end1
  577. * [----------------------------------)
  578. * start2 end2
  579. * [----------------)
  580. */
  581. static inline bool
  582. pnfs_is_range_intersecting(u64 start1, u64 end1, u64 start2, u64 end2)
  583. {
  584. return (end1 == NFS4_MAX_UINT64 || start2 < end1) &&
  585. (end2 == NFS4_MAX_UINT64 || start1 < end2);
  586. }
  587. static inline bool
  588. pnfs_lseg_range_intersecting(const struct pnfs_layout_range *l1,
  589. const struct pnfs_layout_range *l2)
  590. {
  591. u64 end1 = pnfs_end_offset(l1->offset, l1->length);
  592. u64 end2 = pnfs_end_offset(l2->offset, l2->length);
  593. return pnfs_is_range_intersecting(l1->offset, end1, l2->offset, end2);
  594. }
  595. static inline bool
  596. pnfs_lseg_request_intersecting(struct pnfs_layout_segment *lseg, struct nfs_page *req)
  597. {
  598. u64 seg_last = pnfs_end_offset(lseg->pls_range.offset, lseg->pls_range.length);
  599. u64 req_last = req_offset(req) + req->wb_bytes;
  600. return pnfs_is_range_intersecting(lseg->pls_range.offset, seg_last,
  601. req_offset(req), req_last);
  602. }
  603. static inline void pnfs_lseg_cancel_io(struct nfs_server *server,
  604. struct pnfs_layout_segment *lseg)
  605. {
  606. if (server->pnfs_curr_ld->cancel_io)
  607. server->pnfs_curr_ld->cancel_io(lseg);
  608. }
  609. extern unsigned int layoutstats_timer;
  610. #ifdef NFS_DEBUG
  611. void nfs4_print_deviceid(const struct nfs4_deviceid *dev_id);
  612. #else
  613. static inline void nfs4_print_deviceid(const struct nfs4_deviceid *dev_id)
  614. {
  615. }
  616. #endif /* NFS_DEBUG */
  617. #else /* CONFIG_NFS_V4_1 */
  618. static inline bool nfs_have_layout(struct inode *inode)
  619. {
  620. return false;
  621. }
  622. static inline void pnfs_destroy_all_layouts(struct nfs_client *clp)
  623. {
  624. }
  625. static inline void pnfs_destroy_layout(struct nfs_inode *nfsi)
  626. {
  627. }
  628. static inline void pnfs_destroy_layout_final(struct nfs_inode *nfsi)
  629. {
  630. }
  631. static inline struct pnfs_layout_segment *
  632. pnfs_get_lseg(struct pnfs_layout_segment *lseg)
  633. {
  634. return NULL;
  635. }
  636. static inline void pnfs_put_lseg(struct pnfs_layout_segment *lseg)
  637. {
  638. }
  639. static inline int pnfs_return_layout(struct inode *ino)
  640. {
  641. return 0;
  642. }
  643. static inline int pnfs_commit_and_return_layout(struct inode *inode)
  644. {
  645. return 0;
  646. }
  647. static inline bool
  648. pnfs_ld_layoutret_on_setattr(struct inode *inode)
  649. {
  650. return false;
  651. }
  652. static inline bool
  653. pnfs_ld_read_whole_page(struct inode *inode)
  654. {
  655. return false;
  656. }
  657. static inline int
  658. pnfs_sync_inode(struct inode *inode, bool datasync)
  659. {
  660. return 0;
  661. }
  662. static inline bool
  663. pnfs_layoutcommit_outstanding(struct inode *inode)
  664. {
  665. return false;
  666. }
  667. static inline bool
  668. pnfs_roc(struct inode *ino,
  669. struct nfs4_layoutreturn_args *args,
  670. struct nfs4_layoutreturn_res *res,
  671. const struct cred *cred)
  672. {
  673. return false;
  674. }
  675. static inline int
  676. pnfs_roc_done(struct rpc_task *task,
  677. struct nfs4_layoutreturn_args **argpp,
  678. struct nfs4_layoutreturn_res **respp,
  679. int *ret)
  680. {
  681. return 0;
  682. }
  683. static inline void
  684. pnfs_roc_release(struct nfs4_layoutreturn_args *args,
  685. struct nfs4_layoutreturn_res *res,
  686. int ret)
  687. {
  688. }
  689. static inline bool
  690. pnfs_wait_on_layoutreturn(struct inode *ino, struct rpc_task *task)
  691. {
  692. return false;
  693. }
  694. static inline void set_pnfs_layoutdriver(struct nfs_server *s,
  695. const struct nfs_fh *mntfh,
  696. struct nfs_fsinfo *fsinfo)
  697. {
  698. }
  699. static inline void unset_pnfs_layoutdriver(struct nfs_server *s)
  700. {
  701. }
  702. static inline int
  703. pnfs_commit_list(struct inode *inode, struct list_head *mds_pages, int how,
  704. struct nfs_commit_info *cinfo)
  705. {
  706. return PNFS_NOT_ATTEMPTED;
  707. }
  708. static inline struct pnfs_ds_commit_info *
  709. pnfs_get_ds_info(struct inode *inode)
  710. {
  711. return NULL;
  712. }
  713. static inline void
  714. pnfs_init_ds_commit_info_ops(struct pnfs_ds_commit_info *fl_cinfo, struct inode *inode)
  715. {
  716. }
  717. static inline void
  718. pnfs_init_ds_commit_info(struct pnfs_ds_commit_info *fl_cinfo)
  719. {
  720. }
  721. static inline void
  722. pnfs_release_ds_info(struct pnfs_ds_commit_info *fl_cinfo, struct inode *inode)
  723. {
  724. }
  725. static inline bool
  726. pnfs_mark_request_commit(struct nfs_page *req, struct pnfs_layout_segment *lseg,
  727. struct nfs_commit_info *cinfo, u32 ds_commit_idx)
  728. {
  729. return false;
  730. }
  731. static inline bool
  732. pnfs_clear_request_commit(struct nfs_page *req, struct nfs_commit_info *cinfo)
  733. {
  734. return false;
  735. }
  736. static inline int
  737. pnfs_scan_commit_lists(struct inode *inode, struct nfs_commit_info *cinfo,
  738. int max)
  739. {
  740. return 0;
  741. }
  742. static inline void
  743. pnfs_recover_commit_reqs(struct list_head *head, struct nfs_commit_info *cinfo)
  744. {
  745. }
  746. static inline struct nfs_page *
  747. pnfs_search_commit_reqs(struct inode *inode, struct nfs_commit_info *cinfo,
  748. struct page *page)
  749. {
  750. return NULL;
  751. }
  752. static inline int pnfs_layoutcommit_inode(struct inode *inode, bool sync)
  753. {
  754. return 0;
  755. }
  756. static inline bool
  757. pnfs_use_threshold(struct nfs4_threshold **dst, struct nfs4_threshold *src,
  758. struct nfs_server *nfss)
  759. {
  760. return false;
  761. }
  762. static inline struct nfs4_threshold *pnfs_mdsthreshold_alloc(void)
  763. {
  764. return NULL;
  765. }
  766. static inline void nfs4_pnfs_v3_ds_connect_unload(void)
  767. {
  768. }
  769. static inline bool nfs4_layout_refresh_old_stateid(nfs4_stateid *dst,
  770. struct pnfs_layout_range *dst_range,
  771. struct inode *inode)
  772. {
  773. return false;
  774. }
  775. static inline void pnfs_lgopen_prepare(struct nfs4_opendata *data,
  776. struct nfs_open_context *ctx)
  777. {
  778. }
  779. static inline void pnfs_parse_lgopen(struct inode *ino,
  780. struct nfs4_layoutget *lgp,
  781. struct nfs_open_context *ctx)
  782. {
  783. }
  784. static inline void nfs4_lgopen_release(struct nfs4_layoutget *lgp)
  785. {
  786. }
  787. static inline bool pnfs_layout_is_valid(const struct pnfs_layout_hdr *lo)
  788. {
  789. return false;
  790. }
  791. #endif /* CONFIG_NFS_V4_1 */
  792. #if IS_ENABLED(CONFIG_NFS_V4_2)
  793. int pnfs_report_layoutstat(struct inode *inode, gfp_t gfp_flags);
  794. #else
  795. static inline int
  796. pnfs_report_layoutstat(struct inode *inode, gfp_t gfp_flags)
  797. {
  798. return 0;
  799. }
  800. #endif
  801. #endif /* FS_NFS_PNFS_H */