Attachment #149448 for bug #217323





	  Take the default (1) unless you want more control or more info.

config ALPHA_UAC_SYSCTL
	bool "Configure UAC policy via sysctl"
	depends on SYSCTL
	default y
	---help---
	  Configuring the UAC (unaligned access control) policy on a Linux
	  system usually involves setting a compile time define. If you say
	  Y here, you will be able to modify the UAC policy at runtime using
	  the /proc interface.

	  The UAC policy defines the action Linux should take when an
	  unaligned memory access occurs. The action can include printing a
	  warning message (NOPRINT), sending a signal to the offending
	  program to help developers debug their applications (SIGBUS), or
	  disabling the transparent fixing (NOFIX).

	  The sysctls will be initialized to the compile-time defined UAC
	  policy. You can change these manually, or with the sysctl(8)
	  userspace utility.

	  To disable the warning messages at runtime, you would use

	    echo 1 > /proc/sys/kernel/uac/noprint

	  This is pretty harmless. Say Y if you're not sure.

source "drivers/pci/Kconfig"
source "drivers/eisa/Kconfig"





			   "t10", "t11", "ra", "pv", "at", "gp", "sp", "zero"};
#endif

#ifdef CONFIG_ALPHA_UAC_SYSCTL
static struct ctl_table_header *uac_sysctl_header;

/* /proc/sys/kernel/uac */
enum
{
   /* UAC policy on Alpha */
   KERN_UAC_NOPRINT=1, /* int: printk() on unaligned access */
   KERN_UAC_SIGBUS=2,  /* int: send SIGBUS on unaligned access */
   KERN_UAC_NOFIX=3,   /* int: don't fix the unaligned access */
};

static int enabled_noprint = 0;
static int enabled_sigbus = 0;
static int enabled_nofix = 0;

ctl_table uac_table[] = {
	{KERN_UAC_NOPRINT, "noprint", &enabled_noprint, sizeof (int), 0644, NULL, NULL, &proc_dointvec},
	{KERN_UAC_SIGBUS, "sigbus", &enabled_sigbus, sizeof (int), 0644, NULL, NULL, &proc_dointvec},
	{KERN_UAC_NOFIX, "nofix", &enabled_nofix, sizeof (int), 0644, NULL, NULL, &proc_dointvec},
        {0}
};

static int __init init_uac_sysctl(void)
{
	/* Initialize sysctls with the #defined UAC policy */
	enabled_noprint = (test_thread_flag (TIF_UAC_NOPRINT)) ? 1 : 0;
	enabled_sigbus = (test_thread_flag (TIF_UAC_SIGBUS)) ? 1 : 0;
	enabled_nofix = (test_thread_flag (TIF_UAC_NOFIX)) ? 1 : 0;

	/* save this for later so we can clean up */
	uac_sysctl_header = register_sysctl_table(uac_table);
	return 0;
}

static void __exit exit_uac_sysctl(void)
{
	unregister_sysctl_table(uac_sysctl_header);
}
#endif

