[Devel,RHEL7,COMMIT] ploop: add support for dm-crypted ploops

Submitted by Konstantin Khorenko on Aug. 20, 2016, 9:39 a.m.

Details

Message ID 201608200939.u7K9dLim001136@finist_cl7.x64_64.work.ct
State New
Series "ploop: add support for dm-crypted ploops"
Headers show

Commit Message

Konstantin Khorenko Aug. 20, 2016, 9:39 a.m.
The commit is pushed to "branch-rh7-3.10.0-327.28.2.vz7.17.x-ovz" and will appear at https://src.openvz.org/scm/ovz/vzkernel.git
after rh7-3.10.0-327.28.2.vz7.17.2
------>
commit bcd2b8d534909ed000f8697d7c1759d143a52624
Author: Andrey Ryabinin <aryabinin@virtuozzo.com>
Date:   Sat Aug 20 13:39:21 2016 +0400

    ploop: add support for dm-crypted ploops
    
    On dm-crypted ploop fs is mounted not on ploop but on dm-crypt device.
    Thus freeze/thaw used by some ploop's ioctl doesn't freeze/thaw filesystem.
    To fix that, we store pointer to dm-crypt block device inside ploop_device
    struct, and use it to freeze/thaw filesystem.
    
    https://jira.sw.ru/browse/PSBM-50858
    
    Signed-off-by: Andrey Ryabinin <aryabinin@virtuozzo.com>
    Acked-by: Maxim Patlasov <mpatlasov@virtuozzo.com>
    
    v2: by mpatlasov@: kernel panic fixed if someone (mistakenly) tries to "thaw"
    ploop device without "freeze" prior.
---
 drivers/block/ploop/dev.c       | 23 +++++++++++++++++++----
 drivers/block/ploop/io_direct.c | 12 ++++++++++++
 drivers/md/dm-crypt.c           |  8 +++++++-
 drivers/md/dm.c                 |  6 ++++++
 drivers/md/dm.h                 |  2 ++
 include/linux/ploop/ploop.h     | 32 ++++++++++++++++++++++++++++++++
 6 files changed, 78 insertions(+), 5 deletions(-)

Patch hide | download patch | download mbox

diff --git a/drivers/block/ploop/dev.c b/drivers/block/ploop/dev.c
index 8ed402f..921ec8b 100644
--- a/drivers/block/ploop/dev.c
+++ b/drivers/block/ploop/dev.c
@@ -3318,13 +3318,20 @@  void ploop_relax(struct ploop_device * plo)
 }
 
 /* search disk for first partition bdev with mounted fs and freeze it */
