mirror of
https://github.com/torvalds/linux.git
synced 2024-11-23 20:51:44 +00:00
scsi: sg: use standard lists for sg_requests
'Sg_request' is using a private list implementation; convert it to standard lists. Signed-off-by: Hannes Reinecke <hare@suse.com> Reviewed-by: Johannes Thumshirn <jthumshirn@suse.de> Tested-by: Johannes Thumshirn <jthumshirn@suse.de> Reviewed-by: Christoph Hellwig <hch@lst.de> Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
This commit is contained in:
Hannes Reinecke
Martin K. Petersen
parent
28676d869b
commit
109bade9c6
@ -122,7 +122,7 @@ struct sg_device; /* forward declarations */
|
||||
struct sg_fd;
|
||||
|
||||
typedef struct sg_request { /* SG_MAX_QUEUE requests outstanding per file */
|
||||
struct sg_request *nextrp; /* NULL -> tail request (slist) */
|
||||
struct list_head entry; /* list entry */
|
||||
struct sg_fd *parentfp; /* NULL -> not in use */
|
||||
Sg_scatter_hold data; /* hold buffer, perhaps scatter list */
|
||||
sg_io_hdr_t header; /* scsi command+info, see <scsi/sg.h> */
|
||||
@ -146,7 +146,7 @@ typedef struct sg_fd { /* holds the state of a file descriptor */
|
||||
int timeout; /* defaults to SG_DEFAULT_TIMEOUT */
|
||||
int timeout_user; /* defaults to SG_DEFAULT_TIMEOUT_USER */
|
||||
Sg_scatter_hold reserve; /* buffer held for this file descriptor */
|
||||
Sg_request *headrp; /* head of request slist, NULL->empty */
|
||||
struct list_head rq_list; /* head of request list */
|
||||
struct fasync_struct *async_qp; /* used by asynchronous notification */
|
||||
Sg_request req_arr[SG_MAX_QUEUE]; /* used as singly-linked list */
|
||||
char force_packid; /* 1 -> pack_id input to read(), 0 -> ignored */
|
||||
@ -949,7 +949,7 @@ sg_ioctl(struct file *filp, unsigned int cmd_in, unsigned long arg)
|
||||
if (!access_ok(VERIFY_WRITE, ip, sizeof (int)))
|
||||
return -EFAULT;
|
||||
read_lock_irqsave(&sfp->rq_list_lock, iflags);
|
||||
for (srp = sfp->headrp; srp; srp = srp->nextrp) {
|
||||
list_for_each_entry(srp, &sfp->rq_list, entry) {
|
||||
if ((1 == srp->done) && (!srp->sg_io_owned)) {
|
||||
read_unlock_irqrestore(&sfp->rq_list_lock,
|
||||
iflags);
|
||||
@ -962,7 +962,8 @@ sg_ioctl(struct file *filp, unsigned int cmd_in, unsigned long arg)
|
||||
return 0;
|
||||
case SG_GET_NUM_WAITING:
|
||||
read_lock_irqsave(&sfp->rq_list_lock, iflags);
|
||||
for (val = 0, srp = sfp->headrp; srp; srp = srp->nextrp) {
|
||||
val = 0;
|
||||
list_for_each_entry(srp, &sfp->rq_list, entry) {
|
||||
if ((1 == srp->done) && (!srp->sg_io_owned))
|
||||
++val;
|
||||
}
|
||||
@ -1035,35 +1036,33 @@ sg_ioctl(struct file *filp, unsigned int cmd_in, unsigned long arg)
|
||||
if (!rinfo)
|
||||
return -ENOMEM;
|
||||
read_lock_irqsave(&sfp->rq_list_lock, iflags);
|
||||
for (srp = sfp->headrp, val = 0; val < SG_MAX_QUEUE;
|
||||
++val, srp = srp ? srp->nextrp : srp) {
|
||||
val = 0;
|
||||
list_for_each_entry(srp, &sfp->rq_list, entry) {
|
||||
if (val > SG_MAX_QUEUE)
|
||||
break;
|
||||
memset(&rinfo[val], 0, SZ_SG_REQ_INFO);
|
||||
if (srp) {
|
||||
rinfo[val].req_state = srp->done + 1;
|
||||
rinfo[val].problem =
|
||||
srp->header.masked_status &
|
||||
srp->header.host_status &
|
||||
srp->header.driver_status;
|
||||
if (srp->done)
|
||||
rinfo[val].duration =
|
||||
srp->header.duration;
|
||||
else {
|
||||
ms = jiffies_to_msecs(jiffies);
|
||||
rinfo[val].duration =
|
||||
(ms > srp->header.duration) ?
|
||||
(ms - srp->header.duration) : 0;
|
||||
}
|
||||
rinfo[val].orphan = srp->orphan;
|
||||
rinfo[val].sg_io_owned =
|
||||
srp->sg_io_owned;
|
||||
rinfo[val].pack_id =
|
||||
srp->header.pack_id;
|
||||
rinfo[val].usr_ptr =
|
||||
srp->header.usr_ptr;
|
||||
rinfo[val].req_state = srp->done + 1;
|
||||
rinfo[val].problem =
|
||||
srp->header.masked_status &
|
||||
srp->header.host_status &
|
||||
srp->header.driver_status;
|
||||
if (srp->done)
|
||||
rinfo[val].duration =
|
||||
srp->header.duration;
|
||||
else {
|
||||
ms = jiffies_to_msecs(jiffies);
|
||||
rinfo[val].duration =
|
||||
(ms > srp->header.duration) ?
|
||||
(ms - srp->header.duration) : 0;
|
||||
}
|
||||
rinfo[val].orphan = srp->orphan;
|
||||
rinfo[val].sg_io_owned = srp->sg_io_owned;
|
||||
rinfo[val].pack_id = srp->header.pack_id;
|
||||
rinfo[val].usr_ptr = srp->header.usr_ptr;
|
||||
val++;
|
||||
}
|
||||
read_unlock_irqrestore(&sfp->rq_list_lock, iflags);
|
||||
result = __copy_to_user(p, rinfo,
|
||||
result = __copy_to_user(p, rinfo,
|
||||
SZ_SG_REQ_INFO * SG_MAX_QUEUE);
|
||||
result = result ? -EFAULT : 0;
|
||||
kfree(rinfo);
|
||||
@ -1169,7 +1168,7 @@ sg_poll(struct file *filp, poll_table * wait)
|
||||
return POLLERR;
|
||||
poll_wait(filp, &sfp->read_wait, wait);
|
||||
read_lock_irqsave(&sfp->rq_list_lock, iflags);
|
||||
for (srp = sfp->headrp; srp; srp = srp->nextrp) {
|
||||
list_for_each_entry(srp, &sfp->rq_list, entry) {
|
||||
/* if any read waiting, flag it */
|
||||
if ((0 == res) && (1 == srp->done) && (!srp->sg_io_owned))
|
||||
res = POLLIN | POLLRDNORM;
|
||||
@ -2063,7 +2062,7 @@ sg_get_rq_mark(Sg_fd * sfp, int pack_id)
|
||||
unsigned long iflags;
|
||||
|
||||
write_lock_irqsave(&sfp->rq_list_lock, iflags);
|
||||
for (resp = sfp->headrp; resp; resp = resp->nextrp) {
|
||||
list_for_each_entry(resp, &sfp->rq_list, entry) {
|
||||
/* look for requests that are ready + not SG_IO owned */
|
||||
if ((1 == resp->done) && (!resp->sg_io_owned) &&
|
||||
((-1 == pack_id) || (resp->header.pack_id == pack_id))) {
|
||||
@ -2081,70 +2080,45 @@ sg_add_request(Sg_fd * sfp)
|
||||
{
|
||||
int k;
|
||||
unsigned long iflags;
|
||||
Sg_request *resp;
|
||||
Sg_request *rp = sfp->req_arr;
|
||||
|
||||
write_lock_irqsave(&sfp->rq_list_lock, iflags);
|
||||
resp = sfp->headrp;
|
||||
if (!resp) {
|
||||
memset(rp, 0, sizeof (Sg_request));
|
||||
rp->parentfp = sfp;
|
||||
resp = rp;
|
||||
sfp->headrp = resp;
|
||||
} else {
|
||||
if (0 == sfp->cmd_q)
|
||||
resp = NULL; /* command queuing disallowed */
|
||||
else {
|
||||
for (k = 0; k < SG_MAX_QUEUE; ++k, ++rp) {
|
||||
if (!rp->parentfp)
|
||||
break;
|
||||
}
|
||||
if (k < SG_MAX_QUEUE) {
|
||||
memset(rp, 0, sizeof (Sg_request));
|
||||
rp->parentfp = sfp;
|
||||
while (resp->nextrp)
|
||||
resp = resp->nextrp;
|
||||
resp->nextrp = rp;
|
||||
resp = rp;
|
||||
} else
|
||||
resp = NULL;
|
||||
if (!list_empty(&sfp->rq_list)) {
|
||||
if (!sfp->cmd_q)
|
||||
goto out_unlock;
|
||||
|
||||
for (k = 0; k < SG_MAX_QUEUE; ++k, ++rp) {
|
||||
if (!rp->parentfp)
|
||||
break;
|
||||
}
|
||||
if (k >= SG_MAX_QUEUE)
|
||||
goto out_unlock;
|
||||
}
|
||||
if (resp) {
|
||||
resp->nextrp = NULL;
|
||||
resp->header.duration = jiffies_to_msecs(jiffies);
|
||||
}
|
||||
memset(rp, 0, sizeof (Sg_request));
|
||||
rp->parentfp = sfp;
|
||||
rp->header.duration = jiffies_to_msecs(jiffies);
|
||||
list_add_tail(&rp->entry, &sfp->rq_list);
|
||||
write_unlock_irqrestore(&sfp->rq_list_lock, iflags);
|
||||
return resp;
|
||||
return rp;
|
||||
out_unlock:
|
||||
write_unlock_irqrestore(&sfp->rq_list_lock, iflags);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/* Return of 1 for found; 0 for not found */
|
||||
static int
|
||||
sg_remove_request(Sg_fd * sfp, Sg_request * srp)
|
||||
{
|
||||
Sg_request *prev_rp;
|
||||
Sg_request *rp;
|
||||
unsigned long iflags;
|
||||
int res = 0;
|
||||
|
||||
if ((!sfp) || (!srp) || (!sfp->headrp))
|
||||
if (!sfp || !srp || list_empty(&sfp->rq_list))
|
||||
return res;
|
||||
write_lock_irqsave(&sfp->rq_list_lock, iflags);
|
||||
prev_rp = sfp->headrp;
|
||||
if (srp == prev_rp) {
|
||||
sfp->headrp = prev_rp->nextrp;
|
||||
prev_rp->parentfp = NULL;
|
||||
if (!list_empty(&srp->entry)) {
|
||||
list_del(&srp->entry);
|
||||
srp->parentfp = NULL;
|
||||
res = 1;
|
||||
} else {
|
||||
while ((rp = prev_rp->nextrp)) {
|
||||
if (srp == rp) {
|
||||
prev_rp->nextrp = rp->nextrp;
|
||||
rp->parentfp = NULL;
|
||||
res = 1;
|
||||
break;
|
||||
}
|
||||
prev_rp = rp;
|
||||
}
|
||||
}
|
||||
write_unlock_irqrestore(&sfp->rq_list_lock, iflags);
|
||||
return res;
|
||||
@ -2163,7 +2137,7 @@ sg_add_sfp(Sg_device * sdp)
|
||||
|
||||
init_waitqueue_head(&sfp->read_wait);
|
||||
rwlock_init(&sfp->rq_list_lock);
|
||||
|
||||
INIT_LIST_HEAD(&sfp->rq_list);
|
||||
kref_init(&sfp->f_ref);
|
||||
mutex_init(&sfp->f_mutex);
|
||||
sfp->timeout = SG_DEFAULT_TIMEOUT;
|
||||
@ -2202,10 +2176,13 @@ sg_remove_sfp_usercontext(struct work_struct *work)
|
||||
{
|
||||
struct sg_fd *sfp = container_of(work, struct sg_fd, ew.work);
|
||||
struct sg_device *sdp = sfp->parentdp;
|
||||
Sg_request *srp;
|
||||
|
||||
/* Cleanup any responses which were never read(). */
|
||||
while (sfp->headrp)
|
||||
sg_finish_rem_req(sfp->headrp);
|
||||
while (!list_empty(&sfp->rq_list)) {
|
||||
srp = list_first_entry(&sfp->rq_list, Sg_request, entry);
|
||||
sg_finish_rem_req(srp);
|
||||
}
|
||||
|
||||
if (sfp->reserve.bufflen > 0) {
|
||||
SCSI_LOG_TIMEOUT(6, sg_printk(KERN_INFO, sdp,
|
||||
@ -2608,7 +2585,7 @@ static int sg_proc_seq_show_devstrs(struct seq_file *s, void *v)
|
||||
/* must be called while holding sg_index_lock */
|
||||
static void sg_proc_debug_helper(struct seq_file *s, Sg_device * sdp)
|
||||
{
|
||||
int k, m, new_interface, blen, usg;
|
||||
int k, new_interface, blen, usg;
|
||||
Sg_request *srp;
|
||||
Sg_fd *fp;
|
||||
const sg_io_hdr_t *hp;
|
||||
@ -2628,13 +2605,11 @@ static void sg_proc_debug_helper(struct seq_file *s, Sg_device * sdp)
|
||||
seq_printf(s, " cmd_q=%d f_packid=%d k_orphan=%d closed=0\n",
|
||||
(int) fp->cmd_q, (int) fp->force_packid,
|
||||
(int) fp->keep_orphan);
|
||||
for (m = 0, srp = fp->headrp;
|
||||
srp != NULL;
|
||||
++m, srp = srp->nextrp) {
|
||||
list_for_each_entry(srp, &fp->rq_list, entry) {
|
||||
hp = &srp->header;
|
||||
new_interface = (hp->interface_id == '\0') ? 0 : 1;
|
||||
if (srp->res_used) {
|
||||
if (new_interface &&
|
||||
if (new_interface &&
|
||||
(SG_FLAG_MMAP_IO & hp->flags))
|
||||
cp = " mmap>> ";
|
||||
else
|
||||
@ -2665,7 +2640,7 @@ static void sg_proc_debug_helper(struct seq_file *s, Sg_device * sdp)
|
||||
seq_printf(s, "ms sgat=%d op=0x%02x\n", usg,
|
||||
(int) srp->data.cmd_opcode);
|
||||
}
|
||||
if (0 == m)
|
||||
if (list_empty(&fp->rq_list))
|
||||
seq_puts(s, " No requests active\n");
|
||||
read_unlock(&fp->rq_list_lock);
|
||||
}
|
||||
|
||||
Loading…
Reference in New Issue
Block a user