Skip to contentSkip to conversation

scsi: target: tcmu: fix size in calls to tcmu_flush_dcache_range

PATCH Applied Bodo Stroesser 4 participants 8 messages May 28, 2020 – Sep 4, 2020

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

PATCH 1/1 scsi: target: tcmu: fix size in calls to tcmu_flush_dcache_range

1) If remaining ring space before the end of the ring is smaller then the next cmd to write, tcmu writes a padding entry which fills the remaining space at the end of the ring.
Then tcmu calls tcmu_flush_dcache_range() with the size of struct tcmu_cmd_entry as data length to flush. If the space filled by the padding was smaller then tcmu_cmd_entry, tcmu_flush_dcache_range() is called for an address range reaching behind the end of the vmalloc'ed ring.
tcmu_flush_dcache_range() in a loop calls

      flush_dcache_page(virt_to_page(start));

for every page being part of the range. On x86 the line is optimized out by the compiler, as flush_dcache_page() is empty on x86.
But I assume the above can cause trouble on other architectures that really have a flush_dcache_page(). For paddings only the header part of an entry is relevant Due to alignment rules the header always fits in the remaining space, if padding is needed.
So tcmu_flush_dcache_range() can safely be called with sizeof(entry->hdr) as the length here.

2) After it has written a command to cmd ring, tcmu calls tcmu_flush_dcache_range() using the size of a struct tcmu_cmd_entry as data length to flush.
But if a command needs many iovecs, the real size of the command may be bigger then tcmu_cmd_entry, so a part of the written command is not flushed then.

---
 drivers/target/target_core_user.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)
drivers/target/target_core_user.c +2 -2
index f769bb1e3735..cdb4848d23c6 100644
@@ -1026,7 +1026,7 @@ static int queue_cmd_ring(struct tcmu_cmd *tcmu_cmd, sense_reason_t *scsi_err)
 		entry->hdr.cmd_id = 0; /* not used for PAD */
 		entry->hdr.kflags = 0;
 		entry->hdr.uflags = 0;
-		tcmu_flush_dcache_range(entry, sizeof(*entry));
+		tcmu_flush_dcache_range(entry, sizeof(entry->hdr));
 
 		UPDATE_HEAD(mb->cmd_head, pad_size, udev->cmdr_size);
 		tcmu_flush_dcache_range(mb, sizeof(*mb));
@@ -1084,7 +1084,7 @@ static int queue_cmd_ring(struct tcmu_cmd *tcmu_cmd, sense_reason_t *scsi_err)
 	cdb_off = CMDR_OFF + cmd_head + base_command_size;
 	memcpy((void *) mb + cdb_off, se_cmd->t_task_cdb, scsi_command_size(se_cmd->t_task_cdb));
 	entry->req.cdb_off = cdb_off;
-	tcmu_flush_dcache_range(entry, sizeof(*entry));
+	tcmu_flush_dcache_range(entry, command_size);
 
 	UPDATE_HEAD(mb->cmd_head, command_size, udev->cmdr_size);
 	tcmu_flush_dcache_range(mb, sizeof(*mb));
Signature · 1 line
2.12.3
Acked-by on v1 1/1
#1 lore raw
Quoted 50 lines · Bodo Stroesser

1) If remaining ring space before the end of the ring is smaller then the next cmd to write, tcmu writes a padding entry which fills the remaining space at the end of the ring.
Then tcmu calls tcmu_flush_dcache_range() with the size of struct tcmu_cmd_entry as data length to flush. If the space filled by the padding was smaller then tcmu_cmd_entry, tcmu_flush_dcache_range() is called for an address range reaching behind the end of the vmalloc'ed ring.
tcmu_flush_dcache_range() in a loop calls
flush_dcache_page(virt_to_page(start));
for every page being part of the range. On x86 the line is optimized out by the compiler, as flush_dcache_page() is empty on x86.
But I assume the above can cause trouble on other architectures that really have a flush_dcache_page(). For paddings only the header part of an entry is relevant Due to alignment rules the header always fits in the remaining space, if padding is needed.
So tcmu_flush_dcache_range() can safely be called with sizeof(entry->hdr) as the length here.

