diff options
Diffstat (limited to 'fs/exofs/super.c')
-rw-r--r-- | fs/exofs/super.c | 220 |
1 files changed, 212 insertions, 8 deletions
diff --git a/fs/exofs/super.c b/fs/exofs/super.c index 4cd97f526d49..a1d1e77b12eb 100644 --- a/fs/exofs/super.c +++ b/fs/exofs/super.c | |||
@@ -214,12 +214,17 @@ int exofs_sync_fs(struct super_block *sb, int wait) | |||
214 | if (ret) | 214 | if (ret) |
215 | goto out; | 215 | goto out; |
216 | 216 | ||
217 | ios->length = sizeof(*fscb); | 217 | /* Note: We only write the changing part of the fscb. .i.e upto the |
218 | * the fscb->s_dev_table_oid member. There is no read-modify-write | ||
219 | * here. | ||
220 | */ | ||
221 | ios->length = offsetof(struct exofs_fscb, s_dev_table_oid); | ||
218 | memset(fscb, 0, ios->length); | 222 | memset(fscb, 0, ios->length); |
219 | fscb->s_nextid = cpu_to_le64(sbi->s_nextid); | 223 | fscb->s_nextid = cpu_to_le64(sbi->s_nextid); |
220 | fscb->s_numfiles = cpu_to_le32(sbi->s_numfiles); | 224 | fscb->s_numfiles = cpu_to_le32(sbi->s_numfiles); |
221 | fscb->s_magic = cpu_to_le16(sb->s_magic); | 225 | fscb->s_magic = cpu_to_le16(sb->s_magic); |
222 | fscb->s_newfs = 0; | 226 | fscb->s_newfs = 0; |
227 | fscb->s_version = EXOFS_FSCB_VER; | ||
223 | 228 | ||
224 | ios->obj.id = EXOFS_SUPER_ID; | 229 | ios->obj.id = EXOFS_SUPER_ID; |
225 | ios->offset = 0; | 230 | ios->offset = 0; |
@@ -257,6 +262,20 @@ static void _exofs_print_device(const char *msg, const char *dev_path, | |||
257 | msg, dev_path ?: "", odi->osdname, _LLU(pid)); | 262 | msg, dev_path ?: "", odi->osdname, _LLU(pid)); |
258 | } | 263 | } |
259 | 264 | ||
265 | void exofs_free_sbi(struct exofs_sb_info *sbi) | ||
266 | { | ||
267 | while (sbi->s_numdevs) { | ||
268 | int i = --sbi->s_numdevs; | ||
269 | struct osd_dev *od = sbi->s_ods[i]; | ||
270 | |||
271 | if (od) { | ||
272 | sbi->s_ods[i] = NULL; | ||
273 | osduld_put_device(od); | ||
274 | } | ||
275 | } | ||
276 | kfree(sbi); | ||
277 | } | ||
278 | |||
260 | /* | 279 | /* |
261 | * This function is called when the vfs is freeing the superblock. We just | 280 | * This function is called when the vfs is freeing the superblock. We just |
262 | * need to free our own part. | 281 | * need to free our own part. |
@@ -279,12 +298,182 @@ static void exofs_put_super(struct super_block *sb) | |||
279 | msecs_to_jiffies(100)); | 298 | msecs_to_jiffies(100)); |
280 | } | 299 | } |
281 | 300 | ||
282 | _exofs_print_device("Unmounting", NULL, sbi->s_dev, sbi->s_pid); | 301 | _exofs_print_device("Unmounting", NULL, sbi->s_ods[0], sbi->s_pid); |
283 | osduld_put_device(sbi->s_dev); | 302 | |
284 | kfree(sb->s_fs_info); | 303 | exofs_free_sbi(sbi); |
285 | sb->s_fs_info = NULL; | 304 | sb->s_fs_info = NULL; |
286 | } | 305 | } |
287 | 306 | ||
307 | static int _read_and_match_data_map(struct exofs_sb_info *sbi, unsigned numdevs, | ||
308 | struct exofs_device_table *dt) | ||
309 | { | ||
310 | sbi->data_map.odm_num_comps = | ||
311 | le32_to_cpu(dt->dt_data_map.cb_num_comps); | ||
312 | sbi->data_map.odm_stripe_unit = | ||
313 | le64_to_cpu(dt->dt_data_map.cb_stripe_unit); | ||
314 | sbi->data_map.odm_group_width = | ||
315 | le32_to_cpu(dt->dt_data_map.cb_group_width); | ||
316 | sbi->data_map.odm_group_depth = | ||
317 | le32_to_cpu(dt->dt_data_map.cb_group_depth); | ||
318 | sbi->data_map.odm_mirror_cnt = | ||
319 | le32_to_cpu(dt->dt_data_map.cb_mirror_cnt); | ||
320 | sbi->data_map.odm_raid_algorithm = | ||
321 | le32_to_cpu(dt->dt_data_map.cb_raid_algorithm); | ||
322 | |||
323 | /* FIXME: Hard coded mirror only for now. if not so do not mount */ | ||
324 | if ((sbi->data_map.odm_num_comps != numdevs) || | ||
325 | (sbi->data_map.odm_stripe_unit != EXOFS_BLKSIZE) || | ||
326 | (sbi->data_map.odm_raid_algorithm != PNFS_OSD_RAID_0) || | ||
327 | (sbi->data_map.odm_mirror_cnt != (numdevs - 1))) | ||
328 | return -EINVAL; | ||
329 | else | ||
330 | return 0; | ||
331 | } | ||
332 | |||
333 | /* @odi is valid only as long as @fscb_dev is valid */ | ||
334 | static int exofs_devs_2_odi(struct exofs_dt_device_info *dt_dev, | ||
335 | struct osd_dev_info *odi) | ||
336 | { | ||
337 | odi->systemid_len = le32_to_cpu(dt_dev->systemid_len); | ||
338 | memcpy(odi->systemid, dt_dev->systemid, odi->systemid_len); | ||
339 | |||
340 | odi->osdname_len = le32_to_cpu(dt_dev->osdname_len); | ||
341 | odi->osdname = dt_dev->osdname; | ||
342 | |||
343 | /* FIXME support long names. Will need a _put function */ | ||
344 | if (dt_dev->long_name_offset) | ||
345 | return -EINVAL; | ||
346 | |||
347 | /* Make sure osdname is printable! | ||
348 | * mkexofs should give us space for a null-terminator else the | ||
349 | * device-table is invalid. | ||
350 | */ | ||
351 | if (unlikely(odi->osdname_len >= sizeof(dt_dev->osdname))) | ||
352 | odi->osdname_len = sizeof(dt_dev->osdname) - 1; | ||
353 | dt_dev->osdname[odi->osdname_len] = 0; | ||
354 | |||
355 | /* If it's all zeros something is bad we read past end-of-obj */ | ||
356 | return !(odi->systemid_len || odi->osdname_len); | ||
357 | } | ||
358 | |||
359 | static int exofs_read_lookup_dev_table(struct exofs_sb_info **psbi, | ||
360 | unsigned table_count) | ||
361 | { | ||
362 | struct exofs_sb_info *sbi = *psbi; | ||
363 | struct osd_dev *fscb_od; | ||
364 | struct osd_obj_id obj = {.partition = sbi->s_pid, | ||
365 | .id = EXOFS_DEVTABLE_ID}; | ||
366 | struct exofs_device_table *dt; | ||
367 | unsigned table_bytes = table_count * sizeof(dt->dt_dev_table[0]) + | ||
368 | sizeof(*dt); | ||
369 | unsigned numdevs, i; | ||
370 | int ret; | ||
371 | |||
372 | dt = kmalloc(table_bytes, GFP_KERNEL); | ||
373 | if (unlikely(!dt)) { | ||
374 | EXOFS_ERR("ERROR: allocating %x bytes for device table\n", | ||
375 | table_bytes); | ||
376 | return -ENOMEM; | ||
377 | } | ||
378 | |||
379 | fscb_od = sbi->s_ods[0]; | ||
380 | sbi->s_ods[0] = NULL; | ||
381 | sbi->s_numdevs = 0; | ||
382 | ret = exofs_read_kern(fscb_od, sbi->s_cred, &obj, 0, dt, table_bytes); | ||
383 | if (unlikely(ret)) { | ||
384 | EXOFS_ERR("ERROR: reading device table\n"); | ||
385 | goto out; | ||
386 | } | ||
387 | |||
388 | numdevs = le64_to_cpu(dt->dt_num_devices); | ||
389 | if (unlikely(!numdevs)) { | ||
390 | ret = -EINVAL; | ||
391 | goto out; | ||
392 | } | ||
393 | WARN_ON(table_count != numdevs); | ||
394 | |||
395 | ret = _read_and_match_data_map(sbi, numdevs, dt); | ||
396 | if (unlikely(ret)) | ||
397 | goto out; | ||
398 | |||
399 | if (likely(numdevs > 1)) { | ||
400 | unsigned size = numdevs * sizeof(sbi->s_ods[0]); | ||
401 | |||
402 | sbi = krealloc(sbi, sizeof(*sbi) + size, GFP_KERNEL); | ||
403 | if (unlikely(!sbi)) { | ||
404 | ret = -ENOMEM; | ||
405 | goto out; | ||
406 | } | ||
407 | memset(&sbi->s_ods[1], 0, size - sizeof(sbi->s_ods[0])); | ||
408 | *psbi = sbi; | ||
409 | } | ||
410 | |||
411 | for (i = 0; i < numdevs; i++) { | ||
412 | struct exofs_fscb fscb; | ||
413 | struct osd_dev_info odi; | ||
414 | struct osd_dev *od; | ||
415 | |||
416 | if (exofs_devs_2_odi(&dt->dt_dev_table[i], &odi)) { | ||
417 | EXOFS_ERR("ERROR: Read all-zeros device entry\n"); | ||
418 | ret = -EINVAL; | ||
419 | goto out; | ||
420 | } | ||
421 | |||
422 | printk(KERN_NOTICE "Add device[%d]: osd_name-%s\n", | ||
423 | i, odi.osdname); | ||
424 | |||
425 | /* On all devices the device table is identical. The user can | ||
426 | * specify any one of the participating devices on the command | ||
427 | * line. We always keep them in device-table order. | ||
428 | */ | ||
429 | if (fscb_od && osduld_device_same(fscb_od, &odi)) { | ||
430 | sbi->s_ods[i] = fscb_od; | ||
431 | ++sbi->s_numdevs; | ||
432 | fscb_od = NULL; | ||
433 | continue; | ||
434 | } | ||
435 | |||
436 | od = osduld_info_lookup(&odi); | ||
437 | if (unlikely(IS_ERR(od))) { | ||
438 | ret = PTR_ERR(od); | ||
439 | EXOFS_ERR("ERROR: device requested is not found " | ||
440 | "osd_name-%s =>%d\n", odi.osdname, ret); | ||
441 | goto out; | ||
442 | } | ||
443 | |||
444 | sbi->s_ods[i] = od; | ||
445 | ++sbi->s_numdevs; | ||
446 | |||
447 | /* Read the fscb of the other devices to make sure the FS | ||
448 | * partition is there. | ||
449 | */ | ||
450 | ret = exofs_read_kern(od, sbi->s_cred, &obj, 0, &fscb, | ||
451 | sizeof(fscb)); | ||
452 | if (unlikely(ret)) { | ||
453 | EXOFS_ERR("ERROR: Malformed participating device " | ||
454 | "error reading fscb osd_name-%s\n", | ||
455 | odi.osdname); | ||
456 | goto out; | ||
457 | } | ||
458 | |||
459 | /* TODO: verify other information is correct and FS-uuid | ||
460 | * matches. Benny what did you say about device table | ||
461 | * generation and old devices? | ||
462 | */ | ||
463 | } | ||
464 | |||
465 | out: | ||
466 | kfree(dt); | ||
467 | if (unlikely(!ret && fscb_od)) { | ||
468 | EXOFS_ERR( | ||
469 | "ERROR: Bad device-table container device not present\n"); | ||
470 | osduld_put_device(fscb_od); | ||
471 | ret = -EINVAL; | ||
472 | } | ||
473 | |||
474 | return ret; | ||
475 | } | ||
476 | |||
288 | /* | 477 | /* |
289 | * Read the superblock from the OSD and fill in the fields | 478 | * Read the superblock from the OSD and fill in the fields |
290 | */ | 479 | */ |
@@ -296,6 +485,7 @@ static int exofs_fill_super(struct super_block *sb, void *data, int silent) | |||
296 | struct osd_dev *od; /* Master device */ | 485 | struct osd_dev *od; /* Master device */ |
297 | struct exofs_fscb fscb; /*on-disk superblock info */ | 486 | struct exofs_fscb fscb; /*on-disk superblock info */ |
298 | struct osd_obj_id obj; | 487 | struct osd_obj_id obj; |
488 | unsigned table_count; | ||
299 | int ret; | 489 | int ret; |
300 | 490 | ||
301 | sbi = kzalloc(sizeof(*sbi), GFP_KERNEL); | 491 | sbi = kzalloc(sizeof(*sbi), GFP_KERNEL); |
@@ -309,7 +499,8 @@ static int exofs_fill_super(struct super_block *sb, void *data, int silent) | |||
309 | goto free_sbi; | 499 | goto free_sbi; |
310 | } | 500 | } |
311 | 501 | ||
312 | sbi->s_dev = od; | 502 | sbi->s_ods[0] = od; |
503 | sbi->s_numdevs = 1; | ||
313 | sbi->s_pid = opts->pid; | 504 | sbi->s_pid = opts->pid; |
314 | sbi->s_timeout = opts->timeout; | 505 | sbi->s_timeout = opts->timeout; |
315 | 506 | ||
@@ -342,11 +533,24 @@ static int exofs_fill_super(struct super_block *sb, void *data, int silent) | |||
342 | ret = -EINVAL; | 533 | ret = -EINVAL; |
343 | goto free_sbi; | 534 | goto free_sbi; |
344 | } | 535 | } |
536 | if (le32_to_cpu(fscb.s_version) != EXOFS_FSCB_VER) { | ||
537 | EXOFS_ERR("ERROR: Bad FSCB version expected-%d got-%d\n", | ||
538 | EXOFS_FSCB_VER, le32_to_cpu(fscb.s_version)); | ||
539 | ret = -EINVAL; | ||
540 | goto free_sbi; | ||
541 | } | ||
345 | 542 | ||
346 | /* start generation numbers from a random point */ | 543 | /* start generation numbers from a random point */ |
347 | get_random_bytes(&sbi->s_next_generation, sizeof(u32)); | 544 | get_random_bytes(&sbi->s_next_generation, sizeof(u32)); |
348 | spin_lock_init(&sbi->s_next_gen_lock); | 545 | spin_lock_init(&sbi->s_next_gen_lock); |
349 | 546 | ||
547 | table_count = le64_to_cpu(fscb.s_dev_table_count); | ||
548 | if (table_count) { | ||
549 | ret = exofs_read_lookup_dev_table(&sbi, table_count); | ||
550 | if (unlikely(ret)) | ||
551 | goto free_sbi; | ||
552 | } | ||
553 | |||
350 | /* set up operation vectors */ | 554 | /* set up operation vectors */ |
351 | sb->s_fs_info = sbi; | 555 | sb->s_fs_info = sbi; |
352 | sb->s_op = &exofs_sops; | 556 | sb->s_op = &exofs_sops; |
@@ -374,14 +578,14 @@ static int exofs_fill_super(struct super_block *sb, void *data, int silent) | |||
374 | goto free_sbi; | 578 | goto free_sbi; |
375 | } | 579 | } |
376 | 580 | ||
377 | _exofs_print_device("Mounting", opts->dev_name, sbi->s_dev, sbi->s_pid); | 581 | _exofs_print_device("Mounting", opts->dev_name, sbi->s_ods[0], |
582 | sbi->s_pid); | ||
378 | return 0; | 583 | return 0; |
379 | 584 | ||
380 | free_sbi: | 585 | free_sbi: |
381 | EXOFS_ERR("Unable to mount exofs on %s pid=0x%llx err=%d\n", | 586 | EXOFS_ERR("Unable to mount exofs on %s pid=0x%llx err=%d\n", |
382 | opts->dev_name, sbi->s_pid, ret); | 587 | opts->dev_name, sbi->s_pid, ret); |
383 | osduld_put_device(sbi->s_dev); /* NULL safe */ | 588 | exofs_free_sbi(sbi); |
384 | kfree(sbi); | ||
385 | return ret; | 589 | return ret; |
386 | } | 590 | } |
387 | 591 | ||