hollalinux
/
linux-sg2042
mirror of https://github.com/sophgo/linux-riscv.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

cciss: make rebuild_lun_table behave better 

This patch makes the rebuild_lun_table smart enough to not rip a logical
volume out from under the OS. Without this fix if a customer is running
hpacucli to monitor their storage the driver will blindly remove and re-add
the disks whenever the utility calls the CCISS_REGNEWD ioctl. Unfortunately,
both hpacucli and ACUXE call the ioctl repeatedly. Customers have reported
IO coming to a standstill. Calling the ioctl is the problem, this patch is
the fix.

Signed-off-by: Stephen M. Cameron <scameron@beardog.cca.cpqcorp.net>
Signed-off-by: Mike Miller <mike.miller@hp.com>
Signed-off-by: Jens Axboe <jens.axboe@oracle.com>
This commit is contained in:
Mike Miller 2008-08-04 11:54:51 +02:00 committed by Jens Axboe
parent f7108f91cd
commit a72da29b6c
2 changed files with 216 additions and 122 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

336
drivers/block/cciss.c
View File

@ -1330,13 +1330,46 @@ static void cciss_softirq_done(struct request *rq)
spin_unlock_irqrestore(&h->lock, flags); spin_unlock_irqrestore(&h->lock, flags);
} }
/* This function gets the serial number of a logical drive via
* inquiry page 0x83. Serial no. is 16 bytes. If the serial
* number cannot be had, for whatever reason, 16 bytes of 0xff
* are returned instead.
*/
static void cciss_get_serial_no(int ctlr, int logvol, int withirq,
unsigned char *serial_no, int buflen)
{
#define PAGE_83_INQ_BYTES 64
int rc;
unsigned char *buf;
if (buflen > 16)
buflen = 16;
memset(serial_no, 0xff, buflen);
buf = kzalloc(PAGE_83_INQ_BYTES, GFP_KERNEL);
if (!buf)
return;
memset(serial_no, 0, buflen);
if (withirq)
rc = sendcmd_withirq(CISS_INQUIRY, ctlr, buf,
PAGE_83_INQ_BYTES, 1, logvol, 0x83, TYPE_CMD);
else
rc = sendcmd(CISS_INQUIRY, ctlr, buf,
PAGE_83_INQ_BYTES, 1, logvol, 0x83, NULL, TYPE_CMD);
if (rc == IO_OK)
memcpy(serial_no, &buf[8], buflen);
kfree(buf);
return;
}
/* This function will check the usage_count of the drive to be updated/added. /* This function will check the usage_count of the drive to be updated/added.
* If the usage_count is zero then the drive information will be updated and * If the usage_count is zero and it is a heretofore unknown drive, or,
* the disk will be re-registered with the kernel. If not then it will be * the drive's capacity, geometry, or serial number has changed,
* left alone for the next reboot. The exception to this is disk 0 which * then the drive information will be updated and the disk will be
* will always be left registered with the kernel since it is also the * re-registered with the kernel. If these conditions don't hold,
* controller node. Any changes to disk 0 will show up on the next * then it will be left alone for the next reboot. The exception to this
* reboot. * is disk 0 which will always be left registered with the kernel since it
* is also the controller node. Any changes to disk 0 will show up on
* the next reboot.
*/ */
static void cciss_update_drive_info(int ctlr, int drv_index) static void cciss_update_drive_info(int ctlr, int drv_index)
{ {
@ -1347,9 +1380,65 @@ static void cciss_update_drive_info(int ctlr, int drv_index)
sector_t total_size; sector_t total_size;
unsigned long flags = 0; unsigned long flags = 0;
int ret = 0; int ret = 0;
drive_info_struct *drvinfo;
/* Get information about the disk and modify the driver structure */
inq_buff = kmalloc(sizeof(InquiryData_struct), GFP_KERNEL);
drvinfo = kmalloc(sizeof(*drvinfo), GFP_KERNEL);
if (inq_buff == NULL || drvinfo == NULL)
goto mem_msg;
/* testing to see if 16-byte CDBs are already being used */
if (h->cciss_read == CCISS_READ_16) {
cciss_read_capacity_16(h->ctlr, drv_index, 1,
&total_size, &block_size);
} else {
cciss_read_capacity(ctlr, drv_index, 1,
&total_size, &block_size);
/* if read_capacity returns all F's this volume is >2TB */
/* in size so we switch to 16-byte CDB's for all */
/* read/write ops */
if (total_size == 0xFFFFFFFFULL) {
cciss_read_capacity_16(ctlr, drv_index, 1,
&total_size, &block_size);
h->cciss_read = CCISS_READ_16;
h->cciss_write = CCISS_WRITE_16;
} else {
h->cciss_read = CCISS_READ_10;
h->cciss_write = CCISS_WRITE_10;
}
}
cciss_geometry_inquiry(ctlr, drv_index, 1, total_size, block_size,
inq_buff, drvinfo);
drvinfo->block_size = block_size;
drvinfo->nr_blocks = total_size + 1;
cciss_get_serial_no(ctlr, drv_index, 1, drvinfo->serial_no,
sizeof(drvinfo->serial_no));
/* Is it the same disk we already know, and nothing's changed? */
if (h->drv[drv_index].raid_level != -1 &&
((memcmp(drvinfo->serial_no,
h->drv[drv_index].serial_no, 16) == 0) &&
drvinfo->block_size == h->drv[drv_index].block_size &&
drvinfo->nr_blocks == h->drv[drv_index].nr_blocks &&
drvinfo->heads == h->drv[drv_index].heads &&
drvinfo->sectors == h->drv[drv_index].sectors &&
drvinfo->cylinders == h->drv[drv_index].cylinders)) {
/* The disk is unchanged, nothing to update */
goto freeret;
}
/* Not the same disk, or something's changed, so we need to */
/* deregister it, and re-register it, if it's not in use. */
/* if the disk already exists then deregister it before proceeding */ /* if the disk already exists then deregister it before proceeding */
if (h->drv[drv_index].raid_level != -1) { /* (unless it's the first disk (for the controller node). */
if (h->drv[drv_index].raid_level != -1 && drv_index != 0) {
printk(KERN_WARNING "disk %d has changed.\n", drv_index);
spin_lock_irqsave(CCISS_LOCK(h->ctlr), flags); spin_lock_irqsave(CCISS_LOCK(h->ctlr), flags);
h->drv[drv_index].busy_configuring = 1; h->drv[drv_index].busy_configuring = 1;
spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags); spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
@ -1364,43 +1453,23 @@ static void cciss_update_drive_info(int ctlr, int drv_index)
/* If the disk is in use return */ /* If the disk is in use return */
if (ret) if (ret)
return; goto freeret;
/* Get information about the disk and modify the driver structure */ /* Save the new information from cciss_geometry_inquiry */
inq_buff = kmalloc(sizeof(InquiryData_struct), GFP_KERNEL); /* and serial number inquiry. */
if (inq_buff == NULL) h->drv[drv_index].block_size = drvinfo->block_size;
goto mem_msg; h->drv[drv_index].nr_blocks = drvinfo->nr_blocks;
h->drv[drv_index].heads = drvinfo->heads;
/* testing to see if 16-byte CDBs are already being used */ h->drv[drv_index].sectors = drvinfo->sectors;
if (h->cciss_read == CCISS_READ_16) { h->drv[drv_index].cylinders = drvinfo->cylinders;
cciss_read_capacity_16(h->ctlr, drv_index, 1, h->drv[drv_index].raid_level = drvinfo->raid_level;
&total_size, &block_size); memcpy(h->drv[drv_index].serial_no, drvinfo->serial_no, 16);
goto geo_inq;
}
cciss_read_capacity(ctlr, drv_index, 1,
&total_size, &block_size);
/* if read_capacity returns all F's this volume is >2TB in size */
/* so we switch to 16-byte CDB's for all read/write ops */
if (total_size == 0xFFFFFFFFULL) {
cciss_read_capacity_16(ctlr, drv_index, 1,
&total_size, &block_size);
h->cciss_read = CCISS_READ_16;
h->cciss_write = CCISS_WRITE_16;
} else {
h->cciss_read = CCISS_READ_10;
h->cciss_write = CCISS_WRITE_10;
}
geo_inq:
cciss_geometry_inquiry(ctlr, drv_index, 1, total_size, block_size,
inq_buff, &h->drv[drv_index]);
++h->num_luns; ++h->num_luns;
disk = h->gendisk[drv_index]; disk = h->gendisk[drv_index];
set_capacity(disk, h->drv[drv_index].nr_blocks); set_capacity(disk, h->drv[drv_index].nr_blocks);
/* if it's the controller it's already added */ /* if it's the controller (if drv_index == 0) it's already added */
if (drv_index) { if (drv_index) {
disk->queue = blk_init_queue(do_cciss_request, &h->lock); disk->queue = blk_init_queue(do_cciss_request, &h->lock);
sprintf(disk->disk_name, "cciss/c%dd%d", ctlr, drv_index); sprintf(disk->disk_name, "cciss/c%dd%d", ctlr, drv_index);
@ -1437,6 +1506,7 @@ geo_inq:
freeret: freeret:
kfree(inq_buff); kfree(inq_buff);
kfree(drvinfo);
return; return;
mem_msg: mem_msg:
printk(KERN_ERR "cciss: out of memory\n"); printk(KERN_ERR "cciss: out of memory\n");
@ -1478,7 +1548,6 @@ static int rebuild_lun_table(ctlr_info_t *h, struct gendisk *del_disk)
int ctlr = h->ctlr; int ctlr = h->ctlr;
int num_luns; int num_luns;
ReportLunData_struct *ld_buff = NULL; ReportLunData_struct *ld_buff = NULL;
drive_info_struct *drv = NULL;
int return_code; int return_code;
int listlength = 0; int listlength = 0;
int i; int i;
@ -1494,98 +1563,117 @@ static int rebuild_lun_table(ctlr_info_t *h, struct gendisk *del_disk)
return -EBUSY; return -EBUSY;
} }
h->busy_configuring = 1; h->busy_configuring = 1;
spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
/* if del_disk is NULL then we are being called to add a new disk if (!capable(CAP_SYS_RAWIO))
* and update the logical drive table. If it is not NULL then return -EPERM;
* we will check if the disk is in use or not.
*/
if (del_disk != NULL) {
drv = get_drv(del_disk);
drv->busy_configuring = 1;
spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
return_code = deregister_disk(del_disk, drv, 1);
drv->busy_configuring = 0;
h->busy_configuring = 0;
return return_code;
} else {
spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
if (!capable(CAP_SYS_RAWIO))
return -EPERM;
ld_buff = kzalloc(sizeof(ReportLunData_struct), GFP_KERNEL); ld_buff = kzalloc(sizeof(ReportLunData_struct), GFP_KERNEL);
if (ld_buff == NULL) if (ld_buff == NULL)
goto mem_msg; goto mem_msg;
return_code = sendcmd_withirq(CISS_REPORT_LOG, ctlr, ld_buff, return_code = sendcmd_withirq(CISS_REPORT_LOG, ctlr, ld_buff,
sizeof(ReportLunData_struct), 0, sizeof(ReportLunData_struct), 0,
0, 0, TYPE_CMD); 0, 0, TYPE_CMD);
if (return_code == IO_OK) { if (return_code == IO_OK)
listlength = listlength = be32_to_cpu(*(__be32 *) ld_buff->LUNListLength);
be32_to_cpu(*(__be32 *) ld_buff->LUNListLength); else { /* reading number of logical volumes failed */
} else { /* reading number of logical volumes failed */ printk(KERN_WARNING "cciss: report logical volume"
printk(KERN_WARNING "cciss: report logical volume" " command failed\n");
" command failed\n"); listlength = 0;
listlength = 0; goto freeret;
goto freeret; }
}
num_luns = listlength / 8; /* 8 bytes per entry */ num_luns = listlength / 8; /* 8 bytes per entry */
if (num_luns > CISS_MAX_LUN) { if (num_luns > CISS_MAX_LUN) {
num_luns = CISS_MAX_LUN; num_luns = CISS_MAX_LUN;
printk(KERN_WARNING "cciss: more luns configured" printk(KERN_WARNING "cciss: more luns configured"
" on controller than can be handled by" " on controller than can be handled by"
" this driver.\n"); " this driver.\n");
} }
/* Compare controller drive array to drivers drive array. /* Compare controller drive array to driver's drive array */
* Check for updates in the drive information and any new drives /* to see if any drives are missing on the controller due */
* on the controller. /* to action of Array Config Utility (user deletes drive) */
*/ /* and deregister logical drives which have disappeared. */
for (i = 0; i < num_luns; i++) { for (i = 0; i <= h->highest_lun; i++) {
int j; int j;
drv_found = 0;
drv_found = 0; for (j = 0; j < num_luns; j++) {
memcpy(&lunid, &ld_buff->LUN[j][0], 4);
lunid = (0xff & lunid = le32_to_cpu(lunid);
(unsigned int)(ld_buff->LUN[i][3])) << 24; if (h->drv[i].LunID == lunid) {
lunid |= (0xff & drv_found = 1;
(unsigned int)(ld_buff->LUN[i][2])) << 16; break;
lunid |= (0xff &
(unsigned int)(ld_buff->LUN[i][1])) << 8;
lunid |= 0xff & (unsigned int)(ld_buff->LUN[i][0]);
/* Find if the LUN is already in the drive array
* of the controller. If so then update its info
* if not is use. If it does not exist then find
* the first free index and add it.
*/
for (j = 0; j <= h->highest_lun; j++) {
if (h->drv[j].LunID == lunid) {
drv_index = j;
drv_found = 1;
}
} }
}
if (!drv_found) {
/* Deregister it from the OS, it's gone. */
spin_lock_irqsave(CCISS_LOCK(h->ctlr), flags);
h->drv[i].busy_configuring = 1;
spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
return_code = deregister_disk(h->gendisk[i],
&h->drv[i], 1);
h->drv[i].busy_configuring = 0;
}
}
/* check if the drive was found already in the array */ /* Compare controller drive array to driver's drive array.
if (!drv_found) { * Check for updates in the drive information and any new drives
drv_index = cciss_find_free_drive_index(ctlr); * on the controller due to ACU adding logical drives, or changing
if (drv_index == -1) * a logical drive's size, etc. Reregister any new/changed drives
goto freeret; */
for (i = 0; i < num_luns; i++) {
int j;
/*Check if the gendisk needs to be allocated */ drv_found = 0;
memcpy(&lunid, &ld_buff->LUN[i][0], 4);
lunid = le32_to_cpu(lunid);
/* Find if the LUN is already in the drive array
* of the driver. If so then update its info
* if not in use. If it does not exist then find
* the first free index and add it.
*/
for (j = 0; j <= h->highest_lun; j++) {
if (h->drv[j].raid_level != -1 &&
h->drv[j].LunID == lunid) {
drv_index = j;
drv_found = 1;
break;
}
}
/* check if the drive was found already in the array */
if (!drv_found) {
drv_index = cciss_find_free_drive_index(ctlr);
if (drv_index == -1)
goto freeret;
/*Check if the gendisk needs to be allocated */
if (!h->gendisk[drv_index]) {
h->gendisk[drv_index] =
alloc_disk(1 << NWD_SHIFT);
if (!h->gendisk[drv_index]){ if (!h->gendisk[drv_index]){
h->gendisk[drv_index] = alloc_disk(1 << NWD_SHIFT); printk(KERN_ERR "cciss: could not "
if (!h->gendisk[drv_index]){ "allocate new disk %d\n",
printk(KERN_ERR "cciss: could not allocate new disk %d\n", drv_index); drv_index);
goto mem_msg; goto mem_msg;
}
} }
} }
h->drv[drv_index].LunID = lunid; h->drv[drv_index].LunID = lunid;
cciss_update_drive_info(ctlr, drv_index);
} /* end for */ /* Don't need to mark this busy because nobody
} /* end else */ * else knows about this disk yet to contend
* for access to it.
*/
h->drv[drv_index].busy_configuring = 0;
wmb();
}
cciss_update_drive_info(ctlr, drv_index);
} /* end for */
freeret: freeret:
kfree(ld_buff); kfree(ld_buff);
@ -1597,6 +1685,7 @@ static int rebuild_lun_table(ctlr_info_t *h, struct gendisk *del_disk)
return -1; return -1;
mem_msg: mem_msg:
printk(KERN_ERR "cciss: out of memory\n"); printk(KERN_ERR "cciss: out of memory\n");
h->busy_configuring = 0;
goto freeret; goto freeret;
} }
@ -1652,15 +1741,15 @@ static int deregister_disk(struct gendisk *disk, drive_info_struct *drv,
* other than disk 0 we will call put_disk. We do not * other than disk 0 we will call put_disk. We do not
* do this for disk 0 as we need it to be able to * do this for disk 0 as we need it to be able to
* configure the controller. * configure the controller.
*/ */
if (clear_all){ if (clear_all){
/* This isn't pretty, but we need to find the /* This isn't pretty, but we need to find the
* disk in our array and NULL our the pointer. * disk in our array and NULL our the pointer.
* This is so that we will call alloc_disk if * This is so that we will call alloc_disk if
* this index is used again later. * this index is used again later.
*/ */
for (i=0; i < CISS_MAX_LUN; i++){ for (i=0; i < CISS_MAX_LUN; i++){
if(h->gendisk[i] == disk){ if (h->gendisk[i] == disk) {
h->gendisk[i] = NULL; h->gendisk[i] = NULL;
break; break;
} }
@ -1688,7 +1777,7 @@ static int deregister_disk(struct gendisk *disk, drive_info_struct *drv,
if (drv == h->drv + h->highest_lun) { if (drv == h->drv + h->highest_lun) {
/* if so, find the new hightest lun */ /* if so, find the new hightest lun */
int i, newhighest = -1; int i, newhighest = -1;
for (i = 0; i < h->highest_lun; i++) { for (i = 0; i <= h->highest_lun; i++) {
/* if the disk has size > 0, it is available */ /* if the disk has size > 0, it is available */
if (h->drv[i].heads) if (h->drv[i].heads)
newhighest = i; newhighest = i;
@ -3318,6 +3407,9 @@ geo_inq:
cciss_geometry_inquiry(cntl_num, i, 0, total_size, cciss_geometry_inquiry(cntl_num, i, 0, total_size,
block_size, inq_buff, block_size, inq_buff,
&hba[cntl_num]->drv[i]); &hba[cntl_num]->drv[i]);
cciss_get_serial_no(cntl_num, i, 0,
hba[cntl_num]->drv[i].serial_no,
sizeof(hba[cntl_num]->drv[i].serial_no));
} else { } else {
/* initialize raid_level to indicate a free space */ /* initialize raid_level to indicate a free space */
hba[cntl_num]->drv[i].raid_level = -1; hba[cntl_num]->drv[i].raid_level = -1;

2
drivers/block/cciss.h
View File

@ -39,6 +39,8 @@ typedef struct _drive_info_struct
*to prevent it from being opened or it's queue *to prevent it from being opened or it's queue
*from being started. *from being started.
*/ */
__u8 serial_no[16]; /* from inquiry page 0x83, */
/* not necc. null terminated. */
} drive_info_struct; } drive_info_struct;
#ifdef CONFIG_CISS_SCSI_TAPE #ifdef CONFIG_CISS_SCSI_TAPE