Attachment #149485 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"





#include <linux/delay.h>
#include <linux/smp_lock.h>
#include <linux/module.h>
#include <linux/sysctl.h>
#include <linux/init.h>
#include <linux/kallsyms.h>


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

#ifdef CONFIG_ALPHA_UAC_SYSCTL
/* /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;
	return 0;
}
#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 14-19 Link Here

(-)src/arch/alpha/kernel/traps.c.orig (+48 lines)
14	#include <linux/delay.h>	14	#include <linux/delay.h>
15	#include <linux/smp_lock.h>	15	#include <linux/smp_lock.h>
16	#include <linux/module.h>	16	#include <linux/module.h>
		17	#include <linux/sysctl.h>
17	#include <linux/init.h>	18	#include <linux/init.h>
18	#include <linux/kallsyms.h>	19	#include <linux/kallsyms.h>
19		20
Lines 102-107 static char * ireg_name[] = {"v0", "t0", Link Here
102	"t10", "t11", "ra", "pv", "at", "gp", "sp", "zero"};	103	"t10", "t11", "ra", "pv", "at", "gp", "sp", "zero"};
103	#endif	104	#endif
104		105
		106	#ifdef CONFIG_ALPHA_UAC_SYSCTL
		107	/* /proc/sys/kernel/uac */
		108	enum
		109	{
		110	/* UAC policy on Alpha */
		111	KERN_UAC_NOPRINT=1, /* int: printk() on unaligned access */
		112	KERN_UAC_SIGBUS=2, /* int: send SIGBUS on unaligned access */
		113	KERN_UAC_NOFIX=3, /* int: don't fix the unaligned access */
		114	};
		115
		116	static int enabled_noprint = 0;
		117	static int enabled_sigbus = 0;
		118	static int enabled_nofix = 0;
		119
		120	ctl_table uac_table[] = {
		121	{KERN_UAC_NOPRINT, "noprint", &enabled_noprint, sizeof (int), 0644, NULL, NULL, &proc_dointvec},
		122	{KERN_UAC_SIGBUS, "sigbus", &enabled_sigbus, sizeof (int), 0644, NULL, NULL, &proc_dointvec},
		123	{KERN_UAC_NOFIX, "nofix", &enabled_nofix, sizeof (int), 0644, NULL, NULL, &proc_dointvec},
		124	{0}
		125	};
		126
		127	static int __init init_uac_sysctl(void)
		128	{
		129	/* Initialize sysctls with the #defined UAC policy */
		130	enabled_noprint = (test_thread_flag (TIF_UAC_NOPRINT)) ? 1 : 0;
		131	enabled_sigbus = (test_thread_flag (TIF_UAC_SIGBUS)) ? 1 : 0;
		132	enabled_nofix = (test_thread_flag (TIF_UAC_NOFIX)) ? 1 : 0;
		133	return 0;
		134	}
		135	#endif
		136
105	static void	137	static void
106	dik_show_code(unsigned int *pc)	138	dik_show_code(unsigned int *pc)
107	{	139	{
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	812	/* Check the UAC bits to decide what the user wants us to do
781	with the unaliged access. */	813	with the unaliged access. */
782		814
		815	#ifndef CONFIG_ALPHA_UAC_SYSCTL
783	if (!test_thread_flag (TIF_UAC_NOPRINT)) {	816	if (!test_thread_flag (TIF_UAC_NOPRINT)) {
		817	#else /* CONFIG_ALPHA_UAC_SYSCTL */
		818	if (!(enabled_noprint)) {
		819	#endif /* CONFIG_ALPHA_UAC_SYSCTL */
784	if (cnt >= 5 && jiffies - last_time > 5*HZ) {	820	if (cnt >= 5 && jiffies - last_time > 5*HZ) {
785	cnt = 0;	821	cnt = 0;
786	}	822	}
Lines 791-800 do_entUnaUser(void __user * va, unsigned Link Here
791	}	827	}
792	last_time = jiffies;	828	last_time = jiffies;
793	}	829	}
		830	#ifndef CONFIG_ALPHA_UAC_SYSCTL
794	if (test_thread_flag (TIF_UAC_SIGBUS))	831	if (test_thread_flag (TIF_UAC_SIGBUS))
		832	#else /* CONFIG_ALPHA_UAC_SYSCTL */
		833	if (enabled_sigbus)
		834	#endif /* CONFIG_ALPHA_UAC_SYSCTL */
795	goto give_sigbus;	835	goto give_sigbus;
796	/* Not sure why you'd want to use this, but... */	836	/* Not sure why you'd want to use this, but... */
		837	#ifndef CONFIG_ALPHA_UAC_SYSCTL
797	if (test_thread_flag (TIF_UAC_NOFIX))	838	if (test_thread_flag (TIF_UAC_NOFIX))
		839	#else /* CONFIG_ALPHA_UAC_SYSCTL */
		840	if (enabled_nofix)
		841	#endif /* CONFIG_ALPHA_UAC_SYSCTL */
798	return;	842	return;
799		843
800	/* Don't bother reading ds in the access check since we already	844	/* Don't bother reading ds in the access check since we already
Lines 1089-1091 trap_init(void) Link Here
1089	wrent(entSys, 5);	1133	wrent(entSys, 5);
1090	wrent(entDbg, 6);	1134	wrent(entDbg, 6);
1091	}	1135	}
		1136
		1137	#ifdef CONFIG_ALPHA_UAC_SYSCTL
		1138	__initcall(init_uac_sysctl);
		1139	#endif