kernel/exec_domain.c - pub/scm/linux/kernel/git/wtarreau/linux-2.4 - Git at Google

 /*
  * Handling of different ABIs (personalities).
  *
  * We group personalities into execution domains which have their
  * own handlers for kernel entry points, signal mapping, etc...
  *
  * 2001-05-06	Complete rewrite,  Christoph Hellwig (hch@infradead.org)
  */

 #include <linux/config.h>
 #include <linux/init.h>
 #include <linux/kernel.h>
 #include <linux/kmod.h>
 #include <linux/module.h>
 #include <linux/personality.h>
 #include <linux/sched.h>
 #include <linux/sysctl.h>
 #include <linux/types.h>


 static void default_handler(int, struct pt_regs *);

 static struct exec_domain *exec_domains = &default_exec_domain;
 static rwlock_t exec_domains_lock = RW_LOCK_UNLOCKED;


 static u_long ident_map[32] = {
 	0,	1,	2,	3,	4,	5,	6,	7,
 	8,	9,	10,	11,	12,	13,	14,	15,
 	16,	17,	18,	19,	20,	21,	22,	23,
 	24,	25,	26,	27,	28,	29,	30,	31
 };

 struct exec_domain default_exec_domain = {
 	"Linux",		/* name */
 	default_handler,	/* lcall7 causes a seg fault. */
 	0, 0,			/* PER_LINUX personality. */
 	ident_map,		/* Identity map signals. */
 	ident_map,		/*  - both ways. */
 };


 static void
 default_handler(int segment, struct pt_regs *regp)
 {
 	u_long			pers = 0;

 	/*
 	 * This may have been a static linked SVr4 binary, so we would
 	 * have the personality set incorrectly. Or it might have been
 	 * a Solaris/x86 binary. We can tell which because the former
 	 * uses lcall7, while the latter used lcall 0x27.
 	 * Try to find or load the appropriate personality, and fall back
 	 * to just forcing a SEGV.
 	 *
 	 * XXX: this is IA32-specific and should be moved to the MD-tree.
 	 */
 	switch (segment) {
 #ifdef __i386__
 	case 0x07:
 		pers = abi_defhandler_lcall7;
 		break;
 	case 0x27:
 		pers = PER_SOLARIS;
 		break;
 #endif
 	}
 	set_personality(pers);

 	if (current->exec_domain->handler != default_handler)
 		current->exec_domain->handler(segment, regp);
 	else
 		send_sig(SIGSEGV, current, 1);
 }

 static struct exec_domain *
 lookup_exec_domain(u_long personality)
 {
 	struct exec_domain *	ep;
 	u_long			pers = personality(personality);

 	read_lock(&exec_domains_lock);
 	for (ep = exec_domains; ep; ep = ep->next) {
 		if (pers >= ep->pers_low && pers <= ep->pers_high)
 			if (try_inc_mod_count(ep->module))
 				goto out;
 	}

 #ifdef CONFIG_KMOD
 	read_unlock(&exec_domains_lock);
 	{
 		char buffer[30];
 		sprintf(buffer, "personality-%ld", pers);
 		request_module(buffer);
 	}
 	read_lock(&exec_domains_lock);

 	for (ep = exec_domains; ep; ep = ep->next) {
 		if (pers >= ep->pers_low && pers <= ep->pers_high)
 			if (try_inc_mod_count(ep->module))
 				goto out;
 	}
 #endif

 	ep = &default_exec_domain;
 out:
 	read_unlock(&exec_domains_lock);
 	return (ep);
 }

 int
 register_exec_domain(struct exec_domain *ep)
 {
 	struct exec_domain	*tmp;
 	int			err = -EBUSY;

 	if (ep == NULL)
 		return -EINVAL;

 	if (ep->next != NULL)
 		return -EBUSY;

 	write_lock(&exec_domains_lock);
 	for (tmp = exec_domains; tmp; tmp = tmp->next) {
 		if (tmp == ep)
 			goto out;
 	}

 	ep->next = exec_domains;
 	exec_domains = ep;
 	err = 0;

 out:
 	write_unlock(&exec_domains_lock);
 	return (err);
 }

 int
 unregister_exec_domain(struct exec_domain *ep)
 {
 	struct exec_domain	**epp;

 	epp = &exec_domains;
 	write_lock(&exec_domains_lock);
 	for (epp = &exec_domains; *epp; epp = &(*epp)->next) {
 		if (ep == *epp)
 			goto unregister;
 	}
 	write_unlock(&exec_domains_lock);
 	return -EINVAL;

 unregister:
 	*epp = ep->next;
 	ep->next = NULL;
 	write_unlock(&exec_domains_lock);
 	return 0;
 }

 int
 __set_personality(u_long personality)
 {
 	struct exec_domain	*ep, *oep;

 	ep = lookup_exec_domain(personality);
 	if (ep == current->exec_domain) {
 		current->personality = personality;
 		return 0;
 	}

 	if (atomic_read(&current->fs->count) != 1) {
 		struct fs_struct *fsp, *ofsp;

 		fsp = copy_fs_struct(current->fs);
 		if (fsp == NULL) {
 			put_exec_domain(ep);
 			return -ENOMEM;;
 		}

 		task_lock(current);
 		ofsp = current->fs;
 		current->fs = fsp;
 		task_unlock(current);

 		put_fs_struct(ofsp);
 	}

 	/*
 	 * At that point we are guaranteed to be the sole owner of
 	 * current->fs.
 	 */

 	current->personality = personality;
 	oep = current->exec_domain;
 	current->exec_domain = ep;
 	set_fs_altroot();

 	put_exec_domain(oep);

 	return 0;
 }

 int
 get_exec_domain_list(char *page)
 {
 	struct exec_domain	*ep;
 	int			len = 0;

 	read_lock(&exec_domains_lock);
 	for (ep = exec_domains; ep && len < PAGE_SIZE - 80; ep = ep->next)
 		len += sprintf(page + len, "%d-%d\t%-16s\t[%s]\n",
 			ep->pers_low, ep->pers_high, ep->name,
 			ep->module ? ep->module->name : "kernel");
 	read_unlock(&exec_domains_lock);
 	return (len);
 }

 asmlinkage long
 sys_personality(u_long personality)
 {
 	u_long old = current->personality;;

 	if (personality != 0xffffffff) {
 		set_personality(personality);
 		if (current->personality != personality)
 			return -EINVAL;
 	}

 	return (long)old;
 }


 EXPORT_SYMBOL(register_exec_domain);
 EXPORT_SYMBOL(unregister_exec_domain);
 EXPORT_SYMBOL(__set_personality);

 /*
  * We have to have all sysctl handling for the Linux-ABI
  * in one place as the dynamic registration of sysctls is
  * horribly crufty in Linux <= 2.4.
  *
  * I hope the new sysctl schemes discussed for future versions
  * will obsolete this.
  *
  * 				--hch
  */

 u_long abi_defhandler_coff = PER_SCOSVR3;
 u_long abi_defhandler_elf = PER_LINUX;
 u_long abi_defhandler_lcall7 = PER_SVR4;
 u_long abi_defhandler_libcso = PER_SVR4;
 u_int abi_traceflg;
 int abi_fake_utsname;

 static struct ctl_table abi_table[] = {
 	{ABI_DEFHANDLER_COFF, "defhandler_coff", &abi_defhandler_coff,
 		sizeof(int), 0644, NULL, &proc_doulongvec_minmax},
 	{ABI_DEFHANDLER_ELF, "defhandler_elf", &abi_defhandler_elf,
 		sizeof(int), 0644, NULL, &proc_doulongvec_minmax},
 	{ABI_DEFHANDLER_LCALL7, "defhandler_lcall7", &abi_defhandler_lcall7,
 		sizeof(int), 0644, NULL, &proc_doulongvec_minmax},
 	{ABI_DEFHANDLER_LIBCSO, "defhandler_libcso", &abi_defhandler_libcso,
 		sizeof(int), 0644, NULL, &proc_doulongvec_minmax},
 	{ABI_TRACE, "trace", &abi_traceflg,
 		sizeof(u_int), 0644, NULL, &proc_dointvec},
 	{ABI_FAKE_UTSNAME, "fake_utsname", &abi_fake_utsname,
 		sizeof(int), 0644, NULL, &proc_dointvec},
 	{0}
 };

 static struct ctl_table abi_root_table[] = {
 	{CTL_ABI, "abi", NULL, 0, 0555, abi_table},
 	{0}
 };

 static int __init
 abi_register_sysctl(void)
 {
 	register_sysctl_table(abi_root_table, 1);
 	return 0;
 }

 __initcall(abi_register_sysctl);


 EXPORT_SYMBOL(abi_defhandler_coff);
 EXPORT_SYMBOL(abi_defhandler_elf);
 EXPORT_SYMBOL(abi_defhandler_lcall7);
 EXPORT_SYMBOL(abi_defhandler_libcso);
 EXPORT_SYMBOL(abi_traceflg);
 EXPORT_SYMBOL(abi_fake_utsname);
	/*
	* Handling of different ABIs (personalities).
	*
	* We group personalities into execution domains which have their
	* own handlers for kernel entry points, signal mapping, etc...
	*
	* 2001-05-06 Complete rewrite, Christoph Hellwig (hch@infradead.org)
	*/

	#include <linux/config.h>
	#include <linux/init.h>
	#include <linux/kernel.h>
	#include <linux/kmod.h>
	#include <linux/module.h>
	#include <linux/personality.h>
	#include <linux/sched.h>
	#include <linux/sysctl.h>
	#include <linux/types.h>


	static void default_handler(int, struct pt_regs *);

	static struct exec_domain *exec_domains = &default_exec_domain;
	static rwlock_t exec_domains_lock = RW_LOCK_UNLOCKED;


	static u_long ident_map[32] = {
	0, 1, 2, 3, 4, 5, 6, 7,
	8, 9, 10, 11, 12, 13, 14, 15,
	16, 17, 18, 19, 20, 21, 22, 23,
	24, 25, 26, 27, 28, 29, 30, 31
	};

	struct exec_domain default_exec_domain = {
	"Linux", /* name */
	default_handler, /* lcall7 causes a seg fault. */
	0, 0, /* PER_LINUX personality. */
	ident_map, /* Identity map signals. */
	ident_map, /* - both ways. */
	};


	static void
	default_handler(int segment, struct pt_regs *regp)
	{
	u_long pers = 0;

	/*
	* This may have been a static linked SVr4 binary, so we would
	* have the personality set incorrectly. Or it might have been
	* a Solaris/x86 binary. We can tell which because the former
	* uses lcall7, while the latter used lcall 0x27.
	* Try to find or load the appropriate personality, and fall back
	* to just forcing a SEGV.
	*
	* XXX: this is IA32-specific and should be moved to the MD-tree.
	*/
	switch (segment) {
	#ifdef __i386__
	case 0x07:
	pers = abi_defhandler_lcall7;
	break;
	case 0x27:
	pers = PER_SOLARIS;
	break;
	#endif
	}
	set_personality(pers);

	if (current->exec_domain->handler != default_handler)
	current->exec_domain->handler(segment, regp);
	else
	send_sig(SIGSEGV, current, 1);
	}

	static struct exec_domain *
	lookup_exec_domain(u_long personality)
	{
	struct exec_domain * ep;
	u_long pers = personality(personality);

	read_lock(&exec_domains_lock);
	for (ep = exec_domains; ep; ep = ep->next) {
	if (pers >= ep->pers_low && pers <= ep->pers_high)
	if (try_inc_mod_count(ep->module))
	goto out;
	}

	#ifdef CONFIG_KMOD
	read_unlock(&exec_domains_lock);
	{
	char buffer[30];
	sprintf(buffer, "personality-%ld", pers);
	request_module(buffer);
	}
	read_lock(&exec_domains_lock);

	for (ep = exec_domains; ep; ep = ep->next) {
	if (pers >= ep->pers_low && pers <= ep->pers_high)
	if (try_inc_mod_count(ep->module))
	goto out;
	}
	#endif

	ep = &default_exec_domain;
	out:
	read_unlock(&exec_domains_lock);
	return (ep);
	}

	int
	register_exec_domain(struct exec_domain *ep)
	{
	struct exec_domain *tmp;
	int err = -EBUSY;

	if (ep == NULL)
	return -EINVAL;

	if (ep->next != NULL)
	return -EBUSY;

	write_lock(&exec_domains_lock);
	for (tmp = exec_domains; tmp; tmp = tmp->next) {
	if (tmp == ep)
	goto out;
	}

	ep->next = exec_domains;
	exec_domains = ep;
	err = 0;

	out:
	write_unlock(&exec_domains_lock);
	return (err);
	}

	int
	unregister_exec_domain(struct exec_domain *ep)
	{
	struct exec_domain **epp;

	epp = &exec_domains;
	write_lock(&exec_domains_lock);
	for (epp = &exec_domains; epp; epp = &(epp)->next) {
	if (ep == *epp)
	goto unregister;
	}
	write_unlock(&exec_domains_lock);
	return -EINVAL;

	unregister:
	*epp = ep->next;
	ep->next = NULL;
	write_unlock(&exec_domains_lock);
	return 0;
	}

	int
	__set_personality(u_long personality)
	{
	struct exec_domain ep, oep;

	ep = lookup_exec_domain(personality);
	if (ep == current->exec_domain) {
	current->personality = personality;
	return 0;
	}

	if (atomic_read(&current->fs->count) != 1) {
	struct fs_struct fsp, ofsp;

	fsp = copy_fs_struct(current->fs);
	if (fsp == NULL) {
	put_exec_domain(ep);
	return -ENOMEM;;
	}

	task_lock(current);
	ofsp = current->fs;
	current->fs = fsp;
	task_unlock(current);

	put_fs_struct(ofsp);
	}

	/*
	* At that point we are guaranteed to be the sole owner of
	* current->fs.
	*/

	current->personality = personality;
	oep = current->exec_domain;
	current->exec_domain = ep;
	set_fs_altroot();

	put_exec_domain(oep);

	return 0;
	}

	int
	get_exec_domain_list(char *page)
	{
	struct exec_domain *ep;
	int len = 0;

	read_lock(&exec_domains_lock);
	for (ep = exec_domains; ep && len < PAGE_SIZE - 80; ep = ep->next)
	len += sprintf(page + len, "%d-%d\t%-16s\t[%s]\n",
	ep->pers_low, ep->pers_high, ep->name,
	ep->module ? ep->module->name : "kernel");
	read_unlock(&exec_domains_lock);
	return (len);
	}

	asmlinkage long
	sys_personality(u_long personality)
	{
	u_long old = current->personality;;

	if (personality != 0xffffffff) {
	set_personality(personality);
	if (current->personality != personality)
	return -EINVAL;
	}

	return (long)old;
	}


	EXPORT_SYMBOL(register_exec_domain);
	EXPORT_SYMBOL(unregister_exec_domain);
	EXPORT_SYMBOL(__set_personality);

	/*
	* We have to have all sysctl handling for the Linux-ABI
	* in one place as the dynamic registration of sysctls is
	* horribly crufty in Linux <= 2.4.
	*
	* I hope the new sysctl schemes discussed for future versions
	* will obsolete this.
	*
	* --hch
	*/

	u_long abi_defhandler_coff = PER_SCOSVR3;
	u_long abi_defhandler_elf = PER_LINUX;
	u_long abi_defhandler_lcall7 = PER_SVR4;
	u_long abi_defhandler_libcso = PER_SVR4;
	u_int abi_traceflg;
	int abi_fake_utsname;

	static struct ctl_table abi_table[] = {
	{ABI_DEFHANDLER_COFF, "defhandler_coff", &abi_defhandler_coff,
	sizeof(int), 0644, NULL, &proc_doulongvec_minmax},
	{ABI_DEFHANDLER_ELF, "defhandler_elf", &abi_defhandler_elf,
	sizeof(int), 0644, NULL, &proc_doulongvec_minmax},
	{ABI_DEFHANDLER_LCALL7, "defhandler_lcall7", &abi_defhandler_lcall7,
	sizeof(int), 0644, NULL, &proc_doulongvec_minmax},
	{ABI_DEFHANDLER_LIBCSO, "defhandler_libcso", &abi_defhandler_libcso,
	sizeof(int), 0644, NULL, &proc_doulongvec_minmax},
	{ABI_TRACE, "trace", &abi_traceflg,
	sizeof(u_int), 0644, NULL, &proc_dointvec},
	{ABI_FAKE_UTSNAME, "fake_utsname", &abi_fake_utsname,
	sizeof(int), 0644, NULL, &proc_dointvec},
	{0}
	};

	static struct ctl_table abi_root_table[] = {
	{CTL_ABI, "abi", NULL, 0, 0555, abi_table},
	{0}
	};

	static int __init
	abi_register_sysctl(void)
	{
	register_sysctl_table(abi_root_table, 1);
	return 0;
	}

	__initcall(abi_register_sysctl);


	EXPORT_SYMBOL(abi_defhandler_coff);
	EXPORT_SYMBOL(abi_defhandler_elf);
	EXPORT_SYMBOL(abi_defhandler_lcall7);
	EXPORT_SYMBOL(abi_defhandler_libcso);
	EXPORT_SYMBOL(abi_traceflg);
	EXPORT_SYMBOL(abi_fake_utsname);