usr/src/lib/librdc/common/rdcrules.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/utsname.h>
  28 #include <sys/mdb_modapi.h>
  29 #include <stdio.h>
  30 #include <errno.h>
  31 #include <strings.h>
  32 #include <stdlib.h>
  33 #include <unistd.h>
  34 #include <netdb.h>
  35 #include <libintl.h>
  36 #include <sys/stream.h>
  37 #include <sys/socket.h>
  38 #include <sys/stat.h>
  39 #include <netinet/in.h>
  40 #include <arpa/inet.h>
  41 #include <ctype.h>
  42 #include <thread.h>
  43 #include <pthread.h>
  44
  45 #include <sys/unistat/spcs_s.h>
  46 #include <sys/unistat/spcs_s_u.h>
  47 #include <sys/unistat/spcs_s_impl.h>
  48 #include <sys/unistat/spcs_errors.h>
  49
  50 #include <sys/nsctl/rdc_io.h>
  51 #include <sys/nsctl/rdc_ioctl.h>
  52 #include <sys/nsctl/rdc_prot.h>
  53 #include <sys/nsctl/librdc.h>
  54 #include <sys/nsctl/rdcerr.h>
  55 #include <sys/nsctl/cfg.h>
  56
  57 #include <sys/unistat/spcs_dtrinkets.h>
  58 #include <sys/unistat/spcs_etrinkets.h>
  59
  60 #include <sys/socket.h>
  61 #include <sys/mnttab.h>
  62 #include <netinet/in.h>
  63 #include <arpa/inet.h>
  64 #include <netinet/tcp.h>
  65 #include <rpc/rpc_com.h>
  66 #include <rpc/rpc.h>
  67
  68 #define RDC_LOCAL_TAG   "local"
  69
  70 /*
  71  * bitmap_in_use
  72  * return 1 if in use
  73  * return 0 if not in use
  74  * return -1 on error
  75  */
  76
  77 int
  78 bitmap_in_use(int cmd, char *hostp, char *bmp)
  79 {
  80         int i, setnumber;
  81         CFGFILE *cfg;
  82         char host[CFG_MAX_BUF];
  83         char shost[CFG_MAX_BUF];
  84         char pri[CFG_MAX_BUF]; /* rdc primary vol */
  85         char sec[CFG_MAX_BUF]; /* rdc secondary vol */
  86         char sbm[CFG_MAX_BUF]; /* rdc secondary bitmap */
  87         char bit[CFG_MAX_BUF]; /* a bitmap */
  88         char mas[CFG_MAX_BUF]; /* II master */
  89         char sha[CFG_MAX_BUF]; /* II shadow */
  90         char mod[CFG_MAX_BUF]; /* II mode */
  91         char ovr[CFG_MAX_BUF]; /* II overflow */
  92         char buf[CFG_MAX_BUF];
  93         char key[CFG_MAX_KEY];
  94         int rc;
  95         int ret = 0;
  96
  97
  98         if ((cfg = cfg_open(NULL)) == NULL) {
  99                 rdc_set_error(NULL, RDC_DSCFG, 0, NULL);
 100                 return (-1);
 101         }
 102         if (!cfg_lock(cfg, CFG_RDLOCK)) {
 103                 rdc_set_error(NULL, RDC_DSCFG, 0, NULL);
 104                 cfg_close(cfg);
 105                 return (-1);
 106         }
 107
 108         /*
 109          * look into II config to see if this is being used elsewhere
 110          */
 111         /*CSTYLED*/
 112         for (i = 0; ; i++) {
 113                 setnumber = i + 1;
 114                 snprintf(key, sizeof (key), "ii.set%d", setnumber);
 115                 if (cfg_get_cstring(cfg, key, buf, CFG_MAX_BUF) < 0)
 116                         break;
 117
 118                 rc = sscanf(buf, "%s %s %s %s %s", mas, sha, bit, mod, ovr);
 119                 if (rc != 5) {
 120                         rdc_set_error(NULL, RDC_OS, 0, NULL);
 121                             ret = -1;
 122                             goto done;
 123                 }
 124
 125                 /*
 126                  * got master shadow bitmap, now compare
 127                  */
 128                 if ((strcmp(bmp, mas) == 0) ||
 129                     (strcmp(bmp, sha) == 0) ||
 130                     (strcmp(bmp, bit) == 0) ||
 131                     (strcmp(bmp, ovr) == 0)) {
 132                         rdc_set_error(NULL, RDC_INTERNAL, RDC_NONFATAL,
 133                             "bitmap %s is in use by"
 134                             "Point-in-Time Copy", bmp);
 135                         ret = 1;
 136                         goto done;
 137                 }
 138         }
 139         /*
 140          * and last but not least, make sure sndr is not using vol for anything
 141          */
 142         /*CSTYLED*/
 143         for (i = 0; ; i++) {
 144                 setnumber = i + 1;
 145                 snprintf(key, sizeof (key), "sndr.set%d", setnumber);
 146                 if (cfg_get_cstring(cfg, key, buf, CFG_MAX_BUF) < 0)
 147                         break;
 148                 /*
 149                  * I think this is quicker than
 150                  * having to double dip into the config
 151                  */
 152                 (void) sscanf(buf, "%s %s %s %s %s %s", host, pri, bit,
 153                     shost, sec, sbm);
 154                 if (cmd == RDC_CMD_ENABLE) {
 155                         if (self_check(host)) {
 156                                 if ((strcmp(bmp, pri) == 0) ||
 157                                     (strcmp(bmp, bit) == 0)) {
 158                                         rdc_set_error(NULL, RDC_INTERNAL,
 159                                             RDC_NONFATAL, dgettext("librdc",
 160                                             "bitmap %s is in use by %s"),
 161                                             bmp, RDC_NAME_DU_JOUR);
 162
 163
 164                                     ret = 1;
 165                                     goto done;
 166                                 }
 167                         } else {
 168                                 if ((strcmp(bmp, sec) == 0) ||
 169                                     (strcmp(bmp, sbm) == 0)) {
 170                                         rdc_set_error(NULL, RDC_INTERNAL,
 171                                             RDC_NONFATAL, dgettext("librdc",
 172                                             "bitmap %s is in use by %s"),
 173                                             bmp, RDC_NAME_DU_JOUR);
 174                                     ret = 1;
 175                                     goto done;
 176                                 }
 177                         }
 178                 } else if (cmd == RDC_CMD_RECONFIG) {
 179
 180                         /*
 181                          * read this logic 1000 times and consider
 182                          * multi homed, one to many, many to one (marketing)
 183                          * etc, etc, before changing
 184                          */
 185                         if (self_check(hostp)) {
 186                                 if (self_check(host)) {
 187                                         if ((strcmp(bmp, pri) == 0) ||
 188                                             (strcmp(bmp, bit) == 0)) {
 189                                                 rdc_set_error(NULL,
 190                                                     RDC_INTERNAL, RDC_NONFATAL,
 191                                                     dgettext("librdc", "bitmap"
 192                                                     " %s is in use by %s"),
 193                                                     bmp, RDC_NAME_DU_JOUR);
 194                                                 ret = 1;
 195                                                 goto done;
 196                                         }
 197                                 } else {
 198                                         if ((strcmp(hostp, shost) == 0) &&
 199                                             (strcmp(bmp, sec) == 0) ||
 200                                             (strcmp(bmp, sbm) == 0)) {
 201                                                 rdc_set_error(NULL,
 202                                                     RDC_INTERNAL, RDC_NONFATAL,
 203                                                     dgettext("librdc", "bitmap"
 204                                                     " %s is in use by %s"),
 205                                                     bmp, RDC_NAME_DU_JOUR);
 206                                                 ret = 1;
 207                                                 goto done;
 208                                         }
 209                                 }
 210                         } else { /* self_check(hostp) failed */
 211                                 if (self_check(host)) {
 212                                         if ((strcmp(shost, hostp) == 0) &&
 213                                             (strcmp(bmp, sec) == 0) ||
 214                                             (strcmp(bmp, sbm) == 0)) {
 215                                                 rdc_set_error(NULL,
 216                                                     RDC_INTERNAL, RDC_NONFATAL,
 217                                                     dgettext("librdc", "bitmap"
 218                                                     " %s is in use by %s"),
 219                                                     bmp, RDC_NAME_DU_JOUR);
 220                                                 ret = 1;
 221                                                 goto done;
 222                                         }
 223                                 } else {
 224                                         if ((strcmp(host, hostp) == 0) &&
 225                                             (strcmp(bmp, pri) == 0) ||
 226                                             (strcmp(bmp, bit) == 0)) {
 227                                                 rdc_set_error(NULL,
 228                                                     RDC_INTERNAL, RDC_NONFATAL,
 229                                                     dgettext("librdc", "bitmap"
 230                                                     " %s is in use by %s"),
 231                                                     bmp, RDC_NAME_DU_JOUR);
 232                                                 ret = 1;
 233                                                 goto done;
 234                                         }
 235                                 }
 236                         }
 237
 238                 }
 239
 240         }
 241 done:
 242         cfg_close(cfg);
 243         return (ret);
 244
 245 }
 246
 247 int
 248 check_dgislocal(char *dgname)
 249 {
 250         char *othernode;
 251         int rc;
 252
 253         /*
 254          * check where this disk service is mastered
 255          */
 256
 257         rc = cfg_dgname_islocal(dgname, &othernode);
 258         if (rc < 0) {
 259                 rdc_set_error(NULL, RDC_INTERNAL, RDC_NONFATAL,
 260                     gettext("unable to find "
 261                     "disk service, %s: %s"), dgname, strerror(errno));
 262                     return (-1);
 263         }
 264
 265         if (rc == 0) {
 266                 rdc_set_error(NULL, RDC_INTERNAL, RDC_NONFATAL,
 267                     gettext("disk service, %s, is "
 268                     "active on node \"%s\"\nPlease re-issue "
 269                     "the command on that node"), dgname, othernode);
 270                     return (-1);
 271         }
 272         return (DCMD_OK);
 273 }
 274
 275 int
 276 ctag_check(rdcconfig_t *rdc)
 277 {
 278         char *file_dgname;
 279         char *bmp_dgname;
 280         char *fromhost, *tohost;
 281         char *fromfile, *tofile;
 282         char *frombitmap, *tobitmap;
 283         char *localfile;
 284         char *ctag;
 285         char file_buf[MAX_RDC_HOST_SIZE];
 286         char bmp_buf[MAX_RDC_HOST_SIZE];
 287         int is_primary;
 288         int islocal = 0;
 289         struct hostent *hp;
 290         char fromname[MAXHOSTNAMELEN], toname[MAXHOSTNAMELEN];
 291
 292         fromhost = rdc->phost;
 293         fromfile = rdc->pfile;
 294         frombitmap = rdc->pbmp;
 295         tohost = rdc->shost;
 296         tofile = rdc->sfile;
 297         tobitmap = rdc->sbmp;
 298         ctag = rdc->ctag;
 299
 300         /*
 301          * Check for the special (local) cluster tag
 302          */
 303         if (!cfg_iscluster())
 304                 return (0);
 305
 306         if (ctag != NULL && strcmp(rdc->ctag, RDC_LOCAL_TAG) == 0) {
 307                 strcpy(rdc->ctag, "-");
 308                 islocal = TRUE;
 309         } else {
 310                 islocal = FALSE;
 311         }
 312
 313         hp = gethost_byname(fromhost);
 314         strncpy(fromname, hp->h_name, MAXHOSTNAMELEN);
 315         hp = gethost_byname(tohost);
 316         strncpy(toname, hp->h_name, MAXHOSTNAMELEN);
 317         if (!self_check(fromname) && !self_check(toname)) {
 318                 /*
 319                  * If we could get a list of logical hosts on this cluster
 320                  * then we could print something intelligent about where
 321                  * the volume is mastered. For now, just print some babble
 322                  * about the fact that we have no idea.
 323                  */
 324                         rdc_set_error(NULL, RDC_INTERNAL, RDC_NONFATAL,
 325                                 gettext("either %s:%s or %s:%s is not local"),
 326                                         fromhost, fromfile, tohost, tofile);
 327                         return (-1);
 328         }
 329
 330         is_primary = self_check(fromname);
 331
 332         /*
 333          * If implicit disk group name and no ctag specified by user,
 334          * we set the ctag to it.
 335          * If implicit disk group name, it must match any supplied ctag.
 336          */
 337         if (is_primary)
 338                 localfile = fromfile;
 339         else
 340                 localfile = tofile;
 341         file_dgname = cfg_dgname(localfile, file_buf, sizeof (file_buf));
 342         if (file_dgname != NULL && file_dgname[0] != '\0')
 343                 if (check_dgislocal(file_dgname) < 0) {
 344                         /* errors already set */
 345                         return (-1);
 346                 }
 347
 348         if (strlen(ctag) == 0 && file_dgname && strlen(file_dgname))
 349                 strncpy(ctag, file_dgname, MAX_RDC_HOST_SIZE);
 350
 351         /*
 352          * making an exception here for users giving the "local"tag
 353          * this overrides this error message. (rdc_islocal ! = 1)
 354          */
 355         if (strlen(ctag) != 0 && file_dgname && islocal != 1 &&
 356             strlen(file_dgname) != 0 &&
 357             strncmp(ctag, file_dgname, MAX_RDC_HOST_SIZE) != 0) {
 358                 rdc_set_error(NULL, RDC_INTERNAL, RDC_NONFATAL,
 359                     gettext("ctag \"%s\" does not "
 360                     "match disk group name \"%s\" of volume %s"), ctag,
 361                     file_dgname, localfile);
 362                 return (-1);
 363         }
 364         if ((file_dgname == NULL) || ((strlen(ctag) == 0) &&
 365             (strlen(file_dgname) == 0))) {
 366                 /*
 367                  * we must have a non-volume managed disk here
 368                  * so ask for a tag and get out
 369                  */
 370                 rdc_set_error(NULL, RDC_INTERNAL, RDC_NONFATAL,
 371                     gettext("volume \"%s\" is not part"
 372                     " of a disk group,\nplease specify resource ctag\n"),
 373                     localfile);
 374
 375         }
 376
 377         /*
 378          * Local bitmap must also have same ctag.
 379          */
 380         if (is_primary)
 381                 localfile = frombitmap;
 382         else
 383                 localfile = tobitmap;
 384         bmp_dgname = cfg_dgname(localfile, bmp_buf, sizeof (bmp_buf));
 385         if (bmp_dgname != NULL && bmp_dgname[0] != '\0')
 386                 if (check_dgislocal(bmp_dgname) < 0) {
 387                         /* error already set */
 388                         return (-1);
 389                 }
 390
 391         if (file_dgname && strlen(file_dgname) != 0) {
 392                 /* File is in a real disk group */
 393                 if ((bmp_dgname == NULL) || (strlen(bmp_dgname) == 0)) {
 394                         /* Bitmap is not in a real disk group */
 395                         rdc_set_error(NULL, RDC_INTERNAL, RDC_NONFATAL,
 396                             gettext("bitmap %s is not in disk group \"%s\""),
 397                             localfile, islocal < 1?file_dgname:ctag);
 398                         return (-1);
 399                 }
 400         }
 401         if (strlen(ctag) != 0 && bmp_dgname && islocal != 1 &&
 402             strlen(bmp_dgname) != 0 &&
 403             strncmp(ctag, bmp_dgname, MAX_RDC_HOST_SIZE) != 0) {
 404                 rdc_set_error(NULL, RDC_INTERNAL, RDC_NONFATAL,
 405                     gettext("ctag \"%s\" does not "
 406                     "match disk group name \"%s\" of bitmap %s"),
 407                     ctag, bmp_dgname, localfile);
 408                 return (-1);
 409         }
 410
 411         return (0);
 412 }
 413 int
 414 mounted(char *device)
 415 {
 416         char target[NSC_MAXPATH];
 417         struct mnttab mntref;
 418         struct mnttab mntent;
 419         FILE *mntfp;
 420         int rdsk;
 421         char *s;
 422         int rc;
 423         int i;
 424
 425         rdsk = i = 0;
 426         for (s = target; i < NSC_MAXPATH && (*s = *device++); i++) {
 427                 if (*s == 'r' && rdsk == 0 && strncmp(device, "dsk/", 4) == 0)
 428                         rdsk = 1;
 429                 else
 430                         s++;
 431         }
 432         *s = '\0';
 433
 434         mntref.mnt_special = target;
 435         mntref.mnt_mountp = NULL;
 436         mntref.mnt_fstype = NULL;
 437         mntref.mnt_mntopts = NULL;
 438         mntref.mnt_time = NULL;
 439
 440         mntfp = fopen(MNTTAB, "r");
 441
 442         if (mntfp == NULL) {
 443                 /* Assume the worst, that it is mounted */
 444                 return (1);
 445         }
 446
 447         if ((rc = getmntany(mntfp, &mntent, &mntref)) != -1) {
 448                 /* found something before EOF */
 449                 fclose(mntfp);
 450                 return (1);
 451         }
 452
 453         fclose(mntfp);
 454         return (0);
 455 }
 456
 457 int
 458 can_enable(rdcconfig_t *rdc)
 459 {
 460         struct stat stb;
 461
 462         if ((strcmp(rdc->pfile, rdc->pbmp) == 0) ||
 463             (strcmp(rdc->sfile, rdc->sbmp) == 0)) {
 464                 rdc_set_error(NULL, RDC_INTERNAL, RDC_NONFATAL,
 465                 dgettext("librdc", "volumes and bitmaps must not match"));
 466                 return (0);
 467         }
 468         if (ctag_check(rdc) < 0) {
 469                 /* rdc_error should already be set */
 470                 return (0);
 471         }
 472
 473         if (self_check(rdc->phost)) {
 474                 if (stat(rdc->pfile, &stb) != 0) {
 475                         rdc_set_error(NULL, RDC_OS, RDC_FATAL, NULL);
 476                         return (0);
 477                 }
 478                 if (!S_ISCHR(stb.st_mode)) {
 479                         rdc_set_error(NULL, RDC_INTERNAL, RDC_NONFATAL,
 480                             dgettext("librdc", "%s is not a character device"),
 481                             rdc->pfile);
 482                         return (0);
 483                 }
 484                 return (rdc->persist ?
 485                     !bitmap_in_use(RDC_CMD_ENABLE, rdc->phost, rdc->pbmp) : 1);
 486         } else { /* on the secondary */
 487                 if (stat(rdc->sfile, &stb) != 0) {
 488                         rdc_set_error(NULL, RDC_OS, 0,
 489                             dgettext("librdc", "unable to access %s: %s"),
 490                             rdc->sfile, strerror(errno));
 491                 }
 492                 if (!S_ISCHR(stb.st_mode)) {
 493                         rdc_set_error(NULL, RDC_INTERNAL, RDC_NONFATAL,
 494                             dgettext("librdc",
 495                             "%s is not a character device"), rdc->sfile);
 496                 }
 497                 return (rdc->persist ?
 498                     !bitmap_in_use(RDC_CMD_ENABLE, rdc->shost, rdc->sbmp) : 1);
 499         }
 500 }
 501
 502 int
 503 can_reconfig_pbmp(rdcconfig_t *rdc, char *bmp)
 504 {
 505         if (!rdc->persist)
 506                 return (0);
 507
 508         return (!bitmap_in_use(RDC_CMD_RECONFIG, rdc->phost, bmp));
 509 }
 510
 511 int
 512 can_reconfig_sbmp(rdcconfig_t *rdc, char *bmp)
 513 {
 514         if (!rdc->persist)
 515                 return (0);
 516
 517         return (!bitmap_in_use(RDC_CMD_RECONFIG, rdc->shost, bmp));
 518 }
 519
 520 rdc_rc_t *
 521 cant_rsync(rdcconfig_t *rdc)
 522 {
 523         rdc_rc_t *rc;
 524
 525         if (mounted(rdc->pfile)) {
 526                 rc = new_rc();
 527                 if (rc == NULL)
 528                         return (NULL);
 529                 strncpy(rc->set.phost, rdc->phost, MAX_RDC_HOST_SIZE);
 530                 strncpy(rc->set.pfile, rdc->pfile, NSC_MAXPATH);
 531                 strncpy(rc->set.pbmp, rdc->pbmp, NSC_MAXPATH);
 532                 strncpy(rc->set.shost, rdc->shost, MAX_RDC_HOST_SIZE);
 533                 strncpy(rc->set.sfile, rdc->sfile, NSC_MAXPATH);
 534                 strncpy(rc->set.sbmp, rdc->sbmp, NSC_MAXPATH);
 535
 536                 rc->rc = -1;
 537
 538                 rdc_set_error(NULL, RDC_INTERNAL, 0, "unable to sync %s volume"
 539                     " is currently mounted", rdc->pfile);
 540                 strncpy(rc->msg, rdc_error(NULL), RDC_ERR_SIZE);
 541
 542                 return (rc);
 543         }
 544         return (NULL);
 545 }