Whamcloud - gitweb
16a869ff94c28c3d748bc8935b3847f3f0ec0d75
[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 lov_stripe_md;
50 struct lustre_md;
51 struct obd_capa;
52 struct obd_device;
53 struct obd_export;
54 struct page;
55
56 blkcnt_t dirty_cnt(struct inode *inode);
57
58 int cl_glimpse_size0(struct inode *inode, int agl);
59 int cl_glimpse_lock(const struct lu_env *env, struct cl_io *io,
60                     struct inode *inode, struct cl_object *clob, int agl);
61
62 static inline int cl_glimpse_size(struct inode *inode)
63 {
64         return cl_glimpse_size0(inode, 0);
65 }
66
67 static inline int cl_agl(struct inode *inode)
68 {
69         return cl_glimpse_size0(inode, 1);
70 }
71
72 /**
73  * Locking policy for setattr.
74  */
75 enum ccc_setattr_lock_type {
76         /** Locking is done by server */
77         SETATTR_NOLOCK,
78         /** Extent lock is enqueued */
79         SETATTR_EXTENT_LOCK,
80         /** Existing local extent lock is used */
81         SETATTR_MATCH_LOCK
82 };
83
84 enum vvp_io_subtype {
85         /** normal IO */
86         IO_NORMAL,
87         /** io started from splice_{read|write} */
88         IO_SPLICE,
89 };
90
91 /**
92  * IO state private to VVP layer.
93  */
94 struct vvp_io {
95         /** super class */
96         struct cl_io_slice     vui_cl;
97         struct cl_io_lock_link vui_link;
98         /**
99          * I/O vector information to or from which read/write is going.
100          */
101         struct iovec *vui_iov;
102         unsigned long vui_nrsegs;
103         /**
104          * Total iov count for left IO.
105          */
106         unsigned long vui_tot_nrsegs;
107         /**
108          * Old length for iov that was truncated partially.
109          */
110         size_t vui_iov_olen;
111         /**
112          * Total size for the left IO.
113          */
114         size_t vui_tot_count;
115
116         union {
117                 struct vvp_fault_io {
118                         /**
119                          * Inode modification time that is checked across DLM
120                          * lock request.
121                          */
122                         time_t                   ft_mtime;
123                         struct vm_area_struct   *ft_vma;
124                         /**
125                          *  locked page returned from vvp_io
126                          */
127                         struct page             *ft_vmpage;
128                         /**
129                          * kernel fault info
130                          */
131                         struct vm_fault         *ft_vmf;
132                         /**
133                          * fault API used bitflags for return code.
134                          */
135                         unsigned int             ft_flags;
136                         /**
137                          * check that flags are from filemap_fault
138                          */
139                         bool                     ft_flags_valid;
140                 } fault;
141                 struct {
142                         enum ccc_setattr_lock_type vui_local_lock;
143                 } setattr;
144                 struct {
145                         struct pipe_inode_info  *vui_pipe;
146                         unsigned int             vui_flags;
147                 } splice;
148                 struct {
149                         struct cl_page_list vui_queue;
150                         unsigned long vui_written;
151                         int vui_from;
152                         int vui_to;
153                 } write;
154         } u;
155
156         enum vvp_io_subtype     vui_io_subtype;
157
158         /**
159          * Layout version when this IO is initialized
160          */
161         __u32                   vui_layout_gen;
162         /**
163         * File descriptor against which IO is done.
164         */
165         struct ll_file_data     *vui_fd;
166         struct kiocb            *vui_iocb;
167
168         /* Readahead state. */
169         pgoff_t vui_ra_start;
170         pgoff_t vui_ra_count;
171         /* Set when vui_ra_{start,count} have been initialized. */
172         bool            vui_ra_valid;
173 };
174
175 extern struct lu_context_key ccc_key;
176 extern struct lu_context_key vvp_session_key;
177
178 extern struct kmem_cache *vvp_lock_kmem;
179 extern struct kmem_cache *vvp_object_kmem;
180 extern struct kmem_cache *vvp_req_kmem;
181
182 struct ccc_thread_info {
183         struct cl_lock          cti_lock;
184         struct cl_lock_descr    cti_descr;
185         struct cl_io            cti_io;
186         struct cl_attr          cti_attr;
187 };
188
189 static inline struct ccc_thread_info *ccc_env_info(const struct lu_env *env)
190 {
191         struct ccc_thread_info      *info;
192
193         info = lu_context_key_get(&env->le_ctx, &ccc_key);
194         LASSERT(info != NULL);
195
196         return info;
197 }
198
199 static inline struct cl_lock *ccc_env_lock(const struct lu_env *env)
200 {
201         struct cl_lock *lock = &ccc_env_info(env)->cti_lock;
202
203         memset(lock, 0, sizeof(*lock));
204
205         return lock;
206 }
207
208 static inline struct cl_attr *ccc_env_thread_attr(const struct lu_env *env)
209 {
210         struct cl_attr *attr = &ccc_env_info(env)->cti_attr;
211
212         memset(attr, 0, sizeof(*attr));
213
214         return attr;
215 }
216
217 static inline struct cl_io *ccc_env_thread_io(const struct lu_env *env)
218 {
219         struct cl_io *io = &ccc_env_info(env)->cti_io;
220
221         memset(io, 0, sizeof(*io));
222
223         return io;
224 }
225
226 struct vvp_session {
227         struct vvp_io cs_ios;
228 };
229
230 static inline struct vvp_session *vvp_env_session(const struct lu_env *env)
231 {
232         struct vvp_session *ses;
233
234         ses = lu_context_key_get(env->le_ses, &vvp_session_key);
235         LASSERT(ses != NULL);
236
237         return ses;
238 }
239
240 static inline struct vvp_io *vvp_env_io(const struct lu_env *env)
241 {
242         return &vvp_env_session(env)->cs_ios;
243 }
244
245 /**
246  * ccc-private object state.
247  */
248 struct vvp_object {
249         struct cl_object_header vob_header;
250         struct cl_object        vob_cl;
251         struct inode           *vob_inode;
252
253         /**
254          * Number of transient pages.  This is no longer protected by i_sem,
255          * and needs to be atomic.  This is not actually used for anything,
256          * and can probably be removed.
257          */
258         atomic_t                vob_transient_pages;
259         /**
260          * Number of outstanding mmaps on this file.
261          *
262          * \see ll_vm_open(), ll_vm_close().
263          */
264         atomic_t                vob_mmap_cnt;
265
266         /**
267          * various flags
268          * vob_discard_page_warned
269          *     if pages belonging to this object are discarded when a client
270          * is evicted, some debug info will be printed, this flag will be set
271          * during processing the first discarded page, then avoid flooding
272          * debug message for lots of discarded pages.
273          *
274          * \see ll_dirty_page_discard_warn.
275          */
276         unsigned int            vob_discard_page_warned:1;
277 };
278
279 /**
280  * VVP-private page state.
281  */
282 struct vvp_page {
283         struct cl_page_slice vpg_cl;
284         unsigned        vpg_defer_uptodate:1,
285                         vpg_ra_used:1;
286         /** VM page */
287         struct page     *vpg_page;
288 };
289
290 static inline struct vvp_page *cl2vvp_page(const struct cl_page_slice *slice)
291 {
292         return container_of(slice, struct vvp_page, vpg_cl);
293 }
294
295 static inline pgoff_t vvp_index(struct vvp_page *vpg)
296 {
297         return vpg->vpg_cl.cpl_index;
298 }
299
300 struct vvp_device {
301         struct cl_device    vdv_cl;
302         struct super_block *vdv_sb;
303         struct cl_device   *vdv_next;
304 };
305
306 struct vvp_lock {
307         struct cl_lock_slice vlk_cl;
308 };
309
310 struct vvp_req {
311         struct cl_req_slice vrq_cl;
312 };
313
314 void *ccc_key_init(const struct lu_context *ctx, struct lu_context_key *key);
315 void ccc_key_fini(const struct lu_context *ctx, struct lu_context_key *key,
316                   void *data);
317
318 void ccc_umount(const struct lu_env *env, struct cl_device *dev);
319 int ccc_global_init(struct lu_device_type *device_type);
320 void ccc_global_fini(struct lu_device_type *device_type);
321
322 static inline struct lu_device *vvp2lu_dev(struct vvp_device *vdv)
323 {
324         return &vdv->vdv_cl.cd_lu_dev;
325 }
326
327 static inline struct vvp_device *lu2vvp_dev(const struct lu_device *d)
328 {
329         return container_of0(d, struct vvp_device, vdv_cl.cd_lu_dev);
330 }
331
332 static inline struct vvp_device *cl2vvp_dev(const struct cl_device *d)
333 {
334         return container_of0(d, struct vvp_device, vdv_cl);
335 }
336
337 static inline struct vvp_object *cl2vvp(const struct cl_object *obj)
338 {
339         return container_of0(obj, struct vvp_object, vob_cl);
340 }
341
342 static inline struct vvp_object *lu2vvp(const struct lu_object *obj)
343 {
344         return container_of0(obj, struct vvp_object, vob_cl.co_lu);
345 }
346
347 static inline struct inode *vvp_object_inode(const struct cl_object *obj)
348 {
349         return cl2vvp(obj)->vob_inode;
350 }
351
352 int vvp_object_invariant(const struct cl_object *obj);
353 struct vvp_object *cl_inode2vvp(struct inode *inode);
354
355 static inline struct page *cl2vm_page(const struct cl_page_slice *slice)
356 {
357         return cl2vvp_page(slice)->vpg_page;
358 }
359
360 static inline struct vvp_lock *cl2vvp_lock(const struct cl_lock_slice *slice)
361 {
362         return container_of(slice, struct vvp_lock, vlk_cl);
363 }
364
365 int cl_setattr_ost(struct inode *inode, const struct iattr *attr,
366                    struct obd_capa *capa);
367
368 int cl_file_inode_init(struct inode *inode, struct lustre_md *md);
369 void cl_inode_fini(struct inode *inode);
370 int cl_local_size(struct inode *inode);
371
372 __u16 ll_dirent_type_get(struct lu_dirent *ent);
373 __u64 cl_fid_build_ino(const struct lu_fid *fid, int api32);
374 __u32 cl_fid_build_gen(const struct lu_fid *fid);
375
376 #ifdef CONFIG_LUSTRE_DEBUG_EXPENSIVE_CHECK
377 # define CLOBINVRNT(env, clob, expr)                                    \
378         do {                                                            \
379                 if (unlikely(!(expr))) {                                \
380                         LU_OBJECT_DEBUG(D_ERROR, (env), &(clob)->co_lu, \
381                                         #expr "\n");                    \
382                         LINVRNT(0);                                     \
383                 }                                                       \
384         } while (0)
385 #else /* !CONFIG_LUSTRE_DEBUG_EXPENSIVE_CHECK */
386 # define CLOBINVRNT(env, clob, expr)                                    \
387         ((void)sizeof(env), (void)sizeof(clob), (void)sizeof !!(expr))
388 #endif /* CONFIG_LUSTRE_DEBUG_EXPENSIVE_CHECK */
389
390 int cl_init_ea_size(struct obd_export *md_exp, struct obd_export *dt_exp);
391 int cl_ocd_update(struct obd_device *host,
392                   struct obd_device *watched,
393                   enum obd_notify_event ev, void *owner, void *data);
394
395 struct ccc_grouplock {
396         struct lu_env   *cg_env;
397         struct cl_io    *cg_io;
398         struct cl_lock  *cg_lock;
399         unsigned long    cg_gid;
400 };
401
402 int cl_get_grouplock(struct cl_object *obj, unsigned long gid, int nonblock,
403                      struct ccc_grouplock *cg);
404 void cl_put_grouplock(struct ccc_grouplock *cg);
405
406 /**
407  * New interfaces to get and put lov_stripe_md from lov layer. This violates
408  * layering because lov_stripe_md is supposed to be a private data in lov.
409  *
410  * NB: If you find you have to use these interfaces for your new code, please
411  * think about it again. These interfaces may be removed in the future for
412  * better layering. */
413 struct lov_stripe_md *lov_lsm_get(struct cl_object *clobj);
414 void lov_lsm_put(struct cl_object *clobj, struct lov_stripe_md *lsm);
415 int lov_read_and_clear_async_rc(struct cl_object *clob);
416
417 struct lov_stripe_md *ccc_inode_lsm_get(struct inode *inode);
418 void ccc_inode_lsm_put(struct inode *inode, struct lov_stripe_md *lsm);
419
420 enum {
421         LUSTRE_OPC_MKDIR        = 0,
422         LUSTRE_OPC_SYMLINK      = 1,
423         LUSTRE_OPC_MKNOD        = 2,
424         LUSTRE_OPC_CREATE       = 3,
425         LUSTRE_OPC_ANY          = 5,
426 };
427
428 int vvp_io_init(const struct lu_env *env, struct cl_object *obj,
429                 struct cl_io *io);
430 int vvp_io_write_commit(const struct lu_env *env, struct cl_io *io);
431 int vvp_lock_init(const struct lu_env *env, struct cl_object *obj,
432                   struct cl_lock *lock, const struct cl_io *io);
433 int vvp_page_init(const struct lu_env *env, struct cl_object *obj,
434                   struct cl_page *page, pgoff_t index);
435 int vvp_req_init(const struct lu_env *env, struct cl_device *dev,
436                  struct cl_req *req);
437 struct lu_object *vvp_object_alloc(const struct lu_env *env,
438                                    const struct lu_object_header *hdr,
439                                    struct lu_device *dev);
440
441 extern const struct file_operations vvp_dump_pgcache_file_ops;
442
443 #endif /* VVP_INTERNAL_H */