Whamcloud - gitweb
3f73c71cd5c1ea8ca66a80b66dce8fa3245cdb1a
[fs/lustre-release.git] / lustre / lov / lov_ea.c
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) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
24  * Use is subject to license terms.
25  *
26  * Copyright (c) 2011, 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  * lustre/lov/lov_ea.c
33  *
34  * Author: Wang Di <wangdi@clusterfs.com>
35  */
36
37 #define DEBUG_SUBSYSTEM S_LOV
38
39 #include <linux/math64.h>
40 #include <linux/sort.h>
41 #include <libcfs/libcfs.h>
42
43 #include <obd_class.h>
44 #include "lov_internal.h"
45
46 static inline void
47 lu_extent_le_to_cpu(struct lu_extent *dst, const struct lu_extent *src)
48 {
49         dst->e_start = le64_to_cpu(src->e_start);
50         dst->e_end = le64_to_cpu(src->e_end);
51 }
52
53 /*
54  * Find minimum stripe maxbytes value.  For inactive or
55  * reconnecting targets use LUSTRE_EXT3_STRIPE_MAXBYTES.
56  */
57 static loff_t lov_tgt_maxbytes(struct lov_tgt_desc *tgt)
58 {
59         struct obd_import *imp;
60         loff_t maxbytes = LUSTRE_EXT3_STRIPE_MAXBYTES;
61
62         if (!tgt->ltd_active)
63                 return maxbytes;
64
65         imp = tgt->ltd_obd->u.cli.cl_import;
66         if (!imp)
67                 return maxbytes;
68
69         spin_lock(&imp->imp_lock);
70         if ((imp->imp_state == LUSTRE_IMP_FULL ||
71             imp->imp_state == LUSTRE_IMP_IDLE) &&
72             (imp->imp_connect_data.ocd_connect_flags & OBD_CONNECT_MAXBYTES) &&
73             imp->imp_connect_data.ocd_maxbytes > 0)
74                 maxbytes = imp->imp_connect_data.ocd_maxbytes;
75
76         spin_unlock(&imp->imp_lock);
77
78         return maxbytes;
79 }
80
81 static int lsm_lmm_verify_v1v3(struct lov_mds_md *lmm, size_t lmm_size,
82                                u16 stripe_count)
83 {
84         int rc = 0;
85
86         if (stripe_count > LOV_V1_INSANE_STRIPE_COUNT) {
87                 rc = -EINVAL;
88                 CERROR("lov: bad stripe count %d: rc = %d\n",
89                        stripe_count, rc);
90                 lov_dump_lmm_common(D_WARNING, lmm);
91                 goto out;
92         }
93
94         if (lmm_oi_id(&lmm->lmm_oi) == 0) {
95                 rc = -EINVAL;
96                 CERROR("lov: zero object id: rc = %d\n", rc);
97                 lov_dump_lmm_common(D_WARNING, lmm);
98                 goto out;
99         }
100
101         if (lov_pattern(le32_to_cpu(lmm->lmm_pattern)) != LOV_PATTERN_MDT &&
102             lov_pattern(le32_to_cpu(lmm->lmm_pattern)) != LOV_PATTERN_RAID0 &&
103             lov_pattern(le32_to_cpu(lmm->lmm_pattern)) !=
104                         (LOV_PATTERN_RAID0 | LOV_PATTERN_OVERSTRIPING)) {
105                 rc = -EINVAL;
106                 CERROR("lov: unrecognized striping pattern: rc = %d\n", rc);
107                 lov_dump_lmm_common(D_WARNING, lmm);
108                 goto out;
109         }
110
111         if (lmm->lmm_stripe_size == 0 ||
112             (le32_to_cpu(lmm->lmm_stripe_size)&(LOV_MIN_STRIPE_SIZE-1)) != 0) {
113                 rc = -EINVAL;
114                 CERROR("lov: bad stripe size %u: rc = %d\n",
115                        le32_to_cpu(lmm->lmm_stripe_size), rc);
116                 lov_dump_lmm_common(D_WARNING, lmm);
117                 goto out;
118         }
119
120 out:
121         return rc;
122 }
123
124 static void lsme_free(struct lov_stripe_md_entry *lsme)
125 {
126         unsigned int stripe_count = lsme->lsme_stripe_count;
127         unsigned int i;
128         size_t lsme_size;
129
130         if (!lsme_inited(lsme) ||
131             lsme->lsme_pattern & LOV_PATTERN_F_RELEASED)
132                 stripe_count = 0;
133         for (i = 0; i < stripe_count; i++)
134                 OBD_SLAB_FREE_PTR(lsme->lsme_oinfo[i], lov_oinfo_slab);
135
136         lsme_size = offsetof(typeof(*lsme), lsme_oinfo[stripe_count]);
137         OBD_FREE_LARGE(lsme, lsme_size);
138 }
139
140 void lsm_free(struct lov_stripe_md *lsm)
141 {
142         unsigned int entry_count = lsm->lsm_entry_count;
143         unsigned int i;
144         size_t lsm_size;
145
146         if (lsm->lsm_magic == LOV_MAGIC_FOREIGN) {
147                 OBD_FREE_LARGE(lsm_foreign(lsm), lsm->lsm_foreign_size);
148         } else {
149                 for (i = 0; i < entry_count; i++)
150                         lsme_free(lsm->lsm_entries[i]);
151         }
152
153         lsm_size = lsm->lsm_magic == LOV_MAGIC_FOREIGN ?
154                    offsetof(typeof(*lsm), lsm_entries[1]) :
155                    offsetof(typeof(*lsm), lsm_entries[entry_count]);
156         OBD_FREE(lsm, lsm_size);
157 }
158
159 /**
160  * Unpack a struct lov_mds_md into a struct lov_stripe_md_entry.
161  *
162  * The caller should set id and extent.
163  */
164 static struct lov_stripe_md_entry *
165 lsme_unpack(struct lov_obd *lov, struct lov_mds_md *lmm, size_t buf_size,
166             const char *pool_name, bool inited, struct lov_ost_data_v1 *objects,
167             loff_t *maxbytes)
168 {
169         struct lov_stripe_md_entry *lsme;
170         size_t lsme_size;
171         loff_t min_stripe_maxbytes = 0;
172         loff_t lov_bytes;
173         u32 magic;
174         u32 pattern;
175         unsigned int stripe_count;
176         unsigned int i;
177         int rc;
178
179         magic = le32_to_cpu(lmm->lmm_magic);
180         if (magic != LOV_MAGIC_V1 && magic != LOV_MAGIC_V3)
181                 RETURN(ERR_PTR(-EINVAL));
182
183         pattern = le32_to_cpu(lmm->lmm_pattern);
184         if (pattern & LOV_PATTERN_F_RELEASED || !inited)
185                 stripe_count = 0;
186         else
187                 stripe_count = le16_to_cpu(lmm->lmm_stripe_count);
188
189         if (buf_size < (magic == LOV_MAGIC_V1 ? sizeof(struct lov_mds_md_v1) :
190                                                 sizeof(struct lov_mds_md_v3))) {
191                 CERROR("LOV EA %s too small: %zu, need %u\n",
192                        magic == LOV_MAGIC_V1 ? "V1" : "V3", buf_size,
193                        lov_mds_md_size(stripe_count, magic == LOV_MAGIC_V1 ?
194                                        LOV_MAGIC_V1 : LOV_MAGIC_V3));
195                 lov_dump_lmm_common(D_WARNING, lmm);
196                 return ERR_PTR(-EINVAL);
197         }
198
199         rc = lsm_lmm_verify_v1v3(lmm, buf_size, stripe_count);
200         if (rc < 0)
201                 return ERR_PTR(rc);
202
203         lsme_size = offsetof(typeof(*lsme), lsme_oinfo[stripe_count]);
204         OBD_ALLOC_LARGE(lsme, lsme_size);
205         if (!lsme)
206                 RETURN(ERR_PTR(-ENOMEM));
207
208         lsme->lsme_magic = magic;
209         lsme->lsme_pattern = pattern;
210         lsme->lsme_flags = 0;
211         lsme->lsme_stripe_size = le32_to_cpu(lmm->lmm_stripe_size);
212         /* preserve the possible -1 stripe count for uninstantiated component */
213         lsme->lsme_stripe_count = le16_to_cpu(lmm->lmm_stripe_count);
214         lsme->lsme_layout_gen = le16_to_cpu(lmm->lmm_layout_gen);
215
216         if (pool_name) {
217                 size_t pool_name_len;
218
219                 pool_name_len = strlcpy(lsme->lsme_pool_name, pool_name,
220                                         sizeof(lsme->lsme_pool_name));
221                 if (pool_name_len >= sizeof(lsme->lsme_pool_name))
222                         GOTO(out_lsme, rc = -E2BIG);
223         }
224
225         /* with Data-on-MDT set maxbytes to stripe size */
226         if (lsme_is_dom(lsme)) {
227                 if (maxbytes) {
228                         lov_bytes = lsme->lsme_stripe_size;
229                         goto out_dom1;
230                 } else {
231                         goto out_dom2;
232                 }
233         }
234
235         for (i = 0; i < stripe_count; i++) {
236                 struct lov_oinfo *loi;
237                 struct lov_tgt_desc *ltd;
238
239                 OBD_SLAB_ALLOC_PTR_GFP(loi, lov_oinfo_slab, GFP_NOFS);
240                 if (!loi)
241                         GOTO(out_lsme, rc = -ENOMEM);
242
243                 lsme->lsme_oinfo[i] = loi;
244
245                 ostid_le_to_cpu(&objects[i].l_ost_oi, &loi->loi_oi);
246                 loi->loi_ost_idx = le32_to_cpu(objects[i].l_ost_idx);
247                 loi->loi_ost_gen = le32_to_cpu(objects[i].l_ost_gen);
248                 if (lov_oinfo_is_dummy(loi))
249                         continue;
250
251                 if (loi->loi_ost_idx >= lov->desc.ld_tgt_count &&
252                     !lov2obd(lov)->obd_process_conf) {
253                         CERROR("%s: OST index %d more than OST count %d\n",
254                                (char*)lov->desc.ld_uuid.uuid,
255                                loi->loi_ost_idx, lov->desc.ld_tgt_count);
256                         lov_dump_lmm_v1(D_WARNING, lmm);
257                         GOTO(out_lsme, rc = -EINVAL);
258                 }
259
260                 ltd = lov->lov_tgts[loi->loi_ost_idx];
261                 if (!ltd) {
262                         CERROR("%s: OST index %d missing\n",
263                                (char*)lov->desc.ld_uuid.uuid, loi->loi_ost_idx);
264                         lov_dump_lmm_v1(D_WARNING, lmm);
265                         continue;
266                 }
267
268                 lov_bytes = lov_tgt_maxbytes(ltd);
269                 if (min_stripe_maxbytes == 0 || lov_bytes < min_stripe_maxbytes)
270                         min_stripe_maxbytes = lov_bytes;
271         }
272
273         if (maxbytes) {
274                 if (min_stripe_maxbytes == 0)
275                         min_stripe_maxbytes = LUSTRE_EXT3_STRIPE_MAXBYTES;
276
277                 if (stripe_count == 0)
278                         stripe_count = lov->desc.ld_tgt_count;
279
280                 if (min_stripe_maxbytes <= LLONG_MAX / stripe_count)
281                         lov_bytes = min_stripe_maxbytes * stripe_count;
282                 else
283                         lov_bytes = MAX_LFS_FILESIZE;
284 out_dom1:
285                 *maxbytes = min_t(loff_t, lov_bytes, MAX_LFS_FILESIZE);
286         }
287 out_dom2:
288
289         return lsme;
290
291 out_lsme:
292         for (i = 0; i < stripe_count; i++) {
293                 struct lov_oinfo *loi = lsme->lsme_oinfo[i];
294
295                 if (loi)
296                         OBD_SLAB_FREE_PTR(lsme->lsme_oinfo[i], lov_oinfo_slab);
297         }
298         OBD_FREE_LARGE(lsme, lsme_size);
299
300         return ERR_PTR(rc);
301 }
302
303 static struct
304 lov_stripe_md *lsm_unpackmd_v1v3(struct lov_obd *lov, struct lov_mds_md *lmm,
305                                  size_t buf_size, const char *pool_name,
306                                  struct lov_ost_data_v1 *objects)
307 {
308         struct lov_stripe_md *lsm;
309         struct lov_stripe_md_entry *lsme;
310         size_t lsm_size;
311         loff_t maxbytes;
312         u32 pattern;
313         int rc;
314
315         pattern = le32_to_cpu(lmm->lmm_pattern);
316
317         lsme = lsme_unpack(lov, lmm, buf_size, pool_name, true, objects,
318                            &maxbytes);
319         if (IS_ERR(lsme))
320                 RETURN(ERR_CAST(lsme));
321
322         lsme->lsme_flags = LCME_FL_INIT;
323         lsme->lsme_extent.e_start = 0;
324         lsme->lsme_extent.e_end = LUSTRE_EOF;
325
326         lsm_size = offsetof(typeof(*lsm), lsm_entries[1]);
327         OBD_ALLOC(lsm, lsm_size);
328         if (!lsm)
329                 GOTO(out_lsme, rc = -ENOMEM);
330
331         atomic_set(&lsm->lsm_refc, 1);
332         spin_lock_init(&lsm->lsm_lock);
333         lsm->lsm_maxbytes = maxbytes;
334         lmm_oi_le_to_cpu(&lsm->lsm_oi, &lmm->lmm_oi);
335         lsm->lsm_magic = le32_to_cpu(lmm->lmm_magic);
336         lsm->lsm_layout_gen = le16_to_cpu(lmm->lmm_layout_gen);
337         lsm->lsm_entry_count = 1;
338         lsm->lsm_is_released = pattern & LOV_PATTERN_F_RELEASED;
339         lsm->lsm_entries[0] = lsme;
340
341         return lsm;
342
343 out_lsme:
344         lsme_free(lsme);
345
346         return ERR_PTR(rc);
347 }
348
349 static inline struct lov_stripe_md *
350 lsm_unpackmd_v1(struct lov_obd *lov, void *buf, size_t buf_size)
351 {
352         struct lov_mds_md_v1 *lmm = buf;
353
354         return lsm_unpackmd_v1v3(lov, buf, buf_size, NULL, lmm->lmm_objects);
355 }
356
357 const struct lsm_operations lsm_v1_ops = {
358         .lsm_unpackmd           = lsm_unpackmd_v1,
359 };
360
361 static inline
362 struct lov_stripe_md *lsm_unpackmd_v3(struct lov_obd *lov, void *buf,
363                                       size_t buf_size)
364 {
365         struct lov_mds_md_v3 *lmm = buf;
366
367         return lsm_unpackmd_v1v3(lov, buf, buf_size, lmm->lmm_pool_name,
368                                  lmm->lmm_objects);
369 }
370
371 const struct lsm_operations lsm_v3_ops = {
372         .lsm_unpackmd           = lsm_unpackmd_v3,
373 };
374
375 static int lsm_verify_comp_md_v1(struct lov_comp_md_v1 *lcm,
376                                  size_t lcm_buf_size)
377 {
378         unsigned int entry_count;
379         unsigned int i;
380         size_t lcm_size;
381
382         lcm_size = le32_to_cpu(lcm->lcm_size);
383         if (lcm_buf_size < lcm_size) {
384                 CERROR("bad LCM buffer size %zu, expected %zu\n",
385                        lcm_buf_size, lcm_size);
386                 RETURN(-EINVAL);
387         }
388
389         entry_count = le16_to_cpu(lcm->lcm_entry_count);
390         for (i = 0; i < entry_count; i++) {
391                 struct lov_comp_md_entry_v1 *lcme = &lcm->lcm_entries[i];
392                 size_t blob_offset;
393                 size_t blob_size;
394
395                 blob_offset = le32_to_cpu(lcme->lcme_offset);
396                 blob_size = le32_to_cpu(lcme->lcme_size);
397
398                 if (lcm_size < blob_offset || lcm_size < blob_size ||
399                     lcm_size < blob_offset + blob_size) {
400                         CERROR("LCM entry %u has invalid blob: "
401                                "LCM size = %zu, offset = %zu, size = %zu\n",
402                                le32_to_cpu(lcme->lcme_id),
403                                lcm_size, blob_offset, blob_size);
404                         RETURN(-EINVAL);
405                 }
406         }
407
408         return 0;
409 }
410
411 static struct lov_stripe_md_entry *
412 lsme_unpack_comp(struct lov_obd *lov, struct lov_mds_md *lmm,
413                  size_t lmm_buf_size, bool inited, loff_t *maxbytes)
414 {
415         unsigned int magic;
416         unsigned int stripe_count;
417
418         stripe_count = le16_to_cpu(lmm->lmm_stripe_count);
419         if (stripe_count == 0 &&
420             lov_pattern(le32_to_cpu(lmm->lmm_pattern)) != LOV_PATTERN_MDT)
421                 RETURN(ERR_PTR(-EINVAL));
422         /* un-instantiated lmm contains no ost id info, i.e. lov_ost_data_v1 */
423         if (!inited)
424                 stripe_count = 0;
425
426         magic = le32_to_cpu(lmm->lmm_magic);
427         if (magic != LOV_MAGIC_V1 && magic != LOV_MAGIC_V3)
428                 RETURN(ERR_PTR(-EINVAL));
429
430         if (lmm_buf_size < lov_mds_md_size(stripe_count, magic))
431                 RETURN(ERR_PTR(-EINVAL));
432
433         if (magic == LOV_MAGIC_V1) {
434                 return lsme_unpack(lov, lmm, lmm_buf_size, NULL,
435                                    inited, lmm->lmm_objects, maxbytes);
436         } else {
437                 struct lov_mds_md_v3 *lmm3 = (struct lov_mds_md_v3 *)lmm;
438
439                 return lsme_unpack(lov, lmm, lmm_buf_size, lmm3->lmm_pool_name,
440                                    inited, lmm3->lmm_objects, maxbytes);
441         }
442 }
443
444 static struct lov_stripe_md *
445 lsm_unpackmd_comp_md_v1(struct lov_obd *lov, void *buf, size_t buf_size)
446 {
447         struct lov_comp_md_v1 *lcm = buf;
448         struct lov_stripe_md *lsm;
449         size_t lsm_size;
450         unsigned int entry_count = 0;
451         unsigned int i;
452         loff_t maxbytes;
453         int rc;
454
455         rc = lsm_verify_comp_md_v1(buf, buf_size);
456         if (rc < 0)
457                 return ERR_PTR(rc);
458
459         entry_count = le16_to_cpu(lcm->lcm_entry_count);
460
461         lsm_size = offsetof(typeof(*lsm), lsm_entries[entry_count]);
462         OBD_ALLOC(lsm, lsm_size);
463         if (!lsm)
464                 return ERR_PTR(-ENOMEM);
465
466         atomic_set(&lsm->lsm_refc, 1);
467         spin_lock_init(&lsm->lsm_lock);
468         lsm->lsm_magic = le32_to_cpu(lcm->lcm_magic);
469         lsm->lsm_layout_gen = le32_to_cpu(lcm->lcm_layout_gen);
470         lsm->lsm_entry_count = entry_count;
471         lsm->lsm_mirror_count = le16_to_cpu(lcm->lcm_mirror_count);
472         lsm->lsm_flags = le16_to_cpu(lcm->lcm_flags);
473         lsm->lsm_is_released = true;
474         lsm->lsm_maxbytes = LLONG_MIN;
475
476         for (i = 0; i < entry_count; i++) {
477                 struct lov_comp_md_entry_v1 *lcme = &lcm->lcm_entries[i];
478                 struct lov_stripe_md_entry *lsme;
479                 size_t blob_offset;
480                 size_t blob_size;
481                 void *blob;
482
483                 blob_offset = le32_to_cpu(lcme->lcme_offset);
484                 blob_size = le32_to_cpu(lcme->lcme_size);
485                 blob = (char *)lcm + blob_offset;
486
487                 lsme = lsme_unpack_comp(lov, blob, blob_size,
488                                         le32_to_cpu(lcme->lcme_flags) &
489                                         LCME_FL_INIT,
490                                         (i == entry_count - 1) ? &maxbytes :
491                                                                  NULL);
492                 if (IS_ERR(lsme))
493                         GOTO(out_lsm, rc = PTR_ERR(lsme));
494
495                 if (!(lsme->lsme_pattern & LOV_PATTERN_F_RELEASED))
496                         lsm->lsm_is_released = false;
497
498                 lsm->lsm_entries[i] = lsme;
499                 lsme->lsme_id = le32_to_cpu(lcme->lcme_id);
500                 lsme->lsme_flags = le32_to_cpu(lcme->lcme_flags);
501                 if (lsme->lsme_flags & LCME_FL_NOSYNC)
502                         lsme->lsme_timestamp =
503                                 le64_to_cpu(lcme->lcme_timestamp);
504                 lu_extent_le_to_cpu(&lsme->lsme_extent, &lcme->lcme_extent);
505
506                 if (i == entry_count - 1) {
507                         lsm->lsm_maxbytes = (loff_t)lsme->lsme_extent.e_start +
508                                             maxbytes;
509                         /*
510                          * the last component hasn't been defined, or
511                          * lsm_maxbytes overflowed.
512                          */
513                         if (!lsme_is_dom(lsme) &&
514                             (lsme->lsme_extent.e_end != LUSTRE_EOF ||
515                              lsm->lsm_maxbytes <
516                              (loff_t)lsme->lsme_extent.e_start))
517                                 lsm->lsm_maxbytes = MAX_LFS_FILESIZE;
518                 }
519         }
520
521         RETURN(lsm);
522
523 out_lsm:
524         for (i = 0; i < entry_count; i++)
525                 if (lsm->lsm_entries[i])
526                         lsme_free(lsm->lsm_entries[i]);
527
528         OBD_FREE(lsm, lsm_size);
529
530         RETURN(ERR_PTR(rc));
531 }
532
533 const struct lsm_operations lsm_comp_md_v1_ops = {
534         .lsm_unpackmd         = lsm_unpackmd_comp_md_v1,
535 };
536
537 static struct
538 lov_stripe_md *lsm_unpackmd_foreign(struct lov_obd *lov, void *buf,
539                                     size_t buf_size)
540 {
541         struct lov_foreign_md *lfm = buf;
542         struct lov_stripe_md *lsm;
543         size_t lsm_size;
544         struct lov_stripe_md_entry *lsme;
545
546         lsm_size = offsetof(typeof(*lsm), lsm_entries[1]);
547         OBD_ALLOC(lsm, lsm_size);
548         if (lsm == NULL)
549                 RETURN(ERR_PTR(-ENOMEM));
550
551         atomic_set(&lsm->lsm_refc, 1);
552         spin_lock_init(&lsm->lsm_lock);
553         lsm->lsm_magic = le32_to_cpu(lfm->lfm_magic);
554         lsm->lsm_foreign_size = foreign_size_le(lfm);
555
556         /* alloc for full foreign EA including format fields */
557         OBD_ALLOC_LARGE(lsme, lsm->lsm_foreign_size);
558         if (lsme == NULL) {
559                 OBD_FREE(lsm, lsm_size);
560                 RETURN(ERR_PTR(-ENOMEM));
561         }
562
563         /* copy full foreign EA including format fields */
564         memcpy(lsme, buf, lsm->lsm_foreign_size);
565
566         lsm_foreign(lsm) = lsme;
567
568         return lsm;
569 }
570
571 const struct lsm_operations lsm_foreign_ops = {
572         .lsm_unpackmd         = lsm_unpackmd_foreign,
573 };
574
575 void dump_lsm(unsigned int level, const struct lov_stripe_md *lsm)
576 {
577         int i, j;
578
579         CDEBUG_LIMIT(level,
580                      "lsm %p, objid "DOSTID", maxbytes %#llx, magic 0x%08X, refc: %d, entry: %u, layout_gen %u\n",
581                lsm, POSTID(&lsm->lsm_oi), lsm->lsm_maxbytes, lsm->lsm_magic,
582                atomic_read(&lsm->lsm_refc), lsm->lsm_entry_count,
583                lsm->lsm_layout_gen);
584
585         if (lsm->lsm_magic == LOV_MAGIC_FOREIGN) {
586                 struct lov_foreign_md *lfm = (void *)lsm_foreign(lsm);
587
588                 CDEBUG_LIMIT(level,
589                              "foreign LOV EA, magic %x, length %u, type %x, flags %x, value '%.*s'\n",
590                        lfm->lfm_magic, lfm->lfm_length, lfm->lfm_type,
591                        lfm->lfm_flags, lfm->lfm_length, lfm->lfm_value);
592                 return;
593         }
594
595         for (i = 0; i < lsm->lsm_entry_count; i++) {
596                 struct lov_stripe_md_entry *lse = lsm->lsm_entries[i];
597
598                 CDEBUG(level, DEXT ": id: %u, flags: %x, "
599                        "magic 0x%08X, layout_gen %u, "
600                        "stripe count %u, sstripe size %u, "
601                        "pool: ["LOV_POOLNAMEF"]\n",
602                        PEXT(&lse->lsme_extent), lse->lsme_id, lse->lsme_flags,
603                        lse->lsme_magic, lse->lsme_layout_gen,
604                        lse->lsme_stripe_count, lse->lsme_stripe_size,
605                        lse->lsme_pool_name);
606                 if (!lsme_inited(lse) ||
607                     lse->lsme_pattern & LOV_PATTERN_F_RELEASED)
608                         continue;
609                 for (j = 0; j < lse->lsme_stripe_count; j++) {
610                         CDEBUG(level, "   oinfo:%p: ostid: "DOSTID
611                                " ost idx: %d gen: %d\n",
612                                lse->lsme_oinfo[j],
613                                POSTID(&lse->lsme_oinfo[j]->loi_oi),
614                                lse->lsme_oinfo[j]->loi_ost_idx,
615                                lse->lsme_oinfo[j]->loi_ost_gen);
616                 }
617         }
618 }
619
620 int lov_lsm_entry(const struct lov_stripe_md *lsm, __u64 offset)
621 {
622         int i;
623
624         for (i = 0; i < lsm->lsm_entry_count; i++) {
625                 struct lov_stripe_md_entry *lse = lsm->lsm_entries[i];
626
627                 if ((offset >= lse->lsme_extent.e_start &&
628                      offset < lse->lsme_extent.e_end) ||
629                     (offset == OBD_OBJECT_EOF &&
630                      lse->lsme_extent.e_end == OBD_OBJECT_EOF))
631                         return i;
632         }
633
634         return -1;
635 }