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 * Copyright 2008 Sun Microsystems, Inc. All rights reserved. 23 * Use is subject to license terms. 24 * Copyright (c) 2011 Bayard G. Bell. All rights reserved. 25 */ 26 27 #include <sys/types.h> 28 #include <sys/param.h> 29 #include <sys/systm.h> 30 #include <sys/fpu/fpusystm.h> 31 #include <sys/sysmacros.h> 32 #include <sys/signal.h> 33 #include <sys/cred.h> 34 #include <sys/user.h> 35 #include <sys/errno.h> 36 #include <sys/vnode.h> 37 #include <sys/mman.h> 38 #include <sys/kmem.h> 39 #include <sys/proc.h> 40 #include <sys/pathname.h> 41 #include <sys/cmn_err.h> 42 #include <sys/debug.h> 43 #include <sys/exec.h> 44 #include <sys/exechdr.h> 45 #include <sys/auxv.h> 46 #include <sys/core.h> 47 #include <sys/vmparam.h> 48 #include <sys/archsystm.h> 49 #include <sys/fs/swapnode.h> 50 #include <sys/modctl.h> 51 #include <vm/anon.h> 52 #include <vm/as.h> 53 #include <vm/seg.h> 54 55 static int aoutexec(vnode_t *vp, execa_t *uap, uarg_t *args, 56 intpdata_t *idatap, int level, long *execsz, int setid, 57 caddr_t exec_file, cred_t *cred, int brand_action); 58 static int get_aout_head(struct vnode **vpp, struct exdata *edp, long *execsz, 59 int *isdyn); 60 static int aoutcore(vnode_t *vp, proc_t *pp, cred_t *credp, 61 rlim64_t rlimit, int sig, core_content_t content); 62 extern int elf32exec(vnode_t *, execa_t *, uarg_t *, intpdata_t *, int, 63 long *, int, caddr_t, cred_t *, int); 64 extern int elf32core(vnode_t *, proc_t *, cred_t *, rlim64_t, int, 65 core_content_t); 66 67 static struct execsw nesw = { 68 aout_nmagicstr, 69 2, 70 2, 71 aoutexec, 72 aoutcore 73 }; 74 75 static struct execsw zesw = { 76 aout_zmagicstr, 77 2, 78 2, 79 aoutexec, 80 aoutcore 81 }; 82 83 static struct execsw oesw = { 84 aout_omagicstr, 85 2, 86 2, 87 aoutexec, 88 aoutcore 89 }; 90 91 /* 92 * Module linkage information for the kernel. 93 */ 94 static struct modlexec nexec = { 95 &mod_execops, "exec for NMAGIC", &nesw 96 }; 97 98 static struct modlexec zexec = { 99 &mod_execops, "exec for ZMAGIC", &zesw 100 }; 101 102 static struct modlexec oexec = { 103 &mod_execops, "exec for OMAGIC", &oesw 104 }; 105 106 static struct modlinkage modlinkage = { 107 MODREV_1, &nexec, &zexec, &oexec, NULL 108 }; 109 110 int 111 _init(void) 112 { 113 return (mod_install(&modlinkage)); 114 } 115 116 int 117 _fini(void) 118 { 119 return (mod_remove(&modlinkage)); 120 } 121 122 int 123 _info(struct modinfo *modinfop) 124 { 125 return (mod_info(&modlinkage, modinfop)); 126 } 127 128 129 /*ARGSUSED*/ 130 static int 131 aoutexec(vnode_t *vp, struct execa *uap, struct uarg *args, 132 struct intpdata *idatap, int level, long *execsz, int setid, 133 caddr_t exec_file, cred_t *cred, int brand_action) 134 { 135 auxv32_t auxflags_auxv32; 136 int error; 137 struct exdata edp, edpout; 138 struct execenv exenv; 139 proc_t *pp = ttoproc(curthread); 140 struct vnode *nvp; 141 int pagetext, pagedata; 142 int dataprot = PROT_ALL; 143 int textprot = PROT_ALL & ~PROT_WRITE; 144 int isdyn; 145 146 147 args->to_model = DATAMODEL_ILP32; 148 *execsz = btopr(SINCR) + btopr(SSIZE) + btopr(NCARGS32-1); 149 150 /* 151 * Read in and validate the file header. 152 */ 153 if (error = get_aout_head(&vp, &edp, execsz, &isdyn)) 154 return (error); 155 156 if (error = chkaout(&edp)) 157 return (error); 158 159 /* 160 * Take a quick look to see if it looks like we will have 161 * enough swap space for the program to get started. This 162 * is not a guarantee that we will succeed, but it is definitely 163 * better than finding this out after we are committed to the 164 * new memory image. Maybe what is needed is a way to "prereserve" 165 * swap space for some segment mappings here. 166 * 167 * But with shared libraries the process can make it through 168 * the exec only to have ld.so fail to get the program going 169 * because its mmap's will not be able to succeed if the system 170 * is running low on swap space. In fact this is a far more 171 * common failure mode, but we cannot do much about this here 172 * other than add some slop to our anonymous memory resources 173 * requirements estimate based on some guess since we cannot know 174 * what else the program will really need to get to a useful state. 175 * 176 * XXX - The stack size (clrnd(SSIZE + btopr(nargc))) should also 177 * be used when checking for swap space. This requires some work 178 * since nargc is actually determined in exec_args() which is done 179 * after this check and hence we punt for now. 180 * 181 * nargc = SA(nc + (na + 4) * NBPW) + sizeof (struct rwindow); 182 */ 183 if (CURRENT_TOTAL_AVAILABLE_SWAP < btopr(edp.ux_dsize) + btopr(SSIZE)) 184 return (ENOMEM); 185 186 /* 187 * Load the trap 0 interpreter. 188 */ 189 if (error = lookupname("/usr/4lib/sbcp", UIO_SYSSPACE, FOLLOW, 190 NULLVPP, &nvp)) { 191 goto done; 192 } 193 if (error = elf32exec(nvp, uap, args, idatap, level, execsz, 194 setid, exec_file, cred, brand_action)) { 195 VN_RELE(nvp); 196 return (error); 197 } 198 VN_RELE(nvp); 199 200 /* 201 * Determine the a.out's characteristics. 202 */ 203 getexinfo(&edp, &edpout, &pagetext, &pagedata); 204 205 /* 206 * Load the a.out's text and data. 207 */ 208 if (error = execmap(edp.vp, edp.ux_txtorg, edp.ux_tsize, 209 (size_t)0, edp.ux_toffset, textprot, pagetext, 0)) 210 goto done; 211 if (error = execmap(edp.vp, edp.ux_datorg, edp.ux_dsize, 212 edp.ux_bsize, edp.ux_doffset, dataprot, pagedata, 0)) 213 goto done; 214 215 exenv.ex_bssbase = (caddr_t)edp.ux_datorg; 216 exenv.ex_brkbase = (caddr_t)edp.ux_datorg; 217 exenv.ex_brksize = edp.ux_dsize + edp.ux_bsize; 218 exenv.ex_magic = edp.ux_mag; 219 exenv.ex_vp = edp.vp; 220 setexecenv(&exenv); 221 222 /* 223 * It's time to manipulate the process aux vectors. 224 * We need to update the AT_SUN_AUXFLAGS aux vector to set 225 * the AF_SUN_NOPLM flag. 226 */ 227 if (copyin(args->auxp_auxflags, &auxflags_auxv32, 228 sizeof (auxflags_auxv32)) != 0) 229 return (EFAULT); 230 231 ASSERT(auxflags_auxv32.a_type == AT_SUN_AUXFLAGS); 232 auxflags_auxv32.a_un.a_val |= AF_SUN_NOPLM; 233 if (copyout(&auxflags_auxv32, args->auxp_auxflags, 234 sizeof (auxflags_auxv32)) != 0) 235 return (EFAULT); 236 237 done: 238 if (error != 0) 239 psignal(pp, SIGKILL); 240 else { 241 /* 242 * Ensure that the max fds do not exceed 256 (this is 243 * applicable to 4.x binaries, which is why we only 244 * do it on a.out files). 245 */ 246 struct rlimit64 fdno_rlim; 247 rctl_alloc_gp_t *gp = rctl_rlimit_set_prealloc(1); 248 249 mutex_enter(&curproc->p_lock); 250 (void) rctl_rlimit_get(rctlproc_legacy[RLIMIT_NOFILE], curproc, 251 &fdno_rlim); 252 if (fdno_rlim.rlim_cur > 256) { 253 fdno_rlim.rlim_cur = fdno_rlim.rlim_max = 256; 254 (void) rctl_rlimit_set(rctlproc_legacy[RLIMIT_NOFILE], 255 curproc, &fdno_rlim, gp, 256 rctlproc_flags[RLIMIT_NOFILE], 257 rctlproc_signals[RLIMIT_NOFILE], CRED()); 258 } else if (fdno_rlim.rlim_max > 256) { 259 fdno_rlim.rlim_max = 256; 260 (void) rctl_rlimit_set(rctlproc_legacy[RLIMIT_NOFILE], 261 curproc, &fdno_rlim, gp, 262 rctlproc_flags[RLIMIT_NOFILE], 263 rctlproc_signals[RLIMIT_NOFILE], CRED()); 264 } 265 mutex_exit(&curproc->p_lock); 266 267 rctl_prealloc_destroy(gp); 268 } 269 270 return (error); 271 } 272 273 /* 274 * Read in and validate the file header. 275 */ 276 static int 277 get_aout_head(struct vnode **vpp, struct exdata *edp, long *execsz, int *isdyn) 278 { 279 struct vnode *vp = *vpp; 280 struct exec filhdr; 281 int error; 282 ssize_t resid; 283 rlim64_t limit; 284 rlim64_t roundlimit; 285 286 if (error = vn_rdwr(UIO_READ, vp, (caddr_t)&filhdr, 287 (ssize_t)sizeof (filhdr), (offset_t)0, UIO_SYSSPACE, 0, 288 (rlim64_t)0, CRED(), &resid)) 289 return (error); 290 291 if (resid != 0) 292 return (ENOEXEC); 293 294 switch (filhdr.a_magic) { 295 case OMAGIC: 296 filhdr.a_data += filhdr.a_text; 297 filhdr.a_text = 0; 298 break; 299 case ZMAGIC: 300 case NMAGIC: 301 break; 302 default: 303 return (ENOEXEC); 304 } 305 306 /* 307 * Check total memory requirements (in pages) for a new process 308 * against the available memory or upper limit of memory allowed. 309 * 310 * For the 64-bit kernel, the limit can be set large enough so that 311 * rounding it up to a page can overflow, so we check for btopr() 312 * overflowing here by comparing it with the unrounded limit in pages. 313 */ 314 *execsz += btopr(filhdr.a_text + filhdr.a_data); 315 limit = btop(curproc->p_vmem_ctl); 316 roundlimit = btopr(curproc->p_vmem_ctl); 317 if ((roundlimit > limit && *execsz > roundlimit) || 318 (roundlimit < limit && *execsz > limit)) { 319 mutex_enter(&curproc->p_lock); 320 (void) rctl_action(rctlproc_legacy[RLIMIT_VMEM], 321 curproc->p_rctls, curproc, RCA_SAFE); 322 mutex_exit(&curproc->p_lock); 323 return (ENOMEM); 324 } 325 326 edp->ux_mach = filhdr.a_machtype; 327 edp->ux_tsize = filhdr.a_text; 328 edp->ux_dsize = filhdr.a_data; 329 edp->ux_bsize = filhdr.a_bss; 330 edp->ux_mag = filhdr.a_magic; 331 edp->ux_toffset = gettfile(&filhdr); 332 edp->ux_doffset = getdfile(&filhdr); 333 edp->ux_txtorg = gettmem(&filhdr); 334 edp->ux_datorg = getdmem(&filhdr); 335 edp->ux_entloc = (caddr_t)(uintptr_t)filhdr.a_entry; 336 edp->vp = vp; 337 *isdyn = filhdr.a_dynamic; 338 339 return (0); 340 } 341 342 static int 343 aoutcore(vnode_t *vp, proc_t *pp, struct cred *credp, rlim64_t rlimit, int sig, 344 core_content_t content) 345 { 346 return (elf32core(vp, pp, credp, rlimit, sig, content)); 347 } 348