-static struct super_block *find_and_freeze_bdev(struct gendisk *disk,
+static struct super_block *find_and_freeze_bdev(struct ploop_device *plo,
 						struct block_device ** bdev_pp)
 {
 	struct super_block  * sb   = NULL;
 	struct block_device * bdev = NULL;
+	struct gendisk *disk = plo->disk;
 	int i;
 
+	bdev = ploop_get_dm_crypt_bdev(plo);
+	if (bdev) {
+		sb = freeze_bdev(bdev);
+		goto out;
+	}
+
 	for (i = 0; i <= (*bdev_pp)->bd_part_count; i++) {
 		bdev = bdget_disk(disk, i);
 		if (!bdev)
@@ -3339,6 +3346,7 @@  static struct super_block *find_and_freeze_bdev(struct gendisk *disk,
 		bdev = NULL;
 	}
 
+out:
 	if (IS_ERR(sb))
 		bdput(bdev);
 	else
@@ -3401,7 +3409,7 @@  static int ploop_snapshot(struct ploop_device * plo, unsigned long arg,
 		/* freeze_bdev() may trigger ploop_bd_full() */
 		plo->maintenance_type = PLOOP_MNTN_SNAPSHOT;
 		mutex_unlock(&plo->ctl_mutex);
-		sb = find_and_freeze_bdev(plo->disk, &bdev);
+		sb = find_and_freeze_bdev(plo, &bdev);
 		mutex_lock(&plo->ctl_mutex);
 		plo->maintenance_type = PLOOP_MNTN_OFF;
 		if (IS_ERR(sb)) {
@@ -4929,9 +4937,15 @@  static int ploop_freeze(struct ploop_device *plo, struct block_device *bdev)
 	if (plo->freeze_state == PLOOP_F_THAWING)
 		return -EBUSY;
 
+	if (plo->dm_crypt_bdev)
+		bdev = plo->dm_crypt_bdev;
+
+	bdgrab(bdev);
 	sb = freeze_bdev(bdev);
-	if (sb && IS_ERR(sb))
+	if (sb && IS_ERR(sb)) {
+		bdput(bdev);
 		return PTR_ERR(sb);
+	}
 
 	plo->frozen_bdev = bdev;
 	plo->freeze_state = PLOOP_F_FROZEN;
@@ -4941,7 +4955,7 @@  static int ploop_freeze(struct ploop_device *plo, struct block_device *bdev)
 static int ploop_thaw(struct ploop_device *plo)
 {
 	struct block_device *bdev = plo->frozen_bdev;
-	struct super_block *sb = bdev->bd_super;
+	struct super_block *sb = bdev ? bdev->bd_super : NULL;
 	int err;
 
 	if (!test_bit(PLOOP_S_RUNNING, &plo->state))
@@ -4958,6 +4972,7 @@  static int ploop_thaw(struct ploop_device *plo)
 
 	mutex_unlock(&plo->ctl_mutex);
 	err = thaw_bdev(bdev, sb);
+	bdput(bdev);
 	mutex_lock(&plo->ctl_mutex);
 
 	BUG_ON(plo->freeze_state != PLOOP_F_THAWING);
diff --git a/drivers/block/ploop/io_direct.c b/drivers/block/ploop/io_direct.c
index c12e3c8..6663964 100644
--- a/drivers/block/ploop/io_direct.c
+++ b/drivers/block/ploop/io_direct.c
@@ -871,13 +871,25 @@  static int dio_invalidate_cache(struct address_space * mapping,
 retry:
 	err = invalidate_inode_pages2(mapping);
 	if (err) {
+		struct ploop_device *plo = bdev->bd_disk->private_data;
+		struct block_device *dm_crypt_bdev;
+
 		printk("PLOOP: failed to invalidate page cache %d/%d\n", err, attempt2);
 		if (attempt2)
 			return err;
 		attempt2 = 1;
 
 		mutex_unlock(&mapping->host->i_mutex);
+
+		dm_crypt_bdev = ploop_get_dm_crypt_bdev(plo);
+		if (dm_crypt_bdev)
+			bdev = dm_crypt_bdev;
+		else
+			bdgrab(bdev);
+
 		thaw_bdev(bdev, freeze_bdev(bdev));
+		bdput(bdev);
+
 		mutex_lock(&mapping->host->i_mutex);
 		goto retry;
 	}
diff --git a/drivers/md/dm-crypt.c b/drivers/md/dm-crypt.c
index 56ca046..bcdd794 100644
--- a/drivers/md/dm-crypt.c
+++ b/drivers/md/dm-crypt.c
@@ -35,6 +35,8 @@ 
 
 #define DM_MSG_PREFIX "crypt"
 
+#include <linux/ploop/ploop.h>
+#include "dm.h"
 /*
  * context holding the current state of a multi-part conversion
  */
@@ -1645,8 +1647,10 @@  static void crypt_dtr(struct dm_target *ti)
 	if (cc->iv_gen_ops && cc->iv_gen_ops->dtr)
 		cc->iv_gen_ops->dtr(cc);
 
-	if (cc->dev)
+	if (cc->dev) {
+		ploop_set_dm_crypt_bdev(cc->dev->bdev, NULL);
 		dm_put_device(ti, cc->dev);
+	}
 
 	kzfree(cc->cipher);
 	kzfree(cc->cipher_string);
@@ -1915,6 +1919,8 @@  static int crypt_ctr(struct dm_target *ti, unsigned int argc, char **argv)
 		goto bad;
 	}
 
+	ploop_set_dm_crypt_bdev(cc->dev->bdev, dm_md_get_bdev(dm_table_get_md(ti->table)));
+
 	if (sscanf(argv[4], "%llu%c", &tmpll, &dummy) != 1) {
 		ti->error = "Invalid device sector";
 		goto bad;
diff --git a/drivers/md/dm.c b/drivers/md/dm.c
index 8732079..d9a24c9 100644
--- a/drivers/md/dm.c
+++ b/drivers/md/dm.c
@@ -310,6 +310,12 @@  unsigned dm_get_reserved_rq_based_ios(void)
 }
 EXPORT_SYMBOL_GPL(dm_get_reserved_rq_based_ios);
 
+struct block_device *dm_md_get_bdev(struct mapped_device *md)
+{
+	return md->bdev;
+}
+EXPORT_SYMBOL_GPL(dm_md_get_bdev);
+
 static int __init local_init(void)
 {
 	int r = -ENOMEM;
diff --git a/drivers/md/dm.h b/drivers/md/dm.h
index 6123c2b..815afa5 100644
--- a/drivers/md/dm.h
+++ b/drivers/md/dm.h
@@ -79,6 +79,8 @@  struct dm_md_mempools *dm_table_get_md_mempools(struct dm_table *t);
 
 int dm_queue_merge_is_compulsory(struct request_queue *q);
 
+struct block_device *dm_md_get_bdev(struct mapped_device *md);
+
 void dm_lock_md_type(struct mapped_device *md);
 void dm_unlock_md_type(struct mapped_device *md);
 void dm_set_md_type(struct mapped_device *md, unsigned type);
diff --git a/include/linux/ploop/ploop.h b/include/linux/ploop/ploop.h
index 8262a50..b8c480a 100644
--- a/include/linux/ploop/ploop.h
+++ b/include/linux/ploop/ploop.h
@@ -468,6 +468,7 @@  struct ploop_device
 
 	struct ploop_freeblks_desc *fbd;
 	struct ploop_pushbackup_desc *pbd;
+	struct block_device *dm_crypt_bdev;
 
 	unsigned long		locking_state; /* plo locked by userspace */
 };
@@ -634,6 +635,37 @@  static inline int ploop_req_delay_fua_possible(struct ploop_request *preq)
 	return preq->eng_state == PLOOP_E_DATA_WBI;
 }
 
+static inline void ploop_set_dm_crypt_bdev(struct block_device *ploop_bdev,
+				struct block_device *bdev)
+{
+	if (MAJOR(ploop_bdev->bd_dev) == PLOOP_DEVICE_MAJOR) {
+		struct ploop_device *plo = ploop_bdev->bd_disk->private_data;
+		mutex_lock(&plo->ctl_mutex);
+		plo->dm_crypt_bdev = bdev;
+		mutex_unlock(&plo->ctl_mutex);
+	}
+}
+
+static inline struct block_device *__ploop_get_dm_crypt_bdev(
+	struct ploop_device *plo)
+{
+	if (plo->dm_crypt_bdev)
+		bdgrab(plo->dm_crypt_bdev);
+
+	return plo->dm_crypt_bdev;
+}
+
+static inline struct block_device *ploop_get_dm_crypt_bdev(
+				struct ploop_device *plo)
+{
+	struct block_device *ret;
+
+	mutex_lock(&plo->ctl_mutex);
+	ret = __ploop_get_dm_crypt_bdev(plo);
+	mutex_unlock(&plo->ctl_mutex);
+	return ret;
+}
+
 static inline void ploop_req_set_error(struct ploop_request * preq, int err)
 {
 	if (!preq->error) {