usr/src/cmd/avs/rdc/sndrsubr.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 /*
  23  * Copyright 2010 Sun Microsystems, Inc.  All rights reserved.
  24  * Use is subject to license terms.
  25  */
  26
  27 #include <sys/types.h>
  28 #include <stdio.h>
  29 #include <sys/mnttab.h>
  30 #include <errno.h>
  31 #include <limits.h>
  32 #include <fcntl.h>
  33 #include <strings.h>
  34 #include <stdlib.h>
  35 #include <unistd.h>
  36 #include <sys/stat.h>
  37 #include <signal.h>
  38
  39 #include <locale.h>
  40 #include <langinfo.h>
  41 #include <libintl.h>
  42 #include <stdarg.h>
  43 #include <sys/nsctl/rdc_io.h>
  44 #include <sys/nsctl/rdc_ioctl.h>
  45 #include <sys/nsctl/rdc_prot.h>
  46
  47 #include <sys/nsctl/cfg.h>
  48
  49 #include <sys/unistat/spcs_s.h>
  50 #include <sys/unistat/spcs_s_u.h>
  51 #include <sys/unistat/spcs_errors.h>
  52
  53 #include "rdcadm.h"
  54
  55
  56 int maxqfbas = MAXQFBAS;
  57 int maxqitems = MAXQITEMS;
  58 int autosync = AUTOSYNC;
  59 int asyncthr = ASYNCTHR;
  60 int qblock = QBLOCK;
  61
  62 int
  63 mounted(char *device)
  64 {
  65         char target[NSC_MAXPATH];
  66         struct mnttab mntref;
  67         struct mnttab mntent;
  68         FILE *mntfp;
  69         int rdsk;
  70         char *s;
  71         int i;
  72
  73         rdsk = i = 0;
  74         for (s = target; i < NSC_MAXPATH && (*s = *device++); i++) {
  75                 if (*s == 'r' && rdsk == 0 && strncmp(device, "dsk/", 4) == 0)
  76                         rdsk = 1;
  77                 else
  78                         s++;
  79         }
  80         *s = '\0';
  81
  82         mntref.mnt_special = target;
  83         mntref.mnt_mountp = NULL;
  84         mntref.mnt_fstype = NULL;
  85         mntref.mnt_mntopts = NULL;
  86         mntref.mnt_time = NULL;
  87
  88         mntfp = fopen(MNTTAB, "r");
  89
  90         if (mntfp == NULL) {
  91                 rdc_warn(NULL,
  92                         gettext("can not check volume %s against mount table"),
  93                         mntref.mnt_special);
  94                 /* Assume the worst, that it is mounted */
  95                 return (1);
  96         }
  97
  98         if (getmntany(mntfp, &mntent, &mntref) != -1) {
  99                 /* found something before EOF */
 100                 (void) fclose(mntfp);
 101                 return (1);
 102         }
 103
 104         (void) fclose(mntfp);
 105         return (0);
 106 }
 107
 108
 109 /* Needs to match parsing code in rdcboot.c and rdcadm.c */
 110 char *
 111 rdc_decode_flag(int flag, int options)
 112 {
 113         static char str[32];
 114
 115         switch (flag) {
 116         case (RDC_CMD_COPY):
 117                 if (options & RDC_OPT_FULL)
 118                         (void) strcpy(str, "-m");
 119                 else
 120                         (void) strcpy(str, "-u");
 121                 if (options & RDC_OPT_REVERSE)
 122                         (void) strcat(str, " -r");
 123                 break;
 124
 125         case (RDC_CMD_DISABLE):
 126                 (void) strcpy(str, "-d");
 127                 break;
 128
 129         case (RDC_CMD_ENABLE):
 130                 if (options & RDC_OPT_SETBMP)
 131                         (void) strcpy(str, "-e");
 132                 else
 133                         (void) strcpy(str, "-E");
 134                 break;
 135
 136         case (RDC_CMD_LOG):
 137                 (void) strcpy(str, "-l");
 138                 break;
 139
 140         case (RDC_CMD_HEALTH):
 141                 (void) strcpy(str, "-H");
 142                 break;
 143
 144         case (RDC_CMD_WAIT):
 145                 (void) strcpy(str, "-w");
 146                 break;
 147
 148         case (RDC_CMD_RECONFIG):
 149                 (void) strcpy(str, "-R ...");
 150                 break;
 151
 152         case (RDC_CMD_TUNABLE):
 153                 (void) strcpy(str, "");
 154                 if (maxqfbas != MAXQFBAS)
 155                         (void) strcat(str, " -F");
 156                 if (maxqitems != MAXQITEMS)
 157                         (void) strcat(str, " -W");
 158                 if (autosync != AUTOSYNC)
 159                         (void) strcat(str, " -a");
 160                 if (asyncthr != ASYNCTHR)
 161                         (void) strcat(str, " -A");
 162                 if (qblock != QBLOCK)
 163                         (void) strcat(str, " -D");
 164                 break;
 165
 166         case (RDC_CMD_SUSPEND):
 167                 (void) strcpy(str, "-s");
 168                 break;
 169
 170         case (RDC_CMD_RESUME):
 171                 (void) strcpy(str, "-r");
 172                 break;
 173
 174         case (RDC_CMD_RESET):
 175                 (void) strcpy(str, "-R");
 176                 break;
 177
 178         case (RDC_CMD_ADDQ):
 179                 (void) strcpy(str, "-q a");
 180                 break;
 181
 182         case (RDC_CMD_REMQ):
 183                 (void) strcpy(str, "-q d");
 184                 break;
 185
 186         case (RDC_CMD_REPQ):
 187                 (void) strcpy(str, "-q r");
 188                 break;
 189
 190         default:
 191                 (void) strcpy(str, gettext("unknown"));
 192                 break;
 193         }
 194
 195         return (str);
 196 }
 197
 198
 199 static void
 200 rdc_msg(char *prefix, spcs_s_info_t *status, char *string, va_list ap)
 201 {
 202         if (status) {
 203                 (void) fprintf(stderr, "Remote Mirror: %s\n", prefix);
 204                 spcs_s_report(*status, stderr);
 205         } else {
 206                 (void) fprintf(stderr, "%s: %s: ", program, prefix);
 207         }
 208
 209         if (string && *string != '\0') {
 210                 (void) vfprintf(stderr, string, ap);
 211         }
 212
 213         (void) fprintf(stderr, "\n");
 214 }
 215
 216 void
 217 rdc_err(spcs_s_info_t *status, char *string, ...)
 218 {
 219         va_list ap;
 220         va_start(ap, string);
 221
 222         rdc_msg(gettext("Error"), status, string, ap);
 223
 224         va_end(ap);
 225         exit(1);
 226 }
 227
 228 void
 229 rdc_warn(spcs_s_info_t *status, char *string, ...)
 230 {
 231         va_list ap;
 232         va_start(ap, string);
 233
 234         rdc_msg(gettext("warning"), status, string, ap);
 235
 236         va_end(ap);
 237 }
 238
 239 int
 240 rdc_get_maxsets(void)
 241 {
 242         rdc_status_t rdc_status;
 243         spcs_s_info_t ustatus;
 244         int rc;
 245
 246         rdc_status.nset = 0;
 247         ustatus = spcs_s_ucreate();
 248
 249         rc = RDC_IOCTL(RDC_STATUS, &rdc_status, 0, 0, 0, 0, ustatus);
 250         if (rc == SPCS_S_ERROR) {
 251                 rdc_err(&ustatus, gettext("statistics error"));
 252         }
 253
 254         spcs_s_ufree(&ustatus);
 255         return (rdc_status.maxsets);
 256 }
 257
 258 /*
 259  * Look up a set in libcfg to find the setnumber.
 260  *
 261  * ASSUMPTIONS:
 262  *      - a valid cfg handle
 263  *
 264  * INPUTS:
 265  *      cfg - cfg handle
 266  *      tohost - secondary hostname
 267  *      tofile - secondary volume
 268  *
 269  * OUTPUTS:
 270  *      set number if found, otherwise -1 for an error
 271  */
 272 int
 273 find_setnumber_in_libcfg(CFGFILE *cfg, char *ctag, char *tohost, char *tofile)
 274 {
 275         int setnumber;
 276         int entries, rc;
 277         char *buf, *secondary, *shost;
 278         char **entry;
 279         char *cnode;
 280         int offset = 0;
 281
 282         if (cfg == NULL) {
 283 #ifdef DEBUG
 284                 rdc_warn(NULL, "cfg is NULL while looking up set number");
 285 #endif
 286                 return (-1);
 287         }
 288
 289         entries = cfg_get_section(cfg, &entry, "sndr");
 290
 291         rc = -1;
 292         for (setnumber = 1; setnumber <= entries; setnumber++) {
 293                 buf = entry[setnumber - 1];
 294
 295                 (void) strtok(buf, " ");        /* phost */
 296                 (void) strtok(NULL, " ");       /* primary */
 297                 (void) strtok(NULL, " ");       /* pbitmap */
 298                 shost = strtok(NULL, " ");
 299                 secondary = strtok(NULL, " ");
 300
 301                 if (ctag && *ctag) {
 302                         (void) strtok(NULL, " ");       /* sbitmap */
 303                         (void) strtok(NULL, " ");       /* type */
 304                         (void) strtok(NULL, " ");       /* mode */
 305                         (void) strtok(NULL, " ");       /* group */
 306                         cnode = strtok(NULL, " ");
 307
 308                         if (ctag && strcmp(cnode, ctag) != 0) {
 309                                 /* filter this out */
 310                                 ++offset;
 311                                 continue;
 312                         }
 313                 }
 314
 315                 /* Check secondary volume name first, will get less hits */
 316                 if (strcmp(secondary, tofile) != 0) {
 317                         free(buf);
 318                         continue;
 319                 }
 320
 321                 if (strcmp(shost, tohost) == 0) {
 322                         free(buf);
 323                         rc = setnumber - offset;
 324                         break;
 325                 }
 326
 327                 free(buf);
 328         }
 329
 330         while (setnumber < entries)
 331                 free(entry[setnumber++]);
 332         if (entries)
 333                 free(entry);
 334
 335         return (rc);
 336 }
 337
 338 void
 339 get_group_diskq(CFGFILE *cfg, char *group, char *diskq)
 340 {
 341         int i;
 342         char key[CFG_MAX_KEY];
 343         char buf[CFG_MAX_BUF];
 344
 345         if (*group == '\0')
 346                 return;
 347         for (i = 1; ; i++) {
 348                 bzero(&key, sizeof (key));
 349                 bzero(&buf, sizeof (buf));
 350                 (void) sprintf(key, "sndr.set%d.group", i);
 351                 if (cfg_get_cstring(cfg, key, &buf, sizeof (buf)) < 0)
 352                         break;
 353                 if (strncmp(group, buf, sizeof (buf)) == 0) {
 354                         (void) sprintf(key, "sndr.set%d.diskq", i);
 355                         if (cfg_get_cstring(cfg, key, diskq, CFG_MAX_BUF) < 0) {
 356                                 rdc_warn(NULL, gettext("unable to retrieve "
 357                                     "group %s's disk queue"), group);
 358                         }
 359                 }
 360         }
 361 }
 362
 363 int
 364 get_cfg_setid(CFGFILE *cfg, char *ctag, char *tohost, char *tofile)
 365 {
 366         int setnum = 0;
 367         int close_cfg = 0;
 368         char key[CFG_MAX_KEY];
 369         char setid[64];
 370
 371         if (cfg == NULL) {
 372                 close_cfg = 1;
 373                 if ((cfg = cfg_open(NULL)) == NULL) {
 374                         return (-1); /* message printed by caller */
 375                 }
 376                 if (!cfg_lock(cfg, CFG_RDLOCK)) {
 377                         cfg_close(cfg);
 378                         return (-1);
 379                 }
 380         }
 381         setnum = find_setnumber_in_libcfg(cfg, ctag, tohost, tofile);
 382         if (setnum < 0)
 383                 return (setnum);
 384
 385         (void) snprintf(key, CFG_MAX_KEY, "sndr.set%d.options", setnum);
 386         if (cfg_get_single_option(cfg, CFG_SEC_CONF, key, "setid",
 387                     setid, sizeof (setid)) < 0) {
 388                 if (close_cfg)
 389                         cfg_close(cfg);
 390
 391                 spcs_log("sndr", NULL,
 392                     gettext("%s unable to get unique setid "
 393                     "for %s:%s"), program, tohost, tofile);
 394                 return (-1);
 395
 396         }
 397         if (close_cfg)
 398                 cfg_close(cfg);
 399
 400         return (atoi(setid));
 401
 402 }
 403
 404 int
 405 get_new_cfg_setid(CFGFILE *cfg)
 406 {
 407         int setid;
 408         char buf[CFG_MAX_BUF];
 409         char *ctag;
 410
 411         /* If in a Sun Cluster, SetIDs need to have a ctag */
 412         if ((ctag = cfg_get_resource(cfg)) != NULL) {
 413                 ctag = strdup(ctag);
 414                 cfg_resource(cfg, "setid-ctag");
 415         }
 416
 417         if (cfg_get_cstring(cfg, "setid.set1.value", buf, CFG_MAX_BUF) < 0) {
 418                 setid = 1;
 419                 if (cfg_put_cstring(cfg, "setid", "1", CFG_MAX_BUF) < 0) {
 420                         rdc_err(NULL, "Unable to store new setid");
 421                 }
 422         } else {
 423                 setid = atoi(buf);
 424                 setid++;
 425                 if (setid <= 0) {
 426                         setid = 1;
 427                 }
 428         }
 429
 430         bzero(&buf, CFG_MAX_BUF);
 431         (void) snprintf(buf, sizeof (buf), "%d", setid);
 432         if (cfg_put_cstring(cfg, "setid.set1.value", buf, CFG_MAX_BUF) < 0) {
 433                 rdc_err(NULL, "Unable to store new setid");
 434         }
 435
 436         /* Restore old ctag if in a Sun Cluster */
 437         if (ctag) {
 438                 cfg_resource(cfg, ctag);
 439                 free(ctag);
 440         }
 441
 442         return (setid);
 443 }
 444
 445 sigset_t origmask;
 446
 447 void
 448 block_sigs(void)
 449 {
 450         sigset_t allsigs;
 451
 452         (void) sigfillset(&allsigs);
 453         if (sigprocmask(SIG_BLOCK, &allsigs, &origmask) < 0)
 454                 rdc_warn(NULL, gettext("Unable to block signals"));
 455 }
 456
 457 void
 458 unblock_sigs(void)
 459 {
 460         if (sigprocmask(SIG_SETMASK, &origmask, NULL) < 0)
 461                 rdc_warn(NULL, gettext("Unable to unblock signals"));
 462
 463 }