lustre/utils/liblustreapi_layout.c

   1 /*
   2  * LGPL HEADER START
   3  *
   4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   5  *
   6  * All rights reserved. This program and the accompanying materials
   7  * are made available under the terms of the GNU Lesser General Public License
   8  * (LGPL) version 2.1 or (at your discretion) any later version.
   9  * (LGPL) version 2.1 accompanies this distribution, and is available at
  10  * http://www.gnu.org/licenses/lgpl-2.1.html
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * LGPL HEADER END
  18  */
  19 /*
  20  * lustre/utils/liblustreapi_layout.c
  21  *
  22  * lustreapi library for layout calls for interacting with the layout of
  23  * Lustre files while hiding details of the internal data structures
  24  * from the user.
  25  *
  26  * Copyright (c) 2016, 2017, Intel Corporation.
  27  *
  28  * Author: Ned Bass <bass6@llnl.gov>
  29  */
  30
  31 #include <stdio.h>
  32 #include <fcntl.h>
  33 #include <stdlib.h>
  34 #include <unistd.h>
  35 #include <errno.h>
  36 #include <limits.h>
  37 #include <assert.h>
  38 #include <sys/xattr.h>
  39 #include <sys/param.h>
  40
  41 #include <libcfs/util/list.h>
  42 #include <lustre/lustreapi.h>
  43 #include "lustreapi_internal.h"
  44
  45 /**
  46  * Layout component, which contains all attributes of a plain
  47  * V1/V3 layout.
  48  */
  49 struct llapi_layout_comp {
  50         uint64_t        llc_pattern;
  51         uint64_t        llc_stripe_size;
  52         uint64_t        llc_stripe_count;
  53         uint64_t        llc_stripe_offset;
  54         /* Add 1 so user always gets back a null terminated string. */
  55         char            llc_pool_name[LOV_MAXPOOLNAME + 1];
  56         /** Number of objects in llc_objects array if was initialized. */
  57         uint32_t        llc_objects_count;
  58         struct          lov_user_ost_data_v1 *llc_objects;
  59         /* fields used only for composite layouts */
  60         struct lu_extent        llc_extent;     /* [start, end) of component */
  61         uint32_t                llc_id;         /* unique ID of component */
  62         uint32_t                llc_flags;      /* LCME_FL_* flags */
  63         uint64_t                llc_timestamp;  /* snapshot timestamp */
  64         struct list_head        llc_list;       /* linked to the llapi_layout
  65                                                    components list */
  66         bool            llc_ondisk;
  67 };
  68
  69 /**
  70  * An Opaque data type abstracting the layout of a Lustre file.
  71  */
  72 struct llapi_layout {
  73         uint32_t        llot_magic; /* LLAPI_LAYOUT_MAGIC */
  74         uint32_t        llot_gen;
  75         uint32_t        llot_flags;
  76         bool            llot_is_composite;
  77         uint16_t        llot_mirror_count;
  78         /* Cursor pointing to one of the components in llot_comp_list */
  79         struct llapi_layout_comp *llot_cur_comp;
  80         struct list_head          llot_comp_list;
  81 };
  82
  83 /**
  84  * Compute the number of elements in the lmm_objects array of \a lum
  85  * with size \a lum_size.
  86  *
  87  * \param[in] lum       the struct lov_user_md to check
  88  * \param[in] lum_size  the number of bytes in \a lum
  89  *
  90  * \retval              number of elements in array lum->lmm_objects
  91  */
  92 static int llapi_layout_objects_in_lum(struct lov_user_md *lum, size_t lum_size)
  93 {
  94         uint32_t magic;
  95         size_t base_size;
  96
  97         if (lum_size < lov_user_md_size(0, LOV_MAGIC_V1))
  98                 return 0;
  99
 100         if (lum->lmm_magic == __swab32(LOV_MAGIC_V1) ||
 101             lum->lmm_magic == __swab32(LOV_MAGIC_V3))
 102                 magic = __swab32(lum->lmm_magic);
 103         else
 104                 magic = lum->lmm_magic;
 105
 106         base_size = lov_user_md_size(0, magic);
 107
 108         if (lum_size <= base_size)
 109                 return 0;
 110         else
 111                 return (lum_size - base_size) / sizeof(lum->lmm_objects[0]);
 112 }
 113
 114 /**
 115  * Byte-swap the fields of struct lov_user_md.
 116  *
 117  * XXX Rather than duplicating swabbing code here, we should eventually
 118  * refactor the needed functions in lustre/ptlrpc/pack_generic.c
 119  * into a library that can be shared between kernel and user code.
 120  */
 121 static void
 122 llapi_layout_swab_lov_user_md(struct lov_user_md *lum, int lum_size)
 123 {
 124         int i, j, ent_count, obj_count;
 125         struct lov_comp_md_v1 *comp_v1 = NULL;
 126         struct lov_comp_md_entry_v1 *ent;
 127         struct lov_user_ost_data *lod;
 128
 129         if (lum->lmm_magic != __swab32(LOV_MAGIC_V1) &&
 130             lum->lmm_magic != __swab32(LOV_MAGIC_V3) &&
 131             lum->lmm_magic != __swab32(LOV_MAGIC_COMP_V1))
 132                 return;
 133
 134         if (lum->lmm_magic == __swab32(LOV_MAGIC_COMP_V1))
 135                 comp_v1 = (struct lov_comp_md_v1 *)lum;
 136
 137         if (comp_v1 != NULL) {
 138                 comp_v1->lcm_magic = __swab32(comp_v1->lcm_magic);
 139                 comp_v1->lcm_size = __swab32(comp_v1->lcm_size);
 140                 comp_v1->lcm_layout_gen = __swab32(comp_v1->lcm_layout_gen);
 141                 comp_v1->lcm_flags = __swab16(comp_v1->lcm_flags);
 142                 comp_v1->lcm_entry_count = __swab16(comp_v1->lcm_entry_count);
 143                 ent_count = comp_v1->lcm_entry_count;
 144         } else {
 145                 ent_count = 1;
 146         }
 147
 148         for (i = 0; i < ent_count; i++) {
 149                 if (comp_v1 != NULL) {
 150                         ent = &comp_v1->lcm_entries[i];
 151                         ent->lcme_id = __swab32(ent->lcme_id);
 152                         ent->lcme_flags = __swab32(ent->lcme_flags);
 153                         ent->lcme_timestamp = __swab64(ent->lcme_timestamp);
 154                         ent->lcme_extent.e_start = __swab64(ent->lcme_extent.e_start);
 155                         ent->lcme_extent.e_end = __swab64(ent->lcme_extent.e_end);
 156                         ent->lcme_offset = __swab32(ent->lcme_offset);
 157                         ent->lcme_size = __swab32(ent->lcme_size);
 158
 159                         lum = (struct lov_user_md *)((char *)comp_v1 +
 160                                         ent->lcme_offset);
 161                         lum_size = ent->lcme_size;
 162                 }
 163                 obj_count = llapi_layout_objects_in_lum(lum, lum_size);
 164
 165                 lum->lmm_magic = __swab32(lum->lmm_magic);
 166                 lum->lmm_pattern = __swab32(lum->lmm_pattern);
 167                 lum->lmm_stripe_size = __swab32(lum->lmm_stripe_size);
 168                 lum->lmm_stripe_count = __swab16(lum->lmm_stripe_count);
 169                 lum->lmm_stripe_offset = __swab16(lum->lmm_stripe_offset);
 170
 171                 if (lum->lmm_magic != LOV_MAGIC_V1) {
 172                         struct lov_user_md_v3 *v3;
 173                         v3 = (struct lov_user_md_v3 *)lum;
 174                         lod = v3->lmm_objects;
 175                 } else {
 176                         lod = lum->lmm_objects;
 177                 }
 178
 179                 for (j = 0; j < obj_count; j++)
 180                         lod[j].l_ost_idx = __swab32(lod[j].l_ost_idx);
 181         }
 182 }
 183
 184 /**
 185  * (Re-)allocate llc_objects[] to \a num_stripes stripes.
 186  *
 187  * Copy over existing llc_objects[], if any, to the new llc_objects[].
 188  *
 189  * \param[in] layout            existing layout to be modified
 190  * \param[in] num_stripes       number of stripes in new layout
 191  *
 192  * \retval      0 if the objects are re-allocated successfully
 193  * \retval      -1 on error with errno set
 194  */
 195 static int __llapi_comp_objects_realloc(struct llapi_layout_comp *comp,
 196                                         unsigned int new_stripes)
 197 {
 198         struct lov_user_ost_data_v1 *new_objects;
 199         unsigned int i;
 200
 201         if (new_stripes > LOV_MAX_STRIPE_COUNT) {
 202                 errno = EINVAL;
 203                 return -1;
 204         }
 205
 206         if (new_stripes == comp->llc_objects_count)
 207                 return 0;
 208
 209         if (new_stripes != 0 && new_stripes <= comp->llc_objects_count)
 210                 return 0;
 211
 212         new_objects = realloc(comp->llc_objects,
 213                               sizeof(*new_objects) * new_stripes);
 214         if (new_objects == NULL && new_stripes != 0) {
 215                 errno = ENOMEM;
 216                 return -1;
 217         }
 218
 219         for (i = comp->llc_objects_count; i < new_stripes; i++)
 220                 new_objects[i].l_ost_idx = LLAPI_LAYOUT_IDX_MAX;
 221
 222         comp->llc_objects = new_objects;
 223         comp->llc_objects_count = new_stripes;
 224
 225         return 0;
 226 }
 227
 228 /**
 229  * Allocate storage for a llapi_layout_comp with \a num_stripes stripes.
 230  *
 231  * \param[in] num_stripes       number of stripes in new layout
 232  *
 233  * \retval      valid pointer if allocation succeeds
 234  * \retval      NULL if allocation fails
 235  */
 236 static struct llapi_layout_comp *__llapi_comp_alloc(unsigned int num_stripes)
 237 {
 238         struct llapi_layout_comp *comp;
 239
 240         if (num_stripes > LOV_MAX_STRIPE_COUNT) {
 241                 errno = EINVAL;
 242                 return NULL;
 243         }
 244
 245         comp = calloc(1, sizeof(*comp));
 246         if (comp == NULL) {
 247                 errno = ENOMEM;
 248                 return NULL;
 249         }
 250
 251         comp->llc_objects = NULL;
 252         comp->llc_objects_count = 0;
 253
 254         if (__llapi_comp_objects_realloc(comp, num_stripes) < 0) {
 255                 free(comp);
 256                 return NULL;
 257         }
 258
 259         /* Set defaults. */
 260         comp->llc_pattern = LLAPI_LAYOUT_DEFAULT;
 261         comp->llc_stripe_size = LLAPI_LAYOUT_DEFAULT;
 262         comp->llc_stripe_count = LLAPI_LAYOUT_DEFAULT;
 263         comp->llc_stripe_offset = LLAPI_LAYOUT_DEFAULT;
 264         comp->llc_pool_name[0] = '\0';
 265         comp->llc_extent.e_start = 0;
 266         comp->llc_extent.e_end = LUSTRE_EOF;
 267         comp->llc_flags = 0;
 268         comp->llc_id = 0;
 269         INIT_LIST_HEAD(&comp->llc_list);
 270
 271         return comp;
 272 }
 273
 274 /**
 275  * Free memory allocated for \a comp
 276  *
 277  * \param[in] comp      previously allocated by __llapi_comp_alloc()
 278  */
 279 static void __llapi_comp_free(struct llapi_layout_comp *comp)
 280 {
 281         if (comp->llc_objects != NULL)
 282                 free(comp->llc_objects);
 283         free(comp);
 284 }
 285
 286 /**
 287  * Free memory allocated for \a layout.
 288  *
 289  * \param[in] layout    previously allocated by llapi_layout_alloc()
 290  */
 291 void llapi_layout_free(struct llapi_layout *layout)
 292 {
 293         struct llapi_layout_comp *comp, *n;
 294
 295         if (layout == NULL)
 296                 return;
 297
 298         list_for_each_entry_safe(comp, n, &layout->llot_comp_list, llc_list) {
 299                 list_del_init(&comp->llc_list);
 300                 __llapi_comp_free(comp);
 301         }
 302         free(layout);
 303 }
 304
 305 /**
 306  * Allocate and initialize a llapi_layout structure.
 307  *
 308  * \retval      valid llapi_layout pointer on success
 309  * \retval      NULL if memory allocation fails
 310  */
 311 static struct llapi_layout *__llapi_layout_alloc(void)
 312 {
 313         struct llapi_layout *layout;
 314
 315         layout = calloc(1, sizeof(*layout));
 316         if (layout == NULL) {
 317                 errno = ENOMEM;
 318                 return NULL;
 319         }
 320
 321         /* Set defaults. */
 322         layout->llot_magic = LLAPI_LAYOUT_MAGIC;
 323         layout->llot_gen = 0;
 324         layout->llot_flags = 0;
 325         layout->llot_is_composite = false;
 326         layout->llot_mirror_count = 1;
 327         layout->llot_cur_comp = NULL;
 328         INIT_LIST_HEAD(&layout->llot_comp_list);
 329
 330         return layout;
 331 }
 332
 333 /**
 334  * Allocate and initialize a new plain layout.
 335  *
 336  * \retval      valid llapi_layout pointer on success
 337  * \retval      NULL if memory allocation fails
 338  */
 339 struct llapi_layout *llapi_layout_alloc(void)
 340 {
 341         struct llapi_layout_comp *comp;
 342         struct llapi_layout *layout;
 343
 344         layout = __llapi_layout_alloc();
 345         if (layout == NULL)
 346                 return NULL;
 347
 348         comp = __llapi_comp_alloc(0);
 349         if (comp == NULL) {
 350                 free(layout);
 351                 return NULL;
 352         }
 353
 354         list_add_tail(&comp->llc_list, &layout->llot_comp_list);
 355         layout->llot_cur_comp = comp;
 356
 357         return layout;
 358 }
 359
 360 /**
 361  * Check if the given \a lum_size is large enough to hold the required
 362  * fields in \a lum.
 363  *
 364  * \param[in] lum       the struct lov_user_md to check
 365  * \param[in] lum_size  the number of bytes in \a lum
 366  *
 367  * \retval true         the \a lum_size is too small
 368  * \retval false        the \a lum_size is large enough
 369  */
 370 static bool llapi_layout_lum_truncated(struct lov_user_md *lum, size_t lum_size)
 371 {
 372         uint32_t magic;
 373
 374         if (lum_size < sizeof(lum->lmm_magic))
 375                 return true;
 376
 377         if (lum->lmm_magic == LOV_MAGIC_V1 ||
 378             lum->lmm_magic == __swab32(LOV_MAGIC_V1))
 379                 magic = LOV_MAGIC_V1;
 380         else if (lum->lmm_magic == LOV_MAGIC_V3 ||
 381                  lum->lmm_magic == __swab32(LOV_MAGIC_V3))
 382                 magic = LOV_MAGIC_V3;
 383         else if (lum->lmm_magic == LOV_MAGIC_COMP_V1 ||
 384                  lum->lmm_magic == __swab32(LOV_MAGIC_COMP_V1))
 385                 magic = LOV_MAGIC_COMP_V1;
 386         else
 387                 return true;
 388
 389         if (magic == LOV_MAGIC_V1 || magic == LOV_MAGIC_V3)
 390                 return lum_size < lov_user_md_size(0, magic);
 391         else
 392                 return lum_size < sizeof(struct lov_comp_md_v1);
 393 }
 394
 395 /* Verify if the objects count in lum is consistent with the
 396  * stripe count in lum. It applies to regular file only. */
 397 static bool llapi_layout_lum_valid(struct lov_user_md *lum, int lum_size)
 398 {
 399         struct lov_comp_md_v1 *comp_v1 = NULL;
 400         int i, ent_count, obj_count;
 401
 402         if (lum->lmm_magic == LOV_MAGIC_COMP_V1) {
 403                 comp_v1 = (struct lov_comp_md_v1 *)lum;
 404                 ent_count = comp_v1->lcm_entry_count;
 405         } else if (lum->lmm_magic == LOV_MAGIC_V1 ||
 406                    lum->lmm_magic == LOV_MAGIC_V3) {
 407                 ent_count = 1;
 408         } else {
 409                 return false;
 410         }
 411
 412         for (i = 0; i < ent_count; i++) {
 413                 if (comp_v1) {
 414                         lum = (struct lov_user_md *)((char *)comp_v1 +
 415                                 comp_v1->lcm_entries[i].lcme_offset);
 416                         lum_size = comp_v1->lcm_entries[i].lcme_size;
 417                 }
 418                 obj_count = llapi_layout_objects_in_lum(lum, lum_size);
 419
 420                 if (comp_v1) {
 421                         if (!(comp_v1->lcm_entries[i].lcme_flags &
 422                                  LCME_FL_INIT) && obj_count != 0)
 423                                 return false;
 424                 } else if (obj_count != lum->lmm_stripe_count) {
 425                         return false;
 426                 }
 427         }
 428         return true;
 429 }
 430
 431 /**
 432  * Convert the data from a lov_user_md to a newly allocated llapi_layout.
 433  * The caller is responsible for freeing the returned pointer.
 434  *
 435  * \param[in] lov_xattr         LOV user metadata xattr to copy data from
 436  * \param[in] lov_xattr_size    size the lov_xattr_size passed in
 437  * \param[in] flags             flags to control how layout is retrieved
 438  *
 439  * \retval              valid llapi_layout pointer on success
 440  * \retval              NULL if memory allocation fails
 441  */
 442 struct llapi_layout *llapi_layout_get_by_xattr(void *lov_xattr,
 443                                               ssize_t lov_xattr_size,
 444                                               enum llapi_layout_get_flags flags)
 445 {
 446         struct lov_user_md *lum = lov_xattr;
 447         struct lov_comp_md_v1 *comp_v1 = NULL;
 448         struct lov_comp_md_entry_v1 *ent;
 449         struct lov_user_md *v1;
 450         struct llapi_layout *layout = NULL;
 451         struct llapi_layout_comp *comp;
 452         int i, ent_count = 0, obj_count;
 453
 454         if (lov_xattr == NULL || lov_xattr_size <= 0) {
 455                 errno = EINVAL;
 456                 return NULL;
 457         }
 458
 459         /* Return an error if we got back a partial layout. */
 460         if (llapi_layout_lum_truncated(lov_xattr, lov_xattr_size)) {
 461                 errno = ERANGE;
 462                 return NULL;
 463         }
 464
 465 #if __BYTE_ORDER == __BIG_ENDIAN
 466         if (flags & LLAPI_LAYOUT_GET_COPY) {
 467                 lum = malloc(lov_xattr_size);
 468                 if (lum == NULL) {
 469                         errno = ENOMEM;
 470                         return NULL;
 471                 }
 472                 memcpy(lum, lov_xattr, lov_xattr_size);
 473         }
 474 #endif
 475
 476         llapi_layout_swab_lov_user_md(lum, lov_xattr_size);
 477
 478 #if LUSTRE_VERSION_CODE > OBD_OCD_VERSION(2, 16, 53, 0)
 479 #define LLAPI_LXF_CHECK_OLD 0x0001
 480         if (flags & LLAPI_LXF_CHECK_OLD)
 481                 flags = (flags & ~LLAPI_LXF_CHECK_OLD) | LLAPI_LAYOUT_GET_CHECK;
 482 #endif
 483         if ((flags & LLAPI_LAYOUT_GET_CHECK) &&
 484             !llapi_layout_lum_valid(lum, lov_xattr_size)) {
 485                 errno = EBADSLT;
 486                 goto out;
 487         }
 488
 489         layout = __llapi_layout_alloc();
 490         if (layout == NULL) {
 491                 errno = ENOMEM;
 492                 goto out;
 493         }
 494
 495         if (lum->lmm_magic == LOV_MAGIC_COMP_V1) {
 496                 comp_v1 = (struct lov_comp_md_v1 *)lum;
 497                 ent_count = comp_v1->lcm_entry_count;
 498                 layout->llot_gen = comp_v1->lcm_layout_gen;
 499                 layout->llot_is_composite = true;
 500                 layout->llot_mirror_count = comp_v1->lcm_mirror_count + 1;
 501                 layout->llot_gen = comp_v1->lcm_layout_gen;
 502                 layout->llot_flags = comp_v1->lcm_flags;
 503         } else if (lum->lmm_magic == LOV_MAGIC_V1 ||
 504                    lum->lmm_magic == LOV_MAGIC_V3) {
 505                 ent_count = 1;
 506                 layout->llot_is_composite = false;
 507
 508                 if (lov_xattr_size <= 0) {
 509                         errno = EINVAL;
 510                         goto out_layout;
 511                 }
 512         } else {
 513                 errno = EOPNOTSUPP;
 514                 goto out_layout;
 515         }
 516
 517         if (ent_count == 0) {
 518                 errno = EINVAL;
 519                 goto out_layout;
 520         }
 521
 522         v1 = (struct lov_user_md *)lum;
 523         for (i = 0; i < ent_count; i++) {
 524                 if (comp_v1 != NULL) {
 525                         ent = &comp_v1->lcm_entries[i];
 526                         v1 = (struct lov_user_md *)((char *)comp_v1 +
 527                                 ent->lcme_offset);
 528                         lov_xattr_size = ent->lcme_size;
 529                 } else {
 530                         ent = NULL;
 531                 }
 532
 533                 obj_count = llapi_layout_objects_in_lum(v1, lov_xattr_size);
 534                 comp = __llapi_comp_alloc(obj_count);
 535                 if (comp == NULL)
 536                         goto out_layout;
 537
 538                 if (ent != NULL) {
 539                         comp->llc_extent.e_start = ent->lcme_extent.e_start;
 540                         comp->llc_extent.e_end = ent->lcme_extent.e_end;
 541                         comp->llc_id = ent->lcme_id;
 542                         comp->llc_flags = ent->lcme_flags;
 543                         if (comp->llc_flags & LCME_FL_NOSYNC)
 544                                 comp->llc_timestamp = ent->lcme_timestamp;
 545                 } else {
 546                         comp->llc_extent.e_start = 0;
 547                         comp->llc_extent.e_end = LUSTRE_EOF;
 548                         comp->llc_id = 0;
 549                         comp->llc_flags = 0;
 550                 }
 551
 552                 if (v1->lmm_pattern == LOV_PATTERN_RAID0)
 553                         comp->llc_pattern = LLAPI_LAYOUT_RAID0;
 554                 else if (v1->lmm_pattern == (LOV_PATTERN_RAID0 |
 555                                          LOV_PATTERN_OVERSTRIPING))
 556                         comp->llc_pattern = LLAPI_LAYOUT_OVERSTRIPING;
 557                 else if (v1->lmm_pattern == LOV_PATTERN_MDT)
 558                         comp->llc_pattern = LLAPI_LAYOUT_MDT;
 559                 else
 560                         /* Lustre only supports RAID0, overstripping
 561                          * and DoM for now.
 562                          */
 563                         comp->llc_pattern = v1->lmm_pattern;
 564
 565                 if (v1->lmm_stripe_size == 0)
 566                         comp->llc_stripe_size = LLAPI_LAYOUT_DEFAULT;
 567                 else
 568                         comp->llc_stripe_size = v1->lmm_stripe_size;
 569
 570                 if (v1->lmm_stripe_count == (typeof(v1->lmm_stripe_count))-1)
 571                         comp->llc_stripe_count = LLAPI_LAYOUT_WIDE;
 572                 else if (v1->lmm_stripe_count == 0)
 573                         comp->llc_stripe_count = LLAPI_LAYOUT_DEFAULT;
 574                 else
 575                         comp->llc_stripe_count = v1->lmm_stripe_count;
 576
 577                 if (v1->lmm_stripe_offset ==
 578                     (typeof(v1->lmm_stripe_offset))-1)
 579                         comp->llc_stripe_offset = LLAPI_LAYOUT_DEFAULT;
 580                 else
 581                         comp->llc_stripe_offset = v1->lmm_stripe_offset;
 582
 583                 if (v1->lmm_magic != LOV_USER_MAGIC_V1) {
 584                         const struct lov_user_md_v3 *lumv3;
 585                         lumv3 = (struct lov_user_md_v3 *)v1;
 586                         snprintf(comp->llc_pool_name,
 587                                  sizeof(comp->llc_pool_name),
 588                                  "%s", lumv3->lmm_pool_name);
 589                         memcpy(comp->llc_objects, lumv3->lmm_objects,
 590                                obj_count * sizeof(lumv3->lmm_objects[0]));
 591                 } else {
 592                         const struct lov_user_md_v1 *lumv1;
 593                         lumv1 = (struct lov_user_md_v1 *)v1;
 594                         memcpy(comp->llc_objects, lumv1->lmm_objects,
 595                                obj_count * sizeof(lumv1->lmm_objects[0]));
 596                 }
 597
 598                 if (obj_count != 0)
 599                         comp->llc_stripe_offset =
 600                                 comp->llc_objects[0].l_ost_idx;
 601
 602                 comp->llc_ondisk = true;
 603                 list_add_tail(&comp->llc_list, &layout->llot_comp_list);
 604                 layout->llot_cur_comp = comp;
 605         }
 606
 607 out:
 608         if (lum != lov_xattr)
 609                 free(lum);
 610         return layout;
 611 out_layout:
 612         llapi_layout_free(layout);
 613         layout = NULL;
 614         goto out;
 615 }
 616
 617 __u32 llapi_pattern_to_lov(uint64_t pattern)
 618 {
 619         __u32 lov_pattern;
 620
 621         switch (pattern) {
 622         case LLAPI_LAYOUT_DEFAULT:
 623                 lov_pattern = LOV_PATTERN_RAID0;
 624                 break;
 625         case LLAPI_LAYOUT_RAID0:
 626                 lov_pattern = LOV_PATTERN_RAID0;
 627                 break;
 628         case LLAPI_LAYOUT_MDT:
 629                 lov_pattern = LOV_PATTERN_MDT;
 630                 break;
 631         case LLAPI_LAYOUT_OVERSTRIPING:
 632                 lov_pattern = LOV_PATTERN_OVERSTRIPING | LOV_PATTERN_RAID0;
 633                 break;
 634         default:
 635                 lov_pattern = EINVAL;
 636         }
 637
 638         return lov_pattern;
 639 }
 640
 641 /**
 642  * Convert the data from a llapi_layout to a newly allocated lov_user_md.
 643  * The caller is responsible for freeing the returned pointer.
 644  *
 645  * \param[in] layout    the layout to copy from
 646  *
 647  * \retval      valid lov_user_md pointer on success
 648  * \retval      NULL if memory allocation fails or the layout is invalid
 649  */
 650 static struct lov_user_md *
 651 llapi_layout_to_lum(const struct llapi_layout *layout)
 652 {
 653         struct llapi_layout_comp *comp;
 654         struct lov_comp_md_v1 *comp_v1 = NULL;
 655         struct lov_comp_md_entry_v1 *ent;
 656         struct lov_user_md *lum = NULL;
 657         size_t lum_size = 0;
 658         int ent_idx = 0;
 659         uint32_t offset = 0;
 660
 661         if (layout == NULL ||
 662             list_empty((struct list_head *)&layout->llot_comp_list)) {
 663                 errno = EINVAL;
 664                 return NULL;
 665         }
 666
 667         /* Allocate header of lov_comp_md_v1 if necessary */
 668         if (layout->llot_is_composite) {
 669                 int comp_cnt = 0;
 670
 671                 list_for_each_entry(comp, &layout->llot_comp_list, llc_list)
 672                         comp_cnt++;
 673
 674                 lum_size = sizeof(*comp_v1) + comp_cnt * sizeof(*ent);
 675                 lum = calloc(lum_size, 1);
 676                 if (lum == NULL) {
 677                         errno = ENOMEM;
 678                         return NULL;
 679                 }
 680                 comp_v1 = (struct lov_comp_md_v1 *)lum;
 681                 comp_v1->lcm_magic = LOV_USER_MAGIC_COMP_V1;
 682                 comp_v1->lcm_size = lum_size;
 683                 comp_v1->lcm_layout_gen = 0;
 684                 comp_v1->lcm_flags = layout->llot_flags;
 685                 comp_v1->lcm_entry_count = comp_cnt;
 686                 comp_v1->lcm_mirror_count = layout->llot_mirror_count - 1;
 687                 offset += lum_size;
 688         }
 689
 690         list_for_each_entry(comp, &layout->llot_comp_list, llc_list) {
 691                 struct lov_user_md *blob;
 692                 size_t blob_size;
 693                 uint32_t magic;
 694                 int i, obj_count = 0;
 695                 struct lov_user_ost_data *lmm_objects;
 696                 uint64_t pattern = comp->llc_pattern;
 697
 698                 if ((pattern & LLAPI_LAYOUT_SPECIFIC) != 0) {
 699                         if (comp->llc_objects_count <
 700                             comp->llc_stripe_count) {
 701                                 errno = EINVAL;
 702                                 goto error;
 703                         }
 704                         magic = LOV_USER_MAGIC_SPECIFIC;
 705                         obj_count = comp->llc_stripe_count;
 706                         pattern &= ~LLAPI_LAYOUT_SPECIFIC;
 707                 } else if (strlen(comp->llc_pool_name) != 0) {
 708                         magic = LOV_USER_MAGIC_V3;
 709                 } else {
 710                         magic = LOV_USER_MAGIC_V1;
 711                 }
 712                 /* All stripes must be specified when the pattern contains
 713                  * LLAPI_LAYOUT_SPECIFIC */
 714                 for (i = 0; i < obj_count; i++) {
 715                         if (comp->llc_objects[i].l_ost_idx ==
 716                             LLAPI_LAYOUT_IDX_MAX) {
 717                                 errno = EINVAL;
 718                                 goto error;
 719                         }
 720                 }
 721
 722                 blob_size = lov_user_md_size(obj_count, magic);
 723                 blob = realloc(lum, lum_size + blob_size);
 724                 if (blob == NULL) {
 725                         errno = ENOMEM;
 726                         goto error;
 727                 } else {
 728                         lum = blob;
 729                         comp_v1 = (struct lov_comp_md_v1 *)lum;
 730                         blob = (struct lov_user_md *)((char *)lum + lum_size);
 731                         lum_size += blob_size;
 732                 }
 733
 734                 blob->lmm_magic = magic;
 735                 blob->lmm_pattern = llapi_pattern_to_lov(pattern);
 736                 if (blob->lmm_pattern == EINVAL) {
 737                         errno = EINVAL;
 738                         goto error;
 739                 }
 740
 741                 if (comp->llc_stripe_size == LLAPI_LAYOUT_DEFAULT)
 742                         blob->lmm_stripe_size = 0;
 743                 else
 744                         blob->lmm_stripe_size = comp->llc_stripe_size;
 745
 746                 if (comp->llc_stripe_count == LLAPI_LAYOUT_DEFAULT)
 747                         blob->lmm_stripe_count = 0;
 748                 else if (comp->llc_stripe_count == LLAPI_LAYOUT_WIDE)
 749                         blob->lmm_stripe_count = LOV_ALL_STRIPES;
 750                 else
 751                         blob->lmm_stripe_count = comp->llc_stripe_count;
 752
 753                 if (comp->llc_stripe_offset == LLAPI_LAYOUT_DEFAULT)
 754                         blob->lmm_stripe_offset = -1;
 755                 else
 756                         blob->lmm_stripe_offset = comp->llc_stripe_offset;
 757
 758                 if (magic == LOV_USER_MAGIC_V3 ||
 759                     magic == LOV_USER_MAGIC_SPECIFIC) {
 760                         struct lov_user_md_v3 *lumv3 =
 761                                 (struct lov_user_md_v3 *)blob;
 762
 763                         if (comp->llc_pool_name[0] != '\0') {
 764                                 strncpy(lumv3->lmm_pool_name,
 765                                         comp->llc_pool_name,
 766                                         sizeof(lumv3->lmm_pool_name));
 767                         } else {
 768                                 memset(lumv3->lmm_pool_name, 0,
 769                                        sizeof(lumv3->lmm_pool_name));
 770                         }
 771                         lmm_objects = lumv3->lmm_objects;
 772                 } else {
 773                         lmm_objects = blob->lmm_objects;
 774                 }
 775
 776                 for (i = 0; i < obj_count; i++)
 777                         lmm_objects[i].l_ost_idx =
 778                                 comp->llc_objects[i].l_ost_idx;
 779
 780                 if (layout->llot_is_composite) {
 781                         ent = &comp_v1->lcm_entries[ent_idx];
 782                         ent->lcme_id = comp->llc_id;
 783                         ent->lcme_flags = comp->llc_flags;
 784                         if (ent->lcme_flags & LCME_FL_NOSYNC)
 785                                 ent->lcme_timestamp = comp->llc_timestamp;
 786                         ent->lcme_extent.e_start = comp->llc_extent.e_start;
 787                         ent->lcme_extent.e_end = comp->llc_extent.e_end;
 788                         ent->lcme_size = blob_size;
 789                         ent->lcme_offset = offset;
 790                         offset += blob_size;
 791                         comp_v1->lcm_size += blob_size;
 792                         ent_idx++;
 793                 } else {
 794                         break;
 795                 }
 796         }
 797
 798         return lum;
 799 error:
 800         free(lum);
 801         return NULL;
 802 }
 803
 804 /**
 805  * Get the parent directory of a path.
 806  *
 807  * \param[in] path      path to get parent of
 808  * \param[out] buf      buffer in which to store parent path
 809  * \param[in] size      size in bytes of buffer \a buf
 810  */
 811 static void get_parent_dir(const char *path, char *buf, size_t size)
 812 {
 813         char *p;
 814
 815         strncpy(buf, path, size - 1);
 816         p = strrchr(buf, '/');
 817
 818         if (p != NULL) {
 819                 *p = '\0';
 820         } else if (size >= 2) {
 821                 strncpy(buf, ".", 2);
 822                 buf[size - 1] = '\0';
 823         }
 824 }
 825
 826 /**
 827  * Substitute unspecified attribute values in \a layout with values
 828  * from fs global settings. (lov.stripesize, lov.stripecount,
 829  * lov.stripeoffset)
 830  *
 831  * \param[in] layout    layout to inherit values from
 832  * \param[in] path      file path of the filesystem
 833  */
 834 static void inherit_sys_attributes(struct llapi_layout *layout,
 835                                    const char *path)
 836 {
 837         struct llapi_layout_comp *comp;
 838         unsigned int ssize, scount, soffset;
 839         int rc;
 840
 841         rc = sattr_cache_get_defaults(NULL, path, &scount, &ssize, &soffset);
 842         if (rc)
 843                 return;
 844
 845         list_for_each_entry(comp, &layout->llot_comp_list, llc_list) {
 846                 if (comp->llc_pattern == LLAPI_LAYOUT_DEFAULT)
 847                         comp->llc_pattern = LLAPI_LAYOUT_RAID0;
 848                 if (comp->llc_stripe_size == LLAPI_LAYOUT_DEFAULT)
 849                         comp->llc_stripe_size = ssize;
 850                 if (comp->llc_stripe_count == LLAPI_LAYOUT_DEFAULT)
 851                         comp->llc_stripe_count = scount;
 852                 if (comp->llc_stripe_offset == LLAPI_LAYOUT_DEFAULT)
 853                         comp->llc_stripe_offset = soffset;
 854         }
 855 }
 856
 857 /**
 858  * Get the current component of \a layout.
 859  *
 860  * \param[in] layout    layout to get current component
 861  *
 862  * \retval      valid llapi_layout_comp pointer on success
 863  * \retval      NULL on error
 864  */
 865 static struct llapi_layout_comp *
 866 __llapi_layout_cur_comp(const struct llapi_layout *layout)
 867 {
 868         struct llapi_layout_comp *comp;
 869
 870         if (layout == NULL || layout->llot_magic != LLAPI_LAYOUT_MAGIC) {
 871                 errno = EINVAL;
 872                 return NULL;
 873         }
 874         if (layout->llot_cur_comp == NULL) {
 875                 errno = EINVAL;
 876                 return NULL;
 877         }
 878         /* Verify data consistency */
 879         list_for_each_entry(comp, &layout->llot_comp_list, llc_list)
 880                 if (comp == layout->llot_cur_comp)
 881                         return comp;
 882         errno = EFAULT;
 883         return NULL;
 884 }
 885
 886 /**
 887  * Test if any attributes of \a layout are specified.
 888  *
 889  * \param[in] layout    the layout to check
 890  *
 891  * \retval true         any attributes are specified
 892  * \retval false        all attributes are unspecified
 893  */
 894 static bool is_any_specified(const struct llapi_layout *layout)
 895 {
 896         struct llapi_layout_comp *comp;
 897
 898         comp = __llapi_layout_cur_comp(layout);
 899         if (comp == NULL)
 900                 return false;
 901
 902         if (layout->llot_is_composite || layout->llot_mirror_count != 1)
 903                 return true;
 904
 905         return comp->llc_pattern != LLAPI_LAYOUT_DEFAULT ||
 906                comp->llc_stripe_size != LLAPI_LAYOUT_DEFAULT ||
 907                comp->llc_stripe_count != LLAPI_LAYOUT_DEFAULT ||
 908                comp->llc_stripe_offset != LLAPI_LAYOUT_DEFAULT ||
 909                strlen(comp->llc_pool_name);
 910 }
 911
 912 /**
 913  * Get the striping layout for the file referenced by file descriptor \a fd.
 914  *
 915  * If the filesystem does not support the "lustre." xattr namespace, the
 916  * file must be on a non-Lustre filesystem, so set errno to ENOTTY per
 917  * convention.  If the file has no "lustre.lov" data, the file will
 918  * inherit default values, so return a default layout.
 919  *
 920  * If the kernel gives us back less than the expected amount of data,
 921  * we fail with errno set to EINTR.
 922  *
 923  * \param[in] fd        open file descriptor
 924  * \param[in] flags     open file descriptor
 925  *
 926  * \retval      valid llapi_layout pointer on success
 927  * \retval      NULL if an error occurs
 928  */
 929 struct llapi_layout *llapi_layout_get_by_fd(int fd,
 930                                             enum llapi_layout_get_flags flags)
 931 {
 932         size_t lum_len;
 933         struct lov_user_md *lum;
 934         struct llapi_layout *layout = NULL;
 935         ssize_t bytes_read;
 936         struct stat st;
 937
 938         lum_len = XATTR_SIZE_MAX;
 939         lum = malloc(lum_len);
 940         if (lum == NULL)
 941                 return NULL;
 942
 943         bytes_read = fgetxattr(fd, XATTR_LUSTRE_LOV, lum, lum_len);
 944         if (bytes_read < 0) {
 945                 if (errno == EOPNOTSUPP)
 946                         errno = ENOTTY;
 947                 else if (errno == ENODATA)
 948                         layout = llapi_layout_alloc();
 949                 goto out;
 950         }
 951
 952         /* Directories may have a positive non-zero lum->lmm_stripe_count
 953          * yet have an empty lum->lmm_objects array. For non-directories the
 954          * amount of data returned from the kernel must be consistent
 955          * with the stripe count. */
 956         if (fstat(fd, &st) < 0)
 957                 goto out;
 958
 959         layout = llapi_layout_get_by_xattr(lum, bytes_read,
 960                         S_ISDIR(st.st_mode) ? 0 : LLAPI_LAYOUT_GET_CHECK);
 961 out:
 962         free(lum);
 963         return layout;
 964 }
 965
 966 /**
 967  * Get the expected striping layout for a file at \a path.
 968  *
 969  * Substitute expected inherited attribute values for unspecified
 970  * attributes.  Unspecified attributes may belong to directories and
 971  * never-written-to files, and indicate that default values will be
 972  * assigned when files are created or first written to.  A default value
 973  * is inherited from the parent directory if the attribute is specified
 974  * there, otherwise it is inherited from the filesystem root.
 975  * Unspecified attributes normally have the value LLAPI_LAYOUT_DEFAULT.
 976  *
 977  * The complete \a path need not refer to an existing file or directory,
 978  * but some leading portion of it must reside within a lustre filesystem.
 979  * A use case for this interface would be to obtain the literal striping
 980  * values that would be assigned to a new file in a given directory.
 981  *
 982  * \param[in] path      path for which to get the expected layout
 983  *
 984  * \retval      valid llapi_layout pointer on success
 985  * \retval      NULL if an error occurs
 986  */
 987 static struct llapi_layout *llapi_layout_expected(const char *path)
 988 {
 989         struct llapi_layout     *path_layout = NULL;
 990         char                    donor_path[PATH_MAX];
 991         struct stat st;
 992         int fd;
 993         int rc;
 994
 995         fd = open(path, O_RDONLY);
 996         if (fd < 0 && errno != ENOENT)
 997                 return NULL;
 998
 999         if (fd >= 0) {
1000                 int tmp;
1001
1002                 path_layout = llapi_layout_get_by_fd(fd, 0);
1003                 tmp = errno;
1004                 close(fd);
1005                 errno = tmp;
1006         }
1007
1008         if (path_layout == NULL) {
1009                 if (errno != ENODATA && errno != ENOENT)
1010                         return NULL;
1011
1012                 path_layout = llapi_layout_alloc();
1013                 if (path_layout == NULL)
1014                         return NULL;
1015         }
1016
1017         if (is_any_specified(path_layout)) {
1018                 inherit_sys_attributes(path_layout, path);
1019                 return path_layout;
1020         }
1021
1022         llapi_layout_free(path_layout);
1023
1024         rc = stat(path, &st);
1025         if (rc < 0 && errno != ENOENT)
1026                 return NULL;
1027
1028         /* If path is a not a directory or doesn't exist, inherit layout
1029          * from parent directory. */
1030         if ((rc == 0 && !S_ISDIR(st.st_mode)) ||
1031             (rc < 0 && errno == ENOENT)) {
1032                 get_parent_dir(path, donor_path, sizeof(donor_path));
1033                 path_layout = llapi_layout_get_by_path(donor_path, 0);
1034                 if (path_layout != NULL) {
1035                         if (is_any_specified(path_layout)) {
1036                                 inherit_sys_attributes(path_layout, donor_path);
1037                                 return path_layout;
1038                         }
1039                         llapi_layout_free(path_layout);
1040                 }
1041         }
1042
1043         /* Inherit layout from the filesystem root. */
1044         rc = llapi_search_mounts(path, 0, donor_path, NULL);
1045         if (rc < 0)
1046                 return NULL;
1047         path_layout = llapi_layout_get_by_path(donor_path, 0);
1048         if (path_layout == NULL)
1049                 return NULL;
1050
1051         inherit_sys_attributes(path_layout, donor_path);
1052         return path_layout;
1053 }
1054
1055 /**
1056  * Get the striping layout for the file at \a path.
1057  *
1058  * If \a flags contains LLAPI_LAYOUT_GET_EXPECTED, substitute
1059  * expected inherited attribute values for unspecified attributes. See
1060  * llapi_layout_expected().
1061  *
1062  * \param[in] path      path for which to get the layout
1063  * \param[in] flags     flags to control how layout is retrieved
1064  *
1065  * \retval      valid llapi_layout pointer on success
1066  * \retval      NULL if an error occurs
1067  */
1068 struct llapi_layout *llapi_layout_get_by_path(const char *path,
1069                                               enum llapi_layout_get_flags flags)
1070 {
1071         struct llapi_layout *layout = NULL;
1072         bool failed = false;
1073         int open_flags;
1074         int fd;
1075         int tmp;
1076
1077         if (flags & LLAPI_LAYOUT_GET_EXPECTED)
1078                 return llapi_layout_expected(path);
1079
1080         /* Always get layout in O_DIRECT */
1081         /* Allow fetching layout even without the key on encrypted files */
1082         open_flags = O_RDONLY | O_DIRECT | O_FILE_ENC;
1083 do_open:
1084         fd = open(path, open_flags);
1085         if (fd < 0) {
1086                 if (errno != EINVAL || failed)
1087                         return layout;
1088                 /* EINVAL is because a directory cannot be opened in O_DIRECT */
1089                 open_flags = O_RDONLY | O_FILE_ENC;
1090                 failed = true;
1091                 goto do_open;
1092         }
1093
1094         layout = llapi_layout_get_by_fd(fd, flags);
1095         tmp = errno;
1096         close(fd);
1097         errno = tmp;
1098
1099         return layout;
1100 }
1101
1102 /**
1103  * Get the layout for the file with FID \a fidstr in filesystem \a lustre_dir.
1104  *
1105  * \param[in] lustre_dir        path within Lustre filesystem containing \a fid
1106  * \param[in] fid               Lustre identifier of file to get layout for
1107  *
1108  * \retval      valid llapi_layout pointer on success
1109  * \retval      NULL if an error occurs
1110  */
1111 struct llapi_layout *llapi_layout_get_by_fid(const char *lustre_dir,
1112                                              const struct lu_fid *fid,
1113                                              enum llapi_layout_get_flags flags)
1114 {
1115         int fd;
1116         int tmp;
1117         int saved_msg_level = llapi_msg_get_level();
1118         struct llapi_layout *layout = NULL;
1119
1120         /* Prevent llapi internal routines from writing to console
1121          * while executing this function, then restore previous message
1122          * level. */
1123         llapi_msg_set_level(LLAPI_MSG_OFF);
1124         fd = llapi_open_by_fid(lustre_dir, fid, O_RDONLY);
1125         llapi_msg_set_level(saved_msg_level);
1126
1127         if (fd < 0)
1128                 return NULL;
1129
1130         layout = llapi_layout_get_by_fd(fd, flags);
1131         tmp = errno;
1132         close(fd);
1133         errno = tmp;
1134
1135         return layout;
1136 }
1137
1138 /**
1139  * Get the stripe count of \a layout.
1140  *
1141  * \param[in] layout    layout to get stripe count from
1142  * \param[out] count    integer to store stripe count in
1143  *
1144  * \retval      0 on success
1145  * \retval      -1 if arguments are invalid
1146  */
1147 int llapi_layout_stripe_count_get(const struct llapi_layout *layout,
1148                                   uint64_t *count)
1149 {
1150         struct llapi_layout_comp *comp;
1151
1152         comp = __llapi_layout_cur_comp(layout);
1153         if (comp == NULL)
1154                 return -1;
1155
1156         if (count == NULL) {
1157                 errno = EINVAL;
1158                 return -1;
1159         }
1160
1161         *count = comp->llc_stripe_count;
1162
1163         return 0;
1164 }
1165
1166 /*
1167  * The llapi_layout API functions have these extra validity checks since
1168  * they use intuitively named macros to denote special behavior, whereas
1169  * the old API uses 0 and -1.
1170  */
1171
1172 bool llapi_layout_stripe_count_is_valid(int64_t stripe_count)
1173 {
1174         return stripe_count == LLAPI_LAYOUT_DEFAULT ||
1175                 stripe_count == LLAPI_LAYOUT_WIDE ||
1176                 (stripe_count != 0 && stripe_count != -1 &&
1177                  llapi_stripe_count_is_valid(stripe_count));
1178 }
1179
1180 static bool llapi_layout_extension_size_is_valid(uint64_t ext_size)
1181 {
1182         return (ext_size != 0 &&
1183                 llapi_stripe_size_is_aligned(ext_size) &&
1184                 !llapi_stripe_size_is_too_big(ext_size));
1185 }
1186
1187 static bool llapi_layout_stripe_size_is_valid(uint64_t stripe_size)
1188 {
1189         return stripe_size == LLAPI_LAYOUT_DEFAULT ||
1190                 (stripe_size != 0 &&
1191                  llapi_stripe_size_is_aligned(stripe_size) &&
1192                  !llapi_stripe_size_is_too_big(stripe_size));
1193 }
1194
1195 static bool llapi_layout_stripe_index_is_valid(int64_t stripe_index)
1196 {
1197         return stripe_index == LLAPI_LAYOUT_DEFAULT ||
1198                 (stripe_index >= 0 &&
1199                 llapi_stripe_index_is_valid(stripe_index));
1200 }
1201
1202 /**
1203  * Set the stripe count of \a layout.
1204  *
1205  * \param[in] layout    layout to set stripe count in
1206  * \param[in] count     value to be set
1207  *
1208  * \retval      0 on success
1209  * \retval      -1 if arguments are invalid
1210  */
1211 int llapi_layout_stripe_count_set(struct llapi_layout *layout,
1212                                   uint64_t count)
1213 {
1214         struct llapi_layout_comp *comp;
1215
1216         comp = __llapi_layout_cur_comp(layout);
1217         if (comp == NULL)
1218                 return -1;
1219
1220         if (!llapi_layout_stripe_count_is_valid(count)) {
1221                 errno = EINVAL;
1222                 return -1;
1223         }
1224
1225         comp->llc_stripe_count = count;
1226
1227         return 0;
1228 }
1229
1230 /**
1231  * Get the stripe/extension size of \a layout.
1232  *
1233  * \param[in] layout    layout to get stripe size from
1234  * \param[out] size     integer to store stripe size in
1235  * \param[in] extension flag if extenion size is requested
1236  *
1237  * \retval      0 on success
1238  * \retval      -1 if arguments are invalid
1239  */
1240 static int layout_stripe_size_get(const struct llapi_layout *layout,
1241                                   uint64_t *size, bool extension)
1242 {
1243         struct llapi_layout_comp *comp;
1244         int comp_ext;
1245
1246         comp = __llapi_layout_cur_comp(layout);
1247         if (comp == NULL)
1248                 return -1;
1249
1250         if (size == NULL) {
1251                 errno = EINVAL;
1252                 return -1;
1253         }
1254
1255         comp_ext = comp->llc_flags & LCME_FL_EXTENSION;
1256         if ((comp_ext && !extension) || (!comp_ext && extension)) {
1257                 errno = EINVAL;
1258                 return -1;
1259         }
1260
1261         *size = comp->llc_stripe_size;
1262         if (comp->llc_flags & LCME_FL_EXTENSION)
1263                 *size *= SEL_UNIT_SIZE;
1264
1265         return 0;
1266 }
1267
1268 int llapi_layout_stripe_size_get(const struct llapi_layout *layout,
1269                                  uint64_t *size)
1270 {
1271         return layout_stripe_size_get(layout, size, false);
1272 }
1273
1274 int llapi_layout_extension_size_get(const struct llapi_layout *layout,
1275                                     uint64_t *size)
1276 {
1277         return layout_stripe_size_get(layout, size, true);
1278 }
1279
1280 /**
1281  * Set the stripe/extension size of \a layout.
1282  *
1283  * \param[in] layout    layout to set stripe size in
1284  * \param[in] size      value to be set
1285  * \param[in] extension flag if extenion size is passed
1286  *
1287  * \retval      0 on success
1288  * \retval      -1 if arguments are invalid
1289  */
1290 static int layout_stripe_size_set(struct llapi_layout *layout,
1291                                   uint64_t size, bool extension)
1292 {
1293         struct llapi_layout_comp *comp;
1294         int comp_ext;
1295
1296         comp = __llapi_layout_cur_comp(layout);
1297         if (comp == NULL)
1298                 return -1;
1299
1300         comp_ext = comp->llc_flags & LCME_FL_EXTENSION;
1301         if ((comp_ext && !extension) || (!comp_ext && extension)) {
1302                 errno = EINVAL;
1303                 return -1;
1304         }
1305
1306         if (comp_ext)
1307                 size /= SEL_UNIT_SIZE;
1308
1309         if ((comp_ext && !llapi_layout_extension_size_is_valid(size)) ||
1310             (!comp_ext && !llapi_layout_stripe_size_is_valid(size))) {
1311                 errno = EINVAL;
1312                 return -1;
1313         }
1314
1315         comp->llc_stripe_size = size;
1316         return 0;
1317 }
1318
1319 int llapi_layout_stripe_size_set(struct llapi_layout *layout,
1320                                  uint64_t size)
1321 {
1322         return layout_stripe_size_set(layout, size, false);
1323 }
1324
1325 int llapi_layout_extension_size_set(struct llapi_layout *layout,
1326                                     uint64_t size)
1327 {
1328         return layout_stripe_size_set(layout, size, true);
1329 }
1330
1331 /**
1332  * Get the RAID pattern of \a layout.
1333  *
1334  * \param[in] layout    layout to get pattern from
1335  * \param[out] pattern  integer to store pattern in
1336  *
1337  * \retval      0 on success
1338  * \retval      -1 if arguments are invalid
1339  */
1340 int llapi_layout_pattern_get(const struct llapi_layout *layout,
1341                              uint64_t *pattern)
1342 {
1343         struct llapi_layout_comp *comp;
1344
1345         comp = __llapi_layout_cur_comp(layout);
1346         if (comp == NULL)
1347                 return -1;
1348
1349         if (pattern == NULL) {
1350                 errno = EINVAL;
1351                 return -1;
1352         }
1353
1354         *pattern = comp->llc_pattern;
1355
1356         return 0;
1357 }
1358
1359 /**
1360  * Set the pattern of \a layout.
1361  *
1362  * \param[in] layout    layout to set pattern in
1363  * \param[in] pattern   value to be set
1364  *
1365  * \retval      0 on success
1366  * \retval      -1 if arguments are invalid or RAID pattern
1367  *              is unsupported
1368  */
1369 int llapi_layout_pattern_set(struct llapi_layout *layout, uint64_t pattern)
1370 {
1371         struct llapi_layout_comp *comp;
1372
1373         comp = __llapi_layout_cur_comp(layout);
1374         if (comp == NULL)
1375                 return -1;
1376
1377         if (pattern != LLAPI_LAYOUT_DEFAULT &&
1378             pattern != LLAPI_LAYOUT_RAID0 && pattern != LLAPI_LAYOUT_MDT
1379             && pattern != LLAPI_LAYOUT_OVERSTRIPING) {
1380                 errno = EOPNOTSUPP;
1381                 return -1;
1382         }
1383
1384         comp->llc_pattern = pattern |
1385                             (comp->llc_pattern & LLAPI_LAYOUT_SPECIFIC);
1386
1387         return 0;
1388 }
1389
1390 static inline int stripe_number_roundup(int stripe_number)
1391 {
1392         unsigned int round_up = (stripe_number + 8) & ~7;
1393         return round_up > LOV_MAX_STRIPE_COUNT ?
1394                 LOV_MAX_STRIPE_COUNT : round_up;
1395 }
1396
1397 /**
1398  * Set the OST index of stripe number \a stripe_number to \a ost_index.
1399  *
1400  * If only the starting stripe's OST index is specified, then this can use
1401  * the normal LOV_MAGIC_{V1,V3} layout type.  If multiple OST indices are
1402  * given, then allocate an array to hold the list of indices and ensure that
1403  * the LOV_USER_MAGIC_SPECIFIC layout is used when creating the file.
1404  *
1405  * \param[in] layout            layout to set OST index in
1406  * \param[in] stripe_number     stripe number to set index for
1407  * \param[in] ost_index         the index to set
1408  *
1409  * \retval      0 on success
1410  * \retval      -1 if arguments are invalid or an unsupported stripe number
1411  *              was specified, error returned in errno
1412  */
1413 int llapi_layout_ost_index_set(struct llapi_layout *layout, int stripe_number,
1414                                uint64_t ost_index)
1415 {
1416         struct llapi_layout_comp *comp;
1417
1418         comp = __llapi_layout_cur_comp(layout);
1419         if (comp == NULL)
1420                 return -1;
1421
1422         if (!llapi_layout_stripe_index_is_valid(ost_index)) {
1423                 errno = EINVAL;
1424                 return -1;
1425         }
1426
1427         if (stripe_number == 0 && ost_index == LLAPI_LAYOUT_DEFAULT) {
1428                 comp->llc_stripe_offset = ost_index;
1429                 comp->llc_pattern &= ~LLAPI_LAYOUT_SPECIFIC;
1430                 __llapi_comp_objects_realloc(comp, 0);
1431         } else if (stripe_number >= 0 &&
1432                    stripe_number < LOV_MAX_STRIPE_COUNT) {
1433                 if (ost_index >= LLAPI_LAYOUT_IDX_MAX) {
1434                         errno = EINVAL;
1435                         return -1;
1436                 }
1437
1438                 /* Preallocate a few more stripes to avoid realloc() overhead.*/
1439                 if (__llapi_comp_objects_realloc(comp,
1440                                 stripe_number_roundup(stripe_number)) < 0)
1441                         return -1;
1442
1443                 comp->llc_objects[stripe_number].l_ost_idx = ost_index;
1444
1445                 if (stripe_number == 0)
1446                         comp->llc_stripe_offset = ost_index;
1447                 else
1448                         comp->llc_pattern |= LLAPI_LAYOUT_SPECIFIC;
1449
1450                 if (comp->llc_stripe_count == LLAPI_LAYOUT_DEFAULT ||
1451                     comp->llc_stripe_count <= stripe_number)
1452                         comp->llc_stripe_count = stripe_number + 1;
1453         } else {
1454                 errno = EINVAL;
1455                 return -1;
1456         }
1457
1458         return 0;
1459 }
1460
1461 /**
1462  * Get the OST index associated with stripe \a stripe_number.
1463  *
1464  * Stripes are indexed starting from zero.
1465  *
1466  * \param[in] layout            layout to get index from
1467  * \param[in] stripe_number     stripe number to get index for
1468  * \param[out] index            integer to store index in
1469  *
1470  * \retval      0 on success
1471  * \retval      -1 if arguments are invalid
1472  */
1473 int llapi_layout_ost_index_get(const struct llapi_layout *layout,
1474                                uint64_t stripe_number, uint64_t *index)
1475 {
1476         struct llapi_layout_comp *comp;
1477
1478         comp = __llapi_layout_cur_comp(layout);
1479         if (comp == NULL)
1480                 return -1;
1481
1482         if (index == NULL) {
1483                 errno = EINVAL;
1484                 return -1;
1485         }
1486
1487         if (stripe_number >= comp->llc_stripe_count ||
1488             stripe_number >= comp->llc_objects_count) {
1489                 errno = EINVAL;
1490                 return -1;
1491         }
1492
1493         if (comp->llc_stripe_offset == LLAPI_LAYOUT_DEFAULT)
1494                 *index = LLAPI_LAYOUT_DEFAULT;
1495         else
1496                 *index = comp->llc_objects[stripe_number].l_ost_idx;
1497
1498         return 0;
1499 }
1500
1501 /**
1502  *
1503  * Get the pool name of layout \a layout.
1504  *
1505  * \param[in] layout    layout to get pool name from
1506  * \param[out] dest     buffer to store pool name in
1507  * \param[in] n         size in bytes of buffer \a dest
1508  *
1509  * \retval      0 on success
1510  * \retval      -1 if arguments are invalid
1511  */
1512 int llapi_layout_pool_name_get(const struct llapi_layout *layout, char *dest,
1513                                size_t n)
1514 {
1515         struct llapi_layout_comp *comp;
1516
1517         comp = __llapi_layout_cur_comp(layout);
1518         if (comp == NULL)
1519                 return -1;
1520
1521         if (dest == NULL) {
1522                 errno = EINVAL;
1523                 return -1;
1524         }
1525
1526         strncpy(dest, comp->llc_pool_name, n);
1527
1528         return 0;
1529 }
1530
1531 /**
1532  * Set the name of the pool of layout \a layout.
1533  *
1534  * \param[in] layout    layout to set pool name in
1535  * \param[in] pool_name pool name to set
1536  *
1537  * \retval      0 on success
1538  * \retval      -1 if arguments are invalid or pool name is too long
1539  */
1540 int llapi_layout_pool_name_set(struct llapi_layout *layout,
1541                                char *pool_name)
1542 {
1543         struct llapi_layout_comp *comp;
1544
1545         comp = __llapi_layout_cur_comp(layout);
1546         if (comp == NULL)
1547                 return -1;
1548
1549         if (!llapi_pool_name_is_valid(&pool_name, NULL)) {
1550                 errno = EINVAL;
1551                 return -1;
1552         }
1553
1554         strncpy(comp->llc_pool_name, pool_name, sizeof(comp->llc_pool_name));
1555         return 0;
1556 }
1557
1558 /**
1559  * Open and possibly create a file with a given \a layout.
1560  *
1561  * If \a layout is NULL this function acts as a simple wrapper for
1562  * open().  By convention, ENOTTY is returned in errno if \a path
1563  * refers to a non-Lustre file.
1564  *
1565  * \param[in] path              name of the file to open
1566  * \param[in] open_flags        open() flags
1567  * \param[in] mode              permissions to create file, filtered by umask
1568  * \param[in] layout            layout to create new file with
1569  *
1570  * \retval              non-negative file descriptor on successful open
1571  * \retval              -1 if an error occurred
1572  */
1573 int llapi_layout_file_open(const char *path, int open_flags, mode_t mode,
1574                            const struct llapi_layout *layout)
1575 {
1576         int fd;
1577         int rc;
1578         int tmp;
1579         struct lov_user_md *lum;
1580         size_t lum_size;
1581
1582         if (path == NULL ||
1583             (layout != NULL && layout->llot_magic != LLAPI_LAYOUT_MAGIC)) {
1584                 errno = EINVAL;
1585                 return -1;
1586         }
1587
1588         if (layout) {
1589                 rc = llapi_layout_sanity((struct llapi_layout *)layout,
1590                                          path, false,
1591                                          !!(layout->llot_mirror_count > 1));
1592                 if (rc) {
1593                         llapi_layout_sanity_perror(rc);
1594                         return -1;
1595                 }
1596         }
1597
1598         /* Object creation must be postponed until after layout attributes
1599          * have been applied. */
1600         if (layout != NULL && (open_flags & O_CREAT))
1601                 open_flags |= O_LOV_DELAY_CREATE;
1602
1603         fd = open(path, open_flags, mode);
1604
1605         if (layout == NULL || fd < 0)
1606                 return fd;
1607
1608         lum = llapi_layout_to_lum(layout);
1609
1610         if (lum == NULL) {
1611                 tmp = errno;
1612                 close(fd);
1613                 errno = tmp;
1614                 return -1;
1615         }
1616
1617         if (lum->lmm_magic == LOV_USER_MAGIC_COMP_V1)
1618                 lum_size = ((struct lov_comp_md_v1 *)lum)->lcm_size;
1619         else if (lum->lmm_magic == LOV_USER_MAGIC_SPECIFIC)
1620                 lum_size = lov_user_md_size(lum->lmm_stripe_count,
1621                                             lum->lmm_magic);
1622         else
1623                 lum_size = lov_user_md_size(0, lum->lmm_magic);
1624
1625         rc = fsetxattr(fd, XATTR_LUSTRE_LOV, lum, lum_size, 0);
1626         if (rc < 0) {
1627                 tmp = errno;
1628                 close(fd);
1629                 errno = tmp;
1630                 fd = -1;
1631         }
1632
1633         free(lum);
1634         errno = errno == EOPNOTSUPP ? ENOTTY : errno;
1635
1636         return fd;
1637 }
1638
1639 /**
1640  * Create a file with a given \a layout.
1641  *
1642  * Force O_CREAT and O_EXCL flags on so caller is assured that file was
1643  * created with the given \a layout on successful function return.
1644  *
1645  * \param[in] path              name of the file to open
1646  * \param[in] open_flags        open() flags
1647  * \param[in] mode              permissions to create new file with
1648  * \param[in] layout            layout to create new file with
1649  *
1650  * \retval              non-negative file descriptor on successful open
1651  * \retval              -1 if an error occurred
1652  */
1653 int llapi_layout_file_create(const char *path, int open_flags, int mode,
1654                              const struct llapi_layout *layout)
1655 {
1656         return llapi_layout_file_open(path, open_flags|O_CREAT|O_EXCL, mode,
1657                                       layout);
1658 }
1659
1660 int llapi_layout_flags_get(struct llapi_layout *layout, uint32_t *flags)
1661 {
1662         if (layout->llot_magic != LLAPI_LAYOUT_MAGIC) {
1663                 errno = EINVAL;
1664                 return -1;
1665         }
1666
1667         *flags = layout->llot_flags;
1668         return 0;
1669 }
1670
1671 /**
1672  * Set flags to the header of a component layout.
1673  */
1674 int llapi_layout_flags_set(struct llapi_layout *layout, uint32_t flags)
1675 {
1676         if (layout->llot_magic != LLAPI_LAYOUT_MAGIC) {
1677                 errno = EINVAL;
1678                 return -1;
1679         }
1680
1681         layout->llot_flags = flags;
1682         return 0;
1683 }
1684
1685 const char *llapi_layout_flags_string(uint32_t flags)
1686 {
1687         switch (flags & LCM_FL_FLR_MASK) {
1688         case LCM_FL_RDONLY:
1689                 return "ro";
1690         case LCM_FL_WRITE_PENDING:
1691                 return "wp";
1692         case LCM_FL_SYNC_PENDING:
1693                 return "sp";
1694         }
1695
1696         return "0";
1697 }
1698
1699 __u16 llapi_layout_string_flags(char *string)
1700 {
1701         if (strncmp(string, "ro", strlen(string)) == 0)
1702                 return LCM_FL_RDONLY;
1703         if (strncmp(string, "wp", strlen(string)) == 0)
1704                 return LCM_FL_WRITE_PENDING;
1705         if (strncmp(string, "sp", strlen(string)) == 0)
1706                 return LCM_FL_SYNC_PENDING;
1707
1708         return 0;
1709 }
1710
1711 /**
1712  * llapi_layout_mirror_count_is_valid() - Check the validity of mirror count.
1713  * @count: Mirror count value to be checked.
1714  *
1715  * This function checks the validity of mirror count.
1716  *
1717  * Return: true on success or false on failure.
1718  */
1719 static bool llapi_layout_mirror_count_is_valid(uint16_t count)
1720 {
1721         return count >= 0 && count <= LUSTRE_MIRROR_COUNT_MAX;
1722 }
1723
1724 /**
1725  * llapi_layout_mirror_count_get() - Get mirror count from the header of
1726  *                                   a layout.
1727  * @layout: Layout to get mirror count from.
1728  * @count:  Returned mirror count value.
1729  *
1730  * This function gets mirror count from the header of a layout.
1731  *
1732  * Return: 0 on success or -1 on failure.
1733  */
1734 int llapi_layout_mirror_count_get(struct llapi_layout *layout,
1735                                   uint16_t *count)
1736 {
1737         if (layout->llot_magic != LLAPI_LAYOUT_MAGIC) {
1738                 errno = EINVAL;
1739                 return -1;
1740         }
1741
1742         *count = layout->llot_mirror_count;
1743         return 0;
1744 }
1745
1746 /**
1747  * llapi_layout_mirror_count_set() - Set mirror count to the header of a layout.
1748  * @layout: Layout to set mirror count in.
1749  * @count:  Mirror count value to be set.
1750  *
1751  * This function sets mirror count to the header of a layout.
1752  *
1753  * Return: 0 on success or -1 on failure.
1754  */
1755 int llapi_layout_mirror_count_set(struct llapi_layout *layout,
1756                                   uint16_t count)
1757 {
1758         if (layout->llot_magic != LLAPI_LAYOUT_MAGIC) {
1759                 errno = EINVAL;
1760                 return -1;
1761         }
1762
1763         if (!llapi_layout_mirror_count_is_valid(count)) {
1764                 errno = EINVAL;
1765                 return -1;
1766         }
1767
1768         layout->llot_mirror_count = count;
1769         return 0;
1770 }
1771
1772 /**
1773  * Fetch the start and end offset of the current layout component.
1774  *
1775  * \param[in] layout    the layout component
1776  * \param[out] start    extent start, inclusive
1777  * \param[out] end      extent end, exclusive
1778  *
1779  * \retval      0 on success
1780  * \retval      <0 if error occurs
1781  */
1782 int llapi_layout_comp_extent_get(const struct llapi_layout *layout,
1783                                  uint64_t *start, uint64_t *end)
1784 {
1785         struct llapi_layout_comp *comp;
1786
1787         comp = __llapi_layout_cur_comp(layout);
1788         if (comp == NULL)
1789                 return -1;
1790
1791         if (start == NULL || end == NULL) {
1792                 errno = EINVAL;
1793                 return -1;
1794         }
1795
1796         *start = comp->llc_extent.e_start;
1797         *end = comp->llc_extent.e_end;
1798
1799         return 0;
1800 }
1801
1802 /**
1803  * Set the layout extent of a layout.
1804  *
1805  * \param[in] layout    the layout to be set
1806  * \param[in] start     extent start, inclusive
1807  * \param[in] end       extent end, exclusive
1808  *
1809  * \retval      0 on success
1810  * \retval      <0 if error occurs
1811  */
1812 int llapi_layout_comp_extent_set(struct llapi_layout *layout,
1813                                  uint64_t start, uint64_t end)
1814 {
1815         struct llapi_layout_comp *comp;
1816
1817         comp = __llapi_layout_cur_comp(layout);
1818         if (comp == NULL)
1819                 return -1;
1820
1821         if (start > end) {
1822                 errno = EINVAL;
1823                 return -1;
1824         }
1825
1826         comp->llc_extent.e_start = start;
1827         comp->llc_extent.e_end = end;
1828         layout->llot_is_composite = true;
1829
1830         return 0;
1831 }
1832
1833 /**
1834  * Gets the attribute flags of the current component.
1835  *
1836  * \param[in] layout    the layout component
1837  * \param[out] flags    stored the returned component flags
1838  *
1839  * \retval      0 on success
1840  * \retval      <0 if error occurs
1841  */
1842 int llapi_layout_comp_flags_get(const struct llapi_layout *layout,
1843                                 uint32_t *flags)
1844 {
1845         struct llapi_layout_comp *comp;
1846
1847         comp = __llapi_layout_cur_comp(layout);
1848         if (comp == NULL)
1849                 return -1;
1850
1851         if (flags == NULL) {
1852                 errno = EINVAL;
1853                 return -1;
1854         }
1855
1856         *flags = comp->llc_flags;
1857
1858         return 0;
1859 }
1860
1861 /**
1862  * Sets the specified flags of the current component leaving other flags as-is.
1863  *
1864  * \param[in] layout    the layout component
1865  * \param[in] flags     component flags to be set
1866  *
1867  * \retval      0 on success
1868  * \retval      <0 if error occurs
1869  */
1870 int llapi_layout_comp_flags_set(struct llapi_layout *layout, uint32_t flags)
1871 {
1872         struct llapi_layout_comp *comp;
1873
1874         comp = __llapi_layout_cur_comp(layout);
1875         if (comp == NULL)
1876                 return -1;
1877
1878         comp->llc_flags |= flags;
1879
1880         return 0;
1881 }
1882
1883 /**
1884  * Clears the flags specified in the flags leaving other flags as-is.
1885  *
1886  * \param[in] layout    the layout component
1887  * \param[in] flags     component flags to be cleared
1888  *
1889  * \retval      0 on success
1890  * \retval      <0 if error occurs
1891  */
1892 int llapi_layout_comp_flags_clear(struct llapi_layout *layout,
1893                                   uint32_t flags)
1894 {
1895         struct llapi_layout_comp *comp;
1896
1897         comp = __llapi_layout_cur_comp(layout);
1898         if (comp == NULL)
1899                 return -1;
1900
1901         comp->llc_flags &= ~flags;
1902
1903         return 0;
1904 }
1905
1906 /**
1907  * Fetches the file-unique component ID of the current layout component.
1908  *
1909  * \param[in] layout    the layout component
1910  * \param[out] id       stored the returned component ID
1911  *
1912  * \retval      0 on success
1913  * \retval      <0 if error occurs
1914  */
1915 int llapi_layout_comp_id_get(const struct llapi_layout *layout, uint32_t *id)
1916 {
1917         struct llapi_layout_comp *comp;
1918
1919         comp = __llapi_layout_cur_comp(layout);
1920         if (comp == NULL)
1921                 return -1;
1922
1923         if (id == NULL) {
1924                 errno = EINVAL;
1925                 return -1;
1926         }
1927         *id = comp->llc_id;
1928
1929         return 0;
1930 }
1931
1932 /**
1933  * Return the mirror id of the current layout component.
1934  *
1935  * \param[in] layout    the layout component
1936  * \param[out] id       stored the returned mirror ID
1937  *
1938  * \retval      0 on success
1939  * \retval      <0 if error occurs
1940  */
1941 int llapi_layout_mirror_id_get(const struct llapi_layout *layout, uint32_t *id)
1942 {
1943         struct llapi_layout_comp *comp;
1944
1945         comp = __llapi_layout_cur_comp(layout);
1946         if (comp == NULL)
1947                 return -1;
1948
1949         if (id == NULL) {
1950                 errno = EINVAL;
1951                 return -1;
1952         }
1953
1954         *id = mirror_id_of(comp->llc_id);
1955
1956         return 0;
1957 }
1958
1959 /**
1960  * Adds a component to \a layout, the new component will be added to
1961  * the tail of components list and it'll inherit attributes of existing
1962  * ones. The \a layout will change it's current component pointer to
1963  * the newly added component, and it'll be turned into a composite
1964  * layout if it was not before the adding.
1965  *
1966  * \param[in] layout    existing composite or plain layout
1967  *
1968  * \retval      0 on success
1969  * \retval      <0 if error occurs
1970  */
1971 int llapi_layout_comp_add(struct llapi_layout *layout)
1972 {
1973         struct llapi_layout_comp *last, *comp, *new;
1974         bool composite = layout->llot_is_composite;
1975
1976         comp = __llapi_layout_cur_comp(layout);
1977         if (comp == NULL)
1978                 return -1;
1979
1980         new = __llapi_comp_alloc(0);
1981         if (new == NULL)
1982                 return -1;
1983
1984         last = list_entry(layout->llot_comp_list.prev, typeof(*last),
1985                           llc_list);
1986
1987         list_add_tail(&new->llc_list, &layout->llot_comp_list);
1988
1989         /* We must mark the layout composite for the sanity check, but it may
1990          * not stay that way if the check fails */
1991         layout->llot_is_composite = true;
1992         layout->llot_cur_comp = new;
1993
1994         /* We need to set a temporary non-zero value for "end" when we call
1995          * comp_extent_set, so we use LUSTRE_EOF-1, which is > all allowed
1996          * for the end of the previous component.  (If we're adding this
1997          * component, the end of the previous component cannot be EOF.) */
1998         if (llapi_layout_comp_extent_set(layout, last->llc_extent.e_end,
1999                                         LUSTRE_EOF - 1)) {
2000                 llapi_layout_comp_del(layout);
2001                 layout->llot_is_composite = composite;
2002                 return -1;
2003         }
2004
2005         return 0;
2006 }
2007 /**
2008  * Adds a first component of a mirror to \a layout.
2009  * The \a layout will change it's current component pointer to
2010  * the newly added component, and it'll be turned into a composite
2011  * layout if it was not before the adding.
2012  *
2013  * \param[in] layout            existing composite or plain layout
2014  *
2015  * \retval      0 on success
2016  * \retval      <0 if error occurs
2017  */
2018 int llapi_layout_add_first_comp(struct llapi_layout *layout)
2019 {
2020         struct llapi_layout_comp *comp, *new;
2021
2022         comp = __llapi_layout_cur_comp(layout);
2023         if (comp == NULL)
2024                 return -1;
2025
2026         new = __llapi_comp_alloc(0);
2027         if (new == NULL)
2028                 return -1;
2029
2030         new->llc_extent.e_start = 0;
2031
2032         list_add_tail(&new->llc_list, &layout->llot_comp_list);
2033         layout->llot_cur_comp = new;
2034         layout->llot_is_composite = true;
2035
2036         return 0;
2037 }
2038
2039 /**
2040  * Deletes current component from the composite layout. The component
2041  * to be deleted must be the tail of components list, and it can't be
2042  * the only component in the layout.
2043  *
2044  * \param[in] layout    composite layout
2045  *
2046  * \retval      0 on success
2047  * \retval      <0 if error occurs
2048  */
2049 int llapi_layout_comp_del(struct llapi_layout *layout)
2050 {
2051         struct llapi_layout_comp *comp;
2052
2053         comp = __llapi_layout_cur_comp(layout);
2054         if (comp == NULL)
2055                 return -1;
2056
2057         if (!layout->llot_is_composite) {
2058                 errno = EINVAL;
2059                 return -1;
2060         }
2061
2062         /* It must be the tail of the list (for PFL, can be relaxed
2063          * once we get mirrored components) */
2064         if (comp->llc_list.next != &layout->llot_comp_list) {
2065                 errno = EINVAL;
2066                 return -1;
2067         }
2068         layout->llot_cur_comp =
2069                 list_entry(comp->llc_list.prev, typeof(*comp), llc_list);
2070         if (comp->llc_list.prev == &layout->llot_comp_list)
2071                 layout->llot_cur_comp = NULL;
2072
2073         list_del_init(&comp->llc_list);
2074         __llapi_comp_free(comp);
2075
2076         return 0;
2077 }
2078
2079 /**
2080  * Move the current component pointer to the component with
2081  * specified component ID.
2082  *
2083  * \param[in] layout    composite layout
2084  * \param[in] id        component ID
2085  *
2086  * \retval      =0 : moved successfully
2087  * \retval      <0 if error occurs
2088  */
2089 int llapi_layout_comp_use_id(struct llapi_layout *layout, uint32_t comp_id)
2090 {
2091         struct llapi_layout_comp *comp;
2092
2093         comp = __llapi_layout_cur_comp(layout);
2094         if (comp == NULL)
2095                 return -1; /* use previously set errno */
2096
2097         if (!layout->llot_is_composite) {
2098                 errno = EINVAL;
2099                 return -1;
2100         }
2101
2102         if (comp_id == LCME_ID_INVAL) {
2103                 errno = EINVAL;
2104                 return -1;
2105         }
2106
2107         list_for_each_entry(comp, &layout->llot_comp_list, llc_list) {
2108                 if (comp->llc_id == comp_id) {
2109                         layout->llot_cur_comp = comp;
2110                         return 0;
2111                 }
2112         }
2113         errno = ENOENT;
2114         return -1;
2115 }
2116
2117 /**
2118  * Move the current component pointer to a specified position.
2119  *
2120  * \param[in] layout    composite layout
2121  * \param[in] pos       the position to be moved, it can be:
2122  *                      LLAPI_LAYOUT_COMP_USE_FIRST: use first component
2123  *                      LLAPI_LAYOUT_COMP_USE_LAST: use last component
2124  *                      LLAPI_LAYOUT_COMP_USE_NEXT: use component after current
2125  *                      LLAPI_LAYOUT_COMP_USE_PREV: use component before current
2126  *
2127  * \retval      =0 : moved successfully
2128  * \retval      =1 : at last component with NEXT, at first component with PREV
2129  * \retval      <0 if error occurs
2130  */
2131 int llapi_layout_comp_use(struct llapi_layout *layout,
2132                           enum llapi_layout_comp_use pos)
2133 {
2134         struct llapi_layout_comp *comp, *head, *tail;
2135
2136         comp = __llapi_layout_cur_comp(layout);
2137         if (comp == NULL)
2138                 return -1;
2139
2140         if (!layout->llot_is_composite) {
2141                 if (pos == LLAPI_LAYOUT_COMP_USE_FIRST ||
2142                     pos == LLAPI_LAYOUT_COMP_USE_LAST)
2143                         return 0;
2144                 errno = ENOENT;
2145                 return 1;
2146         }
2147
2148         head = list_entry(layout->llot_comp_list.next, typeof(*head), llc_list);
2149         tail = list_entry(layout->llot_comp_list.prev, typeof(*tail), llc_list);
2150         switch (pos) {
2151         case LLAPI_LAYOUT_COMP_USE_FIRST:
2152                 layout->llot_cur_comp = head;
2153                 break;
2154         case LLAPI_LAYOUT_COMP_USE_NEXT:
2155                 if (comp == tail) {
2156                         errno = ENOENT;
2157                         return 1;
2158                 }
2159                 layout->llot_cur_comp = list_entry(comp->llc_list.next,
2160                                                    typeof(*comp), llc_list);
2161                 break;
2162         case LLAPI_LAYOUT_COMP_USE_LAST:
2163                 layout->llot_cur_comp = tail;
2164                 break;
2165         case LLAPI_LAYOUT_COMP_USE_PREV:
2166                 if (comp == head) {
2167                         errno = ENOENT;
2168                         return 1;
2169                 }
2170                 layout->llot_cur_comp = list_entry(comp->llc_list.prev,
2171                                                    typeof(*comp), llc_list);
2172                 break;
2173         default:
2174                 errno = EINVAL;
2175                 return -1;
2176         }
2177
2178         return 0;
2179 }
2180
2181 /**
2182  * Add layout component(s) to an existing file.
2183  *
2184  * \param[in] path      The path name of the file
2185  * \param[in] layout    The layout component(s) to be added
2186  */
2187 int llapi_layout_file_comp_add(const char *path,
2188                                const struct llapi_layout *layout)
2189 {
2190         int rc, fd = -1, lum_size, tmp_errno = 0;
2191         struct llapi_layout *existing_layout = NULL;
2192         struct lov_user_md *lum = NULL;
2193
2194         if (path == NULL || layout == NULL ||
2195             layout->llot_magic != LLAPI_LAYOUT_MAGIC) {
2196                 errno = EINVAL;
2197                 return -1;
2198         }
2199
2200         fd = open(path, O_RDWR);
2201         if (fd < 0) {
2202                 tmp_errno = errno;
2203                 rc = -1;
2204                 goto out;
2205         }
2206
2207         existing_layout = llapi_layout_get_by_fd(fd, 0);
2208         if (existing_layout == NULL) {
2209                 tmp_errno = errno;
2210                 rc = -1;
2211                 goto out;
2212         }
2213
2214         rc = llapi_layout_merge(&existing_layout, layout);
2215         if (rc) {
2216                 tmp_errno = errno;
2217                 rc = -1;
2218                 goto out;
2219         }
2220
2221         rc = llapi_layout_sanity(existing_layout, path, false, false);
2222         if (rc) {
2223                 tmp_errno = errno;
2224                 llapi_layout_sanity_perror(rc);
2225                 rc = -1;
2226                 goto out;
2227         }
2228
2229         lum = llapi_layout_to_lum(layout);
2230         if (lum == NULL) {
2231                 tmp_errno = errno;
2232                 rc = -1;
2233                 goto out;
2234         }
2235
2236         if (lum->lmm_magic != LOV_USER_MAGIC_COMP_V1) {
2237                 tmp_errno = EINVAL;
2238                 rc = -1;
2239                 goto out;
2240         }
2241         lum_size = ((struct lov_comp_md_v1 *)lum)->lcm_size;
2242
2243         rc = fsetxattr(fd, XATTR_LUSTRE_LOV".add", lum, lum_size, 0);
2244         if (rc < 0) {
2245                 tmp_errno = errno;
2246                 rc = -1;
2247                 goto out;
2248         }
2249 out:
2250         if (fd >= 0)
2251                 close(fd);
2252         free(lum);
2253         llapi_layout_free(existing_layout);
2254         errno = tmp_errno;
2255         return rc;
2256 }
2257
2258 /**
2259  * Delete component(s) by the specified component id or component flags
2260  * from an existing file.
2261  *
2262  * \param[in] path      path name of the file
2263  * \param[in] id        unique component ID
2264  * \param[in] flags     flags: LCME_FL_* or;
2265  *                      negative flags: (LCME_FL_NEG|LCME_FL_*)
2266  */
2267 int llapi_layout_file_comp_del(const char *path, uint32_t id, uint32_t flags)
2268 {
2269         int rc = 0, fd = -1, lum_size, tmp_errno = 0;
2270         struct llapi_layout *layout;
2271         struct llapi_layout_comp *comp, *next;
2272         struct llapi_layout *existing_layout = NULL;
2273         struct lov_user_md *lum = NULL;
2274
2275         if (path == NULL || id > LCME_ID_MAX || (flags & ~LCME_KNOWN_FLAGS)) {
2276                 errno = EINVAL;
2277                 return -1;
2278         }
2279
2280         /* Can only specify ID or flags, not both, not none. */
2281         if ((id != LCME_ID_INVAL && flags != 0) ||
2282             (id == LCME_ID_INVAL && flags == 0)) {
2283                 errno = EINVAL;
2284                 return -1;
2285         }
2286
2287         layout = llapi_layout_alloc();
2288         if (layout == NULL)
2289                 return -1;
2290
2291         llapi_layout_comp_extent_set(layout, 0, LUSTRE_EOF);
2292         comp = __llapi_layout_cur_comp(layout);
2293         if (comp == NULL) {
2294                 tmp_errno = errno;
2295                 rc = -1;
2296                 goto out;
2297         }
2298
2299         comp->llc_id = id;
2300         comp->llc_flags = flags;
2301
2302         lum = llapi_layout_to_lum(layout);
2303         if (lum == NULL) {
2304                 tmp_errno = errno;
2305                 rc = -1;
2306                 goto out;
2307         }
2308         lum_size = ((struct lov_comp_md_v1 *)lum)->lcm_size;
2309
2310         fd = open(path, O_RDWR);
2311         if (fd < 0) {
2312                 tmp_errno = errno;
2313                 rc = -1;
2314                 goto out;
2315         }
2316
2317         existing_layout = llapi_layout_get_by_fd(fd, 0);
2318         if (existing_layout == NULL) {
2319                 tmp_errno = errno;
2320                 rc = -1;
2321                 goto out;
2322         }
2323
2324         comp = NULL;
2325         next = NULL;
2326         while (rc == 0 && existing_layout->llot_cur_comp != NULL) {
2327                 rc = llapi_layout_comp_use(existing_layout, comp ?
2328                                            LLAPI_LAYOUT_COMP_USE_PREV :
2329                                            LLAPI_LAYOUT_COMP_USE_LAST);
2330                 if (rc != 0)
2331                         break;
2332
2333                 next = comp;
2334                 comp = __llapi_layout_cur_comp(existing_layout);
2335                 if (comp == NULL) {
2336                         rc = -1;
2337                         break;
2338                 }
2339
2340                 if (id != LCME_ID_INVAL && id != comp->llc_id)
2341                         continue;
2342                 else if ((flags & LCME_FL_NEG) && (flags & comp->llc_flags))
2343                         continue;
2344                 else if (flags && !(flags & comp->llc_flags))
2345                         continue;
2346
2347                 rc = llapi_layout_comp_del(existing_layout);
2348                 /* the layout position is moved to previous one, adjust */
2349                 comp = next;
2350         }
2351         if (rc < 0) {
2352                 tmp_errno = errno;
2353                 goto out;
2354         }
2355
2356         rc = llapi_layout_sanity(existing_layout, path, false, false);
2357         if (rc) {
2358                 tmp_errno = errno;
2359                 llapi_layout_sanity_perror(rc);
2360                 rc = -1;
2361                 goto out;
2362         }
2363
2364         rc = fsetxattr(fd, XATTR_LUSTRE_LOV".del", lum, lum_size, 0);
2365         if (rc < 0) {
2366                 tmp_errno = errno;
2367                 rc = -1;
2368                 goto out;
2369         }
2370
2371 out:
2372         if (fd >= 0)
2373                 close(fd);
2374         free(lum);
2375         llapi_layout_free(layout);
2376         llapi_layout_free(existing_layout);
2377         errno = tmp_errno;
2378
2379         return rc;
2380 }
2381
2382 /* Internal utility function to apply flags for sanity checking */
2383 static void llapi_layout_comp_apply_flags(struct llapi_layout_comp *comp,
2384                                           uint32_t flags)
2385 {
2386         if (flags & LCME_FL_NEG)
2387                 comp->llc_flags &= ~flags;
2388         else
2389                 comp->llc_flags |= flags;
2390 }
2391
2392 struct llapi_layout_apply_flags_args {
2393         uint32_t *lfa_ids;
2394         uint32_t *lfa_flags;
2395         int lfa_count;
2396         int lfa_rc;
2397 };
2398
2399
2400 static int llapi_layout_apply_flags_cb(struct llapi_layout *layout,
2401                                        void *arg)
2402 {
2403         struct llapi_layout_apply_flags_args *args = arg;
2404         struct llapi_layout_comp *comp;
2405         int i = 0;
2406
2407         comp = __llapi_layout_cur_comp(layout);
2408         if (comp == NULL) {
2409                 args->lfa_rc = -1;
2410                 return LLAPI_LAYOUT_ITER_STOP;
2411         }
2412
2413         for (i = 0; i < args->lfa_count; i++) {
2414                 if (comp->llc_id == args->lfa_ids[i])
2415                         llapi_layout_comp_apply_flags(comp, args->lfa_flags[i]);
2416         }
2417
2418         return LLAPI_LAYOUT_ITER_CONT;
2419 }
2420
2421 /* Apply flags to the layout for sanity checking */
2422 static int llapi_layout_apply_flags(struct llapi_layout *layout, uint32_t *ids,
2423                                     uint32_t *flags, int count)
2424 {
2425         struct llapi_layout_apply_flags_args args;
2426         int rc = 0;
2427
2428         if (!ids || !flags || count == 0) {
2429                 errno = EINVAL;
2430                 return -1;
2431         }
2432
2433         args.lfa_ids = ids;
2434         args.lfa_flags = flags;
2435         args.lfa_count = count;
2436         args.lfa_rc = 0;
2437
2438         rc = llapi_layout_comp_iterate(layout,
2439                                        llapi_layout_apply_flags_cb,
2440                                        &args);
2441         if (errno == ENOENT)
2442                 errno = 0;
2443
2444         if (rc != LLAPI_LAYOUT_ITER_CONT)
2445                 rc = args.lfa_rc;
2446
2447         return rc;
2448 }
2449 /**
2450  * Change flags by component ID of components of an existing file.
2451  * The component to be modified is specified by the comp->lcme_id value,
2452  * which must be a unique component ID.
2453  *
2454  * \param[in] path      path name of the file
2455  * \param[in] ids       An array of component IDs
2456  * \param[in] flags     flags: LCME_FL_* or;
2457  *                      negative flags: (LCME_FL_NEG|LCME_FL_*)
2458  * \param[in] count     Number of elements in ids and flags array
2459  */
2460 int llapi_layout_file_comp_set(const char *path, uint32_t *ids, uint32_t *flags,
2461                                size_t count)
2462 {
2463         int rc = -1, fd = -1, i, tmp_errno = 0;
2464         size_t lum_size;
2465         struct llapi_layout *existing_layout = NULL;
2466         struct llapi_layout *layout = NULL;
2467         struct llapi_layout_comp *comp;
2468         struct lov_user_md *lum = NULL;
2469
2470         if (path == NULL) {
2471                 errno = EINVAL;
2472                 return -1;
2473         }
2474
2475         if (!count)
2476                 return 0;
2477
2478         for (i = 0; i < count; i++) {
2479                 if (!ids[i] || !flags[i]) {
2480                         errno = EINVAL;
2481                         return -1;
2482                 }
2483
2484                 if (ids[i] > LCME_ID_MAX || (flags[i] & ~LCME_KNOWN_FLAGS)) {
2485                         errno = EINVAL;
2486                         return -1;
2487                 }
2488
2489                 /* do not allow to set or clear INIT flag */
2490                 if (flags[i] & LCME_FL_INIT) {
2491                         errno = EINVAL;
2492                         return -1;
2493                 }
2494         }
2495
2496         fd = open(path, O_RDWR);
2497         if (fd < 0) {
2498                 tmp_errno = errno;
2499                 rc = -1;
2500                 goto out;
2501         }
2502
2503         existing_layout = llapi_layout_get_by_fd(fd, 0);
2504         if (existing_layout == NULL) {
2505                 tmp_errno = errno;
2506                 rc = -1;
2507                 goto out;
2508         }
2509
2510         if (llapi_layout_apply_flags(existing_layout, ids, flags, count)) {
2511                 tmp_errno = errno;
2512                 rc = -1;
2513                 goto out;
2514         }
2515
2516         rc = llapi_layout_sanity(existing_layout, path, false, false);
2517         if (rc) {
2518                 tmp_errno = errno;
2519                 llapi_layout_sanity_perror(rc);
2520                 rc = -1;
2521                 goto out;
2522         }
2523
2524         layout = __llapi_layout_alloc();
2525         if (layout == NULL) {
2526                 tmp_errno = errno;
2527                 rc = -1;
2528                 goto out;
2529         }
2530
2531         layout->llot_is_composite = true;
2532         for (i = 0; i < count; i++) {
2533                 comp = __llapi_comp_alloc(0);
2534                 if (comp == NULL) {
2535                         tmp_errno = errno;
2536                         rc = -1;
2537                         goto out;
2538                 }
2539
2540                 comp->llc_id = ids[i];
2541                 comp->llc_flags = flags[i];
2542
2543                 list_add_tail(&comp->llc_list, &layout->llot_comp_list);
2544                 layout->llot_cur_comp = comp;
2545         }
2546
2547         lum = llapi_layout_to_lum(layout);
2548         if (lum == NULL) {
2549                 tmp_errno = errno;
2550                 rc = -1;
2551                 goto out;
2552         }
2553
2554         lum_size = ((struct lov_comp_md_v1 *)lum)->lcm_size;
2555
2556         /* flush cached pages from clients */
2557         rc = llapi_file_flush(fd);
2558         if (rc) {
2559                 tmp_errno = -rc;
2560                 rc = -1;
2561                 goto out;
2562         }
2563
2564         rc = fsetxattr(fd, XATTR_LUSTRE_LOV".set.flags", lum, lum_size, 0);
2565         if (rc < 0) {
2566                 tmp_errno = errno;
2567                 goto out;
2568         }
2569
2570         rc = 0;
2571
2572 out:
2573         if (fd >= 0)
2574                 close(fd);
2575
2576         free(lum);
2577         llapi_layout_free(existing_layout);
2578         llapi_layout_free(layout);
2579         errno = tmp_errno;
2580         return rc;
2581 }
2582
2583 /**
2584  * Check if the file layout is composite.
2585  *
2586  * \param[in] layout    the file layout to check
2587  *
2588  * \retval true         composite
2589  * \retval false        not composite
2590  */
2591 bool llapi_layout_is_composite(struct llapi_layout *layout)
2592 {
2593         return layout->llot_is_composite;
2594 }
2595
2596 /**
2597  * Iterate every components in the @layout and call callback function @cb.
2598  *
2599  * \param[in] layout    component layout list.
2600  * \param[in] cb        callback for each component
2601  * \param[in] cbdata    callback data
2602  *
2603  * \retval < 0                          error happens during the iteration
2604  * \retval LLAPI_LAYOUT_ITER_CONT       finished the iteration w/o error
2605  * \retval LLAPI_LAYOUT_ITER_STOP       got something, stop the iteration
2606  */
2607 int llapi_layout_comp_iterate(struct llapi_layout *layout,
2608                               llapi_layout_iter_cb cb, void *cbdata)
2609 {
2610         int rc;
2611
2612         rc = llapi_layout_comp_use(layout, LLAPI_LAYOUT_COMP_USE_FIRST);
2613         if (rc < 0)
2614                 return rc;
2615
2616         /**
2617          * make sure on success llapi_layout_comp_use() API returns 0 with
2618          * USE_FIRST.
2619          */
2620         assert(rc == 0);
2621
2622         while (1) {
2623                 rc = cb(layout, cbdata);
2624                 if (rc != LLAPI_LAYOUT_ITER_CONT)
2625                         break;
2626
2627                 rc = llapi_layout_comp_use(layout, LLAPI_LAYOUT_COMP_USE_NEXT);
2628                 if (rc < 0)
2629                         return rc;
2630                 else if (rc == 1)       /* reached the last comp */
2631                         return LLAPI_LAYOUT_ITER_CONT;
2632         }
2633
2634         return rc;
2635 }
2636
2637 /**
2638  * llapi_layout_merge() - Merge a composite layout into another one.
2639  * @dst_layout: Destination composite layout.
2640  * @src_layout: Source composite layout.
2641  *
2642  * This function copies all of the components from @src_layout and
2643  * appends them to @dst_layout.
2644  *
2645  * Return: 0 on success or -1 on failure.
2646  */
2647 int llapi_layout_merge(struct llapi_layout **dst_layout,
2648                        const struct llapi_layout *src_layout)
2649 {
2650         struct llapi_layout *new_layout = *dst_layout;
2651         struct llapi_layout_comp *new = NULL;
2652         struct llapi_layout_comp *comp = NULL;
2653         int i = 0;
2654
2655         if (src_layout == NULL ||
2656             list_empty((struct list_head *)&src_layout->llot_comp_list))
2657                 return 0;
2658
2659         if (new_layout == NULL) {
2660                 new_layout = __llapi_layout_alloc();
2661                 if (new_layout == NULL) {
2662                         errno = ENOMEM;
2663                         return -1;
2664                 }
2665         }
2666
2667         list_for_each_entry(comp, &src_layout->llot_comp_list, llc_list) {
2668                 new = __llapi_comp_alloc(0);
2669                 if (new == NULL) {
2670                         errno = ENOMEM;
2671                         goto error;
2672                 }
2673
2674                 new->llc_pattern = comp->llc_pattern;
2675                 new->llc_stripe_size = comp->llc_stripe_size;
2676                 new->llc_stripe_count = comp->llc_stripe_count;
2677                 new->llc_stripe_offset = comp->llc_stripe_offset;
2678
2679                 if (comp->llc_pool_name[0] != '\0')
2680                         strncpy(new->llc_pool_name, comp->llc_pool_name,
2681                                 sizeof(new->llc_pool_name));
2682
2683                 for (i = 0; i < comp->llc_objects_count; i++) {
2684                         if (__llapi_comp_objects_realloc(new,
2685                             stripe_number_roundup(i)) < 0) {
2686                                 errno = EINVAL;
2687                                 __llapi_comp_free(new);
2688                                 goto error;
2689                         }
2690                         new->llc_objects[i].l_ost_idx = \
2691                                 comp->llc_objects[i].l_ost_idx;
2692                 }
2693
2694                 new->llc_objects_count = comp->llc_objects_count;
2695                 new->llc_extent.e_start = comp->llc_extent.e_start;
2696                 new->llc_extent.e_end = comp->llc_extent.e_end;
2697                 new->llc_id = comp->llc_id;
2698                 new->llc_flags = comp->llc_flags;
2699
2700                 list_add_tail(&new->llc_list, &new_layout->llot_comp_list);
2701                 new_layout->llot_cur_comp = new;
2702         }
2703         new_layout->llot_is_composite = true;
2704
2705         *dst_layout = new_layout;
2706         return 0;
2707 error:
2708         llapi_layout_free(new_layout);
2709         return -1;
2710 }
2711
2712 /**
2713  * Get the last initialized component
2714  *
2715  * \param[in] layout    component layout list.
2716  *
2717  * \retval 0            found
2718  * \retval -EINVAL      not found
2719  * \retval -EISDIR      directory layout
2720  */
2721 int llapi_layout_get_last_init_comp(struct llapi_layout *layout)
2722 {
2723         struct llapi_layout_comp *comp = NULL, *head = NULL;
2724
2725         if (!layout->llot_is_composite)
2726                 return 0;
2727
2728         head = list_entry(layout->llot_comp_list.next, typeof(*comp), llc_list);
2729         if (head == NULL)
2730                 return -EINVAL;
2731         if (head->llc_id == 0 && !(head->llc_flags & LCME_FL_INIT))
2732                 /* a directory */
2733                 return -EISDIR;
2734
2735         /* traverse the components from the tail to find the last init one */
2736         comp = list_entry(layout->llot_comp_list.prev, typeof(*comp), llc_list);
2737         while (comp != head) {
2738                 if (comp->llc_flags & LCME_FL_INIT)
2739                         break;
2740                 comp = list_entry(comp->llc_list.prev, typeof(*comp), llc_list);
2741         }
2742
2743         layout->llot_cur_comp = comp;
2744
2745         return comp->llc_flags & LCME_FL_INIT ? 0 : -EINVAL;
2746 }
2747
2748 /**
2749  * Interit stripe info from the file's component to the mirror
2750  *
2751  * \param[in] layout    file component layout list.
2752  * \param[in] layout    mirro component layout list.
2753  *
2754  * \retval 0            on success
2755  * \retval -EINVAL      on error
2756  */
2757 int llapi_layout_mirror_inherit(struct llapi_layout *f_layout,
2758                                 struct llapi_layout *m_layout)
2759 {
2760         struct llapi_layout_comp *m_comp = NULL;
2761         struct llapi_layout_comp *f_comp = NULL;
2762         int rc = 0;
2763
2764         f_comp = __llapi_layout_cur_comp(f_layout);
2765         if (f_comp == NULL)
2766                 return -EINVAL;
2767         m_comp = __llapi_layout_cur_comp(m_layout);
2768         if (m_comp == NULL)
2769                 return -EINVAL;
2770
2771         /* DoM component does not inherit stripe size */
2772         if (m_comp->llc_pattern != LLAPI_LAYOUT_MDT)
2773                 m_comp->llc_stripe_size = f_comp->llc_stripe_size;
2774         m_comp->llc_stripe_count = f_comp->llc_stripe_count;
2775
2776         return rc;
2777 }
2778
2779 /**
2780  * Find all stale components.
2781  *
2782  * \param[in] layout            component layout list.
2783  * \param[out] comp             array of stale component info.
2784  * \param[in] comp_size         array size of @comp.
2785  * \param[in] mirror_ids        array of mirror id that only components
2786  *                              belonging to these mirror will be collected.
2787  * \param[in] ids_nr            number of mirror ids array.
2788  *
2789  * \retval              number of component info collected on sucess or
2790  *                      an error code on failure.
2791  */
2792 int llapi_mirror_find_stale(struct llapi_layout *layout,
2793                 struct llapi_resync_comp *comp, size_t comp_size,
2794                 __u16 *mirror_ids, int ids_nr)
2795 {
2796         int idx = 0;
2797         int rc;
2798
2799         rc = llapi_layout_comp_use(layout, LLAPI_LAYOUT_COMP_USE_FIRST);
2800         if (rc < 0)
2801                 goto error;
2802
2803         while (rc == 0) {
2804                 uint32_t id;
2805                 uint32_t mirror_id;
2806                 uint32_t flags;
2807                 uint64_t start, end;
2808
2809                 rc = llapi_layout_comp_flags_get(layout, &flags);
2810                 if (rc < 0)
2811                         goto error;
2812
2813                 if (!(flags & LCME_FL_STALE))
2814                         goto next;
2815
2816                 rc = llapi_layout_mirror_id_get(layout, &mirror_id);
2817                 if (rc < 0)
2818                         goto error;
2819
2820                 /* the caller only wants stale components from specific
2821                  * mirrors */
2822                 if (ids_nr > 0) {
2823                         int j;
2824
2825                         for (j = 0; j < ids_nr; j++) {
2826                                 if (mirror_ids[j] == mirror_id)
2827                                         break;
2828                         }
2829
2830                         /* not in the specified mirror */
2831                         if (j == ids_nr)
2832                                 goto next;
2833                 } else if (flags & LCME_FL_NOSYNC) {
2834                         /* if not specified mirrors, do not resync "nosync"
2835                          * mirrors */
2836                         goto next;
2837                 }
2838
2839                 rc = llapi_layout_comp_id_get(layout, &id);
2840                 if (rc < 0)
2841                         goto error;
2842
2843                 rc = llapi_layout_comp_extent_get(layout, &start, &end);
2844                 if (rc < 0)
2845                         goto error;
2846
2847                 /* pack this component into @comp array */
2848                 comp[idx].lrc_id = id;
2849                 comp[idx].lrc_mirror_id = mirror_id;
2850                 comp[idx].lrc_start = start;
2851                 comp[idx].lrc_end = end;
2852                 idx++;
2853
2854                 if (idx >= comp_size) {
2855                         rc = -EINVAL;
2856                         goto error;
2857                 }
2858
2859         next:
2860                 rc = llapi_layout_comp_use(layout, LLAPI_LAYOUT_COMP_USE_NEXT);
2861                 if (rc < 0) {
2862                         rc = -EINVAL;
2863                         goto error;
2864                 }
2865         }
2866 error:
2867         return rc < 0 ? rc : idx;
2868 }
2869
2870 /* locate @layout to a valid component covering file [file_start, file_end) */
2871 int llapi_mirror_find(struct llapi_layout *layout, uint64_t file_start,
2872                       uint64_t file_end, uint64_t *endp)
2873 {
2874         uint32_t mirror_id = 0;
2875         int rc;
2876
2877         rc = llapi_layout_comp_use(layout, LLAPI_LAYOUT_COMP_USE_FIRST);
2878         if (rc < 0)
2879                 return rc;
2880
2881         *endp = 0;
2882         while (rc == 0) {
2883                 uint64_t start, end;
2884                 uint32_t flags, id, rid;
2885
2886                 rc = llapi_layout_comp_flags_get(layout, &flags);
2887                 if (rc < 0)
2888                         return rc;
2889
2890                 if (flags & LCME_FL_STALE)
2891                         goto next;
2892
2893                 rc = llapi_layout_mirror_id_get(layout, &rid);
2894                 if (rc < 0)
2895                         return rc;
2896
2897                 rc = llapi_layout_comp_id_get(layout, &id);
2898                 if (rc < 0)
2899                         return rc;
2900
2901                 rc = llapi_layout_comp_extent_get(layout, &start, &end);
2902                 if (rc < 0)
2903                         return rc;
2904
2905                 if (file_start >= start && file_start < end) {
2906                         if (!mirror_id)
2907                                 mirror_id = rid;
2908                         else if (mirror_id != rid || *endp != start)
2909                                 break;
2910
2911                         file_start = *endp = end;
2912                         if (end >= file_end)
2913                                 break;
2914                 }
2915
2916         next:
2917                 rc = llapi_layout_comp_use(layout, LLAPI_LAYOUT_COMP_USE_NEXT);
2918                 if (rc < 0)
2919                         return rc;
2920         }
2921         if (!mirror_id)
2922                 return -ENOENT;
2923
2924         return mirror_id;
2925 }
2926
2927 int llapi_mirror_resync_many(int fd, struct llapi_layout *layout,
2928                              struct llapi_resync_comp *comp_array,
2929                              int comp_size,  uint64_t start, uint64_t end)
2930 {
2931         size_t page_size = sysconf(_SC_PAGESIZE);
2932         const size_t buflen = 4 << 20; /* 4M */
2933         void *buf;
2934         uint64_t pos = start;
2935         uint64_t data_off = pos, data_end = pos;
2936         uint32_t src = 0;
2937         int i;
2938         int rc;
2939         int rc2 = 0;
2940
2941         rc = posix_memalign(&buf, page_size, buflen);
2942         if (rc)
2943                 return -rc;
2944
2945         while (pos < end) {
2946                 uint64_t mirror_end;
2947                 ssize_t bytes_read;
2948                 size_t to_read;
2949                 size_t to_write;
2950
2951                 if (pos >= data_end) {
2952                         off_t tmp_off;
2953                         size_t data_size;
2954
2955                         if (pos >= mirror_end || !src) {
2956                                 rc = llapi_mirror_find(layout, pos, end,
2957                                                         &mirror_end);
2958                                 if (rc < 0)
2959                                         return rc;
2960                                 src = rc;
2961                                 /* restrict mirror end by resync end */
2962                                 mirror_end = MIN(end, mirror_end);
2963                         }
2964
2965                         tmp_off = llapi_mirror_data_seek(fd, src, pos,
2966                                                          &data_size);
2967                         if (tmp_off < 0) {
2968                                 /* switch to full copy */
2969                                 to_read = mirror_end - pos;
2970                                 goto do_read;
2971                         }
2972                         data_off = tmp_off;
2973                         data_end = data_off + data_size;
2974
2975                         data_off = MIN(data_off, mirror_end);
2976                         data_end = MIN(data_end, mirror_end);
2977
2978                         /* align by page, if there is data block to copy */
2979                         if (data_size)
2980                                 data_off &= ~(page_size - 1);
2981                 }
2982
2983                 if (pos < data_off) {
2984                         for (i = 0; i < comp_size; i++) {
2985                                 uint64_t cur_pos;
2986                                 size_t to_punch;
2987                                 uint32_t mid = comp_array[i].lrc_mirror_id;
2988
2989                                 /* skip non-overlapped component */
2990                                 if (pos >= comp_array[i].lrc_end ||
2991                                     data_off <= comp_array[i].lrc_start)
2992                                         continue;
2993
2994                                 if (pos < comp_array[i].lrc_start)
2995                                         cur_pos = comp_array[i].lrc_start;
2996                                 else
2997                                         cur_pos = pos;
2998
2999                                 if (data_off > comp_array[i].lrc_end)
3000                                         to_punch = comp_array[i].lrc_end -
3001                                                    cur_pos;
3002                                 else
3003                                         to_punch = data_off - cur_pos;
3004
3005                                 if (comp_array[i].lrc_end == OBD_OBJECT_EOF) {
3006                                         /* the last component can be truncated
3007                                          * safely
3008                                          */
3009                                         rc = llapi_mirror_truncate(fd, mid,
3010                                                                    cur_pos);
3011                                         /* hole at the end of file, so just
3012                                          * truncate up to set size.
3013                                          */
3014                                         if (!rc && data_off == data_end)
3015                                                 rc = llapi_mirror_truncate(fd,
3016                                                                 mid, data_end);
3017                                 } else {
3018                                         rc = llapi_mirror_punch(fd,
3019                                                 comp_array[i].lrc_mirror_id,
3020                                                 cur_pos, to_punch);
3021                                 }
3022                                 /* if failed then read failed hole range */
3023                                 if (rc < 0) {
3024                                         rc = 0;
3025                                         pos = cur_pos;
3026                                         if (pos + to_punch == data_off)
3027                                                 to_read = data_end - pos;
3028                                         else
3029                                                 to_read = to_punch;
3030                                         goto do_read;
3031                                 }
3032                         }
3033                         pos = data_off;
3034                 }
3035                 if (pos == mirror_end)
3036                         continue;
3037                 to_read = data_end - pos;
3038 do_read:
3039                 if (!to_read)
3040                         break;
3041
3042                 assert(data_end <= mirror_end);
3043
3044                 to_read = MIN(buflen, to_read);
3045                 to_read = ((to_read - 1) | (page_size - 1)) + 1;
3046                 bytes_read = llapi_mirror_read(fd, src, buf, to_read, pos);
3047                 if (bytes_read == 0) {
3048                         /* end of file */
3049                         break;
3050                 }
3051                 if (bytes_read < 0) {
3052                         rc = bytes_read;
3053                         break;
3054                 }
3055
3056                 /* round up to page align to make direct IO happy. */
3057                 to_write = ((bytes_read - 1) | (page_size - 1)) + 1;
3058
3059                 for (i = 0; i < comp_size; i++) {
3060                         ssize_t written;
3061                         off_t pos2 = pos;
3062                         size_t to_write2 = to_write;
3063
3064                         /* skip non-overlapped component */
3065                         if (pos >= comp_array[i].lrc_end ||
3066                             pos + to_write <= comp_array[i].lrc_start)
3067                                 continue;
3068
3069                         if (pos < comp_array[i].lrc_start)
3070                                 pos2 = comp_array[i].lrc_start;
3071
3072                         to_write2 -= pos2 - pos;
3073
3074                         if ((pos + to_write) > comp_array[i].lrc_end)
3075                                 to_write2 -= pos + to_write -
3076                                              comp_array[i].lrc_end;
3077
3078                         written = llapi_mirror_write(fd,
3079                                         comp_array[i].lrc_mirror_id,
3080                                         buf + pos2 - pos,
3081                                         to_write2, pos2);
3082                         if (written < 0) {
3083                                 /**
3084                                  * this component is not written successfully,
3085                                  * mark it using its lrc_synced, it is supposed
3086                                  * to be false before getting here.
3087                                  *
3088                                  * And before this function returns, all
3089                                  * elements of comp_array will reverse their
3090                                  * lrc_synced flag to reflect their true
3091                                  * meanings.
3092                                  */
3093                                 comp_array[i].lrc_synced = true;
3094                                 llapi_error(LLAPI_MSG_ERROR, written,
3095                                             "component %u not synced",
3096                                             comp_array[i].lrc_id);
3097                                 if (rc2 == 0)
3098                                         rc2 = (int)written;
3099                                 continue;
3100                         }
3101                         assert(written == to_write2);
3102                 }
3103                 pos += bytes_read;
3104         }
3105
3106         free(buf);
3107
3108         if (rc < 0) {
3109                 /* fatal error happens */
3110                 for (i = 0; i < comp_size; i++)
3111                         comp_array[i].lrc_synced = false;
3112                 return rc;
3113         }
3114
3115         /**
3116          * no fatal error happens, each lrc_synced tells whether the component
3117          * has been resync successfully (note: we'd reverse the value to
3118          * reflect its true meaning.
3119          */
3120         for (i = 0; i < comp_size; i++) {
3121                 comp_array[i].lrc_synced = !comp_array[i].lrc_synced;
3122                 if (comp_array[i].lrc_synced && pos & (page_size - 1)) {
3123                         rc = llapi_mirror_truncate(fd,
3124                                         comp_array[i].lrc_mirror_id, pos);
3125                         /* Ignore truncate error on encrypted file without the
3126                          * key if tried on LUSTRE_ENCRYPTION_UNIT_SIZE boundary.
3127                          */
3128                         if (rc < 0 && (rc != -ENOKEY ||
3129                                        pos & ~LUSTRE_ENCRYPTION_MASK))
3130                                 comp_array[i].lrc_synced = false;
3131                 }
3132         }
3133
3134         /**
3135          * returns the first error code for partially successful resync if
3136          * possible.
3137          */
3138         return rc2;
3139 }
3140
3141 enum llapi_layout_comp_sanity_error {
3142         LSE_OK,
3143         LSE_INCOMPLETE_MIRROR,
3144         LSE_ADJACENT_EXTENSION,
3145         LSE_INIT_EXTENSION,
3146         LSE_FLAGS,
3147         LSE_DOM_EXTENSION,
3148         LSE_DOM_EXTENSION_FOLLOWING,
3149         LSE_DOM_FIRST,
3150         LSE_SET_COMP_START,
3151         LSE_NOT_ZERO_LENGTH_EXTENDABLE,
3152         LSE_END_NOT_GREATER,
3153         LSE_ZERO_LENGTH_NORMAL,
3154         LSE_NOT_ADJACENT_PREV,
3155         LSE_START_GT_END,
3156         LSE_ALIGN_END,
3157         LSE_ALIGN_EXT,
3158         LSE_UNKNOWN_OST,
3159         LSE_LAST,
3160 };
3161
3162 const char *const llapi_layout_strerror[] =
3163 {
3164         [LSE_OK] = "",
3165         [LSE_INCOMPLETE_MIRROR] =
3166                 "Incomplete mirror - must go to EOF",
3167         [LSE_ADJACENT_EXTENSION] =
3168                 "No adjacent extension space components",
3169         [LSE_INIT_EXTENSION] =
3170                 "Cannot apply extension flag to init components",
3171         [LSE_FLAGS] =
3172                 "Wrong flags",
3173         [LSE_DOM_EXTENSION] =
3174                 "DoM components can't be extension space",
3175         [LSE_DOM_EXTENSION_FOLLOWING] =
3176                 "DoM components cannot be followed by extension space",
3177         [LSE_DOM_FIRST] =
3178                 "DoM component should be the first one in a file/mirror",
3179         [LSE_SET_COMP_START] =
3180                 "Must set previous component extent before adding next",
3181         [LSE_NOT_ZERO_LENGTH_EXTENDABLE] =
3182                 "Extendable component must start out zero-length",
3183         [LSE_END_NOT_GREATER] =
3184                 "Component end is before end of previous component",
3185         [LSE_ZERO_LENGTH_NORMAL] =
3186                 "Zero length components must be followed by extension",
3187         [LSE_NOT_ADJACENT_PREV] =
3188                 "Components not adjacent (end != next->start",
3189         [LSE_START_GT_END] =
3190                 "Component start is > end",
3191         [LSE_ALIGN_END] =
3192                 "The component end must be aligned by the stripe size",
3193         [LSE_ALIGN_EXT] =
3194                 "The extension size must be aligned by the stripe size",
3195         [LSE_UNKNOWN_OST] =
3196                 "An unknown OST idx is specified",
3197 };
3198
3199 struct llapi_layout_sanity_args {
3200         char lsa_fsname[MAX_OBD_NAME + 1];
3201         bool lsa_incomplete;
3202         bool lsa_flr;
3203         bool lsa_ondisk;
3204         int lsa_rc;
3205 };
3206
3207 /* The component flags can be set by users at creation/modification time. */
3208 #define LCME_USER_COMP_FLAGS    (LCME_FL_PREF_RW | LCME_FL_NOSYNC | \
3209                                  LCME_FL_EXTENSION)
3210
3211 /**
3212  * When modified, adjust llapi_stripe_param_verify() if needed as well.
3213  */
3214 static int llapi_layout_sanity_cb(struct llapi_layout *layout,
3215                                   void *arg)
3216 {
3217         struct llapi_layout_comp *comp, *next, *prev;
3218         struct llapi_layout_sanity_args *args = arg;
3219         bool first_comp = false;
3220
3221         comp = __llapi_layout_cur_comp(layout);
3222         if (comp == NULL) {
3223                 args->lsa_rc = -1;
3224                 goto out_err;
3225         }
3226
3227         if (comp->llc_list.prev != &layout->llot_comp_list)
3228                 prev = list_entry(comp->llc_list.prev, typeof(*prev),
3229                                   llc_list);
3230         else
3231                 prev = NULL;
3232
3233         if (comp->llc_list.next != &layout->llot_comp_list)
3234                 next = list_entry(comp->llc_list.next, typeof(*next),
3235                                   llc_list);
3236         else
3237                 next = NULL;
3238
3239         /* Start of zero implies a new mirror */
3240         if (comp->llc_extent.e_start == 0) {
3241                 first_comp = true;
3242                 /* Most checks apply only within one mirror, this is an
3243                  * exception. */
3244                 if (prev && prev->llc_extent.e_end != LUSTRE_EOF) {
3245                         args->lsa_rc = LSE_INCOMPLETE_MIRROR;
3246                         goto out_err;
3247                 }
3248
3249                 prev = NULL;
3250         }
3251
3252         if (next && next->llc_extent.e_start == 0)
3253                 next = NULL;
3254
3255         /* Flag sanity checks */
3256         /* No adjacent extension components */
3257         if ((comp->llc_flags & LCME_FL_EXTENSION) && next &&
3258             (next->llc_flags & LCME_FL_EXTENSION)) {
3259                 args->lsa_rc = LSE_ADJACENT_EXTENSION;
3260                 goto out_err;
3261         }
3262
3263         /* Extension flag cannot be applied to init components and the first
3264          * component of each mirror is automatically init */
3265         if ((comp->llc_flags & LCME_FL_EXTENSION) &&
3266             (comp->llc_flags & LCME_FL_INIT || first_comp)) {
3267                 args->lsa_rc = LSE_INIT_EXTENSION;
3268                 goto out_err;
3269         }
3270
3271         if (comp->llc_ondisk) {
3272                 if (comp->llc_flags & LCME_FL_NEG)
3273                         args->lsa_rc = LSE_FLAGS;
3274         } else if (!args->lsa_incomplete) {
3275                 if (args->lsa_flr) {
3276                         if (comp->llc_flags & ~LCME_USER_COMP_FLAGS)
3277                                 args->lsa_rc = LSE_FLAGS;
3278                 } else {
3279                         if (comp->llc_flags &
3280                             ~(LCME_FL_EXTENSION | LCME_FL_PREF_RW))
3281                                 args->lsa_rc = LSE_FLAGS;
3282                 }
3283         }
3284         if (args->lsa_rc)
3285                 goto out_err;
3286
3287         /* DoM sanity checks */
3288         if (comp->llc_pattern == LLAPI_LAYOUT_MDT ||
3289             comp->llc_pattern == LOV_PATTERN_MDT) {
3290                 /* DoM components can't be extension components */
3291                 if (comp->llc_flags & LCME_FL_EXTENSION) {
3292                         args->lsa_rc = LSE_DOM_EXTENSION;
3293                         goto out_err;
3294                 }
3295                 /* DoM components cannot be followed by an extension comp */
3296                 if (next && (next->llc_flags & LCME_FL_EXTENSION)) {
3297                         args->lsa_rc = LSE_DOM_EXTENSION_FOLLOWING;
3298                         goto out_err;
3299                 }
3300
3301                 /* DoM should be the first component in a mirror */
3302                 if (!first_comp) {
3303                         args->lsa_rc = LSE_DOM_FIRST;
3304                         errno = EINVAL;
3305                         goto out_err;
3306                 }
3307         }
3308
3309         /* Extent sanity checks */
3310         /* Must set previous component extent before adding another */
3311         if (prev && prev->llc_extent.e_start == 0 &&
3312             prev->llc_extent.e_end == 0) {
3313                 args->lsa_rc = LSE_SET_COMP_START;
3314                 goto out_err;
3315         }
3316
3317         if (!args->lsa_incomplete) {
3318                 /* Components followed by extension space (extendable
3319                  * components) must be zero length before initialization.
3320                  * (Except for first comp, which will be initialized on
3321                  * creation). */
3322                 if (next && (next->llc_flags & LCME_FL_EXTENSION) &&
3323                     !first_comp && !(comp->llc_flags & LCME_FL_INIT) &&
3324                     comp->llc_extent.e_start != comp->llc_extent.e_end) {
3325                         args->lsa_rc = LSE_NOT_ZERO_LENGTH_EXTENDABLE;
3326                         goto out_err;
3327                 }
3328
3329                 /* End must come after end of previous comp */
3330                 if (prev && comp->llc_extent.e_end < prev->llc_extent.e_end) {
3331                         args->lsa_rc = LSE_END_NOT_GREATER;
3332                         goto out_err;
3333                 }
3334
3335                 /* Components not followed by ext space must have length > 0. */
3336                 if (comp->llc_extent.e_start == comp->llc_extent.e_end &&
3337                     (next == NULL || !(next->llc_flags & LCME_FL_EXTENSION))) {
3338                         args->lsa_rc = LSE_ZERO_LENGTH_NORMAL;
3339                         goto out_err;
3340                 }
3341
3342                 /* The component end must be aligned by the stripe size */
3343                 if ((comp->llc_flags & LCME_FL_EXTENSION) &&
3344                     (prev->llc_stripe_size != LLAPI_LAYOUT_DEFAULT)) {
3345                         if (comp->llc_extent.e_end != LUSTRE_EOF &&
3346                             comp->llc_extent.e_end % prev->llc_stripe_size) {
3347                                 args->lsa_rc = LSE_ALIGN_END;
3348                                 goto out_err;
3349                         }
3350                         if ((comp->llc_stripe_size * SEL_UNIT_SIZE) %
3351                             prev->llc_stripe_size) {
3352                                 args->lsa_rc = LSE_ALIGN_EXT;
3353                                 goto out_err;
3354                         }
3355                 } else if (!(comp->llc_flags & LCME_FL_EXTENSION) &&
3356                            (comp->llc_stripe_size != LLAPI_LAYOUT_DEFAULT)) {
3357                         if (comp->llc_extent.e_end != LUSTRE_EOF &&
3358                             comp->llc_extent.e_end !=
3359                             comp->llc_extent.e_start &&
3360                             comp->llc_extent.e_end % comp->llc_stripe_size) {
3361                                 args->lsa_rc = LSE_ALIGN_END;
3362                                 goto out_err;
3363                         }
3364                 }
3365         }
3366
3367         /* Components must have start == prev->end */
3368         if (prev && comp->llc_extent.e_start != 0 &&
3369             comp->llc_extent.e_start != prev->llc_extent.e_end) {
3370                 args->lsa_rc = LSE_NOT_ADJACENT_PREV;
3371                 goto out_err;
3372         }
3373
3374         /* Components must have start <= end */
3375         if (comp->llc_extent.e_start > comp->llc_extent.e_end) {
3376                 args->lsa_rc = LSE_START_GT_END;
3377                 goto out_err;
3378         }
3379
3380         if (args->lsa_fsname[0] != '\0') {
3381                 int i, rc = 0;
3382
3383                 if (comp->llc_pattern & LLAPI_LAYOUT_SPECIFIC) {
3384                         assert(comp->llc_stripe_count <=
3385                                comp->llc_objects_count);
3386
3387                         for (i = 0; i < comp->llc_stripe_count && rc == 0; i++){
3388                                 if (comp->llc_objects[i].l_ost_idx ==
3389                                     LLAPI_LAYOUT_IDX_MAX) {
3390                                         args->lsa_rc = -1;
3391                                         goto out_err;
3392                                 }
3393                                 rc = llapi_layout_search_ost(
3394                                         comp->llc_objects[i].l_ost_idx,
3395                                         comp->llc_pool_name, args->lsa_fsname);
3396                         }
3397                 } else if (comp->llc_stripe_offset != LLAPI_LAYOUT_DEFAULT) {
3398                         rc = llapi_layout_search_ost(
3399                                 comp->llc_stripe_offset,
3400                                 comp->llc_pool_name, args->lsa_fsname);
3401                 }
3402                 if (rc) {
3403                         args->lsa_rc = LSE_UNKNOWN_OST;
3404                         goto out_err;
3405                 }
3406         }
3407
3408         return LLAPI_LAYOUT_ITER_CONT;
3409
3410 out_err:
3411         errno = errno ? errno : EINVAL;
3412         return LLAPI_LAYOUT_ITER_STOP;
3413 }
3414
3415 /* Print explanation of layout error */
3416 void llapi_layout_sanity_perror(int error)
3417 {
3418         if (error >= LSE_LAST || error < 0) {
3419                 fprintf(stdout, "Invalid layout, unrecognized error: %d\n",
3420                         error);
3421         } else {
3422                 fprintf(stdout, "Invalid layout: %s\n",
3423                         llapi_layout_strerror[error]);
3424         }
3425 }
3426
3427 /* Walk a layout and enforce sanity checks that apply to > 1 component
3428  *
3429  * The core idea here is that of sanity checking individual tokens vs semantic
3430  * checking.
3431  * We cannot check everything at the individual component level ('token'),
3432  * instead we must check whether or not the full layout has a valid meaning.
3433  *
3434  * An example of a component level check is "is stripe size valid?".  That is
3435  * handled when setting stripe size.
3436  *
3437  * An example of a layout level check is "are the extents of these components
3438  * valid when adjacent to one another", or "can we set these flags on adjacent
3439  * components"?
3440  *
3441  * \param[in] layout            component layout list.
3442  * \param[in] fname             file the layout to be checked for
3443  * \param[in] incomplete        if layout is complete or not - some checks can
3444  *                              only be done on complete layouts.
3445  * \param[in] flr               set when this is called from FLR mirror create
3446  *
3447  * \retval                      0, success, positive: various errors, see
3448  *                              llapi_layout_sanity_perror, -1, failure
3449  */
3450 int llapi_layout_sanity(struct llapi_layout *layout,
3451                         const char *fname,
3452                         bool incomplete,
3453                         bool flr)
3454 {
3455         struct llapi_layout_sanity_args args = { { 0 } };
3456         struct llapi_layout_comp *curr;
3457         int rc = 0;
3458
3459         if (!layout)
3460                 return 0;
3461
3462         curr = layout->llot_cur_comp;
3463         if (!curr)
3464                 return 0;
3465
3466         /* Make sure we are on a Lustre file system */
3467         if (fname) {
3468                 rc = llapi_search_fsname(fname, args.lsa_fsname);
3469                 if (rc) {
3470                         llapi_error(LLAPI_MSG_ERROR, rc,
3471                                     "'%s' is not on a Lustre filesystem",
3472                                     fname);
3473                         return rc;
3474                 }
3475         }
3476
3477         /* Set up args */
3478         args.lsa_rc = 0;
3479         args.lsa_flr = flr;
3480         args.lsa_incomplete = incomplete;
3481
3482         /* When we modify an existing layout, this tells us if it's FLR */
3483         if (mirror_id_of(curr->llc_id) > 0)
3484                 args.lsa_flr = true;
3485
3486         errno = 0;
3487         rc = llapi_layout_comp_iterate(layout,
3488                                        llapi_layout_sanity_cb,
3489                                        &args);
3490         if (errno == ENOENT)
3491                 errno = 0;
3492
3493         if (rc != LLAPI_LAYOUT_ITER_CONT)
3494                 rc = args.lsa_rc;
3495
3496         layout->llot_cur_comp = curr;
3497
3498         return rc;
3499 }
3500
3501 int llapi_layout_dom_size(struct llapi_layout *layout, uint64_t *size)
3502 {
3503         uint64_t pattern, start;
3504         int rc;
3505
3506         if (!layout || !llapi_layout_is_composite(layout)) {
3507                 *size = 0;
3508                 return 0;
3509         }
3510
3511         rc = llapi_layout_comp_use(layout, LLAPI_LAYOUT_COMP_USE_FIRST);
3512         if (rc)
3513                 return -errno;
3514
3515         rc = llapi_layout_pattern_get(layout, &pattern);
3516         if (rc)
3517                 return -errno;
3518
3519         if (pattern != LOV_PATTERN_MDT && pattern != LLAPI_LAYOUT_MDT) {
3520                 *size = 0;
3521                 return 0;
3522         }
3523
3524         rc = llapi_layout_comp_extent_get(layout, &start, size);
3525         if (rc)
3526                 return -errno;
3527         if (start)
3528                 return -ERANGE;
3529         return 0;
3530 }
3531
3532 int lov_comp_md_size(struct lov_comp_md_v1 *lcm)
3533 {
3534         if (lcm->lcm_magic == LOV_MAGIC_V1 || lcm->lcm_magic == LOV_MAGIC_V3) {
3535                 struct lov_user_md *lum = (void *)lcm;
3536
3537                 return lov_user_md_size(lum->lmm_stripe_count, lum->lmm_magic);
3538         }
3539
3540         if (lcm->lcm_magic == LOV_MAGIC_FOREIGN) {
3541                 struct lov_foreign_md *lfm = (void *)lcm;
3542
3543                 return lfm->lfm_length;
3544         }
3545
3546         if (lcm->lcm_magic != LOV_MAGIC_COMP_V1)
3547                 return -EOPNOTSUPP;
3548
3549         return lcm->lcm_size;
3550 }
3551
3552 int llapi_get_lum_file_fd(int dir_fd, const char *fname, __u64 *valid,
3553                           lstatx_t *statx, struct lov_user_md *lum,
3554                           size_t lumsize)
3555 {
3556         struct lov_user_mds_data *lmd;
3557         char buf[65536 + offsetof(typeof(*lmd), lmd_lmm)];
3558         int parent_fd = -1;
3559         int rc;
3560
3561         if (lum && lumsize < sizeof(*lum))
3562                 return -EINVAL;
3563
3564         /* If a file name is provided, it is relative to the parent directory */
3565         if (fname) {
3566                 parent_fd = dir_fd;
3567                 dir_fd = -1;
3568         }
3569
3570         lmd = (struct lov_user_mds_data *)buf;
3571         rc = get_lmd_info_fd(fname, parent_fd, dir_fd, buf, sizeof(buf),
3572                              GET_LMD_INFO);
3573         if (rc)
3574                 return rc;
3575
3576         if (valid)
3577                 *valid = lmd->lmd_flags;
3578
3579         if (statx)
3580                 memcpy(statx, &lmd->lmd_stx, sizeof(*statx));
3581
3582         if (lum) {
3583                 if (lmd->lmd_lmmsize > lumsize)
3584                         return -EOVERFLOW;
3585                 memcpy(lum, &lmd->lmd_lmm, lmd->lmd_lmmsize);
3586         }
3587
3588         return 0;
3589 }
3590
3591 int llapi_get_lum_dir_fd(int dir_fd, __u64 *valid, lstatx_t *statx,
3592                          struct lov_user_md *lum, size_t lumsize)
3593 {
3594         return llapi_get_lum_file_fd(dir_fd, NULL, valid, statx, lum, lumsize);
3595 }
3596
3597 int llapi_get_lum_file(const char *path, __u64 *valid, lstatx_t *statx,
3598                        struct lov_user_md *lum, size_t lumsize)
3599 {
3600         char parent[PATH_MAX];
3601         const char *fname;
3602         char *tmp;
3603         int offset;
3604         int dir_fd;
3605         int rc;
3606
3607         tmp = strrchr(path, '/');
3608         if (!tmp) {
3609                 strncpy(parent, ".", sizeof(parent) - 1);
3610                 offset = -1;
3611         } else {
3612                 strncpy(parent, path, tmp - path);
3613                 offset = tmp - path - 1;
3614                 parent[tmp - path] = 0;
3615         }
3616
3617         fname = path;
3618         if (offset >= 0)
3619                 fname += offset + 2;
3620
3621         dir_fd = open(parent, O_RDONLY);
3622         if (dir_fd < 0) {
3623                 rc = -errno;
3624                 llapi_error(LLAPI_MSG_ERROR, rc, "cannot open '%s'", path);
3625                 return rc;
3626         }
3627
3628         rc = llapi_get_lum_file_fd(dir_fd, fname, valid, statx, lum, lumsize);
3629         close(dir_fd);
3630         return rc;
3631 }
3632
3633 int llapi_get_lum_dir(const char *path, __u64 *valid, lstatx_t *statx,
3634                       struct lov_user_md *lum, size_t lumsize)
3635 {
3636         int dir_fd;
3637         int rc;
3638
3639         dir_fd = open(path, O_RDONLY);
3640         if (dir_fd < 0) {
3641                 rc = -errno;
3642                 llapi_error(LLAPI_MSG_ERROR, rc, "cannot open '%s'", path);
3643                 return rc;
3644         }
3645
3646         rc = llapi_get_lum_dir_fd(dir_fd, valid, statx, lum, lumsize);
3647         close(dir_fd);
3648         return rc;
3649 }