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 <fcntl.h> 30 #include <unistd.h> 31 #include <stropts.h> 32 #include <stdio.h> 33 #include <errno.h> 34 #include <libintl.h> 35 #include <locale.h> 36 #include <stdlib.h> 37 38 #include <sys/nsctl/rdcerr.h> 39 #include <sys/nsctl/rdc_ioctl.h> 40 #include <sys/nsctl/librdc.h> 41 #include <sys/nsctl/cfg.h> 42 #include <sys/nsctl/nsc_hash.h> 43 #include <sys/nsctl/sv.h> 44 45 #include <sys/unistat/spcs_dtrinkets.h> 46 #include <sys/unistat/spcs_etrinkets.h> 47 #include <sys/unistat/spcs_s.h> 48 #include <sys/unistat/spcs_s_u.h> 49 #include <sys/unistat/spcs_s_impl.h> 50 #include <sys/unistat/spcs_errors.h> 51 52 typedef struct volcount_s { 53 int count; 54 } volcount_t; 55 56 hash_node_t **volhash = NULL; 57 58 char * 59 config2buf(char *buf, rdcconfig_t *rdc) 60 { 61 snprintf(buf, CFG_MAX_BUF, "%s %s %s %s %s %s %s %s %s %s %s", 62 rdc->phost, rdc->pfile, rdc->pbmp, rdc->shost, rdc->sfile, 63 rdc->sbmp, rdc->direct, rdc->mode, rdc->group ? rdc->group : "", 64 rdc->ctag ? rdc->ctag : "", rdc->options ? rdc->options : ""); 65 return (buf); 66 67 } 68 69 /* 70 * SV type functions. 71 */ 72 73 static void 74 load_rdc_vols(CFGFILE *cfg) 75 { 76 int set; 77 char key[ CFG_MAX_KEY ]; 78 char buf[ CFG_MAX_BUF ]; 79 char *vol, *bmp, *host1, *host2; 80 volcount_t *volcount; 81 82 if (volhash) { 83 return; 84 } 85 86 cfg_rewind(cfg, CFG_SEC_CONF); 87 volhash = nsc_create_hash(); 88 for (set = 1; /*CSTYLED*/; set++) { 89 snprintf(key, CFG_MAX_KEY, "sndr.set%d", set); 90 if (cfg_get_cstring(cfg, key, buf, CFG_MAX_BUF)) { 91 break; 92 } 93 94 host1 = strtok(buf, " "); 95 vol = strtok(NULL, " "); 96 bmp = strtok(NULL, " "); 97 98 if (!self_check(host1)) { 99 /* next one had better be ours */ 100 host2 = strtok(NULL, " "); 101 vol = strtok(NULL, " "); 102 bmp = strtok(NULL, " "); 103 104 if (!self_check(host2)) { 105 continue; 106 } 107 } 108 109 /* primary vol may be used more than once */ 110 volcount = (volcount_t *)nsc_lookup(volhash, vol); 111 if (volcount) { 112 volcount->count++; 113 } else { 114 volcount = (volcount_t *)malloc(sizeof (volcount_t)); 115 volcount->count = 1; 116 nsc_insert_node(volhash, volcount, vol); 117 } 118 119 /* bitmap ought to be only used once */ 120 volcount = (volcount_t *)nsc_lookup(volhash, bmp); 121 if (volcount) { 122 /* argh */ 123 volcount->count++; 124 } else { 125 volcount = (volcount_t *)malloc(sizeof (volcount_t)); 126 volcount->count = 1; 127 nsc_insert_node(volhash, volcount, bmp); 128 } 129 } 130 } 131 132 int 133 sv_enable_one_nocfg(char *vol) 134 { 135 struct stat sb; 136 sv_conf_t svc; 137 int fd; 138 139 bzero(&svc, sizeof (svc)); 140 if (stat(vol, &sb) != 0) { 141 rdc_set_error(NULL, RDC_OS, 0, "unable to stat %s", vol); 142 return (-1); 143 } 144 if (!S_ISCHR(sb.st_mode)) { 145 rdc_set_error(NULL, RDC_INTERNAL, RDC_NONFATAL, "%s is not" 146 " a character device", vol); 147 return (-1); 148 } 149 150 svc.svc_major = major(sb.st_rdev); 151 svc.svc_minor = minor(sb.st_rdev); 152 strncpy(svc.svc_path, vol, sizeof (svc.svc_path)); 153 154 fd = open(SV_DEVICE, O_RDONLY); 155 if (fd < 0) { 156 rdc_set_error(NULL, RDC_OS, 0, 0); 157 return (-1); 158 } 159 160 svc.svc_flag = (NSC_DEVICE | NSC_CACHE); 161 svc.svc_error = spcs_s_ucreate(); 162 163 if (ioctl(fd, SVIOC_ENABLE, &svc) < 0) { 164 if (errno != SV_EENABLED) { 165 rdc_set_error(&svc.svc_error, RDC_INTERNAL, 166 RDC_NONFATAL, 0); 167 return (-1); 168 } 169 } 170 171 spcs_log("sv", NULL, gettext("enabled %s"), svc.svc_path); 172 173 close(fd); 174 return (1); 175 } 176 177 int 178 sv_enable_nocfg(rdcconfig_t *rdc) 179 { 180 struct stat stbv; 181 struct stat stbb; 182 sv_conf_t svcv; 183 sv_conf_t svcb; 184 char vol[NSC_MAXPATH]; 185 char bmp[NSC_MAXPATH]; 186 int fd = -1; 187 188 189 if (self_check(rdc->phost)) { 190 strncpy(vol, rdc->pfile, NSC_MAXPATH); 191 strncpy(bmp, rdc->pbmp, NSC_MAXPATH); 192 } else { 193 strncpy(vol, rdc->sfile, NSC_MAXPATH); 194 strncpy(bmp, rdc->sbmp, NSC_MAXPATH); 195 } 196 197 bzero(&svcv, sizeof (svcv)); 198 bzero(&svcb, sizeof (svcb)); 199 200 if ((stat(vol, &stbv) != 0) || (stat(bmp, &stbb) != 0)) 201 return (-1); 202 203 if ((!S_ISCHR(stbv.st_mode)) || (!S_ISCHR(stbb.st_mode))) 204 return (-1); 205 206 svcv.svc_major = major(stbv.st_rdev); 207 svcb.svc_minor = minor(stbb.st_rdev); 208 209 strncpy(svcv.svc_path, vol, sizeof (svcv.svc_path)); 210 strncpy(svcb.svc_path, bmp, sizeof (svcb.svc_path)); 211 212 fd = open(SV_DEVICE, O_RDONLY); 213 if (fd < 0) 214 return (-1); 215 216 /* SV enable the volume */ 217 svcv.svc_flag = (NSC_DEVICE | NSC_CACHE); 218 svcv.svc_error = spcs_s_ucreate(); 219 220 if (ioctl(fd, SVIOC_ENABLE, &svcv) < 0) { 221 if (errno != SV_EENABLED) { 222 spcs_log("sv", &svcv.svc_error, 223 gettext("unable to enable %s"), 224 svcv.svc_path); 225 spcs_s_ufree(&svcv.svc_error); 226 return (-1); 227 } 228 } 229 230 /* SV enable the bitmap disable the vol on error */ 231 svcb.svc_flag = (NSC_DEVICE | NSC_CACHE); 232 svcb.svc_error = spcs_s_ucreate(); 233 234 if (ioctl(fd, SVIOC_ENABLE, &svcb) < 0) { 235 if (errno != SV_EENABLED) { 236 spcs_log("sv", &svcb.svc_error, 237 gettext("unable to enable %s"), 238 svcb.svc_path); 239 if (ioctl(fd, SVIOC_DISABLE, &svcv) < 0) 240 spcs_log("sv", &svcv.svc_error, 241 gettext("unable to disable %s"), 242 svcv.svc_path); 243 244 spcs_s_ufree(&svcv.svc_error); 245 spcs_s_ufree(&svcb.svc_error); 246 return (-1); 247 } 248 } 249 250 251 spcs_log("sv", NULL, gettext("enabled %s"), svcv.svc_path); 252 spcs_log("sv", NULL, gettext("enabled %s"), svcb.svc_path); 253 spcs_s_ufree(&svcv.svc_error); 254 spcs_s_ufree(&svcb.svc_error); 255 256 257 if (fd >= 0) 258 (void) close(fd); 259 260 return (1); 261 } 262 263 int 264 do_autosv_enable(CFGFILE *cfg, rdcconfig_t *rdc) 265 { 266 char vol[NSC_MAXPATH]; 267 char bmp[NSC_MAXPATH]; 268 269 cfg_load_svols(cfg); 270 cfg_load_dsvols(cfg); 271 cfg_load_shadows(cfg); 272 load_rdc_vols(cfg); 273 274 if (self_check(rdc->phost)) { 275 strncpy(vol, rdc->pfile, NSC_MAXPATH); 276 strncpy(bmp, rdc->pbmp, NSC_MAXPATH); 277 } else { 278 strncpy(vol, rdc->sfile, NSC_MAXPATH); 279 strncpy(bmp, rdc->sbmp, NSC_MAXPATH); 280 } 281 if (nsc_lookup(volhash, vol) == NULL) { 282 if (cfg_vol_enable(cfg, vol, rdc->ctag, "sndr") < 0) { 283 rdc_set_error(NULL, RDC_INTERNAL, RDC_NONFATAL, 284 "auto sv enable failed for %s", vol); 285 return (-1); 286 } 287 } 288 if (nsc_lookup(volhash, bmp) == NULL) { 289 if (cfg_vol_enable(cfg, bmp, rdc->ctag, "sndr") < 0) { 290 rdc_set_error(NULL, RDC_INTERNAL, RDC_NONFATAL, 291 "auto sv enable failed for %s", vol); 292 return (-1); 293 } 294 } 295 296 nsc_remove_all(volhash, free); 297 volhash = NULL; 298 299 cfg_unload_shadows(); 300 cfg_unload_dsvols(); 301 cfg_unload_svols(); 302 303 return (1); 304 } 305 306 int 307 do_autosv_disable(CFGFILE *cfg, rdcconfig_t *rdc) 308 { 309 char vol[NSC_MAXPATH]; 310 char bmp[NSC_MAXPATH]; 311 volcount_t *vc; 312 313 cfg_load_svols(cfg); 314 cfg_load_dsvols(cfg); 315 cfg_load_shadows(cfg); 316 load_rdc_vols(cfg); 317 318 if (self_check(rdc->phost)) { 319 strncpy(vol, rdc->pfile, NSC_MAXPATH); 320 strncpy(bmp, rdc->pbmp, NSC_MAXPATH); 321 } else { 322 strncpy(vol, rdc->sfile, NSC_MAXPATH); 323 strncpy(bmp, rdc->sbmp, NSC_MAXPATH); 324 } 325 326 vc = nsc_lookup(volhash, vol); 327 if (vc && (vc->count == 1)) { 328 if (cfg_vol_disable(cfg, vol, rdc->ctag, "sndr") < 0) 329 rdc_set_error(NULL, RDC_INTERNAL, RDC_NONFATAL, 330 "auto sv disable failed for %s", vol); 331 } else if (!vc) { 332 rdc_set_error(NULL, RDC_INTERNAL, RDC_NONFATAL, 333 "Unable to find %s in config", vol); 334 } 335 vc = nsc_lookup(volhash, bmp); 336 if (vc && (vc->count == 1)) { 337 if (cfg_vol_disable(cfg, bmp, rdc->ctag, "sndr") < 0) 338 rdc_set_error(NULL, RDC_INTERNAL, RDC_NONFATAL, 339 "auto sv disable failed for %s", bmp); 340 341 } else if (!vc) { 342 rdc_set_error(NULL, RDC_INTERNAL, RDC_NONFATAL, 343 "Unable to find %s in config", bmp); 344 } 345 346 return (1); 347 348 } 349 350 /* 351 * do sv enables for the appropriate vol 352 * and bitmap. If called without persistance 353 * it will follow a chain and sv enable all 354 * otherwise, it will enable only the one 355 * set. 356 */ 357 int 358 sv_enable(CFGFILE *cfg, rdcconfig_t *rdcs) 359 { 360 rdcconfig_t *rdcp = NULL; 361 362 rdcp = rdcs; 363 if (!rdcp->persist) { 364 365 return (sv_enable_nocfg(rdcp)); 366 367 } else if (cfg == NULL) { 368 369 return (-1); 370 371 } 372 373 do_autosv_enable(cfg, rdcp); 374 375 return (1); 376 } 377 378 int 379 sv_disable(CFGFILE *cfg, rdcconfig_t *rdcs) 380 { 381 rdcconfig_t *rdcp; 382 383 rdcp = rdcs; 384 if (!rdcp->persist) { /* don't disable */ 385 386 return (1); 387 388 } else if (cfg == NULL) { 389 390 return (-1); 391 392 } 393 394 do_autosv_disable(cfg, rdcp); 395 396 return (1); 397 398 } 399 400 /* 401 * disable the appropriate bitmap in rdc 402 * and replace it with bitmap 403 */ 404 int 405 sv_reconfig(CFGFILE *cfg, rdcconfig_t *rdc, char *oldbmp, char *newbmp) 406 { 407 rdcconfig_t *rdcp; 408 int fail = 0; 409 410 rdcp = rdc; 411 if (!rdcp->persist) { /* just enable, don't disable */ 412 413 sv_enable_one_nocfg(newbmp); 414 415 } else if (rdcp->persist) { /* do sv disable and enable */ 416 volcount_t *vc; 417 418 cfg_load_svols(cfg); 419 cfg_load_dsvols(cfg); 420 cfg_load_shadows(cfg); 421 load_rdc_vols(cfg); 422 423 vc = (volcount_t *)nsc_lookup(volhash, oldbmp); 424 if (vc && (vc->count == 1)) { 425 if (cfg_vol_disable(cfg, oldbmp, rdc->ctag, "sndr") < 0) 426 rdc_set_error(NULL, RDC_INTERNAL, RDC_NONFATAL, 427 "auto sv disable failed for %s", oldbmp); 428 429 } 430 if (nsc_lookup(volhash, newbmp) == NULL) { 431 if (cfg_vol_enable(cfg, 432 newbmp, rdc->ctag, "sndr") < 0) { 433 434 rdc_set_error(NULL, RDC_INTERNAL, RDC_NONFATAL, 435 "auto sv enable failed for %s", newbmp); 436 fail++; 437 } 438 } 439 nsc_remove_all(volhash, free); 440 volhash = NULL; 441 442 cfg_unload_shadows(); 443 cfg_unload_dsvols(); 444 cfg_unload_svols(); 445 if (fail) 446 return (-1); 447 448 } 449 return (1); 450 451 } 452 453 /* 454 * SNDR functions 455 */ 456 457 /* 458 * add_to_rdc_cfg 459 * this adds the successfully created rdc sets to libdscfg, 460 * also, as auto_sv stuff is part of libdscfg, it does the 461 * auto_sv stuff and enables the correct volumes 462 */ 463 int 464 add_to_rdc_cfg(rdcconfig_t *rdcs) 465 { 466 CFGFILE *cfg; 467 rdcconfig_t *rdcp; 468 char *buf; 469 470 471 buf = calloc(CFG_MAX_BUF, sizeof (char)); 472 if (!buf) { 473 rdc_set_error(NULL, RDC_OS, RDC_FATAL, NULL); 474 return (NULL); 475 } 476 477 if ((cfg = cfg_open(NULL)) == NULL) { 478 rdc_set_error(NULL, RDC_DSCFG, 0, 0); 479 return (-1); 480 } 481 if ((cfg_lock(cfg, CFG_WRLOCK)) < 0) { 482 rdc_set_error(NULL, RDC_DSCFG, 0, 0); 483 return (-1); 484 } 485 486 rdcp = rdcs; 487 while (rdcp) { 488 buf = config2buf(buf, rdcp); 489 if ((sv_enable(cfg, rdcp) < 0) || 490 (cfg_put_cstring(cfg, "sndr", buf, CFG_MAX_BUF) < 0)) { 491 rdc_set_error(NULL, RDC_DSCFG, 0, 0); 492 free(buf); 493 return (-1); 494 } 495 rdcp = rdcp->next; 496 } 497 if (!cfg_commit(cfg)) { 498 rdc_set_error(NULL, RDC_DSCFG, 0, NULL); 499 return (-1); 500 } 501 502 cfg_close(cfg); 503 504 return (0); 505 } 506 507 int 508 cfg_lookup(CFGFILE *cfg, char *shost, char *sfile) 509 { 510 char buf[CFG_MAX_BUF]; 511 char key[CFG_MAX_KEY]; 512 int setnum; 513 int numsets = 0; 514 515 numsets = cfg_get_num_entries(cfg, "sndr"); 516 for (setnum = 1; setnum <= numsets; setnum++) { 517 bzero(key, CFG_MAX_KEY); 518 snprintf(key, CFG_MAX_KEY, "sndr.set%d.shost", setnum); 519 if (cfg_get_cstring(cfg, key, buf, CFG_MAX_BUF) < 0) { 520 rdc_set_error(NULL, RDC_DSCFG, 0, 0); 521 return (-1); 522 } 523 if (strncmp(buf, shost, strlen(shost))) 524 continue; 525 526 bzero(key, CFG_MAX_KEY); 527 snprintf(key, CFG_MAX_KEY, "sndr.set%d.secondary", setnum); 528 if (cfg_get_cstring(cfg, key, buf, CFG_MAX_BUF) < 0) { 529 rdc_set_error(NULL, RDC_DSCFG, 0, 0); 530 return (-1); 531 } 532 if (strncmp(buf, sfile, strlen(sfile))) 533 continue; 534 break; 535 } 536 return (setnum); 537 } 538 539 void 540 remove_from_rdc_cfg(rdcconfig_t *rdcs) 541 { 542 CFGFILE *cfg; 543 rdcconfig_t *rdcp; 544 char key[CFG_MAX_KEY]; 545 546 rdcp = rdcs; 547 cfg = cfg_open(NULL); 548 cfg_lock(cfg, CFG_WRLOCK); 549 550 while (rdcp) { 551 snprintf(key, CFG_MAX_KEY, "sndr.set%d", 552 cfg_lookup(cfg, rdcp->shost, rdcp->sfile)); 553 if ((sv_disable(cfg, rdcp) < 0) || 554 (cfg_put_cstring(cfg, key, NULL, 0)) < 0) { 555 rdc_set_error(NULL, RDC_DSCFG, 0, 0); 556 } 557 558 rdcp = rdcp->next; 559 } 560 cfg_commit(cfg); 561 cfg_close(cfg); 562 } 563 /*ARGSUSED*/ 564 int 565 replace_entry(int offset, char *entry) 566 { 567 return (1); 568 } 569 570 /* 571 * this will set the value at "field" in dscfg to the 572 * value contained in entry. 573 * for things like bitmap reconfigs, only pass one rdc 574 * not a chain 575 */ 576 int 577 replace_cfgfield(rdcconfig_t *rdc, char *field, char *entry) 578 { 579 CFGFILE *cfg; 580 rdcconfig_t *rdcp; 581 char key[CFG_MAX_KEY]; 582 char newentry[CFG_MAX_BUF]; 583 char oldbmp[CFG_MAX_BUF]; 584 int setnum; 585 int ispbmp = 0; 586 int issbmp = 0; 587 588 if (strncmp(field, "pbitmap", NSC_MAXPATH) == 0) 589 ispbmp++; 590 if (strncmp(field, "sbitmap", NSC_MAXPATH) == 0) 591 issbmp++; 592 593 bzero(newentry, sizeof (newentry)); 594 if (!entry || strlen(entry) == 0) 595 *newentry = '-'; 596 else 597 strncpy(newentry, entry, CFG_MAX_BUF); 598 599 600 if ((cfg = cfg_open(NULL)) == NULL) { 601 rdc_set_error(NULL, RDC_DSCFG, 0, 0); 602 return (-1); 603 } 604 if ((cfg_lock(cfg, CFG_WRLOCK)) < 0) { 605 rdc_set_error(NULL, RDC_DSCFG, 0, 0); 606 return (-1); 607 } 608 609 rdcp = rdc; 610 while (rdcp) { 611 if ((setnum = cfg_lookup(cfg, rdcp->shost, rdcp->sfile)) < 0) { 612 rdc_set_error(NULL, RDC_DSCFG, 0, 0); 613 return (-1); 614 } 615 snprintf(key, CFG_MAX_KEY, "sndr.set%d.%s", setnum, field); 616 if (!((ispbmp || issbmp) && 617 (cfg_get_cstring(cfg, key, oldbmp, CFG_MAX_BUF)) == 0)) { 618 rdc_set_error(NULL, RDC_DSCFG, 0, "unable to get %s", 619 key); 620 } 621 if (((ispbmp && self_check(rdcp->phost)) || 622 (issbmp && self_check(rdcp->shost))) && 623 (sv_reconfig(cfg, rdcp, oldbmp, newentry) < 0)) { 624 rdc_set_error(NULL, RDC_INTERNAL, RDC_NONFATAL, 625 "unable to sv reconfig %s to %s", oldbmp, newentry); 626 return (-1); 627 } 628 629 if ((cfg_put_cstring(cfg, key, newentry, CFG_MAX_BUF)) < 0) { 630 rdc_set_error(NULL, RDC_DSCFG, 0, 0); 631 return (-1); 632 } 633 rdcp = rdcp->next; 634 } 635 cfg_commit(cfg); 636 cfg_close(cfg); 637 return (1); 638 } 639 640 /* 641 * reverse_in_cfg 642 * used by RDC_OPT_REVERSE_ROLE 643 * swaps primary info and secondary info 644 */ 645 int 646 reverse_in_cfg(rdcconfig_t *rdc) 647 { 648 CFGFILE *cfg; 649 rdcconfig_t *rdcp = NULL; 650 char key[CFG_MAX_KEY]; 651 int setnum; 652 653 if ((cfg = cfg_open(NULL)) == NULL) { 654 rdc_set_error(NULL, RDC_DSCFG, 0, 0); 655 return (-1); 656 } 657 if ((cfg_lock(cfg, CFG_WRLOCK)) < 0) { 658 rdc_set_error(NULL, RDC_DSCFG, 0, 0); 659 return (-1); 660 } 661 662 rdcp = rdc; 663 while (rdcp) { 664 if ((setnum = cfg_lookup(cfg, rdcp->shost, rdcp->sfile)) < 0) { 665 rdc_set_error(NULL, RDC_DSCFG, 0, 0); 666 goto badconfig; 667 } 668 bzero(key, CFG_MAX_KEY); 669 snprintf(key, CFG_MAX_KEY, "sndr.set%d.phost", setnum); 670 if ((cfg_put_cstring(cfg, key, rdcp->shost, CFG_MAX_BUF)) < 0) { 671 rdc_set_error(NULL, RDC_DSCFG, 0, 0); 672 goto badconfig; 673 } 674 bzero(key, CFG_MAX_KEY); 675 snprintf(key, CFG_MAX_KEY, "sndr.set%d.primary", setnum); 676 if ((cfg_put_cstring(cfg, key, rdcp->sfile, CFG_MAX_BUF)) < 0) { 677 rdc_set_error(NULL, RDC_DSCFG, 0, 0); 678 goto badconfig; 679 } 680 bzero(key, CFG_MAX_KEY); 681 snprintf(key, CFG_MAX_KEY, "sndr.set%d.pbitmap", setnum); 682 if ((cfg_put_cstring(cfg, key, rdcp->sbmp, CFG_MAX_BUF)) < 0) { 683 rdc_set_error(NULL, RDC_DSCFG, 0, 0); 684 goto badconfig; 685 } 686 bzero(key, CFG_MAX_KEY); 687 snprintf(key, CFG_MAX_KEY, "sndr.set%d.shost", setnum); 688 if ((cfg_put_cstring(cfg, key, rdcp->phost, CFG_MAX_BUF)) < 0) { 689 rdc_set_error(NULL, RDC_DSCFG, 0, 0); 690 goto badconfig; 691 } 692 bzero(key, CFG_MAX_KEY); 693 snprintf(key, CFG_MAX_KEY, "sndr.set%d.secondary", setnum); 694 if ((cfg_put_cstring(cfg, key, rdcp->pfile, CFG_MAX_BUF)) < 0) { 695 rdc_set_error(NULL, RDC_DSCFG, 0, 0); 696 goto badconfig; 697 } 698 bzero(key, CFG_MAX_KEY); 699 snprintf(key, CFG_MAX_KEY, "sndr.set%d.sbitmap", setnum); 700 if ((cfg_put_cstring(cfg, key, rdcp->pbmp, CFG_MAX_BUF)) < 0) { 701 rdc_set_error(NULL, RDC_DSCFG, 0, 0); 702 goto badconfig; 703 } 704 rdcp = rdcp->next; 705 } 706 if (!cfg_commit(cfg)) { 707 cfg_close(cfg); 708 return (-1); 709 } 710 cfg_close(cfg); 711 return (0); 712 713 badconfig: 714 cfg_close(cfg); 715 return (-1); 716 } 717