[mirror_ubuntu-artful-kernel.git] / arch / x86 / um / ldt.c

/*
 * Copyright (C) 2001 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com)
 * Licensed under the GPL
 */

#include <linux/mm.h>
#include <linux/sched.h>
#include <linux/slab.h>
#include <linux/uaccess.h>
#include <asm/unistd.h>
#include <os.h>
#include <skas.h>
#include <sysdep/tls.h>

extern int modify_ldt(int func, void *ptr, unsigned long bytecount);

static long write_ldt_entry(struct mm_id *mm_idp, int func,
		     struct user_desc *desc, void **addr, int done)
{
	long res;
	void *stub_addr;
	res = syscall_stub_data(mm_idp, (unsigned long *)desc,
				(sizeof(*desc) + sizeof(long) - 1) &
				    ~(sizeof(long) - 1),
				addr, &stub_addr);
	if (!res) {
		unsigned long args[] = { func,
					 (unsigned long)stub_addr,
					 sizeof(*desc),
					 0, 0, 0 };
		res = run_syscall_stub(mm_idp, __NR_modify_ldt, args,
				       0, addr, done);
	}

	return res;
}

/*
 * In skas mode, we hold our own ldt data in UML.
 * Thus, the code implementing sys_modify_ldt_skas
 * is very similar to (and mostly stolen from) sys_modify_ldt
 * for arch/i386/kernel/ldt.c
 * The routines copied and modified in part are:
 * - read_ldt
 * - read_default_ldt
 * - write_ldt
 * - sys_modify_ldt_skas
 */

static int read_ldt(void __user * ptr, unsigned long bytecount)
{
	int i, err = 0;
	unsigned long size;
	uml_ldt_t *ldt = &current->mm->context.arch.ldt;

	if (!ldt->entry_count)
		goto out;
	if (bytecount > LDT_ENTRY_SIZE*LDT_ENTRIES)
		bytecount = LDT_ENTRY_SIZE*LDT_ENTRIES;
	err = bytecount;

	mutex_lock(&ldt->lock);
	if (ldt->entry_count <= LDT_DIRECT_ENTRIES) {
		size = LDT_ENTRY_SIZE*LDT_DIRECT_ENTRIES;
		if (size > bytecount)
			size = bytecount;
		if (copy_to_user(ptr, ldt->u.entries, size))
			err = -EFAULT;
		bytecount -= size;
		ptr += size;
	}
	else {
		for (i=0; i<ldt->entry_count/LDT_ENTRIES_PER_PAGE && bytecount;
		     i++) {
			size = PAGE_SIZE;
			if (size > bytecount)
				size = bytecount;
			if (copy_to_user(ptr, ldt->u.pages[i], size)) {
				err = -EFAULT;
				break;
			}
			bytecount -= size;
			ptr += size;
		}
	}
	mutex_unlock(&ldt->lock);

	if (bytecount == 0 || err == -EFAULT)
		goto out;

	if (clear_user(ptr, bytecount))
		err = -EFAULT;

out:
	return err;
}

static int read_default_ldt(void __user * ptr, unsigned long bytecount)
{
	int err;

	if (bytecount > 5*LDT_ENTRY_SIZE)
		bytecount = 5*LDT_ENTRY_SIZE;

	err = bytecount;
	/*
	 * UML doesn't support lcall7 and lcall27.
	 * So, we don't really have a default ldt, but emulate
	 * an empty ldt of common host default ldt size.
	 */
	if (clear_user(ptr, bytecount))
		err = -EFAULT;

	return err;
}

