Subversion Repositories or1k_old

#ifndef __ASM_ARM_SEGMENT_H
#define __ASM_ARM_SEGMENT_H
 
#define KERNEL_CS   0x0
#define KERNEL_DS   0x0
 
#define USER_CS     0x1
#define USER_DS     0x1
 
#ifndef __ASSEMBLY__
 
#ifdef NO_INLINE
#define __INLINE__
#else
#define __INLINE__ inline
#endif
 
#include <linux/sched.h>
 
/*
 * A better way to do this might be to pass to put/get user a flag
 * indicating the possibility of kernel memory accesses...  That
 * would allow gcc to optimize the following routines a bit better
 * than that which is possible at the moment.
 */
#define IS_USER_SEG (current->tss.fs != KERNEL_DS)
 
/*
 * 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);
 
#ifdef __KERNEL__
 
#include <asm/proc/segment.h>
 
/*
 * these are depreciated..
 */
static __INLINE__ unsigned char get_user_byte(const char *addr)
{
	return __get_user(addr, 1);
}
 
#define get_fs_byte(addr) get_user_byte((char *)(addr))
 
static __INLINE__ unsigned short get_user_word(const short *addr)
{
	return __get_user(addr, 2);
}
 
#define get_fs_word(addr) get_user_word((short *)(addr))
 
static __INLINE__ unsigned long get_user_long(const long *addr)
{
	return __get_user(addr, 4);
}
 
#define get_fs_long(addr) get_user_long((long *)(addr))
 
static __INLINE__ void put_user_byte(char val,char *addr)
{
	__put_user(val, addr, 1);
}
 
#define put_fs_byte(x,addr) put_user_byte((x),(char *)(addr))
 
static __INLINE__ void put_user_word(short val,short *addr)
{
	__put_user(val, addr, 2);
}
 
#define put_fs_word(x,addr) put_user_word((x),(short *)(addr))
 
static __INLINE__ void put_user_long(long val,long *addr)
{
	__put_user(val, addr, 4);
}
 
#define put_fs_long(x,addr) put_user_long((x),(long *)(addr))
 
 
extern void memcpy_fromfs(void * to, const void * from, unsigned long n);
extern void __memcpy_tofs(void * to, const void * from, unsigned long n);
static __INLINE__ void memcpy_tofs(void *to, const void *from, unsigned long n)
{
	if(IS_USER_SEG)
		__memcpy_tofs(to, from, n);
	else
		memcpy(to, from, n);
}
 
static inline unsigned long get_fs(void)
{
	return current->tss.fs;
}
 
static inline unsigned long get_ds(void)
{
	return KERNEL_DS;
}
 
static inline void set_fs(unsigned long val)
{
	current->tss.fs = val;
}
 
#endif /* __KERNEL__ */
 
#endif /* __ASSEMBLY__ */
 
#endif /* __ASM_ARM_SEGMENT_H */