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) 2018, Joyent, Inc.
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 *
port_fop_femop()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 (atomic_cas_ptr(&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 *
port_fop_fsemop()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 (atomic_cas_ptr(&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
port_fop_callback(void * arg,int * events,pid_t pid,int flag,void * evp)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
port_pcache_insert(portfop_cache_t * pfcp,portfop_t * pfp)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
port_pcache_delete(portfop_cache_t * pfcp,portfop_t * pfp)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
port_fop_listinsert(portfop_vp_t * pvp,portfop_t * pfp,int where)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
port_fop_listinsert_head(portfop_vp_t * pvp,portfop_t * pfp)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
port_fop_listinsert_tail(portfop_vp_t * pvp,portfop_t * pfp)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
port_fop_listremove(portfop_vp_t * pvp,portfop_t * pfp)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
port_fop_listmove(portfop_vp_t * pvp,list_t * tlist)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
port_pcache_remove_fop(portfop_cache_t * pfcp,portfop_t * pfp)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
port_fop_trimpfplist(vnode_t * vp)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
port_fop_femuninstall(vnode_t * vp)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
port_remove_fop(portfop_t * pfp,portfop_cache_t * pfcp,int cleanup,int * active,vnode_t ** vpp,vnode_t ** dvpp)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 *
port_cache_lookup_fop(portfop_cache_t * pfcp,pid_t pid,uintptr_t obj)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
port_fop_getdvp(void * objptr,vnode_t ** vp,vnode_t ** dvp,char ** cname,int * len,int follow)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 *
port_getsrc(port_t * pp,int source)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
port_check_timestamp(portfop_cache_t * pfcp,vnode_t * vp,vnode_t * dvp,portfop_t * pfp,void * objptr,uintptr_t object)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
port_fop_associate_source(portfop_cache_t ** pfcpp,port_t * pp,int source)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
port_fop_pvfsadd(portfop_vp_t * pvp)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
port_install_fopdata(vnode_t * vp)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 (atomic_cas_ptr(&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
port_pfp_setup(portfop_t ** pfpp,port_t * pp,vnode_t * vp,portfop_cache_t * pfcp,uintptr_t object,int events,void * user,char * cname,int clen,vnode_t * dvp)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 *
port_resolve_vp(vnode_t * vp)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
port_associate_fop(port_t * pp,int source,uintptr_t object,int events,void * user)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
port_dissociate_fop(port_t * pp,uintptr_t object)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
port_close_fop(void * arg,int port,pid_t pid,int lastclose)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
port_fop_excep(list_t * tlist,int op)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
port_fop_sendevent(vnode_t * vp,int events,vnode_t * dvp,char * cname)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
port_fop(vnode_t * vp,int op,int retval)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 
port_forceunmount(vfs_t * vfsp)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
port_fop_unmount(fsemarg_t * vf,int flag,cred_t * cr)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
port_fop_open(femarg_t * vf,int mode,cred_t * cr,caller_context_t * ct)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
port_fop_write(femarg_t * vf,struct uio * uiop,int ioflag,struct cred * cr,caller_context_t * ct)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
port_fop_map(femarg_t * vf,offset_t off,struct as * as,caddr_t * addrp,size_t len,uchar_t prot,uchar_t maxport,uint_t flags,cred_t * cr,caller_context_t * ct)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
port_fop_read(femarg_t * vf,struct uio * uiop,int ioflag,struct cred * cr,caller_context_t * ct)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
port_fop_setattr(femarg_t * vf,vattr_t * vap,int flags,cred_t * cr,caller_context_t * ct)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
port_fop_create(femarg_t * vf,char * name,vattr_t * vap,vcexcl_t excl,int mode,vnode_t ** vpp,cred_t * cr,int flag,caller_context_t * ct,vsecattr_t * vsecp)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
port_fop_remove(femarg_t * vf,char * nm,cred_t * cr,caller_context_t * ct,int flags)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
port_fop_link(femarg_t * vf,vnode_t * svp,char * tnm,cred_t * cr,caller_context_t * ct,int flags)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
port_fop_rename(femarg_t * vf,char * snm,vnode_t * tdvp,char * tnm,cred_t * cr,caller_context_t * ct,int flags)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
port_fop_mkdir(femarg_t * vf,char * dirname,vattr_t * vap,vnode_t ** vpp,cred_t * cr,caller_context_t * ct,int flags,vsecattr_t * vsecp)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
port_fop_rmdir(femarg_t * vf,char * nm,vnode_t * cdir,cred_t * cr,caller_context_t * ct,int flags)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
port_fop_readdir(femarg_t * vf,uio_t * uiop,cred_t * cr,int * eofp,caller_context_t * ct,int flags)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
port_fop_symlink(femarg_t * vf,char * linkname,vattr_t * vap,char * target,cred_t * cr,caller_context_t * ct,int flags)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
port_fop_setsecattr(femarg_t * vf,vsecattr_t * vsap,int flags,cred_t * cr,caller_context_t * ct)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
port_fop_vnevent(femarg_t * vf,vnevent_t vnevent,vnode_t * dvp,char * name,caller_context_t * ct)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 }
2364