| 1 | /* vi: set sw=4 ts=4: */
|
|---|
| 2 | /*
|
|---|
| 3 | * mkswap.c - set up a linux swap device
|
|---|
| 4 | *
|
|---|
| 5 | * (C) 1991 Linus Torvalds. This file may be redistributed as per
|
|---|
| 6 | * the Linux copyright.
|
|---|
| 7 | */
|
|---|
| 8 |
|
|---|
| 9 | /*
|
|---|
| 10 | * 20.12.91 - time began. Got VM working yesterday by doing this by hand.
|
|---|
| 11 | *
|
|---|
| 12 | * Usage: mkswap [-c] [-vN] [-f] device [size-in-blocks]
|
|---|
| 13 | *
|
|---|
| 14 | * -c for readability checking. (Use it unless you are SURE!)
|
|---|
| 15 | * -vN for swap areas version N. (Only N=0,1 known today.)
|
|---|
| 16 | * -f for forcing swap creation even if it would smash partition table.
|
|---|
| 17 | *
|
|---|
| 18 | * The device may be a block device or an image of one, but this isn't
|
|---|
| 19 | * enforced (but it's not much fun on a character device :-).
|
|---|
| 20 | *
|
|---|
| 21 | * Patches from jaggy@purplet.demon.co.uk (Mike Jagdis) to make the
|
|---|
| 22 | * size-in-blocks parameter optional added Wed Feb 8 10:33:43 1995.
|
|---|
| 23 | *
|
|---|
| 24 | * Version 1 swap area code (for kernel 2.1.117), aeb, 981010.
|
|---|
| 25 | *
|
|---|
| 26 | * Sparc fixes, jj@ultra.linux.cz (Jakub Jelinek), 981201 - mangled by aeb.
|
|---|
| 27 | * V1_MAX_PAGES fixes, jj, 990325.
|
|---|
| 28 | *
|
|---|
| 29 | * 1999-02-22 Arkadiusz Mi¶kiewicz <misiek@misiek.eu.org>
|
|---|
| 30 | * - added Native Language Support
|
|---|
| 31 | *
|
|---|
| 32 | * from util-linux -- adapted for busybox by
|
|---|
| 33 | * Erik Andersen <andersen@codepoet.org>. I ripped out Native Language
|
|---|
| 34 | * Support, made some stuff smaller, and fitted for life in busybox.
|
|---|
| 35 | *
|
|---|
| 36 | */
|
|---|
| 37 |
|
|---|
| 38 | #include "busybox.h"
|
|---|
| 39 | #include <unistd.h>
|
|---|
| 40 | #include <string.h>
|
|---|
| 41 | #include <fcntl.h>
|
|---|
| 42 | #include <sys/ioctl.h> /* for _IO */
|
|---|
| 43 | #include <sys/utsname.h>
|
|---|
| 44 | #include <asm/page.h> /* for PAGE_SIZE and PAGE_SHIFT */
|
|---|
| 45 | /* we also get PAGE_SIZE via getpagesize() */
|
|---|
| 46 |
|
|---|
| 47 | static char *device_name = NULL;
|
|---|
| 48 | static int DEV = -1;
|
|---|
| 49 | static long PAGES = 0;
|
|---|
| 50 | static int check = 0;
|
|---|
| 51 | static int badpages = 0;
|
|---|
| 52 | #if ENABLE_FEATURE_MKSWAP_V0
|
|---|
| 53 | static int version = -1;
|
|---|
| 54 | #else
|
|---|
| 55 | #define version 1
|
|---|
| 56 | /* and make sure that we optimize away anything which would deal with checking
|
|---|
| 57 | * the kernel revision as we have v1 support only anyway.
|
|---|
| 58 | */
|
|---|
| 59 | #undef KERNEL_VERSION
|
|---|
| 60 | #define KERNEL_VERSION(p,q,r) 1
|
|---|
| 61 | #define get_linux_version_code() 1
|
|---|
| 62 | #endif
|
|---|
| 63 |
|
|---|
| 64 | /*
|
|---|
| 65 | * The definition of the union swap_header uses the constant PAGE_SIZE.
|
|---|
| 66 | * Unfortunately, on some architectures this depends on the hardware model,
|
|---|
| 67 | * and can only be found at run time -- we use getpagesize().
|
|---|
| 68 | */
|
|---|
| 69 |
|
|---|
| 70 | static int pagesize;
|
|---|
| 71 | static unsigned int *signature_page;
|
|---|
| 72 |
|
|---|
| 73 | static struct swap_header_v1 {
|
|---|
| 74 | char bootbits[1024]; /* Space for disklabel etc. */
|
|---|
| 75 | unsigned int swap_version;
|
|---|
| 76 | unsigned int last_page;
|
|---|
| 77 | unsigned int nr_badpages;
|
|---|
| 78 | unsigned int padding[125];
|
|---|
| 79 | unsigned int badpages[1];
|
|---|
| 80 | } *p;
|
|---|
| 81 |
|
|---|
| 82 | static inline void init_signature_page(void)
|
|---|
| 83 | {
|
|---|
| 84 | pagesize = getpagesize();
|
|---|
| 85 |
|
|---|
| 86 | #ifdef PAGE_SIZE
|
|---|
| 87 | if (pagesize != PAGE_SIZE)
|
|---|
| 88 | bb_error_msg("Assuming pages of size %d", pagesize);
|
|---|
| 89 | #endif
|
|---|
| 90 | signature_page = (unsigned int *) xmalloc(pagesize);
|
|---|
| 91 | memset(signature_page, 0, pagesize);
|
|---|
| 92 | p = (struct swap_header_v1 *) signature_page;
|
|---|
| 93 | }
|
|---|
| 94 |
|
|---|
| 95 | static inline void write_signature(char *sig)
|
|---|
| 96 | {
|
|---|
| 97 | char *sp = (char *) signature_page;
|
|---|
| 98 |
|
|---|
| 99 | strncpy(sp + pagesize - 10, sig, 10);
|
|---|
| 100 | }
|
|---|
| 101 |
|
|---|
| 102 | #define V0_MAX_PAGES (8 * (pagesize - 10))
|
|---|
| 103 | /* Before 2.2.0pre9 */
|
|---|
| 104 | #define V1_OLD_MAX_PAGES ((0x7fffffff / pagesize) - 1)
|
|---|
| 105 | /* Since 2.2.0pre9:
|
|---|
| 106 | error if nr of pages >= SWP_OFFSET(SWP_ENTRY(0,~0UL))
|
|---|
| 107 | with variations on
|
|---|
| 108 | #define SWP_ENTRY(type,offset) (((type) << 1) | ((offset) << 8))
|
|---|
| 109 | #define SWP_OFFSET(entry) ((entry) >> 8)
|
|---|
| 110 | on the various architectures. Below the result - yuk.
|
|---|
| 111 |
|
|---|
| 112 | Machine pagesize SWP_ENTRY SWP_OFFSET bound+1 oldbound+2
|
|---|
| 113 | i386 2^12 o<<8 e>>8 1<<24 1<<19
|
|---|
| 114 | mips 2^12 o<<15 e>>15 1<<17 1<<19
|
|---|
| 115 | alpha 2^13 o<<40 e>>40 1<<24 1<<18
|
|---|
| 116 | m68k 2^12 o<<12 e>>12 1<<20 1<<19
|
|---|
| 117 | sparc 2^{12,13} (o&0x3ffff)<<9 (e>>9)&0x3ffff 1<<18 1<<{19,18}
|
|---|
| 118 | sparc64 2^13 o<<13 e>>13 1<<51 1<<18
|
|---|
| 119 | ppc 2^12 o<<8 e>>8 1<<24 1<<19
|
|---|
| 120 | armo 2^{13,14,15} o<<8 e>>8 1<<24 1<<{18,17,16}
|
|---|
| 121 | armv 2^12 o<<9 e>>9 1<<23 1<<19
|
|---|
| 122 |
|
|---|
| 123 | assuming that longs have 64 bits on alpha and sparc64 and 32 bits elsewhere.
|
|---|
| 124 |
|
|---|
| 125 | The bad part is that we need to know this since the kernel will
|
|---|
| 126 | refuse a swap space if it is too large.
|
|---|
| 127 | */
|
|---|
| 128 | /* patch from jj - why does this differ from the above? */
|
|---|
| 129 | #if defined(__alpha__)
|
|---|
| 130 | #define V1_MAX_PAGES ((1 << 24) - 1)
|
|---|
| 131 | #elif defined(__mips__)
|
|---|
| 132 | #define V1_MAX_PAGES ((1 << 17) - 1)
|
|---|
| 133 | #elif defined(__sparc_v9__)
|
|---|
| 134 | #define V1_MAX_PAGES ((3 << 29) - 1)
|
|---|
| 135 | #elif defined(__sparc__)
|
|---|
| 136 | #define V1_MAX_PAGES (pagesize == 8192 ? ((3 << 29) - 1) : ((1 << 18) - 1))
|
|---|
| 137 | #else
|
|---|
| 138 | #define V1_MAX_PAGES V1_OLD_MAX_PAGES
|
|---|
| 139 | #endif
|
|---|
| 140 | /* man page now says:
|
|---|
| 141 | The maximum useful size of a swap area now depends on the architecture.
|
|---|
| 142 | It is roughly 2GB on i386, PPC, m68k, ARM, 1GB on sparc, 512MB on mips,
|
|---|
| 143 | 128GB on alpha and 3TB on sparc64.
|
|---|
| 144 | */
|
|---|
| 145 |
|
|---|
| 146 | #define MAX_BADPAGES ((pagesize-1024-128*sizeof(int)-10)/sizeof(int))
|
|---|
| 147 |
|
|---|
| 148 | static inline void bit_set(unsigned int *addr, unsigned int nr)
|
|---|
| 149 | {
|
|---|
| 150 | unsigned int r, m;
|
|---|
| 151 |
|
|---|
| 152 | addr += nr / (8 * sizeof(int));
|
|---|
| 153 |
|
|---|
| 154 | r = *addr;
|
|---|
| 155 | m = 1 << (nr & (8 * sizeof(int) - 1));
|
|---|
| 156 |
|
|---|
| 157 | *addr = r | m;
|
|---|
| 158 | }
|
|---|
| 159 |
|
|---|
| 160 | static int bit_test_and_clear(unsigned int *addr, unsigned int nr)
|
|---|
| 161 | {
|
|---|
| 162 | unsigned int r, m;
|
|---|
| 163 |
|
|---|
| 164 | addr += nr / (8 * sizeof(int));
|
|---|
| 165 |
|
|---|
| 166 | r = *addr;
|
|---|
| 167 | m = 1 << (nr & (8 * sizeof(int) - 1));
|
|---|
| 168 |
|
|---|
| 169 | *addr = r & ~m;
|
|---|
| 170 | return (r & m) != 0;
|
|---|
| 171 | }
|
|---|
| 172 |
|
|---|
| 173 | static void page_ok(int page)
|
|---|
| 174 | {
|
|---|
| 175 | if (ENABLE_FEATURE_MKSWAP_V0) {
|
|---|
| 176 | bit_set(signature_page, page);
|
|---|
| 177 | }
|
|---|
| 178 | }
|
|---|
| 179 |
|
|---|
| 180 | static void check_blocks(void)
|
|---|
| 181 | {
|
|---|
| 182 | unsigned int current_page;
|
|---|
| 183 | int do_seek = 1;
|
|---|
| 184 | char *buffer;
|
|---|
| 185 |
|
|---|
| 186 | buffer = xmalloc(pagesize);
|
|---|
| 187 | current_page = 0;
|
|---|
| 188 | while (current_page < PAGES) {
|
|---|
| 189 | if (!check && version == 0) {
|
|---|
| 190 | page_ok(current_page++);
|
|---|
| 191 | continue;
|
|---|
| 192 | }
|
|---|
| 193 | if (do_seek && lseek(DEV, current_page * pagesize, SEEK_SET) !=
|
|---|
| 194 | current_page * pagesize)
|
|---|
| 195 | bb_error_msg_and_die("seek failed in check_blocks");
|
|---|
| 196 | if ((do_seek = (pagesize != read(DEV, buffer, pagesize)))) {
|
|---|
| 197 | current_page++;
|
|---|
| 198 | if (version == 0)
|
|---|
| 199 | bit_test_and_clear(signature_page, current_page);
|
|---|
| 200 | else {
|
|---|
| 201 | if (badpages == MAX_BADPAGES)
|
|---|
| 202 | bb_error_msg_and_die("too many bad pages");
|
|---|
| 203 | p->badpages[badpages] = current_page;
|
|---|
| 204 | }
|
|---|
| 205 | badpages++;
|
|---|
| 206 | continue;
|
|---|
| 207 | }
|
|---|
| 208 | page_ok(current_page++);
|
|---|
| 209 | }
|
|---|
| 210 | if (ENABLE_FEATURE_CLEAN_UP)
|
|---|
| 211 | free(buffer);
|
|---|
| 212 | if (badpages > 0)
|
|---|
| 213 | printf("%d bad page%s\n", badpages, (badpages==1)?"":"s");
|
|---|
| 214 | }
|
|---|
| 215 |
|
|---|
| 216 | static long valid_offset(int fd, int offset)
|
|---|
| 217 | {
|
|---|
| 218 | char ch;
|
|---|
| 219 |
|
|---|
| 220 | if (lseek(fd, offset, 0) < 0)
|
|---|
| 221 | return 0;
|
|---|
| 222 | if (read(fd, &ch, 1) < 1)
|
|---|
| 223 | return 0;
|
|---|
| 224 | return 1;
|
|---|
| 225 | }
|
|---|
| 226 |
|
|---|
| 227 | static int find_size(int fd)
|
|---|
| 228 | {
|
|---|
| 229 | unsigned int high, low;
|
|---|
| 230 |
|
|---|
| 231 | low = 0;
|
|---|
| 232 | for (high = 1; high > 0 && valid_offset(fd, high); high *= 2)
|
|---|
| 233 | low = high;
|
|---|
| 234 | while (low < high - 1) {
|
|---|
| 235 | const int mid = (low + high) / 2;
|
|---|
| 236 |
|
|---|
| 237 | if (valid_offset(fd, mid))
|
|---|
| 238 | low = mid;
|
|---|
| 239 | else
|
|---|
| 240 | high = mid;
|
|---|
| 241 | }
|
|---|
| 242 | return (low + 1);
|
|---|
| 243 | }
|
|---|
| 244 |
|
|---|
| 245 | /* return size in pages, to avoid integer overflow */
|
|---|
| 246 | static inline long get_size(const char *file)
|
|---|
| 247 | {
|
|---|
| 248 | int fd;
|
|---|
| 249 | long size;
|
|---|
| 250 |
|
|---|
| 251 | fd = bb_xopen3(file, O_RDONLY, 0);
|
|---|
| 252 | if (ioctl(fd, BLKGETSIZE, &size) >= 0) {
|
|---|
| 253 | size /= pagesize / 512;
|
|---|
| 254 | } else {
|
|---|
| 255 | size = find_size(fd) / pagesize;
|
|---|
| 256 | }
|
|---|
| 257 | close(fd);
|
|---|
| 258 | return size;
|
|---|
| 259 | }
|
|---|
| 260 |
|
|---|
| 261 | int mkswap_main(int argc, char **argv)
|
|---|
| 262 | {
|
|---|
| 263 | char *tmp;
|
|---|
| 264 | struct stat statbuf;
|
|---|
| 265 | int sz;
|
|---|
| 266 | int maxpages;
|
|---|
| 267 | int goodpages;
|
|---|
| 268 | #ifdef __sparc__
|
|---|
| 269 | int force = 0;
|
|---|
| 270 | #endif
|
|---|
| 271 |
|
|---|
| 272 | init_signature_page(); /* get pagesize */
|
|---|
| 273 |
|
|---|
| 274 | bb_opt_complementally = "?"; /* call bb_show_usage internally */
|
|---|
| 275 | sz = bb_getopt_ulflags(argc, argv, "+cfv:", &tmp);
|
|---|
| 276 | if (sz & 1)
|
|---|
| 277 | check = 1;
|
|---|
| 278 | #ifdef __sparc__
|
|---|
| 279 | if (sz & 2)
|
|---|
| 280 | force = 1;
|
|---|
| 281 | #endif
|
|---|
| 282 | #if ENABLE_FEATURE_MKSWAP_V0
|
|---|
| 283 | if (sz & 4) {
|
|---|
| 284 | version = bb_xgetlarg(tmp, 10, 0, 1);
|
|---|
| 285 | } else {
|
|---|
| 286 | if (get_linux_version_code() < KERNEL_VERSION(2, 1, 117))
|
|---|
| 287 | version = 0;
|
|---|
| 288 | else
|
|---|
| 289 | version = 1;
|
|---|
| 290 | }
|
|---|
| 291 | #endif
|
|---|
| 292 |
|
|---|
| 293 | argv += optind;
|
|---|
| 294 | argc -= optind;
|
|---|
| 295 |
|
|---|
| 296 | goodpages = pagesize / 1024; /* cache division */
|
|---|
| 297 | while (argc--) {
|
|---|
| 298 | if (device_name) {
|
|---|
| 299 | PAGES = bb_xgetlarg(argv[0], 0, 10, sz * goodpages) / goodpages;
|
|---|
| 300 | argc = 0; /* ignore any surplus args.. */
|
|---|
| 301 | } else {
|
|---|
| 302 | device_name = argv[0];
|
|---|
| 303 | sz = get_size(device_name);
|
|---|
| 304 | argv++;
|
|---|
| 305 | }
|
|---|
| 306 | }
|
|---|
| 307 |
|
|---|
| 308 | if (!device_name) {
|
|---|
| 309 | bb_error_msg_and_die("error: Nowhere to set up swap on?");
|
|---|
| 310 | }
|
|---|
| 311 | if (!PAGES) {
|
|---|
| 312 | PAGES = sz;
|
|---|
| 313 | }
|
|---|
| 314 |
|
|---|
| 315 | #if 0
|
|---|
| 316 | maxpages = ((version == 0) ? V0_MAX_PAGES : V1_MAX_PAGES);
|
|---|
| 317 | #else
|
|---|
| 318 | if (!version)
|
|---|
| 319 | maxpages = V0_MAX_PAGES;
|
|---|
| 320 | else if (get_linux_version_code() >= KERNEL_VERSION(2,2,1))
|
|---|
| 321 | maxpages = V1_MAX_PAGES;
|
|---|
| 322 | else {
|
|---|
| 323 | maxpages = V1_OLD_MAX_PAGES;
|
|---|
| 324 | if (maxpages > V1_MAX_PAGES)
|
|---|
| 325 | maxpages = V1_MAX_PAGES;
|
|---|
| 326 | }
|
|---|
| 327 | #endif
|
|---|
| 328 | if (PAGES > maxpages) {
|
|---|
| 329 | PAGES = maxpages;
|
|---|
| 330 | bb_error_msg("warning: truncating swap area to %ldkB",
|
|---|
| 331 | PAGES * goodpages);
|
|---|
| 332 | }
|
|---|
| 333 |
|
|---|
| 334 | DEV = bb_xopen3(device_name, O_RDWR, 0);
|
|---|
| 335 | if (fstat(DEV, &statbuf) < 0)
|
|---|
| 336 | bb_perror_msg_and_die("%s", device_name);
|
|---|
| 337 | if (!S_ISBLK(statbuf.st_mode))
|
|---|
| 338 | check = 0;
|
|---|
| 339 | else if (statbuf.st_rdev == 0x0300 || statbuf.st_rdev == 0x0340)
|
|---|
| 340 | bb_error_msg_and_die("Will not try to make swapdevice on '%s'", device_name);
|
|---|
| 341 |
|
|---|
| 342 | #ifdef __sparc__
|
|---|
| 343 | if (!force && version == 0) {
|
|---|
| 344 | /* Don't overwrite partition table unless forced */
|
|---|
| 345 | unsigned char *buffer = (unsigned char *) signature_page;
|
|---|
| 346 | unsigned short *q, sum;
|
|---|
| 347 |
|
|---|
| 348 | if (read(DEV, buffer, 512) != 512)
|
|---|
| 349 | bb_error_msg_and_die("fatal: first page unreadable");
|
|---|
| 350 | if (buffer[508] == 0xDA && buffer[509] == 0xBE) {
|
|---|
| 351 | q = (unsigned short *) (buffer + 510);
|
|---|
| 352 | for (sum = 0; q >= (unsigned short *) buffer;)
|
|---|
| 353 | sum ^= *q--;
|
|---|
| 354 | if (!sum) {
|
|---|
| 355 | bb_error_msg("Device '%s' contains a valid Sun disklabel.\n"
|
|---|
| 356 | "This probably means creating v0 swap would destroy your partition table\n"
|
|---|
| 357 | "No swap created. If you really want to create swap v0 on that device, use\n"
|
|---|
| 358 | "the -f option to force it.", device_name);
|
|---|
| 359 | return EXIT_FAILURE;
|
|---|
| 360 | }
|
|---|
| 361 | }
|
|---|
| 362 | }
|
|---|
| 363 | #endif
|
|---|
| 364 |
|
|---|
| 365 | if (version == 0 || check)
|
|---|
| 366 | check_blocks();
|
|---|
| 367 | if (version == 0 && !bit_test_and_clear(signature_page, 0))
|
|---|
| 368 | bb_error_msg_and_die("fatal: first page unreadable");
|
|---|
| 369 | if (version == 1) {
|
|---|
| 370 | p->swap_version = version;
|
|---|
| 371 | p->last_page = PAGES - 1;
|
|---|
| 372 | p->nr_badpages = badpages;
|
|---|
| 373 | }
|
|---|
| 374 |
|
|---|
| 375 | goodpages = PAGES - badpages - 1;
|
|---|
| 376 | if (goodpages <= 0)
|
|---|
| 377 | bb_error_msg_and_die("Unable to set up swap-space: unreadable");
|
|---|
| 378 | printf("Setting up swapspace version %d, size = %ld bytes\n",
|
|---|
| 379 | version, (long) (goodpages * pagesize));
|
|---|
| 380 | write_signature((version == 0) ? "SWAP-SPACE" : "SWAPSPACE2");
|
|---|
| 381 |
|
|---|
| 382 | sz = ((version == 0) ? 0 : 1024); /* offset */
|
|---|
| 383 | if (lseek(DEV, sz, SEEK_SET) != sz)
|
|---|
| 384 | bb_error_msg_and_die("unable to rewind swap-device");
|
|---|
| 385 | goodpages = pagesize - sz; /* cache substraction */
|
|---|
| 386 | if (write(DEV, (char *) signature_page + sz, goodpages)
|
|---|
| 387 | != goodpages)
|
|---|
| 388 | bb_error_msg_and_die("unable to write signature page");
|
|---|
| 389 |
|
|---|
| 390 | /*
|
|---|
| 391 | * A subsequent swapon() will fail if the signature
|
|---|
| 392 | * is not actually on disk. (This is a kernel bug.)
|
|---|
| 393 | */
|
|---|
| 394 | if (fsync(DEV))
|
|---|
| 395 | bb_error_msg_and_die("fsync failed");
|
|---|
| 396 | if (ENABLE_FEATURE_CLEAN_UP) {
|
|---|
| 397 | close(DEV);
|
|---|
| 398 | free(signature_page);
|
|---|
| 399 | }
|
|---|
| 400 | return EXIT_SUCCESS;
|
|---|
| 401 | }
|
|---|
