]> git.ipfire.org Git - thirdparty/u-boot.git/blob - net/nfs.c
projects / thirdparty / u-boot.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
rockchip: Add initial support for the Pinebook Pro laptop from Pine64.
[thirdparty/u-boot.git] / net / nfs.c
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
8 /* NOTE: the NFS code is heavily inspired by the NetBSD netboot code (read:
9 * large portions are copied verbatim) as distributed in OSKit 0.97. A few
10 * changes were necessary to adapt the code to Etherboot and to fix several
11 * inconsistencies. Also the RPC message preparation is done "by hand" to
12 * avoid adding netsprintf() which I find hard to understand and use. */
13
14 /* NOTE 2: Etherboot does not care about things beyond the kernel image, so
15 * it loads the kernel image off the boot server (ARP_SERVER) and does not
16 * access the client root disk (root-path in dhcpd.conf), which would use
17 * ARP_ROOTSERVER. The root disk is something the operating system we are
18 * about to load needs to use. This is different from the OSKit 0.97 logic. */
19
20 /* NOTE 3: Symlink handling introduced by Anselm M Hoffmeister, 2003-July-14
21 * If a symlink is encountered, it is followed as far as possible (recursion
22 * possible, maximum 16 steps). There is no clearing of ".."'s inside the
23 * path, so please DON'T DO THAT. thx. */
24
25 /* NOTE 4: NFSv3 support added by Guillaume GARDET, 2016-June-20.
26 * NFSv2 is still used by default. But if server does not support NFSv2, then
27 * NFSv3 is used, if available on NFS server. */
28
29 #include <common.h>
30 #include <command.h>
31 #include <flash.h>
32 #include <image.h>
33 #include <log.h>
34 #include <net.h>
35 #include <malloc.h>
36 #include <mapmem.h>
37 #include "nfs.h"
38 #include "bootp.h"
39 #include <time.h>
40
41 #define HASHES_PER_LINE 65 /* Number of "loading" hashes per line */
42 #define NFS_RETRY_COUNT 30
43 #ifndef CONFIG_NFS_TIMEOUT
44 # define NFS_TIMEOUT 2000UL
45 #else
46 # define NFS_TIMEOUT CONFIG_NFS_TIMEOUT
47 #endif
48
49 #define NFS_RPC_ERR 1
50 #define NFS_RPC_DROP 124
51
52 static int fs_mounted;
53 static unsigned long rpc_id;
54 static int nfs_offset = -1;
55 static int nfs_len;
56 static ulong nfs_timeout = NFS_TIMEOUT;
57
58 static char dirfh[NFS_FHSIZE]; /* NFSv2 / NFSv3 file handle of directory */
59 static char filefh[NFS3_FHSIZE]; /* NFSv2 / NFSv3 file handle */
60 static int filefh3_length; /* (variable) length of filefh when NFSv3 */
61
62 static enum net_loop_state nfs_download_state;
63 static struct in_addr nfs_server_ip;
64 static int nfs_server_mount_port;
65 static int nfs_server_port;
66 static int nfs_our_port;
67 static int nfs_timeout_count;
68 static int nfs_state;
69 #define STATE_PRCLOOKUP_PROG_MOUNT_REQ 1
70 #define STATE_PRCLOOKUP_PROG_NFS_REQ 2
71 #define STATE_MOUNT_REQ 3
72 #define STATE_UMOUNT_REQ 4
73 #define STATE_LOOKUP_REQ 5
74 #define STATE_READ_REQ 6
75 #define STATE_READLINK_REQ 7
76
77 static char *nfs_filename;
78 static char *nfs_path;
79 static char nfs_path_buff[2048];
80
81 #define NFSV2_FLAG 1
82 #define NFSV3_FLAG 1 << 1
83 static char supported_nfs_versions = NFSV2_FLAG | NFSV3_FLAG;
84
85 static inline int store_block(uchar *src, unsigned offset, unsigned len)
86 {
87 ulong newsize = offset + len;
88 #ifdef CONFIG_SYS_DIRECT_FLASH_NFS
89 int i, rc = 0;
90
91 for (i = 0; i < CONFIG_SYS_MAX_FLASH_BANKS; i++) {
92 /* start address in flash? */
93 if (image_load_addr + offset >= flash_info[i].start[0]) {
94 rc = 1;
95 break;
96 }
97 }
98
99 if (rc) { /* Flash is destination for this packet */
100 rc = flash_write((uchar *)src, (ulong)image_load_addr + offset,
101 len);
102 if (rc) {
103 flash_perror(rc);
104 return -1;
105 }
106 } else
107 #endif /* CONFIG_SYS_DIRECT_FLASH_NFS */
108 {
109 void *ptr = map_sysmem(image_load_addr + offset, len);
110
111 memcpy(ptr, src, len);
112 unmap_sysmem(ptr);
113 }
114
115 if (net_boot_file_size < (offset + len))
116 net_boot_file_size = newsize;
117 return 0;
118 }
119
120 static char *basename(char *path)
121 {
122 char *fname;
123
124 fname = path + strlen(path) - 1;
125 while (fname >= path) {
126 if (*fname == '/') {
127 fname++;
128 break;
129 }
130 fname--;
131 }
132 return fname;
133 }
134
135 static char *dirname(char *path)
136 {
137 char *fname;
138
139 fname = basename(path);
140 --fname;
141 *fname = '\0';
142 return path;
143 }
144
145 /**************************************************************************
146 RPC_ADD_CREDENTIALS - Add RPC authentication/verifier entries
147 **************************************************************************/
148 static uint32_t *rpc_add_credentials(uint32_t *p)
149 {
150 /* Here's the executive summary on authentication requirements of the
151 * various NFS server implementations: Linux accepts both AUTH_NONE
152 * and AUTH_UNIX authentication (also accepts an empty hostname field
153 * in the AUTH_UNIX scheme). *BSD refuses AUTH_NONE, but accepts
154 * AUTH_UNIX (also accepts an empty hostname field in the AUTH_UNIX
155 * scheme). To be safe, use AUTH_UNIX and pass the hostname if we have
156 * it (if the BOOTP/DHCP reply didn't give one, just use an empty
157 * hostname). */
158
159 /* Provide an AUTH_UNIX credential. */
160 *p++ = htonl(1); /* AUTH_UNIX */
161 *p++ = htonl(20); /* auth length */
162 *p++ = 0; /* stamp */
163 *p++ = 0; /* hostname string */
164 *p++ = 0; /* uid */
165 *p++ = 0; /* gid */
166 *p++ = 0; /* auxiliary gid list */
167
168 /* Provide an AUTH_NONE verifier. */
169 *p++ = 0; /* AUTH_NONE */
170 *p++ = 0; /* auth length */
171
172 return p;
173 }
174
175 /**************************************************************************
176 RPC_LOOKUP - Lookup RPC Port numbers
177 **************************************************************************/
178 static void rpc_req(int rpc_prog, int rpc_proc, uint32_t *data, int datalen)
179 {
180 struct rpc_t rpc_pkt;
181 unsigned long id;
182 uint32_t *p;
183 int pktlen;
184 int sport;
185
186 id = ++rpc_id;
187 rpc_pkt.u.call.id = htonl(id);
188 rpc_pkt.u.call.type = htonl(MSG_CALL);
189 rpc_pkt.u.call.rpcvers = htonl(2); /* use RPC version 2 */
190 rpc_pkt.u.call.prog = htonl(rpc_prog);
191 switch (rpc_prog) {
192 case PROG_NFS:
193 if (supported_nfs_versions & NFSV2_FLAG)
194 rpc_pkt.u.call.vers = htonl(2); /* NFS v2 */
195 else /* NFSV3_FLAG */
196 rpc_pkt.u.call.vers = htonl(3); /* NFS v3 */
197 break;
198 case PROG_PORTMAP:
199 case PROG_MOUNT:
200 default:
201 rpc_pkt.u.call.vers = htonl(2); /* portmapper is version 2 */
202 }
203 rpc_pkt.u.call.proc = htonl(rpc_proc);
204 p = rpc_pkt.u.call.data;
205
206 if (datalen)
207 memcpy(p, data, datalen * sizeof(uint32_t));
208
209 pktlen = (char *)p + datalen * sizeof(uint32_t) - (char *)&rpc_pkt;
210
211 memcpy((char *)net_tx_packet + net_eth_hdr_size() + IP_UDP_HDR_SIZE,
212 &rpc_pkt.u.data[0], pktlen);
213
214 if (rpc_prog == PROG_PORTMAP)
215 sport = SUNRPC_PORT;
216 else if (rpc_prog == PROG_MOUNT)
217 sport = nfs_server_mount_port;
218 else
219 sport = nfs_server_port;
220
221 net_send_udp_packet(net_server_ethaddr, nfs_server_ip, sport,
222 nfs_our_port, pktlen);
223 }
224
225 /**************************************************************************
226 RPC_LOOKUP - Lookup RPC Port numbers
227 **************************************************************************/
228 static void rpc_lookup_req(int prog, int ver)
229 {
230 uint32_t data[16];
231
232 data[0] = 0; data[1] = 0; /* auth credential */
233 data[2] = 0; data[3] = 0; /* auth verifier */
234 data[4] = htonl(prog);
235 data[5] = htonl(ver);
236 data[6] = htonl(17); /* IP_UDP */
237 data[7] = 0;
238 rpc_req(PROG_PORTMAP, PORTMAP_GETPORT, data, 8);
239 }
240
241 /**************************************************************************
242 NFS_MOUNT - Mount an NFS Filesystem
243 **************************************************************************/
244 static void nfs_mount_req(char *path)
245 {
246 uint32_t data[1024];
247 uint32_t *p;
248 int len;
249 int pathlen;
250
251 pathlen = strlen(path);
252
253 p = &(data[0]);
254 p = rpc_add_credentials(p);
255
256 *p++ = htonl(pathlen);
257 if (pathlen & 3)
258 *(p + pathlen / 4) = 0;
259 memcpy(p, path, pathlen);
260 p += (pathlen + 3) / 4;
261
262 len = (uint32_t *)p - (uint32_t *)&(data[0]);
263
264 rpc_req(PROG_MOUNT, MOUNT_ADDENTRY, data, len);
265 }
266
267 /**************************************************************************
268 NFS_UMOUNTALL - Unmount all our NFS Filesystems on the Server
269 **************************************************************************/
270 static void nfs_umountall_req(void)
271 {
272 uint32_t data[1024];
273 uint32_t *p;
274 int len;
275
276 if ((nfs_server_mount_port == -1) || (!fs_mounted))
277 /* Nothing mounted, nothing to umount */
278 return;
279
280 p = &(data[0]);
281 p = rpc_add_credentials(p);
282
283 len = (uint32_t *)p - (uint32_t *)&(data[0]);
284
285 rpc_req(PROG_MOUNT, MOUNT_UMOUNTALL, data, len);
286 }
287
288 /***************************************************************************
289 * NFS_READLINK (AH 2003-07-14)
290 * This procedure is called when read of the first block fails -
291 * this probably happens when it's a directory or a symlink
292 * In case of successful readlink(), the dirname is manipulated,
293 * so that inside the nfs() function a recursion can be done.
294 **************************************************************************/
295 static void nfs_readlink_req(void)
296 {
297 uint32_t data[1024];
298 uint32_t *p;
299 int len;
300
301 p = &(data[0]);
302 p = rpc_add_credentials(p);
303
304 if (supported_nfs_versions & NFSV2_FLAG) {
305 memcpy(p, filefh, NFS_FHSIZE);
306 p += (NFS_FHSIZE / 4);
307 } else { /* NFSV3_FLAG */
308 *p++ = htonl(filefh3_length);
309 memcpy(p, filefh, filefh3_length);
310 p += (filefh3_length / 4);
311 }
312
313 len = (uint32_t *)p - (uint32_t *)&(data[0]);
314
315 rpc_req(PROG_NFS, NFS_READLINK, data, len);
316 }
317
318 /**************************************************************************
319 NFS_LOOKUP - Lookup Pathname
320 **************************************************************************/
321 static void nfs_lookup_req(char *fname)
322 {
323 uint32_t data[1024];
324 uint32_t *p;
325 int len;
326 int fnamelen;
327
328 fnamelen = strlen(fname);
329
330 p = &(data[0]);
331 p = rpc_add_credentials(p);
332
333 if (supported_nfs_versions & NFSV2_FLAG) {
334 memcpy(p, dirfh, NFS_FHSIZE);
335 p += (NFS_FHSIZE / 4);
336 *p++ = htonl(fnamelen);
337 if (fnamelen & 3)
338 *(p + fnamelen / 4) = 0;
339 memcpy(p, fname, fnamelen);
340 p += (fnamelen + 3) / 4;
341
342 len = (uint32_t *)p - (uint32_t *)&(data[0]);
343
344 rpc_req(PROG_NFS, NFS_LOOKUP, data, len);
345 } else { /* NFSV3_FLAG */
346 *p++ = htonl(NFS_FHSIZE); /* Dir handle length */
347 memcpy(p, dirfh, NFS_FHSIZE);
348 p += (NFS_FHSIZE / 4);
349 *p++ = htonl(fnamelen);
350 if (fnamelen & 3)
351 *(p + fnamelen / 4) = 0;
352 memcpy(p, fname, fnamelen);
353 p += (fnamelen + 3) / 4;
354
355 len = (uint32_t *)p - (uint32_t *)&(data[0]);
356
357 rpc_req(PROG_NFS, NFS3PROC_LOOKUP, data, len);
358 }
359 }
360
361 /**************************************************************************
362 NFS_READ - Read File on NFS Server
363 **************************************************************************/
364 static void nfs_read_req(int offset, int readlen)
365 {
366 uint32_t data[1024];
367 uint32_t *p;
368 int len;
369
370 p = &(data[0]);
371 p = rpc_add_credentials(p);
372
373 if (supported_nfs_versions & NFSV2_FLAG) {
374 memcpy(p, filefh, NFS_FHSIZE);
375 p += (NFS_FHSIZE / 4);
376 *p++ = htonl(offset);
377 *p++ = htonl(readlen);
378 *p++ = 0;
379 } else { /* NFSV3_FLAG */
380 *p++ = htonl(filefh3_length);
381 memcpy(p, filefh, filefh3_length);
382 p += (filefh3_length / 4);
383 *p++ = htonl(0); /* offset is 64-bit long, so fill with 0 */
384 *p++ = htonl(offset);
385 *p++ = htonl(readlen);
386 *p++ = 0;
387 }
388
389 len = (uint32_t *)p - (uint32_t *)&(data[0]);
390
391 rpc_req(PROG_NFS, NFS_READ, data, len);
392 }
393
394 /**************************************************************************
395 RPC request dispatcher
396 **************************************************************************/
397 static void nfs_send(void)
398 {
399 debug("%s\n", __func__);
400
401 switch (nfs_state) {
402 case STATE_PRCLOOKUP_PROG_MOUNT_REQ:
403 if (supported_nfs_versions & NFSV2_FLAG)
404 rpc_lookup_req(PROG_MOUNT, 1);
405 else /* NFSV3_FLAG */
406 rpc_lookup_req(PROG_MOUNT, 3);
407 break;
408 case STATE_PRCLOOKUP_PROG_NFS_REQ:
409 if (supported_nfs_versions & NFSV2_FLAG)
410 rpc_lookup_req(PROG_NFS, 2);
411 else /* NFSV3_FLAG */
412 rpc_lookup_req(PROG_NFS, 3);
413 break;
414 case STATE_MOUNT_REQ:
415 nfs_mount_req(nfs_path);
416 break;
417 case STATE_UMOUNT_REQ:
418 nfs_umountall_req();
419 break;
420 case STATE_LOOKUP_REQ:
421 nfs_lookup_req(nfs_filename);
422 break;
423 case STATE_READ_REQ:
424 nfs_read_req(nfs_offset, nfs_len);
425 break;
426 case STATE_READLINK_REQ:
427 nfs_readlink_req();
428 break;
429 }
430 }
431
432 /**************************************************************************
433 Handlers for the reply from server
434 **************************************************************************/
435
436 static int rpc_lookup_reply(int prog, uchar *pkt, unsigned len)
437 {
438 struct rpc_t rpc_pkt;
439
440 memcpy(&rpc_pkt.u.data[0], pkt, len);
441
442 debug("%s\n", __func__);
443
444 if (ntohl(rpc_pkt.u.reply.id) > rpc_id)
445 return -NFS_RPC_ERR;
446 else if (ntohl(rpc_pkt.u.reply.id) < rpc_id)
447 return -NFS_RPC_DROP;
448
449 if (rpc_pkt.u.reply.rstatus ||
450 rpc_pkt.u.reply.verifier ||
451 rpc_pkt.u.reply.astatus)
452 return -1;
453
454 switch (prog) {
455 case PROG_MOUNT:
456 nfs_server_mount_port = ntohl(rpc_pkt.u.reply.data[0]);
457 break;
458 case PROG_NFS:
459 nfs_server_port = ntohl(rpc_pkt.u.reply.data[0]);
460 break;
461 }
462
463 return 0;
464 }
465
466 static int nfs_mount_reply(uchar *pkt, unsigned len)
467 {
468 struct rpc_t rpc_pkt;
469
470 debug("%s\n", __func__);
471
472 memcpy(&rpc_pkt.u.data[0], pkt, len);
473
474 if (ntohl(rpc_pkt.u.reply.id) > rpc_id)
475 return -NFS_RPC_ERR;
476 else if (ntohl(rpc_pkt.u.reply.id) < rpc_id)
477 return -NFS_RPC_DROP;
478
479 if (rpc_pkt.u.reply.rstatus ||
480 rpc_pkt.u.reply.verifier ||
481 rpc_pkt.u.reply.astatus ||
482 rpc_pkt.u.reply.data[0])
483 return -1;
484
485 fs_mounted = 1;
486 /* NFSv2 and NFSv3 use same structure */
487 memcpy(dirfh, rpc_pkt.u.reply.data + 1, NFS_FHSIZE);
488
489 return 0;
490 }
491
492 static int nfs_umountall_reply(uchar *pkt, unsigned len)
493 {
494 struct rpc_t rpc_pkt;
495
496 debug("%s\n", __func__);
497
498 memcpy(&rpc_pkt.u.data[0], pkt, len);
499
500 if (ntohl(rpc_pkt.u.reply.id) > rpc_id)
501 return -NFS_RPC_ERR;
502 else if (ntohl(rpc_pkt.u.reply.id) < rpc_id)
503 return -NFS_RPC_DROP;
504
505 if (rpc_pkt.u.reply.rstatus ||
506 rpc_pkt.u.reply.verifier ||
507 rpc_pkt.u.reply.astatus)
508 return -1;
509
510 fs_mounted = 0;
511 memset(dirfh, 0, sizeof(dirfh));
512
513 return 0;
514 }
515
516 static int nfs_lookup_reply(uchar *pkt, unsigned len)
517 {
518 struct rpc_t rpc_pkt;
519
520 debug("%s\n", __func__);
521
522 memcpy(&rpc_pkt.u.data[0], pkt, len);
523
524 if (ntohl(rpc_pkt.u.reply.id) > rpc_id)
525 return -NFS_RPC_ERR;
526 else if (ntohl(rpc_pkt.u.reply.id) < rpc_id)
527 return -NFS_RPC_DROP;
528
529 if (rpc_pkt.u.reply.rstatus ||
530 rpc_pkt.u.reply.verifier ||
531 rpc_pkt.u.reply.astatus ||
532 rpc_pkt.u.reply.data[0]) {
533 switch (ntohl(rpc_pkt.u.reply.astatus)) {
534 case NFS_RPC_SUCCESS: /* Not an error */
535 break;
536 case NFS_RPC_PROG_MISMATCH:
537 /* Remote can't support NFS version */
538 switch (ntohl(rpc_pkt.u.reply.data[0])) {
539 /* Minimal supported NFS version */
540 case 3:
541 debug("*** Warning: NFS version not supported: Requested: V%d, accepted: min V%d - max V%d\n",
542 (supported_nfs_versions & NFSV2_FLAG) ?
543 2 : 3,
544 ntohl(rpc_pkt.u.reply.data[0]),
545 ntohl(rpc_pkt.u.reply.data[1]));
546 debug("Will retry with NFSv3\n");
547 /* Clear NFSV2_FLAG from supported versions */
548 supported_nfs_versions &= ~NFSV2_FLAG;
549 return -NFS_RPC_PROG_MISMATCH;
550 case 4:
551 default:
552 puts("*** ERROR: NFS version not supported");
553 debug(": Requested: V%d, accepted: min V%d - max V%d\n",
554 (supported_nfs_versions & NFSV2_FLAG) ?
555 2 : 3,
556 ntohl(rpc_pkt.u.reply.data[0]),
557 ntohl(rpc_pkt.u.reply.data[1]));
558 puts("\n");
559 }
560 break;
561 case NFS_RPC_PROG_UNAVAIL:
562 case NFS_RPC_PROC_UNAVAIL:
563 case NFS_RPC_GARBAGE_ARGS:
564 case NFS_RPC_SYSTEM_ERR:
565 default: /* Unknown error on 'accept state' flag */
566 debug("*** ERROR: accept state error (%d)\n",
567 ntohl(rpc_pkt.u.reply.astatus));
568 break;
569 }
570 return -1;
571 }
572
573 if (supported_nfs_versions & NFSV2_FLAG) {
574 if (((uchar *)&(rpc_pkt.u.reply.data[0]) - (uchar *)(&rpc_pkt) + NFS_FHSIZE) > len)
575 return -NFS_RPC_DROP;
576 memcpy(filefh, rpc_pkt.u.reply.data + 1, NFS_FHSIZE);
577 } else { /* NFSV3_FLAG */
578 filefh3_length = ntohl(rpc_pkt.u.reply.data[1]);
579 if (filefh3_length > NFS3_FHSIZE)
580 filefh3_length = NFS3_FHSIZE;
581 if (((uchar *)&(rpc_pkt.u.reply.data[0]) - (uchar *)(&rpc_pkt) + filefh3_length) > len)
582 return -NFS_RPC_DROP;
583 memcpy(filefh, rpc_pkt.u.reply.data + 2, filefh3_length);
584 }
585
586 return 0;
587 }
588
589 static int nfs3_get_attributes_offset(uint32_t *data)
590 {
591 if (data[1]) {
592 /* 'attributes_follow' flag is TRUE,
593 * so we have attributes on 21 dwords */
594 /* Skip unused values :
595 type; 32 bits value,
596 mode; 32 bits value,
597 nlink; 32 bits value,
598 uid; 32 bits value,
599 gid; 32 bits value,
600 size; 64 bits value,
601 used; 64 bits value,
602 rdev; 64 bits value,
603 fsid; 64 bits value,
604 fileid; 64 bits value,
605 atime; 64 bits value,
606 mtime; 64 bits value,
607 ctime; 64 bits value,
608 */
609 return 22;
610 } else {
611 /* 'attributes_follow' flag is FALSE,
612 * so we don't have any attributes */
613 return 1;
614 }
615 }
616
617 static int nfs_readlink_reply(uchar *pkt, unsigned len)
618 {
619 struct rpc_t rpc_pkt;
620 int rlen;
621 int nfsv3_data_offset = 0;
622
623 debug("%s\n", __func__);
624
625 memcpy((unsigned char *)&rpc_pkt, pkt, len);
626
627 if (ntohl(rpc_pkt.u.reply.id) > rpc_id)
628 return -NFS_RPC_ERR;
629 else if (ntohl(rpc_pkt.u.reply.id) < rpc_id)
630 return -NFS_RPC_DROP;
631
632 if (rpc_pkt.u.reply.rstatus ||
633 rpc_pkt.u.reply.verifier ||
634 rpc_pkt.u.reply.astatus ||
635 rpc_pkt.u.reply.data[0])
636 return -1;
637
638 if (!(supported_nfs_versions & NFSV2_FLAG)) { /* NFSV3_FLAG */
639 nfsv3_data_offset =
640 nfs3_get_attributes_offset(rpc_pkt.u.reply.data);
641 }
642
643 /* new path length */
644 rlen = ntohl(rpc_pkt.u.reply.data[1 + nfsv3_data_offset]);
645
646 if (((uchar *)&(rpc_pkt.u.reply.data[0]) - (uchar *)(&rpc_pkt) + rlen) > len)
647 return -NFS_RPC_DROP;
648
649 if (*((char *)&(rpc_pkt.u.reply.data[2 + nfsv3_data_offset])) != '/') {
650 int pathlen;
651
652 strcat(nfs_path, "/");
653 pathlen = strlen(nfs_path);
654 memcpy(nfs_path + pathlen,
655 (uchar *)&(rpc_pkt.u.reply.data[2 + nfsv3_data_offset]),
656 rlen);
657 nfs_path[pathlen + rlen] = 0;
658 } else {
659 memcpy(nfs_path,
660 (uchar *)&(rpc_pkt.u.reply.data[2 + nfsv3_data_offset]),
661 rlen);
662 nfs_path[rlen] = 0;
663 }
664 return 0;
665 }
666
667 static int nfs_read_reply(uchar *pkt, unsigned len)
668 {
669 struct rpc_t rpc_pkt;
670 int rlen;
671 uchar *data_ptr;
672
673 debug("%s\n", __func__);
674
675 memcpy(&rpc_pkt.u.data[0], pkt, sizeof(rpc_pkt.u.reply));
676
677 if (ntohl(rpc_pkt.u.reply.id) > rpc_id)
678 return -NFS_RPC_ERR;
679 else if (ntohl(rpc_pkt.u.reply.id) < rpc_id)
680 return -NFS_RPC_DROP;
681
682 if (rpc_pkt.u.reply.rstatus ||
683 rpc_pkt.u.reply.verifier ||
684 rpc_pkt.u.reply.astatus ||
685 rpc_pkt.u.reply.data[0]) {
686 if (rpc_pkt.u.reply.rstatus)
687 return -9999;
688 if (rpc_pkt.u.reply.astatus)
689 return -9999;
690 return -ntohl(rpc_pkt.u.reply.data[0]);
691 }
692
693 if ((nfs_offset != 0) && !((nfs_offset) %
694 (NFS_READ_SIZE / 2 * 10 * HASHES_PER_LINE)))
695 puts("\n\t ");
696 if (!(nfs_offset % ((NFS_READ_SIZE / 2) * 10)))
697 putc('#');
698
699 if (supported_nfs_versions & NFSV2_FLAG) {
700 rlen = ntohl(rpc_pkt.u.reply.data[18]);
701 data_ptr = (uchar *)&(rpc_pkt.u.reply.data[19]);
702 } else { /* NFSV3_FLAG */
703 int nfsv3_data_offset =
704 nfs3_get_attributes_offset(rpc_pkt.u.reply.data);
705
706 /* count value */
707 rlen = ntohl(rpc_pkt.u.reply.data[1 + nfsv3_data_offset]);
708 /* Skip unused values :
709 EOF: 32 bits value,
710 data_size: 32 bits value,
711 */
712 data_ptr = (uchar *)
713 &(rpc_pkt.u.reply.data[4 + nfsv3_data_offset]);
714 }
715
716 if (((uchar *)&(rpc_pkt.u.reply.data[0]) - (uchar *)(&rpc_pkt) + rlen) > len)
717 return -9999;
718
719 if (store_block(data_ptr, nfs_offset, rlen))
720 return -9999;
721
722 return rlen;
723 }
724
725 /**************************************************************************
726 Interfaces of U-BOOT
727 **************************************************************************/
728 static void nfs_timeout_handler(void)
729 {
730 if (++nfs_timeout_count > NFS_RETRY_COUNT) {
731 puts("\nRetry count exceeded; starting again\n");
732 net_start_again();
733 } else {
734 puts("T ");
735 net_set_timeout_handler(nfs_timeout +
736 NFS_TIMEOUT * nfs_timeout_count,
737 nfs_timeout_handler);
738 nfs_send();
739 }
740 }
741
742 static void nfs_handler(uchar *pkt, unsigned dest, struct in_addr sip,
743 unsigned src, unsigned len)
744 {
745 int rlen;
746 int reply;
747
748 debug("%s\n", __func__);
749
750 if (len > sizeof(struct rpc_t))
751 return;
752
753 if (dest != nfs_our_port)
754 return;
755
756 switch (nfs_state) {
757 case STATE_PRCLOOKUP_PROG_MOUNT_REQ:
758 if (rpc_lookup_reply(PROG_MOUNT, pkt, len) == -NFS_RPC_DROP)
759 break;
760 nfs_state = STATE_PRCLOOKUP_PROG_NFS_REQ;
761 nfs_send();
762 break;
763
764 case STATE_PRCLOOKUP_PROG_NFS_REQ:
765 if (rpc_lookup_reply(PROG_NFS, pkt, len) == -NFS_RPC_DROP)
766 break;
767 nfs_state = STATE_MOUNT_REQ;
768 nfs_send();
769 break;
770
771 case STATE_MOUNT_REQ:
772 reply = nfs_mount_reply(pkt, len);
773 if (reply == -NFS_RPC_DROP) {
774 break;
775 } else if (reply == -NFS_RPC_ERR) {
776 puts("*** ERROR: Cannot mount\n");
777 /* just to be sure... */
778 nfs_state = STATE_UMOUNT_REQ;
779 nfs_send();
780 } else {
781 nfs_state = STATE_LOOKUP_REQ;
782 nfs_send();
783 }
784 break;
785
786 case STATE_UMOUNT_REQ:
787 reply = nfs_umountall_reply(pkt, len);
788 if (reply == -NFS_RPC_DROP) {
789 break;
790 } else if (reply == -NFS_RPC_ERR) {
791 debug("*** ERROR: Cannot umount\n");
792 net_set_state(NETLOOP_FAIL);
793 } else {
794 puts("\ndone\n");
795 net_set_state(nfs_download_state);
796 }
797 break;
798
799 case STATE_LOOKUP_REQ:
800 reply = nfs_lookup_reply(pkt, len);
801 if (reply == -NFS_RPC_DROP) {
802 break;
803 } else if (reply == -NFS_RPC_ERR) {
804 puts("*** ERROR: File lookup fail\n");
805 nfs_state = STATE_UMOUNT_REQ;
806 nfs_send();
807 } else if (reply == -NFS_RPC_PROG_MISMATCH &&
808 supported_nfs_versions != 0) {
809 /* umount */
810 nfs_state = STATE_UMOUNT_REQ;
811 nfs_send();
812 /* And retry with another supported version */
813 nfs_state = STATE_PRCLOOKUP_PROG_MOUNT_REQ;
814 nfs_send();
815 } else {
816 nfs_state = STATE_READ_REQ;
817 nfs_offset = 0;
818 nfs_len = NFS_READ_SIZE;
819 nfs_send();
820 }
821 break;
822
823 case STATE_READLINK_REQ:
824 reply = nfs_readlink_reply(pkt, len);
825 if (reply == -NFS_RPC_DROP) {
826 break;
827 } else if (reply == -NFS_RPC_ERR) {
828 puts("*** ERROR: Symlink fail\n");
829 nfs_state = STATE_UMOUNT_REQ;
830 nfs_send();
831 } else {
832 debug("Symlink --> %s\n", nfs_path);
833 nfs_filename = basename(nfs_path);
834 nfs_path = dirname(nfs_path);
835
836 nfs_state = STATE_MOUNT_REQ;
837 nfs_send();
838 }
839 break;
840
841 case STATE_READ_REQ:
842 rlen = nfs_read_reply(pkt, len);
843 if (rlen == -NFS_RPC_DROP)
844 break;
845 net_set_timeout_handler(nfs_timeout, nfs_timeout_handler);
846 if (rlen > 0) {
847 nfs_offset += rlen;
848 nfs_send();
849 } else if ((rlen == -NFSERR_ISDIR) || (rlen == -NFSERR_INVAL)) {
850 /* symbolic link */
851 nfs_state = STATE_READLINK_REQ;
852 nfs_send();
853 } else {
854 if (!rlen)
855 nfs_download_state = NETLOOP_SUCCESS;
856 if (rlen < 0)
857 debug("NFS READ error (%d)\n", rlen);
858 nfs_state = STATE_UMOUNT_REQ;
859 nfs_send();
860 }
861 break;
862 }
863 }
864
865
866 void nfs_start(void)
867 {
868 debug("%s\n", __func__);
869 nfs_download_state = NETLOOP_FAIL;
870
871 nfs_server_ip = net_server_ip;
872 nfs_path = (char *)nfs_path_buff;
873
874 if (nfs_path == NULL) {
875 net_set_state(NETLOOP_FAIL);
876 printf("*** ERROR: Fail allocate memory\n");
877 return;
878 }
879
880 if (!net_parse_bootfile(&nfs_server_ip, nfs_path,
881 sizeof(nfs_path_buff))) {
882 sprintf(nfs_path, "/nfsroot/%02X%02X%02X%02X.img",
883 net_ip.s_addr & 0xFF,
884 (net_ip.s_addr >> 8) & 0xFF,
885 (net_ip.s_addr >> 16) & 0xFF,
886 (net_ip.s_addr >> 24) & 0xFF);
887
888 printf("*** Warning: no boot file name; using '%s'\n",
889 nfs_path);
890 }
891
892 nfs_filename = basename(nfs_path);
893 nfs_path = dirname(nfs_path);
894
895 printf("Using %s device\n", eth_get_name());
896
897 printf("File transfer via NFS from server %pI4; our IP address is %pI4",
898 &nfs_server_ip, &net_ip);
899
900 /* Check if we need to send across this subnet */
901 if (net_gateway.s_addr && net_netmask.s_addr) {
902 struct in_addr our_net;
903 struct in_addr server_net;
904
905 our_net.s_addr = net_ip.s_addr & net_netmask.s_addr;
906 server_net.s_addr = nfs_server_ip.s_addr & net_netmask.s_addr;
907 if (our_net.s_addr != server_net.s_addr)
908 printf("; sending through gateway %pI4",
909 &net_gateway);
910 }
911 printf("\nFilename '%s/%s'.", nfs_path, nfs_filename);
912
913 if (net_boot_file_expected_size_in_blocks) {
914 printf(" Size is 0x%x Bytes = ",
915 net_boot_file_expected_size_in_blocks << 9);
916 print_size(net_boot_file_expected_size_in_blocks << 9, "");
917 }
918 printf("\nLoad address: 0x%lx\nLoading: *\b", image_load_addr);
919
920 net_set_timeout_handler(nfs_timeout, nfs_timeout_handler);
921 net_set_udp_handler(nfs_handler);
922
923 nfs_timeout_count = 0;
924 nfs_state = STATE_PRCLOOKUP_PROG_MOUNT_REQ;
925
926 /*nfs_our_port = 4096 + (get_ticks() % 3072);*/
927 /*FIX ME !!!*/
928 nfs_our_port = 1000;
929
930 /* zero out server ether in case the server ip has changed */
931 memset(net_server_ethaddr, 0, 6);
932
933 nfs_send();
934 }
"Das U-Boot" Source Tree