lael-labs/linux

Documentation/admin-guide/kdump/kdump.rst+4−4

 	CONFIG_KEXEC_CORE=y
-   Subsequently, CRASH_CORE is selected by KEXEC_CORE::
-	CONFIG_CRASH_CORE=y
 2) Enable "sysfs file system support" in "Filesystem" -> "Pseudo
    filesystems." This is usually enabled by default::
 	CONFIG_CRASH_DUMP=y
+   And this will select VMCORE_INFO and CRASH_RESERVE::
+	CONFIG_VMCORE_INFO=y
+	CONFIG_CRASH_RESERVE=y
 2) Enable "/proc/vmcore support" under "Filesystems" -> "Pseudo filesystems"::
 	CONFIG_PROC_VMCORE=y

Documentation/admin-guide/kernel-parameters.txt+3−2

 			Format: [state][,regs][,debounce][,die]
 	nmi_watchdog=	[KNL,BUGS=X86] Debugging features for SMP kernels
-			Format: [panic,][nopanic,][num]
+			Format: [panic,][nopanic,][rNNN,][num]
 			Valid num: 0 or 1
 			0 - turn hardlockup detector in nmi_watchdog off
 			1 - turn hardlockup detector in nmi_watchdog on
+			rNNN - configure the watchdog with raw perf event 0xNNN
 			When panic is specified, panic when an NMI watchdog
 			timeout occurs (or 'nopanic' to not panic on an NMI
 			watchdog, if CONFIG_BOOTPARAM_HARDLOCKUP_PANIC is set)
 				memory, and other data can't be written using
 				xmon commands.
 			off	xmon is disabled.

Documentation/dev-tools/checkpatch.rst+14−0

@@ -906,6 +906,20 @@ Macros, Attributes and Symbols · 905 unmodified lines
906		906
907	See: https://lore.kernel.org/lkml/1399671106.2912.21.camel@joe-AO725/	907	See: https://lore.kernel.org/lkml/1399671106.2912.21.camel@joe-AO725/
908		908
		909	MACRO_ARG_UNUSED
		910	If function-like macros do not utilize a parameter, it might result
		911	in a build warning. We advocate for utilizing static inline functions
		912	to replace such macros.
		913	For example, for a macro such as the one below::
		914
		915	#define test(a) do { } while (0)
		916
		917	there would be a warning like below::
		918
		919	WARNING: Argument 'a' is not used in function-like macro.
		920
		921	See: https://www.kernel.org/doc/html/latest/process/coding-style.html#macros-enums-and-rtl
		922
909	SINGLE_STATEMENT_DO_WHILE_MACRO	923	SINGLE_STATEMENT_DO_WHILE_MACRO
910	For the multi-statement macros, it is necessary to use the do-while	924	For the multi-statement macros, it is necessary to use the do-while
911	loop to avoid unpredictable code paths. The do-while loop helps to	925	loop to avoid unpredictable code paths. The do-while loop helps to

Documentation/process/coding-style.rst+23−0

@@ -827,6 +827,29 @@ Macros with multiple statements should be enclosed in a do - while block: · 826 unmodified lines
827	do_this(b, c); \	827	do_this(b, c); \
828	} while (0)	828	} while (0)
829		829
		830	Function-like macros with unused parameters should be replaced by static
		831	inline functions to avoid the issue of unused variables:
		832
		833	.. code-block:: c
		834
		835	static inline void fun(struct foo *foo)
		836	{
		837	}
		838
		839	Due to historical practices, many files still employ the "cast to (void)"
		840	approach to evaluate parameters. However, this method is not advisable.
		841	Inline functions address the issue of "expression with side effects
		842	evaluated more than once", circumvent unused-variable problems, and
		843	are generally better documented than macros for some reason.
		844
		845	.. code-block:: c
		846
		847	/*
		848	* Avoid doing this whenever possible and instead opt for static
		849	* inline functions
		850	*/
		851	#define macrofun(foo) do { (void) (foo); } while (0)
		852
830	Things to avoid when using macros:	853	Things to avoid when using macros:
831		854
832	1) macros that affect control flow:	855	1) macros that affect control flow:

arch/x86/lib/copy_mc.c+17−4

@@ -4,6 +4,7 @@ · 3 unmodified lines
4	#include <linux/jump_label.h>	4	#include <linux/jump_label.h>
5	#include <linux/uaccess.h>	5	#include <linux/uaccess.h>
6	#include <linux/export.h>	6	#include <linux/export.h>
		7	#include <linux/instrumented.h>
7	#include <linux/string.h>	8	#include <linux/string.h>
8	#include <linux/types.h>	9	#include <linux/types.h>
9		10
@@ -61,10 +62,20 @@ unsigned long copy_mc_enhanced_fast_string(void dst, const void src, unsigned · 51 unmodified lines
61	*/	62	*/
62	unsigned long __must_check copy_mc_to_kernel(void dst, const void src, unsigned len)	63	unsigned long __must_check copy_mc_to_kernel(void dst, const void src, unsigned len)
63	{	64	{
64	if (copy_mc_fragile_enabled)	65	unsigned long ret;
65	return copy_mc_fragile(dst, src, len);	66
66	if (static_cpu_has(X86_FEATURE_ERMS))	67	if (copy_mc_fragile_enabled) {
67	return copy_mc_enhanced_fast_string(dst, src, len);	68	instrument_memcpy_before(dst, src, len);
		69	ret = copy_mc_fragile(dst, src, len);
		70	instrument_memcpy_after(dst, src, len, ret);
		71	return ret;
		72	}
		73	if (static_cpu_has(X86_FEATURE_ERMS)) {
		74	instrument_memcpy_before(dst, src, len);
		75	ret = copy_mc_enhanced_fast_string(dst, src, len);
		76	instrument_memcpy_after(dst, src, len, ret);
		77	return ret;
		78	}
68	memcpy(dst, src, len);	79	memcpy(dst, src, len);
69	return 0;	80	return 0;
70	}	81	}
@@ -75,6 +86,7 @@ unsigned long __must_check copy_mc_to_user(void __user dst, const void src, un · 4 unmodified lines
75	unsigned long ret;	86	unsigned long ret;
76		87
77	if (copy_mc_fragile_enabled) {	88	if (copy_mc_fragile_enabled) {
		89	instrument_copy_to_user(dst, src, len);
78	__uaccess_begin();	90	__uaccess_begin();
79	ret = copy_mc_fragile((__force void *)dst, src, len);	91	ret = copy_mc_fragile((__force void *)dst, src, len);
80	__uaccess_end();	92	__uaccess_end();
@@ -82,6 +94,7 @@ unsigned long __must_check copy_mc_to_user(void __user dst, const void src, un · 1 unmodified line
82	}	94	}
83		95
84	if (static_cpu_has(X86_FEATURE_ERMS)) {	96	if (static_cpu_has(X86_FEATURE_ERMS)) {
		97	instrument_copy_to_user(dst, src, len);
85	__uaccess_begin();	98	__uaccess_begin();
86	ret = copy_mc_enhanced_fast_string((__force void *)dst, src, len);	99	ret = copy_mc_enhanced_fast_string((__force void *)dst, src, len);
87	__uaccess_end();	100	__uaccess_end();

block/partitions/ldm.c+2−4

 		ldm_crit ("Cannot find TOCBLOCK, database may be corrupt.");
 		return false;
 	}
-	strncpy (toc->bitmap1_name, data + 0x24, sizeof (toc->bitmap1_name));
+	strscpy_pad(toc->bitmap1_name, data + 0x24, sizeof(toc->bitmap1_name));
-	toc->bitmap1_name[sizeof (toc->bitmap1_name) - 1] = 0;
 	toc->bitmap1_start = get_unaligned_be64(data + 0x2E);
 	toc->bitmap1_size  = get_unaligned_be64(data + 0x36);
 				TOC_BITMAP1, toc->bitmap1_name);
 		return false;
 	}
-	strncpy (toc->bitmap2_name, data + 0x46, sizeof (toc->bitmap2_name));
+	strscpy_pad(toc->bitmap2_name, data + 0x46, sizeof(toc->bitmap2_name));
-	toc->bitmap2_name[sizeof (toc->bitmap2_name) - 1] = 0;
 	toc->bitmap2_start = get_unaligned_be64(data + 0x50);
 	toc->bitmap2_size  = get_unaligned_be64(data + 0x58);
 	if (strncmp (toc->bitmap2_name, TOC_BITMAP2,

drivers/hwtracing/intel_th/core.c+3−3

@@ -871,7 +871,7 @@ intel_th_alloc(struct device dev, const struct intel_th_drvdata drvdata, · 870 unmodified lines
871	if (!th)	871	if (!th)
872	return ERR_PTR(-ENOMEM);	872	return ERR_PTR(-ENOMEM);
873		873
874	th->id = ida_simple_get(&intel_th_ida, 0, 0, GFP_KERNEL);	874	th->id = ida_alloc(&intel_th_ida, GFP_KERNEL);
875	if (th->id < 0) {	875	if (th->id < 0) {
876	err = th->id;	876	err = th->id;
877	goto err_alloc;	877	goto err_alloc;
@@ -931,7 +931,7 @@ err_chrdev: · 53 unmodified lines
931	"intel_th/output");	931	"intel_th/output");
932		932
933	err_ida:	933	err_ida:
934	ida_simple_remove(&intel_th_ida, th->id);	934	ida_free(&intel_th_ida, th->id);
935		935
936	err_alloc:	936	err_alloc:
937	kfree(th);	937	kfree(th);
@@ -964,7 +964,7 @@ void intel_th_free(struct intel_th *th) · 26 unmodified lines
964	__unregister_chrdev(th->major, 0, TH_POSSIBLE_OUTPUTS,	964	__unregister_chrdev(th->major, 0, TH_POSSIBLE_OUTPUTS,
965	"intel_th/output");	965	"intel_th/output");
966		966
967	ida_simple_remove(&intel_th_ida, th->id);	967	ida_free(&intel_th_ida, th->id);
968		968
969	kfree(th);	969	kfree(th);
970	}	970	}

drivers/media/cec/platform/sti/stih-cec.c+1−0

@@ -6,6 +6,7 @@ · 5 unmodified lines
6	*/	6	*/
7	#include <linux/clk.h>	7	#include <linux/clk.h>
8	#include <linux/interrupt.h>	8	#include <linux/interrupt.h>
		9	#include <linux/io.h>
9	#include <linux/kernel.h>	10	#include <linux/kernel.h>
10	#include <linux/mfd/syscon.h>	11	#include <linux/mfd/syscon.h>
11	#include <linux/module.h>	12	#include <linux/module.h>

drivers/media/rc/mtk-cir.c+1−0

@@ -8,6 +8,7 @@ · 7 unmodified lines
8	#include <linux/clk.h>	8	#include <linux/clk.h>
9	#include <linux/interrupt.h>	9	#include <linux/interrupt.h>
10	#include <linux/module.h>	10	#include <linux/module.h>
		11	#include <linux/io.h>
11	#include <linux/of.h>	12	#include <linux/of.h>
12	#include <linux/platform_device.h>	13	#include <linux/platform_device.h>
13	#include <linux/reset.h>	14	#include <linux/reset.h>

drivers/media/rc/serial_ir.c+1−0

@@ -18,6 +18,7 @@ · 17 unmodified lines
18	#include <linux/module.h>	18	#include <linux/module.h>
19	#include <linux/errno.h>	19	#include <linux/errno.h>
20	#include <linux/interrupt.h>	20	#include <linux/interrupt.h>
		21	#include <linux/io.h>
21	#include <linux/kernel.h>	22	#include <linux/kernel.h>
22	#include <linux/serial_reg.h>	23	#include <linux/serial_reg.h>
23	#include <linux/types.h>	24	#include <linux/types.h>

drivers/media/rc/st_rc.c+1−0

@@ -6,6 +6,7 @@ · 5 unmodified lines
6	#include <linux/kernel.h>	6	#include <linux/kernel.h>
7	#include <linux/clk.h>	7	#include <linux/clk.h>
8	#include <linux/interrupt.h>	8	#include <linux/interrupt.h>
		9	#include <linux/io.h>
9	#include <linux/module.h>	10	#include <linux/module.h>
10	#include <linux/of.h>	11	#include <linux/of.h>
11	#include <linux/platform_device.h>	12	#include <linux/platform_device.h>

drivers/media/rc/sunxi-cir.c+1−0

@@ -12,6 +12,7 @@ · 11 unmodified lines
12		12
13	#include <linux/clk.h>	13	#include <linux/clk.h>
14	#include <linux/interrupt.h>	14	#include <linux/interrupt.h>
		15	#include <linux/io.h>
15	#include <linux/module.h>	16	#include <linux/module.h>
16	#include <linux/of.h>	17	#include <linux/of.h>
17	#include <linux/platform_device.h>	18	#include <linux/platform_device.h>

drivers/mux/core.c+2−2

@@ -64,7 +64,7 @@ static void mux_chip_release(struct device *dev) · 63 unmodified lines
64	{	64	{
65	struct mux_chip *mux_chip = to_mux_chip(dev);	65	struct mux_chip *mux_chip = to_mux_chip(dev);
66		66
67	ida_simple_remove(&mux_ida, mux_chip->id);	67	ida_free(&mux_ida, mux_chip->id);
68	kfree(mux_chip);	68	kfree(mux_chip);
69	}	69	}
70		70
@@ -111,7 +111,7 @@ struct mux_chip mux_chip_alloc(struct device dev, · 40 unmodified lines
111	mux_chip->dev.of_node = dev->of_node;	111	mux_chip->dev.of_node = dev->of_node;
112	dev_set_drvdata(&mux_chip->dev, mux_chip);	112	dev_set_drvdata(&mux_chip->dev, mux_chip);
113		113
114	mux_chip->id = ida_simple_get(&mux_ida, 0, 0, GFP_KERNEL);	114	mux_chip->id = ida_alloc(&mux_ida, GFP_KERNEL);
115	if (mux_chip->id < 0) {	115	if (mux_chip->id < 0) {
116	int err = mux_chip->id;	116	int err = mux_chip->id;
117		117

drivers/pps/clients/pps_parport.c+3−3

@@ -148,7 +148,7 @@ static void parport_attach(struct parport *port) · 147 unmodified lines
148	return;	148	return;
149	}	149	}
150		150
151	index = ida_simple_get(&pps_client_index, 0, 0, GFP_KERNEL);	151	index = ida_alloc(&pps_client_index, GFP_KERNEL);
152	memset(&pps_client_cb, 0, sizeof(pps_client_cb));	152	memset(&pps_client_cb, 0, sizeof(pps_client_cb));
153	pps_client_cb.private = device;	153	pps_client_cb.private = device;
154	pps_client_cb.irq_func = parport_irq;	154	pps_client_cb.irq_func = parport_irq;
@@ -188,7 +188,7 @@ err_release_dev: · 33 unmodified lines
188	err_unregister_dev:	188	err_unregister_dev:
189	parport_unregister_device(device->pardev);	189	parport_unregister_device(device->pardev);
190	err_free:	190	err_free:
191	ida_simple_remove(&pps_client_index, index);	191	ida_free(&pps_client_index, index);
192	kfree(device);	192	kfree(device);
193	}	193	}
194		194
@@ -208,7 +208,7 @@ static void parport_detach(struct parport *port) · 13 unmodified lines
208	pps_unregister_source(device->pps);	208	pps_unregister_source(device->pps);
209	parport_release(pardev);	209	parport_release(pardev);
210	parport_unregister_device(pardev);	210	parport_unregister_device(pardev);
211	ida_simple_remove(&pps_client_index, device->index);	211	ida_free(&pps_client_index, device->index);
212	kfree(device);	212	kfree(device);
213	}	213	}
214		214

