| @@ -232,6 +232,13 @@ struct thin_c { · 231 unmodified lines |
| 232 | 232 | struct bio_list deferred_bio_list; |
| 233 | 233 | struct bio_list retry_on_resume_list; |
| 234 | 234 | struct rb_root sort_bio_list; /* sorted list of deferred bios */ |
| 235 | + |
| 236 | + /* |
| 237 | + * Ensures the thin is not destroyed until the worker has finished |
| 238 | + * iterating the active_thins list. |
| 239 | + */ |
| 240 | + atomic_t refcount; |
| 241 | + struct completion can_destroy; |
| 235 | 242 | }; |
| 236 | 243 | |
| 237 | 244 | /*----------------------------------------------------------------*/ |
| @@ -1486,6 +1493,45 @@ static void process_thin_deferred_bios(struct thin_c *tc) · 1248 unmodified lines |
| 1486 | 1493 | blk_finish_plug(&plug); |
| 1487 | 1494 | } |
| 1488 | 1495 | |
| 1496 | +static void thin_get(struct thin_c *tc); |
| 1497 | +static void thin_put(struct thin_c *tc); |
| 1498 | + |
| 1499 | +/* |
| 1500 | + * We can't hold rcu_read_lock() around code that can block. So we |
| 1501 | + * find a thin with the rcu lock held; bump a refcount; then drop |
| 1502 | + * the lock. |
| 1503 | + */ |
| 1504 | +static struct thin_c *get_first_thin(struct pool *pool) |
| 1505 | +{ |
| 1506 | + struct thin_c *tc = NULL; |
| 1507 | + |
| 1508 | + rcu_read_lock(); |
| 1509 | + if (!list_empty(&pool->active_thins)) { |
| 1510 | + tc = list_entry_rcu(pool->active_thins.next, struct thin_c, list); |
| 1511 | + thin_get(tc); |
| 1512 | + } |
| 1513 | + rcu_read_unlock(); |
| 1514 | + |
| 1515 | + return tc; |
| 1516 | +} |
| 1517 | + |
| 1518 | +static struct thin_c *get_next_thin(struct pool *pool, struct thin_c *tc) |
| 1519 | +{ |
| 1520 | + struct thin_c *old_tc = tc; |
| 1521 | + |
| 1522 | + rcu_read_lock(); |
| 1523 | + list_for_each_entry_continue_rcu(tc, &pool->active_thins, list) { |
| 1524 | + thin_get(tc); |
| 1525 | + thin_put(old_tc); |
| 1526 | + rcu_read_unlock(); |
| 1527 | + return tc; |
| 1528 | + } |
| 1529 | + thin_put(old_tc); |
| 1530 | + rcu_read_unlock(); |
| 1531 | + |
| 1532 | + return NULL; |
| 1533 | +} |
| 1534 | + |
| 1489 | 1535 | static void process_deferred_bios(struct pool *pool) |
| 1490 | 1536 | { |
| 1491 | 1537 | unsigned long flags; |
| @@ -1493,10 +1539,11 @@ static void process_deferred_bios(struct pool *pool) · 1 unmodified line |
| 1493 | 1539 | struct bio_list bios; |
| 1494 | 1540 | struct thin_c *tc; |
| 1495 | 1541 | |
| 1496 | | − rcu_read_lock(); |
| 1497 | | − list_for_each_entry_rcu(tc, &pool->active_thins, list) |
| 1542 | + tc = get_first_thin(pool); |
| 1543 | + while (tc) { |
| 1498 | 1544 | process_thin_deferred_bios(tc); |
| 1499 | | − rcu_read_unlock(); |
| 1545 | + tc = get_next_thin(pool, tc); |
| 1546 | + } |
| 1500 | 1547 | |
| 1501 | 1548 | /* |
| 1502 | 1549 | * If there are any deferred flush bios, we must commit |
| @@ -1578,7 +1625,7 @@ static void noflush_work(struct thin_c *tc, void (*fn)(struct work_struct *)) · 75 unmodified lines |
| 1578 | 1625 | { |
| 1579 | 1626 | struct noflush_work w; |
| 1580 | 1627 | |
| 1581 | | − INIT_WORK(&w.worker, fn); |
| 1628 | + INIT_WORK_ONSTACK(&w.worker, fn); |
| 1582 | 1629 | w.tc = tc; |
| 1583 | 1630 | atomic_set(&w.complete, 0); |
| 1584 | 1631 | init_waitqueue_head(&w.wait); |
| @@ -3061,11 +3108,25 @@ static struct target_type pool_target = { · 1476 unmodified lines |
| 3061 | 3108 | /*---------------------------------------------------------------- |
| 3062 | 3109 | * Thin target methods |
| 3063 | 3110 | *--------------------------------------------------------------*/ |
| 3111 | +static void thin_get(struct thin_c *tc) |
| 3112 | +{ |
| 3113 | + atomic_inc(&tc->refcount); |
| 3114 | +} |
| 3115 | + |
| 3116 | +static void thin_put(struct thin_c *tc) |
| 3117 | +{ |
| 3118 | + if (atomic_dec_and_test(&tc->refcount)) |
| 3119 | + complete(&tc->can_destroy); |
| 3120 | +} |
| 3121 | + |
| 3064 | 3122 | static void thin_dtr(struct dm_target *ti) |
| 3065 | 3123 | { |
| 3066 | 3124 | struct thin_c *tc = ti->private; |
| 3067 | 3125 | unsigned long flags; |
| 3068 | 3126 | |
| 3127 | + thin_put(tc); |
| 3128 | + wait_for_completion(&tc->can_destroy); |
| 3129 | + |
| 3069 | 3130 | spin_lock_irqsave(&tc->pool->lock, flags); |
| 3070 | 3131 | list_del_rcu(&tc->list); |
| 3071 | 3132 | spin_unlock_irqrestore(&tc->pool->lock, flags); |
| @@ -3101,6 +3162,7 @@ static int thin_ctr(struct dm_target *ti, unsigned argc, char **argv) · 29 unmodified lines |
| 3101 | 3162 | struct thin_c *tc; |
| 3102 | 3163 | struct dm_dev *pool_dev, *origin_dev; |
| 3103 | 3164 | struct mapped_device *pool_md; |
| 3165 | + unsigned long flags; |
| 3104 | 3166 | |
| 3105 | 3167 | mutex_lock(&dm_thin_pool_table.mutex); |
| 3106 | 3168 | |
| @@ -3191,9 +3253,12 @@ static int thin_ctr(struct dm_target *ti, unsigned argc, char **argv) · 84 unmodified lines |
| 3191 | 3253 | |
| 3192 | 3254 | mutex_unlock(&dm_thin_pool_table.mutex); |
| 3193 | 3255 | |
| 3194 | | − spin_lock(&tc->pool->lock); |
| 3256 | + atomic_set(&tc->refcount, 1); |
| 3257 | + init_completion(&tc->can_destroy); |
| 3258 | + |
| 3259 | + spin_lock_irqsave(&tc->pool->lock, flags); |
| 3195 | 3260 | list_add_tail_rcu(&tc->list, &tc->pool->active_thins); |
| 3196 | | − spin_unlock(&tc->pool->lock); |
| 3261 | + spin_unlock_irqrestore(&tc->pool->lock, flags); |
| 3197 | 3262 | /* |
| 3198 | 3263 | * This synchronize_rcu() call is needed here otherwise we risk a |
| 3199 | 3264 | * wake_worker() call finding no bios to process (because the newly |