superbh, fractured blocks, and grouped io

diff -Nru a/drivers/block/elevator.c b/drivers/block/elevator.c
@@ -103,6 +103,8 @@
 			continue;
 		if (__rq->nr_sectors + count > max_sectors)
 			continue;
+		if (__rq->dont_merge)
+			continue;
 		if (__rq->sector + __rq->nr_sectors == bh->b_rsector) {
 			ret = ELEVATOR_BACK_MERGE;
 			*req = __rq;

@@ -163,6 +165,8 @@
 		if (__rq->nr_sectors + count > max_sectors)
 			continue;
 		if (__rq->waiting)
+			continue;
+		if (__rq->dont_merge)
 			continue;
 		if (__rq->sector + __rq->nr_sectors == bh->b_rsector) {
 			*req = __rq;

389 lines not on this page · raw message

diff -Nru a/drivers/ide/ide-probe.c b/drivers/ide/ide-probe.c
@@ -603,9 +603,15 @@
 static void ide_init_queue(ide_drive_t *drive)
 {
 	request_queue_t *q = &drive->queue;
+	int max_sectors = 128;
 
 	q->queuedata = HWGROUP(drive);
 	blk_init_queue(q, do_ide_request);
+
+	if (HWIF(drive)->chipset == ide_pdc4030)
+		max_sectors = 127;
+
+	blk_queue_superbh(q, max_sectors);
 
 	if (drive->media == ide_disk) {
 #ifdef CONFIG_BLK_DEV_ELEVATOR_NOOP

diff -Nru a/drivers/scsi/scsi.c b/drivers/scsi/scsi.c
@@ -198,6 +198,14 @@
 	blk_init_queue(q, scsi_request_fn);
 	blk_queue_headactive(q, 0);
 	q->queuedata = (void *) SDpnt;
+
+	q->max_segments = SHpnt->sg_tablesize;
+	blk_queue_superbh(q, SHpnt->max_sectors);
+
+	/*
+	 * FIXME: just for testing, needs to be based on real evidence
+	 */
+	blk_queue_grouped(q, SHpnt->max_sectors);
 }
 
 #ifdef MODULE

diff -Nru a/drivers/scsi/scsi_merge.c b/drivers/scsi/scsi_merge.c
@@ -810,11 +810,9 @@
 	/*
 	 * First we need to know how many scatter gather segments are needed.
 	 */
-	if (!sg_count_valid) {
+	count = req->nr_segments;
+	if (!sg_count_valid || req->seg_invalid)
 		count = __count_segments(req, use_clustering, dma_host, NULL);
-	} else {
-		count = req->nr_segments;
-	}
 
 	/*
 	 * If the dma pool is nearly empty, then queue a minimal request

diff -Nru a/fs/buffer.c b/fs/buffer.c
@@ -2220,7 +2220,7 @@
 	unsigned long	blocknr;
 	struct kiobuf *	iobuf = NULL;
 	struct page *	map;
-	struct buffer_head *tmp, **bhs = NULL;
+	struct buffer_head *tmp, **bhs = NULL, *bh_first, *bh_prev;
 
 	if (!nr)
 		return 0;

@@ -2241,6 +2241,7 @@
 	 * OK to walk down the iovec doing page IO on each page we find. 
 	 */
 	bufind = bhind = transferred = err = 0;
+	bh_first = bh_prev = NULL;
 	for (i = 0; i < nr; i++) {
 		iobuf = iovec[i];
 		offset = iobuf->offset;

@@ -2255,7 +2256,7 @@
 				err = -EFAULT;
 				goto finished;
 			}
-			
+
 			while (length > 0) {
 				blocknr = b[bufind++];
 				if (blocknr == -1UL) {

@@ -2272,6 +2273,9 @@
 				}
 				tmp = bhs[bhind++];
 
+				if (!bh_first)
+					bh_first = tmp;
+
 				tmp->b_size = size;
 				set_bh_page(tmp, map, offset);
 				tmp->b_this_page = tmp;

@@ -2280,6 +2284,7 @@
 				tmp->b_dev = dev;
 				tmp->b_blocknr = blocknr;
 				tmp->b_state = (1 << BH_Mapped) | (1 << BH_Lock) | (1 << BH_Req);
+				tmp->b_reqnext = NULL;
 
 				if (rw == WRITE) {
 					set_bit(BH_Uptodate, &tmp->b_state);

@@ -2288,11 +2293,21 @@
 					set_bit(BH_Uptodate, &tmp->b_state);
 
 				atomic_inc(&iobuf->io_count);
-				submit_bh(rw, tmp);
+
+				if (bh_prev)
+					bh_prev->b_reqnext = tmp;
+
+				bh_prev = tmp;
+
 				/* 
 				 * Wait for IO if we have got too much 
 				 */
 				if (bhind >= KIO_MAX_SECTORS) {
+submit_io:
+					/*
+					 * FIXME: use _grouped for atomic IO
+					 */
+					submit_bh_linked(rw, bh_first);
 					kiobuf_wait_for_io(iobuf); /* wake-one */
 					err = wait_kio(rw, bhind, bhs, size);
 					if (err >= 0)

@@ -2300,12 +2315,19 @@
 					else
 						goto finished;
 					bhind = 0;
+					bh_prev = bh_first = NULL;
 				}
 
 			skip_block:
 				length -= size;
 				offset += size;
 
+				/*
+				 * see if we need to submit the previous bit
+				 */
+				if ((blocknr == -1) && bhind)
+					goto submit_io;
+
 				if (offset >= PAGE_SIZE) {
 					offset = 0;
 					break;

@@ -2316,12 +2338,14 @@
 
 	/* Is there any IO still left to submit? */
 	if (bhind) {
+		/*
+		 * FIXME: use _grouped for atomic IO
+		 */
+		submit_bh_linked(rw, bh_first);
 		kiobuf_wait_for_io(iobuf); /* wake-one */
 		err = wait_kio(rw, bhind, bhs, size);
 		if (err >= 0)
 			transferred += err;
-		else
-			goto finished;
 	}
 
  finished:

diff -Nru a/include/linux/blkdev.h b/include/linux/blkdev.h
@@ -46,6 +46,9 @@
 	struct buffer_head * bh;
 	struct buffer_head * bhtail;
 	request_queue_t *q;
+
+	char dont_merge;
+	char seg_invalid;
 };
 
 #include <linux/elevator.h>

@@ -126,6 +129,22 @@
 	 */
 	char			head_active;
 
+	/*
+	 * max segments
+	 */
+	int			max_segments;
+
+	/*
+	 * The biggest "atomic" io chunk we can deal with, or 0 if not
+	 * supported.
+	 */
+	int			grouped_queue;
+
+	/*
+	 * The biggest superbh we can generate for this queue
+	 */
+	int			superbh_queue;
+
 	unsigned long		bounce_pfn;
 
 	/*

@@ -154,6 +173,12 @@
 {
 	struct page *page = bh->b_page;
 
+	/*
+	 * not a real bh
+	 */
+	if (test_bit(BH_Super, &bh->b_state))
+		return bh;
+
 #ifndef CONFIG_DISCONTIGMEM
 	if (page - mem_map <= q->bounce_pfn)
 #else

@@ -209,6 +234,8 @@
 extern void blk_init_queue(request_queue_t *, request_fn_proc *);
 extern void blk_cleanup_queue(request_queue_t *);
 extern void blk_queue_headactive(request_queue_t *, int);
+extern void blk_queue_grouped(request_queue_t *, int);
+extern void blk_queue_superbh(request_queue_t *, int);
 extern void blk_queue_make_request(request_queue_t *, make_request_fn *);
 extern void generic_unplug_device(void *);
 extern inline int blk_seg_merge_ok(struct buffer_head *, struct buffer_head *);

@@ -227,8 +254,7 @@
 
 #define MAX_SEGMENTS 128
 #define MAX_SECTORS 255
-
-#define PageAlignSize(size) (((size) + PAGE_SIZE -1) & PAGE_MASK)
+#define MAX_SUPERBH 65535	/* must fit info ->b_size right now */
 
 #define blkdev_entry_to_request(entry) list_entry((entry), struct request, queue)
 #define blkdev_entry_next_request(entry) blkdev_entry_to_request((entry)->next)

diff -Nru a/include/linux/fs.h b/include/linux/fs.h
@@ -220,7 +220,8 @@
 	BH_Wait_IO,	/* 1 if we should write out this buffer */
 	BH_Launder,	/* 1 if we can throttle on this buffer */
 	BH_JBD,		/* 1 if it has an attached journal_head */
-
+	BH_Super,	/* 1 if this is a superbh */
+	BH_Grouped,	/* 1 if this is a grouped submit */
 	BH_PrivateStart,/* not a state bit, but the first bit available
 			 * for private allocation by other entities
 			 */

@@ -283,6 +284,8 @@
 #define buffer_new(bh)		__buffer_state(bh,New)
 #define buffer_async(bh)	__buffer_state(bh,Async)
 #define buffer_launder(bh)	__buffer_state(bh,Launder)
+#define buffer_superbh(bh)	__buffer_state(bh,Super)
+#define buffer_grouped(bh)	__buffer_state(bh,Grouped)
 
 #define bh_offset(bh)		((unsigned long)(bh)->b_data & ~PAGE_MASK)
 

@@ -1377,6 +1380,8 @@
 extern struct buffer_head * getblk(kdev_t, int, int);
 extern void ll_rw_block(int, int, struct buffer_head * bh[]);
 extern void submit_bh(int, struct buffer_head *);
+extern int submit_bh_linked(int, struct buffer_head *);
+extern int submit_bh_grouped(int, struct buffer_head *);
 extern int is_read_only(kdev_t);
 extern void __brelse(struct buffer_head *);
 static inline void brelse(struct buffer_head *buf)