Lines Matching refs:raidPtr
110 rf_ConfigureDisks(RF_ShutdownList_t **listp, RF_Raid_t *raidPtr,
122 ret = rf_AllocDiskStructures(raidPtr, cfgPtr);
126 disks = raidPtr->Disks;
129 for (c = 0; c < raidPtr->numCol; c++) {
130 ret = rf_ConfigureDisk(raidPtr,
138 ret = raidfetch_component_label(raidPtr, c);
143 if (!rf_reasonable_label(&raidPtr->raid_cinfo[c].ci_label,0) && !force) {
165 raidPtr->status = rf_rs_degraded;
171 for (c = 0; c < raidPtr->numCol; c++) {
192 if (rf_CheckLabels( raidPtr, cfgPtr )) {
193 printf("raid%d: There were fatal errors\n", raidPtr->raidid);
196 raidPtr->raidid);
203 for (c = 0; c < raidPtr->numCol; c++) {
218 raidPtr->sectorsPerDisk = min_numblks;
219 raidPtr->logBytesPerSector = ffs(bs) - 1;
220 raidPtr->bytesPerSector = bs;
221 raidPtr->sectorMask = bs - 1;
226 rf_UnconfigureVnodes( raidPtr );
238 rf_ConfigureSpareDisks(RF_ShutdownList_t **listp, RF_Raid_t *raidPtr,
251 disks = &raidPtr->Disks[raidPtr->numCol];
252 for (i = 0; i < raidPtr->numSpare; i++) {
253 ret = rf_ConfigureDisk(raidPtr, &cfgPtr->spare_names[i][0],
254 &disks[i], raidPtr->numCol + i);
273 bs = 1 << raidPtr->logBytesPerSector;
274 for (i = 0; i < raidPtr->numSpare; i++) {
280 if (disks[i].numBlocks < raidPtr->sectorsPerDisk) {
283 raidPtr->sectorsPerDisk);
287 if (disks[i].numBlocks > raidPtr->sectorsPerDisk) {
290 raidPtr->sectorsPerDisk,
293 disks[i].numBlocks = raidPtr->sectorsPerDisk;
313 rf_UnconfigureVnodes( raidPtr );
319 rf_AllocDiskStructures(RF_Raid_t *raidPtr, RF_Config_t *cfgPtr)
322 size_t entries = raidPtr->numCol + RF_MAXSPARE;
326 raidPtr->Disks = RF_MallocAndAdd(
327 entries * sizeof(*raidPtr->Disks), raidPtr->cleanupList);
328 if (raidPtr->Disks == NULL) {
334 raidPtr->raid_cinfo = RF_MallocAndAdd(
335 entries * sizeof(*raidPtr->raid_cinfo), raidPtr->cleanupList);
336 if (raidPtr->raid_cinfo == NULL) {
341 raidPtr->abortRecon = RF_MallocAndAdd(
342 entries * sizeof(int), raidPtr->cleanupList);
343 if (raidPtr->abortRecon == NULL) {
351 rf_UnconfigureVnodes( raidPtr );
359 rf_AutoConfigureDisks(RF_Raid_t *raidPtr, RF_Config_t *cfgPtr,
377 ret = rf_AllocDiskStructures(raidPtr, cfgPtr);
381 disks = raidPtr->Disks;
406 for (c = 0; c < raidPtr->numCol; c++) {
474 raidPtr->raid_cinfo[c].ci_vp = ac->vp;
475 raidPtr->raid_cinfo[c].ci_dev = ac->dev;
477 memcpy(raidget_component_label(raidPtr, c),
509 raidPtr->serial_number = ac->clabel->serial_number;
539 raidPtr->status = rf_rs_degraded;
540 raidPtr->numFailures = numFailuresThisRow;
560 raidPtr->mod_counter = mod_counter;
563 raidPtr->parity_good = parity_good;
564 raidPtr->sectorsPerDisk = min_numblks;
565 raidPtr->logBytesPerSector = ffs(bs) - 1;
566 raidPtr
567 raidPtr->sectorMask = bs - 1;
572 rf_UnconfigureVnodes( raidPtr );
580 rf_ConfigureDisk(RF_Raid_t *raidPtr, char *bf, RF_RaidDisk_t *diskPtr,
598 raidPtr->raid_cinfo[col].ci_vp = NULL;
599 raidPtr->raid_cinfo[col].ci_dev = 0;
632 * If this raidPtr's bytesPerSector is zero, fill it in with this
636 if (raidPtr->bytesPerSector == 0)
637 raidPtr->bytesPerSector = diskPtr->blockSize;
640 raidPtr->raid_cinfo[col].ci_vp = vp;
641 raidPtr->raid_cinfo[col].ci_dev = vp->v_rdev;
657 rf_print_label_status(RF_Raid_t *raidPtr, int column, char *dev_name,
662 raidPtr->raidid, dev_name, column );
673 static int rf_check_label_vitals(RF_Raid_t *raidPtr, int row, int column,
697 if (raidPtr->numCol != ci_label->num_columns) {
710 rf_handle_hosed(RF_Raid_t *raidPtr, RF_Config_t *cfgPtr, int hosed_column,
720 if (again && raidPtr->Disks[hosed_column].status == rf_ds_failed)
723 raidPtr->Disks[hosed_column].status = rf_ds_failed;
724 raidPtr->numFailures++;
725 raidPtr->status = rf_rs_degraded;
736 rf_CheckLabels(RF_Raid_t *raidPtr, RF_Config_t *cfgPtr)
783 for (c = 0; c < raidPtr->numCol; c++) {
784 if (raidPtr->Disks[c].status != rf_ds_optimal)
786 ci_label = raidget_component_label(raidPtr, c);
823 printf("raid%d: Summary of serial numbers:\n", raidPtr->raidid);
827 printf("raid%d: Summary of mod counters:\n", raidPtr->raidid);
840 for (c = 0; c < raidPtr->numCol; c++) {
841 if (raidPtr->Disks[c].status != rf_ds_optimal)
843 ci_label = raidget_component_label(raidPtr, c);
850 rf_handle_hosed(raidPtr, cfgPtr, hosed_column,
866 raidPtr->serial_number = serial_number;
889 for (c = 0; c < raidPtr->numCol; c++) {
890 if (raidPtr->Disks[c].status != rf_ds_optimal)
893 ci_label = raidget_component_label(raidPtr, c);
908 rf_handle_hosed(raidPtr, cfgPtr, hosed_column,
920 raidPtr->mod_counter = mod_number;
933 raidPtr->raidid);
939 raidPtr->raidid);
943 for (c = 0; c < raidPtr->numCol; c++) {
944 if (raidPtr->Disks[c].status != rf_ds_optimal) {
955 for (c = 0; c < raidPtr->numCol; c++) {
957 ci_label = raidget_component_label(raidPtr, c);
961 raidPtr->raidid, dev_name);
963 rf_print_label_status( raidPtr, c, dev_name, ci_label);
964 if (rf_check_label_vitals( raidPtr, 0, c,
981 raidPtr->parity_good = parity_good;
987 rf_add_hot_spare(RF_Raid_t *raidPtr, RF_SingleComponent_t *sparePtr)
997 if (raidPtr->numSpare >= RF_MAXSPARE) {
998 RF_ERRORMSG1("Too many spares: %d\n", raidPtr->numSpare);
1002 rf_lock_mutex2(raidPtr->mutex);
1003 while (raidPtr->changing_components == 1) {
1004 rf_wait_cond2(raidPtr->changing_components_cv, raidPtr->mutex);
1006 raidPtr->changing_components = 1;
1007 rf_unlock_mutex2(raidPtr->mutex);
1010 disks = &raidPtr->Disks[raidPtr->numCol];
1012 spare_number = raidPtr->numSpare;
1014 ret = rf_ConfigureDisk(raidPtr, sparePtr->component_name,
1016 raidPtr->numCol + spare_number);
1023 rf_close_component(raidPtr, raidPtr->raid_cinfo[raidPtr->numCol+spare_number].ci_vp, 0);
1039 bs = 1 << raidPtr->logBytesPerSector;
1042 rf_close_component(raidPtr, raidPtr->raid_cinfo[raidPtr->numCol+spare_number].ci_vp, 0);
1046 if (disks[spare_number].numBlocks < raidPtr->sectorsPerDisk) {
1050 raidPtr->sectorsPerDisk);
1051 rf_close_component(raidPtr, raidPtr->raid_cinfo[raidPtr->numCol+spare_number].ci_vp, 0);
1056 raidPtr->sectorsPerDisk) {
1059 raidPtr->sectorsPerDisk,
1062 disks[spare_number].numBlocks = raidPtr->sectorsPerDisk;
1068 * spare_number can be lower than raidPtr->maxQueue (update)
1071 RF_ASSERT(spare_number <= raidPtr->maxQueue);
1073 spareQueues = &raidPtr->Queues[raidPtr->numCol];
1074 if (spare_number == raidPtr->maxQueue) {
1075 ret = rf_ConfigureDiskQueue(raidPtr, &spareQueues[spare_number],
1076 raidPtr->numCol + spare_number,
1077 raidPtr->qType,
1078 raidPtr->sectorsPerDisk,
1079 raidPtr->Disks[raidPtr->numCol +
1081 raidPtr->maxOutstanding,
1082 &raidPtr->shutdownList,
1083 raidPtr->cleanupList);
1086 rf_lock_mutex2(raidPtr->mutex);
1087 raidPtr->maxQueue++;
1088 rf_unlock_mutex2(raidPtr->mutex);
1095 rf_lock_mutex2(raidPtr->mutex);
1098 raidPtr->numSpare++;
1101 raidPtr->changing_components = 0;
1102 rf_signal_cond2(raidPtr->changing_components_cv);
1103 rf_unlock_mutex2(raidPtr->mutex);
1109 rf_remove_hot_spare(RF_Raid_t *raidPtr, RF_SingleComponent_t *sparePtr)
1117 spare_number = sparePtr->column - raidPtr->numCol;
1118 if (spare_number < 0 || spare_number > raidPtr->numSpare)
1121 rf_lock_mutex2(raidPtr->mutex);
1122 while (raidPtr->changing_components == 1) {
1123 rf_wait_cond2(raidPtr->changing_components_cv, raidPtr->mutex);
1125 raidPtr->changing_components = 1;
1126 rf_unlock_mutex2(raidPtr->mutex);
1128 rf_SuspendNewRequestsAndWait(raidPtr);
1130 disk = &raidPtr->Disks[raidPtr->numCol + spare_number];
1138 vp = raidPtr->raid_cinfo[raidPtr->numCol + spare_number].ci_vp;
1139 raidPtr->raid_cinfo[raidPtr->numCol + spare_number].ci_vp = NULL;
1140 raidPtr->raid_cinfo[raidPtr->numCol + spare_number].ci_dev = 0;
1149 rf_close_component(raidPtr, vp, 0);
1151 rf_lock_mutex2(raidPtr->mutex);
1155 for (i = raidPtr->numCol + spare_number; i < raidPtr->numCol+raidPtr->numSpare-1; i++) {
1157 rf_swap_components(raidPtr, i, i+1);
1160 raidPtr->numSpare--;
1161 rf_unlock_mutex2(raidPtr->mutex);
1163 rf_ResumeNewRequests(raidPtr);
1169 rf_lock_mutex2(raidPtr->mutex);
1170 raidPtr->changing_components = 0;
1171 rf_signal_cond2(raidPtr->changing_components_cv);
1172 rf_unlock_mutex2(raidPtr->mutex);
1181 raidPtr, RF_SingleComponent_t *component)
1188 if (col < 0 || col >= raidPtr->numCol)
1191 rf_lock_mutex2(raidPtr->mutex);
1192 while (raidPtr->changing_components == 1) {
1193 rf_wait_cond2(raidPtr->changing_components_cv, raidPtr->mutex);
1195 raidPtr->changing_components = 1;
1196 rf_unlock_mutex2(raidPtr->mutex);
1198 disk = &raidPtr->Disks[col];
1211 vp = raidPtr->raid_cinfo[col].ci_vp;
1212 raidPtr->raid_cinfo[col].ci_vp = NULL;
1213 raidPtr->raid_cinfo[col].ci_dev = 0;
1221 rf_close_component(raidPtr, vp, 0);
1225 rf_lock_mutex2(raidPtr->mutex);
1226 raidPtr->changing_components = 0;
1227 rf_signal_cond2(raidPtr->changing_components_cv);
1228 rf_unlock_mutex2(raidPtr->mutex);
1234 rf_remove_component(RF_Raid_t *raidPtr, RF_SingleComponent_t *component)
1238 if (col < 0 || col >= raidPtr->numCol + raidPtr->numSpare)
1241 if (col >= raidPtr->numCol)
1242 return rf_remove_hot_spare(raidPtr, component);
1244 return rf_delete_component(raidPtr, component);
1248 rf_incorporate_hot_spare(RF_Raid_t *raidPtr,
1259 rf_swap_components(RF_Raid_t *raidPtr, int a, int b)
1269 RF_ASSERT(raidPtr->accesses_suspended == 0);
1272 snprintf(tmpdevname, sizeof(tmpdevname), "%s", raidPtr->Disks[a].devname);
1273 snprintf(raidPtr->Disks[a].devname, sizeof(raidPtr->Disks[a].devname), "%s", raidPtr->Disks[b].devname);
1274 snprintf(raidPtr->Disks[b].devname, sizeof(raidPtr->Disks[b].devname), "%s", tmpdevname);
1277 tmp_ci_vp = raidPtr->raid_cinfo[a].ci_vp;
1278 raidPtr->raid_cinfo[a].ci_vp = raidPtr->raid_cinfo[b].ci_vp;
1279 raidPtr->raid_cinfo[b].ci_vp = tmp_ci_vp;
1282 tmp_ci_dev = raidPtr->raid_cinfo[a].ci_dev;
1283 raidPtr->raid_cinfo[a].ci_dev = raidPtr->raid_cinfo[b].ci_dev;
1284 raidPtr->raid_cinfo[b].ci_dev = tmp_ci_dev;
1287 tmp_dev = raidPtr->Disks[a].dev;
1288 raidPtr->Disks[a].dev = raidPtr->Disks[b].dev;
1289 raidPtr->Disks[b].dev = tmp_dev;
1292 tmp_ci_label = raidPtr->raid_cinfo[a].ci_label;
1293 raidPtr->raid_cinfo[a].ci_label = raidPtr->raid_cinfo[b].ci_label;
1294 raidPtr->raid_cinfo[b].ci_label = tmp_ci_label;
1297 tmp_status = raidPtr->Disks[a].status;
1298 raidPtr->Disks[a].status = raidPtr->Disks[b].status;
1299 raidPtr->Disks[b].status = tmp_status;
Indexes created Fri Oct 17 09:09:57 GMT 2025