static void
dik_show_code(unsigned int *pc)
{

	/* Check the UAC bits to decide what the user wants us to do
	   with the unaliged access.  */

#ifndef CONFIG_ALPHA_UAC_SYSCTL
	if (!test_thread_flag (TIF_UAC_NOPRINT)) {
#else  /* CONFIG_ALPHA_UAC_SYSCTL */
	if (!(enabled_noprint)) {
#endif /* CONFIG_ALPHA_UAC_SYSCTL */
		if (cnt >= 5 && jiffies - last_time > 5*HZ) {
			cnt = 0;
		}

		}
		last_time = jiffies;
	}
#ifndef CONFIG_ALPHA_UAC_SYSCTL
	if (test_thread_flag (TIF_UAC_SIGBUS))
#else  /* CONFIG_ALPHA_UAC_SYSCTL */
	if (enabled_sigbus)
#endif /* CONFIG_ALPHA_UAC_SYSCTL */
		goto give_sigbus;
	/* Not sure why you'd want to use this, but... */
#ifndef CONFIG_ALPHA_UAC_SYSCTL
	if (test_thread_flag (TIF_UAC_NOFIX))
#else  /* CONFIG_ALPHA_UAC_SYSCTL */
	if (enabled_nofix)
#endif /* CONFIG_ALPHA_UAC_SYSCTL */
		return;

	/* Don't bother reading ds in the access check since we already

	wrent(entSys, 5);
	wrent(entDbg, 6);
}

#ifdef CONFIG_ALPHA_UAC_SYSCTL
__initcall(init_uac_sysctl);
#endif

Lines 155-160 static int proc_dointvec_taint(struct ct Link Here

(-)src/kernel/sysctl.c.orig (+12 lines)
155	void __user buffer, size_t lenp, loff_t *ppos);	155	void __user buffer, size_t lenp, loff_t *ppos);
156	#endif	156	#endif
157		157
		158	#ifdef CONFIG_ALPHA_UAC_SYSCTL
		159	extern ctl_table uac_table[];
		160	#endif
		161
158	static struct ctl_table root_table[];	162	static struct ctl_table root_table[];
159	static struct ctl_table_header root_table_header =	163	static struct ctl_table_header root_table_header =
160	{ root_table, LIST_HEAD_INIT(root_table_header.ctl_entry) };	164	{ root_table, LIST_HEAD_INIT(root_table_header.ctl_entry) };
Lines 221-226 static struct ctl_table root_table[] = { Link Here
221	* NOTE: do not add new entries to this table unless you have read	225	* NOTE: do not add new entries to this table unless you have read
222	* Documentation/sysctl/ctl_unnumbered.txt	226	* Documentation/sysctl/ctl_unnumbered.txt
223	*/	227	*/
		228	#ifdef CONFIG_ALPHA_UAC_SYSCTL
		229	{
		230	.ctl_name = CTL_UNNUMBERED,
		231	.procname = "uac",
		232	.mode = 0555,
		233	.child = uac_table,
		234	},
		235	#endif /* CONFIG_ALPHA_UAC_SYSCTL */
224	{ .ctl_name = 0 }	236	{ .ctl_name = 0 }
225	};	237	};
226		238

Return to bug 217323

Lines 616-621 config VERBOSE_MCHECK_ON Link Here

(-)src/arch/alpha/Kconfig.orig (+26 lines)
616		616
617	Take the default (1) unless you want more control or more info.	617	Take the default (1) unless you want more control or more info.
618		618
		619	config ALPHA_UAC_SYSCTL
		620	bool "Configure UAC policy via sysctl"
		621	depends on SYSCTL
		622	default y
		623	---help---
		624	Configuring the UAC (unaligned access control) policy on a Linux
		625	system usually involves setting a compile time define. If you say
		626	Y here, you will be able to modify the UAC policy at runtime using
		627	the /proc interface.
		628
		629	The UAC policy defines the action Linux should take when an
		630	unaligned memory access occurs. The action can include printing a
		631	warning message (NOPRINT), sending a signal to the offending
		632	program to help developers debug their applications (SIGBUS), or
		633	disabling the transparent fixing (NOFIX).
		634
		635	The sysctls will be initialized to the compile-time defined UAC
		636	policy. You can change these manually, or with the sysctl(8)
		637	userspace utility.
		638
		639	To disable the warning messages at runtime, you would use
		640
		641	echo 1 > /proc/sys/kernel/uac/noprint
		642
		643	This is pretty harmless. Say Y if you're not sure.
		644
619	source "drivers/pci/Kconfig"	645	source "drivers/pci/Kconfig"
620	source "drivers/eisa/Kconfig"	646	source "drivers/eisa/Kconfig"
621		647