2) After it has written a command to cmd ring, tcmu calls tcmu_flush_dcache_range() using the size of a struct tcmu_cmd_entry as data length to flush.
But if a command needs many iovecs, the real size of the command may be bigger then tcmu_cmd_entry, so a part of the written command is not flushed then.

---
  drivers/target/target_core_user.c | 4 ++--
  1 file changed, 2 insertions(+), 2 deletions(-)
drivers/target/target_core_user.c +1 -1
index f769bb1e3735..cdb4848d23c6 100644
@@ -1026,7 +1026,7 @@ static int queue_cmd_ring(struct tcmu_cmd *tcmu_cmd, sense_reason_t *scsi_err)
  		entry->hdr.cmd_id = 0; /* not used for PAD */
  		entry->hdr.kflags = 0;
  		entry->hdr.uflags = 0;
-		tcmu_flush_dcache_range(entry, sizeof(*entry));
+		tcmu_flush_dcache_range(entry, sizeof(entry->hdr));
 
  		UPDATE_HEAD(mb->cmd_head, pad_size, udev->cmdr_size);
  		tcmu_flush_dcache_range(mb, sizeof(*mb));

drivers/target/target_core_user.c static int queue_cmd_ring(struct tcmu_cmd *tcmu_cmd, sense_reason_t *scsi_err) · line 1090

Quoted 8 lines
drivers/target/target_core_user.c +1 -1
@@ -1084,7 +1084,7 @@ static int queue_cmd_ring(struct tcmu_cmd *tcmu_cmd, sense_reason_t *scsi_err)
  	cdb_off = CMDR_OFF + cmd_head + base_command_size;
  	memcpy((void *) mb + cdb_off, se_cmd->t_task_cdb, scsi_command_size(se_cmd->t_task_cdb));
  	entry->req.cdb_off = cdb_off;
-	tcmu_flush_dcache_range(entry, sizeof(*entry));
+	tcmu_flush_dcache_range(entry, command_size);
 
  	UPDATE_HEAD(mb->cmd_head, command_size, udev->cmdr_size);
  	tcmu_flush_dcache_range(mb, sizeof(*mb));
#2 lore raw
In reply to Bodo Stroesser
Quoted 23 lines · Bodo Stroesser

1) If remaining ring space before the end of the ring is smaller then the next cmd to write, tcmu writes a padding entry which fills the remaining space at the end of the ring.
Then tcmu calls tcmu_flush_dcache_range() with the size of struct tcmu_cmd_entry as data length to flush. If the space filled by the padding was smaller then tcmu_cmd_entry, tcmu_flush_dcache_range() is called for an address range reaching behind the end of the vmalloc'ed ring.
tcmu_flush_dcache_range() in a loop calls

      flush_dcache_page(virt_to_page(start));

for every page being part of the range. On x86 the line is optimized out by the compiler, as flush_dcache_page() is empty on x86.
But I assume the above can cause trouble on other architectures that really have a flush_dcache_page(). For paddings only the header part of an entry is relevant Due to alignment rules the header always fits in the remaining space, if padding is needed.
So tcmu_flush_dcache_range() can safely be called with sizeof(entry->hdr) as the length here.

Quoted 1 line

[...]

Applied to 5.8/scsi-queue, thanks!

[1/1] scsi: target: tcmu: Fix size in calls to tcmu_flush_dcache_range

      https://git.kernel.org/mkp/scsi/c/8c4e0f212398
Signature · 1 line
Martin K. Petersen	Oracle Linux Engineering
#3 lore raw

Hi,

I'm adding [email protected]

Quoted 25 lines · Martin K. Petersen
Quoted 23 lines · Bodo Stroesser

1) If remaining ring space before the end of the ring is smaller then the next cmd to write, tcmu writes a padding entry which fills the remaining space at the end of the ring.
Then tcmu calls tcmu_flush_dcache_range() with the size of struct tcmu_cmd_entry as data length to flush. If the space filled by the padding was smaller then tcmu_cmd_entry, tcmu_flush_dcache_range() is called for an address range reaching behind the end of the vmalloc'ed ring.
tcmu_flush_dcache_range() in a loop calls
flush_dcache_page(virt_to_page(start));
for every page being part of the range. On x86 the line is optimized out by the compiler, as flush_dcache_page() is empty on x86.
But I assume the above can cause trouble on other architectures that really have a flush_dcache_page(). For paddings only the header part of an entry is relevant Due to alignment rules the header always fits in the remaining space, if padding is needed.
So tcmu_flush_dcache_range() can safely be called with sizeof(entry->hdr) as the length here.

