From patchwork Wed Mar 4 02:51:12 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Light Hsieh X-Patchwork-Id: 11419183 Return-Path: Received: from mail.kernel.org (pdx-korg-mail-1.web.codeaurora.org [172.30.200.123]) by pdx-korg-patchwork-2.web.codeaurora.org (Postfix) with ESMTP id 7A3F71580 for ; Wed, 4 Mar 2020 02:51:25 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 4938521775 for ; Wed, 4 Mar 2020 02:51:25 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (1024-bit key) header.d=mediatek.com header.i=@mediatek.com header.b="jNtdJVSY" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S2387505AbgCDCvY (ORCPT ); Tue, 3 Mar 2020 21:51:24 -0500 Received: from mailgw02.mediatek.com ([210.61.82.184]:20785 "EHLO mailgw02.mediatek.com" rhost-flags-OK-FAIL-OK-FAIL) by vger.kernel.org with ESMTP id S2387432AbgCDCvX (ORCPT ); Tue, 3 Mar 2020 21:51:23 -0500 X-UUID: 1d0d1469fb8b47a49bc6725e0a1af2c9-20200304 DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=mediatek.com; s=dk; h=Content-Transfer-Encoding:Content-Type:MIME-Version:References:In-Reply-To:Message-ID:Date:Subject:CC:To:From; bh=qsn5ZtkxofEPhSlSyo8Sta1tKWHmr79ZpPp6bUCSBTY=; b=jNtdJVSYBkAI8+TtGQCRgIhfuGCDAPyITAP65ot2ehtNMcxy22BcPT1ZCjfF/OJ4NUAYWwFBPMMPeowiziqfuOmHXKl/68GruooxFHB47fGKjxOBJtMuDM8ghqXegKeo3KiBYFDGnIfA3wqPXXDRUIk/M4IZeE0GVuO4osHcwR0=; X-UUID: 1d0d1469fb8b47a49bc6725e0a1af2c9-20200304 Received: from mtkexhb01.mediatek.inc [(172.21.101.102)] by mailgw02.mediatek.com (envelope-from ) (Cellopoint E-mail Firewall v4.1.10 Build 0809 with TLS) with ESMTP id 62745562; Wed, 04 Mar 2020 10:51:16 +0800 Received: from mtkcas08.mediatek.inc (172.21.101.126) by mtkmbs05n2.mediatek.inc (172.21.101.140) with Microsoft SMTP Server (TLS) id 15.0.1395.4; Wed, 4 Mar 2020 10:50:15 +0800 Received: from mtkswgap22.mediatek.inc (172.21.77.33) by mtkcas08.mediatek.inc (172.21.101.73) with Microsoft SMTP Server id 15.0.1395.4 via Frontend Transport; Wed, 4 Mar 2020 10:51:54 +0800 From: To: CC: , , , , , , Light Hsieh Subject: [PATCH v1 1/3] mmc: record wp_grp_size and boot_wp_status Date: Wed, 4 Mar 2020 10:51:12 +0800 Message-ID: <1583290274-5525-2-git-send-email-light.hsieh@mediatek.com> X-Mailer: git-send-email 1.8.1.1.dirty In-Reply-To: <1583290274-5525-1-git-send-email-light.hsieh@mediatek.com> References: <1583290274-5525-1-git-send-email-light.hsieh@mediatek.com> MIME-Version: 1.0 X-MTK: N Sender: linux-block-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-block@vger.kernel.org From: Light Hsieh 1. record wp_grp_size (write-protection group size) in struct mmc_csd and struct mmc_card. 2. record boot_wp_status (boot partition write-protection status) in struct mmc_ext_csd. Signed-off-by: Light Hsieh --- drivers/mmc/core/mmc.c | 16 ++++++++++++++++ include/linux/mmc/card.h | 3 +++ include/linux/mmc/mmc.h | 1 + 3 files changed, 20 insertions(+) diff --git a/drivers/mmc/core/mmc.c b/drivers/mmc/core/mmc.c index f6912de..77305c8 100644 --- a/drivers/mmc/core/mmc.c +++ b/drivers/mmc/core/mmc.c @@ -127,6 +127,16 @@ static void mmc_set_erase_size(struct mmc_card *card) mmc_init_erase(card); } +static void mmc_set_wp_grp_size(struct mmc_card *card) +{ + if (card->ext_csd.erase_group_def & 1) + card->wp_grp_size = card->ext_csd.hc_erase_size * + card->ext_csd.raw_hc_erase_gap_size; + else + card->wp_grp_size = card->csd.erase_size * + (card->csd.wp_grp_size + 1); +} + /* * Given a 128-bit response, decode to our card CSD structure. */ @@ -177,6 +187,7 @@ static int mmc_decode_csd(struct mmc_card *card) b = UNSTUFF_BITS(resp, 37, 5); csd->erase_size = (a + 1) * (b + 1); csd->erase_size <<= csd->write_blkbits - 9; + csd->wp_grp_size = UNSTUFF_BITS(resp, 32, 5); } return 0; @@ -496,6 +507,8 @@ static int mmc_decode_ext_csd(struct mmc_card *card, u8 *ext_csd) card->ext_csd.boot_ro_lock = ext_csd[EXT_CSD_BOOT_WP]; card->ext_csd.boot_ro_lockable = true; + card->ext_csd.boot_wp_status = ext_csd[EXT_CSD_BOOT_WP_STATUS]; + /* Save power class values */ card->ext_csd.raw_pwr_cl_52_195 = ext_csd[EXT_CSD_PWR_CL_52_195]; @@ -769,6 +782,7 @@ static int mmc_compare_ext_csds(struct mmc_card *card, unsigned bus_width) card->raw_csd[2], card->raw_csd[3]); MMC_DEV_ATTR(date, "%02d/%04d\n", card->cid.month, card->cid.year); MMC_DEV_ATTR(erase_size, "%u\n", card->erase_size << 9); +MMC_DEV_ATTR(wp_grp_size, "%u\n", card->wp_grp_size << 9); MMC_DEV_ATTR(preferred_erase_size, "%u\n", card->pref_erase << 9); MMC_DEV_ATTR(ffu_capable, "%d\n", card->ext_csd.ffu_capable); MMC_DEV_ATTR(hwrev, "0x%x\n", card->cid.hwrev); @@ -828,6 +842,7 @@ static ssize_t mmc_dsr_show(struct device *dev, &dev_attr_csd.attr, &dev_attr_date.attr, &dev_attr_erase_size.attr, + &dev_attr_wp_grp_size.attr, &dev_attr_preferred_erase_size.attr, &dev_attr_fwrev.attr, &dev_attr_ffu_capable.attr, @@ -1709,6 +1724,7 @@ static int mmc_init_card(struct mmc_host *host, u32 ocr, mmc_set_erase_size(card); } } + mmc_set_wp_grp_size(card); /* * Ensure eMMC user default partition is enabled diff --git a/include/linux/mmc/card.h b/include/linux/mmc/card.h index cf3780a..0139461 100644 --- a/include/linux/mmc/card.h +++ b/include/linux/mmc/card.h @@ -32,6 +32,7 @@ struct mmc_csd { unsigned int r2w_factor; unsigned int max_dtr; unsigned int erase_size; /* In sectors */ + unsigned int wp_grp_size; unsigned int read_blkbits; unsigned int write_blkbits; unsigned int capacity; @@ -94,6 +95,7 @@ struct mmc_ext_csd { u8 raw_exception_status; /* 54 */ u8 raw_partition_support; /* 160 */ u8 raw_rpmb_size_mult; /* 168 */ + u8 boot_wp_status; /* 174 */ u8 raw_erased_mem_count; /* 181 */ u8 strobe_support; /* 184 */ u8 raw_ext_csd_structure; /* 194 */ @@ -278,6 +280,7 @@ struct mmc_card { unsigned int eg_boundary; /* don't cross erase-group boundaries */ unsigned int erase_arg; /* erase / trim / discard */ u8 erased_byte; /* value of erased bytes */ + unsigned int wp_grp_size; /* write group size(sectors) */ u32 raw_cid[4]; /* raw card CID */ u32 raw_csd[4]; /* raw card CSD */ diff --git a/include/linux/mmc/mmc.h b/include/linux/mmc/mmc.h index 897a87c..2c9d988 100644 --- a/include/linux/mmc/mmc.h +++ b/include/linux/mmc/mmc.h @@ -259,6 +259,7 @@ static inline bool mmc_op_multi(u32 opcode) #define EXT_CSD_RPMB_MULT 168 /* RO */ #define EXT_CSD_FW_CONFIG 169 /* R/W */ #define EXT_CSD_BOOT_WP 173 /* R/W */ +#define EXT_CSD_BOOT_WP_STATUS 174 /* RO */ #define EXT_CSD_ERASE_GROUP_DEF 175 /* R/W */ #define EXT_CSD_PART_CONFIG 179 /* R/W */ #define EXT_CSD_ERASED_MEM_CONT 181 /* RO */ From patchwork Wed Mar 4 02:51:13 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Light Hsieh X-Patchwork-Id: 11419187 Return-Path: Received: from mail.kernel.org (pdx-korg-mail-1.web.codeaurora.org [172.30.200.123]) by pdx-korg-patchwork-2.web.codeaurora.org (Postfix) with ESMTP id 4E43392A for ; Wed, 4 Mar 2020 02:51:32 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 1DCD3214DB for ; Wed, 4 Mar 2020 02:51:32 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (1024-bit key) header.d=mediatek.com header.i=@mediatek.com header.b="UjMA+0zu" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S2387619AbgCDCvZ (ORCPT ); Tue, 3 Mar 2020 21:51:25 -0500 Received: from mailgw02.mediatek.com ([210.61.82.184]:61552 "EHLO mailgw02.mediatek.com" rhost-flags-OK-FAIL-OK-FAIL) by vger.kernel.org with ESMTP id S2387454AbgCDCvY (ORCPT ); Tue, 3 Mar 2020 21:51:24 -0500 X-UUID: c2f9ab2ea42f4828b42726c149d7e6df-20200304 DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=mediatek.com; s=dk; h=Content-Transfer-Encoding:Content-Type:MIME-Version:References:In-Reply-To:Message-ID:Date:Subject:CC:To:From; bh=+OjRhnFwB7N+qUCZlu/luvxZ8XB1cxUBw5E13DY1Vig=; b=UjMA+0zuL7/d0zoo6K0/y9VeRkWGk6ceEL9MLPlqLaSOH7UIPBtxKaJMjy0e9/OkAneMjoH3IzputMSYs2AfUpSgrxsY2RMA/7yHG4/9CanHBOqLXIM0cW3bYba1YRzp4aLoB/xg4IBPOok00FHKW1FU8ATmxPmFxy22lViUnmE=; X-UUID: c2f9ab2ea42f4828b42726c149d7e6df-20200304 Received: from mtkcas06.mediatek.inc [(172.21.101.30)] by mailgw02.mediatek.com (envelope-from ) (Cellopoint E-mail Firewall v4.1.10 Build 0809 with TLS) with ESMTP id 1264542302; Wed, 04 Mar 2020 10:51:17 +0800 Received: from mtkcas08.mediatek.inc (172.21.101.126) by mtkmbs02n1.mediatek.inc (172.21.101.77) with Microsoft SMTP Server (TLS) id 15.0.1395.4; Wed, 4 Mar 2020 10:49:14 +0800 Received: from mtkswgap22.mediatek.inc (172.21.77.33) by mtkcas08.mediatek.inc (172.21.101.73) with Microsoft SMTP Server id 15.0.1395.4 via Frontend Transport; Wed, 4 Mar 2020 10:51:55 +0800 From: To: CC: , , , , , , Light Hsieh Subject: [PATCH v1 2/3] mmc: check write-protection status during BLKROSET ioctl Date: Wed, 4 Mar 2020 10:51:13 +0800 Message-ID: <1583290274-5525-3-git-send-email-light.hsieh@mediatek.com> X-Mailer: git-send-email 1.8.1.1.dirty In-Reply-To: <1583290274-5525-1-git-send-email-light.hsieh@mediatek.com> References: <1583290274-5525-1-git-send-email-light.hsieh@mediatek.com> MIME-Version: 1.0 X-MTK: N Sender: linux-block-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-block@vger.kernel.org From: Light Hsieh Since MMC layer does not implement BLKROSET ioctl, BLKROSET ioctl that tries to clear ro attribute of an mmcblk device will get -EINVAL from __blkdev_driver_ioctl(). blkdev_roset() regard -EINVAL as "unrecogized ioctl" and then clear the ro attribute un-conditionally. However, when eMMC write-protection (power-on, temporarily write, or permanent) is enabled in some area, this un-conditional clear of ro will lead to issue. From user's view, eMMC device is writable since ro is not set. But write operation sent to eMMC will get write-protection error. Since most write are asynchronus buffered write, such write-protection error won't be delivered to user who send the write operation. This patch implement BLKROSET in MMC layer. 1. For SD device, 0 is retured. 2. For setting ro to eMMC area, 0 is returned without any other check. 2. For clearing ro to eMMC area, write-proetction status is checked: 2a. For boot0 or boot1 partition, boot_wp_status get from EXTCSD is checked. -EACCES is returned when the target boot partition is write-protected; 0 is returned otherwise. 2b. For user area partition, one or more MMC_SEND_WRITE_PROT_TYPE commands are sent to get/check write-protection status of target address range. -EACCES is returned when target address range is fully/partially write-protected; 0 is returned otherwise. With the above implementation and correct ioctl parameters, return value of __blkdev_driver_ioctl() will be 0 or -EACCES. blkdev_roset() can continue to clear ro attribute when return value is 0, which means whole target eMMC address range is not write-protected. Signed-off-by: Light Hsieh --- block/ioctl.c | 2 +- drivers/mmc/core/block.c | 216 +++++++++++++++++++++++++++++++++++++++++++++++ include/linux/mmc/mmc.h | 1 + 3 files changed, 218 insertions(+), 1 deletion(-) diff --git a/block/ioctl.c b/block/ioctl.c index 127194b..af047a0 100644 --- a/block/ioctl.c +++ b/block/ioctl.c @@ -485,7 +485,7 @@ static int blkdev_roset(struct block_device *bdev, fmode_t mode, return -EACCES; ret = __blkdev_driver_ioctl(bdev, mode, cmd, arg); - if (!is_unrecognized_ioctl(ret)) + if (ret && !is_unrecognized_ioctl(ret)) return ret; if (get_user(n, (int __user *)arg)) return -EFAULT; diff --git a/drivers/mmc/core/block.c b/drivers/mmc/core/block.c index 663d879..ee85abf 100644 --- a/drivers/mmc/core/block.c +++ b/drivers/mmc/core/block.c @@ -778,6 +778,220 @@ static int mmc_blk_check_blkdev(struct block_device *bdev) return 0; } +#define MMC_BLK_NO_WP 0 +#define MMC_BLK_PARTIALLY_WP 1 +#define MMC_BLK_FULLY_WP 2 + +static int mmc_blk_check_disk_range_wp(struct gendisk *disk, + sector_t part_start, sector_t part_nr_sects) +{ + struct mmc_command cmd = {0}; + struct mmc_request mrq = {NULL}; + struct mmc_data data = {0}; + struct mmc_blk_data *md; + struct mmc_card *card; + struct scatterlist sg; + unsigned char *buf = NULL, status; + sector_t start, end, quot; + sector_t wp_grp_rem, wp_grp_total, wp_grp_found, status_query_cnt; + unsigned int remain; + int err = 0, i, j, k; + u8 boot_wp_status = 0; + + md = mmc_blk_get(disk); + if (!md) + return -EINVAL; + + if (!md->queue.card) { + err = -EINVAL; + goto out2; + } + + card = md->queue.card; + if (!mmc_card_mmc(card) || + md->part_type == EXT_CSD_PART_CONFIG_ACC_RPMB) { + err = MMC_BLK_NO_WP; + goto out2; + } + + if (md->part_type == 0) + goto check_user_area_wp_status; + + /* BOOT_WP_STATUS in EXT_CSD: + * |-----bit[7:4]-----|-------bit[3:2]--------|-------bit[1:0]--------| + * |-----reserved-----|----boot1 wp status----|----boot0 wp status----| + * boot0 area wp type:depending on bit[1:0] + * 0->not wp; 1->power on wp; 2->permanent wp; 3:reserved value + * boot1 area wp type:depending on bit[3:2] + * 0->not wp; 1->power on wp; 2->permanent wp; 3:reserved value + */ + if (md->part_type == EXT_CSD_PART_CONFIG_ACC_BOOT0) + boot_wp_status = card->ext_csd.boot_wp_status & 0x3; + else if (md->part_type == (EXT_CSD_PART_CONFIG_ACC_BOOT0 + 1)) + boot_wp_status = (card->ext_csd.boot_wp_status >> 2) & 0x3; + + if (boot_wp_status == 0x1 || boot_wp_status == 0x2) { + pr_notice("%s is fully write protected\n", disk->disk_name); + err = MMC_BLK_FULLY_WP; + } else + err = MMC_BLK_NO_WP; + goto out2; + +check_user_area_wp_status: + if (!card->wp_grp_size) { + pr_notice("Write protect group size cannot be 0!\n"); + err = -EINVAL; + goto out2; + } + + start = part_start; + quot = start; + remain = do_div(quot, card->wp_grp_size); + if (remain) { + pr_notice("Start 0x%llx of disk %s not write group aligned\n", + (unsigned long long)part_start, disk->disk_name); + start -= remain; + } + + end = part_start + part_nr_sects; + quot = end; + remain = do_div(quot, card->wp_grp_size); + if (remain) { + pr_notice("End 0x%llx of disk %s not write group aligned\n", + (unsigned long long)part_start, disk->disk_name); + end += card->wp_grp_size - remain; + } + wp_grp_total = end - start; + do_div(wp_grp_total, card->wp_grp_size); + wp_grp_rem = wp_grp_total; + wp_grp_found = 0; + + cmd.opcode = MMC_SEND_WRITE_PROT_TYPE; + cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_ADTC; + + buf = kmalloc(8, GFP_KERNEL); + if (!buf) { + err = -ENOMEM; + goto out2; + } + sg_init_one(&sg, buf, 8); + + data.blksz = 8; + data.blocks = 1; + data.flags = MMC_DATA_READ; + data.sg = &sg; + data.sg_len = 1; + mmc_set_data_timeout(&data, card); + + mrq.cmd = &cmd; + mrq.data = &data; + + mmc_get_card(card, NULL); + + err = mmc_blk_part_switch(card, md->part_type); + if (err) { + err = -EIO; + goto out; + } + + status_query_cnt = (wp_grp_total + 31) / 32; + for (i = 0; i < status_query_cnt; i++) { + cmd.arg = start + i * card->wp_grp_size * 32; + mmc_wait_for_req(card->host, &mrq); + if (cmd.error) { + pr_notice("%s: cmd error %d\n", __func__, cmd.error); + err = -EIO; + goto out; + } + + /* wp status is returned in 8 bytes. + * The 8 bytes are regarded as 64-bits bit-stream: + * +--------+--------+-------------------------+--------+ + * | byte 7 | byte 6 | ... | byte 0 | + * | bits | bits | | bits | + * |76543210|76543210| |76543210| + * +--------+--------+-------------------------+--------+ + * The 2 LSBits represent write-protect group status of + * the lowest address group being queried. + * The 2 MSBits represent write-protect group status of + * the highest address group being queried. + */ + /* Check write-protect group status from lowest address + * group to highest address group + */ + for (j = 0; j < 8; j++) { + status = buf[7 - j]; + for (k = 0; k < 8; k += 2) { + if (status & (3 << k)) + wp_grp_found++; + wp_grp_rem--; + if (!wp_grp_rem) + goto out; + } + } + + memset(buf, 0, 8); + } + +out: + mmc_put_card(card, NULL); + if (!wp_grp_rem) { + if (!wp_grp_found) + err = MMC_BLK_NO_WP; + else if (wp_grp_found == wp_grp_total) { + pr_notice("0x%llx ~ 0x%llx of %s is fully write protected\n", + (unsigned long long)part_start, + (unsigned long long)part_start + part_nr_sects, + disk->disk_name); + err = MMC_BLK_FULLY_WP; + } else { + pr_notice("0x%llx ~ 0x%llx of %s is %u%% write protected\n", + wp_grp_found * 100 / wp_grp_total, + (unsigned long long)part_start, + (unsigned long long)part_start + part_nr_sects, + disk->disk_name); + err = MMC_BLK_PARTIALLY_WP; + } + } + + kfree(buf); + +out2: + mmc_blk_put(md); + return err; +} + +static int mmc_blk_check_wp(struct block_device *bdev) +{ + if (!bdev->bd_disk || !bdev->bd_part) + return -EINVAL; + + return mmc_blk_check_disk_range_wp(bdev->bd_disk, + bdev->bd_part->start_sect, + bdev->bd_part->nr_sects); +} + +static int mmc_blk_ioctl_roset(struct block_device *bdev, + unsigned long arg) +{ + int val; + + /* Always return -EACCES to block layer on any error + * and then block layer will abort the remaining operation + */ + if (get_user(val, (int __user *)arg)) + return -EACCES; + + /* No need to check write-protect status when setting as readonly */ + if (val) + return 0; + + if (mmc_blk_check_wp(bdev) != MMC_BLK_NO_WP) + return -EACCES; + + return 0; +} + static int mmc_blk_ioctl(struct block_device *bdev, fmode_t mode, unsigned int cmd, unsigned long arg) { @@ -809,6 +1023,8 @@ static int mmc_blk_ioctl(struct block_device *bdev, fmode_t mode, NULL); mmc_blk_put(md); return ret; + case BLKROSET: + return mmc_blk_ioctl_roset(bdev, arg); default: return -EINVAL; } diff --git a/include/linux/mmc/mmc.h b/include/linux/mmc/mmc.h index 2c9d988..f7c1237 100644 --- a/include/linux/mmc/mmc.h +++ b/include/linux/mmc/mmc.h @@ -69,6 +69,7 @@ #define MMC_SET_WRITE_PROT 28 /* ac [31:0] data addr R1b */ #define MMC_CLR_WRITE_PROT 29 /* ac [31:0] data addr R1b */ #define MMC_SEND_WRITE_PROT 30 /* adtc [31:0] wpdata addr R1 */ +#define MMC_SEND_WRITE_PROT_TYPE 31 /* adtc [31:0] wpdata addr R1 */ /* class 5 */ #define MMC_ERASE_GROUP_START 35 /* ac [31:0] data addr R1 */ From patchwork Wed Mar 4 02:51:14 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Light Hsieh X-Patchwork-Id: 11419181 Return-Path: Received: from mail.kernel.org (pdx-korg-mail-1.web.codeaurora.org [172.30.200.123]) by pdx-korg-patchwork-2.web.codeaurora.org (Postfix) with ESMTP id 56FD192A for ; Wed, 4 Mar 2020 02:51:21 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 30DAC20866 for ; Wed, 4 Mar 2020 02:51:21 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (1024-bit key) header.d=mediatek.com header.i=@mediatek.com header.b="hPYqR650" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S2387457AbgCDCvU (ORCPT ); Tue, 3 Mar 2020 21:51:20 -0500 Received: from mailgw01.mediatek.com ([210.61.82.183]:27958 "EHLO mailgw01.mediatek.com" rhost-flags-OK-FAIL-OK-FAIL) by vger.kernel.org with ESMTP id S2387411AbgCDCvU (ORCPT ); Tue, 3 Mar 2020 21:51:20 -0500 X-UUID: dec6e0326ba54b168947a9cbb341fd39-20200304 DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=mediatek.com; s=dk; h=Content-Transfer-Encoding:Content-Type:MIME-Version:References:In-Reply-To:Message-ID:Date:Subject:CC:To:From; bh=7FGKC2CL96iktvyoBP2vbwLVT6EXR3CbHjrpB2EcLgw=; b=hPYqR650vpsEYzBHmuAXyKnxqVIEQBBVAcCTMDzNGoAwtzCDRYIwjuEb74suQHC5uF4kn9HIzQZzW9VPpMZXVOqR6GhdGGz6Sna6R/dEJQeOswmugcivby0Zpb9CoNoF+LDw6DxpNOBtZMdUVkZODgFNz4OAgslUCgFw25w1QQs=; X-UUID: dec6e0326ba54b168947a9cbb341fd39-20200304 Received: from mtkcas06.mediatek.inc [(172.21.101.30)] by mailgw01.mediatek.com (envelope-from ) (Cellopoint E-mail Firewall v4.1.10 Build 0809 with TLS) with ESMTP id 1622470829; Wed, 04 Mar 2020 10:51:17 +0800 Received: from mtkcas08.mediatek.inc (172.21.101.126) by mtkmbs05n1.mediatek.inc (172.21.101.15) with Microsoft SMTP Server (TLS) id 15.0.1395.4; Wed, 4 Mar 2020 10:50:08 +0800 Received: from mtkswgap22.mediatek.inc (172.21.77.33) by mtkcas08.mediatek.inc (172.21.101.73) with Microsoft SMTP Server id 15.0.1395.4 via Frontend Transport; Wed, 4 Mar 2020 10:51:55 +0800 From: To: CC: , , , , , , Light Hsieh Subject: [PATCH v1 3/3] block: set partition read/write policy according to write-protection status Date: Wed, 4 Mar 2020 10:51:14 +0800 Message-ID: <1583290274-5525-4-git-send-email-light.hsieh@mediatek.com> X-Mailer: git-send-email 1.8.1.1.dirty In-Reply-To: <1583290274-5525-1-git-send-email-light.hsieh@mediatek.com> References: <1583290274-5525-1-git-send-email-light.hsieh@mediatek.com> MIME-Version: 1.0 X-MTK: N Sender: linux-block-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-block@vger.kernel.org From: Light Hsieh For storage device with write-protection support, e.g. eMMC, register check_disk_range_wp() in struct block_device_operations for checking write-protection status. When creating block device for a partition, set read/write policy according to result of check_disk_range_wp() operation (if registered). Without this patch, ro attribute is not set for created block device of write-protected partition. User perform asynchronous buffered write to such partition won't get immediate error and therefore he won't be awared that write is not actually performed. With this patch, ro attribute is set for created block device of write-protected partition. User perform asynchronous buffered write to such partition will get immediate error and therefore he will be awared. Signed-off-by: Light Hsieh --- block/partition-generic.c | 10 ++++++++++ drivers/mmc/core/block.c | 1 + include/linux/blkdev.h | 1 + 3 files changed, 12 insertions(+) diff --git a/block/partition-generic.c b/block/partition-generic.c index 564fae7..69088e8 100644 --- a/block/partition-generic.c +++ b/block/partition-generic.c @@ -394,6 +394,16 @@ struct hd_struct *add_partition(struct gendisk *disk, int partno, goto out_free_info; pdev->devt = devt; + if (!p->policy) { + if (disk->fops->check_disk_range_wp) { + err = disk->fops->check_disk_range_wp(disk, start, len); + if (err > 0) + p->policy = 1; + else if (err != 0) + goto out_free_info; + } + } + /* delay uevent until 'holders' subdir is created */ dev_set_uevent_suppress(pdev, 1); err = device_add(pdev); diff --git a/drivers/mmc/core/block.c b/drivers/mmc/core/block.c index ee85abf..af81311 100644 --- a/drivers/mmc/core/block.c +++ b/drivers/mmc/core/block.c @@ -1047,6 +1047,7 @@ static int mmc_blk_compat_ioctl(struct block_device *bdev, fmode_t mode, #ifdef CONFIG_COMPAT .compat_ioctl = mmc_blk_compat_ioctl, #endif + .check_disk_range_wp = mmc_blk_check_disk_range_wp, }; static int mmc_blk_part_switch_pre(struct mmc_card *card, diff --git a/include/linux/blkdev.h b/include/linux/blkdev.h index 053ea4b..7814290 100644 --- a/include/linux/blkdev.h +++ b/include/linux/blkdev.h @@ -1707,6 +1707,7 @@ struct block_device_operations { void (*swap_slot_free_notify) (struct block_device *, unsigned long); int (*report_zones)(struct gendisk *, sector_t sector, unsigned int nr_zones, report_zones_cb cb, void *data); + int (*check_disk_range_wp)(struct gendisk *d, sector_t s, sector_t l); struct module *owner; const struct pr_ops *pr_ops; };