Skip to contentSkip to conversation

ata,sd: Fix reading concurrent positioning ranges

PATCH Applied Tyler Erickson 5 participants 17 messages Jun 2, 2022 – Jun 8, 2022

Subsystems (4)
lore
Share & tools
lore
#0 lore raw

v2 cover ata,sd: Fix reading concurrent positioning ranges

This patch series fixes reading the concurrent positioning ranges.

The first patch fixes reading this in libata, where it was reading more data than a drive necessarily supports, resulting in a command abort.

The second patch fixes the SCSI translated data to put the VPD page length in the correct starting byte.

The third patch in sd, the fix is adding 4 instead of 3 for the header length. Using 3 will always result in an error and was likely used incorrectly as T10 specifications list all tables starting at byte 0, and byte 3 is the page length, which would mean there are 4 total bytes before the remaining data that contains the ranges and other information.

Tyler Erickson (3):
libata: fix reading concurrent positioning ranges log
libata: fix translation of concurrent positioning ranges
scsi: sd: Fix interpretation of VPD B9h length

 drivers/ata/libata-core.c | 21 +++++++++++++--------
 drivers/ata/libata-scsi.c |  2 +-
 drivers/scsi/sd.c         |  2 +-
 3 files changed, 15 insertions(+), 10 deletions(-)

base-commit: 700170bf6b4d773e328fa54ebb70ba444007c702

Signature · 1 line
2.17.1
#1 lore raw

PATCH v2 1/3 libata: fix reading concurrent positioning ranges log

The concurrent positioning ranges log is not a fixed size and may depend on how many ranges are supported by the device. This patch uses the size reported in the GPL directory to determine the number of pages supported by the device before attempting to read this log page.

This resolves this error from the dmesg output:

    ata6.00: Read log 0x47 page 0x00 failed, Emask 0x1
Fixes fe22e1c2f705 ("libata: support concurrent positioning ranges log")
---
 drivers/ata/libata-core.c | 21 +++++++++++++--------
 1 file changed, 13 insertions(+), 8 deletions(-)
drivers/ata/libata-core.c +13 -8
index 40e816419f48..3ea10f72cb70 100644
@@ -2010,16 +2010,16 @@ unsigned int ata_read_log_page(struct ata_device *dev, u8 log,
 	return err_mask;
 }
 
-static bool ata_log_supported(struct ata_device *dev, u8 log)
+static int ata_log_supported(struct ata_device *dev, u8 log)
 {
 	struct ata_port *ap = dev->link->ap;
 
 	if (dev->horkage & ATA_HORKAGE_NO_LOG_DIR)
-		return false;
+		return 0;
 
 	if (ata_read_log_page(dev, ATA_LOG_DIRECTORY, 0, ap->sector_buf, 1))
-		return false;
-	return get_unaligned_le16(&ap->sector_buf[log * 2]) ? true : false;
+		return 0;
+	return get_unaligned_le16(&ap->sector_buf[log * 2]);
 }
 
 static bool ata_identify_page_supported(struct ata_device *dev, u8 page)
@@ -2455,15 +2455,20 @@ static void ata_dev_config_cpr(struct ata_device *dev)
 	struct ata_cpr_log *cpr_log = NULL;
 	u8 *desc, *buf = NULL;
 
-	if (ata_id_major_version(dev->id) < 11 ||
-	    !ata_log_supported(dev, ATA_LOG_CONCURRENT_POSITIONING_RANGES))
+	if (ata_id_major_version(dev->id) < 11)
+		goto out;
+
+	buf_len = ata_log_supported(dev, ATA_LOG_CONCURRENT_POSITIONING_RANGES);
+	if (buf_len == 0)
 		goto out;
 
 	/*
 	 * Read the concurrent positioning ranges log (0x47). We can have at
-	 * most 255 32B range descriptors plus a 64B header.
+	 * most 255 32B range descriptors plus a 64B header. This log varies in
+	 * size, so use the size reported in the GPL directory. Reading beyond
+	 * the supported length will result in an error.
 	 */
-	buf_len = (64 + 255 * 32 + 511) & ~511;
+	buf_len <<= 9;
 	buf = kzalloc(buf_len, GFP_KERNEL);
 	if (!buf)
 		goto out;
Signature · 1 line
2.17.1
#2 lore raw

Re: [PATCH v2 1/3] libata: fix reading concurrent positioning ranges log

Quoted 31 lines · Tyler Erickson

The concurrent positioning ranges log is not a fixed size and may depend on how many ranges are supported by the device. This patch uses the size reported in the GPL directory to determine the number of pages supported by the device before attempting to read this log page.

This resolves this error from the dmesg output:

     ata6.00: Read log 0x47 page 0x00 failed, Emask 0x1
Fixes fe22e1c2f705 ("libata: support concurrent positioning ranges log")
---
  drivers/ata/libata-core.c | 21 +++++++++++++--------
  1 file changed, 13 insertions(+), 8 deletions(-)
drivers/ata/libata-core.c +1 -1
index 40e816419f48..3ea10f72cb70 100644
@@ -2010,16 +2010,16 @@ unsigned int ata_read_log_page(struct ata_device *dev, u8 log,
  	return err_mask;
  }
 
