kernel: Remove some unused variables in RAID and disk drivers.
[dragonfly.git] / sys / dev / raid / vinum / vinumconfig.c
CommitLineData
984263bc
MD
1/*
2 * To do:
3 *
4 * Don't store drive configuration on the config DB: read each drive's header
5 * to decide where it is.
6 *
7 * Accept any old crap in the config_<foo> functions, and complain when
8 * we try to bring it up.
9 *
10 * When trying to bring volumes up, check that the complete address range
11 * is covered.
12 */
13/*-
14 * Copyright (c) 1997, 1998
15 * Nan Yang Computer Services Limited. All rights reserved.
16 *
17 * This software is distributed under the so-called ``Berkeley
18 * License'':
19 *
20 * Redistribution and use in source and binary forms, with or without
21 * modification, are permitted provided that the following conditions
22 * are met:
23 * 1. Redistributions of source code must retain the above copyright
24 * notice, this list of conditions and the following disclaimer.
25 * 2. Redistributions in binary form must reproduce the above copyright
26 * notice, this list of conditions and the following disclaimer in the
27 * documentation and/or other materials provided with the distribution.
28 * 3. All advertising materials mentioning features or use of this software
29 * must display the following acknowledgement:
30 * This product includes software developed by Nan Yang Computer
31 * Services Limited.
32 * 4. Neither the name of the Company nor the names of its contributors
33 * may be used to endorse or promote products derived from this software
34 * without specific prior written permission.
35 *
36 * This software is provided ``as is'', and any express or implied
37 * warranties, including, but not limited to, the implied warranties of
38 * merchantability and fitness for a particular purpose are disclaimed.
39 * In no event shall the company or contributors be liable for any
40 * direct, indirect, incidental, special, exemplary, or consequential
41 * damages (including, but not limited to, procurement of substitute
42 * goods or services; loss of use, data, or profits; or business
43 * interruption) however caused and on any theory of liability, whether
44 * in contract, strict liability, or tort (including negligence or
45 * otherwise) arising in any way out of the use of this software, even if
46 * advised of the possibility of such damage.
47 *
48 * $Id: vinumconfig.c,v 1.30 2000/05/01 09:45:50 grog Exp grog $
49 * $FreeBSD: src/sys/dev/vinum/vinumconfig.c,v 1.32.2.6 2002/02/03 00:43:35 grog Exp $
50 */
51
52#define STATIC static
53
f5d8307c 54#include <sys/udev.h>
1f2de5d4
MD
55#include "vinumhdr.h"
56#include "request.h"
984263bc
MD
57
58#define MAXTOKEN 64 /* maximum number of tokens in a line */
59
60/*
61 * We can afford the luxury of global variables here,
62 * since start_config ensures that these functions
63 * are single-threaded.
64 */
65
66/* These are indices in vinum_conf of the last-mentioned of each kind of object */
67static int current_drive; /* note the last drive we mention, for
68 * some defaults */
69static int current_plex; /* and the same for the last plex */
70static int current_volume; /* and the last volme */
71static struct _ioctl_reply *ioctl_reply; /* struct to return via ioctl */
72
d736a600
MD
73static void made_sd(struct sd *sd);
74static void made_vol(struct volume *vol);
75static void made_plex(struct plex *plex);
984263bc
MD
76
77/* These values are used by most of these routines, so set them as globals */
78static char *token[MAXTOKEN]; /* pointers to individual tokens */
79static int tokens; /* number of tokens */
80
81#define TOCONS 0x01
82#define TOTTY 0x02
83#define TOLOG 0x04
84
85struct putchar_arg {
86 int flags;
87 struct tty *tty;
88};
89
90#define MSG_MAX 1024 /* maximum length of a formatted message */
91/*
92 * Format an error message and return to the user in the reply.
93 * CARE: This routine is designed to be called only from the
94 * configuration routines, so it assumes it's the owner of
95 * the configuration lock, and unlocks it on exit
96 */
97void
98throw_rude_remark(int error, char *msg,...)
99{
e2565a42 100 __va_list ap;
984263bc
MD
101 char *text;
102 static int finishing; /* don't recurse */
103 int was_finishing;
104
105 if ((vinum_conf.flags & VF_LOCKED) == 0) /* bug catcher */
106 panic ("throw_rude_remark: called without config lock");
e2565a42 107 __va_start(ap, msg);
984263bc
MD
108 if ((ioctl_reply != NULL) /* we're called from the user */
109 &&(!(vinum_conf.flags & VF_READING_CONFIG))) { /* and not reading from disk: return msg */
110 /*
111 * We can't just format to ioctl_reply, since it
112 * may contain our input parameters
113 */
da655383 114 kvasnrprintf(&text, MSG_MAX, 10, msg, ap);
984263bc
MD
115 strcpy(ioctl_reply->msg, text);
116 ioctl_reply->error = error; /* first byte is the error number */
da655383 117 kvasfree(&text);
984263bc 118 } else {
e3869ec7 119 kprintf("vinum: ");
379210cb 120 kvprintf(msg, ap); /* print to the console */
e3869ec7 121 kprintf("\n");
984263bc 122 }
e2565a42 123 __va_end(ap);
984263bc
MD
124
125 if (vinum_conf.flags & VF_READING_CONFIG) { /* go through to the bitter end, */
126 if ((vinum_conf.flags & VF_READING_CONFIG) /* we're reading from disk, */
127 &&((daemon_options & daemon_noupdate) == 0)) {
128 log(LOG_NOTICE, "Disabling configuration updates\n");
129 daemon_options |= daemon_noupdate;
130 }
131 return;
132 }
133 /*
134 * We have a problem here: we want to unlock the
135 * configuration, which implies tidying up, but
136 * if we find an error while tidying up, we could
137 * recurse for ever. Use this kludge to only try
138 * once
139 */
140 was_finishing = finishing;
141 finishing = 1;
142 finish_config(was_finishing); /* unlock anything we may be holding */
143 finishing = was_finishing;
144 longjmp(command_fail, error);
145}
146
147/*
148 * Check a volume to see if the plex is already assigned to it.
149 * Return index in volume->plex, or -1 if not assigned
150 */
151int
152my_plex(int volno, int plexno)
153{
154 int i;
155 struct volume *vol;
156
157 vol = &VOL[volno]; /* point to volno */
158 for (i = 0; i < vol->plexes; i++)
159 if (vol->plex[i] == plexno)
160 return i;
161 return -1; /* not found */
162}
163
164/*
165 * Check a plex to see if the subdisk is already assigned to it.
166 * Return index in plex->sd, or -1 if not assigned
167 */
168int
169my_sd(int plexno, int sdno)
170{
171 int i;
172 struct plex *plex;
173
174 plex = &PLEX[plexno];
175 for (i = 0; i < plex->subdisks; i++)
176 if (plex->sdnos[i] == sdno)
177 return i;
178 return -1; /* not found */
179}
180
181/* Add plex to the volume if possible */
182int
183give_plex_to_volume(int volno, int plexno)
184{
185 struct volume *vol;
186 int i;
187
188 /*
189 * It's not an error for the plex to already
190 * belong to the volume, but we need to check a
191 * number of things to make sure it's done right.
192 * Some day.
193 */
194 if (my_plex(volno, plexno) >= 0)
195 return plexno; /* that's it */
196
197 vol = &VOL[volno]; /* point to volume */
198 if (vol->plexes == MAXPLEX) /* all plexes allocated */
199 throw_rude_remark(ENOSPC,
200 "Too many plexes for volume %s",
201 vol->name);
202 else if ((vol->plexes > 0) /* we have other plexes */
203 &&((vol->flags & VF_CONFIG_SETUPSTATE) == 0)) /* and we're not setting up state */
204 invalidate_subdisks(&PLEX[plexno], sd_stale); /* make the subdisks invalid */
205 vol->plex[vol->plexes] = plexno; /* this one */
206 vol->plexes++; /* add another plex */
207 PLEX[plexno].volno = volno; /* note the number of our volume */
208
209 /* Find out how big our volume is */
210 for (i = 0; i < vol->plexes; i++)
0d0607d0 211 vol->size = u64max(vol->size, PLEX[vol->plex[i]].length);
984263bc
MD
212 return vol->plexes - 1; /* and return its index */
213}
214
215/*
216 * Add subdisk to a plex if possible
217 */
218int
219give_sd_to_plex(int plexno, int sdno)
220{
221 int i;
222 struct plex *plex;
223 struct sd *sd;
224
225 /*
226 * It's not an error for the sd to already
227 * belong to the plex, but we need to check a
228 * number of things to make sure it's done right.
229 * Some day.
230 */
231 i = my_sd(plexno, sdno);
232 if (i >= 0) /* does it already belong to us? */
233 return i; /* that's it */
234
235 plex = &PLEX[plexno]; /* point to the plex */
236 sd = &SD[sdno]; /* and the subdisk */
237
238 /* Do we have an offset? Otherwise put it after the last one */
239 if (sd->plexoffset < 0) { /* no offset specified */
240 if (plex->subdisks > 0) {
241 struct sd *lastsd = &SD[plex->sdnos[plex->subdisks - 1]]; /* last subdisk */
242
243 if (plex->organization == plex_concat) /* concat, */
244 sd->plexoffset = lastsd->sectors + lastsd->plexoffset; /* starts here */
245 else /* striped, RAID-4 or RAID-5 */
246 sd->plexoffset = plex->stripesize * plex->subdisks; /* starts here */
247 } else /* first subdisk */
248 sd->plexoffset = 0; /* start at the beginning */
249 }
250 if (plex->subdisks == MAXSD) /* we already have our maximum */
251 throw_rude_remark(ENOSPC, /* crap out */
252 "Can't add %s to %s: plex full",
253 sd->name,
254 plex->name);
255
256 plex->subdisks++; /* another entry */
257 if (plex->subdisks >= plex->subdisks_allocated) /* need more space */
258 EXPAND(plex->sdnos, int, plex->subdisks_allocated, INITIAL_SUBDISKS_IN_PLEX);
259
260 /* Adjust size of plex and volume. */
261 if (isparity(plex)) /* RAID-4 or RAID-5 */
262 plex->length = (plex->subdisks - 1) * sd->sectors; /* size is one disk short */
263 else
264 plex->length += sd->sectors; /* plex gets this much bigger */
265 if (plex->volno >= 0) /* we have a volume */
0d0607d0 266 VOL[plex->volno].size = u64max(VOL[plex->volno].size, plex->length); /* adjust its size */
984263bc
MD
267
268 /*
269 * We need to check that the subdisks don't overlap,
270 * but we can't do that until a point where we *must*
271 * know the size of all the subdisks. That's not
272 * here. But we need to sort them by offset
273 */
274 for (i = 0; i < plex->subdisks - 1; i++) {
275 if (sd->plexoffset < SD[plex->sdnos[i]].plexoffset) { /* it fits before this one */
276 /* First move any remaining subdisks by one */
277 int j;
278
279 for (j = plex->subdisks - 1; j > i; j--) /* move up one at a time */
280 plex->sdnos[j] = plex->sdnos[j - 1];
281 plex->sdnos[i] = sdno;
282 sd->plexsdno = i; /* note where we are in the subdisk */
283 return i;
284 }
285 }
286
287 /*
288 * The plex doesn't have any subdisk with a
289 * larger offset. Insert it here.
290 */
291 plex->sdnos[i] = sdno;
292 sd->plexsdno = i; /* note where we are in the subdisk */
293 sd->plexno = plex->plexno; /* and who we belong to */
294 return i;
295}
296
297/*
298 * Add a subdisk to drive if possible. The
299 * pointer to the drive must already be stored in
300 * the sd structure, but the drive doesn't know
301 * about the subdisk yet.
302 */
303void
304give_sd_to_drive(int sdno)
305{
306 struct sd *sd; /* pointer to subdisk */
307 struct drive *drive; /* and drive */
308 int fe; /* index in free list */
309 int sfe; /* and index of subdisk when assigning max */
310
311 sd = &SD[sdno]; /* point to sd */
312 drive = &DRIVE[sd->driveno]; /* and drive */
313
314 if (drive->state != drive_up) {
315 update_sd_state(sdno); /* that crashes the subdisk */
316 return;
317 }
318 if (drive->flags & VF_HOTSPARE) /* the drive is a hot spare, */
319 throw_rude_remark(ENOSPC,
320 "Can't place %s on hot spare drive %s",
321 sd->name,
322 drive->label.name);
323 if ((drive->sectors_available == 0) /* no space left */
324 ||(sd->sectors > drive->sectors_available)) { /* or too big, */
325 sd->driveoffset = -1; /* don't be confusing */
326 free_sd(sd->sdno);
327 throw_rude_remark(ENOSPC, "No space for %s on %s", sd->name, drive->label.name);
328 return; /* in case we come back here */
329 }
330 drive->subdisks_used++; /* one more subdisk */
331
332 if (sd->sectors == 0) { /* take the largest chunk */
333 sfe = 0; /* to keep the compiler happy */
334 for (fe = 0; fe < drive->freelist_entries; fe++) {
335 if (drive->freelist[fe].sectors >= sd->sectors) { /* more space here */
336 sd->sectors = drive->freelist[fe].sectors; /* take it */
337 sd->driveoffset = drive->freelist[fe].offset;
338 sfe = fe; /* and note the index for later */
339 }
340 }
341 if (sd->sectors == 0) { /* no luck, */
342 sd->driveoffset = -1; /* don't be confusing */
343 free_sd(sd->sdno);
344 throw_rude_remark(ENOSPC, /* give up */
345 "No space for %s on %s",
346 sd->name,
347 drive->label.name);
348 }
349 if (sfe < (drive->freelist_entries - 1)) /* not the last one, */
350 bcopy(&drive->freelist[sfe + 1],
351 &drive->freelist[sfe],
352 (drive->freelist_entries - sfe) * sizeof(struct drive_freelist));
353 drive->freelist_entries--; /* one less entry */
354 drive->sectors_available -= sd->sectors; /* and note how much less space we have */
355 } else if (sd->driveoffset < 0) { /* no offset specified, find one */
356 for (fe = 0; fe < drive->freelist_entries; fe++) {
357 if (drive->freelist[fe].sectors >= sd->sectors) { /* it'll fit here */
358 sd->driveoffset = drive->freelist[fe].offset;
359 if (sd->sectors == drive->freelist[fe].sectors) { /* used up the entire entry */
360 if (fe < (drive->freelist_entries - 1)) /* not the last one, */
361 bcopy(&drive->freelist[fe + 1],
362 &drive->freelist[fe],
363 (drive->freelist_entries - fe) * sizeof(struct drive_freelist));
364 drive->freelist_entries--; /* one less entry */
365 } else {
366 drive->freelist[fe].sectors -= sd->sectors; /* this much less space */
367 drive->freelist[fe].offset += sd->sectors; /* this much further on */
368 }
369 drive->sectors_available -= sd->sectors; /* and note how much less space we have */
370 break;
371 }
372 }
373 if (sd->driveoffset < 0)
374 /*
375 * Didn't find anything. Although the drive has
376 * enough space, it's too fragmented
377 */
378 {
379 free_sd(sd->sdno);
380 throw_rude_remark(ENOSPC, "No space for %s on %s", sd->name, drive->label.name);
381 }
382 } else { /* specific offset */
383 /*
384 * For a specific offset to work, the space must be
385 * entirely in a single freelist entry. Look for it.
386 */
387 u_int64_t sdend = sd->driveoffset + sd->sectors; /* end of our subdisk */
388 for (fe = 0; fe < drive->freelist_entries; fe++) {
389 u_int64_t dend = drive->freelist[fe].offset + drive->freelist[fe].sectors; /* end of entry */
390 if (dend >= sdend) { /* fits before here */
391 if (drive->freelist[fe].offset > sd->driveoffset) { /* starts after the beginning of sd area */
392 sd->driveoffset = -1; /* don't be confusing */
393 set_sd_state(sd->sdno, sd_down, setstate_force);
394 throw_rude_remark(ENOSPC,
7bfcf376 395 "No space for %s on drive %s at offset %jd",
984263bc
MD
396 sd->name,
397 drive->label.name,
7bfcf376 398 (intmax_t)sd->driveoffset);
984263bc
MD
399 return;
400 }
401 /*
402 * We've found the space, and we can allocate it.
403 * We don't need to say that to the subdisk, which
404 * already knows about it. We need to tell it to
405 * the free list, though. We have four possibilities:
406 *
407 * 1. The subdisk exactly eats up the entry. That's the
408 * same as above.
409 * 2. The subdisk starts at the beginning and leaves space
410 * at the end.
411 * 3. The subdisk starts after the beginning and leaves
412 * space at the end as well: we end up with another
413 * fragment.
414 * 4. The subdisk leaves space at the beginning and finishes
415 * at the end.
416 */
417 drive->sectors_available -= sd->sectors; /* note how much less space we have */
418 if (sd->driveoffset == drive->freelist[fe].offset) { /* 1 or 2 */
419 if (sd->sectors == drive->freelist[fe].sectors) { /* 1: used up the entire entry */
420 if (fe < (drive->freelist_entries - 1)) /* not the last one, */
421 bcopy(&drive->freelist[fe + 1],
422 &drive->freelist[fe],
423 (drive->freelist_entries - fe) * sizeof(struct drive_freelist));
424 drive->freelist_entries--; /* one less entry */
425 } else { /* 2: space at the end */
426 drive->freelist[fe].sectors -= sd->sectors; /* this much less space */
427 drive->freelist[fe].offset += sd->sectors; /* this much further on */
428 }
429 } else { /* 3 or 4 */
430 drive->freelist[fe].sectors = sd->driveoffset - drive->freelist[fe].offset;
431 if (dend > sdend) { /* 3: space at the end as well */
432 if (fe < (drive->freelist_entries - 1)) /* not the last one */
433 bcopy(&drive->freelist[fe], /* move the rest down */
434 &drive->freelist[fe + 1],
435 (drive->freelist_entries - fe) * sizeof(struct drive_freelist));
436 drive->freelist_entries++; /* one less entry */
437 drive->freelist[fe + 1].offset = sdend; /* second entry starts after sd */
438 drive->freelist[fe + 1].sectors = dend - sdend; /* and is this long */
439 }
440 }
441 break;
442 }
443 }
444 }
445 drive->opencount++; /* one more subdisk attached */
446}
447
448/* Get an empty drive entry from the drive table */
449int
450get_empty_drive(void)
451{
452 int driveno;
453 struct drive *drive;
454
455 /* first see if we have one which has been deallocated */
456 for (driveno = 0; driveno < vinum_conf.drives_allocated; driveno++) {
457 if (DRIVE[driveno].state == drive_unallocated) /* bingo */
458 break;
459 }
460
461 if (driveno >= vinum_conf.drives_allocated) /* we've used all our allocation */
462 EXPAND(DRIVE, struct drive, vinum_conf.drives_allocated, INITIAL_DRIVES);
463
464 /* got a drive entry. Make it pretty */
465 drive = &DRIVE[driveno];
466 bzero(drive, sizeof(struct drive));
467 drive->driveno = driveno; /* put number in structure */
468 drive->flags |= VF_NEWBORN; /* newly born drive */
16d16813 469 strcpy(drive->devicename, "unknown"); /* and make the name ``unknown'' */
984263bc
MD
470 return driveno; /* return the index */
471}
472
473/*
474 * Find the named drive in vinum_conf.drive, return a pointer
475 * return the index in vinum_conf.drive.
476 * Don't mark the drive as allocated (XXX SMP)
477 * If create != 0, create an entry if it doesn't exist
478 */
479/* XXX check if we have it open from attach */
480int
481find_drive(const char *name, int create)
482{
483 int driveno;
484 struct drive *drive;
485
486 if (name != NULL) {
487 for (driveno = 0; driveno < vinum_conf.drives_allocated; driveno++) {
488 drive = &DRIVE[driveno]; /* point to drive */
489 if ((drive->label.name[0] != '\0') /* it has a name */
490 &&(strcmp(drive->label.name, name) == 0) /* and it's this one */
491 &&(drive->state > drive_unallocated)) /* and it's a real one: found */
492 return driveno;
493 }
494 }
495 /* the drive isn't in the list. Add it if he wants */
496 if (create == 0) /* don't want to create */
497 return -1; /* give up */
498
499 driveno = get_empty_drive();
500 drive = &DRIVE[driveno];
501 if (name != NULL)
0d0607d0 502 ksnprintf(drive->label.name, sizeof(drive->label.name), "%s", name);
984263bc
MD
503 drive->state = drive_referenced; /* in use, nothing worthwhile there */
504 return driveno; /* return the index */
505}
506
507/*
508 * Find a drive given its device name.
509 * devname must be valid.
510 * Otherwise the same as find_drive above
511 */
512int
513find_drive_by_dev(const char *devname, int create)
514{
515 int driveno;
516 struct drive *drive;
517
518 for (driveno = 0; driveno < vinum_conf.drives_allocated; driveno++) {
5ad175c9
MD
519 drive = &DRIVE[driveno];
520 if (strcmp(drive->devicename, devname) == 0 &&
521 drive->state > drive_unallocated
522 ) {
984263bc 523 return driveno;
5ad175c9 524 }
984263bc
MD
525 }
526
5ad175c9
MD
527 if (create == 0)
528 return -1;
984263bc
MD
529
530 driveno = get_empty_drive();
531 drive = &DRIVE[driveno];
5ad175c9
MD
532 ksnprintf(drive->devicename, sizeof(drive->devicename), "%s", devname);
533 /* in use, nothing worthwhile there */
534 drive->state = drive_referenced;
535 return driveno;
984263bc
MD
536}
537
538/* Find an empty subdisk in the subdisk table */
539int
540get_empty_sd(void)
541{
542 int sdno;
543 struct sd *sd;
544
545 /* first see if we have one which has been deallocated */
546 for (sdno = 0; sdno < vinum_conf.subdisks_allocated; sdno++) {
547 if (SD[sdno].state == sd_unallocated) /* bingo */
548 break;
549 }
550 if (sdno >= vinum_conf.subdisks_allocated)
551 /*
552 * We've run out of space. sdno is pointing
553 * where we want it, but at the moment we
554 * don't have the space. Get it.
555 */
556 EXPAND(SD, struct sd, vinum_conf.subdisks_allocated, INITIAL_SUBDISKS);
557
558 /* initialize some things */
559 sd = &SD[sdno]; /* point to it */
560 bzero(sd, sizeof(struct sd)); /* initialize */
561 sd->flags |= VF_NEWBORN; /* newly born subdisk */
562 sd->plexno = -1; /* no plex */
563 sd->sectors = -1; /* no space */
564 sd->driveno = -1; /* no drive */
565 sd->plexoffset = -1; /* and no offsets */
566 sd->driveoffset = -1;
567 return sdno; /* return the index */
568}
569
570/* return a drive to the free pool */
571void
572free_drive(struct drive *drive)
573{
574 if ((drive->state > drive_referenced) /* real drive */
575 ||(drive->flags & VF_OPEN)) { /* how can it be open without a state? */
576 LOCKDRIVE(drive);
577 if (drive->flags & VF_OPEN) { /* it's open, */
578 close_locked_drive(drive); /* close it */
579 drive->state = drive_down; /* and note the fact */
580 }
581 if (drive->freelist)
582 Free(drive->freelist);
583 bzero(drive, sizeof(struct drive)); /* this also sets drive_unallocated */
584 unlockdrive(drive);
585 }
586}
587
588/*
589 * Find the named subdisk in vinum_conf.sd.
590 *
591 * If create != 0, create an entry if it doesn't exist
592 *
593 * Return index in vinum_conf.sd
594 */
595int
596find_subdisk(const char *name, int create)
597{
598 int sdno;
599 struct sd *sd;
600
601 for (sdno = 0; sdno < vinum_conf.subdisks_allocated; sdno++) {
602 if (strcmp(SD[sdno].name, name) == 0) /* found it */
603 return sdno;
604 }
605
606 /* the subdisk isn't in the list. Add it if he wants */
607 if (create == 0) /* don't want to create */
608 return -1; /* give up */
609
610 /* Allocate one and insert the name */
611 sdno = get_empty_sd();
612 sd = &SD[sdno];
0d0607d0 613 ksnprintf(sd->name, sizeof(sd->name), "%s", name);
984263bc
MD
614 return sdno; /* return the pointer */
615}
616
617/* Return space to a drive */
618void
619return_drive_space(int driveno, int64_t offset, int length)
620{
621 struct drive *drive;
622 int fe; /* free list entry */
623 u_int64_t sdend; /* end of our subdisk */
624 u_int64_t dend; /* end of our freelist entry */
625
626 drive = &DRIVE[driveno];
627 if (drive->state == drive_up) {
628 sdend = offset + length; /* end of our subdisk */
629
630 /* Look for where to return the sd address space */
631 for (fe = 0;
632 (fe < drive->freelist_entries) && (drive->freelist[fe].offset < offset);
633 fe++);
634 /*
635 * Now we are pointing to the last entry, the first
636 * with a higher offset than the subdisk, or both.
637 */
638 if ((fe > 1) /* not the first entry */
639 &&((fe == drive->freelist_entries) /* gone past the end */
640 ||(drive->freelist[fe].offset > offset))) /* or past the block were looking for */
641 fe--; /* point to the block before */
642 dend = drive->freelist[fe].offset + drive->freelist[fe].sectors; /* end of the entry */
643
644 /*
645 * At this point, we are pointing to the correct
646 * place in the free list. A number of possibilities
647 * exist:
648 *
649 * 1. The block to be freed starts at the end of the
650 * block to which we are pointing. This has two
651 * subcases:
652 *
653 * a. The block to be freed ends at the beginning
654 * of the following block. Merge the three
655 * areas into a single block.
656 *
657 * b. The block is shorter than the space between
658 * the current block and the next one. Enlarge
659 * the current block.
660 *
661 * 2. The block to be freed starts after the end
662 * of the block. Again, we have two cases:
663 *
664 * a. It ends before the start of the following block.
665 * Create a new free block.
666 *
667 * b. It ends at the start of the following block.
668 * Enlarge the following block downwards.
669 *
670 * When there is only one free space block, and the
671 * space to be returned is before it, the pointer is
672 * to a non-existent zeroth block. XXX check this
673 */
674 if (offset == dend) { /* Case 1: it starts at the end of this block */
675 if ((fe < drive->freelist_entries - 1) /* we're not the last block in the free list */
676 /* and the subdisk ends at the start of the next block */
677 &&(sdend == drive->freelist[fe + 1].offset)) {
678 drive->freelist[fe].sectors /* 1a: merge all three blocks */
679 = drive->freelist[fe + 1].sectors;
680 if (fe < drive->freelist_entries - 2) /* still more blocks after next */
681 bcopy(&drive->freelist[fe + 2], /* move down one */
682 &drive->freelist[fe + 1],
683 (drive->freelist_entries - 2 - fe)
684 * sizeof(struct drive_freelist));
685 drive->freelist_entries--; /* one less entry in the free list */
686 } else /* 1b: just enlarge this block */
687 drive->freelist[fe].sectors += length;
688 } else { /* Case 2 */
689 if (offset > dend) /* it starts after this block */
690 fe++; /* so look at the next block */
691 if ((fe < drive->freelist_entries) /* we're not the last block in the free list */
692 /* and the subdisk ends at the start of this block: case 4 */
693 &&(sdend == drive->freelist[fe].offset)) {
694 drive->freelist[fe].offset = offset; /* it starts where the sd was */
695 drive->freelist[fe].sectors += length; /* and it's this much bigger */
696 } else { /* case 3: non-contiguous */
697 if (fe < drive->freelist_entries) /* not after the last block, */
698 bcopy(&drive->freelist[fe], /* move the rest up one entry */
699 &drive->freelist[fe + 1],
700 (drive->freelist_entries - fe)
701 * sizeof(struct drive_freelist));
702 drive->freelist_entries++; /* one less entry */
703 drive->freelist[fe].offset = offset; /* this entry represents the sd */
704 drive->freelist[fe].sectors = length;
705 }
706 }
707 drive->sectors_available += length; /* the sectors are now available */
708 }
709}
710
711/*
712 * Free an allocated sd entry.
713 * This performs memory management only. remove()
714 * is responsible for checking relationships.
715 */
716void
717free_sd(int sdno)
718{
719 struct sd *sd;
720
721 sd = &SD[sdno];
722 if ((sd->driveno >= 0) /* we have a drive, */
723 &&(sd->sectors > 0)) /* and some space on it */
724 return_drive_space(sd->driveno, /* return the space */
725 sd->driveoffset,
726 sd->sectors);
727 if (sd->plexno >= 0)
728 PLEX[sd->plexno].subdisks--; /* one less subdisk */
d736a600
MD
729 sd->state = sd_unallocated;
730 made_sd(sd);
984263bc
MD
731 bzero(sd, sizeof(struct sd)); /* and clear it out */
732 sd->state = sd_unallocated;
733 vinum_conf.subdisks_used--; /* one less sd */
734}
735
d736a600
MD
736static void
737made_sd(struct sd *sd)
738{
739 if (sd->sd_dev == NULL && sd->state != sd_unallocated) {
740 sd->sd_dev = make_dev(&vinum_ops, VINUM_SD(sd->sdno),
741 UID_ROOT, GID_OPERATOR, 0640,
742 VINUM_BASE "sd/%s", sd->name);
f5d8307c
AH
743 udev_dict_set_cstr(sd->sd_dev, "subsystem", "raid");
744 udev_dict_set_cstr(sd->sd_dev, "disk-type", "raid");
d736a600
MD
745#if 0
746 if (sd->plexno >= 0 && PLEX[sd->plexno].volno >= 0) {
747 make_dev_alias(sd->sd_dev, "vol/%s.plex/%s",
748 VOL[PLEX[sd->plexno].volno].name,
749 plex->name, VOL[plex->volno].name);
750 }
751#endif
752 }
753 if (sd->sd_dev && sd->state == sd_unallocated) {
754 destroy_dev(sd->sd_dev);
755 sd->sd_dev = NULL;
756 }
757}
758
759static void
760made_vol(struct volume *vol)
761{
762 if (vol->vol_dev == NULL && vol->state != volume_unallocated) {
763 vol->vol_dev = make_dev(&vinum_ops,
764 VINUMDEV(vol->volno, 0, 0, VINUM_VOLUME_TYPE),
765 UID_ROOT, GID_OPERATOR, 0640,
766 VINUM_BASE "vol/%s", vol->name);
f5d8307c
AH
767 udev_dict_set_cstr(vol->vol_dev, "subsystem", "raid");
768 udev_dict_set_cstr(vol->vol_dev, "disk-type", "raid");
d736a600
MD
769 }
770 if (vol->vol_dev && vol->state == volume_unallocated) {
771 destroy_dev(vol->vol_dev);
772 vol->vol_dev = NULL;
773 }
774}
775
776static void
777made_plex(struct plex *plex)
778{
779 if (plex->plex_dev == NULL && plex->state != plex_unallocated) {
780 plex->plex_dev = make_dev(&vinum_ops, VINUM_PLEX(plex->plexno),
781 UID_ROOT, GID_OPERATOR, 0640,
782 VINUM_BASE "plex/%s", plex->name);
f5d8307c
AH
783 udev_dict_set_cstr(plex->plex_dev, "subsystem", "raid");
784 udev_dict_set_cstr(plex->plex_dev, "disk-type", "raid");
d736a600
MD
785 if (plex->volno >= 0) {
786 make_dev_alias(plex->plex_dev, "vol/%s.plex/%s",
787 plex->name, VOL[plex->volno].name);
788 }
789 }
790 if (plex->plex_dev && plex->state == plex_unallocated) {
791 destroy_dev(plex->plex_dev);
792 plex->plex_dev = NULL;
793 }
794}
795
984263bc
MD
796/* Find an empty plex in the plex table */
797int
798get_empty_plex(void)
799{
800 int plexno;
801 struct plex *plex; /* if we allocate one */
802
803 /* first see if we have one which has been deallocated */
804 for (plexno = 0; plexno < vinum_conf.plexes_allocated; plexno++) {
805 if (PLEX[plexno].state == plex_unallocated) /* bingo */
806 break; /* and get out of here */
807 }
808
809 if (plexno >= vinum_conf.plexes_allocated)
810 EXPAND(PLEX, struct plex, vinum_conf.plexes_allocated, INITIAL_PLEXES);
811
812 /* Found a plex. Give it an sd structure */
813 plex = &PLEX[plexno]; /* this one is ours */
814 bzero(plex, sizeof(struct plex)); /* polish it up */
815 plex->sdnos = (int *) Malloc(sizeof(int) * INITIAL_SUBDISKS_IN_PLEX); /* allocate sd table */
816 CHECKALLOC(plex->sdnos, "vinum: Can't allocate plex subdisk table");
817 bzero(plex->sdnos, (sizeof(int) * INITIAL_SUBDISKS_IN_PLEX)); /* do we need this? */
818 plex->flags |= VF_NEWBORN; /* newly born plex */
819 plex->subdisks = 0; /* no subdisks in use */
820 plex->subdisks_allocated = INITIAL_SUBDISKS_IN_PLEX; /* and we have space for this many */
821 plex->organization = plex_disorg; /* and it's not organized */
822 plex->volno = -1; /* no volume yet */
823 return plexno; /* return the index */
824}
825
826/*
827 * Find the named plex in vinum_conf.plex
828 *
829 * If create != 0, create an entry if it doesn't exist
830 * return index in vinum_conf.plex
831 */
832int
833find_plex(const char *name, int create)
834{
835 int plexno;
836 struct plex *plex;
837
838 for (plexno = 0; plexno < vinum_conf.plexes_allocated; plexno++) {
839 if (strcmp(PLEX[plexno].name, name) == 0) /* found it */
840 return plexno;
841 }
842
843 /* the plex isn't in the list. Add it if he wants */
844 if (create == 0) /* don't want to create */
845 return -1; /* give up */
846
847 /* Allocate one and insert the name */
848 plexno = get_empty_plex();
849 plex = &PLEX[plexno]; /* point to it */
0d0607d0 850 ksnprintf(plex->name, sizeof(plex->name), "%s", name);
984263bc
MD
851 return plexno; /* return the pointer */
852}
853
854/*
855 * Free an allocated plex entry
856 * and its associated memory areas
857 */
858void
859free_plex(int plexno)
860{
861 struct plex *plex;
862
863 plex = &PLEX[plexno];
864 if (plex->sdnos)
865 Free(plex->sdnos);
866 if (plex->lock)
867 Free(plex->lock);
d736a600
MD
868 plex->state = plex_unallocated;
869 made_plex(plex);
984263bc
MD
870 bzero(plex, sizeof(struct plex)); /* and clear it out */
871 plex->state = plex_unallocated;
872}
873
874/* Find an empty volume in the volume table */
875int
876get_empty_volume(void)
877{
878 int volno;
879 struct volume *vol;
880 int i;
881
882 /* first see if we have one which has been deallocated */
883 for (volno = 0; volno < vinum_conf.volumes_allocated; volno++) {
884 if (VOL[volno].state == volume_unallocated) /* bingo */
885 break;
886 }
887
888 if (volno >= vinum_conf.volumes_allocated)
889 EXPAND(VOL, struct volume, vinum_conf.volumes_allocated, INITIAL_VOLUMES);
890
891 /* Now initialize fields */
892 vol = &VOL[volno];
893 bzero(vol, sizeof(struct volume));
894 vol->flags |= VF_NEWBORN | VF_CREATED; /* newly born volume */
895 vol->preferred_plex = ROUND_ROBIN_READPOL; /* round robin */
896 for (i = 0; i < MAXPLEX; i++) /* mark the plexes missing */
897 vol->plex[i] = -1;
898 return volno; /* return the index */
899}
900
901/*
902 * Find the named volume in vinum_conf.volume.
903 *
904 * If create != 0, create an entry if it doesn't exist
905 * return the index in vinum_conf
906 */
907int
908find_volume(const char *name, int create)
909{
910 int volno;
911 struct volume *vol;
912
913 for (volno = 0; volno < vinum_conf.volumes_allocated; volno++) {
914 if (strcmp(VOL[volno].name, name) == 0) /* found it */
915 return volno;
916 }
917
918 /* the volume isn't in the list. Add it if he wants */
919 if (create == 0) /* don't want to create */
920 return -1; /* give up */
921
922 /* Allocate one and insert the name */
923 volno = get_empty_volume();
924 vol = &VOL[volno];
0d0607d0 925 ksnprintf(vol->name, sizeof(vol->name), "%s", name);
984263bc
MD
926 vol->blocksize = DEV_BSIZE; /* block size of this volume */
927 return volno; /* return the pointer */
928}
929
930/*
931 * Free an allocated volume entry
932 * and its associated memory areas
933 */
934void
935free_volume(int volno)
936{
937 struct volume *vol;
938
939 vol = &VOL[volno];
d736a600
MD
940 vol->state = volume_unallocated;
941 made_vol(vol);
984263bc
MD
942 bzero(vol, sizeof(struct volume)); /* and clear it out */
943 vol->state = volume_unallocated;
944}
945
946/*
947 * Handle a drive definition. We store the information in the global variable
948 * drive, so we don't need to allocate.
949 *
950 * If we find an error, print a message and return
951 */
952void
953config_drive(int update)
954{
955 enum drive_label_info partition_status; /* info about the partition */
956 int parameter;
957 int driveno; /* index of drive in vinum_conf */
958 struct drive *drive; /* and pointer to it */
959 int otherdriveno; /* index of possible second drive */
960 int sdno;
961
962 if (tokens < 2) /* not enough tokens */
963 throw_rude_remark(EINVAL, "Drive has no name\n");
964 driveno = find_drive(token[1], 1); /* allocate a drive to initialize */
965 drive = &DRIVE[driveno]; /* and get a pointer */
966 if (update && ((drive->flags & VF_NEWBORN) == 0)) /* this drive exists already */
967 return; /* don't do anything */
968 drive->flags &= ~VF_NEWBORN; /* no longer newly born */
969
970 if (drive->state != drive_referenced) { /* we already know this drive */
971 /*
972 * XXX Check which definition is more up-to-date. Give
973 * preference for the definition on its own drive.
974 */
975 return; /* XXX */
976 }
977 for (parameter = 2; parameter < tokens; parameter++) { /* look at the other tokens */
978 switch (get_keyword(token[parameter], &keyword_set)) {
979 case kw_device:
980 parameter++;
981 otherdriveno = find_drive_by_dev(token[parameter], 0); /* see if it exists already */
982 if (otherdriveno >= 0) { /* yup, */
983 drive->state = drive_unallocated; /* deallocate the drive */
984 throw_rude_remark(EEXIST, /* and complain */
985 "Drive %s would have same device as drive %s",
986 token[1],
987 DRIVE[otherdriveno].label.name);
988 }
989 if (drive->devicename[0] == '/') { /* we know this drive... */
990 if (strcmp(drive->devicename, token[parameter])) /* different name */
991 close_drive(drive); /* close it if it's open */
992 else /* no change */
993 break;
994 }
5ad175c9
MD
995
996 /*
997 * open the device and get the configuration
998 */
999 ksnprintf(drive->devicename, sizeof(drive->devicename),
1000 "%s", token[parameter]);
984263bc 1001 partition_status = read_drive_label(drive, 1);
5ad175c9 1002
984263bc
MD
1003 switch (partition_status) {
1004 case DL_CANT_OPEN: /* not our kind */
1005 close_drive(drive);
1006 if (drive->lasterror == EFTYPE) /* wrong kind of partition */
1007 throw_rude_remark(drive->lasterror,
1008 "Drive %s has invalid partition type",
1009 drive->label.name);
1010 else /* I/O error of some kind */
1011 throw_rude_remark(drive->lasterror,
1012 "Can't initialize drive %s",
1013 drive->label.name);
1014 break;
1015
1016 case DL_WRONG_DRIVE: /* valid drive, not the name we expected */
1017 if (vinum_conf.flags & VF_FORCECONFIG) { /* but we'll accept that */
1018 bcopy(token[1], drive->label.name, sizeof(drive->label.name));
1019 break;
1020 }
1021 close_drive(drive);
1022 /*
1023 * There's a potential race condition here:
1024 * the rude remark refers to a field in an
1025 * unallocated drive, which potentially could
1026 * be reused. This works because we're the only
1027 * thread accessing the config at the moment.
1028 */
1029 drive->state = drive_unallocated; /* throw it away completely */
1030 throw_rude_remark(drive->lasterror,
1031 "Incorrect drive name %s specified for drive %s",
1032 token[1],
1033 drive->label.name);
1034 break;
1035
1036 case DL_DELETED_LABEL: /* it was a drive, but we deleted it */
1037 case DL_NOT_OURS: /* nothing to do with the rest */
1038 case DL_OURS:
1039 break;
1040 }
1041 /*
1042 * read_drive_label overwrites the device name.
1043 * If we get here, we can have the drive,
1044 * so put it back again
1045 */
0d0607d0
MD
1046 ksnprintf(drive->devicename, sizeof(drive->devicename),
1047 "%s", token[parameter]);
984263bc
MD
1048 break;
1049
1050 case kw_state:
1051 parameter++; /* skip the keyword */
1052 if (vinum_conf.flags & VF_READING_CONFIG)
1053 drive->state = DriveState(token[parameter]); /* set the state */
1054 break;
1055
1056 case kw_hotspare: /* this drive is a hot spare */
1057 drive->flags |= VF_HOTSPARE;
1058 break;
1059
1060 default:
1061 close_drive(drive);
1062 throw_rude_remark(EINVAL,
1063 "Drive %s, invalid keyword: %s",
1064 token[1],
1065 token[parameter]);
1066 }
1067 }
1068
1069 if (drive->devicename[0] != '/') {
1070 drive->state = drive_unallocated; /* deallocate the drive */
1071 throw_rude_remark(EINVAL, "No device name for %s", drive->label.name);
1072 }
1073 vinum_conf.drives_used++; /* passed all hurdles: one more in use */
1074 /*
1075 * If we're replacing a drive, it could be that
1076 * we already have subdisks referencing this
1077 * drive. Note where they should be and change
1078 * their state to obsolete.
1079 */
1080 for (sdno = 0; sdno < vinum_conf.subdisks_allocated; sdno++) {
1081 if ((SD[sdno].state > sd_referenced)
1082 && (SD[sdno].driveno == driveno)) {
1083 give_sd_to_drive(sdno);
1084 if (SD[sdno].state > sd_stale)
1085 SD[sdno].state = sd_stale;
1086 }
1087 }
1088}
1089
1090/*
1091 * Handle a subdisk definition. We store the information in the global variable
1092 * sd, so we don't need to allocate.
1093 *
1094 * If we find an error, print a message and return
1095 */
1096void
1097config_subdisk(int update)
1098{
1099 int parameter;
1100 int sdno; /* index of sd in vinum_conf */
1101 struct sd *sd; /* and pointer to it */
1102 u_int64_t size;
1103 int detached = 0; /* set to 1 if this is a detached subdisk */
1104 int sdindex = -1; /* index in plexes subdisk table */
1105 enum sdstate state = sd_unallocated; /* state to set, if specified */
1106 int autosize = 0; /* set if we autosize in give_sd_to_drive */
1107 int namedsdno; /* index of another with this name */
984263bc
MD
1108
1109 sdno = get_empty_sd(); /* allocate an SD to initialize */
1110 sd = &SD[sdno]; /* and get a pointer */
1111
1112 for (parameter = 1; parameter < tokens; parameter++) { /* look at the other tokens */
1113 switch (get_keyword(token[parameter], &keyword_set)) {
1114 /*
1115 * If we have a 'name' parameter, it must
1116 * come first, because we're too lazy to tidy
1117 * up dangling refs if it comes later.
1118 */
1119 case kw_name:
1120 namedsdno = find_subdisk(token[++parameter], 0); /* find an existing sd with this name */
1121 if (namedsdno >= 0) { /* got one */
1122 if (SD[namedsdno].state == sd_referenced) { /* we've been told about this one */
1123 if (parameter > 2)
1124 throw_rude_remark(EINVAL,
1125 "sd %s: name parameter must come first\n", /* no go */
1126 token[parameter]);
1127 else {
1128 int i;
1129 struct plex *plex; /* for tidying up dangling references */
1130
1131 *sd = SD[namedsdno]; /* copy from the referenced one */
d736a600
MD
1132 sd->sd_dev = NULL;
1133 made_sd(sd);
984263bc 1134 SD[namedsdno].state = sd_unallocated; /* and deallocate the referenced one */
d736a600 1135 made_sd(&SD[namedsdno]);
984263bc
MD
1136 plex = &PLEX[sd->plexno]; /* now take a look at our plex */
1137 for (i = 0; i < plex->subdisks; i++) { /* look for the pointer */
1138 if (plex->sdnos[i] == namedsdno) /* pointing to the old subdisk */
1139 plex->sdnos[i] = sdno; /* bend it to point here */
1140 }
1141 }
1142 }
1143 if (update) /* are we updating? */
1144 return; /* that's OK, nothing more to do */
1145 else
1146 throw_rude_remark(EINVAL, "Duplicate subdisk %s", token[parameter]);
0d0607d0
MD
1147 } else {
1148 ksnprintf(sd->name, sizeof(sd->name),
1149 "%s", token[parameter]);
1150 }
984263bc
MD
1151 break;
1152
1153 case kw_detached:
1154 detached = 1;
1155 break;
1156
1157 case kw_plexoffset:
1158 size = sizespec(token[++parameter]);
1159 if ((size == -1) /* unallocated */
1160 &&(vinum_conf.flags & VF_READING_CONFIG)) /* reading from disk */
1161 break; /* invalid sd; just ignore it */
1162 if ((size % DEV_BSIZE) != 0)
1163 throw_rude_remark(EINVAL,
1164 "sd %s, bad plex offset alignment: %lld",
1165 sd->name,
1166 (long long) size);
1167 else
1168 sd->plexoffset = size / DEV_BSIZE;
1169 break;
1170
1171 case kw_driveoffset:
1172 size = sizespec(token[++parameter]);
1173 if ((size == -1) /* unallocated */
1174 &&(vinum_conf.flags & VF_READING_CONFIG)) /* reading from disk */
1175 break; /* invalid sd; just ignore it */
1176 if ((size % DEV_BSIZE) != 0)
1177 throw_rude_remark(EINVAL,
1178 "sd %s, bad drive offset alignment: %lld",
1179 sd->name,
1180 (long long) size);
1181 else
1182 sd->driveoffset = size / DEV_BSIZE;
1183 break;
1184
1185 case kw_len:
1186 if (get_keyword(token[++parameter], &keyword_set) == kw_max) /* select maximum size from drive */
1187 size = 0; /* this is how we say it :-) */
1188 else
1189 size = sizespec(token[parameter]);
1190 if ((size % DEV_BSIZE) != 0)
7bfcf376 1191 throw_rude_remark(EINVAL, "sd %s, length %jd not multiple of sector size", sd->name, (intmax_t)size);
984263bc
MD
1192 else
1193 sd->sectors = size / DEV_BSIZE;
1194 /*
1195 * We have a problem with autosizing: we need to
1196 * give the drive to the plex before we give it
1197 * to the drive, in order to be clean if we give
1198 * up in the middle, but at this time the size hasn't
1199 * been set. Note that we have to fix up after
1200 * giving the subdisk to the drive.
1201 */
1202 if (size == 0)
1203 autosize = 1; /* note that we're autosizing */
1204 break;
1205
1206 case kw_drive:
1207 sd->driveno = find_drive(token[++parameter], 1); /* insert drive information */
1208 break;
1209
1210 case kw_plex:
1211 sd->plexno = find_plex(token[++parameter], 1); /* insert plex information */
1212 break;
1213
1214 /*
1215 * Set the state. We can't do this directly,
1216 * because give_sd_to_plex may change it
1217 */
1218 case kw_state:
1219 parameter++; /* skip the keyword */
1220 if (vinum_conf.flags & VF_READING_CONFIG)
1221 state = SdState(token[parameter]); /* set the state */
1222 break;
1223
1224 case kw_partition:
1225 parameter++; /* skip the keyword */
1226 if ((strlen(token[parameter]) != 1)
1227 || (token[parameter][0] < 'a')
83d36d43 1228 || (token[parameter][0] > 'p'))
984263bc
MD
1229 throw_rude_remark(EINVAL,
1230 "%s: invalid partition %c",
1231 sd->name,
1232 token[parameter][0]);
984263bc
MD
1233 break;
1234
1235 case kw_retryerrors:
1236 sd->flags |= VF_RETRYERRORS;
1237 break;
1238
1239 default:
1240 throw_rude_remark(EINVAL, "%s: invalid keyword: %s", sd->name, token[parameter]);
1241 }
1242 }
1243
1244 /* Check we have a drive name */
1245 if (sd->driveno < 0) { /* didn't specify a drive */
1246 sd->driveno = current_drive; /* set to the current drive */
1247 if (sd->driveno < 0) /* no current drive? */
1248 throw_rude_remark(EINVAL, "Subdisk %s is not associated with a drive", sd->name);
1249 }
1250 /*
1251 * This is tacky. If something goes wrong
1252 * with the checks, we may end up losing drive
1253 * space. FIXME.
1254 */
1255 if (autosize != 0) /* need to find a size, */
1256 give_sd_to_drive(sdno); /* do it before the plex */
1257
1258 /* Check for a plex name */
1259 if ((sd->plexno < 0) /* didn't specify a plex */
1260 &&(!detached)) /* and didn't say not to, */
1261 sd->plexno = current_plex; /* set to the current plex */
1262
1263 if (sd->plexno >= 0)
1264 sdindex = give_sd_to_plex(sd->plexno, sdno); /* now tell the plex that it has this sd */
1265
1266 sd->sdno = sdno; /* point to our entry in the table */
1267
1268 /* Does the subdisk have a name? If not, give it one */
1269 if (sd->name[0] == '\0') { /* no name */
1270 char sdsuffix[8]; /* form sd name suffix here */
1271
1272 /* Do we have a plex name? */
1273 if (sdindex >= 0) /* we have a plex */
1274 strcpy(sd->name, PLEX[sd->plexno].name); /* take it from there */
1275 else /* no way */
1276 throw_rude_remark(EINVAL, "Unnamed sd is not associated with a plex");
f8c7a42d 1277 ksprintf(sdsuffix, ".s%d", sdindex); /* form the suffix */
984263bc
MD
1278 strcat(sd->name, sdsuffix); /* and add it to the name */
1279 }
1280 /* do we have complete info for this subdisk? */
1281 if (sd->sectors < 0)
1282 throw_rude_remark(EINVAL, "sd %s has no length spec", sd->name);
1283
d736a600 1284 if (state != sd_unallocated) { /* we had a specific state to set */
984263bc 1285 sd->state = state; /* do it now */
d736a600
MD
1286 made_sd(sd);
1287 } else if (sd->state == sd_unallocated) { /* no, nothing set yet, */
984263bc 1288 sd->state = sd_empty; /* must be empty */
d736a600
MD
1289 made_sd(sd);
1290 }
984263bc
MD
1291 if (autosize == 0) /* no autoconfig, do the drive now */
1292 give_sd_to_drive(sdno);
1293 vinum_conf.subdisks_used++; /* one more in use */
1294}
1295
1296/*
1297 * Handle a plex definition.
1298 */
1299void
1300config_plex(int update)
1301{
1302 int parameter;
1303 int plexno; /* index of plex in vinum_conf */
1304 struct plex *plex; /* and pointer to it */
1305 int pindex = MAXPLEX; /* index in volume's plex list */
1306 int detached = 0; /* don't give it to a volume */
1307 int namedplexno;
1308 enum plexstate state = plex_init; /* state to set at end */
1309
1310 current_plex = -1; /* forget the previous plex */
1311 plexno = get_empty_plex(); /* allocate a plex */
1312 plex = &PLEX[plexno]; /* and point to it */
1313 plex->plexno = plexno; /* and back to the config */
1314
1315 for (parameter = 1; parameter < tokens; parameter++) { /* look at the other tokens */
1316 switch (get_keyword(token[parameter], &keyword_set)) {
1317 /*
1318 * If we have a 'name' parameter, it must
1319 * come first, because we're too lazy to tidy
1320 * up dangling refs if it comes later.
1321 */
1322 case kw_name:
1323 namedplexno = find_plex(token[++parameter], 0); /* find an existing plex with this name */
1324 if (namedplexno >= 0) { /* plex exists already, */
1325 if (PLEX[namedplexno].state == plex_referenced) { /* we've been told about this one */
1326 if (parameter > 2) /* we've done other things first, */
1327 throw_rude_remark(EINVAL,
1328 "plex %s: name parameter must come first\n", /* no go */
1329 token[parameter]);
1330 else {
1331 int i;
1332 struct volume *vol; /* for tidying up dangling references */
1333
1334 *plex = PLEX[namedplexno]; /* get the info */
d736a600
MD
1335 plex->plex_dev = NULL;
1336 made_plex(plex);
984263bc 1337 PLEX[namedplexno].state = plex_unallocated; /* and deallocate the other one */
d736a600 1338 made_plex(&PLEX[namedplexno]);
984263bc
MD
1339 vol = &VOL[plex->volno]; /* point to the volume */
1340 for (i = 0; i < MAXPLEX; i++) { /* for each plex */
1341 if (vol->plex[i] == namedplexno)
1342 vol->plex[i] = plexno; /* bend the pointer */
1343 }
1344 }
1345 break; /* use this one */
1346 }
1347 if (update) /* are we updating? */
1348 return; /* yes: that's OK, just return */
1349 else
1350 throw_rude_remark(EINVAL, "Duplicate plex %s", token[parameter]);
0d0607d0
MD
1351 } else {
1352 ksnprintf(plex->name, sizeof(plex->name),
1353 "%s", token[parameter]);
1354 }
984263bc
MD
1355 break;
1356
1357 case kw_detached:
1358 detached = 1;
1359 break;
1360
1361 case kw_org: /* plex organization */
1362 switch (get_keyword(token[++parameter], &keyword_set)) {
1363 case kw_concat:
1364 plex->organization = plex_concat;
1365 break;
1366
1367 case kw_striped:
1368 {
1369 int stripesize = sizespec(token[++parameter]);
1370
1371 plex->organization = plex_striped;
1372 if (stripesize % DEV_BSIZE != 0) /* not a multiple of block size, */
1373 throw_rude_remark(EINVAL, "plex %s: stripe size %d not a multiple of sector size",
1374 plex->name,
1375 stripesize);
1376 else
1377 plex->stripesize = stripesize / DEV_BSIZE;
1378 break;
1379 }
1380
1381 case kw_raid4:
1382 {
1383 int stripesize = sizespec(token[++parameter]);
1384
1385 plex->organization = plex_raid4;
1386 if (stripesize % DEV_BSIZE != 0) /* not a multiple of block size, */
1387 throw_rude_remark(EINVAL, "plex %s: stripe size %d not a multiple of sector size",
1388 plex->name,
1389 stripesize);
1390 else
1391 plex->stripesize = stripesize / DEV_BSIZE;
1392 break;
1393 }
1394
1395 case kw_raid5:
1396 {
1397 int stripesize = sizespec(token[++parameter]);
1398
1399 plex->organization = plex_raid5;
1400 if (stripesize % DEV_BSIZE != 0) /* not a multiple of block size, */
1401 throw_rude_remark(EINVAL, "plex %s: stripe size %d not a multiple of sector size",
1402 plex->name,
1403 stripesize);
1404 else
1405 plex->stripesize = stripesize / DEV_BSIZE;
1406 break;
1407 }
1408
1409 default:
1410 throw_rude_remark(EINVAL, "Invalid plex organization");
1411 }
1412 if (isstriped(plex)
1413 && (plex->stripesize == 0)) /* didn't specify a valid stripe size */
1414 throw_rude_remark(EINVAL, "Need a stripe size parameter");
1415 break;
1416
1417 case kw_volume:
1418 plex->volno = find_volume(token[++parameter], 1); /* insert a pointer to the volume */
1419 break;
1420
1421 case kw_sd: /* add a subdisk */
1422 {
1423 int sdno;
1424
1425 sdno = find_subdisk(token[++parameter], 1); /* find a subdisk */
1426 SD[sdno].plexoffset = sizespec(token[++parameter]); /* get the offset */
1427 give_sd_to_plex(plexno, sdno); /* and insert it there */
1428 break;
1429 }
1430
1431 case kw_state:
1432 parameter++; /* skip the keyword */
1433 if (vinum_conf.flags & VF_READING_CONFIG)
1434 state = PlexState(token[parameter]); /* set the state */
1435 break;
1436
1437 default:
1438 throw_rude_remark(EINVAL, "plex %s, invalid keyword: %s",
1439 plex->name,
1440 token[parameter]);
1441 }
1442 }
1443
1444 if (plex->organization == plex_disorg)
1445 throw_rude_remark(EINVAL, "No plex organization specified");
1446
1447 if ((plex->volno < 0) /* we don't have a volume */
1448 &&(!detached)) /* and we wouldn't object */
1449 plex->volno = current_volume;
1450
1451 if (plex->volno >= 0)
1452 pindex = give_plex_to_volume(plex->volno, plexno); /* Now tell the volume that it has this plex */
1453
1454 /* Does the plex have a name? If not, give it one */
1455 if (plex->name[0] == '\0') { /* no name */
1456 char plexsuffix[8]; /* form plex name suffix here */
1457 /* Do we have a volume name? */
1458 if (plex->volno >= 0) /* we have a volume */
1459 strcpy(plex->name, /* take it from there */
1460 VOL[plex->volno].name);
1461 else /* no way */
1462 throw_rude_remark(EINVAL, "Unnamed plex is not associated with a volume");
f8c7a42d 1463 ksprintf(plexsuffix, ".p%d", pindex); /* form the suffix */
984263bc
MD
1464 strcat(plex->name, plexsuffix); /* and add it to the name */
1465 }
1466 if (isstriped(plex)) {
1467 plex->lock = (struct rangelock *)
1468 Malloc(PLEX_LOCKS * sizeof(struct rangelock));
1469 CHECKALLOC(plex->lock, "vinum: Can't allocate lock table\n");
1470 bzero((char *) plex->lock, PLEX_LOCKS * sizeof(struct rangelock));
1471 }
1472 /* Note the last plex we configured */
1473 current_plex = plexno;
1474 plex->state = state; /* set whatever state we chose */
d736a600 1475 made_plex(plex);
984263bc
MD
1476 vinum_conf.plexes_used++; /* one more in use */
1477}
1478
1479/*
1480 * Handle a volume definition.
1481 * If we find an error, print a message, deallocate the nascent volume, and return
1482 */
1483void
1484config_volume(int update)
1485{
1486 int parameter;
1487 int volno;
1488 struct volume *vol; /* collect volume info here */
1489 int i;
1490
1491 if (tokens < 2) /* not enough tokens */
1492 throw_rude_remark(EINVAL, "Volume has no name");
1493 current_volume = -1; /* forget the previous volume */
1494 volno = find_volume(token[1], 1); /* allocate a volume to initialize */
1495 vol = &VOL[volno]; /* and get a pointer */
1496 if (update && ((vol->flags & VF_CREATED) == 0)) /* this volume exists already */
1497 return; /* don't do anything */
1498 vol->flags &= ~VF_CREATED; /* it exists now */
1499
1500 for (parameter = 2; parameter < tokens; parameter++) { /* look at all tokens */
1501 switch (get_keyword(token[parameter], &keyword_set)) {
1502 case kw_plex:
1503 {
1504 int plexno; /* index of this plex */
1505 int myplexno; /* and index if it's already ours */
1506
1507 plexno = find_plex(token[++parameter], 1); /* find a plex */
1508 if (plexno < 0) /* couldn't */
1509 break; /* we've already had an error message */
1510 myplexno = my_plex(volno, plexno); /* does it already belong to us? */
1511 if (myplexno > 0) /* yes, shouldn't get it again */
1512 throw_rude_remark(EINVAL,
1513 "Plex %s already belongs to volume %s",
1514 token[parameter],
1515 vol->name);
ade9289f 1516 else if (vol->plexes + 1 > 8) /* another entry */
984263bc
MD
1517 throw_rude_remark(EINVAL,
1518 "Too many plexes for volume %s",
1519 vol->name);
ade9289f
SS
1520 vol->plex[vol->plexes] = plexno;
1521 vol->plexes++;
984263bc
MD
1522 PLEX[plexno].state = plex_referenced; /* we know something about it */
1523 PLEX[plexno].volno = volno; /* and this volume references it */
1524 }
1525 break;
1526
1527 case kw_readpol:
1528 switch (get_keyword(token[++parameter], &keyword_set)) { /* decide what to do */
1529 case kw_round:
1530 vol->preferred_plex = ROUND_ROBIN_READPOL; /* default */
1531 break;
1532
1533 case kw_prefer:
1534 {
1535 int myplexno; /* index of this plex */
1536
1537 myplexno = find_plex(token[++parameter], 1); /* find a plex */
1538 if (myplexno < 0) /* couldn't */
1539 break; /* we've already had an error message */
1540 myplexno = my_plex(volno, myplexno); /* does it already belong to us? */
1541 if (myplexno > 0) /* yes */
1542 vol->preferred_plex = myplexno; /* just note the index */
1543 else if (++vol->plexes > 8) /* another entry */
1544 throw_rude_remark(EINVAL, "Too many plexes");
1545 else { /* space for the new plex */
1546 vol->plex[vol->plexes - 1] = myplexno; /* add it to our list */
1547 vol->preferred_plex = vol->plexes - 1; /* and note the index */
1548 }
1549 }
1550 break;
1551
1552 default:
1553 throw_rude_remark(EINVAL, "Invalid read policy");
1554 }
1555
1556 case kw_setupstate:
1557 vol->flags |= VF_CONFIG_SETUPSTATE; /* set the volume up later on */
1558 break;
1559
1560 case kw_state:
1561 parameter++; /* skip the keyword */
d736a600 1562 if (vinum_conf.flags & VF_READING_CONFIG) {
984263bc 1563 vol->state = VolState(token[parameter]); /* set the state */
f80ef8b6 1564 vol->volno = volno; /* needs correct volno to make devs */
d736a600
MD
1565 made_vol(vol);
1566 }
984263bc
MD
1567 break;
1568
1569 /*
1570 * XXX experimental ideas. These are not
1571 * documented, and will not be until I
1572 * decide they're worth keeping
1573 */
1574 case kw_writethrough: /* set writethrough mode */
1575 vol->flags |= VF_WRITETHROUGH;
1576 break;
1577
1578 case kw_writeback: /* set writeback mode */
1579 vol->flags &= ~VF_WRITETHROUGH;
1580 break;
1581
1582 case kw_raw:
1583 vol->flags |= VF_RAW; /* raw volume (no label) */
1584 break;
1585
1586 default:
1587 throw_rude_remark(EINVAL, "volume %s, invalid keyword: %s",
1588 vol->name,
1589 token[parameter]);
1590 }
1591 }
1592 current_volume = volno; /* note last referred volume */
1593 vol->volno = volno; /* also note in volume */
1594
1595 /*
1596 * Before we can actually use the volume, we need
1597 * a volume label. We could start to fake one here,
1598 * but it will be a lot easier when we have some
1599 * to copy from the drives, so defer it until we
1600 * set up the configuration. XXX
1601 */
d736a600 1602 if (vol->state == volume_unallocated) {
984263bc 1603 vol->state = volume_down; /* now ready to bring up at the end */
d736a600
MD
1604 made_vol(vol);
1605 }
984263bc
MD
1606
1607 /* Find out how big our volume is */
1608 for (i = 0; i < vol->plexes; i++)
0d0607d0 1609 vol->size = u64max(vol->size, PLEX[vol->plex[i]].length);
984263bc
MD
1610 vinum_conf.volumes_used++; /* one more in use */
1611}
1612
1613/*
1614 * Parse a config entry. CARE! This destroys the original contents of the
1615 * config entry, which we don't really need after this. More specifically, it
1616 * places \0 characters at the end of each token.
1617 *
1618 * Return 0 if all is well, otherwise EINVAL for invalid keyword,
1619 * or ENOENT if 'read' command doesn't find any drives.
1620 */
1621int
1622parse_config(char *cptr, struct keywordset *keyset, int update)
1623{
1624 int status;
1625
1626 status = 0; /* until proven otherwise */
1627 tokens = tokenize(cptr, token); /* chop up into tokens */
1628
1629 if (tokens <= 0) /* screwed up or empty line */
1630 return tokens; /* give up */
1631
1632 if (token[0][0] == '#') /* comment line */
1633 return 0;
1634
1635 switch (get_keyword(token[0], keyset)) { /* decide what to do */
1636 case kw_read: /* read config from a specified drive */
1637 status = vinum_scandisk(&token[1], tokens - 1); /* read the config from disk */
1638 break;
1639
1640 case kw_drive:
1641 config_drive(update);
1642 break;
1643
1644 case kw_subdisk:
1645 config_subdisk(update);
1646 break;
1647
1648 case kw_plex:
1649 config_plex(update);
1650 break;
1651
1652 case kw_volume:
1653 config_volume(update);
1654 break;
1655
1656 /* Anything else is invalid in this context */
1657 default:
1658 throw_rude_remark(EINVAL, /* should we die? */
1659 "Invalid configuration information: %s",
1660 token[0]);
1661 }
1662 return status;
1663}
1664
1665/*
1666 * parse a line handed in from userland via ioctl.
1667 * This differs only by the error reporting mechanism:
1668 * we return the error indication in the reply to the
1669 * ioctl, so we need to set a global static pointer in
1670 * this file. This technique works because we have
1671 * ensured that configuration is performed in a single-
1672 * threaded manner
1673 */
1674int
1675parse_user_config(char *cptr, struct keywordset *keyset)
1676{
1677 int status;
1678
1679 ioctl_reply = (struct _ioctl_reply *) cptr;
1680 status = parse_config(cptr, keyset, 0);
1681 if (status == ENOENT) /* from scandisk, but it can't tell us */
1682 strcpy(ioctl_reply->msg, "no drives found");
1683 ioctl_reply = NULL; /* don't do this again */
1684 return status;
1685}
1686
1687/* Remove an object */
1688void
1689remove(struct vinum_ioctl_msg *msg)
1690{
1691 struct vinum_ioctl_msg message = *msg; /* make a copy to hand on */
1692
1693 ioctl_reply = (struct _ioctl_reply *) msg; /* reinstate the address to reply to */
1694 ioctl_reply->error = 0; /* no error, */
1695 ioctl_reply->msg[0] = '\0'; /* no message */
1696
1697 switch (message.type) {
1698 case drive_object:
1699 remove_drive_entry(message.index, message.force);
1700 updateconfig(0);
1701 return;
1702
1703 case sd_object:
1704 remove_sd_entry(message.index, message.force, message.recurse);
1705 updateconfig(0);
1706 return;
1707
1708 case plex_object:
1709 remove_plex_entry(message.index, message.force, message.recurse);
1710 updateconfig(0);
1711 return;
1712
1713 case volume_object:
1714 remove_volume_entry(message.index, message.force, message.recurse);
1715 updateconfig(0);
1716 return;
1717
1718 default:
1719 ioctl_reply->error = EINVAL;
1720 strcpy(ioctl_reply->msg, "Invalid object type");
1721 }
1722}
1723
1724/* Remove a drive. */
1725void
1726remove_drive_entry(int driveno, int force)
1727{
1728 struct drive *drive = &DRIVE[driveno];
1729 int sdno;
1730
1731 if ((driveno > vinum_conf.drives_allocated) /* not a valid drive */
1732 ||(drive->state == drive_unallocated)) { /* or nothing there */
1733 ioctl_reply->error = EINVAL;
1734 strcpy(ioctl_reply->msg, "No such drive");
1735 } else if (drive->opencount > 0) { /* we have subdisks */
1736 if (force) { /* do it at any cost */
1737 for (sdno = 0; sdno < vinum_conf.subdisks_allocated; sdno++) {
1738 if ((SD[sdno].state != sd_unallocated) /* subdisk is allocated */
1739 &&(SD[sdno].driveno == driveno)) /* and it belongs to this drive */
1740 remove_sd_entry(sdno, force, 0);
1741 }
1742 remove_drive(driveno); /* now remove it */
1743 vinum_conf.drives_used--; /* one less drive */
1744 } else
1745 ioctl_reply->error = EBUSY; /* can't do that */
1746 } else {
1747 remove_drive(driveno); /* just remove it */
1748 vinum_conf.drives_used--; /* one less drive */
1749 }
1750}
1751
1752/* remove a subdisk */
1753void
1754remove_sd_entry(int sdno, int force, int recurse)
1755{
1756 struct sd *sd = &SD[sdno];
1757
1758 if ((sdno > vinum_conf.subdisks_allocated) /* not a valid sd */
1759 ||(sd->state == sd_unallocated)) { /* or nothing there */
1760 ioctl_reply->error = EINVAL;
1761 strcpy(ioctl_reply->msg, "No such subdisk");
1762 } else if (sd->flags & VF_OPEN) { /* we're open */
1763 ioctl_reply->error = EBUSY; /* no getting around that */
1764 return;
1765 } else if (sd->plexno >= 0) { /* we have a plex */
1766 if (force) { /* do it at any cost */
1767 struct plex *plex = &PLEX[sd->plexno]; /* point to our plex */
1768 int mysdno;
1769
1770 for (mysdno = 0; /* look for ourselves */
1771 mysdno < plex->subdisks && &SD[plex->sdnos[mysdno]] != sd;
1772 mysdno++);
1773 if (mysdno == plex->subdisks) /* didn't find it */
1774 log(LOG_ERR,
1775 "Error removing subdisk %s: not found in plex %s\n",
1776 SD[mysdno].name,
1777 plex->name);
1778 else { /* remove the subdisk from plex */
1779 if (mysdno < (plex->subdisks - 1)) /* not the last subdisk */
1780 bcopy(&plex->sdnos[mysdno + 1],
1781 &plex->sdnos[mysdno],
1782 (plex->subdisks - 1 - mysdno) * sizeof(int));
1783 plex->subdisks--;
1784 sd->plexno = -1; /* disown the subdisk */
1785 }
1786
1787 /*
1788 * Removing a subdisk from a striped or
1789 * RAID-4 or RAID-5 plex really tears the
1790 * hell out of the structure, and it needs
1791 * to be reinitialized.
1792 */
1793 if (plex->organization != plex_concat) /* not concatenated, */
1794 set_plex_state(plex->plexno, plex_faulty, setstate_force); /* need to reinitialize */
1795 log(LOG_INFO, "vinum: removing %s\n", sd->name);
1796 free_sd(sdno);
1797 } else
1798 ioctl_reply->error = EBUSY; /* can't do that */
1799 } else {
1800 log(LOG_INFO, "vinum: removing %s\n", sd->name);
1801 free_sd(sdno);
1802 }
1803}
1804
1805/* remove a plex */
1806void
1807remove_plex_entry(int plexno, int force, int recurse)
1808{
1809 struct plex *plex = &PLEX[plexno];
1810 int sdno;
1811
1812 if ((plexno > vinum_conf.plexes_allocated) /* not a valid plex */
1813 ||(plex->state == plex_unallocated)) { /* or nothing there */
1814 ioctl_reply->error = EINVAL;
1815 strcpy(ioctl_reply->msg, "No such plex");
1816 } else if (plex->flags & VF_OPEN) { /* we're open */
1817 ioctl_reply->error = EBUSY; /* no getting around that */
1818 return;
1819 }
1820 if (plex->subdisks) {
1821 if (force) { /* do it anyway */
1822 if (recurse) { /* remove all below */
1823 int sds = plex->subdisks;
1824 for (sdno = 0; sdno < sds; sdno++)
1825 free_sd(plex->sdnos[sdno]); /* free all subdisks */
1826 } else { /* just tear them out */
1827 int sds = plex->subdisks;
1828 for (sdno = 0; sdno < sds; sdno++)
1829 SD[plex->sdnos[sdno]].plexno = -1; /* no plex any more */
1830 }
1831 } else { /* can't do it without force */
1832 ioctl_reply->error = EBUSY; /* can't do that */
1833 return;
1834 }
1835 }
1836 if (plex->volno >= 0) { /* we are part of a volume */
1837 if (force) { /* do it at any cost */
1838 struct volume *vol = &VOL[plex->volno];
1839 int myplexno;
1840
1841 for (myplexno = 0; myplexno < vol->plexes; myplexno++)
1842 if (vol->plex[myplexno] == plexno) /* found it */
1843 break;
1844 if (myplexno == vol->plexes) /* didn't find it. Huh? */
1845 log(LOG_ERR,
1846 "Error removing plex %s: not found in volume %s\n",
1847 plex->name,
1848 vol->name);
1849 if (myplexno < (vol->plexes - 1)) /* not the last plex in the list */
1850 bcopy(&vol->plex[myplexno + 1],
1851 &vol->plex[myplexno],
1852 vol->plexes - 1 - myplexno);
1853 vol->plexes--;
1854 } else {
1855 ioctl_reply->error = EBUSY; /* can't do that */
1856 return;
1857 }
1858 }
1859 log(LOG_INFO, "vinum: removing %s\n", plex->name);
1860 free_plex(plexno);
1861 vinum_conf.plexes_used--; /* one less plex */
1862}
1863
1864/* remove a volume */
1865void
1866remove_volume_entry(int volno, int force, int recurse)
1867{
1868 struct volume *vol = &VOL[volno];
1869 int plexno;
1870
1871 if ((volno > vinum_conf.volumes_allocated) /* not a valid volume */
1872 ||(vol->state == volume_unallocated)) { /* or nothing there */
1873 ioctl_reply->error = EINVAL;
1874 strcpy(ioctl_reply->msg, "No such volume");
1875 } else if (vol->flags & VF_OPEN) /* we're open */
1876 ioctl_reply->error = EBUSY; /* no getting around that */
1877 else if (vol->plexes) {
1878 if (recurse && force) { /* remove all below */
1879 int plexes = vol->plexes;
1880
1881/* for (plexno = plexes - 1; plexno >= 0; plexno--) */
1882 for (plexno = 0; plexno < plexes; plexno++)
1883 remove_plex_entry(vol->plex[plexno], force, recurse);
1884 log(LOG_INFO, "vinum: removing %s\n", vol->name);
1885 free_volume(volno);
1886 vinum_conf.volumes_used--; /* one less volume */
1887 } else
1888 ioctl_reply->error = EBUSY; /* can't do that */
1889 } else {
1890 log(LOG_INFO, "vinum: removing %s\n", vol->name);
1891 free_volume(volno);
1892 vinum_conf.volumes_used--; /* one less volume */
1893 }
1894}
1895
1896/* Currently called only from ioctl */
1897void
1898update_sd_config(int sdno, int diskconfig)
1899{
1900 if (!diskconfig)
1901 set_sd_state(sdno, sd_up, setstate_configuring);
1902 SD[sdno].flags &= ~VF_NEWBORN;
1903}
1904
1905void
1906update_plex_config(int plexno, int diskconfig)
1907{
1908 u_int64_t size;
1909 int sdno;
1910 struct plex *plex = &PLEX[plexno];
1911 enum plexstate state = plex_up; /* state we want the plex in */
1912 int remainder; /* size of fractional stripe at end */
1913 int added_plex; /* set if we add a plex to a volume */
1914 int required_sds; /* number of subdisks we need */
1915 struct sd *sd;
1916 struct volume *vol;
354addd7 1917 int data_sds = 0; /* number of sds carrying data */
984263bc
MD
1918
1919 if (plex->state < plex_init) /* not a real plex, */
1920 return;
1921 added_plex = 0;
1922 if (plex->volno >= 0) { /* we have a volume */
1923 vol = &VOL[plex->volno];
1924
1925 /*
1926 * If we're newly born,
1927 * and the volume isn't,
1928 * and it has other plexes,
1929 * and we didn't read this mess from disk,
1930 * we were added later.
1931 */
1932 if ((plex->flags & VF_NEWBORN)
1933 && ((vol->flags & VF_NEWBORN) == 0)
1934 && (vol->plexes > 0)
1935 && (diskconfig == 0)) {
1936 added_plex = 1;
1937 state = plex_down; /* so take ourselves down */
1938 }
1939 }
1940 /*
1941 * Check that our subdisks make sense. For
1942 * striped, RAID-4 and RAID-5 plexes, we need at
1943 * least two subdisks, and they must all be the
1944 * same size.
1945 */
1946 if (plex->organization == plex_striped) {
1947 data_sds = plex->subdisks;
1948 required_sds = 2;
1949 } else if (isparity(plex)) { /* RAID 4 or 5 */
1950 data_sds = plex->subdisks - 1;
1951 required_sds = 3;
1952 } else
1953 required_sds = 0;
1954 if (required_sds > 0) { /* striped, RAID-4 or RAID-5 */
1955 if (plex->subdisks < required_sds) {
1956 log(LOG_ERR,
1957 "vinum: plex %s does not have at least %d subdisks\n",
1958 plex->name,
1959 required_sds);
1960 state = plex_faulty;
1961 }
1962 /*
1963 * Now see if the plex size is a multiple of
1964 * the stripe size. If not, trim off the end
1965 * of each subdisk and return it to the drive.
1966 */
1967 if (plex->length > 0) {
1968 if (data_sds > 0) {
1969 if (plex->stripesize > 0) {
1970 remainder = (int) (plex->length /* are we exact? */
1971 % ((u_int64_t) plex->stripesize * data_sds));
1972 if (remainder) { /* no */
1973 log(LOG_INFO, "vinum: removing %d blocks of partial stripe at the end of %s\n",
1974 remainder,
1975 plex->name);
1976 plex->length -= remainder; /* shorten the plex */
1977 remainder /= data_sds; /* spread the remainder amongst the sds */
1978 for (sdno = 0; sdno < plex->subdisks; sdno++) {
1979 sd = &SD[plex->sdnos[sdno]]; /* point to the subdisk */
1980 return_drive_space(sd->driveno, /* return the space */
1981 sd->driveoffset + sd->sectors - remainder,
1982 remainder);
1983 sd->sectors -= remainder; /* and shorten it */
1984 }
1985 }
1986 } else /* no data sds, */
1987 plex->length = 0; /* reset length */
1988 }
1989 }
1990 }
1991 size = 0;
1992 for (sdno = 0; sdno < plex->subdisks; sdno++) {
1993 sd = &SD[plex->sdnos[sdno]];
1994 if (isstriped(plex)
1995 && (sdno > 0)
1996 && (sd->sectors != SD[plex->sdnos[sdno - 1]].sectors)) {
1997 log(LOG_ERR, "vinum: %s must have equal sized subdisks\n", plex->name);
1998 state = plex_down;
1999 }
2000 size += sd->sectors;
d736a600 2001 if (added_plex) { /* we were added later */
984263bc 2002 sd->state = sd_stale; /* stale until proven otherwise */
d736a600
MD
2003 made_sd(sd);
2004 }
984263bc
MD
2005 }
2006
2007 if (plex->subdisks) { /* plex has subdisks, calculate size */
2008 /*
2009 * XXX We shouldn't need to calculate the size any
2010 * more. Check this some time
2011 */
2012 if (isparity(plex))
2013 size = size / plex->subdisks * (plex->subdisks - 1); /* less space for RAID-4 and RAID-5 */
2014 if (plex->length != size)
2015 log(LOG_INFO,
2016 "Correcting length of %s: was %lld, is %lld\n",
2017 plex->name,
2018 (long long) plex->length,
2019 (long long) size);
2020 plex->length = size;
2021 } else { /* no subdisks, */
2022 plex->length = 0; /* no size */
2023 state = plex_down; /* take it down */
2024 }
2025 update_plex_state(plexno); /* set the state */
2026 plex->flags &= ~VF_NEWBORN;
2027}
2028
2029void
2030update_volume_config(int volno, int diskconfig)
2031{
2032 struct volume *vol = &VOL[volno];
2033 struct plex *plex;
2034 int plexno;
2035
2036 if (vol->state != volume_unallocated)
2037 /*
2038 * Recalculate the size of the volume,
2039 * which might change if the original
2040 * plexes were not a multiple of the
2041 * stripe size.
2042 */
2043 {
2044 vol->size = 0;
2045 for (plexno = 0; plexno < vol->plexes; plexno++) {
2046 plex = &PLEX[vol->plex[plexno]];
0d0607d0
MD
2047 vol->size = u64max(plex->length, vol->size);
2048 plex->volplexno = plexno; /* note it in the plex */
984263bc
MD
2049 }
2050 }
0d0607d0 2051 vol->flags &= ~VF_NEWBORN; /* no longer newly born */
984263bc
MD
2052}
2053
2054/*
2055 * Update the global configuration.
2056 * diskconfig is != 0 if we're reading in a config
2057 * from disk. In this case, we don't try to
2058 * bring the devices up, though we will bring
2059 * them down if there's some error which got
2060 * missed when writing to disk.
2061 */
2062void
2063updateconfig(int diskconfig)
2064{
2065 int plexno;
2066 int volno;
2067
2068 for (plexno = 0; plexno < vinum_conf.plexes_allocated; plexno++)
2069 update_plex_config(plexno, diskconfig);
2070
2071 for (volno = 0; volno < vinum_conf.volumes_allocated; volno++) {
2072 if (VOL[volno].state > volume_uninit) {
2073 VOL[volno].flags &= ~VF_CONFIG_SETUPSTATE; /* no more setupstate */
2074 update_volume_state(volno);
2075 update_volume_config(volno, diskconfig);
2076 }
2077 }
2078 save_config();
2079}
2080
2081/*
2082 * Start manual changes to the configuration and lock out
2083 * others who may wish to do so.
2084 * XXX why do we need this and lock_config too?
2085 */
2086int
2087start_config(int force)
2088{
2089 int error;
2090
2091 current_drive = -1; /* note the last drive we mention, for
2092 * some defaults */
2093 current_plex = -1; /* and the same for the last plex */
2094 current_volume = -1; /* and the last volume */
2095 while ((vinum_conf.flags & VF_CONFIGURING) != 0) {
2096 vinum_conf.flags |= VF_WILL_CONFIGURE;
377d4740 2097 if ((error = tsleep(&vinum_conf, PCATCH, "vincfg", 0)) != 0)
984263bc
MD
2098 return error;
2099 }
2100 /*
2101 * We need two flags here: VF_CONFIGURING
2102 * tells other processes to hold off (this
2103 * function), and VF_CONFIG_INCOMPLETE
2104 * tells the state change routines not to
2105 * propagate incrememntal state changes
2106 */
2107 vinum_conf.flags |= VF_CONFIGURING | VF_CONFIG_INCOMPLETE;
2108 if (force)
2109 vinum_conf.flags |= VF_FORCECONFIG; /* overwrite differently named drives */
2110 current_drive = -1; /* reset the defaults */
2111 current_plex = -1; /* and the same for the last plex */
2112 current_volume = -1; /* and the last volme */
2113 return 0;
2114}
2115
2116/*
2117 * Update the config if update is 1, and unlock
2118 * it. We won't update the configuration if we
2119 * are called in a recursive loop via throw_rude_remark.
2120 */
2121void
2122finish_config(int update)
2123{
2124 /* we've finished our config */
2125 vinum_conf.flags &= ~(VF_CONFIG_INCOMPLETE | VF_READING_CONFIG | VF_FORCECONFIG);
2126 if (update)
2127 updateconfig(0); /* so update things */
2128 else
2129 updateconfig(1); /* do some updates only */
2130 vinum_conf.flags &= ~VF_CONFIGURING; /* and now other people can take a turn */
2131 if ((vinum_conf.flags & VF_WILL_CONFIGURE) != 0) {
2132 vinum_conf.flags &= ~VF_WILL_CONFIGURE;
2133 wakeup_one(&vinum_conf);
2134 }
2135}