static int write_ldt(void __user * ptr, unsigned long bytecount, int func)
{
	uml_ldt_t *ldt = &current->mm->context.arch.ldt;
	struct mm_id * mm_idp = &current->mm->context.id;
	int i, err;
	struct user_desc ldt_info;
	struct ldt_entry entry0, *ldt_p;
	void *addr = NULL;

	err = -EINVAL;
	if (bytecount != sizeof(ldt_info))
		goto out;
	err = -EFAULT;
	if (copy_from_user(&ldt_info, ptr, sizeof(ldt_info)))
		goto out;

	err = -EINVAL;
	if (ldt_info.entry_number >= LDT_ENTRIES)
		goto out;
	if (ldt_info.contents == 3) {
		if (func == 1)
			goto out;
		if (ldt_info.seg_not_present == 0)
			goto out;
	}

	mutex_lock(&ldt->lock);

	err = write_ldt_entry(mm_idp, func, &ldt_info, &addr, 1);
	if (err)
		goto out_unlock;

	if (ldt_info.entry_number >= ldt->entry_count &&
	    ldt_info.entry_number >= LDT_DIRECT_ENTRIES) {
		for (i=ldt->entry_count/LDT_ENTRIES_PER_PAGE;
		     i*LDT_ENTRIES_PER_PAGE <= ldt_info.entry_number;
		     i++) {
			if (i == 0)
				memcpy(&entry0, ldt->u.entries,
				       sizeof(entry0));
			ldt->u.pages[i] = (struct ldt_entry *)
				__get_free_page(GFP_KERNEL|__GFP_ZERO);
			if (!ldt->u.pages[i]) {
				err = -ENOMEM;
				/* Undo the change in host */
				memset(&ldt_info, 0, sizeof(ldt_info));
				write_ldt_entry(mm_idp, 1, &ldt_info, &addr, 1);
				goto out_unlock;
			}
			if (i == 0) {
				memcpy(ldt->u.pages[0], &entry0,
				       sizeof(entry0));
				memcpy(ldt->u.pages[0]+1, ldt->u.entries+1,
				       sizeof(entry0)*(LDT_DIRECT_ENTRIES-1));
			}
			ldt->entry_count = (i + 1) * LDT_ENTRIES_PER_PAGE;
		}
	}
	if (ldt->entry_count <= ldt_info.entry_number)
		ldt->entry_count = ldt_info.entry_number + 1;

	if (ldt->entry_count <= LDT_DIRECT_ENTRIES)
		ldt_p = ldt->u.entries + ldt_info.entry_number;
	else
		ldt_p = ldt->u.pages[ldt_info.entry_number/LDT_ENTRIES_PER_PAGE] +
			ldt_info.entry_number%LDT_ENTRIES_PER_PAGE;

	if (ldt_info.base_addr == 0 && ldt_info.limit == 0 &&
	   (func == 1 || LDT_empty(&ldt_info))) {
		ldt_p->a = 0;
		ldt_p->b = 0;
	}
	else{
		if (func == 1)
			ldt_info.useable = 0;
		ldt_p->a = LDT_entry_a(&ldt_info);
		ldt_p->b = LDT_entry_b(&ldt_info);
	}
	err = 0;

out_unlock:
	mutex_unlock(&ldt->lock);
out:
	return err;
}

static long do_modify_ldt_skas(int func, void __user *ptr,
			       unsigned long bytecount)
{
	int ret = -ENOSYS;

	switch (func) {
		case 0:
			ret = read_ldt(ptr, bytecount);
			break;
		case 1:
		case 0x11:
			ret = write_ldt(ptr, bytecount, func);
			break;
		case 2:
			ret = read_default_ldt(ptr, bytecount);
			break;
	}
	return ret;
}

static DEFINE_SPINLOCK(host_ldt_lock);
static short dummy_list[9] = {0, -1};
static short * host_ldt_entries = NULL;

