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 /*
23 * Copyright 2010 Sun Microsystems, Inc. All rights reserved.
24 * Use is subject to license terms.
25 */
26
27 /*
28 * Utility for cache configuration
29 */
30 #include <unistd.h>
31 #include <stdio.h>
32 #include <stdlib.h>
33 #include <strings.h>
34 #include <locale.h>
35 #include <langinfo.h>
36 #include <libintl.h>
37 #include <time.h>
38 #include <sys/nsctl/sd_bcache.h>
39 #include <sys/wait.h>
40 #include <errno.h>
41 #include <signal.h>
42 #include <sys/types.h>
43 #include <fcntl.h>
44 #include <stropts.h>
45 #include <ctype.h>
46 #include <libgen.h>
47
48 #include <sys/nsctl/sdbc_ioctl.h>
49 #include <sys/unistat/spcs_s.h>
50 #include <sys/unistat/spcs_s_u.h>
51 #include <sys/unistat/spcs_errors.h>
52 #include <nsctl.h>
53
54 #include <sys/nsctl/cfg.h>
55 #define STATS_PATH "/usr/bin/sd_stats"
56
57 #define _SD_FNAME /* bring in function names from sd_trace.h */
58 #include <sys/nsctl/sd_trace.h>
59 #include <sys/syslog.h>
60
61 /*
62 * Since we no longer support nvram cards, the hints wrthru and nowrthru no
63 * longer serve any purpose, and the system will always be in wrthru mode.
64 * WRTHRU_HINTS, if defined still allows the setting and reporting of write
65 * hints. This is defined by default on DEBUG builds.
66 */
67 #ifdef DEBUG
68 #define WRTHRU_HINTS
69 #endif
70
71 static int sdbc_max_devices = 0;
72
73 static char alert_file[200] = "/dev/console";
74
75 /* Variables used to set up paramater block passed to kernel */
76 static _sd_cache_param_t user_level_conf;
77 static int myid;
78
79 static int nodes_configured = 0;
80 static int minidsp = 0; /* Is it a sp10 */
81 static int forced_wrthru = -1; /* 0 clear, 1 set,-1 as is */
82 static int no_forced_wrthru = -1;
83 static short node_defined[MAX_SD_NODES];
84 static short nodes_conf[MAX_SD_NODES];
85
86 #define USAGELEN 1024
87 char stats_usage[USAGELEN+128];
88 char scmadmUsage[USAGELEN];
89
90 static caddr_t progname;
91
92
93 /*
94 * Functions exported for fwcadm.
95 */
96 void enable_sdbc(void);
97 void disable_sdbc(void);
98 void sdbc_set_maxdev();
99
100 static void buildusage(char *);
101
102 void print_all_options(void);
103 void get_cd_all(void);
104 int toggle_flush(void);
105 static void sd_gather_alert_dumps();
106 static int get_cd(char *);
107 static int get_hint(char *, int *, int *);
108 static void check_and_set_mirrors(int, int);
109 static void print_hint(const uint_t, const int);
110 static char *get_device_name(char *arg);
111 static void get_version();
112
113 extern struct tm *localtime_r(const time_t *, struct tm *);
114
115 #define PRINT_CACHE_SZ_ERR(sz) {\
116 (void) fprintf(stderr, gettext("\n%s: desired cache size (%d) "\
117 "set to system max (%d)\n"), \
118 progname, (sz), MAX_CACHE_SIZE); \
119 spcs_log("sdbc", NULL, \
120 gettext("desired cache size (%d) "\
121 "set to system max (%d)\n"), \
122 (sz), MAX_CACHE_SIZE); \
123 }
124
125 void
126 sdbc_report_error(spcs_s_info_t *ustatus)
127 {
128 if (*ustatus != NULL) {
129 spcs_s_report(*ustatus, stderr);
130 spcs_s_ufree(ustatus);
131 } else
132 (void) fprintf(stderr, "%s\n", strerror(errno));
133 }
134
135
136 /*
137 * Return the per-cd hints for a cd.
138 *
139 * Since the global (no)wrthru and NSC_NOCACHE hints take precedence
140 * over the per-cd hints, get them as well and OR the whole lot
141 * together.
142 */
143 static int
144 get_cd_hint(const int cd)
145 {
146 spcs_s_info_t ustats;
147 int nodehint, cdhint;
148
149 nodehint = SDBC_IOCTL(SDBC_GET_NODE_HINT, 0, 0, 0, 0, 0, &ustats);
150 if (nodehint == SPCS_S_ERROR) {
151 (void) fprintf(stderr,
152 gettext("%s: get system options failed\n"), progname);
153 sdbc_report_error(&ustats);
154 exit(1);
155 }
156
157 cdhint = SDBC_IOCTL(SDBC_GET_CD_HINT, cd, 0, 0, 0, 0, &ustats);
158 if (cdhint == SPCS_S_ERROR) {
159 (void) fprintf(stderr,
160 gettext("%s: get cd(%d) hint failed\n"), progname, cd);
161 sdbc_report_error(&ustats);
162 exit(1);
163 }
164
165 #ifdef WRTHRU_HINTS
166 nodehint &= (NSC_FORCED_WRTHRU | NSC_NO_FORCED_WRTHRU | NSC_NOCACHE);
167 #else
168 nodehint &= (NSC_NOCACHE);
169 #endif
170 if (nodehint) {
171 /* set the top bit to mark it as a system override */
172 nodehint |= 0x80000000;
173 }
174
175 return (cdhint | nodehint);
176 }
177
178
179
180 /*
181 * Check for a config.
182 *
183 * If no suitable config can be found, install the default config.
184 *
185 * Calling state:
186 * libcfg locked (mode describes type of lock)
187 */
188 static void
189 convert_config(CFGFILE *cfg, CFGLOCK mode)
190 {
191 char buf[CFG_MAX_BUF];
192 char *default_cfg = "128 64";
193
194 retry:
195 if (cfg_get_cstring(cfg, "scm.set1", buf, sizeof (buf)) >= 0) {
196 /* config exists, return */
197 return;
198 }
199
200 cfg_rewind(cfg, CFG_SEC_CONF);
201
202 #ifdef DEBUG
203 (void) printf(gettext("%s: installing default config entry '%s'\n"),
204 progname, default_cfg);
205 #endif
206 if (mode != CFG_WRLOCK) {
207 cfg_unlock(cfg);
208 if (!cfg_lock(cfg, CFG_WRLOCK)) {
209 (void) fprintf(stderr,
210 gettext("%s: unable to lock configuration: %s\n"),
211 progname, cfg_error(NULL));
212 exit(1);
213 }
214 mode = CFG_WRLOCK;
215 #ifdef DEBUG
216 (void) printf(gettext("%s: upgraded lock, retrying\n"),
217 progname);
218 #endif
219 goto retry;
220 }
221
222 if (cfg_put_cstring(cfg, "scm", default_cfg, strlen(default_cfg)) < 0) {
223 (void) fprintf(stderr,
224 gettext("%s: unable to write configuration: %s\n"),
225 progname, cfg_error(NULL));
226 exit(1);
227 }
228
229 if (!cfg_commit(cfg)) {
230 (void) fprintf(stderr,
231 gettext("%s: unable to write to configuration: %s\n"),
232 progname, cfg_error(NULL));
233 }
234
235 if (mode != CFG_WRLOCK) {
236 if (!cfg_lock(cfg, mode)) {
237 (void) fprintf(stderr,
238 gettext("%s: unable to relock configuration: %s\n"),
239 progname, cfg_error(NULL));
240 exit(1);
241 }
242 }
243
244 cfg_rewind(cfg, CFG_SEC_CONF);
245 }
246
247
248 static int
249 iscluster(void)
250 {
251 int rc;
252
253 rc = cfg_iscluster();
254 if (rc == 0) {
255 return (FALSE);
256 } else if (rc > 0) {
257 return (TRUE);
258 } else {
259 (void) fprintf(stderr,
260 gettext("%s: unable to ascertain environment\n"), progname);
261 exit(1);
262 }
263
264 /* NOTREACHED */
265 }
266
267
268 static void
269 restore_hints()
270 {
271 CFGFILE *cfg;
272 char key[CFG_MAX_KEY], buf[CFG_MAX_BUF];
273 int setnumber;
274 spcs_s_info_t ustatus;
275 int cd;
276
277 if ((cfg = cfg_open(NULL)) == NULL) {
278 (void) fprintf(stderr,
279 gettext("%s: unable to access configuration: %s\n"),
280 progname, cfg_error(NULL));
281 exit(1);
282 }
283 if (!cfg_lock(cfg, CFG_RDLOCK)) {
284 (void) fprintf(stderr,
285 gettext("%s: unable to lock configuration: %s\n"),
286 progname, cfg_error(NULL));
287 exit(1);
288 }
289
290 for (setnumber = 1; /*CONSTCOND*/ TRUE; setnumber++) {
291 (void) snprintf(key, sizeof (key), "cache_hint.set%d.device",
292 setnumber);
293 if (cfg_get_cstring(cfg, key, buf, sizeof (buf)) < 0) {
294 /* error or not found */
295 break;
296 }
297
298 if (strcmp(buf, "system") == 0) {
299 cd = -1;
300 } else {
301 cd = get_cd(buf);
302 if (cd < 0)
303 continue;
304 }
305
306 (void) snprintf(key, sizeof (key), "cache_hint.set%d.wrthru",
307 setnumber);
308 if (cfg_get_cstring(cfg, key, buf, sizeof (buf)) < 0)
309 continue;
310
311 if (atoi(buf) == 1) {
312 if (cd == -1) {
313 /* Node hint */
314 if (SDBC_IOCTL(SDBC_SET_NODE_HINT, NSC_WRTHRU,
315 1, 0, 0, 0, &ustatus) == SPCS_S_ERROR) {
316 (void) fprintf(stderr,
317 gettext("%s: set system "
318 "option failed\n"),
319 progname);
320 sdbc_report_error(&ustatus);
321 exit(1);
322 }
323 } else if (SDBC_IOCTL(SDBC_SET_CD_HINT, cd,
324 NSC_WRTHRU, 1, 0, 0, &ustatus) == SPCS_S_ERROR) {
325 (void) fprintf(stderr,
326 gettext("%s: set option failed\n"),
327 progname);
328 sdbc_report_error(&ustatus);
329 exit(1);
330 }
331 }
332
333 (void) snprintf(key, sizeof (key), "cache_hint.set%d.nordcache",
334 setnumber);
335 if (cfg_get_cstring(cfg, key, buf, sizeof (buf)) < 0)
336 continue;
337
338 if (atoi(buf) == 1) {
339 if (cd == -1) {
340 /* Node hint */
341 if (SDBC_IOCTL(SDBC_SET_NODE_HINT, NSC_NOCACHE,
342 1, 0, 0, 0, &ustatus) == SPCS_S_ERROR) {
343 (void) fprintf(stderr,
344 gettext("%s: set system "
345 "option failed\n"),
346 progname);
347 sdbc_report_error(&ustatus);
348 exit(1);
349 }
350 } else if (SDBC_IOCTL(SDBC_SET_CD_HINT, cd, NSC_NOCACHE,
351 1, 0, 0, &ustatus) == SPCS_S_ERROR) {
352 (void) fprintf(stderr,
353 gettext("%s: set option failed\n"),
354 progname);
355 sdbc_report_error(&ustatus);
356 exit(1);
357 }
358 }
359 }
360
361 cfg_close(cfg);
362 }
363
364 void
365 sdbc_set_maxdev()
366 {
367 spcs_s_info_t ustats;
368
369 if (SDBC_IOCTL(SDBC_MAXFILES, &sdbc_max_devices,
370 0, 0, 0, 0, &ustats) == SPCS_S_ERROR) {
371 (void) fprintf(stderr, gettext("%s: get maxfiles failed\n"),
372 progname);
373 sdbc_report_error(&ustats);
374 exit(1);
375 }
376 }
377
378 static void
379 bitmapfs_print(void)
380 {
381 CFGFILE *cfg;
382 char key[CFG_MAX_KEY], buf[CFG_MAX_BUF];
383 int setnumber;
384
385 cfg = cfg_open(NULL);
386 if (cfg == NULL) {
387 (void) fprintf(stderr,
388 gettext("%s: unable to access configuration: %s\n"),
389 progname, cfg_error(NULL));
390 exit(1);
391 }
392
393 if (!cfg_lock(cfg, CFG_RDLOCK)) {
394 (void) fprintf(stderr,
395 gettext("%s: unable to lock configuration: %s\n"),
396 progname, cfg_error(NULL));
397 exit(1);
398 }
399
400 for (setnumber = 1; /*CSTYLED*/; setnumber++) {
401 (void) snprintf(key, sizeof (key),
402 "bitmaps.set%d.bitmap", setnumber);
403 buf[0] = 0;
404
405 if (cfg_get_cstring(cfg, key, buf, sizeof (buf)) < 0) {
406 if (errno == ESRCH) {
407 /* end of list */
408 break;
409 }
410
411 (void) fprintf(stderr,
412 gettext("%s: error reading configuration: %s\n"),
413 progname, cfg_error(NULL));
414 exit(1);
415 }
416
417 (void) printf("%s\n", buf);
418 }
419
420 cfg_close(cfg);
421 }
422
423
424 static void
425 bitmapfs_delete(char *bitmapfs)
426 {
427 CFGFILE *cfg;
428 char key[CFG_MAX_KEY], buf[CFG_MAX_BUF];
429 int setnumber;
430 int commit = 0;
431
432 cfg = cfg_open(NULL);
433 if (cfg == NULL) {
434 (void) fprintf(stderr,
435 gettext("%s: unable to access configuration: %s\n"),
436 progname, cfg_error(NULL));
437 exit(1);
438 }
439
440 if (!cfg_lock(cfg, CFG_WRLOCK)) {
441 (void) fprintf(stderr,
442 gettext("%s: unable to lock configuration: %s\n"),
443 progname, cfg_error(NULL));
444 exit(1);
445 }
446
447 for (setnumber = 1; /*CSTYLED*/; setnumber++) {
448 (void) snprintf(key, sizeof (key),
449 "bitmaps.set%d.bitmap", setnumber);
450 buf[0] = 0;
451
452 if (cfg_get_cstring(cfg, key, buf, sizeof (buf)) < 0) {
453 if (errno == ESRCH) {
454 /* end of list */
455 (void) fprintf(stderr,
456 gettext("%s: %s not found "
457 "in configuration\n"),
458 progname, bitmapfs);
459 break;
460 }
461
462 (void) fprintf(stderr,
463 gettext("%s: error reading configuration: %s\n"),
464 progname, cfg_error(NULL));
465 exit(1);
466 }
467
468 if (strcmp(bitmapfs, buf) == 0) {
469 (void) snprintf(key, sizeof (key),
470 "bitmaps.set%d", setnumber);
471
472 if (cfg_put_cstring(cfg, key, (char *)NULL, 0) < 0) {
473 (void) fprintf(stderr,
474 gettext("%s: unable to delete %s "
475 "from configuration: %s\n"),
476 progname, bitmapfs, cfg_error(NULL));
477 } else
478 commit++;
479
480 break;
481 }
482 }
483
484 if (commit) {
485 if (!cfg_commit(cfg)) {
486 (void) fprintf(stderr,
487 gettext("%s: unable to write "
488 "to configuration: %s\n"),
489 progname, cfg_error(NULL));
490 }
491 commit = 0;
492 }
493
494 cfg_close(cfg);
495 }
496
497
498 /*
499 * User visible configuration.
500 */
501
502 static const struct {
503 const char *tag; /* libcfg tag */
504 const char *name; /* user presented name */
505 const char *help; /* explanation string */
506 } sdbc_cfg_options[] = {
507 { "thread", "nthreads", "number of threads" },
508 { "size", "cache_size", "total cache size" },
509 #ifdef DEBUG
510 { "write_cache", "write_cache_size", "write cache size" },
511 { "fill_pattern", "fill_pattern", "debug fill pattern" },
512 { "reserved1", "reserved1", "unavailable, do not use" },
513 { "iobuf", "niobuf", "number of io buffers" },
514 { "tdemons", "ntdeamons", "number of sd_test daemons" },
515 { "forced_wrthru", "forced_wrthru", "override wrthru detection" },
516 { "no_forced_wrthru", "no_forced_wrthru", "override wrthru"},
517 #endif
518 { NULL }
519 };
520
521
522 static int
523 configure_sdbc(int argc, char *argv[], int optind)
524 {
525 CFGFILE *cfg;
526 char key[CFG_MAX_KEY], buf[CFG_MAX_BUF];
527 char *cp, option[CFG_MAX_BUF], value[CFG_MAX_BUF];
528 const int opt_width = 20;
529 int error, found, commit;
530 int i;
531
532 error = commit = 0;
533
534 cfg = cfg_open(NULL);
535 if (cfg == NULL) {
536 (void) fprintf(stderr, "%s: unable to open configuration: %s",
537 progname, cfg_error(NULL));
538 return (1);
539 }
540
541 if (argc == optind) {
542 /* display current user visible config */
543
544 if (!cfg_lock(cfg, CFG_RDLOCK)) {
545 (void) fprintf(stderr,
546 gettext("%s: unable to lock configuration: %s\n"),
547 progname, cfg_error(NULL));
548 error = 1;
549 goto out;
550 }
551
552 convert_config(cfg, CFG_RDLOCK);
553
554 for (i = 0; sdbc_cfg_options[i].tag != NULL; i++) {
555 (void) snprintf(key, sizeof (key),
556 "scm.set1.%s", sdbc_cfg_options[i].tag);
557 if (cfg_get_cstring(cfg, key, buf, sizeof (buf)) < 0) {
558 if (errno == ESRCH) {
559 /* not found */
560 (void) strcpy(buf, "");
561 } else {
562 (void) fprintf(stderr,
563 gettext("%s: error reading "
564 "configuration: %s\n"),
565 progname, cfg_error(NULL));
566 error = 1;
567 goto out;
568 }
569 }
570
571 (void) printf("%-*s: %-*s /* %s */\n",
572 opt_width, sdbc_cfg_options[i].name,
573 opt_width, buf, sdbc_cfg_options[i].help);
574 }
575 } else {
576 if (!cfg_lock(cfg, CFG_WRLOCK)) {
577 (void) fprintf(stderr,
578 gettext("%s: unable to lock configuration: %s\n"),
579 progname, cfg_error(NULL));
580 error = 1;
581 goto out;
582 }
583
584 convert_config(cfg, CFG_WRLOCK);
585
586 for (/*CSTYLED*/; optind < argc; optind++) {
587 (void) strncpy(option, argv[optind], sizeof (option));
588 option[sizeof (option) - 1] = '\0'; /* terminate */
589
590 cp = strchr(option, '=');
591 if (cp != NULL) {
592 *cp = '\0'; /* terminate option */
593 cp++;
594 (void) strncpy(value, cp, sizeof (value));
595 value[sizeof (value) - 1] = '\0';
596
597 if (*value == '\0')
598 (void) strncpy(value, "-",
599 sizeof (value));
600 }
601
602 found = 0;
603 for (i = 0; sdbc_cfg_options[i].tag != NULL; i++) {
604 if (strcmp(option,
605 sdbc_cfg_options[i].name) == 0) {
606 found = 1;
607 break;
608 }
609 }
610
611 if (!found) {
612 (void) fprintf(stderr,
613 gettext("%s: unknown configuration "
614 "parameter: %s\n"), progname, option);
615 continue;
616 }
617
618 (void) snprintf(key, sizeof (key),
619 "scm.set1.%s", sdbc_cfg_options[i].tag);
620 if (cfg_get_cstring(cfg, key, buf, sizeof (buf)) < 0) {
621 (void) fprintf(stderr,
622 gettext("%s: error reading "
623 "configuration: %s\n"),
624 progname, cfg_error(NULL));
625 error = 1;
626 goto out;
627 }
628
629 if (*buf == '\0')
630 (void) strncpy(buf, "<default>", sizeof (buf));
631
632 if (cp != NULL) {
633 char *tmp;
634 long val;
635 /* set to new value */
636
637 if (strcmp(value, "-")) { /* default ? */
638
639 val = strtol(value, &tmp, 0);
640 if (strcmp(value, tmp) == 0) {
641 (void) fprintf(stderr,
642 gettext(
643 "%s: bad value (%s) "
644 "for option %s\n"),
645 progname, value, option);
646 error = 1;
647 goto out;
648 }
649
650 /* make sure cache size is valid */
651 if (strcmp(key, "scm.set1.size") == 0) {
652 if (val > MAX_CACHE_SIZE) {
653 PRINT_CACHE_SZ_ERR(val);
654
655 /*
656 * Overwrite the
657 * cache size with
658 * the maximum cache
659 * size.
660 */
661 (void) snprintf(value,
662 sizeof (value),
663 "%ld",
664 (long)
665 MAX_CACHE_SIZE);
666 }
667 }
668 }
669
670 if (cfg_put_cstring(cfg, key, value,
671 strlen(value)) < 0) {
672 (void) fprintf(stderr,
673 gettext("\n%s: error writing "
674 "configuration: %s\n"),
675 progname, cfg_error(NULL));
676 error = 1;
677 goto out;
678 }
679
680 (void) snprintf(buf, sizeof (buf),
681 "%s = %s", buf,
682 (strcmp(value, "-") == 0) ?
683 "<default>" : value);
684
685 commit = 1;
686 }
687
688 (void) printf("%-*s: %-*s /* %s */\n",
689 opt_width, sdbc_cfg_options[i].name,
690 opt_width, buf, sdbc_cfg_options[i].help);
691 } /* end command line args */
692 }
693
694 out:
695 if (commit) {
696 if (!cfg_commit(cfg)) {
697 (void) fprintf(stderr,
698 gettext("%s: unable to write "
699 "to configuration: %s\n"),
700 progname, cfg_error(NULL));
701 }
702 commit = 0;
703
704 (void) printf("\n%s\n",
705 gettext("Changed configuration parameters "
706 "will take effect when the cache is restarted"));
707 }
708
709 cfg_close(cfg);
710 return (error);
711 }
712
713
714 static char *
715 cd_to_device(int cd)
716 {
717 static _sd_stats_t *cs_cur = NULL;
718 spcs_s_info_t ustatus;
719
720 if (cs_cur == NULL) {
721 cs_cur = malloc(sizeof (_sd_stats_t) +
722 (sdbc_max_devices - 1) * sizeof (_sd_shared_t));
723
724 if (cs_cur == NULL) {
725 (void) fprintf(stderr, gettext("%s malloc: %s\n"),
726 progname, strerror(errno));
727 exit(1);
728 }
729 }
730
731 if (SDBC_IOCTL(SDBC_STATS, cs_cur, 0, 0, 0, 0,
732 &ustatus) == SPCS_S_ERROR) {
733 (void) fprintf(stderr,
734 gettext("%s: stats ioctl failed\n"), progname);
735 sdbc_report_error(&ustatus);
736 exit(1);
737 }
738 if (cs_cur->st_cachesize == 0 || cd >= cs_cur->st_count)
739 return ("");
740
741 return (cs_cur->st_shared[cd].sh_filename);
742 }
743
744 /*
745 * takes either either a string containing the cd or the device name, and
746 * returns the device name.
747 */
748 static char *
749 get_device_name(char *arg)
750 {
751 long cd = 0;
752 char *device;
753
754 /* if the arg has a leading '/', assume it's a valid device name */
755 if (!arg || *arg == '/') {
756 return (arg);
757 }
758
759 /* treat the "all" keyword as a valid device name */
760 if (strcmp(arg, "all") == 0) {
761 return (arg);
762 }
763
764 /*
765 * Next, assume it's a cd, and try to convert it to an integer, and
766 * subsequently convert that cd to its corresponding device name.
767 *
768 * Since strtol returns 0 on failure, we need to make a special case
769 * for a cd of "0", which is valid.
770 */
771 if (((cd = strtol(arg, (char **)NULL, 10)) > 0) ||
772 strcmp(arg, "0") == 0) {
773 device = cd_to_device((int)cd);
774
775 /* cd_to_device returns NULL or "" on failure--check both */
776 if (device && (strcmp(device, ""))) {
777 /* it seems to be a valid device name */
778 return (device);
779 }
780 }
781
782 return (NULL);
783 }
784
785 static void
786 remove_hint(char *device)
787 {
788 CFGFILE *cfg;
789 char key[CFG_MAX_KEY], buf[CFG_MAX_BUF];
790 int setnumber;
791 int rc;
792
793 if ((cfg = cfg_open(NULL)) == NULL) {
794 (void) fprintf(stderr,
795 gettext("%s: unable to access configuration: %s\n"),
796 progname, cfg_error(NULL));
797 exit(1);
798 }
799 if (!cfg_lock(cfg, CFG_WRLOCK)) {
800 (void) fprintf(stderr,
801 gettext("%s: unable to lock configuration: %s\n"),
802 progname, cfg_error(NULL));
803 exit(1);
804 }
805
806 for (setnumber = 1; /*CONSTCOND*/ TRUE; setnumber++) {
807 (void) snprintf(key, sizeof (key), "cache_hint.set%d.device",
808 setnumber);
809 if (cfg_get_cstring(cfg, key, buf, sizeof (buf)) < 0) {
810 /* error or not found */
811 break;
812 }
813
814 if (strcmp(device, buf) != 0)
815 continue;
816
817 /* remove config file entry */
818 (void) snprintf(key, sizeof (key),
819 "cache_hint.set%d", setnumber);
820 rc = cfg_put_cstring(cfg, key, NULL, 0);
821 if (rc < 0)
822 (void) fprintf(stderr,
823 gettext("%s: unable to update configuration "
824 "storage: %s"),
825 progname, cfg_error(NULL));
826 else if (!cfg_commit(cfg))
827 (void) fprintf(stderr,
828 gettext("%s: unable to update configuration "
829 "storage: %s"),
830 progname, cfg_error(NULL));
831 else
832 (void) fprintf(stderr,
833 gettext("%s: persistent hint for %s"
834 " removed from configuration\n"),
835 progname, device);
836 break;
837 }
838 cfg_close(cfg);
839 }
840
841
842 static void
843 save_hint(int cd, int hint, int flag)
844 {
845 char device[NSC_MAXPATH];
846 CFGFILE *cfg;
847 char key[CFG_MAX_KEY], buf[CFG_MAX_BUF];
848 int setnumber;
849 int found;
850 int rc;
851
852 if (hint != NSC_WRTHRU && hint != NSC_NOCACHE)
853 return;
854
855 if (flag != 0 && flag != 1)
856 return;
857
858 if ((cfg = cfg_open(NULL)) == NULL) {
859 (void) fprintf(stderr,
860 gettext("%s: unable to access configuration: %s\n"),
861 progname, cfg_error(NULL));
862 exit(1);
863 }
864 if (!cfg_lock(cfg, CFG_WRLOCK)) {
865 (void) fprintf(stderr,
866 gettext("%s: unable to lock configuration: %s\n"),
867 progname, cfg_error(NULL));
868 exit(1);
869 }
870
871 if (cd == -1)
872 (void) strcpy(device, "system");
873 else
874 (void) strncpy(device, cd_to_device(cd), NSC_MAXPATH);
875
876 found = 0;
877 for (setnumber = 1; /*CONSTCOND*/ TRUE; setnumber++) {
878 (void) snprintf(key, sizeof (key), "cache_hint.set%d.device",
879 setnumber);
880 if (cfg_get_cstring(cfg, key, buf, sizeof (buf)) < 0) {
881 /* error or not found */
882 break;
883 }
884
885 if (strcmp(device, buf) == 0) {
886 found = 1;
887 break;
888 }
889 }
890
891 if (found) {
892 if (hint == NSC_WRTHRU)
893 (void) snprintf(key, sizeof (key),
894 "cache_hint.set%d.wrthru", setnumber);
895 else /* NSC_NOCACHE */
896 (void) snprintf(key, sizeof (key),
897 "cache_hint.set%d.nordcache", setnumber);
898 if (flag == 0)
899 rc = cfg_put_cstring(cfg, key, "0", 1);
900 else
901 rc = cfg_put_cstring(cfg, key, "1", 1);
902 } else {
903 (void) strncpy(buf, device, CFG_MAX_BUF);
904 if (flag == 0)
905 (void) strncat(buf, " 0 0", CFG_MAX_BUF);
906 else if (hint == NSC_WRTHRU)
907 (void) strncat(buf, " 1 0", CFG_MAX_BUF);
908 else /* NSC_NOCACHE */
909 (void) strncat(buf, " 0 1", CFG_MAX_BUF);
910 rc = cfg_put_cstring(cfg, "cache_hint", buf, sizeof (buf));
911 }
912
913 if (rc < 0)
914 (void) fprintf(stderr,
915 gettext("%s: unable to update configuration storage: %s"),
916 progname, cfg_error(NULL));
917 else if (!cfg_commit(cfg))
918 (void) fprintf(stderr,
919 gettext("%s: unable to update configuration storage: %s"),
920 progname, cfg_error(NULL));
921 cfg_close(cfg);
922 }
923
924 #ifdef lint
925 int
926 scmadm_lintmain(int argc, char *argv[])
927 #else
928 int
929 main(int argc, char *argv[])
930 #endif
931 {
932 int o = 0;
933 int c;
934 int errflg = 0;
935 int hflag = 0;
936 int qflag = 1;
937 extern int optind;
938 extern char *optarg;
939 int cd;
940 int hint;
941 int flag;
942 int optflag = 0;
943 spcs_s_info_t ustats;
944 int Dopt, Lopt;
945 int Oopt = 0;
946 char *bitmapfs = NULL;
947 const char *exclusive = gettext(
948 "-d, -e, -m, -o, -C, -D, -L, and -v "
949 "are mutually exclusive\n");
950
951 (void) setlocale(LC_ALL, "");
952 (void) textdomain("scm");
953
954 progname = strdup(basename(argv[0]));
955
956 sdbc_set_maxdev();
957
958 buildusage(progname);
959
960 Dopt = Lopt = 0;
961
962 while ((c = getopt(argc, argv,
963 #ifdef DEBUG
964 "gi:t:S"
965 #endif
966 "CD:LOa:devqhm:o:")) != EOF) {
967
968 switch (c) {
969
970 case 'D':
971 if (optflag) {
972 (void) fprintf(stderr, exclusive);
973 goto usage;
974 }
975
976 Dopt++;
977 optflag++;
978 bitmapfs = optarg;
979 break;
980
981 case 'L':
982 if (optflag) {
983 (void) fprintf(stderr, exclusive);
984 goto usage;
985 }
986
987 Lopt++;
988 optflag++;
989 break;
990
991 #ifdef DEBUG
992 case 'S':
993 if (optflag) {
994 (void) fprintf(stderr, exclusive);
995 goto usage;
996 }
997
998 if (putenv(stats_usage) != 0) {
999 (void) fprintf(stderr,
1000 gettext("%s: unable to putenv()\n"),
1001 progname);
1002 exit(1);
1003 }
1004
1005 argv[1] = "scmadm";
1006 if (execv(STATS_PATH, &argv[1]) == -1) {
1007 (void) fprintf(stderr,
1008 gettext("%s: failed to execute " STATS_PATH
1009 "\n"), progname);
1010 (void) fprintf(stderr,
1011 gettext("Please be sure to copy sd_stats"
1012 " from src/cmd/ns/sdbc in a development"
1013 " workspace\n"));
1014 }
1015 exit(0);
1016 break;
1017 #endif
1018 case 'a':
1019 (void) strcpy(alert_file, optarg);
1020 break;
1021 case 'q':
1022 qflag++;
1023 break;
1024 case 'O': /* restore hints */
1025 Oopt++;
1026 break;
1027 case 'C': /* configure */
1028 case 'e': /* enable */
1029 case 'd': /* disable */
1030 case 'v': /* get version */
1031 case 'o': /* get/set options */
1032 case 'm': /* get cd map */
1033 #ifdef DEBUG
1034 case 't': /* trace */
1035 case 'i': /* inject_ioerr */
1036 case 'c': /* clear_ioerr */
1037 case 'g': /* toggle_flush */
1038 #endif
1039 if (optflag) {
1040 (void) fprintf(stderr,
1041 #ifdef DEBUG
1042 "%s%s", gettext("-t, -i, -c, -g, "),
1043 #endif
1044 exclusive);
1045
1046 errflg++;
1047 }
1048 optflag++;
1049 o = c;
1050 break;
1051 case 'h':
1052 hflag = 1;
1053 break;
1054 case '?':
1055 default:
1056 errflg++;
1057 break;
1058 }
1059 if (errflg || hflag)
1060 goto usage;
1061 }
1062
1063 if (Oopt) {
1064 /* Set hints saved in persistent configuration */
1065 restore_hints();
1066 exit(0);
1067 }
1068 if (Dopt || Lopt) {
1069 /* bitmapfs control */
1070
1071 if (iscluster()) {
1072 (void) fprintf(stderr,
1073 gettext("%s: bitmap filesystems are not "
1074 "allowed in a cluster\n"), progname);
1075 goto usage;
1076 }
1077
1078 if ((Dopt + Lopt) > 1) {
1079 (void) fprintf(stderr, gettext("-D and -L are"
1080 "mutually exclusive\n"));
1081 goto usage;
1082 }
1083
1084 if (Lopt)
1085 bitmapfs_print();
1086 else /* if (Dopt) */
1087 bitmapfs_delete(bitmapfs);
1088
1089 exit(0);
1090 }
1091
1092 if (!o) {
1093 if (argc > 1)
1094 goto usage;
1095 (void) printf(gettext("%s: Printing all cd's and options:\n"),
1096 progname);
1097 print_all_options();
1098 }
1099
1100 /* Configure */
1101 if (o == 'C') {
1102 exit(configure_sdbc(argc, argv, optind));
1103 }
1104 /* enable */
1105 if (o == 'e') {
1106 enable_sdbc();
1107 if (qflag == 0)
1108 sd_gather_alert_dumps();
1109 exit(0);
1110 }
1111 /* disable */
1112 if (o == 'd') {
1113 disable_sdbc();
1114 exit(0);
1115 }
1116 /* get version */
1117 if (o == 'v') {
1118 get_version();
1119 exit(0);
1120 }
1121 /* node_hint or cd_hint */
1122 if (o == 'o') {
1123 if (!(strcoll(optarg, "system"))) { /* node_hint */
1124 if ((optind - 1) == (argc - 1)) { /* get */
1125 if ((hint = SDBC_IOCTL(SDBC_GET_NODE_HINT, 0, 0,
1126 0, 0, 0, &ustats)) == SPCS_S_ERROR) {
1127 (void) fprintf(stderr,
1128 gettext("%s: get system "
1129 "options failed\n"),
1130 progname);
1131 sdbc_report_error(&ustats);
1132 exit(1);
1133 }
1134 #ifdef WRTHRU_HINTS
1135 (void) printf(gettext("System Status: "));
1136 print_hint(hint, 1);
1137 #endif
1138 (void) printf(gettext("System Options: "));
1139 print_hint(hint, 0);
1140 exit(0);
1141 } else { /* set, clear */
1142 if (get_hint(argv[optind], &hint, &flag) == -1)
1143 goto usage;
1144 if (hint == -1) {
1145 /* remove hint from config */
1146 remove_hint("system");
1147 exit(0);
1148 }
1149
1150 if (SDBC_IOCTL(SDBC_SET_NODE_HINT, hint, flag,
1151 0, 0, 0, &ustats) == SPCS_S_ERROR) {
1152 (void) fprintf(stderr,
1153 gettext("%s: set system "
1154 "option failed\n"),
1155 progname);
1156 sdbc_report_error(&ustats);
1157 exit(1);
1158 }
1159 save_hint(-1, hint, flag);
1160 (void) printf(gettext("%s: System option %s"
1161 " now set.\n"), progname, argv[optind]);
1162 exit(0);
1163 }
1164 } else { /* cd_hint */
1165 cd = get_cd(optarg);
1166 if ((optind - 1) == (argc - 1)) { /* get */
1167 if (cd < 0) {
1168 (void) fprintf(stderr,
1169 gettext("%s: device %s not "
1170 "found\n"),
1171 progname, optarg);
1172 exit(1);
1173 }
1174 hint = get_cd_hint(cd);
1175 (void) printf(gettext("%s: cd(%d) Current "
1176 "options are: "), progname, cd);
1177 print_hint(hint, 0);
1178 exit(0);
1179 } else { /* set, clear */
1180 if (get_hint(argv[optind], &hint, &flag) == -1)
1181 goto usage;
1182 if (hint == -1) {
1183 /* remove hint from config */
1184 if (cd < 0)
1185 remove_hint(optarg);
1186 else
1187 remove_hint(cd_to_device(cd));
1188 exit(0);
1189 }
1190 if (cd < 0) {
1191 (void) fprintf(stderr,
1192 gettext("%s: device %s not "
1193 "found\n"),
1194 progname, optarg);
1195 exit(1);
1196 }
1197
1198 if (SDBC_IOCTL(SDBC_SET_CD_HINT, cd, hint,
1199 flag, 0, 0, &ustats) == SPCS_S_ERROR) {
1200 (void) fprintf(stderr,
1201 gettext("%s: set option "
1202 "failed\n"), progname);
1203 sdbc_report_error(&ustats);
1204 exit(1);
1205 }
1206 save_hint(cd, hint, flag);
1207 (void) printf(gettext("%s: cd %d option %s now"
1208 " set.\n"), progname, cd, argv[optind]);
1209 exit(0);
1210 }
1211 }
1212 }
1213
1214 if (o == 'm') { /* "get_cd" = map */
1215 char *dev_name;
1216
1217 if (!(strcoll(optarg, "all"))) /* all */
1218 (void) get_cd_all();
1219 else {
1220 cd = get_cd(optarg);
1221 if (cd < 0) {
1222 (void) fprintf(stderr,
1223 gettext("%s: device or cd %s not found\n"),
1224 progname, optarg);
1225 exit(1);
1226 }
1227
1228 if ((dev_name = get_device_name(optarg)) == NULL) {
1229 (void) fprintf(stderr, gettext(
1230 "%s: device for cd %d not found\n"),
1231 progname, cd);
1232 exit(1);
1233 }
1234
1235 (void) printf(gettext("%s: diskname %s; cd %d\n"),
1236 progname, dev_name, cd);
1237 exit(0);
1238 }
1239 }
1240
1241 #ifdef DEBUG
1242 if (o == 't') { /* "trace" */
1243 int flag, value;
1244 _sdtr_table_t tt;
1245 if ((optind+1) != (argc-1))
1246 goto usage;
1247 cd = get_cd(argv[optind]);
1248 if (cd < 0) {
1249 (void) fprintf(stderr,
1250 gettext("%s: device or cd %s not found\n"),
1251 progname, argv[optind]);
1252 exit(1);
1253 }
1254
1255 value = strtol(argv[optind+1], 0, 0);
1256 if (!(strcoll(optarg, gettext("size")))) {
1257 flag = SD_SET_SIZE;
1258 tt.tt_max = value;
1259 } else if (!(strcoll(optarg, gettext("mask")))) {
1260 flag = SD_SET_MASK;
1261 tt.tt_mask = value;
1262 } else if (!(strcoll(optarg, gettext("lbolt")))) {
1263 flag = SD_SET_LBOLT;
1264 tt.tt_lbolt = value;
1265 } else if (!(strcoll(optarg, gettext("good")))) {
1266 flag = SD_SET_GOOD;
1267 tt.tt_good = value;
1268 } else goto usage;
1269
1270 if (SDBC_IOCTL(SDBC_ADUMP, (long)cd, &tt, NULL, 0L,
1271 (long)flag, &ustats) == SPCS_S_ERROR) {
1272 (void) fprintf(stderr,
1273 gettext("%s: trace %s failed\n"),
1274 progname, optarg);
1275 sdbc_report_error(&ustats);
1276 exit(1);
1277 }
1278 (void) printf(gettext("%s: trace %s processed\n"),
1279 progname, optarg);
1280 if (cd != -1)
1281 (void) printf(gettext(" cd %d; size %d; mask 0x%04x; "
1282 "lbolt %d; good %d;\n"),
1283 cd, tt.tt_max, tt.tt_mask,
1284 tt.tt_lbolt, tt.tt_good);
1285 exit(0);
1286 }
1287
1288 if (o == 'i') { /* "inject_ioerr" */
1289 int ioj_err = EIO;
1290 int cd;
1291 int ioj_cnt = 0;
1292
1293 /* a cd of "-1" represents all devices */
1294 if (strcmp(optarg, "-1") == 0) {
1295 cd = -1;
1296 } else if ((cd = get_cd(optarg)) < 0) {
1297 (void) fprintf(stderr,
1298 gettext("%s: device or cd %s not found\n"),
1299 progname, optarg);
1300 exit(1);
1301 }
1302 if (argc == 4)
1303 ioj_err = strtol(argv[optind], 0, 0);
1304 if (argc == 5)
1305 ioj_cnt = strtol(argv[optind+1], 0, 0);
1306
1307 if (SDBC_IOCTL(SDBC_INJ_IOERR, cd, ioj_err, ioj_cnt, 0, 0,
1308 &ustats) == SPCS_S_ERROR) {
1309 (void) fprintf(stderr,
1310 gettext("%s: i/o error injection for cd %s "
1311 "failed\n"), progname, optarg);
1312 sdbc_report_error(&ustats);
1313 exit(1);
1314 }
1315 (void) printf(gettext("%s: i/o error injection cd %d errno %d "
1316 "processed\n"), progname, cd, ioj_err);
1317 exit(0);
1318 }
1319
1320 if (o == 'c') { /* "clear_ioerr" */
1321 int cd;
1322
1323 /* a cd of "-1" represents all devices */
1324 if (strcmp(optarg, "-1") == 0) {
1325 cd = -1;
1326 } else if ((cd = get_cd(optarg)) < 0) {
1327 (void) fprintf(stderr,
1328 gettext("%s: device or cd %s not found\n"),
1329 progname, optarg);
1330 exit(1);
1331 }
1332
1333 if (SDBC_IOCTL(SDBC_CLR_IOERR, cd, 0, 0, 0, 0, &ustats)
1334 == SPCS_S_ERROR) {
1335 (void) fprintf(stderr,
1336 gettext("%s: i/o error clear %s failed\n"),
1337 progname, optarg);
1338 sdbc_report_error(&ustats);
1339 exit(1);
1340 }
1341 (void) printf(gettext("%s: i/o error clear for cd %d "
1342 "processed\n"), progname, cd);
1343 exit(0);
1344 }
1345
1346 if (o == 'g') { /* "toggle_flush" */
1347 flag = toggle_flush();
1348 (void) printf(gettext("%s: sdbc cache flush now %s\n"),
1349 progname, flag ? "on" : "off");
1350 exit(0);
1351 }
1352 #endif /* DEBUG */
1353
1354 return (0);
1355 usage:
1356 (void) fprintf(stderr, "%s\n", scmadmUsage);
1357 if (hflag) {
1358 return (0);
1359 }
1360 return (1);
1361 }
1362
1363
1364 #define addusage(f__) \
1365 (void) strncat(scmadmUsage, f__, sizeof (scmadmUsage));
1366
1367 #define addusage1(f__, a__) \
1368 (void) snprintf(fmt, sizeof (fmt), "%s%s", scmadmUsage, f__); \
1369 (void) snprintf(scmadmUsage, sizeof (scmadmUsage), fmt, a__);
1370
1371 #define addusage2(f__, a__, b__) \
1372 (void) snprintf(fmt, sizeof (fmt), "%s%s", scmadmUsage, f__); \
1373 (void) snprintf(scmadmUsage, sizeof (scmadmUsage), fmt, a__, b__);
1374
1375 static void
1376 buildusage(char *p)
1377 {
1378 char fmt[USAGELEN];
1379 #ifdef WRTHRU_HINTS
1380 char *hints_str = "[nordcache|rdcache|wrthru|nowrthru|forget]\n";
1381 #else
1382 char *hints_str = "[nordcache|rdcache|forget]\n";
1383 #endif
1384
1385 bzero(scmadmUsage, sizeof (scmadmUsage));
1386 bzero(fmt, sizeof (fmt));
1387
1388 addusage(gettext("Usage :\n"));
1389 addusage1(gettext("\t%s\n"), p);
1390 addusage1(gettext("\t%s -h\n"), p);
1391 addusage1(gettext("\t%s -e\n"), p);
1392 addusage1(gettext("\t%s -d\n"), p);
1393 addusage1(gettext("\t%s -v\n"), p);
1394 addusage1(gettext("\t%s {-L | -D bitmapfs}\n"), p);
1395 addusage1(gettext("\t%s -C [parameter[=[value]] ...]\n"), p);
1396 addusage2(gettext("\t%s -o system %s"), p, hints_str);
1397 addusage2(gettext("\t%s -o <cd> %s"), p, hints_str);
1398 addusage2(gettext("\t%s -o <diskname> %s"), p, hints_str);
1399 addusage1(gettext("\t%s -m {<cd>|<diskname>|all}\n"), p);
1400 #ifdef DEBUG
1401 addusage1(gettext(
1402 "\t%s -S [-Mz] [-d delay_time] [-l logfile] [-r range]\n"), p);
1403 addusage1(gettext(
1404 "\t%s -t {size|mask|lbolt|good} <cd|diskname> <value>\n"), p);
1405 addusage1(gettext("\t%s -g\n"), p);
1406 addusage1(gettext(
1407 "\t%s -i {cd|diskname|-1 for all} [errno [countdown]]\n"), p);
1408 addusage1(gettext("\t%s -c {cd|diskname|-1 for all}\n"), p);
1409 addusage(gettext("\nt = trace\tg = toggle_flush\ti = inject ioerr\n"
1410 "c = clear ioerr\tS = stats\n"));
1411 #endif /* DEBUG */
1412 addusage(gettext(
1413 "e = enable\td = disable\tv=version\to = get/ set options\n"));
1414 addusage(gettext(
1415 "m = get cd map\n"));
1416 addusage1(gettext(
1417 "note: cd is a cache descriptor integer in the range [0-%d]\n"),
1418 sdbc_max_devices - 1);
1419 addusage(gettext(
1420 " bitmapfs is a block device or filesystem mount point\n"));
1421
1422 #ifdef DEBUG
1423 (void) snprintf(stats_usage, sizeof (stats_usage),
1424 "SD_STATS_USAGE=%s", scmadmUsage);
1425 #endif
1426 }
1427
1428 static int
1429 get_hint(char *str, int *hint, int *flag)
1430 {
1431 #ifdef WRTHRU_HINTS
1432 if (!(strcoll(str, gettext("wrthru")))) {
1433 *hint = NSC_WRTHRU;
1434 *flag = 1;
1435 return (0);
1436 } else if (!(strcoll(str, gettext("nowrthru")))) {
1437 *hint = NSC_WRTHRU;
1438 *flag = 0;
1439 return (0);
1440 } else
1441 #endif
1442 if (!(strcoll(str, gettext("nordcache")))) {
1443 *hint = NSC_NOCACHE;
1444 *flag = 1;
1445 return (0);
1446 } else if (!(strcoll(str, gettext("rdcache")))) {
1447 *hint = NSC_NOCACHE;
1448 *flag = 0;
1449 return (0);
1450 } else if (!(strcoll(str, gettext("forget")))) {
1451 *hint = -1;
1452 *flag = 0;
1453 return (0);
1454 }
1455 return (-1);
1456 }
1457
1458 /*ARGSUSED*/
1459 void
1460 print_hint(const uint_t type, const int status)
1461 {
1462 #ifdef WRTHRU_HINTS
1463 if (status) {
1464 if (type & NSC_FORCED_WRTHRU) {
1465 (void) printf(gettext("Fast Writes Overridden\n"));
1466 } else {
1467 /* if (type & NSC_NO_FORCED_WRTHRU) */
1468 (void) printf(gettext("default\n"));
1469 }
1470 } else {
1471 (void) printf("%swrthru, %srdcache",
1472 (type & (NSC_FORCED_WRTHRU|NSC_WRTHRU)) ? "" : "no",
1473 (type & NSC_NOCACHE) ? "no" : "");
1474 #else
1475 {
1476 (void) printf("%srdcache", (type & NSC_NOCACHE) ? "no" : "");
1477 #endif
1478
1479 if (type & 0x80000000)
1480 (void) printf(" (overridden by system)");
1481
1482 (void) printf("\n");
1483 }
1484 }
1485
1486 /*
1487 * Read the configuration via libcfg
1488 */
1489
1490 int
1491 get_cache_config()
1492 {
1493 int i;
1494 int sysid;
1495 CFGFILE *cfg;
1496 char buf[CFG_MAX_BUF];
1497 char key[CFG_MAX_KEY];
1498
1499
1500 if ((cfg = cfg_open(NULL)) == NULL) {
1501 (void) fprintf(stderr,
1502 gettext("Cannot open configuration file\n"));
1503 exit(1);
1504 }
1505
1506 if (!cfg_lock(cfg, CFG_RDLOCK)) {
1507 (void) fprintf(stderr,
1508 gettext("Cannot lock configuration file\n"));
1509 exit(1);
1510 }
1511
1512 convert_config(cfg, CFG_RDLOCK);
1513 (void) memset((char *)&user_level_conf, 0, sizeof (_sd_cache_param_t));
1514
1515 /* Get the system ID */
1516 if (nsc_getsystemid(&sysid) < 0) {
1517 (void) fprintf(stderr,
1518 gettext("%s Unable to obtain subsystem ID: %s\n"),
1519 progname, strerror(errno));
1520 exit(1);
1521 }
1522 myid = sysid;
1523
1524 user_level_conf.blk_size = 8192; /* DEFAULT */
1525 user_level_conf.procs = 16; /* DEFAULT */
1526 user_level_conf.reserved1 = RESERVED1_DEFAULTS;
1527
1528 bzero(buf, CFG_MAX_BUF);
1529 (void) snprintf(key, sizeof (key), "scm.set1.thread");
1530 if (cfg_get_cstring(cfg, key, buf, CFG_MAX_BUF) > 0) {
1531 user_level_conf.threads = atoi(buf);
1532 } else
1533 user_level_conf.threads = 128; /* DEFAULT */
1534
1535 (void) snprintf(key, sizeof (key), "scm.set1.tdemons");
1536 if (cfg_get_cstring(cfg, key, buf, CFG_MAX_BUF) > 0) {
1537 user_level_conf.test_demons = atoi(buf);
1538 }
1539
1540 (void) snprintf(key, sizeof (key), "scm.set1.write_cache");
1541 if (cfg_get_cstring(cfg, key, buf, CFG_MAX_BUF) > 0) {
1542 user_level_conf.write_cache = atoi(buf);
1543 }
1544
1545 (void) snprintf(key, sizeof (key), "scm.set1.size");
1546 if (cfg_get_cstring(cfg, key, buf, CFG_MAX_BUF) > 0) {
1547 /*
1548 * We need to run strtol for backwards compatibility in 3.2.
1549 * A workaround for this bug was put in 3.2 which allowed
1550 * customers to set the cache size up to 1024 if it was
1551 * specified in hexadecimal. Decimal still had the limit
1552 * of 128. This change treats them both identically.
1553 */
1554 user_level_conf.cache_mem[0] = (int)strtol(buf, NULL, 0);
1555 if (user_level_conf.cache_mem[0] > MAX_CACHE_SIZE) {
1556 (void) fprintf(stderr, gettext(
1557 "The cache size of %ld is larger than "
1558 "the system maximum of %ld.\nUse \"scmadm -C "
1559 "cache_size=<size>\" to set the size to a proper "
1560 "value.\n"),
1561 user_level_conf.cache_mem[0], MAX_CACHE_SIZE);
1562 user_level_conf.cache_mem[0] = MAX_CACHE_SIZE;
1563 }
1564 }
1565
1566 (void) snprintf(key, sizeof (key), "scm.set1.iobuf");
1567 if (cfg_get_cstring(cfg, key, buf, CFG_MAX_BUF) > 0) {
1568 user_level_conf.iobuf = atoi(buf);
1569 }
1570
1571 (void) snprintf(key, sizeof (key), "scm.set1.fill_pattern");
1572 if (cfg_get_cstring(cfg, key, buf, CFG_MAX_BUF) > 0) {
1573 user_level_conf.fill_pattern = atoi(buf);
1574 user_level_conf.gen_pattern = 1;
1575 }
1576
1577 (void) snprintf(key, sizeof (key), "scm.set1.no_forced_wrthru");
1578 if (cfg_get_cstring(cfg, key, buf, CFG_MAX_BUF) > 0) {
1579 no_forced_wrthru = atoi(buf);
1580 }
1581
1582 (void) snprintf(key, sizeof (key), "scm.set1.forced_wrthru");
1583 if (cfg_get_cstring(cfg, key, buf, CFG_MAX_BUF) > 0) {
1584 forced_wrthru = atoi(buf);
1585 }
1586
1587 (void) snprintf(key, sizeof (key), "scm.set1.reserved1");
1588 if (cfg_get_cstring(cfg, key, buf, CFG_MAX_BUF) > 0) {
1589 user_level_conf.reserved1 = atoi(buf);
1590 }
1591
1592 cfg_close(cfg);
1593
1594 /*
1595 * use the default minidsp configuration if no
1596 * node/mirror/remote-mirror/cluster line is in the sd.cf file
1597 */
1598 if (nodes_configured == 0)
1599 check_and_set_mirrors(myid, _SD_NO_HOST);
1600
1601
1602 /* Check if our sysid was defined */
1603 if (!node_defined[myid]) {
1604 (void) fprintf(stderr,
1605 gettext("This node(%d) is not defined in config.\n"), myid);
1606 exit(1);
1607 }
1608
1609 /*
1610 * Save off number of nodes so we can calculate the point-to-point
1611 * segements. Code in kernel currently supports MAX_SD_NODES
1612 */
1613 if ((user_level_conf.num_nodes = nodes_configured) >
1614 MAX_SD_NODES) {
1615 (void) fprintf(stderr,
1616 gettext("Cache can support only %d nodes(%d).\n"),
1617 MAX_SD_NODES, nodes_configured);
1618 exit(1);
1619 }
1620
1621 if ((nodes_configured % 2) && !minidsp) {
1622 if (nodes_configured == 1)
1623 (void) fprintf(stderr,
1624 gettext("Only one node configured, "
1625 "mirror node must be %d\n"), _SD_NO_HOST);
1626 else
1627 (void) fprintf(stderr,
1628 gettext("Cannot configure odd number of nodes.\n"));
1629 exit(1);
1630 }
1631
1632
1633 /* Pass List of Nodes Configured to Cache */
1634 for (i = 0; i < nodes_configured; i++)
1635 user_level_conf.nodes_conf[i] = nodes_conf[i];
1636
1637 /* Place magic number in user_level_conf. Kernel will test for it */
1638 user_level_conf.magic = _SD_MAGIC;
1639 (void) sleep(1);
1640 return (0);
1641 }
1642
1643 _sdtr_t hdr;
1644
1645 /* function name string */
1646 char *
1647 _sd_fname(int f)
1648 {
1649 int fn = f & ST_FUNC;
1650 static char c[8];
1651 char *s;
1652
1653 if (f & ST_BCACHE)
1654 s = _bcache_fname[fn];
1655 else if (f & ST_BSUB)
1656 s = _bsub_fname[fn];
1657 else if (f & ST_IO)
1658 s = _io_fname[fn];
1659 else if (f & ST_STATS)
1660 s = _stats_fname[fn];
1661 else if (f & ST_CCIO)
1662 s = _ccio_fname[fn];
1663 else if (f & ST_FT)
1664 s = _ft_fname[fn];
1665 else if (f & ST_INFO)
1666 s = _info_fname[fn];
1667 if (!s)
1668 (void) sprintf(s = c, "0x%04x", f & 0xffff);
1669 return (s);
1670 }
1671
1672 int alerts = 0;
1673
1674 /*
1675 * Background daemon to wait for alert (on any device)
1676 * Writes the traces to "sd_alert.CD.NUM",
1677 * and writes an information message to the alert_file.
1678 */
1679
1680 void
1681 sd_gather_alert_dumps()
1682 {
1683 _sdtr_table_t tt;
1684 _sdtr_t *buf;
1685 int cd, count, size, flag;
1686 char filename[64];
1687 int fd;
1688 time_t tloc;
1689 struct tm tm_storage;
1690 struct tm *tm_ptr;
1691 char timebuf[80];
1692 spcs_s_info_t ustats;
1693
1694 /* fork and detach daemon */
1695 if (fork())
1696 exit(0);
1697 (void) close(0);
1698 fd = open(alert_file, O_WRONLY|O_APPEND|O_CREAT, 0644);
1699 if (fd == -1)
1700 fd = open("/dev/console", O_WRONLY);
1701 if (fd != -1) {
1702 (void) dup2(fd, 1);
1703 (void) dup2(fd, 2);
1704 (void) close(fd);
1705 }
1706 (void) setsid();
1707
1708 size = 10000;
1709 if (size < user_level_conf.trace_size)
1710 size = user_level_conf.trace_size;
1711
1712 buf = (_sdtr_t *)malloc(size * sizeof (_sdtr_t));
1713 if (!buf) {
1714 (void) fprintf(stderr, gettext("%s malloc: %s\n"),
1715 progname, strerror(errno));
1716 exit(1);
1717 }
1718 tloc = time(NULL);
1719 tm_ptr = (struct tm *)localtime_r(&tloc, &tm_storage);
1720
1721 loop:
1722 cd = SDT_ANY_CD; /* any device */
1723 flag = SD_ALERT_WAIT; /* block for alert */
1724 if ((count = SDBC_IOCTL(SDBC_ADUMP, cd, &tt, buf, size,
1725 flag, &ustats)) == SPCS_S_ERROR) {
1726 (void) fprintf(stderr, gettext("%s: sd_adump\n"), progname);
1727 sdbc_report_error(&ustats);
1728 if (errno == EIDRM) {
1729 (void) strftime(timebuf, 80, "%x %X", tm_ptr);
1730 (void) fprintf(stderr,
1731 gettext("%s: cache deconfigured at %s\n"),
1732 progname, timebuf);
1733 exit(0);
1734 }
1735 if (errno == ENOSYS)
1736 exit(0);
1737 exit(errno);
1738 }
1739 if (count == 0)
1740 goto loop;
1741 cd = tt.tt_cd;
1742 (void) sprintf(filename, "%s.%d.%d", "sd_alert", cd, alerts++);
1743 if ((fd = open(filename, O_CREAT | O_RDWR, 0444)) == -1) {
1744 (void) fprintf(stderr, gettext("%s: open: %s\n"),
1745 progname, strerror(errno));
1746 exit(errno);
1747 }
1748 /*
1749 * write header to identify device, write entries
1750 */
1751 hdr.t_func = SDF_CD;
1752 hdr.t_len = count;
1753 hdr.t_ret = tt.tt_cd;
1754 if (write(fd, &hdr, sizeof (_sdtr_t)) == -1) {
1755 (void) fprintf(stderr, gettext("%s: write: %s\n"),
1756 progname, strerror(errno));
1757 exit(errno);
1758 }
1759
1760 if (write(fd, buf, sizeof (_sdtr_t)*count) == -1) {
1761 (void) fprintf(stderr, gettext("%s: write: %s\n"),
1762 progname, strerror(errno));
1763 exit(errno);
1764 }
1765 (void) close(fd);
1766
1767 (void) strftime(timebuf, 80, "%x %X", tm_ptr);
1768 (void) printf("sd alert trace dump %s at %s\n", filename, timebuf);
1769 goto loop;
1770 }
1771
1772
1773
1774 /*
1775 * print list of configured cd's, diskname, options and global options
1776 */
1777 void
1778 print_all_options()
1779 {
1780 static _sd_stats_t *cs_cur;
1781 spcs_s_info_t ustats;
1782 int cd;
1783 int hint;
1784 char *s1 = "device name";
1785 char *s2 = "option";
1786 char fn[19];
1787 int len;
1788
1789 /* No corresponding free because this function exits */
1790 cs_cur = malloc(sizeof (_sd_stats_t) +
1791 (sdbc_max_devices - 1) * sizeof (_sd_shared_t));
1792 if (cs_cur == NULL) {
1793 (void) fprintf(stderr, gettext("%s malloc: %s\n"),
1794 progname, strerror(errno));
1795 exit(1);
1796 }
1797
1798 /* node hints */
1799 if ((hint = SDBC_IOCTL(SDBC_GET_NODE_HINT, 0, 0, 0, 0, 0,
1800 &ustats)) == SPCS_S_ERROR) {
1801 (void) fprintf(stderr,
1802 gettext("%s: get system option failed\n"),
1803 progname);
1804 sdbc_report_error(&ustats);
1805 exit(1);
1806 }
1807 #ifdef WRTHRU_HINTS
1808 (void) printf(gettext("System Status: "));
1809 print_hint(hint, 1);
1810 #endif
1811 (void) printf(gettext("System Options: "));
1812 print_hint(hint, 0);
1813
1814 /* get cds */
1815 if (SDBC_IOCTL(SDBC_STATS, cs_cur, 0, 0, 0, 0, &ustats)
1816 == SPCS_S_ERROR) {
1817 (void) fprintf(stderr,
1818 gettext("%s: get_cd failed in print_all options\n"),
1819 progname);
1820 sdbc_report_error(&ustats);
1821 exit(1);
1822 }
1823 if (cs_cur->st_cachesize == 0)
1824 (void) printf(gettext("Cache is disabled\n"));
1825 else if (cs_cur->st_count == 0)
1826 (void) printf(gettext("No devices are configured\n"));
1827 else {
1828 (void) printf(
1829 gettext("\nConfigured cd's, disknames and options: \n"));
1830 (void) printf(gettext("cd\t%-28s\t%-20s\n"), s1, s2);
1831 for (cd = 0; cd < cs_cur->st_count; cd++) {
1832 if (cs_cur->st_shared[cd].sh_alloc) {
1833 hint = get_cd_hint(cd);
1834 if ((len =
1835 strlen(cs_cur->st_shared[cd].sh_filename))
1836 > 23) {
1837 (void) strcpy(fn, "...");
1838 (void) strcat(fn,
1839 cs_cur->st_shared[cd].sh_filename +
1840 len - 20);
1841 } else {
1842 (void) strcpy(fn,
1843 cs_cur->st_shared[cd].sh_filename);
1844 }
1845
1846 (void) printf(gettext("%d\t%-28.*s\t"), cd,
1847 NSC_MAXPATH, fn);
1848
1849 print_hint(hint, 0);
1850 }
1851 }
1852 }
1853 exit(0);
1854 }
1855
1856
1857 /*
1858 * cache device -- lookup names and cache descriptors of all configured devices
1859 */
1860 void
1861 get_cd_all()
1862 {
1863 static _sd_stats_t *cs_cur;
1864 spcs_s_info_t ustats;
1865 int cd;
1866 char fn[19];
1867 int len;
1868
1869 /* No corresponding free because this function exits */
1870 cs_cur = malloc(sizeof (_sd_stats_t) +
1871 (sdbc_max_devices - 1) * sizeof (_sd_shared_t));
1872 if (cs_cur == NULL) {
1873 (void) fprintf(stderr, gettext("%s malloc: %s\n"),
1874 progname, strerror(errno));
1875 exit(1);
1876 }
1877
1878 if (SDBC_IOCTL(SDBC_STATS, cs_cur, 0, 0, 0, 0, &ustats)
1879 == SPCS_S_ERROR) {
1880 (void) fprintf(stderr, gettext("%s: get_cd_all"),
1881 progname);
1882 sdbc_report_error(&ustats);
1883 exit(1);
1884 }
1885 if (cs_cur->st_cachesize == 0)
1886 (void) printf(gettext("Cache is disabled\n"));
1887 else if (cs_cur->st_count == 0)
1888 (void) printf(gettext("No devices are configured\n"));
1889 else {
1890 (void) printf(gettext("\tcd\tdevice name\n"));
1891 for (cd = 0; cd < cs_cur->st_count; cd++) {
1892 if (cs_cur->st_shared[cd].sh_alloc) {
1893 if ((len = strlen(
1894 cs_cur->st_shared[cd].sh_filename)) > 15) {
1895 (void) strcpy(fn, "...");
1896 (void) strcat(fn,
1897 cs_cur->st_shared[cd].sh_filename +
1898 len - 12);
1899 } else {
1900 (void) strcpy(fn,
1901 cs_cur->st_shared[cd].sh_filename);
1902 }
1903 (void) printf(gettext("\t%d\t%s\n"),
1904 cd, fn);
1905 }
1906 }
1907 }
1908 exit(0);
1909 }
1910
1911 /*
1912 * cache device -- specified by number or lookup name
1913 */
1914 static int
1915 get_cd(char *s)
1916 {
1917 static _sd_stats_t *cs_cur = NULL;
1918 spcs_s_info_t ustats;
1919 int cd, arg_cd = -1;
1920
1921 if (cs_cur == NULL) {
1922 /*
1923 * No corresponding free because the memory is reused
1924 * every time the function is called.
1925 */
1926 cs_cur = malloc(sizeof (_sd_stats_t) +
1927 (sdbc_max_devices - 1) * sizeof (_sd_shared_t));
1928 if (cs_cur == NULL) {
1929 (void) fprintf(stderr, gettext("%s malloc: %s\n"),
1930 progname, strerror(errno));
1931 exit(1);
1932 }
1933 }
1934
1935 if (SDBC_IOCTL(SDBC_STATS, cs_cur, 0, 0, 0, 0, &ustats)
1936 == SPCS_S_ERROR) {
1937 (void) fprintf(stderr, gettext("%s: get_cd\n"), progname);
1938 sdbc_report_error(&ustats);
1939 exit(1);
1940 }
1941 if (cs_cur->st_cachesize == 0) {
1942 (void) printf(gettext("Cache is disabled\n"));
1943 exit(0);
1944 }
1945
1946 if (*s != '/') {
1947 /*
1948 * Since strtol returns 0 on failure, we need to make a
1949 * special case for a cd of "0", which is valid.
1950 *
1951 * This case also deals with the difference between
1952 * scmadm -o system and scmadm -o 0
1953 */
1954 if (((int)strtol(s, (char **)NULL, 10) == 0) &&
1955 strcmp(s, "0"))
1956 return (-1);
1957
1958 /*
1959 * Only return failure at this point, in order to allow
1960 * checking arg_cd against st_count later on.
1961 */
1962 if ((arg_cd = strtol(s, 0, 0)) < 0) {
1963 return (arg_cd);
1964 }
1965 }
1966
1967 /* make sure the cd passed as an argument is alloc'd and < st_count */
1968 if (arg_cd >= 0) {
1969 return (((arg_cd < cs_cur->st_count) &&
1970 (cs_cur->st_shared[arg_cd].sh_alloc)) ? arg_cd : -1);
1971 }
1972
1973 for (cd = 0; cd < cs_cur->st_count; cd++) {
1974 if (cs_cur->st_shared[cd].sh_alloc &&
1975 strcmp(s, cs_cur->st_shared[cd].sh_filename) == 0)
1976 return (cd);
1977 }
1978 return (-1);
1979 }
1980
1981 void
1982 check_and_set_mirrors(int node, int mirror)
1983 {
1984
1985 if (minidsp) {
1986 (void) fprintf(stderr,
1987 gettext("%s: minidsp defined. "
1988 "Cannot define other nodes.\n"),
1989 progname);
1990 exit(1);
1991 }
1992
1993 if (mirror == _SD_NO_HOST) {
1994 minidsp++;
1995 } else if ((!(node % 2) && !(node == mirror - 1)) ||
1996 (((node % 2) && !(node == mirror + 1)))) {
1997 (void) fprintf(stderr,
1998 gettext("%s: Node and Mirror identification values "
1999 "must be consecutive\n"
2000 "starting at an even number (Node = %d Mirror = %d)\n"),
2001 progname, node, mirror);
2002 exit(1);
2003 }
2004
2005 node_defined[node]++;
2006
2007 nodes_conf[nodes_configured] = node;
2008 nodes_configured++;
2009
2010 if (node == myid) {
2011 user_level_conf.mirror_host = mirror;
2012 }
2013 }
2014
2015 char *mem_string =
2016 "%-8s Structures use approx. %8d bytes (%5d pages) of memory\n";
2017
2018 void
2019 enable_sdbc()
2020 {
2021 spcs_s_info_t ustats;
2022
2023 if (get_cache_config()) {
2024 (void) fprintf(stderr,
2025 gettext("%s: unable to read configuration file\n"),
2026 progname);
2027 exit(1);
2028 }
2029
2030 if (SDBC_IOCTL(SDBC_ENABLE, &user_level_conf, 0, 0, 0, 0,
2031 &ustats) == SPCS_S_ERROR) {
2032 (void) fprintf(stderr, gettext("%s: cache enable failed\n"),
2033 progname);
2034 spcs_log("scm", &ustats, gettext("%s cache enable failed"),
2035 progname);
2036 sdbc_report_error(&ustats);
2037 exit(1);
2038 }
2039 spcs_log("scm", NULL, gettext("%s cache enable succeeded"),
2040 progname);
2041 #ifdef DEBUG
2042 (void) printf(gettext("%s: cache has been configured\n"), progname);
2043 #endif
2044 #ifdef WRTHRU_HINTS
2045 if (iscluster()) {
2046 /* Must writethru on a cluster, even if nvram configured */
2047 forced_wrthru = 1;
2048 }
2049
2050 if (minidsp && forced_wrthru != -1) {
2051 /* Have minidsp with forced_wrthru hint. Set / Clear hint */
2052 if (SDBC_IOCTL(SDBC_SET_NODE_HINT, NSC_FORCED_WRTHRU,
2053 forced_wrthru, 0, 0, 0, &ustats) == SPCS_S_ERROR) {
2054 (void) fprintf(stderr,
2055 gettext("%s: set/clear forced_wrthru failed\n"),
2056 progname);
2057 sdbc_report_error(&ustats);
2058 } else if (forced_wrthru) {
2059 (void) printf(gettext("%s: Node option forced_wrthru "
2060 "now set.\n"), progname);
2061 } else {
2062 (void) printf(gettext("%s: Node option forced_wrthru "
2063 "now cleared.\n"), progname);
2064 }
2065 }
2066 if (no_forced_wrthru != -1) {
2067 if (SDBC_IOCTL(SDBC_SET_NODE_HINT, NSC_NO_FORCED_WRTHRU,
2068 no_forced_wrthru, 0, 0, 0, &ustats) == SPCS_S_ERROR) {
2069 (void) fprintf(stderr,
2070 gettext("%s: set/clear no_forced_wrthru "
2071 "failed\n"), progname);
2072 sdbc_report_error(&ustats);
2073 } else if (no_forced_wrthru) {
2074 (void) printf(gettext("%s: Node option no_forced_wrthru"
2075 " now set.\n"), progname);
2076 } else {
2077 (void) printf(gettext("%s: Node option no_forced_wrthru"
2078 " now cleared.\n"), progname);
2079 }
2080 }
2081 #endif
2082
2083 /* do scmadm -O to cater for manual cache disable then enable */
2084 restore_hints();
2085 }
2086
2087 void
2088 disable_sdbc()
2089 {
2090 spcs_s_info_t ustats;
2091
2092 if (SDBC_IOCTL(SDBC_DISABLE, 0, 0, 0, 0, 0, &ustats) != SPCS_S_OK) {
2093 /*
2094 * If it wasn't already enabled, don't appear to fail
2095 * or users of this program might think the cache is
2096 * configured, when it actually isn't.
2097 */
2098 if (errno != SDBC_EDISABLE) {
2099 spcs_log("scm", &ustats,
2100 gettext("%s cache disable failed"), progname);
2101 sdbc_report_error(&ustats);
2102 exit(1);
2103 }
2104 }
2105 #ifdef DEBUG
2106 (void) printf(gettext("%s: cache has been deconfigured\n"), progname);
2107 #endif
2108 spcs_log("scm", NULL, gettext("%s cache disable succeeded"),
2109 progname);
2110 }
2111
2112 static void
2113 get_version()
2114 {
2115 cache_version_t version;
2116 spcs_s_info_t ustats;
2117
2118 if (SDBC_IOCTL(SDBC_VERSION, &version, 0, 0, 0, 0, &ustats) ==
2119 SPCS_S_ERROR) {
2120 (void) fprintf(stderr,
2121 gettext("%s: get cache version failed\n"), progname);
2122 sdbc_report_error(&ustats);
2123 exit(1);
2124 }
2125 #ifdef DEBUG
2126 (void) printf(gettext("Cache version %d.%d.%d.%d\n"),
2127 version.major, version.minor, version.micro, version.baseline);
2128 #else
2129 if (version.micro) {
2130 (void) printf(gettext("Cache version %d.%d.%d\n"),
2131 version.major, version.minor, version.micro);
2132 } else {
2133 (void) printf(gettext("Cache version %d.%d\n"),
2134 version.major, version.minor);
2135 }
2136 #endif
2137 }
2138
2139 #ifdef DEBUG
2140 int
2141 toggle_flush(void)
2142 {
2143 int rc;
2144 spcs_s_info_t ustats;
2145
2146 if ((rc = SDBC_IOCTL(SDBC_TOGGLE_FLUSH, 0, 0, 0,
2147 0, 0, &ustats)) == SPCS_S_ERROR) {
2148 (void) fprintf(stderr,
2149 gettext("%s: toggle sdbc cache flush failed\n"),
2150 progname);
2151 sdbc_report_error(&ustats);
2152 exit(1);
2153 }
2154 return (rc);
2155 }
2156 #endif