1 | /* vi: set sw=4 ts=4: */
|
---|
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 | *
|
---|
12 | * Usage: mkswap [-c] [-vN] [-f] device [size-in-blocks]
|
---|
13 | *
|
---|
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.
|
---|
17 | *
|
---|
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 :-).
|
---|
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.
|
---|
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 <andersen@codepoet.org>. I ripped out Native Language
|
---|
34 | * Support, made some stuff smaller, and fitted for life in busybox.
|
---|
35 | *
|
---|
36 | */
|
---|
37 |
|
---|
38 | #include "busybox.h"
|
---|
39 | #include <unistd.h>
|
---|
40 | #include <string.h>
|
---|
41 | #include <fcntl.h>
|
---|
42 | #include <sys/ioctl.h> /* for _IO */
|
---|
43 | #include <sys/utsname.h>
|
---|
44 | #include <asm/page.h> /* for PAGE_SIZE and PAGE_SHIFT */
|
---|
45 | /* we also get PAGE_SIZE via getpagesize() */
|
---|
46 |
|
---|
47 | static char *device_name = NULL;
|
---|
48 | static int DEV = -1;
|
---|
49 | static long PAGES = 0;
|
---|
50 | static int check = 0;
|
---|
51 | static int badpages = 0;
|
---|
52 | #if ENABLE_FEATURE_MKSWAP_V0
|
---|
53 | static int version = -1;
|
---|
54 | #else
|
---|
55 | #define version 1
|
---|
56 | /* and make sure that we optimize away anything which would deal with checking
|
---|
57 | * the kernel revision as we have v1 support only anyway.
|
---|
58 | */
|
---|
59 | #undef KERNEL_VERSION
|
---|
60 | #define KERNEL_VERSION(p,q,r) 1
|
---|
61 | #define get_linux_version_code() 1
|
---|
62 | #endif
|
---|
63 |
|
---|
64 | /*
|
---|
65 | * The definition of the union swap_header uses the constant PAGE_SIZE.
|
---|
66 | * Unfortunately, on some architectures this depends on the hardware model,
|
---|
67 | * and can only be found at run time -- we use getpagesize().
|
---|
68 | */
|
---|
69 |
|
---|
70 | static int pagesize;
|
---|
71 | static unsigned int *signature_page;
|
---|
72 |
|
---|
73 | static struct swap_header_v1 {
|
---|
74 | char bootbits[1024]; /* Space for disklabel etc. */
|
---|
75 | unsigned int swap_version;
|
---|
76 | unsigned int last_page;
|
---|
77 | unsigned int nr_badpages;
|
---|
78 | unsigned int padding[125];
|
---|
79 | unsigned int badpages[1];
|
---|
80 | } *p;
|
---|
81 |
|
---|
82 | static inline void init_signature_page(void)
|
---|
83 | {
|
---|
84 | pagesize = getpagesize();
|
---|
85 |
|
---|
86 | #ifdef PAGE_SIZE
|
---|
87 | if (pagesize != PAGE_SIZE)
|
---|
88 | bb_error_msg("Assuming pages of size %d", pagesize);
|
---|
89 | #endif
|
---|
90 | signature_page = (unsigned int *) xmalloc(pagesize);
|
---|
91 | memset(signature_page, 0, pagesize);
|
---|
92 | p = (struct swap_header_v1 *) signature_page;
|
---|
93 | }
|
---|
94 |
|
---|
95 | static inline void write_signature(char *sig)
|
---|
96 | {
|
---|
97 | char *sp = (char *) signature_page;
|
---|
98 |
|
---|
99 | strncpy(sp + pagesize - 10, sig, 10);
|
---|
100 | }
|
---|
101 |
|
---|
102 | #define V0_MAX_PAGES (8 * (pagesize - 10))
|
---|
103 | /* Before 2.2.0pre9 */
|
---|
104 | #define V1_OLD_MAX_PAGES ((0x7fffffff / pagesize) - 1)
|
---|
105 | /* Since 2.2.0pre9:
|
---|
106 | error if nr of pages >= SWP_OFFSET(SWP_ENTRY(0,~0UL))
|
---|
107 | with variations on
|
---|
108 | #define SWP_ENTRY(type,offset) (((type) << 1) | ((offset) << 8))
|
---|
109 | #define SWP_OFFSET(entry) ((entry) >> 8)
|
---|
110 | on the various architectures. Below the result - yuk.
|
---|
111 |
|
---|
112 | Machine pagesize SWP_ENTRY SWP_OFFSET bound+1 oldbound+2
|
---|
113 | i386 2^12 o<<8 e>>8 1<<24 1<<19
|
---|
114 | mips 2^12 o<<15 e>>15 1<<17 1<<19
|
---|
115 | alpha 2^13 o<<40 e>>40 1<<24 1<<18
|
---|
116 | m68k 2^12 o<<12 e>>12 1<<20 1<<19
|
---|
117 | sparc 2^{12,13} (o&0x3ffff)<<9 (e>>9)&0x3ffff 1<<18 1<<{19,18}
|
---|
118 | sparc64 2^13 o<<13 e>>13 1<<51 1<<18
|
---|
119 | ppc 2^12 o<<8 e>>8 1<<24 1<<19
|
---|
120 | armo 2^{13,14,15} o<<8 e>>8 1<<24 1<<{18,17,16}
|
---|
121 | armv 2^12 o<<9 e>>9 1<<23 1<<19
|
---|
122 |
|
---|
123 | assuming that longs have 64 bits on alpha and sparc64 and 32 bits elsewhere.
|
---|
124 |
|
---|
125 | The bad part is that we need to know this since the kernel will
|
---|
126 | refuse a swap space if it is too large.
|
---|
127 | */
|
---|
128 | /* patch from jj - why does this differ from the above? */
|
---|
129 | #if defined(__alpha__)
|
---|
130 | #define V1_MAX_PAGES ((1 << 24) - 1)
|
---|
131 | #elif defined(__mips__)
|
---|
132 | #define V1_MAX_PAGES ((1 << 17) - 1)
|
---|
133 | #elif defined(__sparc_v9__)
|
---|
134 | #define V1_MAX_PAGES ((3 << 29) - 1)
|
---|
135 | #elif defined(__sparc__)
|
---|
136 | #define V1_MAX_PAGES (pagesize == 8192 ? ((3 << 29) - 1) : ((1 << 18) - 1))
|
---|
137 | #else
|
---|
138 | #define V1_MAX_PAGES V1_OLD_MAX_PAGES
|
---|
139 | #endif
|
---|
140 | /* man page now says:
|
---|
141 | The maximum useful size of a swap area now depends on the architecture.
|
---|
142 | It is roughly 2GB on i386, PPC, m68k, ARM, 1GB on sparc, 512MB on mips,
|
---|
143 | 128GB on alpha and 3TB on sparc64.
|
---|
144 | */
|
---|
145 |
|
---|
146 | #define MAX_BADPAGES ((pagesize-1024-128*sizeof(int)-10)/sizeof(int))
|
---|
147 |
|
---|
148 | static inline void bit_set(unsigned int *addr, unsigned int nr)
|
---|
149 | {
|
---|
150 | unsigned int r, m;
|
---|
151 |
|
---|
152 | addr += nr / (8 * sizeof(int));
|
---|
153 |
|
---|
154 | r = *addr;
|
---|
155 | m = 1 << (nr & (8 * sizeof(int) - 1));
|
---|
156 |
|
---|
157 | *addr = r | m;
|
---|
158 | }
|
---|
159 |
|
---|
160 | static int bit_test_and_clear(unsigned int *addr, unsigned int nr)
|
---|
161 | {
|
---|
162 | unsigned int r, m;
|
---|
163 |
|
---|
164 | addr += nr / (8 * sizeof(int));
|
---|
165 |
|
---|
166 | r = *addr;
|
---|
167 | m = 1 << (nr & (8 * sizeof(int) - 1));
|
---|
168 |
|
---|
169 | *addr = r & ~m;
|
---|
170 | return (r & m) != 0;
|
---|
171 | }
|
---|
172 |
|
---|
173 | static void page_ok(int page)
|
---|
174 | {
|
---|
175 | if (ENABLE_FEATURE_MKSWAP_V0) {
|
---|
176 | bit_set(signature_page, page);
|
---|
177 | }
|
---|
178 | }
|
---|
179 |
|
---|
180 | static void check_blocks(void)
|
---|
181 | {
|
---|
182 | unsigned int current_page;
|
---|
183 | int do_seek = 1;
|
---|
184 | char *buffer;
|
---|
185 |
|
---|
186 | buffer = xmalloc(pagesize);
|
---|
187 | current_page = 0;
|
---|
188 | while (current_page < PAGES) {
|
---|
189 | if (!check && version == 0) {
|
---|
190 | page_ok(current_page++);
|
---|
191 | continue;
|
---|
192 | }
|
---|
193 | if (do_seek && lseek(DEV, current_page * pagesize, SEEK_SET) !=
|
---|
194 | current_page * pagesize)
|
---|
195 | bb_error_msg_and_die("seek failed in check_blocks");
|
---|
196 | if ((do_seek = (pagesize != read(DEV, buffer, pagesize)))) {
|
---|
197 | current_page++;
|
---|
198 | if (version == 0)
|
---|
199 | bit_test_and_clear(signature_page, current_page);
|
---|
200 | else {
|
---|
201 | if (badpages == MAX_BADPAGES)
|
---|
202 | bb_error_msg_and_die("too many bad pages");
|
---|
203 | p->badpages[badpages] = current_page;
|
---|
204 | }
|
---|
205 | badpages++;
|
---|
206 | continue;
|
---|
207 | }
|
---|
208 | page_ok(current_page++);
|
---|
209 | }
|
---|
210 | if (ENABLE_FEATURE_CLEAN_UP)
|
---|
211 | free(buffer);
|
---|
212 | if (badpages > 0)
|
---|
213 | printf("%d bad page%s\n", badpages, (badpages==1)?"":"s");
|
---|
214 | }
|
---|
215 |
|
---|
216 | static long valid_offset(int fd, int offset)
|
---|
217 | {
|
---|
218 | char ch;
|
---|
219 |
|
---|
220 | if (lseek(fd, offset, 0) < 0)
|
---|
221 | return 0;
|
---|
222 | if (read(fd, &ch, 1) < 1)
|
---|
223 | return 0;
|
---|
224 | return 1;
|
---|
225 | }
|
---|
226 |
|
---|
227 | static int find_size(int fd)
|
---|
228 | {
|
---|
229 | unsigned int high, low;
|
---|
230 |
|
---|
231 | low = 0;
|
---|
232 | for (high = 1; high > 0 && valid_offset(fd, high); high *= 2)
|
---|
233 | low = high;
|
---|
234 | while (low < high - 1) {
|
---|
235 | const int mid = (low + high) / 2;
|
---|
236 |
|
---|
237 | if (valid_offset(fd, mid))
|
---|
238 | low = mid;
|
---|
239 | else
|
---|
240 | high = mid;
|
---|
241 | }
|
---|
242 | return (low + 1);
|
---|
243 | }
|
---|
244 |
|
---|
245 | /* return size in pages, to avoid integer overflow */
|
---|
246 | static inline long get_size(const char *file)
|
---|
247 | {
|
---|
248 | int fd;
|
---|
249 | long size;
|
---|
250 |
|
---|
251 | fd = bb_xopen3(file, O_RDONLY, 0);
|
---|
252 | if (ioctl(fd, BLKGETSIZE, &size) >= 0) {
|
---|
253 | size /= pagesize / 512;
|
---|
254 | } else {
|
---|
255 | size = find_size(fd) / pagesize;
|
---|
256 | }
|
---|
257 | close(fd);
|
---|
258 | return size;
|
---|
259 | }
|
---|
260 |
|
---|
261 | int mkswap_main(int argc, char **argv)
|
---|
262 | {
|
---|
263 | char *tmp;
|
---|
264 | struct stat statbuf;
|
---|
265 | int sz;
|
---|
266 | int maxpages;
|
---|
267 | int goodpages;
|
---|
268 | #ifdef __sparc__
|
---|
269 | int force = 0;
|
---|
270 | #endif
|
---|
271 |
|
---|
272 | init_signature_page(); /* get pagesize */
|
---|
273 |
|
---|
274 | bb_opt_complementally = "?"; /* call bb_show_usage internally */
|
---|
275 | sz = bb_getopt_ulflags(argc, argv, "+cfv:", &tmp);
|
---|
276 | if (sz & 1)
|
---|
277 | check = 1;
|
---|
278 | #ifdef __sparc__
|
---|
279 | if (sz & 2)
|
---|
280 | force = 1;
|
---|
281 | #endif
|
---|
282 | #if ENABLE_FEATURE_MKSWAP_V0
|
---|
283 | if (sz & 4) {
|
---|
284 | version = bb_xgetlarg(tmp, 10, 0, 1);
|
---|
285 | } else {
|
---|
286 | if (get_linux_version_code() < KERNEL_VERSION(2, 1, 117))
|
---|
287 | version = 0;
|
---|
288 | else
|
---|
289 | version = 1;
|
---|
290 | }
|
---|
291 | #endif
|
---|
292 |
|
---|
293 | argv += optind;
|
---|
294 | argc -= optind;
|
---|
295 |
|
---|
296 | goodpages = pagesize / 1024; /* cache division */
|
---|
297 | while (argc--) {
|
---|
298 | if (device_name) {
|
---|
299 | PAGES = bb_xgetlarg(argv[0], 0, 10, sz * goodpages) / goodpages;
|
---|
300 | argc = 0; /* ignore any surplus args.. */
|
---|
301 | } else {
|
---|
302 | device_name = argv[0];
|
---|
303 | sz = get_size(device_name);
|
---|
304 | argv++;
|
---|
305 | }
|
---|
306 | }
|
---|
307 |
|
---|
308 | if (!device_name) {
|
---|
309 | bb_error_msg_and_die("error: Nowhere to set up swap on?");
|
---|
310 | }
|
---|
311 | if (!PAGES) {
|
---|
312 | PAGES = sz;
|
---|
313 | }
|
---|
314 |
|
---|
315 | #if 0
|
---|
316 | maxpages = ((version == 0) ? V0_MAX_PAGES : V1_MAX_PAGES);
|
---|
317 | #else
|
---|
318 | if (!version)
|
---|
319 | maxpages = V0_MAX_PAGES;
|
---|
320 | else if (get_linux_version_code() >= KERNEL_VERSION(2,2,1))
|
---|
321 | maxpages = V1_MAX_PAGES;
|
---|
322 | else {
|
---|
323 | maxpages = V1_OLD_MAX_PAGES;
|
---|
324 | if (maxpages > V1_MAX_PAGES)
|
---|
325 | maxpages = V1_MAX_PAGES;
|
---|
326 | }
|
---|
327 | #endif
|
---|
328 | if (PAGES > maxpages) {
|
---|
329 | PAGES = maxpages;
|
---|
330 | bb_error_msg("warning: truncating swap area to %ldkB",
|
---|
331 | PAGES * goodpages);
|
---|
332 | }
|
---|
333 |
|
---|
334 | DEV = bb_xopen3(device_name, O_RDWR, 0);
|
---|
335 | if (fstat(DEV, &statbuf) < 0)
|
---|
336 | bb_perror_msg_and_die("%s", device_name);
|
---|
337 | if (!S_ISBLK(statbuf.st_mode))
|
---|
338 | check = 0;
|
---|
339 | else if (statbuf.st_rdev == 0x0300 || statbuf.st_rdev == 0x0340)
|
---|
340 | bb_error_msg_and_die("Will not try to make swapdevice on '%s'", device_name);
|
---|
341 |
|
---|
342 | #ifdef __sparc__
|
---|
343 | if (!force && version == 0) {
|
---|
344 | /* Don't overwrite partition table unless forced */
|
---|
345 | unsigned char *buffer = (unsigned char *) signature_page;
|
---|
346 | unsigned short *q, sum;
|
---|
347 |
|
---|
348 | if (read(DEV, buffer, 512) != 512)
|
---|
349 | bb_error_msg_and_die("fatal: first page unreadable");
|
---|
350 | if (buffer[508] == 0xDA && buffer[509] == 0xBE) {
|
---|
351 | q = (unsigned short *) (buffer + 510);
|
---|
352 | for (sum = 0; q >= (unsigned short *) buffer;)
|
---|
353 | sum ^= *q--;
|
---|
354 | if (!sum) {
|
---|
355 | bb_error_msg("Device '%s' contains a valid Sun disklabel.\n"
|
---|
356 | "This probably means creating v0 swap would destroy your partition table\n"
|
---|
357 | "No swap created. If you really want to create swap v0 on that device, use\n"
|
---|
358 | "the -f option to force it.", device_name);
|
---|
359 | return EXIT_FAILURE;
|
---|
360 | }
|
---|
361 | }
|
---|
362 | }
|
---|
363 | #endif
|
---|
364 |
|
---|
365 | if (version == 0 || check)
|
---|
366 | check_blocks();
|
---|
367 | if (version == 0 && !bit_test_and_clear(signature_page, 0))
|
---|
368 | bb_error_msg_and_die("fatal: first page unreadable");
|
---|
369 | if (version == 1) {
|
---|
370 | p->swap_version = version;
|
---|
371 | p->last_page = PAGES - 1;
|
---|
372 | p->nr_badpages = badpages;
|
---|
373 | }
|
---|
374 |
|
---|
375 | goodpages = PAGES - badpages - 1;
|
---|
376 | if (goodpages <= 0)
|
---|
377 | bb_error_msg_and_die("Unable to set up swap-space: unreadable");
|
---|
378 | printf("Setting up swapspace version %d, size = %ld bytes\n",
|
---|
379 | version, (long) (goodpages * pagesize));
|
---|
380 | write_signature((version == 0) ? "SWAP-SPACE" : "SWAPSPACE2");
|
---|
381 |
|
---|
382 | sz = ((version == 0) ? 0 : 1024); /* offset */
|
---|
383 | if (lseek(DEV, sz, SEEK_SET) != sz)
|
---|
384 | bb_error_msg_and_die("unable to rewind swap-device");
|
---|
385 | goodpages = pagesize - sz; /* cache substraction */
|
---|
386 | if (write(DEV, (char *) signature_page + sz, goodpages)
|
---|
387 | != goodpages)
|
---|
388 | bb_error_msg_and_die("unable to write signature page");
|
---|
389 |
|
---|
390 | /*
|
---|
391 | * A subsequent swapon() will fail if the signature
|
---|
392 | * is not actually on disk. (This is a kernel bug.)
|
---|
393 | */
|
---|
394 | if (fsync(DEV))
|
---|
395 | bb_error_msg_and_die("fsync failed");
|
---|
396 | if (ENABLE_FEATURE_CLEAN_UP) {
|
---|
397 | close(DEV);
|
---|
398 | free(signature_page);
|
---|
399 | }
|
---|
400 | return EXIT_SUCCESS;
|
---|
401 | }
|
---|