+3 -20

drivers/base/memory.c

reviewed

··· 97 97 } 98 98 99 99 /* 100 100 - * Show whether the memory block is likely to be offlineable (or is already 101 101 - * offline). Once offline, the memory block could be removed. The return 102 102 - * value does, however, not indicate that there is a way to remove the 103 103 - * memory block. 100 100 + * Legacy interface that we cannot remove. Always indicate "removable" 101 101 + * with CONFIG_MEMORY_HOTREMOVE - bad heuristic. 104 102 */ 105 103 static ssize_t removable_show(struct device *dev, struct device_attribute *attr, 106 104 char *buf) 107 105 { 108 108 - struct memory_block *mem = to_memory_block(dev); 109 109 - unsigned long pfn; 110 110 - int ret = 1, i; 111 111 - 112 112 - if (mem->state != MEM_ONLINE) 113 113 - goto out; 114 114 - 115 115 - for (i = 0; i < sections_per_block; i++) { 116 116 - if (!present_section_nr(mem->start_section_nr + i)) 117 117 - continue; 118 118 - pfn = section_nr_to_pfn(mem->start_section_nr + i); 119 119 - ret &= is_mem_section_removable(pfn, PAGES_PER_SECTION); 120 120 - } 121 121 - 122 122 - out: 123 123 - return sprintf(buf, "%d\n", ret); 106 106 + return sprintf(buf, "%d\n", (int)IS_ENABLED(CONFIG_MEMORY_HOTREMOVE)); 124 107 } 125 108 126 109 /*

+12

include/linux/memcontrol.h

reviewed

··· 695 695 void __mod_lruvec_state(struct lruvec *lruvec, enum node_stat_item idx, 696 696 int val); 697 697 void __mod_lruvec_slab_state(void *p, enum node_stat_item idx, int val); 698 698 + void mod_memcg_obj_state(void *p, int idx, int val); 698 699 699 700 static inline void mod_lruvec_state(struct lruvec *lruvec, 700 701 enum node_stat_item idx, int val) ··· 1124 1123 __mod_node_page_state(page_pgdat(page), idx, val); 1125 1124 } 1126 1125 1126 1126 + static inline void mod_memcg_obj_state(void *p, int idx, int val) 1127 1127 + { 1128 1128 + } 1129 1129 + 1127 1130 static inline 1128 1131 unsigned long mem_cgroup_soft_limit_reclaim(pg_data_t *pgdat, int order, 1129 1132 gfp_t gfp_mask, ··· 1432 1427 return memcg ? memcg->kmemcg_id : -1; 1433 1428 } 1434 1429 1430 1430 + struct mem_cgroup *mem_cgroup_from_obj(void *p); 1431 1431 + 1435 1432 #else 1436 1433 1437 1434 static inline int memcg_kmem_charge(struct page *page, gfp_t gfp, int order) ··· 1473 1466 1474 1467 static inline void memcg_put_cache_ids(void) 1475 1468 { 1469 1469 + } 1470 1470 + 1471 1471 + static inline struct mem_cgroup *mem_cgroup_from_obj(void *p) 1472 1472 + { 1473 1473 + return NULL; 1476 1474 } 1477 1475 1478 1476 #endif /* CONFIG_MEMCG_KMEM */

+2 -2

kernel/fork.c

reviewed

··· 397 397 mod_zone_page_state(page_zone(first_page), NR_KERNEL_STACK_KB, 398 398 THREAD_SIZE / 1024 * account); 399 399 400 400 - mod_memcg_page_state(first_page, MEMCG_KERNEL_STACK_KB, 401 401 - account * (THREAD_SIZE / 1024)); 400 400 + mod_memcg_obj_state(stack, MEMCG_KERNEL_STACK_KB, 401 401 + account * (THREAD_SIZE / 1024)); 402 402 } 403 403 } 404 404

+1 -2

mm/hugetlb_cgroup.c

reviewed

··· 240 240 if (!page_counter_try_charge(&h_cg->hugepage[idx], nr_pages, 241 241 &counter)) { 242 242 ret = -ENOMEM; 243 243 - hugetlb_event(hugetlb_cgroup_from_counter(counter, idx), idx, 244 244 - HUGETLB_MAX); 243 243 + hugetlb_event(h_cg, idx, HUGETLB_MAX); 245 244 } 246 245 css_put(&h_cg->css); 247 246 done:

