Fix a minor bug that prevented compilation.
[dragonfly.git] / sys / dev / raid / vinum / vinumioctl.c
CommitLineData
984263bc
MD
1/*
2 * XXX replace all the checks on object validity with
3 * calls to valid<object>
4 */
5/*-
6 * Copyright (c) 1997, 1998, 1999
7 * Nan Yang Computer Services Limited. All rights reserved.
8 *
9 * Parts copyright (c) 1997, 1998 Cybernet Corporation, NetMAX project.
10 *
11 * Written by Greg Lehey
12 *
13 * This software is distributed under the so-called ``Berkeley
14 * License'':
15 *
16 * Redistribution and use in source and binary forms, with or without
17 * modification, are permitted provided that the following conditions
18 * are met:
19 * 1. Redistributions of source code must retain the above copyright
20 * notice, this list of conditions and the following disclaimer.
21 * 2. Redistributions in binary form must reproduce the above copyright
22 * notice, this list of conditions and the following disclaimer in the
23 * documentation and/or other materials provided with the distribution.
24 * 3. All advertising materials mentioning features or use of this software
25 * must display the following acknowledgement:
26 * This product includes software developed by Nan Yang Computer
27 * Services Limited.
28 * 4. Neither the name of the Company nor the names of its contributors
29 * may be used to endorse or promote products derived from this software
30 * without specific prior written permission.
31 *
32 * This software is provided ``as is'', and any express or implied
33 * warranties, including, but not limited to, the implied warranties of
34 * merchantability and fitness for a particular purpose are disclaimed.
35 * In no event shall the company or contributors be liable for any
36 * direct, indirect, incidental, special, exemplary, or consequential
37 * damages (including, but not limited to, procurement of substitute
38 * goods or services; loss of use, data, or profits; or business
39 * interruption) however caused and on any theory of liability, whether
40 * in contract, strict liability, or tort (including negligence or
41 * otherwise) arising in any way out of the use of this software, even if
42 * advised of the possibility of such damage.
43 *
44 * $Id: vinumioctl.c,v 1.14 2000/10/27 03:07:53 grog Exp grog $
45 * $FreeBSD: src/sys/dev/vinum/vinumioctl.c,v 1.25.2.4 2002/02/03 00:44:19 grog Exp $
6b08710e 46 * $DragonFly: src/sys/dev/raid/vinum/vinumioctl.c,v 1.5 2003/11/15 21:05:42 dillon Exp $
984263bc
MD
47 */
48
1f2de5d4
MD
49#include "vinumhdr.h"
50#include "request.h"
984263bc
MD
51
52#ifdef VINUMDEBUG
53#include <sys/reboot.h>
54#endif
55
56void attachobject(struct vinum_ioctl_msg *);
57void detachobject(struct vinum_ioctl_msg *);
58void renameobject(struct vinum_rename_msg *);
59void replaceobject(struct vinum_ioctl_msg *);
60void moveobject(struct vinum_ioctl_msg *);
61
62jmp_buf command_fail; /* return on a failed command */
63
64/* ioctl routine */
65int
41c20dac 66vinumioctl(dev_t dev, u_long cmd, caddr_t data, int flag, d_thread_t *td)
984263bc
MD
67{
68 unsigned int objno;
69 int error = 0;
70 struct sd *sd;
71 struct plex *plex;
72 struct volume *vol;
73 unsigned int index; /* for transferring config info */
74 unsigned int sdno; /* for transferring config info */
75 int fe; /* free list element number */
76 struct _ioctl_reply *ioctl_reply = (struct _ioctl_reply *) data; /* struct to return */
77
78 /* First, decide what we're looking at */
79 switch (DEVTYPE(dev)) {
80 case VINUM_SUPERDEV_TYPE: /* ordinary super device */
81 ioctl_reply = (struct _ioctl_reply *) data; /* save the address to reply to */
82 switch (cmd) {
83#ifdef VINUMDEBUG
84 case VINUM_DEBUG:
85 if (((struct debuginfo *) data)->changeit) /* change debug settings */
86 debug = (((struct debuginfo *) data)->param);
87 else {
88 if (debug & DEBUG_REMOTEGDB)
89 boothowto |= RB_GDB; /* serial debug line */
90 else
91 boothowto &= ~RB_GDB; /* local ddb */
92 Debugger("vinum debug");
93 }
94 ioctl_reply = (struct _ioctl_reply *) data; /* reinstate the address to reply to */
95 ioctl_reply->error = 0;
96 return 0;
97#endif
98
99 case VINUM_CREATE: /* create a vinum object */
100 error = lock_config(); /* get the config for us alone */
101 if (error) /* can't do it, */
102 return error; /* give up */
103 error = setjmp(command_fail); /* come back here on error */
104 if (error == 0) /* first time, */
105 ioctl_reply->error = parse_user_config((char *) data, /* update the config */
106 &keyword_set);
107 else if (ioctl_reply->error == 0) { /* longjmp, but no error status */
108 ioctl_reply->error = EINVAL; /* note that something's up */
109 ioctl_reply->msg[0] = '\0'; /* no message? */
110 }
111 unlock_config();
112 return 0; /* must be 0 to return the real error info */
113
114 case VINUM_GETCONFIG: /* get the configuration information */
115 bcopy(&vinum_conf, data, sizeof(vinum_conf));
116 return 0;
117
118 /* start configuring the subsystem */
119 case VINUM_STARTCONFIG:
120 return start_config(*(int *) data); /* just lock it. Parameter is 'force' */
121
122 /*
123 * Move the individual parts of the config to user space.
124 *
125 * Specify the index of the object in the first word of data,
126 * and return the object there
127 */
128 case VINUM_DRIVECONFIG:
129 index = *(int *) data; /* get the index */
130 if (index >= (unsigned) vinum_conf.drives_allocated) /* can't do it */
131 return ENXIO; /* bang */
132 bcopy(&DRIVE[index], data, sizeof(struct drive)); /* copy the config item out */
133 return 0;
134
135 case VINUM_SDCONFIG:
136 index = *(int *) data; /* get the index */
137 if (index >= (unsigned) vinum_conf.subdisks_allocated) /* can't do it */
138 return ENXIO; /* bang */
139 bcopy(&SD[index], data, sizeof(struct sd)); /* copy the config item out */
140 return 0;
141
142 case VINUM_PLEXCONFIG:
143 index = *(int *) data; /* get the index */
144 if (index >= (unsigned) vinum_conf.plexes_allocated) /* can't do it */
145 return ENXIO; /* bang */
146 bcopy(&PLEX[index], data, sizeof(struct plex)); /* copy the config item out */
147 return 0;
148
149 case VINUM_VOLCONFIG:
150 index = *(int *) data; /* get the index */
151 if (index >= (unsigned) vinum_conf.volumes_allocated) /* can't do it */
152 return ENXIO; /* bang */
153 bcopy(&VOL[index], data, sizeof(struct volume)); /* copy the config item out */
154 return 0;
155
156 case VINUM_PLEXSDCONFIG:
157 index = *(int *) data; /* get the plex index */
158 sdno = ((int *) data)[1]; /* and the sd index */
159 if ((index >= (unsigned) vinum_conf.plexes_allocated) /* plex doesn't exist */
160 ||(sdno >= PLEX[index].subdisks)) /* or it doesn't have this many subdisks */
161 return ENXIO; /* bang */
162 bcopy(&SD[PLEX[index].sdnos[sdno]], /* copy the config item out */
163 data,
164 sizeof(struct sd));
165 return 0;
166
167 /*
168 * We get called in two places: one from the
169 * userland config routines, which call us
170 * to complete the config and save it. This
171 * call supplies the value 0 as a parameter.
172 *
173 * The other place is from the user "saveconfig"
174 * routine, which can only work if we're *not*
175 * configuring. In this case, supply parameter 1.
176 */
177 case VINUM_SAVECONFIG:
178 if (VFLAGS & VF_CONFIGURING) { /* must be us, the others are asleep */
179 if (*(int *) data == 0) /* finish config */
180 finish_config(1); /* finish the configuration and update it */
181 else
182 return EBUSY; /* can't do it now */
183 }
184 save_config(); /* save configuration to disk */
185 return 0;
186
187 case VINUM_RELEASECONFIG: /* release the config */
188 if (VFLAGS & VF_CONFIGURING) { /* must be us, the others are asleep */
189 finish_config(0); /* finish the configuration, don't change it */
190 save_config(); /* save configuration to disk */
191 } else
192 error = EINVAL; /* release what config? */
193 return error;
194
195 case VINUM_INIT:
196 ioctl_reply = (struct _ioctl_reply *) data; /* reinstate the address to reply to */
197 ioctl_reply->error = 0;
198 return 0;
199
200 case VINUM_RESETCONFIG:
201 if (vinum_inactive(0)) { /* if the volumes are not active */
202 /*
203 * Note the open count. We may be called from v, so we'll be open.
204 * Keep the count so we don't underflow
205 */
206 free_vinum(1); /* clean up everything */
207 log(LOG_NOTICE, "vinum: CONFIGURATION OBLITERATED\n");
208 ioctl_reply = (struct _ioctl_reply *) data; /* reinstate the address to reply to */
209 ioctl_reply->error = 0;
210 return 0;
211 }
212 return EBUSY;
213
214 case VINUM_SETSTATE:
215 setstate((struct vinum_ioctl_msg *) data); /* set an object state */
216 return 0;
217
218 /*
219 * Set state by force, without changing
220 * anything else.
221 */
222 case VINUM_SETSTATE_FORCE:
223 setstate_by_force((struct vinum_ioctl_msg *) data); /* set an object state */
224 return 0;
225
226#ifdef VINUMDEBUG
227 case VINUM_MEMINFO:
228 vinum_meminfo(data);
229 return 0;
230
231 case VINUM_MALLOCINFO:
232 return vinum_mallocinfo(data);
233
234 case VINUM_RQINFO:
235 return vinum_rqinfo(data);
236#endif
237
238 case VINUM_LABEL: /* label a volume */
239 ioctl_reply->error = write_volume_label(*(int *) data); /* index of the volume to label */
240 ioctl_reply->msg[0] = '\0'; /* no message */
241 return 0;
242
243 case VINUM_REMOVE:
244 remove((struct vinum_ioctl_msg *) data); /* remove an object */
245 return 0;
246
247 case VINUM_GETFREELIST: /* get a drive free list element */
248 index = *(int *) data; /* get the drive index */
249 fe = ((int *) data)[1]; /* and the free list element */
250 if ((index >= (unsigned) vinum_conf.drives_allocated) /* plex doesn't exist */
251 ||(DRIVE[index].state == drive_unallocated))
252 return ENODEV;
253 if (fe >= DRIVE[index].freelist_entries) /* no such entry */
254 return ENOENT;
255 bcopy(&DRIVE[index].freelist[fe],
256 data,
257 sizeof(struct drive_freelist));
258 return 0;
259
260 case VINUM_RESETSTATS:
261 resetstats((struct vinum_ioctl_msg *) data); /* reset object stats */
262 return 0;
263
264 /* attach an object to a superordinate object */
265 case VINUM_ATTACH:
266 attachobject((struct vinum_ioctl_msg *) data);
267 return 0;
268
269 /* detach an object from a superordinate object */
270 case VINUM_DETACH:
271 detachobject((struct vinum_ioctl_msg *) data);
272 return 0;
273
274 /* rename an object */
275 case VINUM_RENAME:
276 renameobject((struct vinum_rename_msg *) data);
277 return 0;
278
279 /* replace an object */
280 case VINUM_REPLACE:
281 replaceobject((struct vinum_ioctl_msg *) data);
282 return 0;
283
284 case VINUM_DAEMON:
285 vinum_daemon(); /* perform the daemon */
286 return 0;
287
288 case VINUM_FINDDAEMON: /* check for presence of daemon */
289 return vinum_finddaemon();
290 return 0;
291
292 case VINUM_SETDAEMON: /* set daemon flags */
293 return vinum_setdaemonopts(*(int *) data);
294
295 case VINUM_GETDAEMON: /* get daemon flags */
296 *(int *) data = daemon_options;
297 return 0;
298
299 case VINUM_PARITYOP: /* check/rebuild RAID-4/5 parity */
300 parityops((struct vinum_ioctl_msg *) data);
301 return 0;
302
303 /* move an object */
304 case VINUM_MOVE:
305 moveobject((struct vinum_ioctl_msg *) data);
306 return 0;
984263bc
MD
307 default:
308 /* FALLTHROUGH */
6b08710e 309 break;
984263bc
MD
310 }
311
312 case VINUM_DRIVE_TYPE:
313 default:
314 log(LOG_WARNING,
315 "vinumioctl: invalid ioctl from process %d (%s): %lx\n",
316 curproc->p_pid,
317 curproc->p_comm,
318 cmd);
319 return EINVAL;
320
321 case VINUM_SD_TYPE:
322 case VINUM_RAWSD_TYPE:
323 objno = Sdno(dev);
324
325 sd = &SD[objno];
326
327 switch (cmd) {
328 case DIOCGDINFO: /* get disk label */
329 get_volume_label(sd->name, 1, sd->sectors, (struct disklabel *) data);
330 break;
331
332 /*
333 * We don't have this stuff on hardware,
334 * so just pretend to do it so that
335 * utilities don't get upset.
336 */
337 case DIOCWDINFO: /* write partition info */
338 case DIOCSDINFO: /* set partition info */
339 return 0; /* not a titty */
340
341 default:
342 return ENOTTY; /* not my kind of ioctl */
343 }
344
345 return 0; /* pretend we did it */
346
347 case VINUM_RAWPLEX_TYPE:
348 case VINUM_PLEX_TYPE:
349 objno = Plexno(dev);
350
351 plex = &PLEX[objno];
352
353 switch (cmd) {
354 case DIOCGDINFO: /* get disk label */
355 get_volume_label(plex->name, 1, plex->length, (struct disklabel *) data);
356 break;
357
358 /*
359 * We don't have this stuff on hardware,
360 * so just pretend to do it so that
361 * utilities don't get upset.
362 */
363 case DIOCWDINFO: /* write partition info */
364 case DIOCSDINFO: /* set partition info */
365 return 0; /* not a titty */
366
367 default:
368 return ENOTTY; /* not my kind of ioctl */
369 }
370
371 return 0; /* pretend we did it */
372
373 case VINUM_VOLUME_TYPE:
374 objno = Volno(dev);
375
376 if ((unsigned) objno >= (unsigned) vinum_conf.volumes_allocated) /* not a valid volume */
377 return ENXIO;
378 vol = &VOL[objno];
379 if (vol->state != volume_up) /* not up, */
380 return EIO; /* I/O error */
381
382 switch (cmd) {
383 case DIOCGDINFO: /* get disk label */
384 get_volume_label(vol->name, vol->plexes, vol->size, (struct disklabel *) data);
385 break;
386
387 /*
388 * Care! DIOCGPART returns *pointers* to
389 * the caller, so we need to store this crap
390 * as well. And yes, we need it.
391 */
392 case DIOCGPART: /* get partition information */
393 get_volume_label(vol->name, vol->plexes, vol->size, &vol->label);
394 ((struct partinfo *) data)->disklab = &vol->label;
395 ((struct partinfo *) data)->part = &vol->label.d_partitions[0];
396 break;
397
398 /*
399 * We don't have this stuff on hardware,
400 * so just pretend to do it so that
401 * utilities don't get upset.
402 */
403 case DIOCWDINFO: /* write partition info */
404 case DIOCSDINFO: /* set partition info */
405 return 0; /* not a titty */
406
407 case DIOCWLABEL: /* set or reset label writeable */
408 if ((flag & FWRITE) == 0) /* not writeable? */
409 return EACCES; /* no, die */
410 if (*(int *) data != 0) /* set it? */
411 vol->flags |= VF_WLABEL; /* yes */
412 else
413 vol->flags &= ~VF_WLABEL; /* no, reset */
414 break;
415
416 default:
417 return ENOTTY; /* not my kind of ioctl */
418 }
419 break;
420 }
421 return 0; /* XXX */
422}
423
424/*
425 * The following four functions check the supplied
426 * object index and return a pointer to the object
427 * if it exists. Otherwise they longjump out via
428 * throw_rude_remark.
429 */
430struct drive *
431validdrive(int driveno, struct _ioctl_reply *reply)
432{
433 if ((driveno < vinum_conf.drives_allocated)
434 && (DRIVE[driveno].state > drive_referenced))
435 return &DRIVE[driveno];
436 strcpy(reply->msg, "No such drive");
437 reply->error = ENOENT;
438 return NULL;
439}
440
441struct sd *
442validsd(int sdno, struct _ioctl_reply *reply)
443{
444 if ((sdno < vinum_conf.subdisks_allocated)
445 && (SD[sdno].state > sd_referenced))
446 return &SD[sdno];
447 strcpy(reply->msg, "No such subdisk");
448 reply->error = ENOENT;
449 return NULL;
450}
451
452struct plex *
453validplex(int plexno, struct _ioctl_reply *reply)
454{
455 if ((plexno < vinum_conf.plexes_allocated)
456 && (PLEX[plexno].state > plex_referenced))
457 return &PLEX[plexno];
458 strcpy(reply->msg, "No such plex");
459 reply->error = ENOENT;
460 return NULL;
461}
462
463struct volume *
464validvol(int volno, struct _ioctl_reply *reply)
465{
466 if ((volno < vinum_conf.volumes_allocated)
467 && (VOL[volno].state > volume_uninit))
468 return &VOL[volno];
469 strcpy(reply->msg, "No such volume");
470 reply->error = ENOENT;
471 return NULL;
472}
473
474/* reset an object's stats */
475void
476resetstats(struct vinum_ioctl_msg *msg)
477{
478 struct _ioctl_reply *reply = (struct _ioctl_reply *) msg;
479
480 switch (msg->type) {
481 case drive_object:
482 if (msg->index < vinum_conf.drives_allocated) {
483 struct drive *drive = &DRIVE[msg->index];
484 if (drive->state > drive_referenced) {
485 drive->reads = 0; /* number of reads on this drive */
486 drive->writes = 0; /* number of writes on this drive */
487 drive->bytes_read = 0; /* number of bytes read */
488 drive->bytes_written = 0; /* number of bytes written */
489 reply->error = 0;
490 return;
491 }
492 reply->error = EINVAL;
493 return;
494 }
495 case sd_object:
496 if (msg->index < vinum_conf.subdisks_allocated) {
497 struct sd *sd = &SD[msg->index];
498 if (sd->state > sd_referenced) {
499 sd->reads = 0; /* number of reads on this subdisk */
500 sd->writes = 0; /* number of writes on this subdisk */
501 sd->bytes_read = 0; /* number of bytes read */
502 sd->bytes_written = 0; /* number of bytes written */
503 reply->error = 0;
504 return;
505 }
506 reply->error = EINVAL;
507 return;
508 }
509 break;
510
511 case plex_object:
512 if (msg->index < vinum_conf.plexes_allocated) {
513 struct plex *plex = &PLEX[msg->index];
514 if (plex->state > plex_referenced) {
515 plex->reads = 0;
516 plex->writes = 0; /* number of writes on this plex */
517 plex->bytes_read = 0; /* number of bytes read */
518 plex->bytes_written = 0; /* number of bytes written */
519 plex->recovered_reads = 0; /* number of recovered read operations */
520 plex->degraded_writes = 0; /* number of degraded writes */
521 plex->parityless_writes = 0; /* number of parityless writes */
522 plex->multiblock = 0; /* requests that needed more than one block */
523 plex->multistripe = 0; /* requests that needed more than one stripe */
524 reply->error = 0;
525 return;
526 }
527 reply->error = EINVAL;
528 return;
529 }
530 break;
531
532 case volume_object:
533 if (msg->index < vinum_conf.volumes_allocated) {
534 struct volume *vol = &VOL[msg->index];
535 if (vol->state > volume_uninit) {
536 vol->bytes_read = 0; /* number of bytes read */
537 vol->bytes_written = 0; /* number of bytes written */
538 vol->reads = 0; /* number of reads on this volume */
539 vol->writes = 0; /* number of writes on this volume */
540 vol->recovered_reads = 0; /* reads recovered from another plex */
541 reply->error = 0;
542 return;
543 }
544 reply->error = EINVAL;
545 return;
546 }
547 case invalid_object: /* can't get this */
548 reply->error = EINVAL;
549 return;
550 }
551}
552
553/* attach an object to a superior object */
554void
555attachobject(struct vinum_ioctl_msg *msg)
556{
557 struct _ioctl_reply *reply = (struct _ioctl_reply *) msg;
558 int sdno;
559 struct sd *sd;
560 struct plex *plex;
561 struct volume *vol;
562
563 switch (msg->type) {
564 case drive_object: /* you can't attach a drive to anything */
565 case volume_object: /* nor a volume */
566 case invalid_object: /* "this can't happen" */
567 reply->error = EINVAL;
568 reply->msg[0] = '\0'; /* vinum(8) doesn't do this */
569 return;
570
571 case sd_object:
572 sd = validsd(msg->index, reply);
573 if (sd == NULL) /* not a valid subdisk */
574 return;
575 plex = validplex(msg->otherobject, reply);
576 if (plex) {
577 /*
578 * We should be more intelligent about this.
579 * We should be able to reattach a dead
580 * subdisk, but if we want to increase the total
581 * number of subdisks, we have a lot of reshuffling
582 * to do. XXX
583 */
584 if ((plex->organization != plex_concat) /* can't attach to striped and RAID-4/5 */
585 &&(!msg->force)) { /* without using force */
586 reply->error = EINVAL; /* no message, the user should check */
587 strcpy(reply->msg, "Can't attach to this plex organization");
588 return;
589 }
590 if (sd->plexno >= 0) { /* already belong to a plex */
591 reply->error = EBUSY; /* no message, the user should check */
592 reply->msg[0] = '\0';
593 return;
594 }
595 sd->plexoffset = msg->offset; /* this is where we want it */
596 set_sd_state(sd->sdno, sd_stale, setstate_force); /* make sure it's stale */
597 give_sd_to_plex(plex->plexno, sd->sdno); /* and give it to the plex */
598 update_sd_config(sd->sdno, 0);
599 save_config();
600 }
601 if (sd->state == sd_reviving)
602 reply->error = EAGAIN; /* need to revive it */
603 else
604 reply->error = 0;
605 break;
606
607 case plex_object:
608 plex = validplex(msg->index, reply); /* get plex */
609 if (plex == NULL)
610 return;
611 vol = validvol(msg->otherobject, reply); /* and volume information */
612 if (vol) {
613 if ((vol->plexes == MAXPLEX) /* we have too many already */
614 ||(plex->volno >= 0)) { /* or the plex has an owner */
615 reply->error = EINVAL; /* no message, the user should check */
616 reply->msg[0] = '\0';
617 return;
618 }
619 for (sdno = 0; sdno < plex->subdisks; sdno++) {
620 sd = &SD[plex->sdnos[sdno]];
621
622 if (sd->state > sd_down) /* real subdisk, vaguely accessible */
623 set_sd_state(plex->sdnos[sdno], sd_stale, setstate_force); /* make it stale */
624 }
625 set_plex_state(plex->plexno, plex_up, setstate_none); /* update plex state */
626 give_plex_to_volume(msg->otherobject, msg->index); /* and give it to the volume */
627 update_plex_config(plex->plexno, 0);
628 save_config();
629 }
630 }
631}
632
633/* detach an object from a superior object */
634void
635detachobject(struct vinum_ioctl_msg *msg)
636{
637 struct _ioctl_reply *reply = (struct _ioctl_reply *) msg;
638 struct sd *sd;
639 struct plex *plex;
640 struct volume *vol;
641 int sdno;
642 int plexno;
643
644 switch (msg->type) {
645 case drive_object: /* you can't detach a drive from anything */
646 case volume_object: /* nor a volume */
647 case invalid_object: /* "this can't happen" */
648 reply->error = EINVAL;
649 reply->msg[0] = '\0'; /* vinum(8) doesn't do this */
650 return;
651
652 case sd_object:
653 sd = validsd(msg->index, reply);
654 if (sd == NULL)
655 return;
656 if (sd->plexno < 0) { /* doesn't belong to a plex */
657 reply->error = ENOENT;
658 strcpy(reply->msg, "Subdisk is not attached");
659 return;
660 } else { /* valid plex number */
661 plex = &PLEX[sd->plexno];
662 if ((!msg->force) /* don't force things */
663 &&((plex->state == plex_up) /* and the plex is up */
664 ||((plex->state == plex_flaky) && sd->state == sd_up))) { /* or flaky with this sd up */
665 reply->error = EBUSY; /* we need this sd */
666 reply->msg[0] = '\0';
667 return;
668 }
669 sd->plexno = -1; /* anonymous sd */
670 if (plex->subdisks == 1) { /* this was the only subdisk */
671 Free(plex->sdnos); /* free the subdisk array */
672 plex->sdnos = NULL; /* and note the fact */
673 plex->subdisks_allocated = 0; /* no subdisk space */
674 } else {
675 for (sdno = 0; sdno < plex->subdisks; sdno++) {
676 if (plex->sdnos[sdno] == msg->index) /* found our subdisk */
677 break;
678 }
679 if (sdno < (plex->subdisks - 1)) /* not the last one, compact */
680 bcopy(&plex->sdnos[sdno + 1],
681 &plex->sdnos[sdno],
682 (plex->subdisks - 1 - sdno) * sizeof(int));
683 }
684 plex->subdisks--;
685 if (!bcmp(plex->name, sd->name, strlen(plex->name) + 1))
686 /* this subdisk is named after the plex */
687 {
688 bcopy(sd->name,
689 &sd->name[3],
690 min(strlen(sd->name) + 1, MAXSDNAME - 3));
691 bcopy("ex-", sd->name, 3);
692 sd->name[MAXSDNAME - 1] = '\0';
693 }
694 update_plex_config(plex->plexno, 0);
695 if (isstriped(plex)) /* we've just mutilated our plex, */
696 set_plex_state(plex->plexno,
697 plex_down,
698 setstate_force | setstate_configuring);
699 save_config();
700 reply->error = 0;
701 }
702 return;
703
704 case plex_object:
705 plex = validplex(msg->index, reply); /* get plex */
706 if (plex == NULL)
707 return;
708 if (plex->volno >= 0) {
709 int volno = plex->volno;
710
711 vol = &VOL[volno];
712 if ((!msg->force) /* don't force things */
713 &&((vol->state == volume_up) /* and the volume is up */
714 &&(vol->plexes == 1))) { /* and this is the last plex */
715 /*
716 * XXX As elsewhere, check whether we will lose
717 * mapping by removing this plex
718 */
719 reply->error = EBUSY; /* we need this plex */
720 reply->msg[0] = '\0';
721 return;
722 }
723 plex->volno = -1; /* anonymous plex */
724 for (plexno = 0; plexno < vol->plexes; plexno++) {
725 if (vol->plex[plexno] == msg->index) /* found our plex */
726 break;
727 }
728 if (plexno < (vol->plexes - 1)) /* not the last one, compact */
729 bcopy(&vol->plex[plexno + 1],
730 &vol->plex[plexno],
731 (vol->plexes - 1 - plexno) * sizeof(int));
732 vol->plexes--;
733 vol->last_plex_read = 0; /* don't go beyond the end */
734 if (!bcmp(vol->name, plex->name, strlen(vol->name) + 1))
735 /* this plex is named after the volume */
736 {
737 /* First, check if the subdisks are the same */
738 if (msg->recurse) {
739 int sdno;
740
741 for (sdno = 0; sdno < plex->subdisks; sdno++) {
742 struct sd *sd = &SD[plex->sdnos[sdno]];
743
744 if (!bcmp(plex->name, sd->name, strlen(plex->name) + 1))
745 /* subdisk is named after the plex */
746 {
747 bcopy(sd->name,
748 &sd->name[3],
749 min(strlen(sd->name) + 1, MAXSDNAME - 3));
750 bcopy("ex-", sd->name, 3);
751 sd->name[MAXSDNAME - 1] = '\0';
752 }
753 }
754 }
755 bcopy(plex->name,
756 &plex->name[3],
757 min(strlen(plex->name) + 1, MAXPLEXNAME - 3));
758 bcopy("ex-", plex->name, 3);
759 plex->name[MAXPLEXNAME - 1] = '\0';
760 }
761 update_volume_config(volno, 0);
762 save_config();
763 reply->error = 0;
764 } else {
765 reply->error = ENOENT;
766 strcpy(reply->msg, "Plex is not attached");
767 }
768 }
769}
770
771void
772renameobject(struct vinum_rename_msg *msg)
773{
774 struct _ioctl_reply *reply = (struct _ioctl_reply *) msg;
775 struct drive *drive;
776 struct sd *sd;
777 struct plex *plex;
778 struct volume *vol;
779
780 switch (msg->type) {
781 case drive_object: /* you can't attach a drive to anything */
782 if (find_drive(msg->newname, 0) >= 0) { /* we have that name already, */
783 reply->error = EEXIST;
784 reply->msg[0] = '\0';
785 return;
786 }
787 drive = validdrive(msg->index, reply);
788 if (drive) {
789 bcopy(msg->newname, drive->label.name, MAXDRIVENAME);
790 save_config();
791 reply->error = 0;
792 }
793 return;
794
795 case sd_object: /* you can't attach a subdisk to anything */
796 if (find_subdisk(msg->newname, 0) >= 0) { /* we have that name already, */
797 reply->error = EEXIST;
798 reply->msg[0] = '\0';
799 return;
800 }
801 sd = validsd(msg->index, reply);
802 if (sd) {
803 bcopy(msg->newname, sd->name, MAXSDNAME);
804 update_sd_config(sd->sdno, 0);
805 save_config();
806 reply->error = 0;
807 }
808 return;
809
810 case plex_object: /* you can't attach a plex to anything */
811 if (find_plex(msg->newname, 0) >= 0) { /* we have that name already, */
812 reply->error = EEXIST;
813 reply->msg[0] = '\0';
814 return;
815 }
816 plex = validplex(msg->index, reply);
817 if (plex) {
818 bcopy(msg->newname, plex->name, MAXPLEXNAME);
819 update_plex_config(plex->plexno, 0);
820 save_config();
821 reply->error = 0;
822 }
823 return;
824
825 case volume_object: /* you can't attach a volume to anything */
826 if (find_volume(msg->newname, 0) >= 0) { /* we have that name already, */
827 reply->error = EEXIST;
828 reply->msg[0] = '\0';
829 return;
830 }
831 vol = validvol(msg->index, reply);
832 if (vol) {
833 bcopy(msg->newname, vol->name, MAXVOLNAME);
834 update_volume_config(msg->index, 0);
835 save_config();
836 reply->error = 0;
837 }
838 return;
839
840 case invalid_object:
841 reply->error = EINVAL;
842 reply->msg[0] = '\0';
843 }
844}
845
846/*
847 * Replace one object with another.
848 * Currently only for drives.
849 * message->index is the drive number of the old drive
850 * message->otherobject is the drive number of the new drive
851 */
852void
853replaceobject(struct vinum_ioctl_msg *msg)
854{
855 struct _ioctl_reply *reply = (struct _ioctl_reply *) msg;
856
857 reply->error = ENODEV; /* until I know how to do this */
858 strcpy(reply->msg, "replace not implemented yet");
859/* save_config (); */
860}
861
862void
863moveobject(struct vinum_ioctl_msg *msg)
864{
865 struct _ioctl_reply *reply = (struct _ioctl_reply *) msg;
866 struct drive *drive;
867 struct sd *sd;
868
869 /* Check that our objects are valid (i.e. they exist) */
870 drive = validdrive(msg->index, (struct _ioctl_reply *) msg);
871 if (drive == NULL)
872 return;
873 sd = validsd(msg->otherobject, (struct _ioctl_reply *) msg);
874 if (sd == NULL)
875 return;
876 if (sd->driveno == msg->index) /* sd already belongs to drive */
877 return;
878
879 if (sd->state > sd_stale)
880 set_sd_state(sd->sdno, sd_stale, setstate_force); /* make the subdisk stale */
881 else
882 sd->state = sd_empty;
883 if (sd->plexno >= 0) /* part of a plex, */
884 update_plex_state(sd->plexno); /* update its state */
885
886 /* Return the space on the old drive */
887 if ((sd->driveno >= 0) /* we have a drive, */
888 &&(sd->sectors > 0)) /* and some space on it */
889 return_drive_space(sd->driveno, /* return the space */
890 sd->driveoffset,
891 sd->sectors);
892
893 /* Reassign the old subdisk */
894 sd->driveno = msg->index;
895 sd->driveoffset = -1; /* let the drive decide where to put us */
896 give_sd_to_drive(sd->sdno);
897 reply->error = 0;
898}
899
900/* Local Variables: */
901/* fill-column: 50 */
902/* End: */