*
* 1999-02-22 Arkadiusz Mi¶kiewicz <misiek@pld.ORG.PL>
* - added Native Language Support
- *
+ *
*/
#include <stdio.h>
#include <string.h>
#include <fcntl.h>
#include <stdlib.h>
-#include <sys/ioctl.h> /* for _IO */
+#include <limits.h>
+#include <mntent.h>
#include <sys/utsname.h>
#include <sys/stat.h>
-#include "nls.h"
-
-/* Try to get PAGE_SIZE from libc or kernel includes */
-#ifdef HAVE_sys_user_h
- /* Note: <sys/user.h> says: for gdb only */
-#include <sys/user.h> /* for PAGE_SIZE and PAGE_SHIFT */
-#else
-#ifdef HAVE_asm_page_h
-#include <asm/page.h> /* for PAGE_SIZE and PAGE_SHIFT */
- /* we also get PAGE_SIZE via getpagesize() */
+#include <errno.h>
+#include <err.h>
+#include <getopt.h>
+#ifdef HAVE_LIBSELINUX
+#include <selinux/selinux.h>
+#include <selinux/context.h>
#endif
+
+#include "linux_version.h"
+#include "swapheader.h"
+#include "strutils.h"
+#include "nls.h"
+#include "blkdev.h"
+#include "pathnames.h"
+#include "wholedisk.h"
+#include "writeall.h"
+#include "xalloc.h"
+
+#ifdef HAVE_LIBUUID
+# include <uuid.h>
#endif
-#ifndef _IO
-/* pre-1.3.45 */
-#define BLKGETSIZE 0x1260
-#else
-/* same on i386, m68k, arm; different on alpha, mips, sparc, ppc */
-#define BLKGETSIZE _IO(0x12,96)
+#ifdef HAVE_LIBBLKID_INTERNAL
+# include <blkid.h>
#endif
-static char * program_name = "mkswap";
-static char * device_name = NULL;
+static char *device_name = NULL;
static int DEV = -1;
-static long PAGES = 0;
+static unsigned long long PAGES = 0;
+static unsigned long badpages = 0;
static int check = 0;
-static int badpages = 0;
-static int version = -1;
-
-#define MAKE_VERSION(p,q,r) (65536*(p) + 256*(q) + (r))
-static int
-linux_version_code(void) {
- struct utsname my_utsname;
- int p, q, r;
-
- if (uname(&my_utsname) == 0) {
- p = atoi(strtok(my_utsname.release, "."));
- q = atoi(strtok(NULL, "."));
- r = atoi(strtok(NULL, "."));
- return MAKE_VERSION(p,q,r);
- }
- return 0;
-}
+#define SELINUX_SWAPFILE_TYPE "swapfile_t"
#ifdef __sparc__
# ifdef __arch64__
# define is_be64() 1
# else /* sparc32 */
static int
-is_sparc64(void) {
+is_sparc64(void)
+{
struct utsname un;
static int sparc64 = -1;
- if (sparc64 != -1) return sparc64;
+ if (sparc64 != -1)
+ return sparc64;
sparc64 = 0;
- if (uname(&un) < 0) return 0;
+ if (uname(&un) < 0)
+ return 0;
if (! strcmp(un.machine, "sparc64")) {
sparc64 = 1;
return 1;
if (strcmp(un.machine, "sparc"))
return 0; /* Should not happen */
-#ifdef HAVE_personality
+#ifdef HAVE_PERSONALITY
{
extern int personality(unsigned long);
int oldpers;
#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(), so that
- * we do not need separate binaries e.g. for sun4, sun4c/d/m and sun4u.
+ * The definition of the union swap_header uses the kernel constant PAGE_SIZE.
+ * Unfortunately, on some architectures this depends on the hardware model, and
+ * can only be found at run time -- we use getpagesize(), so that we do not
+ * need separate binaries e.g. for sun4, sun4c/d/m and sun4u.
+ *
+ * Even more unfortunately, getpagesize() does not always return the right
+ * information. For example, libc4, libc5 and glibc 2.0 do not use the system
+ * call but invent a value themselves (EXEC_PAGESIZE or NBPG * CLSIZE or NBPC),
+ * and thus it may happen that e.g. on a sparc kernel PAGE_SIZE=4096 and
+ * getpagesize() returns 8192.
*
- * Even more unfortunately, getpagesize() does not always return
- * the right information. For example, libc4 and libc5 do not use
- * the system call but invent a value themselves
- * (EXEC_PAGESIZE or NBPG * CLSIZE or NBPC), and thus it may happen
- * that e.g. on a sparc PAGE_SIZE=4096 and getpagesize() returns 8192.
* What to do? Let us allow the user to specify the pagesize explicitly.
+ *
*/
-
-static int user_pagesize = 0;
-static int kernel_pagesize; /* obtained via getpagesize(); */
-static int defined_pagesize = 0; /* PAGE_SIZE, when that exists */
+static long user_pagesize;
static int pagesize;
-static long *signature_page;
-
-struct swap_header_v1 {
- char bootbits[1024]; /* Space for disklabel etc. */
- unsigned int version;
- unsigned int last_page;
- unsigned int nr_badpages;
- unsigned int padding[125];
- unsigned int badpages[1];
-} *p;
+static unsigned long *signature_page = NULL;
static void
-init_signature_page(void) {
-#ifdef PAGE_SIZE
- defined_pagesize = PAGE_SIZE;
-#endif
- kernel_pagesize = getpagesize();
- pagesize = kernel_pagesize;
+init_signature_page(void)
+{
+
+ int kernel_pagesize = pagesize = getpagesize();
if (user_pagesize) {
- if ((user_pagesize & (user_pagesize-1)) ||
- user_pagesize < 1024) {
- fprintf(stderr, _("Bad user-specified page size %d\n"),
+ if ((user_pagesize & (user_pagesize - 1)) ||
+ user_pagesize < (long) sizeof(struct swap_header_v1_2) + 10)
+ errx(EXIT_FAILURE,
+ _("Bad user-specified page size %lu"),
user_pagesize);
- exit(1);
- }
pagesize = user_pagesize;
}
- if (user_pagesize && user_pagesize != kernel_pagesize &&
- user_pagesize != defined_pagesize)
- fprintf(stderr, _("Using user-specified page size %d, "
- "instead of the system values %d/%d\n"),
- pagesize, kernel_pagesize, defined_pagesize);
- else if (defined_pagesize && pagesize != defined_pagesize)
- fprintf(stderr, _("Assuming pages of size %d (not %d)\n"),
- pagesize, defined_pagesize);
-
- signature_page = (long *) malloc(pagesize);
- memset(signature_page,0,pagesize);
- p = (struct swap_header_v1 *) signature_page;
+ if (user_pagesize && user_pagesize != kernel_pagesize)
+ warnx(_("Using user-specified page size %d, "
+ "instead of the system value %d"),
+ pagesize, kernel_pagesize);
+
+ signature_page = (unsigned long *) xcalloc(1, pagesize);
}
static void
-write_signature(char *sig) {
+write_signature(char *sig)
+{
char *sp = (char *) signature_page;
- strncpy(sp+pagesize-10, sig, 10);
+ strncpy(sp + pagesize - 10, sig, 10);
+}
+
+static void
+write_uuid_and_label(unsigned char *uuid, char *volume_name)
+{
+ struct swap_header_v1_2 *h;
+
+ /* Sanity check */
+ if (sizeof(struct swap_header_v1) !=
+ sizeof(struct swap_header_v1_2)) {
+ warnx(_("Bad swap header size, no label written."));
+ return;
+ }
+
+ h = (struct swap_header_v1_2 *) signature_page;
+ if (uuid)
+ memcpy(h->uuid, uuid, sizeof(h->uuid));
+ if (volume_name) {
+ xstrncpy(h->volume_name, volume_name, sizeof(h->volume_name));
+ if (strlen(volume_name) > strlen(h->volume_name))
+ warnx(_("Label was truncated."));
+ }
+ if (uuid || volume_name) {
+ if (volume_name)
+ printf("LABEL=%s, ", h->volume_name);
+ else
+ printf(_("no label, "));
+#ifdef HAVE_LIBUUID
+ if (uuid) {
+ char uuid_string[37];
+ uuid_unparse(uuid, uuid_string);
+ printf("UUID=%s\n", uuid_string);
+ } else
+#endif
+ printf(_("no uuid\n"));
+ }
}
/*
* swap space as it can handle, but until 2.3.4 it would return an error
* to swapon() if the swapspace was too large.
*/
-#define V0_MAX_PAGES (8 * (pagesize - 10))
/* Before 2.2.0pre9 */
#define V1_OLD_MAX_PAGES ((0x7fffffff / pagesize) - 1)
/* Since 2.2.0pre9, before 2.3.4:
#elif defined(__sparc__)
#define V1_MAX_PAGES (is_sparc64() ? ((3 << 29) - 1) : ((1 << 18) - 1))
#elif defined(__ia64__)
-/*
+/*
* The actual size will depend on the amount of virtual address space
* available to vmalloc the swap map.
*/
*/
#define MAX_BADPAGES ((pagesize-1024-128*sizeof(int)-10)/sizeof(int))
-
-/*
- * One more point of lossage - Linux swapspace really is a mess.
- * The definition of the bitmap used is architecture dependent,
- * and requires one to know whether the machine is bigendian,
- * and if so, whether it will use 32-bit or 64-bit units in
- * test_bit().
- * davem writes: "... is based upon an unsigned long type of
- * the cpu and the native endianness".
- * So, it seems we can write `unsigned long' below.
- * However, sparc64 uses 64-bit units in the kernel, while
- * mkswap may have been translated with 32-bit longs. Thus,
- * we need an explicit test for version 0 swap on sparc64.
- */
-
-static void
-bit_set (unsigned long *addr, unsigned int nr) {
- unsigned int r, m;
-
- if(is_be64()) {
- unsigned long long *bitmap = (unsigned long long *) addr;
- unsigned long long bitnum = (unsigned long long) nr;
- unsigned long long rl, ml;
-
- bitmap += bitnum / (8 * sizeof(long long));
- rl = *bitmap;
- ml = 1ULL << (bitnum & (8ULL * sizeof(long long) - 1ULL));
- *bitmap = rl | ml;
- return;
- }
-
- addr += nr / (8 * sizeof(unsigned long));
- r = *addr;
- m = 1 << (nr & (8 * sizeof(unsigned long) - 1));
- *addr = r | m;
-}
-
-static int
-bit_test_and_clear (unsigned long *addr, unsigned int nr) {
- unsigned int r, m;
-
- if(is_be64()) {
- unsigned long long *bitmap = (unsigned long long *) addr;
- unsigned long long bitnum = (unsigned long long) nr;
- unsigned long long rl, ml;
-
- bitmap += bitnum / (8 * sizeof(long long));
- rl = *bitmap;
- ml = 1ULL << (bitnum & (8ULL * sizeof(long long) - 1ULL));
- *bitmap = rl & ~ml;
- return ((rl & ml) != 0ULL);
- }
-
- addr += nr / (8 * sizeof(unsigned long));
- r = *addr;
- m = 1 << (nr & (8 * sizeof(unsigned long) - 1));
- *addr = r & ~m;
- return (r & m) != 0;
-}
-
-static void
-usage(void) {
- fprintf(stderr,
- _("Usage: %s [-c] [-v0|-v1] [-pPAGESZ] /dev/name [blocks]\n"),
- program_name);
- exit(1);
+#define MIN_GOODPAGES 10
+
+static void __attribute__ ((__noreturn__)) usage(FILE *out)
+{
+ fprintf(out,
+ _("\nUsage:\n"
+ " %s [options] device [size]\n"),
+ program_invocation_short_name);
+
+ fprintf(out, _(
+ "\nOptions:\n"
+ " -c, --check check bad blocks before creating the swap area\n"
+ " -f, --force allow swap size area be larger than device\n"
+ " -p, --pagesize SIZE specify page size in bytes\n"
+ " -L, --label LABEL specify label\n"
+ " -v, --swapversion NUM specify swap-space version number\n"
+ " -U, --uuid UUID specify the uuid to use\n"
+ " -V, --version output version information and exit\n"
+ " -h, --help display this help and exit\n\n"));
+
+ exit(out == stderr ? EXIT_FAILURE : EXIT_SUCCESS);
}
static void
-die(const char *str) {
- fprintf(stderr, "%s: %s\n", program_name, str);
- exit(1);
-}
-
-static void
-page_ok(int page) {
- if (version==0)
- bit_set(signature_page, page);
-}
+page_bad(int page)
+{
+ struct swap_header_v1_2 *p = (struct swap_header_v1_2 *) signature_page;
-static void
-page_bad(int page) {
- if (version == 0)
- bit_test_and_clear(signature_page, page);
- else {
- if (badpages == MAX_BADPAGES)
- die(_("too many bad pages"));
- p->badpages[badpages] = page;
- }
+ if (badpages == MAX_BADPAGES)
+ errx(EXIT_FAILURE, _("too many bad pages"));
+ p->badpages[badpages] = page;
badpages++;
}
static void
-check_blocks(void) {
+check_blocks(void)
+{
unsigned int current_page;
int do_seek = 1;
char *buffer;
- buffer = malloc(pagesize);
- if (!buffer)
- die(_("Out of memory"));
+ buffer = xmalloc(pagesize);
current_page = 0;
while (current_page < PAGES) {
- if (!check) {
- page_ok(current_page++);
- continue;
- }
if (do_seek && lseek(DEV,current_page*pagesize,SEEK_SET) !=
current_page*pagesize)
- die(_("seek failed in check_blocks"));
- if ((do_seek = (pagesize != read(DEV, buffer, pagesize)))) {
- page_bad(current_page++);
- continue;
- }
- page_ok(current_page++);
+ errx(EXIT_FAILURE, _("seek failed in check_blocks"));
+ if ((do_seek = (pagesize != read(DEV, buffer, pagesize))))
+ page_bad(current_page);
+ current_page++;
}
if (badpages == 1)
printf(_("one bad page\n"));
else if (badpages > 1)
- printf(_("%d bad pages\n"), badpages);
+ printf(_("%lu bad pages\n"), badpages);
+ free(buffer);
}
-static long
-valid_offset (int fd, off_t offset) {
- char ch;
+/* return size in pages */
+static unsigned long long
+get_size(const char *file)
+{
+ int fd;
+ unsigned long long size;
- if (lseek (fd, offset, 0) < 0)
+ fd = open(file, O_RDONLY);
+ if (fd < 0) {
+ perror(file);
+ exit(EXIT_FAILURE);
+ }
+ if (blkdev_get_size(fd, &size) == 0)
+ size /= pagesize;
+
+ close(fd);
+ return size;
+}
+
+/*
+ * Check to make certain that our new filesystem won't be created on
+ * an already mounted partition. Code adapted from mke2fs, Copyright
+ * (C) 1994 Theodore Ts'o. Also licensed under GPL.
+ * (C) 2006 Karel Zak -- port to mkswap
+ */
+static int
+check_mount(void)
+{
+ FILE *f;
+ struct mntent *mnt;
+
+ if ((f = setmntent (_PATH_MOUNTED, "r")) == NULL)
return 0;
- if (read (fd, &ch, 1) < 1)
+ while ((mnt = getmntent (f)) != NULL)
+ if (strcmp (device_name, mnt->mnt_fsname) == 0)
+ break;
+ endmntent (f);
+ if (!mnt)
return 0;
return 1;
}
-static off_t
-find_size (int fd) {
- off_t high, low;
-
- low = 0;
- for (high = 1; high > 0 && valid_offset (fd, high); high *= 2)
- low = high;
- while (low < high - 1) {
- const off_t mid = (low + high) / 2;
-
- if (valid_offset (fd, mid))
- low = mid;
- else
- high = mid;
+static void
+zap_bootbits(int fd, const char *devname, int force, int is_blkdev)
+{
+ char *type = NULL;
+ int whole = 0;
+ int zap = 1;
+
+ if (!force) {
+ if (lseek(fd, 0, SEEK_SET) != 0)
+ errx(EXIT_FAILURE, _("unable to rewind swap-device"));
+
+ if (is_blkdev && is_whole_disk_fd(fd, devname)) {
+ /* don't zap bootbits on whole disk -- we know nothing
+ * about bootloaders on the device */
+ whole = 1;
+ zap = 0;
+ } else {
+#ifdef HAVE_LIBBLKID_INTERNAL
+ blkid_probe pr = blkid_new_probe();
+ if (!pr)
+ errx(EXIT_FAILURE, _("unable to alloc new libblkid probe"));
+ if (blkid_probe_set_device(pr, fd, 0, 0))
+ errx(EXIT_FAILURE, _("unable to assign device to libblkid probe"));
+
+ blkid_probe_enable_partitions(pr, 1);
+ blkid_probe_enable_superblocks(pr, 0);
+
+ if (blkid_do_fullprobe(pr) == 0)
+ blkid_probe_lookup_value(pr, "PTTYPE",
+ (const char **) &type, NULL);
+ if (type) {
+ type = xstrdup(type);
+ zap = 0;
+ }
+ blkid_free_probe(pr);
+#else
+ /* don't zap if compiled without libblkid */
+ zap = 0;
+#endif
+ }
}
- return (low + 1);
-}
-/* return size in pages, to avoid integer overflow */
-static long
-get_size(const char *file) {
- int fd;
- long size;
+ if (zap) {
+ char buf[1024];
- fd = open(file, O_RDONLY);
- if (fd < 0) {
- perror(file);
- exit(1);
- }
- if (ioctl(fd, BLKGETSIZE, &size) >= 0) {
- int sectors_per_page = pagesize/512;
- size /= sectors_per_page;
- } else {
- size = find_size(fd) / pagesize;
+ if (lseek(fd, 0, SEEK_SET) != 0)
+ errx(EXIT_FAILURE, _("unable to rewind swap-device"));
+
+ memset(buf, 0, sizeof(buf));
+ if (write_all(fd, buf, sizeof(buf)))
+ errx(EXIT_FAILURE, _("unable to erase bootbits sectors"));
+ return;
}
- close(fd);
- return size;
-}
-static int
-isnzdigit(char c) {
- return (c >= '1' && c <= '9');
+ warnx(_("%s: warning: don't erase bootbits sectors"),
+ devname);
+ if (type)
+ fprintf(stderr, _(" (%s partition table detected). "), type);
+ else if (whole)
+ fprintf(stderr, _(" on whole disk. "));
+ else
+ fprintf(stderr, _(" (compiled without libblkid). "));
+ fprintf(stderr, "Use -f to force.\n");
}
int
-main(int argc, char ** argv) {
+main(int argc, char **argv) {
struct stat statbuf;
- int i, sz;
- long maxpages;
- long goodpages;
+ struct swap_header_v1_2 *hdr;
+ int c;
+ unsigned long long maxpages;
+ unsigned long long goodpages;
+ unsigned long long sz;
off_t offset;
int force = 0;
+ long version = 1;
char *block_count = 0;
- char *pp;
-
- program_name = (argc && *argv) ? argv[0] : "fsck.minix";
- if ((pp = strrchr(program_name, '/')) != NULL)
- program_name = pp+1;
+ char *opt_label = NULL;
+ unsigned char *uuid = NULL;
+#ifdef HAVE_LIBUUID
+ const char *opt_uuid = NULL;
+ uuid_t uuid_dat;
+#endif
+ static const struct option longopts[] = {
+ { "check", no_argument, 0, 'c' },
+ { "force", no_argument, 0, 'f' },
+ { "pagesize", required_argument, 0, 'p' },
+ { "label", required_argument, 0, 'L' },
+ { "swapversion", required_argument, 0, 'v' },
+ { "uuid", required_argument, 0, 'U' },
+ { "version", no_argument, 0, 'V' },
+ { "help", no_argument, 0, 'h' },
+ { NULL, 0, 0, 0 }
+ };
setlocale(LC_ALL, "");
bindtextdomain(PACKAGE, LOCALEDIR);
textdomain(PACKAGE);
- if (argc == 2 &&
- (!strcmp(argv[1], "-V") || !strcmp(argv[1], "--version"))) {
- printf(_("%s from %s\n"), program_name, util_linux_version);
- exit(0);
+ while((c = getopt_long(argc, argv, "cfp:L:v:U:Vh", longopts, NULL)) != -1) {
+ switch (c) {
+ case 'c':
+ check=1;
+ break;
+ case 'f':
+ force=1;
+ break;
+ case 'p':
+ user_pagesize = strtol_or_err(optarg, _("parse page size failed"));
+ break;
+ case 'L':
+ opt_label = optarg;
+ break;
+ case 'v':
+ version = strtol_or_err(optarg, _("parse version number failed"));
+ break;
+ case 'U':
+#ifdef HAVE_LIBUUID
+ opt_uuid = optarg;
+#else
+ warnx(_("warning: ignore -U (UUIDs are unsupported by %s)"),
+ program_invocation_short_name);
+#endif
+ break;
+ case 'V':
+ printf(_("%s from %s\n"), program_invocation_short_name,
+ PACKAGE_STRING);
+ exit(EXIT_SUCCESS);
+ case 'h':
+ usage(stdout);
+ default:
+ usage(stderr);
+ }
}
-
- for (i=1; i<argc; i++) {
- if (argv[i][0] == '-') {
- switch (argv[i][1]) {
- case 'c':
- check=1;
- break;
- case 'f':
- force=1;
- break;
- case 'p':
- pp = argv[i]+2;
- if (!*pp && i+1 < argc)
- pp = argv[++i];
- if (isnzdigit(*pp))
- user_pagesize=atoi(pp);
- else
- usage();
- break;
- case 'v':
- version = atoi(argv[i]+2);
- break;
- default:
- usage();
- }
- } else if (!device_name) {
- device_name = argv[i];
- } else if (!block_count) {
- block_count = argv[i];
- } else
- usage();
+ if (optind < argc)
+ device_name = argv[optind++];
+ if (optind < argc)
+ block_count = argv[optind++];
+ if (optind != argc) {
+ warnx(("only one device as argument is currently supported."));
+ usage(stderr);
}
+ if (version != 1)
+ errx(EXIT_FAILURE,
+ _("does not support swapspace version %lu."),
+ version);
+
+#ifdef HAVE_LIBUUID
+ if(opt_uuid) {
+ if (uuid_parse(opt_uuid, uuid_dat) != 0)
+ errx(EXIT_FAILURE, _("error: UUID parsing failed"));
+ } else
+ uuid_generate(uuid_dat);
+ uuid = uuid_dat;
+#endif
+
init_signature_page(); /* get pagesize */
if (!device_name) {
- fprintf(stderr,
- _("%s: error: Nowhere to set up swap on?\n"),
- program_name);
- usage();
+ warnx(_("error: Nowhere to set up swap on?"));
+ usage(stderr);
}
if (block_count) {
- /* this silly user specified the number of blocks
- explicitly */
- char *tmp;
- int blocks_per_page = pagesize/1024;
- PAGES = strtol(block_count,&tmp,0)/blocks_per_page;
- if (*tmp)
- usage();
+ /* this silly user specified the number of blocks explicitly */
+ long long blks;
+
+ blks = strtoll_or_err(block_count, "parse block count failed");
+ if (blks < 0)
+ usage(stderr);
+
+ PAGES = blks / (pagesize / 1024);
}
sz = get_size(device_name);
- if (!PAGES) {
+ if (!PAGES)
PAGES = sz;
- } else if (PAGES > sz && !force) {
- fprintf(stderr,
- _("%s: error: "
- "size %ld is larger than device size %d\n"),
- program_name,
+ else if (PAGES > sz && !force) {
+ errx(EXIT_FAILURE,
+ _("error: "
+ "size %llu KiB is larger than device size %llu KiB"),
PAGES*(pagesize/1024), sz*(pagesize/1024));
- exit(1);
- }
-
- if (version == -1) {
- /* use version 1 as default, if possible */
- if (PAGES <= V0_MAX_PAGES && PAGES > V1_MAX_PAGES)
- version = 0;
- else if (linux_version_code() < MAKE_VERSION(2,1,117))
- version = 0;
- else if (pagesize < 2048)
- version = 0;
- else
- version = 1;
- }
- if (version != 0 && version != 1) {
- fprintf(stderr, _("%s: error: unknown version %d\n"),
- program_name, version);
- usage();
}
- if (PAGES < 10) {
- fprintf(stderr,
- _("%s: error: swap area needs to be at least %ldkB\n"),
- program_name, (long)(10 * pagesize / 1000));
- usage();
+ if (PAGES < MIN_GOODPAGES) {
+ warnx(_("error: swap area needs to be at least %ld KiB"),
+ (long)(MIN_GOODPAGES * pagesize/1024));
+ usage(stderr);
}
- if (version == 0)
- maxpages = V0_MAX_PAGES;
- else if (linux_version_code() >= MAKE_VERSION(2,3,4))
- maxpages = PAGES;
- else if (linux_version_code() >= MAKE_VERSION(2,2,1))
+#ifdef __linux__
+ if (get_linux_version() >= KERNEL_VERSION(2,3,4))
+ maxpages = UINT_MAX + 1ULL;
+ else if (get_linux_version() >= KERNEL_VERSION(2,2,1))
maxpages = V1_MAX_PAGES;
else
+#endif
maxpages = V1_OLD_MAX_PAGES;
if (PAGES > maxpages) {
PAGES = maxpages;
- fprintf(stderr,
- _("%s: warning: truncating swap area to %ldkB\n"),
- program_name, PAGES * pagesize / 1000);
+ warnx(_("warning: truncating swap area to %llu KiB"),
+ PAGES * pagesize / 1024);
+ }
+
+ if (stat(device_name, &statbuf) < 0) {
+ perror(device_name);
+ exit(EXIT_FAILURE);
}
+ if (S_ISBLK(statbuf.st_mode))
+ DEV = open(device_name, O_RDWR | O_EXCL);
+ else
+ DEV = open(device_name, O_RDWR);
- DEV = open(device_name,O_RDWR);
- if (DEV < 0 || fstat(DEV, &statbuf) < 0) {
+ if (DEV < 0) {
perror(device_name);
- exit(1);
+ exit(EXIT_FAILURE);
}
/* Want a block device. Probably not /dev/hda or /dev/hdb. */
if (!S_ISBLK(statbuf.st_mode))
check=0;
else if (statbuf.st_rdev == 0x0300 || statbuf.st_rdev == 0x0340)
- die(_("Will not try to make swapdevice on '%s'"));
+ errx(EXIT_FAILURE, _("error: "
+ "will not try to make swapdevice on '%s'"),
+ device_name);
+ else if (check_mount())
+ errx(EXIT_FAILURE, _("error: "
+ "%s is mounted; will not make swapspace."),
+ device_name);
+
+ if (check)
+ check_blocks();
-#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)
- 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) {
- fprintf(stderr, _("\
-%s: 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.\n"),
- program_name, device_name);
- exit(1);
- }
- }
- }
-#endif
+ zap_bootbits(DEV, device_name, force, S_ISBLK(statbuf.st_mode));
- if (version == 0 || check)
- check_blocks();
- if (version == 0 && !bit_test_and_clear(signature_page,0))
- die(_("fatal: first page unreadable"));
- if (version == 1) {
- p->version = version;
- p->last_page = PAGES-1;
- p->nr_badpages = badpages;
- }
+ hdr = (struct swap_header_v1_2 *) signature_page;
+ hdr->version = 1;
+ hdr->last_page = PAGES - 1;
+ hdr->nr_badpages = badpages;
+
+ if (badpages > PAGES - MIN_GOODPAGES)
+ errx(EXIT_FAILURE, _("Unable to set up swap-space: unreadable"));
goodpages = PAGES - badpages - 1;
- if (goodpages <= 0)
- die(_("Unable to set up swap-space: unreadable"));
- printf(_("Setting up swapspace version %d, size = %llu kB\n"),
- version, (unsigned long long)goodpages * pagesize / 1000);
- write_signature((version == 0) ? "SWAP-SPACE" : "SWAPSPACE2");
+ printf(_("Setting up swapspace version 1, size = %llu KiB\n"),
+ goodpages * pagesize / 1024);
+
+ write_signature("SWAPSPACE2");
+ write_uuid_and_label(uuid, opt_label);
- offset = ((version == 0) ? 0 : 1024);
+ offset = 1024;
if (lseek(DEV, offset, SEEK_SET) != offset)
- die(_("unable to rewind swap-device"));
- if (write(DEV,(char*)signature_page+offset, pagesize-offset)
- != pagesize-offset)
- die(_("unable to write signature page"));
+ errx(EXIT_FAILURE, _("unable to rewind swap-device"));
+ if (write_all(DEV, (char *) signature_page + offset,
+ pagesize - offset) == -1)
+ err(EXIT_FAILURE,
+ _("%s: unable to write signature page"),
+ device_name);
/*
* A subsequent swapon() will fail if the signature
* is not actually on disk. (This is a kernel bug.)
*/
-#ifdef HAVE_fsync
+#ifdef HAVE_FSYNC
if (fsync(DEV))
- die(_("fsync failed"));
+ errx(EXIT_FAILURE, _("fsync failed"));
+#endif
+
+#ifdef HAVE_LIBSELINUX
+ if (S_ISREG(statbuf.st_mode) && is_selinux_enabled() > 0) {
+ security_context_t context_string;
+ security_context_t oldcontext;
+ context_t newcontext;
+
+ if (fgetfilecon(DEV, &oldcontext) < 0) {
+ if (errno != ENODATA)
+ err(EXIT_FAILURE,
+ _("%s: unable to obtain selinux file label"),
+ device_name);
+ if (matchpathcon(device_name, statbuf.st_mode, &oldcontext))
+ errx(EXIT_FAILURE, _("unable to matchpathcon()"));
+ }
+ if (!(newcontext = context_new(oldcontext)))
+ errx(EXIT_FAILURE, _("unable to create new selinux context"));
+ if (context_type_set(newcontext, SELINUX_SWAPFILE_TYPE))
+ errx(EXIT_FAILURE, _("couldn't compute selinux context"));
+
+ context_string = context_str(newcontext);
+
+ if (strcmp(context_string, oldcontext)!=0) {
+ if (fsetfilecon(DEV, context_string))
+ err(EXIT_FAILURE, _("unable to relabel %s to %s"),
+ device_name, context_string);
+ }
+ context_free(newcontext);
+ freecon(oldcontext);
+ }
#endif
- return 0;
+ return EXIT_SUCCESS;
}
projects / thirdparty / util-linux.git / blobdiff