summaryrefslogtreecommitdiff
path: root/sys/dev
diff options
context:
space:
mode:
authoroster <oster@NetBSD.org>2000-01-08 01:52:42 +0000
committeroster <oster@NetBSD.org>2000-01-08 01:52:42 +0000
commitef979643a763f71dbb7f7d838cecd20c7acb7afa (patch)
treecbded5870f39633fa84d4e15db8fd4b06d0d51d3 /sys/dev
parent7a458244ef81331bb7ba5db0df6e71771079e1c4 (diff)
Replace raidPtrs[unit] with just raidPtr, and assign the former to the
later early on in raidioctl(). Code is easier to read now too.
Diffstat (limited to 'sys/dev')
-rw-r--r--sys/dev/raidframe/rf_netbsdkintf.c162
1 files changed, 80 insertions, 82 deletions
diff --git a/sys/dev/raidframe/rf_netbsdkintf.c b/sys/dev/raidframe/rf_netbsdkintf.c
index 40da5d3fc62..161fc0fb55d 100644
--- a/sys/dev/raidframe/rf_netbsdkintf.c
+++ b/sys/dev/raidframe/rf_netbsdkintf.c
@@ -1,4 +1,4 @@
-/* $NetBSD: rf_netbsdkintf.c,v 1.41 2000/01/08 01:37:37 oster Exp $ */
+/* $NetBSD: rf_netbsdkintf.c,v 1.42 2000/01/08 01:52:42 oster Exp $ */
/*-
* Copyright (c) 1996, 1997, 1998 The NetBSD Foundation, Inc.
* All rights reserved.
@@ -662,7 +662,7 @@ raidioctl(dev, cmd, data, flag, p)
int part, pmask;
struct raid_softc *rs;
RF_Config_t *k_cfg, *u_cfg;
- RF_Raid_t *raid;
+ RF_Raid_t *raidPtr;
RF_AccTotals_t *totals;
RF_DeviceConfig_t *d_cfg, **ucfgp;
u_char *specific_buf;
@@ -681,6 +681,7 @@ raidioctl(dev, cmd, data, flag, p)
if (unit >= numraid)
return (ENXIO);
rs = &raid_softc[unit];
+ raidPtr = raidPtrs[unit];
db1_printf(("raidioctl: %d %d %d %d\n", (int) dev,
(int) DISKPART(dev), (int) unit, (int) cmd));
@@ -737,7 +738,6 @@ raidioctl(dev, cmd, data, flag, p)
u_cfg = *((RF_Config_t **) data);
RF_Malloc(k_cfg, sizeof(RF_Config_t), (RF_Config_t *));
if (k_cfg == NULL) {
- db3_printf(("rf_ioctl: ENOMEM for config. Code is %d\n", retcode));
return (ENOMEM);
}
retcode = copyin((caddr_t) u_cfg, (caddr_t) k_cfg,
@@ -769,7 +769,8 @@ raidioctl(dev, cmd, data, flag, p)
k_cfg->layoutSpecificSize);
if (retcode) {
RF_Free(k_cfg, sizeof(RF_Config_t));
- RF_Free(specific_buf, k_cfg->layoutSpecificSize);
+ RF_Free(specific_buf,
+ k_cfg->layoutSpecificSize);
db3_printf(("rf_ioctl: retcode=%d copyin.2\n",
retcode));
return (retcode);
@@ -783,24 +784,24 @@ raidioctl(dev, cmd, data, flag, p)
/* configure the system */
- raidPtrs[unit]->raidid = unit;
+ raidPtr->raidid = unit;
- retcode = rf_Configure(raidPtrs[unit], k_cfg);
+ retcode = rf_Configure(raidPtr, k_cfg);
if (retcode == 0) {
/* allow this many simultaneous IO's to
this RAID device */
- raidPtrs[unit]->openings = RAIDOUTSTANDING;
+ raidPtr->openings = RAIDOUTSTANDING;
/* XXX should be moved to rf_Configure() */
- raidPtrs[unit]->copyback_in_progress = 0;
- raidPtrs[unit]->parity_rewrite_in_progress = 0;
- raidPtrs[unit]->recon_in_progress = 0;
+ raidPtr->copyback_in_progress = 0;
+ raidPtr->parity_rewrite_in_progress = 0;
+ raidPtr->recon_in_progress = 0;
- retcode = raidinit(dev, raidPtrs[unit], unit);
- rf_markalldirty( raidPtrs[unit] );
+ retcode = raidinit(dev, raidPtr, unit);
+ rf_markalldirty( raidPtr );
}
/* free the buffers. No return code here. */
if (k_cfg->layoutSpecificSize) {
@@ -833,7 +834,7 @@ raidioctl(dev, cmd, data, flag, p)
return (EBUSY);
}
- retcode = rf_Shutdown(raidPtrs[unit]);
+ retcode = rf_Shutdown(raidPtr);
pool_destroy(&rs->sc_cbufpool);
@@ -873,15 +874,15 @@ raidioctl(dev, cmd, data, flag, p)
row = component_label->row;
column = component_label->column;
- if ((row < 0) || (row >= raidPtrs[unit]->numRow) ||
- (column < 0) || (column >= raidPtrs[unit]->numCol)) {
+ if ((row < 0) || (row >= raidPtr->numRow) ||
+ (column < 0) || (column >= raidPtr->numCol)) {
RF_Free( component_label, sizeof(RF_ComponentLabel_t));
return(EINVAL);
}
raidread_component_label(
- raidPtrs[unit]->Disks[row][column].dev,
- raidPtrs[unit]->raid_cinfo[row][column].ci_vp,
+ raidPtr->Disks[row][column].dev,
+ raidPtr->raid_cinfo[row][column].ci_vp,
component_label );
retcode = copyout((caddr_t) component_label,
@@ -913,16 +914,16 @@ raidioctl(dev, cmd, data, flag, p)
row = component_label->row;
column = component_label->column;
- if ((row < 0) || (row >= raidPtrs[unit]->numRow) ||
- (column < 0) || (column >= raidPtrs[unit]->numCol)) {
+ if ((row < 0) || (row >= raidPtr->numRow) ||
+ (column < 0) || (column >= raidPtr->numCol)) {
return(EINVAL);
}
/* XXX this isn't allowed to do anything for now :-) */
#if 0
raidwrite_component_label(
- raidPtrs[unit]->Disks[row][column].dev,
- raidPtrs[unit]->raid_cinfo[row][column].ci_vp,
+ raidPtr->Disks[row][column].dev,
+ raidPtr->raid_cinfo[row][column].ci_vp,
component_label );
#endif
return (0);
@@ -936,23 +937,23 @@ raidioctl(dev, cmd, data, flag, p)
set.
*/
- raidPtrs[unit]->serial_number = component_label->serial_number;
+ raidPtr->serial_number = component_label->serial_number;
/* current version number */
ci_label.version = RF_COMPONENT_LABEL_VERSION;
ci_label.serial_number = component_label->serial_number;
- ci_label.mod_counter = raidPtrs[unit]->mod_counter;
- ci_label.num_rows = raidPtrs[unit]->numRow;
- ci_label.num_columns = raidPtrs[unit]->numCol;
+ ci_label.mod_counter = raidPtr->mod_counter;
+ ci_label.num_rows = raidPtr->numRow;
+ ci_label.num_columns = raidPtr->numCol;
ci_label.clean = RF_RAID_DIRTY; /* not clean */
ci_label.status = rf_ds_optimal; /* "It's good!" */
- for(row=0;row<raidPtrs[unit]->numRow;row++) {
+ for(row=0;row<raidPtr->numRow;row++) {
ci_label.row = row;
- for(column=0;column<raidPtrs[unit]->numCol;column++) {
+ for(column=0;column<raidPtr->numCol;column++) {
ci_label.column = column;
raidwrite_component_label(
- raidPtrs[unit]->Disks[row][column].dev,
- raidPtrs[unit]->raid_cinfo[row][column].ci_vp,
+ raidPtr->Disks[row][column].dev,
+ raidPtr->raid_cinfo[row][column].ci_vp,
&ci_label );
}
}
@@ -962,22 +963,22 @@ raidioctl(dev, cmd, data, flag, p)
/* initialize all parity */
case RAIDFRAME_REWRITEPARITY:
- if (raidPtrs[unit]->Layout.map->faultsTolerated == 0) {
+ if (raidPtr->Layout.map->faultsTolerated == 0) {
/* Parity for RAID 0 is trivially correct */
- raidPtrs[unit]->parity_good = RF_RAID_CLEAN;
+ raidPtr->parity_good = RF_RAID_CLEAN;
return(0);
}
- if (raidPtrs[unit]->parity_rewrite_in_progress == 1) {
+ if (raidPtr->parity_rewrite_in_progress == 1) {
/* Re-write is already in progress! */
return(EINVAL);
}
/* borrow the thread of the requesting process */
- retcode = RF_CREATE_THREAD(raidPtrs[unit]->parity_rewrite_thread,
+ retcode = RF_CREATE_THREAD(raidPtr->parity_rewrite_thread,
rf_RewriteParityThread,
- raidPtrs[unit],"raid_parity");
+ raidPtr,"raid_parity");
return (retcode);
@@ -985,7 +986,7 @@ raidioctl(dev, cmd, data, flag, p)
sparePtr = (RF_SingleComponent_t *) data;
memcpy( &hot_spare, sparePtr, sizeof(RF_SingleComponent_t));
printf("Adding spare\n");
- retcode = rf_add_hot_spare(raidPtrs[unit], &hot_spare);
+ retcode = rf_add_hot_spare(raidPtr, &hot_spare);
return(retcode);
case RAIDFRAME_REMOVE_HOT_SPARE:
@@ -993,12 +994,12 @@ raidioctl(dev, cmd, data, flag, p)
case RAIDFRAME_REBUILD_IN_PLACE:
- if (raidPtrs[unit]->Layout.map->faultsTolerated == 0) {
+ if (raidPtr->Layout.map->faultsTolerated == 0) {
/* Can't do this on a RAID 0!! */
return(EINVAL);
}
- if (raidPtrs[unit]->recon_in_progress == 1) {
+ if (raidPtr->recon_in_progress == 1) {
/* a reconstruct is already in progress! */
return(EINVAL);
}
@@ -1009,8 +1010,8 @@ raidioctl(dev, cmd, data, flag, p)
row = component.row;
column = component.column;
printf("Rebuild: %d %d\n",row, column);
- if ((row < 0) || (row >= raidPtrs[unit]->numRow) ||
- (column < 0) || (column >= raidPtrs[unit]->numCol)) {
+ if ((row < 0) || (row >= raidPtr->numRow) ||
+ (column < 0) || (column >= raidPtr->numCol)) {
return(EINVAL);
}
@@ -1018,19 +1019,17 @@ raidioctl(dev, cmd, data, flag, p)
if (rrcopy == NULL)
return(ENOMEM);
- rrcopy->raidPtr = (void *) raidPtrs[unit];
+ rrcopy->raidPtr = (void *) raidPtr;
rrcopy->row = row;
rrcopy->col = column;
- retcode = RF_CREATE_THREAD(raidPtrs[unit]->recon_thread,
+ retcode = RF_CREATE_THREAD(raidPtr->recon_thread,
rf_ReconstructInPlaceThread,
rrcopy,"raid_reconip");
return(retcode);
case RAIDFRAME_GET_INFO:
- raid = raidPtrs[unit];
-
- if (!raid->valid)
+ if (!raidPtr->valid)
return (ENODEV);
ucfgp = (RF_DeviceConfig_t **) data;
RF_Malloc(d_cfg, sizeof(RF_DeviceConfig_t),
@@ -1038,28 +1037,28 @@ raidioctl(dev, cmd, data, flag, p)
if (d_cfg == NULL)
return (ENOMEM);
bzero((char *) d_cfg, sizeof(RF_DeviceConfig_t));
- d_cfg->rows = raid->numRow;
- d_cfg->cols = raid->numCol;
- d_cfg->ndevs = raid->numRow * raid->numCol;
+ d_cfg->rows = raidPtr->numRow;
+ d_cfg->cols = raidPtr->numCol;
+ d_cfg->ndevs = raidPtr->numRow * raidPtr->numCol;
if (d_cfg->ndevs >= RF_MAX_DISKS) {
RF_Free(d_cfg, sizeof(RF_DeviceConfig_t));
return (ENOMEM);
}
- d_cfg->nspares = raid->numSpare;
+ d_cfg->nspares = raidPtr->numSpare;
if (d_cfg->nspares >= RF_MAX_DISKS) {
RF_Free(d_cfg, sizeof(RF_DeviceConfig_t));
return (ENOMEM);
}
- d_cfg->maxqdepth = raid->maxQueueDepth;
+ d_cfg->maxqdepth = raidPtr->maxQueueDepth;
d = 0;
for (i = 0; i < d_cfg->rows; i++) {
for (j = 0; j < d_cfg->cols; j++) {
- d_cfg->devs[d] = raid->Disks[i][j];
+ d_cfg->devs[d] = raidPtr->Disks[i][j];
d++;
}
}
for (j = d_cfg->cols, i = 0; i < d_cfg->nspares; i++, j++) {
- d_cfg->spares[i] = raid->Disks[0][j];
+ d_cfg->spares[i] = raidPtr->Disks[0][j];
}
retcode = copyout((caddr_t) d_cfg, (caddr_t) * ucfgp,
sizeof(RF_DeviceConfig_t));
@@ -1068,40 +1067,38 @@ raidioctl(dev, cmd, data, flag, p)
return (retcode);
case RAIDFRAME_CHECK_PARITY:
- *(int *) data = raidPtrs[unit]->parity_good;
+ *(int *) data = raidPtr->parity_good;
return (0);
case RAIDFRAME_RESET_ACCTOTALS:
- raid = raidPtrs[unit];
- bzero(&raid->acc_totals, sizeof(raid->acc_totals));
+ bzero(&raidPtr->acc_totals, sizeof(raidPtr->acc_totals));
return (0);
case RAIDFRAME_GET_ACCTOTALS:
totals = (RF_AccTotals_t *) data;
- raid = raidPtrs[unit];
- *totals = raid->acc_totals;
+ *totals = raidPtr->acc_totals;
return (0);
case RAIDFRAME_KEEP_ACCTOTALS:
- raidPtrs[unit]->keep_acc_totals = *(int *)data;
+ raidPtr->keep_acc_totals = *(int *)data;
return (0);
case RAIDFRAME_GET_SIZE:
- *(int *) data = raidPtrs[unit]->totalSectors;
+ *(int *) data = raidPtr->totalSectors;
return (0);
/* fail a disk & optionally start reconstruction */
case RAIDFRAME_FAIL_DISK:
- if (raidPtrs[unit]->Layout.map->faultsTolerated == 0) {
+ if (raidPtr->Layout.map->faultsTolerated == 0) {
/* Can't do this on a RAID 0!! */
return(EINVAL);
}
rr = (struct rf_recon_req *) data;
- if (rr->row < 0 || rr->row >= raidPtrs[unit]->numRow
- || rr->col < 0 || rr->col >= raidPtrs[unit]->numCol)
+ if (rr->row < 0 || rr->row >= raidPtr->numRow
+ || rr->col < 0 || rr->col >= raidPtr->numCol)
return (EINVAL);
printf("raid%d: Failing the disk: row: %d col: %d\n",
@@ -1113,9 +1110,9 @@ raidioctl(dev, cmd, data, flag, p)
if (rrcopy == NULL)
return(ENOMEM);
bcopy(rr, rrcopy, sizeof(*rr));
- rrcopy->raidPtr = (void *) raidPtrs[unit];
+ rrcopy->raidPtr = (void *) raidPtr;
- retcode = RF_CREATE_THREAD(raidPtrs[unit]->recon_thread,
+ retcode = RF_CREATE_THREAD(raidPtr->recon_thread,
rf_ReconThread,
rrcopy,"raid_recon");
return (0);
@@ -1124,53 +1121,54 @@ raidioctl(dev, cmd, data, flag, p)
* needs it, if any */
case RAIDFRAME_COPYBACK:
- if (raidPtrs[unit]->Layout.map->faultsTolerated == 0) {
+ if (raidPtr->Layout.map->faultsTolerated == 0) {
/* This makes no sense on a RAID 0!! */
return(EINVAL);
}
- if (raidPtrs[unit]->copyback_in_progress == 1) {
+ if (raidPtr->copyback_in_progress == 1) {
/* Copyback is already in progress! */
return(EINVAL);
}
- retcode = RF_CREATE_THREAD(raidPtrs[unit]->copyback_thread,
+ retcode = RF_CREATE_THREAD(raidPtr->copyback_thread,
rf_CopybackThread,
- raidPtrs[unit],"raid_copyback");
+ raidPtr,"raid_copyback");
return (retcode);
/* return the percentage completion of reconstruction */
case RAIDFRAME_CHECK_RECON_STATUS:
- if (raidPtrs[unit]->Layout.map->faultsTolerated == 0) {
+ if (raidPtr->Layout.map->faultsTolerated == 0) {
/* This makes no sense on a RAID 0 */
return(EINVAL);
}
row = 0; /* XXX we only consider a single row... */
- if (raidPtrs[unit]->status[row] != rf_rs_reconstructing)
+ if (raidPtr->status[row] != rf_rs_reconstructing)
*(int *) data = 100;
else
- *(int *) data = raidPtrs[unit]->reconControl[row]->percentComplete;
+ *(int *) data = raidPtr->reconControl[row]->percentComplete;
return (0);
case RAIDFRAME_CHECK_PARITYREWRITE_STATUS:
- if (raidPtrs[unit]->Layout.map->faultsTolerated == 0) {
+ if (raidPtr->Layout.map->faultsTolerated == 0) {
/* This makes no sense on a RAID 0 */
return(EINVAL);
}
- if (raidPtrs[unit]->parity_rewrite_in_progress == 1) {
- *(int *) data = 100 * raidPtrs[unit]->parity_rewrite_stripes_done / raidPtrs[unit]->Layout.numStripe;
+ if (raidPtr->parity_rewrite_in_progress == 1) {
+ *(int *) data = 100 * raidPtr->parity_rewrite_stripes_done / raidPtr->Layout.numStripe;
} else {
*(int *) data = 100;
}
return (0);
case RAIDFRAME_CHECK_COPYBACK_STATUS:
- if (raidPtrs[unit]->Layout.map->faultsTolerated == 0) {
+ if (raidPtr->Layout.map->faultsTolerated == 0) {
/* This makes no sense on a RAID 0 */
return(EINVAL);
}
- if (raidPtrs[unit]->copyback_in_progress == 1) {
- *(int *) data = 100 * raidPtrs[unit]->copyback_stripes_done / raidPtrs[unit]->Layout.numStripe;
+ if (raidPtr->copyback_in_progress == 1) {
+ *(int *) data = 100 * raidPtr->copyback_stripes_done /
+ raidPtr->Layout.numStripe;
} else {
*(int *) data = 100;
}
@@ -1183,7 +1181,7 @@ raidioctl(dev, cmd, data, flag, p)
* ioctl code is almost certainly wrong and evil. -- XXX XXX
* -- I should either compute the spare table in the kernel,
* or have a different -- XXX XXX -- interface (a different
- * character device) for delivering the table -- XXX */
+ * character device) for delivering the table -- XXX */
#if 0
case RAIDFRAME_SPARET_WAIT:
RF_LOCK_MUTEX(rf_sparet_wait_mutex);
@@ -1193,12 +1191,12 @@ raidioctl(dev, cmd, data, flag, p)
rf_sparet_wait_queue = rf_sparet_wait_queue->next;
RF_UNLOCK_MUTEX(rf_sparet_wait_mutex);
- *((RF_SparetWait_t *) data) = *waitreq; /* structure assignment */
+ /* structure assignment */
+ *((RF_SparetWait_t *) data) = *waitreq;
RF_Free(waitreq, sizeof(*waitreq));
return (0);
-
/* wakes up a process waiting on SPARET_WAIT and puts an error
* code in it that will cause the dameon to exit */
case RAIDFRAME_ABORT_SPARET_WAIT:
@@ -1216,7 +1214,7 @@ raidioctl(dev, cmd, data, flag, p)
case RAIDFRAME_SEND_SPARET:
/* install the spare table */
- retcode = rf_SetSpareTable(raidPtrs[unit], *(void **) data);
+ retcode = rf_SetSpareTable(raidPtr, *(void **) data);
/* respond to the requestor. the return status of the spare
* table installation is passed in the "fcol" field */
@@ -1236,7 +1234,7 @@ raidioctl(dev, cmd, data, flag, p)
}
- if (!raidPtrs[unit]->valid)
+ if (!raidPtr->valid)
return (EINVAL);
/*
@@ -1285,7 +1283,7 @@ raidioctl(dev, cmd, data, flag, p)
break;
case DIOCGDEFLABEL:
- raidgetdefaultlabel(raidPtrs[unit], rs,
+ raidgetdefaultlabel(raidPtr, rs,
(struct disklabel *) data);
break;