usr/src/lib/librdc/common/rdcpersist.c

   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 }