xref: /illumos-gate/usr/src/uts/common/fs/smbsrv/smb_node.c (revision 4282a9f9db1981e6d51d924c785f407b6fe5c5bb)
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 (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
23  * Copyright 2017 Nexenta Systems, Inc.  All rights reserved.
24  */
25 /*
26  * SMB Node State Machine
27  * ----------------------
28  *
29  *
30  *		    +----------- Creation/Allocation
31  *		    |
32  *		    | T0
33  *		    |
34  *		    v
35  *    +----------------------------+
36  *    |  SMB_NODE_STATE_AVAILABLE  |
37  *    +----------------------------+
38  *		    |
39  *		    | T1
40  *		    |
41  *		    v
42  *    +-----------------------------+
43  *    |  SMB_NODE_STATE_DESTROYING  |
44  *    +-----------------------------+
45  *		    |
46  *		    |
47  *		    | T2
48  *		    |
49  *		    +----------> Deletion/Free
50  *
51  * Transition T0
52  *
53  *    This transition occurs in smb_node_lookup(). If the node looked for is
54  *    not found in the has table a new node is created. The reference count is
55  *    initialized to 1 and the state initialized to SMB_NODE_STATE_AVAILABLE.
56  *
57  * Transition T1
58  *
59  *    This transition occurs in smb_node_release(). If the reference count
60  *    drops to zero the state is moved to SMB_NODE_STATE_DESTROYING and no more
61  *    reference count will be given out for that node.
62  *
63  * Transition T2
64  *
65  *    This transition occurs in smb_node_release(). The structure is deleted.
66  *
67  * Comments
68  * --------
69  *
70  *    The reason the smb node has 2 states is the following synchronization
71  *    rule:
72  *
73  *    There's a mutex embedded in the node used to protect its fields and
74  *    there's a lock embedded in the bucket of the hash table the node belongs
75  *    to. To increment or to decrement the reference count the mutex must be
76  *    entered. To insert the node into the bucket and to remove it from the
77  *    bucket the lock must be entered in RW_WRITER mode. When both (mutex and
78  *    lock) have to be entered, the lock has always to be entered first then
79  *    the mutex. This prevents a deadlock between smb_node_lookup() and
80  *    smb_node_release() from occurring. However, in smb_node_release() when the
81  *    reference count drops to zero and triggers the deletion of the node, the
82  *    mutex has to be released before entering the lock of the bucket (to
83  *    remove the node). This creates a window during which the node that is
84  *    about to be freed could be given out by smb_node_lookup(). To close that
85  *    window the node is moved to the state SMB_NODE_STATE_DESTROYING before
86  *    releasing the mutex. That way, even if smb_node_lookup() finds it, the
87  *    state will indicate that the node should be treated as non existent (of
88  *    course the state of the node should be tested/updated under the
89  *    protection of the mutex).
90  */
91 #include <smbsrv/smb_kproto.h>
92 #include <smbsrv/smb_fsops.h>
93 #include <smbsrv/smb_kstat.h>
94 #include <sys/ddi.h>
95 #include <sys/extdirent.h>
96 #include <sys/pathname.h>
97 #include <sys/sdt.h>
98 #include <sys/nbmlock.h>
99 #include <fs/fs_reparse.h>
100 
101 uint32_t smb_is_executable(char *);
102 static void smb_node_delete_on_close(smb_node_t *);
103 static void smb_node_create_audit_buf(smb_node_t *, int);
104 static void smb_node_destroy_audit_buf(smb_node_t *);
105 static void smb_node_audit(smb_node_t *);
106 static smb_node_t *smb_node_alloc(char *, vnode_t *, smb_llist_t *, uint32_t);
107 static void smb_node_free(smb_node_t *);
108 static int smb_node_constructor(void *, void *, int);
109 static void smb_node_destructor(void *, void *);
110 static smb_llist_t *smb_node_get_hash(fsid_t *, smb_attr_t *, uint32_t *);
111 
112 static void smb_node_init_reparse(smb_node_t *, smb_attr_t *);
113 static void smb_node_init_system(smb_node_t *);
114 
115 #define	VALIDATE_DIR_NODE(_dir_, _node_) \
116     ASSERT((_dir_)->n_magic == SMB_NODE_MAGIC); \
117     ASSERT(((_dir_)->vp->v_xattrdir) || ((_dir_)->vp->v_type == VDIR)); \
118     ASSERT((_dir_)->n_dnode != (_node_));
119 
120 /* round sz to DEV_BSIZE block */
121 #define	SMB_ALLOCSZ(sz)	(((sz) + DEV_BSIZE-1) & ~(DEV_BSIZE-1))
122 
123 static kmem_cache_t	*smb_node_cache = NULL;
124 static smb_llist_t	smb_node_hash_table[SMBND_HASH_MASK+1];
125 static smb_node_t	*smb_root_node;
126 
127 /*
128  * smb_node_init
129  *
130  * Initialization of the SMB node layer.
131  *
132  * This function is not multi-thread safe. The caller must make sure only one
133  * thread makes the call.
134  */
135 void
136 smb_node_init(void)
137 {
138 	smb_attr_t	attr;
139 	smb_llist_t	*node_hdr;
140 	smb_node_t	*node;
141 	uint32_t	hashkey;
142 	int		i;
143 
144 	if (smb_node_cache != NULL)
145 		return;
146 
147 	smb_node_cache = kmem_cache_create(SMBSRV_KSTAT_NODE_CACHE,
148 	    sizeof (smb_node_t), 8, smb_node_constructor, smb_node_destructor,
149 	    NULL, NULL, NULL, 0);
150 
151 	for (i = 0; i <= SMBND_HASH_MASK; i++) {
152 		smb_llist_constructor(&smb_node_hash_table[i],
153 		    sizeof (smb_node_t), offsetof(smb_node_t, n_lnd));
154 	}
155 
156 	/*
157 	 * The node cache is shared by all zones, so the smb_root_node
158 	 * must represent the real (global zone) rootdir.
159 	 * Note intentional use of kcred here.
160 	 */
161 	attr.sa_mask = SMB_AT_ALL;
162 	VERIFY0(smb_vop_getattr(rootdir, NULL, &attr, 0, kcred));
163 	node_hdr = smb_node_get_hash(&rootdir->v_vfsp->vfs_fsid, &attr,
164 	    &hashkey);
165 	node = smb_node_alloc("/", rootdir, node_hdr, hashkey);
166 	smb_llist_enter(node_hdr, RW_WRITER);
167 	smb_llist_insert_head(node_hdr, node);
168 	smb_llist_exit(node_hdr);
169 	smb_root_node = node;	/* smb_node_release in smb_node_fini */
170 }
171 
172 /*
173  * smb_node_fini
174  *
175  * This function is not multi-thread safe. The caller must make sure only one
176  * thread makes the call.
177  */
178 void
179 smb_node_fini(void)
180 {
181 	int	i;
182 
183 	if (smb_root_node != NULL) {
184 		smb_node_release(smb_root_node);
185 		smb_root_node = NULL;
186 	}
187 
188 	if (smb_node_cache == NULL)
189 		return;
190 
191 #ifdef DEBUG
192 	for (i = 0; i <= SMBND_HASH_MASK; i++) {
193 		smb_node_t	*node;
194 
195 		/*
196 		 * The following sequence is just intended for sanity check.
197 		 * This will have to be modified when the code goes into
198 		 * production.
199 		 *
200 		 * The SMB node hash table should be emtpy at this point. If the
201 		 * hash table is not empty a panic will be triggered.
202 		 *
203 		 * The reason why SMB nodes are still remaining in the hash
204 		 * table is problably due to a mismatch between calls to
205 		 * smb_node_lookup() and smb_node_release(). You must track that
206 		 * down.
207 		 */
208 		node = smb_llist_head(&smb_node_hash_table[i]);
209 		ASSERT(node == NULL);
210 	}
211 #endif
212 
213 	for (i = 0; i <= SMBND_HASH_MASK; i++) {
214 		smb_llist_destructor(&smb_node_hash_table[i]);
215 	}
216 	kmem_cache_destroy(smb_node_cache);
217 	smb_node_cache = NULL;
218 }
219 
220 /*
221  * smb_node_lookup()
222  *
223  * NOTE: This routine should only be called by the file system interface layer,
224  * and not by SMB.
225  *
226  * smb_node_lookup() is called upon successful lookup, mkdir, and create
227  * (for both non-streams and streams).  In each of these cases, a held vnode is
228  * passed into this routine.  If a new smb_node is created it will take its
229  * own hold on the vnode.  The caller's hold therefore still belongs to, and
230  * should be released by, the caller.
231  *
232  * A reference is taken on the smb_node whether found in the hash table
233  * or newly created.
234  *
235  * If an smb_node needs to be created, a reference is also taken on the
236  * dnode (if passed in).
237  *
238  * See smb_node_release() for details on the release of these references.
239  */
240 
241 /*ARGSUSED*/
242 smb_node_t *
243 smb_node_lookup(
244     struct smb_request	*sr,
245     struct open_param	*op,
246     cred_t		*cred,
247     vnode_t		*vp,
248     char		*od_name,
249     smb_node_t		*dnode,
250     smb_node_t		*unode)
251 {
252 	smb_llist_t		*node_hdr;
253 	smb_node_t		*node;
254 	smb_attr_t		attr;
255 	uint32_t		hashkey = 0;
256 	fsid_t			fsid;
257 	int			error;
258 	krw_t			lock_mode;
259 	vnode_t			*unnamed_vp = NULL;
260 
261 	/*
262 	 * smb_vop_getattr() is called here instead of smb_fsop_getattr(),
263 	 * because the node may not yet exist.  We also do not want to call
264 	 * it with the list lock held.
265 	 */
266 
267 	if (unode)
268 		unnamed_vp = unode->vp;
269 
270 	/*
271 	 * This getattr is performed on behalf of the server
272 	 * that's why kcred is used not the user's cred
273 	 */
274 	attr.sa_mask = SMB_AT_ALL;
275 	error = smb_vop_getattr(vp, unnamed_vp, &attr, 0, zone_kcred());
276 	if (error)
277 		return (NULL);
278 
279 	if (sr && sr->tid_tree) {
280 		/*
281 		 * The fsid for a file is that of the tree, even
282 		 * if the file resides in a different mountpoint
283 		 * under the share.
284 		 */
285 		fsid = SMB_TREE_FSID(sr->tid_tree);
286 	} else {
287 		/*
288 		 * This should be getting executed only for the
289 		 * tree root smb_node.
290 		 */
291 		fsid = vp->v_vfsp->vfs_fsid;
292 	}
293 
294 	node_hdr = smb_node_get_hash(&fsid, &attr, &hashkey);
295 	lock_mode = RW_READER;
296 
297 	smb_llist_enter(node_hdr, lock_mode);
298 	for (;;) {
299 		node = list_head(&node_hdr->ll_list);
300 		while (node) {
301 			ASSERT(node->n_magic == SMB_NODE_MAGIC);
302 			ASSERT(node->n_hash_bucket == node_hdr);
303 			if ((node->n_hashkey == hashkey) && (node->vp == vp)) {
304 				mutex_enter(&node->n_mutex);
305 				DTRACE_PROBE1(smb_node_lookup_hit,
306 				    smb_node_t *, node);
307 				switch (node->n_state) {
308 				case SMB_NODE_STATE_AVAILABLE:
309 					/* The node was found. */
310 					node->n_refcnt++;
311 					if ((node->n_dnode == NULL) &&
312 					    (dnode != NULL) &&
313 					    (node != dnode) &&
314 					    (strcmp(od_name, "..") != 0) &&
315 					    (strcmp(od_name, ".") != 0)) {
316 						VALIDATE_DIR_NODE(dnode, node);
317 						node->n_dnode = dnode;
318 						smb_node_ref(dnode);
319 					}
320 
321 					smb_node_audit(node);
322 					mutex_exit(&node->n_mutex);
323 					smb_llist_exit(node_hdr);
324 					return (node);
325 
326 				case SMB_NODE_STATE_DESTROYING:
327 					/*
328 					 * Although the node exists it is about
329 					 * to be destroyed. We act as it hasn't
330 					 * been found.
331 					 */
332 					mutex_exit(&node->n_mutex);
333 					break;
334 				default:
335 					/*
336 					 * Although the node exists it is in an
337 					 * unknown state. We act as it hasn't
338 					 * been found.
339 					 */
340 					ASSERT(0);
341 					mutex_exit(&node->n_mutex);
342 					break;
343 				}
344 			}
345 			node = smb_llist_next(node_hdr, node);
346 		}
347 		if ((lock_mode == RW_READER) && smb_llist_upgrade(node_hdr)) {
348 			lock_mode = RW_WRITER;
349 			continue;
350 		}
351 		break;
352 	}
353 	node = smb_node_alloc(od_name, vp, node_hdr, hashkey);
354 	smb_node_init_reparse(node, &attr);
355 
356 	if (op)
357 		node->flags |= smb_is_executable(op->fqi.fq_last_comp);
358 
359 	if (dnode) {
360 		smb_node_ref(dnode);
361 		node->n_dnode = dnode;
362 		ASSERT(dnode->n_dnode != node);
363 		ASSERT((dnode->vp->v_xattrdir) ||
364 		    (dnode->vp->v_type == VDIR));
365 	}
366 
367 	if (unode) {
368 		smb_node_ref(unode);
369 		node->n_unode = unode;
370 	}
371 
372 	smb_node_init_system(node);
373 
374 	DTRACE_PROBE1(smb_node_lookup_miss, smb_node_t *, node);
375 	smb_node_audit(node);
376 	smb_llist_insert_head(node_hdr, node);
377 	smb_llist_exit(node_hdr);
378 	return (node);
379 }
380 
381 /*
382  * smb_stream_node_lookup()
383  *
384  * Note: stream_name (the name that will be stored in the "od_name" field
385  * of a stream's smb_node) is the same as the on-disk name for the stream
386  * except that it does not have SMB_STREAM_PREFIX prepended.
387  */
388 
389 smb_node_t *
390 smb_stream_node_lookup(smb_request_t *sr, cred_t *cr, smb_node_t *fnode,
391     vnode_t *xattrdirvp, vnode_t *vp, char *stream_name)
392 {
393 	smb_node_t	*xattrdir_node;
394 	smb_node_t	*snode;
395 
396 	xattrdir_node = smb_node_lookup(sr, NULL, cr, xattrdirvp, XATTR_DIR,
397 	    fnode, NULL);
398 
399 	if (xattrdir_node == NULL)
400 		return (NULL);
401 
402 	snode = smb_node_lookup(sr, NULL, cr, vp, stream_name, xattrdir_node,
403 	    fnode);
404 
405 	(void) smb_node_release(xattrdir_node);
406 	return (snode);
407 }
408 
409 
410 /*
411  * This function should be called whenever a reference is needed on an
412  * smb_node pointer.  The copy of an smb_node pointer from one non-local
413  * data structure to another requires a reference to be taken on the smb_node
414  * (unless the usage is localized).  Each data structure deallocation routine
415  * will call smb_node_release() on its smb_node pointers.
416  *
417  * In general, an smb_node pointer residing in a structure should never be
418  * stale.  A node pointer may be NULL, however, and care should be taken
419  * prior to calling smb_node_ref(), which ASSERTs that the pointer is valid.
420  * Care also needs to be taken with respect to racing deallocations of a
421  * structure.
422  */
423 void
424 smb_node_ref(smb_node_t *node)
425 {
426 	SMB_NODE_VALID(node);
427 
428 	mutex_enter(&node->n_mutex);
429 	switch (node->n_state) {
430 	case SMB_NODE_STATE_AVAILABLE:
431 		node->n_refcnt++;
432 		ASSERT(node->n_refcnt);
433 		DTRACE_PROBE1(smb_node_ref_exit, smb_node_t *, node);
434 		smb_node_audit(node);
435 		break;
436 	default:
437 		SMB_PANIC();
438 	}
439 	mutex_exit(&node->n_mutex);
440 }
441 
442 /*
443  * smb_node_lookup() takes a hold on an smb_node, whether found in the
444  * hash table or newly created.  This hold is expected to be released
445  * in the following manner.
446  *
447  * smb_node_lookup() takes an address of an smb_node pointer.  This should
448  * be getting passed down via a lookup (whether path name or component), mkdir,
449  * create.  If the original smb_node pointer resides in a data structure, then
450  * the deallocation routine for the data structure is responsible for calling
451  * smb_node_release() on the smb_node pointer.  Alternatively,
452  * smb_node_release() can be called as soon as the smb_node pointer is no longer
453  * needed.  In this case, callers are responsible for setting an embedded
454  * pointer to NULL if it is known that the last reference is being released.
455  *
456  * If the passed-in address of the smb_node pointer belongs to a local variable,
457  * then the caller with the local variable should call smb_node_release()
458  * directly.
459  *
460  * smb_node_release() itself will call smb_node_release() on a node's n_dnode,
461  * as smb_node_lookup() takes a hold on dnode.
462  */
463 void
464 smb_node_release(smb_node_t *node)
465 {
466 	SMB_NODE_VALID(node);
467 
468 	mutex_enter(&node->n_mutex);
469 	ASSERT(node->n_refcnt);
470 	DTRACE_PROBE1(smb_node_release, smb_node_t *, node);
471 	if (--node->n_refcnt == 0) {
472 		switch (node->n_state) {
473 
474 		case SMB_NODE_STATE_AVAILABLE:
475 			node->n_state = SMB_NODE_STATE_DESTROYING;
476 			mutex_exit(&node->n_mutex);
477 
478 			smb_llist_enter(node->n_hash_bucket, RW_WRITER);
479 			smb_llist_remove(node->n_hash_bucket, node);
480 			smb_llist_exit(node->n_hash_bucket);
481 
482 			/*
483 			 * Check if the file was deleted
484 			 */
485 			smb_node_delete_on_close(node);
486 
487 			if (node->n_dnode) {
488 				ASSERT(node->n_dnode->n_magic ==
489 				    SMB_NODE_MAGIC);
490 				smb_node_release(node->n_dnode);
491 			}
492 
493 			if (node->n_unode) {
494 				ASSERT(node->n_unode->n_magic ==
495 				    SMB_NODE_MAGIC);
496 				smb_node_release(node->n_unode);
497 			}
498 
499 			smb_node_free(node);
500 			return;
501 
502 		default:
503 			SMB_PANIC();
504 		}
505 	}
506 	smb_node_audit(node);
507 	mutex_exit(&node->n_mutex);
508 }
509 
510 static void
511 smb_node_delete_on_close(smb_node_t *node)
512 {
513 	smb_node_t	*d_snode;
514 	int		rc = 0;
515 	uint32_t	flags = 0;
516 
517 	d_snode = node->n_dnode;
518 	if (node->flags & NODE_FLAGS_DELETE_ON_CLOSE) {
519 		node->flags &= ~NODE_FLAGS_DELETE_ON_CLOSE;
520 		flags = node->n_delete_on_close_flags;
521 		ASSERT(node->od_name != NULL);
522 
523 		if (smb_node_is_dir(node))
524 			rc = smb_fsop_rmdir(0, node->delete_on_close_cred,
525 			    d_snode, node->od_name, flags);
526 		else
527 			rc = smb_fsop_remove(0, node->delete_on_close_cred,
528 			    d_snode, node->od_name, flags);
529 		crfree(node->delete_on_close_cred);
530 	}
531 	if (rc != 0)
532 		cmn_err(CE_WARN, "File %s could not be removed, rc=%d\n",
533 		    node->od_name, rc);
534 	DTRACE_PROBE2(smb_node_delete_on_close, int, rc, smb_node_t *, node);
535 }
536 
537 /*
538  * smb_node_rename()
539  *
540  */
541 void
542 smb_node_rename(
543     smb_node_t	*from_dnode,
544     smb_node_t	*ret_node,
545     smb_node_t	*to_dnode,
546     char	*to_name)
547 {
548 	SMB_NODE_VALID(from_dnode);
549 	SMB_NODE_VALID(to_dnode);
550 	SMB_NODE_VALID(ret_node);
551 
552 	smb_node_ref(to_dnode);
553 	mutex_enter(&ret_node->n_mutex);
554 	switch (ret_node->n_state) {
555 	case SMB_NODE_STATE_AVAILABLE:
556 		ret_node->n_dnode = to_dnode;
557 		mutex_exit(&ret_node->n_mutex);
558 		ASSERT(to_dnode->n_dnode != ret_node);
559 		ASSERT((to_dnode->vp->v_xattrdir) ||
560 		    (to_dnode->vp->v_type == VDIR));
561 		smb_node_release(from_dnode);
562 		(void) strcpy(ret_node->od_name, to_name);
563 		/*
564 		 * XXX Need to update attributes?
565 		 */
566 		break;
567 	default:
568 		SMB_PANIC();
569 	}
570 }
571 
572 /*
573  * Find/create an SMB node for the root of this zone and store it
574  * in *svrootp.  Also create nodes leading to this directory.
575  */
576 int
577 smb_node_root_init(smb_server_t *sv, smb_node_t **svrootp)
578 {
579 	zone_t		*zone = curzone;
580 	int		error;
581 
582 	ASSERT(zone->zone_id == sv->sv_zid);
583 	if (smb_root_node == NULL)
584 		return (ENOENT);
585 
586 	/*
587 	 * We're getting smb nodes below the zone root here,
588 	 * so need to use kcred, not zone_kcred().
589 	 */
590 	error = smb_pathname(NULL, zone->zone_rootpath, 0,
591 	    smb_root_node, smb_root_node, NULL, svrootp, kcred);
592 
593 	return (error);
594 }
595 
596 /*
597  * Helper function for smb_node_set_delete_on_close(). Assumes node is a dir.
598  * Return 0 if this is an empty dir. Otherwise return a NT_STATUS code.
599  * Unfortunately, to find out if a directory is empty, we have to read it
600  * and check for anything other than "." or ".." in the readdir buf.
601  */
602 static uint32_t
603 smb_rmdir_possible(smb_node_t *n, uint32_t flags)
604 {
605 	ASSERT(n->vp->v_type == VDIR);
606 	char buf[512]; /* Only large enough to see if the dir is empty. */
607 	int eof, bsize = sizeof (buf), reclen = 0;
608 	char *name;
609 	boolean_t edp = vfs_has_feature(n->vp->v_vfsp, VFSFT_DIRENTFLAGS);
610 
611 	union {
612 		char		*u_bufptr;
613 		struct edirent	*u_edp;
614 		struct dirent64	*u_dp;
615 	} u;
616 #define	bufptr	u.u_bufptr
617 #define	extdp	u.u_edp
618 #define	dp	u.u_dp
619 
620 	if (smb_vop_readdir(n->vp, 0, buf, &bsize, &eof, flags, zone_kcred()))
621 		return (NT_STATUS_INTERNAL_ERROR);
622 	if (bsize == 0)
623 		return (0); /* empty dir */
624 	bufptr = buf;
625 	while ((bufptr += reclen) < buf + bsize) {
626 		if (edp) {
627 			reclen = extdp->ed_reclen;
628 			name = extdp->ed_name;
629 		} else {
630 			reclen = dp->d_reclen;
631 			name = dp->d_name;
632 		}
633 		if (strcmp(name, ".") != 0 && strcmp(name, "..") != 0)
634 			return (NT_STATUS_DIRECTORY_NOT_EMPTY);
635 	}
636 	return (0);
637 }
638 
639 /*
640  * When DeleteOnClose is set on an smb_node, the common open code will
641  * reject subsequent open requests for the file. Observation of Windows
642  * 2000 indicates that subsequent opens should be allowed (assuming
643  * there would be no sharing violation) until the file is closed using
644  * the fid on which the DeleteOnClose was requested.
645  *
646  * If there are multiple opens with delete-on-close create options,
647  * whichever the first file handle is closed will trigger the node to be
648  * marked as delete-on-close. The credentials of that ofile will be used
649  * as the delete-on-close credentials of the node.
650  *
651  * Note that "read-only" tests have already happened before this call.
652  */
653 uint32_t
654 smb_node_set_delete_on_close(smb_node_t *node, cred_t *cr, uint32_t flags)
655 {
656 	uint32_t status;
657 
658 	/*
659 	 * If the directory is not empty we should fail setting del-on-close
660 	 * with STATUS_DIRECTORY_NOT_EMPTY. see MS's
661 	 * "File System Behavior Overview" doc section 4.3.2
662 	 */
663 	if (smb_node_is_dir(node)) {
664 		status = smb_rmdir_possible(node, flags);
665 		if (status != 0) {
666 			return (status);
667 		}
668 	}
669 
670 	mutex_enter(&node->n_mutex);
671 	if (node->flags & NODE_FLAGS_DELETE_ON_CLOSE) {
672 		/* It was already marked.  We're done. */
673 		mutex_exit(&node->n_mutex);
674 		return (NT_STATUS_SUCCESS);
675 	}
676 
677 	crhold(cr);
678 	node->delete_on_close_cred = cr;
679 	node->n_delete_on_close_flags = flags;
680 	node->flags |= NODE_FLAGS_DELETE_ON_CLOSE;
681 	mutex_exit(&node->n_mutex);
682 
683 	/*
684 	 * Tell any change notify calls to close their handles
685 	 * and get out of the way.  FILE_ACTION_DELETE_PENDING
686 	 * is a special, internal-only action for this purpose.
687 	 */
688 	smb_node_notify_change(node, FILE_ACTION_DELETE_PENDING, NULL);
689 
690 	return (NT_STATUS_SUCCESS);
691 }
692 
693 void
694 smb_node_reset_delete_on_close(smb_node_t *node)
695 {
696 	mutex_enter(&node->n_mutex);
697 	if (node->flags & NODE_FLAGS_DELETE_ON_CLOSE) {
698 		node->flags &= ~NODE_FLAGS_DELETE_ON_CLOSE;
699 		crfree(node->delete_on_close_cred);
700 		node->delete_on_close_cred = NULL;
701 		node->n_delete_on_close_flags = 0;
702 	}
703 	mutex_exit(&node->n_mutex);
704 }
705 
706 /*
707  * smb_node_open_check
708  *
709  * check file sharing rules for current open request
710  * against all existing opens for a file.
711  *
712  * Returns NT_STATUS_SHARING_VIOLATION if there is any
713  * sharing conflict, otherwise returns NT_STATUS_SUCCESS.
714  */
715 uint32_t
716 smb_node_open_check(smb_node_t *node, uint32_t desired_access,
717     uint32_t share_access)
718 {
719 	smb_ofile_t *of;
720 	uint32_t status;
721 
722 	SMB_NODE_VALID(node);
723 
724 	smb_llist_enter(&node->n_ofile_list, RW_READER);
725 	of = smb_llist_head(&node->n_ofile_list);
726 	while (of) {
727 		status = smb_ofile_open_check(of, desired_access, share_access);
728 
729 		switch (status) {
730 		case NT_STATUS_INVALID_HANDLE:
731 		case NT_STATUS_SUCCESS:
732 			of = smb_llist_next(&node->n_ofile_list, of);
733 			break;
734 		default:
735 			ASSERT(status == NT_STATUS_SHARING_VIOLATION);
736 			smb_llist_exit(&node->n_ofile_list);
737 			return (status);
738 		}
739 	}
740 
741 	smb_llist_exit(&node->n_ofile_list);
742 	return (NT_STATUS_SUCCESS);
743 }
744 
745 uint32_t
746 smb_node_rename_check(smb_node_t *node)
747 {
748 	smb_ofile_t	*of;
749 	uint32_t	status;
750 
751 	SMB_NODE_VALID(node);
752 
753 	/*
754 	 * Intra-CIFS check
755 	 */
756 	smb_llist_enter(&node->n_ofile_list, RW_READER);
757 	of = smb_llist_head(&node->n_ofile_list);
758 	while (of) {
759 		status = smb_ofile_rename_check(of);
760 
761 		switch (status) {
762 		case NT_STATUS_INVALID_HANDLE:
763 		case NT_STATUS_SUCCESS:
764 			of = smb_llist_next(&node->n_ofile_list, of);
765 			break;
766 		default:
767 			ASSERT(status == NT_STATUS_SHARING_VIOLATION);
768 			smb_llist_exit(&node->n_ofile_list);
769 			return (status);
770 		}
771 	}
772 	smb_llist_exit(&node->n_ofile_list);
773 	return (NT_STATUS_SUCCESS);
774 }
775 
776 uint32_t
777 smb_node_delete_check(smb_node_t *node)
778 {
779 	smb_ofile_t	*of;
780 	uint32_t	status;
781 
782 	SMB_NODE_VALID(node);
783 
784 	if (smb_node_is_dir(node))
785 		return (NT_STATUS_SUCCESS);
786 
787 	if (smb_node_is_reparse(node))
788 		return (NT_STATUS_ACCESS_DENIED);
789 
790 	/*
791 	 * intra-CIFS check
792 	 */
793 	smb_llist_enter(&node->n_ofile_list, RW_READER);
794 	of = smb_llist_head(&node->n_ofile_list);
795 	while (of) {
796 		status = smb_ofile_delete_check(of);
797 
798 		switch (status) {
799 		case NT_STATUS_INVALID_HANDLE:
800 		case NT_STATUS_SUCCESS:
801 			of = smb_llist_next(&node->n_ofile_list, of);
802 			break;
803 		default:
804 			ASSERT(status == NT_STATUS_SHARING_VIOLATION);
805 			smb_llist_exit(&node->n_ofile_list);
806 			return (status);
807 		}
808 	}
809 	smb_llist_exit(&node->n_ofile_list);
810 	return (NT_STATUS_SUCCESS);
811 }
812 
813 /*
814  * smb_node_share_check
815  *
816  * Returns: TRUE    - ofiles have non-zero share access
817  *          B_FALSE - ofile with share access NONE.
818  */
819 boolean_t
820 smb_node_share_check(smb_node_t *node)
821 {
822 	smb_ofile_t	*of;
823 	boolean_t	status = B_TRUE;
824 
825 	SMB_NODE_VALID(node);
826 
827 	smb_llist_enter(&node->n_ofile_list, RW_READER);
828 	of = smb_llist_head(&node->n_ofile_list);
829 	if (of)
830 		status = smb_ofile_share_check(of);
831 	smb_llist_exit(&node->n_ofile_list);
832 
833 	return (status);
834 }
835 
836 /*
837  * SMB Change Notification
838  */
839 
840 void
841 smb_node_fcn_subscribe(smb_node_t *node)
842 {
843 
844 	mutex_enter(&node->n_mutex);
845 	if (node->n_fcn_count == 0)
846 		(void) smb_fem_fcn_install(node);
847 	node->n_fcn_count++;
848 	mutex_exit(&node->n_mutex);
849 }
850 
851 void
852 smb_node_fcn_unsubscribe(smb_node_t *node)
853 {
854 
855 	mutex_enter(&node->n_mutex);
856 	node->n_fcn_count--;
857 	if (node->n_fcn_count == 0)
858 		smb_fem_fcn_uninstall(node);
859 	mutex_exit(&node->n_mutex);
860 }
861 
862 void
863 smb_node_notify_change(smb_node_t *node, uint_t action, const char *name)
864 {
865 	smb_ofile_t	*of;
866 
867 	SMB_NODE_VALID(node);
868 
869 	smb_llist_enter(&node->n_ofile_list, RW_READER);
870 	of = smb_llist_head(&node->n_ofile_list);
871 	while (of) {
872 		/*
873 		 * We'd rather deliver events only to ofiles that have
874 		 * subscribed.  There's no explicit synchronization with
875 		 * where this flag is set, but other actions cause this
876 		 * value to reach visibility soon enough for events to
877 		 * start arriving by the time we need them to start.
878 		 * Once nc_subscribed is set, it stays set for the
879 		 * life of the ofile.
880 		 */
881 		if (of->f_notify.nc_subscribed)
882 			smb_notify_ofile(of, action, name);
883 		of = smb_llist_next(&node->n_ofile_list, of);
884 	}
885 	smb_llist_exit(&node->n_ofile_list);
886 
887 	/*
888 	 * After changes that add or remove a name,
889 	 * we know the directory attributes changed,
890 	 * and we can tell the immediate parent.
891 	 */
892 	switch (action) {
893 	case FILE_ACTION_ADDED:
894 	case FILE_ACTION_REMOVED:
895 	case FILE_ACTION_RENAMED_NEW_NAME:
896 		/*
897 		 * Note: FILE_ACTION_RENAMED_OLD_NAME is intentionally
898 		 * omitted, because it's always followed by another
899 		 * event with FILE_ACTION_RENAMED_NEW_NAME posted to
900 		 * the same directory, and we only need/want one.
901 		 */
902 		if (node->n_dnode != NULL) {
903 			smb_node_notify_change(node->n_dnode,
904 			    FILE_ACTION_MODIFIED, node->od_name);
905 		}
906 		break;
907 	}
908 
909 	/*
910 	 * If we wanted to support recursive notify events
911 	 * (where a notify call on some directory receives
912 	 * events from all objects below that directory),
913 	 * we might deliver _SUBDIR_CHANGED to all our
914 	 * parents, grandparents etc, here.  However, we
915 	 * don't currently subscribe to changes on all the
916 	 * child (and grandchild) objects that would be
917 	 * needed to make that work. It's prohibitively
918 	 * expensive to do that, and support for recursive
919 	 * notify is optional anyway, so don't bother.
920 	 */
921 }
922 
923 /*
924  * smb_node_start_crit()
925  *
926  * Enter critical region for share reservations.
927  * See comments above smb_fsop_shrlock().
928  */
929 void
930 smb_node_start_crit(smb_node_t *node, krw_t mode)
931 {
932 	rw_enter(&node->n_lock, mode);
933 	nbl_start_crit(node->vp, mode);
934 }
935 
936 /*
937  * smb_node_end_crit()
938  *
939  * Exit critical region for share reservations.
940  */
941 void
942 smb_node_end_crit(smb_node_t *node)
943 {
944 	nbl_end_crit(node->vp);
945 	rw_exit(&node->n_lock);
946 }
947 
948 int
949 smb_node_in_crit(smb_node_t *node)
950 {
951 	return (nbl_in_crit(node->vp) && RW_LOCK_HELD(&node->n_lock));
952 }
953 
954 void
955 smb_node_rdlock(smb_node_t *node)
956 {
957 	rw_enter(&node->n_lock, RW_READER);
958 }
959 
960 void
961 smb_node_wrlock(smb_node_t *node)
962 {
963 	rw_enter(&node->n_lock, RW_WRITER);
964 }
965 
966 void
967 smb_node_unlock(smb_node_t *node)
968 {
969 	rw_exit(&node->n_lock);
970 }
971 
972 void
973 smb_node_add_ofile(smb_node_t *node, smb_ofile_t *of)
974 {
975 	SMB_NODE_VALID(node);
976 
977 	smb_llist_enter(&node->n_ofile_list, RW_WRITER);
978 	smb_llist_insert_tail(&node->n_ofile_list, of);
979 	smb_llist_exit(&node->n_ofile_list);
980 }
981 
982 void
983 smb_node_rem_ofile(smb_node_t *node, smb_ofile_t *of)
984 {
985 	SMB_NODE_VALID(node);
986 
987 	smb_llist_enter(&node->n_ofile_list, RW_WRITER);
988 	smb_llist_remove(&node->n_ofile_list, of);
989 	smb_llist_exit(&node->n_ofile_list);
990 }
991 
992 /*
993  * smb_node_inc_open_ofiles
994  */
995 void
996 smb_node_inc_open_ofiles(smb_node_t *node)
997 {
998 	SMB_NODE_VALID(node);
999 	atomic_inc_32(&node->n_open_count);
1000 }
1001 
1002 /*
1003  * smb_node_dec_open_ofiles
1004  * returns new value
1005  */
1006 uint32_t
1007 smb_node_dec_open_ofiles(smb_node_t *node)
1008 {
1009 	SMB_NODE_VALID(node);
1010 	return (atomic_dec_32_nv(&node->n_open_count));
1011 }
1012 
1013 /*
1014  * smb_node_inc_opening_count
1015  */
1016 void
1017 smb_node_inc_opening_count(smb_node_t *node)
1018 {
1019 	SMB_NODE_VALID(node);
1020 	atomic_inc_32(&node->n_opening_count);
1021 }
1022 
1023 /*
1024  * smb_node_dec_opening_count
1025  */
1026 void
1027 smb_node_dec_opening_count(smb_node_t *node)
1028 {
1029 	SMB_NODE_VALID(node);
1030 	atomic_dec_32(&node->n_opening_count);
1031 }
1032 
1033 /*
1034  * smb_node_getmntpath
1035  */
1036 int
1037 smb_node_getmntpath(smb_node_t *node, char *buf, uint32_t buflen)
1038 {
1039 	vnode_t *vp, *root_vp;
1040 	vfs_t *vfsp;
1041 	int err;
1042 
1043 	ASSERT(node);
1044 	ASSERT(node->vp);
1045 	ASSERT(node->vp->v_vfsp);
1046 
1047 	vp = node->vp;
1048 	vfsp = vp->v_vfsp;
1049 
1050 	if (VFS_ROOT(vfsp, &root_vp))
1051 		return (ENOENT);
1052 
1053 	VN_HOLD(vp);
1054 
1055 	/* NULL is passed in as we want to start at "/" */
1056 	err = vnodetopath(NULL, root_vp, buf, buflen, zone_kcred());
1057 
1058 	VN_RELE(vp);
1059 	VN_RELE(root_vp);
1060 	return (err);
1061 }
1062 
1063 /*
1064  * smb_node_getshrpath
1065  *
1066  * Determine the absolute pathname of 'node' within the share (tree).
1067  * For example if the node represents file "test1.txt" in directory
1068  * "dir1" the pathname would be: \dir1\test1.txt
1069  */
1070 int
1071 smb_node_getshrpath(smb_node_t *node, smb_tree_t *tree,
1072     char *buf, uint32_t buflen)
1073 {
1074 	int rc;
1075 
1076 	ASSERT(node);
1077 	ASSERT(tree);
1078 	ASSERT(tree->t_snode);
1079 
1080 	rc = smb_node_getpath(node, tree->t_snode->vp, buf, buflen);
1081 	(void) strsubst(buf, '/', '\\');
1082 	return (rc);
1083 }
1084 
1085 /*
1086  * smb_node_getpath
1087  *
1088  * Determine the absolute pathname of 'node' from 'rootvp'.
1089  *
1090  * Using vnodetopath is only reliable for directory nodes (due to
1091  * its reliance on the DNLC for non-directory nodes). Thus, if node
1092  * represents a file, construct the pathname for the parent dnode
1093  * and append filename.
1094  * If node represents a named stream, construct the pathname for the
1095  * associated unnamed stream and append the stream name.
1096  *
1097  * The pathname returned in buf will be '/' separated.
1098  */
1099 int
1100 smb_node_getpath(smb_node_t *node, vnode_t *rootvp, char *buf, uint32_t buflen)
1101 {
1102 	int rc;
1103 	vnode_t *vp;
1104 	smb_node_t *unode, *dnode;
1105 	cred_t *kcr = zone_kcred();
1106 
1107 	unode = (SMB_IS_STREAM(node)) ? node->n_unode : node;
1108 	dnode = (smb_node_is_dir(unode)) ? unode : unode->n_dnode;
1109 
1110 	/* find path to directory node */
1111 	vp = dnode->vp;
1112 	VN_HOLD(vp);
1113 	if (rootvp) {
1114 		VN_HOLD(rootvp);
1115 		rc = vnodetopath(rootvp, vp, buf, buflen, kcr);
1116 		VN_RELE(rootvp);
1117 	} else {
1118 		rc = vnodetopath(NULL, vp, buf, buflen, kcr);
1119 	}
1120 	VN_RELE(vp);
1121 
1122 	if (rc != 0)
1123 		return (rc);
1124 
1125 	/* append filename if necessary */
1126 	if (!smb_node_is_dir(unode)) {
1127 		if (buf[strlen(buf) - 1] != '/')
1128 			(void) strlcat(buf, "/", buflen);
1129 		(void) strlcat(buf, unode->od_name, buflen);
1130 	}
1131 
1132 	/* append named stream name if necessary */
1133 	if (SMB_IS_STREAM(node))
1134 		(void) strlcat(buf, node->od_name, buflen);
1135 
1136 	return (rc);
1137 }
1138 
1139 /*
1140  * smb_node_alloc
1141  */
1142 static smb_node_t *
1143 smb_node_alloc(
1144     char	*od_name,
1145     vnode_t	*vp,
1146     smb_llist_t	*bucket,
1147     uint32_t	hashkey)
1148 {
1149 	smb_node_t	*node;
1150 	vnode_t		*root_vp;
1151 
1152 	node = kmem_cache_alloc(smb_node_cache, KM_SLEEP);
1153 
1154 	if (node->n_audit_buf != NULL)
1155 		node->n_audit_buf->anb_index = 0;
1156 
1157 	node->flags = 0;
1158 	VN_HOLD(vp);
1159 	node->vp = vp;
1160 	node->n_refcnt = 1;
1161 	node->n_hash_bucket = bucket;
1162 	node->n_hashkey = hashkey;
1163 	node->n_pending_dosattr = 0;
1164 	node->n_open_count = 0;
1165 	node->n_allocsz = 0;
1166 	node->n_dnode = NULL;
1167 	node->n_unode = NULL;
1168 	node->delete_on_close_cred = NULL;
1169 	node->n_delete_on_close_flags = 0;
1170 	node->n_oplock.ol_fem = B_FALSE;
1171 	node->n_oplock.ol_xthread = NULL;
1172 	node->n_oplock.ol_count = 0;
1173 	node->n_oplock.ol_break = SMB_OPLOCK_NO_BREAK;
1174 
1175 	(void) strlcpy(node->od_name, od_name, sizeof (node->od_name));
1176 	if (strcmp(od_name, XATTR_DIR) == 0)
1177 		node->flags |= NODE_XATTR_DIR;
1178 
1179 	if (VFS_ROOT(vp->v_vfsp, &root_vp) == 0) {
1180 		if (vp == root_vp)
1181 			node->flags |= NODE_FLAGS_VFSROOT;
1182 		VN_RELE(root_vp);
1183 	}
1184 
1185 	node->n_state = SMB_NODE_STATE_AVAILABLE;
1186 	node->n_magic = SMB_NODE_MAGIC;
1187 
1188 	return (node);
1189 }
1190 
1191 /*
1192  * smb_node_free
1193  */
1194 static void
1195 smb_node_free(smb_node_t *node)
1196 {
1197 	SMB_NODE_VALID(node);
1198 
1199 	node->n_magic = 0;
1200 	VERIFY(!list_link_active(&node->n_lnd));
1201 	VERIFY(node->n_lock_list.ll_count == 0);
1202 	VERIFY(node->n_wlock_list.ll_count == 0);
1203 	VERIFY(node->n_ofile_list.ll_count == 0);
1204 	VERIFY(node->n_oplock.ol_count == 0);
1205 	VERIFY(node->n_oplock.ol_xthread == NULL);
1206 	VERIFY(node->n_oplock.ol_fem == B_FALSE);
1207 	VERIFY(MUTEX_NOT_HELD(&node->n_mutex));
1208 	VERIFY(!RW_LOCK_HELD(&node->n_lock));
1209 	VN_RELE(node->vp);
1210 	kmem_cache_free(smb_node_cache, node);
1211 }
1212 
1213 /*
1214  * smb_node_constructor
1215  */
1216 static int
1217 smb_node_constructor(void *buf, void *un, int kmflags)
1218 {
1219 	_NOTE(ARGUNUSED(kmflags, un))
1220 
1221 	smb_node_t	*node = (smb_node_t *)buf;
1222 
1223 	bzero(node, sizeof (smb_node_t));
1224 
1225 	smb_llist_constructor(&node->n_ofile_list, sizeof (smb_ofile_t),
1226 	    offsetof(smb_ofile_t, f_nnd));
1227 	smb_llist_constructor(&node->n_lock_list, sizeof (smb_lock_t),
1228 	    offsetof(smb_lock_t, l_lnd));
1229 	smb_llist_constructor(&node->n_wlock_list, sizeof (smb_lock_t),
1230 	    offsetof(smb_lock_t, l_lnd));
1231 	cv_init(&node->n_oplock.ol_cv, NULL, CV_DEFAULT, NULL);
1232 	mutex_init(&node->n_oplock.ol_mutex, NULL, MUTEX_DEFAULT, NULL);
1233 	list_create(&node->n_oplock.ol_grants, sizeof (smb_oplock_grant_t),
1234 	    offsetof(smb_oplock_grant_t, og_lnd));
1235 	rw_init(&node->n_lock, NULL, RW_DEFAULT, NULL);
1236 	mutex_init(&node->n_mutex, NULL, MUTEX_DEFAULT, NULL);
1237 	smb_node_create_audit_buf(node, kmflags);
1238 	return (0);
1239 }
1240 
1241 /*
1242  * smb_node_destructor
1243  */
1244 static void
1245 smb_node_destructor(void *buf, void *un)
1246 {
1247 	_NOTE(ARGUNUSED(un))
1248 
1249 	smb_node_t	*node = (smb_node_t *)buf;
1250 
1251 	smb_node_destroy_audit_buf(node);
1252 	mutex_destroy(&node->n_mutex);
1253 	rw_destroy(&node->n_lock);
1254 	cv_destroy(&node->n_oplock.ol_cv);
1255 	mutex_destroy(&node->n_oplock.ol_mutex);
1256 	smb_llist_destructor(&node->n_lock_list);
1257 	smb_llist_destructor(&node->n_wlock_list);
1258 	smb_llist_destructor(&node->n_ofile_list);
1259 	list_destroy(&node->n_oplock.ol_grants);
1260 }
1261 
1262 /*
1263  * smb_node_create_audit_buf
1264  */
1265 static void
1266 smb_node_create_audit_buf(smb_node_t *node, int kmflags)
1267 {
1268 	smb_audit_buf_node_t	*abn;
1269 
1270 	if (smb_audit_flags & SMB_AUDIT_NODE) {
1271 		abn = kmem_zalloc(sizeof (smb_audit_buf_node_t), kmflags);
1272 		abn->anb_max_index = SMB_AUDIT_BUF_MAX_REC - 1;
1273 		node->n_audit_buf = abn;
1274 	}
1275 }
1276 
1277 /*
1278  * smb_node_destroy_audit_buf
1279  */
1280 static void
1281 smb_node_destroy_audit_buf(smb_node_t *node)
1282 {
1283 	if (node->n_audit_buf != NULL) {
1284 		kmem_free(node->n_audit_buf, sizeof (smb_audit_buf_node_t));
1285 		node->n_audit_buf = NULL;
1286 	}
1287 }
1288 
1289 /*
1290  * smb_node_audit
1291  *
1292  * This function saves the calling stack in the audit buffer of the node passed
1293  * in.
1294  */
1295 static void
1296 smb_node_audit(smb_node_t *node)
1297 {
1298 #ifdef	_KERNEL
1299 	smb_audit_buf_node_t	*abn;
1300 	smb_audit_record_node_t	*anr;
1301 
1302 	if (node->n_audit_buf) {
1303 		abn = node->n_audit_buf;
1304 		anr = abn->anb_records;
1305 		anr += abn->anb_index;
1306 		abn->anb_index++;
1307 		abn->anb_index &= abn->anb_max_index;
1308 		anr->anr_refcnt = node->n_refcnt;
1309 		anr->anr_depth = getpcstack(anr->anr_stack,
1310 		    SMB_AUDIT_STACK_DEPTH);
1311 	}
1312 #else	/* _KERNEL */
1313 	_NOTE(ARGUNUSED(node))
1314 #endif	/* _KERNEL */
1315 }
1316 
1317 static smb_llist_t *
1318 smb_node_get_hash(fsid_t *fsid, smb_attr_t *attr, uint32_t *phashkey)
1319 {
1320 	uint32_t	hashkey;
1321 
1322 	hashkey = fsid->val[0] + attr->sa_vattr.va_nodeid;
1323 	hashkey += (hashkey >> 24) + (hashkey >> 16) + (hashkey >> 8);
1324 	*phashkey = hashkey;
1325 	return (&smb_node_hash_table[(hashkey & SMBND_HASH_MASK)]);
1326 }
1327 
1328 boolean_t
1329 smb_node_is_file(smb_node_t *node)
1330 {
1331 	SMB_NODE_VALID(node);
1332 	return (node->vp->v_type == VREG);
1333 }
1334 
1335 boolean_t
1336 smb_node_is_dir(smb_node_t *node)
1337 {
1338 	SMB_NODE_VALID(node);
1339 	return ((node->vp->v_type == VDIR) ||
1340 	    (node->flags & NODE_FLAGS_DFSLINK));
1341 }
1342 
1343 boolean_t
1344 smb_node_is_symlink(smb_node_t *node)
1345 {
1346 	SMB_NODE_VALID(node);
1347 	return ((node->vp->v_type == VLNK) &&
1348 	    ((node->flags & NODE_FLAGS_REPARSE) == 0));
1349 }
1350 
1351 boolean_t
1352 smb_node_is_dfslink(smb_node_t *node)
1353 {
1354 	SMB_NODE_VALID(node);
1355 	return ((node->vp->v_type == VLNK) &&
1356 	    (node->flags & NODE_FLAGS_DFSLINK));
1357 }
1358 
1359 boolean_t
1360 smb_node_is_reparse(smb_node_t *node)
1361 {
1362 	SMB_NODE_VALID(node);
1363 	return ((node->vp->v_type == VLNK) &&
1364 	    (node->flags & NODE_FLAGS_REPARSE));
1365 }
1366 
1367 boolean_t
1368 smb_node_is_vfsroot(smb_node_t *node)
1369 {
1370 	SMB_NODE_VALID(node);
1371 	return ((node->flags & NODE_FLAGS_VFSROOT) == NODE_FLAGS_VFSROOT);
1372 }
1373 
1374 boolean_t
1375 smb_node_is_system(smb_node_t *node)
1376 {
1377 	SMB_NODE_VALID(node);
1378 	return ((node->flags & NODE_FLAGS_SYSTEM) == NODE_FLAGS_SYSTEM);
1379 }
1380 
1381 /*
1382  * smb_node_file_is_readonly
1383  *
1384  * Checks if the file (which node represents) is marked readonly
1385  * in the filesystem. No account is taken of any pending readonly
1386  * in the node, which must be handled by the callers.
1387  * (See SMB_OFILE_IS_READONLY and SMB_PATHFILE_IS_READONLY)
1388  */
1389 boolean_t
1390 smb_node_file_is_readonly(smb_node_t *node)
1391 {
1392 	smb_attr_t attr;
1393 
1394 	if (node == NULL)
1395 		return (B_FALSE);	/* pipes */
1396 
1397 	if (node->n_pending_dosattr & FILE_ATTRIBUTE_READONLY)
1398 		return (B_TRUE);
1399 
1400 	bzero(&attr, sizeof (smb_attr_t));
1401 	attr.sa_mask = SMB_AT_DOSATTR;
1402 	(void) smb_fsop_getattr(NULL, zone_kcred(), node, &attr);
1403 	return ((attr.sa_dosattr & FILE_ATTRIBUTE_READONLY) != 0);
1404 }
1405 
1406 /*
1407  * smb_node_setattr
1408  *
1409  * The sr may be NULL, for example when closing an ofile.
1410  * The ofile may be NULL, for example when a client request
1411  * specifies the file by pathname.
1412  *
1413  * Returns: errno
1414  *
1415  * Timestamps
1416  *
1417  * Windows and Unix have different models for timestamp updates.
1418  * [MS-FSA 2.1.5.14 Server Requests Setting of File Information]
1419  *
1420  * An open "handle" in Windows can control whether and when
1421  * any timestamp updates happen for that handle.  For example,
1422  * timestamps set via some handle are no longer updated by I/O
1423  * operations on that handle.  In Unix we don't really have any
1424  * way to avoid the timestamp updates that the file system does.
1425  * Therefore, we need to make some compromises, and simulate the
1426  * more important parts of the Windows file system semantics.
1427  *
1428  * For example, when an SMB client sets file times, set those
1429  * times in the file system (so the change will be visible to
1430  * other clients, at least until they change again) but we also
1431  * make those times "sticky" in our open handle, and reapply
1432  * those times when the handle is closed.  That reapply on close
1433  * simulates the Windows behavior where the timestamp updates
1434  * would be discontinued after they were set.  These "sticky"
1435  * attributes are returned in any query on the handle where
1436  * they are stored.
1437  *
1438  * Other than the above, the file system layer takes care of the
1439  * normal time stamp updates, such as updating the mtime after a
1440  * write, and ctime after an attribute change.
1441  *
1442  * Dos Attributes are stored persistently, but with a twist:
1443  * In Windows, when you set the "read-only" bit on some file,
1444  * existing writable handles to that file continue to have
1445  * write access.  (because access check happens at open)
1446  * If we were to set the read-only bit directly, we would
1447  * cause errors in subsequent writes on any of our open
1448  * (and writable) file handles.  So here too, we have to
1449  * simulate the Windows behavior.  We keep the read-only
1450  * bit "pending" in the smb_node (so it will be visible in
1451  * any new opens of the file) and apply it on close.
1452  *
1453  * File allocation size is also simulated, and not persistent.
1454  * When the file allocation size is set it is first rounded up
1455  * to block size. If the file size is smaller than the allocation
1456  * size the file is truncated by setting the filesize to allocsz.
1457  */
1458 int
1459 smb_node_setattr(smb_request_t *sr, smb_node_t *node,
1460     cred_t *cr, smb_ofile_t *of, smb_attr_t *attr)
1461 {
1462 	int rc;
1463 	uint_t times_mask;
1464 	smb_attr_t tmp_attr;
1465 
1466 	SMB_NODE_VALID(node);
1467 
1468 	/* set attributes specified in attr */
1469 	if (attr->sa_mask == 0)
1470 		return (0);  /* nothing to do (caller bug?) */
1471 
1472 	/*
1473 	 * Allocation size and EOF position interact.
1474 	 * We don't persistently store the allocation size
1475 	 * but make it look like we do while there are opens.
1476 	 * Note: We update the caller's attr in the cases
1477 	 * where they're setting only one of allocsz|size.
1478 	 */
1479 	switch (attr->sa_mask & (SMB_AT_ALLOCSZ | SMB_AT_SIZE)) {
1480 
1481 	case SMB_AT_ALLOCSZ:
1482 		/*
1483 		 * Setting the allocation size but not EOF position.
1484 		 * Get the current EOF in tmp_attr and (if necessary)
1485 		 * truncate to the (rounded up) allocation size.
1486 		 * Using kcred here because if we don't have access,
1487 		 * we want to fail at setattr below and not here.
1488 		 */
1489 		bzero(&tmp_attr, sizeof (smb_attr_t));
1490 		tmp_attr.sa_mask = SMB_AT_SIZE;
1491 		rc = smb_fsop_getattr(NULL, zone_kcred(), node, &tmp_attr);
1492 		if (rc != 0)
1493 			return (rc);
1494 		attr->sa_allocsz = SMB_ALLOCSZ(attr->sa_allocsz);
1495 		if (tmp_attr.sa_vattr.va_size > attr->sa_allocsz) {
1496 			/* truncate the file to allocsz */
1497 			attr->sa_vattr.va_size = attr->sa_allocsz;
1498 			attr->sa_mask |= SMB_AT_SIZE;
1499 		}
1500 		break;
1501 
1502 	case SMB_AT_SIZE:
1503 		/*
1504 		 * Setting the EOF position but not allocation size.
1505 		 * If the new EOF position would be greater than
1506 		 * the allocation size, increase the latter.
1507 		 */
1508 		if (node->n_allocsz < attr->sa_vattr.va_size) {
1509 			attr->sa_mask |= SMB_AT_ALLOCSZ;
1510 			attr->sa_allocsz =
1511 			    SMB_ALLOCSZ(attr->sa_vattr.va_size);
1512 		}
1513 		break;
1514 
1515 	case SMB_AT_ALLOCSZ | SMB_AT_SIZE:
1516 		/*
1517 		 * Setting both.  Increase alloc size if needed.
1518 		 */
1519 		if (attr->sa_allocsz < attr->sa_vattr.va_size)
1520 			attr->sa_allocsz =
1521 			    SMB_ALLOCSZ(attr->sa_vattr.va_size);
1522 		break;
1523 
1524 	default:
1525 		break;
1526 	}
1527 
1528 	/*
1529 	 * If we have an open file, and we set the size,
1530 	 * then set the "written" flag so that at close,
1531 	 * we can force an mtime update.
1532 	 */
1533 	if (of != NULL && (attr->sa_mask & SMB_AT_SIZE) != 0)
1534 		of->f_written = B_TRUE;
1535 
1536 	/*
1537 	 * When operating on an open file, some settable attributes
1538 	 * become "sticky" in the open file object until close.
1539 	 * (see above re. timestamps)
1540 	 */
1541 	times_mask = attr->sa_mask & SMB_AT_TIMES;
1542 	if (of != NULL && times_mask != 0) {
1543 		smb_attr_t *pa;
1544 
1545 		SMB_OFILE_VALID(of);
1546 		mutex_enter(&of->f_mutex);
1547 		pa = &of->f_pending_attr;
1548 
1549 		pa->sa_mask |= times_mask;
1550 
1551 		if (times_mask & SMB_AT_ATIME)
1552 			pa->sa_vattr.va_atime =
1553 			    attr->sa_vattr.va_atime;
1554 		if (times_mask & SMB_AT_MTIME)
1555 			pa->sa_vattr.va_mtime =
1556 			    attr->sa_vattr.va_mtime;
1557 		if (times_mask & SMB_AT_CTIME)
1558 			pa->sa_vattr.va_ctime =
1559 			    attr->sa_vattr.va_ctime;
1560 		if (times_mask & SMB_AT_CRTIME)
1561 			pa->sa_crtime =
1562 			    attr->sa_crtime;
1563 
1564 		mutex_exit(&of->f_mutex);
1565 		/*
1566 		 * The f_pending_attr times are reapplied in
1567 		 * smb_ofile_close().
1568 		 */
1569 	}
1570 
1571 	/*
1572 	 * After this point, tmp_attr is what we will actually
1573 	 * store in the file system _now_, which may differ
1574 	 * from the callers attr and f_pending_attr w.r.t.
1575 	 * the DOS readonly flag etc.
1576 	 */
1577 	bcopy(attr, &tmp_attr, sizeof (tmp_attr));
1578 	if (attr->sa_mask & (SMB_AT_DOSATTR | SMB_AT_ALLOCSZ)) {
1579 		mutex_enter(&node->n_mutex);
1580 		if ((attr->sa_mask & SMB_AT_DOSATTR) != 0) {
1581 			tmp_attr.sa_dosattr &= smb_vop_dosattr_settable;
1582 			if (((tmp_attr.sa_dosattr &
1583 			    FILE_ATTRIBUTE_READONLY) != 0) &&
1584 			    (node->n_open_count != 0)) {
1585 				/* Delay setting readonly */
1586 				node->n_pending_dosattr =
1587 				    tmp_attr.sa_dosattr;
1588 				tmp_attr.sa_dosattr &=
1589 				    ~FILE_ATTRIBUTE_READONLY;
1590 			} else {
1591 				node->n_pending_dosattr = 0;
1592 			}
1593 		}
1594 		/*
1595 		 * Simulate n_allocsz persistence only while
1596 		 * there are opens.  See smb_node_getattr
1597 		 */
1598 		if ((attr->sa_mask & SMB_AT_ALLOCSZ) != 0 &&
1599 		    node->n_open_count != 0)
1600 			node->n_allocsz = attr->sa_allocsz;
1601 		mutex_exit(&node->n_mutex);
1602 	}
1603 
1604 	rc = smb_fsop_setattr(sr, cr, node, &tmp_attr);
1605 	if (rc != 0)
1606 		return (rc);
1607 
1608 	if (node->n_dnode != NULL) {
1609 		smb_node_notify_change(node->n_dnode,
1610 		    FILE_ACTION_MODIFIED, node->od_name);
1611 	}
1612 
1613 	return (0);
1614 }
1615 
1616 /*
1617  * smb_node_getattr
1618  *
1619  * Get attributes from the file system and apply any smb-specific
1620  * overrides for size, dos attributes and timestamps
1621  *
1622  * When node->n_pending_readonly is set on a node, pretend that
1623  * we've already set this node readonly at the filesystem level.
1624  * We can't actually do that until all writable handles are closed
1625  * or those writable handles would suddenly loose their access.
1626  *
1627  * Returns: errno
1628  */
1629 int
1630 smb_node_getattr(smb_request_t *sr, smb_node_t *node, cred_t *cr,
1631     smb_ofile_t *of, smb_attr_t *attr)
1632 {
1633 	int rc;
1634 	uint_t want_mask, pend_mask;
1635 	boolean_t isdir;
1636 
1637 	SMB_NODE_VALID(node);
1638 
1639 	/* Deal with some interdependencies */
1640 	if (attr->sa_mask & SMB_AT_ALLOCSZ)
1641 		attr->sa_mask |= SMB_AT_SIZE;
1642 	if (attr->sa_mask & SMB_AT_DOSATTR)
1643 		attr->sa_mask |= SMB_AT_TYPE;
1644 
1645 	rc = smb_fsop_getattr(sr, cr, node, attr);
1646 	if (rc != 0)
1647 		return (rc);
1648 
1649 	isdir = smb_node_is_dir(node);
1650 
1651 	mutex_enter(&node->n_mutex);
1652 
1653 	/*
1654 	 * When there are open handles, and one of them has
1655 	 * set the DOS readonly flag (in n_pending_dosattr),
1656 	 * it will not have been stored in the file system.
1657 	 * In this case use n_pending_dosattr. Note that
1658 	 * n_pending_dosattr has only the settable bits,
1659 	 * (setattr masks it with smb_vop_dosattr_settable)
1660 	 * so we need to keep any non-settable bits we got
1661 	 * from the file-system above.
1662 	 */
1663 	if (attr->sa_mask & SMB_AT_DOSATTR) {
1664 		if (node->n_pending_dosattr) {
1665 			attr->sa_dosattr &= ~smb_vop_dosattr_settable;
1666 			attr->sa_dosattr |= node->n_pending_dosattr;
1667 		}
1668 		if (attr->sa_dosattr == 0) {
1669 			attr->sa_dosattr = (isdir) ?
1670 			    FILE_ATTRIBUTE_DIRECTORY:
1671 			    FILE_ATTRIBUTE_NORMAL;
1672 		}
1673 	}
1674 
1675 	/*
1676 	 * Also fix-up sa_allocsz, which is not persistent.
1677 	 * When there are no open files, allocsz is faked.
1678 	 * While there are open files, we pretend we have a
1679 	 * persistent allocation size in n_allocsz, and
1680 	 * keep that up-to-date here, increasing it when
1681 	 * we see the file size grow past it.
1682 	 */
1683 	if (attr->sa_mask & SMB_AT_ALLOCSZ) {
1684 		if (isdir) {
1685 			attr->sa_allocsz = 0;
1686 		} else if (node->n_open_count == 0) {
1687 			attr->sa_allocsz =
1688 			    SMB_ALLOCSZ(attr->sa_vattr.va_size);
1689 		} else {
1690 			if (node->n_allocsz < attr->sa_vattr.va_size)
1691 				node->n_allocsz =
1692 				    SMB_ALLOCSZ(attr->sa_vattr.va_size);
1693 			attr->sa_allocsz = node->n_allocsz;
1694 		}
1695 	}
1696 
1697 	mutex_exit(&node->n_mutex);
1698 
1699 	if (isdir) {
1700 		attr->sa_vattr.va_size = 0;
1701 		attr->sa_vattr.va_nlink = 1;
1702 	}
1703 
1704 	/*
1705 	 * getattr with an ofile gets any "pending" times that
1706 	 * might have been previously set via this ofile.
1707 	 * This is what makes these times "sticky".
1708 	 */
1709 	want_mask = attr->sa_mask & SMB_AT_TIMES;
1710 	if (of != NULL && want_mask != 0) {
1711 		smb_attr_t *pa;
1712 
1713 		SMB_OFILE_VALID(of);
1714 		mutex_enter(&of->f_mutex);
1715 		pa = &of->f_pending_attr;
1716 
1717 		pend_mask = pa->sa_mask;
1718 
1719 		if (want_mask & pend_mask & SMB_AT_ATIME)
1720 			attr->sa_vattr.va_atime =
1721 			    pa->sa_vattr.va_atime;
1722 		if (want_mask & pend_mask & SMB_AT_MTIME)
1723 			attr->sa_vattr.va_mtime =
1724 			    pa->sa_vattr.va_mtime;
1725 		if (want_mask & pend_mask & SMB_AT_CTIME)
1726 			attr->sa_vattr.va_ctime =
1727 			    pa->sa_vattr.va_ctime;
1728 		if (want_mask & pend_mask & SMB_AT_CRTIME)
1729 			attr->sa_crtime =
1730 			    pa->sa_crtime;
1731 
1732 		mutex_exit(&of->f_mutex);
1733 	}
1734 
1735 
1736 	return (0);
1737 }
1738 
1739 
1740 #ifndef	_KERNEL
1741 extern int reparse_vnode_parse(vnode_t *vp, nvlist_t *nvl);
1742 #endif	/* _KERNEL */
1743 
1744 /*
1745  * Check to see if the node represents a reparse point.
1746  * If yes, whether the reparse point contains a DFS link.
1747  */
1748 static void
1749 smb_node_init_reparse(smb_node_t *node, smb_attr_t *attr)
1750 {
1751 	nvlist_t *nvl;
1752 	nvpair_t *rec;
1753 	char *rec_type;
1754 
1755 	if ((attr->sa_dosattr & FILE_ATTRIBUTE_REPARSE_POINT) == 0)
1756 		return;
1757 
1758 	if ((nvl = reparse_init()) == NULL)
1759 		return;
1760 
1761 	if (reparse_vnode_parse(node->vp, nvl) != 0) {
1762 		reparse_free(nvl);
1763 		return;
1764 	}
1765 
1766 	node->flags |= NODE_FLAGS_REPARSE;
1767 
1768 	rec = nvlist_next_nvpair(nvl, NULL);
1769 	while (rec != NULL) {
1770 		rec_type = nvpair_name(rec);
1771 		if ((rec_type != NULL) &&
1772 		    (strcasecmp(rec_type, DFS_REPARSE_SVCTYPE) == 0)) {
1773 			node->flags |= NODE_FLAGS_DFSLINK;
1774 			break;
1775 		}
1776 		rec = nvlist_next_nvpair(nvl, rec);
1777 	}
1778 
1779 	reparse_free(nvl);
1780 }
1781 
1782 /*
1783  * smb_node_init_system
1784  *
1785  * If the node represents a special system file set NODE_FLAG_SYSTEM.
1786  * System files:
1787  * - any node whose parent dnode has NODE_FLAG_SYSTEM set
1788  * - any node whose associated unnamed stream node (unode) has
1789  *   NODE_FLAG_SYSTEM set
1790  * - .$EXTEND at root of share (quota management)
1791  */
1792 static void
1793 smb_node_init_system(smb_node_t *node)
1794 {
1795 	smb_node_t *dnode = node->n_dnode;
1796 	smb_node_t *unode = node->n_unode;
1797 
1798 	if ((dnode) && (dnode->flags & NODE_FLAGS_SYSTEM)) {
1799 		node->flags |= NODE_FLAGS_SYSTEM;
1800 		return;
1801 	}
1802 
1803 	if ((unode) && (unode->flags & NODE_FLAGS_SYSTEM)) {
1804 		node->flags |= NODE_FLAGS_SYSTEM;
1805 		return;
1806 	}
1807 
1808 	if ((dnode) && (smb_node_is_vfsroot(node->n_dnode) &&
1809 	    (strcasecmp(node->od_name, ".$EXTEND") == 0))) {
1810 		node->flags |= NODE_FLAGS_SYSTEM;
1811 	}
1812 }
1813