/*

 * CDDL HEADER START

 *

 * The contents of this file are subject to the terms of the

 * Common Development and Distribution License, Version 1.0 only

 * (the "License").  You may not use this file except in compliance

 * with the License.

 *

 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE

 * or http://www.opensolaris.org/os/licensing.

 * See the License for the specific language governing permissions

 * and limitations under the License.

 *

 * When distributing Covered Code, include this CDDL HEADER in each

 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.

 * If applicable, add the following below this CDDL HEADER, with the

 * fields enclosed by brackets "[]" replaced with your own identifying

 * information: Portions Copyright [yyyy] [name of copyright owner]

 *

 * CDDL HEADER END

 */

/*

 * Copyright 2005 Sun Microsystems, Inc.  All rights reserved.

 * Use is subject to license terms.

 */

#pragma ident	"%Z%%M%	%I%	%E% SMI"

#include <sys/asm_linkage.h>

#if defined(__lint)

char stubs_base[1], stubs_end[1];

#else	/* __lint */

#include "assym.h"

/*

 * !!!!!!!! WARNING! WARNING! WARNING! WARNING! WARNING! WARNING! !!!!!!!!

 *

 *	For functions which are either STUBs or WSTUBs the actual function

 *	need to be called using 'call' instruction because of preamble and

 *	postamble (i.e mod_hold_stub and mod_release_stub) around the

 *	function call. Due to this we need to copy arguments for the

 *	real function. On Intel we can't tell how many arguments are there

 *	on the stack so we have to either copy everything between esp and

 *	ebp or copy only a fixed number (MAXNARG - defined here) for

 *	all the stub functions. Currently we are using MAXNARG (it is a kludge

 *	but worth it?!).

 *

 *	NOTE: Use NO_UNLOAD_STUBs if the module is NOT unloadable once it is

 *	      loaded.

 */

#define	MAXNARG	10

/*

 * WARNING: there is no check for forgetting to write END_MODULE,

 * and if you do, the kernel will most likely crash.  Be careful

 *

 * This file assumes that all of the contributions to the data segment

 * will be contiguous in the output file, even though they are separated

 * by pieces of text.  This is safe for all assemblers I know of now...

 */

/*

 * This file uses ansi preprocessor features:

 *

 * 1. 	#define mac(a) extra_ ## a     -->   mac(x) expands to extra_a

 * The old version of this is

 *      #define mac(a) extra_/.*.*./a

 * but this fails if the argument has spaces "mac ( x )"

 * (Ignore the dots above, I had to put them in to keep this a comment.)

 *

 * 2.   #define mac(a) #a             -->    mac(x) expands to "x"

 * The old version is

 *      #define mac(a) "a"

 *

 * For some reason, the 5.0 preprocessor isn't happy with the above usage.

 * For now, we're not using these ansi features.

 *

 * The reason is that "the 5.0 ANSI preprocessor" is built into the compiler

 * and is a tokenizing preprocessor. This means, when confronted by something

 * other than C token generation rules, strange things occur. In this case,

 * when confronted by an assembly file, it would turn the token ".globl" into

 * two tokens "." and "globl". For this reason, the traditional, non-ANSI

 * preprocessor is used on assembly files.

 *

 * It would be desirable to have a non-tokenizing cpp (accp?) to use for this.

 */

/*

 * This file contains the stubs routines for modules which can be autoloaded.

 */

#if defined(__amd64)

/*

 * See the 'struct mod_modinfo' definition to see what this declaration

 * is trying to achieve here.

 */

#define	MODULE(module,namespace)	\

	.data;				\

module/**/_modname:			\

	.string	"namespace/module";	\

	SET_SIZE(module/**/_modname);	\

	.align	CPTRSIZE;		\

	.globl	module/**/_modinfo;	\

	.type	module/**/_modinfo, @object;	\

module/**/_modinfo:			\

	.quad	module/**/_modname;	\

	.quad	0	/* storage for modctl pointer */

	/* then mod_stub_info structures follow until a mods_func_adr is 0 */

/* this puts a 0 where the next mods_func_adr would be */

#define	END_MODULE(module)		\

	.data;				\

	.align	CPTRSIZE;		\

	.quad 0;			\

	SET_SIZE(module/**/_modinfo)

/*

 * The data section in the stub_common macro is the

 * mod_stub_info structure for the stub function

 */