static void ldt_get_host_info(void)
{
	long ret;
	struct ldt_entry * ldt;
	short *tmp;
	int i, size, k, order;

	spin_lock(&host_ldt_lock);

	if (host_ldt_entries != NULL) {
		spin_unlock(&host_ldt_lock);
		return;
	}
	host_ldt_entries = dummy_list+1;

	spin_unlock(&host_ldt_lock);

	for (i = LDT_PAGES_MAX-1, order=0; i; i>>=1, order++)
		;

	ldt = (struct ldt_entry *)
	      __get_free_pages(GFP_KERNEL|__GFP_ZERO, order);
	if (ldt == NULL) {
		printk(KERN_ERR "ldt_get_host_info: couldn't allocate buffer "
		       "for host ldt\n");
		return;
	}

	ret = modify_ldt(0, ldt, (1<<order)*PAGE_SIZE);
	if (ret < 0) {
		printk(KERN_ERR "ldt_get_host_info: couldn't read host ldt\n");
		goto out_free;
	}
	if (ret == 0) {
		/* default_ldt is active, simply write an empty entry 0 */
		host_ldt_entries = dummy_list;
		goto out_free;
	}

	for (i=0, size=0; i<ret/LDT_ENTRY_SIZE; i++) {
		if (ldt[i].a != 0 || ldt[i].b != 0)
			size++;
	}

	if (size < ARRAY_SIZE(dummy_list))
		host_ldt_entries = dummy_list;
	else {
		size = (size + 1) * sizeof(dummy_list[0]);
		tmp = kmalloc(size, GFP_KERNEL);
		if (tmp == NULL) {
			printk(KERN_ERR "ldt_get_host_info: couldn't allocate "
			       "host ldt list\n");
			goto out_free;
		}
		host_ldt_entries = tmp;
	}

	for (i=0, k=0; i<ret/LDT_ENTRY_SIZE; i++) {
		if (ldt[i].a != 0 || ldt[i].b != 0)
			host_ldt_entries[k++] = i;
	}
	host_ldt_entries[k] = -1;

out_free:
	free_pages((unsigned long)ldt, order);
}

long init_new_ldt(struct mm_context *new_mm, struct mm_context *from_mm)
{
	struct user_desc desc;
	short * num_p;
	int i;
	long page, err=0;
	void *addr = NULL;


	mutex_init(&new_mm->arch.ldt.lock);

	if (!from_mm) {
		memset(&desc, 0, sizeof(desc));
		/*
		 * Now we try to retrieve info about the ldt, we
		 * inherited from the host. All ldt-entries found
		 * will be reset in the following loop
		 */
		ldt_get_host_info();
		for (num_p=host_ldt_entries; *num_p != -1; num_p++) {
			desc.entry_number = *num_p;
			err = write_ldt_entry(&new_mm->id, 1, &desc,
					      &addr, *(num_p + 1) == -1);
			if (err)
				break;
		}
		new_mm->arch.ldt.entry_count = 0;

		goto out;
	}

	/*
	 * Our local LDT is used to supply the data for
	 * modify_ldt(READLDT), if PTRACE_LDT isn't available,
	 * i.e., we have to use the stub for modify_ldt, which
	 * can't handle the big read buffer of up to 64kB.
	 */
	mutex_lock(&from_mm->arch.ldt.lock);
	if (from_mm->arch.ldt.entry_count <= LDT_DIRECT_ENTRIES)
		memcpy(new_mm->arch.ldt.u.entries, from_mm->arch.ldt.u.entries,
		       sizeof(new_mm->arch.ldt.u.entries));
	else {
		i = from_mm->arch.ldt.entry_count / LDT_ENTRIES_PER_PAGE;
		while (i-->0) {
			page = __get_free_page(GFP_KERNEL|__GFP_ZERO);
			if (!page) {
				err = -ENOMEM;
				break;
			}
			new_mm->arch.ldt.u.pages[i] =
				(struct ldt_entry *) page;
			memcpy(new_mm->arch.ldt.u.pages[i],
			       from_mm->arch.ldt.u.pages[i], PAGE_SIZE);
		}
	}
	new_mm->arch.ldt.entry_count = from_mm->arch.ldt.entry_count;
	mutex_unlock(&from_mm->arch.ldt.lock);

    out:
	return err;
}


void free_ldt(struct mm_context *mm)
{
	int i;

	if (mm->arch.ldt.entry_count > LDT_DIRECT_ENTRIES) {
		i = mm->arch.ldt.entry_count / LDT_ENTRIES_PER_PAGE;
		while (i-- > 0)
			free_page((long) mm->arch.ldt.u.pages[i]);
	}
	mm->arch.ldt.entry_count = 0;
}

int sys_modify_ldt(int func, void __user *ptr, unsigned long bytecount)
{
	return do_modify_ldt_skas(func, ptr, bytecount);
}
Commit	Line	Data
1da177e4	1	/*
ba180fd4	2	* Copyright (C) 2001 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com)
1da177e4 LT	3	* Licensed under the GPL
	4	*/
	5
