aboutsummaryrefslogtreecommitdiffstats
path: root/arch/i386/kernel/ioport.c
diff options
context:
space:
mode:
authorLinus Torvalds <torvalds@ppc970.osdl.org>2005-04-16 18:20:36 -0400
committerLinus Torvalds <torvalds@ppc970.osdl.org>2005-04-16 18:20:36 -0400
commit1da177e4c3f41524e886b7f1b8a0c1fc7321cac2 (patch)
tree0bba044c4ce775e45a88a51686b5d9f90697ea9d /arch/i386/kernel/ioport.c
Linux-2.6.12-rc2v2.6.12-rc2
Initial git repository build. I'm not bothering with the full history, even though we have it. We can create a separate "historical" git archive of that later if we want to, and in the meantime it's about 3.2GB when imported into git - space that would just make the early git days unnecessarily complicated, when we don't have a lot of good infrastructure for it. Let it rip!
Diffstat (limited to 'arch/i386/kernel/ioport.c')
-rw-r--r--arch/i386/kernel/ioport.c147
1 files changed, 147 insertions, 0 deletions
diff --git a/arch/i386/kernel/ioport.c b/arch/i386/kernel/ioport.c
new file mode 100644
index 000000000000..8b25160393c1
--- /dev/null
+++ b/arch/i386/kernel/ioport.c
@@ -0,0 +1,147 @@
1/*
2 * linux/arch/i386/kernel/ioport.c
3 *
4 * This contains the io-permission bitmap code - written by obz, with changes
5 * by Linus.
6 */
7
8#include <linux/sched.h>
9#include <linux/kernel.h>
10#include <linux/errno.h>
11#include <linux/types.h>
12#include <linux/ioport.h>
13#include <linux/smp.h>
14#include <linux/smp_lock.h>
15#include <linux/stddef.h>
16#include <linux/slab.h>
17#include <linux/thread_info.h>
18
19/* Set EXTENT bits starting at BASE in BITMAP to value TURN_ON. */
20static void set_bitmap(unsigned long *bitmap, unsigned int base, unsigned int extent, int new_value)
21{
22 unsigned long mask;
23 unsigned long *bitmap_base = bitmap + (base / BITS_PER_LONG);
24 unsigned int low_index = base & (BITS_PER_LONG-1);
25 int length = low_index + extent;
26
27 if (low_index != 0) {
28 mask = (~0UL << low_index);
29 if (length < BITS_PER_LONG)
30 mask &= ~(~0UL << length);
31 if (new_value)
32 *bitmap_base++ |= mask;
33 else
34 *bitmap_base++ &= ~mask;
35 length -= BITS_PER_LONG;
36 }
37
38 mask = (new_value ? ~0UL : 0UL);
39 while (length >= BITS_PER_LONG) {
40 *bitmap_base++ = mask;
41 length -= BITS_PER_LONG;
42 }
43
44 if (length > 0) {
45 mask = ~(~0UL << length);
46 if (new_value)
47 *bitmap_base++ |= mask;
48 else
49 *bitmap_base++ &= ~mask;
50 }
51}
52
53
54/*
55 * this changes the io permissions bitmap in the current task.
56 */
57asmlinkage long sys_ioperm(unsigned long from, unsigned long num, int turn_on)
58{
59 unsigned long i, max_long, bytes, bytes_updated;
60 struct thread_struct * t = &current->thread;
61 struct tss_struct * tss;
62 unsigned long *bitmap;
63
64 if ((from + num <= from) || (from + num > IO_BITMAP_BITS))
65 return -EINVAL;
66 if (turn_on && !capable(CAP_SYS_RAWIO))
67 return -EPERM;
68
69 /*
70 * If it's the first ioperm() call in this thread's lifetime, set the
71 * IO bitmap up. ioperm() is much less timing critical than clone(),
72 * this is why we delay this operation until now:
73 */
74 if (!t->io_bitmap_ptr) {
75 bitmap = kmalloc(IO_BITMAP_BYTES, GFP_KERNEL);
76 if (!bitmap)
77 return -ENOMEM;
78
79 memset(bitmap, 0xff, IO_BITMAP_BYTES);
80 t->io_bitmap_ptr = bitmap;
81 }
82
83 /*
84 * do it in the per-thread copy and in the TSS ...
85 *
86 * Disable preemption via get_cpu() - we must not switch away
87 * because the ->io_bitmap_max value must match the bitmap
88 * contents:
89 */
90 tss = &per_cpu(init_tss, get_cpu());
91
92 set_bitmap(t->io_bitmap_ptr, from, num, !turn_on);
93
94 /*
95 * Search for a (possibly new) maximum. This is simple and stupid,
96 * to keep it obviously correct:
97 */
98 max_long = 0;
99 for (i = 0; i < IO_BITMAP_LONGS; i++)
100 if (t->io_bitmap_ptr[i] != ~0UL)
101 max_long = i;
102
103 bytes = (max_long + 1) * sizeof(long);
104 bytes_updated = max(bytes, t->io_bitmap_max);
105
106 t->io_bitmap_max = bytes;
107
108 /*
109 * Sets the lazy trigger so that the next I/O operation will
110 * reload the correct bitmap.
111 */
112 tss->io_bitmap_base = INVALID_IO_BITMAP_OFFSET_LAZY;
113
114 put_cpu();
115
116 return 0;
117}
118
119/*
120 * sys_iopl has to be used when you want to access the IO ports
121 * beyond the 0x3ff range: to get the full 65536 ports bitmapped
122 * you'd need 8kB of bitmaps/process, which is a bit excessive.
123 *
124 * Here we just change the eflags value on the stack: we allow
125 * only the super-user to do it. This depends on the stack-layout
126 * on system-call entry - see also fork() and the signal handling
127 * code.
128 */
129
130asmlinkage long sys_iopl(unsigned long unused)
131{
132 volatile struct pt_regs * regs = (struct pt_regs *) &unused;
133 unsigned int level = regs->ebx;
134 unsigned int old = (regs->eflags >> 12) & 3;
135
136 if (level > 3)
137 return -EINVAL;
138 /* Trying to gain more privileges? */
139 if (level > old) {
140 if (!capable(CAP_SYS_RAWIO))
141 return -EPERM;
142 }
143 regs->eflags = (regs->eflags &~ 0x3000UL) | (level << 12);
144 /* Make sure we return the long way (not sysenter) */
145 set_thread_flag(TIF_IRET);
146 return 0;
147}