boot/bootimage.c

   1 /*      bootimage.c - Load an image and start it.       Author: Kees J. Bot
   2  *                                                              19 Jan 1992
   3  */
   4 #define BIOS            1       /* Can only be used under the BIOS. */
   5 #define nil 0
   6 #define _POSIX_SOURCE   1
   7 #define _MINIX          1
   8 #include <stddef.h>
   9 #include <sys/types.h>
  10 #include <sys/stat.h>
  11 #include <stdlib.h>
  12 #include <stdio.h>
  13 #include <limits.h>
  14 #include <string.h>
  15 #include <errno.h>
  16 #include <a.out.h>
  17 #include <minix/config.h>
  18 #include <minix/const.h>
  19 #include <minix/type.h>
  20 #include <minix/syslib.h>
  21 #include <kernel/const.h>
  22 #include <kernel/type.h>
  23 #include <ibm/partition.h>
  24 #include "rawfs.h"
  25 #include "image.h"
  26 #include "boot.h"
  27
  28 static int block_size = 0;
  29
  30 #define click_shift     clck_shft       /* 7 char clash with click_size. */
  31
  32 /* Some kernels have extra features: */
  33 #define K_I386   0x0001 /* Make the 386 transition before you call me. */
  34 #define K_CLAIM  0x0002 /* I will acquire my own bss pages, thank you. */
  35 #define K_CHMEM  0x0004 /* This kernel listens to chmem for its stack size. */
  36 #define K_HIGH   0x0008 /* Load mm, fs, etc. in extended memory. */
  37 #define K_HDR    0x0010 /* No need to patch sizes, kernel uses the headers. */
  38 #define K_RET    0x0020 /* Returns to the monitor on reboot. */
  39 #define K_INT86  0x0040 /* Requires generic INT support. */
  40 #define K_MEML   0x0080 /* Pass a list of free memory. */
  41 #define K_BRET   0x0100 /* New monitor code on shutdown in boot parameters. */
  42 #define K_ALL    0x01FF /* All feature bits this monitor supports. */
  43
  44
  45 /* Data about the different processes. */
  46
  47 #define PROCESS_MAX     16      /* Must match the space in kernel/mpx.x */
  48 #define KERNEL_IDX      0       /* The first process is the kernel. */
  49 #define FS              2       /* The third must be fs. */
  50
  51 struct process {        /* Per-process memory adresses. */
  52         u32_t   entry;          /* Entry point. */
  53         u32_t   cs;             /* Code segment. */
  54         u32_t   ds;             /* Data segment. */
  55         u32_t   data;           /* To access the data segment. */
  56         u32_t   end;            /* End of this process, size = (end - cs). */
  57 } process[PROCESS_MAX];
  58 int n_procs;                    /* Number of processes. */
  59
  60 /* Magic numbers in process' data space. */
  61 #define MAGIC_OFF       0       /* Offset of magic # in data seg. */
  62 #define CLICK_OFF       2       /* Offset in kernel text to click_shift. */
  63 #define FLAGS_OFF       4       /* Offset in kernel text to flags. */
  64 #define KERNEL_D_MAGIC  0x526F  /* Kernel magic number. */
  65
  66 /* Offsets of sizes to be patched into kernel and fs. */
  67 #define P_SIZ_OFF       0       /* Process' sizes into kernel data. */
  68 #define P_INIT_OFF      4       /* Init cs & sizes into fs data. */
  69
  70
  71 #define between(a, c, z)        ((unsigned) ((c) - (a)) <= ((z) - (a)))
  72
  73 void pretty_image(char *image)
  74 /* Pretty print the name of the image to load.  Translate '/' and '_' to
  75  * space, first letter goes uppercase.  An 'r' before a digit prints as
  76  * 'revision'.  E.g. 'minix/1.6.16r10' -> 'Minix 1.6.16 revision 10'.
  77  * The idea is that the part before the 'r' is the official Minix release
  78  * and after the 'r' you can put version numbers for your own changes.
  79  */
  80 {
  81         int up= 0, c;
  82
  83         while ((c= *image++) != 0) {
  84                 if (c == '/' || c == '_') c= ' ';
  85
  86                 if (c == 'r' && between('0', *image, '9')) {
  87                         printf(" revision ");
  88                         continue;
  89                 }
  90                 if (!up && between('a', c, 'z')) c= c - 'a' + 'A';
  91
  92                 if (between('A', c, 'Z')) up= 1;
  93
  94                 putch(c);
  95         }
  96 }
  97
  98 void raw_clear(u32_t addr, u32_t count)
  99 /* Clear "count" bytes at absolute address "addr". */
 100 {
 101         static char zeros[128];
 102         u32_t dst;
 103         u32_t zct;
 104
 105         zct= sizeof(zeros);
 106         if (zct > count) zct= count;
 107         raw_copy(addr, mon2abs(&zeros), zct);
 108         count-= zct;
 109
 110         while (count > 0) {
 111                 dst= addr + zct;
 112                 if (zct > count) zct= count;
 113                 raw_copy(dst, addr, zct);
 114                 count-= zct;
 115                 zct*= 2;
 116         }
 117 }
 118
 119 /* Align a to a multiple of n (a power of 2): */
 120 #define align(a, n)     (((u32_t)(a) + ((u32_t)(n) - 1)) & ~((u32_t)(n) - 1))
 121 unsigned click_shift;
 122 unsigned click_size;    /* click_size = Smallest kernel memory object. */
 123 unsigned k_flags;       /* Not all kernels are created equal. */
 124 u32_t reboot_code;      /* Obsolete reboot code return pointer. */
 125
 126 int params2params(char *params, size_t psize)
 127 /* Repackage the environment settings for the kernel. */
 128 {
 129         size_t i, n;
 130         environment *e;
 131         char *name, *value;
 132         dev_t dev;
 133
 134         i= 0;
 135         for (e= env; e != nil; e= e->next) {
 136                 name= e->name;
 137                 value= e->value;
 138
 139                 if (!(e->flags & E_VAR)) continue;
 140
 141                 if (e->flags & E_DEV) {
 142                         if ((dev= name2dev(value)) == -1) return 0;
 143                         value= ul2a10((u16_t) dev);
 144                 }
 145
 146                 n= i + strlen(name) + 1 + strlen(value) + 1;
 147                 if (n < psize) {
 148                         strcpy(params + i, name);
 149                         strcat(params + i, "=");
 150                         strcat(params + i, value);
 151                 }
 152                 i= n;
 153         }
 154
 155         if (!(k_flags & K_MEML)) {
 156                 /* Require old memory size variables. */
 157
 158                 value= ul2a10((mem[0].base + mem[0].size) / 1024);
 159                 n= i + 7 + 1 + strlen(value) + 1;
 160                 if (n < psize) {
 161                         strcpy(params + i, "memsize=");
 162                         strcat(params + i, value);
 163                 }
 164                 i= n;
 165                 value= ul2a10(mem[1].size / 1024);
 166                 n= i + 7 + 1 + strlen(value) + 1;
 167                 if (n < psize) {
 168                         strcpy(params + i, "emssize=");
 169                         strcat(params + i, value);
 170                 }
 171                 i= n;
 172         }
 173
 174         if (i >= psize) {
 175                 printf("Too many boot parameters\n");
 176                 return 0;
 177         }
 178         params[i]= 0;   /* End marked with empty string. */
 179         return 1;
 180 }
 181
 182 void patch_sizes(void)
 183 /* Patch sizes of each process into kernel data space, kernel ds into kernel
 184  * text space, and sizes of init into data space of fs.  All the patched
 185  * numbers are based on the kernel click size, not hardware segments.
 186  */
 187 {
 188         u16_t text_size, data_size;
 189         int i;
 190         struct process *procp, *initp;
 191         u32_t doff;
 192
 193         if (k_flags & K_HDR) return;    /* Uses the headers. */
 194
 195         /* Patch text and data sizes of the processes into kernel data space.
 196          */
 197         doff= process[KERNEL_IDX].data + P_SIZ_OFF;
 198
 199         for (i= 0; i < n_procs; i++) {
 200                 procp= &process[i];
 201                 text_size= (procp->ds - procp->cs) >> click_shift;
 202                 data_size= (procp->end - procp->ds) >> click_shift;
 203
 204                 /* Two words per process, the text and data size: */
 205                 put_word(doff, text_size); doff+= 2;
 206                 put_word(doff, data_size); doff+= 2;
 207
 208                 initp= procp;   /* The last process must be init. */
 209         }
 210
 211         if (k_flags & (K_HIGH|K_MEML)) return;  /* Doesn't need FS patching. */
 212
 213         /* Patch cs and sizes of init into fs data. */
 214         put_word(process[FS].data + P_INIT_OFF+0, initp->cs >> click_shift);
 215         put_word(process[FS].data + P_INIT_OFF+2, text_size);
 216         put_word(process[FS].data + P_INIT_OFF+4, data_size);
 217 }
 218
 219 int selected(char *name)
 220 /* True iff name has no label or the proper label. */
 221 {
 222         char *colon, *label;
 223         int cmp;
 224
 225         if ((colon= strchr(name, ':')) == nil) return 1;
 226         if ((label= b_value("label")) == nil) return 1;
 227
 228         *colon= 0;
 229         cmp= strcmp(label, name);
 230         *colon= ':';
 231         return cmp == 0;
 232 }
 233
 234 u32_t proc_size(struct image_header *hdr)
 235 /* Return the size of a process in sectors as found in an image. */
 236 {
 237         u32_t len= hdr->process.a_text;
 238
 239         if (hdr->process.a_flags & A_PAL) len+= hdr->process.a_hdrlen;
 240         if (hdr->process.a_flags & A_SEP) len= align(len, SECTOR_SIZE);
 241         len= align(len + hdr->process.a_data, SECTOR_SIZE);
 242
 243         return len >> SECTOR_SHIFT;
 244 }
 245
 246 off_t image_off, image_size;
 247 u32_t (*vir2sec)(u32_t vsec);   /* Where is a sector on disk? */
 248
 249 u32_t file_vir2sec(u32_t vsec)
 250 /* Translate a virtual sector number to an absolute disk sector. */
 251 {
 252         off_t blk;
 253
 254         if(!block_size) { errno = 0;  return -1; }
 255
 256         if ((blk= r_vir2abs(vsec / RATIO(block_size))) == -1) {
 257                 errno= EIO;
 258                 return -1;
 259         }
 260         return blk == 0 ? 0 : lowsec + blk * RATIO(block_size) + vsec % RATIO(block_size);
 261 }
 262
 263 u32_t flat_vir2sec(u32_t vsec)
 264 /* Simply add an absolute sector offset to vsec. */
 265 {
 266         return lowsec + image_off + vsec;
 267 }
 268
 269 char *get_sector(u32_t vsec)
 270 /* Read a sector "vsec" from the image into memory and return its address.
 271  * Return nil on error.  (This routine tries to read an entire track, so
 272  * the next request is usually satisfied from the track buffer.)
 273  */
 274 {
 275         u32_t sec;
 276         int r;
 277 #define SECBUFS 16
 278         static char buf[SECBUFS * SECTOR_SIZE];
 279         static size_t count;            /* Number of sectors in the buffer. */
 280         static u32_t bufsec;            /* First Sector now in the buffer. */
 281
 282         if (vsec == 0) count= 0;        /* First sector; initialize. */
 283
 284         if ((sec= (*vir2sec)(vsec)) == -1) return nil;
 285
 286         if (sec == 0) {
 287                 /* A hole. */
 288                 count= 0;
 289                 memset(buf, 0, SECTOR_SIZE);
 290                 return buf;
 291         }
 292
 293         /* Can we return a sector from the buffer? */
 294         if ((sec - bufsec) < count) {
 295                 return buf + ((size_t) (sec - bufsec) << SECTOR_SHIFT);
 296         }
 297
 298         /* Not in the buffer. */
 299         count= 0;
 300         bufsec= sec;
 301
 302         /* Read a whole track if possible. */
 303         while (++count < SECBUFS && !dev_boundary(bufsec + count)) {
 304                 vsec++;
 305                 if ((sec= (*vir2sec)(vsec)) == -1) break;
 306
 307                 /* Consecutive? */
 308                 if (sec != bufsec + count) break;
 309         }
 310
 311         /* Actually read the sectors. */
 312         if ((r= readsectors(mon2abs(buf), bufsec, count)) != 0) {
 313                 readerr(bufsec, r);
 314                 count= 0;
 315                 errno= 0;
 316                 return nil;
 317         }
 318         return buf;
 319 }
 320
 321 int get_clickshift(u32_t ksec, struct image_header *hdr)
 322 /* Get the click shift and special flags from kernel text. */
 323 {
 324         char *textp;
 325
 326         if ((textp= get_sector(ksec)) == nil) return 0;
 327
 328         if (hdr->process.a_flags & A_PAL) textp+= hdr->process.a_hdrlen;
 329         click_shift= * (u16_t *) (textp + CLICK_OFF);
 330         k_flags= * (u16_t *) (textp + FLAGS_OFF);
 331
 332         if ((k_flags & ~K_ALL) != 0) {
 333                 printf("%s requires features this monitor doesn't offer\n",
 334                         hdr->name);
 335                 return 0;
 336         }
 337
 338         if (click_shift < HCLICK_SHIFT || click_shift > 16) {
 339                 printf("%s click size is bad\n", hdr->name);
 340                 errno= 0;
 341                 return 0;
 342         }
 343
 344         click_size= 1 << click_shift;
 345
 346         return 1;
 347 }
 348
 349 int get_segment(u32_t *vsec, long *size, u32_t *addr, u32_t limit)
 350 /* Read *size bytes starting at virtual sector *vsec to memory at *addr. */
 351 {
 352         char *buf;
 353         size_t cnt, n;
 354
 355         cnt= 0;
 356         while (*size > 0) {
 357                 if (cnt == 0) {
 358                         if ((buf= get_sector((*vsec)++)) == nil) return 0;
 359                         cnt= SECTOR_SIZE;
 360                 }
 361                 if (*addr + click_size > limit) { errno= ENOMEM; return 0; }
 362                 n= click_size;
 363                 if (n > cnt) n= cnt;
 364                 raw_copy(*addr, mon2abs(buf), n);
 365                 *addr+= n;
 366                 *size-= n;
 367                 buf+= n;
 368                 cnt-= n;
 369         }
 370
 371         /* Zero extend to a click. */
 372         n= align(*addr, click_size) - *addr;
 373         raw_clear(*addr, n);
 374         *addr+= n;
 375         *size-= n;
 376         return 1;
 377 }
 378
 379 void exec_image(char *image)
 380 /* Get a Minix image into core, patch it up and execute. */
 381 {
 382         char *delayvalue;
 383         int i;
 384         struct image_header hdr;
 385         char *buf;
 386         u32_t vsec, addr, limit, aout, n;
 387         struct process *procp;          /* Process under construction. */
 388         long a_text, a_data, a_bss, a_stack;
 389         int banner= 0;
 390         long processor= a2l(b_value("processor"));
 391         u16_t mode;
 392         char *console;
 393         char params[SECTOR_SIZE];
 394         extern char *sbrk(int);
 395
 396         /* The stack is pretty deep here, so check if heap and stack collide. */
 397         (void) sbrk(0);
 398
 399         printf("\nLoading ");
 400         pretty_image(image);
 401         printf(".\n\n");
 402
 403         vsec= 0;                        /* Load this sector from image next. */
 404         addr= mem[0].base;              /* Into this memory block. */
 405         limit= mem[0].base + mem[0].size;
 406         if (limit > caddr) limit= caddr;
 407
 408         /* Allocate and clear the area where the headers will be placed. */
 409         aout = (limit -= PROCESS_MAX * A_MINHDR);
 410
 411         /* Clear the area where the headers will be placed. */
 412         raw_clear(aout, PROCESS_MAX * A_MINHDR);
 413
 414         /* Read the many different processes: */
 415         for (i= 0; vsec < image_size; i++) {
 416                 if (i == PROCESS_MAX) {
 417                         printf("There are more then %d programs in %s\n",
 418                                 PROCESS_MAX, image);
 419                         errno= 0;
 420                         return;
 421                 }
 422                 procp= &process[i];
 423
 424                 /* Read header. */
 425                 for (;;) {
 426                         if ((buf= get_sector(vsec++)) == nil) return;
 427
 428                         memcpy(&hdr, buf, sizeof(hdr));
 429
 430                         if (BADMAG(hdr.process)) { errno= ENOEXEC; return; }
 431
 432                         /* Check the optional label on the process. */
 433                         if (selected(hdr.name)) break;
 434
 435                         /* Bad label, skip this process. */
 436                         vsec+= proc_size(&hdr);
 437                 }
 438
 439                 /* Sanity check: an 8086 can't run a 386 kernel. */
 440                 if (hdr.process.a_cpu == A_I80386 && processor < 386) {
 441                         printf("You can't run a 386 kernel on this 80%ld\n",
 442                                 processor);
 443                         errno= 0;
 444                         return;
 445                 }
 446
 447                 /* Get the click shift from the kernel text segment. */
 448                 if (i == KERNEL_IDX) {
 449                         if (!get_clickshift(vsec, &hdr)) return;
 450                         addr= align(addr, click_size);
 451                 }
 452
 453                 /* Save a copy of the header for the kernel, with a_syms
 454                  * misused as the address where the process is loaded at.
 455                  */
 456                 hdr.process.a_syms= addr;
 457                 raw_copy(aout + i * A_MINHDR, mon2abs(&hdr.process), A_MINHDR);
 458
 459                 if (!banner) {
 460                         printf("     cs       ds     text     data      bss");
 461                         if (k_flags & K_CHMEM) printf("    stack");
 462                         putch('\n');
 463                         banner= 1;
 464                 }
 465
 466                 /* Segment sizes. */
 467                 a_text= hdr.process.a_text;
 468                 a_data= hdr.process.a_data;
 469                 a_bss= hdr.process.a_bss;
 470                 if (k_flags & K_CHMEM) {
 471                         a_stack= hdr.process.a_total - a_data - a_bss;
 472                         if (!(hdr.process.a_flags & A_SEP)) a_stack-= a_text;
 473                 } else {
 474                         a_stack= 0;
 475                 }
 476
 477                 /* Collect info about the process to be. */
 478                 procp->cs= addr;
 479
 480                 /* Process may be page aligned so that the text segment contains
 481                  * the header, or have an unmapped zero page against vaxisms.
 482                  */
 483                 procp->entry= hdr.process.a_entry;
 484                 if (hdr.process.a_flags & A_PAL) a_text+= hdr.process.a_hdrlen;
 485                 if (hdr.process.a_flags & A_UZP) procp->cs-= click_size;
 486
 487                 /* Separate I&D: two segments.  Common I&D: only one. */
 488                 if (hdr.process.a_flags & A_SEP) {
 489                         /* Read the text segment. */
 490                         if (!get_segment(&vsec, &a_text, &addr, limit)) return;
 491
 492                         /* The data segment follows. */
 493                         procp->ds= addr;
 494                         if (hdr.process.a_flags & A_UZP) procp->ds-= click_size;
 495                         procp->data= addr;
 496                 } else {
 497                         /* Add text to data to form one segment. */
 498                         procp->data= addr + a_text;
 499                         procp->ds= procp->cs;
 500                         a_data+= a_text;
 501                 }
 502
 503                 /* Read the data segment. */
 504                 if (!get_segment(&vsec, &a_data, &addr, limit)) return;
 505
 506                 /* Make space for bss and stack unless... */
 507                 if (i != KERNEL_IDX && (k_flags & K_CLAIM)) a_bss= a_stack= 0;
 508
 509                 printf("%07lx  %07lx %8ld %8ld %8ld",
 510                         procp->cs, procp->ds,
 511                         hdr.process.a_text, hdr.process.a_data,
 512                         hdr.process.a_bss
 513                 );
 514                 if (k_flags & K_CHMEM) printf(" %8ld", a_stack);
 515
 516                 printf("  %s\n", hdr.name);
 517
 518                 /* Note that a_data may be negative now, but we can look at it
 519                  * as -a_data bss bytes.
 520                  */
 521
 522                 /* Compute the number of bss clicks left. */
 523                 a_bss+= a_data;
 524                 n= align(a_bss, click_size);
 525                 a_bss-= n;
 526
 527                 /* Zero out bss. */
 528                 if (addr + n > limit) { errno= ENOMEM; return; }
 529                 raw_clear(addr, n);
 530                 addr+= n;
 531
 532                 /* And the number of stack clicks. */
 533                 a_stack+= a_bss;
 534                 n= align(a_stack, click_size);
 535                 a_stack-= n;
 536
 537                 /* Add space for the stack. */
 538                 addr+= n;
 539
 540                 /* Process endpoint. */
 541                 procp->end= addr;
 542
 543                 if (i == 0 && (k_flags & K_HIGH)) {
 544                         /* Load the rest in extended memory. */
 545                         addr= mem[1].base;
 546                         limit= mem[1].base + mem[1].size;
 547                 }
 548         }
 549
 550         if ((n_procs= i) == 0) {
 551                 printf("There are no programs in %s\n", image);
 552                 errno= 0;
 553                 return;
 554         }
 555
 556         /* Check the kernel magic number. */
 557         if (get_word(process[KERNEL_IDX].data + MAGIC_OFF) != KERNEL_D_MAGIC) {
 558                 printf("Kernel magic number is incorrect\n");
 559                 errno= 0;
 560                 return;
 561         }
 562
 563         /* Patch sizes, etc. into kernel data. */
 564         patch_sizes();
 565
 566 #if !DOS
 567         if (!(k_flags & K_MEML)) {
 568                 /* Copy the a.out headers to the old place. */
 569                 raw_copy(HEADERPOS, aout, PROCESS_MAX * A_MINHDR);
 570         }
 571 #endif
 572
 573         /* Do delay if wanted. */
 574         if((delayvalue = b_value("bootdelay")) != nil > 0) {
 575                 delay(delayvalue);
 576         }
 577
 578         /* Run the trailer function just before starting Minix. */
 579         if (!run_trailer()) { errno= 0; return; }
 580
 581         /* Translate the boot parameters to what Minix likes best. */
 582         if (!params2params(params, sizeof(params))) { errno= 0; return; }
 583
 584         /* Set the video to the required mode. */
 585         if ((console= b_value("console")) == nil || (mode= a2x(console)) == 0) {
 586                 mode= strcmp(b_value("chrome"), "color") == 0 ? COLOR_MODE :
 587                                                                 MONO_MODE;
 588         }
 589         set_mode(mode);
 590
 591         /* Close the disk. */
 592         (void) dev_close();
 593
 594         /* Minix. */
 595         minix(process[KERNEL_IDX].entry, process[KERNEL_IDX].cs,
 596                         process[KERNEL_IDX].ds, params, sizeof(params), aout);
 597
 598         if (!(k_flags & K_BRET)) {
 599                 extern u32_t reboot_code;
 600                 raw_copy(mon2abs(params), reboot_code, sizeof(params));
 601         }
 602         parse_code(params);
 603
 604         /* Return from Minix.  Things may have changed, so assume nothing. */
 605         fsok= -1;
 606         errno= 0;
 607
 608         /* Read leftover character, if any. */
 609         scan_keyboard();
 610 }
 611
 612 ino_t latest_version(char *version, struct stat *stp)
 613 /* Recursively read the current directory, selecting the newest image on
 614  * the way up.  (One can't use r_stat while reading a directory.)
 615  */
 616 {
 617         char name[NAME_MAX + 1];
 618         ino_t ino, newest;
 619         time_t mtime;
 620
 621         if ((ino= r_readdir(name)) == 0) { stp->st_mtime= 0; return 0; }
 622
 623         newest= latest_version(version, stp);
 624         mtime= stp->st_mtime;
 625         r_stat(ino, stp);
 626
 627         if (S_ISREG(stp->st_mode) && stp->st_mtime > mtime) {
 628                 newest= ino;
 629                 strcpy(version, name);
 630         } else {
 631                 stp->st_mtime= mtime;
 632         }
 633         return newest;
 634 }
 635
 636 char *select_image(char *image)
 637 /* Look image up on the filesystem, if it is a file then we're done, but
 638  * if its a directory then we want the newest file in that directory.  If
 639  * it doesn't exist at all, then see if it is 'number:number' and get the
 640  * image from that absolute offset off the disk.
 641  */
 642 {
 643         ino_t image_ino;
 644         struct stat st;
 645
 646         image= strcpy(malloc((strlen(image) + 1 + NAME_MAX + 1)
 647                                                  * sizeof(char)), image);
 648
 649         fsok= r_super(&block_size) != 0;
 650         if (!fsok || (image_ino= r_lookup(ROOT_INO, image)) == 0) {
 651                 char *size;
 652
 653                 if (numprefix(image, &size) && *size++ == ':'
 654                                                 && numeric(size)) {
 655                         vir2sec= flat_vir2sec;
 656                         image_off= a2l(image);
 657                         image_size= a2l(size);
 658                         strcpy(image, "Minix");
 659                         return image;
 660                 }
 661                 if (!fsok)
 662                         printf("No image selected\n");
 663                 else
 664                         printf("Can't load %s: %s\n", image, unix_err(errno));
 665                 goto bail_out;
 666         }
 667
 668         r_stat(image_ino, &st);
 669         if (!S_ISREG(st.st_mode)) {
 670                 char *version= image + strlen(image);
 671                 char dots[NAME_MAX + 1];
 672
 673                 if (!S_ISDIR(st.st_mode)) {
 674                         printf("%s: %s\n", image, unix_err(ENOTDIR));
 675                         goto bail_out;
 676                 }
 677                 (void) r_readdir(dots);
 678                 (void) r_readdir(dots); /* "." & ".." */
 679                 *version++= '/';
 680                 *version= 0;
 681                 if ((image_ino= latest_version(version, &st)) == 0) {
 682                         printf("There are no images in %s\n", image);
 683                         goto bail_out;
 684                 }
 685                 r_stat(image_ino, &st);
 686         }
 687         vir2sec= file_vir2sec;
 688         image_size= (st.st_size + SECTOR_SIZE - 1) >> SECTOR_SHIFT;
 689         return image;
 690 bail_out:
 691         free(image);
 692         return nil;
 693 }
 694
 695 void bootminix(void)
 696 /* Load Minix and run it.  (Given the size of this program it is surprising
 697  * that it ever gets to that.)
 698  */
 699 {
 700         char *image;
 701
 702         if ((image= select_image(b_value("image"))) == nil) return;
 703
 704         exec_image(image);
 705
 706         switch (errno) {
 707         case ENOEXEC:
 708                 printf("%s contains a bad program header\n", image);
 709                 break;
 710         case ENOMEM:
 711                 printf("Not enough memory to load %s\n", image);
 712                 break;
 713         case EIO:
 714                 printf("Unsuspected EOF on %s\n", image);
 715         case 0:
 716                 /* No error or error already reported. */;
 717         }
 718         free(image);
 719 }
 720
 721 /*
 722  * $PchId: bootimage.c,v 1.10 2002/02/27 19:39:09 philip Exp $
 723  */