Lines 102-107 static char * ireg_name[] = {"v0", "t0", Link Here

(-)src/arch/alpha/kernel/traps.c.orig (+57 lines)
102	"t10", "t11", "ra", "pv", "at", "gp", "sp", "zero"};	102	"t10", "t11", "ra", "pv", "at", "gp", "sp", "zero"};
103	#endif	103	#endif
104		104
		105	#ifdef CONFIG_ALPHA_UAC_SYSCTL
		106	static struct ctl_table_header *uac_sysctl_header;
		107
		108	/* /proc/sys/kernel/uac */
		109	enum
		110	{
		111	/* UAC policy on Alpha */
		112	KERN_UAC_NOPRINT=1, /* int: printk() on unaligned access */
		113	KERN_UAC_SIGBUS=2, /* int: send SIGBUS on unaligned access */
		114	KERN_UAC_NOFIX=3, /* int: don't fix the unaligned access */
		115	};
		116
		117	static int enabled_noprint = 0;
		118	static int enabled_sigbus = 0;
		119	static int enabled_nofix = 0;
		120
		121	ctl_table uac_table[] = {
		122	{KERN_UAC_NOPRINT, "noprint", &enabled_noprint, sizeof (int), 0644, NULL, NULL, &proc_dointvec},
		123	{KERN_UAC_SIGBUS, "sigbus", &enabled_sigbus, sizeof (int), 0644, NULL, NULL, &proc_dointvec},
		124	{KERN_UAC_NOFIX, "nofix", &enabled_nofix, sizeof (int), 0644, NULL, NULL, &proc_dointvec},
		125	{0}
		126	};
		127
		128	static int __init init_uac_sysctl(void)
		129	{
		130	/* Initialize sysctls with the #defined UAC policy */
		131	enabled_noprint = (test_thread_flag (TIF_UAC_NOPRINT)) ? 1 : 0;
		132	enabled_sigbus = (test_thread_flag (TIF_UAC_SIGBUS)) ? 1 : 0;
		133	enabled_nofix = (test_thread_flag (TIF_UAC_NOFIX)) ? 1 : 0;
		134
		135	/* save this for later so we can clean up */
		136	uac_sysctl_header = register_sysctl_table(uac_table);
		137	return 0;
		138	}
		139
		140	static void __exit exit_uac_sysctl(void)
		141	{
		142	unregister_sysctl_table(uac_sysctl_header);
		143	}
		144	#endif
		145
105	static void	146	static void
106	dik_show_code(unsigned int *pc)	147	dik_show_code(unsigned int *pc)
107	{	148	{
Lines 780-786 do_entUnaUser(void __user * va, unsigned Link Here
780	/* Check the UAC bits to decide what the user wants us to do	821	/* Check the UAC bits to decide what the user wants us to do
781	with the unaliged access. */	822	with the unaliged access. */
782		823
		824	#ifndef CONFIG_ALPHA_UAC_SYSCTL
783	if (!test_thread_flag (TIF_UAC_NOPRINT)) {	825	if (!test_thread_flag (TIF_UAC_NOPRINT)) {
		826	#else /* CONFIG_ALPHA_UAC_SYSCTL */
		827	if (!(enabled_noprint)) {
		828	#endif /* CONFIG_ALPHA_UAC_SYSCTL */
784	if (cnt >= 5 && jiffies - last_time > 5*HZ) {	829	if (cnt >= 5 && jiffies - last_time > 5*HZ) {
785	cnt = 0;	830	cnt = 0;
786	}	831	}
Lines 791-800 do_entUnaUser(void __user * va, unsigned Link Here
791	}	836	}
792	last_time = jiffies;	837	last_time = jiffies;
793	}	838	}
		839	#ifndef CONFIG_ALPHA_UAC_SYSCTL
794	if (test_thread_flag (TIF_UAC_SIGBUS))	840	if (test_thread_flag (TIF_UAC_SIGBUS))
		841	#else /* CONFIG_ALPHA_UAC_SYSCTL */
		842	if (enabled_sigbus)
		843	#endif /* CONFIG_ALPHA_UAC_SYSCTL */
795	goto give_sigbus;	844	goto give_sigbus;
796	/* Not sure why you'd want to use this, but... */	845	/* Not sure why you'd want to use this, but... */
		846	#ifndef CONFIG_ALPHA_UAC_SYSCTL
797	if (test_thread_flag (TIF_UAC_NOFIX))	847	if (test_thread_flag (TIF_UAC_NOFIX))
		848	#else /* CONFIG_ALPHA_UAC_SYSCTL */
		849	if (enabled_nofix)
		850	#endif /* CONFIG_ALPHA_UAC_SYSCTL */
798	return;	851	return;
799		852
800	/* Don't bother reading ds in the access check since we already	853	/* Don't bother reading ds in the access check since we already
Lines 1089-1091 trap_init(void) Link Here
1089	wrent(entSys, 5);	1142	wrent(entSys, 5);
1090	wrent(entDbg, 6);	1143	wrent(entDbg, 6);
1091	}	1144	}
		1145
		1146	#ifdef CONFIG_ALPHA_UAC_SYSCTL
		1147	__initcall(init_uac_sysctl);
		1148	#endif