Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 8d01eddf authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge branch 'for-2.6.25' of git://git.kernel.dk/linux-2.6-block 

* 'for-2.6.25' of git://git.kernel.dk/linux-2.6-block:
  block: implement drain buffers
  __bio_clone: don't calculate hw/phys segment counts
  block: allow queue dma_alignment of zero
  blktrace: Add blktrace ioctls to SCSI generic devices
parents f0f00520 fa0ccd83

block/blktrace.c

+14 −10
Original line number Diff line number Diff line
@@ -235,7 +235,7 @@ static void blk_trace_cleanup(struct blk_trace *bt) 
	kfree(bt);

}



static int blk_trace_remove(struct request_queue *q)

int blk_trace_remove(struct request_queue *q)

{

	struct blk_trace *bt;
@@ -249,6 +249,7 @@ static int blk_trace_remove(struct request_queue *q) 


	return 0;

}

EXPORT_SYMBOL_GPL(blk_trace_remove);



static int blk_dropped_open(struct inode *inode, struct file *filp)

{
@@ -316,18 +317,17 @@ static struct rchan_callbacks blk_relay_callbacks = { 
/*

 * Setup everything required to start tracing

 */

int do_blk_trace_setup(struct request_queue *q, struct block_device *bdev,

int do_blk_trace_setup(struct request_queue *q, char *name, dev_t dev,

			struct blk_user_trace_setup *buts)

{

	struct blk_trace *old_bt, *bt = NULL;

	struct dentry *dir = NULL;

	char b[BDEVNAME_SIZE];

	int ret, i;



	if (!buts->buf_size || !buts->buf_nr)

		return -EINVAL;



	strcpy(buts->name, bdevname(bdev, b));

	strcpy(buts->name, name);



	/*

	 * some device names have larger paths - convert the slashes
@@ -352,7 +352,7 @@ int do_blk_trace_setup(struct request_queue *q, struct block_device *bdev, 
		goto err;



	bt->dir = dir;

	bt->dev = bdev->bd_dev;

	bt->dev = dev;

	atomic_set(&bt->dropped, 0);



	ret = -EIO;
@@ -399,7 +399,7 @@ int do_blk_trace_setup(struct request_queue *q, struct block_device *bdev, 
	return ret;

}



static int blk_trace_setup(struct request_queue *q, struct block_device *bdev,

int blk_trace_setup(struct request_queue *q, char *name, dev_t dev,

		    char __user *arg)

{

	struct blk_user_trace_setup buts;
@@ -409,7 +409,7 @@ static int blk_trace_setup(struct request_queue *q, struct block_device *bdev, 
	if (ret)

		return -EFAULT;



	ret = do_blk_trace_setup(q, bdev, &buts);

	ret = do_blk_trace_setup(q, name, dev, &buts);

	if (ret)

		return ret;
@@ -418,8 +418,9 @@ static int blk_trace_setup(struct request_queue *q, struct block_device *bdev, 


	return 0;

}

EXPORT_SYMBOL_GPL(blk_trace_setup);



static int blk_trace_startstop(struct request_queue *q, int start)

int blk_trace_startstop(struct request_queue *q, int start)

{

	struct blk_trace *bt;

	int ret;
@@ -452,6 +453,7 @@ static int blk_trace_startstop(struct request_queue *q, int start) 


	return ret;

}

EXPORT_SYMBOL_GPL(blk_trace_startstop);



/**

 * blk_trace_ioctl: - handle the ioctls associated with tracing
@@ -464,6 +466,7 @@ int blk_trace_ioctl(struct block_device *bdev, unsigned cmd, char __user *arg) 
{

	struct request_queue *q;

	int ret, start = 0;

	char b[BDEVNAME_SIZE];



	q = bdev_get_queue(bdev);

	if (!q)
@@ -473,7 +476,8 @@ int blk_trace_ioctl(struct block_device *bdev, unsigned cmd, char __user *arg) 


	switch (cmd) {

	case BLKTRACESETUP:

		ret = blk_trace_setup(q, bdev, arg);

		strcpy(b, bdevname(bdev, b));

		ret = blk_trace_setup(q, b, bdev->bd_dev, arg);

		break;

	case BLKTRACESTART:

		start = 1;

block/compat_ioctl.c

+4 −1
Original line number Diff line number Diff line
@@ -545,6 +545,7 @@ static int compat_blk_trace_setup(struct block_device *bdev, char __user *arg) 
	struct blk_user_trace_setup buts;

	struct compat_blk_user_trace_setup cbuts;

	struct request_queue *q;

	char b[BDEVNAME_SIZE];

	int ret;



	q = bdev_get_queue(bdev);
@@ -554,6 +555,8 @@ static int compat_blk_trace_setup(struct block_device *bdev, char __user *arg) 
	if (copy_from_user(&cbuts, arg, sizeof(cbuts)))

		return -EFAULT;



	strcpy(b, bdevname(bdev, b));



	buts = (struct blk_user_trace_setup) {

		.act_mask = cbuts.act_mask,

		.buf_size = cbuts.buf_size,
@@ -565,7 +568,7 @@ static int compat_blk_trace_setup(struct block_device *bdev, char __user *arg) 
	memcpy(&buts.name, &cbuts.name, 32);



	mutex_lock(&bdev->bd_mutex);

	ret = do_blk_trace_setup(q, bdev, &buts);

	ret = do_blk_trace_setup(q, b, bdev->bd_dev, &buts);

	mutex_unlock(&bdev->bd_mutex);

	if (ret)

		return ret;

block/elevator.c

+25 −1
Original line number Diff line number Diff line
@@ -741,7 +741,21 @@ struct request *elv_next_request(struct request_queue *q) 
			q->boundary_rq = NULL;

		}



		if ((rq->cmd_flags & REQ_DONTPREP) || !q->prep_rq_fn)

		if (rq->cmd_flags & REQ_DONTPREP)

			break;



		if (q->dma_drain_size && rq->data_len) {

			/*

			 * make sure space for the drain appears we

			 * know we can do this because max_hw_segments

			 * has been adjusted to be one fewer than the

			 * device can handle

			 */

			rq->nr_phys_segments++;

			rq->nr_hw_segments++;

		}



		if (!q->prep_rq_fn)

			break;



		ret = q->prep_rq_fn(q, rq);
@@ -754,6 +768,16 @@ struct request *elv_next_request(struct request_queue *q) 
			 * avoid resource deadlock.  REQ_STARTED will

			 * prevent other fs requests from passing this one.

			 */

			if (q->dma_drain_size && rq->data_len &&

			    !(rq->cmd_flags & REQ_DONTPREP)) {

				/*

				 * remove the space for the drain we added

				 * so that we don't add it again

				 */

				--rq->nr_phys_segments;

				--rq->nr_hw_segments;

			}



			rq = NULL;

			break;

		} else if (ret == BLKPREP_KILL) {

block/ll_rw_blk.c

+49 −0
Original line number Diff line number Diff line
@@ -720,6 +720,45 @@ void blk_queue_stack_limits(struct request_queue *t, struct request_queue *b) 


EXPORT_SYMBOL(blk_queue_stack_limits);



/**

 * blk_queue_dma_drain - Set up a drain buffer for excess dma.

 *

 * @q:  the request queue for the device

 * @buf:	physically contiguous buffer

 * @size:	size of the buffer in bytes

 *

 * Some devices have excess DMA problems and can't simply discard (or

 * zero fill) the unwanted piece of the transfer.  They have to have a

 * real area of memory to transfer it into.  The use case for this is

 * ATAPI devices in DMA mode.  If the packet command causes a transfer

 * bigger than the transfer size some HBAs will lock up if there

 * aren't DMA elements to contain the excess transfer.  What this API

 * does is adjust the queue so that the buf is always appended

 * silently to the scatterlist.

 *

 * Note: This routine adjusts max_hw_segments to make room for

 * appending the drain buffer.  If you call

 * blk_queue_max_hw_segments() or blk_queue_max_phys_segments() after

 * calling this routine, you must set the limit to one fewer than your

 * device can support otherwise there won't be room for the drain

 * buffer.

 */

int blk_queue_dma_drain(struct request_queue *q, void *buf,

				unsigned int size)

{

	if (q->max_hw_segments < 2 || q->max_phys_segments < 2)

		return -EINVAL;

	/* make room for appending the drain */

	--q->max_hw_segments;

	--q->max_phys_segments;

	q->dma_drain_buffer = buf;

	q->dma_drain_size = size;



	return 0;

}



EXPORT_SYMBOL_GPL(blk_queue_dma_drain);



/**

 * blk_queue_segment_boundary - set boundary rules for segment merging

 * @q:  the request queue for the device
@@ -1374,6 +1413,16 @@ int blk_rq_map_sg(struct request_queue *q, struct request *rq, 
		bvprv = bvec;

	} /* segments in rq */



	if (q->dma_drain_size) {

		sg->page_link &= ~0x02;

		sg = sg_next(sg);

		sg_set_page(sg, virt_to_page(q->dma_drain_buffer),

			    q->dma_drain_size,

			    ((unsigned long)q->dma_drain_buffer) &

			    (PAGE_SIZE - 1));

		nsegs++;

	}



	if (sg)

		sg_mark_end(sg);

drivers/scsi/sg.c

+12 −0
Original line number Diff line number Diff line
@@ -48,6 +48,7 @@ static int sg_version_num = 30534; /* 2 digits for each component */ 
#include <linux/blkdev.h>

#include <linux/delay.h>

#include <linux/scatterlist.h>

#include <linux/blktrace_api.h>



#include "scsi.h"

#include <scsi/scsi_dbg.h>
@@ -1067,6 +1068,17 @@ sg_ioctl(struct inode *inode, struct file *filp, 
	case BLKSECTGET:

		return put_user(sdp->device->request_queue->max_sectors * 512,

				ip);

	case BLKTRACESETUP:

		return blk_trace_setup(sdp->device->request_queue,

				       sdp->disk->disk_name,

				       sdp->device->sdev_gendev.devt,

				       (char *)arg);

	case BLKTRACESTART:

		return blk_trace_startstop(sdp->device->request_queue, 1);

	case BLKTRACESTOP:

		return blk_trace_startstop(sdp->device->request_queue, 0);

	case BLKTRACETEARDOWN:

		return blk_trace_remove(sdp->device->request_queue);

	default:

		if (read_only)

			return -EPERM;	/* don't know so take safe approach */