← Back to branch summary

~ubuntu-branches/ubuntu/quantal/linux-linaro-mx51/quantal

« back to all changes in this revision

Viewing changes to fs/nfs/pnfs.h

  • Committer: Package Import Robot
  • Author(s): John Rigby, John Rigby
  • Date: 2011-09-26 10:44:23 UTC
  • Revision ID: package-import@ubuntu.com-20110926104423-3o58a3c1bj7x00rs
Tags: 3.0.0-1007.9
https://launchpad.net/bugs/826021
[ John Rigby ]

Enable crypto modules and remove crypto-modules from
exclude-module files
LP: #826021

Show diffs side-by-side

added added

removed removed

Lines of Context:
fs/nfs/pnfs.h
30
30
#ifndef FS_NFS_PNFS_H
31
31
#define FS_NFS_PNFS_H
32
32
 
 
33
#include <linux/nfs_fs.h>
33
34
#include <linux/nfs_page.h>
34
35
 
35
36
enum {
36
37
        NFS_LSEG_VALID = 0,     /* cleared when lseg is recalled/returned */
37
38
        NFS_LSEG_ROC,           /* roc bit received from server */
 
39
        NFS_LSEG_LAYOUTCOMMIT,  /* layoutcommit bit set for layoutcommit */
38
40
};
39
41
 
40
42
struct pnfs_layout_segment {
41
43
        struct list_head pls_list;
 
44
        struct list_head pls_lc_list;
42
45
        struct pnfs_layout_range pls_range;
43
46
        atomic_t pls_refcount;
44
47
        unsigned long pls_flags;
45
48
        struct pnfs_layout_hdr *pls_layout;
46
 
        struct rpc_cred *pls_lc_cred; /* LAYOUTCOMMIT credential */
47
 
        loff_t pls_end_pos; /* LAYOUTCOMMIT write end */
48
49
};
49
50
 
50
51
enum pnfs_try_status {
64
65
        NFS_LAYOUT_DESTROYED,           /* no new use of layout allowed */
65
66
};
66
67
 
 
68
enum layoutdriver_policy_flags {
 
69
        /* Should the pNFS client commit and return the layout upon a setattr */
 
70
        PNFS_LAYOUTRET_ON_SETATTR       = 1 << 0,
 
71
};
 
72
 
 
73
struct nfs4_deviceid_node;
 
74
 
67
75
/* Per-layout driver specific registration structure */
68
76
struct pnfs_layoutdriver_type {
69
77
        struct list_head pnfs_tblid;
70
78
        const u32 id;
71
79
        const char *name;
72
80
        struct module *owner;
 
81
        unsigned flags;
 
82
 
 
83
        struct pnfs_layout_hdr * (*alloc_layout_hdr) (struct inode *inode, gfp_t gfp_flags);
 
84
        void (*free_layout_hdr) (struct pnfs_layout_hdr *);
 
85
 
73
86
        struct pnfs_layout_segment * (*alloc_lseg) (struct pnfs_layout_hdr *layoutid, struct nfs4_layoutget_res *lgr, gfp_t gfp_flags);
74
87
        void (*free_lseg) (struct pnfs_layout_segment *lseg);
75
88
 
76
89
        /* test for nfs page cache coalescing */
77
 
        int (*pg_test)(struct nfs_pageio_descriptor *, struct nfs_page *, struct nfs_page *);
 
90
        bool (*pg_test)(struct nfs_pageio_descriptor *, struct nfs_page *, struct nfs_page *);
78
91
 
79
92
        /* Returns true if layoutdriver wants to divert this request to
80
93
         * driver's commit routine.
89
102
         */
90
103
        enum pnfs_try_status (*read_pagelist) (struct nfs_read_data *nfs_data);
91
104
        enum pnfs_try_status (*write_pagelist) (struct nfs_write_data *nfs_data, int how);
 
105
 
 
106
        void (*free_deviceid_node) (struct nfs4_deviceid_node *);
 
107
 
 
108
        void (*encode_layoutreturn) (struct pnfs_layout_hdr *layoutid,
 
109
                                     struct xdr_stream *xdr,
 
110
                                     const struct nfs4_layoutreturn_args *args);
 
111
 
 
112
        void (*encode_layoutcommit) (struct pnfs_layout_hdr *layoutid,
 
113
                                     struct xdr_stream *xdr,
 
114
                                     const struct nfs4_layoutcommit_args *args);
92
115
};
93
116
 
