LCOV - code coverage report
Current view: top level - mm/kasan - common.c (source / functions) Hit Total Coverage
Test: combined.info Lines: 212 241 88.0 %
Date: 2022-03-28 15:32:58 Functions: 30 35 85.7 %
Branches: 55 96 57.3 %

           Branch data     Line data    Source code
       1                 :            : // SPDX-License-Identifier: GPL-2.0
       2                 :            : /*
       3                 :            :  * This file contains common generic and tag-based KASAN code.
       4                 :            :  *
       5                 :            :  * Copyright (c) 2014 Samsung Electronics Co., Ltd.
       6                 :            :  * Author: Andrey Ryabinin <ryabinin.a.a@gmail.com>
       7                 :            :  *
       8                 :            :  * Some code borrowed from https://github.com/xairy/kasan-prototype by
       9                 :            :  *        Andrey Konovalov <andreyknvl@gmail.com>
      10                 :            :  *
      11                 :            :  * This program is free software; you can redistribute it and/or modify
      12                 :            :  * it under the terms of the GNU General Public License version 2 as
      13                 :            :  * published by the Free Software Foundation.
      14                 :            :  *
      15                 :            :  */
      16                 :            : 
      17                 :            : #include <linux/export.h>
      18                 :            : #include <linux/interrupt.h>
      19                 :            : #include <linux/init.h>
      20                 :            : #include <linux/kasan.h>
      21                 :            : #include <linux/kernel.h>
      22                 :            : #include <linux/kmemleak.h>
      23                 :            : #include <linux/linkage.h>
      24                 :            : #include <linux/memblock.h>
      25                 :            : #include <linux/memory.h>
      26                 :            : #include <linux/mm.h>
      27                 :            : #include <linux/module.h>
      28                 :            : #include <linux/printk.h>
      29                 :            : #include <linux/sched.h>
      30                 :            : #include <linux/sched/task_stack.h>
      31                 :            : #include <linux/slab.h>
      32                 :            : #include <linux/stacktrace.h>
      33                 :            : #include <linux/string.h>
      34                 :            : #include <linux/types.h>
      35                 :            : #include <linux/vmalloc.h>
      36                 :            : #include <linux/bug.h>
      37                 :            : #include <linux/uaccess.h>
      38                 :            : 
      39                 :            : #include <asm/cacheflush.h>
      40                 :            : #include <asm/tlbflush.h>
      41                 :            : 
      42                 :            : #include "kasan.h"
      43                 :            : #include "../slab.h"
      44                 :            : 
      45                 :            : static inline int in_irqentry_text(unsigned long ptr)
      46                 :            : {
      47                 :            :         return (ptr >= (unsigned long)&__irqentry_text_start &&
      48                 :            :                 ptr < (unsigned long)&__irqentry_text_end) ||
      49                 :            :                 (ptr >= (unsigned long)&__softirqentry_text_start &&
      50                 :            :                  ptr < (unsigned long)&__softirqentry_text_end);
      51                 :            : }
      52                 :            : 
      53                 :            : static inline unsigned int filter_irq_stacks(unsigned long *entries,
      54                 :            :                                              unsigned int nr_entries)
      55                 :            : {
      56                 :            :         unsigned int i;
      57                 :            : 
      58                 :            :         for (i = 0; i < nr_entries; i++) {
      59                 :            :                 if (in_irqentry_text(entries[i])) {
      60                 :            :                         /* Include the irqentry function into the stack. */
      61                 :            :                         return i + 1;
      62                 :            :                 }
      63                 :            :         }
      64                 :            :         return nr_entries;
      65                 :            : }
      66                 :            : 
      67                 :   41531350 : static inline depot_stack_handle_t save_stack(gfp_t flags)
      68                 :            : {
      69                 :   41531350 :         unsigned long entries[KASAN_STACK_DEPTH];
      70                 :   41531350 :         unsigned int nr_entries;
      71                 :            : 
      72                 :            :         //nr_entries = stack_trace_save(entries, ARRAY_SIZE(entries), 0);
      73                 :            :         //nr_entries = filter_irq_stacks(entries, nr_entries);
      74                 :   41531350 :         nr_entries = 1;
      75                 :   41531350 :         entries[0] = -1;
      76                 :   41531350 :         return stack_depot_save(entries, nr_entries, flags);
      77                 :            : }
      78                 :            : 
      79                 :   41526460 : static inline void set_track(struct kasan_track *track, gfp_t flags)
      80                 :            : {
      81                 :   41526460 :         track->pid = current->pid;
      82                 :   41526460 :         track->stack = save_stack(flags);
      83                 :   23964227 : }
      84                 :            : 
      85                 :     278796 : void kasan_enable_current(void)
      86                 :            : {
      87                 :     278796 :         current->kasan_depth++;
      88                 :     278796 : }
      89                 :            : 
      90                 :     278796 : void kasan_disable_current(void)
      91                 :            : {
      92                 :     278796 :         current->kasan_depth--;
      93                 :     278796 : }
      94                 :            : 
      95                 :  458873800 : bool __kasan_check_read(const volatile void *p, unsigned int size)
      96                 :            : {
      97                 :  458873800 :         return check_memory_region((unsigned long)p, size, false, _RET_IP_);
      98                 :            : }
      99                 :            : EXPORT_SYMBOL(__kasan_check_read);
     100                 :            : 
     101                 :  465345100 : bool __kasan_check_write(const volatile void *p, unsigned int size)
     102                 :            : {
     103                 :  465345100 :         return check_memory_region((unsigned long)p, size, true, _RET_IP_);
     104                 :            : }
     105                 :            : EXPORT_SYMBOL(__kasan_check_write);
     106                 :            : 
     107                 :            : #undef memset
     108                 :    9153317 : void *memset(void *addr, int c, size_t len)
     109                 :            : {
     110                 :    9153317 :         check_memory_region((unsigned long)addr, len, true, _RET_IP_);
     111                 :            : 
     112                 :    9153317 :         return __memset(addr, c, len);
     113                 :            : }
     114                 :            : 
     115                 :            : #ifdef __HAVE_ARCH_MEMMOVE
     116                 :            : #undef memmove
     117                 :     147168 : void *memmove(void *dest, const void *src, size_t len)
     118                 :            : {
     119                 :     147168 :         check_memory_region((unsigned long)src, len, false, _RET_IP_);
     120                 :     147168 :         check_memory_region((unsigned long)dest, len, true, _RET_IP_);
     121                 :            : 
     122                 :     147168 :         return __memmove(dest, src, len);
     123                 :            : }
     124                 :            : #endif
     125                 :            : 
     126                 :            : #undef memcpy
     127                 :   18367512 : void *memcpy(void *dest, const void *src, size_t len)
     128                 :            : {
     129                 :   18367512 :         check_memory_region((unsigned long)src, len, false, _RET_IP_);
     130                 :   18367512 :         check_memory_region((unsigned long)dest, len, true, _RET_IP_);
     131                 :            : 
     132                 :   18367512 :         return __memcpy(dest, src, len);
     133                 :            : }
     134                 :            : 
     135                 :            : /*
     136                 :            :  * Poisons the shadow memory for 'size' bytes starting from 'addr'.
     137                 :            :  * Memory addresses should be aligned to KASAN_SHADOW_SCALE_SIZE.
     138                 :            :  */
     139                 :   86410640 : void kasan_poison_shadow(const void *address, size_t size, u8 value)
     140                 :            : {
     141                 :   86410640 :         void *shadow_start, *shadow_end;
     142                 :            : 
     143                 :            :         /*
     144                 :            :          * Perform shadow offset calculation based on untagged address, as
     145                 :            :          * some of the callers (e.g. kasan_poison_object_data) pass tagged
     146                 :            :          * addresses to this function.
     147                 :            :          */
     148                 :   86410640 :         address = reset_tag(address);
     149                 :            : 
     150                 :    9651066 :         shadow_start = kasan_mem_to_shadow(address);
     151                 :   17573341 :         shadow_end = kasan_mem_to_shadow(address + size);
     152                 :            : 
     153                 :   86409770 :         __memset(shadow_start, value, shadow_end - shadow_start);
     154                 :          0 : }
     155                 :            : 
     156                 :   34557710 : void kasan_unpoison_shadow(const void *address, size_t size)
     157                 :            : {
     158                 :   34557710 :         u8 tag = get_tag(address);
     159                 :            : 
     160                 :            :         /*
     161                 :            :          * Perform shadow offset calculation based on untagged address, as
     162                 :            :          * some of the callers (e.g. kasan_unpoison_object_data) pass tagged
     163                 :            :          * addresses to this function.
     164                 :            :          */
     165                 :   34557710 :         address = reset_tag(address);
     166                 :            : 
     167                 :   34557710 :         kasan_poison_shadow(address, size, tag);
     168                 :            : 
     169         [ +  + ]:   34557710 :         if (size & KASAN_SHADOW_MASK) {
     170                 :    1581121 :                 u8 *shadow = (u8 *)kasan_mem_to_shadow(address + size);
     171                 :            : 
     172                 :    1581121 :                 if (IS_ENABLED(CONFIG_KASAN_SW_TAGS))
     173                 :            :                         *shadow = tag;
     174                 :            :                 else
     175                 :    1581121 :                         *shadow = size & KASAN_SHADOW_MASK;
     176                 :            :         }
     177                 :   34557710 : }
     178                 :            : 
     179                 :         28 : static void __kasan_unpoison_stack(struct task_struct *task, const void *sp)
     180                 :            : {
     181                 :         28 :         void *base = task_stack_page(task);
     182                 :         28 :         size_t size = sp - base;
     183                 :            : 
     184                 :         28 :         kasan_unpoison_shadow(base, size);
     185                 :            : }
     186                 :            : 
     187                 :            : /* Unpoison the entire stack for a task. */
     188                 :         28 : void kasan_unpoison_task_stack(struct task_struct *task)
     189                 :            : {
     190                 :         28 :         __kasan_unpoison_stack(task, task_stack_page(task) + THREAD_SIZE);
     191                 :         28 : }
     192                 :            : 
     193                 :            : /* Unpoison the stack for the current task beyond a watermark sp value. */
     194                 :          0 : asmlinkage void kasan_unpoison_task_stack_below(const void *watermark)
     195                 :            : {
     196                 :            :         /*
     197                 :            :          * Calculate the task stack base address.  Avoid using 'current'
     198                 :            :          * because this function is called by early resume code which hasn't
     199                 :            :          * yet set up the percpu register (%gs).
     200                 :            :          */
     201                 :          0 :         void *base = (void *)((unsigned long)watermark & ~(THREAD_SIZE - 1));
     202                 :            : 
     203                 :          0 :         kasan_unpoison_shadow(base, watermark - base);
     204                 :          0 : }
     205                 :            : 
     206                 :            : /*
     207                 :            :  * Clear all poison for the region between the current SP and a provided
     208                 :            :  * watermark value, as is sometimes required prior to hand-crafted asm function
     209                 :            :  * returns in the middle of functions.
     210                 :            :  */
     211                 :          0 : void kasan_unpoison_stack_above_sp_to(const void *watermark)
     212                 :            : {
     213                 :          0 :         const void *sp = __builtin_frame_address(0);
     214                 :          0 :         size_t size = watermark - sp;
     215                 :            : 
     216   [ #  #  #  # ]:          0 :         if (WARN_ON(sp > watermark))
     217                 :            :                 return;
     218                 :          0 :         kasan_unpoison_shadow(sp, size);
     219                 :            : }
     220                 :            : 
     221                 :    3650226 : void kasan_alloc_pages(struct page *page, unsigned int order)
     222                 :            : {
     223                 :    3650226 :         u8 tag;
     224                 :    3650226 :         unsigned long i;
     225                 :            : 
     226                 :    3650226 :         if (unlikely(PageHighMem(page)))
     227                 :            :                 return;
     228                 :            : 
     229                 :    3650226 :         tag = random_tag();
     230                 :    3650226 :         for (i = 0; i < (1 << order); i++)
     231                 :            :                 page_kasan_tag_set(page + i, tag);
     232                 :    3650226 :         kasan_unpoison_shadow(page_address(page), PAGE_SIZE << order);
     233                 :            : }
     234                 :            : 
     235                 :    2835825 : void kasan_free_pages(struct page *page, unsigned int order)
     236                 :            : {
     237                 :    2835825 :         if (likely(!PageHighMem(page)))
     238                 :    2835825 :                 kasan_poison_shadow(page_address(page),
     239                 :            :                                 PAGE_SIZE << order,
     240                 :            :                                 KASAN_FREE_PAGE);
     241                 :    2835825 : }
     242                 :            : 
     243                 :            : /*
     244                 :            :  * Adaptive redzone policy taken from the userspace AddressSanitizer runtime.
     245                 :            :  * For larger allocations larger redzones are used.
     246                 :            :  */
     247                 :       6132 : static inline unsigned int optimal_redzone(unsigned int object_size)
     248                 :            : {
     249                 :       6132 :         if (IS_ENABLED(CONFIG_KASAN_SW_TAGS))
     250                 :            :                 return 0;
     251                 :            : 
     252                 :       6132 :         return
     253   [ +  +  +  +  :       5068 :                 object_size <= 64        - 16   ? 16 :
          +  +  -  +  -  
                -  -  - ]
     254                 :            :                 object_size <= 128       - 32   ? 32 :
     255                 :            :                 object_size <= 512       - 64   ? 64 :
     256                 :            :                 object_size <= 4096      - 128  ? 128 :
     257                 :            :                 object_size <= (1 << 14) - 256  ? 256 :
     258                 :            :                 object_size <= (1 << 15) - 512  ? 512 :
     259                 :            :                 object_size <= (1 << 16) - 1024 ? 1024 : 2048;
     260                 :            : }
     261                 :            : 
     262                 :       6132 : void kasan_cache_create(struct kmem_cache *cache, unsigned int *size,
     263                 :            :                         slab_flags_t *flags)
     264                 :            : {
     265                 :       6132 :         unsigned int orig_size = *size;
     266                 :       6132 :         unsigned int redzone_size;
     267                 :       6132 :         int redzone_adjust;
     268                 :            : 
     269                 :            :         /* Add alloc meta. */
     270                 :       6132 :         cache->kasan_info.alloc_meta_offset = *size;
     271                 :       6132 :         *size += sizeof(struct kasan_alloc_meta);
     272                 :            : 
     273                 :            :         /* Add free meta. */
     274                 :      11452 :         if (IS_ENABLED(CONFIG_KASAN_GENERIC) &&
     275   [ +  +  +  + ]:       6132 :             (cache->flags & SLAB_TYPESAFE_BY_RCU || cache->ctor ||
     276         [ -  + ]:       5320 :              cache->object_size < sizeof(struct kasan_free_meta))) {
     277                 :        812 :                 cache->kasan_info.free_meta_offset = *size;
     278                 :        812 :                 *size += sizeof(struct kasan_free_meta);
     279                 :            :         }
     280                 :            : 
     281         [ +  + ]:       6132 :         redzone_size = optimal_redzone(cache->object_size);
     282                 :       6132 :         redzone_adjust = redzone_size - (*size - cache->object_size);
     283         [ +  + ]:       6132 :         if (redzone_adjust > 0)
     284                 :       5012 :                 *size += redzone_adjust;
     285                 :            : 
     286                 :       6132 :         *size = min_t(unsigned int, KMALLOC_MAX_SIZE,
     287                 :            :                         max(*size, cache->object_size + redzone_size));
     288                 :            : 
     289                 :            :         /*
     290                 :            :          * If the metadata doesn't fit, don't enable KASAN at all.
     291                 :            :          */
     292         [ +  - ]:       6132 :         if (*size <= cache->kasan_info.alloc_meta_offset ||
     293         [ -  + ]:       6132 :                         *size <= cache->kasan_info.free_meta_offset) {
     294                 :          0 :                 cache->kasan_info.alloc_meta_offset = 0;
     295                 :          0 :                 cache->kasan_info.free_meta_offset = 0;
     296                 :          0 :                 *size = orig_size;
     297                 :          0 :                 return;
     298                 :            :         }
     299                 :            : 
     300                 :       6132 :         *flags |= SLAB_KASAN;
     301                 :            : }
     302                 :            : 
     303                 :          0 : size_t kasan_metadata_size(struct kmem_cache *cache)
     304                 :            : {
     305                 :          0 :         return (cache->kasan_info.alloc_meta_offset ?
     306         [ #  # ]:          0 :                 sizeof(struct kasan_alloc_meta) : 0) +
     307                 :          0 :                 (cache->kasan_info.free_meta_offset ?
     308         [ #  # ]:          0 :                 sizeof(struct kasan_free_meta) : 0);
     309                 :            : }
     310                 :            : 
     311                 :   54100270 : struct kasan_alloc_meta *get_alloc_info(struct kmem_cache *cache,
     312                 :            :                                         const void *object)
     313                 :            : {
     314                 :   54100270 :         return (void *)object + cache->kasan_info.alloc_meta_offset;
     315                 :            : }
     316                 :            : 
     317                 :   17562225 : struct kasan_free_meta *get_free_info(struct kmem_cache *cache,
     318                 :            :                                       const void *object)
     319                 :            : {
     320                 :   17562225 :         BUILD_BUG_ON(sizeof(struct kasan_free_meta) > 32);
     321                 :   17562225 :         return (void *)object + cache->kasan_info.free_meta_offset;
     322                 :            : }
     323                 :            : 
     324                 :            : 
     325                 :   17562225 : static void kasan_set_free_info(struct kmem_cache *cache,
     326                 :            :                 void *object, u8 tag)
     327                 :            : {
     328                 :   17562225 :         struct kasan_alloc_meta *alloc_meta;
     329                 :   17562225 :         u8 idx = 0;
     330                 :            : 
     331                 :   17562225 :         alloc_meta = get_alloc_info(cache, object);
     332                 :            : 
     333                 :            : #ifdef CONFIG_KASAN_SW_TAGS_IDENTIFY
     334                 :            :         idx = alloc_meta->free_track_idx;
     335                 :            :         alloc_meta->free_pointer_tag[idx] = tag;
     336                 :            :         alloc_meta->free_track_idx = (idx + 1) % KASAN_NR_FREE_STACKS;
     337                 :            : #endif
     338                 :            : 
     339                 :   17562225 :         set_track(&alloc_meta->free_track[idx], GFP_NOWAIT);
     340                 :            : }
     341                 :            : 
     342                 :     641269 : void kasan_poison_slab(struct page *page)
     343                 :            : {
     344                 :     641269 :         unsigned long i;
     345                 :            : 
     346         [ +  + ]:    3464080 :         for (i = 0; i < compound_nr(page); i++)
     347                 :    2181542 :                 page_kasan_tag_reset(page + i);
     348                 :     641269 :         kasan_poison_shadow(page_address(page), page_size(page),
     349                 :            :                         KASAN_KMALLOC_REDZONE);
     350                 :     641269 : }
     351                 :            : 
     352                 :     663461 : void kasan_unpoison_object_data(struct kmem_cache *cache, void *object)
     353                 :            : {
     354                 :     663461 :         kasan_unpoison_shadow(object, cache->object_size);
     355                 :     663461 : }
     356                 :            : 
     357                 :     663461 : void kasan_poison_object_data(struct kmem_cache *cache, void *object)
     358                 :            : {
     359                 :     663461 :         kasan_poison_shadow(object,
     360                 :     663461 :                         round_up(cache->object_size, KASAN_SHADOW_SCALE_SIZE),
     361                 :            :                         KASAN_KMALLOC_REDZONE);
     362                 :     663461 : }
     363                 :            : 
     364                 :            : /*
     365                 :            :  * This function assigns a tag to an object considering the following:
     366                 :            :  * 1. A cache might have a constructor, which might save a pointer to a slab
     367                 :            :  *    object somewhere (e.g. in the object itself). We preassign a tag for
     368                 :            :  *    each object in caches with constructors during slab creation and reuse
     369                 :            :  *    the same tag each time a particular object is allocated.
     370                 :            :  * 2. A cache might be SLAB_TYPESAFE_BY_RCU, which means objects can be
     371                 :            :  *    accessed after being freed. We preassign tags for objects in these
     372                 :            :  *    caches as well.
     373                 :            :  * 3. For SLAB allocator we can't preassign tags randomly since the freelist
     374                 :            :  *    is stored as an array of indexes instead of a linked list. Assign tags
     375                 :            :  *    based on objects indexes, so that objects that are next to each other
     376                 :            :  *    get different tags.
     377                 :            :  */
     378                 :            : static u8 assign_tag(struct kmem_cache *cache, const void *object,
     379                 :            :                         bool init, bool keep_tag)
     380                 :            : {
     381                 :            :         /*
     382                 :            :          * 1. When an object is kmalloc()'ed, two hooks are called:
     383                 :            :          *    kasan_slab_alloc() and kasan_kmalloc(). We assign the
     384                 :            :          *    tag only in the first one.
     385                 :            :          * 2. We reuse the same tag for krealloc'ed objects.
     386                 :            :          */
     387                 :            :         if (keep_tag)
     388                 :            :                 return get_tag(object);
     389                 :            : 
     390                 :            :         /*
     391                 :            :          * If the cache neither has a constructor nor has SLAB_TYPESAFE_BY_RCU
     392                 :            :          * set, assign a tag when the object is being allocated (init == false).
     393                 :            :          */
     394                 :            :         if (!cache->ctor && !(cache->flags & SLAB_TYPESAFE_BY_RCU))
     395                 :            :                 return init ? KASAN_TAG_KERNEL : random_tag();
     396                 :            : 
     397                 :            :         /* For caches that either have a constructor or SLAB_TYPESAFE_BY_RCU: */
     398                 :            : #ifdef CONFIG_SLAB
     399                 :            :         /* For SLAB assign tags based on the object index in the freelist. */
     400                 :            :         return (u8)obj_to_index(cache, virt_to_page(object), (void *)object);
     401                 :            : #else
     402                 :            :         /*
     403                 :            :          * For SLUB assign a random tag during slab creation, otherwise reuse
     404                 :            :          * the already assigned tag.
     405                 :            :          */
     406                 :            :         return init ? random_tag() : get_tag(object);
     407                 :            : #endif
     408                 :            : }
     409                 :            : 
     410                 :   12573791 : void * __must_check kasan_init_slab_obj(struct kmem_cache *cache,
     411                 :            :                                                 const void *object)
     412                 :            : {
     413                 :   12573791 :         struct kasan_alloc_meta *alloc_info;
     414                 :            : 
     415         [ +  - ]:   12573791 :         if (!(cache->flags & SLAB_KASAN))
     416                 :            :                 return (void *)object;
     417                 :            : 
     418                 :   12573791 :         alloc_info = get_alloc_info(cache, object);
     419                 :   12573791 :         __memset(alloc_info, 0, sizeof(*alloc_info));
     420                 :            : 
     421                 :   12573791 :         if (IS_ENABLED(CONFIG_KASAN_SW_TAGS))
     422                 :            :                 object = set_tag(object,
     423                 :            :                                 assign_tag(cache, object, true, false));
     424                 :            : 
     425                 :   12573791 :         return (void *)object;
     426                 :            : }
     427                 :            : 
     428                 :   17573341 : static inline bool shadow_invalid(u8 tag, s8 shadow_byte)
     429                 :            : {
     430                 :   17573341 :         if (IS_ENABLED(CONFIG_KASAN_GENERIC))
     431                 :   17573341 :                 return shadow_byte < 0 ||
     432                 :            :                         shadow_byte >= KASAN_SHADOW_SCALE_SIZE;
     433                 :            : 
     434                 :            :         /* else CONFIG_KASAN_SW_TAGS: */
     435                 :            :         if ((u8)shadow_byte == KASAN_TAG_INVALID)
     436                 :            :                 return true;
     437                 :            :         if ((tag != KASAN_TAG_KERNEL) && (tag != (u8)shadow_byte))
     438                 :            :                 return true;
     439                 :            : 
     440                 :            :         return false;
     441                 :            : }
     442                 :            : 
     443                 :   18260518 : static bool __kasan_slab_free(struct kmem_cache *cache, void *object,
     444                 :            :                               unsigned long ip, bool quarantine)
     445                 :            : {
     446                 :   18260518 :         s8 shadow_byte;
     447                 :   18260518 :         u8 tag;
     448                 :   18260518 :         void *tagged_object;
     449                 :   18260518 :         unsigned long rounded_up_size;
     450                 :            : 
     451                 :   18260518 :         tag = get_tag(object);
     452                 :   18260518 :         tagged_object = object;
     453                 :   18260518 :         object = reset_tag(object);
     454                 :            : 
     455   [ +  -  -  + ]:   36521040 :         if (unlikely(nearest_obj(cache, virt_to_head_page(object), object) !=
     456                 :            :             object)) {
     457                 :          0 :                 kasan_report_invalid_free(tagged_object, ip);
     458                 :          0 :                 return true;
     459                 :            :         }
     460                 :            : 
     461                 :            :         /* RCU slabs could be legally used after free within the RCU period */
     462         [ +  + ]:   18260518 :         if (unlikely(cache->flags & SLAB_TYPESAFE_BY_RCU))
     463                 :            :                 return false;
     464                 :            : 
     465         [ -  + ]:   17573341 :         shadow_byte = READ_ONCE(*(s8 *)kasan_mem_to_shadow(object));
     466         [ -  + ]:   17573341 :         if (shadow_invalid(tag, shadow_byte)) {
     467                 :          0 :                 kasan_report_invalid_free(tagged_object, ip);
     468                 :          0 :                 return true;
     469                 :            :         }
     470                 :            : 
     471                 :   17573341 :         rounded_up_size = round_up(cache->object_size, KASAN_SHADOW_SCALE_SIZE);
     472                 :   17573341 :         kasan_poison_shadow(object, rounded_up_size, KASAN_KMALLOC_FREE);
     473                 :            : 
     474         [ +  + ]:   17573341 :         if ((IS_ENABLED(CONFIG_KASAN_GENERIC) && !quarantine) ||
     475         [ +  - ]:   17562225 :                         unlikely(!(cache->flags & SLAB_KASAN)))
     476                 :            :                 return false;
     477                 :            : 
     478                 :   17562225 :         kasan_set_free_info(cache, object, tag);
     479                 :            : 
     480                 :   17562225 :         quarantine_put(get_free_info(cache, object), cache);
     481                 :            : 
     482                 :   17562225 :         return IS_ENABLED(CONFIG_KASAN_GENERIC);
     483                 :            : }
     484                 :            : 
     485                 :   18249402 : bool kasan_slab_free(struct kmem_cache *cache, void *object, unsigned long ip)
     486                 :            : {
     487                 :   18249402 :         return __kasan_slab_free(cache, object, ip, true);
     488                 :            : }
     489                 :            : 
     490                 :   23964227 : static void *__kasan_kmalloc(struct kmem_cache *cache, const void *object,
     491                 :            :                                 size_t size, gfp_t flags, bool keep_tag)
     492                 :            : {
     493                 :   23964227 :         unsigned long redzone_start;
     494                 :   23964227 :         unsigned long redzone_end;
     495                 :   23964227 :         u8 tag = 0xff;
     496                 :            : 
     497         [ +  + ]:   23964227 :         if (gfpflags_allow_blocking(flags))
     498                 :   22781985 :                 quarantine_reduce();
     499                 :            : 
     500         [ +  - ]:   23964227 :         if (unlikely(object == NULL))
     501                 :            :                 return NULL;
     502                 :            : 
     503                 :   23964227 :         redzone_start = round_up((unsigned long)(object + size),
     504                 :            :                                 KASAN_SHADOW_SCALE_SIZE);
     505                 :   23964227 :         redzone_end = round_up((unsigned long)object + cache->object_size,
     506                 :            :                                 KASAN_SHADOW_SCALE_SIZE);
     507                 :            : 
     508                 :   23964227 :         if (IS_ENABLED(CONFIG_KASAN_SW_TAGS))
     509                 :            :                 tag = assign_tag(cache, object, false, keep_tag);
     510                 :            : 
     511                 :            :         /* Tag is ignored in set_tag without CONFIG_KASAN_SW_TAGS */
     512                 :   23964227 :         kasan_unpoison_shadow(set_tag(object, tag), size);
     513                 :   23964227 :         kasan_poison_shadow((void *)redzone_start, redzone_end - redzone_start,
     514                 :            :                 KASAN_KMALLOC_REDZONE);
     515                 :            : 
     516         [ +  - ]:   23964227 :         if (cache->flags & SLAB_KASAN)
     517                 :   23964227 :                 set_track(&get_alloc_info(cache, object)->alloc_track, flags);
     518                 :            : 
     519                 :            :         return set_tag(object, tag);
     520                 :            : }
     521                 :            : 
     522                 :   21400160 : void * __must_check kasan_slab_alloc(struct kmem_cache *cache, void *object,
     523                 :            :                                         gfp_t flags)
     524                 :            : {
     525                 :   21400160 :         return __kasan_kmalloc(cache, object, cache->object_size, flags, false);
     526                 :            : }
     527                 :            : 
     528                 :    2555611 : void * __must_check kasan_kmalloc(struct kmem_cache *cache, const void *object,
     529                 :            :                                 size_t size, gfp_t flags)
     530                 :            : {
     531                 :    2555611 :         return __kasan_kmalloc(cache, object, size, flags, true);
     532                 :            : }
     533                 :            : EXPORT_SYMBOL(kasan_kmalloc);
     534                 :            : 
     535                 :        868 : void * __must_check kasan_kmalloc_large(const void *ptr, size_t size,
     536                 :            :                                                 gfp_t flags)
     537                 :            : {
     538                 :        868 :         struct page *page;
     539                 :        868 :         unsigned long redzone_start;
     540                 :        868 :         unsigned long redzone_end;
     541                 :            : 
     542         [ +  + ]:        868 :         if (gfpflags_allow_blocking(flags))
     543                 :        840 :                 quarantine_reduce();
     544                 :            : 
     545         [ +  - ]:        868 :         if (unlikely(ptr == NULL))
     546                 :            :                 return NULL;
     547                 :            : 
     548         [ +  - ]:        868 :         page = virt_to_page(ptr);
     549                 :        868 :         redzone_start = round_up((unsigned long)(ptr + size),
     550                 :            :                                 KASAN_SHADOW_SCALE_SIZE);
     551                 :        868 :         redzone_end = (unsigned long)ptr + page_size(page);
     552                 :            : 
     553                 :        868 :         kasan_unpoison_shadow(ptr, size);
     554                 :        868 :         kasan_poison_shadow((void *)redzone_start, redzone_end - redzone_start,
     555                 :            :                 KASAN_PAGE_REDZONE);
     556                 :            : 
     557                 :        868 :         return (void *)ptr;
     558                 :            : }
     559                 :            : 
     560                 :       8176 : void * __must_check kasan_krealloc(const void *object, size_t size, gfp_t flags)
     561                 :            : {
     562                 :       8176 :         struct page *page;
     563                 :            : 
     564         [ +  - ]:       8176 :         if (unlikely(object == ZERO_SIZE_PTR))
     565                 :            :                 return (void *)object;
     566                 :            : 
     567         [ +  - ]:       8176 :         page = virt_to_head_page(object);
     568                 :            : 
     569   [ -  +  -  + ]:       8176 :         if (unlikely(!PageSlab(page)))
     570                 :          0 :                 return kasan_kmalloc_large(object, size, flags);
     571                 :            :         else
     572                 :       8176 :                 return __kasan_kmalloc(page->slab_cache, object, size,
     573                 :            :                                                 flags, true);
     574                 :            : }
     575                 :            : 
     576                 :      11116 : void kasan_poison_kfree(void *ptr, unsigned long ip)
     577                 :            : {
     578                 :      11116 :         struct page *page;
     579                 :            : 
     580         [ +  - ]:      11116 :         page = virt_to_head_page(ptr);
     581                 :            : 
     582   [ -  +  -  + ]:      11116 :         if (unlikely(!PageSlab(page))) {
     583         [ #  # ]:          0 :                 if (ptr != page_address(page)) {
     584                 :          0 :                         kasan_report_invalid_free(ptr, ip);
     585                 :          0 :                         return;
     586                 :            :                 }
     587                 :          0 :                 kasan_poison_shadow(ptr, page_size(page), KASAN_FREE_PAGE);
     588                 :            :         } else {
     589                 :      11116 :                 __kasan_slab_free(page->slab_cache, ptr, ip, false);
     590                 :            :         }
     591                 :            : }
     592                 :            : 
     593                 :        426 : void kasan_kfree_large(void *ptr, unsigned long ip)
     594                 :            : {
     595   [ +  -  -  + ]:        852 :         if (ptr != page_address(virt_to_head_page(ptr)))
     596                 :          0 :                 kasan_report_invalid_free(ptr, ip);
     597                 :            :         /* The object will be poisoned by page_alloc. */
     598                 :        426 : }
     599                 :            : 
     600                 :            : #ifndef CONFIG_KASAN_VMALLOC
     601                 :        168 : int kasan_module_alloc(void *addr, size_t size)
     602                 :            : {
     603                 :        168 :         void *ret;
     604                 :        168 :         size_t scaled_size;
     605                 :        168 :         size_t shadow_size;
     606                 :        168 :         unsigned long shadow_start;
     607                 :            : 
     608         [ -  + ]:        168 :         shadow_start = (unsigned long)kasan_mem_to_shadow(addr);
     609                 :        168 :         scaled_size = (size + KASAN_SHADOW_MASK) >> KASAN_SHADOW_SCALE_SHIFT;
     610                 :        168 :         shadow_size = round_up(scaled_size, PAGE_SIZE);
     611                 :            : 
     612   [ -  +  +  - ]:        168 :         if (WARN_ON(!PAGE_ALIGNED(shadow_start)))
     613                 :            :                 return -EINVAL;
     614                 :            : 
     615                 :        336 :         ret = __vmalloc_node_range(shadow_size, 1, shadow_start,
     616                 :            :                         shadow_start + shadow_size,
     617                 :            :                         GFP_KERNEL,
     618                 :        168 :                         PAGE_KERNEL, VM_NO_GUARD, NUMA_NO_NODE,
     619                 :        168 :                         __builtin_return_address(0));
     620                 :            : 
     621         [ +  - ]:        168 :         if (ret) {
     622                 :        168 :                 __memset(ret, KASAN_SHADOW_INIT, shadow_size);
     623                 :        168 :                 find_vm_area(addr)->flags |= VM_KASAN;
     624                 :        168 :                 kmemleak_ignore(ret);
     625                 :        168 :                 return 0;
     626                 :            :         }
     627                 :            : 
     628                 :            :         return -ENOMEM;
     629                 :            : }
     630                 :            : 
     631                 :     339397 : void kasan_free_shadow(const struct vm_struct *vm)
     632                 :            : {
     633         [ +  + ]:     339397 :         if (vm->flags & VM_KASAN)
     634                 :         84 :                 vfree(kasan_mem_to_shadow(vm->addr));
     635                 :     339397 : }
     636                 :            : #endif
     637                 :            : 
     638                 :            : extern void __kasan_report(unsigned long addr, size_t size, bool is_write, unsigned long ip);
     639                 :            : 
     640                 :    3933132 : void kasan_report(unsigned long addr, size_t size, bool is_write, unsigned long ip)
     641                 :            : {
     642                 :    3933132 :         unsigned long flags = user_access_save();
     643                 :    3933132 :         __kasan_report(addr, size, is_write, ip);
     644                 :    3933132 :         user_access_restore(flags);
     645                 :    3933132 : }
     646                 :            : 
     647                 :            : #ifdef CONFIG_MEMORY_HOTPLUG
     648                 :            : static bool shadow_mapped(unsigned long addr)
     649                 :            : {
     650                 :            :         pgd_t *pgd = pgd_offset_k(addr);
     651                 :            :         p4d_t *p4d;
     652                 :            :         pud_t *pud;
     653                 :            :         pmd_t *pmd;
     654                 :            :         pte_t *pte;
     655                 :            : 
     656                 :            :         if (pgd_none(*pgd))
     657                 :            :                 return false;
     658                 :            :         p4d = p4d_offset(pgd, addr);
     659                 :            :         if (p4d_none(*p4d))
     660                 :            :                 return false;
     661                 :            :         pud = pud_offset(p4d, addr);
     662                 :            :         if (pud_none(*pud))
     663                 :            :                 return false;
     664                 :            : 
     665                 :            :         /*
     666                 :            :          * We can't use pud_large() or pud_huge(), the first one is
     667                 :            :          * arch-specific, the last one depends on HUGETLB_PAGE.  So let's abuse
     668                 :            :          * pud_bad(), if pud is bad then it's bad because it's huge.
     669                 :            :          */
     670                 :            :         if (pud_bad(*pud))
     671                 :            :                 return true;
     672                 :            :         pmd = pmd_offset(pud, addr);
     673                 :            :         if (pmd_none(*pmd))
     674                 :            :                 return false;
     675                 :            : 
     676                 :            :         if (pmd_bad(*pmd))
     677                 :            :                 return true;
     678                 :            :         pte = pte_offset_kernel(pmd, addr);
     679                 :            :         return !pte_none(*pte);
     680                 :            : }
     681                 :            : 
     682                 :            : static int __meminit kasan_mem_notifier(struct notifier_block *nb,
     683                 :            :                         unsigned long action, void *data)
     684                 :            : {
     685                 :            :         struct memory_notify *mem_data = data;
     686                 :            :         unsigned long nr_shadow_pages, start_kaddr, shadow_start;
     687                 :            :         unsigned long shadow_end, shadow_size;
     688                 :            : 
     689                 :            :         nr_shadow_pages = mem_data->nr_pages >> KASAN_SHADOW_SCALE_SHIFT;
     690                 :            :         start_kaddr = (unsigned long)pfn_to_kaddr(mem_data->start_pfn);
     691                 :            :         shadow_start = (unsigned long)kasan_mem_to_shadow((void *)start_kaddr);
     692                 :            :         shadow_size = nr_shadow_pages << PAGE_SHIFT;
     693                 :            :         shadow_end = shadow_start + shadow_size;
     694                 :            : 
     695                 :            :         if (WARN_ON(mem_data->nr_pages % KASAN_SHADOW_SCALE_SIZE) ||
     696                 :            :                 WARN_ON(start_kaddr % (KASAN_SHADOW_SCALE_SIZE << PAGE_SHIFT)))
     697                 :            :                 return NOTIFY_BAD;
     698                 :            : 
     699                 :            :         switch (action) {
     700                 :            :         case MEM_GOING_ONLINE: {
     701                 :            :                 void *ret;
     702                 :            : 
     703                 :            :                 /*
     704                 :            :                  * If shadow is mapped already than it must have been mapped
     705                 :            :                  * during the boot. This could happen if we onlining previously
     706                 :            :                  * offlined memory.
     707                 :            :                  */
     708                 :            :                 if (shadow_mapped(shadow_start))
     709                 :            :                         return NOTIFY_OK;
     710                 :            : 
     711                 :            :                 ret = __vmalloc_node_range(shadow_size, PAGE_SIZE, shadow_start,
     712                 :            :                                         shadow_end, GFP_KERNEL,
     713                 :            :                                         PAGE_KERNEL, VM_NO_GUARD,
     714                 :            :                                         pfn_to_nid(mem_data->start_pfn),
     715                 :            :                                         __builtin_return_address(0));
     716                 :            :                 if (!ret)
     717                 :            :                         return NOTIFY_BAD;
     718                 :            : 
     719                 :            :                 kmemleak_ignore(ret);
     720                 :            :                 return NOTIFY_OK;
     721                 :            :         }
     722                 :            :         case MEM_CANCEL_ONLINE:
     723                 :            :         case MEM_OFFLINE: {
     724                 :            :                 struct vm_struct *vm;
     725                 :            : 
     726                 :            :                 /*
     727                 :            :                  * shadow_start was either mapped during boot by kasan_init()
     728                 :            :                  * or during memory online by __vmalloc_node_range().
     729                 :            :                  * In the latter case we can use vfree() to free shadow.
     730                 :            :                  * Non-NULL result of the find_vm_area() will tell us if
     731                 :            :                  * that was the second case.
     732                 :            :                  *
     733                 :            :                  * Currently it's not possible to free shadow mapped
     734                 :            :                  * during boot by kasan_init(). It's because the code
     735                 :            :                  * to do that hasn't been written yet. So we'll just
     736                 :            :                  * leak the memory.
     737                 :            :                  */
     738                 :            :                 vm = find_vm_area((void *)shadow_start);
     739                 :            :                 if (vm)
     740                 :            :                         vfree((void *)shadow_start);
     741                 :            :         }
     742                 :            :         }
     743                 :            : 
     744                 :            :         return NOTIFY_OK;
     745                 :            : }
     746                 :            : 
     747                 :            : static int __init kasan_memhotplug_init(void)
     748                 :            : {
     749                 :            :         hotplug_memory_notifier(kasan_mem_notifier, 0);
     750                 :            : 
     751                 :            :         return 0;
     752                 :            : }
     753                 :            : 
     754                 :            : core_initcall(kasan_memhotplug_init);
     755                 :            : #endif
     756                 :            : 
     757                 :            : #ifdef CONFIG_KASAN_VMALLOC
     758                 :            : static int kasan_populate_vmalloc_pte(pte_t *ptep, unsigned long addr,
     759                 :            :                                       void *unused)
     760                 :            : {
     761                 :            :         unsigned long page;
     762                 :            :         pte_t pte;
     763                 :            : 
     764                 :            :         if (likely(!pte_none(*ptep)))
     765                 :            :                 return 0;
     766                 :            : 
     767                 :            :         page = __get_free_page(GFP_KERNEL);
     768                 :            :         if (!page)
     769                 :            :                 return -ENOMEM;
     770                 :            : 
     771                 :            :         memset((void *)page, KASAN_VMALLOC_INVALID, PAGE_SIZE);
     772                 :            :         pte = pfn_pte(PFN_DOWN(__pa(page)), PAGE_KERNEL);
     773                 :            : 
     774                 :            :         spin_lock(&init_mm.page_table_lock);
     775                 :            :         if (likely(pte_none(*ptep))) {
     776                 :            :                 set_pte_at(&init_mm, addr, ptep, pte);
     777                 :            :                 page = 0;
     778                 :            :         }
     779                 :            :         spin_unlock(&init_mm.page_table_lock);
     780                 :            :         if (page)
     781                 :            :                 free_page(page);
     782                 :            :         return 0;
     783                 :            : }
     784                 :            : 
     785                 :            : int kasan_populate_vmalloc(unsigned long addr, unsigned long size)
     786                 :            : {
     787                 :            :         unsigned long shadow_start, shadow_end;
     788                 :            :         int ret;
     789                 :            : 
     790                 :            :         if (!is_vmalloc_or_module_addr((void *)addr))
     791                 :            :                 return 0;
     792                 :            : 
     793                 :            :         shadow_start = (unsigned long)kasan_mem_to_shadow((void *)addr);
     794                 :            :         shadow_start = ALIGN_DOWN(shadow_start, PAGE_SIZE);
     795                 :            :         shadow_end = (unsigned long)kasan_mem_to_shadow((void *)addr + size);
     796                 :            :         shadow_end = ALIGN(shadow_end, PAGE_SIZE);
     797                 :            : 
     798                 :            :         ret = apply_to_page_range(&init_mm, shadow_start,
     799                 :            :                                   shadow_end - shadow_start,
     800                 :            :                                   kasan_populate_vmalloc_pte, NULL);
     801                 :            :         if (ret)
     802                 :            :                 return ret;
     803                 :            : 
     804                 :            :         flush_cache_vmap(shadow_start, shadow_end);
     805                 :            : 
     806                 :            :         /*
     807                 :            :          * We need to be careful about inter-cpu effects here. Consider:
     808                 :            :          *
     809                 :            :          *   CPU#0                                CPU#1
     810                 :            :          * WRITE_ONCE(p, vmalloc(100));         while (x = READ_ONCE(p)) ;
     811                 :            :          *                                      p[99] = 1;
     812                 :            :          *
     813                 :            :          * With compiler instrumentation, that ends up looking like this:
     814                 :            :          *
     815                 :            :          *   CPU#0                                CPU#1
     816                 :            :          * // vmalloc() allocates memory
     817                 :            :          * // let a = area->addr
     818                 :            :          * // we reach kasan_populate_vmalloc
     819                 :            :          * // and call kasan_unpoison_shadow:
     820                 :            :          * STORE shadow(a), unpoison_val
     821                 :            :          * ...
     822                 :            :          * STORE shadow(a+99), unpoison_val     x = LOAD p
     823                 :            :          * // rest of vmalloc process           <data dependency>
     824                 :            :          * STORE p, a                           LOAD shadow(x+99)
     825                 :            :          *
     826                 :            :          * If there is no barrier between the end of unpoisioning the shadow
     827                 :            :          * and the store of the result to p, the stores could be committed
     828                 :            :          * in a different order by CPU#0, and CPU#1 could erroneously observe
     829                 :            :          * poison in the shadow.
     830                 :            :          *
     831                 :            :          * We need some sort of barrier between the stores.
     832                 :            :          *
     833                 :            :          * In the vmalloc() case, this is provided by a smp_wmb() in
     834                 :            :          * clear_vm_uninitialized_flag(). In the per-cpu allocator and in
     835                 :            :          * get_vm_area() and friends, the caller gets shadow allocated but
     836                 :            :          * doesn't have any pages mapped into the virtual address space that
     837                 :            :          * has been reserved. Mapping those pages in will involve taking and
     838                 :            :          * releasing a page-table lock, which will provide the barrier.
     839                 :            :          */
     840                 :            : 
     841                 :            :         return 0;
     842                 :            : }
     843                 :            : 
     844                 :            : /*
     845                 :            :  * Poison the shadow for a vmalloc region. Called as part of the
     846                 :            :  * freeing process at the time the region is freed.
     847                 :            :  */
     848                 :            : void kasan_poison_vmalloc(const void *start, unsigned long size)
     849                 :            : {
     850                 :            :         if (!is_vmalloc_or_module_addr(start))
     851                 :            :                 return;
     852                 :            : 
     853                 :            :         size = round_up(size, KASAN_SHADOW_SCALE_SIZE);
     854                 :            :         kasan_poison_shadow(start, size, KASAN_VMALLOC_INVALID);
     855                 :            : }
     856                 :            : 
     857                 :            : void kasan_unpoison_vmalloc(const void *start, unsigned long size)
     858                 :            : {
     859                 :            :         if (!is_vmalloc_or_module_addr(start))
     860                 :            :                 return;
     861                 :            : 
     862                 :            :         kasan_unpoison_shadow(start, size);
     863                 :            : }
     864                 :            : 
     865                 :            : static int kasan_depopulate_vmalloc_pte(pte_t *ptep, unsigned long addr,
     866                 :            :                                         void *unused)
     867                 :            : {
     868                 :            :         unsigned long page;
     869                 :            : 
     870                 :            :         page = (unsigned long)__va(pte_pfn(*ptep) << PAGE_SHIFT);
     871                 :            : 
     872                 :            :         spin_lock(&init_mm.page_table_lock);
     873                 :            : 
     874                 :            :         if (likely(!pte_none(*ptep))) {
     875                 :            :                 pte_clear(&init_mm, addr, ptep);
     876                 :            :                 free_page(page);
     877                 :            :         }
     878                 :            :         spin_unlock(&init_mm.page_table_lock);
     879                 :            : 
     880                 :            :         return 0;
     881                 :            : }
     882                 :            : 
     883                 :            : /*
     884                 :            :  * Release the backing for the vmalloc region [start, end), which
     885                 :            :  * lies within the free region [free_region_start, free_region_end).
     886                 :            :  *
     887                 :            :  * This can be run lazily, long after the region was freed. It runs
     888                 :            :  * under vmap_area_lock, so it's not safe to interact with the vmalloc/vmap
     889                 :            :  * infrastructure.
     890                 :            :  *
     891                 :            :  * How does this work?
     892                 :            :  * -------------------
     893                 :            :  *
     894                 :            :  * We have a region that is page aligned, labelled as A.
     895                 :            :  * That might not map onto the shadow in a way that is page-aligned:
     896                 :            :  *
     897                 :            :  *                    start                     end
     898                 :            :  *                    v                         v
     899                 :            :  * |????????|????????|AAAAAAAA|AA....AA|AAAAAAAA|????????| < vmalloc
     900                 :            :  *  -------- -------- --------          -------- --------
     901                 :            :  *      |        |       |                 |        |
     902                 :            :  *      |        |       |         /-------/        |
     903                 :            :  *      \-------\|/------/         |/---------------/
     904                 :            :  *              |||                ||
     905                 :            :  *             |??AAAAAA|AAAAAAAA|AA??????|                < shadow
     906                 :            :  *                 (1)      (2)      (3)
     907                 :            :  *
     908                 :            :  * First we align the start upwards and the end downwards, so that the
     909                 :            :  * shadow of the region aligns with shadow page boundaries. In the
     910                 :            :  * example, this gives us the shadow page (2). This is the shadow entirely
     911                 :            :  * covered by this allocation.
     912                 :            :  *
     913                 :            :  * Then we have the tricky bits. We want to know if we can free the
     914                 :            :  * partially covered shadow pages - (1) and (3) in the example. For this,
     915                 :            :  * we are given the start and end of the free region that contains this
     916                 :            :  * allocation. Extending our previous example, we could have:
     917                 :            :  *
     918                 :            :  *  free_region_start                                    free_region_end
     919                 :            :  *  |                 start                     end      |
     920                 :            :  *  v                 v                         v        v
     921                 :            :  * |FFFFFFFF|FFFFFFFF|AAAAAAAA|AA....AA|AAAAAAAA|FFFFFFFF| < vmalloc
     922                 :            :  *  -------- -------- --------          -------- --------
     923                 :            :  *      |        |       |                 |        |
     924                 :            :  *      |        |       |         /-------/        |
     925                 :            :  *      \-------\|/------/         |/---------------/
     926                 :            :  *              |||                ||
     927                 :            :  *             |FFAAAAAA|AAAAAAAA|AAF?????|                < shadow
     928                 :            :  *                 (1)      (2)      (3)
     929                 :            :  *
     930                 :            :  * Once again, we align the start of the free region up, and the end of
     931                 :            :  * the free region down so that the shadow is page aligned. So we can free
     932                 :            :  * page (1) - we know no allocation currently uses anything in that page,
     933                 :            :  * because all of it is in the vmalloc free region. But we cannot free
     934                 :            :  * page (3), because we can't be sure that the rest of it is unused.
     935                 :            :  *
     936                 :            :  * We only consider pages that contain part of the original region for
     937                 :            :  * freeing: we don't try to free other pages from the free region or we'd
     938                 :            :  * end up trying to free huge chunks of virtual address space.
     939                 :            :  *
     940                 :            :  * Concurrency
     941                 :            :  * -----------
     942                 :            :  *
     943                 :            :  * How do we know that we're not freeing a page that is simultaneously
     944                 :            :  * being used for a fresh allocation in kasan_populate_vmalloc(_pte)?
     945                 :            :  *
     946                 :            :  * We _can_ have kasan_release_vmalloc and kasan_populate_vmalloc running
     947                 :            :  * at the same time. While we run under free_vmap_area_lock, the population
     948                 :            :  * code does not.
     949                 :            :  *
     950                 :            :  * free_vmap_area_lock instead operates to ensure that the larger range
     951                 :            :  * [free_region_start, free_region_end) is safe: because __alloc_vmap_area and
     952                 :            :  * the per-cpu region-finding algorithm both run under free_vmap_area_lock,
     953                 :            :  * no space identified as free will become used while we are running. This
     954                 :            :  * means that so long as we are careful with alignment and only free shadow
     955                 :            :  * pages entirely covered by the free region, we will not run in to any
     956                 :            :  * trouble - any simultaneous allocations will be for disjoint regions.
     957                 :            :  */
     958                 :            : void kasan_release_vmalloc(unsigned long start, unsigned long end,
     959                 :            :                            unsigned long free_region_start,
     960                 :            :                            unsigned long free_region_end)
     961                 :            : {
     962                 :            :         void *shadow_start, *shadow_end;
     963                 :            :         unsigned long region_start, region_end;
     964                 :            :         unsigned long size;
     965                 :            : 
     966                 :            :         region_start = ALIGN(start, PAGE_SIZE * KASAN_SHADOW_SCALE_SIZE);
     967                 :            :         region_end = ALIGN_DOWN(end, PAGE_SIZE * KASAN_SHADOW_SCALE_SIZE);
     968                 :            : 
     969                 :            :         free_region_start = ALIGN(free_region_start,
     970                 :            :                                   PAGE_SIZE * KASAN_SHADOW_SCALE_SIZE);
     971                 :            : 
     972                 :            :         if (start != region_start &&
     973                 :            :             free_region_start < region_start)
     974                 :            :                 region_start -= PAGE_SIZE * KASAN_SHADOW_SCALE_SIZE;
     975                 :            : 
     976                 :            :         free_region_end = ALIGN_DOWN(free_region_end,
     977                 :            :                                      PAGE_SIZE * KASAN_SHADOW_SCALE_SIZE);
     978                 :            : 
     979                 :            :         if (end != region_end &&
     980                 :            :             free_region_end > region_end)
     981                 :            :                 region_end += PAGE_SIZE * KASAN_SHADOW_SCALE_SIZE;
     982                 :            : 
     983                 :            :         shadow_start = kasan_mem_to_shadow((void *)region_start);
     984                 :            :         shadow_end = kasan_mem_to_shadow((void *)region_end);
     985                 :            : 
     986                 :            :         if (shadow_end > shadow_start) {
     987                 :            :                 size = shadow_end - shadow_start;
     988                 :            :                 apply_to_existing_page_range(&init_mm,
     989                 :            :                                              (unsigned long)shadow_start,
     990                 :            :                                              size, kasan_depopulate_vmalloc_pte,
     991                 :            :                                              NULL);
     992                 :            :                 flush_tlb_kernel_range((unsigned long)shadow_start,
     993                 :            :                                        (unsigned long)shadow_end);
     994                 :            :         }
     995                 :            : }
     996                 :            : #endif

Generated by: LCOV version 1.14