LCOV - code coverage report
Current view: top level - fs/nfs - pnfs.h (source / functions) Hit Total Coverage
Test: Real Lines: 0 54 0.0 %
Date: 2020-10-17 15:46:16 Functions: 0 5 0.0 %
Legend: Neither, QEMU, Real, Both Branches: 0 0 -

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

Generated by: LCOV version 1.14