94
117
struct pnfs_layout_hdr {
101
124
        unsigned long           plh_block_lgets; /* block LAYOUTGET if >0 */
102
125
        u32                     plh_barrier; /* ignore lower seqids */
103
126
        unsigned long           plh_flags;
 
127
        loff_t                  plh_lwb; /* last write byte for layoutcommit */
 
128
        struct rpc_cred         *plh_lc_cred; /* layoutcommit cred */
104
129
        struct inode            *plh_inode;
105
130
};
106
131
 
120
145
extern int nfs4_proc_getdeviceinfo(struct nfs_server *server,
121
146
                                   struct pnfs_device *dev);
122
147
extern int nfs4_proc_layoutget(struct nfs4_layoutget *lgp);
 
148
extern int nfs4_proc_layoutreturn(struct nfs4_layoutreturn *lrp);
123
149
 
124
150
/* pnfs.c */
125
151
void get_layout_hdr(struct pnfs_layout_hdr *lo);
126
152
void put_lseg(struct pnfs_layout_segment *lseg);
127
153
struct pnfs_layout_segment *
128
154
pnfs_update_layout(struct inode *ino, struct nfs_open_context *ctx,
129
 
                   enum pnfs_iomode access_type, gfp_t gfp_flags);
 
155
                   loff_t pos, u64 count, enum pnfs_iomode access_type,
 
156
                   gfp_t gfp_flags);
130
157
void set_pnfs_layoutdriver(struct nfs_server *, u32 id);
131
158
void unset_pnfs_layoutdriver(struct nfs_server *);
132
159
enum pnfs_try_status pnfs_try_to_write_data(struct nfs_write_data *,
133
160
                                             const struct rpc_call_ops *, int);
134
161
enum pnfs_try_status pnfs_try_to_read_data(struct nfs_read_data *,
135
162
                                            const struct rpc_call_ops *);
136
 
void pnfs_pageio_init_read(struct nfs_pageio_descriptor *, struct inode *);
137
 
void pnfs_pageio_init_write(struct nfs_pageio_descriptor *, struct inode *);
 
163
bool pnfs_generic_pg_test(struct nfs_pageio_descriptor *pgio, struct nfs_page *prev, struct nfs_page *req);
138
164
int pnfs_layout_process(struct nfs4_layoutget *lgp);
139
165
void pnfs_free_lseg_list(struct list_head *tmp_list);
140
166
void pnfs_destroy_layout(struct nfs_inode *);
148
174
                                  struct nfs4_state *open_state);
149
175
int mark_matching_lsegs_invalid(struct pnfs_layout_hdr *lo,
150
176
                                struct list_head *tmp_list,
151
 
                                u32 iomode);
 
177
                                struct pnfs_layout_range *recall_range);
152
178
bool pnfs_roc(struct inode *ino);
153
179
void pnfs_roc_release(struct inode *ino);
154
180
void pnfs_roc_set_barrier(struct inode *ino, u32 barrier);
155
181
bool pnfs_roc_drain(struct inode *ino, u32 *barrier);
156
182
void pnfs_set_layoutcommit(struct nfs_write_data *wdata);
157
183
int pnfs_layoutcommit_inode(struct inode *inode, bool sync);
 
184
int _pnfs_return_layout(struct inode *);
 
185
int pnfs_ld_write_done(struct nfs_write_data *);
 
186
int pnfs_ld_read_done(struct nfs_read_data *);
 
187
 
 
188
/* pnfs_dev.c */
 
189
struct nfs4_deviceid_node {
 
190
        struct hlist_node               node;
 
191
        struct hlist_node               tmpnode;
 
192
        const struct pnfs_layoutdriver_type *ld;
 
193
        const struct nfs_client         *nfs_client;
 
194
        struct nfs4_deviceid            deviceid;
 
195
        atomic_t                        ref;
 
196
};
 
197
 
 
198
void nfs4_print_deviceid(const struct nfs4_deviceid *dev_id);
 
199
struct nfs4_deviceid_node *nfs4_find_get_deviceid(const struct pnfs_layoutdriver_type *, const struct nfs_client *, const struct nfs4_deviceid *);
 
200
struct nfs4_deviceid_node *nfs4_unhash_put_deviceid(const struct pnfs_layoutdriver_type *, const struct nfs_client *, const struct nfs4_deviceid *);
 
