linux/fs/nfs/pnfs.h
<<
>>
Prefs
   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/nfs_fs.h>
  34#include <linux/nfs_page.h>
  35
  36enum {
  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};
  41
  42struct pnfs_layout_segment {
  43        struct list_head pls_list;
  44        struct list_head pls_lc_list;
  45        struct pnfs_layout_range pls_range;
  46        atomic_t pls_refcount;
  47        unsigned long pls_flags;
  48        struct pnfs_layout_hdr *pls_layout;
  49};
  50
  51enum pnfs_try_status {
  52        PNFS_ATTEMPTED     = 0,
  53        PNFS_NOT_ATTEMPTED = 1,
  54};
  55
  56#ifdef CONFIG_NFS_V4_1
  57
  58#define LAYOUT_NFSV4_1_MODULE_PREFIX "nfs-layouttype4"
  59
  60enum {
  61        NFS_LAYOUT_RO_FAILED = 0,       /* get ro layout failed stop trying */
  62        NFS_LAYOUT_RW_FAILED,           /* get rw layout failed stop trying */
  63        NFS_LAYOUT_BULK_RECALL,         /* bulk recall affecting layout */
  64        NFS_LAYOUT_ROC,                 /* some lseg had roc bit set */
  65        NFS_LAYOUT_DESTROYED,           /* no new use of layout allowed */
  66        NFS_LAYOUT_INVALID,             /* layout is being destroyed */
  67        NFS_LAYOUT_RETURNED,            /* layout has already been returned */
  68};
  69
  70enum layoutdriver_policy_flags {
  71        /* Should the pNFS client commit and return the layout upon a setattr */
  72        PNFS_LAYOUTRET_ON_SETATTR       = 1 << 0,
  73        PNFS_LAYOUTRET_ON_ERROR         = 1 << 1,
  74};
  75
  76struct nfs4_deviceid_node;
  77
  78/* Per-layout driver specific registration structure */
  79struct pnfs_layoutdriver_type {
  80        struct list_head pnfs_tblid;
  81        const u32 id;
  82        const char *name;
  83        struct module *owner;
  84        unsigned flags;
  85
  86        int (*set_layoutdriver) (struct nfs_server *, const struct nfs_fh *);
  87        int (*clear_layoutdriver) (struct nfs_server *);
  88
  89        struct pnfs_layout_hdr * (*alloc_layout_hdr) (struct inode *inode, gfp_t gfp_flags);
  90        void (*free_layout_hdr) (struct pnfs_layout_hdr *);
  91
  92        struct pnfs_layout_segment * (*alloc_lseg) (struct pnfs_layout_hdr *layoutid, struct nfs4_layoutget_res *lgr, gfp_t gfp_flags);
  93        void (*free_lseg) (struct pnfs_layout_segment *lseg);
  94
  95        /* test for nfs page cache coalescing */
  96        const struct nfs_pageio_ops *pg_read_ops;
  97        const struct nfs_pageio_ops *pg_write_ops;
  98
  99        struct pnfs_ds_commit_info *(*get_ds_info) (struct inode *inode);
 100        void (*mark_request_commit) (struct nfs_page *req,
 101                                     struct pnfs_layout_segment *lseg,
 102                                     struct nfs_commit_info *cinfo);
 103        void (*clear_request_commit) (struct nfs_page *req,
 104                                      struct nfs_commit_info *cinfo);
 105        int (*scan_commit_lists) (struct nfs_commit_info *cinfo,
 106                                  int max);
 107        void (*recover_commit_reqs) (struct list_head *list,
 108                                     struct nfs_commit_info *cinfo);
 109        int (*commit_pagelist)(struct inode *inode,
 110                               struct list_head *mds_pages,
 111                               int how,
 112                               struct nfs_commit_info *cinfo);
 113
 114        /*
 115         * Return PNFS_ATTEMPTED to indicate the layout code has attempted
 116         * I/O, else return PNFS_NOT_ATTEMPTED to fall back to normal NFS
 117         */
 118        enum pnfs_try_status (*read_pagelist) (struct nfs_read_data *nfs_data);
 119        enum pnfs_try_status (*write_pagelist) (struct nfs_write_data *nfs_data, int how);
 120
 121        void (*free_deviceid_node) (struct nfs4_deviceid_node *);
 122
 123        void (*encode_layoutreturn) (struct pnfs_layout_hdr *layoutid,
 124                                     struct xdr_stream *xdr,
 125                                     const struct nfs4_layoutreturn_args *args);
 126
 127        void (*cleanup_layoutcommit) (struct nfs4_layoutcommit_data *data);
 128
 129        void (*encode_layoutcommit) (struct pnfs_layout_hdr *layoutid,
 130                                     struct xdr_stream *xdr,
 131                                     const struct nfs4_layoutcommit_args *args);
 132};
 133
 134struct pnfs_layout_hdr {
 135        atomic_t                plh_refcount;
 136        struct list_head        plh_layouts;   /* other client layouts */
 137        struct list_head        plh_bulk_recall; /* clnt list of bulk recalls */
 138        struct list_head        plh_segs;      /* layout segments list */
 139        nfs4_stateid            plh_stateid;
 140        atomic_t                plh_outstanding; /* number of RPCs out */
 141        unsigned long           plh_block_lgets; /* block LAYOUTGET if >0 */
 142        u32                     plh_barrier; /* ignore lower seqids */
 143        unsigned long           plh_flags;
 144        loff_t                  plh_lwb; /* last write byte for layoutcommit */
 145        struct rpc_cred         *plh_lc_cred; /* layoutcommit cred */
 146        struct inode            *plh_inode;
 147};
 148
 149struct pnfs_device {
 150        struct nfs4_deviceid dev_id;
 151        unsigned int  layout_type;
 152        unsigned int  mincount;
 153        struct page **pages;
 154        unsigned int  pgbase;
 155        unsigned int  pglen;
 156};
 157
 158#define NFS4_PNFS_GETDEVLIST_MAXNUM 16
 159
 160struct pnfs_devicelist {
 161        unsigned int            eof;
 162        unsigned int            num_devs;
 163        struct nfs4_deviceid    dev_id[NFS4_PNFS_GETDEVLIST_MAXNUM];
 164};
 165
 166extern int pnfs_register_layoutdriver(struct pnfs_layoutdriver_type *);
 167extern void pnfs_unregister_layoutdriver(struct pnfs_layoutdriver_type *);
 168
 169/* nfs4proc.c */
 170extern int nfs4_proc_getdevicelist(struct nfs_server *server,
 171                                   const struct nfs_fh *fh,
 172                                   struct pnfs_devicelist *devlist);
 173extern int nfs4_proc_getdeviceinfo(struct nfs_server *server,
 174                                   struct pnfs_device *dev);
 175extern void nfs4_proc_layoutget(struct nfs4_layoutget *lgp, gfp_t gfp_flags);
 176extern int nfs4_proc_layoutreturn(struct nfs4_layoutreturn *lrp);
 177
 178/* pnfs.c */
 179void get_layout_hdr(struct pnfs_layout_hdr *lo);
 180void put_lseg(struct pnfs_layout_segment *lseg);
 181
 182void pnfs_pageio_init_read(struct nfs_pageio_descriptor *, struct inode *,
 183                           const struct nfs_pgio_completion_ops *);
 184void pnfs_pageio_init_write(struct nfs_pageio_descriptor *, struct inode *,
 185                            int, const struct nfs_pgio_completion_ops *);
 186
 187void set_pnfs_layoutdriver(struct nfs_server *, const struct nfs_fh *, u32);
 188void unset_pnfs_layoutdriver(struct nfs_server *);
 189void pnfs_generic_pg_init_read(struct nfs_pageio_descriptor *, struct nfs_page *);
 190int pnfs_generic_pg_readpages(struct nfs_pageio_descriptor *desc);
 191void pnfs_generic_pg_init_write(struct nfs_pageio_descriptor *, struct nfs_page *);
 192int pnfs_generic_pg_writepages(struct nfs_pageio_descriptor *desc);
 193bool pnfs_generic_pg_test(struct nfs_pageio_descriptor *pgio, struct nfs_page *prev, struct nfs_page *req);
 194void pnfs_set_lo_fail(struct pnfs_layout_segment *lseg);
 195int pnfs_layout_process(struct nfs4_layoutget *lgp);
 196void pnfs_free_lseg_list(struct list_head *tmp_list);
 197void pnfs_destroy_layout(struct nfs_inode *);
 198void pnfs_destroy_all_layouts(struct nfs_client *);
 199void put_layout_hdr(struct pnfs_layout_hdr *lo);
 200void pnfs_set_layout_stateid(struct pnfs_layout_hdr *lo,
 201                             const nfs4_stateid *new,
 202                             bool update_barrier);
 203int pnfs_choose_layoutget_stateid(nfs4_stateid *dst,
 204                                  struct pnfs_layout_hdr *lo,
 205                                  struct nfs4_state *open_state);
 206int mark_matching_lsegs_invalid(struct pnfs_layout_hdr *lo,
 207                                struct list_head *tmp_list,
 208                                struct pnfs_layout_range *recall_range);
 209bool pnfs_roc(struct inode *ino);
 210void pnfs_roc_release(struct inode *ino);
 211void pnfs_roc_set_barrier(struct inode *ino, u32 barrier);
 212bool pnfs_roc_drain(struct inode *ino, u32 *barrier);
 213void pnfs_set_layoutcommit(struct nfs_write_data *wdata);
 214void pnfs_cleanup_layoutcommit(struct nfs4_layoutcommit_data *data);
 215int pnfs_layoutcommit_inode(struct inode *inode, bool sync);
 216int _pnfs_return_layout(struct inode *);
 217void pnfs_ld_write_done(struct nfs_write_data *);
 218void pnfs_ld_read_done(struct nfs_read_data *);
 219struct pnfs_layout_segment *pnfs_update_layout(struct inode *ino,
 220                                               struct nfs_open_context *ctx,
 221                                               loff_t pos,
 222                                               u64 count,
 223                                               enum pnfs_iomode iomode,
 224                                               gfp_t gfp_flags);
 225
 226void nfs4_deviceid_mark_client_invalid(struct nfs_client *clp);
 227int pnfs_read_done_resend_to_mds(struct inode *inode, struct list_head *head,
 228                        const struct nfs_pgio_completion_ops *compl_ops);
 229int pnfs_write_done_resend_to_mds(struct inode *inode, struct list_head *head,
 230                        const struct nfs_pgio_completion_ops *compl_ops);
 231struct nfs4_threshold *pnfs_mdsthreshold_alloc(void);
 232
 233/* nfs4_deviceid_flags */
 234enum {
 235        NFS_DEVICEID_INVALID = 0,       /* set when MDS clientid recalled */
 236};
 237
 238/* pnfs_dev.c */
 239struct nfs4_deviceid_node {
 240        struct hlist_node               node;
 241        struct hlist_node               tmpnode;
 242        const struct pnfs_layoutdriver_type *ld;
 243        const struct nfs_client         *nfs_client;
 244        unsigned long                   flags;
 245        struct nfs4_deviceid            deviceid;
 246        atomic_t                        ref;
 247};
 248
 249struct nfs4_deviceid_node *nfs4_find_get_deviceid(const struct pnfs_layoutdriver_type *, const struct nfs_client *, const struct nfs4_deviceid *);
 250void nfs4_delete_deviceid(const struct pnfs_layoutdriver_type *, const struct nfs_client *, const struct nfs4_deviceid *);
 251void nfs4_init_deviceid_node(struct nfs4_deviceid_node *,
 252                             const struct pnfs_layoutdriver_type *,
 253                             const struct nfs_client *,
 254                             const struct nfs4_deviceid *);
 255struct nfs4_deviceid_node *nfs4_insert_deviceid_node(struct nfs4_deviceid_node *);
 256bool nfs4_put_deviceid_node(struct nfs4_deviceid_node *);
 257void nfs4_deviceid_purge_client(const struct nfs_client *);
 258
 259static inline void
 260pnfs_mark_layout_returned(struct pnfs_layout_hdr *lo)
 261{
 262        set_bit(NFS_LAYOUT_RETURNED, &lo->plh_flags);
 263}
 264
 265static inline void
 266pnfs_clear_layout_returned(struct pnfs_layout_hdr *lo)
 267{
 268        clear_bit(NFS_LAYOUT_RETURNED, &lo->plh_flags);
 269}
 270
 271static inline bool
 272pnfs_test_layout_returned(struct pnfs_layout_hdr *lo)
 273{
 274        return test_bit(NFS_LAYOUT_RETURNED, &lo->plh_flags);
 275}
 276
 277static inline int lo_fail_bit(u32 iomode)
 278{
 279        return iomode == IOMODE_RW ?
 280                         NFS_LAYOUT_RW_FAILED : NFS_LAYOUT_RO_FAILED;
 281}
 282
 283static inline struct pnfs_layout_segment *
 284get_lseg(struct pnfs_layout_segment *lseg)
 285{
 286        if (lseg) {
 287                atomic_inc(&lseg->pls_refcount);
 288                smp_mb__after_atomic_inc();
 289        }
 290        return lseg;
 291}
 292
 293/* Return true if a layout driver is being used for this mountpoint */
 294static inline int pnfs_enabled_sb(struct nfs_server *nfss)
 295{
 296        return nfss->pnfs_curr_ld != NULL;
 297}
 298
 299static inline int
 300pnfs_commit_list(struct inode *inode, struct list_head *mds_pages, int how,
 301                 struct nfs_commit_info *cinfo)
 302{
 303        if (cinfo->ds == NULL || cinfo->ds->ncommitting == 0)
 304                return PNFS_NOT_ATTEMPTED;
 305        return NFS_SERVER(inode)->pnfs_curr_ld->commit_pagelist(inode, mds_pages, how, cinfo);
 306}
 307
 308static inline struct pnfs_ds_commit_info *
 309pnfs_get_ds_info(struct inode *inode)
 310{
 311        struct pnfs_layoutdriver_type *ld = NFS_SERVER(inode)->pnfs_curr_ld;
 312
 313        if (ld == NULL || ld->get_ds_info == NULL)
 314                return NULL;
 315        return ld->get_ds_info(inode);
 316}
 317
 318static inline bool
 319pnfs_mark_request_commit(struct nfs_page *req, struct pnfs_layout_segment *lseg,
 320                         struct nfs_commit_info *cinfo)
 321{
 322        struct inode *inode = req->wb_context->dentry->d_inode;
 323        struct pnfs_layoutdriver_type *ld = NFS_SERVER(inode)->pnfs_curr_ld;
 324
 325        if (lseg == NULL || ld->mark_request_commit == NULL)
 326                return false;
 327        ld->mark_request_commit(req, lseg, cinfo);
 328        return true;
 329}
 330
 331static inline bool
 332pnfs_clear_request_commit(struct nfs_page *req, struct nfs_commit_info *cinfo)
 333{
 334        struct inode *inode = req->wb_context->dentry->d_inode;
 335        struct pnfs_layoutdriver_type *ld = NFS_SERVER(inode)->pnfs_curr_ld;
 336
 337        if (ld == NULL || ld->clear_request_commit == NULL)
 338                return false;
 339        ld->clear_request_commit(req, cinfo);
 340        return true;
 341}
 342
 343static inline int
 344pnfs_scan_commit_lists(struct inode *inode, struct nfs_commit_info *cinfo,
 345                       int max)
 346{
 347        if (cinfo->ds == NULL || cinfo->ds->nwritten == 0)
 348                return 0;
 349        else
 350                return NFS_SERVER(inode)->pnfs_curr_ld->scan_commit_lists(cinfo, max);
 351}
 352
 353static inline void
 354pnfs_recover_commit_reqs(struct inode *inode, struct list_head *list,
 355                         struct nfs_commit_info *cinfo)
 356{
 357        if (cinfo->ds == NULL || cinfo->ds->nwritten == 0)
 358                return;
 359        NFS_SERVER(inode)->pnfs_curr_ld->recover_commit_reqs(list, cinfo);
 360}
 361
 362/* Should the pNFS client commit and return the layout upon a setattr */
 363static inline bool
 364pnfs_ld_layoutret_on_setattr(struct inode *inode)
 365{
 366        if (!pnfs_enabled_sb(NFS_SERVER(inode)))
 367                return false;
 368        return NFS_SERVER(inode)->pnfs_curr_ld->flags &
 369                PNFS_LAYOUTRET_ON_SETATTR;
 370}
 371
 372static inline int pnfs_return_layout(struct inode *ino)
 373{
 374        struct nfs_inode *nfsi = NFS_I(ino);
 375        struct nfs_server *nfss = NFS_SERVER(ino);
 376
 377        if (pnfs_enabled_sb(nfss) && nfsi->layout)
 378                return _pnfs_return_layout(ino);
 379
 380        return 0;
 381}
 382
 383static inline bool
 384pnfs_use_threshold(struct nfs4_threshold **dst, struct nfs4_threshold *src,
 385                   struct nfs_server *nfss)
 386{
 387        return (dst && src && src->bm != 0 && nfss->pnfs_curr_ld &&
 388                                        nfss->pnfs_curr_ld->id == src->l_type);
 389}
 390
 391#ifdef NFS_DEBUG
 392void nfs4_print_deviceid(const struct nfs4_deviceid *dev_id);
 393#else
 394static inline void nfs4_print_deviceid(const struct nfs4_deviceid *dev_id)
 395{
 396}
 397#endif /* NFS_DEBUG */
 398#else  /* CONFIG_NFS_V4_1 */
 399
 400static inline void pnfs_destroy_all_layouts(struct nfs_client *clp)
 401{
 402}
 403
 404static inline void pnfs_destroy_layout(struct nfs_inode *nfsi)
 405{
 406}
 407
 408static inline struct pnfs_layout_segment *
 409get_lseg(struct pnfs_layout_segment *lseg)
 410{
 411        return NULL;
 412}
 413
 414static inline void put_lseg(struct pnfs_layout_segment *lseg)
 415{
 416}
 417
 418static inline int pnfs_return_layout(struct inode *ino)
 419{
 420        return 0;
 421}
 422
 423static inline bool
 424pnfs_ld_layoutret_on_setattr(struct inode *inode)
 425{
 426        return false;
 427}
 428
 429static inline bool
 430pnfs_roc(struct inode *ino)
 431{
 432        return false;
 433}
 434
 435static inline void
 436pnfs_roc_release(struct inode *ino)
 437{
 438}
 439
 440static inline void
 441pnfs_roc_set_barrier(struct inode *ino, u32 barrier)
 442{
 443}
 444
 445static inline bool
 446pnfs_roc_drain(struct inode *ino, u32 *barrier)
 447{
 448        return false;
 449}
 450
 451static inline void set_pnfs_layoutdriver(struct nfs_server *s,
 452                                         const struct nfs_fh *mntfh, u32 id)
 453{
 454}
 455
 456static inline void unset_pnfs_layoutdriver(struct nfs_server *s)
 457{
 458}
 459
 460static inline void pnfs_pageio_init_read(struct nfs_pageio_descriptor *pgio, struct inode *inode,
 461                                         const struct nfs_pgio_completion_ops *compl_ops)
 462{
 463        nfs_pageio_init_read(pgio, inode, compl_ops);
 464}
 465
 466static inline void pnfs_pageio_init_write(struct nfs_pageio_descriptor *pgio, struct inode *inode, int ioflags,
 467                                          const struct nfs_pgio_completion_ops *compl_ops)
 468{
 469        nfs_pageio_init_write(pgio, inode, ioflags, compl_ops);
 470}
 471
 472static inline int
 473pnfs_commit_list(struct inode *inode, struct list_head *mds_pages, int how,
 474                 struct nfs_commit_info *cinfo)
 475{
 476        return PNFS_NOT_ATTEMPTED;
 477}
 478
 479static inline struct pnfs_ds_commit_info *
 480pnfs_get_ds_info(struct inode *inode)
 481{
 482        return NULL;
 483}
 484
 485static inline bool
 486pnfs_mark_request_commit(struct nfs_page *req, struct pnfs_layout_segment *lseg,
 487                         struct nfs_commit_info *cinfo)
 488{
 489        return false;
 490}
 491
 492static inline bool
 493pnfs_clear_request_commit(struct nfs_page *req, struct nfs_commit_info *cinfo)
 494{
 495        return false;
 496}
 497
 498static inline int
 499pnfs_scan_commit_lists(struct inode *inode, struct nfs_commit_info *cinfo,
 500                       int max)
 501{
 502        return 0;
 503}
 504
 505static inline void
 506pnfs_recover_commit_reqs(struct inode *inode, struct list_head *list,
 507                         struct nfs_commit_info *cinfo)
 508{
 509}
 510
 511static inline int pnfs_layoutcommit_inode(struct inode *inode, bool sync)
 512{
 513        return 0;
 514}
 515
 516static inline bool
 517pnfs_use_threshold(struct nfs4_threshold **dst, struct nfs4_threshold *src,
 518                   struct nfs_server *nfss)
 519{
 520        return false;
 521}
 522
 523static inline struct nfs4_threshold *pnfs_mdsthreshold_alloc(void)
 524{
 525        return NULL;
 526}
 527
 528#endif /* CONFIG_NFS_V4_1 */
 529
 530#endif /* FS_NFS_PNFS_H */
 531
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.