super.c (028ddcac477b691dd9205c92f991cc15259d033e) super.c (abcc0cbd49283fccd20420e86416b2475b00819c)
1// SPDX-License-Identifier: GPL-2.0
2/*
3 * bcache setup/teardown code, and some metadata io - read a superblock and
4 * figure out what to do with it.
5 *
6 * Copyright 2010, 2011 Kent Overstreet <kent.overstreet@gmail.com>
7 * Copyright 2012 Google, Inc.
8 */

--- 2434 unchanged lines hidden (view full) ---

2443}
2444
2445struct async_reg_args {
2446 struct delayed_work reg_work;
2447 char *path;
2448 struct cache_sb *sb;
2449 struct cache_sb_disk *sb_disk;
2450 struct block_device *bdev;
1// SPDX-License-Identifier: GPL-2.0
2/*
3 * bcache setup/teardown code, and some metadata io - read a superblock and
4 * figure out what to do with it.
5 *
6 * Copyright 2010, 2011 Kent Overstreet <kent.overstreet@gmail.com>
7 * Copyright 2012 Google, Inc.
8 */

--- 2434 unchanged lines hidden (view full) ---

2443}
2444
2445struct async_reg_args {
2446 struct delayed_work reg_work;
2447 char *path;
2448 struct cache_sb *sb;
2449 struct cache_sb_disk *sb_disk;
2450 struct block_device *bdev;
2451 void *holder;
2451};
2452
2453static void register_bdev_worker(struct work_struct *work)
2454{
2455 int fail = false;
2456 struct async_reg_args *args =
2457 container_of(work, struct async_reg_args, reg_work.work);
2452};
2453
2454static void register_bdev_worker(struct work_struct *work)
2455{
2456 int fail = false;
2457 struct async_reg_args *args =
2458 container_of(work, struct async_reg_args, reg_work.work);
2458 struct cached_dev *dc;
2459
2459
2460 dc = kzalloc(sizeof(*dc), GFP_KERNEL);
2461 if (!dc) {
2462 fail = true;
2463 put_page(virt_to_page(args->sb_disk));
2464 blkdev_put(args->bdev, bcache_kobj);
2465 goto out;
2466 }
2467
2468 mutex_lock(&bch_register_lock);
2460 mutex_lock(&bch_register_lock);
2469 if (register_bdev(args->sb, args->sb_disk, args->bdev, dc) < 0)
2461 if (register_bdev(args->sb, args->sb_disk, args->bdev, args->holder)
2462 < 0)
2470 fail = true;
2471 mutex_unlock(&bch_register_lock);
2472
2463 fail = true;
2464 mutex_unlock(&bch_register_lock);
2465
2473out:
2474 if (fail)
2475 pr_info("error %s: fail to register backing device\n",
2476 args->path);
2477 kfree(args->sb);
2478 kfree(args->path);
2479 kfree(args);
2480 module_put(THIS_MODULE);
2481}
2482
2483static void register_cache_worker(struct work_struct *work)
2484{
2485 int fail = false;
2486 struct async_reg_args *args =
2487 container_of(work, struct async_reg_args, reg_work.work);
2466 if (fail)
2467 pr_info("error %s: fail to register backing device\n",
2468 args->path);
2469 kfree(args->sb);
2470 kfree(args->path);
2471 kfree(args);
2472 module_put(THIS_MODULE);
2473}
2474
2475static void register_cache_worker(struct work_struct *work)
2476{
2477 int fail = false;
2478 struct async_reg_args *args =
2479 container_of(work, struct async_reg_args, reg_work.work);
2488 struct cache *ca;
2489
2480
2490 ca = kzalloc(sizeof(*ca), GFP_KERNEL);
2491 if (!ca) {
2492 fail = true;
2493 put_page(virt_to_page(args->sb_disk));
2494 blkdev_put(args->bdev, bcache_kobj);
2495 goto out;
2496 }
2497
2498 /* blkdev_put() will be called in bch_cache_release() */
2481 /* blkdev_put() will be called in bch_cache_release() */
2499 if (register_cache(args->sb, args->sb_disk, args->bdev, ca) != 0)
2482 if (register_cache(args->sb, args->sb_disk, args->bdev, args->holder))
2500 fail = true;
2501
2483 fail = true;
2484
2502out:
2503 if (fail)
2504 pr_info("error %s: fail to register cache device\n",
2505 args->path);
2506 kfree(args->sb);
2507 kfree(args->path);
2508 kfree(args);
2509 module_put(THIS_MODULE);
2510}

