Go to Linux kernel indentation style throughout
authorH. Peter Anvin <hpa@zytor.com>
Fri, 11 Jan 2008 03:13:39 +0000 (19:13 -0800)
committerH. Peter Anvin <hpa@zytor.com>
Fri, 11 Jan 2008 03:13:39 +0000 (19:13 -0800)
linux.c
main.c
mapfile.c
nbi.c
nbi.h
wraplinux.h
xmalloc.c

diff --git a/linux.c b/linux.c
index 54df4ac..c28789f 100644 (file)
--- a/linux.c
+++ b/linux.c
@@ -39,299 +39,306 @@ extern uint32_t reloc_size;
    (which should include the final =; do not use for boolean arguments) */
 static const char *find_argument(const char *cmdline, const char *argument)
 {
-  int la = strlen(argument);
-  const char *p = cmdline;
-  int wasspace = 1;
+       int la = strlen(argument);
+       const char *p = cmdline;
+       int wasspace = 1;
 
-  while (*p) {
-    if (wasspace && !memcmp(p, argument, la))
-      return p+la;
+       while (*p) {
+               if (wasspace && !memcmp(p, argument, la))
+                       return p + la;
 
-    wasspace = isspace(*p++);
-  }
+               wasspace = isspace(*p++);
+       }
 
-  return NULL;
+       return NULL;
 }
 
 /* Truncate to 32 bits, with saturate */
 static inline uint32_t saturate32(unsigned long long v)
 {
-  return (v > 0xffffffff) ? 0xffffffff : (uint32_t)v;
+       return (v > 0xffffffff) ? 0xffffffff : (uint32_t) v;
 }
 
 /* Get a value with a potential suffix (k/m/g/t/p/e) */
 static unsigned long long suffix_number(const char *str)
 {
-  char *ep;
-  unsigned long long v;
-  int shift;
-
-  v = strtoull(str, &ep, 0);
-  switch (*ep|0x20) {
-  case 'k':
-    shift = 10;
-    break;
-  case 'm':
-    shift = 20;
-    break;
-  case 'g':
-    shift = 30;
-    break;
-  case 't':
-    shift = 40;
-    break;
-  case 'p':
-    shift = 50;
-    break;
-  case 'e':
-    shift = 60;
-    break;
-  default:
-    shift = 0;
-    break;
-  }
-  v <<= shift;
-
-  return v;
+       char *ep;
+       unsigned long long v;
+       int shift;
+
+       v = strtoull(str, &ep, 0);
+       switch (*ep | 0x20) {
+       case 'k':
+               shift = 10;
+               break;
+       case 'm':
+               shift = 20;
+               break;
+       case 'g':
+               shift = 30;
+               break;
+       case 't':
+               shift = 40;
+               break;
+       case 'p':
+               shift = 50;
+               break;
+       case 'e':
+               shift = 60;
+               break;
+       default:
+               shift = 0;
+               break;
+       }
+       v <<= shift;
+
+       return v;
 }
 
 int wrap_kernel(const char *kernel_file, const char *cmdline,
                const struct string_list *initrd_list, FILE *out)
 {
-  struct initrd_info {
-    int fd;
-    struct segment seg;
-  } *ird = NULL;
-  int kernel_fd = -1;
-  char *kernel = NULL;
-  size_t kernel_len = 0;
-  struct segment srel, ssup, scmd, skrn;
-  struct startup_info *info = (void *)reloc;
-  struct setup_header *hdr;
-  size_t setup_len;
-  size_t initrd_len;
-  size_t initrd_addr;
-  int rv = EX_SOFTWARE;                /* Should never be returned... */
-  int ninitrd = 0;
-  int i;
-  const struct string_list *ip;
-  int setup_ver;               /* Setup protocol version */
-  int setup_space;             /* How much space for the setup */
-  const char *cmd;
-  uint32_t initrd_max;
-
-  /* Process the kernel file */
-
-  kernel_fd = open(kernel_file, O_RDONLY);
-  if (kernel_fd < 0) {
-    fprintf(stderr, "%s: %s: %s\n", program, kernel_file, strerror(errno));
-    rv = EX_NOINPUT;
-    goto err;
-  }
-
-  kernel = mapfile(kernel_fd, &kernel_len, 1);
-  if (!kernel) {
-    fprintf(stderr, "%s: %s: %s\n", program, kernel_file, strerror(errno));
-    rv = EX_NOINPUT;
-    goto err;
-  }
-
-  if (kernel_len < 1024) {
-    fprintf(stderr, "%s: %s: kernel file too small\n", program, kernel_file);
-    rv = EX_NOINPUT;
-    errno = EINVAL;
-    goto err;
-  }
-
-  /* Pick apart the header... */
-
-  hdr = (struct setup_header *)(kernel + 0x1f1);
-  setup_len = (hdr->setup_sects + 1) << 9;
-  if (setup_len == 512)
-    setup_len += 2048;         /* Really old kernel */
-
-  if (rdle32(&hdr->header) != LINUX_MAGIC)
-    setup_ver = 0;             /* Ancient kernel */
-  else
-    setup_ver = rdle16(&hdr->version);
-
-  if (setup_ver >= 0x200 && (hdr->loadflags & LOADED_HIGH)) {
-    skrn.address = 0x100000;
-    ssup.address = 0x10000;
-    setup_space  = setup_ver >= 0x202 ? 0x10000 : 0xa000;
-  } else {
-    skrn.address = 0x10000;
-    ssup.address = 0x90000;
-    setup_space  = 0xa000;
-  }
-
-  if (setup_ver <= 0x200)
-    initrd_list = NULL;                /* No initrd for ancient kernel */
-
-  if (setup_ver >= 0x203)
-    initrd_max = rdle32(&hdr->initrd_addr_max);
-  else
-    initrd_max = 0x37ffffff;
-
-  if ((cmd = find_argument(cmdline, "mem="))) {
-    uint32_t mem = saturate32(suffix_number(cmd));
-    if (initrd_max >= mem)
-      initrd_max = mem-1;
-  }
-
-  if ((cmd = find_argument(cmdline, "vga="))) {
-    uint16_t vga;
-
-    switch (cmd[0] | 0x20) {
-    case 'a':                  /* "ask" */
-      vga = 0xfffd;
-      break;
-    case 'e':                  /* "ext" */
-      vga = 0xfffe;
-      break;
-    case 'n':                  /* "normal" */
-      vga = 0xffff;
-      break;
-    default:
-      vga = strtoul(cmd, NULL, 0);
-      break;
-    }
-    wrle16(vga, &hdr->vid_mode);
-  }
-
-  /* Process the initrd file(s) */
-
-  ninitrd = 0;
-  for (ip = initrd_list; ip; ip = ip->next)
-    ninitrd++;
-
-  if (ninitrd) {
-    ird = xcalloc(ninitrd, sizeof *ird);
-    for (i = 0; i < ninitrd; i++)
-      ird[i].fd = -1;
-  }
-
-  initrd_len = 0;
-  for (ip = initrd_list, i = 0; ip; ip = ip->next, i++) {
-    ird[i].fd = open(ip->str, O_RDONLY);
-    if (ird[i].fd < 0) {
-      fprintf(stderr, "%s: %s: %s", program, ip->str, strerror(errno));
-      rv = EX_NOINPUT;
-      goto err;
-    }
-
-    ird[i].seg.data = mapfile(ird[i].fd, &ird[i].seg.length, 0);
-    if (!ird[i].seg.data) {
-      fprintf(stderr, "%s: %s: %s", program, ip->str, strerror(errno));
-      rv = EX_NOINPUT;
-      goto err;
-    }
-
-    /* We need to pad the space between initrds to a 4-byte boundary.
-       This is safe because an mmap is always padded with zero
-       to a page boundary... */
-    if (i < ninitrd-1)
-      ird[i].seg.length = (ird[i].seg.length + 3) & ~3;
-
-    initrd_len += ird[i].seg.length;
-  }
-
-  /* Segment: relocation code */
-  /* We put this immediately after the kernel setup, in the memory
-     which will be reclaimed for setup. */
-  srel.next     = &ssup;
-  srel.address  = (ssup.address + setup_len + 15) & ~15;
-  srel.align    = 4;           /* 2**4 = 16 bytes */
-  srel.length   = reloc_size;
-  srel.sh_type  = SHT_PROGBITS;
-  srel.sh_flags = SHF_ALLOC|SHF_WRITE|SHF_EXECINSTR;
-  srel.name     = "reloc";
-  srel.data    = reloc;
-
-  /* Segment: Linux kernel setup */
-  ssup.next     = &scmd;
-  ssup.align    = 4;           /* 2**4 = 16 bytes */
-  ssup.length   = setup_len;
-  ssup.sh_type  = SHT_PROGBITS;
-  ssup.sh_flags = SHF_ALLOC|SHF_WRITE|SHF_EXECINSTR;
-  ssup.name     = "setup";
-  ssup.data     = kernel;
-  if (setup_ver >= 0x200)
-    hdr->type_of_loader = 0xff;        /* "Other modern loader" */
-
-  /* Segment: kernel command line */
-  scmd.next     = &skrn;
-  scmd.length   = strlen(cmdline)+1;
-  scmd.address  = (ssup.address + setup_space - scmd.length) & ~15;
-  scmd.align    = 4;           /* 2**4 = 16 bytes */
-  if (srel.address + reloc_size > scmd.address) {
-    /* Uh-oh, we're short on space... push the command line
-       higher. */
-    scmd.address = (srel.address + reloc_size + 15) & ~15;
-  }
-  scmd.sh_type  = SHT_PROGBITS;
-  scmd.sh_flags = SHF_ALLOC;
-  scmd.name     = "cmdline";
-  scmd.data     = cmdline;
-  if (setup_ver >= 0x202) {
-    wrle32(scmd.address, &hdr->cmd_line_ptr);
-  } else {
-    /* Old-style command line protocol */
-    wrle16(OLD_CMDLINE_MAGIC, (uint16_t *)(kernel+0x20));
-    wrle16(scmd.address - ssup.address, (uint16_t *)(kernel+0x22));
-  }
-  if (setup_ver >= 0x201) {
-    wrle16(scmd.address - ssup.address - 0x200, &hdr->heap_end_ptr);
-    hdr->loadflags |= CAN_USE_HEAP;
-  }
-
-  /* Segment: Linux kernel proper */
-  skrn.next     = ninitrd ? &ird[0].seg : NULL;
-  skrn.align    = 4;           /* 2**4 = 16 bytes */
-  skrn.length   = kernel_len - setup_len;
-  skrn.sh_type  = SHT_PROGBITS;
-  skrn.sh_flags = SHF_ALLOC;
-  skrn.name     = "kernel";
-  skrn.data     = kernel + setup_len;
-
-  /* Additional segments: initrd */
-  if (skrn.address < 0x100000)
-    initrd_addr = 0x100000;
-  else
-    initrd_addr = (skrn.address + skrn.length + 3) & ~3;
-
-  for (i = 0; i < ninitrd; i++) {
-    char *name;
-
-    ird[i].seg.next     = (i < ninitrd-1) ? &ird[i+1].seg : 0;
-    ird[i].seg.address  = initrd_addr;
-    ird[i].seg.align    = 2;   /* 2**2 = 4 bytes */
-    ird[i].seg.sh_type  = SHT_PROGBITS;
-    ird[i].seg.sh_flags = SHF_ALLOC;
-    xasprintf(&name, "initrd.%d", i);
-    ird[i].seg.name = name;
-
-    initrd_addr += ird[i].seg.length;
-  }
-  if (setup_ver >= 0x200)
-    wrle32(initrd_len, &hdr->ramdisk_size);
-
-  /* Set up the startup info */
-  wrle32(ninitrd ? ird[0].seg.address : 0, &info->rd_addr);
-  wrle32(initrd_len, &info->rd_len);
-  wrle32(initrd_max, &info->rd_maxaddr);
-  wrle32(ssup.address, &info->setup_addr);
-  wrle32(scmd.address, &info->cmdline_addr);
-
-  rv = opt.output(&srel, srel.address + sizeof *info, out);
+       struct initrd_info {
+               int fd;
+               struct segment seg;
+       } *ird = NULL;
+       int kernel_fd = -1;
+       char *kernel = NULL;
+       size_t kernel_len = 0;
+       struct segment srel, ssup, scmd, skrn;
+       struct startup_info *info = (void *)reloc;
+       struct setup_header *hdr;
+       size_t setup_len;
+       size_t initrd_len;
+       size_t initrd_addr;
+       int rv = EX_SOFTWARE;   /* Should never be returned... */
+       int ninitrd = 0;
+       int i;
+       const struct string_list *ip;
+       int setup_ver;          /* Setup protocol version */
+       int setup_space;        /* How much space for the setup */
+       const char *cmd;
+       uint32_t initrd_max;
+
+       /* Process the kernel file */
+
+       kernel_fd = open(kernel_file, O_RDONLY);
+       if (kernel_fd < 0) {
+               fprintf(stderr, "%s: %s: %s\n", program, kernel_file,
+                       strerror(errno));
+               rv = EX_NOINPUT;
+               goto err;
+       }
+
+       kernel = mapfile(kernel_fd, &kernel_len, 1);
+       if (!kernel) {
+               fprintf(stderr, "%s: %s: %s\n", program, kernel_file,
+                       strerror(errno));
+               rv = EX_NOINPUT;
+               goto err;
+       }
+
+       if (kernel_len < 1024) {
+               fprintf(stderr, "%s: %s: kernel file too small\n", program,
+                       kernel_file);
+               rv = EX_NOINPUT;
+               errno = EINVAL;
+               goto err;
+       }
+
+       /* Pick apart the header... */
+
+       hdr = (struct setup_header *)(kernel + 0x1f1);
+       setup_len = (hdr->setup_sects + 1) << 9;
+       if (setup_len == 512)
+               setup_len += 2048;      /* Really old kernel */
+
+       if (rdle32(&hdr->header) != LINUX_MAGIC)
+               setup_ver = 0;  /* Ancient kernel */
+       else
+               setup_ver = rdle16(&hdr->version);
+
+       if (setup_ver >= 0x200 && (hdr->loadflags & LOADED_HIGH)) {
+               skrn.address = 0x100000;
+               ssup.address = 0x10000;
+               setup_space = setup_ver >= 0x202 ? 0x10000 : 0xa000;
+       } else {
+               skrn.address = 0x10000;
+               ssup.address = 0x90000;
+               setup_space = 0xa000;
+       }
+
+       if (setup_ver <= 0x200)
+               initrd_list = NULL;     /* No initrd for ancient kernel */
+
+       if (setup_ver >= 0x203)
+               initrd_max = rdle32(&hdr->initrd_addr_max);
+       else
+               initrd_max = 0x37ffffff;
+
+       if ((cmd = find_argument(cmdline, "mem="))) {
+               uint32_t mem = saturate32(suffix_number(cmd));
+               if (initrd_max >= mem)
+                       initrd_max = mem - 1;
+       }
+
+       if ((cmd = find_argument(cmdline, "vga="))) {
+               uint16_t vga;
+
+               switch (cmd[0] | 0x20) {
+               case 'a':       /* "ask" */
+                       vga = 0xfffd;
+                       break;
+               case 'e':       /* "ext" */
+                       vga = 0xfffe;
+                       break;
+               case 'n':       /* "normal" */
+                       vga = 0xffff;
+                       break;
+               default:
+                       vga = strtoul(cmd, NULL, 0);
+                       break;
+               }
+               wrle16(vga, &hdr->vid_mode);
+       }
+
+       /* Process the initrd file(s) */
+
+       ninitrd = 0;
+       for (ip = initrd_list; ip; ip = ip->next)
+               ninitrd++;
+
+       if (ninitrd) {
+               ird = xcalloc(ninitrd, sizeof *ird);
+               for (i = 0; i < ninitrd; i++)
+                       ird[i].fd = -1;
+       }
+
+       initrd_len = 0;
+       for (ip = initrd_list, i = 0; ip; ip = ip->next, i++) {
+               ird[i].fd = open(ip->str, O_RDONLY);
+               if (ird[i].fd < 0) {
+                       fprintf(stderr, "%s: %s: %s", program, ip->str,
+                               strerror(errno));
+                       rv = EX_NOINPUT;
+                       goto err;
+               }
+
+               ird[i].seg.data = mapfile(ird[i].fd, &ird[i].seg.length, 0);
+               if (!ird[i].seg.data) {
+                       fprintf(stderr, "%s: %s: %s", program, ip->str,
+                               strerror(errno));
+                       rv = EX_NOINPUT;
+                       goto err;
+               }
+
+               /* We need to pad the space between initrds to a
+                  4-byte boundary.  This is safe because an mmap is
+                  always padded with zero to a page boundary... */
+               if (i < ninitrd - 1)
+                       ird[i].seg.length = (ird[i].seg.length + 3) & ~3;
+
+               initrd_len += ird[i].seg.length;
+       }
+
+       /* Segment: relocation code */
+       /* We put this immediately after the kernel setup, in the memory
+          which will be reclaimed for setup. */
+       srel.next = &ssup;
+       srel.address = (ssup.address + setup_len + 15) & ~15;
+       srel.align = 4;         /* 2**4 = 16 bytes */
+       srel.length = reloc_size;
+       srel.sh_type = SHT_PROGBITS;
+       srel.sh_flags = SHF_ALLOC | SHF_WRITE | SHF_EXECINSTR;
+       srel.name = "reloc";
+       srel.data = reloc;
+
+       /* Segment: Linux kernel setup */
+       ssup.next = &scmd;
+       ssup.align = 4;         /* 2**4 = 16 bytes */
+       ssup.length = setup_len;
+       ssup.sh_type = SHT_PROGBITS;
+       ssup.sh_flags = SHF_ALLOC | SHF_WRITE | SHF_EXECINSTR;
+       ssup.name = "setup";
+       ssup.data = kernel;
+       if (setup_ver >= 0x200)
+               hdr->type_of_loader = 0xff;     /* "Other modern loader" */
+
+       /* Segment: kernel command line */
+       scmd.next = &skrn;
+       scmd.length = strlen(cmdline) + 1;
+       scmd.address = (ssup.address + setup_space - scmd.length) & ~15;
+       scmd.align = 4;         /* 2**4 = 16 bytes */
+       if (srel.address + reloc_size > scmd.address) {
+               /* Uh-oh, we're short on space... push the command line
+                  higher. */
+               scmd.address = (srel.address + reloc_size + 15) & ~15;
+       }
+       scmd.sh_type = SHT_PROGBITS;
+       scmd.sh_flags = SHF_ALLOC;
+       scmd.name = "cmdline";
+       scmd.data = cmdline;
+       if (setup_ver >= 0x202) {
+               wrle32(scmd.address, &hdr->cmd_line_ptr);
+       } else {
+               /* Old-style command line protocol */
+               wrle16(OLD_CMDLINE_MAGIC, (uint16_t *) (kernel + 0x20));
+               wrle16(scmd.address - ssup.address,
+                      (uint16_t *) (kernel + 0x22));
+       }
+       if (setup_ver >= 0x201) {
+               wrle16(scmd.address - ssup.address - 0x200, &hdr->heap_end_ptr);
+               hdr->loadflags |= CAN_USE_HEAP;
+       }
+
+       /* Segment: Linux kernel proper */
+       skrn.next = ninitrd ? &ird[0].seg : NULL;
+       skrn.align = 4;         /* 2**4 = 16 bytes */
+       skrn.length = kernel_len - setup_len;
+       skrn.sh_type = SHT_PROGBITS;
+       skrn.sh_flags = SHF_ALLOC;
+       skrn.name = "kernel";
+       skrn.data = kernel + setup_len;
+
+       /* Additional segments: initrd */
+       if (skrn.address < 0x100000)
+               initrd_addr = 0x100000;
+       else
+               initrd_addr = (skrn.address + skrn.length + 3) & ~3;
+
+       for (i = 0; i < ninitrd; i++) {
+               char *name;
+
+               ird[i].seg.next = (i < ninitrd - 1) ? &ird[i + 1].seg : 0;
+               ird[i].seg.address = initrd_addr;
+               ird[i].seg.align = 2;   /* 2**2 = 4 bytes */
+               ird[i].seg.sh_type = SHT_PROGBITS;
+               ird[i].seg.sh_flags = SHF_ALLOC;
+               xasprintf(&name, "initrd.%d", i);
+               ird[i].seg.name = name;
+
+               initrd_addr += ird[i].seg.length;
+       }
+       if (setup_ver >= 0x200)
+               wrle32(initrd_len, &hdr->ramdisk_size);
+
+       /* Set up the startup info */
+       wrle32(ninitrd ? ird[0].seg.address : 0, &info->rd_addr);
+       wrle32(initrd_len, &info->rd_len);
+       wrle32(initrd_max, &info->rd_maxaddr);
+       wrle32(ssup.address, &info->setup_addr);
+       wrle32(scmd.address, &info->cmdline_addr);
+
+       rv = opt.output(&srel, srel.address + sizeof *info, out);
 
  err:
-  if (ird) {
-    for (i = 0; i < ninitrd; i++)
-      unmapfile(ird[i].fd, (void *)ird[i].seg.data, ird[i].seg.length);
-    free(ird);
-  }
-
-  unmapfile(kernel_fd, kernel, kernel_len);
-  return rv;
+       if (ird) {
+               for (i = 0; i < ninitrd; i++)
+                       unmapfile(ird[i].fd, (void *)ird[i].seg.data,
+                                 ird[i].seg.length);
+               free(ird);
+       }
+
+       unmapfile(kernel_fd, kernel, kernel_len);
+       return rv;
 }
