Whamcloud - gitweb
LU-6260 llite: add support for new iter functionality
[fs/lustre-release.git] / lustre / llite / vvp_internal.h
1 /*
2  * GPL HEADER START
3  *
4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License version 2 only,
8  * as published by the Free Software Foundation.
9  *
10  * This program is distributed in the hope that it will be useful, but
11  * WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  * General Public License version 2 for more details (a copy is included
14  * in the LICENSE file that accompanied this code).
15  *
16  * You should have received a copy of the GNU General Public License
17  * version 2 along with this program; If not, see
18  * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
19  *
20  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
21  * CA 95054 USA or visit www.sun.com if you need additional information or
22  * have any questions.
23  *
24  * GPL HEADER END
25  */
26 /*
27  * Copyright (c) 2002, 2010, Oracle and/or its affiliates. All rights reserved.
28  * Use is subject to license terms.
29  *
30  * Copyright (c) 2013, 2014, Intel Corporation.
31  */
32 /*
33  * This file is part of Lustre, http://www.lustre.org/
34  * Lustre is a trademark of Sun Microsystems, Inc.
35  *
36  * Internal definitions for VVP layer.
37  *
38  *   Author: Nikita Danilov <nikita.danilov@sun.com>
39  */
40
41 #ifndef VVP_INTERNAL_H
42 #define VVP_INTERNAL_H
43
44 #include <lustre/lustre_idl.h>
45 #include <cl_object.h>
46
47 enum obd_notify_event;
48 struct inode;
49 struct lustre_md;
50 struct obd_device;
51 struct obd_export;
52 struct page;
53
54 enum vvp_io_subtype {
55         /** normal IO */
56         IO_NORMAL,
57         /** io started from splice_{read|write} */
58         IO_SPLICE,
59 };
60
61 /**
62  * IO state private to VVP layer.
63  */
64 struct vvp_io {
65         /** super class */
66         struct cl_io_slice     vui_cl;
67         struct cl_io_lock_link vui_link;
68         /**
69          * I/O vector information to or from which read/write is going.
70          */
71         struct iov_iter *vui_iter;
72 #ifndef HAVE_FILE_OPERATIONS_READ_WRITE_ITER
73         /**
74          * Total iov count for left IO.
75          */
76         unsigned long vui_tot_nrsegs;
77         /**
78          * Old length for iov that was truncated partially.
79          */
80         size_t vui_iov_olen;
81 #endif /* !HAVE_FILE_OPERATIONS_READ_WRITE_ITER */
82         /**
83          * Total size for the left IO.
84          */
85         size_t vui_tot_count;
86
87         union {
88                 struct vvp_fault_io {
89                         /**
90                          * Inode modification time that is checked across DLM
91                          * lock request.
92                          */
93                         time_t                   ft_mtime;
94                         struct vm_area_struct   *ft_vma;
95                         /**
96                          *  locked page returned from vvp_io
97                          */
98                         struct page             *ft_vmpage;
99                         /**
100                          * kernel fault info
101                          */
102                         struct vm_fault         *ft_vmf;
103                         /**
104                          * fault API used bitflags for return code.
105                          */
106                         unsigned int             ft_flags;
107                         /**
108                          * check that flags are from filemap_fault
109                          */
110                         bool                     ft_flags_valid;
111                 } fault;
112                 struct {
113                         struct pipe_inode_info  *vui_pipe;
114                         unsigned int             vui_flags;
115                 } splice;
116                 struct {
117                         struct cl_page_list vui_queue;
118                         unsigned long vui_written;
119                         int vui_from;
120                         int vui_to;
121                 } write;
122         } u;
123
124         enum vvp_io_subtype     vui_io_subtype;
125
126         /**
127          * Layout version when this IO is initialized
128          */
129         __u32                   vui_layout_gen;
130         /**
131         * File descriptor against which IO is done.
132         */
133         struct ll_file_data     *vui_fd;
134         struct kiocb            *vui_iocb;
135
136         /* Readahead state. */
137         pgoff_t vui_ra_start;
138         pgoff_t vui_ra_count;
139         /* Set when vui_ra_{start,count} have been initialized. */
140         bool            vui_ra_valid;
141 };
142
143 extern struct lu_device_type vvp_device_type;
144
145 extern struct lu_context_key vvp_session_key;
146 extern struct lu_context_key vvp_thread_key;
147
148 extern struct kmem_cache *vvp_lock_kmem;
149 extern struct kmem_cache *vvp_object_kmem;
150 extern struct kmem_cache *vvp_req_kmem;
151
152 struct vvp_thread_info {
153         struct cl_lock          vti_lock;
154         struct cl_lock_descr    vti_descr;
155         struct cl_io            vti_io;
156         struct cl_attr          vti_attr;
157 };
158
159 static inline struct vvp_thread_info *vvp_env_info(const struct lu_env *env)
160 {
161         struct vvp_thread_info *vti;
162
163         vti = lu_context_key_get(&env->le_ctx, &vvp_thread_key);
164         LASSERT(vti != NULL);
165
166         return vti;
167 }
168
169 static inline struct cl_lock *vvp_env_lock(const struct lu_env *env)
170 {
171         struct cl_lock *lock = &vvp_env_info(env)->vti_lock;
172
173         memset(lock, 0, sizeof(*lock));
174
175         return lock;
176 }
177
178 static inline struct cl_attr *vvp_env_thread_attr(const struct lu_env *env)
179 {
180         struct cl_attr *attr = &vvp_env_info(env)->vti_attr;
181
182         memset(attr, 0, sizeof(*attr));
183
184         return attr;
185 }
186
187 static inline struct cl_io *vvp_env_thread_io(const struct lu_env *env)
188 {
189         struct cl_io *io = &vvp_env_info(env)->vti_io;
190
191         memset(io, 0, sizeof(*io));
192
193         return io;
194 }
195
196 struct vvp_session {
197         struct vvp_io vs_ios;
198 };
199
200 static inline struct vvp_session *vvp_env_session(const struct lu_env *env)
201 {
202         struct vvp_session *ses;
203
204         ses = lu_context_key_get(env->le_ses, &vvp_session_key);
205         LASSERT(ses != NULL);
206
207         return ses;
208 }
209
210 static inline struct vvp_io *vvp_env_io(const struct lu_env *env)
211 {
212         return &vvp_env_session(env)->vs_ios;
213 }
214
215 /**
216  * VPP-private object state.
217  */
218 struct vvp_object {
219         struct cl_object_header vob_header;
220         struct cl_object        vob_cl;
221         struct inode           *vob_inode;
222
223         /**
224          * Number of transient pages.  This is no longer protected by i_sem,
225          * and needs to be atomic.  This is not actually used for anything,
226          * and can probably be removed.
227          */
228         atomic_t                vob_transient_pages;
229         /**
230          * Number of outstanding mmaps on this file.
231          *
232          * \see ll_vm_open(), ll_vm_close().
233          */
234         atomic_t                vob_mmap_cnt;
235
236         /**
237          * various flags
238          * vob_discard_page_warned
239          *     if pages belonging to this object are discarded when a client
240          * is evicted, some debug info will be printed, this flag will be set
241          * during processing the first discarded page, then avoid flooding
242          * debug message for lots of discarded pages.
243          *
244          * \see ll_dirty_page_discard_warn.
245          */
246         unsigned int            vob_discard_page_warned:1;
247 };
248
249 /**
250  * VVP-private page state.
251  */
252 struct vvp_page {
253         struct cl_page_slice vpg_cl;
254         unsigned        vpg_defer_uptodate:1,
255                         vpg_ra_used:1;
256         /** VM page */
257         struct page     *vpg_page;
258 };
259
260 static inline struct vvp_page *cl2vvp_page(const struct cl_page_slice *slice)
261 {
262         return container_of(slice, struct vvp_page, vpg_cl);
263 }
264
265 static inline pgoff_t vvp_index(struct vvp_page *vpg)
266 {
267         return vpg->vpg_cl.cpl_index;
268 }
269
270 struct vvp_device {
271         struct cl_device    vdv_cl;
272         struct super_block *vdv_sb;
273         struct cl_device   *vdv_next;
274 };
275
276 struct vvp_lock {
277         struct cl_lock_slice vlk_cl;
278 };
279
280 struct vvp_req {
281         struct cl_req_slice vrq_cl;
282 };
283
284 static inline struct lu_device *vvp2lu_dev(struct vvp_device *vdv)
285 {
286         return &vdv->vdv_cl.cd_lu_dev;
287 }
288
289 static inline struct vvp_device *lu2vvp_dev(const struct lu_device *d)
290 {
291         return container_of0(d, struct vvp_device, vdv_cl.cd_lu_dev);
292 }
293
294 static inline struct vvp_device *cl2vvp_dev(const struct cl_device *d)
295 {
296         return container_of0(d, struct vvp_device, vdv_cl);
297 }
298
299 static inline struct vvp_object *cl2vvp(const struct cl_object *obj)
300 {
301         return container_of0(obj, struct vvp_object, vob_cl);
302 }
303
304 static inline struct vvp_object *lu2vvp(const struct lu_object *obj)
305 {
306         return container_of0(obj, struct vvp_object, vob_cl.co_lu);
307 }
308
309 static inline struct inode *vvp_object_inode(const struct cl_object *obj)
310 {
311         return cl2vvp(obj)->vob_inode;
312 }
313
314 int vvp_object_invariant(const struct cl_object *obj);
315 struct vvp_object *cl_inode2vvp(struct inode *inode);
316
317 static inline struct page *cl2vm_page(const struct cl_page_slice *slice)
318 {
319         return cl2vvp_page(slice)->vpg_page;
320 }
321
322 static inline struct vvp_lock *cl2vvp_lock(const struct cl_lock_slice *slice)
323 {
324         return container_of(slice, struct vvp_lock, vlk_cl);
325 }
326
327 #ifdef CONFIG_LUSTRE_DEBUG_EXPENSIVE_CHECK
328 # define CLOBINVRNT(env, clob, expr)                                    \
329         do {                                                            \
330                 if (unlikely(!(expr))) {                                \
331                         LU_OBJECT_DEBUG(D_ERROR, (env), &(clob)->co_lu, \
332                                         #expr "\n");                    \
333                         LINVRNT(0);                                     \
334                 }                                                       \
335         } while (0)
336 #else /* !CONFIG_LUSTRE_DEBUG_EXPENSIVE_CHECK */
337 # define CLOBINVRNT(env, clob, expr)                                    \
338         ((void)sizeof(env), (void)sizeof(clob), (void)sizeof !!(expr))
339 #endif /* CONFIG_LUSTRE_DEBUG_EXPENSIVE_CHECK */
340
341 int lov_read_and_clear_async_rc(struct cl_object *clob);
342
343 int vvp_io_init(const struct lu_env *env, struct cl_object *obj,
344                 struct cl_io *io);
345 int vvp_io_write_commit(const struct lu_env *env, struct cl_io *io);
346 int vvp_lock_init(const struct lu_env *env, struct cl_object *obj,
347                   struct cl_lock *lock, const struct cl_io *io);
348 int vvp_page_init(const struct lu_env *env, struct cl_object *obj,
349                   struct cl_page *page, pgoff_t index);
350 int vvp_req_init(const struct lu_env *env, struct cl_device *dev,
351                  struct cl_req *req);
352 struct lu_object *vvp_object_alloc(const struct lu_env *env,
353                                    const struct lu_object_header *hdr,
354                                    struct lu_device *dev);
355
356 int vvp_global_init(void);
357 void vvp_global_fini(void);
358
359 extern const struct file_operations vvp_dump_pgcache_file_ops;
360
361 #endif /* VVP_INTERNAL_H */