Whamcloud - gitweb
LU-9906 clio: use pagevec_release for many pages
[fs/lustre-release.git] / lustre / lov / lov_cl_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.gnu.org/licenses/gpl-2.0.html
19  *
20  * GPL HEADER END
21  */
22 /*
23  * Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
24  * Use is subject to license terms.
25  *
26  * Copyright (c) 2012, 2017, Intel Corporation.
27  */
28 /*
29  * This file is part of Lustre, http://www.lustre.org/
30  * Lustre is a trademark of Sun Microsystems, Inc.
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 interfaces of LOV layer.
37  *
38  *   Author: Nikita Danilov <nikita.danilov@sun.com>
39  *   Author: Jinshan Xiong <jinshan.xiong@intel.com>
40  */
41
42 #ifndef LOV_CL_INTERNAL_H
43 #define LOV_CL_INTERNAL_H
44
45 #include <libcfs/libcfs.h>
46 #include <obd.h>
47 #include <cl_object.h>
48 #include "lov_internal.h"
49
50 /** \defgroup lov lov
51  * Logical object volume layer. This layer implements data striping (raid0).
52  *
53  * At the lov layer top-entity (object, page, lock, io) is connected to one or
54  * more sub-entities: top-object, representing a file is connected to a set of
55  * sub-objects, each representing a stripe, file-level top-lock is connected
56  * to a set of per-stripe sub-locks, top-page is connected to a (single)
57  * sub-page, and a top-level IO is connected to a set of (potentially
58  * concurrent) sub-IO's.
59  *
60  * Sub-object, sub-page, and sub-io have well-defined top-object and top-page
61  * respectively, while a single sub-lock can be part of multiple top-locks.
62  *
63  * Reference counting models are different for different types of entities:
64  *
65  *     - top-object keeps a reference to its sub-objects, and destroys them
66  *       when it is destroyed.
67  *
68  *     - top-page keeps a reference to its sub-page, and destroys it when it
69  *       is destroyed.
70  *
71  *     - IO's are not reference counted.
72  *
73  * To implement a connection between top and sub entities, lov layer is split
74  * into two pieces: lov ("upper half"), and lovsub ("bottom half"), both
75  * implementing full set of cl-interfaces. For example, top-object has vvp and
76  * lov layers, and it's sub-object has lovsub and osc layers. lovsub layer is
77  * used to track child-parent relationship.
78  *
79  * @{
80  */
81
82 struct lovsub_device;
83 struct lovsub_object;
84
85 enum lov_device_flags {
86         LOV_DEV_INITIALIZED = 1 << 0
87 };
88
89 /*
90  * Upper half.
91  */
92
93 /* Data-on-MDT array item in lov_device::ld_md_tgts[] */
94 struct lovdom_device {
95         struct cl_device        *ldm_mdc;
96         int                      ldm_idx;
97 };
98
99 struct lov_device {
100         /*
101          * XXX Locking of lov-private data is missing.
102          */
103         struct cl_device          ld_cl;
104         struct lov_obd           *ld_lov;
105         /** size of lov_device::ld_target[] array */
106         __u32                     ld_target_nr;
107         struct lovsub_device    **ld_target;
108         __u32                     ld_flags;
109
110         /* Data-on-MDT devices */
111         __u32                     ld_md_tgts_nr;
112         struct lovdom_device     *ld_md_tgts;
113         struct obd_device        *ld_lmv;
114         /* LU site for subdevices */
115         struct lu_site            ld_site;
116 };
117
118 /**
119  * Layout type.
120  */
121 enum lov_layout_type {
122         LLT_EMPTY,      /** empty file without body (mknod + truncate) */
123         LLT_RELEASED,   /** file with no objects (data in HSM) */
124         LLT_COMP,       /** support composite layout */
125         LLT_NR
126 };
127
128 static inline char *llt2str(enum lov_layout_type llt)
129 {
130         switch (llt) {
131         case LLT_EMPTY:
132                 return "EMPTY";
133         case LLT_RELEASED:
134                 return "RELEASED";
135         case LLT_COMP:
136                 return "COMPOSITE";
137         case LLT_NR:
138                 LBUG();
139         }
140         LBUG();
141         return "";
142 }
143
144 /**
145  * Return lov_layout_entry_type associated with a given composite layout
146  * entry.
147  */
148 static inline __u32 lov_entry_type(struct lov_stripe_md_entry *lsme)
149 {
150         if ((lov_pattern(lsme->lsme_pattern) == LOV_PATTERN_RAID0) ||
151             (lov_pattern(lsme->lsme_pattern) == LOV_PATTERN_MDT))
152                 return lov_pattern(lsme->lsme_pattern);
153         return 0;
154 }
155
156 struct lov_layout_entry;
157 struct lov_object;
158 struct lov_lock_sub;
159
160 struct lov_comp_layout_entry_ops {
161         int (*lco_init)(const struct lu_env *env, struct lov_device *dev,
162                         struct lov_object *lov, unsigned int index,
163                         const struct cl_object_conf *conf,
164                         struct lov_layout_entry *lle);
165         void (*lco_fini)(const struct lu_env *env,
166                          struct lov_layout_entry *lle);
167         int  (*lco_getattr)(const struct lu_env *env, struct lov_object *obj,
168                             unsigned int index, struct lov_layout_entry *lle,
169                             struct cl_attr **attr);
170 };
171
172 struct lov_layout_raid0 {
173         unsigned               lo_nr;
174         /**
175          * When this is true, lov_object::lo_attr contains
176          * valid up to date attributes for a top-level
177          * object. This field is reset to 0 when attributes of
178          * any sub-object change.
179          */
180         bool                   lo_attr_valid;
181         /**
182          * Array of sub-objects. Allocated when top-object is
183          * created (lov_init_raid0()).
184          *
185          * Top-object is a strict master of its sub-objects:
186          * it is created before them, and outlives its
187          * children (this later is necessary so that basic
188          * functions like cl_object_top() always
189          * work). Top-object keeps a reference on every
190          * sub-object.
191          *
192          * When top-object is destroyed (lov_delete_raid0())
193          * it releases its reference to a sub-object and waits
194          * until the latter is finally destroyed.
195          */
196         struct lovsub_object **lo_sub;
197         /**
198          * protect lo_sub
199          */
200         spinlock_t              lo_sub_lock;
201         /**
202          * Cached object attribute, built from sub-object
203          * attributes.
204          */
205         struct cl_attr         lo_attr;
206 };
207
208 struct lov_layout_dom {
209         /* keep this always at first place so DOM layout entry
210          * can be addressed also as RAID0 after initialization.
211          */
212         struct lov_layout_raid0 lo_dom_r0;
213         struct lovsub_object *lo_dom;
214         struct lov_oinfo *lo_loi;
215 };
216
217 struct lov_layout_entry {
218         __u32                           lle_type;
219         unsigned int                    lle_valid:1;
220         struct lu_extent                *lle_extent;
221         struct lov_stripe_md_entry      *lle_lsme;
222         struct lov_comp_layout_entry_ops *lle_comp_ops;
223         union {
224                 struct lov_layout_raid0 lle_raid0;
225                 struct lov_layout_dom   lle_dom;
226         };
227 };
228
229 struct lov_mirror_entry {
230         unsigned short  lre_mirror_id;
231         unsigned short  lre_preferred:1,
232                         lre_stale:1,    /* set if any components is stale */
233                         lre_valid:1;    /* set if at least one of components
234                                          * in this mirror is valid */
235         unsigned short  lre_start;      /* index to lo_entries, start index of
236                                          * this mirror */
237         unsigned short  lre_end;        /* end index of this mirror */
238 };
239
240 /**
241  * lov-specific file state.
242  *
243  * lov object has particular layout type, determining how top-object is built
244  * on top of sub-objects. Layout type can change dynamically. When this
245  * happens, lov_object::lo_type_guard semaphore is taken in exclusive mode,
246  * all state pertaining to the old layout type is destroyed, and new state is
247  * constructed. All object methods take said semaphore in the shared mode,
248  * providing serialization against transition between layout types.
249  *
250  * To avoid multiple `if' or `switch' statements, selecting behavior for the
251  * current layout type, object methods perform double-dispatch, invoking
252  * function corresponding to the current layout type.
253  */
254 struct lov_object {
255         struct cl_object        lo_cl;
256         /**
257          * Serializes object operations with transitions between layout types.
258          *
259          * This semaphore is taken in shared mode by all object methods, and
260          * is taken in exclusive mode when object type is changed.
261          *
262          * \see lov_object::lo_type
263          */
264         struct rw_semaphore     lo_type_guard;
265         /**
266          * Type of an object. Protected by lov_object::lo_type_guard.
267          */
268         enum lov_layout_type    lo_type;
269         /**
270          * True if layout is invalid. This bit is cleared when layout lock
271          * is lost.
272          */
273         bool                    lo_layout_invalid;
274         /**
275          * How many IOs are on going on this object. Layout can be changed
276          * only if there is no active IO.
277          */
278         atomic_t               lo_active_ios;
279         /**
280          * Waitq - wait for no one else is using lo_lsm
281          */
282         wait_queue_head_t       lo_waitq;
283         /**
284          * Layout metadata. NULL if empty layout.
285          */
286         struct lov_stripe_md  *lo_lsm;
287
288         union lov_layout_state {
289                 struct lov_layout_state_empty {
290                 } empty;
291                 struct lov_layout_state_released {
292                 } released;
293                 struct lov_layout_composite {
294                         /**
295                          * flags of lov_comp_md_v1::lcm_flags. Mainly used
296                          * by FLR.
297                          */
298                         uint32_t        lo_flags;
299                         /**
300                          * For FLR: index of preferred mirror to read.
301                          * Preferred mirror is initialized by the preferred
302                          * bit of lsme. It can be changed when the preferred
303                          * is inaccessible.
304                          * In order to make lov_lsm_entry() return the same
305                          * mirror in the same IO context, it's only possible
306                          * to change the preferred mirror when the
307                          * lo_active_ios reaches zero.
308                          */
309                         int             lo_preferred_mirror;
310                         /**
311                          * For FLR: the lock to protect access to
312                          * lo_preferred_mirror.
313                          */
314                         spinlock_t      lo_write_lock;
315                         /**
316                          * For FLR: Number of (valid) mirrors.
317                          */
318                         unsigned        lo_mirror_count;
319                         struct lov_mirror_entry *lo_mirrors;
320                         /**
321                          * Current entry count of lo_entries, include
322                          * invalid entries.
323                          */
324                         unsigned int    lo_entry_count;
325                         struct lov_layout_entry *lo_entries;
326                 } composite;
327         } u;
328         /**
329          * Thread that acquired lov_object::lo_type_guard in an exclusive
330          * mode.
331          */
332         struct task_struct            *lo_owner;
333 };
334
335 static inline struct lov_layout_raid0 *lov_r0(struct lov_object *lov, int i)
336 {
337         LASSERT(lov->lo_type == LLT_COMP);
338         LASSERTF(i < lov->u.composite.lo_entry_count,
339                  "entry %d entry_count %d", i, lov->u.composite.lo_entry_count);
340
341         return &lov->u.composite.lo_entries[i].lle_raid0;
342 }
343
344 static inline struct lov_stripe_md_entry *lov_lse(struct lov_object *lov, int i)
345 {
346         LASSERT(lov->lo_lsm != NULL);
347         LASSERT(i < lov->lo_lsm->lsm_entry_count);
348
349         return lov->lo_lsm->lsm_entries[i];
350 }
351
352 static inline unsigned lov_flr_state(const struct lov_object *lov)
353 {
354         if (lov->lo_type != LLT_COMP)
355                 return LCM_FL_NONE;
356
357         return lov->u.composite.lo_flags & LCM_FL_FLR_MASK;
358 }
359
360 static inline bool lov_is_flr(const struct lov_object *lov)
361 {
362         return lov_flr_state(lov) != LCM_FL_NONE;
363 }
364
365 static inline struct lov_layout_entry *lov_entry(struct lov_object *lov, int i)
366 {
367         LASSERT(lov->lo_type == LLT_COMP);
368         LASSERTF(i < lov->u.composite.lo_entry_count,
369                  "entry %d entry_count %d", i, lov->u.composite.lo_entry_count);
370
371         return &lov->u.composite.lo_entries[i];
372 }
373
374 #define lov_for_layout_entry(lov, entry, start, end)                    \
375         for (entry = lov_entry(lov, start);                             \
376              entry <= lov_entry(lov, end); entry++)
377
378 #define lov_foreach_layout_entry(lov, entry)                            \
379         lov_for_layout_entry(lov, entry, 0,                             \
380                              (lov)->u.composite.lo_entry_count - 1)
381
382 #define lov_foreach_mirror_layout_entry(lov, entry, lre)                \
383         lov_for_layout_entry(lov, entry, (lre)->lre_start, (lre)->lre_end)
384
385 static inline struct lov_mirror_entry *
386 lov_mirror_entry(struct lov_object *lov, int i)
387 {
388         LASSERT(i < lov->u.composite.lo_mirror_count);
389         return &lov->u.composite.lo_mirrors[i];
390 }
391
392 #define lov_foreach_mirror_entry(lov, lre)                              \
393         for (lre = lov_mirror_entry(lov, 0);                            \
394              lre <= lov_mirror_entry(lov,                               \
395                                 lov->u.composite.lo_mirror_count - 1);  \
396              lre++)
397
398 static inline unsigned
399 lov_layout_entry_index(struct lov_object *lov, struct lov_layout_entry *entry)
400 {
401         struct lov_layout_entry *first = &lov->u.composite.lo_entries[0];
402         unsigned index = (unsigned)(entry - first);
403
404         LASSERT(entry >= first);
405         LASSERT(index < lov->u.composite.lo_entry_count);
406
407         return index;
408 }
409
410 /**
411  * State lov_lock keeps for each sub-lock.
412  */
413 struct lov_lock_sub {
414         /** sub-lock itself */
415         struct cl_lock          sub_lock;
416         /** Set if the sublock has ever been enqueued, meaning it may
417          * hold resources of underlying layers */
418         unsigned int            sub_is_enqueued:1,
419                                 sub_initialized:1;
420         int                     sub_index;
421 };
422
423 /**
424  * lov-specific lock state.
425  */
426 struct lov_lock {
427         struct cl_lock_slice    lls_cl;
428         /** Number of sub-locks in this lock */
429         int                     lls_nr;
430         /** sublock array */
431         struct lov_lock_sub     lls_sub[0];
432 };
433
434 struct lov_page {
435         struct cl_page_slice    lps_cl;
436         /** layout_entry + stripe index, composed using lov_comp_index() */
437         unsigned int            lps_index;
438         /* the layout gen when this page was created */
439         __u32                   lps_layout_gen;
440 };
441
442 /*
443  * Bottom half.
444  */
445
446 struct lovsub_device {
447         struct cl_device   acid_cl;
448         struct cl_device  *acid_next;
449 };
450
451 struct lovsub_object {
452         struct cl_object_header lso_header;
453         struct cl_object        lso_cl;
454         struct lov_object      *lso_super;
455         int                     lso_index;
456 };
457
458 /**
459  * Describe the environment settings for sublocks.
460  */
461 struct lov_sublock_env {
462         const struct lu_env *lse_env;
463         struct cl_io        *lse_io;
464 };
465
466 struct lov_thread_info {
467         struct cl_object_conf   lti_stripe_conf;
468         struct lu_fid           lti_fid;
469         struct ost_lvb          lti_lvb;
470         struct cl_2queue        lti_cl2q;
471         struct cl_page_list     lti_plist;
472         wait_queue_entry_t      lti_waiter;
473 };
474
475 /**
476  * State that lov_io maintains for every sub-io.
477  */
478 struct lov_io_sub {
479         /**
480          * Linkage into a list (hanging off lov_io::lis_subios)
481          */
482         struct list_head        sub_list;
483         /**
484          * Linkage into a list (hanging off lov_io::lis_active) of all
485          * sub-io's active for the current IO iteration.
486          */
487         struct list_head        sub_linkage;
488         unsigned int            sub_subio_index;
489         /**
490          * sub-io for a stripe. Ideally sub-io's can be stopped and resumed
491          * independently, with lov acting as a scheduler to maximize overall
492          * throughput.
493          */
494         struct cl_io            sub_io;
495         /**
496          * environment, in which sub-io executes.
497          */
498         struct lu_env           *sub_env;
499         /**
500          * environment's refcheck.
501          *
502          * \see cl_env_get()
503          */
504         __u16                   sub_refcheck;
505         __u16                   sub_reenter;
506 };
507
508 /**
509  * IO state private for LOV.
510  */
511 struct lov_io {
512         /** super-class */
513         struct cl_io_slice lis_cl;
514
515         /**
516          * FLR: index to lo_mirrors. Valid only if lov_is_flr() returns true.
517          *
518          * The mirror index of this io. Preserved over cl_io_init()
519          * if io->ci_ndelay_tried is greater than zero.
520          */
521         int                     lis_mirror_index;
522         /**
523          * FLR: the layout gen when lis_mirror_index was cached. The
524          * mirror index makes sense only when the layout gen doesn't
525          * change.
526          */
527         int                     lis_mirror_layout_gen;
528
529         /**
530          * fields below this will be initialized in lov_io_init().
531          */
532         unsigned                lis_preserved;
533
534         /**
535          * Pointer to the object slice. This is a duplicate of
536          * lov_io::lis_cl::cis_object.
537          */
538         struct lov_object *lis_object;
539         /**
540          * Original end-of-io position for this IO, set by the upper layer as
541          * cl_io::u::ci_rw::pos + cl_io::u::ci_rw::count. lov remembers this,
542          * changes pos and count to fit IO into a single stripe and uses saved
543          * value to determine when IO iterations have to stop.
544          *
545          * This is used only for CIT_READ and CIT_WRITE io's.
546          */
547         loff_t             lis_io_endpos;
548
549         /**
550          * starting position within a file, for the current io loop iteration
551          * (stripe), used by ci_io_loop().
552          */
553         loff_t                  lis_pos;
554         /**
555          * end position with in a file, for the current stripe io. This is
556          * exclusive (i.e., next offset after last byte affected by io).
557          */
558         loff_t                  lis_endpos;
559         int                     lis_nr_subios;
560
561         /**
562          * the index of ls_single_subio in ls_subios array
563          */
564         int                     lis_single_subio_index;
565         struct lov_io_sub       lis_single_subio;
566
567         /**
568          * List of active sub-io's. Active sub-io's are under the range
569          * of [lis_pos, lis_endpos).
570          */
571         struct list_head        lis_active;
572         /**
573          * All sub-io's created in this lov_io.
574          */
575         struct list_head        lis_subios;
576
577 };
578
579 struct lov_session {
580         struct lov_io          ls_io;
581         struct lov_sublock_env ls_subenv;
582 };
583
584 extern struct lu_device_type lov_device_type;
585 extern struct lu_device_type lovsub_device_type;
586
587 extern struct lu_context_key lov_key;
588 extern struct lu_context_key lov_session_key;
589
590 extern struct kmem_cache *lov_lock_kmem;
591 extern struct kmem_cache *lov_object_kmem;
592 extern struct kmem_cache *lov_thread_kmem;
593 extern struct kmem_cache *lov_session_kmem;
594
595 extern struct kmem_cache *lovsub_object_kmem;
596
597 int   lov_object_init     (const struct lu_env *env, struct lu_object *obj,
598                            const struct lu_object_conf *conf);
599 int   lovsub_object_init  (const struct lu_env *env, struct lu_object *obj,
600                            const struct lu_object_conf *conf);
601 int   lov_lock_init       (const struct lu_env *env, struct cl_object *obj,
602                            struct cl_lock *lock, const struct cl_io *io);
603 int   lov_io_init         (const struct lu_env *env, struct cl_object *obj,
604                            struct cl_io *io);
605
606 int   lov_lock_init_composite(const struct lu_env *env, struct cl_object *obj,
607                            struct cl_lock *lock, const struct cl_io *io);
608 int   lov_lock_init_empty (const struct lu_env *env, struct cl_object *obj,
609                            struct cl_lock *lock, const struct cl_io *io);
610 int   lov_io_init_composite(const struct lu_env *env, struct cl_object *obj,
611                            struct cl_io *io);
612 int   lov_io_init_empty   (const struct lu_env *env, struct cl_object *obj,
613                            struct cl_io *io);
614 int   lov_io_init_released(const struct lu_env *env, struct cl_object *obj,
615                            struct cl_io *io);
616
617 struct lov_io_sub *lov_sub_get(const struct lu_env *env, struct lov_io *lio,
618                                int stripe);
619
620 int   lov_page_init       (const struct lu_env *env, struct cl_object *ob,
621                            struct cl_page *page, pgoff_t index);
622 int   lov_page_init_empty (const struct lu_env *env, struct cl_object *obj,
623                            struct cl_page *page, pgoff_t index);
624 int   lov_page_init_composite(const struct lu_env *env, struct cl_object *obj,
625                            struct cl_page *page, pgoff_t index);
626 struct lu_object *lov_object_alloc   (const struct lu_env *env,
627                                       const struct lu_object_header *hdr,
628                                       struct lu_device *dev);
629 struct lu_object *lovsub_object_alloc(const struct lu_env *env,
630                                       const struct lu_object_header *hdr,
631                                       struct lu_device *dev);
632
633 struct lov_stripe_md *lov_lsm_addref(struct lov_object *lov);
634 int lov_page_stripe(const struct cl_page *page);
635 bool lov_page_is_empty(const struct cl_page *page);
636 int lov_lsm_entry(const struct lov_stripe_md *lsm, __u64 offset);
637 int lov_io_layout_at(struct lov_io *lio, __u64 offset);
638
639 #define lov_foreach_target(lov, var)                    \
640         for (var = 0; var < lov_targets_nr(lov); ++var)
641
642 static inline struct lu_extent *lov_io_extent(struct lov_io *io, int i)
643 {
644         return &lov_lse(io->lis_object, i)->lsme_extent;
645 }
646
647 /**
648  * For layout entries within @ext.
649  */
650 #define lov_foreach_io_layout(ind, lio, ext)                            \
651         for (ind = lov_io_layout_at(lio, (ext)->e_start);               \
652              ind >= 0 &&                                                \
653              lu_extent_is_overlapped(lov_io_extent(lio, ind), ext);     \
654              ind = lov_io_layout_at(lio, lov_io_extent(lio, ind)->e_end))
655
656 /*****************************************************************************
657  *
658  * Type conversions.
659  *
660  * Accessors.
661  *
662  */
663
664 static inline struct lov_session *lov_env_session(const struct lu_env *env)
665 {
666         struct lov_session *ses;
667
668         ses = lu_context_key_get(env->le_ses, &lov_session_key);
669         LASSERT(ses != NULL);
670         return ses;
671 }
672
673 static inline struct lov_io *lov_env_io(const struct lu_env *env)
674 {
675         return &lov_env_session(env)->ls_io;
676 }
677
678 static inline int lov_is_object(const struct lu_object *obj)
679 {
680         return obj->lo_dev->ld_type == &lov_device_type;
681 }
682
683 static inline int lovsub_is_object(const struct lu_object *obj)
684 {
685         return obj->lo_dev->ld_type == &lovsub_device_type;
686 }
687
688 static inline struct lu_device *lov2lu_dev(struct lov_device *lov)
689 {
690         return &lov->ld_cl.cd_lu_dev;
691 }
692
693 static inline struct lov_device *lu2lov_dev(const struct lu_device *d)
694 {
695         LINVRNT(d->ld_type == &lov_device_type);
696         return container_of0(d, struct lov_device, ld_cl.cd_lu_dev);
697 }
698
699 static inline struct cl_device *lovsub2cl_dev(struct lovsub_device *lovsub)
700 {
701         return &lovsub->acid_cl;
702 }
703
704 static inline struct lu_device *lovsub2lu_dev(struct lovsub_device *lovsub)
705 {
706         return &lovsub2cl_dev(lovsub)->cd_lu_dev;
707 }
708
709 static inline struct lovsub_device *lu2lovsub_dev(const struct lu_device *d)
710 {
711         LINVRNT(d->ld_type == &lovsub_device_type);
712         return container_of0(d, struct lovsub_device, acid_cl.cd_lu_dev);
713 }
714
715 static inline struct lovsub_device *cl2lovsub_dev(const struct cl_device *d)
716 {
717         LINVRNT(d->cd_lu_dev.ld_type == &lovsub_device_type);
718         return container_of0(d, struct lovsub_device, acid_cl);
719 }
720
721 static inline struct lu_object *lov2lu(struct lov_object *lov)
722 {
723         return &lov->lo_cl.co_lu;
724 }
725
726 static inline struct cl_object *lov2cl(struct lov_object *lov)
727 {
728         return &lov->lo_cl;
729 }
730
731 static inline struct lov_object *lu2lov(const struct lu_object *obj)
732 {
733         LINVRNT(lov_is_object(obj));
734         return container_of0(obj, struct lov_object, lo_cl.co_lu);
735 }
736
737 static inline struct lov_object *cl2lov(const struct cl_object *obj)
738 {
739         LINVRNT(lov_is_object(&obj->co_lu));
740         return container_of0(obj, struct lov_object, lo_cl);
741 }
742
743 static inline struct lu_object *lovsub2lu(struct lovsub_object *los)
744 {
745         return &los->lso_cl.co_lu;
746 }
747
748 static inline struct cl_object *lovsub2cl(struct lovsub_object *los)
749 {
750         return &los->lso_cl;
751 }
752
753 static inline struct lovsub_object *cl2lovsub(const struct cl_object *obj)
754 {
755         LINVRNT(lovsub_is_object(&obj->co_lu));
756         return container_of0(obj, struct lovsub_object, lso_cl);
757 }
758
759 static inline struct lovsub_object *lu2lovsub(const struct lu_object *obj)
760 {
761         LINVRNT(lovsub_is_object(obj));
762         return container_of0(obj, struct lovsub_object, lso_cl.co_lu);
763 }
764
765 static inline struct lov_lock *cl2lov_lock(const struct cl_lock_slice *slice)
766 {
767         LINVRNT(lov_is_object(&slice->cls_obj->co_lu));
768         return container_of(slice, struct lov_lock, lls_cl);
769 }
770
771 static inline struct lov_page *cl2lov_page(const struct cl_page_slice *slice)
772 {
773         LINVRNT(lov_is_object(&slice->cpl_obj->co_lu));
774         return container_of0(slice, struct lov_page, lps_cl);
775 }
776
777 static inline struct lov_io *cl2lov_io(const struct lu_env *env,
778                                 const struct cl_io_slice *ios)
779 {
780         struct lov_io *lio;
781
782         lio = container_of(ios, struct lov_io, lis_cl);
783         LASSERT(lio == lov_env_io(env));
784         return lio;
785 }
786
787 static inline int lov_targets_nr(const struct lov_device *lov)
788 {
789         return lov->ld_lov->desc.ld_tgt_count;
790 }
791
792 static inline struct lov_thread_info *lov_env_info(const struct lu_env *env)
793 {
794         struct lov_thread_info *info;
795
796         info = lu_context_key_get(&env->le_ctx, &lov_key);
797         LASSERT(info != NULL);
798         return info;
799 }
800
801 /* lov_pack.c */
802 int lov_getstripe(const struct lu_env *env, struct lov_object *obj,
803                   struct lov_stripe_md *lsm, struct lov_user_md __user *lump,
804                   size_t size);
805
806 /** @} lov */
807
808 #endif