8192ab42 JD	6	#include <linux/mm.h>
8192ab42 JD	7	#include <linux/sched.h>
5a0e3ad6	8	#include <linux/slab.h>
1d04c8d7	9	#include <linux/uaccess.h>
8192ab42	10	#include <asm/unistd.h>
37185b33	11	#include <os.h>
37185b33	12	#include <skas.h>
37185b33	13	#include <sysdep/tls.h>
ba180fd4 JD	14
ba180fd4 JD	15	extern int modify_ldt(int func, void *ptr, unsigned long bytecount);
858259cf	16
99764fa4 WC	17	static long write_ldt_entry(struct mm_id *mm_idp, int func,
99764fa4 WC	18	struct user_desc desc, void *addr, int done)
858259cf BS	19	{
858259cf BS	20	long res;
d0b5e15f RW	21	void *stub_addr;
	22	res = syscall_stub_data(mm_idp, (unsigned long *)desc,
	23	(sizeof(*desc) + sizeof(long) - 1) &
	24	~(sizeof(long) - 1),
	25	addr, &stub_addr);
	26	if (!res) {
	27	unsigned long args[] = { func,
	28	(unsigned long)stub_addr,
	29	sizeof(*desc),
	30	0, 0, 0 };
	31	res = run_syscall_stub(mm_idp, __NR_modify_ldt, args,
	32	0, addr, done);
858259cf BS	33	}
858259cf BS	34
858259cf BS	35	return res;
	36	}
	37
	38	/*
	39	* In skas mode, we hold our own ldt data in UML.
	40	* Thus, the code implementing sys_modify_ldt_skas
	41	* is very similar to (and mostly stolen from) sys_modify_ldt
	42	* for arch/i386/kernel/ldt.c
	43	* The routines copied and modified in part are:
	44	* - read_ldt
	45	* - read_default_ldt
	46	* - write_ldt
	47	* - sys_modify_ldt_skas
	48	*/
	49
	50	static int read_ldt(void __user * ptr, unsigned long bytecount)
	51	{
	52	int i, err = 0;
	53	unsigned long size;
b3ee571e	54	uml_ldt_t *ldt = &current->mm->context.arch.ldt;
858259cf	55
ba180fd4	56	if (!ldt->entry_count)
858259cf	57	goto out;
ba180fd4	58	if (bytecount > LDT_ENTRY_SIZE*LDT_ENTRIES)
858259cf BS	59	bytecount = LDT_ENTRY_SIZE*LDT_ENTRIES;
	60	err = bytecount;
	61
01ac835f	62	mutex_lock(&ldt->lock);
ba180fd4	63	if (ldt->entry_count <= LDT_DIRECT_ENTRIES) {
858259cf	64	size = LDT_ENTRY_SIZE*LDT_DIRECT_ENTRIES;
ba180fd4	65	if (size > bytecount)
858259cf	66	size = bytecount;
ba180fd4	67	if (copy_to_user(ptr, ldt->u.entries, size))
858259cf BS	68	err = -EFAULT;
	69	bytecount -= size;
	70	ptr += size;
	71	}
	72	else {
ba180fd4 JD	73	for (i=0; i<ldt->entry_count/LDT_ENTRIES_PER_PAGE && bytecount;
ba180fd4 JD	74	i++) {
858259cf	75	size = PAGE_SIZE;
ba180fd4	76	if (size > bytecount)
858259cf	77	size = bytecount;
ba180fd4	78	if (copy_to_user(ptr, ldt->u.pages[i], size)) {
858259cf BS	79	err = -EFAULT;
	80	break;
	81	}
	82	bytecount -= size;
	83	ptr += size;
	84	}
	85	}
01ac835f	86	mutex_unlock(&ldt->lock);
858259cf	87
ba180fd4	88	if (bytecount == 0 \|\| err == -EFAULT)
858259cf BS	89	goto out;
858259cf BS	90
ba180fd4	91	if (clear_user(ptr, bytecount))
858259cf BS	92	err = -EFAULT;
	93
	94	out:
	95	return err;
	96	}
	97
	98	static int read_default_ldt(void __user * ptr, unsigned long bytecount)
	99	{
	100	int err;
	101
ba180fd4	102	if (bytecount > 5*LDT_ENTRY_SIZE)
858259cf BS	103	bytecount = 5*LDT_ENTRY_SIZE;
	104
	105	err = bytecount;
ba180fd4 JD	106	/*
ba180fd4 JD	107	* UML doesn't support lcall7 and lcall27.
858259cf BS	108	* So, we don't really have a default ldt, but emulate
	109	* an empty ldt of common host default ldt size.
	110	*/
ba180fd4	111	if (clear_user(ptr, bytecount))
858259cf BS	112	err = -EFAULT;
	113
	114	return err;
	115	}
	116
	117	static int write_ldt(void __user * ptr, unsigned long bytecount, int func)
	118	{
b3ee571e	119	uml_ldt_t *ldt = &current->mm->context.arch.ldt;
6c738ffa	120	struct mm_id * mm_idp = &current->mm->context.id;
858259cf BS	121	int i, err;
	122	struct user_desc ldt_info;
	123	struct ldt_entry entry0, *ldt_p;
	124	void *addr = NULL;
	125
	126	err = -EINVAL;
ba180fd4	127	if (bytecount != sizeof(ldt_info))
858259cf BS	128	goto out;
858259cf BS	129	err = -EFAULT;
ba180fd4	130	if (copy_from_user(&ldt_info, ptr, sizeof(ldt_info)))
858259cf BS	131	goto out;
	132
	133	err = -EINVAL;
ba180fd4	134	if (ldt_info.entry_number >= LDT_ENTRIES)
858259cf	135	goto out;
ba180fd4	136	if (ldt_info.contents == 3) {
858259cf BS	137	if (func == 1)
	138	goto out;
	139	if (ldt_info.seg_not_present == 0)
	140	goto out;
	141	}
	142
d0b5e15f	143	mutex_lock(&ldt->lock);
858259cf BS	144
858259cf BS	145	err = write_ldt_entry(mm_idp, func, &ldt_info, &addr, 1);
ba180fd4	146	if (err)
858259cf	147	goto out_unlock;
ba180fd4 JD	148
	149	if (ldt_info.entry_number >= ldt->entry_count &&
	150	ldt_info.entry_number >= LDT_DIRECT_ENTRIES) {
	151	for (i=ldt->entry_count/LDT_ENTRIES_PER_PAGE;
	152	i*LDT_ENTRIES_PER_PAGE <= ldt_info.entry_number;
	153	i++) {
	154	if (i == 0)
e23181de JD	155	memcpy(&entry0, ldt->u.entries,
	156	sizeof(entry0));
	157	ldt->u.pages[i] = (struct ldt_entry *)
	158	__get_free_page(GFP_KERNEL\|__GFP_ZERO);
ba180fd4	159	if (!ldt->u.pages[i]) {
858259cf BS	160	err = -ENOMEM;
	161	/* Undo the change in host */
	162	memset(&ldt_info, 0, sizeof(ldt_info));
	163	write_ldt_entry(mm_idp, 1, &ldt_info, &addr, 1);
	164	goto out_unlock;
	165	}
ba180fd4	166	if (i == 0) {
e23181de JD	167	memcpy(ldt->u.pages[0], &entry0,
	168	sizeof(entry0));
	169	memcpy(ldt->u.pages[0]+1, ldt->u.entries+1,
858259cf BS	170	sizeof(entry0)*(LDT_DIRECT_ENTRIES-1));
	171	}
	172	ldt->entry_count = (i + 1) * LDT_ENTRIES_PER_PAGE;
	173	}
	174	}
ba180fd4	175	if (ldt->entry_count <= ldt_info.entry_number)
858259cf BS	176	ldt->entry_count = ldt_info.entry_number + 1;
858259cf BS	177
ba180fd4	178	if (ldt->entry_count <= LDT_DIRECT_ENTRIES)
e23181de	179	ldt_p = ldt->u.entries + ldt_info.entry_number;
858259cf	180	else
e23181de	181	ldt_p = ldt->u.pages[ldt_info.entry_number/LDT_ENTRIES_PER_PAGE] +
858259cf BS	182	ldt_info.entry_number%LDT_ENTRIES_PER_PAGE;
858259cf BS	183
ba180fd4 JD	184	if (ldt_info.base_addr == 0 && ldt_info.limit == 0 &&
ba180fd4 JD	185	(func == 1 \|\| LDT_empty(&ldt_info))) {
858259cf BS	186	ldt_p->a = 0;
	187	ldt_p->b = 0;
	188	}
	189	else{
	190	if (func == 1)
	191	ldt_info.useable = 0;
	192	ldt_p->a = LDT_entry_a(&ldt_info);
	193	ldt_p->b = LDT_entry_b(&ldt_info);
	194	}
	195	err = 0;
	196
	197	out_unlock:
01ac835f	198	mutex_unlock(&ldt->lock);
858259cf BS	199	out:
	200	return err;
	201	}
	202
	203	static long do_modify_ldt_skas(int func, void __user *ptr,
	204	unsigned long bytecount)
	205	{
	206	int ret = -ENOSYS;
	207
	208	switch (func) {
	209	case 0:
	210	ret = read_ldt(ptr, bytecount);
	211	break;
	212	case 1:
	213	case 0x11:
	214	ret = write_ldt(ptr, bytecount, func);
	215	break;
	216	case 2:
	217	ret = read_default_ldt(ptr, bytecount);
	218	break;
	219	}
	220	return ret;
	221	}
	222