Quoted 7 lines
Quoted 1 line

[...]

Applied to 5.8/scsi-queue, thanks!

[1/1] scsi: target: tcmu: Fix size in calls to tcmu_flush_dcache_range

       https://git.kernel.org/mkp/scsi/c/8c4e0f212398

The full commit of this patch is:

    8c4e0f212398cdd1eb4310a5981d06a723cdd24f

This patch is the first of four patches that are necessary to run tcmu on ARM without crash. For details please see

    https://bugzilla.kernel.org/show_bug.cgi?id 8045

Upsteam commits of patches 2,3, and 4 are:
2: 3c58f737231e "scsi: target: tcmu: Optimize use of flush_dcache_page" 3: 3145550a7f8b "scsi: target: tcmu: Fix crash in tcmu_flush_dcache_range on ARM" 4: 5a0c256d96f0 "scsi: target: tcmu: Fix crash on ARM during cmd completion"

Since patches 3 and 4 already were accepted for 5.8, 5.4, and 4.19, and I sent a request to add patch 2 about 1 hour ago, please consider adding this patch to 5.4 and 4.19, because without it tcmu on ARM will still crash.

Thank you,
Bodo

#4 lore raw

Hi,
I'm adding [email protected]

Once again, this time really adding stable.

Quoted 25 lines · Martin K. Petersen
Quoted 23 lines · Bodo Stroesser

1) If remaining ring space before the end of the ring is smaller then the next cmd to write, tcmu writes a padding entry which fills the remaining space at the end of the ring.
Then tcmu calls tcmu_flush_dcache_range() with the size of struct tcmu_cmd_entry as data length to flush. If the space filled by the padding was smaller then tcmu_cmd_entry, tcmu_flush_dcache_range() is called for an address range reaching behind the end of the vmalloc'ed ring.
tcmu_flush_dcache_range() in a loop calls
flush_dcache_page(virt_to_page(start));
for every page being part of the range. On x86 the line is optimized out by the compiler, as flush_dcache_page() is empty on x86.
But I assume the above can cause trouble on other architectures that really have a flush_dcache_page(). For paddings only the header part of an entry is relevant Due to alignment rules the header always fits in the remaining space, if padding is needed.
So tcmu_flush_dcache_range() can safely be called with sizeof(entry->hdr) as the length here.

Quoted 7 lines
Quoted 1 line

[...]

Applied to 5.8/scsi-queue, thanks!

[1/1] scsi: target: tcmu: Fix size in calls to tcmu_flush_dcache_range

        https://git.kernel.org/mkp/scsi/c/8c4e0f212398

The full commit of this patch is:

     8c4e0f212398cdd1eb4310a5981d06a723cdd24f

This patch is the first of four patches that are necessary to run tcmu on ARM without crash. For details please see

     https://bugzilla.kernel.org/show_bug.cgi?id=208045

Upsteam commits of patches 2,3, and 4 are:
2: 3c58f737231e "scsi: target: tcmu: Optimize use of flush_dcache_page" 3: 3145550a7f8b "scsi: target: tcmu: Fix crash in
tcmu_flush_dcache_range on ARM"
4: 5a0c256d96f0 "scsi: target: tcmu: Fix crash on ARM during cmd
completion"

Since patches 3 and 4 already were accepted for 5.8, 5.4, and 4.19, and I sent a request to add patch 2 about 1 hour ago, please consider adding this patch to 5.4 and 4.19, because without it tcmu on ARM will still crash.

Thank you,
Bodo

maintainer
#5 lore raw
Quoted 52 lines · Bodo Stroesser

Hi,
I'm adding [email protected]

Once again, this time really adding stable.

Quoted 25 lines · Martin K. Petersen
Quoted 23 lines · Bodo Stroesser

