2 * NFS support driver - based on etherboot and U-BOOT's tftp.c
4 * Masami Komiya <mkomiya@sonare.it> 2004
8 /* NOTE: the NFS code is heavily inspired by the NetBSD netboot code (read:
9 * large portions are copied verbatim) as distributed in OSKit 0.97. A few
10 * changes were necessary to adapt the code to Etherboot and to fix several
11 * inconsistencies. Also the RPC message preparation is done "by hand" to
12 * avoid adding netsprintf() which I find hard to understand and use. */
14 /* NOTE 2: Etherboot does not care about things beyond the kernel image, so
15 * it loads the kernel image off the boot server (ARP_SERVER) and does not
16 * access the client root disk (root-path in dhcpd.conf), which would use
17 * ARP_ROOTSERVER. The root disk is something the operating system we are
18 * about to load needs to use. This is different from the OSKit 0.97 logic. */
20 /* NOTE 3: Symlink handling introduced by Anselm M Hoffmeister, 2003-July-14
21 * If a symlink is encountered, it is followed as far as possible (recursion
22 * possible, maximum 16 steps). There is no clearing of ".."'s inside the
23 * path, so please DON'T DO THAT. thx. */
32 #define HASHES_PER_LINE 65 /* Number of "loading" hashes per line */
33 #define NFS_RETRY_COUNT 30
34 #define NFS_TIMEOUT 2000UL
36 static int fs_mounted
= 0;
37 static unsigned long rpc_id
= 0;
38 static int nfs_offset
= -1;
41 static char dirfh
[NFS_FHSIZE
]; /* file handle of directory */
42 static char filefh
[NFS_FHSIZE
]; /* file handle of kernel image */
44 static int NfsDownloadState
;
45 static IPaddr_t NfsServerIP
;
46 static int NfsSrvMountPort
;
47 static int NfsSrvNfsPort
;
48 static int NfsOurPort
;
49 static int NfsTimeoutCount
;
51 #define STATE_PRCLOOKUP_PROG_MOUNT_REQ 1
52 #define STATE_PRCLOOKUP_PROG_NFS_REQ 2
53 #define STATE_MOUNT_REQ 3
54 #define STATE_UMOUNT_REQ 4
55 #define STATE_LOOKUP_REQ 5
56 #define STATE_READ_REQ 6
57 #define STATE_READLINK_REQ 7
59 static char default_filename
[64];
60 static char *nfs_filename
;
61 static char *nfs_path
;
62 static char nfs_path_buff
[2048];
65 store_block (uchar
* src
, unsigned offset
, unsigned len
)
67 ulong newsize
= offset
+ len
;
68 #ifdef CONFIG_SYS_DIRECT_FLASH_NFS
71 for (i
=0; i
<CONFIG_SYS_MAX_FLASH_BANKS
; i
++) {
72 /* start address in flash? */
73 if (load_addr
+ offset
>= flash_info
[i
].start
[0]) {
79 if (rc
) { /* Flash is destination for this packet */
80 rc
= flash_write ((uchar
*)src
, (ulong
)(load_addr
+offset
), len
);
86 #endif /* CONFIG_SYS_DIRECT_FLASH_NFS */
88 (void)memcpy ((void *)(load_addr
+ offset
), src
, len
);
91 if (NetBootFileXferSize
< (offset
+len
))
92 NetBootFileXferSize
= newsize
;
101 fname
= path
+ strlen(path
) - 1;
102 while (fname
>= path
) {
117 fname
= basename (path
);
123 /**************************************************************************
124 RPC_ADD_CREDENTIALS - Add RPC authentication/verifier entries
125 **************************************************************************/
126 static long *rpc_add_credentials (long *p
)
132 strcpy (hostname
, "");
133 hostnamelen
=strlen (hostname
);
135 /* Here's the executive summary on authentication requirements of the
136 * various NFS server implementations: Linux accepts both AUTH_NONE
137 * and AUTH_UNIX authentication (also accepts an empty hostname field
138 * in the AUTH_UNIX scheme). *BSD refuses AUTH_NONE, but accepts
139 * AUTH_UNIX (also accepts an empty hostname field in the AUTH_UNIX
140 * scheme). To be safe, use AUTH_UNIX and pass the hostname if we have
141 * it (if the BOOTP/DHCP reply didn't give one, just use an empty
144 hl
= (hostnamelen
+ 3) & ~3;
146 /* Provide an AUTH_UNIX credential. */
147 *p
++ = htonl(1); /* AUTH_UNIX */
148 *p
++ = htonl(hl
+20); /* auth length */
149 *p
++ = htonl(0); /* stamp */
150 *p
++ = htonl(hostnamelen
); /* hostname string */
151 if (hostnamelen
& 3) {
152 *(p
+ hostnamelen
/ 4) = 0; /* add zero padding */
154 memcpy (p
, hostname
, hostnamelen
);
158 *p
++ = 0; /* auxiliary gid list */
160 /* Provide an AUTH_NONE verifier. */
161 *p
++ = 0; /* AUTH_NONE */
162 *p
++ = 0; /* auth length */
167 /**************************************************************************
168 RPC_LOOKUP - Lookup RPC Port numbers
169 **************************************************************************/
171 rpc_req (int rpc_prog
, int rpc_proc
, uint32_t *data
, int datalen
)
180 pkt
.u
.call
.id
= htonl(id
);
181 pkt
.u
.call
.type
= htonl(MSG_CALL
);
182 pkt
.u
.call
.rpcvers
= htonl(2); /* use RPC version 2 */
183 pkt
.u
.call
.prog
= htonl(rpc_prog
);
184 pkt
.u
.call
.vers
= htonl(2); /* portmapper is version 2 */
185 pkt
.u
.call
.proc
= htonl(rpc_proc
);
186 p
= (uint32_t *)&(pkt
.u
.call
.data
);
189 memcpy ((char *)p
, (char *)data
, datalen
*sizeof(uint32_t));
191 pktlen
= (char *)p
+ datalen
*sizeof(uint32_t) - (char *)&pkt
;
193 memcpy ((char *)NetTxPacket
+ NetEthHdrSize() + IP_HDR_SIZE
, (char *)&pkt
, pktlen
);
195 if (rpc_prog
== PROG_PORTMAP
)
197 else if (rpc_prog
== PROG_MOUNT
)
198 sport
= NfsSrvMountPort
;
200 sport
= NfsSrvNfsPort
;
202 NetSendUDPPacket (NetServerEther
, NfsServerIP
, sport
, NfsOurPort
, pktlen
);
205 /**************************************************************************
206 RPC_LOOKUP - Lookup RPC Port numbers
207 **************************************************************************/
209 rpc_lookup_req (int prog
, int ver
)
213 data
[0] = 0; data
[1] = 0; /* auth credential */
214 data
[2] = 0; data
[3] = 0; /* auth verifier */
215 data
[4] = htonl(prog
);
216 data
[5] = htonl(ver
);
217 data
[6] = htonl(17); /* IP_UDP */
220 rpc_req (PROG_PORTMAP
, PORTMAP_GETPORT
, data
, 8);
223 /**************************************************************************
224 NFS_MOUNT - Mount an NFS Filesystem
225 **************************************************************************/
227 nfs_mount_req (char *path
)
234 pathlen
= strlen (path
);
237 p
= (uint32_t *)rpc_add_credentials((long *)p
);
239 *p
++ = htonl(pathlen
);
240 if (pathlen
& 3) *(p
+ pathlen
/ 4) = 0;
241 memcpy (p
, path
, pathlen
);
242 p
+= (pathlen
+ 3) / 4;
244 len
= (uint32_t *)p
- (uint32_t *)&(data
[0]);
246 rpc_req (PROG_MOUNT
, MOUNT_ADDENTRY
, data
, len
);
249 /**************************************************************************
250 NFS_UMOUNTALL - Unmount all our NFS Filesystems on the Server
251 **************************************************************************/
253 nfs_umountall_req (void)
259 if ((NfsSrvMountPort
== -1) || (!fs_mounted
)) {
260 /* Nothing mounted, nothing to umount */
265 p
= (uint32_t *)rpc_add_credentials ((long *)p
);
267 len
= (uint32_t *)p
- (uint32_t *)&(data
[0]);
269 rpc_req (PROG_MOUNT
, MOUNT_UMOUNTALL
, data
, len
);
272 /***************************************************************************
273 * NFS_READLINK (AH 2003-07-14)
274 * This procedure is called when read of the first block fails -
275 * this probably happens when it's a directory or a symlink
276 * In case of successful readlink(), the dirname is manipulated,
277 * so that inside the nfs() function a recursion can be done.
278 **************************************************************************/
280 nfs_readlink_req (void)
287 p
= (uint32_t *)rpc_add_credentials ((long *)p
);
289 memcpy (p
, filefh
, NFS_FHSIZE
);
290 p
+= (NFS_FHSIZE
/ 4);
292 len
= (uint32_t *)p
- (uint32_t *)&(data
[0]);
294 rpc_req (PROG_NFS
, NFS_READLINK
, data
, len
);
297 /**************************************************************************
298 NFS_LOOKUP - Lookup Pathname
299 **************************************************************************/
301 nfs_lookup_req (char *fname
)
308 fnamelen
= strlen (fname
);
311 p
= (uint32_t *)rpc_add_credentials ((long *)p
);
313 memcpy (p
, dirfh
, NFS_FHSIZE
);
314 p
+= (NFS_FHSIZE
/ 4);
315 *p
++ = htonl(fnamelen
);
316 if (fnamelen
& 3) *(p
+ fnamelen
/ 4) = 0;
317 memcpy (p
, fname
, fnamelen
);
318 p
+= (fnamelen
+ 3) / 4;
320 len
= (uint32_t *)p
- (uint32_t *)&(data
[0]);
322 rpc_req (PROG_NFS
, NFS_LOOKUP
, data
, len
);
325 /**************************************************************************
326 NFS_READ - Read File on NFS Server
327 **************************************************************************/
329 nfs_read_req (int offset
, int readlen
)
336 p
= (uint32_t *)rpc_add_credentials ((long *)p
);
338 memcpy (p
, filefh
, NFS_FHSIZE
);
339 p
+= (NFS_FHSIZE
/ 4);
340 *p
++ = htonl(offset
);
341 *p
++ = htonl(readlen
);
344 len
= (uint32_t *)p
- (uint32_t *)&(data
[0]);
346 rpc_req (PROG_NFS
, NFS_READ
, data
, len
);
349 /**************************************************************************
350 RPC request dispatcher
351 **************************************************************************/
356 debug("%s\n", __func__
);
359 case STATE_PRCLOOKUP_PROG_MOUNT_REQ
:
360 rpc_lookup_req (PROG_MOUNT
, 1);
362 case STATE_PRCLOOKUP_PROG_NFS_REQ
:
363 rpc_lookup_req (PROG_NFS
, 2);
365 case STATE_MOUNT_REQ
:
366 nfs_mount_req (nfs_path
);
368 case STATE_UMOUNT_REQ
:
369 nfs_umountall_req ();
371 case STATE_LOOKUP_REQ
:
372 nfs_lookup_req (nfs_filename
);
375 nfs_read_req (nfs_offset
, nfs_len
);
377 case STATE_READLINK_REQ
:
383 /**************************************************************************
384 Handlers for the reply from server
385 **************************************************************************/
388 rpc_lookup_reply (int prog
, uchar
*pkt
, unsigned len
)
390 struct rpc_t rpc_pkt
;
392 memcpy ((unsigned char *)&rpc_pkt
, pkt
, len
);
394 debug("%s\n", __func__
);
396 if (ntohl(rpc_pkt
.u
.reply
.id
) != rpc_id
)
399 if (rpc_pkt
.u
.reply
.rstatus
||
400 rpc_pkt
.u
.reply
.verifier
||
401 rpc_pkt
.u
.reply
.astatus
) {
407 NfsSrvMountPort
= ntohl(rpc_pkt
.u
.reply
.data
[0]);
410 NfsSrvNfsPort
= ntohl(rpc_pkt
.u
.reply
.data
[0]);
418 nfs_mount_reply (uchar
*pkt
, unsigned len
)
420 struct rpc_t rpc_pkt
;
422 debug("%s\n", __func__
);
424 memcpy ((unsigned char *)&rpc_pkt
, pkt
, len
);
426 if (ntohl(rpc_pkt
.u
.reply
.id
) != rpc_id
)
429 if (rpc_pkt
.u
.reply
.rstatus
||
430 rpc_pkt
.u
.reply
.verifier
||
431 rpc_pkt
.u
.reply
.astatus
||
432 rpc_pkt
.u
.reply
.data
[0]) {
437 memcpy (dirfh
, rpc_pkt
.u
.reply
.data
+ 1, NFS_FHSIZE
);
443 nfs_umountall_reply (uchar
*pkt
, unsigned len
)
445 struct rpc_t rpc_pkt
;
447 debug("%s\n", __func__
);
449 memcpy ((unsigned char *)&rpc_pkt
, pkt
, len
);
451 if (ntohl(rpc_pkt
.u
.reply
.id
) != rpc_id
)
454 if (rpc_pkt
.u
.reply
.rstatus
||
455 rpc_pkt
.u
.reply
.verifier
||
456 rpc_pkt
.u
.reply
.astatus
) {
461 memset (dirfh
, 0, sizeof(dirfh
));
467 nfs_lookup_reply (uchar
*pkt
, unsigned len
)
469 struct rpc_t rpc_pkt
;
471 debug("%s\n", __func__
);
473 memcpy ((unsigned char *)&rpc_pkt
, pkt
, len
);
475 if (ntohl(rpc_pkt
.u
.reply
.id
) != rpc_id
)
478 if (rpc_pkt
.u
.reply
.rstatus
||
479 rpc_pkt
.u
.reply
.verifier
||
480 rpc_pkt
.u
.reply
.astatus
||
481 rpc_pkt
.u
.reply
.data
[0]) {
485 memcpy (filefh
, rpc_pkt
.u
.reply
.data
+ 1, NFS_FHSIZE
);
491 nfs_readlink_reply (uchar
*pkt
, unsigned len
)
493 struct rpc_t rpc_pkt
;
496 debug("%s\n", __func__
);
498 memcpy ((unsigned char *)&rpc_pkt
, pkt
, len
);
500 if (ntohl(rpc_pkt
.u
.reply
.id
) != rpc_id
)
503 if (rpc_pkt
.u
.reply
.rstatus
||
504 rpc_pkt
.u
.reply
.verifier
||
505 rpc_pkt
.u
.reply
.astatus
||
506 rpc_pkt
.u
.reply
.data
[0]) {
510 rlen
= ntohl (rpc_pkt
.u
.reply
.data
[1]); /* new path length */
512 if (*((char *)&(rpc_pkt
.u
.reply
.data
[2])) != '/') {
514 strcat (nfs_path
, "/");
515 pathlen
= strlen(nfs_path
);
516 memcpy (nfs_path
+pathlen
, (uchar
*)&(rpc_pkt
.u
.reply
.data
[2]), rlen
);
517 nfs_path
[pathlen
+ rlen
] = 0;
519 memcpy (nfs_path
, (uchar
*)&(rpc_pkt
.u
.reply
.data
[2]), rlen
);
526 nfs_read_reply (uchar
*pkt
, unsigned len
)
528 struct rpc_t rpc_pkt
;
531 debug("%s\n", __func__
);
533 memcpy ((uchar
*)&rpc_pkt
, pkt
, sizeof(rpc_pkt
.u
.reply
));
535 if (ntohl(rpc_pkt
.u
.reply
.id
) != rpc_id
)
538 if (rpc_pkt
.u
.reply
.rstatus
||
539 rpc_pkt
.u
.reply
.verifier
||
540 rpc_pkt
.u
.reply
.astatus
||
541 rpc_pkt
.u
.reply
.data
[0]) {
542 if (rpc_pkt
.u
.reply
.rstatus
) {
545 if (rpc_pkt
.u
.reply
.astatus
) {
548 return -ntohl(rpc_pkt
.u
.reply
.data
[0]);;
551 if ((nfs_offset
!=0) && !((nfs_offset
) % (NFS_READ_SIZE
/2*10*HASHES_PER_LINE
))) {
554 if (!(nfs_offset
% ((NFS_READ_SIZE
/2)*10))) {
558 rlen
= ntohl(rpc_pkt
.u
.reply
.data
[18]);
559 if ( store_block ((uchar
*)pkt
+sizeof(rpc_pkt
.u
.reply
), nfs_offset
, rlen
) )
565 /**************************************************************************
567 **************************************************************************/
572 if ( ++NfsTimeoutCount
> NFS_RETRY_COUNT
) {
573 puts ("\nRetry count exceeded; starting again\n");
577 NetSetTimeout (NFS_TIMEOUT
, NfsTimeout
);
583 NfsHandler(uchar
*pkt
, unsigned dest
, IPaddr_t sip
, unsigned src
, unsigned len
)
587 debug("%s\n", __func__
);
589 if (dest
!= NfsOurPort
) return;
592 case STATE_PRCLOOKUP_PROG_MOUNT_REQ
:
593 rpc_lookup_reply (PROG_MOUNT
, pkt
, len
);
594 NfsState
= STATE_PRCLOOKUP_PROG_NFS_REQ
;
598 case STATE_PRCLOOKUP_PROG_NFS_REQ
:
599 rpc_lookup_reply (PROG_NFS
, pkt
, len
);
600 NfsState
= STATE_MOUNT_REQ
;
604 case STATE_MOUNT_REQ
:
605 if (nfs_mount_reply(pkt
, len
)) {
606 puts ("*** ERROR: Cannot mount\n");
607 /* just to be sure... */
608 NfsState
= STATE_UMOUNT_REQ
;
611 NfsState
= STATE_LOOKUP_REQ
;
616 case STATE_UMOUNT_REQ
:
617 if (nfs_umountall_reply(pkt
, len
)) {
618 puts ("*** ERROR: Cannot umount\n");
619 NetState
= NETLOOP_FAIL
;
622 NetState
= NfsDownloadState
;
626 case STATE_LOOKUP_REQ
:
627 if (nfs_lookup_reply(pkt
, len
)) {
628 puts ("*** ERROR: File lookup fail\n");
629 NfsState
= STATE_UMOUNT_REQ
;
632 NfsState
= STATE_READ_REQ
;
634 nfs_len
= NFS_READ_SIZE
;
639 case STATE_READLINK_REQ
:
640 if (nfs_readlink_reply(pkt
, len
)) {
641 puts ("*** ERROR: Symlink fail\n");
642 NfsState
= STATE_UMOUNT_REQ
;
645 debug("Symlink --> %s\n", nfs_path
);
646 nfs_filename
= basename (nfs_path
);
647 nfs_path
= dirname (nfs_path
);
649 NfsState
= STATE_MOUNT_REQ
;
655 rlen
= nfs_read_reply (pkt
, len
);
656 NetSetTimeout (NFS_TIMEOUT
, NfsTimeout
);
661 else if ((rlen
== -NFSERR_ISDIR
)||(rlen
== -NFSERR_INVAL
)) {
663 NfsState
= STATE_READLINK_REQ
;
666 if ( ! rlen
) NfsDownloadState
= NETLOOP_SUCCESS
;
667 NfsState
= STATE_UMOUNT_REQ
;
678 debug("%s\n", __func__
);
679 NfsDownloadState
= NETLOOP_FAIL
;
681 NfsServerIP
= NetServerIP
;
682 nfs_path
= (char *)nfs_path_buff
;
684 if (nfs_path
== NULL
) {
685 NetState
= NETLOOP_FAIL
;
686 puts ("*** ERROR: Fail allocate memory\n");
690 if (BootFile
[0] == '\0') {
691 sprintf(default_filename
, "/nfsroot/%02X%02X%02X%02X.img",
693 (NetOurIP
>> 8) & 0xFF,
694 (NetOurIP
>> 16) & 0xFF,
695 (NetOurIP
>> 24) & 0xFF );
696 strcpy (nfs_path
, default_filename
);
698 printf ("*** Warning: no boot file name; using '%s'\n",
706 NfsServerIP
= string_to_ip (BootFile
);
708 strcpy (nfs_path
, p
);
710 strcpy (nfs_path
, BootFile
);
714 nfs_filename
= basename (nfs_path
);
715 nfs_path
= dirname (nfs_path
);
717 printf ("Using %s device\n", eth_get_name());
719 printf("File transfer via NFS from server %pI4"
720 "; our IP address is %pI4", &NfsServerIP
, &NetOurIP
);
722 /* Check if we need to send across this subnet */
723 if (NetOurGatewayIP
&& NetOurSubnetMask
) {
724 IPaddr_t OurNet
= NetOurIP
& NetOurSubnetMask
;
725 IPaddr_t ServerNet
= NetServerIP
& NetOurSubnetMask
;
727 if (OurNet
!= ServerNet
)
728 printf("; sending through gateway %pI4", &NetOurGatewayIP
);
730 printf ("\nFilename '%s/%s'.", nfs_path
, nfs_filename
);
732 if (NetBootFileSize
) {
733 printf (" Size is 0x%x Bytes = ", NetBootFileSize
<<9);
734 print_size (NetBootFileSize
<<9, "");
736 printf ("\nLoad address: 0x%lx\n"
737 "Loading: *\b", load_addr
);
739 NetSetTimeout (NFS_TIMEOUT
, NfsTimeout
);
740 NetSetHandler (NfsHandler
);
743 NfsState
= STATE_PRCLOOKUP_PROG_MOUNT_REQ
;
745 /*NfsOurPort = 4096 + (get_ticks() % 3072);*/
749 /* zero out server ether in case the server ip has changed */
750 memset (NetServerEther
, 0, 6);