/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (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 (c) 1989, 2010, Oracle and/or its affiliates. All rights reserved.
 * Copyright 2022 Garrett D'Amore <garrett@damore.org>
 */

/*      Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
/*        All Rights Reserved   */

/*
 * Copyright 2019 Joyent, Inc.
 */

#ifndef _SYS_EXEC_H
#define _SYS_EXEC_H

#include <sys/systm.h>
#include <vm/seg.h>
#include <vm/seg_vn.h>
#include <sys/model.h>
#include <sys/uio.h>
#include <sys/corectl.h>
#include <sys/machelf.h>

#ifdef  __cplusplus
extern "C" {
#endif

/*
 * Number of bytes to read for magic string
 */
#define MAGIC_BYTES     8

#define getexmag(x)     (((x)[0] << 8) + (x)[1])

typedef struct execa {
        const char *fname;
        const char **argp;
        const char **envp;
} execa_t;

typedef struct execenv {
        caddr_t ex_bssbase;
        caddr_t ex_brkbase;
        size_t  ex_brksize;
        vnode_t *ex_vp;
        short   ex_magic;
} execenv_t;

#ifdef _KERNEL

#define LOADABLE_EXEC(e)        ((e)->exec_lock)
#define LOADED_EXEC(e)          ((e)->exec_func)


/*
 * User argument structure for passing exec information around between the
 * common and machine-dependent portions of exec and the exec modules.
 */
typedef struct uarg {
        ssize_t na;
        ssize_t ne;
        ssize_t nc;
        ssize_t arglen;
        char    *fname;
        char    *pathname;
        size_t  auxsize;
        caddr_t stackend;
        size_t  stk_align;
        size_t  stk_size;
        char    *stk_base;
        char    *stk_strp;
        int     *stk_offp;
        size_t  usrstack_size;
        uint_t  stk_prot;
        uint_t  dat_prot;
        int     traceinval;
        int     addr32;
        model_t to_model;
        model_t from_model;
        size_t  to_ptrsize;
        size_t  from_ptrsize;
        size_t  ncargs;
        struct execsw *execswp;
        uintptr_t entry;
        uintptr_t thrptr;
        vnode_t *ex_vp;
        char    *emulator;
        char    *brandname;
        char    *auxp_auxflags; /* addr of auxflags auxv on the user stack */
        char    *auxp_brand; /* address of first brand auxv on user stack */
        cred_t  *pfcred;
        boolean_t scrubenv;
        uintptr_t commpage;
} uarg_t;

/*
 * Possible brand actions for exec.
 */
#define EBA_NONE        0
#define EBA_NATIVE      1
#define EBA_BRAND       2

/*
 * The following macro is a machine dependent encapsulation of
 * postfix processing to hide the stack direction from elf.c
 * thereby making the elf.c code machine independent.
 */
#define execpoststack(ARGS, ARRAYADDR, BYTESIZE) \
        (copyout((caddr_t)(ARRAYADDR), (ARGS)->stackend, (BYTESIZE)) ? EFAULT \
                : (((ARGS)->stackend += (BYTESIZE)), 0))

/*
 * This provides the current user stack address for an object of size BYTESIZE.
 * Used to determine the stack address just before applying execpoststack().
 */
#define stackaddress(ARGS, BYTESIZE)    ((ARGS)->stackend)

/*
 * Macro to add attribute/values the aux vector under construction.
 */
/* BEGIN CSTYLED */
#if ((_LONG_ALIGNMENT == (2 * _INT_ALIGNMENT)) || \
     (_POINTER_ALIGNMENT == (2 * _INT_ALIGNMENT)))
/* END CSTYLED */
/*
 * This convoluted stuff is necessitated by the fact that there is
 * potential padding in the aux vector, but not necessarily and
 * without clearing the padding there is a small, but potential
 * security hole.
 */
#define ADDAUX(p, a, v) {               \
                (&(p)->a_type)[1] = 0;  \
                (p)->a_type = (a);      \
                (p)->a_un.a_val = (v);  \
                ++(p);                  \
        }
#else
#define ADDAUX(p, a, v) {                       \
                (p)->a_type = (a);              \
                ((p)++)->a_un.a_val = (v);      \
        }
#endif

