Skip to contentSkip to conversation

block, nvme: Increase max segments parameter setting value

PATCH In review Tokunori Ikegami 6 participants 19 messages Mar 23, 2020 – Mar 31, 2020

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

PATCH 1/1 block, nvme: Increase max segments parameter setting value

Currently data length can be specified as UINT_MAX but failed. This is caused by the max segments parameter limit set as USHRT_MAX. To resolve this issue change to increase the value limit range.

---
 block/blk-settings.c     | 2 +-
 drivers/nvme/host/core.c | 2 +-
 include/linux/blkdev.h   | 7 ++++---
 3 files changed, 6 insertions(+), 5 deletions(-)
block/blk-settings.c +1 -1
index c8eda2e7b91e..ed40bda573c2 100644
@@ -266,7 +266,7 @@ EXPORT_SYMBOL(blk_queue_max_write_zeroes_sectors);
  *    Enables a low level driver to set an upper limit on the number of
  *    hw data segments in a request.
  **/
-void blk_queue_max_segments(struct request_queue *q, unsigned short max_segments)
+void blk_queue_max_segments(struct request_queue *q, unsigned int max_segments)
 {
 	if (!max_segments) {
 		max_segments = 1;
drivers/nvme/host/core.c +1 -1
index a4d8c90ee7cc..2b48aab0969e 100644
@@ -2193,7 +2193,7 @@ static void nvme_set_queue_limits(struct nvme_ctrl *ctrl,
 
 		max_segments = min_not_zero(max_segments, ctrl->max_segments);
 		blk_queue_max_hw_sectors(q, ctrl->max_hw_sectors);
-		blk_queue_max_segments(q, min_t(u32, max_segments, USHRT_MAX));
+		blk_queue_max_segments(q, min_t(u32, max_segments, UINT_MAX));
 	}
 	if ((ctrl->quirks & NVME_QUIRK_STRIPE_SIZE) &&
 	    is_power_of_2(ctrl->max_hw_sectors))
include/linux/blkdev.h +4 -3
index f629d40c645c..4f4224e20c28 100644
@@ -338,8 +338,8 @@ struct queue_limits {
 	unsigned int		max_write_zeroes_sectors;
 	unsigned int		discard_granularity;
 	unsigned int		discard_alignment;
+	unsigned int		max_segments;
 
-	unsigned short		max_segments;
 	unsigned short		max_integrity_segments;
 	unsigned short		max_discard_segments;
 
@@ -1067,7 +1067,8 @@ extern void blk_queue_make_request(struct request_queue *, make_request_fn *);
 extern void blk_queue_bounce_limit(struct request_queue *, u64);
 extern void blk_queue_max_hw_sectors(struct request_queue *, unsigned int);
 extern void blk_queue_chunk_sectors(struct request_queue *, unsigned int);
-extern void blk_queue_max_segments(struct request_queue *, unsigned short);
+extern void blk_queue_max_segments(struct request_queue *q,
+				   unsigned int max_segments);
 extern void blk_queue_max_discard_segments(struct request_queue *,
 		unsigned short);
 extern void blk_queue_max_segment_size(struct request_queue *, unsigned int);
@@ -1276,7 +1277,7 @@ static inline unsigned int queue_max_hw_sectors(const struct request_queue *q)
 	return q->limits.max_hw_sectors;
 }
 
-static inline unsigned short queue_max_segments(const struct request_queue *q)
+static inline unsigned int queue_max_segments(const struct request_queue *q)
 {
 	return q->limits.max_segments;
 }
Signature · 7 lines
2.17.1


_______________________________________________
linux-nvme mailing list
[email protected]
http://lists.infradead.org/mailman/listinfo/linux-nvme
#2 lore raw

Hi,

Quoted 3 lines

The change looks okay, but why do we need such a large data length ?

Do you have a use-case or performance numbers ?

We use the large data length to get log page by the NVMe admin command. In the past it was able to get with the same length but failed currently with it. So it seems that depended on the kernel version as caused by the version up. Also I have confirmed that currently failed with the length 0x10000000 256MB.

Regards,
Ikegami

maintainer
#3 lore raw
Quoted 10 lines · Tokunori Ikegami

Hi,

Quoted 3 lines

The change looks okay, but why do we need such a large data length ?

Do you have a use-case or performance numbers ?

We use the large data length to get log page by the NVMe admin command. In the past it was able to get with the same length but failed currently with it.

So it seems that depended on the kernel version as caused by the version up.

We didn't have 32-bit max segments before, though. Why was 16-bits enough in older kernels? Which kernel did this stop working?

Quoted 2 lines

Also I have confirmed that currently failed with the length 0x10000000 256MB.

If your hitting max segment limits before any other limit, you should be able to do larger transfers with more physically contiguous memory. Huge pages can get the same data length in fewer segments, if you want to try that.

But wouldn't it be better if your application splits the transfer into smaller chunks across multiple commands? NVMe log page command supports offsets for this reason.

Reviewed-by on v1 1/1
#17 lore raw
In reply to Tokunori Ikegami
Quoted 65 lines · Tokunori Ikegami

Currently data length can be specified as UINT_MAX but failed. This is caused by the max segments parameter limit set as USHRT_MAX. To resolve this issue change to increase the value limit range.

---
  block/blk-settings.c     | 2 +-
  drivers/nvme/host/core.c | 2 +-
  include/linux/blkdev.h   | 7 ++++---
  3 files changed, 6 insertions(+), 5 deletions(-)
block/blk-settings.c +1 -1
index c8eda2e7b91e..ed40bda573c2 100644
@@ -266,7 +266,7 @@ EXPORT_SYMBOL(blk_queue_max_write_zeroes_sectors);
   *    Enables a low level driver to set an upper limit on the number of
   *    hw data segments in a request.
   **/
-void blk_queue_max_segments(struct request_queue *q, unsigned short max_segments)
+void blk_queue_max_segments(struct request_queue *q, unsigned int max_segments)
  {
  	if (!max_segments) {
  		max_segments = 1;
drivers/nvme/host/core.c +1 -1
index a4d8c90ee7cc..2b48aab0969e 100644
@@ -2193,7 +2193,7 @@ static void nvme_set_queue_limits(struct nvme_ctrl *ctrl,
 
  		max_segments = min_not_zero(max_segments, ctrl->max_segments);
  		blk_queue_max_hw_sectors(q, ctrl->max_hw_sectors);
-		blk_queue_max_segments(q, min_t(u32, max_segments, USHRT_MAX));
+		blk_queue_max_segments(q, min_t(u32, max_segments, UINT_MAX));
  	}
  	if ((ctrl->quirks & NVME_QUIRK_STRIPE_SIZE) &&
  	    is_power_of_2(ctrl->max_hw_sectors))
include/linux/blkdev.h +3 -2
index f629d40c645c..4f4224e20c28 100644
@@ -338,8 +338,8 @@ struct queue_limits {
  	unsigned int		max_write_zeroes_sectors;
  	unsigned int		discard_granularity;
  	unsigned int		discard_alignment;
+	unsigned int		max_segments;
 
-	unsigned short		max_segments;
  	unsigned short		max_integrity_segments;
  	unsigned short		max_discard_segments;
 
@@ -1067,7 +1067,8 @@ extern void blk_queue_make_request(struct request_queue *, make_request_fn *);
  extern void blk_queue_bounce_limit(struct request_queue *, u64);
  extern void blk_queue_max_hw_sectors(struct request_queue *, unsigned int);
  extern void blk_queue_chunk_sectors(struct request_queue *, unsigned int);
-extern void blk_queue_max_segments(struct request_queue *, unsigned short);
+extern void blk_queue_max_segments(struct request_queue *q,
+				   unsigned int max_segments);
  extern void blk_queue_max_discard_segments(struct request_queue *,
  		unsigned short);
  extern void blk_queue_max_segment_size(struct request_queue *, unsigned int);

include/linux/blkdev.h static inline unsigned int queue_max_hw_sectors(const struct request_queue *q) · line 1283

Quoted 8 lines
include/linux/blkdev.h +1 -1
@@ -1276,7 +1277,7 @@ static inline unsigned int queue_max_hw_sectors(const struct request_queue *q)
  	return q->limits.max_hw_sectors;
  }
 
-static inline unsigned short queue_max_segments(const struct request_queue *q)
+static inline unsigned int queue_max_segments(const struct request_queue *q)
  {
  	return q->limits.max_segments;
  }

One would assume that the same reasoning goes for max_integrity_segment, no?

Otherwise looks good.

Cheers,

Hannes

Signature · 4 lines
Dr. Hannes Reinecke            Teamlead Storage & Networking
[email protected]                               +49 911 74053 688
SUSE Software Solutions GmbH, Maxfeldstr. 5, 90409 Nürnberg
HRB 36809 (AG Nürnberg), Geschäftsführer: Felix Imendörffer
#4 lore raw
In reply to Keith Busch
Quoted 4 lines · Keith Busch
Quoted 3 lines · Tokunori Ikegami

Hi,

Quoted 2 lines

The change looks okay, but why do we need such a large data length ?

Quoted 8 lines
Quoted 6 lines
Quoted 1 line

Do you have a use-case or performance numbers ?

We use the large data length to get log page by the NVMe admin command. In the past it was able to get with the same length but failed currently with it.

So it seems that depended on the kernel version as caused by the version up.

We didn't have 32-bit max segments before, though. Why was 16-bits enough in older kernels? Which kernel did this stop working?

Now I am asking the detail information to the reporter so let me update later. That was able to use the same command script with the large data length in the past.

Quoted 11 lines
Quoted 3 lines

Also I have confirmed that currently failed with the length 0x10000000 256MB.

If your hitting max segment limits before any other limit, you should be able to do larger transfers with more physically contiguous memory. Huge pages can get the same data length in fewer segments, if you want to try that.

But wouldn't it be better if your application splits the transfer into smaller chunks across multiple commands? NVMe log page command supports offsets for this reason.

Yes actually now we are using the offset parameter to split the data to get. For a future usage it seems that it is better to use the large number size also.

#18 lore raw
In reply to Hannes Reinecke
Quoted 69 lines · Hannes Reinecke
Quoted 68 lines · Tokunori Ikegami

Currently data length can be specified as UINT_MAX but failed. This is caused by the max segments parameter limit set as USHRT_MAX. To resolve this issue change to increase the value limit range.

---
  block/blk-settings.c     | 2 +-
  drivers/nvme/host/core.c | 2 +-
  include/linux/blkdev.h   | 7 ++++---

  3 files changed, 6 insertions(+), 5 deletions(-)
block/blk-settings.c +1 -1
index c8eda2e7b91e..ed40bda573c2 100644
@@ -266,7 +266,7 @@ EXPORT_SYMBOL(blk_queue_max_write_zeroes_sectors);
    *    Enables a low level driver to set an upper limit on the number of
    *    hw data segments in a request.
    **/
-void blk_queue_max_segments(struct request_queue *q, unsigned short 
 max_segments)
+void blk_queue_max_segments(struct request_queue *q, unsigned int 
 max_segments)
   {

      if (!max_segments) {
          max_segments = 1;

drivers/nvme/host/core.c +1 -1
index a4d8c90ee7cc..2b48aab0969e 100644
@@ -2193,7 +2193,7 @@ static void nvme_set_queue_limits(struct 
 nvme_ctrl *ctrl,
             max_segments = min_not_zero(max_segments, ctrl->max_segments);
           blk_queue_max_hw_sectors(q, ctrl->max_hw_sectors);
-        blk_queue_max_segments(q, min_t(u32, max_segments, USHRT_MAX));
+        blk_queue_max_segments(q, min_t(u32, max_segments, UINT_MAX));
       }

      if ((ctrl->quirks & NVME_QUIRK_STRIPE_SIZE) && is_power_of_2(ctrl->max_hw_sectors))

include/linux/blkdev.h +1 -0
index f629d40c645c..4f4224e20c28 100644
@@ -338,8 +338,8 @@ struct queue_limits {
       unsigned int        max_write_zeroes_sectors;
       unsigned int        discard_granularity;
       unsigned int        discard_alignment;
+    unsigned int        max_segments;
   -    unsigned short        max_segments;
       unsigned short        max_integrity_segments;
       unsigned short        max_discard_segments;
   @@ -1067,7 +1067,8 @@ extern void blk_queue_make_request(struct request_queue *, make_request_fn *);

  extern void blk_queue_bounce_limit(struct request_queue *, u64); extern void blk_queue_max_hw_sectors(struct request_queue *, unsigned int); extern void blk_queue_chunk_sectors(struct request_queue *, unsigned int); -extern void blk_queue_max_segments(struct request_queue *, unsigned short);
+extern void blk_queue_max_segments(struct request_queue *q,
+                   unsigned int max_segments);
  extern void blk_queue_max_discard_segments(struct request_queue *, unsigned short);
  extern void blk_queue_max_segment_size(struct request_queue *, unsigned int);

include/linux/blkdev.h +0 -0
@@ -1276,7 +1277,7 @@ static inline unsigned int 
 queue_max_hw_sectors(const struct request_queue *q)
       return q->limits.max_hw_sectors;
   }
Quoted 8 lines
Quoted 7 lines
include/linux/blkdev.h +1 -0
   -static inline unsigned short queue_max_segments(const struct request_queue *q)
+static inline unsigned int queue_max_segments(const struct 
 request_queue *q)
   {

      return q->limits.max_segments;
  }

One would assume that the same reasoning goes for max_integrity_segment, no?

The error case itself can be resolved by the change without the max_integrity_segment changes.
Also the value is set to 0 as default and set to 1 by the nvme driver so it seems that not necessary to change for this case.

Quoted 4 lines

Otherwise looks good.

Thanks for your reviewing.

Quoted 4 lines

Cheers,

Hannes

#5 lore raw
In reply to Tokunori Ikegami
Quoted 11 lines · Tokunori Ikegami
Quoted 9 lines · Keith Busch
Quoted 8 lines · Tokunori Ikegami

Hi,

Quoted 3 lines

The change looks okay, but why do we need such a large data length ?

Do you have a use-case or performance numbers ?

We use the large data length to get log page by the NVMe admin command. In the past it was able to get with the same length but failed currently with it.

Quoted 5 lines
Quoted 3 lines
Quoted 1 line

So it seems that depended on the kernel version as caused by the version up.

We didn't have 32-bit max segments before, though. Why was 16-bits enough in older kernels? Which kernel did this stop working?

Now I am asking the detail information to the reporter so let me update later. That was able to use the same command script with the large data length in the past.

I have just confirmed the detail so let me update below.

The data length 20,531,712 (0x1394A00) is used on kernel 3.10.0 (CentOS 64bit). Also it is failed on kernel 10 4.10.0 (Ubuntu 32bit).
But just confirmed it as succeeded on both 4.15.0 (Ubuntu 32bit) and 4.15.1 (Ubuntu 64bit). So the original 20,531,712 length failure issue seems already resolved.

I tested the data length 0x10000000 (268,435,456) and it is failed But now confirmed it as failed on all the above kernel versions. Also the patch fixes only this 0x10000000 length failure issue.

There was confused and sorry for that.

Regards,
Ikegami

maintainer
#6 lore raw
Quoted 17 lines · Tokunori Ikegami
Quoted 6 lines · Tokunori Ikegami
Quoted 2 lines · Keith Busch

We didn't have 32-bit max segments before, though. Why was 16-bits enough in older kernels? Which kernel did this stop working?

Now I am asking the detail information to the reporter so let me update later. That was able to use the same command script with the large data length in the past.

I have just confirmed the detail so let me update below.

The data length 20,531,712 (0x1394A00) is used on kernel 3.10.0 (CentOS 64bit).
Also it is failed on kernel 10 4.10.0 (Ubuntu 32bit).
But just confirmed it as succeeded on both 4.15.0 (Ubuntu 32bit) and 4.15.1 (Ubuntu 64bit).
So the original 20,531,712 length failure issue seems already resolved.

Quoted 3 lines

I tested the data length 0x10000000 (268,435,456) and it is failed But now confirmed it as failed on all the above kernel versions. Also the patch fixes only this 0x10000000 length failure issue.

This is actually even more confusing. We do not support 256MB transfers within a single command in the pci nvme driver anymore. The max is 4MB, so I don't see how increasing the max segments will help: you should be hitting the 'max_sectors' limit if you don't hit the segment limit first.

#7 lore raw
Quoted 19 lines · Keith Busch
Quoted 17 lines · Tokunori Ikegami
Quoted 6 lines · Tokunori Ikegami
Quoted 2 lines · Keith Busch

We didn't have 32-bit max segments before, though. Why was 16-bits enough in older kernels? Which kernel did this stop working?

Now I am asking the detail information to the reporter so let me update later. That was able to use the same command script with the large data length in the past.

I have just confirmed the detail so let me update below.

The data length 20,531,712 (0x1394A00) is used on kernel 3.10.0 (CentOS 64bit).
Also it is failed on kernel 10 4.10.0 (Ubuntu 32bit).
But just confirmed it as succeeded on both 4.15.0 (Ubuntu 32bit) and 4.15.1 (Ubuntu 64bit).
So the original 20,531,712 length failure issue seems already resolved.

Quoted 8 lines
Quoted 3 lines

I tested the data length 0x10000000 (268,435,456) and it is failed But now confirmed it as failed on all the above kernel versions. Also the patch fixes only this 0x10000000 length failure issue.

This is actually even more confusing. We do not support 256MB transfers within a single command in the pci nvme driver anymore. The max is 4MB, so I don't see how increasing the max segments will help: you should be hitting the 'max_sectors' limit if you don't hit the segment limit first.

That looks a bug for passthrough req, because 'max_sectors' limit is only checked in bio_add_pc_page(), not done in blk_rq_append_bio(), something like the following seems required:

block/blk-map.c +4 -0
index b0790268ed9d..e120d80b75a5 100644
@@ -22,6 +22,10 @@ int blk_rq_append_bio(struct request *rq, struct bio **bio)
        struct bio_vec bv;
        unsigned int nr_segs = 0;
 
+       if (((rq->__data_len + (*bio)->bi_iter.bi_size) >> 9) >
+                       queue_max_hw_sectors(rq->q))
+               return -EINVAL;
+
 
 

Thanks,
Ming Lei

maintainer
#8 lore raw
Quoted 10 lines · Ming Lei
Quoted 5 lines · Keith Busch

This is actually even more confusing. We do not support 256MB transfers within a single command in the pci nvme driver anymore. The max is 4MB, so I don't see how increasing the max segments will help: you should be hitting the 'max_sectors' limit if you don't hit the segment limit first.

That looks a bug for passthrough req, because 'max_sectors' limit is only checked in bio_add_pc_page(), not done in blk_rq_append_bio(), something like the following seems required:

Shouldn't bio_map_user_iov() or bio_copy_user_iov() have caught the length limit before proceeding to blk_rq_append_bio()?

#9 lore raw
Quoted 9 lines · Keith Busch
Quoted 7 lines · Ming Lei
Quoted 5 lines · Keith Busch

This is actually even more confusing. We do not support 256MB transfers within a single command in the pci nvme driver anymore. The max is 4MB, so I don't see how increasing the max segments will help: you should be hitting the 'max_sectors' limit if you don't hit the segment limit first.

Quoted 6 lines
Quoted 3 lines

That looks a bug for passthrough req, because 'max_sectors' limit is only checked in bio_add_pc_page(), not done in blk_rq_append_bio(), something like the following seems required:

Shouldn't bio_map_user_iov() or bio_copy_user_iov() have caught the length limit before proceeding to blk_rq_append_bio()?

Actually the limit should be caught earlier in bio_add_pc_page(), that requires to pass 'rq' in, then one perfect passthrough bio can be made before appending to rq.

Not only max sector limit, max segments & virt_boundary should be checked in request wide too.

So far, only lightnvm calls bio_add_pc_page() before allocating request, and that is
the 1st bio, so NULL rq can be passed.

thanks,
Ming Lei

#10 lore raw
In reply to Ming Lei

Hi,

Quoted 34 lines · Ming Lei
Quoted 17 lines · Keith Busch
Quoted 16 lines · Tokunori Ikegami
Quoted 6 lines · Tokunori Ikegami
Quoted 2 lines · Keith Busch

We didn't have 32-bit max segments before, though. Why was 16-bits enough in older kernels? Which kernel did this stop working?

Now I am asking the detail information to the reporter so let me update later. That was able to use the same command script with the large data length in the past.

I have just confirmed the detail so let me update below.

The data length 20,531,712 (0x1394A00) is used on kernel 3.10.0 (CentOS 64bit).
Also it is failed on kernel 10 4.10.0 (Ubuntu 32bit).
But just confirmed it as succeeded on both 4.15.0 (Ubuntu 32bit) and 4.15.1 (Ubuntu 64bit).
So the original 20,531,712 length failure issue seems already resolved.

Quoted 7 lines
Quoted 3 lines

I tested the data length 0x10000000 (268,435,456) and it is failed But now confirmed it as failed on all the above kernel versions. Also the patch fixes only this 0x10000000 length failure issue.

This is actually even more confusing. We do not support 256MB transfers within a single command in the pci nvme driver anymore. The max is 4MB, so I don't see how increasing the max segments will help: you should be hitting the 'max_sectors' limit if you don't hit the segment limit first.

That looks a bug for passthrough req, because 'max_sectors' limit is only checked in bio_add_pc_page(), not done in blk_rq_append_bio(), something like the following seems required:

block/blk-map.c +0 -0
index b0790268ed9d..e120d80b75a5 100644

block/blk-map.c int blk_rq_append_bio(struct request *rq, struct bio **bio) · line 28

Quoted 7 lines
block/blk-map.c +4 -0
@@ -22,6 +22,10 @@ int blk_rq_append_bio(struct request *rq, struct bio **bio)
         struct bio_vec bv;
         unsigned int nr_segs = 0;
 
+       if (((rq->__data_len + (*bio)->bi_iter.bi_size) >> 9) >
+                       queue_max_hw_sectors(rq->q))
+               return -EINVAL;
+

I have just confirmed about the max_hw_sectors checking below. It is checked by the function blk_rq_map_kern() also as below.

    if (len > (queue_max_hw_sectors(q) << 9))
        return -EINVAL;

The function calls blk_rq_append_bio().
So the max_hw_sectors will be used to check the length with the change above. But it seems that there is a difference also for the checking limit condition.

It seems that it is better to check the limit by blk_rq_map_user() instead of blk_rq_append_bio(). Or it can be changed to check the limit by blk_rq_append_bio() only without blk_rq_map_kern().

Regards,
Ikegami

#11 lore raw
Quoted 49 lines · Tokunori Ikegami

Hi,

Quoted 34 lines · Ming Lei
Quoted 17 lines · Keith Busch
Quoted 16 lines · Tokunori Ikegami
Quoted 6 lines · Tokunori Ikegami
Quoted 2 lines · Keith Busch

We didn't have 32-bit max segments before, though. Why was 16-bits enough in older kernels? Which kernel did this stop working?

Now I am asking the detail information to the reporter so let me update later. That was able to use the same command script with the large data length in the past.

I have just confirmed the detail so let me update below.

The data length 20,531,712 (0x1394A00) is used on kernel 3.10.0 (CentOS 64bit).
Also it is failed on kernel 10 4.10.0 (Ubuntu 32bit).
But just confirmed it as succeeded on both 4.15.0 (Ubuntu 32bit) and 4.15.1 (Ubuntu 64bit).
So the original 20,531,712 length failure issue seems already resolved.

Quoted 7 lines
Quoted 3 lines

I tested the data length 0x10000000 (268,435,456) and it is failed But now confirmed it as failed on all the above kernel versions. Also the patch fixes only this 0x10000000 length failure issue.

This is actually even more confusing. We do not support 256MB transfers within a single command in the pci nvme driver anymore. The max is 4MB, so I don't see how increasing the max segments will help: you should be hitting the 'max_sectors' limit if you don't hit the segment limit first.

That looks a bug for passthrough req, because 'max_sectors' limit is only checked in bio_add_pc_page(), not done in blk_rq_append_bio(), something like the following seems required:

block/blk-map.c +0 -0
index b0790268ed9d..e120d80b75a5 100644

block/blk-map.c int blk_rq_append_bio(struct request *rq, struct bio **bio) · line 28

Quoted 7 lines
block/blk-map.c +4 -0
@@ -22,6 +22,10 @@ int blk_rq_append_bio(struct request *rq, struct bio **bio)
         struct bio_vec bv;
         unsigned int nr_segs = 0;
 
+       if (((rq->__data_len + (*bio)->bi_iter.bi_size) >> 9) >
+                       queue_max_hw_sectors(rq->q))
+               return -EINVAL;
+

I have just confirmed about the max_hw_sectors checking below. It is checked by the function blk_rq_map_kern() also as below.

Quoted 2 lines
     if (len > (queue_max_hw_sectors(q) << 9))
         return -EINVAL;

The above check doesn't take rq->__data_len into account.

Thanks,
Ming Lei

#12 lore raw
Quoted 48 lines · Ming Lei
Quoted 47 lines · Tokunori Ikegami

Hi,

Quoted 34 lines · Ming Lei
Quoted 17 lines · Keith Busch
Quoted 16 lines · Tokunori Ikegami
Quoted 6 lines · Tokunori Ikegami
Quoted 2 lines · Keith Busch

We didn't have 32-bit max segments before, though. Why was 16-bits enough in older kernels? Which kernel did this stop working?

Now I am asking the detail information to the reporter so let me update later. That was able to use the same command script with the large data length in the past.

I have just confirmed the detail so let me update below.

The data length 20,531,712 (0x1394A00) is used on kernel 3.10.0 (CentOS 64bit).
Also it is failed on kernel 10 4.10.0 (Ubuntu 32bit).
But just confirmed it as succeeded on both 4.15.0 (Ubuntu 32bit) and 4.15.1 (Ubuntu 64bit).
So the original 20,531,712 length failure issue seems already resolved.

Quoted 7 lines
Quoted 3 lines

I tested the data length 0x10000000 (268,435,456) and it is failed But now confirmed it as failed on all the above kernel versions. Also the patch fixes only this 0x10000000 length failure issue.

This is actually even more confusing. We do not support 256MB transfers within a single command in the pci nvme driver anymore. The max is 4MB, so I don't see how increasing the max segments will help: you should be hitting the 'max_sectors' limit if you don't hit the segment limit first.

That looks a bug for passthrough req, because 'max_sectors' limit is only checked in bio_add_pc_page(), not done in blk_rq_append_bio(), something like the following seems required:

block/blk-map.c +0 -0
index b0790268ed9d..e120d80b75a5 100644

block/blk-map.c int blk_rq_append_bio(struct request *rq, struct bio **bio) · line 28

Quoted 7 lines
block/blk-map.c +4 -0
@@ -22,6 +22,10 @@ int blk_rq_append_bio(struct request *rq, struct bio **bio)
          struct bio_vec bv;
          unsigned int nr_segs = 0;
 
+       if (((rq->__data_len + (*bio)->bi_iter.bi_size) >> 9) >
+                       queue_max_hw_sectors(rq->q))
+               return -EINVAL;
+

I have just confirmed about the max_hw_sectors checking below. It is checked by the function blk_rq_map_kern() also as below.

Quoted 3 lines
Quoted 2 lines
      if (len > (queue_max_hw_sectors(q) << 9))
          return -EINVAL;

The above check doesn't take rq->__data_len into account.

Thanks for the comment and noted it.
I have just confirmed the behavior on 5.6.0-rc7 as below.
It works to limit the data length size 4MB as expected basically. Also it can be limited by the check existed below in ll_back_merge_fn().

    if (blk_rq_sectors(req) + bio_sectors(bio) > blk_rq_get_max_sectors(req, blk_rq_pos(req))) {

But there is a case that the command data length is limited by 512KB. I am not sure about this condition so needed more investigation.

Regards,
Ikegami

maintainer
#13 lore raw
Quoted 2 lines · Tokunori Ikegami

But there is a case that the command data length is limited by 512KB. I am not sure about this condition so needed more investigation.

Your memory is too fragmented. You need more physically contiguous memory or you'll hit the segment limit before you hit the length limit. Try allocating huge pages.

#15 lore raw
In reply to Tokunori Ikegami

Hi Ikegami,

Are you actually able to bump up the max segments with the original patch? I did not notice the patch doing anything about NVME_MAX_SEGS, which is set to 127 currently.

From pci.c -
/*
* These can be higher, but we need to ensure that any command doesn't
* require an sg allocation that needs more than a page of data. */
#define NVME_MAX_KB_SZ 4096
#define NVME_MAX_SEGS 127

Quoted 11 lines
(quoted diff) +1 -1
@@ -2193,7 +2193,7 @@ static void nvme_set_queue_limits(struct nvme_ctrl
 *ctrl,
 
 max_segments = min_not_zero(max_segments, ctrl-
 >max_segments);
 blk_queue_max_hw_sectors(q, ctrl->max_hw_sectors);
- blk_queue_max_segments(q, min_t(u32, max_segments,
 USHRT_MAX));
+ blk_queue_max_segments(q, min_t(u32, max_segments,

UINT_MAX));
}

Since ctrl->max_segment is set to 127, max_segments will not go beyond 127.

Thanks,

Quoted 69 lines · Tokunori Ikegami
Quoted 48 lines · Ming Lei
Quoted 47 lines · Tokunori Ikegami

Hi,

Quoted 34 lines · Ming Lei
Quoted 17 lines · Keith Busch
Quoted 16 lines · Tokunori Ikegami
Quoted 6 lines · Tokunori Ikegami
Quoted 2 lines · Keith Busch

We didn't have 32-bit max segments before, though. Why was 16-bits enough in older kernels? Which kernel did this stop working?

Now I am asking the detail information to the reporter so let me update later. That was able to use the same command script with the large data length in the past.

I have just confirmed the detail so let me update below.

The data length 20,531,712 (0x1394A00) is used on kernel 3.10.0 (CentOS 64bit).
Also it is failed on kernel 10 4.10.0 (Ubuntu 32bit).
But just confirmed it as succeeded on both 4.15.0 (Ubuntu 32bit) and 4.15.1 (Ubuntu 64bit).
So the original 20,531,712 length failure issue seems already resolved.

Quoted 7 lines
Quoted 3 lines

I tested the data length 0x10000000 (268,435,456) and it is failed But now confirmed it as failed on all the above kernel versions. Also the patch fixes only this 0x10000000 length failure issue.

This is actually even more confusing. We do not support 256MB transfers within a single command in the pci nvme driver anymore. The max is 4MB, so I don't see how increasing the max segments will help: you should be hitting the 'max_sectors' limit if you don't hit the segment limit first.

That looks a bug for passthrough req, because 'max_sectors' limit is only checked in bio_add_pc_page(), not done in blk_rq_append_bio(), something like the following seems required:

block/blk-map.c +0 -0
index b0790268ed9d..e120d80b75a5 100644

block/blk-map.c int blk_rq_append_bio(struct request *rq, struct bio **bio) · line 28

Quoted 7 lines
block/blk-map.c +4 -0
@@ -22,6 +22,10 @@ int blk_rq_append_bio(struct request *rq, struct bio **bio)
          struct bio_vec bv;
          unsigned int nr_segs = 0;
 
+       if (((rq->__data_len + (*bio)->bi_iter.bi_size) >> 9) >
+                       queue_max_hw_sectors(rq->q))
+               return -EINVAL;
+

I have just confirmed about the max_hw_sectors checking below. It is checked by the function blk_rq_map_kern() also as below.

Quoted 3 lines
Quoted 2 lines
      if (len > (queue_max_hw_sectors(q) << 9))
          return -EINVAL;

The above check doesn't take rq->__data_len into account.

Thanks for the comment and noted it.
I have just confirmed the behavior on 5.6.0-rc7 as below.
It works to limit the data length size 4MB as expected basically. Also it can be limited by the check existed below in ll_back_merge_fn().

if (blk_rq_sectors(req) + bio_sectors(bio) >
blk_rq_get_max_sectors(req, blk_rq_pos(req))) {

But there is a case that the command data length is limited by 512KB. I am not sure about this condition so needed more investigation.

Regards,
Ikegami

Signature · 1 line
Joshi
#14 lore raw
In reply to Keith Busch

Hi,

Quoted 6 lines · Keith Busch
Quoted 2 lines · Tokunori Ikegami

But there is a case that the command data length is limited by 512KB. I am not sure about this condition so needed more investigation.

Your memory is too fragmented. You need more physically contiguous memory or you'll hit the segment limit before you hit the length limit. Try allocating huge pages.

Thank you so much for your advise.
I have confirmed that the 512KB case is limited by the 127 segments check below in ll_new_hw_segment().

    if (req->nr_phys_segments + nr_phys_segs > queue_max_segments(req->q)) {

Also confirmed that the 4MB limit works correctly with the memory condition not fragmented too much. I will do abandon the patch to increase max segments as limited 4MB now by NVMe PCIe driver.

Regards,
Ikegami

#16 lore raw
In reply to Joshi

Hi,

Quoted 3 lines · Joshi

Hi Ikegami,

Are you actually able to bump up the max segments with the original patch?

No as you mentioned currently it is limited by NVME_MAX_SEGS.
On the older kernel version it was not limited by the value but limited by USHRT_MAX. So it was able to change the limit by the patch.

As Keith-san also mentioned currently it is limited by the 4MB and 127 segments as you mentioned by the NVMe PCIe driver. So I will do abandon the patch to increase max segments.

Regards,
Ikegami