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 2010 Sun Microsystems, Inc.  All rights reserved.
  23  * Use is subject to license terms.
  24  */
  25 
  26 /*
  27  * Copyright (c) 2013, Joyent, Inc. All rights reserved.
  28  */
  29 
  30 /*
  31  * File Events Notification
  32  * ------------------------
  33  *
  34  * The File Events Notification facility provides file and directory change
  35  * notification. It is implemented as an event source(PORT_SOURCE_FILE)
  36  * under the Event Ports framework. Therefore the API is an extension to
  37  * the Event Ports API.
  38  *
  39  * It uses the FEM (File Events Monitoring) framework to intercept
  40  * operations on the files & directories and generate appropriate events.
  41  *
  42  * It provides event notification in accordance with what an application
  43  * can find out by stat`ing the file and comparing time stamps. The various
  44  * system calls that update the file's access, modification, and change
  45  * time stamps are documented in the man page section 2.
  46  *
  47  * It is non intrusive. That is, having an active file event watch on a file
  48  * or directory will not prevent it from being removed or renamed or block an
  49  * unmount operation of the file system where the watched file or directory
  50  * resides.
  51  *
  52  *
  53  * Interface:
  54  * ----------
  55  *
  56  *   The object for this event source is of type 'struct file_obj *'
  57  *
  58  *   The file that needs to be monitored is specified in 'fo_name'.
  59  *   The time stamps collected by a stat(2) call are passed in fo_atime,
  60  *   fo_mtime, fo_ctime. At the time a file events watch is registered, the
  61  *   time stamps passed in are compared with the current time stamps of the
  62  *   file. If it has changed, relevant events are sent immediately. If the time
  63  *   stamps are all '0', they will not be compared.
  64  *
  65  *
  66  * The events are delivered to an event port. A port is created using
  67  * port_create().
  68  *
  69  * To register a file events watch on a file or directory.
  70  *
  71  *   port_associate(int port, PORT_SOURCE_FILE, (uintptr_t)&fobj, events, user)
  72  *
  73  *   'user' is the user pointer to be returned with the event.
  74  *
  75  * To de-register a file events watch,
  76  *
  77  *   port_dissociate(int port, PORT_SOURCE_FILE, (uintptr_t)&fobj)
  78  *
  79  * The events are collected using the port_get()/port_getn() interface. The
  80  * event source will be PORT_SOURCE_FILE.
  81  *
  82  * After an event is delivered, the file events watch gets de-activated. To
  83  * receive the next event, the process will have to re-register the watch and
  84  * activate it by calling port_associate() again. This behavior is intentional
  85  * and supports proper multi threaded programming when using file events
  86  * notification API.
  87  *
  88  *
  89  * Implementation overview:
  90  * ------------------------
  91  *
  92  * Each file events watch is represented by 'portfop_t' in the kernel. A
  93  * cache(in portfop_cache_t) of these portfop_t's are maintained per event
  94  * port by this source. The object here is the pointer to the file_obj
  95  * structure. The portfop_t's are hashed in using the object pointer. Therefore
  96  * it is possible to have multiple file events watches on a file by the same
  97  * process by using different object structure(file_obj_t) and hence can
  98  * receive multiple event notification for a file. These watches can be for
  99  * different event types.
 100  *
 101  * The cached entries of these file objects are retained, even after delivering
 102  * an event, marking them inactive for performance reasons. The assumption
 103  * is that the process would come back and re-register the file to receive
 104  * further events. When there are more then 'port_fop_maxpfps' watches per file
 105  * it will attempt to free the oldest inactive watches.
 106  *
 107  * In case the event that is being delivered is an exception event, the cached
 108  * entries get removed. An exception event on a file or directory means its
 109  * identity got changed(rename to/from, delete, mounted over, file system
 110  * unmount).
 111  *
 112  * If the event port gets closed, all the associated file event watches will be
 113  * removed and discarded.
 114  *
 115  *
 116  * Data structures:
 117  * ----------------
 118  *
 119  * The list of file event watches per file are managed by the data structure
 120  * portfop_vp_t. The first time a file events watch is registered for a file,
 121  * a portfop_vp_t is installed on the vnode_t's member v_fopdata. This gets
 122  * removed and freed only when the vnode becomes inactive. The FEM hooks are
 123  * also installed when the first watch is registered on a file. The FEM hooks
 124  * get un-installed when all the watches are removed.
 125  *
 126  * Each file events watch is represented by the structure portfop_t. They
 127  * get added to a list of portfop_t's on the vnode(portfop_vp_t). After
 128  * delivering an event, the portfop_t is marked inactive but retained. It is
 129  * moved to the end of the list. All the active portfop_t's are maintained at
 130  * the beginning. In case of exception events, the portfop_t will be removed
 131  * and discarded.
 132  *
 133  * To intercept unmount operations, FSEM hooks are added to the file system
 134  * under which files are being watched. A hash table('portfop_vfs_hash_t') of
 135  * active file systems is maintained. Each file system that has active watches
 136  * is represented by 'portfop_vfs_t' and is added to the hash table.
 137  * The vnode's 'portfop_vp_t' structure is added to the list of files(vnodes)
 138  * being watched on the portfop_vfs_t structure.
 139  *
 140  *
 141  * File system support:
 142  * -------------------
 143  *
 144  * The file system implementation has to provide vnode event notifications
 145  * (vnevents) in order to support watching any files on that file system.
 146  * The vnode events(vnevents) are notifications provided by the file system
 147  * for name based file operations like rename, remove etc, which do not go
 148  * thru the VOP_** interfaces. If the file system does not implement vnode
 149  * notifications, watching for file events on such file systems is not
 150  * supported. The vnode event notifications support is determined by the call
 151  * vnevent_support(vp) (VOP_VNEVENT(vp, VE_SUPPORT)), which the file system
 152  * has to implement.
 153  *
 154  *
 155  * Locking order:
 156  * --------------
 157  *
 158  * A file(vnode) can have file event watches registered by different processes.
 159  * There is one portfop_t per watch registered. These are on the vnode's list
 160  * protected by the mutex 'pvp_mutex' in 'portfop_vp_t'. The portfop_t's are
 161  * also on the per port cache. The cache is protected by the pfc_lock of
 162  * portfop_cache_t. The lock order here is 'pfc_lock' -> 'pvp_mutex'.
 163  *
 164  */
 165 
 166 #include <sys/types.h>
 167 #include <sys/systm.h>
 168 #include <sys/stat.h>
 169 #include <sys/errno.h>
 170 #include <sys/kmem.h>
 171 #include <sys/sysmacros.h>
 172 #include <sys/debug.h>
 173 #include <sys/vnode.h>
 174 #include <sys/poll_impl.h>
 175 #include <sys/port_impl.h>
 176 #include <sys/fem.h>
 177 #include <sys/vfs_opreg.h>
 178 #include <sys/atomic.h>
 179 #include <sys/mount.h>
 180 #include <sys/mntent.h>
 181 
 182 /*
 183  * For special case support of mnttab (/etc/mnttab).
 184  */
 185 extern struct vnode *vfs_mntdummyvp;
 186 extern int mntfstype;
 187 
 188 #define PORTFOP_PVFSH(vfsp)     (&portvfs_hash[PORTFOP_PVFSHASH(vfsp)])
 189 portfop_vfs_hash_t       portvfs_hash[PORTFOP_PVFSHASH_SZ];
 190 
 191 #define PORTFOP_NVP     20
 192 /*
 193  * Inactive file event watches(portfop_t) are retained on the vnode's list
 194  * for performance reason. If the applications re-registers the file, the
 195  * inactive entry is made active and moved up the list.
 196  *
 197  * If there are greater then the following number of watches on a vnode,
 198  * it will attempt to discard an oldest inactive watch(pfp) at the time
 199  * a new watch is being registered and when events get delivered. We
 200  * do this to avoid accumulating inactive watches on a file.
 201  */
 202 int     port_fop_maxpfps = 20;
 203 
 204 /* local functions */
 205 static int      port_fop_callback(void *, int *, pid_t, int, void *);
 206 
 207 static void     port_pcache_insert(portfop_cache_t *, portfop_t *);
 208 static void     port_pcache_delete(portfop_cache_t *, portfop_t *);
 209 static void     port_close_fop(void *arg, int port, pid_t pid, int lastclose);
 210 
 211 /*
 212  * port fop functions that will be the fem hooks.
 213  */
 214 static int port_fop_open(femarg_t *vf, int mode, cred_t *cr,
 215     caller_context_t *);
 216 static int port_fop_read(femarg_t *vf, uio_t *uiop, int ioflag, cred_t *cr,
 217     struct caller_context *ct);
 218 static int port_fop_write(femarg_t *vf, uio_t *uiop, int ioflag, cred_t *cr,
 219     caller_context_t *ct);
 220 static int port_fop_map(femarg_t *vf, offset_t off, struct as *as,
 221     caddr_t *addrp, size_t len, uchar_t prot, uchar_t maxport,
 222     uint_t flags, cred_t *cr, caller_context_t *ct);
 223 static int port_fop_setattr(femarg_t *vf, vattr_t *vap, int flags, cred_t *cr,
 224     caller_context_t *ct);
 225 static int port_fop_create(femarg_t *vf, char *name, vattr_t *vap,
 226     vcexcl_t excl, int mode, vnode_t **vpp, cred_t *cr, int flag,
 227     caller_context_t *ct, vsecattr_t *vsecp);
 228 static int port_fop_remove(femarg_t *vf, char *nm, cred_t *cr,
 229     caller_context_t *ct, int flags);
 230 static int port_fop_link(femarg_t *vf, vnode_t *svp, char *tnm, cred_t *cr,
 231     caller_context_t *ct, int flags);
 232 static int port_fop_rename(femarg_t *vf, char *snm, vnode_t *tdvp, char *tnm,
 233     cred_t *cr, caller_context_t *ct, int flags);
 234 static int port_fop_mkdir(femarg_t *vf, char *dirname, vattr_t *vap,
 235     vnode_t **vpp, cred_t *cr, caller_context_t *ct, int flags,
 236     vsecattr_t *vsecp);
 237 static int port_fop_rmdir(femarg_t *vf, char *nm, vnode_t *cdir, cred_t *cr,
 238     caller_context_t *ct, int flags);
 239 static int port_fop_readdir(femarg_t *vf, uio_t *uiop, cred_t *cr, int *eofp,
 240     caller_context_t *ct, int flags);
 241 static int port_fop_symlink(femarg_t *vf, char *linkname, vattr_t *vap,
 242     char *target, cred_t *cr, caller_context_t *ct, int flags);
 243 static int port_fop_setsecattr(femarg_t *vf, vsecattr_t *vsap, int flag,
 244     cred_t *cr, caller_context_t *ct);
 245 
 246 static int port_fop_vnevent(femarg_t *vf, vnevent_t vnevent, vnode_t *dvp,
 247     char *cname, caller_context_t *ct);
 248 
 249 static int port_fop_unmount(fsemarg_t *vf, int flag, cred_t *cr);
 250 
 251 
 252 /*
 253  * Fem hooks.
 254  */
 255 const fs_operation_def_t        port_vnodesrc_template[] = {
 256         VOPNAME_OPEN,           { .femop_open = port_fop_open },
 257         VOPNAME_READ,           { .femop_read = port_fop_read },
 258         VOPNAME_WRITE,          { .femop_write = port_fop_write },
 259         VOPNAME_MAP,            { .femop_map = port_fop_map },
 260         VOPNAME_SETATTR,        { .femop_setattr = port_fop_setattr },
 261         VOPNAME_CREATE,         { .femop_create = port_fop_create },
 262         VOPNAME_REMOVE,         { .femop_remove = port_fop_remove },
 263         VOPNAME_LINK,           { .femop_link = port_fop_link },
 264         VOPNAME_RENAME,         { .femop_rename = port_fop_rename },
 265         VOPNAME_MKDIR,          { .femop_mkdir = port_fop_mkdir },
 266         VOPNAME_RMDIR,          { .femop_rmdir = port_fop_rmdir },
 267         VOPNAME_READDIR,        { .femop_readdir = port_fop_readdir },
 268         VOPNAME_SYMLINK,        { .femop_symlink = port_fop_symlink },
 269         VOPNAME_SETSECATTR,     { .femop_setsecattr = port_fop_setsecattr },
 270         VOPNAME_VNEVENT,        { .femop_vnevent = port_fop_vnevent },
 271         NULL,   NULL
 272 };
 273 
 274 /*
 275  * Fsem - vfs ops hooks
 276  */
 277 const fs_operation_def_t        port_vfssrc_template[] = {
 278         VFSNAME_UNMOUNT,        { .fsemop_unmount = port_fop_unmount },
 279         NULL,   NULL
 280 };
 281 
 282 fem_t *fop_femop;
 283 fsem_t *fop_fsemop;
 284 
 285 static fem_t *
 286 port_fop_femop()
 287 {
 288         fem_t *femp;
 289         if (fop_femop != NULL)
 290                 return (fop_femop);
 291         if (fem_create("portfop_fem",
 292             (const struct fs_operation_def *)port_vnodesrc_template,
 293             (fem_t **)&femp)) {
 294                 return (NULL);
 295         }
 296         if (casptr(&fop_femop, NULL, femp) != NULL) {
 297                 /*
 298                  * some other thread beat us to it.
 299                  */
 300                 fem_free(femp);
 301         }
 302         return (fop_femop);
 303 }
 304 
 305 static fsem_t *
 306 port_fop_fsemop()
 307 {
 308         fsem_t *fsemp;
 309         if (fop_fsemop != NULL)
 310                 return (fop_fsemop);
 311         if (fsem_create("portfop_fsem", port_vfssrc_template, &fsemp)) {
 312                 return (NULL);
 313         }
 314         if (casptr(&fop_fsemop, NULL, fsemp) != NULL) {
 315                 /*
 316                  * some other thread beat us to it.
 317                  */
 318                 fsem_free(fsemp);
 319         }
 320         return (fop_fsemop);
 321 }
 322 
 323 /*
 324  * port_fop_callback()
 325  * - PORT_CALLBACK_DEFAULT
 326  *      The file event will be delivered to the application.
 327  * - PORT_CALLBACK_DISSOCIATE
 328  *      The object will be dissociated from  the port.
 329  * - PORT_CALLBACK_CLOSE
 330  *      The object will be dissociated from the port because the port
 331  *      is being closed.
 332  */
 333 /* ARGSUSED */
 334 static int
 335 port_fop_callback(void *arg, int *events, pid_t pid, int flag, void *evp)
 336 {
 337         portfop_t       *pfp = (portfop_t *)arg;
 338         port_kevent_t   *pkevp = (port_kevent_t *)evp;
 339         int             error = 0;
 340 
 341         ASSERT((events != NULL));
 342         if (flag == PORT_CALLBACK_DEFAULT) {
 343                 if (curproc->p_pid != pid) {
 344                                 return (EACCES); /* deny delivery of events */
 345                 }
 346 
 347                 *events = pkevp->portkev_events;
 348                 pkevp->portkev_events = 0;
 349                 if (pfp != NULL) {
 350                         pfp->pfop_flags &= ~PORT_FOP_KEV_ONQ;
 351                 }
 352         }
 353         return (error);
 354 }
 355 
 356 /*
 357  * Inserts a portfop_t into the port sources cache's.
 358  */
 359 static void
 360 port_pcache_insert(portfop_cache_t *pfcp, portfop_t *pfp)
 361 {
 362         portfop_t       **bucket;
 363 
 364         ASSERT(MUTEX_HELD(&pfcp->pfc_lock));
 365         bucket = PORT_FOP_BUCKET(pfcp, pfp->pfop_object);
 366         pfp->pfop_hashnext = *bucket;
 367         *bucket = pfp;
 368         pfcp->pfc_objcount++;
 369 }
 370 
 371 /*
 372  * Remove the pfp from the port source cache.
 373  */
 374 static void
 375 port_pcache_delete(portfop_cache_t *pfcp, portfop_t *pfp)
 376 {
 377         portfop_t       *lpdp;
 378         portfop_t       *cpdp;
 379         portfop_t       **bucket;
 380 
 381         bucket = PORT_FOP_BUCKET(pfcp, pfp->pfop_object);
 382         cpdp = *bucket;
 383         if (pfp == cpdp) {
 384                 *bucket = pfp->pfop_hashnext;
 385         } else {
 386                 while (cpdp != NULL) {
 387                         lpdp = cpdp;
 388                         cpdp = cpdp->pfop_hashnext;
 389                         if (cpdp == pfp) {
 390                                 /* portfop struct found */
 391                                 lpdp->pfop_hashnext = pfp->pfop_hashnext;
 392                                 break;
 393                         }
 394                 }
 395         }
 396         pfcp->pfc_objcount--;
 397 }
 398 
 399 /*
 400  * The vnode's(portfop_vp_t) pfp list management. The 'pvp_mutex' is held
 401  * when these routines are called.
 402  *
 403  * The 'pvp_lpfop' member points to the oldest inactive entry on the list.
 404  * It is used to discard the oldtest inactive pfp if the number of entries
 405  * exceed the limit.
 406  */
 407 static void
 408 port_fop_listinsert(portfop_vp_t *pvp, portfop_t *pfp, int where)
 409 {
 410         if (where == 1) {
 411                 list_insert_head(&pvp->pvp_pfoplist, (void *)pfp);
 412         } else {
 413                 list_insert_tail(&pvp->pvp_pfoplist, (void *)pfp);
 414         }
 415         if (pvp->pvp_lpfop == NULL) {
 416                 pvp->pvp_lpfop = pfp;
 417         }
 418         pvp->pvp_cnt++;
 419 }
 420 
 421 static void
 422 port_fop_listinsert_head(portfop_vp_t *pvp, portfop_t *pfp)
 423 {
 424         port_fop_listinsert(pvp, pfp, 1);
 425 }
 426 
 427 static void
 428 port_fop_listinsert_tail(portfop_vp_t *pvp, portfop_t *pfp)
 429 {
 430         /*
 431          * We point lpfop to an inactive one, if it was initially pointing
 432          * to an active one. Insert to the tail is done only when a pfp goes
 433          * inactive.
 434          */
 435         if (pvp->pvp_lpfop && pvp->pvp_lpfop->pfop_flags & PORT_FOP_ACTIVE) {
 436                 pvp->pvp_lpfop = pfp;
 437         }
 438         port_fop_listinsert(pvp, pfp, 0);
 439 }
 440 
 441 static void
 442 port_fop_listremove(portfop_vp_t *pvp, portfop_t *pfp)
 443 {
 444         if (pvp->pvp_lpfop == pfp) {
 445                 pvp->pvp_lpfop = list_next(&pvp->pvp_pfoplist, (void *)pfp);
 446         }
 447 
 448         list_remove(&pvp->pvp_pfoplist, (void *)pfp);
 449 
 450         pvp->pvp_cnt--;
 451         if (pvp->pvp_cnt && pvp->pvp_lpfop == NULL) {
 452                 pvp->pvp_lpfop = list_head(&pvp->pvp_pfoplist);
 453         }
 454 }
 455 
 456 static void
 457 port_fop_listmove(portfop_vp_t *pvp, list_t *tlist)
 458 {
 459         list_move_tail(tlist, &pvp->pvp_pfoplist);
 460         pvp->pvp_lpfop = NULL;
 461         pvp->pvp_cnt = 0;
 462 }
 463 
 464 /*
 465  * Remove a portfop_t from the port cache hash table and discard it.
 466  * It is called only when pfp is not on the vnode's list. Otherwise,
 467  * port_remove_fop() is called.
 468  */
 469 void
 470 port_pcache_remove_fop(portfop_cache_t *pfcp, portfop_t *pfp)
 471 {
 472         port_kevent_t   *pkevp;
 473 
 474 
 475         ASSERT(MUTEX_HELD(&pfcp->pfc_lock));
 476 
 477         pkevp = pfp->pfop_pev;
 478         pfp->pfop_pev = NULL;
 479 
 480         if (pkevp != NULL) {
 481                 (void) port_remove_done_event(pkevp);
 482                 port_free_event_local(pkevp, 0);
 483         }
 484 
 485         port_pcache_delete(pfcp, pfp);
 486 
 487         if (pfp->pfop_cname != NULL)
 488                 kmem_free(pfp->pfop_cname, pfp->pfop_clen + 1);
 489         kmem_free(pfp, sizeof (portfop_t));
 490         if (pfcp->pfc_objcount == 0)
 491                 cv_signal(&pfcp->pfc_lclosecv);
 492 }
 493 
 494 /*
 495  * if we have too many watches on the vnode, attempt to discard an
 496  * inactive one.
 497  */
 498 static void
 499 port_fop_trimpfplist(vnode_t *vp)
 500 {
 501         portfop_vp_t *pvp;
 502         portfop_t *pfp = NULL;
 503         portfop_cache_t *pfcp;
 504         vnode_t *tdvp;
 505 
 506         /*
 507          * Due to a reference the vnode cannot disappear, v_fopdata should
 508          * not change.
 509          */
 510         if ((pvp = vp->v_fopdata) != NULL &&
 511             pvp->pvp_cnt > port_fop_maxpfps) {
 512                 mutex_enter(&pvp->pvp_mutex);
 513                 pfp = pvp->pvp_lpfop;
 514                 pfcp = pfp->pfop_pcache;
 515                 /*
 516                  * only if we can get the cache lock, we need to
 517                  * do this due to reverse lock order and some thread
 518                  * that may be trying to reactivate this entry.
 519                  */
 520                 if (mutex_tryenter(&pfcp->pfc_lock)) {
 521                         if (pfp && !(pfp->pfop_flags & PORT_FOP_ACTIVE) &&
 522                             !(pfp->pfop_flags & PORT_FOP_KEV_ONQ)) {
 523                                 port_fop_listremove(pvp, pfp);
 524                                 pfp->pfop_flags |= PORT_FOP_REMOVING;
 525                         } else {
 526                                 mutex_exit(&pfcp->pfc_lock);
 527                                 pfp = NULL;
 528                         }
 529                 } else {
 530                         pfp = NULL;
 531                 }
 532                 mutex_exit(&pvp->pvp_mutex);
 533 
 534                 /*
 535                  * discard pfp if any.
 536                  */
 537                 if (pfp != NULL) {
 538                         tdvp = pfp->pfop_dvp;
 539                         port_pcache_remove_fop(pfcp, pfp);
 540                         mutex_exit(&pfcp->pfc_lock);
 541                         if (tdvp != NULL)
 542                                 VN_RELE(tdvp);
 543                 }
 544         }
 545 }
 546 
 547 /*
 548  * This routine returns 1, if the vnode can be rele'ed by the caller.
 549  * The caller has to VN_RELE the vnode with out holding any
 550  * locks.
 551  */
 552 int
 553 port_fop_femuninstall(vnode_t *vp)
 554 {
 555         portfop_vp_t    *pvp;
 556         vfs_t           *vfsp;
 557         portfop_vfs_t *pvfsp;
 558         portfop_vfs_hash_t      *pvfsh;
 559         kmutex_t        *mtx;
 560         int     ret = 0;
 561 
 562         /*
 563          * if list is empty, uninstall fem.
 564          */
 565         pvp = vp->v_fopdata;
 566         ASSERT(MUTEX_HELD(&pvp->pvp_mutex));
 567 
 568         /*
 569          * make sure the list is empty.
 570          */
 571         if (!list_head(&pvp->pvp_pfoplist)) {
 572 
 573                 /*
 574                  * we could possibly uninstall the fem hooks when
 575                  * the vnode becomes inactive and the v_fopdata is
 576                  * free. But the hooks get triggered unnecessarily
 577                  * even though there are no active watches. So, we
 578                  * uninstall it here.
 579                  */
 580                 (void) fem_uninstall(vp, (fem_t *)pvp->pvp_femp, vp);
 581                 pvp->pvp_femp = NULL;
 582 
 583 
 584                 /*
 585                  * If we successfully uninstalled fem, no process is watching
 586                  * this vnode, Remove it from the vfs's list of watched vnodes.
 587                  */
 588                 pvfsp = pvp->pvp_pvfsp;
 589                 vfsp = vp->v_vfsp;
 590                 pvfsh = PORTFOP_PVFSH(vfsp);
 591                 mtx = &pvfsh->pvfshash_mutex;
 592                 mutex_enter(mtx);
 593                 /*
 594                  * If unmount is in progress, that thread will remove and
 595                  * release the vnode from the vfs's list, just leave.
 596                  */
 597                 if (!pvfsp->pvfs_unmount) {
 598                         list_remove(&pvfsp->pvfs_pvplist, pvp);
 599                         mutex_exit(mtx);
 600                         ret = 1;
 601                 } else {
 602                         mutex_exit(mtx);
 603                 }
 604         }
 605         mutex_exit(&pvp->pvp_mutex);
 606         return (ret);
 607 }
 608 
 609 /*
 610  * Remove pfp from the vnode's watch list and the cache and discard it.
 611  * If it is the last pfp on the vnode's list, the fem hooks get uninstalled.
 612  * Returns 1 if pfp removed successfully.
 613  *
 614  * The *active is set to indicate if the pfp was still active(no events had
 615  * been posted, or the posted event had not been collected yet and it was
 616  * able to remove it from the port's queue).
 617  *
 618  * vpp and dvpp will point to the vnode and directory vnode which the caller
 619  * is required to VN_RELE without holding any locks.
 620  */
 621 int
 622 port_remove_fop(portfop_t *pfp, portfop_cache_t *pfcp, int cleanup,
 623     int *active, vnode_t **vpp, vnode_t **dvpp)
 624 {
 625         vnode_t         *vp;
 626         portfop_vp_t    *pvp;
 627         int     tactive = 0;
 628 
 629         ASSERT(MUTEX_HELD(&pfcp->pfc_lock));
 630         vp = pfp->pfop_vp;
 631         pvp = vp->v_fopdata;
 632         mutex_enter(&pvp->pvp_mutex);
 633 
 634         /*
 635          * if not cleanup, remove it only if the pfp is still active and
 636          * is not being removed by some other thread.
 637          */
 638         if (!cleanup && (!(pfp->pfop_flags & PORT_FOP_ACTIVE) ||
 639             pfp->pfop_flags & PORT_FOP_REMOVING)) {
 640                 mutex_exit(&pvp->pvp_mutex);
 641                 return (0);
 642         }
 643 
 644         /*
 645          * mark it inactive.
 646          */
 647         if (pfp->pfop_flags & PORT_FOP_ACTIVE) {
 648                 pfp->pfop_flags &= ~PORT_FOP_ACTIVE;
 649                 tactive = 1;
 650         }
 651 
 652         /*
 653          * Check if the pfp is still on the vnode's list. This can
 654          * happen if port_fop_excep() is in the process of removing it.
 655          * In case of cleanup, just mark this pfp as inactive so that no
 656          * new events (VNEVENT) will be delivered, and remove it from the
 657          * event queue if it was already queued. Since the cache lock is
 658          * held, the pfp will not disappear, even though it is being
 659          * removed.
 660          */
 661         if (pfp->pfop_flags & PORT_FOP_REMOVING) {
 662                 mutex_exit(&pvp->pvp_mutex);
 663                 if (!tactive && port_remove_done_event(pfp->pfop_pev)) {
 664                         pfp->pfop_flags &= ~PORT_FOP_KEV_ONQ;
 665                         tactive = 1;
 666                 }
 667                 if (active) {
 668                         *active = tactive;
 669                 }
 670                 return (1);
 671         }
 672 
 673         /*
 674          * if we find an event on the queue and removed it, then this
 675          * association is considered active.
 676          */
 677         if (!tactive && port_remove_done_event(pfp->pfop_pev)) {
 678                 pfp->pfop_flags &= ~PORT_FOP_KEV_ONQ;
 679                 tactive = 1;
 680         }
 681 
 682         if (active) {
 683                 *active = tactive;
 684         }
 685         pvp = (portfop_vp_t *)vp->v_fopdata;
 686 
 687         /*
 688          * remove pfp from the vnode's list
 689          */
 690         port_fop_listremove(pvp, pfp);
 691 
 692         /*
 693          * If no more associations on the vnode, uninstall fem hooks.
 694          * The pvp mutex will be released in this routine.
 695          */
 696         if (port_fop_femuninstall(vp))
 697                 *vpp = vp;
 698         *dvpp = pfp->pfop_dvp;
 699         port_pcache_remove_fop(pfcp, pfp);
 700         return (1);
 701 }
 702 
 703 /*
 704  * This routine returns a pointer to a cached portfop entry, or NULL if it
 705  * does not find it in the hash table. The object pointer is used as index.
 706  * The entries are hashed by the object's address. We need to match the pid
 707  * as the evet port can be shared between processes. The file events
 708  * watches are per process only.
 709  */
 710 portfop_t *
 711 port_cache_lookup_fop(portfop_cache_t *pfcp, pid_t pid, uintptr_t obj)
 712 {
 713         portfop_t       *pfp = NULL;
 714         portfop_t       **bucket;
 715 
 716         ASSERT(MUTEX_HELD(&pfcp->pfc_lock));
 717         bucket = PORT_FOP_BUCKET(pfcp, obj);
 718         pfp = *bucket;
 719         while (pfp != NULL) {
 720                 if (pfp->pfop_object == obj && pfp->pfop_pid == pid)
 721                         break;
 722                 pfp = pfp->pfop_hashnext;
 723         }
 724         return (pfp);
 725 }
 726 
 727 /*
 728  * Given the file name, get the vnode and also the directory vnode
 729  * On return, the vnodes are held (VN_HOLD). The caller has to VN_RELE
 730  * the vnode(s).
 731  */
 732 int
 733 port_fop_getdvp(void *objptr, vnode_t **vp, vnode_t **dvp,
 734         char **cname, int *len, int follow)
 735 {
 736         int error = 0;
 737         struct pathname pn;
 738         char *fname;
 739 
 740         if (get_udatamodel() == DATAMODEL_NATIVE) {
 741                 fname = ((file_obj_t *)objptr)->fo_name;
 742 #ifdef  _SYSCALL32_IMPL
 743         } else {
 744                 fname = (caddr_t)(uintptr_t)((file_obj32_t *)objptr)->fo_name;
 745 #endif  /* _SYSCALL32_IMPL */
 746         }
 747 
 748         /*
 749          * lookuppn may fail with EINVAL, if dvp is  non-null(like when
 750          * looking for "."). So call again with dvp = NULL.
 751          */
 752         if ((error = pn_get(fname, UIO_USERSPACE, &pn)) != 0) {
 753                 return (error);
 754         }
 755 
 756         error = lookuppn(&pn, NULL, follow, dvp, vp);
 757         if (error == EINVAL) {
 758                 pn_free(&pn);
 759                 if ((error = pn_get(fname, UIO_USERSPACE, &pn)) != 0) {
 760                         return (error);
 761                 }
 762                 error = lookuppn(&pn, NULL, follow, NULL, vp);
 763                 if (dvp != NULL) {
 764                         *dvp = NULL;
 765                 }
 766         }
 767 
 768         if (error == 0 && cname != NULL && len != NULL) {
 769                 pn_setlast(&pn);
 770                 *len = pn.pn_pathlen;
 771                 *cname = kmem_alloc(*len + 1, KM_SLEEP);
 772                 (void) strcpy(*cname, pn.pn_path);
 773         } else {
 774                 if (cname != NULL && len != NULL) {
 775                         *cname = NULL;
 776                         *len = 0;
 777                 }
 778         }
 779 
 780         pn_free(&pn);
 781         return (error);
 782 }
 783 
 784 port_source_t *
 785 port_getsrc(port_t *pp, int source)
 786 {
 787         port_source_t *pse;
 788         int     lock = 0;
 789         /*
 790          * get the port source structure.
 791          */
 792         if (!MUTEX_HELD(&pp->port_queue.portq_source_mutex)) {
 793                 mutex_enter(&pp->port_queue.portq_source_mutex);
 794                 lock = 1;
 795         }
 796 
 797         pse = pp->port_queue.portq_scache[PORT_SHASH(source)];
 798         for (; pse != NULL; pse = pse->portsrc_next) {
 799                 if (pse->portsrc_source == source)
 800                         break;
 801         }
 802 
 803         if (lock) {
 804                 mutex_exit(&pp->port_queue.portq_source_mutex);
 805         }
 806         return (pse);
 807 }
 808 
 809 
 810 /*
 811  * Compare time stamps and generate an event if it has changed.
 812  * Note that the port cache pointer will be valid due to a reference
 813  * to the port. We need to grab the port cache lock and verify that
 814  * the pfp is still the same before proceeding to deliver an event.
 815  */
 816 static void
 817 port_check_timestamp(portfop_cache_t *pfcp, vnode_t *vp, vnode_t *dvp,
 818         portfop_t *pfp, void *objptr, uintptr_t object)
 819 {
 820         vattr_t         vatt;
 821         portfop_vp_t    *pvp = vp->v_fopdata;
 822         int             events = 0;
 823         port_kevent_t   *pkevp;
 824         file_obj_t      *fobj;
 825         portfop_t       *tpfp;
 826 
 827         /*
 828          * If time stamps are specified, get attributes and compare.
 829          */
 830         vatt.va_mask = AT_ATIME|AT_MTIME|AT_CTIME;
 831         if (get_udatamodel() == DATAMODEL_NATIVE) {
 832                 fobj = (file_obj_t *)objptr;
 833                 if (fobj->fo_atime.tv_sec || fobj->fo_atime.tv_nsec ||
 834                     fobj->fo_mtime.tv_sec || fobj->fo_mtime.tv_nsec ||
 835                     fobj->fo_ctime.tv_sec || fobj->fo_ctime.tv_nsec) {
 836                         if (VOP_GETATTR(vp, &vatt, 0, CRED(), NULL)) {
 837                                 return;
 838                         }
 839                 } else {
 840                         /*
 841                          * timestamp not specified, all 0's,
 842                          */
 843                         return;
 844                 }
 845 #ifdef  _SYSCALL32_IMPL
 846         } else {
 847                 file_obj32_t    *fobj32;
 848                 fobj32 = (file_obj32_t *)objptr;
 849                 if (fobj32->fo_atime.tv_sec || fobj32->fo_atime.tv_nsec ||
 850                     fobj32->fo_mtime.tv_sec || fobj32->fo_mtime.tv_nsec ||
 851                     fobj32->fo_ctime.tv_sec || fobj32->fo_ctime.tv_nsec) {
 852                         if (VOP_GETATTR(vp, &vatt, 0, CRED(), NULL)) {
 853                                 return;
 854                         }
 855                 } else {
 856                         /*
 857                          * timestamp not specified, all 0.
 858                          */
 859                         return;
 860                 }
 861 #endif /* _SYSCALL32_IMPL */
 862         }
 863 
 864         /*
 865          * Now grab the cache lock and verify that we are still
 866          * dealing with the same pfp and curthread is the one
 867          * which registered it. We need to do this to avoid
 868          * delivering redundant events.
 869          */
 870         mutex_enter(&pfcp->pfc_lock);
 871         tpfp = port_cache_lookup_fop(pfcp, curproc->p_pid, object);
 872 
 873         if (tpfp == NULL || tpfp != pfp ||
 874             pfp->pfop_vp != vp || pfp->pfop_dvp != dvp ||
 875             pfp->pfop_callrid != curthread ||
 876             !(pfp->pfop_flags & PORT_FOP_ACTIVE)) {
 877                 /*
 878                  * Some other event was delivered, the file
 879                  * watch was removed or reassociated. Just
 880                  * ignore it and leave
 881                  */
 882                 mutex_exit(&pfcp->pfc_lock);
 883                 return;
 884         }
 885 
 886         mutex_enter(&pvp->pvp_mutex);
 887         /*
 888          * The pfp cannot disappear as the port cache lock is held.
 889          * While the pvp_mutex is held, no events will get delivered.
 890          */
 891         if (pfp->pfop_flags & PORT_FOP_ACTIVE &&
 892             !(pfp->pfop_flags & PORT_FOP_REMOVING)) {
 893                 if (get_udatamodel() == DATAMODEL_NATIVE) {
 894                         fobj = (file_obj_t *)objptr;
 895                         if (pfp->pfop_events & FILE_ACCESS &&
 896                             (fobj->fo_atime.tv_sec || fobj->fo_atime.tv_nsec) &&
 897                             (vatt.va_atime.tv_sec != fobj->fo_atime.tv_sec ||
 898                             vatt.va_atime.tv_nsec != fobj->fo_atime.tv_nsec))
 899                                 events |= FILE_ACCESS;
 900 
 901                         if (pfp->pfop_events & FILE_MODIFIED &&
 902                             (fobj->fo_mtime.tv_sec || fobj->fo_mtime.tv_nsec) &&
 903                             (vatt.va_mtime.tv_sec != fobj->fo_mtime.tv_sec ||
 904                             vatt.va_mtime.tv_nsec != fobj->fo_mtime.tv_nsec))
 905                                 events |= FILE_MODIFIED;
 906 
 907                         if (pfp->pfop_events & FILE_ATTRIB &&
 908                             (fobj->fo_ctime.tv_sec || fobj->fo_ctime.tv_nsec) &&
 909                             (vatt.va_ctime.tv_sec != fobj->fo_ctime.tv_sec ||
 910                             vatt.va_ctime.tv_nsec != fobj->fo_ctime.tv_nsec))
 911                                 events |= FILE_ATTRIB;
 912 #ifdef  _SYSCALL32_IMPL
 913                 } else {
 914                         file_obj32_t    *fobj32;
 915                         fobj32 = (file_obj32_t *)objptr;
 916                         if (pfp->pfop_events & FILE_ACCESS &&
 917                             (fobj32->fo_atime.tv_sec ||
 918                             fobj32->fo_atime.tv_nsec) &&
 919                             (vatt.va_atime.tv_sec != fobj32->fo_atime.tv_sec ||
 920                             vatt.va_atime.tv_nsec != fobj32->fo_atime.tv_nsec))
 921                                 events |= FILE_ACCESS;
 922 
 923                         if (pfp->pfop_events & FILE_MODIFIED &&
 924                             (fobj32->fo_mtime.tv_sec ||
 925                             fobj32->fo_mtime.tv_nsec) &&
 926                             (vatt.va_mtime.tv_sec != fobj32->fo_mtime.tv_sec ||
 927                             vatt.va_mtime.tv_nsec != fobj32->fo_mtime.tv_nsec))
 928                                 events |= FILE_MODIFIED;
 929 
 930                         if (pfp->pfop_events & FILE_ATTRIB &&
 931                             (fobj32->fo_ctime.tv_sec ||
 932                             fobj32->fo_ctime.tv_nsec) &&
 933                             (vatt.va_ctime.tv_sec != fobj32->fo_ctime.tv_sec ||
 934                             vatt.va_ctime.tv_nsec != fobj32->fo_ctime.tv_nsec))
 935                                 events |= FILE_ATTRIB;
 936 #endif /* _SYSCALL32_IMPL */
 937                 }
 938 
 939                 /*
 940                  * No events to deliver
 941                  */
 942                 if (events == 0) {
 943                         mutex_exit(&pvp->pvp_mutex);
 944                         mutex_exit(&pfcp->pfc_lock);
 945                         return;
 946                 }
 947 
 948                 /*
 949                  * Deliver the event now.
 950                  */
 951                 pkevp = pfp->pfop_pev;
 952                 pfp->pfop_flags &= ~PORT_FOP_ACTIVE;
 953                 pkevp->portkev_events |= events;
 954                 /*
 955                  * Move it to the tail as active once are in the
 956                  * beginning of the list.
 957                  */
 958                 port_fop_listremove(pvp, pfp);
 959                 port_fop_listinsert_tail(pvp, pfp);
 960                 port_send_event(pkevp);
 961                 pfp->pfop_flags |= PORT_FOP_KEV_ONQ;
 962         }
 963         mutex_exit(&pvp->pvp_mutex);
 964         mutex_exit(&pfcp->pfc_lock);
 965 }
 966 
 967 /*
 968  * Add the event source to the port and return the port source cache pointer.
 969  */
 970 int
 971 port_fop_associate_source(portfop_cache_t **pfcpp, port_t *pp, int source)
 972 {
 973         portfop_cache_t *pfcp;
 974         port_source_t   *pse;
 975         int             error;
 976 
 977         /*
 978          * associate PORT_SOURCE_FILE source with the port, if it is
 979          * not associated yet. Note the PORT_SOURCE_FILE source is
 980          * associated once and will not be dissociated.
 981          */
 982         if ((pse = port_getsrc(pp, PORT_SOURCE_FILE)) == NULL) {
 983                 if (error = port_associate_ksource(pp->port_fd, source,
 984                     &pse, port_close_fop, pp, NULL)) {
 985                         *pfcpp = NULL;
 986                         return (error);
 987                 }
 988         }
 989 
 990         /*
 991          * Get the portfop cache pointer.
 992          */
 993         if ((pfcp = pse->portsrc_data) == NULL) {
 994                 /*
 995                  * This is the first time that a file is being associated,
 996                  * create the portfop cache.
 997                  */
 998                 pfcp = kmem_zalloc(sizeof (portfop_cache_t), KM_SLEEP);
 999                 mutex_enter(&pp->port_queue.portq_source_mutex);
1000                 if (pse->portsrc_data == NULL) {
1001                         pse->portsrc_data = pfcp;
1002                         mutex_exit(&pp->port_queue.portq_source_mutex);
1003                 } else {
1004                         /*
1005                          * someone else created the port cache, free
1006                          * what we just now allocated.
1007                          */
1008                         mutex_exit(&pp->port_queue.portq_source_mutex);
1009                         kmem_free(pfcp, sizeof (portfop_cache_t));
1010                         pfcp = pse->portsrc_data;
1011                 }
1012         }
1013         *pfcpp = pfcp;
1014         return (0);
1015 }
1016 
1017 /*
1018  * Add the given pvp on the file system's list of vnodes watched.
1019  */
1020 int
1021 port_fop_pvfsadd(portfop_vp_t *pvp)
1022 {
1023         int error = 0;
1024         vnode_t *vp = pvp->pvp_vp;
1025         portfop_vfs_hash_t *pvfsh;
1026         portfop_vfs_t    *pvfsp;
1027         fsem_t          *fsemp;
1028 
1029         pvfsh = PORTFOP_PVFSH(vp->v_vfsp);
1030         mutex_enter(&pvfsh->pvfshash_mutex);
1031         for (pvfsp = pvfsh->pvfshash_pvfsp; pvfsp &&
1032             pvfsp->pvfs != vp->v_vfsp; pvfsp = pvfsp->pvfs_next)
1033                 ;
1034 
1035         if (!pvfsp) {
1036                 if ((fsemp = port_fop_fsemop()) != NULL) {
1037                         if ((error = fsem_install(vp->v_vfsp, fsemp,
1038                             vp->v_vfsp, OPUNIQ, NULL, NULL))) {
1039                                 mutex_exit(&pvfsh->pvfshash_mutex);
1040                                 return (error);
1041                         }
1042                 } else {
1043                         mutex_exit(&pvfsh->pvfshash_mutex);
1044                         return (EINVAL);
1045                 }
1046                 pvfsp = kmem_zalloc(sizeof (portfop_vfs_t), KM_SLEEP);
1047                 pvfsp->pvfs = vp->v_vfsp;
1048                 list_create(&(pvfsp->pvfs_pvplist), sizeof (portfop_vp_t),
1049                     offsetof(portfop_vp_t, pvp_pvfsnode));
1050                 pvfsp->pvfs_fsemp = fsemp;
1051                 pvfsp->pvfs_next = pvfsh->pvfshash_pvfsp;
1052                 pvfsh->pvfshash_pvfsp = pvfsp;
1053         }
1054 
1055         /*
1056          * check if an unmount is in progress.
1057          */
1058         if (!pvfsp->pvfs_unmount) {
1059                 /*
1060                  * insert the pvp on list.
1061                  */
1062                 pvp->pvp_pvfsp = pvfsp;
1063                 list_insert_head(&pvfsp->pvfs_pvplist, (void *)pvp);
1064         } else {
1065                 error = EINVAL;
1066         }
1067         mutex_exit(&pvfsh->pvfshash_mutex);
1068         return (error);
1069 }
1070 
1071 /*
1072  * Installs the portfop_vp_t data structure on the
1073  * vnode. The 'pvp_femp == NULL' indicates it is not
1074  * active. The fem hooks have to be installed.
1075  * The portfop_vp_t is only freed when the vnode gets freed.
1076  */
1077 void
1078 port_install_fopdata(vnode_t *vp)
1079 {
1080         portfop_vp_t *npvp;
1081 
1082         npvp = kmem_zalloc(sizeof (*npvp), KM_SLEEP);
1083         mutex_init(&npvp->pvp_mutex, NULL, MUTEX_DEFAULT, NULL);
1084         list_create(&npvp->pvp_pfoplist, sizeof (portfop_t),
1085             offsetof(portfop_t, pfop_node));
1086         npvp->pvp_vp = vp;
1087         /*
1088          * If v_fopdata is not null, some other thread beat us to it.
1089          */
1090         if (casptr(&vp->v_fopdata, NULL, npvp) != NULL) {
1091                 mutex_destroy(&npvp->pvp_mutex);
1092                 list_destroy(&npvp->pvp_pfoplist);
1093                 kmem_free(npvp, sizeof (*npvp));
1094         }
1095 }
1096 
1097 
1098 /*
1099  * Allocate and add a portfop_t to the per port cache. Also add the portfop_t
1100  * to the vnode's list. The association is identified by the object pointer
1101  * address and pid.
1102  */
1103 int
1104 port_pfp_setup(portfop_t **pfpp, port_t *pp, vnode_t *vp, portfop_cache_t *pfcp,
1105         uintptr_t object, int events, void *user, char *cname, int clen,
1106         vnode_t *dvp)
1107 {
1108         portfop_t       *pfp = NULL;
1109         port_kevent_t   *pkevp;
1110         fem_t           *femp;
1111         int             error = 0;
1112         portfop_vp_t    *pvp;
1113 
1114 
1115         /*
1116          * The port cache mutex is held.
1117          */
1118         *pfpp  = NULL;
1119 
1120 
1121         /*
1122          * At this point the fem monitor is installed.
1123          * Allocate a port event structure per vnode association.
1124          */
1125         if (pfp == NULL) {
1126                 if (error = port_alloc_event_local(pp, PORT_SOURCE_FILE,
1127                     PORT_ALLOC_CACHED, &pkevp)) {
1128                         return (error);
1129                 }
1130                 pfp = kmem_zalloc(sizeof (portfop_t), KM_SLEEP);
1131                 pfp->pfop_pev = pkevp;
1132         }
1133 
1134         pfp->pfop_vp = vp;
1135         pfp->pfop_pid = curproc->p_pid;
1136         pfp->pfop_pcache = pfcp;
1137         pfp->pfop_pp = pp;
1138         pfp->pfop_flags |= PORT_FOP_ACTIVE;
1139         pfp->pfop_cname = cname;
1140         pfp->pfop_clen = clen;
1141         pfp->pfop_dvp = dvp;
1142         pfp->pfop_object = object;
1143 
1144         pkevp->portkev_callback = port_fop_callback;
1145         pkevp->portkev_arg = pfp;
1146         pkevp->portkev_object = object;
1147         pkevp->portkev_user = user;
1148         pkevp->portkev_events = 0;
1149 
1150         port_pcache_insert(pfcp, pfp);
1151 
1152         /*
1153          * Register a new file events monitor for this file(vnode), if not
1154          * done already.
1155          */
1156         if ((pvp = vp->v_fopdata) == NULL) {
1157                 port_install_fopdata(vp);
1158                 pvp = vp->v_fopdata;
1159         }
1160 
1161         mutex_enter(&pvp->pvp_mutex);
1162         /*
1163          * if the vnode does not have the file events hooks, install it.
1164          */
1165         if (pvp->pvp_femp == NULL) {
1166                 if ((femp = port_fop_femop()) != NULL) {
1167                         if (!(error = fem_install(pfp->pfop_vp, femp,
1168                             (void *)vp, OPUNIQ, NULL, NULL))) {
1169                                 pvp->pvp_femp = femp;
1170                                 /*
1171                                  * add fsem_t hooks to the vfsp and add pvp to
1172                                  * the list of vnodes for this vfs.
1173                                  */
1174                                 if (!(error = port_fop_pvfsadd(pvp))) {
1175                                         /*
1176                                          * Hold a reference to the vnode since
1177                                          * we successfully installed the hooks.
1178                                          */
1179                                         VN_HOLD(vp);
1180                                 } else {
1181                                         (void) fem_uninstall(vp, femp, vp);
1182                                         pvp->pvp_femp = NULL;
1183                                 }
1184                         }
1185                 } else {
1186                         error = EINVAL;
1187                 }
1188         }
1189 
1190         if (error) {
1191                 /*
1192                  * pkevp will get freed here.
1193                  */
1194                 pfp->pfop_cname = NULL;
1195                 port_pcache_remove_fop(pfcp, pfp);
1196                 mutex_exit(&pvp->pvp_mutex);
1197                 return (error);
1198         }
1199 
1200         /*
1201          * insert the pfp on the vnode's list. After this
1202          * events can get delivered.
1203          */
1204         pfp->pfop_events = events;
1205         port_fop_listinsert_head(pvp, pfp);
1206 
1207         mutex_exit(&pvp->pvp_mutex);
1208         /*
1209          * Hold the directory vnode since we have a reference now.
1210          */
1211         if (dvp != NULL)
1212                 VN_HOLD(dvp);
1213         *pfpp = pfp;
1214         return (0);
1215 }
1216 
1217 vnode_t *
1218 port_resolve_vp(vnode_t *vp)
1219 {
1220         vnode_t *rvp;
1221         /*
1222          * special case /etc/mnttab(mntfs type). The mntfstype != 0
1223          * if mntfs got mounted.
1224          */
1225         if (vfs_mntdummyvp && mntfstype != 0 &&
1226             vp->v_vfsp->vfs_fstype == mntfstype) {
1227                 VN_RELE(vp);
1228                 vp = vfs_mntdummyvp;
1229                 VN_HOLD(vfs_mntdummyvp);
1230         }
1231 
1232         /*
1233          * This should take care of lofs mounted fs systems and nfs4
1234          * hardlinks.
1235          */
1236         if ((VOP_REALVP(vp, &rvp, NULL) == 0) && vp != rvp) {
1237                 VN_HOLD(rvp);
1238                 VN_RELE(vp);
1239                 vp = rvp;
1240         }
1241         return (vp);
1242 }
1243 
1244 /*
1245  * Register a file events watch on the given file associated to the port *pp.
1246  *
1247  * The association is identified by the object pointer and the pid.
1248  * The events argument contains the events to be monitored for.
1249  *
1250  * The vnode will have a VN_HOLD once the fem hooks are installed.
1251  *
1252  * Every reference(pfp) to the directory vnode will have a VN_HOLD to ensure
1253  * that the directory vnode pointer does not change.
1254  */
1255 int
1256 port_associate_fop(port_t *pp, int source, uintptr_t object, int events,
1257     void *user)
1258 {
1259         portfop_cache_t *pfcp;
1260         vnode_t         *vp, *dvp, *oldvp = NULL, *olddvp = NULL, *orig;
1261         portfop_t       *pfp;
1262         int             error = 0;
1263         file_obj_t      fobj;
1264         void            *objptr;
1265         char            *cname;
1266         int             clen;
1267         int             follow;
1268 
1269         /*
1270          * check that events specified are valid.
1271          */
1272         if ((events & ~FILE_EVENTS_MASK) != 0)
1273                 return (EINVAL);
1274 
1275         if (get_udatamodel() == DATAMODEL_NATIVE) {
1276                 if (copyin((void *)object, &fobj, sizeof (file_obj_t)))
1277                         return (EFAULT);
1278                 objptr = (void *)&fobj;
1279 #ifdef  _SYSCALL32_IMPL
1280         } else {
1281                 file_obj32_t    fobj32;
1282                 if (copyin((void *)object, &fobj32, sizeof (file_obj32_t)))
1283                         return (EFAULT);
1284                 objptr = (void *)&fobj32;
1285 #endif  /* _SYSCALL32_IMPL */
1286         }
1287 
1288         vp = dvp = NULL;
1289 
1290         /*
1291          * find out if we need to follow symbolic links.
1292          */
1293         follow = !(events & FILE_NOFOLLOW);
1294         events = events & ~FILE_NOFOLLOW;
1295 
1296         /*
1297          * lookup and find the vnode and its directory vnode of the given
1298          * file.
1299          */
1300         if ((error = port_fop_getdvp(objptr, &vp, &dvp, &cname, &clen,
1301             follow)) != 0) {
1302                 return (error);
1303         }
1304 
1305         if (dvp != NULL) {
1306                 dvp = port_resolve_vp(dvp);
1307         }
1308 
1309         /*
1310          * Not found
1311          */
1312         if (vp == NULL) {
1313                 error = ENOENT;
1314                 goto errout;
1315         }
1316 
1317         vp = port_resolve_vp(orig = vp);
1318 
1319         if (vp != NULL && vnevent_support(vp, NULL)) {
1320                 error = ENOTSUP;
1321                 goto errout;
1322         }
1323 
1324         /*
1325          * If dvp belongs to a different filesystem just ignore it, as hard
1326          * links cannot exist across filesystems.  We make an exception for
1327          * procfs, however, the magic of which we treat semantically as a hard
1328          * link, allowing one to use /proc/[pid]/fd/[fd] for PORT_SOURCE_FILE
1329          * and avoid spurious FILE_RENAME_FROM/FILE_RENAME_TO events.
1330          */
1331         if (dvp != NULL && dvp->v_vfsp != vp->v_vfsp &&
1332             !(orig->v_type == VPROC && vp != NULL && vp->v_type != VPROC)) {
1333                 VN_RELE(dvp);
1334                 dvp = NULL;
1335         }
1336 
1337         /*
1338          * Associate this source to the port and get the per port
1339          * fop cache pointer. If the source is already associated, it
1340          * will just return the cache pointer.
1341          */
1342         if (error = port_fop_associate_source(&pfcp, pp, source)) {
1343                 goto errout;
1344         }
1345 
1346         /*
1347          * Check if there is an existing association of this file.
1348          */
1349         mutex_enter(&pfcp->pfc_lock);
1350         pfp = port_cache_lookup_fop(pfcp, curproc->p_pid, object);
1351 
1352         /*
1353          * If it is not the same vnode, just discard it. VN_RELE needs to be
1354          * called with no locks held, therefore save vnode pointers and
1355          * vn_rele them later.
1356          */
1357         if (pfp != NULL && (pfp->pfop_vp != vp || pfp->pfop_dvp != dvp)) {
1358                 (void) port_remove_fop(pfp, pfcp, 1, NULL, &oldvp, &olddvp);
1359                 pfp = NULL;
1360         }
1361 
1362         if (pfp == NULL) {
1363                 vnode_t *tvp, *tdvp;
1364                 portfop_t       *tpfp;
1365                 int error;
1366 
1367                 /*
1368                  * Add a new association, save the file name and the
1369                  * directory vnode pointer.
1370                  */
1371                 if (error = port_pfp_setup(&pfp, pp, vp, pfcp, object,
1372                     events, user, cname, clen, dvp)) {
1373                         mutex_exit(&pfcp->pfc_lock);
1374                         goto errout;
1375                 }
1376 
1377                 pfp->pfop_callrid = curthread;
1378                 /*
1379                  * File name used, so make sure we don't free it.
1380                  */
1381                 cname = NULL;
1382 
1383                 /*
1384                  * We need to check if the file was removed after the
1385                  * the lookup and before the fem hooks where added. If
1386                  * so, return error. The vnode will still exist as we have
1387                  * a hold on it.
1388                  *
1389                  * Drop the cache lock before calling port_fop_getdvp().
1390                  * port_fop_getdvp() may block either in the vfs layer
1391                  * or some filesystem.  Therefore there is potential
1392                  * for deadlock if cache lock is held and if some other
1393                  * thread is attempting to deliver file events which would
1394                  * require getting the cache lock, while it may be holding
1395                  * the filesystem or vfs layer locks.
1396                  */
1397                 mutex_exit(&pfcp->pfc_lock);
1398                 tvp = NULL;
1399                 if ((error = port_fop_getdvp(objptr, &tvp, NULL,
1400                     NULL, NULL, follow)) == 0) {
1401                         if (tvp != NULL) {
1402                                 tvp = port_resolve_vp(tvp);
1403                                 /*
1404                                  * This vnode pointer is just used
1405                                  * for comparison, so rele it
1406                                  */
1407                                 VN_RELE(tvp);
1408                         }
1409                 }
1410 
1411                 if (error || tvp == NULL || tvp != vp) {
1412                         /*
1413                          * Since we dropped the cache lock, make sure
1414                          * we are still dealing with the same pfp and this
1415                          * is the thread which registered it.
1416                          */
1417                         mutex_enter(&pfcp->pfc_lock);
1418                         tpfp = port_cache_lookup_fop(pfcp,
1419                             curproc->p_pid, object);
1420 
1421                         error = 0;
1422                         if (tpfp == NULL || tpfp != pfp ||
1423                             pfp->pfop_vp != vp ||
1424                             pfp->pfop_dvp != dvp ||
1425                             pfp->pfop_callrid != curthread) {
1426                                 /*
1427                                  * Some other event was delivered, the file
1428                                  * watch was removed or reassociated, just
1429                                  * ignore it and leave
1430                                  */
1431                                 mutex_exit(&pfcp->pfc_lock);
1432                                 goto errout;
1433                         }
1434 
1435                         /*
1436                          * remove the pfp and fem hooks, if pfp still
1437                          * active and it is not being removed from
1438                          * the vnode list. This is checked in
1439                          * port_remove_fop with the vnode lock held.
1440                          * The vnode returned is VN_RELE'ed after dropping
1441                          * the locks.
1442                          */
1443                         tdvp = tvp = NULL;
1444                         if (port_remove_fop(pfp, pfcp, 0, NULL, &tvp, &tdvp)) {
1445                                 /*
1446                                  * The pfp was removed, means no
1447                                  * events where queued. Report the
1448                                  * error now.
1449                                  */
1450                                 error = EINVAL;
1451                         }
1452                         mutex_exit(&pfcp->pfc_lock);
1453                         if (tvp != NULL)
1454                                 VN_RELE(tvp);
1455                         if (tdvp != NULL)
1456                                 VN_RELE(tdvp);
1457                         goto errout;
1458                 }
1459         } else {
1460                 portfop_vp_t    *pvp = vp->v_fopdata;
1461 
1462                 /*
1463                  * Re-association of the object.
1464                  */
1465                 mutex_enter(&pvp->pvp_mutex);
1466 
1467                 /*
1468                  * remove any queued up event.
1469                  */
1470                 if (port_remove_done_event(pfp->pfop_pev)) {
1471                         pfp->pfop_flags &= ~PORT_FOP_KEV_ONQ;
1472                 }
1473 
1474                 /*
1475                  * set new events to watch.
1476                  */
1477                 pfp->pfop_events = events;
1478 
1479                 /*
1480                  * If not active, mark it active even if it is being
1481                  * removed. Then it can send an exception event.
1482                  *
1483                  * Move it to the head, as the active ones are only
1484                  * in the beginning. If removing, the pfp will be on
1485                  * a temporary list, no need to move it to the front
1486                  * all the entries will be processed. Some exception
1487                  * events will be delivered in port_fop_excep();
1488                  */
1489                 if (!(pfp->pfop_flags & PORT_FOP_ACTIVE)) {
1490                         pfp->pfop_flags |= PORT_FOP_ACTIVE;
1491                         if (!(pfp->pfop_flags & PORT_FOP_REMOVING)) {
1492                                 pvp = (portfop_vp_t *)vp->v_fopdata;
1493                                 port_fop_listremove(pvp, pfp);
1494                                 port_fop_listinsert_head(pvp, pfp);
1495                         }
1496                 }
1497                 pfp->pfop_callrid = curthread;
1498                 mutex_exit(&pvp->pvp_mutex);
1499                 mutex_exit(&pfcp->pfc_lock);
1500         }
1501 
1502         /*
1503          * Compare time stamps and deliver events.
1504          */
1505         if (vp->v_type != VFIFO) {
1506                 port_check_timestamp(pfcp, vp, dvp, pfp, objptr, object);
1507         }
1508 
1509         error = 0;
1510 
1511         /*
1512          *  If we have too many watches on the vnode, discard an
1513          *  inactive watch.
1514          */
1515         port_fop_trimpfplist(vp);
1516 
1517 errout:
1518         /*
1519          * Release the hold acquired due to the lookup operation.
1520          */
1521         if (vp != NULL)
1522                 VN_RELE(vp);
1523         if (dvp != NULL)
1524                 VN_RELE(dvp);
1525 
1526         if (oldvp != NULL)
1527                 VN_RELE(oldvp);
1528         if (olddvp != NULL)
1529                 VN_RELE(olddvp);
1530 
1531         /*
1532          * copied file name not used, free it.
1533          */
1534         if (cname != NULL) {
1535                 kmem_free(cname, clen + 1);
1536         }
1537         return (error);
1538 }
1539 
1540 
1541 /*
1542  * The port_dissociate_fop() function dissociates the file object
1543  * from the event port and removes any events that are already on the queue.
1544  * Only the owner of the association is allowed to dissociate the file from
1545  * the port. Returns  success (0) if it was found and removed. Otherwise
1546  * ENOENT.
1547  */
1548 int
1549 port_dissociate_fop(port_t *pp, uintptr_t object)
1550 {
1551         portfop_cache_t *pfcp;
1552         portfop_t       *pfp;
1553         port_source_t   *pse;
1554         int             active = 0;
1555         vnode_t         *tvp = NULL, *tdvp = NULL;
1556 
1557         pse = port_getsrc(pp, PORT_SOURCE_FILE);
1558 
1559         /*
1560          * if this source is not associated or if there is no
1561          * cache, nothing to do just return.
1562          */
1563         if (pse == NULL ||
1564             (pfcp = (portfop_cache_t *)pse->portsrc_data) == NULL)
1565                 return (EINVAL);
1566 
1567         /*
1568          * Check if this object is on the cache. Only the owner pid
1569          * is allowed to dissociate.
1570          */
1571         mutex_enter(&pfcp->pfc_lock);
1572         pfp = port_cache_lookup_fop(pfcp, curproc->p_pid, object);
1573         if (pfp == NULL) {
1574                 mutex_exit(&pfcp->pfc_lock);
1575                 return (ENOENT);
1576         }
1577 
1578         /*
1579          * If this was the last association, it will release
1580          * the hold on the vnode. There is a race condition where
1581          * the the pfp is being removed due to an exception event
1582          * in port_fop_sendevent()->port_fop_excep() and port_remove_fop().
1583          * Since port source cache lock is held, port_fop_excep() cannot
1584          * complete. The vnode itself will not disappear as long its pfps
1585          * have a reference.
1586          */
1587         (void) port_remove_fop(pfp, pfcp, 1, &active, &tvp, &tdvp);
1588         mutex_exit(&pfcp->pfc_lock);
1589         if (tvp != NULL)
1590                 VN_RELE(tvp);
1591         if (tdvp != NULL)
1592                 VN_RELE(tdvp);
1593         return (active ? 0 : ENOENT);
1594 }
1595 
1596 
1597 /*
1598  * port_close() calls this function to request the PORT_SOURCE_FILE source
1599  * to remove/free all resources allocated and associated with the port.
1600  */
1601 
1602 /* ARGSUSED */
1603 static void
1604 port_close_fop(void *arg, int port, pid_t pid, int lastclose)
1605 {
1606         port_t          *pp = arg;
1607         portfop_cache_t *pfcp;
1608         portfop_t       **hashtbl;
1609         portfop_t       *pfp;
1610         portfop_t       *pfpnext;
1611         int             index, i;
1612         port_source_t   *pse;
1613         vnode_t         *tdvp = NULL;
1614         vnode_t         *vpl[PORTFOP_NVP];
1615 
1616         pse = port_getsrc(pp, PORT_SOURCE_FILE);
1617 
1618         /*
1619          * No source or no cache, nothing to do.
1620          */
1621         if (pse == NULL ||
1622             (pfcp = (portfop_cache_t *)pse->portsrc_data) == NULL)
1623                 return;
1624         /*
1625          * Scan the cache and free all allocated portfop_t and port_kevent_t
1626          * structures of this pid. Note, no new association for this pid will
1627          * be possible as the port is being closed.
1628          *
1629          * The common case is that the port is not shared and all the entries
1630          * are of this pid and have to be freed. Since VN_RELE has to be
1631          * called outside the lock, we do it in batches.
1632          */
1633         hashtbl = (portfop_t **)pfcp->pfc_hash;
1634         index = i = 0;
1635         bzero(vpl, sizeof (vpl));
1636         mutex_enter(&pfcp->pfc_lock);
1637         while (index < PORTFOP_HASHSIZE) {
1638                 pfp = hashtbl[index];
1639                 while (pfp != NULL && i < (PORTFOP_NVP - 1)) {
1640                         pfpnext = pfp->pfop_hashnext;
1641                         if (pid == pfp->pfop_pid) {
1642                                 (void) port_remove_fop(pfp, pfcp, 1, NULL,
1643                                     &vpl[i], &tdvp);
1644                                 if (vpl[i] != NULL) {
1645                                         i++;
1646                                 }
1647                                 if (tdvp != NULL) {
1648                                         vpl[i++] = tdvp;
1649                                         tdvp = NULL;
1650                                 }
1651                         }
1652                         pfp = pfpnext;
1653                 }
1654                 if (pfp == NULL)
1655                         index++;
1656                 /*
1657                  * Now call VN_RELE if we have collected enough vnodes or
1658                  * we have reached the end of the hash table.
1659                  */
1660                 if (i >= (PORTFOP_NVP - 1) ||
1661                     (i > 0 && index == PORTFOP_HASHSIZE)) {
1662                         mutex_exit(&pfcp->pfc_lock);
1663                         while (i > 0) {
1664                                 VN_RELE(vpl[--i]);
1665                                 vpl[i] = NULL;
1666                         }
1667                         mutex_enter(&pfcp->pfc_lock);
1668                 }
1669         }
1670 
1671         /*
1672          * Due to a race between port_close_fop() and port_fop()
1673          * trying to remove the pfp's from the port's cache, it is
1674          * possible that some pfp's are still in the process of being
1675          * freed so we wait.
1676          */
1677         while (lastclose && pfcp->pfc_objcount) {
1678                 (void) cv_wait_sig(&pfcp->pfc_lclosecv, &pfcp->pfc_lock);
1679         }
1680         mutex_exit(&pfcp->pfc_lock);
1681         /*
1682          * last close, free the cache.
1683          */
1684         if (lastclose) {
1685                 ASSERT(pfcp->pfc_objcount == 0);
1686                 pse->portsrc_data = NULL;
1687                 kmem_free(pfcp, sizeof (portfop_cache_t));
1688         }
1689 }
1690 
1691 /*
1692  * Given the list of associations(watches), it will send exception events,
1693  * if still active, and discard them. The exception events are handled
1694  * separately because, the pfp needs to be removed from the port cache and
1695  * freed as the vnode's identity is changing or being removed. To remove
1696  * the pfp from the port's cache, we need to hold the cache lock (pfc_lock).
1697  * The lock order is pfc_lock -> pvp_mutex(vnode's) mutex and that is why
1698  * the cache's lock cannot be acquired in port_fop_sendevent().
1699  */
1700 static void
1701 port_fop_excep(list_t *tlist, int op)
1702 {
1703         portfop_t       *pfp;
1704         portfop_cache_t *pfcp;
1705         port_t  *pp;
1706         port_kevent_t   *pkevp;
1707         vnode_t         *tdvp;
1708         int             error = 0;
1709 
1710         while (pfp = (portfop_t *)list_head(tlist)) {
1711                 int removed = 0;
1712                 /*
1713                  * remove from the temp list. Since PORT_FOP_REMOVING is
1714                  * set, no other thread should attempt to perform a
1715                  * list_remove on this pfp.
1716                  */
1717                 list_remove(tlist, pfp);
1718 
1719                 pfcp = pfp->pfop_pcache;
1720                 mutex_enter(&pfcp->pfc_lock);
1721 
1722                 /*
1723                  * Remove the event from the port queue if it was queued up.
1724                  * No need to clear the PORT_FOP_KEV_ONQ flag as this pfp is
1725                  * no longer on the vnode's list.
1726                  */
1727                 if ((pfp->pfop_flags & PORT_FOP_KEV_ONQ)) {
1728                         removed = port_remove_done_event(pfp->pfop_pev);
1729                 }
1730 
1731                 /*
1732                  * If still active or the event was queued up and
1733                  * had not been collected yet, send an EXCEPTION event.
1734                  */
1735                 if (pfp->pfop_flags & (PORT_FOP_ACTIVE) || removed) {
1736                         pp = pfp->pfop_pp;
1737                         /*
1738                          * Allocate a port_kevent_t non cached to send this
1739                          * event since we will be de-registering.
1740                          * The port_kevent_t cannot be pointing back to the
1741                          * pfp anymore.
1742                          */
1743                         pfp->pfop_flags &= ~PORT_FOP_ACTIVE;
1744                         error = port_alloc_event_local(pp, PORT_SOURCE_FILE,
1745                             PORT_ALLOC_DEFAULT, &pkevp);
1746                         if (!error) {
1747 
1748                                 pkevp->portkev_callback = port_fop_callback;
1749                                 pkevp->portkev_arg = NULL;
1750                                 pkevp->portkev_object =
1751                                     pfp->pfop_pev->portkev_object;
1752                                 pkevp->portkev_user =
1753                                     pfp->pfop_pev->portkev_user;
1754                                 /*
1755                                  * Copy the pid of the watching process.
1756                                  */
1757                                 pkevp->portkev_pid =
1758                                     pfp->pfop_pev->portkev_pid;
1759                                 pkevp->portkev_events = op;
1760                                 port_send_event(pkevp);
1761                         }
1762                 }
1763                 /*
1764                  * At this point the pfp has been removed from the vnode's
1765                  * list its cached port_kevent_t is not on the done queue.
1766                  * Remove the pfp and free it from the cache.
1767                  */
1768                 tdvp = pfp->pfop_dvp;
1769                 port_pcache_remove_fop(pfcp, pfp);
1770                 mutex_exit(&pfcp->pfc_lock);
1771                 if (tdvp != NULL)
1772                         VN_RELE(tdvp);
1773         }
1774 }
1775 
1776 /*
1777  * Send the file events to all of the processes watching this
1778  * vnode. In case of hard links, the directory vnode pointer and
1779  * the file name are compared. If the names match, then the specified
1780  * event is sent or else, the FILE_ATTRIB event is sent, This is the
1781  * documented behavior.
1782  */
1783 void
1784 port_fop_sendevent(vnode_t *vp, int events, vnode_t *dvp, char *cname)
1785 {
1786         port_kevent_t   *pkevp;
1787         portfop_t       *pfp, *npfp;
1788         portfop_vp_t    *pvp;
1789         list_t          tmplist;
1790         int             removeall = 0;
1791 
1792         pvp = (portfop_vp_t *)vp->v_fopdata;
1793         mutex_enter(&pvp->pvp_mutex);
1794 
1795         /*
1796          * Check if the list is empty.
1797          *
1798          * All entries have been removed by some other thread.
1799          * The vnode may be still active and we got called,
1800          * but some other thread is in the process of removing the hooks.
1801          */
1802         if (!list_head(&pvp->pvp_pfoplist)) {
1803                 mutex_exit(&pvp->pvp_mutex);
1804                 return;
1805         }
1806 
1807         if ((events & (FILE_EXCEPTION))) {
1808                 /*
1809                  * If it is an event for which we are going to remove
1810                  * the watches so just move it a temporary list and
1811                  * release this vnode.
1812                  */
1813                 list_create(&tmplist, sizeof (portfop_t),
1814                     offsetof(portfop_t, pfop_node));
1815 
1816                 /*
1817                  * If it is an UNMOUNT, MOUNTEDOVER or no file name has been
1818                  * passed for an exception event, all associations need to be
1819                  * removed.
1820                  */
1821                 if (dvp == NULL || cname == NULL) {
1822                         removeall = 1;
1823                 }
1824         }
1825 
1826         if (!removeall) {
1827                 /*
1828                  * All the active ones are in the beginning of the list.
1829                  * Note that we process this list in reverse order to assure
1830                  * that events are delivered in the order that they were
1831                  * associated.
1832                  */
1833                 for (pfp = (portfop_t *)list_tail(&pvp->pvp_pfoplist);
1834                     pfp && !(pfp->pfop_flags & PORT_FOP_ACTIVE); pfp = npfp) {
1835                         npfp = list_prev(&pvp->pvp_pfoplist, pfp);
1836                 }
1837 
1838                 for (; pfp != NULL; pfp = npfp) {
1839                         int levents = events;
1840 
1841                         npfp = list_prev(&pvp->pvp_pfoplist, pfp);
1842                         /*
1843                          * Hard links case - If the file is being
1844                          * removed/renamed, and the name matches
1845                          * the watched file, then it is an EXCEPTION
1846                          * event or else it will be just a FILE_ATTRIB.
1847                          */
1848                         if ((events & (FILE_EXCEPTION))) {
1849                                 ASSERT(dvp != NULL && cname != NULL);
1850                                 if (pfp->pfop_dvp == NULL ||
1851                                     (pfp->pfop_dvp == dvp &&
1852                                     (strcmp(cname, pfp->pfop_cname) == 0))) {
1853                                         /*
1854                                          * It is an exception event, move it
1855                                          * to temp list and process it later.
1856                                          * Note we don't set the pfp->pfop_vp
1857                                          * to NULL even thought it has been
1858                                          * removed from the vnode's list. This
1859                                          * pointer is referenced in
1860                                          * port_remove_fop(). The vnode it
1861                                          * self cannot disappear until this
1862                                          * pfp gets removed and freed.
1863                                          */
1864                                         port_fop_listremove(pvp, pfp);
1865                                         list_insert_tail(&tmplist, (void *)pfp);
1866                                         pfp->pfop_flags  |= PORT_FOP_REMOVING;
1867                                         continue;
1868                                 } else {
1869                                         levents = FILE_ATTRIB;
1870                                 }
1871 
1872                         }
1873 
1874                         if (pfp->pfop_events & levents) {
1875                                 /*
1876                                  * deactivate and move it to the tail.
1877                                  * If the pfp was active, it cannot be
1878                                  * on the port's done queue.
1879                                  */
1880                                 pfp->pfop_flags &= ~PORT_FOP_ACTIVE;
1881                                 port_fop_listremove(pvp, pfp);
1882                                 port_fop_listinsert_tail(pvp, pfp);
1883 
1884                                 pkevp = pfp->pfop_pev;
1885                                 pkevp->portkev_events |=
1886                                     (levents & pfp->pfop_events);
1887                                 port_send_event(pkevp);
1888                                 pfp->pfop_flags |= PORT_FOP_KEV_ONQ;
1889                         }
1890                 }
1891         }
1892 
1893 
1894         if ((events & (FILE_EXCEPTION))) {
1895                 if (!removeall) {
1896                         /*
1897                          * Check the inactive associations and remove them if
1898                          * the file name matches.
1899                          */
1900                         for (; pfp; pfp = npfp) {
1901                                 npfp = list_next(&pvp->pvp_pfoplist, pfp);
1902                                 if (dvp == NULL || cname == NULL ||
1903                                     pfp->pfop_dvp == NULL ||
1904                                     (pfp->pfop_dvp == dvp &&
1905                                     (strcmp(cname, pfp->pfop_cname) == 0))) {
1906                                         port_fop_listremove(pvp, pfp);
1907                                         list_insert_tail(&tmplist, (void *)pfp);
1908                                         pfp->pfop_flags  |= PORT_FOP_REMOVING;
1909                                 }
1910                         }
1911                 } else {
1912                         /*
1913                          * Can be optimized to avoid two pass over this list
1914                          * by having a flag in the vnode's portfop_vp_t
1915                          * structure to indicate that it is going away,
1916                          * Or keep the list short by reusing inactive watches.
1917                          */
1918                         port_fop_listmove(pvp, &tmplist);
1919                         for (pfp = (portfop_t *)list_head(&tmplist);
1920                             pfp; pfp = list_next(&tmplist, pfp)) {
1921                                 pfp->pfop_flags |= PORT_FOP_REMOVING;
1922                         }
1923                 }
1924 
1925                 /*
1926                  * Uninstall the fem hooks if there are no more associations.
1927                  * This will release the pvp mutex.
1928                  *
1929                  * Even thought all entries may have been removed,
1930                  * the vnode itself cannot disappear as there will be a
1931                  * hold on it due to this call to port_fop_sendevent. This is
1932                  * important to syncronize with a port_dissociate_fop() call
1933                  * that may be attempting to remove an object from the vnode's.
1934                  */
1935                 if (port_fop_femuninstall(vp))
1936                         VN_RELE(vp);
1937 
1938                 /*
1939                  * Send exception events and discard the watch entries.
1940                  */
1941                 port_fop_excep(&tmplist, events);
1942                 list_destroy(&tmplist);
1943 
1944         } else {
1945                 mutex_exit(&pvp->pvp_mutex);
1946 
1947                 /*
1948                  * trim the list.
1949                  */
1950                 port_fop_trimpfplist(vp);
1951         }
1952 }
1953 
1954 /*
1955  * Given the file operation, map it to the event types and send.
1956  */
1957 void
1958 port_fop(vnode_t *vp, int op, int retval)
1959 {
1960         int event = 0;
1961         /*
1962          * deliver events only if the operation was successful.
1963          */
1964         if (retval)
1965                 return;
1966 
1967         /*
1968          * These events occurring on the watched file.
1969          */
1970         if (op & FOP_MODIFIED_MASK) {
1971                 event  = FILE_MODIFIED;
1972         }
1973         if (op & FOP_ACCESS_MASK) {
1974                 event  |= FILE_ACCESS;
1975         }
1976         if (op & FOP_ATTRIB_MASK) {
1977                 event  |= FILE_ATTRIB;
1978         }
1979         if (op & FOP_TRUNC_MASK) {
1980                 event  |= FILE_TRUNC;
1981         }
1982         if (event) {
1983                 port_fop_sendevent(vp,  event, NULL, NULL);
1984         }
1985 }
1986 
1987 static int port_forceunmount(vfs_t *vfsp)
1988 {
1989         char *fsname = vfssw[vfsp->vfs_fstype].vsw_name;
1990 
1991         if (fsname == NULL) {
1992                 return (0);
1993         }
1994 
1995         if (strcmp(fsname, MNTTYPE_NFS) == 0) {
1996                 return (1);
1997         }
1998 
1999         if (strcmp(fsname, MNTTYPE_NFS3) == 0) {
2000                 return (1);
2001         }
2002 
2003         if (strcmp(fsname, MNTTYPE_NFS4) == 0) {
2004                 return (1);
2005         }
2006         return (0);
2007 }
2008 /*
2009  * ----- the unmount filesystem op(fsem) hook.
2010  */
2011 int
2012 port_fop_unmount(fsemarg_t *vf, int flag, cred_t *cr)
2013 {
2014         vfs_t   *vfsp = (vfs_t *)vf->fa_fnode->fn_available;
2015         kmutex_t        *mtx;
2016         portfop_vfs_t   *pvfsp, **ppvfsp;
2017         portfop_vp_t    *pvp;
2018         int error;
2019         int fmfs;
2020 
2021         fmfs = port_forceunmount(vfsp);
2022 
2023         mtx = &(portvfs_hash[PORTFOP_PVFSHASH(vfsp)].pvfshash_mutex);
2024         ppvfsp = &(portvfs_hash[PORTFOP_PVFSHASH(vfsp)].pvfshash_pvfsp);
2025         pvfsp = NULL;
2026         mutex_enter(mtx);
2027         /*
2028          * since this fsem hook is triggered, the vfsp has to be on
2029          * the hash list.
2030          */
2031         for (pvfsp = *ppvfsp; pvfsp->pvfs != vfsp; pvfsp = pvfsp->pvfs_next)
2032         ;
2033 
2034         /*
2035          * For some of the filesystems, allow unmounts to proceed only if
2036          * there are no files being watched or it is a forced unmount.
2037          */
2038         if (fmfs && !(flag & MS_FORCE) &&
2039             !list_is_empty(&pvfsp->pvfs_pvplist)) {
2040                 mutex_exit(mtx);
2041                 return (EBUSY);
2042         }
2043 
2044         /*
2045          * Indicate that the unmount is in process. Don't remove it yet.
2046          * The underlying filesystem unmount routine sets the VFS_UNMOUNTED
2047          * flag on the vfs_t structure. But we call the filesystem unmount
2048          * routine after removing all the file watches for this filesystem,
2049          * otherwise the unmount will fail due to active vnodes.
2050          * Meanwhile setting pvfsp->unmount = 1 will prevent any thread
2051          * attempting to add a file watch.
2052          */
2053         pvfsp->pvfs_unmount = 1;
2054         mutex_exit(mtx);
2055 
2056         /*
2057          * uninstall the fsem hooks.
2058          */
2059         (void) fsem_uninstall(vfsp, (fsem_t *)pvfsp->pvfs_fsemp, vfsp);
2060 
2061         while (pvp = list_head(&pvfsp->pvfs_pvplist)) {
2062                 list_remove(&pvfsp->pvfs_pvplist, pvp);
2063                 /*
2064                  * This should send an UNMOUNTED event to all the
2065                  * watched vnode of this filesystem and uninstall
2066                  * the fem hooks. We release the hold on the vnode here
2067                  * because port_fop_femuninstall() will not do it if
2068                  * unmount is in process.
2069                  */
2070                 port_fop_sendevent(pvp->pvp_vp, UNMOUNTED, NULL, NULL);
2071                 VN_RELE(pvp->pvp_vp);
2072         }
2073 
2074         error = vfsnext_unmount(vf, flag, cr);
2075 
2076         /*
2077          * we free the pvfsp after the unmount has been completed.
2078          */
2079         mutex_enter(mtx);
2080         for (; *ppvfsp && (*ppvfsp)->pvfs != vfsp;
2081             ppvfsp = &(*ppvfsp)->pvfs_next)
2082         ;
2083 
2084         /*
2085          * remove and free it.
2086          */
2087         ASSERT(list_head(&pvfsp->pvfs_pvplist) == NULL);
2088         if (*ppvfsp) {
2089                 pvfsp = *ppvfsp;
2090                 *ppvfsp = pvfsp->pvfs_next;
2091         }
2092         mutex_exit(mtx);
2093         kmem_free(pvfsp, sizeof (portfop_vfs_t));
2094         return (error);
2095 }
2096 
2097 /*
2098  * ------------------------------file op hooks--------------------------
2099  * The O_TRUNC operation is caught with the VOP_SETATTR(AT_SIZE) call.
2100  */
2101 static int
2102 port_fop_open(femarg_t *vf, int mode, cred_t *cr, caller_context_t *ct)
2103 {
2104         int             retval;
2105         vnode_t         *vp = (vnode_t *)vf->fa_fnode->fn_available;
2106 
2107         retval = vnext_open(vf, mode, cr, ct);
2108         port_fop(vp, FOP_FILE_OPEN, retval);
2109         return (retval);
2110 }
2111 
2112 static int
2113 port_fop_write(femarg_t *vf, struct uio *uiop, int ioflag, struct cred *cr,
2114     caller_context_t *ct)
2115 {
2116         int             retval;
2117         vnode_t         *vp = (vnode_t *)vf->fa_fnode->fn_available;
2118 
2119         retval =  vnext_write(vf, uiop, ioflag, cr, ct);
2120         port_fop(vp, FOP_FILE_WRITE, retval);
2121         return (retval);
2122 }
2123 
2124 static int
2125 port_fop_map(femarg_t *vf, offset_t off, struct as *as, caddr_t *addrp,
2126     size_t len, uchar_t prot, uchar_t maxport, uint_t flags, cred_t *cr,
2127     caller_context_t *ct)
2128 {
2129         int             retval;
2130         vnode_t         *vp = (vnode_t *)vf->fa_fnode->fn_available;
2131 
2132         retval =  vnext_map(vf, off, as, addrp, len, prot, maxport,
2133             flags, cr, ct);
2134         port_fop(vp, FOP_FILE_MAP, retval);
2135         return (retval);
2136 }
2137 
2138 static int
2139 port_fop_read(femarg_t *vf, struct uio *uiop, int ioflag, struct cred *cr,
2140     caller_context_t *ct)
2141 {
2142         int             retval;
2143         vnode_t         *vp = (vnode_t *)vf->fa_fnode->fn_available;
2144 
2145         retval =  vnext_read(vf, uiop, ioflag, cr, ct);
2146         port_fop(vp, FOP_FILE_READ, retval);
2147         return (retval);
2148 }
2149 
2150 
2151 /*
2152  * AT_SIZE - is for the open(O_TRUNC) case.
2153  */
2154 int
2155 port_fop_setattr(femarg_t *vf, vattr_t *vap, int flags, cred_t *cr,
2156     caller_context_t *ct)
2157 {
2158         int             retval;
2159         vnode_t         *vp = (vnode_t *)vf->fa_fnode->fn_available;
2160         int             events = 0;
2161 
2162         retval = vnext_setattr(vf, vap, flags, cr, ct);
2163         if (vap->va_mask & AT_SIZE) {
2164                 events |= FOP_FILE_TRUNC;
2165         }
2166         if (vap->va_mask & (AT_SIZE|AT_MTIME)) {
2167                 events |= FOP_FILE_SETATTR_MTIME;
2168         }
2169         if (vap->va_mask & AT_ATIME) {
2170                 events |= FOP_FILE_SETATTR_ATIME;
2171         }
2172         events |= FOP_FILE_SETATTR_CTIME;
2173 
2174         port_fop(vp, events, retval);
2175         return (retval);
2176 }
2177 
2178 int
2179 port_fop_create(femarg_t *vf, char *name, vattr_t *vap, vcexcl_t excl,
2180     int mode, vnode_t **vpp, cred_t *cr, int flag,
2181     caller_context_t *ct, vsecattr_t *vsecp)
2182 {
2183         int             retval, got = 1;
2184         vnode_t         *vp = (vnode_t *)vf->fa_fnode->fn_available;
2185         vattr_t         vatt, vatt1;
2186 
2187         /*
2188          * If the file already exists, then there will be no change
2189          * to the directory. Therefore, we need to compare the
2190          * modification time of the directory to determine if the
2191          * file was actually created.
2192          */
2193         vatt.va_mask = AT_ATIME|AT_MTIME|AT_CTIME;
2194         if (VOP_GETATTR(vp, &vatt, 0, CRED(), ct)) {
2195                 got = 0;
2196         }
2197         retval = vnext_create(vf, name, vap, excl, mode, vpp, cr,
2198             flag, ct, vsecp);
2199 
2200         vatt1.va_mask = AT_ATIME|AT_MTIME|AT_CTIME;
2201         if (got && !VOP_GETATTR(vp, &vatt1, 0, CRED(), ct)) {
2202                 if ((vatt1.va_mtime.tv_sec > vatt.va_mtime.tv_sec ||
2203                     (vatt1.va_mtime.tv_sec = vatt.va_mtime.tv_sec &&
2204                     vatt1.va_mtime.tv_nsec > vatt.va_mtime.tv_nsec))) {
2205                         /*
2206                          * File was created.
2207                          */
2208                         port_fop(vp, FOP_FILE_CREATE, retval);
2209                 }
2210         }
2211         return (retval);
2212 }
2213 
2214 int
2215 port_fop_remove(femarg_t *vf, char *nm, cred_t *cr, caller_context_t *ct,
2216     int flags)
2217 {
2218         int             retval;
2219         vnode_t         *vp = (vnode_t *)vf->fa_fnode->fn_available;
2220 
2221         retval = vnext_remove(vf, nm, cr, ct, flags);
2222         port_fop(vp, FOP_FILE_REMOVE, retval);
2223         return (retval);
2224 }
2225 
2226 int
2227 port_fop_link(femarg_t *vf, vnode_t *svp, char *tnm, cred_t *cr,
2228     caller_context_t *ct, int flags)
2229 {
2230         int             retval;
2231         vnode_t         *vp = (vnode_t *)vf->fa_fnode->fn_available;
2232 
2233         retval = vnext_link(vf, svp, tnm, cr, ct, flags);
2234         port_fop(vp, FOP_FILE_LINK, retval);
2235         return (retval);
2236 }
2237 
2238 /*
2239  * Rename operation is allowed only when from and to directories are
2240  * on the same filesystem. This is checked in vn_rename().
2241  * The target directory is notified thru a VNEVENT by the filesystem
2242  * if the source dir != target dir.
2243  */
2244 int
2245 port_fop_rename(femarg_t *vf, char *snm, vnode_t *tdvp, char *tnm, cred_t *cr,
2246     caller_context_t *ct, int flags)
2247 {
2248         int             retval;
2249         vnode_t         *vp = (vnode_t *)vf->fa_fnode->fn_available;
2250 
2251         retval = vnext_rename(vf, snm, tdvp, tnm, cr, ct, flags);
2252         port_fop(vp, FOP_FILE_RENAMESRC, retval);
2253         return (retval);
2254 }
2255 
2256 int
2257 port_fop_mkdir(femarg_t *vf, char *dirname, vattr_t *vap, vnode_t **vpp,
2258     cred_t *cr, caller_context_t *ct, int flags, vsecattr_t *vsecp)
2259 {
2260         int             retval;
2261         vnode_t         *vp = (vnode_t *)vf->fa_fnode->fn_available;
2262 
2263         retval = vnext_mkdir(vf, dirname, vap, vpp, cr, ct, flags, vsecp);
2264         port_fop(vp, FOP_FILE_MKDIR, retval);
2265         return (retval);
2266 }
2267 
2268 int
2269 port_fop_rmdir(femarg_t *vf, char *nm, vnode_t *cdir, cred_t *cr,
2270     caller_context_t *ct, int flags)
2271 {
2272         int             retval;
2273         vnode_t         *vp = (vnode_t *)vf->fa_fnode->fn_available;
2274 
2275         retval = vnext_rmdir(vf, nm, cdir, cr, ct, flags);
2276         port_fop(vp, FOP_FILE_RMDIR, retval);
2277         return (retval);
2278 }
2279 
2280 int
2281 port_fop_readdir(femarg_t *vf, uio_t *uiop, cred_t *cr, int *eofp,
2282     caller_context_t *ct, int flags)
2283 {
2284         int             retval;
2285         vnode_t         *vp = (vnode_t *)vf->fa_fnode->fn_available;
2286 
2287         retval = vnext_readdir(vf, uiop, cr, eofp, ct, flags);
2288         port_fop(vp, FOP_FILE_READDIR, retval);
2289         return (retval);
2290 }
2291 
2292 int
2293 port_fop_symlink(femarg_t *vf, char *linkname, vattr_t *vap, char *target,
2294     cred_t *cr, caller_context_t *ct, int flags)
2295 {
2296         int             retval;
2297         vnode_t         *vp = (vnode_t *)vf->fa_fnode->fn_available;
2298 
2299         retval = vnext_symlink(vf, linkname, vap, target, cr, ct, flags);
2300         port_fop(vp, FOP_FILE_SYMLINK, retval);
2301         return (retval);
2302 }
2303 
2304 /*
2305  * acl, facl call this.
2306  */
2307 int
2308 port_fop_setsecattr(femarg_t *vf, vsecattr_t *vsap, int flags, cred_t *cr,
2309     caller_context_t *ct)
2310 {
2311         int     retval;
2312         vnode_t         *vp = (vnode_t *)vf->fa_fnode->fn_available;
2313         retval = vnext_setsecattr(vf, vsap, flags, cr, ct);
2314         port_fop(vp, FOP_FILE_SETSECATTR, retval);
2315         return (retval);
2316 }
2317 
2318 /*
2319  * these are events on the watched file/directory
2320  */
2321 int
2322 port_fop_vnevent(femarg_t *vf, vnevent_t vnevent, vnode_t *dvp, char *name,
2323     caller_context_t *ct)
2324 {
2325         vnode_t         *vp = (vnode_t *)vf->fa_fnode->fn_available;
2326 
2327         switch (vnevent) {
2328         case    VE_RENAME_SRC:
2329                         port_fop_sendevent(vp, FILE_RENAME_FROM, dvp, name);
2330                 break;
2331         case    VE_RENAME_DEST:
2332                         port_fop_sendevent(vp, FILE_RENAME_TO, dvp, name);
2333                 break;
2334         case    VE_REMOVE:
2335                         port_fop_sendevent(vp, FILE_DELETE, dvp, name);
2336                 break;
2337         case    VE_RMDIR:
2338                         port_fop_sendevent(vp, FILE_DELETE, dvp, name);
2339                 break;
2340         case    VE_CREATE:
2341                         port_fop_sendevent(vp,
2342                             FILE_MODIFIED|FILE_ATTRIB|FILE_TRUNC, NULL, NULL);
2343                 break;
2344         case    VE_LINK:
2345                         port_fop_sendevent(vp, FILE_ATTRIB, NULL, NULL);
2346                 break;
2347 
2348         case    VE_RENAME_DEST_DIR:
2349                         port_fop_sendevent(vp, FILE_MODIFIED|FILE_ATTRIB,
2350                             NULL, NULL);
2351                 break;
2352 
2353         case    VE_MOUNTEDOVER:
2354                         port_fop_sendevent(vp, MOUNTEDOVER, NULL, NULL);
2355                 break;
2356         case    VE_TRUNCATE:
2357                         port_fop_sendevent(vp, FILE_TRUNC, NULL, NULL);
2358                 break;
2359         default:
2360                 break;
2361         }
2362         return (vnext_vnevent(vf, vnevent, dvp, name, ct));
2363 }