fs/binfmt_elf.c+1−1

@@ -1934,7 +1934,7 @@ static void free_note_info(struct elf_note_info *info) · 1933 unmodified lines
1934	threads = t->next;	1934	threads = t->next;
1935	WARN_ON(t->notes[0].data && t->notes[0].data != &t->prstatus);	1935	WARN_ON(t->notes[0].data && t->notes[0].data != &t->prstatus);
1936	for (i = 1; i < info->thread_notes; ++i)	1936	for (i = 1; i < info->thread_notes; ++i)
1937	kfree(t->notes[i].data);	1937	kvfree(t->notes[i].data);
1938	kfree(t);	1938	kfree(t);
1939	}	1939	}
1940	kfree(info->psinfo.data);	1940	kfree(info->psinfo.data);

fs/fat/dir.c+12−0

@@ -269,6 +269,18 @@ enum { PARSE_INVALID = 1, PARSE_NOT_LONGNAME, PARSE_EOF, }; · 268 unmodified lines
269	/**	269	/**
270	* fat_parse_long - Parse extended directory entry.	270	* fat_parse_long - Parse extended directory entry.
271	*	271	*
		272	* @dir: Pointer to the inode that represents the directory.
		273	* @pos: On input, contains the starting position to read from.
		274	* On output, updated with the new position.
		275	* @bh: Pointer to the buffer head that may be used for reading directory
		276	* entries. May be updated.
		277	* @de: On input, points to the current directory entry.
		278	* On output, points to the next directory entry.
		279	* @unicode: Pointer to a buffer where the parsed Unicode long filename will be
		280	* stored.
		281	* @nr_slots: Pointer to a variable that will store the number of longname
		282	* slots found.
		283	*
272	* This function returns zero on success, negative value on error, or one of	284	* This function returns zero on success, negative value on error, or one of
273	* the following:	285	* the following:
274	*	286	*

fs/nilfs2/btree.c+16−7

 }
 /**
- * nilfs_btree_convert_and_insert -
+ * nilfs_btree_convert_and_insert - Convert and insert entries into a B-tree
- * @bmap:
+ * @btree: NILFS B-tree structure
- * @key:
+ * @key: Key of the new entry to be inserted
- * @ptr:
+ * @ptr: Pointer (block number) associated with the key to be inserted
- * @keys:
+ * @keys: Array of keys to be inserted in addition to @key
- * @ptrs:
+ * @ptrs: Array of pointers associated with @keys
- * @n:
+ * @n: Number of keys and pointers in @keys and @ptrs
+ *
+ * This function is used to insert a new entry specified by @key and @ptr,
+ * along with additional entries specified by @keys and @ptrs arrays, into a
+ * NILFS B-tree.
+ * It prepares the necessary changes by allocating the required blocks and any
+ * necessary intermediate nodes. It converts configurations from other forms of
+ * block mapping (the one that currently exists is direct mapping) to a B-tree.
+ *
+ * Return: 0 on success or a negative error code on failure.
  */
 int nilfs_btree_convert_and_insert(struct nilfs_bmap *btree,
 				   __u64 key, __u64 ptr,

fs/nilfs2/dir.c+0−1

@@ -174,7 +174,6 @@ Eend: · 173 unmodified lines
174	dir->i_ino, (folio->index << PAGE_SHIFT) + offs,	174	dir->i_ino, (folio->index << PAGE_SHIFT) + offs,
175	(unsigned long)le64_to_cpu(p->inode));	175	(unsigned long)le64_to_cpu(p->inode));
176	fail:	176	fail:
177	folio_set_error(folio);
178	return false;	177	return false;
179	}	178	}
180		179

fs/nilfs2/gcinode.c+1−0