+38

mm/memcontrol.c

reviewed

··· 777 777 rcu_read_unlock(); 778 778 } 779 779 780 780 + void mod_memcg_obj_state(void *p, int idx, int val) 781 781 + { 782 782 + struct mem_cgroup *memcg; 783 783 + 784 784 + rcu_read_lock(); 785 785 + memcg = mem_cgroup_from_obj(p); 786 786 + if (memcg) 787 787 + mod_memcg_state(memcg, idx, val); 788 788 + rcu_read_unlock(); 789 789 + } 790 790 + 780 791 /** 781 792 * __count_memcg_events - account VM events in a cgroup 782 793 * @memcg: the memory cgroup ··· 2672 2661 } 2673 2662 2674 2663 #ifdef CONFIG_MEMCG_KMEM 2664 2664 + /* 2665 2665 + * Returns a pointer to the memory cgroup to which the kernel object is charged. 2666 2666 + * 2667 2667 + * The caller must ensure the memcg lifetime, e.g. by taking rcu_read_lock(), 2668 2668 + * cgroup_mutex, etc. 2669 2669 + */ 2670 2670 + struct mem_cgroup *mem_cgroup_from_obj(void *p) 2671 2671 + { 2672 2672 + struct page *page; 2673 2673 + 2674 2674 + if (mem_cgroup_disabled()) 2675 2675 + return NULL; 2676 2676 + 2677 2677 + page = virt_to_head_page(p); 2678 2678 + 2679 2679 + /* 2680 2680 + * Slab pages don't have page->mem_cgroup set because corresponding 2681 2681 + * kmem caches can be reparented during the lifetime. That's why 2682 2682 + * memcg_from_slab_page() should be used instead. 2683 2683 + */ 2684 2684 + if (PageSlab(page)) 2685 2685 + return memcg_from_slab_page(page); 2686 2686 + 2687 2687 + /* All other pages use page->mem_cgroup */ 2688 2688 + return page->mem_cgroup; 2689 2689 + } 2690 2690 + 2675 2691 static int memcg_alloc_cache_id(void) 2676 2692 { 2677 2693 int id, size;

+6

mm/sparse.c

reviewed

··· 781 781 ms->usage = NULL; 782 782 } 783 783 memmap = sparse_decode_mem_map(ms->section_mem_map, section_nr); 784 784 + /* 785 785 + * Mark the section invalid so that valid_section() 786 786 + * return false. This prevents code from dereferencing 787 787 + * ms->usage array. 788 788 + */ 789 789 + ms->section_mem_map &= ~SECTION_HAS_MEM_MAP; 784 790 } 785 791 786 792 if (section_is_early && memmap)

+20 -21

mm/swapfile.c

reviewed