diff --git a/main.c b/main.c
index 75a79c3..90c4e70 100644 (file)
--- a/main.c
+++ b/main.c
 const char *program;
 
 const struct option long_options[] = {
-  { "params",          1, 0, 'p' },
-  { "cmdline",         1, 0, 'p' },
-  { "commandline",     1, 0, 'p' },
-  { "initrd",          1, 0, 'i' },
-  { "output",          1, 0, 'o' },
-  { "elf",             0, 0, 'E' },
-  { "nbi",             0, 0, 'N' },
-  { "help",            0, 0, 'h' },
-  { 0, 0, 0, 0 }
+       {"params", 1, 0, 'p'},
+       {"cmdline", 1, 0, 'p'},
+       {"commandline", 1, 0, 'p'},
+       {"initrd", 1, 0, 'i'},
+       {"output", 1, 0, 'o'},
+       {"elf", 0, 0, 'E'},
+       {"nbi", 0, 0, 'N'},
+       {"help", 0, 0, 'h'},
+       {0, 0, 0, 0}
 };
+
 #define OPTSTRING "p:i:o:ENh"
 
 static void usage(int err)
 {
-  fprintf(stderr,
-          "Usage: %s [-ENh] [-p \"kernel_comandline\"] [-i initrd_filename]"
-          " [-o output_filename] kernel\n"
-          "  --params       -p    kernel commandline parameters\n"
-          "  --initrd       -i    initrd (multiple initrd options supported)\n"
-          "  --output       -o    output filename (default stdout)\n"
-          "  --elf          -E    output in ELF format (default)\n"
-          "  --nbi          -N    output in NBI format\n"
-          "  --help         -h    display this help text\n"
-          ,program);
-  exit(err);
+       fprintf(stderr,
+               "Usage: %s [options] kernel\n"
+               "  --params       -p    kernel commandline parameters\n"
+               "  --initrd       -i    initrd (multiple initrd options "
+               "supported)\n"
+               "  --output       -o    output filename (default stdout)\n"
+               "  --elf          -E    output in ELF format (default)\n"
+               "  --nbi          -N    output in NBI format\n"
+               "  --help         -h    display this help text\n",
+               program);
+       exit(err);
 }
 
 int main(int argc, char *argv[])
 {
-  int optch;
-  const char *kernel;
-  struct string_list *ird = NULL, **irdp = &ird, *ip;
-  FILE *out = stdout;
+       int optch;
+       const char *kernel;
+       struct string_list *ird = NULL, **irdp = &ird, *ip;
+       FILE *out = stdout;
 
-  program = argv[0];
+       program = argv[0];
 
-  opt.output = output_elf;
+       opt.output = output_elf;
 
-  while ( (optch = getopt_long(argc, argv, OPTSTRING, long_options, NULL))
-         != EOF ) {
-    switch (optch) {
-    case 'p':
-      opt.params = optarg;
-      break;
-    case 'i':
-      ip = xmalloc(sizeof *ip);
-      ip->str = optarg;
-      ip->next = NULL;
-      *irdp = ip;
-      irdp = &ip->next;
-      break;
-    case 'o':
-      if (optarg[0] == '-' && !optarg[1]) {
-       out = stdout;
-      } else {
-       out = fopen(optarg, "wb");
-       if (!out) {
-         fprintf(stderr, "%s: %s: %s\n", program, optarg, strerror(errno));
-         return EX_CANTCREAT;
+       while ((optch = getopt_long(argc, argv, OPTSTRING, long_options, NULL))
+              != EOF) {
+               switch (optch) {
+               case 'p':
+                       opt.params = optarg;
+                       break;
+               case 'i':
+                       ip = xmalloc(sizeof *ip);
+                       ip->str = optarg;
+                       ip->next = NULL;
+                       *irdp = ip;
+                       irdp = &ip->next;
+                       break;
+               case 'o':
+                       if (optarg[0] == '-' && !optarg[1]) {
+                               out = stdout;
+                       } else {
+                               out = fopen(optarg, "wb");
+                               if (!out) {
+                                       fprintf(stderr, "%s: %s: %s\n", program,
+                                               optarg, strerror(errno));
+                                       return EX_CANTCREAT;
+                               }
+                       }
+                       break;
+               case 'E':
+                       opt.output = output_elf;
+                       break;
+               case 'N':
+                       opt.output = output_nbi;
+                       break;
+               case 'h':
+                       usage(EX_USAGE);
+                       break;
+               default:
+                       usage(EX_USAGE);
+                       break;
+               }
        }
-      }
-      break;
-    case 'E':
-      opt.output = output_elf;
-      break;
-    case 'N':
-      opt.output = output_nbi;
-      break;
-    case 'h':
-      usage(EX_USAGE);
-      break;
-    default:
-      usage(EX_USAGE);
-      break;
-    }
-  }
 
-  if ((argc-optind) != 1)
-    usage(EX_USAGE);
+       if ((argc - optind) != 1)
+               usage(EX_USAGE);
 
-  kernel = argv[optind];
+       kernel = argv[optind];
 
-  if (!opt.params)
-    opt.params = "";
+       if (!opt.params)
+               opt.params = "";
 
-  return wrap_kernel(kernel, opt.params, ird, out);
+       return wrap_kernel(kernel, opt.params, ird, out);
 }
index 0f26ca6..370175e 100644 (file)
--- a/mapfile.c
+++ b/mapfile.c
 
 void *mapfile(int fd, size_t *len, int writable)
 {
-  struct stat st;
-  void *ptr;
+       struct stat st;
+       void *ptr;
 
-  if (fstat(fd, &st))
-    return NULL;
+       if (fstat(fd, &st))
+               return NULL;
 
-  *len = st.st_size;
+       *len = st.st_size;
 
-  if (writable)
-    ptr = mmap(NULL, st.st_size, PROT_READ|PROT_WRITE, MAP_PRIVATE, fd, 0);
-  else
-    ptr = mmap(NULL, st.st_size, PROT_READ, MAP_SHARED, fd, 0);
+       if (writable)
+               ptr =
+                   mmap(NULL, st.st_size, PROT_READ | PROT_WRITE, MAP_PRIVATE,
+                        fd, 0);
+       else
+               ptr = mmap(NULL, st.st_size, PROT_READ, MAP_SHARED, fd, 0);
 
-  return (ptr == MAP_FAILED) ? NULL : ptr;
+       return (ptr == MAP_FAILED) ? NULL : ptr;
 }
 
 void unmapfile(int fd, void *ptr, size_t len)
 {
-  if (ptr)
-    munmap(ptr, len);
-  if (fd >= 0)
-    close(fd);
+       if (ptr)
+               munmap(ptr, len);
+       if (fd >= 0)
+               close(fd);
 }
diff --git a/nbi.c b/nbi.c
index 57bf414..6f5cfac 100644 (file)
--- a/nbi.c
+++ b/nbi.c
@@ -54,7 +54,7 @@ int output_nbi(struct segment *segs, addr_t entry, FILE *out)
                if (is_real_seg(s)) {
                        if (s->address >= base+512)
                                break;  /* Found a safe area */
-                       
+
                        base = (s->address + s->length + 511) & ~511;
                }
        }
