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