@@ -175,6 +175,7 @@ int nilfs_init_gcinode(struct inode *inode) · 174 unmodified lines
175		175
176	/**	176	/**
177	* nilfs_remove_all_gcinodes() - remove all unprocessed gc inodes	177	* nilfs_remove_all_gcinodes() - remove all unprocessed gc inodes
		178	* @nilfs: NILFS filesystem instance
178	*/	179	*/
179	void nilfs_remove_all_gcinodes(struct the_nilfs *nilfs)	180	void nilfs_remove_all_gcinodes(struct the_nilfs *nilfs)
180	{	181	{

fs/nilfs2/nilfs.h+2−2

@@ -335,8 +335,8 @@ void __nilfs_error(struct super_block sb, const char function, · 334 unmodified lines
335		335
336	extern struct nilfs_super_block *	336	extern struct nilfs_super_block *
337	nilfs_read_super_block(struct super_block , u64, int, struct buffer_head *);	337	nilfs_read_super_block(struct super_block , u64, int, struct buffer_head *);
338	extern int nilfs_store_magic_and_option(struct super_block *,	338	extern int nilfs_store_magic(struct super_block *sb,
339	struct nilfs_super_block , char );	339	struct nilfs_super_block *sbp);
340	extern int nilfs_check_feature_compatibility(struct super_block *,	340	extern int nilfs_check_feature_compatibility(struct super_block *,
341	struct nilfs_super_block *);	341	struct nilfs_super_block *);
342	extern void nilfs_set_log_cursor(struct nilfs_super_block *,	342	extern void nilfs_set_log_cursor(struct nilfs_super_block *,

fs/nilfs2/recovery.c+4−1

  * checkpoint
  * @nilfs: nilfs object
  * @sb: super block instance
+ * @root: NILFS root instance
  * @ri: pointer to a nilfs_recovery_info
  */
 static int nilfs_do_roll_forward(struct the_nilfs *nilfs,
 		return;
 	bh = __getblk(nilfs->ns_bdev, ri->ri_lsegs_start, nilfs->ns_blocksize);
-	BUG_ON(!bh);
+	if (WARN_ON(!bh))
+		return;  /* should never happen */
 	memset(bh->b_data, 0, bh->b_size);
 	set_buffer_dirty(bh);
 	err = sync_dirty_buffer(bh);

fs/nilfs2/segment.c+1−7

 		return;
 	}
-	if (!err) {
+	if (err || !nilfs_folio_buffers_clean(folio))
-		if (!nilfs_folio_buffers_clean(folio))
-			filemap_dirty_folio(folio->mapping, folio);
-		folio_clear_error(folio);
-	} else {
 		filemap_dirty_folio(folio->mapping, folio);
-		folio_set_error(folio);
-	}
 	folio_end_writeback(folio);
 }

fs/nilfs2/super.c+169−219

@@ -29,13 +29,13 @@ · 28 unmodified lines
29	#include <linux/slab.h>	29	#include <linux/slab.h>
30	#include <linux/init.h>	30	#include <linux/init.h>
31	#include <linux/blkdev.h>	31	#include <linux/blkdev.h>
32	#include <linux/parser.h>
33	#include <linux/crc32.h>	32	#include <linux/crc32.h>
34	#include <linux/vfs.h>	33	#include <linux/vfs.h>
35	#include <linux/writeback.h>	34	#include <linux/writeback.h>
36	#include <linux/seq_file.h>	35	#include <linux/seq_file.h>
37	#include <linux/mount.h>	36	#include <linux/mount.h>
38	#include <linux/fs_context.h>	37	#include <linux/fs_context.h>
		38	#include <linux/fs_parser.h>
39	#include "nilfs.h"	39	#include "nilfs.h"
40	#include "export.h"	40	#include "export.h"
41	#include "mdt.h"	41	#include "mdt.h"
@@ -61,7 +61,6 @@ struct kmem_cache *nilfs_segbuf_cachep; · 19 unmodified lines
61	struct kmem_cache *nilfs_btree_path_cache;	61	struct kmem_cache *nilfs_btree_path_cache;
62		62
63	static int nilfs_setup_super(struct super_block *sb, int is_mount);	63	static int nilfs_setup_super(struct super_block *sb, int is_mount);
64	static int nilfs_remount(struct super_block sb, int flags, char *data);
65		64
66	void __nilfs_msg(struct super_block sb, const char fmt, ...)	65	void __nilfs_msg(struct super_block sb, const char fmt, ...)
67	{	66	{
@@ -702,105 +701,98 @@ static const struct super_operations nilfs_sops = { · 634 unmodified lines
702	.freeze_fs = nilfs_freeze,	701	.freeze_fs = nilfs_freeze,
703	.unfreeze_fs = nilfs_unfreeze,	702	.unfreeze_fs = nilfs_unfreeze,
704	.statfs = nilfs_statfs,	703	.statfs = nilfs_statfs,
705	.remount_fs = nilfs_remount,
706	.show_options = nilfs_show_options	704	.show_options = nilfs_show_options
707	};	705	};
708		706
709	enum {	707	enum {
710	Opt_err_cont, Opt_err_panic, Opt_err_ro,	708	Opt_err, Opt_barrier, Opt_snapshot, Opt_order, Opt_norecovery,
711	Opt_barrier, Opt_nobarrier, Opt_snapshot, Opt_order, Opt_norecovery,	709	Opt_discard,
712	Opt_discard, Opt_nodiscard, Opt_err,
713	};	710	};
714		711
715	static match_table_t tokens = {	712	static const struct constant_table nilfs_param_err[] = {
716	{Opt_err_cont, "errors=continue"},	713	{"continue", NILFS_MOUNT_ERRORS_CONT},
717	{Opt_err_panic, "errors=panic"},	714	{"panic", NILFS_MOUNT_ERRORS_PANIC},
718	{Opt_err_ro, "errors=remount-ro"},	715	{"remount-ro", NILFS_MOUNT_ERRORS_RO},
719	{Opt_barrier, "barrier"},	716	{}
720	{Opt_nobarrier, "nobarrier"},
721	{Opt_snapshot, "cp=%u"},
722	{Opt_order, "order=%s"},
723	{Opt_norecovery, "norecovery"},
724	{Opt_discard, "discard"},
725	{Opt_nodiscard, "nodiscard"},
726	{Opt_err, NULL}
727	};	717	};
728		718
729	static int parse_options(char options, struct super_block sb, int is_remount)	719	static const struct fs_parameter_spec nilfs_param_spec[] = {
730	{	720	fsparam_enum ("errors", Opt_err, nilfs_param_err),
731	struct the_nilfs *nilfs = sb->s_fs_info;	721	fsparam_flag_no ("barrier", Opt_barrier),
732	char *p;	722	fsparam_u64 ("cp", Opt_snapshot),
733	substring_t args[MAX_OPT_ARGS];	723	fsparam_string ("order", Opt_order),
734		724	fsparam_flag ("norecovery", Opt_norecovery),
735	if (!options)	725	fsparam_flag_no ("discard", Opt_discard),
736	return 1;	726	{}
737		727	};
738	while ((p = strsep(&options, ",")) != NULL) {
739	int token;
740		728
741	if (!*p)	729	struct nilfs_fs_context {
742	continue;	730	unsigned long ns_mount_opt;
		731	__u64 cno;
		732	};
743		733
744	token = match_token(p, tokens, args);	734	static int nilfs_parse_param(struct fs_context fc, struct fs_parameter param)
745	switch (token) {	735	{
746	case Opt_barrier:	736	struct nilfs_fs_context *nilfs = fc->fs_private;
747	nilfs_set_opt(nilfs, BARRIER);	737	int is_remount = fc->purpose == FS_CONTEXT_FOR_RECONFIGURE;
748	break;	738	struct fs_parse_result result;
749	case Opt_nobarrier:	739	int opt;
		740
		741	opt = fs_parse(fc, nilfs_param_spec, param, &result);
		742	if (opt < 0)
		743	return opt;
		744
		745	switch (opt) {
		746	case Opt_barrier:
		747	if (result.negated)
750	nilfs_clear_opt(nilfs, BARRIER);	748	nilfs_clear_opt(nilfs, BARRIER);
751	break;	749	else
752	case Opt_order:	750	nilfs_set_opt(nilfs, BARRIER);
753	if (strcmp(args[0].from, "relaxed") == 0)	751	break;
754	/* Ordered data semantics */	752	case Opt_order:
755	nilfs_clear_opt(nilfs, STRICT_ORDER);	753	if (strcmp(param->string, "relaxed") == 0)
756	else if (strcmp(args[0].from, "strict") == 0)	754	/* Ordered data semantics */
757	/* Strict in-order semantics */	755	nilfs_clear_opt(nilfs, STRICT_ORDER);
758	nilfs_set_opt(nilfs, STRICT_ORDER);	756	else if (strcmp(param->string, "strict") == 0)
759	else	757	/* Strict in-order semantics */
760	return 0;	758	nilfs_set_opt(nilfs, STRICT_ORDER);
761	break;	759	else
762	case Opt_err_panic:	760	return -EINVAL;
763	nilfs_write_opt(nilfs, ERROR_MODE, ERRORS_PANIC);	761	break;
764	break;	762	case Opt_err:
765	case Opt_err_ro:	763	nilfs->ns_mount_opt &= ~NILFS_MOUNT_ERROR_MODE;
766	nilfs_write_opt(nilfs, ERROR_MODE, ERRORS_RO);	764	nilfs->ns_mount_opt \|= result.uint_32;
767	break;	765	break;
768	case Opt_err_cont:	766	case Opt_snapshot:
769	nilfs_write_opt(nilfs, ERROR_MODE, ERRORS_CONT);	767	if (is_remount) {
770	break;	768	struct super_block *sb = fc->root->d_sb;
771	case Opt_snapshot:	769
772	if (is_remount) {	770	nilfs_err(sb,
773	nilfs_err(sb,	771	"\"%s\" option is invalid for remount",
774	"\"%s\" option is invalid for remount",	772	param->key);
775	p);	773	return -EINVAL;
776	return 0;	774	}
777	}	775	if (result.uint_64 == 0) {
778	break;	776	nilfs_err(NULL,
779	case Opt_norecovery:	777	"invalid option \"cp=0\": invalid checkpoint number 0");
780	nilfs_set_opt(nilfs, NORECOVERY);	778	return -EINVAL;
781	break;
782	case Opt_discard:
783	nilfs_set_opt(nilfs, DISCARD);
784	break;
785	case Opt_nodiscard:
786	nilfs_clear_opt(nilfs, DISCARD);
787	break;
788	default:
789	nilfs_err(sb, "unrecognized mount option \"%s\"", p);
790	return 0;
791	}	779	}
		780	nilfs->cno = result.uint_64;
		781	break;
		782	case Opt_norecovery:
		783	nilfs_set_opt(nilfs, NORECOVERY);
		784	break;
		785	case Opt_discard:
		786	if (result.negated)
		787	nilfs_clear_opt(nilfs, DISCARD);
		788	else
		789	nilfs_set_opt(nilfs, DISCARD);
		790	break;
		791	default:
		792	return -EINVAL;
792	}	793	}
793	return 1;
794	}
795
796	static inline void
797	nilfs_set_default_options(struct super_block *sb,
798	struct nilfs_super_block *sbp)
799	{
800	struct the_nilfs *nilfs = sb->s_fs_info;
801		794
802	nilfs->ns_mount_opt =	795	return 0;
803	NILFS_MOUNT_ERRORS_RO \| NILFS_MOUNT_BARRIER;
804	}	796	}
805		797
806	static int nilfs_setup_super(struct super_block *sb, int is_mount)	798	static int nilfs_setup_super(struct super_block *sb, int is_mount)
@@ -857,9 +849,8 @@ struct nilfs_super_block nilfs_read_super_block(struct super_block sb, · 50 unmodified lines
857	return (struct nilfs_super_block )((char )(*pbh)->b_data + offset);	849	return (struct nilfs_super_block )((char )(*pbh)->b_data + offset);
858	}	850	}
859		851
860	int nilfs_store_magic_and_option(struct super_block *sb,	852	int nilfs_store_magic(struct super_block *sb,
861	struct nilfs_super_block *sbp,	853	struct nilfs_super_block *sbp)
862	char *data)
863	{	854	{
864	struct the_nilfs *nilfs = sb->s_fs_info;	855	struct the_nilfs *nilfs = sb->s_fs_info;
865		856
@@ -870,14 +861,12 @@ int nilfs_store_magic_and_option(struct super_block *sb, · 4 unmodified lines
870	sb->s_flags \|= SB_NOATIME;	861	sb->s_flags \|= SB_NOATIME;
871	#endif	862	#endif
872		863
873	nilfs_set_default_options(sb, sbp);
874
875	nilfs->ns_resuid = le16_to_cpu(sbp->s_def_resuid);	864	nilfs->ns_resuid = le16_to_cpu(sbp->s_def_resuid);
876	nilfs->ns_resgid = le16_to_cpu(sbp->s_def_resgid);	865	nilfs->ns_resgid = le16_to_cpu(sbp->s_def_resgid);
877	nilfs->ns_interval = le32_to_cpu(sbp->s_c_interval);	866	nilfs->ns_interval = le32_to_cpu(sbp->s_c_interval);
878	nilfs->ns_watermark = le32_to_cpu(sbp->s_c_block_max);	867	nilfs->ns_watermark = le32_to_cpu(sbp->s_c_block_max);
879		868
880	return !parse_options(data, sb, 0) ? -EINVAL : 0;	869	return 0;
881	}	870	}
882		871
883	int nilfs_check_feature_compatibility(struct super_block *sb,	872	int nilfs_check_feature_compatibility(struct super_block *sb,
@@ -1035,17 +1024,17 @@ int nilfs_checkpoint_is_mounted(struct super_block *sb, __u64 cno) · 151 unmodified lines
1035	/**	1024	/**
1036	* nilfs_fill_super() - initialize a super block instance	1025	* nilfs_fill_super() - initialize a super block instance
1037	* @sb: super_block	1026	* @sb: super_block
1038	* @data: mount options	1027	* @fc: filesystem context
1039	* @silent: silent mode flag
1040	*	1028	*
1041	* This function is called exclusively by nilfs->ns_mount_mutex.	1029	* This function is called exclusively by nilfs->ns_mount_mutex.
1042	* So, the recovery process is protected from other simultaneous mounts.	1030	* So, the recovery process is protected from other simultaneous mounts.
1043	*/	1031	*/
1044	static int	1032	static int
1045	nilfs_fill_super(struct super_block sb, void data, int silent)	1033	nilfs_fill_super(struct super_block sb, struct fs_context fc)
1046	{	1034	{
1047	struct the_nilfs *nilfs;	1035	struct the_nilfs *nilfs;
1048	struct nilfs_root *fsroot;	1036	struct nilfs_root *fsroot;
		1037	struct nilfs_fs_context *ctx = fc->fs_private;
1049	__u64 cno;	1038	__u64 cno;
1050	int err;	1039	int err;
1051		1040
@@ -1055,10 +1044,13 @@ nilfs_fill_super(struct super_block sb, void data, int silent) · 3 unmodified lines
1055		1044
1056	sb->s_fs_info = nilfs;	1045	sb->s_fs_info = nilfs;
1057		1046
1058	err = init_nilfs(nilfs, sb, (char *)data);	1047	err = init_nilfs(nilfs, sb);
1059	if (err)	1048	if (err)
1060	goto failed_nilfs;	1049	goto failed_nilfs;
1061		1050
		1051	/* Copy in parsed mount options */
		1052	nilfs->ns_mount_opt = ctx->ns_mount_opt;
		1053
1062	sb->s_op = &nilfs_sops;	1054	sb->s_op = &nilfs_sops;
1063	sb->s_export_op = &nilfs_export_ops;	1055	sb->s_export_op = &nilfs_export_ops;
1064	sb->s_root = NULL;	1056	sb->s_root = NULL;
@@ -1117,34 +1109,25 @@ nilfs_fill_super(struct super_block sb, void data, int silent) · 52 unmodified lines
1117	return err;	1109	return err;
1118	}	1110	}
1119		1111
1120	static int nilfs_remount(struct super_block sb, int flags, char *data)	1112	static int nilfs_reconfigure(struct fs_context *fc)
1121	{	1113	{
		1114	struct nilfs_fs_context *ctx = fc->fs_private;
		1115	struct super_block *sb = fc->root->d_sb;
1122	struct the_nilfs *nilfs = sb->s_fs_info;	1116	struct the_nilfs *nilfs = sb->s_fs_info;
1123	unsigned long old_sb_flags;
1124	unsigned long old_mount_opt;
1125	int err;	1117	int err;
1126		1118
1127	sync_filesystem(sb);	1119	sync_filesystem(sb);
1128	old_sb_flags = sb->s_flags;
1129	old_mount_opt = nilfs->ns_mount_opt;
1130
1131	if (!parse_options(data, sb, 1)) {
1132	err = -EINVAL;
1133	goto restore_opts;
1134	}
1135	sb->s_flags = (sb->s_flags & ~SB_POSIXACL);
1136		1120
1137	err = -EINVAL;	1121	err = -EINVAL;
1138		1122
1139	if (!nilfs_valid_fs(nilfs)) {	1123	if (!nilfs_valid_fs(nilfs)) {
1140	nilfs_warn(sb,	1124	nilfs_warn(sb,
1141	"couldn't remount because the filesystem is in an incomplete recovery state");	1125	"couldn't remount because the filesystem is in an incomplete recovery state");
1142	goto restore_opts;	1126	goto ignore_opts;
1143	}	1127	}
1144		1128	if ((bool)(fc->sb_flags & SB_RDONLY) == sb_rdonly(sb))
1145	if ((bool)(*flags & SB_RDONLY) == sb_rdonly(sb))
1146	goto out;	1129	goto out;
1147	if (*flags & SB_RDONLY) {	1130	if (fc->sb_flags & SB_RDONLY) {
1148	sb->s_flags \|= SB_RDONLY;	1131	sb->s_flags \|= SB_RDONLY;
1149		1132
1150	/*	1133	/*
@@ -1172,138 +1155,67 @@ static int nilfs_remount(struct super_block sb, int flags, char *data) · 21 unmodified lines
1172	"couldn't remount RDWR because of unsupported optional features (%llx)",	1155	"couldn't remount RDWR because of unsupported optional features (%llx)",
1173	(unsigned long long)features);	1156	(unsigned long long)features);
1174	err = -EROFS;	1157	err = -EROFS;
1175	goto restore_opts;	1158	goto ignore_opts;
1176	}	1159	}
1177		1160
1178	sb->s_flags &= ~SB_RDONLY;	1161	sb->s_flags &= ~SB_RDONLY;
1179		1162
1180	root = NILFS_I(d_inode(sb->s_root))->i_root;	1163	root = NILFS_I(d_inode(sb->s_root))->i_root;
1181	err = nilfs_attach_log_writer(sb, root);	1164	err = nilfs_attach_log_writer(sb, root);
1182	if (err)	1165	if (err) {
1183	goto restore_opts;	1166	sb->s_flags \|= SB_RDONLY;
		1167	goto ignore_opts;
		1168	}
1184		1169
1185	down_write(&nilfs->ns_sem);	1170	down_write(&nilfs->ns_sem);
1186	nilfs_setup_super(sb, true);	1171	nilfs_setup_super(sb, true);
1187	up_write(&nilfs->ns_sem);	1172	up_write(&nilfs->ns_sem);
1188	}	1173	}
1189	out:	1174	out:
1190	return 0;	1175	sb->s_flags = (sb->s_flags & ~SB_POSIXACL);
1191		1176	/* Copy over parsed remount options */
1192	restore_opts:	1177	nilfs->ns_mount_opt = ctx->ns_mount_opt;
1193	sb->s_flags = old_sb_flags;
1194	nilfs->ns_mount_opt = old_mount_opt;
1195	return err;
1196	}
1197
1198	struct nilfs_super_data {
1199	__u64 cno;
1200	int flags;
1201	};
1202
1203	static int nilfs_parse_snapshot_option(const char *option,
1204	const substring_t *arg,
1205	struct nilfs_super_data *sd)
1206	{
1207	unsigned long long val;
1208	const char *msg = NULL;
1209	int err;
1210
1211	if (!(sd->flags & SB_RDONLY)) {
1212	msg = "read-only option is not specified";
1213	goto parse_error;
1214	}
1215
1216	err = kstrtoull(arg->from, 0, &val);
1217	if (err) {
1218	if (err == -ERANGE)
1219	msg = "too large checkpoint number";
1220	else
1221	msg = "malformed argument";
1222	goto parse_error;
1223	} else if (val == 0) {
1224	msg = "invalid checkpoint number 0";
1225	goto parse_error;
1226	}
1227	sd->cno = val;
1228	return 0;
1229
1230	parse_error:
1231	nilfs_err(NULL, "invalid option \"%s\": %s", option, msg);
1232	return 1;
1233	}
1234
1235	/**
1236	* nilfs_identify - pre-read mount options needed to identify mount instance
1237	* @data: mount options
1238	* @sd: nilfs_super_data
1239	*/
1240	static int nilfs_identify(char data, struct nilfs_super_data sd)
1241	{
1242	char p, options = data;
1243	substring_t args[MAX_OPT_ARGS];
1244	int token;
1245	int ret = 0;
1246
1247	do {
1248	p = strsep(&options, ",");
1249	if (p != NULL && *p) {
1250	token = match_token(p, tokens, args);
1251	if (token == Opt_snapshot)
1252	ret = nilfs_parse_snapshot_option(p, &args[0],
1253	sd);
1254	}
1255	if (!options)
1256	break;
1257	BUG_ON(options == data);
1258	*(options - 1) = ',';
1259	} while (!ret);
1260	return ret;
1261	}
1262		1178
1263	static int nilfs_set_bdev_super(struct super_block s, void data)
1264	{
1265	s->s_dev = (dev_t )data;
1266	return 0;	1179	return 0;
1267	}
1268		1180
1269	static int nilfs_test_bdev_super(struct super_block s, void data)	1181	ignore_opts:
1270	{	1182	return err;
1271	return !(s->s_iflags & SB_I_RETIRED) && s->s_dev == (dev_t )data;
1272	}	1183	}
1273		1184
1274	static struct dentry *	1185	static int
1275	nilfs_mount(struct file_system_type *fs_type, int flags,	1186	nilfs_get_tree(struct fs_context *fc)
1276	const char dev_name, void data)
1277	{	1187	{
1278	struct nilfs_super_data sd = { .flags = flags };	1188	struct nilfs_fs_context *ctx = fc->fs_private;
1279	struct super_block *s;	1189	struct super_block *s;
1280	dev_t dev;	1190	dev_t dev;
1281	int err;	1191	int err;
1282		1192
1283	if (nilfs_identify(data, &sd))	1193	if (ctx->cno && !(fc->sb_flags & SB_RDONLY)) {
1284	return ERR_PTR(-EINVAL);	1194	nilfs_err(NULL,
		1195	"invalid option \"cp=%llu\": read-only option is not specified",
		1196	ctx->cno);
		1197	return -EINVAL;
		1198	}
1285		1199
1286	err = lookup_bdev(dev_name, &dev);	1200	err = lookup_bdev(fc->source, &dev);
1287	if (err)	1201	if (err)
1288	return ERR_PTR(err);	1202	return err;
1289		1203
1290	s = sget(fs_type, nilfs_test_bdev_super, nilfs_set_bdev_super, flags,	1204	s = sget_dev(fc, dev);
1291	&dev);
1292	if (IS_ERR(s))	1205	if (IS_ERR(s))
1293	return ERR_CAST(s);	1206	return PTR_ERR(s);
1294		1207
1295	if (!s->s_root) {	1208	if (!s->s_root) {
1296	err = setup_bdev_super(s, flags, NULL);	1209	err = setup_bdev_super(s, fc->sb_flags, fc);
1297	if (!err)	1210	if (!err)
1298	err = nilfs_fill_super(s, data,	1211	err = nilfs_fill_super(s, fc);
1299	flags & SB_SILENT ? 1 : 0);
1300	if (err)	1212	if (err)
1301	goto failed_super;	1213	goto failed_super;
1302		1214
1303	s->s_flags \|= SB_ACTIVE;	1215	s->s_flags \|= SB_ACTIVE;
1304	} else if (!sd.cno) {	1216	} else if (!ctx->cno) {
1305	if (nilfs_tree_is_busy(s->s_root)) {	1217	if (nilfs_tree_is_busy(s->s_root)) {
1306	if ((flags ^ s->s_flags) & SB_RDONLY) {	1218	if ((fc->sb_flags ^ s->s_flags) & SB_RDONLY) {
1307	nilfs_err(s,	1219	nilfs_err(s,
1308	"the device already has a %s mount.",	1220	"the device already has a %s mount.",
1309	sb_rdonly(s) ? "read-only" : "read/write");	1221	sb_rdonly(s) ? "read-only" : "read/write");
@@ -1312,37 +1224,75 @@ nilfs_mount(struct file_system_type *fs_type, int flags, · 2 unmodified lines
1312	}	1224	}
1313	} else {	1225	} else {
1314	/*	1226	/*
1315	* Try remount to setup mount states if the current	1227	* Try reconfigure to setup mount states if the current
1316	* tree is not mounted and only snapshots use this sb.	1228	* tree is not mounted and only snapshots use this sb.
		1229	*
		1230	* Since nilfs_reconfigure() requires fc->root to be
		1231	* set, set it first and release it on failure.
1317	*/	1232	*/
1318	err = nilfs_remount(s, &flags, data);	1233	fc->root = dget(s->s_root);
1319	if (err)	1234	err = nilfs_reconfigure(fc);
		1235	if (err) {
		1236	dput(fc->root);
		1237	fc->root = NULL; /* prevent double release */
1320	goto failed_super;	1238	goto failed_super;
		1239	}
		1240	return 0;
1321	}	1241	}
1322	}	1242	}
1323		1243
1324	if (sd.cno) {	1244	if (ctx->cno) {
1325	struct dentry *root_dentry;	1245	struct dentry *root_dentry;
1326		1246
1327	err = nilfs_attach_snapshot(s, sd.cno, &root_dentry);	1247	err = nilfs_attach_snapshot(s, ctx->cno, &root_dentry);
1328	if (err)	1248	if (err)
1329	goto failed_super;	1249	goto failed_super;
1330	return root_dentry;	1250	fc->root = root_dentry;
		1251	return 0;
1331	}	1252	}
1332		1253
1333	return dget(s->s_root);	1254	fc->root = dget(s->s_root);
		1255	return 0;
1334		1256
1335	failed_super:	1257	failed_super:
1336	deactivate_locked_super(s);	1258	deactivate_locked_super(s);
1337	return ERR_PTR(err);	1259	return err;
		1260	}
		1261
		1262	static void nilfs_free_fc(struct fs_context *fc)
		1263	{
		1264	kfree(fc->fs_private);
		1265	}
		1266
		1267	static const struct fs_context_operations nilfs_context_ops = {
		1268	.parse_param = nilfs_parse_param,
		1269	.get_tree = nilfs_get_tree,
		1270	.reconfigure = nilfs_reconfigure,
		1271	.free = nilfs_free_fc,
		1272	};
		1273
		1274	static int nilfs_init_fs_context(struct fs_context *fc)
		1275	{
		1276	struct nilfs_fs_context *ctx;
		1277
		1278	ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
		1279	if (!ctx)
		1280	return -ENOMEM;
		1281
		1282	ctx->ns_mount_opt = NILFS_MOUNT_ERRORS_RO \| NILFS_MOUNT_BARRIER;
		1283	fc->fs_private = ctx;
		1284	fc->ops = &nilfs_context_ops;
		1285
		1286	return 0;
1338	}	1287	}
1339		1288
1340	struct file_system_type nilfs_fs_type = {	1289	struct file_system_type nilfs_fs_type = {
1341	.owner = THIS_MODULE,	1290	.owner = THIS_MODULE,
1342	.name = "nilfs2",	1291	.name = "nilfs2",
1343	.mount = nilfs_mount,
1344	.kill_sb = kill_block_super,	1292	.kill_sb = kill_block_super,
1345	.fs_flags = FS_REQUIRES_DEV,	1293	.fs_flags = FS_REQUIRES_DEV,
		1294	.init_fs_context = nilfs_init_fs_context,
		1295	.parameters = nilfs_param_spec,
1346	};	1296	};
1347	MODULE_ALIAS_FS("nilfs2");	1297	MODULE_ALIAS_FS("nilfs2");
1348		1298

fs/nilfs2/the_nilfs.c+20−5

 	struct nilfs_super_block **sbp = nilfs->ns_sbp;
 	struct buffer_head **sbh = nilfs->ns_sbh;
 	u64 sb2off, devsize = bdev_nr_bytes(nilfs->ns_bdev);
-	int valid[2], swp = 0;
+	int valid[2], swp = 0, older;
 	if (devsize < NILFS_SEG_MIN_BLOCKS * NILFS_MIN_BLOCK_SIZE + 4096) {
 		nilfs_err(sb, "device size too small");
 	if (swp)
 		nilfs_swap_super_block(nilfs);
+	/*
+	 * Calculate the array index of the older superblock data.
+	 * If one has been dropped, set index 0 pointing to the remaining one,
+	 * otherwise set index 1 pointing to the old one (including if both
+	 * are the same).
+	 *
+	 *  Divided case             valid[0]  valid[1]  swp  ->  older
+	 *  -------------------------------------------------------------
+	 *  Both SBs are invalid        0         0       N/A (Error)
+	 *  SB1 is invalid              0         1       1         0
+	 *  SB2 is invalid              1         0       0         0
+	 *  SB2 is newer                1         1       1         0
+	 *  SB2 is older or the same    1         1       0         1
+	 */
+	older = valid[1] ^ swp;
 	nilfs->ns_sbwcount = 0;
 	nilfs->ns_sbwtime = le64_to_cpu(sbp[0]->s_wtime);
-	nilfs->ns_prot_seq = le64_to_cpu(sbp[valid[1] & !swp]->s_last_seq);
+	nilfs->ns_prot_seq = le64_to_cpu(sbp[older]->s_last_seq);
 	*sbpp = sbp[0];
 	return 0;
 }
  * init_nilfs - initialize a NILFS instance.
  * @nilfs: the_nilfs structure
  * @sb: super block
- * @data: mount options
  *
  * init_nilfs() performs common initialization per block device (e.g.
  * reading the super block, getting disk layout information, initializing
  * Return Value: On success, 0 is returned. On error, a negative error
  * code is returned.
  */
-int init_nilfs(struct the_nilfs *nilfs, struct super_block *sb, char *data)
+int init_nilfs(struct the_nilfs *nilfs, struct super_block *sb)
 {
 	struct nilfs_super_block *sbp;
 	int blocksize;
 	if (err)
 		goto out;
-	err = nilfs_store_magic_and_option(sb, sbp, data);
+	err = nilfs_store_magic(sb, sbp);
 	if (err)
 		goto failed_sbh;

fs/nilfs2/the_nilfs.h+1−5

 #define nilfs_set_opt(nilfs, opt)  \
 	((nilfs)->ns_mount_opt |= NILFS_MOUNT_##opt)
 #define nilfs_test_opt(nilfs, opt) ((nilfs)->ns_mount_opt & NILFS_MOUNT_##opt)
-#define nilfs_write_opt(nilfs, mask, opt)				\
-	((nilfs)->ns_mount_opt =					\
-		(((nilfs)->ns_mount_opt & ~NILFS_MOUNT_##mask) |	\
-		 NILFS_MOUNT_##opt))					\
 /**
  * struct nilfs_root - nilfs root object
 void nilfs_set_last_segment(struct the_nilfs *, sector_t, u64, __u64);
 struct the_nilfs *alloc_nilfs(struct super_block *sb);
 void destroy_nilfs(struct the_nilfs *nilfs);
-int init_nilfs(struct the_nilfs *nilfs, struct super_block *sb, char *data);
+int init_nilfs(struct the_nilfs *nilfs, struct super_block *sb);
 int load_nilfs(struct the_nilfs *nilfs, struct super_block *sb);
 unsigned long nilfs_nrsvsegs(struct the_nilfs *nilfs, unsigned long nsegs);
 void nilfs_set_nsegments(struct the_nilfs *nilfs, unsigned long nsegs);

fs/ocfs2/aops.c+0−2

@@ -2283,8 +2283,6 @@ unlock: · 2282 unmodified lines
2283	ocfs2_inode_unlock(inode, 1);	2283	ocfs2_inode_unlock(inode, 1);
2284	brelse(di_bh);	2284	brelse(di_bh);
2285	out:	2285	out:
2286	if (ret < 0)
2287	ret = -EIO;
2288	return ret;	2286	return ret;
2289	}	2287	}
2290		2288

fs/ocfs2/dlm/dlmdomain.c+5−7

 {
 	struct dlm_query_nodeinfo *qn;
 	struct dlm_ctxt *dlm = NULL;
-	int locked = 0, status = -EINVAL;
+	int status = -EINVAL;
 	qn = (struct dlm_query_nodeinfo *) msg->buf;
 	}
 	spin_lock(&dlm->spinlock);
-	locked = 1;
 	if (dlm->joining_node != qn->qn_nodenum) {
 		mlog(ML_ERROR, "Node %d queried nodes on domain %s but "
 		     "joining node is %d\n", qn->qn_nodenum, qn->qn_domain,
 		     dlm->joining_node);
-		goto bail;
+		goto unlock;
 	}
 	/* Support for node query was added in 1.1 */
 		     "but active dlm protocol is %d.%d\n", qn->qn_nodenum,
 		     qn->qn_domain, dlm->dlm_locking_proto.pv_major,
 		     dlm->dlm_locking_proto.pv_minor);
-		goto bail;
+		goto unlock;
 	}
 	status = dlm_match_nodes(dlm, qn);
+unlock:
+	spin_unlock(&dlm->spinlock);
 bail:
-	if (locked)
-		spin_unlock(&dlm->spinlock);
 	spin_unlock(&dlm_domain_lock);
 	return status;
 {
 	int status, node, live;
-	status = 0;
 	node = -1;
 	while ((node = find_next_bit(node_map, O2NM_MAX_NODES,
 				     node + 1)) < O2NM_MAX_NODES) {

fs/ocfs2/export.c+6−6

@@ -255,9 +255,9 @@ static struct dentry ocfs2_fh_to_dentry(struct super_block sb, · 254 unmodified lines
255	if (fh_len < 3 \|\| fh_type > 2)	255	if (fh_len < 3 \|\| fh_type > 2)
256	return NULL;	256	return NULL;
257		257
258	handle.ih_blkno = (u64)le32_to_cpu(fid->raw[0]) << 32;	258	handle.ih_blkno = (u64)le32_to_cpu((__force __le32)fid->raw[0]) << 32;
259	handle.ih_blkno \|= (u64)le32_to_cpu(fid->raw[1]);	259	handle.ih_blkno \|= (u64)le32_to_cpu((__force __le32)fid->raw[1]);
260	handle.ih_generation = le32_to_cpu(fid->raw[2]);	260	handle.ih_generation = le32_to_cpu((__force __le32)fid->raw[2]);
261	return ocfs2_get_dentry(sb, &handle);	261	return ocfs2_get_dentry(sb, &handle);
262	}	262	}
263		263
@@ -269,9 +269,9 @@ static struct dentry ocfs2_fh_to_parent(struct super_block sb, · 5 unmodified lines
269	if (fh_type != 2 \|\| fh_len < 6)	269	if (fh_type != 2 \|\| fh_len < 6)
270	return NULL;	270	return NULL;
271		271
272	parent.ih_blkno = (u64)le32_to_cpu(fid->raw[3]) << 32;	272	parent.ih_blkno = (u64)le32_to_cpu((__force __le32)fid->raw[3]) << 32;
273	parent.ih_blkno \|= (u64)le32_to_cpu(fid->raw[4]);	273	parent.ih_blkno \|= (u64)le32_to_cpu((__force __le32)fid->raw[4]);
274	parent.ih_generation = le32_to_cpu(fid->raw[5]);	274	parent.ih_generation = le32_to_cpu((__force __le32)fid->raw[5]);
275	return ocfs2_get_dentry(sb, &parent);	275	return ocfs2_get_dentry(sb, &parent);
276	}	276	}
277		277

fs/ocfs2/file.c+2−0

@@ -1936,6 +1936,8 @@ static int __ocfs2_change_file_space(struct file file, struct inode inode, · 1935 unmodified lines
1936		1936
1937	inode_lock(inode);	1937	inode_lock(inode);
1938		1938
		1939	/* Wait all existing dio workers, newcomers will block on i_rwsem */
		1940	inode_dio_wait(inode);
1939	/*	1941	/*
1940	* This prevents concurrent writes on other nodes	1942	* This prevents concurrent writes on other nodes
1941	*/	1943	*/

fs/ocfs2/inode.c+2−0

 }
 static void ocfs2_inode_cache_lock(struct ocfs2_caching_info *ci)
+__acquires(&oi->ip_lock)
 {
 	struct ocfs2_inode_info *oi = cache_info_to_inode(ci);
 }
 static void ocfs2_inode_cache_unlock(struct ocfs2_caching_info *ci)
+__releases(&oi->ip_lock)
 {
 	struct ocfs2_inode_info *oi = cache_info_to_inode(ci);

fs/ocfs2/ioctl.c+1−0

@@ -125,6 +125,7 @@ int ocfs2_fileattr_set(struct mnt_idmap *idmap, · 124 unmodified lines
125		125
126	ocfs2_inode->ip_attr = flags;	126	ocfs2_inode->ip_attr = flags;
127	ocfs2_set_inode_flags(inode);	127	ocfs2_set_inode_flags(inode);
		128	inode_set_ctime_current(inode);
128		129
129	status = ocfs2_mark_inode_dirty(handle, inode, bh);	130	status = ocfs2_mark_inode_dirty(handle, inode, bh);
130	if (status < 0)	131	if (status < 0)

fs/ocfs2/localalloc.c+14−20

@@ -212,14 +212,15 @@ static inline int ocfs2_la_state_enabled(struct ocfs2_super *osb) · 211 unmodified lines
212	void ocfs2_local_alloc_seen_free_bits(struct ocfs2_super *osb,	212	void ocfs2_local_alloc_seen_free_bits(struct ocfs2_super *osb,
213	unsigned int num_clusters)	213	unsigned int num_clusters)
214	{	214	{
215	spin_lock(&osb->osb_lock);	215	if (num_clusters >= osb->local_alloc_default_bits) {
216	if (osb->local_alloc_state == OCFS2_LA_DISABLED \|\|	216	spin_lock(&osb->osb_lock);
217	osb->local_alloc_state == OCFS2_LA_THROTTLED)	217	if (osb->local_alloc_state == OCFS2_LA_DISABLED \|\|
218	if (num_clusters >= osb->local_alloc_default_bits) {	218	osb->local_alloc_state == OCFS2_LA_THROTTLED) {
219	cancel_delayed_work(&osb->la_enable_wq);	219	cancel_delayed_work(&osb->la_enable_wq);
220	osb->local_alloc_state = OCFS2_LA_ENABLED;	220	osb->local_alloc_state = OCFS2_LA_ENABLED;
221	}	221	}
222	spin_unlock(&osb->osb_lock);	222	spin_unlock(&osb->osb_lock);
		223	}
223	}	224	}
224		225
225	void ocfs2_la_enable_worker(struct work_struct *work)	226	void ocfs2_la_enable_worker(struct work_struct *work)
@@ -335,7 +336,7 @@ int ocfs2_load_local_alloc(struct ocfs2_super *osb) · 109 unmodified lines
335	"found = %u, set = %u, taken = %u, off = %u\n",	336	"found = %u, set = %u, taken = %u, off = %u\n",
336	num_used, le32_to_cpu(alloc->id1.bitmap1.i_used),	337	num_used, le32_to_cpu(alloc->id1.bitmap1.i_used),
337	le32_to_cpu(alloc->id1.bitmap1.i_total),	338	le32_to_cpu(alloc->id1.bitmap1.i_total),
338	OCFS2_LOCAL_ALLOC(alloc)->la_bm_off);	339	le32_to_cpu(OCFS2_LOCAL_ALLOC(alloc)->la_bm_off));
339		340
340	status = -EINVAL;	341	status = -EINVAL;
341	goto bail;	342	goto bail;
@@ -863,14 +864,8 @@ static int ocfs2_local_alloc_find_clear_bits(struct ocfs2_super *osb, · 521 unmodified lines
863		864
864	numfound = bitoff = startoff = 0;	865	numfound = bitoff = startoff = 0;
865	left = le32_to_cpu(alloc->id1.bitmap1.i_total);	866	left = le32_to_cpu(alloc->id1.bitmap1.i_total);
866	while ((bitoff = ocfs2_find_next_zero_bit(bitmap, left, startoff)) != -1) {	867	while ((bitoff = ocfs2_find_next_zero_bit(bitmap, left, startoff)) <
867	if (bitoff == left) {	868	left) {
868	/* mlog(0, "bitoff (%d) == left", bitoff); */
869	break;
870	}
871	/* mlog(0, "Found a zero: bitoff = %d, startoff = %d, "
872	"numfound = %d\n", bitoff, startoff, numfound);*/
873
874	/* Ok, we found a zero bit... is it contig. or do we	869	/* Ok, we found a zero bit... is it contig. or do we
875	* start over?*/	870	* start over?*/
876	if (bitoff == startoff) {	871	if (bitoff == startoff) {
@@ -976,9 +971,9 @@ static int ocfs2_sync_local_to_main(struct ocfs2_super *osb, · 99 unmodified lines
976	start = count = 0;	971	start = count = 0;
977	left = le32_to_cpu(alloc->id1.bitmap1.i_total);	972	left = le32_to_cpu(alloc->id1.bitmap1.i_total);
978		973
979	while ((bit_off = ocfs2_find_next_zero_bit(bitmap, left, start))	974	while ((bit_off = ocfs2_find_next_zero_bit(bitmap, left, start)) <
980	!= -1) {	975	left) {
981	if ((bit_off < left) && (bit_off == start)) {	976	if (bit_off == start) {
982	count++;	977	count++;
983	start++;	978	start++;
984	continue;	979	continue;
@@ -1002,8 +997,7 @@ static int ocfs2_sync_local_to_main(struct ocfs2_super *osb, · 17 unmodified lines
1002	goto bail;	997	goto bail;
1003	}	998	}
1004	}	999	}
1005	if (bit_off >= left)	1000
1006	break;
1007	count = 1;	1001	count = 1;
1008	start = bit_off + 1;	1002	start = bit_off + 1;
1009	}	1003	}
@@ -1220,7 +1214,7 @@ retry_enospc: · 210 unmodified lines
1220	OCFS2_LOCAL_ALLOC(alloc)->la_bitmap);	1214	OCFS2_LOCAL_ALLOC(alloc)->la_bitmap);
1221		1215
1222	trace_ocfs2_local_alloc_new_window_result(	1216	trace_ocfs2_local_alloc_new_window_result(
1223	OCFS2_LOCAL_ALLOC(alloc)->la_bm_off,	1217	le32_to_cpu(OCFS2_LOCAL_ALLOC(alloc)->la_bm_off),
1224	le32_to_cpu(alloc->id1.bitmap1.i_total));	1218	le32_to_cpu(alloc->id1.bitmap1.i_total));
1225		1219
1226	bail:	1220	bail:

fs/ocfs2/move_extents.c+1−1

@@ -685,7 +685,7 @@ static int ocfs2_move_extent(struct ocfs2_move_extents_context *context, · 684 unmodified lines
685	}	685	}
686		686
687	ret = ocfs2_block_group_set_bits(handle, gb_inode, gd, gd_bh,	687	ret = ocfs2_block_group_set_bits(handle, gb_inode, gd, gd_bh,
688	goal_bit, len);	688	goal_bit, len, 0, 0);
689	if (ret) {	689	if (ret) {
690	ocfs2_rollback_alloc_dinode_counts(gb_inode, gb_bh, len,	690	ocfs2_rollback_alloc_dinode_counts(gb_inode, gb_bh, len,
691	le16_to_cpu(gd->bg_chain));	691	le16_to_cpu(gd->bg_chain));

fs/ocfs2/namei.c+3−1

 	fe->i_last_eb_blk = 0;
 	strcpy(fe->i_signature, OCFS2_INODE_SIGNATURE);
 	fe->i_flags |= cpu_to_le32(OCFS2_VALID_FL);
-	ktime_get_real_ts64(&ts);
+	ktime_get_coarse_real_ts64(&ts);
 	fe->i_atime = fe->i_ctime = fe->i_mtime =
 		cpu_to_le64(ts.tv_sec);
 	fe->i_mtime_nsec = fe->i_ctime_nsec = fe->i_atime_nsec =
 	ocfs2_set_links_count(fe, inode->i_nlink);
 	fe->i_ctime = cpu_to_le64(inode_get_ctime_sec(inode));
 	fe->i_ctime_nsec = cpu_to_le32(inode_get_ctime_nsec(inode));
+	ocfs2_update_inode_fsync_trans(handle, inode, 0);
 	ocfs2_journal_dirty(handle, fe_bh);
 	err = ocfs2_add_entry(handle, dentry, inode,
 		drop_nlink(inode);
 	drop_nlink(inode);
 	ocfs2_set_links_count(fe, inode->i_nlink);
+	ocfs2_update_inode_fsync_trans(handle, inode, 0);
 	ocfs2_journal_dirty(handle, fe_bh);
 	inode_set_mtime_to_ts(dir, inode_set_ctime_current(dir));

fs/ocfs2/ocfs2_fs.h+2−1

 	__le16	bg_free_bits_count;     /* Free bits count */
 	__le16   bg_chain;               /* What chain I am in. */
 /*10*/	__le32   bg_generation;
-	__le32	bg_reserved1;
+	__le16   bg_contig_free_bits;   /* max contig free bits length */
+	__le16   bg_reserved1;
 	__le64   bg_next_group;          /* Next group in my list, in
 					   blocks */
 /*20*/	__le64   bg_parent_dinode;       /* dinode which owns me, in

fs/ocfs2/refcounttree.c+1−1

@@ -630,7 +630,7 @@ static int ocfs2_create_refcount_tree(struct inode *inode, · 629 unmodified lines
630	rb->rf_records.rl_count =	630	rb->rf_records.rl_count =
631	cpu_to_le16(ocfs2_refcount_recs_per_rb(osb->sb));	631	cpu_to_le16(ocfs2_refcount_recs_per_rb(osb->sb));
632	spin_lock(&osb->osb_lock);	632	spin_lock(&osb->osb_lock);
633	rb->rf_generation = osb->s_next_generation++;	633	rb->rf_generation = cpu_to_le32(osb->s_next_generation++);
634	spin_unlock(&osb->osb_lock);	634	spin_unlock(&osb->osb_lock);
635		635
636	ocfs2_journal_dirty(handle, new_bh);	636	ocfs2_journal_dirty(handle, new_bh);

fs/ocfs2/reservations.c+1−1

@@ -414,7 +414,7 @@ static int ocfs2_resmap_find_free_bits(struct ocfs2_reservation_map *resmap, · 413 unmodified lines
414		414
415	start = search_start;	415	start = search_start;
416	while ((offset = ocfs2_find_next_zero_bit(bitmap, resmap->m_bitmap_len,	416	while ((offset = ocfs2_find_next_zero_bit(bitmap, resmap->m_bitmap_len,
417	start)) != -1) {	417	start)) < resmap->m_bitmap_len) {
418	/* Search reached end of the region */	418	/* Search reached end of the region */
419	if (offset >= (search_start + search_len))	419	if (offset >= (search_start + search_len))
420	break;	420	break;

fs/ocfs2/resize.c+8−0

 	u16 cl_bpc = le16_to_cpu(cl->cl_bpc);
 	u16 cl_cpg = le16_to_cpu(cl->cl_cpg);
 	u16 old_bg_clusters;
+	u16 contig_bits;
+	__le16 old_bg_contig_free_bits;
 	trace_ocfs2_update_last_group_and_inode(new_clusters,
 						first_new_cluster);
 		le16_add_cpu(&group->bg_free_bits_count, -1 * backups);
 	}
+	contig_bits = ocfs2_find_max_contig_free_bits(group->bg_bitmap,
+					le16_to_cpu(group->bg_bits), 0);
+	old_bg_contig_free_bits = group->bg_contig_free_bits;
+	group->bg_contig_free_bits = cpu_to_le16(contig_bits);
 	ocfs2_journal_dirty(handle, group_bh);
 	/* update the inode accordingly. */
 		le16_add_cpu(&group->bg_free_bits_count, backups);
 		le16_add_cpu(&group->bg_bits, -1 * num_bits);
 		le16_add_cpu(&group->bg_free_bits_count, -1 * num_bits);
+		group->bg_contig_free_bits = old_bg_contig_free_bits;
 	}
 out:
 	if (ret)

fs/ocfs2/suballoc.c+97−20

 	u64		sr_blkno;	/* The first allocated block */
 	unsigned int	sr_bit_offset;	/* The bit in the bg */
 	unsigned int	sr_bits;	/* How many bits we claimed */
+	unsigned int	sr_max_contig_bits; /* The length for contiguous
+					     * free bits, only available
+					     * for cluster group
+					     */
 };
 static u64 ocfs2_group_from_res(struct ocfs2_suballoc_result *res)
 	return ret;
 }
+u16 ocfs2_find_max_contig_free_bits(void *bitmap,
+			 u16 total_bits, u16 start)
+{
+	u16 offset, free_bits;
+	u16 contig_bits = 0;
+	while (start < total_bits) {
+		offset = ocfs2_find_next_zero_bit(bitmap, total_bits, start);
+		if (offset == total_bits)
+			break;
+		start = ocfs2_find_next_bit(bitmap, total_bits, offset);
+		free_bits = start - offset;
+		if (contig_bits < free_bits)
+			contig_bits = free_bits;
+	}
+	return contig_bits;
+}
 static int ocfs2_block_group_find_clear_bits(struct ocfs2_super *osb,
 					     struct buffer_head *bg_bh,
 					     unsigned int bits_wanted,
 {
 	void *bitmap;
 	u16 best_offset, best_size;
+	u16 prev_best_size = 0;
 	int offset, start, found, status = 0;
 	struct ocfs2_group_desc *bg = (struct ocfs2_group_desc *) bg_bh->b_data;
 	found = start = best_offset = best_size = 0;
 	bitmap = bg->bg_bitmap;
-	while((offset = ocfs2_find_next_zero_bit(bitmap, total_bits, start)) != -1) {
+	while ((offset = ocfs2_find_next_zero_bit(bitmap, total_bits, start)) <
-		if (offset == total_bits)
+	       total_bits) {
-			break;
 		if (!ocfs2_test_bg_bit_allocatable(bg_bh, offset)) {
 			/* We found a zero, but we can't use it as it
 			 * hasn't been put to disk yet! */
 			/* got a zero after some ones */
 			found = 1;
 			start = offset + 1;
+			prev_best_size = best_size;
 		}
 		if (found > best_size) {
 			best_size = found;
 		}
 	}
+	/* best_size will be allocated, we save prev_best_size */
+	res->sr_max_contig_bits = prev_best_size;
 	if (best_size) {
 		res->sr_bit_offset = best_offset;
 		res->sr_bits = best_size;
 					     struct ocfs2_group_desc *bg,
 					     struct buffer_head *group_bh,
 					     unsigned int bit_off,
-					     unsigned int num_bits)
+					     unsigned int num_bits,
+					     unsigned int max_contig_bits,
+					     int fastpath)
 {
 	int status;
 	void *bitmap = bg->bg_bitmap;
 	int journal_type = OCFS2_JOURNAL_ACCESS_WRITE;
+	unsigned int start = bit_off + num_bits;
+	u16 contig_bits;
+	struct ocfs2_super *osb = OCFS2_SB(alloc_inode->i_sb);
 	/* All callers get the descriptor via
 	 * ocfs2_read_group_descriptor().  Any corruption is a code bug. */
 	while(num_bits--)
 		ocfs2_set_bit(bit_off++, bitmap);
+	/*
+	 * this is optimize path, caller set old contig value
+	 * in max_contig_bits to bypass finding action.
+	 */
+	if (fastpath) {
+		bg->bg_contig_free_bits = cpu_to_le16(max_contig_bits);
+	} else if (ocfs2_is_cluster_bitmap(alloc_inode)) {
+		/*
+		 * Usually, the block group bitmap allocates only 1 bit
+		 * at a time, while the cluster group allocates n bits
+		 * each time. Therefore, we only save the contig bits for
+		 * the cluster group.
+		 */
+		contig_bits = ocfs2_find_max_contig_free_bits(bitmap,
+				    le16_to_cpu(bg->bg_bits), start);
+		if (contig_bits > max_contig_bits)
+			max_contig_bits = contig_bits;
+		bg->bg_contig_free_bits = cpu_to_le16(max_contig_bits);
+		ocfs2_local_alloc_seen_free_bits(osb, max_contig_bits);
+	} else {
+		bg->bg_contig_free_bits = 0;
+	}
 	ocfs2_journal_dirty(handle, group_bh);
 bail:
 	BUG_ON(!ocfs2_is_cluster_bitmap(inode));
-	if (gd->bg_free_bits_count) {
+	if (le16_to_cpu(gd->bg_contig_free_bits) &&
+	    le16_to_cpu(gd->bg_contig_free_bits) < bits_wanted)
+		return -ENOSPC;
+	/* ->bg_contig_free_bits may un-initialized, so compare again */
+	if (le16_to_cpu(gd->bg_free_bits_count) >= bits_wanted) {
 		max_bits = le16_to_cpu(gd->bg_bits);
 		/* Tail groups in cluster bitmaps which aren't cpg
 		 * of bits. */
 		if (min_bits <= res->sr_bits)
 			search = 0; /* success */
-		else if (res->sr_bits) {
-			/*
-			 * Don't show bits which we'll be returning
-			 * for allocation to the local alloc bitmap.
-			 */
-			ocfs2_local_alloc_seen_free_bits(osb, res->sr_bits);
-		}
 	}
 	return search;
 	BUG_ON(min_bits != 1);
 	BUG_ON(ocfs2_is_cluster_bitmap(inode));
-	if (bg->bg_free_bits_count) {
+	if (le16_to_cpu(bg->bg_free_bits_count) >= bits_wanted) {
 		ret = ocfs2_block_group_find_clear_bits(OCFS2_SB(inode->i_sb),
 							group_bh, bits_wanted,
 							le16_to_cpu(bg->bg_bits),
 	}
 	ret = ocfs2_block_group_set_bits(handle, alloc_inode, gd, group_bh,
-					 res->sr_bit_offset, res->sr_bits);
+					 res->sr_bit_offset, res->sr_bits,
+					 res->sr_max_contig_bits, 0);
 	if (ret < 0) {
 		ocfs2_rollback_alloc_dinode_counts(alloc_inode, ac->ac_bh,
 					       res->sr_bits,
 					    bg,
 					    group_bh,
 					    res->sr_bit_offset,
-					    res->sr_bits);
+					    res->sr_bits,
+					    res->sr_max_contig_bits,
+					    0);
 	if (status < 0) {
 		ocfs2_rollback_alloc_dinode_counts(alloc_inode,
 					ac->ac_bh, res->sr_bits, chain);
 	for (i = 0; i < le16_to_cpu(cl->cl_next_free_rec); i ++) {
 		if (i == victim)
 			continue;
-		if (!cl->cl_recs[i].c_free)
+		if (le32_to_cpu(cl->cl_recs[i].c_free) < bits_wanted)
 			continue;
 		ac->ac_chain = i;
 					 bg,
 					 bg_bh,
 					 res->sr_bit_offset,
-					 res->sr_bits);
+					 res->sr_bits,
+					 res->sr_max_contig_bits,
+					 0);
 	if (ret < 0) {
 		ocfs2_rollback_alloc_dinode_counts(ac->ac_inode,
 					       ac->ac_bh, res->sr_bits, chain);
 					struct buffer_head *group_bh,
 					unsigned int bit_off,
 					unsigned int num_bits,
+					unsigned int max_contig_bits,
 					void (*undo_fn)(unsigned int bit,
 							unsigned long *bmap))
 {
 	int status;
 	unsigned int tmp;
+	u16 contig_bits;
 	struct ocfs2_group_desc *undo_bg = NULL;
 	struct journal_head *jh;
 				   num_bits);
 	}
+	/*
+	 * TODO: even 'num_bits == 1' (the worst case, release 1 cluster),
+	 * we still need to rescan whole bitmap.
+	 */
+	if (ocfs2_is_cluster_bitmap(alloc_inode)) {
+		contig_bits = ocfs2_find_max_contig_free_bits(bg->bg_bitmap,
+				    le16_to_cpu(bg->bg_bits), 0);
+		if (contig_bits > max_contig_bits)
+			max_contig_bits = contig_bits;
+		bg->bg_contig_free_bits = cpu_to_le16(max_contig_bits);
+	} else {
+		bg->bg_contig_free_bits = 0;
+	}
 	if (undo_fn)
 		spin_unlock(&jh->b_state_lock);
 	struct ocfs2_chain_list *cl = &fe->id2.i_chain;
 	struct buffer_head *group_bh = NULL;
 	struct ocfs2_group_desc *group;
+	__le16 old_bg_contig_free_bits = 0;
 	/* The alloc_bh comes from ocfs2_free_dinode() or
 	 * ocfs2_free_clusters().  The callers have all locked the
 	BUG_ON((count + start_bit) > le16_to_cpu(group->bg_bits));
+	if (ocfs2_is_cluster_bitmap(alloc_inode))
+		old_bg_contig_free_bits = group->bg_contig_free_bits;
 	status = ocfs2_block_group_clear_bits(handle, alloc_inode,
 					      group, group_bh,
-					      start_bit, count, undo_fn);
+					      start_bit, count, 0, undo_fn);
 	if (status < 0) {
 		mlog_errno(status);
 		goto bail;
 	if (status < 0) {
 		mlog_errno(status);
 		ocfs2_block_group_set_bits(handle, alloc_inode, group, group_bh,
-				start_bit, count);
+				start_bit, count,
+				le16_to_cpu(old_bg_contig_free_bits), 1);
 		goto bail;
 	}

fs/ocfs2/suballoc.h+5−1

 			 struct buffer_head *di_bh,
 			 u32 num_bits,
 			 u16 chain);
+u16 ocfs2_find_max_contig_free_bits(void *bitmap,
+			 u16 total_bits, u16 start);
 int ocfs2_block_group_set_bits(handle_t *handle,
 			 struct inode *alloc_inode,
 			 struct ocfs2_group_desc *bg,
 			 struct buffer_head *group_bh,
 			 unsigned int bit_off,
-			 unsigned int num_bits);
+			 unsigned int num_bits,
+			 unsigned int max_contig_bits,
+			 int fastpath);
 int ocfs2_claim_metadata(handle_t *handle,
 			 struct ocfs2_alloc_context *ac,

fs/proc/vmcore.c+4−3

 		/* leave now if filled buffer already */
 		if (!iov_iter_count(iter))
 			return acc;
+		cond_resched();
 	}
 	list_for_each_entry(m, &vmcore_list, list) {
 	vdd_hdr->n_descsz = size + sizeof(vdd_hdr->dump_name);
 	vdd_hdr->n_type = NT_VMCOREDD;
-	strncpy((char *)vdd_hdr->name, VMCOREDD_NOTE_NAME,
+	strscpy_pad(vdd_hdr->name, VMCOREDD_NOTE_NAME);
-		sizeof(vdd_hdr->name));
+	strscpy_pad(vdd_hdr->dump_name, data->dump_name);
-	memcpy(vdd_hdr->dump_name, data->dump_name, sizeof(vdd_hdr->dump_name));
 }
 /**

fs/squashfs/file.c+1−5

 	flush_dcache_page(page);
 	if (copied == avail)
 		SetPageUptodate(page);
-	else
-		SetPageError(page);
 }
 /* Copy data into page cache  */
 		res = read_blocklist(inode, index, &block);
 		if (res < 0)
-			goto error_out;
+			goto out;
 		if (res == 0)
 			res = squashfs_readpage_sparse(page, expected);
 	if (!res)
 		return 0;
-error_out:
-	SetPageError(page);
 out:
 	pageaddr = kmap_atomic(page);
 	memset(pageaddr, 0, PAGE_SIZE);

fs/squashfs/file_direct.c+1−2

 	return 0;
 mark_errored:
-	/* Decompression failed, mark pages as errored.  Target_page is
+	/* Decompression failed.  Target_page is
 	 * dealt with by the caller
 	 */
 	for (i = 0; i < pages; i++) {
 		if (page[i] == NULL || page[i] == target_page)
 			continue;
 		flush_dcache_page(page[i]);
-		SetPageError(page[i]);
 		unlock_page(page[i]);
 		put_page(page[i]);
 	}

fs/squashfs/namei.c+4−10

  */
 static int get_dir_index_using_name(struct super_block *sb,
 			u64 *next_block, int *next_offset, u64 index_start,
-			int index_offset, int i_count, const char *name,
+			int index_offset, int i_count, const char *name)
-			int len)
 {
 	struct squashfs_sb_info *msblk = sb->s_fs_info;
 	int i, length = 0, err;
 	unsigned int size;
 	struct squashfs_dir_index *index;
-	char *str;
 	TRACE("Entered get_dir_index_using_name, i_count %d\n", i_count);
-	index = kmalloc(sizeof(*index) + SQUASHFS_NAME_LEN * 2 + 2, GFP_KERNEL);
+	index = kmalloc(sizeof(*index) + SQUASHFS_NAME_LEN + 1, GFP_KERNEL);
 	if (index == NULL) {
 		ERROR("Failed to allocate squashfs_dir_index\n");
 		goto out;
 	}
-	str = &index->name[SQUASHFS_NAME_LEN + 1];
-	strncpy(str, name, len);
-	str[len] = '\0';
 	for (i = 0; i < i_count; i++) {
 		err = squashfs_read_metadata(sb, index, &index_start,
 					&index_offset, sizeof(*index));
 		index->name[size] = '\0';
-		if (strcmp(index->name, str) > 0)
+		if (strcmp(index->name, name) > 0)
 			break;
 		length = le32_to_cpu(index->index);
 	length = get_dir_index_using_name(dir->i_sb, &block, &offset,
 				squashfs_i(dir)->dir_idx_start,
 				squashfs_i(dir)->dir_idx_offset,
-				squashfs_i(dir)->dir_idx_cnt, name, len);
+				squashfs_i(dir)->dir_idx_cnt, name);
 	while (length < i_size_read(dir)) {
 		/*

fs/squashfs/symlink.c+16−19

@@ -32,20 +32,19 @@ · 31 unmodified lines
32		32
33	static int squashfs_symlink_read_folio(struct file file, struct folio folio)	33	static int squashfs_symlink_read_folio(struct file file, struct folio folio)
34	{	34	{
35	struct page *page = &folio->page;	35	struct inode *inode = folio->mapping->host;
36	struct inode *inode = page->mapping->host;
37	struct super_block *sb = inode->i_sb;	36	struct super_block *sb = inode->i_sb;
38	struct squashfs_sb_info *msblk = sb->s_fs_info;	37	struct squashfs_sb_info *msblk = sb->s_fs_info;
39	int index = page->index << PAGE_SHIFT;	38	int index = folio_pos(folio);
40	u64 block = squashfs_i(inode)->start;	39	u64 block = squashfs_i(inode)->start;
41	int offset = squashfs_i(inode)->offset;	40	int offset = squashfs_i(inode)->offset;
42	int length = min_t(int, i_size_read(inode) - index, PAGE_SIZE);	41	int length = min_t(int, i_size_read(inode) - index, PAGE_SIZE);
43	int bytes, copied;	42	int bytes, copied, error;
44	void *pageaddr;	43	void *pageaddr;
45	struct squashfs_cache_entry *entry;	44	struct squashfs_cache_entry *entry;
46		45
47	TRACE("Entered squashfs_symlink_readpage, page index %ld, start block "	46	TRACE("Entered squashfs_symlink_readpage, page index %ld, start block "
48	"%llx, offset %x\n", page->index, block, offset);	47	"%llx, offset %x\n", folio->index, block, offset);
49		48
50	/*	49	/*
51	* Skip index bytes into symlink metadata.	50	* Skip index bytes into symlink metadata.
@@ -57,14 +56,15 @@ static int squashfs_symlink_read_folio(struct file file, struct folio folio) · 5 unmodified lines
57	ERROR("Unable to read symlink [%llx:%x]\n",	56	ERROR("Unable to read symlink [%llx:%x]\n",
58	squashfs_i(inode)->start,	57	squashfs_i(inode)->start,
59	squashfs_i(inode)->offset);	58	squashfs_i(inode)->offset);
60	goto error_out;	59	error = bytes;
		60	goto out;
61	}	61	}
62	}	62	}
63		63
64	/*	64	/*
65	* Read length bytes from symlink metadata. Squashfs_read_metadata	65	* Read length bytes from symlink metadata. Squashfs_read_metadata
66	* is not used here because it can sleep and we want to use	66	* is not used here because it can sleep and we want to use
67	* kmap_atomic to map the page. Instead call the underlying	67	* kmap_local to map the folio. Instead call the underlying
68	* squashfs_cache_get routine. As length bytes may overlap metadata	68	* squashfs_cache_get routine. As length bytes may overlap metadata
69	* blocks, we may need to call squashfs_cache_get multiple times.	69	* blocks, we may need to call squashfs_cache_get multiple times.
70	*/	70	*/
@@ -75,29 +75,26 @@ static int squashfs_symlink_read_folio(struct file file, struct folio folio) · 4 unmodified lines
75	squashfs_i(inode)->start,	75	squashfs_i(inode)->start,
76	squashfs_i(inode)->offset);	76	squashfs_i(inode)->offset);
77	squashfs_cache_put(entry);	77	squashfs_cache_put(entry);
78	goto error_out;	78	error = entry->error;
		79	goto out;
79	}	80	}
80		81
81	pageaddr = kmap_atomic(page);	82	pageaddr = kmap_local_folio(folio, 0);
82	copied = squashfs_copy_data(pageaddr + bytes, entry, offset,	83	copied = squashfs_copy_data(pageaddr + bytes, entry, offset,
83	length - bytes);	84	length - bytes);
84	if (copied == length - bytes)	85	if (copied == length - bytes)
85	memset(pageaddr + length, 0, PAGE_SIZE - length);	86	memset(pageaddr + length, 0, PAGE_SIZE - length);
86	else	87	else
87	block = entry->next_index;	88	block = entry->next_index;
88	kunmap_atomic(pageaddr);	89	kunmap_local(pageaddr);
89	squashfs_cache_put(entry);	90	squashfs_cache_put(entry);
90	}	91	}
91		92
92	flush_dcache_page(page);	93	flush_dcache_folio(folio);
93	SetPageUptodate(page);	94	error = 0;
94	unlock_page(page);	95	out:
95	return 0;	96	folio_end_read(folio, error == 0);
96		97	return error;
97	error_out:
98	SetPageError(page);
99	unlock_page(page);
100	return 0;
101	}	98	}
102		99
103		100

include/linux/cpumask.h+0−5

 void init_cpu_possible(const struct cpumask *src);
 void init_cpu_online(const struct cpumask *src);
-static inline void reset_cpu_possible_mask(void)
-{
-	bitmap_zero(cpumask_bits(&__cpu_possible_mask), NR_CPUS);
-}
 static inline void
 set_cpu_possible(unsigned int cpu, bool possible)
 {

include/linux/instrumented.h+35−0

@@ -147,6 +147,41 @@ instrument_copy_from_user_after(const void to, const void __user from, · 146 unmodified lines
147	kmsan_unpoison_memory(to, n - left);	147	kmsan_unpoison_memory(to, n - left);
148	}	148	}
149		149
		150	/**
		151	* instrument_memcpy_before - add instrumentation before non-instrumented memcpy
		152	* @to: destination address
		153	* @from: source address
		154	* @n: number of bytes to copy
		155	*
		156	* Instrument memory accesses that happen in custom memcpy implementations. The
		157	* instrumentation should be inserted before the memcpy call.
		158	*/
		159	static __always_inline void instrument_memcpy_before(void to, const void from,
		160	unsigned long n)
		161	{
		162	kasan_check_write(to, n);
		163	kasan_check_read(from, n);
		164	kcsan_check_write(to, n);
		165	kcsan_check_read(from, n);
		166	}
		167
		168	/**
		169	* instrument_memcpy_after - add instrumentation after non-instrumented memcpy
		170	* @to: destination address
		171	* @from: source address
		172	* @n: number of bytes to copy
		173	* @left: number of bytes not copied (if known)
		174	*
		175	* Instrument memory accesses that happen in custom memcpy implementations. The
		176	* instrumentation should be inserted after the memcpy call.
		177	*/
		178	static __always_inline void instrument_memcpy_after(void to, const void from,
		179	unsigned long n,
		180	unsigned long left)
		181	{
		182	kmsan_memmove(to, from, n - left);
		183	}
		184
150	/**	185	/**
151	* instrument_get_user() - add instrumentation to get_user()-like macros	186	* instrument_get_user() - add instrumentation to get_user()-like macros
152	* @to: destination variable, may not be address-taken	187	* @to: destination variable, may not be address-taken

include/linux/kexec.h+2−4

@@ -464,10 +464,8 @@ static inline void arch_kexec_pre_free_pages(void *vaddr, unsigned int pages) { · 463 unmodified lines
464		464
465	extern bool kexec_file_dbg_print;	465	extern bool kexec_file_dbg_print;
466		466
467	#define kexec_dprintk(fmt, ...) \	467	#define kexec_dprintk(fmt, arg...) \
468	printk("%s" fmt, \	468	do { if (kexec_file_dbg_print) pr_info(fmt, ##arg); } while (0)
469	kexec_file_dbg_print ? KERN_INFO : KERN_DEBUG, \
470	##__VA_ARGS__)
471		469
472	#else /* !CONFIG_KEXEC_CORE */	470	#else /* !CONFIG_KEXEC_CORE */
473	struct pt_regs;	471	struct pt_regs;

include/linux/kfifo.h+7−2

  * to lock the reader.
  */
-#include <linux/kernel.h>
+#include <linux/array_size.h>
 #include <linux/spinlock.h>
 #include <linux/stddef.h>
-#include <linux/scatterlist.h>
+#include <linux/types.h>
+#include <asm/barrier.h>
+#include <asm/errno.h>
+struct scatterlist;
 struct __kfifo {
 	unsigned int	in;

include/linux/kmsan-checks.h+15−0

@@ -61,6 +61,17 @@ void kmsan_check_memory(const void *address, size_t size); · 60 unmodified lines
61	void kmsan_copy_to_user(void __user to, const void from, size_t to_copy,	61	void kmsan_copy_to_user(void __user to, const void from, size_t to_copy,
62	size_t left);	62	size_t left);
63		63
		64	/**
		65	* kmsan_memmove() - Notify KMSAN about a data copy within kernel.
		66	* @to: destination address in the kernel.
		67	* @from: source address in the kernel.
		68	* @size: number of bytes to copy.
		69	*
		70	* Invoked after non-instrumented version (e.g. implemented using assembly
		71	* code) of memmove()/memcpy() is called, in order to copy KMSAN's metadata.
		72	*/
		73	void kmsan_memmove(void to, const void from, size_t to_copy);
		74
64	#else	75	#else
65		76
66	static inline void kmsan_poison_memory(const void *address, size_t size,	77	static inline void kmsan_poison_memory(const void *address, size_t size,
@@ -78,6 +89,10 @@ static inline void kmsan_copy_to_user(void __user to, const void from, · 11 unmodified lines
78	{	89	{
79	}	90	}
80		91
		92	static inline void kmsan_memmove(void to, const void from, size_t to_copy)
		93	{
		94	}
		95
81	#endif	96	#endif
82		97
83	#endif /* _LINUX_KMSAN_CHECKS_H */	98	#endif /* _LINUX_KMSAN_CHECKS_H */

include/linux/nmi.h+2−0

 extern void hardlockup_detector_perf_stop(void);
 extern void hardlockup_detector_perf_restart(void);
 extern void hardlockup_detector_perf_cleanup(void);
+extern void hardlockup_config_perf_event(const char *str);
 #else
 static inline void hardlockup_detector_perf_stop(void) { }
 static inline void hardlockup_detector_perf_restart(void) { }
 static inline void hardlockup_detector_perf_cleanup(void) { }
+static inline void hardlockup_config_perf_event(const char *str) { }
 #endif
 void watchdog_hardlockup_stop(void);

include/trace/events/nilfs2.h+5−1

 		    __field(struct inode *, inode)
 		    __field(unsigned long, ino)
 		    __field(unsigned long, blkoff)
-		    __field(enum req_op, mode)
+		    /*
+		     * Use field_struct() to avoid is_signed_type() on the
+		     * bitwise type enum req_op.
+		     */
+		    __field_struct(enum req_op, mode)
 	    ),
 	    TP_fast_assign(

init/do_mounts_initrd.c+0−1

@@ -29,7 +29,6 @@ static struct ctl_table kern_do_mounts_initrd_table[] = { · 28 unmodified lines
29	.mode = 0644,	29	.mode = 0644,
30	.proc_handler = proc_dointvec,	30	.proc_handler = proc_dointvec,
31	},	31	},
32	{ }
33	};	32	};
34		33
35	static __init int kernel_do_mounts_initrd_sysctls_init(void)	34	static __init int kernel_do_mounts_initrd_sysctls_init(void)

init/main.c+19−0

@@ -345,6 +345,11 @@ static int __init xbc_snprint_cmdline(char *buf, size_t size, · 344 unmodified lines
345	continue;	345	continue;
346	}	346	}
347	xbc_array_for_each_value(vnode, val) {	347	xbc_array_for_each_value(vnode, val) {
		348	/*
		349	* For prettier and more readable /proc/cmdline, only
		350	* quote the value when necessary, i.e. when it contains
		351	* whitespace.
		352	*/
348	q = strpbrk(val, " \t\r\n") ? "\"" : "";	353	q = strpbrk(val, " \t\r\n") ? "\"" : "";
349	ret = snprintf(buf, rest(buf, end), "%s=%s%s%s ",	354	ret = snprintf(buf, rest(buf, end), "%s=%s%s%s ",
350	xbc_namebuf, q, val, q);	355	xbc_namebuf, q, val, q);
@@ -881,6 +886,19 @@ static void __init print_unknown_bootoptions(void) · 530 unmodified lines
881	memblock_free(unknown_options, len);	886	memblock_free(unknown_options, len);
882	}	887	}
883		888
		889	static void __init early_numa_node_init(void)
		890	{
		891	#ifdef CONFIG_USE_PERCPU_NUMA_NODE_ID
		892	#ifndef cpu_to_node
		893	int cpu;
		894
		895	/* The early_cpu_to_node() should be ready here. */
		896	for_each_possible_cpu(cpu)
		897	set_cpu_numa_node(cpu, early_cpu_to_node(cpu));
		898	#endif
		899	#endif
		900	}
		901
884	asmlinkage __visible __init __no_sanitize_address __noreturn __no_stack_protector	902	asmlinkage __visible __init __no_sanitize_address __noreturn __no_stack_protector
885	void start_kernel(void)	903	void start_kernel(void)
886	{	904	{
@@ -911,6 +929,7 @@ void start_kernel(void) · 24 unmodified lines
911	setup_nr_cpu_ids();	929	setup_nr_cpu_ids();
912	setup_per_cpu_areas();	930	setup_per_cpu_areas();
913	smp_prepare_boot_cpu(); /* arch-specific boot-cpu hooks */	931	smp_prepare_boot_cpu(); /* arch-specific boot-cpu hooks */
		932	early_numa_node_init();
914	boot_cpu_hotplug_init();	933	boot_cpu_hotplug_init();
915		934
916	pr_notice("Kernel command line: %s\n", saved_command_line);	935	pr_notice("Kernel command line: %s\n", saved_command_line);

ipc/ipc_sysctl.c+0−1

@@ -178,7 +178,6 @@ static struct ctl_table ipc_sysctls[] = { · 177 unmodified lines
178	.extra2 = SYSCTL_INT_MAX,	178	.extra2 = SYSCTL_INT_MAX,
179	},	179	},
180	#endif	180	#endif
181	{}
182	};	181	};
183		182
184	static struct ctl_table_set set_lookup(struct ctl_table_root root)	183	static struct ctl_table_set set_lookup(struct ctl_table_root root)

ipc/mq_sysctl.c+0−1

@@ -64,7 +64,6 @@ static struct ctl_table mq_sysctls[] = { · 63 unmodified lines
64	.extra1 = &msg_maxsize_limit_min,	64	.extra1 = &msg_maxsize_limit_min,
65	.extra2 = &msg_maxsize_limit_max,	65	.extra2 = &msg_maxsize_limit_max,
66	},	66	},
67	{}
68	};	67	};
69		68
70	static struct ctl_table_set set_lookup(struct ctl_table_root root)	69	static struct ctl_table_set set_lookup(struct ctl_table_root root)

kernel/crash_core.c+2−0

@@ -4,6 +4,8 @@ · 3 unmodified lines
4	* Copyright (C) 2002-2004 Eric Biederman <ebiederm@xmission.com>	4	* Copyright (C) 2002-2004 Eric Biederman <ebiederm@xmission.com>
5	*/	5	*/
6		6
		7	#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
		8
7	#include <linux/buildid.h>	9	#include <linux/buildid.h>
8	#include <linux/init.h>	10	#include <linux/init.h>
9	#include <linux/utsname.h>	11	#include <linux/utsname.h>

kernel/crash_reserve.c+2−2

@@ -109,7 +109,7 @@ static int __init parse_crashkernel_mem(char *cmdline, · 108 unmodified lines
109		109
110	size = memparse(cur, &tmp);	110	size = memparse(cur, &tmp);
111	if (cur == tmp) {	111	if (cur == tmp) {
112	pr_warn("Memory value expected\n");	112	pr_warn("crashkernel: Memory value expected\n");
113	return -EINVAL;	113	return -EINVAL;
114	}	114	}
115	cur = tmp;	115	cur = tmp;
@@ -132,7 +132,7 @@ static int __init parse_crashkernel_mem(char *cmdline, · 16 unmodified lines
132	cur++;	132	cur++;
133	*crash_base = memparse(cur, &tmp);	133	*crash_base = memparse(cur, &tmp);
134	if (cur == tmp) {	134	if (cur == tmp) {
135	pr_warn("Memory value expected after '@'\n");	135	pr_warn("crahskernel: Memory value expected after '@'\n");
136	return -EINVAL;	136	return -EINVAL;
137	}	137	}
138	}	138	}

kernel/kcov.c+2−1

 		mode = kcov_get_mode(remote_arg->trace_mode);
 		if (mode < 0)
 			return mode;
-		if (remote_arg->area_size > LONG_MAX / sizeof(unsigned long))
+		if ((unsigned long)remote_arg->area_size >
+		    LONG_MAX / sizeof(unsigned long))
 			return -EINVAL;
 		kcov->mode = mode;
 		t->kcov = kcov;

kernel/regset.c+3−3

@@ -16,14 +16,14 @@ static int __regset_get(struct task_struct *target, · 15 unmodified lines
16	if (size > regset->n * regset->size)	16	if (size > regset->n * regset->size)
17	size = regset->n * regset->size;	17	size = regset->n * regset->size;
18	if (!p) {	18	if (!p) {
19	to_free = p = kzalloc(size, GFP_KERNEL);	19	to_free = p = kvzalloc(size, GFP_KERNEL);
20	if (!p)	20	if (!p)
21	return -ENOMEM;	21	return -ENOMEM;
22	}	22	}
23	res = regset->regset_get(target, regset,	23	res = regset->regset_get(target, regset,
24	(struct membuf){.p = p, .left = size});	24	(struct membuf){.p = p, .left = size});
25	if (res < 0) {	25	if (res < 0) {
26	kfree(to_free);	26	kvfree(to_free);
27	return res;	27	return res;
28	}	28	}
29	*data = p;	29	*data = p;
@@ -71,6 +71,6 @@ int copy_regset_to_user(struct task_struct *target, · 41 unmodified lines
71	ret = regset_get_alloc(target, regset, size, &buf);	71	ret = regset_get_alloc(target, regset, size, &buf);
72	if (ret > 0)	72	if (ret > 0)
73	ret = copy_to_user(data, buf, ret) ? -EFAULT : 0;	73	ret = copy_to_user(data, buf, ret) ? -EFAULT : 0;
74	kfree(buf);	74	kvfree(buf);
75	return ret;	75	return ret;
76	}	76	}

kernel/trace/blktrace.c+1−2

@@ -524,8 +524,7 @@ static int do_blk_trace_setup(struct request_queue q, char name, dev_t dev, · 523 unmodified lines
524	if (!buts->buf_size \|\| !buts->buf_nr)	524	if (!buts->buf_size \|\| !buts->buf_nr)
525	return -EINVAL;	525	return -EINVAL;
526		526
527	strncpy(buts->name, name, BLKTRACE_BDEV_SIZE);	527	strscpy_pad(buts->name, name, BLKTRACE_BDEV_SIZE);
528	buts->name[BLKTRACE_BDEV_SIZE - 1] = '\0';
529		528
530	/*	529	/*
531	* some device names have larger paths - convert the slashes	530	* some device names have larger paths - convert the slashes

kernel/watchdog.c+9−0

 static int __init hardlockup_panic_setup(char *str)
 {
+next:
 	if (!strncmp(str, "panic", 5))
 		hardlockup_panic = 1;
 	else if (!strncmp(str, "nopanic", 7))
 		watchdog_hardlockup_user_enabled = 0;
 	else if (!strncmp(str, "1", 1))
 		watchdog_hardlockup_user_enabled = 1;
+	else if (!strncmp(str, "r", 1))
+		hardlockup_config_perf_event(str + 1);
+	while (*(str++)) {
+		if (*str == ',') {
+			str++;
+			goto next;
+		}
+	}
 	return 1;
 }
 __setup("nmi_watchdog=", hardlockup_panic_setup);

kernel/watchdog_perf.c+45−2

@@ -90,6 +90,14 @@ static struct perf_event_attr wd_hw_attr = { · 89 unmodified lines
90	.disabled = 1,	90	.disabled = 1,
91	};	91	};
92		92
		93	static struct perf_event_attr fallback_wd_hw_attr = {
		94	.type = PERF_TYPE_HARDWARE,
		95	.config = PERF_COUNT_HW_CPU_CYCLES,
		96	.size = sizeof(struct perf_event_attr),
		97	.pinned = 1,
		98	.disabled = 1,
		99	};
		100
93	/* Callback function for perf event subsystem */	101	/* Callback function for perf event subsystem */
94	static void watchdog_overflow_callback(struct perf_event *event,	102	static void watchdog_overflow_callback(struct perf_event *event,
95	struct perf_sample_data *data,	103	struct perf_sample_data *data,
@@ -122,6 +130,13 @@ static int hardlockup_detector_event_create(void) · 26 unmodified lines
122	/* Try to register using hardware perf events */	130	/* Try to register using hardware perf events */
123	evt = perf_event_create_kernel_counter(wd_attr, cpu, NULL,	131	evt = perf_event_create_kernel_counter(wd_attr, cpu, NULL,
124	watchdog_overflow_callback, NULL);	132	watchdog_overflow_callback, NULL);
		133	if (IS_ERR(evt)) {
		134	wd_attr = &fallback_wd_hw_attr;
		135	wd_attr->sample_period = hw_nmi_get_sample_period(watchdog_thresh);
		136	evt = perf_event_create_kernel_counter(wd_attr, cpu, NULL,
		137	watchdog_overflow_callback, NULL);
		138	}
		139
125	if (IS_ERR(evt)) {	140	if (IS_ERR(evt)) {
126	pr_debug("Perf event create on CPU %d failed with %ld\n", cpu,	141	pr_debug("Perf event create on CPU %d failed with %ld\n", cpu,
127	PTR_ERR(evt));	142	PTR_ERR(evt));
@@ -133,7 +148,6 @@ static int hardlockup_detector_event_create(void) · 5 unmodified lines
133		148
134	/**	149	/**
135	* watchdog_hardlockup_enable - Enable the local event	150	* watchdog_hardlockup_enable - Enable the local event
136	*
137	* @cpu: The CPU to enable hard lockup on.	151	* @cpu: The CPU to enable hard lockup on.
138	*/	152	*/
139	void watchdog_hardlockup_enable(unsigned int cpu)	153	void watchdog_hardlockup_enable(unsigned int cpu)
@@ -152,7 +166,6 @@ void watchdog_hardlockup_enable(unsigned int cpu) · 12 unmodified lines
152		166
153	/**	167	/**
154	* watchdog_hardlockup_disable - Disable the local event	168	* watchdog_hardlockup_disable - Disable the local event
155	*
156	* @cpu: The CPU to enable hard lockup on.	169	* @cpu: The CPU to enable hard lockup on.
157	*/	170	*/
158	void watchdog_hardlockup_disable(unsigned int cpu)	171	void watchdog_hardlockup_disable(unsigned int cpu)
@@ -259,3 +272,33 @@ int __init watchdog_hardlockup_probe(void) · 100 unmodified lines
259	}	272	}
260	return ret;	273	return ret;
261	}	274	}
		275
		276	/**
		277	* hardlockup_config_perf_event - Overwrite config of wd_hw_attr.
		278	* @str: number which identifies the raw perf event to use
		279	*/
		280	void __init hardlockup_config_perf_event(const char *str)
		281	{
		282	u64 config;
		283	char buf[24];
		284	char *comma = strchr(str, ',');
		285
		286	if (!comma) {
		287	if (kstrtoull(str, 16, &config))
		288	return;
		289	} else {
		290	unsigned int len = comma - str;
		291
		292	if (len >= sizeof(buf))
		293	return;
		294
		295	if (strscpy(buf, str, sizeof(buf)) < 0)
		296	return;
		297	buf[len] = 0;
		298	if (kstrtoull(buf, 16, &config))
		299	return;
		300	}
		301
		302	wd_hw_attr.type = PERF_TYPE_RAW;
		303	wd_hw_attr.config = config;
		304	}

lib/Kconfig.kgdb+1−0

@@ -122,6 +122,7 @@ config KDB_DEFAULT_ENABLE · 121 unmodified lines
122	config KDB_KEYBOARD	122	config KDB_KEYBOARD
123	bool "KGDB_KDB: keyboard as input device"	123	bool "KGDB_KDB: keyboard as input device"
124	depends on VT && KGDB_KDB && !PARISC	124	depends on VT && KGDB_KDB && !PARISC
		125	depends on HAS_IOPORT
125	default n	126	default n
126	help	127	help
127	KDB can use a PS/2 type keyboard for an input device	128	KDB can use a PS/2 type keyboard for an input device

lib/build_OID_registry+4−1

 #
 use strict;
+use Cwd qw(abs_path);
 my @names = ();
 my @oids = ();
     exit(2);
 }
+my $abs_srctree = abs_path($ENV{'srctree'});
 #
 # Open the file to read from
 #
 #
 open C_FILE, ">$ARGV[1]" or die;
 print C_FILE "/*\n";
-print C_FILE " * Automatically generated by ", $0, ".  Do not edit\n";
+print C_FILE " * Automatically generated by ", $0 =~ s#^\Q$abs_srctree/\E##r, ".  Do not edit\n";
 print C_FILE " */\n";
 #

lib/devres.c+15−11

 // SPDX-License-Identifier: GPL-2.0
+#include <linux/bug.h>
 #include <linux/device.h>
-#include <linux/err.h>
+#include <linux/errno.h>
-#include <linux/io.h>
-#include <linux/gfp.h>
 #include <linux/export.h>
+#include <linux/gfp_types.h>
+#include <linux/io.h>
+#include <linux/ioport.h>
 #include <linux/of_address.h>
+#include <linux/types.h>
 enum devm_ioremap_type {
 	DEVM_IOREMAP = 0,
 	resource_size_t size;
 	void __iomem *dest_ptr;
 	char *pretty_name;
+	int ret;
 	BUG_ON(!dev);
 	if (!res || resource_type(res) != IORESOURCE_MEM) {
-		dev_err(dev, "invalid resource %pR\n", res);
+		ret = dev_err_probe(dev, -EINVAL, "invalid resource %pR\n", res);
-		return IOMEM_ERR_PTR(-EINVAL);
+		return IOMEM_ERR_PTR(ret);
 	}
 	if (type == DEVM_IOREMAP && res->flags & IORESOURCE_MEM_NONPOSTED)
 	else
 		pretty_name = devm_kstrdup(dev, dev_name(dev), GFP_KERNEL);
 	if (!pretty_name) {
-		dev_err(dev, "can't generate pretty name for resource %pR\n", res);
+		ret = dev_err_probe(dev, -ENOMEM, "can't generate pretty name for resource %pR\n", res);
-		return IOMEM_ERR_PTR(-ENOMEM);
+		return IOMEM_ERR_PTR(ret);
 	}
 	if (!devm_request_mem_region(dev, res->start, size, pretty_name)) {
-		dev_err(dev, "can't request region for resource %pR\n", res);
+		ret = dev_err_probe(dev, -EBUSY, "can't request region for resource %pR\n", res);
-		return IOMEM_ERR_PTR(-EBUSY);
+		return IOMEM_ERR_PTR(ret);
 	}
 	dest_ptr = __devm_ioremap(dev, res->start, size, type);
 	if (!dest_ptr) {
-		dev_err(dev, "ioremap failed for resource %pR\n", res);
 		devm_release_mem_region(dev, res->start, size);
-		dest_ptr = IOMEM_ERR_PTR(-ENOMEM);
+		ret = dev_err_probe(dev, -ENOMEM, "ioremap failed for resource %pR\n", res);
+		return IOMEM_ERR_PTR(ret);
 	}
 	return dest_ptr;

lib/kfifo.c+4−4

  * Copyright (C) 2009/2010 Stefani Seibold <stefani@seibold.net>
  */
-#include <linux/kernel.h>
-#include <linux/export.h>
-#include <linux/slab.h>
 #include <linux/err.h>
+#include <linux/export.h>
+#include <linux/kfifo.h>
 #include <linux/log2.h>
+#include <linux/scatterlist.h>
+#include <linux/slab.h>
 #include <linux/uaccess.h>
-#include <linux/kfifo.h>
 /*
  * internal helper to calculate the unused elements in a fifo

lib/test_hexdump.c+1−1

@@ -113,7 +113,7 @@ static void __init test_hexdump_prepare_test(size_t len, int rowsize, · 112 unmodified lines
113	*p++ = ' ';	113	*p++ = ' ';
114	} while (p < test + rs * 2 + rs / gs + 1);	114	} while (p < test + rs * 2 + rs / gs + 1);
115		115
116	strncpy(p, data_a, l);	116	memcpy(p, data_a, l);
117	p += l;	117	p += l;
118	}	118	}
119		119

mm/kmsan/hooks.c+11−0

@@ -285,6 +285,17 @@ void kmsan_copy_to_user(void __user to, const void from, size_t to_copy, · 284 unmodified lines
285	}	285	}
286	EXPORT_SYMBOL(kmsan_copy_to_user);	286	EXPORT_SYMBOL(kmsan_copy_to_user);
287		287
		288	void kmsan_memmove(void to, const void from, size_t size)
		289	{
		290	if (!kmsan_enabled \|\| kmsan_in_runtime())
		291	return;
		292
		293	kmsan_enter_runtime();
		294	kmsan_internal_memmove_metadata(to, (void *)from, size);
		295	kmsan_leave_runtime();
		296	}
		297	EXPORT_SYMBOL(kmsan_memmove);
		298
288	/* Helper function to check an URB. */	299	/* Helper function to check an URB. */
289	void kmsan_handle_urb(const struct urb *urb, bool is_out)	300	void kmsan_handle_urb(const struct urb *urb, bool is_out)
290	{	301	{

samples/kfifo/dma-example.c+2−1

  */
 #include <linux/init.h>
-#include <linux/module.h>
 #include <linux/kfifo.h>
+#include <linux/module.h>
+#include <linux/scatterlist.h>
 /*
  * This module shows how to handle fifo dma operations.

scripts/checkpatch.pl+6−0

 					CHK("MACRO_ARG_PRECEDENCE",
 					    "Macro argument '$arg' may be better as '($arg)' to avoid precedence issues\n" . "$herectx");
 				}
+# check if this is an unused argument
+				if ($define_stmt !~ /\b$arg\b/) {
+					WARN("MACRO_ARG_UNUSED",
+					     "Argument '$arg' is not used in function-like macro\n" . "$herectx");
+				}
 			}
 # check for macros with flow control, but without ## concatenation

scripts/gdb/linux/cpus.py+3−8

     if utils.get_gdbserver_type() == utils.GDBSERVER_QEMU:
         return gdb.selected_thread().num - 1
     elif utils.get_gdbserver_type() == utils.GDBSERVER_KGDB:
-        tid = gdb.selected_thread().ptid[2]
+        return gdb.parse_and_eval("kgdb_active.counter")
-        if tid > (0x100000000 - MAX_CPUS - 2):
-            return 0x100000000 - tid - 2
-        else:
-            return tasks.get_thread_info(tasks.get_task_by_pid(tid))['cpu']
     else:
         raise gdb.GdbError("Sorry, obtaining the current CPU is not yet "
                            "supported with this gdb server.")
     def __init__(self):
         super(PerCpu, self).__init__("lx_per_cpu")
-    def invoke(self, var_name, cpu=-1):
+    def invoke(self, var, cpu=-1):
-        var_ptr = gdb.parse_and_eval("&" + var_name.string())
+        return per_cpu(var.address, cpu)
-        return per_cpu(var_ptr, cpu)
 PerCpu()

scripts/gdb/linux/tasks.py+1−1

@@ -85,7 +85,7 @@ thread_info_type = utils.CachedType("struct thread_info") · 84 unmodified lines
85		85
86	def get_thread_info(task):	86	def get_thread_info(task):
87	thread_info_ptr_type = thread_info_type.get_type().pointer()	87	thread_info_ptr_type = thread_info_type.get_type().pointer()
88	if task.type.fields()[0].type == thread_info_type.get_type():	88	if task_type.get_type().fields()[0].type == thread_info_type.get_type():
89	return task['thread_info']	89	return task['thread_info']
90	thread_info = task['stack'].cast(thread_info_ptr_type)	90	thread_info = task['stack'].cast(thread_info_ptr_type)
91	return thread_info.dereference()	91	return thread_info.dereference()

scripts/gdb/linux/utils.py+1−1

@@ -196,7 +196,7 @@ def get_gdbserver_type(): · 195 unmodified lines
196	def probe_kgdb():	196	def probe_kgdb():
197	try:	197	try:
198	thread_info = gdb.execute("info thread 2", to_string=True)	198	thread_info = gdb.execute("info thread 2", to_string=True)
199	return "shadowCPU0" in thread_info	199	return "shadowCPU" in thread_info
200	except gdb.error:	200	except gdb.error:
201	return False	201	return False
202		202

tools/include/linux/rbtree_augmented.h+2−2

@@ -158,13 +158,13 @@ RB_DECLARE_CALLBACKS(RBSTATIC, RBNAME, \ · 157 unmodified lines
158		158
159	static inline void rb_set_parent(struct rb_node rb, struct rb_node p)	159	static inline void rb_set_parent(struct rb_node rb, struct rb_node p)
160	{	160	{
161	rb->__rb_parent_color = rb_color(rb) \| (unsigned long)p;	161	rb->__rb_parent_color = rb_color(rb) + (unsigned long)p;
162	}	162	}
163		163
164	static inline void rb_set_parent_color(struct rb_node *rb,	164	static inline void rb_set_parent_color(struct rb_node *rb,
165	struct rb_node *p, int color)	165	struct rb_node *p, int color)
166	{	166	{
167	rb->__rb_parent_color = (unsigned long)p \| color;	167	rb->__rb_parent_color = (unsigned long)p + color;
168	}	168	}
169		169
170	static inline void	170	static inline void

tools/lib/rbtree.c+1−1

@@ -58,7 +58,7 @@ · 57 unmodified lines
58		58
59	static inline void rb_set_black(struct rb_node *rb)	59	static inline void rb_set_black(struct rb_node *rb)
60	{	60	{
61	rb->__rb_parent_color \|= RB_BLACK;	61	rb->__rb_parent_color += RB_BLACK;
62	}	62	}
63		63
64	static inline struct rb_node rb_red_parent(struct rb_node red)	64	static inline struct rb_node rb_red_parent(struct rb_node red)

tools/testing/selftests/kcmp/kcmp_test.c+1−1

@@ -91,7 +91,7 @@ int main(int argc, char **argv) · 90 unmodified lines
91	ksft_print_header();	91	ksft_print_header();
92	ksft_set_plan(3);	92	ksft_set_plan(3);
93		93
94	fd2 = open(kpath, O_RDWR, 0644);	94	fd2 = open(kpath, O_RDWR);
95	if (fd2 < 0) {	95	if (fd2 < 0) {
96	perror("Can't open file");	96	perror("Can't open file");
97	ksft_exit_fail();	97	ksft_exit_fail();