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