include/sys/exec.h

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21
  22 /*
  23  * Copyright (c) 1989, 2010, Oracle and/or its affiliates. All rights reserved.
  24  */
  25
  26 /*      Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
  27 /*        All Rights Reserved   */
  28
  29 #ifndef _SYS_EXEC_H
  30 #define _SYS_EXEC_H
  31
  32 #include <sys/systm.h>
  33 #include <vm/seg.h>
  34 #include <vm/seg_vn.h>
  35 #include <sys/model.h>
  36 #include <sys/uio.h>
  37 #include <sys/corectl.h>
  38 #include <sys/machelf.h>
  39
  40 #ifdef  __cplusplus
  41 extern "C" {
  42 #endif
  43
  44 /*
  45  * Number of bytes to read for magic string
  46  */
  47 #define MAGIC_BYTES     8
  48
  49 #define getexmag(x)     (((x)[0] << 8) + (x)[1])
  50
  51 typedef struct execa {
  52         const char *fname;
  53         const char **argp;
  54         const char **envp;
  55 } execa_t;
  56
  57 typedef struct execenv {
  58         caddr_t ex_bssbase;
  59         caddr_t ex_brkbase;
  60         size_t  ex_brksize;
  61         vnode_t *ex_vp;
  62         short   ex_magic;
  63 } execenv_t;
  64
  65 #ifdef _KERNEL
  66
  67 #define LOADABLE_EXEC(e)        ((e)->exec_lock)
  68 #define LOADED_EXEC(e)          ((e)->exec_func)
  69
  70
  71 /*
  72  * User argument structure for passing exec information around between the
  73  * common and machine-dependent portions of exec and the exec modules.
  74  */
  75 typedef struct uarg {
  76         ssize_t na;
  77         ssize_t ne;
  78         ssize_t nc;
  79         ssize_t arglen;
  80         char    *fname;
  81         char    *pathname;
  82         ssize_t auxsize;
  83         caddr_t stackend;
  84         size_t  stk_align;
  85         size_t  stk_size;
  86         char    *stk_base;
  87         char    *stk_strp;
  88         int     *stk_offp;
  89         size_t  usrstack_size;
  90         uint_t  stk_prot;
  91         uint_t  dat_prot;
  92         int     traceinval;
  93         int     addr32;
  94         model_t to_model;
  95         model_t from_model;
  96         size_t  to_ptrsize;
  97         size_t  from_ptrsize;
  98         size_t  ncargs;
  99         struct execsw *execswp;
 100         uintptr_t entry;
 101         uintptr_t thrptr;
 102         vnode_t *ex_vp;
 103         char    *emulator;
 104         char    *brandname;
 105         char    *auxp_auxflags; /* addr of auxflags auxv on the user stack */
 106         char    *auxp_brand; /* address of first brand auxv on user stack */
 107         cred_t  *pfcred;
 108         boolean_t scrubenv;
 109         uintptr_t commpage;
 110 } uarg_t;
 111
 112 /*
 113  * Possible brand actions for exec.
 114  */
 115 #define EBA_NONE        0
 116 #define EBA_NATIVE      1
 117 #define EBA_BRAND       2
 118
 119 /*
 120  * The following macro is a machine dependent encapsulation of
 121  * postfix processing to hide the stack direction from elf.c
 122  * thereby making the elf.c code machine independent.
 123  */
 124 #define execpoststack(ARGS, ARRAYADDR, BYTESIZE) \
 125         (copyout((caddr_t)(ARRAYADDR), (ARGS)->stackend, (BYTESIZE)) ? EFAULT \
 126                 : (((ARGS)->stackend += (BYTESIZE)), 0))
 127
 128 /*
 129  * This provides the current user stack address for an object of size BYTESIZE.
 130  * Used to determine the stack address just before applying execpoststack().
 131  */
 132 #define stackaddress(ARGS, BYTESIZE)    ((ARGS)->stackend)
 133
 134 /*
 135  * Macro to add attribute/values the aux vector under construction.
 136  */
 137 /* BEGIN CSTYLED */
 138 #if ((_LONG_ALIGNMENT == (2 * _INT_ALIGNMENT)) || \
 139      (_POINTER_ALIGNMENT == (2 * _INT_ALIGNMENT)))
 140 /* END CSTYLED */
 141 /*
 142  * This convoluted stuff is necessitated by the fact that there is
 143  * potential padding in the aux vector, but not necessarily and
 144  * without clearing the padding there is a small, but potential
 145  * security hole.
 146  */
 147 #define ADDAUX(p, a, v) {               \
 148                 (&(p)->a_type)[1] = 0;  \
 149                 (p)->a_type = (a);      \
 150                 (p)->a_un.a_val = (v);  \
 151                 ++(p);                  \
 152         }
 153 #else
 154 #define ADDAUX(p, a, v) {                       \
 155                 (p)->a_type = (a);              \
 156                 ((p)++)->a_un.a_val = (v);      \
 157         }
 158 #endif
 159
 160 #define INTPSZ  MAXPATHLEN
 161 #define INTP_MAXDEPTH   5       /* Nested interpreter depth matches Linux */
 162 typedef struct intpdata {
 163         char    *intp;
 164         char    *intp_name[INTP_MAXDEPTH];
 165         char    *intp_arg[INTP_MAXDEPTH];
 166 } intpdata_t;
 167
 168 #define EXECSETID_SETID         0x1 /* setid exec */
 169 #define EXECSETID_UGIDS         0x2 /* [ug]ids mismatch */
 170 #define EXECSETID_PRIVS         0x4 /* more privs than before */
 171
 172 struct execsw {
 173         char    *exec_magic;
 174         int     exec_magoff;
 175         int     exec_maglen;
 176         int     (*exec_func)(struct vnode *vp, struct execa *uap,
 177                     struct uarg *args, struct intpdata *idata, int level,
 178                     long *execsz, int setid, caddr_t exec_file,
 179                     struct cred *cred, int brand_action);
 180         int     (*exec_core)(struct vnode *vp, struct proc *p,
 181                     struct cred *cred, rlim64_t rlimit, int sig,
 182                     core_content_t content);
 183         krwlock_t       *exec_lock;
 184 };
 185
 186 extern int nexectype;           /* number of elements in execsw */
 187 extern struct execsw execsw[];
 188 extern kmutex_t execsw_lock;
 189
 190 extern short elfmagic;
 191 extern short intpmagic;
 192 extern short javamagic;
 193 extern short nomagic;
 194
 195 extern char elf32magicstr[];
 196 extern char elf64magicstr[];
 197 extern char intpmagicstr[];
 198 extern char javamagicstr[];
 199 extern char nomagicstr[];
 200
 201 extern int exec_args(execa_t *, uarg_t *, intpdata_t *, void **);
 202 extern int exece(const char *fname, const char **argp, const char **envp);
 203 extern int exec_common(const char *fname, const char **argp,
 204     const char **envp, int brand_action);
 205 extern int gexec(vnode_t **vp, struct execa *uap, struct uarg *args,
 206     struct intpdata *idata, int level, long *execsz, caddr_t exec_file,
 207     struct cred *cred, int brand_action);
 208 extern struct execsw *allocate_execsw(char *name, char *magic,
 209     size_t magic_size);
 210 extern struct execsw *findexecsw(char *magic);
 211 extern struct execsw *findexec_by_hdr(char *header);
 212 extern struct execsw *findexec_by_magic(char *magic);
 213 extern int execpermissions(struct vnode *vp, struct vattr *vattrp,
 214     struct uarg *args);
 215 extern int execmap(vnode_t *vp, caddr_t addr, size_t len, size_t zfodlen,
 216     off_t offset, int prot, int page, uint_t);
 217 extern void setexecenv(struct execenv *ep);
 218 extern int execopen(struct vnode **vpp, int *fdp);
 219 extern int execclose(int fd);
 220 extern void setregs(uarg_t *);
 221 extern void exec_set_sp(size_t);
 222
 223 /*
 224  * Utility functions for branded process executing
 225  */
 226 #if !defined(_ELF32_COMPAT)
 227 /*
 228  * When compiling 64-bit kernels we don't want these definitions included
 229  * when compiling the 32-bit compatability elf code in the elfexec module.
 230  */
 231 extern int elfexec(vnode_t *, execa_t *, uarg_t *, intpdata_t *, int,
 232     long *, int, caddr_t, cred_t *, int);
 233 extern int mapexec_brand(vnode_t *, uarg_t *, Ehdr *, Addr *,
 234     intptr_t *, caddr_t, int *, caddr_t *, caddr_t *, size_t *, uintptr_t *);
 235 #endif /* !_ELF32_COMPAT */
 236
 237 #if defined(_LP64)
 238 extern int elf32exec(vnode_t *, execa_t *, uarg_t *, intpdata_t *, int,
 239     long *, int, caddr_t, cred_t *, int);
 240 extern int mapexec32_brand(vnode_t *, uarg_t *, Elf32_Ehdr *, Elf32_Addr *,
 241     intptr_t *, caddr_t, int *, caddr_t *, caddr_t *, size_t *, uintptr_t *);
 242 #endif  /* _LP64 */
 243
 244 /*
 245  * Utility functions for exec module core routines:
 246  */
 247 extern int core_seg(proc_t *, vnode_t *, offset_t, caddr_t,
 248     size_t, rlim64_t, cred_t *);
 249
 250 extern int core_write(vnode_t *, enum uio_seg, offset_t,
 251     const void *, size_t, rlim64_t, cred_t *);
 252
 253 /* a.out stuff */
 254
 255 struct exec;
 256
 257 extern caddr_t gettmem(struct exec *exp);
 258 extern caddr_t getdmem(struct exec *exp);
 259 extern ulong_t getdfile(struct exec *exp);
 260 extern uint_t gettfile(struct exec *exp);
 261 extern void getexinfo(struct exdata *edp_in, struct exdata *edp_out,
 262     int *pagetext, int *pagedata);
 263
 264 #endif  /* _KERNEL */
 265
 266 #ifdef  __cplusplus
 267 }
 268 #endif
 269
 270 #endif /* _SYS_EXEC_H */