granicus.if.org Git - zfs/blob - module/spl/spl-kmem.c

   1 /*
   2  *  Copyright (C) 2007-2010 Lawrence Livermore National Security, LLC.
   3  *  Copyright (C) 2007 The Regents of the University of California.
   4  *  Produced at Lawrence Livermore National Laboratory (cf, DISCLAIMER).
   5  *  Written by Brian Behlendorf <behlendorf1@llnl.gov>.
   6  *  UCRL-CODE-235197
   7  *
   8  *  This file is part of the SPL, Solaris Porting Layer.
   9  *  For details, see <http://zfsonlinux.org/>.
  10  *
  11  *  The SPL is free software; you can redistribute it and/or modify it
  12  *  under the terms of the GNU General Public License as published by the
  13  *  Free Software Foundation; either version 2 of the License, or (at your
  14  *  option) any later version.
  15  *
  16  *  The SPL is distributed in the hope that it will be useful, but WITHOUT
  17  *  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  18  *  FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  19  *  for more details.
  20  *
  21  *  You should have received a copy of the GNU General Public License along
  22  *  with the SPL.  If not, see <http://www.gnu.org/licenses/>.
  23  */
  24
  25 #include <sys/debug.h>
  26 #include <sys/sysmacros.h>
  27 #include <sys/kmem.h>
  28 #include <sys/vmem.h>
  29 #include <linux/mm.h>
  30 #include <linux/ratelimit.h>
  31
  32 /*
  33  * As a general rule kmem_alloc() allocations should be small, preferably
  34  * just a few pages since they must by physically contiguous.  Therefore, a
  35  * rate limited warning will be printed to the console for any kmem_alloc()
  36  * which exceeds a reasonable threshold.
  37  *
  38  * The default warning threshold is set to eight pages but capped at 32K to
  39  * accommodate systems using large pages.  This value was selected to be small
  40  * enough to ensure the largest allocations are quickly noticed and fixed.
  41  * But large enough to avoid logging any warnings when a allocation size is
  42  * larger than optimal but not a serious concern.  Since this value is tunable,
  43  * developers are encouraged to set it lower when testing so any new largish
  44  * allocations are quickly caught.  These warnings may be disabled by setting
  45  * the threshold to zero.
  46  */
  47 unsigned int spl_kmem_alloc_warn = MAX(8 * PAGE_SIZE, 32 * 1024);
  48 module_param(spl_kmem_alloc_warn, uint, 0644);
  49 MODULE_PARM_DESC(spl_kmem_alloc_warn,
  50         "Warning threshold in bytes for a kmem_alloc()");
  51 EXPORT_SYMBOL(spl_kmem_alloc_warn);
  52
  53 /*
  54  * Large kmem_alloc() allocations will fail if they exceed KMALLOC_MAX_SIZE.
  55  * Allocations which are marginally smaller than this limit may succeed but
  56  * should still be avoided due to the expense of locating a contiguous range
  57  * of free pages.  Therefore, a maximum kmem size with reasonable safely
  58  * margin of 4x is set.  Kmem_alloc() allocations larger than this maximum
  59  * will quickly fail.  Vmem_alloc() allocations less than or equal to this
  60  * value will use kmalloc(), but shift to vmalloc() when exceeding this value.
  61  */
  62 unsigned int spl_kmem_alloc_max = (KMALLOC_MAX_SIZE >> 2);
  63 module_param(spl_kmem_alloc_max, uint, 0644);
  64 MODULE_PARM_DESC(spl_kmem_alloc_max,
  65         "Maximum size in bytes for a kmem_alloc()");
  66 EXPORT_SYMBOL(spl_kmem_alloc_max);
  67
  68 int
  69 kmem_debugging(void)
  70 {
  71         return (0);
  72 }
  73 EXPORT_SYMBOL(kmem_debugging);
  74
  75 char *
  76 kmem_vasprintf(const char *fmt, va_list ap)
  77 {
  78         va_list aq;
  79         char *ptr;
  80
  81         do {
  82                 va_copy(aq, ap);
  83                 ptr = kvasprintf(kmem_flags_convert(KM_SLEEP), fmt, aq);
  84                 va_end(aq);
  85         } while (ptr == NULL);
  86
  87         return (ptr);
  88 }
  89 EXPORT_SYMBOL(kmem_vasprintf);
  90
  91 char *
  92 kmem_asprintf(const char *fmt, ...)
  93 {
  94         va_list ap;
  95         char *ptr;
  96
  97         do {
  98                 va_start(ap, fmt);
  99                 ptr = kvasprintf(kmem_flags_convert(KM_SLEEP), fmt, ap);
 100                 va_end(ap);
 101         } while (ptr == NULL);
 102
 103         return (ptr);
 104 }
 105 EXPORT_SYMBOL(kmem_asprintf);
 106
 107 static char *
 108 __strdup(const char *str, int flags)
 109 {
 110         char *ptr;
 111         int n;
 112
 113         n = strlen(str);
 114         ptr = kmalloc(n + 1, kmem_flags_convert(flags));
 115         if (ptr)
 116                 memcpy(ptr, str, n + 1);
 117
 118         return (ptr);
 119 }
 120
 121 char *
 122 strdup(const char *str)
 123 {
 124         return (__strdup(str, KM_SLEEP));
 125 }
 126 EXPORT_SYMBOL(strdup);
 127
 128 void
 129 strfree(char *str)
 130 {
 131         kfree(str);
 132 }
 133 EXPORT_SYMBOL(strfree);
 134
 135 /*
 136  * Limit the number of large allocation stack traces dumped to not more than
 137  * 5 every 60 seconds to prevent denial-of-service attacks from debug code.
 138  */
 139 DEFINE_RATELIMIT_STATE(kmem_alloc_ratelimit_state, 60 * HZ, 5);
 140
 141 /*
 142  * General purpose unified implementation of kmem_alloc(). It is an
 143  * amalgamation of Linux and Illumos allocator design. It should never be
 144  * exported to ensure that code using kmem_alloc()/kmem_zalloc() remains
 145  * relatively portable.  Consumers may only access this function through
 146  * wrappers that enforce the common flags to ensure portability.
 147  */
 148 inline void *
 149 spl_kmem_alloc_impl(size_t size, int flags, int node)
 150 {
 151         gfp_t lflags = kmem_flags_convert(flags);
 152         int use_vmem = 0;
 153         void *ptr;
 154
 155         /*
 156          * Log abnormally large allocations and rate limit the console output.
 157          * Allocations larger than spl_kmem_alloc_warn should be performed
 158          * through the vmem_alloc()/vmem_zalloc() interfaces.
 159          */
 160         if ((spl_kmem_alloc_warn > 0) && (size > spl_kmem_alloc_warn) &&
 161             !(flags & KM_VMEM) && __ratelimit(&kmem_alloc_ratelimit_state)) {
 162                 printk(KERN_WARNING
 163                     "Large kmem_alloc(%lu, 0x%x), please file an issue at:\n"
 164                     "https://github.com/zfsonlinux/zfs/issues/new\n",
 165                     (unsigned long)size, flags);
 166                 dump_stack();
 167         }
 168
 169         /*
 170          * Use a loop because kmalloc_node() can fail when GFP_KERNEL is used
 171          * unlike kmem_alloc() with KM_SLEEP on Illumos.
 172          */
 173         do {
 174                 /*
 175                  * Calling kmalloc_node() when the size >= spl_kmem_alloc_max
 176                  * is unsafe.  This must fail for all for kmem_alloc() and
 177                  * kmem_zalloc() callers.
 178                  *
 179                  * For vmem_alloc() and vmem_zalloc() callers it is permissible
 180                  * to use __vmalloc().  However, in general use of __vmalloc()
 181                  * is strongly discouraged because a global lock must be
 182                  * acquired.  Contention on this lock can significantly
 183                  * impact performance so frequently manipulating the virtual
 184                  * address space is strongly discouraged.
 185                  */
 186                 if ((size > spl_kmem_alloc_max) || use_vmem) {
 187                         if (flags & KM_VMEM) {
 188                                 ptr = __vmalloc(size, lflags, PAGE_KERNEL);
 189                         } else {
 190                                 return (NULL);
 191                         }
 192                 } else {
 193                         ptr = kmalloc_node(size, lflags, node);
 194                 }
 195
 196                 if (likely(ptr) || (flags & KM_NOSLEEP))
 197                         return (ptr);
 198
 199                 /*
 200                  * For vmem_alloc() and vmem_zalloc() callers retry immediately
 201                  * using __vmalloc() which is unlikely to fail.
 202                  */
 203                 if ((flags & KM_VMEM) && (use_vmem == 0))  {
 204                         use_vmem = 1;
 205                         continue;
 206                 }
 207
 208                 if (unlikely(__ratelimit(&kmem_alloc_ratelimit_state))) {
 209                         printk(KERN_WARNING
 210                             "Possible memory allocation deadlock: "
 211                             "size=%lu lflags=0x%x",
 212                             (unsigned long)size, lflags);
 213                         dump_stack();
 214                 }
 215
 216                 /*
 217                  * Use cond_resched() instead of congestion_wait() to avoid
 218                  * deadlocking systems where there are no block devices.
 219                  */
 220                 cond_resched();
 221         } while (1);
 222
 223         return (NULL);
 224 }
 225
 226 inline void
 227 spl_kmem_free_impl(const void *buf, size_t size)
 228 {
 229         if (is_vmalloc_addr(buf))
 230                 vfree(buf);
 231         else
 232                 kfree(buf);
 233 }
 234
 235 /*
 236  * Memory allocation and accounting for kmem_* * style allocations.  When
 237  * DEBUG_KMEM is enabled the total memory allocated will be tracked and
 238  * any memory leaked will be reported during module unload.
 239  *
 240  * ./configure --enable-debug-kmem
 241  */
 242 #ifdef DEBUG_KMEM
 243
 244 /* Shim layer memory accounting */
 245 #ifdef HAVE_ATOMIC64_T
 246 atomic64_t kmem_alloc_used = ATOMIC64_INIT(0);
 247 unsigned long long kmem_alloc_max = 0;
 248 #else  /* HAVE_ATOMIC64_T */
 249 atomic_t kmem_alloc_used = ATOMIC_INIT(0);
 250 unsigned long long kmem_alloc_max = 0;
 251 #endif /* HAVE_ATOMIC64_T */
 252
 253 EXPORT_SYMBOL(kmem_alloc_used);
 254 EXPORT_SYMBOL(kmem_alloc_max);
 255
 256 inline void *
 257 spl_kmem_alloc_debug(size_t size, int flags, int node)
 258 {
 259         void *ptr;
 260
 261         ptr = spl_kmem_alloc_impl(size, flags, node);
 262         if (ptr) {
 263                 kmem_alloc_used_add(size);
 264                 if (unlikely(kmem_alloc_used_read() > kmem_alloc_max))
 265                         kmem_alloc_max = kmem_alloc_used_read();
 266         }
 267
 268         return (ptr);
 269 }
 270
 271 inline void
 272 spl_kmem_free_debug(const void *ptr, size_t size)
 273 {
 274         kmem_alloc_used_sub(size);
 275         spl_kmem_free_impl(ptr, size);
 276 }
 277
 278 /*
 279  * When DEBUG_KMEM_TRACKING is enabled not only will total bytes be tracked
 280  * but also the location of every alloc and free.  When the SPL module is
 281  * unloaded a list of all leaked addresses and where they were allocated
 282  * will be dumped to the console.  Enabling this feature has a significant
 283  * impact on performance but it makes finding memory leaks straight forward.
 284  *
 285  * Not surprisingly with debugging enabled the xmem_locks are very highly
 286  * contended particularly on xfree().  If we want to run with this detailed
 287  * debugging enabled for anything other than debugging  we need to minimize
 288  * the contention by moving to a lock per xmem_table entry model.
 289  *
 290  * ./configure --enable-debug-kmem-tracking
 291  */
 292 #ifdef DEBUG_KMEM_TRACKING
 293
 294 #include <linux/hash.h>
 295 #include <linux/ctype.h>
 296
 297 #define KMEM_HASH_BITS          10
 298 #define KMEM_TABLE_SIZE         (1 << KMEM_HASH_BITS)
 299
 300 typedef struct kmem_debug {
 301         struct hlist_node kd_hlist;     /* Hash node linkage */
 302         struct list_head kd_list;       /* List of all allocations */
 303         void *kd_addr;                  /* Allocation pointer */
 304         size_t kd_size;                 /* Allocation size */
 305         const char *kd_func;            /* Allocation function */
 306         int kd_line;                    /* Allocation line */
 307 } kmem_debug_t;
 308
 309 static spinlock_t kmem_lock;
 310 static struct hlist_head kmem_table[KMEM_TABLE_SIZE];
 311 static struct list_head kmem_list;
 312
 313 static kmem_debug_t *
 314 kmem_del_init(spinlock_t *lock, struct hlist_head *table,
 315     int bits, const void *addr)
 316 {
 317         struct hlist_head *head;
 318         struct hlist_node *node;
 319         struct kmem_debug *p;
 320         unsigned long flags;
 321
 322         spin_lock_irqsave(lock, flags);
 323
 324         head = &table[hash_ptr((void *)addr, bits)];
 325         hlist_for_each(node, head) {
 326                 p = list_entry(node, struct kmem_debug, kd_hlist);
 327                 if (p->kd_addr == addr) {
 328                         hlist_del_init(&p->kd_hlist);
 329                         list_del_init(&p->kd_list);
 330                         spin_unlock_irqrestore(lock, flags);
 331                         return (p);
 332                 }
 333         }
 334
 335         spin_unlock_irqrestore(lock, flags);
 336
 337         return (NULL);
 338 }
 339
 340 inline void *
 341 spl_kmem_alloc_track(size_t size, int flags,
 342     const char *func, int line, int node)
 343 {
 344         void *ptr = NULL;
 345         kmem_debug_t *dptr;
 346         unsigned long irq_flags;
 347
 348         dptr = kmalloc(sizeof (kmem_debug_t), kmem_flags_convert(flags));
 349         if (dptr == NULL)
 350                 return (NULL);
 351
 352         dptr->kd_func = __strdup(func, flags);
 353         if (dptr->kd_func == NULL) {
 354                 kfree(dptr);
 355                 return (NULL);
 356         }
 357
 358         ptr = spl_kmem_alloc_debug(size, flags, node);
 359         if (ptr == NULL) {
 360                 kfree(dptr->kd_func);
 361                 kfree(dptr);
 362                 return (NULL);
 363         }
 364
 365         INIT_HLIST_NODE(&dptr->kd_hlist);
 366         INIT_LIST_HEAD(&dptr->kd_list);
 367
 368         dptr->kd_addr = ptr;
 369         dptr->kd_size = size;
 370         dptr->kd_line = line;
 371
 372         spin_lock_irqsave(&kmem_lock, irq_flags);
 373         hlist_add_head(&dptr->kd_hlist,
 374             &kmem_table[hash_ptr(ptr, KMEM_HASH_BITS)]);
 375         list_add_tail(&dptr->kd_list, &kmem_list);
 376         spin_unlock_irqrestore(&kmem_lock, irq_flags);
 377
 378         return (ptr);
 379 }
 380
 381 inline void
 382 spl_kmem_free_track(const void *ptr, size_t size)
 383 {
 384         kmem_debug_t *dptr;
 385
 386         /* Ignore NULL pointer since we haven't tracked it at all*/
 387         if (ptr == NULL)
 388                 return;
 389
 390         /* Must exist in hash due to kmem_alloc() */
 391         dptr = kmem_del_init(&kmem_lock, kmem_table, KMEM_HASH_BITS, ptr);
 392         ASSERT3P(dptr, !=, NULL);
 393         ASSERT3S(dptr->kd_size, ==, size);
 394
 395         kfree(dptr->kd_func);
 396         kfree(dptr);
 397
 398         spl_kmem_free_debug(ptr, size);
 399 }
 400 #endif /* DEBUG_KMEM_TRACKING */
 401 #endif /* DEBUG_KMEM */
 402
 403 /*
 404  * Public kmem_alloc(), kmem_zalloc() and kmem_free() interfaces.
 405  */
 406 void *
 407 spl_kmem_alloc(size_t size, int flags, const char *func, int line)
 408 {
 409         ASSERT0(flags & ~KM_PUBLIC_MASK);
 410
 411 #if !defined(DEBUG_KMEM)
 412         return (spl_kmem_alloc_impl(size, flags, NUMA_NO_NODE));
 413 #elif !defined(DEBUG_KMEM_TRACKING)
 414         return (spl_kmem_alloc_debug(size, flags, NUMA_NO_NODE));
 415 #else
 416         return (spl_kmem_alloc_track(size, flags, func, line, NUMA_NO_NODE));
 417 #endif
 418 }
 419 EXPORT_SYMBOL(spl_kmem_alloc);
 420
 421 void *
 422 spl_kmem_zalloc(size_t size, int flags, const char *func, int line)
 423 {
 424         ASSERT0(flags & ~KM_PUBLIC_MASK);
 425
 426         flags |= KM_ZERO;
 427
 428 #if !defined(DEBUG_KMEM)
 429         return (spl_kmem_alloc_impl(size, flags, NUMA_NO_NODE));
 430 #elif !defined(DEBUG_KMEM_TRACKING)
 431         return (spl_kmem_alloc_debug(size, flags, NUMA_NO_NODE));
 432 #else
 433         return (spl_kmem_alloc_track(size, flags, func, line, NUMA_NO_NODE));
 434 #endif
 435 }
 436 EXPORT_SYMBOL(spl_kmem_zalloc);
 437
 438 void
 439 spl_kmem_free(const void *buf, size_t size)
 440 {
 441 #if !defined(DEBUG_KMEM)
 442         return (spl_kmem_free_impl(buf, size));
 443 #elif !defined(DEBUG_KMEM_TRACKING)
 444         return (spl_kmem_free_debug(buf, size));
 445 #else
 446         return (spl_kmem_free_track(buf, size));
 447 #endif
 448 }
 449 EXPORT_SYMBOL(spl_kmem_free);
 450
 451 #if defined(DEBUG_KMEM) && defined(DEBUG_KMEM_TRACKING)
 452 static char *
 453 spl_sprintf_addr(kmem_debug_t *kd, char *str, int len, int min)
 454 {
 455         int size = ((len - 1) < kd->kd_size) ? (len - 1) : kd->kd_size;
 456         int i, flag = 1;
 457
 458         ASSERT(str != NULL && len >= 17);
 459         memset(str, 0, len);
 460
 461         /*
 462          * Check for a fully printable string, and while we are at
 463          * it place the printable characters in the passed buffer.
 464          */
 465         for (i = 0; i < size; i++) {
 466                 str[i] = ((char *)(kd->kd_addr))[i];
 467                 if (isprint(str[i])) {
 468                         continue;
 469                 } else {
 470                         /*
 471                          * Minimum number of printable characters found
 472                          * to make it worthwhile to print this as ascii.
 473                          */
 474                         if (i > min)
 475                                 break;
 476
 477                         flag = 0;
 478                         break;
 479                 }
 480         }
 481
 482         if (!flag) {
 483                 sprintf(str, "%02x%02x%02x%02x%02x%02x%02x%02x",
 484                     *((uint8_t *)kd->kd_addr),
 485                     *((uint8_t *)kd->kd_addr + 2),
 486                     *((uint8_t *)kd->kd_addr + 4),
 487                     *((uint8_t *)kd->kd_addr + 6),
 488                     *((uint8_t *)kd->kd_addr + 8),
 489                     *((uint8_t *)kd->kd_addr + 10),
 490                     *((uint8_t *)kd->kd_addr + 12),
 491                     *((uint8_t *)kd->kd_addr + 14));
 492         }
 493
 494         return (str);
 495 }
 496
 497 static int
 498 spl_kmem_init_tracking(struct list_head *list, spinlock_t *lock, int size)
 499 {
 500         int i;
 501
 502         spin_lock_init(lock);
 503         INIT_LIST_HEAD(list);
 504
 505         for (i = 0; i < size; i++)
 506                 INIT_HLIST_HEAD(&kmem_table[i]);
 507
 508         return (0);
 509 }
 510
 511 static void
 512 spl_kmem_fini_tracking(struct list_head *list, spinlock_t *lock)
 513 {
 514         unsigned long flags;
 515         kmem_debug_t *kd;
 516         char str[17];
 517
 518         spin_lock_irqsave(lock, flags);
 519         if (!list_empty(list))
 520                 printk(KERN_WARNING "%-16s %-5s %-16s %s:%s\n", "address",
 521                     "size", "data", "func", "line");
 522
 523         list_for_each_entry(kd, list, kd_list)
 524                 printk(KERN_WARNING "%p %-5d %-16s %s:%d\n", kd->kd_addr,
 525                     (int)kd->kd_size, spl_sprintf_addr(kd, str, 17, 8),
 526                     kd->kd_func, kd->kd_line);
 527
 528         spin_unlock_irqrestore(lock, flags);
 529 }
 530 #endif /* DEBUG_KMEM && DEBUG_KMEM_TRACKING */
 531
 532 int
 533 spl_kmem_init(void)
 534 {
 535 #ifdef DEBUG_KMEM
 536         kmem_alloc_used_set(0);
 537
 538 #ifdef DEBUG_KMEM_TRACKING
 539         spl_kmem_init_tracking(&kmem_list, &kmem_lock, KMEM_TABLE_SIZE);
 540 #endif /* DEBUG_KMEM_TRACKING */
 541 #endif /* DEBUG_KMEM */
 542
 543         return (0);
 544 }
 545
 546 void
 547 spl_kmem_fini(void)
 548 {
 549 #ifdef DEBUG_KMEM
 550         /*
 551          * Display all unreclaimed memory addresses, including the
 552          * allocation size and the first few bytes of what's located
 553          * at that address to aid in debugging.  Performance is not
 554          * a serious concern here since it is module unload time.
 555          */
 556         if (kmem_alloc_used_read() != 0)
 557                 printk(KERN_WARNING "kmem leaked %ld/%llu bytes\n",
 558                     (unsigned long)kmem_alloc_used_read(), kmem_alloc_max);
 559
 560 #ifdef DEBUG_KMEM_TRACKING
 561         spl_kmem_fini_tracking(&kmem_list, &kmem_lock);
 562 #endif /* DEBUG_KMEM_TRACKING */
 563 #endif /* DEBUG_KMEM */
 564 }