··· 2899 2899 p->bdev = inode->i_sb->s_bdev; 2900 2900 } 2901 2901 2902 2902 - inode_lock(inode); 2903 2903 - if (IS_SWAPFILE(inode)) 2904 2904 - return -EBUSY; 2905 2905 - 2906 2902 return 0; 2907 2903 } 2908 2904 ··· 3153 3157 mapping = swap_file->f_mapping; 3154 3158 inode = mapping->host; 3155 3159 3156 3156 - /* will take i_rwsem; */ 3157 3160 error = claim_swapfile(p, inode); 3158 3161 if (unlikely(error)) 3159 3162 goto bad_swap; 3163 3163 + 3164 3164 + inode_lock(inode); 3165 3165 + if (IS_SWAPFILE(inode)) { 3166 3166 + error = -EBUSY; 3167 3167 + goto bad_swap_unlock_inode; 3168 3168 + } 3160 3169 3161 3170 /* 3162 3171 * Read the swap header. 3163 3172 */ 3164 3173 if (!mapping->a_ops->readpage) { 3165 3174 error = -EINVAL; 3166 3166 - goto bad_swap; 3175 3175 + goto bad_swap_unlock_inode; 3167 3176 } 3168 3177 page = read_mapping_page(mapping, 0, swap_file); 3169 3178 if (IS_ERR(page)) { 3170 3179 error = PTR_ERR(page); 3171 3171 - goto bad_swap; 3180 3180 + goto bad_swap_unlock_inode; 3172 3181 } 3173 3182 swap_header = kmap(page); 3174 3183 3175 3184 maxpages = read_swap_header(p, swap_header, inode); 3176 3185 if (unlikely(!maxpages)) { 3177 3186 error = -EINVAL; 3178 3178 - goto bad_swap; 3187 3187 + goto bad_swap_unlock_inode; 3179 3188 } 3180 3189 3181 3190 /* OK, set up the swap map and apply the bad block list */ 3182 3191 swap_map = vzalloc(maxpages); 3183 3192 if (!swap_map) { 3184 3193 error = -ENOMEM; 3185 3185 - goto bad_swap; 3194 3194 + goto bad_swap_unlock_inode; 3186 3195 } 3187 3196 3188 3197 if (bdi_cap_stable_pages_required(inode_to_bdi(inode))) ··· 3212 3211 GFP_KERNEL); 3213 3212 if (!cluster_info) { 3214 3213 error = -ENOMEM; 3215 3215 - goto bad_swap; 3214 3214 + goto bad_swap_unlock_inode; 3216 3215 } 3217 3216 3218 3217 for (ci = 0; ci < nr_cluster; ci++) ··· 3221 3220 p->percpu_cluster = alloc_percpu(struct percpu_cluster); 3222 3221 if (!p->percpu_cluster) { 3223 3222 error = -ENOMEM; 3224 3224 - goto bad_swap; 3223 3223 + goto bad_swap_unlock_inode; 3225 3224 } 3226 3225 for_each_possible_cpu(cpu) { 3227 3226 struct percpu_cluster *cluster; ··· 3235 3234 3236 3235 error = swap_cgroup_swapon(p->type, maxpages); 3237 3236 if (error) 3238 3238 - goto bad_swap; 3237 3237 + goto bad_swap_unlock_inode; 3239 3238 3240 3239 nr_extents = setup_swap_map_and_extents(p, swap_header, swap_map, 3241 3240 cluster_info, maxpages, &span); 3242 3241 if (unlikely(nr_extents < 0)) { 3243 3242 error = nr_extents; 3244 3244 - goto bad_swap; 3243 3243 + goto bad_swap_unlock_inode; 3245 3244 } 3246 3245 /* frontswap enabled? set up bit-per-page map for frontswap */ 3247 3246 if (IS_ENABLED(CONFIG_FRONTSWAP)) ··· 3281 3280 3282 3281 error = init_swap_address_space(p->type, maxpages); 3283 3282 if (error) 3284 3284 - goto bad_swap; 3283 3283 + goto bad_swap_unlock_inode; 3285 3284 3286 3285 /* 3287 3286 * Flush any pending IO and dirty mappings before we start using this ··· 3291 3290 error = inode_drain_writes(inode); 3292 3291 if (error) { 3293 3292 inode->i_flags &= ~S_SWAPFILE; 3294 3294 - goto bad_swap; 3293 3293 + goto bad_swap_unlock_inode; 3295 3294 } 3296 3295 3297 3296 mutex_lock(&swapon_mutex); ··· 3316 3315 3317 3316 error = 0; 3318 3317 goto out; 3318 3318 + bad_swap_unlock_inode: 3319 3319 + inode_unlock(inode); 3319 3320 bad_swap: 3320 3321 free_percpu(p->percpu_cluster); 3321 3322 p->percpu_cluster = NULL; ··· 3325 3322 set_blocksize(p->bdev, p->old_block_size); 3326 3323 blkdev_put(p->bdev, FMODE_READ | FMODE_WRITE | FMODE_EXCL); 3327 3324 } 3325 3325 + inode = NULL; 3328 3326 destroy_swap_extents(p); 3329 3327 swap_cgroup_swapoff(p->type); 3330 3328 spin_lock(&swap_lock); ··· 3337 3333 kvfree(frontswap_map); 3338 3334 if (inced_nr_rotate_swap) 3339 3335 atomic_dec(&nr_rotate_swap); 3340 3340 - if (swap_file) { 3341 3341 - if (inode) { 3342 3342 - inode_unlock(inode); 3343 3343 - inode = NULL; 3344 3344 - } 3336 3336 + if (swap_file) 3345 3337 filp_close(swap_file, NULL); 3346 3346 - } 3347 3338 out: 3348 3339 if (page && !IS_ERR(page)) { 3349 3340 kunmap(page);