/* This returns vnode with ioref */
static vnode_t
cttyvp(proc_t p)
{
vnode_t vp;
int vid;
struct session *sessp;
sessp = proc_session(p);
session_lock(sessp);
vp = (p->p_flag & P_CONTROLT ? sessp->s_ttyvp : NULLVP);
vid = sessp->s_ttyvid;
session_unlock(sessp);
session_rele(sessp);
if (vp != NULLVP) {
/* cannot get an IO reference, return NULLVP */
if (vnode_getwithvid(vp, vid) != 0)
vp = NULLVP;
}
return(vp);
}
int
cttyioctl(__unused dev_t dev, u_long cmd, caddr_t addr, int flag, proc_t p)
{
vnode_t ttyvp = cttyvp(current_proc());
struct vfs_context context;
struct session *sessp;
int error = 0;
if (ttyvp == NULL)
return (EIO);
if (cmd == TIOCSCTTY) { /* don't allow controlling tty to be set */
error = EINVAL; /* to controlling tty -- infinite recursion */
goto out;
}
if (cmd == TIOCNOTTY) {
sessp = proc_session(p);
if (!SESS_LEADER(p, sessp)) {
OSBitAndAtomic(~((uint32_t)P_CONTROLT), &p->p_flag);
if (sessp != SESSION_NULL)
session_rele(sessp);
error = 0;
goto out;
} else {
if (sessp != SESSION_NULL)
session_rele(sessp);
error = EINVAL;
goto out;
}
}
context.vc_thread = current_thread();
context.vc_ucred = NOCRED;
error = VNOP_IOCTL(ttyvp, cmd, addr, flag, &context);
out:
vnode_put(ttyvp);
return (error);
}
/*
* forkproc
*
* Description: Create a new process structure, given a parent process
* structure.
*
* Parameters: parent_proc The parent process
*
* Returns: !NULL The new process structure
* NULL Error (insufficient free memory)
*
* Note: When successful, the newly created process structure is
* partially initialized; if a caller needs to deconstruct the
* returned structure, they must call forkproc_free() to do so.
*/
proc_t
forkproc(proc_t parent_proc)
{
proc_t child_proc; /* Our new process */
static int nextpid = 0, pidwrap = 0, nextpidversion = 0;
int error = 0;
struct session *sessp;
uthread_t parent_uthread = (uthread_t)get_bsdthread_info(current_thread());
MALLOC_ZONE(child_proc, proc_t , sizeof *child_proc, M_PROC, M_WAITOK);
if (child_proc == NULL) {
printf("forkproc: M_PROC zone exhausted\n");
goto bad;
}
/* zero it out as we need to insert in hash */
bzero(child_proc, sizeof *child_proc);
MALLOC_ZONE(child_proc->p_stats, struct pstats *,
sizeof *child_proc->p_stats, M_PSTATS, M_WAITOK);
if (child_proc->p_stats == NULL) {
printf("forkproc: M_SUBPROC zone exhausted (p_stats)\n");
FREE_ZONE(child_proc, sizeof *child_proc, M_PROC);
child_proc = NULL;
goto bad;
}
MALLOC_ZONE(child_proc->p_sigacts, struct sigacts *,
sizeof *child_proc->p_sigacts, M_SIGACTS, M_WAITOK);
if (child_proc->p_sigacts == NULL) {
printf("forkproc: M_SUBPROC zone exhausted (p_sigacts)\n");
FREE_ZONE(child_proc->p_stats, sizeof *child_proc->p_stats, M_PSTATS);
FREE_ZONE(child_proc, sizeof *child_proc, M_PROC);
child_proc = NULL;
goto bad;
}
/* allocate a callout for use by interval timers */
child_proc->p_rcall = thread_call_allocate((thread_call_func_t)realitexpire, child_proc);
if (child_proc->p_rcall == NULL) {
FREE_ZONE(child_proc->p_sigacts, sizeof *child_proc->p_sigacts, M_SIGACTS);
FREE_ZONE(child_proc->p_stats, sizeof *child_proc->p_stats, M_PSTATS);
FREE_ZONE(child_proc, sizeof *child_proc, M_PROC);
child_proc = NULL;
goto bad;
}
/*
* Find an unused PID.
*/
proc_list_lock();
nextpid++;
retry:
/*
* If the process ID prototype has wrapped around,
* restart somewhat above 0, as the low-numbered procs
* tend to include daemons that don't exit.
*/
if (nextpid >= PID_MAX) {
nextpid = 100;
pidwrap = 1;
}
if (pidwrap != 0) {
/* if the pid stays in hash both for zombie and runniing state */
if (pfind_locked(nextpid) != PROC_NULL) {
nextpid++;
goto retry;
}
if (pgfind_internal(nextpid) != PGRP_NULL) {
nextpid++;
goto retry;
}
if (session_find_internal(nextpid) != SESSION_NULL) {
nextpid++;
goto retry;
}
}
nprocs++;
child_proc->p_pid = nextpid;
child_proc->p_idversion = nextpidversion++;
#if 1
if (child_proc->p_pid != 0) {
if (pfind_locked(child_proc->p_pid) != PROC_NULL)
panic("proc in the list already\n");
}
#endif
/* Insert in the hash */
child_proc->p_listflag |= (P_LIST_INHASH | P_LIST_INCREATE);
LIST_INSERT_HEAD(PIDHASH(child_proc->p_pid), child_proc, p_hash);
proc_list_unlock();
/*
* We've identified the PID we are going to use; initialize the new
* process structure.
*/
child_proc->p_stat = SIDL;
child_proc->p_pgrpid = PGRPID_DEAD;
/*
* The zero'ing of the proc was at the allocation time due to need
* for insertion to hash. Copy the section that is to be copied
* directly from the parent.
*/
bcopy(&parent_proc->p_startcopy, &child_proc->p_startcopy,
(unsigned) ((caddr_t)&child_proc->p_endcopy - (caddr_t)&child_proc->p_startcopy));
/*
* Some flags are inherited from the parent.
* Duplicate sub-structures as needed.
* Increase reference counts on shared objects.
* The p_stats and p_sigacts substructs are set in vm_fork.
*/
child_proc->p_flag = (parent_proc->p_flag & (P_LP64 | P_TRANSLATED | P_AFFINITY));
if (parent_proc->p_flag & P_PROFIL)
startprofclock(child_proc);
/*
* Note that if the current thread has an assumed identity, this
* credential will be granted to the new process.
*/
child_proc->p_ucred = kauth_cred_get_with_ref();
#ifdef CONFIG_EMBEDDED
lck_mtx_init(&child_proc->p_mlock, proc_lck_grp, proc_lck_attr);
lck_mtx_init(&child_proc->p_fdmlock, proc_lck_grp, proc_lck_attr);
#if CONFIG_DTRACE
lck_mtx_init(&child_proc->p_dtrace_sprlock, proc_lck_grp, proc_lck_attr);
#endif
lck_spin_init(&child_proc->p_slock, proc_lck_grp, proc_lck_attr);
#else /* !CONFIG_EMBEDDED */
lck_mtx_init(&child_proc->p_mlock, proc_mlock_grp, proc_lck_attr);
lck_mtx_init(&child_proc->p_fdmlock, proc_fdmlock_grp, proc_lck_attr);
#if CONFIG_DTRACE
lck_mtx_init(&child_proc->p_dtrace_sprlock, proc_lck_grp, proc_lck_attr);
#endif
lck_spin_init(&child_proc->p_slock, proc_slock_grp, proc_lck_attr);
#endif /* !CONFIG_EMBEDDED */
klist_init(&child_proc->p_klist);
if (child_proc->p_textvp != NULLVP) {
/* bump references to the text vnode */
/* Need to hold iocount across the ref call */
if (vnode_getwithref(child_proc->p_textvp) == 0) {
error = vnode_ref(child_proc->p_textvp);
vnode_put(child_proc->p_textvp);
if (error != 0)
child_proc->p_textvp = NULLVP;
}
}
/*
* Copy the parents per process open file table to the child; if
* there is a per-thread current working directory, set the childs
* per-process current working directory to that instead of the
* parents.
*
* XXX may fail to copy descriptors to child
*/
child_proc->p_fd = fdcopy(parent_proc, parent_uthread->uu_cdir);
#if SYSV_SHM
if (parent_proc->vm_shm) {
/* XXX may fail to attach shm to child */
(void)shmfork(parent_proc, child_proc);
}
#endif
/*
* inherit the limit structure to child
*/
proc_limitfork(parent_proc, child_proc);
if (child_proc->p_limit->pl_rlimit[RLIMIT_CPU].rlim_cur != RLIM_INFINITY) {
uint64_t rlim_cur = child_proc->p_limit->pl_rlimit[RLIMIT_CPU].rlim_cur;
child_proc->p_rlim_cpu.tv_sec = (rlim_cur > __INT_MAX__) ? __INT_MAX__ : rlim_cur;
}
/* Intialize new process stats, including start time */
/* <rdar://6640543> non-zeroed portion contains garbage AFAICT */
bzero(&child_proc->p_stats->pstat_startzero,
(unsigned) ((caddr_t)&child_proc->p_stats->pstat_endzero -
(caddr_t)&child_proc->p_stats->pstat_startzero));
bzero(&child_proc->p_stats->user_p_prof, sizeof(struct user_uprof));
microtime(&child_proc->p_start);
child_proc->p_stats->p_start = child_proc->p_start; /* for compat */
if (parent_proc->p_sigacts != NULL)
(void)memcpy(child_proc->p_sigacts,
parent_proc->p_sigacts, sizeof *child_proc->p_sigacts);
else
(void)memset(child_proc->p_sigacts, 0, sizeof *child_proc->p_sigacts);
sessp = proc_session(parent_proc);
if (sessp->s_ttyvp != NULL && parent_proc->p_flag & P_CONTROLT)
OSBitOrAtomic(P_CONTROLT, &child_proc->p_flag);
session_rele(sessp);
/*
* block all signals to reach the process.
* no transition race should be occuring with the child yet,
* but indicate that the process is in (the creation) transition.
*/
proc_signalstart(child_proc, 0);
proc_transstart(child_proc, 0);
child_proc->p_pcaction = (parent_proc->p_pcaction) & P_PCMAX;
TAILQ_INIT(&child_proc->p_uthlist);
TAILQ_INIT(&child_proc->p_aio_activeq);
TAILQ_INIT(&child_proc->p_aio_doneq);
/* Inherit the parent flags for code sign */
child_proc->p_csflags = parent_proc->p_csflags;
/*
* All processes have work queue locks; cleaned up by
* reap_child_locked()
*/
workqueue_init_lock(child_proc);
/*
* Copy work queue information
*
* Note: This should probably only happen in the case where we are
* creating a child that is a copy of the parent; since this
* routine is called in the non-duplication case of vfork()
* or posix_spawn(), then this information should likely not
* be duplicated.
*
* <rdar://6640553> Work queue pointers that no longer point to code
*/
child_proc->p_wqthread = parent_proc->p_wqthread;
child_proc->p_threadstart = parent_proc->p_threadstart;
child_proc->p_pthsize = parent_proc->p_pthsize;
child_proc->p_targconc = parent_proc->p_targconc;
if ((parent_proc->p_lflag & P_LREGISTER) != 0) {
child_proc->p_lflag |= P_LREGISTER;
}
child_proc->p_dispatchqueue_offset = parent_proc->p_dispatchqueue_offset;
#if PSYNCH
pth_proc_hashinit(child_proc);
#endif /* PSYNCH */
#if CONFIG_LCTX
child_proc->p_lctx = NULL;
/* Add new process to login context (if any). */
if (parent_proc->p_lctx != NULL) {
/*
* <rdar://6640564> This should probably be delayed in the
* vfork() or posix_spawn() cases.
*/
LCTX_LOCK(parent_proc->p_lctx);
enterlctx(child_proc, parent_proc->p_lctx, 0);
}
#endif
bad:
return(child_proc);
}
/*
* Device close routine
*/
int
spec_close(struct vnop_close_args *ap)
{
struct vnode *vp = ap->a_vp;
dev_t dev = vp->v_rdev;
int (*devclose)(dev_t, int, int, struct proc *);
int mode, error;
int flags = ap->a_fflag;
struct proc *p = vfs_context_proc(ap->a_context);
struct session *sessp;
switch (vp->v_type) {
case VCHR:
/*
* Hack: a tty device that is a controlling terminal
* has a reference from the session structure.
* We cannot easily tell that a character device is
* a controlling terminal, unless it is the closing
* process' controlling terminal. In that case,
* if the reference count is 1 (this is the very
* last close)
*/
sessp = proc_session(p);
if (sessp != SESSION_NULL) {
if ((vcount(vp) == 1) &&
(vp == sessp->s_ttyvp)) {
session_lock(sessp);
sessp->s_ttyvp = NULL;
sessp->s_ttyvid = 0;
sessp->s_ttyp = TTY_NULL;
sessp->s_ttypgrpid = NO_PID;
session_unlock(sessp);
vnode_rele(vp);
}
session_rele(sessp);
}
devclose = cdevsw[major(dev)].d_close;
mode = S_IFCHR;
/*
* close on last reference or on vnode revoke call
*/
if ((flags & IO_REVOKE) != 0)
break;
if (vcount(vp) > 0)
return (0);
break;
case VBLK:
/*
* Since every use (buffer, vnode, swap, blockmap)
* holds a reference to the vnode, and because we mark
* any other vnodes that alias this device, when the
* sum of the reference counts on all the aliased
* vnodes descends to zero, we are on last close.
*/
if (vcount(vp) > 0)
return (0);
/*
* On last close of a block device (that isn't mounted)
* we must invalidate any in core blocks, so that
* we can, for instance, change floppy disks.
*/
if ((error = spec_fsync_internal(vp, MNT_WAIT, ap->a_context)))
return (error);
error = buf_invalidateblks(vp, BUF_WRITE_DATA, 0, 0);
if (error)
return (error);
devclose = bdevsw[major(dev)].d_close;
mode = S_IFBLK;
break;
default:
panic("spec_close: not special");
return(EBADF);
}
return ((*devclose)(dev, flags, mode, p));
}
int
cttyopen(dev_t dev, int flag, __unused int mode, proc_t p)
{
vnode_t ttyvp = cttyvp(p);
struct vfs_context context;
int error = 0;
int cttyflag, doclose = 0;
struct session *sessp;
if (ttyvp == NULL)
return (ENXIO);
context.vc_thread = current_thread();
context.vc_ucred = kauth_cred_proc_ref(p);
sessp = proc_session(p);
session_lock(sessp);
cttyflag = sessp->s_flags & S_CTTYREF;
session_unlock(sessp);
/*
* A little hack--this device, used by many processes,
* happens to do an open on another device, which can
* cause unhappiness if the second-level open blocks indefinitely
* (as could be the case if the master side has hung up). Since
* we know that this driver doesn't care about the serializing
* opens and closes, we can drop the lock. To avoid opencount leak,
* open the vnode only for the first time.
*/
if (cttyflag == 0) {
devsw_unlock(dev, S_IFCHR);
error = VNOP_OPEN(ttyvp, flag, &context);
devsw_lock(dev, S_IFCHR);
if (error)
goto out;
/*
* If S_CTTYREF is set, some other thread did an open
* and was able to set the flag, now perform a close, else
* set the flag.
*/
session_lock(sessp);
if (cttyflag == (sessp->s_flags & S_CTTYREF))
sessp->s_flags |= S_CTTYREF;
else
doclose = 1;
session_unlock(sessp);
/*
* We have to take a reference here to make sure a close
* gets called during revoke. Note that once a controlling
* tty gets opened by this driver, the only way close will
* get called is when the session leader , whose controlling
* tty is ttyvp, exits and vnode is revoked. We cannot
* redirect close from this driver because underlying controlling
* terminal might change and close may get redirected to a
* wrong vnode causing panic.
*/
if (doclose) {
devsw_unlock(dev, S_IFCHR);
VNOP_CLOSE(ttyvp, flag, &context);
devsw_lock(dev, S_IFCHR);
} else {
error = vnode_ref(ttyvp);
}
}
out:
session_rele(sessp);
vnode_put(ttyvp);
kauth_cred_unref(&context.vc_ucred);
return (error);
}
/*
* Write out process accounting information, on process exit.
* Data to be written out is specified in Leffler, et al.
* and are enumerated below. (They're also noted in the system
* "acct.h" header file.)
*/
int
acct_process(proc_t p)
{
struct acct an_acct;
struct rusage rup, *r;
struct timeval ut, st, tmp;
int t;
int error;
struct vnode *vp;
kauth_cred_t safecred;
struct session * sessp;
boolean_t fstate;
/* If accounting isn't enabled, don't bother */
vp = acctp;
if (vp == NULLVP)
return (0);
/*
* Get process accounting information.
*/
/* (1) The name of the command that ran */
bcopy(p->p_comm, an_acct.ac_comm, sizeof an_acct.ac_comm);
/* (2) The amount of user and system time that was used */
calcru(p, &ut, &st, NULL);
an_acct.ac_utime = encode_comp_t(ut.tv_sec, ut.tv_usec);
an_acct.ac_stime = encode_comp_t(st.tv_sec, st.tv_usec);
/* (3) The elapsed time the commmand ran (and its starting time) */
an_acct.ac_btime = p->p_start.tv_sec;
microtime(&tmp);
timevalsub(&tmp, &p->p_start);
an_acct.ac_etime = encode_comp_t(tmp.tv_sec, tmp.tv_usec);
/* (4) The average amount of memory used */
proc_lock(p);
rup = p->p_stats->p_ru;
proc_unlock(p);
r = &rup;
tmp = ut;
timevaladd(&tmp, &st);
t = tmp.tv_sec * hz + tmp.tv_usec / tick;
if (t)
an_acct.ac_mem = (r->ru_ixrss + r->ru_idrss + r->ru_isrss) / t;
else
an_acct.ac_mem = 0;
/* (5) The number of disk I/O operations done */
an_acct.ac_io = encode_comp_t(r->ru_inblock + r->ru_oublock, 0);
/* (6) The UID and GID of the process */
safecred = kauth_cred_proc_ref(p);
an_acct.ac_uid = safecred->cr_ruid;
an_acct.ac_gid = safecred->cr_rgid;
/* (7) The terminal from which the process was started */
sessp = proc_session(p);
if ((p->p_flag & P_CONTROLT) && (sessp != SESSION_NULL) && (sessp->s_ttyp != TTY_NULL)) {
fstate = thread_funnel_set(kernel_flock, TRUE);
an_acct.ac_tty = sessp->s_ttyp->t_dev;
(void) thread_funnel_set(kernel_flock, fstate);
}else
an_acct.ac_tty = NODEV;
if (sessp != SESSION_NULL)
session_rele(sessp);
/* (8) The boolean flags that tell how the process terminated, etc. */
an_acct.ac_flag = p->p_acflag;
/*
* Now, just write the accounting information to the file.
*/
if ((error = vnode_getwithref(vp)) == 0) {
error = vn_rdwr(UIO_WRITE, vp, (caddr_t)&an_acct, sizeof (an_acct),
(off_t)0, UIO_SYSSPACE32, IO_APPEND|IO_UNIT, safecred,
(int *)0, p);
vnode_put(vp);
}
kauth_cred_unref(&safecred);
return (error);
}
