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>
46 #include <asm/page.h> /* for PAGE_SIZE and PAGE_SHIFT */
47 /* we also get PAGE_SIZE via getpagesize() */
51 #define BLKGETSIZE 0x1260
53 /* same on i386, m68k, arm; different on alpha, mips, sparc, ppc */
54 #define BLKGETSIZE _IO(0x12,96)
57 static char *device_name = NULL;
59 static long PAGES = 0;
61 static int badpages = 0;
62 static int version = -1;
64 #define MAKE_VERSION(p,q,r) (65536*(p) + 256*(q) + (r))
66 static int linux_version_code(void)
68 struct utsname my_utsname;
71 if (uname(&my_utsname) == 0) {
72 p = atoi(strtok(my_utsname.release, "."));
73 q = atoi(strtok(NULL, "."));
74 r = atoi(strtok(NULL, "."));
75 return MAKE_VERSION(p, q, r);
81 * The definition of the union swap_header uses the constant PAGE_SIZE.
82 * Unfortunately, on some architectures this depends on the hardware model,
83 * and can only be found at run time -- we use getpagesize().
87 static int *signature_page;
89 struct swap_header_v1 {
90 char bootbits[1024]; /* Space for disklabel etc. */
92 unsigned int last_page;
93 unsigned int nr_badpages;
94 unsigned int padding[125];
95 unsigned int badpages[1];
98 static void init_signature_page()
100 pagesize = getpagesize();
103 if (pagesize != PAGE_SIZE)
104 errorMsg("Assuming pages of size %d\n", pagesize);
106 signature_page = (int *) xmalloc(pagesize);
107 memset(signature_page, 0, pagesize);
108 p = (struct swap_header_v1 *) signature_page;
111 static void write_signature(char *sig)
113 char *sp = (char *) signature_page;
115 strncpy(sp + pagesize - 10, sig, 10);
118 #define V0_MAX_PAGES (8 * (pagesize - 10))
119 /* Before 2.2.0pre9 */
120 #define V1_OLD_MAX_PAGES ((0x7fffffff / pagesize) - 1)
122 error if nr of pages >= SWP_OFFSET(SWP_ENTRY(0,~0UL))
124 #define SWP_ENTRY(type,offset) (((type) << 1) | ((offset) << 8))
125 #define SWP_OFFSET(entry) ((entry) >> 8)
126 on the various architectures. Below the result - yuk.
128 Machine pagesize SWP_ENTRY SWP_OFFSET bound+1 oldbound+2
129 i386 2^12 o<<8 e>>8 1<<24 1<<19
130 mips 2^12 o<<15 e>>15 1<<17 1<<19
131 alpha 2^13 o<<40 e>>40 1<<24 1<<18
132 m68k 2^12 o<<12 e>>12 1<<20 1<<19
133 sparc 2^{12,13} (o&0x3ffff)<<9 (e>>9)&0x3ffff 1<<18 1<<{19,18}
134 sparc64 2^13 o<<13 e>>13 1<<51 1<<18
135 ppc 2^12 o<<8 e>>8 1<<24 1<<19
136 armo 2^{13,14,15} o<<8 e>>8 1<<24 1<<{18,17,16}
137 armv 2^12 o<<9 e>>9 1<<23 1<<19
139 assuming that longs have 64 bits on alpha and sparc64 and 32 bits elsewhere.
141 The bad part is that we need to know this since the kernel will
142 refuse a swap space if it is too large.
144 /* patch from jj - why does this differ from the above? */
145 #if defined(__alpha__)
146 #define V1_MAX_PAGES ((1 << 24) - 1)
147 #elif defined(__mips__)
148 #define V1_MAX_PAGES ((1 << 17) - 1)
149 #elif defined(__sparc_v9__)
150 #define V1_MAX_PAGES ((3 << 29) - 1)
151 #elif defined(__sparc__)
152 #define V1_MAX_PAGES (pagesize == 8192 ? ((3 << 29) - 1) : ((1 << 18) - 1))
154 #define V1_MAX_PAGES V1_OLD_MAX_PAGES
156 /* man page now says:
157 The maximum useful size of a swap area now depends on the architecture.
158 It is roughly 2GB on i386, PPC, m68k, ARM, 1GB on sparc, 512MB on mips,
159 128GB on alpha and 3TB on sparc64.
162 #define MAX_BADPAGES ((pagesize-1024-128*sizeof(int)-10)/sizeof(int))
164 static void bit_set(unsigned int *addr, unsigned int nr)
168 addr += nr / (8 * sizeof(int));
171 m = 1 << (nr & (8 * sizeof(int) - 1));
176 static int bit_test_and_clear(unsigned int *addr, unsigned int nr)
180 addr += nr / (8 * sizeof(int));
183 m = 1 << (nr & (8 * sizeof(int) - 1));
190 void die(const char *str)
192 errorMsg("%s\n", str);
196 void page_ok(int page)
199 bit_set(signature_page, page);
202 void page_bad(int page)
205 bit_test_and_clear(signature_page, page);
207 if (badpages == MAX_BADPAGES)
208 die("too many bad pages");
209 p->badpages[badpages] = page;
214 void check_blocks(void)
216 unsigned int current_page;
220 buffer = xmalloc(pagesize);
222 while (current_page < PAGES) {
224 page_ok(current_page++);
227 if (do_seek && lseek(DEV, current_page * pagesize, SEEK_SET) !=
228 current_page * pagesize)
229 die("seek failed in check_blocks");
230 if ((do_seek = (pagesize != read(DEV, buffer, pagesize)))) {
231 page_bad(current_page++);
234 page_ok(current_page++);
237 printf("one bad page\n");
238 else if (badpages > 1)
239 printf("%d bad pages\n", badpages);
242 static long valid_offset(int fd, int offset)
246 if (lseek(fd, offset, 0) < 0)
248 if (read(fd, &ch, 1) < 1)
253 static int find_size(int fd)
255 unsigned int high, low;
258 for (high = 1; high > 0 && valid_offset(fd, high); high *= 2)
260 while (low < high - 1) {
261 const int mid = (low + high) / 2;
263 if (valid_offset(fd, mid))
271 /* return size in pages, to avoid integer overflow */
272 static long get_size(const char *file)
277 fd = open(file, O_RDONLY);
282 if (ioctl(fd, BLKGETSIZE, &size) >= 0) {
283 int sectors_per_page = pagesize / 512;
285 size /= sectors_per_page;
287 size = find_size(fd) / pagesize;
293 int mkswap_main(int argc, char **argv)
303 init_signature_page(); /* get pagesize */
307 if (argv[0][0] != '-') {
309 int blocks_per_page = pagesize / 1024;
311 PAGES = strtol(argv[0], &tmp, 0) / blocks_per_page;
315 device_name = argv[0];
317 switch (argv[0][1]) {
325 version = atoi(argv[0] + 2);
333 errorMsg("error: Nowhere to set up swap on?\n");
336 sz = get_size(device_name);
339 } else if (PAGES > sz && !force) {
340 errorMsg("error: size %ld is larger than device size %d\n",
341 PAGES * (pagesize / 1024), sz * (pagesize / 1024));
346 if (PAGES <= V0_MAX_PAGES)
348 else if (linux_version_code() < MAKE_VERSION(2, 1, 117))
350 else if (pagesize < 2048)
355 if (version != 0 && version != 1) {
356 errorMsg("error: unknown version %d\n", version);
360 errorMsg("error: swap area needs to be at least %ldkB\n",
361 (long) (10 * pagesize / 1024));
365 maxpages = ((version == 0) ? V0_MAX_PAGES : V1_MAX_PAGES);
368 maxpages = V0_MAX_PAGES;
369 else if (linux_version_code() >= MAKE_VERSION(2, 2, 1))
370 maxpages = V1_MAX_PAGES;
372 maxpages = V1_OLD_MAX_PAGES;
373 if (maxpages > V1_MAX_PAGES)
374 maxpages = V1_MAX_PAGES;
377 if (PAGES > maxpages) {
379 errorMsg("warning: truncating swap area to %ldkB\n",
380 PAGES * pagesize / 1024);
383 DEV = open(device_name, O_RDWR);
384 if (DEV < 0 || fstat(DEV, &statbuf) < 0) {
388 if (!S_ISBLK(statbuf.st_mode))
390 else if (statbuf.st_rdev == 0x0300 || statbuf.st_rdev == 0x0340)
391 die("Will not try to make swapdevice on '%s'");
394 if (!force && version == 0) {
395 /* Don't overwrite partition table unless forced */
396 unsigned char *buffer = (unsigned char *) signature_page;
397 unsigned short *q, sum;
399 if (read(DEV, buffer, 512) != 512)
400 die("fatal: first page unreadable");
401 if (buffer[508] == 0xDA && buffer[509] == 0xBE) {
402 q = (unsigned short *) (buffer + 510);
403 for (sum = 0; q >= (unsigned short *) buffer;)
406 errorMsg("Device '%s' contains a valid Sun disklabel.\n"
407 "This probably means creating v0 swap would destroy your partition table\n"
408 "No swap created. If you really want to create swap v0 on that device, use\n"
409 "the -f option to force it.\n", device_name);
416 if (version == 0 || check)
418 if (version == 0 && !bit_test_and_clear(signature_page, 0))
419 die("fatal: first page unreadable");
421 p->version = version;
422 p->last_page = PAGES - 1;
423 p->nr_badpages = badpages;
426 goodpages = PAGES - badpages - 1;
428 die("Unable to set up swap-space: unreadable");
429 printf("Setting up swapspace version %d, size = %ld bytes\n",
430 version, (long) (goodpages * pagesize));
431 write_signature((version == 0) ? "SWAP-SPACE" : "SWAPSPACE2");
433 offset = ((version == 0) ? 0 : 1024);
434 if (lseek(DEV, offset, SEEK_SET) != offset)
435 die("unable to rewind swap-device");
436 if (write(DEV, (char *) signature_page + offset, pagesize - offset)
437 != pagesize - offset)
438 die("unable to write signature page");
441 * A subsequent swapon() will fail if the signature
442 * is not actually on disk. (This is a kernel bug.)