Whamcloud - gitweb
LU-10308 misc: update Intel copyright messages for 2017
[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_NOT_FLR;
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_NOT_FLR;
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 lovsub_page {
467         struct cl_page_slice lsb_cl;
468 };
469
470
471 struct lov_thread_info {
472         struct cl_object_conf   lti_stripe_conf;
473         struct lu_fid           lti_fid;
474         struct ost_lvb          lti_lvb;
475         struct cl_2queue        lti_cl2q;
476         struct cl_page_list     lti_plist;
477         wait_queue_t            lti_waiter;
478 };
479
480 /**
481  * State that lov_io maintains for every sub-io.
482  */
483 struct lov_io_sub {
484         /**
485          * Linkage into a list (hanging off lov_io::lis_subios)
486          */
487         struct list_head        sub_list;
488         /**
489          * Linkage into a list (hanging off lov_io::lis_active) of all
490          * sub-io's active for the current IO iteration.
491          */
492         struct list_head        sub_linkage;
493         unsigned int            sub_subio_index;
494         /**
495          * sub-io for a stripe. Ideally sub-io's can be stopped and resumed
496          * independently, with lov acting as a scheduler to maximize overall
497          * throughput.
498          */
499         struct cl_io            sub_io;
500         /**
501          * environment, in which sub-io executes.
502          */
503         struct lu_env           *sub_env;
504         /**
505          * environment's refcheck.
506          *
507          * \see cl_env_get()
508          */
509         __u16                   sub_refcheck;
510         __u16                   sub_reenter;
511 };
512
513 /**
514  * IO state private for LOV.
515  */
516 struct lov_io {
517         /** super-class */
518         struct cl_io_slice lis_cl;
519
520         /**
521          * FLR: index to lo_mirrors. Valid only if lov_is_flr() returns true.
522          *
523          * The mirror index of this io. Preserved over cl_io_init()
524          * if io->ci_ndelay_tried is greater than zero.
525          */
526         int                     lis_mirror_index;
527         /**
528          * FLR: the layout gen when lis_mirror_index was cached. The
529          * mirror index makes sense only when the layout gen doesn't
530          * change.
531          */
532         int                     lis_mirror_layout_gen;
533
534         /**
535          * fields below this will be initialized in lov_io_init().
536          */
537         unsigned                lis_preserved;
538
539         /**
540          * Pointer to the object slice. This is a duplicate of
541          * lov_io::lis_cl::cis_object.
542          */
543         struct lov_object *lis_object;
544         /**
545          * Original end-of-io position for this IO, set by the upper layer as
546          * cl_io::u::ci_rw::pos + cl_io::u::ci_rw::count. lov remembers this,
547          * changes pos and count to fit IO into a single stripe and uses saved
548          * value to determine when IO iterations have to stop.
549          *
550          * This is used only for CIT_READ and CIT_WRITE io's.
551          */
552         loff_t             lis_io_endpos;
553
554         /**
555          * starting position within a file, for the current io loop iteration
556          * (stripe), used by ci_io_loop().
557          */
558         loff_t                  lis_pos;
559         /**
560          * end position with in a file, for the current stripe io. This is
561          * exclusive (i.e., next offset after last byte affected by io).
562          */
563         loff_t                  lis_endpos;
564         int                     lis_nr_subios;
565
566         /**
567          * the index of ls_single_subio in ls_subios array
568          */
569         int                     lis_single_subio_index;
570         struct lov_io_sub       lis_single_subio;
571
572         /**
573          * List of active sub-io's. Active sub-io's are under the range
574          * of [lis_pos, lis_endpos).
575          */
576         struct list_head        lis_active;
577         /**
578          * All sub-io's created in this lov_io.
579          */
580         struct list_head        lis_subios;
581
582 };
583
584 struct lov_session {
585         struct lov_io          ls_io;
586         struct lov_sublock_env ls_subenv;
587 };
588
589 extern struct lu_device_type lov_device_type;
590 extern struct lu_device_type lovsub_device_type;
591
592 extern struct lu_context_key lov_key;
593 extern struct lu_context_key lov_session_key;
594
595 extern struct kmem_cache *lov_lock_kmem;
596 extern struct kmem_cache *lov_object_kmem;
597 extern struct kmem_cache *lov_thread_kmem;
598 extern struct kmem_cache *lov_session_kmem;
599
600 extern struct kmem_cache *lovsub_object_kmem;
601
602 int   lov_object_init     (const struct lu_env *env, struct lu_object *obj,
603                            const struct lu_object_conf *conf);
604 int   lovsub_object_init  (const struct lu_env *env, struct lu_object *obj,
605                            const struct lu_object_conf *conf);
606 int   lov_lock_init       (const struct lu_env *env, struct cl_object *obj,
607                            struct cl_lock *lock, const struct cl_io *io);
608 int   lov_io_init         (const struct lu_env *env, struct cl_object *obj,
609                            struct cl_io *io);
610
611 int   lov_lock_init_composite(const struct lu_env *env, struct cl_object *obj,
612                            struct cl_lock *lock, const struct cl_io *io);
613 int   lov_lock_init_empty (const struct lu_env *env, struct cl_object *obj,
614                            struct cl_lock *lock, const struct cl_io *io);
615 int   lov_io_init_composite(const struct lu_env *env, struct cl_object *obj,
616                            struct cl_io *io);
617 int   lov_io_init_empty   (const struct lu_env *env, struct cl_object *obj,
618                            struct cl_io *io);
619 int   lov_io_init_released(const struct lu_env *env, struct cl_object *obj,
620                            struct cl_io *io);
621
622 struct lov_io_sub *lov_sub_get(const struct lu_env *env, struct lov_io *lio,
623                                int stripe);
624
625 int   lov_page_init       (const struct lu_env *env, struct cl_object *ob,
626                            struct cl_page *page, pgoff_t index);
627 int   lovsub_page_init    (const struct lu_env *env, struct cl_object *ob,
628                            struct cl_page *page, pgoff_t index);
629 int   lov_page_init_empty (const struct lu_env *env, struct cl_object *obj,
630                            struct cl_page *page, pgoff_t index);
631 int   lov_page_init_composite(const struct lu_env *env, struct cl_object *obj,
632                            struct cl_page *page, pgoff_t index);
633 struct lu_object *lov_object_alloc   (const struct lu_env *env,
634                                       const struct lu_object_header *hdr,
635                                       struct lu_device *dev);
636 struct lu_object *lovsub_object_alloc(const struct lu_env *env,
637                                       const struct lu_object_header *hdr,
638                                       struct lu_device *dev);
639
640 struct lov_stripe_md *lov_lsm_addref(struct lov_object *lov);
641 int lov_page_stripe(const struct cl_page *page);
642 bool lov_page_is_empty(const struct cl_page *page);
643 int lov_lsm_entry(const struct lov_stripe_md *lsm, __u64 offset);
644 int lov_io_layout_at(struct lov_io *lio, __u64 offset);
645
646 #define lov_foreach_target(lov, var)                    \
647         for (var = 0; var < lov_targets_nr(lov); ++var)
648
649 static inline struct lu_extent *lov_io_extent(struct lov_io *io, int i)
650 {
651         return &lov_lse(io->lis_object, i)->lsme_extent;
652 }
653
654 /**
655  * For layout entries within @ext.
656  */
657 #define lov_foreach_io_layout(ind, lio, ext)                            \
658         for (ind = lov_io_layout_at(lio, (ext)->e_start);               \
659              ind >= 0 &&                                                \
660              lu_extent_is_overlapped(lov_io_extent(lio, ind), ext);     \
661              ind = lov_io_layout_at(lio, lov_io_extent(lio, ind)->e_end))
662
663 /*****************************************************************************
664  *
665  * Type conversions.
666  *
667  * Accessors.
668  *
669  */
670
671 static inline struct lov_session *lov_env_session(const struct lu_env *env)
672 {
673         struct lov_session *ses;
674
675         ses = lu_context_key_get(env->le_ses, &lov_session_key);
676         LASSERT(ses != NULL);
677         return ses;
678 }
679
680 static inline struct lov_io *lov_env_io(const struct lu_env *env)
681 {
682         return &lov_env_session(env)->ls_io;
683 }
684
685 static inline int lov_is_object(const struct lu_object *obj)
686 {
687         return obj->lo_dev->ld_type == &lov_device_type;
688 }
689
690 static inline int lovsub_is_object(const struct lu_object *obj)
691 {
692         return obj->lo_dev->ld_type == &lovsub_device_type;
693 }
694
695 static inline struct lu_device *lov2lu_dev(struct lov_device *lov)
696 {
697         return &lov->ld_cl.cd_lu_dev;
698 }
699
700 static inline struct lov_device *lu2lov_dev(const struct lu_device *d)
701 {
702         LINVRNT(d->ld_type == &lov_device_type);
703         return container_of0(d, struct lov_device, ld_cl.cd_lu_dev);
704 }
705
706 static inline struct cl_device *lovsub2cl_dev(struct lovsub_device *lovsub)
707 {
708         return &lovsub->acid_cl;
709 }
710
711 static inline struct lu_device *lovsub2lu_dev(struct lovsub_device *lovsub)
712 {
713         return &lovsub2cl_dev(lovsub)->cd_lu_dev;
714 }
715
716 static inline struct lovsub_device *lu2lovsub_dev(const struct lu_device *d)
717 {
718         LINVRNT(d->ld_type == &lovsub_device_type);
719         return container_of0(d, struct lovsub_device, acid_cl.cd_lu_dev);
720 }
721
722 static inline struct lovsub_device *cl2lovsub_dev(const struct cl_device *d)
723 {
724         LINVRNT(d->cd_lu_dev.ld_type == &lovsub_device_type);
725         return container_of0(d, struct lovsub_device, acid_cl);
726 }
727
728 static inline struct lu_object *lov2lu(struct lov_object *lov)
729 {
730         return &lov->lo_cl.co_lu;
731 }
732
733 static inline struct cl_object *lov2cl(struct lov_object *lov)
734 {
735         return &lov->lo_cl;
736 }
737
738 static inline struct lov_object *lu2lov(const struct lu_object *obj)
739 {
740         LINVRNT(lov_is_object(obj));
741         return container_of0(obj, struct lov_object, lo_cl.co_lu);
742 }
743
744 static inline struct lov_object *cl2lov(const struct cl_object *obj)
745 {
746         LINVRNT(lov_is_object(&obj->co_lu));
747         return container_of0(obj, struct lov_object, lo_cl);
748 }
749
750 static inline struct lu_object *lovsub2lu(struct lovsub_object *los)
751 {
752         return &los->lso_cl.co_lu;
753 }
754
755 static inline struct cl_object *lovsub2cl(struct lovsub_object *los)
756 {
757         return &los->lso_cl;
758 }
759
760 static inline struct lovsub_object *cl2lovsub(const struct cl_object *obj)
761 {
762         LINVRNT(lovsub_is_object(&obj->co_lu));
763         return container_of0(obj, struct lovsub_object, lso_cl);
764 }
765
766 static inline struct lovsub_object *lu2lovsub(const struct lu_object *obj)
767 {
768         LINVRNT(lovsub_is_object(obj));
769         return container_of0(obj, struct lovsub_object, lso_cl.co_lu);
770 }
771
772 static inline struct lov_lock *cl2lov_lock(const struct cl_lock_slice *slice)
773 {
774         LINVRNT(lov_is_object(&slice->cls_obj->co_lu));
775         return container_of(slice, struct lov_lock, lls_cl);
776 }
777
778 static inline struct lov_page *cl2lov_page(const struct cl_page_slice *slice)
779 {
780         LINVRNT(lov_is_object(&slice->cpl_obj->co_lu));
781         return container_of0(slice, struct lov_page, lps_cl);
782 }
783
784 static inline struct lovsub_page *
785 cl2lovsub_page(const struct cl_page_slice *slice)
786 {
787         LINVRNT(lovsub_is_object(&slice->cpl_obj->co_lu));
788         return container_of0(slice, struct lovsub_page, lsb_cl);
789 }
790
791 static inline struct lov_io *cl2lov_io(const struct lu_env *env,
792                                 const struct cl_io_slice *ios)
793 {
794         struct lov_io *lio;
795
796         lio = container_of(ios, struct lov_io, lis_cl);
797         LASSERT(lio == lov_env_io(env));
798         return lio;
799 }
800
801 static inline int lov_targets_nr(const struct lov_device *lov)
802 {
803         return lov->ld_lov->desc.ld_tgt_count;
804 }
805
806 static inline struct lov_thread_info *lov_env_info(const struct lu_env *env)
807 {
808         struct lov_thread_info *info;
809
810         info = lu_context_key_get(&env->le_ctx, &lov_key);
811         LASSERT(info != NULL);
812         return info;
813 }
814
815 /* lov_pack.c */
816 int lov_getstripe(const struct lu_env *env, struct lov_object *obj,
817                   struct lov_stripe_md *lsm, struct lov_user_md __user *lump,
818                   size_t size);
819
820 /** @} lov */
821
822 #endif