-static bool ata_log_supported(struct ata_device *dev, u8 log)
+static int ata_log_supported(struct ata_device *dev, u8 log)
  {
  	struct ata_port *ap = dev->link->ap;
 
  	if (dev->horkage & ATA_HORKAGE_NO_LOG_DIR)

drivers/ata/libata-core.c unsigned int ata_read_log_page(struct ata_device *dev, u8 log, · line 2024

Quoted 10 lines
drivers/ata/libata-core.c +3 -3
-		return false;
+		return 0;
 
  	if (ata_read_log_page(dev, ATA_LOG_DIRECTORY, 0, ap->sector_buf, 1))
-		return false;
-	return get_unaligned_le16(&ap->sector_buf[log * 2]) ? true : false;
+		return 0;
+	return get_unaligned_le16(&ap->sector_buf[log * 2]);
  }
 

Maybe we should change to name of the function here; 'ata_log_supported()' suggests a bool return.

ata_check_log_page() ?

Quoted 16 lines
drivers/ata/libata-core.c +5 -2
  static bool ata_identify_page_supported(struct ata_device *dev, u8 page)
@@ -2455,15 +2455,20 @@ static void ata_dev_config_cpr(struct ata_device *dev)
  	struct ata_cpr_log *cpr_log = NULL;
  	u8 *desc, *buf = NULL;
 
-	if (ata_id_major_version(dev->id) < 11 ||
-	    !ata_log_supported(dev, ATA_LOG_CONCURRENT_POSITIONING_RANGES))
+	if (ata_id_major_version(dev->id) < 11)
+		goto out;
+
+	buf_len = ata_log_supported(dev, ATA_LOG_CONCURRENT_POSITIONING_RANGES);
+	if (buf_len == 0)
  		goto out;
 
  	/*
  	 * Read the concurrent positioning ranges log (0x47). We can have at

drivers/ata/libata-core.c static void ata_dev_config_cpr(struct ata_device *dev) · line 2474

Quoted 10 lines
drivers/ata/libata-core.c +4 -2
-	 * most 255 32B range descriptors plus a 64B header.
+	 * most 255 32B range descriptors plus a 64B header. This log varies in
+	 * size, so use the size reported in the GPL directory. Reading beyond
+	 * the supported length will result in an error.
  	 */
-	buf_len = (64 + 255 * 32 + 511) & ~511;
+	buf_len <<= 9;
  	buf = kzalloc(buf_len, GFP_KERNEL);
  	if (!buf)
  		goto out;

I don't get it.
You just returned the actual length of the log page from the previous function. Why do you need to calculate the length here?

Cheers,

Hannes

Signature · 4 lines
Dr. Hannes Reinecke		           Kernel Storage Architect
[email protected]			                  +49 911 74053 688
SUSE Software Solutions Germany GmbH, Maxfeldstr. 5, 90409 Nürnberg
HRB 36809 (AG Nürnberg), GF: Felix Imendörffer
#3 lore raw

Re: [PATCH v2 1/3] libata: fix reading concurrent positioning ranges log

Quoted 61 lines · Hannes Reinecke
Quoted 31 lines · Tyler Erickson

The concurrent positioning ranges log is not a fixed size and may depend on how many ranges are supported by the device. This patch uses the size reported in the GPL directory to determine the number of pages supported by the device before attempting to read this log page.

This resolves this error from the dmesg output:

     ata6.00: Read log 0x47 page 0x00 failed, Emask 0x1
Fixes fe22e1c2f705 ("libata: support concurrent positioning ranges log")
---
  drivers/ata/libata-core.c | 21 +++++++++++++--------
  1 file changed, 13 insertions(+), 8 deletions(-)
drivers/ata/libata-core.c +1 -1
index 40e816419f48..3ea10f72cb70 100644
@@ -2010,16 +2010,16 @@ unsigned int ata_read_log_page(struct ata_device *dev, u8 log,
  	return err_mask;
  }
 
-static bool ata_log_supported(struct ata_device *dev, u8 log)
+static int ata_log_supported(struct ata_device *dev, u8 log)
  {
  	struct ata_port *ap = dev->link->ap;
 
  	if (dev->horkage & ATA_HORKAGE_NO_LOG_DIR)

drivers/ata/libata-core.c unsigned int ata_read_log_page(struct ata_device *dev, u8 log, · line 2024

Quoted 10 lines
drivers/ata/libata-core.c +3 -3
-		return false;
+		return 0;
 
  	if (ata_read_log_page(dev, ATA_LOG_DIRECTORY, 0, ap->sector_buf, 1))
-		return false;
-	return get_unaligned_le16(&ap->sector_buf[log * 2]) ? true : false;
+		return 0;
+	return get_unaligned_le16(&ap->sector_buf[log * 2]);
  }
 

Maybe we should change to name of the function here; 'ata_log_supported()' suggests a bool return.

ata_check_log_page() ?

Quoted 14 lines
drivers/ata/libata-core.c +5 -2
  static bool ata_identify_page_supported(struct ata_device *dev, u8 page)
@@ -2455,15 +2455,20 @@ static void ata_dev_config_cpr(struct ata_device *dev)
  	struct ata_cpr_log *cpr_log = NULL;
  	u8 *desc, *buf = NULL;
 
-	if (ata_id_major_version(dev->id) < 11 ||
-	    !ata_log_supported(dev, ATA_LOG_CONCURRENT_POSITIONING_RANGES))
+	if (ata_id_major_version(dev->id) < 11)
+		goto out;
+
+	buf_len = ata_log_supported(dev, ATA_LOG_CONCURRENT_POSITIONING_RANGES);
+	if (buf_len == 0)
  		goto out;
 
Quoted 16 lines

drivers/ata/libata-core.c static void ata_dev_config_cpr(struct ata_device *dev) · line 2474

Quoted 12 lines
drivers/ata/libata-core.c +4 -2
  	/*
  	 * Read the concurrent positioning ranges log (0x47). We can have at
-	 * most 255 32B range descriptors plus a 64B header.
+	 * most 255 32B range descriptors plus a 64B header. This log varies in
+	 * size, so use the size reported in the GPL directory. Reading beyond
+	 * the supported length will result in an error.
  	 */
-	buf_len = (64 + 255 * 32 + 511) & ~511;
+	buf_len <<= 9;
  	buf = kzalloc(buf_len, GFP_KERNEL);
  	if (!buf)
  		goto out;

I don't get it.
You just returned the actual length of the log page from the previous function. Why do you need to calculate the length here?

Calculate ? This is only converting from 512B sectors to bytes. The calculation was mine, a gross error :) This is what this patch is fixing.

Quoted 4 lines

Cheers,

Hannes

Signature · 2 lines
Damien Le Moal
Western Digital Research
#4 lore raw

Re: [PATCH v2 1/3] libata: fix reading concurrent positioning ranges log

Quoted 79 lines · Damien Le Moal
Quoted 61 lines · Hannes Reinecke
Quoted 31 lines · Tyler Erickson

The concurrent positioning ranges log is not a fixed size and may depend on how many ranges are supported by the device. This patch uses the size reported in the GPL directory to determine the number of pages supported by the device before attempting to read this log page.

This resolves this error from the dmesg output:

      ata6.00: Read log 0x47 page 0x00 failed, Emask 0x1
Fixes fe22e1c2f705 ("libata: support concurrent positioning ranges log")
---
   drivers/ata/libata-core.c | 21 +++++++++++++--------
   1 file changed, 13 insertions(+), 8 deletions(-)
drivers/ata/libata-core.c +1 -1
index 40e816419f48..3ea10f72cb70 100644
@@ -2010,16 +2010,16 @@ unsigned int ata_read_log_page(struct ata_device *dev, u8 log,
   	return err_mask;
   }
 
-static bool ata_log_supported(struct ata_device *dev, u8 log)
+static int ata_log_supported(struct ata_device *dev, u8 log)
   {
   	struct ata_port *ap = dev->link->ap;
 
   	if (dev->horkage & ATA_HORKAGE_NO_LOG_DIR)

drivers/ata/libata-core.c unsigned int ata_read_log_page(struct ata_device *dev, u8 log, · line 2024

Quoted 10 lines
drivers/ata/libata-core.c +3 -3
-		return false;
+		return 0;
 
   	if (ata_read_log_page(dev, ATA_LOG_DIRECTORY, 0, ap->sector_buf, 1))
-		return false;
-	return get_unaligned_le16(&ap->sector_buf[log * 2]) ? true : false;
+		return 0;
+	return get_unaligned_le16(&ap->sector_buf[log * 2]);
   }
 

Maybe we should change to name of the function here; 'ata_log_supported()' suggests a bool return.

ata_check_log_page() ?

Quoted 14 lines
drivers/ata/libata-core.c +5 -2
   static bool ata_identify_page_supported(struct ata_device *dev, u8 page)
@@ -2455,15 +2455,20 @@ static void ata_dev_config_cpr(struct ata_device *dev)
   	struct ata_cpr_log *cpr_log = NULL;
   	u8 *desc, *buf = NULL;
 
-	if (ata_id_major_version(dev->id) < 11 ||
-	    !ata_log_supported(dev, ATA_LOG_CONCURRENT_POSITIONING_RANGES))
+	if (ata_id_major_version(dev->id) < 11)
+		goto out;
+
+	buf_len = ata_log_supported(dev, ATA_LOG_CONCURRENT_POSITIONING_RANGES);
+	if (buf_len == 0)
   		goto out;
 
Quoted 16 lines

drivers/ata/libata-core.c static void ata_dev_config_cpr(struct ata_device *dev) · line 2474

Quoted 12 lines
drivers/ata/libata-core.c +4 -2
   	/*
   	 * Read the concurrent positioning ranges log (0x47). We can have at
-	 * most 255 32B range descriptors plus a 64B header.
+	 * most 255 32B range descriptors plus a 64B header. This log varies in
+	 * size, so use the size reported in the GPL directory. Reading beyond
+	 * the supported length will result in an error.
   	 */
-	buf_len = (64 + 255 * 32 + 511) & ~511;
+	buf_len <<= 9;
   	buf = kzalloc(buf_len, GFP_KERNEL);
   	if (!buf)
   		goto out;

I don't get it.
You just returned the actual length of the log page from the previous function. Why do you need to calculate the length here?

Quoted 3 lines

Calculate ? This is only converting from 512B sectors to bytes. The calculation was mine, a gross error :) This is what this patch is fixing.

Sigh. Can't we have a 'bytes_to_sectors' helper? All this shifting by 9 is getting on my nerves ...

Cheers,

Hannes

Signature · 4 lines
Dr. Hannes Reinecke		           Kernel Storage Architect
[email protected]			                  +49 911 74053 688
SUSE Software Solutions Germany GmbH, Maxfeldstr. 5, 90409 Nürnberg
HRB 36809 (AG Nürnberg), GF: Felix Imendörffer
#5 lore raw

Re: [PATCH v2 1/3] libata: fix reading concurrent positioning ranges log

Quoted 80 lines · Hannes Reinecke
Quoted 79 lines · Damien Le Moal
Quoted 77 lines · Hannes Reinecke
Quoted 31 lines · Tyler Erickson

The concurrent positioning ranges log is not a fixed size and may depend on how many ranges are supported by the device. This patch uses the size reported in the GPL directory to determine the number of pages supported by the device before attempting to read this log page.

This resolves this error from the dmesg output:

      ata6.00: Read log 0x47 page 0x00 failed, Emask 0x1
Fixes fe22e1c2f705 ("libata: support concurrent positioning ranges log")
---
   drivers/ata/libata-core.c | 21 +++++++++++++--------
   1 file changed, 13 insertions(+), 8 deletions(-)
drivers/ata/libata-core.c +1 -1
index 40e816419f48..3ea10f72cb70 100644
@@ -2010,16 +2010,16 @@ unsigned int ata_read_log_page(struct ata_device *dev, u8 log,
   	return err_mask;
   }
 
-static bool ata_log_supported(struct ata_device *dev, u8 log)
+static int ata_log_supported(struct ata_device *dev, u8 log)
   {
   	struct ata_port *ap = dev->link->ap;
 
   	if (dev->horkage & ATA_HORKAGE_NO_LOG_DIR)

drivers/ata/libata-core.c unsigned int ata_read_log_page(struct ata_device *dev, u8 log, · line 2024

Quoted 10 lines
drivers/ata/libata-core.c +3 -3
-		return false;
+		return 0;
 
   	if (ata_read_log_page(dev, ATA_LOG_DIRECTORY, 0, ap->sector_buf, 1))
-		return false;
-	return get_unaligned_le16(&ap->sector_buf[log * 2]) ? true : false;
+		return 0;
+	return get_unaligned_le16(&ap->sector_buf[log * 2]);
   }
 

Maybe we should change to name of the function here; 'ata_log_supported()' suggests a bool return.

ata_check_log_page() ?

Quoted 16 lines
drivers/ata/libata-core.c +5 -2
   static bool ata_identify_page_supported(struct ata_device *dev, u8 page)
@@ -2455,15 +2455,20 @@ static void ata_dev_config_cpr(struct ata_device *dev)
   	struct ata_cpr_log *cpr_log = NULL;
   	u8 *desc, *buf = NULL;
 
-	if (ata_id_major_version(dev->id) < 11 ||
-	    !ata_log_supported(dev, ATA_LOG_CONCURRENT_POSITIONING_RANGES))
+	if (ata_id_major_version(dev->id) < 11)
+		goto out;
+
+	buf_len = ata_log_supported(dev, ATA_LOG_CONCURRENT_POSITIONING_RANGES);
+	if (buf_len == 0)
   		goto out;
 
   	/*
   	 * Read the concurrent positioning ranges log (0x47). We can have at

drivers/ata/libata-core.c static void ata_dev_config_cpr(struct ata_device *dev) · line 2474

Quoted 10 lines
drivers/ata/libata-core.c +4 -2
-	 * most 255 32B range descriptors plus a 64B header.
+	 * most 255 32B range descriptors plus a 64B header. This log varies in
+	 * size, so use the size reported in the GPL directory. Reading beyond
+	 * the supported length will result in an error.
   	 */
-	buf_len = (64 + 255 * 32 + 511) & ~511;
+	buf_len <<= 9;
   	buf = kzalloc(buf_len, GFP_KERNEL);
   	if (!buf)
   		goto out;

I don't get it.
You just returned the actual length of the log page from the previous function. Why do you need to calculate the length here?

Quoted 5 lines
Quoted 3 lines

Calculate ? This is only converting from 512B sectors to bytes. The calculation was mine, a gross error :) This is what this patch is fixing.

Sigh. Can't we have a 'bytes_to_sectors' helper? All this shifting by 9 is getting on my nerves ...

Haha ! Yes, we can do that. But not in this patch since that is a bug fix.

Signature · 2 lines
Damien Le Moal
Western Digital Research
#6 lore raw

PATCH v2 2/3 libata: fix translation of concurrent positioning ranges

In reply to Tyler Erickson

Fixing the page length in the SCSI translation for the concurrent positioning ranges VPD page. It was writing starting in offset 3 rather than offset 2 where the MSB is supposed to start for the VPD page length.

Fixes fe22e1c2f705 ("libata: support concurrent positioning ranges log")
---
 drivers/ata/libata-scsi.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)
