libinstaller/syslxmod.c

   1 /* ----------------------------------------------------------------------- *
   2  *
   3  *   Copyright 1998-2008 H. Peter Anvin - All Rights Reserved
   4  *   Copyright 2009-2010 Intel Corporation; author H. Peter Anvin
   5  *
   6  *   This program is free software; you can redistribute it and/or modify
   7  *   it under the terms of the GNU General Public License as published by
   8  *   the Free Software Foundation, Inc., 53 Temple Place Ste 330,
   9  *   Boston MA 02111-1307, USA; either version 2 of the License, or
  10  *   (at your option) any later version; incorporated herein by reference.
  11  *
  12  * ----------------------------------------------------------------------- */
  13
  14 /*
  15  * syslxmod.c - Code to provide a SYSLINUX code set to an installer.
  16  */
  17
  18 #define _XOPEN_SOURCE 500       /* Required on glibc 2.x */
  19 #define _BSD_SOURCE
  20 #include <stdio.h>
  21 #include <inttypes.h>
  22 #include <string.h>
  23 #include <stddef.h>
  24 #include <stdlib.h>
  25
  26 #include "syslinux.h"
  27 #include "syslxint.h"
  28
  29
  30 /*
  31  * Generate sector extents
  32  */
  33 static void generate_extents(struct syslinux_extent *ex, int nptrs,
  34                              const sector_t *sectp, int nsect)
  35 {
  36     uint32_t addr = 0x8000;     /* ldlinux.sys starts loading here */
  37     uint32_t base;
  38     sector_t sect, lba;
  39     unsigned int len;
  40
  41     base = addr;
  42     len = lba = 0;
  43
  44     memset(ex, 0, nptrs * sizeof *ex);
  45
  46     while (nsect) {
  47         sect = *sectp++;
  48
  49         if (len) {
  50             uint32_t xbytes = (len + 1) * SECTOR_SIZE;
  51
  52             if (sect == lba + len && xbytes < 65536 &&
  53                 ((addr ^ (base + xbytes - 1)) & 0xffff0000) == 0) {
  54                 /* We can add to the current extent */
  55                 len++;
  56                 goto next;
  57             }
  58
  59             set_64_sl(&ex->lba, lba);
  60             set_16_sl(&ex->len, len);
  61             ex++;
  62         }
  63
  64         base = addr;
  65         lba  = sect;
  66         len  = 1;
  67
  68     next:
  69         addr += SECTOR_SIZE;
  70         nsect--;
  71     }
  72
  73     if (len) {
  74         set_64_sl(&ex->lba, lba);
  75         set_16_sl(&ex->len, len);
  76         ex++;
  77     }
  78 }
  79
  80 /*
  81  * Form a pointer based on a 16-bit patcharea/epa field
  82  */
  83 static inline void *ptr(void *img, uint16_t *offset_p)
  84 {
  85     return (char *)img + get_16_sl(offset_p);
  86 }
  87
  88 /*
  89  * This patches the boot sector and the beginning of ldlinux.sys
  90  * based on an ldlinux.sys sector map passed in.  Typically this is
  91  * handled by writing ldlinux.sys, mapping it, and then overwrite it
  92  * with the patched version.  If this isn't safe to do because of
  93  * an OS which does block reallocation, then overwrite it with
  94  * direct access since the location is known.
  95  *
  96  * Returns the number of modified bytes in ldlinux.sys if successful,
  97  * otherwise -1.
  98  */
  99 #define NADV 2
 100
 101 int syslinux_patch(const sector_t *sectp, int nsectors,
 102                    int stupid, int raid_mode,
 103                    const char *subdir, const char *subvol)
 104 {
 105     struct patch_area *patcharea;
 106     struct ext_patch_area *epa;
 107     struct syslinux_extent *ex;
 108     uint32_t *wp;
 109     int nsect = ((boot_image_len + SECTOR_SIZE - 1) >> SECTOR_SHIFT) + 2;
 110     uint32_t csum;
 111     int i, dw, nptrs;
 112     struct fat_boot_sector *sbs = (struct fat_boot_sector *)boot_sector;
 113     uint64_t *advptrs;
 114
 115     if (nsectors < nsect)
 116         return -1;              /* The actual file is too small for content */
 117
 118     /* Search for LDLINUX_MAGIC to find the patch area */
 119     for (wp = (uint32_t *)boot_image; get_32_sl(wp) != LDLINUX_MAGIC;
 120          wp++)
 121         ;
 122     patcharea = (struct patch_area *)wp;
 123     epa = ptr(boot_image, &patcharea->epaoffset);
 124
 125     /* First sector need pointer in boot sector */
 126     set_32(ptr(sbs, &epa->sect1ptr0), sectp[0]);
 127     set_32(ptr(sbs, &epa->sect1ptr1), sectp[0] >> 32);
 128     sectp++;
 129
 130     /* Handle RAID mode */
 131     if (raid_mode) {
 132         /* Patch in INT 18h = CD 18 */
 133         set_16(ptr(sbs, &epa->raidpatch), 0x18CD);
 134     }
 135
 136     /* Set up the totals */
 137     dw = boot_image_len >> 2;   /* COMPLETE dwords, excluding ADV */
 138     set_16_sl(&patcharea->data_sectors, nsect - 2); /* Not including ADVs */
 139     set_16_sl(&patcharea->adv_sectors, 2);      /* ADVs need 2 sectors */
 140     set_32_sl(&patcharea->dwords, dw);
 141
 142     /* Handle Stupid mode */
 143     if (stupid) {
 144         /* Access only one sector at a time */
 145         set_16_sl(&patcharea->maxtransfer, 1);
 146     }
 147
 148     /* Set the sector extents */
 149     ex = ptr(boot_image, &epa->secptroffset);
 150     nptrs = get_16_sl(&epa->secptrcnt);
 151
 152     if (nsect > nptrs) {
 153         /* Not necessarily an error in this case, but a general problem */
 154         fprintf(stderr, "Insufficient extent space, build error!\n");
 155         exit(1);
 156     }
 157
 158     /* -1 for the pointer in the boot sector, -2 for the two ADVs */
 159     generate_extents(ex, nptrs, sectp, nsect-1-2);
 160
 161     /* ADV pointers */
 162     advptrs = ptr(boot_image, &epa->advptroffset);
 163     set_64_sl(&advptrs[0], sectp[nsect-1-2]);
 164     set_64_sl(&advptrs[1], sectp[nsect-1-1]);
 165
 166     /* Poke in the base directory path */
 167     if (subdir) {
 168         int sublen = strlen(subdir) + 1;
 169         if (get_16_sl(&epa->dirlen) < sublen) {
 170             fprintf(stderr, "Subdirectory path too long... aborting install!\n");
 171             exit(1);
 172         }
 173         memcpy_to_sl(ptr(boot_image, &epa->diroffset), subdir, sublen);
 174     }
 175
 176     /* Poke in the subvolume information */
 177     if (subvol) {
 178         int sublen = strlen(subvol) + 1;
 179         if (get_16_sl(&epa->subvollen) < sublen) {
 180             fprintf(stderr, "Subvol name too long... aborting install!\n");
 181             exit(1);
 182         }
 183         memcpy_to_sl(ptr(boot_image, &epa->subvoloffset), subvol, sublen);
 184     }
 185
 186     /* Now produce a checksum */
 187     set_32_sl(&patcharea->checksum, 0);
 188
 189     csum = LDLINUX_MAGIC;
 190     for (i = 0, wp = (uint32_t *)boot_image; i < dw; i++, wp++)
 191         csum -= get_32_sl(wp);  /* Negative checksum */
 192
 193     set_32_sl(&patcharea->checksum, csum);
 194
 195     /*
 196      * Assume all bytes modified.  This can be optimized at the expense
 197      * of keeping track of what the highest modified address ever was.
 198      */
 199     return dw << 2;
 200 }