1/*
2 * Copyright (c) 2000-2001, Boris Popov
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 *    notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 *    notice, this list of conditions and the following disclaimer in the
12 *    documentation and/or other materials provided with the distribution.
13 * 3. All advertising materials mentioning features or use of this software
14 *    must display the following acknowledgement:
15 *    This product includes software developed by Boris Popov.
16 * 4. Neither the name of the author nor the names of any co-contributors
17 *    may be used to endorse or promote products derived from this software
18 *    without specific prior written permission.
19 *
20 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
21 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
24 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
25 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
26 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
28 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
29 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
30 * SUCH DAMAGE.
31 *
32 * $Id: smbfs_vfsops.c,v 1.73.64.1 2005/05/27 02:35:28 lindak Exp $
33 */
34
35/*
36 * Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
37 */
38
39#include <sys/systm.h>
40#include <sys/cred.h>
41#include <sys/time.h>
42#include <sys/vfs.h>
43#include <sys/vnode.h>
44#include <fs/fs_subr.h>
45#include <sys/sysmacros.h>
46#include <sys/kmem.h>
47#include <sys/mkdev.h>
48#include <sys/mount.h>
49#include <sys/statvfs.h>
50#include <sys/errno.h>
51#include <sys/debug.h>
52#include <sys/cmn_err.h>
53#include <sys/modctl.h>
54#include <sys/policy.h>
55#include <sys/atomic.h>
56#include <sys/zone.h>
57#include <sys/vfs_opreg.h>
58#include <sys/mntent.h>
59#include <sys/priv.h>
60#include <sys/tsol/label.h>
61#include <sys/tsol/tndb.h>
62#include <inet/ip.h>
63
64#include <netsmb/smb_osdep.h>
65#include <netsmb/smb.h>
66#include <netsmb/smb_conn.h>
67#include <netsmb/smb_subr.h>
68#include <netsmb/smb_dev.h>
69
70#include <smbfs/smbfs.h>
71#include <smbfs/smbfs_node.h>
72#include <smbfs/smbfs_subr.h>
73
74/*
75 * Local functions definitions.
76 */
77int		smbfsinit(int fstyp, char *name);
78void		smbfsfini();
79static int	smbfs_mount_label_policy(vfs_t *, void *, int, cred_t *);
80
81/*
82 * SMBFS Mount options table for MS_OPTIONSTR
83 * Note: These are not all the options.
84 * Some options come in via MS_DATA.
85 * Others are generic (see vfs.c)
86 */
87static char *intr_cancel[] = { MNTOPT_NOINTR, NULL };
88static char *nointr_cancel[] = { MNTOPT_INTR, NULL };
89static char *acl_cancel[] = { MNTOPT_NOACL, NULL };
90static char *noacl_cancel[] = { MNTOPT_ACL, NULL };
91static char *xattr_cancel[] = { MNTOPT_NOXATTR, NULL };
92static char *noxattr_cancel[] = { MNTOPT_XATTR, NULL };
93
94static mntopt_t mntopts[] = {
95/*
96 *	option name		cancel option	default arg	flags
97 *		ufs arg flag
98 */
99	{ MNTOPT_INTR,		intr_cancel,	NULL,	MO_DEFAULT, 0 },
100	{ MNTOPT_NOINTR,	nointr_cancel,	NULL,	0,	0 },
101	{ MNTOPT_ACL,		acl_cancel,	NULL,	MO_DEFAULT, 0 },
102	{ MNTOPT_NOACL,		noacl_cancel,	NULL,	0,	0 },
103	{ MNTOPT_XATTR,		xattr_cancel,	NULL,	MO_DEFAULT, 0 },
104	{ MNTOPT_NOXATTR,	noxattr_cancel, NULL,	0,	0 }
105};
106
107static mntopts_t smbfs_mntopts = {
108	sizeof (mntopts) / sizeof (mntopt_t),
109	mntopts
110};
111
112static const char fs_type_name[FSTYPSZ] = "smbfs";
113
114static vfsdef_t vfw = {
115	VFSDEF_VERSION,
116	(char *)fs_type_name,
117	smbfsinit,		/* init routine */
118	VSW_HASPROTO|VSW_NOTZONESAFE|VSW_ZMOUNT,	/* flags */
119	&smbfs_mntopts			/* mount options table prototype */
120};
121
122static struct modlfs modlfs = {
123	&mod_fsops,
124	"SMBFS filesystem",
125	&vfw
126};
127
128static struct modlinkage modlinkage = {
129	MODREV_1, (void *)&modlfs, NULL
130};
131
132/*
133 * Mutex to protect the following variables:
134 *	  smbfs_major
135 *	  smbfs_minor
136 */
137extern	kmutex_t	smbfs_minor_lock;
138extern	int		smbfs_major;
139extern	int		smbfs_minor;
140
141/*
142 * Prevent unloads while we have mounts
143 */
144uint32_t	smbfs_mountcount;
145
146/*
147 * smbfs vfs operations.
148 */
149static int	smbfs_mount(vfs_t *, vnode_t *, struct mounta *, cred_t *);
150static int	smbfs_unmount(vfs_t *, int, cred_t *);
151static int	smbfs_root(vfs_t *, vnode_t **);
152static int	smbfs_statvfs(vfs_t *, statvfs64_t *);
153static int	smbfs_sync(vfs_t *, short, cred_t *);
154static void	smbfs_freevfs(vfs_t *);
155
156/*
157 * Module loading
158 */
159
160/*
161 * This routine is invoked automatically when the kernel module
162 * containing this routine is loaded.  This allows module specific
163 * initialization to be done when the module is loaded.
164 */
165int
166_init(void)
167{
168	int		error;
169
170	/*
171	 * Check compiled-in version of "nsmb"
172	 * that we're linked with.  (paranoid)
173	 */
174	if (nsmb_version != NSMB_VERSION) {
175		cmn_err(CE_WARN, "_init: nsmb version mismatch");
176		return (ENOTTY);
177	}
178
179	smbfs_mountcount = 0;
180
181	/*
182	 * NFS calls these two in _clntinit
183	 * Easier to follow this way.
184	 */
185	if ((error = smbfs_subrinit()) != 0) {
186		cmn_err(CE_WARN, "_init: smbfs_subrinit failed");
187		return (error);
188	}
189
190	if ((error = smbfs_vfsinit()) != 0) {
191		cmn_err(CE_WARN, "_init: smbfs_vfsinit failed");
192		smbfs_subrfini();
193		return (error);
194	}
195
196	if ((error = smbfs_clntinit()) != 0) {
197		cmn_err(CE_WARN, "_init: smbfs_clntinit failed");
198		smbfs_vfsfini();
199		smbfs_subrfini();
200		return (error);
201	}
202
203	error = mod_install((struct modlinkage *)&modlinkage);
204	return (error);
205}
206
207/*
208 * Free kernel module resources that were allocated in _init
209 * and remove the linkage information into the kernel
210 */
211int
212_fini(void)
213{
214	int	error;
215
216	/*
217	 * If a forcedly unmounted instance is still hanging around,
218	 * we cannot allow the module to be unloaded because that would
219	 * cause panics once the VFS framework decides it's time to call
220	 * into VFS_FREEVFS().
221	 */
222	if (smbfs_mountcount)
223		return (EBUSY);
224
225	error = mod_remove(&modlinkage);
226	if (error)
227		return (error);
228
229	/*
230	 * Free the allocated smbnodes, etc.
231	 */
232	smbfs_clntfini();
233
234	/* NFS calls these two in _clntfini */
235	smbfs_vfsfini();
236	smbfs_subrfini();
237
238	/*
239	 * Free the ops vectors
240	 */
241	smbfsfini();
242	return (0);
243}
244
245/*
246 * Return information about the module
247 */
248int
249_info(struct modinfo *modinfop)
250{
251	return (mod_info((struct modlinkage *)&modlinkage, modinfop));
252}
253
254/*
255 * Initialize the vfs structure
256 */
257
258int smbfsfstyp;
259vfsops_t *smbfs_vfsops = NULL;
260
261static const fs_operation_def_t smbfs_vfsops_template[] = {
262	{ VFSNAME_MOUNT, { .vfs_mount = smbfs_mount } },
263	{ VFSNAME_UNMOUNT, { .vfs_unmount = smbfs_unmount } },
264	{ VFSNAME_ROOT,	{ .vfs_root = smbfs_root } },
265	{ VFSNAME_STATVFS, { .vfs_statvfs = smbfs_statvfs } },
266	{ VFSNAME_SYNC,	{ .vfs_sync = smbfs_sync } },
267	{ VFSNAME_VGET,	{ .error = fs_nosys } },
268	{ VFSNAME_MOUNTROOT, { .error = fs_nosys } },
269	{ VFSNAME_FREEVFS, { .vfs_freevfs = smbfs_freevfs } },
270	{ NULL, NULL }
271};
272
273int
274smbfsinit(int fstyp, char *name)
275{
276	int		error;
277
278	error = vfs_setfsops(fstyp, smbfs_vfsops_template, &smbfs_vfsops);
279	if (error != 0) {
280		zcmn_err(GLOBAL_ZONEID, CE_WARN,
281		    "smbfsinit: bad vfs ops template");
282		return (error);
283	}
284
285	error = vn_make_ops(name, smbfs_vnodeops_template, &smbfs_vnodeops);
286	if (error != 0) {
287		(void) vfs_freevfsops_by_type(fstyp);
288		zcmn_err(GLOBAL_ZONEID, CE_WARN,
289		    "smbfsinit: bad vnode ops template");
290		return (error);
291	}
292
293	smbfsfstyp = fstyp;
294
295	return (0);
296}
297
298void
299smbfsfini()
300{
301	if (smbfs_vfsops) {
302		(void) vfs_freevfsops_by_type(smbfsfstyp);
303		smbfs_vfsops = NULL;
304	}
305	if (smbfs_vnodeops) {
306		vn_freevnodeops(smbfs_vnodeops);
307		smbfs_vnodeops = NULL;
308	}
309}
310
311void
312smbfs_free_smi(smbmntinfo_t *smi)
313{
314	if (smi == NULL)
315		return;
316
317	if (smi->smi_zone_ref.zref_zone != NULL)
318		zone_rele_ref(&smi->smi_zone_ref, ZONE_REF_SMBFS);
319
320	if (smi->smi_share != NULL)
321		smb_share_rele(smi->smi_share);
322
323	avl_destroy(&smi->smi_hash_avl);
324	rw_destroy(&smi->smi_hash_lk);
325	cv_destroy(&smi->smi_statvfs_cv);
326	mutex_destroy(&smi->smi_lock);
327
328	kmem_free(smi, sizeof (smbmntinfo_t));
329}
330
331/*
332 * smbfs mount vfsop
333 * Set up mount info record and attach it to vfs struct.
334 */
335static int
336smbfs_mount(vfs_t *vfsp, vnode_t *mvp, struct mounta *uap, cred_t *cr)
337{
338	char		*data = uap->dataptr;
339	int		error;
340	smbnode_t 	*rtnp = NULL;	/* root of this fs */
341	smbmntinfo_t 	*smi = NULL;
342	dev_t 		smbfs_dev;
343	int 		version;
344	int 		devfd;
345	zone_t		*zone = curproc->p_zone;
346	zone_t		*mntzone = NULL;
347	smb_share_t 	*ssp = NULL;
348	smb_cred_t 	scred;
349	int		flags, sec;
350
351	STRUCT_DECL(smbfs_args, args);		/* smbfs mount arguments */
352
353	if ((error = secpolicy_fs_mount(cr, mvp, vfsp)) != 0)
354		return (error);
355
356	if (mvp->v_type != VDIR)
357		return (ENOTDIR);
358
359	/*
360	 * get arguments
361	 *
362	 * uap->datalen might be different from sizeof (args)
363	 * in a compatible situation.
364	 */
365	STRUCT_INIT(args, get_udatamodel());
366	bzero(STRUCT_BUF(args), SIZEOF_STRUCT(smbfs_args, DATAMODEL_NATIVE));
367	if (copyin(data, STRUCT_BUF(args), MIN(uap->datalen,
368	    SIZEOF_STRUCT(smbfs_args, DATAMODEL_NATIVE))))
369		return (EFAULT);
370
371	/*
372	 * Check mount program version
373	 */
374	version = STRUCT_FGET(args, version);
375	if (version != SMBFS_VERSION) {
376		cmn_err(CE_WARN, "mount version mismatch:"
377		    " kernel=%d, mount=%d\n",
378		    SMBFS_VERSION, version);
379		return (EINVAL);
380	}
381
382	/*
383	 * Deal with re-mount requests.
384	 */
385	if (uap->flags & MS_REMOUNT) {
386		cmn_err(CE_WARN, "MS_REMOUNT not implemented");
387		return (ENOTSUP);
388	}
389
390	/*
391	 * Check for busy
392	 */
393	mutex_enter(&mvp->v_lock);
394	if (!(uap->flags & MS_OVERLAY) &&
395	    (mvp->v_count != 1 || (mvp->v_flag & VROOT))) {
396		mutex_exit(&mvp->v_lock);
397		return (EBUSY);
398	}
399	mutex_exit(&mvp->v_lock);
400
401	/*
402	 * Get the "share" from the netsmb driver (ssp).
403	 * It is returned with a "ref" (hold) for us.
404	 * Release this hold: at errout below, or in
405	 * smbfs_freevfs().
406	 */
407	devfd = STRUCT_FGET(args, devfd);
408	error = smb_dev2share(devfd, &ssp);
409	if (error) {
410		cmn_err(CE_WARN, "invalid device handle %d (%d)\n",
411		    devfd, error);
412		return (error);
413	}
414
415	/*
416	 * Use "goto errout" from here on.
417	 * See: ssp, smi, rtnp, mntzone
418	 */
419
420	/*
421	 * Determine the zone we're being mounted into.
422	 */
423	zone_hold(mntzone = zone);		/* start with this assumption */
424	if (getzoneid() == GLOBAL_ZONEID) {
425		zone_rele(mntzone);
426		mntzone = zone_find_by_path(refstr_value(vfsp->vfs_mntpt));
427		ASSERT(mntzone != NULL);
428		if (mntzone != zone) {
429			error = EBUSY;
430			goto errout;
431		}
432	}
433
434	/*
435	 * Stop the mount from going any further if the zone is going away.
436	 */
437	if (zone_status_get(mntzone) >= ZONE_IS_SHUTTING_DOWN) {
438		error = EBUSY;
439		goto errout;
440	}
441
442	/*
443	 * On a Trusted Extensions client, we may have to force read-only
444	 * for read-down mounts.
445	 */
446	if (is_system_labeled()) {
447		void *addr;
448		int ipvers = 0;
449		struct smb_vc *vcp;
450
451		vcp = SSTOVC(ssp);
452		addr = smb_vc_getipaddr(vcp, &ipvers);
453		error = smbfs_mount_label_policy(vfsp, addr, ipvers, cr);
454
455		if (error > 0)
456			goto errout;
457
458		if (error == -1) {
459			/* change mount to read-only to prevent write-down */
460			vfs_setmntopt(vfsp, MNTOPT_RO, NULL, 0);
461		}
462	}
463
464	/* Prevent unload. */
465	atomic_inc_32(&smbfs_mountcount);
466
467	/*
468	 * Create a mount record and link it to the vfs struct.
469	 * No more possiblities for errors from here on.
470	 * Tear-down of this stuff is in smbfs_free_smi()
471	 *
472	 * Compare with NFS: nfsrootvp()
473	 */
474	smi = kmem_zalloc(sizeof (*smi), KM_SLEEP);
475
476	mutex_init(&smi->smi_lock, NULL, MUTEX_DEFAULT, NULL);
477	cv_init(&smi->smi_statvfs_cv, NULL, CV_DEFAULT, NULL);
478
479	rw_init(&smi->smi_hash_lk, NULL, RW_DEFAULT, NULL);
480	smbfs_init_hash_avl(&smi->smi_hash_avl);
481
482	smi->smi_share = ssp;
483	ssp = NULL;
484
485	/*
486	 * Convert the anonymous zone hold acquired via zone_hold() above
487	 * into a zone reference.
488	 */
489	zone_init_ref(&smi->smi_zone_ref);
490	zone_hold_ref(mntzone, &smi->smi_zone_ref, ZONE_REF_SMBFS);
491	zone_rele(mntzone);
492	mntzone = NULL;
493
494	/*
495	 * Initialize option defaults
496	 */
497	smi->smi_flags	= SMI_LLOCK;
498	smi->smi_acregmin = SEC2HR(SMBFS_ACREGMIN);
499	smi->smi_acregmax = SEC2HR(SMBFS_ACREGMAX);
500	smi->smi_acdirmin = SEC2HR(SMBFS_ACDIRMIN);
501	smi->smi_acdirmax = SEC2HR(SMBFS_ACDIRMAX);
502
503	/*
504	 * All "generic" mount options have already been
505	 * handled in vfs.c:domount() - see mntopts stuff.
506	 * Query generic options using vfs_optionisset().
507	 */
508	if (vfs_optionisset(vfsp, MNTOPT_INTR, NULL))
509		smi->smi_flags |= SMI_INT;
510	if (vfs_optionisset(vfsp, MNTOPT_ACL, NULL))
511		smi->smi_flags |= SMI_ACL;
512
513	/*
514	 * Get the mount options that come in as smbfs_args,
515	 * starting with args.flags (SMBFS_MF_xxx)
516	 */
517	flags = STRUCT_FGET(args, flags);
518	smi->smi_uid 	= STRUCT_FGET(args, uid);
519	smi->smi_gid 	= STRUCT_FGET(args, gid);
520	smi->smi_fmode	= STRUCT_FGET(args, file_mode) & 0777;
521	smi->smi_dmode	= STRUCT_FGET(args, dir_mode) & 0777;
522
523	/*
524	 * Hande the SMBFS_MF_xxx flags.
525	 */
526	if (flags & SMBFS_MF_NOAC)
527		smi->smi_flags |= SMI_NOAC;
528	if (flags & SMBFS_MF_ACREGMIN) {
529		sec = STRUCT_FGET(args, acregmin);
530		if (sec < 0 || sec > SMBFS_ACMINMAX)
531			sec = SMBFS_ACMINMAX;
532		smi->smi_acregmin = SEC2HR(sec);
533	}
534	if (flags & SMBFS_MF_ACREGMAX) {
535		sec = STRUCT_FGET(args, acregmax);
536		if (sec < 0 || sec > SMBFS_ACMAXMAX)
537			sec = SMBFS_ACMAXMAX;
538		smi->smi_acregmax = SEC2HR(sec);
539	}
540	if (flags & SMBFS_MF_ACDIRMIN) {
541		sec = STRUCT_FGET(args, acdirmin);
542		if (sec < 0 || sec > SMBFS_ACMINMAX)
543			sec = SMBFS_ACMINMAX;
544		smi->smi_acdirmin = SEC2HR(sec);
545	}
546	if (flags & SMBFS_MF_ACDIRMAX) {
547		sec = STRUCT_FGET(args, acdirmax);
548		if (sec < 0 || sec > SMBFS_ACMAXMAX)
549			sec = SMBFS_ACMAXMAX;
550		smi->smi_acdirmax = SEC2HR(sec);
551	}
552
553	/*
554	 * Get attributes of the remote file system,
555	 * i.e. ACL support, named streams, etc.
556	 */
557	smb_credinit(&scred, cr);
558	error = smbfs_smb_qfsattr(smi->smi_share, &smi->smi_fsa, &scred);
559	smb_credrele(&scred);
560	if (error) {
561		SMBVDEBUG("smbfs_smb_qfsattr error %d\n", error);
562	}
563
564	/*
565	 * We enable XATTR by default (via smbfs_mntopts)
566	 * but if the share does not support named streams,
567	 * force the NOXATTR option (also clears XATTR).
568	 * Caller will set or clear VFS_XATTR after this.
569	 */
570	if ((smi->smi_fsattr & FILE_NAMED_STREAMS) == 0)
571		vfs_setmntopt(vfsp, MNTOPT_NOXATTR, NULL, 0);
572
573	/*
574	 * Ditto ACLs (disable if not supported on this share)
575	 */
576	if ((smi->smi_fsattr & FILE_PERSISTENT_ACLS) == 0) {
577		vfs_setmntopt(vfsp, MNTOPT_NOACL, NULL, 0);
578		smi->smi_flags &= ~SMI_ACL;
579	}
580
581	/*
582	 * Assign a unique device id to the mount
583	 */
584	mutex_enter(&smbfs_minor_lock);
585	do {
586		smbfs_minor = (smbfs_minor + 1) & MAXMIN32;
587		smbfs_dev = makedevice(smbfs_major, smbfs_minor);
588	} while (vfs_devismounted(smbfs_dev));
589	mutex_exit(&smbfs_minor_lock);
590
591	vfsp->vfs_dev	= smbfs_dev;
592	vfs_make_fsid(&vfsp->vfs_fsid, smbfs_dev, smbfsfstyp);
593	vfsp->vfs_data	= (caddr_t)smi;
594	vfsp->vfs_fstype = smbfsfstyp;
595	vfsp->vfs_bsize = MAXBSIZE;
596	vfsp->vfs_bcount = 0;
597
598	smi->smi_vfsp	= vfsp;
599	smbfs_zonelist_add(smi);	/* undo in smbfs_freevfs */
600
601	/*
602	 * Create the root vnode, which we need in unmount
603	 * for the call to smbfs_check_table(), etc.
604	 * Release this hold in smbfs_unmount.
605	 */
606	rtnp = smbfs_node_findcreate(smi, "\\", 1, NULL, 0, 0,
607	    &smbfs_fattr0);
608	ASSERT(rtnp != NULL);
609	rtnp->r_vnode->v_type = VDIR;
610	rtnp->r_vnode->v_flag |= VROOT;
611	smi->smi_root = rtnp;
612
613	/*
614	 * NFS does other stuff here too:
615	 *   async worker threads
616	 *   init kstats
617	 *
618	 * End of code from NFS nfsrootvp()
619	 */
620	return (0);
621
622errout:
623	vfsp->vfs_data = NULL;
624	if (smi != NULL)
625		smbfs_free_smi(smi);
626
627	if (mntzone != NULL)
628		zone_rele(mntzone);
629
630	if (ssp != NULL)
631		smb_share_rele(ssp);
632
633	return (error);
634}
635
636/*
637 * vfs operations
638 */
639static int
640smbfs_unmount(vfs_t *vfsp, int flag, cred_t *cr)
641{
642	smbmntinfo_t	*smi;
643	smbnode_t	*rtnp;
644
645	smi = VFTOSMI(vfsp);
646
647	if (secpolicy_fs_unmount(cr, vfsp) != 0)
648		return (EPERM);
649
650	if ((flag & MS_FORCE) == 0) {
651		smbfs_rflush(vfsp, cr);
652
653		/*
654		 * If there are any active vnodes on this file system,
655		 * (other than the root vnode) then the file system is
656		 * busy and can't be umounted.
657		 */
658		if (smbfs_check_table(vfsp, smi->smi_root))
659			return (EBUSY);
660
661		/*
662		 * We normally hold a ref to the root vnode, so
663		 * check for references beyond the one we expect:
664		 *   smbmntinfo_t -> smi_root
665		 * Note that NFS does not hold the root vnode.
666		 */
667		if (smi->smi_root &&
668		    smi->smi_root->r_vnode->v_count > 1)
669			return (EBUSY);
670	}
671
672	/*
673	 * common code for both forced and non-forced
674	 *
675	 * Setting VFS_UNMOUNTED prevents new operations.
676	 * Operations already underway may continue,
677	 * but not for long.
678	 */
679	vfsp->vfs_flag |= VFS_UNMOUNTED;
680
681	/*
682	 * Shutdown any outstanding I/O requests on this share,
683	 * and force a tree disconnect.  The share object will
684	 * continue to hang around until smb_share_rele().
685	 * This should also cause most active nodes to be
686	 * released as their operations fail with EIO.
687	 */
688	smb_share_kill(smi->smi_share);
689
690	/*
691	 * If we hold the root VP (and we normally do)
692	 * then it's safe to release it now.
693	 */
694	if (smi->smi_root) {
695		rtnp = smi->smi_root;
696		smi->smi_root = NULL;
697		VN_RELE(rtnp->r_vnode);	/* release root vnode */
698	}
699
700	/*
701	 * Remove all nodes from the node hash tables.
702	 * This (indirectly) calls: smbfs_addfree, smbinactive,
703	 * which will try to flush dirty pages, etc. so
704	 * don't destroy the underlying share just yet.
705	 *
706	 * Also, with a forced unmount, some nodes may
707	 * remain active, and those will get cleaned up
708	 * after their last vn_rele.
709	 */
710	smbfs_destroy_table(vfsp);
711
712	/*
713	 * Delete our kstats...
714	 *
715	 * Doing it here, rather than waiting until
716	 * smbfs_freevfs so these are not visible
717	 * after the unmount.
718	 */
719	if (smi->smi_io_kstats) {
720		kstat_delete(smi->smi_io_kstats);
721		smi->smi_io_kstats = NULL;
722	}
723	if (smi->smi_ro_kstats) {
724		kstat_delete(smi->smi_ro_kstats);
725		smi->smi_ro_kstats = NULL;
726	}
727
728	/*
729	 * The rest happens in smbfs_freevfs()
730	 */
731	return (0);
732}
733
734
735/*
736 * find root of smbfs
737 */
738static int
739smbfs_root(vfs_t *vfsp, vnode_t **vpp)
740{
741	smbmntinfo_t	*smi;
742	vnode_t		*vp;
743
744	smi = VFTOSMI(vfsp);
745
746	if (curproc->p_zone != smi->smi_zone_ref.zref_zone)
747		return (EPERM);
748
749	if (smi->smi_flags & SMI_DEAD || vfsp->vfs_flag & VFS_UNMOUNTED)
750		return (EIO);
751
752	/*
753	 * The root vp is created in mount and held
754	 * until unmount, so this is paranoia.
755	 */
756	if (smi->smi_root == NULL)
757		return (EIO);
758
759	/* Just take a reference and return it. */
760	vp = SMBTOV(smi->smi_root);
761	VN_HOLD(vp);
762	*vpp = vp;
763
764	return (0);
765}
766
767/*
768 * Get file system statistics.
769 */
770static int
771smbfs_statvfs(vfs_t *vfsp, statvfs64_t *sbp)
772{
773	int		error;
774	smbmntinfo_t	*smi = VFTOSMI(vfsp);
775	smb_share_t	*ssp = smi->smi_share;
776	statvfs64_t	stvfs;
777	hrtime_t now;
778	smb_cred_t	scred;
779
780	if (curproc->p_zone != smi->smi_zone_ref.zref_zone)
781		return (EPERM);
782
783	if (smi->smi_flags & SMI_DEAD || vfsp->vfs_flag & VFS_UNMOUNTED)
784		return (EIO);
785
786	mutex_enter(&smi->smi_lock);
787
788	/*
789	 * Use cached result if still valid.
790	 */
791recheck:
792	now = gethrtime();
793	if (now < smi->smi_statfstime) {
794		error = 0;
795		goto cache_hit;
796	}
797
798	/*
799	 * FS attributes are stale, so someone
800	 * needs to do an OTW call to get them.
801	 * Serialize here so only one thread
802	 * does the OTW call.
803	 */
804	if (smi->smi_status & SM_STATUS_STATFS_BUSY) {
805		smi->smi_status |= SM_STATUS_STATFS_WANT;
806		if (!cv_wait_sig(&smi->smi_statvfs_cv, &smi->smi_lock)) {
807			mutex_exit(&smi->smi_lock);
808			return (EINTR);
809		}
810		/* Hope status is valid now. */
811		goto recheck;
812	}
813	smi->smi_status |= SM_STATUS_STATFS_BUSY;
814	mutex_exit(&smi->smi_lock);
815
816	/*
817	 * Do the OTW call.  Note: lock NOT held.
818	 */
819	smb_credinit(&scred, NULL);
820	bzero(&stvfs, sizeof (stvfs));
821	error = smbfs_smb_statfs(ssp, &stvfs, &scred);
822	smb_credrele(&scred);
823	if (error) {
824		SMBVDEBUG("statfs error=%d\n", error);
825	} else {
826
827		/*
828		 * Set a few things the OTW call didn't get.
829		 */
830		stvfs.f_frsize = stvfs.f_bsize;
831		stvfs.f_favail = stvfs.f_ffree;
832		stvfs.f_fsid = (unsigned long)vfsp->vfs_fsid.val[0];
833		bcopy(fs_type_name, stvfs.f_basetype, FSTYPSZ);
834		stvfs.f_flag	= vf_to_stf(vfsp->vfs_flag);
835		stvfs.f_namemax	= smi->smi_fsa.fsa_maxname;
836
837		/*
838		 * Save the result, update lifetime
839		 */
840		now = gethrtime();
841		smi->smi_statfstime = now +
842		    (SM_MAX_STATFSTIME * (hrtime_t)NANOSEC);
843		smi->smi_statvfsbuf = stvfs; /* struct assign! */
844	}
845
846	mutex_enter(&smi->smi_lock);
847	if (smi->smi_status & SM_STATUS_STATFS_WANT)
848		cv_broadcast(&smi->smi_statvfs_cv);
849	smi->smi_status &= ~(SM_STATUS_STATFS_BUSY | SM_STATUS_STATFS_WANT);
850
851	/*
852	 * Copy the statvfs data to caller's buf.
853	 * Note: struct assignment
854	 */
855cache_hit:
856	if (error == 0)
857		*sbp = smi->smi_statvfsbuf;
858	mutex_exit(&smi->smi_lock);
859	return (error);
860}
861
862static kmutex_t smbfs_syncbusy;
863
864/*
865 * Flush dirty smbfs files for file system vfsp.
866 * If vfsp == NULL, all smbfs files are flushed.
867 */
868/*ARGSUSED*/
869static int
870smbfs_sync(vfs_t *vfsp, short flag, cred_t *cr)
871{
872	/*
873	 * Cross-zone calls are OK here, since this translates to a
874	 * VOP_PUTPAGE(B_ASYNC), which gets picked up by the right zone.
875	 */
876	if (!(flag & SYNC_ATTR) && mutex_tryenter(&smbfs_syncbusy) != 0) {
877		smbfs_rflush(vfsp, cr);
878		mutex_exit(&smbfs_syncbusy);
879	}
880
881	return (0);
882}
883
884/*
885 * Initialization routine for VFS routines.  Should only be called once
886 */
887int
888smbfs_vfsinit(void)
889{
890	mutex_init(&smbfs_syncbusy, NULL, MUTEX_DEFAULT, NULL);
891	return (0);
892}
893
894/*
895 * Shutdown routine for VFS routines.  Should only be called once
896 */
897void
898smbfs_vfsfini(void)
899{
900	mutex_destroy(&smbfs_syncbusy);
901}
902
903void
904smbfs_freevfs(vfs_t *vfsp)
905{
906	smbmntinfo_t    *smi;
907
908	/* free up the resources */
909	smi = VFTOSMI(vfsp);
910
911	/*
912	 * By this time we should have already deleted the
913	 * smi kstats in the unmount code.  If they are still around
914	 * something is wrong
915	 */
916	ASSERT(smi->smi_io_kstats == NULL);
917
918	smbfs_zonelist_remove(smi);
919
920	smbfs_free_smi(smi);
921
922	/*
923	 * Allow _fini() to succeed now, if so desired.
924	 */
925	atomic_dec_32(&smbfs_mountcount);
926}
927
928/*
929 * smbfs_mount_label_policy:
930 *	Determine whether the mount is allowed according to MAC check,
931 *	by comparing (where appropriate) label of the remote server
932 *	against the label of the zone being mounted into.
933 *
934 *	Returns:
935 *		 0 :	access allowed
936 *		-1 :	read-only access allowed (i.e., read-down)
937 *		>0 :	error code, such as EACCES
938 *
939 * NB:
940 * NFS supports Cipso labels by parsing the vfs_resource
941 * to see what the Solaris server global zone has shared.
942 * We can't support that for CIFS since resource names
943 * contain share names, not paths.
944 */
945static int
946smbfs_mount_label_policy(vfs_t *vfsp, void *ipaddr, int addr_type, cred_t *cr)
947{
948	bslabel_t	*server_sl, *mntlabel;
949	zone_t		*mntzone = NULL;
950	ts_label_t	*zlabel;
951	tsol_tpc_t	*tp;
952	ts_label_t	*tsl = NULL;
953	int		retv;
954
955	/*
956	 * Get the zone's label.  Each zone on a labeled system has a label.
957	 */
958	mntzone = zone_find_by_any_path(refstr_value(vfsp->vfs_mntpt), B_FALSE);
959	zlabel = mntzone->zone_slabel;
960	ASSERT(zlabel != NULL);
961	label_hold(zlabel);
962
963	retv = EACCES;				/* assume the worst */
964
965	/*
966	 * Next, get the assigned label of the remote server.
967	 */
968	tp = find_tpc(ipaddr, addr_type, B_FALSE);
969	if (tp == NULL)
970		goto out;			/* error getting host entry */
971
972	if (tp->tpc_tp.tp_doi != zlabel->tsl_doi)
973		goto rel_tpc;			/* invalid domain */
974	if ((tp->tpc_tp.host_type != UNLABELED))
975		goto rel_tpc;			/* invalid hosttype */
976
977	server_sl = &tp->tpc_tp.tp_def_label;
978	mntlabel = label2bslabel(zlabel);
979
980	/*
981	 * Now compare labels to complete the MAC check.  If the labels
982	 * are equal or if the requestor is in the global zone and has
983	 * NET_MAC_AWARE, then allow read-write access.   (Except for
984	 * mounts into the global zone itself; restrict these to
985	 * read-only.)
986	 *
987	 * If the requestor is in some other zone, but his label
988	 * dominates the server, then allow read-down.
989	 *
990	 * Otherwise, access is denied.
991	 */
992	if (blequal(mntlabel, server_sl) ||
993	    (crgetzoneid(cr) == GLOBAL_ZONEID &&
994	    getpflags(NET_MAC_AWARE, cr) != 0)) {
995		if ((mntzone == global_zone) ||
996		    !blequal(mntlabel, server_sl))
997			retv = -1;		/* read-only */
998		else
999			retv = 0;		/* access OK */
1000	} else if (bldominates(mntlabel, server_sl)) {
1001		retv = -1;			/* read-only */
1002	} else {
1003		retv = EACCES;
1004	}
1005
1006	if (tsl != NULL)
1007		label_rele(tsl);
1008
1009rel_tpc:
1010	/*LINTED*/
1011	TPC_RELE(tp);
1012out:
1013	if (mntzone)
1014		zone_rele(mntzone);
1015	label_rele(zlabel);
1016	return (retv);
1017}
1018