Whamcloud - gitweb
f2da472c46824b650625df9de5b9377fecd8261a
[fs/lustre-release.git] / lustre / lov / lov_pack.c
1 /*
2  * GPL HEADER START
3  *
4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License version 2 only,
8  * as published by the Free Software Foundation.
9  *
10  * This program is distributed in the hope that it will be useful, but
11  * WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  * General Public License version 2 for more details (a copy is included
14  * in the LICENSE file that accompanied this code).
15  *
16  * You should have received a copy of the GNU General Public License
17  * version 2 along with this program; If not, see
18  * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
19  *
20  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
21  * CA 95054 USA or visit www.sun.com if you need additional information or
22  * have any questions.
23  *
24  * GPL HEADER END
25  */
26 /*
27  * Copyright (c) 2002, 2010, Oracle and/or its affiliates. All rights reserved.
28  * Use is subject to license terms.
29  *
30  * Copyright (c) 2011, 2013, Intel Corporation.
31  */
32 /*
33  * This file is part of Lustre, http://www.lustre.org/
34  * Lustre is a trademark of Sun Microsystems, Inc.
35  *
36  * lustre/lov/lov_pack.c
37  *
38  * (Un)packing of OST/MDS requests
39  *
40  * Author: Andreas Dilger <adilger@clusterfs.com>
41  */
42
43 #define DEBUG_SUBSYSTEM S_LOV
44 #ifndef __KERNEL__
45 #include <liblustre.h>
46 #endif
47
48 #include <lustre_net.h>
49 #include <obd.h>
50 #include <obd_lov.h>
51 #include <obd_class.h>
52 #include <obd_support.h>
53 #include <lustre/lustre_user.h>
54
55 #include "lov_internal.h"
56
57 static void lov_dump_lmm_common(int level, void *lmmp)
58 {
59         struct lov_mds_md *lmm = lmmp;
60         struct ost_id   oi;
61
62         lmm_oi_le_to_cpu(&oi, &lmm->lmm_oi);
63         CDEBUG(level, "objid "DOSTID", magic 0x%08x, pattern %#x\n",
64                POSTID(&oi), le32_to_cpu(lmm->lmm_magic),
65                le32_to_cpu(lmm->lmm_pattern));
66         CDEBUG(level, "stripe_size %u, stripe_count %u, layout_gen %u\n",
67                le32_to_cpu(lmm->lmm_stripe_size),
68                le16_to_cpu(lmm->lmm_stripe_count),
69                le16_to_cpu(lmm->lmm_layout_gen));
70 }
71
72 static void lov_dump_lmm_objects(int level, struct lov_ost_data *lod,
73                                  int stripe_count)
74 {
75         int i;
76
77         if (stripe_count > LOV_V1_INSANE_STRIPE_COUNT) {
78                 CDEBUG(level, "bad stripe_count %u > max_stripe_count %u\n",
79                        stripe_count, LOV_V1_INSANE_STRIPE_COUNT);
80         }
81
82         for (i = 0; i < stripe_count; ++i, ++lod) {
83                 struct ost_id   oi;
84
85                 ostid_le_to_cpu(&lod->l_ost_oi, &oi);
86                 CDEBUG(level, "stripe %u idx %u subobj "DOSTID"\n", i,
87                        le32_to_cpu(lod->l_ost_idx), POSTID(&oi));
88         }
89 }
90
91 void lov_dump_lmm_v1(int level, struct lov_mds_md_v1 *lmm)
92 {
93         lov_dump_lmm_common(level, lmm);
94         lov_dump_lmm_objects(level, lmm->lmm_objects,
95                              le16_to_cpu(lmm->lmm_stripe_count));
96 }
97
98 void lov_dump_lmm_v3(int level, struct lov_mds_md_v3 *lmm)
99 {
100         lov_dump_lmm_common(level, lmm);
101         CDEBUG(level,"pool_name "LOV_POOLNAMEF"\n", lmm->lmm_pool_name);
102         lov_dump_lmm_objects(level, lmm->lmm_objects,
103                              le16_to_cpu(lmm->lmm_stripe_count));
104 }
105
106 void lov_dump_lmm(int level, void *lmm)
107 {
108         int magic;
109
110         magic = ((struct lov_mds_md_v1 *)(lmm))->lmm_magic;
111         switch (magic) {
112         case LOV_MAGIC_V1:
113                 return lov_dump_lmm_v1(level, (struct lov_mds_md_v1 *)(lmm));
114         case LOV_MAGIC_V3:
115                 return lov_dump_lmm_v3(level, (struct lov_mds_md_v3 *)(lmm));
116         default:
117                 CERROR("Cannot recognize lmm_magic %x", magic);
118         }
119         return;
120 }
121
122 #define LMM_ASSERT(test)                                                \
123 do {                                                                    \
124         if (!(test)) lov_dump_lmm(D_ERROR, lmm);                        \
125         LASSERT(test); /* so we know what assertion failed */           \
126 } while(0)
127
128 /* Pack LOV object metadata for disk storage.  It is packed in LE byte
129  * order and is opaque to the networking layer.
130  *
131  * XXX In the future, this will be enhanced to get the EA size from the
132  *     underlying OSC device(s) to get their EA sizes so we can stack
133  *     LOVs properly.  For now lov_mds_md_size() just assumes one obd_id
134  *     per stripe.
135  */
136 int lov_packmd(struct obd_export *exp, struct lov_mds_md **lmmp,
137                struct lov_stripe_md *lsm)
138 {
139         struct obd_device *obd = class_exp2obd(exp);
140         struct lov_obd *lov = &obd->u.lov;
141         struct lov_mds_md_v1 *lmmv1;
142         struct lov_mds_md_v3 *lmmv3;
143         __u16 stripe_count;
144         struct lov_ost_data_v1 *lmm_objects;
145         int lmm_size, lmm_magic;
146         int i;
147         int cplen = 0;
148         ENTRY;
149
150         if (lsm) {
151                 lmm_magic = lsm->lsm_magic;
152         } else {
153                 if (lmmp && *lmmp)
154                         lmm_magic = le32_to_cpu((*lmmp)->lmm_magic);
155                 else
156                         /* lsm == NULL and lmmp == NULL */
157                         lmm_magic = LOV_MAGIC;
158         }
159
160         if ((lmm_magic != LOV_MAGIC_V1) &&
161             (lmm_magic != LOV_MAGIC_V3)) {
162                 CERROR("bad mem LOV MAGIC: 0x%08X != 0x%08X nor 0x%08X\n",
163                         lmm_magic, LOV_MAGIC_V1, LOV_MAGIC_V3);
164                 RETURN(-EINVAL);
165
166         }
167
168         if (lsm) {
169                 /* If we are just sizing the EA, limit the stripe count
170                  * to the actual number of OSTs in this filesystem. */
171                 if (!lmmp) {
172                         stripe_count = lov_get_stripecnt(lov, lmm_magic,
173                                                          lsm->lsm_stripe_count);
174                         lsm->lsm_stripe_count = stripe_count;
175                 } else {
176                         stripe_count = lsm->lsm_stripe_count;
177                 }
178         } else {
179                 /* No need to allocate more than maximum supported stripes.
180                  * Anyway, this is pretty inaccurate since ld_tgt_count now
181                  * represents max index and we should rely on the actual number
182                  * of OSTs instead */
183                 stripe_count = lov_mds_md_stripecnt(lov->lov_ocd.ocd_max_easize,
184                                                     lmm_magic);
185                 if (stripe_count > lov->desc.ld_tgt_count)
186                         stripe_count = lov->desc.ld_tgt_count;
187         }
188
189         /* XXX LOV STACKING call into osc for sizes */
190         lmm_size = lov_mds_md_size(stripe_count, lmm_magic);
191
192         if (!lmmp)
193                 RETURN(lmm_size);
194
195         if (*lmmp && !lsm) {
196                 stripe_count = le16_to_cpu((*lmmp)->lmm_stripe_count);
197                 lmm_size = lov_mds_md_size(stripe_count, lmm_magic);
198                 OBD_FREE_LARGE(*lmmp, lmm_size);
199                 *lmmp = NULL;
200                 RETURN(0);
201         }
202
203         if (!*lmmp) {
204                 OBD_ALLOC_LARGE(*lmmp, lmm_size);
205                 if (!*lmmp)
206                         RETURN(-ENOMEM);
207         }
208
209         CDEBUG(D_INFO, "lov_packmd: LOV_MAGIC 0x%08X, lmm_size = %d \n",
210                lmm_magic, lmm_size);
211
212         lmmv1 = *lmmp;
213         lmmv3 = (struct lov_mds_md_v3 *)*lmmp;
214         if (lmm_magic == LOV_MAGIC_V3)
215                 lmmv3->lmm_magic = cpu_to_le32(LOV_MAGIC_V3);
216         else
217                 lmmv1->lmm_magic = cpu_to_le32(LOV_MAGIC_V1);
218
219         if (!lsm)
220                 RETURN(lmm_size);
221
222         /* lmmv1 and lmmv3 point to the same struct and have the
223          * same first fields
224          */
225         lmm_oi_cpu_to_le(&lmmv1->lmm_oi, &lsm->lsm_oi);
226         lmmv1->lmm_stripe_size = cpu_to_le32(lsm->lsm_stripe_size);
227         lmmv1->lmm_stripe_count = cpu_to_le16(stripe_count);
228         lmmv1->lmm_pattern = cpu_to_le32(lsm->lsm_pattern);
229         lmmv1->lmm_layout_gen = cpu_to_le16(lsm->lsm_layout_gen);
230         if (lsm->lsm_magic == LOV_MAGIC_V3) {
231                 cplen = strlcpy(lmmv3->lmm_pool_name, lsm->lsm_pool_name,
232                                 sizeof(lmmv3->lmm_pool_name));
233                 if (cplen >= sizeof(lmmv3->lmm_pool_name))
234                         RETURN(-E2BIG);
235                 lmm_objects = lmmv3->lmm_objects;
236         } else {
237                 lmm_objects = lmmv1->lmm_objects;
238         }
239
240         for (i = 0; i < stripe_count; i++) {
241                 struct lov_oinfo *loi = lsm->lsm_oinfo[i];
242                 /* XXX LOV STACKING call down to osc_packmd() to do packing */
243                 LASSERTF(ostid_id(&loi->loi_oi) != 0, "lmm_oi "DOSTID
244                          " stripe %u/%u idx %u\n", POSTID(&lmmv1->lmm_oi),
245                          i, stripe_count, loi->loi_ost_idx);
246                 ostid_cpu_to_le(&loi->loi_oi, &lmm_objects[i].l_ost_oi);
247                 lmm_objects[i].l_ost_gen = cpu_to_le32(loi->loi_ost_gen);
248                 lmm_objects[i].l_ost_idx = cpu_to_le32(loi->loi_ost_idx);
249         }
250
251         RETURN(lmm_size);
252 }
253
254 /* Find the max stripecount we should use */
255 __u16 lov_get_stripecnt(struct lov_obd *lov, __u32 magic, __u16 stripe_count)
256 {
257         __u32 max_stripes = LOV_MAX_STRIPE_COUNT_OLD;
258
259         if (!stripe_count)
260                 stripe_count = lov->desc.ld_default_stripe_count;
261         if (stripe_count > lov->desc.ld_active_tgt_count)
262                 stripe_count = lov->desc.ld_active_tgt_count;
263         if (!stripe_count)
264                 stripe_count = 1;
265
266         /* stripe count is based on whether ldiskfs can handle
267          * larger EA sizes */
268         if (lov->lov_ocd.ocd_connect_flags & OBD_CONNECT_MAX_EASIZE &&
269             lov->lov_ocd.ocd_max_easize)
270                 max_stripes = lov_mds_md_stripecnt(lov->lov_ocd.ocd_max_easize,
271                                                    magic);
272
273         if (stripe_count > max_stripes)
274                 stripe_count = max_stripes;
275
276         return stripe_count;
277 }
278
279
280 static int lov_verify_lmm(void *lmm, int lmm_bytes, __u16 *stripe_count)
281 {
282         int rc;
283
284         if (lsm_op_find(le32_to_cpu(*(__u32 *)lmm)) == NULL) {
285                 char *buffer;
286                 int sz;
287
288                 CERROR("bad disk LOV MAGIC: 0x%08X; dumping LMM (size=%d):\n",
289                        le32_to_cpu(*(__u32 *)lmm), lmm_bytes);
290                 sz = lmm_bytes * 2 + 1;
291                 OBD_ALLOC_LARGE(buffer, sz);
292                 if (buffer != NULL) {
293                         int i;
294
295                         for (i = 0; i < lmm_bytes; i++)
296                                 sprintf(buffer+2*i, "%.2X", ((char *)lmm)[i]);
297                         buffer[sz - 1] = '\0';
298                         CERROR("%s\n", buffer);
299                         OBD_FREE_LARGE(buffer, sz);
300                 }
301                 return -EINVAL;
302         }
303         rc = lsm_op_find(le32_to_cpu(*(__u32 *)lmm))->lsm_lmm_verify(lmm,
304                                      lmm_bytes, stripe_count);
305         return rc;
306 }
307
308 int lov_alloc_memmd(struct lov_stripe_md **lsmp, __u16 stripe_count,
309                     int pattern, int magic)
310 {
311         int i, lsm_size;
312         ENTRY;
313
314         CDEBUG(D_INFO, "alloc lsm, stripe_count %d\n", stripe_count);
315
316         *lsmp = lsm_alloc_plain(stripe_count, &lsm_size);
317         if (!*lsmp) {
318                 CERROR("can't allocate lsmp stripe_count %d\n", stripe_count);
319                 RETURN(-ENOMEM);
320         }
321
322         cfs_atomic_set(&(*lsmp)->lsm_refc, 1);
323         spin_lock_init(&(*lsmp)->lsm_lock);
324         (*lsmp)->lsm_magic = magic;
325         (*lsmp)->lsm_stripe_count = stripe_count;
326         (*lsmp)->lsm_maxbytes = LUSTRE_STRIPE_MAXBYTES * stripe_count;
327         (*lsmp)->lsm_pattern = pattern;
328         (*lsmp)->lsm_pool_name[0] = '\0';
329         (*lsmp)->lsm_layout_gen = 0;
330         (*lsmp)->lsm_oinfo[0]->loi_ost_idx = ~0;
331
332         for (i = 0; i < stripe_count; i++)
333                 loi_init((*lsmp)->lsm_oinfo[i]);
334
335         RETURN(lsm_size);
336 }
337
338 int lov_free_memmd(struct lov_stripe_md **lsmp)
339 {
340         struct lov_stripe_md *lsm = *lsmp;
341         int refc;
342
343         *lsmp = NULL;
344         LASSERT(cfs_atomic_read(&lsm->lsm_refc) > 0);
345         if ((refc = cfs_atomic_dec_return(&lsm->lsm_refc)) == 0) {
346                 LASSERT(lsm_op_find(lsm->lsm_magic) != NULL);
347                 lsm_op_find(lsm->lsm_magic)->lsm_free(lsm);
348         }
349         return refc;
350 }
351
352
353 /* Unpack LOV object metadata from disk storage.  It is packed in LE byte
354  * order and is opaque to the networking layer.
355  */
356 int lov_unpackmd(struct obd_export *exp,  struct lov_stripe_md **lsmp,
357                  struct lov_mds_md *lmm, int lmm_bytes)
358 {
359         struct obd_device *obd = class_exp2obd(exp);
360         struct lov_obd *lov = &obd->u.lov;
361         int rc = 0, lsm_size;
362         __u16 stripe_count;
363         __u32 magic;
364         ENTRY;
365
366         /* If passed an MDS struct use values from there, otherwise defaults */
367         if (lmm) {
368                 rc = lov_verify_lmm(lmm, lmm_bytes, &stripe_count);
369                 if (rc)
370                         RETURN(rc);
371                 magic = le32_to_cpu(lmm->lmm_magic);
372         } else {
373                 magic = LOV_MAGIC;
374                 stripe_count = lov_get_stripecnt(lov, magic, 0);
375         }
376
377         /* If we aren't passed an lsmp struct, we just want the size */
378         if (!lsmp) {
379                 /* XXX LOV STACKING call into osc for sizes */
380                 LBUG();
381                 RETURN(lov_stripe_md_size(stripe_count));
382         }
383         /* If we are passed an allocated struct but nothing to unpack, free */
384         if (*lsmp && !lmm) {
385                 lov_free_memmd(lsmp);
386                 RETURN(0);
387         }
388
389         lsm_size = lov_alloc_memmd(lsmp, stripe_count, LOV_PATTERN_RAID0,
390                                    magic);
391         if (lsm_size < 0)
392                 RETURN(lsm_size);
393
394         /* If we are passed a pointer but nothing to unpack, we only alloc */
395         if (!lmm)
396                 RETURN(lsm_size);
397
398         LASSERT(lsm_op_find(magic) != NULL);
399         rc = lsm_op_find(magic)->lsm_unpackmd(lov, *lsmp, lmm);
400         if (rc) {
401                 lov_free_memmd(lsmp);
402                 RETURN(rc);
403         }
404
405         RETURN(lsm_size);
406 }
407
408 static int __lov_setstripe(struct obd_export *exp, int max_lmm_size,
409                            struct lov_stripe_md **lsmp,
410                            struct lov_user_md *lump)
411 {
412         struct obd_device *obd = class_exp2obd(exp);
413         struct lov_obd *lov = &obd->u.lov;
414         char buffer[sizeof(struct lov_user_md_v3)];
415         struct lov_user_md_v3 *lumv3 = (struct lov_user_md_v3 *)&buffer[0];
416         struct lov_user_md_v1 *lumv1 = (struct lov_user_md_v1 *)&buffer[0];
417         int lmm_magic;
418         __u16 stripe_count;
419         int rc;
420         int cplen = 0;
421         ENTRY;
422
423         rc = lov_lum_swab_if_needed(lumv3, &lmm_magic, lump);
424         if (rc)
425                 RETURN(rc);
426
427         /* in the rest of the tests, as *lumv1 and lumv3 have the same
428          * fields, we use lumv1 to avoid code duplication */
429
430         if (lumv1->lmm_pattern == 0) {
431                 lumv1->lmm_pattern = lov->desc.ld_pattern ?
432                         lov->desc.ld_pattern : LOV_PATTERN_RAID0;
433         }
434
435         if (lumv1->lmm_pattern != LOV_PATTERN_RAID0) {
436                 CDEBUG(D_IOCTL, "bad userland stripe pattern: %#x\n",
437                        lumv1->lmm_pattern);
438                 RETURN(-EINVAL);
439         }
440
441         /* 64kB is the largest common page size we see (ia64), and matches the
442          * check in lfs */
443         if (lumv1->lmm_stripe_size & (LOV_MIN_STRIPE_SIZE - 1)) {
444                 CDEBUG(D_IOCTL, "stripe size %u not multiple of %u, fixing\n",
445                        lumv1->lmm_stripe_size, LOV_MIN_STRIPE_SIZE);
446                 lumv1->lmm_stripe_size = LOV_MIN_STRIPE_SIZE;
447         }
448
449         if ((lumv1->lmm_stripe_offset >= lov->desc.ld_tgt_count) &&
450             (lumv1->lmm_stripe_offset !=
451              (typeof(lumv1->lmm_stripe_offset))(-1))) {
452                 CDEBUG(D_IOCTL, "stripe offset %u > number of OSTs %u\n",
453                        lumv1->lmm_stripe_offset, lov->desc.ld_tgt_count);
454                 RETURN(-EINVAL);
455         }
456         stripe_count = lov_get_stripecnt(lov, lmm_magic,
457                                          lumv1->lmm_stripe_count);
458
459         if (max_lmm_size) {
460                 int max_stripes = (max_lmm_size -
461                                    lov_mds_md_size(0, lmm_magic)) /
462                                    sizeof(struct lov_ost_data_v1);
463                 if (unlikely(max_stripes < stripe_count)) {
464                         CDEBUG(D_IOCTL, "stripe count reset from %d to %d\n",
465                                stripe_count, max_stripes);
466                         stripe_count = max_stripes;
467                 }
468         }
469
470         if (lmm_magic == LOV_USER_MAGIC_V3) {
471                 struct pool_desc *pool;
472
473                 /* In the function below, .hs_keycmp resolves to
474                  * pool_hashkey_keycmp() */
475                 /* coverity[overrun-buffer-val] */
476                 pool = lov_find_pool(lov, lumv3->lmm_pool_name);
477                 if (pool != NULL) {
478                         if (lumv3->lmm_stripe_offset !=
479                             (typeof(lumv3->lmm_stripe_offset))(-1)) {
480                                 rc = lov_check_index_in_pool(
481                                         lumv3->lmm_stripe_offset, pool);
482                                 if (rc < 0) {
483                                         lov_pool_putref(pool);
484                                         RETURN(-EINVAL);
485                                 }
486                         }
487
488                         if (stripe_count > pool_tgt_count(pool))
489                                 stripe_count = pool_tgt_count(pool);
490
491                         lov_pool_putref(pool);
492                 }
493         }
494
495         rc = lov_alloc_memmd(lsmp, stripe_count, lumv1->lmm_pattern, lmm_magic);
496
497         if (rc >= 0) {
498                 (*lsmp)->lsm_oinfo[0]->loi_ost_idx = lumv1->lmm_stripe_offset;
499                 (*lsmp)->lsm_stripe_size = lumv1->lmm_stripe_size;
500                 if (lmm_magic == LOV_USER_MAGIC_V3) {
501                         cplen = strlcpy((*lsmp)->lsm_pool_name,
502                                         lumv3->lmm_pool_name,
503                                         sizeof((*lsmp)->lsm_pool_name));
504                         if (cplen >= sizeof((*lsmp)->lsm_pool_name))
505                                 rc = -E2BIG;
506                 }
507                 rc = 0;
508         }
509
510         RETURN(rc);
511 }
512
513 /* Configure object striping information on a new file.
514  *
515  * @lmmu is a pointer to a user struct with one or more of the fields set to
516  * indicate the application preference: lmm_stripe_count, lmm_stripe_size,
517  * lmm_stripe_offset, and lmm_stripe_pattern.  lmm_magic must be LOV_MAGIC.
518  * @lsmp is a pointer to an in-core stripe MD that needs to be filled in.
519  */
520 int lov_setstripe(struct obd_export *exp, int max_lmm_size,
521                   struct lov_stripe_md **lsmp, struct lov_user_md *lump)
522 {
523         int rc;
524         mm_segment_t seg;
525
526         seg = get_fs();
527         set_fs(KERNEL_DS);
528
529         rc = __lov_setstripe(exp, max_lmm_size, lsmp, lump);
530         set_fs(seg);
531         RETURN(rc);
532 }
533
534 int lov_setea(struct obd_export *exp, struct lov_stripe_md **lsmp,
535               struct lov_user_md *lump)
536 {
537         int i;
538         int rc;
539         struct obd_export *oexp;
540         struct lov_obd *lov = &exp->exp_obd->u.lov;
541         obd_id last_id = 0;
542         struct lov_user_ost_data_v1 *lmm_objects;
543
544         ENTRY;
545
546         if (lump->lmm_magic == LOV_USER_MAGIC_V3)
547                 lmm_objects = ((struct lov_user_md_v3 *)lump)->lmm_objects;
548         else
549                 lmm_objects = lump->lmm_objects;
550
551         for (i = 0; i < lump->lmm_stripe_count; i++) {
552                 __u32 len = sizeof(last_id);
553                 oexp = lov->lov_tgts[lmm_objects[i].l_ost_idx]->ltd_exp;
554                 rc = obd_get_info(NULL, oexp, sizeof(KEY_LAST_ID), KEY_LAST_ID,
555                                   &len, &last_id, NULL);
556                 if (rc)
557                         RETURN(rc);
558                 if (ostid_id(&lmm_objects[i].l_ost_oi) > last_id) {
559                         CERROR("Setting EA for object > than last id on"
560                                " ost idx %d "DOSTID" > "LPD64" \n",
561                                lmm_objects[i].l_ost_idx,
562                                POSTID(&lmm_objects[i].l_ost_oi), last_id);
563                         RETURN(-EINVAL);
564                 }
565         }
566
567         rc = lov_setstripe(exp, 0, lsmp, lump);
568         if (rc)
569                 RETURN(rc);
570
571         for (i = 0; i < lump->lmm_stripe_count; i++) {
572                 (*lsmp)->lsm_oinfo[i]->loi_ost_idx =
573                         lmm_objects[i].l_ost_idx;
574                 (*lsmp)->lsm_oinfo[i]->loi_oi = lmm_objects[i].l_ost_oi;
575         }
576         RETURN(0);
577 }
578
579
580 /* Retrieve object striping information.
581  *
582  * @lump is a pointer to an in-core struct with lmm_ost_count indicating
583  * the maximum number of OST indices which will fit in the user buffer.
584  * lmm_magic must be LOV_USER_MAGIC.
585  */
586 int lov_getstripe(struct obd_export *exp, struct lov_stripe_md *lsm,
587                   struct lov_user_md *lump)
588 {
589         /*
590          * XXX huge struct allocated on stack.
591          */
592         /* we use lov_user_md_v3 because it is larger than lov_user_md_v1 */
593         struct lov_user_md_v3 lum;
594         struct lov_mds_md *lmmk = NULL;
595         int rc, lmm_size;
596         int lum_size;
597         mm_segment_t seg;
598         ENTRY;
599
600         if (!lsm)
601                 RETURN(-ENODATA);
602
603         /*
604          * "Switch to kernel segment" to allow copying from kernel space by
605          * copy_{to,from}_user().
606          */
607         seg = get_fs();
608         set_fs(KERNEL_DS);
609
610         /* we only need the header part from user space to get lmm_magic and
611          * lmm_stripe_count, (the header part is common to v1 and v3) */
612         lum_size = sizeof(struct lov_user_md_v1);
613         if (cfs_copy_from_user(&lum, lump, lum_size))
614                 GOTO(out_set, rc = -EFAULT);
615         else if ((lum.lmm_magic != LOV_USER_MAGIC) &&
616                  (lum.lmm_magic != LOV_USER_MAGIC_V3))
617                 GOTO(out_set, rc = -EINVAL);
618
619         if (lum.lmm_stripe_count &&
620             (lum.lmm_stripe_count < lsm->lsm_stripe_count)) {
621                 /* Return right size of stripe to user */
622                 lum.lmm_stripe_count = lsm->lsm_stripe_count;
623                 rc = cfs_copy_to_user(lump, &lum, lum_size);
624                 GOTO(out_set, rc = -EOVERFLOW);
625         }
626         rc = lov_packmd(exp, &lmmk, lsm);
627         if (rc < 0)
628                 GOTO(out_set, rc);
629         lmm_size = rc;
630         rc = 0;
631
632         /* FIXME: Bug 1185 - copy fields properly when structs change */
633         /* struct lov_user_md_v3 and struct lov_mds_md_v3 must be the same */
634         CLASSERT(sizeof(lum) == sizeof(struct lov_mds_md_v3));
635         CLASSERT(sizeof lum.lmm_objects[0] == sizeof lmmk->lmm_objects[0]);
636
637         if ((cpu_to_le32(LOV_MAGIC) != LOV_MAGIC) &&
638             ((lmmk->lmm_magic == cpu_to_le32(LOV_MAGIC_V1)) ||
639             (lmmk->lmm_magic == cpu_to_le32(LOV_MAGIC_V3)))) {
640                 lustre_swab_lov_mds_md(lmmk);
641                 lustre_swab_lov_user_md_objects(
642                                 (struct lov_user_ost_data*)lmmk->lmm_objects,
643                                 lmmk->lmm_stripe_count);
644         }
645         if (lum.lmm_magic == LOV_USER_MAGIC) {
646                 /* User request for v1, we need skip lmm_pool_name */
647                 if (lmmk->lmm_magic == LOV_MAGIC_V3) {
648                         memmove((char*)(&lmmk->lmm_stripe_count) +
649                                 sizeof(lmmk->lmm_stripe_count),
650                                 ((struct lov_mds_md_v3*)lmmk)->lmm_objects,
651                                 lmmk->lmm_stripe_count *
652                                 sizeof(struct lov_ost_data_v1));
653                         lmm_size -= LOV_MAXPOOLNAME;
654                 }
655         } else {
656                 /* if v3 we just have to update the lum_size */
657                 lum_size = sizeof(struct lov_user_md_v3);
658         }
659
660         /* User wasn't expecting this many OST entries */
661         if (lum.lmm_stripe_count == 0)
662                 lmm_size = lum_size;
663         else if (lum.lmm_stripe_count < lmmk->lmm_stripe_count)
664                 GOTO(out_set, rc = -EOVERFLOW);
665         /*
666          * Have a difference between lov_mds_md & lov_user_md.
667          * So we have to re-order the data before copy to user.
668          */
669         lum.lmm_stripe_count = lmmk->lmm_stripe_count;
670         lum.lmm_layout_gen = lmmk->lmm_layout_gen;
671         ((struct lov_user_md *)lmmk)->lmm_layout_gen = lum.lmm_layout_gen;
672         ((struct lov_user_md *)lmmk)->lmm_stripe_count = lum.lmm_stripe_count;
673         if (cfs_copy_to_user(lump, lmmk, lmm_size))
674                 rc = -EFAULT;
675
676         obd_free_diskmd(exp, &lmmk);
677 out_set:
678         set_fs(seg);
679         RETURN(rc);
680 }