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 <sys/stat.h>
28 #include <sys/mkdev.h>
29 #include <sys/param.h>
30 #include <fcntl.h>
31 #include <stdarg.h>
32 #include <stdlib.h>
33 #include <strings.h>
34 #include <errno.h>
35 #include <stdio.h>
36 #include <locale.h>
37 #include <unistd.h>
38 #include <libgen.h>
39 #include <nsctl.h>
40
41 #include <sys/unistat/spcs_s.h>
42 #include <sys/unistat/spcs_s_u.h>
43 #include <sys/unistat/spcs_errors.h>
44
45 #include <sys/nsctl/sv.h>
46 #include <sys/nsctl/sv_impl.h>
47
48 #include <sys/nsctl/cfg.h>
49
50
51 static int sv_max_devices;
52
53
54 /*
55 * Pathnames.
56 */
57
58 static const caddr_t sv_rpath = SV_DEVICE;
59
60 /*
61 * Functions.
62 */
63
64 static void resume_dev(int, sv_name_t *);
65 static void suspend_dev(int, const caddr_t);
66 static int read_libcfg(sv_name_t svn[]);
67 static void resume_sv();
68 static void suspend_sv();
69 static void prepare_unload_sv();
70
71
72 /*
73 * support for the special cluster tag "local" to be used with -C in a
74 * cluster for local volumes.
75 */
76
77 #define SV_LOCAL_TAG "local"
78
79 static caddr_t program;
80 static caddr_t cfg_cluster_tag;
81
82
83 static void
84 usage(void)
85 {
86 (void) fprintf(stderr, gettext("usage:\n"));
87
88 (void) fprintf(stderr, gettext(
89 "\t%s -h help\n"), program);
90
91 (void) fprintf(stderr, gettext(
92 "\t%s [-C tag] -r resume all sv devices\n"), program);
93
94 (void) fprintf(stderr, gettext(
95 "\t%s [-C tag] -s suspend all sv devices\n"), program);
96
97 (void) fprintf(stderr, gettext(
98 "\t%s -u prepare for sv unload\n"), program);
99 }
100
101
102 static void
103 message(caddr_t prefix, spcs_s_info_t *status, caddr_t string, va_list ap)
104 {
105 (void) fprintf(stderr, "%s: %s: ", program, prefix);
106 (void) vfprintf(stderr, string, ap);
107 (void) fprintf(stderr, "\n");
108
109 if (status) {
110 spcs_s_report(*status, stderr);
111 spcs_s_ufree(status);
112 }
113 }
114
115
116 static void
117 error(spcs_s_info_t *status, caddr_t string, ...)
118 {
119 va_list ap;
120 va_start(ap, string);
121
122 message(gettext("error"), status, string, ap);
123
124 va_end(ap);
125 exit(1);
126 }
127
128
129 static void
130 warn(spcs_s_info_t *status, caddr_t string, ...)
131 {
132 va_list ap;
133 va_start(ap, string);
134
135 message(gettext("warning"), status, string, ap);
136
137 va_end(ap);
138 }
139
140
141 static void
142 sv_get_maxdevs(void)
143 {
144 sv_name_t svn[1];
145 sv_list_t svl;
146 int fd;
147
148 if (sv_max_devices > 0)
149 return;
150
151 fd = open(sv_rpath, O_RDONLY);
152 if (fd < 0)
153 error(NULL, gettext("unable to open %s: %s"),
154 sv_rpath, strerror(errno));
155
156 bzero(&svl, sizeof (svl));
157 bzero(&svn[0], sizeof (svn));
158
159 svl.svl_names = &svn[0];
160 svl.svl_error = spcs_s_ucreate();
161
162 if (ioctl(fd, SVIOC_LIST, &svl) < 0)
163 error(&svl.svl_error, gettext("unable to get max devs"));
164
165 spcs_s_ufree(&svl.svl_error);
166 sv_max_devices = svl.svl_maxdevs;
167
168 (void) close(fd);
169 }
170
171
172 static sv_name_t *
173 sv_alloc_svnames(void)
174 {
175 sv_name_t *svn = NULL;
176
177 sv_get_maxdevs();
178
179 svn = calloc(sv_max_devices, sizeof (*svn));
180 if (svn == NULL) {
181 error(NULL, "unable to allocate %ld bytes of memory",
182 sv_max_devices * sizeof (*svn));
183 }
184
185 return (svn);
186 }
187
188 int
189 main(int argc, char *argv[])
190 {
191 extern int optind;
192 extern char *optarg;
193 int Cflag, resume, suspend, unload;
194 int opt;
195
196 (void) setlocale(LC_ALL, "");
197 (void) textdomain("svboot");
198
199 program = strdup(basename(argv[0]));
200
201 Cflag = unload = resume = suspend = 0;
202
203 while ((opt = getopt(argc, argv, "C:hrsu")) != EOF) {
204 switch (opt) {
205
206 case 'C':
207 if (Cflag) {
208 warn(NULL,
209 gettext("-C specified multiple times"));
210 usage();
211 exit(2);
212 /* NOTREACHED */
213 }
214
215 Cflag++;
216 cfg_cluster_tag = optarg;
217 break;
218
219 case 'r':
220 resume++;
221 break;
222
223 case 's':
224 suspend++;
225 break;
226
227 case 'u':
228 unload++;
229 break;
230
231 case 'h':
232 usage();
233 exit(0);
234
235 case '?': /* FALLTHRU */
236
237 default:
238 usage();
239 exit(2);
240 /* NOTREACHED */
241 }
242 }
243
244
245 /*
246 * Usage checks
247 */
248
249 if ((resume + suspend + unload) > 1) {
250 warn(NULL, gettext("-r , -s and -u are mutually exclusive"));
251 usage();
252 exit(2);
253 }
254
255 if (!resume && !suspend && !unload) {
256 warn(NULL, gettext("option required"));
257 usage();
258 exit(2);
259 }
260
261 if (optind != argc) {
262 usage();
263 exit(2);
264 }
265
266
267 /*
268 * Check for the special (local) cluster tag
269 */
270
271 if (cfg_cluster_tag != NULL &&
272 strcmp(cfg_cluster_tag, SV_LOCAL_TAG) == 0)
273 cfg_cluster_tag = "-";
274
275 /*
276 * Process commands
277 */
278
279 if (resume)
280 resume_sv();
281 else if (suspend)
282 suspend_sv();
283 else if (unload)
284 prepare_unload_sv();
285
286 return (0);
287 }
288
289
290 static void
291 resume_sv()
292 {
293 int index;
294 sv_name_t *svn;
295 int cnt;
296 int fd;
297
298 svn = sv_alloc_svnames();
299
300 index = read_libcfg(svn);
301
302 fd = open(sv_rpath, O_RDONLY);
303 if (fd < 0) {
304 warn(NULL, gettext("unable to open %s: %s"),
305 svn->svn_path, strerror(errno));
306 return;
307 }
308
309 for (cnt = 0; cnt < index; cnt++) {
310
311 /*
312 * Check for more data.
313 */
314 if (svn[cnt].svn_path[0] == '\0') {
315 /*
316 * This was set when reading sv.conf. After the last
317 * line svn_path was set to \0, so we are finished.
318 * We shouldn't get here, but put this in just in
319 * case.
320 */
321 break;
322 }
323 resume_dev(fd, &svn[cnt]);
324 }
325 (void) close(fd);
326 }
327
328
329 static void
330 resume_dev(int fd, sv_name_t *svn)
331 {
332 struct stat stb;
333 sv_conf_t svc;
334
335 bzero(&svc, sizeof (svc));
336
337 if (stat(svn->svn_path, &stb) != 0) {
338 warn(NULL, gettext("unable to access %s: %s"),
339 svn->svn_path, strerror(errno));
340 return;
341 }
342
343 svc.svc_major = major(stb.st_rdev);
344 svc.svc_minor = minor(stb.st_rdev);
345 (void) strncpy(svc.svc_path, svn->svn_path, sizeof (svc.svc_path));
346
347 svc.svc_flag = svn->svn_mode;
348 svc.svc_error = spcs_s_ucreate();
349
350 if (ioctl(fd, SVIOC_ENABLE, &svc) < 0) {
351 spcs_log("sv", &svc.svc_error,
352 gettext("%s: unable to resume %s"),
353 program, svn->svn_path);
354
355 warn(&svc.svc_error, gettext("unable to resume %s"),
356 svn->svn_path);
357 return;
358 }
359
360 spcs_log("sv", NULL, gettext("%s: resume %s"),
361 program, svn->svn_path);
362
363 spcs_s_ufree(&svc.svc_error);
364 }
365
366
367 /*
368 * This routine parses the config file and
369 * stores the data in the svn array. The return value is the number
370 * of entries read from conf_file. If an error occurs the error()
371 * routine is called (which exits the program).
372 */
373 static int
374 read_libcfg(sv_name_t svn[])
375 {
376 char rdev[CFG_MAX_BUF];
377 char key[CFG_MAX_KEY];
378 struct stat stb;
379 int i;
380 int setnumber;
381 int index = 0; /* Current location in svn array */
382 sv_name_t *cur_svn; /* Pointer to svn[index] */
383 CFGFILE *cfg;
384
385 if ((cfg = cfg_open("")) == NULL) {
386 error(NULL, gettext("Error opening config: %s"),
387 strerror(errno));
388 }
389
390 cfg_resource(cfg, cfg_cluster_tag);
391 if (!cfg_lock(cfg, CFG_RDLOCK)) {
392 error(NULL, gettext("Error locking config: %s"),
393 strerror(errno));
394 }
395
396 for (i = 0; /*CSTYLED*/; i++) {
397 setnumber = i + 1;
398
399 bzero(rdev, CFG_MAX_BUF);
400 (void) snprintf(key, sizeof (key), "sv.set%d.vol", setnumber);
401 if (cfg_get_cstring(cfg, key, rdev, sizeof (rdev)) < 0)
402 break;
403
404 /* Check to see if the raw device is present */
405 if (stat(rdev, &stb) != 0) {
406 warn(NULL, gettext("unable to access %s: %s"),
407 rdev, strerror(errno));
408 continue;
409 }
410
411 if (!S_ISCHR(stb.st_mode)) {
412 warn(NULL, gettext("%s is not a character device"),
413 rdev);
414 continue;
415 }
416
417 cur_svn = &svn[index]; /* For easier reading below */
418
419 if (strlen(rdev) >= sizeof (cur_svn->svn_path)) {
420 warn(NULL, gettext(
421 "raw device name (%s) longer than %d characters"),
422 rdev,
423 (sizeof (cur_svn->svn_path) - 1));
424 continue;
425 }
426
427 (void) strcpy(cur_svn->svn_path, rdev);
428 cur_svn->svn_mode = (NSC_DEVICE | NSC_CACHE);
429
430 index++;
431 }
432
433 cfg_close(cfg);
434
435 /* Set the last path to NULL */
436 svn[index].svn_path[0] = '\0';
437
438 return (index);
439 }
440
441
442 static void
443 suspend_dev(int fd, const caddr_t path)
444 {
445 struct stat stb;
446 sv_conf_t svc;
447
448 if (stat(path, &stb) < 0) {
449 svc.svc_major = (major_t)-1;
450 svc.svc_minor = (minor_t)-1;
451 } else {
452 svc.svc_major = major(stb.st_rdev);
453 svc.svc_minor = minor(stb.st_rdev);
454 }
455
456 (void) strcpy(svc.svc_path, path);
457 svc.svc_error = spcs_s_ucreate();
458
459 if (ioctl(fd, SVIOC_DISABLE, &svc) < 0) {
460 if (errno != SV_EDISABLED) {
461 spcs_log("sv", &svc.svc_error,
462 gettext("%s: unable to suspend %s"),
463 program, path);
464
465 warn(&svc.svc_error,
466 gettext("unable to suspend %s"), path);
467 return;
468 }
469 }
470
471 spcs_log("sv", NULL, gettext("%s: suspend %s"), program, path);
472
473 spcs_s_ufree(&svc.svc_error);
474 }
475
476
477 static void
478 suspend_sv(void)
479 {
480 sv_name_t *svn, *svn_system; /* Devices in system */
481 sv_list_t svl_system;
482 int i;
483 int fd;
484
485 svn_system = sv_alloc_svnames();
486
487 svl_system.svl_count = read_libcfg(svn_system);
488
489 if ((fd = open(sv_rpath, O_RDONLY)) < 0) {
490 warn(NULL, gettext("unable to open %s: %s"),
491 sv_rpath, strerror(errno));
492 return;
493 }
494
495 for (i = 0; i < svl_system.svl_count; i++) {
496 if (*svn_system[i].svn_path == '\0')
497 break;
498
499 svn = &svn_system[i];
500 suspend_dev(fd, svn->svn_path);
501 }
502
503 (void) close(fd);
504 }
505
506
507 /*
508 * Check kernel's sv_ndevices and thread sets,
509 * if empty then change kernel state to allow unload,
510 * and sleep SV_WAIT_UNLAOD (10 seconds).
511 *
512 * Only called in pkgrm time.
513 */
514 static void
515 prepare_unload_sv(void)
516 {
517 int fd;
518 int rc = 0;
519
520 if ((fd = open(sv_rpath, O_RDONLY)) < 0) {
521 warn(NULL, gettext("unable to open %s: %s"),
522 sv_rpath, strerror(errno));
523 return;
524 }
525
526 if (ioctl(fd, SVIOC_UNLOAD, &rc) < 0)
527 error(NULL, gettext("unable to unload"));
528
529 if (rc != 0)
530 error(NULL, gettext("still has active devices or threads"));
531
532 (void) close(fd);
533 }