usr/src/uts/common/sys/session.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  * Copyright 2006 Sun Microsystems, Inc.  All rights reserved.
  23  * Use is subject to license terms.
  24  */
  25
  26 /*      Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
  27 /*        All Rights Reserved   */
  28
  29
  30 #ifndef _SYS_SESSION_H
  31 #define _SYS_SESSION_H
  32
  33 #pragma ident   "%Z%%M% %I%     %E% SMI"
  34
  35 #ifdef  __cplusplus
  36 extern "C" {
  37 #endif
  38
  39 /*
  40  * Session structure overview.
  41  *
  42  * Currently, the only structure in the kernel which has a pointer to a
  43  * session structures is the proc_t via the p_sessp pointer.  To
  44  * access a session proc_t->p_sessp pointer a caller must hold either
  45  * pidlock or p_splock.  These locks only protect the p_sessp pointer
  46  * itself and do not protect any of the contents of the session structure.
  47  * To prevent the contents of a the session structure from changing the
  48  * caller must grab s_lock.
  49  *
  50  * No callers should ever update the contents of the session structure
  51  * directly.  Only the session management code should ever modify the
  52  * contents of the session structure.  When the session code attempts
  53  * to modify the contents of a session structure it must hold multiple
  54  * locks.  The locking order for all the locks that may need to be
  55  * acquired is:
  56  *      sd_lock -> pidlock -> p_splock -> s_lock
  57  *
  58  * If a caller requires access to a session structure for long
  59  * periods of time or across operations that may block it should
  60  * use the tty_hold() and sess_hold() interfaces.
  61  *
  62  * sess_hold() returns a pointer to a session structure associated
  63  * with the proc_t that was passed in.  It also increments the reference
  64  * count associated with that session structure to ensure that it
  65  * can't be freed until after the caller is done with it and calls
  66  * sess_rele().  This hold doesn't actually protect any of the
  67  * contents of the session structure.
  68  *
  69  * tty_hold() returns a pointer to a session structure associated
  70  * with the curproc.  It also "locks" the contents of the session
  71  * structure.  This hold should be used when the caller will be
  72  * doing operations on a controlling tty associated with the session.
  73  * This operation doesn an implicit sess_hold() so that the session
  74  * structure can't be free'd until after the caller is done with it
  75  * and invokes tty_rele().
  76  *
  77  * NOTE: Neither of these functions (sess_hold() or tty_hold())
  78  * prevent a process from changing its session.  Once these functions
  79  * return a session pointer, that session pointer may no longer be
  80  * associated with the current process.  If a caller wants to prevent
  81  * a process from changing its session then it must hold pidlock or
  82  * p_splock.
  83  */
  84
  85 typedef struct sess {
  86         struct pid *s_sidp;             /* session ID info, never changes */
  87
  88         kmutex_t s_lock;                /* protects everything below */
  89         uint_t s_ref;                   /* reference count */
  90         boolean_t s_sighuped;           /* ctty had sighup sent to it */
  91
  92         boolean_t s_exit;               /* sesion leader is exiting */
  93         kcondvar_t s_exit_cv;           /* Condvar for s_exit */
  94
  95         int s_cnt;                      /* active users of this ctty */
  96         kcondvar_t s_cnt_cv;            /* Condvar for s_cnt */
  97
  98         /*
  99          * The following fields can only be updated while s_lock is held
 100          * and s_cnt is 0.  (ie, no one has a tty_hold() on this session.)
 101          */
 102         dev_t s_dev;                    /* tty's device number */
 103         struct vnode *s_vp;             /* tty's vnode */
 104         struct cred *s_cred;            /* allocation credentials */
 105 } sess_t;
 106
 107 #define s_sid s_sidp->pid_id
 108
 109 #if defined(_KERNEL)
 110
 111 extern sess_t session0;
 112
 113 /* forward referenced structure tags */
 114 struct vnode;
 115 struct proc;
 116 struct stdata;
 117
 118 extern void sess_hold(proc_t *p);
 119 extern void sess_rele(sess_t *, boolean_t);
 120 extern sess_t *tty_hold(void);
 121 extern void tty_rele(sess_t *sp);
 122
 123
 124 extern void sess_create(void);
 125 extern int strctty(struct stdata *);
 126 extern int freectty(boolean_t);
 127 extern dev_t cttydev(struct proc *);
 128 extern void ctty_clear_sighuped(void);
 129
 130 #endif /* defined(_KERNEL) */
 131
 132 #ifdef  __cplusplus
 133 }
 134 #endif
 135
 136 #endif  /* _SYS_SESSION_H */