Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit bdf428fe authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge tag 'modules-next-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/rusty/linux 

Pull module update from Rusty Russell:
 "Nothing major: support for compressing modules, and auto-tainting
  params.

  PS. My virtio-next tree is empty: DaveM took the patches I had.  There
      might be a virtio-rng starvation fix, but so far it's a bit voodoo
      so I will get to that in the next two days or it will wait"

* tag 'modules-next-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/rusty/linux:
  moduleparam: Resolve missing-field-initializer warning
  kbuild: handle module compression while running 'make modules_install'.
  modinst: wrap long lines in order to enhance cmd_modules_install
  modsign: lookup lines ending in .ko in .mod files
  modpost: simplify file name generation of *.mod.c files
  modpost: reduce visibility of symbols and constify r/o arrays
  param: check for tainting before calling set op.
  drm/i915: taint the kernel if unsafe module parameters are set
  module: add module_param_unsafe and module_param_named_unsafe
  module: make it possible to have unsafe, tainting module params
  module: rename KERNEL_PARAM_FL_NOARG to avoid confusion
parents a40a7201 184c3fc3

Makefile

+15 −0
Original line number Diff line number Diff line
@@ -842,6 +842,21 @@ mod_strip_cmd = true 
endif # INSTALL_MOD_STRIP

export mod_strip_cmd



# CONFIG_MODULE_COMPRESS, if defined, will cause module to be compressed

# after they are installed in agreement with CONFIG_MODULE_COMPRESS_GZIP

# or CONFIG_MODULE_COMPRESS_XZ.



mod_compress_cmd = true

ifdef CONFIG_MODULE_COMPRESS

  ifdef CONFIG_MODULE_COMPRESS_GZIP

    mod_compress_cmd = gzip -n

  endif # CONFIG_MODULE_COMPRESS_GZIP

  ifdef CONFIG_MODULE_COMPRESS_XZ

    mod_compress_cmd = xz

  endif # CONFIG_MODULE_COMPRESS_XZ

endif # CONFIG_MODULE_COMPRESS

export mod_compress_cmd



# Select initial ramdisk compression format, default is gzip(1).

# This shall be used by the dracut(8) tool while creating an initramfs image.

#

drivers/gpu/drm/i915/i915_params.c

+4 −4
Original line number Diff line number Diff line
@@ -66,12 +66,12 @@ module_param_named(powersave, i915.powersave, int, 0600); 
MODULE_PARM_DESC(powersave,

	"Enable powersavings, fbc, downclocking, etc. (default: true)");



module_param_named(semaphores, i915.semaphores, int, 0400);

module_param_named_unsafe(semaphores, i915.semaphores, int, 0400);

MODULE_PARM_DESC(semaphores,

	"Use semaphores for inter-ring sync "

	"(default: -1 (use per-chip defaults))");



module_param_named(enable_rc6, i915.enable_rc6, int, 0400);

module_param_named_unsafe(enable_rc6, i915.enable_rc6, int, 0400);

MODULE_PARM_DESC(enable_rc6,

	"Enable power-saving render C-state 6. "

	"Different stages can be selected via bitmask values "
@@ -79,7 +79,7 @@ MODULE_PARM_DESC(enable_rc6, 
	"For example, 3 would enable rc6 and deep rc6, and 7 would enable everything. "

	"default: -1 (use per-chip default)");



module_param_named(enable_fbc, i915.enable_fbc, int, 0600);

module_param_named_unsafe(enable_fbc, i915.enable_fbc, int, 0600);

MODULE_PARM_DESC(enable_fbc,

	"Enable frame buffer compression for power savings "

	"(default: -1 (use per-chip default))");
@@ -113,7 +113,7 @@ MODULE_PARM_DESC(enable_hangcheck, 
	"WARNING: Disabling this can cause system wide hangs. "

	"(default: true)");



module_param_named(enable_ppgtt, i915.enable_ppgtt, int, 0400);

module_param_named_unsafe(enable_ppgtt, i915.enable_ppgtt, int, 0400);

MODULE_PARM_DESC(enable_ppgtt,

	"Override PPGTT usage. "

	"(-1=auto [default], 0=disabled, 1=aliasing, 2=full)");

drivers/tty/serial/8250/8250_core.c

+1 −1
Original line number Diff line number Diff line
@@ -3587,7 +3587,7 @@ static void __used s8250_options(void) 
#ifdef CONFIG_SERIAL_8250_RSA

	__module_param_call(MODULE_PARAM_PREFIX, probe_rsa,

		&param_array_ops, .arr = &__param_arr_probe_rsa,

		0444, -1);

		0444, -1, 0);

