[COL_LABEL] = { "LABEL", 0.20, 0, N_("swap label")},
};
-/* control struct */
-struct swapon_ctl {
- const char *device; /* device or file to be turned on */
- const char *options; /* fstab-compatible option string */
+
+/* swap area properties */
+struct swap_prop {
+ int discard; /* discard policy */
+ int priority; /* non-prioritized swap by default */
+ int no_fail; /* skip device if not exist */
+};
+
+/* device description */
+struct swap_device {
+ const char *path; /* device or file to be turned on */
const char *label; /* swap label */
const char *uuid; /* unique identifier */
- int discard; /* discard policy */
+ unsigned int pagesize;
+};
+
+/* control struct */
+struct swapon_ctl {
int columns[ARRAY_SIZE(infos) * 2]; /* --show columns */
- int ncolumns; /* number of columns */
- int priority; /* non-prioritized swap by default */
- unsigned int pagesize; /* swap page size */
+ int ncolumns; /* number of columns */
+
+ struct swap_prop props; /* global settings for all devices */
+
unsigned int
all:1, /* turn on all swap devices */
bytes:1, /* display --show in bytes */
fix_page_size:1, /* reinitialize page size */
- no_fail:1, /* skip devices that do not exist */
no_heading:1, /* toggle --show headers */
raw:1, /* toggle --show alignment */
show:1, /* display --show information */
}
/* calls mkswap */
-static int swap_reinitialize(struct swapon_ctl *ctl)
+static int swap_reinitialize(struct swap_device *dev)
{
pid_t pid;
int status, ret;
char const *cmd[7];
int idx=0;
- warnx(_("%s: reinitializing the swap."), ctl->device);
+ assert(dev);
+ assert(dev->path);
+
+ warnx(_("%s: reinitializing the swap."), dev->path);
switch ((pid=fork())) {
case -1: /* fork error */
}
cmd[idx++] = "mkswap";
- if (ctl->label) {
+ if (dev->label) {
cmd[idx++] = "-L";
- cmd[idx++] = ctl->label;
+ cmd[idx++] = dev->label;
}
- if (ctl->uuid) {
+ if (dev->uuid) {
cmd[idx++] = "-U";
- cmd[idx++] = ctl->uuid;
+ cmd[idx++] = dev->uuid;
}
- cmd[idx++] = ctl->device;
+ cmd[idx++] = dev->path;
cmd[idx++] = NULL;
execvp(cmd[0], (char * const *) cmd);
err(EXIT_FAILURE, _("failed to execute %s"), cmd[0]);
return -1; /* error */
}
-static int swap_rewrite_signature(const struct swapon_ctl *ctl)
+/* Replaces unwanted SWSUSPEND signature with swap signature */
+static int swap_rewrite_signature(const struct swap_device *dev)
{
int fd, rc = -1;
- fd = open(ctl->device, O_WRONLY);
+ assert(dev);
+ assert(dev->path);
+ assert(dev->pagesize);
+
+ fd = open(dev->path, O_WRONLY);
if (fd == -1) {
- warn(_("cannot open %s"), ctl->device);
+ warn(_("cannot open %s"), dev->path);
return -1;
}
- if (lseek(fd, ctl->pagesize - SWAP_SIGNATURE_SZ, SEEK_SET) < 0) {
- warn(_("%s: lseek failed"), ctl->device);
+ if (lseek(fd, dev->pagesize - SWAP_SIGNATURE_SZ, SEEK_SET) < 0) {
+ warn(_("%s: lseek failed"), dev->path);
goto err;
}
if (write(fd, (void *) SWAP_SIGNATURE,
SWAP_SIGNATURE_SZ) != SWAP_SIGNATURE_SZ) {
- warn(_("%s: write signature failed"), ctl->device);
+ warn(_("%s: write signature failed"), dev->path);
goto err;
}
rc = 0;
err:
if (close_fd(fd) != 0) {
- warn(_("write failed: %s"), ctl->device);
+ warn(_("write failed: %s"), dev->path);
rc = -1;
}
return rc;
static int swap_detect_signature(const char *buf, int *sig)
{
+ assert(buf);
+ assert(sig);
+
if (memcmp(buf, SWAP_SIGNATURE, SWAP_SIGNATURE_SZ) == 0)
*sig = SIG_SWAPSPACE;
return 1;
}
-static char *swap_get_header(struct swapon_ctl *ctl, int fd, int *sig)
+static char *swap_get_header(int fd, int *sig, unsigned int *pagesize)
{
char *buf;
ssize_t datasz;
unsigned int page;
- ctl->pagesize = 0;
+ assert(sig);
+ assert(pagesize);
+
+ *pagesize = 0;
*sig = 0;
buf = xmalloc(MAX_PAGESIZE);
if (datasz < 0 || (size_t) datasz < (page - SWAP_SIGNATURE_SZ))
break;
if (swap_detect_signature(buf + page - SWAP_SIGNATURE_SZ, sig)) {
- ctl->pagesize = page;
+ *pagesize = page;
break;
}
}
- if (ctl->pagesize)
+ if (*pagesize)
return buf;
err:
free(buf);
}
/* returns real size of swap space */
-static unsigned long long swap_get_size(const struct swapon_ctl *ctl, const char *hdr)
+static unsigned long long swap_get_size(const struct swap_device *dev,
+ const char *hdr)
{
unsigned int last_page = 0;
const unsigned int swap_version = SWAP_VERSION;
- int flip = 0;
struct swap_header_v1_2 *s;
+ assert(dev);
+ assert(dev->pagesize > 0);
+
s = (struct swap_header_v1_2 *) hdr;
- if (s->version == swap_version) {
+
+ if (s->version == swap_version)
last_page = s->last_page;
- } else if (swab32(s->version) == swap_version) {
- flip = 1;
+ else if (swab32(s->version) == swap_version)
last_page = swab32(s->last_page);
- }
- if (ctl->verbose)
- warnx(_("%s: found swap signature: version %ud, "
- "page-size %d, %s byte order"),
- ctl->device,
- swap_version,
- ctl->pagesize / 1024,
- flip ? _("different") : _("same"));
-
- return ((unsigned long long) last_page + 1) * ctl->pagesize;
+
+ return ((unsigned long long) last_page + 1) * dev->pagesize;
}
-static void swap_get_info(struct swapon_ctl *ctl, const char *hdr)
+static void swap_get_info(struct swap_device *dev, const char *hdr)
{
struct swap_header_v1_2 *s = (struct swap_header_v1_2 *) hdr;
+ assert(dev);
+
if (s && *s->volume_name)
- ctl->label = xstrdup(s->volume_name);
+ dev->label = xstrdup(s->volume_name);
if (s && *s->uuid) {
const unsigned char *u = s->uuid;
u[0], u[1], u[2], u[3],
u[4], u[5], u[6], u[7],
u[8], u[9], u[10], u[11], u[12], u[13], u[14], u[15]);
- ctl->uuid = xstrdup(str);
+ dev->uuid = xstrdup(str);
}
}
-static int swapon_checks(struct swapon_ctl *ctl)
+static int swapon_checks(const struct swapon_ctl *ctl, struct swap_device *dev)
{
struct stat st;
int fd = -1, sig;
unsigned long long devsize = 0;
int permMask;
- fd = open(ctl->device, O_RDONLY);
+ assert(ctl);
+ assert(dev);
+ assert(dev->path);
+
+ fd = open(dev->path, O_RDONLY);
if (fd == -1) {
- warn(_("cannot open %s"), ctl->device);
+ warn(_("cannot open %s"), dev->path);
goto err;
}
if (fstat(fd, &st) < 0) {
- warn(_("stat of %s failed"), ctl->device);
+ warn(_("stat of %s failed"), dev->path);
goto err;
}
permMask = S_ISBLK(st.st_mode) ? 07007 : 07077;
if ((st.st_mode & permMask) != 0)
warnx(_("%s: insecure permissions %04o, %04o suggested."),
- ctl->device, st.st_mode & 07777,
+ dev->path, st.st_mode & 07777,
~permMask & 0666);
if (S_ISREG(st.st_mode) && st.st_uid != 0)
warnx(_("%s: insecure file owner %d, 0 (root) suggested."),
- ctl->device, st.st_uid);
+ dev->path, st.st_uid);
/* test for holes by LBT */
if (S_ISREG(st.st_mode)) {
if (st.st_blocks * 512 < st.st_size) {
warnx(_("%s: skipping - it appears to have holes."),
- ctl->device);
+ dev->path);
goto err;
}
devsize = st.st_size;
}
if (S_ISBLK(st.st_mode) && blkdev_get_size(fd, &devsize)) {
- warnx(_("%s: get size failed"), ctl->device);
+ warnx(_("%s: get size failed"), dev->path);
goto err;
}
- hdr = swap_get_header(ctl, fd, &sig);
+ hdr = swap_get_header(fd, &sig, &dev->pagesize);
if (!hdr) {
- warnx(_("%s: read swap header failed"), ctl->device);
+ warnx(_("%s: read swap header failed"), dev->path);
goto err;
}
- if (sig == SIG_SWAPSPACE && ctl->pagesize) {
- unsigned long long swapsize =
- swap_get_size(ctl, hdr);
+ if (ctl->verbose)
+ warnx(_("%s: found signature [pagesize=%d, signature=%s]"),
+ dev->path,
+ dev->pagesize,
+ sig == SIG_SWAPSPACE ? "swap" :
+ sig == SIG_SWSUSPEND ? "suspend" : "unknown");
+
+ if (sig == SIG_SWAPSPACE && dev->pagesize) {
+ unsigned long long swapsize = swap_get_size(dev, hdr);
int syspg = getpagesize();
if (ctl->verbose)
warnx(_("%s: pagesize=%d, swapsize=%llu, devsize=%llu"),
- ctl->device, ctl->pagesize, swapsize, devsize);
+ dev->path, dev->pagesize, swapsize, devsize);
if (swapsize > devsize) {
if (ctl->verbose)
warnx(_("%s: last_page 0x%08llx is larger"
" than actual size of swapspace"),
- ctl->device, swapsize);
- } else if (syspg < 0 || (unsigned int) syspg != ctl->pagesize) {
+ dev->path, swapsize);
+
+ } else if (syspg < 0 || (unsigned int) syspg != dev->pagesize) {
if (ctl->fix_page_size) {
int rc;
- swap_get_info(ctl, hdr);
+ swap_get_info(dev, hdr);
warnx(_("%s: swap format pagesize does not match."),
- ctl->device);
- rc = swap_reinitialize(ctl);
+ dev->path);
+ rc = swap_reinitialize(dev);
if (rc < 0)
goto err;
} else
warnx(_("%s: swap format pagesize does not match. "
"(Use --fixpgsz to reinitialize it.)"),
- ctl->device);
+ dev->path);
}
} else if (sig == SIG_SWSUSPEND) {
/* We have to reinitialize swap with old (=useless) software suspend
*/
warnx(_("%s: software suspend data detected. "
"Rewriting the swap signature."),
- ctl->device);
- if (swap_rewrite_signature(ctl) < 0)
+ dev->path);
+ if (swap_rewrite_signature(dev) < 0)
goto err;
}
return -1;
}
-static int do_swapon(struct swapon_ctl *ctl, const char *spec, int canonic)
+static int do_swapon(const struct swapon_ctl *ctl,
+ const struct swap_prop *prop,
+ const char *spec,
+ int canonic)
{
+ struct swap_device dev = { .path = NULL };
int status;
int flags = 0;
+ int priority;
- /* all initilized by do_swapon() */
- ctl->device = ctl->label = ctl->uuid = NULL;
-
- if (ctl->verbose)
- printf(_("swapon %s\n"), ctl->device);
+ assert(ctl);
+ assert(prop);
if (!canonic) {
- ctl->device = mnt_resolve_spec(spec, mntcache);
- if (!ctl->device)
+ dev.path = mnt_resolve_spec(spec, mntcache);
+ if (!dev.path)
return cannot_find(spec);
} else
- ctl->device = spec;
+ dev.path = spec;
- if (swapon_checks(ctl))
+ priority = prop->priority;
+
+ if (swapon_checks(ctl, &dev))
return -1;
#ifdef SWAP_FLAG_PREFER
- if (ctl->priority >= 0) {
- if (ctl->priority > SWAP_FLAG_PRIO_MASK)
- ctl->priority = SWAP_FLAG_PRIO_MASK;
+ if (priority >= 0) {
+ if (priority > SWAP_FLAG_PRIO_MASK)
+ priority = SWAP_FLAG_PRIO_MASK;
+
flags = SWAP_FLAG_PREFER
- | ((ctl->priority & SWAP_FLAG_PRIO_MASK)
+ | ((priority & SWAP_FLAG_PRIO_MASK)
<< SWAP_FLAG_PRIO_SHIFT);
}
#endif
* Validate the discard flags passed and set them
* accordingly before calling sys_swapon.
*/
- if (ctl->discard && !(ctl->discard & ~SWAP_FLAGS_DISCARD_VALID)) {
+ if (prop->discard && !(prop->discard & ~SWAP_FLAGS_DISCARD_VALID)) {
/*
* If we get here with both discard policy flags set,
* we just need to tell the kernel to enable discards
* and it will do correctly, just as we expect.
*/
- if ((ctl->discard & SWAP_FLAG_DISCARD_ONCE) &&
- (ctl->discard & SWAP_FLAG_DISCARD_PAGES))
+ if ((prop->discard & SWAP_FLAG_DISCARD_ONCE) &&
+ (prop->discard & SWAP_FLAG_DISCARD_PAGES))
flags |= SWAP_FLAG_DISCARD;
else
- flags |= ctl->discard;
+ flags |= prop->discard;
}
- status = swapon(ctl->device, flags);
+ if (ctl->verbose)
+ printf(_("swapon %s\n"), dev.path);
+
+ status = swapon(dev.path, flags);
if (status < 0)
- warn(_("%s: swapon failed"), ctl->device);
+ warn(_("%s: swapon failed"), dev.path);
return status;
}
static int swapon_by_label(struct swapon_ctl *ctl, const char *label)
{
char *device = mnt_resolve_tag("LABEL", label, mntcache);
- return device ? do_swapon(ctl, device, TRUE) : cannot_find(label);
+ return device ? do_swapon(ctl, &ctl->props, device, TRUE) : cannot_find(label);
}
static int swapon_by_uuid(struct swapon_ctl *ctl, const char *uuid)
{
char *device = mnt_resolve_tag("UUID", uuid, mntcache);
- return device ? do_swapon(ctl, device, TRUE) : cannot_find(uuid);
+ return device ? do_swapon(ctl, &ctl->props, device, TRUE) : cannot_find(uuid);
}
/* -o <options> or fstab */
-static int parse_options(struct swapon_ctl *ctl)
+static int parse_options(struct swap_prop *props, const char *options)
{
char *arg = NULL;
- assert(ctl->options);
+ assert(props);
+ assert(options);
- if (mnt_optstr_get_option(ctl->options, "nofail", NULL, 0) == 0)
- ctl->no_fail = 1;
+ if (mnt_optstr_get_option(options, "nofail", NULL, 0) == 0)
+ props->no_fail = 1;
- if (mnt_optstr_get_option(ctl->options, "discard", &arg, NULL) == 0) {
- ctl->discard |= SWAP_FLAG_DISCARD;
+ if (mnt_optstr_get_option(options, "discard", &arg, NULL) == 0) {
+ props->discard |= SWAP_FLAG_DISCARD;
if (arg) {
/* only single-time discards are wanted */
if (strcmp(arg, "once") == 0)
- ctl->discard |= SWAP_FLAG_DISCARD_ONCE;
+ props->discard |= SWAP_FLAG_DISCARD_ONCE;
/* do discard for every released swap page */
if (strcmp(arg, "pages") == 0)
- ctl->discard |= SWAP_FLAG_DISCARD_PAGES;
- }
+ props->discard |= SWAP_FLAG_DISCARD_PAGES;
+ }
}
arg = NULL;
- if (mnt_optstr_get_option(ctl->options, "pri", &arg, NULL) == 0 && arg)
- ctl->priority = atoi(arg);
+ if (mnt_optstr_get_option(options, "pri", &arg, NULL) == 0 && arg)
+ props->priority = atoi(arg);
return 0;
}
/* defaults */
const char *opts;
const char *device;
+ struct swap_prop prop; /* per device setting */
- if (mnt_fs_get_option(fs, "noauto", NULL, NULL) == 0)
+ if (mnt_fs_get_option(fs, "noauto", NULL, NULL) == 0) {
+ if (ctl->verbose)
+ warnx(_("%s: noauto option -- ignored"), mnt_fs_get_source(fs));
continue;
+ }
+
+ /* default setting */
+ prop = ctl->props;
+ /* overwrite default by setting from fstab */
opts = mnt_fs_get_options(fs);
if (opts)
- parse_options(ctl);
+ parse_options(&prop, opts);
+ /* convert LABEL=, UUID= etc. from fstab to device name */
device = mnt_resolve_spec(mnt_fs_get_source(fs), mntcache);
if (!device) {
- if (!ctl->no_fail)
+ if (!prop.no_fail)
status |= cannot_find(mnt_fs_get_source(fs));
continue;
}
- if (!is_active_swap(device) &&
- (!ctl->no_fail || !access(device, R_OK)))
- status |= do_swapon(ctl, device, TRUE);
+ if (is_active_swap(device)) {
+ if (ctl->verbose)
+ warnx(_("%s: already active -- ignored"), device);
+ continue;
+ }
+
+ if (prop.no_fail && access(device, R_OK) != 0) {
+ if (ctl->verbose)
+ warnx(_("%s: unaccessible -- ignored"), device);
+ continue;
+ }
+
+ /* swapon */
+ status |= do_swapon(ctl, &prop, device, TRUE);
}
mnt_free_iter(itr);
{
int status = 0, c;
size_t i;
+ char *options = NULL;
enum {
BYTES_OPTION = CHAR_MAX + 1,
};
int excl_st[ARRAY_SIZE(excl)] = UL_EXCL_STATUS_INIT;
- struct swapon_ctl ctl = { .priority = -1 };
+ struct swapon_ctl ctl;
setlocale(LC_ALL, "");
bindtextdomain(PACKAGE, LOCALEDIR);
textdomain(PACKAGE);
atexit(close_stdout);
+ memset(&ctl, 0, sizeof(struct swapon_ctl));
+ ctl.props.priority = -1;
+
mnt_init_debug(0);
mntcache = mnt_new_cache();
usage(stdout);
break;
case 'o':
- ctl.options = optarg;
+ options = optarg;
break;
case 'p': /* priority */
- ctl.priority = strtos16_or_err(optarg,
+ ctl.props.priority = strtos16_or_err(optarg,
_("failed to parse priority"));
break;
case 'L':
add_uuid(optarg);
break;
case 'd':
- ctl.discard |= SWAP_FLAG_DISCARD;
+ ctl.props.discard |= SWAP_FLAG_DISCARD;
if (optarg) {
if (*optarg == '=')
optarg++;
if (strcmp(optarg, "once") == 0)
- ctl.discard |= SWAP_FLAG_DISCARD_ONCE;
+ ctl.props.discard |= SWAP_FLAG_DISCARD_ONCE;
else if (strcmp(optarg, "pages") == 0)
- ctl.discard |= SWAP_FLAG_DISCARD_PAGES;
+ ctl.props.discard |= SWAP_FLAG_DISCARD_PAGES;
else
errx(EXIT_FAILURE, _("unsupported discard policy: %s"), optarg);
}
break;
case 'e': /* ifexists */
- ctl.no_fail = 1;
+ ctl.props.no_fail = 1;
break;
case 'f':
ctl.fix_page_size = 1;
return status;
}
- if (ctl.no_fail && !ctl.all)
+ if (ctl.props.no_fail && !ctl.all)
usage(stderr);
if (ctl.all)
status |= swapon_all(&ctl);
- if (ctl.options)
- parse_options(&ctl);
+ if (options)
+ parse_options(&ctl.props, options);
for (i = 0; i < numof_labels(); i++)
status |= swapon_by_label(&ctl, get_label(i));
status |= swapon_by_uuid(&ctl, get_uuid(i));
while (*argv != NULL)
- status |= do_swapon(&ctl, *argv++, FALSE);
+ status |= do_swapon(&ctl, &ctl.props, *argv++, FALSE);
free_tables();
mnt_unref_cache(mntcache);
projects / thirdparty / util-linux.git / commitdiff
