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 }