usr/src/uts/common/fs/portfs/port_vnops.c

   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 /*
  23  * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
  24  * Use is subject to license terms.
  25  */
  26
  27 /*
  28  * Copyright (c) 2014, Joyent, Inc.  All rights reserved.
  29  */
  30
  31 #include <sys/types.h>
  32 #include <sys/vnode.h>
  33 #include <sys/vfs_opreg.h>
  34 #include <sys/kmem.h>
  35 #include <fs/fs_subr.h>
  36 #include <sys/proc.h>
  37 #include <sys/kstat.h>
  38 #include <sys/port_impl.h>
  39
  40 /* local functions */
  41 static int port_open(struct vnode **, int, cred_t *, caller_context_t *);
  42 static int port_close(struct vnode *, int, int, offset_t, cred_t *,
  43         caller_context_t *);
  44 static int port_getattr(struct vnode *, struct vattr *, int, cred_t *,
  45         caller_context_t *);
  46 static int port_access(struct vnode *, int, int, cred_t *, caller_context_t *);
  47 static int port_realvp(vnode_t *, vnode_t **, caller_context_t *);
  48 static int port_poll(vnode_t *, short, int, short *, struct pollhead **,
  49         caller_context_t *);
  50 static void port_inactive(struct vnode *, cred_t *, caller_context_t *);
  51
  52 const fs_operation_def_t port_vnodeops_template[] = {
  53         VOPNAME_OPEN,           { .vop_open = port_open },
  54         VOPNAME_CLOSE,          { .vop_close = port_close },
  55         VOPNAME_GETATTR,        { .vop_getattr = port_getattr },
  56         VOPNAME_ACCESS,         { .vop_access = port_access },
  57         VOPNAME_INACTIVE,       { .vop_inactive = port_inactive },
  58         VOPNAME_FRLOCK,         { .error = fs_error },
  59         VOPNAME_REALVP,         { .vop_realvp = port_realvp },
  60         VOPNAME_POLL,           { .vop_poll = port_poll },
  61         VOPNAME_PATHCONF,       { .error = fs_error },
  62         VOPNAME_DISPOSE,        { .error = fs_error },
  63         VOPNAME_GETSECATTR,     { .error = fs_error },
  64         VOPNAME_SHRLOCK,        { .error = fs_error },
  65         NULL,                   NULL
  66 };
  67
  68 /* ARGSUSED */
  69 static int
  70 port_open(struct vnode **vpp, int flag, cred_t *cr, caller_context_t *ct)
  71 {
  72         return (0);
  73 }
  74
  75 /*
  76  * port_discard_events() scans the port event queue for events owned
  77  * by current proc. Non-shareable events will be discarded, all other
  78  * events remain in the event queue.
  79  */
  80 void
  81 port_discard_events(port_queue_t *portq)
  82 {
  83         port_kevent_t   *kevp;
  84         pid_t           pid = curproc->p_pid;
  85
  86         /*
  87          * The call to port_block() is required to avoid interaction
  88          * with other threads in port_get(n).
  89          */
  90         mutex_enter(&portq->portq_mutex);
  91         port_block(portq);
  92         port_push_eventq(portq);        /* empty temporary queue */
  93         kevp = list_head(&portq->portq_list);
  94         while (kevp) {
  95                 if (kevp->portkev_pid == pid) {
  96                         /* own event, check if it is shareable */
  97                         if (kevp->portkev_flags & PORT_KEV_NOSHARE)
  98                                 kevp->portkev_flags |= PORT_KEV_FREE;
  99                 }
 100                 kevp = list_next(&portq->portq_list, kevp);
 101         }
 102         port_unblock(portq);
 103         mutex_exit(&portq->portq_mutex);
 104 }
 105
 106 /*
 107  * Called from port_close().
 108  * Free all kernel events structures which are still in the event queue.
 109  */
 110 static void
 111 port_close_events(port_queue_t *portq)
 112 {
 113         port_kevent_t   *pkevp;
 114         int             events;         /* ignore events */
 115
 116         mutex_enter(&portq->portq_mutex);
 117         while (pkevp = list_head(&portq->portq_list)) {
 118                 portq->portq_nent--;
 119                 list_remove(&portq->portq_list, pkevp);
 120                 if (pkevp->portkev_callback) {
 121                         (void) (*pkevp->portkev_callback)(pkevp->portkev_arg,
 122                             &events, pkevp->portkev_pid, PORT_CALLBACK_CLOSE,
 123                             pkevp);
 124                 }
 125                 mutex_exit(&portq->portq_mutex);
 126                 port_free_event_local(pkevp, 0);
 127                 mutex_enter(&portq->portq_mutex);
 128         }
 129
 130         /*
 131          * Wait for any thread in pollwakeup(), accessing this port to
 132          * finish.
 133          */
 134         while (portq->portq_flags & PORTQ_POLLWK_PEND) {
 135                 cv_wait(&portq->portq_closecv, &portq->portq_mutex);
 136         }
 137         mutex_exit(&portq->portq_mutex);
 138 }
 139
 140 /*
 141  * The port_close() function is called from standard close(2) when
 142  * the file descriptor is of type S_IFPORT/VPORT.
 143  * Port file descriptors behave like standard file descriptors. It means,
 144  * the port file/vnode is only destroyed on last close.
 145  * If the reference counter is > 1 then
 146  * - sources associated with the port will be notified about the close,
 147  * - objects associated with the port will be dissociated,
 148  * - pending and delivered events will be discarded.
 149  * On last close all references and caches will be removed. The vnode itself
 150  * will be destroyed with VOP_RELE().
 151  */
 152 /* ARGSUSED */
 153 static int
 154 port_close(struct vnode *vp, int flag, int count, offset_t offset, cred_t *cr,
 155     caller_context_t *ct)
 156 {
 157         port_t          *pp;
 158         port_queue_t    *portq;
 159         port_source_t   *ps;
 160         port_source_t   *ps_next;
 161         int             source;
 162
 163         pp = VTOEP(vp);
 164         mutex_enter(&pp->port_mutex);
 165         if (pp->port_flags & PORT_CLOSED) {
 166                 mutex_exit(&pp->port_mutex);
 167                 return (0);
 168         }
 169         mutex_exit(&pp->port_mutex);
 170
 171         portq = &pp->port_queue;
 172         if (count > 1) {
 173                 /*
 174                  * It is not the last close.
 175                  * Remove/free all event resources owned by the current proc
 176                  * First notify all with the port associated sources about the
 177                  * close(2). The last argument of the close callback function
 178                  * advises the source about the type of of the close.
 179                  * If the port was set in alert mode by the curren process then
 180                  * remove the alert mode.
 181                  */
 182
 183                 /* check alert mode of the port */
 184                 mutex_enter(&portq->portq_mutex);
 185                 if ((portq->portq_flags & PORTQ_ALERT) &&
 186                     (portq->portq_alert.portal_pid == curproc->p_pid))
 187                         portq->portq_flags &= ~PORTQ_ALERT;
 188                 mutex_exit(&portq->portq_mutex);
 189
 190                 /* notify all event sources about port_close() */
 191                 mutex_enter(&portq->portq_source_mutex);
 192                 for (source = 0; source < PORT_SCACHE_SIZE; source++) {
 193                         ps = portq->portq_scache[PORT_SHASH(source)];
 194                         for (; ps != NULL; ps = ps->portsrc_next) {
 195                                 if (ps->portsrc_close != NULL)
 196                                         (*ps->portsrc_close)
 197                                             (ps->portsrc_closearg, pp->port_fd,
 198                                             curproc->p_pid, 0);
 199                         }
 200                 }
 201                 mutex_exit(&portq->portq_source_mutex);
 202                 port_discard_events(&pp->port_queue);
 203                 return (0);
 204         }
 205
 206         /*
 207          * We are executing the last close of the port -> discard everything
 208          * Make sure that all threads/processes accessing this port leave
 209          * the kernel immediately.
 210          */
 211
 212         mutex_enter(&portq->portq_mutex);
 213         portq->portq_flags |= PORTQ_CLOSE;
 214         while (portq->portq_thrcnt > 0) {
 215                 if (portq->portq_thread != NULL)
 216                         cv_signal(&portq->portq_thread->portget_cv);
 217                 cv_wait(&portq->portq_closecv, &portq->portq_mutex);
 218         }
 219         mutex_exit(&portq->portq_mutex);
 220
 221         /*
 222          * Send "last close" message to associated sources.
 223          * - new event allocation requests are being denied since uf_file entry
 224          *   was set to NULL in closeandsetf().
 225          * - all still allocated event structures must be returned to the
 226          *   port immediately:
 227          *      - call port_free_event(*event) or
 228          *      - call port_send_event(*event) to complete event operations
 229          *        which need activities in a dedicated process environment.
 230          * The port_close() function waits until all allocated event structures
 231          * are delivered back to the port.
 232          */
 233
 234         mutex_enter(&portq->portq_source_mutex);
 235         for (source = 0; source < PORT_SCACHE_SIZE; source++) {
 236                 ps = portq->portq_scache[PORT_SHASH(source)];
 237                 for (; ps != NULL; ps = ps_next) {
 238                         ps_next = ps->portsrc_next;
 239                         if (ps->portsrc_close != NULL)
 240                                 (*ps->portsrc_close)(ps->portsrc_closearg,
 241                                     pp->port_fd, curproc->p_pid, 1);
 242                         kmem_free(ps, sizeof (port_source_t));
 243                 }
 244         }
 245         kmem_free(portq->portq_scache,
 246             PORT_SCACHE_SIZE * sizeof (port_source_t *));
 247         portq->portq_scache = NULL;
 248         mutex_exit(&portq->portq_source_mutex);
 249
 250         mutex_enter(&portq->portq_mutex);
 251         /* Wait for outstanding events */
 252         while (pp->port_curr > portq->portq_nent)
 253                 cv_wait(&portq->portq_closecv, &portq->portq_mutex);
 254         mutex_exit(&portq->portq_mutex);
 255
 256         /*
 257          * If PORT_SOURCE_FD objects were not associated with the port then
 258          * it is necessary to free the port_fdcache structure here.
 259          */
 260
 261         if (portq->portq_pcp != NULL) {
 262                 mutex_destroy(&portq->portq_pcp->pc_lock);
 263                 kmem_free(portq->portq_pcp, sizeof (port_fdcache_t));
 264                 portq->portq_pcp = NULL;
 265         }
 266
 267         /*
 268          * Now all events are passed back to the port,
 269          * discard remaining events in the port queue
 270          */
 271
 272         port_close_events(portq);
 273         return (0);
 274 }
 275
 276 /*
 277  * The port_poll() function is the VOP_POLL() entry of event ports.
 278  * Event ports return:
 279  * POLLIN  : events are available in the event queue
 280  * POLLOUT : event queue can still accept events
 281  */
 282 /*ARGSUSED*/
 283 static int
 284 port_poll(vnode_t *vp, short events, int anyyet, short *reventsp,
 285     struct pollhead **phpp, caller_context_t *ct)
 286 {
 287         port_t          *pp;
 288         port_queue_t    *portq;
 289         short           levents;
 290
 291         pp = VTOEP(vp);
 292         portq = &pp->port_queue;
 293         levents = 0;
 294         mutex_enter(&portq->portq_mutex);
 295         if (portq->portq_nent)
 296                 levents = POLLIN;
 297         if (pp->port_curr < pp->port_max_events)
 298                 levents |= POLLOUT;
 299         levents &= events;
 300         *reventsp = levents;
 301         if ((levents == 0 && !anyyet) || (events & POLLET)) {
 302                 *phpp = &pp->port_pollhd;
 303                 portq->portq_flags |= events & POLLIN ? PORTQ_POLLIN : 0;
 304                 portq->portq_flags |= events & POLLOUT ? PORTQ_POLLOUT : 0;
 305         }
 306         mutex_exit(&portq->portq_mutex);
 307         return (0);
 308 }
 309
 310
 311 /* ARGSUSED */
 312 static int
 313 port_getattr(struct vnode *vp, struct vattr *vap, int flags, cred_t *cr,
 314     caller_context_t *ct)
 315 {
 316         port_t  *pp;
 317         extern dev_t portdev;
 318
 319         pp = VTOEP(vp);
 320
 321         vap->va_type = vp->v_type;      /* vnode type (for create) */
 322         vap->va_mode = 0;               /* file access mode */
 323         vap->va_uid = pp->port_uid;     /* owner user id */
 324         vap->va_gid = pp->port_gid;     /* owner group id */
 325         vap->va_fsid = portdev;         /* file system id  */
 326         vap->va_nodeid = (ino64_t)0;    /* node id */
 327         vap->va_nlink = vp->v_count;    /* number of references to file */
 328         vap->va_size = (u_offset_t)pp->port_queue.portq_nent; /* file size */
 329         vap->va_atime = pp->port_ctime; /* time of last access */
 330         vap->va_mtime = pp->port_ctime; /* time of last modification */
 331         vap->va_ctime = pp->port_ctime; /* time file ``created'' */
 332         vap->va_rdev = portdev;         /* device the file represents */
 333         vap->va_blksize = 0;            /* fundamental block size */
 334         vap->va_nblocks = (fsblkcnt64_t)0;      /* # of blocks allocated */
 335         vap->va_seq = 0;                /* sequence number */
 336
 337         return (0);
 338 }
 339
 340 /*
 341  * Destroy the port.
 342  */
 343 /* ARGSUSED */
 344 static void
 345 port_inactive(struct vnode *vp, cred_t *cr, caller_context_t *ct)
 346 {
 347         port_t  *pp = VTOEP(vp);
 348         extern  port_kstat_t port_kstat;
 349
 350         mutex_enter(&port_control.pc_mutex);
 351         port_control.pc_nents--;
 352         curproc->p_portcnt--;
 353         port_kstat.pks_ports.value.ui32--;
 354         mutex_exit(&port_control.pc_mutex);
 355         vn_free(vp);
 356         mutex_destroy(&pp->port_mutex);
 357         mutex_destroy(&pp->port_queue.portq_mutex);
 358         mutex_destroy(&pp->port_queue.portq_source_mutex);
 359         kmem_free(pp, sizeof (port_t));
 360 }
 361
 362 /* ARGSUSED */
 363 static int
 364 port_access(struct vnode *vp, int mode, int flags, cred_t *cr,
 365     caller_context_t *ct)
 366 {
 367         return (0);
 368 }
 369
 370 /* ARGSUSED */
 371 static int
 372 port_realvp(vnode_t *vp, vnode_t **vpp, caller_context_t *ct)
 373 {
 374         *vpp = vp;
 375         return (0);
 376 }