pnfs.h 28 KB

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