Merge pull request #25 from derfelot/lineage-18.1_update

VERSION = 4

PATCHLEVEL = 4

SUBLEVEL = 261

SUBLEVEL = 263

EXTRAVERSION =

NAME = Blurry Fish Butt

generic-y += clkdev.h

generic-y += cputime.h

generic-y += exec.h

generic-y += export.h

generic-y += hash.h

generic-y += irq_work.h

generic-y += mcs_spinlock.h

 * Complex access routines

 */

/* This little bit of silliness is to get the GP loaded for a function

   that ordinarily wouldn't.  Otherwise we could have it done by the macro

   directly, which can be optimized the linker.  */

#ifdef MODULE

#define __module_address(sym)		"r"(sym),

#define __module_call(ra, arg, sym)	"jsr $" #ra ",(%" #arg ")," #sym

#else

#define __module_address(sym)

#define __module_call(ra, arg, sym)	"bsr $" #ra "," #sym " !samegp"

#endif

extern void __copy_user(void);

extern inline long

__copy_tofrom_user_nocheck(void *to, const void *from, long len)

{

	register void * __cu_to __asm__("$6") = to;

	register const void * __cu_from __asm__("$7") = from;

	register long __cu_len __asm__("$0") = len;

	__asm__ __volatile__(

		__module_call(28, 3, __copy_user)

		: "=r" (__cu_len), "=r" (__cu_from), "=r" (__cu_to)

		: __module_address(__copy_user)

		  "0" (__cu_len), "1" (__cu_from), "2" (__cu_to)

		: "$1", "$2", "$3", "$4", "$5", "$28", "memory");

	return __cu_len;

}

extern long __copy_user(void *to, const void *from, long len);

#define __copy_to_user(to, from, n)			\

({							\

	__chk_user_ptr(to);				\

	__copy_tofrom_user_nocheck((__force void *)(to), (from), (n));	\

	__copy_user((__force void *)(to), (from), (n));	\

})

#define __copy_from_user(to, from, n)			\

({							\

	__chk_user_ptr(from);				\

	__copy_tofrom_user_nocheck((to), (__force void *)(from), (n));	\

	__copy_user((to), (__force void *)(from), (n));	\

})

#define __copy_to_user_inatomic __copy_to_user

copy_to_user(void __user *to, const void *from, long n)

{

	if (likely(__access_ok((unsigned long)to, n, get_fs())))

		n = __copy_tofrom_user_nocheck((__force void *)to, from, n);

		n = __copy_user((__force void *)to, from, n);

	return n;

}

extern inline long

copy_from_user(void *to, const void __user *from, long n)

{

	long res = n;

	if (likely(__access_ok((unsigned long)from, n, get_fs())))

		n = __copy_tofrom_user_nocheck(to, (__force void *)from, n);

	else

		memset(to, 0, n);

	return n;

		res = __copy_from_user_inatomic(to, from, n);

	if (unlikely(res))

		memset(to + (n - res), 0, res);

	return res;

}

extern void __do_clear_user(void);

extern inline long

__clear_user(void __user *to, long len)

{

	register void __user * __cl_to __asm__("$6") = to;

	register long __cl_len __asm__("$0") = len;

	__asm__ __volatile__(

		__module_call(28, 2, __do_clear_user)

		: "=r"(__cl_len), "=r"(__cl_to)

		: __module_address(__do_clear_user)

		  "0"(__cl_len), "1"(__cl_to)

		: "$1", "$2", "$3", "$4", "$5", "$28", "memory");

	return __cl_len;

}

extern long __clear_user(void __user *to, long len);

extern inline long

clear_user(void __user *to, long len)

	return len;

}

#undef __module_address

#undef __module_call

#define user_addr_max() \

        (segment_eq(get_fs(), USER_DS) ? TASK_SIZE : ~0UL)

obj-y    := entry.o traps.o process.o osf_sys.o irq.o \

	    irq_alpha.o signal.o setup.o ptrace.o time.o \

	    alpha_ksyms.o systbls.o err_common.o io.o

	    systbls.o err_common.o io.o

