commands/swifi/extra.c

   1 /*
   2 Declaration for Linux kernel compatibility
   3 */
   4
   5 #include <assert.h>
   6 #include <stdarg.h>
   7 #include <stdio.h>
   8 #include <stdlib.h>
   9 #include <sys/types.h>
  10 #include <sys/ptrace.h>
  11
  12 #include "extra.h"
  13
  14 pid_t victim_pid= -1;
  15 char *victim_exe= NULL;
  16
  17 #define TRAP_BIT        (0x80000000)
  18
  19 static struct nlist *exe_nlist;
  20 static int exe_nlist_n;
  21
  22 /* unsigned long __get_free_page(int type) { assert(0); } */
  23 /* void *kmalloc(size_t size, int type) { assert(0); } */
  24 void free_page(unsigned long page) { assert(0); }
  25 /* void kfree(void *mem) { assert(0); } */
  26 void vfree(void *mem) { assert(0); }
  27
  28 size_t strncpy_from_user(char *addr, const char *user_name, size_t size)
  29 { assert(0); }
  30
  31 /* void lock_kernel(void) { assert(0); } */
  32 /* void unlock_kernel(void) { assert(0); } */
  33 void __asm__(char *str) { assert(0); }
  34
  35 extern void *__vmalloc(unsigned long size, int gfp_mask, pgprot_t prot)
  36 { assert(0); }
  37
  38 #if 0
  39 void kallsyms_sections(void *infop,
  40         int (*fp)(void *token, const char *modname, const char *secname,
  41               ElfW(Addr) secstart, ElfW(Addr) secend, ElfW(Word) secflags))
  42 { assert(0); }
  43 #endif
  44
  45 unsigned long __generic_copy_to_user(void *x, const void *y, unsigned long z)
  46 { assert(0); }
  47 unsigned long __generic_copy_from_user(void *x, const void *y, unsigned long z)
  48 { assert(0); }
  49
  50 /* void read_lock(struct lock *lock) { assert(0); } */
  51 /* void read_unlock(struct lock *lock) { assert(0); } */
  52 void udelay(unsigned long usecs) { assert(0); }
  53 int copy_to_user(void * result_record, void *res, size_t size)
  54 {
  55         memcpy(result_record, res, size);
  56         return 0;
  57 }
  58
  59 void panic(char *str) { assert(0); }
  60
  61 void printk(char *fmt, ...)
  62 {
  63         va_list ap;
  64
  65         va_start(ap, fmt);
  66         vfprintf(stderr, fmt, ap);
  67         va_end(ap);
  68 }
  69
  70 int kallsyms_address_to_symbol(db_expr_t off,
  71     const char * *mod_name, unsigned long *mod_start, unsigned long *mod_end,
  72     const char * *sec_name, unsigned long *sec_start, unsigned long *sec_end,
  73     const char * *sym_name, unsigned long *sym_start, unsigned long *sym_end)
  74 {
  75         static char name[sizeof(((struct nlist *)0)->n_name)+1];
  76
  77         int i;
  78         unsigned long btext, etext;
  79         struct nlist *below, *above;
  80
  81         off &= ~TRAP_BIT;
  82         load_nlist(victim_exe, &btext, &etext);
  83         below= above= NULL;
  84         for (i= 0; i<exe_nlist_n; i++)
  85         {
  86                 if ((exe_nlist[i].n_sclass & N_SECT) != N_TEXT)
  87                         continue;
  88                 if (exe_nlist[i].n_value <= off)
  89                 {
  90                         if (!below || exe_nlist[i].n_value > below->n_value)
  91                                 below= &exe_nlist[i];
  92                 }
  93                 if (exe_nlist[i].n_value > off)
  94                 {
  95                         if (!above || exe_nlist[i].n_value < above->n_value)
  96                                 above= &exe_nlist[i];
  97                 }
  98         }
  99 #if 0
 100         if (below)
 101         {
 102                 printf("found '%.*s' at 0x%x\n", sizeof(below->n_name),
 103                         below->n_name, below->n_value);
 104         }
 105         if (above)
 106         {
 107                 printf("found '%.*s' at 0x%x\n", sizeof(above->n_name),
 108                         above->n_name, above->n_value);
 109         }
 110 #endif
 111
 112         btext |= TRAP_BIT;
 113         etext |= TRAP_BIT;
 114
 115         *mod_name = victim_exe;
 116         *mod_start = btext;
 117         *mod_end = etext;
 118         *sec_name = ".text";
 119         *sec_start = btext;
 120         *sec_end = etext;
 121
 122         assert(below && above);
 123
 124         memcpy(name, below->n_name, sizeof(below->n_name));
 125         name[sizeof(below->n_name)]= '\0';
 126         *sym_name= name;
 127
 128         *sym_start= below->n_value | TRAP_BIT;
 129         *sym_end= above->n_value | TRAP_BIT;
 130
 131         return 1;
 132 }
 133
 134 struct module *module_list;
 135 struct task_struct *task_list;
 136 struct lock tasklist_lock;
 137
 138 unsigned long text_read_ul(void *addr)
 139 {
 140         int i;
 141         unsigned long value;
 142
 143         for (i= 0; i<sizeof(value); i++)
 144         {
 145                 ((unsigned char *)&value)[i]= text_read_ub((char *)addr+i);
 146         }
 147         return value;
 148 }
 149
 150 unsigned char text_read_ub(void *addr)
 151 {
 152         int v;
 153         unsigned long vaddr;
 154
 155         vaddr= (unsigned long)addr;
 156         vaddr &= ~TRAP_BIT;
 157         v= ptrace(T_READB_INS, victim_pid, vaddr, 0);
 158         if (v < 0)
 159         {
 160                 fprintf(stderr,
 161         "text_read_ub: trace T_READB_INS failed on pid %d, addr 0x%x: %s\n",
 162                         victim_pid, vaddr, strerror(errno));
 163                 exit(1);
 164         }
 165         return v;
 166 }
 167
 168 void text_write_ul(void *addr, unsigned long value)
 169 {
 170         int i;
 171
 172         for (i= 0; i<sizeof(value); i++)
 173         {
 174                 text_write_ub((char *)addr+i, ((unsigned char *)&value)[i]);
 175         }
 176 }
 177
 178 void text_write_ub(void *addr, unsigned char value)
 179 {
 180         int v;
 181         unsigned long vaddr;
 182
 183         vaddr= (unsigned long)addr;
 184         vaddr &= ~TRAP_BIT;
 185         v= ptrace(T_WRITEB_INS, victim_pid, vaddr, value);
 186         if (v < 0)
 187         {
 188                 fprintf(stderr,
 189         "text_read_ub: trace T_WRITEB_INS failed on pid %d, addr 0x%x: %s\n",
 190                         victim_pid, vaddr, strerror(errno));
 191                 exit(1);
 192         }
 193 }
 194
 195 void load_nlist(exe_name, btextp, etextp)
 196 char *exe_name;
 197 unsigned long *btextp;
 198 unsigned long *etextp;
 199 {
 200         int i;
 201         unsigned long btext, etext;
 202
 203         if (!exe_nlist)
 204         {
 205                 exe_nlist_n= read_nlist(exe_name, &exe_nlist);
 206                 if (exe_nlist_n <= 0)
 207                 {
 208                         if (exe_nlist_n == -1)
 209                         {
 210                                 fprintf(stderr,
 211                                 "error reading name list from '%s': %s\n",
 212                                         exe_name, strerror(errno));
 213                         }
 214                         else
 215                                 fprintf(stderr, "no name list in '%s'\n",
 216                                         exe_name);
 217                         exit(1);
 218                 }
 219         }
 220
 221         if (!btextp && !etextp)
 222                 return;
 223
 224         etext= 0;
 225         btext= (unsigned long)-1;
 226         for (i= 0; i<exe_nlist_n; i++)
 227         {
 228                 if ((exe_nlist[i].n_sclass & N_SECT) != N_TEXT)
 229                         continue;
 230                 if (exe_nlist[i].n_value < btext)
 231                         btext= exe_nlist[i].n_value;
 232                 if (exe_nlist[i].n_value > etext)
 233                         etext= exe_nlist[i].n_value;
 234         }
 235
 236         if (btext >= etext)
 237         {
 238                 fprintf(stderr, "Bad btext (0x%x) or etext (0x%x) in %d\n",
 239                         btext, etext, exe_name);
 240                 exit(1);
 241         }
 242
 243         btext |= TRAP_BIT;
 244         etext |= TRAP_BIT;
 245
 246         if (btextp)
 247                 *btextp= btext;
 248         if (etextp)
 249                 *etextp= etext;
 250 }