/*
 * 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 (c) 1984, 1986, 1987, 1988, 1989 AT&T */
/*        All Rights Reserved   */


/*
 * Copyright 2005 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#include <sys/types.h>
#include <sys/sysmacros.h>
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/cred.h>
#include <sys/vnode.h>
#include <sys/errno.h>
#include <sys/user.h>
#include <sys/mount.h>
#include <sys/proc.h>
#include <sys/signal.h>
#include <sys/siginfo.h>
#include <sys/ucontext.h>
#include <sys/prsystm.h>
#include <sys/session.h>
#include <sys/stream.h>
#include <sys/strsubr.h>
#include <sys/debug.h>

/*
 * Return 1 if process pointed to by 'cp' has a parent that would
 * prevent its process group from being orphaned, 0 otherwise
 */

static int
pglinked(cp)
        register proc_t *cp;
{
        register proc_t *pp;

        ASSERT(MUTEX_HELD(&pidlock));

        if ((pp = cp->p_parent) != NULL &&
            pp->p_pgidp != cp->p_pgidp &&
            pp->p_sessp == cp->p_sessp)
                return (1);
        return (0);
}

/*
 * Send the specified signal to all processes whose process group ID is
 * equal to 'pgid'
 */

void
pgsignal(pidp, sig)
        register struct pid *pidp;
        int sig;
{
        register proc_t *prp;

        mutex_enter(&pidlock);
        for (prp = pidp->pid_pglink; prp; prp = prp->p_pglink) {
                mutex_enter(&prp->p_lock);
                sigtoproc(prp, NULL, sig);
                mutex_exit(&prp->p_lock);
        }
        mutex_exit(&pidlock);
}

/*
 * similiar to pgsignal in function except that pidlock mutex is assumed
 * to be held by the caller.
 */
void
sigtopg(pidp, sig)
        register struct pid *pidp;
        int sig;
{
        register proc_t *prp;

        ASSERT(MUTEX_HELD(&pidlock));

        for (prp = pidp->pid_pglink; prp; prp = prp->p_pglink) {
                mutex_enter(&prp->p_lock);
                sigtoproc(prp, NULL, sig);
                mutex_exit(&prp->p_lock);
        }
}

/*
 * Add a process to a process group
 */

void
pgjoin(p, pgp)
        register proc_t *p;
        register struct pid *pgp;
{
        ASSERT(MUTEX_HELD(&pidlock));

        p->p_pgidp = pgp;

        if (pgp->pid_pglink == NULL) {
                ASSERT(pgp->pid_pgtail == NULL);
                p->p_ppglink = NULL;
                p->p_pglink = NULL;
                pgp->pid_pglink = p;
                pgp->pid_pgtail = p;
        } else  {
                ASSERT(pgp->pid_pgtail != NULL);
                if (pglinked(p)) {
                        p->p_ppglink = NULL;
                        p->p_pglink = pgp->pid_pglink;
                        pgp->pid_pglink->p_ppglink = p;
                        pgp->pid_pglink = p;
                } else {
                        p->p_ppglink = pgp->pid_pgtail;
                        p->p_pglink = NULL;
                        pgp->pid_pgtail->p_pglink = p;
                        pgp->pid_pgtail = p;
                }
        }

        if (pgp->pid_pglink == pgp->pid_pgtail) {
                PID_HOLD(pgp);
                if (pglinked(p))
                        pgp->pid_pgorphaned = 0;
                else
                        pgp->pid_pgorphaned = 1;
        } else if (pgp->pid_pgorphaned && pglinked(p))
                pgp->pid_pgorphaned = 0;
}

void
pgexit(prp)
        proc_t *prp;
{
        register proc_t *p;
        register struct pid *pgp;

        ASSERT(MUTEX_HELD(&pidlock));

        pgp = prp->p_pgidp;

        if (pgp->pid_pglink == prp) {
                ASSERT(prp->p_ppglink == NULL); /* must be at the front */
                pgp->pid_pglink = prp->p_pglink;
        }
        if (prp->p_ppglink) {
                prp->p_ppglink->p_pglink = prp->p_pglink;
        }
        if (prp->p_pglink) {
                prp->p_pglink->p_ppglink = prp->p_ppglink;
        }
        if (pgp->pid_pgtail == prp) {
                pgp->pid_pgtail = prp->p_ppglink;
        }

        prp->p_pgidp = NULL;
        prp->p_pglink = NULL;
        prp->p_ppglink = NULL;

        if ((p = pgp->pid_pglink) == NULL) {
                PID_RELE(pgp);
        } else if (pgp->pid_pgorphaned == 0) {
                do {
                        if (pglinked(p)) {
                                return;
                        }
                } while ((p = p->p_pglink) != NULL);
                pgp->pid_pgorphaned = 1;
        }
}

/*
 * process 'pp' is exiting - check to see if this will
 * orphan its children's process groups
 */

void
pgdetach(pp)
        proc_t *pp;
{
        int stopped;
        register proc_t *cp;
        register proc_t *mp;
        register struct pid *pgp;

        ASSERT(MUTEX_HELD(&pidlock));

        for (cp = pp->p_child; cp; cp = cp->p_sibling) {
                if ((pgp = cp->p_pgidp)->pid_pgorphaned)
                        continue;
                stopped = 0;
                mp = pgp->pid_pglink;
                ASSERT(mp != NULL);
                for (;;) {
                        if (mp != pp && mp->p_parent != pp && pglinked(mp))
                                break;
                        if (!stopped && mp != curproc) {
                                mutex_enter(&mp->p_lock);
                                stopped = jobstopped(mp);
                                mutex_exit(&mp->p_lock);
                        }
                        if ((mp = mp->p_pglink) == NULL) {
                                pgp->pid_pgorphaned = 1;
                                if (stopped) {
                                        sigtopg(pgp, SIGHUP);
                                        sigtopg(pgp, SIGCONT);
                                }
                                break;
                        }
                }
        }
}

/*
 * Return 1 if pgid is the process group ID of an existing process group
 *      that has members not the process group leader in it.
 *
 * Otherwise, return 0.
 */

int
pgmembers(pgid)
        register pid_t pgid;
{
        register proc_t *prp;

        ASSERT(MUTEX_HELD(&pidlock));

        for (prp = pgfind(pgid); prp; prp = prp->p_pglink)
                if (prp->p_pid != pgid) {
                        return (1);
                }
        return (0);
}