#define STUB_COMMON(module, fcnname, install_fcn, retfcn, weak)		\

	ENTRY(fcnname);							\

	leaq	fcnname/**/_info(%rip), %rax;				\

	cmpl	$0, MODS_FLAG(%rax);			/* weak? */	\

	je	stubs_common_code;			/* not weak */	\

	testb	$MODS_INSTALLED, MODS_FLAG(%rax);	/* installed? */ \

	jne	stubs_common_code;		/* yes, do the mod_hold */ \

	jmp	*MODS_RETFCN(%rax);		/* no, jump to retfcn */ \

	SET_SIZE(fcnname);						\

	.data;								\

	.align	 CPTRSIZE;						\

	.type	fcnname/**/_info, @object;				\

fcnname/**/_info:							\

	.quad	install_fcn;		/* 0 */				\

	.quad	module/**/_modinfo;	/* 0x8 */			\

	.quad	fcnname;		/* 0x10 */			\

	.quad	retfcn;			/* 0x18 */			\

	.long	weak;			/* 0x20 */			\

	SET_SIZE(fcnname/**/_info)

#define STUB_UNLOADABLE(module, fcnname, install_fcn, retfcn, weak)	\

	ENTRY(fcnname);							\

	leaq	fcnname/**/_info(%rip), %rax;				\

	testb	$MODS_INSTALLED, MODS_FLAG(%rax); /* installed? */	\

	je	5f;			/* no */			\

	jmp	*(%rax);		/* yes, jump to install_fcn */	\

5:	testb	$MODS_WEAK, MODS_FLAG(%rax);	/* weak? */		\

	je	stubs_common_code;	/* no, do mod load */		\

	jmp	*MODS_RETFCN(%rax);	/* yes, jump to retfcn */	\

	SET_SIZE(fcnname);						\

	.data;								\

	.align	CPTRSIZE;						\

	.type	fcnname/**/_info, @object;				\

fcnname/**/_info:							\

	.quad	install_fcn;		/* 0 */				\

	.quad	module/**/_modinfo;	/* 0x8 */			\

	.quad	fcnname;		/* 0x10 */			\

	.quad	retfcn;			/* 0x18 */			\

	.long   weak;			/* 0x20 */			\

	SET_SIZE(fcnname/**/_info)

/*

 * We branch here with the fcnname_info pointer in %rax

 */

	ENTRY_NP(stubs_common_code)

	.globl	mod_hold_stub

	.globl	mod_release_stub

	pushq	%rbp

	movq	%rsp, %rbp

	subq	$0x10, %rsp

	movq	%r15, (%rsp)		/* (caller saved) */

	movq	%rax, %r15		/* stash the fcnname_info pointer */

	/*

	 * save incoming register arguments

	 */

	pushq	%rdi

	pushq	%rsi

	pushq	%rdx

	pushq	%rcx

	pushq	%r8

	pushq	%r9

	/* (next 4 args, if any, are already on the stack above %rbp) */

	movq	%r15, %rdi

	call	mod_hold_stub		/* mod_hold_stub(mod_stub_info *) */

	cmpl	$-1, %eax		/* error? */

	jne	.L1

	movq	0x18(%r15), %rax

	call	*%rax

	addq	$0x30, %rsp

	jmp	.L2

.L1:

	/*

	 * copy MAXNARG == 10 incoming arguments

	 */

	popq	%r9

	popq	%r8

	popq	%rcx

	popq	%rdx

	popq	%rsi

	popq	%rdi

	/*

	 * stack:

	 *	arg9		0x38(%rsp)

	 *	arg8		0x30(%rsp)

	 *	arg7		0x28(%rsp)

	 *	arg6		0x20(%rsp)

	 *	saved %rip	0x18(%rsp)

	 *	saved %rbp	0x10(%rsp)

	 *	<pad>		0x8(%rsp)

	 *	saved %r15	0x0(%rsp)

	 */

	movl	$MAXNARG - 6 + 3, %r11d

	pushq	(%rsp, %r11, 8)

	pushq	(%rsp, %r11, 8)

	pushq	(%rsp, %r11, 8)

	pushq	(%rsp, %r11, 8)

	call	*(%r15)			/* call the stub fn(arg, ..) */

	addq	$0x20, %rsp		/* pop off last 4 args */

	pushq	%rax			/* save any return values */

	pushq	%rdx

	movq	%r15, %rdi

	call	mod_release_stub	/* release hold on module */

	popq	%rdx			/* restore return values */

	popq	%rax

.L2:

	popq	%r15

	leave

	ret

	SET_SIZE(stubs_common_code)

#elif defined(__i386)

/*

 * See the 'struct mod_modinfo' definition to see what this declaration

 * is trying to achieve here.

 */

#define MODULE(module,namespace)	\

	.data;				\

module/**/_modname:			\

	.string	"namespace/module";	\

	SET_SIZE(module/**/_modname);	\

	.align	CPTRSIZE;		\

	.globl	module/**/_modinfo;	\

	.type	module/**/_modinfo, @object;	\

