1 /* 2 * S390 virtio-ccw network boot loading program 3 * 4 * Copyright 2017 Thomas Huth, Red Hat Inc. 5 * 6 * Based on the S390 virtio-ccw loading program (main.c) 7 * Copyright (c) 2013 Alexander Graf <agraf@suse.de> 8 * 9 * And based on the network loading code from SLOF (netload.c) 10 * Copyright (c) 2004, 2008 IBM Corporation 11 * 12 * This code is free software; you can redistribute it and/or modify it 13 * under the terms of the GNU General Public License as published by the 14 * Free Software Foundation; either version 2 of the License, or (at your 15 * option) any later version. 16 */ 17 18 #include <stdint.h> 19 #include <stdbool.h> 20 #include <stdio.h> 21 #include <stdlib.h> 22 #include <string.h> 23 #include <unistd.h> 24 25 #include <tftp.h> 26 #include <ethernet.h> 27 #include <dhcp.h> 28 #include <dhcpv6.h> 29 #include <ipv4.h> 30 #include <ipv6.h> 31 #include <dns.h> 32 #include <time.h> 33 #include <pxelinux.h> 34 35 #include "s390-ccw.h" 36 #include "cio.h" 37 #include "virtio.h" 38 #include "s390-time.h" 39 40 #define DEFAULT_BOOT_RETRIES 10 41 #define DEFAULT_TFTP_RETRIES 20 42 43 extern char _start[]; 44 45 #define KERNEL_ADDR ((void *)0L) 46 #define KERNEL_MAX_SIZE ((long)_start) 47 #define ARCH_COMMAND_LINE_SIZE 896 /* Taken from Linux kernel */ 48 49 /* STSI 3.2.2 offset of first vmdb + offset of uuid inside vmdb */ 50 #define STSI322_VMDB_UUID_OFFSET ((8 + 12) * 4) 51 52 static char cfgbuf[2048]; 53 54 SubChannelId net_schid = { .one = 1 }; 55 static uint8_t mac[6]; 56 static uint64_t dest_timer; 57 58 void set_timer(int val) 59 { 60 dest_timer = get_time_ms() + val; 61 } 62 63 int get_timer(void) 64 { 65 return dest_timer - get_time_ms(); 66 } 67 68 int get_sec_ticks(void) 69 { 70 return 1000; /* number of ticks in 1 second */ 71 } 72 73 /** 74 * Obtain IP and configuration info from DHCP server (either IPv4 or IPv6). 75 * @param fn_ip contains the following configuration information: 76 * client MAC, client IP, TFTP-server MAC, TFTP-server IP, 77 * boot file name 78 * @param retries Number of DHCP attempts 79 * @return 0 : IP and configuration info obtained; 80 * non-0 : error condition occurred. 81 */ 82 static int dhcp(struct filename_ip *fn_ip, int retries) 83 { 84 int i = retries + 1; 85 int rc = -1; 86 87 printf(" Requesting information via DHCP: "); 88 89 dhcpv4_generate_transaction_id(); 90 dhcpv6_generate_transaction_id(); 91 92 do { 93 printf("\b\b\b%03d", i - 1); 94 if (!--i) { 95 printf("\nGiving up after %d DHCP requests\n", retries); 96 return -1; 97 } 98 fn_ip->ip_version = 4; 99 rc = dhcpv4(NULL, fn_ip); 100 if (rc == -1) { 101 fn_ip->ip_version = 6; 102 set_ipv6_address(fn_ip->fd, 0); 103 rc = dhcpv6(NULL, fn_ip); 104 if (rc == 0) { 105 memcpy(&fn_ip->own_ip6, get_ipv6_address(), 16); 106 break; 107 } 108 } 109 if (rc != -1) { /* either success or non-dhcp failure */ 110 break; 111 } 112 } while (1); 113 printf("\b\b\b\bdone\n"); 114 115 return rc; 116 } 117 118 /** 119 * Seed the random number generator with our mac and current timestamp 120 */ 121 static void seed_rng(uint8_t mac[]) 122 { 123 uint64_t seed; 124 125 asm volatile(" stck %0 " : : "Q"(seed) : "memory"); 126 seed ^= (mac[2] << 24) | (mac[3] << 16) | (mac[4] << 8) | mac[5]; 127 srand(seed); 128 } 129 130 static int tftp_load(filename_ip_t *fnip, void *buffer, int len) 131 { 132 tftp_err_t tftp_err; 133 int rc; 134 135 rc = tftp(fnip, buffer, len, DEFAULT_TFTP_RETRIES, &tftp_err); 136 137 if (rc < 0) { 138 /* Make sure that error messages are put into a new line */ 139 printf("\n "); 140 } 141 142 if (rc > 1024) { 143 printf(" TFTP: Received %s (%d KBytes)\n", fnip->filename, rc / 1024); 144 } else if (rc > 0) { 145 printf(" TFTP: Received %s (%d Bytes)\n", fnip->filename, rc); 146 } else { 147 const char *errstr = NULL; 148 int ecode; 149 tftp_get_error_info(fnip, &tftp_err, rc, &errstr, &ecode); 150 printf("TFTP error: %s\n", errstr ? errstr : "unknown error"); 151 } 152 153 return rc; 154 } 155 156 static int net_init_ip(filename_ip_t *fn_ip) 157 { 158 int rc; 159 160 printf(" Using MAC address: %02x:%02x:%02x:%02x:%02x:%02x\n", 161 mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]); 162 163 set_mac_address(mac); /* init ethernet layer */ 164 seed_rng(mac); 165 166 rc = dhcp(fn_ip, DEFAULT_BOOT_RETRIES); 167 if (rc >= 0) { 168 if (fn_ip->ip_version == 4) { 169 set_ipv4_address(fn_ip->own_ip); 170 } 171 } else { 172 puts("Could not get IP address"); 173 return -101; 174 } 175 176 if (fn_ip->ip_version == 4) { 177 printf(" Using IPv4 address: %d.%d.%d.%d\n", 178 (fn_ip->own_ip >> 24) & 0xFF, (fn_ip->own_ip >> 16) & 0xFF, 179 (fn_ip->own_ip >> 8) & 0xFF, fn_ip->own_ip & 0xFF); 180 } else if (fn_ip->ip_version == 6) { 181 char ip6_str[40]; 182 ipv6_to_str(fn_ip->own_ip6.addr, ip6_str); 183 printf(" Using IPv6 address: %s\n", ip6_str); 184 } 185 186 if (rc == -2) { 187 printf("ARP request to TFTP server (%d.%d.%d.%d) failed\n", 188 (fn_ip->server_ip >> 24) & 0xFF, (fn_ip->server_ip >> 16) & 0xFF, 189 (fn_ip->server_ip >> 8) & 0xFF, fn_ip->server_ip & 0xFF); 190 return -102; 191 } 192 if (rc == -4 || rc == -3) { 193 puts("Can't obtain TFTP server IP address"); 194 return -107; 195 } 196 197 printf(" Using TFTP server: "); 198 if (fn_ip->ip_version == 4) { 199 printf("%d.%d.%d.%d\n", 200 (fn_ip->server_ip >> 24) & 0xFF, (fn_ip->server_ip >> 16) & 0xFF, 201 (fn_ip->server_ip >> 8) & 0xFF, fn_ip->server_ip & 0xFF); 202 } else if (fn_ip->ip_version == 6) { 203 char ip6_str[40]; 204 ipv6_to_str(fn_ip->server_ip6.addr, ip6_str); 205 printf("%s\n", ip6_str); 206 } 207 208 if (strlen(fn_ip->filename) > 0) { 209 printf(" Bootfile name: '%s'\n", fn_ip->filename); 210 } 211 212 return rc; 213 } 214 215 static int net_init(filename_ip_t *fn_ip) 216 { 217 int rc; 218 219 memset(fn_ip, 0, sizeof(filename_ip_t)); 220 221 rc = virtio_net_init(mac); 222 if (rc < 0) { 223 puts("Could not initialize network device"); 224 return -101; 225 } 226 fn_ip->fd = rc; 227 228 rc = net_init_ip(fn_ip); 229 if (rc < 0) { 230 virtio_net_deinit(); 231 } 232 233 return rc; 234 } 235 236 static void net_release(filename_ip_t *fn_ip) 237 { 238 if (fn_ip->ip_version == 4) { 239 dhcp_send_release(fn_ip->fd); 240 } 241 virtio_net_deinit(); 242 } 243 244 /** 245 * Retrieve the Universally Unique Identifier of the VM. 246 * @return UUID string, or NULL in case of errors 247 */ 248 static const char *get_uuid(void) 249 { 250 register int r0 asm("0"); 251 register int r1 asm("1"); 252 uint8_t *mem, *buf, uuid[16]; 253 int i, cc, chk = 0; 254 static char uuid_str[37]; 255 256 mem = malloc(2 * PAGE_SIZE); 257 if (!mem) { 258 puts("Out of memory ... can not get UUID."); 259 return NULL; 260 } 261 buf = (uint8_t *)(((uint64_t)mem + PAGE_SIZE - 1) & ~(PAGE_SIZE - 1)); 262 memset(buf, 0, PAGE_SIZE); 263 264 /* Get SYSIB 3.2.2 */ 265 r0 = (3 << 28) | 2; 266 r1 = 2; 267 asm volatile(" stsi 0(%[addr])\n" 268 " ipm %[cc]\n" 269 " srl %[cc],28\n" 270 : [cc] "=d" (cc) 271 : "d" (r0), "d" (r1), [addr] "a" (buf) 272 : "cc", "memory"); 273 if (cc) { 274 free(mem); 275 return NULL; 276 } 277 278 for (i = 0; i < 16; i++) { 279 uuid[i] = buf[STSI322_VMDB_UUID_OFFSET + i]; 280 chk |= uuid[i]; 281 } 282 free(mem); 283 if (!chk) { 284 return NULL; 285 } 286 287 sprintf(uuid_str, "%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-" 288 "%02x%02x%02x%02x%02x%02x", uuid[0], uuid[1], uuid[2], uuid[3], 289 uuid[4], uuid[5], uuid[6], uuid[7], uuid[8], uuid[9], uuid[10], 290 uuid[11], uuid[12], uuid[13], uuid[14], uuid[15]); 291 292 return uuid_str; 293 } 294 295 /** 296 * Load a kernel with initrd (i.e. with the information that we've got from 297 * a pxelinux.cfg config file) 298 */ 299 static int load_kernel_with_initrd(filename_ip_t *fn_ip, 300 struct pl_cfg_entry *entry) 301 { 302 int rc; 303 304 printf("Loading pxelinux.cfg entry '%s'\n", entry->label); 305 306 if (!entry->kernel) { 307 puts("Kernel entry is missing!\n"); 308 return -1; 309 } 310 311 strncpy(fn_ip->filename, entry->kernel, sizeof(fn_ip->filename)); 312 rc = tftp_load(fn_ip, KERNEL_ADDR, KERNEL_MAX_SIZE); 313 if (rc < 0) { 314 return rc; 315 } 316 317 if (entry->initrd) { 318 uint64_t iaddr = (rc + 0xfff) & ~0xfffUL; 319 320 strncpy(fn_ip->filename, entry->initrd, sizeof(fn_ip->filename)); 321 rc = tftp_load(fn_ip, (void *)iaddr, KERNEL_MAX_SIZE - iaddr); 322 if (rc < 0) { 323 return rc; 324 } 325 /* Patch location and size: */ 326 *(uint64_t *)0x10408 = iaddr; 327 *(uint64_t *)0x10410 = rc; 328 rc += iaddr; 329 } 330 331 if (entry->append) { 332 strncpy((char *)0x10480, entry->append, ARCH_COMMAND_LINE_SIZE); 333 } 334 335 return rc; 336 } 337 338 #define MAX_PXELINUX_ENTRIES 16 339 340 static int net_try_pxelinux_cfg(filename_ip_t *fn_ip) 341 { 342 struct pl_cfg_entry entries[MAX_PXELINUX_ENTRIES]; 343 int num_ent, def_ent = 0; 344 345 num_ent = pxelinux_load_parse_cfg(fn_ip, mac, get_uuid(), 346 DEFAULT_TFTP_RETRIES, 347 cfgbuf, sizeof(cfgbuf), 348 entries, MAX_PXELINUX_ENTRIES, &def_ent); 349 if (num_ent > 0) { 350 return load_kernel_with_initrd(fn_ip, &entries[def_ent]); 351 } 352 353 return -1; 354 } 355 356 /** 357 * Load via information from a .INS file (which can be found on CD-ROMs 358 * for example) 359 */ 360 static int handle_ins_cfg(filename_ip_t *fn_ip, char *cfg, int cfgsize) 361 { 362 char *ptr; 363 int rc = -1, llen; 364 void *destaddr; 365 char *insbuf = cfg; 366 367 ptr = strchr(insbuf, '\n'); 368 if (!ptr) { 369 puts("Does not seem to be a valid .INS file"); 370 return -1; 371 } 372 373 *ptr = 0; 374 printf("\nParsing .INS file:\n %s\n", &insbuf[2]); 375 376 insbuf = ptr + 1; 377 while (*insbuf && insbuf < cfg + cfgsize) { 378 ptr = strchr(insbuf, '\n'); 379 if (ptr) { 380 *ptr = 0; 381 } 382 llen = strlen(insbuf); 383 if (!llen) { 384 insbuf = ptr + 1; 385 continue; 386 } 387 ptr = strchr(insbuf, ' '); 388 if (!ptr) { 389 puts("Missing space separator in .INS file"); 390 return -1; 391 } 392 *ptr = 0; 393 strncpy(fn_ip->filename, insbuf, sizeof(fn_ip->filename)); 394 destaddr = (char *)atol(ptr + 1); 395 rc = tftp_load(fn_ip, destaddr, (long)_start - (long)destaddr); 396 if (rc <= 0) { 397 break; 398 } 399 insbuf += llen + 1; 400 } 401 402 return rc; 403 } 404 405 static int net_try_direct_tftp_load(filename_ip_t *fn_ip) 406 { 407 int rc; 408 void *loadaddr = (void *)0x2000; /* Load right after the low-core */ 409 410 rc = tftp_load(fn_ip, loadaddr, KERNEL_MAX_SIZE - (long)loadaddr); 411 if (rc < 0) { 412 return rc; 413 } else if (rc < 8) { 414 printf("'%s' is too small (%i bytes only).\n", fn_ip->filename, rc); 415 return -1; 416 } 417 418 /* Check whether it is a configuration file instead of a kernel */ 419 if (rc < sizeof(cfgbuf) - 1) { 420 memcpy(cfgbuf, loadaddr, rc); 421 cfgbuf[rc] = 0; /* Make sure that it is NUL-terminated */ 422 if (!strncmp("* ", cfgbuf, 2)) { 423 return handle_ins_cfg(fn_ip, cfgbuf, rc); 424 } 425 /* 426 * pxelinux.cfg support via bootfile name is just here for developers' 427 * convenience (it eases testing with the built-in DHCP server of QEMU 428 * that does not support RFC 5071). The official way to configure a 429 * pxelinux.cfg file name is to use DHCP options 209 and 210 instead. 430 * So only use the pxelinux.cfg parser here for files that start with 431 * a magic comment string. 432 */ 433 if (!strncasecmp("# pxelinux", cfgbuf, 10)) { 434 struct pl_cfg_entry entries[MAX_PXELINUX_ENTRIES]; 435 int num_ent, def_ent = 0; 436 437 num_ent = pxelinux_parse_cfg(cfgbuf, sizeof(cfgbuf), entries, 438 MAX_PXELINUX_ENTRIES, &def_ent); 439 if (num_ent <= 0) { 440 return -1; 441 } 442 return load_kernel_with_initrd(fn_ip, &entries[def_ent]); 443 } 444 } 445 446 /* Move kernel to right location */ 447 memmove(KERNEL_ADDR, loadaddr, rc); 448 449 return rc; 450 } 451 452 static bool find_net_dev(Schib *schib, int dev_no) 453 { 454 int i, r; 455 456 for (i = 0; i < 0x10000; i++) { 457 net_schid.sch_no = i; 458 r = stsch_err(net_schid, schib); 459 if (r == 3 || r == -EIO) { 460 break; 461 } 462 if (!schib->pmcw.dnv) { 463 continue; 464 } 465 enable_subchannel(net_schid); 466 if (!virtio_is_supported(net_schid)) { 467 continue; 468 } 469 if (virtio_get_device_type() != VIRTIO_ID_NET) { 470 continue; 471 } 472 if (dev_no < 0 || schib->pmcw.dev == dev_no) { 473 return true; 474 } 475 } 476 477 return false; 478 } 479 480 static bool virtio_setup(void) 481 { 482 Schib schib; 483 int ssid; 484 bool found = false; 485 uint16_t dev_no; 486 487 /* 488 * We unconditionally enable mss support. In every sane configuration, 489 * this will succeed; and even if it doesn't, stsch_err() can deal 490 * with the consequences. 491 */ 492 enable_mss_facility(); 493 494 if (have_iplb || store_iplb(&iplb)) { 495 IPL_assert(iplb.pbt == S390_IPL_TYPE_CCW, "IPL_TYPE_CCW expected"); 496 dev_no = iplb.ccw.devno; 497 debug_print_int("device no. ", dev_no); 498 net_schid.ssid = iplb.ccw.ssid & 0x3; 499 debug_print_int("ssid ", net_schid.ssid); 500 found = find_net_dev(&schib, dev_no); 501 } else { 502 for (ssid = 0; ssid < 0x3; ssid++) { 503 net_schid.ssid = ssid; 504 found = find_net_dev(&schib, -1); 505 if (found) { 506 break; 507 } 508 } 509 } 510 511 return found; 512 } 513 514 int netmain(void) 515 { 516 filename_ip_t fn_ip; 517 int rc, fnlen; 518 519 sclp_setup(); 520 puts("Network boot starting..."); 521 522 if (!virtio_setup()) { 523 puts("No virtio net device found."); 524 return -1; 525 } 526 527 rc = net_init(&fn_ip); 528 if (rc) { 529 puts("Network initialization failed."); 530 return -1; 531 } 532 533 fnlen = strlen(fn_ip.filename); 534 if (fnlen > 0 && fn_ip.filename[fnlen - 1] != '/') { 535 rc = net_try_direct_tftp_load(&fn_ip); 536 } 537 if (rc <= 0) { 538 rc = net_try_pxelinux_cfg(&fn_ip); 539 } 540 541 net_release(&fn_ip); 542 543 if (rc > 0) { 544 puts("Network loading done, starting kernel..."); 545 jump_to_low_kernel(); 546 } 547 548 puts("Failed to load OS from network."); 549 return -1; 550 } 551