michael/u-boot
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge tag 'net-20260115' of https://source.denx.de/u-boot/custodians/u-boot-net

Browse Source 
Pull request net-20260115.

CI: https://source.denx.de/u-boot/custodians/u-boot-net/-/pipelines/29008

net:
- phy: micrel KSZ9031 and KSZ9021 fixes
- phy: marvell10g fix
- Fix "net stats" help
- Add Microsemi/Microchip MDIO driver
- tftpput: Rework to exclude code from xPL phases

net-legacy:
- Some refactoring to help with lwIP NF support

net-lwip:
- Add NFS support
This commit is contained in:
Tom Rini
2026-01-15 08:50:53 -06:00
parent d503633a36 b61d7d95cc
commit 5665d1f4e7
24 changed files with 1589 additions and 974 deletions
Download Patch File Download Diff File Expand all files Collapse all files

28
cmd/Kconfig
View File

@@ -2116,20 +2116,6 @@ config CMD_RARP
help
Boot image via network using RARP/TFTP protocol
config CMD_NFS
bool "nfs"
help
Boot image via network using NFS protocol.
config NFS_TIMEOUT
int "Timeout in milliseconds for NFS mounts"
depends on CMD_NFS
default 2000
help
Timeout in milliseconds used in NFS protocol. If you encounter
"ERROR: Cannot umount" in nfs command, try longer timeout such as
10000.
config SYS_DISABLE_AUTOLOAD
bool "Disable automatically loading files over the network"
depends on CMD_BOOTP || CMD_DHCP || CMD_NFS || CMD_RARP
@@ -2224,6 +2210,20 @@ config CMD_MDIO
The MDIO interface is orthogonal to the MII interface and extends
it by adding access to more registers through indirect addressing.
config CMD_NFS
bool "nfs"
help
Boot image via network using NFS protocol.
config NFS_TIMEOUT
int "Timeout in milliseconds for NFS mounts"
depends on CMD_NFS
default 2000
help
Timeout in milliseconds used in NFS protocol. If you encounter
"ERROR: Cannot umount" in nfs command, try longer timeout such as
10000.
config CMD_PING
bool "ping"
select PROT_RAW_LWIP if NET_LWIP

1
cmd/lwip/Makefile
View File

@@ -1,5 +1,6 @@
obj-$(CONFIG_CMD_DHCP) += dhcp.o
obj-$(CONFIG_CMD_DNS) += dns.o
obj-$(CONFIG_CMD_NFS) += nfs.o
obj-$(CONFIG_CMD_PING) += ping.o
obj-$(CONFIG_CMD_SNTP) += sntp.o
obj-$(CONFIG_CMD_TFTPBOOT) += tftp.o

11
cmd/lwip/nfs.c Normal file
View File

@@ -0,0 +1,11 @@
// SPDX-License-Identifier: GPL-2.0+
/* Copyright (C) 2025 Linaro Ltd. */
#include <command.h>
#include <net.h>
U_BOOT_CMD(nfs, 3, 1, do_nfs,
"boot image via network using NFS protocol",
"[loadAddress] [[hostIPaddr:]bootfilename]"
);

2
cmd/net-common.c
View File

@@ -103,4 +103,4 @@ static int do_net(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
U_BOOT_CMD(net, 3, 1, do_net, "NET sub-system",
"list - list available devices\n"
"stats <device> - dump statistics for specified device\n");
"net stats <device> - dump statistics for specified device\n");

1
configs/qemu_arm64_lwip_defconfig
View File

@@ -5,6 +5,7 @@ CONFIG_ARCH_QEMU=y
CONFIG_NET_LWIP=y
CONFIG_CMD_DNS=y
CONFIG_CMD_NFS=y
CONFIG_CMD_SNTP=y
CONFIG_CMD_WGET=y
CONFIG_EFI_HTTP_BOOT=y

8
drivers/net/Kconfig
View File

@@ -1069,6 +1069,14 @@ config ASPEED_MDIO
This driver supports the MDIO bus of Aspeed AST2600 SOC. The driver
currently supports Clause 22.
config MDIO_MSCC_MIIM
bool "Microsemi MIIM interface support"
depends on DM_MDIO
select REGMAP
help
This driver supports MDIO interface found in Microsemi and Microchip
network switches.
config MDIO_MUX_MMIOREG
bool "MDIO MUX accessed as a MMIO register access"
depends on DM_MDIO_MUX

1
drivers/net/Makefile
View File

@@ -62,6 +62,7 @@ obj-$(CONFIG_LITEETH) += liteeth.o
obj-$(CONFIG_MACB) += macb.o
obj-$(CONFIG_MCFFEC) += mcffec.o mcfmii.o
obj-$(CONFIG_MDIO_IPQ4019) += mdio-ipq4019.o
obj-$(CONFIG_MDIO_MSCC_MIIM) += mdio-mscc-miim.o
obj-$(CONFIG_MDIO_GPIO_BITBANG) += mdio_gpio.o
obj-$(CONFIG_MDIO_MT7531_MMIO) += mdio-mt7531-mmio.o
obj-$(CONFIG_MDIO_MUX_I2CREG) += mdio_mux_i2creg.o

136
drivers/net/mdio-mscc-miim.c Normal file
View File

@@ -0,0 +1,136 @@
// SPDX-License-Identifier: GPL-2.0+
#include <asm/io.h>
#include <dm.h>
#include <time.h>
#include <regmap.h>
#include <miiphy.h>
#include <linux/bitfield.h>
#define MSCC_MIIM_REG_STATUS 0x0
#define MSCC_MIIM_STATUS_STAT_PENDING BIT(2)
#define MSCC_MIIM_STATUS_STAT_BUSY BIT(3)
#define MSCC_MIIM_REG_CMD 0x8
#define MSCC_MIIM_CMD_OPR_WRITE BIT(1)
#define MSCC_MIIM_CMD_OPR_READ BIT(2)
#define MSCC_MIIM_CMD_WRDATA_SHIFT 4
#define MSCC_MIIM_CMD_REGAD_SHIFT 20
#define MSCC_MIIM_CMD_PHYAD_SHIFT 25
#define MSCC_MIIM_CMD_VLD BIT(31)
#define MSCC_MIIM_REG_DATA 0xC
#define MSCC_MIIM_DATA_ERROR (BIT(16) | BIT(17))
#define MSCC_MIIM_DATA_MASK GENMASK(15, 0)
#define MSCC_MIIM_REG_CFG 0x10
#define MSCC_MIIM_CFG_PRESCALE_MASK GENMASK(7, 0)
/* 01 = Clause 22, 00 = Clause 45 */
#define MSCC_MIIM_CFG_ST_CFG_MASK GENMASK(10, 9)
#define MSCC_MIIM_C22 1
#define MSCC_MIIM_C45 0
#define MSCC_MDIO_TIMEOUT 10000
#define MSCC_MDIO_SLEEP 50
struct mscc_mdio_priv {
struct regmap *map;
};
static int mscc_mdio_wait_busy(struct mscc_mdio_priv *priv)
{
u32 busy;
return regmap_read_poll_timeout(priv->map, MSCC_MIIM_REG_STATUS, busy,
(busy & MSCC_MIIM_STATUS_STAT_BUSY) == 0,
MSCC_MDIO_SLEEP,
MSCC_MDIO_TIMEOUT);
}
static int mscc_mdio_read(struct udevice *dev, int addr, int devad, int reg)
{
struct mscc_mdio_priv *priv = dev_get_priv(dev);
u32 val;
int ret;
if (mscc_mdio_wait_busy(priv))
return -ETIMEDOUT;
ret = regmap_write(priv->map, MSCC_MIIM_REG_CMD,
MSCC_MIIM_CMD_VLD |
(addr << MSCC_MIIM_CMD_PHYAD_SHIFT) |
(reg << MSCC_MIIM_CMD_REGAD_SHIFT) |
MSCC_MIIM_CMD_OPR_READ);
if (ret)
return ret;
if (mscc_mdio_wait_busy(priv))
return -ETIMEDOUT;
regmap_read(priv->map, MSCC_MIIM_REG_DATA, &val);
if (val & MSCC_MIIM_DATA_ERROR)
return -EIO;
return FIELD_GET(MSCC_MIIM_DATA_MASK, val);
}
int mscc_mdio_write(struct udevice *dev, int addr, int devad, int reg, u16 val)
{
struct mscc_mdio_priv *priv = dev_get_priv(dev);
int ret;
if (mscc_mdio_wait_busy(priv))
return -ETIMEDOUT;
ret = regmap_write(priv->map, MSCC_MIIM_REG_CMD,
MSCC_MIIM_CMD_VLD |
(addr << MSCC_MIIM_CMD_PHYAD_SHIFT) |
(reg << MSCC_MIIM_CMD_REGAD_SHIFT) |
(val << MSCC_MIIM_CMD_WRDATA_SHIFT) |
MSCC_MIIM_CMD_OPR_WRITE);
return ret;
}
static const struct mdio_ops mscc_mdio_ops = {
.read = mscc_mdio_read,
.write = mscc_mdio_write,
};
static int mscc_mdio_bind(struct udevice *dev)
{
if (ofnode_valid(dev_ofnode(dev)))
device_set_name(dev, ofnode_get_name(dev_ofnode(dev)));
return 0;
}
static int mscc_mdio_probe(struct udevice *dev)
{
struct mscc_mdio_priv *priv = dev_get_priv(dev);
int ret;
ret = regmap_init_mem(dev_ofnode(dev), &priv->map);
if (ret)
return -EINVAL;
/* Enter Clause 22 mode */
ret = regmap_update_bits(priv->map, MSCC_MIIM_REG_CFG,
MSCC_MIIM_CFG_ST_CFG_MASK,
FIELD_PREP(MSCC_MIIM_CFG_ST_CFG_MASK,
MSCC_MIIM_C22));
return ret;
}
static const struct udevice_id mscc_mdio_ids[] = {
{ .compatible = "mscc,ocelot-miim", },
{ }
};
U_BOOT_DRIVER(mscc_mdio) = {
.name = "mscc_mdio",
.id = UCLASS_MDIO,
.of_match = mscc_mdio_ids,
.bind = mscc_mdio_bind,
.probe = mscc_mdio_probe,
.ops = &mscc_mdio_ops,
.priv_auto = sizeof(struct mscc_mdio_priv),
};

