[mmotm:master 14/264] mm/zsmalloc.c:2415:27: error: 'struct zs_pool' has no member named 'migration_wait'

[kbuild test robot <lkp@intel.com>]

[-- Attachment #1: Type: text/plain, Size: 5799 bytes --]

tree:   git://git.cmpxchg.org/linux-mmotm.git master
head:   f50a6baf25034cdc74a3c2a919c455076f776944
commit: 5e656681183d9045de7815921012f5731c16eae3 [14/264] mm/zsmalloc.c: fix race condition in zs_destroy_pool
config: i386-randconfig-c003-201934 (attached as .config)
compiler: gcc-7 (Debian 7.4.0-10) 7.4.0
reproduce:
        git checkout 5e656681183d9045de7815921012f5731c16eae3
        # save the attached .config to linux build tree
        make ARCH=i386 

If you fix the issue, kindly add following tag
Reported-by: kbuild test robot <lkp@intel.com>

All errors (new ones prefixed by >>):

   In file included from include/linux/mmzone.h:10:0,
                    from include/linux/gfp.h:6,
                    from include/linux/umh.h:4,
                    from include/linux/kmod.h:9,
                    from include/linux/module.h:13,
                    from mm/zsmalloc.c:33:
   mm/zsmalloc.c: In function 'zs_create_pool':
>> mm/zsmalloc.c:2415:27: error: 'struct zs_pool' has no member named 'migration_wait'
     init_waitqueue_head(&pool->migration_wait);
                              ^
   include/linux/wait.h:67:26: note: in definition of macro 'init_waitqueue_head'
      __init_waitqueue_head((wq_head), #wq_head, &__key);  \
                             ^~~~~~~

vim +2415 mm/zsmalloc.c

  2388	
  2389	/**
  2390	 * zs_create_pool - Creates an allocation pool to work from.
  2391	 * @name: pool name to be created
  2392	 *
  2393	 * This function must be called before anything when using
  2394	 * the zsmalloc allocator.
  2395	 *
  2396	 * On success, a pointer to the newly created pool is returned,
  2397	 * otherwise NULL.
  2398	 */
  2399	struct zs_pool *zs_create_pool(const char *name)
  2400	{
  2401		int i;
  2402		struct zs_pool *pool;
  2403		struct size_class *prev_class = NULL;
  2404	
  2405		pool = kzalloc(sizeof(*pool), GFP_KERNEL);
  2406		if (!pool)
  2407			return NULL;
  2408	
  2409		init_deferred_free(pool);
  2410	
  2411		pool->name = kstrdup(name, GFP_KERNEL);
  2412		if (!pool->name)
  2413			goto err;
  2414	
> 2415		init_waitqueue_head(&pool->migration_wait);
  2416	
  2417		if (create_cache(pool))
  2418			goto err;
  2419	
  2420		/*
  2421		 * Iterate reversely, because, size of size_class that we want to use
  2422		 * for merging should be larger or equal to current size.
  2423		 */
  2424		for (i = ZS_SIZE_CLASSES - 1; i >= 0; i--) {
  2425			int size;
  2426			int pages_per_zspage;
  2427			int objs_per_zspage;
  2428			struct size_class *class;
  2429			int fullness = 0;
  2430	
  2431			size = ZS_MIN_ALLOC_SIZE + i * ZS_SIZE_CLASS_DELTA;
  2432			if (size > ZS_MAX_ALLOC_SIZE)
  2433				size = ZS_MAX_ALLOC_SIZE;
  2434			pages_per_zspage = get_pages_per_zspage(size);
  2435			objs_per_zspage = pages_per_zspage * PAGE_SIZE / size;
  2436	
  2437			/*
  2438			 * We iterate from biggest down to smallest classes,
  2439			 * so huge_class_size holds the size of the first huge
  2440			 * class. Any object bigger than or equal to that will
  2441			 * endup in the huge class.
  2442			 */
  2443			if (pages_per_zspage != 1 && objs_per_zspage != 1 &&
  2444					!huge_class_size) {
  2445				huge_class_size = size;
  2446				/*
  2447				 * The object uses ZS_HANDLE_SIZE bytes to store the
  2448				 * handle. We need to subtract it, because zs_malloc()
  2449				 * unconditionally adds handle size before it performs
  2450				 * size class search - so object may be smaller than
  2451				 * huge class size, yet it still can end up in the huge
  2452				 * class because it grows by ZS_HANDLE_SIZE extra bytes
  2453				 * right before class lookup.
  2454				 */
  2455				huge_class_size -= (ZS_HANDLE_SIZE - 1);
  2456			}
  2457	
  2458			/*
  2459			 * size_class is used for normal zsmalloc operation such
  2460			 * as alloc/free for that size. Although it is natural that we
  2461			 * have one size_class for each size, there is a chance that we
  2462			 * can get more memory utilization if we use one size_class for
  2463			 * many different sizes whose size_class have same
  2464			 * characteristics. So, we makes size_class point to
  2465			 * previous size_class if possible.
  2466			 */
  2467			if (prev_class) {
  2468				if (can_merge(prev_class, pages_per_zspage, objs_per_zspage)) {
  2469					pool->size_class[i] = prev_class;
  2470					continue;
  2471				}
  2472			}
  2473	
  2474			class = kzalloc(sizeof(struct size_class), GFP_KERNEL);
  2475			if (!class)
  2476				goto err;
  2477	
  2478			class->size = size;
  2479			class->index = i;
  2480			class->pages_per_zspage = pages_per_zspage;
  2481			class->objs_per_zspage = objs_per_zspage;
  2482			spin_lock_init(&class->lock);
  2483			pool->size_class[i] = class;
  2484			for (fullness = ZS_EMPTY; fullness < NR_ZS_FULLNESS;
  2485								fullness++)
  2486				INIT_LIST_HEAD(&class->fullness_list[fullness]);
  2487	
  2488			prev_class = class;
  2489		}
  2490	
  2491		/* debug only, don't abort if it fails */
  2492		zs_pool_stat_create(pool, name);
  2493	
  2494		if (zs_register_migration(pool))
  2495			goto err;
  2496	
  2497		/*
  2498		 * Not critical since shrinker is only used to trigger internal
  2499		 * defragmentation of the pool which is pretty optional thing.  If
  2500		 * registration fails we still can use the pool normally and user can
  2501		 * trigger compaction manually. Thus, ignore return code.
  2502		 */
  2503		zs_register_shrinker(pool);
  2504	
  2505		return pool;
  2506	
  2507	err:
  2508		zs_destroy_pool(pool);
  2509		return NULL;
  2510	}
  2511	EXPORT_SYMBOL_GPL(zs_create_pool);
  2512	

---
0-DAY kernel test infrastructure                Open Source Technology Center
https://lists.01.org/pipermail/kbuild-all                   Intel Corporation

[-- Attachment #2: .config.gz --]
[-- Type: application/gzip, Size: 30977 bytes --]