pc-bios/s390-ccw/netmain.c

   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         return NULL;
 273     }
 274
 275     for (i = 0; i < 16; i++) {
 276         uuid[i] = buf[STSI322_VMDB_UUID_OFFSET + i];
 277         chk |= uuid[i];
 278     }
 279     free(mem);
 280     if (!chk) {
 281         return NULL;
 282     }
 283
 284     sprintf(uuid_str, "%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-"
 285             "%02x%02x%02x%02x%02x%02x", uuid[0], uuid[1], uuid[2], uuid[3],
 286             uuid[4], uuid[5], uuid[6], uuid[7], uuid[8], uuid[9], uuid[10],
 287             uuid[11], uuid[12], uuid[13], uuid[14], uuid[15]);
 288
 289     return uuid_str;
 290 }
 291
 292 /**
 293  * Load a kernel with initrd (i.e. with the information that we've got from
 294  * a pxelinux.cfg config file)
 295  */
 296 static int load_kernel_with_initrd(filename_ip_t *fn_ip,
 297                                    struct pl_cfg_entry *entry)
 298 {
 299     int rc;
 300
 301     printf("Loading pxelinux.cfg entry '%s'\n", entry->label);
 302
 303     if (!entry->kernel) {
 304         printf("Kernel entry is missing!\n");
 305         return -1;
 306     }
 307
 308     strncpy(fn_ip->filename, entry->kernel, sizeof(fn_ip->filename));
 309     rc = tftp_load(fn_ip, KERNEL_ADDR, KERNEL_MAX_SIZE);
 310     if (rc < 0) {
 311         return rc;
 312     }
 313
 314     if (entry->initrd) {
 315         uint64_t iaddr = (rc + 0xfff) & ~0xfffUL;
 316
 317         strncpy(fn_ip->filename, entry->initrd, sizeof(fn_ip->filename));
 318         rc = tftp_load(fn_ip, (void *)iaddr, KERNEL_MAX_SIZE - iaddr);
 319         if (rc < 0) {
 320             return rc;
 321         }
 322         /* Patch location and size: */
 323         *(uint64_t *)0x10408 = iaddr;
 324         *(uint64_t *)0x10410 = rc;
 325         rc += iaddr;
 326     }
 327
 328     if (entry->append) {
 329         strncpy((char *)0x10480, entry->append, ARCH_COMMAND_LINE_SIZE);
 330     }
 331
 332     return rc;
 333 }
 334
 335 #define MAX_PXELINUX_ENTRIES 16
 336
 337 static int net_try_pxelinux_cfg(filename_ip_t *fn_ip)
 338 {
 339     struct pl_cfg_entry entries[MAX_PXELINUX_ENTRIES];
 340     int num_ent, def_ent = 0;
 341
 342     num_ent = pxelinux_load_parse_cfg(fn_ip, mac, get_uuid(),
 343                                       DEFAULT_TFTP_RETRIES,
 344                                       cfgbuf, sizeof(cfgbuf),
 345                                       entries, MAX_PXELINUX_ENTRIES, &def_ent);
 346     if (num_ent > 0) {
 347         return load_kernel_with_initrd(fn_ip, &entries[def_ent]);
 348     }
 349
 350     return -1;
 351 }
 352
 353 /**
 354  * Load via information from a .INS file (which can be found on CD-ROMs
 355  * for example)
 356  */
 357 static int handle_ins_cfg(filename_ip_t *fn_ip, char *cfg, int cfgsize)
 358 {
 359     char *ptr;
 360     int rc = -1, llen;
 361     void *destaddr;
 362     char *insbuf = cfg;
 363
 364     ptr = strchr(insbuf, '\n');
 365     if (!ptr) {
 366         puts("Does not seem to be a valid .INS file");
 367         return -1;
 368     }
 369
 370     *ptr = 0;
 371     printf("\nParsing .INS file:\n %s\n", &insbuf[2]);
 372
 373     insbuf = ptr + 1;
 374     while (*insbuf && insbuf < cfg + cfgsize) {
 375         ptr = strchr(insbuf, '\n');
 376         if (ptr) {
 377             *ptr = 0;
 378         }
 379         llen = strlen(insbuf);
 380         if (!llen) {
 381             insbuf = ptr + 1;
 382             continue;
 383         }
 384         ptr = strchr(insbuf, ' ');
 385         if (!ptr) {
 386             puts("Missing space separator in .INS file");
 387             return -1;
 388         }
 389         *ptr = 0;
 390         strncpy(fn_ip->filename, insbuf, sizeof(fn_ip->filename));
 391         destaddr = (char *)atol(ptr + 1);
 392         rc = tftp_load(fn_ip, destaddr, (long)_start - (long)destaddr);
 393         if (rc <= 0) {
 394             break;
 395         }
 396         insbuf += llen + 1;
 397     }
 398
 399     return rc;
 400 }
 401
 402 static int net_try_direct_tftp_load(filename_ip_t *fn_ip)
 403 {
 404     int rc;
 405     void *loadaddr = (void *)0x2000;  /* Load right after the low-core */
 406
 407     rc = tftp_load(fn_ip, loadaddr, KERNEL_MAX_SIZE - (long)loadaddr);
 408     if (rc < 0) {
 409         return rc;
 410     } else if (rc < 8) {
 411         printf("'%s' is too small (%i bytes only).\n", fn_ip->filename, rc);
 412         return -1;
 413     }
 414
 415     /* Check whether it is a configuration file instead of a kernel */
 416     if (rc < sizeof(cfgbuf) - 1) {
 417         memcpy(cfgbuf, loadaddr, rc);
 418         cfgbuf[rc] = 0;    /* Make sure that it is NUL-terminated */
 419         if (!strncmp("* ", cfgbuf, 2)) {
 420             return handle_ins_cfg(fn_ip, cfgbuf, rc);
 421         }
 422         /*
 423          * pxelinux.cfg support via bootfile name is just here for developers'
 424          * convenience (it eases testing with the built-in DHCP server of QEMU
 425          * that does not support RFC 5071). The official way to configure a
 426          * pxelinux.cfg file name is to use DHCP options 209 and 210 instead.
 427          * So only use the pxelinux.cfg parser here for files that start with
 428          * a magic comment string.
 429          */
 430         if (!strncasecmp("# pxelinux", cfgbuf, 10)) {
 431             struct pl_cfg_entry entries[MAX_PXELINUX_ENTRIES];
 432             int num_ent, def_ent = 0;
 433
 434             num_ent = pxelinux_parse_cfg(cfgbuf, sizeof(cfgbuf), entries,
 435                                          MAX_PXELINUX_ENTRIES, &def_ent);
 436             if (num_ent <= 0) {
 437                 return -1;
 438             }
 439             return load_kernel_with_initrd(fn_ip, &entries[def_ent]);
 440         }
 441     }
 442
 443     /* Move kernel to right location */
 444     memmove(KERNEL_ADDR, loadaddr, rc);
 445
 446     return rc;
 447 }
 448
 449 void panic(const char *string)
 450 {
 451     sclp_print(string);
 452     for (;;) {
 453         disabled_wait();
 454     }
 455 }
 456
 457 void write_subsystem_identification(void)
 458 {
 459     SubChannelId *schid = (SubChannelId *) 184;
 460     uint32_t *zeroes = (uint32_t *) 188;
 461
 462     *schid = net_schid;
 463     *zeroes = 0;
 464 }
 465
 466 static bool find_net_dev(Schib *schib, int dev_no)
 467 {
 468     int i, r;
 469
 470     for (i = 0; i < 0x10000; i++) {
 471         net_schid.sch_no = i;
 472         r = stsch_err(net_schid, schib);
 473         if (r == 3 || r == -EIO) {
 474             break;
 475         }
 476         if (!schib->pmcw.dnv) {
 477             continue;
 478         }
 479         enable_subchannel(net_schid);
 480         if (!virtio_is_supported(net_schid)) {
 481             continue;
 482         }
 483         if (virtio_get_device_type() != VIRTIO_ID_NET) {
 484             continue;
 485         }
 486         if (dev_no < 0 || schib->pmcw.dev == dev_no) {
 487             return true;
 488         }
 489     }
 490
 491     return false;
 492 }
 493
 494 static void virtio_setup(void)
 495 {
 496     Schib schib;
 497     int ssid;
 498     bool found = false;
 499     uint16_t dev_no;
 500
 501     /*
 502      * We unconditionally enable mss support. In every sane configuration,
 503      * this will succeed; and even if it doesn't, stsch_err() can deal
 504      * with the consequences.
 505      */
 506     enable_mss_facility();
 507
 508     if (store_iplb(&iplb)) {
 509         IPL_assert(iplb.pbt == S390_IPL_TYPE_CCW, "IPL_TYPE_CCW expected");
 510         dev_no = iplb.ccw.devno;
 511         debug_print_int("device no. ", dev_no);
 512         net_schid.ssid = iplb.ccw.ssid & 0x3;
 513         debug_print_int("ssid ", net_schid.ssid);
 514         found = find_net_dev(&schib, dev_no);
 515     } else {
 516         for (ssid = 0; ssid < 0x3; ssid++) {
 517             net_schid.ssid = ssid;
 518             found = find_net_dev(&schib, -1);
 519             if (found) {
 520                 break;
 521             }
 522         }
 523     }
 524
 525     IPL_assert(found, "No virtio net device found");
 526 }
 527
 528 void main(void)
 529 {
 530     filename_ip_t fn_ip;
 531     int rc, fnlen;
 532
 533     sclp_setup();
 534     sclp_print("Network boot starting...\n");
 535
 536     virtio_setup();
 537
 538     rc = net_init(&fn_ip);
 539     if (rc) {
 540         panic("Network initialization failed. Halting.\n");
 541     }
 542
 543     fnlen = strlen(fn_ip.filename);
 544     if (fnlen > 0 && fn_ip.filename[fnlen - 1] != '/') {
 545         rc = net_try_direct_tftp_load(&fn_ip);
 546     }
 547     if (rc <= 0) {
 548         rc = net_try_pxelinux_cfg(&fn_ip);
 549     }
 550
 551     net_release(&fn_ip);
 552
 553     if (rc > 0) {
 554         sclp_print("Network loading done, starting kernel...\n");
 555         jump_to_low_kernel();
 556     }
 557
 558     panic("Failed to load OS from network\n");
 559 }