14
drivers/net/phy/marvell10g.c
View File

@@ -342,8 +342,7 @@ static int mv2110_select_mactype(struct phy_device *phydev)
{
if (phydev->interface == PHY_INTERFACE_MODE_USXGMII)
return MV_PMA_21X0_PORT_CTRL_MACTYPE_USXGMII;
else if (phydev->interface == PHY_INTERFACE_MODE_SGMII &&
!(phydev->interface == PHY_INTERFACE_MODE_10GBASER))
else if (phydev->interface == PHY_INTERFACE_MODE_SGMII)
return MV_PMA_21X0_PORT_CTRL_MACTYPE_5GBASER;
else if (phydev->interface == PHY_INTERFACE_MODE_10GBASER)
return MV_PMA_21X0_PORT_CTRL_MACTYPE_10GBASER_RATE_MATCH;
@@ -381,15 +380,6 @@ static int mv3310_select_mactype(struct phy_device *phydev)
{
if (phydev->interface == PHY_INTERFACE_MODE_USXGMII)
return MV_V2_33X0_PORT_CTRL_MACTYPE_USXGMII;
else if (phydev->interface == PHY_INTERFACE_MODE_SGMII &&
phydev->interface == PHY_INTERFACE_MODE_10GBASER)
return MV_V2_33X0_PORT_CTRL_MACTYPE_10GBASER;
else if (phydev->interface == PHY_INTERFACE_MODE_SGMII &&
phydev->interface == PHY_INTERFACE_MODE_RXAUI)
return MV_V2_33X0_PORT_CTRL_MACTYPE_RXAUI;
else if (phydev->interface == PHY_INTERFACE_MODE_SGMII &&
phydev->interface == PHY_INTERFACE_MODE_XAUI)
return MV_V2_3310_PORT_CTRL_MACTYPE_XAUI;
else if (phydev->interface == PHY_INTERFACE_MODE_10GBASER)
return MV_V2_33X0_PORT_CTRL_MACTYPE_10GBASER_RATE_MATCH;
else if (phydev->interface == PHY_INTERFACE_MODE_RXAUI)
@@ -542,7 +532,7 @@ static bool mv3310_has_downshift(struct phy_device *phydev)
}
#define mv_test_bit(iface, phydev) \
({ if ((phydev)->interface & (iface)) return 0; })
({ if ((phydev)->interface == (iface)) return 0; })
static int mv3310_mv3340_test_supported_interfaces(struct phy_device *phydev)
{

66
drivers/net/phy/micrel_ksz90x1.c
View File

@@ -189,7 +189,10 @@ static int ksz9031_of_config(struct phy_device *phydev)
{ MII_KSZ9031_EXT_RGMII_TX_DATA_SKEW, 2, ksz90x1_txd_grp, 4 },
{ MII_KSZ9031_EXT_RGMII_CLOCK_SKEW, 2, ksz9031_clk_grp, 2 },
};
const unsigned int master = CTRL1000_CONFIG_MASTER | CTRL1000_MANUAL_CONFIG;
struct udevice *dev = phydev->dev;
int i, ret = 0;
ofnode node;
for (i = 0; i < ARRAY_SIZE(ofcfg); i++) {
ret = ksz90x1_of_config_group(phydev, &ofcfg[i],
@@ -198,7 +201,39 @@ static int ksz9031_of_config(struct phy_device *phydev)
return ret;
}
return 0;
node = phydev->node;
/* Look for a PHY node under the Ethernet node */
if (!ofnode_valid(node))
node = dev_read_subnode(dev, "ethernet-phy");
/* No node found, look in the Ethernet node */
if (!ofnode_valid(node))
node = dev_ofnode(dev);
/* Silicon Errata Sheet (DS80000691D or DS80000692D):
* When the device links in the 1000BASE-T slave mode only,
* the optional 125MHz reference output clock (CLK125_NDO)
* has wide duty cycle variation.
*
* The optional CLK125_NDO clock does not meet the RGMII
* 45/55 percent (min/max) duty cycle requirement and therefore
* cannot be used directly by the MAC side for clocking
* applications that have setup/hold time requirements on
* rising and falling clock edges.
*
* Workaround:
* Force the phy to be the master to receive a stable clock
* which meets the duty cycle requirement.
*/
if (ofnode_read_bool(node, "micrel,force-master")) {
ret = phy_modify(phydev, MDIO_DEVAD_NONE, MII_CTRL1000,
master | CTRL1000_PREFER_MASTER, master);
if (ret < 0)
pr_err("KSZ9031: error applying 'micrel,force-master'\n");
}
return ret;
}
static int ksz9031_center_flp_timing(struct phy_device *phydev)
@@ -217,6 +252,31 @@ static int ksz9031_center_flp_timing(struct phy_device *phydev)
return ret;
}
static void ksz90x1_workaround_asymmetric_pause(struct phy_device *phydev)
{
u32 features = phydev->drv->features;
/* Silicon Errata Sheet (DS80000691D or DS80000692D):
* Whenever the device's Asymmetric Pause capability is set to 1,
* link-up may fail after a link-up to link-down transition.
*
* The Errata Sheet is for ksz9031, but ksz9021 has the same issue
*
* Workaround:
* Do not enable the Asymmetric Pause capability bit.
*/
features &= ~ADVERTISE_PAUSE_ASYM;
/* We force setting the Pause capability as the core will force the
* Asymmetric Pause capability to 1 otherwise.
*/
features |= ADVERTISE_PAUSE_CAP;
/* update feature support and forward to advertised features */
phydev->supported = features;
phydev->advertising = phydev->supported;
}
/*
* KSZ9021
*/
@@ -260,6 +320,8 @@ static int ksz9021_config(struct phy_device *phydev)
if (ret)
return ret;
ksz90x1_workaround_asymmetric_pause(phydev);
if (env_get("disable_giga"))
features &= ~(SUPPORTED_1000baseT_Half |
SUPPORTED_1000baseT_Full);
@@ -345,6 +407,8 @@ static int ksz9031_config(struct phy_device *phydev)
if (ret)
return ret;
ksz90x1_workaround_asymmetric_pause(phydev);
/* add an option to disable the gigabit feature of this PHY */
if (env_get("disable_giga")) {
unsigned features;

29
include/net-common.h
View File

@@ -13,6 +13,7 @@
#include <time.h>
#define DEBUG_NET_PKT_TRACE 0 /* Trace all packet data */
#define DEBUG_INT_STATE 0 /* Internal network state changes */
/*
* The number of receive packet buffers, and the required packet buffer
@@ -114,14 +115,38 @@ struct ip_udp_hdr {
#define RINGSZ 4
#define RINGSZ_LOG2 2
/* Network loop state */
enum net_loop_state {
NETLOOP_CONTINUE,
NETLOOP_RESTART,
NETLOOP_SUCCESS,
NETLOOP_FAIL
};
extern enum net_loop_state net_state;
static inline void net_set_state(enum net_loop_state state)
{
debug_cond(DEBUG_INT_STATE, "--- NetState set to %d\n", state);
net_state = state;
}
extern int net_restart_wrap; /* Tried all network devices */
extern uchar *net_rx_packets[PKTBUFSRX]; /* Receive packets */
extern uchar *net_rx_packets[PKTBUFSRX]; /* Receive packets */
extern const u8 net_bcast_ethaddr[ARP_HLEN]; /* Ethernet broadcast address */
extern char net_boot_file_name[1024];/* Boot File name */
extern struct in_addr net_ip; /* Our IP addr (0 = unknown) */
/* Indicates whether the pxe path prefix / config file was specified in dhcp option */
extern char *pxelinux_configfile;
/* Our IP addr (0 = unknown) */
extern struct in_addr net_ip;
/* Boot File name */
extern char net_boot_file_name[1024];
/* The actual transferred size of the bootfile (in bytes) */
extern u32 net_boot_file_size;
/* Boot file size in blocks as reported by the DHCP server */
extern u32 net_boot_file_expected_size_in_blocks;
/**
* compute_ip_checksum() - Compute IP checksum
*

22
include/net-legacy.h
View File

@@ -25,7 +25,6 @@ struct udevice;
#define DEBUG_LL_STATE 0 /* Link local state machine changes */
#define DEBUG_DEV_PKT 0 /* Packets or info directed to the device */
#define DEBUG_NET_PKT 0 /* Packets on info on the network at large */
#define DEBUG_INT_STATE 0 /* Internal network state changes */
/* ARP hardware address length */
#define ARP_HLEN 6
@@ -290,7 +289,6 @@ extern u8 net_ethaddr[ARP_HLEN]; /* Our ethernet address */
extern u8 net_server_ethaddr[ARP_HLEN]; /* Boot server enet address */
extern struct in_addr net_server_ip; /* Server IP addr (0 = unknown) */
extern uchar *net_tx_packet; /* THE transmit packet */
extern uchar *net_rx_packets[PKTBUFSRX]; /* Receive packets */
extern uchar *net_rx_packet; /* Current receive packet */
extern int net_rx_packet_len; /* Current rx packet length */
extern const u8 net_null_ethaddr[ARP_HLEN];
@@ -310,10 +308,6 @@ enum proto_t {
/* Indicates whether the file name was specified on the command line */
extern bool net_boot_file_name_explicit;
/* The actual transferred size of the bootfile (in bytes) */
extern u32 net_boot_file_size;
/* Boot file size in blocks as reported by the DHCP server */
extern u32 net_boot_file_expected_size_in_blocks;
#if defined(CONFIG_DNS)
extern char *net_dns_resolve; /* The host to resolve */
@@ -369,22 +363,6 @@ bool arp_is_waiting(void); /* Waiting for ARP reply? */
void net_set_icmp_handler(rxhand_icmp_f *f); /* Set ICMP RX handler */
void net_set_timeout_handler(ulong t, thand_f *f);/* Set timeout handler */
/* Network loop state */
enum net_loop_state {
NETLOOP_CONTINUE,
NETLOOP_RESTART,
NETLOOP_SUCCESS,
NETLOOP_FAIL
};
extern enum net_loop_state net_state;
static inline void net_set_state(enum net_loop_state state)
{
debug_cond(DEBUG_INT_STATE, "--- NetState set to %d\n", state);
net_state = state;
}
/*
* net_get_async_tx_pkt_buf - Get a packet buffer that is not in use for
* sending an asynchronous reply

1
include/net-lwip.h
View File

@@ -51,6 +51,7 @@ int net_lwip_dns_resolve(char *name_or_ip, ip_addr_t *ip);
bool wget_validate_uri(char *uri);
int do_dns(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[]);
int do_nfs(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[]);
int do_wget(struct cmd_tbl *cmdtp, int flag, int argc, char * const argv[]);
#endif /* __NET_LWIP_H__ */

1
net/Makefile
View File

@@ -43,6 +43,7 @@ obj-$(CONFIG_$(PHASE_)DM_ETH) += eth-uclass.o
obj-$(CONFIG_$(PHASE_)BOOTDEV_ETH) += eth_bootdev.o
obj-$(CONFIG_DM_MDIO) += mdio-uclass.o
obj-$(CONFIG_DM_MDIO_MUX) += mdio-mux-uclass.o
obj-$(CONFIG_CMD_NFS) += nfs-common.o
obj-$(CONFIG_$(PHASE_)DM_ETH) += eth_common.o
obj-y += net-common.o
endif

1
net/lwip/Makefile
View File

@@ -4,6 +4,7 @@ obj-$(CONFIG_$(PHASE_)DM_ETH) += net-lwip.o
obj-$(CONFIG_CMD_DHCP) += dhcp.o
obj-$(CONFIG_DNS) += dns.o
obj-$(CONFIG_LWIP_ICMP_SHOW_UNREACH) += icmp_unreach.o
obj-$(CONFIG_CMD_NFS) += nfs.o
obj-$(CONFIG_CMD_TFTPBOOT) += tftp.o
obj-$(CONFIG_WGET) += wget.o

6
net/lwip/net-lwip.c
View File

@@ -33,13 +33,8 @@ static int net_restarted;
int net_restart_wrap;
static uchar net_pkt_buf[(PKTBUFSRX) * PKTSIZE_ALIGN + PKTALIGN]
__aligned(PKTALIGN);
uchar *net_rx_packets[PKTBUFSRX];
uchar *net_rx_packet;
const u8 net_bcast_ethaddr[6] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
char *pxelinux_configfile;
/* Our IP addr (0 = unknown) */
struct in_addr net_ip;
char net_boot_file_name[1024];
static err_t net_lwip_tx(struct netif *netif, struct pbuf *p)
{
@@ -297,6 +292,7 @@ static struct pbuf *alloc_pbuf_and_copy(uchar *data, int len)
/* We allocate a pbuf chain of pbufs from the pool. */
p = pbuf_alloc(PBUF_RAW, len, PBUF_POOL);
if (!p) {
debug("Failed to allocate pbuf !!!!!\n");
LINK_STATS_INC(link.memerr);
LINK_STATS_INC(link.drop);
return NULL;

286
net/lwip/nfs.c Normal file
View File

@@ -0,0 +1,286 @@
// SPDX-License-Identifier: GPL-2.0+
/* Copyright (C) 2025 Linaro Ltd. */
#include <console.h>
#include <display_options.h>
#include <env.h>
#include <image.h>
#include <linux/kconfig.h>
#include <lwip/timeouts.h>
#include <lwip/udp.h>
#include <net.h>
#include "../nfs-common.h"
#include <time.h>
static ulong timer_start;
static struct nfs_ctx {
ip_addr_t nfs_server;
struct udp_pcb *pcb;
} sess_ctx;
/**************************************************************************
* RPC_LOOKUP - Lookup RPC Port numbers
**************************************************************************
*/
void rpc_req(int rpc_prog, int rpc_proc, uint32_t *data, int datalen)
{
struct pbuf *pb;
int pktlen;
int sport;
err_t err;
pb = pbuf_alloc(PBUF_TRANSPORT, sizeof(struct rpc_t), PBUF_RAM);
if (!pb) {
debug("Failed to allocate pbuf to build RPC packet\n");
return;
}
rpc_req_common(rpc_prog, rpc_proc, data, datalen,
pb->payload, &pktlen, &sport);
pbuf_realloc(pb, (u16_t)pktlen);
err = udp_sendto(sess_ctx.pcb, pb, &sess_ctx.nfs_server, sport);
debug_cond((err != ERR_OK), "Failed to send UDP packet err = %d\n", err);
pbuf_free(pb);
}
void nfs_refresh_timeout(void)
{
timer_start = get_timer(0);
}
static void nfs_recv(void *arg, struct udp_pcb *pcb, struct pbuf *p,
const ip_addr_t *addr, u16_t port)
{
struct nfs_ctx *ctx = arg;
int plen;
struct rpc_t rpc_pkt;
if (addr->addr != ctx->nfs_server.addr)
goto exitfree;
if (p->tot_len > sizeof(struct rpc_t))
goto exitfree;
plen = pbuf_copy_partial(p, &rpc_pkt.u.data[0], sizeof(rpc_pkt), 0);
nfs_pkt_recv(&rpc_pkt.u.data[0], plen);
exitfree:
pbuf_free(p);
}
static int nfs_udp_init(struct nfs_ctx *ctx)
{
ctx->pcb = udp_new();
if (!ctx->pcb)
return -ENOMEM;
ctx->pcb->local_port = nfs_our_port;
udp_recv(ctx->pcb, nfs_recv, ctx);
return 0;
}
static int nfs_timeout_check(void)
{
if (get_timer(timer_start) < nfs_timeout)
return 0;
if (++nfs_timeout_count < NFS_RETRY_COUNT) {
puts("T ");
timer_start = get_timer(0);
nfs_send();
return 0;
}
return 1;
}
static int nfs_loop(struct udevice *udev, ulong addr, char *fname,
ip_addr_t srvip)
{
struct netif *netif;
int ret;
nfs_download_state = NETLOOP_FAIL;
net_set_state(NETLOOP_FAIL);
if (!fname || addr == 0)
return -1;
netif = net_lwip_new_netif(udev);
if (!netif)
return -1;
nfs_filename = nfs_basename(fname);
nfs_path = nfs_dirname(fname);
printf("Using %s device\n", eth_get_name());
printf("File transfer via NFS from server %s; our IP address is %s\n",
ip4addr_ntoa(&srvip), env_get("ipaddr"));
printf("\nFilename '%s/%s'.", nfs_path, nfs_filename);
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\nLoading: *\b", addr);
image_load_addr = addr;
nfs_timeout_count = 0;
nfs_state = STATE_PRCLOOKUP_PROG_MOUNT_REQ;
ret = nfs_udp_init(&sess_ctx);
if (ret < 0) {
net_lwip_remove_netif(netif);
debug("Failed to init network interface, aborting for error = %d\n", ret);
return ret;
}
net_set_state(NETLOOP_CONTINUE);
sess_ctx.nfs_server.addr = srvip.addr;
nfs_send();
timer_start = get_timer(0);
do {
net_lwip_rx(udev, netif);
if (net_state != NETLOOP_CONTINUE)
break;
if (ctrlc()) {
printf("\nAbort\n");
break;
}
if (nfs_timeout_check())
break;
} while (true);
debug("%s: Loop exit at %lu\n", __func__, get_timer(0));
net_lwip_remove_netif(netif);
if (net_state == NETLOOP_SUCCESS) {
ret = 0;
if (net_boot_file_size > 0) {
printf("Bytes transferred = %u (%x hex)\n",
net_boot_file_size, net_boot_file_size);
env_set_hex("filesize", net_boot_file_size);
env_set_hex("fileaddr", image_load_addr);
}
} else {
debug("%s: NFS loop failed\n", __func__);
ret = -1;
}
return ret;
}
int do_nfs(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
int ret = CMD_RET_SUCCESS;
char *arg = NULL;
char *words[2] = { };
char *fname = NULL;
char *server_ip = NULL;
char *end;
ip_addr_t srvip;
ulong laddr;
ulong addr;
int i;
laddr = env_get_ulong("loadaddr", 16, image_load_addr);
switch (argc) {
case 1:
fname = env_get("bootfile");
break;
case 2:
/*
* Only one arg - accept two forms:
* Just load address, or just boot file name. The latter
* form must be written in a format which can not be
* mis-interpreted as a valid number.
*/
addr = hextoul(argv[1], &end);
if (end == (argv[1] + strlen(argv[1]))) {
laddr = addr;
fname = env_get("bootfile");
} else {
arg = strdup(argv[1]);
}
break;
case 3:
laddr = hextoul(argv[1], NULL);
arg = strdup(argv[2]);
break;
default:
ret = CMD_RET_USAGE;
goto out;
}
if (!arg)
arg = net_boot_file_name;
if (*arg) {
/* Parse [ip:]fname */
i = 0;
while ((*(words + i) = strsep(&arg, ":")))
i++;
switch (i) {
case 2:
server_ip = words[0];
fname = words[1];
break;
case 1:
fname = words[0];
break;
default:
break;
}
}
if (!server_ip)
server_ip = env_get("serverip");
if (!server_ip) {
log_err("*** ERROR: 'serverip' not set\n");
ret = CMD_RET_FAILURE;
goto out;
}
if (!ipaddr_aton(server_ip, &srvip)) {
log_err("error: ipaddr_aton\n");
ret = CMD_RET_FAILURE;
goto out;
}
if (!fname) {
log_err("error: no file name\n");
ret = CMD_RET_FAILURE;
goto out;
}
if (!laddr) {
log_err("error: no load address\n");
ret = CMD_RET_FAILURE;
goto out;
}
if (net_lwip_eth_start() < 0) {
ret = CMD_RET_FAILURE;
goto out;
}
if (nfs_loop(eth_get_dev(), laddr, fname, srvip) < 0)
ret = CMD_RET_FAILURE;
out:
if (arg != net_boot_file_name)
free(arg);
return ret;
}

12
net/net-common.c
View File

@@ -6,6 +6,18 @@
#include <linux/time.h>
#include <rtc.h>
/* Network loop state */
enum net_loop_state net_state;
/* Our IP addr (0 = unknown) */
struct in_addr net_ip;
/* Boot File name */
char net_boot_file_name[1024];
/* The actual transferred size of the bootfile (in bytes) */
u32 net_boot_file_size;
/* Boot file size in blocks as reported by the DHCP server */
u32 net_boot_file_expected_size_in_blocks;
uchar *net_rx_packets[PKTBUFSRX];
void copy_filename(char *dst, const char *src, int size)
{
if (src && *src && (*src == '"')) {

12
net/net.c
View File

@@ -141,8 +141,6 @@ char *pxelinux_configfile;
u8 net_ethaddr[6];
/* Boot server enet address */
u8 net_server_ethaddr[6];
/* Our IP addr (0 = unknown) */
struct in_addr net_ip;
/* Server IP addr (0 = unknown) */
struct in_addr net_server_ip;
/* Current receive packet */
@@ -157,8 +155,6 @@ const u8 net_null_ethaddr[6];
#if defined(CONFIG_API) || defined(CONFIG_EFI_LOADER)
void (*push_packet)(void *, int len) = 0;
#endif
/* Network loop state */
enum net_loop_state net_state;
/* Tried all network devices */
int net_restart_wrap;
/* Network loop restarted */
@@ -172,18 +168,10 @@ ushort net_our_vlan = 0xFFFF;
/* ditto */
ushort net_native_vlan = 0xFFFF;
/* Boot File name */
char net_boot_file_name[1024];
/* Indicates whether the file name was specified on the command line */
bool net_boot_file_name_explicit;
/* The actual transferred size of the bootfile (in bytes) */
u32 net_boot_file_size;
/* Boot file size in blocks as reported by the DHCP server */
u32 net_boot_file_expected_size_in_blocks;
static uchar net_pkt_buf[(PKTBUFSRX+1) * PKTSIZE_ALIGN + PKTALIGN];
/* Receive packets */
uchar *net_rx_packets[PKTBUFSRX];
/* Current UDP RX packet handler */
static rxhand_f *udp_packet_handler;
/* Current ARP RX packet handler */

863
net/nfs-common.c Normal file
View File

@@ -0,0 +1,863 @@
// SPDX-License-Identifier: GPL-2.0+
/*
* 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.
*/
/* NOTE 4: NFSv3 support added by Guillaume GARDET, 2016-June-20.
* NFSv2 is still used by default. But if server does not support NFSv2, then
* NFSv3 is used, if available on NFS server.
*/
/* NOTE 5: NFSv1 support added by Christian Gmeiner, Thomas Rienoessl,
* September 27, 2018. As of now, NFSv3 is the default choice. If the server
* does not support NFSv3, we fall back to versions 2 or 1.
*/
#ifdef CONFIG_SYS_DIRECT_FLASH_NFS
#include <flash.h>
#endif
#include <image.h>
#include <log.h>
#include <net.h>
#include <mapmem.h>
#include "nfs.h"
#include "nfs-common.h"
static int fs_mounted;
static char dirfh[NFS3_FHSIZE]; /* NFSv2 / NFSv3 file handle of directory */
static unsigned int dirfh3_length; /* (variable) length of dirfh when NFSv3 */
static char filefh[NFS3_FHSIZE]; /* NFSv2 / NFSv3 file handle */
static unsigned int filefh3_length; /* (variable) length of filefh when NFSv3 */
enum net_loop_state nfs_download_state;
char *nfs_filename;
char *nfs_path;
char nfs_path_buff[2048];
struct in_addr nfs_server_ip;
int nfs_server_mount_port;
int nfs_server_port;
int nfs_our_port;
int nfs_state;
int nfs_timeout_count;
unsigned long rpc_id;
int nfs_offset = -1;
int nfs_len;
const ulong nfs_timeout = CONFIG_NFS_TIMEOUT;
enum nfs_version choosen_nfs_version = NFS_V3;
static inline int store_block(uchar *src, unsigned int offset, unsigned int 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 (image_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)image_load_addr + offset,
len);
if (rc) {
flash_perror(rc);
return -1;
}
} else
#endif /* CONFIG_SYS_DIRECT_FLASH_NFS */
{
void *ptr = map_sysmem(image_load_addr + offset, len);
memcpy(ptr, src, len);
unmap_sysmem(ptr);
}
if (net_boot_file_size < (offset + len))
net_boot_file_size = newsize;
return 0;
}
char *nfs_basename(char *path)
{
char *fname;
fname = path + strlen(path) - 1;
while (fname >= path) {
if (*fname == '/') {
fname++;
break;
}
fname--;
}
return fname;
}
char *nfs_dirname(char *path)
{
char *fname;
fname = nfs_basename(path);
--fname;
*fname = '\0';
return path;
}
/**************************************************************************
* RPC_ADD_CREDENTIALS - Add RPC authentication/verifier entries
**************************************************************************
*/
static uint32_t *rpc_add_credentials(uint32_t *p)
{
/* 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).
*/
/* Provide an AUTH_UNIX credential. */
*p++ = htonl(1); /* AUTH_UNIX */
*p++ = htonl(20); /* auth length */
*p++ = 0; /* stamp */
*p++ = 0; /* hostname string */
*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;
}
void rpc_req_common(int rpc_prog, int rpc_proc, uint32_t *data, int datalen,
uchar *txbuff, int *pktlen, int *sport)
{
struct rpc_t rpc_pkt;
unsigned long id;
u32 *p;
id = ++rpc_id;
rpc_pkt.u.call.id = htonl(id);
rpc_pkt.u.call.type = htonl(MSG_CALL);
rpc_pkt.u.call.rpcvers = htonl(2); /* use RPC version 2 */
rpc_pkt.u.call.prog = htonl(rpc_prog);
switch (rpc_prog) {
case PROG_NFS:
switch (choosen_nfs_version) {
case NFS_V1:
case NFS_V2:
rpc_pkt.u.call.vers = htonl(2);
break;
case NFS_V3:
rpc_pkt.u.call.vers = htonl(3);
break;
case NFS_UNKOWN:
/* nothing to do */
break;
}
break;
case PROG_MOUNT:
switch (choosen_nfs_version) {
case NFS_V1:
rpc_pkt.u.call.vers = htonl(1);
break;
case NFS_V2:
rpc_pkt.u.call.vers = htonl(2);
break;
case NFS_V3:
rpc_pkt.u.call.vers = htonl(3);
break;
case NFS_UNKOWN:
/* nothing to do */
break;
}
break;
case PROG_PORTMAP:
default:
rpc_pkt.u.call.vers = htonl(2); /* portmapper is version 2 */
}
rpc_pkt.u.call.proc = htonl(rpc_proc);
p = rpc_pkt.u.call.data;
if (datalen)
memcpy(p, data, datalen * sizeof(uint32_t));
*pktlen = (char *)p + datalen * sizeof(uint32_t) - (char *)&rpc_pkt;
memcpy(txbuff, &rpc_pkt.u.data[0], *pktlen);
if (rpc_prog == PROG_PORTMAP)
*sport = SUNRPC_PORT;
else if (rpc_prog == PROG_MOUNT)
*sport = nfs_server_mount_port;
else
*sport = nfs_server_port;
}
/**************************************************************************
* RPC_LOOKUP - Lookup RPC Port numbers
**************************************************************************
*/
static void rpc_lookup_req(int prog, int ver)
{
u32 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)
{
u32 data[1024];
u32 *p;
int len;
int pathlen;
pathlen = strlen(path);
p = &data[0];
p = rpc_add_credentials(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)
{
u32 data[1024];
u32 *p;
int len;
if ((nfs_server_mount_port == -1) || !fs_mounted) {
/* Nothing mounted, nothing to umount */
net_set_state(NETLOOP_FAIL);
return;
}
p = &data[0];
p = rpc_add_credentials(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)
{
u32 data[1024];
u32 *p;
int len;
p = &data[0];
p = rpc_add_credentials(p);
if (choosen_nfs_version != NFS_V3) {
memcpy(p, filefh, NFS_FHSIZE);
p += (NFS_FHSIZE / 4);
} else { /* NFS_V3 */
*p++ = htonl(filefh3_length);
memcpy(p, filefh, filefh3_length);
p += (filefh3_length / 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)
{
u32 data[1024];
u32 *p;
int len;
int fnamelen;
fnamelen = strlen(fname);
p = &data[0];
p = rpc_add_credentials(p);
if (choosen_nfs_version != NFS_V3) {
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);
} else { /* NFS_V3 */
*p++ = htonl(dirfh3_length); /* Dir handle length */
memcpy(p, dirfh, dirfh3_length);
p += (dirfh3_length / 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, NFS3PROC_LOOKUP, data, len);
}
}
/**************************************************************************
* NFS_READ - Read File on NFS Server
**************************************************************************
*/
static void nfs_read_req(int offset, int readlen)
{
u32 data[1024];
u32 *p;
int len;
p = &data[0];
p = rpc_add_credentials(p);
if (choosen_nfs_version != NFS_V3) {
memcpy(p, filefh, NFS_FHSIZE);
p += (NFS_FHSIZE / 4);
*p++ = htonl(offset);
*p++ = htonl(readlen);
*p++ = 0;
} else { /* NFS_V3 */
*p++ = htonl(filefh3_length);
memcpy(p, filefh, filefh3_length);
p += (filefh3_length / 4);
*p++ = htonl(0); /* offset is 64-bit long, so fill with 0 */
*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
**************************************************************************
*/
void nfs_send(void)
{
switch (nfs_state) {
case STATE_PRCLOOKUP_PROG_MOUNT_REQ:
if (choosen_nfs_version != NFS_V3)
rpc_lookup_req(PROG_MOUNT, 1);
else /* NFS_V3 */
rpc_lookup_req(PROG_MOUNT, 3);
break;
case STATE_PRCLOOKUP_PROG_NFS_REQ:
if (choosen_nfs_version != NFS_V3)
rpc_lookup_req(PROG_NFS, 2);
else /* NFS_V3 */
rpc_lookup_req(PROG_NFS, 3);
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_handle_error(struct rpc_t *rpc_pkt)
{
if (rpc_pkt->u.reply.rstatus ||
rpc_pkt->u.reply.verifier ||
rpc_pkt->u.reply.astatus ||
rpc_pkt->u.reply.data[0]) {
switch (ntohl(rpc_pkt->u.reply.astatus)) {
case NFS_RPC_SUCCESS: /* Not an error */
break;
case NFS_RPC_PROG_MISMATCH: {
/* Remote can't support NFS version */
const int min = ntohl(rpc_pkt->u.reply.data[0]);
const int max = ntohl(rpc_pkt->u.reply.data[1]);
if (max < NFS_V1 || max > NFS_V3 || min > NFS_V3) {
puts("*** ERROR: NFS version not supported");
debug(": Requested: V%d, accepted: min V%d - max V%d\n",
choosen_nfs_version,
ntohl(rpc_pkt->u.reply.data[0]),
ntohl(rpc_pkt->u.reply.data[1]));
puts("\n");
choosen_nfs_version = NFS_UNKOWN;
break;
}
debug("*** Warning: NFS version not supported: Requested: V%d, accepted: min V%d - max V%d\n",
choosen_nfs_version,
ntohl(rpc_pkt->u.reply.data[0]),
ntohl(rpc_pkt->u.reply.data[1]));
debug("Will retry with NFSv%d\n", min);
choosen_nfs_version = min;
return -NFS_RPC_PROG_MISMATCH;
}
case NFS_RPC_PROG_UNAVAIL:
case NFS_RPC_PROC_UNAVAIL:
case NFS_RPC_GARBAGE_ARGS:
case NFS_RPC_SYSTEM_ERR:
default: /* Unknown error on 'accept state' flag */
debug("*** ERROR: accept state error (%d)\n",
ntohl(rpc_pkt->u.reply.astatus));
break;
}
return -1;
}
return 0;
}
static int rpc_lookup_reply(int prog, uchar *pkt, unsigned int len)
{
struct rpc_t rpc_pkt;
memcpy(&rpc_pkt.u.data[0], 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;
switch (prog) {
case PROG_MOUNT:
nfs_server_mount_port = ntohl(rpc_pkt.u.reply.data[0]);
break;
case PROG_NFS:
nfs_server_port = ntohl(rpc_pkt.u.reply.data[0]);
break;
}
return 0;
}
static int nfs_mount_reply(uchar *pkt, unsigned int len)
{
struct rpc_t rpc_pkt;
int ret;
memcpy(&rpc_pkt.u.data[0], 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;
ret = rpc_handle_error(&rpc_pkt);
if (ret)
return ret;
fs_mounted = 1;
/* NFSv2 and NFSv3 use same structure */
if (choosen_nfs_version != NFS_V3) {
memcpy(dirfh, rpc_pkt.u.reply.data + 1, NFS_FHSIZE);
} else {
dirfh3_length = ntohl(rpc_pkt.u.reply.data[1]);
if (dirfh3_length > NFS3_FHSIZE)
dirfh3_length = NFS3_FHSIZE;
memcpy(dirfh, rpc_pkt.u.reply.data + 2, dirfh3_length);
}
return 0;
}
static int nfs_umountall_reply(uchar *pkt, unsigned int len)
{
struct rpc_t rpc_pkt;
memcpy(&rpc_pkt.u.data[0], 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 int len)
{
struct rpc_t rpc_pkt;
int ret;
memcpy(&rpc_pkt.u.data[0], 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;
ret = rpc_handle_error(&rpc_pkt);
if (ret)
return ret;
if (choosen_nfs_version != NFS_V3) {
if (((uchar *)&rpc_pkt.u.reply.data[0] - (uchar *)&rpc_pkt + NFS_FHSIZE) > len)
return -NFS_RPC_DROP;
memcpy(filefh, rpc_pkt.u.reply.data + 1, NFS_FHSIZE);
} else { /* NFS_V3 */
filefh3_length = ntohl(rpc_pkt.u.reply.data[1]);
if (filefh3_length > NFS3_FHSIZE)
filefh3_length = NFS3_FHSIZE;
memcpy(filefh, rpc_pkt.u.reply.data + 2, filefh3_length);
}
return 0;
}
static int nfs3_get_attributes_offset(uint32_t *data)
{
if (data[1]) {
/* 'attributes_follow' flag is TRUE,
* so we have attributes on 21 dwords
*/
/* Skip unused values :
* type; 32 bits value,
* mode; 32 bits value,
* nlink; 32 bits value,
* uid; 32 bits value,
* gid; 32 bits value,
* size; 64 bits value,
* used; 64 bits value,
* rdev; 64 bits value,
* fsid; 64 bits value,
* fileid; 64 bits value,
* atime; 64 bits value,
* mtime; 64 bits value,
* ctime; 64 bits value,
*/
return 22;
}
/* 'attributes_follow' flag is FALSE,
* so we don't have any attributes
*/
return 1;
}
static int nfs_readlink_reply(uchar *pkt, unsigned int len)
{
struct rpc_t rpc_pkt;
int rlen;
int nfsv3_data_offset = 0;
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;
if (choosen_nfs_version == NFS_V3) {
nfsv3_data_offset =
nfs3_get_attributes_offset(rpc_pkt.u.reply.data);
}
/* new path length */
rlen = ntohl(rpc_pkt.u.reply.data[1 + nfsv3_data_offset]);
if (((uchar *)&rpc_pkt.u.reply.data[0] - (uchar *)&rpc_pkt + rlen) > len)
return -NFS_RPC_DROP;
if (*((char *)&rpc_pkt.u.reply.data[2 + nfsv3_data_offset]) != '/') {
int pathlen;
strcat(nfs_path, "/");
pathlen = strlen(nfs_path);
memcpy(nfs_path + pathlen,
(uchar *)&rpc_pkt.u.reply.data[2 + nfsv3_data_offset],
rlen);
nfs_path[pathlen + rlen] = 0;
} else {
memcpy(nfs_path,
(uchar *)&rpc_pkt.u.reply.data[2 + nfsv3_data_offset],
rlen);
nfs_path[rlen] = 0;
}
return 0;
}
static int nfs_read_reply(uchar *pkt, unsigned int len)
{
struct rpc_t rpc_pkt;
int rlen;
uchar *data_ptr;
memcpy(&rpc_pkt.u.data[0], 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('#');
if (choosen_nfs_version != NFS_V3) {
rlen = ntohl(rpc_pkt.u.reply.data[18]);
data_ptr = (uchar *)&rpc_pkt.u.reply.data[19];
} else { /* NFS_V3 */
int nfsv3_data_offset =
nfs3_get_attributes_offset(rpc_pkt.u.reply.data);
/* count value */
rlen = ntohl(rpc_pkt.u.reply.data[1 + nfsv3_data_offset]);
/* Skip unused values :
* EOF: 32 bits value,
* data_size: 32 bits value,
*/
data_ptr = (uchar *)
&rpc_pkt.u.reply.data[4 + nfsv3_data_offset];
}
if (((uchar *)&rpc_pkt.u.reply.data[0] - (uchar *)&rpc_pkt + rlen) > len)
return -9999;
if (store_block(data_ptr, nfs_offset, rlen))
return -9999;
return rlen;
}
void nfs_pkt_recv(uchar *pkt, unsigned int len)
{
int rlen;
int reply;
switch (nfs_state) {
case STATE_PRCLOOKUP_PROG_MOUNT_REQ:
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:
if (rpc_lookup_reply(PROG_NFS, pkt, len) == -NFS_RPC_DROP)
break;
nfs_state = STATE_MOUNT_REQ;
nfs_send();
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... */
nfs_state = STATE_UMOUNT_REQ;
nfs_send();
} else if (reply == -NFS_RPC_PROG_MISMATCH &&
choosen_nfs_version != NFS_UNKOWN) {
nfs_state = STATE_MOUNT_REQ;
nfs_send();
} else {
nfs_state = STATE_LOOKUP_REQ;
nfs_send();
}
break;
case STATE_UMOUNT_REQ:
reply = nfs_umountall_reply(pkt, len);
if (reply == -NFS_RPC_DROP) {
break;
} else if (reply == -NFS_RPC_ERR) {
debug("*** 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");
nfs_state = STATE_UMOUNT_REQ;
nfs_send();
} else if (reply == -NFS_RPC_PROG_MISMATCH &&
choosen_nfs_version != NFS_UNKOWN) {
/* umount */
nfs_state = STATE_UMOUNT_REQ;
nfs_send();
/* And retry with another supported version */
nfs_state = STATE_PRCLOOKUP_PROG_MOUNT_REQ;
nfs_send();
} else {
nfs_state = STATE_READ_REQ;
nfs_offset = 0;
nfs_len = NFS_READ_SIZE;
nfs_send();
}
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");
nfs_state = STATE_UMOUNT_REQ;
nfs_send();
} else {
debug("Symlink --> %s\n", nfs_path);
nfs_filename = nfs_basename(nfs_path);
nfs_path = nfs_dirname(nfs_path);
nfs_state = STATE_MOUNT_REQ;
nfs_send();
}
break;
case STATE_READ_REQ:
rlen = nfs_read_reply(pkt, len);
if (rlen == -NFS_RPC_DROP)
break;
nfs_refresh_timeout();
if (rlen > 0) {
nfs_offset += rlen;
nfs_send();
} else if ((rlen == -NFSERR_ISDIR) || (rlen == -NFSERR_INVAL)) {
/* symbolic link */
nfs_state = STATE_READLINK_REQ;
nfs_send();
} else {
if (!rlen)
nfs_download_state = NETLOOP_SUCCESS;
if (rlen < 0)
debug("NFS READ error (%d)\n", rlen);
nfs_state = STATE_UMOUNT_REQ;
nfs_send();
}
break;
}
}

123
net/nfs-common.h Normal file
View File

@@ -0,0 +1,123 @@
/* SPDX-License-Identifier: GPL-2.0+ */
/*
* (C) Masami Komiya <mkomiya@sonare.it> 2004
*/
#ifndef __NFS_COMMON_H__
#define __NFS_COMMON_H__
#define SUNRPC_PORT 111
#define PROG_PORTMAP 100000
#define PROG_NFS 100003
#define PROG_MOUNT 100005
#define MSG_CALL 0
#define MSG_REPLY 1
#define HASHES_PER_LINE 65 /* Number of "loading" hashes per line */
#define NFS_RETRY_COUNT 30
#define NFS_RPC_ERR 1
#define NFS_RPC_DROP 124
#define NFSERR_PERM 1
#define NFSERR_NOENT 2
#define NFSERR_ACCES 13
#define NFSERR_ISDIR 21
#define NFSERR_INVAL 22
/* Values for Accept State flag on RPC answers (See: rfc1831) */
enum rpc_accept_stat {
NFS_RPC_SUCCESS = 0, /* RPC executed successfully */
NFS_RPC_PROG_UNAVAIL = 1, /* remote hasn't exported program */
NFS_RPC_PROG_MISMATCH = 2, /* remote can't support version # */
NFS_RPC_PROC_UNAVAIL = 3, /* program can't support procedure */
NFS_RPC_GARBAGE_ARGS = 4, /* procedure can't decode params */
NFS_RPC_SYSTEM_ERR = 5 /* errors like memory allocation failure */
};
enum nfs_version {
NFS_UNKOWN = 0,
NFS_V1 = 1,
NFS_V2 = 2,
NFS_V3 = 3,
};
extern enum net_loop_state nfs_download_state;
extern char *nfs_filename;
extern char *nfs_path;
extern char nfs_path_buff[2048];
extern struct in_addr nfs_server_ip;
extern int nfs_server_mount_port;
extern int nfs_server_port;
extern int nfs_our_port;
extern int nfs_timeout_count;
extern unsigned long rpc_id;
extern int nfs_offset;
extern int nfs_len;
extern const ulong nfs_timeout;
extern int nfs_state;
#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
/*
* Block size used for NFS read accesses. A RPC reply packet (including all
* headers) must fit within a single Ethernet frame to avoid fragmentation.
* However, if CONFIG_IP_DEFRAG is set, a bigger value could be used. In any
* case, most NFS servers are optimized for a power of 2.
*/
#define NFS_READ_SIZE 1024 /* biggest power of two that fits Ether frame */
#define NFS_MAX_ATTRS 26
struct rpc_t {
union {
u8 data[NFS_READ_SIZE + (6 + NFS_MAX_ATTRS) *
sizeof(uint32_t)];
struct {
u32 id;
u32 type;
u32 rpcvers;
u32 prog;
u32 vers;
u32 proc;
u32 data[1];
} call;
struct {
u32 id;
u32 type;
u32 rstatus;
u32 verifier;
u32 v2;
u32 astatus;
u32 data[NFS_READ_SIZE / sizeof(u32) +
NFS_MAX_ATTRS];
} reply;
} u;
};
char *nfs_basename(char *path);
char *nfs_dirname(char *path);
void rpc_req_common(int rpc_prog, int rpc_proc, uint32_t *data, int datalen,
uchar *txbuff, int *pktlen, int *sport);
void nfs_send(void);
void nfs_pkt_recv(uchar *pkt, unsigned int len);
extern enum nfs_version choosen_nfs_version;
/*
* Implementation specific functions called from common code
*/
void rpc_req(int rpc_prog, int rpc_proc, uint32_t *data, int datalen);
void nfs_refresh_timeout(void);
/**********************************************************************/
#endif /* __NFS_COMMON_H__ */

849
net/nfs.c
View File

@@ -1,3 +1,4 @@
// SPDX-License-Identifier: GPL-2.0+
/*
* NFS support driver - based on etherboot and U-BOOT's tftp.c
*
@@ -30,745 +31,31 @@
* September 27, 2018. As of now, NFSv3 is the default choice. If the server
* does not support NFSv3, we fall back to versions 2 or 1. */
#include <command.h>
#include <display_options.h>
#ifdef CONFIG_SYS_DIRECT_FLASH_NFS
#include <flash.h>
#endif
#include <image.h>
#include <log.h>
#include <net.h>
#include <malloc.h>
#include <mapmem.h>
#include "nfs.h"
#include "bootp.h"
#include "nfs-common.h"
#include <time.h>
#define HASHES_PER_LINE 65 /* Number of "loading" hashes per line */
#define NFS_RETRY_COUNT 30
#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 const ulong nfs_timeout = CONFIG_NFS_TIMEOUT;
static char dirfh[NFS3_FHSIZE]; /* NFSv2 / NFSv3 file handle of directory */
static unsigned int dirfh3_length; /* (variable) length of dirfh when NFSv3 */
static char filefh[NFS3_FHSIZE]; /* NFSv2 / NFSv3 file handle */
static unsigned int filefh3_length; /* (variable) length of filefh when NFSv3 */
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
#define STATE_UMOUNT_REQ 4
#define STATE_LOOKUP_REQ 5
#define STATE_READ_REQ 6
#define STATE_READLINK_REQ 7
static char *nfs_filename;
static char *nfs_path;
static char nfs_path_buff[2048];
enum nfs_version {
NFS_UNKOWN = 0,
NFS_V1 = 1,
NFS_V2 = 2,
NFS_V3 = 3,
};
static enum nfs_version choosen_nfs_version = NFS_V3;
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 (image_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)image_load_addr + offset,
len);
if (rc) {
flash_perror(rc);
return -1;
}
} else
#endif /* CONFIG_SYS_DIRECT_FLASH_NFS */
{
void *ptr = map_sysmem(image_load_addr + offset, len);
memcpy(ptr, src, len);
unmap_sysmem(ptr);
}
if (net_boot_file_size < (offset + len))
net_boot_file_size = 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 uint32_t *rpc_add_credentials(uint32_t *p)
{
/* 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). */
/* Provide an AUTH_UNIX credential. */
*p++ = htonl(1); /* AUTH_UNIX */
*p++ = htonl(20); /* auth length */
*p++ = 0; /* stamp */
*p++ = 0; /* hostname string */
*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)
void rpc_req(int rpc_prog, int rpc_proc, uint32_t *data, int datalen)
{
struct rpc_t rpc_pkt;
unsigned long id;
uint32_t *p;
int pktlen;
int sport;
id = ++rpc_id;
rpc_pkt.u.call.id = htonl(id);
rpc_pkt.u.call.type = htonl(MSG_CALL);
rpc_pkt.u.call.rpcvers = htonl(2); /* use RPC version 2 */
rpc_pkt.u.call.prog = htonl(rpc_prog);
switch (rpc_prog) {
case PROG_NFS:
switch (choosen_nfs_version) {
case NFS_V1:
case NFS_V2:
rpc_pkt.u.call.vers = htonl(2);
break;
case NFS_V3:
rpc_pkt.u.call.vers = htonl(3);
break;
case NFS_UNKOWN:
/* nothing to do */
break;
}
break;
case PROG_MOUNT:
switch (choosen_nfs_version) {
case NFS_V1:
rpc_pkt.u.call.vers = htonl(1);
break;
case NFS_V2:
rpc_pkt.u.call.vers = htonl(2);
break;
case NFS_V3:
rpc_pkt.u.call.vers = htonl(3);
break;
case NFS_UNKOWN:
/* nothing to do */
break;
}
break;
case PROG_PORTMAP:
default:
rpc_pkt.u.call.vers = htonl(2); /* portmapper is version 2 */
}
rpc_pkt.u.call.proc = htonl(rpc_proc);
p = rpc_pkt.u.call.data;
if (datalen)
memcpy(p, data, datalen * sizeof(uint32_t));
pktlen = (char *)p + datalen * sizeof(uint32_t) - (char *)&rpc_pkt;
memcpy((char *)net_tx_packet + net_eth_hdr_size() + IP_UDP_HDR_SIZE,
&rpc_pkt.u.data[0], pktlen);
if (rpc_prog == PROG_PORTMAP)
sport = SUNRPC_PORT;
else if (rpc_prog == PROG_MOUNT)
sport = nfs_server_mount_port;
else
sport = nfs_server_port;
rpc_req_common(rpc_prog, rpc_proc, data, datalen,
(char *)net_tx_packet + net_eth_hdr_size()
+ IP_UDP_HDR_SIZE, &pktlen, &sport);
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)
{
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 = rpc_add_credentials(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 ((nfs_server_mount_port == -1) || (!fs_mounted))
/* Nothing mounted, nothing to umount */
return;
p = &(data[0]);
p = rpc_add_credentials(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 = rpc_add_credentials(p);
if (choosen_nfs_version != NFS_V3) {
memcpy(p, filefh, NFS_FHSIZE);
p += (NFS_FHSIZE / 4);
} else { /* NFS_V3 */
*p++ = htonl(filefh3_length);
memcpy(p, filefh, filefh3_length);
p += (filefh3_length / 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 = rpc_add_credentials(p);
if (choosen_nfs_version != NFS_V3) {
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);
} else { /* NFS_V3 */
*p++ = htonl(dirfh3_length); /* Dir handle length */
memcpy(p, dirfh, dirfh3_length);
p += (dirfh3_length / 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, NFS3PROC_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 = rpc_add_credentials(p);
if (choosen_nfs_version != NFS_V3) {
memcpy(p, filefh, NFS_FHSIZE);
p += (NFS_FHSIZE / 4);
*p++ = htonl(offset);
*p++ = htonl(readlen);
*p++ = 0;
} else { /* NFS_V3 */
*p++ = htonl(filefh3_length);
memcpy(p, filefh, filefh3_length);
p += (filefh3_length / 4);
*p++ = htonl(0); /* offset is 64-bit long, so fill with 0 */
*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 nfs_send(void)
{
debug("%s\n", __func__);
switch (nfs_state) {
case STATE_PRCLOOKUP_PROG_MOUNT_REQ:
if (choosen_nfs_version != NFS_V3)
rpc_lookup_req(PROG_MOUNT, 1);
else /* NFS_V3 */
rpc_lookup_req(PROG_MOUNT, 3);
break;
case STATE_PRCLOOKUP_PROG_NFS_REQ:
if (choosen_nfs_version != NFS_V3)
rpc_lookup_req(PROG_NFS, 2);
else /* NFS_V3 */
rpc_lookup_req(PROG_NFS, 3);
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_handle_error(struct rpc_t *rpc_pkt)
{
if (rpc_pkt->u.reply.rstatus ||
rpc_pkt->u.reply.verifier ||
rpc_pkt->u.reply.astatus ||
rpc_pkt->u.reply.data[0]) {
switch (ntohl(rpc_pkt->u.reply.astatus)) {
case NFS_RPC_SUCCESS: /* Not an error */
break;
case NFS_RPC_PROG_MISMATCH: {
/* Remote can't support NFS version */
const int min = ntohl(rpc_pkt->u.reply.data[0]);
const int max = ntohl(rpc_pkt->u.reply.data[1]);
if (max < NFS_V1 || max > NFS_V3 || min > NFS_V3) {
puts("*** ERROR: NFS version not supported");
debug(": Requested: V%d, accepted: min V%d - max V%d\n",
choosen_nfs_version,
ntohl(rpc_pkt->u.reply.data[0]),
ntohl(rpc_pkt->u.reply.data[1]));
puts("\n");
choosen_nfs_version = NFS_UNKOWN;
break;
}
debug("*** Warning: NFS version not supported: Requested: V%d, accepted: min V%d - max V%d\n",
choosen_nfs_version,
ntohl(rpc_pkt->u.reply.data[0]),
ntohl(rpc_pkt->u.reply.data[1]));
debug("Will retry with NFSv%d\n", min);
choosen_nfs_version = min;
return -NFS_RPC_PROG_MISMATCH;
}
case NFS_RPC_PROG_UNAVAIL:
case NFS_RPC_PROC_UNAVAIL:
case NFS_RPC_GARBAGE_ARGS:
case NFS_RPC_SYSTEM_ERR:
default: /* Unknown error on 'accept state' flag */
debug("*** ERROR: accept state error (%d)\n",
ntohl(rpc_pkt->u.reply.astatus));
break;
}
return -1;
}
return 0;
}
static int rpc_lookup_reply(int prog, uchar *pkt, unsigned len)
{
struct rpc_t rpc_pkt;
memcpy(&rpc_pkt.u.data[0], 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:
nfs_server_mount_port = ntohl(rpc_pkt.u.reply.data[0]);
break;
case PROG_NFS:
nfs_server_port = ntohl(rpc_pkt.u.reply.data[0]);
break;
}
return 0;
}
static int nfs_mount_reply(uchar *pkt, unsigned len)
{
struct rpc_t rpc_pkt;
int ret;
debug("%s\n", __func__);
memcpy(&rpc_pkt.u.data[0], 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;
ret = rpc_handle_error(&rpc_pkt);
if (ret)
return ret;
fs_mounted = 1;
/* NFSv2 and NFSv3 use same structure */
if (choosen_nfs_version != NFS_V3) {
memcpy(dirfh, rpc_pkt.u.reply.data + 1, NFS_FHSIZE);
} else {
dirfh3_length = ntohl(rpc_pkt.u.reply.data[1]);
if (dirfh3_length > NFS3_FHSIZE)
dirfh3_length = NFS3_FHSIZE;
memcpy(dirfh, rpc_pkt.u.reply.data + 2, dirfh3_length);
}
return 0;
}
static int nfs_umountall_reply(uchar *pkt, unsigned len)
{
struct rpc_t rpc_pkt;
debug("%s\n", __func__);
memcpy(&rpc_pkt.u.data[0], 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;
int ret;
debug("%s\n", __func__);
memcpy(&rpc_pkt.u.data[0], 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;
ret = rpc_handle_error(&rpc_pkt);
if (ret)
return ret;
if (choosen_nfs_version != NFS_V3) {
if (((uchar *)&(rpc_pkt.u.reply.data[0]) - (uchar *)(&rpc_pkt) + NFS_FHSIZE) > len)
return -NFS_RPC_DROP;
memcpy(filefh, rpc_pkt.u.reply.data + 1, NFS_FHSIZE);
} else { /* NFS_V3 */
filefh3_length = ntohl(rpc_pkt.u.reply.data[1]);
if (filefh3_length > NFS3_FHSIZE)
filefh3_length = NFS3_FHSIZE;
memcpy(filefh, rpc_pkt.u.reply.data + 2, filefh3_length);
}
return 0;
}
static int nfs3_get_attributes_offset(uint32_t *data)
{
if (data[1]) {
/* 'attributes_follow' flag is TRUE,
* so we have attributes on 21 dwords */
/* Skip unused values :
type; 32 bits value,
mode; 32 bits value,
nlink; 32 bits value,
uid; 32 bits value,
gid; 32 bits value,
size; 64 bits value,
used; 64 bits value,
rdev; 64 bits value,
fsid; 64 bits value,
fileid; 64 bits value,
atime; 64 bits value,
mtime; 64 bits value,
ctime; 64 bits value,
*/
return 22;
} else {
/* 'attributes_follow' flag is FALSE,
* so we don't have any attributes */
return 1;
}
}
static int nfs_readlink_reply(uchar *pkt, unsigned len)
{
struct rpc_t rpc_pkt;
int rlen;
int nfsv3_data_offset = 0;
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;
if (choosen_nfs_version == NFS_V3) {
nfsv3_data_offset =
nfs3_get_attributes_offset(rpc_pkt.u.reply.data);
}
/* new path length */
rlen = ntohl(rpc_pkt.u.reply.data[1 + nfsv3_data_offset]);
if (((uchar *)&(rpc_pkt.u.reply.data[0]) - (uchar *)(&rpc_pkt) + rlen) > len)
return -NFS_RPC_DROP;
if (*((char *)&(rpc_pkt.u.reply.data[2 + nfsv3_data_offset])) != '/') {
int pathlen;
strcat(nfs_path, "/");
pathlen = strlen(nfs_path);
memcpy(nfs_path + pathlen,
(uchar *)&(rpc_pkt.u.reply.data[2 + nfsv3_data_offset]),
rlen);
nfs_path[pathlen + rlen] = 0;
} else {
memcpy(nfs_path,
(uchar *)&(rpc_pkt.u.reply.data[2 + nfsv3_data_offset]),
rlen);
nfs_path[rlen] = 0;
}
return 0;
}
static int nfs_read_reply(uchar *pkt, unsigned len)
{
struct rpc_t rpc_pkt;
int rlen;
uchar *data_ptr;
debug("%s\n", __func__);
memcpy(&rpc_pkt.u.data[0], 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('#');
if (choosen_nfs_version != NFS_V3) {
rlen = ntohl(rpc_pkt.u.reply.data[18]);
data_ptr = (uchar *)&(rpc_pkt.u.reply.data[19]);
} else { /* NFS_V3 */
int nfsv3_data_offset =
nfs3_get_attributes_offset(rpc_pkt.u.reply.data);
/* count value */
rlen = ntohl(rpc_pkt.u.reply.data[1 + nfsv3_data_offset]);
/* Skip unused values :
EOF: 32 bits value,
data_size: 32 bits value,
*/
data_ptr = (uchar *)
&(rpc_pkt.u.reply.data[4 + nfsv3_data_offset]);
}
if (((uchar *)&(rpc_pkt.u.reply.data[0]) - (uchar *)(&rpc_pkt) + rlen) > len)
return -9999;
if (store_block(data_ptr, nfs_offset, rlen))
return -9999;
return rlen;
}
/**************************************************************************
Interfaces of U-BOOT
**************************************************************************/
@@ -786,12 +73,14 @@ static void nfs_timeout_handler(void)
}
}
void nfs_refresh_timeout(void)
{
net_set_timeout_handler(nfs_timeout, nfs_timeout_handler);
}
static void nfs_handler(uchar *pkt, unsigned dest, struct in_addr sip,
unsigned src, unsigned len)
{
int rlen;
int reply;
debug("%s\n", __func__);
if (len > sizeof(struct rpc_t))
@@ -800,117 +89,7 @@ static void nfs_handler(uchar *pkt, unsigned dest, struct in_addr sip,
if (dest != nfs_our_port)
return;
switch (nfs_state) {
case STATE_PRCLOOKUP_PROG_MOUNT_REQ:
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:
if (rpc_lookup_reply(PROG_NFS, pkt, len) == -NFS_RPC_DROP)
break;
nfs_state = STATE_MOUNT_REQ;
nfs_send();
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... */
nfs_state = STATE_UMOUNT_REQ;
nfs_send();
} else if (reply == -NFS_RPC_PROG_MISMATCH &&
choosen_nfs_version != NFS_UNKOWN) {
nfs_state = STATE_MOUNT_REQ;
nfs_send();
} else {
nfs_state = STATE_LOOKUP_REQ;
nfs_send();
}
break;
case STATE_UMOUNT_REQ:
reply = nfs_umountall_reply(pkt, len);
if (reply == -NFS_RPC_DROP) {
break;
} else if (reply == -NFS_RPC_ERR) {
debug("*** 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");
nfs_state = STATE_UMOUNT_REQ;
nfs_send();
} else if (reply == -NFS_RPC_PROG_MISMATCH &&
choosen_nfs_version != NFS_UNKOWN) {
/* umount */
nfs_state = STATE_UMOUNT_REQ;
nfs_send();
/* And retry with another supported version */
nfs_state = STATE_PRCLOOKUP_PROG_MOUNT_REQ;
nfs_send();
} else {
nfs_state = STATE_READ_REQ;
nfs_offset = 0;
nfs_len = NFS_READ_SIZE;
nfs_send();
}
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");
nfs_state = STATE_UMOUNT_REQ;
nfs_send();
} else {
debug("Symlink --> %s\n", nfs_path);
nfs_filename = basename(nfs_path);
nfs_path = dirname(nfs_path);
nfs_state = STATE_MOUNT_REQ;
nfs_send();
}
break;
case STATE_READ_REQ:
rlen = nfs_read_reply(pkt, len);
if (rlen == -NFS_RPC_DROP)
break;
net_set_timeout_handler(nfs_timeout, nfs_timeout_handler);
if (rlen > 0) {
nfs_offset += rlen;
nfs_send();
} else if ((rlen == -NFSERR_ISDIR) || (rlen == -NFSERR_INVAL)) {
/* symbolic link */
nfs_state = STATE_READLINK_REQ;
nfs_send();
} else {
if (!rlen)
nfs_download_state = NETLOOP_SUCCESS;
if (rlen < 0)
debug("NFS READ error (%d)\n", rlen);
nfs_state = STATE_UMOUNT_REQ;
nfs_send();
}
break;
}
nfs_pkt_recv(pkt, len);
}
void nfs_start(void)
@@ -939,8 +118,8 @@ void nfs_start(void)
nfs_path);
}
nfs_filename = basename(nfs_path);
nfs_path = dirname(nfs_path);
nfs_filename = nfs_basename(nfs_path);
nfs_path = nfs_dirname(nfs_path);
printf("Using %s device\n", eth_get_name());

59
net/nfs.h
View File

@@ -6,15 +6,6 @@
#ifndef __NFS_H__
#define __NFS_H__
#define SUNRPC_PORT 111
#define PROG_PORTMAP 100000
#define PROG_NFS 100003
#define PROG_MOUNT 100005
#define MSG_CALL 0
#define MSG_REPLY 1
#define PORTMAP_GETPORT 3
#define MOUNT_ADDENTRY 1
@@ -29,56 +20,6 @@
#define NFS_FHSIZE 32
#define NFS3_FHSIZE 64
#define NFSERR_PERM 1
#define NFSERR_NOENT 2
#define NFSERR_ACCES 13
#define NFSERR_ISDIR 21
#define NFSERR_INVAL 22
/*
* Block size used for NFS read accesses. A RPC reply packet (including all
* headers) must fit within a single Ethernet frame to avoid fragmentation.
* However, if CONFIG_IP_DEFRAG is set, a bigger value could be used. In any
* case, most NFS servers are optimized for a power of 2.
*/
#define NFS_READ_SIZE 1024 /* biggest power of two that fits Ether frame */
#define NFS_MAX_ATTRS 26
/* Values for Accept State flag on RPC answers (See: rfc1831) */
enum rpc_accept_stat {
NFS_RPC_SUCCESS = 0, /* RPC executed successfully */
NFS_RPC_PROG_UNAVAIL = 1, /* remote hasn't exported program */
NFS_RPC_PROG_MISMATCH = 2, /* remote can't support version # */
NFS_RPC_PROC_UNAVAIL = 3, /* program can't support procedure */
NFS_RPC_GARBAGE_ARGS = 4, /* procedure can't decode params */
NFS_RPC_SYSTEM_ERR = 5 /* errors like memory allocation failure */
};
struct rpc_t {
union {
uint8_t data[NFS_READ_SIZE + (6 + NFS_MAX_ATTRS) *
sizeof(uint32_t)];
struct {
uint32_t id;
uint32_t type;
uint32_t rpcvers;
uint32_t prog;
uint32_t vers;
uint32_t proc;
uint32_t data[1];
} call;
struct {
uint32_t id;
uint32_t type;
uint32_t rstatus;
uint32_t verifier;
uint32_t v2;
uint32_t astatus;
uint32_t data[NFS_READ_SIZE / sizeof(uint32_t) +
NFS_MAX_ATTRS];
} reply;
} u;
};
void nfs_start(void); /* Begin NFS */
/**********************************************************************/

31
net/tftp.c
View File

@@ -22,6 +22,15 @@
DECLARE_GLOBAL_DATA_PTR;
/*
* We cannot use the 'tftpput' command in xPL phases. Given how the
* support is integrated in the code, this is how we disable that support
* in xPL.
*/
#if defined(CONFIG_CMD_TFTPPUT) && !defined(CONFIG_XPL_BUILD)
#define CMD_TFTPPUT
#endif
/* Well known TFTP port # */
#define WELL_KNOWN_PORT 69
/* Millisecs to timeout for lost pkt */
@@ -95,7 +104,7 @@ static ushort tftp_windowsize;
static ushort tftp_next_ack;
/* Last nack block we send */
static ushort tftp_last_nack;
#ifdef CONFIG_CMD_TFTPPUT
#ifdef CMD_TFTPPUT
/* 1 if writing, else 0 */
static int tftp_put_active;
/* 1 if we have sent the last block */
@@ -183,13 +192,13 @@ static void new_transfer(void)
tftp_prev_block = 0;
tftp_block_wrap = 0;
tftp_block_wrap_offset = 0;
#ifdef CONFIG_CMD_TFTPPUT
#ifdef CMD_TFTPPUT
tftp_put_final_block_sent = 0;
#endif
led_activity_blink();
}
#ifdef CONFIG_CMD_TFTPPUT
#ifdef CMD_TFTPPUT
/**
* Load the next block from memory to be sent over tftp.
*
@@ -329,7 +338,7 @@ static void tftp_send(void)
case STATE_SEND_WRQ:
xp = pkt;
s = (ushort *)pkt;
#ifdef CONFIG_CMD_TFTPPUT
#ifdef CMD_TFTPPUT
*s++ = htons(tftp_state == STATE_SEND_RRQ ? TFTP_RRQ :
TFTP_WRQ);
#else
@@ -372,7 +381,7 @@ static void tftp_send(void)
s[0] = htons(TFTP_ACK);
s[1] = htons(tftp_cur_block);
pkt = (uchar *)(s + 2);
#ifdef CONFIG_CMD_TFTPPUT
#ifdef CMD_TFTPPUT
if (tftp_put_active) {
int toload = tftp_block_size;
int loaded = load_block(tftp_cur_block, pkt, toload);
@@ -437,7 +446,7 @@ static void tftp_send(void)
net_set_state(NETLOOP_FAIL);
}
#ifdef CONFIG_CMD_TFTPPUT
#ifdef CMD_TFTPPUT
static void icmp_handler(unsigned type, unsigned code, unsigned dest,
struct in_addr sip, unsigned src, uchar *pkt,
unsigned len)
@@ -476,7 +485,7 @@ static void tftp_handler(uchar *pkt, unsigned dest, struct in_addr sip,
break;
case TFTP_ACK:
#ifdef CONFIG_CMD_TFTPPUT
#ifdef CMD_TFTPPUT
if (tftp_put_active) {
timeout_count = 0;
if (tftp_put_final_block_sent) {
@@ -578,7 +587,7 @@ static void tftp_handler(uchar *pkt, unsigned dest, struct in_addr sip,
tftp_next_ack = tftp_windowsize;
#ifdef CONFIG_CMD_TFTPPUT
#ifdef CMD_TFTPPUT
if (tftp_put_active && tftp_state == STATE_OACK) {
/* Get ready to send the first block */
tftp_state = STATE_DATA;
@@ -854,7 +863,7 @@ void tftp_start(enum proto_t protocol)
tftp_block_size_option = TFTP_MTU_BLOCKSIZE6;
} else {
printf("TFTP %s server %pI4; our IP address is %pI4",
#ifdef CONFIG_CMD_TFTPPUT
#ifdef CMD_TFTPPUT
protocol == TFTPPUT ? "to" : "from",
#else
"from",
@@ -888,7 +897,7 @@ void tftp_start(enum proto_t protocol)
}
putc('\n');
#ifdef CONFIG_CMD_TFTPPUT
#ifdef CMD_TFTPPUT
tftp_put_active = (protocol == TFTPPUT);
if (tftp_put_active) {
printf("Save address: 0x%lx\n", image_save_addr);
@@ -911,7 +920,7 @@ void tftp_start(enum proto_t protocol)
net_set_timeout_handler(timeout_ms, tftp_timeout_handler);
net_set_udp_handler(tftp_handler);
#ifdef CONFIG_CMD_TFTPPUT
#ifdef CMD_TFTPPUT
net_set_icmp_handler(icmp_handler);
#endif
tftp_remote_port = WELL_KNOWN_PORT;