lkml.org 
[lkml]   [2016]   [Jun]   [8]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    /
    Date
    From
    SubjectRe: [PATCH] mm, kasan: switch SLUB to stackdepot, enable memory quarantine for SLUB
    Hi,

    [auto build test WARNING on v4.7-rc2]
    [cannot apply to next-20160608]
    [if your patch is applied to the wrong git tree, please drop us a note to help improve the system]

    url: https://github.com/0day-ci/linux/commits/Alexander-Potapenko/mm-kasan-switch-SLUB-to-stackdepot-enable-memory-quarantine-for-SLUB/20160609-024216
    config: x86_64-allmodconfig (attached as .config)
    compiler: gcc-6 (Debian 6.1.1-1) 6.1.1 20160430
    reproduce:
    # save the attached .config to linux build tree
    make ARCH=x86_64

    All warnings (new ones prefixed by >>):

    mm/kasan/kasan.c: In function 'kasan_cache_create':
    >> mm/kasan/kasan.c:374:22: warning: unused variable 'orig_size' [-Wunused-variable]
    int redzone_adjust, orig_size = *size;
    ^~~~~~~~~
    mm/kasan/kasan.c: In function 'kasan_slab_free':
    >> mm/kasan/kasan.c:561:4: warning: 'return' with no value, in function returning non-void [-Wreturn-type]
    return;
    ^~~~~~
    mm/kasan/kasan.c:547:6: note: declared here
    bool kasan_slab_free(struct kmem_cache *cache, void *object)
    ^~~~~~~~~~~~~~~

    vim +/orig_size +374 mm/kasan/kasan.c

    368 return rz;
    369 }
    370
    371 void kasan_cache_create(struct kmem_cache *cache, size_t *size,
    372 unsigned long *flags)
    373 {
    > 374 int redzone_adjust, orig_size = *size;
    375
    376 #ifdef CONFIG_SLAB
    377 /*
    378 * Make sure the adjusted size is still less than
    379 * KMALLOC_MAX_CACHE_SIZE, i.e. we don't use the page allocator.
    380 */
    381
    382 if (*size > KMALLOC_MAX_CACHE_SIZE -
    383 sizeof(struct kasan_alloc_meta) -
    384 sizeof(struct kasan_free_meta))
    385 return;
    386 #endif
    387 *flags |= SLAB_KASAN;
    388
    389 /* Add alloc meta. */
    390 cache->kasan_info.alloc_meta_offset = *size;
    391 *size += sizeof(struct kasan_alloc_meta);
    392
    393 /* Add free meta. */
    394 if (cache->flags & SLAB_DESTROY_BY_RCU || cache->ctor ||
    395 cache->object_size < sizeof(struct kasan_free_meta)) {
    396 cache->kasan_info.free_meta_offset = *size;
    397 *size += sizeof(struct kasan_free_meta);
    398 } else {
    399 cache->kasan_info.free_meta_offset = 0;
    400 }
    401 redzone_adjust = optimal_redzone(cache->object_size) -
    402 (*size - cache->object_size);
    403
    404 if (redzone_adjust > 0)
    405 *size += redzone_adjust;
    406
    407 #ifdef CONFIG_SLAB
    408 *size = min(KMALLOC_MAX_CACHE_SIZE,
    409 max(*size,
    410 cache->object_size +
    411 optimal_redzone(cache->object_size)));
    412 /*
    413 * If the metadata doesn't fit, disable KASAN at all.
    414 */
    415 if (*size <= cache->kasan_info.alloc_meta_offset ||
    416 *size <= cache->kasan_info.free_meta_offset) {
    417 *flags &= ~SLAB_KASAN;
    418 *size = orig_size;
    419 cache->kasan_info.alloc_meta_offset = -1;
    420 cache->kasan_info.free_meta_offset = -1;
    421 }
    422 #else
    423 *size = max(*size,
    424 cache->object_size +
    425 optimal_redzone(cache->object_size));
    426
    427 #endif
    428 }
    429
    430 void kasan_cache_shrink(struct kmem_cache *cache)
    431 {
    432 quarantine_remove_cache(cache);
    433 }
    434
    435 void kasan_cache_destroy(struct kmem_cache *cache)
    436 {
    437 quarantine_remove_cache(cache);
    438 }
    439
    440 void kasan_poison_slab(struct page *page)
    441 {
    442 kasan_poison_shadow(page_address(page),
    443 PAGE_SIZE << compound_order(page),
    444 KASAN_KMALLOC_REDZONE);
    445 }
    446
    447 void kasan_unpoison_object_data(struct kmem_cache *cache, void *object)
    448 {
    449 kasan_unpoison_shadow(object, cache->object_size);
    450 }
    451
    452 void kasan_poison_object_data(struct kmem_cache *cache, void *object)
    453 {
    454 kasan_poison_shadow(object,
    455 round_up(cache->object_size, KASAN_SHADOW_SCALE_SIZE),
    456 KASAN_KMALLOC_REDZONE);
    457 if (cache->flags & SLAB_KASAN) {
    458 struct kasan_alloc_meta *alloc_info =
    459 get_alloc_info(cache, object);
    460 if (alloc_info)
    461 alloc_info->state = KASAN_STATE_INIT;
    462 }
    463 }
    464
    465 static inline int in_irqentry_text(unsigned long ptr)
    466 {
    467 return (ptr >= (unsigned long)&__irqentry_text_start &&
    468 ptr < (unsigned long)&__irqentry_text_end) ||
    469 (ptr >= (unsigned long)&__softirqentry_text_start &&
    470 ptr < (unsigned long)&__softirqentry_text_end);
    471 }
    472
    473 static inline void filter_irq_stacks(struct stack_trace *trace)
    474 {
    475 int i;
    476
    477 if (!trace->nr_entries)
    478 return;
    479 for (i = 0; i < trace->nr_entries; i++)
    480 if (in_irqentry_text(trace->entries[i])) {
    481 /* Include the irqentry function into the stack. */
    482 trace->nr_entries = i + 1;
    483 break;
    484 }
    485 }
    486
    487 static inline depot_stack_handle_t save_stack(gfp_t flags)
    488 {
    489 unsigned long entries[KASAN_STACK_DEPTH];
    490 struct stack_trace trace = {
    491 .nr_entries = 0,
    492 .entries = entries,
    493 .max_entries = KASAN_STACK_DEPTH,
    494 .skip = 0
    495 };
    496
    497 save_stack_trace(&trace);
    498 filter_irq_stacks(&trace);
    499 if (trace.nr_entries != 0 &&
    500 trace.entries[trace.nr_entries-1] == ULONG_MAX)
    501 trace.nr_entries--;
    502
    503 return depot_save_stack(&trace, flags);
    504 }
    505
    506 static inline void set_track(struct kasan_track *track, gfp_t flags)
    507 {
    508 track->pid = current->pid;
    509 track->stack = save_stack(flags);
    510 }
    511
    512 struct kasan_alloc_meta *get_alloc_info(struct kmem_cache *cache,
    513 const void *object)
    514 {
    515 BUILD_BUG_ON(sizeof(struct kasan_alloc_meta) > 32);
    516 if (cache->kasan_info.alloc_meta_offset == -1)
    517 return NULL;
    518 return (void *)object + cache->kasan_info.alloc_meta_offset;
    519 }
    520
    521 struct kasan_free_meta *get_free_info(struct kmem_cache *cache,
    522 const void *object)
    523 {
    524 BUILD_BUG_ON(sizeof(struct kasan_free_meta) > 32);
    525 if (cache->kasan_info.free_meta_offset == -1)
    526 return NULL;
    527 return (void *)object + cache->kasan_info.free_meta_offset;
    528 }
    529
    530 void kasan_slab_alloc(struct kmem_cache *cache, void *object, gfp_t flags)
    531 {
    532 kasan_kmalloc(cache, object, cache->object_size, flags);
    533 }
    534
    535 void kasan_poison_slab_free(struct kmem_cache *cache, void *object)
    536 {
    537 unsigned long size = cache->object_size;
    538 unsigned long rounded_up_size = round_up(size, KASAN_SHADOW_SCALE_SIZE);
    539
    540 /* RCU slabs could be legally used after free within the RCU period */
    541 if (unlikely(cache->flags & SLAB_DESTROY_BY_RCU))
    542 return;
    543
    544 kasan_poison_shadow(object, rounded_up_size, KASAN_KMALLOC_FREE);
    545 }
    546
    547 bool kasan_slab_free(struct kmem_cache *cache, void *object)
    548 {
    549 /* RCU slabs could be legally used after free within the RCU period */
    550 if (unlikely(cache->flags & SLAB_DESTROY_BY_RCU))
    551 return false;
    552
    553 if (likely(cache->flags & SLAB_KASAN)) {
    554 struct kasan_alloc_meta *alloc_info =
    555 get_alloc_info(cache, object);
    556 struct kasan_free_meta *free_info =
    557 get_free_info(cache, object);
    558 WARN_ON(!alloc_info);
    559 WARN_ON(!free_info);
    560 if (!alloc_info || !free_info)
    > 561 return;
    562 switch (alloc_info->state) {
    563 case KASAN_STATE_ALLOC:
    564 alloc_info->state = KASAN_STATE_QUARANTINE;

    ---
    0-DAY kernel test infrastructure Open Source Technology Center
    https://lists.01.org/pipermail/kbuild-all Intel Corporation
    [unhandled content-type:application/octet-stream]
    \
     
     \ /
      Last update: 2016-06-08 22:21    [W:3.184 / U:0.176 seconds]
    ©2003-2020 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site