Skip to contentSkip to conversation

scsi_debug: disable clustering

PATCH In review FUJITA Tomonori 4 participants 9 messages Feb 16, 2008 – Feb 17, 2008

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

PATCH 1/1 scsi_debug: disable clustering

From: FUJITA Tomonori <[email protected]>
Subject: [PATCH] scsi_debug: disable clustering

scsi_debug does at several places:

for_each_sg(sdb->table.sgl, sg, sdb->table.nents, k) {
	kaddr = (unsigned char *)
		kmap_atomic(sg_page(sg), KM_USER0);

We cannot do something like that with the clustering enabled (or we can use scsi_kmap_atomic_sg).

---
 drivers/scsi/scsi_debug.c |    2 +-
 1 files changed, 1 insertions(+), 1 deletions(-)
drivers/scsi/scsi_debug.c +1 -1
index 1541c17..d1777a9 100644
@@ -222,7 +222,7 @@ static struct scsi_host_template sdebug_driver_template = {
 	.cmd_per_lun =		16,
 	.max_sectors =		0xffff,
 	.unchecked_isa_dma = 	0,
-	.use_clustering = 	ENABLE_CLUSTERING,
+	.use_clustering = 	DISABLE_CLUSTERING,
 	.module =		THIS_MODULE,
 };
 
Signature · 1 line
1.5.3.7
#1 lore raw
Quoted 10 lines · FUJITA Tomonori

From: FUJITA Tomonori <[email protected]>
Subject: [PATCH] scsi_debug: disable clustering

scsi_debug does at several places:

for_each_sg(sdb->table.sgl, sg, sdb->table.nents, k) {
	kaddr = (unsigned char *)
		kmap_atomic(sg_page(sg), KM_USER0);
Quoted 4 lines

We cannot do something like that with the clustering enabled (or we can use scsi_kmap_atomic_sg).

Thanks, Tomo.

Quoted 17 lines
---
 drivers/scsi/scsi_debug.c |    2 +-
 1 files changed, 1 insertions(+), 1 deletions(-)
drivers/scsi/scsi_debug.c +1 -1
index 1541c17..d1777a9 100644
@@ -222,7 +222,7 @@ static struct scsi_host_template sdebug_driver_template = {
 	.cmd_per_lun =		16,
 	.max_sectors =		0xffff,
 	.unchecked_isa_dma = 	0,
-	.use_clustering = 	ENABLE_CLUSTERING,
+	.use_clustering = 	DISABLE_CLUSTERING,
 	.module =		THIS_MODULE,
 };
 
#2 lore raw
In reply to FUJITA Tomonori
Quoted 9 lines · FUJITA Tomonori

scsi_debug does at several places:

for_each_sg(sdb->table.sgl, sg, sdb->table.nents, k) {
	kaddr = (unsigned char *)
		kmap_atomic(sg_page(sg), KM_USER0);

We cannot do something like that with the clustering enabled (or we can use scsi_kmap_atomic_sg).

Why not? Is KM_USER0 used for something else with clstering enabled?

Signature · 4 lines
Intel are signing my paycheques ... these opinions are still mine
"Bill, look, we understand that you're interested in selling us this
operating system, but compare it to ours.  We can't possibly take such
a retrograde step."
maintainer
#3 lore raw
Quoted 8 lines · Matthew Wilcox
Quoted 7 lines · FUJITA Tomonori

scsi_debug does at several places:

for_each_sg(sdb->table.sgl, sg, sdb->table.nents, k) {
	kaddr = (unsigned char *)
		kmap_atomic(sg_page(sg), KM_USER0);
Quoted 4 lines
Quoted 2 lines

We cannot do something like that with the clustering enabled (or we can use scsi_kmap_atomic_sg).

Why not? Is KM_USER0 used for something else with clstering enabled?

No, he means that kmap_atomic can only map a page of data. This makes single page only sg list entries and input assumption into this loop.
with ENABLE_CLUSTERING, that's potentially not true. Of course, this
accidentally works most of the time because of the way kmap functions.

James

#4 lore raw
Quoted 4 lines · James Bottomley

No, he means that kmap_atomic can only map a page of data. This makes single page only sg list entries and input assumption into this loop.
with ENABLE_CLUSTERING, that's potentially not true. Of course, this
accidentally works most of the time because of the way kmap functions.

Ah, right. I'm on the verge of releasing a ram-based scsi driver I've been working on ... this loop should work fine with clustering as it takes account of the sg potentially having multiple pages:

        scsi_for_each_sg(cmnd, sg, scsi_sg_count(cmnd), i) {
                struct page *sgpage = sg_page(sg);
                unsigned int to_off = sg->offset;
                unsigned int sg_copy = sg->length;
                if (sg_copy > len)
                        sg_copy = len;
                len -= sg_copy;

                while (sg_copy > 0) {
                        char *vto, *vfrom;
                        unsigned int page_copy;

                        if (from_off > to_off)
                                page_copy = PAGE_SIZE - from_off;
                        else
                                page_copy = PAGE_SIZE - to_off;
                        if (page_copy > sg_copy)
                                page_copy = sg_copy;

                        vfrom = get_data_page(data_pfn);
                        vto = get_sg_page(sgpage);
                        memcpy(vto + to_off, vfrom + from_off, page_copy);
                        put_sg_page(vto);
                        put_data_page(vfrom);

                        from_off += page_copy;
                        if (from_off == PAGE_SIZE) {
                                from_off = 0;
                                data_pfn++;
                        }
                        to_off += page_copy;
                        if (to_off == PAGE_SIZE) {
                                to_off = 0;
                                sgpage++;
                        }
                        sg_copy -= page_copy;
                }
                if (!len)
                        break;
        }

get_data_page() and get_sg_page() each do a kmap_atomic, so I was concerned that I might be out of KM_USER* pages.

Signature · 4 lines
Intel are signing my paycheques ... these opinions are still mine
"Bill, look, we understand that you're interested in selling us this
operating system, but compare it to ours.  We can't possibly take such
a retrograde step."
#5 lore raw
Quoted 10 lines · On Sun, 17 Feb 2008 07:28:48 -0700 Matthew Wilcox <[email protected]> wrote:
Quoted 4 lines · James Bottomley

No, he means that kmap_atomic can only map a page of data. This makes single page only sg list entries and input assumption into this loop.
with ENABLE_CLUSTERING, that's potentially not true. Of course, this
accidentally works most of the time because of the way kmap functions.

Ah, right. I'm on the verge of releasing a ram-based scsi driver I've been working on ... this loop should work fine with clustering as it takes account of the sg potentially having multiple pages:

Quoted 7 lines
        scsi_for_each_sg(cmnd, sg, scsi_sg_count(cmnd), i) {
                struct page *sgpage = sg_page(sg);
                unsigned int to_off = sg->offset;
                unsigned int sg_copy = sg->length;
                if (sg_copy > len)
                        sg_copy = len;
                len -= sg_copy;

stex driver has a similar function to copies data between a buffer and a scatter list. I think that scsi_kmap_atomic_sg is a bit primitive (and not very popular). I'll send a patch to add a helper function to scsi_lib.c that copies data between a buffer and a scatter list. It would be useful for several drivers.

maintainer
#6 lore raw
Quoted 21 lines · FUJITA Tomonori
Quoted 10 lines · On Sun, 17 Feb 2008 07:28:48 -0700 Matthew Wilcox <[email protected]> wrote:
Quoted 4 lines · James Bottomley

No, he means that kmap_atomic can only map a page of data. This makes single page only sg list entries and input assumption into this loop.
with ENABLE_CLUSTERING, that's potentially not true. Of course, this
accidentally works most of the time because of the way kmap functions.

Ah, right. I'm on the verge of releasing a ram-based scsi driver I've been working on ... this loop should work fine with clustering as it takes account of the sg potentially having multiple pages:

Quoted 7 lines
        scsi_for_each_sg(cmnd, sg, scsi_sg_count(cmnd), i) {
                struct page *sgpage = sg_page(sg);
                unsigned int to_off = sg->offset;
                unsigned int sg_copy = sg->length;
                if (sg_copy > len)
                        sg_copy = len;
                len -= sg_copy;
Quoted 5 lines

stex driver has a similar function to copies data between a buffer and a scatter list. I think that scsi_kmap_atomic_sg is a bit primitive (and not very popular). I'll send a patch to add a helper function to scsi_lib.c that copies data between a buffer and a scatter list. It would be useful for several drivers.

Actually, if you're going to sweep up them all, libata also does this.

However, mapping and copying data isn't a SCSI specific function, it's one any virtual block driver should do, so I think block might be the correct location for such a function.

James

#7 lore raw
Quoted 23 lines · On Sun, 17 Feb 2008 09:02:14 -0600 James Bottomley…
Quoted 21 lines · FUJITA Tomonori
Quoted 17 lines · On Sun, 17 Feb 2008 07:28:48 -0700 Matthew Wilcox <[email protected]> wrote:
Quoted 4 lines · James Bottomley

No, he means that kmap_atomic can only map a page of data. This makes single page only sg list entries and input assumption into this loop.
with ENABLE_CLUSTERING, that's potentially not true. Of course, this
accidentally works most of the time because of the way kmap functions.

Ah, right. I'm on the verge of releasing a ram-based scsi driver I've been working on ... this loop should work fine with clustering as it takes account of the sg potentially having multiple pages:

        scsi_for_each_sg(cmnd, sg, scsi_sg_count(cmnd), i) {
                struct page *sgpage = sg_page(sg);
                unsigned int to_off = sg->offset;
                unsigned int sg_copy = sg->length;
                if (sg_copy > len)
                        sg_copy = len;
                len -= sg_copy;
Quoted 7 lines
Quoted 5 lines

stex driver has a similar function to copies data between a buffer and a scatter list. I think that scsi_kmap_atomic_sg is a bit primitive (and not very popular). I'll send a patch to add a helper function to scsi_lib.c that copies data between a buffer and a scatter list. It would be useful for several drivers.

Actually, if you're going to sweep up them all, libata also does this.

Thanks, I'll look at it.

Quoted 3 lines

However, mapping and copying data isn't a SCSI specific function, it's one any virtual block driver should do, so I think block might be the correct location for such a function.

I see. It could go to lib/scatterlist.c or block/ I guess.

maintainer
#8 lore raw
Quoted 34 lines · FUJITA Tomonori
Quoted 23 lines · On Sun, 17 Feb 2008 09:02:14 -0600 James Bottomley…
Quoted 21 lines · FUJITA Tomonori
Quoted 17 lines · On Sun, 17 Feb 2008 07:28:48 -0700 Matthew Wilcox <[email protected]> wrote:
Quoted 4 lines · James Bottomley

No, he means that kmap_atomic can only map a page of data. This makes single page only sg list entries and input assumption into this loop.
with ENABLE_CLUSTERING, that's potentially not true. Of course, this
accidentally works most of the time because of the way kmap functions.

Ah, right. I'm on the verge of releasing a ram-based scsi driver I've been working on ... this loop should work fine with clustering as it takes account of the sg potentially having multiple pages:

        scsi_for_each_sg(cmnd, sg, scsi_sg_count(cmnd), i) {
                struct page *sgpage = sg_page(sg);
                unsigned int to_off = sg->offset;
                unsigned int sg_copy = sg->length;
                if (sg_copy > len)
                        sg_copy = len;
                len -= sg_copy;
Quoted 7 lines
Quoted 5 lines

stex driver has a similar function to copies data between a buffer and a scatter list. I think that scsi_kmap_atomic_sg is a bit primitive (and not very popular). I'll send a patch to add a helper function to scsi_lib.c that copies data between a buffer and a scatter list. It would be useful for several drivers.

Actually, if you're going to sweep up them all, libata also does this.

Quoted 8 lines

Thanks, I'll look at it.

Quoted 3 lines

However, mapping and copying data isn't a SCSI specific function, it's one any virtual block driver should do, so I think block might be the correct location for such a function.

I see. It could go to lib/scatterlist.c or block/ I guess.

Actually, lib/scatterlist is probably better.

James