drivers/ata/libata-scsi.c +1 -1
index 42cecf95a4e5..86dbb1cdfabd 100644
@@ -2125,7 +2125,7 @@ static unsigned int ata_scsiop_inq_b9(struct ata_scsi_args *args, u8 *rbuf)
 
 	/* SCSI Concurrent Positioning Ranges VPD page: SBC-5 rev 1 or later */
 	rbuf[1] = 0xb9;
-	put_unaligned_be16(64 + (int)cpr_log->nr_cpr * 32 - 4, &rbuf[3]);
+	put_unaligned_be16(64 + (int)cpr_log->nr_cpr * 32 - 4, &rbuf[2]);
 
 	for (i = 0; i < cpr_log->nr_cpr; i++, desc += 32) {
 		desc[0] = cpr_log->cpr[i].num;
Signature · 1 line
2.17.1
Reviewed-by on v2 2/3
#7 lore raw

Re: [PATCH v2 2/3] libata: fix translation of concurrent positioning ranges

Quoted 19 lines · Tyler Erickson

Fixing the page length in the SCSI translation for the concurrent positioning ranges VPD page. It was writing starting in offset 3 rather than offset 2 where the MSB is supposed to start for the VPD page length.

Fixes fe22e1c2f705 ("libata: support concurrent positioning ranges log")
---
  drivers/ata/libata-scsi.c | 2 +-
  1 file changed, 1 insertion(+), 1 deletion(-)
drivers/ata/libata-scsi.c +0 -0
index 42cecf95a4e5..86dbb1cdfabd 100644

drivers/ata/libata-scsi.c static unsigned int ata_scsiop_inq_b9(struct ata_scsi_args *args, u8 *rbuf) · line 2131

Quoted 8 lines
drivers/ata/libata-scsi.c +1 -1
@@ -2125,7 +2125,7 @@ static unsigned int ata_scsiop_inq_b9(struct ata_scsi_args *args, u8 *rbuf)
 
  	/* SCSI Concurrent Positioning Ranges VPD page: SBC-5 rev 1 or later */
  	rbuf[1] = 0xb9;
-	put_unaligned_be16(64 + (int)cpr_log->nr_cpr * 32 - 4, &rbuf[3]);
+	put_unaligned_be16(64 + (int)cpr_log->nr_cpr * 32 - 4, &rbuf[2]);
 
  	for (i = 0; i < cpr_log->nr_cpr; i++, desc += 32) {
  		desc[0] = cpr_log->cpr[i].num;

Cheers,

Hannes

Signature · 4 lines
Dr. Hannes Reinecke		           Kernel Storage Architect
[email protected]			                  +49 911 74053 688
SUSE Software Solutions Germany GmbH, Maxfeldstr. 5, 90409 Nürnberg
HRB 36809 (AG Nürnberg), GF: Felix Imendörffer
#8 lore raw

PATCH v2 3/3 scsi: sd: Fix interpretation of VPD B9h length

In reply to Tyler Erickson

Fixing the interpretation of the length of the B9h VPD page (concurrent positioning ranges). Adding 4 is necessary as the first 4 bytes of the page is the header with page number and length information. Adding 3 was likely a misinterpretation of the SBC-5 specification which sets all offsets starting at zero.

This fixes the error in dmesg:

[ 9.014456] sd 1:0:0:0: [sda] Invalid Concurrent Positioning Ranges VPD page
Fixes e815d36548f0 ("scsi: sd: add concurrent positioning ranges support")
---
 drivers/scsi/sd.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)
drivers/scsi/sd.c +1 -1
index 749316462075..f25b0cc5dd21 100644
@@ -3072,7 +3072,7 @@ static void sd_read_cpr(struct scsi_disk *sdkp)
 		goto out;
 
 	/* We must have at least a 64B header and one 32B range descriptor */
-	vpd_len = get_unaligned_be16(&buffer[2]) + 3;
+	vpd_len = get_unaligned_be16(&buffer[2]) + 4;
 	if (vpd_len > buf_len || vpd_len < 64 + 32 || (vpd_len & 31)) {
 		sd_printk(KERN_ERR, sdkp,
 			  "Invalid Concurrent Positioning Ranges VPD page\n");
Signature · 1 line
2.17.1
Reviewed-by on v2 3/3
#9 lore raw

Re: [PATCH v2 3/3] scsi: sd: Fix interpretation of VPD B9h length

Quoted 23 lines · Tyler Erickson

Fixing the interpretation of the length of the B9h VPD page (concurrent positioning ranges). Adding 4 is necessary as the first 4 bytes of the page is the header with page number and length information. Adding 3 was likely a misinterpretation of the SBC-5 specification which sets all offsets starting at zero.

This fixes the error in dmesg:

[ 9.014456] sd 1:0:0:0: [sda] Invalid Concurrent Positioning Ranges VPD page
Fixes e815d36548f0 ("scsi: sd: add concurrent positioning ranges support")
---
 drivers/scsi/sd.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)
drivers/scsi/sd.c +0 -0
index 749316462075..f25b0cc5dd21 100644

drivers/scsi/sd.c static void sd_read_cpr(struct scsi_disk *sdkp) · line 3078

Quoted 8 lines
drivers/scsi/sd.c +1 -1
@@ -3072,7 +3072,7 @@ static void sd_read_cpr(struct scsi_disk *sdkp)
 		goto out;
 
 	/* We must have at least a 64B header and one 32B range descriptor */
-	vpd_len = get_unaligned_be16(&buffer[2]) + 3;
+	vpd_len = get_unaligned_be16(&buffer[2]) + 4;
 	if (vpd_len > buf_len || vpd_len < 64 + 32 || (vpd_len & 31)) {
 		sd_printk(KERN_ERR, sdkp,
 			  "Invalid Concurrent Positioning Ranges VPD page\n");

Martin,

If you take this one:

Signature · 2 lines
Damien Le Moal
Western Digital Research
#10 lore raw

Re: [PATCH v2 3/3] scsi: sd: Fix interpretation of VPD B9h length

Quoted 35 lines · Damien Le Moal
Quoted 23 lines · Tyler Erickson

Fixing the interpretation of the length of the B9h VPD page (concurrent positioning ranges). Adding 4 is necessary as the first 4 bytes of the page is the header with page number and length information. Adding 3 was likely a misinterpretation of the SBC-5 specification which sets all offsets starting at zero.

This fixes the error in dmesg:

[ 9.014456] sd 1:0:0:0: [sda] Invalid Concurrent Positioning Ranges VPD page
Fixes e815d36548f0 ("scsi: sd: add concurrent positioning ranges support")
---
 drivers/scsi/sd.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)
drivers/scsi/sd.c +0 -0
index 749316462075..f25b0cc5dd21 100644

drivers/scsi/sd.c static void sd_read_cpr(struct scsi_disk *sdkp) · line 3078

Quoted 8 lines
drivers/scsi/sd.c +1 -1
@@ -3072,7 +3072,7 @@ static void sd_read_cpr(struct scsi_disk *sdkp)
 		goto out;
 
 	/* We must have at least a 64B header and one 32B range descriptor */
-	vpd_len = get_unaligned_be16(&buffer[2]) + 3;
+	vpd_len = get_unaligned_be16(&buffer[2]) + 4;
 	if (vpd_len > buf_len || vpd_len < 64 + 32 || (vpd_len & 31)) {
 		sd_printk(KERN_ERR, sdkp,
 			  "Invalid Concurrent Positioning Ranges VPD page\n");

Martin,

Quoted 4 lines

If you take this one:

Martin,

Ping ?
How do you want to handle this one ? I can take it if you want (need your acked-by) or you can take it through the scsi tree.

Thanks !

Signature · 2 lines
Damien Le Moal
Western Digital Research
Reviewed-by on v2 3/3
#11 lore raw

Re: [PATCH v2 3/3] scsi: sd: Fix interpretation of VPD B9h length

In reply to Tyler Erickson
Quoted 23 lines · Tyler Erickson

Fixing the interpretation of the length of the B9h VPD page (concurrent positioning ranges). Adding 4 is necessary as the first 4 bytes of the page is the header with page number and length information. Adding 3 was likely a misinterpretation of the SBC-5 specification which sets all offsets starting at zero.

This fixes the error in dmesg:

[ 9.014456] sd 1:0:0:0: [sda] Invalid Concurrent Positioning Ranges VPD page
Fixes e815d36548f0 ("scsi: sd: add concurrent positioning ranges support")
---
  drivers/scsi/sd.c | 2 +-
  1 file changed, 1 insertion(+), 1 deletion(-)
drivers/scsi/sd.c +0 -0
index 749316462075..f25b0cc5dd21 100644

drivers/scsi/sd.c static void sd_read_cpr(struct scsi_disk *sdkp) · line 3078

Quoted 8 lines
drivers/scsi/sd.c +1 -1
@@ -3072,7 +3072,7 @@ static void sd_read_cpr(struct scsi_disk *sdkp)
  		goto out;
 
  	/* We must have at least a 64B header and one 32B range descriptor */
-	vpd_len = get_unaligned_be16(&buffer[2]) + 3;
+	vpd_len = get_unaligned_be16(&buffer[2]) + 4;
  	if (vpd_len > buf_len || vpd_len < 64 + 32 || (vpd_len & 31)) {
  		sd_printk(KERN_ERR, sdkp,
  			  "Invalid Concurrent Positioning Ranges VPD page\n");

Cheers,

Hannes

Signature · 4 lines
Dr. Hannes Reinecke		           Kernel Storage Architect
[email protected]			                  +49 911 74053 688
SUSE Software Solutions Germany GmbH, Maxfeldstr. 5, 90409 Nürnberg
HRB 36809 (AG Nürnberg), GF: Felix Imendörffer
#12 lore raw
In reply to Tyler Erickson
Quoted 21 lines · Tyler Erickson

This patch series fixes reading the concurrent positioning ranges.

The first patch fixes reading this in libata, where it was reading more data than a drive necessarily supports, resulting in a command abort.

The second patch fixes the SCSI translated data to put the VPD page length in the correct starting byte.

The third patch in sd, the fix is adding 4 instead of 3 for the header length. Using 3 will always result in an error and was likely used incorrectly as T10 specifications list all tables starting at byte 0, and byte 3 is the page length, which would mean there are 4 total bytes before the remaining data that contains the ranges and other information.

Tyler Erickson (3):
libata: fix reading concurrent positioning ranges log
libata: fix translation of concurrent positioning ranges
scsi: sd: Fix interpretation of VPD B9h length

Quoted 7 lines
 drivers/ata/libata-core.c | 21 +++++++++++++--------
 drivers/ata/libata-scsi.c |  2 +-
 drivers/scsi/sd.c         |  2 +-
 3 files changed, 15 insertions(+), 10 deletions(-)

base-commit: 700170bf6b4d773e328fa54ebb70ba444007c702

Looks all good to me. I tested this and really wonder how I did not catch these mistakes earlier :)

Using a tcmu emulator for various concurrent positioning range configs to test, I got a lockdep splat when unplugging the drive:

[  760.702859] ======================================================
[  760.702863] WARNING: possible circular locking dependency detected
[  760.702868] 5.18.0+ #1509 Not tainted
[  760.702875] ------------------------------------------------------
[...]
[  760.702966] the existing dependency chain (in reverse order) is:
[  760.702969]
[  760.702969] -> #1 (&q->sysfs_lock){+.+.}-{3:3}:
[  760.702982]        __mutex_lock+0x15b/0x1480
[  760.702998]        blk_ia_range_sysfs_show+0x41/0xc0
[  760.703010]        sysfs_kf_seq_show+0x1f2/0x360
[  760.703022]        seq_read_iter+0x40f/0x1130
[  760.703036]        new_sync_read+0x2d8/0x520
[  760.703049]        vfs_read+0x31a/0x450
[  760.703060]        ksys_read+0xf7/0x1d0
[  760.703070]        do_syscall_64+0x34/0x80
[  760.703081]        entry_SYSCALL_64_after_hwframe+0x46/0xb0
[  760.703093]
[  760.703093] -> #0 (kn->active#385){++++}-{0:0}:
[  760.703108]        __lock_acquire+0x2ba6/0x6a20
[  760.703125]        lock_acquire+0x19f/0x510
[  760.703136]        __kernfs_remove+0x739/0x940
[  760.703145]        kernfs_remove_by_name_ns+0x90/0xe0
[  760.703154]        remove_files+0x8c/0x1a0
[  760.703165]        sysfs_remove_group+0x77/0x150
[  760.703175]        sysfs_remove_groups+0x4f/0x90
[  760.703186]        __kobject_del+0x7d/0x1b0
[  760.703196]        kobject_del+0x31/0x50
[  760.703203]        disk_unregister_independent_access_ranges+0x153/0x290
[  760.703214]        blk_unregister_queue+0x166/0x210
[  760.703226]        del_gendisk+0x2f8/0x7c0
[  760.703233]        sd_remove+0x5e/0xb0 [sd_mod]
[  760.703252]        device_release_driver_internal+0x3ad/0x750
[  760.703262]        bus_remove_device+0x2a6/0x570
[  760.703269]        device_del+0x48f/0xb50
[  760.703280]        __scsi_remove_device+0x21b/0x2b0 [scsi_mod]
[  760.703339]        scsi_remove_device+0x3a/0x50 [scsi_mod]
[  760.703391]        tcm_loop_port_unlink+0xca/0x160 [tcm_loop]
[  760.703407]        target_fabric_port_unlink+0xd5/0x120 [target_core_mod]
[  760.703494]        configfs_unlink+0x37f/0x7a0
[  760.703502]        vfs_unlink+0x295/0x800
[  760.703514]        do_unlinkat+0x2d9/0x560
[  760.703520]        __x64_sys_unlink+0xa5/0xf0
[  760.703528]        do_syscall_64+0x34/0x80
[  760.703537]        entry_SYSCALL_64_after_hwframe+0x46/0xb0
[  760.703548]
[  760.703548] other info that might help us debug this:
[  760.703548]
[  760.703551]  Possible unsafe locking scenario:
[  760.703551]
[  760.703554]        CPU0                    CPU1
[  760.703556]        ----                    ----
[  760.703558]   lock(&q->sysfs_lock);
[  760.703565]                                lock(kn->active#385);
[  760.703573]                                lock(&q->sysfs_lock);
[  760.703579]   lock(kn->active#385);
[  760.703587]
[  760.703587]  *** DEADLOCK ***

This needs to be checked too, but that is not related to your fixes.

I will queue the libata patches for rc1 update.

Martin,

Do you want to take patch 3 or should I just take it ?

Signature · 2 lines
Damien Le Moal
Western Digital Research
#13 lore raw
Quoted 5 lines · Damien Le Moal

Looks all good to me. I tested this and really wonder how I did not catch these mistakes earlier :)

Using a tcmu emulator for various concurrent positioning range configs to test, I got a lockdep splat when unplugging the drive:

You probably want something like this:

---
From 4340b85be3532149310326b5f0caf329e1f4c748 Mon Sep 17 00:00:00 2001
From: Christoph Hellwig <[email protected]>
Date: Mon, 23 May 2022 09:18:44 +0200
Subject: block: don't take sysfs_lock in blk_ia_range_sysfs_show

sysfs already synchronizes internally against kobject removal, so remove the extra lock.

---
 block/blk-ia-ranges.c  | 8 +-------
 include/linux/blkdev.h | 1 -
 2 files changed, 1 insertion(+), 8 deletions(-)
block/blk-ia-ranges.c +1 -7
index 853be76b9808b..e9e7ebf02737f 100644
@@ -54,13 +54,8 @@ static ssize_t blk_ia_range_sysfs_show(struct kobject *kobj,
 		container_of(attr, struct blk_ia_range_sysfs_entry, attr);
 	struct blk_independent_access_range *iar =
 		container_of(kobj, struct blk_independent_access_range, kobj);
-	ssize_t ret;
 
-	mutex_lock(&iar->queue->sysfs_lock);
-	ret = entry->show(iar, buf);
-	mutex_unlock(&iar->queue->sysfs_lock);
-
-	return ret;
+	return entry->show(iar, buf);
 }
 
 static const struct sysfs_ops blk_ia_range_sysfs_ops = {
@@ -149,7 +144,6 @@ int disk_register_independent_access_ranges(struct gendisk *disk,
 	}
 
 	for (i = 0; i < iars->nr_ia_ranges; i++) {
-		iars->ia_range[i].queue = q;
 		ret = kobject_init_and_add(&iars->ia_range[i].kobj,
 					   &blk_ia_range_ktype, &iars->kobj,
 					   "%d", i);
include/linux/blkdev.h +0 -1
index a72203ed25454..0ceb85ca52af4 100644
@@ -348,7 +348,6 @@ static inline int blkdev_zone_mgmt_ioctl(struct block_device *bdev,
  */
 struct blk_independent_access_range {
 	struct kobject		kobj;
-	struct request_queue	*queue;
 	sector_t		sector;
 	sector_t		nr_sectors;
 };
Signature · 1 line
2.30.2
#14 lore raw
Quoted 30 lines · Christoph Hellwig
Quoted 5 lines · Damien Le Moal

Looks all good to me. I tested this and really wonder how I did not catch these mistakes earlier :)

Using a tcmu emulator for various concurrent positioning range configs to test, I got a lockdep splat when unplugging the drive:

You probably want something like this:

---
From 4340b85be3532149310326b5f0caf329e1f4c748 Mon Sep 17 00:00:00 2001
From: Christoph Hellwig <[email protected]>
Date: Mon, 23 May 2022 09:18:44 +0200
Subject: block: don't take sysfs_lock in blk_ia_range_sysfs_show

sysfs already synchronizes internally against kobject removal, so remove the extra lock.

---
 block/blk-ia-ranges.c  | 8 +-------
 include/linux/blkdev.h | 1 -
 2 files changed, 1 insertion(+), 8 deletions(-)
block/blk-ia-ranges.c +0 -0
index 853be76b9808b..e9e7ebf02737f 100644
@@ -54,13 +54,8 @@ static ssize_t blk_ia_range_sysfs_show(struct kobject *kobj,
 		container_of(attr, struct blk_ia_range_sysfs_entry, attr);

block/blk-ia-ranges.c static ssize_t blk_ia_range_sysfs_show(struct kobject *kobj, · line 58

Quoted 10 lines
block/blk-ia-ranges.c +1 -6
 	struct blk_independent_access_range *iar =
 		container_of(kobj, struct blk_independent_access_range, kobj);
-	ssize_t ret;
 
-	mutex_lock(&iar->queue->sysfs_lock);
-	ret = entry->show(iar, buf);
-	mutex_unlock(&iar->queue->sysfs_lock);
-
-	return ret;
+	return entry->show(iar, buf);

I sent a patch that Jens applied doing exactly that. But forgot to add the removal of the queue pointer you have below. Sending an incremental patch for that.

Quoted 23 lines
block/blk-ia-ranges.c +0 -1
 }
 
 static const struct sysfs_ops blk_ia_range_sysfs_ops = {
@@ -149,7 +144,6 @@ int disk_register_independent_access_ranges(struct gendisk *disk,
 	}
 
 	for (i = 0; i < iars->nr_ia_ranges; i++) {
-		iars->ia_range[i].queue = q;
 		ret = kobject_init_and_add(&iars->ia_range[i].kobj,
 					   &blk_ia_range_ktype, &iars->kobj,
 					   "%d", i);
include/linux/blkdev.h +0 -1
index a72203ed25454..0ceb85ca52af4 100644
@@ -348,7 +348,6 @@ static inline int blkdev_zone_mgmt_ioctl(struct block_device *bdev,
  */
 struct blk_independent_access_range {
 	struct kobject		kobj;
-	struct request_queue	*queue;
 	sector_t		sector;
 	sector_t		nr_sectors;
 };
Signature · 2 lines
Damien Le Moal
Western Digital Research
#15 lore raw
In reply to Tyler Erickson
Quoted 16 lines · Tyler Erickson

This patch series fixes reading the concurrent positioning ranges.

The first patch fixes reading this in libata, where it was reading more data than a drive necessarily supports, resulting in a command abort.

The second patch fixes the SCSI translated data to put the VPD page length in the correct starting byte.

The third patch in sd, the fix is adding 4 instead of 3 for the header length. Using 3 will always result in an error and was likely used incorrectly as T10 specifications list all tables starting at byte 0, and byte 3 is the page length, which would mean there are 4 total bytes before the remaining data that contains the ranges and other information.

Quoted 4 lines

Tyler Erickson (3):
libata: fix reading concurrent positioning ranges log
libata: fix translation of concurrent positioning ranges
scsi: sd: Fix interpretation of VPD B9h length

Applied 1-2 to for-5.19-fixes. Thanks !

Quoted 8 lines
 drivers/ata/libata-core.c | 21 +++++++++++++--------
 drivers/ata/libata-scsi.c |  2 +-
 drivers/scsi/sd.c         |  2 +-
 3 files changed, 15 insertions(+), 10 deletions(-)

base-commit: 700170bf6b4d773e328fa54ebb70ba444007c702

Signature · 2 lines
Damien Le Moal
Western Digital Research
#16 lore raw
In reply to Tyler Erickson
Quoted 10 lines · Tyler Erickson

This patch series fixes reading the concurrent positioning ranges.

The first patch fixes reading this in libata, where it was reading more data than a drive necessarily supports, resulting in a command abort.

The second patch fixes the SCSI translated data to put the VPD page length in the correct starting byte.

[...]

Applied to 5.19/scsi-fixes, thanks!

[3/3] scsi: sd: Fix interpretation of VPD B9h length

      https://git.kernel.org/mkp/scsi/c/f92de9d11042
Signature · 1 line
Martin K. Petersen	Oracle Linux Engineering