201
void nfs4_delete_deviceid(const struct pnfs_layoutdriver_type *, const struct nfs_client *, const struct nfs4_deviceid *);
 
202
void nfs4_init_deviceid_node(struct nfs4_deviceid_node *,
 
203
                             const struct pnfs_layoutdriver_type *,
 
204
                             const struct nfs_client *,
 
205
                             const struct nfs4_deviceid *);
 
206
struct nfs4_deviceid_node *nfs4_insert_deviceid_node(struct nfs4_deviceid_node *);
 
207
bool nfs4_put_deviceid_node(struct nfs4_deviceid_node *);
 
208
void nfs4_deviceid_purge_client(const struct nfs_client *);
158
209
 
159
210
static inline int lo_fail_bit(u32 iomode)
160
211
{
223
274
                put_lseg(req->wb_commit_lseg);
224
275
}
225
276
 
 
277
/* Should the pNFS client commit and return the layout upon a setattr */
 
278
static inline bool
 
279
pnfs_ld_layoutret_on_setattr(struct inode *inode)
 
280
{
 
281
        if (!pnfs_enabled_sb(NFS_SERVER(inode)))
 
282
                return false;
 
283
        return NFS_SERVER(inode)->pnfs_curr_ld->flags &
 
284
                PNFS_LAYOUTRET_ON_SETATTR;
 
285
}
 
286
 
 
287
static inline int pnfs_return_layout(struct inode *ino)
 
288
{
 
289
        struct nfs_inode *nfsi = NFS_I(ino);
 
290
        struct nfs_server *nfss = NFS_SERVER(ino);
 
291
 
 
292
        if (pnfs_enabled_sb(nfss) && nfsi->layout)
 
293
                return _pnfs_return_layout(ino);
 
294
 
 
295
        return 0;
 
296
}
 
297
 
 
298
static inline void pnfs_pageio_init(struct nfs_pageio_descriptor *pgio,
 
299
                                    struct inode *inode)
 
300
{
 
301
        struct pnfs_layoutdriver_type *ld = NFS_SERVER(inode)->pnfs_curr_ld;
 
302
 
 
303
        if (ld)
 
304
                pgio->pg_test = ld->pg_test;
 
305
}
 
306
 
226
307
#else  /* CONFIG_NFS_V4_1 */
227
308
 
228
309
static inline void pnfs_destroy_all_layouts(struct nfs_client *clp)
245
326
 
246
327
static inline struct pnfs_layout_segment *
247
328
pnfs_update_layout(struct inode *ino, struct nfs_open_context *ctx,
248
 
                   enum pnfs_iomode access_type, gfp_t gfp_flags)
 
329
                   loff_t pos, u64 count, enum pnfs_iomode access_type,
 
330
                   gfp_t gfp_flags)
249
331
{
250
332
        return NULL;
251
333
}
264
346
        return PNFS_NOT_ATTEMPTED;
265
347
}
266
348
 
 
349
static inline int pnfs_return_layout(struct inode *ino)
 
350
{
 
351
        return 0;
 
352
}
 
353
 
 
354
static inline bool
 
355
pnfs_ld_layoutret_on_setattr(struct inode *inode)
 
356
{
 
357
        return false;
 
358
}
 
359
 
267
360
static inline bool
268
361
pnfs_roc(struct inode *ino)
269
362
{
294
387
{
295
388
}
296
389
 
297
 
static inline void
298
 
pnfs_pageio_init_read(struct nfs_pageio_descriptor *pgio, struct inode *ino)
299
 
{
300
 
        pgio->pg_test = NULL;
301
 
}
302
 
 
303
 
static inline void
304
 
pnfs_pageio_init_write(struct nfs_pageio_descriptor *pgio, struct inode *ino)
305
 
{
306
 
        pgio->pg_test = NULL;
 
390
static inline void pnfs_pageio_init(struct nfs_pageio_descriptor *pgio,
 
391
                                    struct inode *inode)
 
392
{
307
393
}
308
394
 
309
395
static inline void
331
417
{
332
418
        return 0;
333
419
}
 
420
 
 
421
static inline void nfs4_deviceid_purge_client(struct nfs_client *ncl)
 
422
{
 
423
}
334
424
#endif /* CONFIG_NFS_V4_1 */
335
425
 
336
426
#endif /* FS_NFS_PNFS_H */