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, 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 <sys/xattr.h>
  38
  39 #include <libcfs/util/list.h>
  40 #include <lustre/lustreapi.h>
  41 #include <lustre/lustre_idl.h>
  42 #include "lustreapi_internal.h"
  43
  44 /**
  45  * Layout component, which contains all attributes of a plain
  46  * V1/V3 layout.
  47  */
  48 struct llapi_layout_comp {
  49         uint64_t        llc_pattern;
  50         uint64_t        llc_stripe_size;
  51         uint64_t        llc_stripe_count;
  52         uint64_t        llc_stripe_offset;
  53         /* Add 1 so user always gets back a null terminated string. */
  54         char            llc_pool_name[LOV_MAXPOOLNAME + 1];
  55         /** Number of objects in llc_objects array if was initialized. */
  56         uint32_t        llc_objects_count;
  57         struct          lov_user_ost_data_v1 *llc_objects;
  58         /* fields used only for composite layouts */
  59         struct lu_extent        llc_extent;     /* [start, end) of component */
  60         uint32_t                llc_id;         /* unique ID of component */
  61         uint32_t                llc_flags;      /* LCME_FL_* flags */
  62         struct list_head        llc_list;       /* linked to the llapi_layout
  63                                                    components list */
  64 };
  65
  66 /**
  67  * An Opaque data type abstracting the layout of a Lustre file.
  68  */
  69 struct llapi_layout {
  70         uint32_t        llot_magic; /* LLAPI_LAYOUT_MAGIC */
  71         uint32_t        llot_gen;
  72         uint32_t        llot_flags;
  73         bool            llot_is_composite;
  74         /* Cursor pointing to one of the components in llot_comp_list */
  75         struct llapi_layout_comp *llot_cur_comp;
  76         struct list_head          llot_comp_list;
  77 };
  78
  79 /**
  80  * Compute the number of elements in the lmm_objects array of \a lum
  81  * with size \a lum_size.
  82  *
  83  * \param[in] lum       the struct lov_user_md to check
  84  * \param[in] lum_size  the number of bytes in \a lum
  85  *
  86  * \retval              number of elements in array lum->lmm_objects
  87  */
  88 static int llapi_layout_objects_in_lum(struct lov_user_md *lum, size_t lum_size)
  89 {
  90         uint32_t magic;
  91         size_t base_size;
  92
  93         if (lum_size < lov_user_md_size(0, LOV_MAGIC_V1))
  94                 return 0;
  95
  96         if (lum->lmm_magic == __swab32(LOV_MAGIC_V1) ||
  97             lum->lmm_magic == __swab32(LOV_MAGIC_V3))
  98                 magic = __swab32(lum->lmm_magic);
  99         else
 100                 magic = lum->lmm_magic;
 101
 102         base_size = lov_user_md_size(0, magic);
 103
 104         if (lum_size <= base_size)
 105                 return 0;
 106         else
 107                 return (lum_size - base_size) / sizeof(lum->lmm_objects[0]);
 108 }
 109
 110 /**
 111  * Byte-swap the fields of struct lov_user_md.
 112  *
 113  * XXX Rather than duplicating swabbing code here, we should eventually
 114  * refactor the needed functions in lustre/ptlrpc/pack_generic.c
 115  * into a library that can be shared between kernel and user code.
 116  */
 117 static void
 118 llapi_layout_swab_lov_user_md(struct lov_user_md *lum, int lum_size)
 119 {
 120         int i, j, ent_count, obj_count;
 121         struct lov_comp_md_v1 *comp_v1 = NULL;
 122         struct lov_comp_md_entry_v1 *ent;
 123         struct lov_user_ost_data *lod;
 124
 125         if (lum->lmm_magic != __swab32(LOV_MAGIC_V1) &&
 126             lum->lmm_magic != __swab32(LOV_MAGIC_V3) &&
 127             lum->lmm_magic != __swab32(LOV_MAGIC_COMP_V1))
 128                 return;
 129
 130         if (lum->lmm_magic == __swab32(LOV_MAGIC_COMP_V1))
 131                 comp_v1 = (struct lov_comp_md_v1 *)lum;
 132
 133         if (comp_v1 != NULL) {
 134                 __swab32s(&comp_v1->lcm_magic);
 135                 __swab32s(&comp_v1->lcm_size);
 136                 __swab32s(&comp_v1->lcm_layout_gen);
 137                 __swab16s(&comp_v1->lcm_flags);
 138                 __swab16s(&comp_v1->lcm_entry_count);
 139                 ent_count = comp_v1->lcm_entry_count;
 140         } else {
 141                 ent_count = 1;
 142         }
 143
 144         for (i = 0; i < ent_count; i++) {
 145                 if (comp_v1 != NULL) {
 146                         ent = &comp_v1->lcm_entries[i];
 147                         __swab32s(&ent->lcme_id);
 148                         __swab32s(&ent->lcme_flags);
 149                         __swab64s(&ent->lcme_extent.e_start);
 150                         __swab64s(&ent->lcme_extent.e_end);
 151                         __swab32s(&ent->lcme_offset);
 152                         __swab32s(&ent->lcme_size);
 153
 154                         lum = (struct lov_user_md *)((char *)comp_v1 +
 155                                         ent->lcme_offset);
 156                         lum_size = ent->lcme_size;
 157                 }
 158                 obj_count = llapi_layout_objects_in_lum(lum, lum_size);
 159
 160                 __swab32s(&lum->lmm_magic);
 161                 __swab32s(&lum->lmm_pattern);
 162                 __swab32s(&lum->lmm_stripe_size);
 163                 __swab16s(&lum->lmm_stripe_count);
 164                 __swab16s(&lum->lmm_stripe_offset);
 165
 166                 if (lum->lmm_magic != LOV_MAGIC_V1) {
 167                         struct lov_user_md_v3 *v3;
 168                         v3 = (struct lov_user_md_v3 *)lum;
 169                         lod = v3->lmm_objects;
 170                 } else {
 171                         lod = lum->lmm_objects;
 172                 }
 173
 174                 for (j = 0; j < obj_count; j++)
 175                         __swab32s(&lod[j].l_ost_idx);
 176         }
 177 }
 178
 179 /**
 180  * (Re-)allocate llc_objects[] to \a num_stripes stripes.
 181  *
 182  * Copy over existing llc_objects[], if any, to the new llc_objects[].
 183  *
 184  * \param[in] layout            existing layout to be modified
 185  * \param[in] num_stripes       number of stripes in new layout
 186  *
 187  * \retval      0 if the objects are re-allocated successfully
 188  * \retval      -1 on error with errno set
 189  */
 190 static int __llapi_comp_objects_realloc(struct llapi_layout_comp *comp,
 191                                         unsigned int new_stripes)
 192 {
 193         struct lov_user_ost_data_v1 *new_objects;
 194         unsigned int i;
 195
 196         if (new_stripes > LOV_MAX_STRIPE_COUNT) {
 197                 errno = EINVAL;
 198                 return -1;
 199         }
 200
 201         if (new_stripes == comp->llc_objects_count)
 202                 return 0;
 203
 204         if (new_stripes != 0 && new_stripes <= comp->llc_objects_count)
 205                 return 0;
 206
 207         new_objects = realloc(comp->llc_objects,
 208                               sizeof(*new_objects) * new_stripes);
 209         if (new_objects == NULL && new_stripes != 0) {
 210                 errno = ENOMEM;
 211                 return -1;
 212         }
 213
 214         for (i = comp->llc_objects_count; i < new_stripes; i++)
 215                 new_objects[i].l_ost_idx = LLAPI_LAYOUT_IDX_MAX;
 216
 217         comp->llc_objects = new_objects;
 218         comp->llc_objects_count = new_stripes;
 219
 220         return 0;
 221 }
 222
 223 /**
 224  * Allocate storage for a llapi_layout_comp with \a num_stripes stripes.
 225  *
 226  * \param[in] num_stripes       number of stripes in new layout
 227  *
 228  * \retval      valid pointer if allocation succeeds
 229  * \retval      NULL if allocation fails
 230  */
 231 static struct llapi_layout_comp *__llapi_comp_alloc(unsigned int num_stripes)
 232 {
 233         struct llapi_layout_comp *comp;
 234
 235         if (num_stripes > LOV_MAX_STRIPE_COUNT) {
 236                 errno = EINVAL;
 237                 return NULL;
 238         }
 239
 240         comp = calloc(1, sizeof(*comp));
 241         if (comp == NULL) {
 242                 errno = ENOMEM;
 243                 return NULL;
 244         }
 245
 246         comp->llc_objects = NULL;
 247         comp->llc_objects_count = 0;
 248
 249         if (__llapi_comp_objects_realloc(comp, num_stripes) < 0) {
 250                 free(comp);
 251                 return NULL;
 252         }
 253
 254         /* Set defaults. */
 255         comp->llc_pattern = LLAPI_LAYOUT_DEFAULT;
 256         comp->llc_stripe_size = LLAPI_LAYOUT_DEFAULT;
 257         comp->llc_stripe_count = LLAPI_LAYOUT_DEFAULT;
 258         comp->llc_stripe_offset = LLAPI_LAYOUT_DEFAULT;
 259         comp->llc_pool_name[0] = '\0';
 260         comp->llc_extent.e_start = 0;
 261         comp->llc_extent.e_end = LUSTRE_EOF;
 262         comp->llc_flags = 0;
 263         comp->llc_id = 0;
 264         INIT_LIST_HEAD(&comp->llc_list);
 265
 266         return comp;
 267 }
 268
 269 /**
 270  * Free memory allocated for \a comp
 271  *
 272  * \param[in] comp      previously allocated by __llapi_comp_alloc()
 273  */
 274 static void __llapi_comp_free(struct llapi_layout_comp *comp)
 275 {
 276         if (comp->llc_objects != NULL)
 277                 free(comp->llc_objects);
 278         free(comp);
 279 }
 280
 281 /**
 282  * Free memory allocated for \a layout.
 283  *
 284  * \param[in] layout    previously allocated by llapi_layout_alloc()
 285  */
 286 void llapi_layout_free(struct llapi_layout *layout)
 287 {
 288         struct llapi_layout_comp *comp, *n;
 289
 290         if (layout == NULL)
 291                 return;
 292
 293         list_for_each_entry_safe(comp, n, &layout->llot_comp_list, llc_list) {
 294                 list_del_init(&comp->llc_list);
 295                 __llapi_comp_free(comp);
 296         }
 297         free(layout);
 298 }
 299
 300 /**
 301  * Allocate and initialize a llapi_layout structure.
 302  *
 303  * \retval      valid llapi_layout pointer on success
 304  * \retval      NULL if memory allocation fails
 305  */
 306 static struct llapi_layout *__llapi_layout_alloc(void)
 307 {
 308         struct llapi_layout *layout;
 309
 310         layout = calloc(1, sizeof(*layout));
 311         if (layout == NULL) {
 312                 errno = ENOMEM;
 313                 return NULL;
 314         }
 315
 316         /* Set defaults. */
 317         layout->llot_magic = LLAPI_LAYOUT_MAGIC;
 318         layout->llot_gen = 0;
 319         layout->llot_flags = 0;
 320         layout->llot_is_composite = false;
 321         layout->llot_cur_comp = NULL;
 322         INIT_LIST_HEAD(&layout->llot_comp_list);
 323
 324         return layout;
 325 }
 326
 327 /**
 328  * Allocate and initialize a new plain layout.
 329  *
 330  * \retval      valid llapi_layout pointer on success
 331  * \retval      NULL if memory allocation fails
 332  */
 333 struct llapi_layout *llapi_layout_alloc(void)
 334 {
 335         struct llapi_layout_comp *comp;
 336         struct llapi_layout *layout;
 337
 338         layout = __llapi_layout_alloc();
 339         if (layout == NULL)
 340                 return NULL;
 341
 342         comp = __llapi_comp_alloc(0);
 343         if (comp == NULL) {
 344                 free(layout);
 345                 return NULL;
 346         }
 347
 348         list_add_tail(&comp->llc_list, &layout->llot_comp_list);
 349         layout->llot_cur_comp = comp;
 350
 351         return layout;
 352 }
 353
 354 /**
 355  * Convert the data from a lov_user_md to a newly allocated llapi_layout.
 356  * The caller is responsible for freeing the returned pointer.
 357  *
 358  * \param[in] lum       LOV user metadata structure to copy data from
 359  * \param[in] lum_size  size the the lum passed in
 360  *
 361  * \retval              valid llapi_layout pointer on success
 362  * \retval              NULL if memory allocation fails
 363  */
 364 static struct llapi_layout *
 365 llapi_layout_from_lum(const struct lov_user_md *lum, int lum_size)
 366 {
 367         struct lov_comp_md_v1 *comp_v1 = NULL;
 368         struct lov_comp_md_entry_v1 *ent;
 369         struct lov_user_md *v1;
 370         struct llapi_layout *layout;
 371         struct llapi_layout_comp *comp;
 372         int i, ent_count = 0, obj_count;
 373
 374         layout = __llapi_layout_alloc();
 375         if (layout == NULL)
 376                 return NULL;
 377
 378         if (lum->lmm_magic == LOV_MAGIC_COMP_V1) {
 379                 comp_v1 = (struct lov_comp_md_v1 *)lum;
 380                 ent_count = comp_v1->lcm_entry_count;
 381                 layout->llot_is_composite = true;
 382                 layout->llot_gen = comp_v1->lcm_layout_gen;
 383                 layout->llot_flags = comp_v1->lcm_flags;
 384         } else if (lum->lmm_magic == LOV_MAGIC_V1 ||
 385                    lum->lmm_magic == LOV_MAGIC_V3) {
 386                 ent_count = 1;
 387                 layout->llot_is_composite = false;
 388         }
 389
 390         if (ent_count == 0) {
 391                 errno = EINVAL;
 392                 goto error;
 393         }
 394
 395         v1 = (struct lov_user_md *)lum;
 396         for (i = 0; i < ent_count; i++) {
 397                 if (comp_v1 != NULL) {
 398                         ent = &comp_v1->lcm_entries[i];
 399                         v1 = (struct lov_user_md *)((char *)comp_v1 +
 400                                 ent->lcme_offset);
 401                         lum_size = ent->lcme_size;
 402                 } else {
 403                         ent = NULL;
 404                 }
 405
 406                 obj_count = llapi_layout_objects_in_lum(v1, lum_size);
 407                 comp = __llapi_comp_alloc(obj_count);
 408                 if (comp == NULL)
 409                         goto error;
 410
 411                 if (ent != NULL) {
 412                         comp->llc_extent.e_start = ent->lcme_extent.e_start;
 413                         comp->llc_extent.e_end = ent->lcme_extent.e_end;
 414                         comp->llc_id = ent->lcme_id;
 415                         comp->llc_flags = ent->lcme_flags;
 416                 } else {
 417                         comp->llc_extent.e_start = 0;
 418                         comp->llc_extent.e_end = LUSTRE_EOF;
 419                         comp->llc_id = 0;
 420                         comp->llc_flags = 0;
 421                 }
 422
 423                 if (v1->lmm_pattern == LOV_PATTERN_RAID0)
 424                         comp->llc_pattern = LLAPI_LAYOUT_RAID0;
 425                 else
 426                         /* Lustre only supports RAID0 for now. */
 427                         comp->llc_pattern = v1->lmm_pattern;
 428
 429                 if (v1->lmm_stripe_size == 0)
 430                         comp->llc_stripe_size = LLAPI_LAYOUT_DEFAULT;
 431                 else
 432                         comp->llc_stripe_size = v1->lmm_stripe_size;
 433
 434                 if (v1->lmm_stripe_count == (typeof(v1->lmm_stripe_count))-1)
 435                         comp->llc_stripe_count = LLAPI_LAYOUT_WIDE;
 436                 else if (v1->lmm_stripe_count == 0)
 437                         comp->llc_stripe_count = LLAPI_LAYOUT_DEFAULT;
 438                 else
 439                         comp->llc_stripe_count = v1->lmm_stripe_count;
 440
 441                 if (v1->lmm_stripe_offset ==
 442                     (typeof(v1->lmm_stripe_offset))-1)
 443                         comp->llc_stripe_offset = LLAPI_LAYOUT_DEFAULT;
 444                 else
 445                         comp->llc_stripe_offset = v1->lmm_stripe_offset;
 446
 447                 if (v1->lmm_magic != LOV_USER_MAGIC_V1) {
 448                         const struct lov_user_md_v3 *lumv3;
 449                         lumv3 = (struct lov_user_md_v3 *)v1;
 450                         snprintf(comp->llc_pool_name,
 451                                  sizeof(comp->llc_pool_name),
 452                                  "%s", lumv3->lmm_pool_name);
 453                         memcpy(comp->llc_objects, lumv3->lmm_objects,
 454                                obj_count * sizeof(lumv3->lmm_objects[0]));
 455                 } else {
 456                         const struct lov_user_md_v1 *lumv1;
 457                         lumv1 = (struct lov_user_md_v1 *)v1;
 458                         memcpy(comp->llc_objects, lumv1->lmm_objects,
 459                                obj_count * sizeof(lumv1->lmm_objects[0]));
 460                 }
 461
 462                 if (obj_count != 0)
 463                         comp->llc_stripe_offset =
 464                                 comp->llc_objects[0].l_ost_idx;
 465
 466                 list_add_tail(&comp->llc_list, &layout->llot_comp_list);
 467                 layout->llot_cur_comp = comp;
 468         }
 469
 470         return layout;
 471 error:
 472         llapi_layout_free(layout);
 473         return NULL;
 474 }
 475
 476 /**
 477  * Convert the data from a llapi_layout to a newly allocated lov_user_md.
 478  * The caller is responsible for freeing the returned pointer.
 479  *
 480  * \param[in] layout    the layout to copy from
 481  *
 482  * \retval      valid lov_user_md pointer on success
 483  * \retval      NULL if memory allocation fails or the layout is invalid
 484  */
 485 static struct lov_user_md *
 486 llapi_layout_to_lum(const struct llapi_layout *layout)
 487 {
 488         struct llapi_layout_comp *comp;
 489         struct lov_comp_md_v1 *comp_v1 = NULL;
 490         struct lov_comp_md_entry_v1 *ent;
 491         struct lov_user_md *lum = NULL;
 492         size_t lum_size = 0;
 493         int ent_idx = 0;
 494         uint32_t offset = 0;
 495
 496         if (layout == NULL ||
 497             list_empty((struct list_head *)&layout->llot_comp_list)) {
 498                 errno = EINVAL;
 499                 return NULL;
 500         }
 501
 502         /* Allocate header of lov_comp_md_v1 if necessary */
 503         if (layout->llot_is_composite) {
 504                 int comp_cnt = 0;
 505
 506                 list_for_each_entry(comp, &layout->llot_comp_list, llc_list)
 507                         comp_cnt++;
 508
 509                 lum_size = sizeof(*comp_v1) + comp_cnt * sizeof(*ent);
 510                 lum = malloc(lum_size);
 511                 if (lum == NULL) {
 512                         errno = ENOMEM;
 513                         return NULL;
 514                 }
 515                 comp_v1 = (struct lov_comp_md_v1 *)lum;
 516                 comp_v1->lcm_magic = LOV_USER_MAGIC_COMP_V1;
 517                 comp_v1->lcm_size = lum_size;
 518                 comp_v1->lcm_layout_gen = 0;
 519                 comp_v1->lcm_flags = 0;
 520                 comp_v1->lcm_entry_count = comp_cnt;
 521                 offset += lum_size;
 522         }
 523
 524         list_for_each_entry(comp, &layout->llot_comp_list, llc_list) {
 525                 struct lov_user_md *blob;
 526                 size_t blob_size;
 527                 uint32_t magic;
 528                 int i, obj_count = 0;
 529                 struct lov_user_ost_data *lmm_objects;
 530                 uint64_t pattern = comp->llc_pattern;
 531
 532                 if ((pattern & LLAPI_LAYOUT_SPECIFIC) != 0) {
 533                         if (comp->llc_objects_count <
 534                             comp->llc_stripe_count) {
 535                                 errno = EINVAL;
 536                                 goto error;
 537                         }
 538                         magic = LOV_USER_MAGIC_SPECIFIC;
 539                         obj_count = comp->llc_stripe_count;
 540                         pattern &= ~LLAPI_LAYOUT_SPECIFIC;
 541                 } else if (strlen(comp->llc_pool_name) != 0) {
 542                         magic = LOV_USER_MAGIC_V3;
 543                 } else {
 544                         magic = LOV_USER_MAGIC_V1;
 545                 }
 546                 /* All stripes must be specified when the pattern contains
 547                  * LLAPI_LAYOUT_SPECIFIC */
 548                 for (i = 0; i < obj_count; i++) {
 549                         if (comp->llc_objects[i].l_ost_idx ==
 550                             LLAPI_LAYOUT_IDX_MAX) {
 551                                 errno = EINVAL;
 552                                 goto error;
 553                         }
 554                 }
 555
 556                 blob_size = lov_user_md_size(obj_count, magic);
 557                 blob = realloc(lum, lum_size + blob_size);
 558                 if (blob == NULL) {
 559                         errno = ENOMEM;
 560                         goto error;
 561                 } else {
 562                         lum = blob;
 563                         blob = (struct lov_user_md *)((char *)lum + lum_size);
 564                         lum_size += blob_size;
 565                 }
 566
 567                 blob->lmm_magic = magic;
 568                 if (pattern == LLAPI_LAYOUT_DEFAULT)
 569                         blob->lmm_pattern = 0;
 570                 else if (pattern == LLAPI_LAYOUT_RAID0)
 571                         blob->lmm_pattern = LOV_PATTERN_RAID0;
 572                 else
 573                         blob->lmm_pattern = pattern;
 574
 575                 if (comp->llc_stripe_size == LLAPI_LAYOUT_DEFAULT)
 576                         blob->lmm_stripe_size = 0;
 577                 else
 578                         blob->lmm_stripe_size = comp->llc_stripe_size;
 579
 580                 if (comp->llc_stripe_count == LLAPI_LAYOUT_DEFAULT)
 581                         blob->lmm_stripe_count = 0;
 582                 else if (comp->llc_stripe_count == LLAPI_LAYOUT_WIDE)
 583                         blob->lmm_stripe_count = LOV_ALL_STRIPES;
 584                 else
 585                         blob->lmm_stripe_count = comp->llc_stripe_count;
 586
 587                 if (comp->llc_stripe_offset == LLAPI_LAYOUT_DEFAULT)
 588                         blob->lmm_stripe_offset = -1;
 589                 else
 590                         blob->lmm_stripe_offset = comp->llc_stripe_offset;
 591
 592                 if (magic == LOV_USER_MAGIC_V3 ||
 593                     magic == LOV_USER_MAGIC_SPECIFIC) {
 594                         struct lov_user_md_v3 *lumv3 =
 595                                 (struct lov_user_md_v3 *)blob;
 596
 597                         if (comp->llc_pool_name[0] != '\0') {
 598                                 strncpy(lumv3->lmm_pool_name,
 599                                         comp->llc_pool_name,
 600                                         sizeof(lumv3->lmm_pool_name));
 601                         } else {
 602                                 memset(lumv3->lmm_pool_name, 0,
 603                                        sizeof(lumv3->lmm_pool_name));
 604                         }
 605                         lmm_objects = lumv3->lmm_objects;
 606                 } else {
 607                         lmm_objects = blob->lmm_objects;
 608                 }
 609
 610                 for (i = 0; i < obj_count; i++)
 611                         lmm_objects[i].l_ost_idx =
 612                                 comp->llc_objects[i].l_ost_idx;
 613
 614                 if (comp_v1 != NULL) {
 615                         ent = &comp_v1->lcm_entries[ent_idx];
 616                         ent->lcme_id = comp->llc_id;
 617                         ent->lcme_flags = comp->llc_flags;
 618                         ent->lcme_extent.e_start = comp->llc_extent.e_start;
 619                         ent->lcme_extent.e_end = comp->llc_extent.e_end;
 620                         ent->lcme_size = blob_size;
 621                         ent->lcme_offset = offset;
 622                         offset += blob_size;
 623                         comp_v1->lcm_size += blob_size;
 624                         ent_idx++;
 625                 } else {
 626                         break;
 627                 }
 628         }
 629
 630         return lum;
 631 error:
 632         free(lum);
 633         return NULL;
 634 }
 635
 636 /**
 637  * Get the parent directory of a path.
 638  *
 639  * \param[in] path      path to get parent of
 640  * \param[out] buf      buffer in which to store parent path
 641  * \param[in] size      size in bytes of buffer \a buf
 642  */
 643 static void get_parent_dir(const char *path, char *buf, size_t size)
 644 {
 645         char *p;
 646
 647         strncpy(buf, path, size);
 648         p = strrchr(buf, '/');
 649
 650         if (p != NULL)
 651                 *p = '\0';
 652         else if (size >= 2)
 653                 strncpy(buf, ".", 2);
 654 }
 655
 656 /**
 657  * Substitute unspecified attribute values in \a layout with values
 658  * from fs global settings. (lov.stripesize, lov.stripecount,
 659  * lov.stripeoffset)
 660  *
 661  * \param[in] layout    layout to inherit values from
 662  * \param[in] path      file path of the filesystem
 663  */
 664 static void inherit_sys_attributes(struct llapi_layout *layout,
 665                                    const char *path)
 666 {
 667         struct llapi_layout_comp *comp;
 668         unsigned int ssize, scount, soffset;
 669         int rc;
 670
 671         rc = sattr_cache_get_defaults(NULL, path, &scount, &ssize, &soffset);
 672         if (rc)
 673                 return;
 674
 675         list_for_each_entry(comp, &layout->llot_comp_list, llc_list) {
 676                 if (comp->llc_pattern == LLAPI_LAYOUT_DEFAULT)
 677                         comp->llc_pattern = LLAPI_LAYOUT_RAID0;
 678                 if (comp->llc_stripe_size == LLAPI_LAYOUT_DEFAULT)
 679                         comp->llc_stripe_size = ssize;
 680                 if (comp->llc_stripe_count == LLAPI_LAYOUT_DEFAULT)
 681                         comp->llc_stripe_count = scount;
 682                 if (comp->llc_stripe_offset == LLAPI_LAYOUT_DEFAULT)
 683                         comp->llc_stripe_offset = soffset;
 684         }
 685 }
 686
 687 /**
 688  * Get the current component of \a layout.
 689  *
 690  * \param[in] layout    layout to get current component
 691  *
 692  * \retval      valid llapi_layout_comp pointer on success
 693  * \retval      NULL on error
 694  */
 695 static struct llapi_layout_comp *
 696 __llapi_layout_cur_comp(const struct llapi_layout *layout)
 697 {
 698         struct llapi_layout_comp *comp;
 699
 700         if (layout == NULL || layout->llot_magic != LLAPI_LAYOUT_MAGIC) {
 701                 errno = EINVAL;
 702                 return NULL;
 703         }
 704         if (layout->llot_cur_comp == NULL) {
 705                 errno = EINVAL;
 706                 return NULL;
 707         }
 708         /* Verify data consistency */
 709         list_for_each_entry(comp, &layout->llot_comp_list, llc_list)
 710                 if (comp == layout->llot_cur_comp)
 711                         return comp;
 712         errno = EFAULT;
 713         return NULL;
 714 }
 715
 716 /**
 717  * Test if any attributes of \a layout are specified.
 718  *
 719  * \param[in] layout    the layout to check
 720  *
 721  * \retval true         any attributes are specified
 722  * \retval false        all attributes are unspecified
 723  */
 724 static bool is_any_specified(const struct llapi_layout *layout)
 725 {
 726         struct llapi_layout_comp *comp;
 727
 728         comp = __llapi_layout_cur_comp(layout);
 729         if (comp == NULL)
 730                 return false;
 731
 732         if (layout->llot_is_composite)
 733                 return true;
 734
 735         return comp->llc_pattern != LLAPI_LAYOUT_DEFAULT ||
 736                comp->llc_stripe_size != LLAPI_LAYOUT_DEFAULT ||
 737                comp->llc_stripe_count != LLAPI_LAYOUT_DEFAULT ||
 738                comp->llc_stripe_offset != LLAPI_LAYOUT_DEFAULT ||
 739                strlen(comp->llc_pool_name);
 740 }
 741
 742 /**
 743  * Check if the given \a lum_size is large enough to hold the required
 744  * fields in \a lum.
 745  *
 746  * \param[in] lum       the struct lov_user_md to check
 747  * \param[in] lum_size  the number of bytes in \a lum
 748  *
 749  * \retval true         the \a lum_size is too small
 750  * \retval false        the \a lum_size is large enough
 751  */
 752 static bool llapi_layout_lum_truncated(struct lov_user_md *lum, size_t lum_size)
 753 {
 754         uint32_t magic;
 755
 756         if (lum_size < sizeof(lum->lmm_magic))
 757                 return true;
 758
 759         if (lum->lmm_magic == LOV_MAGIC_V1 ||
 760             lum->lmm_magic == __swab32(LOV_MAGIC_V1))
 761                 magic = LOV_MAGIC_V1;
 762         else if (lum->lmm_magic == LOV_MAGIC_V3 ||
 763                  lum->lmm_magic == __swab32(LOV_MAGIC_V3))
 764                 magic = LOV_MAGIC_V3;
 765         else if (lum->lmm_magic == LOV_MAGIC_COMP_V1 ||
 766                  lum->lmm_magic == __swab32(LOV_MAGIC_COMP_V1))
 767                 magic = LOV_MAGIC_COMP_V1;
 768         else
 769                 return true;
 770
 771         if (magic == LOV_MAGIC_V1 || magic == LOV_MAGIC_V3)
 772                 return lum_size < lov_user_md_size(0, magic);
 773         else
 774                 return lum_size < sizeof(struct lov_comp_md_v1);
 775 }
 776
 777 /* Verify if the objects count in lum is consistent with the
 778  * stripe count in lum. It applies to regular file only. */
 779 static bool llapi_layout_lum_valid(struct lov_user_md *lum, int lum_size)
 780 {
 781         struct lov_comp_md_v1 *comp_v1 = NULL;
 782         int i, ent_count, obj_count;
 783
 784         if (lum->lmm_magic == LOV_MAGIC_COMP_V1) {
 785                 comp_v1 = (struct lov_comp_md_v1 *)lum;
 786                 ent_count = comp_v1->lcm_entry_count;
 787         } else if (lum->lmm_magic == LOV_MAGIC_V1 ||
 788                    lum->lmm_magic == LOV_MAGIC_V3) {
 789                 ent_count = 1;
 790         } else {
 791                 return false;
 792         }
 793
 794         for (i = 0; i < ent_count; i++) {
 795                 if (comp_v1) {
 796                         lum = (struct lov_user_md *)((char *)comp_v1 +
 797                                 comp_v1->lcm_entries[i].lcme_offset);
 798                         lum_size = comp_v1->lcm_entries[i].lcme_size;
 799                 }
 800                 obj_count = llapi_layout_objects_in_lum(lum, lum_size);
 801
 802                 if (comp_v1) {
 803                         if (!(comp_v1->lcm_entries[i].lcme_flags &
 804                                  LCME_FL_INIT) && obj_count != 0)
 805                                 return false;
 806                 } else if (obj_count != lum->lmm_stripe_count) {
 807                         return false;
 808                 }
 809         }
 810         return true;
 811 }
 812
 813 /**
 814  * Get the striping layout for the file referenced by file descriptor \a fd.
 815  *
 816  * If the filesystem does not support the "lustre." xattr namespace, the
 817  * file must be on a non-Lustre filesystem, so set errno to ENOTTY per
 818  * convention.  If the file has no "lustre.lov" data, the file will
 819  * inherit default values, so return a default layout.
 820  *
 821  * If the kernel gives us back less than the expected amount of data,
 822  * we fail with errno set to EINTR.
 823  *
 824  * \param[in] fd        open file descriptor
 825  * \param[in] flags     open file descriptor
 826  *
 827  * \retval      valid llapi_layout pointer on success
 828  * \retval      NULL if an error occurs
 829  */
 830 struct llapi_layout *llapi_layout_get_by_fd(int fd, uint32_t flags)
 831 {
 832         size_t lum_len;
 833         struct lov_user_md *lum;
 834         struct llapi_layout *layout = NULL;
 835         ssize_t bytes_read;
 836         struct stat st;
 837
 838         lum_len = XATTR_SIZE_MAX;
 839         lum = malloc(lum_len);
 840         if (lum == NULL)
 841                 return NULL;
 842
 843         bytes_read = fgetxattr(fd, XATTR_LUSTRE_LOV, lum, lum_len);
 844         if (bytes_read < 0) {
 845                 if (errno == EOPNOTSUPP)
 846                         errno = ENOTTY;
 847                 else if (errno == ENODATA)
 848                         layout = llapi_layout_alloc();
 849                 goto out;
 850         }
 851
 852         /* Return an error if we got back a partial layout. */
 853         if (llapi_layout_lum_truncated(lum, bytes_read)) {
 854                 errno = EINTR;
 855                 goto out;
 856         }
 857
 858         llapi_layout_swab_lov_user_md(lum, bytes_read);
 859
 860         /* Directories may have a positive non-zero lum->lmm_stripe_count
 861          * yet have an empty lum->lmm_objects array. For non-directories the
 862          * amount of data returned from the kernel must be consistent
 863          * with the stripe count. */
 864         if (fstat(fd, &st) < 0)
 865                 goto out;
 866
 867         if (!S_ISDIR(st.st_mode) && !llapi_layout_lum_valid(lum, bytes_read)) {
 868                 errno = EINTR;
 869                 goto out;
 870         }
 871
 872         layout = llapi_layout_from_lum(lum, bytes_read);
 873 out:
 874         free(lum);
 875         return layout;
 876 }
 877
 878 /**
 879  * Get the expected striping layout for a file at \a path.
 880  *
 881  * Substitute expected inherited attribute values for unspecified
 882  * attributes.  Unspecified attributes may belong to directories and
 883  * never-written-to files, and indicate that default values will be
 884  * assigned when files are created or first written to.  A default value
 885  * is inherited from the parent directory if the attribute is specified
 886  * there, otherwise it is inherited from the filesystem root.
 887  * Unspecified attributes normally have the value LLAPI_LAYOUT_DEFAULT.
 888  *
 889  * The complete \a path need not refer to an existing file or directory,
 890  * but some leading portion of it must reside within a lustre filesystem.
 891  * A use case for this interface would be to obtain the literal striping
 892  * values that would be assigned to a new file in a given directory.
 893  *
 894  * \param[in] path      path for which to get the expected layout
 895  *
 896  * \retval      valid llapi_layout pointer on success
 897  * \retval      NULL if an error occurs
 898  */
 899 static struct llapi_layout *llapi_layout_expected(const char *path)
 900 {
 901         struct llapi_layout     *path_layout = NULL;
 902         char                    donor_path[PATH_MAX];
 903         struct stat st;
 904         int fd;
 905         int rc;
 906
 907         fd = open(path, O_RDONLY);
 908         if (fd < 0 && errno != ENOENT)
 909                 return NULL;
 910
 911         if (fd >= 0) {
 912                 int tmp;
 913
 914                 path_layout = llapi_layout_get_by_fd(fd, 0);
 915                 tmp = errno;
 916                 close(fd);
 917                 errno = tmp;
 918         }
 919
 920         if (path_layout == NULL) {
 921                 if (errno != ENODATA && errno != ENOENT)
 922                         return NULL;
 923
 924                 path_layout = llapi_layout_alloc();
 925                 if (path_layout == NULL)
 926                         return NULL;
 927         }
 928
 929         if (is_any_specified(path_layout)) {
 930                 inherit_sys_attributes(path_layout, path);
 931                 return path_layout;
 932         }
 933
 934         llapi_layout_free(path_layout);
 935
 936         rc = stat(path, &st);
 937         if (rc < 0 && errno != ENOENT)
 938                 return NULL;
 939
 940         /* If path is a not a directory or doesn't exist, inherit layout
 941          * from parent directory. */
 942         if ((rc == 0 && !S_ISDIR(st.st_mode)) ||
 943             (rc < 0 && errno == ENOENT)) {
 944                 get_parent_dir(path, donor_path, sizeof(donor_path));
 945                 path_layout = llapi_layout_get_by_path(donor_path, 0);
 946                 if (path_layout != NULL) {
 947                         if (is_any_specified(path_layout)) {
 948                                 inherit_sys_attributes(path_layout, donor_path);
 949                                 return path_layout;
 950                         }
 951                         llapi_layout_free(path_layout);
 952                 }
 953         }
 954
 955         /* Inherit layout from the filesystem root. */
 956         rc = llapi_search_mounts(path, 0, donor_path, NULL);
 957         if (rc < 0)
 958                 return NULL;
 959         path_layout = llapi_layout_get_by_path(donor_path, 0);
 960         if (path_layout == NULL)
 961                 return NULL;
 962
 963         inherit_sys_attributes(path_layout, donor_path);
 964         return path_layout;
 965 }
 966
 967 /**
 968  * Get the striping layout for the file at \a path.
 969  *
 970  * If \a flags contains LAYOUT_GET_EXPECTED, substitute
 971  * expected inherited attribute values for unspecified attributes. See
 972  * llapi_layout_expected().
 973  *
 974  * \param[in] path      path for which to get the layout
 975  * \param[in] flags     flags to control how layout is retrieved
 976  *
 977  * \retval      valid llapi_layout pointer on success
 978  * \retval      NULL if an error occurs
 979  */
 980 struct llapi_layout *llapi_layout_get_by_path(const char *path, uint32_t flags)
 981 {
 982         struct llapi_layout *layout = NULL;
 983         int fd;
 984         int tmp;
 985
 986         if (flags & LAYOUT_GET_EXPECTED)
 987                 return llapi_layout_expected(path);
 988
 989         fd = open(path, O_RDONLY);
 990         if (fd < 0)
 991                 return layout;
 992
 993         layout = llapi_layout_get_by_fd(fd, flags);
 994         tmp = errno;
 995         close(fd);
 996         errno = tmp;
 997
 998         return layout;
 999 }
