Re: [PATCH] mempolicy: alloc_pages_mpol() for NUMA policy without vma: fix
From: kernel test robot
Date: Tue Oct 24 2023 - 04:17:55 EST
Hi Hugh,
kernel test robot noticed the following build warnings:
url: https://github.com/intel-lab-lkp/linux/commits/UPDATE-20231024-144517/Hugh-Dickins/hugetlbfs-drop-shared-NUMA-mempolicy-pretence/20231003-173301
base: the 10th patch of https://lore.kernel.org/r/74e34633-6060-f5e3-aee-7040d43f2e93%40google.com
patch link: https://lore.kernel.org/r/00dc4f56-e623-7c85-29ea-4211e93063f6%40google.com
patch subject: [PATCH] mempolicy: alloc_pages_mpol() for NUMA policy without vma: fix
config: m68k-allyesconfig (https://download.01.org/0day-ci/archive/20231024/202310241551.uY40myKo-lkp@xxxxxxxxx/config)
compiler: m68k-linux-gcc (GCC) 13.2.0
reproduce (this is a W=1 build): (https://download.01.org/0day-ci/archive/20231024/202310241551.uY40myKo-lkp@xxxxxxxxx/reproduce)
If you fix the issue in a separate patch/commit (i.e. not just a new version of
the same patch/commit), kindly add following tags
| Reported-by: kernel test robot <lkp@xxxxxxxxx>
| Closes: https://lore.kernel.org/oe-kbuild-all/202310241551.uY40myKo-lkp@xxxxxxxxx/
All warnings (new ones prefixed by >>):
In file included from mm/zswap.c:41:
mm/internal.h: In function 'shrinker_debugfs_name_alloc':
mm/internal.h:1232:9: warning: function 'shrinker_debugfs_name_alloc' might be a candidate for 'gnu_printf' format attribute [-Wsuggest-attribute=format]
1232 | shrinker->name = kvasprintf_const(GFP_KERNEL, fmt, ap);
| ^~~~~~~~
mm/zswap.c: In function 'zswap_writeback_entry':
mm/zswap.c:1322:16: error: implicit declaration of function 'get_task_policy'; did you mean 'get_vma_policy'? [-Werror=implicit-function-declaration]
1322 | mpol = get_task_policy(current);
| ^~~~~~~~~~~~~~~
| get_vma_policy
>> mm/zswap.c:1322:14: warning: assignment to 'struct mempolicy *' from 'int' makes pointer from integer without a cast [-Wint-conversion]
1322 | mpol = get_task_policy(current);
| ^
cc1: some warnings being treated as errors
vim +1322 mm/zswap.c
1282
1283 /*********************************
1284 * writeback code
1285 **********************************/
1286 /*
1287 * Attempts to free an entry by adding a page to the swap cache,
1288 * decompressing the entry data into the page, and issuing a
1289 * bio write to write the page back to the swap device.
1290 *
1291 * This can be thought of as a "resumed writeback" of the page
1292 * to the swap device. We are basically resuming the same swap
1293 * writeback path that was intercepted with the zswap_store()
1294 * in the first place. After the page has been decompressed into
1295 * the swap cache, the compressed version stored by zswap can be
1296 * freed.
1297 */
1298 static int zswap_writeback_entry(struct zswap_entry *entry,
1299 struct zswap_tree *tree)
1300 {
1301 swp_entry_t swpentry = entry->swpentry;
1302 struct page *page;
1303 struct mempolicy *mpol;
1304 struct scatterlist input, output;
1305 struct crypto_acomp_ctx *acomp_ctx;
1306 struct zpool *pool = zswap_find_zpool(entry);
1307 bool page_was_allocated;
1308 u8 *src, *tmp = NULL;
1309 unsigned int dlen;
1310 int ret;
1311 struct writeback_control wbc = {
1312 .sync_mode = WB_SYNC_NONE,
1313 };
1314
1315 if (!zpool_can_sleep_mapped(pool)) {
1316 tmp = kmalloc(PAGE_SIZE, GFP_KERNEL);
1317 if (!tmp)
1318 return -ENOMEM;
1319 }
1320
1321 /* try to allocate swap cache page */
> 1322 mpol = get_task_policy(current);
1323 page = __read_swap_cache_async(swpentry, GFP_KERNEL, mpol,
1324 NO_INTERLEAVE_INDEX, &page_was_allocated);
1325 if (!page) {
1326 ret = -ENOMEM;
1327 goto fail;
1328 }
1329
1330 /* Found an existing page, we raced with load/swapin */
1331 if (!page_was_allocated) {
1332 put_page(page);
1333 ret = -EEXIST;
1334 goto fail;
1335 }
1336
1337 /*
1338 * Page is locked, and the swapcache is now secured against
1339 * concurrent swapping to and from the slot. Verify that the
1340 * swap entry hasn't been invalidated and recycled behind our
1341 * backs (our zswap_entry reference doesn't prevent that), to
1342 * avoid overwriting a new swap page with old compressed data.
1343 */
1344 spin_lock(&tree->lock);
1345 if (zswap_rb_search(&tree->rbroot, swp_offset(entry->swpentry)) != entry) {
1346 spin_unlock(&tree->lock);
1347 delete_from_swap_cache(page_folio(page));
1348 ret = -ENOMEM;
1349 goto fail;
1350 }
1351 spin_unlock(&tree->lock);
1352
1353 /* decompress */
1354 acomp_ctx = raw_cpu_ptr(entry->pool->acomp_ctx);
1355 dlen = PAGE_SIZE;
1356
1357 src = zpool_map_handle(pool, entry->handle, ZPOOL_MM_RO);
1358 if (!zpool_can_sleep_mapped(pool)) {
1359 memcpy(tmp, src, entry->length);
1360 src = tmp;
1361 zpool_unmap_handle(pool, entry->handle);
1362 }
1363
1364 mutex_lock(acomp_ctx->mutex);
1365 sg_init_one(&input, src, entry->length);
1366 sg_init_table(&output, 1);
1367 sg_set_page(&output, page, PAGE_SIZE, 0);
1368 acomp_request_set_params(acomp_ctx->req, &input, &output, entry->length, dlen);
1369 ret = crypto_wait_req(crypto_acomp_decompress(acomp_ctx->req), &acomp_ctx->wait);
1370 dlen = acomp_ctx->req->dlen;
1371 mutex_unlock(acomp_ctx->mutex);
1372
1373 if (!zpool_can_sleep_mapped(pool))
1374 kfree(tmp);
1375 else
1376 zpool_unmap_handle(pool, entry->handle);
1377
1378 BUG_ON(ret);
1379 BUG_ON(dlen != PAGE_SIZE);
1380
1381 /* page is up to date */
1382 SetPageUptodate(page);
1383
1384 /* move it to the tail of the inactive list after end_writeback */
1385 SetPageReclaim(page);
1386
1387 /* start writeback */
1388 __swap_writepage(page, &wbc);
1389 put_page(page);
1390 zswap_written_back_pages++;
1391
1392 return ret;
1393
1394 fail:
1395 if (!zpool_can_sleep_mapped(pool))
1396 kfree(tmp);
1397
1398 /*
1399 * If we get here because the page is already in swapcache, a
1400 * load may be happening concurrently. It is safe and okay to
1401 * not free the entry. It is also okay to return !0.
1402 */
1403 return ret;
1404 }
1405
--
0-DAY CI Kernel Test Service
https://github.com/intel/lkp-tests/wiki