sys/dev/raid/vinum/vinummemory.c

   1 /*-
   2  * Copyright (c) 1997, 1998
   3  *      Nan Yang Computer Services Limited.  All rights reserved.
   4  *
   5  *  This software is distributed under the so-called ``Berkeley
   6  *  License'':
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  * 3. All advertising materials mentioning features or use of this software
  17  *    must display the following acknowledgement:
  18  *      This product includes software developed by Nan Yang Computer
  19  *      Services Limited.
  20  * 4. Neither the name of the Company nor the names of its contributors
  21  *    may be used to endorse or promote products derived from this software
  22  *    without specific prior written permission.
  23  *
  24  * This software is provided ``as is'', and any express or implied
  25  * warranties, including, but not limited to, the implied warranties of
  26  * merchantability and fitness for a particular purpose are disclaimed.
  27  * In no event shall the company or contributors be liable for any
  28  * direct, indirect, incidental, special, exemplary, or consequential
  29  * damages (including, but not limited to, procurement of substitute
  30  * goods or services; loss of use, data, or profits; or business
  31  * interruption) however caused and on any theory of liability, whether
  32  * in contract, strict liability, or tort (including negligence or
  33  * otherwise) arising in any way out of the use of this software, even if
  34  * advised of the possibility of such damage.
  35  *
  36  * $Id: vinummemory.c,v 1.25 2000/05/04 01:57:48 grog Exp grog $
  37  * $FreeBSD: src/sys/dev/vinum/vinummemory.c,v 1.22.2.1 2000/06/02 04:26:11 grog Exp $
  38  * $DragonFly: src/sys/dev/raid/vinum/vinummemory.c,v 1.8 2005/07/30 18:52:35 joerg Exp $
  39  */
  40
  41 #include "vinumhdr.h"
  42
  43 #ifdef VINUMDEBUG
  44 #undef longjmp                                              /* this was defined as LongJmp */
  45 void longjmp(jmp_buf, int);                                 /* the kernel doesn't define this */
  46
  47 #include "request.h"
  48 extern struct rqinfo rqinfo[];
  49 extern struct rqinfo *rqip;
  50 int rqinfo_size = RQINFO_SIZE;                              /* for debugger */
  51
  52 #ifdef __i386__                                             /* check for validity */
  53 void
  54 LongJmp(jmp_buf buf, int retval)
  55 {
  56 /*
  57    * longjmp is not documented, not even jmp_buf.
  58    * This is what's in i386/i386/support.s:
  59    * ENTRY(longjmp)
  60    *    movl    4(%esp),%eax
  61    *    movl    (%eax),%ebx                      restore ebx
  62    *    movl    4(%eax),%esp                     restore esp
  63    *    movl    8(%eax),%ebp                     restore ebp
  64    *    movl    12(%eax),%esi                    restore esi
  65    *    movl    16(%eax),%edi                    restore edi
  66    *    movl    20(%eax),%edx                    get rta
  67    *    movl    %edx,(%esp)                      put in return frame
  68    *    xorl    %eax,%eax                        return(1);
  69    *    incl    %eax
  70    *    ret
  71    *
  72    * from which we deduce the structure of jmp_buf:
  73  */
  74     struct JmpBuf {
  75         int jb_ebx;
  76         int jb_esp;
  77         int jb_ebp;
  78         int jb_esi;
  79         int jb_edi;
  80         int jb_eip;
  81     };
  82
  83     struct JmpBuf *jb = (struct JmpBuf *) buf;
  84
  85     if ((jb->jb_esp < 0xc0000000)
  86         || (jb->jb_ebp < 0xc0000000)
  87         || (jb->jb_eip < 0xc0000000))
  88         panic("Invalid longjmp");
  89     longjmp(buf, retval);
  90 }
  91
  92 #else
  93 #define LongJmp longjmp                                     /* just use the kernel function */
  94 #endif
  95 #endif
  96
  97 /* find the base name of a path name */
  98 char *
  99 basename(char *file)
 100 {
 101     char *f = rindex(file, '/');                            /* chop off dirname if present */
 102
 103     if (f == NULL)
 104         return file;
 105     else
 106         return ++f;                                         /* skip the / */
 107 }
 108
 109 void
 110 expand_table(void **table, int oldsize, int newsize)
 111 {
 112     if (newsize > oldsize) {
 113         int *temp;
 114
 115         crit_enter();
 116         temp = (int *) Malloc(newsize);                     /* allocate a new table */
 117         CHECKALLOC(temp, "vinum: Can't expand table\n");
 118         bzero((char *) temp, newsize);                      /* clean it all out */
 119         if (*table != NULL) {                               /* already something there, */
 120             bcopy((char *) *table, (char *) temp, oldsize); /* copy it to the old table */
 121             Free(*table);
 122         }
 123         *table = temp;
 124         crit_exit();
 125     }
 126 }
 127
 128 #if VINUMDEBUG                                              /* XXX debug */
 129 #define MALLOCENTRIES 16384
 130 int malloccount = 0;
 131 int highwater = 0;                                          /* highest index ever allocated */
 132 struct mc malloced[MALLOCENTRIES];
 133
 134 #define FREECOUNT 64
 135 int freecount = FREECOUNT;                                  /* for debugger */
 136 int lastfree = 0;
 137 struct mc freeinfo[FREECOUNT];
 138
 139 int total_malloced;
 140 static int mallocseq = 0;
 141
 142 caddr_t
 143 MMalloc(int size, char *file, int line)
 144 {
 145     caddr_t result;
 146     int i;
 147
 148     if (malloccount >= MALLOCENTRIES) {                     /* too many */
 149         log(LOG_ERR, "vinum: can't allocate table space to trace memory allocation");
 150         return 0;                                           /* can't continue */
 151     }
 152     /* Wait for malloc if we can */
 153     result = malloc(size, M_DEVBUF, mycpu->gd_intr_nesting_level == 0 ? M_WAITOK : M_INTWAIT);
 154     if (result == NULL)
 155         log(LOG_ERR, "vinum: can't allocate %d bytes from %s:%d\n", size, file, line);
 156     else {
 157         crit_enter();
 158         for (i = 0; i < malloccount; i++) {
 159             if (((result + size) > malloced[i].address)
 160                 && (result < malloced[i].address + malloced[i].size)) /* overlap */
 161                 Debugger("Malloc overlap");
 162         }
 163         if (result) {
 164             char *f = basename(file);
 165
 166             i = malloccount++;
 167             total_malloced += size;
 168             microtime(&malloced[i].time);
 169             malloced[i].seq = mallocseq++;
 170             malloced[i].size = size;
 171             malloced[i].line = line;
 172             malloced[i].address = result;
 173             bcopy(f, malloced[i].file, min(strlen(f), MCFILENAMELEN - 1));
 174             malloced[i].file[MCFILENAMELEN - 1] = '\0';
 175         }
 176         if (malloccount > highwater)
 177             highwater = malloccount;
 178         crit_exit();
 179     }
 180     return result;
 181 }
 182
 183 void
 184 FFree(void *mem, char *file, int line)
 185 {
 186     int i;
 187
 188     crit_enter();
 189     for (i = 0; i < malloccount; i++) {
 190         if ((caddr_t) mem == malloced[i].address) {         /* found it */
 191             bzero(mem, malloced[i].size);                   /* XXX */
 192             free(mem, M_DEVBUF);
 193             malloccount--;
 194             total_malloced -= malloced[i].size;
 195             if (debug & DEBUG_MEMFREE) {                    /* keep track of recent frees */
 196                 char *f = rindex(file, '/');                /* chop off dirname if present */
 197
 198                 if (f == NULL)
 199                     f = file;
 200                 else
 201                     f++;                                    /* skip the / */
 202
 203                 microtime(&freeinfo[lastfree].time);
 204                 freeinfo[lastfree].seq = malloced[i].seq;
 205                 freeinfo[lastfree].size = malloced[i].size;
 206                 freeinfo[lastfree].line = line;
 207                 freeinfo[lastfree].address = mem;
 208                 bcopy(f, freeinfo[lastfree].file, min(strlen(f), MCFILENAMELEN - 1));
 209                 freeinfo[lastfree].file[MCFILENAMELEN - 1] = '\0';
 210                 if (++lastfree == FREECOUNT)
 211                     lastfree = 0;
 212             }
 213             if (i < malloccount)                            /* more coming after */
 214                 bcopy(&malloced[i + 1], &malloced[i], (malloccount - i) * sizeof(struct mc));
 215             crit_exit();
 216             return;
 217         }
 218     }
 219     log(LOG_ERR,
 220         "Freeing unallocated data at 0x%p from %s, line %d\n",
 221         mem,
 222         file,
 223         line);
 224     Debugger("Free");
 225     crit_exit();
 226 }
 227
 228 void
 229 vinum_meminfo(caddr_t data)
 230 {
 231     struct meminfo *m = (struct meminfo *) data;
 232
 233     m->mallocs = malloccount;
 234     m->total_malloced = total_malloced;
 235     m->malloced = malloced;
 236     m->highwater = highwater;
 237 }
 238
 239 int
 240 vinum_mallocinfo(caddr_t data)
 241 {
 242     struct mc *m = (struct mc *) data;
 243     unsigned int ent = m->seq;                              /* index of entry to return */
 244
 245     if (ent >= malloccount)
 246         return ENOENT;
 247     m->address = malloced[ent].address;
 248     m->size = malloced[ent].size;
 249     m->line = malloced[ent].line;
 250     m->seq = malloced[ent].seq;
 251     bcopy(malloced[ent].file, m->file, MCFILENAMELEN);
 252     return 0;
 253 }
 254
 255 /*
 256  * return the nth request trace buffer entry.  This
 257  * is indexed back from the current entry (which
 258  * has index 0)
 259  */
 260 int
 261 vinum_rqinfo(caddr_t data)
 262 {
 263     struct rqinfo *rq = (struct rqinfo *) data;
 264     int ent = *(int *) data;                                /* 1st word is index */
 265     int lastent = rqip - rqinfo;                            /* entry number of current entry */
 266
 267     if (ent >= RQINFO_SIZE)                                 /* out of the table */
 268         return ENOENT;
 269     if ((ent = lastent - ent - 1) < 0)
 270         ent += RQINFO_SIZE;                                 /* roll over backwards */
 271     bcopy(&rqinfo[ent], rq, sizeof(struct rqinfo));
 272     return 0;
 273 }
 274 #endif