x86/ioperm: Move iobitmap data into a struct (577d5cd7) · Commits · 戴 / test

arch/x86/include/asm/io_bitmap.h

0 → 100644

+13 −0

Original line number	Original line	Diff line number	Diff line
			/* SPDX-License-Identifier: GPL-2.0 */
			#ifndef _ASM_X86_IOBITMAP_H
			#define _ASM_X86_IOBITMAP_H

			#include <asm/processor.h>

			struct io_bitmap {
			/* The maximum number of bytes to copy so all zero bits are covered */
			unsigned int max;
			unsigned long bitmap[IO_BITMAP_LONGS];
			};

			#endif

arch/x86/include/asm/processor.h

+2 −4

Original line number	Original line	Diff line number	Diff line
	@@ -7,6 +7,7 @@
	/* Forward declaration, a strange C thing */		/* Forward declaration, a strange C thing */
	struct task_struct;		struct task_struct;
	struct mm_struct;		struct mm_struct;
			struct io_bitmap;
	struct vm86;		struct vm86;

	#include <asm/math_emu.h>		#include <asm/math_emu.h>
	@@ -501,10 +502,8 @@ struct thread_struct {
	struct vm86 *vm86;		struct vm86 *vm86;
	#endif		#endif
	/* IO permissions: */		/* IO permissions: */
	unsigned long *io_bitmap_ptr;		struct io_bitmap *io_bitmap;
	unsigned long iopl;		unsigned long iopl;
	/* Max allowed port in the bitmap, in bytes: */
	unsigned io_bitmap_max;

	mm_segment_t addr_limit;		mm_segment_t addr_limit;

	@@ -862,7 +861,6 @@ static inline void spin_lock_prefetch(const void *x)
	#define INIT_THREAD { \		#define INIT_THREAD { \
	.sp0 = TOP_OF_INIT_STACK, \		.sp0 = TOP_OF_INIT_STACK, \
	.sysenter_cs = __KERNEL_CS, \		.sysenter_cs = __KERNEL_CS, \
	.io_bitmap_ptr = NULL, \
	.addr_limit = KERNEL_DS, \		.addr_limit = KERNEL_DS, \
	}		}

arch/x86/kernel/ioport.c

+14 −13

Original line number	Original line	Diff line number	Diff line
	@@ -11,6 +11,7 @@
	#include <linux/sched.h>		#include <linux/sched.h>
	#include <linux/slab.h>		#include <linux/slab.h>

			#include <asm/io_bitmap.h>
	#include <asm/desc.h>		#include <asm/desc.h>

	/*		/*
	@@ -21,7 +22,7 @@ long ksys_ioperm(unsigned long from, unsigned long num, int turn_on)
	unsigned int i, max_long, bytes, bytes_updated;		unsigned int i, max_long, bytes, bytes_updated;
	struct thread_struct *t = &current->thread;		struct thread_struct *t = &current->thread;
	struct tss_struct *tss;		struct tss_struct *tss;
	unsigned long *bitmap;		struct io_bitmap *iobm;

	if ((from + num <= from) \|\| (from + num > IO_BITMAP_BITS))		if ((from + num <= from) \|\| (from + num > IO_BITMAP_BITS))
	return -EINVAL;		return -EINVAL;
	@@ -34,16 +35,16 @@ long ksys_ioperm(unsigned long from, unsigned long num, int turn_on)
	* IO bitmap up. ioperm() is much less timing critical than clone(),		* IO bitmap up. ioperm() is much less timing critical than clone(),
	* this is why we delay this operation until now:		* this is why we delay this operation until now:
	*/		*/
	bitmap = t->io_bitmap_ptr;		iobm = t->io_bitmap;
	if (!bitmap) {		if (!iobm) {
	/* No point to allocate a bitmap just to clear permissions */		/* No point to allocate a bitmap just to clear permissions */
	if (!turn_on)		if (!turn_on)
	return 0;		return 0;
	bitmap = kmalloc(IO_BITMAP_BYTES, GFP_KERNEL);		iobm = kmalloc(sizeof(*iobm), GFP_KERNEL);
	if (!bitmap)		if (!iobm)
	return -ENOMEM;		return -ENOMEM;

	memset(bitmap, 0xff, IO_BITMAP_BYTES);		memset(iobm->bitmap, 0xff, sizeof(iobm->bitmap));
	}		}

	/*		/*
	@@ -52,9 +53,9 @@ long ksys_ioperm(unsigned long from, unsigned long num, int turn_on)
	*/		*/
	preempt_disable();		preempt_disable();
	if (turn_on)		if (turn_on)
	bitmap_clear(bitmap, from, num);		bitmap_clear(iobm->bitmap, from, num);
	else		else
	bitmap_set(bitmap, from, num);		bitmap_set(iobm->bitmap, from, num);

	/*		/*
	* Search for a (possibly new) maximum. This is simple and stupid,		* Search for a (possibly new) maximum. This is simple and stupid,
	@@ -62,26 +63,26 @@ long ksys_ioperm(unsigned long from, unsigned long num, int turn_on)
	*/		*/
	max_long = 0;		max_long = 0;
	for (i = 0; i < IO_BITMAP_LONGS; i++) {		for (i = 0; i < IO_BITMAP_LONGS; i++) {
	if (bitmap[i] != ~0UL)		if (iobm->bitmap[i] != ~0UL)
	max_long = i;		max_long = i;
	}		}

	bytes = (max_long + 1) * sizeof(unsigned long);		bytes = (max_long + 1) * sizeof(unsigned long);
	bytes_updated = max(bytes, t->io_bitmap_max);		bytes_updated = max(bytes, t->io_bitmap->max);

	/* Update the thread data */		/* Update the thread data */
	t->io_bitmap_max = bytes;		iobm->max = bytes;
	/*		/*
	* Store the bitmap pointer (might be the same if the task already		* Store the bitmap pointer (might be the same if the task already
	* head one). Set the TIF flag, just in case this is the first		* head one). Set the TIF flag, just in case this is the first
	* invocation.		* invocation.
	*/		*/
	t->io_bitmap_ptr = bitmap;		t->io_bitmap = iobm;
	set_thread_flag(TIF_IO_BITMAP);		set_thread_flag(TIF_IO_BITMAP);

	/* Update the TSS */		/* Update the TSS */
	tss = this_cpu_ptr(&cpu_tss_rw);		tss = this_cpu_ptr(&cpu_tss_rw);
	memcpy(tss->io_bitmap.bitmap, t->io_bitmap_ptr, bytes_updated);		memcpy(tss->io_bitmap.bitmap, iobm->bitmap, bytes_updated);
	/* Store the new end of the zero bits */		/* Store the new end of the zero bits */
	tss->io_bitmap.prev_max = bytes;		tss->io_bitmap.prev_max = bytes;
	/* Make the bitmap base in the TSS valid */		/* Make the bitmap base in the TSS valid */

