lael-labs/linux

Documentation/admin-guide/kernel-parameters.txt+12−0

@@ -834,6 +834,18 @@ · 833 unmodified lines
834	dump out devices still on the deferred probe list after	834	dump out devices still on the deferred probe list after
835	retrying.	835	retrying.
836		836
		837	dfltcc= [HW,S390]
		838	Format: { on \| off \| def_only \| inf_only \| always }
		839	on: s390 zlib hardware support for compression on
		840	level 1 and decompression (default)
		841	off: No s390 zlib hardware support
		842	def_only: s390 zlib hardware support for deflate
		843	only (compression on level 1)
		844	inf_only: s390 zlib hardware support for inflate
		845	only (decompression)
		846	always: Same as 'on' but ignores the selected compression
		847	level always using hardware support (used for debugging)
		848
837	dhash_entries= [KNL]	849	dhash_entries= [KNL]
838	Set number of hash buckets for dentry cache.	850	Set number of hash buckets for dentry cache.
839		851

Documentation/core-api/index.rst+1−0

@@ -31,6 +31,7 @@ Core utilities · 30 unmodified lines
31	generic-radix-tree	31	generic-radix-tree
32	memory-allocation	32	memory-allocation
33	mm-api	33	mm-api
		34	pin_user_pages
34	gfp_mask-from-fs-io	35	gfp_mask-from-fs-io
35	timekeeping	36	timekeeping
36	boot-time-mm	37	boot-time-mm

Documentation/core-api/pin_user_pages.rst+232−0

@@ -0,0 +1,232 @@
	1	.. SPDX-License-Identifier: GPL-2.0
	2
	3	====================================================
	4	pin_user_pages() and related calls
	5	====================================================
	6
	7	.. contents:: :local:
	8
	9	Overview
	10	========
	11
	12	This document describes the following functions::
	13
	14	pin_user_pages()
	15	pin_user_pages_fast()
	16	pin_user_pages_remote()
	17
	18	Basic description of FOLL_PIN
	19	=============================
	20
	21	FOLL_PIN and FOLL_LONGTERM are flags that can be passed to the get_user_pages*()
	22	("gup") family of functions. FOLL_PIN has significant interactions and
	23	interdependencies with FOLL_LONGTERM, so both are covered here.
	24
	25	FOLL_PIN is internal to gup, meaning that it should not appear at the gup call
	26	sites. This allows the associated wrapper functions (pin_user_pages*() and
	27	others) to set the correct combination of these flags, and to check for problems
	28	as well.
	29
	30	FOLL_LONGTERM, on the other hand, is allowed to be set at the gup call sites.
	31	This is in order to avoid creating a large number of wrapper functions to cover
	32	all combinations of get(), pin(), FOLL_LONGTERM, and more. Also, the
	33	pin_user_pages() APIs are clearly distinct from the get_user_pages() APIs, so
	34	that's a natural dividing line, and a good point to make separate wrapper calls.
	35	In other words, use pin_user_pages*() for DMA-pinned pages, and
	36	get_user_pages*() for other cases. There are four cases described later on in
	37	this document, to further clarify that concept.
	38
	39	FOLL_PIN and FOLL_GET are mutually exclusive for a given gup call. However,
	40	multiple threads and call sites are free to pin the same struct pages, via both
	41	FOLL_PIN and FOLL_GET. It's just the call site that needs to choose one or the
	42	other, not the struct page(s).
	43
	44	The FOLL_PIN implementation is nearly the same as FOLL_GET, except that FOLL_PIN
	45	uses a different reference counting technique.
	46
	47	FOLL_PIN is a prerequisite to FOLL_LONGTERM. Another way of saying that is,
	48	FOLL_LONGTERM is a specific case, more restrictive case of FOLL_PIN.
	49
	50	Which flags are set by each wrapper
	51	===================================
	52
	53	For these pin_user_pages*() functions, FOLL_PIN is OR'd in with whatever gup
	54	flags the caller provides. The caller is required to pass in a non-null struct
	55	pages* array, and the function then pin pages by incrementing each by a special
	56	value. For now, that value is +1, just like get_user_pages*().::
	57
	58	Function
	59	--------
	60	pin_user_pages FOLL_PIN is always set internally by this function.
	61	pin_user_pages_fast FOLL_PIN is always set internally by this function.
	62	pin_user_pages_remote FOLL_PIN is always set internally by this function.
	63
	64	For these get_user_pages*() functions, FOLL_GET might not even be specified.
	65	Behavior is a little more complex than above. If FOLL_GET was not specified,
	66	but the caller passed in a non-null struct pages* array, then the function
	67	sets FOLL_GET for you, and proceeds to pin pages by incrementing the refcount
	68	of each page by +1.::
	69
	70	Function
	71	--------
	72	get_user_pages FOLL_GET is sometimes set internally by this function.
	73	get_user_pages_fast FOLL_GET is sometimes set internally by this function.
	74	get_user_pages_remote FOLL_GET is sometimes set internally by this function.
	75
	76	Tracking dma-pinned pages
	77	=========================
	78
	79	Some of the key design constraints, and solutions, for tracking dma-pinned
	80	pages:
	81
	82	* An actual reference count, per struct page, is required. This is because
	83	multiple processes may pin and unpin a page.
	84
	85	* False positives (reporting that a page is dma-pinned, when in fact it is not)
	86	are acceptable, but false negatives are not.
	87
	88	* struct page may not be increased in size for this, and all fields are already
	89	used.
	90
	91	* Given the above, we can overload the page->_refcount field by using, sort of,
	92	the upper bits in that field for a dma-pinned count. "Sort of", means that,
	93	rather than dividing page->_refcount into bit fields, we simple add a medium-
	94	large value (GUP_PIN_COUNTING_BIAS, initially chosen to be 1024: 10 bits) to
	95	page->_refcount. This provides fuzzy behavior: if a page has get_page() called
	96	on it 1024 times, then it will appear to have a single dma-pinned count.
	97	And again, that's acceptable.
	98
	99	This also leads to limitations: there are only 31-10==21 bits available for a
	100	counter that increments 10 bits at a time.
	101
	102	TODO: for 1GB and larger huge pages, this is cutting it close. That's because
	103	when pin_user_pages() follows such pages, it increments the head page by "1"
	104	(where "1" used to mean "+1" for get_user_pages(), but now means "+1024" for
	105	pin_user_pages()) for each tail page. So if you have a 1GB huge page:
	106
	107	* There are 256K (18 bits) worth of 4 KB tail pages.
	108	* There are 21 bits available to count up via GUP_PIN_COUNTING_BIAS (that is,
	109	10 bits at a time)
	110	* There are 21 - 18 == 3 bits available to count. Except that there aren't,
	111	because you need to allow for a few normal get_page() calls on the head page,
	112	as well. Fortunately, the approach of using addition, rather than "hard"
	113	bitfields, within page->_refcount, allows for sharing these bits gracefully.
	114	But we're still looking at about 8 references.
	115
	116	This, however, is a missing feature more than anything else, because it's easily
	117	solved by addressing an obvious inefficiency in the original get_user_pages()
	118	approach of retrieving pages: stop treating all the pages as if they were
	119	PAGE_SIZE. Retrieve huge pages as huge pages. The callers need to be aware of
	120	this, so some work is required. Once that's in place, this limitation mostly
	121	disappears from view, because there will be ample refcounting range available.
	122
	123	* Callers must specifically request "dma-pinned tracking of pages". In other
	124	words, just calling get_user_pages() will not suffice; a new set of functions,
	125	pin_user_page() and related, must be used.
	126
	127	FOLL_PIN, FOLL_GET, FOLL_LONGTERM: when to use which flags
	128	==========================================================
	129
	130	Thanks to Jan Kara, Vlastimil Babka and several other -mm people, for describing
	131	these categories:
	132
	133	CASE 1: Direct IO (DIO)
	134	-----------------------
	135	There are GUP references to pages that are serving
	136	as DIO buffers. These buffers are needed for a relatively short time (so they
	137	are not "long term"). No special synchronization with page_mkclean() or
	138	munmap() is provided. Therefore, flags to set at the call site are: ::
	139
	140	FOLL_PIN
	141
	142	...but rather than setting FOLL_PIN directly, call sites should use one of
	143	the pin_user_pages*() routines that set FOLL_PIN.
	144
	145	CASE 2: RDMA
	146	------------
	147	There are GUP references to pages that are serving as DMA
	148	buffers. These buffers are needed for a long time ("long term"). No special
	149	synchronization with page_mkclean() or munmap() is provided. Therefore, flags
	150	to set at the call site are: ::
	151
	152	FOLL_PIN \| FOLL_LONGTERM
	153
	154	NOTE: Some pages, such as DAX pages, cannot be pinned with longterm pins. That's
	155	because DAX pages do not have a separate page cache, and so "pinning" implies
	156	locking down file system blocks, which is not (yet) supported in that way.
	157
	158	CASE 3: Hardware with page faulting support
	159	-------------------------------------------
	160	Here, a well-written driver doesn't normally need to pin pages at all. However,
	161	if the driver does choose to do so, it can register MMU notifiers for the range,
	162	and will be called back upon invalidation. Either way (avoiding page pinning, or
	163	using MMU notifiers to unpin upon request), there is proper synchronization with
	164	both filesystem and mm (page_mkclean(), munmap(), etc).
	165
	166	Therefore, neither flag needs to be set.
	167
	168	In this case, ideally, neither get_user_pages() nor pin_user_pages() should be
	169	called. Instead, the software should be written so that it does not pin pages.
	170	This allows mm and filesystems to operate more efficiently and reliably.
	171
	172	CASE 4: Pinning for struct page manipulation only
	173	-------------------------------------------------
	174	Here, normal GUP calls are sufficient, so neither flag needs to be set.
	175
	176	page_dma_pinned(): the whole point of pinning
	177	=============================================
	178
	179	The whole point of marking pages as "DMA-pinned" or "gup-pinned" is to be able
	180	to query, "is this page DMA-pinned?" That allows code such as page_mkclean()
	181	(and file system writeback code in general) to make informed decisions about
	182	what to do when a page cannot be unmapped due to such pins.
	183
	184	What to do in those cases is the subject of a years-long series of discussions
	185	and debates (see the References at the end of this document). It's a TODO item
	186	here: fill in the details once that's worked out. Meanwhile, it's safe to say
	187	that having this available: ::
	188
	189	static inline bool page_dma_pinned(struct page *page)
	190
	191	...is a prerequisite to solving the long-running gup+DMA problem.
	192
	193	Another way of thinking about FOLL_GET, FOLL_PIN, and FOLL_LONGTERM
	194	===================================================================
	195
	196	Another way of thinking about these flags is as a progression of restrictions:
	197	FOLL_GET is for struct page manipulation, without affecting the data that the
	198	struct page refers to. FOLL_PIN is a replacement for FOLL_GET, and is for
	199	short term pins on pages whose data will get accessed. As such, FOLL_PIN is
	200	a "more severe" form of pinning. And finally, FOLL_LONGTERM is an even more
	201	restrictive case that has FOLL_PIN as a prerequisite: this is for pages that
	202	will be pinned longterm, and whose data will be accessed.
	203
	204	Unit testing
	205	============
	206	This file::
	207
	208	tools/testing/selftests/vm/gup_benchmark.c
	209
	210	has the following new calls to exercise the new pin*() wrapper functions:
	211
	212	* PIN_FAST_BENCHMARK (./gup_benchmark -a)
	213	* PIN_BENCHMARK (./gup_benchmark -b)
	214
	215	You can monitor how many total dma-pinned pages have been acquired and released
	216	since the system was booted, via two new /proc/vmstat entries: ::
	217
	218	/proc/vmstat/nr_foll_pin_requested
	219	/proc/vmstat/nr_foll_pin_requested
	220
	221	Those are both going to show zero, unless CONFIG_DEBUG_VM is set. This is
	222	because there is a noticeable performance drop in unpin_user_page(), when they
	223	are activated.
	224
	225	References
	226	==========
	227
	228	* `Some slow progress on get_user_pages() (Apr 2, 2019) <https://lwn.net/Articles/784574/>`_
	229	* `DMA and get_user_pages() (LPC: Dec 12, 2018) <https://lwn.net/Articles/774411/>`_
	230	* `The trouble with get_user_pages() (Apr 30, 2018) <https://lwn.net/Articles/753027/>`_
	231
	232	John Hubbard, October, 2019

Documentation/vm/zswap.rst+13−0

@@ -130,6 +130,19 @@ checking for the same-value filled pages during store operation. However, the · 129 unmodified lines
130	existing pages which are marked as same-value filled pages remain stored	130	existing pages which are marked as same-value filled pages remain stored
131	unchanged in zswap until they are either loaded or invalidated.	131	unchanged in zswap until they are either loaded or invalidated.
132		132
		133	To prevent zswap from shrinking pool when zswap is full and there's a high
		134	pressure on swap (this will result in flipping pages in and out zswap pool
		135	without any real benefit but with a performance drop for the system), a
		136	special parameter has been introduced to implement a sort of hysteresis to
		137	refuse taking pages into zswap pool until it has sufficient space if the limit
		138	has been hit. To set the threshold at which zswap would start accepting pages
		139	again after it became full, use the sysfs ``accept_threhsold_percent``
		140	attribute, e. g.::
		141
		142	echo 80 > /sys/module/zswap/parameters/accept_threhsold_percent
		143
		144	Setting this parameter to 100 will disable the hysteresis.
		145
133	A debugfs interface is provided for various statistic about pool size, number	146	A debugfs interface is provided for various statistic about pool size, number
134	of pages stored, same-value filled pages and various counters for the reasons	147	of pages stored, same-value filled pages and various counters for the reasons
135	pages are rejected.	148	pages are rejected.

arch/powerpc/mm/book3s64/iommu_api.c+5−5

 	for (entry = 0; entry < entries; entry += chunk) {
 		unsigned long n = min(entries - entry, chunk);
-		ret = get_user_pages(ua + (entry << PAGE_SHIFT), n,
+		ret = pin_user_pages(ua + (entry << PAGE_SHIFT), n,
 				FOLL_WRITE | FOLL_LONGTERM,
 				mem->hpages + entry, NULL);
 		if (ret == n) {
 	return 0;
 free_exit:
-	/* free the reference taken */
+	/* free the references taken */
-	for (i = 0; i < pinned; i++)
+	unpin_user_pages(mem->hpages, pinned);
-		put_page(mem->hpages[i]);
 	vfree(mem->hpas);
 	kfree(mem);
 		if (mem->hpas[i] & MM_IOMMU_TABLE_GROUP_PAGE_DIRTY)
 			SetPageDirty(page);
-		put_page(page);
+		unpin_user_page(page);
 		mem->hpas[i] = 0;
 	}
 }

arch/s390/boot/compressed/decompressor.c+4−4

@@ -30,13 +30,13 @@ extern unsigned char _compressed_start[]; · 29 unmodified lines
30	extern unsigned char _compressed_end[];	30	extern unsigned char _compressed_end[];
31		31
32	#ifdef CONFIG_HAVE_KERNEL_BZIP2	32	#ifdef CONFIG_HAVE_KERNEL_BZIP2
33	#define HEAP_SIZE 0x400000	33	#define BOOT_HEAP_SIZE 0x400000
34	#else	34	#else
35	#define HEAP_SIZE 0x10000	35	#define BOOT_HEAP_SIZE 0x10000
36	#endif	36	#endif
37		37
38	static unsigned long free_mem_ptr = (unsigned long) _end;	38	static unsigned long free_mem_ptr = (unsigned long) _end;
39	static unsigned long free_mem_end_ptr = (unsigned long) _end + HEAP_SIZE;	39	static unsigned long free_mem_end_ptr = (unsigned long) _end + BOOT_HEAP_SIZE;
40		40
41	#ifdef CONFIG_KERNEL_GZIP	41	#ifdef CONFIG_KERNEL_GZIP
42	#include "../../../../lib/decompress_inflate.c"	42	#include "../../../../lib/decompress_inflate.c"
@@ -62,7 +62,7 @@ static unsigned long free_mem_end_ptr = (unsigned long) _end + HEAP_SIZE; · 19 unmodified lines
62	#include "../../../../lib/decompress_unxz.c"	62	#include "../../../../lib/decompress_unxz.c"
63	#endif	63	#endif
64		64
65	#define decompress_offset ALIGN((unsigned long)_end + HEAP_SIZE, PAGE_SIZE)	65	#define decompress_offset ALIGN((unsigned long)_end + BOOT_HEAP_SIZE, PAGE_SIZE)
66		66
67	unsigned long mem_safe_offset(void)	67	unsigned long mem_safe_offset(void)
68	{	68	{

arch/s390/boot/ipl_parm.c+14−0

@@ -14,6 +14,7 @@ · 13 unmodified lines
14	char __bootdata(early_command_line)[COMMAND_LINE_SIZE];	14	char __bootdata(early_command_line)[COMMAND_LINE_SIZE];
15	struct ipl_parameter_block __bootdata_preserved(ipl_block);	15	struct ipl_parameter_block __bootdata_preserved(ipl_block);
16	int __bootdata_preserved(ipl_block_valid);	16	int __bootdata_preserved(ipl_block_valid);
		17	unsigned int __bootdata_preserved(zlib_dfltcc_support) = ZLIB_DFLTCC_FULL;
17		18
18	unsigned long __bootdata(vmalloc_size) = VMALLOC_DEFAULT_SIZE;	19	unsigned long __bootdata(vmalloc_size) = VMALLOC_DEFAULT_SIZE;
19	unsigned long __bootdata(memory_end);	20	unsigned long __bootdata(memory_end);
@@ -229,6 +230,19 @@ void parse_boot_command_line(void) · 209 unmodified lines
229	if (!strcmp(param, "vmalloc") && val)	230	if (!strcmp(param, "vmalloc") && val)
230	vmalloc_size = round_up(memparse(val, NULL), PAGE_SIZE);	231	vmalloc_size = round_up(memparse(val, NULL), PAGE_SIZE);
231		232
		233	if (!strcmp(param, "dfltcc")) {
		234	if (!strcmp(val, "off"))
		235	zlib_dfltcc_support = ZLIB_DFLTCC_DISABLED;
		236	else if (!strcmp(val, "on"))
		237	zlib_dfltcc_support = ZLIB_DFLTCC_FULL;
		238	else if (!strcmp(val, "def_only"))
		239	zlib_dfltcc_support = ZLIB_DFLTCC_DEFLATE_ONLY;
		240	else if (!strcmp(val, "inf_only"))
		241	zlib_dfltcc_support = ZLIB_DFLTCC_INFLATE_ONLY;
		242	else if (!strcmp(val, "always"))
		243	zlib_dfltcc_support = ZLIB_DFLTCC_FULL_DEBUG;
		244	}
		245
232	if (!strcmp(param, "noexec")) {	246	if (!strcmp(param, "noexec")) {
233	rc = kstrtobool(val, &enabled);	247	rc = kstrtobool(val, &enabled);
234	if (!rc && !enabled)	248	if (!rc && !enabled)

arch/s390/include/asm/setup.h+7−0

@@ -79,6 +79,13 @@ struct parmarea { · 78 unmodified lines
79	char command_line[ARCH_COMMAND_LINE_SIZE]; /* 0x10480 */	79	char command_line[ARCH_COMMAND_LINE_SIZE]; /* 0x10480 */
80	};	80	};
81		81
		82	extern unsigned int zlib_dfltcc_support;
		83	#define ZLIB_DFLTCC_DISABLED 0
		84	#define ZLIB_DFLTCC_FULL 1
		85	#define ZLIB_DFLTCC_DEFLATE_ONLY 2
		86	#define ZLIB_DFLTCC_INFLATE_ONLY 3
		87	#define ZLIB_DFLTCC_FULL_DEBUG 4
		88
82	extern int noexec_disabled;	89	extern int noexec_disabled;
83	extern int memory_end_set;	90	extern int memory_end_set;
84	extern unsigned long memory_end;	91	extern unsigned long memory_end;

arch/s390/kernel/setup.c+5−9

 unsigned long __bootdata_preserved(__sdma);
 unsigned long __bootdata_preserved(__edma);
 unsigned long __bootdata_preserved(__kaslr_offset);
+unsigned int __bootdata_preserved(zlib_dfltcc_support);
+EXPORT_SYMBOL(zlib_dfltcc_support);
 unsigned long VMALLOC_START;
 EXPORT_SYMBOL(VMALLOC_START);
 		memblock_free(start, size);
 }
-static void __init memblock_physmem_add(phys_addr_t start, phys_addr_t size)
-{
-	memblock_dbg("memblock_physmem_add: [%#016llx-%#016llx]\n",
-		     start, start + size - 1);
-	memblock_add_range(&memblock.memory, start, size, 0, 0);
-	memblock_add_range(&memblock.physmem, start, size, 0, 0);
-}
 static const char * __init get_mem_info_source(void)
 {
 	switch (mem_detect.info_source) {
 		     get_mem_info_source(), mem_detect.info_source);
 	/* keep memblock lists close to the kernel */
 	memblock_set_bottom_up(true);
-	for_each_mem_detect_block(i, &start, &end)
+	for_each_mem_detect_block(i, &start, &end) {
+		memblock_add(start, end - start);
 		memblock_physmem_add(start, end - start);
+	}
 	memblock_set_bottom_up(false);
 	memblock_dump_all();
 }

drivers/acpi/thermal.c+18−16

 #include <linux/acpi.h>
 #include <linux/workqueue.h>
 #include <linux/uaccess.h>
+#include <linux/units.h>
 #define PREFIX "ACPI: "
 	struct acpi_handle_list devices;
 	struct thermal_zone_device *thermal_zone;
 	int tz_enabled;
-	int kelvin_offset;
+	int kelvin_offset;	/* in millidegrees */
 	struct work_struct thermal_check_work;
 };
 			if (crt == -1) {
 				tz->trips.critical.flags.valid = 0;
 			} else if (crt > 0) {
-				unsigned long crt_k = CELSIUS_TO_DECI_KELVIN(crt);
+				unsigned long crt_k = celsius_to_deci_kelvin(crt);
 				/*
 				 * Allow override critical threshold
 				 */
 		if (psv == -1) {
 			status = AE_SUPPORT;
 		} else if (psv > 0) {
-			tmp = CELSIUS_TO_DECI_KELVIN(psv);
+			tmp = celsius_to_deci_kelvin(psv);
 			status = AE_OK;
 		} else {
 			status = acpi_evaluate_integer(tz->device->handle,
 					break;
 				if (i == 1)
 					tz->trips.active[0].temperature =
-						CELSIUS_TO_DECI_KELVIN(act);
+						celsius_to_deci_kelvin(act);
 				else
 					/*
 					 * Don't allow override higher than
 					 */
 					tz->trips.active[i - 1].temperature =
 						(tz->trips.active[i - 2].temperature <
-						CELSIUS_TO_DECI_KELVIN(act) ?
+						celsius_to_deci_kelvin(act) ?
 						tz->trips.active[i - 2].temperature :
-						CELSIUS_TO_DECI_KELVIN(act));
+						celsius_to_deci_kelvin(act));
 				break;
 			} else {
 				tz->trips.active[i].temperature = tmp;
 	if (result)
 		return result;
-	*temp = DECI_KELVIN_TO_MILLICELSIUS_WITH_OFFSET(tz->temperature,
+	*temp = deci_kelvin_to_millicelsius_with_offset(tz->temperature,
 							tz->kelvin_offset);
 	return 0;
 }
 	if (tz->trips.critical.flags.valid) {
 		if (!trip) {
-			*temp = DECI_KELVIN_TO_MILLICELSIUS_WITH_OFFSET(
+			*temp = deci_kelvin_to_millicelsius_with_offset(
 				tz->trips.critical.temperature,
 				tz->kelvin_offset);
 			return 0;
 	if (tz->trips.hot.flags.valid) {
 		if (!trip) {
-			*temp = DECI_KELVIN_TO_MILLICELSIUS_WITH_OFFSET(
+			*temp = deci_kelvin_to_millicelsius_with_offset(
 				tz->trips.hot.temperature,
 				tz->kelvin_offset);
 			return 0;
 	if (tz->trips.passive.flags.valid) {
 		if (!trip) {
-			*temp = DECI_KELVIN_TO_MILLICELSIUS_WITH_OFFSET(
+			*temp = deci_kelvin_to_millicelsius_with_offset(
 				tz->trips.passive.temperature,
 				tz->kelvin_offset);
 			return 0;
 	for (i = 0; i < ACPI_THERMAL_MAX_ACTIVE &&
 		tz->trips.active[i].flags.valid; i++) {
 		if (!trip) {
-			*temp = DECI_KELVIN_TO_MILLICELSIUS_WITH_OFFSET(
+			*temp = deci_kelvin_to_millicelsius_with_offset(
 				tz->trips.active[i].temperature,
 				tz->kelvin_offset);
 			return 0;
 	struct acpi_thermal *tz = thermal->devdata;
 	if (tz->trips.critical.flags.valid) {
-		*temperature = DECI_KELVIN_TO_MILLICELSIUS_WITH_OFFSET(
+		*temperature = deci_kelvin_to_millicelsius_with_offset(
 				tz->trips.critical.temperature,
 				tz->kelvin_offset);
 		return 0;
 	if (type == THERMAL_TRIP_ACTIVE) {
 		int trip_temp;
-		int temp = DECI_KELVIN_TO_MILLICELSIUS_WITH_OFFSET(
+		int temp = deci_kelvin_to_millicelsius_with_offset(
 					tz->temperature, tz->kelvin_offset);
 		if (thermal_get_trip_temp(thermal, trip, &trip_temp))
 			return -EINVAL;
 {
 	if (tz->trips.critical.flags.valid &&
 	    (tz->trips.critical.temperature % 5) == 1)
-		tz->kelvin_offset = 2731;
+		tz->kelvin_offset = 273100;
 	else
-		tz->kelvin_offset = 2732;
+		tz->kelvin_offset = 273200;
 }
 static void acpi_thermal_check_fn(struct work_struct *work)
 	INIT_WORK(&tz->thermal_check_work, acpi_thermal_check_fn);
 	pr_info(PREFIX "%s [%s] (%ld C)\n", acpi_device_name(device),
-		acpi_device_bid(device), DECI_KELVIN_TO_CELSIUS(tz->temperature));
+		acpi_device_bid(device), deci_kelvin_to_celsius(tz->temperature));
 	goto end;
 free_memory:

drivers/base/memory.c+3−22

 }
 EXPORT_SYMBOL(unregister_memory_notifier);
-static ATOMIC_NOTIFIER_HEAD(memory_isolate_chain);
-int register_memory_isolate_notifier(struct notifier_block *nb)
-{
-	return atomic_notifier_chain_register(&memory_isolate_chain, nb);
-}
-EXPORT_SYMBOL(register_memory_isolate_notifier);
-void unregister_memory_isolate_notifier(struct notifier_block *nb)
-{
-	atomic_notifier_chain_unregister(&memory_isolate_chain, nb);
-}
-EXPORT_SYMBOL(unregister_memory_isolate_notifier);
 static void memory_block_release(struct device *dev)
 {
 	struct memory_block *mem = to_memory_block(dev);
 	return blocking_notifier_call_chain(&memory_chain, val, v);
 }
-int memory_isolate_notify(unsigned long val, void *v)
-{
-	return atomic_notifier_call_chain(&memory_isolate_chain, val, v);
-}
 /*
  * The probe routines leave the pages uninitialized, just as the bootmem code
  * does. Make sure we do not access them, but instead use only information from
  */
 static int
 memory_block_action(unsigned long start_section_nr, unsigned long action,
-		    int online_type)
+		    int online_type, int nid)
 {
 	unsigned long start_pfn;
 	unsigned long nr_pages = PAGES_PER_SECTION * sections_per_block;
 		if (!pages_correctly_probed(start_pfn))
 			return -EBUSY;
-		ret = online_pages(start_pfn, nr_pages, online_type);
+		ret = online_pages(start_pfn, nr_pages, online_type, nid);
 		break;
 	case MEM_OFFLINE:
 		ret = offline_pages(start_pfn, nr_pages);
 		mem->state = MEM_GOING_OFFLINE;
 	ret = memory_block_action(mem->start_section_nr, to_state,
-				mem->online_type);
+				  mem->online_type, mem->nid);
 	mem->state = ret ? from_state_req : to_state;

drivers/block/zram/zram_drv.c+6−4

 static bool page_same_filled(void *ptr, unsigned long *element)
 {
-	unsigned int pos;
 	unsigned long *page;
 	unsigned long val;
+	unsigned int pos, last_pos = PAGE_SIZE / sizeof(*page) - 1;
 	page = (unsigned long *)ptr;
 	val = page[0];
-	for (pos = 1; pos < PAGE_SIZE / sizeof(*page); pos++) {
+	if (val != page[last_pos])
+		return false;
+	for (pos = 1; pos < last_pos; pos++) {
 		if (val != page[pos])
 			return false;
 	}
 	struct bio bio;
 	struct bio_vec bio_vec;
 	struct page *page;
-	ssize_t ret;
+	ssize_t ret = len;
 	int mode;
 	unsigned long blk_idx = 0;
 	if (blk_idx)
 		free_block_bdev(zram, blk_idx);
-	ret = len;
 	__free_page(page);
 release_init_lock:
 	up_read(&zram->init_lock);

drivers/gpu/drm/via/via_dmablit.c+3−3

@@ -188,8 +188,8 @@ via_free_sg_info(struct pci_dev pdev, drm_via_sg_info_t vsg) · 187 unmodified lines
188	kfree(vsg->desc_pages);	188	kfree(vsg->desc_pages);
189	/* fall through */	189	/* fall through */
190	case dr_via_pages_locked:	190	case dr_via_pages_locked:
191	put_user_pages_dirty_lock(vsg->pages, vsg->num_pages,	191	unpin_user_pages_dirty_lock(vsg->pages, vsg->num_pages,
192	(vsg->direction == DMA_FROM_DEVICE));	192	(vsg->direction == DMA_FROM_DEVICE));
193	/* fall through */	193	/* fall through */
194	case dr_via_pages_alloc:	194	case dr_via_pages_alloc:
195	vfree(vsg->pages);	195	vfree(vsg->pages);
@@ -239,7 +239,7 @@ via_lock_all_dma_pages(drm_via_sg_info_t vsg, drm_via_dmablit_t xfer) · 43 unmodified lines
239	vsg->pages = vzalloc(array_size(sizeof(struct page *), vsg->num_pages));	239	vsg->pages = vzalloc(array_size(sizeof(struct page *), vsg->num_pages));
240	if (NULL == vsg->pages)	240	if (NULL == vsg->pages)
241	return -ENOMEM;	241	return -ENOMEM;
242	ret = get_user_pages_fast((unsigned long)xfer->mem_addr,	242	ret = pin_user_pages_fast((unsigned long)xfer->mem_addr,
243	vsg->num_pages,	243	vsg->num_pages,
244	vsg->direction == DMA_FROM_DEVICE ? FOLL_WRITE : 0,	244	vsg->direction == DMA_FROM_DEVICE ? FOLL_WRITE : 0,
245	vsg->pages);	245	vsg->pages);

drivers/iio/adc/qcom-vadc-common.c+3−3

 #include <linux/log2.h>
 #include <linux/err.h>
 #include <linux/module.h>
+#include <linux/units.h>
 #include "qcom-vadc-common.h"
 		voltage = 0;
 	}
-	voltage -= KELVINMIL_CELSIUSMIL;
+	*result_mdec = milli_kelvin_to_millicelsius(voltage);
-	*result_mdec = voltage;
 	return 0;
 }
 {
 	*result_mdec = qcom_vadc_scale_code_voltage_factor(adc_code,
 				prescale, data, 2);
-	*result_mdec -= KELVINMIL_CELSIUSMIL;
+	*result_mdec = milli_kelvin_to_millicelsius(*result_mdec);
 	return 0;
 }

drivers/iio/adc/qcom-vadc-common.h+0−1

@@ -38,7 +38,6 @@ · 37 unmodified lines
38	#define VADC_AVG_SAMPLES_MAX 512	38	#define VADC_AVG_SAMPLES_MAX 512
39	#define ADC5_AVG_SAMPLES_MAX 16	39	#define ADC5_AVG_SAMPLES_MAX 16
40		40
41	#define KELVINMIL_CELSIUSMIL 273150
42	#define PMIC5_CHG_TEMP_SCALE_FACTOR 377500	41	#define PMIC5_CHG_TEMP_SCALE_FACTOR 377500
43	#define PMIC5_SMB_TEMP_CONSTANT 419400	42	#define PMIC5_SMB_TEMP_CONSTANT 419400
44	#define PMIC5_SMB_TEMP_SCALE_FACTOR 356	43	#define PMIC5_SMB_TEMP_SCALE_FACTOR 356

drivers/infiniband/core/umem.c+7−12

 	for_each_sg_page(umem->sg_head.sgl, &sg_iter, umem->sg_nents, 0) {
 		page = sg_page_iter_page(&sg_iter);
-		put_user_pages_dirty_lock(&page, 1, umem->writable && dirty);
+		unpin_user_pages_dirty_lock(&page, 1, umem->writable && dirty);
 	}
 	sg_free_table(&umem->sg_head);
 	sg = umem->sg_head.sgl;
 	while (npages) {
-		down_read(&mm->mmap_sem);
+		ret = pin_user_pages_fast(cur_base,
-		ret = get_user_pages(cur_base,
+					  min_t(unsigned long, npages,
-				     min_t(unsigned long, npages,
+						PAGE_SIZE /
-					   PAGE_SIZE / sizeof (struct page *)),
+						sizeof(struct page *)),
-				     gup_flags | FOLL_LONGTERM,
+					  gup_flags | FOLL_LONGTERM, page_list);
-				     page_list, NULL);
+		if (ret < 0)
-		if (ret < 0) {
-			up_read(&mm->mmap_sem);
 			goto umem_release;
-		}
 		cur_base += ret * PAGE_SIZE;
 		npages   -= ret;
 		sg = ib_umem_add_sg_table(sg, page_list, ret,
 			dma_get_max_seg_size(device->dma_device),
 			&umem->sg_nents);
-		up_read(&mm->mmap_sem);
 	}
 	sg_mark_end(sg);

drivers/infiniband/core/umem_odp.c+6−7

  * The function returns -EFAULT if the DMA mapping operation fails. It returns
  * -EAGAIN if a concurrent invalidation prevents us from updating the page.
  *
- * The page is released via put_user_page even if the operation failed. For
+ * The page is released via put_page even if the operation failed. For on-demand
- * on-demand pinning, the page is released whenever it isn't stored in the
+ * pinning, the page is released whenever it isn't stored in the umem.
- * umem.
  */
 static int ib_umem_odp_map_dma_single_page(
 		struct ib_umem_odp *umem_odp,
 	}
 out:
-	put_user_page(page);
+	put_page(page);
 	return ret;
 }
 					ret = -EFAULT;
 					break;
 				}
-				put_user_page(local_page_list[j]);
+				put_page(local_page_list[j]);
 				continue;
 			}
 			 * ib_umem_odp_map_dma_single_page().
 			 */
 			if (npages - (j + 1) > 0)
-				put_user_pages(&local_page_list[j+1],
+				release_pages(&local_page_list[j+1],
-					       npages - (j + 1));
+					      npages - (j + 1));
 			break;
 		}
 	}

drivers/infiniband/hw/hfi1/user_pages.c+2−2

@@ -106,7 +106,7 @@ int hfi1_acquire_user_pages(struct mm_struct *mm, unsigned long vaddr, size_t np · 105 unmodified lines
106	int ret;	106	int ret;
107	unsigned int gup_flags = FOLL_LONGTERM \| (writable ? FOLL_WRITE : 0);	107	unsigned int gup_flags = FOLL_LONGTERM \| (writable ? FOLL_WRITE : 0);
108		108
109	ret = get_user_pages_fast(vaddr, npages, gup_flags, pages);	109	ret = pin_user_pages_fast(vaddr, npages, gup_flags, pages);
110	if (ret < 0)	110	if (ret < 0)
111	return ret;	111	return ret;
112		112
@@ -118,7 +118,7 @@ int hfi1_acquire_user_pages(struct mm_struct *mm, unsigned long vaddr, size_t np · 5 unmodified lines
118	void hfi1_release_user_pages(struct mm_struct mm, struct page *p,	118	void hfi1_release_user_pages(struct mm_struct mm, struct page *p,
119	size_t npages, bool dirty)	119	size_t npages, bool dirty)
120	{	120	{
121	put_user_pages_dirty_lock(p, npages, dirty);	121	unpin_user_pages_dirty_lock(p, npages, dirty);
122		122
123	if (mm) { /* during close after signal, mm can be NULL */	123	if (mm) { /* during close after signal, mm can be NULL */
124	atomic64_sub(npages, &mm->pinned_vm);	124	atomic64_sub(npages, &mm->pinned_vm);

drivers/infiniband/hw/mthca/mthca_memfree.c+4−4

@@ -472,7 +472,7 @@ int mthca_map_user_db(struct mthca_dev dev, struct mthca_uar uar, · 471 unmodified lines
472	goto out;	472	goto out;
473	}	473	}
474		474
475	ret = get_user_pages_fast(uaddr & PAGE_MASK, 1,	475	ret = pin_user_pages_fast(uaddr & PAGE_MASK, 1,
476	FOLL_WRITE \| FOLL_LONGTERM, pages);	476	FOLL_WRITE \| FOLL_LONGTERM, pages);
477	if (ret < 0)	477	if (ret < 0)
478	goto out;	478	goto out;
@@ -482,7 +482,7 @@ int mthca_map_user_db(struct mthca_dev dev, struct mthca_uar uar, · 3 unmodified lines
482		482
483	ret = pci_map_sg(dev->pdev, &db_tab->page[i].mem, 1, PCI_DMA_TODEVICE);	483	ret = pci_map_sg(dev->pdev, &db_tab->page[i].mem, 1, PCI_DMA_TODEVICE);
484	if (ret < 0) {	484	if (ret < 0) {
485	put_user_page(pages[0]);	485	unpin_user_page(pages[0]);
486	goto out;	486	goto out;
487	}	487	}
488		488
@@ -490,7 +490,7 @@ int mthca_map_user_db(struct mthca_dev dev, struct mthca_uar uar, · 1 unmodified line
490	mthca_uarc_virt(dev, uar, i));	490	mthca_uarc_virt(dev, uar, i));
491	if (ret) {	491	if (ret) {
492	pci_unmap_sg(dev->pdev, &db_tab->page[i].mem, 1, PCI_DMA_TODEVICE);	492	pci_unmap_sg(dev->pdev, &db_tab->page[i].mem, 1, PCI_DMA_TODEVICE);
493	put_user_page(sg_page(&db_tab->page[i].mem));	493	unpin_user_page(sg_page(&db_tab->page[i].mem));
494	goto out;	494	goto out;
495	}	495	}
496		496
@@ -556,7 +556,7 @@ void mthca_cleanup_user_db_tab(struct mthca_dev dev, struct mthca_uar uar, · 59 unmodified lines
556	if (db_tab->page[i].uvirt) {	556	if (db_tab->page[i].uvirt) {
557	mthca_UNMAP_ICM(dev, mthca_uarc_virt(dev, uar, i), 1);	557	mthca_UNMAP_ICM(dev, mthca_uarc_virt(dev, uar, i), 1);
558	pci_unmap_sg(dev->pdev, &db_tab->page[i].mem, 1, PCI_DMA_TODEVICE);	558	pci_unmap_sg(dev->pdev, &db_tab->page[i].mem, 1, PCI_DMA_TODEVICE);
559	put_user_page(sg_page(&db_tab->page[i].mem));	559	unpin_user_page(sg_page(&db_tab->page[i].mem));
560	}	560	}
561	}	561	}
562		562

drivers/infiniband/hw/qib/qib_user_pages.c+2−2

@@ -40,7 +40,7 @@ · 39 unmodified lines
40	static void __qib_release_user_pages(struct page **p, size_t num_pages,	40	static void __qib_release_user_pages(struct page **p, size_t num_pages,
41	int dirty)	41	int dirty)
42	{	42	{
43	put_user_pages_dirty_lock(p, num_pages, dirty);	43	unpin_user_pages_dirty_lock(p, num_pages, dirty);
44	}	44	}
45		45
46	/**	46	/**
@@ -108,7 +108,7 @@ int qib_get_user_pages(unsigned long start_page, size_t num_pages, · 61 unmodified lines
108		108
109	down_read(&current->mm->mmap_sem);	109	down_read(&current->mm->mmap_sem);
110	for (got = 0; got < num_pages; got += ret) {	110	for (got = 0; got < num_pages; got += ret) {
111	ret = get_user_pages(start_page + got * PAGE_SIZE,	111	ret = pin_user_pages(start_page + got * PAGE_SIZE,
112	num_pages - got,	112	num_pages - got,
113	FOLL_LONGTERM \| FOLL_WRITE \| FOLL_FORCE,	113	FOLL_LONGTERM \| FOLL_WRITE \| FOLL_FORCE,
114	p + got, NULL);	114	p + got, NULL);

drivers/infiniband/hw/qib/qib_user_sdma.c+4−4

@@ -317,7 +317,7 @@ static int qib_user_sdma_page_to_frags(const struct qib_devdata *dd, · 316 unmodified lines
317	* the caller can ignore this page.	317	* the caller can ignore this page.
318	*/	318	*/
319	if (put) {	319	if (put) {
320	put_user_page(page);	320	unpin_user_page(page);
321	} else {	321	} else {
322	/* coalesce case */	322	/* coalesce case */
323	kunmap(page);	323	kunmap(page);
@@ -631,7 +631,7 @@ static void qib_user_sdma_free_pkt_frag(struct device *dev, · 307 unmodified lines
631	kunmap(pkt->addr[i].page);	631	kunmap(pkt->addr[i].page);
632		632
633	if (pkt->addr[i].put_page)	633	if (pkt->addr[i].put_page)
634	put_user_page(pkt->addr[i].page);	634	unpin_user_page(pkt->addr[i].page);
635	else	635	else
636	__free_page(pkt->addr[i].page);	636	__free_page(pkt->addr[i].page);
637	} else if (pkt->addr[i].kvaddr) {	637	} else if (pkt->addr[i].kvaddr) {
@@ -670,7 +670,7 @@ static int qib_user_sdma_pin_pages(const struct qib_devdata *dd, · 32 unmodified lines
670	else	670	else
671	j = npages;	671	j = npages;
672		672
673	ret = get_user_pages_fast(addr, j, FOLL_LONGTERM, pages);	673	ret = pin_user_pages_fast(addr, j, FOLL_LONGTERM, pages);
674	if (ret != j) {	674	if (ret != j) {
675	i = 0;	675	i = 0;
676	j = ret;	676	j = ret;
@@ -706,7 +706,7 @@ static int qib_user_sdma_pin_pages(const struct qib_devdata *dd, · 29 unmodified lines
706	/* if error, return all pages not managed by pkt */	706	/* if error, return all pages not managed by pkt */
707	free_pages:	707	free_pages:
708	while (i < j)	708	while (i < j)
709	put_user_page(pages[i++]);	709	unpin_user_page(pages[i++]);
710		710
711	done:	711	done:
712	return ret;	712	return ret;

drivers/infiniband/hw/usnic/usnic_uiom.c+2−2

@@ -75,7 +75,7 @@ static void usnic_uiom_put_pages(struct list_head *chunk_list, int dirty) · 74 unmodified lines
75	for_each_sg(chunk->page_list, sg, chunk->nents, i) {	75	for_each_sg(chunk->page_list, sg, chunk->nents, i) {
76	page = sg_page(sg);	76	page = sg_page(sg);
77	pa = sg_phys(sg);	77	pa = sg_phys(sg);
78	put_user_pages_dirty_lock(&page, 1, dirty);	78	unpin_user_pages_dirty_lock(&page, 1, dirty);
79	usnic_dbg("pa: %pa\n", &pa);	79	usnic_dbg("pa: %pa\n", &pa);
80	}	80	}
81	kfree(chunk);	81	kfree(chunk);
@@ -141,7 +141,7 @@ static int usnic_uiom_get_pages(unsigned long addr, size_t size, int writable, · 59 unmodified lines
141	ret = 0;	141	ret = 0;
142		142
143	while (npages) {	143	while (npages) {
144	ret = get_user_pages(cur_base,	144	ret = pin_user_pages(cur_base,
145	min_t(unsigned long, npages,	145	min_t(unsigned long, npages,
146	PAGE_SIZE / sizeof(struct page *)),	146	PAGE_SIZE / sizeof(struct page *)),
147	gup_flags \| FOLL_LONGTERM,	147	gup_flags \| FOLL_LONGTERM,

drivers/infiniband/sw/siw/siw_mem.c+2−2

@@ -63,7 +63,7 @@ struct siw_mem siw_mem_id2obj(struct siw_device sdev, int stag_index) · 62 unmodified lines
63	static void siw_free_plist(struct siw_page_chunk *chunk, int num_pages,	63	static void siw_free_plist(struct siw_page_chunk *chunk, int num_pages,
64	bool dirty)	64	bool dirty)
65	{	65	{
66	put_user_pages_dirty_lock(chunk->plist, num_pages, dirty);	66	unpin_user_pages_dirty_lock(chunk->plist, num_pages, dirty);
67	}	67	}
68		68
69	void siw_umem_release(struct siw_umem *umem, bool dirty)	69	void siw_umem_release(struct siw_umem *umem, bool dirty)
@@ -426,7 +426,7 @@ struct siw_umem *siw_umem_get(u64 start, u64 len, bool writable) · 356 unmodified lines
426	while (nents) {	426	while (nents) {
427	struct page **plist = &umem->page_chunk[i].plist[got];	427	struct page **plist = &umem->page_chunk[i].plist[got];
428		428
429	rv = get_user_pages(first_page_va, nents,	429	rv = pin_user_pages(first_page_va, nents,
430	foll_flags \| FOLL_LONGTERM,	430	foll_flags \| FOLL_LONGTERM,
431	plist, NULL);	431	plist, NULL);
432	if (rv < 0)	432	if (rv < 0)

drivers/media/v4l2-core/videobuf-dma-sg.c+4−4

@@ -183,12 +183,12 @@ static int videobuf_dma_init_user_locked(struct videobuf_dmabuf *dma, · 182 unmodified lines
183	dprintk(1, "init user [0x%lx+0x%lx => %d pages]\n",	183	dprintk(1, "init user [0x%lx+0x%lx => %d pages]\n",
184	data, size, dma->nr_pages);	184	data, size, dma->nr_pages);
185		185
186	err = get_user_pages(data & PAGE_MASK, dma->nr_pages,	186	err = pin_user_pages(data & PAGE_MASK, dma->nr_pages,
187	flags \| FOLL_LONGTERM, dma->pages, NULL);	187	flags \| FOLL_LONGTERM, dma->pages, NULL);
188		188
189	if (err != dma->nr_pages) {	189	if (err != dma->nr_pages) {
190	dma->nr_pages = (err >= 0) ? err : 0;	190	dma->nr_pages = (err >= 0) ? err : 0;
191	dprintk(1, "get_user_pages: err=%d [%d]\n", err,	191	dprintk(1, "pin_user_pages: err=%d [%d]\n", err,
192	dma->nr_pages);	192	dma->nr_pages);
193	return err < 0 ? err : -EINVAL;	193	return err < 0 ? err : -EINVAL;
194	}	194	}
@@ -349,8 +349,8 @@ int videobuf_dma_free(struct videobuf_dmabuf *dma) · 154 unmodified lines
349	BUG_ON(dma->sglen);	349	BUG_ON(dma->sglen);
350		350
351	if (dma->pages) {	351	if (dma->pages) {
352	for (i = 0; i < dma->nr_pages; i++)	352	unpin_user_pages_dirty_lock(dma->pages, dma->nr_pages,
353	put_page(dma->pages[i]);	353	dma->direction == DMA_FROM_DEVICE);
354	kfree(dma->pages);	354	kfree(dma->pages);
355	dma->pages = NULL;	355	dma->pages = NULL;
356	}	356	}

drivers/net/ethernet/broadcom/bnx2x/bnx2x_init.h+0−1

@@ -296,7 +296,6 @@ static inline void bnx2x_dcb_config_qm(struct bnx2x *bp, enum cos_mode mode, · 295 unmodified lines
296	* possible, the driver should only write the valid vnics into the internal	296	* possible, the driver should only write the valid vnics into the internal
297	* ram according to the appropriate port mode.	297	* ram according to the appropriate port mode.
298	*/	298	*/
299	#define BITS_TO_BYTES(x) ((x)/8)
300		299
301	/* CMNG constants, as derived from system spec calculations */	300	/* CMNG constants, as derived from system spec calculations */
302		301

drivers/net/wireless/intel/iwlegacy/4965-mac.c+2−1

 #include <linux/firmware.h>
 #include <linux/etherdevice.h>
 #include <linux/if_arp.h>
+#include <linux/units.h>
 #include <net/mac80211.h>
 	il->hw_params.valid_rx_ant = il->cfg->valid_rx_ant;
 	il->hw_params.ct_kill_threshold =
-	   CELSIUS_TO_KELVIN(CT_KILL_THRESHOLD_LEGACY);
+	   celsius_to_kelvin(CT_KILL_THRESHOLD_LEGACY);
 	il->hw_params.sens = &il4965_sensitivity;
 	il->hw_params.beacon_time_tsf_bits = IL4965_EXT_BEACON_TIME_POS;

drivers/net/wireless/intel/iwlegacy/4965.c+9−8

 #include <linux/sched.h>
 #include <linux/skbuff.h>
 #include <linux/netdevice.h>
+#include <linux/units.h>
 #include <net/mac80211.h>
 #include <linux/etherdevice.h>
 #include <asm/unaligned.h>
 	/* get current temperature (Celsius) */
 	current_temp = max(il->temperature, IL_TX_POWER_TEMPERATURE_MIN);
 	current_temp = min(il->temperature, IL_TX_POWER_TEMPERATURE_MAX);
-	current_temp = KELVIN_TO_CELSIUS(current_temp);
+	current_temp = kelvin_to_celsius(current_temp);
 	/* select thermal txpower adjustment params, based on channel group
 	 *   (same frequency group used for mimo txatten adjustment) */
 	temperature =
 	    (temperature * 97) / 100 + TEMPERATURE_CALIB_KELVIN_OFFSET;
-	D_TEMP("Calibrated temperature: %dK, %dC\n", temperature,
+	D_TEMP("Calibrated temperature: %dK, %ldC\n", temperature,
-	       KELVIN_TO_CELSIUS(temperature));
+	       kelvin_to_celsius(temperature));
 	return temperature;
 }
 	if (il->temperature != temp) {
 		if (il->temperature)
-			D_TEMP("Temperature changed " "from %dC to %dC\n",
+			D_TEMP("Temperature changed " "from %ldC to %ldC\n",
-			       KELVIN_TO_CELSIUS(il->temperature),
+			       kelvin_to_celsius(il->temperature),
-			       KELVIN_TO_CELSIUS(temp));
+			       kelvin_to_celsius(temp));
 		else
-			D_TEMP("Temperature " "initialized to %dC\n",
+			D_TEMP("Temperature " "initialized to %ldC\n",
-			       KELVIN_TO_CELSIUS(temp));
+			       kelvin_to_celsius(temp));
 	}
 	il->temperature = temp;

drivers/net/wireless/intel/iwlegacy/common.h+0−3

@@ -779,9 +779,6 @@ struct il_sensitivity_ranges { · 778 unmodified lines
779	u16 nrg_th_cca;	779	u16 nrg_th_cca;
780	};	780	};
781		781
782	#define KELVIN_TO_CELSIUS(x) ((x)-273)
783	#define CELSIUS_TO_KELVIN(x) ((x)+273)
784
785	/**	782	/**
786	* struct il_hw_params	783	* struct il_hw_params
787	* @bcast_id: f/w broadcast station ID	784	* @bcast_id: f/w broadcast station ID

drivers/net/wireless/intel/iwlwifi/dvm/dev.h+0−5

@@ -237,11 +237,6 @@ struct iwl_sensitivity_ranges { · 236 unmodified lines
237	u16 nrg_th_cca;	237	u16 nrg_th_cca;
238	};	238	};
239		239
240
241	#define KELVIN_TO_CELSIUS(x) ((x)-273)
242	#define CELSIUS_TO_KELVIN(x) ((x)+273)
243
244
245	/******************************************************************************	240	/******************************************************************************
246	*	241	*
247	* Functions implemented in core module which are forward declared here	242	* Functions implemented in core module which are forward declared here

drivers/net/wireless/intel/iwlwifi/dvm/devices.c+4−2

  *
  *****************************************************************************/
+#include <linux/units.h>
 /*
  * DVM device-specific data & functions
  */
 static void iwl5150_set_ct_threshold(struct iwl_priv *priv)
 {
 	const s32 volt2temp_coef = IWL_5150_VOLTAGE_TO_TEMPERATURE_COEFF;
-	s32 threshold = (s32)CELSIUS_TO_KELVIN(CT_KILL_THRESHOLD_LEGACY) -
+	s32 threshold = (s32)celsius_to_kelvin(CT_KILL_THRESHOLD_LEGACY) -
 			iwl_temp_calib_to_offset(priv);
 	priv->hw_params.ct_kill_threshold = threshold * volt2temp_coef;
 	vt = le32_to_cpu(priv->statistics.common.temperature);
 	vt = vt / IWL_5150_VOLTAGE_TO_TEMPERATURE_COEFF + offset;
 	/* now vt hold the temperature in Kelvin */
-	priv->temperature = KELVIN_TO_CELSIUS(vt);
+	priv->temperature = kelvin_to_celsius(vt);
 	iwl_tt_handler(priv);
 }

drivers/nvdimm/pmem.c+0−6

 	put_disk(pmem->disk);
 }
-static void pmem_pagemap_page_free(struct page *page)
-{
-	wake_up_var(&page->_refcount);
-}
 static const struct dev_pagemap_ops fsdax_pagemap_ops = {
-	.page_free		= pmem_pagemap_page_free,
 	.kill			= pmem_pagemap_kill,
 	.cleanup		= pmem_pagemap_cleanup,
 };

drivers/nvme/host/hwmon.c+5−8

  */
 #include <linux/hwmon.h>
+#include <linux/units.h>
 #include <asm/unaligned.h>
 #include "nvme.h"
-/* These macros should be moved to linux/temperature.h */
-#define MILLICELSIUS_TO_KELVIN(t) DIV_ROUND_CLOSEST((t) + 273150, 1000)
-#define KELVIN_TO_MILLICELSIUS(t) ((t) * 1000L - 273150)
 struct nvme_hwmon_data {
 	struct nvme_ctrl *ctrl;
 	struct nvme_smart_log log;
 		return -EIO;
 	if (ret < 0)
 		return ret;
-	*temp = KELVIN_TO_MILLICELSIUS(status & NVME_TEMP_THRESH_MASK);
+	*temp = kelvin_to_millicelsius(status & NVME_TEMP_THRESH_MASK);
 	return 0;
 }
 	unsigned int threshold = sensor << NVME_TEMP_THRESH_SELECT_SHIFT;
 	int ret;
-	temp = MILLICELSIUS_TO_KELVIN(temp);
+	temp = millicelsius_to_kelvin(temp);
 	threshold |= clamp_val(temp, 0, NVME_TEMP_THRESH_MASK);
 	if (under)
 	case hwmon_temp_min:
 		return nvme_get_temp_thresh(data->ctrl, channel, true, val);
 	case hwmon_temp_crit:
-		*val = KELVIN_TO_MILLICELSIUS(data->ctrl->cctemp);
+		*val = kelvin_to_millicelsius(data->ctrl->cctemp);
 		return 0;
 	default:
 		break;
 			temp = get_unaligned_le16(log->temperature);
 		else
 			temp = le16_to_cpu(log->temp_sensor[channel - 1]);
-		*val = KELVIN_TO_MILLICELSIUS(temp);
+		*val = kelvin_to_millicelsius(temp);
 		break;
 	case hwmon_temp_alarm:
 		*val = !!(log->critical_warning & NVME_SMART_CRIT_TEMPERATURE);

drivers/platform/goldfish/goldfish_pipe.c+12−23

 	}
 }
-static int pin_user_pages(unsigned long first_page,
+static int goldfish_pin_pages(unsigned long first_page,
-			  unsigned long last_page,
+			      unsigned long last_page,
-			  unsigned int last_page_size,
+			      unsigned int last_page_size,
-			  int is_write,
+			      int is_write,
-			  struct page *pages[MAX_BUFFERS_PER_COMMAND],
+			      struct page *pages[MAX_BUFFERS_PER_COMMAND],
-			  unsigned int *iter_last_page_size)
+			      unsigned int *iter_last_page_size)
 {
 	int ret;
 	int requested_pages = ((last_page - first_page) >> PAGE_SHIFT) + 1;
 		*iter_last_page_size = last_page_size;
 	}
-	ret = get_user_pages_fast(first_page, requested_pages,
+	ret = pin_user_pages_fast(first_page, requested_pages,
 				  !is_write ? FOLL_WRITE : 0,
 				  pages);
 	if (ret <= 0)
 	return ret;
 }
-static void release_user_pages(struct page **pages, int pages_count,
-			       int is_write, s32 consumed_size)
-{
-	int i;
-	for (i = 0; i < pages_count; i++) {
-		if (!is_write && consumed_size > 0)
-			set_page_dirty(pages[i]);
-		put_page(pages[i]);
-	}
-}
 /* Populate the call parameters, merging adjacent pages together */
 static void populate_rw_params(struct page **pages,
 			       int pages_count,
 	if (mutex_lock_interruptible(&pipe->lock))
 		return -ERESTARTSYS;
-	pages_count = pin_user_pages(first_page, last_page,
+	pages_count = goldfish_pin_pages(first_page, last_page,
-				     last_page_size, is_write,
+					 last_page_size, is_write,
-				     pipe->pages, &iter_last_page_size);
+					 pipe->pages, &iter_last_page_size);
 	if (pages_count < 0) {
 		mutex_unlock(&pipe->lock);
 		return pages_count;
 	*consumed_size = pipe->command_buffer->rw_params.consumed_size;
-	release_user_pages(pipe->pages, pages_count, is_write, *consumed_size);
+	unpin_user_pages_dirty_lock(pipe->pages, pages_count,
+				    !is_write && *consumed_size > 0);
 	mutex_unlock(&pipe->lock);
 	return 0;

drivers/platform/x86/asus-wmi.c+3−4

@@ -33,9 +33,9 @@ · 32 unmodified lines
33	#include <linux/seq_file.h>	33	#include <linux/seq_file.h>
34	#include <linux/platform_data/x86/asus-wmi.h>	34	#include <linux/platform_data/x86/asus-wmi.h>
35	#include <linux/platform_device.h>	35	#include <linux/platform_device.h>
36	#include <linux/thermal.h>
37	#include <linux/acpi.h>	36	#include <linux/acpi.h>
38	#include <linux/dmi.h>	37	#include <linux/dmi.h>
		38	#include <linux/units.h>
39		39
40	#include <acpi/battery.h>	40	#include <acpi/battery.h>
41	#include <acpi/video.h>	41	#include <acpi/video.h>
@@ -1514,9 +1514,8 @@ static ssize_t asus_hwmon_temp1(struct device *dev, · 1472 unmodified lines
1514	if (err < 0)	1514	if (err < 0)
1515	return err;	1515	return err;
1516		1516
1517	value = DECI_KELVIN_TO_CELSIUS((value & 0xFFFF)) * 1000;	1517	return sprintf(buf, "%ld\n",
1518		1518	deci_kelvin_to_millicelsius(value & 0xFFFF));
1519	return sprintf(buf, "%d\n", value);
1520	}	1519	}
1521		1520
1522	/* Fan1 */	1521	/* Fan1 */

drivers/platform/x86/intel_menlow.c+6−3

 #include <linux/slab.h>
 #include <linux/thermal.h>
 #include <linux/types.h>
+#include <linux/units.h>
 MODULE_AUTHOR("Thomas Sujith");
 MODULE_AUTHOR("Zhang Rui");
 	int result;
 	result = sensor_get_auxtrip(attr->handle, idx, &value);
+	if (result)
+		return result;
-	return result ? result : sprintf(buf, "%lu", DECI_KELVIN_TO_CELSIUS(value));
+	return sprintf(buf, "%lu", deci_kelvin_to_celsius(value));
 }
 static ssize_t aux0_show(struct device *dev,
 	if (value < 0)
 		return -EINVAL;
 	result = sensor_set_auxtrip(attr->handle, idx,
-				    CELSIUS_TO_DECI_KELVIN(value));
+				    celsius_to_deci_kelvin(value));
 	return result ? result : count;
 }

drivers/thermal/armada_thermal.c+0−2

@@ -21,8 +21,6 @@ · 20 unmodified lines
21		21
22	#include "thermal_core.h"	22	#include "thermal_core.h"
23		23
24	#define TO_MCELSIUS(c) ((c) * 1000)
25
26	/* Thermal Manager Control and Status Register */	24	/* Thermal Manager Control and Status Register */
27	#define PMU_TDC0_SW_RST_MASK (0x1 << 1)	25	#define PMU_TDC0_SW_RST_MASK (0x1 << 1)
28	#define PMU_TM_DISABLE_OFFS 0	26	#define PMU_TM_DISABLE_OFFS 0

drivers/thermal/intel/int340x_thermal/int340x_thermal_zone.c+4−3

 #include <linux/init.h>
 #include <linux/acpi.h>
 #include <linux/thermal.h>
+#include <linux/units.h>
 #include "int340x_thermal_zone.h"
 static int int340x_thermal_get_zone_temp(struct thermal_zone_device *zone,
 		*temp = (unsigned long)conv_temp * 10;
 	} else
 		/* _TMP returns the temperature in tenths of degrees Kelvin */
-		*temp = DECI_KELVIN_TO_MILLICELSIUS(tmp);
+		*temp = deci_kelvin_to_millicelsius(tmp);
 	return 0;
 }
 	snprintf(name, sizeof(name), "PAT%d", trip);
 	status = acpi_execute_simple_method(d->adev->handle, name,
-			MILLICELSIUS_TO_DECI_KELVIN(temp));
+			millicelsius_to_deci_kelvin(temp));
 	if (ACPI_FAILURE(status))
 		return -EIO;
 	if (ACPI_FAILURE(status))
 		return -EIO;
-	*temp = DECI_KELVIN_TO_MILLICELSIUS(r);
+	*temp = deci_kelvin_to_millicelsius(r);
 	return 0;
 }

drivers/thermal/intel/intel_pch_thermal.c+2−1

 #include <linux/pci.h>
 #include <linux/acpi.h>
 #include <linux/thermal.h>
+#include <linux/units.h>
 #include <linux/pm.h>
 /* Intel PCH thermal Device IDs */
 		if (ACPI_SUCCESS(status)) {
 			unsigned long trip_temp;
-			trip_temp = DECI_KELVIN_TO_MILLICELSIUS(r);
+			trip_temp = deci_kelvin_to_millicelsius(r);
 			if (trip_temp) {
 				ptd->psv_temp = trip_temp;
 				ptd->psv_trip_id = *nr_trips;

drivers/vfio/vfio_iommu_type1.c+7−28

@@ -309,9 +309,8 @@ static int put_pfn(unsigned long pfn, int prot) · 308 unmodified lines
309	{	309	{
310	if (!is_invalid_reserved_pfn(pfn)) {	310	if (!is_invalid_reserved_pfn(pfn)) {
311	struct page *page = pfn_to_page(pfn);	311	struct page *page = pfn_to_page(pfn);
312	if (prot & IOMMU_WRITE)	312
313	SetPageDirty(page);	313	unpin_user_pages_dirty_lock(&page, 1, prot & IOMMU_WRITE);
314	put_page(page);
315	return 1;	314	return 1;
316	}	315	}
317	return 0;	316	return 0;
@@ -322,7 +321,6 @@ static int vaddr_get_pfn(struct mm_struct *mm, unsigned long vaddr, · 4 unmodified lines
322	{	321	{
323	struct page *page[1];	322	struct page *page[1];
324	struct vm_area_struct *vma;	323	struct vm_area_struct *vma;
325	struct vm_area_struct *vmas[1];
326	unsigned int flags = 0;	324	unsigned int flags = 0;
327	int ret;	325	int ret;
328		326
@@ -330,33 +328,14 @@ static int vaddr_get_pfn(struct mm_struct *mm, unsigned long vaddr, · 1 unmodified line
330	flags \|= FOLL_WRITE;	328	flags \|= FOLL_WRITE;
331		329
332	down_read(&mm->mmap_sem);	330	down_read(&mm->mmap_sem);
333	if (mm == current->mm) {	331	ret = pin_user_pages_remote(NULL, mm, vaddr, 1, flags \| FOLL_LONGTERM,
334	ret = get_user_pages(vaddr, 1, flags \| FOLL_LONGTERM, page,	332	page, NULL, NULL);
335	vmas);
336	} else {
337	ret = get_user_pages_remote(NULL, mm, vaddr, 1, flags, page,
338	vmas, NULL);
339	/*
340	* The lifetime of a vaddr_get_pfn() page pin is
341	* userspace-controlled. In the fs-dax case this could
342	* lead to indefinite stalls in filesystem operations.
343	* Disallow attempts to pin fs-dax pages via this
344	* interface.
345	*/
346	if (ret > 0 && vma_is_fsdax(vmas[0])) {
347	ret = -EOPNOTSUPP;
348	put_page(page[0]);
349	}
350	}
351	up_read(&mm->mmap_sem);
352
353	if (ret == 1) {	333	if (ret == 1) {
354	*pfn = page_to_pfn(page[0]);	334	*pfn = page_to_pfn(page[0]);
355	return 0;	335	ret = 0;
		336	goto done;
356	}	337	}
357		338
358	down_read(&mm->mmap_sem);
359
360	vaddr = untagged_addr(vaddr);	339	vaddr = untagged_addr(vaddr);
361		340
362	vma = find_vma_intersection(mm, vaddr, vaddr + 1);	341	vma = find_vma_intersection(mm, vaddr, vaddr + 1);
@@ -366,7 +345,7 @@ static int vaddr_get_pfn(struct mm_struct *mm, unsigned long vaddr, · 3 unmodified lines
366	if (is_invalid_reserved_pfn(*pfn))	345	if (is_invalid_reserved_pfn(*pfn))
367	ret = 0;	346	ret = 0;
368	}	347	}
369		348	done:
370	up_read(&mm->mmap_sem);	349	up_read(&mm->mmap_sem);
371	return ret;	350	return ret;
372	}	351	}

fs/binfmt_elf.c+74−70

@@ -97,7 +97,7 @@ static struct linux_binfmt elf_format = { · 96 unmodified lines
97	.min_coredump = ELF_EXEC_PAGESIZE,	97	.min_coredump = ELF_EXEC_PAGESIZE,
98	};	98	};
99		99
100	#define BAD_ADDR(x) ((unsigned long)(x) >= TASK_SIZE)	100	#define BAD_ADDR(x) (unlikely((unsigned long)(x) >= TASK_SIZE))
101		101
102	static int set_brk(unsigned long start, unsigned long end, int prot)	102	static int set_brk(unsigned long start, unsigned long end, int prot)
103	{	103	{
@@ -161,9 +161,11 @@ static int padzero(unsigned long elf_bss) · 57 unmodified lines
161	#endif	161	#endif
162		162
163	static int	163	static int
164	create_elf_tables(struct linux_binprm bprm, struct elfhdr exec,	164	create_elf_tables(struct linux_binprm bprm, const struct elfhdr exec,
165	unsigned long load_addr, unsigned long interp_load_addr)	165	unsigned long load_addr, unsigned long interp_load_addr,
		166	unsigned long e_entry)
166	{	167	{
		168	struct mm_struct *mm = current->mm;
167	unsigned long p = bprm->p;	169	unsigned long p = bprm->p;
168	int argc = bprm->argc;	170	int argc = bprm->argc;
169	int envc = bprm->envc;	171	int envc = bprm->envc;
@@ -176,7 +178,7 @@ create_elf_tables(struct linux_binprm bprm, struct elfhdr exec, · 6 unmodified lines
176	unsigned char k_rand_bytes[16];	178	unsigned char k_rand_bytes[16];
177	int items;	179	int items;
178	elf_addr_t *elf_info;	180	elf_addr_t *elf_info;
179	int ei_index = 0;	181	int ei_index;
180	const struct cred *cred = current_cred();	182	const struct cred *cred = current_cred();
181	struct vm_area_struct *vma;	183	struct vm_area_struct *vma;
182		184
@@ -226,12 +228,12 @@ create_elf_tables(struct linux_binprm bprm, struct elfhdr exec, · 43 unmodified lines
226	return -EFAULT;	228	return -EFAULT;
227		229
228	/* Create the ELF interpreter info */	230	/* Create the ELF interpreter info */
229	elf_info = (elf_addr_t *)current->mm->saved_auxv;	231	elf_info = (elf_addr_t *)mm->saved_auxv;
230	/* update AT_VECTOR_SIZE_BASE if the number of NEW_AUX_ENT() changes */	232	/* update AT_VECTOR_SIZE_BASE if the number of NEW_AUX_ENT() changes */
231	#define NEW_AUX_ENT(id, val) \	233	#define NEW_AUX_ENT(id, val) \
232	do { \	234	do { \
233	elf_info[ei_index++] = id; \	235	*elf_info++ = id; \
234	elf_info[ei_index++] = val; \	236	*elf_info++ = val; \
235	} while (0)	237	} while (0)
236		238
237	#ifdef ARCH_DLINFO	239	#ifdef ARCH_DLINFO
@@ -251,7 +253,7 @@ create_elf_tables(struct linux_binprm bprm, struct elfhdr exec, · 13 unmodified lines
251	NEW_AUX_ENT(AT_PHNUM, exec->e_phnum);	253	NEW_AUX_ENT(AT_PHNUM, exec->e_phnum);
252	NEW_AUX_ENT(AT_BASE, interp_load_addr);	254	NEW_AUX_ENT(AT_BASE, interp_load_addr);
253	NEW_AUX_ENT(AT_FLAGS, 0);	255	NEW_AUX_ENT(AT_FLAGS, 0);
254	NEW_AUX_ENT(AT_ENTRY, exec->e_entry);	256	NEW_AUX_ENT(AT_ENTRY, e_entry);
255	NEW_AUX_ENT(AT_UID, from_kuid_munged(cred->user_ns, cred->uid));	257	NEW_AUX_ENT(AT_UID, from_kuid_munged(cred->user_ns, cred->uid));
256	NEW_AUX_ENT(AT_EUID, from_kuid_munged(cred->user_ns, cred->euid));	258	NEW_AUX_ENT(AT_EUID, from_kuid_munged(cred->user_ns, cred->euid));
257	NEW_AUX_ENT(AT_GID, from_kgid_munged(cred->user_ns, cred->gid));	259	NEW_AUX_ENT(AT_GID, from_kgid_munged(cred->user_ns, cred->gid));
@@ -275,12 +277,13 @@ create_elf_tables(struct linux_binprm bprm, struct elfhdr exec, · 17 unmodified lines
275	}	277	}
276	#undef NEW_AUX_ENT	278	#undef NEW_AUX_ENT
277	/* AT_NULL is zero; clear the rest too */	279	/* AT_NULL is zero; clear the rest too */
278	memset(&elf_info[ei_index], 0,	280	memset(elf_info, 0, (char *)mm->saved_auxv +
279	sizeof current->mm->saved_auxv - ei_index * sizeof elf_info[0]);	281	sizeof(mm->saved_auxv) - (char *)elf_info);
280		282
281	/* And advance past the AT_NULL entry. */	283	/* And advance past the AT_NULL entry. */
282	ei_index += 2;	284	elf_info += 2;
283		285
		286	ei_index = elf_info - (elf_addr_t *)mm->saved_auxv;
284	sp = STACK_ADD(p, ei_index);	287	sp = STACK_ADD(p, ei_index);
285		288
286	items = (argc + 1) + (envc + 1) + 1;	289	items = (argc + 1) + (envc + 1) + 1;
@@ -299,7 +302,7 @@ create_elf_tables(struct linux_binprm bprm, struct elfhdr exec, · 12 unmodified lines
299	* Grow the stack manually; some architectures have a limit on how	302	* Grow the stack manually; some architectures have a limit on how
300	* far ahead a user-space access may be in order to grow the stack.	303	* far ahead a user-space access may be in order to grow the stack.
301	*/	304	*/
302	vma = find_extend_vma(current->mm, bprm->p);	305	vma = find_extend_vma(mm, bprm->p);
303	if (!vma)	306	if (!vma)
304	return -EFAULT;	307	return -EFAULT;
305		308
@@ -308,7 +311,7 @@ create_elf_tables(struct linux_binprm bprm, struct elfhdr exec, · 2 unmodified lines
308	return -EFAULT;	311	return -EFAULT;
309		312
310	/* Populate list of argv pointers back to argv strings. */	313	/* Populate list of argv pointers back to argv strings. */
311	p = current->mm->arg_end = current->mm->arg_start;	314	p = mm->arg_end = mm->arg_start;
312	while (argc-- > 0) {	315	while (argc-- > 0) {
313	size_t len;	316	size_t len;
314	if (__put_user((elf_addr_t)p, sp++))	317	if (__put_user((elf_addr_t)p, sp++))
@@ -320,10 +323,10 @@ create_elf_tables(struct linux_binprm bprm, struct elfhdr exec, · 5 unmodified lines
320	}	323	}
321	if (__put_user(0, sp++))	324	if (__put_user(0, sp++))
322	return -EFAULT;	325	return -EFAULT;
323	current->mm->arg_end = p;	326	mm->arg_end = p;
324		327
325	/* Populate list of envp pointers back to envp strings. */	328	/* Populate list of envp pointers back to envp strings. */
326	current->mm->env_end = current->mm->env_start = p;	329	mm->env_end = mm->env_start = p;
327	while (envc-- > 0) {	330	while (envc-- > 0) {
328	size_t len;	331	size_t len;
329	if (__put_user((elf_addr_t)p, sp++))	332	if (__put_user((elf_addr_t)p, sp++))
@@ -335,10 +338,10 @@ create_elf_tables(struct linux_binprm bprm, struct elfhdr exec, · 5 unmodified lines
335	}	338	}
336	if (__put_user(0, sp++))	339	if (__put_user(0, sp++))
337	return -EFAULT;	340	return -EFAULT;
338	current->mm->env_end = p;	341	mm->env_end = p;
339		342
340	/* Put the elf_info on the stack in the right place. */	343	/* Put the elf_info on the stack in the right place. */
341	if (copy_to_user(sp, elf_info, ei_index * sizeof(elf_addr_t)))	344	if (copy_to_user(sp, mm->saved_auxv, ei_index * sizeof(elf_addr_t)))
342	return -EFAULT;	345	return -EFAULT;
343	return 0;	346	return 0;
344	}	347	}
@@ -689,15 +692,17 @@ static int load_elf_binary(struct linux_binprm *bprm) · 344 unmodified lines
689	int bss_prot = 0;	692	int bss_prot = 0;
690	int retval, i;	693	int retval, i;
691	unsigned long elf_entry;	694	unsigned long elf_entry;
		695	unsigned long e_entry;
692	unsigned long interp_load_addr = 0;	696	unsigned long interp_load_addr = 0;
693	unsigned long start_code, end_code, start_data, end_data;	697	unsigned long start_code, end_code, start_data, end_data;
694	unsigned long reloc_func_desc __maybe_unused = 0;	698	unsigned long reloc_func_desc __maybe_unused = 0;
695	int executable_stack = EXSTACK_DEFAULT;	699	int executable_stack = EXSTACK_DEFAULT;
		700	struct elfhdr elf_ex = (struct elfhdr )bprm->buf;
696	struct {	701	struct {
697	struct elfhdr elf_ex;
698	struct elfhdr interp_elf_ex;	702	struct elfhdr interp_elf_ex;
699	} *loc;	703	} *loc;
700	struct arch_elf_state arch_state = INIT_ARCH_ELF_STATE;	704	struct arch_elf_state arch_state = INIT_ARCH_ELF_STATE;
		705	struct mm_struct *mm;
701	struct pt_regs *regs;	706	struct pt_regs *regs;
702		707
703	loc = kmalloc(sizeof(*loc), GFP_KERNEL);	708	loc = kmalloc(sizeof(*loc), GFP_KERNEL);
@@ -705,30 +710,27 @@ static int load_elf_binary(struct linux_binprm *bprm) · 1 unmodified line
705	retval = -ENOMEM;	710	retval = -ENOMEM;
706	goto out_ret;	711	goto out_ret;
707	}	712	}
708
709	/* Get the exec-header */
710	loc->elf_ex = ((struct elfhdr )bprm->buf);
711		713
712	retval = -ENOEXEC;	714	retval = -ENOEXEC;
713	/* First of all, some simple consistency checks */	715	/* First of all, some simple consistency checks */
714	if (memcmp(loc->elf_ex.e_ident, ELFMAG, SELFMAG) != 0)	716	if (memcmp(elf_ex->e_ident, ELFMAG, SELFMAG) != 0)
715	goto out;	717	goto out;
716		718
717	if (loc->elf_ex.e_type != ET_EXEC && loc->elf_ex.e_type != ET_DYN)	719	if (elf_ex->e_type != ET_EXEC && elf_ex->e_type != ET_DYN)
718	goto out;	720	goto out;
719	if (!elf_check_arch(&loc->elf_ex))	721	if (!elf_check_arch(elf_ex))
720	goto out;	722	goto out;
721	if (elf_check_fdpic(&loc->elf_ex))	723	if (elf_check_fdpic(elf_ex))
722	goto out;	724	goto out;
723	if (!bprm->file->f_op->mmap)	725	if (!bprm->file->f_op->mmap)
724	goto out;	726	goto out;
725		727
726	elf_phdata = load_elf_phdrs(&loc->elf_ex, bprm->file);	728	elf_phdata = load_elf_phdrs(elf_ex, bprm->file);
727	if (!elf_phdata)	729	if (!elf_phdata)
728	goto out;	730	goto out;
729		731
730	elf_ppnt = elf_phdata;	732	elf_ppnt = elf_phdata;
731	for (i = 0; i < loc->elf_ex.e_phnum; i++, elf_ppnt++) {	733	for (i = 0; i < elf_ex->e_phnum; i++, elf_ppnt++) {
732	char *elf_interpreter;	734	char *elf_interpreter;
733		735
734	if (elf_ppnt->p_type != PT_INTERP)	736	if (elf_ppnt->p_type != PT_INTERP)
@@ -782,7 +784,7 @@ out_free_interp: · 47 unmodified lines
782	}	784	}
783		785
784	elf_ppnt = elf_phdata;	786	elf_ppnt = elf_phdata;
785	for (i = 0; i < loc->elf_ex.e_phnum; i++, elf_ppnt++)	787	for (i = 0; i < elf_ex->e_phnum; i++, elf_ppnt++)
786	switch (elf_ppnt->p_type) {	788	switch (elf_ppnt->p_type) {
787	case PT_GNU_STACK:	789	case PT_GNU_STACK:
788	if (elf_ppnt->p_flags & PF_X)	790	if (elf_ppnt->p_flags & PF_X)
@@ -792,7 +794,7 @@ out_free_interp: · 3 unmodified lines
792	break;	794	break;
793		795
794	case PT_LOPROC ... PT_HIPROC:	796	case PT_LOPROC ... PT_HIPROC:
795	retval = arch_elf_pt_proc(&loc->elf_ex, elf_ppnt,	797	retval = arch_elf_pt_proc(elf_ex, elf_ppnt,
796	bprm->file, false,	798	bprm->file, false,
797	&arch_state);	799	&arch_state);
798	if (retval)	800	if (retval)
@@ -836,7 +838,7 @@ out_free_interp: · 37 unmodified lines
836	* still possible to return an error to the code that invoked	838	* still possible to return an error to the code that invoked
837	* the exec syscall.	839	* the exec syscall.
838	*/	840	*/
839	retval = arch_check_elf(&loc->elf_ex,	841	retval = arch_check_elf(elf_ex,
840	!!interpreter, &loc->interp_elf_ex,	842	!!interpreter, &loc->interp_elf_ex,
841	&arch_state);	843	&arch_state);
842	if (retval)	844	if (retval)
@@ -849,8 +851,8 @@ out_free_interp: · 6 unmodified lines
849		851
850	/* Do this immediately, since STACK_TOP as used in setup_arg_pages	852	/* Do this immediately, since STACK_TOP as used in setup_arg_pages
851	may depend on the personality. */	853	may depend on the personality. */
852	SET_PERSONALITY2(loc->elf_ex, &arch_state);	854	SET_PERSONALITY2(*elf_ex, &arch_state);
853	if (elf_read_implies_exec(loc->elf_ex, executable_stack))	855	if (elf_read_implies_exec(*elf_ex, executable_stack))
854	current->personality \|= READ_IMPLIES_EXEC;	856	current->personality \|= READ_IMPLIES_EXEC;
855		857
856	if (!(current->personality & ADDR_NO_RANDOMIZE) && randomize_va_space)	858	if (!(current->personality & ADDR_NO_RANDOMIZE) && randomize_va_space)
@@ -877,7 +879,7 @@ out_free_interp: · 20 unmodified lines
877	/* Now we do a little grungy work by mmapping the ELF image into	879	/* Now we do a little grungy work by mmapping the ELF image into
878	the correct location in memory. */	880	the correct location in memory. */
879	for(i = 0, elf_ppnt = elf_phdata;	881	for(i = 0, elf_ppnt = elf_phdata;
880	i < loc->elf_ex.e_phnum; i++, elf_ppnt++) {	882	i < elf_ex->e_phnum; i++, elf_ppnt++) {
881	int elf_prot, elf_flags;	883	int elf_prot, elf_flags;
882	unsigned long k, vaddr;	884	unsigned long k, vaddr;
883	unsigned long total_size = 0;	885	unsigned long total_size = 0;
@@ -921,9 +923,9 @@ out_free_interp: · 37 unmodified lines
921	* If we are loading ET_EXEC or we have already performed	923	* If we are loading ET_EXEC or we have already performed
922	* the ET_DYN load_addr calculations, proceed normally.	924	* the ET_DYN load_addr calculations, proceed normally.
923	*/	925	*/
924	if (loc->elf_ex.e_type == ET_EXEC \|\| load_addr_set) {	926	if (elf_ex->e_type == ET_EXEC \|\| load_addr_set) {
925	elf_flags \|= MAP_FIXED;	927	elf_flags \|= MAP_FIXED;
926	} else if (loc->elf_ex.e_type == ET_DYN) {	928	} else if (elf_ex->e_type == ET_DYN) {
927	/*	929	/*
928	* This logic is run once for the first LOAD Program	930	* This logic is run once for the first LOAD Program
929	* Header for ET_DYN binaries to calculate the	931	* Header for ET_DYN binaries to calculate the
@@ -972,7 +974,7 @@ out_free_interp: · 42 unmodified lines
972	load_bias = ELF_PAGESTART(load_bias - vaddr);	974	load_bias = ELF_PAGESTART(load_bias - vaddr);
973		975
974	total_size = total_mapping_size(elf_phdata,	976	total_size = total_mapping_size(elf_phdata,
975	loc->elf_ex.e_phnum);	977	elf_ex->e_phnum);
976	if (!total_size) {	978	if (!total_size) {
977	retval = -EINVAL;	979	retval = -EINVAL;
978	goto out_free_dentry;	980	goto out_free_dentry;
@@ -990,7 +992,7 @@ out_free_interp: · 11 unmodified lines
990	if (!load_addr_set) {	992	if (!load_addr_set) {
991	load_addr_set = 1;	993	load_addr_set = 1;
992	load_addr = (elf_ppnt->p_vaddr - elf_ppnt->p_offset);	994	load_addr = (elf_ppnt->p_vaddr - elf_ppnt->p_offset);
993	if (loc->elf_ex.e_type == ET_DYN) {	995	if (elf_ex->e_type == ET_DYN) {
994	load_bias += error -	996	load_bias += error -
995	ELF_PAGESTART(load_bias + vaddr);	997	ELF_PAGESTART(load_bias + vaddr);
996	load_addr += load_bias;	998	load_addr += load_bias;
@@ -998,7 +1000,7 @@ out_free_interp: · 1 unmodified line
998	}	1000	}
999	}	1001	}
1000	k = elf_ppnt->p_vaddr;	1002	k = elf_ppnt->p_vaddr;
1001	if (k < start_code)	1003	if ((elf_ppnt->p_flags & PF_X) && k < start_code)
1002	start_code = k;	1004	start_code = k;
1003	if (start_data < k)	1005	if (start_data < k)
1004	start_data = k;	1006	start_data = k;
@@ -1031,7 +1033,7 @@ out_free_interp: · 26 unmodified lines
1031	}	1033	}
1032	}	1034	}
1033		1035
1034	loc->elf_ex.e_entry += load_bias;	1036	e_entry = elf_ex->e_entry + load_bias;
1035	elf_bss += load_bias;	1037	elf_bss += load_bias;
1036	elf_brk += load_bias;	1038	elf_brk += load_bias;
1037	start_code += load_bias;	1039	start_code += load_bias;
@@ -1074,7 +1076,7 @@ out_free_interp: · 36 unmodified lines
1074	allow_write_access(interpreter);	1076	allow_write_access(interpreter);
1075	fput(interpreter);	1077	fput(interpreter);
1076	} else {	1078	} else {
1077	elf_entry = loc->elf_ex.e_entry;	1079	elf_entry = e_entry;
1078	if (BAD_ADDR(elf_entry)) {	1080	if (BAD_ADDR(elf_entry)) {
1079	retval = -EINVAL;	1081	retval = -EINVAL;
1080	goto out_free_dentry;	1082	goto out_free_dentry;
@@ -1092,15 +1094,17 @@ out_free_interp: · 11 unmodified lines
1092	goto out;	1094	goto out;
1093	#endif /* ARCH_HAS_SETUP_ADDITIONAL_PAGES */	1095	#endif /* ARCH_HAS_SETUP_ADDITIONAL_PAGES */
1094		1096
1095	retval = create_elf_tables(bprm, &loc->elf_ex,	1097	retval = create_elf_tables(bprm, elf_ex,
1096	load_addr, interp_load_addr);	1098	load_addr, interp_load_addr, e_entry);
1097	if (retval < 0)	1099	if (retval < 0)
1098	goto out;	1100	goto out;
1099	current->mm->end_code = end_code;	1101
1100	current->mm->start_code = start_code;	1102	mm = current->mm;
1101	current->mm->start_data = start_data;	1103	mm->end_code = end_code;
1102	current->mm->end_data = end_data;	1104	mm->start_code = start_code;
1103	current->mm->start_stack = bprm->p;	1105	mm->start_data = start_data;
		1106	mm->end_data = end_data;
		1107	mm->start_stack = bprm->p;
1104		1108
1105	if ((current->flags & PF_RANDOMIZE) && (randomize_va_space > 1)) {	1109	if ((current->flags & PF_RANDOMIZE) && (randomize_va_space > 1)) {
1106	/*	1110	/*
@@ -1111,12 +1115,11 @@ out_free_interp: · 4 unmodified lines
1111	* growing down), and into the unused ELF_ET_DYN_BASE region.	1115	* growing down), and into the unused ELF_ET_DYN_BASE region.
1112	*/	1116	*/
1113	if (IS_ENABLED(CONFIG_ARCH_HAS_ELF_RANDOMIZE) &&	1117	if (IS_ENABLED(CONFIG_ARCH_HAS_ELF_RANDOMIZE) &&
1114	loc->elf_ex.e_type == ET_DYN && !interpreter)	1118	elf_ex->e_type == ET_DYN && !interpreter) {
1115	current->mm->brk = current->mm->start_brk =	1119	mm->brk = mm->start_brk = ELF_ET_DYN_BASE;
1116	ELF_ET_DYN_BASE;	1120	}
1117		1121
1118	current->mm->brk = current->mm->start_brk =	1122	mm->brk = mm->start_brk = arch_randomize_brk(mm);
1119	arch_randomize_brk(current->mm);
1120	#ifdef compat_brk_randomized	1123	#ifdef compat_brk_randomized
1121	current->brk_randomized = 1;	1124	current->brk_randomized = 1;
1122	#endif	1125	#endif
@@ -1574,6 +1577,7 @@ static void fill_siginfo_note(struct memelfnote note, user_siginfo_t csigdata, · 451 unmodified lines
1574	*/	1577	*/
1575	static int fill_files_note(struct memelfnote *note)	1578	static int fill_files_note(struct memelfnote *note)
1576	{	1579	{
		1580	struct mm_struct *mm = current->mm;
1577	struct vm_area_struct *vma;	1581	struct vm_area_struct *vma;
1578	unsigned count, size, names_ofs, remaining, n;	1582	unsigned count, size, names_ofs, remaining, n;
1579	user_long_t *data;	1583	user_long_t *data;
@@ -1581,7 +1585,7 @@ static int fill_files_note(struct memelfnote *note) · 1 unmodified line
1581	char name_base, name_curpos;	1585	char name_base, name_curpos;
1582		1586
1583	/* Estimated file count and total data size needed */	1587	/* Estimated file count and total data size needed */
1584	count = current->mm->map_count;	1588	count = mm->map_count;
1585	if (count > UINT_MAX / 64)	1589	if (count > UINT_MAX / 64)
1586	return -EINVAL;	1590	return -EINVAL;
1587	size = count * 64;	1591	size = count * 64;
@@ -1591,6 +1595,10 @@ static int fill_files_note(struct memelfnote *note) · 3 unmodified lines
1591	if (size >= MAX_FILE_NOTE_SIZE) /* paranoia check */	1595	if (size >= MAX_FILE_NOTE_SIZE) /* paranoia check */
1592	return -EINVAL;	1596	return -EINVAL;
1593	size = round_up(size, PAGE_SIZE);	1597	size = round_up(size, PAGE_SIZE);
		1598	/*
		1599	* "size" can be 0 here legitimately.
		1600	* Let it ENOMEM and omit NT_FILE section which will be empty anyway.
		1601	*/
1594	data = kvmalloc(size, GFP_KERNEL);	1602	data = kvmalloc(size, GFP_KERNEL);
1595	if (ZERO_OR_NULL_PTR(data))	1603	if (ZERO_OR_NULL_PTR(data))
1596	return -ENOMEM;	1604	return -ENOMEM;
@@ -1599,7 +1607,7 @@ static int fill_files_note(struct memelfnote *note) · 2 unmodified lines
1599	name_base = name_curpos = ((char *)data) + names_ofs;	1607	name_base = name_curpos = ((char *)data) + names_ofs;
1600	remaining = size - names_ofs;	1608	remaining = size - names_ofs;
1601	count = 0;	1609	count = 0;
1602	for (vma = current->mm->mmap; vma != NULL; vma = vma->vm_next) {	1610	for (vma = mm->mmap; vma != NULL; vma = vma->vm_next) {
1603	struct file *file;	1611	struct file *file;
1604	const char *filename;	1612	const char *filename;
1605		1613
@@ -1633,10 +1641,10 @@ static int fill_files_note(struct memelfnote *note) · 27 unmodified lines
1633	data[0] = count;	1641	data[0] = count;
1634	data[1] = PAGE_SIZE;	1642	data[1] = PAGE_SIZE;
1635	/*	1643	/*
1636	* Count usually is less than current->mm->map_count,	1644	* Count usually is less than mm->map_count,
1637	* we need to move filenames down.	1645	* we need to move filenames down.
1638	*/	1646	*/
1639	n = current->mm->map_count - count;	1647	n = mm->map_count - count;
1640	if (n != 0) {	1648	if (n != 0) {
1641	unsigned shift_bytes = n * 3 * sizeof(data[0]);	1649	unsigned shift_bytes = n * 3 * sizeof(data[0]);
1642	memmove(name_base - shift_bytes, name_base,	1650	memmove(name_base - shift_bytes, name_base,
@@ -2182,7 +2190,7 @@ static int elf_core_dump(struct coredump_params *cprm) · 539 unmodified lines
2182	int segs, i;	2190	int segs, i;
2183	size_t vma_data_size = 0;	2191	size_t vma_data_size = 0;
2184	struct vm_area_struct vma, gate_vma;	2192	struct vm_area_struct vma, gate_vma;
2185	struct elfhdr *elf = NULL;	2193	struct elfhdr elf;
2186	loff_t offset = 0, dataoff;	2194	loff_t offset = 0, dataoff;
2187	struct elf_note_info info = { };	2195	struct elf_note_info info = { };
2188	struct elf_phdr *phdr4note = NULL;	2196	struct elf_phdr *phdr4note = NULL;
@@ -2203,10 +2211,6 @@ static int elf_core_dump(struct coredump_params *cprm) · 14 unmodified lines
2203	* exists while dumping the mm->vm_next areas to the core file.	2211	* exists while dumping the mm->vm_next areas to the core file.
2204	*/	2212	*/
2205		2213
2206	/* alloc memory for large data structures: too large to be on stack */
2207	elf = kmalloc(sizeof(*elf), GFP_KERNEL);
2208	if (!elf)
2209	goto out;
2210	/*	2214	/*
2211	* The number of segs are recored into ELF header as 16bit value.	2215	* The number of segs are recored into ELF header as 16bit value.
2212	* Please check DEFAULT_MAX_MAP_COUNT definition when you modify here.	2216	* Please check DEFAULT_MAX_MAP_COUNT definition when you modify here.
@@ -2230,7 +2234,7 @@ static int elf_core_dump(struct coredump_params *cprm) · 17 unmodified lines
2230	* Collect all the non-memory information about the process for the	2234	* Collect all the non-memory information about the process for the
2231	* notes. This also sets up the file header.	2235	* notes. This also sets up the file header.
2232	*/	2236	*/
2233	if (!fill_note_info(elf, e_phnum, &info, cprm->siginfo, cprm->regs))	2237	if (!fill_note_info(&elf, e_phnum, &info, cprm->siginfo, cprm->regs))
2234	goto cleanup;	2238	goto cleanup;
2235		2239
2236	has_dumped = 1;	2240	has_dumped = 1;
@@ -2238,7 +2242,7 @@ static int elf_core_dump(struct coredump_params *cprm) · 1 unmodified line
2238	fs = get_fs();	2242	fs = get_fs();
2239	set_fs(KERNEL_DS);	2243	set_fs(KERNEL_DS);
2240		2244
2241	offset += sizeof(elf); / Elf header */	2245	offset += sizeof(elf); /* Elf header */
2242	offset += segs * sizeof(struct elf_phdr); /* Program headers */	2246	offset += segs * sizeof(struct elf_phdr); /* Program headers */
2243		2247
2244	/* Write notes phdr entry */	2248	/* Write notes phdr entry */
@@ -2257,11 +2261,13 @@ static int elf_core_dump(struct coredump_params *cprm) · 12 unmodified lines
2257		2261
2258	dataoff = offset = roundup(offset, ELF_EXEC_PAGESIZE);	2262	dataoff = offset = roundup(offset, ELF_EXEC_PAGESIZE);
2259		2263
2260	if (segs - 1 > ULONG_MAX / sizeof(*vma_filesz))	2264	/*
2261	goto end_coredump;	2265	* Zero vma process will get ZERO_SIZE_PTR here.
		2266	* Let coredump continue for register state at least.
		2267	*/
2262	vma_filesz = kvmalloc(array_size(sizeof(*vma_filesz), (segs - 1)),	2268	vma_filesz = kvmalloc(array_size(sizeof(*vma_filesz), (segs - 1)),
2263	GFP_KERNEL);	2269	GFP_KERNEL);
2264	if (ZERO_OR_NULL_PTR(vma_filesz))	2270	if (!vma_filesz)
2265	goto end_coredump;	2271	goto end_coredump;
2266		2272
2267	for (i = 0, vma = first_vma(current, gate_vma); vma != NULL;	2273	for (i = 0, vma = first_vma(current, gate_vma); vma != NULL;
@@ -2281,12 +2287,12 @@ static int elf_core_dump(struct coredump_params *cprm) · 13 unmodified lines
2281	shdr4extnum = kmalloc(sizeof(*shdr4extnum), GFP_KERNEL);	2287	shdr4extnum = kmalloc(sizeof(*shdr4extnum), GFP_KERNEL);
2282	if (!shdr4extnum)	2288	if (!shdr4extnum)
2283	goto end_coredump;	2289	goto end_coredump;
2284	fill_extnum_info(elf, shdr4extnum, e_shoff, segs);	2290	fill_extnum_info(&elf, shdr4extnum, e_shoff, segs);
2285	}	2291	}
2286		2292
2287	offset = dataoff;	2293	offset = dataoff;
2288		2294
2289	if (!dump_emit(cprm, elf, sizeof(*elf)))	2295	if (!dump_emit(cprm, &elf, sizeof(elf)))
2290	goto end_coredump;	2296	goto end_coredump;
2291		2297
2292	if (!dump_emit(cprm, phdr4note, sizeof(*phdr4note)))	2298	if (!dump_emit(cprm, phdr4note, sizeof(*phdr4note)))
@@ -2370,8 +2376,6 @@ cleanup: · 77 unmodified lines
2370	kfree(shdr4extnum);	2376	kfree(shdr4extnum);
2371	kvfree(vma_filesz);	2377	kvfree(vma_filesz);
2372	kfree(phdr4note);	2378	kfree(phdr4note);
2373	kfree(elf);
2374	out:
2375	return has_dumped;	2379	return has_dumped;
2376	}	2380	}
2377		2381

fs/btrfs/compression.c+1−1

@@ -1290,7 +1290,7 @@ int btrfs_decompress_buf2page(const char *buf, unsigned long buf_start, · 1289 unmodified lines
1290	/* copy bytes from the working buffer into the pages */	1290	/* copy bytes from the working buffer into the pages */
1291	while (working_bytes > 0) {	1291	while (working_bytes > 0) {
1292	bytes = min_t(unsigned long, bvec.bv_len,	1292	bytes = min_t(unsigned long, bvec.bv_len,
1293	PAGE_SIZE - buf_offset);	1293	PAGE_SIZE - (buf_offset % PAGE_SIZE));
1294	bytes = min(bytes, working_bytes);	1294	bytes = min(bytes, working_bytes);
1295		1295
1296	kaddr = kmap_atomic(bvec.bv_page);	1296	kaddr = kmap_atomic(bvec.bv_page);

fs/btrfs/zlib.c+100−35

@@ -20,9 +20,13 @@ · 19 unmodified lines
20	#include <linux/refcount.h>	20	#include <linux/refcount.h>
21	#include "compression.h"	21	#include "compression.h"
22		22
		23	/* workspace buffer size for s390 zlib hardware support */
		24	#define ZLIB_DFLTCC_BUF_SIZE (4 * PAGE_SIZE)
		25
23	struct workspace {	26	struct workspace {
24	z_stream strm;	27	z_stream strm;
25	char *buf;	28	char *buf;
		29	unsigned int buf_size;
26	struct list_head list;	30	struct list_head list;
27	int level;	31	int level;
28	};	32	};
@@ -61,7 +65,21 @@ struct list_head *zlib_alloc_workspace(unsigned int level) · 32 unmodified lines
61	zlib_inflate_workspacesize());	65	zlib_inflate_workspacesize());
62	workspace->strm.workspace = kvmalloc(workspacesize, GFP_KERNEL);	66	workspace->strm.workspace = kvmalloc(workspacesize, GFP_KERNEL);
63	workspace->level = level;	67	workspace->level = level;
64	workspace->buf = kmalloc(PAGE_SIZE, GFP_KERNEL);	68	workspace->buf = NULL;
		69	/*
		70	* In case of s390 zlib hardware support, allocate lager workspace
		71	* buffer. If allocator fails, fall back to a single page buffer.
		72	*/
		73	if (zlib_deflate_dfltcc_enabled()) {
		74	workspace->buf = kmalloc(ZLIB_DFLTCC_BUF_SIZE,
		75	__GFP_NOMEMALLOC \| __GFP_NORETRY \|
		76	__GFP_NOWARN \| GFP_NOIO);
		77	workspace->buf_size = ZLIB_DFLTCC_BUF_SIZE;
		78	}
		79	if (!workspace->buf) {
		80	workspace->buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
		81	workspace->buf_size = PAGE_SIZE;
		82	}
65	if (!workspace->strm.workspace \|\| !workspace->buf)	83	if (!workspace->strm.workspace \|\| !workspace->buf)
66	goto fail;	84	goto fail;
67		85
@@ -85,6 +103,7 @@ int zlib_compress_pages(struct list_head ws, struct address_space mapping, · 17 unmodified lines
85	struct page *in_page = NULL;	103	struct page *in_page = NULL;
86	struct page *out_page = NULL;	104	struct page *out_page = NULL;
87	unsigned long bytes_left;	105	unsigned long bytes_left;
		106	unsigned int in_buf_pages;
88	unsigned long len = *total_out;	107	unsigned long len = *total_out;
89	unsigned long nr_dest_pages = *out_pages;	108	unsigned long nr_dest_pages = *out_pages;
90	const unsigned long max_out = nr_dest_pages * PAGE_SIZE;	109	const unsigned long max_out = nr_dest_pages * PAGE_SIZE;
@@ -102,9 +121,6 @@ int zlib_compress_pages(struct list_head ws, struct address_space mapping, · 11 unmodified lines
102	workspace->strm.total_in = 0;	121	workspace->strm.total_in = 0;
103	workspace->strm.total_out = 0;	122	workspace->strm.total_out = 0;
104		123
105	in_page = find_get_page(mapping, start >> PAGE_SHIFT);
106	data_in = kmap(in_page);
107
108	out_page = alloc_page(GFP_NOFS \| __GFP_HIGHMEM);	124	out_page = alloc_page(GFP_NOFS \| __GFP_HIGHMEM);
109	if (out_page == NULL) {	125	if (out_page == NULL) {
110	ret = -ENOMEM;	126	ret = -ENOMEM;
@@ -114,12 +130,51 @@ int zlib_compress_pages(struct list_head ws, struct address_space mapping, · 3 unmodified lines
114	pages[0] = out_page;	130	pages[0] = out_page;
115	nr_pages = 1;	131	nr_pages = 1;
116		132
117	workspace->strm.next_in = data_in;	133	workspace->strm.next_in = workspace->buf;
		134	workspace->strm.avail_in = 0;
118	workspace->strm.next_out = cpage_out;	135	workspace->strm.next_out = cpage_out;
119	workspace->strm.avail_out = PAGE_SIZE;	136	workspace->strm.avail_out = PAGE_SIZE;
120	workspace->strm.avail_in = min(len, PAGE_SIZE);
121		137
122	while (workspace->strm.total_in < len) {	138	while (workspace->strm.total_in < len) {
		139	/*
		140	* Get next input pages and copy the contents to
		141	* the workspace buffer if required.
		142	*/
		143	if (workspace->strm.avail_in == 0) {
		144	bytes_left = len - workspace->strm.total_in;
		145	in_buf_pages = min(DIV_ROUND_UP(bytes_left, PAGE_SIZE),
		146	workspace->buf_size / PAGE_SIZE);
		147	if (in_buf_pages > 1) {
		148	int i;
		149
		150	for (i = 0; i < in_buf_pages; i++) {
		151	if (in_page) {
		152	kunmap(in_page);
		153	put_page(in_page);
		154	}
		155	in_page = find_get_page(mapping,
		156	start >> PAGE_SHIFT);
		157	data_in = kmap(in_page);
		158	memcpy(workspace->buf + i * PAGE_SIZE,
		159	data_in, PAGE_SIZE);
		160	start += PAGE_SIZE;
		161	}
		162	workspace->strm.next_in = workspace->buf;
		163	} else {
		164	if (in_page) {
		165	kunmap(in_page);
		166	put_page(in_page);
		167	}
		168	in_page = find_get_page(mapping,
		169	start >> PAGE_SHIFT);
		170	data_in = kmap(in_page);
		171	start += PAGE_SIZE;
		172	workspace->strm.next_in = data_in;
		173	}
		174	workspace->strm.avail_in = min(bytes_left,
		175	(unsigned long) workspace->buf_size);
		176	}
		177
123	ret = zlib_deflate(&workspace->strm, Z_SYNC_FLUSH);	178	ret = zlib_deflate(&workspace->strm, Z_SYNC_FLUSH);
124	if (ret != Z_OK) {	179	if (ret != Z_OK) {
125	pr_debug("BTRFS: deflate in loop returned %d\n",	180	pr_debug("BTRFS: deflate in loop returned %d\n",
@@ -161,33 +216,43 @@ int zlib_compress_pages(struct list_head ws, struct address_space mapping, · 35 unmodified lines
161	/* we're all done */	216	/* we're all done */
162	if (workspace->strm.total_in >= len)	217	if (workspace->strm.total_in >= len)
163	break;	218	break;
164		219	if (workspace->strm.total_out > max_out)
165	/* we've read in a full page, get a new one */	220	break;
166	if (workspace->strm.avail_in == 0) {
167	if (workspace->strm.total_out > max_out)
168	break;
169
170	bytes_left = len - workspace->strm.total_in;
171	kunmap(in_page);
172	put_page(in_page);
173
174	start += PAGE_SIZE;
175	in_page = find_get_page(mapping,
176	start >> PAGE_SHIFT);
177	data_in = kmap(in_page);
178	workspace->strm.avail_in = min(bytes_left,
179	PAGE_SIZE);
180	workspace->strm.next_in = data_in;
181	}
182	}	221	}
183	workspace->strm.avail_in = 0;	222	workspace->strm.avail_in = 0;
184	ret = zlib_deflate(&workspace->strm, Z_FINISH);	223	/*
185	zlib_deflateEnd(&workspace->strm);	224	* Call deflate with Z_FINISH flush parameter providing more output
186		225	* space but no more input data, until it returns with Z_STREAM_END.
187	if (ret != Z_STREAM_END) {	226	*/
188	ret = -EIO;	227	while (ret != Z_STREAM_END) {
189	goto out;	228	ret = zlib_deflate(&workspace->strm, Z_FINISH);
		229	if (ret == Z_STREAM_END)
		230	break;
		231	if (ret != Z_OK && ret != Z_BUF_ERROR) {
		232	zlib_deflateEnd(&workspace->strm);
		233	ret = -EIO;
		234	goto out;
		235	} else if (workspace->strm.avail_out == 0) {
		236	/* get another page for the stream end */
		237	kunmap(out_page);
		238	if (nr_pages == nr_dest_pages) {
		239	out_page = NULL;
		240	ret = -E2BIG;
		241	goto out;
		242	}
		243	out_page = alloc_page(GFP_NOFS \| __GFP_HIGHMEM);
		244	if (out_page == NULL) {
		245	ret = -ENOMEM;
		246	goto out;
		247	}
		248	cpage_out = kmap(out_page);
		249	pages[nr_pages] = out_page;
		250	nr_pages++;
		251	workspace->strm.avail_out = PAGE_SIZE;
		252	workspace->strm.next_out = cpage_out;
		253	}
190	}	254	}
		255	zlib_deflateEnd(&workspace->strm);
191		256
192	if (workspace->strm.total_out >= workspace->strm.total_in) {	257	if (workspace->strm.total_out >= workspace->strm.total_in) {
193	ret = -E2BIG;	258	ret = -E2BIG;
@@ -231,7 +296,7 @@ int zlib_decompress_bio(struct list_head ws, struct compressed_bio cb) · 37 unmodified lines
231		296
232	workspace->strm.total_out = 0;	297	workspace->strm.total_out = 0;
233	workspace->strm.next_out = workspace->buf;	298	workspace->strm.next_out = workspace->buf;
234	workspace->strm.avail_out = PAGE_SIZE;	299	workspace->strm.avail_out = workspace->buf_size;
235		300
236	/* If it's deflate, and it's got no preset dictionary, then	301	/* If it's deflate, and it's got no preset dictionary, then
237	we can tell zlib to skip the adler32 check. */	302	we can tell zlib to skip the adler32 check. */
@@ -270,7 +335,7 @@ int zlib_decompress_bio(struct list_head ws, struct compressed_bio cb) · 32 unmodified lines
270	}	335	}
271		336
272	workspace->strm.next_out = workspace->buf;	337	workspace->strm.next_out = workspace->buf;
273	workspace->strm.avail_out = PAGE_SIZE;	338	workspace->strm.avail_out = workspace->buf_size;
274		339
275	if (workspace->strm.avail_in == 0) {	340	if (workspace->strm.avail_in == 0) {
276	unsigned long tmp;	341	unsigned long tmp;
@@ -320,7 +385,7 @@ int zlib_decompress(struct list_head ws, unsigned char data_in, · 43 unmodified lines
320	workspace->strm.total_in = 0;	385	workspace->strm.total_in = 0;
321		386
322	workspace->strm.next_out = workspace->buf;	387	workspace->strm.next_out = workspace->buf;
323	workspace->strm.avail_out = PAGE_SIZE;	388	workspace->strm.avail_out = workspace->buf_size;
324	workspace->strm.total_out = 0;	389	workspace->strm.total_out = 0;
325	/* If it's deflate, and it's got no preset dictionary, then	390	/* If it's deflate, and it's got no preset dictionary, then
326	we can tell zlib to skip the adler32 check. */	391	we can tell zlib to skip the adler32 check. */
@@ -364,7 +429,7 @@ int zlib_decompress(struct list_head ws, unsigned char data_in, · 37 unmodified lines
364	buf_offset = 0;	429	buf_offset = 0;
365		430
366	bytes = min(PAGE_SIZE - pg_offset,	431	bytes = min(PAGE_SIZE - pg_offset,
367	PAGE_SIZE - buf_offset);	432	PAGE_SIZE - (buf_offset % PAGE_SIZE));
368	bytes = min(bytes, bytes_left);	433	bytes = min(bytes, bytes_left);
369		434
370	kaddr = kmap_atomic(dest_page);	435	kaddr = kmap_atomic(dest_page);
@@ -375,7 +440,7 @@ int zlib_decompress(struct list_head ws, unsigned char data_in, · 4 unmodified lines
375	bytes_left -= bytes;	440	bytes_left -= bytes;
376	next:	441	next:
377	workspace->strm.next_out = workspace->buf;	442	workspace->strm.next_out = workspace->buf;
378	workspace->strm.avail_out = PAGE_SIZE;	443	workspace->strm.avail_out = workspace->buf_size;
379	}	444	}
380		445
381	if (ret != Z_STREAM_END && bytes_left != 0)	446	if (ret != Z_STREAM_END && bytes_left != 0)

fs/exec.c+5−0

 		goto out_unlock;
 	BUG_ON(prev != vma);
+	if (unlikely(vm_flags & VM_EXEC)) {
+		pr_warn_once("process '%pD4' started with executable stack\n",
+			     bprm->file);
+	}
 	/* Move stack pages down in memory. */
 	if (stack_shift) {
 		ret = shift_arg_pages(vma, stack_shift);

fs/fs-writeback.c+1−1

@@ -2063,7 +2063,7 @@ void wb_workfn(struct work_struct *work) · 2062 unmodified lines
2063	struct bdi_writeback, dwork);	2063	struct bdi_writeback, dwork);
2064	long pages_written;	2064	long pages_written;
2065		2065
2066	set_worker_desc("flush-%s", dev_name(wb->bdi->dev));	2066	set_worker_desc("flush-%s", bdi_dev_name(wb->bdi));
2067	current->flags \|= PF_SWAPWRITE;	2067	current->flags \|= PF_SWAPWRITE;
2068		2068
2069	if (likely(!current_is_workqueue_rescuer() \|\|	2069	if (likely(!current_is_workqueue_rescuer() \|\|

fs/io_uring.c+3−3

@@ -6005,7 +6005,7 @@ static int io_sqe_buffer_unregister(struct io_ring_ctx *ctx) · 6004 unmodified lines
6005	struct io_mapped_ubuf *imu = &ctx->user_bufs[i];	6005	struct io_mapped_ubuf *imu = &ctx->user_bufs[i];
6006		6006
6007	for (j = 0; j < imu->nr_bvecs; j++)	6007	for (j = 0; j < imu->nr_bvecs; j++)
6008	put_user_page(imu->bvec[j].bv_page);	6008	unpin_user_page(imu->bvec[j].bv_page);
6009		6009
6010	if (ctx->account_mem)	6010	if (ctx->account_mem)
6011	io_unaccount_mem(ctx->user, imu->nr_bvecs);	6011	io_unaccount_mem(ctx->user, imu->nr_bvecs);
@@ -6126,7 +6126,7 @@ static int io_sqe_buffer_register(struct io_ring_ctx ctx, void __user arg, · 114 unmodified lines
6126		6126
6127	ret = 0;	6127	ret = 0;
6128	down_read(&current->mm->mmap_sem);	6128	down_read(&current->mm->mmap_sem);
6129	pret = get_user_pages(ubuf, nr_pages,	6129	pret = pin_user_pages(ubuf, nr_pages,
6130	FOLL_WRITE \| FOLL_LONGTERM,	6130	FOLL_WRITE \| FOLL_LONGTERM,
6131	pages, vmas);	6131	pages, vmas);
6132	if (pret == nr_pages) {	6132	if (pret == nr_pages) {
@@ -6150,7 +6150,7 @@ static int io_sqe_buffer_register(struct io_ring_ctx ctx, void __user arg, · 17 unmodified lines
6150	* release any pages we did get	6150	* release any pages we did get
6151	*/	6151	*/
6152	if (pret > 0)	6152	if (pret > 0)
6153	put_user_pages(pages, pret);	6153	unpin_user_pages(pages, pret);
6154	if (ctx->account_mem)	6154	if (ctx->account_mem)
6155	io_unaccount_mem(ctx->user, nr_pages);	6155	io_unaccount_mem(ctx->user, nr_pages);
6156	kvfree(imu->bvec);	6156	kvfree(imu->bvec);

fs/ocfs2/cluster/quorum.c+1−1

@@ -73,7 +73,7 @@ static void o2quo_fence_self(void) · 72 unmodified lines
73	"system by restarting ***\n");	73	"system by restarting ***\n");
74	emergency_restart();	74	emergency_restart();
75	break;	75	break;
76	};	76	}
77	}	77	}
78		78
79	/* Indicate that a timeout occurred on a heartbeat region write. The	79	/* Indicate that a timeout occurred on a heartbeat region write. The

fs/ocfs2/dlm/Makefile+0−2

@@ -1,6 +1,4 @@
1	# SPDX-License-Identifier: GPL-2.0-only	1	# SPDX-License-Identifier: GPL-2.0-only
2	ccflags-y := -I $(srctree)/$(src)/..
3
4	obj-$(CONFIG_OCFS2_FS_O2CB) += ocfs2_dlm.o	2	obj-$(CONFIG_OCFS2_FS_O2CB) += ocfs2_dlm.o
5		3
6	ocfs2_dlm-objs := dlmdomain.o dlmdebug.o dlmthread.o dlmrecovery.o \	4	ocfs2_dlm-objs := dlmdomain.o dlmdebug.o dlmthread.o dlmrecovery.o \

fs/ocfs2/dlm/dlmast.c+4−4

@@ -23,15 +23,15 @@ · 22 unmodified lines
23	#include <linux/spinlock.h>	23	#include <linux/spinlock.h>
24		24
25		25
26	#include "cluster/heartbeat.h"	26	#include "../cluster/heartbeat.h"
27	#include "cluster/nodemanager.h"	27	#include "../cluster/nodemanager.h"
28	#include "cluster/tcp.h"	28	#include "../cluster/tcp.h"
29		29
30	#include "dlmapi.h"	30	#include "dlmapi.h"
31	#include "dlmcommon.h"	31	#include "dlmcommon.h"
32		32
33	#define MLOG_MASK_PREFIX ML_DLM	33	#define MLOG_MASK_PREFIX ML_DLM
34	#include "cluster/masklog.h"	34	#include "../cluster/masklog.h"
35		35
36	static void dlm_update_lvb(struct dlm_ctxt dlm, struct dlm_lock_resource res,	36	static void dlm_update_lvb(struct dlm_ctxt dlm, struct dlm_lock_resource res,
37	struct dlm_lock *lock);	37	struct dlm_lock *lock);

fs/ocfs2/dlm/dlmcommon.h+0−4

@@ -688,10 +688,6 @@ struct dlm_begin_reco · 687 unmodified lines
688	__be32 pad2;	688	__be32 pad2;
689	};	689	};
690		690
691
692	#define BITS_PER_BYTE 8
693	#define BITS_TO_BYTES(bits) (((bits)+BITS_PER_BYTE-1)/BITS_PER_BYTE)
694
695	struct dlm_query_join_request	691	struct dlm_query_join_request
696	{	692	{
697	u8 node_idx;	693	u8 node_idx;

fs/ocfs2/dlm/dlmconvert.c+4−4

@@ -23,9 +23,9 @@ · 22 unmodified lines
23	#include <linux/spinlock.h>	23	#include <linux/spinlock.h>
24		24
25		25
26	#include "cluster/heartbeat.h"	26	#include "../cluster/heartbeat.h"
27	#include "cluster/nodemanager.h"	27	#include "../cluster/nodemanager.h"
28	#include "cluster/tcp.h"	28	#include "../cluster/tcp.h"
29		29
30	#include "dlmapi.h"	30	#include "dlmapi.h"
31	#include "dlmcommon.h"	31	#include "dlmcommon.h"
@@ -33,7 +33,7 @@ · 1 unmodified line
33	#include "dlmconvert.h"	33	#include "dlmconvert.h"
34		34
35	#define MLOG_MASK_PREFIX ML_DLM	35	#define MLOG_MASK_PREFIX ML_DLM
36	#include "cluster/masklog.h"	36	#include "../cluster/masklog.h"
37		37
38	/* NOTE: __dlmconvert_master is the only function in here that	38	/* NOTE: __dlmconvert_master is the only function in here that
39	* needs a spinlock held on entry (res->spinlock) and it is the	39	* needs a spinlock held on entry (res->spinlock) and it is the

fs/ocfs2/dlm/dlmdebug.c+4−4

@@ -17,9 +17,9 @@ · 16 unmodified lines
17	#include <linux/debugfs.h>	17	#include <linux/debugfs.h>
18	#include <linux/export.h>	18	#include <linux/export.h>
19		19
20	#include "cluster/heartbeat.h"	20	#include "../cluster/heartbeat.h"
21	#include "cluster/nodemanager.h"	21	#include "../cluster/nodemanager.h"
22	#include "cluster/tcp.h"	22	#include "../cluster/tcp.h"
23		23
24	#include "dlmapi.h"	24	#include "dlmapi.h"
25	#include "dlmcommon.h"	25	#include "dlmcommon.h"
@@ -27,7 +27,7 @@ · 1 unmodified line
27	#include "dlmdebug.h"	27	#include "dlmdebug.h"
28		28
29	#define MLOG_MASK_PREFIX ML_DLM	29	#define MLOG_MASK_PREFIX ML_DLM
30	#include "cluster/masklog.h"	30	#include "../cluster/masklog.h"
31		31
32	static int stringify_lockname(const char lockname, int locklen, char buf,	32	static int stringify_lockname(const char lockname, int locklen, char buf,
33	int len);	33	int len);

fs/ocfs2/dlm/dlmdomain.c+4−4

@@ -20,9 +20,9 @@ · 19 unmodified lines
20	#include <linux/debugfs.h>	20	#include <linux/debugfs.h>
21	#include <linux/sched/signal.h>	21	#include <linux/sched/signal.h>
22		22
23	#include "cluster/heartbeat.h"	23	#include "../cluster/heartbeat.h"
24	#include "cluster/nodemanager.h"	24	#include "../cluster/nodemanager.h"
25	#include "cluster/tcp.h"	25	#include "../cluster/tcp.h"
26		26
27	#include "dlmapi.h"	27	#include "dlmapi.h"
28	#include "dlmcommon.h"	28	#include "dlmcommon.h"
@@ -30,7 +30,7 @@ · 1 unmodified line
30	#include "dlmdebug.h"	30	#include "dlmdebug.h"
31		31
32	#define MLOG_MASK_PREFIX (ML_DLM\|ML_DLM_DOMAIN)	32	#define MLOG_MASK_PREFIX (ML_DLM\|ML_DLM_DOMAIN)
33	#include "cluster/masklog.h"	33	#include "../cluster/masklog.h"
34		34
35	/*	35	/*
36	* ocfs2 node maps are array of long int, which limits to send them freely	36	* ocfs2 node maps are array of long int, which limits to send them freely

fs/ocfs2/dlm/dlmlock.c+4−4

@@ -25,9 +25,9 @@ · 24 unmodified lines
25	#include <linux/delay.h>	25	#include <linux/delay.h>
26		26
27		27
28	#include "cluster/heartbeat.h"	28	#include "../cluster/heartbeat.h"
29	#include "cluster/nodemanager.h"	29	#include "../cluster/nodemanager.h"
30	#include "cluster/tcp.h"	30	#include "../cluster/tcp.h"
31		31
32	#include "dlmapi.h"	32	#include "dlmapi.h"
33	#include "dlmcommon.h"	33	#include "dlmcommon.h"
@@ -35,7 +35,7 @@ · 1 unmodified line
35	#include "dlmconvert.h"	35	#include "dlmconvert.h"
36		36
37	#define MLOG_MASK_PREFIX ML_DLM	37	#define MLOG_MASK_PREFIX ML_DLM
38	#include "cluster/masklog.h"	38	#include "../cluster/masklog.h"
39		39
40	static struct kmem_cache *dlm_lock_cache;	40	static struct kmem_cache *dlm_lock_cache;
41		41

fs/ocfs2/dlm/dlmmaster.c+4−6

 #include <linux/delay.h>
-#include "cluster/heartbeat.h"
+#include "../cluster/heartbeat.h"
-#include "cluster/nodemanager.h"
+#include "../cluster/nodemanager.h"
-#include "cluster/tcp.h"
+#include "../cluster/tcp.h"
 #include "dlmapi.h"
 #include "dlmcommon.h"
 #include "dlmdebug.h"
 #define MLOG_MASK_PREFIX (ML_DLM|ML_DLM_MASTER)
-#include "cluster/masklog.h"
+#include "../cluster/masklog.h"
 static void dlm_mle_node_down(struct dlm_ctxt *dlm,
 			      struct dlm_master_list_entry *mle,
 	if (!dlm_grab(dlm))
 		return -EINVAL;
-	BUG_ON(target == O2NM_MAX_NODES);
 	name = res->lockname.name;
 	namelen = res->lockname.len;

fs/ocfs2/dlm/dlmrecovery.c+5−5

@@ -26,16 +26,16 @@ · 25 unmodified lines
26	#include <linux/delay.h>	26	#include <linux/delay.h>
27		27
28		28
29	#include "cluster/heartbeat.h"	29	#include "../cluster/heartbeat.h"
30	#include "cluster/nodemanager.h"	30	#include "../cluster/nodemanager.h"
31	#include "cluster/tcp.h"	31	#include "../cluster/tcp.h"
32		32
33	#include "dlmapi.h"	33	#include "dlmapi.h"
34	#include "dlmcommon.h"	34	#include "dlmcommon.h"
35	#include "dlmdomain.h"	35	#include "dlmdomain.h"
36		36
37	#define MLOG_MASK_PREFIX (ML_DLM\|ML_DLM_RECOVERY)	37	#define MLOG_MASK_PREFIX (ML_DLM\|ML_DLM_RECOVERY)
38	#include "cluster/masklog.h"	38	#include "../cluster/masklog.h"
39		39
40	static void dlm_do_local_recovery_cleanup(struct dlm_ctxt *dlm, u8 dead_node);	40	static void dlm_do_local_recovery_cleanup(struct dlm_ctxt *dlm, u8 dead_node);
41		41
@@ -1668,7 +1668,7 @@ static int dlm_lockres_master_requery(struct dlm_ctxt *dlm, · 1626 unmodified lines
1668	int dlm_do_master_requery(struct dlm_ctxt dlm, struct dlm_lock_resource res,	1668	int dlm_do_master_requery(struct dlm_ctxt dlm, struct dlm_lock_resource res,
1669	u8 nodenum, u8 *real_master)	1669	u8 nodenum, u8 *real_master)
1670	{	1670	{
1671	int ret = -EINVAL;	1671	int ret;
1672	struct dlm_master_requery req;	1672	struct dlm_master_requery req;
1673	int status = DLM_LOCK_RES_OWNER_UNKNOWN;	1673	int status = DLM_LOCK_RES_OWNER_UNKNOWN;
1674		1674

fs/ocfs2/dlm/dlmthread.c+4−4

@@ -25,16 +25,16 @@ · 24 unmodified lines
25	#include <linux/delay.h>	25	#include <linux/delay.h>
26		26
27		27
28	#include "cluster/heartbeat.h"	28	#include "../cluster/heartbeat.h"
29	#include "cluster/nodemanager.h"	29	#include "../cluster/nodemanager.h"
30	#include "cluster/tcp.h"	30	#include "../cluster/tcp.h"
31		31
32	#include "dlmapi.h"	32	#include "dlmapi.h"
33	#include "dlmcommon.h"	33	#include "dlmcommon.h"
34	#include "dlmdomain.h"	34	#include "dlmdomain.h"
35		35
36	#define MLOG_MASK_PREFIX (ML_DLM\|ML_DLM_THREAD)	36	#define MLOG_MASK_PREFIX (ML_DLM\|ML_DLM_THREAD)
37	#include "cluster/masklog.h"	37	#include "../cluster/masklog.h"
38		38
39	static int dlm_thread(void *data);	39	static int dlm_thread(void *data);
40	static void dlm_flush_asts(struct dlm_ctxt *dlm);	40	static void dlm_flush_asts(struct dlm_ctxt *dlm);

fs/ocfs2/dlm/dlmunlock.c+4−4

@@ -23,15 +23,15 @@ · 22 unmodified lines
23	#include <linux/spinlock.h>	23	#include <linux/spinlock.h>
24	#include <linux/delay.h>	24	#include <linux/delay.h>
25		25
26	#include "cluster/heartbeat.h"	26	#include "../cluster/heartbeat.h"
27	#include "cluster/nodemanager.h"	27	#include "../cluster/nodemanager.h"
28	#include "cluster/tcp.h"	28	#include "../cluster/tcp.h"
29		29
30	#include "dlmapi.h"	30	#include "dlmapi.h"
31	#include "dlmcommon.h"	31	#include "dlmcommon.h"
32		32
33	#define MLOG_MASK_PREFIX ML_DLM	33	#define MLOG_MASK_PREFIX ML_DLM
34	#include "cluster/masklog.h"	34	#include "../cluster/masklog.h"
35		35
36	#define DLM_UNLOCK_FREE_LOCK 0x00000001	36	#define DLM_UNLOCK_FREE_LOCK 0x00000001
37	#define DLM_UNLOCK_CALL_AST 0x00000002	37	#define DLM_UNLOCK_CALL_AST 0x00000002

fs/ocfs2/dlmfs/Makefile+0−2

@@ -1,6 +1,4 @@
1	# SPDX-License-Identifier: GPL-2.0-only	1	# SPDX-License-Identifier: GPL-2.0-only
2	ccflags-y := -I $(srctree)/$(src)/..
3
4	obj-$(CONFIG_OCFS2_FS) += ocfs2_dlmfs.o	2	obj-$(CONFIG_OCFS2_FS) += ocfs2_dlmfs.o
5		3
6	ocfs2_dlmfs-objs := userdlm.o dlmfs.o	4	ocfs2_dlmfs-objs := userdlm.o dlmfs.o

fs/ocfs2/dlmfs/dlmfs.c+2−2

@@ -33,11 +33,11 @@ · 32 unmodified lines
33		33
34	#include <linux/uaccess.h>	34	#include <linux/uaccess.h>
35		35
36	#include "stackglue.h"	36	#include "../stackglue.h"
37	#include "userdlm.h"	37	#include "userdlm.h"
38		38
39	#define MLOG_MASK_PREFIX ML_DLMFS	39	#define MLOG_MASK_PREFIX ML_DLMFS
40	#include "cluster/masklog.h"	40	#include "../cluster/masklog.h"
41		41
42		42
43	static const struct super_operations dlmfs_ops;	43	static const struct super_operations dlmfs_ops;

fs/ocfs2/dlmfs/userdlm.c+3−3

@@ -21,12 +21,12 @@ · 20 unmodified lines
21	#include <linux/types.h>	21	#include <linux/types.h>
22	#include <linux/crc32.h>	22	#include <linux/crc32.h>
23		23
24	#include "ocfs2_lockingver.h"	24	#include "../ocfs2_lockingver.h"
25	#include "stackglue.h"	25	#include "../stackglue.h"
26	#include "userdlm.h"	26	#include "userdlm.h"
27		27
28	#define MLOG_MASK_PREFIX ML_DLMFS	28	#define MLOG_MASK_PREFIX ML_DLMFS
29	#include "cluster/masklog.h"	29	#include "../cluster/masklog.h"
30		30
31		31
32	static inline struct user_lock_res user_lksb_to_lock_res(struct ocfs2_dlm_lksb lksb)	32	static inline struct user_lock_res user_lksb_to_lock_res(struct ocfs2_dlm_lksb lksb)

fs/ocfs2/dlmglue.c+1−1

@@ -570,7 +570,7 @@ void ocfs2_inode_lock_res_init(struct ocfs2_lock_res *res, · 569 unmodified lines
570	mlog_bug_on_msg(1, "type: %d\n", type);	570	mlog_bug_on_msg(1, "type: %d\n", type);
571	ops = NULL; /* thanks, gcc */	571	ops = NULL; /* thanks, gcc */
572	break;	572	break;
573	};	573	}
574		574
575	ocfs2_build_lock_name(type, OCFS2_I(inode)->ip_blkno,	575	ocfs2_build_lock_name(type, OCFS2_I(inode)->ip_blkno,
576	generation, res->l_name);	576	generation, res->l_name);

fs/ocfs2/journal.h+5−3

 {
 	struct ocfs2_inode_info *oi = OCFS2_I(inode);
-	oi->i_sync_tid = handle->h_transaction->t_tid;
+	if (!is_handle_aborted(handle)) {
-	if (datasync)
+		oi->i_sync_tid = handle->h_transaction->t_tid;
-		oi->i_datasync_tid = handle->h_transaction->t_tid;
+		if (datasync)
+			oi->i_datasync_tid = handle->h_transaction->t_tid;
+	}
 }
 #endif /* OCFS2_JOURNAL_H */

fs/ocfs2/namei.c+1−2

@@ -586,8 +586,7 @@ static int __ocfs2_mknod_locked(struct inode *dir, · 585 unmodified lines
586	mlog_errno(status);	586	mlog_errno(status);
587	}	587	}
588		588
589	oi->i_sync_tid = handle->h_transaction->t_tid;	589	ocfs2_update_inode_fsync_trans(handle, inode, 1);
590	oi->i_datasync_tid = handle->h_transaction->t_tid;
591		590
592	leave:	591	leave:
593	if (status < 0) {	592	if (status < 0) {

fs/reiserfs/stree.c+2−1

 	/* also releases the path */
 	unfix_nodes(&s_ins_balance);
 #ifdef REISERQUOTA_DEBUG
-	reiserfs_debug(th->t_super, REISERFS_DEBUG_CODE,
+	if (inode)
+		reiserfs_debug(th->t_super, REISERFS_DEBUG_CODE,
 		       "reiserquota insert_item(): freeing %u id=%u type=%c",
 		       quota_bytes, inode->i_uid, head2type(ih));
 #endif

include/linux/backing-dev.h+10−0

 #include <linux/fs.h>
 #include <linux/sched.h>
 #include <linux/blkdev.h>
+#include <linux/device.h>
 #include <linux/writeback.h>
 #include <linux/blk-cgroup.h>
 #include <linux/backing-dev-defs.h>
 				  (1 << WB_async_congested));
 }
+extern const char *bdi_unknown_name;
+static inline const char *bdi_dev_name(struct backing_dev_info *bdi)
+{
+	if (!bdi || !bdi->dev)
+		return bdi_unknown_name;
+	return dev_name(bdi->dev);
+}
 #endif	/* _LINUX_BACKING_DEV_H */

include/linux/bitops.h+1−0

@@ -13,6 +13,7 @@ · 12 unmodified lines
13		13
14	#define BITS_PER_TYPE(type) (sizeof(type) * BITS_PER_BYTE)	14	#define BITS_PER_TYPE(type) (sizeof(type) * BITS_PER_BYTE)
15	#define BITS_TO_LONGS(nr) DIV_ROUND_UP(nr, BITS_PER_TYPE(long))	15	#define BITS_TO_LONGS(nr) DIV_ROUND_UP(nr, BITS_PER_TYPE(long))
		16	#define BITS_TO_BYTES(nr) DIV_ROUND_UP(nr, BITS_PER_TYPE(char))
16		17
17	extern unsigned int __sw_hweight8(unsigned int w);	18	extern unsigned int __sw_hweight8(unsigned int w);
18	extern unsigned int __sw_hweight16(unsigned int w);	19	extern unsigned int __sw_hweight16(unsigned int w);

include/linux/fs.h+5−1

 extern bool filemap_range_has_page(struct address_space *, loff_t lstart,
 				  loff_t lend);
-extern int filemap_write_and_wait(struct address_space *mapping);
 extern int filemap_write_and_wait_range(struct address_space *mapping,
 				        loff_t lstart, loff_t lend);
 extern int __filemap_fdatawrite_range(struct address_space *mapping,
 extern int filemap_check_errors(struct address_space *mapping);
 extern void __filemap_set_wb_err(struct address_space *mapping, int err);
+static inline int filemap_write_and_wait(struct address_space *mapping)
+{
+	return filemap_write_and_wait_range(mapping, 0, LLONG_MAX);
+}
 extern int __must_check file_fdatawait_range(struct file *file, loff_t lstart,
 						loff_t lend);
 extern int __must_check file_check_and_advance_wb_err(struct file *file);

include/linux/io-mapping.h+2−3

 #ifdef CONFIG_HAVE_ATOMIC_IOMAP
+#include <linux/pfn.h>
 #include <asm/iomap.h>
 /*
  * For small address space machines, mapping large objects
 			 unsigned long offset)
 {
 	resource_size_t phys_addr;
-	unsigned long pfn;
 	BUG_ON(offset >= mapping->size);
 	phys_addr = mapping->base + offset;
-	pfn = (unsigned long) (phys_addr >> PAGE_SHIFT);
+	return iomap_atomic_prot_pfn(PHYS_PFN(phys_addr), mapping->prot);
-	return iomap_atomic_prot_pfn(pfn, mapping->prot);
 }
 static inline void

include/linux/memblock.h+3−4

 int memblock_remove(phys_addr_t base, phys_addr_t size);
 int memblock_free(phys_addr_t base, phys_addr_t size);
 int memblock_reserve(phys_addr_t base, phys_addr_t size);
+#ifdef CONFIG_HAVE_MEMBLOCK_PHYS_MAP
+int memblock_physmem_add(phys_addr_t base, phys_addr_t size);
+#endif
 void memblock_trim_memory(phys_addr_t align);
 bool memblock_overlaps_region(struct memblock_type *type,
 			      phys_addr_t base, phys_addr_t size);
 void reset_all_zones_managed_pages(void);
 /* Low level functions */
-int memblock_add_range(struct memblock_type *type,
-		       phys_addr_t base, phys_addr_t size,
-		       int nid, enum memblock_flags flags);
 void __next_mem_range(u64 *idx, int nid, enum memblock_flags flags,
 		      struct memblock_type *type_a,
 		      struct memblock_type *type_b, phys_addr_t *out_start,

include/linux/memory.h+0−29

@@ -29,8 +29,6 @@ struct memory_block { · 28 unmodified lines
29	int section_count; /* serialized by mem_sysfs_mutex */	29	int section_count; /* serialized by mem_sysfs_mutex */
30	int online_type; /* for passing data to online routine */	30	int online_type; /* for passing data to online routine */
31	int phys_device; /* to which fru does this belong? */	31	int phys_device; /* to which fru does this belong? */
32	void hw; / optional pointer to fw/hw data */
33	int (phys_callback)(struct memory_block );
34	struct device dev;	32	struct device dev;
35	int nid; /* NID for this memory block */	33	int nid; /* NID for this memory block */
36	};	34	};
@@ -55,19 +53,6 @@ struct memory_notify { · 18 unmodified lines
55	int status_change_nid;	53	int status_change_nid;
56	};	54	};
57		55
58	/*
59	* During pageblock isolation, count the number of pages within the
60	* range [start_pfn, start_pfn + nr_pages) which are owned by code
61	* in the notifier chain.
62	*/
63	#define MEM_ISOLATE_COUNT (1<<0)
64
65	struct memory_isolate_notify {
66	unsigned long start_pfn; /* Start of range to check */
67	unsigned int nr_pages; /* # pages in range to check */
68	unsigned int pages_found; /* # pages owned found by callbacks */
69	};
70
71	struct notifier_block;	56	struct notifier_block;
72	struct mem_section;	57	struct mem_section;
73		58
@@ -94,27 +79,13 @@ static inline int memory_notify(unsigned long val, void *v) · 20 unmodified lines
94	{	79	{
95	return 0;	80	return 0;
96	}	81	}
97	static inline int register_memory_isolate_notifier(struct notifier_block *nb)
98	{
99	return 0;
100	}
101	static inline void unregister_memory_isolate_notifier(struct notifier_block *nb)
102	{
103	}
104	static inline int memory_isolate_notify(unsigned long val, void *v)
105	{
106	return 0;
107	}
108	#else	82	#else
109	extern int register_memory_notifier(struct notifier_block *nb);	83	extern int register_memory_notifier(struct notifier_block *nb);
110	extern void unregister_memory_notifier(struct notifier_block *nb);	84	extern void unregister_memory_notifier(struct notifier_block *nb);
111	extern int register_memory_isolate_notifier(struct notifier_block *nb);
112	extern void unregister_memory_isolate_notifier(struct notifier_block *nb);
113	int create_memory_block_devices(unsigned long start, unsigned long size);	85	int create_memory_block_devices(unsigned long start, unsigned long size);
114	void remove_memory_block_devices(unsigned long start, unsigned long size);	86	void remove_memory_block_devices(unsigned long start, unsigned long size);
115	extern void memory_dev_init(void);	87	extern void memory_dev_init(void);
116	extern int memory_notify(unsigned long val, void *v);	88	extern int memory_notify(unsigned long val, void *v);
117	extern int memory_isolate_notify(unsigned long val, void *v);
118	extern struct memory_block find_memory_block(struct mem_section );	89	extern struct memory_block find_memory_block(struct mem_section );
119	typedef int (walk_memory_blocks_func_t)(struct memory_block , void *);	90	typedef int (walk_memory_blocks_func_t)(struct memory_block , void *);
120	extern int walk_memory_blocks(unsigned long start, unsigned long size,	91	extern int walk_memory_blocks(unsigned long start, unsigned long size,

include/linux/memory_hotplug.h+2−1

 extern int zone_grow_waitqueues(struct zone *zone, unsigned long nr_pages);
 extern int add_one_highpage(struct page *page, int pfn, int bad_ppro);
 /* VM interface that may be used by firmware interface */
-extern int online_pages(unsigned long, unsigned long, int);
+extern int online_pages(unsigned long pfn, unsigned long nr_pages,
+			int online_type, int nid);
 extern int test_pages_in_a_zone(unsigned long start_pfn, unsigned long end_pfn,
 	unsigned long *valid_start, unsigned long *valid_end);
 extern unsigned long __offline_isolated_pages(unsigned long start_pfn,

include/linux/mm.h+70−34

@@ -70,11 +70,6 @@ static inline void totalram_pages_add(long count) · 69 unmodified lines
70	atomic_long_add(count, &_totalram_pages);	70	atomic_long_add(count, &_totalram_pages);
71	}	71	}
72		72
73	static inline void totalram_pages_set(long val)
74	{
75	atomic_long_set(&_totalram_pages, val);
76	}
77
78	extern void * high_memory;	73	extern void * high_memory;
79	extern int page_cluster;	74	extern int page_cluster;
80		75
@@ -916,10 +911,6 @@ vm_fault_t finish_mkwrite_fault(struct vm_fault *vmf); · 835 unmodified lines
916		911
917	#define ZONEID_PGSHIFT (ZONEID_PGOFF * (ZONEID_SHIFT != 0))	912	#define ZONEID_PGSHIFT (ZONEID_PGOFF * (ZONEID_SHIFT != 0))
918		913
919	#if SECTIONS_WIDTH+NODES_WIDTH+ZONES_WIDTH > BITS_PER_LONG - NR_PAGEFLAGS
920	#error SECTIONS_WIDTH+NODES_WIDTH+ZONES_WIDTH > BITS_PER_LONG - NR_PAGEFLAGS
921	#endif
922
923	#define ZONES_MASK ((1UL << ZONES_WIDTH) - 1)	914	#define ZONES_MASK ((1UL << ZONES_WIDTH) - 1)
924	#define NODES_MASK ((1UL << NODES_WIDTH) - 1)	915	#define NODES_MASK ((1UL << NODES_WIDTH) - 1)
925	#define SECTIONS_MASK ((1UL << SECTIONS_WIDTH) - 1)	916	#define SECTIONS_MASK ((1UL << SECTIONS_WIDTH) - 1)
@@ -947,9 +938,10 @@ static inline bool is_zone_device_page(const struct page *page) · 21 unmodified lines
947	#endif	938	#endif
948		939
949	#ifdef CONFIG_DEV_PAGEMAP_OPS	940	#ifdef CONFIG_DEV_PAGEMAP_OPS
950	void __put_devmap_managed_page(struct page *page);	941	void free_devmap_managed_page(struct page *page);
951	DECLARE_STATIC_KEY_FALSE(devmap_managed_key);	942	DECLARE_STATIC_KEY_FALSE(devmap_managed_key);
952	static inline bool put_devmap_managed_page(struct page *page)	943
		944	static inline bool page_is_devmap_managed(struct page *page)
953	{	945	{
954	if (!static_branch_unlikely(&devmap_managed_key))	946	if (!static_branch_unlikely(&devmap_managed_key))
955	return false;	947	return false;
@@ -958,7 +950,6 @@ static inline bool put_devmap_managed_page(struct page *page) · 2 unmodified lines
958	switch (page->pgmap->type) {	950	switch (page->pgmap->type) {
959	case MEMORY_DEVICE_PRIVATE:	951	case MEMORY_DEVICE_PRIVATE:
960	case MEMORY_DEVICE_FS_DAX:	952	case MEMORY_DEVICE_FS_DAX:
961	__put_devmap_managed_page(page);
962	return true;	953	return true;
963	default:	954	default:
964	break;	955	break;
@@ -966,11 +957,17 @@ static inline bool put_devmap_managed_page(struct page *page) · 1 unmodified line
966	return false;	957	return false;
967	}	958	}
968		959
		960	void put_devmap_managed_page(struct page *page);
		961
969	#else /* CONFIG_DEV_PAGEMAP_OPS */	962	#else /* CONFIG_DEV_PAGEMAP_OPS */
970	static inline bool put_devmap_managed_page(struct page *page)	963	static inline bool page_is_devmap_managed(struct page *page)
971	{	964	{
972	return false;	965	return false;
973	}	966	}
		967
		968	static inline void put_devmap_managed_page(struct page *page)
		969	{
		970	}
974	#endif /* CONFIG_DEV_PAGEMAP_OPS */	971	#endif /* CONFIG_DEV_PAGEMAP_OPS */
975		972
976	static inline bool is_device_private_page(const struct page *page)	973	static inline bool is_device_private_page(const struct page *page)
@@ -1023,37 +1020,37 @@ static inline void put_page(struct page *page) · 46 unmodified lines
1023	* need to inform the device driver through callback. See	1020	* need to inform the device driver through callback. See
1024	* include/linux/memremap.h and HMM for details.	1021	* include/linux/memremap.h and HMM for details.
1025	*/	1022	*/
1026	if (put_devmap_managed_page(page))	1023	if (page_is_devmap_managed(page)) {
		1024	put_devmap_managed_page(page);
1027	return;	1025	return;
		1026	}
1028		1027
1029	if (put_page_testzero(page))	1028	if (put_page_testzero(page))
1030	__put_page(page);	1029	__put_page(page);
1031	}	1030	}
1032		1031
1033	/**	1032	/**
1034	* put_user_page() - release a gup-pinned page	1033	* unpin_user_page() - release a gup-pinned page
1035	* @page: pointer to page to be released	1034	* @page: pointer to page to be released
1036	*	1035	*
1037	* Pages that were pinned via get_user_pages*() must be released via	1036	* Pages that were pinned via pin_user_pages*() must be released via either
1038	* either put_user_page(), or one of the put_user_pages*() routines	1037	* unpin_user_page(), or one of the unpin_user_pages*() routines. This is so
1039	* below. This is so that eventually, pages that are pinned via	1038	* that eventually such pages can be separately tracked and uniquely handled. In
1040	* get_user_pages*() can be separately tracked and uniquely handled. In	1039	* particular, interactions with RDMA and filesystems need special handling.
1041	* particular, interactions with RDMA and filesystems need special
1042	* handling.
1043	*	1040	*
1044	* put_user_page() and put_page() are not interchangeable, despite this early	1041	* unpin_user_page() and put_page() are not interchangeable, despite this early
1045	* implementation that makes them look the same. put_user_page() calls must	1042	* implementation that makes them look the same. unpin_user_page() calls must
1046	* be perfectly matched up with get_user_page() calls.	1043	* be perfectly matched up with pin*() calls.
1047	*/	1044	*/
1048	static inline void put_user_page(struct page *page)	1045	static inline void unpin_user_page(struct page *page)
1049	{	1046	{
1050	put_page(page);	1047	put_page(page);
1051	}	1048	}
1052		1049
1053	void put_user_pages_dirty_lock(struct page **pages, unsigned long npages,	1050	void unpin_user_pages_dirty_lock(struct page **pages, unsigned long npages,
1054	bool make_dirty);	1051	bool make_dirty);
1055		1052
1056	void put_user_pages(struct page **pages, unsigned long npages);	1053	void unpin_user_pages(struct page **pages, unsigned long npages);
1057		1054
1058	#if defined(CONFIG_SPARSEMEM) && !defined(CONFIG_SPARSEMEM_VMEMMAP)	1055	#if defined(CONFIG_SPARSEMEM) && !defined(CONFIG_SPARSEMEM_VMEMMAP)
1059	#define SECTION_IN_PAGE_FLAGS	1056	#define SECTION_IN_PAGE_FLAGS
@@ -1501,9 +1498,16 @@ long get_user_pages_remote(struct task_struct tsk, struct mm_struct mm, · 441 unmodified lines
1501	unsigned long start, unsigned long nr_pages,	1498	unsigned long start, unsigned long nr_pages,
1502	unsigned int gup_flags, struct page **pages,	1499	unsigned int gup_flags, struct page **pages,
1503	struct vm_area_struct *vmas, int locked);	1500	struct vm_area_struct *vmas, int locked);
		1501	long pin_user_pages_remote(struct task_struct tsk, struct mm_struct mm,
		1502	unsigned long start, unsigned long nr_pages,
		1503	unsigned int gup_flags, struct page **pages,
		1504	struct vm_area_struct *vmas, int locked);
1504	long get_user_pages(unsigned long start, unsigned long nr_pages,	1505	long get_user_pages(unsigned long start, unsigned long nr_pages,
1505	unsigned int gup_flags, struct page **pages,	1506	unsigned int gup_flags, struct page **pages,
1506	struct vm_area_struct **vmas);	1507	struct vm_area_struct **vmas);
		1508	long pin_user_pages(unsigned long start, unsigned long nr_pages,
		1509	unsigned int gup_flags, struct page **pages,
		1510	struct vm_area_struct **vmas);
1507	long get_user_pages_locked(unsigned long start, unsigned long nr_pages,	1511	long get_user_pages_locked(unsigned long start, unsigned long nr_pages,
1508	unsigned int gup_flags, struct page *pages, int locked);	1512	unsigned int gup_flags, struct page *pages, int locked);
1509	long get_user_pages_unlocked(unsigned long start, unsigned long nr_pages,	1513	long get_user_pages_unlocked(unsigned long start, unsigned long nr_pages,
@@ -1511,6 +1515,8 @@ long get_user_pages_unlocked(unsigned long start, unsigned long nr_pages, · 1 unmodified line
1511		1515
1512	int get_user_pages_fast(unsigned long start, int nr_pages,	1516	int get_user_pages_fast(unsigned long start, int nr_pages,
1513	unsigned int gup_flags, struct page **pages);	1517	unsigned int gup_flags, struct page **pages);
		1518	int pin_user_pages_fast(unsigned long start, int nr_pages,
		1519	unsigned int gup_flags, struct page **pages);
1514		1520
1515	int account_locked_vm(struct mm_struct *mm, unsigned long pages, bool inc);	1521	int account_locked_vm(struct mm_struct *mm, unsigned long pages, bool inc);
1516	int __account_locked_vm(struct mm_struct *mm, unsigned long pages, bool inc,	1522	int __account_locked_vm(struct mm_struct *mm, unsigned long pages, bool inc,
@@ -2575,13 +2581,15 @@ struct page follow_page(struct vm_area_struct vma, unsigned long address, · 1058 unmodified lines
2575	#define FOLL_ANON 0x8000 /* don't do file mappings */	2581	#define FOLL_ANON 0x8000 /* don't do file mappings */
2576	#define FOLL_LONGTERM 0x10000 /* mapping lifetime is indefinite: see below */	2582	#define FOLL_LONGTERM 0x10000 /* mapping lifetime is indefinite: see below */
2577	#define FOLL_SPLIT_PMD 0x20000 /* split huge pmd before returning */	2583	#define FOLL_SPLIT_PMD 0x20000 /* split huge pmd before returning */
		2584	#define FOLL_PIN 0x40000 /* pages must be released via unpin_user_page */
2578		2585
2579	/*	2586	/*
2580	* NOTE on FOLL_LONGTERM:	2587	* FOLL_PIN and FOLL_LONGTERM may be used in various combinations with each
		2588	* other. Here is what they mean, and how to use them:
2581	*	2589	*
2582	* FOLL_LONGTERM indicates that the page will be held for an indefinite time	2590	* FOLL_LONGTERM indicates that the page will be held for an indefinite time
2583	* period _often_ under userspace control. This is contrasted with	2591	* period _often_ under userspace control. This is in contrast to
2584	* iov_iter_get_pages() where usages which are transient.	2592	* iov_iter_get_pages(), whose usages are transient.
2585	*	2593	*
2586	* FIXME: For pages which are part of a filesystem, mappings are subject to the	2594	* FIXME: For pages which are part of a filesystem, mappings are subject to the
2587	* lifetime enforced by the filesystem and we need guarantees that longterm	2595	* lifetime enforced by the filesystem and we need guarantees that longterm
@@ -2596,11 +2604,39 @@ struct page follow_page(struct vm_area_struct vma, unsigned long address, · 8 unmodified lines
2596	* Currently only get_user_pages() and get_user_pages_fast() support this flag	2604	* Currently only get_user_pages() and get_user_pages_fast() support this flag
2597	* and calls to get_user_pages_[un]locked are specifically not allowed. This	2605	* and calls to get_user_pages_[un]locked are specifically not allowed. This
2598	* is due to an incompatibility with the FS DAX check and	2606	* is due to an incompatibility with the FS DAX check and
2599	* FAULT_FLAG_ALLOW_RETRY	2607	* FAULT_FLAG_ALLOW_RETRY.
2600	*	2608	*
2601	* In the CMA case: longterm pins in a CMA region would unnecessarily fragment	2609	* In the CMA case: long term pins in a CMA region would unnecessarily fragment
2602	* that region. And so CMA attempts to migrate the page before pinning when	2610	* that region. And so, CMA attempts to migrate the page before pinning, when
2603	* FOLL_LONGTERM is specified.	2611	* FOLL_LONGTERM is specified.
		2612	*
		2613	* FOLL_PIN indicates that a special kind of tracking (not just page->_refcount,
		2614	* but an additional pin counting system) will be invoked. This is intended for
		2615	* anything that gets a page reference and then touches page data (for example,
		2616	* Direct IO). This lets the filesystem know that some non-file-system entity is
		2617	* potentially changing the pages' data. In contrast to FOLL_GET (whose pages
		2618	* are released via put_page()), FOLL_PIN pages must be released, ultimately, by
		2619	* a call to unpin_user_page().
		2620	*
		2621	* FOLL_PIN is similar to FOLL_GET: both of these pin pages. They use different
		2622	* and separate refcounting mechanisms, however, and that means that each has
		2623	* its own acquire and release mechanisms:
		2624	*
		2625	* FOLL_GET: get_user_pages*() to acquire, and put_page() to release.
		2626	*
		2627	* FOLL_PIN: pin_user_pages*() to acquire, and unpin_user_pages to release.
		2628	*
		2629	* FOLL_PIN and FOLL_GET are mutually exclusive for a given function call.
		2630	* (The underlying pages may experience both FOLL_GET-based and FOLL_PIN-based
		2631	* calls applied to them, and that's perfectly OK. This is a constraint on the
		2632	* callers, not on the pages.)
		2633	*
		2634	* FOLL_PIN should be set internally by the pin_user_pages*() APIs, never
		2635	* directly by the caller. That's in order to help avoid mismatches when
		2636	* releasing pages: get_user_pages*() pages must be released via put_page(),
		2637	* while pin_user_pages*() pages must be released via unpin_user_page().
		2638	*
		2639	* Please see Documentation/vm/pin_user_pages.rst for more information.
2604	*/	2640	*/
2605		2641
2606	static inline int vm_fault_to_errno(vm_fault_t vm_fault, int foll_flags)	2642	static inline int vm_fault_to_errno(vm_fault_t vm_fault, int foll_flags)

include/linux/mmzone.h+1−1

@@ -758,7 +758,7 @@ typedef struct pglist_data { · 757 unmodified lines
758		758
759	#ifdef CONFIG_NUMA	759	#ifdef CONFIG_NUMA
760	/*	760	/*
761	* zone reclaim becomes active if more unmapped pages exist.	761	* node reclaim becomes active if more unmapped pages exist.
762	*/	762	*/
763	unsigned long min_unmapped_pages;	763	unsigned long min_unmapped_pages;
764	unsigned long min_slab_pages;	764	unsigned long min_slab_pages;

include/linux/page-isolation.h+2−2

@@ -33,8 +33,8 @@ static inline bool is_migrate_isolate(int migratetype) · 32 unmodified lines
33	#define MEMORY_OFFLINE 0x1	33	#define MEMORY_OFFLINE 0x1
34	#define REPORT_FAILURE 0x2	34	#define REPORT_FAILURE 0x2
35		35
36	bool has_unmovable_pages(struct zone zone, struct page page, int count,	36	struct page has_unmovable_pages(struct zone zone, struct page *page,
37	int migratetype, int flags);	37	int migratetype, int flags);
38	void set_pageblock_migratetype(struct page *page, int migratetype);	38	void set_pageblock_migratetype(struct page *page, int migratetype);
39	int move_freepages_block(struct zone zone, struct page page,	39	int move_freepages_block(struct zone zone, struct page page,
40	int migratetype, int *num_movable);	40	int migratetype, int *num_movable);

include/linux/swab.h+1−0

@@ -7,6 +7,7 @@ · 6 unmodified lines
7	# define swab16 __swab16	7	# define swab16 __swab16
8	# define swab32 __swab32	8	# define swab32 __swab32
9	# define swab64 __swab64	9	# define swab64 __swab64
		10	# define swab __swab
10	# define swahw32 __swahw32	11	# define swahw32 __swahw32
11	# define swahb32 __swahb32	12	# define swahb32 __swahb32
12	# define swab16p __swab16p	13	# define swab16p __swab16p

include/linux/thermal.h+0−11

@@ -32,17 +32,6 @@ · 31 unmodified lines
32	/* use value, which < 0K, to indicate an invalid/uninitialized temperature */	32	/* use value, which < 0K, to indicate an invalid/uninitialized temperature */
33	#define THERMAL_TEMP_INVALID -274000	33	#define THERMAL_TEMP_INVALID -274000
34		34
35	/* Unit conversion macros */
36	#define DECI_KELVIN_TO_CELSIUS(t) ({ \
37	long _t = (t); \
38	((_t-2732 >= 0) ? (_t-2732+5)/10 : (_t-2732-5)/10); \
39	})
40	#define CELSIUS_TO_DECI_KELVIN(t) ((t)*10+2732)
41	#define DECI_KELVIN_TO_MILLICELSIUS_WITH_OFFSET(t, off) (((t) - (off)) * 100)
42	#define DECI_KELVIN_TO_MILLICELSIUS(t) DECI_KELVIN_TO_MILLICELSIUS_WITH_OFFSET(t, 2732)
43	#define MILLICELSIUS_TO_DECI_KELVIN_WITH_OFFSET(t, off) (((t) / 100) + (off))
44	#define MILLICELSIUS_TO_DECI_KELVIN(t) MILLICELSIUS_TO_DECI_KELVIN_WITH_OFFSET(t, 2732)
45
46	/* Default Thermal Governor */	35	/* Default Thermal Governor */
47	#if defined(CONFIG_THERMAL_DEFAULT_GOV_STEP_WISE)	36	#if defined(CONFIG_THERMAL_DEFAULT_GOV_STEP_WISE)
48	#define DEFAULT_THERMAL_GOVERNOR "step_wise"	37	#define DEFAULT_THERMAL_GOVERNOR "step_wise"

include/linux/units.h+84−0

@@ -0,0 +1,84 @@
	1	/* SPDX-License-Identifier: GPL-2.0 */
	2	#ifndef _LINUX_UNITS_H
	3	#define _LINUX_UNITS_H
	4
	5	#include <linux/kernel.h>
	6
	7	#define ABSOLUTE_ZERO_MILLICELSIUS -273150
	8
	9	static inline long milli_kelvin_to_millicelsius(long t)
	10	{
	11	return t + ABSOLUTE_ZERO_MILLICELSIUS;
	12	}
	13
	14	static inline long millicelsius_to_milli_kelvin(long t)
	15	{
	16	return t - ABSOLUTE_ZERO_MILLICELSIUS;
	17	}
	18
	19	#define MILLIDEGREE_PER_DEGREE 1000
	20	#define MILLIDEGREE_PER_DECIDEGREE 100
	21
	22	static inline long kelvin_to_millicelsius(long t)
	23	{
	24	return milli_kelvin_to_millicelsius(t * MILLIDEGREE_PER_DEGREE);
	25	}
	26
	27	static inline long millicelsius_to_kelvin(long t)
	28	{
	29	t = millicelsius_to_milli_kelvin(t);
	30
	31	return DIV_ROUND_CLOSEST(t, MILLIDEGREE_PER_DEGREE);
	32	}
	33
	34	static inline long deci_kelvin_to_celsius(long t)
	35	{
	36	t = milli_kelvin_to_millicelsius(t * MILLIDEGREE_PER_DECIDEGREE);
	37
	38	return DIV_ROUND_CLOSEST(t, MILLIDEGREE_PER_DEGREE);
	39	}
	40
	41	static inline long celsius_to_deci_kelvin(long t)
	42	{
	43	t = millicelsius_to_milli_kelvin(t * MILLIDEGREE_PER_DEGREE);
	44
	45	return DIV_ROUND_CLOSEST(t, MILLIDEGREE_PER_DECIDEGREE);
	46	}
	47
	48	/**
	49	* deci_kelvin_to_millicelsius_with_offset - convert Kelvin to Celsius
	50	* @t: temperature value in decidegrees Kelvin
	51	* @offset: difference between Kelvin and Celsius in millidegrees
	52	*
	53	* Return: temperature value in millidegrees Celsius
	54	*/
	55	static inline long deci_kelvin_to_millicelsius_with_offset(long t, long offset)
	56	{
	57	return t * MILLIDEGREE_PER_DECIDEGREE - offset;
	58	}
	59
	60	static inline long deci_kelvin_to_millicelsius(long t)
	61	{
	62	return milli_kelvin_to_millicelsius(t * MILLIDEGREE_PER_DECIDEGREE);
	63	}
	64
	65	static inline long millicelsius_to_deci_kelvin(long t)
	66	{
	67	t = millicelsius_to_milli_kelvin(t);
	68
	69	return DIV_ROUND_CLOSEST(t, MILLIDEGREE_PER_DECIDEGREE);
	70	}
	71
	72	static inline long kelvin_to_celsius(long t)
	73	{
	74	return t + DIV_ROUND_CLOSEST(ABSOLUTE_ZERO_MILLICELSIUS,
	75	MILLIDEGREE_PER_DEGREE);
	76	}
	77
	78	static inline long celsius_to_kelvin(long t)
	79	{
	80	return t - DIV_ROUND_CLOSEST(ABSOLUTE_ZERO_MILLICELSIUS,
	81	MILLIDEGREE_PER_DEGREE);
	82	}
	83
	84	#endif /* _LINUX_UNITS_H */

include/linux/zlib.h+6−0

    exceed those passed here.
 */
+extern int zlib_deflate_dfltcc_enabled (void);
+/*
+   Returns 1 if Deflate-Conversion facility is installed and enabled,
+   otherwise 0.
+*/
 /*
 extern int deflateInit (z_streamp strm, int level);

include/trace/events/kmem.h+2−2

@@ -88,8 +88,8 @@ DECLARE_EVENT_CLASS(kmem_alloc_node, · 87 unmodified lines
88	__entry->node = node;	88	__entry->node = node;
89	),	89	),
90		90
91	TP_printk("call_site=%lx ptr=%p bytes_req=%zu bytes_alloc=%zu gfp_flags=%s node=%d",	91	TP_printk("call_site=%pS ptr=%p bytes_req=%zu bytes_alloc=%zu gfp_flags=%s node=%d",
92	__entry->call_site,	92	(void *)__entry->call_site,
93	__entry->ptr,	93	__entry->ptr,
94	__entry->bytes_req,	94	__entry->bytes_req,
95	__entry->bytes_alloc,	95	__entry->bytes_alloc,

include/trace/events/writeback.h+17−20

 	TP_fast_assign(
 		strscpy_pad(__entry->name,
-			    mapping ? dev_name(inode_to_bdi(mapping->host)->dev) : "(unknown)",
+			    bdi_dev_name(mapping ? inode_to_bdi(mapping->host) :
-			    32);
+					 NULL), 32);
 		__entry->ino = mapping ? mapping->host->i_ino : 0;
 		__entry->index = page->index;
 	),
 		struct backing_dev_info *bdi = inode_to_bdi(inode);
 		/* may be called for files on pseudo FSes w/ unregistered bdi */
-		strscpy_pad(__entry->name,
+		strscpy_pad(__entry->name, bdi_dev_name(bdi), 32);
-			    bdi->dev ? dev_name(bdi->dev) : "(unknown)", 32);
 		__entry->ino		= inode->i_ino;
 		__entry->state		= inode->i_state;
 		__entry->flags		= flags;
 	),
 	TP_fast_assign(
-		strncpy(__entry->name, dev_name(inode_to_bdi(inode)->dev), 32);
+		strncpy(__entry->name, bdi_dev_name(inode_to_bdi(inode)), 32);
 		__entry->ino		= inode->i_ino;
 		__entry->cgroup_ino	= __trace_wbc_assign_cgroup(wbc);
 		__entry->history	= history;
 	),
 	TP_fast_assign(
-		strncpy(__entry->name,	dev_name(old_wb->bdi->dev), 32);
+		strncpy(__entry->name,	bdi_dev_name(old_wb->bdi), 32);
 		__entry->ino		= inode->i_ino;
 		__entry->old_cgroup_ino	= __trace_wb_assign_cgroup(old_wb);
 		__entry->new_cgroup_ino	= __trace_wb_assign_cgroup(new_wb);
 		struct address_space *mapping = page_mapping(page);
 		struct inode *inode = mapping ? mapping->host : NULL;
-		strncpy(__entry->name,	dev_name(wb->bdi->dev), 32);
+		strncpy(__entry->name,	bdi_dev_name(wb->bdi), 32);
 		__entry->bdi_id		= wb->bdi->id;
 		__entry->ino		= inode ? inode->i_ino : 0;
 		__entry->memcg_id	= wb->memcg_css->id;
 	),
 	TP_fast_assign(
-		strncpy(__entry->name,	dev_name(wb->bdi->dev), 32);
+		strncpy(__entry->name,	bdi_dev_name(wb->bdi), 32);
 		__entry->cgroup_ino	= __trace_wb_assign_cgroup(wb);
 		__entry->frn_bdi_id	= frn_bdi_id;
 		__entry->frn_memcg_id	= frn_memcg_id;
 	TP_fast_assign(
 		strscpy_pad(__entry->name,
-			    dev_name(inode_to_bdi(inode)->dev), 32);
+			    bdi_dev_name(inode_to_bdi(inode)), 32);
 		__entry->ino		= inode->i_ino;
 		__entry->sync_mode	= wbc->sync_mode;
 		__entry->cgroup_ino	= __trace_wbc_assign_cgroup(wbc);
 		__field(ino_t, cgroup_ino)
 	),
 	TP_fast_assign(
-		strscpy_pad(__entry->name,
+		strscpy_pad(__entry->name, bdi_dev_name(wb->bdi), 32);
-			    wb->bdi->dev ? dev_name(wb->bdi->dev) :
-			    "(unknown)", 32);
 		__entry->nr_pages = work->nr_pages;
 		__entry->sb_dev = work->sb ? work->sb->s_dev : 0;
 		__entry->sync_mode = work->sync_mode;
 		__field(ino_t, cgroup_ino)
 	),
 	TP_fast_assign(
-		strscpy_pad(__entry->name, dev_name(wb->bdi->dev), 32);
+		strscpy_pad(__entry->name, bdi_dev_name(wb->bdi), 32);
 		__entry->cgroup_ino = __trace_wb_assign_cgroup(wb);
 	),
 	TP_printk("bdi %s: cgroup_ino=%lu",
 		__array(char, name, 32)
 	),
 	TP_fast_assign(
-		strscpy_pad(__entry->name, dev_name(bdi->dev), 32);
+		strscpy_pad(__entry->name, bdi_dev_name(bdi), 32);
 	),
 	TP_printk("bdi %s",
 		__entry->name
 	),
 	TP_fast_assign(
-		strscpy_pad(__entry->name, dev_name(bdi->dev), 32);
+		strscpy_pad(__entry->name, bdi_dev_name(bdi), 32);
 		__entry->nr_to_write	= wbc->nr_to_write;
 		__entry->pages_skipped	= wbc->pages_skipped;
 		__entry->sync_mode	= wbc->sync_mode;
 	),
 	TP_fast_assign(
 		unsigned long *older_than_this = work->older_than_this;
-		strscpy_pad(__entry->name, dev_name(wb->bdi->dev), 32);
+		strscpy_pad(__entry->name, bdi_dev_name(wb->bdi), 32);
 		__entry->older	= older_than_this ?  *older_than_this : 0;
 		__entry->age	= older_than_this ?
 				  (jiffies - *older_than_this) * 1000 / HZ : -1;
 	),
 	TP_fast_assign(
-		strscpy_pad(__entry->bdi, dev_name(wb->bdi->dev), 32);
+		strscpy_pad(__entry->bdi, bdi_dev_name(wb->bdi), 32);
 		__entry->write_bw	= KBps(wb->write_bandwidth);
 		__entry->avg_write_bw	= KBps(wb->avg_write_bandwidth);
 		__entry->dirty_rate	= KBps(dirty_rate);
 	TP_fast_assign(
 		unsigned long freerun = (thresh + bg_thresh) / 2;
-		strscpy_pad(__entry->bdi, dev_name(wb->bdi->dev), 32);
+		strscpy_pad(__entry->bdi, bdi_dev_name(wb->bdi), 32);
 		__entry->limit		= global_wb_domain.dirty_limit;
 		__entry->setpoint	= (global_wb_domain.dirty_limit +
 	TP_fast_assign(
 		strscpy_pad(__entry->name,
-			    dev_name(inode_to_bdi(inode)->dev), 32);
+			    bdi_dev_name(inode_to_bdi(inode)), 32);
 		__entry->ino		= inode->i_ino;
 		__entry->state		= inode->i_state;
 		__entry->dirtied_when	= inode->dirtied_when;
 	TP_fast_assign(
 		strscpy_pad(__entry->name,
-			    dev_name(inode_to_bdi(inode)->dev), 32);
+			    bdi_dev_name(inode_to_bdi(inode)), 32);
 		__entry->ino		= inode->i_ino;
 		__entry->state		= inode->i_state;
 		__entry->dirtied_when	= inode->dirtied_when;

include/uapi/linux/swab.h+10−0

 #include <linux/types.h>
 #include <linux/compiler.h>
+#include <asm/bitsperlong.h>
 #include <asm/swab.h>
 /*
 	__fswab64(x))
 #endif
+static __always_inline unsigned long __swab(const unsigned long y)
+{
+#if BITS_PER_LONG == 64
+	return __swab64(y);
+#else /* BITS_PER_LONG == 32 */
+	return __swab32(y);
+#endif
+}
 /**
  * __swahw32 - return a word-swapped 32-bit value
  * @x: value to wordswap

include/uapi/linux/sysctl.h+1−1

@@ -195,7 +195,7 @@ enum · 194 unmodified lines
195	VM_MIN_UNMAPPED=32, /* Set min percent of unmapped pages */	195	VM_MIN_UNMAPPED=32, /* Set min percent of unmapped pages */
196	VM_PANIC_ON_OOM=33, /* panic at out-of-memory */	196	VM_PANIC_ON_OOM=33, /* panic at out-of-memory */
197	VM_VDSO_ENABLED=34, /* map VDSO into new processes? */	197	VM_VDSO_ENABLED=34, /* map VDSO into new processes? */
198	VM_MIN_SLAB=35, /* Percent pages ignored by zone reclaim */	198	VM_MIN_SLAB=35, /* Percent pages ignored by node reclaim */
199	};	199	};
200		200
201		201

init/main.c+27−9

 early_param("loglevel", loglevel);
 /* Change NUL term back to "=", to make "param" the whole string. */
-static int __init repair_env_string(char *param, char *val,
+static void __init repair_env_string(char *param, char *val)
-				    const char *unused, void *arg)
 {
 	if (val) {
 		/* param=val or param="val"? */
 		else if (val == param+strlen(param)+2) {
 			val[-2] = '=';
 			memmove(val-1, val, strlen(val)+1);
-			val--;
 		} else
 			BUG();
 	}
-	return 0;
 }
 /* Anything after -- gets handed straight to init. */
 	if (panic_later)
 		return 0;
-	repair_env_string(param, val, unused, NULL);
+	repair_env_string(param, val);
 	for (i = 0; argv_init[i]; i++) {
 		if (i == MAX_INIT_ARGS) {
 static int __init unknown_bootoption(char *param, char *val,
 				     const char *unused, void *arg)
 {
-	repair_env_string(param, val, unused, NULL);
+	size_t len = strlen(param);
+	repair_env_string(param, val);
 	/* Handle obsolete-style parameters */
 	if (obsolete_checksetup(param))
 		return 0;
 	/* Unused module parameter. */
-	if (strchr(param, '.') && (!val || strchr(param, '.') < val))
+	if (strnchr(param, len, '.'))
 		return 0;
 	if (panic_later)
 				panic_later = "env";
 				panic_param = param;
 			}
-			if (!strncmp(param, envp_init[i], val - param))
+			if (!strncmp(param, envp_init[i], len+1))
 				break;
 		}
 		envp_init[i] = param;
 	"late",
 };
+static int __init ignore_unknown_bootoption(char *param, char *val,
+			       const char *unused, void *arg)
+{
+	return 0;
+}
 static void __init do_initcall_level(int level)
 {
 	initcall_entry_t *fn;
 		   initcall_command_line, __start___param,
 		   __stop___param - __start___param,
 		   level, level,
-		   NULL, &repair_env_string);
+		   NULL, ignore_unknown_bootoption);
 	trace_initcall_level(initcall_level_names[level]);
 	for (fn = initcall_levels[level]; fn < initcall_levels[level+1]; fn++)
 static int run_init_process(const char *init_filename)
 {
+	const char *const *p;
 	argv_init[0] = init_filename;
 	pr_info("Run %s as init process\n", init_filename);
+	pr_debug("  with arguments:\n");
+	for (p = argv_init; *p; p++)
+		pr_debug("    %s\n", *p);
+	pr_debug("  with environment:\n");
+	for (p = envp_init; *p; p++)
+		pr_debug("    %s\n", *p);
 	return do_execve(getname_kernel(init_filename),
 		(const char __user *const __user *)argv_init,
 		(const char __user *const __user *)envp_init);
 	} else
 		pr_info("Kernel memory protection disabled.\n");
 }
+#elif defined(CONFIG_ARCH_HAS_STRICT_KERNEL_RWX)
+static inline void mark_readonly(void)
+{
+	pr_warn("Kernel memory protection not selected by kernel config.\n");
+}
 #else
 static inline void mark_readonly(void)
 {

kernel/Makefile+1−0

@@ -27,6 +27,7 @@ KCOV_INSTRUMENT_softirq.o := n · 26 unmodified lines
27	# and produce insane amounts of uninteresting coverage.	27	# and produce insane amounts of uninteresting coverage.
28	KCOV_INSTRUMENT_module.o := n	28	KCOV_INSTRUMENT_module.o := n
29	KCOV_INSTRUMENT_extable.o := n	29	KCOV_INSTRUMENT_extable.o := n
		30	KCOV_INSTRUMENT_stacktrace.o := n
30	# Don't self-instrument.	31	# Don't self-instrument.
31	KCOV_INSTRUMENT_kcov.o := n	32	KCOV_INSTRUMENT_kcov.o := n
32	KASAN_SANITIZE_kcov.o := n	33	KASAN_SANITIZE_kcov.o := n

lib/Kconfig+7−0

@@ -278,6 +278,13 @@ config ZLIB_DEFLATE · 277 unmodified lines
278	tristate	278	tristate
279	select BITREVERSE	279	select BITREVERSE
280		280
		281	config ZLIB_DFLTCC
		282	def_bool y
		283	depends on S390
		284	prompt "Enable s390x DEFLATE CONVERSION CALL support for kernel zlib"
		285	help
		286	Enable s390x hardware support for zlib in the kernel.
		287
281	config LZO_COMPRESS	288	config LZO_COMPRESS
282	tristate	289	tristate
283		290

lib/Makefile+2−0

 KCOV_INSTRUMENT_list_debug.o := n
 KCOV_INSTRUMENT_debugobjects.o := n
 KCOV_INSTRUMENT_dynamic_debug.o := n
+KCOV_INSTRUMENT_fault-inject.o := n
 # Early boot use of cmdline, don't instrument it
 ifdef CONFIG_AMD_MEM_ENCRYPT
 obj-$(CONFIG_842_DECOMPRESS) += 842/
 obj-$(CONFIG_ZLIB_INFLATE) += zlib_inflate/
 obj-$(CONFIG_ZLIB_DEFLATE) += zlib_deflate/
+obj-$(CONFIG_ZLIB_DFLTCC) += zlib_dfltcc/
 obj-$(CONFIG_REED_SOLOMON) += reed_solomon/
 obj-$(CONFIG_BCH) += bch.o
 obj-$(CONFIG_LZO_COMPRESS) += lzo/

lib/decompress_inflate.c+13−0

 #include "zlib_inflate/inftrees.c"
 #include "zlib_inflate/inffast.c"
 #include "zlib_inflate/inflate.c"
+#ifdef CONFIG_ZLIB_DFLTCC
+#include "zlib_dfltcc/dfltcc.c"
+#include "zlib_dfltcc/dfltcc_inflate.c"
+#endif
 #else /* STATIC */
 /* initramfs et al: linked */
 	}
 	strm->workspace = malloc(flush ? zlib_inflate_workspacesize() :
+#ifdef CONFIG_ZLIB_DFLTCC
+	/* Always allocate the full workspace for DFLTCC */
+				 zlib_inflate_workspacesize());
+#else
 				 sizeof(struct inflate_state));
+#endif
 	if (strm->workspace == NULL) {
 		error("Out of memory while allocating workspace");
 		goto gunzip_nomem4;
 	rc = zlib_inflateInit2(strm, -MAX_WBITS);
+#ifdef CONFIG_ZLIB_DFLTCC
+	/* Always keep the window for DFLTCC */
+#else
 	if (!flush) {
 		WS(strm)->inflate_state.wsize = 0;
 		WS(strm)->inflate_state.window = NULL;
 	}
+#endif
 	while (rc == Z_OK) {
 		if (strm->avail_in == 0) {

lib/find_bit.c+20−58

@@ -17,9 +17,9 @@ · 16 unmodified lines
17	#include <linux/export.h>	17	#include <linux/export.h>
18	#include <linux/kernel.h>	18	#include <linux/kernel.h>
19		19
20	#if !defined(find_next_bit) \|\| !defined(find_next_zero_bit) \|\| \	20	#if !defined(find_next_bit) \|\| !defined(find_next_zero_bit) \|\| \
21	!defined(find_next_and_bit)	21	!defined(find_next_bit_le) \|\| !defined(find_next_zero_bit_le) \|\| \
22		22	!defined(find_next_and_bit)
23	/*	23	/*
24	* This is a common helper function for find_next_bit, find_next_zero_bit, and	24	* This is a common helper function for find_next_bit, find_next_zero_bit, and
25	* find_next_and_bit. The differences are:	25	* find_next_and_bit. The differences are:
@@ -27,11 +27,11 @@ · 1 unmodified line
27	* searching it for one bits.	27	* searching it for one bits.
28	* - The optional "addr2", which is anded with "addr1" if present.	28	* - The optional "addr2", which is anded with "addr1" if present.
29	*/	29	*/
30	static inline unsigned long _find_next_bit(const unsigned long *addr1,	30	static unsigned long _find_next_bit(const unsigned long *addr1,
31	const unsigned long *addr2, unsigned long nbits,	31	const unsigned long *addr2, unsigned long nbits,
32	unsigned long start, unsigned long invert)	32	unsigned long start, unsigned long invert, unsigned long le)
33	{	33	{
34	unsigned long tmp;	34	unsigned long tmp, mask;
35		35
36	if (unlikely(start >= nbits))	36	if (unlikely(start >= nbits))
37	return nbits;	37	return nbits;
@@ -42,7 +42,12 @@ static inline unsigned long _find_next_bit(const unsigned long *addr1, · 4 unmodified lines
42	tmp ^= invert;	42	tmp ^= invert;
43		43
44	/* Handle 1st word. */	44	/* Handle 1st word. */
45	tmp &= BITMAP_FIRST_WORD_MASK(start);	45	mask = BITMAP_FIRST_WORD_MASK(start);
		46	if (le)
		47	mask = swab(mask);
		48
		49	tmp &= mask;
		50
46	start = round_down(start, BITS_PER_LONG);	51	start = round_down(start, BITS_PER_LONG);
47		52
48	while (!tmp) {	53	while (!tmp) {
@@ -56,6 +61,9 @@ static inline unsigned long _find_next_bit(const unsigned long *addr1, · 7 unmodified lines
56	tmp ^= invert;	61	tmp ^= invert;
57	}	62	}
58		63
		64	if (le)
		65	tmp = swab(tmp);
		66
59	return min(start + __ffs(tmp), nbits);	67	return min(start + __ffs(tmp), nbits);
60	}	68	}
61	#endif	69	#endif
@@ -67,7 +75,7 @@ static inline unsigned long _find_next_bit(const unsigned long *addr1, · 5 unmodified lines
67	unsigned long find_next_bit(const unsigned long *addr, unsigned long size,	75	unsigned long find_next_bit(const unsigned long *addr, unsigned long size,
68	unsigned long offset)	76	unsigned long offset)
69	{	77	{
70	return _find_next_bit(addr, NULL, size, offset, 0UL);	78	return _find_next_bit(addr, NULL, size, offset, 0UL, 0);
71	}	79	}
72	EXPORT_SYMBOL(find_next_bit);	80	EXPORT_SYMBOL(find_next_bit);
73	#endif	81	#endif
@@ -76,7 +84,7 @@ EXPORT_SYMBOL(find_next_bit); · 2 unmodified lines
76	unsigned long find_next_zero_bit(const unsigned long *addr, unsigned long size,	84	unsigned long find_next_zero_bit(const unsigned long *addr, unsigned long size,
77	unsigned long offset)	85	unsigned long offset)
78	{	86	{
79	return _find_next_bit(addr, NULL, size, offset, ~0UL);	87	return _find_next_bit(addr, NULL, size, offset, ~0UL, 0);
80	}	88	}
81	EXPORT_SYMBOL(find_next_zero_bit);	89	EXPORT_SYMBOL(find_next_zero_bit);
82	#endif	90	#endif
@@ -86,7 +94,7 @@ unsigned long find_next_and_bit(const unsigned long *addr1, · 3 unmodified lines
86	const unsigned long *addr2, unsigned long size,	94	const unsigned long *addr2, unsigned long size,
87	unsigned long offset)	95	unsigned long offset)
88	{	96	{
89	return _find_next_bit(addr1, addr2, size, offset, 0UL);	97	return _find_next_bit(addr1, addr2, size, offset, 0UL, 0);
90	}	98	}
91	EXPORT_SYMBOL(find_next_and_bit);	99	EXPORT_SYMBOL(find_next_and_bit);
92	#endif	100	#endif
@@ -149,57 +157,11 @@ EXPORT_SYMBOL(find_last_bit); · 56 unmodified lines
149		157
150	#ifdef __BIG_ENDIAN	158	#ifdef __BIG_ENDIAN
151		159
152	/* include/linux/byteorder does not support "unsigned long" type */
153	static inline unsigned long ext2_swab(const unsigned long y)
154	{
155	#if BITS_PER_LONG == 64
156	return (unsigned long) __swab64((u64) y);
157	#elif BITS_PER_LONG == 32
158	return (unsigned long) __swab32((u32) y);
159	#else
160	#error BITS_PER_LONG not defined
161	#endif
162	}
163
164	#if !defined(find_next_bit_le) \|\| !defined(find_next_zero_bit_le)
165	static inline unsigned long _find_next_bit_le(const unsigned long *addr1,
166	const unsigned long *addr2, unsigned long nbits,
167	unsigned long start, unsigned long invert)
168	{
169	unsigned long tmp;
170
171	if (unlikely(start >= nbits))
172	return nbits;
173
174	tmp = addr1[start / BITS_PER_LONG];
175	if (addr2)
176	tmp &= addr2[start / BITS_PER_LONG];
177	tmp ^= invert;
178
179	/* Handle 1st word. */
180	tmp &= ext2_swab(BITMAP_FIRST_WORD_MASK(start));
181	start = round_down(start, BITS_PER_LONG);
182
183	while (!tmp) {
184	start += BITS_PER_LONG;
185	if (start >= nbits)
186	return nbits;
187
188	tmp = addr1[start / BITS_PER_LONG];
189	if (addr2)
190	tmp &= addr2[start / BITS_PER_LONG];
191	tmp ^= invert;
192	}
193
194	return min(start + __ffs(ext2_swab(tmp)), nbits);
195	}
196	#endif
197
198	#ifndef find_next_zero_bit_le	160	#ifndef find_next_zero_bit_le
199	unsigned long find_next_zero_bit_le(const void *addr, unsigned	161	unsigned long find_next_zero_bit_le(const void *addr, unsigned
200	long size, unsigned long offset)	162	long size, unsigned long offset)
201	{	163	{
202	return _find_next_bit_le(addr, NULL, size, offset, ~0UL);	164	return _find_next_bit(addr, NULL, size, offset, ~0UL, 1);
203	}	165	}
204	EXPORT_SYMBOL(find_next_zero_bit_le);	166	EXPORT_SYMBOL(find_next_zero_bit_le);
205	#endif	167	#endif
@@ -208,7 +170,7 @@ EXPORT_SYMBOL(find_next_zero_bit_le); · 2 unmodified lines
208	unsigned long find_next_bit_le(const void *addr, unsigned	170	unsigned long find_next_bit_le(const void *addr, unsigned
209	long size, unsigned long offset)	171	long size, unsigned long offset)
210	{	172	{
211	return _find_next_bit_le(addr, NULL, size, offset, 0UL);	173	return _find_next_bit(addr, NULL, size, offset, 0UL, 1);
212	}	174	}
213	EXPORT_SYMBOL(find_next_bit_le);	175	EXPORT_SYMBOL(find_next_bit_le);
214	#endif	176	#endif

lib/scatterlist.c+1−1

@@ -311,7 +311,7 @@ int __sg_alloc_table(struct sg_table *table, unsigned int nents, · 310 unmodified lines
311	if (prv)	311	if (prv)
312	table->nents = ++table->orig_nents;	312	table->nents = ++table->orig_nents;
313		313
314	return -ENOMEM;	314	return -ENOMEM;
315	}	315	}
316		316
317	sg_init_table(sg, alloc_size);	317	sg_init_table(sg, alloc_size);

lib/test_bitmap.c+5−4

 static void __init test_replace(void)
 {
 	unsigned int nbits = 64;
+	unsigned int nlongs = DIV_ROUND_UP(nbits, BITS_PER_LONG);
 	DECLARE_BITMAP(bmap, 1024);
 	bitmap_zero(bmap, 1024);
-	bitmap_replace(bmap, &exp2[0], &exp2[1], exp2_to_exp3_mask, nbits);
+	bitmap_replace(bmap, &exp2[0 * nlongs], &exp2[1 * nlongs], exp2_to_exp3_mask, nbits);
 	expect_eq_bitmap(bmap, exp3_0_1, nbits);
 	bitmap_zero(bmap, 1024);
-	bitmap_replace(bmap, &exp2[1], &exp2[0], exp2_to_exp3_mask, nbits);
+	bitmap_replace(bmap, &exp2[1 * nlongs], &exp2[0 * nlongs], exp2_to_exp3_mask, nbits);
 	expect_eq_bitmap(bmap, exp3_1_0, nbits);
 	bitmap_fill(bmap, 1024);
-	bitmap_replace(bmap, &exp2[0], &exp2[1], exp2_to_exp3_mask, nbits);
+	bitmap_replace(bmap, &exp2[0 * nlongs], &exp2[1 * nlongs], exp2_to_exp3_mask, nbits);
 	expect_eq_bitmap(bmap, exp3_0_1, nbits);
 	bitmap_fill(bmap, 1024);
-	bitmap_replace(bmap, &exp2[1], &exp2[0], exp2_to_exp3_mask, nbits);
+	bitmap_replace(bmap, &exp2[1 * nlongs], &exp2[0 * nlongs], exp2_to_exp3_mask, nbits);
 	expect_eq_bitmap(bmap, exp3_1_0, nbits);
 }

lib/test_kasan.c+1−0

@@ -158,6 +158,7 @@ static noinline void __init kmalloc_oob_krealloc_more(void) · 157 unmodified lines
158	if (!ptr1 \|\| !ptr2) {	158	if (!ptr1 \|\| !ptr2) {
159	pr_err("Allocation failed\n");	159	pr_err("Allocation failed\n");
160	kfree(ptr1);	160	kfree(ptr1);
		161	kfree(ptr2);
161	return;	162	return;
162	}	163	}
163		164

lib/zlib_deflate/deflate.c+47−38

 #include <linux/zutil.h>
 #include "defutil.h"
+/* architecture-specific bits */
+#ifdef CONFIG_ZLIB_DFLTCC
+#  include "../zlib_dfltcc/dfltcc.h"
+#else
+#define DEFLATE_RESET_HOOK(strm) do {} while (0)
+#define DEFLATE_HOOK(strm, flush, bstate) 0
+#define DEFLATE_NEED_CHECKSUM(strm) 1
+#define DEFLATE_DFLTCC_ENABLED() 0
+#endif
 /* ===========================================================================
  *  Function prototypes.
  */
-typedef enum {
-    need_more,      /* block not completed, need more input or more output */
-    block_done,     /* block flush performed */
-    finish_started, /* finish started, need only more output at next deflate */
-    finish_done     /* finish done, accept no more input or output */
-} block_state;
 typedef block_state (*compress_func) (deflate_state *s, int flush);
 /* Compression function. Returns the block state after the call. */
 static block_state deflate_slow   (deflate_state *s, int flush);
 static void lm_init        (deflate_state *s);
 static void putShortMSB    (deflate_state *s, uInt b);
-static void flush_pending  (z_streamp strm);
 static int read_buf        (z_streamp strm, Byte *buf, unsigned size);
 static uInt longest_match  (deflate_state *s, IPos cur_match);
  * See deflate.c for comments about the MIN_MATCH+1.
  */
+/* Workspace to be allocated for deflate processing */
+typedef struct deflate_workspace {
+    /* State memory for the deflator */
+    deflate_state deflate_memory;
+#ifdef CONFIG_ZLIB_DFLTCC
+    /* State memory for s390 hardware deflate */
+    struct dfltcc_state dfltcc_memory;
+#endif
+    Byte *window_memory;
+    Pos *prev_memory;
+    Pos *head_memory;
+    char *overlay_memory;
+} deflate_workspace;
+#ifdef CONFIG_ZLIB_DFLTCC
+/* dfltcc_state must be doubleword aligned for DFLTCC call */
+static_assert(offsetof(struct deflate_workspace, dfltcc_memory) % 8 == 0);
+#endif
 /* Values for max_lazy_match, good_match and max_chain_length, depending on
  * the desired pack level (0..9). The values given below have been tuned to
  * exclude worst case performance for pathological files. Better values may be
      */
     next = (char *) mem;
     next += sizeof(*mem);
+#ifdef CONFIG_ZLIB_DFLTCC
+    /*
+     *  DFLTCC requires the window to be page aligned.
+     *  Thus, we overallocate and take the aligned portion of the buffer.
+     */
+    mem->window_memory = (Byte *) PTR_ALIGN(next, PAGE_SIZE);
+#else
     mem->window_memory = (Byte *) next;
+#endif
     next += zlib_deflate_window_memsize(windowBits);
     mem->prev_memory = (Pos *) next;
     next += zlib_deflate_prev_memsize(windowBits);
     zlib_tr_init(s);
     lm_init(s);
+    DEFLATE_RESET_HOOK(strm);
     return Z_OK;
 }
     put_byte(s, (Byte)(b & 0xff));
 }
-/* =========================================================================
- * Flush as much pending output as possible. All deflate() output goes
- * through this function so some applications may wish to modify it
- * to avoid allocating a large strm->next_out buffer and copying into it.
- * (See also read_buf()).
- */
-static void flush_pending(
-	z_streamp strm
-)
-{
-    deflate_state *s = (deflate_state *) strm->state;
-    unsigned len = s->pending;
-    if (len > strm->avail_out) len = strm->avail_out;
-    if (len == 0) return;
-    if (strm->next_out != NULL) {
-	memcpy(strm->next_out, s->pending_out, len);
-	strm->next_out += len;
-    }
-    s->pending_out += len;
-    strm->total_out += len;
-    strm->avail_out  -= len;
-    s->pending -= len;
-    if (s->pending == 0) {
-        s->pending_out = s->pending_buf;
-    }
-}
 /* ========================================================================= */
 int zlib_deflate(
 	z_streamp strm,
         (flush != Z_NO_FLUSH && s->status != FINISH_STATE)) {
         block_state bstate;
-	bstate = (*(configuration_table[s->level].func))(s, flush);
+	bstate = DEFLATE_HOOK(strm, flush, &bstate) ? bstate :
+		 (*(configuration_table[s->level].func))(s, flush);
         if (bstate == finish_started || bstate == finish_done) {
             s->status = FINISH_STATE;
     strm->avail_in  -= len;
-    if (!((deflate_state *)(strm->state))->noheader) {
+    if (!DEFLATE_NEED_CHECKSUM(strm)) {}
+    else if (!((deflate_state *)(strm->state))->noheader) {
         strm->adler = zlib_adler32(strm->adler, strm->next_in, len);
     }
     memcpy(buf, strm->next_in, len);
         + zlib_deflate_head_memsize(memLevel)
         + zlib_deflate_overlay_memsize(memLevel);
 }
+int zlib_deflate_dfltcc_enabled(void)
+{
+	return DEFLATE_DFLTCC_ENABLED();
+}

lib/zlib_deflate/deflate_syms.c+1−0

@@ -12,6 +12,7 @@ · 11 unmodified lines
12	#include <linux/zlib.h>	12	#include <linux/zlib.h>
13		13
14	EXPORT_SYMBOL(zlib_deflate_workspacesize);	14	EXPORT_SYMBOL(zlib_deflate_workspacesize);
		15	EXPORT_SYMBOL(zlib_deflate_dfltcc_enabled);
15	EXPORT_SYMBOL(zlib_deflate);	16	EXPORT_SYMBOL(zlib_deflate);
16	EXPORT_SYMBOL(zlib_deflateInit2);	17	EXPORT_SYMBOL(zlib_deflateInit2);
17	EXPORT_SYMBOL(zlib_deflateEnd);	18	EXPORT_SYMBOL(zlib_deflateEnd);

lib/zlib_deflate/deftree.c+0−54

@@ -76,11 +76,6 @@ static const uch bl_order[BL_CODES] · 75 unmodified lines
76	* probability, to avoid transmitting the lengths for unused bit length codes.	76	* probability, to avoid transmitting the lengths for unused bit length codes.
77	*/	77	*/
78		78
79	#define Buf_size (8 * 2*sizeof(char))
80	/* Number of bits used within bi_buf. (bi_buf might be implemented on
81	* more than 16 bits on some systems.)
82	*/
83
84	/* ===========================================================================	79	/* ===========================================================================
85	* Local data. These are initialized only once.	80	* Local data. These are initialized only once.
86	*/	81	*/
@@ -147,7 +142,6 @@ static void send_all_trees (deflate_state *s, int lcodes, int dcodes, · 60 unmodified lines
147	static void compress_block (deflate_state s, ct_data ltree,	142	static void compress_block (deflate_state s, ct_data ltree,
148	ct_data *dtree);	143	ct_data *dtree);
149	static void set_data_type (deflate_state *s);	144	static void set_data_type (deflate_state *s);
150	static void bi_windup (deflate_state *s);
151	static void bi_flush (deflate_state *s);	145	static void bi_flush (deflate_state *s);
152	static void copy_block (deflate_state s, char buf, unsigned len,	146	static void copy_block (deflate_state s, char buf, unsigned len,
153	int header);	147	int header);
@@ -169,54 +163,6 @@ static void copy_block (deflate_state s, char buf, unsigned len, · 15 unmodified lines
169	* used.	163	* used.
170	*/	164	*/
171		165
172	/* ===========================================================================
173	* Send a value on a given number of bits.
174	* IN assertion: length <= 16 and value fits in length bits.
175	*/
176	#ifdef DEBUG_ZLIB
177	static void send_bits (deflate_state *s, int value, int length);
178
179	static void send_bits(
180	deflate_state *s,
181	int value, /* value to send */
182	int length /* number of bits */
183	)
184	{
185	Tracevv((stderr," l %2d v %4x ", length, value));
186	Assert(length > 0 && length <= 15, "invalid length");
187	s->bits_sent += (ulg)length;
188
189	/* If not enough room in bi_buf, use (valid) bits from bi_buf and
190	* (16 - bi_valid) bits from value, leaving (width - (16-bi_valid))
191	* unused bits in value.
192	*/
193	if (s->bi_valid > (int)Buf_size - length) {
194	s->bi_buf \|= (value << s->bi_valid);
195	put_short(s, s->bi_buf);
196	s->bi_buf = (ush)value >> (Buf_size - s->bi_valid);
197	s->bi_valid += length - Buf_size;
198	} else {
199	s->bi_buf \|= value << s->bi_valid;
200	s->bi_valid += length;
201	}
202	}
203	#else /* !DEBUG_ZLIB */
204
205	#define send_bits(s, value, length) \
206	{ int len = length;\
207	if (s->bi_valid > (int)Buf_size - len) {\
208	int val = value;\
209	s->bi_buf \|= (val << s->bi_valid);\
210	put_short(s, s->bi_buf);\
211	s->bi_buf = (ush)val >> (Buf_size - s->bi_valid);\
212	s->bi_valid += len - Buf_size;\
213	} else {\
214	s->bi_buf \|= (value) << s->bi_valid;\
215	s->bi_valid += len;\
216	}\
217	}
218	#endif /* DEBUG_ZLIB */
219
220	/* ===========================================================================	166	/* ===========================================================================
221	* Initialize the various 'constant' tables. In a multi-threaded environment,	167	* Initialize the various 'constant' tables. In a multi-threaded environment,
222	* this function may be called by two threads concurrently, but this is	168	* this function may be called by two threads concurrently, but this is

lib/zlib_deflate/defutil.h+124−10

@@ -1,5 +1,7 @@
		1	#ifndef DEFUTIL_H
		2	#define DEFUTIL_H
1		3
2		4	#include <linux/zutil.h>
3		5
4	#define Assert(err, str)	6	#define Assert(err, str)
5	#define Trace(dummy)	7	#define Trace(dummy)
@@ -238,17 +240,13 @@ typedef struct deflate_state { · 232 unmodified lines
238		240
239	} deflate_state;	241	} deflate_state;
240		242
241	typedef struct deflate_workspace {	243	#ifdef CONFIG_ZLIB_DFLTCC
242	/* State memory for the deflator */	244	#define zlib_deflate_window_memsize(windowBits) \
243	deflate_state deflate_memory;	245	(2 * (1 << (windowBits)) * sizeof(Byte) + PAGE_SIZE)
244	Byte *window_memory;	246	#else
245	Pos *prev_memory;
246	Pos *head_memory;
247	char *overlay_memory;
248	} deflate_workspace;
249
250	#define zlib_deflate_window_memsize(windowBits) \	247	#define zlib_deflate_window_memsize(windowBits) \
251	(2 * (1 << (windowBits)) * sizeof(Byte))	248	(2 * (1 << (windowBits)) * sizeof(Byte))
		249	#endif
252	#define zlib_deflate_prev_memsize(windowBits) \	250	#define zlib_deflate_prev_memsize(windowBits) \
253	((1 << (windowBits)) * sizeof(Pos))	251	((1 << (windowBits)) * sizeof(Pos))
254	#define zlib_deflate_head_memsize(memLevel) \	252	#define zlib_deflate_head_memsize(memLevel) \
@@ -292,6 +290,24 @@ void zlib_tr_stored_type_only (deflate_state *); · 37 unmodified lines
292	put_byte(s, (uch)((ush)(w) >> 8)); \	290	put_byte(s, (uch)((ush)(w) >> 8)); \
293	}	291	}
294		292
		293	/* ===========================================================================
		294	* Reverse the first len bits of a code, using straightforward code (a faster
		295	* method would use a table)
		296	* IN assertion: 1 <= len <= 15
		297	*/
		298	static inline unsigned bi_reverse(
		299	unsigned code, /* the value to invert */
		300	int len /* its bit length */
		301	)
		302	{
		303	register unsigned res = 0;
		304	do {
		305	res \|= code & 1;
		306	code >>= 1, res <<= 1;
		307	} while (--len > 0);
		308	return res >> 1;
		309	}
		310
295	/* ===========================================================================	311	/* ===========================================================================
296	* Flush the bit buffer, keeping at most 7 bits in it.	312	* Flush the bit buffer, keeping at most 7 bits in it.
297	*/	313	*/
@@ -325,3 +341,101 @@ static inline void bi_windup(deflate_state *s) · 27 unmodified lines
325	#endif	341	#endif
326	}	342	}
327		343
		344	typedef enum {
		345	need_more, /* block not completed, need more input or more output */
		346	block_done, /* block flush performed */
		347	finish_started, /* finish started, need only more output at next deflate */
		348	finish_done /* finish done, accept no more input or output */
		349	} block_state;
		350
		351	#define Buf_size (8 * 2*sizeof(char))
		352	/* Number of bits used within bi_buf. (bi_buf might be implemented on
		353	* more than 16 bits on some systems.)
		354	*/
		355
		356	/* ===========================================================================
		357	* Send a value on a given number of bits.
		358	* IN assertion: length <= 16 and value fits in length bits.
		359	*/
		360	#ifdef DEBUG_ZLIB
		361	static void send_bits (deflate_state *s, int value, int length);
		362
		363	static void send_bits(
		364	deflate_state *s,
		365	int value, /* value to send */
		366	int length /* number of bits */
		367	)
		368	{
		369	Tracevv((stderr," l %2d v %4x ", length, value));
		370	Assert(length > 0 && length <= 15, "invalid length");
		371	s->bits_sent += (ulg)length;
		372
		373	/* If not enough room in bi_buf, use (valid) bits from bi_buf and
		374	* (16 - bi_valid) bits from value, leaving (width - (16-bi_valid))
		375	* unused bits in value.
		376	*/
		377	if (s->bi_valid > (int)Buf_size - length) {
		378	s->bi_buf \|= (value << s->bi_valid);
		379	put_short(s, s->bi_buf);
		380	s->bi_buf = (ush)value >> (Buf_size - s->bi_valid);
		381	s->bi_valid += length - Buf_size;
		382	} else {
		383	s->bi_buf \|= value << s->bi_valid;
		384	s->bi_valid += length;
		385	}
		386	}
		387	#else /* !DEBUG_ZLIB */
		388
		389	#define send_bits(s, value, length) \
		390	{ int len = length;\
		391	if (s->bi_valid > (int)Buf_size - len) {\
		392	int val = value;\
		393	s->bi_buf \|= (val << s->bi_valid);\
		394	put_short(s, s->bi_buf);\
		395	s->bi_buf = (ush)val >> (Buf_size - s->bi_valid);\
		396	s->bi_valid += len - Buf_size;\
		397	} else {\
		398	s->bi_buf \|= (value) << s->bi_valid;\
		399	s->bi_valid += len;\
		400	}\
		401	}
		402	#endif /* DEBUG_ZLIB */
		403
		404	static inline void zlib_tr_send_bits(
		405	deflate_state *s,
		406	int value,
		407	int length
		408	)
		409	{
		410	send_bits(s, value, length);
		411	}
		412
		413	/* =========================================================================
		414	* Flush as much pending output as possible. All deflate() output goes
		415	* through this function so some applications may wish to modify it
		416	* to avoid allocating a large strm->next_out buffer and copying into it.
		417	* (See also read_buf()).
		418	*/
		419	static inline void flush_pending(
		420	z_streamp strm
		421	)
		422	{
		423	deflate_state s = (deflate_state ) strm->state;
		424	unsigned len = s->pending;
		425
		426	if (len > strm->avail_out) len = strm->avail_out;
		427	if (len == 0) return;
		428
		429	if (strm->next_out != NULL) {
		430	memcpy(strm->next_out, s->pending_out, len);
		431	strm->next_out += len;
		432	}
		433	s->pending_out += len;
		434	strm->total_out += len;
		435	strm->avail_out -= len;
		436	s->pending -= len;
		437	if (s->pending == 0) {
		438	s->pending_out = s->pending_buf;
		439	}
		440	}
		441	#endif /* DEFUTIL_H */

lib/zlib_dfltcc/Makefile+11−0

@@ -0,0 +1,11 @@
	1	# SPDX-License-Identifier: GPL-2.0-only
	2	#
	3	# This is a modified version of zlib, which does all memory
	4	# allocation ahead of time.
	5	#
	6	# This is the code for s390 zlib hardware support.
	7	#
	8
	9	obj-$(CONFIG_ZLIB_DFLTCC) += zlib_dfltcc.o
	10
	11	zlib_dfltcc-objs := dfltcc.o dfltcc_deflate.o dfltcc_inflate.o dfltcc_syms.o

lib/zlib_dfltcc/dfltcc.c+55−0

@@ -0,0 +1,55 @@
	1	// SPDX-License-Identifier: Zlib
	2	/* dfltcc.c - SystemZ DEFLATE CONVERSION CALL support. */
	3
	4	#include <linux/zutil.h>
	5	#include "dfltcc_util.h"
	6	#include "dfltcc.h"
	7
	8	char *oesc_msg(
	9	char *buf,
	10	int oesc
	11	)
	12	{
	13	if (oesc == 0x00)
	14	return NULL; /* Successful completion */
	15	else {
	16	#ifdef STATIC
	17	return NULL; /* Ignore for pre-boot decompressor */
	18	#else
	19	sprintf(buf, "Operation-Ending-Supplemental Code is 0x%.2X", oesc);
	20	return buf;
	21	#endif
	22	}
	23	}
	24
	25	void dfltcc_reset(
	26	z_streamp strm,
	27	uInt size
	28	)
	29	{
	30	struct dfltcc_state *dfltcc_state =
	31	(struct dfltcc_state )((char )strm->state + size);
	32	struct dfltcc_qaf_param *param =
	33	(struct dfltcc_qaf_param *)&dfltcc_state->param;
	34
	35	/* Initialize available functions */
	36	if (is_dfltcc_enabled()) {
	37	dfltcc(DFLTCC_QAF, param, NULL, NULL, NULL, NULL, NULL);
	38	memmove(&dfltcc_state->af, param, sizeof(dfltcc_state->af));
	39	} else
	40	memset(&dfltcc_state->af, 0, sizeof(dfltcc_state->af));
	41
	42	/* Initialize parameter block */
	43	memset(&dfltcc_state->param, 0, sizeof(dfltcc_state->param));
	44	dfltcc_state->param.nt = 1;
	45
	46	/* Initialize tuning parameters */
	47	if (zlib_dfltcc_support == ZLIB_DFLTCC_FULL_DEBUG)
	48	dfltcc_state->level_mask = DFLTCC_LEVEL_MASK_DEBUG;
	49	else
	50	dfltcc_state->level_mask = DFLTCC_LEVEL_MASK;
	51	dfltcc_state->block_size = DFLTCC_BLOCK_SIZE;
	52	dfltcc_state->block_threshold = DFLTCC_FIRST_FHT_BLOCK_SIZE;
	53	dfltcc_state->dht_threshold = DFLTCC_DHT_MIN_SAMPLE_SIZE;
	54	dfltcc_state->param.ribm = DFLTCC_RIBM;
	55	}

lib/zlib_dfltcc/dfltcc.h+155−0

@@ -0,0 +1,155 @@
	1	// SPDX-License-Identifier: Zlib
	2	#ifndef DFLTCC_H
	3	#define DFLTCC_H
	4
	5	#include "../zlib_deflate/defutil.h"
	6	#include <asm/facility.h>
	7	#include <asm/setup.h>
	8
	9	/*
	10	* Tuning parameters.
	11	*/
	12	#define DFLTCC_LEVEL_MASK 0x2 /* DFLTCC compression for level 1 only */
	13	#define DFLTCC_LEVEL_MASK_DEBUG 0x3fe /* DFLTCC compression for all levels */
	14	#define DFLTCC_BLOCK_SIZE 1048576
	15	#define DFLTCC_FIRST_FHT_BLOCK_SIZE 4096
	16	#define DFLTCC_DHT_MIN_SAMPLE_SIZE 4096
	17	#define DFLTCC_RIBM 0
	18
	19	#define DFLTCC_FACILITY 151
	20
	21	/*
	22	* Parameter Block for Query Available Functions.
	23	*/
	24	struct dfltcc_qaf_param {
	25	char fns[16];
	26	char reserved1[8];
	27	char fmts[2];
	28	char reserved2[6];
	29	};
	30
	31	static_assert(sizeof(struct dfltcc_qaf_param) == 32);
	32
	33	#define DFLTCC_FMT0 0
	34
	35	/*
	36	* Parameter Block for Generate Dynamic-Huffman Table, Compress and Expand.
	37	*/
	38	struct dfltcc_param_v0 {
	39	uint16_t pbvn; /* Parameter-Block-Version Number */
	40	uint8_t mvn; /* Model-Version Number */
	41	uint8_t ribm; /* Reserved for IBM use */
	42	unsigned reserved32 : 31;
	43	unsigned cf : 1; /* Continuation Flag */
	44	uint8_t reserved64[8];
	45	unsigned nt : 1; /* New Task */
	46	unsigned reserved129 : 1;
	47	unsigned cvt : 1; /* Check Value Type */
	48	unsigned reserved131 : 1;
	49	unsigned htt : 1; /* Huffman-Table Type */
	50	unsigned bcf : 1; /* Block-Continuation Flag */
	51	unsigned bcc : 1; /* Block Closing Control */
	52	unsigned bhf : 1; /* Block Header Final */
	53	unsigned reserved136 : 1;
	54	unsigned reserved137 : 1;
	55	unsigned dhtgc : 1; /* DHT Generation Control */
	56	unsigned reserved139 : 5;
	57	unsigned reserved144 : 5;
	58	unsigned sbb : 3; /* Sub-Byte Boundary */
	59	uint8_t oesc; /* Operation-Ending-Supplemental Code */
	60	unsigned reserved160 : 12;
	61	unsigned ifs : 4; /* Incomplete-Function Status */
	62	uint16_t ifl; /* Incomplete-Function Length */
	63	uint8_t reserved192[8];
	64	uint8_t reserved256[8];
	65	uint8_t reserved320[4];
	66	uint16_t hl; /* History Length */
	67	unsigned reserved368 : 1;
	68	uint16_t ho : 15; /* History Offset */
	69	uint32_t cv; /* Check Value */
	70	unsigned eobs : 15; /* End-of-block Symbol */
	71	unsigned reserved431: 1;
	72	uint8_t eobl : 4; /* End-of-block Length */
	73	unsigned reserved436 : 12;
	74	unsigned reserved448 : 4;
	75	uint16_t cdhtl : 12; /* Compressed-Dynamic-Huffman Table
	76	Length */
	77	uint8_t reserved464[6];
	78	uint8_t cdht[288];
	79	uint8_t reserved[32];
	80	uint8_t csb[1152];
	81	};
	82
	83	static_assert(sizeof(struct dfltcc_param_v0) == 1536);
	84
	85	#define CVT_CRC32 0
	86	#define CVT_ADLER32 1
	87	#define HTT_FIXED 0
	88	#define HTT_DYNAMIC 1
	89
	90	/*
	91	* Extension of inflate_state and deflate_state for DFLTCC.
	92	*/
	93	struct dfltcc_state {
	94	struct dfltcc_param_v0 param; /* Parameter block */
	95	struct dfltcc_qaf_param af; /* Available functions */
	96	uLong level_mask; /* Levels on which to use DFLTCC */
	97	uLong block_size; /* New block each X bytes */
	98	uLong block_threshold; /* New block after total_in > X */
	99	uLong dht_threshold; /* New block only if avail_in >= X */
	100	char msg[64]; /* Buffer for strm->msg */
	101	};
	102
	103	/* Resides right after inflate_state or deflate_state */
	104	#define GET_DFLTCC_STATE(state) ((struct dfltcc_state *)((state) + 1))
	105
	106	/* External functions */
	107	int dfltcc_can_deflate(z_streamp strm);
	108	int dfltcc_deflate(z_streamp strm,
	109	int flush,
	110	block_state *result);
	111	void dfltcc_reset(z_streamp strm, uInt size);
	112	int dfltcc_can_inflate(z_streamp strm);
	113	typedef enum {
	114	DFLTCC_INFLATE_CONTINUE,
	115	DFLTCC_INFLATE_BREAK,
	116	DFLTCC_INFLATE_SOFTWARE,
	117	} dfltcc_inflate_action;
	118	dfltcc_inflate_action dfltcc_inflate(z_streamp strm,
	119	int flush, int *ret);
	120	static inline int is_dfltcc_enabled(void)
	121	{
	122	return (zlib_dfltcc_support != ZLIB_DFLTCC_DISABLED &&
	123	test_facility(DFLTCC_FACILITY));
	124	}
	125
	126	#define DEFLATE_RESET_HOOK(strm) \
	127	dfltcc_reset((strm), sizeof(deflate_state))
	128
	129	#define DEFLATE_HOOK dfltcc_deflate
	130
	131	#define DEFLATE_NEED_CHECKSUM(strm) (!dfltcc_can_deflate((strm)))
	132
	133	#define DEFLATE_DFLTCC_ENABLED() is_dfltcc_enabled()
	134
	135	#define INFLATE_RESET_HOOK(strm) \
	136	dfltcc_reset((strm), sizeof(struct inflate_state))
	137
	138	#define INFLATE_TYPEDO_HOOK(strm, flush) \
	139	if (dfltcc_can_inflate((strm))) { \
	140	dfltcc_inflate_action action; \
	141	\
	142	RESTORE(); \
	143	action = dfltcc_inflate((strm), (flush), &ret); \
	144	LOAD(); \
	145	if (action == DFLTCC_INFLATE_CONTINUE) \
	146	break; \
	147	else if (action == DFLTCC_INFLATE_BREAK) \
	148	goto inf_leave; \
	149	}
	150
	151	#define INFLATE_NEED_CHECKSUM(strm) (!dfltcc_can_inflate((strm)))
	152
	153	#define INFLATE_NEED_UPDATEWINDOW(strm) (!dfltcc_can_inflate((strm)))
	154
	155	#endif /* DFLTCC_H */

lib/zlib_dfltcc/dfltcc_deflate.c+279−0

@@ -0,0 +1,279 @@
	1	// SPDX-License-Identifier: Zlib
	2
	3	#include "../zlib_deflate/defutil.h"
	4	#include "dfltcc_util.h"
	5	#include "dfltcc.h"
	6	#include <asm/setup.h>
	7	#include <linux/zutil.h>
	8
	9	/*
	10	* Compress.
	11	*/
	12	int dfltcc_can_deflate(
	13	z_streamp strm
	14	)
	15	{
	16	deflate_state state = (deflate_state )strm->state;
	17	struct dfltcc_state *dfltcc_state = GET_DFLTCC_STATE(state);
	18
	19	/* Check for kernel dfltcc command line parameter */
	20	if (zlib_dfltcc_support == ZLIB_DFLTCC_DISABLED \|\|
	21	zlib_dfltcc_support == ZLIB_DFLTCC_INFLATE_ONLY)
	22	return 0;
	23
	24	/* Unsupported compression settings */
	25	if (!dfltcc_are_params_ok(state->level, state->w_bits, state->strategy,
	26	dfltcc_state->level_mask))
	27	return 0;
	28
	29	/* Unsupported hardware */
	30	if (!is_bit_set(dfltcc_state->af.fns, DFLTCC_GDHT) \|\|
	31	!is_bit_set(dfltcc_state->af.fns, DFLTCC_CMPR) \|\|
	32	!is_bit_set(dfltcc_state->af.fmts, DFLTCC_FMT0))
	33	return 0;
	34
	35	return 1;
	36	}
	37
	38	static void dfltcc_gdht(
	39	z_streamp strm
	40	)
	41	{
	42	deflate_state state = (deflate_state )strm->state;
	43	struct dfltcc_param_v0 *param = &GET_DFLTCC_STATE(state)->param;
	44	size_t avail_in = avail_in = strm->avail_in;
	45
	46	dfltcc(DFLTCC_GDHT,
	47	param, NULL, NULL,
	48	&strm->next_in, &avail_in, NULL);
	49	}
	50
	51	static dfltcc_cc dfltcc_cmpr(
	52	z_streamp strm
	53	)
	54	{
	55	deflate_state state = (deflate_state )strm->state;
	56	struct dfltcc_param_v0 *param = &GET_DFLTCC_STATE(state)->param;
	57	size_t avail_in = strm->avail_in;
	58	size_t avail_out = strm->avail_out;
	59	dfltcc_cc cc;
	60
	61	cc = dfltcc(DFLTCC_CMPR \| HBT_CIRCULAR,
	62	param, &strm->next_out, &avail_out,
	63	&strm->next_in, &avail_in, state->window);
	64	strm->total_in += (strm->avail_in - avail_in);
	65	strm->total_out += (strm->avail_out - avail_out);
	66	strm->avail_in = avail_in;
	67	strm->avail_out = avail_out;
	68	return cc;
	69	}
	70
	71	static void send_eobs(
	72	z_streamp strm,
	73	const struct dfltcc_param_v0 *param
	74	)
	75	{
	76	deflate_state state = (deflate_state )strm->state;
	77
	78	zlib_tr_send_bits(
	79	state,
	80	bi_reverse(param->eobs >> (15 - param->eobl), param->eobl),
	81	param->eobl);
	82	flush_pending(strm);
	83	if (state->pending != 0) {
	84	/* The remaining data is located in pending_out[0:pending]. If someone
	85	* calls put_byte() - this might happen in deflate() - the byte will be
	86	* placed into pending_buf[pending], which is incorrect. Move the
	87	* remaining data to the beginning of pending_buf so that put_byte() is
	88	* usable again.
	89	*/
	90	memmove(state->pending_buf, state->pending_out, state->pending);
	91	state->pending_out = state->pending_buf;
	92	}
	93	#ifdef ZLIB_DEBUG
	94	state->compressed_len += param->eobl;
	95	#endif
	96	}
	97
	98	int dfltcc_deflate(
	99	z_streamp strm,
	100	int flush,
	101	block_state *result
	102	)
	103	{
	104	deflate_state state = (deflate_state )strm->state;
	105	struct dfltcc_state *dfltcc_state = GET_DFLTCC_STATE(state);
	106	struct dfltcc_param_v0 *param = &dfltcc_state->param;
	107	uInt masked_avail_in;
	108	dfltcc_cc cc;
	109	int need_empty_block;
	110	int soft_bcc;
	111	int no_flush;
	112
	113	if (!dfltcc_can_deflate(strm))
	114	return 0;
	115
	116	again:
	117	masked_avail_in = 0;
	118	soft_bcc = 0;
	119	no_flush = flush == Z_NO_FLUSH;
	120
	121	/* Trailing empty block. Switch to software, except when Continuation Flag
	122	* is set, which means that DFLTCC has buffered some output in the
	123	* parameter block and needs to be called again in order to flush it.
	124	*/
	125	if (flush == Z_FINISH && strm->avail_in == 0 && !param->cf) {
	126	if (param->bcf) {
	127	/* A block is still open, and the hardware does not support closing
	128	* blocks without adding data. Thus, close it manually.
	129	*/
	130	send_eobs(strm, param);
	131	param->bcf = 0;
	132	}
	133	return 0;
	134	}
	135
	136	if (strm->avail_in == 0 && !param->cf) {
	137	*result = need_more;
	138	return 1;
	139	}
	140
	141	/* There is an open non-BFINAL block, we are not going to close it just
	142	* yet, we have compressed more than DFLTCC_BLOCK_SIZE bytes and we see
	143	* more than DFLTCC_DHT_MIN_SAMPLE_SIZE bytes. Open a new block with a new
	144	* DHT in order to adapt to a possibly changed input data distribution.
	145	*/
	146	if (param->bcf && no_flush &&
	147	strm->total_in > dfltcc_state->block_threshold &&
	148	strm->avail_in >= dfltcc_state->dht_threshold) {
	149	if (param->cf) {
	150	/* We need to flush the DFLTCC buffer before writing the
	151	* End-of-block Symbol. Mask the input data and proceed as usual.
	152	*/
	153	masked_avail_in += strm->avail_in;
	154	strm->avail_in = 0;
	155	no_flush = 0;
	156	} else {
	157	/* DFLTCC buffer is empty, so we can manually write the
	158	* End-of-block Symbol right away.
	159	*/
	160	send_eobs(strm, param);
	161	param->bcf = 0;
	162	dfltcc_state->block_threshold =
	163	strm->total_in + dfltcc_state->block_size;
	164	if (strm->avail_out == 0) {
	165	*result = need_more;
	166	return 1;
	167	}
	168	}
	169	}
	170
	171	/* The caller gave us too much data. Pass only one block worth of
	172	* uncompressed data to DFLTCC and mask the rest, so that on the next
	173	* iteration we start a new block.
	174	*/
	175	if (no_flush && strm->avail_in > dfltcc_state->block_size) {
	176	masked_avail_in += (strm->avail_in - dfltcc_state->block_size);
	177	strm->avail_in = dfltcc_state->block_size;
	178	}
	179
	180	/* When we have an open non-BFINAL deflate block and caller indicates that
	181	* the stream is ending, we need to close an open deflate block and open a
	182	* BFINAL one.
	183	*/
	184	need_empty_block = flush == Z_FINISH && param->bcf && !param->bhf;
	185
	186	/* Translate stream to parameter block */
	187	param->cvt = CVT_ADLER32;
	188	if (!no_flush)
	189	/* We need to close a block. Always do this in software - when there is
	190	* no input data, the hardware will not nohor BCC. */
	191	soft_bcc = 1;
	192	if (flush == Z_FINISH && !param->bcf)
	193	/* We are about to open a BFINAL block, set Block Header Final bit
	194	* until the stream ends.
	195	*/
	196	param->bhf = 1;
	197	/* DFLTCC-CMPR will write to next_out, so make sure that buffers with
	198	* higher precedence are empty.
	199	*/
	200	Assert(state->pending == 0, "There must be no pending bytes");
	201	Assert(state->bi_valid < 8, "There must be less than 8 pending bits");
	202	param->sbb = (unsigned int)state->bi_valid;
	203	if (param->sbb > 0)
	204	*strm->next_out = (Byte)state->bi_buf;
	205	if (param->hl)
	206	param->nt = 0; /* Honor history */
	207	param->cv = strm->adler;
	208
	209	/* When opening a block, choose a Huffman-Table Type */
	210	if (!param->bcf) {
	211	if (strm->total_in == 0 && dfltcc_state->block_threshold > 0) {
	212	param->htt = HTT_FIXED;
	213	}
	214	else {
	215	param->htt = HTT_DYNAMIC;
	216	dfltcc_gdht(strm);
	217	}
	218	}
	219
	220	/* Deflate */
	221	do {
	222	cc = dfltcc_cmpr(strm);
	223	if (strm->avail_in < 4096 && masked_avail_in > 0)
	224	/* We are about to call DFLTCC with a small input buffer, which is
	225	* inefficient. Since there is masked data, there will be at least
	226	* one more DFLTCC call, so skip the current one and make the next
	227	* one handle more data.
	228	*/
	229	break;
	230	} while (cc == DFLTCC_CC_AGAIN);
	231
	232	/* Translate parameter block to stream */
	233	strm->msg = oesc_msg(dfltcc_state->msg, param->oesc);
	234	state->bi_valid = param->sbb;
	235	if (state->bi_valid == 0)
	236	state->bi_buf = 0; /* Avoid accessing next_out */
	237	else
	238	state->bi_buf = *strm->next_out & ((1 << state->bi_valid) - 1);
	239	strm->adler = param->cv;
	240
	241	/* Unmask the input data */
	242	strm->avail_in += masked_avail_in;
	243	masked_avail_in = 0;
	244
	245	/* If we encounter an error, it means there is a bug in DFLTCC call */
	246	Assert(cc != DFLTCC_CC_OP2_CORRUPT \|\| param->oesc == 0, "BUG");
	247
	248	/* Update Block-Continuation Flag. It will be used to check whether to call
	249	* GDHT the next time.
	250	*/
	251	if (cc == DFLTCC_CC_OK) {
	252	if (soft_bcc) {
	253	send_eobs(strm, param);
	254	param->bcf = 0;
	255	dfltcc_state->block_threshold =
	256	strm->total_in + dfltcc_state->block_size;
	257	} else
	258	param->bcf = 1;
	259	if (flush == Z_FINISH) {
	260	if (need_empty_block)
	261	/* Make the current deflate() call also close the stream */
	262	return 0;
	263	else {
	264	bi_windup(state);
	265	*result = finish_done;
	266	}
	267	} else {
	268	if (flush == Z_FULL_FLUSH)
	269	param->hl = 0; /* Clear history */
	270	*result = flush == Z_NO_FLUSH ? need_more : block_done;
	271	}
	272	} else {
	273	param->bcf = 1;
	274	*result = need_more;
	275	}
	276	if (strm->avail_in != 0 && strm->avail_out != 0)
	277	goto again; /* deflate() must use all input or all output */
	278	return 1;
	279	}

lib/zlib_dfltcc/dfltcc_inflate.c+149−0

@@ -0,0 +1,149 @@
	1	// SPDX-License-Identifier: Zlib
	2
	3	#include "../zlib_inflate/inflate.h"
	4	#include "dfltcc_util.h"
	5	#include "dfltcc.h"
	6	#include <asm/setup.h>
	7	#include <linux/zutil.h>
	8
	9	/*
	10	* Expand.
	11	*/
	12	int dfltcc_can_inflate(
	13	z_streamp strm
	14	)
	15	{
	16	struct inflate_state state = (struct inflate_state )strm->state;
	17	struct dfltcc_state *dfltcc_state = GET_DFLTCC_STATE(state);
	18
	19	/* Check for kernel dfltcc command line parameter */
	20	if (zlib_dfltcc_support == ZLIB_DFLTCC_DISABLED \|\|
	21	zlib_dfltcc_support == ZLIB_DFLTCC_DEFLATE_ONLY)
	22	return 0;
	23
	24	/* Unsupported compression settings */
	25	if (state->wbits != HB_BITS)
	26	return 0;
	27
	28	/* Unsupported hardware */
	29	return is_bit_set(dfltcc_state->af.fns, DFLTCC_XPND) &&
	30	is_bit_set(dfltcc_state->af.fmts, DFLTCC_FMT0);
	31	}
	32
	33	static int dfltcc_was_inflate_used(
	34	z_streamp strm
	35	)
	36	{
	37	struct inflate_state state = (struct inflate_state )strm->state;
	38	struct dfltcc_param_v0 *param = &GET_DFLTCC_STATE(state)->param;
	39
	40	return !param->nt;
	41	}
	42
	43	static int dfltcc_inflate_disable(
	44	z_streamp strm
	45	)
	46	{
	47	struct inflate_state state = (struct inflate_state )strm->state;
	48	struct dfltcc_state *dfltcc_state = GET_DFLTCC_STATE(state);
	49
	50	if (!dfltcc_can_inflate(strm))
	51	return 0;
	52	if (dfltcc_was_inflate_used(strm))
	53	/* DFLTCC has already decompressed some data. Since there is not
	54	* enough information to resume decompression in software, the call
	55	* must fail.
	56	*/
	57	return 1;
	58	/* DFLTCC was not used yet - decompress in software */
	59	memset(&dfltcc_state->af, 0, sizeof(dfltcc_state->af));
	60	return 0;
	61	}
	62
	63	static dfltcc_cc dfltcc_xpnd(
	64	z_streamp strm
	65	)
	66	{
	67	struct inflate_state state = (struct inflate_state )strm->state;
	68	struct dfltcc_param_v0 *param = &GET_DFLTCC_STATE(state)->param;
	69	size_t avail_in = strm->avail_in;
	70	size_t avail_out = strm->avail_out;
	71	dfltcc_cc cc;
	72
	73	cc = dfltcc(DFLTCC_XPND \| HBT_CIRCULAR,
	74	param, &strm->next_out, &avail_out,
	75	&strm->next_in, &avail_in, state->window);
	76	strm->avail_in = avail_in;
	77	strm->avail_out = avail_out;
	78	return cc;
	79	}
	80
	81	dfltcc_inflate_action dfltcc_inflate(
	82	z_streamp strm,
	83	int flush,
	84	int *ret
	85	)
	86	{
	87	struct inflate_state state = (struct inflate_state )strm->state;
	88	struct dfltcc_state *dfltcc_state = GET_DFLTCC_STATE(state);
	89	struct dfltcc_param_v0 *param = &dfltcc_state->param;
	90	dfltcc_cc cc;
	91
	92	if (flush == Z_BLOCK) {
	93	/* DFLTCC does not support stopping on block boundaries */
	94	if (dfltcc_inflate_disable(strm)) {
	95	*ret = Z_STREAM_ERROR;
	96	return DFLTCC_INFLATE_BREAK;
	97	} else
	98	return DFLTCC_INFLATE_SOFTWARE;
	99	}
	100
	101	if (state->last) {
	102	if (state->bits != 0) {
	103	strm->next_in++;
	104	strm->avail_in--;
	105	state->bits = 0;
	106	}
	107	state->mode = CHECK;
	108	return DFLTCC_INFLATE_CONTINUE;
	109	}
	110
	111	if (strm->avail_in == 0 && !param->cf)
	112	return DFLTCC_INFLATE_BREAK;
	113
	114	if (!state->window \|\| state->wsize == 0) {
	115	state->mode = MEM;
	116	return DFLTCC_INFLATE_CONTINUE;
	117	}
	118
	119	/* Translate stream to parameter block */
	120	param->cvt = CVT_ADLER32;
	121	param->sbb = state->bits;
	122	param->hl = state->whave; /* Software and hardware history formats match */
	123	param->ho = (state->write - state->whave) & ((1 << HB_BITS) - 1);
	124	if (param->hl)
	125	param->nt = 0; /* Honor history for the first block */
	126	param->cv = state->flags ? REVERSE(state->check) : state->check;
	127
	128	/* Inflate */
	129	do {
	130	cc = dfltcc_xpnd(strm);
	131	} while (cc == DFLTCC_CC_AGAIN);
	132
	133	/* Translate parameter block to stream */
	134	strm->msg = oesc_msg(dfltcc_state->msg, param->oesc);
	135	state->last = cc == DFLTCC_CC_OK;
	136	state->bits = param->sbb;
	137	state->whave = param->hl;
	138	state->write = (param->ho + param->hl) & ((1 << HB_BITS) - 1);
	139	state->check = state->flags ? REVERSE(param->cv) : param->cv;
	140	if (cc == DFLTCC_CC_OP2_CORRUPT && param->oesc != 0) {
	141	/* Report an error if stream is corrupted */
	142	state->mode = BAD;
	143	return DFLTCC_INFLATE_CONTINUE;
	144	}
	145	state->mode = TYPEDO;
	146	/* Break if operands are exhausted, otherwise continue looping */
	147	return (cc == DFLTCC_CC_OP1_TOO_SHORT \|\| cc == DFLTCC_CC_OP2_TOO_SHORT) ?
	148	DFLTCC_INFLATE_BREAK : DFLTCC_INFLATE_CONTINUE;
	149	}

lib/zlib_dfltcc/dfltcc_syms.c+17−0

@@ -0,0 +1,17 @@
	1	// SPDX-License-Identifier: GPL-2.0-only
	2	/*
	3	* linux/lib/zlib_dfltcc/dfltcc_syms.c
	4	*
	5	* Exported symbols for the s390 zlib dfltcc support.
	6	*
	7	*/
	8
	9	#include <linux/init.h>
	10	#include <linux/module.h>
	11	#include <linux/zlib.h>
	12	#include "dfltcc.h"
	13
	14	EXPORT_SYMBOL(dfltcc_can_deflate);
	15	EXPORT_SYMBOL(dfltcc_deflate);
	16	EXPORT_SYMBOL(dfltcc_reset);
	17	MODULE_LICENSE("GPL");

lib/zlib_dfltcc/dfltcc_util.h+103−0

@@ -0,0 +1,103 @@
	1	// SPDX-License-Identifier: Zlib
	2	#ifndef DFLTCC_UTIL_H
	3	#define DFLTCC_UTIL_H
	4
	5	#include <linux/zutil.h>
	6
	7	/*
	8	* C wrapper for the DEFLATE CONVERSION CALL instruction.
	9	*/
	10	typedef enum {
	11	DFLTCC_CC_OK = 0,
	12	DFLTCC_CC_OP1_TOO_SHORT = 1,
	13	DFLTCC_CC_OP2_TOO_SHORT = 2,
	14	DFLTCC_CC_OP2_CORRUPT = 2,
	15	DFLTCC_CC_AGAIN = 3,
	16	} dfltcc_cc;
	17
	18	#define DFLTCC_QAF 0
	19	#define DFLTCC_GDHT 1
	20	#define DFLTCC_CMPR 2
	21	#define DFLTCC_XPND 4
	22	#define HBT_CIRCULAR (1 << 7)
	23	#define HB_BITS 15
	24	#define HB_SIZE (1 << HB_BITS)
	25
	26	static inline dfltcc_cc dfltcc(
	27	int fn,
	28	void *param,
	29	Byte **op1,
	30	size_t *len1,
	31	const Byte **op2,
	32	size_t *len2,
	33	void *hist
	34	)
	35	{
	36	Byte t2 = op1 ? op1 : NULL;
	37	size_t t3 = len1 ? *len1 : 0;
	38	const Byte t4 = op2 ? op2 : NULL;
	39	size_t t5 = len2 ? *len2 : 0;
	40	register int r0 __asm__("r0") = fn;
	41	register void *r1 __asm__("r1") = param;
	42	register Byte *r2 __asm__("r2") = t2;
	43	register size_t r3 __asm__("r3") = t3;
	44	register const Byte *r4 __asm__("r4") = t4;
	45	register size_t r5 __asm__("r5") = t5;
	46	int cc;
	47
	48	__asm__ volatile(
	49	".insn rrf,0xb9390000,%[r2],%[r4],%[hist],0\n"
	50	"ipm %[cc]\n"
	51	: [r2] "+r" (r2)
	52	, [r3] "+r" (r3)
	53	, [r4] "+r" (r4)
	54	, [r5] "+r" (r5)
	55	, [cc] "=r" (cc)
	56	: [r0] "r" (r0)
	57	, [r1] "r" (r1)
	58	, [hist] "r" (hist)
	59	: "cc", "memory");
	60	t2 = r2; t3 = r3; t4 = r4; t5 = r5;
	61
	62	if (op1)
	63	*op1 = t2;
	64	if (len1)
	65	*len1 = t3;
	66	if (op2)
	67	*op2 = t4;
	68	if (len2)
	69	*len2 = t5;
	70	return (cc >> 28) & 3;
	71	}
	72
	73	static inline int is_bit_set(
	74	const char *bits,
	75	int n
	76	)
	77	{
	78	return bits[n / 8] & (1 << (7 - (n % 8)));
	79	}
	80
	81	static inline void turn_bit_off(
	82	char *bits,
	83	int n
	84	)
	85	{
	86	bits[n / 8] &= ~(1 << (7 - (n % 8)));
	87	}
	88
	89	static inline int dfltcc_are_params_ok(
	90	int level,
	91	uInt window_bits,
	92	int strategy,
	93	uLong level_mask
	94	)
	95	{
	96	return (level_mask & (1 << level)) != 0 &&
	97	(window_bits == HB_BITS) &&
	98	(strategy == Z_DEFAULT_STRATEGY);
	99	}
	100
	101	char oesc_msg(char buf, int oesc);
	102
	103	#endif /* DFLTCC_UTIL_H */

lib/zlib_inflate/inflate.c+24−8

 #include "inffast.h"
 #include "infutil.h"
+/* architecture-specific bits */
+#ifdef CONFIG_ZLIB_DFLTCC
+#  include "../zlib_dfltcc/dfltcc.h"
+#else
+#define INFLATE_RESET_HOOK(strm) do {} while (0)
+#define INFLATE_TYPEDO_HOOK(strm, flush) do {} while (0)
+#define INFLATE_NEED_UPDATEWINDOW(strm) 1
+#define INFLATE_NEED_CHECKSUM(strm) 1
+#endif
 int zlib_inflate_workspacesize(void)
 {
     return sizeof(struct inflate_workspace);
     state->write = 0;
     state->whave = 0;
+    INFLATE_RESET_HOOK(strm);
     return Z_OK;
 }
         return Z_STREAM_ERROR;
     }
     state->wbits = (unsigned)windowBits;
+#ifdef CONFIG_ZLIB_DFLTCC
+    /*
+     * DFLTCC requires the window to be page aligned.
+     * Thus, we overallocate and take the aligned portion of the buffer.
+     */
+    state->window = PTR_ALIGN(&WS(strm)->working_window[0], PAGE_SIZE);
+#else
     state->window = &WS(strm)->working_window[0];
+#endif
     return zlib_inflateReset(strm);
 }
         bits -= bits & 7; \
     } while (0)
-/* Reverse the bytes in a 32-bit value */
-#define REVERSE(q) \
-    ((((q) >> 24) & 0xff) + (((q) >> 8) & 0xff00) + \
-     (((q) & 0xff00) << 8) + (((q) & 0xff) << 24))
 /*
    inflate() uses a state machine to process as much input data and generate as
    much output data as possible before returning.  The state machine is
             if (flush == Z_BLOCK) goto inf_leave;
 	    /* fall through */
         case TYPEDO:
+            INFLATE_TYPEDO_HOOK(strm, flush);
             if (state->last) {
                 BYTEBITS();
                 state->mode = CHECK;
                 out -= left;
                 strm->total_out += out;
                 state->total += out;
-                if (out)
+                if (INFLATE_NEED_CHECKSUM(strm) && out)
                     strm->adler = state->check =
                         UPDATE(state->check, put - out, out);
                 out = left;
      */
   inf_leave:
     RESTORE();
-    if (state->wsize || (state->mode < CHECK && out != strm->avail_out))
+    if (INFLATE_NEED_UPDATEWINDOW(strm) &&
+            (state->wsize || (state->mode < CHECK && out != strm->avail_out)))
         zlib_updatewindow(strm, out);
     in -= strm->avail_in;
     strm->total_in += in;
     strm->total_out += out;
     state->total += out;
-    if (state->wrap && out)
+    if (INFLATE_NEED_CHECKSUM(strm) && state->wrap && out)
         strm->adler = state->check =
             UPDATE(state->check, strm->next_out - out, out);

lib/zlib_inflate/inflate.h+8−0

    subject to change. Applications should only use zlib.h.
  */
+#include "inftrees.h"
 /* Possible inflate modes between inflate() calls */
 typedef enum {
     HEAD,       /* i: waiting for magic header */
     unsigned short work[288];   /* work area for code table building */
     code codes[ENOUGH];         /* space for code tables */
 };
+/* Reverse the bytes in a 32-bit value */
+#define REVERSE(q) \
+    ((((q) >> 24) & 0xff) + (((q) >> 8) & 0xff00) + \
+     (((q) & 0xff00) << 8) + (((q) & 0xff) << 24))
 #endif

lib/zlib_inflate/infutil.h+16−2

 #define _INFUTIL_H
 #include <linux/zlib.h>
+#ifdef CONFIG_ZLIB_DFLTCC
+#include "../zlib_dfltcc/dfltcc.h"
+#include <asm/page.h>
+#endif
 /* memory allocation for inflation */
 struct inflate_workspace {
 	struct inflate_state inflate_state;
-	unsigned char working_window[1 << MAX_WBITS];
+#ifdef CONFIG_ZLIB_DFLTCC
+	struct dfltcc_state dfltcc_state;
+	unsigned char working_window[(1 << MAX_WBITS) + PAGE_SIZE];
+#else
+	unsigned char working_window[(1 << MAX_WBITS)];
+#endif
 };
-#define WS(z) ((struct inflate_workspace *)(z->workspace))
+#ifdef CONFIG_ZLIB_DFLTCC
+/* dfltcc_state must be doubleword aligned for DFLTCC call */
+static_assert(offsetof(struct inflate_workspace, dfltcc_state) % 8 == 0);
+#endif
+#define WS(strm) ((struct inflate_workspace *)(strm->workspace))
 #endif

mm/Makefile+1−0

@@ -20,6 +20,7 @@ KCOV_INSTRUMENT_kmemleak.o := n · 19 unmodified lines
20	KCOV_INSTRUMENT_memcontrol.o := n	20	KCOV_INSTRUMENT_memcontrol.o := n
21	KCOV_INSTRUMENT_mmzone.o := n	21	KCOV_INSTRUMENT_mmzone.o := n
22	KCOV_INSTRUMENT_vmstat.o := n	22	KCOV_INSTRUMENT_vmstat.o := n
		23	KCOV_INSTRUMENT_failslab.o := n
23		24
24	CFLAGS_init-mm.o += $(call cc-disable-warning, override-init)	25	CFLAGS_init-mm.o += $(call cc-disable-warning, override-init)
25	CFLAGS_init-mm.o += $(call cc-disable-warning, initializer-overrides)	26	CFLAGS_init-mm.o += $(call cc-disable-warning, initializer-overrides)

mm/backing-dev.c+1−0

@@ -21,6 +21,7 @@ struct backing_dev_info noop_backing_dev_info = { · 20 unmodified lines
21	EXPORT_SYMBOL_GPL(noop_backing_dev_info);	21	EXPORT_SYMBOL_GPL(noop_backing_dev_info);
22		22
23	static struct class *bdi_class;	23	static struct class *bdi_class;
		24	const char *bdi_unknown_name = "(unknown)";
24		25
25	/*	26	/*
26	* bdi_lock protects bdi_tree and updates to bdi_list. bdi_list has RCU	27	* bdi_lock protects bdi_tree and updates to bdi_list. bdi_list has RCU

mm/debug.c+13−3

 {
 	struct address_space *mapping;
 	bool page_poisoned = PagePoisoned(page);
+	/*
+	 * Accessing the pageblock without the zone lock. It could change to
+	 * "isolate" again in the meantime, but since we are just dumping the
+	 * state for debugging, it should be fine to accept a bit of
+	 * inaccuracy here due to racing.
+	 */
+	bool page_cma = is_migrate_cma_page(page);
 	int mapcount;
+	char *type = "";
 	/*
 	 * If struct page is poisoned don't access Page*() functions as that
 			page, page_ref_count(page), mapcount,
 			page->mapping, page_to_pgoff(page));
 	if (PageKsm(page))
-		pr_warn("ksm flags: %#lx(%pGp)\n", page->flags, &page->flags);
+		type = "ksm ";
 	else if (PageAnon(page))
-		pr_warn("anon flags: %#lx(%pGp)\n", page->flags, &page->flags);
+		type = "anon ";
 	else if (mapping) {
 		if (mapping->host && mapping->host->i_dentry.first) {
 			struct dentry *dentry;
 			pr_warn("%ps name:\"%pd\"\n", mapping->a_ops, dentry);
 		} else
 			pr_warn("%ps\n", mapping->a_ops);
-		pr_warn("flags: %#lx(%pGp)\n", page->flags, &page->flags);
 	}
 	BUILD_BUG_ON(ARRAY_SIZE(pageflag_names) != __NR_PAGEFLAGS + 1);
+	pr_warn("%sflags: %#lx(%pGp)%s\n", type, page->flags, &page->flags,
+		page_cma ? " CMA" : "");
 hex_only:
 	print_hex_dump(KERN_WARNING, "raw: ", DUMP_PREFIX_NONE, 32,
 			sizeof(unsigned long), page,

mm/early_ioremap.c+4−4

@@ -121,8 +121,8 @@ __early_ioremap(resource_size_t phys_addr, unsigned long size, pgprot_t prot) · 120 unmodified lines
121	}	121	}
122	}	122	}
123		123
124	if (WARN(slot < 0, "%s(%08llx, %08lx) not found slot\n",	124	if (WARN(slot < 0, "%s(%pa, %08lx) not found slot\n",
125	__func__, (u64)phys_addr, size))	125	__func__, &phys_addr, size))
126	return NULL;	126	return NULL;
127		127
128	/* Don't allow wraparound or zero size */	128	/* Don't allow wraparound or zero size */
@@ -158,8 +158,8 @@ __early_ioremap(resource_size_t phys_addr, unsigned long size, pgprot_t prot) · 29 unmodified lines
158	--idx;	158	--idx;
159	--nrpages;	159	--nrpages;
160	}	160	}
161	WARN(early_ioremap_debug, "%s(%08llx, %08lx) [%d] => %08lx + %08lx\n",	161	WARN(early_ioremap_debug, "%s(%pa, %08lx) [%d] => %08lx + %08lx\n",
162	__func__, (u64)phys_addr, size, slot, offset, slot_virt[slot]);	162	__func__, &phys_addr, size, slot, offset, slot_virt[slot]);
163		163
164	prev_map[slot] = (void __iomem *)(offset + slot_virt[slot]);	164	prev_map[slot] = (void __iomem *)(offset + slot_virt[slot]);
165	return prev_map[slot];	165	return prev_map[slot];

mm/filemap.c+6−28

@@ -632,33 +632,6 @@ static bool mapping_needs_writeback(struct address_space *mapping) · 631 unmodified lines
632	return mapping->nrpages;	632	return mapping->nrpages;
633	}	633	}
634		634
635	int filemap_write_and_wait(struct address_space *mapping)
636	{
637	int err = 0;
638
639	if (mapping_needs_writeback(mapping)) {
640	err = filemap_fdatawrite(mapping);
641	/*
642	* Even if the above returned error, the pages may be
643	* written partially (e.g. -ENOSPC), so we wait for it.
644	* But the -EIO is special case, it may indicate the worst
645	* thing (e.g. bug) happened, so we avoid waiting for it.
646	*/
647	if (err != -EIO) {
648	int err2 = filemap_fdatawait(mapping);
649	if (!err)
650	err = err2;
651	} else {
652	/* Clear any previously stored errors */
653	filemap_check_errors(mapping);
654	}
655	} else {
656	err = filemap_check_errors(mapping);
657	}
658	return err;
659	}
660	EXPORT_SYMBOL(filemap_write_and_wait);
661
662	/**	635	/**
663	* filemap_write_and_wait_range - write out & wait on a file range	636	* filemap_write_and_wait_range - write out & wait on a file range
664	* @mapping: the address_space for the pages	637	* @mapping: the address_space for the pages
@@ -680,7 +653,12 @@ int filemap_write_and_wait_range(struct address_space *mapping, · 15 unmodified lines
680	if (mapping_needs_writeback(mapping)) {	653	if (mapping_needs_writeback(mapping)) {
681	err = __filemap_fdatawrite_range(mapping, lstart, lend,	654	err = __filemap_fdatawrite_range(mapping, lstart, lend,
682	WB_SYNC_ALL);	655	WB_SYNC_ALL);
683	/* See comment of filemap_write_and_wait() */	656	/*
		657	* Even if the above returned error, the pages may be
		658	* written partially (e.g. -ENOSPC), so we wait for it.
		659	* But the -EIO is special case, it may indicate the worst
		660	* thing (e.g. bug) happened, so we avoid waiting for it.
		661	*/
684	if (err != -EIO) {	662	if (err != -EIO) {
685	int err2 = filemap_fdatawait_range(mapping,	663	int err2 = filemap_fdatawait_range(mapping,
686	lstart, lend);	664	lstart, lend);

mm/gup.c+310−191

@@ -29,8 +29,23 @@ struct follow_page_context { · 28 unmodified lines
29	unsigned int page_mask;	29	unsigned int page_mask;
30	};	30	};
31		31
		32	/*
		33	* Return the compound head page with ref appropriately incremented,
		34	* or NULL if that failed.
		35	*/
		36	static inline struct page try_get_compound_head(struct page page, int refs)
		37	{
		38	struct page *head = compound_head(page);
		39
		40	if (WARN_ON_ONCE(page_ref_count(head) < 0))
		41	return NULL;
		42	if (unlikely(!page_cache_add_speculative(head, refs)))
		43	return NULL;
		44	return head;
		45	}
		46
32	/**	47	/**
33	* put_user_pages_dirty_lock() - release and optionally dirty gup-pinned pages	48	* unpin_user_pages_dirty_lock() - release and optionally dirty gup-pinned pages
34	* @pages: array of pages to be maybe marked dirty, and definitely released.	49	* @pages: array of pages to be maybe marked dirty, and definitely released.
35	* @npages: number of pages in the @pages array.	50	* @npages: number of pages in the @pages array.
36	* @make_dirty: whether to mark the pages dirty	51	* @make_dirty: whether to mark the pages dirty
@@ -40,19 +55,19 @@ struct follow_page_context { · 3 unmodified lines
40	*	55	*
41	* For each page in the @pages array, make that page (or its head page, if a	56	* For each page in the @pages array, make that page (or its head page, if a
42	* compound page) dirty, if @make_dirty is true, and if the page was previously	57	* compound page) dirty, if @make_dirty is true, and if the page was previously
43	* listed as clean. In any case, releases all pages using put_user_page(),	58	* listed as clean. In any case, releases all pages using unpin_user_page(),
44	* possibly via put_user_pages(), for the non-dirty case.	59	* possibly via unpin_user_pages(), for the non-dirty case.
45	*	60	*
46	* Please see the put_user_page() documentation for details.	61	* Please see the unpin_user_page() documentation for details.
47	*	62	*
48	* set_page_dirty_lock() is used internally. If instead, set_page_dirty() is	63	* set_page_dirty_lock() is used internally. If instead, set_page_dirty() is
49	* required, then the caller should a) verify that this is really correct,	64	* required, then the caller should a) verify that this is really correct,
50	* because _lock() is usually required, and b) hand code it:	65	* because _lock() is usually required, and b) hand code it:
51	* set_page_dirty_lock(), put_user_page().	66	* set_page_dirty_lock(), unpin_user_page().
52	*	67	*
53	*/	68	*/
54	void put_user_pages_dirty_lock(struct page **pages, unsigned long npages,	69	void unpin_user_pages_dirty_lock(struct page **pages, unsigned long npages,
55	bool make_dirty)	70	bool make_dirty)
56	{	71	{
57	unsigned long index;	72	unsigned long index;
58		73
@@ -63,7 +78,7 @@ void put_user_pages_dirty_lock(struct page **pages, unsigned long npages, · 4 unmodified lines
63	*/	78	*/
64		79
65	if (!make_dirty) {	80	if (!make_dirty) {
66	put_user_pages(pages, npages);	81	unpin_user_pages(pages, npages);
67	return;	82	return;
68	}	83	}
69		84
@@ -91,21 +106,21 @@ void put_user_pages_dirty_lock(struct page **pages, unsigned long npages, · 21 unmodified lines
91	*/	106	*/
92	if (!PageDirty(page))	107	if (!PageDirty(page))
93	set_page_dirty_lock(page);	108	set_page_dirty_lock(page);
94	put_user_page(page);	109	unpin_user_page(page);
95	}	110	}
96	}	111	}
97	EXPORT_SYMBOL(put_user_pages_dirty_lock);	112	EXPORT_SYMBOL(unpin_user_pages_dirty_lock);
98		113
99	/**	114	/**
100	* put_user_pages() - release an array of gup-pinned pages.	115	* unpin_user_pages() - release an array of gup-pinned pages.
101	* @pages: array of pages to be marked dirty and released.	116	* @pages: array of pages to be marked dirty and released.
102	* @npages: number of pages in the @pages array.	117	* @npages: number of pages in the @pages array.
103	*	118	*
104	* For each page in the @pages array, release the page using put_user_page().	119	* For each page in the @pages array, release the page using unpin_user_page().
105	*	120	*
106	* Please see the put_user_page() documentation for details.	121	* Please see the unpin_user_page() documentation for details.
107	*/	122	*/
108	void put_user_pages(struct page **pages, unsigned long npages)	123	void unpin_user_pages(struct page **pages, unsigned long npages)
109	{	124	{
110	unsigned long index;	125	unsigned long index;
111		126
@@ -115,9 +130,9 @@ void put_user_pages(struct page **pages, unsigned long npages) · 3 unmodified lines
115	* single operation to the head page should suffice.	130	* single operation to the head page should suffice.
116	*/	131	*/
117	for (index = 0; index < npages; index++)	132	for (index = 0; index < npages; index++)
118	put_user_page(pages[index]);	133	unpin_user_page(pages[index]);
119	}	134	}
120	EXPORT_SYMBOL(put_user_pages);	135	EXPORT_SYMBOL(unpin_user_pages);
121		136
122	#ifdef CONFIG_MMU	137	#ifdef CONFIG_MMU
123	static struct page no_page_table(struct vm_area_struct vma,	138	static struct page no_page_table(struct vm_area_struct vma,
@@ -179,6 +194,10 @@ static struct page follow_page_pte(struct vm_area_struct vma, · 55 unmodified lines
179	spinlock_t *ptl;	194	spinlock_t *ptl;
180	pte_t *ptep, pte;	195	pte_t *ptep, pte;
181		196
		197	/* FOLL_GET and FOLL_PIN are mutually exclusive. */
		198	if (WARN_ON_ONCE((flags & (FOLL_PIN \| FOLL_GET)) ==
		199	(FOLL_PIN \| FOLL_GET)))
		200	return ERR_PTR(-EINVAL);
182	retry:	201	retry:
183	if (unlikely(pmd_bad(*pmd)))	202	if (unlikely(pmd_bad(*pmd)))
184	return no_page_table(vma, flags);	203	return no_page_table(vma, flags);
@@ -323,7 +342,7 @@ static struct page follow_pmd_mask(struct vm_area_struct vma, · 138 unmodified lines
323	pmdval = READ_ONCE(*pmd);	342	pmdval = READ_ONCE(*pmd);
324	if (pmd_none(pmdval))	343	if (pmd_none(pmdval))
325	return no_page_table(vma, flags);	344	return no_page_table(vma, flags);
326	if (pmd_huge(pmdval) && vma->vm_flags & VM_HUGETLB) {	345	if (pmd_huge(pmdval) && is_vm_hugetlb_page(vma)) {
327	page = follow_huge_pmd(mm, address, pmd, flags);	346	page = follow_huge_pmd(mm, address, pmd, flags);
328	if (page)	347	if (page)
329	return page;	348	return page;
@@ -433,7 +452,7 @@ static struct page follow_pud_mask(struct vm_area_struct vma, · 103 unmodified lines
433	pud = pud_offset(p4dp, address);	452	pud = pud_offset(p4dp, address);
434	if (pud_none(*pud))	453	if (pud_none(*pud))
435	return no_page_table(vma, flags);	454	return no_page_table(vma, flags);
436	if (pud_huge(*pud) && vma->vm_flags & VM_HUGETLB) {	455	if (pud_huge(*pud) && is_vm_hugetlb_page(vma)) {
437	page = follow_huge_pud(mm, address, pud, flags);	456	page = follow_huge_pud(mm, address, pud, flags);
438	if (page)	457	if (page)
439	return page;	458	return page;
@@ -796,7 +815,7 @@ static long __get_user_pages(struct task_struct tsk, struct mm_struct mm, · 356 unmodified lines
796		815
797	start = untagged_addr(start);	816	start = untagged_addr(start);
798		817
799	VM_BUG_ON(!!pages != !!(gup_flags & FOLL_GET));	818	VM_BUG_ON(!!pages != !!(gup_flags & (FOLL_GET \| FOLL_PIN)));
800		819
801	/*	820	/*
802	* If FOLL_FORCE is set then do not force a full fault as the hinting	821	* If FOLL_FORCE is set then do not force a full fault as the hinting
@@ -1020,7 +1039,16 @@ static __always_inline long __get_user_pages_locked(struct task_struct *tsk, · 217 unmodified lines
1020	BUG_ON(*locked != 1);	1039	BUG_ON(*locked != 1);
1021	}	1040	}
1022		1041
1023	if (pages)	1042	/*
		1043	* FOLL_PIN and FOLL_GET are mutually exclusive. Traditional behavior
		1044	* is to set FOLL_GET if the caller wants pages[] filled in (but has
		1045	* carelessly failed to specify FOLL_GET), so keep doing that, but only
		1046	* for FOLL_GET, not for the newer FOLL_PIN.
		1047	*
		1048	* FOLL_PIN always expects pages to be non-null, but no need to assert
		1049	* that here, as any failures will be obvious enough.
		1050	*/
		1051	if (pages && !(flags & FOLL_PIN))
1024	flags \|= FOLL_GET;	1052	flags \|= FOLL_GET;
1025		1053
1026	pages_done = 0;	1054	pages_done = 0;
@@ -1096,88 +1124,6 @@ static __always_inline long __get_user_pages_locked(struct task_struct *tsk, · 69 unmodified lines
1096	return pages_done;	1124	return pages_done;
1097	}	1125	}
1098		1126
1099	/*
1100	* get_user_pages_remote() - pin user pages in memory
1101	* @tsk: the task_struct to use for page fault accounting, or
1102	* NULL if faults are not to be recorded.
1103	* @mm: mm_struct of target mm
1104	* @start: starting user address
1105	* @nr_pages: number of pages from start to pin
1106	* @gup_flags: flags modifying lookup behaviour
1107	* @pages: array that receives pointers to the pages pinned.
1108	* Should be at least nr_pages long. Or NULL, if caller
1109	* only intends to ensure the pages are faulted in.
1110	* @vmas: array of pointers to vmas corresponding to each page.
1111	* Or NULL if the caller does not require them.
1112	* @locked: pointer to lock flag indicating whether lock is held and
1113	* subsequently whether VM_FAULT_RETRY functionality can be
1114	* utilised. Lock must initially be held.
1115	*
1116	* Returns either number of pages pinned (which may be less than the
1117	* number requested), or an error. Details about the return value:
1118	*
1119	* -- If nr_pages is 0, returns 0.
1120	* -- If nr_pages is >0, but no pages were pinned, returns -errno.
1121	* -- If nr_pages is >0, and some pages were pinned, returns the number of
1122	* pages pinned. Again, this may be less than nr_pages.
1123	*
1124	* The caller is responsible for releasing returned @pages, via put_page().
1125	*
1126	* @vmas are valid only as long as mmap_sem is held.
1127	*
1128	* Must be called with mmap_sem held for read or write.
1129	*
1130	* get_user_pages walks a process's page tables and takes a reference to
1131	* each struct page that each user address corresponds to at a given
1132	* instant. That is, it takes the page that would be accessed if a user
1133	* thread accesses the given user virtual address at that instant.
1134	*
1135	* This does not guarantee that the page exists in the user mappings when
1136	* get_user_pages returns, and there may even be a completely different
1137	* page there in some cases (eg. if mmapped pagecache has been invalidated
1138	* and subsequently re faulted). However it does guarantee that the page
1139	* won't be freed completely. And mostly callers simply care that the page
1140	* contains data that was valid at some point in time. Typically, an IO
1141	* or similar operation cannot guarantee anything stronger anyway because
1142	* locks can't be held over the syscall boundary.
1143	*
1144	* If gup_flags & FOLL_WRITE == 0, the page must not be written to. If the page
1145	* is written to, set_page_dirty (or set_page_dirty_lock, as appropriate) must
1146	* be called after the page is finished with, and before put_page is called.
1147	*
1148	* get_user_pages is typically used for fewer-copy IO operations, to get a
1149	* handle on the memory by some means other than accesses via the user virtual
1150	* addresses. The pages may be submitted for DMA to devices or accessed via
1151	* their kernel linear mapping (via the kmap APIs). Care should be taken to
1152	* use the correct cache flushing APIs.
1153	*
1154	* See also get_user_pages_fast, for performance critical applications.
1155	*
1156	* get_user_pages should be phased out in favor of
1157	* get_user_pages_locked\|unlocked or get_user_pages_fast. Nothing
1158	* should use get_user_pages because it cannot pass
1159	* FAULT_FLAG_ALLOW_RETRY to handle_mm_fault.
1160	*/
1161	long get_user_pages_remote(struct task_struct tsk, struct mm_struct mm,
1162	unsigned long start, unsigned long nr_pages,
1163	unsigned int gup_flags, struct page **pages,
1164	struct vm_area_struct *vmas, int locked)
1165	{
1166	/*
1167	* FIXME: Current FOLL_LONGTERM behavior is incompatible with
1168	* FAULT_FLAG_ALLOW_RETRY because of the FS DAX check requirement on
1169	* vmas. As there are no users of this flag in this call we simply
1170	* disallow this option for now.
1171	*/
1172	if (WARN_ON_ONCE(gup_flags & FOLL_LONGTERM))
1173	return -EINVAL;
1174
1175	return __get_user_pages_locked(tsk, mm, start, nr_pages, pages, vmas,
1176	locked,
1177	gup_flags \| FOLL_TOUCH \| FOLL_REMOTE);
1178	}
1179	EXPORT_SYMBOL(get_user_pages_remote);
1180
1181	/**	1127	/**
1182	* populate_vma_page_range() - populate a range of pages in the vma.	1128	* populate_vma_page_range() - populate a range of pages in the vma.
1183	* @vma: target vma	1129	* @vma: target vma
@@ -1611,6 +1557,116 @@ static __always_inline long __gup_longterm_locked(struct task_struct *tsk, · 427 unmodified lines
1611	}	1557	}
1612	#endif /* CONFIG_FS_DAX \|\| CONFIG_CMA */	1558	#endif /* CONFIG_FS_DAX \|\| CONFIG_CMA */
1613		1559
		1560	/*
		1561	* get_user_pages_remote() - pin user pages in memory
		1562	* @tsk: the task_struct to use for page fault accounting, or
		1563	* NULL if faults are not to be recorded.
		1564	* @mm: mm_struct of target mm
		1565	* @start: starting user address
		1566	* @nr_pages: number of pages from start to pin
		1567	* @gup_flags: flags modifying lookup behaviour
		1568	* @pages: array that receives pointers to the pages pinned.
		1569	* Should be at least nr_pages long. Or NULL, if caller
		1570	* only intends to ensure the pages are faulted in.
		1571	* @vmas: array of pointers to vmas corresponding to each page.
		1572	* Or NULL if the caller does not require them.
		1573	* @locked: pointer to lock flag indicating whether lock is held and
		1574	* subsequently whether VM_FAULT_RETRY functionality can be
		1575	* utilised. Lock must initially be held.
		1576	*
		1577	* Returns either number of pages pinned (which may be less than the
		1578	* number requested), or an error. Details about the return value:
		1579	*
		1580	* -- If nr_pages is 0, returns 0.
		1581	* -- If nr_pages is >0, but no pages were pinned, returns -errno.
		1582	* -- If nr_pages is >0, and some pages were pinned, returns the number of
		1583	* pages pinned. Again, this may be less than nr_pages.
		1584	*
		1585	* The caller is responsible for releasing returned @pages, via put_page().
		1586	*
		1587	* @vmas are valid only as long as mmap_sem is held.
		1588	*
		1589	* Must be called with mmap_sem held for read or write.
		1590	*
		1591	* get_user_pages walks a process's page tables and takes a reference to
		1592	* each struct page that each user address corresponds to at a given
		1593	* instant. That is, it takes the page that would be accessed if a user
		1594	* thread accesses the given user virtual address at that instant.
		1595	*
		1596	* This does not guarantee that the page exists in the user mappings when
		1597	* get_user_pages returns, and there may even be a completely different
		1598	* page there in some cases (eg. if mmapped pagecache has been invalidated
		1599	* and subsequently re faulted). However it does guarantee that the page
		1600	* won't be freed completely. And mostly callers simply care that the page
		1601	* contains data that was valid at some point in time. Typically, an IO
		1602	* or similar operation cannot guarantee anything stronger anyway because
		1603	* locks can't be held over the syscall boundary.
		1604	*
		1605	* If gup_flags & FOLL_WRITE == 0, the page must not be written to. If the page
		1606	* is written to, set_page_dirty (or set_page_dirty_lock, as appropriate) must
		1607	* be called after the page is finished with, and before put_page is called.
		1608	*
		1609	* get_user_pages is typically used for fewer-copy IO operations, to get a
		1610	* handle on the memory by some means other than accesses via the user virtual
		1611	* addresses. The pages may be submitted for DMA to devices or accessed via
		1612	* their kernel linear mapping (via the kmap APIs). Care should be taken to
		1613	* use the correct cache flushing APIs.
		1614	*
		1615	* See also get_user_pages_fast, for performance critical applications.
		1616	*
		1617	* get_user_pages should be phased out in favor of
		1618	* get_user_pages_locked\|unlocked or get_user_pages_fast. Nothing
		1619	* should use get_user_pages because it cannot pass
		1620	* FAULT_FLAG_ALLOW_RETRY to handle_mm_fault.
		1621	*/
		1622	#ifdef CONFIG_MMU
		1623	long get_user_pages_remote(struct task_struct tsk, struct mm_struct mm,
		1624	unsigned long start, unsigned long nr_pages,
		1625	unsigned int gup_flags, struct page **pages,
		1626	struct vm_area_struct *vmas, int locked)
		1627	{
		1628	/*
		1629	* FOLL_PIN must only be set internally by the pin_user_pages*() APIs,
		1630	* never directly by the caller, so enforce that with an assertion:
		1631	*/
		1632	if (WARN_ON_ONCE(gup_flags & FOLL_PIN))
		1633	return -EINVAL;
		1634
		1635	/*
		1636	* Parts of FOLL_LONGTERM behavior are incompatible with
		1637	* FAULT_FLAG_ALLOW_RETRY because of the FS DAX check requirement on
		1638	* vmas. However, this only comes up if locked is set, and there are
		1639	* callers that do request FOLL_LONGTERM, but do not set locked. So,
		1640	* allow what we can.
		1641	*/
		1642	if (gup_flags & FOLL_LONGTERM) {
		1643	if (WARN_ON_ONCE(locked))
		1644	return -EINVAL;
		1645	/*
		1646	* This will check the vmas (even if our vmas arg is NULL)
		1647	* and return -ENOTSUPP if DAX isn't allowed in this case:
		1648	*/
		1649	return __gup_longterm_locked(tsk, mm, start, nr_pages, pages,
		1650	vmas, gup_flags \| FOLL_TOUCH \|
		1651	FOLL_REMOTE);
		1652	}
		1653
		1654	return __get_user_pages_locked(tsk, mm, start, nr_pages, pages, vmas,
		1655	locked,
		1656	gup_flags \| FOLL_TOUCH \| FOLL_REMOTE);
		1657	}
		1658	EXPORT_SYMBOL(get_user_pages_remote);
		1659
		1660	#else /* CONFIG_MMU */
		1661	long get_user_pages_remote(struct task_struct tsk, struct mm_struct mm,
		1662	unsigned long start, unsigned long nr_pages,
		1663	unsigned int gup_flags, struct page **pages,
		1664	struct vm_area_struct *vmas, int locked)
		1665	{
		1666	return 0;
		1667	}
		1668	#endif /* !CONFIG_MMU */
		1669
1614	/*	1670	/*
1615	* This is the same as get_user_pages_remote(), just with a	1671	* This is the same as get_user_pages_remote(), just with a
1616	* less-flexible calling convention where we assume that the task	1672	* less-flexible calling convention where we assume that the task
@@ -1622,6 +1678,13 @@ long get_user_pages(unsigned long start, unsigned long nr_pages, · 5 unmodified lines
1622	unsigned int gup_flags, struct page **pages,	1678	unsigned int gup_flags, struct page **pages,
1623	struct vm_area_struct **vmas)	1679	struct vm_area_struct **vmas)
1624	{	1680	{
		1681	/*
		1682	* FOLL_PIN must only be set internally by the pin_user_pages*() APIs,
		1683	* never directly by the caller, so enforce that with an assertion:
		1684	*/
		1685	if (WARN_ON_ONCE(gup_flags & FOLL_PIN))
		1686	return -EINVAL;
		1687
1625	return __gup_longterm_locked(current, current->mm, start, nr_pages,	1688	return __gup_longterm_locked(current, current->mm, start, nr_pages,
1626	pages, vmas, gup_flags \| FOLL_TOUCH);	1689	pages, vmas, gup_flags \| FOLL_TOUCH);
1627	}	1690	}
@@ -1807,20 +1870,6 @@ static void __maybe_unused undo_dev_pagemap(int *nr, int nr_start, · 179 unmodified lines
1807	}	1870	}
1808	}	1871	}
1809		1872
1810	/*
1811	* Return the compund head page with ref appropriately incremented,
1812	* or NULL if that failed.
1813	*/
1814	static inline struct page try_get_compound_head(struct page page, int refs)
1815	{
1816	struct page *head = compound_head(page);
1817	if (WARN_ON_ONCE(page_ref_count(head) < 0))
1818	return NULL;
1819	if (unlikely(!page_cache_add_speculative(head, refs)))
1820	return NULL;
1821	return head;
1822	}
1823
1824	#ifdef CONFIG_ARCH_HAS_PTE_SPECIAL	1873	#ifdef CONFIG_ARCH_HAS_PTE_SPECIAL
1825	static int gup_pte_range(pmd_t pmd, unsigned long addr, unsigned long end,	1874	static int gup_pte_range(pmd_t pmd, unsigned long addr, unsigned long end,
1826	unsigned int flags, struct page *pages, int nr)	1875	unsigned int flags, struct page *pages, int nr)
@@ -1978,6 +2027,29 @@ static int __gup_device_huge_pud(pud_t pud, pud_t *pudp, unsigned long addr, · 151 unmodified lines
1978	}	2027	}
1979	#endif	2028	#endif
1980		2029
		2030	static int record_subpages(struct page *page, unsigned long addr,
		2031	unsigned long end, struct page **pages)
		2032	{
		2033	int nr;
		2034
		2035	for (nr = 0; addr != end; addr += PAGE_SIZE)
		2036	pages[nr++] = page++;
		2037
		2038	return nr;
		2039	}
		2040
		2041	static void put_compound_head(struct page *page, int refs)
		2042	{
		2043	VM_BUG_ON_PAGE(page_ref_count(page) < refs, page);
		2044	/*
		2045	* Calling put_page() for each ref is unnecessarily slow. Only the last
		2046	* ref needs a put_page().
		2047	*/
		2048	if (refs > 1)
		2049	page_ref_sub(page, refs - 1);
		2050	put_page(page);
		2051	}
		2052
1981	#ifdef CONFIG_ARCH_HAS_HUGEPD	2053	#ifdef CONFIG_ARCH_HAS_HUGEPD
1982	static unsigned long hugepte_addr_end(unsigned long addr, unsigned long end,	2054	static unsigned long hugepte_addr_end(unsigned long addr, unsigned long end,
1983	unsigned long sz)	2055	unsigned long sz)
@@ -2007,32 +2079,20 @@ static int gup_hugepte(pte_t *ptep, unsigned long sz, unsigned long addr, · 23 unmodified lines
2007	/* hugepages are never "special" */	2079	/* hugepages are never "special" */
2008	VM_BUG_ON(!pfn_valid(pte_pfn(pte)));	2080	VM_BUG_ON(!pfn_valid(pte_pfn(pte)));
2009		2081
2010	refs = 0;
2011	head = pte_page(pte);	2082	head = pte_page(pte);
2012
2013	page = head + ((addr & (sz-1)) >> PAGE_SHIFT);	2083	page = head + ((addr & (sz-1)) >> PAGE_SHIFT);
2014	do {	2084	refs = record_subpages(page, addr, end, pages + *nr);
2015	VM_BUG_ON(compound_head(page) != head);
2016	pages[*nr] = page;
2017	(*nr)++;
2018	page++;
2019	refs++;
2020	} while (addr += PAGE_SIZE, addr != end);
2021		2085
2022	head = try_get_compound_head(head, refs);	2086	head = try_get_compound_head(head, refs);
2023	if (!head) {	2087	if (!head)
2024	*nr -= refs;
2025	return 0;	2088	return 0;
2026	}
2027		2089
2028	if (unlikely(pte_val(pte) != pte_val(*ptep))) {	2090	if (unlikely(pte_val(pte) != pte_val(*ptep))) {
2029	/* Could be optimized better */	2091	put_compound_head(head, refs);
2030	*nr -= refs;
2031	while (refs--)
2032	put_page(head);
2033	return 0;	2092	return 0;
2034	}	2093	}
2035		2094
		2095	*nr += refs;
2036	SetPageReferenced(head);	2096	SetPageReferenced(head);
2037	return 1;	2097	return 1;
2038	}	2098	}
@@ -2079,28 +2139,19 @@ static int gup_huge_pmd(pmd_t orig, pmd_t *pmdp, unsigned long addr, · 40 unmodified lines
2079	return __gup_device_huge_pmd(orig, pmdp, addr, end, pages, nr);	2139	return __gup_device_huge_pmd(orig, pmdp, addr, end, pages, nr);
2080	}	2140	}
2081		2141
2082	refs = 0;
2083	page = pmd_page(orig) + ((addr & ~PMD_MASK) >> PAGE_SHIFT);	2142	page = pmd_page(orig) + ((addr & ~PMD_MASK) >> PAGE_SHIFT);
2084	do {	2143	refs = record_subpages(page, addr, end, pages + *nr);
2085	pages[*nr] = page;
2086	(*nr)++;
2087	page++;
2088	refs++;
2089	} while (addr += PAGE_SIZE, addr != end);
2090		2144
2091	head = try_get_compound_head(pmd_page(orig), refs);	2145	head = try_get_compound_head(pmd_page(orig), refs);
2092	if (!head) {	2146	if (!head)
2093	*nr -= refs;
2094	return 0;	2147	return 0;
2095	}
2096		2148
2097	if (unlikely(pmd_val(orig) != pmd_val(*pmdp))) {	2149	if (unlikely(pmd_val(orig) != pmd_val(*pmdp))) {
2098	*nr -= refs;	2150	put_compound_head(head, refs);
2099	while (refs--)
2100	put_page(head);
2101	return 0;	2151	return 0;
2102	}	2152	}
2103		2153
		2154	*nr += refs;
2104	SetPageReferenced(head);	2155	SetPageReferenced(head);
2105	return 1;	2156	return 1;
2106	}	2157	}
@@ -2120,28 +2171,19 @@ static int gup_huge_pud(pud_t orig, pud_t *pudp, unsigned long addr, · 13 unmodified lines
2120	return __gup_device_huge_pud(orig, pudp, addr, end, pages, nr);	2171	return __gup_device_huge_pud(orig, pudp, addr, end, pages, nr);
2121	}	2172	}
2122		2173
2123	refs = 0;
2124	page = pud_page(orig) + ((addr & ~PUD_MASK) >> PAGE_SHIFT);	2174	page = pud_page(orig) + ((addr & ~PUD_MASK) >> PAGE_SHIFT);
2125	do {	2175	refs = record_subpages(page, addr, end, pages + *nr);
2126	pages[*nr] = page;
2127	(*nr)++;
2128	page++;
2129	refs++;
2130	} while (addr += PAGE_SIZE, addr != end);
2131		2176
2132	head = try_get_compound_head(pud_page(orig), refs);	2177	head = try_get_compound_head(pud_page(orig), refs);
2133	if (!head) {	2178	if (!head)
2134	*nr -= refs;
2135	return 0;	2179	return 0;
2136	}
2137		2180
2138	if (unlikely(pud_val(orig) != pud_val(*pudp))) {	2181	if (unlikely(pud_val(orig) != pud_val(*pudp))) {
2139	*nr -= refs;	2182	put_compound_head(head, refs);
2140	while (refs--)
2141	put_page(head);
2142	return 0;	2183	return 0;
2143	}	2184	}
2144		2185
		2186	*nr += refs;
2145	SetPageReferenced(head);	2187	SetPageReferenced(head);
2146	return 1;	2188	return 1;
2147	}	2189	}
@@ -2157,28 +2199,20 @@ static int gup_huge_pgd(pgd_t orig, pgd_t *pgdp, unsigned long addr, · 9 unmodified lines
2157	return 0;	2199	return 0;
2158		2200
2159	BUILD_BUG_ON(pgd_devmap(orig));	2201	BUILD_BUG_ON(pgd_devmap(orig));
2160	refs = 0;	2202
2161	page = pgd_page(orig) + ((addr & ~PGDIR_MASK) >> PAGE_SHIFT);	2203	page = pgd_page(orig) + ((addr & ~PGDIR_MASK) >> PAGE_SHIFT);
2162	do {	2204	refs = record_subpages(page, addr, end, pages + *nr);
2163	pages[*nr] = page;
2164	(*nr)++;
2165	page++;
2166	refs++;
2167	} while (addr += PAGE_SIZE, addr != end);
2168		2205
2169	head = try_get_compound_head(pgd_page(orig), refs);	2206	head = try_get_compound_head(pgd_page(orig), refs);
2170	if (!head) {	2207	if (!head)
2171	*nr -= refs;
2172	return 0;	2208	return 0;
2173	}
2174		2209
2175	if (unlikely(pgd_val(orig) != pgd_val(*pgdp))) {	2210	if (unlikely(pgd_val(orig) != pgd_val(*pgdp))) {
2176	*nr -= refs;	2211	put_compound_head(head, refs);
2177	while (refs--)
2178	put_page(head);
2179	return 0;	2212	return 0;
2180	}	2213	}
2181		2214
		2215	*nr += refs;
2182	SetPageReferenced(head);	2216	SetPageReferenced(head);
2183	return 1;	2217	return 1;
2184	}	2218	}
@@ -2237,7 +2271,7 @@ static int gup_pud_range(p4d_t p4d, unsigned long addr, unsigned long end, · 52 unmodified lines
2237	pud_t pud = READ_ONCE(*pudp);	2271	pud_t pud = READ_ONCE(*pudp);
2238		2272
2239	next = pud_addr_end(addr, end);	2273	next = pud_addr_end(addr, end);
2240	if (pud_none(pud))	2274	if (unlikely(!pud_present(pud)))
2241	return 0;	2275	return 0;
2242	if (unlikely(pud_huge(pud))) {	2276	if (unlikely(pud_huge(pud))) {
2243	if (!gup_huge_pud(pud, pudp, addr, next, flags,	2277	if (!gup_huge_pud(pud, pudp, addr, next, flags,
@@ -2393,29 +2427,15 @@ static int __gup_longterm_unlocked(unsigned long start, int nr_pages, · 149 unmodified lines
2393	return ret;	2427	return ret;
2394	}	2428	}
2395		2429
2396	/**	2430	static int internal_get_user_pages_fast(unsigned long start, int nr_pages,
2397	* get_user_pages_fast() - pin user pages in memory	2431	unsigned int gup_flags,
2398	* @start: starting user address	2432	struct page **pages)
2399	* @nr_pages: number of pages from start to pin
2400	* @gup_flags: flags modifying pin behaviour
2401	* @pages: array that receives pointers to the pages pinned.
2402	* Should be at least nr_pages long.
2403	*
2404	* Attempt to pin user pages in memory without taking mm->mmap_sem.
2405	* If not successful, it will fall back to taking the lock and
2406	* calling get_user_pages().
2407	*
2408	* Returns number of pages pinned. This may be fewer than the number
2409	* requested. If nr_pages is 0 or negative, returns 0. If no pages
2410	* were pinned, returns -errno.
2411	*/
2412	int get_user_pages_fast(unsigned long start, int nr_pages,
2413	unsigned int gup_flags, struct page **pages)
2414	{	2433	{
2415	unsigned long addr, len, end;	2434	unsigned long addr, len, end;
2416	int nr = 0, ret = 0;	2435	int nr = 0, ret = 0;
2417		2436
2418	if (WARN_ON_ONCE(gup_flags & ~(FOLL_WRITE \| FOLL_LONGTERM)))	2437	if (WARN_ON_ONCE(gup_flags & ~(FOLL_WRITE \| FOLL_LONGTERM \|
		2438	FOLL_FORCE \| FOLL_PIN)))
2419	return -EINVAL;	2439	return -EINVAL;
2420		2440
2421	start = untagged_addr(start) & PAGE_MASK;	2441	start = untagged_addr(start) & PAGE_MASK;
@@ -2455,4 +2475,103 @@ int get_user_pages_fast(unsigned long start, int nr_pages, · 33 unmodified lines
2455		2475
2456	return ret;	2476	return ret;
2457	}	2477	}
		2478
		2479	/**
		2480	* get_user_pages_fast() - pin user pages in memory
		2481	* @start: starting user address
		2482	* @nr_pages: number of pages from start to pin
		2483	* @gup_flags: flags modifying pin behaviour
		2484	* @pages: array that receives pointers to the pages pinned.
		2485	* Should be at least nr_pages long.
		2486	*
		2487	* Attempt to pin user pages in memory without taking mm->mmap_sem.
		2488	* If not successful, it will fall back to taking the lock and
		2489	* calling get_user_pages().
		2490	*
		2491	* Returns number of pages pinned. This may be fewer than the number requested.
		2492	* If nr_pages is 0 or negative, returns 0. If no pages were pinned, returns
		2493	* -errno.
		2494	*/
		2495	int get_user_pages_fast(unsigned long start, int nr_pages,
		2496	unsigned int gup_flags, struct page **pages)
		2497	{
		2498	/*
		2499	* FOLL_PIN must only be set internally by the pin_user_pages*() APIs,
		2500	* never directly by the caller, so enforce that:
		2501	*/
		2502	if (WARN_ON_ONCE(gup_flags & FOLL_PIN))
		2503	return -EINVAL;
		2504
		2505	return internal_get_user_pages_fast(start, nr_pages, gup_flags, pages);
		2506	}
2458	EXPORT_SYMBOL_GPL(get_user_pages_fast);	2507	EXPORT_SYMBOL_GPL(get_user_pages_fast);
		2508
		2509	/**
		2510	* pin_user_pages_fast() - pin user pages in memory without taking locks
		2511	*
		2512	* For now, this is a placeholder function, until various call sites are
		2513	* converted to use the correct get_user_pages() or pin_user_pages() API. So,
		2514	* this is identical to get_user_pages_fast().
		2515	*
		2516	* This is intended for Case 1 (DIO) in Documentation/vm/pin_user_pages.rst. It
		2517	* is NOT intended for Case 2 (RDMA: long-term pins).
		2518	*/
		2519	int pin_user_pages_fast(unsigned long start, int nr_pages,
		2520	unsigned int gup_flags, struct page **pages)
		2521	{
		2522	/*
		2523	* This is a placeholder, until the pin functionality is activated.
		2524	* Until then, just behave like the corresponding get_user_pages*()
		2525	* routine.
		2526	*/
		2527	return get_user_pages_fast(start, nr_pages, gup_flags, pages);
		2528	}
		2529	EXPORT_SYMBOL_GPL(pin_user_pages_fast);
		2530
		2531	/**
		2532	* pin_user_pages_remote() - pin pages of a remote process (task != current)
		2533	*
		2534	* For now, this is a placeholder function, until various call sites are
		2535	* converted to use the correct get_user_pages() or pin_user_pages() API. So,
		2536	* this is identical to get_user_pages_remote().
		2537	*
		2538	* This is intended for Case 1 (DIO) in Documentation/vm/pin_user_pages.rst. It
		2539	* is NOT intended for Case 2 (RDMA: long-term pins).
		2540	*/
		2541	long pin_user_pages_remote(struct task_struct tsk, struct mm_struct mm,
		2542	unsigned long start, unsigned long nr_pages,
		2543	unsigned int gup_flags, struct page **pages,
		2544	struct vm_area_struct *vmas, int locked)
		2545	{
		2546	/*
		2547	* This is a placeholder, until the pin functionality is activated.
		2548	* Until then, just behave like the corresponding get_user_pages*()
		2549	* routine.
		2550	*/
		2551	return get_user_pages_remote(tsk, mm, start, nr_pages, gup_flags, pages,
		2552	vmas, locked);
		2553	}
		2554	EXPORT_SYMBOL(pin_user_pages_remote);
		2555
		2556	/**
		2557	* pin_user_pages() - pin user pages in memory for use by other devices
		2558	*
		2559	* For now, this is a placeholder function, until various call sites are
		2560	* converted to use the correct get_user_pages() or pin_user_pages() API. So,
		2561	* this is identical to get_user_pages().
		2562	*
		2563	* This is intended for Case 1 (DIO) in Documentation/vm/pin_user_pages.rst. It
		2564	* is NOT intended for Case 2 (RDMA: long-term pins).
		2565	*/
		2566	long pin_user_pages(unsigned long start, unsigned long nr_pages,
		2567	unsigned int gup_flags, struct page **pages,
		2568	struct vm_area_struct **vmas)
		2569	{
		2570	/*
		2571	* This is a placeholder, until the pin functionality is activated.
		2572	* Until then, just behave like the corresponding get_user_pages*()
		2573	* routine.
		2574	*/
		2575	return get_user_pages(start, nr_pages, gup_flags, pages, vmas);
		2576	}
		2577	EXPORT_SYMBOL(pin_user_pages);

mm/gup_benchmark.c+6−3

 			nr = (next - addr) / PAGE_SIZE;
 		}
+		/* Filter out most gup flags: only allow a tiny subset here: */
+		gup->flags &= FOLL_WRITE;
 		switch (cmd) {
 		case GUP_FAST_BENCHMARK:
-			nr = get_user_pages_fast(addr, nr, gup->flags & 1,
+			nr = get_user_pages_fast(addr, nr, gup->flags,
 						 pages + i);
 			break;
 		case GUP_LONGTERM_BENCHMARK:
 			nr = get_user_pages(addr, nr,
-					    (gup->flags & 1) | FOLL_LONGTERM,
+					    gup->flags | FOLL_LONGTERM,
 					    pages + i, NULL);
 			break;
 		case GUP_BENCHMARK:
-			nr = get_user_pages(addr, nr, gup->flags & 1, pages + i,
+			nr = get_user_pages(addr, nr, gup->flags, pages + i,
 					    NULL);
 			break;
 		default:

mm/huge_memory.c+18−26

 {
 	ssize_t ret = count;
-	if (!memcmp("always", buf,
+	if (sysfs_streq(buf, "always")) {
-		    min(sizeof("always")-1, count))) {
 		clear_bit(TRANSPARENT_HUGEPAGE_REQ_MADV_FLAG, &transparent_hugepage_flags);
 		set_bit(TRANSPARENT_HUGEPAGE_FLAG, &transparent_hugepage_flags);
-	} else if (!memcmp("madvise", buf,
+	} else if (sysfs_streq(buf, "madvise")) {
-			   min(sizeof("madvise")-1, count))) {
 		clear_bit(TRANSPARENT_HUGEPAGE_FLAG, &transparent_hugepage_flags);
 		set_bit(TRANSPARENT_HUGEPAGE_REQ_MADV_FLAG, &transparent_hugepage_flags);
-	} else if (!memcmp("never", buf,
+	} else if (sysfs_streq(buf, "never")) {
-			   min(sizeof("never")-1, count))) {
 		clear_bit(TRANSPARENT_HUGEPAGE_FLAG, &transparent_hugepage_flags);
 		clear_bit(TRANSPARENT_HUGEPAGE_REQ_MADV_FLAG, &transparent_hugepage_flags);
 	} else
 			    struct kobj_attribute *attr,
 			    const char *buf, size_t count)
 {
-	if (!memcmp("always", buf,
+	if (sysfs_streq(buf, "always")) {
-		    min(sizeof("always")-1, count))) {
 		clear_bit(TRANSPARENT_HUGEPAGE_DEFRAG_KSWAPD_FLAG, &transparent_hugepage_flags);
 		clear_bit(TRANSPARENT_HUGEPAGE_DEFRAG_KSWAPD_OR_MADV_FLAG, &transparent_hugepage_flags);
 		clear_bit(TRANSPARENT_HUGEPAGE_DEFRAG_REQ_MADV_FLAG, &transparent_hugepage_flags);
 		set_bit(TRANSPARENT_HUGEPAGE_DEFRAG_DIRECT_FLAG, &transparent_hugepage_flags);
-	} else if (!memcmp("defer+madvise", buf,
+	} else if (sysfs_streq(buf, "defer+madvise")) {
-		    min(sizeof("defer+madvise")-1, count))) {
 		clear_bit(TRANSPARENT_HUGEPAGE_DEFRAG_DIRECT_FLAG, &transparent_hugepage_flags);
 		clear_bit(TRANSPARENT_HUGEPAGE_DEFRAG_KSWAPD_FLAG, &transparent_hugepage_flags);
 		clear_bit(TRANSPARENT_HUGEPAGE_DEFRAG_REQ_MADV_FLAG, &transparent_hugepage_flags);
 		set_bit(TRANSPARENT_HUGEPAGE_DEFRAG_KSWAPD_OR_MADV_FLAG, &transparent_hugepage_flags);
-	} else if (!memcmp("defer", buf,
+	} else if (sysfs_streq(buf, "defer")) {
-		    min(sizeof("defer")-1, count))) {
 		clear_bit(TRANSPARENT_HUGEPAGE_DEFRAG_DIRECT_FLAG, &transparent_hugepage_flags);
 		clear_bit(TRANSPARENT_HUGEPAGE_DEFRAG_KSWAPD_OR_MADV_FLAG, &transparent_hugepage_flags);
 		clear_bit(TRANSPARENT_HUGEPAGE_DEFRAG_REQ_MADV_FLAG, &transparent_hugepage_flags);
 		set_bit(TRANSPARENT_HUGEPAGE_DEFRAG_KSWAPD_FLAG, &transparent_hugepage_flags);
-	} else if (!memcmp("madvise", buf,
+	} else if (sysfs_streq(buf, "madvise")) {
-			   min(sizeof("madvise")-1, count))) {
 		clear_bit(TRANSPARENT_HUGEPAGE_DEFRAG_DIRECT_FLAG, &transparent_hugepage_flags);
 		clear_bit(TRANSPARENT_HUGEPAGE_DEFRAG_KSWAPD_FLAG, &transparent_hugepage_flags);
 		clear_bit(TRANSPARENT_HUGEPAGE_DEFRAG_KSWAPD_OR_MADV_FLAG, &transparent_hugepage_flags);
 		set_bit(TRANSPARENT_HUGEPAGE_DEFRAG_REQ_MADV_FLAG, &transparent_hugepage_flags);
-	} else if (!memcmp("never", buf,
+	} else if (sysfs_streq(buf, "never")) {
-			   min(sizeof("never")-1, count))) {
 		clear_bit(TRANSPARENT_HUGEPAGE_DEFRAG_DIRECT_FLAG, &transparent_hugepage_flags);
 		clear_bit(TRANSPARENT_HUGEPAGE_DEFRAG_KSWAPD_FLAG, &transparent_hugepage_flags);
 		clear_bit(TRANSPARENT_HUGEPAGE_DEFRAG_KSWAPD_OR_MADV_FLAG, &transparent_hugepage_flags);
 {
 	struct page *head = compound_head(page);
 	struct pglist_data *pgdata = NODE_DATA(page_to_nid(head));
-	struct deferred_split *ds_queue = get_deferred_split_queue(page);
+	struct deferred_split *ds_queue = get_deferred_split_queue(head);
 	struct anon_vma *anon_vma = NULL;
 	struct address_space *mapping = NULL;
 	int count, mapcount, extra_pins, ret;
 	unsigned long flags;
 	pgoff_t end;
-	VM_BUG_ON_PAGE(is_huge_zero_page(page), page);
+	VM_BUG_ON_PAGE(is_huge_zero_page(head), head);
-	VM_BUG_ON_PAGE(!PageLocked(page), page);
+	VM_BUG_ON_PAGE(!PageLocked(head), head);
-	VM_BUG_ON_PAGE(!PageCompound(page), page);
+	VM_BUG_ON_PAGE(!PageCompound(head), head);
-	if (PageWriteback(page))
+	if (PageWriteback(head))
 		return -EBUSY;
 	if (PageAnon(head)) {
 		goto out_unlock;
 	}
-	mlocked = PageMlocked(page);
+	mlocked = PageMlocked(head);
 	unmap_page(head);
 	VM_BUG_ON_PAGE(compound_mapcount(head), head);
 			ds_queue->split_queue_len--;
 			list_del(page_deferred_list(head));
 		}
+		spin_unlock(&ds_queue->split_queue_lock);
 		if (mapping) {
-			if (PageSwapBacked(page))
+			if (PageSwapBacked(head))
-				__dec_node_page_state(page, NR_SHMEM_THPS);
+				__dec_node_page_state(head, NR_SHMEM_THPS);
 			else
-				__dec_node_page_state(page, NR_FILE_THPS);
+				__dec_node_page_state(head, NR_FILE_THPS);
 		}
-		spin_unlock(&ds_queue->split_queue_lock);
 		__split_huge_page(page, list, end, flags);
 		if (PageSwapCache(head)) {
 			swp_entry_t entry = { .val = page_private(head) };

mm/kmemleak.c+56−56

@@ -13,7 +13,7 @@ · 12 unmodified lines
13	*	13	*
14	* The following locks and mutexes are used by kmemleak:	14	* The following locks and mutexes are used by kmemleak:
15	*	15	*
16	* - kmemleak_lock (rwlock): protects the object_list modifications and	16	* - kmemleak_lock (raw_spinlock_t): protects the object_list modifications and
17	* accesses to the object_tree_root. The object_list is the main list	17	* accesses to the object_tree_root. The object_list is the main list
18	* holding the metadata (struct kmemleak_object) for the allocated memory	18	* holding the metadata (struct kmemleak_object) for the allocated memory
19	* blocks. The object_tree_root is a red black tree used to look-up	19	* blocks. The object_tree_root is a red black tree used to look-up
@@ -22,13 +22,13 @@ · 2 unmodified lines
22	* object_tree_root in the create_object() function called from the	22	* object_tree_root in the create_object() function called from the
23	* kmemleak_alloc() callback and removed in delete_object() called from the	23	* kmemleak_alloc() callback and removed in delete_object() called from the
24	* kmemleak_free() callback	24	* kmemleak_free() callback
25	* - kmemleak_object.lock (spinlock): protects a kmemleak_object. Accesses to	25	* - kmemleak_object.lock (raw_spinlock_t): protects a kmemleak_object.
26	* the metadata (e.g. count) are protected by this lock. Note that some	26	* Accesses to the metadata (e.g. count) are protected by this lock. Note
27	* members of this structure may be protected by other means (atomic or	27	* that some members of this structure may be protected by other means
28	* kmemleak_lock). This lock is also held when scanning the corresponding	28	* (atomic or kmemleak_lock). This lock is also held when scanning the
29	* memory block to avoid the kernel freeing it via the kmemleak_free()	29	* corresponding memory block to avoid the kernel freeing it via the
30	* callback. This is less heavyweight than holding a global lock like	30	* kmemleak_free() callback. This is less heavyweight than holding a global
31	* kmemleak_lock during scanning	31	* lock like kmemleak_lock during scanning.
32	* - scan_mutex (mutex): ensures that only one thread may scan the memory for	32	* - scan_mutex (mutex): ensures that only one thread may scan the memory for
33	* unreferenced objects at a time. The gray_list contains the objects which	33	* unreferenced objects at a time. The gray_list contains the objects which
34	* are already referenced or marked as false positives and need to be	34	* are already referenced or marked as false positives and need to be
@@ -135,7 +135,7 @@ struct kmemleak_scan_area { · 100 unmodified lines
135	* (use_count) and freed using the RCU mechanism.	135	* (use_count) and freed using the RCU mechanism.
136	*/	136	*/
137	struct kmemleak_object {	137	struct kmemleak_object {
138	spinlock_t lock;	138	raw_spinlock_t lock;
139	unsigned int flags; /* object status flags */	139	unsigned int flags; /* object status flags */
140	struct list_head object_list;	140	struct list_head object_list;
141	struct list_head gray_list;	141	struct list_head gray_list;
@@ -191,8 +191,8 @@ static int mem_pool_free_count = ARRAY_SIZE(mem_pool); · 49 unmodified lines
191	static LIST_HEAD(mem_pool_free_list);	191	static LIST_HEAD(mem_pool_free_list);
192	/* search tree for object boundaries */	192	/* search tree for object boundaries */
193	static struct rb_root object_tree_root = RB_ROOT;	193	static struct rb_root object_tree_root = RB_ROOT;
194	/* rw_lock protecting the access to object_list and object_tree_root */	194	/* protecting the access to object_list and object_tree_root */
195	static DEFINE_RWLOCK(kmemleak_lock);	195	static DEFINE_RAW_SPINLOCK(kmemleak_lock);
196		196
197	/* allocation caches for kmemleak internal data */	197	/* allocation caches for kmemleak internal data */
198	static struct kmem_cache *object_cache;	198	static struct kmem_cache *object_cache;
@@ -426,7 +426,7 @@ static struct kmemleak_object *mem_pool_alloc(gfp_t gfp) · 227 unmodified lines
426	}	426	}
427		427
428	/* slab allocation failed, try the memory pool */	428	/* slab allocation failed, try the memory pool */
429	write_lock_irqsave(&kmemleak_lock, flags);	429	raw_spin_lock_irqsave(&kmemleak_lock, flags);
430	object = list_first_entry_or_null(&mem_pool_free_list,	430	object = list_first_entry_or_null(&mem_pool_free_list,
431	typeof(*object), object_list);	431	typeof(*object), object_list);
432	if (object)	432	if (object)
@@ -435,7 +435,7 @@ static struct kmemleak_object *mem_pool_alloc(gfp_t gfp) · 2 unmodified lines
435	object = &mem_pool[--mem_pool_free_count];	435	object = &mem_pool[--mem_pool_free_count];
436	else	436	else
437	pr_warn_once("Memory pool empty, consider increasing CONFIG_DEBUG_KMEMLEAK_MEM_POOL_SIZE\n");	437	pr_warn_once("Memory pool empty, consider increasing CONFIG_DEBUG_KMEMLEAK_MEM_POOL_SIZE\n");
438	write_unlock_irqrestore(&kmemleak_lock, flags);	438	raw_spin_unlock_irqrestore(&kmemleak_lock, flags);
439		439
440	return object;	440	return object;
441	}	441	}
@@ -453,9 +453,9 @@ static void mem_pool_free(struct kmemleak_object *object) · 11 unmodified lines
453	}	453	}
454		454
455	/* add the object to the memory pool free list */	455	/* add the object to the memory pool free list */
456	write_lock_irqsave(&kmemleak_lock, flags);	456	raw_spin_lock_irqsave(&kmemleak_lock, flags);
457	list_add(&object->object_list, &mem_pool_free_list);	457	list_add(&object->object_list, &mem_pool_free_list);
458	write_unlock_irqrestore(&kmemleak_lock, flags);	458	raw_spin_unlock_irqrestore(&kmemleak_lock, flags);
459	}	459	}
460		460
461	/*	461	/*
@@ -514,9 +514,9 @@ static struct kmemleak_object *find_and_get_object(unsigned long ptr, int alias) · 52 unmodified lines
514	struct kmemleak_object *object;	514	struct kmemleak_object *object;
515		515
516	rcu_read_lock();	516	rcu_read_lock();
517	read_lock_irqsave(&kmemleak_lock, flags);	517	raw_spin_lock_irqsave(&kmemleak_lock, flags);
518	object = lookup_object(ptr, alias);	518	object = lookup_object(ptr, alias);
519	read_unlock_irqrestore(&kmemleak_lock, flags);	519	raw_spin_unlock_irqrestore(&kmemleak_lock, flags);
520		520
521	/* check whether the object is still available */	521	/* check whether the object is still available */
522	if (object && !get_object(object))	522	if (object && !get_object(object))
@@ -546,11 +546,11 @@ static struct kmemleak_object *find_and_remove_object(unsigned long ptr, int ali · 23 unmodified lines
546	unsigned long flags;	546	unsigned long flags;
547	struct kmemleak_object *object;	547	struct kmemleak_object *object;
548		548
549	write_lock_irqsave(&kmemleak_lock, flags);	549	raw_spin_lock_irqsave(&kmemleak_lock, flags);
550	object = lookup_object(ptr, alias);	550	object = lookup_object(ptr, alias);
551	if (object)	551	if (object)
552	__remove_object(object);	552	__remove_object(object);
553	write_unlock_irqrestore(&kmemleak_lock, flags);	553	raw_spin_unlock_irqrestore(&kmemleak_lock, flags);
554		554
555	return object;	555	return object;
556	}	556	}
@@ -585,7 +585,7 @@ static struct kmemleak_object *create_object(unsigned long ptr, size_t size, · 28 unmodified lines
585	INIT_LIST_HEAD(&object->object_list);	585	INIT_LIST_HEAD(&object->object_list);
586	INIT_LIST_HEAD(&object->gray_list);	586	INIT_LIST_HEAD(&object->gray_list);
587	INIT_HLIST_HEAD(&object->area_list);	587	INIT_HLIST_HEAD(&object->area_list);
588	spin_lock_init(&object->lock);	588	raw_spin_lock_init(&object->lock);
589	atomic_set(&object->use_count, 1);	589	atomic_set(&object->use_count, 1);
590	object->flags = OBJECT_ALLOCATED;	590	object->flags = OBJECT_ALLOCATED;
591	object->pointer = ptr;	591	object->pointer = ptr;
@@ -617,7 +617,7 @@ static struct kmemleak_object *create_object(unsigned long ptr, size_t size, · 25 unmodified lines
617	/* kernel backtrace */	617	/* kernel backtrace */
618	object->trace_len = __save_stack_trace(object->trace);	618	object->trace_len = __save_stack_trace(object->trace);
619		619
620	write_lock_irqsave(&kmemleak_lock, flags);	620	raw_spin_lock_irqsave(&kmemleak_lock, flags);
621		621
622	untagged_ptr = (unsigned long)kasan_reset_tag((void *)ptr);	622	untagged_ptr = (unsigned long)kasan_reset_tag((void *)ptr);
623	min_addr = min(min_addr, untagged_ptr);	623	min_addr = min(min_addr, untagged_ptr);
@@ -649,7 +649,7 @@ static struct kmemleak_object *create_object(unsigned long ptr, size_t size, · 25 unmodified lines
649		649
650	list_add_tail_rcu(&object->object_list, &object_list);	650	list_add_tail_rcu(&object->object_list, &object_list);
651	out:	651	out:
652	write_unlock_irqrestore(&kmemleak_lock, flags);	652	raw_spin_unlock_irqrestore(&kmemleak_lock, flags);
653	return object;	653	return object;
654	}	654	}
655		655
@@ -667,9 +667,9 @@ static void __delete_object(struct kmemleak_object *object) · 11 unmodified lines
667	* Locking here also ensures that the corresponding memory block	667	* Locking here also ensures that the corresponding memory block
668	* cannot be freed when it is being scanned.	668	* cannot be freed when it is being scanned.
669	*/	669	*/
670	spin_lock_irqsave(&object->lock, flags);	670	raw_spin_lock_irqsave(&object->lock, flags);
671	object->flags &= ~OBJECT_ALLOCATED;	671	object->flags &= ~OBJECT_ALLOCATED;
672	spin_unlock_irqrestore(&object->lock, flags);	672	raw_spin_unlock_irqrestore(&object->lock, flags);
673	put_object(object);	673	put_object(object);
674	}	674	}
675		675
@@ -739,9 +739,9 @@ static void paint_it(struct kmemleak_object *object, int color) · 63 unmodified lines
739	{	739	{
740	unsigned long flags;	740	unsigned long flags;
741		741
742	spin_lock_irqsave(&object->lock, flags);	742	raw_spin_lock_irqsave(&object->lock, flags);
743	__paint_it(object, color);	743	__paint_it(object, color);
744	spin_unlock_irqrestore(&object->lock, flags);	744	raw_spin_unlock_irqrestore(&object->lock, flags);
745	}	745	}
746		746
747	static void paint_ptr(unsigned long ptr, int color)	747	static void paint_ptr(unsigned long ptr, int color)
@@ -798,7 +798,7 @@ static void add_scan_area(unsigned long ptr, size_t size, gfp_t gfp) · 50 unmodified lines
798	if (scan_area_cache)	798	if (scan_area_cache)
799	area = kmem_cache_alloc(scan_area_cache, gfp_kmemleak_mask(gfp));	799	area = kmem_cache_alloc(scan_area_cache, gfp_kmemleak_mask(gfp));
800		800
801	spin_lock_irqsave(&object->lock, flags);	801	raw_spin_lock_irqsave(&object->lock, flags);
802	if (!area) {	802	if (!area) {
803	pr_warn_once("Cannot allocate a scan area, scanning the full object\n");	803	pr_warn_once("Cannot allocate a scan area, scanning the full object\n");
804	/* mark the object for full scan to avoid false positives */	804	/* mark the object for full scan to avoid false positives */
@@ -820,7 +820,7 @@ static void add_scan_area(unsigned long ptr, size_t size, gfp_t gfp) · 15 unmodified lines
820		820
821	hlist_add_head(&area->node, &object->area_list);	821	hlist_add_head(&area->node, &object->area_list);
822	out_unlock:	822	out_unlock:
823	spin_unlock_irqrestore(&object->lock, flags);	823	raw_spin_unlock_irqrestore(&object->lock, flags);
824	put_object(object);	824	put_object(object);
825	}	825	}
826		826
@@ -842,9 +842,9 @@ static void object_set_excess_ref(unsigned long ptr, unsigned long excess_ref) · 15 unmodified lines
842	return;	842	return;
843	}	843	}
844		844
845	spin_lock_irqsave(&object->lock, flags);	845	raw_spin_lock_irqsave(&object->lock, flags);
846	object->excess_ref = excess_ref;	846	object->excess_ref = excess_ref;
847	spin_unlock_irqrestore(&object->lock, flags);	847	raw_spin_unlock_irqrestore(&object->lock, flags);
848	put_object(object);	848	put_object(object);
849	}	849	}
850		850
@@ -864,9 +864,9 @@ static void object_no_scan(unsigned long ptr) · 13 unmodified lines
864	return;	864	return;
865	}	865	}
866		866
867	spin_lock_irqsave(&object->lock, flags);	867	raw_spin_lock_irqsave(&object->lock, flags);
868	object->flags \|= OBJECT_NO_SCAN;	868	object->flags \|= OBJECT_NO_SCAN;
869	spin_unlock_irqrestore(&object->lock, flags);	869	raw_spin_unlock_irqrestore(&object->lock, flags);
870	put_object(object);	870	put_object(object);
871	}	871	}
872		872
@@ -1026,9 +1026,9 @@ void __ref kmemleak_update_trace(const void *ptr) · 153 unmodified lines
1026	return;	1026	return;
1027	}	1027	}
1028		1028
1029	spin_lock_irqsave(&object->lock, flags);	1029	raw_spin_lock_irqsave(&object->lock, flags);
1030	object->trace_len = __save_stack_trace(object->trace);	1030	object->trace_len = __save_stack_trace(object->trace);
1031	spin_unlock_irqrestore(&object->lock, flags);	1031	raw_spin_unlock_irqrestore(&object->lock, flags);
1032		1032
1033	put_object(object);	1033	put_object(object);
1034	}	1034	}
@@ -1233,7 +1233,7 @@ static void scan_block(void _start, void _end, · 198 unmodified lines
1233	unsigned long flags;	1233	unsigned long flags;
1234	unsigned long untagged_ptr;	1234	unsigned long untagged_ptr;
1235		1235
1236	read_lock_irqsave(&kmemleak_lock, flags);	1236	raw_spin_lock_irqsave(&kmemleak_lock, flags);
1237	for (ptr = start; ptr < end; ptr++) {	1237	for (ptr = start; ptr < end; ptr++) {
1238	struct kmemleak_object *object;	1238	struct kmemleak_object *object;
1239	unsigned long pointer;	1239	unsigned long pointer;
@@ -1268,7 +1268,7 @@ static void scan_block(void _start, void _end, · 28 unmodified lines
1268	* previously acquired in scan_object(). These locks are	1268	* previously acquired in scan_object(). These locks are
1269	* enclosed by scan_mutex.	1269	* enclosed by scan_mutex.
1270	*/	1270	*/
1271	spin_lock_nested(&object->lock, SINGLE_DEPTH_NESTING);	1271	raw_spin_lock_nested(&object->lock, SINGLE_DEPTH_NESTING);
1272	/* only pass surplus references (object already gray) */	1272	/* only pass surplus references (object already gray) */
1273	if (color_gray(object)) {	1273	if (color_gray(object)) {
1274	excess_ref = object->excess_ref;	1274	excess_ref = object->excess_ref;
@@ -1277,7 +1277,7 @@ static void scan_block(void _start, void _end, · 2 unmodified lines
1277	excess_ref = 0;	1277	excess_ref = 0;
1278	update_refs(object);	1278	update_refs(object);
1279	}	1279	}
1280	spin_unlock(&object->lock);	1280	raw_spin_unlock(&object->lock);
1281		1281
1282	if (excess_ref) {	1282	if (excess_ref) {
1283	object = lookup_object(excess_ref, 0);	1283	object = lookup_object(excess_ref, 0);
@@ -1286,12 +1286,12 @@ static void scan_block(void _start, void _end, · 2 unmodified lines
1286	if (object == scanned)	1286	if (object == scanned)
1287	/* circular reference, ignore */	1287	/* circular reference, ignore */
1288	continue;	1288	continue;
1289	spin_lock_nested(&object->lock, SINGLE_DEPTH_NESTING);	1289	raw_spin_lock_nested(&object->lock, SINGLE_DEPTH_NESTING);
1290	update_refs(object);	1290	update_refs(object);
1291	spin_unlock(&object->lock);	1291	raw_spin_unlock(&object->lock);
1292	}	1292	}
1293	}	1293	}
1294	read_unlock_irqrestore(&kmemleak_lock, flags);	1294	raw_spin_unlock_irqrestore(&kmemleak_lock, flags);
1295	}	1295	}
1296		1296
1297	/*	1297	/*
@@ -1324,7 +1324,7 @@ static void scan_object(struct kmemleak_object *object) · 26 unmodified lines
1324	* Once the object->lock is acquired, the corresponding memory block	1324	* Once the object->lock is acquired, the corresponding memory block
1325	* cannot be freed (the same lock is acquired in delete_object).	1325	* cannot be freed (the same lock is acquired in delete_object).
1326	*/	1326	*/
1327	spin_lock_irqsave(&object->lock, flags);	1327	raw_spin_lock_irqsave(&object->lock, flags);
1328	if (object->flags & OBJECT_NO_SCAN)	1328	if (object->flags & OBJECT_NO_SCAN)
1329	goto out;	1329	goto out;
1330	if (!(object->flags & OBJECT_ALLOCATED))	1330	if (!(object->flags & OBJECT_ALLOCATED))
@@ -1344,9 +1344,9 @@ static void scan_object(struct kmemleak_object *object) · 13 unmodified lines
1344	if (start >= end)	1344	if (start >= end)
1345	break;	1345	break;
1346		1346
1347	spin_unlock_irqrestore(&object->lock, flags);	1347	raw_spin_unlock_irqrestore(&object->lock, flags);
1348	cond_resched();	1348	cond_resched();
1349	spin_lock_irqsave(&object->lock, flags);	1349	raw_spin_lock_irqsave(&object->lock, flags);
1350	} while (object->flags & OBJECT_ALLOCATED);	1350	} while (object->flags & OBJECT_ALLOCATED);
1351	} else	1351	} else
1352	hlist_for_each_entry(area, &object->area_list, node)	1352	hlist_for_each_entry(area, &object->area_list, node)
@@ -1354,7 +1354,7 @@ static void scan_object(struct kmemleak_object *object) · 1 unmodified line
1354	(void *)(area->start + area->size),	1354	(void *)(area->start + area->size),
1355	object);	1355	object);
1356	out:	1356	out:
1357	spin_unlock_irqrestore(&object->lock, flags);	1357	raw_spin_unlock_irqrestore(&object->lock, flags);
1358	}	1358	}
1359		1359
1360	/*	1360	/*
@@ -1407,7 +1407,7 @@ static void kmemleak_scan(void) · 46 unmodified lines
1407	/* prepare the kmemleak_object's */	1407	/* prepare the kmemleak_object's */
1408	rcu_read_lock();	1408	rcu_read_lock();
1409	list_for_each_entry_rcu(object, &object_list, object_list) {	1409	list_for_each_entry_rcu(object, &object_list, object_list) {
1410	spin_lock_irqsave(&object->lock, flags);	1410	raw_spin_lock_irqsave(&object->lock, flags);
1411	#ifdef DEBUG	1411	#ifdef DEBUG
1412	/*	1412	/*
1413	* With a few exceptions there should be a maximum of	1413	* With a few exceptions there should be a maximum of
@@ -1424,7 +1424,7 @@ static void kmemleak_scan(void) · 10 unmodified lines
1424	if (color_gray(object) && get_object(object))	1424	if (color_gray(object) && get_object(object))
1425	list_add_tail(&object->gray_list, &gray_list);	1425	list_add_tail(&object->gray_list, &gray_list);
1426		1426
1427	spin_unlock_irqrestore(&object->lock, flags);	1427	raw_spin_unlock_irqrestore(&object->lock, flags);
1428	}	1428	}
1429	rcu_read_unlock();	1429	rcu_read_unlock();
1430		1430
@@ -1492,14 +1492,14 @@ static void kmemleak_scan(void) · 61 unmodified lines
1492	*/	1492	*/
1493	rcu_read_lock();	1493	rcu_read_lock();
1494	list_for_each_entry_rcu(object, &object_list, object_list) {	1494	list_for_each_entry_rcu(object, &object_list, object_list) {
1495	spin_lock_irqsave(&object->lock, flags);	1495	raw_spin_lock_irqsave(&object->lock, flags);
1496	if (color_white(object) && (object->flags & OBJECT_ALLOCATED)	1496	if (color_white(object) && (object->flags & OBJECT_ALLOCATED)
1497	&& update_checksum(object) && get_object(object)) {	1497	&& update_checksum(object) && get_object(object)) {
1498	/* color it gray temporarily */	1498	/* color it gray temporarily */
1499	object->count = object->min_count;	1499	object->count = object->min_count;
1500	list_add_tail(&object->gray_list, &gray_list);	1500	list_add_tail(&object->gray_list, &gray_list);
1501	}	1501	}
1502	spin_unlock_irqrestore(&object->lock, flags);	1502	raw_spin_unlock_irqrestore(&object->lock, flags);
1503	}	1503	}
1504	rcu_read_unlock();	1504	rcu_read_unlock();
1505		1505
@@ -1519,7 +1519,7 @@ static void kmemleak_scan(void) · 13 unmodified lines
1519	*/	1519	*/
1520	rcu_read_lock();	1520	rcu_read_lock();
1521	list_for_each_entry_rcu(object, &object_list, object_list) {	1521	list_for_each_entry_rcu(object, &object_list, object_list) {
1522	spin_lock_irqsave(&object->lock, flags);	1522	raw_spin_lock_irqsave(&object->lock, flags);
1523	if (unreferenced_object(object) &&	1523	if (unreferenced_object(object) &&
1524	!(object->flags & OBJECT_REPORTED)) {	1524	!(object->flags & OBJECT_REPORTED)) {
1525	object->flags \|= OBJECT_REPORTED;	1525	object->flags \|= OBJECT_REPORTED;
@@ -1529,7 +1529,7 @@ static void kmemleak_scan(void) · 3 unmodified lines
1529		1529
1530	new_leaks++;	1530	new_leaks++;
1531	}	1531	}
1532	spin_unlock_irqrestore(&object->lock, flags);	1532	raw_spin_unlock_irqrestore(&object->lock, flags);
1533	}	1533	}
1534	rcu_read_unlock();	1534	rcu_read_unlock();
1535		1535
@@ -1681,10 +1681,10 @@ static int kmemleak_seq_show(struct seq_file seq, void v) · 145 unmodified lines
1681	struct kmemleak_object *object = v;	1681	struct kmemleak_object *object = v;
1682	unsigned long flags;	1682	unsigned long flags;
1683		1683
1684	spin_lock_irqsave(&object->lock, flags);	1684	raw_spin_lock_irqsave(&object->lock, flags);
1685	if ((object->flags & OBJECT_REPORTED) && unreferenced_object(object))	1685	if ((object->flags & OBJECT_REPORTED) && unreferenced_object(object))
1686	print_unreferenced(seq, object);	1686	print_unreferenced(seq, object);
1687	spin_unlock_irqrestore(&object->lock, flags);	1687	raw_spin_unlock_irqrestore(&object->lock, flags);
1688	return 0;	1688	return 0;
1689	}	1689	}
1690		1690
@@ -1714,9 +1714,9 @@ static int dump_str_object_info(const char *str) · 23 unmodified lines
1714	return -EINVAL;	1714	return -EINVAL;
1715	}	1715	}
1716		1716
1717	spin_lock_irqsave(&object->lock, flags);	1717	raw_spin_lock_irqsave(&object->lock, flags);
1718	dump_object_info(object);	1718	dump_object_info(object);
1719	spin_unlock_irqrestore(&object->lock, flags);	1719	raw_spin_unlock_irqrestore(&object->lock, flags);
1720		1720
1721	put_object(object);	1721	put_object(object);
1722	return 0;	1722	return 0;
@@ -1735,11 +1735,11 @@ static void kmemleak_clear(void) · 12 unmodified lines
1735		1735
1736	rcu_read_lock();	1736	rcu_read_lock();
1737	list_for_each_entry_rcu(object, &object_list, object_list) {	1737	list_for_each_entry_rcu(object, &object_list, object_list) {
1738	spin_lock_irqsave(&object->lock, flags);	1738	raw_spin_lock_irqsave(&object->lock, flags);
1739	if ((object->flags & OBJECT_REPORTED) &&	1739	if ((object->flags & OBJECT_REPORTED) &&
1740	unreferenced_object(object))	1740	unreferenced_object(object))
1741	__paint_it(object, KMEMLEAK_GREY);	1741	__paint_it(object, KMEMLEAK_GREY);
1742	spin_unlock_irqrestore(&object->lock, flags);	1742	raw_spin_unlock_irqrestore(&object->lock, flags);
1743	}	1743	}
1744	rcu_read_unlock();	1744	rcu_read_unlock();
1745		1745

mm/memblock.c+17−5

  * Return:
  * 0 on success, -errno on failure.
  */
-int __init_memblock memblock_add_range(struct memblock_type *type,
+static int __init_memblock memblock_add_range(struct memblock_type *type,
 				phys_addr_t base, phys_addr_t size,
 				int nid, enum memblock_flags flags)
 {
 {
 	phys_addr_t end = base + size - 1;
-	memblock_dbg("memblock_add: [%pa-%pa] %pS\n",
+	memblock_dbg("%s: [%pa-%pa] %pS\n", __func__,
 		     &base, &end, (void *)_RET_IP_);
 	return memblock_add_range(&memblock.memory, base, size, MAX_NUMNODES, 0);
 {
 	phys_addr_t end = base + size - 1;
-	memblock_dbg("memblock_remove: [%pa-%pa] %pS\n",
+	memblock_dbg("%s: [%pa-%pa] %pS\n", __func__,
 		     &base, &end, (void *)_RET_IP_);
 	return memblock_remove_range(&memblock.memory, base, size);
 {
 	phys_addr_t end = base + size - 1;
-	memblock_dbg("   memblock_free: [%pa-%pa] %pS\n",
+	memblock_dbg("%s: [%pa-%pa] %pS\n", __func__,
 		     &base, &end, (void *)_RET_IP_);
 	kmemleak_free_part_phys(base, size);
 {
 	phys_addr_t end = base + size - 1;
-	memblock_dbg("memblock_reserve: [%pa-%pa] %pS\n",
+	memblock_dbg("%s: [%pa-%pa] %pS\n", __func__,
 		     &base, &end, (void *)_RET_IP_);
 	return memblock_add_range(&memblock.reserved, base, size, MAX_NUMNODES, 0);
 }
+#ifdef CONFIG_HAVE_MEMBLOCK_PHYS_MAP
+int __init_memblock memblock_physmem_add(phys_addr_t base, phys_addr_t size)
+{
+	phys_addr_t end = base + size - 1;
+	memblock_dbg("%s: [%pa-%pa] %pS\n", __func__,
+		     &base, &end, (void *)_RET_IP_);
+	return memblock_add_range(&memblock.physmem, base, size, MAX_NUMNODES, 0);
+}
+#endif
 /**
  * memblock_setclr_flag - set or clear flag for a memory region
  * @base: base address of the region

mm/memcontrol.c+3−22

 		__mod_lruvec_state(to_vec, NR_WRITEBACK, nr_pages);
 	}
-#ifdef CONFIG_TRANSPARENT_HUGEPAGE
-	if (compound && !list_empty(page_deferred_list(page))) {
-		spin_lock(&from->deferred_split_queue.split_queue_lock);
-		list_del_init(page_deferred_list(page));
-		from->deferred_split_queue.split_queue_len--;
-		spin_unlock(&from->deferred_split_queue.split_queue_lock);
-	}
-#endif
 	/*
 	 * It is safe to change page->mem_cgroup here because the page
 	 * is referenced, charged, and isolated - we can't race with
 	/* caller should have done css_get */
 	page->mem_cgroup = to;
-#ifdef CONFIG_TRANSPARENT_HUGEPAGE
-	if (compound && list_empty(page_deferred_list(page))) {
-		spin_lock(&to->deferred_split_queue.split_queue_lock);
-		list_add_tail(page_deferred_list(page),
-			      &to->deferred_split_queue.split_queue);
-		to->deferred_split_queue.split_queue_len++;
-		spin_unlock(&to->deferred_split_queue.split_queue_lock);
-	}
-#endif
 	spin_unlock_irqrestore(&from->move_lock, flags);
 	ret = 0;
 {
 	struct mem_cgroup *memcg;
 	unsigned int nr_pages;
-	bool compound;
 	unsigned long flags;
 	VM_BUG_ON_PAGE(!PageLocked(oldpage), oldpage);
 		return;
 	/* Force-charge the new page. The old one will be freed soon */
-	compound = PageTransHuge(newpage);
+	nr_pages = hpage_nr_pages(newpage);
-	nr_pages = compound ? hpage_nr_pages(newpage) : 1;
 	page_counter_charge(&memcg->memory, nr_pages);
 	if (do_memsw_account())
 	commit_charge(newpage, memcg, false);
 	local_irq_save(flags);
-	mem_cgroup_charge_statistics(memcg, newpage, compound, nr_pages);
+	mem_cgroup_charge_statistics(memcg, newpage, PageTransHuge(newpage),
+			nr_pages);
 	memcg_check_events(memcg, newpage);
 	local_irq_restore(flags);
 }

mm/memory_hotplug.c+9−15

 	return default_zone_for_pfn(nid, start_pfn, nr_pages);
 }
-int __ref online_pages(unsigned long pfn, unsigned long nr_pages, int online_type)
+int __ref online_pages(unsigned long pfn, unsigned long nr_pages,
+		       int online_type, int nid)
 {
 	unsigned long flags;
 	unsigned long onlined_pages = 0;
 	struct zone *zone;
 	int need_zonelists_rebuild = 0;
-	int nid;
 	int ret;
 	struct memory_notify arg;
-	struct memory_block *mem;
 	mem_hotplug_begin();
-	/*
-	 * We can't use pfn_to_nid() because nid might be stored in struct page
-	 * which is not yet initialized. Instead, we find nid from memory block.
-	 */
-	mem = find_memory_block(__pfn_to_section(pfn));
-	nid = mem->nid;
-	put_device(&mem->dev);
 	/* associate pfn range with the zone */
 	zone = zone_for_pfn_range(online_type, nid, pfn, nr_pages);
 	move_pfn_range_to_zone(zone, pfn, nr_pages, NULL);
 	if (!zone_spans_pfn(zone, pfn))
 		return false;
-	return !has_unmovable_pages(zone, page, 0, MIGRATE_MOVABLE,
+	return !has_unmovable_pages(zone, page, MIGRATE_MOVABLE,
 				    MEMORY_OFFLINE);
 }
 	BUG_ON(check_hotplug_memory_range(start, size));
-	mem_hotplug_begin();
 	/*
 	 * All memory blocks must be offlined before removing memory.  Check
 	 * whether all memory blocks in question are offline and return error
 	/* remove memmap entry */
 	firmware_map_remove(start, start + size, "System RAM");
-	/* remove memory block devices before removing memory */
+	/*
+	 * Memory block device removal under the device_hotplug_lock is
+	 * a barrier against racing online attempts.
+	 */
 	remove_memory_block_devices(start, size);
+	mem_hotplug_begin();
 	arch_remove_memory(nid, start, size, NULL);
 	memblock_free(start, size);
 	memblock_remove(start, size);

mm/mempolicy.c+3−3

 	char *flags = strchr(str, '=');
 	int err = 1, mode;
+	if (flags)
+		*flags++ = '\0';	/* terminate mode string */
 	if (nodelist) {
 		/* NUL-terminate mode or flags string */
 		*nodelist++ = '\0';
 	} else
 		nodes_clear(nodes);
-	if (flags)
-		*flags++ = '\0';	/* terminate mode string */
 	mode = match_string(policy_modes, MPOL_MAX, str);
 	if (mode < 0)
 		goto out;

mm/memremap.c+35−40

@@ -27,7 +27,8 @@ static void devmap_managed_enable_put(void) · 26 unmodified lines
27		27
28	static int devmap_managed_enable_get(struct dev_pagemap *pgmap)	28	static int devmap_managed_enable_get(struct dev_pagemap *pgmap)
29	{	29	{
30	if (!pgmap->ops \|\| !pgmap->ops->page_free) {	30	if (pgmap->type == MEMORY_DEVICE_PRIVATE &&
		31	(!pgmap->ops \|\| !pgmap->ops->page_free)) {
31	WARN(1, "Missing page_free method\n");	32	WARN(1, "Missing page_free method\n");
32	return -EINVAL;	33	return -EINVAL;
33	}	34	}
@@ -410,48 +411,42 @@ struct dev_pagemap *get_dev_pagemap(unsigned long pfn, · 376 unmodified lines
410	EXPORT_SYMBOL_GPL(get_dev_pagemap);	411	EXPORT_SYMBOL_GPL(get_dev_pagemap);
411		412
412	#ifdef CONFIG_DEV_PAGEMAP_OPS	413	#ifdef CONFIG_DEV_PAGEMAP_OPS
413	void __put_devmap_managed_page(struct page *page)	414	void free_devmap_managed_page(struct page *page)
414	{	415	{
415	int count = page_ref_dec_return(page);	416	/* notify page idle for dax */
416		417	if (!is_device_private_page(page)) {
417	/*	418	wake_up_var(&page->_refcount);
418	* If refcount is 1 then page is freed and refcount is stable as nobody	419	return;
419	* holds a reference on the page.	420	}
420	*/
421	if (count == 1) {
422	/* Clear Active bit in case of parallel mark_page_accessed */
423	__ClearPageActive(page);
424	__ClearPageWaiters(page);
425		421
426	mem_cgroup_uncharge(page);	422	/* Clear Active bit in case of parallel mark_page_accessed */
		423	__ClearPageActive(page);
		424	__ClearPageWaiters(page);
427		425
428	/*	426	mem_cgroup_uncharge(page);
429	* When a device_private page is freed, the page->mapping field
430	* may still contain a (stale) mapping value. For example, the
431	* lower bits of page->mapping may still identify the page as
432	* an anonymous page. Ultimately, this entire field is just
433	* stale and wrong, and it will cause errors if not cleared.
434	* One example is:
435	*
436	* migrate_vma_pages()
437	* migrate_vma_insert_page()
438	* page_add_new_anon_rmap()
439	* __page_set_anon_rmap()
440	* ...checks page->mapping, via PageAnon(page) call,
441	* and incorrectly concludes that the page is an
442	* anonymous page. Therefore, it incorrectly,
443	* silently fails to set up the new anon rmap.
444	*
445	* For other types of ZONE_DEVICE pages, migration is either
446	* handled differently or not done at all, so there is no need
447	* to clear page->mapping.
448	*/
449	if (is_device_private_page(page))
450	page->mapping = NULL;
451		427
452	page->pgmap->ops->page_free(page);	428	/*
453	} else if (!count)	429	* When a device_private page is freed, the page->mapping field
454	__put_page(page);	430	* may still contain a (stale) mapping value. For example, the
		431	* lower bits of page->mapping may still identify the page as an
		432	* anonymous page. Ultimately, this entire field is just stale
		433	* and wrong, and it will cause errors if not cleared. One
		434	* example is:
		435	*
		436	* migrate_vma_pages()
		437	* migrate_vma_insert_page()
		438	* page_add_new_anon_rmap()
		439	* __page_set_anon_rmap()
		440	* ...checks page->mapping, via PageAnon(page) call,
		441	* and incorrectly concludes that the page is an
		442	* anonymous page. Therefore, it incorrectly,
		443	* silently fails to set up the new anon rmap.
		444	*
		445	* For other types of ZONE_DEVICE pages, migration is either
		446	* handled differently or not done at all, so there is no need
		447	* to clear page->mapping.
		448	*/
		449	page->mapping = NULL;
		450	page->pgmap->ops->page_free(page);
455	}	451	}
456	EXPORT_SYMBOL(__put_devmap_managed_page);
457	#endif /* CONFIG_DEV_PAGEMAP_OPS */	452	#endif /* CONFIG_DEV_PAGEMAP_OPS */

mm/migrate.c+51−26

 #include <linux/page_owner.h>
 #include <linux/sched/mm.h>
 #include <linux/ptrace.h>
+#include <linux/oom.h>
 #include <asm/tlbflush.h>
 		}
 		/*
-		 * Anonymous and movable page->mapping will be cleard by
+		 * Anonymous and movable page->mapping will be cleared by
 		 * free_pages_prepare so don't reset it here for keeping
 		 * the type to work PageAnon, for example.
 		 */
 		/*
 		 * A page that has been migrated has all references
 		 * removed and will be freed. A page that has not been
-		 * migrated will have kepts its references and be
+		 * migrated will have kept its references and be restored.
-		 * restored.
 		 */
 		list_del(&page->lru);
 			start = i;
 		} else if (node != current_node) {
 			err = do_move_pages_to_node(mm, &pagelist, current_node);
-			if (err)
+			if (err) {
+				/*
+				 * Positive err means the number of failed
+				 * pages to migrate.  Since we are going to
+				 * abort and return the number of non-migrated
+				 * pages, so need to incude the rest of the
+				 * nr_pages that have not been attempted as
+				 * well.
+				 */
+				if (err > 0)
+					err += nr_pages - i - 1;
 				goto out;
+			}
 			err = store_status(status, start, current_node, i - start);
 			if (err)
 				goto out;
 			goto out_flush;
 		err = do_move_pages_to_node(mm, &pagelist, current_node);
-		if (err)
+		if (err) {
+			if (err > 0)
+				err += nr_pages - i - 1;
 			goto out;
+		}
 		if (i > start) {
 			err = store_status(status, start, current_node, i - start);
 			if (err)
 	/* Make sure we do not overwrite the existing error */
 	err1 = do_move_pages_to_node(mm, &pagelist, current_node);
+	/*
+	 * Don't have to report non-attempted pages here since:
+	 *     - If the above loop is done gracefully all pages have been
+	 *       attempted.
+	 *     - If the above loop is aborted it means a fatal error
+	 *       happened, should return ret.
+	 */
 	if (!err1)
 		err1 = store_status(status, start, current_node, i - start);
-	if (!err)
+	if (err >= 0)
 		err = err1;
 out:
 	return err;
 	struct migrate_vma *migrate = walk->private;
 	unsigned long addr;
-	for (addr = start & PAGE_MASK; addr < end; addr += PAGE_SIZE) {
+	for (addr = start; addr < end; addr += PAGE_SIZE) {
 		migrate->src[migrate->npages] = MIGRATE_PFN_MIGRATE;
 		migrate->dst[migrate->npages] = 0;
 		migrate->npages++;
 	struct migrate_vma *migrate = walk->private;
 	unsigned long addr;
-	for (addr = start & PAGE_MASK; addr < end; addr += PAGE_SIZE) {
+	for (addr = start; addr < end; addr += PAGE_SIZE) {
 		migrate->dst[migrate->npages] = 0;
 		migrate->src[migrate->npages++] = 0;
 	}
 }
 EXPORT_SYMBOL(migrate_vma_setup);
+/*
+ * This code closely matches the code in:
+ *   __handle_mm_fault()
+ *     handle_pte_fault()
+ *       do_anonymous_page()
+ * to map in an anonymous zero page but the struct page will be a ZONE_DEVICE
+ * private page.
+ */
 static void migrate_vma_insert_page(struct migrate_vma *migrate,
 				    unsigned long addr,
 				    struct page *page,
 	ptep = pte_offset_map_lock(mm, pmdp, addr, &ptl);
+	if (check_stable_address_space(mm))
+		goto unlock_abort;
 	if (pte_present(*ptep)) {
 		unsigned long pfn = pte_pfn(*ptep);
-		if (!is_zero_pfn(pfn)) {
+		if (!is_zero_pfn(pfn))
-			pte_unmap_unlock(ptep, ptl);
+			goto unlock_abort;
-			mem_cgroup_cancel_charge(page, memcg, false);
-			goto abort;
-		}
 		flush = true;
-	} else if (!pte_none(*ptep)) {
+	} else if (!pte_none(*ptep))
-		pte_unmap_unlock(ptep, ptl);
+		goto unlock_abort;
-		mem_cgroup_cancel_charge(page, memcg, false);
-		goto abort;
-	}
 	/*
-	 * Check for usefaultfd but do not deliver the fault. Instead,
+	 * Check for userfaultfd but do not deliver the fault. Instead,
 	 * just back off.
 	 */
-	if (userfaultfd_missing(vma)) {
+	if (userfaultfd_missing(vma))
-		pte_unmap_unlock(ptep, ptl);
+		goto unlock_abort;
-		mem_cgroup_cancel_charge(page, memcg, false);
-		goto abort;
-	}
 	inc_mm_counter(mm, MM_ANONPAGES);
 	page_add_new_anon_rmap(page, vma, addr, false);
 	*src = MIGRATE_PFN_MIGRATE;
 	return;
+unlock_abort:
+	pte_unmap_unlock(ptep, ptl);
+	mem_cgroup_cancel_charge(page, memcg, false);
 abort:
 	*src &= ~MIGRATE_PFN_MIGRATE;
 }
 		}
 		if (!page) {
-			if (!(migrate->src[i] & MIGRATE_PFN_MIGRATE)) {
+			if (!(migrate->src[i] & MIGRATE_PFN_MIGRATE))
 				continue;
-			}
 			if (!notified) {
 				notified = true;

mm/mmap.c+16−20

@@ -1270,26 +1270,22 @@ static struct anon_vma reusable_anon_vma(struct vm_area_struct old, struct vm_ · 1269 unmodified lines
1270	*/	1270	*/
1271	struct anon_vma find_mergeable_anon_vma(struct vm_area_struct vma)	1271	struct anon_vma find_mergeable_anon_vma(struct vm_area_struct vma)
1272	{	1272	{
1273	struct anon_vma *anon_vma;	1273	struct anon_vma *anon_vma = NULL;
1274	struct vm_area_struct *near;	1274
1275		1275	/* Try next first. */
1276	near = vma->vm_next;	1276	if (vma->vm_next) {
1277	if (!near)	1277	anon_vma = reusable_anon_vma(vma->vm_next, vma, vma->vm_next);
1278	goto try_prev;	1278	if (anon_vma)
1279		1279	return anon_vma;
1280	anon_vma = reusable_anon_vma(near, vma, near);	1280	}
1281	if (anon_vma)	1281
1282	return anon_vma;	1282	/* Try prev next. */
1283	try_prev:	1283	if (vma->vm_prev)
1284	near = vma->vm_prev;	1284	anon_vma = reusable_anon_vma(vma->vm_prev, vma->vm_prev, vma);
1285	if (!near)	1285
1286	goto none;
1287
1288	anon_vma = reusable_anon_vma(near, near, vma);
1289	if (anon_vma)
1290	return anon_vma;
1291	none:
1292	/*	1286	/*
		1287	* We might reach here with anon_vma == NULL if we can't find
		1288	* any reusable anon_vma.
1293	* There's no absolute need to look only at touching neighbours:	1289	* There's no absolute need to look only at touching neighbours:
1294	* we could search further afield for "compatible" anon_vmas.	1290	* we could search further afield for "compatible" anon_vmas.
1295	* But it would probably just be a waste of time searching,	1291	* But it would probably just be a waste of time searching,
@@ -1297,7 +1293,7 @@ none: · 1 unmodified line
1297	* We're trying to allow mprotect remerging later on,	1293	* We're trying to allow mprotect remerging later on,
1298	* not trying to minimize memory used for anon_vmas.	1294	* not trying to minimize memory used for anon_vmas.
1299	*/	1295	*/
1300	return NULL;	1296	return anon_vma;
1301	}	1297	}
1302		1298
1303	/*	1299	/*

mm/oom_kill.c+2−0

 #include <linux/sched/mm.h>
 #include <linux/sched/coredump.h>
 #include <linux/sched/task.h>
+#include <linux/sched/debug.h>
 #include <linux/swap.h>
 #include <linux/timex.h>
 #include <linux/jiffies.h>
 	pr_info("oom_reaper: unable to reap pid:%d (%s)\n",
 		task_pid_nr(tsk), tsk->comm);
+	sched_show_task(tsk);
 	debug_show_all_locks();
 done:

mm/page_alloc.c+44−31

 	return false;
 }
+#ifdef CONFIG_SPARSEMEM
+/* Skip PFNs that belong to non-present sections */
+static inline __meminit unsigned long next_pfn(unsigned long pfn)
+{
+	unsigned long section_nr;
+	section_nr = pfn_to_section_nr(++pfn);
+	if (present_section_nr(section_nr))
+		return pfn;
+	while (++section_nr <= __highest_present_section_nr) {
+		if (present_section_nr(section_nr))
+			return section_nr_to_pfn(section_nr);
+	}
+	return -1;
+}
+#else
+static inline __meminit unsigned long next_pfn(unsigned long pfn)
+{
+	return pfn++;
+}
+#endif
 /*
  * Initially all pages are reserved - free ones are freed
  * up by memblock_free_all() once the early boot process is
 		 * function.  They do not exist on hotplugged memory.
 		 */
 		if (context == MEMMAP_EARLY) {
-			if (!early_pfn_valid(pfn))
+			if (!early_pfn_valid(pfn)) {
+				pfn = next_pfn(pfn) - 1;
 				continue;
+			}
 			if (!early_pfn_in_nid(pfn, nid))
 				continue;
 			if (overlap_memmap_init(zone, &pfn))
 /*
  * This function checks whether pageblock includes unmovable pages or not.
- * If @count is not zero, it is okay to include less @count unmovable pages
  *
  * PageLRU check without isolation or lru_lock could race so that
  * MIGRATE_MOVABLE block might include unmovable pages. And __PageMovable
  * check without lock_page also may miss some movable non-lru pages at
  * race condition. So you can't expect this function should be exact.
+ *
+ * Returns a page without holding a reference. If the caller wants to
+ * dereference that page (e.g., dumping), it has to make sure that that it
+ * cannot get removed (e.g., via memory unplug) concurrently.
+ *
  */
-bool has_unmovable_pages(struct zone *zone, struct page *page, int count,
+struct page *has_unmovable_pages(struct zone *zone, struct page *page,
-			 int migratetype, int flags)
+				 int migratetype, int flags)
 {
-	unsigned long found;
 	unsigned long iter = 0;
 	unsigned long pfn = page_to_pfn(page);
-	const char *reason = "unmovable page";
 	/*
 	 * TODO we could make this much more efficient by not checking every
 		 * so consider them movable here.
 		 */
 		if (is_migrate_cma(migratetype))
-			return false;
+			return NULL;
-		reason = "CMA page";
+		return page;
-		goto unmovable;
 	}
-	for (found = 0; iter < pageblock_nr_pages; iter++) {
+	for (; iter < pageblock_nr_pages; iter++) {
-		unsigned long check = pfn + iter;
+		if (!pfn_valid_within(pfn + iter))
-		if (!pfn_valid_within(check))
 			continue;
-		page = pfn_to_page(check);
+		page = pfn_to_page(pfn + iter);
 		if (PageReserved(page))
-			goto unmovable;
+			return page;
 		/*
 		 * If the zone is movable and we have ruled out all reserved
 			unsigned int skip_pages;
 			if (!hugepage_migration_supported(page_hstate(head)))
-				goto unmovable;
+				return page;
 			skip_pages = compound_nr(head) - (page - head);
 			iter += skip_pages - 1;
 		if ((flags & MEMORY_OFFLINE) && PageHWPoison(page))
 			continue;
-		if (__PageMovable(page))
+		if (__PageMovable(page) || PageLRU(page))
 			continue;
-		if (!PageLRU(page))
-			found++;
 		/*
 		 * If there are RECLAIMABLE pages, we need to check
 		 * it.  But now, memory offline itself doesn't call
 		 * is set to both of a memory hole page and a _used_ kernel
 		 * page at boot.
 		 */
-		if (found > count)
+		return page;
-			goto unmovable;
 	}
-	return false;
+	return NULL;
-unmovable:
-	WARN_ON_ONCE(zone_idx(zone) == ZONE_MOVABLE);
-	if (flags & REPORT_FAILURE)
-		dump_page(pfn_to_page(pfn + iter), reason);
-	return true;
 }
 #ifdef CONFIG_CONTIG_ALLOC
 		BUG_ON(!PageBuddy(page));
 		order = page_order(page);
 		offlined_pages += 1 << order;
-#ifdef CONFIG_DEBUG_VM
-		pr_info("remove from free list %lx %d %lx\n",
-			pfn, 1 << order, end_pfn);
-#endif
 		del_page_from_free_area(page, &zone->free_area[order]);
 		pfn += (1 << order);
 	}

mm/page_isolation.c+18−35

 static int set_migratetype_isolate(struct page *page, int migratetype, int isol_flags)
 {
+	struct page *unmovable = NULL;
 	struct zone *zone;
-	unsigned long flags, pfn;
+	unsigned long flags;
-	struct memory_isolate_notify arg;
-	int notifier_ret;
 	int ret = -EBUSY;
 	zone = page_zone(page);
 	if (is_migrate_isolate_page(page))
 		goto out;
-	pfn = page_to_pfn(page);
-	arg.start_pfn = pfn;
-	arg.nr_pages = pageblock_nr_pages;
-	arg.pages_found = 0;
-	/*
-	 * It may be possible to isolate a pageblock even if the
-	 * migratetype is not MIGRATE_MOVABLE. The memory isolation
-	 * notifier chain is used by balloon drivers to return the
-	 * number of pages in a range that are held by the balloon
-	 * driver to shrink memory. If all the pages are accounted for
-	 * by balloons, are free, or on the LRU, isolation can continue.
-	 * Later, for example, when memory hotplug notifier runs, these
-	 * pages reported as "can be isolated" should be isolated(freed)
-	 * by the balloon driver through the memory notifier chain.
-	 */
-	notifier_ret = memory_isolate_notify(MEM_ISOLATE_COUNT, &arg);
-	notifier_ret = notifier_to_errno(notifier_ret);
-	if (notifier_ret)
-		goto out;
 	/*
 	 * FIXME: Now, memory hotplug doesn't call shrink_slab() by itself.
 	 * We just check MOVABLE pages.
 	 */
-	if (!has_unmovable_pages(zone, page, arg.pages_found, migratetype,
+	unmovable = has_unmovable_pages(zone, page, migratetype, isol_flags);
-				 isol_flags))
+	if (!unmovable) {
-		ret = 0;
-	/*
-	 * immobile means "not-on-lru" pages. If immobile is larger than
-	 * removable-by-driver pages reported by notifier, we'll fail.
-	 */
-out:
-	if (!ret) {
 		unsigned long nr_pages;
 		int mt = get_pageblock_migratetype(page);
 									NULL);
 		__mod_zone_freepage_state(zone, -nr_pages, mt);
+		ret = 0;
 	}
+out:
 	spin_unlock_irqrestore(&zone->lock, flags);
-	if (!ret)
+	if (!ret) {
 		drain_all_pages(zone);
+	} else {
+		WARN_ON_ONCE(zone_idx(zone) == ZONE_MOVABLE);
+		if ((isol_flags & REPORT_FAILURE) && unmovable)
+			/*
+			 * printk() with zone->lock held will likely trigger a
+			 * lockdep splat, so defer it here.
+			 */
+			dump_page(unmovable, "unmovable page");
+	}
 	return ret;
 }

mm/page_vma_mapped.c+8−4

 	return true;
 }
-static inline bool pfn_in_hpage(struct page *hpage, unsigned long pfn)
+static inline bool pfn_is_match(struct page *page, unsigned long pfn)
 {
-	unsigned long hpage_pfn = page_to_pfn(hpage);
+	unsigned long page_pfn = page_to_pfn(page);
+	/* normal page and hugetlbfs page */
+	if (!PageTransCompound(page) || PageHuge(page))
+		return page_pfn == pfn;
 	/* THP can be referenced by any subpage */
-	return pfn >= hpage_pfn && pfn - hpage_pfn < hpage_nr_pages(hpage);
+	return pfn >= page_pfn && pfn - page_pfn < hpage_nr_pages(page);
 }
 /**
 		pfn = pte_pfn(*pvmw->pte);
 	}
-	return pfn_in_hpage(pvmw->page, pfn);
+	return pfn_is_match(pvmw->page, pfn);
 }
 /**

mm/process_vm_access.c+15−13

@@ -42,12 +42,11 @@ static int process_vm_rw_pages(struct page **pages, · 41 unmodified lines
42	if (copy > len)	42	if (copy > len)
43	copy = len;	43	copy = len;
44		44
45	if (vm_write) {	45	if (vm_write)
46	copied = copy_page_from_iter(page, offset, copy, iter);	46	copied = copy_page_from_iter(page, offset, copy, iter);
47	set_page_dirty_lock(page);	47	else
48	} else {
49	copied = copy_page_to_iter(page, offset, copy, iter);	48	copied = copy_page_to_iter(page, offset, copy, iter);
50	}	49
51	len -= copied;	50	len -= copied;
52	if (copied < copy && iov_iter_count(iter))	51	if (copied < copy && iov_iter_count(iter))
53	return -EFAULT;	52	return -EFAULT;
@@ -96,7 +95,7 @@ static int process_vm_rw_single_vec(unsigned long addr, · 42 unmodified lines
96	flags \|= FOLL_WRITE;	95	flags \|= FOLL_WRITE;
97		96
98	while (!rc && nr_pages && iov_iter_count(iter)) {	97	while (!rc && nr_pages && iov_iter_count(iter)) {
99	int pages = min(nr_pages, max_pages_per_loop);	98	int pinned_pages = min(nr_pages, max_pages_per_loop);
100	int locked = 1;	99	int locked = 1;
101	size_t bytes;	100	size_t bytes;
102		101
@@ -106,14 +105,15 @@ static int process_vm_rw_single_vec(unsigned long addr, · 3 unmodified lines
106	* current/current->mm	105	* current/current->mm
107	*/	106	*/
108	down_read(&mm->mmap_sem);	107	down_read(&mm->mmap_sem);
109	pages = get_user_pages_remote(task, mm, pa, pages, flags,	108	pinned_pages = pin_user_pages_remote(task, mm, pa, pinned_pages,
110	process_pages, NULL, &locked);	109	flags, process_pages,
		110	NULL, &locked);
111	if (locked)	111	if (locked)
112	up_read(&mm->mmap_sem);	112	up_read(&mm->mmap_sem);
113	if (pages <= 0)	113	if (pinned_pages <= 0)
114	return -EFAULT;	114	return -EFAULT;
115		115
116	bytes = pages * PAGE_SIZE - start_offset;	116	bytes = pinned_pages * PAGE_SIZE - start_offset;
117	if (bytes > len)	117	if (bytes > len)
118	bytes = len;	118	bytes = len;
119		119
@@ -122,10 +122,12 @@ static int process_vm_rw_single_vec(unsigned long addr, · 2 unmodified lines
122	vm_write);	122	vm_write);
123	len -= bytes;	123	len -= bytes;
124	start_offset = 0;	124	start_offset = 0;
125	nr_pages -= pages;	125	nr_pages -= pinned_pages;
126	pa += pages * PAGE_SIZE;	126	pa += pinned_pages * PAGE_SIZE;
127	while (pages)	127
128	put_page(process_pages[--pages]);	128	/* If vm_write is set, the pages need to be made dirty: */
		129	unpin_user_pages_dirty_lock(process_pages, pinned_pages,
		130	vm_write);
129	}	131	}
130		132
131	return rc;	133	return rc;

mm/slub.c+47−41

@@ -439,19 +439,38 @@ static inline bool cmpxchg_double_slab(struct kmem_cache s, struct page page, · 438 unmodified lines
439	}	439	}
440		440
441	#ifdef CONFIG_SLUB_DEBUG	441	#ifdef CONFIG_SLUB_DEBUG
		442	static unsigned long object_map[BITS_TO_LONGS(MAX_OBJS_PER_PAGE)];
		443	static DEFINE_SPINLOCK(object_map_lock);
		444
442	/*	445	/*
443	* Determine a map of object in use on a page.	446	* Determine a map of object in use on a page.
444	*	447	*
445	* Node listlock must be held to guarantee that the page does	448	* Node listlock must be held to guarantee that the page does
446	* not vanish from under us.	449	* not vanish from under us.
447	*/	450	*/
448	static void get_map(struct kmem_cache s, struct page page, unsigned long *map)	451	static unsigned long get_map(struct kmem_cache s, struct page *page)
449	{	452	{
450	void *p;	453	void *p;
451	void *addr = page_address(page);	454	void *addr = page_address(page);
452		455
		456	VM_BUG_ON(!irqs_disabled());
		457
		458	spin_lock(&object_map_lock);
		459
		460	bitmap_zero(object_map, page->objects);
		461
453	for (p = page->freelist; p; p = get_freepointer(s, p))	462	for (p = page->freelist; p; p = get_freepointer(s, p))
454	set_bit(slab_index(p, s, addr), map);	463	set_bit(slab_index(p, s, addr), object_map);
		464
		465	return object_map;
		466	}
		467
		468	static void put_map(unsigned long *map)
		469	{
		470	VM_BUG_ON(map != object_map);
		471	lockdep_assert_held(&object_map_lock);
		472
		473	spin_unlock(&object_map_lock);
455	}	474	}
456		475
457	static inline unsigned int size_from_object(struct kmem_cache *s)	476	static inline unsigned int size_from_object(struct kmem_cache *s)
@@ -3675,13 +3694,12 @@ static void list_slab_objects(struct kmem_cache s, struct page page, · 3217 unmodified lines
3675	#ifdef CONFIG_SLUB_DEBUG	3694	#ifdef CONFIG_SLUB_DEBUG
3676	void *addr = page_address(page);	3695	void *addr = page_address(page);
3677	void *p;	3696	void *p;
3678	unsigned long *map = bitmap_zalloc(page->objects, GFP_ATOMIC);	3697	unsigned long *map;
3679	if (!map)	3698
3680	return;
3681	slab_err(s, page, text, s->name);	3699	slab_err(s, page, text, s->name);
3682	slab_lock(page);	3700	slab_lock(page);
3683		3701
3684	get_map(s, page, map);	3702	map = get_map(s, page);
3685	for_each_object(p, s, addr, page->objects) {	3703	for_each_object(p, s, addr, page->objects) {
3686		3704
3687	if (!test_bit(slab_index(p, s, addr), map)) {	3705	if (!test_bit(slab_index(p, s, addr), map)) {
@@ -3689,8 +3707,9 @@ static void list_slab_objects(struct kmem_cache s, struct page page, · 1 unmodified line
3689	print_tracking(s, p);	3707	print_tracking(s, p);
3690	}	3708	}
3691	}	3709	}
		3710	put_map(map);
		3711
3692	slab_unlock(page);	3712	slab_unlock(page);
3693	bitmap_free(map);
3694	#endif	3713	#endif
3695	}	3714	}
3696		3715
@@ -4384,19 +4403,19 @@ static int count_total(struct page *page) · 687 unmodified lines
4384	#endif	4403	#endif
4385		4404
4386	#ifdef CONFIG_SLUB_DEBUG	4405	#ifdef CONFIG_SLUB_DEBUG
4387	static void validate_slab(struct kmem_cache s, struct page page,	4406	static void validate_slab(struct kmem_cache s, struct page page)
4388	unsigned long *map)
4389	{	4407	{
4390	void *p;	4408	void *p;
4391	void *addr = page_address(page);	4409	void *addr = page_address(page);
		4410	unsigned long *map;
		4411
		4412	slab_lock(page);
4392		4413
4393	if (!check_slab(s, page) \|\| !on_freelist(s, page, NULL))	4414	if (!check_slab(s, page) \|\| !on_freelist(s, page, NULL))
4394	return;	4415	goto unlock;
4395		4416
4396	/* Now we know that a valid freelist exists */	4417	/* Now we know that a valid freelist exists */
4397	bitmap_zero(map, page->objects);	4418	map = get_map(s, page);
4398
4399	get_map(s, page, map);
4400	for_each_object(p, s, addr, page->objects) {	4419	for_each_object(p, s, addr, page->objects) {
4401	u8 val = test_bit(slab_index(p, s, addr), map) ?	4420	u8 val = test_bit(slab_index(p, s, addr), map) ?
4402	SLUB_RED_INACTIVE : SLUB_RED_ACTIVE;	4421	SLUB_RED_INACTIVE : SLUB_RED_ACTIVE;
@@ -4404,18 +4423,13 @@ static void validate_slab(struct kmem_cache s, struct page page, · 1 unmodified line
4404	if (!check_object(s, page, p, val))	4423	if (!check_object(s, page, p, val))
4405	break;	4424	break;
4406	}	4425	}
4407	}	4426	put_map(map);
4408		4427	unlock:
4409	static void validate_slab_slab(struct kmem_cache s, struct page page,
4410	unsigned long *map)
4411	{
4412	slab_lock(page);
4413	validate_slab(s, page, map);
4414	slab_unlock(page);	4428	slab_unlock(page);
4415	}	4429	}
4416		4430
4417	static int validate_slab_node(struct kmem_cache *s,	4431	static int validate_slab_node(struct kmem_cache *s,
4418	struct kmem_cache_node n, unsigned long map)	4432	struct kmem_cache_node *n)
4419	{	4433	{
4420	unsigned long count = 0;	4434	unsigned long count = 0;
4421	struct page *page;	4435	struct page *page;
@@ -4424,7 +4438,7 @@ static int validate_slab_node(struct kmem_cache *s, · 2 unmodified lines
4424	spin_lock_irqsave(&n->list_lock, flags);	4438	spin_lock_irqsave(&n->list_lock, flags);
4425		4439
4426	list_for_each_entry(page, &n->partial, slab_list) {	4440	list_for_each_entry(page, &n->partial, slab_list) {
4427	validate_slab_slab(s, page, map);	4441	validate_slab(s, page);
4428	count++;	4442	count++;
4429	}	4443	}
4430	if (count != n->nr_partial)	4444	if (count != n->nr_partial)
@@ -4435,7 +4449,7 @@ static int validate_slab_node(struct kmem_cache *s, · 4 unmodified lines
4435	goto out;	4449	goto out;
4436		4450
4437	list_for_each_entry(page, &n->full, slab_list) {	4451	list_for_each_entry(page, &n->full, slab_list) {
4438	validate_slab_slab(s, page, map);	4452	validate_slab(s, page);
4439	count++;	4453	count++;
4440	}	4454	}
4441	if (count != atomic_long_read(&n->nr_slabs))	4455	if (count != atomic_long_read(&n->nr_slabs))
@@ -4452,15 +4466,11 @@ static long validate_slab_cache(struct kmem_cache *s) · 10 unmodified lines
4452	int node;	4466	int node;
4453	unsigned long count = 0;	4467	unsigned long count = 0;
4454	struct kmem_cache_node *n;	4468	struct kmem_cache_node *n;
4455	unsigned long *map = bitmap_alloc(oo_objects(s->max), GFP_KERNEL);
4456
4457	if (!map)
4458	return -ENOMEM;
4459		4469
4460	flush_all(s);	4470	flush_all(s);
4461	for_each_kmem_cache_node(s, node, n)	4471	for_each_kmem_cache_node(s, node, n)
4462	count += validate_slab_node(s, n, map);	4472	count += validate_slab_node(s, n);
4463	bitmap_free(map);	4473
4464	return count;	4474	return count;
4465	}	4475	}
4466	/*	4476	/*
@@ -4590,18 +4600,17 @@ static int add_location(struct loc_track t, struct kmem_cache s, · 123 unmodified lines
4590	}	4600	}
4591		4601
4592	static void process_slab(struct loc_track t, struct kmem_cache s,	4602	static void process_slab(struct loc_track t, struct kmem_cache s,
4593	struct page *page, enum track_item alloc,	4603	struct page *page, enum track_item alloc)
4594	unsigned long *map)
4595	{	4604	{
4596	void *addr = page_address(page);	4605	void *addr = page_address(page);
4597	void *p;	4606	void *p;
		4607	unsigned long *map;
4598		4608
4599	bitmap_zero(map, page->objects);	4609	map = get_map(s, page);
4600	get_map(s, page, map);
4601
4602	for_each_object(p, s, addr, page->objects)	4610	for_each_object(p, s, addr, page->objects)
4603	if (!test_bit(slab_index(p, s, addr), map))	4611	if (!test_bit(slab_index(p, s, addr), map))
4604	add_location(t, s, get_track(s, p, alloc));	4612	add_location(t, s, get_track(s, p, alloc));
		4613	put_map(map);
4605	}	4614	}
4606		4615
4607	static int list_locations(struct kmem_cache s, char buf,	4616	static int list_locations(struct kmem_cache s, char buf,
@@ -4612,11 +4621,9 @@ static int list_locations(struct kmem_cache s, char buf, · 4 unmodified lines
4612	struct loc_track t = { 0, 0, NULL };	4621	struct loc_track t = { 0, 0, NULL };
4613	int node;	4622	int node;
4614	struct kmem_cache_node *n;	4623	struct kmem_cache_node *n;
4615	unsigned long *map = bitmap_alloc(oo_objects(s->max), GFP_KERNEL);
4616		4624
4617	if (!map \|\| !alloc_loc_track(&t, PAGE_SIZE / sizeof(struct location),	4625	if (!alloc_loc_track(&t, PAGE_SIZE / sizeof(struct location),
4618	GFP_KERNEL)) {	4626	GFP_KERNEL)) {
4619	bitmap_free(map);
4620	return sprintf(buf, "Out of memory\n");	4627	return sprintf(buf, "Out of memory\n");
4621	}	4628	}
4622	/* Push back cpu slabs */	4629	/* Push back cpu slabs */
@@ -4631,9 +4638,9 @@ static int list_locations(struct kmem_cache s, char buf, · 8 unmodified lines
4631		4638
4632	spin_lock_irqsave(&n->list_lock, flags);	4639	spin_lock_irqsave(&n->list_lock, flags);
4633	list_for_each_entry(page, &n->partial, slab_list)	4640	list_for_each_entry(page, &n->partial, slab_list)
4634	process_slab(&t, s, page, alloc, map);	4641	process_slab(&t, s, page, alloc);
4635	list_for_each_entry(page, &n->full, slab_list)	4642	list_for_each_entry(page, &n->full, slab_list)
4636	process_slab(&t, s, page, alloc, map);	4643	process_slab(&t, s, page, alloc);
4637	spin_unlock_irqrestore(&n->list_lock, flags);	4644	spin_unlock_irqrestore(&n->list_lock, flags);
4638	}	4645	}
4639		4646
@@ -4682,7 +4689,6 @@ static int list_locations(struct kmem_cache s, char buf, · 42 unmodified lines
4682	}	4689	}
4683		4690
4684	free_loc_track(&t);	4691	free_loc_track(&t);
4685	bitmap_free(map);
4686	if (!t.count)	4692	if (!t.count)
4687	len += sprintf(buf, "No data\n");	4693	len += sprintf(buf, "No data\n");
4688	return len;	4694	return len;

mm/sparse.c+1−1

@@ -789,7 +789,7 @@ static void section_deactivate(unsigned long pfn, unsigned long nr_pages, · 788 unmodified lines
789	ms->usage = NULL;	789	ms->usage = NULL;
790	}	790	}
791	memmap = sparse_decode_mem_map(ms->section_mem_map, section_nr);	791	memmap = sparse_decode_mem_map(ms->section_mem_map, section_nr);
792	ms->section_mem_map = sparse_encode_mem_map(NULL, section_nr);	792	ms->section_mem_map = (unsigned long)NULL;
793	}	793	}
794		794
795	if (section_is_early && memmap)	795	if (section_is_early && memmap)

mm/swap.c+26−1

@@ -813,8 +813,10 @@ void release_pages(struct page **pages, int nr) · 812 unmodified lines
813	* processing, and instead, expect a call to	813	* processing, and instead, expect a call to
814	* put_page_testzero().	814	* put_page_testzero().
815	*/	815	*/
816	if (put_devmap_managed_page(page))	816	if (page_is_devmap_managed(page)) {
		817	put_devmap_managed_page(page);
817	continue;	818	continue;
		819	}
818	}	820	}
819		821
820	page = compound_head(page);	822	page = compound_head(page);
@@ -1102,3 +1104,26 @@ void __init swap_setup(void) · 281 unmodified lines
1102	* _really_ don't want to cluster much more	1104	* _really_ don't want to cluster much more
1103	*/	1105	*/
1104	}	1106	}
		1107
		1108	#ifdef CONFIG_DEV_PAGEMAP_OPS
		1109	void put_devmap_managed_page(struct page *page)
		1110	{
		1111	int count;
		1112
		1113	if (WARN_ON_ONCE(!page_is_devmap_managed(page)))
		1114	return;
		1115
		1116	count = page_ref_dec_return(page);
		1117
		1118	/*
		1119	* devmap page refcounts are 1-based, rather than 0-based: if
		1120	* refcount is 1, then the page is free and the refcount is
		1121	* stable because nobody holds a reference on the page.
		1122	*/
		1123	if (count == 1)
		1124	free_devmap_managed_page(page);
		1125	else if (!count)
		1126	__put_page(page);
		1127	}
		1128	EXPORT_SYMBOL(put_devmap_managed_page);
		1129	#endif

mm/swapfile.c+1−1

 	else
 		type = si->type + 1;
+	++(*pos);
 	for (; (si = swap_type_to_swap_info(type)); type++) {
 		if (!(si->flags & SWP_USED) || !si->swap_map)
 			continue;
-		++*pos;
 		return si;
 	}

mm/vmscan.c+3−21

 	struct reclaim_state reclaim_state;
 };
-#ifdef ARCH_HAS_PREFETCH
-#define prefetch_prev_lru_page(_page, _base, _field)			\
-	do {								\
-		if ((_page)->lru.prev != _base) {			\
-			struct page *prev;				\
-									\
-			prev = lru_to_page(&(_page->lru));		\
-			prefetch(&prev->_field);			\
-		}							\
-	} while (0)
-#else
-#define prefetch_prev_lru_page(_page, _base, _field) do { } while (0)
-#endif
 #ifdef ARCH_HAS_PREFETCHW
 #define prefetchw_prev_lru_page(_page, _base, _field)			\
 	do {								\
 	} while ((memcg = mem_cgroup_iter(target_memcg, memcg, NULL)));
 }
-static bool shrink_node(pg_data_t *pgdat, struct scan_control *sc)
+static void shrink_node(pg_data_t *pgdat, struct scan_control *sc)
 {
 	struct reclaim_state *reclaim_state = current->reclaim_state;
 	unsigned long nr_reclaimed, nr_scanned;
 	 */
 	if (reclaimable)
 		pgdat->kswapd_failures = 0;
-	return reclaimable;
 }
 /*
  */
 int node_reclaim_mode __read_mostly;
-#define RECLAIM_OFF 0
+#define RECLAIM_WRITE (1<<0)	/* Writeout pages during reclaim */
-#define RECLAIM_ZONE (1<<0)	/* Run shrink_inactive_list on the zone */
+#define RECLAIM_UNMAP (1<<1)	/* Unmap pages during reclaim */
-#define RECLAIM_WRITE (1<<1)	/* Writeout pages during reclaim */
-#define RECLAIM_UNMAP (1<<2)	/* Unmap pages during reclaim */
 /*
  * Priority for NODE_RECLAIM. This determines the fraction of pages

mm/zswap.c+55−31

 #include <linux/swapops.h>
 #include <linux/writeback.h>
 #include <linux/pagemap.h>
+#include <linux/workqueue.h>
 /*********************************
 * statistics
 /* Duplicate store was encountered (rare) */
 static u64 zswap_duplicate_entry;
+/* Shrinker work queue */
+static struct workqueue_struct *shrink_wq;
+/* Pool limit was hit, we need to calm down */
+static bool zswap_pool_reached_full;
 /*********************************
 * tunables
 **********************************/
 static unsigned int zswap_max_pool_percent = 20;
 module_param_named(max_pool_percent, zswap_max_pool_percent, uint, 0644);
+/* The threshold for accepting new pages after the max_pool_percent was hit */
+static unsigned int zswap_accept_thr_percent = 90; /* of max pool size */
+module_param_named(accept_threshold_percent, zswap_accept_thr_percent,
+		   uint, 0644);
 /* Enable/disable handling same-value filled pages (enabled by default) */
 static bool zswap_same_filled_pages_enabled = true;
 module_param_named(same_filled_pages_enabled, zswap_same_filled_pages_enabled,
 	struct crypto_comp * __percpu *tfm;
 	struct kref kref;
 	struct list_head list;
-	struct work_struct work;
+	struct work_struct release_work;
+	struct work_struct shrink_work;
 	struct hlist_node node;
 	char tfm_name[CRYPTO_MAX_ALG_NAME];
 };
 			DIV_ROUND_UP(zswap_pool_total_size, PAGE_SIZE);
 }
+static bool zswap_can_accept(void)
+{
+	return totalram_pages() * zswap_accept_thr_percent / 100 *
+				zswap_max_pool_percent / 100 >
+			DIV_ROUND_UP(zswap_pool_total_size, PAGE_SIZE);
+}
 static void zswap_update_total_size(void)
 {
 	struct zswap_pool *pool;
 	return NULL;
 }
+static void shrink_worker(struct work_struct *w)
+{
+	struct zswap_pool *pool = container_of(w, typeof(*pool),
+						shrink_work);
+	if (zpool_shrink(pool->zpool, 1, NULL))
+		zswap_reject_reclaim_fail++;
+	zswap_pool_put(pool);
+}
 static struct zswap_pool *zswap_pool_create(char *type, char *compressor)
 {
 	struct zswap_pool *pool;
 	 */
 	kref_init(&pool->kref);
 	INIT_LIST_HEAD(&pool->list);
+	INIT_WORK(&pool->shrink_work, shrink_worker);
 	zswap_pool_debug("created", pool);
 static void __zswap_pool_release(struct work_struct *work)
 {
-	struct zswap_pool *pool = container_of(work, typeof(*pool), work);
+	struct zswap_pool *pool = container_of(work, typeof(*pool),
+						release_work);
 	synchronize_rcu();
 	list_del_rcu(&pool->list);
-	INIT_WORK(&pool->work, __zswap_pool_release);
+	INIT_WORK(&pool->release_work, __zswap_pool_release);
-	schedule_work(&pool->work);
+	schedule_work(&pool->release_work);
 	spin_unlock(&zswap_pools_lock);
 }
 	return ret;
 }
-static int zswap_shrink(void)
-{
-	struct zswap_pool *pool;
-	int ret;
-	pool = zswap_pool_last_get();
-	if (!pool)
-		return -ENOENT;
-	ret = zpool_shrink(pool->zpool, 1, NULL);
-	zswap_pool_put(pool);
-	return ret;
-}
 static int zswap_is_page_same_filled(void *ptr, unsigned long *value)
 {
 	unsigned int pos;
 	/* reclaim space if needed */
 	if (zswap_is_full()) {
+		struct zswap_pool *pool;
 		zswap_pool_limit_hit++;
-		if (zswap_shrink()) {
+		zswap_pool_reached_full = true;
-			zswap_reject_reclaim_fail++;
+		pool = zswap_pool_last_get();
-			ret = -ENOMEM;
+		if (pool)
-			goto reject;
+			queue_work(shrink_wq, &pool->shrink_work);
-		}
+		ret = -ENOMEM;
+		goto reject;
+	}
-		/* A second zswap_is_full() check after
+	if (zswap_pool_reached_full) {
-		 * zswap_shrink() to make sure it's now
+	       if (!zswap_can_accept()) {
-		 * under the max_pool_percent
-		 */
-		if (zswap_is_full()) {
 			ret = -ENOMEM;
 			goto reject;
-		}
+		} else
+			zswap_pool_reached_full = false;
 	}
 	/* allocate entry */
 		zswap_enabled = false;
 	}
+	shrink_wq = create_workqueue("zswap-shrink");
+	if (!shrink_wq)
+		goto fallback_fail;
 	frontswap_register_ops(&zswap_frontswap_ops);
 	if (zswap_debugfs_init())
 		pr_warn("debugfs initialization failed\n");
 	return 0;
+fallback_fail:
+	if (pool)
+		zswap_pool_destroy(pool);
 hp_fail:
 	cpuhp_remove_state(CPUHP_MM_ZSWP_MEM_PREPARE);
 dstmem_fail:

net/xdp/xdp_umem.c+2−2

@@ -212,7 +212,7 @@ static int xdp_umem_map_pages(struct xdp_umem *umem) · 211 unmodified lines
212		212
213	static void xdp_umem_unpin_pages(struct xdp_umem *umem)	213	static void xdp_umem_unpin_pages(struct xdp_umem *umem)
214	{	214	{
215	put_user_pages_dirty_lock(umem->pgs, umem->npgs, true);	215	unpin_user_pages_dirty_lock(umem->pgs, umem->npgs, true);
216		216
217	kfree(umem->pgs);	217	kfree(umem->pgs);
218	umem->pgs = NULL;	218	umem->pgs = NULL;
@@ -291,7 +291,7 @@ static int xdp_umem_pin_pages(struct xdp_umem *umem) · 72 unmodified lines
291	return -ENOMEM;	291	return -ENOMEM;
292		292
293	down_read(&current->mm->mmap_sem);	293	down_read(&current->mm->mmap_sem);
294	npgs = get_user_pages(umem->address, umem->npgs,	294	npgs = pin_user_pages(umem->address, umem->npgs,
295	gup_flags \| FOLL_LONGTERM, &umem->pgs[0], NULL);	295	gup_flags \| FOLL_LONGTERM, &umem->pgs[0], NULL);
296	up_read(&current->mm->mmap_sem);	296	up_read(&current->mm->mmap_sem);
297		297

scripts/spelling.txt+14−0

@@ -39,6 +39,8 @@ accout\|\|account · 38 unmodified lines
39	accquire\|\|acquire	39	accquire\|\|acquire
40	accquired\|\|acquired	40	accquired\|\|acquired
41	accross\|\|across	41	accross\|\|across
		42	accumalate\|\|accumulate
		43	accumalator\|\|accumulator
42	acessable\|\|accessible	44	acessable\|\|accessible
43	acess\|\|access	45	acess\|\|access
44	acessing\|\|accessing	46	acessing\|\|accessing
@@ -106,6 +108,7 @@ alogrithm\|\|algorithm · 61 unmodified lines
106	alot\|\|a lot	108	alot\|\|a lot
107	alow\|\|allow	109	alow\|\|allow
108	alows\|\|allows	110	alows\|\|allows
		111	alreay\|\|already
109	alredy\|\|already	112	alredy\|\|already
110	altough\|\|although	113	altough\|\|although
111	alue\|\|value	114	alue\|\|value
@@ -241,6 +244,7 @@ calender\|\|calendar · 129 unmodified lines
241	calescing\|\|coalescing	244	calescing\|\|coalescing
242	calle\|\|called	245	calle\|\|called
243	callibration\|\|calibration	246	callibration\|\|calibration
		247	callled\|\|called
244	calucate\|\|calculate	248	calucate\|\|calculate
245	calulate\|\|calculate	249	calulate\|\|calculate
246	cancelation\|\|cancellation	250	cancelation\|\|cancellation
@@ -311,6 +315,7 @@ compaibility\|\|compatibility · 64 unmodified lines
311	comparsion\|\|comparison	315	comparsion\|\|comparison
312	compatability\|\|compatibility	316	compatability\|\|compatibility
313	compatable\|\|compatible	317	compatable\|\|compatible
		318	compatibililty\|\|compatibility
314	compatibiliy\|\|compatibility	319	compatibiliy\|\|compatibility
315	compatibilty\|\|compatibility	320	compatibilty\|\|compatibility
316	compatiblity\|\|compatibility	321	compatiblity\|\|compatibility
@@ -330,6 +335,7 @@ comunication\|\|communication · 13 unmodified lines
330	conbination\|\|combination	335	conbination\|\|combination
331	conditionaly\|\|conditionally	336	conditionaly\|\|conditionally
332	conditon\|\|condition	337	conditon\|\|condition
		338	condtion\|\|condition
333	conected\|\|connected	339	conected\|\|connected
334	conector\|\|connector	340	conector\|\|connector
335	connecetd\|\|connected	341	connecetd\|\|connected
@@ -388,6 +394,8 @@ dafault\|\|default · 52 unmodified lines
388	deafult\|\|default	394	deafult\|\|default
389	deamon\|\|daemon	395	deamon\|\|daemon
390	debouce\|\|debounce	396	debouce\|\|debounce
		397	decendant\|\|descendant
		398	decendants\|\|descendants
391	decompres\|\|decompress	399	decompres\|\|decompress
392	decsribed\|\|described	400	decsribed\|\|described
393	decription\|\|description	401	decription\|\|description
@@ -411,11 +419,13 @@ delare\|\|declare · 17 unmodified lines
411	delares\|\|declares	419	delares\|\|declares
412	delaring\|\|declaring	420	delaring\|\|declaring
413	delemiter\|\|delimiter	421	delemiter\|\|delimiter
		422	delievered\|\|delivered
414	demodualtor\|\|demodulator	423	demodualtor\|\|demodulator
415	demension\|\|dimension	424	demension\|\|dimension
416	dependancies\|\|dependencies	425	dependancies\|\|dependencies
417	dependancy\|\|dependency	426	dependancy\|\|dependency
418	dependant\|\|dependent	427	dependant\|\|dependent
		428	dependend\|\|dependent
419	depreacted\|\|deprecated	429	depreacted\|\|deprecated
420	depreacte\|\|deprecate	430	depreacte\|\|deprecate
421	desactivate\|\|deactivate	431	desactivate\|\|deactivate
@@ -791,6 +801,7 @@ ireelevant\|\|irrelevant · 369 unmodified lines
791	irrelevent\|\|irrelevant	801	irrelevent\|\|irrelevant
792	isnt\|\|isn't	802	isnt\|\|isn't
793	isssue\|\|issue	803	isssue\|\|issue
		804	issus\|\|issues
794	iternations\|\|iterations	805	iternations\|\|iterations
795	itertation\|\|iteration	806	itertation\|\|iteration
796	itslef\|\|itself	807	itslef\|\|itself
@@ -995,6 +1006,7 @@ peice\|\|piece · 198 unmodified lines
995	pendantic\|\|pedantic	1006	pendantic\|\|pedantic
996	peprocessor\|\|preprocessor	1007	peprocessor\|\|preprocessor
997	perfoming\|\|performing	1008	perfoming\|\|performing
		1009	perfomring\|\|performing
998	peripherial\|\|peripheral	1010	peripherial\|\|peripheral
999	permissons\|\|permissions	1011	permissons\|\|permissions
1000	peroid\|\|period	1012	peroid\|\|period
@@ -1166,6 +1178,8 @@ retreive\|\|retrieve · 165 unmodified lines
1166	retreiving\|\|retrieving	1178	retreiving\|\|retrieving
1167	retrive\|\|retrieve	1179	retrive\|\|retrieve
1168	retrived\|\|retrieved	1180	retrived\|\|retrieved
		1181	retrun\|\|return
		1182	retun\|\|return
1169	retuned\|\|returned	1183	retuned\|\|returned
1170	reudce\|\|reduce	1184	reudce\|\|reduce
1171	reuest\|\|request	1185	reuest\|\|request

tools/testing/selftests/vm/gup_benchmark.c+5−1

 #define GUP_LONGTERM_BENCHMARK	_IOWR('g', 2, struct gup_benchmark)
 #define GUP_BENCHMARK		_IOWR('g', 3, struct gup_benchmark)
+/* Just the flags we need, copied from mm.h: */
+#define FOLL_WRITE	0x01	/* check pte is writable */
 struct gup_benchmark {
 	__u64 get_delta_usec;
 	__u64 put_delta_usec;
 	}
 	gup.nr_pages_per_call = nr_pages;
-	gup.flags = write;
+	if (write)
+		gup.flags |= FOLL_WRITE;
 	fd = open("/sys/kernel/debug/gup_benchmark", O_RDWR);
 	if (fd == -1)

tools/vm/slabinfo.c+2−2

@@ -720,11 +720,11 @@ static void slab_debug(struct slabinfo *s) · 719 unmodified lines
720	return;	720	return;
721		721
722	if (sanity && !s->sanity_checks) {	722	if (sanity && !s->sanity_checks) {
723	set_obj(s, "sanity", 1);	723	set_obj(s, "sanity_checks", 1);
724	}	724	}
725	if (!sanity && s->sanity_checks) {	725	if (!sanity && s->sanity_checks) {
726	if (slab_empty(s))	726	if (slab_empty(s))
727	set_obj(s, "sanity", 0);	727	set_obj(s, "sanity_checks", 0);
728	else	728	else
729	fprintf(stderr, "%s not empty cannot disable sanity checks\n", s->name);	729	fprintf(stderr, "%s not empty cannot disable sanity checks\n", s->name);
730	}	730	}