mirror of
https://github.com/AsahiLinux/u-boot
synced 2024-12-05 02:51:00 +00:00
fa84fa708c
This patch tackles the time out problem which leads to break the boot process, when loading file over nfs. The patch does two things. First of all, we just ignore messages that arrive with a rpc_id smaller then the client id. We just interpret this messages as answers to formaly timed out messages. Second, when a time out occurs we double the time to wait, so that we do not stress the server resending the last message. Signed-off-by: Matthias Brugger <matthias.bgg@gmail.com> Tested-by: Enric Balletbo i Serra <eballetbo@gmail.com>
787 lines
18 KiB
C
787 lines
18 KiB
C
/*
|
|
* NFS support driver - based on etherboot and U-BOOT's tftp.c
|
|
*
|
|
* Masami Komiya <mkomiya@sonare.it> 2004
|
|
*
|
|
*/
|
|
|
|
/* NOTE: the NFS code is heavily inspired by the NetBSD netboot code (read:
|
|
* large portions are copied verbatim) as distributed in OSKit 0.97. A few
|
|
* changes were necessary to adapt the code to Etherboot and to fix several
|
|
* inconsistencies. Also the RPC message preparation is done "by hand" to
|
|
* avoid adding netsprintf() which I find hard to understand and use. */
|
|
|
|
/* NOTE 2: Etherboot does not care about things beyond the kernel image, so
|
|
* it loads the kernel image off the boot server (ARP_SERVER) and does not
|
|
* access the client root disk (root-path in dhcpd.conf), which would use
|
|
* ARP_ROOTSERVER. The root disk is something the operating system we are
|
|
* about to load needs to use. This is different from the OSKit 0.97 logic. */
|
|
|
|
/* NOTE 3: Symlink handling introduced by Anselm M Hoffmeister, 2003-July-14
|
|
* If a symlink is encountered, it is followed as far as possible (recursion
|
|
* possible, maximum 16 steps). There is no clearing of ".."'s inside the
|
|
* path, so please DON'T DO THAT. thx. */
|
|
|
|
#include <common.h>
|
|
#include <command.h>
|
|
#include <net.h>
|
|
#include <malloc.h>
|
|
#include "nfs.h"
|
|
#include "bootp.h"
|
|
|
|
#define HASHES_PER_LINE 65 /* Number of "loading" hashes per line */
|
|
#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;
|
|
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 enum net_loop_state nfs_download_state;
|
|
static IPaddr_t NfsServerIP;
|
|
static int NfsSrvMountPort;
|
|
static int NfsSrvNfsPort;
|
|
static int NfsOurPort;
|
|
static int NfsTimeoutCount;
|
|
static int NfsState;
|
|
#define STATE_PRCLOOKUP_PROG_MOUNT_REQ 1
|
|
#define STATE_PRCLOOKUP_PROG_NFS_REQ 2
|
|
#define STATE_MOUNT_REQ 3
|
|
#define STATE_UMOUNT_REQ 4
|
|
#define STATE_LOOKUP_REQ 5
|
|
#define STATE_READ_REQ 6
|
|
#define STATE_READLINK_REQ 7
|
|
|
|
static char default_filename[64];
|
|
static char *nfs_filename;
|
|
static char *nfs_path;
|
|
static char nfs_path_buff[2048];
|
|
|
|
static inline int
|
|
store_block(uchar *src, unsigned offset, unsigned len)
|
|
{
|
|
ulong newsize = offset + len;
|
|
#ifdef CONFIG_SYS_DIRECT_FLASH_NFS
|
|
int i, rc = 0;
|
|
|
|
for (i = 0; i < CONFIG_SYS_MAX_FLASH_BANKS; i++) {
|
|
/* start address in flash? */
|
|
if (load_addr + offset >= flash_info[i].start[0]) {
|
|
rc = 1;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (rc) { /* Flash is destination for this packet */
|
|
rc = flash_write((uchar *)src, (ulong)(load_addr+offset), len);
|
|
if (rc) {
|
|
flash_perror(rc);
|
|
return -1;
|
|
}
|
|
} else
|
|
#endif /* CONFIG_SYS_DIRECT_FLASH_NFS */
|
|
{
|
|
(void)memcpy((void *)(load_addr + offset), src, len);
|
|
}
|
|
|
|
if (NetBootFileXferSize < (offset+len))
|
|
NetBootFileXferSize = newsize;
|
|
return 0;
|
|
}
|
|
|
|
static char*
|
|
basename(char *path)
|
|
{
|
|
char *fname;
|
|
|
|
fname = path + strlen(path) - 1;
|
|
while (fname >= path) {
|
|
if (*fname == '/') {
|
|
fname++;
|
|
break;
|
|
}
|
|
fname--;
|
|
}
|
|
return fname;
|
|
}
|
|
|
|
static char*
|
|
dirname(char *path)
|
|
{
|
|
char *fname;
|
|
|
|
fname = basename(path);
|
|
--fname;
|
|
*fname = '\0';
|
|
return path;
|
|
}
|
|
|
|
/**************************************************************************
|
|
RPC_ADD_CREDENTIALS - Add RPC authentication/verifier entries
|
|
**************************************************************************/
|
|
static long *rpc_add_credentials(long *p)
|
|
{
|
|
int hl;
|
|
int hostnamelen;
|
|
char hostname[256];
|
|
|
|
strcpy(hostname, "");
|
|
hostnamelen = strlen(hostname);
|
|
|
|
/* Here's the executive summary on authentication requirements of the
|
|
* various NFS server implementations: Linux accepts both AUTH_NONE
|
|
* and AUTH_UNIX authentication (also accepts an empty hostname field
|
|
* in the AUTH_UNIX scheme). *BSD refuses AUTH_NONE, but accepts
|
|
* AUTH_UNIX (also accepts an empty hostname field in the AUTH_UNIX
|
|
* scheme). To be safe, use AUTH_UNIX and pass the hostname if we have
|
|
* it (if the BOOTP/DHCP reply didn't give one, just use an empty
|
|
* hostname). */
|
|
|
|
hl = (hostnamelen + 3) & ~3;
|
|
|
|
/* Provide an AUTH_UNIX credential. */
|
|
*p++ = htonl(1); /* AUTH_UNIX */
|
|
*p++ = htonl(hl+20); /* auth length */
|
|
*p++ = htonl(0); /* stamp */
|
|
*p++ = htonl(hostnamelen); /* hostname string */
|
|
if (hostnamelen & 3)
|
|
*(p + hostnamelen / 4) = 0; /* add zero padding */
|
|
memcpy(p, hostname, hostnamelen);
|
|
p += hl / 4;
|
|
*p++ = 0; /* uid */
|
|
*p++ = 0; /* gid */
|
|
*p++ = 0; /* auxiliary gid list */
|
|
|
|
/* Provide an AUTH_NONE verifier. */
|
|
*p++ = 0; /* AUTH_NONE */
|
|
*p++ = 0; /* auth length */
|
|
|
|
return p;
|
|
}
|
|
|
|
/**************************************************************************
|
|
RPC_LOOKUP - Lookup RPC Port numbers
|
|
**************************************************************************/
|
|
static void
|
|
rpc_req(int rpc_prog, int rpc_proc, uint32_t *data, int datalen)
|
|
{
|
|
struct rpc_t pkt;
|
|
unsigned long id;
|
|
uint32_t *p;
|
|
int pktlen;
|
|
int sport;
|
|
|
|
id = ++rpc_id;
|
|
pkt.u.call.id = htonl(id);
|
|
pkt.u.call.type = htonl(MSG_CALL);
|
|
pkt.u.call.rpcvers = htonl(2); /* use RPC version 2 */
|
|
pkt.u.call.prog = htonl(rpc_prog);
|
|
pkt.u.call.vers = htonl(2); /* portmapper is version 2 */
|
|
pkt.u.call.proc = htonl(rpc_proc);
|
|
p = (uint32_t *)&(pkt.u.call.data);
|
|
|
|
if (datalen)
|
|
memcpy((char *)p, (char *)data, datalen*sizeof(uint32_t));
|
|
|
|
pktlen = (char *)p + datalen*sizeof(uint32_t) - (char *)&pkt;
|
|
|
|
memcpy((char *)NetTxPacket + NetEthHdrSize() + IP_UDP_HDR_SIZE,
|
|
(char *)&pkt, pktlen);
|
|
|
|
if (rpc_prog == PROG_PORTMAP)
|
|
sport = SUNRPC_PORT;
|
|
else if (rpc_prog == PROG_MOUNT)
|
|
sport = NfsSrvMountPort;
|
|
else
|
|
sport = NfsSrvNfsPort;
|
|
|
|
NetSendUDPPacket(NetServerEther, NfsServerIP, sport, NfsOurPort,
|
|
pktlen);
|
|
}
|
|
|
|
/**************************************************************************
|
|
RPC_LOOKUP - Lookup RPC Port numbers
|
|
**************************************************************************/
|
|
static void
|
|
rpc_lookup_req(int prog, int ver)
|
|
{
|
|
uint32_t data[16];
|
|
|
|
data[0] = 0; data[1] = 0; /* auth credential */
|
|
data[2] = 0; data[3] = 0; /* auth verifier */
|
|
data[4] = htonl(prog);
|
|
data[5] = htonl(ver);
|
|
data[6] = htonl(17); /* IP_UDP */
|
|
data[7] = 0;
|
|
|
|
rpc_req(PROG_PORTMAP, PORTMAP_GETPORT, data, 8);
|
|
}
|
|
|
|
/**************************************************************************
|
|
NFS_MOUNT - Mount an NFS Filesystem
|
|
**************************************************************************/
|
|
static void
|
|
nfs_mount_req(char *path)
|
|
{
|
|
uint32_t data[1024];
|
|
uint32_t *p;
|
|
int len;
|
|
int pathlen;
|
|
|
|
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);
|
|
p += (pathlen + 3) / 4;
|
|
|
|
len = (uint32_t *)p - (uint32_t *)&(data[0]);
|
|
|
|
rpc_req(PROG_MOUNT, MOUNT_ADDENTRY, data, len);
|
|
}
|
|
|
|
/**************************************************************************
|
|
NFS_UMOUNTALL - Unmount all our NFS Filesystems on the Server
|
|
**************************************************************************/
|
|
static void
|
|
nfs_umountall_req(void)
|
|
{
|
|
uint32_t data[1024];
|
|
uint32_t *p;
|
|
int len;
|
|
|
|
if ((NfsSrvMountPort == -1) || (!fs_mounted))
|
|
/* Nothing mounted, nothing to umount */
|
|
return;
|
|
|
|
p = &(data[0]);
|
|
p = (uint32_t *)rpc_add_credentials((long *)p);
|
|
|
|
len = (uint32_t *)p - (uint32_t *)&(data[0]);
|
|
|
|
rpc_req(PROG_MOUNT, MOUNT_UMOUNTALL, data, len);
|
|
}
|
|
|
|
/***************************************************************************
|
|
* NFS_READLINK (AH 2003-07-14)
|
|
* This procedure is called when read of the first block fails -
|
|
* this probably happens when it's a directory or a symlink
|
|
* 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)
|
|
{
|
|
uint32_t data[1024];
|
|
uint32_t *p;
|
|
int len;
|
|
|
|
p = &(data[0]);
|
|
p = (uint32_t *)rpc_add_credentials((long *)p);
|
|
|
|
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);
|
|
}
|
|
|
|
/**************************************************************************
|
|
NFS_LOOKUP - Lookup Pathname
|
|
**************************************************************************/
|
|
static void
|
|
nfs_lookup_req(char *fname)
|
|
{
|
|
uint32_t data[1024];
|
|
uint32_t *p;
|
|
int len;
|
|
int fnamelen;
|
|
|
|
fnamelen = strlen(fname);
|
|
|
|
p = &(data[0]);
|
|
p = (uint32_t *)rpc_add_credentials((long *)p);
|
|
|
|
memcpy(p, dirfh, NFS_FHSIZE);
|
|
p += (NFS_FHSIZE / 4);
|
|
*p++ = htonl(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);
|
|
}
|
|
|
|
/**************************************************************************
|
|
NFS_READ - Read File on NFS Server
|
|
**************************************************************************/
|
|
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);
|
|
|
|
memcpy(p, filefh, NFS_FHSIZE);
|
|
p += (NFS_FHSIZE / 4);
|
|
*p++ = htonl(offset);
|
|
*p++ = htonl(readlen);
|
|
*p++ = 0;
|
|
|
|
len = (uint32_t *)p - (uint32_t *)&(data[0]);
|
|
|
|
rpc_req(PROG_NFS, NFS_READ, data, len);
|
|
}
|
|
|
|
/**************************************************************************
|
|
RPC request dispatcher
|
|
**************************************************************************/
|
|
|
|
static void
|
|
NfsSend(void)
|
|
{
|
|
debug("%s\n", __func__);
|
|
|
|
switch (NfsState) {
|
|
case STATE_PRCLOOKUP_PROG_MOUNT_REQ:
|
|
rpc_lookup_req(PROG_MOUNT, 1);
|
|
break;
|
|
case STATE_PRCLOOKUP_PROG_NFS_REQ:
|
|
rpc_lookup_req(PROG_NFS, 2);
|
|
break;
|
|
case STATE_MOUNT_REQ:
|
|
nfs_mount_req(nfs_path);
|
|
break;
|
|
case STATE_UMOUNT_REQ:
|
|
nfs_umountall_req();
|
|
break;
|
|
case STATE_LOOKUP_REQ:
|
|
nfs_lookup_req(nfs_filename);
|
|
break;
|
|
case STATE_READ_REQ:
|
|
nfs_read_req(nfs_offset, nfs_len);
|
|
break;
|
|
case STATE_READLINK_REQ:
|
|
nfs_readlink_req();
|
|
break;
|
|
}
|
|
}
|
|
|
|
/**************************************************************************
|
|
Handlers for the reply from server
|
|
**************************************************************************/
|
|
|
|
static int
|
|
rpc_lookup_reply(int prog, uchar *pkt, unsigned len)
|
|
{
|
|
struct rpc_t rpc_pkt;
|
|
|
|
memcpy((unsigned char *)&rpc_pkt, pkt, len);
|
|
|
|
debug("%s\n", __func__);
|
|
|
|
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)
|
|
return -1;
|
|
|
|
switch (prog) {
|
|
case PROG_MOUNT:
|
|
NfsSrvMountPort = ntohl(rpc_pkt.u.reply.data[0]);
|
|
break;
|
|
case PROG_NFS:
|
|
NfsSrvNfsPort = ntohl(rpc_pkt.u.reply.data[0]);
|
|
break;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
nfs_mount_reply(uchar *pkt, unsigned len)
|
|
{
|
|
struct rpc_t rpc_pkt;
|
|
|
|
debug("%s\n", __func__);
|
|
|
|
memcpy((unsigned char *)&rpc_pkt, pkt, len);
|
|
|
|
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])
|
|
return -1;
|
|
|
|
fs_mounted = 1;
|
|
memcpy(dirfh, rpc_pkt.u.reply.data + 1, NFS_FHSIZE);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
nfs_umountall_reply(uchar *pkt, unsigned len)
|
|
{
|
|
struct rpc_t rpc_pkt;
|
|
|
|
debug("%s\n", __func__);
|
|
|
|
memcpy((unsigned char *)&rpc_pkt, pkt, len);
|
|
|
|
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)
|
|
return -1;
|
|
|
|
fs_mounted = 0;
|
|
memset(dirfh, 0, sizeof(dirfh));
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
nfs_lookup_reply(uchar *pkt, unsigned len)
|
|
{
|
|
struct rpc_t rpc_pkt;
|
|
|
|
debug("%s\n", __func__);
|
|
|
|
memcpy((unsigned char *)&rpc_pkt, pkt, len);
|
|
|
|
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])
|
|
return -1;
|
|
|
|
memcpy(filefh, rpc_pkt.u.reply.data + 1, NFS_FHSIZE);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
nfs_readlink_reply(uchar *pkt, unsigned len)
|
|
{
|
|
struct rpc_t rpc_pkt;
|
|
int rlen;
|
|
|
|
debug("%s\n", __func__);
|
|
|
|
memcpy((unsigned char *)&rpc_pkt, pkt, len);
|
|
|
|
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])
|
|
return -1;
|
|
|
|
rlen = ntohl(rpc_pkt.u.reply.data[1]); /* new path length */
|
|
|
|
if (*((char *)&(rpc_pkt.u.reply.data[2])) != '/') {
|
|
int pathlen;
|
|
strcat(nfs_path, "/");
|
|
pathlen = strlen(nfs_path);
|
|
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);
|
|
nfs_path[rlen] = 0;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
nfs_read_reply(uchar *pkt, unsigned len)
|
|
{
|
|
struct rpc_t rpc_pkt;
|
|
int rlen;
|
|
|
|
debug("%s\n", __func__);
|
|
|
|
memcpy((uchar *)&rpc_pkt, pkt, sizeof(rpc_pkt.u.reply));
|
|
|
|
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)
|
|
return -9999;
|
|
if (rpc_pkt.u.reply.astatus)
|
|
return -9999;
|
|
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('#');
|
|
|
|
rlen = ntohl(rpc_pkt.u.reply.data[18]);
|
|
if (store_block((uchar *)pkt + sizeof(rpc_pkt.u.reply),
|
|
nfs_offset, rlen))
|
|
return -9999;
|
|
|
|
return rlen;
|
|
}
|
|
|
|
/**************************************************************************
|
|
Interfaces of U-BOOT
|
|
**************************************************************************/
|
|
|
|
static void
|
|
NfsTimeout(void)
|
|
{
|
|
if (++NfsTimeoutCount > NFS_RETRY_COUNT) {
|
|
puts("\nRetry count exceeded; starting again\n");
|
|
NetStartAgain();
|
|
} else {
|
|
puts("T ");
|
|
NetSetTimeout(nfs_timeout + NFS_TIMEOUT * NfsTimeoutCount,
|
|
NfsTimeout);
|
|
NfsSend();
|
|
}
|
|
}
|
|
|
|
static void
|
|
NfsHandler(uchar *pkt, unsigned dest, IPaddr_t sip, unsigned src, unsigned len)
|
|
{
|
|
int rlen;
|
|
int reply;
|
|
|
|
debug("%s\n", __func__);
|
|
|
|
if (dest != NfsOurPort)
|
|
return;
|
|
|
|
switch (NfsState) {
|
|
case STATE_PRCLOOKUP_PROG_MOUNT_REQ:
|
|
if (rpc_lookup_reply(PROG_MOUNT, pkt, len) == -NFS_RPC_DROP)
|
|
break;
|
|
NfsState = STATE_PRCLOOKUP_PROG_NFS_REQ;
|
|
NfsSend();
|
|
break;
|
|
|
|
case STATE_PRCLOOKUP_PROG_NFS_REQ:
|
|
if (rpc_lookup_reply(PROG_NFS, pkt, len) == -NFS_RPC_DROP)
|
|
break;
|
|
NfsState = STATE_MOUNT_REQ;
|
|
NfsSend();
|
|
break;
|
|
|
|
case STATE_MOUNT_REQ:
|
|
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();
|
|
} else {
|
|
NfsState = STATE_LOOKUP_REQ;
|
|
NfsSend();
|
|
}
|
|
break;
|
|
|
|
case STATE_UMOUNT_REQ:
|
|
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");
|
|
net_set_state(nfs_download_state);
|
|
}
|
|
break;
|
|
|
|
case STATE_LOOKUP_REQ:
|
|
reply = nfs_lookup_reply(pkt, len);
|
|
if (reply == -NFS_RPC_DROP)
|
|
break;
|
|
else if (reply == -NFS_RPC_ERR) {
|
|
puts("*** ERROR: File lookup fail\n");
|
|
NfsState = STATE_UMOUNT_REQ;
|
|
NfsSend();
|
|
} else {
|
|
NfsState = STATE_READ_REQ;
|
|
nfs_offset = 0;
|
|
nfs_len = NFS_READ_SIZE;
|
|
NfsSend();
|
|
}
|
|
break;
|
|
|
|
case STATE_READLINK_REQ:
|
|
reply = nfs_readlink_reply(pkt, len);
|
|
if (reply == -NFS_RPC_DROP)
|
|
break;
|
|
else if (reply == -NFS_RPC_ERR) {
|
|
puts("*** ERROR: Symlink fail\n");
|
|
NfsState = STATE_UMOUNT_REQ;
|
|
NfsSend();
|
|
} else {
|
|
debug("Symlink --> %s\n", nfs_path);
|
|
nfs_filename = basename(nfs_path);
|
|
nfs_path = dirname(nfs_path);
|
|
|
|
NfsState = STATE_MOUNT_REQ;
|
|
NfsSend();
|
|
}
|
|
break;
|
|
|
|
case STATE_READ_REQ:
|
|
rlen = nfs_read_reply(pkt, len);
|
|
NetSetTimeout(nfs_timeout, NfsTimeout);
|
|
if (rlen > 0) {
|
|
nfs_offset += rlen;
|
|
NfsSend();
|
|
} else if ((rlen == -NFSERR_ISDIR) || (rlen == -NFSERR_INVAL)) {
|
|
/* symbolic link */
|
|
NfsState = STATE_READLINK_REQ;
|
|
NfsSend();
|
|
} else {
|
|
if (!rlen)
|
|
nfs_download_state = NETLOOP_SUCCESS;
|
|
NfsState = STATE_UMOUNT_REQ;
|
|
NfsSend();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
void
|
|
NfsStart(void)
|
|
{
|
|
debug("%s\n", __func__);
|
|
nfs_download_state = NETLOOP_FAIL;
|
|
|
|
NfsServerIP = NetServerIP;
|
|
nfs_path = (char *)nfs_path_buff;
|
|
|
|
if (nfs_path == NULL) {
|
|
net_set_state(NETLOOP_FAIL);
|
|
puts("*** ERROR: Fail allocate memory\n");
|
|
return;
|
|
}
|
|
|
|
if (BootFile[0] == '\0') {
|
|
sprintf(default_filename, "/nfsroot/%02X%02X%02X%02X.img",
|
|
NetOurIP & 0xFF,
|
|
(NetOurIP >> 8) & 0xFF,
|
|
(NetOurIP >> 16) & 0xFF,
|
|
(NetOurIP >> 24) & 0xFF);
|
|
strcpy(nfs_path, default_filename);
|
|
|
|
printf("*** Warning: no boot file name; using '%s'\n",
|
|
nfs_path);
|
|
} else {
|
|
char *p = BootFile;
|
|
|
|
p = strchr(p, ':');
|
|
|
|
if (p != NULL) {
|
|
NfsServerIP = string_to_ip(BootFile);
|
|
++p;
|
|
strcpy(nfs_path, p);
|
|
} else {
|
|
strcpy(nfs_path, BootFile);
|
|
}
|
|
}
|
|
|
|
nfs_filename = basename(nfs_path);
|
|
nfs_path = dirname(nfs_path);
|
|
|
|
printf("Using %s device\n", eth_get_name());
|
|
|
|
printf("File transfer via NFS from server %pI4"
|
|
"; our IP address is %pI4", &NfsServerIP, &NetOurIP);
|
|
|
|
/* 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)
|
|
printf("; sending through gateway %pI4",
|
|
&NetOurGatewayIP);
|
|
}
|
|
printf("\nFilename '%s/%s'.", nfs_path, nfs_filename);
|
|
|
|
if (NetBootFileSize) {
|
|
printf(" Size is 0x%x Bytes = ", NetBootFileSize<<9);
|
|
print_size(NetBootFileSize<<9, "");
|
|
}
|
|
printf("\nLoad address: 0x%lx\n"
|
|
"Loading: *\b", load_addr);
|
|
|
|
NetSetTimeout(nfs_timeout, NfsTimeout);
|
|
net_set_udp_handler(NfsHandler);
|
|
|
|
NfsTimeoutCount = 0;
|
|
NfsState = STATE_PRCLOOKUP_PROG_MOUNT_REQ;
|
|
|
|
/*NfsOurPort = 4096 + (get_ticks() % 3072);*/
|
|
/*FIX ME !!!*/
|
|
NfsOurPort = 1000;
|
|
|
|
/* zero out server ether in case the server ip has changed */
|
|
memset(NetServerEther, 0, 6);
|
|
|
|
NfsSend();
|
|
}
|