#endif

}

#else

include/linux/moduleparam.h

+39 −11
Original line number Diff line number Diff line
@@ -42,7 +42,7 @@ struct kernel_param; 
 * NOARG - the parameter allows for no argument (foo instead of foo=1)

 */

enum {

	KERNEL_PARAM_FL_NOARG = (1 << 0)

	KERNEL_PARAM_OPS_FL_NOARG = (1 << 0)

};



struct kernel_param_ops {
@@ -56,11 +56,21 @@ struct kernel_param_ops { 
	void (*free)(void *arg);

};



/*

 * Flags available for kernel_param

 *

 * UNSAFE - the parameter is dangerous and setting it will taint the kernel

 */

enum {

	KERNEL_PARAM_FL_UNSAFE = (1 << 0)

};



struct kernel_param {

	const char *name;

	const struct kernel_param_ops *ops;

	u16 perm;

	s16 level;

	s8 level;

	u8 flags;

	union {

		void *arg;

		const struct kparam_string *str;
@@ -112,6 +122,12 @@ struct kparam_array 
#define module_param(name, type, perm)				\

	module_param_named(name, name, type, perm)



/**

 * module_param_unsafe - same as module_param but taints kernel

 */

#define module_param_unsafe(name, type, perm)			\

	module_param_named_unsafe(name, name, type, perm)



/**

 * module_param_named - typesafe helper for a renamed module/cmdline parameter

 * @name: a valid C identifier which is the parameter name.
@@ -128,6 +144,14 @@ struct kparam_array 
	module_param_cb(name, &param_ops_##type, &value, perm);		   \

	__MODULE_PARM_TYPE(name, #type)



/**

 * module_param_named_unsafe - same as module_param_named but taints kernel

 */

#define module_param_named_unsafe(name, value, type, perm)		\

	param_check_##type(name, &(value));				\

	module_param_cb_unsafe(name, &param_ops_##type, &value, perm);	\

	__MODULE_PARM_TYPE(name, #type)



/**

 * module_param_cb - general callback for a module/cmdline parameter

 * @name: a valid C identifier which is the parameter name.
@@ -137,7 +161,11 @@ struct kparam_array 
 * The ops can have NULL set or get functions.

 */

#define module_param_cb(name, ops, arg, perm)				      \

	__module_param_call(MODULE_PARAM_PREFIX, name, ops, arg, perm, -1)

	__module_param_call(MODULE_PARAM_PREFIX, name, ops, arg, perm, -1, 0)



#define module_param_cb_unsafe(name, ops, arg, perm)			      \

	__module_param_call(MODULE_PARAM_PREFIX, name, ops, arg, perm, -1,    \

			    KERNEL_PARAM_FL_UNSAFE)



/**

 * <level>_param_cb - general callback for a module/cmdline parameter
@@ -149,7 +177,7 @@ struct kparam_array 
 * The ops can have NULL set or get functions.

 */

#define __level_param_cb(name, ops, arg, perm, level)			\

	__module_param_call(MODULE_PARAM_PREFIX, name, ops, arg, perm, level)

	__module_param_call(MODULE_PARAM_PREFIX, name, ops, arg, perm, level, 0)



#define core_param_cb(name, ops, arg, perm)		\

	__level_param_cb(name, ops, arg, perm, 1)
@@ -184,22 +212,22 @@ struct kparam_array 


/* This is the fundamental function for registering boot/module

   parameters. */

#define __module_param_call(prefix, name, ops, arg, perm, level)	\

#define __module_param_call(prefix, name, ops, arg, perm, level, flags)	\

	/* Default value instead of permissions? */			\

	static const char __param_str_##name[] = prefix #name; \

	static struct kernel_param __moduleparam_const __param_##name	\

	__used								\

    __attribute__ ((unused,__section__ ("__param"),aligned(sizeof(void *)))) \

	= { __param_str_##name, ops, VERIFY_OCTAL_PERMISSIONS(perm),	\

	    level, { arg } }

	    level, flags, { arg } }



/* Obsolete - use module_param_cb() */

#define module_param_call(name, set, get, arg, perm)			\

	static struct kernel_param_ops __param_ops_##name =		\

		{ 0, (void *)set, (void *)get };			\

		{ .flags = 0, (void *)set, (void *)get };		\

	__module_param_call(MODULE_PARAM_PREFIX,			\

			    name, &__param_ops_##name, arg,		\

			    (perm) + sizeof(__check_old_set_param(set))*0, -1)

			    (perm) + sizeof(__check_old_set_param(set))*0, -1, 0)



/* We don't get oldget: it's often a new-style param_get_uint, etc. */

static inline int
@@ -279,7 +307,7 @@ static inline void __kernel_param_unlock(void) 
 */

#define core_param(name, var, type, perm)				\

