redonkable
/
alistair23-linux
1
0
Fork 0
Code Releases Activity

[PATCH] Cleanup blk_rq_map_* interfaces 

Change the blk_rq_map_user() and blk_rq_map_kern() interface to require
a previously allocated request to be passed in. This is both more efficient
for multiple iterations of mapping data to the same request, and it is also
a much nicer API.

Signed-off-by: Jens Axboe <axboe@suse.de>
hifive-unleashed-5.1
Jens Axboe 2005-06-20 14:06:01 +02:00
parent b823825e8e
commit dd1cab95f3
4 changed files with 53 additions and 58 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

68
drivers/block/ll_rw_blk.c
View File

@ -2107,21 +2107,19 @@ EXPORT_SYMBOL(blk_insert_request);
* original bio must be passed back in to blk_rq_unmap_user() for proper
* unmapping.
*/
struct request *blk_rq_map_user(request_queue_t *q, int rw, void __user *ubuf,
unsigned int len)
int blk_rq_map_user(request_queue_t *q, struct request *rq, void __user *ubuf,
unsigned int len)
{
unsigned long uaddr;
struct request *rq;
struct bio *bio;
int reading;
if (len > (q->max_sectors << 9))
return ERR_PTR(-EINVAL);
if ((!len && ubuf) || (len && !ubuf))
return ERR_PTR(-EINVAL);
return -EINVAL;
if (!len || !ubuf)
return -EINVAL;
rq = blk_get_request(q, rw, __GFP_WAIT);
if (!rq)
return ERR_PTR(-ENOMEM);
reading = rq_data_dir(rq) == READ;
/*
* if alignment requirement is satisfied, map in user pages for
@ -2129,9 +2127,9 @@ struct request *blk_rq_map_user(request_queue_t *q, int rw, void __user *ubuf,
*/
uaddr = (unsigned long) ubuf;
if (!(uaddr & queue_dma_alignment(q)) && !(len & queue_dma_alignment(q)))
bio = bio_map_user(q, NULL, uaddr, len, rw == READ);
bio = bio_map_user(q, NULL, uaddr, len, reading);
else
bio = bio_copy_user(q, uaddr, len, rw == READ);
bio = bio_copy_user(q, uaddr, len, reading);
if (!IS_ERR(bio)) {
rq->bio = rq->biotail = bio;
@ -2139,14 +2137,13 @@ struct request *blk_rq_map_user(request_queue_t *q, int rw, void __user *ubuf,
rq->buffer = rq->data = NULL;
rq->data_len = len;
return rq;
return 0;
}
/*
* bio is the err-ptr
*/
blk_put_request(rq);
return (struct request *) bio;
return PTR_ERR(bio);
}
EXPORT_SYMBOL(blk_rq_map_user);
@ -2160,7 +2157,7 @@ EXPORT_SYMBOL(blk_rq_map_user);
* Description:
* Unmap a request previously mapped by blk_rq_map_user().
*/
int blk_rq_unmap_user(struct request *rq, struct bio *bio, unsigned int ulen)
int blk_rq_unmap_user(struct bio *bio, unsigned int ulen)
{
int ret = 0;
@ -2171,8 +2168,7 @@ int blk_rq_unmap_user(struct request *rq, struct bio *bio, unsigned int ulen)
ret = bio_uncopy_user(bio);
}
blk_put_request(rq);
return ret;
return 0;
}
EXPORT_SYMBOL(blk_rq_unmap_user);
@ -2184,39 +2180,29 @@ EXPORT_SYMBOL(blk_rq_unmap_user);
* @kbuf: the kernel buffer
* @len: length of user data
*/
struct request *blk_rq_map_kern(request_queue_t *q, int rw, void *kbuf,
unsigned int len, unsigned int gfp_mask)
int blk_rq_map_kern(request_queue_t *q, struct request *rq, void *kbuf,
unsigned int len, unsigned int gfp_mask)
{
struct request *rq;
struct bio *bio;
if (len > (q->max_sectors << 9))
return ERR_PTR(-EINVAL);
if ((!len && kbuf) || (len && !kbuf))
return ERR_PTR(-EINVAL);
rq = blk_get_request(q, rw, gfp_mask);
if (!rq)
return ERR_PTR(-ENOMEM);
return -EINVAL;
if (!len || !kbuf)
return -EINVAL;
bio = bio_map_kern(q, kbuf, len, gfp_mask);
if (!IS_ERR(bio)) {
if (rw)
bio->bi_rw |= (1 << BIO_RW);
if (IS_ERR(bio))
return PTR_ERR(bio);
rq->bio = rq->biotail = bio;
blk_rq_bio_prep(q, rq, bio);
if (rq_data_dir(rq) == WRITE)
bio->bi_rw |= (1 << BIO_RW);
rq->buffer = rq->data = NULL;
rq->data_len = len;
return rq;
}
rq->bio = rq->biotail = bio;
blk_rq_bio_prep(q, rq, bio);
/*
* bio is the err-ptr
*/
blk_put_request(rq);
return (struct request *) bio;
rq->buffer = rq->data = NULL;
rq->data_len = len;
return 0;
}
EXPORT_SYMBOL(blk_rq_map_kern);

