block/fvd-debug.c

   1 /*
   2  * Copyright (c) 2010-2011 IBM
   3  *
   4  * Authors:
   5  *         Chunqiang Tang <ctang@us.ibm.com>
   6  *
   7  * This work is licensed under the terms of the GNU GPL, version 2.
   8  * See the COPYING file in the top-level directory.
   9  */
  10
  11 /*=============================================================================
  12  *  A short description: this module implements debugging functions for
  13  *  the Fast Virtual Disk (FVD) format.
  14  *============================================================================*/
  15
  16 #ifndef ENABLE_TRACE_IO
  17 # define TRACE_REQUEST(...) do {} while (0)
  18 # define TRACE_STORE_IN_FVD(...) do {} while (0)
  19
  20 #else
  21 /* Monitor IO on a specific sector that triggers bugs. */
  22 static inline void debug_sector (int64_t sector_num)
  23 {
  24     if (FALSE) {
  25         if (sector_num == ((int64_t) 1023990LL)) {
  26             QPAUSE ("right sector");
  27         }
  28     }
  29 }
  30
  31 static void TRACE_REQUEST (int do_write, int64_t sector_num, int nb_sectors)
  32 {
  33     if (do_write) {
  34         QDEBUG ("TRACE_REQUEST: write sector_num=%" PRId64
  35                 " nb_sectors=%d\n    [ ", sector_num, nb_sectors);
  36     } else {
  37         QDEBUG ("TRACE_REQUEST: read  sector_num=%" PRId64 " nb_sectors=%d\n"
  38                 "[ ", sector_num, nb_sectors);
  39     }
  40
  41     int64_t end = sector_num + nb_sectors;
  42     int64_t sec;
  43     for (sec = sector_num; sec < end; sec++) {
  44         QDEBUG ("sec%" PRId64 " ", sec);
  45         debug_sector (sec);
  46     }
  47     QDEBUG (" ]\n");
  48 }
  49
  50 static void TRACE_STORE_IN_FVD (const char *str, int64_t sector_num,
  51                                 int nb_sectors)
  52 {
  53     QDEBUG ("TRACE_STORE: %s sector_num=%" PRId64 " nb_sectors=%d\n    [ ",
  54             str, sector_num, nb_sectors);
  55     int64_t end = sector_num + nb_sectors;
  56     int64_t sec;
  57     for (sec = sector_num; sec < end; sec++) {
  58         QDEBUG ("sec%" PRId64 " ", sec);
  59         debug_sector (sec);
  60     }
  61     QDEBUG (" ]\n");
  62 }
  63 #endif
  64
  65 #ifndef FVD_DEBUG
  66 # define my_qemu_malloc g_malloc
  67 # define my_qemu_mallocz g_malloc0
  68 # define my_qemu_blockalign qemu_blockalign
  69 # define my_qemu_free g_free
  70 # define my_qemu_vfree qemu_vfree
  71 # define my_qemu_aio_get qemu_aio_get
  72 # define my_qemu_aio_release qemu_aio_release
  73 # define COPY_UUID(to,from) do {} while (0)
  74
  75 #else
  76 FILE *__fvd_debug_fp;
  77 static unsigned long long int fvd_uuid = 1;
  78 static int64_t pending_qemu_malloc = 0;
  79 static int64_t pending_qemu_aio_get = 0;
  80 static int64_t pending_local_writes = 0;
  81 static const char *alloc_file;
  82 static int alloc_line;
  83
  84 #define my_qemu_malloc(size) \
  85     ((void*)(alloc_file=__FILE__, alloc_line=__LINE__, _my_qemu_malloc(size)))
  86
  87 #define my_qemu_mallocz(size) \
  88     ((void*)(alloc_file=__FILE__, alloc_line=__LINE__, _my_qemu_mallocz(size)))
  89
  90 #define my_qemu_blockalign(bs,size) \
  91     ((void*)(alloc_file=__FILE__, \
  92              alloc_line=__LINE__, \
  93              _my_qemu_blockalign(bs,size)))
  94
  95 #define my_qemu_aio_get(pool,bs,cb,op) \
  96     ((void*)(alloc_file=__FILE__, \
  97              alloc_line=__LINE__, \
  98              _my_qemu_aio_get(pool,bs,cb,op)))
  99
 100 #define my_qemu_free(p) \
 101     (alloc_file=__FILE__, alloc_line=__LINE__, _my_qemu_free(p))
 102
 103 #define my_qemu_vfree(p) \
 104     (alloc_file=__FILE__, alloc_line=__LINE__, _my_qemu_vfree(p))
 105
 106 static void COPY_UUID (FvdAIOCB * to, FvdAIOCB * from)
 107 {
 108     if (from) {
 109         to->uuid = from->uuid;
 110         FVD_DEBUG_ACB (to);
 111     }
 112 }
 113
 114 #ifdef DEBUG_MEMORY_LEAK
 115 # define MAX_TRACER 10485760
 116 static int alloc_tracer_used = 1;        /* slot 0 is not used. */
 117 static void **alloc_tracers = NULL;
 118
 119 static void __attribute__ ((constructor)) init_mem_alloc_tracers (void)
 120 {
 121     if (!alloc_tracers) {
 122         alloc_tracers = g_malloc0(sizeof(void *) * MAX_TRACER);
 123     }
 124 }
 125
 126 static void trace_alloc (void *p, size_t size)
 127 {
 128     alloc_tracer_t *t = p;
 129     t->magic = FVD_ALLOC_MAGIC;
 130     t->alloc_file = alloc_file;
 131     t->alloc_line = alloc_line;
 132     t->size = size;
 133
 134     if (alloc_tracer_used < MAX_TRACER) {
 135         t->alloc_tracer = alloc_tracer_used++;
 136         alloc_tracers[t->alloc_tracer] = t;
 137         QDEBUG ("Allocate memory using tracer%d in %s on line %d.\n",
 138                 t->alloc_tracer, alloc_file, alloc_line);
 139     } else {
 140         t->alloc_tracer = 0;
 141     }
 142
 143     /* Set header and footer to detect out-of-range writes. */
 144     if (size != (size_t) - 1) {
 145         uint8_t *q = (uint8_t *) p;
 146         uint64_t *header = (uint64_t *) (q + 512 - sizeof (uint64_t));
 147         uint64_t *footer = (uint64_t *) (q + size - 512);
 148         *header = FVD_ALLOC_MAGIC;
 149         *footer = FVD_ALLOC_MAGIC;
 150     }
 151 }
 152
 153 static void trace_free (void *p)
 154 {
 155     alloc_tracer_t *t = p;
 156
 157     QDEBUG ("Free memory with tracer%d in %s on line %d.\n",
 158             t->alloc_tracer, alloc_file, alloc_line);
 159     ASSERT (t->magic == FVD_ALLOC_MAGIC && t->alloc_tracer >= 0);
 160
 161     /* Check header and footer to detect out-of-range writes. */
 162     if (t->size != (size_t) - 1) {
 163         uint8_t *q = (uint8_t *) p;
 164         uint64_t *header = (uint64_t *) (q + 512 - sizeof (uint64_t));
 165         uint64_t *footer = (uint64_t *) (q + t->size - 512);
 166         ASSERT (*header == FVD_ALLOC_MAGIC);
 167         ASSERT (*footer == FVD_ALLOC_MAGIC);
 168     }
 169
 170     if (t->alloc_tracer) {
 171         ASSERT (alloc_tracers[t->alloc_tracer] == t);
 172         alloc_tracers[t->alloc_tracer] = NULL;
 173         t->alloc_tracer = -INT_MAX;
 174     } else {
 175         t->alloc_tracer *= -1;        /* Guard against double free. */
 176     }
 177 }
 178
 179 static void dump_alloc_tracers (void)
 180 {
 181     int unfreed = 0;
 182     int i;
 183     for (i = 1; i < alloc_tracer_used; i++) {
 184         if (!alloc_tracers[i]) {
 185             continue;
 186         }
 187
 188         unfreed++;
 189         alloc_tracer_t *t = alloc_tracers[i];
 190
 191         if (t->size == (size_t) - 1) {
 192             FvdAIOCB *acb = container_of (alloc_tracers[i], FvdAIOCB, tracer);
 193             ASSERT (acb->magic == FVDAIOCB_MAGIC);
 194             QDEBUG ("Memory %p with tracer%d allocated in %s on line %d "
 195                     "(FvdAIOCB acb%llu-%p) is not freed. magic %s\n",
 196                     alloc_tracers[i], i, t->alloc_file, t->alloc_line,
 197                     acb->uuid, acb,
 198                     t->magic == FVD_ALLOC_MAGIC ? "correct" : "wrong");
 199         } else {
 200             QDEBUG ("Memory %p with tracer%d allocated in %s on line %d is "
 201                     "not freed. magic %s\n",
 202                     alloc_tracers[i], i, t->alloc_file, t->alloc_line,
 203                     t->magic == FVD_ALLOC_MAGIC ? "correct" : "wrong");
 204
 205             uint8_t *q = (uint8_t *) t;
 206             uint64_t *header = (uint64_t *) (q + 512 - sizeof (uint64_t));
 207             uint64_t *footer = (uint64_t *) (q + t->size - 512);
 208             ASSERT (*header == FVD_ALLOC_MAGIC);
 209             ASSERT (*footer == FVD_ALLOC_MAGIC);
 210         }
 211     }
 212
 213     QDEBUG ("Unfreed memory allocations: %d\n", unfreed);
 214 }
 215 #endif
 216
 217 static inline void *_my_qemu_aio_get (AIOCBInfo *pool, BlockDriverState *bs,
 218                                       BlockDriverCompletionFunc * cb,
 219                                       void *opaque)
 220 {
 221     pending_qemu_aio_get++;
 222     FvdAIOCB *acb = (FvdAIOCB *) qemu_aio_get (&fvd_aio_pool, bs, cb, opaque);
 223     acb->uuid = ++fvd_uuid;
 224     acb->magic = FVDAIOCB_MAGIC;
 225
 226     FVD_DEBUG_ACB (acb);
 227
 228 #ifdef DEBUG_MEMORY_LEAK
 229     trace_alloc (&acb->tracer, -1);
 230 #endif
 231
 232     return acb;
 233 }
 234
 235 static inline void my_qemu_aio_release (void *p)
 236 {
 237     pending_qemu_aio_get--;
 238     ASSERT (pending_qemu_aio_get >= 0);
 239
 240 #ifdef DEBUG_MEMORY_LEAK
 241     FvdAIOCB *acb = p;
 242     trace_free (&acb->tracer);
 243 #endif
 244
 245     qemu_aio_release (p);
 246 }
 247
 248 static inline void *_my_qemu_malloc (size_t size)
 249 {
 250     ASSERT (size > 0);
 251     pending_qemu_malloc++;
 252 #ifndef DEBUG_MEMORY_LEAK
 253     return g_malloc(size);
 254 #else
 255
 256     size += 1024;        /* 512 bytes header and 512 bytes footer. */
 257     uint8_t *ret = g_malloc(size);
 258     trace_alloc (ret, size);
 259     return ret + 512;
 260 #endif
 261 }
 262
 263 static inline void *_my_qemu_mallocz (size_t size)
 264 {
 265     ASSERT (size > 0);
 266     pending_qemu_malloc++;
 267 #ifndef DEBUG_MEMORY_LEAK
 268     return g_malloc0(size);
 269 #else
 270
 271     size += 1024;        /* 512 bytes header and 512 bytes footer. */
 272     uint8_t *ret = g_malloc0(size);
 273     trace_alloc (ret, size);
 274     return ret + 512;
 275 #endif
 276 }
 277
 278 static inline void *_my_qemu_blockalign (BlockDriverState * bs, size_t size)
 279 {
 280     ASSERT (size > 0);
 281     pending_qemu_malloc++;
 282
 283 #ifndef DEBUG_MEMORY_LEAK
 284     return qemu_blockalign (bs, size);
 285 #else
 286
 287     size += 1024;        /* 512 bytes header and 512 bytes footer. */
 288     uint8_t *ret = qemu_blockalign (bs, size);
 289     trace_alloc (ret, size);
 290     return ret + 512;
 291 #endif
 292 }
 293
 294 static inline void _my_qemu_free (void *ptr)
 295 {
 296     pending_qemu_malloc--;
 297     ASSERT (pending_qemu_malloc >= 0);
 298 #ifndef DEBUG_MEMORY_LEAK
 299     g_free(ptr);
 300 #else
 301
 302     uint8_t *q = ((uint8_t *) ptr) - 512;
 303     trace_free (q);
 304     g_free(q);
 305 #endif
 306 }
 307
 308 static inline void _my_qemu_vfree (void *ptr)
 309 {
 310     pending_qemu_malloc--;
 311     ASSERT (pending_qemu_malloc >= 0);
 312 #ifndef DEBUG_MEMORY_LEAK
 313     qemu_vfree (ptr);
 314 #else
 315
 316     uint8_t *q = ((uint8_t *) ptr) - 512;
 317     trace_free (q);
 318     qemu_vfree (q);
 319 #endif
 320 }
 321
 322 static void count_pending_requests (BDRVFvdState * s)
 323 {
 324     int m = 0, k = 0;
 325     FvdAIOCB *w;
 326
 327     QLIST_FOREACH (w, &s->copy_locks, copy_lock.next) {
 328         m++;
 329         QDEBUG ("copy_lock: acb%llu-%p\n", w->uuid, w);
 330     }
 331
 332     QLIST_FOREACH (w, &s->write_locks, write.next_write_lock) {
 333         k++;
 334         QDEBUG ("write_lock: acb%llu-%p\n", w->uuid, w);
 335     }
 336
 337     QDEBUG ("Debug_memory_leak: copy_locks=%d  write_locks=%d\n", m, k);
 338 }
 339
 340 static void dump_resource_summary (BDRVFvdState * s)
 341 {
 342 #ifdef DEBUG_MEMORY_LEAK
 343     dump_alloc_tracers ();
 344 #endif
 345
 346     QDEBUG ("Resource summary: outstanding_copy_on_read_data=%" PRId64
 347             " total_copy_on_read_data=%" PRId64 " total_prefetch_data=%" PRId64
 348             " " " pending_qemu_malloc=%" PRId64 " pending_qemu_aio_get=%" PRId64
 349             " pending_local_writes=%" PRId64 "\n",
 350             s->outstanding_copy_on_read_data, s->total_copy_on_read_data,
 351             s->total_prefetch_data, pending_qemu_malloc, pending_qemu_aio_get,
 352             pending_local_writes);
 353     count_pending_requests (s);
 354 }
 355
 356 /* Monitor processing a specific FvdAIOCB that triggers bugs. */
 357 void FVD_DEBUG_ACB (void *p)
 358 {
 359     if (FALSE) {
 360         FvdAIOCB *acb = p;
 361
 362         /* Is it FvdAIOCB? */
 363         if (acb->magic != FVDAIOCB_MAGIC || acb->common.bs->drv != &bdrv_fvd) {
 364             /* Is it CompactChildCB? */
 365             CompactChildCB *child = p;
 366             acb = child->acb;
 367             if (acb->magic != FVDAIOCB_MAGIC
 368                 || acb->common.bs->drv != &bdrv_fvd
 369                 || (acb->type != OP_LOAD_COMPACT
 370                     && acb->type != OP_STORE_COMPACT)) {
 371                 return;
 372             }
 373         }
 374
 375         if (acb->uuid == 20ULL) {
 376             QPAUSE ("Processing the right acb");
 377         }
 378     }
 379 }
 380
 381 void init_fvd_debug_fp (void)
 382 {
 383     char buf[256];
 384     sprintf (buf, "/tmp/fvd.log-%d", getpid ());
 385     if ((__fvd_debug_fp = fopen (buf, "wt")) == NULL) {
 386         __fvd_debug_fp = stdout;
 387     }
 388 }
 389 #endif
 390
 391 void fvd_check_memory_usage (void)
 392 {
 393     ASSERT (pending_qemu_malloc == 0);
 394 }
 395
 396 int fvd_get_copy_on_read (BlockDriverState * bs)
 397 {
 398     BDRVFvdState *s = bs->opaque;
 399     return s->copy_on_read;
 400 }
 401
 402 void fvd_set_copy_on_read (BlockDriverState * bs, int copy_on_read)
 403 {
 404     BDRVFvdState *s = bs->opaque;
 405     s->copy_on_read = copy_on_read;
 406 }