[linux-2.6-block.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/syscalls.h>
#include <linux/uaccess.h>
#include <asm/unistd.h>
#include <os.h>
#include <skas.h>
#include <sysdep/tls.h>

static inline int modify_ldt (int func, void *ptr, unsigned long bytecount)
{
	return syscall(__NR_modify_ldt, func, ptr, 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;
}

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