--- 4 unchanged lines hidden (view full) ---

2515 INIT_DELAYED_WORK(&args->reg_work, register_bdev_worker);
2516 else
2517 INIT_DELAYED_WORK(&args->reg_work, register_cache_worker);
2518
2519 /* 10 jiffies is enough for a delay */
2520 queue_delayed_work(system_wq, &args->reg_work, 10);
2521}
2522
2485 if (fail)
2486 pr_info("error %s: fail to register cache device\n",
2487 args->path);
2488 kfree(args->sb);
2489 kfree(args->path);
2490 kfree(args);
2491 module_put(THIS_MODULE);
2492}

--- 4 unchanged lines hidden (view full) ---

2497 INIT_DELAYED_WORK(&args->reg_work, register_bdev_worker);
2498 else
2499 INIT_DELAYED_WORK(&args->reg_work, register_cache_worker);
2500
2501 /* 10 jiffies is enough for a delay */
2502 queue_delayed_work(system_wq, &args->reg_work, 10);
2503}
2504
2505static void *alloc_holder_object(struct cache_sb *sb)
2506{
2507 if (SB_IS_BDEV(sb))
2508 return kzalloc(sizeof(struct cached_dev), GFP_KERNEL);
2509 return kzalloc(sizeof(struct cache), GFP_KERNEL);
2510}
2511
2523static ssize_t register_bcache(struct kobject *k, struct kobj_attribute *attr,
2524 const char *buffer, size_t size)
2525{
2526 const char *err;
2527 char *path = NULL;
2528 struct cache_sb *sb;
2529 struct cache_sb_disk *sb_disk;
2530 struct block_device *bdev;
2512static ssize_t register_bcache(struct kobject *k, struct kobj_attribute *attr,
2513 const char *buffer, size_t size)
2514{
2515 const char *err;
2516 char *path = NULL;
2517 struct cache_sb *sb;
2518 struct cache_sb_disk *sb_disk;
2519 struct block_device *bdev;
2520 void *holder;
2531 ssize_t ret;
2532 bool async_registration = false;
2533
2534#ifdef CONFIG_BCACHE_ASYNC_REGISTRATION
2535 async_registration = true;
2536#endif
2537
2538 ret = -EBUSY;

--- 41 unchanged lines hidden (view full) ---

2580 err = "failed to set blocksize";
2581 if (set_blocksize(bdev, 4096))
2582 goto out_blkdev_put;
2583
2584 err = read_super(sb, bdev, &sb_disk);
2585 if (err)
2586 goto out_blkdev_put;
2587
2521 ssize_t ret;
2522 bool async_registration = false;
2523
2524#ifdef CONFIG_BCACHE_ASYNC_REGISTRATION
2525 async_registration = true;
2526#endif
2527
2528 ret = -EBUSY;

--- 41 unchanged lines hidden (view full) ---

2570 err = "failed to set blocksize";
2571 if (set_blocksize(bdev, 4096))
2572 goto out_blkdev_put;
2573
2574 err = read_super(sb, bdev, &sb_disk);
2575 if (err)
2576 goto out_blkdev_put;
2577
2578 holder = alloc_holder_object(sb);
2579 if (!holder) {
2580 ret = -ENOMEM;
2581 err = "cannot allocate memory";
2582 goto out_put_sb_page;
2583 }
2584
2588 err = "failed to register device";
2589
2590 if (async_registration) {
2591 /* register in asynchronous way */
2592 struct async_reg_args *args =
2593 kzalloc(sizeof(struct async_reg_args), GFP_KERNEL);
2594
2595 if (!args) {
2596 ret = -ENOMEM;
2597 err = "cannot allocate memory";
2585 err = "failed to register device";
2586
2587 if (async_registration) {
2588 /* register in asynchronous way */
2589 struct async_reg_args *args =
2590 kzalloc(sizeof(struct async_reg_args), GFP_KERNEL);
2591
2592 if (!args) {
2593 ret = -ENOMEM;
2594 err = "cannot allocate memory";
2598 goto out_put_sb_page;
2595 goto out_free_holder;
2599 }
2600
2601 args->path = path;
2602 args->sb = sb;
2603 args->sb_disk = sb_disk;
2604 args->bdev = bdev;
2596 }
2597
2598 args->path = path;
2599 args->sb = sb;
2600 args->sb_disk = sb_disk;
2601 args->bdev = bdev;
2602 args->holder = holder;
2605 register_device_async(args);
2606 /* No wait and returns to user space */
2607 goto async_done;
2608 }
2609
2610 if (SB_IS_BDEV(sb)) {
2603 register_device_async(args);
2604 /* No wait and returns to user space */
2605 goto async_done;
2606 }
2607
2608 if (SB_IS_BDEV(sb)) {
2611 struct cached_dev *dc = kzalloc(sizeof(*dc), GFP_KERNEL);
2612
2613 if (!dc) {
2614 ret = -ENOMEM;
2615 err = "cannot allocate memory";
2616 goto out_put_sb_page;
2617 }
2618
2619 mutex_lock(&bch_register_lock);
2609 mutex_lock(&bch_register_lock);
2620 ret = register_bdev(sb, sb_disk, bdev, dc);
2610 ret = register_bdev(sb, sb_disk, bdev, holder);
2621 mutex_unlock(&bch_register_lock);
2622 /* blkdev_put() will be called in cached_dev_free() */
2623 if (ret < 0)
2624 goto out_free_sb;
2625 } else {
2611 mutex_unlock(&bch_register_lock);
2612 /* blkdev_put() will be called in cached_dev_free() */
2613 if (ret < 0)
2614 goto out_free_sb;
2615 } else {
2626 struct cache *ca = kzalloc(sizeof(*ca), GFP_KERNEL);
2627
2628 if (!ca) {
2629 ret = -ENOMEM;
2630 err = "cannot allocate memory";
2631 goto out_put_sb_page;
2632 }
2633
2634 /* blkdev_put() will be called in bch_cache_release() */
2616 /* blkdev_put() will be called in bch_cache_release() */
2635 ret = register_cache(sb, sb_disk, bdev, ca);
2617 ret = register_cache(sb, sb_disk, bdev, holder);
2636 if (ret)
2637 goto out_free_sb;
2638 }
2639
2640done:
2641 kfree(sb);
2642 kfree(path);
2643 module_put(THIS_MODULE);
2644async_done:
2645 return size;
2646
2618 if (ret)
2619 goto out_free_sb;
2620 }
2621
2622done:
2623 kfree(sb);
2624 kfree(path);
2625 module_put(THIS_MODULE);
2626async_done:
2627 return size;
2628
2629out_free_holder:
2630 kfree(holder);
2647out_put_sb_page:
2648 put_page(virt_to_page(sb_disk));
2649out_blkdev_put:
2650 blkdev_put(bdev, register_bcache);
2651out_free_sb:
2652 kfree(sb);
2653out_free_path:
2654 kfree(path);

--- 283 unchanged lines hidden --- 		2631out_put_sb_page:
2632 put_page(virt_to_page(sb_disk));
2633out_blkdev_put:
2634 blkdev_put(bdev, register_bcache);
2635out_free_sb:
2636 kfree(sb);
2637out_free_path:
2638 kfree(path);

--- 283 unchanged lines hidden ---