/*
+ * SPDX-License-Identifier: GPL-2.0-or-later
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
* mkswap.c - set up a linux swap device
*
* Copyright (C) 1991 Linus Torvalds
#ifdef HAVE_LIBSELINUX
# include <selinux/selinux.h>
# include <selinux/context.h>
+# include "selinux-utils.h"
#endif
#ifdef HAVE_LINUX_FIEMAP_H
# include <linux/fs.h>
#include "c.h"
#include "closestream.h"
#include "ismounted.h"
+#include "optutils.h"
+#include "bitops.h"
#ifdef HAVE_LIBUUID
# include <uuid.h>
#define SELINUX_SWAPFILE_TYPE "swapfile_t"
+enum ENDIANNESS {
+ ENDIANNESS_NATIVE,
+ ENDIANNESS_LITTLE,
+ ENDIANNESS_BIG,
+};
+
struct mkswap_control {
struct swap_header_v1_2 *hdr; /* swap header */
void *signature_page;/* buffer with swap header */
int user_pagesize; /* --pagesize */
int pagesize; /* final pagesize used for the header */
+ off_t offset; /* offset of the header in the target */
char *opt_label; /* LABEL as specified on command line */
unsigned char *uuid; /* UUID parsed by libbuuid */
+ unsigned long long filesz; /* desired swap file size */
+
size_t nbad_extents;
+ enum ENDIANNESS endianness;
+
unsigned int check:1, /* --check */
verbose:1, /* --verbose */
- force:1; /* --force */
+ quiet:1, /* --quiet */
+ force:1, /* --force */
+ file:1; /* --file */
};
+static uint32_t cpu32_to_endianness(uint32_t v, enum ENDIANNESS e)
+{
+ switch (e) {
+ case ENDIANNESS_NATIVE: return v;
+ case ENDIANNESS_LITTLE: return cpu_to_le32(v);
+ case ENDIANNESS_BIG: return cpu_to_be32(v);
+ }
+ abort();
+}
+
static void init_signature_page(struct mkswap_control *ctl)
{
const int kernel_pagesize = getpagesize();
errx(EXIT_FAILURE,
_("Bad user-specified page size %u"),
ctl->user_pagesize);
- if (ctl->user_pagesize != kernel_pagesize)
+ if (!ctl->quiet && ctl->user_pagesize != kernel_pagesize)
warnx(_("Using user-specified page size %d, "
"instead of the system value %d"),
ctl->user_pagesize, kernel_pagesize);
if (ctl->opt_label) {
xstrncpy(ctl->hdr->volume_name,
ctl->opt_label, sizeof(ctl->hdr->volume_name));
- if (strlen(ctl->opt_label) > strlen(ctl->hdr->volume_name))
+ if (!ctl->quiet
+ && strlen(ctl->opt_label) > strlen(ctl->hdr->volume_name))
warnx(_("Label was truncated."));
}
/* report results */
- if (ctl->uuid || ctl->opt_label) {
+ if (!ctl->quiet && (ctl->uuid || ctl->opt_label)) {
if (ctl->opt_label)
printf("LABEL=%s, ", ctl->hdr->volume_name);
else
fputs(USAGE_OPTIONS, out);
fputs(_(" -c, --check check bad blocks before creating the swap area\n"), out);
fputs(_(" -f, --force allow swap size area be larger than device\n"), out);
+ fputs(_(" -q, --quiet suppress output and warning messages\n"), out);
fputs(_(" -p, --pagesize SIZE specify page size in bytes\n"), out);
fputs(_(" -L, --label LABEL specify label\n"), out);
fputs(_(" -v, --swapversion NUM specify swap-space version number\n"), out);
fputs(_(" -U, --uuid UUID specify the uuid to use\n"), out);
+ fprintf(out,
+ _(" -e, --endianness=<value> specify the endianness to use "
+ "(%s, %s or %s)\n"), "native", "little", "big");
+ fputs(_(" -o, --offset OFFSET specify the offset in the device\n"), out);
+ fputs(_(" -s, --size SIZE specify the size of a swap file in bytes\n"), out);
+ fputs(_(" -F, --file create a swap file\n"), out);
fputs(_(" --verbose verbose output\n"), out);
fprintf(out,
_(" --lock[=<mode>] use exclusive device lock (%s, %s or %s)\n"), "yes", "no", "nonblock");
- printf(USAGE_HELP_OPTIONS(27));
- printf(USAGE_MAN_TAIL("mkswap(8)"));
+ fprintf(out, USAGE_HELP_OPTIONS(27));
+
+ fprintf(out, USAGE_MAN_TAIL("mkswap(8)"));
exit(EXIT_SUCCESS);
}
page_bad(ctl, current_page);
current_page++;
}
- printf(P_("%lu bad page\n", "%lu bad pages\n", ctl->nbadpages), ctl->nbadpages);
+
+ if (!ctl->quiet)
+ printf(P_("%lu bad page\n", "%lu bad pages\n", ctl->nbadpages), ctl->nbadpages);
free(buffer);
}
return;
n = fiemap->fm_mapped_extents;
+ if (n == 0)
+ break;
for (i = 0; i < n; i++) {
struct fiemap_extent *e = &fiemap->fm_extents[i];
warn_extent(ctl, _("data inline extent at offset %ju"),
(uintmax_t) e->fe_logical);
if (e->fe_flags & FIEMAP_EXTENT_SHARED)
- warn_extent(ctl, _("shared extent at offset %ju"),
+ warn_extent(ctl, _("shared extent at offset %ju"),
(uintmax_t) e->fe_logical);
if (e->fe_flags & FIEMAP_EXTENT_DELALLOC)
warn_extent(ctl, _("unallocated extent at offset %ju"),
/* return size in pages */
static unsigned long long get_size(const struct mkswap_control *ctl)
{
- int fd;
unsigned long long size;
- fd = open(ctl->devname, O_RDONLY);
- if (fd < 0)
- err(EXIT_FAILURE, _("cannot open %s"), ctl->devname);
- if (blkdev_get_size(fd, &size) == 0)
- size /= ctl->pagesize;
-
- close(fd);
+ if (ctl->file && ctl->filesz)
+ size = ctl->filesz;
+ else {
+ int fd = open(ctl->devname, O_RDONLY);
+ if (fd < 0)
+ err(EXIT_FAILURE, _("cannot open %s"), ctl->devname);
+ if (blkdev_get_size(fd, &size) < 0)
+ err(EXIT_FAILURE, _("cannot determine size of %s"), ctl->devname);
+ if ((unsigned long long) ctl->offset > size)
+ errx(EXIT_FAILURE, _("offset larger than file size"));
+ close(fd);
+ }
+ size -= ctl->offset;
+ size /= ctl->pagesize;
return size;
}
assert(ctl);
assert(ctl->devname);
- if (stat(ctl->devname, &ctl->devstat) < 0)
- err(EXIT_FAILURE, _("stat of %s failed"), ctl->devname);
- ctl->fd = open_blkdev_or_file(&ctl->devstat, ctl->devname, O_RDWR);
+ if (ctl->file) {
+ if (stat(ctl->devname, &ctl->devstat) == 0) {
+ if (!S_ISREG(ctl->devstat.st_mode))
+ err(EXIT_FAILURE, _("cannot create swap file %s: node isn't regular file"), ctl->devname);
+ if (chmod(ctl->devname, 0600) < 9)
+ err(EXIT_FAILURE, _("cannot set permissions on swap file %s"), ctl->devname);
+ }
+ ctl->fd = open(ctl->devname, O_RDWR | O_CREAT, 0600);
+ } else {
+ if (stat(ctl->devname, &ctl->devstat) < 0)
+ err(EXIT_FAILURE, _("stat of %s failed"), ctl->devname);
+ ctl->fd = open_blkdev_or_file(&ctl->devstat, ctl->devname, O_RDWR);
+ }
if (ctl->fd < 0)
err(EXIT_FAILURE, _("cannot open %s"), ctl->devname);
+ if (ctl->file && ctl->filesz) {
+ if (ftruncate(ctl->fd, ctl->filesz) < 0)
+ err(EXIT_FAILURE, _("couldn't allocate swap file %s"), ctl->devname);
+#ifdef HAVE_POSIX_FALLOCATE
+ errno = posix_fallocate(ctl->fd, 0, ctl->filesz);
+ if (errno)
+ err(EXIT_FAILURE, _("couldn't allocate swap file %s"), ctl->devname);
+#elif defined(HAVE_FALLOCATE)
+ if (fallocate(ctl->fd, 0, 0, ctl->filesz) < 0)
+ err(EXIT_FAILURE, _("couldn't allocate swap file %s"), ctl->devname);
+#endif
+ }
if (blkdev_lock(ctl->fd, ctl->devname, ctl->lockmode) != 0)
exit(EXIT_FAILURE);
if (ctl->check && S_ISREG(ctl->devstat.st_mode)) {
ctl->check = 0;
- warnx(_("warning: checking bad blocks from swap file is not supported: %s"),
- ctl->devname);
+ if (!ctl->quiet)
+ warnx(_("warning: checking bad blocks from swap file is not supported: %s"),
+ ctl->devname);
}
}
int zap = 1;
#ifdef HAVE_LIBBLKID
blkid_probe pr = NULL;
+ const char *v = NULL;
#endif
if (!ctl->force) {
- const char *v = NULL;
-
if (lseek(ctl->fd, 0, SEEK_SET) != 0)
errx(EXIT_FAILURE, _("unable to rewind swap-device"));
while (blkid_do_probe(pr) == 0) {
const char *data = NULL;
- if (blkid_probe_lookup_value(pr, "TYPE", &data, NULL) == 0 && data)
+ if (!ctl->quiet
+ && blkid_probe_lookup_value(pr, "TYPE", &data, NULL) == 0 && data)
warnx(_("%s: warning: wiping old %s signature."), ctl->devname, data);
blkid_do_wipe(pr, 0);
}
#endif
- } else {
+ } else if (!ctl->quiet) {
warnx(_("%s: warning: don't erase bootbits sectors"),
ctl->devname);
if (type)
static void write_header_to_device(struct mkswap_control *ctl)
{
+ off_t offset;
+
assert(ctl);
assert(ctl->fd > -1);
assert(ctl->signature_page);
- if (lseek(ctl->fd, SIGNATURE_OFFSET, SEEK_SET) != SIGNATURE_OFFSET)
+ offset = SIGNATURE_OFFSET + ctl->offset;
+
+ if (lseek(ctl->fd, offset, SEEK_SET) != offset)
errx(EXIT_FAILURE, _("unable to rewind swap-device"));
if (write_all(ctl->fd, (char *) ctl->signature_page + SIGNATURE_OFFSET,
int main(int argc, char **argv)
{
- struct mkswap_control ctl = { .fd = -1 };
+ struct mkswap_control ctl = { .fd = -1, .endianness = ENDIANNESS_NATIVE };
int c, permMask;
uint64_t sz;
int version = SWAP_VERSION;
static const struct option longopts[] = {
{ "check", no_argument, NULL, 'c' },
{ "force", no_argument, NULL, 'f' },
+ { "quiet", no_argument, NULL, 'q' },
{ "pagesize", required_argument, NULL, 'p' },
{ "label", required_argument, NULL, 'L' },
{ "swapversion", required_argument, NULL, 'v' },
{ "uuid", required_argument, NULL, 'U' },
+ { "endianness", required_argument, NULL, 'e' },
+ { "offset", required_argument, NULL, 'o' },
+ { "size", required_argument, NULL, 's' },
+ { "file", no_argument, NULL, 'F' },
{ "version", no_argument, NULL, 'V' },
{ "help", no_argument, NULL, 'h' },
{ "lock", optional_argument, NULL, OPT_LOCK },
{ NULL, 0, NULL, 0 }
};
+ static const ul_excl_t excl[] = { /* rows and cols in ASCII order */
+ { 'c', 'q' },
+ { 0 }
+ };
+ int excl_st[ARRAY_SIZE(excl)] = UL_EXCL_STATUS_INIT;
+
setlocale(LC_ALL, "");
bindtextdomain(PACKAGE, LOCALEDIR);
textdomain(PACKAGE);
close_stdout_atexit();
- while((c = getopt_long(argc, argv, "cfp:L:v:U:Vh", longopts, NULL)) != -1) {
+ while((c = getopt_long(argc, argv, "cfp:qL:v:U:e:o:s:FVh", longopts, NULL)) != -1) {
+
+ err_exclusive_options(c, longopts, excl, excl_st);
+
switch (c) {
case 'c':
ctl.check = 1;
case 'p':
ctl.user_pagesize = strtou32_or_err(optarg, _("parsing page size failed"));
break;
+ case 'q':
+ ctl.quiet = 1;
+ break;
case 'L':
ctl.opt_label = optarg;
break;
program_invocation_short_name);
#endif
break;
+ case 'e':
+ if (strcmp(optarg, "native") == 0) {
+ ctl.endianness = ENDIANNESS_NATIVE;
+ } else if (strcmp(optarg, "little") == 0) {
+ ctl.endianness = ENDIANNESS_LITTLE;
+ } else if (strcmp(optarg, "big") == 0) {
+ ctl.endianness = ENDIANNESS_BIG;
+ } else {
+ errx(EXIT_FAILURE,
+ _("invalid endianness %s is not supported"), optarg);
+ }
+ break;
+ case 'o':
+ ctl.offset = str2unum_or_err(optarg,
+ 10, _("Invalid offset"), SINT_MAX(off_t));
+ break;
+ case 's':
+ ctl.filesz = strtosize_or_err(optarg, _("Invalid size"));
+ break;
+ case 'F':
+ ctl.file = 1;
+ break;
case 'V':
print_version(EXIT_SUCCESS);
break;
#ifdef HAVE_LIBUUID
if(opt_uuid) {
- if (uuid_parse(opt_uuid, uuid_dat) != 0)
+ if (strcmp(opt_uuid, "clear") == 0)
+ uuid_clear(uuid_dat);
+ else if (strcmp(opt_uuid, "random") == 0)
+ uuid_generate_random(uuid_dat);
+ else if (strcmp(opt_uuid, "time") == 0)
+ uuid_generate_time(uuid_dat);
+ else if (uuid_parse(opt_uuid, uuid_dat) != 0)
errx(EXIT_FAILURE, _("error: parsing UUID failed"));
} else
uuid_generate(uuid_dat);
if (ctl.npages > UINT32_MAX) {
/* true when swap is bigger than 17.59 terabytes */
ctl.npages = UINT32_MAX;
- warnx(_("warning: truncating swap area to %llu KiB"),
- ctl.npages * ctl.pagesize / 1024);
+ if (!ctl.quiet)
+ warnx(_("warning: truncating swap area to %llu KiB"),
+ ctl.npages * ctl.pagesize / 1024);
}
if (is_mounted(ctl.devname))
open_device(&ctl);
permMask = S_ISBLK(ctl.devstat.st_mode) ? 07007 : 07077;
- if ((ctl.devstat.st_mode & permMask) != 0)
+ if (!ctl.quiet && (ctl.devstat.st_mode & permMask) != 0)
warnx(_("%s: insecure permissions %04o, fix with: chmod %04o %s"),
ctl.devname, ctl.devstat.st_mode & 07777,
~permMask & 0666, ctl.devname);
- if (getuid() == 0 && S_ISREG(ctl.devstat.st_mode) && ctl.devstat.st_uid != 0)
+ if (!ctl.quiet
+ && getuid() == 0 && S_ISREG(ctl.devstat.st_mode) && ctl.devstat.st_uid != 0)
warnx(_("%s: insecure file owner %d, fix with: chown 0:0 %s"),
ctl.devname, ctl.devstat.st_uid, ctl.devname);
if (ctl.check)
check_blocks(&ctl);
#ifdef HAVE_LINUX_FIEMAP_H
- if (S_ISREG(ctl.devstat.st_mode))
+ if (!ctl.quiet && S_ISREG(ctl.devstat.st_mode))
check_extents(&ctl);
#endif
wipe_device(&ctl);
assert(ctl.hdr);
- ctl.hdr->version = version;
- ctl.hdr->last_page = ctl.npages - 1;
- ctl.hdr->nr_badpages = ctl.nbadpages;
+ ctl.hdr->version = cpu32_to_endianness(version, ctl.endianness);
+ ctl.hdr->last_page = cpu32_to_endianness(ctl.npages - 1, ctl.endianness);
+ ctl.hdr->nr_badpages = cpu32_to_endianness(ctl.nbadpages, ctl.endianness);
if ((ctl.npages - MIN_GOODPAGES) < ctl.nbadpages)
errx(EXIT_FAILURE, _("Unable to set up swap-space: unreadable"));
sz = (ctl.npages - ctl.nbadpages - 1) * ctl.pagesize;
strsz = size_to_human_string(SIZE_SUFFIX_SPACE | SIZE_SUFFIX_3LETTER, sz);
- printf(_("Setting up swapspace version %d, size = %s (%"PRIu64" bytes)\n"),
- version, strsz, sz);
+ if (!ctl.quiet)
+ printf(_("Setting up swapspace version %d, size = %s (%"PRIu64" bytes)\n"),
+ version, strsz, sz);
free(strsz);
set_signature(&ctl);
#ifdef HAVE_LIBSELINUX
if (S_ISREG(ctl.devstat.st_mode) && is_selinux_enabled() > 0) {
- char *context_string, *oldcontext;
+ const char *context_string;
+ char *oldcontext;
context_t newcontext;
if (fgetfilecon(ctl.fd, &oldcontext) < 0) {
err(EXIT_FAILURE,
_("%s: unable to obtain selinux file label"),
ctl.devname);
- if (matchpathcon(ctl.devname, ctl.devstat.st_mode, &oldcontext))
- errx(EXIT_FAILURE, _("unable to matchpathcon()"));
+ if (ul_selinux_get_default_context(ctl.devname,
+ ctl.devstat.st_mode, &oldcontext))
+ errx(EXIT_FAILURE,
+ _("%s: unable to obtain default selinux file label"),
+ ctl.devname);
}
if (!(newcontext = context_new(oldcontext)))
errx(EXIT_FAILURE, _("unable to create new selinux context"));
projects / thirdparty / util-linux.git / blobdiff