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 /* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */ 27 /* All Rights Reserved */ 28 29 /* 30 * University Copyright- Copyright (c) 1982, 1986, 1988 31 * The Regents of the University of California 32 * All Rights Reserved 33 * 34 * University Acknowledgment- Portions of this document are derived from 35 * software developed by the University of California, Berkeley, and its 36 * contributors. 37 */ 38 39 /* 40 * Copyright 2017 Jason King. 41 */ 42 43 /* 44 * Swap administrative interface 45 * Used to add/delete/list swap devices. 46 */ 47 48 #include <sys/types.h> 49 #include <sys/dumpadm.h> 50 #include <string.h> 51 #include <stdio.h> 52 #include <stdlib.h> 53 #include <unistd.h> 54 #include <errno.h> 55 #include <sys/param.h> 56 #include <dirent.h> 57 #include <sys/swap.h> 58 #include <sys/sysmacros.h> 59 #include <sys/mkdev.h> 60 #include <sys/stat.h> 61 #include <sys/statvfs.h> 62 #include <sys/uadmin.h> 63 #include <vm/anon.h> 64 #include <fcntl.h> 65 #include <locale.h> 66 #include <libintl.h> 67 #include <libdiskmgt.h> 68 #include <sys/fs/zfs.h> 69 #include <libcmdutils.h> 70 #include <sys/debug.h> 71 72 #define LFLAG 0x01 /* swap -l (list swap devices) */ 73 #define DFLAG 0x02 /* swap -d (delete swap device) */ 74 #define AFLAG 0x04 /* swap -a (add swap device) */ 75 #define SFLAG 0x08 /* swap -s (swap info summary) */ 76 #define P1FLAG 0x10 /* swap -1 (swapadd pass1; do not modify dump device) */ 77 #define P2FLAG 0x20 /* swap -2 (swapadd pass2; do not modify dump device) */ 78 #define HFLAG 0x40 /* swap -h (size in human readable format) */ 79 #define KFLAG 0x80 /* swap -k (size in kilobytes) */ 80 81 #define NUMBER_WIDTH 64 82 /* make sure nicenum_scale() has enough space */ 83 CTASSERT(NUMBER_WIDTH >= NN_NUMBUF_SZ); 84 typedef char numbuf_t[NUMBER_WIDTH]; 85 86 static char *prognamep; 87 88 static int add(char *, off_t, off_t, int); 89 static int delete(char *, off_t); 90 static void usage(void); 91 static int doswap(int flag); 92 static int valid(char *, off_t, off_t); 93 static int list(int flag); 94 95 int 96 main(int argc, char **argv) 97 { 98 int c, flag = 0; 99 int ret; 100 int error = 0; 101 off_t s_offset = 0; 102 off_t length = 0; 103 char *pathname; 104 char *msg; 105 106 (void) setlocale(LC_ALL, ""); 107 108 #if !defined(TEXT_DOMAIN) 109 #define TEXT_DOMAIN "SYS_TEST" 110 #endif 111 (void) textdomain(TEXT_DOMAIN); 112 113 prognamep = argv[0]; 114 if (argc < 2) { 115 usage(); 116 exit(1); 117 } 118 119 while ((c = getopt(argc, argv, "khlsd:a:12")) != EOF) { 120 char *char_p; 121 switch (c) { 122 case 'l': /* list all the swap devices */ 123 flag |= LFLAG; 124 break; 125 case 's': 126 flag |= SFLAG; 127 break; 128 case 'd': 129 /* 130 * The argument for starting offset is optional. 131 * If no argument is specified, the entire swap file 132 * is added although this will fail if a non-zero 133 * starting offset was specified when added. 134 */ 135 if ((argc - optind) > 1 || flag != 0) { 136 usage(); 137 exit(1); 138 } 139 flag |= DFLAG; 140 pathname = optarg; 141 if (optind < argc) { 142 errno = 0; 143 s_offset = strtol(argv[optind++], &char_p, 10); 144 if (errno != 0 || *char_p != '\0') { 145 (void) fprintf(stderr, 146 gettext("error in [low block]\n")); 147 exit(1); 148 } 149 } 150 ret = delete(pathname, s_offset); 151 break; 152 153 case 'a': 154 /* 155 * The arguments for starting offset and number of 156 * blocks are optional. If only the starting offset 157 * is specified, all the blocks to the end of the swap 158 * file will be added. If no starting offset is 159 * specified, the entire swap file is assumed. 160 */ 161 if ((argc - optind) > 2 || 162 (flag & ~(P1FLAG | P2FLAG)) != 0) { 163 usage(); 164 exit(1); 165 } 166 if (*optarg != '/') { 167 (void) fprintf(stderr, 168 gettext("%s: path must be absolute\n"), 169 prognamep); 170 exit(1); 171 } 172 flag |= AFLAG; 173 pathname = optarg; 174 if (optind < argc) { 175 errno = 0; 176 s_offset = strtol(argv[optind++], &char_p, 10); 177 if (errno != 0 || *char_p != '\0') { 178 (void) fprintf(stderr, 179 gettext("error in [low block]\n")); 180 exit(1); 181 } 182 } 183 if (optind < argc) { 184 errno = 0; 185 length = strtol(argv[optind++], &char_p, 10); 186 if (errno != 0 || *char_p != '\0') { 187 (void) fprintf(stderr, 188 gettext("error in [nbr of blocks]\n")); 189 exit(1); 190 } 191 } 192 break; 193 case 'h': 194 flag |= HFLAG; 195 break; 196 197 case 'k': 198 flag |= KFLAG; 199 break; 200 201 case '1': 202 flag |= P1FLAG; 203 break; 204 205 case '2': 206 flag |= P2FLAG; 207 break; 208 209 case '?': 210 usage(); 211 exit(1); 212 } 213 } 214 215 if (flag & SFLAG) { 216 if (flag & ~SFLAG & ~HFLAG) { 217 /* 218 * The only option that can be used with -s is -h. 219 */ 220 usage(); 221 exit(1); 222 } 223 224 ret = doswap(flag); 225 226 } 227 228 if (flag & LFLAG) { 229 if (flag & ~KFLAG & ~HFLAG & ~LFLAG) { 230 usage(); 231 exit(1); 232 } 233 ret = list(flag); 234 } 235 236 /* 237 * do the add here. Check for in use prior to add. 238 * The values for length and offset are set above. 239 */ 240 if (flag & AFLAG) { 241 /* 242 * If device is in use for a swap device, print message 243 * and exit. 244 */ 245 if (dm_inuse(pathname, &msg, DM_WHO_SWAP, &error) || 246 error) { 247 if (error != 0) { 248 (void) fprintf(stderr, gettext("Error occurred" 249 " with device in use checking: %s\n"), 250 strerror(error)); 251 } else { 252 (void) fprintf(stderr, "%s", msg); 253 free(msg); 254 exit(1); 255 } 256 } 257 if ((ret = valid(pathname, 258 s_offset * 512, length * 512)) == 0) { 259 ret = add(pathname, s_offset, length, flag); 260 } 261 } 262 if (!(flag & ~HFLAG & ~KFLAG)) { 263 /* only -h and/or -k flag, or no flag */ 264 usage(); 265 exit(1); 266 } 267 return (ret); 268 } 269 270 271 static void 272 usage(void) 273 { 274 (void) fprintf(stderr, gettext("Usage:\t%s -l\n"), prognamep); 275 (void) fprintf(stderr, gettext("\tsub option :\n")); 276 (void) fprintf(stderr, gettext("\t\t-h : displays size in human " 277 "readable format\n")); 278 (void) fprintf(stderr, gettext("\t\t-k : displays size in KB\n")); 279 (void) fprintf(stderr, "\t%s -s\n", prognamep); 280 (void) fprintf(stderr, gettext("\tsub option :\n")); 281 (void) fprintf(stderr, gettext("\t\t-h : displays size in human " 282 "readable format rather than KB\n")); 283 (void) fprintf(stderr, gettext("\t%s -d <file name> [low block]\n"), 284 prognamep); 285 (void) fprintf(stderr, gettext("\t%s -a <file name> [low block]" 286 " [nbr of blocks]\n"), prognamep); 287 } 288 289 /* 290 * Implement: 291 * #define ctok(x) ((ctob(x))>>10) 292 * in a machine independent way. (Both assume a click > 1k) 293 */ 294 static size_t 295 ctok(pgcnt_t clicks) 296 { 297 static int factor = -1; 298 299 if (factor == -1) 300 factor = (int)(sysconf(_SC_PAGESIZE) >> 10); 301 return ((size_t)(clicks * factor)); 302 } 303 304 305 static int 306 doswap(int flag) 307 { 308 struct anoninfo ai; 309 pgcnt_t allocated, reserved, available; 310 numbuf_t numbuf; 311 312 /* 313 * max = total amount of swap space including physical memory 314 * ai.ani_max = MAX(anoninfo.ani_resv, anoninfo.ani_max) + 315 * availrmem - swapfs_minfree; 316 * ai.ani_free = amount of unallocated anonymous memory 317 * (ie. = resverved_unallocated + unreserved) 318 * ai.ani_free = anoninfo.ani_free + (availrmem - swapfs_minfree); 319 * ai.ani_resv = total amount of reserved anonymous memory 320 * ai.ani_resv = anoninfo.ani_resv; 321 * 322 * allocated = anon memory not free 323 * reserved = anon memory reserved but not allocated 324 * available = anon memory not reserved 325 */ 326 if (swapctl(SC_AINFO, &ai) == -1) { 327 perror(prognamep); 328 return (2); 329 } 330 331 allocated = ai.ani_max - ai.ani_free; 332 reserved = ai.ani_resv - allocated; 333 available = ai.ani_max - ai.ani_resv; 334 335 /* 336 * TRANSLATION_NOTE 337 * Translations (if any) of these keywords should match with 338 * translations (if any) of the swap.1M man page keywords for 339 * -s option: "allocated", "reserved", "used", "available" 340 */ 341 342 if (flag & HFLAG) { 343 int factor = (int)(sysconf(_SC_PAGESIZE)); 344 345 nicenum_scale(allocated, factor, numbuf, sizeof (numbuf), 0); 346 (void) printf(gettext("total: %s allocated + "), numbuf); 347 348 nicenum_scale(reserved, factor, numbuf, sizeof (numbuf), 0); 349 (void) printf(gettext("%s reserved = "), numbuf); 350 351 nicenum_scale(allocated + reserved, factor, numbuf, 352 sizeof (numbuf), 0); 353 (void) printf(gettext("%s used, "), numbuf); 354 355 nicenum_scale(available, factor, numbuf, sizeof (numbuf), 0); 356 (void) printf(gettext("%s available\n"), numbuf); 357 } else { 358 (void) printf(gettext("total: %luk bytes allocated + %luk" 359 " reserved = %luk used, %luk available\n"), 360 ctok(allocated), ctok(reserved), 361 ctok(reserved) + ctok(allocated), 362 ctok(available)); 363 } 364 365 return (0); 366 } 367 368 static int 369 list(int flag) 370 { 371 struct swaptable *st; 372 struct swapent *swapent; 373 int i; 374 struct stat64 statbuf; 375 char *path; 376 char fullpath[MAXPATHLEN+1]; 377 int num; 378 numbuf_t numbuf; 379 380 if ((num = swapctl(SC_GETNSWP, NULL)) == -1) { 381 perror(prognamep); 382 return (2); 383 } 384 if (num == 0) { 385 (void) fprintf(stderr, gettext("No swap devices configured\n")); 386 return (1); 387 } 388 389 if ((st = malloc(num * sizeof (swapent_t) + sizeof (int))) 390 == NULL) { 391 (void) fprintf(stderr, 392 gettext("Malloc failed. Please try later.\n")); 393 perror(prognamep); 394 return (2); 395 } 396 if ((path = malloc(num * MAXPATHLEN)) == NULL) { 397 (void) fprintf(stderr, 398 gettext("Malloc failed. Please try later.\n")); 399 perror(prognamep); 400 return (2); 401 } 402 swapent = st->swt_ent; 403 for (i = 0; i < num; i++, swapent++) { 404 swapent->ste_path = path; 405 path += MAXPATHLEN; 406 } 407 408 st->swt_n = num; 409 if ((num = swapctl(SC_LIST, st)) == -1) { 410 perror(prognamep); 411 return (2); 412 } 413 414 /* 415 * TRANSLATION_NOTE 416 * Following translations for "swap -l" should account for for 417 * alignment of header and output. 418 * The first translation is for the header. If the alignment 419 * of the header changes, change the next 5 formats as needed 420 * to make alignment of output agree with alignment of the header. 421 * The next four translations are four cases for printing the 422 * 1st & 2nd fields. 423 * The next translation is for printing the 3rd, 4th & 5th fields. 424 * 425 * Translations (if any) of the following keywords should match the 426 * translations (if any) of the swap.1M man page keywords for 427 * -l option: "swapfile", "dev", "swaplo", "blocks", "free" 428 */ 429 (void) printf( 430 gettext("swapfile dev swaplo blocks free\n")); 431 432 swapent = st->swt_ent; 433 for (i = 0; i < num; i++, swapent++) { 434 if (*swapent->ste_path != '/') 435 (void) snprintf(fullpath, sizeof (fullpath), 436 "/dev/%s", swapent->ste_path); 437 else 438 (void) snprintf(fullpath, sizeof (fullpath), 439 "%s", swapent->ste_path); 440 if (stat64(fullpath, &statbuf) < 0) 441 if (*swapent->ste_path != '/') 442 (void) printf(gettext("%-20s - "), 443 swapent->ste_path); 444 else 445 (void) printf(gettext("%-20s ?,? "), 446 fullpath); 447 else { 448 if (S_ISBLK(statbuf.st_mode) || 449 S_ISCHR(statbuf.st_mode)) { 450 (void) printf(gettext("%-19s %2lu,%-2lu"), 451 fullpath, 452 major(statbuf.st_rdev), 453 minor(statbuf.st_rdev)); 454 } else { 455 (void) printf(gettext("%-20s - "), fullpath); 456 } 457 } 458 { 459 int diskblks_per_page = 460 (int)(sysconf(_SC_PAGESIZE) >> DEV_BSHIFT); 461 if (flag & HFLAG) { 462 nicenum_scale(swapent->ste_start, DEV_BSIZE, numbuf, 463 sizeof (numbuf), 0); 464 (void) printf(gettext(" %8s"), numbuf); 465 466 nicenum_scale(swapent->ste_pages, DEV_BSIZE * 467 diskblks_per_page, numbuf, sizeof (numbuf), 0); 468 (void) printf(gettext(" %8s"), numbuf); 469 470 nicenum_scale(swapent->ste_free, DEV_BSIZE * 471 diskblks_per_page, numbuf, sizeof (numbuf), 0); 472 (void) printf(gettext(" %8s"), numbuf); 473 } else if (flag & KFLAG) { 474 (void) printf(gettext(" %7luK %7luK %7luK"), 475 swapent->ste_start * DEV_BSIZE / 1024, 476 swapent->ste_pages * diskblks_per_page * 477 DEV_BSIZE / 1024, 478 swapent->ste_free * diskblks_per_page * 479 DEV_BSIZE / 1024); 480 } else { 481 (void) printf(gettext(" %8lu %8lu %8lu"), 482 swapent->ste_start, 483 swapent->ste_pages * diskblks_per_page, 484 swapent->ste_free * diskblks_per_page); 485 } 486 } 487 if (swapent->ste_flags & ST_INDEL) 488 (void) printf(" INDEL\n"); 489 else 490 (void) printf("\n"); 491 } 492 return (0); 493 } 494 495 static void 496 dumpadm_err(const char *warning) 497 { 498 (void) fprintf(stderr, "%s (%s):\n", warning, strerror(errno)); 499 (void) fprintf(stderr, gettext( 500 "run dumpadm(1M) to verify dump configuration\n")); 501 } 502 503 static int 504 delete(char *path, off_t offset) 505 { 506 swapres_t swr; 507 int fd; 508 509 swr.sr_name = path; 510 swr.sr_start = offset; 511 512 if (swapctl(SC_REMOVE, &swr) < 0) { 513 switch (errno) { 514 case (ENOSYS): 515 (void) fprintf(stderr, gettext( 516 "%s: Invalid operation for this filesystem type\n"), 517 path); 518 break; 519 default: 520 perror(path); 521 break; 522 } 523 return (2); 524 } 525 526 /* 527 * If our swap -d succeeded, open up /dev/dump and ask what the dump 528 * device is set to. If this returns ENODEV, we just deleted the 529 * dump device, so try to change the dump device to another swap 530 * device. We do this by firing up /usr/sbin/dumpadm -ud swap. 531 */ 532 if ((fd = open("/dev/dump", O_RDONLY)) >= 0) { 533 char dumpdev[MAXPATHLEN]; 534 535 if (ioctl(fd, DIOCGETDEV, dumpdev) == -1) { 536 if (errno == ENODEV) { 537 (void) printf(gettext("%s was dump device --\n" 538 "invoking dumpadm(1M) -d swap to " 539 "select new dump device\n"), path); 540 /* 541 * Close /dev/dump prior to executing dumpadm 542 * since /dev/dump mandates exclusive open. 543 */ 544 (void) close(fd); 545 546 if (system("/usr/sbin/dumpadm -ud swap") == -1) 547 dumpadm_err(gettext( 548 "Warning: failed to execute dumpadm -d swap")); 549 } else 550 dumpadm_err(gettext( 551 "Warning: failed to check dump device")); 552 } 553 (void) close(fd); 554 } else 555 dumpadm_err(gettext("Warning: failed to open /dev/dump")); 556 557 return (0); 558 } 559 560 /* 561 * swapres_t structure units are in 512-blocks 562 */ 563 static int 564 add(char *path, off_t offset, off_t cnt, int flags) 565 { 566 swapres_t swr; 567 568 int fd, have_dumpdev = 1; 569 struct statvfs fsb; 570 571 /* 572 * Before adding swap, we first check to see if we have a dump 573 * device configured. If we don't (errno == ENODEV), and if 574 * our SC_ADD is successful, then run /usr/sbin/dumpadm -ud swap 575 * to attempt to reconfigure the dump device to the new swap. 576 */ 577 if ((fd = open("/dev/dump", O_RDONLY)) >= 0) { 578 char dumpdev[MAXPATHLEN]; 579 580 if (ioctl(fd, DIOCGETDEV, dumpdev) == -1) { 581 if (errno == ENODEV) 582 have_dumpdev = 0; 583 else 584 dumpadm_err(gettext( 585 "Warning: failed to check dump device")); 586 } 587 588 (void) close(fd); 589 590 /* 591 * zvols cannot act as both a swap device and dump device. 592 */ 593 if (strncmp(dumpdev, ZVOL_FULL_DEV_DIR, 594 strlen(ZVOL_FULL_DEV_DIR)) == 0) { 595 if (strcmp(dumpdev, path) == 0) { 596 (void) fprintf(stderr, gettext("%s: zvol " 597 "cannot be used as a swap device and a " 598 "dump device\n"), path); 599 return (2); 600 } 601 } 602 603 } else if (!(flags & P1FLAG)) 604 dumpadm_err(gettext("Warning: failed to open /dev/dump")); 605 606 swr.sr_name = path; 607 swr.sr_start = offset; 608 swr.sr_length = cnt; 609 610 if (swapctl(SC_ADD, &swr) < 0) { 611 switch (errno) { 612 case (ENOSYS): 613 (void) fprintf(stderr, gettext( 614 "%s: Invalid operation for this filesystem type\n"), 615 path); 616 break; 617 case (EEXIST): 618 (void) fprintf(stderr, gettext( 619 "%s: Overlapping swap files are not allowed\n"), 620 path); 621 break; 622 default: 623 perror(path); 624 break; 625 } 626 return (2); 627 } 628 629 /* 630 * If the swapctl worked and we don't have a dump device, and /etc 631 * is part of a writeable filesystem, then run dumpadm -ud swap. 632 * If /etc (presumably part of /) is still mounted read-only, then 633 * dumpadm will fail to write its config file, so there's no point 634 * running it now. This also avoids spurious messages during boot 635 * when the first swapadd takes place, at which point / is still ro. 636 * Similarly, if swapadd invoked us with -1 or -2 (but root is 637 * writeable), we don't want to modify the dump device because 638 * /etc/init.d/savecore has yet to execute; if we run dumpadm now 639 * we would lose the user's previous setting. 640 */ 641 if (!have_dumpdev && !(flags & (P1FLAG | P2FLAG)) && 642 statvfs("/etc", &fsb) == 0 && !(fsb.f_flag & ST_RDONLY)) { 643 644 (void) printf( 645 gettext("operating system crash dump was previously " 646 "disabled --\ninvoking dumpadm(1M) -d swap to select " 647 "new dump device\n")); 648 649 if (system("/usr/sbin/dumpadm -ud swap") == -1) 650 dumpadm_err(gettext( 651 "Warning: failed to execute dumpadm -d swap")); 652 } 653 654 return (0); 655 } 656 657 static int 658 valid(char *pathname, off_t offset, off_t length) 659 { 660 struct stat64 f; 661 struct statvfs64 fs; 662 off_t need; 663 664 if (stat64(pathname, &f) < 0 || statvfs64(pathname, &fs) < 0) { 665 (void) perror(pathname); 666 return (errno); 667 } 668 669 if (!((S_ISREG(f.st_mode) && (f.st_mode & S_ISVTX) == S_ISVTX) || 670 S_ISBLK(f.st_mode))) { 671 (void) fprintf(stderr, 672 gettext("\"%s\" is not valid for swapping.\n" 673 "It must be a block device or a regular file with the\n" 674 "\"save user text on execution\" bit set.\n"), 675 pathname); 676 return (EINVAL); 677 } 678 679 if (S_ISREG(f.st_mode)) { 680 if (length == 0) 681 length = (off_t)f.st_size; 682 683 /* 684 * "f.st_blocks < 8" because the first eight 685 * 512-byte sectors are always skipped 686 */ 687 688 if (f.st_size < (length - offset) || f.st_size == 0 || 689 f.st_size > MAXOFF_T || f.st_blocks < 8 || length < 0) { 690 (void) fprintf(stderr, gettext("%s: size is invalid\n"), 691 pathname); 692 return (EINVAL); 693 } 694 695 if (offset < 0) { 696 (void) fprintf(stderr, 697 gettext("%s: low block is invalid\n"), 698 pathname); 699 return (EINVAL); 700 } 701 702 need = roundup(length, fs.f_bsize) / DEV_BSIZE; 703 704 /* 705 * "need > f.st_blocks" to account for indirect blocks 706 * Note: 707 * This can be fooled by a file large enough to 708 * contain indirect blocks that also contains holes. 709 * However, we don't know (and don't want to know) 710 * about the underlying storage implementation. 711 * But, if it doesn't have at least this many blocks, 712 * there must be a hole. 713 */ 714 715 if (need > f.st_blocks) { 716 (void) fprintf(stderr, gettext( 717 "\"%s\" may contain holes - can't swap on it.\n"), 718 pathname); 719 return (EINVAL); 720 } 721 } 722 /* 723 * else, we cannot get st_size for S_ISBLK device and 724 * no meaningful checking can be done. 725 */ 726 727 return (0); 728 } 729