dm.c (db8fef4fabe4a546ce74f80bff64fd43776e5912) dm.c (32a926da5a16c01a8213331e5764472ce2f14a8d)
1/*
2 * Copyright (C) 2001, 2002 Sistina Software (UK) Limited.
3 * Copyright (C) 2004-2008 Red Hat, Inc. All rights reserved.
4 *
5 * This file is released under the GPL.
6 */
7
8#include "dm.h"

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

1175 sprintf(md->disk->disk_name, "dm-%d", minor);
1176 add_disk(md->disk);
1177 format_dev_t(md->name, MKDEV(_major, minor));
1178
1179 md->wq = create_singlethread_workqueue("kdmflush");
1180 if (!md->wq)
1181 goto bad_thread;
1182
1/*
2 * Copyright (C) 2001, 2002 Sistina Software (UK) Limited.
3 * Copyright (C) 2004-2008 Red Hat, Inc. All rights reserved.
4 *
5 * This file is released under the GPL.
6 */
7
8#include "dm.h"

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

1175 sprintf(md->disk->disk_name, "dm-%d", minor);
1176 add_disk(md->disk);
1177 format_dev_t(md->name, MKDEV(_major, minor));
1178
1179 md->wq = create_singlethread_workqueue("kdmflush");
1180 if (!md->wq)
1181 goto bad_thread;
1182
1183 md->bdev = bdget_disk(md->disk, 0);
1184 if (!md->bdev)
1185 goto bad_bdev;
1186
1183 /* Populate the mapping, nobody knows we exist yet */
1184 spin_lock(&_minor_lock);
1185 old_md = idr_replace(&_minor_idr, md, minor);
1186 spin_unlock(&_minor_lock);
1187
1188 BUG_ON(old_md != MINOR_ALLOCED);
1189
1190 return md;
1191
1187 /* Populate the mapping, nobody knows we exist yet */
1188 spin_lock(&_minor_lock);
1189 old_md = idr_replace(&_minor_idr, md, minor);
1190 spin_unlock(&_minor_lock);
1191
1192 BUG_ON(old_md != MINOR_ALLOCED);
1193
1194 return md;
1195
1196bad_bdev:
1197 destroy_workqueue(md->wq);
1192bad_thread:
1193 put_disk(md->disk);
1194bad_disk:
1195 bioset_free(md->bs);
1196bad_no_bioset:
1197 mempool_destroy(md->tio_pool);
1198bad_tio_pool:
1199 mempool_destroy(md->io_pool);

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

1209}
1210
1211static void unlock_fs(struct mapped_device *md);
1212
1213static void free_dev(struct mapped_device *md)
1214{
1215 int minor = MINOR(disk_devt(md->disk));
1216
1198bad_thread:
1199 put_disk(md->disk);
1200bad_disk:
1201 bioset_free(md->bs);
1202bad_no_bioset:
1203 mempool_destroy(md->tio_pool);
1204bad_tio_pool:
1205 mempool_destroy(md->io_pool);

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

1215}
1216
1217static void unlock_fs(struct mapped_device *md);
1218
1219static void free_dev(struct mapped_device *md)
1220{
1221 int minor = MINOR(disk_devt(md->disk));
1222
1217 if (md->bdev) {
1218 unlock_fs(md);
1219 bdput(md->bdev);
1220 }
1223 unlock_fs(md);
1224 bdput(md->bdev);
1221 destroy_workqueue(md->wq);
1222 mempool_destroy(md->tio_pool);
1223 mempool_destroy(md->io_pool);
1224 bioset_free(md->bs);
1225 blk_integrity_unregister(md->disk);
1226 del_gendisk(md->disk);
1227 free_minor(minor);
1228

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

1272 size = dm_table_get_size(t);
1273
1274 /*
1275 * Wipe any geometry if the size of the table changed.
1276 */
1277 if (size != get_capacity(md->disk))
1278 memset(&md->geometry, 0, sizeof(md->geometry));
1279
1225 destroy_workqueue(md->wq);
1226 mempool_destroy(md->tio_pool);
1227 mempool_destroy(md->io_pool);
1228 bioset_free(md->bs);
1229 blk_integrity_unregister(md->disk);
1230 del_gendisk(md->disk);
1231 free_minor(minor);
1232

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

1276 size = dm_table_get_size(t);
1277
1278 /*
1279 * Wipe any geometry if the size of the table changed.
1280 */
1281 if (size != get_capacity(md->disk))
1282 memset(&md->geometry, 0, sizeof(md->geometry));
1283
1280 if (md->bdev)
1281 __set_size(md, size);
1284 __set_size(md, size);
1282
1283 if (!size) {
1284 dm_table_destroy(t);
1285 return 0;
1286 }
1287
1288 dm_table_event_callback(t, event_callback, md);
1289

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

1515 int r = -EINVAL;
1516
1517 mutex_lock(&md->suspend_lock);
1518
1519 /* device must be suspended */
1520 if (!dm_suspended(md))
1521 goto out;
1522
1285
1286 if (!size) {
1287 dm_table_destroy(t);
1288 return 0;
1289 }
1290
1291 dm_table_event_callback(t, event_callback, md);
1292

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

1518 int r = -EINVAL;
1519
1520 mutex_lock(&md->suspend_lock);
1521
1522 /* device must be suspended */
1523 if (!dm_suspended(md))
1524 goto out;
1525
1523 /* without bdev, the device size cannot be changed */
1524 if (!md->bdev)
1525 if (get_capacity(md->disk) != dm_table_get_size(table))
1526 goto out;
1527
1528 __unbind(md);
1529 r = __bind(md, table);
1530
1531out:
1532 mutex_unlock(&md->suspend_lock);
1533 return r;
1534}
1535

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

