1 /* vi: set sw=4 ts=4: */
3 * mkswap.c - set up a linux swap device
5 * (C) 1991 Linus Torvalds. This file may be redistributed as per
10 * 20.12.91 - time began. Got VM working yesterday by doing this by hand.
12 * Usage: mkswap [-c] [-vN] [-f] device [size-in-blocks]
14 * -c for readability checking. (Use it unless you are SURE!)
15 * -vN for swap areas version N. (Only N=0,1 known today.)
16 * -f for forcing swap creation even if it would smash partition table.
18 * The device may be a block device or an image of one, but this isn't
19 * enforced (but it's not much fun on a character device :-).
21 * Patches from jaggy@purplet.demon.co.uk (Mike Jagdis) to make the
22 * size-in-blocks parameter optional added Wed Feb 8 10:33:43 1995.
24 * Version 1 swap area code (for kernel 2.1.117), aeb, 981010.
26 * Sparc fixes, jj@ultra.linux.cz (Jakub Jelinek), 981201 - mangled by aeb.
27 * V1_MAX_PAGES fixes, jj, 990325.
29 * 1999-02-22 Arkadiusz Mi¶kiewicz <misiek@misiek.eu.org>
30 * - added Native Language Support
32 * from util-linux -- adapted for busybox by
33 * Erik Andersen <andersee@debian.org>. I ripped out Native Language
34 * Support, made some stuff smaller, and fitted for life in busybox.
44 #include <sys/ioctl.h> /* for _IO */
45 #include <sys/utsname.h>
47 #include <asm/page.h> /* for PAGE_SIZE and PAGE_SHIFT */
48 /* we also get PAGE_SIZE via getpagesize() */
52 #define BLKGETSIZE 0x1260
54 /* same on i386, m68k, arm; different on alpha, mips, sparc, ppc */
55 #define BLKGETSIZE _IO(0x12,96)
58 static char *device_name = NULL;
60 static long PAGES = 0;
62 static int badpages = 0;
63 static int version = -1;
65 #define MAKE_VERSION(p,q,r) (65536*(p) + 256*(q) + (r))
67 static int linux_version_code(void)
69 struct utsname my_utsname;
72 if (uname(&my_utsname) == 0) {
73 p = atoi(strtok(my_utsname.release, "."));
74 q = atoi(strtok(NULL, "."));
75 r = atoi(strtok(NULL, "."));
76 return MAKE_VERSION(p, q, r);
82 * The definition of the union swap_header uses the constant PAGE_SIZE.
83 * Unfortunately, on some architectures this depends on the hardware model,
84 * and can only be found at run time -- we use getpagesize().
88 static int *signature_page;
90 struct swap_header_v1 {
91 char bootbits[1024]; /* Space for disklabel etc. */
93 unsigned int last_page;
94 unsigned int nr_badpages;
95 unsigned int padding[125];
96 unsigned int badpages[1];
99 static void init_signature_page()
101 pagesize = getpagesize();
104 if (pagesize != PAGE_SIZE)
105 errorMsg("Assuming pages of size %d\n", pagesize);
107 signature_page = (int *) xmalloc(pagesize);
108 memset(signature_page, 0, pagesize);
109 p = (struct swap_header_v1 *) signature_page;
112 static void write_signature(char *sig)
114 char *sp = (char *) signature_page;
116 strncpy(sp + pagesize - 10, sig, 10);
119 #define V0_MAX_PAGES (8 * (pagesize - 10))
120 /* Before 2.2.0pre9 */
121 #define V1_OLD_MAX_PAGES ((0x7fffffff / pagesize) - 1)
123 error if nr of pages >= SWP_OFFSET(SWP_ENTRY(0,~0UL))
125 #define SWP_ENTRY(type,offset) (((type) << 1) | ((offset) << 8))
126 #define SWP_OFFSET(entry) ((entry) >> 8)
127 on the various architectures. Below the result - yuk.
129 Machine pagesize SWP_ENTRY SWP_OFFSET bound+1 oldbound+2
130 i386 2^12 o<<8 e>>8 1<<24 1<<19
131 mips 2^12 o<<15 e>>15 1<<17 1<<19
132 alpha 2^13 o<<40 e>>40 1<<24 1<<18
133 m68k 2^12 o<<12 e>>12 1<<20 1<<19
134 sparc 2^{12,13} (o&0x3ffff)<<9 (e>>9)&0x3ffff 1<<18 1<<{19,18}
135 sparc64 2^13 o<<13 e>>13 1<<51 1<<18
136 ppc 2^12 o<<8 e>>8 1<<24 1<<19
137 armo 2^{13,14,15} o<<8 e>>8 1<<24 1<<{18,17,16}
138 armv 2^12 o<<9 e>>9 1<<23 1<<19
140 assuming that longs have 64 bits on alpha and sparc64 and 32 bits elsewhere.
142 The bad part is that we need to know this since the kernel will
143 refuse a swap space if it is too large.
145 /* patch from jj - why does this differ from the above? */
146 #if defined(__alpha__)
147 #define V1_MAX_PAGES ((1 << 24) - 1)
148 #elif defined(__mips__)
149 #define V1_MAX_PAGES ((1 << 17) - 1)
150 #elif defined(__sparc_v9__)
151 #define V1_MAX_PAGES ((3 << 29) - 1)
152 #elif defined(__sparc__)
153 #define V1_MAX_PAGES (pagesize == 8192 ? ((3 << 29) - 1) : ((1 << 18) - 1))
155 #define V1_MAX_PAGES V1_OLD_MAX_PAGES
157 /* man page now says:
158 The maximum useful size of a swap area now depends on the architecture.
159 It is roughly 2GB on i386, PPC, m68k, ARM, 1GB on sparc, 512MB on mips,
160 128GB on alpha and 3TB on sparc64.
163 #define MAX_BADPAGES ((pagesize-1024-128*sizeof(int)-10)/sizeof(int))
165 static void bit_set(unsigned int *addr, unsigned int nr)
169 addr += nr / (8 * sizeof(int));
172 m = 1 << (nr & (8 * sizeof(int) - 1));
177 static int bit_test_and_clear(unsigned int *addr, unsigned int nr)
181 addr += nr / (8 * sizeof(int));
184 m = 1 << (nr & (8 * sizeof(int) - 1));
191 void die(const char *str)
193 errorMsg("%s\n", str);
197 void page_ok(int page)
200 bit_set(signature_page, page);
203 void page_bad(int page)
206 bit_test_and_clear(signature_page, page);
208 if (badpages == MAX_BADPAGES)
209 die("too many bad pages");
210 p->badpages[badpages] = page;
215 void check_blocks(void)
217 unsigned int current_page;
221 buffer = xmalloc(pagesize);
223 while (current_page < PAGES) {
225 page_ok(current_page++);
228 if (do_seek && lseek(DEV, current_page * pagesize, SEEK_SET) !=
229 current_page * pagesize)
230 die("seek failed in check_blocks");
231 if ((do_seek = (pagesize != read(DEV, buffer, pagesize)))) {
232 page_bad(current_page++);
235 page_ok(current_page++);
238 printf("one bad page\n");
239 else if (badpages > 1)
240 printf("%d bad pages\n", badpages);
243 static long valid_offset(int fd, int offset)
247 if (lseek(fd, offset, 0) < 0)
249 if (read(fd, &ch, 1) < 1)
254 static int find_size(int fd)
256 unsigned int high, low;
259 for (high = 1; high > 0 && valid_offset(fd, high); high *= 2)
261 while (low < high - 1) {
262 const int mid = (low + high) / 2;
264 if (valid_offset(fd, mid))
272 /* return size in pages, to avoid integer overflow */
273 static long get_size(const char *file)
278 fd = open(file, O_RDONLY);
283 if (ioctl(fd, BLKGETSIZE, &size) >= 0) {
284 int sectors_per_page = pagesize / 512;
286 size /= sectors_per_page;
288 size = find_size(fd) / pagesize;
294 int mkswap_main(int argc, char **argv)
304 init_signature_page(); /* get pagesize */
308 if (argv[0][0] != '-') {
310 int blocks_per_page = pagesize / 1024;
312 PAGES = strtol(argv[0], &tmp, 0) / blocks_per_page;
316 device_name = argv[0];
318 switch (argv[0][1]) {
326 version = atoi(argv[0] + 2);
334 errorMsg("error: Nowhere to set up swap on?\n");
337 sz = get_size(device_name);
340 } else if (PAGES > sz && !force) {
341 errorMsg("error: size %ld is larger than device size %d\n",
342 PAGES * (pagesize / 1024), sz * (pagesize / 1024));
347 if (PAGES <= V0_MAX_PAGES)
349 else if (linux_version_code() < MAKE_VERSION(2, 1, 117))
351 else if (pagesize < 2048)
356 if (version != 0 && version != 1) {
357 errorMsg("error: unknown version %d\n", version);
361 errorMsg("error: swap area needs to be at least %ldkB\n",
362 (long) (10 * pagesize / 1024));
366 maxpages = ((version == 0) ? V0_MAX_PAGES : V1_MAX_PAGES);
369 maxpages = V0_MAX_PAGES;
370 else if (linux_version_code() >= MAKE_VERSION(2, 2, 1))
371 maxpages = V1_MAX_PAGES;
373 maxpages = V1_OLD_MAX_PAGES;
374 if (maxpages > V1_MAX_PAGES)
375 maxpages = V1_MAX_PAGES;
378 if (PAGES > maxpages) {
380 errorMsg("warning: truncating swap area to %ldkB\n",
381 PAGES * pagesize / 1024);
384 DEV = open(device_name, O_RDWR);
385 if (DEV < 0 || fstat(DEV, &statbuf) < 0) {
389 if (!S_ISBLK(statbuf.st_mode))
391 else if (statbuf.st_rdev == 0x0300 || statbuf.st_rdev == 0x0340)
392 die("Will not try to make swapdevice on '%s'");
395 if (!force && version == 0) {
396 /* Don't overwrite partition table unless forced */
397 unsigned char *buffer = (unsigned char *) signature_page;
398 unsigned short *q, sum;
400 if (read(DEV, buffer, 512) != 512)
401 die("fatal: first page unreadable");
402 if (buffer[508] == 0xDA && buffer[509] == 0xBE) {
403 q = (unsigned short *) (buffer + 510);
404 for (sum = 0; q >= (unsigned short *) buffer;)
407 errorMsg("Device '%s' contains a valid Sun disklabel.\n"
408 "This probably means creating v0 swap would destroy your partition table\n"
409 "No swap created. If you really want to create swap v0 on that device, use\n"
410 "the -f option to force it.\n", device_name);
417 if (version == 0 || check)
419 if (version == 0 && !bit_test_and_clear(signature_page, 0))
420 die("fatal: first page unreadable");
422 p->version = version;
423 p->last_page = PAGES - 1;
424 p->nr_badpages = badpages;
427 goodpages = PAGES - badpages - 1;
429 die("Unable to set up swap-space: unreadable");
430 printf("Setting up swapspace version %d, size = %ld bytes\n",
431 version, (long) (goodpages * pagesize));
432 write_signature((version == 0) ? "SWAP-SPACE" : "SWAPSPACE2");
434 offset = ((version == 0) ? 0 : 1024);
435 if (lseek(DEV, offset, SEEK_SET) != offset)
436 die("unable to rewind swap-device");
437 if (write(DEV, (char *) signature_page + offset, pagesize - offset)
438 != pagesize - offset)
439 die("unable to write signature page");
442 * A subsequent swapon() will fail if the signature
443 * is not actually on disk. (This is a kernel bug.)