@@ -83,7 +83,7 @@ int output_nbi(struct segment *segs, addr_t entry, FILE *out)
                           allow generation of NOBITS segments. */
                        ihdr.filesz = s->length;
                        ihdr.memsz  = s->length;
-                       
+
                        fwrite(&ihdr, 1, sizeof ihdr, out);
                        offset += sizeof ihdr;
                }
diff --git a/nbi.h b/nbi.h
index d5a908b..af95283 100644 (file)
--- a/nbi.h
+++ b/nbi.h
 #define NBI_MAGIC 0x1b031336
 
 struct nbi_header {
-  uint32_t magic;
-  uint32_t flags;
-  uint16_t header_off, header_seg;
-  uint32_t entry;
+       uint32_t magic;
+       uint32_t flags;
+       uint16_t header_off, header_seg;
+       uint32_t entry;
 };
 
 #define NBI_HFLAG_RETURN       0x00000100
 #define NBI_HFLAG_PROTMODE     0x80000000
 
 struct nbi_image_header {
-  uint8_t  lengths;
-  uint8_t  tags;
-  uint8_t  resv;
-  uint8_t  flags;
-  uint32_t load_addr;
-  uint32_t filesz;
-  uint32_t memsz;
+       uint8_t lengths;
+       uint8_t tags;
+       uint8_t resv;
+       uint8_t flags;
+       uint32_t load_addr;
+       uint32_t filesz;
+       uint32_t memsz;
 };
 
 #define NBI_IFLAG_ADDR_LAST    0x01
