nfs.c 19 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774
  1. /*
  2. * NFS support driver - based on etherboot and U-BOOT's tftp.c
  3. *
  4. * Masami Komiya <mkomiya@sonare.it> 2004
  5. *
  6. */
  7. /* NOTE: the NFS code is heavily inspired by the NetBSD netboot code (read:
  8. * large portions are copied verbatim) as distributed in OSKit 0.97. A few
  9. * changes were necessary to adapt the code to Etherboot and to fix several
  10. * inconsistencies. Also the RPC message preparation is done "by hand" to
  11. * avoid adding netsprintf() which I find hard to understand and use. */
  12. /* NOTE 2: Etherboot does not care about things beyond the kernel image, so
  13. * it loads the kernel image off the boot server (ARP_SERVER) and does not
  14. * access the client root disk (root-path in dhcpd.conf), which would use
  15. * ARP_ROOTSERVER. The root disk is something the operating system we are
  16. * about to load needs to use. This is different from the OSKit 0.97 logic. */
  17. /* NOTE 3: Symlink handling introduced by Anselm M Hoffmeister, 2003-July-14
  18. * If a symlink is encountered, it is followed as far as possible (recursion
  19. * possible, maximum 16 steps). There is no clearing of ".."'s inside the
  20. * path, so please DON'T DO THAT. thx. */
  21. #include <common.h>
  22. #include <command.h>
  23. #include <net.h>
  24. #include <malloc.h>
  25. #include <mapmem.h>
  26. #include "nfs.h"
  27. #include "bootp.h"
  28. #define HASHES_PER_LINE 65 /* Number of "loading" hashes per line */
  29. #define NFS_RETRY_COUNT 30
  30. #ifndef CONFIG_NFS_TIMEOUT
  31. # define NFS_TIMEOUT 2000UL
  32. #else
  33. # define NFS_TIMEOUT CONFIG_NFS_TIMEOUT
  34. #endif
  35. #define NFS_RPC_ERR 1
  36. #define NFS_RPC_DROP 124
  37. static int fs_mounted;
  38. static unsigned long rpc_id;
  39. static int nfs_offset = -1;
  40. static int nfs_len;
  41. static ulong nfs_timeout = NFS_TIMEOUT;
  42. static char dirfh[NFS_FHSIZE]; /* file handle of directory */
  43. static char filefh[NFS_FHSIZE]; /* file handle of kernel image */
  44. static enum net_loop_state nfs_download_state;
  45. static struct in_addr nfs_server_ip;
  46. static int nfs_server_mount_port;
  47. static int nfs_server_port;
  48. static int nfs_our_port;
  49. static int nfs_timeout_count;
  50. static int nfs_state;
  51. #define STATE_PRCLOOKUP_PROG_MOUNT_REQ 1
  52. #define STATE_PRCLOOKUP_PROG_NFS_REQ 2
  53. #define STATE_MOUNT_REQ 3
  54. #define STATE_UMOUNT_REQ 4
  55. #define STATE_LOOKUP_REQ 5
  56. #define STATE_READ_REQ 6
  57. #define STATE_READLINK_REQ 7
  58. static char default_filename[64];
  59. static char *nfs_filename;
  60. static char *nfs_path;
  61. static char nfs_path_buff[2048];
  62. static inline int store_block(uchar *src, unsigned offset, unsigned len)
  63. {
  64. ulong newsize = offset + len;
  65. #ifdef CONFIG_SYS_DIRECT_FLASH_NFS
  66. int i, rc = 0;
  67. for (i = 0; i < CONFIG_SYS_MAX_FLASH_BANKS; i++) {
  68. /* start address in flash? */
  69. if (load_addr + offset >= flash_info[i].start[0]) {
  70. rc = 1;
  71. break;
  72. }
  73. }
  74. if (rc) { /* Flash is destination for this packet */
  75. rc = flash_write((uchar *)src, (ulong)(load_addr+offset), len);
  76. if (rc) {
  77. flash_perror(rc);
  78. return -1;
  79. }
  80. } else
  81. #endif /* CONFIG_SYS_DIRECT_FLASH_NFS */
  82. {
  83. void *ptr = map_sysmem(load_addr + offset, len);
  84. memcpy(ptr, src, len);
  85. unmap_sysmem(ptr);
  86. }
  87. if (net_boot_file_size < (offset + len))
  88. net_boot_file_size = newsize;
  89. return 0;
  90. }
  91. static char *basename(char *path)
  92. {
  93. char *fname;
  94. fname = path + strlen(path) - 1;
  95. while (fname >= path) {
  96. if (*fname == '/') {
  97. fname++;
  98. break;
  99. }
  100. fname--;
  101. }
  102. return fname;
  103. }
  104. static char *dirname(char *path)
  105. {
  106. char *fname;
  107. fname = basename(path);
  108. --fname;
  109. *fname = '\0';
  110. return path;
  111. }
  112. /**************************************************************************
  113. RPC_ADD_CREDENTIALS - Add RPC authentication/verifier entries
  114. **************************************************************************/
  115. static long *rpc_add_credentials(long *p)
  116. {
  117. int hl;
  118. int hostnamelen;
  119. char hostname[256];
  120. strcpy(hostname, "");
  121. hostnamelen = strlen(hostname);
  122. /* Here's the executive summary on authentication requirements of the
  123. * various NFS server implementations: Linux accepts both AUTH_NONE
  124. * and AUTH_UNIX authentication (also accepts an empty hostname field
  125. * in the AUTH_UNIX scheme). *BSD refuses AUTH_NONE, but accepts
  126. * AUTH_UNIX (also accepts an empty hostname field in the AUTH_UNIX
  127. * scheme). To be safe, use AUTH_UNIX and pass the hostname if we have
  128. * it (if the BOOTP/DHCP reply didn't give one, just use an empty
  129. * hostname). */
  130. hl = (hostnamelen + 3) & ~3;
  131. /* Provide an AUTH_UNIX credential. */
  132. *p++ = htonl(1); /* AUTH_UNIX */
  133. *p++ = htonl(hl+20); /* auth length */
  134. *p++ = htonl(0); /* stamp */
  135. *p++ = htonl(hostnamelen); /* hostname string */
  136. if (hostnamelen & 3)
  137. *(p + hostnamelen / 4) = 0; /* add zero padding */
  138. memcpy(p, hostname, hostnamelen);
  139. p += hl / 4;
  140. *p++ = 0; /* uid */
  141. *p++ = 0; /* gid */
  142. *p++ = 0; /* auxiliary gid list */
  143. /* Provide an AUTH_NONE verifier. */
  144. *p++ = 0; /* AUTH_NONE */
  145. *p++ = 0; /* auth length */
  146. return p;
  147. }
  148. /**************************************************************************
  149. RPC_LOOKUP - Lookup RPC Port numbers
  150. **************************************************************************/
  151. static void rpc_req(int rpc_prog, int rpc_proc, uint32_t *data, int datalen)
  152. {
  153. struct rpc_t pkt;
  154. unsigned long id;
  155. uint32_t *p;
  156. int pktlen;
  157. int sport;
  158. id = ++rpc_id;
  159. pkt.u.call.id = htonl(id);
  160. pkt.u.call.type = htonl(MSG_CALL);
  161. pkt.u.call.rpcvers = htonl(2); /* use RPC version 2 */
  162. pkt.u.call.prog = htonl(rpc_prog);
  163. pkt.u.call.vers = htonl(2); /* portmapper is version 2 */
  164. pkt.u.call.proc = htonl(rpc_proc);
  165. p = (uint32_t *)&(pkt.u.call.data);
  166. if (datalen)
  167. memcpy((char *)p, (char *)data, datalen*sizeof(uint32_t));
  168. pktlen = (char *)p + datalen*sizeof(uint32_t) - (char *)&pkt;
  169. memcpy((char *)net_tx_packet + net_eth_hdr_size() + IP_UDP_HDR_SIZE,
  170. (char *)&pkt, pktlen);
  171. if (rpc_prog == PROG_PORTMAP)
  172. sport = SUNRPC_PORT;
  173. else if (rpc_prog == PROG_MOUNT)
  174. sport = nfs_server_mount_port;
  175. else
  176. sport = nfs_server_port;
  177. net_send_udp_packet(net_server_ethaddr, nfs_server_ip, sport,
  178. nfs_our_port, pktlen);
  179. }
  180. /**************************************************************************
  181. RPC_LOOKUP - Lookup RPC Port numbers
  182. **************************************************************************/
  183. static void rpc_lookup_req(int prog, int ver)
  184. {
  185. uint32_t data[16];
  186. data[0] = 0; data[1] = 0; /* auth credential */
  187. data[2] = 0; data[3] = 0; /* auth verifier */
  188. data[4] = htonl(prog);
  189. data[5] = htonl(ver);
  190. data[6] = htonl(17); /* IP_UDP */
  191. data[7] = 0;
  192. rpc_req(PROG_PORTMAP, PORTMAP_GETPORT, data, 8);
  193. }
  194. /**************************************************************************
  195. NFS_MOUNT - Mount an NFS Filesystem
  196. **************************************************************************/
  197. static void nfs_mount_req(char *path)
  198. {
  199. uint32_t data[1024];
  200. uint32_t *p;
  201. int len;
  202. int pathlen;
  203. pathlen = strlen(path);
  204. p = &(data[0]);
  205. p = (uint32_t *)rpc_add_credentials((long *)p);
  206. *p++ = htonl(pathlen);
  207. if (pathlen & 3)
  208. *(p + pathlen / 4) = 0;
  209. memcpy(p, path, pathlen);
  210. p += (pathlen + 3) / 4;
  211. len = (uint32_t *)p - (uint32_t *)&(data[0]);
  212. rpc_req(PROG_MOUNT, MOUNT_ADDENTRY, data, len);
  213. }
  214. /**************************************************************************
  215. NFS_UMOUNTALL - Unmount all our NFS Filesystems on the Server
  216. **************************************************************************/
  217. static void nfs_umountall_req(void)
  218. {
  219. uint32_t data[1024];
  220. uint32_t *p;
  221. int len;
  222. if ((nfs_server_mount_port == -1) || (!fs_mounted))
  223. /* Nothing mounted, nothing to umount */
  224. return;
  225. p = &(data[0]);
  226. p = (uint32_t *)rpc_add_credentials((long *)p);
  227. len = (uint32_t *)p - (uint32_t *)&(data[0]);
  228. rpc_req(PROG_MOUNT, MOUNT_UMOUNTALL, data, len);
  229. }
  230. /***************************************************************************
  231. * NFS_READLINK (AH 2003-07-14)
  232. * This procedure is called when read of the first block fails -
  233. * this probably happens when it's a directory or a symlink
  234. * In case of successful readlink(), the dirname is manipulated,
  235. * so that inside the nfs() function a recursion can be done.
  236. **************************************************************************/
  237. static void nfs_readlink_req(void)
  238. {
  239. uint32_t data[1024];
  240. uint32_t *p;
  241. int len;
  242. p = &(data[0]);
  243. p = (uint32_t *)rpc_add_credentials((long *)p);
  244. memcpy(p, filefh, NFS_FHSIZE);
  245. p += (NFS_FHSIZE / 4);
  246. len = (uint32_t *)p - (uint32_t *)&(data[0]);
  247. rpc_req(PROG_NFS, NFS_READLINK, data, len);
  248. }
  249. /**************************************************************************
  250. NFS_LOOKUP - Lookup Pathname
  251. **************************************************************************/
  252. static void nfs_lookup_req(char *fname)
  253. {
  254. uint32_t data[1024];
  255. uint32_t *p;
  256. int len;
  257. int fnamelen;
  258. fnamelen = strlen(fname);
  259. p = &(data[0]);
  260. p = (uint32_t *)rpc_add_credentials((long *)p);
  261. memcpy(p, dirfh, NFS_FHSIZE);
  262. p += (NFS_FHSIZE / 4);
  263. *p++ = htonl(fnamelen);
  264. if (fnamelen & 3)
  265. *(p + fnamelen / 4) = 0;
  266. memcpy(p, fname, fnamelen);
  267. p += (fnamelen + 3) / 4;
  268. len = (uint32_t *)p - (uint32_t *)&(data[0]);
  269. rpc_req(PROG_NFS, NFS_LOOKUP, data, len);
  270. }
  271. /**************************************************************************
  272. NFS_READ - Read File on NFS Server
  273. **************************************************************************/
  274. static void nfs_read_req(int offset, int readlen)
  275. {
  276. uint32_t data[1024];
  277. uint32_t *p;
  278. int len;
  279. p = &(data[0]);
  280. p = (uint32_t *)rpc_add_credentials((long *)p);
  281. memcpy(p, filefh, NFS_FHSIZE);
  282. p += (NFS_FHSIZE / 4);
  283. *p++ = htonl(offset);
  284. *p++ = htonl(readlen);
  285. *p++ = 0;
  286. len = (uint32_t *)p - (uint32_t *)&(data[0]);
  287. rpc_req(PROG_NFS, NFS_READ, data, len);
  288. }
  289. /**************************************************************************
  290. RPC request dispatcher
  291. **************************************************************************/
  292. static void nfs_send(void)
  293. {
  294. debug("%s\n", __func__);
  295. switch (nfs_state) {
  296. case STATE_PRCLOOKUP_PROG_MOUNT_REQ:
  297. rpc_lookup_req(PROG_MOUNT, 1);
  298. break;
  299. case STATE_PRCLOOKUP_PROG_NFS_REQ:
  300. rpc_lookup_req(PROG_NFS, 2);
  301. break;
  302. case STATE_MOUNT_REQ:
  303. nfs_mount_req(nfs_path);
  304. break;
  305. case STATE_UMOUNT_REQ:
  306. nfs_umountall_req();
  307. break;
  308. case STATE_LOOKUP_REQ:
  309. nfs_lookup_req(nfs_filename);
  310. break;
  311. case STATE_READ_REQ:
  312. nfs_read_req(nfs_offset, nfs_len);
  313. break;
  314. case STATE_READLINK_REQ:
  315. nfs_readlink_req();
  316. break;
  317. }
  318. }
  319. /**************************************************************************
  320. Handlers for the reply from server
  321. **************************************************************************/
  322. static int rpc_lookup_reply(int prog, uchar *pkt, unsigned len)
  323. {
  324. struct rpc_t rpc_pkt;
  325. memcpy((unsigned char *)&rpc_pkt, pkt, len);
  326. debug("%s\n", __func__);
  327. if (ntohl(rpc_pkt.u.reply.id) > rpc_id)
  328. return -NFS_RPC_ERR;
  329. else if (ntohl(rpc_pkt.u.reply.id) < rpc_id)
  330. return -NFS_RPC_DROP;
  331. if (rpc_pkt.u.reply.rstatus ||
  332. rpc_pkt.u.reply.verifier ||
  333. rpc_pkt.u.reply.astatus)
  334. return -1;
  335. switch (prog) {
  336. case PROG_MOUNT:
  337. nfs_server_mount_port = ntohl(rpc_pkt.u.reply.data[0]);
  338. break;
  339. case PROG_NFS:
  340. nfs_server_port = ntohl(rpc_pkt.u.reply.data[0]);
  341. break;
  342. }
  343. return 0;
  344. }
  345. static int nfs_mount_reply(uchar *pkt, unsigned len)
  346. {
  347. struct rpc_t rpc_pkt;
  348. debug("%s\n", __func__);
  349. memcpy((unsigned char *)&rpc_pkt, pkt, len);
  350. if (ntohl(rpc_pkt.u.reply.id) > rpc_id)
  351. return -NFS_RPC_ERR;
  352. else if (ntohl(rpc_pkt.u.reply.id) < rpc_id)
  353. return -NFS_RPC_DROP;
  354. if (rpc_pkt.u.reply.rstatus ||
  355. rpc_pkt.u.reply.verifier ||
  356. rpc_pkt.u.reply.astatus ||
  357. rpc_pkt.u.reply.data[0])
  358. return -1;
  359. fs_mounted = 1;
  360. memcpy(dirfh, rpc_pkt.u.reply.data + 1, NFS_FHSIZE);
  361. return 0;
  362. }
  363. static int nfs_umountall_reply(uchar *pkt, unsigned len)
  364. {
  365. struct rpc_t rpc_pkt;
  366. debug("%s\n", __func__);
  367. memcpy((unsigned char *)&rpc_pkt, pkt, len);
  368. if (ntohl(rpc_pkt.u.reply.id) > rpc_id)
  369. return -NFS_RPC_ERR;
  370. else if (ntohl(rpc_pkt.u.reply.id) < rpc_id)
  371. return -NFS_RPC_DROP;
  372. if (rpc_pkt.u.reply.rstatus ||
  373. rpc_pkt.u.reply.verifier ||
  374. rpc_pkt.u.reply.astatus)
  375. return -1;
  376. fs_mounted = 0;
  377. memset(dirfh, 0, sizeof(dirfh));
  378. return 0;
  379. }
  380. static int nfs_lookup_reply(uchar *pkt, unsigned len)
  381. {
  382. struct rpc_t rpc_pkt;
  383. debug("%s\n", __func__);
  384. memcpy((unsigned char *)&rpc_pkt, pkt, len);
  385. if (ntohl(rpc_pkt.u.reply.id) > rpc_id)
  386. return -NFS_RPC_ERR;
  387. else if (ntohl(rpc_pkt.u.reply.id) < rpc_id)
  388. return -NFS_RPC_DROP;
  389. if (rpc_pkt.u.reply.rstatus ||
  390. rpc_pkt.u.reply.verifier ||
  391. rpc_pkt.u.reply.astatus ||
  392. rpc_pkt.u.reply.data[0])
  393. return -1;
  394. memcpy(filefh, rpc_pkt.u.reply.data + 1, NFS_FHSIZE);
  395. return 0;
  396. }
  397. static int nfs_readlink_reply(uchar *pkt, unsigned len)
  398. {
  399. struct rpc_t rpc_pkt;
  400. int rlen;
  401. debug("%s\n", __func__);
  402. memcpy((unsigned char *)&rpc_pkt, pkt, len);
  403. if (ntohl(rpc_pkt.u.reply.id) > rpc_id)
  404. return -NFS_RPC_ERR;
  405. else if (ntohl(rpc_pkt.u.reply.id) < rpc_id)
  406. return -NFS_RPC_DROP;
  407. if (rpc_pkt.u.reply.rstatus ||
  408. rpc_pkt.u.reply.verifier ||
  409. rpc_pkt.u.reply.astatus ||
  410. rpc_pkt.u.reply.data[0])
  411. return -1;
  412. rlen = ntohl(rpc_pkt.u.reply.data[1]); /* new path length */
  413. if (*((char *)&(rpc_pkt.u.reply.data[2])) != '/') {
  414. int pathlen;
  415. strcat(nfs_path, "/");
  416. pathlen = strlen(nfs_path);
  417. memcpy(nfs_path + pathlen, (uchar *)&(rpc_pkt.u.reply.data[2]),
  418. rlen);
  419. nfs_path[pathlen + rlen] = 0;
  420. } else {
  421. memcpy(nfs_path, (uchar *)&(rpc_pkt.u.reply.data[2]), rlen);
  422. nfs_path[rlen] = 0;
  423. }
  424. return 0;
  425. }
  426. static int nfs_read_reply(uchar *pkt, unsigned len)
  427. {
  428. struct rpc_t rpc_pkt;
  429. int rlen;
  430. debug("%s\n", __func__);
  431. memcpy((uchar *)&rpc_pkt, pkt, sizeof(rpc_pkt.u.reply));
  432. if (ntohl(rpc_pkt.u.reply.id) > rpc_id)
  433. return -NFS_RPC_ERR;
  434. else if (ntohl(rpc_pkt.u.reply.id) < rpc_id)
  435. return -NFS_RPC_DROP;
  436. if (rpc_pkt.u.reply.rstatus ||
  437. rpc_pkt.u.reply.verifier ||
  438. rpc_pkt.u.reply.astatus ||
  439. rpc_pkt.u.reply.data[0]) {
  440. if (rpc_pkt.u.reply.rstatus)
  441. return -9999;
  442. if (rpc_pkt.u.reply.astatus)
  443. return -9999;
  444. return -ntohl(rpc_pkt.u.reply.data[0]);
  445. }
  446. if ((nfs_offset != 0) && !((nfs_offset) %
  447. (NFS_READ_SIZE / 2 * 10 * HASHES_PER_LINE)))
  448. puts("\n\t ");
  449. if (!(nfs_offset % ((NFS_READ_SIZE / 2) * 10)))
  450. putc('#');
  451. rlen = ntohl(rpc_pkt.u.reply.data[18]);
  452. if (store_block((uchar *)pkt + sizeof(rpc_pkt.u.reply),
  453. nfs_offset, rlen))
  454. return -9999;
  455. return rlen;
  456. }
  457. /**************************************************************************
  458. Interfaces of U-BOOT
  459. **************************************************************************/
  460. static void nfs_timeout_handler(void)
  461. {
  462. if (++nfs_timeout_count > NFS_RETRY_COUNT) {
  463. puts("\nRetry count exceeded; starting again\n");
  464. net_start_again();
  465. } else {
  466. puts("T ");
  467. net_set_timeout_handler(nfs_timeout +
  468. NFS_TIMEOUT * nfs_timeout_count,
  469. nfs_timeout_handler);
  470. nfs_send();
  471. }
  472. }
  473. static void nfs_handler(uchar *pkt, unsigned dest, struct in_addr sip,
  474. unsigned src, unsigned len)
  475. {
  476. int rlen;
  477. int reply;
  478. debug("%s\n", __func__);
  479. if (dest != nfs_our_port)
  480. return;
  481. switch (nfs_state) {
  482. case STATE_PRCLOOKUP_PROG_MOUNT_REQ:
  483. if (rpc_lookup_reply(PROG_MOUNT, pkt, len) == -NFS_RPC_DROP)
  484. break;
  485. nfs_state = STATE_PRCLOOKUP_PROG_NFS_REQ;
  486. nfs_send();
  487. break;
  488. case STATE_PRCLOOKUP_PROG_NFS_REQ:
  489. if (rpc_lookup_reply(PROG_NFS, pkt, len) == -NFS_RPC_DROP)
  490. break;
  491. nfs_state = STATE_MOUNT_REQ;
  492. nfs_send();
  493. break;
  494. case STATE_MOUNT_REQ:
  495. reply = nfs_mount_reply(pkt, len);
  496. if (reply == -NFS_RPC_DROP) {
  497. break;
  498. } else if (reply == -NFS_RPC_ERR) {
  499. puts("*** ERROR: Cannot mount\n");
  500. /* just to be sure... */
  501. nfs_state = STATE_UMOUNT_REQ;
  502. nfs_send();
  503. } else {
  504. nfs_state = STATE_LOOKUP_REQ;
  505. nfs_send();
  506. }
  507. break;
  508. case STATE_UMOUNT_REQ:
  509. reply = nfs_umountall_reply(pkt, len);
  510. if (reply == -NFS_RPC_DROP) {
  511. break;
  512. } else if (reply == -NFS_RPC_ERR) {
  513. puts("*** ERROR: Cannot umount\n");
  514. net_set_state(NETLOOP_FAIL);
  515. } else {
  516. puts("\ndone\n");
  517. net_set_state(nfs_download_state);
  518. }
  519. break;
  520. case STATE_LOOKUP_REQ:
  521. reply = nfs_lookup_reply(pkt, len);
  522. if (reply == -NFS_RPC_DROP) {
  523. break;
  524. } else if (reply == -NFS_RPC_ERR) {
  525. puts("*** ERROR: File lookup fail\n");
  526. nfs_state = STATE_UMOUNT_REQ;
  527. nfs_send();
  528. } else {
  529. nfs_state = STATE_READ_REQ;
  530. nfs_offset = 0;
  531. nfs_len = NFS_READ_SIZE;
  532. nfs_send();
  533. }
  534. break;
  535. case STATE_READLINK_REQ:
  536. reply = nfs_readlink_reply(pkt, len);
  537. if (reply == -NFS_RPC_DROP) {
  538. break;
  539. } else if (reply == -NFS_RPC_ERR) {
  540. puts("*** ERROR: Symlink fail\n");
  541. nfs_state = STATE_UMOUNT_REQ;
  542. nfs_send();
  543. } else {
  544. debug("Symlink --> %s\n", nfs_path);
  545. nfs_filename = basename(nfs_path);
  546. nfs_path = dirname(nfs_path);
  547. nfs_state = STATE_MOUNT_REQ;
  548. nfs_send();
  549. }
  550. break;
  551. case STATE_READ_REQ:
  552. rlen = nfs_read_reply(pkt, len);
  553. net_set_timeout_handler(nfs_timeout, nfs_timeout_handler);
  554. if (rlen > 0) {
  555. nfs_offset += rlen;
  556. nfs_send();
  557. } else if ((rlen == -NFSERR_ISDIR) || (rlen == -NFSERR_INVAL)) {
  558. /* symbolic link */
  559. nfs_state = STATE_READLINK_REQ;
  560. nfs_send();
  561. } else {
  562. if (!rlen)
  563. nfs_download_state = NETLOOP_SUCCESS;
  564. nfs_state = STATE_UMOUNT_REQ;
  565. nfs_send();
  566. }
  567. break;
  568. }
  569. }
  570. void nfs_start(void)
  571. {
  572. debug("%s\n", __func__);
  573. nfs_download_state = NETLOOP_FAIL;
  574. nfs_server_ip = net_server_ip;
  575. nfs_path = (char *)nfs_path_buff;
  576. if (nfs_path == NULL) {
  577. net_set_state(NETLOOP_FAIL);
  578. puts("*** ERROR: Fail allocate memory\n");
  579. return;
  580. }
  581. if (net_boot_file_name[0] == '\0') {
  582. sprintf(default_filename, "/nfsroot/%02X%02X%02X%02X.img",
  583. net_ip.s_addr & 0xFF,
  584. (net_ip.s_addr >> 8) & 0xFF,
  585. (net_ip.s_addr >> 16) & 0xFF,
  586. (net_ip.s_addr >> 24) & 0xFF);
  587. strcpy(nfs_path, default_filename);
  588. printf("*** Warning: no boot file name; using '%s'\n",
  589. nfs_path);
  590. } else {
  591. char *p = net_boot_file_name;
  592. p = strchr(p, ':');
  593. if (p != NULL) {
  594. nfs_server_ip = string_to_ip(net_boot_file_name);
  595. ++p;
  596. strcpy(nfs_path, p);
  597. } else {
  598. strcpy(nfs_path, net_boot_file_name);
  599. }
  600. }
  601. nfs_filename = basename(nfs_path);
  602. nfs_path = dirname(nfs_path);
  603. printf("Using %s device\n", eth_get_name());
  604. printf("File transfer via NFS from server %pI4; our IP address is %pI4",
  605. &nfs_server_ip, &net_ip);
  606. /* Check if we need to send across this subnet */
  607. if (net_gateway.s_addr && net_netmask.s_addr) {
  608. struct in_addr our_net;
  609. struct in_addr server_net;
  610. our_net.s_addr = net_ip.s_addr & net_netmask.s_addr;
  611. server_net.s_addr = net_server_ip.s_addr & net_netmask.s_addr;
  612. if (our_net.s_addr != server_net.s_addr)
  613. printf("; sending through gateway %pI4",
  614. &net_gateway);
  615. }
  616. printf("\nFilename '%s/%s'.", nfs_path, nfs_filename);
  617. if (net_boot_file_expected_size_in_blocks) {
  618. printf(" Size is 0x%x Bytes = ",
  619. net_boot_file_expected_size_in_blocks << 9);
  620. print_size(net_boot_file_expected_size_in_blocks << 9, "");
  621. }
  622. printf("\nLoad address: 0x%lx\n"
  623. "Loading: *\b", load_addr);
  624. net_set_timeout_handler(nfs_timeout, nfs_timeout_handler);
  625. net_set_udp_handler(nfs_handler);
  626. nfs_timeout_count = 0;
  627. nfs_state = STATE_PRCLOOKUP_PROG_MOUNT_REQ;
  628. /*nfs_our_port = 4096 + (get_ticks() % 3072);*/
  629. /*FIX ME !!!*/
  630. nfs_our_port = 1000;
  631. /* zero out server ether in case the server ip has changed */
  632. memset(net_server_ethaddr, 0, 6);
  633. nfs_send();
  634. }