obj-$(CONFIG_VGA_HOSE)	+= console.o

obj-$(CONFIG_SMP)	+= smp.o

/*

 * linux/arch/alpha/kernel/alpha_ksyms.c

 *

 * Export the alpha-specific functions that are needed for loadable

 * modules.

 */

#include <linux/module.h>

#include <asm/console.h>

#include <asm/uaccess.h>

#include <asm/checksum.h>

#include <asm/fpu.h>

#include <asm/machvec.h>

#include <linux/syscalls.h>

/* these are C runtime functions with special calling conventions: */

extern void __divl (void);

extern void __reml (void);

extern void __divq (void);

extern void __remq (void);

extern void __divlu (void);

extern void __remlu (void);

extern void __divqu (void);

extern void __remqu (void);

EXPORT_SYMBOL(alpha_mv);

EXPORT_SYMBOL(callback_getenv);

EXPORT_SYMBOL(callback_setenv);

EXPORT_SYMBOL(callback_save_env);

/* platform dependent support */

EXPORT_SYMBOL(strcat);

EXPORT_SYMBOL(strcpy);

EXPORT_SYMBOL(strlen);

EXPORT_SYMBOL(strncpy);

EXPORT_SYMBOL(strncat);

EXPORT_SYMBOL(strchr);

EXPORT_SYMBOL(strrchr);

EXPORT_SYMBOL(memmove);

EXPORT_SYMBOL(__memcpy);

EXPORT_SYMBOL(__memset);

EXPORT_SYMBOL(___memset);

EXPORT_SYMBOL(__memsetw);

EXPORT_SYMBOL(__constant_c_memset);

EXPORT_SYMBOL(copy_page);

EXPORT_SYMBOL(clear_page);

EXPORT_SYMBOL(alpha_read_fp_reg);

EXPORT_SYMBOL(alpha_read_fp_reg_s);

EXPORT_SYMBOL(alpha_write_fp_reg);

EXPORT_SYMBOL(alpha_write_fp_reg_s);

/* Networking helper routines. */

EXPORT_SYMBOL(csum_tcpudp_magic);

EXPORT_SYMBOL(ip_compute_csum);

EXPORT_SYMBOL(ip_fast_csum);

EXPORT_SYMBOL(csum_partial_copy_nocheck);

EXPORT_SYMBOL(csum_partial_copy_from_user);

EXPORT_SYMBOL(csum_ipv6_magic);

#ifdef CONFIG_MATHEMU_MODULE

extern long (*alpha_fp_emul_imprecise)(struct pt_regs *, unsigned long);

extern long (*alpha_fp_emul) (unsigned long pc);

EXPORT_SYMBOL(alpha_fp_emul_imprecise);

EXPORT_SYMBOL(alpha_fp_emul);

#endif

/*

 * The following are specially called from the uaccess assembly stubs.

 */

EXPORT_SYMBOL(__copy_user);

EXPORT_SYMBOL(__do_clear_user);

/* 

 * SMP-specific symbols.

 */

#ifdef CONFIG_SMP

EXPORT_SYMBOL(_atomic_dec_and_lock);

#endif /* CONFIG_SMP */

/*

 * The following are special because they're not called

 * explicitly (the C compiler or assembler generates them in

 * response to division operations).  Fortunately, their

 * interface isn't gonna change any time soon now, so it's OK

 * to leave it out of version control.

 */

# undef memcpy

# undef memset

EXPORT_SYMBOL(__divl);

EXPORT_SYMBOL(__divlu);

EXPORT_SYMBOL(__divq);

EXPORT_SYMBOL(__divqu);

EXPORT_SYMBOL(__reml);

EXPORT_SYMBOL(__remlu);

EXPORT_SYMBOL(__remq);

EXPORT_SYMBOL(__remqu);

EXPORT_SYMBOL(memcpy);

EXPORT_SYMBOL(memset);

EXPORT_SYMBOL(memchr);