Release 4.10 arch/x86/kernel/ldt.c

Directory: arch/x86/kernel
/*
 * Copyright (C) 1992 Krishna Balasubramanian and Linus Torvalds
 * Copyright (C) 1999 Ingo Molnar <mingo@redhat.com>
 * Copyright (C) 2002 Andi Kleen
 *
 * This handles calls from both 32bit and 64bit mode.
 */

#include <linux/errno.h>
#include <linux/gfp.h>
#include <linux/sched.h>
#include <linux/string.h>
#include <linux/mm.h>
#include <linux/smp.h>
#include <linux/slab.h>
#include <linux/vmalloc.h>
#include <linux/uaccess.h>

#include <asm/ldt.h>
#include <asm/desc.h>
#include <asm/mmu_context.h>
#include <asm/syscalls.h>

/* context.lock is held for us, so we don't need any locking. */


static void flush_ldt(void *current_mm)
{
	mm_context_t *pc;

	if (current->active_mm != current_mm)
		return;

	pc = &current->active_mm->context;
	set_ldt(pc->ldt->entries, pc->ldt->size);
}

Contributors
Person Tokens Prop Commits CommitProp
andy lutomirski andy lutomirski 22 46.81% 1 25.00%
dave jones dave jones 21 44.68% 1 25.00%
jan beulich jan beulich 2 4.26% 1 25.00%
manfred spraul manfred spraul 2 4.26% 1 25.00%
Total 47 100.00% 4 100.00%

/* The caller must call finalize_ldt_struct on the result. LDT starts zeroed. */


static struct ldt_struct *alloc_ldt_struct(unsigned int size)
{
	struct ldt_struct *new_ldt;
	unsigned int alloc_size;

	if (size > LDT_ENTRIES)
		return NULL;

	new_ldt = kmalloc(sizeof(struct ldt_struct), GFP_KERNEL);
	if (!new_ldt)
		return NULL;

	BUILD_BUG_ON(LDT_ENTRY_SIZE != sizeof(struct desc_struct));
	alloc_size = size * LDT_ENTRY_SIZE;

	/*
         * Xen is very picky: it requires a page-aligned LDT that has no
         * trailing nonzero bytes in any page that contains LDT descriptors.
         * Keep it simple: zero the whole allocation and never allocate less
         * than PAGE_SIZE.
         */
	if (alloc_size > PAGE_SIZE)
		new_ldt->entries = vzalloc(alloc_size);
	else
		new_ldt->entries = (void *)get_zeroed_page(GFP_KERNEL);

	if (!new_ldt->entries) {
		kfree(new_ldt);
		return NULL;
	}

	new_ldt->size = size;
	return new_ldt;
}

Contributors
Person Tokens Prop Commits CommitProp
andy lutomirski andy lutomirski 73 58.87% 1 14.29%
dave jones dave jones 41 33.06% 1 14.29%
jan beulich jan beulich 6 4.84% 2 28.57%
cyrill gorcunov cyrill gorcunov 2 1.61% 1 14.29%
dan carpenter dan carpenter 1 0.81% 1 14.29%
thomas gleixner thomas gleixner 1 0.81% 1 14.29%
Total 124 100.00% 7 100.00%

/* After calling this, the LDT is immutable. */


static void finalize_ldt_struct(struct ldt_struct *ldt)
{
	paravirt_alloc_ldt(ldt->entries, ldt->size);
}

Contributors
Person Tokens Prop Commits CommitProp
andy lutomirski andy lutomirski 15 68.18% 1 25.00%
dave jones dave jones 4 18.18% 1 25.00%
jeremy fitzhardinge jeremy fitzhardinge 2 9.09% 1 25.00%
ingo molnar ingo molnar 1 4.55% 1 25.00%
Total 22 100.00% 4 100.00%

/* context.lock is held */


static void install_ldt(struct mm_struct *current_mm,
			struct ldt_struct *ldt)
{
	/* Synchronizes with lockless_dereference in load_mm_ldt. */
	smp_store_release(&current_mm->context.ldt, ldt);

	/* Activate the LDT for all CPUs using current_mm. */
	on_each_cpu_mask(mm_cpumask(current_mm), flush_ldt, current_mm, true);
}

Contributors
Person Tokens Prop Commits CommitProp
andy lutomirski andy lutomirski 29 65.91% 1 20.00%
dave jones dave jones 7 15.91% 1 20.00%
andrew morton andrew morton 5 11.36% 2 40.00%
rusty russell rusty russell 3 6.82% 1 20.00%
Total 44 100.00% 5 100.00%



static void free_ldt_struct(struct ldt_struct *ldt)
{
	if (likely(!ldt))
		return;

	paravirt_free_ldt(ldt->entries, ldt->size);
	if (ldt->size * LDT_ENTRY_SIZE > PAGE_SIZE)
		vfree_atomic(ldt->entries);
	else
		free_page((unsigned long)ldt->entries);
	kfree(ldt);
}