module/**/_modinfo:			\

	.long	module/**/_modname;	\

	.long	0	/* storage for modctl pointer */

	/* then mod_stub_info structures follow until a mods_func_adr is 0 */

/* this puts a 0 where the next mods_func_adr would be */

#define END_MODULE(module)		\

	.data;				\

	.align	CPTRSIZE;		\

	.long 0;			\

	SET_SIZE(module/**/_modinfo)

/*

 * The data section in the stub_common macro is the

 * mod_stub_info structure for the stub function

 */

/*	

 * The flag MODS_INSTALLED is stored in the stub data and is used to

 * indicate if a module is installed and initialized.  This flag is used

 * instead of the mod_stub_info->mods_modinfo->mod_installed flag

 * to minimize the number of pointer de-references for each function

 * call (and also to avoid possible TLB misses which could be induced

 * by dereferencing these pointers.)

 */	

#define STUB_COMMON(module, fcnname, install_fcn, retfcn, weak)		\

	ENTRY(fcnname);							\

	leal	fcnname/**/_info, %eax;					\

	cmpl	$0, MODS_FLAG(%eax);	/* weak? */			\

	je	stubs_common_code;	/* not weak */			\

	testb	$MODS_INSTALLED, MODS_FLAG(%eax); /* installed? */	\

	jne	stubs_common_code;	/* yes, do the mod_hold */	\

	jmp	*MODS_RETFCN(%eax);	/* no, just jump to retfcn */	\

	SET_SIZE(fcnname);						\

	.data;								\

	.align	 CPTRSIZE;						\

	.type	fcnname/**/_info, @object;				\

fcnname/**/_info:							\

	.long	install_fcn;						\

	.long	module/**/_modinfo;					\

	.long	fcnname;						\

	.long	retfcn;							\

	.long   weak;							\

	SET_SIZE(fcnname/**/_info)

#define STUB_UNLOADABLE(module, fcnname, install_fcn, retfcn, weak)	\

	ENTRY(fcnname);							\

	leal	fcnname/**/_info, %eax;					\

	testb	$MODS_INSTALLED, MODS_FLAG(%eax); /* installed? */	\

	je	5f;		/* no */				\

	jmp	*(%eax);	/* yes, just jump to install_fcn */	\

5:	testb	$MODS_WEAK, MODS_FLAG(%eax);	/* weak? */		\

	je	stubs_common_code;	/* no, do mod load */		\

	jmp	*MODS_RETFCN(%eax);	/* yes, just jump to retfcn */ 	\

	SET_SIZE(fcnname);						\

	.data;								\

	.align	CPTRSIZE;						\

	.type	fcnname/**/_info, @object;				\

fcnname/**/_info:							\

	.long	install_fcn;		/* 0 */				\

	.long	module/**/_modinfo;	/* 0x4 */			\

	.long	fcnname;		/* 0x8 */			\

	.long	retfcn;			/* 0xc */			\

	.long   weak;			/* 0x10 */			\

	SET_SIZE(fcnname/**/_info)

/*

 * We branch here with the fcnname_info pointer in %eax

 */

	ENTRY_NP(stubs_common_code)

	.globl	mod_hold_stub

	.globl	mod_release_stub

	pushl	%esi

	movl	%eax, %esi		/ save the info pointer

	pushl	%eax

	call	mod_hold_stub		/ mod_hold_stub(mod_stub_info *)

	popl	%ecx

	cmpl	$-1, %eax		/ error?

	jne	.L1

	movl	MODS_RETFCN(%esi), %eax

	call    *%eax	

	popl	%esi			/ yes, return error (panic?)

	ret

.L1:

	movl	$MAXNARG+1, %ecx

	/ copy incoming arguments

	pushl	(%esp, %ecx, 4)		/ push MAXNARG times

	pushl	(%esp, %ecx, 4)

	pushl	(%esp, %ecx, 4)

	pushl	(%esp, %ecx, 4)

	pushl	(%esp, %ecx, 4)

	pushl	(%esp, %ecx, 4)

	pushl	(%esp, %ecx, 4)

	pushl	(%esp, %ecx, 4)

	pushl	(%esp, %ecx, 4)

	pushl	(%esp, %ecx, 4)

	call	*(%esi)			/ call the stub function(arg1,arg2, ...)

	add	$_MUL(MAXNARG, 4), %esp	/ pop off MAXNARG arguments

	pushl	%eax			/ save any return values from the stub

	pushl	%edx

	pushl	%esi

	call	mod_release_stub	/ release hold on module

	addl	$4, %esp

	popl	%edx			/ restore return values

	popl	%eax