1547 if (IS_ERR(md->frozen_sb)) {
1548 r = PTR_ERR(md->frozen_sb);
1549 md->frozen_sb = NULL;
1550 return r;
1551 }
1552
1553 set_bit(DMF_FROZEN, &md->flags);
1554
1526 __unbind(md);
1527 r = __bind(md, table);
1528
1529out:
1530 mutex_unlock(&md->suspend_lock);
1531 return r;
1532}
1533

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

1545 if (IS_ERR(md->frozen_sb)) {
1546 r = PTR_ERR(md->frozen_sb);
1547 md->frozen_sb = NULL;
1548 return r;
1549 }
1550
1551 set_bit(DMF_FROZEN, &md->flags);
1552
1555 /* don't bdput right now, we don't want the bdev
1556 * to go away while it is locked.
1557 */
1558 return 0;
1559}
1560
1561static void unlock_fs(struct mapped_device *md)
1562{
1563 if (!test_bit(DMF_FROZEN, &md->flags))
1564 return;
1565

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

1596 * This flag is cleared before dm_suspend returns.
1597 */
1598 if (noflush)
1599 set_bit(DMF_NOFLUSH_SUSPENDING, &md->flags);
1600
1601 /* This does not get reverted if there's an error later. */
1602 dm_table_presuspend_targets(map);
1603
1553 return 0;
1554}
1555
1556static void unlock_fs(struct mapped_device *md)
1557{
1558 if (!test_bit(DMF_FROZEN, &md->flags))
1559 return;
1560

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

1591 * This flag is cleared before dm_suspend returns.
1592 */
1593 if (noflush)
1594 set_bit(DMF_NOFLUSH_SUSPENDING, &md->flags);
1595
1596 /* This does not get reverted if there's an error later. */
1597 dm_table_presuspend_targets(map);
1598
1604 /* bdget() can stall if the pending I/Os are not flushed */
1605 if (!noflush) {
1606 md->bdev = bdget_disk(md->disk, 0);
1607 if (!md->bdev) {
1608 DMWARN("bdget failed in dm_suspend");
1609 r = -ENOMEM;
1599 /*
1600 * Flush I/O to the device. noflush supersedes do_lockfs,
1601 * because lock_fs() needs to flush I/Os.
1602 */
1603 if (!noflush && do_lockfs) {
1604 r = lock_fs(md);
1605 if (r)
1610 goto out;
1606 goto out;
1611 }
1612
1613 /*
1614 * Flush I/O to the device. noflush supersedes do_lockfs,
1615 * because lock_fs() needs to flush I/Os.
1616 */
1617 if (do_lockfs) {
1618 r = lock_fs(md);
1619 if (r)
1620 goto out;
1621 }
1622 }
1623
1624 /*
1625 * Here we must make sure that no processes are submitting requests
1626 * to target drivers i.e. no one may be executing
1627 * __split_and_process_bio. This is called from dm_request and
1628 * dm_wq_work.
1629 *

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

1670 * requests are being added to md->deferred list.
1671 */
1672
1673 dm_table_postsuspend_targets(map);
1674
1675 set_bit(DMF_SUSPENDED, &md->flags);
1676
1677out:
1607 }
1608
1609 /*
1610 * Here we must make sure that no processes are submitting requests
1611 * to target drivers i.e. no one may be executing
1612 * __split_and_process_bio. This is called from dm_request and
1613 * dm_wq_work.
1614 *

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

1655 * requests are being added to md->deferred list.
1656 */
1657
1658 dm_table_postsuspend_targets(map);
1659
1660 set_bit(DMF_SUSPENDED, &md->flags);
1661
1662out:
1678 if (r && md->bdev) {
1679 bdput(md->bdev);
1680 md->bdev = NULL;
1681 }
1682
1683 dm_table_put(map);
1684
1685out_unlock:
1686 mutex_unlock(&md->suspend_lock);
1687 return r;
1688}
1689
1690int dm_resume(struct mapped_device *md)

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

1703 r = dm_table_resume_targets(map);
1704 if (r)
1705 goto out;
1706
1707 dm_queue_flush(md);
1708
1709 unlock_fs(md);
1710
1663 dm_table_put(map);
1664
1665out_unlock:
1666 mutex_unlock(&md->suspend_lock);
1667 return r;
1668}
1669
1670int dm_resume(struct mapped_device *md)

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

1683 r = dm_table_resume_targets(map);
1684 if (r)
1685 goto out;
1686
1687 dm_queue_flush(md);
1688
1689 unlock_fs(md);
1690
1711 if (md->bdev) {
1712 bdput(md->bdev);
1713 md->bdev = NULL;
1714 }
1715
1716 clear_bit(DMF_SUSPENDED, &md->flags);
1717
1718 dm_table_unplug_all(map);
1719
1720 dm_kobject_uevent(md);
1721
1722 r = 0;
1723

--- 111 unchanged lines hidden --- 		1691 clear_bit(DMF_SUSPENDED, &md->flags);
1692
1693 dm_table_unplug_all(map);
1694
1695 dm_kobject_uevent(md);
1696
1697 r = 0;
1698

--- 111 unchanged lines hidden ---