1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21 /*
22 * Copyright 2008 Sun Microsystems, Inc. All rights reserved.
23 * Use is subject to license terms.
24 */
25
26 #include <sys/types.h>
27 #include <stdio.h>
28 #include <fcntl.h>
29 #include <unistd.h>
30 #include <sys/stat.h>
31 #include <sys/mkdev.h>
32 #include <strings.h>
33 #include <stdarg.h>
34 #include <stdlib.h>
35 #include <locale.h>
36 #include <errno.h>
37
38 #include <sys/nsctl/cfg.h>
39
40 #include <sys/unistat/spcs_s.h>
41 #include <sys/unistat/spcs_s_u.h>
42 #include <sys/unistat/spcs_errors.h>
43 #include <sys/unistat/spcs_s_impl.h>
44
45 #include <sys/nsctl/sv.h>
46 #include <sys/nsctl/nsc_hash.h>
47
48 #define DEV_EXPAND 32
49
50 #define DO_DISABLE 0
51 #define DO_ENABLE 1
52
53 /*
54 * Utility functions for iiadm and rdcadm/sndradm.
55 */
56
57 typedef struct hash_data_s {
58 union {
59 char *users;
60 char *mode;
61 } u;
62 char *path;
63 char *node;
64 int setno;
65 } hash_data_t;
66
67 typedef struct {
68 dev_t rdev;
69 mode_t mode;
70 char *path;
71 } device_t;
72
73 static hash_data_t *make_svol_data(char *, char *, char *, int);
74 static hash_data_t *make_dsvol_data(char *, char *, char *, int);
75 static void delete_svol_data(void *);
76 static void delete_dsvol_data(void *);
77 static int sv_action(char *, CFGFILE *, char *, int);
78
79 static int add_dev_entry(const char *);
80 static int compare(const void *, const void *);
81 static char *find_devid(const char *);
82 static void free_dev_entries();
83 static void rebuild_devhash();
84
85 static hash_node_t **dsvol;
86 static int dsvol_loaded = 0;
87
88 static hash_node_t **svol;
89 static int svol_loaded = 0;
90
91 static hash_node_t **shadowvol;
92
93 static hash_node_t **devhash;
94 static device_t *devlist;
95 static int devcount = 0;
96 static int devalloc = 0;
97
98 /*
99 * cfg_add_user
100 *
101 * Description:
102 * Adds the calling tool as a user of the volume.
103 *
104 * Inputs:
105 * char *path: The pathname of the volume to be enabled.
106 * char *cnode: The device group name, or NULL if -C local or not cluster
107 * CFGFILE *cfg: A pointer to the current config file, or NULL if this
108 * function is to open/write/commit/close the change itself.
109 *
110 * Return values:
111 * CFG_USER_FIRST: Indicates that this is the first user of this
112 * particular volume.
113 * CFG_USER_OK: Indicates that the volume has already been entered into
114 * the config file.
115 * CFG_USER_ERR: Indicates that some failure has occurred and no changes
116 * to the config file have been made.
117 * CFG_USER_REPEAT: Indicates that this user has already registered for
118 * the volume.
119 */
120 int
121 cfg_add_user(CFGFILE* cfg, char *path, char *cnode, char *user)
122 {
123 int self_open, self_loaded, change_made;
124 char *ctag, search_key[ CFG_MAX_KEY ], buf[ CFG_MAX_BUF ];
125 int retval, rc;
126 hash_data_t *data;
127
128 self_open = (cfg == NULL);
129 self_loaded = 0;
130 change_made = 0;
131
132 if (self_open) {
133 cfg = cfg_open(NULL);
134 if (cfg == NULL) {
135 return (CFG_USER_ERR);
136 }
137
138 if (!cfg_lock(cfg, CFG_WRLOCK)) {
139 /* oops */
140 cfg_close(cfg);
141 return (CFG_USER_ERR);
142 }
143 }
144
145 /* Check cnode */
146 ctag = cfg_get_resource(cfg);
147 if (cnode) {
148 if (ctag) {
149 if (strcmp(cnode, ctag))
150 return (CFG_USER_ERR);
151 } else
152 cfg_resource(cfg, cnode);
153 } else
154 cnode = ctag;
155
156 if (!dsvol_loaded) {
157 if (cfg_load_dsvols(cfg) < 0) {
158 if (self_open) {
159 cfg_close(cfg);
160 }
161 return (CFG_USER_ERR);
162 }
163 self_loaded = 1;
164 }
165
166 /* find the volume */
167 (void) snprintf(search_key, CFG_MAX_KEY, "%s:%s", path, cnode);
168 data = nsc_lookup(dsvol, search_key);
169
170 if (!data) {
171 /* whoops, not found. Add as new user */
172 cfg_rewind(cfg, CFG_SEC_CONF);
173 (void) snprintf(buf, CFG_MAX_BUF, "%s %s %s", path, cnode,
174 user);
175 rc = cfg_put_cstring(cfg, "dsvol", buf, strlen(buf));
176 if (rc < 0) {
177 if (self_loaded) {
178 cfg_unload_dsvols();
179 }
180 if (self_open) {
181 cfg_close(cfg);
182 }
183 return (CFG_USER_ERR);
184 }
185 /* reload hash, if we need to */
186 if (!self_loaded) {
187 cfg_unload_dsvols();
188 if (cfg_load_dsvols(cfg) < 0) {
189 if (self_open) {
190 cfg_close(cfg);
191 }
192 return (CFG_USER_ERR);
193 }
194 }
195 retval = CFG_USER_FIRST;
196 change_made = 1;
197 } else {
198 /* Check to ensure we're not already listed */
199 char *p = strdup(data->u.users);
200 char *q = strtok(p, ",");
201 while (q && (strcmp(q, user) != 0)) {
202 q = strtok(0, ",");
203 }
204 free(p); /* not using data; only testing 'q' ptr */
205
206 if (!q) {
207 /* not listed as a user */
208 cfg_rewind(cfg, CFG_SEC_CONF);
209 (void) snprintf(buf, CFG_MAX_BUF, "%s %s %s,%s",
210 data->path, data->node, data->u.users, user);
211 (void) snprintf(search_key, CFG_MAX_KEY, "dsvol.set%d",
212 data->setno);
213 if (cfg_put_cstring(cfg, search_key, buf,
214 strlen(buf)) < 0) {
215 if (self_loaded) {
216 cfg_unload_dsvols();
217 }
218 if (self_open) {
219 cfg_close(cfg);
220 }
221 return (CFG_USER_ERR);
222 }
223
224 /*
225 * Since we deleted an entry from the config
226 * file, we don't know what all the new
227 * set numbers are. We need to reload
228 * everything
229 */
230 if (!self_loaded) {
231 cfg_unload_dsvols();
232 if (cfg_load_dsvols(cfg) < 0) {
233 if (self_open) {
234 cfg_close(cfg);
235 }
236 return (CFG_USER_ERR);
237 }
238 }
239 change_made = 1;
240 retval = CFG_USER_OK;
241 } else {
242 retval = CFG_USER_REPEAT;
243 }
244 }
245
246 if (self_loaded) {
247 cfg_unload_dsvols();
248 }
249
250 if (self_open) {
251 if (change_made)
252 (void) cfg_commit(cfg);
253 cfg_close(cfg);
254 }
255
256 return (retval);
257 }
258
259 /*
260 * cfg_rem_user
261 *
262 * Description:
263 * Removes a user from the config file.
264 *
265 * Inputs:
266 * char *path: The pathname of the volume to be enabled.
267 * char *cnode: The device group name, or NULL if -C local or not cluster
268 * char *user: The subsystem that is adding this tag (sv, ii, sndr)
269 * CFGFILE *cfg: A pointer to the current config file, or NULL if this
270 * function is to open/write/commit/close the change itself.
271 * Return values:
272 * CFG_USER_ERR: An error occurred during the processing of this
273 * directive.
274 * CFG_USER_OK: User successfully removed; volume in use by other(s).
275 * CFG_USER_LAST: User successfuly removed; no other users registered
276 * CFG_USER_GONE: The volume is no longer listed in the dsvol section,
277 * indicating some sort of application-level error.
278 *
279 */
280 int
281 cfg_rem_user(CFGFILE *cfg, char *path, char *cnode, char *user)
282 {
283 int self_open, self_loaded, change_made;
284 char *ctag, search_key[ CFG_MAX_KEY ], buf[ CFG_MAX_BUF ];
285 char cfg_key[ CFG_MAX_KEY ];
286 hash_data_t *data;
287 int retval;
288 int force_remove;
289
290 self_open = (cfg == NULL);
291 self_loaded = 0;
292 change_made = 0;
293 force_remove = (strcmp(user, "sv") == 0);
294
295 if ('-' == *user) {
296 ++user;
297 }
298
299 /* Check cnode */
300 ctag = cfg_get_resource(cfg);
301 if (cnode) {
302 if (ctag) {
303 if (strcmp(cnode, ctag))
304 return (CFG_USER_ERR);
305 } else
306 cfg_resource(cfg, cnode);
307 } else
308 cnode = ctag;
309
310 if (self_open) {
311 cfg = cfg_open(NULL);
312 if (cfg == NULL) {
313 return (CFG_USER_ERR);
314 }
315
316 if (!cfg_lock(cfg, CFG_WRLOCK)) {
317 /* oops */
318 cfg_close(cfg);
319 return (CFG_USER_ERR);
320 }
321 }
322
323
324 change_made = 0;
325 if (!dsvol_loaded) {
326 if (cfg_load_dsvols(cfg) < 0) {
327 if (self_open) {
328 cfg_close(cfg);
329 }
330 return (CFG_USER_ERR);
331 }
332 self_loaded = 1;
333 }
334
335 /* find the volume */
336 (void) snprintf(search_key, CFG_MAX_KEY, "%s:%s", path, cnode);
337 data = nsc_lookup(dsvol, search_key);
338
339 if (!data) {
340 /* yipes */
341 retval = CFG_USER_GONE;
342 } else if (force_remove) {
343 retval = CFG_USER_LAST;
344 cfg_rewind(cfg, CFG_SEC_CONF);
345 (void) snprintf(cfg_key, CFG_MAX_KEY, "dsvol.set%d",
346 data->setno);
347 if (cfg_put_cstring(cfg, cfg_key, NULL, 0) < 0) {
348 if (self_loaded) {
349 cfg_unload_dsvols();
350 }
351 if (self_open) {
352 cfg_close(cfg);
353 }
354 return (CFG_USER_ERR);
355 }
356 if (!self_loaded) {
357 cfg_unload_dsvols();
358 if (cfg_load_dsvols(cfg) < 0) {
359 if (self_open) {
360 cfg_close(cfg);
361 }
362 return (CFG_USER_ERR);
363 }
364 }
365 } else {
366 char *p = strdup(data->u.users);
367 char *q = strtok(p, ",");
368 int appended = 0;
369
370 (void) snprintf(buf, CFG_MAX_BUF, "%s %s ", data->path,
371 data->node);
372 while (q && (strcmp(q, user) != 0)) {
373 if (appended) {
374 strcat(buf, ",");
375 strcat(buf, q);
376 } else {
377 strcat(buf, q);
378 appended = 1;
379 }
380 q = strtok(0, ",");
381 }
382
383 if (!q) {
384 /* uh-oh */
385 retval = CFG_USER_GONE;
386 } else {
387 /* old user skipped; add in remaining users */
388 while (q = strtok(0, ", ")) {
389 if (appended) {
390 strcat(buf, ",");
391 strcat(buf, q);
392 } else {
393 strcat(buf, q);
394 appended = 1;
395 }
396 }
397
398 if (appended) {
399 retval = CFG_USER_OK;
400 cfg_rewind(cfg, CFG_SEC_CONF);
401 (void) snprintf(cfg_key, CFG_MAX_KEY,
402 "dsvol.set%d", data->setno);
403 if (cfg_put_cstring(cfg, cfg_key, buf,
404 strlen(buf)) < 0) {
405 if (self_loaded) {
406 cfg_unload_dsvols();
407 }
408 if (self_open) {
409 cfg_close(cfg);
410 }
411 return (CFG_USER_ERR);
412 }
413 if (!self_loaded) {
414 cfg_unload_dsvols();
415 if (cfg_load_dsvols(cfg) < 0) {
416 if (self_open) {
417 cfg_close(cfg);
418 }
419 return (CFG_USER_ERR);
420 }
421 }
422 } else {
423 retval = CFG_USER_LAST;
424 cfg_rewind(cfg, CFG_SEC_CONF);
425 (void) snprintf(cfg_key, CFG_MAX_KEY,
426 "dsvol.set%d", data->setno);
427 if (cfg_put_cstring(cfg, cfg_key, NULL,
428 0) < 0) {
429 if (self_loaded) {
430 cfg_unload_dsvols();
431 }
432 if (self_open) {
433 cfg_close(cfg);
434 }
435 return (CFG_USER_ERR);
436 }
437 /*
438 * Since we deleted an entry from the config
439 * file, we don't know what all the new
440 * set numbers are. We need to reload
441 * everything
442 */
443 if (!self_loaded) {
444 cfg_unload_dsvols();
445 if (cfg_load_dsvols(cfg) < 0) {
446 if (self_open) {
447 cfg_close(cfg);
448 }
449 return (CFG_USER_ERR);
450 }
451 }
452 }
453 change_made = 1;
454 }
455 }
456
457 if (self_loaded) {
458 cfg_unload_dsvols();
459 }
460
461 if (self_open) {
462 if (change_made)
463 (void) cfg_commit(cfg);
464 cfg_close(cfg);
465 }
466
467 return (retval);
468 }
469
470 /*
471 * Enable a volume under SV control (or add this char *user to the list
472 * of users of that volume).
473 *
474 * Parameters:
475 * cfg - The config file to use.
476 * path - The pathname of the volume
477 * ctag - The cluster tag for this volume (if any)
478 * user - The user (sv, ii, sndr) of the volume.
479 */
480 int
481 cfg_vol_enable(CFGFILE *cfg, char *path, char *ctag, char *user)
482 {
483 int rc;
484 int retval;
485
486 if (!ctag || *ctag == '\0') {
487 ctag = "-";
488 }
489
490 retval = -1;
491 rc = cfg_add_user(cfg, path, ctag, user);
492 switch (rc) {
493 case CFG_USER_ERR:
494 spcs_log("dsvol", NULL,
495 gettext("unable to set up dsvol section of config for %s"),
496 path);
497 break;
498 case CFG_USER_OK:
499 retval = 0;
500 break;
501 case CFG_USER_FIRST:
502 /* enable sv! */
503 retval = sv_action(path, cfg, ctag, DO_ENABLE);
504 if (retval < 0) {
505 (void) cfg_rem_user(cfg, path, ctag, user);
506 }
507 break;
508 default:
509 spcs_log("dsvol", NULL,
510 gettext("unexpected return from cfg_add_user(%d)"), rc);
511 break;
512 }
513
514 return (retval);
515 }
516
517 /*
518 * Disable a volume from SV control (or remove this char *user from the list
519 * of users of that volume).
520 *
521 * Parameters:
522 * cfg - The config file to use.
523 * path - The pathname of the volume
524 * ctag - The cluster tag for this volume (if any)
525 * user - The user (sv, ii, sndr) of the volume.
526 */
527 int
528 cfg_vol_disable(CFGFILE *cfg, char *path, char *ctag, char *user)
529 {
530 int rc;
531 int retval;
532
533 if (!ctag || *ctag == '\0') {
534 ctag = "-";
535 }
536
537 retval = -1;
538 rc = cfg_rem_user(cfg, path, ctag, user);
539 switch (rc) {
540 case CFG_USER_ERR:
541 spcs_log("dsvol", NULL,
542 gettext("unable to set up dsvol section of config for %s"),
543 path);
544 break;
545 case CFG_USER_OK:
546 retval = 0;
547 break;
548 case CFG_USER_GONE:
549 spcs_log("dsvol", NULL,
550 gettext("%s tried to remove non-existent tag for %s"),
551 user, path);
552 break;
553 case CFG_USER_LAST:
554 /* diable sv! */
555 retval = sv_action(path, cfg, ctag, DO_DISABLE);
556 break;
557 default:
558 spcs_log("dsvol", NULL,
559 gettext("unexpected return from cfg_rem_user(%d)"), rc);
560 break;
561 }
562
563 return (retval);
564 }
565
566 /*
567 * cfg_load_dsvols
568 *
569 * Description:
570 * Loads the dsvol section of the config file into a giant hash, to
571 * make searching faster. The important bit to remember is to not
572 * release the write lock between calling cfg_load_dsvols() and the
573 * cfg_*_user() functions.
574 *
575 * Assumptions:
576 * 1/ cfg file is open
577 * 2/ cfg file has been write-locked
578 * 3/ user of this routine may already be using hcreate/hsearch
579 *
580 * Return value:
581 * -1 if error, or total number of sets found
582 */
583 int
584 cfg_load_dsvols(CFGFILE *cfg)
585 {
586 int set, rc, entries;
587 char search_key[ CFG_MAX_KEY ];
588 char *buf;
589 char **entry, *path, *cnode, *users;
590 hash_data_t *data;
591 int devs_added = 0;
592 int offset = 0;
593 char *ctag = cfg_get_resource(cfg);
594 if (!ctag || *ctag == '\0') {
595 ctag = "-";
596 }
597
598 dsvol = nsc_create_hash();
599 if (!dsvol) {
600 return (-1);
601 }
602
603 rc = 0;
604 cfg_rewind(cfg, CFG_SEC_CONF);
605 entries = cfg_get_section(cfg, &entry, "dsvol");
606 for (set = 1; set <= entries; set++) {
607 buf = entry[set - 1];
608
609 /* split up the line */
610 if (!(path = strtok(buf, " "))) {
611 /* oops, now what? */
612 free(buf);
613 break;
614 }
615 if (!(cnode = strtok(0, " "))) {
616 free(buf);
617 break;
618 }
619 if (ctag && (strcmp(cnode, ctag) != 0)) {
620 ++offset;
621 free(buf);
622 continue;
623 }
624
625 if (!(users = strtok(0, " "))) {
626 free(buf);
627 break;
628 }
629
630 data = make_dsvol_data(path, cnode, users, set - offset);
631 if (!data) {
632 free(buf);
633 break;
634 }
635 (void) snprintf(search_key, CFG_MAX_KEY, "%s:%s", path, cnode);
636 rc = nsc_insert_node(dsvol, data, search_key);
637 if (rc < 0) {
638 free(buf);
639 break;
640 }
641
642 /* we also need to keep track of node information */
643 rc = add_dev_entry(path);
644 if (rc < 0) {
645 free(buf);
646 break;
647 } else if (rc)
648 ++devs_added;
649
650 free(buf);
651 rc = 0;
652 }
653
654 while (set < entries)
655 free(entry[set++]);
656 if (entries)
657 free(entry);
658
659 if (devs_added) {
660 qsort(devlist, devcount, sizeof (device_t), compare);
661 rebuild_devhash();
662 }
663
664 dsvol_loaded = 1;
665 return (rc < 0? rc : entries);
666 }
667
668 /*
669 * cfg_unload_dsvols
670 *
671 * Description:
672 * Free all memory allocated with cfg_load_dsvols.
673 */
674 void
675 cfg_unload_dsvols()
676 {
677 if (dsvol) {
678 nsc_remove_all(dsvol, delete_dsvol_data);
679 dsvol = 0;
680 dsvol_loaded = 0;
681 }
682 }
683
684 /*
685 * cfg_load_svols
686 *
687 * Description:
688 * Loads the sv section of the config file into a giant hash, to make
689 * searching faster. The important bit to remember is to not release
690 * the write lock between calling cfg_load_svols() and the cfg_*_user()
691 * functions.
692 *
693 * Assumptions:
694 * 1/ cfg file is open
695 * 2/ cfg file has been write-locked
696 * 3/ user of this routine may already be using builtin hcreate/hsearch
697 */
698 int
699 cfg_load_svols(CFGFILE *cfg)
700 {
701 int set, entries, offset = 0;
702 char *buf, **entry;
703 char *path, *mode, *cnode;
704 hash_data_t *data;
705 char *ctag = cfg_get_resource(cfg);
706 if (!ctag || *ctag == '\0') {
707 ctag = "-";
708 }
709
710 svol = nsc_create_hash();
711 if (!svol) {
712 return (-1);
713 }
714
715 cfg_rewind(cfg, CFG_SEC_CONF);
716 entries = cfg_get_section(cfg, &entry, "sv");
717 for (set = 1; set <= entries; set++) {
718 buf = entry[set - 1];
719
720 /* split up the line */
721 if (!(path = strtok(buf, " "))) {
722 free(buf);
723 break;
724 }
725 if (!(mode = strtok(0, " "))) {
726 free(buf);
727 break;
728 }
729 if (!(cnode = strtok(0, " "))) {
730 cnode = "";
731 }
732
733 if (ctag && (strcmp(cnode, ctag) != 0)) {
734 ++offset;
735 free(buf);
736 continue;
737 }
738
739 data = make_svol_data(path, mode, cnode, set - offset);
740 if (!data) {
741 free(buf);
742 break;
743 }
744 if (nsc_insert_node(svol, data, path) < 0) {
745 free(buf);
746 break;
747 }
748 free(buf);
749 }
750 while (set < entries)
751 free(entry[set++]);
752 if (entries)
753 free(entry);
754
755 svol_loaded = 1;
756 return (0);
757 }
758
759 /*
760 * cfg_unload_svols
761 *
762 * Description:
763 * Frees all memory allocated with cfg_load_dsvols
764 */
765 void
766 cfg_unload_svols()
767 {
768 if (svol) {
769 nsc_remove_all(svol, delete_svol_data);
770 svol = 0;
771 svol_loaded = 0;
772 }
773 }
774
775 /*
776 * cfg_get_canonical_name
777 *
778 * Description:
779 * Find out whether a device is already known by another name in
780 * the config file.
781 *
782 * Parameters:
783 * cfg - The config file to use
784 * path - The pathname of the device
785 * result - (output) The name it is otherwise known as. This parameter
786 * must be freed by the caller.
787 *
788 * Return values:
789 * -1: error
790 * 0: name is as expected, or is not known
791 * 1: Name is known by different name (stored in 'result')
792 */
793 int
794 cfg_get_canonical_name(CFGFILE *cfg, const char *path, char **result)
795 {
796 int self_loaded;
797 char *alt_path;
798 int retval;
799
800 if (devlist) {
801 self_loaded = 0;
802 } else {
803 if (cfg_load_shadows(cfg) < 0) {
804 return (-1);
805 }
806 self_loaded = 1;
807 }
808
809 /* see if it exists under a different name */
810 alt_path = find_devid(path);
811 if (!alt_path || strcmp(path, alt_path) == 0) {
812 *result = NULL;
813 retval = 0;
814 } else {
815 /* a-ha */
816 *result = strdup(alt_path);
817 retval = 1;
818 }
819
820 if (self_loaded) {
821 free_dev_entries();
822 }
823
824 return (retval);
825 }
826
827 /*
828 * cfg_load_shadows
829 *
830 * Description:
831 * Load in shadow and bitmap volumes from the II section of the
832 * config file. SNDR's volumes are handled already by cfg_load_dsvols.
833 * Not all shadow volumes are listed under dsvol: they can be exported.
834 *
835 * Parameters:
836 * cfg - The config file to use
837 *
838 * Return values:
839 * -1: error
840 * 0: success
841 */
842 int
843 cfg_load_shadows(CFGFILE *cfg)
844 {
845 int set, self_loaded, rc, entries;
846 char *buf, **entry, *ptr;
847 int devs_added = 0;
848
849 if (dsvol_loaded) {
850 self_loaded = 0;
851 } else {
852 if (cfg_load_dsvols(cfg) < 0) {
853 return (-1);
854 }
855 self_loaded = 1;
856 }
857
858 shadowvol = nsc_create_hash();
859 if (!shadowvol) {
860 return (-1);
861 }
862
863 rc = 0;
864 cfg_rewind(cfg, CFG_SEC_CONF);
865 entries = cfg_get_section(cfg, &entry, "ii");
866 for (set = 1; set <= entries; set++) {
867 buf = entry[set - 1];
868
869 /* skip the master vol */
870 ptr = strtok(buf, " ");
871
872 /* shadow is next */
873 ptr = strtok(NULL, " ");
874
875 rc = add_dev_entry(ptr);
876 if (rc < 0) {
877 free(buf);
878 break;
879 } else if (rc)
880 ++devs_added;
881
882 /* and next is bitmap */
883 ptr = strtok(NULL, " ");
884
885 rc = add_dev_entry(ptr);
886 if (rc < 0) {
887 free(buf);
888 break;
889 } else if (rc)
890 ++devs_added;
891 rc = 0;
892 free(buf);
893 }
894 while (set < entries)
895 free(entry[set++]);
896 if (entries)
897 free(entry);
898
899 if (self_loaded) {
900 cfg_unload_dsvols();
901 }
902
903 if (devs_added) {
904 /* sort it, in preparation for lookups */
905 qsort(devlist, devcount, sizeof (device_t), compare);
906 rebuild_devhash();
907 }
908
909 return (rc);
910 }
911
912 void
913 cfg_unload_shadows()
914 {
915 /* do nothing */
916 }
917
918 /* ---------------------------------------------------------------------- */
919
920 static hash_data_t *
921 make_dsvol_data(char *path, char *cnode, char *users, int set)
922 {
923 hash_data_t *data;
924
925 data = (hash_data_t *)malloc(sizeof (hash_data_t));
926 if (!data) {
927 return (0);
928 }
929
930 data->u.users = strdup(users);
931 data->path = strdup(path);
932 data->node = strdup(cnode);
933 data->setno = set;
934
935 return (data);
936 }
937
938 static void
939 delete_dsvol_data(void *data)
940 {
941 hash_data_t *p = (hash_data_t *)data;
942
943 free(p->u.users);
944 free(p->path);
945 free(p->node);
946 free(p);
947 }
948
949 static hash_data_t *
950 make_svol_data(char *path, char *mode, char *cnode, int set)
951 {
952 hash_data_t *data;
953
954 data = (hash_data_t *)malloc(sizeof (hash_data_t));
955 if (!data) {
956 return (0);
957 }
958
959 data->u.mode = strdup(mode);
960 data->path = strdup(path);
961 data->node = strdup(cnode);
962 data->setno = set;
963
964 return (data);
965 }
966
967
968 static void
969 delete_svol_data(void *data)
970 {
971 hash_data_t *p = (hash_data_t *)data;
972
973 free(p->u.mode);
974 free(p->path);
975 free(p->node);
976 free(p);
977 }
978
979 static int
980 sv_action(char *path, CFGFILE *caller_cfg, char *ctag, int enable)
981 {
982 struct stat stb;
983 sv_conf_t svc;
984 int fd = -1;
985 int cfg_changed = 0;
986 CFGFILE *cfg;
987 int print_log = 0;
988 int err = 0, rc;
989 int sv_ioctl, spcs_err, self_loaded;
990 char *log_str1, *log_str2;
991 char key[ CFG_MAX_KEY ];
992 char buf[ CFG_MAX_BUF ];
993 hash_data_t *node;
994 device_t *statinfo = 0;
995
996 if (caller_cfg == NULL) {
997 cfg = cfg_open(NULL);
998 if (cfg == NULL)
999 return (-1);
1000
1001 if (ctag)
1002 cfg_resource(cfg, ctag);
1003 } else
1004 cfg = caller_cfg;
1005
1006
1007 self_loaded = 0;
1008 sv_ioctl = (enable? SVIOC_ENABLE : SVIOC_DISABLE);
1009 log_str1 = (enable? gettext("enabled %s") : gettext("disabled %s"));
1010 log_str2 = (enable? gettext("unable to enable %s") :
1011 gettext("unable to disable %s"));
1012 spcs_err = (enable? SV_EENABLED : SV_EDISABLED);
1013 bzero(&svc, sizeof (svc));
1014
1015 if (devhash)
1016 statinfo = nsc_lookup(devhash, path);
1017
1018 if (statinfo) {
1019 if (!S_ISCHR(statinfo->mode))
1020 goto error;
1021 svc.svc_major = major(statinfo->rdev);
1022 svc.svc_minor = minor(statinfo->rdev);
1023 } else {
1024 if (stat(path, &stb) != 0)
1025 goto error;
1026
1027 if (!S_ISCHR(stb.st_mode))
1028 goto error;
1029 svc.svc_major = major(stb.st_rdev);
1030 svc.svc_minor = minor(stb.st_rdev);
1031 }
1032
1033 strncpy(svc.svc_path, path, sizeof (svc.svc_path));
1034
1035 fd = open(SV_DEVICE, O_RDONLY);
1036 if (fd < 0)
1037 goto error;
1038
1039 svc.svc_flag = (NSC_DEVICE | NSC_CACHE);
1040 svc.svc_error = spcs_s_ucreate();
1041
1042 do {
1043 rc = ioctl(fd, sv_ioctl, &svc);
1044 } while (rc < 0 && errno == EINTR);
1045
1046 if (rc < 0) {
1047 if (errno != spcs_err) {
1048 spcs_log("sv", &svc.svc_error, log_str2, svc.svc_path);
1049 if (enable)
1050 goto error;
1051 else
1052 err = errno;
1053 } else
1054 err = spcs_err;
1055 }
1056
1057 spcs_log("sv", NULL, log_str1, svc.svc_path);
1058
1059 /* SV enable succeeded */
1060 if (caller_cfg == NULL) /* was not previously locked */
1061 if (!cfg_lock(cfg, CFG_WRLOCK))
1062 goto error;
1063
1064 if (err != spcs_err) { /* already enabled, already in config */
1065 if (enable) {
1066 cfg_rewind(cfg, CFG_SEC_CONF);
1067 (void) snprintf(buf, CFG_MAX_BUF, "%s - %s", path,
1068 ctag? ctag : "-");
1069 if (cfg_put_cstring(cfg, "sv", buf, CFG_MAX_BUF) < 0) {
1070 /* SV config not updated, so SV disable again */
1071 (void) ioctl(fd, SVIOC_DISABLE, &svc);
1072 print_log++;
1073 } else
1074 cfg_changed = 1;
1075 } else {
1076 /* pull it out of the config */
1077 if (!svol_loaded) {
1078 if (cfg_load_svols(cfg) < 0) {
1079 if (NULL == caller_cfg) {
1080 cfg_close(cfg);
1081 }
1082 return (-1);
1083 }
1084 self_loaded = 1;
1085 }
1086 node = nsc_lookup(svol, svc.svc_path);
1087 if (node) {
1088 cfg_rewind(cfg, CFG_SEC_CONF);
1089 (void) snprintf(key, CFG_MAX_KEY, "sv.set%d",
1090 node->setno);
1091 if (cfg_put_cstring(cfg, key, NULL, NULL) < 0) {
1092 spcs_log("sv", NULL,
1093 gettext("failed to remove %s from "
1094 "sv config"), svc.svc_path);
1095 }
1096 /*
1097 * Since we deleted an entry from the config
1098 * file, we don't know what all the new
1099 * set numbers are. We need to reload
1100 * everything
1101 */
1102 if (!self_loaded) {
1103 cfg_unload_svols();
1104 if (cfg_load_svols(cfg) < 0) {
1105 if (NULL == caller_cfg) {
1106 cfg_close(cfg);
1107 }
1108 return (-1);
1109 }
1110 }
1111 cfg_changed = 1;
1112 }
1113 if (self_loaded) {
1114 cfg_unload_svols();
1115 self_loaded = 0;
1116 }
1117 }
1118 }
1119
1120 #ifdef lint
1121 (void) printf("extra line to shut lint up %s\n", module_names[0]);
1122 #endif
1123
1124 error:
1125 if (fd >= 0)
1126 (void) close(fd);
1127
1128 if (cfg == NULL)
1129 return (-1);
1130
1131 if (cfg_changed)
1132 if (caller_cfg == NULL) /* we opened config */
1133 (void) cfg_commit(cfg);
1134
1135 if (caller_cfg == NULL)
1136 cfg_close(cfg);
1137 if ((cfg_changed) || (err == spcs_err))
1138 return (1);
1139 if (print_log)
1140 spcs_log("sv", NULL,
1141 gettext("unable to add to configuration, disabled %s"),
1142 svc.svc_path);
1143 spcs_s_ufree(&svc.svc_error);
1144
1145 return (-1);
1146 }
1147
1148 /*
1149 * add_dev_entry
1150 *
1151 * Add an entry into the devlist and the devhash for future lookups.
1152 *
1153 * Return values:
1154 * -1 An error occurred.
1155 * 0 Entry added
1156 * 1 Entry already exists.
1157 */
1158 static int
1159 add_dev_entry(const char *path)
1160 {
1161 struct stat buf;
1162 device_t *newmem;
1163 hash_data_t *data;
1164
1165 if (!devhash) {
1166 devhash = nsc_create_hash();
1167 if (!devhash) {
1168 return (-1);
1169 }
1170 } else {
1171 data = nsc_lookup(devhash, path);
1172 if (data) {
1173 return (1);
1174 }
1175 }
1176
1177 if (stat(path, &buf) < 0) {
1178 /* ignore error, we are most likely deleting entry anyway */
1179 buf.st_rdev = 0;
1180 }
1181
1182 if (devcount >= devalloc) {
1183 /* make some room */
1184 devalloc += DEV_EXPAND;
1185 newmem = (device_t *)realloc(devlist, devalloc *
1186 sizeof (device_t));
1187 if (!newmem) {
1188 free_dev_entries();
1189 return (-1);
1190 } else {
1191 devlist = newmem;
1192 }
1193 }
1194
1195 devlist[ devcount ].path = strdup(path);
1196 devlist[ devcount ].rdev = buf.st_rdev;
1197 devlist[ devcount ].mode = buf.st_mode;
1198
1199 if (nsc_insert_node(devhash, &devlist[devcount], path) < 0) {
1200 return (-1);
1201 }
1202
1203 ++devcount;
1204 return (0);
1205 }
1206
1207 static void
1208 rebuild_devhash()
1209 {
1210 int i;
1211
1212 if (!devhash)
1213 nsc_remove_all(devhash, 0);
1214
1215 devhash = nsc_create_hash();
1216 if (!devhash)
1217 return;
1218
1219 for (i = 0; i < devcount; i++) {
1220 nsc_insert_node(devhash, &devlist[i], devlist[i].path);
1221 }
1222 }
1223
1224 static int
1225 compare(const void *va, const void *vb)
1226 {
1227 device_t *a = (device_t *)va;
1228 device_t *b = (device_t *)vb;
1229
1230 return (b->rdev - a->rdev);
1231 }
1232
1233 static char *
1234 find_devid(const char *path)
1235 {
1236 device_t key;
1237 device_t *result;
1238 struct stat buf;
1239
1240 if (!devlist || !devhash)
1241 return (NULL);
1242
1243 /* See if we already know the device id by this name */
1244 result = (device_t *)nsc_lookup(devhash, path);
1245 if (result) {
1246 return (NULL);
1247 }
1248
1249 /* try to find it by another name */
1250 if (stat(path, &buf) < 0)
1251 return (NULL);
1252
1253 key.rdev = buf.st_rdev;
1254
1255 /* it's storted, so we use the binary-chop method to find it */
1256 result = bsearch(&key, devlist, devcount, sizeof (device_t), compare);
1257
1258 if (result) {
1259 return (result->path);
1260 }
1261
1262 return (NULL);
1263 }
1264
1265 static void
1266 free_dev_entries()
1267 {
1268 int i;
1269 device_t *p;
1270
1271 if (!devlist) {
1272 return;
1273 }
1274 for (i = 0, p = devlist; i < devcount; i++, p++) {
1275 free(p->path);
1276 }
1277 free(devlist);
1278 devlist = NULL;
1279 devcount = 0;
1280 devalloc = 0;
1281
1282 if (devhash) {
1283 nsc_remove_all(devhash, 0);
1284 devhash = NULL;
1285 }
1286 }