kmodsrc/helper.c

   1 /*  Copyright (C) 2008  Jeffrey Brian Arnold <jbarnold@mit.edu>
   2  *
   3  *  This program is free software; you can redistribute it and/or modify
   4  *  it under the terms of the GNU General Public License, version 2.
   5  *
   6  *  This program is distributed in the hope that it will be useful,
   7  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
   8  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   9  *  GNU General Public License for more details.
  10  *
  11  *  You should have received a copy of the GNU General Public License
  12  *  along with this program; if not, write to the Free Software
  13  *  Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
  14  *  02110-1301, USA.
  15  */
  16
  17 #include "modcommon.h"
  18 #include "helper.h"
  19 #include "jumps.h"
  20 #include "nops.h"
  21 #include <linux/kthread.h>
  22
  23 /* defined by modcommon.c */
  24 extern int debug;
  25
  26 /* defined by ksplice-create */
  27 extern struct ksplice_size ksplice_sizes;
  28
  29 #undef max
  30 #define max(a, b) ((a) > (b) ? (a) : (b))
  31
  32 int init_module(void)
  33 {
  34         printk("ksplice_h: Preparing and checking %s\n", ksplice_name);
  35
  36         if (ksplice_do_helper() != 0)
  37                 return -1;
  38
  39         if (ksplice_do_primary() != 0)
  40                 return -1;
  41
  42         return 0;
  43 }
  44
  45 void cleanup_module(void)
  46 {
  47         clear_list(&reloc_namevals, struct reloc_nameval, list);
  48         clear_list(&reloc_addrmaps, struct reloc_addrmap, list);
  49         if (ksplice_state == KSPLICE_PREPARING)
  50                 clear_list(&safety_records, struct safety_record, list);
  51 }
  52
  53 int ksplice_do_helper(void)
  54 {
  55         struct ksplice_size *s;
  56         int i, record_count = 0, ret;
  57         char *finished;
  58         int numfinished, oldfinished = 0;
  59         int restart_count = 0, stage = 1;
  60
  61         if (process_ksplice_relocs(1) != 0)
  62                 return -1;
  63
  64         for (s = &ksplice_sizes; s->name != NULL; s++) {
  65                 record_count++;
  66         }
  67
  68         /* old kernels do not have kcalloc */
  69         finished = ksplice_kcalloc(record_count);
  70
  71 start:
  72         for (s = &ksplice_sizes, i = 0; s->name != NULL; s++, i++) {
  73                 if (s->size == 0)
  74                         finished[i] = 1;
  75                 if (finished[i])
  76                         continue;
  77
  78                 ret = search_for_match(s, &stage);
  79                 if (ret < 0) {
  80                         kfree(finished);
  81                         return ret;
  82                 } else if (ret == 0) {
  83                         finished[i] = 1;
  84                 }
  85         }
  86
  87         numfinished = 0;
  88         for (i = 0; i < record_count; i++) {
  89                 if (finished[i])
  90                         numfinished++;
  91         }
  92         if (numfinished == record_count) {
  93                 kfree(finished);
  94                 return 0;
  95         }
  96
  97         if (oldfinished == numfinished) {
  98                 if (stage < 3) {
  99                         stage++;
 100                         goto start;
 101                 }
 102                 print_abort("run-pre: could not match some sections");
 103                 kfree(finished);
 104                 return -1;
 105         }
 106         oldfinished = numfinished;
 107
 108         if (restart_count < 20) {
 109                 restart_count++;
 110                 goto start;
 111         }
 112         print_abort("run-pre: restart limit exceeded");
 113         kfree(finished);
 114         return -1;
 115 }
 116
 117 /* old kernels do not have kcalloc */
 118 void *ksplice_kcalloc(int size)
 119 {
 120         char *mem = kmalloc(size, GFP_KERNEL);
 121         int i;
 122         for (i = 0; i < size; i++) {
 123                 mem[i] = 0;
 124         }
 125         return mem;
 126 }
 127
 128 int search_for_match(struct ksplice_size *s, int *stage)
 129 {
 130         int i, saved_debug;
 131         long run_addr;
 132         LIST_HEAD(vals);
 133         struct candidate_val *v;
 134
 135         for (i = 0; i < s->num_sym_addrs; i++) {
 136                 add_candidate_val(&vals, s->sym_addrs[i]);
 137         }
 138
 139         compute_address(s->name, &vals);
 140         if (*stage <= 1 && !singular(&vals)) {
 141                 release_vals(&vals);
 142                 return 1;
 143         }
 144
 145         if (debug >= 3) {
 146                 printk("ksplice_h: run-pre: starting sect search for %s\n",
 147                        s->name);
 148         }
 149
 150         list_for_each_entry(v, &vals, list) {
 151                 run_addr = v->val;
 152
 153                 yield();
 154                 if (try_addr(s, run_addr, s->thismod_addr, !singular(&vals))) {
 155                         release_vals(&vals);
 156                         return 0;
 157                 }
 158         }
 159         release_vals(&vals);
 160
 161         if (*stage <= 2)
 162                 return 1;
 163
 164         saved_debug = debug;
 165         debug = 0;
 166         brute_search_all_mods(s);
 167         debug = saved_debug;
 168         return 1;
 169 }
 170
 171 int
 172 try_addr(struct ksplice_size *s, long run_addr, long pre_addr,
 173          int create_nameval)
 174 {
 175         struct safety_record *tmp;
 176
 177         if (run_pre_cmp(run_addr, pre_addr, s->size, 0) != 0) {
 178                 set_temp_myst_relocs(NOVAL);
 179                 if (debug >= 1) {
 180                         printk("ksplice_h: run-pre: sect %s does not match ",
 181                                s->name);
 182                         printk("(r_a=%08lx p_a=%08lx s=%ld)\n",
 183                                run_addr, pre_addr, s->size);
 184                         printk("ksplice_h: run-pre: ");
 185                         run_pre_cmp(run_addr, pre_addr, s->size, 1);
 186                         printk("\n");
 187                 }
 188         } else {
 189                 set_temp_myst_relocs(VAL);
 190
 191                 if (debug >= 3) {
 192                         printk("ksplice_h: run-pre: found sect %s=%08lx\n",
 193                                s->name, run_addr);
 194                 }
 195
 196                 tmp = kmalloc(sizeof(*tmp), GFP_KERNEL);
 197                 tmp->addr = run_addr;
 198                 tmp->size = s->size;
 199                 tmp->care = 0;
 200                 list_add(&tmp->list, &safety_records);
 201
 202                 if (create_nameval) {
 203                         struct reloc_nameval *nv = find_nameval(s->name, 1);
 204                         nv->val = run_addr;
 205                         nv->status = VAL;
 206                 }
 207
 208                 return 1;
 209         }
 210         return 0;
 211 }
 212
 213 int run_pre_cmp(long run_addr, long pre_addr, int size, int rerun)
 214 {
 215         int run_o = 0, pre_o = 0, lenient = 0, prev_c3 = 0, recent_5b = 0;
 216         unsigned char run, pre;
 217         struct reloc_addrmap *map;
 218
 219         if (size == 0)
 220                 return 1;
 221
 222         while (run_o < size && pre_o < size) {
 223                 if (lenient > 0)
 224                         lenient--;
 225                 if (prev_c3 > 0)
 226                         prev_c3--;
 227                 if (recent_5b > 0)
 228                         recent_5b--;
 229
 230                 if (!virtual_address_mapped(run_addr + run_o))
 231                         return 1;
 232
 233                 if ((map = find_addrmap(pre_addr + pre_o)) != NULL) {
 234                         if (handle_myst_reloc
 235                             (pre_addr, &pre_o, run_addr, &run_o, map,
 236                              rerun) == 1)
 237                                 return 1;
 238                         continue;
 239                 }
 240
 241                 if (match_nop(run_addr, &run_o) || match_nop(pre_addr, &pre_o))
 242                         continue;
 243
 244                 run = *(unsigned char *)(run_addr + run_o);
 245                 pre = *(unsigned char *)(pre_addr + pre_o);
 246
 247                 if (rerun)
 248                         printk("%02x/%02x ", run, pre);
 249
 250                 if (run == pre) {
 251                         if (pre == 0xc3)
 252                                 prev_c3 = 1 + 1;
 253                         if (pre == 0x5b)
 254                                 recent_5b = 10 + 1;
 255                         if (jumplen[pre])
 256                                 lenient = max(jumplen[pre] + 1, lenient);
 257                         pre_o++, run_o++;
 258                         continue;
 259                 }
 260
 261                 if (prev_c3 && recent_5b)
 262                         return 0;
 263                 if (jumplen[run] && jumplen[pre]) {
 264                         run_o += 1 + jumplen[run];
 265                         pre_o += 1 + jumplen[pre];
 266                         continue;
 267                 }
 268                 if (lenient) {
 269                         pre_o++, run_o++;
 270                         continue;
 271                 }
 272                 if (rerun) {
 273                         printk("[p_o=%08x] ! %02x/%02x %02x/%02x",
 274                                pre_o,
 275                                *(unsigned char *)(run_addr + run_o + 1),
 276                                *(unsigned char *)(pre_addr + pre_o + 1),
 277                                *(unsigned char *)(run_addr + run_o + 2),
 278                                *(unsigned char *)(pre_addr + pre_o + 2));
 279                 }
 280                 return 1;
 281         }
 282         return 0;
 283 }
 284
 285 int
 286 handle_myst_reloc(long pre_addr, int *pre_o, long run_addr,
 287                   int *run_o, struct reloc_addrmap *map, int rerun)
 288 {
 289         int expected;
 290         int offset = (int)(pre_addr + *pre_o - map->addr);
 291         long run_reloc;
 292         long run_reloc_addr;
 293         run_reloc_addr = run_addr + *run_o - offset;
 294         if (map->size == 4) {
 295                 run_reloc = *(int *)run_reloc_addr;
 296         } else if (map->size == 8) {
 297                 run_reloc = *(long long *)run_reloc_addr;
 298         } else {
 299                 BUG();
 300         }
 301
 302         if (debug >= 3 && !rerun) {
 303                 printk("ksplice_h: run-pre: reloc at r_a=%08lx p_o=%08x: ",
 304                        run_addr, *pre_o);
 305                 printk("%s=%08lx (A=%08lx *r=%08lx)\n",
 306                        map->nameval->name, map->nameval->val,
 307                        map->addend, run_reloc);
 308         }
 309
 310         if (!starts_with(map->nameval->name, ".rodata.str")) {
 311                 expected = run_reloc - map->addend;
 312                 if ((int)run_reloc == 0x77777777)
 313                         return 1;
 314                 if (map->flags & PCREL)
 315                         expected += run_reloc_addr;
 316                 if (map->nameval->status == NOVAL) {
 317                         map->nameval->val = expected;
 318                         map->nameval->status = TEMP;
 319                 } else if (map->nameval->val != expected) {
 320                         if (rerun)
 321                                 return 1;
 322                         printk("ksplice_h: pre-run reloc: Expected %s=%08x!\n",
 323                                map->nameval->name, expected);
 324                         return 1;
 325                 }
 326         }
 327
 328         *pre_o += map->size - offset;
 329         *run_o += map->size - offset;
 330         return 0;
 331 }
 332
 333 /* TODO: The recommended way to pad 64bit code is to use NOPs preceded by
 334    maximally four 0x66 prefixes.  */
 335 int match_nop(long addr, int *o)
 336 {
 337         int i, j;
 338         for (i = NUM_NOPS - 1; i >= 0; i--) {
 339                 for (j = 0; j < i + 1; j++) {
 340                         if (!virtual_address_mapped(addr + *o + j))
 341                                 break;
 342                         if (*(unsigned char *)(addr + *o + j) != nops[i][j])
 343                                 break;
 344                 }
 345                 if (j == i + 1) {
 346                         *o += j;
 347                         return 1;
 348                 }
 349
 350         }
 351         return 0;
 352 }
 353
 354 void brute_search_all_mods(struct ksplice_size *s)
 355 {
 356         struct module *m;
 357         list_for_each_entry(m, &(THIS_MODULE->list), list) {
 358                 if (!starts_with(m->name, ksplice_name)
 359                     && !ends_with(m->name, "_helper")) {
 360                         if (brute_search(s, m->module_core, m->core_size) == 0)
 361                                 return;
 362                         if (brute_search(s, m->module_init, m->init_size) == 0)
 363                                 return;
 364                 }
 365         }
 366 }