LKML Archive on lore.kernel.org
help / color / mirror / Atom feed
From: kernel test robot <lkp@intel.com>
To: Johannes Weiner <hannes@cmpxchg.org>,
	Andrew Morton <akpm@linux-foundation.org>
Cc: kbuild-all@lists.01.org,
	Linux Memory Management List <linux-mm@kvack.org>,
	linux-kernel@vger.kernel.org, kernel-team@fb.com
Subject: Re: [PATCH 4/4] mm: zswap: add basic meminfo and vmstat coverage
Date: Tue, 31 Aug 2021 02:04:28 +0800	[thread overview]
Message-ID: <202108310149.vrh2uOrs-lkp@intel.com> (raw)
In-Reply-To: <20210819195533.211756-4-hannes@cmpxchg.org>

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

Hi Johannes,

I love your patch! Yet something to improve:

[auto build test ERROR on linux/master]
[cannot apply to hnaz-linux-mm/master block/for-next linus/master v5.14 next-20210830]
[If your patch is applied to the wrong git tree, kindly drop us a note.
And when submitting patch, we suggest to use '--base' as documented in
https://git-scm.com/docs/git-format-patch]

url:    https://github.com/0day-ci/linux/commits/Johannes-Weiner/mm-Kconfig-move-swap-and-slab-config-options-to-the-MM-section/20210820-035613
base:   https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git 349a2d52ffe59b7a0c5876fa7ee9f3eaf188b830
config: x86_64-rhel-8.3 (attached as .config)
compiler: gcc-9 (Debian 9.3.0-22) 9.3.0
reproduce (this is a W=1 build):
        # https://github.com/0day-ci/linux/commit/216a0ba919927dccd2dd26d7af1e395f4360002f
        git remote add linux-review https://github.com/0day-ci/linux
        git fetch --no-tags linux-review Johannes-Weiner/mm-Kconfig-move-swap-and-slab-config-options-to-the-MM-section/20210820-035613
        git checkout 216a0ba919927dccd2dd26d7af1e395f4360002f
        # save the attached .config to linux build tree
        mkdir build_dir
        make W=1 O=build_dir ARCH=x86_64 SHELL=/bin/bash

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

All errors (new ones prefixed by >>):

   mm/zswap.c: In function 'zswap_frontswap_store':
>> mm/zswap.c:1234:17: error: 'ZSWAPOUT' undeclared (first use in this function); did you mean 'ZSWPOUT'?
    1234 |  count_vm_event(ZSWAPOUT);
         |                 ^~~~~~~~
         |                 ZSWPOUT
   mm/zswap.c:1234:17: note: each undeclared identifier is reported only once for each function it appears in
   mm/zswap.c: In function 'zswap_frontswap_load':
>> mm/zswap.c:1316:17: error: 'ZSWAPIN' undeclared (first use in this function); did you mean 'ZSWPIN'?
    1316 |  count_vm_event(ZSWAPIN);
         |                 ^~~~~~~
         |                 ZSWPIN


vim +1234 mm/zswap.c

  1080	
  1081	/*********************************
  1082	* frontswap hooks
  1083	**********************************/
  1084	/* attempts to compress and store an single page */
  1085	static int zswap_frontswap_store(unsigned type, pgoff_t offset,
  1086					struct page *page)
  1087	{
  1088		struct zswap_tree *tree = zswap_trees[type];
  1089		struct zswap_entry *entry, *dupentry;
  1090		struct scatterlist input, output;
  1091		struct crypto_acomp_ctx *acomp_ctx;
  1092		int ret;
  1093		unsigned int hlen, dlen = PAGE_SIZE;
  1094		unsigned long handle, value;
  1095		char *buf;
  1096		u8 *src, *dst;
  1097		struct zswap_header zhdr = { .swpentry = swp_entry(type, offset) };
  1098		gfp_t gfp;
  1099	
  1100		/* THP isn't supported */
  1101		if (PageTransHuge(page)) {
  1102			ret = -EINVAL;
  1103			goto reject;
  1104		}
  1105	
  1106		if (!zswap_enabled || !tree) {
  1107			ret = -ENODEV;
  1108			goto reject;
  1109		}
  1110	
  1111		/* reclaim space if needed */
  1112		if (zswap_is_full()) {
  1113			struct zswap_pool *pool;
  1114	
  1115			zswap_pool_limit_hit++;
  1116			zswap_pool_reached_full = true;
  1117			pool = zswap_pool_last_get();
  1118			if (pool)
  1119				queue_work(shrink_wq, &pool->shrink_work);
  1120			ret = -ENOMEM;
  1121			goto reject;
  1122		}
  1123	
  1124		if (zswap_pool_reached_full) {
  1125		       if (!zswap_can_accept()) {
  1126				ret = -ENOMEM;
  1127				goto reject;
  1128			} else
  1129				zswap_pool_reached_full = false;
  1130		}
  1131	
  1132		/* allocate entry */
  1133		entry = zswap_entry_cache_alloc(GFP_KERNEL);
  1134		if (!entry) {
  1135			zswap_reject_kmemcache_fail++;
  1136			ret = -ENOMEM;
  1137			goto reject;
  1138		}
  1139	
  1140		if (zswap_same_filled_pages_enabled) {
  1141			src = kmap_atomic(page);
  1142			if (zswap_is_page_same_filled(src, &value)) {
  1143				kunmap_atomic(src);
  1144				entry->offset = offset;
  1145				entry->length = 0;
  1146				entry->value = value;
  1147				atomic_inc(&zswap_same_filled_pages);
  1148				goto insert_entry;
  1149			}
  1150			kunmap_atomic(src);
  1151		}
  1152	
  1153		/* if entry is successfully added, it keeps the reference */
  1154		entry->pool = zswap_pool_current_get();
  1155		if (!entry->pool) {
  1156			ret = -EINVAL;
  1157			goto freepage;
  1158		}
  1159	
  1160		/* compress */
  1161		acomp_ctx = raw_cpu_ptr(entry->pool->acomp_ctx);
  1162	
  1163		mutex_lock(acomp_ctx->mutex);
  1164	
  1165		dst = acomp_ctx->dstmem;
  1166		sg_init_table(&input, 1);
  1167		sg_set_page(&input, page, PAGE_SIZE, 0);
  1168	
  1169		/* zswap_dstmem is of size (PAGE_SIZE * 2). Reflect same in sg_list */
  1170		sg_init_one(&output, dst, PAGE_SIZE * 2);
  1171		acomp_request_set_params(acomp_ctx->req, &input, &output, PAGE_SIZE, dlen);
  1172		/*
  1173		 * it maybe looks a little bit silly that we send an asynchronous request,
  1174		 * then wait for its completion synchronously. This makes the process look
  1175		 * synchronous in fact.
  1176		 * Theoretically, acomp supports users send multiple acomp requests in one
  1177		 * acomp instance, then get those requests done simultaneously. but in this
  1178		 * case, frontswap actually does store and load page by page, there is no
  1179		 * existing method to send the second page before the first page is done
  1180		 * in one thread doing frontswap.
  1181		 * but in different threads running on different cpu, we have different
  1182		 * acomp instance, so multiple threads can do (de)compression in parallel.
  1183		 */
  1184		ret = crypto_wait_req(crypto_acomp_compress(acomp_ctx->req), &acomp_ctx->wait);
  1185		dlen = acomp_ctx->req->dlen;
  1186	
  1187		if (ret) {
  1188			ret = -EINVAL;
  1189			goto put_dstmem;
  1190		}
  1191	
  1192		/* store */
  1193		hlen = zpool_evictable(entry->pool->zpool) ? sizeof(zhdr) : 0;
  1194		gfp = __GFP_NORETRY | __GFP_NOWARN | __GFP_KSWAPD_RECLAIM;
  1195		if (zpool_malloc_support_movable(entry->pool->zpool))
  1196			gfp |= __GFP_HIGHMEM | __GFP_MOVABLE;
  1197		ret = zpool_malloc(entry->pool->zpool, hlen + dlen, gfp, &handle);
  1198		if (ret == -ENOSPC) {
  1199			zswap_reject_compress_poor++;
  1200			goto put_dstmem;
  1201		}
  1202		if (ret) {
  1203			zswap_reject_alloc_fail++;
  1204			goto put_dstmem;
  1205		}
  1206		buf = zpool_map_handle(entry->pool->zpool, handle, ZPOOL_MM_RW);
  1207		memcpy(buf, &zhdr, hlen);
  1208		memcpy(buf + hlen, dst, dlen);
  1209		zpool_unmap_handle(entry->pool->zpool, handle);
  1210		mutex_unlock(acomp_ctx->mutex);
  1211	
  1212		/* populate entry */
  1213		entry->offset = offset;
  1214		entry->handle = handle;
  1215		entry->length = dlen;
  1216	
  1217	insert_entry:
  1218		/* map */
  1219		spin_lock(&tree->lock);
  1220		do {
  1221			ret = zswap_rb_insert(&tree->rbroot, entry, &dupentry);
  1222			if (ret == -EEXIST) {
  1223				zswap_duplicate_entry++;
  1224				/* remove from rbtree */
  1225				zswap_rb_erase(&tree->rbroot, dupentry);
  1226				zswap_entry_put(tree, dupentry);
  1227			}
  1228		} while (ret == -EEXIST);
  1229		spin_unlock(&tree->lock);
  1230	
  1231		/* update stats */
  1232		atomic_inc(&zswap_stored_pages);
  1233		zswap_update_total_size();
> 1234		count_vm_event(ZSWAPOUT);
  1235	
  1236		return 0;
  1237	
  1238	put_dstmem:
  1239		mutex_unlock(acomp_ctx->mutex);
  1240		zswap_pool_put(entry->pool);
  1241	freepage:
  1242		zswap_entry_cache_free(entry);
  1243	reject:
  1244		return ret;
  1245	}
  1246	
  1247	/*
  1248	 * returns 0 if the page was successfully decompressed
  1249	 * return -1 on entry not found or error
  1250	*/
  1251	static int zswap_frontswap_load(unsigned type, pgoff_t offset,
  1252					struct page *page)
  1253	{
  1254		struct zswap_tree *tree = zswap_trees[type];
  1255		struct zswap_entry *entry;
  1256		struct scatterlist input, output;
  1257		struct crypto_acomp_ctx *acomp_ctx;
  1258		u8 *src, *dst, *tmp;
  1259		unsigned int dlen;
  1260		int ret;
  1261	
  1262		/* find */
  1263		spin_lock(&tree->lock);
  1264		entry = zswap_entry_find_get(&tree->rbroot, offset);
  1265		if (!entry) {
  1266			/* entry was written back */
  1267			spin_unlock(&tree->lock);
  1268			return -1;
  1269		}
  1270		spin_unlock(&tree->lock);
  1271	
  1272		if (!entry->length) {
  1273			dst = kmap_atomic(page);
  1274			zswap_fill_page(dst, entry->value);
  1275			kunmap_atomic(dst);
  1276			ret = 0;
  1277			goto stats;
  1278		}
  1279	
  1280		if (!zpool_can_sleep_mapped(entry->pool->zpool)) {
  1281			tmp = kmalloc(entry->length, GFP_ATOMIC);
  1282			if (!tmp) {
  1283				ret = -ENOMEM;
  1284				goto freeentry;
  1285			}
  1286		}
  1287	
  1288		/* decompress */
  1289		dlen = PAGE_SIZE;
  1290		src = zpool_map_handle(entry->pool->zpool, entry->handle, ZPOOL_MM_RO);
  1291		if (zpool_evictable(entry->pool->zpool))
  1292			src += sizeof(struct zswap_header);
  1293	
  1294		if (!zpool_can_sleep_mapped(entry->pool->zpool)) {
  1295			memcpy(tmp, src, entry->length);
  1296			src = tmp;
  1297			zpool_unmap_handle(entry->pool->zpool, entry->handle);
  1298		}
  1299	
  1300		acomp_ctx = raw_cpu_ptr(entry->pool->acomp_ctx);
  1301		mutex_lock(acomp_ctx->mutex);
  1302		sg_init_one(&input, src, entry->length);
  1303		sg_init_table(&output, 1);
  1304		sg_set_page(&output, page, PAGE_SIZE, 0);
  1305		acomp_request_set_params(acomp_ctx->req, &input, &output, entry->length, dlen);
  1306		ret = crypto_wait_req(crypto_acomp_decompress(acomp_ctx->req), &acomp_ctx->wait);
  1307		mutex_unlock(acomp_ctx->mutex);
  1308	
  1309		if (zpool_can_sleep_mapped(entry->pool->zpool))
  1310			zpool_unmap_handle(entry->pool->zpool, entry->handle);
  1311		else
  1312			kfree(tmp);
  1313	
  1314		BUG_ON(ret);
  1315	stats:
> 1316		count_vm_event(ZSWAPIN);
  1317	freeentry:
  1318		spin_lock(&tree->lock);
  1319		zswap_entry_put(tree, entry);
  1320		spin_unlock(&tree->lock);
  1321	
  1322		return ret;
  1323	}
  1324	

---
0-DAY CI Kernel Test Service, Intel Corporation
https://lists.01.org/hyperkitty/list/kbuild-all@lists.01.org

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

  parent reply	other threads:[~2021-08-30 18:04 UTC|newest]

Thread overview: 13+ messages / expand[flat|nested]  mbox.gz  Atom feed  top
2021-08-19 19:55 [PATCH 1/4] mm: Kconfig: move swap and slab config options to the MM section Johannes Weiner
2021-08-19 19:55 ` [PATCH 2/4] mm: Kconfig: group swap, slab, hotplug and thp options into submenus Johannes Weiner
2021-08-24 12:03   ` Vlastimil Babka
2021-08-24 14:56     ` Johannes Weiner
2021-08-19 19:55 ` [PATCH 3/4] mm: Kconfig: simplify zswap configuration Johannes Weiner
2021-08-24 12:04   ` Vlastimil Babka
2021-08-19 19:55 ` [PATCH 4/4] mm: zswap: add basic meminfo and vmstat coverage Johannes Weiner
2021-08-24 12:05   ` Vlastimil Babka
2021-08-30 18:04   ` kernel test robot [this message]
2021-08-30 18:49   ` Minchan Kim
2021-11-02 15:06     ` Johannes Weiner
2021-11-10 19:11       ` Minchan Kim
2021-08-24 11:47 ` [PATCH 1/4] mm: Kconfig: move swap and slab config options to the MM section Vlastimil Babka

Reply instructions:

You may reply publicly to this message via plain-text email
using any one of the following methods:

* Save the following mbox file, import it into your mail client,
  and reply-to-all from there: mbox

  Avoid top-posting and favor interleaved quoting:
  https://en.wikipedia.org/wiki/Posting_style#Interleaved_style

* Reply using the --to, --cc, and --in-reply-to
  switches of git-send-email(1):

  git send-email \
    --in-reply-to=202108310149.vrh2uOrs-lkp@intel.com \
    --to=lkp@intel.com \
    --cc=akpm@linux-foundation.org \
    --cc=hannes@cmpxchg.org \
    --cc=kbuild-all@lists.01.org \
    --cc=kernel-team@fb.com \
    --cc=linux-kernel@vger.kernel.org \
    --cc=linux-mm@kvack.org \
    --subject='Re: [PATCH 4/4] mm: zswap: add basic meminfo and vmstat coverage' \
    /path/to/YOUR_REPLY

  https://kernel.org/pub/software/scm/git/docs/git-send-email.html

* If your mail client supports setting the In-Reply-To header
  via mailto: links, try the mailto: link

This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for NNTP newsgroup(s).