1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
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
42extern char _start[];
43
44#define KERNEL_ADDR ((void *)0L)
45#define KERNEL_MAX_SIZE ((long)_start)
46#define ARCH_COMMAND_LINE_SIZE 896
47
48
49#define STSI322_VMDB_UUID_OFFSET ((8 + 12) * 4)
50
51char stack[PAGE_SIZE * 8] __attribute__((aligned(PAGE_SIZE)));
52IplParameterBlock iplb __attribute__((aligned(PAGE_SIZE)));
53static char cfgbuf[2048];
54
55static SubChannelId net_schid = { .one = 1 };
56static uint8_t mac[6];
57static uint64_t dest_timer;
58
59static uint64_t get_timer_ms(void)
60{
61 uint64_t clk;
62
63 asm volatile(" stck %0 " : : "Q"(clk) : "memory");
64
65
66 return (clk >> (63 - 51)) / 1000;
67}
68
69void set_timer(int val)
70{
71 dest_timer = get_timer_ms() + val;
72}
73
74int get_timer(void)
75{
76 return dest_timer - get_timer_ms();
77}
78
79int get_sec_ticks(void)
80{
81 return 1000;
82}
83
84
85
86
87
88
89
90
91
92
93static 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) {
121 break;
122 }
123 } while (1);
124 printf("\b\b\b\bdone\n");
125
126 return rc;
127}
128
129
130
131
132static 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
141static 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
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
167static 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);
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
235static 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
244
245
246static 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
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
294
295
296static 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
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
337static 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
355
356
357static 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
402static int net_try_direct_tftp_load(filename_ip_t *fn_ip)
403{
404 int rc;
405 void *loadaddr = (void *)0x2000;
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
416 if (rc < sizeof(cfgbuf) - 1) {
417 memcpy(cfgbuf, loadaddr, rc);
418 cfgbuf[rc] = 0;
419 if (!strncmp("* ", cfgbuf, 2)) {
420 return handle_ins_cfg(fn_ip, cfgbuf, rc);
421 }
422
423
424
425
426
427
428
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
444 memmove(KERNEL_ADDR, loadaddr, rc);
445
446 return rc;
447}
448
449void panic(const char *string)
450{
451 sclp_print(string);
452 for (;;) {
453 disabled_wait();
454 }
455}
456
457void 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
466static 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
494static void virtio_setup(void)
495{
496 Schib schib;
497 int ssid;
498 bool found = false;
499 uint16_t dev_no;
500
501
502
503
504
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
528void 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}
560