1) If remaining ring space before the end of the ring is smaller then the next cmd to write, tcmu writes a padding entry which fills the remaining space at the end of the ring.
Then tcmu calls tcmu_flush_dcache_range() with the size of struct tcmu_cmd_entry as data length to flush. If the space filled by the padding was smaller then tcmu_cmd_entry, tcmu_flush_dcache_range() is called for an address range reaching behind the end of the vmalloc'ed ring.
tcmu_flush_dcache_range() in a loop calls
flush_dcache_page(virt_to_page(start));
for every page being part of the range. On x86 the line is optimized out by the compiler, as flush_dcache_page() is empty on x86.
But I assume the above can cause trouble on other architectures that really have a flush_dcache_page(). For paddings only the header part of an entry is relevant Due to alignment rules the header always fits in the remaining space, if padding is needed.
So tcmu_flush_dcache_range() can safely be called with sizeof(entry->hdr) as the length here.

Quoted 7 lines
Quoted 1 line

[...]

Applied to 5.8/scsi-queue, thanks!

[1/1] scsi: target: tcmu: Fix size in calls to tcmu_flush_dcache_range

        https://git.kernel.org/mkp/scsi/c/8c4e0f212398

The full commit of this patch is:

     8c4e0f212398cdd1eb4310a5981d06a723cdd24f

This patch is the first of four patches that are necessary to run tcmu on ARM without crash. For details please see

     https://bugzilla.kernel.org/show_bug.cgi?id 8045

Upsteam commits of patches 2,3, and 4 are:
2: 3c58f737231e "scsi: target: tcmu: Optimize use of flush_dcache_page" 3: 3145550a7f8b "scsi: target: tcmu: Fix crash in tcmu_flush_dcache_range
on ARM"
4: 5a0c256d96f0 "scsi: target: tcmu: Fix crash on ARM during cmd
completion"

Quoted 4 lines

Since patches 3 and 4 already were accepted for 5.8, 5.4, and 4.19, and I sent a request to add patch 2 about 1 hour ago, please consider adding this patch to 5.4 and 4.19, because without it tcmu on ARM will still crash.

I don't see such a request, and am confused now.

What exact commits do you want backported, and to what trees?

thanks,

greg k-h

#6 lore raw
Quoted 58 lines · Greg KH
Quoted 52 lines · Bodo Stroesser

Hi,
I'm adding [email protected]

Once again, this time really adding stable.

Quoted 25 lines · Martin K. Petersen
Quoted 23 lines · Bodo Stroesser

1) If remaining ring space before the end of the ring is smaller then the next cmd to write, tcmu writes a padding entry which fills the remaining space at the end of the ring.
Then tcmu calls tcmu_flush_dcache_range() with the size of struct tcmu_cmd_entry as data length to flush. If the space filled by the padding was smaller then tcmu_cmd_entry, tcmu_flush_dcache_range() is called for an address range reaching behind the end of the vmalloc'ed ring.
tcmu_flush_dcache_range() in a loop calls
flush_dcache_page(virt_to_page(start));
for every page being part of the range. On x86 the line is optimized out by the compiler, as flush_dcache_page() is empty on x86.
But I assume the above can cause trouble on other architectures that really have a flush_dcache_page(). For paddings only the header part of an entry is relevant Due to alignment rules the header always fits in the remaining space, if padding is needed.
So tcmu_flush_dcache_range() can safely be called with sizeof(entry->hdr) as the length here.

Quoted 7 lines
Quoted 1 line

[...]

Applied to 5.8/scsi-queue, thanks!

[1/1] scsi: target: tcmu: Fix size in calls to tcmu_flush_dcache_range

         https://git.kernel.org/mkp/scsi/c/8c4e0f212398

The full commit of this patch is:

      8c4e0f212398cdd1eb4310a5981d06a723cdd24f

This patch is the first of four patches that are necessary to run tcmu on ARM without crash. For details please see

      https://bugzilla.kernel.org/show_bug.cgi?id 8045

Upsteam commits of patches 2,3, and 4 are:
2: 3c58f737231e "scsi: target: tcmu: Optimize use of flush_dcache_page" 3: 3145550a7f8b "scsi: target: tcmu: Fix crash in tcmu_flush_dcache_range
on ARM"
4: 5a0c256d96f0 "scsi: target: tcmu: Fix crash on ARM during cmd
completion"

Quoted 4 lines