	param_check_##type(name, &(var));				\

	__module_param_call("", name, &param_ops_##type, &var, perm, -1)

	__module_param_call("", name, &param_ops_##type, &var, perm, -1, 0)

#endif /* !MODULE */



/**
@@ -297,7 +325,7 @@ static inline void __kernel_param_unlock(void) 
		= { len, string };					\

	__module_param_call(MODULE_PARAM_PREFIX, name,			\

			    &param_ops_string,				\

			    .str = &__param_string_##name, perm, -1);	\

			    .str = &__param_string_##name, perm, -1, 0);\

	__MODULE_PARM_TYPE(name, "string")



/**
@@ -444,7 +472,7 @@ extern int param_set_bint(const char *val, const struct kernel_param *kp); 
	__module_param_call(MODULE_PARAM_PREFIX, name,			\

			    &param_array_ops,				\

			    .arr = &__param_arr_##name,			\

			    perm, -1);					\

			    perm, -1, 0);				\

	__MODULE_PARM_TYPE(name, "array of " #type)



extern struct kernel_param_ops param_array_ops;

init/Kconfig

+43 −0
Original line number Diff line number Diff line
@@ -1919,6 +1919,49 @@ config MODULE_SIG_HASH 
	default "sha384" if MODULE_SIG_SHA384

	default "sha512" if MODULE_SIG_SHA512



config MODULE_COMPRESS

	bool "Compress modules on installation"

	depends on MODULES

	help

	  This option compresses the kernel modules when 'make

	  modules_install' is run.



	  The modules will be compressed either using gzip or xz depend on the

	  choice made in "Compression algorithm".



	  module-init-tools has support for gzip format while kmod handle gzip

	  and xz compressed modules.



	  When a kernel module is installed from outside of the main kernel

	  source and uses the Kbuild system for installing modules then that

	  kernel module will also be compressed when it is installed.



	  This option provides little benefit when the modules are to be used inside

	  an initrd or initramfs, it generally is more efficient to compress the whole

	  initrd or initramfs instead.



	  This is fully compatible with signed modules while the signed module is

	  compressed. module-init-tools or kmod handles decompression and provide to

	  other layer the uncompressed but signed payload.



choice

	prompt "Compression algorithm"

	depends on MODULE_COMPRESS

	default MODULE_COMPRESS_GZIP

	help

	  This determines which sort of compression will be used during

	  'make modules_install'.



	  GZIP (default) and XZ are supported.



config MODULE_COMPRESS_GZIP

	bool "GZIP"



config MODULE_COMPRESS_XZ

	bool "XZ"



endchoice



endif # MODULES



config INIT_ALL_POSSIBLE