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