1000
1001 /**
1002  * Get the layout for the file with FID \a fidstr in filesystem \a lustre_dir.
1003  *
1004  * \param[in] lustre_dir        path within Lustre filesystem containing \a fid
1005  * \param[in] fid               Lustre identifier of file to get layout for
1006  *
1007  * \retval      valid llapi_layout pointer on success
1008  * \retval      NULL if an error occurs
1009  */
1010 struct llapi_layout *llapi_layout_get_by_fid(const char *lustre_dir,
1011                                              const lustre_fid *fid,
1012                                              uint32_t flags)
1013 {
1014         int fd;
1015         int tmp;
1016         int saved_msg_level = llapi_msg_get_level();
1017         struct llapi_layout *layout = NULL;
1018
1019         /* Prevent llapi internal routines from writing to console
1020          * while executing this function, then restore previous message
1021          * level. */
1022         llapi_msg_set_level(LLAPI_MSG_OFF);
1023         fd = llapi_open_by_fid(lustre_dir, fid, O_RDONLY);
1024         llapi_msg_set_level(saved_msg_level);
1025
1026         if (fd < 0)
1027                 return NULL;
1028
1029         layout = llapi_layout_get_by_fd(fd, flags);
1030         tmp = errno;
1031         close(fd);
1032         errno = tmp;
1033
1034         return layout;
1035 }
1036
1037 /**
1038  * Get the stripe count of \a layout.
1039  *
1040  * \param[in] layout    layout to get stripe count from
1041  * \param[out] count    integer to store stripe count in
1042  *
1043  * \retval      0 on success
1044  * \retval      -1 if arguments are invalid
1045  */
1046 int llapi_layout_stripe_count_get(const struct llapi_layout *layout,
1047                                   uint64_t *count)
1048 {
1049         struct llapi_layout_comp *comp;
1050
1051         comp = __llapi_layout_cur_comp(layout);
1052         if (comp == NULL)
1053                 return -1;
1054
1055         if (count == NULL) {
1056                 errno = EINVAL;
1057                 return -1;
1058         }
1059
1060         *count = comp->llc_stripe_count;
1061
1062         return 0;
1063 }
1064
1065 /*
1066  * The llapi_layout API functions have these extra validity checks since
1067  * they use intuitively named macros to denote special behavior, whereas
1068  * the old API uses 0 and -1.
1069  */
1070
1071 static bool llapi_layout_stripe_count_is_valid(int64_t stripe_count)
1072 {
1073         return stripe_count == LLAPI_LAYOUT_DEFAULT ||
1074                 stripe_count == LLAPI_LAYOUT_WIDE ||
1075                 (stripe_count != 0 && stripe_count != -1 &&
1076                  llapi_stripe_count_is_valid(stripe_count));
1077 }
1078
1079 static bool llapi_layout_stripe_size_is_valid(uint64_t stripe_size)
1080 {
1081         return stripe_size == LLAPI_LAYOUT_DEFAULT ||
1082                 (stripe_size != 0 &&
1083                  llapi_stripe_size_is_aligned(stripe_size) &&
1084                  !llapi_stripe_size_is_too_big(stripe_size));
1085 }
1086
1087 static bool llapi_layout_stripe_index_is_valid(int64_t stripe_index)
1088 {
1089         return stripe_index == LLAPI_LAYOUT_DEFAULT ||
1090                 (stripe_index >= 0 &&
1091                 llapi_stripe_index_is_valid(stripe_index));
1092 }
1093
1094 /**
1095  * Set the stripe count of \a layout.
1096  *
1097  * \param[in] layout    layout to set stripe count in
1098  * \param[in] count     value to be set
1099  *
1100  * \retval      0 on success
1101  * \retval      -1 if arguments are invalid
1102  */
1103 int llapi_layout_stripe_count_set(struct llapi_layout *layout,
1104                                   uint64_t count)
1105 {
1106         struct llapi_layout_comp *comp;
1107
1108         comp = __llapi_layout_cur_comp(layout);
1109         if (comp == NULL)
1110                 return -1;
1111
1112         if (!llapi_layout_stripe_count_is_valid(count)) {
1113                 errno = EINVAL;
1114                 return -1;
1115         }
1116
1117         comp->llc_stripe_count = count;
1118
1119         return 0;
1120 }
1121
1122 /**
1123  * Get the stripe size of \a layout.
1124  *
1125  * \param[in] layout    layout to get stripe size from
1126  * \param[out] size     integer to store stripe size in
1127  *
1128  * \retval      0 on success
1129  * \retval      -1 if arguments are invalid
1130  */
1131 int llapi_layout_stripe_size_get(const struct llapi_layout *layout,
1132                                  uint64_t *size)
1133 {
1134         struct llapi_layout_comp *comp;
1135
1136         comp = __llapi_layout_cur_comp(layout);
1137         if (comp == NULL)
1138                 return -1;
1139
1140         if (size == NULL) {
1141                 errno = EINVAL;
1142                 return -1;
1143         }
1144
1145         *size = comp->llc_stripe_size;
1146
1147         return 0;
1148 }
1149
1150 /**
1151  * Set the stripe size of \a layout.
1152  *
1153  * \param[in] layout    layout to set stripe size in
1154  * \param[in] size      value to be set
1155  *
1156  * \retval      0 on success
1157  * \retval      -1 if arguments are invalid
1158  */
1159 int llapi_layout_stripe_size_set(struct llapi_layout *layout,
1160                                  uint64_t size)
1161 {
1162         struct llapi_layout_comp *comp;
1163
1164         comp = __llapi_layout_cur_comp(layout);
1165         if (comp == NULL)
1166                 return -1;
1167
1168         if (!llapi_layout_stripe_size_is_valid(size)) {
1169                 errno = EINVAL;
1170                 return -1;
1171         }
1172
1173         comp->llc_stripe_size = size;
1174
1175         return 0;
1176 }
1177
1178 /**
1179  * Get the RAID pattern of \a layout.
1180  *
1181  * \param[in] layout    layout to get pattern from
1182  * \param[out] pattern  integer to store pattern in
1183  *
1184  * \retval      0 on success
1185  * \retval      -1 if arguments are invalid
1186  */
1187 int llapi_layout_pattern_get(const struct llapi_layout *layout,
1188                              uint64_t *pattern)
1189 {
1190         struct llapi_layout_comp *comp;
1191
1192         comp = __llapi_layout_cur_comp(layout);
1193         if (comp == NULL)
1194                 return -1;
1195
1196         if (pattern == NULL) {
1197                 errno = EINVAL;
1198                 return -1;
1199         }
1200
1201         *pattern = comp->llc_pattern;
1202
1203         return 0;
1204 }
1205
1206 /**
1207  * Set the RAID pattern of \a layout.
1208  *
1209  * \param[in] layout    layout to set pattern in
1210  * \param[in] pattern   value to be set
1211  *
1212  * \retval      0 on success
1213  * \retval      -1 if arguments are invalid or RAID pattern
1214  *              is unsupported
1215  */
1216 int llapi_layout_pattern_set(struct llapi_layout *layout, uint64_t pattern)
1217 {
1218         struct llapi_layout_comp *comp;
1219
1220         comp = __llapi_layout_cur_comp(layout);
1221         if (comp == NULL)
1222                 return -1;
1223
1224         if (pattern != LLAPI_LAYOUT_DEFAULT &&
1225             pattern != LLAPI_LAYOUT_RAID0) {
1226                 errno = EOPNOTSUPP;
1227                 return -1;
1228         }
1229
1230         comp->llc_pattern = pattern |
1231                             (comp->llc_pattern & LLAPI_LAYOUT_SPECIFIC);
1232
1233         return 0;
1234 }
1235
1236 static inline int stripe_number_roundup(int stripe_number)
1237 {
1238         unsigned int round_up = (stripe_number + 8) & ~7;
1239         return round_up > LOV_MAX_STRIPE_COUNT ?
1240                 LOV_MAX_STRIPE_COUNT : round_up;
1241 }
1242
1243 /**
1244  * Set the OST index of stripe number \a stripe_number to \a ost_index.
1245  *
1246  * If only the starting stripe's OST index is specified, then this can use
1247  * the normal LOV_MAGIC_{V1,V3} layout type.  If multiple OST indices are
1248  * given, then allocate an array to hold the list of indices and ensure that
1249  * the LOV_USER_MAGIC_SPECIFIC layout is used when creating the file.
1250  *
1251  * \param[in] layout            layout to set OST index in
1252  * \param[in] stripe_number     stripe number to set index for
1253  * \param[in] ost_index         the index to set
1254  *
1255  * \retval      0 on success
1256  * \retval      -1 if arguments are invalid or an unsupported stripe number
1257  *              was specified, error returned in errno
1258  */
1259 int llapi_layout_ost_index_set(struct llapi_layout *layout, int stripe_number,
1260                                uint64_t ost_index)
1261 {
1262         struct llapi_layout_comp *comp;
1263
1264         comp = __llapi_layout_cur_comp(layout);
1265         if (comp == NULL)
1266                 return -1;
1267
1268         if (!llapi_layout_stripe_index_is_valid(ost_index)) {
1269                 errno = EINVAL;
1270                 return -1;
1271         }
1272
1273         if (stripe_number == 0 && ost_index == LLAPI_LAYOUT_DEFAULT) {
1274                 comp->llc_stripe_offset = ost_index;
1275                 comp->llc_pattern &= ~LLAPI_LAYOUT_SPECIFIC;
1276                 __llapi_comp_objects_realloc(comp, 0);
1277         } else if (stripe_number >= 0 &&
1278                    stripe_number < LOV_MAX_STRIPE_COUNT) {
1279                 if (ost_index >= LLAPI_LAYOUT_IDX_MAX) {
1280                         errno = EINVAL;
1281                         return -1;
1282                 }
1283
1284                 /* Preallocate a few more stripes to avoid realloc() overhead.*/
1285                 if (__llapi_comp_objects_realloc(comp,
1286                                 stripe_number_roundup(stripe_number)) < 0)
1287                         return -1;
1288
1289                 comp->llc_objects[stripe_number].l_ost_idx = ost_index;
1290
1291                 if (stripe_number == 0)
1292                         comp->llc_stripe_offset = ost_index;
1293                 else
1294                         comp->llc_pattern |= LLAPI_LAYOUT_SPECIFIC;
1295
1296                 if (comp->llc_stripe_count == LLAPI_LAYOUT_DEFAULT ||
1297                     comp->llc_stripe_count <= stripe_number)
1298                         comp->llc_stripe_count = stripe_number + 1;
1299         } else {
1300                 errno = EINVAL;
1301                 return -1;
1302         }
1303
1304         return 0;
1305 }
1306
1307 /**
1308  * Get the OST index associated with stripe \a stripe_number.
1309  *
1310  * Stripes are indexed starting from zero.
1311  *
1312  * \param[in] layout            layout to get index from
1313  * \param[in] stripe_number     stripe number to get index for
1314  * \param[out] index            integer to store index in
1315  *
1316  * \retval      0 on success
1317  * \retval      -1 if arguments are invalid
1318  */
1319 int llapi_layout_ost_index_get(const struct llapi_layout *layout,
1320                                uint64_t stripe_number, uint64_t *index)
1321 {
1322         struct llapi_layout_comp *comp;
1323
1324         comp = __llapi_layout_cur_comp(layout);
1325         if (comp == NULL)
1326                 return -1;
1327
1328         if (index == NULL) {
1329                 errno = EINVAL;
1330                 return -1;
1331         }
1332
1333         if (stripe_number >= comp->llc_stripe_count ||
1334             stripe_number >= comp->llc_objects_count) {
1335                 errno = EINVAL;
1336                 return -1;
1337         }
1338
1339         if (comp->llc_stripe_offset == LLAPI_LAYOUT_DEFAULT)
1340                 *index = LLAPI_LAYOUT_DEFAULT;
1341         else
1342                 *index = comp->llc_objects[stripe_number].l_ost_idx;
1343
1344         return 0;
1345 }
1346
1347 /**
1348  *
1349  * Get the pool name of layout \a layout.
1350  *
1351  * \param[in] layout    layout to get pool name from
1352  * \param[out] dest     buffer to store pool name in
1353  * \param[in] n         size in bytes of buffer \a dest
1354  *
1355  * \retval      0 on success
1356  * \retval      -1 if arguments are invalid
1357  */
1358 int llapi_layout_pool_name_get(const struct llapi_layout *layout, char *dest,
1359                                size_t n)
1360 {
1361         struct llapi_layout_comp *comp;
1362
1363         comp = __llapi_layout_cur_comp(layout);
1364         if (comp == NULL)
1365                 return -1;
1366
1367         if (dest == NULL) {
1368                 errno = EINVAL;
1369                 return -1;
1370         }
1371
1372         strncpy(dest, comp->llc_pool_name, n);
1373
1374         return 0;
1375 }
1376
1377 /**
1378  * Set the name of the pool of layout \a layout.
1379  *
1380  * \param[in] layout    layout to set pool name in
1381  * \param[in] pool_name pool name to set
1382  *
1383  * \retval      0 on success
1384  * \retval      -1 if arguments are invalid or pool name is too long
1385  */
1386 int llapi_layout_pool_name_set(struct llapi_layout *layout,
1387                                const char *pool_name)
1388 {
1389         struct llapi_layout_comp *comp;
1390         char *ptr;
1391
1392         comp = __llapi_layout_cur_comp(layout);
1393         if (comp == NULL)
1394                 return -1;
1395
1396         if (pool_name == NULL) {
1397                 errno = EINVAL;
1398                 return -1;
1399         }
1400
1401         /* Strip off any 'fsname.' portion. */
1402         ptr = strchr(pool_name, '.');
1403         if (ptr != NULL)
1404                 pool_name = ptr + 1;
1405
1406         if (strlen(pool_name) > LOV_MAXPOOLNAME) {
1407                 errno = EINVAL;
1408                 return -1;
1409         }
1410
1411         strncpy(comp->llc_pool_name, pool_name, sizeof(comp->llc_pool_name));
1412
1413         return 0;
1414 }
1415
1416 /**
1417  * Open and possibly create a file with a given \a layout.
1418  *
1419  * If \a layout is NULL this function acts as a simple wrapper for
1420  * open().  By convention, ENOTTY is returned in errno if \a path
1421  * refers to a non-Lustre file.
1422  *
1423  * \param[in] path              name of the file to open
1424  * \param[in] open_flags        open() flags
1425  * \param[in] mode              permissions to create new file with
1426  * \param[in] layout            layout to create new file with
1427  *
1428  * \retval              non-negative file descriptor on successful open
1429  * \retval              -1 if an error occurred
1430  */
1431 int llapi_layout_file_open(const char *path, int open_flags, mode_t mode,
1432                            const struct llapi_layout *layout)
1433 {
1434         int fd;
1435         int rc;
1436         int tmp;
1437         struct lov_user_md *lum;
1438         size_t lum_size;
1439
1440         if (path == NULL ||
1441             (layout != NULL && layout->llot_magic != LLAPI_LAYOUT_MAGIC)) {
1442                 errno = EINVAL;
1443                 return -1;
1444         }
1445
1446         /* Object creation must be postponed until after layout attributes
1447          * have been applied. */
1448         if (layout != NULL && (open_flags & O_CREAT))
1449                 open_flags |= O_LOV_DELAY_CREATE;
1450
1451         fd = open(path, open_flags, mode);
1452
1453         if (layout == NULL || fd < 0)
1454                 return fd;
1455
1456         lum = llapi_layout_to_lum(layout);
1457
1458         if (lum == NULL) {
1459                 tmp = errno;
1460                 close(fd);
1461                 errno = tmp;
1462                 return -1;
1463         }
1464
1465         if (lum->lmm_magic == LOV_USER_MAGIC_COMP_V1)
1466                 lum_size = ((struct lov_comp_md_v1 *)lum)->lcm_size;
1467         else if (lum->lmm_magic == LOV_USER_MAGIC_SPECIFIC)
1468                 lum_size = lov_user_md_size(lum->lmm_stripe_count,
1469                                             lum->lmm_magic);
1470         else
1471                 lum_size = lov_user_md_size(0, lum->lmm_magic);
1472
1473         rc = fsetxattr(fd, XATTR_LUSTRE_LOV, lum, lum_size, 0);
1474         if (rc < 0) {
1475                 tmp = errno;
1476                 close(fd);
1477                 errno = tmp;
1478                 fd = -1;
1479         }
1480
1481         free(lum);
1482         errno = errno == EOPNOTSUPP ? ENOTTY : errno;
1483
1484         return fd;
1485 }
1486
1487 /**
1488  * Create a file with a given \a layout.
1489  *
1490  * Force O_CREAT and O_EXCL flags on so caller is assured that file was
1491  * created with the given \a layout on successful function return.
1492  *
1493  * \param[in] path              name of the file to open
1494  * \param[in] open_flags        open() flags
1495  * \param[in] mode              permissions to create new file with
1496  * \param[in] layout            layout to create new file with
1497  *
1498  * \retval              non-negative file descriptor on successful open
1499  * \retval              -1 if an error occurred
1500  */
1501 int llapi_layout_file_create(const char *path, int open_flags, int mode,
1502                              const struct llapi_layout *layout)
1503 {
1504         return llapi_layout_file_open(path, open_flags|O_CREAT|O_EXCL, mode,
1505                                       layout);
1506 }
1507
1508 /**
1509  * Fetch the start and end offset of the current layout component.
1510  *
1511  * \param[in] layout    the layout component
1512  * \param[out] start    extent start, inclusive
1513  * \param[out] end      extent end, exclusive
1514  *
1515  * \retval      0 on success
1516  * \retval      <0 if error occurs
1517  */
1518 int llapi_layout_comp_extent_get(const struct llapi_layout *layout,
1519                                  uint64_t *start, uint64_t *end)
1520 {
1521         struct llapi_layout_comp *comp;
1522
1523         comp = __llapi_layout_cur_comp(layout);
1524         if (comp == NULL)
1525                 return -1;
1526
1527         if (start == NULL || end == NULL) {
1528                 errno = EINVAL;
1529                 return -1;
1530         }
1531
1532         *start = comp->llc_extent.e_start;
1533         *end = comp->llc_extent.e_end;
1534
1535         return 0;
1536 }
1537
1538 /**
1539  * Set the layout extent of a layout.
1540  *
1541  * \param[in] layout    the layout to be set
1542  * \param[in] start     extent start, inclusive
1543  * \param[in] end       extent end, exclusive
1544  *
1545  * \retval      0 on success
1546  * \retval      <0 if error occurs
1547  */
1548 int llapi_layout_comp_extent_set(struct llapi_layout *layout,
1549                                  uint64_t start, uint64_t end)
1550 {
1551         struct llapi_layout_comp *prev, *next, *comp;
1552
1553         comp = __llapi_layout_cur_comp(layout);
1554         if (comp == NULL)
1555                 return -1;
1556
1557         if (start >= end) {
1558                 errno = EINVAL;
1559                 return -1;
1560         }
1561
1562         /*
1563          * We need to make sure the extent to be set is valid: the new
1564          * extent must be adjacent with the prev & next component.
1565          */
1566         if (comp->llc_list.prev != &layout->llot_comp_list) {
1567                 prev = list_entry(comp->llc_list.prev, typeof(*prev),
1568                                   llc_list);
1569                 if (start != prev->llc_extent.e_end) {
1570                         errno = EINVAL;
1571                         return -1;
1572                 }
1573         }
1574
1575         if (comp->llc_list.next != &layout->llot_comp_list) {
1576                 next = list_entry(comp->llc_list.next, typeof(*next),
1577                                   llc_list);
1578                 if (end != next->llc_extent.e_start) {
1579                         errno = EINVAL;
1580                         return -1;
1581                 }
1582         }
1583
1584         comp->llc_extent.e_start = start;
1585         comp->llc_extent.e_end = end;
1586         layout->llot_is_composite = true;
1587
1588         return 0;
1589 }
1590
1591 /**
1592  * Gets the attribute flags of the current component.
1593  *
1594  * \param[in] layout    the layout component
1595  * \param[out] flags    stored the returned component flags
1596  *
1597  * \retval      0 on success
1598  * \retval      <0 if error occurs
1599  */
1600 int llapi_layout_comp_flags_get(const struct llapi_layout *layout,
1601                                 uint32_t *flags)
1602 {
1603         struct llapi_layout_comp *comp;
1604
1605         comp = __llapi_layout_cur_comp(layout);
1606         if (comp == NULL)
1607                 return -1;
1608
1609         if (flags == NULL) {
1610                 errno = EINVAL;
1611                 return -1;
1612         }
1613
1614         *flags = comp->llc_flags;
1615
1616         return 0;
1617 }
1618
1619 /**
1620  * Sets the specified flags of the current component leaving other flags as-is.
1621  *
1622  * \param[in] layout    the layout component
1623  * \param[in] flags     component flags to be set
1624  *
1625  * \retval      0 on success
1626  * \retval      <0 if error occurs
1627  */
1628 int llapi_layout_comp_flags_set(struct llapi_layout *layout, uint32_t flags)
1629 {
1630         struct llapi_layout_comp *comp;
1631
1632         comp = __llapi_layout_cur_comp(layout);
1633         if (comp == NULL)
1634                 return -1;
1635
1636         comp->llc_flags |= flags;
1637
1638         return 0;
1639 }
1640
1641 /**
1642  * Clears the flags specified in the flags leaving other flags as-is.
1643  *
1644  * \param[in] layout    the layout component
1645  * \param[in] flags     component flags to be cleared
1646  *
1647  * \retval      0 on success
1648  * \retval      <0 if error occurs
1649  */
1650 int llapi_layout_comp_flags_clear(struct llapi_layout *layout,
1651                                   uint32_t flags)
1652 {
1653         struct llapi_layout_comp *comp;
1654
1655         comp = __llapi_layout_cur_comp(layout);
1656         if (comp == NULL)
1657                 return -1;
1658
1659         comp->llc_flags &= ~flags;
1660
1661         return 0;
1662 }
1663
1664 /**
1665  * Fetches the file-unique component ID of the current layout component.
1666  *
1667  * \param[in] layout    the layout component
1668  * \param[out] id       stored the returned component ID
1669  *
1670  * \retval      0 on success
1671  * \retval      <0 if error occurs
1672  */
1673 int llapi_layout_comp_id_get(const struct llapi_layout *layout, uint32_t *id)
1674 {
1675         struct llapi_layout_comp *comp;
1676
1677         comp = __llapi_layout_cur_comp(layout);
1678         if (comp == NULL)
1679                 return -1;
1680
1681         if (id == NULL) {
1682                 errno = EINVAL;
1683                 return -1;
1684         }
1685         *id = comp->llc_id;
1686
1687         return 0;
1688 }
1689
1690 /**
1691  * Adds a component to \a layout, the new component will be added to
1692  * the tail of components list and it'll inherit attributes of existing
1693  * ones. The \a layout will change it's current component pointer to
1694  * the newly added component, and it'll be turned into a composite
1695  * layout if it was not before the adding.
1696  *
1697  * \param[in] layout    existing composite or plain layout
1698  *
1699  * \retval      0 on success
1700  * \retval      <0 if error occurs
1701  */
1702 int llapi_layout_comp_add(struct llapi_layout *layout)
1703 {
1704         struct llapi_layout_comp *last, *comp, *new;
1705
1706         comp = __llapi_layout_cur_comp(layout);
1707         if (comp == NULL)
1708                 return -1;
1709
1710         new = __llapi_comp_alloc(0);
1711         if (new == NULL)
1712                 return -1;
1713
1714         last = list_entry(layout->llot_comp_list.prev, typeof(*last),
1715                           llc_list);
1716
1717         /* Inherit some attributes from existing component */
1718         new->llc_stripe_size = comp->llc_stripe_size;
1719         new->llc_stripe_count = comp->llc_stripe_count;
1720         if (new->llc_extent.e_end <= last->llc_extent.e_end) {
1721                 __llapi_comp_free(new);
1722                 errno = EINVAL;
1723                 return -1;
1724         }
1725         new->llc_extent.e_start = last->llc_extent.e_end;
1726
1727         list_add_tail(&new->llc_list, &layout->llot_comp_list);
1728         layout->llot_cur_comp = new;
1729         layout->llot_is_composite = true;
1730
1731         return 0;
1732 }
1733
1734 /**
1735  * Deletes current component from the composite layout. The component
1736  * to be deleted must be the tail of components list, and it can't be
1737  * the last component in the layout.
1738  *
1739  * \param[in] layout    composite layout
1740  *
1741  * \retval      0 on success
1742  * \retval      <0 if error occurs
1743  */
1744 int llapi_layout_comp_del(struct llapi_layout *layout)
1745 {
1746         struct llapi_layout_comp *comp;
1747
1748         comp = __llapi_layout_cur_comp(layout);
1749         if (comp == NULL)
1750                 return -1;
1751
1752         if (!layout->llot_is_composite) {
1753                 errno = EINVAL;
1754                 return -1;
1755         }
1756
1757         /* It must be the tail of the list */
1758         if (comp->llc_list.next != &layout->llot_comp_list) {
1759                 errno = EINVAL;
1760                 return -1;
1761         }
1762         /* It can't be the last one on the list */
1763         if (comp->llc_list.prev == &layout->llot_comp_list) {
1764                 errno = EINVAL;
1765                 return -1;
1766         }
1767
1768         list_del_init(&comp->llc_list);
1769         __llapi_comp_free(comp);
1770         layout->llot_cur_comp =
1771                 list_entry(comp->llc_list.prev, typeof(*comp),
1772                            llc_list);
1773
1774         return 0;
1775 }
1776
1777 /**
1778  * Move the current component pointer to the component with
1779  * specified component ID.
1780  *
1781  * \param[in] layout    composite layout
1782  * \param[in] id        component ID
1783  *
1784  * \retval      =0 : moved successfully
1785  * \retval      <0 if error occurs
1786  */
1787 int llapi_layout_comp_move_at(struct llapi_layout *layout, uint32_t id)
1788 {
1789         struct llapi_layout_comp *comp;
1790
1791         comp = __llapi_layout_cur_comp(layout);
1792         if (comp == NULL)
1793                 return -1;
1794
1795         if (!layout->llot_is_composite) {
1796                 errno = EINVAL;
1797                 return -1;
1798         }
1799
1800         if (id == 0) {
1801                 errno = EINVAL;
1802                 return -1;
1803         }
1804
1805         list_for_each_entry(comp, &layout->llot_comp_list, llc_list) {
1806                 if (comp->llc_id == id) {
1807                         layout->llot_cur_comp = comp;
1808                         return 0;
1809                 }
1810         }
1811         errno = ENOENT;
1812         return -1;
1813 }
1814
1815 /**
1816  * Move the current component pointer to a specified position.
1817  *
1818  * \param[in] layout    composite layout
1819  * \param[in] pos       the position to be moved, it can be:
1820  *                      LLAPI_LAYOUT_COMP_POS_FIRST: move to head
1821  *                      LLAPI_LAYOUT_COMP_POS_LAST: move to tail
1822  *                      LLAPI_LAYOUT_COMP_POS_NEXT: move to next
1823  *
1824  * \retval      =0 : moved successfully
1825  * \retval      =1 : already at the tail when move to the next
1826  * \retval      <0 if error occurs
1827  */
1828 int llapi_layout_comp_move(struct llapi_layout *layout, uint32_t pos)
1829 {
1830         struct llapi_layout_comp *comp, *head, *tail;
1831
1832         comp = __llapi_layout_cur_comp(layout);
1833         if (comp == NULL)
1834                 return -1;
1835
1836         if (!layout->llot_is_composite) {
1837                 errno = EINVAL;
1838                 return -1;
1839         }
1840
1841         head = list_entry(layout->llot_comp_list.next, typeof(*head),
1842                           llc_list);
1843         tail = list_entry(layout->llot_comp_list.prev, typeof(*tail),
1844                           llc_list);
1845
1846         if (pos == LLAPI_LAYOUT_COMP_POS_NEXT) {
1847                 if (comp == tail)
1848                         return 1;
1849                 layout->llot_cur_comp = list_entry(comp->llc_list.next,
1850                                                    typeof(*comp), llc_list);
1851         } else if (pos == LLAPI_LAYOUT_COMP_POS_FIRST) {
1852                 layout->llot_cur_comp = head;
1853         } else if (pos == LLAPI_LAYOUT_COMP_POS_LAST) {
1854                 layout->llot_cur_comp = tail;
1855         } else {
1856                 errno = EINVAL;
1857                 return -1;
1858         }
1859
1860         return 0;
1861 }
1862
1863 /**
1864  * Add layout component(s) to an existing file.
1865  *
1866  * \param[in] path      The path name of the file
1867  * \param[in] layout    The layout component(s) to be added
1868  */
1869 int llapi_layout_file_comp_add(const char *path,
1870                                const struct llapi_layout *layout)
1871 {
1872         int rc, fd, lum_size, tmp_errno = 0;
1873         struct lov_user_md *lum;
1874
1875         if (path == NULL || layout == NULL ||
1876             layout->llot_magic != LLAPI_LAYOUT_MAGIC) {
1877                 errno = EINVAL;
1878                 return -1;
1879         }
1880
1881         lum = llapi_layout_to_lum(layout);
1882         if (lum == NULL)
1883                 return -1;
1884
1885         if (lum->lmm_magic != LOV_USER_MAGIC_COMP_V1) {
1886                 free(lum);
1887                 errno = EINVAL;
1888                 return -1;
1889         }
1890         lum_size = ((struct lov_comp_md_v1 *)lum)->lcm_size;
1891
1892         fd = open(path, O_RDWR);
1893         if (fd < 0) {
1894                 tmp_errno = errno;
1895                 rc = -1;
1896                 goto out;
1897         }
1898
1899         rc = fsetxattr(fd, XATTR_LUSTRE_LOV".add", lum, lum_size, 0);
1900         if (rc < 0) {
1901                 tmp_errno = errno;
1902                 close(fd);
1903                 rc = -1;
1904                 goto out;
1905         }
1906         close(fd);
1907 out:
1908         free(lum);
1909         errno = tmp_errno;
1910         return rc;
1911 }
1912
1913 /**
1914  * Delete component(s) by the specified component id (accepting lcme_id
1915  * wildcards also) from an existing file.
1916  *
1917  * \param[in] path      path name of the file
1918  * \param[in] id        unique component ID or an lcme_id
1919  *                      (LCME_ID_NONE | LCME_FL_* )
1920  */
1921 int llapi_layout_file_comp_del(const char *path, uint32_t id)
1922 {
1923         int rc, fd;
1924
1925         if (path == NULL || id == 0) {
1926                 errno = EINVAL;
1927                 return -1;
1928         }
1929
1930         fd = open(path, O_RDWR);
1931         if (fd < 0)
1932                 return -1;
1933
1934         rc = fsetxattr(fd, XATTR_LUSTRE_LOV".del", &id, sizeof(id), 0);
1935         if (rc < 0) {
1936                 int tmp_errno = errno;
1937                 close(fd);
1938                 errno = tmp_errno;
1939                 return -1;
1940         }
1941         close(fd);
1942         return 0;
1943 }
1944
1945 /**
1946  * Change flags or other parameters of the component(s) by component ID of an
1947  * existing file. The component to be modified is specified by the
1948  * comp->lcme_id value, which must be an unique component ID. The new
1949  * attributes are passed in by @comp and @valid is used to specify which
1950  * attributes in the component are going to be changed.
1951  */
1952 int llapi_layout_file_comp_set(const char *path,
1953                                const struct llapi_layout *comp,
1954                                uint32_t valid)
1955 {
1956         errno = EOPNOTSUPP;
1957         return -1;
1958 }