#define INTPSZ  MAXPATHLEN
#define INTP_MAXDEPTH   5       /* Nested interpreter depth matches Linux */
typedef struct intpdata {
        char    *intp;
        char    *intp_name[INTP_MAXDEPTH];
        char    *intp_arg[INTP_MAXDEPTH];
} intpdata_t;

#define EXECSETID_SETID         0x1 /* setid exec */
#define EXECSETID_UGIDS         0x2 /* [ug]ids mismatch */
#define EXECSETID_PRIVS         0x4 /* more privs than before */

struct execsw {
        char    *exec_magic;
        int     exec_magoff;
        int     exec_maglen;
        int     (*exec_func)(struct vnode *vp, struct execa *uap,
                    struct uarg *args, struct intpdata *idata, int level,
                    size_t *execsz, int setid, caddr_t exec_file,
                    struct cred *cred, int brand_action);
        int     (*exec_core)(struct vnode *vp, struct proc *p,
                    struct cred *cred, rlim64_t rlimit, int sig,
                    core_content_t content);
        krwlock_t       *exec_lock;
};

extern int nexectype;           /* number of elements in execsw */
extern struct execsw execsw[];
extern kmutex_t execsw_lock;

extern short elfmagic;
extern short intpmagic;
extern short javamagic;
extern short nomagic;

extern char elf32magicstr[];
extern char elf64magicstr[];
extern char intpmagicstr[];
extern char javamagicstr[];
extern char nomagicstr[];

extern int exec_args(execa_t *, uarg_t *, intpdata_t *, void **);
extern int exece(uintptr_t, const char **, const char **, int);
extern int exec_common(const char *, const char **, const char **, vnode_t *,
    int);
extern int gexec(vnode_t **vp, struct execa *uap, struct uarg *args,
    struct intpdata *idata, int level, size_t *execsz, caddr_t exec_file,
    struct cred *cred, int brand_action);
extern struct execsw *allocate_execsw(char *name, char *magic,
    size_t magic_size);
extern struct execsw *findexecsw(char *magic);
extern struct execsw *findexec_by_hdr(char *header);
extern struct execsw *findexec_by_magic(char *magic);
extern int execpermissions(struct vnode *vp, struct vattr *vattrp,
    struct uarg *args);
extern int execmap(vnode_t *vp, caddr_t addr, size_t len, size_t zfodlen,
    off_t offset, int prot, int page, uint_t);
extern void setexecenv(struct execenv *ep);
extern int execopen(struct vnode **vpp, int *fdp);
extern int execclose(int fd);
extern void setregs(uarg_t *);
extern void exec_set_sp(size_t);

/*
 * Utility functions for branded process executing
 */
#if !defined(_ELF32_COMPAT)
/*
 * When compiling 64-bit kernels we don't want these definitions included
 * when compiling the 32-bit compatability elf code in the elfexec module.
 */
extern int elfexec(vnode_t *, execa_t *, uarg_t *, intpdata_t *, int,
    size_t *, int, caddr_t, cred_t *, int);
extern int mapexec_brand(vnode_t *, uarg_t *, Ehdr *, Addr *,
    intptr_t *, caddr_t, int *, caddr_t *, caddr_t *, size_t *, uintptr_t *);
extern int elfreadhdr(vnode_t *, cred_t *, Ehdr *, uint_t *, caddr_t *,
    size_t *);
#endif /* !_ELF32_COMPAT */

#if defined(_LP64)
extern int elf32exec(vnode_t *, execa_t *, uarg_t *, intpdata_t *, int,
    size_t *, int, caddr_t, cred_t *, int);
extern int mapexec32_brand(vnode_t *, uarg_t *, Elf32_Ehdr *, Elf32_Addr *,
    intptr_t *, caddr_t, int *, caddr_t *, caddr_t *, size_t *, uintptr_t *);
extern int elf32readhdr(vnode_t *, cred_t *, Elf32_Ehdr *, uint_t *, caddr_t *,
    size_t *);
#endif  /* _LP64 */

/*
 * Utility functions for exec module core routines:
 */
extern int core_seg(proc_t *, vnode_t *, u_offset_t, caddr_t, size_t,
    rlim64_t, cred_t *);

extern int core_write(vnode_t *, enum uio_seg, u_offset_t, const void *,
    size_t, rlim64_t, cred_t *);

#endif  /* _KERNEL */

#ifdef  __cplusplus
}
#endif

#endif /* _SYS_EXEC_H */