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