lustre/utils/liblustreapi_layout.c

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