Erik Andersen | e49d5ec | 2000-02-08 19:58:47 +0000 | [diff] [blame] | 1 | /* vi: set sw=4 ts=4: */ |
Eric Andersen | cc8ed39 | 1999-10-05 16:24:54 +0000 | [diff] [blame] | 2 | /* |
| 3 | * mkswap.c - set up a linux swap device |
| 4 | * |
| 5 | * (C) 1991 Linus Torvalds. This file may be redistributed as per |
| 6 | * the Linux copyright. |
| 7 | */ |
| 8 | |
| 9 | /* |
| 10 | * 20.12.91 - time began. Got VM working yesterday by doing this by hand. |
| 11 | * |
Eric Andersen | e77ae3a | 1999-10-19 20:03:34 +0000 | [diff] [blame] | 12 | * Usage: mkswap [-c] [-vN] [-f] device [size-in-blocks] |
Eric Andersen | cc8ed39 | 1999-10-05 16:24:54 +0000 | [diff] [blame] | 13 | * |
Eric Andersen | e77ae3a | 1999-10-19 20:03:34 +0000 | [diff] [blame] | 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. |
Eric Andersen | cc8ed39 | 1999-10-05 16:24:54 +0000 | [diff] [blame] | 17 | * |
Eric Andersen | e77ae3a | 1999-10-19 20:03:34 +0000 | [diff] [blame] | 18 | * The device may be a block device or an image of one, but this isn't |
Eric Andersen | cc8ed39 | 1999-10-05 16:24:54 +0000 | [diff] [blame] | 19 | * enforced (but it's not much fun on a character device :-). |
| 20 | * |
| 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. |
Eric Andersen | e77ae3a | 1999-10-19 20:03:34 +0000 | [diff] [blame] | 23 | * |
| 24 | * Version 1 swap area code (for kernel 2.1.117), aeb, 981010. |
| 25 | * |
| 26 | * Sparc fixes, jj@ultra.linux.cz (Jakub Jelinek), 981201 - mangled by aeb. |
| 27 | * V1_MAX_PAGES fixes, jj, 990325. |
| 28 | * |
| 29 | * 1999-02-22 Arkadiusz Mi¶kiewicz <misiek@misiek.eu.org> |
| 30 | * - added Native Language Support |
| 31 | * |
| 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. |
| 35 | * |
Eric Andersen | cc8ed39 | 1999-10-05 16:24:54 +0000 | [diff] [blame] | 36 | */ |
| 37 | |
Eric Andersen | 3570a34 | 2000-09-25 21:45:58 +0000 | [diff] [blame] | 38 | #include "busybox.h" |
Eric Andersen | cc8ed39 | 1999-10-05 16:24:54 +0000 | [diff] [blame] | 39 | #include <stdio.h> |
| 40 | #include <unistd.h> |
| 41 | #include <string.h> |
| 42 | #include <fcntl.h> |
| 43 | #include <stdlib.h> |
Erik Andersen | e49d5ec | 2000-02-08 19:58:47 +0000 | [diff] [blame] | 44 | #include <sys/ioctl.h> /* for _IO */ |
Eric Andersen | e77ae3a | 1999-10-19 20:03:34 +0000 | [diff] [blame] | 45 | #include <sys/utsname.h> |
Erik Andersen | e49d5ec | 2000-02-08 19:58:47 +0000 | [diff] [blame] | 46 | #include <asm/page.h> /* for PAGE_SIZE and PAGE_SHIFT */ |
Eric Andersen | e77ae3a | 1999-10-19 20:03:34 +0000 | [diff] [blame] | 47 | /* we also get PAGE_SIZE via getpagesize() */ |
Eric Andersen | cc8ed39 | 1999-10-05 16:24:54 +0000 | [diff] [blame] | 48 | |
Eric Andersen | e77ae3a | 1999-10-19 20:03:34 +0000 | [diff] [blame] | 49 | #ifndef _IO |
| 50 | /* pre-1.3.45 */ |
| 51 | #define BLKGETSIZE 0x1260 |
| 52 | #else |
| 53 | /* same on i386, m68k, arm; different on alpha, mips, sparc, ppc */ |
| 54 | #define BLKGETSIZE _IO(0x12,96) |
Eric Andersen | cc8ed39 | 1999-10-05 16:24:54 +0000 | [diff] [blame] | 55 | #endif |
| 56 | |
Erik Andersen | e49d5ec | 2000-02-08 19:58:47 +0000 | [diff] [blame] | 57 | static char *device_name = NULL; |
Eric Andersen | cc8ed39 | 1999-10-05 16:24:54 +0000 | [diff] [blame] | 58 | static int DEV = -1; |
| 59 | static long PAGES = 0; |
Eric Andersen | e77ae3a | 1999-10-19 20:03:34 +0000 | [diff] [blame] | 60 | static int check = 0; |
Eric Andersen | cc8ed39 | 1999-10-05 16:24:54 +0000 | [diff] [blame] | 61 | static int badpages = 0; |
Eric Andersen | e77ae3a | 1999-10-19 20:03:34 +0000 | [diff] [blame] | 62 | static int version = -1; |
Eric Andersen | cc8ed39 | 1999-10-05 16:24:54 +0000 | [diff] [blame] | 63 | |
Eric Andersen | e77ae3a | 1999-10-19 20:03:34 +0000 | [diff] [blame] | 64 | #define MAKE_VERSION(p,q,r) (65536*(p) + 256*(q) + (r)) |
Eric Andersen | cc8ed39 | 1999-10-05 16:24:54 +0000 | [diff] [blame] | 65 | |
Eric Andersen | e77ae3a | 1999-10-19 20:03:34 +0000 | [diff] [blame] | 66 | /* |
| 67 | * The definition of the union swap_header uses the constant PAGE_SIZE. |
| 68 | * Unfortunately, on some architectures this depends on the hardware model, |
| 69 | * and can only be found at run time -- we use getpagesize(). |
| 70 | */ |
| 71 | |
| 72 | static int pagesize; |
| 73 | static int *signature_page; |
| 74 | |
| 75 | struct swap_header_v1 { |
Erik Andersen | e49d5ec | 2000-02-08 19:58:47 +0000 | [diff] [blame] | 76 | char bootbits[1024]; /* Space for disklabel etc. */ |
Eric Andersen | e77ae3a | 1999-10-19 20:03:34 +0000 | [diff] [blame] | 77 | unsigned int version; |
| 78 | unsigned int last_page; |
| 79 | unsigned int nr_badpages; |
| 80 | unsigned int padding[125]; |
| 81 | unsigned int badpages[1]; |
| 82 | } *p; |
| 83 | |
Erik Andersen | e49d5ec | 2000-02-08 19:58:47 +0000 | [diff] [blame] | 84 | static void init_signature_page() |
| 85 | { |
Eric Andersen | e77ae3a | 1999-10-19 20:03:34 +0000 | [diff] [blame] | 86 | pagesize = getpagesize(); |
| 87 | |
| 88 | #ifdef PAGE_SIZE |
| 89 | if (pagesize != PAGE_SIZE) |
Mark Whitley | f57c944 | 2000-12-07 19:56:48 +0000 | [diff] [blame] | 90 | error_msg("Assuming pages of size %d\n", pagesize); |
Eric Andersen | e77ae3a | 1999-10-19 20:03:34 +0000 | [diff] [blame] | 91 | #endif |
Erik Andersen | 0d068a2 | 2000-03-21 22:32:57 +0000 | [diff] [blame] | 92 | signature_page = (int *) xmalloc(pagesize); |
Erik Andersen | e49d5ec | 2000-02-08 19:58:47 +0000 | [diff] [blame] | 93 | memset(signature_page, 0, pagesize); |
Eric Andersen | e77ae3a | 1999-10-19 20:03:34 +0000 | [diff] [blame] | 94 | p = (struct swap_header_v1 *) signature_page; |
| 95 | } |
| 96 | |
Erik Andersen | e49d5ec | 2000-02-08 19:58:47 +0000 | [diff] [blame] | 97 | static void write_signature(char *sig) |
| 98 | { |
Eric Andersen | e77ae3a | 1999-10-19 20:03:34 +0000 | [diff] [blame] | 99 | char *sp = (char *) signature_page; |
| 100 | |
Erik Andersen | e49d5ec | 2000-02-08 19:58:47 +0000 | [diff] [blame] | 101 | strncpy(sp + pagesize - 10, sig, 10); |
Eric Andersen | e77ae3a | 1999-10-19 20:03:34 +0000 | [diff] [blame] | 102 | } |
| 103 | |
| 104 | #define V0_MAX_PAGES (8 * (pagesize - 10)) |
| 105 | /* Before 2.2.0pre9 */ |
| 106 | #define V1_OLD_MAX_PAGES ((0x7fffffff / pagesize) - 1) |
| 107 | /* Since 2.2.0pre9: |
| 108 | error if nr of pages >= SWP_OFFSET(SWP_ENTRY(0,~0UL)) |
| 109 | with variations on |
| 110 | #define SWP_ENTRY(type,offset) (((type) << 1) | ((offset) << 8)) |
| 111 | #define SWP_OFFSET(entry) ((entry) >> 8) |
| 112 | on the various architectures. Below the result - yuk. |
| 113 | |
| 114 | Machine pagesize SWP_ENTRY SWP_OFFSET bound+1 oldbound+2 |
| 115 | i386 2^12 o<<8 e>>8 1<<24 1<<19 |
| 116 | mips 2^12 o<<15 e>>15 1<<17 1<<19 |
| 117 | alpha 2^13 o<<40 e>>40 1<<24 1<<18 |
| 118 | m68k 2^12 o<<12 e>>12 1<<20 1<<19 |
| 119 | sparc 2^{12,13} (o&0x3ffff)<<9 (e>>9)&0x3ffff 1<<18 1<<{19,18} |
| 120 | sparc64 2^13 o<<13 e>>13 1<<51 1<<18 |
| 121 | ppc 2^12 o<<8 e>>8 1<<24 1<<19 |
| 122 | armo 2^{13,14,15} o<<8 e>>8 1<<24 1<<{18,17,16} |
| 123 | armv 2^12 o<<9 e>>9 1<<23 1<<19 |
| 124 | |
| 125 | assuming that longs have 64 bits on alpha and sparc64 and 32 bits elsewhere. |
| 126 | |
| 127 | The bad part is that we need to know this since the kernel will |
| 128 | refuse a swap space if it is too large. |
| 129 | */ |
| 130 | /* patch from jj - why does this differ from the above? */ |
| 131 | #if defined(__alpha__) |
| 132 | #define V1_MAX_PAGES ((1 << 24) - 1) |
| 133 | #elif defined(__mips__) |
| 134 | #define V1_MAX_PAGES ((1 << 17) - 1) |
| 135 | #elif defined(__sparc_v9__) |
| 136 | #define V1_MAX_PAGES ((3 << 29) - 1) |
| 137 | #elif defined(__sparc__) |
| 138 | #define V1_MAX_PAGES (pagesize == 8192 ? ((3 << 29) - 1) : ((1 << 18) - 1)) |
| 139 | #else |
| 140 | #define V1_MAX_PAGES V1_OLD_MAX_PAGES |
| 141 | #endif |
| 142 | /* man page now says: |
| 143 | The maximum useful size of a swap area now depends on the architecture. |
| 144 | It is roughly 2GB on i386, PPC, m68k, ARM, 1GB on sparc, 512MB on mips, |
| 145 | 128GB on alpha and 3TB on sparc64. |
| 146 | */ |
| 147 | |
| 148 | #define MAX_BADPAGES ((pagesize-1024-128*sizeof(int)-10)/sizeof(int)) |
| 149 | |
Erik Andersen | e49d5ec | 2000-02-08 19:58:47 +0000 | [diff] [blame] | 150 | static void bit_set(unsigned int *addr, unsigned int nr) |
Eric Andersen | cc8ed39 | 1999-10-05 16:24:54 +0000 | [diff] [blame] | 151 | { |
| 152 | unsigned int r, m; |
| 153 | |
| 154 | addr += nr / (8 * sizeof(int)); |
Erik Andersen | e49d5ec | 2000-02-08 19:58:47 +0000 | [diff] [blame] | 155 | |
Eric Andersen | cc8ed39 | 1999-10-05 16:24:54 +0000 | [diff] [blame] | 156 | r = *addr; |
| 157 | m = 1 << (nr & (8 * sizeof(int) - 1)); |
Erik Andersen | e49d5ec | 2000-02-08 19:58:47 +0000 | [diff] [blame] | 158 | |
Eric Andersen | cc8ed39 | 1999-10-05 16:24:54 +0000 | [diff] [blame] | 159 | *addr = r | m; |
Eric Andersen | cc8ed39 | 1999-10-05 16:24:54 +0000 | [diff] [blame] | 160 | } |
| 161 | |
Erik Andersen | e49d5ec | 2000-02-08 19:58:47 +0000 | [diff] [blame] | 162 | static int bit_test_and_clear(unsigned int *addr, unsigned int nr) |
Eric Andersen | cc8ed39 | 1999-10-05 16:24:54 +0000 | [diff] [blame] | 163 | { |
| 164 | unsigned int r, m; |
| 165 | |
| 166 | addr += nr / (8 * sizeof(int)); |
Erik Andersen | e49d5ec | 2000-02-08 19:58:47 +0000 | [diff] [blame] | 167 | |
Eric Andersen | cc8ed39 | 1999-10-05 16:24:54 +0000 | [diff] [blame] | 168 | r = *addr; |
| 169 | m = 1 << (nr & (8 * sizeof(int) - 1)); |
Erik Andersen | e49d5ec | 2000-02-08 19:58:47 +0000 | [diff] [blame] | 170 | |
Eric Andersen | cc8ed39 | 1999-10-05 16:24:54 +0000 | [diff] [blame] | 171 | *addr = r & ~m; |
| 172 | return (r & m) != 0; |
| 173 | } |
| 174 | |
Eric Andersen | e77ae3a | 1999-10-19 20:03:34 +0000 | [diff] [blame] | 175 | |
Eric Andersen | 16fdbe8 | 2000-12-20 23:40:57 +0000 | [diff] [blame] | 176 | static void die(const char *str) |
Erik Andersen | e49d5ec | 2000-02-08 19:58:47 +0000 | [diff] [blame] | 177 | { |
Mark Whitley | f57c944 | 2000-12-07 19:56:48 +0000 | [diff] [blame] | 178 | error_msg("%s\n", str); |
Matt Kraai | 3e856ce | 2000-12-01 02:55:13 +0000 | [diff] [blame] | 179 | exit(EXIT_FAILURE); |
Eric Andersen | cc8ed39 | 1999-10-05 16:24:54 +0000 | [diff] [blame] | 180 | } |
| 181 | |
Eric Andersen | 16fdbe8 | 2000-12-20 23:40:57 +0000 | [diff] [blame] | 182 | static void page_ok(int page) |
Erik Andersen | e49d5ec | 2000-02-08 19:58:47 +0000 | [diff] [blame] | 183 | { |
| 184 | if (version == 0) |
Eric Andersen | e77ae3a | 1999-10-19 20:03:34 +0000 | [diff] [blame] | 185 | bit_set(signature_page, page); |
| 186 | } |
Eric Andersen | cc8ed39 | 1999-10-05 16:24:54 +0000 | [diff] [blame] | 187 | |
Eric Andersen | 16fdbe8 | 2000-12-20 23:40:57 +0000 | [diff] [blame] | 188 | static void page_bad(int page) |
Erik Andersen | e49d5ec | 2000-02-08 19:58:47 +0000 | [diff] [blame] | 189 | { |
Eric Andersen | e77ae3a | 1999-10-19 20:03:34 +0000 | [diff] [blame] | 190 | if (version == 0) |
| 191 | bit_test_and_clear(signature_page, page); |
| 192 | else { |
| 193 | if (badpages == MAX_BADPAGES) |
| 194 | die("too many bad pages"); |
| 195 | p->badpages[badpages] = page; |
| 196 | } |
| 197 | badpages++; |
| 198 | } |
| 199 | |
Eric Andersen | 16fdbe8 | 2000-12-20 23:40:57 +0000 | [diff] [blame] | 200 | static void check_blocks(void) |
Erik Andersen | e49d5ec | 2000-02-08 19:58:47 +0000 | [diff] [blame] | 201 | { |
Eric Andersen | cc8ed39 | 1999-10-05 16:24:54 +0000 | [diff] [blame] | 202 | unsigned int current_page; |
| 203 | int do_seek = 1; |
Eric Andersen | e77ae3a | 1999-10-19 20:03:34 +0000 | [diff] [blame] | 204 | char *buffer; |
Eric Andersen | cc8ed39 | 1999-10-05 16:24:54 +0000 | [diff] [blame] | 205 | |
Erik Andersen | 0d068a2 | 2000-03-21 22:32:57 +0000 | [diff] [blame] | 206 | buffer = xmalloc(pagesize); |
Eric Andersen | cc8ed39 | 1999-10-05 16:24:54 +0000 | [diff] [blame] | 207 | current_page = 0; |
| 208 | while (current_page < PAGES) { |
Eric Andersen | e77ae3a | 1999-10-19 20:03:34 +0000 | [diff] [blame] | 209 | if (!check) { |
| 210 | page_ok(current_page++); |
Eric Andersen | cc8ed39 | 1999-10-05 16:24:54 +0000 | [diff] [blame] | 211 | continue; |
Eric Andersen | cc8ed39 | 1999-10-05 16:24:54 +0000 | [diff] [blame] | 212 | } |
Erik Andersen | e49d5ec | 2000-02-08 19:58:47 +0000 | [diff] [blame] | 213 | if (do_seek && lseek(DEV, current_page * pagesize, SEEK_SET) != |
| 214 | current_page * pagesize) |
Eric Andersen | cc8ed39 | 1999-10-05 16:24:54 +0000 | [diff] [blame] | 215 | die("seek failed in check_blocks"); |
Eric Andersen | e77ae3a | 1999-10-19 20:03:34 +0000 | [diff] [blame] | 216 | if ((do_seek = (pagesize != read(DEV, buffer, pagesize)))) { |
| 217 | page_bad(current_page++); |
Eric Andersen | cc8ed39 | 1999-10-05 16:24:54 +0000 | [diff] [blame] | 218 | continue; |
| 219 | } |
Eric Andersen | e77ae3a | 1999-10-19 20:03:34 +0000 | [diff] [blame] | 220 | page_ok(current_page++); |
Eric Andersen | cc8ed39 | 1999-10-05 16:24:54 +0000 | [diff] [blame] | 221 | } |
Eric Andersen | e77ae3a | 1999-10-19 20:03:34 +0000 | [diff] [blame] | 222 | if (badpages == 1) |
| 223 | printf("one bad page\n"); |
| 224 | else if (badpages > 1) |
| 225 | printf("%d bad pages\n", badpages); |
Eric Andersen | cc8ed39 | 1999-10-05 16:24:54 +0000 | [diff] [blame] | 226 | } |
| 227 | |
Erik Andersen | e49d5ec | 2000-02-08 19:58:47 +0000 | [diff] [blame] | 228 | static long valid_offset(int fd, int offset) |
Eric Andersen | cc8ed39 | 1999-10-05 16:24:54 +0000 | [diff] [blame] | 229 | { |
| 230 | char ch; |
| 231 | |
Erik Andersen | e49d5ec | 2000-02-08 19:58:47 +0000 | [diff] [blame] | 232 | if (lseek(fd, offset, 0) < 0) |
Eric Andersen | cc8ed39 | 1999-10-05 16:24:54 +0000 | [diff] [blame] | 233 | return 0; |
Erik Andersen | e49d5ec | 2000-02-08 19:58:47 +0000 | [diff] [blame] | 234 | if (read(fd, &ch, 1) < 1) |
Eric Andersen | cc8ed39 | 1999-10-05 16:24:54 +0000 | [diff] [blame] | 235 | return 0; |
| 236 | return 1; |
| 237 | } |
| 238 | |
Erik Andersen | e49d5ec | 2000-02-08 19:58:47 +0000 | [diff] [blame] | 239 | static int find_size(int fd) |
Eric Andersen | cc8ed39 | 1999-10-05 16:24:54 +0000 | [diff] [blame] | 240 | { |
Eric Andersen | e77ae3a | 1999-10-19 20:03:34 +0000 | [diff] [blame] | 241 | unsigned int high, low; |
Eric Andersen | cc8ed39 | 1999-10-05 16:24:54 +0000 | [diff] [blame] | 242 | |
| 243 | low = 0; |
Erik Andersen | e49d5ec | 2000-02-08 19:58:47 +0000 | [diff] [blame] | 244 | for (high = 1; high > 0 && valid_offset(fd, high); high *= 2) |
Eric Andersen | cc8ed39 | 1999-10-05 16:24:54 +0000 | [diff] [blame] | 245 | low = high; |
Erik Andersen | e49d5ec | 2000-02-08 19:58:47 +0000 | [diff] [blame] | 246 | while (low < high - 1) { |
Eric Andersen | cc8ed39 | 1999-10-05 16:24:54 +0000 | [diff] [blame] | 247 | const int mid = (low + high) / 2; |
| 248 | |
Erik Andersen | e49d5ec | 2000-02-08 19:58:47 +0000 | [diff] [blame] | 249 | if (valid_offset(fd, mid)) |
Eric Andersen | cc8ed39 | 1999-10-05 16:24:54 +0000 | [diff] [blame] | 250 | low = mid; |
| 251 | else |
| 252 | high = mid; |
| 253 | } |
Eric Andersen | cc8ed39 | 1999-10-05 16:24:54 +0000 | [diff] [blame] | 254 | return (low + 1); |
| 255 | } |
| 256 | |
Eric Andersen | e77ae3a | 1999-10-19 20:03:34 +0000 | [diff] [blame] | 257 | /* return size in pages, to avoid integer overflow */ |
Erik Andersen | e49d5ec | 2000-02-08 19:58:47 +0000 | [diff] [blame] | 258 | static long get_size(const char *file) |
Eric Andersen | cc8ed39 | 1999-10-05 16:24:54 +0000 | [diff] [blame] | 259 | { |
Erik Andersen | e49d5ec | 2000-02-08 19:58:47 +0000 | [diff] [blame] | 260 | int fd; |
| 261 | long size; |
Eric Andersen | cc8ed39 | 1999-10-05 16:24:54 +0000 | [diff] [blame] | 262 | |
Matt Kraai | a9819b2 | 2000-12-22 01:48:07 +0000 | [diff] [blame^] | 263 | if ((fd = open(file, O_RDONLY)) < 0) |
| 264 | perror_msg_and_die("%s", file); |
Eric Andersen | cc8ed39 | 1999-10-05 16:24:54 +0000 | [diff] [blame] | 265 | if (ioctl(fd, BLKGETSIZE, &size) >= 0) { |
Erik Andersen | e49d5ec | 2000-02-08 19:58:47 +0000 | [diff] [blame] | 266 | int sectors_per_page = pagesize / 512; |
| 267 | |
Eric Andersen | e77ae3a | 1999-10-19 20:03:34 +0000 | [diff] [blame] | 268 | size /= sectors_per_page; |
| 269 | } else { |
| 270 | size = find_size(fd) / pagesize; |
Eric Andersen | cc8ed39 | 1999-10-05 16:24:54 +0000 | [diff] [blame] | 271 | } |
Eric Andersen | cc8ed39 | 1999-10-05 16:24:54 +0000 | [diff] [blame] | 272 | close(fd); |
| 273 | return size; |
| 274 | } |
| 275 | |
Erik Andersen | e49d5ec | 2000-02-08 19:58:47 +0000 | [diff] [blame] | 276 | int mkswap_main(int argc, char **argv) |
Eric Andersen | cc8ed39 | 1999-10-05 16:24:54 +0000 | [diff] [blame] | 277 | { |
Erik Andersen | e49d5ec | 2000-02-08 19:58:47 +0000 | [diff] [blame] | 278 | char *tmp; |
Eric Andersen | e77ae3a | 1999-10-19 20:03:34 +0000 | [diff] [blame] | 279 | struct stat statbuf; |
| 280 | int sz; |
| 281 | int maxpages; |
| 282 | int goodpages; |
| 283 | int offset; |
| 284 | int force = 0; |
Eric Andersen | cc8ed39 | 1999-10-05 16:24:54 +0000 | [diff] [blame] | 285 | |
Erik Andersen | e49d5ec | 2000-02-08 19:58:47 +0000 | [diff] [blame] | 286 | init_signature_page(); /* get pagesize */ |
Eric Andersen | e77ae3a | 1999-10-19 20:03:34 +0000 | [diff] [blame] | 287 | |
| 288 | while (argc-- > 1) { |
Eric Andersen | cc8ed39 | 1999-10-05 16:24:54 +0000 | [diff] [blame] | 289 | argv++; |
Eric Andersen | e77ae3a | 1999-10-19 20:03:34 +0000 | [diff] [blame] | 290 | if (argv[0][0] != '-') { |
Eric Andersen | cc8ed39 | 1999-10-05 16:24:54 +0000 | [diff] [blame] | 291 | if (device_name) { |
Erik Andersen | e49d5ec | 2000-02-08 19:58:47 +0000 | [diff] [blame] | 292 | int blocks_per_page = pagesize / 1024; |
| 293 | |
| 294 | PAGES = strtol(argv[0], &tmp, 0) / blocks_per_page; |
Eric Andersen | e77ae3a | 1999-10-19 20:03:34 +0000 | [diff] [blame] | 295 | if (*tmp) |
Erik Andersen | e49d5ec | 2000-02-08 19:58:47 +0000 | [diff] [blame] | 296 | usage(mkswap_usage); |
Eric Andersen | cc8ed39 | 1999-10-05 16:24:54 +0000 | [diff] [blame] | 297 | } else |
| 298 | device_name = argv[0]; |
Eric Andersen | e77ae3a | 1999-10-19 20:03:34 +0000 | [diff] [blame] | 299 | } else { |
| 300 | switch (argv[0][1]) { |
Erik Andersen | e49d5ec | 2000-02-08 19:58:47 +0000 | [diff] [blame] | 301 | case 'c': |
| 302 | check = 1; |
| 303 | break; |
| 304 | case 'f': |
| 305 | force = 1; |
| 306 | break; |
| 307 | case 'v': |
| 308 | version = atoi(argv[0] + 2); |
| 309 | break; |
| 310 | default: |
| 311 | usage(mkswap_usage); |
Eric Andersen | cc8ed39 | 1999-10-05 16:24:54 +0000 | [diff] [blame] | 312 | } |
Eric Andersen | e77ae3a | 1999-10-19 20:03:34 +0000 | [diff] [blame] | 313 | } |
Eric Andersen | cc8ed39 | 1999-10-05 16:24:54 +0000 | [diff] [blame] | 314 | } |
Eric Andersen | e77ae3a | 1999-10-19 20:03:34 +0000 | [diff] [blame] | 315 | if (!device_name) { |
Mark Whitley | f57c944 | 2000-12-07 19:56:48 +0000 | [diff] [blame] | 316 | error_msg("error: Nowhere to set up swap on?\n"); |
Erik Andersen | e49d5ec | 2000-02-08 19:58:47 +0000 | [diff] [blame] | 317 | usage(mkswap_usage); |
Eric Andersen | e77ae3a | 1999-10-19 20:03:34 +0000 | [diff] [blame] | 318 | } |
| 319 | sz = get_size(device_name); |
| 320 | if (!PAGES) { |
| 321 | PAGES = sz; |
| 322 | } else if (PAGES > sz && !force) { |
Mark Whitley | f57c944 | 2000-12-07 19:56:48 +0000 | [diff] [blame] | 323 | error_msg("error: size %ld is larger than device size %d\n", |
Erik Andersen | e49d5ec | 2000-02-08 19:58:47 +0000 | [diff] [blame] | 324 | PAGES * (pagesize / 1024), sz * (pagesize / 1024)); |
Matt Kraai | 3e856ce | 2000-12-01 02:55:13 +0000 | [diff] [blame] | 325 | return EXIT_FAILURE; |
Eric Andersen | e77ae3a | 1999-10-19 20:03:34 +0000 | [diff] [blame] | 326 | } |
| 327 | |
| 328 | if (version == -1) { |
| 329 | if (PAGES <= V0_MAX_PAGES) |
| 330 | version = 0; |
Eric Andersen | ef936da | 2000-10-30 17:22:04 +0000 | [diff] [blame] | 331 | else if (get_kernel_revision() < MAKE_VERSION(2, 1, 117)) |
Eric Andersen | e77ae3a | 1999-10-19 20:03:34 +0000 | [diff] [blame] | 332 | version = 0; |
| 333 | else if (pagesize < 2048) |
| 334 | version = 0; |
| 335 | else |
| 336 | version = 1; |
| 337 | } |
| 338 | if (version != 0 && version != 1) { |
Mark Whitley | f57c944 | 2000-12-07 19:56:48 +0000 | [diff] [blame] | 339 | error_msg("error: unknown version %d\n", version); |
Erik Andersen | e49d5ec | 2000-02-08 19:58:47 +0000 | [diff] [blame] | 340 | usage(mkswap_usage); |
Eric Andersen | e77ae3a | 1999-10-19 20:03:34 +0000 | [diff] [blame] | 341 | } |
| 342 | if (PAGES < 10) { |
Mark Whitley | f57c944 | 2000-12-07 19:56:48 +0000 | [diff] [blame] | 343 | error_msg("error: swap area needs to be at least %ldkB\n", |
Matt Kraai | d537a95 | 2000-07-14 01:51:25 +0000 | [diff] [blame] | 344 | (long) (10 * pagesize / 1024)); |
Erik Andersen | e49d5ec | 2000-02-08 19:58:47 +0000 | [diff] [blame] | 345 | usage(mkswap_usage); |
Eric Andersen | e77ae3a | 1999-10-19 20:03:34 +0000 | [diff] [blame] | 346 | } |
| 347 | #if 0 |
| 348 | maxpages = ((version == 0) ? V0_MAX_PAGES : V1_MAX_PAGES); |
| 349 | #else |
| 350 | if (!version) |
| 351 | maxpages = V0_MAX_PAGES; |
Eric Andersen | ef936da | 2000-10-30 17:22:04 +0000 | [diff] [blame] | 352 | else if (get_kernel_revision() >= MAKE_VERSION(2, 2, 1)) |
Eric Andersen | e77ae3a | 1999-10-19 20:03:34 +0000 | [diff] [blame] | 353 | maxpages = V1_MAX_PAGES; |
| 354 | else { |
| 355 | maxpages = V1_OLD_MAX_PAGES; |
| 356 | if (maxpages > V1_MAX_PAGES) |
| 357 | maxpages = V1_MAX_PAGES; |
| 358 | } |
| 359 | #endif |
| 360 | if (PAGES > maxpages) { |
| 361 | PAGES = maxpages; |
Mark Whitley | f57c944 | 2000-12-07 19:56:48 +0000 | [diff] [blame] | 362 | error_msg("warning: truncating swap area to %ldkB\n", |
Matt Kraai | d537a95 | 2000-07-14 01:51:25 +0000 | [diff] [blame] | 363 | PAGES * pagesize / 1024); |
Eric Andersen | e77ae3a | 1999-10-19 20:03:34 +0000 | [diff] [blame] | 364 | } |
| 365 | |
Erik Andersen | e49d5ec | 2000-02-08 19:58:47 +0000 | [diff] [blame] | 366 | DEV = open(device_name, O_RDWR); |
Matt Kraai | a9819b2 | 2000-12-22 01:48:07 +0000 | [diff] [blame^] | 367 | if (DEV < 0 || fstat(DEV, &statbuf) < 0) |
| 368 | perror_msg_and_die("%s", device_name); |
Eric Andersen | e77ae3a | 1999-10-19 20:03:34 +0000 | [diff] [blame] | 369 | if (!S_ISBLK(statbuf.st_mode)) |
Erik Andersen | e49d5ec | 2000-02-08 19:58:47 +0000 | [diff] [blame] | 370 | check = 0; |
Eric Andersen | e77ae3a | 1999-10-19 20:03:34 +0000 | [diff] [blame] | 371 | else if (statbuf.st_rdev == 0x0300 || statbuf.st_rdev == 0x0340) |
| 372 | die("Will not try to make swapdevice on '%s'"); |
| 373 | |
| 374 | #ifdef __sparc__ |
| 375 | if (!force && version == 0) { |
| 376 | /* Don't overwrite partition table unless forced */ |
Erik Andersen | e49d5ec | 2000-02-08 19:58:47 +0000 | [diff] [blame] | 377 | unsigned char *buffer = (unsigned char *) signature_page; |
Eric Andersen | e77ae3a | 1999-10-19 20:03:34 +0000 | [diff] [blame] | 378 | unsigned short *q, sum; |
| 379 | |
| 380 | if (read(DEV, buffer, 512) != 512) |
| 381 | die("fatal: first page unreadable"); |
| 382 | if (buffer[508] == 0xDA && buffer[509] == 0xBE) { |
Erik Andersen | e49d5ec | 2000-02-08 19:58:47 +0000 | [diff] [blame] | 383 | q = (unsigned short *) (buffer + 510); |
Eric Andersen | e77ae3a | 1999-10-19 20:03:34 +0000 | [diff] [blame] | 384 | for (sum = 0; q >= (unsigned short *) buffer;) |
| 385 | sum ^= *q--; |
| 386 | if (!sum) { |
Mark Whitley | f57c944 | 2000-12-07 19:56:48 +0000 | [diff] [blame] | 387 | error_msg("Device '%s' contains a valid Sun disklabel.\n" |
Matt Kraai | d537a95 | 2000-07-14 01:51:25 +0000 | [diff] [blame] | 388 | "This probably means creating v0 swap would destroy your partition table\n" |
| 389 | "No swap created. If you really want to create swap v0 on that device, use\n" |
| 390 | "the -f option to force it.\n", device_name); |
Matt Kraai | 3e856ce | 2000-12-01 02:55:13 +0000 | [diff] [blame] | 391 | return EXIT_FAILURE; |
Eric Andersen | e77ae3a | 1999-10-19 20:03:34 +0000 | [diff] [blame] | 392 | } |
| 393 | } |
| 394 | } |
| 395 | #endif |
| 396 | |
| 397 | if (version == 0 || check) |
| 398 | check_blocks(); |
Erik Andersen | e49d5ec | 2000-02-08 19:58:47 +0000 | [diff] [blame] | 399 | if (version == 0 && !bit_test_and_clear(signature_page, 0)) |
Eric Andersen | e77ae3a | 1999-10-19 20:03:34 +0000 | [diff] [blame] | 400 | die("fatal: first page unreadable"); |
| 401 | if (version == 1) { |
| 402 | p->version = version; |
Erik Andersen | e49d5ec | 2000-02-08 19:58:47 +0000 | [diff] [blame] | 403 | p->last_page = PAGES - 1; |
Eric Andersen | e77ae3a | 1999-10-19 20:03:34 +0000 | [diff] [blame] | 404 | p->nr_badpages = badpages; |
| 405 | } |
| 406 | |
| 407 | goodpages = PAGES - badpages - 1; |
| 408 | if (goodpages <= 0) |
| 409 | die("Unable to set up swap-space: unreadable"); |
| 410 | printf("Setting up swapspace version %d, size = %ld bytes\n", |
Erik Andersen | e49d5ec | 2000-02-08 19:58:47 +0000 | [diff] [blame] | 411 | version, (long) (goodpages * pagesize)); |
Eric Andersen | e77ae3a | 1999-10-19 20:03:34 +0000 | [diff] [blame] | 412 | write_signature((version == 0) ? "SWAP-SPACE" : "SWAPSPACE2"); |
| 413 | |
| 414 | offset = ((version == 0) ? 0 : 1024); |
| 415 | if (lseek(DEV, offset, SEEK_SET) != offset) |
| 416 | die("unable to rewind swap-device"); |
Erik Andersen | e49d5ec | 2000-02-08 19:58:47 +0000 | [diff] [blame] | 417 | if (write(DEV, (char *) signature_page + offset, pagesize - offset) |
| 418 | != pagesize - offset) |
Eric Andersen | e77ae3a | 1999-10-19 20:03:34 +0000 | [diff] [blame] | 419 | die("unable to write signature page"); |
| 420 | |
| 421 | /* |
| 422 | * A subsequent swapon() will fail if the signature |
| 423 | * is not actually on disk. (This is a kernel bug.) |
| 424 | */ |
| 425 | if (fsync(DEV)) |
Erik Andersen | e49d5ec | 2000-02-08 19:58:47 +0000 | [diff] [blame] | 426 | die("fsync failed"); |
Matt Kraai | 3e856ce | 2000-12-01 02:55:13 +0000 | [diff] [blame] | 427 | return EXIT_SUCCESS; |
Eric Andersen | cc8ed39 | 1999-10-05 16:24:54 +0000 | [diff] [blame] | 428 | } |