From beb116954b9b7f3bb56412b2494b562f02b864b1 Mon Sep 17 00:00:00 2001 From: Ralf Baechle Date: Tue, 7 Jan 1997 02:33:00 +0000 Subject: Import of Linux/MIPS 2.1.14 --- include/asm-mips/uaccess.h | 314 +++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 314 insertions(+) create mode 100644 include/asm-mips/uaccess.h (limited to 'include/asm-mips/uaccess.h') diff --git a/include/asm-mips/uaccess.h b/include/asm-mips/uaccess.h new file mode 100644 index 000000000..48a205077 --- /dev/null +++ b/include/asm-mips/uaccess.h @@ -0,0 +1,314 @@ +/* + * include/asm-mips/uaccess.h + * + * This file is subject to the terms and conditions of the GNU General Public + * License. See the file "COPYING" in the main directory of this archive + * for more details. + * + * Copyright (C) 1996 by Ralf Baechle + */ +#ifndef __ASM_MIPS_UACCESS_H +#define __ASM_MIPS_UACCESS_H + +#include +#include +#include + +#define STR(x) __STR(x) +#define __STR(x) #x + +/* + * 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 VERIFY_READ 0 +#define VERIFY_WRITE 1 + +#define get_fs() (current->tss.segment) +#define set_fs(x) (current->tss.segment=(x)) + +static inline unsigned long get_ds(void) +{ + return KERNEL_DS; +} + +/* + * Is a address valid? This does a straighforward calculation rather + * than tests. + * + * Address valid if: + * - "addr" doesn't have any high-bits set + * - AND "size" doesn't have any high-bits set + * - AND "addr+size" doesn't have any high-bits set + * - OR we are in kernel mode. + */ +#define __access_ok(addr,size,mask) \ + (((__signed__ long)((mask)&(addr | size | (addr+size)))) >= 0) +#define __access_mask (-(long)get_fs()) + +#define access_ok(type,addr,size) \ +__access_ok(((unsigned long)(addr)),(size),__access_mask) + +extern inline int verify_area(int type, const void * addr, unsigned long size) +{ + return access_ok(type,addr,size) ? 0 : -EFAULT; +} + +/* + * Uh, these should become the main single-value transfer routines ... + * They automatically use the right size if we just have the right + * pointer type ... + * + * As MIPS uses the same address space for kernel and user data, we + * can just do these as direct assignments. + * + * Careful to not + * (a) re-use the arguments for side effects (sizeof is ok) + * (b) require any knowledge of processes at this stage + */ +#define put_user(x,ptr) __put_user_check((x),(ptr),sizeof(*(ptr)),__access_mask) +#define get_user(x,ptr) __get_user_check((x),(ptr),sizeof(*(ptr)),__access_mask) + +/* + * The "__xxx" versions do not do address space checking, useful when + * doing multiple accesses to the same area (the user has to do the + * checks by hand with "access_ok()") + */ +#define __put_user(x,ptr) __put_user_nocheck((x),(ptr),sizeof(*(ptr))) +#define __get_user(x,ptr) __get_user_nocheck((x),(ptr),sizeof(*(ptr))) + +struct __large_struct { unsigned long buf[100]; }; +#define __m(x) (*(struct __large_struct *)(x)) + +#define copy_to_user(to,from,n) __copy_tofrom_user((to),(from),(n),__cu_to) +#define copy_from_user(to,from,n) __copy_tofrom_user((to),(from),(n),__cu_from) + +extern size_t __copy_user(void *__to, const void *__from, size_t __n); + +#define __copy_tofrom_user(to,from,n,v) ({ \ + void * __cu_to; \ + const void * __cu_from; \ + long __cu_len; \ + \ + __cu_to = (to); \ + __cu_from = (from); \ + __cu_len = (n); \ + if (__access_ok(((unsigned long)(v)),__cu_len,__access_mask)) \ + __cu_len = __copy_user(__cu_to, __cu_from, __cu_len); \ + __cu_len; \ +}) + +#define __get_user_nocheck(x,ptr,size) ({ \ +long __gu_err; \ +long __gu_val; \ +long __gu_addr; \ +__asm__("":"=r" (__gu_val)); \ +__gu_addr = (long) (ptr); \ +__gu_err = 0; \ +switch (size) { \ +case 1: __get_user_nocheck_asm("lb"); break; \ +case 2: __get_user_nocheck_asm("lh"); break; \ +case 4: __get_user_nocheck_asm("lw"); break; \ +case 8: __get_user_nocheck_asm("ld"); break; \ +default: __get_user_unknown(); break; \ +} x = (__typeof__(*(ptr))) __gu_val; __gu_err; }) + +#define __get_user_nocheck_asm(insn) \ +({ \ +__asm__ __volatile__( \ + "1:\t" insn "\t%1,%3\n" \ + "2:\n\t" \ + ".section\t.fixup,\"ax\"\n" \ + "3:\t.set\tnoat\n\t" \ + "la\t$1,2b\n\t" \ + "li\t%0,%4\n\t" \ + "jr\t$1\n\t" \ + ".set\tat\n\t" \ + ".section\t__ex_table,\"a\"\n\t" \ + STR(PTR)"\t1b,3b\n\t" \ + ".text" \ + :"=r" (__gu_err), "=r" (__gu_val) \ + :"0" (__gu_err), "o" (__m(__gu_addr)), "i" (-EFAULT) \ + :"$1"); }) + +#define __get_user_check(x,ptr,size,mask) ({ \ +long __gu_err; \ +long __gu_val; \ +long __gu_addr; \ +__asm__("":"=r" (__gu_val)); \ +__gu_addr = (long) (ptr); \ +__gu_err = -EFAULT; \ +if (__access_ok(__gu_addr,size,mask)) { \ +switch (size) { \ +case 1: __get_user_check_asm("lb"); break; \ +case 2: __get_user_check_asm("lh"); break; \ +case 4: __get_user_check_asm("lw"); break; \ +case 8: __get_user_check_asm("ld"); break; \ +default: __get_user_unknown(); break; \ +} } x = (__typeof__(*(ptr))) __gu_val; __gu_err; }) + +#define __get_user_check_asm(insn) \ +({ \ +__asm__ __volatile__( \ + "1:\t" insn "\t%1,%2\n\t" \ + "move\t%0,$0\n" \ + "2:\n\t" \ + ".section\t.fixup,\"ax\"\n" \ + "3:\t.set\tnoat\n\t" \ + "la\t$1,2b\n\t" \ + "jr\t$1\n\t" \ + ".set\tat\n\t" \ + ".section\t__ex_table,\"a\"\n\t" \ + STR(PTR)"\t1b,3b\n\t" \ + ".text" \ + :"=r" (__gu_err), "=r" (__gu_val) \ + :"o" (__m(__gu_addr)) \ + :"$1"); }) + +extern void __get_user_unknown(void); + +#define __put_user_nocheck(x,ptr,size) ({ \ +long __pu_err; \ +__typeof__(*(ptr)) __pu_val; \ +long __pu_addr; \ +__pu_val = (x); \ +__pu_addr = (long) (ptr); \ +__pu_err = 0; \ +switch (size) { \ +case 1: __put_user_nocheck_asm("sb"); break; \ +case 2: __put_user_nocheck_asm("sh"); break; \ +case 4: __put_user_nocheck_asm("sw"); break; \ +case 8: __put_user_nocheck_asm("sd"); break; \ +default: __put_user_unknown(); break; \ +} __pu_err; }) + +#define __put_user_nocheck_asm(insn) \ +({ \ +__asm__ __volatile__( \ + "1:\t" insn "\t%1,%2\n" \ + "2:\n\t" \ + ".section\t.fixup,\"ax\"\n" \ + "3:\t.set\tnoat\n\t" \ + "la\t$1,2b\n\t" \ + "li\t%0,%3\n\t" \ + "jr\t$1\n\t" \ + ".set\tat\n\t" \ + ".section\t__ex_table,\"a\"\n\t" \ + STR(PTR)"\t1b,3b\n\t" \ + ".text" \ + :"=r" (__pu_err) \ + :"r" (__pu_val), "o" (__m(__pu_addr)), "i" (-EFAULT) \ + :"$1"); }) + +#define __put_user_check(x,ptr,size,mask) ({ \ +long __pu_err; \ +__typeof__(*(ptr)) __pu_val; \ +long __pu_addr; \ +__pu_val = (x); \ +__pu_addr = (long) (ptr); \ +__pu_err = -EFAULT; \ +if (__access_ok(__pu_addr,size,mask)) { \ +switch (size) { \ +case 1: __put_user_check_asm("sb"); break; \ +case 2: __put_user_check_asm("sh"); break; \ +case 4: __put_user_check_asm("sw"); break; \ +case 8: __put_user_check_asm("sd"); break; \ +default: __put_user_unknown(); break; \ +} } __pu_err; }) + +#define __put_user_check_asm(insn) \ +({ \ +__asm__ __volatile__( \ + "1:\t" insn "\t%1,%2\n\t" \ + "move\t%0,$0\n" \ + "2:\n\t" \ + ".section\t.fixup,\"ax\"\n" \ + "3:\t.set\tnoat\n\t" \ + "la\t$1,2b\n\t" \ + "jr\t$1\n\t" \ + ".set\tat\n\t" \ + ".section\t__ex_table,\"a\"\n\t" \ + STR(PTR)"\t1b,3b\n\t" \ + ".text" \ + :"=r" (__pu_err) \ + :"r" (__pu_val), "o" (__m(__pu_addr)) \ + :"$1"); }) + +extern void __put_user_unknown(void); + +#define __clear_user(addr,size) \ +({ \ + void *__cu_end; \ + __asm__ __volatile__( \ + ".set\tnoreorder\n\t" \ + "1:\tsb\t$0,(%0)\n\t" \ + "bne\t%0,%1,1b\n\t" \ + "addiu\t%0,1\n" \ + "2:\t.set\treorder\n\t" \ + ".section\t.fixup,\"ax\"\n" \ + "3:\t.set\tnoat\n\t" \ + "la\t$1,2b\n\t" \ + "jr\t$1\n\t" \ + ".set\tat\n\t" \ + ".section\t__ex_table,\"a\"\n\t" \ + STR(PTR)"\t1b,3b\n\t" \ + ".text" \ + :"=r" (addr), "=r" (__cu_end) \ + :"0" (addr), "1" (addr + size - 1), "i" (-EFAULT) \ + :"$1","memory"); \ + size = __cu_end - (addr) - 1; \ +}) + +#define clear_user(addr,n) ({ \ +void * __cl_addr = (addr); \ +unsigned long __cl_size = (n); \ +if (__cl_size && __access_ok(VERIFY_WRITE, ((unsigned long)(__cl_addr)), __cl_size)) \ +__clear_user(__cl_addr, __cl_size); \ +__cl_size; }) + +/* + * Returns: -EFAULT if exception before terminator, N if the entire + * buffer filled, else strlen. + */ +extern long __strncpy_from_user(char *__to, const char *__from, long __to_len); + +#define strncpy_from_user(dest,src,count) ({ \ + const void * __sc_src = (src); \ + long __sc_res = -EFAULT; \ + if (access_ok(VERIFY_READ, __sc_src, 0)) { \ + __sc_res = __strncpy_from_user(dest, __sc_src, count); \ +} __sc_res; }) + +/* Returns: 0 if bad, string length+1 (memory size) of string if ok */ +extern long __strlen_user(const char *); + +extern inline long strlen_user(const char *str) +{ + long len = __strlen_user(str); + if (!access_ok(VERIFY_READ, str, len)) + len = 0; + return len; +} + +struct exception_table_entry +{ + unsigned long insn; + unsigned long nextinsn; +}; + +/* Returns 0 if exception not found and fixup.unit otherwise. */ +extern unsigned long search_exception_table(unsigned long addr); + +/* Returns the new pc */ +#define fixup_exception(map_reg, fixup_unit, pc) \ +({ \ + fixup_unit; \ +}) + +#endif /* __ASM_MIPS_UACCESS_H */ -- cgit v1.2.3