5370f1b9aa431f8cd356f0dbce7bdb2f377b34b7
[linux-2.6.git] / fs / nfs / pnfs.h
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_page.h>
34
35 enum {
36         NFS_LSEG_VALID = 0,     /* cleared when lseg is recalled/returned */
37         NFS_LSEG_ROC,           /* roc bit received from server */
38 };
39
40 struct pnfs_layout_segment {
41         struct list_head pls_list;
42         struct pnfs_layout_range pls_range;
43         atomic_t pls_refcount;
44         unsigned long pls_flags;
45         struct pnfs_layout_hdr *pls_layout;
46 };
47
48 enum pnfs_try_status {
49         PNFS_ATTEMPTED     = 0,
50         PNFS_NOT_ATTEMPTED = 1,
51 };
52
53 #ifdef CONFIG_NFS_V4_1
54
55 #define LAYOUT_NFSV4_1_MODULE_PREFIX "nfs-layouttype4"
56
57 enum {
58         NFS_LAYOUT_RO_FAILED = 0,       /* get ro layout failed stop trying */
59         NFS_LAYOUT_RW_FAILED,           /* get rw layout failed stop trying */
60         NFS_LAYOUT_BULK_RECALL,         /* bulk recall affecting layout */
61         NFS_LAYOUT_ROC,                 /* some lseg had roc bit set */
62         NFS_LAYOUT_DESTROYED,           /* no new use of layout allowed */
63 };
64
65 /* Per-layout driver specific registration structure */
66 struct pnfs_layoutdriver_type {
67         struct list_head pnfs_tblid;
68         const u32 id;
69         const char *name;
70         struct module *owner;
71         struct pnfs_layout_segment * (*alloc_lseg) (struct pnfs_layout_hdr *layoutid, struct nfs4_layoutget_res *lgr);
72         void (*free_lseg) (struct pnfs_layout_segment *lseg);
73
74         /* test for nfs page cache coalescing */
75         int (*pg_test)(struct nfs_pageio_descriptor *, struct nfs_page *, struct nfs_page *);
76
77         /* Returns true if layoutdriver wants to divert this request to
78          * driver's commit routine.
79          */
80         bool (*mark_pnfs_commit)(struct pnfs_layout_segment *lseg);
81         struct list_head * (*choose_commit_list) (struct nfs_page *req);
82         int (*commit_pagelist)(struct inode *inode, struct list_head *mds_pages, int how);
83
84         /*
85          * Return PNFS_ATTEMPTED to indicate the layout code has attempted
86          * I/O, else return PNFS_NOT_ATTEMPTED to fall back to normal NFS
87          */
88         enum pnfs_try_status (*read_pagelist) (struct nfs_read_data *nfs_data);
89         enum pnfs_try_status (*write_pagelist) (struct nfs_write_data *nfs_data, int how);
90 };
91
92 struct pnfs_layout_hdr {
93         atomic_t                plh_refcount;
94         struct list_head        plh_layouts;   /* other client layouts */
95         struct list_head        plh_bulk_recall; /* clnt list of bulk recalls */
96         struct list_head        plh_segs;      /* layout segments list */
97         nfs4_stateid            plh_stateid;
98         atomic_t                plh_outstanding; /* number of RPCs out */
99         unsigned long           plh_block_lgets; /* block LAYOUTGET if >0 */
100         u32                     plh_barrier; /* ignore lower seqids */
101         unsigned long           plh_flags;
102         struct inode            *plh_inode;
103 };
104
105 struct pnfs_device {
106         struct nfs4_deviceid dev_id;
107         unsigned int  layout_type;
108         unsigned int  mincount;
109         struct page **pages;
110         void          *area;
111         unsigned int  pgbase;
112         unsigned int  pglen;
113 };
114
115 extern int pnfs_register_layoutdriver(struct pnfs_layoutdriver_type *);
116 extern void pnfs_unregister_layoutdriver(struct pnfs_layoutdriver_type *);
117
118 /* nfs4proc.c */
119 extern int nfs4_proc_getdeviceinfo(struct nfs_server *server,
120                                    struct pnfs_device *dev);
121 extern int nfs4_proc_layoutget(struct nfs4_layoutget *lgp);
122
123 /* pnfs.c */
124 void get_layout_hdr(struct pnfs_layout_hdr *lo);
125 void put_lseg(struct pnfs_layout_segment *lseg);
126 struct pnfs_layout_segment *
127 pnfs_update_layout(struct inode *ino, struct nfs_open_context *ctx,
128                    enum pnfs_iomode access_type);
129 void set_pnfs_layoutdriver(struct nfs_server *, u32 id);
130 void unset_pnfs_layoutdriver(struct nfs_server *);
131 enum pnfs_try_status pnfs_try_to_write_data(struct nfs_write_data *,
132                                              const struct rpc_call_ops *, int);
133 enum pnfs_try_status pnfs_try_to_read_data(struct nfs_read_data *,
134                                             const struct rpc_call_ops *);
135 void pnfs_pageio_init_read(struct nfs_pageio_descriptor *, struct inode *);
136 void pnfs_pageio_init_write(struct nfs_pageio_descriptor *, struct inode *);
137 int pnfs_layout_process(struct nfs4_layoutget *lgp);
138 void pnfs_free_lseg_list(struct list_head *tmp_list);
139 void pnfs_destroy_layout(struct nfs_inode *);
140 void pnfs_destroy_all_layouts(struct nfs_client *);
141 void put_layout_hdr(struct pnfs_layout_hdr *lo);
142 void pnfs_set_layout_stateid(struct pnfs_layout_hdr *lo,
143                              const nfs4_stateid *new,
144                              bool update_barrier);
145 int pnfs_choose_layoutget_stateid(nfs4_stateid *dst,
146                                   struct pnfs_layout_hdr *lo,
147                                   struct nfs4_state *open_state);
148 int mark_matching_lsegs_invalid(struct pnfs_layout_hdr *lo,
149                                 struct list_head *tmp_list,
150                                 u32 iomode);
151 bool pnfs_roc(struct inode *ino);
152 void pnfs_roc_release(struct inode *ino);
153 void pnfs_roc_set_barrier(struct inode *ino, u32 barrier);
154 bool pnfs_roc_drain(struct inode *ino, u32 *barrier);
155
156
157 static inline int lo_fail_bit(u32 iomode)
158 {
159         return iomode == IOMODE_RW ?
160                          NFS_LAYOUT_RW_FAILED : NFS_LAYOUT_RO_FAILED;
161 }
162
163 static inline struct pnfs_layout_segment *
164 get_lseg(struct pnfs_layout_segment *lseg)
165 {
166         if (lseg) {
167                 atomic_inc(&lseg->pls_refcount);
168                 smp_mb__after_atomic_inc();
169         }
170         return lseg;
171 }
172
173 /* Return true if a layout driver is being used for this mountpoint */
174 static inline int pnfs_enabled_sb(struct nfs_server *nfss)
175 {
176         return nfss->pnfs_curr_ld != NULL;
177 }
178
179 static inline void
180 pnfs_mark_request_commit(struct nfs_page *req, struct pnfs_layout_segment *lseg)
181 {
182         if (lseg) {
183                 struct pnfs_layoutdriver_type *ld;
184
185                 ld = NFS_SERVER(req->wb_page->mapping->host)->pnfs_curr_ld;
186                 if (ld->mark_pnfs_commit && ld->mark_pnfs_commit(lseg)) {
187                         set_bit(PG_PNFS_COMMIT, &req->wb_flags);
188                         req->wb_commit_lseg = get_lseg(lseg);
189                 }
190         }
191 }
192
193 static inline int
194 pnfs_commit_list(struct inode *inode, struct list_head *mds_pages, int how)
195 {
196         if (!test_and_clear_bit(NFS_INO_PNFS_COMMIT, &NFS_I(inode)->flags))
197                 return PNFS_NOT_ATTEMPTED;
198         return NFS_SERVER(inode)->pnfs_curr_ld->commit_pagelist(inode, mds_pages, how);
199 }
200
201 static inline struct list_head *
202 pnfs_choose_commit_list(struct nfs_page *req, struct list_head *mds)
203 {
204         struct list_head *rv;
205
206         if (test_and_clear_bit(PG_PNFS_COMMIT, &req->wb_flags)) {
207                 struct inode *inode = req->wb_commit_lseg->pls_layout->plh_inode;
208
209                 set_bit(NFS_INO_PNFS_COMMIT, &NFS_I(inode)->flags);
210                 rv = NFS_SERVER(inode)->pnfs_curr_ld->choose_commit_list(req);
211                 /* matched by ref taken when PG_PNFS_COMMIT is set */
212                 put_lseg(req->wb_commit_lseg);
213         } else
214                 rv = mds;
215         return rv;
216 }
217
218 static inline void pnfs_clear_request_commit(struct nfs_page *req)
219 {
220         if (test_and_clear_bit(PG_PNFS_COMMIT, &req->wb_flags))
221                 put_lseg(req->wb_commit_lseg);
222 }
223
224 #else  /* CONFIG_NFS_V4_1 */
225
226 static inline void pnfs_destroy_all_layouts(struct nfs_client *clp)
227 {
228 }
229
230 static inline void pnfs_destroy_layout(struct nfs_inode *nfsi)
231 {
232 }
233
234 static inline struct pnfs_layout_segment *
235 get_lseg(struct pnfs_layout_segment *lseg)
236 {
237         return NULL;
238 }
239
240 static inline void put_lseg(struct pnfs_layout_segment *lseg)
241 {
242 }
243
244 static inline struct pnfs_layout_segment *
245 pnfs_update_layout(struct inode *ino, struct nfs_open_context *ctx,
246                    enum pnfs_iomode access_type)
247 {
248         return NULL;
249 }
250
251 static inline enum pnfs_try_status
252 pnfs_try_to_read_data(struct nfs_read_data *data,
253                       const struct rpc_call_ops *call_ops)
254 {
255         return PNFS_NOT_ATTEMPTED;
256 }
257
258 static inline enum pnfs_try_status
259 pnfs_try_to_write_data(struct nfs_write_data *data,
260                        const struct rpc_call_ops *call_ops, int how)
261 {
262         return PNFS_NOT_ATTEMPTED;
263 }
264
265 static inline bool
266 pnfs_roc(struct inode *ino)
267 {
268         return false;
269 }
270
271 static inline void
272 pnfs_roc_release(struct inode *ino)
273 {
274 }
275
276 static inline void
277 pnfs_roc_set_barrier(struct inode *ino, u32 barrier)
278 {
279 }
280
281 static inline bool
282 pnfs_roc_drain(struct inode *ino, u32 *barrier)
283 {
284         return false;
285 }
286
287 static inline void set_pnfs_layoutdriver(struct nfs_server *s, u32 id)
288 {
289 }
290
291 static inline void unset_pnfs_layoutdriver(struct nfs_server *s)
292 {
293 }
294
295 static inline void
296 pnfs_pageio_init_read(struct nfs_pageio_descriptor *pgio, struct inode *ino)
297 {
298         pgio->pg_test = NULL;
299 }
300
301 static inline void
302 pnfs_pageio_init_write(struct nfs_pageio_descriptor *pgio, struct inode *ino)
303 {
304         pgio->pg_test = NULL;
305 }
306
307 static inline void
308 pnfs_mark_request_commit(struct nfs_page *req, struct pnfs_layout_segment *lseg)
309 {
310 }
311
312 static inline int
313 pnfs_commit_list(struct inode *inode, struct list_head *mds_pages, int how)
314 {
315         return PNFS_NOT_ATTEMPTED;
316 }
317
318 static inline struct list_head *
319 pnfs_choose_commit_list(struct nfs_page *req, struct list_head *mds)
320 {
321         return mds;
322 }
323
324 static inline void pnfs_clear_request_commit(struct nfs_page *req)
325 {
326 }
327
328 #endif /* CONFIG_NFS_V4_1 */
329
330 #endif /* FS_NFS_PNFS_H */