Contents of /alx-src/tags/kernel26-2.6.12-alx-r9/init/do_mounts.c
Parent Directory | Revision Log
Revision 630 -
(show annotations)
(download)
Wed Mar 4 11:03:09 2009 UTC (15 years, 6 months ago) by niro
File MIME type: text/plain
File size: 9271 byte(s)
Wed Mar 4 11:03:09 2009 UTC (15 years, 6 months ago) by niro
File MIME type: text/plain
File size: 9271 byte(s)
Tag kernel26-2.6.12-alx-r9
1 | #include <linux/module.h> |
2 | #include <linux/sched.h> |
3 | #include <linux/ctype.h> |
4 | #include <linux/fd.h> |
5 | #include <linux/tty.h> |
6 | #include <linux/suspend.h> |
7 | #include <linux/root_dev.h> |
8 | #include <linux/security.h> |
9 | #include <linux/delay.h> |
10 | |
11 | #include <linux/nfs_fs.h> |
12 | #include <linux/nfs_fs_sb.h> |
13 | #include <linux/nfs_mount.h> |
14 | |
15 | #include "do_mounts.h" |
16 | |
17 | extern int get_filesystem_list(char * buf); |
18 | |
19 | int __initdata rd_doload; /* 1 = load RAM disk, 0 = don't load */ |
20 | |
21 | int root_mountflags = MS_RDONLY | MS_VERBOSE; |
22 | char * __initdata root_device_name; |
23 | static char __initdata saved_root_name[64]; |
24 | |
25 | /* this is initialized in init/main.c */ |
26 | dev_t ROOT_DEV; |
27 | |
28 | EXPORT_SYMBOL(ROOT_DEV); |
29 | |
30 | static int __init load_ramdisk(char *str) |
31 | { |
32 | rd_doload = simple_strtol(str,NULL,0) & 3; |
33 | return 1; |
34 | } |
35 | __setup("load_ramdisk=", load_ramdisk); |
36 | |
37 | static int __init readonly(char *str) |
38 | { |
39 | if (*str) |
40 | return 0; |
41 | root_mountflags |= MS_RDONLY; |
42 | return 1; |
43 | } |
44 | |
45 | static int __init readwrite(char *str) |
46 | { |
47 | if (*str) |
48 | return 0; |
49 | root_mountflags &= ~MS_RDONLY; |
50 | return 1; |
51 | } |
52 | |
53 | __setup("ro", readonly); |
54 | __setup("rw", readwrite); |
55 | |
56 | static dev_t try_name(char *name, int part) |
57 | { |
58 | char path[64]; |
59 | char buf[32]; |
60 | int range; |
61 | dev_t res; |
62 | char *s; |
63 | int len; |
64 | int fd; |
65 | unsigned int maj, min; |
66 | |
67 | /* read device number from .../dev */ |
68 | |
69 | sprintf(path, "/sys/block/%s/dev", name); |
70 | fd = sys_open(path, 0, 0); |
71 | if (fd < 0) |
72 | goto fail; |
73 | len = sys_read(fd, buf, 32); |
74 | sys_close(fd); |
75 | if (len <= 0 || len == 32 || buf[len - 1] != '\n') |
76 | goto fail; |
77 | buf[len - 1] = '\0'; |
78 | if (sscanf(buf, "%u:%u", &maj, &min) == 2) { |
79 | /* |
80 | * Try the %u:%u format -- see print_dev_t() |
81 | */ |
82 | res = MKDEV(maj, min); |
83 | if (maj != MAJOR(res) || min != MINOR(res)) |
84 | goto fail; |
85 | } else { |
86 | /* |
87 | * Nope. Try old-style "0321" |
88 | */ |
89 | res = new_decode_dev(simple_strtoul(buf, &s, 16)); |
90 | if (*s) |
91 | goto fail; |
92 | } |
93 | |
94 | /* if it's there and we are not looking for a partition - that's it */ |
95 | if (!part) |
96 | return res; |
97 | |
98 | /* otherwise read range from .../range */ |
99 | sprintf(path, "/sys/block/%s/range", name); |
100 | fd = sys_open(path, 0, 0); |
101 | if (fd < 0) |
102 | goto fail; |
103 | len = sys_read(fd, buf, 32); |
104 | sys_close(fd); |
105 | if (len <= 0 || len == 32 || buf[len - 1] != '\n') |
106 | goto fail; |
107 | buf[len - 1] = '\0'; |
108 | range = simple_strtoul(buf, &s, 10); |
109 | if (*s) |
110 | goto fail; |
111 | |
112 | /* if partition is within range - we got it */ |
113 | if (part < range) |
114 | return res + part; |
115 | fail: |
116 | return 0; |
117 | } |
118 | |
119 | /* |
120 | * Convert a name into device number. We accept the following variants: |
121 | * |
122 | * 1) device number in hexadecimal represents itself |
123 | * 2) /dev/nfs represents Root_NFS (0xff) |
124 | * 3) /dev/<disk_name> represents the device number of disk |
125 | * 4) /dev/<disk_name><decimal> represents the device number |
126 | * of partition - device number of disk plus the partition number |
127 | * 5) /dev/<disk_name>p<decimal> - same as the above, that form is |
128 | * used when disk name of partitioned disk ends on a digit. |
129 | * |
130 | * If name doesn't have fall into the categories above, we return 0. |
131 | * Driverfs is used to check if something is a disk name - it has |
132 | * all known disks under bus/block/devices. If the disk name |
133 | * contains slashes, name of driverfs node has them replaced with |
134 | * bangs. try_name() does the actual checks, assuming that driverfs |
135 | * is mounted on rootfs /sys. |
136 | */ |
137 | |
138 | dev_t name_to_dev_t(char *name) |
139 | { |
140 | char s[32]; |
141 | char *p; |
142 | dev_t res = 0; |
143 | int part; |
144 | |
145 | #ifdef CONFIG_SYSFS |
146 | int mkdir_err = sys_mkdir("/sys", 0700); |
147 | if (sys_mount("sysfs", "/sys", "sysfs", 0, NULL) < 0) |
148 | goto out; |
149 | #endif |
150 | |
151 | if (strncmp(name, "/dev/", 5) != 0) { |
152 | unsigned maj, min; |
153 | |
154 | if (sscanf(name, "%u:%u", &maj, &min) == 2) { |
155 | res = MKDEV(maj, min); |
156 | if (maj != MAJOR(res) || min != MINOR(res)) |
157 | goto fail; |
158 | } else { |
159 | res = new_decode_dev(simple_strtoul(name, &p, 16)); |
160 | if (*p) |
161 | goto fail; |
162 | } |
163 | goto done; |
164 | } |
165 | name += 5; |
166 | res = Root_NFS; |
167 | if (strcmp(name, "nfs") == 0) |
168 | goto done; |
169 | res = Root_RAM0; |
170 | if (strcmp(name, "ram") == 0) |
171 | goto done; |
172 | |
173 | if (strlen(name) > 31) |
174 | goto fail; |
175 | strcpy(s, name); |
176 | for (p = s; *p; p++) |
177 | if (*p == '/') |
178 | *p = '!'; |
179 | res = try_name(s, 0); |
180 | if (res) |
181 | goto done; |
182 | |
183 | while (p > s && isdigit(p[-1])) |
184 | p--; |
185 | if (p == s || !*p || *p == '0') |
186 | goto fail; |
187 | part = simple_strtoul(p, NULL, 10); |
188 | *p = '\0'; |
189 | res = try_name(s, part); |
190 | if (res) |
191 | goto done; |
192 | |
193 | if (p < s + 2 || !isdigit(p[-2]) || p[-1] != 'p') |
194 | goto fail; |
195 | p[-1] = '\0'; |
196 | res = try_name(s, part); |
197 | done: |
198 | #ifdef CONFIG_SYSFS |
199 | sys_umount("/sys", 0); |
200 | out: |
201 | if (!mkdir_err) |
202 | sys_rmdir("/sys"); |
203 | #endif |
204 | return res; |
205 | fail: |
206 | res = 0; |
207 | goto done; |
208 | } |
209 | |
210 | static int __init root_dev_setup(char *line) |
211 | { |
212 | strlcpy(saved_root_name, line, sizeof(saved_root_name)); |
213 | return 1; |
214 | } |
215 | |
216 | __setup("root=", root_dev_setup); |
217 | |
218 | static char * __initdata root_mount_data; |
219 | static int __init root_data_setup(char *str) |
220 | { |
221 | root_mount_data = str; |
222 | return 1; |
223 | } |
224 | |
225 | static char * __initdata root_fs_names; |
226 | static int __init fs_names_setup(char *str) |
227 | { |
228 | root_fs_names = str; |
229 | return 1; |
230 | } |
231 | |
232 | static unsigned int __initdata root_delay; |
233 | static int __init root_delay_setup(char *str) |
234 | { |
235 | root_delay = simple_strtoul(str, NULL, 0); |
236 | return 1; |
237 | } |
238 | |
239 | __setup("rootflags=", root_data_setup); |
240 | __setup("rootfstype=", fs_names_setup); |
241 | __setup("rootdelay=", root_delay_setup); |
242 | |
243 | static void __init get_fs_names(char *page) |
244 | { |
245 | char *s = page; |
246 | |
247 | if (root_fs_names) { |
248 | strcpy(page, root_fs_names); |
249 | while (*s++) { |
250 | if (s[-1] == ',') |
251 | s[-1] = '\0'; |
252 | } |
253 | } else { |
254 | int len = get_filesystem_list(page); |
255 | char *p, *next; |
256 | |
257 | page[len] = '\0'; |
258 | for (p = page-1; p; p = next) { |
259 | next = strchr(++p, '\n'); |
260 | if (*p++ != '\t') |
261 | continue; |
262 | while ((*s++ = *p++) != '\n') |
263 | ; |
264 | s[-1] = '\0'; |
265 | } |
266 | } |
267 | *s = '\0'; |
268 | } |
269 | |
270 | static int __init do_mount_root(char *name, char *fs, int flags, void *data) |
271 | { |
272 | int err = sys_mount(name, "/root", fs, flags, data); |
273 | if (err) |
274 | return err; |
275 | |
276 | sys_chdir("/root"); |
277 | ROOT_DEV = current->fs->pwdmnt->mnt_sb->s_dev; |
278 | printk("VFS: Mounted root (%s filesystem)%s.\n", |
279 | current->fs->pwdmnt->mnt_sb->s_type->name, |
280 | current->fs->pwdmnt->mnt_sb->s_flags & MS_RDONLY ? |
281 | " readonly" : ""); |
282 | return 0; |
283 | } |
284 | |
285 | void __init mount_block_root(char *name, int flags) |
286 | { |
287 | char *fs_names = __getname(); |
288 | char *p; |
289 | char b[BDEVNAME_SIZE]; |
290 | |
291 | get_fs_names(fs_names); |
292 | retry: |
293 | for (p = fs_names; *p; p += strlen(p)+1) { |
294 | int err = do_mount_root(name, p, flags, root_mount_data); |
295 | switch (err) { |
296 | case 0: |
297 | goto out; |
298 | case -EACCES: |
299 | flags |= MS_RDONLY; |
300 | goto retry; |
301 | case -EINVAL: |
302 | continue; |
303 | } |
304 | /* |
305 | * Allow the user to distinguish between failed sys_open |
306 | * and bad superblock on root device. |
307 | */ |
308 | __bdevname(ROOT_DEV, b); |
309 | printk("VFS: Cannot open root device \"%s\" or %s\n", |
310 | root_device_name, b); |
311 | printk("Please append a correct \"root=\" boot option\n"); |
312 | |
313 | panic("VFS: Unable to mount root fs on %s", b); |
314 | } |
315 | panic("VFS: Unable to mount root fs on %s", __bdevname(ROOT_DEV, b)); |
316 | out: |
317 | putname(fs_names); |
318 | } |
319 | |
320 | #ifdef CONFIG_ROOT_NFS |
321 | static int __init mount_nfs_root(void) |
322 | { |
323 | void *data = nfs_root_data(); |
324 | |
325 | create_dev("/dev/root", ROOT_DEV, NULL); |
326 | if (data && |
327 | do_mount_root("/dev/root", "nfs", root_mountflags, data) == 0) |
328 | return 1; |
329 | return 0; |
330 | } |
331 | #endif |
332 | |
333 | #if defined(CONFIG_BLK_DEV_RAM) || defined(CONFIG_BLK_DEV_FD) |
334 | void __init change_floppy(char *fmt, ...) |
335 | { |
336 | struct termios termios; |
337 | char buf[80]; |
338 | char c; |
339 | int fd; |
340 | va_list args; |
341 | va_start(args, fmt); |
342 | vsprintf(buf, fmt, args); |
343 | va_end(args); |
344 | fd = sys_open("/dev/root", O_RDWR | O_NDELAY, 0); |
345 | if (fd >= 0) { |
346 | sys_ioctl(fd, FDEJECT, 0); |
347 | sys_close(fd); |
348 | } |
349 | printk(KERN_NOTICE "VFS: Insert %s and press ENTER\n", buf); |
350 | fd = sys_open("/dev/console", O_RDWR, 0); |
351 | if (fd >= 0) { |
352 | sys_ioctl(fd, TCGETS, (long)&termios); |
353 | termios.c_lflag &= ~ICANON; |
354 | sys_ioctl(fd, TCSETSF, (long)&termios); |
355 | sys_read(fd, &c, 1); |
356 | termios.c_lflag |= ICANON; |
357 | sys_ioctl(fd, TCSETSF, (long)&termios); |
358 | sys_close(fd); |
359 | } |
360 | } |
361 | #endif |
362 | |
363 | void __init mount_root(void) |
364 | { |
365 | #ifdef CONFIG_ROOT_NFS |
366 | if (MAJOR(ROOT_DEV) == UNNAMED_MAJOR) { |
367 | if (mount_nfs_root()) |
368 | return; |
369 | |
370 | printk(KERN_ERR "VFS: Unable to mount root fs via NFS, trying floppy.\n"); |
371 | ROOT_DEV = Root_FD0; |
372 | } |
373 | #endif |
374 | #ifdef CONFIG_BLK_DEV_FD |
375 | if (MAJOR(ROOT_DEV) == FLOPPY_MAJOR) { |
376 | /* rd_doload is 2 for a dual initrd/ramload setup */ |
377 | if (rd_doload==2) { |
378 | if (rd_load_disk(1)) { |
379 | ROOT_DEV = Root_RAM1; |
380 | root_device_name = NULL; |
381 | } |
382 | } else |
383 | change_floppy("root floppy"); |
384 | } |
385 | #endif |
386 | create_dev("/dev/root", ROOT_DEV, root_device_name); |
387 | mount_block_root("/dev/root", root_mountflags); |
388 | } |
389 | |
390 | /* |
391 | * Prepare the namespace - decide what/where to mount, load ramdisks, etc. |
392 | */ |
393 | void __init prepare_namespace(void) |
394 | { |
395 | int is_floppy; |
396 | |
397 | mount_devfs(); |
398 | |
399 | if (root_delay) { |
400 | printk(KERN_INFO "Waiting %dsec before mounting root device...\n", |
401 | root_delay); |
402 | ssleep(root_delay); |
403 | } |
404 | |
405 | md_run_setup(); |
406 | |
407 | if (saved_root_name[0]) { |
408 | root_device_name = saved_root_name; |
409 | ROOT_DEV = name_to_dev_t(root_device_name); |
410 | if (strncmp(root_device_name, "/dev/", 5) == 0) |
411 | root_device_name += 5; |
412 | } |
413 | |
414 | is_floppy = MAJOR(ROOT_DEV) == FLOPPY_MAJOR; |
415 | |
416 | if (initrd_load()) |
417 | goto out; |
418 | |
419 | if (is_floppy && rd_doload && rd_load_disk(0)) |
420 | ROOT_DEV = Root_RAM0; |
421 | |
422 | mount_root(); |
423 | out: |
424 | umount_devfs("/dev"); |
425 | sys_mount(".", "/", NULL, MS_MOVE, NULL); |
426 | sys_chroot("."); |
427 | security_sb_post_mountroot(); |
428 | mount_devfs_fs (); |
429 | } |
430 |