Whamcloud - gitweb
51258b32a842fcb9c699cb3296d75afa1e4133ca
[fs/lustre-release.git] / lustre / lov / lov_ea.c
1 /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
2  * vim:expandtab:shiftwidth=8:tabstop=8:
3  *
4  *  Copyright (c) 2001-2005 Cluster File Systems, Inc.
5  *   Author: Wang Di <wangdi@clusterfs.com>
6  *
7  *   This file is part of the Lustre file system, http://www.lustre.org
8  *   Lustre is a trademark of Cluster File Systems, Inc.
9  *
10  *   You may have signed or agreed to another license before downloading
11  *   this software.  If so, you are bound by the terms and conditions
12  *   of that agreement, and the following does not apply to you.  See the
13  *   LICENSE file included with this distribution for more information.
14  *
15  *   If you did not agree to a different license, then this copy of Lustre
16  *   is open source software; you can redistribute it and/or modify it
17  *   under the terms of version 2 of the GNU General Public License as
18  *   published by the Free Software Foundation.
19  *
20  *   In either case, Lustre is distributed in the hope that it will be
21  *   useful, but WITHOUT ANY WARRANTY; without even the implied warranty
22  *   of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
23  *   license text for more details.
24  */
25
26 #ifndef EXPORT_SYMTAB
27 # define EXPORT_SYMTAB
28 #endif
29 #define DEBUG_SUBSYSTEM S_LOV
30
31 #ifdef __KERNEL__
32 #include <asm/div64.h>
33 #include <libcfs/libcfs.h>
34 #else
35 #include <liblustre.h>
36 #endif
37
38 #include <obd_class.h>
39 #include <obd_lov.h>
40 #include <lustre/lustre_idl.h>
41 #include <lustre_log.h>
42
43 #include "lov_internal.h"
44
45 struct lovea_unpack_args {
46         struct lov_stripe_md *lsm;
47         int                   cursor;
48 };
49
50 static int lsm_lmm_verify_common(struct lov_mds_md *lmm, int lmm_bytes,
51                                  int stripe_count)
52 {
53
54         if (stripe_count == 0) {
55                 CERROR("bad stripe count %d\n", stripe_count);
56                 lov_dump_lmm_v1(D_WARNING, lmm);
57                 return -EINVAL;
58         }
59         
60         if (lmm->lmm_object_id == 0) {
61                 CERROR("zero object id\n");
62                 lov_dump_lmm_v1(D_WARNING, lmm);
63                 return -EINVAL;
64         }
65         
66         if (lmm->lmm_pattern != cpu_to_le32(LOV_PATTERN_RAID0)) {
67                 CERROR("bad striping pattern\n");
68                 lov_dump_lmm_v1(D_WARNING, lmm);
69                 return -EINVAL;
70         }
71
72         if (lmm->lmm_stripe_size == 0 ||
73             (__u64)le32_to_cpu(lmm->lmm_stripe_size)*stripe_count > 0xffffffff){
74                 CERROR("bad stripe size %u\n",
75                        le32_to_cpu(lmm->lmm_stripe_size));
76                 lov_dump_lmm_v1(D_WARNING, lmm);
77                 return -EINVAL;
78         }
79         return 0;
80 }
81
82 struct lov_stripe_md *lsm_alloc_plain(int stripe_count, int *size)
83 {
84         struct lov_stripe_md *lsm;
85         int i, oinfo_ptrs_size;
86         struct lov_oinfo *loi;
87
88         LASSERT(stripe_count > 0);
89
90         oinfo_ptrs_size = sizeof(struct lov_oinfo *) * stripe_count;
91         *size = sizeof(struct lov_stripe_md) + oinfo_ptrs_size;
92
93         OBD_ALLOC(lsm, *size);
94         if (!lsm)
95                 return NULL;;
96
97         for (i = 0; i < stripe_count; i++) {
98                 OBD_SLAB_ALLOC(loi, lov_oinfo_slab, GFP_NOFS, sizeof(*loi));
99                 if (loi == NULL)
100                         goto err;
101                 lsm->lsm_oinfo[i] = loi;
102         }
103         lsm->lsm_stripe_count = stripe_count;
104         return lsm;
105
106 err:
107         while (--i >= 0)
108                 OBD_SLAB_FREE(lsm->lsm_oinfo[i], lov_oinfo_slab, sizeof(*loi));
109         OBD_FREE(lsm, *size);
110         return NULL;
111 }
112
113 void lsm_free_plain(struct lov_stripe_md *lsm)
114 {
115         int stripe_count = lsm->lsm_stripe_count;
116         int i;
117
118         for (i = 0; i < stripe_count; i++)
119                 OBD_SLAB_FREE(lsm->lsm_oinfo[i], lov_oinfo_slab,
120                               sizeof(struct lov_oinfo));
121         OBD_FREE(lsm, sizeof(struct lov_stripe_md) +
122                  stripe_count * sizeof(struct lov_oinfo *));
123 }
124
125 static void lsm_unpackmd_common(struct lov_stripe_md *lsm,
126                                 struct lov_mds_md *lmm)
127 {
128         lsm->lsm_object_id = le64_to_cpu(lmm->lmm_object_id);
129         lsm->lsm_object_gr = le64_to_cpu(lmm->lmm_object_gr);
130         lsm->lsm_stripe_size = le32_to_cpu(lmm->lmm_stripe_size);
131         lsm->lsm_pattern = le32_to_cpu(lmm->lmm_pattern);
132 }
133
134 static void
135 lsm_stripe_by_index_plain(struct lov_stripe_md *lsm, int *stripeno,
136                            obd_off *lov_off, unsigned long *swidth)
137 {
138         if (swidth)
139                 *swidth = (ulong)lsm->lsm_stripe_size * lsm->lsm_stripe_count;
140 }
141
142 static void
143 lsm_stripe_by_offset_plain(struct lov_stripe_md *lsm, int *stripeno,
144                            obd_off *lov_off, unsigned long *swidth)
145 {
146         if (swidth)
147                 *swidth = (ulong)lsm->lsm_stripe_size * lsm->lsm_stripe_count;
148 }
149
150 static obd_off
151 lsm_stripe_offset_by_index_plain(struct lov_stripe_md *lsm,
152                                   int stripe_index)
153 {
154         return 0;
155 }
156
157 static obd_off
158 lsm_stripe_offset_by_offset_plain(struct lov_stripe_md *lsm,
159                                   obd_off lov_off)
160 {
161         return 0;
162 }
163
164 static int
165 lsm_stripe_index_by_offset_plain(struct lov_stripe_md *lsm,
166                                   obd_off lov_off)
167 {
168         return 0;
169 }
170
171 static int lsm_revalidate_plain(struct lov_stripe_md *lsm,
172                                 struct obd_device *obd)
173 {
174         return 0;
175 }
176
177 static int lsm_destroy_plain(struct lov_stripe_md *lsm, struct obdo *oa,
178                              struct obd_export *md_exp)
179 {
180         return 0;
181 }
182
183 static int lsm_lmm_verify_plain(struct lov_mds_md *lmm, int lmm_bytes,
184                              int *stripe_count)
185 {
186         if (lmm_bytes < sizeof(*lmm)) {
187                 CERROR("lov_mds_md too small: %d, need at least %d\n",
188                        lmm_bytes, (int)sizeof(*lmm));
189                 return -EINVAL;
190         }
191
192         *stripe_count = le32_to_cpu(lmm->lmm_stripe_count);
193
194         if (lmm_bytes < lov_mds_md_v1_size(*stripe_count)) {
195                 CERROR("LOV EA too small: %d, need %d\n",
196                        lmm_bytes, lov_mds_md_v1_size(*stripe_count));
197                 lov_dump_lmm_v1(D_WARNING, lmm);
198                 return -EINVAL;
199         }
200
201         return lsm_lmm_verify_common(lmm, lmm_bytes, *stripe_count);
202 }
203
204 int lsm_unpackmd_plain(struct lov_obd *lov, struct lov_stripe_md *lsm,
205                     struct lov_mds_md_v1 *lmm)
206 {
207         struct lov_oinfo *loi;
208         int i;
209
210         lsm_unpackmd_common(lsm, lmm);
211
212         for (i = 0; i < lsm->lsm_stripe_count; i++) {
213                 /* XXX LOV STACKING call down to osc_unpackmd() */
214                 loi = lsm->lsm_oinfo[i];
215                 loi->loi_id = le64_to_cpu(lmm->lmm_objects[i].l_object_id);
216                 loi->loi_gr = le64_to_cpu(lmm->lmm_objects[i].l_object_gr);
217                 loi->loi_ost_idx = le32_to_cpu(lmm->lmm_objects[i].l_ost_idx);
218                 loi->loi_ost_gen = le32_to_cpu(lmm->lmm_objects[i].l_ost_gen);
219                 if (loi->loi_ost_idx >= lov->desc.ld_tgt_count) {
220                         CERROR("OST index %d more than OST count %d\n",
221                                loi->loi_ost_idx, lov->desc.ld_tgt_count);
222                         lov_dump_lmm_v1(D_WARNING, lmm);
223                         return -EINVAL;
224                 }
225                 if (!lov->lov_tgts[loi->loi_ost_idx]) {
226                         CERROR("OST index %d missing\n", loi->loi_ost_idx);
227                         lov_dump_lmm_v1(D_WARNING, lmm);
228                         return -EINVAL;
229                 }
230         }
231
232         return 0;
233 }
234
235 struct lsm_operations lsm_plain_ops = {
236         .lsm_free            = lsm_free_plain,
237         .lsm_destroy         = lsm_destroy_plain,
238         .lsm_stripe_by_index    = lsm_stripe_by_index_plain,
239         .lsm_stripe_by_offset   = lsm_stripe_by_offset_plain,
240         .lsm_revalidate         = lsm_revalidate_plain,
241         .lsm_stripe_offset_by_index  = lsm_stripe_offset_by_index_plain,
242         .lsm_stripe_offset_by_offset = lsm_stripe_offset_by_offset_plain,
243         .lsm_stripe_index_by_offset  = lsm_stripe_index_by_offset_plain,
244         .lsm_lmm_verify         = lsm_lmm_verify_plain,
245         .lsm_unpackmd           = lsm_unpackmd_plain,
246 };
247
248 struct lov_extent *lovea_off2le(struct lov_stripe_md *lsm, obd_off lov_off)
249 {
250         struct lov_array_info *lai;
251         struct lov_extent *le;
252         int i = 0;
253
254         LASSERT(lsm->lsm_array != NULL);
255         lai = lsm->lsm_array;
256         LASSERT(lai->lai_ext_count > 1);
257
258         for (le = lai->lai_ext_array, i = 0;
259              i < lai->lai_ext_count && le->le_start + le->le_len <= lov_off
260              && le->le_len != -1;
261              i ++, le ++) {
262                ; /* empty loop */
263         }
264
265         CDEBUG(D_INFO, "off "LPU64" idx %d, ext "LPU64":"LPU64" idx %d sc %d\n",
266                lov_off, i, le->le_start, le->le_len, le->le_loi_idx,
267                le->le_stripe_count);
268
269         RETURN(le);
270 }
271
272 struct lov_extent *lovea_idx2le(struct lov_stripe_md *lsm, int stripe_no)
273 {
274         struct lov_extent *le;
275         struct lov_array_info *lai;
276         int i, stripe_index;
277
278         LASSERT(lsm->lsm_array != NULL);
279         LASSERT(stripe_no >= 0 && stripe_no <= lsm->lsm_stripe_count);
280         lai = lsm->lsm_array;
281         LASSERT(lai->lai_ext_count > 1);
282
283         for (le = lai->lai_ext_array, i = 0, stripe_index = le->le_stripe_count;
284              i < lai->lai_ext_count && stripe_index <= stripe_no &&
285              le->le_len != -1; i ++, le ++,
286              stripe_index += le->le_stripe_count) {
287                 ; /* empty loop */
288         }
289
290         CDEBUG(D_INFO, "stripe %d idx %d, ext "LPU64":"LPU64" idx %d sc %d\n",
291                stripe_no, i, le->le_start, le->le_len, le->le_loi_idx,
292                le->le_stripe_count);
293         RETURN(le);
294 }
295
296 static void lovea_free_array_info(struct lov_stripe_md *lsm)
297 {
298         if (!lsm || !lsm->lsm_array)
299                 return;
300
301         if (lsm->lsm_array->lai_ext_array)
302                 OBD_FREE(lsm->lsm_array->lai_ext_array,
303                          lsm->lsm_array->lai_ext_count *
304                          sizeof(struct lov_extent));
305
306         OBD_FREE_PTR(lsm->lsm_array);
307 }
308
309 static void lsm_free_join(struct lov_stripe_md *lsm)
310 {
311         lovea_free_array_info(lsm);
312         lsm_free_plain(lsm);
313 }
314
315 static void
316 lsm_stripe_by_index_join(struct lov_stripe_md *lsm, int *stripeno,
317                            obd_off *lov_off, unsigned long *swidth)
318 {
319         struct lov_extent *le;
320
321         LASSERT(stripeno != NULL);
322
323         le = lovea_idx2le(lsm, *stripeno);
324
325         LASSERT(le != NULL && le->le_stripe_count != 0);
326
327         *stripeno -= le->le_loi_idx;
328
329         if (swidth)
330                 *swidth = (ulong)lsm->lsm_stripe_size * le->le_stripe_count;
331
332         if (lov_off) {
333                 struct lov_extent *lov_le = lovea_off2le(lsm, *lov_off);
334                 if (lov_le == le) {
335                         *lov_off = (*lov_off > le->le_start) ?
336                                    (*lov_off - le->le_start) : 0;
337                 } else {
338                         *lov_off = (*lov_off > le->le_start) ?
339                                    le->le_len : 0;
340                         LASSERT(*lov_off != -1);
341                 }
342         }
343 }
344
345 static void
346 lsm_stripe_by_offset_join(struct lov_stripe_md *lsm, int *stripeno,
347                            obd_off *lov_off, unsigned long *swidth)
348 {
349         struct lov_extent *le;
350
351         LASSERT(lov_off != NULL);
352
353         le = lovea_off2le(lsm, *lov_off);
354
355         LASSERT(le != NULL && le->le_stripe_count != 0);
356
357         *lov_off = (*lov_off > le->le_start) ? (*lov_off - le->le_start) : 0;
358
359         if (stripeno)
360                 *stripeno -= le->le_loi_idx;
361
362         if (swidth)
363                 *swidth = (ulong)lsm->lsm_stripe_size * le->le_stripe_count;
364 }
365
366 static obd_off
367 lsm_stripe_offset_by_index_join(struct lov_stripe_md *lsm,
368                                  int stripe_index)
369 {
370         struct lov_extent *le;
371
372         le = lovea_idx2le(lsm, stripe_index);
373
374         return le ? le->le_start : 0;
375 }
376
377 static obd_off
378 lsm_stripe_offset_by_offset_join(struct lov_stripe_md *lsm,
379                                  obd_off lov_off)
380 {
381         struct lov_extent *le;
382
383         le = lovea_off2le(lsm, lov_off);
384
385         return le ? le->le_start : 0;
386 }
387
388 static int
389 lsm_stripe_index_by_offset_join(struct lov_stripe_md *lsm,
390                                  obd_off lov_off)
391 {
392         struct lov_extent *le = NULL;
393
394         le = lovea_off2le(lsm, lov_off);
395
396         return le ? le->le_loi_idx : 0;
397 }
398
399 static int lovea_unpack_array(struct llog_handle *handle,
400                               struct llog_rec_hdr *rec, void *data)
401 {
402         struct lovea_unpack_args *args = (struct lovea_unpack_args *)data;
403         struct llog_array_rec *la_rec = (struct llog_array_rec*)rec;
404         struct mds_extent_desc *med = &la_rec->lmr_med;
405         struct lov_stripe_md *lsm = args->lsm;
406         int cursor = args->cursor++;
407         struct lov_mds_md *lmm;
408         struct lov_array_info *lai;
409         struct lov_oinfo * loi;
410         int i, loi_index;
411         ENTRY;
412
413         /* sanity check */
414         LASSERT(lsm->lsm_stripe_count != 0);
415         lmm = &med->med_lmm;
416         LASSERT(lsm->lsm_array != NULL);
417
418         lai = lsm->lsm_array;
419
420         if (cursor == 0) {
421                lai->lai_ext_array[cursor].le_loi_idx = 0;
422         } else {
423                int next_loi_index = lai->lai_ext_array[cursor - 1].le_loi_idx +
424                                  lai->lai_ext_array[cursor - 1].le_stripe_count;
425                lai->lai_ext_array[cursor].le_loi_idx = next_loi_index;
426         }
427         /* insert extent desc into lsm extent array  */
428         lai->lai_ext_array[cursor].le_start = le64_to_cpu(med->med_start);
429         lai->lai_ext_array[cursor].le_len   = le64_to_cpu(med->med_len);
430         lai->lai_ext_array[cursor].le_stripe_count = lmm->lmm_stripe_count;
431
432         /* unpack extent's lmm to lov_oinfo array */
433         loi_index = lai->lai_ext_array[cursor].le_loi_idx;
434         CDEBUG(D_INFO, "lovea upackmd cursor %d, loi_index %d extent "
435                         LPU64":"LPU64"\n", cursor, loi_index, med->med_start,
436                         med->med_len);
437
438         for (i = 0; i < le32_to_cpu(lmm->lmm_stripe_count); i ++, loi_index++) {
439                 /* XXX LOV STACKING call down to osc_unpackmd() */
440                 loi = lsm->lsm_oinfo[loi_index];
441                 loi->loi_id = le64_to_cpu(lmm->lmm_objects[i].l_object_id);
442                 loi->loi_gr = le64_to_cpu(lmm->lmm_objects[i].l_object_gr);
443                 loi->loi_ost_idx = le32_to_cpu(lmm->lmm_objects[i].l_ost_idx);
444                 loi->loi_ost_gen = le32_to_cpu(lmm->lmm_objects[i].l_ost_gen);
445         }
446
447         RETURN(0);
448 }
449
450 static int lsm_revalidate_join(struct lov_stripe_md *lsm,
451                                struct obd_device *obd)
452 {
453         struct llog_handle *llh;
454         struct llog_ctxt *ctxt;
455         struct lovea_unpack_args args;
456         int rc, rc2;
457         ENTRY;
458
459         LASSERT(lsm->lsm_array != NULL);
460
461         /*Revalidate lsm might be called from client or MDS server.
462          *So the ctxt might be in different position
463          */
464         ctxt = llog_get_context(obd, LLOG_LOVEA_REPL_CTXT);
465         if (!ctxt)
466                 ctxt = llog_get_context(obd, LLOG_LOVEA_ORIG_CTXT);
467
468         LASSERT(ctxt);
469
470         if (lsm->lsm_array && lsm->lsm_array->lai_ext_array)
471                 RETURN(0);
472
473         CDEBUG(D_INFO, "get lsm logid: "LPU64":"LPU64"\n",
474                lsm->lsm_array->lai_array_id.lgl_oid,
475                lsm->lsm_array->lai_array_id.lgl_ogr);
476         OBD_ALLOC(lsm->lsm_array->lai_ext_array,lsm->lsm_array->lai_ext_count *
477                                                 sizeof (struct lov_extent));
478         if (!lsm->lsm_array->lai_ext_array)
479                 RETURN(-ENOMEM);
480
481         CDEBUG(D_INFO, "get lsm logid: "LPU64":"LPU64"\n",
482                lsm->lsm_array->lai_array_id.lgl_oid,
483                lsm->lsm_array->lai_array_id.lgl_ogr);
484
485         rc = llog_create(ctxt, &llh, &lsm->lsm_array->lai_array_id, NULL);
486         if (rc)
487                 GOTO(out, rc);
488
489         args.lsm = lsm;
490         args.cursor = 0;
491         rc = llog_init_handle(llh, LLOG_F_IS_PLAIN, NULL);
492         if (rc == 0)
493                 rc = llog_process(llh, lovea_unpack_array, &args, NULL);
494         rc2 = llog_close(llh);
495         if (rc == 0)
496                 rc = rc2;
497 out:
498         if (rc)
499                 lovea_free_array_info(lsm);
500         RETURN(rc);
501 }
502
503 int lsm_destroy_join(struct lov_stripe_md *lsm, struct obdo *oa, 
504                       struct obd_export *md_exp)
505 {
506         struct llog_ctxt *ctxt;
507         struct llog_handle *llh;
508         int rc = 0;
509         ENTRY;
510
511         LASSERT(md_exp != NULL);
512         ctxt = llog_get_context(md_exp->exp_obd, LLOG_LOVEA_REPL_CTXT);
513         if (!ctxt)
514                 GOTO(out, rc = -EINVAL);
515
516         LASSERT(lsm->lsm_array != NULL);
517         /*for those orphan inode, we should keep array id*/
518         if (!(oa->o_valid & OBD_MD_FLCOOKIE))
519                 RETURN(0);
520
521         LASSERT(ctxt != NULL);
522         rc = llog_create(ctxt, &llh, &lsm->lsm_array->lai_array_id,
523                          NULL);
524         if (rc)
525                 GOTO(out, rc);
526
527         rc = llog_init_handle(llh, LLOG_F_IS_PLAIN, NULL);
528         if (rc == 0) {
529                 rc = llog_destroy(llh);
530         }
531         llog_free_handle(llh);
532 out:
533         RETURN(rc);
534 }
535
536 static int lsm_lmm_verify_join(struct lov_mds_md *lmm, int lmm_bytes,
537                                int *stripe_count)
538 {
539         struct lov_mds_md_join *lmmj = (struct lov_mds_md_join *)lmm;
540
541         if (lmm_bytes < sizeof(*lmmj)) {
542                 CERROR("lov_mds_md too small: %d, need at least %d\n",
543                        lmm_bytes, (int)sizeof(*lmmj));
544                 return -EINVAL;
545         }
546
547         if (lmmj->lmmj_array_id.lgl_oid == 0) {
548                 CERROR("zero array object id\n");
549                 return -EINVAL;
550         }
551
552         *stripe_count = le32_to_cpu(lmmj->lmmj_md.lmm_stripe_count);
553
554         return lsm_lmm_verify_common(&lmmj->lmmj_md, lmm_bytes, *stripe_count);
555 }
556
557 static int lovea_init_array_info(struct lov_stripe_md *lsm,
558                                  struct llog_logid *logid,
559                                  __u32 extent_count)
560 {
561         struct lov_array_info *lai;
562         ENTRY;
563
564         OBD_ALLOC_PTR(lai);
565         if (!lai)
566                 RETURN(-ENOMEM);
567
568         lai->lai_array_id = *logid;
569         lai->lai_ext_count = extent_count;
570         lsm->lsm_array = lai;
571         RETURN(0);
572 }
573
574 static int lsm_unpackmd_join(struct lov_obd *lov, struct lov_stripe_md *lsm,
575                       struct lov_mds_md *lmm)
576 {
577         struct lov_mds_md_join *lmmj = (struct lov_mds_md_join*)lmm;
578         int    rc;
579         ENTRY;
580
581         lsm_unpackmd_common(lsm, &lmmj->lmmj_md);
582
583         rc = lovea_init_array_info(lsm, &lmmj->lmmj_array_id,
584                                    lmmj->lmmj_extent_count);
585         if (rc) {
586                 CERROR("Init joined lsm id"LPU64" arrary error %d",
587                         lsm->lsm_object_id, rc);
588                 GOTO(out, rc);
589         }
590 out:
591         RETURN(rc);
592 }
593
594 struct lsm_operations lsm_join_ops = {
595         .lsm_free             = lsm_free_join,
596         .lsm_destroy          = lsm_destroy_join,
597         .lsm_stripe_by_index  = lsm_stripe_by_index_join,
598         .lsm_stripe_by_offset = lsm_stripe_by_offset_join,
599         .lsm_revalidate       = lsm_revalidate_join,
600         .lsm_stripe_offset_by_index  = lsm_stripe_offset_by_index_join,
601         .lsm_stripe_offset_by_offset = lsm_stripe_offset_by_offset_join,
602         .lsm_stripe_index_by_offset  = lsm_stripe_index_by_offset_join,
603         .lsm_lmm_verify         = lsm_lmm_verify_join,
604         .lsm_unpackmd           = lsm_unpackmd_join,
605 };
606
607