swap.c revision 7c478bd95313f5f23a4c958a745db2134aa03244
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License, Version 1.0 only
* (the "License"). You may not use this file except in compliance
* with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/*
* Copyright 2004 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
/* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
/* All Rights Reserved */
/*
* University Copyright- Copyright (c) 1982, 1986, 1988
* The Regents of the University of California
* All Rights Reserved
*
* University Acknowledgment- Portions of this document are derived from
* software developed by the University of California, Berkeley, and its
* contributors.
*/
#pragma ident "%Z%%M% %I% %E% SMI"
/*
* Swap administrative interface
*/
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <dirent.h>
#include <sys/sysmacros.h>
#include <fcntl.h>
#include <locale.h>
#include <libintl.h>
static char *prognamep;
static void usage(void);
static int doswap(void);
static int list(void);
int
{
int c, flag = 0;
int ret;
char *pathname;
#if !defined(TEXT_DOMAIN)
#define TEXT_DOMAIN "SYS_TEST"
#endif
(void) textdomain(TEXT_DOMAIN);
if (argc < 2) {
usage();
exit(1);
}
char *char_p;
switch (c) {
case 'l': /* list all the swap devices */
usage();
exit(1);
}
break;
case 's':
usage();
exit(1);
}
break;
case 'd':
/*
* The argument for starting offset is optional.
* If no argument is specified, the entire swap file
* is added although this will fail if a non-zero
* starting offset was specified when added.
*/
usage();
exit(1);
}
errno = 0;
gettext("error in [low block]\n"));
exit(1);
}
}
break;
case 'a':
/*
* The arguments for starting offset and number of
* blocks are optional. If only the starting offset
* is specified, all the blocks to the end of the swap
* file will be added. If no starting offset is
* specified, the entire swap file is assumed.
*/
usage();
exit(1);
}
if (*optarg != '/') {
gettext("%s: path must be absolute\n"),
exit(1);
}
errno = 0;
gettext("error in [low block]\n"));
exit(1);
}
}
errno = 0;
gettext("error in [nbr of blocks]\n"));
exit(1);
}
}
break;
case '1':
break;
case '2':
break;
case '?':
usage();
exit(1);
}
}
if (!flag) {
usage();
exit(1);
}
return (ret);
}
static void
usage(void)
{
" [nbr of blocks]\n"), prognamep);
}
/*
* Implement:
* #define ctok(x) ((ctob(x))>>10)
* in a machine independent way. (Both assume a click > 1k)
*/
static size_t
{
static int factor = -1;
if (factor == -1)
}
static int
doswap(void)
{
/*
* max = total amount of swap space including physical memory
* ai.ani_max = MAX(anoninfo.ani_resv, anoninfo.ani_max) +
* availrmem - swapfs_minfree;
* ai.ani_free = amount of unallocated anonymous memory
* (ie. = resverved_unallocated + unreserved)
* ai.ani_free = anoninfo.ani_free + (availrmem - swapfs_minfree);
* ai.ani_resv = total amount of reserved anonymous memory
* ai.ani_resv = anoninfo.ani_resv;
*
* allocated = anon memory not free
* reserved = anon memory reserved but not allocated
* available = anon memory not reserved
*/
return (2);
}
/*
* TRANSLATION_NOTE
* Translations (if any) of these keywords should match with
* translations (if any) of the swap.1M man page keywords for
* -s option: "allocated", "reserved", "used", "available"
*/
%luk used, %luk available\n"),
return (0);
}
static int
list(void)
{
int i;
char *path;
int num;
return (2);
}
if (num == 0) {
return (1);
}
== NULL) {
gettext("Malloc failed. Please try later.\n"));
return (2);
}
gettext("Malloc failed. Please try later.\n"));
return (2);
}
path += MAXPATHLEN;
}
return (2);
}
/*
* TRANSLATION_NOTE
* Following translations for "swap -l" should account for for
* alignment of header and output.
* The first translation is for the header. If the alignment
* of the header changes, change the next 5 formats as needed
* to make alignment of output agree with alignment of the header.
* The next four translations are four cases for printing the
* 1st & 2nd fields.
* The next translation is for printing the 3rd, 4th & 5th fields.
*
* Translations (if any) of the following keywords should match the
* translations (if any) of the swap.1M man page keywords for
* -l option: "swapfile", "dev", "swaplo", "blocks", "free"
*/
(void) printf(
gettext("swapfile dev swaplo blocks free\n"));
else
else
fullpath);
else {
else
}
{
int diskblks_per_page =
}
(void) printf(" INDEL\n");
else
(void) printf("\n");
}
return (0);
}
static void
dumpadm_err(const char *warning)
{
"run dumpadm(1M) to verify dump configuration\n"));
}
static int
{
int fd;
switch (errno) {
case (ENOSYS):
"%s: Invalid operation for this filesystem type\n"),
path);
break;
default:
break;
}
return (2);
}
/*
* device is set to. If this returns ENODEV, we just deleted the
* dump device, so try to change the dump device to another swap
*/
char dumpdev[MAXPATHLEN];
"invoking dumpadm(1M) -d swap to "
"select new dump device\n"), path);
/*
*/
"Warning: failed to execute dumpadm -d swap"));
} else
"Warning: failed to check dump device"));
}
} else
return (0);
}
/*
* swapres_t structure units are in 512-blocks
*/
static int
{
/*
* Before adding swap, we first check to see if we have a dump
* device configured. If we don't (errno == ENODEV), and if
* to attempt to reconfigure the dump device to the new swap.
*/
char dumpdev[MAXPATHLEN];
have_dumpdev = 0;
else
"Warning: failed to check dump device"));
}
switch (errno) {
case (ENOSYS):
"%s: Invalid operation for this filesystem type\n"),
path);
break;
case (EEXIST):
"%s: Overlapping swap files are not allowed\n"),
path);
break;
default:
break;
}
return (2);
}
/*
* If the swapctl worked and we don't have a dump device, and /etc
* is part of a writeable filesystem, then run dumpadm -ud swap.
* If /etc (presumably part of /) is still mounted read-only, then
* dumpadm will fail to write its config file, so there's no point
* running it now. This also avoids spurious messages during boot
* when the first swapadd takes place, at which point / is still ro.
* Similarly, if swapadd invoked us with -1 or -2 (but root is
* writeable), we don't want to modify the dump device because
* we would lose the user's previous setting.
*/
(void) printf(
gettext("operating system crash dump was previously "
"disabled --\ninvoking dumpadm(1M) -d swap to select "
"new dump device\n"));
"Warning: failed to execute dumpadm -d swap"));
}
return (0);
}
static int
{
struct stat64 f;
return (errno);
}
gettext("\"%s\" is not valid for swapping.\n"
"It must be a block device or a regular file with the\n"
"\"save user text on execution\" bit set.\n"),
pathname);
return (EINVAL);
}
if (length == 0)
/*
* "f.st_blocks < 8" because the first eight
* 512-byte sectors are always skipped
*/
pathname);
return (EINVAL);
}
if (offset < 0) {
gettext("%s: low block is invalid\n"),
pathname);
return (EINVAL);
}
/*
* "need > f.st_blocks" to account for indirect blocks
* Note:
* This can be fooled by a file large enough to
* contain indirect blocks that also contains holes.
* However, we don't know (and don't want to know)
* about the underlying storage implementation.
* But, if it doesn't have at least this many blocks,
* there must be a hole.
*/
"\"%s\" may contain holes - can't swap on it.\n"),
pathname);
return (EINVAL);
}
}
/*
* else, we cannot get st_size for S_ISBLK device and
* no meaningful checking can be done.
*/
return (0);
}