Loading...
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 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 | #ifndef __PARISC_UACCESS_H #define __PARISC_UACCESS_H /* * User space memory access functions */ #include <linux/sched.h> #include <asm/page.h> #include <asm/system.h> #include <asm/cache.h> #define VERIFY_READ 0 #define VERIFY_WRITE 1 #define KERNEL_DS ((mm_segment_t){0}) #define USER_DS ((mm_segment_t){1}) #define segment_eq(a,b) ((a).seg == (b).seg) #define get_ds() (KERNEL_DS) #define get_fs() (current->addr_limit) #define set_fs(x) (current->addr_limit = (x)) /* * Note that since kernel addresses are in a separate address space on * parisc, we don't need to do anything for access_ok() or verify_area(). * We just let the page fault handler do the right thing. This also means * that put_user is the same as __put_user, etc. */ #define access_ok(type,addr,size) (1) #define verify_area(type,addr,size) (0) #define put_user __put_user #define get_user __get_user /* * The exception table contains two values: the first is an address * for an instruction that is allowed to fault, and the second is * the number of bytes to skip if a fault occurs. We also support in * two bit flags: 0x2 tells the exception handler to clear register * r9 and 0x1 tells the exception handler to put -EFAULT in r8. * This allows us to handle the simple cases for put_user and * get_user without having to have .fixup sections. */ struct exception_table_entry { unsigned long addr; /* address of insn that is allowed to fault. */ int skip; /* pcoq skip | r9 clear flag | r8 -EFAULT flag */ }; extern const struct exception_table_entry *search_exception_table(unsigned long addr); #define __get_user(x,ptr) \ ({ \ register long __gu_err __asm__ ("r8") = 0; \ register long __gu_val __asm__ ("r9") = 0; \ \ if (segment_eq(get_fs(),KERNEL_DS)) { \ switch (sizeof(*(ptr))) { \ case 1: __get_kernel_asm("ldb",ptr); break; \ case 2: __get_kernel_asm("ldh",ptr); break; \ case 4: __get_kernel_asm("ldw",ptr); break; \ case 8: __get_kernel_asm("ldd",ptr); break; \ default: BUG(); break; \ } \ } \ else { \ switch (sizeof(*(ptr))) { \ case 1: __get_user_asm("ldb",ptr); break; \ case 2: __get_user_asm("ldh",ptr); break; \ case 4: __get_user_asm("ldw",ptr); break; \ case 8: __get_user_asm("ldd",ptr); break; \ default: BUG(); break; \ } \ } \ \ (x) = (__typeof__(*(ptr))) __gu_val; \ __gu_err; \ }) #define __get_kernel_asm(ldx,ptr) \ __asm__("\n1:\t" ldx "\t0(%2),%0\n" \ "2:\n" \ "\t.section __ex_table,\"a\"\n" \ "\t.word\t1b\n" \ "\t.word\t(2b-1b)+3\n" \ "\t.previous" \ : "=r"(__gu_val), "=r"(__gu_err) \ : "r"(ptr), "1"(__gu_err)); #define __get_user_asm(ldx,ptr) \ __asm__("\n1:\t" ldx "\t0(%%sr3,%2),%0\n" \ "2:\n" \ "\t.section __ex_table,\"a\"\n" \ "\t.word\t1b\n" \ "\t.word\t(2b-1b)+3\n" \ "\t.previous" \ : "=r"(__gu_val), "=r"(__gu_err) \ : "r"(ptr), "1"(__gu_err)); #define __put_user(x,ptr) \ ({ \ register long __pu_err __asm__ ("r8") = 0; \ \ if (segment_eq(get_fs(),KERNEL_DS)) { \ switch (sizeof(*(ptr))) { \ case 1: __put_kernel_asm("stb",x,ptr); break; \ case 2: __put_kernel_asm("sth",x,ptr); break; \ case 4: __put_kernel_asm("stw",x,ptr); break; \ case 8: __put_kernel_asm("std",x,ptr); break; \ default: BUG(); break; \ } \ } \ else { \ switch (sizeof(*(ptr))) { \ case 1: __put_user_asm("stb",x,ptr); break; \ case 2: __put_user_asm("sth",x,ptr); break; \ case 4: __put_user_asm("stw",x,ptr); break; \ case 8: __put_user_asm("std",x,ptr); break; \ default: BUG(); break; \ } \ } \ \ __pu_err; \ }) /* * The "__put_user/kernel_asm()" macros tell gcc they read from memory * instead of writing. This is because they do not write to any memory * gcc knows about, so there are no aliasing issues. */ #define __put_kernel_asm(stx,x,ptr) \ __asm__ __volatile__ ( \ "\n1:\t" stx "\t%2,0(%1)\n" \ "2:\n" \ "\t.section __ex_table,\"a\"\n" \ "\t.word\t1b\n" \ "\t.word\t(2b-1b)+1\n" \ "\t.previous" \ : "=r"(__pu_err) \ : "r"(ptr), "r"(x), "0"(__pu_err)) #define __put_user_asm(stx,x,ptr) \ __asm__ __volatile__ ( \ "\n1:\t" stx "\t%2,0(%%sr3,%1)\n" \ "2:\n" \ "\t.section __ex_table,\"a\"\n" \ "\t.word\t1b\n" \ "\t.word\t(2b-1b)+1\n" \ "\t.previous" \ : "=r"(__pu_err) \ : "r"(ptr), "r"(x), "0"(__pu_err)) /* * Complex access routines -- external declarations */ extern unsigned long lcopy_to_user(void *, const void *, unsigned long); extern unsigned long lcopy_from_user(void *, const void *, unsigned long); extern long lstrncpy_from_user(char *, const char *, long); extern unsigned lclear_user(void *,unsigned long); extern long lstrnlen_user(const char *,long); /* * Complex access routines -- macros */ #define strncpy_from_user lstrncpy_from_user #define strnlen_user lstrnlen_user #define strlen_user(str) lstrnlen_user(str, 0x7fffffffL) #define clear_user lclear_user #define copy_from_user lcopy_from_user #define __copy_from_user lcopy_from_user #define copy_to_user lcopy_to_user #define __copy_to_user lcopy_to_user #define copy_to_user_ret(to,from,n,retval) \ ({ if (lcopy_to_user(to,from,n)) return retval; }) #define copy_from_user_ret(to,from,n,retval) \ ({ if (lcopy_from_user(to,from,n)) return retval; }) #endif /* __PARISC_UACCESS_H */ |