af727902 JD	223	static DEFINE_SPINLOCK(host_ldt_lock);
	224	static short dummy_list[9] = {0, -1};
	225	static short * host_ldt_entries = NULL;
858259cf	226
af727902	227	static void ldt_get_host_info(void)
858259cf BS	228	{
858259cf BS	229	long ret;
622e6969 JD	230	struct ldt_entry * ldt;
622e6969 JD	231	short *tmp;
858259cf BS	232	int i, size, k, order;
858259cf BS	233
af727902 JD	234	spin_lock(&host_ldt_lock);
af727902 JD	235
ba180fd4	236	if (host_ldt_entries != NULL) {
af727902 JD	237	spin_unlock(&host_ldt_lock);
	238	return;
	239	}
858259cf BS	240	host_ldt_entries = dummy_list+1;
858259cf BS	241
af727902 JD	242	spin_unlock(&host_ldt_lock);
af727902 JD	243
ba180fd4 JD	244	for (i = LDT_PAGES_MAX-1, order=0; i; i>>=1, order++)
ba180fd4 JD	245	;
858259cf BS	246
	247	ldt = (struct ldt_entry *)
	248	__get_free_pages(GFP_KERNEL\|__GFP_ZERO, order);
ba180fd4 JD	249	if (ldt == NULL) {
	250	printk(KERN_ERR "ldt_get_host_info: couldn't allocate buffer "
	251	"for host ldt\n");
858259cf BS	252	return;
	253	}
	254
	255	ret = modify_ldt(0, ldt, (1<<order)*PAGE_SIZE);
ba180fd4 JD	256	if (ret < 0) {
ba180fd4 JD	257	printk(KERN_ERR "ldt_get_host_info: couldn't read host ldt\n");
858259cf BS	258	goto out_free;
858259cf BS	259	}
ba180fd4	260	if (ret == 0) {
858259cf BS	261	/* default_ldt is active, simply write an empty entry 0 */
	262	host_ldt_entries = dummy_list;
	263	goto out_free;
	264	}
	265
ba180fd4 JD	266	for (i=0, size=0; i<ret/LDT_ENTRY_SIZE; i++) {
ba180fd4 JD	267	if (ldt[i].a != 0 \|\| ldt[i].b != 0)
858259cf BS	268	size++;
	269	}
	270
ba180fd4	271	if (size < ARRAY_SIZE(dummy_list))
858259cf	272	host_ldt_entries = dummy_list;
858259cf BS	273	else {
858259cf BS	274	size = (size + 1) * sizeof(dummy_list[0]);
af727902	275	tmp = kmalloc(size, GFP_KERNEL);
ba180fd4 JD	276	if (tmp == NULL) {
	277	printk(KERN_ERR "ldt_get_host_info: couldn't allocate "
	278	"host ldt list\n");
858259cf BS	279	goto out_free;
858259cf BS	280	}
af727902	281	host_ldt_entries = tmp;
858259cf BS	282	}
858259cf BS	283
ba180fd4 JD	284	for (i=0, k=0; i<ret/LDT_ENTRY_SIZE; i++) {
ba180fd4 JD	285	if (ldt[i].a != 0 \|\| ldt[i].b != 0)
858259cf	286	host_ldt_entries[k++] = i;
858259cf BS	287	}
	288	host_ldt_entries[k] = -1;
	289
	290	out_free:
	291	free_pages((unsigned long)ldt, order);
	292	}
	293
