xref: /dragonfly/sys/dev/raid/vinum/vinumconfig.c (revision ae71ac09)
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 
54 #include <sys/udev.h>
55 #include "vinumhdr.h"
56 #include "request.h"
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 */
67 static int current_drive;				    /* note the last drive we mention, for
68 							    * some defaults */
69 static int current_plex;				    /* and the same for the last plex */
70 static int current_volume;				    /* and the last volme */
71 static struct _ioctl_reply *ioctl_reply;		    /* struct to return via ioctl */
72 
73 static void made_sd(struct sd *sd);
74 static void made_vol(struct volume *vol);
75 static void made_plex(struct plex *plex);
76 
77 /* These values are used by most of these routines, so set them as globals */
78 static char *token[MAXTOKEN];				    /* pointers to individual tokens */
79 static int tokens;					    /* number of tokens */
80 
81 #define TOCONS	0x01
82 #define TOTTY	0x02
83 #define TOLOG	0x04
84 
85 struct 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  */
97 void
throw_rude_remark(int error,char * msg,...)98 throw_rude_remark(int error, char *msg,...)
99 {
100     __va_list ap;
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");
107     __va_start(ap, msg);
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 	 */
114 	    kvasnprintf(&text, MSG_MAX, msg, ap);
115 	    strcpy(ioctl_reply->msg, text);
116 	    ioctl_reply->error = error;			    /* first byte is the error number */
117 	    kvasfree(&text);
118     } else {
119 	kprintf("vinum: ");
120 	kvprintf(msg, ap);				    /* print to the console */
121 	kprintf("\n");
122     }
123     __va_end(ap);
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  */
151 int
my_plex(int volno,int plexno)152 my_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  */
168 int
my_sd(int plexno,int sdno)169 my_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 */
182 int
give_plex_to_volume(int volno,int plexno)183 give_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++)
211 	vol->size = u64max(vol->size, PLEX[vol->plex[i]].length);
212     return vol->plexes - 1;				    /* and return its index */
213 }
214 
215 /*
216  * Add subdisk to a plex if possible
217  */
218 int
give_sd_to_plex(int plexno,int sdno)219 give_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 */
266 	VOL[plex->volno].size = u64max(VOL[plex->volno].size, plex->length); /* adjust its size */
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  */
303 void
give_sd_to_drive(int sdno)304 give_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,
395 			"No space for %s on drive %s at offset %jd",
396 			sd->name,
397 			drive->label.name,
398 			(intmax_t)sd->driveoffset);
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 */
449 int
get_empty_drive(void)450 get_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 */
469     strcpy(drive->devicename, "unknown");		    /* and make the name ``unknown'' */
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 */
480 int
find_drive(const char * name,int create)481 find_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)
502 	ksnprintf(drive->label.name, sizeof(drive->label.name), "%s", name);
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  */
512 int
find_drive_by_dev(const char * devname,int create)513 find_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++) {
519 	drive = &DRIVE[driveno];
520 	if (strcmp(drive->devicename, devname) == 0 &&
521 	    drive->state > drive_unallocated
522 	) {
523 	    return driveno;
524 	}
525     }
526 
527     if (create == 0)
528 	return -1;
529 
530     driveno = get_empty_drive();
531     drive = &DRIVE[driveno];
532     ksnprintf(drive->devicename, sizeof(drive->devicename), "%s", devname);
533     /* in use, nothing worthwhile there */
534     drive->state = drive_referenced;
535     return driveno;
536 }
537 
538 /* Find an empty subdisk in the subdisk table */
539 int
get_empty_sd(void)540 get_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 */
571 void
free_drive(struct drive * drive)572 free_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  */
595 int
find_subdisk(const char * name,int create)596 find_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];
613     ksnprintf(sd->name, sizeof(sd->name), "%s", name);
614     return sdno;					    /* return the pointer */
615 }
616 
617 /* Return space to a drive */
618 void
return_drive_space(int driveno,int64_t offset,int length)619 return_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  */
716 void
free_sd(int sdno)717 free_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 */
729     sd->state = sd_unallocated;
730     made_sd(sd);
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 
736 static void
made_sd(struct sd * sd)737 made_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);
743 	udev_dict_set_cstr(sd->sd_dev, "subsystem", "raid");
744 	udev_dict_set_cstr(sd->sd_dev, "disk-type", "raid");
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 
759 static void
made_vol(struct volume * vol)760 made_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);
767 	udev_dict_set_cstr(vol->vol_dev, "subsystem", "raid");
768 	udev_dict_set_cstr(vol->vol_dev, "disk-type", "raid");
769     }
770     if (vol->vol_dev && vol->state == volume_unallocated) {
771 	destroy_dev(vol->vol_dev);
772 	vol->vol_dev = NULL;
773     }
774 }
775 
776 static void
made_plex(struct plex * plex)777 made_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);
783 	udev_dict_set_cstr(plex->plex_dev, "subsystem", "raid");
784 	udev_dict_set_cstr(plex->plex_dev, "disk-type", "raid");
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 
796 /* Find an empty plex in the plex table */
797 int
get_empty_plex(void)798 get_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  */
832 int
find_plex(const char * name,int create)833 find_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 */
850     ksnprintf(plex->name, sizeof(plex->name), "%s", name);
851     return plexno;					    /* return the pointer */
852 }
853 
854 /*
855  * Free an allocated plex entry
856  * and its associated memory areas
857  */
858 void
free_plex(int plexno)859 free_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);
868     plex->state = plex_unallocated;
869     made_plex(plex);
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 */
875 int
get_empty_volume(void)876 get_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  */
907 int
find_volume(const char * name,int create)908 find_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];
925     ksnprintf(vol->name, sizeof(vol->name), "%s", name);
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  */
934 void
free_volume(int volno)935 free_volume(int volno)
936 {
937     struct volume *vol;
938 
939     vol = &VOL[volno];
940     vol->state = volume_unallocated;
941     made_vol(vol);
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  */
952 void
config_drive(int update)953 config_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 	    }
995 
996 	    /*
997 	     * open the device and get the configuration
998 	     */
999 	    ksnprintf(drive->devicename, sizeof(drive->devicename),
1000 		      "%s", token[parameter]);
1001 	    partition_status = read_drive_label(drive, 1);
1002 
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 	     */
1046 	    ksnprintf(drive->devicename, sizeof(drive->devicename),
1047 		      "%s", token[parameter]);
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  */
1096 void
config_subdisk(int update)1097 config_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 */
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 */
1132 			sd->sd_dev = NULL;
1133 			made_sd(sd);
1134 			SD[namedsdno].state = sd_unallocated; /* and deallocate the referenced one */
1135 			made_sd(&SD[namedsdno]);
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]);
1147 	    } else {
1148 		    ksnprintf(sd->name, sizeof(sd->name),
1149 			      "%s", token[parameter]);
1150 	    }
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)
1191 		throw_rude_remark(EINVAL, "sd %s, length %jd not multiple of sector size", sd->name, (intmax_t)size);
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')
1228 		|| (token[parameter][0] > 'p'))
1229 		throw_rude_remark(EINVAL,
1230 		    "%s: invalid partition %c",
1231 		    sd->name,
1232 		    token[parameter][0]);
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");
1277 	ksprintf(sdsuffix, ".s%d", sdindex);		    /* form the suffix */
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 
1284     if (state != sd_unallocated) {			    /* we had a specific state to set */
1285 	sd->state = state;				    /* do it now */
1286 	made_sd(sd);
1287     } else if (sd->state == sd_unallocated) {		    /* no, nothing set yet, */
1288 	sd->state = sd_empty;				    /* must be empty */
1289 	made_sd(sd);
1290     }
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  */
1299 void
config_plex(int update)1300 config_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 */
1335 			plex->plex_dev = NULL;
1336 			made_plex(plex);
1337 			PLEX[namedplexno].state = plex_unallocated; /* and deallocate the other one */
1338 			made_plex(&PLEX[namedplexno]);
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]);
1351 	    } else {
1352 		    ksnprintf(plex->name, sizeof(plex->name),
1353 			      "%s", token[parameter]);
1354 	    }
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");
1463 	ksprintf(plexsuffix, ".p%d", pindex);		    /* form the suffix */
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 */
1475     made_plex(plex);
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  */
1483 void
config_volume(int update)1484 config_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);
1516 		else if (vol->plexes + 1 > 8)		    /* another entry */
1517 		    throw_rude_remark(EINVAL,
1518 			"Too many plexes for volume %s",
1519 			vol->name);
1520 		vol->plex[vol->plexes] = plexno;
1521 		vol->plexes++;
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 */
1562 	    if (vinum_conf.flags & VF_READING_CONFIG) {
1563 		vol->state = VolState(token[parameter]);    /* set the state */
1564 		vol->volno = volno;	/* needs correct volno to make devs */
1565 		made_vol(vol);
1566 	    }
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      */
1602     if (vol->state == volume_unallocated) {
1603 	vol->state = volume_down;			    /* now ready to bring up at the end */
1604 	made_vol(vol);
1605     }
1606 
1607     /* Find out how big our volume is */
1608     for (i = 0; i < vol->plexes; i++)
1609 	vol->size = u64max(vol->size, PLEX[vol->plex[i]].length);
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  */
1621 int
parse_config(char * cptr,struct keywordset * keyset,int update)1622 parse_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  */
1674 int
parse_user_config(char * cptr,struct keywordset * keyset)1675 parse_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 */
1688 void
remove(struct vinum_ioctl_msg * msg)1689 remove(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.  */
1725 void
remove_drive_entry(int driveno,int force)1726 remove_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 */
1753 void
remove_sd_entry(int sdno,int force,int recurse)1754 remove_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 */
1806 void
remove_plex_entry(int plexno,int force,int recurse)1807 remove_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 */
1865 void
remove_volume_entry(int volno,int force,int recurse)1866 remove_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 */
1897 void
update_sd_config(int sdno,int diskconfig)1898 update_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 
1905 void
update_plex_config(int plexno,int diskconfig)1906 update_plex_config(int plexno, int diskconfig)
1907 {
1908     u_int64_t size;
1909     int sdno;
1910     struct plex *plex = &PLEX[plexno];
1911     int remainder;					    /* size of fractional stripe at end */
1912     int added_plex;					    /* set if we add a plex to a volume */
1913     int required_sds;					    /* number of subdisks we need */
1914     struct sd *sd;
1915     struct volume *vol;
1916     int data_sds = 0;					    /* number of sds carrying data */
1917 
1918     if (plex->state < plex_init)			    /* not a real plex, */
1919 	return;
1920     added_plex = 0;
1921     if (plex->volno >= 0) {				    /* we have a volume */
1922 	vol = &VOL[plex->volno];
1923 
1924 	/*
1925 	 * If we're newly born,
1926 	 * and the volume isn't,
1927 	 * and it has other plexes,
1928 	 * and we didn't read this mess from disk,
1929 	 * we were added later.
1930 	 */
1931 	if ((plex->flags & VF_NEWBORN)
1932 	    && ((vol->flags & VF_NEWBORN) == 0)
1933 	    && (vol->plexes > 0)
1934 	    && (diskconfig == 0)) {
1935 	    added_plex = 1;
1936 	}
1937     }
1938     /*
1939      * Check that our subdisks make sense.  For
1940      * striped, RAID-4 and RAID-5 plexes, we need at
1941      * least two subdisks, and they must all be the
1942      * same size.
1943      */
1944     if (plex->organization == plex_striped) {
1945 	data_sds = plex->subdisks;
1946 	required_sds = 2;
1947     } else if (isparity(plex)) {			    /* RAID 4 or 5 */
1948 	data_sds = plex->subdisks - 1;
1949 	required_sds = 3;
1950     } else
1951 	required_sds = 0;
1952     if (required_sds > 0) {				    /* striped, RAID-4 or RAID-5 */
1953 	if (plex->subdisks < required_sds) {
1954 	    log(LOG_ERR,
1955 		"vinum: plex %s does not have at least %d subdisks\n",
1956 		plex->name,
1957 		required_sds);
1958 	}
1959 	/*
1960 	 * Now see if the plex size is a multiple of
1961 	 * the stripe size.  If not, trim off the end
1962 	 * of each subdisk and return it to the drive.
1963 	 */
1964 	if (plex->length > 0) {
1965 	    if (data_sds > 0) {
1966 		if (plex->stripesize > 0) {
1967 		    remainder = (int) (plex->length	    /* are we exact? */
1968 			% ((u_int64_t) plex->stripesize * data_sds));
1969 		    if (remainder) {			    /* no */
1970 			log(LOG_INFO, "vinum: removing %d blocks of partial stripe at the end of %s\n",
1971 			    remainder,
1972 			    plex->name);
1973 			plex->length -= remainder;	    /* shorten the plex */
1974 			remainder /= data_sds;		    /* spread the remainder amongst the sds */
1975 			for (sdno = 0; sdno < plex->subdisks; sdno++) {
1976 			    sd = &SD[plex->sdnos[sdno]];    /* point to the subdisk */
1977 			    return_drive_space(sd->driveno, /* return the space */
1978 				sd->driveoffset + sd->sectors - remainder,
1979 				remainder);
1980 			    sd->sectors -= remainder;	    /* and shorten it */
1981 			}
1982 		    }
1983 		} else					    /* no data sds, */
1984 		    plex->length = 0;			    /* reset length */
1985 	    }
1986 	}
1987     }
1988     size = 0;
1989     for (sdno = 0; sdno < plex->subdisks; sdno++) {
1990 	sd = &SD[plex->sdnos[sdno]];
1991 	if (isstriped(plex)
1992 	    && (sdno > 0)
1993 	    && (sd->sectors != SD[plex->sdnos[sdno - 1]].sectors)) {
1994 	    log(LOG_ERR, "vinum: %s must have equal sized subdisks\n", plex->name);
1995 	}
1996 	size += sd->sectors;
1997 	if (added_plex) {				    /* we were added later */
1998 	    sd->state = sd_stale;			    /* stale until proven otherwise */
1999 	    made_sd(sd);
2000 	}
2001     }
2002 
2003     if (plex->subdisks) {				    /* plex has subdisks, calculate size */
2004 	/*
2005 	 * XXX We shouldn't need to calculate the size any
2006 	 * more.  Check this some time
2007 	 */
2008 	if (isparity(plex))
2009 	    size = size / plex->subdisks * (plex->subdisks - 1); /* less space for RAID-4 and RAID-5 */
2010 	if (plex->length != size)
2011 	    log(LOG_INFO,
2012 		"Correcting length of %s: was %lld, is %lld\n",
2013 		plex->name,
2014 		(long long) plex->length,
2015 		(long long) size);
2016 	plex->length = size;
2017     } else {						    /* no subdisks, */
2018 	plex->length = 0;				    /* no size */
2019     }
2020     update_plex_state(plexno);				    /* set the state */
2021     plex->flags &= ~VF_NEWBORN;
2022 }
2023 
2024 void
update_volume_config(int volno,int diskconfig)2025 update_volume_config(int volno, int diskconfig)
2026 {
2027     struct volume *vol = &VOL[volno];
2028     struct plex *plex;
2029     int plexno;
2030 
2031     if (vol->state != volume_unallocated)
2032 	/*
2033 	 * Recalculate the size of the volume,
2034 	 * which might change if the original
2035 	 * plexes were not a multiple of the
2036 	 * stripe size.
2037 	 */
2038     {
2039 	vol->size = 0;
2040 	for (plexno = 0; plexno < vol->plexes; plexno++) {
2041 	    plex = &PLEX[vol->plex[plexno]];
2042 	    vol->size = u64max(plex->length, vol->size);
2043 	    plex->volplexno = plexno;	    /* note it in the plex */
2044 	}
2045     }
2046     vol->flags &= ~VF_NEWBORN;		    /* no longer newly born */
2047 }
2048 
2049 /*
2050  * Update the global configuration.
2051  * diskconfig is != 0 if we're reading in a config
2052  * from disk.  In this case, we don't try to
2053  * bring the devices up, though we will bring
2054  * them down if there's some error which got
2055  * missed when writing to disk.
2056  */
2057 void
updateconfig(int diskconfig)2058 updateconfig(int diskconfig)
2059 {
2060     int plexno;
2061     int volno;
2062 
2063     for (plexno = 0; plexno < vinum_conf.plexes_allocated; plexno++)
2064 	update_plex_config(plexno, diskconfig);
2065 
2066     for (volno = 0; volno < vinum_conf.volumes_allocated; volno++) {
2067 	if (VOL[volno].state > volume_uninit) {
2068 	    VOL[volno].flags &= ~VF_CONFIG_SETUPSTATE;	    /* no more setupstate */
2069 	    update_volume_state(volno);
2070 	    update_volume_config(volno, diskconfig);
2071 	}
2072     }
2073     save_config();
2074 }
2075 
2076 /*
2077  * Start manual changes to the configuration and lock out
2078  * others who may wish to do so.
2079  * XXX why do we need this and lock_config too?
2080  */
2081 int
start_config(int force)2082 start_config(int force)
2083 {
2084     int error;
2085 
2086     current_drive = -1;					    /* note the last drive we mention, for
2087 							    * some defaults */
2088     current_plex = -1;					    /* and the same for the last plex */
2089     current_volume = -1;				    /* and the last volume */
2090     while ((vinum_conf.flags & VF_CONFIGURING) != 0) {
2091 	vinum_conf.flags |= VF_WILL_CONFIGURE;
2092 	if ((error = tsleep(&vinum_conf, PCATCH, "vincfg", 0)) != 0)
2093 	    return error;
2094     }
2095     /*
2096      * We need two flags here: VF_CONFIGURING
2097      * tells other processes to hold off (this
2098      * function), and VF_CONFIG_INCOMPLETE
2099      * tells the state change routines not to
2100      * propagate incrememntal state changes
2101      */
2102     vinum_conf.flags |= VF_CONFIGURING | VF_CONFIG_INCOMPLETE;
2103     if (force)
2104 	vinum_conf.flags |= VF_FORCECONFIG;		    /* overwrite differently named drives */
2105     current_drive = -1;					    /* reset the defaults */
2106     current_plex = -1;					    /* and the same for the last plex */
2107     current_volume = -1;				    /* and the last volme */
2108     return 0;
2109 }
2110 
2111 /*
2112  * Update the config if update is 1, and unlock
2113  * it.  We won't update the configuration if we
2114  * are called in a recursive loop via throw_rude_remark.
2115  */
2116 void
finish_config(int update)2117 finish_config(int update)
2118 {
2119     /* we've finished our config */
2120     vinum_conf.flags &= ~(VF_CONFIG_INCOMPLETE | VF_READING_CONFIG | VF_FORCECONFIG);
2121     if (update)
2122 	updateconfig(0);				    /* so update things */
2123     else
2124 	updateconfig(1);				    /* do some updates only */
2125     vinum_conf.flags &= ~VF_CONFIGURING;		    /* and now other people can take a turn */
2126     if ((vinum_conf.flags & VF_WILL_CONFIGURE) != 0) {
2127 	vinum_conf.flags &= ~VF_WILL_CONFIGURE;
2128 	wakeup_one(&vinum_conf);
2129     }
2130 }
2131