leandrof/linux
1
0
Fork 0
forked from Minki/linux
Code Issues Pull Requests Packages Projects Releases Wiki Activity

paride: convert pf to blk-mq

Browse Source 
Tested-by: Ondrej Zary <linux@rainbow-software.org>
Signed-off-by: Jens Axboe <axboe@kernel.dk>
This commit is contained in:
Jens Axboe 2018-10-15 08:38:08 -06:00
parent 99fe8b02a8
commit 77218ddf46
1 changed files with 42 additions and 14 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

56
drivers/block/paride/pf.c
View File

@ -152,7 +152,7 @@ enum {D_PRT, D_PRO, D_UNI, D_MOD, D_SLV, D_LUN, D_DLY};
#include <linux/hdreg.h> #include <linux/hdreg.h>
#include <linux/cdrom.h> #include <linux/cdrom.h>
#include <linux/spinlock.h> #include <linux/spinlock.h>
#include <linux/blkdev.h> #include <linux/blk-mq.h>
#include <linux/blkpg.h> #include <linux/blkpg.h>
#include <linux/mutex.h> #include <linux/mutex.h>
#include <linux/uaccess.h> #include <linux/uaccess.h>
@ -206,7 +206,8 @@ module_param_array(drive3, int, NULL, 0);
#define ATAPI_WRITE_10 0x2a #define ATAPI_WRITE_10 0x2a
static int pf_open(struct block_device *bdev, fmode_t mode); static int pf_open(struct block_device *bdev, fmode_t mode);
static void do_pf_request(struct request_queue * q); static blk_status_t pf_queue_rq(struct blk_mq_hw_ctx *hctx,
const struct blk_mq_queue_data *bd);
static int pf_ioctl(struct block_device *bdev, fmode_t mode, static int pf_ioctl(struct block_device *bdev, fmode_t mode,
unsigned int cmd, unsigned long arg); unsigned int cmd, unsigned long arg);
static int pf_getgeo(struct block_device *bdev, struct hd_geometry *geo); static int pf_getgeo(struct block_device *bdev, struct hd_geometry *geo);
@ -238,6 +239,8 @@ struct pf_unit {
int present; /* device present ? */ int present; /* device present ? */
char name[PF_NAMELEN]; /* pf0, pf1, ... */ char name[PF_NAMELEN]; /* pf0, pf1, ... */
struct gendisk *disk; struct gendisk *disk;
struct blk_mq_tag_set tag_set;
struct list_head rq_list;
}; };
static struct pf_unit units[PF_UNITS]; static struct pf_unit units[PF_UNITS];
@ -277,6 +280,10 @@ static const struct block_device_operations pf_fops = {
.check_events = pf_check_events, .check_events = pf_check_events,
}; };
static const struct blk_mq_ops pf_mq_ops = {
.queue_rq = pf_queue_rq,
};
static void __init pf_init_units(void) static void __init pf_init_units(void)
{ {
struct pf_unit *pf; struct pf_unit *pf;
@ -284,14 +291,22 @@ static void __init pf_init_units(void)
pf_drive_count = 0; pf_drive_count = 0;
for (unit = 0, pf = units; unit < PF_UNITS; unit++, pf++) { for (unit = 0, pf = units; unit < PF_UNITS; unit++, pf++) {
struct gendisk *disk = alloc_disk(1); struct gendisk *disk;
disk = alloc_disk(1);
if (!disk) if (!disk)
continue; continue;
disk->queue = blk_init_queue(do_pf_request, &pf_spin_lock);
if (!disk->queue) { disk->queue = blk_mq_init_sq_queue(&pf->tag_set, &pf_mq_ops,
1, BLK_MQ_F_SHOULD_MERGE);
if (IS_ERR(disk->queue)) {
put_disk(disk); put_disk(disk);
return; disk->queue = NULL;
continue;
} }
INIT_LIST_HEAD(&pf->rq_list);
disk->queue->queuedata = pf;
blk_queue_max_segments(disk->queue, cluster); blk_queue_max_segments(disk->queue, cluster);
blk_queue_bounce_limit(disk->queue, BLK_BOUNCE_HIGH); blk_queue_bounce_limit(disk->queue, BLK_BOUNCE_HIGH);
pf->disk = disk; pf->disk = disk;
@ -784,18 +799,18 @@ static int pf_queue;
static int set_next_request(void) static int set_next_request(void)
{ {
struct pf_unit *pf; struct pf_unit *pf;
struct request_queue *q;
int old_pos = pf_queue; int old_pos = pf_queue;
do { do {
pf = &units[pf_queue]; pf = &units[pf_queue];
q = pf->present ? pf->disk->queue : NULL;
if (++pf_queue == PF_UNITS) if (++pf_queue == PF_UNITS)
pf_queue = 0; pf_queue = 0;
if (q) { if (pf->present && !list_empty(&pf->rq_list)) {
pf_req = blk_fetch_request(q); pf_req = list_first_entry(&pf->rq_list, struct request,
if (pf_req) queuelist);
break; list_del_init(&pf_req->queuelist);
blk_mq_start_request(pf_req);
break;
} }
} while (pf_queue != old_pos); } while (pf_queue != old_pos);
@ -804,8 +819,12 @@ static int set_next_request(void)
static void pf_end_request(blk_status_t err) static void pf_end_request(blk_status_t err)
{ {
if (pf_req && !__blk_end_request_cur(pf_req, err)) if (!pf_req)
return;
if (!blk_update_request(pf_req, err, blk_rq_cur_bytes(pf_req))) {
__blk_mq_end_request(pf_req, err);
pf_req = NULL; pf_req = NULL;
}
} }
static void pf_request(void) static void pf_request(void)
@ -842,9 +861,17 @@ repeat:
} }
} }
static void do_pf_request(struct request_queue *q) static blk_status_t pf_queue_rq(struct blk_mq_hw_ctx *hctx,
const struct blk_mq_queue_data *bd)
{ {
struct pf_unit *pf = hctx->queue->queuedata;
spin_lock_irq(&pf_spin_lock);
list_add_tail(&bd->rq->queuelist, &pf->rq_list);
pf_request(); pf_request();
spin_unlock_irq(&pf_spin_lock);
return BLK_STS_OK;
} }
static int pf_next_buf(void) static int pf_next_buf(void)
@ -1024,6 +1051,7 @@ static void __exit pf_exit(void)
continue; continue;
del_gendisk(pf->disk); del_gendisk(pf->disk);
blk_cleanup_queue(pf->disk->queue); blk_cleanup_queue(pf->disk->queue);
blk_mq_free_tag_set(&pf->tag_set);
put_disk(pf->disk); put_disk(pf->disk);
pi_release(pf->pi); pi_release(pf->pi);
} }