23
drivers/block/scsi_ioctl.c
View File

@ -216,7 +216,7 @@ static int sg_io(struct file *file, request_queue_t *q,
struct gendisk *bd_disk, struct sg_io_hdr *hdr)
{
unsigned long start_time;
int reading, writing;
int reading, writing, ret;
struct request *rq;
struct bio *bio;
char sense[SCSI_SENSE_BUFFERSIZE];
@ -255,14 +255,17 @@ static int sg_io(struct file *file, request_queue_t *q,
reading = 1;
break;
}
}
rq = blk_rq_map_user(q, writing ? WRITE : READ, hdr->dxferp,
hdr->dxfer_len);
rq = blk_get_request(q, writing ? WRITE : READ, GFP_KERNEL);
if (!rq)
return -ENOMEM;
if (IS_ERR(rq))
return PTR_ERR(rq);
} else
rq = blk_get_request(q, READ, __GFP_WAIT);
if (reading || writing) {
ret = blk_rq_map_user(q, rq, hdr->dxferp, hdr->dxfer_len);
if (ret)
goto out;
}
/*
* fill in request structure
@ -321,11 +324,13 @@ static int sg_io(struct file *file, request_queue_t *q,
}
if (blk_rq_unmap_user(rq, bio, hdr->dxfer_len))
return -EFAULT;
ret = -EFAULT;
/* may not have succeeded, but output values written to control
* structure (struct sg_io_hdr). */
return 0;
out:
blk_put_request(rq);
return ret;
}
#define OMAX_SB_LEN 16 /* For backward compatibility */

13
drivers/cdrom/cdrom.c
View File

@ -2097,6 +2097,10 @@ static int cdrom_read_cdda_bpc(struct cdrom_device_info *cdi, __u8 __user *ubuf,
if (!q)
return -ENXIO;
rq = blk_get_request(q, READ, GFP_KERNEL);
if (!rq)
return -ENOMEM;
cdi->last_sense = 0;
while (nframes) {
@ -2108,9 +2112,9 @@ static int cdrom_read_cdda_bpc(struct cdrom_device_info *cdi, __u8 __user *ubuf,
len = nr * CD_FRAMESIZE_RAW;
rq = blk_rq_map_user(q, READ, ubuf, len);
if (IS_ERR(rq))
return PTR_ERR(rq);
ret = blk_rq_map_user(q, rq, ubuf, len);
if (ret)
break;
memset(rq->cmd, 0, sizeof(rq->cmd));
rq->cmd[0] = GPCMD_READ_CD;
@ -2138,7 +2142,7 @@ static int cdrom_read_cdda_bpc(struct cdrom_device_info *cdi, __u8 __user *ubuf,
cdi->last_sense = s->sense_key;
}
if (blk_rq_unmap_user(rq, bio, len))
if (blk_rq_unmap_user(bio, len))
ret = -EFAULT;
if (ret)
@ -2149,6 +2153,7 @@ static int cdrom_read_cdda_bpc(struct cdrom_device_info *cdi, __u8 __user *ubuf,
ubuf += len;
}
blk_put_request(rq);
return ret;
}

7
include/linux/blkdev.h
View File

@ -558,10 +558,9 @@ extern void blk_sync_queue(struct request_queue *q);
extern void __blk_stop_queue(request_queue_t *q);
extern void blk_run_queue(request_queue_t *);
extern void blk_queue_activity_fn(request_queue_t *, activity_fn *, void *);
extern struct request *blk_rq_map_user(request_queue_t *, int, void __user *, unsigned int);
extern int blk_rq_unmap_user(struct request *, struct bio *, unsigned int);
extern struct request *blk_rq_map_kern(request_queue_t *, int, void *,
unsigned int, unsigned int);
extern int blk_rq_map_user(request_queue_t *, struct request *, void __user *, unsigned int);
extern int blk_rq_unmap_user(struct bio *, unsigned int);
extern int blk_rq_map_kern(request_queue_t *, struct request *, void *, unsigned int, unsigned int);
extern int blk_execute_rq(request_queue_t *, struct gendisk *, struct request *);
static inline request_queue_t *bdev_get_queue(struct block_device *bdev)