X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=util-linux%2Fmkswap.c;h=7e32d91edba94396543a4b03471e83dfbaca0edc;hb=4f0408b5bc6ed726e7f98d6adedede41337b9b74;hp=44d809a3677015653586c5d0404ec620f05b2740;hpb=c2cb0f32b44a9918364af39c24b5643388c553f6;p=oweals%2Fbusybox.git diff --git a/util-linux/mkswap.c b/util-linux/mkswap.c index 44d809a36..7e32d91ed 100644 --- a/util-linux/mkswap.c +++ b/util-linux/mkswap.c @@ -1,411 +1,136 @@ /* vi: set sw=4 ts=4: */ -/* - * mkswap.c - set up a linux swap device - * - * (C) 1991 Linus Torvalds. This file may be redistributed as per - * the Linux copyright. - */ - -/* - * 20.12.91 - time began. Got VM working yesterday by doing this by hand. - * - * Usage: mkswap [-c] [-vN] [-f] device [size-in-blocks] - * - * -c for readability checking. (Use it unless you are SURE!) - * -vN for swap areas version N. (Only N=0,1 known today.) - * -f for forcing swap creation even if it would smash partition table. +/* mkswap.c - format swap device (Linux v1 only) * - * The device may be a block device or an image of one, but this isn't - * enforced (but it's not much fun on a character device :-). + * Copyright 2006 Rob Landley * - * Patches from jaggy@purplet.demon.co.uk (Mike Jagdis) to make the - * size-in-blocks parameter optional added Wed Feb 8 10:33:43 1995. - * - * Version 1 swap area code (for kernel 2.1.117), aeb, 981010. - * - * Sparc fixes, jj@ultra.linux.cz (Jakub Jelinek), 981201 - mangled by aeb. - * V1_MAX_PAGES fixes, jj, 990325. - * - * 1999-02-22 Arkadiusz Mi¶kiewicz - * - added Native Language Support - * - * from util-linux -- adapted for busybox by - * Erik Andersen . I ripped out Native Language - * Support, made some stuff smaller, and fitted for life in busybox. - * - */ - -#include -#include -#include -#include -#include -#include /* for _IO */ -#include -#include /* for PAGE_SIZE and PAGE_SHIFT */ - /* we also get PAGE_SIZE via getpagesize() */ -#include "busybox.h" - -#ifndef _IO -/* pre-1.3.45 */ -enum { BLKGETSIZE = 0x1260 }; -#else -/* same on i386, m68k, arm; different on alpha, mips, sparc, ppc */ -#define BLKGETSIZE _IO(0x12,96) -#endif - -static char *device_name = NULL; -static int DEV = -1; -static long PAGES = 0; -static int check = 0; -static int badpages = 0; -#if ENABLE_FEATURE_MKSWAP_V0 -static int version = -1; -#define MAKE_VERSION(p,q,r) (65536*(p) + 256*(q) + (r)) -#else -#define version 1 -/* and make sure that we optimize away anything which would deal with checking - * the kernel revision as we have v1 support only anyway. + * Licensed under GPL version 2, see file LICENSE in this tarball for details. */ -#define MAKE_VERSION(p,q,r) 1 -#define get_kernel_revision() 1 -#endif - -/* - * The definition of the union swap_header uses the constant PAGE_SIZE. - * Unfortunately, on some architectures this depends on the hardware model, - * and can only be found at run time -- we use getpagesize(). - */ - -static int pagesize; -static unsigned int *signature_page; - -static struct swap_header_v1 { - char bootbits[1024]; /* Space for disklabel etc. */ - unsigned int swap_version; - unsigned int last_page; - unsigned int nr_badpages; - unsigned int padding[125]; - unsigned int badpages[1]; -} *p; - -static inline void init_signature_page(void) -{ - pagesize = getpagesize(); - -#ifdef PAGE_SIZE - if (pagesize != PAGE_SIZE) - bb_error_msg("Assuming pages of size %d", pagesize); -#endif - signature_page = (unsigned int *) xmalloc(pagesize); - memset(signature_page, 0, pagesize); - p = (struct swap_header_v1 *) signature_page; -} - -static inline void write_signature(char *sig) -{ - char *sp = (char *) signature_page; - - strncpy(sp + pagesize - 10, sig, 10); -} - -#define V0_MAX_PAGES (8 * (pagesize - 10)) -/* Before 2.2.0pre9 */ -#define V1_OLD_MAX_PAGES ((0x7fffffff / pagesize) - 1) -/* Since 2.2.0pre9: - error if nr of pages >= SWP_OFFSET(SWP_ENTRY(0,~0UL)) - with variations on - #define SWP_ENTRY(type,offset) (((type) << 1) | ((offset) << 8)) - #define SWP_OFFSET(entry) ((entry) >> 8) - on the various architectures. Below the result - yuk. - - Machine pagesize SWP_ENTRY SWP_OFFSET bound+1 oldbound+2 - i386 2^12 o<<8 e>>8 1<<24 1<<19 - mips 2^12 o<<15 e>>15 1<<17 1<<19 - alpha 2^13 o<<40 e>>40 1<<24 1<<18 - m68k 2^12 o<<12 e>>12 1<<20 1<<19 - sparc 2^{12,13} (o&0x3ffff)<<9 (e>>9)&0x3ffff 1<<18 1<<{19,18} - sparc64 2^13 o<<13 e>>13 1<<51 1<<18 - ppc 2^12 o<<8 e>>8 1<<24 1<<19 - armo 2^{13,14,15} o<<8 e>>8 1<<24 1<<{18,17,16} - armv 2^12 o<<9 e>>9 1<<23 1<<19 - - assuming that longs have 64 bits on alpha and sparc64 and 32 bits elsewhere. - - The bad part is that we need to know this since the kernel will - refuse a swap space if it is too large. -*/ -/* patch from jj - why does this differ from the above? */ -#if defined(__alpha__) -#define V1_MAX_PAGES ((1 << 24) - 1) -#elif defined(__mips__) -#define V1_MAX_PAGES ((1 << 17) - 1) -#elif defined(__sparc_v9__) -#define V1_MAX_PAGES ((3 << 29) - 1) -#elif defined(__sparc__) -#define V1_MAX_PAGES (pagesize == 8192 ? ((3 << 29) - 1) : ((1 << 18) - 1)) -#else -#define V1_MAX_PAGES V1_OLD_MAX_PAGES -#endif -/* man page now says: -The maximum useful size of a swap area now depends on the architecture. -It is roughly 2GB on i386, PPC, m68k, ARM, 1GB on sparc, 512MB on mips, -128GB on alpha and 3TB on sparc64. -*/ - -#define MAX_BADPAGES ((pagesize-1024-128*sizeof(int)-10)/sizeof(int)) - -static inline void bit_set(unsigned int *addr, unsigned int nr) -{ - unsigned int r, m; - - addr += nr / (8 * sizeof(int)); - - r = *addr; - m = 1 << (nr & (8 * sizeof(int) - 1)); - - *addr = r | m; -} - -static int bit_test_and_clear(unsigned int *addr, unsigned int nr) -{ - unsigned int r, m; - - addr += nr / (8 * sizeof(int)); - - r = *addr; - m = 1 << (nr & (8 * sizeof(int) - 1)); +#include "libbb.h" - *addr = r & ~m; - return (r & m) != 0; -} - -static void page_ok(int page) +#if ENABLE_SELINUX +static void mkswap_selinux_setcontext(int fd, const char *path) { - if (ENABLE_FEATURE_MKSWAP_V0) { - bit_set(signature_page, page); - } -} - -static void check_blocks(void) -{ - unsigned int current_page; - int do_seek = 1; - char *buffer; - - buffer = xmalloc(pagesize); - current_page = 0; - while (current_page < PAGES) { - if (!check && version == 0) { - page_ok(current_page++); - continue; + struct stat stbuf; + + if (!is_selinux_enabled()) + return; + + if (fstat(fd, &stbuf) < 0) + bb_perror_msg_and_die("fstat failed"); + if (S_ISREG(stbuf.st_mode)) { + security_context_t newcon; + security_context_t oldcon = NULL; + context_t context; + + if (fgetfilecon(fd, &oldcon) < 0) { + if (errno != ENODATA) + goto error; + if (matchpathcon(path, stbuf.st_mode, &oldcon) < 0) + goto error; } - if (do_seek && lseek(DEV, current_page * pagesize, SEEK_SET) != - current_page * pagesize) - bb_error_msg_and_die("seek failed in check_blocks"); - if ((do_seek = (pagesize != read(DEV, buffer, pagesize)))) { - current_page++; - if (version == 0) - bit_test_and_clear(signature_page, current_page); - else { - if (badpages == MAX_BADPAGES) - bb_error_msg_and_die("too many bad pages"); - p->badpages[badpages] = current_page; - } - badpages++; - continue; + context = context_new(oldcon); + if (!context || context_type_set(context, "swapfile_t")) + goto error; + newcon = context_str(context); + if (!newcon) + goto error; + /* fsetfilecon_raw is hidden */ + if (strcmp(oldcon, newcon) != 0 && fsetfilecon(fd, newcon) < 0) + goto error; + if (ENABLE_FEATURE_CLEAN_UP) { + context_free(context); + freecon(oldcon); } - page_ok(current_page++); - } - if (ENABLE_FEATURE_CLEAN_UP) - free(buffer); - if (badpages > 0) - printf("%d bad page%s\n", badpages, (badpages==1)?"":"s"); -} - -static long valid_offset(int fd, int offset) -{ - char ch; - - if (lseek(fd, offset, 0) < 0) - return 0; - if (read(fd, &ch, 1) < 1) - return 0; - return 1; -} - -static int find_size(int fd) -{ - unsigned int high, low; - - low = 0; - for (high = 1; high > 0 && valid_offset(fd, high); high *= 2) - low = high; - while (low < high - 1) { - const int mid = (low + high) / 2; - - if (valid_offset(fd, mid)) - low = mid; - else - high = mid; } - return (low + 1); + return; + error: + bb_perror_msg_and_die("SELinux relabeling failed"); } +#else +# define mkswap_selinux_setcontext(fd, path) ((void)0) +#endif -/* return size in pages, to avoid integer overflow */ -static inline long get_size(const char *file) +/* from Linux 2.6.23 */ +/* + * Magic header for a swap area. ... Note that the first + * kilobyte is reserved for boot loader or disk label stuff. + */ +struct swap_header_v1 { +/* char bootbits[1024]; Space for disklabel etc. */ + uint32_t version; /* second kbyte, word 0 */ + uint32_t last_page; /* 1 */ + uint32_t nr_badpages; /* 2 */ + char sws_uuid[16]; /* 3,4,5,6 */ + char sws_volume[16]; /* 7,8,9,10 */ + uint32_t padding[117]; /* 11..127 */ + uint32_t badpages[1]; /* 128 */ + /* total 129 32-bit words in 2nd kilobyte */ +} FIX_ALIASING; + +#define NWORDS 129 +#define hdr ((struct swap_header_v1*)bb_common_bufsiz1) + +struct BUG_sizes { + char swap_header_v1_wrong[sizeof(*hdr) != (NWORDS * 4) ? -1 : 1]; + char bufsiz1_is_too_small[COMMON_BUFSIZE < (NWORDS * 4) ? -1 : 1]; +}; + +/* Stored without terminating NUL */ +static const char SWAPSPACE2[sizeof("SWAPSPACE2")-1] ALIGN1 = "SWAPSPACE2"; + +int mkswap_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE; +int mkswap_main(int argc UNUSED_PARAM, char **argv) { int fd; - long size; - - fd = bb_xopen3(file, O_RDONLY, 0); - if (ioctl(fd, BLKGETSIZE, &size) >= 0) { - size /= pagesize / 512; - } else { - size = find_size(fd) / pagesize; - } - close(fd); - return size; -} - -int mkswap_main(int argc, char **argv) -{ - char *tmp; - struct stat statbuf; - int sz; - int maxpages; - int goodpages; -#ifdef __sparc__ - int force = 0; -#endif - - init_signature_page(); /* get pagesize */ - - bb_opt_complementally = "?"; /* call bb_show_usage internally */ - sz = bb_getopt_ulflags(argc, argv, "+cfv:", &tmp); - if (sz & 1) - check = 1; -#ifdef __sparc__ - if (sz & 2) - force = 1; -#endif -#if ENABLE_FEATURE_MKSWAP_V0 - if (sz & 4) { - version = bb_xgetlarg(tmp, 10, 0, 1); - } else { - if (get_kernel_revision() < MAKE_VERSION(2, 1, 117)) - version = 0; - else - version = 1; - } -#endif + unsigned pagesize; + off_t len; + const char *label = ""; + opt_complementary = "-1"; /* at least one param */ + /* TODO: -p PAGESZ, -U UUID */ + getopt32(argv, "L:", &label); argv += optind; - argc -= optind; - - goodpages = pagesize / 1024; /* cache division */ - while (argc--) { - if (device_name) { - PAGES = bb_xgetlarg(argv[0], 0, 10, sz * goodpages) / goodpages; - argc = 0; /* ignore any surplus args.. */ - } else { - device_name = argv[0]; - sz = get_size(device_name); - argv++; - } - } - - if (!device_name) { - bb_error_msg_and_die("error: Nowhere to set up swap on?"); - } - if (!PAGES) { - PAGES = sz; - } -#if 0 - maxpages = ((version == 0) ? V0_MAX_PAGES : V1_MAX_PAGES); -#else - if (!version) - maxpages = V0_MAX_PAGES; - else if (get_kernel_revision() >= MAKE_VERSION(2, 2, 1)) - maxpages = V1_MAX_PAGES; - else { - maxpages = V1_OLD_MAX_PAGES; - if (maxpages > V1_MAX_PAGES) - maxpages = V1_MAX_PAGES; - } -#endif - if (PAGES > maxpages) { - PAGES = maxpages; - bb_error_msg("warning: truncating swap area to %ldkB", - PAGES * goodpages); - } + fd = xopen(argv[0], O_WRONLY); - DEV = bb_xopen3(device_name, O_RDWR, 0); - if (fstat(DEV, &statbuf) < 0) - bb_perror_msg_and_die("%s", device_name); - if (!S_ISBLK(statbuf.st_mode)) - check = 0; - else if (statbuf.st_rdev == 0x0300 || statbuf.st_rdev == 0x0340) - bb_error_msg_and_die("Will not try to make swapdevice on '%s'", device_name); - -#ifdef __sparc__ - if (!force && version == 0) { - /* Don't overwrite partition table unless forced */ - unsigned char *buffer = (unsigned char *) signature_page; - unsigned short *q, sum; - - if (read(DEV, buffer, 512) != 512) - bb_error_msg_and_die("fatal: first page unreadable"); - if (buffer[508] == 0xDA && buffer[509] == 0xBE) { - q = (unsigned short *) (buffer + 510); - for (sum = 0; q >= (unsigned short *) buffer;) - sum ^= *q--; - if (!sum) { - bb_error_msg("Device '%s' contains a valid Sun disklabel.\n" -"This probably means creating v0 swap would destroy your partition table\n" -"No swap created. If you really want to create swap v0 on that device, use\n" -"the -f option to force it.", device_name); - return EXIT_FAILURE; - } - } - } -#endif - - if (version == 0 || check) - check_blocks(); - if (version == 0 && !bit_test_and_clear(signature_page, 0)) - bb_error_msg_and_die("fatal: first page unreadable"); - if (version == 1) { - p->swap_version = version; - p->last_page = PAGES - 1; - p->nr_badpages = badpages; + /* Figure out how big the device is */ + len = get_volume_size_in_bytes(fd, argv[1], 1024, /*extend:*/ 1); + pagesize = getpagesize(); + len -= pagesize; + + /* Announce our intentions */ + printf("Setting up swapspace version 1, size = %"OFF_FMT"u bytes\n", len); + mkswap_selinux_setcontext(fd, argv[0]); + + /* Make a header. hdr is zero-filled so far... */ + hdr->version = 1; + hdr->last_page = (uoff_t)len / pagesize; + + if (ENABLE_FEATURE_MKSWAP_UUID) { + char uuid_string[32]; + generate_uuid((void*)hdr->sws_uuid); + bin2hex(uuid_string, hdr->sws_uuid, 16); + /* f.e. UUID=dfd9c173-be52-4d27-99a5-c34c6c2ff55f */ + printf("UUID=%.8s" "-%.4s-%.4s-%.4s-%.12s\n", + uuid_string, + uuid_string+8, + uuid_string+8+4, + uuid_string+8+4+4, + uuid_string+8+4+4+4 + ); } + safe_strncpy(hdr->sws_volume, label, 16); - goodpages = PAGES - badpages - 1; - if (goodpages <= 0) - bb_error_msg_and_die("Unable to set up swap-space: unreadable"); - printf("Setting up swapspace version %d, size = %ld bytes\n", - version, (long) (goodpages * pagesize)); - write_signature((version == 0) ? "SWAP-SPACE" : "SWAPSPACE2"); + /* Write the header. Sync to disk because some kernel versions check + * signature on disk (not in cache) during swapon. */ + xlseek(fd, 1024, SEEK_SET); + xwrite(fd, hdr, NWORDS * 4); + xlseek(fd, pagesize - 10, SEEK_SET); + xwrite(fd, SWAPSPACE2, 10); + fsync(fd); - sz = ((version == 0) ? 0 : 1024); /* offset */ - if (lseek(DEV, sz, SEEK_SET) != sz) - bb_error_msg_and_die("unable to rewind swap-device"); - goodpages = pagesize - sz; /* cache substraction */ - if (write(DEV, (char *) signature_page + sz, goodpages) - != goodpages) - bb_error_msg_and_die("unable to write signature page"); + if (ENABLE_FEATURE_CLEAN_UP) + close(fd); - /* - * A subsequent swapon() will fail if the signature - * is not actually on disk. (This is a kernel bug.) - */ - if (fsync(DEV)) - bb_error_msg_and_die("fsync failed"); - if (ENABLE_FEATURE_CLEAN_UP) { - close(DEV); - free(signature_page); - } - return EXIT_SUCCESS; + return 0; }