.L2:

	popl	%esi

	ret

	SET_SIZE(stubs_common_code)

#endif	/* __i386 */

#define STUB(module, fcnname, retfcn)	\

    STUB_COMMON(module, fcnname, mod_hold_stub, retfcn, 0)

/*

 * "weak stub", don't load on account of this call

 */

#define WSTUB(module, fcnname, retfcn)	\

    STUB_COMMON(module, fcnname, retfcn, retfcn, MODS_WEAK)

/*

 * "non-unloadable stub", don't bother 'holding' module if it's already loaded

 * since the module cannot be unloaded.

 *

 * User *MUST* guarantee the module is not unloadable (no _fini routine).

 */

#define NO_UNLOAD_STUB(module, fcnname, retfcn) \

    STUB_UNLOADABLE(module, fcnname,  retfcn, retfcn, MODS_NOUNLOAD)

/*

 * "weak stub" for non-unloadable module, don't load on account of this call

 */

#define NO_UNLOAD_WSTUB(module, fcnname, retfcn) \

    STUB_UNLOADABLE(module, fcnname, retfcn, retfcn, MODS_NOUNLOAD|MODS_WEAK)

/*

 * this is just a marker for the beginning area of text that contains stubs

 */

	ENTRY_NP(stubs_base)

	nop

/*

 * WARNING WARNING WARNING!!!!!!

 * 

 * On the MODULE macro you MUST NOT use any spaces!!! They are

 * significant to the preprocessor.  With ansi c there is a way around this

 * but for some reason (yet to be investigated) ansi didn't work for other

 * reasons!  

 *

 * When zero is used as the return function, the system will call

 * panic if the stub can't be resolved.

 */

/*

 * Stubs for devfs. A non-unloadable module.

 */

#ifndef	DEVFS_MODULE

	MODULE(devfs,fs);

	NO_UNLOAD_STUB(devfs, devfs_clean,		nomod_minus_one);

	NO_UNLOAD_STUB(devfs, devfs_lookupname,		nomod_minus_one);

	NO_UNLOAD_STUB(devfs, devfs_walk,		nomod_minus_one);

	NO_UNLOAD_STUB(devfs, devfs_devpolicy,		nomod_minus_one);

	NO_UNLOAD_STUB(devfs, devfs_reset_perm,		nomod_minus_one);

	NO_UNLOAD_STUB(devfs, devfs_remdrv_cleanup,	nomod_minus_one);

	END_MODULE(devfs);

#endif

/*

 * Stubs for specfs. A non-unloadable module.

 */

#ifndef SPEC_MODULE

	MODULE(specfs,fs);

	NO_UNLOAD_STUB(specfs, common_specvp,		nomod_zero);

	NO_UNLOAD_STUB(specfs, makectty,		nomod_zero);

	NO_UNLOAD_STUB(specfs, makespecvp,     		nomod_zero);

	NO_UNLOAD_STUB(specfs, smark,          		nomod_zero);

	NO_UNLOAD_STUB(specfs, spec_segmap,    		nomod_einval);

	NO_UNLOAD_STUB(specfs, specfind,       		nomod_zero);

	NO_UNLOAD_STUB(specfs, specvp,         		nomod_zero);

	NO_UNLOAD_STUB(specfs, devi_stillreferenced,	nomod_zero);

	NO_UNLOAD_STUB(specfs, spec_getvnodeops,	nomod_zero);

	NO_UNLOAD_STUB(specfs, spec_char_map,		nomod_zero);

	NO_UNLOAD_STUB(specfs, specvp_devfs,  		nomod_zero);

	NO_UNLOAD_STUB(specfs, spec_assoc_vp_with_devi,	nomod_void);

	NO_UNLOAD_STUB(specfs, spec_hold_devi_by_vp,	nomod_zero);

	NO_UNLOAD_STUB(specfs, spec_snode_walk,		nomod_void);

	NO_UNLOAD_STUB(specfs, spec_devi_open_count,	nomod_minus_one);

	NO_UNLOAD_STUB(specfs, spec_is_clone,		nomod_zero);

	NO_UNLOAD_STUB(specfs, spec_is_selfclone,	nomod_zero);

	END_MODULE(specfs);

#endif

/*

 * Stubs for sockfs. A non-unloadable module.

 */