Contributors
Person Tokens Prop Commits CommitProp
andy lutomirski andy lutomirski 32 49.23% 1 20.00%
dave jones dave jones 21 32.31% 1 20.00%
jeremy fitzhardinge jeremy fitzhardinge 6 9.23% 1 20.00%
jan beulich jan beulich 5 7.69% 1 20.00%
andrey ryabinin andrey ryabinin 1 1.54% 1 20.00%
Total 65 100.00% 5 100.00%

/*
 * we do not have to muck with descriptors here, that is
 * done in switch_mm() as needed.
 */


int init_new_context_ldt(struct task_struct *tsk, struct mm_struct *mm)
{
	struct ldt_struct *new_ldt;
	struct mm_struct *old_mm;
	int retval = 0;

	mutex_init(&mm->context.lock);
	old_mm = current->mm;
	if (!old_mm) {
		mm->context.ldt = NULL;
		return 0;
	}

	mutex_lock(&old_mm->context.lock);
	if (!old_mm->context.ldt) {
		mm->context.ldt = NULL;
		goto out_unlock;
	}

	new_ldt = alloc_ldt_struct(old_mm->context.ldt->size);
	if (!new_ldt) {
		retval = -ENOMEM;
		goto out_unlock;
	}

	memcpy(new_ldt->entries, old_mm->context.ldt->entries,
	       new_ldt->size * LDT_ENTRY_SIZE);
	finalize_ldt_struct(new_ldt);

	mm->context.ldt = new_ldt;

out_unlock:
	mutex_unlock(&old_mm->context.lock);
	return retval;
}

Contributors
Person Tokens Prop Commits CommitProp
andy lutomirski andy lutomirski 84 48.55% 1 20.00%
dave jones dave jones 74 42.77% 1 20.00%
jeremy fitzhardinge jeremy fitzhardinge 10 5.78% 1 20.00%
luiz fernando capitulino luiz fernando capitulino 4 2.31% 1 20.00%
dave hansen dave hansen 1 0.58% 1 20.00%
Total 173 100.00% 5 100.00%

/*
 * No need to lock the MM as we are the last user
 *
 * 64bit: Don't touch the LDT register - we're already in the next thread.
 */


void destroy_context_ldt(struct mm_struct *mm)
{
	free_ldt_struct(mm->context.ldt);
	mm->context.ldt = NULL;
}

Contributors
Person Tokens Prop Commits CommitProp
dave jones dave jones 16 59.26% 1 33.33%
andy lutomirski andy lutomirski 10 37.04% 1 33.33%
dave hansen dave hansen 1 3.70% 1 33.33%
Total 27 100.00% 3 100.00%



