X-Git-Url: https://git.kernelconcepts.de/?p=karo-tx-uboot.git;a=blobdiff_plain;f=net%2Fnfs.c;h=78968d82e94b25d5accec9b655c6bb37918dc38b;hp=137b3bf8398c46398800a3c8dc1ef753c7032bea;hb=4ace9bb52864de73b4a092e7110129fb38b1e451;hpb=4b9206ed51a3e3dc06dca2a3930a24e4f0025f3d diff --git a/net/nfs.c b/net/nfs.c index 137b3bf839..78968d82e9 100644 --- a/net/nfs.c +++ b/net/nfs.c @@ -26,30 +26,37 @@ #include #include #include +#include #include "nfs.h" #include "bootp.h" -/*#define NFS_DEBUG*/ - -#if ((CONFIG_COMMANDS & CFG_CMD_NET) && (CONFIG_COMMANDS & CFG_CMD_NFS)) - #define HASHES_PER_LINE 65 /* Number of "loading" hashes per line */ -#define NFS_TIMEOUT 10 +#define NFS_RETRY_COUNT 30 +#ifndef CONFIG_NFS_TIMEOUT +# define NFS_TIMEOUT 2000UL +#else +# define NFS_TIMEOUT CONFIG_NFS_TIMEOUT +#endif + +#define NFS_RPC_ERR 1 +#define NFS_RPC_DROP 124 -static int fs_mounted = 0; -static unsigned long rpc_id = 0; +static int fs_mounted; +static unsigned long rpc_id; static int nfs_offset = -1; static int nfs_len; +static ulong nfs_timeout = NFS_TIMEOUT; static char dirfh[NFS_FHSIZE]; /* file handle of directory */ static char filefh[NFS_FHSIZE]; /* file handle of kernel image */ -static IPaddr_t NfsServerIP; -static int NfsSrvMountPort; -static int NfsSrvNfsPort; -static int NfsOurPort; -static int NfsTimeoutCount; -static int NfsState; +static enum net_loop_state nfs_download_state; +static struct in_addr nfs_server_ip; +static int nfs_server_mount_port; +static int nfs_server_port; +static int nfs_our_port; +static int nfs_timeout_count; +static int nfs_state; #define STATE_PRCLOOKUP_PROG_MOUNT_REQ 1 #define STATE_PRCLOOKUP_PROG_NFS_REQ 2 #define STATE_MOUNT_REQ 3 @@ -63,14 +70,13 @@ static char *nfs_filename; static char *nfs_path; static char nfs_path_buff[2048]; -static __inline__ void -store_block (uchar * src, unsigned offset, unsigned len) +static inline int store_block(uchar *src, unsigned offset, unsigned len) { ulong newsize = offset + len; -#ifdef CFG_DIRECT_FLASH_NFS +#ifdef CONFIG_SYS_DIRECT_FLASH_NFS int i, rc = 0; - for (i=0; i= flash_info[i].start[0]) { rc = 1; @@ -79,24 +85,26 @@ store_block (uchar * src, unsigned offset, unsigned len) } if (rc) { /* Flash is destination for this packet */ - rc = flash_write ((uchar *)src, (ulong)(load_addr+offset), len); + rc = flash_write((uchar *)src, (ulong)(load_addr+offset), len); if (rc) { - flash_perror (rc); - NetState = NETLOOP_FAIL; - return; + flash_perror(rc); + return -1; } } else -#endif /* CFG_DIRECT_FLASH_NFS */ +#endif /* CONFIG_SYS_DIRECT_FLASH_NFS */ { - (void)memcpy ((void *)(load_addr + offset), src, len); + void *ptr = map_sysmem(load_addr + offset, len); + + memcpy(ptr, src, len); + unmap_sysmem(ptr); } - if (NetBootFileXferSize < (offset+len)) - NetBootFileXferSize = newsize; + if (net_boot_file_size < (offset + len)) + net_boot_file_size = newsize; + return 0; } -static char* -basename (char *path) +static char *basename(char *path) { char *fname; @@ -111,12 +119,11 @@ basename (char *path) return fname; } -static char* -dirname (char *path) +static char *dirname(char *path) { char *fname; - fname = basename (path); + fname = basename(path); --fname; *fname = '\0'; return path; @@ -125,14 +132,14 @@ dirname (char *path) /************************************************************************** RPC_ADD_CREDENTIALS - Add RPC authentication/verifier entries **************************************************************************/ -static long *rpc_add_credentials (long *p) +static long *rpc_add_credentials(long *p) { int hl; int hostnamelen; char hostname[256]; - strcpy (hostname, ""); - hostnamelen=strlen (hostname); + strcpy(hostname, ""); + hostnamelen = strlen(hostname); /* Here's the executive summary on authentication requirements of the * various NFS server implementations: Linux accepts both AUTH_NONE @@ -150,10 +157,9 @@ static long *rpc_add_credentials (long *p) *p++ = htonl(hl+20); /* auth length */ *p++ = htonl(0); /* stamp */ *p++ = htonl(hostnamelen); /* hostname string */ - if (hostnamelen & 3) { + if (hostnamelen & 3) *(p + hostnamelen / 4) = 0; /* add zero padding */ - } - memcpy (p, hostname, hostnamelen); + memcpy(p, hostname, hostnamelen); p += hl / 4; *p++ = 0; /* uid */ *p++ = 0; /* gid */ @@ -169,8 +175,7 @@ static long *rpc_add_credentials (long *p) /************************************************************************** RPC_LOOKUP - Lookup RPC Port numbers **************************************************************************/ -static void -rpc_req (int rpc_prog, int rpc_proc, uint32_t *data, int datalen) +static void rpc_req(int rpc_prog, int rpc_proc, uint32_t *data, int datalen) { struct rpc_t pkt; unsigned long id; @@ -188,27 +193,28 @@ rpc_req (int rpc_prog, int rpc_proc, uint32_t *data, int datalen) p = (uint32_t *)&(pkt.u.call.data); if (datalen) - memcpy ((char *)p, (char *)data, datalen*sizeof(uint32_t)); + memcpy((char *)p, (char *)data, datalen*sizeof(uint32_t)); pktlen = (char *)p + datalen*sizeof(uint32_t) - (char *)&pkt; - memcpy ((char *)NetTxPacket+ETHER_HDR_SIZE+IP_HDR_SIZE, (char *)&pkt, pktlen); + memcpy((char *)net_tx_packet + net_eth_hdr_size() + IP_UDP_HDR_SIZE, + (char *)&pkt, pktlen); if (rpc_prog == PROG_PORTMAP) sport = SUNRPC_PORT; else if (rpc_prog == PROG_MOUNT) - sport = NfsSrvMountPort; + sport = nfs_server_mount_port; else - sport = NfsSrvNfsPort; + sport = nfs_server_port; - NetSendUDPPacket (NetServerEther, NfsServerIP, sport, NfsOurPort, pktlen); + net_send_udp_packet(net_server_ethaddr, nfs_server_ip, sport, + nfs_our_port, pktlen); } /************************************************************************** RPC_LOOKUP - Lookup RPC Port numbers **************************************************************************/ -static void -rpc_lookup_req (int prog, int ver) +static void rpc_lookup_req(int prog, int ver) { uint32_t data[16]; @@ -219,56 +225,54 @@ rpc_lookup_req (int prog, int ver) data[6] = htonl(17); /* IP_UDP */ data[7] = 0; - rpc_req (PROG_PORTMAP, PORTMAP_GETPORT, data, 8); + rpc_req(PROG_PORTMAP, PORTMAP_GETPORT, data, 8); } /************************************************************************** NFS_MOUNT - Mount an NFS Filesystem **************************************************************************/ -static void -nfs_mount_req (char *path) +static void nfs_mount_req(char *path) { uint32_t data[1024]; uint32_t *p; int len; int pathlen; - pathlen = strlen (path); + pathlen = strlen(path); p = &(data[0]); p = (uint32_t *)rpc_add_credentials((long *)p); *p++ = htonl(pathlen); - if (pathlen & 3) *(p + pathlen / 4) = 0; - memcpy (p, path, pathlen); + if (pathlen & 3) + *(p + pathlen / 4) = 0; + memcpy(p, path, pathlen); p += (pathlen + 3) / 4; len = (uint32_t *)p - (uint32_t *)&(data[0]); - rpc_req (PROG_MOUNT, MOUNT_ADDENTRY, data, len); + rpc_req(PROG_MOUNT, MOUNT_ADDENTRY, data, len); } /************************************************************************** NFS_UMOUNTALL - Unmount all our NFS Filesystems on the Server **************************************************************************/ -static void -nfs_umountall_req (void) +static void nfs_umountall_req(void) { uint32_t data[1024]; uint32_t *p; int len; - if ((NfsSrvMountPort == -1) || (!fs_mounted)) { + if ((nfs_server_mount_port == -1) || (!fs_mounted)) /* Nothing mounted, nothing to umount */ return; - } p = &(data[0]); - p = (uint32_t *)rpc_add_credentials ((long *)p); + p = (uint32_t *)rpc_add_credentials((long *)p); len = (uint32_t *)p - (uint32_t *)&(data[0]); - rpc_req (PROG_MOUNT, MOUNT_UMOUNTALL, data, len); + rpc_req(PROG_MOUNT, MOUNT_UMOUNTALL, data, len); } /*************************************************************************** @@ -278,66 +282,64 @@ nfs_umountall_req (void) * In case of successful readlink(), the dirname is manipulated, * so that inside the nfs() function a recursion can be done. **************************************************************************/ -static void -nfs_readlink_req (void) +static void nfs_readlink_req(void) { uint32_t data[1024]; uint32_t *p; int len; p = &(data[0]); - p = (uint32_t *)rpc_add_credentials ((long *)p); + p = (uint32_t *)rpc_add_credentials((long *)p); - memcpy (p, filefh, NFS_FHSIZE); + memcpy(p, filefh, NFS_FHSIZE); p += (NFS_FHSIZE / 4); len = (uint32_t *)p - (uint32_t *)&(data[0]); - rpc_req (PROG_NFS, NFS_READLINK, data, len); + rpc_req(PROG_NFS, NFS_READLINK, data, len); } /************************************************************************** NFS_LOOKUP - Lookup Pathname **************************************************************************/ -static void -nfs_lookup_req (char *fname) +static void nfs_lookup_req(char *fname) { uint32_t data[1024]; uint32_t *p; int len; int fnamelen; - fnamelen = strlen (fname); + fnamelen = strlen(fname); p = &(data[0]); - p = (uint32_t *)rpc_add_credentials ((long *)p); + p = (uint32_t *)rpc_add_credentials((long *)p); - memcpy (p, dirfh, NFS_FHSIZE); + memcpy(p, dirfh, NFS_FHSIZE); p += (NFS_FHSIZE / 4); *p++ = htonl(fnamelen); - if (fnamelen & 3) *(p + fnamelen / 4) = 0; - memcpy (p, fname, fnamelen); + if (fnamelen & 3) + *(p + fnamelen / 4) = 0; + memcpy(p, fname, fnamelen); p += (fnamelen + 3) / 4; len = (uint32_t *)p - (uint32_t *)&(data[0]); - rpc_req (PROG_NFS, NFS_LOOKUP, data, len); + rpc_req(PROG_NFS, NFS_LOOKUP, data, len); } /************************************************************************** NFS_READ - Read File on NFS Server **************************************************************************/ -static void -nfs_read_req (int offset, int readlen) +static void nfs_read_req(int offset, int readlen) { uint32_t data[1024]; uint32_t *p; int len; p = &(data[0]); - p = (uint32_t *)rpc_add_credentials ((long *)p); + p = (uint32_t *)rpc_add_credentials((long *)p); - memcpy (p, filefh, NFS_FHSIZE); + memcpy(p, filefh, NFS_FHSIZE); p += (NFS_FHSIZE / 4); *p++ = htonl(offset); *p++ = htonl(readlen); @@ -345,41 +347,37 @@ nfs_read_req (int offset, int readlen) len = (uint32_t *)p - (uint32_t *)&(data[0]); - rpc_req (PROG_NFS, NFS_READ, data, len); + rpc_req(PROG_NFS, NFS_READ, data, len); } /************************************************************************** RPC request dispatcher **************************************************************************/ - -static void -NfsSend (void) +static void nfs_send(void) { -#ifdef NFS_DEBUG - printf ("%s\n", __FUNCTION__); -#endif + debug("%s\n", __func__); - switch (NfsState) { + switch (nfs_state) { case STATE_PRCLOOKUP_PROG_MOUNT_REQ: - rpc_lookup_req (PROG_MOUNT, 1); + rpc_lookup_req(PROG_MOUNT, 1); break; case STATE_PRCLOOKUP_PROG_NFS_REQ: - rpc_lookup_req (PROG_NFS, 2); + rpc_lookup_req(PROG_NFS, 2); break; case STATE_MOUNT_REQ: - nfs_mount_req (nfs_path); + nfs_mount_req(nfs_path); break; case STATE_UMOUNT_REQ: - nfs_umountall_req (); + nfs_umountall_req(); break; case STATE_LOOKUP_REQ: - nfs_lookup_req (nfs_filename); + nfs_lookup_req(nfs_filename); break; case STATE_READ_REQ: - nfs_read_req (nfs_offset, nfs_len); + nfs_read_req(nfs_offset, nfs_len); break; case STATE_READLINK_REQ: - nfs_readlink_req (); + nfs_readlink_req(); break; } } @@ -388,192 +386,180 @@ NfsSend (void) Handlers for the reply from server **************************************************************************/ -static int -rpc_lookup_reply (int prog, uchar *pkt, unsigned len) +static int rpc_lookup_reply(int prog, uchar *pkt, unsigned len) { struct rpc_t rpc_pkt; - memcpy ((unsigned char *)&rpc_pkt, pkt, len); + memcpy((unsigned char *)&rpc_pkt, pkt, len); -#ifdef NFS_DEBUG - printf ("%s\n", __FUNCTION__); -#endif + debug("%s\n", __func__); - if (ntohl(rpc_pkt.u.reply.id) != rpc_id) - return -1; + if (ntohl(rpc_pkt.u.reply.id) > rpc_id) + return -NFS_RPC_ERR; + else if (ntohl(rpc_pkt.u.reply.id) < rpc_id) + return -NFS_RPC_DROP; if (rpc_pkt.u.reply.rstatus || rpc_pkt.u.reply.verifier || - rpc_pkt.u.reply.astatus || - rpc_pkt.u.reply.astatus) { + rpc_pkt.u.reply.astatus) return -1; - } switch (prog) { case PROG_MOUNT: - NfsSrvMountPort = ntohl(rpc_pkt.u.reply.data[0]); + nfs_server_mount_port = ntohl(rpc_pkt.u.reply.data[0]); break; case PROG_NFS: - NfsSrvNfsPort = ntohl(rpc_pkt.u.reply.data[0]); + nfs_server_port = ntohl(rpc_pkt.u.reply.data[0]); break; } return 0; } -static int -nfs_mount_reply (uchar *pkt, unsigned len) +static int nfs_mount_reply(uchar *pkt, unsigned len) { struct rpc_t rpc_pkt; -#ifdef NFS_DEBUG - printf ("%s\n", __FUNCTION__); -#endif + debug("%s\n", __func__); - memcpy ((unsigned char *)&rpc_pkt, pkt, len); + memcpy((unsigned char *)&rpc_pkt, pkt, len); - if (ntohl(rpc_pkt.u.reply.id) != rpc_id) - return -1; + if (ntohl(rpc_pkt.u.reply.id) > rpc_id) + return -NFS_RPC_ERR; + else if (ntohl(rpc_pkt.u.reply.id) < rpc_id) + return -NFS_RPC_DROP; if (rpc_pkt.u.reply.rstatus || rpc_pkt.u.reply.verifier || rpc_pkt.u.reply.astatus || - rpc_pkt.u.reply.data[0]) { + rpc_pkt.u.reply.data[0]) return -1; - } fs_mounted = 1; - memcpy (dirfh, rpc_pkt.u.reply.data + 1, NFS_FHSIZE); + memcpy(dirfh, rpc_pkt.u.reply.data + 1, NFS_FHSIZE); return 0; } -static int -nfs_umountall_reply (uchar *pkt, unsigned len) +static int nfs_umountall_reply(uchar *pkt, unsigned len) { struct rpc_t rpc_pkt; -#ifdef NFS_DEBUG - printf ("%s\n", __FUNCTION__); -#endif + debug("%s\n", __func__); - memcpy ((unsigned char *)&rpc_pkt, pkt, len); + memcpy((unsigned char *)&rpc_pkt, pkt, len); - if (ntohl(rpc_pkt.u.reply.id) != rpc_id) - return -1; + if (ntohl(rpc_pkt.u.reply.id) > rpc_id) + return -NFS_RPC_ERR; + else if (ntohl(rpc_pkt.u.reply.id) < rpc_id) + return -NFS_RPC_DROP; if (rpc_pkt.u.reply.rstatus || rpc_pkt.u.reply.verifier || - rpc_pkt.u.reply.astatus) { + rpc_pkt.u.reply.astatus) return -1; - } fs_mounted = 0; - memset (dirfh, 0, sizeof(dirfh)); + memset(dirfh, 0, sizeof(dirfh)); return 0; } -static int -nfs_lookup_reply (uchar *pkt, unsigned len) +static int nfs_lookup_reply(uchar *pkt, unsigned len) { struct rpc_t rpc_pkt; -#ifdef NFS_DEBUG - printf ("%s\n", __FUNCTION__); -#endif + debug("%s\n", __func__); - memcpy ((unsigned char *)&rpc_pkt, pkt, len); + memcpy((unsigned char *)&rpc_pkt, pkt, len); - if (ntohl(rpc_pkt.u.reply.id) != rpc_id) - return -1; + if (ntohl(rpc_pkt.u.reply.id) > rpc_id) + return -NFS_RPC_ERR; + else if (ntohl(rpc_pkt.u.reply.id) < rpc_id) + return -NFS_RPC_DROP; if (rpc_pkt.u.reply.rstatus || rpc_pkt.u.reply.verifier || rpc_pkt.u.reply.astatus || - rpc_pkt.u.reply.data[0]) { + rpc_pkt.u.reply.data[0]) return -1; - } - memcpy (filefh, rpc_pkt.u.reply.data + 1, NFS_FHSIZE); + memcpy(filefh, rpc_pkt.u.reply.data + 1, NFS_FHSIZE); return 0; } -static int -nfs_readlink_reply (uchar *pkt, unsigned len) +static int nfs_readlink_reply(uchar *pkt, unsigned len) { struct rpc_t rpc_pkt; int rlen; -#ifdef NFS_DEBUG - printf ("%s\n", __FUNCTION__); -#endif + debug("%s\n", __func__); - memcpy ((unsigned char *)&rpc_pkt, pkt, len); + memcpy((unsigned char *)&rpc_pkt, pkt, len); - if (ntohl(rpc_pkt.u.reply.id) != rpc_id) - return -1; + if (ntohl(rpc_pkt.u.reply.id) > rpc_id) + return -NFS_RPC_ERR; + else if (ntohl(rpc_pkt.u.reply.id) < rpc_id) + return -NFS_RPC_DROP; if (rpc_pkt.u.reply.rstatus || rpc_pkt.u.reply.verifier || rpc_pkt.u.reply.astatus || - rpc_pkt.u.reply.data[0]) { + rpc_pkt.u.reply.data[0]) return -1; - } - rlen = ntohl (rpc_pkt.u.reply.data[1]); /* new path length */ + rlen = ntohl(rpc_pkt.u.reply.data[1]); /* new path length */ if (*((char *)&(rpc_pkt.u.reply.data[2])) != '/') { int pathlen; - strcat (nfs_path, "/"); + strcat(nfs_path, "/"); pathlen = strlen(nfs_path); - memcpy (nfs_path+pathlen, (uchar *)&(rpc_pkt.u.reply.data[2]), rlen); - nfs_path[pathlen+rlen+1] = 0; + memcpy(nfs_path + pathlen, (uchar *)&(rpc_pkt.u.reply.data[2]), + rlen); + nfs_path[pathlen + rlen] = 0; } else { - memcpy (nfs_path, (uchar *)&(rpc_pkt.u.reply.data[2]), rlen); + memcpy(nfs_path, (uchar *)&(rpc_pkt.u.reply.data[2]), rlen); nfs_path[rlen] = 0; } return 0; } -static int -nfs_read_reply (uchar *pkt, unsigned len) +static int nfs_read_reply(uchar *pkt, unsigned len) { struct rpc_t rpc_pkt; int rlen; -#ifdef NFS_DEBUG_nop - printf ("%s\n", __FUNCTION__); -#endif + debug("%s\n", __func__); - memcpy ((uchar *)&rpc_pkt, pkt, sizeof(rpc_pkt.u.reply)); + memcpy((uchar *)&rpc_pkt, pkt, sizeof(rpc_pkt.u.reply)); - if (ntohl(rpc_pkt.u.reply.id) != rpc_id) - return -1; + if (ntohl(rpc_pkt.u.reply.id) > rpc_id) + return -NFS_RPC_ERR; + else if (ntohl(rpc_pkt.u.reply.id) < rpc_id) + return -NFS_RPC_DROP; if (rpc_pkt.u.reply.rstatus || rpc_pkt.u.reply.verifier || rpc_pkt.u.reply.astatus || rpc_pkt.u.reply.data[0]) { - if (rpc_pkt.u.reply.rstatus) { + if (rpc_pkt.u.reply.rstatus) return -9999; - } - if (rpc_pkt.u.reply.astatus) { + if (rpc_pkt.u.reply.astatus) return -9999; - } - return -ntohl(rpc_pkt.u.reply.data[0]);; + return -ntohl(rpc_pkt.u.reply.data[0]); } - if ((nfs_offset!=0) && !((nfs_offset) % (NFS_READ_SIZE/2*10*HASHES_PER_LINE))) { - puts ("\n\t "); - } - if (!(nfs_offset % ((NFS_READ_SIZE/2)*10))) { - putc ('#'); - } + if ((nfs_offset != 0) && !((nfs_offset) % + (NFS_READ_SIZE / 2 * 10 * HASHES_PER_LINE))) + puts("\n\t "); + if (!(nfs_offset % ((NFS_READ_SIZE / 2) * 10))) + putc('#'); rlen = ntohl(rpc_pkt.u.reply.data[18]); - store_block ((uchar *)pkt+sizeof(rpc_pkt.u.reply), nfs_offset, rlen); + if (store_block((uchar *)pkt + sizeof(rpc_pkt.u.reply), + nfs_offset, rlen)) + return -9999; return rlen; } @@ -581,194 +567,208 @@ nfs_read_reply (uchar *pkt, unsigned len) /************************************************************************** Interfaces of U-BOOT **************************************************************************/ +static void nfs_timeout_handler(void) +{ + if (++nfs_timeout_count > NFS_RETRY_COUNT) { + puts("\nRetry count exceeded; starting again\n"); + net_start_again(); + } else { + puts("T "); + net_set_timeout_handler(nfs_timeout + + NFS_TIMEOUT * nfs_timeout_count, + nfs_timeout_handler); + nfs_send(); + } +} -static void -NfsHandler (uchar *pkt, unsigned dest, unsigned src, unsigned len) +static void nfs_handler(uchar *pkt, unsigned dest, struct in_addr sip, + unsigned src, unsigned len) { int rlen; + int reply; -#ifdef NFS_DEBUG - printf ("%s\n", __FUNCTION__); -#endif + debug("%s\n", __func__); - if (dest != NfsOurPort) return; + if (dest != nfs_our_port) + return; - switch (NfsState) { + switch (nfs_state) { case STATE_PRCLOOKUP_PROG_MOUNT_REQ: - rpc_lookup_reply (PROG_MOUNT, pkt, len); - NfsState = STATE_PRCLOOKUP_PROG_NFS_REQ; - NfsSend (); + if (rpc_lookup_reply(PROG_MOUNT, pkt, len) == -NFS_RPC_DROP) + break; + nfs_state = STATE_PRCLOOKUP_PROG_NFS_REQ; + nfs_send(); break; case STATE_PRCLOOKUP_PROG_NFS_REQ: - rpc_lookup_reply (PROG_NFS, pkt, len); - NfsState = STATE_MOUNT_REQ; - NfsSend (); + if (rpc_lookup_reply(PROG_NFS, pkt, len) == -NFS_RPC_DROP) + break; + nfs_state = STATE_MOUNT_REQ; + nfs_send(); break; case STATE_MOUNT_REQ: - if (nfs_mount_reply(pkt, len)) { - puts ("*** ERROR: Cannot mount\n"); + reply = nfs_mount_reply(pkt, len); + if (reply == -NFS_RPC_DROP) { + break; + } else if (reply == -NFS_RPC_ERR) { + puts("*** ERROR: Cannot mount\n"); /* just to be sure... */ - NfsState = STATE_UMOUNT_REQ; - NfsSend (); + nfs_state = STATE_UMOUNT_REQ; + nfs_send(); } else { - NfsState = STATE_LOOKUP_REQ; - NfsSend (); + nfs_state = STATE_LOOKUP_REQ; + nfs_send(); } break; case STATE_UMOUNT_REQ: - if (nfs_umountall_reply(pkt, len)) { - puts ("*** ERROR: Cannot umount\n"); - NetState = NETLOOP_FAIL; + reply = nfs_umountall_reply(pkt, len); + if (reply == -NFS_RPC_DROP) { + break; + } else if (reply == -NFS_RPC_ERR) { + puts("*** ERROR: Cannot umount\n"); + net_set_state(NETLOOP_FAIL); } else { - puts ("\ndone\n"); - NetState = NETLOOP_SUCCESS; + puts("\ndone\n"); + net_set_state(nfs_download_state); } break; case STATE_LOOKUP_REQ: - if (nfs_lookup_reply(pkt, len)) { - puts ("*** ERROR: File lookup fail\n"); - NfsState = STATE_UMOUNT_REQ; - NfsSend (); + reply = nfs_lookup_reply(pkt, len); + if (reply == -NFS_RPC_DROP) { + break; + } else if (reply == -NFS_RPC_ERR) { + puts("*** ERROR: File lookup fail\n"); + nfs_state = STATE_UMOUNT_REQ; + nfs_send(); } else { - NfsState = STATE_READ_REQ; + nfs_state = STATE_READ_REQ; nfs_offset = 0; nfs_len = NFS_READ_SIZE; - NfsSend (); + nfs_send(); } break; case STATE_READLINK_REQ: - if (nfs_readlink_reply(pkt, len)) { - puts ("*** ERROR: Symlink fail\n"); - NfsState = STATE_UMOUNT_REQ; - NfsSend (); + reply = nfs_readlink_reply(pkt, len); + if (reply == -NFS_RPC_DROP) { + break; + } else if (reply == -NFS_RPC_ERR) { + puts("*** ERROR: Symlink fail\n"); + nfs_state = STATE_UMOUNT_REQ; + nfs_send(); } else { -#ifdef NFS_DEBUG - printf ("Symlink --> %s\n", nfs_path); -#endif - nfs_filename = basename (nfs_path); - nfs_path = dirname (nfs_path); + debug("Symlink --> %s\n", nfs_path); + nfs_filename = basename(nfs_path); + nfs_path = dirname(nfs_path); - NfsState = STATE_MOUNT_REQ; - NfsSend (); + nfs_state = STATE_MOUNT_REQ; + nfs_send(); } break; case STATE_READ_REQ: - rlen = nfs_read_reply (pkt, len); + rlen = nfs_read_reply(pkt, len); + net_set_timeout_handler(nfs_timeout, nfs_timeout_handler); if (rlen > 0) { nfs_offset += rlen; - NfsSend (); - } - else if ((rlen == -NFSERR_ISDIR)||(rlen == -NFSERR_INVAL)) { + nfs_send(); + } else if ((rlen == -NFSERR_ISDIR) || (rlen == -NFSERR_INVAL)) { /* symbolic link */ - NfsState = STATE_READLINK_REQ; - NfsSend (); + nfs_state = STATE_READLINK_REQ; + nfs_send(); } else { - NfsState = STATE_UMOUNT_REQ; - NfsSend (); + if (!rlen) + nfs_download_state = NETLOOP_SUCCESS; + nfs_state = STATE_UMOUNT_REQ; + nfs_send(); } break; } } -static void -NfsTimeout (void) -{ - puts ("Timeout\n"); - NetState = NETLOOP_FAIL; - return; -} -void -NfsStart (void) +void nfs_start(void) { -#ifdef NFS_DEBUG - printf ("%s\n", __FUNCTION__); -#endif + debug("%s\n", __func__); + nfs_download_state = NETLOOP_FAIL; - NfsServerIP = NetServerIP; + nfs_server_ip = net_server_ip; nfs_path = (char *)nfs_path_buff; if (nfs_path == NULL) { - NetState = NETLOOP_FAIL; - puts ("*** ERROR: Fail allocate memory\n"); + net_set_state(NETLOOP_FAIL); + puts("*** ERROR: Fail allocate memory\n"); return; } - if (BootFile[0] == '\0') { - IPaddr_t OurIP = ntohl (NetOurIP); + if (net_boot_file_name[0] == '\0') { + sprintf(default_filename, "/nfsroot/%02X%02X%02X%02X.img", + net_ip.s_addr & 0xFF, + (net_ip.s_addr >> 8) & 0xFF, + (net_ip.s_addr >> 16) & 0xFF, + (net_ip.s_addr >> 24) & 0xFF); + strcpy(nfs_path, default_filename); - sprintf (default_filename, "/nfsroot/%02lX%02lX%02lX%02lX.img", - OurIP & 0xFF, - (OurIP >> 8) & 0xFF, - (OurIP >> 16) & 0xFF, - (OurIP >> 24) & 0xFF ); - strcpy (nfs_path, default_filename); - - printf ("*** Warning: no boot file name; using '%s'\n", - nfs_path); + printf("*** Warning: no boot file name; using '%s'\n", + nfs_path); } else { - char *p=BootFile; + char *p = net_boot_file_name; - p = strchr (p, ':'); + p = strchr(p, ':'); if (p != NULL) { - NfsServerIP = string_to_ip (BootFile); + nfs_server_ip = string_to_ip(net_boot_file_name); ++p; - strcpy (nfs_path, p); + strcpy(nfs_path, p); } else { - strcpy (nfs_path, BootFile); + strcpy(nfs_path, net_boot_file_name); } } - nfs_filename = basename (nfs_path); - nfs_path = dirname (nfs_path); + nfs_filename = basename(nfs_path); + nfs_path = dirname(nfs_path); -#if defined(CONFIG_NET_MULTI) - printf ("Using %s device\n", eth_get_name()); -#endif + printf("Using %s device\n", eth_get_name()); - puts ("File transfer via NFS from server "); print_IPaddr (NfsServerIP); - puts ("; our IP address is "); print_IPaddr (NetOurIP); + printf("File transfer via NFS from server %pI4; our IP address is %pI4", + &nfs_server_ip, &net_ip); /* Check if we need to send across this subnet */ - if (NetOurGatewayIP && NetOurSubnetMask) { - IPaddr_t OurNet = NetOurIP & NetOurSubnetMask; - IPaddr_t ServerNet = NetServerIP & NetOurSubnetMask; - - if (OurNet != ServerNet) { - puts ("; sending through gateway "); - print_IPaddr (NetOurGatewayIP) ; - } + if (net_gateway.s_addr && net_netmask.s_addr) { + struct in_addr our_net; + struct in_addr server_net; + + our_net.s_addr = net_ip.s_addr & net_netmask.s_addr; + server_net.s_addr = net_server_ip.s_addr & net_netmask.s_addr; + if (our_net.s_addr != server_net.s_addr) + printf("; sending through gateway %pI4", + &net_gateway); } - printf ("\nFilename '%s/%s'.", nfs_path, nfs_filename); + printf("\nFilename '%s/%s'.", nfs_path, nfs_filename); - if (NetBootFileSize) { - printf (" Size is 0x%x Bytes = ", NetBootFileSize<<9); - print_size (NetBootFileSize<<9, ""); + if (net_boot_file_expected_size_in_blocks) { + printf(" Size is 0x%x Bytes = ", + net_boot_file_expected_size_in_blocks << 9); + print_size(net_boot_file_expected_size_in_blocks << 9, ""); } - printf ("\nLoad address: 0x%lx\n" + printf("\nLoad address: 0x%lx\n" "Loading: *\b", load_addr); - NetSetTimeout (NFS_TIMEOUT * CFG_HZ, NfsTimeout); - NetSetHandler (NfsHandler); + net_set_timeout_handler(nfs_timeout, nfs_timeout_handler); + net_set_udp_handler(nfs_handler); - NfsTimeoutCount = 0; - NfsState = STATE_PRCLOOKUP_PROG_MOUNT_REQ; + nfs_timeout_count = 0; + nfs_state = STATE_PRCLOOKUP_PROG_MOUNT_REQ; - /*NfsOurPort = 4096 + (get_ticks() % 3072);*/ + /*nfs_our_port = 4096 + (get_ticks() % 3072);*/ /*FIX ME !!!*/ - NfsOurPort = 1000; + nfs_our_port = 1000; /* zero out server ether in case the server ip has changed */ - memset (NetServerEther, 0, 6); + memset(net_server_ethaddr, 0, 6); - NfsSend (); + nfs_send(); } - -#endif /* CONFIG_COMMANDS & CFG_CMD_NFS */