#ifndef SOCK_MODULE

	MODULE(sockfs,fs);

	NO_UNLOAD_STUB(sockfs, so_socket,  	nomod_zero);

	NO_UNLOAD_STUB(sockfs, so_socketpair,	nomod_zero);

	NO_UNLOAD_STUB(sockfs, bind,  		nomod_zero);

	NO_UNLOAD_STUB(sockfs, listen,  	nomod_zero);

	NO_UNLOAD_STUB(sockfs, accept,  	nomod_zero);

	NO_UNLOAD_STUB(sockfs, connect,  	nomod_zero);

	NO_UNLOAD_STUB(sockfs, shutdown,  	nomod_zero);

	NO_UNLOAD_STUB(sockfs, recv,  		nomod_zero);

	NO_UNLOAD_STUB(sockfs, recvfrom,  	nomod_zero);

	NO_UNLOAD_STUB(sockfs, recvmsg,  	nomod_zero);

	NO_UNLOAD_STUB(sockfs, send,  		nomod_zero);

	NO_UNLOAD_STUB(sockfs, sendmsg,  	nomod_zero);

	NO_UNLOAD_STUB(sockfs, sendto,  	nomod_zero);

#ifdef _SYSCALL32_IMPL

	NO_UNLOAD_STUB(sockfs, recv32,		nomod_zero);

	NO_UNLOAD_STUB(sockfs, recvfrom32,	nomod_zero);

	NO_UNLOAD_STUB(sockfs, send32,		nomod_zero);

	NO_UNLOAD_STUB(sockfs, sendto32,	nomod_zero);

#endif	/* _SYSCALL32_IMPL */

	NO_UNLOAD_STUB(sockfs, getpeername,  	nomod_zero);

	NO_UNLOAD_STUB(sockfs, getsockname,  	nomod_zero);

	NO_UNLOAD_STUB(sockfs, getsockopt,  	nomod_zero);

	NO_UNLOAD_STUB(sockfs, setsockopt,  	nomod_zero);

	NO_UNLOAD_STUB(sockfs, sockconfig,  	nomod_zero);

	NO_UNLOAD_STUB(sockfs, nca_sendfilev,  	nomod_zero);

	NO_UNLOAD_STUB(sockfs, sock_getmsg,  	nomod_zero);

	NO_UNLOAD_STUB(sockfs, sock_putmsg,  	nomod_zero);

	NO_UNLOAD_STUB(sockfs, sosendfile64,  	nomod_zero);

	NO_UNLOAD_STUB(sockfs, sock_getfasync,  nomod_zero);

	NO_UNLOAD_STUB(sockfs, nl7c_sendfilev,  nomod_zero);

	END_MODULE(sockfs);

#endif

/*

 * IPsec stubs.

 */

#ifndef	IPSECAH_MODULE

	MODULE(ipsecah,drv);

	WSTUB(ipsecah,	ipsec_construct_inverse_acquire,	nomod_zero);

	WSTUB(ipsecah,	sadb_acquire,		nomod_zero);

	WSTUB(ipsecah,	sadb_ill_download,	nomod_zero); 	

	WSTUB(ipsecah,	ipsecah_algs_changed,	nomod_zero);

	WSTUB(ipsecah,	sadb_alg_update,	nomod_zero);

	WSTUB(ipsecah,	sadb_unlinkassoc,	nomod_zero);

	WSTUB(ipsecah,	sadb_insertassoc,	nomod_zero);

	WSTUB(ipsecah,	ipsecah_rl_strlog,	nomod_zero);

	WSTUB(ipsecah,	ipsecah_in_assocfailure,	nomod_zero);

	WSTUB(ipsecah,	sadb_set_lpkt,		nomod_zero);

	WSTUB(ipsecah,	ipsecah_icmp_error,	nomod_zero);

	END_MODULE(ipsecah);

#endif

#ifndef	IPSECESP_MODULE

	MODULE(ipsecesp,drv);

	WSTUB(ipsecesp,	ipsecesp_fill_defs,	nomod_zero);

	WSTUB(ipsecesp,	ipsecesp_algs_changed,	nomod_zero);

	WSTUB(ipsecesp, ipsecesp_in_assocfailure,	nomod_zero);

	WSTUB(ipsecesp, ipsecesp_init_funcs,	nomod_zero);

	WSTUB(ipsecesp,	ipsecesp_icmp_error,	nomod_zero);

	END_MODULE(ipsecesp);

#endif

#ifndef	KEYSOCK_MODULE

	MODULE(keysock,	drv);

	WSTUB(keysock,	keysock_plumb_ipsec,	nomod_zero);

	WSTUB(keysock,	keysock_extended_reg,	nomod_zero);

	WSTUB(keysock,	keysock_next_seq,	nomod_zero);

	END_MODULE(keysock);

#endif

#ifndef SPDSOCK_MODULE

	MODULE(spdsock,drv);