static int read_ldt(void __user *ptr, unsigned long bytecount)
{
	int retval;
	unsigned long size;
	struct mm_struct *mm = current->mm;

	mutex_lock(&mm->context.lock);

	if (!mm->context.ldt) {
		retval = 0;
		goto out_unlock;
	}

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

	size = mm->context.ldt->size * LDT_ENTRY_SIZE;
	if (size > bytecount)
		size = bytecount;

	if (copy_to_user(ptr, mm->context.ldt->entries, size)) {
		retval = -EFAULT;
		goto out_unlock;
	}

	if (size != bytecount) {
		/* Zero-fill the rest and pretend we read bytecount bytes. */
		if (clear_user(ptr + size, bytecount - size)) {
			retval = -EFAULT;
			goto out_unlock;
		}
	}
	retval = bytecount;

out_unlock:
	mutex_unlock(&mm->context.lock);
	return retval;
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 69 39.88% 7 63.64%
andy lutomirski andy lutomirski 46 26.59% 1 9.09%
dave jones dave jones 42 24.28% 1 9.09%
jesper juhl jesper juhl 15 8.67% 1 9.09%
linus torvalds linus torvalds 1 0.58% 1 9.09%
Total 173 100.00% 11 100.00%



static int read_default_ldt(void __user *ptr, unsigned long bytecount)
{
	/* CHECKME: Can we use _one_ random number ? */
#ifdef CONFIG_X86_32
	unsigned long size = 5 * sizeof(struct desc_struct);
#else
	unsigned long size = 128;
#endif
	if (bytecount > size)
		bytecount = size;
	if (clear_user(ptr, bytecount))
		return -EFAULT;
	return bytecount;
}

Contributors
Person Tokens Prop Commits CommitProp
linus torvalds linus torvalds 42 62.69% 2 40.00%
thomas gleixner thomas gleixner 22 32.84% 1 20.00%
dave jones dave jones 2 2.99% 1 20.00%
jeremy fitzhardinge jeremy fitzhardinge 1 1.49% 1 20.00%
Total 67 100.00% 5 100.00%



static int write_ldt(void __user *ptr, unsigned long bytecount, int oldmode)
{
	struct mm_struct *mm = current->mm;
	struct ldt_struct *new_ldt, *old_ldt;
	unsigned int oldsize, newsize;
	struct user_desc ldt_info;
	struct desc_struct ldt;
	int error;

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

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

	if ((oldmode && !ldt_info.base_addr && !ldt_info.limit) ||
	    LDT_empty(&ldt_info)) {
		/* The user wants to clear the entry. */
		memset(&ldt, 0, sizeof(ldt));
	} else {
		if (!IS_ENABLED(CONFIG_X86_16BIT) && !ldt_info.seg_32bit) {
			error = -EINVAL;
			goto out;
		}

		fill_ldt(&ldt, &ldt_info);
		if (oldmode)
			ldt.avl = 0;
	}

	mutex_lock(&mm->context.lock);

	old_ldt = mm->context.ldt;
	oldsize = old_ldt ? old_ldt->size : 0;
	newsize = max(ldt_info.entry_number + 1, oldsize);

	error = -ENOMEM;
	new_ldt = alloc_ldt_struct(newsize);
	if (!new_ldt)
		goto out_unlock;

	if (old_ldt)
		memcpy(new_ldt->entries, old_ldt->entries, oldsize * LDT_ENTRY_SIZE);
	new_ldt->entries[ldt_info.entry_number] = ldt;
	finalize_ldt_struct(new_ldt);

	install_ldt(mm, new_ldt);
	free_ldt_struct(old_ldt);
	error = 0;

out_unlock:
	mutex_unlock(&mm->context.lock);
out:
	return error;
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 159 45.69% 6 37.50%
andy lutomirski andy lutomirski 108 31.03% 1 6.25%
h. peter anvin h. peter anvin 22 6.32% 1 6.25%
glauber de oliveira costa glauber de oliveira costa 21 6.03% 2 12.50%
thomas gleixner thomas gleixner 15 4.31% 1 6.25%
zachary amsden zachary amsden 11 3.16% 1 6.25%
ingo molnar ingo molnar 7 2.01% 1 6.25%
luiz fernando capitulino luiz fernando capitulino 2 0.57% 1 6.25%
dave jones dave jones 2 0.57% 1 6.25%
linus torvalds linus torvalds 1 0.29% 1 6.25%
Total 348 100.00% 16 100.00%



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

	switch (func) {
	case 0:
		ret = read_ldt(ptr, bytecount);
		break;
	case 1:
		ret = write_ldt(ptr, bytecount, 1);
		break;
	case 2:
		ret = read_default_ldt(ptr, bytecount);
		break;
	case 0x11:
		ret = write_ldt(ptr, bytecount, 0);
		break;
	}
	return ret;
}
Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 75 84.27% 5 71.43%
linus torvalds linus torvalds 14 15.73% 2 28.57%
Total 89 100.00% 7 100.00%

Overall Contributors
Person Tokens Prop Commits CommitProp
andy lutomirski andy lutomirski 427 34.86% 1 2.17%
pre-git pre-git 329 26.86% 15 32.61%
dave jones dave jones 231 18.86% 1 2.17%
linus torvalds linus torvalds 58 4.73% 2 4.35%
thomas gleixner thomas gleixner 39 3.18% 2 4.35%
h. peter anvin h. peter anvin 22 1.80% 1 2.17%
glauber de oliveira costa glauber de oliveira costa 21 1.71% 2 4.35%
jeremy fitzhardinge jeremy fitzhardinge 19 1.55% 2 4.35%
jesper juhl jesper juhl 15 1.22% 1 2.17%
jan beulich jan beulich 13 1.06% 3 6.52%
zachary amsden zachary amsden 11 0.90% 1 2.17%
ingo molnar ingo molnar 8 0.65% 2 4.35%
luiz fernando capitulino luiz fernando capitulino 6 0.49% 1 2.17%
andrew morton andrew morton 5 0.41% 2 4.35%
jaswinder singh rajput jaswinder singh rajput 4 0.33% 2 4.35%
adrian bunk adrian bunk 3 0.24% 1 2.17%
tejun heo tejun heo 3 0.24% 1 2.17%
rusty russell rusty russell 3 0.24% 1 2.17%
cyrill gorcunov cyrill gorcunov 2 0.16% 1 2.17%
dave hansen dave hansen 2 0.16% 1 2.17%
manfred spraul manfred spraul 2 0.16% 1 2.17%
andrey ryabinin andrey ryabinin 1 0.08% 1 2.17%
dan carpenter dan carpenter 1 0.08% 1 2.17%
Total 1225 100.00% 46 100.00%
Directory: arch/x86/kernel

Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
	Person	Tokens	Prop	Commits	CommitProp
andy lutomirski	andy lutomirski	22	46.81%	1	25.00%
dave jones	dave jones	21	44.68%	1	25.00%
jan beulich	jan beulich	2	4.26%	1	25.00%
manfred spraul	manfred spraul	2	4.26%	1	25.00%
	Total	47	100.00%	4	100.00%
cregit-Linux how code gets into the kernel

Release 4.10 arch/x86/kernel/ldt.c

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Overall Contributors