Since patches 3 and 4 already were accepted for 5.8, 5.4, and 4.19, and I sent a request to add patch 2 about 1 hour ago, please consider adding this patch to 5.4 and 4.19, because without it tcmu on ARM will still crash.

Quoted 8 lines

I don't see such a request, and am confused now.

What exact commits do you want backported, and to what trees?

thanks,

greg k-h

Sorry for the confusion.

The subject of the request I mentioned is
"Re: [PATCH v2 0/2] scsi: target: tcmu: fix crashes on ARM"
because it is for the first patch of a small series of two.

Please backport to kernels 4.19 and 5.4 (it is part of 5.8 from beginning):
8c4e0f212398 "scsi: target: tcmu: fix size in calls to tcmu_flush_dcache_range"

Please backport to kernels 4.19, 5.4 and 5.8:
3c58f737231e "scsi: target: tcmu: Optimize use of flush_dcache_page"

Backporting to 4.14 or earlier AFAICS would need more work, especially testing. I don't think that its worth it.

Thank you,
Bodo

maintainer
#7 lore raw
Quoted 74 lines · Bodo Stroesser
Quoted 58 lines · Greg KH
Quoted 52 lines · Bodo Stroesser

Hi,
I'm adding [email protected]

Once again, this time really adding stable.

Quoted 25 lines · Martin K. Petersen
Quoted 23 lines · Bodo Stroesser

1) If remaining ring space before the end of the ring is smaller then the next cmd to write, tcmu writes a padding entry which fills the remaining space at the end of the ring.
Then tcmu calls tcmu_flush_dcache_range() with the size of struct tcmu_cmd_entry as data length to flush. If the space filled by the padding was smaller then tcmu_cmd_entry, tcmu_flush_dcache_range() is called for an address range reaching behind the end of the vmalloc'ed ring.
tcmu_flush_dcache_range() in a loop calls
flush_dcache_page(virt_to_page(start));
for every page being part of the range. On x86 the line is optimized out by the compiler, as flush_dcache_page() is empty on x86.
But I assume the above can cause trouble on other architectures that really have a flush_dcache_page(). For paddings only the header part of an entry is relevant Due to alignment rules the header always fits in the remaining space, if padding is needed.
So tcmu_flush_dcache_range() can safely be called with sizeof(entry->hdr) as the length here.

Quoted 7 lines
Quoted 1 line

[...]

Applied to 5.8/scsi-queue, thanks!

[1/1] scsi: target: tcmu: Fix size in calls to tcmu_flush_dcache_range

         https://git.kernel.org/mkp/scsi/c/8c4e0f212398

The full commit of this patch is:

      8c4e0f212398cdd1eb4310a5981d06a723cdd24f

This patch is the first of four patches that are necessary to run tcmu on ARM without crash. For details please see

      https://bugzilla.kernel.org/show_bug.cgi?id=208045

Upsteam commits of patches 2,3, and 4 are:
2: 3c58f737231e "scsi: target: tcmu: Optimize use of flush_dcache_page" 3: 3145550a7f8b "scsi: target: tcmu: Fix crash in tcmu_flush_dcache_range
on ARM"
4: 5a0c256d96f0 "scsi: target: tcmu: Fix crash on ARM during cmd
completion"

Quoted 4 lines

Since patches 3 and 4 already were accepted for 5.8, 5.4, and 4.19, and I sent a request to add patch 2 about 1 hour ago, please consider adding this patch to 5.4 and 4.19, because without it tcmu on ARM will still crash.

Quoted 8 lines

I don't see such a request, and am confused now.

What exact commits do you want backported, and to what trees?

thanks,

greg k-h

Sorry for the confusion.

The subject of the request I mentioned is
"Re: [PATCH v2 0/2] scsi: target: tcmu: fix crashes on ARM"
because it is for the first patch of a small series of two.

Quoted 8 lines

Please backport to kernels 4.19 and 5.4 (it is part of 5.8 from beginning):
8c4e0f212398 "scsi: target: tcmu: fix size in calls to tcmu_flush_dcache_range"

Please backport to kernels 4.19, 5.4 and 5.8:
3c58f737231e "scsi: target: tcmu: Optimize use of flush_dcache_page"

Backporting to 4.14 or earlier AFAICS would need more work, especially testing. I don't think that its worth it.

Thanks, both now queued up.

greg k-h