1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
|
#ifndef _ASM_SEGMENT_H
#define _ASM_SEGMENT_H
#include <linux/string.h>
/*
* This is a gcc optimization barrier, which essentially
* inserts a sequence point in the gcc RTL tree that gcc
* can't move code around. This is needed when we enter
* or exit a critical region (in this case around user-level
* accesses that may sleep, and we can't let gcc optimize
* global state around them).
*/
#define __gcc_barrier() __asm__ __volatile__("": : :"memory")
/*
* Uh, these should become the main single-value transfer routines..
* They automatically use the right size if we just have the right
* pointer type..
*/
#define put_user(x,ptr) __put_user((unsigned long)(x),(ptr),sizeof(*(ptr)))
#define get_user(ptr) ((__typeof__(*(ptr)))__get_user((ptr),sizeof(*(ptr))))
/*
* This is a silly but good way to make sure that
* the __put_user function is indeed always optimized,
* and that we use the correct sizes..
*/
extern int bad_user_access_length(void);
/* I should make this use unaligned transfers etc.. */
static inline void __put_user(unsigned long x, void * y, int size)
{
__gcc_barrier();
switch (size) {
case 1:
*(char *) y = x;
break;
case 2:
*(short *) y = x;
break;
case 4:
*(int *) y = x;
break;
case 8:
*(long *) y = x;
break;
default:
bad_user_access_length();
}
__gcc_barrier();
}
/* I should make this use unaligned transfers etc.. */
static inline unsigned long __get_user(const void * y, int size)
{
unsigned long result;
__gcc_barrier();
switch (size) {
case 1:
result = *(unsigned char *) y;
break;
case 2:
result = *(unsigned short *) y;
break;
case 4:
result = *(unsigned int *) y;
break;
case 8:
result = *(unsigned long *) y;
break;
default:
result = bad_user_access_length();
}
__gcc_barrier();
return result;
}
#define get_fs_byte(addr) get_user((unsigned char *)(addr))
#define get_fs_word(addr) get_user((unsigned short *)(addr))
#define get_fs_long(addr) get_user((unsigned int *)(addr))
#define get_fs_quad(addr) get_user((unsigned long *)(addr))
#define put_fs_byte(x,addr) put_user((x),(char *)(addr))
#define put_fs_word(x,addr) put_user((x),(short *)(addr))
#define put_fs_long(x,addr) put_user((x),(int *)(addr))
#define put_fs_quad(x,addr) put_user((x),(long *)(addr))
static inline void memcpy_fromfs(void * to, const void * from, unsigned long n)
{
__gcc_barrier();
memcpy(to, from, n);
__gcc_barrier();
}
static inline void memcpy_tofs(void * to, const void * from, unsigned long n)
{
__gcc_barrier();
memcpy(to, from, n);
__gcc_barrier();
}
/*
* The fs value determines whether argument validity checking should be
* performed or not. If get_fs() == USER_DS, checking is performed, with
* get_fs() == KERNEL_DS, checking is bypassed.
*
* For historical reasons, these macros are grossly misnamed.
*/
#define KERNEL_DS 0
#define USER_DS 1
#define get_fs() (current->tss.flags & 0x1)
#define set_fs(x) (current->tss.flags = (current->tss.flags & ~0x1) | ((x) & 0x1))
static inline unsigned long get_ds(void)
{
return 0;
}
#endif /* _ASM_SEGMENT_H */
|