index 2037343..707ac70 100644 (file)
 extern const char *program;
 
 struct opt {
-  const char *params;
-  int (*output)(struct segment *, addr_t, FILE *);
+       const char *params;
+       int (*output) (struct segment *, addr_t, FILE *);
 } opt;
 
 struct string_list {
-  struct string_list *next;
-  const char *str;
+       struct string_list *next;
+       const char *str;
 };
 
 /* linux.c */
index bbafe9d..6d57a59 100644 (file)
--- a/xmalloc.c
+++ b/xmalloc.c
 
 void *xmalloc(size_t size)
 {
-  void *p = malloc(size);
+       void *p = malloc(size);
 
-  if ( !p ) {
-    fprintf(stderr, "%s: %s\n", program, strerror(errno));
-    exit(EX_OSERR);
-  }
+       if (!p) {
+               fprintf(stderr, "%s: %s\n", program, strerror(errno));
+               exit(EX_OSERR);
+       }
 
-  return p;
+       return p;
 }
 
 void *xcalloc(size_t nmemb, size_t size)
 {
-  void *p = calloc(nmemb, size);
+       void *p = calloc(nmemb, size);
 
-  if ( !p ) {
-    fprintf(stderr, "%s: %s\n", program, strerror(errno));
-    exit(EX_OSERR);
-  }
+       if (!p) {
+               fprintf(stderr, "%s: %s\n", program, strerror(errno));
+               exit(EX_OSERR);
+       }
 
-  return p;
+       return p;
 }
 
 int xasprintf(char **strp, const char *fmt, ...)
 {
-  va_list va;
-  int n;
+       va_list va;
+       int n;
 
-  va_start(va, fmt);
-  n = vasprintf(strp, fmt, va);
-  va_end(va);
+       va_start(va, fmt);
+       n = vasprintf(strp, fmt, va);
+       va_end(va);
 
-  if (n < 0) {
-    fprintf(stderr, "%s: %s\n", program, strerror(errno));
-    exit(EX_OSERR);
-  }
+       if (n < 0) {
+               fprintf(stderr, "%s: %s\n", program, strerror(errno));
+               exit(EX_OSERR);
+       }
 
-  return n;
+       return n;
 }