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