6c738ffa	294	long init_new_ldt(struct mm_context new_mm, struct mm_context from_mm)
858259cf BS	295	{
	296	struct user_desc desc;
	297	short * num_p;
	298	int i;
	299	long page, err=0;
	300	void *addr = NULL;
	301
858259cf	302
d0b5e15f	303	mutex_init(&new_mm->arch.ldt.lock);
858259cf	304
ba180fd4	305	if (!from_mm) {
12919aa6	306	memset(&desc, 0, sizeof(desc));
858259cf	307	/*
d0b5e15f RW	308	* Now we try to retrieve info about the ldt, we
	309	* inherited from the host. All ldt-entries found
	310	* will be reset in the following loop
858259cf	311	*/
d0b5e15f RW	312	ldt_get_host_info();
	313	for (num_p=host_ldt_entries; *num_p != -1; num_p++) {
	314	desc.entry_number = *num_p;
	315	err = write_ldt_entry(&new_mm->id, 1, &desc,
	316	&addr, *(num_p + 1) == -1);
	317	if (err)
	318	break;
858259cf	319	}
b3ee571e	320	new_mm->arch.ldt.entry_count = 0;
12919aa6 BS	321
12919aa6 BS	322	goto out;
858259cf	323	}
12919aa6	324
d0b5e15f RW	325	/*
	326	* Our local LDT is used to supply the data for
	327	* modify_ldt(READLDT), if PTRACE_LDT isn't available,
	328	* i.e., we have to use the stub for modify_ldt, which
	329	* can't handle the big read buffer of up to 64kB.
	330	*/
	331	mutex_lock(&from_mm->arch.ldt.lock);
	332	if (from_mm->arch.ldt.entry_count <= LDT_DIRECT_ENTRIES)
	333	memcpy(new_mm->arch.ldt.u.entries, from_mm->arch.ldt.u.entries,
	334	sizeof(new_mm->arch.ldt.u.entries));
	335	else {
	336	i = from_mm->arch.ldt.entry_count / LDT_ENTRIES_PER_PAGE;
	337	while (i-->0) {
	338	page = __get_free_page(GFP_KERNEL\|__GFP_ZERO);
	339	if (!page) {
	340	err = -ENOMEM;
	341	break;
858259cf	342	}
d0b5e15f RW	343	new_mm->arch.ldt.u.pages[i] =
	344	(struct ldt_entry *) page;
	345	memcpy(new_mm->arch.ldt.u.pages[i],
	346	from_mm->arch.ldt.u.pages[i], PAGE_SIZE);
858259cf	347	}
858259cf	348	}
d0b5e15f RW	349	new_mm->arch.ldt.entry_count = from_mm->arch.ldt.entry_count;
d0b5e15f RW	350	mutex_unlock(&from_mm->arch.ldt.lock);
858259cf	351
12919aa6	352	out:
858259cf BS	353	return err;
	354	}
	355
	356
6c738ffa	357	void free_ldt(struct mm_context *mm)
858259cf BS	358	{
	359	int i;
	360
d0b5e15f	361	if (mm->arch.ldt.entry_count > LDT_DIRECT_ENTRIES) {
b3ee571e	362	i = mm->arch.ldt.entry_count / LDT_ENTRIES_PER_PAGE;
ba180fd4	363	while (i-- > 0)
b3ee571e	364	free_page((long) mm->arch.ldt.u.pages[i]);
858259cf	365	}
b3ee571e	366	mm->arch.ldt.entry_count = 0;
858259cf	367	}
858259cf BS	368
	369	int sys_modify_ldt(int func, void __user *ptr, unsigned long bytecount)
	370	{
6aa802ce	371	return do_modify_ldt_skas(func, ptr, bytecount);
858259cf	372	}