Annotation of sys/nfs/nfs_boot.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: nfs_boot.c,v 1.18 2006/06/17 14:14:12 henning Exp $ */
! 2: /* $NetBSD: nfs_boot.c,v 1.26 1996/05/07 02:51:25 thorpej Exp $ */
! 3:
! 4: /*
! 5: * Copyright (c) 1995 Adam Glass, Gordon Ross
! 6: * All rights reserved.
! 7: *
! 8: * Redistribution and use in source and binary forms, with or without
! 9: * modification, are permitted provided that the following conditions
! 10: * are met:
! 11: * 1. Redistributions of source code must retain the above copyright
! 12: * notice, this list of conditions and the following disclaimer.
! 13: * 2. Redistributions in binary form must reproduce the above copyright
! 14: * notice, this list of conditions and the following disclaimer in the
! 15: * documentation and/or other materials provided with the distribution.
! 16: * 3. The name of the authors may not be used to endorse or promote products
! 17: * derived from this software without specific prior written permission.
! 18: *
! 19: * THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR
! 20: * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
! 21: * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
! 22: * IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY DIRECT, INDIRECT,
! 23: * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
! 24: * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
! 25: * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
! 26: * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
! 27: * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
! 28: * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
! 29: */
! 30:
! 31: #include <sys/param.h>
! 32: #include <sys/systm.h>
! 33: #include <sys/kernel.h>
! 34: #include <sys/conf.h>
! 35: #include <sys/ioctl.h>
! 36: #include <sys/proc.h>
! 37: #include <sys/mount.h>
! 38: #include <sys/mbuf.h>
! 39: #include <sys/reboot.h>
! 40: #include <sys/socket.h>
! 41: #include <sys/socketvar.h>
! 42:
! 43: #include <net/if.h>
! 44: #include <net/route.h>
! 45:
! 46: #include <netinet/in.h>
! 47: #include <netinet/if_ether.h>
! 48:
! 49: #include <nfs/rpcv2.h>
! 50: #include <nfs/nfsproto.h>
! 51: #include <nfs/nfs.h>
! 52: #include <nfs/nfsdiskless.h>
! 53: #include <nfs/krpc.h>
! 54: #include <nfs/xdr_subs.h>
! 55: #include <nfs/nfs_var.h>
! 56:
! 57: #include "ether.h"
! 58:
! 59: #if !defined(NFSCLIENT) || (NETHER == 0 && NFDDI == 0)
! 60:
! 61: int
! 62: nfs_boot_init(nd, procp)
! 63: struct nfs_diskless *nd;
! 64: struct proc *procp;
! 65: {
! 66: panic("nfs_boot_init: NFSCLIENT not enabled in kernel");
! 67: }
! 68:
! 69: int
! 70: nfs_boot_getfh(bpsin, key, ndmntp, retries)
! 71: struct sockaddr_in *bpsin;
! 72: char *key;
! 73: struct nfs_dlmount *ndmntp;
! 74: int retries;
! 75: {
! 76: /* can not get here */
! 77: return (EOPNOTSUPP);
! 78: }
! 79:
! 80: #else
! 81:
! 82: /*
! 83: * Support for NFS diskless booting, specifically getting information
! 84: * about where to boot from, what pathnames, etc.
! 85: *
! 86: * This implementation uses RARP and the bootparam RPC.
! 87: * We are forced to implement RPC anyway (to get file handles)
! 88: * so we might as well take advantage of it for bootparam too.
! 89: *
! 90: * The diskless boot sequence goes as follows:
! 91: * (1) Use RARP to get our interface address
! 92: * (2) Use RPC/bootparam/whoami to get our hostname,
! 93: * our IP address, and the server's IP address.
! 94: * (3) Use RPC/bootparam/getfile to get the root path
! 95: * (4) Use RPC/mountd to get the root file handle
! 96: * (5) Use RPC/bootparam/getfile to get the swap path
! 97: * (6) Use RPC/mountd to get the swap file handle
! 98: *
! 99: * (This happens to be the way Sun does it too.)
! 100: */
! 101:
! 102: /* bootparam RPC */
! 103: static int bp_whoami(struct sockaddr_in *bpsin,
! 104: struct in_addr *my_ip, struct in_addr *gw_ip);
! 105: static int bp_getfile(struct sockaddr_in *bpsin, char *key,
! 106: struct sockaddr_in *mdsin, char *servname, char *path, int retries);
! 107:
! 108: /* mountd RPC */
! 109: static int md_mount(struct sockaddr_in *mdsin, char *path,
! 110: u_char *fh);
! 111:
! 112: char *nfsbootdevname;
! 113:
! 114: /*
! 115: * Called with an empty nfs_diskless struct to be filled in.
! 116: */
! 117: int
! 118: nfs_boot_init(nd, procp)
! 119: struct nfs_diskless *nd;
! 120: struct proc *procp;
! 121: {
! 122: struct ifreq ireq;
! 123: struct in_addr my_ip, gw_ip;
! 124: struct sockaddr_in bp_sin;
! 125: struct sockaddr_in *sin;
! 126: struct ifnet *ifp;
! 127: struct socket *so;
! 128: int error;
! 129:
! 130: /*
! 131: * Find an interface, rarp for its ip address, stuff it, the
! 132: * implied broadcast addr, and netmask into a nfs_diskless struct.
! 133: *
! 134: * This was moved here from nfs_vfsops.c because this procedure
! 135: * would be quite different if someone decides to write (i.e.) a
! 136: * BOOTP version of this file (might not use RARP, etc.)
! 137: */
! 138:
! 139: /*
! 140: * Find a network interface.
! 141: */
! 142: if (nfsbootdevname)
! 143: ifp = ifunit(nfsbootdevname);
! 144: else {
! 145: for (ifp = TAILQ_FIRST(&ifnet); ifp != NULL;
! 146: ifp = TAILQ_NEXT(ifp, if_list)) {
! 147: if ((ifp->if_flags &
! 148: (IFF_LOOPBACK|IFF_POINTOPOINT)) == 0)
! 149: break;
! 150: }
! 151: }
! 152: if (ifp == NULL)
! 153: panic("nfs_boot: no suitable interface");
! 154: bcopy(ifp->if_xname, ireq.ifr_name, IFNAMSIZ);
! 155: printf("nfs_boot: using interface %s, with revarp & bootparams\n",
! 156: ireq.ifr_name);
! 157:
! 158: /*
! 159: * Bring up the interface.
! 160: *
! 161: * Get the old interface flags and or IFF_UP into them; if
! 162: * IFF_UP set blindly, interface selection can be clobbered.
! 163: */
! 164: if ((error = socreate(AF_INET, &so, SOCK_DGRAM, 0)) != 0)
! 165: panic("nfs_boot: socreate, error=%d", error);
! 166: error = ifioctl(so, SIOCGIFFLAGS, (caddr_t)&ireq, procp);
! 167: if (error)
! 168: panic("nfs_boot: GIFFLAGS, error=%d", error);
! 169: ireq.ifr_flags |= IFF_UP;
! 170: error = ifioctl(so, SIOCSIFFLAGS, (caddr_t)&ireq, procp);
! 171: if (error)
! 172: panic("nfs_boot: SIFFLAGS, error=%d", error);
! 173:
! 174: /*
! 175: * Do RARP for the interface address.
! 176: */
! 177: if ((error = revarpwhoami(&my_ip, ifp)) != 0)
! 178: panic("revarp failed, error=%d", error);
! 179: printf("nfs_boot: client_addr=%s\n", inet_ntoa(my_ip));
! 180:
! 181: /*
! 182: * Do enough of ifconfig(8) so that the chosen interface
! 183: * can talk to the servers. (just set the address)
! 184: */
! 185: sin = (struct sockaddr_in *)&ireq.ifr_addr;
! 186: bzero((caddr_t)sin, sizeof(*sin));
! 187: sin->sin_len = sizeof(*sin);
! 188: sin->sin_family = AF_INET;
! 189: sin->sin_addr.s_addr = my_ip.s_addr;
! 190: error = ifioctl(so, SIOCSIFADDR, (caddr_t)&ireq, procp);
! 191: if (error)
! 192: panic("nfs_boot: set if addr, error=%d", error);
! 193:
! 194: soclose(so);
! 195:
! 196: /*
! 197: * Get client name and gateway address.
! 198: * RPC: bootparam/whoami
! 199: * Use the old broadcast address for the WHOAMI
! 200: * call because we do not yet know our netmask.
! 201: * The server address returned by the WHOAMI call
! 202: * is used for all subsequent booptaram RPCs.
! 203: */
! 204: bzero((caddr_t)&bp_sin, sizeof(bp_sin));
! 205: bp_sin.sin_len = sizeof(bp_sin);
! 206: bp_sin.sin_family = AF_INET;
! 207: bp_sin.sin_addr.s_addr = INADDR_BROADCAST;
! 208: hostnamelen = MAXHOSTNAMELEN;
! 209:
! 210: /* this returns gateway IP address */
! 211: error = bp_whoami(&bp_sin, &my_ip, &gw_ip);
! 212: if (error)
! 213: panic("nfs_boot: bootparam whoami, error=%d", error);
! 214: printf("nfs_boot: server_addr=%s hostname=%s\n",
! 215: inet_ntoa(bp_sin.sin_addr), hostname);
! 216:
! 217: #ifdef NFS_BOOT_GATEWAY
! 218: /*
! 219: * XXX - This code is conditionally compiled only because
! 220: * many bootparam servers (in particular, SunOS 4.1.3)
! 221: * always set the gateway address to their own address.
! 222: * The bootparam server is not necessarily the gateway.
! 223: * We could just believe the server, and at worst you would
! 224: * need to delete the incorrect default route before adding
! 225: * the correct one, but for simplicity, ignore the gateway.
! 226: * If your server is OK, you can turn on this option.
! 227: *
! 228: * If the gateway address is set, add a default route.
! 229: * (The mountd RPCs may go across a gateway.)
! 230: */
! 231: if (gw_ip.s_addr) {
! 232: struct sockaddr dst, gw, mask;
! 233: /* Destination: (default) */
! 234: bzero((caddr_t)&dst, sizeof(dst));
! 235: dst.sa_len = sizeof(dst);
! 236: dst.sa_family = AF_INET;
! 237: /* Gateway: */
! 238: bzero((caddr_t)&gw, sizeof(gw));
! 239: sin = (struct sockaddr_in *)&gw;
! 240: sin->sin_len = sizeof(gw);
! 241: sin->sin_family = AF_INET;
! 242: sin->sin_addr.s_addr = gw_ip.s_addr;
! 243: /* Mask: (zero length) */
! 244: bzero(&mask, sizeof(mask));
! 245:
! 246: printf("nfs_boot: gateway=%s\n", inet_ntoa(gw_ip));
! 247: /* add, dest, gw, mask, flags, 0 */
! 248: error = rtrequest(RTM_ADD, &dst, (struct sockaddr *)&gw,
! 249: &mask, (RTF_UP | RTF_GATEWAY | RTF_STATIC), NULL, 0);
! 250: if (error)
! 251: printf("nfs_boot: add route, error=%d\n", error);
! 252: }
! 253: #endif
! 254:
! 255: bcopy(&bp_sin, &nd->nd_boot, sizeof(bp_sin));
! 256:
! 257: return (0);
! 258: }
! 259:
! 260: int
! 261: nfs_boot_getfh(bpsin, key, ndmntp, retries)
! 262: struct sockaddr_in *bpsin; /* bootparam server */
! 263: char *key; /* root or swap */
! 264: struct nfs_dlmount *ndmntp; /* output */
! 265: int retries;
! 266: {
! 267: char pathname[MAXPATHLEN];
! 268: char *sp, *dp, *endp;
! 269: struct sockaddr_in *sin;
! 270: int error;
! 271:
! 272: sin = &ndmntp->ndm_saddr;
! 273:
! 274: /*
! 275: * Get server:pathname for "key" (root or swap)
! 276: * using RPC to bootparam/getfile
! 277: */
! 278: error = bp_getfile(bpsin, key, sin, ndmntp->ndm_host, pathname,
! 279: retries);
! 280: if (error) {
! 281: printf("nfs_boot: bootparam get %s: %d\n", key, error);
! 282: return (error);
! 283: }
! 284:
! 285: /*
! 286: * Get file handle for "key" (root or swap)
! 287: * using RPC to mountd/mount
! 288: */
! 289: error = md_mount(sin, pathname, ndmntp->ndm_fh);
! 290: if (error) {
! 291: printf("nfs_boot: mountd %s, error=%d\n", key, error);
! 292: return (error);
! 293: }
! 294:
! 295: /* Set port number for NFS use. */
! 296: /* XXX: NFS port is always 2049, right? */
! 297: error = krpc_portmap(sin, NFS_PROG, NFS_VER2, &sin->sin_port);
! 298: if (error) {
! 299: printf("nfs_boot: portmap NFS/v2, error=%d\n", error);
! 300: return (error);
! 301: }
! 302:
! 303: /* Construct remote path (for getmntinfo(3)) */
! 304: dp = ndmntp->ndm_host;
! 305: endp = dp + MNAMELEN - 1;
! 306: dp += strlen(dp);
! 307: *dp++ = ':';
! 308: for (sp = pathname; *sp && dp < endp;)
! 309: *dp++ = *sp++;
! 310: *dp = '\0';
! 311:
! 312: return (0);
! 313: }
! 314:
! 315:
! 316: /*
! 317: * RPC: bootparam/whoami
! 318: * Given client IP address, get:
! 319: * client name (hostname)
! 320: * domain name (domainname)
! 321: * gateway address
! 322: *
! 323: * The hostname and domainname are set here for convenience.
! 324: *
! 325: * Note - bpsin is initialized to the broadcast address,
! 326: * and will be replaced with the bootparam server address
! 327: * after this call is complete. Have to use PMAP_PROC_CALL
! 328: * to make sure we get responses only from a servers that
! 329: * know about us (don't want to broadcast a getport call).
! 330: */
! 331: static int
! 332: bp_whoami(bpsin, my_ip, gw_ip)
! 333: struct sockaddr_in *bpsin;
! 334: struct in_addr *my_ip;
! 335: struct in_addr *gw_ip;
! 336: {
! 337: /* RPC structures for PMAPPROC_CALLIT */
! 338: struct whoami_call {
! 339: u_int32_t call_prog;
! 340: u_int32_t call_vers;
! 341: u_int32_t call_proc;
! 342: u_int32_t call_arglen;
! 343: } *call;
! 344: struct callit_reply {
! 345: u_int32_t port;
! 346: u_int32_t encap_len;
! 347: /* encapsulated data here */
! 348: } *reply;
! 349:
! 350: struct mbuf *m, *from;
! 351: struct sockaddr_in *sin;
! 352: int error, msg_len;
! 353: int16_t port;
! 354:
! 355: /*
! 356: * Build request message for PMAPPROC_CALLIT.
! 357: */
! 358: m = m_get(M_WAIT, MT_DATA);
! 359: call = mtod(m, struct whoami_call *);
! 360: m->m_len = sizeof(*call);
! 361: call->call_prog = txdr_unsigned(BOOTPARAM_PROG);
! 362: call->call_vers = txdr_unsigned(BOOTPARAM_VERS);
! 363: call->call_proc = txdr_unsigned(BOOTPARAM_WHOAMI);
! 364:
! 365: /*
! 366: * append encapsulated data (client IP address)
! 367: */
! 368: m->m_next = xdr_inaddr_encode(my_ip);
! 369: call->call_arglen = txdr_unsigned(m->m_next->m_len);
! 370:
! 371: /* RPC: portmap/callit */
! 372: bpsin->sin_port = htons(PMAPPORT);
! 373: from = NULL;
! 374: error = krpc_call(bpsin, PMAPPROG, PMAPVERS,
! 375: PMAPPROC_CALLIT, &m, &from, -1);
! 376: if (error)
! 377: return error;
! 378:
! 379: /*
! 380: * Parse result message.
! 381: */
! 382: if (m->m_len < sizeof(*reply)) {
! 383: m = m_pullup(m, sizeof(*reply));
! 384: if (m == NULL)
! 385: goto bad;
! 386: }
! 387: reply = mtod(m, struct callit_reply *);
! 388: port = fxdr_unsigned(u_int32_t, reply->port);
! 389: msg_len = fxdr_unsigned(u_int32_t, reply->encap_len);
! 390: m_adj(m, sizeof(*reply));
! 391:
! 392: /*
! 393: * Save bootparam server address
! 394: */
! 395: sin = mtod(from, struct sockaddr_in *);
! 396: bpsin->sin_port = htons(port);
! 397: bpsin->sin_addr.s_addr = sin->sin_addr.s_addr;
! 398:
! 399: /* client name */
! 400: hostnamelen = MAXHOSTNAMELEN-1;
! 401: m = xdr_string_decode(m, hostname, &hostnamelen);
! 402: if (m == NULL)
! 403: goto bad;
! 404:
! 405: /* domain name */
! 406: domainnamelen = MAXHOSTNAMELEN-1;
! 407: m = xdr_string_decode(m, domainname, &domainnamelen);
! 408: if (m == NULL)
! 409: goto bad;
! 410:
! 411: /* gateway address */
! 412: m = xdr_inaddr_decode(m, gw_ip);
! 413: if (m == NULL)
! 414: goto bad;
! 415:
! 416: /* success */
! 417: goto out;
! 418:
! 419: bad:
! 420: printf("nfs_boot: bootparam_whoami: bad reply\n");
! 421: error = EBADRPC;
! 422:
! 423: out:
! 424: if (from)
! 425: m_freem(from);
! 426: if (m)
! 427: m_freem(m);
! 428: return(error);
! 429: }
! 430:
! 431:
! 432: /*
! 433: * RPC: bootparam/getfile
! 434: * Given client name and file "key", get:
! 435: * server name
! 436: * server IP address
! 437: * server pathname
! 438: */
! 439: static int
! 440: bp_getfile(bpsin, key, md_sin, serv_name, pathname, retries)
! 441: struct sockaddr_in *bpsin;
! 442: char *key;
! 443: struct sockaddr_in *md_sin;
! 444: char *serv_name;
! 445: char *pathname;
! 446: int retries;
! 447: {
! 448: struct mbuf *m;
! 449: struct sockaddr_in *sin;
! 450: struct in_addr inaddr;
! 451: int error, sn_len, path_len;
! 452:
! 453: /*
! 454: * Build request message.
! 455: */
! 456:
! 457: /* client name (hostname) */
! 458: m = xdr_string_encode(hostname, hostnamelen);
! 459: if (m == NULL)
! 460: return (ENOMEM);
! 461:
! 462: /* key name (root or swap) */
! 463: m->m_next = xdr_string_encode(key, strlen(key));
! 464: if (m->m_next == NULL)
! 465: return (ENOMEM);
! 466:
! 467: /* RPC: bootparam/getfile */
! 468: error = krpc_call(bpsin, BOOTPARAM_PROG, BOOTPARAM_VERS,
! 469: BOOTPARAM_GETFILE, &m, NULL, retries);
! 470: if (error)
! 471: return error;
! 472:
! 473: /*
! 474: * Parse result message.
! 475: */
! 476:
! 477: /* server name */
! 478: sn_len = MNAMELEN-1;
! 479: m = xdr_string_decode(m, serv_name, &sn_len);
! 480: if (m == NULL)
! 481: goto bad;
! 482:
! 483: /* server IP address (mountd/NFS) */
! 484: m = xdr_inaddr_decode(m, &inaddr);
! 485: if (m == NULL)
! 486: goto bad;
! 487:
! 488: /* server pathname */
! 489: path_len = MAXPATHLEN-1;
! 490: m = xdr_string_decode(m, pathname, &path_len);
! 491: if (m == NULL)
! 492: goto bad;
! 493:
! 494: /* setup server socket address */
! 495: sin = md_sin;
! 496: bzero((caddr_t)sin, sizeof(*sin));
! 497: sin->sin_len = sizeof(*sin);
! 498: sin->sin_family = AF_INET;
! 499: sin->sin_addr = inaddr;
! 500:
! 501: /* success */
! 502: goto out;
! 503:
! 504: bad:
! 505: printf("nfs_boot: bootparam_getfile: bad reply\n");
! 506: error = EBADRPC;
! 507:
! 508: out:
! 509: m_freem(m);
! 510: return(0);
! 511: }
! 512:
! 513:
! 514: /*
! 515: * RPC: mountd/mount
! 516: * Given a server pathname, get an NFS file handle.
! 517: * Also, sets sin->sin_port to the NFS service port.
! 518: */
! 519: static int
! 520: md_mount(mdsin, path, fhp)
! 521: struct sockaddr_in *mdsin; /* mountd server address */
! 522: char *path;
! 523: u_char *fhp;
! 524: {
! 525: /* The RPC structures */
! 526: struct rdata {
! 527: u_int32_t errno;
! 528: u_int8_t fh[NFSX_V2FH];
! 529: } *rdata;
! 530: struct mbuf *m;
! 531: int error;
! 532:
! 533: /* Get port number for MOUNTD. */
! 534: error = krpc_portmap(mdsin, RPCPROG_MNT, RPCMNT_VER1,
! 535: &mdsin->sin_port);
! 536: if (error) return error;
! 537:
! 538: m = xdr_string_encode(path, strlen(path));
! 539: if (m == NULL)
! 540: return ENOMEM;
! 541:
! 542: /* Do RPC to mountd. */
! 543: error = krpc_call(mdsin, RPCPROG_MNT, RPCMNT_VER1,
! 544: RPCMNT_MOUNT, &m, NULL, -1);
! 545: if (error)
! 546: return error; /* message already freed */
! 547:
! 548: /* The reply might have only the errno. */
! 549: if (m->m_len < 4)
! 550: goto bad;
! 551: /* Have at least errno, so check that. */
! 552: rdata = mtod(m, struct rdata *);
! 553: error = fxdr_unsigned(u_int32_t, rdata->errno);
! 554: if (error)
! 555: goto out;
! 556:
! 557: /* Have errno==0, so the fh must be there. */
! 558: if (m->m_len < sizeof(*rdata)) {
! 559: m = m_pullup(m, sizeof(*rdata));
! 560: if (m == NULL)
! 561: goto bad;
! 562: rdata = mtod(m, struct rdata *);
! 563: }
! 564: bcopy(rdata->fh, fhp, NFSX_V2FH);
! 565: goto out;
! 566:
! 567: bad:
! 568: error = EBADRPC;
! 569:
! 570: out:
! 571: m_freem(m);
! 572: return error;
! 573: }
! 574:
! 575: #endif /* ifdef NFSCLIENT */
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to nfs_boot.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / nfs