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