arch/x86/kernel/process.c

+20 −18

Original line number	Original line	Diff line number	Diff line
	@@ -41,6 +41,7 @@
	#include <asm/desc.h>		#include <asm/desc.h>
	#include <asm/prctl.h>		#include <asm/prctl.h>
	#include <asm/spec-ctrl.h>		#include <asm/spec-ctrl.h>
			#include <asm/io_bitmap.h>
	#include <asm/proto.h>		#include <asm/proto.h>

	#include "process.h"		#include "process.h"
	@@ -101,21 +102,20 @@ int arch_dup_task_struct(struct task_struct dst, struct task_struct src)
	void exit_thread(struct task_struct *tsk)		void exit_thread(struct task_struct *tsk)
	{		{
	struct thread_struct *t = &tsk->thread;		struct thread_struct *t = &tsk->thread;
	unsigned long *bp = t->io_bitmap_ptr;		struct io_bitmap *iobm = t->io_bitmap;
	struct fpu *fpu = &t->fpu;		struct fpu *fpu = &t->fpu;
	struct tss_struct *tss;		struct tss_struct *tss;

	if (bp) {		if (iobm) {
	preempt_disable();		preempt_disable();
	tss = this_cpu_ptr(&cpu_tss_rw);		tss = this_cpu_ptr(&cpu_tss_rw);

	t->io_bitmap_ptr = NULL;		t->io_bitmap = NULL;
	t->io_bitmap_max = 0;
	clear_thread_flag(TIF_IO_BITMAP);		clear_thread_flag(TIF_IO_BITMAP);
	/* Invalidate the io bitmap base in the TSS */		/* Invalidate the io bitmap base in the TSS */
	tss->x86_tss.io_bitmap_base = IO_BITMAP_OFFSET_INVALID;		tss->x86_tss.io_bitmap_base = IO_BITMAP_OFFSET_INVALID;
	preempt_enable();		preempt_enable();
	kfree(bp);		kfree(iobm);
	}		}

	free_vm86(t);		free_vm86(t);
	@@ -135,25 +135,25 @@ static int set_new_tls(struct task_struct *p, unsigned long tls)

	static inline int copy_io_bitmap(struct task_struct *tsk)		static inline int copy_io_bitmap(struct task_struct *tsk)
	{		{
			struct io_bitmap *iobm = current->thread.io_bitmap;

	if (likely(!test_tsk_thread_flag(current, TIF_IO_BITMAP)))		if (likely(!test_tsk_thread_flag(current, TIF_IO_BITMAP)))
	return 0;		return 0;

	tsk->thread.io_bitmap_ptr = kmemdup(current->thread.io_bitmap_ptr,		tsk->thread.io_bitmap = kmemdup(iobm, sizeof(*iobm), GFP_KERNEL);
	IO_BITMAP_BYTES, GFP_KERNEL);
	if (!tsk->thread.io_bitmap_ptr) {		if (!tsk->thread.io_bitmap)
	tsk->thread.io_bitmap_max = 0;
	return -ENOMEM;		return -ENOMEM;
	}
	set_tsk_thread_flag(tsk, TIF_IO_BITMAP);		set_tsk_thread_flag(tsk, TIF_IO_BITMAP);
	return 0;		return 0;
	}		}

	static inline void free_io_bitmap(struct task_struct *tsk)		static inline void free_io_bitmap(struct task_struct *tsk)
	{		{
	if (tsk->thread.io_bitmap_ptr) {		if (tsk->thread.io_bitmap) {
	kfree(tsk->thread.io_bitmap_ptr);		kfree(tsk->thread.io_bitmap);
	tsk->thread.io_bitmap_ptr = NULL;		tsk->thread.io_bitmap = NULL;
	tsk->thread.io_bitmap_max = 0;
	}		}
	}		}

	@@ -172,7 +172,7 @@ int copy_thread_tls(unsigned long clone_flags, unsigned long sp,
	frame->bp = 0;		frame->bp = 0;
	frame->ret_addr = (unsigned long) ret_from_fork;		frame->ret_addr = (unsigned long) ret_from_fork;
	p->thread.sp = (unsigned long) fork_frame;		p->thread.sp = (unsigned long) fork_frame;
	p->thread.io_bitmap_ptr = NULL;		p->thread.io_bitmap = NULL;
	memset(p->thread.ptrace_bps, 0, sizeof(p->thread.ptrace_bps));		memset(p->thread.ptrace_bps, 0, sizeof(p->thread.ptrace_bps));

	#ifdef CONFIG_X86_64		#ifdef CONFIG_X86_64
	@@ -366,6 +366,8 @@ static inline void switch_to_bitmap(struct thread_struct *next,
	struct tss_struct *tss = this_cpu_ptr(&cpu_tss_rw);		struct tss_struct *tss = this_cpu_ptr(&cpu_tss_rw);

	if (tifn & _TIF_IO_BITMAP) {		if (tifn & _TIF_IO_BITMAP) {
			struct io_bitmap *iobm = next->io_bitmap;

	/*		/*
	* Copy at least the size of the incoming tasks bitmap		* Copy at least the size of the incoming tasks bitmap
	* which covers the last permitted I/O port.		* which covers the last permitted I/O port.
	@@ -374,11 +376,11 @@ static inline void switch_to_bitmap(struct thread_struct *next,
	* bits permitted, then the copy needs to cover those as		* bits permitted, then the copy needs to cover those as
	* well so they get turned off.		* well so they get turned off.
	*/		*/
	memcpy(tss->io_bitmap.bitmap, next->io_bitmap_ptr,		memcpy(tss->io_bitmap.bitmap, next->io_bitmap->bitmap,
	max(tss->io_bitmap.prev_max, next->io_bitmap_max));		max(tss->io_bitmap.prev_max, next->io_bitmap->max));

	/* Store the new max and set io_bitmap_base valid */		/* Store the new max and set io_bitmap_base valid */
	tss->io_bitmap.prev_max = next->io_bitmap_max;		tss->io_bitmap.prev_max = next->io_bitmap->max;
	tss->x86_tss.io_bitmap_base = IO_BITMAP_OFFSET_VALID;		tss->x86_tss.io_bitmap_base = IO_BITMAP_OFFSET_VALID;

	/*		/*

arch/x86/kernel/ptrace.c

+8 −4

Original line number	Original line	Diff line number	Diff line
	@@ -42,6 +42,7 @@
	#include <asm/traps.h>		#include <asm/traps.h>
	#include <asm/syscall.h>		#include <asm/syscall.h>
	#include <asm/fsgsbase.h>		#include <asm/fsgsbase.h>
			#include <asm/io_bitmap.h>

	#include "tls.h"		#include "tls.h"

	@@ -697,7 +698,9 @@ static int ptrace_set_debugreg(struct task_struct *tsk, int n,
	static int ioperm_active(struct task_struct *target,		static int ioperm_active(struct task_struct *target,
	const struct user_regset *regset)		const struct user_regset *regset)
	{		{
	return DIV_ROUND_UP(target->thread.io_bitmap_max, regset->size);		struct io_bitmap *iobm = target->thread.io_bitmap;

			return iobm ? DIV_ROUND_UP(iobm->max, regset->size) : 0;
	}		}

	static int ioperm_get(struct task_struct *target,		static int ioperm_get(struct task_struct *target,
	@@ -705,12 +708,13 @@ static int ioperm_get(struct task_struct *target,
	unsigned int pos, unsigned int count,		unsigned int pos, unsigned int count,
	void kbuf, void __user ubuf)		void kbuf, void __user ubuf)
	{		{
	if (!target->thread.io_bitmap_ptr)		struct io_bitmap *iobm = target->thread.io_bitmap;

			if (!iobm)
	return -ENXIO;		return -ENXIO;

	return user_regset_copyout(&pos, &count, &kbuf, &ubuf,		return user_regset_copyout(&pos, &count, &kbuf, &ubuf,
	target->thread.io_bitmap_ptr,		iobm->bitmap, 0, IO_BITMAP_BYTES);
	0, IO_BITMAP_BYTES);
	}		}

	/*		/*

Admin message