Whamcloud - gitweb
LU-9771 flr: lfs mirror create and extend commands
[fs/lustre-release.git] / 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 "lustreapi_internal.h"
42
43 /**
44  * Layout component, which contains all attributes of a plain
45  * V1/V3 layout.
46  */
47 struct llapi_layout_comp {
48         uint64_t        llc_pattern;
49         uint64_t        llc_stripe_size;
50         uint64_t        llc_stripe_count;
51         uint64_t        llc_stripe_offset;
52         /* Add 1 so user always gets back a null terminated string. */
53         char            llc_pool_name[LOV_MAXPOOLNAME + 1];
54         /** Number of objects in llc_objects array if was initialized. */
55         uint32_t        llc_objects_count;
56         struct          lov_user_ost_data_v1 *llc_objects;
57         /* fields used only for composite layouts */
58         struct lu_extent        llc_extent;     /* [start, end) of component */
59         uint32_t                llc_id;         /* unique ID of component */
60         uint32_t                llc_flags;      /* LCME_FL_* flags */
61         struct list_head        llc_list;       /* linked to the llapi_layout
62                                                    components list */
63 };
64
65 /**
66  * An Opaque data type abstracting the layout of a Lustre file.
67  */
68 struct llapi_layout {
69         uint32_t        llot_magic; /* LLAPI_LAYOUT_MAGIC */
70         uint32_t        llot_gen;
71         uint32_t        llot_flags;
72         bool            llot_is_composite;
73         uint16_t        llot_mirror_count;
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_mirror_count = 1;
322         layout->llot_cur_comp = NULL;
323         INIT_LIST_HEAD(&layout->llot_comp_list);
324
325         return layout;
326 }
327
328 /**
329  * Allocate and initialize a new plain layout.
330  *
331  * \retval      valid llapi_layout pointer on success
332  * \retval      NULL if memory allocation fails
333  */
334 struct llapi_layout *llapi_layout_alloc(void)
335 {
336         struct llapi_layout_comp *comp;
337         struct llapi_layout *layout;
338
339         layout = __llapi_layout_alloc();
340         if (layout == NULL)
341                 return NULL;
342
343         comp = __llapi_comp_alloc(0);
344         if (comp == NULL) {
345                 free(layout);
346                 return NULL;
347         }
348
349         list_add_tail(&comp->llc_list, &layout->llot_comp_list);
350         layout->llot_cur_comp = comp;
351
352         return layout;
353 }
354
355 /**
356  * Convert the data from a lov_user_md to a newly allocated llapi_layout.
357  * The caller is responsible for freeing the returned pointer.
358  *
359  * \param[in] lum       LOV user metadata structure to copy data from
360  * \param[in] lum_size  size the the lum passed in
361  *
362  * \retval              valid llapi_layout pointer on success
363  * \retval              NULL if memory allocation fails
364  */
365 static struct llapi_layout *
366 llapi_layout_from_lum(const struct lov_user_md *lum, int lum_size)
367 {
368         struct lov_comp_md_v1 *comp_v1 = NULL;
369         struct lov_comp_md_entry_v1 *ent;
370         struct lov_user_md *v1;
371         struct llapi_layout *layout;
372         struct llapi_layout_comp *comp;
373         int i, ent_count = 0, obj_count;
374
375         layout = __llapi_layout_alloc();
376         if (layout == NULL)
377                 return NULL;
378
379         if (lum->lmm_magic == LOV_MAGIC_COMP_V1) {
380                 comp_v1 = (struct lov_comp_md_v1 *)lum;
381                 ent_count = comp_v1->lcm_entry_count;
382                 layout->llot_gen = comp_v1->lcm_layout_gen;
383                 layout->llot_is_composite = true;
384                 layout->llot_mirror_count = comp_v1->lcm_mirror_count + 1;
385                 layout->llot_gen = comp_v1->lcm_layout_gen;
386                 layout->llot_flags = comp_v1->lcm_flags;
387         } else if (lum->lmm_magic == LOV_MAGIC_V1 ||
388                    lum->lmm_magic == LOV_MAGIC_V3) {
389                 ent_count = 1;
390                 layout->llot_is_composite = false;
391         }
392
393         if (ent_count == 0) {
394                 errno = EINVAL;
395                 goto error;
396         }
397
398         v1 = (struct lov_user_md *)lum;
399         for (i = 0; i < ent_count; i++) {
400                 if (comp_v1 != NULL) {
401                         ent = &comp_v1->lcm_entries[i];
402                         v1 = (struct lov_user_md *)((char *)comp_v1 +
403                                 ent->lcme_offset);
404                         lum_size = ent->lcme_size;
405                 } else {
406                         ent = NULL;
407                 }
408
409                 obj_count = llapi_layout_objects_in_lum(v1, lum_size);
410                 comp = __llapi_comp_alloc(obj_count);
411                 if (comp == NULL)
412                         goto error;
413
414                 if (ent != NULL) {
415                         comp->llc_extent.e_start = ent->lcme_extent.e_start;
416                         comp->llc_extent.e_end = ent->lcme_extent.e_end;
417                         comp->llc_id = ent->lcme_id;
418                         comp->llc_flags = ent->lcme_flags;
419                 } else {
420                         comp->llc_extent.e_start = 0;
421                         comp->llc_extent.e_end = LUSTRE_EOF;
422                         comp->llc_id = 0;
423                         comp->llc_flags = 0;
424                 }
425
426                 if (v1->lmm_pattern == LOV_PATTERN_RAID0)
427                         comp->llc_pattern = LLAPI_LAYOUT_RAID0;
428                 else
429                         /* Lustre only supports RAID0 for now. */
430                         comp->llc_pattern = v1->lmm_pattern;
431
432                 if (v1->lmm_stripe_size == 0)
433                         comp->llc_stripe_size = LLAPI_LAYOUT_DEFAULT;
434                 else
435                         comp->llc_stripe_size = v1->lmm_stripe_size;
436
437                 if (v1->lmm_stripe_count == (typeof(v1->lmm_stripe_count))-1)
438                         comp->llc_stripe_count = LLAPI_LAYOUT_WIDE;
439                 else if (v1->lmm_stripe_count == 0)
440                         comp->llc_stripe_count = LLAPI_LAYOUT_DEFAULT;
441                 else
442                         comp->llc_stripe_count = v1->lmm_stripe_count;
443
444                 if (v1->lmm_stripe_offset ==
445                     (typeof(v1->lmm_stripe_offset))-1)
446                         comp->llc_stripe_offset = LLAPI_LAYOUT_DEFAULT;
447                 else
448                         comp->llc_stripe_offset = v1->lmm_stripe_offset;
449
450                 if (v1->lmm_magic != LOV_USER_MAGIC_V1) {
451                         const struct lov_user_md_v3 *lumv3;
452                         lumv3 = (struct lov_user_md_v3 *)v1;
453                         snprintf(comp->llc_pool_name,
454                                  sizeof(comp->llc_pool_name),
455                                  "%s", lumv3->lmm_pool_name);
456                         memcpy(comp->llc_objects, lumv3->lmm_objects,
457                                obj_count * sizeof(lumv3->lmm_objects[0]));
458                 } else {
459                         const struct lov_user_md_v1 *lumv1;
460                         lumv1 = (struct lov_user_md_v1 *)v1;
461                         memcpy(comp->llc_objects, lumv1->lmm_objects,
462                                obj_count * sizeof(lumv1->lmm_objects[0]));
463                 }
464
465                 if (obj_count != 0)
466                         comp->llc_stripe_offset =
467                                 comp->llc_objects[0].l_ost_idx;
468
469                 list_add_tail(&comp->llc_list, &layout->llot_comp_list);
470                 layout->llot_cur_comp = comp;
471         }
472
473         return layout;
474 error:
475         llapi_layout_free(layout);
476         return NULL;
477 }
478
479 /**
480  * Convert the data from a llapi_layout to a newly allocated lov_user_md.
481  * The caller is responsible for freeing the returned pointer.
482  *
483  * \param[in] layout    the layout to copy from
484  *
485  * \retval      valid lov_user_md pointer on success
486  * \retval      NULL if memory allocation fails or the layout is invalid
487  */
488 static struct lov_user_md *
489 llapi_layout_to_lum(const struct llapi_layout *layout)
490 {
491         struct llapi_layout_comp *comp;
492         struct lov_comp_md_v1 *comp_v1 = NULL;
493         struct lov_comp_md_entry_v1 *ent;
494         struct lov_user_md *lum = NULL;
495         size_t lum_size = 0;
496         int ent_idx = 0;
497         uint32_t offset = 0;
498
499         if (layout == NULL ||
500             list_empty((struct list_head *)&layout->llot_comp_list)) {
501                 errno = EINVAL;
502                 return NULL;
503         }
504
505         /* Allocate header of lov_comp_md_v1 if necessary */
506         if (layout->llot_is_composite) {
507                 int comp_cnt = 0;
508
509                 list_for_each_entry(comp, &layout->llot_comp_list, llc_list)
510                         comp_cnt++;
511
512                 lum_size = sizeof(*comp_v1) + comp_cnt * sizeof(*ent);
513                 lum = calloc(lum_size, 1);
514                 if (lum == NULL) {
515                         errno = ENOMEM;
516                         return NULL;
517                 }
518                 comp_v1 = (struct lov_comp_md_v1 *)lum;
519                 comp_v1->lcm_magic = LOV_USER_MAGIC_COMP_V1;
520                 comp_v1->lcm_size = lum_size;
521                 comp_v1->lcm_layout_gen = 0;
522                 comp_v1->lcm_flags = layout->llot_flags;
523                 comp_v1->lcm_entry_count = comp_cnt;
524                 comp_v1->lcm_mirror_count = layout->llot_mirror_count - 1;
525                 offset += lum_size;
526         }
527
528         list_for_each_entry(comp, &layout->llot_comp_list, llc_list) {
529                 struct lov_user_md *blob;
530                 size_t blob_size;
531                 uint32_t magic;
532                 int i, obj_count = 0;
533                 struct lov_user_ost_data *lmm_objects;
534                 uint64_t pattern = comp->llc_pattern;
535
536                 if ((pattern & LLAPI_LAYOUT_SPECIFIC) != 0) {
537                         if (comp->llc_objects_count <
538                             comp->llc_stripe_count) {
539                                 errno = EINVAL;
540                                 goto error;
541                         }
542                         magic = LOV_USER_MAGIC_SPECIFIC;
543                         obj_count = comp->llc_stripe_count;
544                         pattern &= ~LLAPI_LAYOUT_SPECIFIC;
545                 } else if (strlen(comp->llc_pool_name) != 0) {
546                         magic = LOV_USER_MAGIC_V3;
547                 } else {
548                         magic = LOV_USER_MAGIC_V1;
549                 }
550                 /* All stripes must be specified when the pattern contains
551                  * LLAPI_LAYOUT_SPECIFIC */
552                 for (i = 0; i < obj_count; i++) {
553                         if (comp->llc_objects[i].l_ost_idx ==
554                             LLAPI_LAYOUT_IDX_MAX) {
555                                 errno = EINVAL;
556                                 goto error;
557                         }
558                 }
559
560                 blob_size = lov_user_md_size(obj_count, magic);
561                 blob = realloc(lum, lum_size + blob_size);
562                 if (blob == NULL) {
563                         errno = ENOMEM;
564                         goto error;
565                 } else {
566                         lum = blob;
567                         comp_v1 = (struct lov_comp_md_v1 *)lum;
568                         blob = (struct lov_user_md *)((char *)lum + lum_size);
569                         lum_size += blob_size;
570                 }
571
572                 blob->lmm_magic = magic;
573                 if (pattern == LLAPI_LAYOUT_DEFAULT)
574                         blob->lmm_pattern = LOV_PATTERN_RAID0;
575                 else if (pattern == LLAPI_LAYOUT_MDT)
576                         blob->lmm_pattern = LOV_PATTERN_MDT;
577                 else
578                         blob->lmm_pattern = pattern;
579
580                 if (comp->llc_stripe_size == LLAPI_LAYOUT_DEFAULT)
581                         blob->lmm_stripe_size = 0;
582                 else
583                         blob->lmm_stripe_size = comp->llc_stripe_size;
584
585                 if (comp->llc_stripe_count == LLAPI_LAYOUT_DEFAULT)
586                         blob->lmm_stripe_count = 0;
587                 else if (comp->llc_stripe_count == LLAPI_LAYOUT_WIDE)
588                         blob->lmm_stripe_count = LOV_ALL_STRIPES;
589                 else
590                         blob->lmm_stripe_count = comp->llc_stripe_count;
591
592                 if (comp->llc_stripe_offset == LLAPI_LAYOUT_DEFAULT)
593                         blob->lmm_stripe_offset = -1;
594                 else
595                         blob->lmm_stripe_offset = comp->llc_stripe_offset;
596
597                 if (magic == LOV_USER_MAGIC_V3 ||
598                     magic == LOV_USER_MAGIC_SPECIFIC) {
599                         struct lov_user_md_v3 *lumv3 =
600                                 (struct lov_user_md_v3 *)blob;
601
602                         if (comp->llc_pool_name[0] != '\0') {
603                                 strncpy(lumv3->lmm_pool_name,
604                                         comp->llc_pool_name,
605                                         sizeof(lumv3->lmm_pool_name));
606                         } else {
607                                 memset(lumv3->lmm_pool_name, 0,
608                                        sizeof(lumv3->lmm_pool_name));
609                         }
610                         lmm_objects = lumv3->lmm_objects;
611                 } else {
612                         lmm_objects = blob->lmm_objects;
613                 }
614
615                 for (i = 0; i < obj_count; i++)
616                         lmm_objects[i].l_ost_idx =
617                                 comp->llc_objects[i].l_ost_idx;
618
619                 if (layout->llot_is_composite) {
620                         ent = &comp_v1->lcm_entries[ent_idx];
621                         ent->lcme_id = comp->llc_id;
622                         ent->lcme_flags = comp->llc_flags;
623                         ent->lcme_extent.e_start = comp->llc_extent.e_start;
624                         ent->lcme_extent.e_end = comp->llc_extent.e_end;
625                         ent->lcme_size = blob_size;
626                         ent->lcme_offset = offset;
627                         offset += blob_size;
628                         comp_v1->lcm_size += blob_size;
629                         ent_idx++;
630                 } else {
631                         break;
632                 }
633         }
634
635         return lum;
636 error:
637         free(lum);
638         return NULL;
639 }
640
641 /**
642  * Get the parent directory of a path.
643  *
644  * \param[in] path      path to get parent of
645  * \param[out] buf      buffer in which to store parent path
646  * \param[in] size      size in bytes of buffer \a buf
647  */
648 static void get_parent_dir(const char *path, char *buf, size_t size)
649 {
650         char *p;
651
652         strncpy(buf, path, size);
653         p = strrchr(buf, '/');
654
655         if (p != NULL) {
656                 *p = '\0';
657         } else if (size >= 2) {
658                 strncpy(buf, ".", 2);
659                 buf[size - 1] = '\0';
660         }
661 }
662
663 /**
664  * Substitute unspecified attribute values in \a layout with values
665  * from fs global settings. (lov.stripesize, lov.stripecount,
666  * lov.stripeoffset)
667  *
668  * \param[in] layout    layout to inherit values from
669  * \param[in] path      file path of the filesystem
670  */
671 static void inherit_sys_attributes(struct llapi_layout *layout,
672                                    const char *path)
673 {
674         struct llapi_layout_comp *comp;
675         unsigned int ssize, scount, soffset;
676         int rc;
677
678         rc = sattr_cache_get_defaults(NULL, path, &scount, &ssize, &soffset);
679         if (rc)
680                 return;
681
682         list_for_each_entry(comp, &layout->llot_comp_list, llc_list) {
683                 if (comp->llc_pattern == LLAPI_LAYOUT_DEFAULT)
684                         comp->llc_pattern = LLAPI_LAYOUT_RAID0;
685                 if (comp->llc_stripe_size == LLAPI_LAYOUT_DEFAULT)
686                         comp->llc_stripe_size = ssize;
687                 if (comp->llc_stripe_count == LLAPI_LAYOUT_DEFAULT)
688                         comp->llc_stripe_count = scount;
689                 if (comp->llc_stripe_offset == LLAPI_LAYOUT_DEFAULT)
690                         comp->llc_stripe_offset = soffset;
691         }
692 }
693
694 /**
695  * Get the current component of \a layout.
696  *
697  * \param[in] layout    layout to get current component
698  *
699  * \retval      valid llapi_layout_comp pointer on success
700  * \retval      NULL on error
701  */
702 static struct llapi_layout_comp *
703 __llapi_layout_cur_comp(const struct llapi_layout *layout)
704 {
705         struct llapi_layout_comp *comp;
706
707         if (layout == NULL || layout->llot_magic != LLAPI_LAYOUT_MAGIC) {
708                 errno = EINVAL;
709                 return NULL;
710         }
711         if (layout->llot_cur_comp == NULL) {
712                 errno = EINVAL;
713                 return NULL;
714         }
715         /* Verify data consistency */
716         list_for_each_entry(comp, &layout->llot_comp_list, llc_list)
717                 if (comp == layout->llot_cur_comp)
718                         return comp;
719         errno = EFAULT;
720         return NULL;
721 }
722
723 /**
724  * Test if any attributes of \a layout are specified.
725  *
726  * \param[in] layout    the layout to check
727  *
728  * \retval true         any attributes are specified
729  * \retval false        all attributes are unspecified
730  */
731 static bool is_any_specified(const struct llapi_layout *layout)
732 {
733         struct llapi_layout_comp *comp;
734
735         comp = __llapi_layout_cur_comp(layout);
736         if (comp == NULL)
737                 return false;
738
739         if (layout->llot_is_composite || layout->llot_mirror_count != 1)
740                 return true;
741
742         return comp->llc_pattern != LLAPI_LAYOUT_DEFAULT ||
743                comp->llc_stripe_size != LLAPI_LAYOUT_DEFAULT ||
744                comp->llc_stripe_count != LLAPI_LAYOUT_DEFAULT ||
745                comp->llc_stripe_offset != LLAPI_LAYOUT_DEFAULT ||
746                strlen(comp->llc_pool_name);
747 }
748
749 /**
750  * Check if the given \a lum_size is large enough to hold the required
751  * fields in \a lum.
752  *
753  * \param[in] lum       the struct lov_user_md to check
754  * \param[in] lum_size  the number of bytes in \a lum
755  *
756  * \retval true         the \a lum_size is too small
757  * \retval false        the \a lum_size is large enough
758  */
759 static bool llapi_layout_lum_truncated(struct lov_user_md *lum, size_t lum_size)
760 {
761         uint32_t magic;
762
763         if (lum_size < sizeof(lum->lmm_magic))
764                 return true;
765
766         if (lum->lmm_magic == LOV_MAGIC_V1 ||
767             lum->lmm_magic == __swab32(LOV_MAGIC_V1))
768                 magic = LOV_MAGIC_V1;
769         else if (lum->lmm_magic == LOV_MAGIC_V3 ||
770                  lum->lmm_magic == __swab32(LOV_MAGIC_V3))
771                 magic = LOV_MAGIC_V3;
772         else if (lum->lmm_magic == LOV_MAGIC_COMP_V1 ||
773                  lum->lmm_magic == __swab32(LOV_MAGIC_COMP_V1))
774                 magic = LOV_MAGIC_COMP_V1;
775         else
776                 return true;
777
778         if (magic == LOV_MAGIC_V1 || magic == LOV_MAGIC_V3)
779                 return lum_size < lov_user_md_size(0, magic);
780         else
781                 return lum_size < sizeof(struct lov_comp_md_v1);
782 }
783
784 /* Verify if the objects count in lum is consistent with the
785  * stripe count in lum. It applies to regular file only. */
786 static bool llapi_layout_lum_valid(struct lov_user_md *lum, int lum_size)
787 {
788         struct lov_comp_md_v1 *comp_v1 = NULL;
789         int i, ent_count, obj_count;
790
791         if (lum->lmm_magic == LOV_MAGIC_COMP_V1) {
792                 comp_v1 = (struct lov_comp_md_v1 *)lum;
793                 ent_count = comp_v1->lcm_entry_count;
794         } else if (lum->lmm_magic == LOV_MAGIC_V1 ||
795                    lum->lmm_magic == LOV_MAGIC_V3) {
796                 ent_count = 1;
797         } else {
798                 return false;
799         }
800
801         for (i = 0; i < ent_count; i++) {
802                 if (comp_v1) {
803                         lum = (struct lov_user_md *)((char *)comp_v1 +
804                                 comp_v1->lcm_entries[i].lcme_offset);
805                         lum_size = comp_v1->lcm_entries[i].lcme_size;
806                 }
807                 obj_count = llapi_layout_objects_in_lum(lum, lum_size);
808
809                 if (comp_v1) {
810                         if (!(comp_v1->lcm_entries[i].lcme_flags &
811                                  LCME_FL_INIT) && obj_count != 0)
812                                 return false;
813                 } else if (obj_count != lum->lmm_stripe_count) {
814                         return false;
815                 }
816         }
817         return true;
818 }
819
820 /**
821  * Get the striping layout for the file referenced by file descriptor \a fd.
822  *
823  * If the filesystem does not support the "lustre." xattr namespace, the
824  * file must be on a non-Lustre filesystem, so set errno to ENOTTY per
825  * convention.  If the file has no "lustre.lov" data, the file will
826  * inherit default values, so return a default layout.
827  *
828  * If the kernel gives us back less than the expected amount of data,
829  * we fail with errno set to EINTR.
830  *
831  * \param[in] fd        open file descriptor
832  * \param[in] flags     open file descriptor
833  *
834  * \retval      valid llapi_layout pointer on success
835  * \retval      NULL if an error occurs
836  */
837 struct llapi_layout *llapi_layout_get_by_fd(int fd, uint32_t flags)
838 {
839         size_t lum_len;
840         struct lov_user_md *lum;
841         struct llapi_layout *layout = NULL;
842         ssize_t bytes_read;
843         struct stat st;
844
845         lum_len = XATTR_SIZE_MAX;
846         lum = malloc(lum_len);
847         if (lum == NULL)
848                 return NULL;
849
850         bytes_read = fgetxattr(fd, XATTR_LUSTRE_LOV, lum, lum_len);
851         if (bytes_read < 0) {
852                 if (errno == EOPNOTSUPP)
853                         errno = ENOTTY;
854                 else if (errno == ENODATA)
855                         layout = llapi_layout_alloc();
856                 goto out;
857         }
858
859         /* Return an error if we got back a partial layout. */
860         if (llapi_layout_lum_truncated(lum, bytes_read)) {
861                 errno = EINTR;
862                 goto out;
863         }
864
865         llapi_layout_swab_lov_user_md(lum, bytes_read);
866
867         /* Directories may have a positive non-zero lum->lmm_stripe_count
868          * yet have an empty lum->lmm_objects array. For non-directories the
869          * amount of data returned from the kernel must be consistent
870          * with the stripe count. */
871         if (fstat(fd, &st) < 0)
872                 goto out;
873
874         if (!S_ISDIR(st.st_mode) && !llapi_layout_lum_valid(lum, bytes_read)) {
875                 errno = EINTR;
876                 goto out;
877         }
878
879         layout = llapi_layout_from_lum(lum, bytes_read);
880 out:
881         free(lum);
882         return layout;
883 }
884
885 /**
886  * Get the expected striping layout for a file at \a path.
887  *
888  * Substitute expected inherited attribute values for unspecified
889  * attributes.  Unspecified attributes may belong to directories and
890  * never-written-to files, and indicate that default values will be
891  * assigned when files are created or first written to.  A default value
892  * is inherited from the parent directory if the attribute is specified
893  * there, otherwise it is inherited from the filesystem root.
894  * Unspecified attributes normally have the value LLAPI_LAYOUT_DEFAULT.
895  *
896  * The complete \a path need not refer to an existing file or directory,
897  * but some leading portion of it must reside within a lustre filesystem.
898  * A use case for this interface would be to obtain the literal striping
899  * values that would be assigned to a new file in a given directory.
900  *
901  * \param[in] path      path for which to get the expected layout
902  *
903  * \retval      valid llapi_layout pointer on success
904  * \retval      NULL if an error occurs
905  */
906 static struct llapi_layout *llapi_layout_expected(const char *path)
907 {
908         struct llapi_layout     *path_layout = NULL;
909         char                    donor_path[PATH_MAX];
910         struct stat st;
911         int fd;
912         int rc;
913
914         fd = open(path, O_RDONLY);
915         if (fd < 0 && errno != ENOENT)
916                 return NULL;
917
918         if (fd >= 0) {
919                 int tmp;
920
921                 path_layout = llapi_layout_get_by_fd(fd, 0);
922                 tmp = errno;
923                 close(fd);
924                 errno = tmp;
925         }
926
927         if (path_layout == NULL) {
928                 if (errno != ENODATA && errno != ENOENT)
929                         return NULL;
930
931                 path_layout = llapi_layout_alloc();
932                 if (path_layout == NULL)
933                         return NULL;
934         }
935
936         if (is_any_specified(path_layout)) {
937                 inherit_sys_attributes(path_layout, path);
938                 return path_layout;
939         }
940
941         llapi_layout_free(path_layout);
942
943         rc = stat(path, &st);
944         if (rc < 0 && errno != ENOENT)
945                 return NULL;
946
947         /* If path is a not a directory or doesn't exist, inherit layout
948          * from parent directory. */
949         if ((rc == 0 && !S_ISDIR(st.st_mode)) ||
950             (rc < 0 && errno == ENOENT)) {
951                 get_parent_dir(path, donor_path, sizeof(donor_path));
952                 path_layout = llapi_layout_get_by_path(donor_path, 0);
953                 if (path_layout != NULL) {
954                         if (is_any_specified(path_layout)) {
955                                 inherit_sys_attributes(path_layout, donor_path);
956                                 return path_layout;
957                         }
958                         llapi_layout_free(path_layout);
959                 }
960         }
961
962         /* Inherit layout from the filesystem root. */
963         rc = llapi_search_mounts(path, 0, donor_path, NULL);
964         if (rc < 0)
965                 return NULL;
966         path_layout = llapi_layout_get_by_path(donor_path, 0);
967         if (path_layout == NULL)
968                 return NULL;
969
970         inherit_sys_attributes(path_layout, donor_path);
971         return path_layout;
972 }
973
974 /**
975  * Get the striping layout for the file at \a path.
976  *
977  * If \a flags contains LAYOUT_GET_EXPECTED, substitute
978  * expected inherited attribute values for unspecified attributes. See
979  * llapi_layout_expected().
980  *
981  * \param[in] path      path for which to get the layout
982  * \param[in] flags     flags to control how layout is retrieved
983  *
984  * \retval      valid llapi_layout pointer on success
985  * \retval      NULL if an error occurs
986  */
987 struct llapi_layout *llapi_layout_get_by_path(const char *path, uint32_t flags)
988 {
989         struct llapi_layout *layout = NULL;
990         int fd;
991         int tmp;
992
993         if (flags & LAYOUT_GET_EXPECTED)
994                 return llapi_layout_expected(path);
995
996         fd = open(path, O_RDONLY);
997         if (fd < 0)
998                 return layout;
999
1000         layout = llapi_layout_get_by_fd(fd, flags);
1001         tmp = errno;
1002         close(fd);
1003         errno = tmp;
1004
1005         return layout;
1006 }
1007
1008 /**
1009  * Get the layout for the file with FID \a fidstr in filesystem \a lustre_dir.
1010  *
1011  * \param[in] lustre_dir        path within Lustre filesystem containing \a fid
1012  * \param[in] fid               Lustre identifier of file to get layout for
1013  *
1014  * \retval      valid llapi_layout pointer on success
1015  * \retval      NULL if an error occurs
1016  */
1017 struct llapi_layout *llapi_layout_get_by_fid(const char *lustre_dir,
1018                                              const lustre_fid *fid,
1019                                              uint32_t flags)
1020 {
1021         int fd;
1022         int tmp;
1023         int saved_msg_level = llapi_msg_get_level();
1024         struct llapi_layout *layout = NULL;
1025
1026         /* Prevent llapi internal routines from writing to console
1027          * while executing this function, then restore previous message
1028          * level. */
1029         llapi_msg_set_level(LLAPI_MSG_OFF);
1030         fd = llapi_open_by_fid(lustre_dir, fid, O_RDONLY);
1031         llapi_msg_set_level(saved_msg_level);
1032
1033         if (fd < 0)
1034                 return NULL;
1035
1036         layout = llapi_layout_get_by_fd(fd, flags);
1037         tmp = errno;
1038         close(fd);
1039         errno = tmp;
1040
1041         return layout;
1042 }
1043
1044 /**
1045  * Get the stripe count of \a layout.
1046  *
1047  * \param[in] layout    layout to get stripe count from
1048  * \param[out] count    integer to store stripe count in
1049  *
1050  * \retval      0 on success
1051  * \retval      -1 if arguments are invalid
1052  */
1053 int llapi_layout_stripe_count_get(const struct llapi_layout *layout,
1054                                   uint64_t *count)
1055 {
1056         struct llapi_layout_comp *comp;
1057
1058         comp = __llapi_layout_cur_comp(layout);
1059         if (comp == NULL)
1060                 return -1;
1061
1062         if (count == NULL) {
1063                 errno = EINVAL;
1064                 return -1;
1065         }
1066
1067         *count = comp->llc_stripe_count;
1068
1069         return 0;
1070 }
1071
1072 /*
1073  * The llapi_layout API functions have these extra validity checks since
1074  * they use intuitively named macros to denote special behavior, whereas
1075  * the old API uses 0 and -1.
1076  */
1077
1078 static bool llapi_layout_stripe_count_is_valid(int64_t stripe_count)
1079 {
1080         return stripe_count == LLAPI_LAYOUT_DEFAULT ||
1081                 stripe_count == LLAPI_LAYOUT_WIDE ||
1082                 (stripe_count != 0 && stripe_count != -1 &&
1083                  llapi_stripe_count_is_valid(stripe_count));
1084 }
1085
1086 static bool llapi_layout_stripe_size_is_valid(uint64_t stripe_size)
1087 {
1088         return stripe_size == LLAPI_LAYOUT_DEFAULT ||
1089                 (stripe_size != 0 &&
1090                  llapi_stripe_size_is_aligned(stripe_size) &&
1091                  !llapi_stripe_size_is_too_big(stripe_size));
1092 }
1093
1094 static bool llapi_layout_stripe_index_is_valid(int64_t stripe_index)
1095 {
1096         return stripe_index == LLAPI_LAYOUT_DEFAULT ||
1097                 (stripe_index >= 0 &&
1098                 llapi_stripe_index_is_valid(stripe_index));
1099 }
1100
1101 /**
1102  * Set the stripe count of \a layout.
1103  *
1104  * \param[in] layout    layout to set stripe count in
1105  * \param[in] count     value to be set
1106  *
1107  * \retval      0 on success
1108  * \retval      -1 if arguments are invalid
1109  */
1110 int llapi_layout_stripe_count_set(struct llapi_layout *layout,
1111                                   uint64_t count)
1112 {
1113         struct llapi_layout_comp *comp;
1114
1115         comp = __llapi_layout_cur_comp(layout);
1116         if (comp == NULL)
1117                 return -1;
1118
1119         if (!llapi_layout_stripe_count_is_valid(count)) {
1120                 errno = EINVAL;
1121                 return -1;
1122         }
1123
1124         comp->llc_stripe_count = count;
1125
1126         return 0;
1127 }
1128
1129 /**
1130  * Get the stripe size of \a layout.
1131  *
1132  * \param[in] layout    layout to get stripe size from
1133  * \param[out] size     integer to store stripe size in
1134  *
1135  * \retval      0 on success
1136  * \retval      -1 if arguments are invalid
1137  */
1138 int llapi_layout_stripe_size_get(const struct llapi_layout *layout,
1139                                  uint64_t *size)
1140 {
1141         struct llapi_layout_comp *comp;
1142
1143         comp = __llapi_layout_cur_comp(layout);
1144         if (comp == NULL)
1145                 return -1;
1146
1147         if (size == NULL) {
1148                 errno = EINVAL;
1149                 return -1;
1150         }
1151
1152         *size = comp->llc_stripe_size;
1153
1154         return 0;
1155 }
1156
1157 /**
1158  * Set the stripe size of \a layout.
1159  *
1160  * \param[in] layout    layout to set stripe size in
1161  * \param[in] size      value to be set
1162  *
1163  * \retval      0 on success
1164  * \retval      -1 if arguments are invalid
1165  */
1166 int llapi_layout_stripe_size_set(struct llapi_layout *layout,
1167                                  uint64_t size)
1168 {
1169         struct llapi_layout_comp *comp;
1170
1171         comp = __llapi_layout_cur_comp(layout);
1172         if (comp == NULL)
1173                 return -1;
1174
1175         if (!llapi_layout_stripe_size_is_valid(size)) {
1176                 errno = EINVAL;
1177                 return -1;
1178         }
1179
1180         comp->llc_stripe_size = size;
1181
1182         return 0;
1183 }
1184
1185 /**
1186  * Get the RAID pattern of \a layout.
1187  *
1188  * \param[in] layout    layout to get pattern from
1189  * \param[out] pattern  integer to store pattern in
1190  *
1191  * \retval      0 on success
1192  * \retval      -1 if arguments are invalid
1193  */
1194 int llapi_layout_pattern_get(const struct llapi_layout *layout,
1195                              uint64_t *pattern)
1196 {
1197         struct llapi_layout_comp *comp;
1198
1199         comp = __llapi_layout_cur_comp(layout);
1200         if (comp == NULL)
1201                 return -1;
1202
1203         if (pattern == NULL) {
1204                 errno = EINVAL;
1205                 return -1;
1206         }
1207
1208         *pattern = comp->llc_pattern;
1209
1210         return 0;
1211 }
1212
1213 /**
1214  * Set the pattern of \a layout.
1215  *
1216  * \param[in] layout    layout to set pattern in
1217  * \param[in] pattern   value to be set
1218  *
1219  * \retval      0 on success
1220  * \retval      -1 if arguments are invalid or RAID pattern
1221  *              is unsupported
1222  */
1223 int llapi_layout_pattern_set(struct llapi_layout *layout, uint64_t pattern)
1224 {
1225         struct llapi_layout_comp *comp;
1226
1227         comp = __llapi_layout_cur_comp(layout);
1228         if (comp == NULL)
1229                 return -1;
1230
1231         if (pattern != LLAPI_LAYOUT_DEFAULT &&
1232             pattern != LLAPI_LAYOUT_RAID0 && pattern != LLAPI_LAYOUT_MDT) {
1233                 errno = EOPNOTSUPP;
1234                 return -1;
1235         }
1236
1237         comp->llc_pattern = pattern |
1238                             (comp->llc_pattern & LLAPI_LAYOUT_SPECIFIC);
1239
1240         return 0;
1241 }
1242
1243 static inline int stripe_number_roundup(int stripe_number)
1244 {
1245         unsigned int round_up = (stripe_number + 8) & ~7;
1246         return round_up > LOV_MAX_STRIPE_COUNT ?
1247                 LOV_MAX_STRIPE_COUNT : round_up;
1248 }
1249
1250 /**
1251  * Set the OST index of stripe number \a stripe_number to \a ost_index.
1252  *
1253  * If only the starting stripe's OST index is specified, then this can use
1254  * the normal LOV_MAGIC_{V1,V3} layout type.  If multiple OST indices are
1255  * given, then allocate an array to hold the list of indices and ensure that
1256  * the LOV_USER_MAGIC_SPECIFIC layout is used when creating the file.
1257  *
1258  * \param[in] layout            layout to set OST index in
1259  * \param[in] stripe_number     stripe number to set index for
1260  * \param[in] ost_index         the index to set
1261  *
1262  * \retval      0 on success
1263  * \retval      -1 if arguments are invalid or an unsupported stripe number
1264  *              was specified, error returned in errno
1265  */
1266 int llapi_layout_ost_index_set(struct llapi_layout *layout, int stripe_number,
1267                                uint64_t ost_index)
1268 {
1269         struct llapi_layout_comp *comp;
1270
1271         comp = __llapi_layout_cur_comp(layout);
1272         if (comp == NULL)
1273                 return -1;
1274
1275         if (!llapi_layout_stripe_index_is_valid(ost_index)) {
1276                 errno = EINVAL;
1277                 return -1;
1278         }
1279
1280         if (stripe_number == 0 && ost_index == LLAPI_LAYOUT_DEFAULT) {
1281                 comp->llc_stripe_offset = ost_index;
1282                 comp->llc_pattern &= ~LLAPI_LAYOUT_SPECIFIC;
1283                 __llapi_comp_objects_realloc(comp, 0);
1284         } else if (stripe_number >= 0 &&
1285                    stripe_number < LOV_MAX_STRIPE_COUNT) {
1286                 if (ost_index >= LLAPI_LAYOUT_IDX_MAX) {
1287                         errno = EINVAL;
1288                         return -1;
1289                 }
1290
1291                 /* Preallocate a few more stripes to avoid realloc() overhead.*/
1292                 if (__llapi_comp_objects_realloc(comp,
1293                                 stripe_number_roundup(stripe_number)) < 0)
1294                         return -1;
1295
1296                 comp->llc_objects[stripe_number].l_ost_idx = ost_index;
1297
1298                 if (stripe_number == 0)
1299                         comp->llc_stripe_offset = ost_index;
1300                 else
1301                         comp->llc_pattern |= LLAPI_LAYOUT_SPECIFIC;
1302
1303                 if (comp->llc_stripe_count == LLAPI_LAYOUT_DEFAULT ||
1304                     comp->llc_stripe_count <= stripe_number)
1305                         comp->llc_stripe_count = stripe_number + 1;
1306         } else {
1307                 errno = EINVAL;
1308                 return -1;
1309         }
1310
1311         return 0;
1312 }
1313
1314 /**
1315  * Get the OST index associated with stripe \a stripe_number.
1316  *
1317  * Stripes are indexed starting from zero.
1318  *
1319  * \param[in] layout            layout to get index from
1320  * \param[in] stripe_number     stripe number to get index for
1321  * \param[out] index            integer to store index in
1322  *
1323  * \retval      0 on success
1324  * \retval      -1 if arguments are invalid
1325  */
1326 int llapi_layout_ost_index_get(const struct llapi_layout *layout,
1327                                uint64_t stripe_number, uint64_t *index)
1328 {
1329         struct llapi_layout_comp *comp;
1330
1331         comp = __llapi_layout_cur_comp(layout);
1332         if (comp == NULL)
1333                 return -1;
1334
1335         if (index == NULL) {
1336                 errno = EINVAL;
1337                 return -1;
1338         }
1339
1340         if (stripe_number >= comp->llc_stripe_count ||
1341             stripe_number >= comp->llc_objects_count) {
1342                 errno = EINVAL;
1343                 return -1;
1344         }
1345
1346         if (comp->llc_stripe_offset == LLAPI_LAYOUT_DEFAULT)
1347                 *index = LLAPI_LAYOUT_DEFAULT;
1348         else
1349                 *index = comp->llc_objects[stripe_number].l_ost_idx;
1350
1351         return 0;
1352 }
1353
1354 /**
1355  *
1356  * Get the pool name of layout \a layout.
1357  *
1358  * \param[in] layout    layout to get pool name from
1359  * \param[out] dest     buffer to store pool name in
1360  * \param[in] n         size in bytes of buffer \a dest
1361  *
1362  * \retval      0 on success
1363  * \retval      -1 if arguments are invalid
1364  */
1365 int llapi_layout_pool_name_get(const struct llapi_layout *layout, char *dest,
1366                                size_t n)
1367 {
1368         struct llapi_layout_comp *comp;
1369
1370         comp = __llapi_layout_cur_comp(layout);
1371         if (comp == NULL)
1372                 return -1;
1373
1374         if (dest == NULL) {
1375                 errno = EINVAL;
1376                 return -1;
1377         }
1378
1379         strncpy(dest, comp->llc_pool_name, n);
1380
1381         return 0;
1382 }
1383
1384 /**
1385  * Set the name of the pool of layout \a layout.
1386  *
1387  * \param[in] layout    layout to set pool name in
1388  * \param[in] pool_name pool name to set
1389  *
1390  * \retval      0 on success
1391  * \retval      -1 if arguments are invalid or pool name is too long
1392  */
1393 int llapi_layout_pool_name_set(struct llapi_layout *layout,
1394                                const char *pool_name)
1395 {
1396         struct llapi_layout_comp *comp;
1397         char *ptr;
1398
1399         comp = __llapi_layout_cur_comp(layout);
1400         if (comp == NULL)
1401                 return -1;
1402
1403         if (pool_name == NULL) {
1404                 errno = EINVAL;
1405                 return -1;
1406         }
1407
1408         /* Strip off any 'fsname.' portion. */
1409         ptr = strchr(pool_name, '.');
1410         if (ptr != NULL)
1411                 pool_name = ptr + 1;
1412
1413         if (strlen(pool_name) > LOV_MAXPOOLNAME) {
1414                 errno = EINVAL;
1415                 return -1;
1416         }
1417
1418         strncpy(comp->llc_pool_name, pool_name, sizeof(comp->llc_pool_name));
1419
1420         return 0;
1421 }
1422
1423 /**
1424  * Open and possibly create a file with a given \a layout.
1425  *
1426  * If \a layout is NULL this function acts as a simple wrapper for
1427  * open().  By convention, ENOTTY is returned in errno if \a path
1428  * refers to a non-Lustre file.
1429  *
1430  * \param[in] path              name of the file to open
1431  * \param[in] open_flags        open() flags
1432  * \param[in] mode              permissions to create new file with
1433  * \param[in] layout            layout to create new file with
1434  *
1435  * \retval              non-negative file descriptor on successful open
1436  * \retval              -1 if an error occurred
1437  */
1438 int llapi_layout_file_open(const char *path, int open_flags, mode_t mode,
1439                            const struct llapi_layout *layout)
1440 {
1441         int fd;
1442         int rc;
1443         int tmp;
1444         struct lov_user_md *lum;
1445         size_t lum_size;
1446
1447         if (path == NULL ||
1448             (layout != NULL && layout->llot_magic != LLAPI_LAYOUT_MAGIC)) {
1449                 errno = EINVAL;
1450                 return -1;
1451         }
1452
1453         /* Object creation must be postponed until after layout attributes
1454          * have been applied. */
1455         if (layout != NULL && (open_flags & O_CREAT))
1456                 open_flags |= O_LOV_DELAY_CREATE;
1457
1458         fd = open(path, open_flags, mode);
1459
1460         if (layout == NULL || fd < 0)
1461                 return fd;
1462
1463         lum = llapi_layout_to_lum(layout);
1464
1465         if (lum == NULL) {
1466                 tmp = errno;
1467                 close(fd);
1468                 errno = tmp;
1469                 return -1;
1470         }
1471
1472         if (lum->lmm_magic == LOV_USER_MAGIC_COMP_V1)
1473                 lum_size = ((struct lov_comp_md_v1 *)lum)->lcm_size;
1474         else if (lum->lmm_magic == LOV_USER_MAGIC_SPECIFIC)
1475                 lum_size = lov_user_md_size(lum->lmm_stripe_count,
1476                                             lum->lmm_magic);
1477         else
1478                 lum_size = lov_user_md_size(0, lum->lmm_magic);
1479
1480         rc = fsetxattr(fd, XATTR_LUSTRE_LOV, lum, lum_size, 0);
1481         if (rc < 0) {
1482                 tmp = errno;
1483                 close(fd);
1484                 errno = tmp;
1485                 fd = -1;
1486         }
1487
1488         free(lum);
1489         errno = errno == EOPNOTSUPP ? ENOTTY : errno;
1490
1491         return fd;
1492 }
1493
1494 /**
1495  * Create a file with a given \a layout.
1496  *
1497  * Force O_CREAT and O_EXCL flags on so caller is assured that file was
1498  * created with the given \a layout on successful function return.
1499  *
1500  * \param[in] path              name of the file to open
1501  * \param[in] open_flags        open() flags
1502  * \param[in] mode              permissions to create new file with
1503  * \param[in] layout            layout to create new file with
1504  *
1505  * \retval              non-negative file descriptor on successful open
1506  * \retval              -1 if an error occurred
1507  */
1508 int llapi_layout_file_create(const char *path, int open_flags, int mode,
1509                              const struct llapi_layout *layout)
1510 {
1511         return llapi_layout_file_open(path, open_flags|O_CREAT|O_EXCL, mode,
1512                                       layout);
1513 }
1514
1515 int llapi_layout_flags_get(struct llapi_layout *layout, uint32_t *flags)
1516 {
1517         if (layout->llot_magic != LLAPI_LAYOUT_MAGIC) {
1518                 errno = EINVAL;
1519                 return -1;
1520         }
1521
1522         *flags = layout->llot_flags;
1523         return 0;
1524 }
1525
1526 /**
1527  * Set flags to the header of a component layout.
1528  */
1529 int llapi_layout_flags_set(struct llapi_layout *layout, uint32_t flags)
1530 {
1531         if (layout->llot_magic != LLAPI_LAYOUT_MAGIC) {
1532                 errno = EINVAL;
1533                 return -1;
1534         }
1535
1536         layout->llot_flags = flags;
1537         return 0;
1538 }
1539
1540 /**
1541  * llapi_layout_mirror_count_is_valid() - Check the validity of mirror count.
1542  * @count: Mirror count value to be checked.
1543  *
1544  * This function checks the validity of mirror count.
1545  *
1546  * Return: true on success or false on failure.
1547  */
1548 static bool llapi_layout_mirror_count_is_valid(uint16_t count)
1549 {
1550         return count >= 0 && count <= LUSTRE_MIRROR_COUNT_MAX;
1551 }
1552
1553 /**
1554  * llapi_layout_mirror_count_get() - Get mirror count from the header of
1555  *                                   a layout.
1556  * @layout: Layout to get mirror count from.
1557  * @count:  Returned mirror count value.
1558  *
1559  * This function gets mirror count from the header of a layout.
1560  *
1561  * Return: 0 on success or -1 on failure.
1562  */
1563 int llapi_layout_mirror_count_get(struct llapi_layout *layout,
1564                                   uint16_t *count)
1565 {
1566         if (layout->llot_magic != LLAPI_LAYOUT_MAGIC) {
1567                 errno = EINVAL;
1568                 return -1;
1569         }
1570
1571         *count = layout->llot_mirror_count;
1572         return 0;
1573 }
1574
1575 /**
1576  * llapi_layout_mirror_count_set() - Set mirror count to the header of a layout.
1577  * @layout: Layout to set mirror count in.
1578  * @count:  Mirror count value to be set.
1579  *
1580  * This function sets mirror count to the header of a layout.
1581  *
1582  * Return: 0 on success or -1 on failure.
1583  */
1584 int llapi_layout_mirror_count_set(struct llapi_layout *layout,
1585                                   uint16_t count)
1586 {
1587         if (layout->llot_magic != LLAPI_LAYOUT_MAGIC) {
1588                 errno = EINVAL;
1589                 return -1;
1590         }
1591
1592         if (!llapi_layout_mirror_count_is_valid(count)) {
1593                 errno = EINVAL;
1594                 return -1;
1595         }
1596
1597         layout->llot_mirror_count = count;
1598         return 0;
1599 }
1600
1601 /**
1602  * Fetch the start and end offset of the current layout component.
1603  *
1604  * \param[in] layout    the layout component
1605  * \param[out] start    extent start, inclusive
1606  * \param[out] end      extent end, exclusive
1607  *
1608  * \retval      0 on success
1609  * \retval      <0 if error occurs
1610  */
1611 int llapi_layout_comp_extent_get(const struct llapi_layout *layout,
1612                                  uint64_t *start, uint64_t *end)
1613 {
1614         struct llapi_layout_comp *comp;
1615
1616         comp = __llapi_layout_cur_comp(layout);
1617         if (comp == NULL)
1618                 return -1;
1619
1620         if (start == NULL || end == NULL) {
1621                 errno = EINVAL;
1622                 return -1;
1623         }
1624
1625         *start = comp->llc_extent.e_start;
1626         *end = comp->llc_extent.e_end;
1627
1628         return 0;
1629 }
1630
1631 /**
1632  * Set the layout extent of a layout.
1633  *
1634  * \param[in] layout    the layout to be set
1635  * \param[in] start     extent start, inclusive
1636  * \param[in] end       extent end, exclusive
1637  *
1638  * \retval      0 on success
1639  * \retval      <0 if error occurs
1640  */
1641 int llapi_layout_comp_extent_set(struct llapi_layout *layout,
1642                                  uint64_t start, uint64_t end)
1643 {
1644         struct llapi_layout_comp *prev, *next, *comp;
1645
1646         comp = __llapi_layout_cur_comp(layout);
1647         if (comp == NULL)
1648                 return -1;
1649
1650         if (start >= end) {
1651                 errno = EINVAL;
1652                 return -1;
1653         }
1654
1655         /*
1656          * We need to make sure the extent to be set is valid: the new
1657          * extent must be adjacent with the prev & next component.
1658          */
1659         if (comp->llc_list.prev != &layout->llot_comp_list) {
1660                 prev = list_entry(comp->llc_list.prev, typeof(*prev),
1661                                   llc_list);
1662                 if (start != prev->llc_extent.e_end) {
1663                         errno = EINVAL;
1664                         return -1;
1665                 }
1666         }
1667
1668         if (comp->llc_list.next != &layout->llot_comp_list) {
1669                 next = list_entry(comp->llc_list.next, typeof(*next),
1670                                   llc_list);
1671                 if (end != next->llc_extent.e_start) {
1672                         errno = EINVAL;
1673                         return -1;
1674                 }
1675         }
1676
1677         comp->llc_extent.e_start = start;
1678         comp->llc_extent.e_end = end;
1679         layout->llot_is_composite = true;
1680
1681         return 0;
1682 }
1683
1684 /**
1685  * Gets the attribute flags of the current component.
1686  *
1687  * \param[in] layout    the layout component
1688  * \param[out] flags    stored the returned component flags
1689  *
1690  * \retval      0 on success
1691  * \retval      <0 if error occurs
1692  */
1693 int llapi_layout_comp_flags_get(const struct llapi_layout *layout,
1694                                 uint32_t *flags)
1695 {
1696         struct llapi_layout_comp *comp;
1697
1698         comp = __llapi_layout_cur_comp(layout);
1699         if (comp == NULL)
1700                 return -1;
1701
1702         if (flags == NULL) {
1703                 errno = EINVAL;
1704                 return -1;
1705         }
1706
1707         *flags = comp->llc_flags;
1708
1709         return 0;
1710 }
1711
1712 /**
1713  * Sets the specified flags of the current component leaving other flags as-is.
1714  *
1715  * \param[in] layout    the layout component
1716  * \param[in] flags     component flags to be set
1717  *
1718  * \retval      0 on success
1719  * \retval      <0 if error occurs
1720  */
1721 int llapi_layout_comp_flags_set(struct llapi_layout *layout, uint32_t flags)
1722 {
1723         struct llapi_layout_comp *comp;
1724
1725         comp = __llapi_layout_cur_comp(layout);
1726         if (comp == NULL)
1727                 return -1;
1728
1729         comp->llc_flags |= flags;
1730
1731         return 0;
1732 }
1733
1734 /**
1735  * Clears the flags specified in the flags leaving other flags as-is.
1736  *
1737  * \param[in] layout    the layout component
1738  * \param[in] flags     component flags to be cleared
1739  *
1740  * \retval      0 on success
1741  * \retval      <0 if error occurs
1742  */
1743 int llapi_layout_comp_flags_clear(struct llapi_layout *layout,
1744                                   uint32_t flags)
1745 {
1746         struct llapi_layout_comp *comp;
1747
1748         comp = __llapi_layout_cur_comp(layout);
1749         if (comp == NULL)
1750                 return -1;
1751
1752         comp->llc_flags &= ~flags;
1753
1754         return 0;
1755 }
1756
1757 /**
1758  * Fetches the file-unique component ID of the current layout component.
1759  *
1760  * \param[in] layout    the layout component
1761  * \param[out] id       stored the returned component ID
1762  *
1763  * \retval      0 on success
1764  * \retval      <0 if error occurs
1765  */
1766 int llapi_layout_comp_id_get(const struct llapi_layout *layout, uint32_t *id)
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 (id == NULL) {
1775                 errno = EINVAL;
1776                 return -1;
1777         }
1778         *id = comp->llc_id;
1779
1780         return 0;
1781 }
1782
1783 /**
1784  * Return the mirror id of the current layout component.
1785  *
1786  * \param[in] layout    the layout component
1787  * \param[out] id       stored the returned mirror ID
1788  *
1789  * \retval      0 on success
1790  * \retval      <0 if error occurs
1791  */
1792 int llapi_layout_mirror_id_get(const struct llapi_layout *layout, uint32_t *id)
1793 {
1794         struct llapi_layout_comp *comp;
1795
1796         comp = __llapi_layout_cur_comp(layout);
1797         if (comp == NULL)
1798                 return -1;
1799
1800         if (id == NULL) {
1801                 errno = EINVAL;
1802                 return -1;
1803         }
1804
1805         *id = mirror_id_of(comp->llc_id);
1806
1807         return 0;
1808 }
1809
1810 /**
1811  * Adds a component to \a layout, the new component will be added to
1812  * the tail of components list and it'll inherit attributes of existing
1813  * ones. The \a layout will change it's current component pointer to
1814  * the newly added component, and it'll be turned into a composite
1815  * layout if it was not before the adding.
1816  *
1817  * \param[in] layout    existing composite or plain layout
1818  *
1819  * \retval      0 on success
1820  * \retval      <0 if error occurs
1821  */
1822 int llapi_layout_comp_add(struct llapi_layout *layout)
1823 {
1824         struct llapi_layout_comp *last, *comp, *new;
1825
1826         comp = __llapi_layout_cur_comp(layout);
1827         if (comp == NULL)
1828                 return -1;
1829
1830         new = __llapi_comp_alloc(0);
1831         if (new == NULL)
1832                 return -1;
1833
1834         last = list_entry(layout->llot_comp_list.prev, typeof(*last),
1835                           llc_list);
1836
1837         if (new->llc_extent.e_end <= last->llc_extent.e_end) {
1838                 __llapi_comp_free(new);
1839                 errno = EINVAL;
1840                 return -1;
1841         }
1842         new->llc_extent.e_start = last->llc_extent.e_end;
1843
1844         list_add_tail(&new->llc_list, &layout->llot_comp_list);
1845         layout->llot_cur_comp = new;
1846         layout->llot_is_composite = true;
1847
1848         return 0;
1849 }
1850
1851 /**
1852  * Deletes current component from the composite layout. The component
1853  * to be deleted must be the tail of components list, and it can't be
1854  * the only component in the layout.
1855  *
1856  * \param[in] layout    composite layout
1857  *
1858  * \retval      0 on success
1859  * \retval      <0 if error occurs
1860  */
1861 int llapi_layout_comp_del(struct llapi_layout *layout)
1862 {
1863         struct llapi_layout_comp *comp;
1864
1865         comp = __llapi_layout_cur_comp(layout);
1866         if (comp == NULL)
1867                 return -1;
1868
1869         if (!layout->llot_is_composite) {
1870                 errno = EINVAL;
1871                 return -1;
1872         }
1873
1874         /* It must be the tail of the list (for PFL, can be relaxed
1875          * once we get mirrored components) */
1876         if (comp->llc_list.next != &layout->llot_comp_list) {
1877                 errno = EINVAL;
1878                 return -1;
1879         }
1880         /* It can't be the only one on the list */
1881         if (comp->llc_list.prev == &layout->llot_comp_list) {
1882                 errno = EINVAL;
1883                 return -1;
1884         }
1885
1886         layout->llot_cur_comp =
1887                 list_entry(comp->llc_list.prev, typeof(*comp), llc_list);
1888         list_del_init(&comp->llc_list);
1889         __llapi_comp_free(comp);
1890
1891         return 0;
1892 }
1893
1894 /**
1895  * Move the current component pointer to the component with
1896  * specified component ID.
1897  *
1898  * \param[in] layout    composite layout
1899  * \param[in] id        component ID
1900  *
1901  * \retval      =0 : moved successfully
1902  * \retval      <0 if error occurs
1903  */
1904 int llapi_layout_comp_use_id(struct llapi_layout *layout, uint32_t comp_id)
1905 {
1906         struct llapi_layout_comp *comp;
1907
1908         comp = __llapi_layout_cur_comp(layout);
1909         if (comp == NULL)
1910                 return -1; /* use previously set errno */
1911
1912         if (!layout->llot_is_composite) {
1913                 errno = EINVAL;
1914                 return -1;
1915         }
1916
1917         if (comp_id == LCME_ID_INVAL) {
1918                 errno = EINVAL;
1919                 return -1;
1920         }
1921
1922         list_for_each_entry(comp, &layout->llot_comp_list, llc_list) {
1923                 if (comp->llc_id == comp_id) {
1924                         layout->llot_cur_comp = comp;
1925                         return 0;
1926                 }
1927         }
1928         errno = ENOENT;
1929         return -1;
1930 }
1931
1932 /**
1933  * Move the current component pointer to a specified position.
1934  *
1935  * \param[in] layout    composite layout
1936  * \param[in] pos       the position to be moved, it can be:
1937  *                      LLAPI_LAYOUT_COMP_USE_FIRST: use first component
1938  *                      LLAPI_LAYOUT_COMP_USE_LAST: use last component
1939  *                      LLAPI_LAYOUT_COMP_USE_NEXT: use component after current
1940  *                      LLAPI_LAYOUT_COMP_USE_PREV: use component before current
1941  *
1942  * \retval      =0 : moved successfully
1943  * \retval      =1 : at last component with NEXT, at first component with PREV
1944  * \retval      <0 if error occurs
1945  */
1946 int llapi_layout_comp_use(struct llapi_layout *layout,
1947                           enum llapi_layout_comp_use pos)
1948 {
1949         struct llapi_layout_comp *comp, *head, *tail;
1950
1951         comp = __llapi_layout_cur_comp(layout);
1952         if (comp == NULL)
1953                 return -1;
1954
1955         if (!layout->llot_is_composite) {
1956                 if (pos == LLAPI_LAYOUT_COMP_USE_FIRST ||
1957                     pos == LLAPI_LAYOUT_COMP_USE_LAST)
1958                         return 0;
1959                 errno = ENOENT;
1960                 return 1;
1961         }
1962
1963         head = list_entry(layout->llot_comp_list.next, typeof(*head), llc_list);
1964         tail = list_entry(layout->llot_comp_list.prev, typeof(*tail), llc_list);
1965         switch (pos) {
1966         case LLAPI_LAYOUT_COMP_USE_FIRST:
1967                 layout->llot_cur_comp = head;
1968                 break;
1969         case LLAPI_LAYOUT_COMP_USE_NEXT:
1970                 if (comp == tail) {
1971                         errno = ENOENT;
1972                         return 1;
1973                 }
1974                 layout->llot_cur_comp = list_entry(comp->llc_list.next,
1975                                                    typeof(*comp), llc_list);
1976                 break;
1977         case LLAPI_LAYOUT_COMP_USE_LAST:
1978                 layout->llot_cur_comp = tail;
1979                 break;
1980         case LLAPI_LAYOUT_COMP_USE_PREV:
1981                 if (comp == head) {
1982                         errno = ENOENT;
1983                         return 1;
1984                 }
1985                 layout->llot_cur_comp = list_entry(comp->llc_list.prev,
1986                                                    typeof(*comp), llc_list);
1987                 break;
1988         default:
1989                 errno = EINVAL;
1990                 return -1;
1991         }
1992
1993         return 0;
1994 }
1995
1996 /**
1997  * Add layout component(s) to an existing file.
1998  *
1999  * \param[in] path      The path name of the file
2000  * \param[in] layout    The layout component(s) to be added
2001  */
2002 int llapi_layout_file_comp_add(const char *path,
2003                                const struct llapi_layout *layout)
2004 {
2005         int rc, fd, lum_size, tmp_errno = 0;
2006         struct lov_user_md *lum;
2007
2008         if (path == NULL || layout == NULL ||
2009             layout->llot_magic != LLAPI_LAYOUT_MAGIC) {
2010                 errno = EINVAL;
2011                 return -1;
2012         }
2013
2014         lum = llapi_layout_to_lum(layout);
2015         if (lum == NULL)
2016                 return -1;
2017
2018         if (lum->lmm_magic != LOV_USER_MAGIC_COMP_V1) {
2019                 free(lum);
2020                 errno = EINVAL;
2021                 return -1;
2022         }
2023         lum_size = ((struct lov_comp_md_v1 *)lum)->lcm_size;
2024
2025         fd = open(path, O_RDWR);
2026         if (fd < 0) {
2027                 tmp_errno = errno;
2028                 rc = -1;
2029                 goto out;
2030         }
2031
2032         rc = fsetxattr(fd, XATTR_LUSTRE_LOV".add", lum, lum_size, 0);
2033         if (rc < 0) {
2034                 tmp_errno = errno;
2035                 close(fd);
2036                 rc = -1;
2037                 goto out;
2038         }
2039         close(fd);
2040 out:
2041         free(lum);
2042         errno = tmp_errno;
2043         return rc;
2044 }
2045
2046 /**
2047  * Delete component(s) by the specified component id or component flags
2048  * from an existing file.
2049  *
2050  * \param[in] path      path name of the file
2051  * \param[in] id        unique component ID
2052  * \param[in] flags     flags: LCME_FL_* or;
2053  *                      negative flags: (LCME_FL_NEG|LCME_FL_*)
2054  */
2055 int llapi_layout_file_comp_del(const char *path, uint32_t id, uint32_t flags)
2056 {
2057         int rc, fd, lum_size;
2058         struct llapi_layout *layout;
2059         struct llapi_layout_comp *comp;
2060         struct lov_user_md *lum;
2061
2062         if (path == NULL || id > LCME_ID_MAX || (flags & ~LCME_KNOWN_FLAGS)) {
2063                 errno = EINVAL;
2064                 return -1;
2065         }
2066
2067         /* Can only specify ID or flags, not both. */
2068         if (id != 0 && flags != 0) {
2069                 errno = EINVAL;
2070                 return -1;
2071         }
2072
2073         layout = llapi_layout_alloc();
2074         if (layout == NULL)
2075                 return -1;
2076
2077         llapi_layout_comp_extent_set(layout, 0, LUSTRE_EOF);
2078         comp = __llapi_layout_cur_comp(layout);
2079         if (comp == NULL) {
2080                 llapi_layout_free(layout);
2081                 return -1;
2082         }
2083
2084         comp->llc_id = id;
2085         comp->llc_flags = flags;
2086
2087         lum = llapi_layout_to_lum(layout);
2088         if (lum == NULL) {
2089                 llapi_layout_free(layout);
2090                 return -1;
2091         }
2092         lum_size = ((struct lov_comp_md_v1 *)lum)->lcm_size;
2093
2094         fd = open(path, O_RDWR);
2095         if (fd < 0) {
2096                 rc = -1;
2097                 goto out;
2098         }
2099
2100         rc = fsetxattr(fd, XATTR_LUSTRE_LOV".del", lum, lum_size, 0);
2101         if (rc < 0) {
2102                 int tmp_errno = errno;
2103                 close(fd);
2104                 errno = tmp_errno;
2105                 rc = -1;
2106                 goto out;
2107         }
2108         close(fd);
2109 out:
2110         free(lum);
2111         llapi_layout_free(layout);
2112         return rc;
2113 }
2114
2115 /**
2116  * Change flags or other parameters of the component(s) by component ID of an
2117  * existing file. The component to be modified is specified by the
2118  * comp->lcme_id value, which must be an unique component ID. The new
2119  * attributes are passed in by @comp and @valid is used to specify which
2120  * attributes in the component are going to be changed.
2121  */
2122 int llapi_layout_file_comp_set(const char *path,
2123                                const struct llapi_layout *comp,
2124                                uint32_t valid)
2125 {
2126         errno = EOPNOTSUPP;
2127         return -1;
2128 }
2129
2130 /**
2131  * Check if the file layout is composite.
2132  *
2133  * \param[in] layout    the file layout to check
2134  *
2135  * \retval true         composite
2136  * \retval false        not composite
2137  */
2138 bool llapi_layout_is_composite(struct llapi_layout *layout)
2139 {
2140         return layout->llot_is_composite;
2141 }
2142
2143 /**
2144  * llapi_layout_merge() - Merge a composite layout into another one.
2145  * @dst_layout: Destination composite layout.
2146  * @src_layout: Source composite layout.
2147  *
2148  * This function copies all of the components from @src_layout and
2149  * appends them to @dst_layout.
2150  *
2151  * Return: 0 on success or -1 on failure.
2152  */
2153 int llapi_layout_merge(struct llapi_layout **dst_layout,
2154                        const struct llapi_layout *src_layout)
2155 {
2156         struct llapi_layout *new_layout = *dst_layout;
2157         struct llapi_layout_comp *new = NULL;
2158         struct llapi_layout_comp *comp = NULL;
2159         int i = 0;
2160
2161         if (src_layout == NULL ||
2162             list_empty((struct list_head *)&src_layout->llot_comp_list))
2163                 return 0;
2164
2165         if (new_layout == NULL) {
2166                 new_layout = __llapi_layout_alloc();
2167                 if (new_layout == NULL) {
2168                         errno = ENOMEM;
2169                         return -1;
2170                 }
2171         }
2172
2173         list_for_each_entry(comp, &src_layout->llot_comp_list, llc_list) {
2174                 new = __llapi_comp_alloc(0);
2175                 if (new == NULL) {
2176                         errno = ENOMEM;
2177                         goto error;
2178                 }
2179
2180                 new->llc_pattern = comp->llc_pattern;
2181                 new->llc_stripe_size = comp->llc_stripe_size;
2182                 new->llc_stripe_count = comp->llc_stripe_count;
2183                 new->llc_stripe_offset = comp->llc_stripe_offset;
2184
2185                 if (comp->llc_pool_name[0] != '\0')
2186                         strncpy(new->llc_pool_name, comp->llc_pool_name,
2187                                 sizeof(new->llc_pool_name));
2188
2189                 for (i = 0; i < comp->llc_objects_count; i++) {
2190                         if (__llapi_comp_objects_realloc(new,
2191                             stripe_number_roundup(i)) < 0) {
2192                                 errno = EINVAL;
2193                                 __llapi_comp_free(new);
2194                                 goto error;
2195                         }
2196                         new->llc_objects[i].l_ost_idx = \
2197                                 comp->llc_objects[i].l_ost_idx;
2198                 }
2199
2200                 new->llc_objects_count = comp->llc_objects_count;
2201                 new->llc_extent.e_start = comp->llc_extent.e_start;
2202                 new->llc_extent.e_end = comp->llc_extent.e_end;
2203                 new->llc_id = comp->llc_id;
2204                 new->llc_flags = comp->llc_flags;
2205
2206                 list_add_tail(&new->llc_list, &new_layout->llot_comp_list);
2207                 new_layout->llot_cur_comp = new;
2208         }
2209         new_layout->llot_is_composite = true;
2210
2211         *dst_layout = new_layout;
2212         return 0;
2213 error:
2214         llapi_layout_free(new_layout);
2215         return -1;
2216 }