This source file includes following definitions.
- root_rarp_open
- root_rarp_close
- root_rarp_recv
- root_rarp_send
- do_rarp
- get_address
- root_nfs_parse
- root_nfs_print
- root_nfs_setup
- nfs_root_init
- root_nfs_open
- root_nfs_close
- root_nfs_bind
- root_nfs_call
- root_nfs_header
- root_nfs_get_port
- root_nfs_ports
- root_nfs_get_handle
- root_nfs_do_mount
- nfs_root_mount
1
2
3
4
5
6
7
8
9
10
11
12
13
14 #define NFSROOT_DEBUG 1
15
16
17 #define RARP_TIMEOUT 30
18 #define RARP_RETRIES 5
19
20 #include <linux/config.h>
21 #include <linux/types.h>
22 #include <linux/string.h>
23 #include <linux/kernel.h>
24 #include <linux/sched.h>
25 #include <linux/fs.h>
26
27 #include <asm/param.h>
28 #include <linux/utsname.h>
29 #include <linux/in.h>
30 #include <linux/if.h>
31 #include <linux/inet.h>
32 #include <linux/net.h>
33 #include <linux/if_arp.h>
34 #include <linux/netdevice.h>
35 #ifdef CONFIG_AX25
36 #include <net/ax25.h>
37 #endif
38 #include <linux/skbuff.h>
39 #include <linux/socket.h>
40 #include <linux/route.h>
41 #include <net/route.h>
42 #include <linux/nfs.h>
43 #include <linux/nfs_fs.h>
44 #include <linux/nfs_mount.h>
45
46
47 #define IPPORT_RESERVED 1024
48
49
50 #define STARTPORT 600
51 #define ENDPORT (IPPORT_RESERVED - 1)
52 #define NPORTS (ENDPORT - STARTPORT + 1)
53
54
55
56 struct open_dev
57 {
58 struct device *dev;
59 unsigned short old_flags;
60 struct open_dev *next;
61 };
62
63 static struct open_dev *open_base = NULL;
64 static struct device *root_dev = NULL;
65 static struct sockaddr_in myaddr;
66 static struct sockaddr_in server;
67 static struct nfs_mount_data nfs_data;
68 static char nfs_path[NFS_MAXPATHLEN];
69 static int nfs_port;
70
71
72
73
74
75
76
77
78
79 extern void arp_send(int type, int ptype, unsigned long target_ip,
80 struct device *dev, unsigned long src_ip,
81 unsigned char *dest_hw, unsigned char *src_hw,
82 unsigned char *target_hw);
83
84 static int root_rarp_recv(struct sk_buff *skb, struct device *dev,
85 struct packet_type *pt);
86
87
88 static struct packet_type rarp_packet_type =
89 {
90 0,
91 NULL,
92 root_rarp_recv,
93 NULL,
94 NULL
95 };
96
97
98
99
100
101
102 static int root_rarp_open(void)
103 {
104 struct open_dev *openp;
105 struct device *dev;
106 unsigned short old_flags;
107 int num;
108
109
110 rarp_packet_type.type=htons(ETH_P_RARP);
111 dev_add_pack(&rarp_packet_type);
112
113
114 for (dev = dev_base, num = 0; dev != NULL; dev = dev->next) {
115 if (dev->type < ARPHRD_SLIP &&
116 dev->family == AF_INET &&
117 !(dev->flags & (IFF_LOOPBACK | IFF_POINTOPOINT | IFF_NOARP))) {
118
119 old_flags = dev->flags;
120 dev->flags = IFF_UP | IFF_BROADCAST | IFF_RUNNING;
121 if (!(old_flags & IFF_UP) && dev_open(dev)) {
122 dev->flags = old_flags;
123 continue;
124 }
125 openp = (struct open_dev *) kmalloc(sizeof(struct open_dev),
126 GFP_ATOMIC);
127 if (openp == NULL)
128 continue;
129 openp->dev = dev;
130 openp->old_flags = old_flags;
131 openp->next = open_base;
132 open_base = openp;
133 num++;
134 }
135 }
136 return num;
137 }
138
139
140
141
142
143
144
145 static void root_rarp_close(void)
146 {
147 struct open_dev *openp;
148 struct open_dev *nextp;
149
150
151 rarp_packet_type.type=htons(ETH_P_RARP);
152 dev_remove_pack(&rarp_packet_type);
153
154
155
156
157 openp = open_base;
158 while (openp != NULL) {
159 nextp = openp->next;
160 openp->next = NULL;
161 if (openp->dev != root_dev) {
162 if (!(openp->old_flags & IFF_UP))
163 dev_close(openp->dev);
164 openp->dev->flags = openp->old_flags;
165 }
166 kfree_s(openp, sizeof(struct open_dev));
167 openp = nextp;
168 }
169 }
170
171
172
173
174
175 static int root_rarp_recv(struct sk_buff *skb, struct device *dev, struct packet_type *pt)
176 {
177 struct arphdr *rarp = (struct arphdr *)skb->h.raw;
178 unsigned char *rarp_ptr = (unsigned char *)(rarp+1);
179 unsigned long sip, tip;
180 unsigned char *sha, *tha;
181
182
183 if (rarp->ar_hln != dev->addr_len || dev->type != ntohs(rarp->ar_hrd)) {
184 kfree_skb(skb, FREE_READ);
185 return 0;
186 }
187
188
189 if (rarp->ar_op != htons(ARPOP_RREPLY)) {
190 kfree_skb(skb, FREE_READ);
191 return 0;
192 }
193
194
195 if ((rarp->ar_pro != htons(ETH_P_IP) && dev->type != ARPHRD_AX25) ||
196 #ifdef CONFIG_AX25
197 (rarp->ar_pro != htons(AX25_P_IP) && dev->type == ARPHRD_AX25) ||
198 #endif
199 rarp->ar_pln != 4) {
200 kfree_skb(skb, FREE_READ);
201 return 0;
202 }
203
204
205 sha = rarp_ptr;
206 rarp_ptr += dev->addr_len;
207 memcpy(&sip, rarp_ptr, 4);
208 rarp_ptr += 4;
209 tha = rarp_ptr;
210 rarp_ptr += dev->addr_len;
211 memcpy(&tip, rarp_ptr, 4);
212
213
214 if (memcmp(tha, dev->dev_addr, dev->addr_len)) {
215 kfree_skb(skb, FREE_READ);
216 return 0;
217 }
218
219
220 cli();
221 if (root_dev != NULL) {
222 sti();
223 kfree_skb(skb, FREE_READ);
224 return 0;
225 }
226 root_dev = dev;
227 sti();
228
229 myaddr.sin_family = dev->family;
230 myaddr.sin_addr.s_addr = tip;
231 server.sin_family = dev->family;
232 if (!server.sin_addr.s_addr)
233 server.sin_addr.s_addr = sip;
234
235 kfree_skb(skb, FREE_READ);
236 return 0;
237 }
238
239
240
241
242
243 static void root_rarp_send(void)
244 {
245 struct open_dev *openp;
246 struct device *dev;
247
248 #ifdef NFSROOT_DEBUG
249 printk(KERN_NOTICE "NFS: Sending RARP request...\n");
250 #endif
251
252 for (openp = open_base; openp != NULL; openp = openp->next) {
253 dev = openp->dev;
254 arp_send(ARPOP_RREQUEST, ETH_P_RARP, 0, dev, 0, NULL,
255 dev->dev_addr, dev->dev_addr);
256 }
257 }
258
259
260
261
262
263
264 static int do_rarp(void)
265 {
266 int retries = 0;
267 unsigned long timeout;
268
269
270 if (!root_rarp_open()) {
271 printk(KERN_ERR "NFS: No network device found to send RARP request to\n");
272 return -1;
273 }
274
275
276
277
278
279 for (retries = 0; retries < RARP_RETRIES && root_dev == NULL; retries++) {
280 root_rarp_send();
281 timeout = jiffies + (RARP_TIMEOUT * HZ);
282 while (jiffies < timeout && root_dev == NULL)
283 ;;
284 }
285
286 if (root_dev == NULL) {
287 printk(KERN_ERR "NFS: Timed out while waiting for RARP answer\n");
288 return -1;
289 }
290
291 root_rarp_close();
292
293 printk(KERN_NOTICE "NFS: ");
294 printk("Got RARP answer from %s, ", in_ntoa(server.sin_addr.s_addr));
295 printk("my address is %s\n", in_ntoa(myaddr.sin_addr.s_addr));
296
297 return 0;
298 }
299
300
301
302
303
304
305
306
307
308
309 extern void ip_rt_add(short flags, unsigned long addr, unsigned long mask,
310 unsigned long gw, struct device *dev,
311 unsigned short mss, unsigned long window);
312
313
314
315 static struct nfs_int_opts
316 {
317 char *name;
318 int *val;
319 } root_int_opts[] = {
320 { "port", &nfs_port },
321 { "rsize", &nfs_data.rsize },
322 { "wsize", &nfs_data.wsize },
323 { "timeo", &nfs_data.timeo },
324 { "retrans", &nfs_data.retrans },
325 { "acregmin", &nfs_data.acregmin },
326 { "acregmax", &nfs_data.acregmax },
327 { "acdirmin", &nfs_data.acdirmin },
328 { "acdirmax", &nfs_data.acdirmax },
329 { NULL, NULL }};
330
331
332
333 static struct nfs_bool_opts
334 {
335 char *name;
336 int and_mask;
337 int or_mask;
338 } root_bool_opts[] = {
339 { "soft", ~NFS_MOUNT_SOFT, NFS_MOUNT_SOFT },
340 { "hard", ~NFS_MOUNT_SOFT, 0 },
341 { "intr", ~NFS_MOUNT_INTR, NFS_MOUNT_INTR },
342 { "nointr", ~NFS_MOUNT_INTR, 0 },
343 { "posix", ~NFS_MOUNT_POSIX, NFS_MOUNT_POSIX },
344 { "noposix", ~NFS_MOUNT_POSIX, 0 },
345 { "cto", ~NFS_MOUNT_NOCTO, 0 },
346 { "nocto", ~NFS_MOUNT_NOCTO, NFS_MOUNT_NOCTO },
347 { "ac", ~NFS_MOUNT_NOAC, 0 },
348 { "noac", ~NFS_MOUNT_NOAC, NFS_MOUNT_NOAC },
349 { NULL, 0, 0 }};
350
351
352 static unsigned long get_address (char **str)
353 {
354 unsigned long l;
355 unsigned int val;
356 int i;
357
358 l = 0;
359 for (i = 0; i < 4; i++)
360 {
361
362 l <<= 8;
363 if (**str != '\0')
364 {
365
366 val = 0;
367 while (**str != '\0' && **str != '.' && **str != ':')
368 {
369
370 val *= 10;
371 val += **str - '0';
372 (*str)++;
373 }
374
375 l |= val;
376 if (**str != '\0')
377 (*str)++;
378 }
379
380 }
381
382 return(htonl(l));
383 }
384
385
386
387
388 static int root_nfs_parse(char *name)
389 {
390 char buf[NFS_MAXPATHLEN];
391 char *cp, *options, *val;
392
393
394 if (*name >= '0' && *name <= '9'){
395 server.sin_addr.s_addr = get_address (&name);
396 }
397
398 cp = in_ntoa(server.sin_addr.s_addr);
399 strncpy(nfs_data.hostname, cp, 255);
400 nfs_data.addr = server;
401
402
403 cp = in_ntoa(myaddr.sin_addr.s_addr);
404 strncpy(buf, name, 255);
405 if ((options = strchr(buf, ',')))
406 *options++ = '\0';
407 if (strlen(buf) + strlen(cp) > NFS_MAXPATHLEN) {
408 printk(KERN_ERR "NFS: Pathname for remote directory too long\n");
409 return -1;
410 }
411 sprintf(nfs_path, buf, cp);
412
413
414 nfs_port = -1;
415 nfs_data.version = NFS_MOUNT_VERSION;
416 nfs_data.flags = 0;
417 nfs_data.rsize = NFS_DEF_FILE_IO_BUFFER_SIZE;
418 nfs_data.wsize = NFS_DEF_FILE_IO_BUFFER_SIZE;
419 nfs_data.timeo = 7;
420 nfs_data.retrans = 3;
421 nfs_data.acregmin = 3;
422 nfs_data.acregmax = 60;
423 nfs_data.acdirmin = 30;
424 nfs_data.acdirmax = 60;
425
426
427 if (options) {
428 cp = strtok(options, ",");
429 while (cp) {
430 if ((val = strchr(cp, '='))) {
431 struct nfs_int_opts *opts = root_int_opts;
432 *val++ = '\0';
433 while (opts->name && strcmp(opts->name, cp))
434 opts++;
435 if (opts->name)
436 *(opts->val) = (int) simple_strtoul(val, NULL, 10);
437 } else {
438 struct nfs_bool_opts *opts = root_bool_opts;
439 while (opts->name && strcmp(opts->name, cp))
440 opts++;
441 if (opts->name) {
442 nfs_data.flags &= opts->and_mask;
443 nfs_data.flags |= opts->or_mask;
444 }
445 }
446 cp = strtok(NULL, ",");
447 }
448 }
449
450 return 0;
451 }
452
453
454
455
456
457 static void root_nfs_print(void)
458 {
459 #ifdef NFSROOT_DEBUG
460 printk(KERN_NOTICE "NFS: Mounting %s on server %s as root\n",
461 nfs_path, nfs_data.hostname);
462 printk(KERN_NOTICE "NFS: rsize = %d, wsize = %d, timeo = %d, retrans = %d\n",
463 nfs_data.rsize, nfs_data.wsize, nfs_data.timeo, nfs_data.retrans);
464 printk(KERN_NOTICE "NFS: acreg (min,max) = (%d,%d), acdir (min,max) = (%d,%d)\n",
465 nfs_data.acregmin, nfs_data.acregmax,
466 nfs_data.acdirmin, nfs_data.acdirmax);
467 printk(KERN_NOTICE "NFS: port = %d, flags = %08x\n",
468 nfs_port, nfs_data.flags);
469 #endif
470 }
471
472
473
474
475
476 static void root_nfs_setup(void)
477 {
478 struct rtentry server_route;
479 struct sockaddr_in *sin;
480
481
482 root_dev->family = myaddr.sin_family;
483 root_dev->pa_addr = myaddr.sin_addr.s_addr;
484 root_dev->pa_mask = ip_get_mask(myaddr.sin_addr.s_addr);
485 root_dev->pa_brdaddr = root_dev->pa_addr | ~root_dev->pa_mask;
486 root_dev->pa_dstaddr = 0;
487
488 sin=(struct sockaddr_in *)&server_route.rt_dst;
489 *sin=server;
490 sin=(struct sockaddr_in *)&server_route.rt_genmask;
491 sin->sin_family=AF_INET;
492 sin->sin_addr.s_addr= root_dev->pa_mask;
493 server_route.rt_dev=NULL;
494 server_route.rt_flags=RTF_HOST|RTF_UP;
495
496
497 if(ip_rt_new(&server_route)==-1)
498 printk("Unable to add NFS server route.\n");
499 }
500
501
502
503
504
505
506 int nfs_root_init(char *nfsname)
507 {
508
509 if (do_rarp() < 0)
510 return -1;
511
512
513
514
515 if (root_nfs_parse(nfsname) < 0)
516 return -1;
517 root_nfs_print();
518 root_nfs_setup();
519 return 0;
520 }
521
522
523
524
525
526
527
528
529
530
531 static struct file nfs_file;
532 static struct inode nfs_inode;
533 static int *rpc_packet = NULL;
534
535 extern asmlinkage int sys_socketcall(int call, unsigned long *args);
536 extern struct socket *socki_lookup(struct inode *inode);
537
538
539
540
541
542 static int root_nfs_open(void)
543 {
544 struct file *filp;
545 unsigned long opt[] = { AF_INET, SOCK_DGRAM, IPPROTO_UDP };
546
547
548 if ((nfs_data.fd = sys_socketcall(SYS_SOCKET, opt)) < 0) {
549 printk(KERN_ERR "NFS: Cannot open UDP socket\n");
550 return -1;
551 }
552
553
554
555
556
557
558 filp = current->files->fd[nfs_data.fd];
559 memcpy(&nfs_file, filp, sizeof(struct file));
560 nfs_file.f_next = nfs_file.f_prev = NULL;
561 current->files->fd[nfs_data.fd] = &nfs_file;
562 filp->f_count = 0;
563
564 memcpy(&nfs_inode, nfs_file.f_inode, sizeof(struct inode));
565 nfs_inode.i_hash_next = nfs_inode.i_hash_prev = NULL;
566 nfs_inode.i_next = nfs_inode.i_prev = NULL;
567 clear_inode(nfs_file.f_inode);
568 nfs_file.f_inode = &nfs_inode;
569 nfs_inode.u.socket_i.inode = &nfs_inode;
570 nfs_file.private_data = NULL;
571
572 return 0;
573 }
574
575
576
577
578
579
580
581 static void root_nfs_close(int close_all)
582 {
583
584 current->files->fd[nfs_data.fd] = NULL;
585 if (current->files->count > 0)
586 current->files->count--;
587
588
589 if (rpc_packet != NULL)
590 kfree_s(rpc_packet, nfs_data.wsize + 1024);
591
592
593 if (close_all) {
594 nfs_inode.u.socket_i.inode = NULL;
595 if (nfs_file.f_op->release)
596 nfs_file.f_op->release(&nfs_inode, &nfs_file);
597 }
598 }
599
600
601
602
603
604 static int root_nfs_bind(void)
605 {
606 int res = -1;
607 short port = STARTPORT;
608 struct sockaddr_in *sin = &myaddr;
609 int i;
610
611 if (nfs_inode.u.socket_i.ops->bind) {
612 for (i = 0; i < NPORTS && res < 0; i++) {
613 sin->sin_port = htons(port++);
614 if (port > ENDPORT) {
615 port = STARTPORT;
616 }
617 res = nfs_inode.u.socket_i.ops->bind(&nfs_inode.u.socket_i,
618 (struct sockaddr *) sin, sizeof(struct sockaddr_in));
619 }
620 }
621 if (res < 0) {
622 printk(KERN_ERR "NFS: Cannot find a suitable listening port\n");
623 root_nfs_close(1);
624 return -1;
625 }
626
627 #ifdef NFSROOT_DEBUG
628 printk(KERN_NOTICE "NFS: Binding to listening port %d\n", port);
629 #endif
630 return 0;
631 }
632
633
634
635
636
637 static int *root_nfs_call(int *end)
638 {
639 struct file *filp;
640 struct socket *sock;
641 int dummylen;
642 static struct nfs_server s =
643 { &nfs_file,
644 0,
645 {
646 0, "",
647 },
648 0,
649 NULL,
650 NFS_MOUNT_SOFT,
651 0, 0,
652 0,
653 0,
654 3*HZ, 60*HZ, 30*HZ, 60*HZ, "\0" };
655
656 filp = &nfs_file;
657 sock = &((filp->f_inode)->u.socket_i);
658
659
660 sock->ops->getname(sock, &(s.toaddr), &dummylen, 1) ;
661 ((struct sockaddr_in *) &s.toaddr)->sin_port = server.sin_port;
662 ((struct sockaddr_in *) &s.toaddr)->sin_family = server.sin_family;
663 ((struct sockaddr_in *) &s.toaddr)->sin_addr.s_addr = server.sin_addr.s_addr;
664
665 s.rsock = rpc_makesock(filp);
666 s.flags = nfs_data.flags;
667 s.rsize = nfs_data.rsize;
668 s.wsize = nfs_data.wsize;
669 s.timeo = nfs_data.timeo * HZ / 10;
670 s.retrans = nfs_data.retrans;
671 strcpy(s.hostname, nfs_data.hostname);
672
673
674
675
676 if (nfs_inode.u.socket_i.ops->connect &&
677 nfs_inode.u.socket_i.ops->connect(&nfs_inode.u.socket_i,
678 (struct sockaddr *) &server, sizeof(struct sockaddr_in),
679 nfs_file.f_flags) < 0)
680 return NULL;
681 if (nfs_rpc_call(&s, rpc_packet, end, nfs_data.wsize) < 0)
682 return NULL;
683 return rpc_verify(rpc_packet);
684 }
685
686
687
688
689
690 static int *root_nfs_header(int proc, int program, int version)
691 {
692 int groups[] = { 0, NOGROUP };
693
694 if (rpc_packet == NULL) {
695 if (!(rpc_packet = kmalloc(nfs_data.wsize + 1024, GFP_NFS))) {
696 printk(KERN_ERR "NFS: Cannot allocate UDP buffer\n");
697 return NULL;
698 }
699 }
700 strcpy(system_utsname.nodename, in_ntoa(myaddr.sin_addr.s_addr));
701 return rpc_header(rpc_packet, proc, program, version, 0, 0, groups);
702 }
703
704
705
706
707
708 static int root_nfs_get_port(int program, int version)
709 {
710 int *p;
711
712
713 server.sin_port = htons(NFS_PMAP_PORT);
714 p = root_nfs_header(NFS_PMAP_PROC, NFS_PMAP_PROGRAM, NFS_PMAP_VERSION);
715 if (!p)
716 return -1;
717
718
719 *p++ = htonl(program);
720 *p++ = htonl(version);
721 *p++ = htonl(IPPROTO_UDP);
722 *p++ = 0;
723
724
725 if ((p = root_nfs_call(p)) == NULL)
726 return -1;
727
728 return ntohl(*p);
729 }
730
731
732
733
734
735 static int root_nfs_ports(void)
736 {
737 int port;
738
739 if (nfs_port < 0) {
740 if ((port = root_nfs_get_port(NFS_NFS_PROGRAM, NFS_NFS_VERSION)) < 0) {
741 printk(KERN_ERR "NFS: Unable to get nfsd port number from server, using default\n");
742 port = NFS_NFS_PORT;
743 }
744 nfs_port = port;
745 #ifdef NFSROOT_DEBUG
746 printk(KERN_NOTICE "NFS: Portmapper on server returned %d as nfsd port\n", port);
747 #endif
748 }
749
750 if ((port = root_nfs_get_port(NFS_MOUNT_PROGRAM, NFS_MOUNT_VERSION)) < 0) {
751 printk(KERN_ERR "NFS: Unable to get mountd port number from server, using default\n");
752 port = NFS_MOUNT_PORT;
753 }
754 server.sin_port = htons(port);
755 #ifdef NFSROOT_DEBUG
756 printk(KERN_NOTICE "NFS: Portmapper on server returned %d as mountd port\n", port);
757 #endif
758
759 return 0;
760 }
761
762
763
764
765
766 static int root_nfs_get_handle(void)
767 {
768 int len, status, *p;
769
770
771 p = root_nfs_header(NFS_MOUNT_PROC, NFS_MOUNT_PROGRAM, NFS_MOUNT_VERSION);
772 if (!p) {
773 root_nfs_close(1);
774 return -1;
775 }
776
777
778 len = strlen(nfs_path);
779 *p++ = htonl(len);
780 memcpy(p, nfs_path, len);
781 len = (len + 3) >> 2;
782 p[len] = 0;
783 p += len;
784
785
786 if ((p = root_nfs_call(p)) == NULL) {
787 root_nfs_close(1);
788 return -1;
789 }
790
791 status = ntohl(*p++);
792 if (status == 0) {
793 nfs_data.root = *((struct nfs_fh *) p);
794 } else {
795 printk(KERN_ERR "NFS: Server returned error %d while mounting %s\n",
796 status, nfs_path);
797 root_nfs_close(1);
798 return -1;
799 }
800
801 return 0;
802 }
803
804
805
806
807
808 static int root_nfs_do_mount(struct super_block *sb)
809 {
810
811 server.sin_port = htons(nfs_port);
812 nfs_data.addr = server;
813 if (nfs_inode.u.socket_i.ops->connect &&
814 nfs_inode.u.socket_i.ops->connect(&nfs_inode.u.socket_i,
815 (struct sockaddr *) &server, sizeof(struct sockaddr_in),
816 nfs_file.f_flags) < 0) {
817 root_nfs_close(1);
818 return -1;
819 }
820
821
822 if (nfs_read_super(sb, &nfs_data, 1) == NULL) {
823 root_nfs_close(1);
824 return -1;
825 }
826
827 return 0;
828 }
829
830
831
832
833
834
835 int nfs_root_mount(struct super_block *sb)
836 {
837 if (root_nfs_open() < 0)
838 return -1;
839 if (root_nfs_bind() < 0)
840 return -1;
841 if (root_nfs_ports() < 0)
842 return -1;
843 if (root_nfs_get_handle() < 0)
844 return -1;
845 if (root_nfs_do_mount(sb) < 0)
846 return -1;
847 root_nfs_close(0);
848 return 0;
849 }