| blob | 13e4ea92870b9dd8407f9f09c37bf385f8aff887 |
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_vnops.c,v 1.128.36.1 2005/05/27 02:35:28 lindak Exp $
33 */
35 /*
36 * Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
37 */
39 /*
40 * Vnode operations
41 *
42 * This file is similar to nfs3_vnops.c
43 */
45 #include <sys/param.h>
46 #include <sys/systm.h>
47 #include <sys/cred.h>
48 #include <sys/vnode.h>
49 #include <sys/vfs.h>
50 #include <sys/filio.h>
51 #include <sys/uio.h>
52 #include <sys/dirent.h>
53 #include <sys/errno.h>
54 #include <sys/sunddi.h>
55 #include <sys/sysmacros.h>
56 #include <sys/kmem.h>
57 #include <sys/cmn_err.h>
58 #include <sys/vfs.h>
59 #include <sys/pathname.h>
60 #include <sys/policy.h>
61 #include <sys/sdt.h>
62 #include <sys/taskq_impl.h>
63 #include <sys/zone.h>
64 #include <sys/vmsystm.h>
66 #include <vm/hat.h>
67 #include <vm/as.h>
68 #include <vm/page.h>
69 #include <vm/pvn.h>
70 #include <vm/seg.h>
71 #include <vm/seg_map.h>
72 #include <vm/seg_kpm.h>
73 #include <vm/seg_vn.h>
75 #include <netsmb/smb_osdep.h>
76 #include <netsmb/smb.h>
77 #include <netsmb/smb_conn.h>
78 #include <netsmb/smb_subr.h>
80 #include <smbfs/smbfs.h>
81 #include <smbfs/smbfs_node.h>
82 #include <smbfs/smbfs_subr.h>
84 #include <sys/fs/smbfs_ioctl.h>
85 #include <sys/fs_subr.h>
87 /*
88 * We assign directory offsets like the NFS client, where the
89 * offset increments by _one_ after each directory entry.
90 * Further, the entries "." and ".." are always at offsets
91 * zero and one (respectively) and the "real" entries from
92 * the server appear at offsets starting with two. This
93 * macro is used to initialize the n_dirofs field after
94 * setting n_dirseq with a _findopen call.
95 */
96 #define FIRST_DIROFS 2
98 /*
99 * These characters are illegal in NTFS file names.
100 * ref: http://support.microsoft.com/kb/147438
101 *
102 * Careful! The check in the XATTR case skips the
103 * first character to allow colon in XATTR names.
104 */
115 0
116 };
118 /*
119 * Turning this on causes nodes to be created in the cache
120 * during directory listings, normally avoiding a second
121 * OtW attribute fetch just after a readdir.
122 */
125 /* local static function defines */
128 cred_t *);
138 caller_context_t *);
143 cred_t *);
150 caller_context_t *);
158 /*
159 * Error flags used to pass information about certain special errors
160 * which need to be handled specially.
161 */
162 #define SMBFS_EOF -98
164 /* When implementing OtW locks, make this a real function. */
165 #define smbfs_lm_has_sleep(vp) 0
167 /*
168 * These are the vnode ops routines which implement the vnode interface to
169 * the networked file system. These routines just take their parameters,
170 * make them look networkish by putting the right info into interface structs,
171 * and then calling the appropriate remote routine(s) to do the work.
172 *
173 * Note on directory name lookup cacheing: If we detect a stale fhandle,
174 * we purge the directory cache relative to that vnode. This way, the
175 * user won't get burned by the cache repeatedly. See <smbfs/smbnode.h> for
176 * more details on smbnode locking.
177 */
179 /*
180 * XXX
181 * When new and relevant functionality is enabled, we should be
182 * calling vfs_set_feature() to inform callers that pieces of
183 * functionality are available, per PSARC 2007/227.
184 */
185 /* ARGSUSED */
186 static int
188 {
191 smbfattr_t fa;
216 }
218 /*
219 * Get exclusive access to n_fid and related stuff.
220 * No returns after this until out.
221 */
226 /*
227 * Keep track of the vnode type at first open.
228 * It may change later, and we need close to do
229 * cleanup for the type we opened. Also deny
230 * open of new types until old type is closed.
231 */
240 }
242 /*
243 * Directory open. See smbfs_readvdir()
244 */
247 /* first open */
253 }
257 }
259 /*
260 * If caller specified O_TRUNC/FTRUNC, then be sure to set
261 * FWRITE (to drive successful setattr(size=0) after open)
262 */
266 /*
267 * If we already have it open, and the FID is still valid,
268 * check whether the rights are sufficient for FID reuse.
269 */
281 /*
282 * the existing open is good enough
283 */
286 }
287 }
290 /*
291 * we always ask for READ_CONTROL so we can always get the
292 * owner/group IDs to satisfy a stat. Ditto attributes.
293 */
295 SA_RIGHT_FILE_READ_ATTRIBUTES);
300 SA_RIGHT_FILE_APPEND_DATA |
301 SA_RIGHT_FILE_WRITE_ATTRIBUTES;
312 /*
313 * We have a new FID and access rights.
314 */
323 /*
324 * We already had it open (presumably because
325 * it was open with insufficient rights.)
326 * Close old wire-open.
327 */
333 }
335 /*
336 * This thread did the open.
337 * Save our credentials too.
338 */
347 have_fid:
348 /*
349 * Keep track of the vnode type at first open.
350 * (see comments above)
351 */
355 out:
359 }
361 /*ARGSUSED*/
362 static int
365 {
374 /*
375 * Don't "bail out" for VFS_UNMOUNTED here,
376 * as we want to do cleanup, etc.
377 */
379 /*
380 * zone_enter(2) prevents processes from changing zones with SMBFS files
381 * open; if we happen to get here from the wrong zone we can't do
382 * anything over the wire.
383 */
385 /*
386 * We could attempt to clean up locks, except we're sure
387 * that the current process didn't acquire any locks on
388 * the file: any attempt to lock a file belong to another zone
389 * will fail, and one can't lock an SMBFS file and then change
390 * zones, as that fails too.
391 *
392 * Returning an error here is the sane thing to do. A
393 * subsequent call to VN_RELE() which translates to a
394 * smbfs_inactive() will clean up state: if the zone of the
395 * vnode's origin is still alive and kicking, an async worker
396 * thread will handle the request (from the correct zone), and
397 * everything (minus the final smbfs_getattr_otw() call) should
398 * be OK. If the zone is going away smbfs_async_inactive() will
399 * throw away cached pages inline.
400 */
402 }
404 /*
405 * If we are using local locking for this filesystem, then
406 * release all of the SYSV style record locks. Otherwise,
407 * we are doing network locking and we need to release all
408 * of the network locks. All of the locks held by this
409 * process on this file are released no matter what the
410 * incoming reference count is.
411 */
416 }
417 /*
418 * else doing OtW locking. SMB servers drop all locks
419 * on the file ID we close here, so no _lockrelease()
420 */
422 /*
423 * This (passed in) count is the ref. count from the
424 * user's file_t before the closef call (fio.c).
425 * The rest happens only on last close.
426 */
430 /* NFS has DNLC purge here. */
432 /*
433 * If the file was open for write and there are pages,
434 * then make sure dirty pages written back.
435 *
436 * NFS does this async when "close-to-open" is off
437 * (MI_NOCTO flag is set) to avoid blocking the caller.
438 * For now, always do this synchronously (no B_ASYNC).
439 */
444 }
450 }
452 /*
453 * Decrement the reference count for the FID
454 * and possibly do the OtW close.
455 *
456 * Exclusive lock for modifying n_fid stuff.
457 * Don't want this one ever interruptible.
458 */
468 }
470 /*
471 * Helper for smbfs_close. Decrement the reference count
472 * for an SMB-level file or directory ID, and when the last
473 * reference for the fid goes away, do the OtW close.
474 * Also called in smbfs_inactive (defensive cleanup).
475 */
476 static void
478 {
488 /* Make sure we serialize for n_dirseq use. */
491 /*
492 * Note that vp->v_type may change if a remote node
493 * is deleted and recreated as a different type, and
494 * our getattr may change v_type accordingly.
495 * Now use n_ovtype to keep track of the v_type
496 * we had during open (see comments above).
497 */
507 }
516 /* After reconnect, n_fid is invalid */
520 }
521 }
527 }
531 }
533 /* Allow next open to use any v_type. */
536 /*
537 * Other "last close" stuff.
538 */
547 }
549 /* ARGSUSED */
550 static int
553 {
559 offset_t endoff;
560 ssize_t past_eof;
563 caddr_t base;
564 uoff_t off;
567 uint_t flags;
587 /*
588 * Like NFS3, just check for 63-bit overflow.
589 * Our SMB layer takes care to return EFBIG
590 * when it has to fallback to a 32-bit call.
591 */
596 /* get vnode attributes from server */
601 /* Update mtime with mtime from server here? */
603 /* if offset is beyond EOF, read nothing */
607 /*
608 * Limit the read to the remaining file size.
609 * Do this by temporarily reducing uio_resid
610 * by the amount the lies beyoned the EOF.
611 */
618 /*
619 * Bypass VM if caching has been disabled (e.g., locking) or if
620 * using client-side direct I/O and the file is not mmap'd and
621 * there are no cached pages.
622 */
628 /* Shared lock for n_fid use in smb_rwuio */
633 /* After reconnect, n_fid is invalid */
636 else
643 /* undo adjustment of resid */
647 }
649 /* (else) Do I/O through segmap. */
659 /* NFS waits for RINCACHEPURGE here. */
662 /*
663 * Copy data.
664 */
669 S_READ);
672 }
675 /*
676 * If read a whole block or read to eof,
677 * won't need this buffer again soon.
678 */
683 else
690 }
696 }
697 }
700 /* undo adjustment of resid */
704 }
707 /* ARGSUSED */
708 static int
711 {
718 ssize_t past_limit;
720 caddr_t base;
721 uoff_t off;
724 uint_t flags;
725 uoff_t last_off;
727 uint_t bsize;
747 /*
748 * Handle ioflag bits: (FAPPEND|FSYNC|FDSYNC)
749 */
753 }
754 }
756 /*
757 * File size can be changed by another client
758 *
759 * Todo: Consider redesigning this to use a
760 * handle opened for append instead.
761 */
766 }
768 /*
769 * Like NFS3, just check for 63-bit overflow.
770 */
775 /*
776 * Check to make sure that the process will not exceed
777 * its limit on file size. It is okay to write up to
778 * the limit, but not beyond. Thus, the write which
779 * reaches the limit will be short and the next write
780 * will return an error.
781 *
782 * So if we're starting at or beyond the limit, EFBIG.
783 * Otherwise, temporarily reduce resid to the amount
784 * that is after the limit.
785 */
797 }
804 /*
805 * Bypass VM if caching has been disabled (e.g., locking) or if
806 * using client-side direct I/O and the file is not mmap'd and
807 * there are no cached pages.
808 */
814 smbfs_fwrite:
819 /*
820 * A close may have cleared r_error, if so,
821 * propagate ESTALE error return properly
822 */
826 }
828 /* Timeout: longer for append. */
833 /* Shared lock for n_fid use in smb_rwuio */
838 /* After reconnect, n_fid is invalid */
841 else
852 /* Don't error the I/O if this fails. */
854 }
855 }
860 /* undo adjustment of resid */
864 }
866 /* (else) Do I/O through segmap. */
879 /*
880 * A close may have cleared r_error, if so,
881 * propagate ESTALE error return properly
882 */
886 }
888 /*
889 * From NFS: Don't create dirty pages faster than they
890 * can be cleaned.
891 *
892 * Here NFS also checks for async writes (np->r_awcount)
893 */
907 }
912 }
915 /*
916 * Touch the page and fault it in if it is not in core
917 * before segmap_getmapflt or vpm_data_copy can lock it.
918 * This is to avoid the deadlock if the buffer is mapped
919 * to the same file through mmap which we want to write.
920 */
924 /*
925 * It will use kpm mappings, so no need to
926 * pass an address.
927 */
945 pagecreate);
951 }
952 }
959 /*
960 * Have written a whole block.
961 * Start an asynchronous write
962 * and mark the buffer to
963 * indicate that it won't be
964 * needed again soon.
965 */
973 }
978 }
984 }
985 /*
986 * In the event that we got an access error while
987 * faulting in a page for a write-only file just
988 * force a write.
989 */
992 }
995 bottom:
996 /* undo adjustment of resid */
1002 }
1005 }
1007 /*
1008 * Like nfs_client.c: writerp()
1009 *
1010 * Write by creating pages and uiomove data onto them.
1011 */
1013 int
1016 {
1020 caddr_t saved_base;
1021 uoff_t offset;
1030 }
1032 /*
1033 * Move bytes in at most PAGESIZE chunks. We must avoid
1034 * spanning pages in uiomove() because page faults may cause
1035 * the cache to be invalidated out from under us. The r_size is not
1036 * updated until after the uiomove. If we push the last page of a
1037 * file before r_size is correct, we will lose the data written past
1038 * the current (and invalid) r_size.
1039 */
1044 /*
1045 * n is the number of bytes required to satisfy the request
1046 * or the number of bytes to fill out the page.
1047 */
1050 /*
1051 * Check to see if we can skip reading in the page
1052 * and just allocate the memory. We can do this
1053 * if we are going to rewrite the entire mapping
1054 * or if we are going to write to or beyond the current
1055 * end of file from the beginning of the mapping.
1056 *
1057 * The read of r_size is now protected by r_statelock.
1058 */
1060 /*
1061 * When pgcreated is nonzero the caller has already done
1062 * a segmap_getmapflt with forcefault 0 and S_WRITE. With
1063 * segkpm this means we already have at least one page
1064 * created and mapped at base.
1065 */
1072 /*
1073 * The last argument tells segmap_pagecreate() to
1074 * always lock the page, as opposed to sometimes
1075 * returning with the page locked. This way we avoid a
1076 * fault on the ensuing uiomove(), but also
1077 * more importantly (to fix bug 1094402) we can
1078 * call segmap_fault() to unlock the page in all
1079 * cases. An alternative would be to modify
1080 * segmap_pagecreate() to tell us when it is
1081 * locking a page, but that's a fairly major
1082 * interface change.
1083 */
1089 }
1091 /*
1092 * The number of bytes of data in the last page can not
1093 * be accurately be determined while page is being
1094 * uiomove'd to and the size of the file being updated.
1095 * Thus, inform threads which need to know accurately
1096 * how much data is in the last page of the file. They
1097 * will not do the i/o immediately, but will arrange for
1098 * the i/o to happen later when this modify operation
1099 * will have finished.
1100 */
1108 /*
1109 * Copy data. If new pages are created, part of
1110 * the page that is not written will be initizliazed
1111 * with zeros.
1112 */
1117 }
1119 /*
1120 * r_size is the maximum number of
1121 * bytes known to be in the file.
1122 * Make sure it is at least as high as the
1123 * first unwritten byte pointed to by uio_loffset.
1124 */
1132 /* n = # of bytes written */
1137 }
1139 /*
1140 * If we created pages w/o initializing them completely,
1141 * we need to zero the part that wasn't set up.
1142 * This happens on a most EOF write cases and if
1143 * we had some sort of error during the uiomove.
1144 */
1150 /*
1151 * Caller is responsible for this page,
1152 * it was not created in this loop.
1153 */
1156 /*
1157 * For bug 1094402: segmap_pagecreate locks
1158 * page. Unlock it. This also unlocks the
1159 * pages allocated by page_create_va() in
1160 * segmap_pagecreate().
1161 */
1167 }
1168 }
1172 }
1174 /*
1175 * Flags are composed of {B_ASYNC, B_INVAL, B_FREE, B_DONTNEED}
1176 * Like nfs3_rdwrlbn()
1177 */
1178 static int
1181 {
1196 /*
1197 * pageio_setup should have set b_addr to 0. This
1198 * is correct since we want to do I/O on a page
1199 * boundary. bp_mapin will use this addr to calculate
1200 * an offset, and then set b_addr to the kernel virtual
1201 * address it allocated for us.
1202 */
1212 /*
1213 * Calculate the desired level of stability to write data.
1214 */
1220 }
1228 }
1231 /*
1232 * Corresponds to nfs3_vnopc.c : nfs3_bio(), though the NFS code
1233 * uses nfs3read()/nfs3write() where we use smb_rwuio(). Also,
1234 * NFS has this later in the file. Move it up here closer to
1235 * the one call site just above.
1236 */
1238 static int
1240 {
1247 offset_t offset;
1248 offset_t endoff;
1261 /*
1262 * Limit file I/O to the remaining file size, but see
1263 * the notes in smbfs_getpage about SMBFS_EOF.
1264 */
1272 }
1273 }
1282 /* Caller did bpmapin(). Mapped address is... */
1292 /* Shared lock for n_fid use in smb_rwuio */
1302 /* After reconnect, n_fid is invalid */
1305 else
1309 /* Like NFS, only set b_error here. */
1316 /* Zero the memory beyond EOF. */
1318 }
1321 /* After reconnect, n_fid is invalid */
1324 else
1328 /* Like NFS, only set b_error here. */
1336 }
1337 }
1339 /*
1340 * This comes from nfs3_commit()
1341 */
1350 }
1361 }
1363 /*
1364 * Here NFS has: nfs3write, nfs3read
1365 * We use smb_rwuio instead.
1366 */
1368 /* ARGSUSED */
1369 static int
1372 {
1390 /*
1391 * The following two ioctls are used by bfu.
1392 * Silently ignore to avoid bfu errors.
1393 */
1402 #endif
1408 /*
1409 * Allow get/set with "raw" security descriptor (SD) data.
1410 * Useful for testing, diagnosing idmap problems, etc.
1411 */
1423 }
1426 }
1429 /*
1430 * Return either cached or remote attributes. If get remote attr
1431 * use them to check and invalidate caches, then cache the new attributes.
1432 */
1433 /* ARGSUSED */
1434 static int
1437 {
1450 /*
1451 * If it has been specified that the return value will
1452 * just be used as a hint, and we are only being asked
1453 * for size, fsid or rdevid, then return the client's
1454 * notion of these values without checking to make sure
1455 * that the attribute cache is up to date.
1456 * The whole point is to avoid an over the wire GETATTR
1457 * call.
1458 */
1472 }
1473 }
1475 /*
1476 * Only need to flush pages if asking for the mtime
1477 * and if there any dirty pages.
1478 *
1479 * Here NFS also checks for async writes (np->r_awcount)
1480 */
1492 }
1496 }
1497 }
1500 }
1502 /* smbfsgetattr() in smbfs_client.c */
1504 /*ARGSUSED4*/
1505 static int
1508 {
1512 uint_t mask;
1531 /*
1532 * This is a _local_ access check so that only the owner of
1533 * this mount can set attributes. With ACLs enabled, the
1534 * file owner can be different from the mount owner, and we
1535 * need to check the _mount_ owner here. See _access_rwx
1536 */
1554 else
1559 /*
1560 * It might be more correct to return the
1561 * error here, but that causes complaints
1562 * when root extracts a cpio archive, etc.
1563 * So ignore this error, and go ahead with
1564 * the rest of the setattr work.
1565 */
1566 }
1567 }
1571 #ifdef SMBFS_VNEVENT
1574 #endif
1577 }
1579 /*
1580 * Mostly from Darwin smbfs_setattr()
1581 * but then modified a lot.
1582 */
1583 /* ARGSUSED */
1584 static int
1586 {
1600 /*
1601 * There are no settable attributes on the XATTR dir,
1602 * so just silently ignore these. On XATTR files,
1603 * you can set the size but nothing else.
1604 */
1611 }
1613 /*
1614 * Only need to flush pages if there are any pages and
1615 * if the file is marked as dirty in some fashion. The
1616 * file must be flushed so that we can accurately
1617 * determine the size of the file and the cached data
1618 * after the SETATTR returns. A file is considered to
1619 * be dirty if it is either marked with RDIRTY, has
1620 * outstanding i/o's active, or is mmap'd. In this
1621 * last case, we can't tell whether there are dirty
1622 * pages, so we flush just to be sure.
1623 */
1635 }
1636 }
1638 /*
1639 * If our caller is trying to set multiple attributes, they
1640 * can make no assumption about what order they are done in.
1641 * Here we try to do them in order of decreasing likelihood
1642 * of failure, just to minimize the chance we'll wind up
1643 * with a partially complete request.
1644 */
1646 /* Shared lock for (possible) n_fid use. */
1651 /*
1652 * If the caller has provided extensible attributes,
1653 * map those into DOS attributes supported by SMB.
1654 * Note: zero means "no change".
1655 */
1659 /*
1660 * Will we need an open handle for this setattr?
1661 * If so, what rights will we need?
1662 */
1664 rights |=
1665 SA_RIGHT_FILE_WRITE_ATTRIBUTES;
1666 }
1668 rights |=
1669 SA_RIGHT_FILE_WRITE_DATA |
1670 SA_RIGHT_FILE_APPEND_DATA;
1671 }
1673 /*
1674 * Only SIZE really requires a handle, but it's
1675 * simpler and more reliable to set via a handle.
1676 * Some servers like NT4 won't set times by path.
1677 * Also, we're usually setting everything anyway.
1678 */
1685 }
1687 }
1689 /*
1690 * If the server supports the UNIX extensions, right here is where
1691 * we'd support changes to uid, gid, mode, and possibly va_flags.
1692 * For now we claim to have made any such changes.
1693 */
1696 /*
1697 * If the new file size is less than what the client sees as
1698 * the file size, then just change the size and invalidate
1699 * the pages.
1700 */
1702 /*
1703 * Set the file size to vap->va_size.
1704 */
1711 /*
1712 * Darwin had code here to zero-extend.
1713 * Tests indicate the server will zero-fill,
1714 * so looks like we don't need to do that.
1715 */
1720 }
1721 }
1723 /*
1724 * Todo: Implement setting create_time (which is
1725 * different from ctime).
1726 */
1731 /*
1732 * Always use the handle-based set attr call now.
1733 */
1742 }
1743 }
1745 out:
1751 }
1757 /*
1758 * Invalidate attribute cache in case the server
1759 * doesn't set exactly the attributes we asked.
1760 */
1763 /*
1764 * If changing the size of the file, invalidate
1765 * any local cached data which is no longer part
1766 * of the file. We also possibly invalidate the
1767 * last page in the file. We could use
1768 * pvn_vpzero(), but this would mark the page as
1769 * modified and require it to be written back to
1770 * the server for no particularly good reason.
1771 * This way, if we access it, then we bring it
1772 * back in. A read should be cheaper than a
1773 * write.
1774 */
1778 }
1779 }
1782 }
1784 /*
1785 * Helper function for extensible system attributes (PSARC 2007/315)
1786 * Compute the DOS attribute word to pass to _setfattr (see above).
1787 * This returns zero IFF no change is being made to attributes.
1788 * Otherwise return the new attributes or SMB_EFA_NORMAL.
1789 */
1790 static uint32_t
1792 {
1804 else
1808 }
1812 else
1816 }
1820 else
1824 }
1828 else
1832 }
1840 }
1842 /*
1843 * smbfs_access_rwx()
1844 * Common function for smbfs_access, etc.
1845 *
1846 * The security model implemented by the FS is unusual
1847 * due to the current "single user mounts" restriction:
1848 * All access under a given mount point uses the CIFS
1849 * credentials established by the owner of the mount.
1850 *
1851 * Most access checking is handled by the CIFS server,
1852 * but we need sufficient Unix access checks here to
1853 * prevent other local Unix users from having access
1854 * to objects under this mount that the uid/gid/mode
1855 * settings in the mount would not allow.
1856 *
1857 * With this model, there is a case where we need the
1858 * ability to do an access check before we have the
1859 * vnode for an object. This function takes advantage
1860 * of the fact that the uid/gid/mode is per mount, and
1861 * avoids the need for a vnode.
1862 *
1863 * We still (sort of) need a vnode when we call
1864 * secpolicy_vnode_access, but that only uses
1865 * the vtype field, so we can use a pair of fake
1866 * vnodes that have only v_type filled in.
1867 */
1868 static int
1870 {
1871 /* See the secpolicy call below. */
1874 vattr_t va;
1879 /*
1880 * Build our (fabricated) vnode attributes.
1881 */
1890 /*
1891 * Disallow write attempts on read-only file systems,
1892 * unless the file is a device or fifo node. Note:
1893 * Inline vn_is_readonly and IS_DEVVP here because
1894 * we may not have a vnode ptr. Original expr. was:
1895 * (mode & VWRITE) && vn_is_readonly(vp) && !IS_DEVVP(vp))
1896 */
1902 /*
1903 * Disallow attempts to access mandatory lock files.
1904 * Similarly, expand MANDLOCK here.
1905 */
1910 /*
1911 * Access check is based on only
1912 * one of owner, group, public.
1913 * If not owner, then check group.
1914 * If not a member of the group,
1915 * then check public access.
1916 */
1921 }
1923 /*
1924 * We need a vnode for secpolicy_vnode_access,
1925 * but the only thing it looks at is v_type,
1926 * so pass one of the templates above.
1927 */
1934 }
1936 /*
1937 * See smbfs_setattr
1938 */
1939 static int
1941 {
1943 /*
1944 * Note: The caller has checked the current zone,
1945 * the SMI_DEAD and VFS_UNMOUNTED flags, etc.
1946 */
1948 }
1950 /*
1951 * XXX
1952 * This op should support PSARC 2007/403, Modified Access Checks for CIFS
1953 */
1954 /* ARGSUSED */
1955 static int
1957 {
1971 }
1974 /* ARGSUSED */
1975 static int
1977 {
1978 /* Not yet... */
1980 }
1983 /*
1984 * Flush local dirty pages to stable storage on the server.
1985 *
1986 * If FNODSYNC is specified, then there is nothing to do because
1987 * metadata changes are not cached on the client before being
1988 * sent to the server.
1989 */
1990 /* ARGSUSED */
1991 static int
1993 {
2018 /* Shared lock for n_fid use in _flush */
2029 }
2031 /*
2032 * Last reference to vnode went away.
2033 */
2034 /* ARGSUSED */
2035 static void
2037 {
2042 /*
2043 * Don't "bail out" for VFS_UNMOUNTED here,
2044 * as we want to do cleanup, etc.
2045 * See also pcfs_inactive
2046 */
2048 /*
2049 * If this is coming from the wrong zone, we let someone in the right
2050 * zone take care of it asynchronously. We can get here due to
2051 * VN_RELE() being called from pageout() or fsflush(). This call may
2052 * potentially turn into an expensive no-op if, for instance, v_count
2053 * gets incremented in the meantime, but it's still correct.
2054 */
2056 /*
2057 * From NFS:rinactive()
2058 *
2059 * Before freeing anything, wait until all asynchronous
2060 * activity is done on this rnode. This will allow all
2061 * asynchronous read ahead and write behind i/o's to
2062 * finish.
2063 */
2069 /*
2070 * Flush and invalidate all pages associated with the vnode.
2071 */
2080 }
2081 }
2083 }
2084 /*
2085 * This vnode should have lost all cached data.
2086 */
2089 /*
2090 * Defend against the possibility that higher-level callers
2091 * might not correctly balance open and close calls. If we
2092 * get here with open references remaining, it means there
2093 * was a missing fop_close somewhere. If that happens, do
2094 * the close here so we don't "leak" FIDs on the server.
2095 *
2096 * Exclusive lock for modifying n_fid stuff.
2097 * Don't want this one ever interruptible.
2098 */
2104 /* not open (OK) */
2112 /* Force last close. */
2122 /* Force last close. */
2131 }
2136 /*
2137 * XATTR directories (and the files under them) have
2138 * little value for reclaim, so just remove them from
2139 * the "hash" (AVL) as soon as they go inactive.
2140 * Note that the node may already have been removed
2141 * from the hash by smbfsremove.
2142 */
2148 }
2150 /*
2151 * Remote file system operations having to do with directory manipulation.
2152 */
2153 /* ARGSUSED */
2154 static int
2158 {
2175 /*
2176 * Are we looking up extended attributes? If so, "dvp" is
2177 * the file or directory for which we want attributes, and
2178 * we need a lookup of the (faked up) attribute directory
2179 * before we lookup the rest of the path.
2180 */
2182 /*
2183 * Require the xattr mount option.
2184 */
2190 }
2200 }
2202 /* ARGSUSED */
2203 static int
2206 {
2213 /* struct smb_vc *vcp; */
2226 #ifdef NOT_YET
2229 /* XXX: Should compute this once and store it in smbmntinfo_t */
2231 #else
2233 #endif
2235 /*
2236 * RWlock must be held, either reader or writer.
2237 */
2240 /*
2241 * If lookup is for "", just return dvp.
2242 * No need to perform any access checks.
2243 */
2248 }
2250 /*
2251 * Can't do lookups in non-directories.
2252 */
2256 /*
2257 * Need search permission in the directory.
2258 */
2263 /*
2264 * If lookup is for ".", just return dvp.
2265 * Access check was done above.
2266 */
2271 }
2273 /*
2274 * Now some sanity checks on the name.
2275 * First check the length.
2276 */
2280 /*
2281 * Avoid surprises with characters that are
2282 * illegal in Windows file names.
2283 * Todo: CATIA mappings?
2284 */
2291 /*
2292 * Special handling for lookup of ".."
2293 *
2294 * We keep full pathnames (as seen on the server)
2295 * so we can just trim off the last component to
2296 * get the full pathname of the parent. Note:
2297 * We don't actually copy and modify, but just
2298 * compute the trimmed length and pass that with
2299 * the current dir path (not null terminated).
2300 *
2301 * We don't go over-the-wire to get attributes
2302 * for ".." because we know it's a directory,
2303 * and we can just leave the rest "stale"
2304 * until someone does a getattr.
2305 */
2308 /*
2309 * Already at the root. This can happen
2310 * with directory listings at the root,
2311 * which lookup "." and ".." to get the
2312 * inode numbers. Let ".." be the same
2313 * as "." in the FS root.
2314 */
2318 }
2320 /*
2321 * Special case for XATTR directory
2322 */
2326 }
2328 /*
2329 * Find the parent path length.
2330 */
2336 }
2338 /* Found our way to the root. */
2343 }
2351 /* Success! */
2354 }
2356 /*
2357 * Normal lookup of a name under this directory.
2358 * Note we handled "", ".", ".." above.
2359 */
2361 /*
2362 * The caller indicated that it's OK to use a
2363 * cached result for this lookup, so try to
2364 * reclaim a node from the smbfs node cache.
2365 */
2370 /* hold taken in lookup_cache */
2373 }
2374 }
2376 /*
2377 * OK, go over-the-wire to get the attributes,
2378 * then create the node.
2379 */
2381 /* Note: this can allocate a new "name" */
2385 /*
2386 * Lookup failed because this directory was
2387 * removed or renamed by another client.
2388 * Remove any cached attributes under it.
2389 */
2392 }
2400 /* Success! */
2403 out:
2404 /* smbfs_smb_lookup may have allocated name. */
2409 }
2411 /*
2412 * smbfslookup_cache
2413 *
2414 * Try to reclaim a node from the smbfs node cache.
2415 * Some statistics for DEBUG.
2416 *
2417 * This mechanism lets us avoid many of the five (or more)
2418 * OtW lookup calls per file seen with "ls -l" if we search
2419 * the smbfs node cache for recently inactive(ated) nodes.
2420 */
2421 #ifdef DEBUG
2429 /* ARGSUSED */
2430 static int
2433 {
2444 #ifdef DEBUG
2445 smbfs_lookup_cache_calls++;
2446 #endif
2448 /*
2449 * First make sure we can get attributes for the
2450 * directory. Cached attributes are OK here.
2451 * If we removed or renamed the directory, this
2452 * will return ENOENT. If someone else removed
2453 * this directory or file, we'll find out when we
2454 * try to open or get attributes.
2455 */
2459 #ifdef DEBUG
2460 smbfs_lookup_cache_error++;
2461 #endif
2463 }
2465 /*
2466 * Passing NULL smbfattr here so we will
2467 * just look, not create.
2468 */
2474 #ifdef DEBUG
2475 smbfs_lookup_cache_miss++;
2476 #endif
2478 }
2480 /*
2481 * Found it. Attributes still valid?
2482 */
2485 /* stale */
2486 #ifdef DEBUG
2487 smbfs_lookup_cache_stale++;
2488 #endif
2491 }
2493 /*
2494 * Success!
2495 * Caller gets hold from smbfs_node_findcreate
2496 */
2497 #ifdef DEBUG
2498 smbfs_lookup_cache_hits++;
2499 #endif
2502 }
2505 /*
2506 * XXX
2507 * vsecattr_t is new to build 77, and we need to eventually support
2508 * it in order to create an ACL when an object is created.
2509 *
2510 * This op should support the new FIGNORECASE flag for case-insensitive
2511 * lookups, per PSARC 2007/244.
2512 */
2513 /* ARGSUSED */
2514 static int
2518 {
2546 /*
2547 * Note: this may break mknod(2) calls to create a directory,
2548 * but that's obscure use. Some other filesystems do this.
2549 * Todo: redirect VDIR type here to _mkdir.
2550 */
2554 /*
2555 * If the pathname is "", just use dvp, no checks.
2556 * Do this outside of the rwlock (like zfs).
2557 */
2562 }
2564 /* Don't allow "." or ".." through here. */
2569 /*
2570 * We make a copy of the attributes because the caller does not
2571 * expect us to change what va points to.
2572 */
2579 /*
2580 * NFS needs to go over the wire, just to be sure whether the
2581 * file exists or not. Using a cached result is dangerous in
2582 * this case when making a decision regarding existence.
2583 *
2584 * The SMB protocol does NOT really need to go OTW here
2585 * thanks to the expressive NTCREATE disposition values.
2586 * Unfortunately, to do Unix access checks correctly,
2587 * we need to know if the object already exists.
2588 * When the object does not exist, we need VWRITE on
2589 * the directory. Note: smbfslookup() checks VEXEC.
2590 */
2593 /*
2594 * The file already exists. Error?
2595 * NB: have a hold from smbfslookup
2596 */
2601 }
2602 /*
2603 * Verify requested access.
2604 */
2609 }
2611 /*
2612 * Truncate (if requested).
2613 */
2616 /*
2617 * Check here for large file truncation by
2618 * LF-unaware process, like ufs_create().
2619 */
2625 }
2629 }
2635 }
2636 #ifdef SMBFS_VNEVENT
2637 /* Existing file was truncated */
2639 #endif
2640 /* invalidate pages done in smbfssetattr() */
2641 }
2642 /* Success! */
2645 }
2647 /*
2648 * The file did not exist. Need VWRITE in the directory.
2649 */
2654 /*
2655 * Now things get tricky. We also need to check the
2656 * requested open mode against the file we may create.
2657 * See comments at smbfs_access_rwx
2658 */
2663 /*
2664 * Now the code derived from Darwin,
2665 * but with greater use of NT_CREATE
2666 * disposition options. Much changed.
2667 *
2668 * Create (or open) a new child node.
2669 * Note we handled "." and ".." above.
2670 */
2675 /* Truncate regular files if requested. */
2680 else
2682 }
2690 /*
2691 * Should use the fid to get/set the size
2692 * while we have it opened here. See above.
2693 */
2700 /*
2701 * In the open case, the name may differ a little
2702 * from what we passed to create (case, etc.)
2703 * so call lookup to get the (opened) name.
2704 *
2705 * XXX: Could avoid this extra lookup if the
2706 * "createact" result from NT_CREATE says we
2707 * created the object.
2708 */
2713 /* update attr and directory cache */
2720 /* Success! */
2724 out:
2730 }
2732 /*
2733 * XXX
2734 * This op should support the new FIGNORECASE flag for case-insensitive
2735 * lookups, per PSARC 2007/244.
2736 */
2737 /* ARGSUSED */
2738 static int
2741 {
2754 /*
2755 * Verify access to the dirctory.
2756 */
2765 /* Lookup the file to remove. */
2768 /*
2769 * Do the real remove work
2770 */
2773 }
2779 }
2781 /*
2782 * smbfsremove does the real work of removing in SMBFS
2783 * Caller has done dir access checks etc.
2784 *
2785 * The normal way to delete a file over SMB is open it (with DELETE access),
2786 * set the "delete-on-close" flag, and close the file. The problem for Unix
2787 * applications is that they expect the file name to be gone once the unlink
2788 * completes, and the SMB server does not actually delete the file until ALL
2789 * opens of that file are closed. We can't assume our open handles are the
2790 * only open handles on a file we're deleting, so to be safe we'll try to
2791 * rename the file to a temporary name and then set delete-on-close. If we
2792 * fail to set delete-on-close (i.e. because other opens prevent it) then
2793 * undo the changes we made and give up with EBUSY. Note that we might have
2794 * permission to delete a file but lack permission to rename, so we want to
2795 * continue in cases where rename fails. As an optimization, only do the
2796 * rename when we have the file open.
2797 *
2798 * This is similar to what NFS does when deleting a file that has local opens,
2799 * but thanks to SMB delete-on-close, we don't need to keep track of when the
2800 * last local open goes away and send a delete. The server does that for us.
2801 */
2802 /* ARGSUSED */
2803 static int
2806 {
2816 /*
2817 * The dvp RWlock must be held as writer.
2818 */
2821 /* Never allow link/unlink directories on SMB. */
2825 /*
2826 * We need to flush any dirty pages which happen to
2827 * be hanging around before removing the file. This
2828 * shouldn't happen very often and mostly on file
2829 * systems mounted "nocto".
2830 */
2840 }
2841 }
2843 /* Shared lock for n_fid use in smbfs_smb_setdisp etc. */
2847 /*
2848 * Get a file handle with delete access.
2849 * Close this FID before return.
2850 */
2857 }
2860 /*
2861 * If we have the file open, try to rename it to a temporary name.
2862 * If we can't rename, continue on and try setting DoC anyway.
2863 */
2871 /* Keep going without the rename. */
2874 }
2875 }
2877 /*
2878 * Mark the file as delete-on-close. If we can't,
2879 * undo what we did and err out.
2880 */
2885 /*
2886 * Failed to set DoC. If we renamed, undo that.
2887 * Need np->n_rpath relative to parent (dnp).
2888 * Use parent path name length plus one for
2889 * the separator ('/' or ':')
2890 */
2902 }
2905 }
2906 /* Done! */
2909 #ifdef SMBFS_VNEVENT
2911 #endif
2913 out:
2922 /* Keep lookup from finding this node anymore. */
2924 }
2927 }
2930 /* ARGSUSED */
2931 static int
2934 {
2935 /* Not yet... */
2937 }
2940 /*
2941 * XXX
2942 * This op should support the new FIGNORECASE flag for case-insensitive
2943 * lookups, per PSARC 2007/244.
2944 */
2945 /* ARGSUSED */
2946 static int
2949 {
2970 /*
2971 * Check that everything is on the same filesystem.
2972 * vn_rename checks the fsid's, but in case we don't
2973 * fill those in correctly, check here too.
2974 */
2978 /*
2979 * Need write access on source and target.
2980 * Server takes care of most checks.
2981 */
2989 }
2991 /*
2992 * Need to lock both old/new dirs as writer.
2993 *
2994 * Avoid deadlock here on old vs new directory nodes
2995 * by always taking the locks in order of address.
2996 * The order is arbitrary, but must be consistent.
2997 */
3006 }
3015 }
3016 }
3019 /* Lookup the "old" name */
3022 /*
3023 * Do the real rename work
3024 */
3027 }
3034 }
3036 /*
3037 * smbfsrename does the real work of renaming in SMBFS
3038 * Caller has done dir access checks etc.
3039 */
3040 /* ARGSUSED */
3041 static int
3044 {
3052 /* Things our caller should have checked. */
3058 /*
3059 * Lookup the target file. If it exists, it needs to be
3060 * checked to see whether it is a mount point and whether
3061 * it is active (open).
3062 */
3065 /*
3066 * Target (nvp) already exists. Check that it
3067 * has the same type as the source. The server
3068 * will check this also, (and more reliably) but
3069 * this lets us return the correct error codes.
3070 */
3075 }
3080 }
3081 }
3083 /*
3084 * POSIX dictates that when the source and target
3085 * entries refer to the same file object, rename
3086 * must do nothing and exit without error.
3087 */
3091 }
3093 /*
3094 * Also must ensure the target is not a mount point,
3095 * and keep mount/umount away until we're done.
3096 */
3100 }
3105 }
3107 /*
3108 * CIFS may give a SHARING_VIOLATION error when
3109 * trying to rename onto an exising object,
3110 * so try to remove the target first.
3111 * (Only for files, not directories.)
3112 */
3116 }
3121 /*
3122 * OK, removed the target file. Continue as if
3123 * lookup target had failed (nvp == NULL).
3124 */
3134 /*
3135 * If the old name should no longer exist,
3136 * discard any cached attributes under it.
3137 */
3140 /* SMBFS_VNEVENT... */
3141 }
3143 out:
3148 }
3151 }
3153 /*
3154 * XXX
3155 * vsecattr_t is new to build 77, and we need to eventually support
3156 * it in order to create an ACL when an object is created.
3157 *
3158 * This op should support the new FIGNORECASE flag for case-insensitive
3159 * lookups, per PSARC 2007/244.
3160 */
3161 /* ARGSUSED */
3162 static int
3165 {
3185 /* Only plain files are allowed in V_XATTRDIR. */
3193 /*
3194 * Require write access in the containing directory.
3195 */
3218 /* Success! */
3221 out:
3229 }
3231 /*
3232 * XXX
3233 * This op should support the new FIGNORECASE flag for case-insensitive
3234 * lookups, per PSARC 2007/244.
3235 */
3236 /* ARGSUSED */
3237 static int
3240 {
3259 /*
3260 * Require w/x access in the containing directory.
3261 * Server handles all other access checks.
3262 */
3267 /*
3268 * First lookup the entry to be removed.
3269 */
3275 /*
3276 * Disallow rmdir of "." or current dir, or the FS root.
3277 * Also make sure it's a directory, not a mount point,
3278 * and lock to keep mount/umount away until we're done.
3279 */
3283 }
3287 }
3291 }
3296 }
3301 /*
3302 * Similar to smbfs_remove
3303 */
3310 }
3321 out:
3326 }
3331 }
3334 /* ARGSUSED */
3335 static int
3338 {
3339 /* Not yet... */
3341 }
3344 /* ARGSUSED */
3345 static int
3348 {
3361 /*
3362 * Require read access in the directory.
3363 */
3370 /*
3371 * Todo readdir cache here
3372 *
3373 * I am serializing the entire readdir opreation
3374 * now since we have not yet implemented readdir
3375 * cache. This fix needs to be revisited once
3376 * we implement readdir cache.
3377 */
3386 }
3388 /* ARGSUSED */
3389 static int
3392 {
3393 /*
3394 * Note: "limit" tells the SMB-level FindFirst/FindNext
3395 * functions how many directory entries to request in
3396 * each OtW call. It needs to be large enough so that
3397 * we don't make lots of tiny OtW requests, but there's
3398 * no point making it larger than the maximum number of
3399 * OtW entries that would fit in a maximum sized trans2
3400 * response (64k / 48). Beyond that, it's just tuning.
3401 * WinNT used 512, Win2k used 1366. We use 1000.
3402 */
3404 /* Largest possible dirent size. */
3411 ssize_t save_resid;
3415 ushort_t reclen;
3419 /* Make sure we serialize for n_dirseq use. */
3422 /*
3423 * Make sure smbfs_open filled in n_dirseq
3424 */
3428 /* Check for overflow of (32-bit) directory offset. */
3433 /* Require space for at least one dirent. */
3448 /*
3449 * Generate the "." and ".." entries here so we can
3450 * (1) make sure they appear (but only once), and
3451 * (2) deal with getting their I numbers which the
3452 * findnext below does only for normal names.
3453 */
3455 /*
3456 * Tricky bit filling in the first two:
3457 * offset 0 is ".", offset 1 is ".."
3458 * so strlen of these is offset+1.
3459 */
3468 /*
3469 * Want the real I-numbers for the "." and ".."
3470 * entries. For these two names, we know that
3471 * smbfslookup can get the nodes efficiently.
3472 */
3479 }
3480 /*
3481 * Note: d_off is the offset that a user-level program
3482 * should seek to for reading the NEXT directory entry.
3483 * See libc: readdir, telldir, seekdir
3484 */
3489 /*
3490 * Note: uiomove updates uio->uio_offset,
3491 * but we want it to be our "cookie" value,
3492 * which just counts dirents ignoring size.
3493 */
3495 }
3497 /*
3498 * If there was a backward seek, we have to reopen.
3499 */
3509 }
3510 /* free the old one */
3512 /* save the new one */
3517 }
3519 /*
3520 * Skip entries before the requested offset.
3521 */
3527 }
3529 /*
3530 * While there's room in the caller's buffer:
3531 * get a directory entry from SMB,
3532 * convert to a dirent, copyout.
3533 * We stop when there is no longer room for a
3534 * maximum sized dirent because we must decide
3535 * before we know anything about the next entry.
3536 */
3543 /* Sanity check the name length. */
3548 }
3550 /* See comment at smbfs_fastlookup above. */
3554 }
3566 /* See comment re. uio_offset above. */
3568 }
3570 out:
3571 /*
3572 * When we come to the end of a directory, the
3573 * SMB-level functions return ENOENT, but the
3574 * caller is not expecting an error return.
3575 *
3576 * Also note that we must delay the call to
3577 * smbfs_smb_findclose(np->n_dirseq, ...)
3578 * until smbfs_close so that all reads at the
3579 * end of the directory will return no data.
3580 */
3585 }
3586 /*
3587 * If we encountered an error (i.e. "access denied")
3588 * from the FindFirst call, we will have copied out
3589 * the "." and ".." entries leaving offset == 2.
3590 * In that case, restore the original offset/resid
3591 * so the caller gets no data with the error.
3592 */
3596 }
3603 }
3605 /*
3606 * Here NFS has: nfs3_bio
3607 * See smbfs_bio above.
3608 */
3610 /* ARGSUSED */
3611 static int
3613 {
3615 }
3618 /*
3619 * The pair of functions fop_rwlock, fop_rwunlock
3620 * are optional functions that are called by:
3621 * getdents, before/after fop_readdir
3622 * pread, before/after ... fop_read
3623 * pwrite, before/after ... fop_write
3624 * (other places)
3625 *
3626 * Careful here: None of the above check for any
3627 * error returns from fop_rwlock / fop_rwunlock!
3628 * In fact, the return value from _rwlock is NOT
3629 * an error code, but V_WRITELOCK_TRUE / _FALSE.
3630 *
3631 * Therefore, it's up to _this_ code to make sure
3632 * the lock state remains balanced, which means
3633 * we can't "bail out" on interrupts, etc.
3634 */
3636 /* ARGSUSED2 */
3637 static int
3639 {
3645 }
3650 }
3652 /* ARGSUSED */
3653 static void
3655 {
3659 }
3662 /* ARGSUSED */
3663 static int
3665 {
3676 /*
3677 * Because we stuff the readdir cookie into the offset field
3678 * someone may attempt to do an lseek with the cookie which
3679 * we want to succeed.
3680 */
3684 /* Like NFS3, just check for 63-bit overflow. */
3689 }
3691 /* mmap support ******************************************************** */
3693 #ifdef DEBUG
3695 #endif
3697 /*
3698 * Return all the pages from [off..off+len) in file
3699 * Like nfs3_getpage
3700 */
3701 /* ARGSUSED */
3702 static int
3706 {
3726 /*
3727 * Now valididate that the caches are up to date.
3728 */
3733 retry:
3736 /*
3737 * Don't create dirty pages faster than they
3738 * can be cleaned ... (etc. see nfs)
3739 *
3740 * Here NFS also tests:
3741 * (mi->mi_max_threads != 0 &&
3742 * rp->r_awcount > 2 * mi->mi_max_threads)
3743 */
3747 }
3749 /*
3750 * If we are getting called as a side effect of a write
3751 * operation the local file size might not be extended yet.
3752 * In this case we want to be able to return pages of zeroes.
3753 */
3757 }
3769 /*
3770 * Here NFS has: PURGE_STALE_FH(error, vp, cr);
3771 * In-line here as we only use it once.
3772 */
3784 }
3787 }
3789 /*
3790 * Called from pvn_getpages to get a particular page.
3791 * Like nfs3_getapage
3792 */
3793 /* ARGSUSED */
3794 static int
3798 {
3802 uint_t bsize;
3805 uoff_t lbn;
3806 uoff_t io_off;
3807 uoff_t blkoff;
3809 uint_t blksize;
3811 /* int readahead; */
3813 /* int ra_window; * readahead window */
3827 reread:
3839 /*
3840 * NFS queues up readahead work here.
3841 */
3843 again:
3848 /*
3849 * Block for this page is not allocated, or the offset
3850 * is beyond the current allocation size, or we're
3851 * allocating a swap slot and the page was not found,
3852 * so allocate it and return a zero page.
3853 */
3862 /*
3863 * Need to go to server to get a BLOCK, exception to
3864 * that being while reading at offset = 0 or doing
3865 * random i/o, in that case read only a PAGE.
3866 */
3870 /*
3871 * If only a block or less is left in
3872 * the file, read all that is remaining.
3873 */
3875 /*
3876 * Trying to access beyond EOF,
3877 * set up to get at least one page.
3878 */
3893 /*
3894 * Some other thread has entered the page,
3895 * so just use it.
3896 */
3900 /*
3901 * Now round the request size up to page boundaries.
3902 * This ensures that the entire page will be
3903 * initialized to zeroes if EOF is encountered.
3904 */
3910 /*
3911 * pageio_setup should have set b_addr to 0. This
3912 * is correct since we want to do I/O on a page
3913 * boundary. bp_mapin will use this addr to calculate
3914 * an offset, and then set b_addr to the kernel virtual
3915 * address it allocated for us.
3916 */
3926 /*
3927 * If doing a write beyond what we believe is EOF,
3928 * don't bother trying to read the pages from the
3929 * server, we'll just zero the pages here. We
3930 * don't check that the rw flag is S_WRITE here
3931 * because some implementations may attempt a
3932 * read access to the buffer before copying data.
3933 */
3941 }
3943 /*
3944 * Unmap the buffer before freeing it.
3945 */
3949 /* Here NFS3 updates all pp->p_fsdata */
3952 /*
3953 * If doing a write system call just return
3954 * zeroed pages, else user tried to get pages
3955 * beyond EOF, return error. We don't check
3956 * that the rw flag is S_WRITE here because
3957 * some implementations may attempt a read
3958 * access to the buffer before copying data.
3959 */
3962 else
3964 }
3970 }
3971 }
3972 }
3981 }
3986 /*
3987 * Page exists in the cache, acquire the appropriate lock.
3988 * If this fails, start all over again.
3989 */
3991 #ifdef DEBUG
3992 smbfs_lostpage++;
3993 #endif
3995 }
3999 }
4005 }
4007 /*
4008 * Here NFS has: nfs3_readahead
4009 * No read-ahead in smbfs yet.
4010 */
4012 /*
4013 * Flags are composed of {B_INVAL, B_FREE, B_DONTNEED, B_FORCE}
4014 * If len == 0, do from off to EOF.
4015 *
4016 * The normal cases should be len == 0 && off == 0 (entire vp list),
4017 * len == MAXBSIZE (from segmap_release actions), and len == PAGESIZE
4018 * (from pageout).
4019 *
4020 * Like nfs3_putpage + nfs_putpages
4021 */
4022 /* ARGSUSED */
4023 static int
4026 {
4030 uoff_t eoff;
4031 uoff_t io_off;
4049 /* Here NFS does rp->r_count (++/--) stuff. */
4051 /* Beginning of code from nfs_putpages. */
4056 /*
4057 * If ROUTOFSPACE is set, then all writes turn into B_INVAL
4058 * writes. B_FORCE is set to force the VM system to actually
4059 * invalidate the pages, even if the i/o failed. The pages
4060 * need to get invalidated because they can't be written out
4061 * because there isn't any space left on either the server's
4062 * file system or in the user's disk quota. The B_FREE bit
4063 * is cleared to avoid confusion as to whether this is a
4064 * request to place the page on the freelist or to destroy
4065 * it.
4066 */
4072 /*
4073 * If doing a full file synchronous operation, then clear
4074 * the RDIRTY bit. If a page gets dirtied while the flush
4075 * is happening, then RDIRTY will get set again. The
4076 * RDIRTY bit must get cleared before the flush so that
4077 * we don't lose this information.
4078 *
4079 * NFS has B_ASYNC vs sync stuff here.
4080 */
4090 /*
4091 * Search the entire vp list for pages >= off, and flush
4092 * the dirty pages.
4093 */
4097 /*
4098 * If an error occurred and the file was marked as dirty
4099 * before and we aren't forcibly invalidating pages, then
4100 * reset the RDIRTY flag.
4101 */
4107 }
4109 /*
4110 * Do a range from [off...off + len) looking for pages
4111 * to deal with.
4112 */
4122 }
4124 /*
4125 * If we are not invalidating, synchronously
4126 * freeing or writing pages use the routine
4127 * page_lookup_nowait() to prevent reclaiming
4128 * them from the free list.
4129 */
4137 }
4146 /*
4147 * "io_off" and "io_len" are returned as
4148 * the range of pages we actually wrote.
4149 * This allows us to skip ahead more quickly
4150 * since several pages may've been dealt
4151 * with by this iteration of the loop.
4152 */
4153 }
4154 }
4155 }
4158 }
4160 /*
4161 * Write out a single page, possibly klustering adjacent dirty pages.
4162 *
4163 * Like nfs3_putapage / nfs3_sync_putapage
4164 */
4165 static int
4168 {
4170 uoff_t io_off;
4171 uoff_t lbn_off;
4172 uoff_t lbn;
4174 uint_t bsize;
4185 /*
4186 * Find a kluster that fits in one block, or in
4187 * one page if pages are bigger than blocks. If
4188 * there is less file space allocated than a whole
4189 * page, we'll shorten the i/o request below.
4190 */
4194 /*
4195 * pvn_write_kluster shouldn't have returned a page with offset
4196 * behind the original page we were given. Verify that.
4197 */
4200 /*
4201 * Now pp will have the list of kept dirty pages marked for
4202 * write back. It will also handle invalidation and freeing
4203 * of pages that are not dirty. Check for page length rounding
4204 * problems.
4205 */
4209 }
4210 /*
4211 * The RMODINPROGRESS flag makes sure that smbfs_bio() sees a
4212 * consistent value of r_size. RMODINPROGRESS is set in writerp().
4213 * When RMODINPROGRESS is set it indicates that a uiomove() is in
4214 * progress and the r_size has not been made consistent with the
4215 * new size of the file. When the uiomove() completes the r_size is
4216 * updated and the RMODINPROGRESS flag is cleared.
4217 *
4218 * The RMODINPROGRESS flag makes sure that smbfs_bio() sees a
4219 * consistent value of r_size. Without this handshaking, it is
4220 * possible that smbfs_bio() picks up the old value of r_size
4221 * before the uiomove() in writerp() completes. This will result
4222 * in the write through smbfs_bio() being dropped.
4223 *
4224 * More precisely, there is a window between the time the uiomove()
4225 * completes and the time the r_size is updated. If a VOP_PUTPAGE()
4226 * operation intervenes in this window, the page will be picked up,
4227 * because it is dirty (it will be unlocked, unless it was
4228 * pagecreate'd). When the page is picked up as dirty, the dirty
4229 * bit is reset (pvn_getdirty()). In smbfs_write(), r_size is
4230 * checked. This will still be the old size. Therefore the page will
4231 * not be written out. When segmap_release() calls VOP_PUTPAGE(),
4232 * the page will be found to be clean and the write will be dropped.
4233 */
4240 /*
4241 * A write is in progress for this region of the file.
4242 * If we did not detect RMODINPROGRESS here then this
4243 * path through smbfs_putapage() would eventually go to
4244 * smbfs_bio() and may not write out all of the data
4245 * in the pages. We end up losing data. So we decide
4246 * to set the modified bit on each page in the page
4247 * list and mark the rnode with RDIRTY. This write
4248 * will be restarted at some later time.
4249 */
4257 }
4265 }
4267 }
4269 /*
4270 * NFS handles (flags & B_ASYNC) here...
4271 * (See nfs_async_putapage())
4272 *
4273 * This code section from: nfs3_sync_putapage()
4274 */
4287 }
4290 /*
4291 * If this was not an async thread, then try again to
4292 * write out the pages, but this time, also destroy
4293 * them whether or not the write is successful. This
4294 * will prevent memory from filling up with these
4295 * pages and destroying them is the only alternative
4296 * if they can't be written out.
4297 *
4298 * Don't do this if this is an async thread because
4299 * when the pages are unlocked in pvn_write_done,
4300 * some other thread could have come along, locked
4301 * them, and queued for an async thread. It would be
4302 * possible for all of the async threads to be tied
4303 * up waiting to lock the pages again and they would
4304 * all already be locked and waiting for an async
4305 * thread to handle them. Deadlock.
4306 */
4310 }
4318 }
4320 }
4322 /* Now more code from: nfs3_putapage */
4330 }
4332 /*
4333 * NFS has this in nfs_client.c (shared by v2,v3,...)
4334 * We have it here so smbfs_putapage can be file scope.
4335 */
4336 void
4338 {
4352 }
4353 /* Here NFSv3 has np->r_truncaddr = off; */
4363 }
4365 /* Like nfs3_map */
4367 /* ARGSUSED */
4368 static int
4372 {
4373 segvn_crargs_t vn_a;
4397 /*
4398 * NFS does close-to-open consistency stuff here.
4399 * Just get (possibly cached) attributes.
4400 */
4405 /*
4406 * Check to see if the vnode is currently marked as not cachable.
4407 * This means portions of the file are locked (through VOP_FRLOCK).
4408 * In this case the map request must be refused. We use
4409 * rp->r_lkserlock to avoid a race with concurrent lock requests.
4410 */
4411 /*
4412 * Atomically increment r_inmap after acquiring r_rwlock. The
4413 * idea here is to acquire r_rwlock to block read/write and
4414 * not to protect r_inmap. r_inmap will inform smbfs_read/write()
4415 * that we are in smbfs_map(). Now, r_rwlock is acquired in order
4416 * and we can prevent the deadlock that would have occurred
4417 * when smbfs_addmap() would have acquired it out of order.
4418 *
4419 * Since we are not protecting r_inmap by any lock, we do not
4420 * hold any lock when we decrement it. We atomically decrement
4421 * r_inmap after we release r_lkserlock. Note that rwlock is
4422 * re-entered as writer in smbfs_addmap (called via as_map).
4423 */
4433 }
4438 }
4440 /*
4441 * Don't allow concurrent locks and mapping if mandatory locking is
4442 * enabled.
4443 */
4448 }
4455 }
4471 done:
4475 }
4477 /*
4478 * This uses addmap/delmap functions to hold the SMB FID open as long as
4479 * there are pages mapped in this as/seg. Increment the FID refs. when
4480 * the maping count goes from zero to non-zero, and release the FID ref
4481 * when the maping count goes from non-zero to zero.
4482 */
4484 /* ARGSUSED */
4485 static int
4489 {
4493 /*
4494 * When r_mapcnt goes from zero to non-zero,
4495 * increment n_fidrefs
4496 */
4507 }
4510 }
4512 /*
4513 * Args passed to smbfs_delmap_async
4514 */
4516 taskq_ent_t dm_tqent;
4519 offset_t dm_off;
4520 caddr_t dm_addr;
4522 uint_t dm_prot;
4523 uint_t dm_maxprot;
4524 uint_t dm_flags;
4525 boolean_t dm_rele_fid;
4528 /*
4529 * Using delmap not only to release the SMB FID (as described above)
4530 * but to flush dirty pages as needed. Both of those do the actual
4531 * work in an async taskq job to avoid interfering with locks held
4532 * in the VM layer when this is called.
4533 */
4535 /* ARGSUSED */
4536 static int
4540 {
4547 /*
4548 * The VM layer may segvn_free the seg holding this vnode
4549 * before our callback has a chance run, so take a hold on
4550 * the vnode here and release it in the callback.
4551 * (same for the cred)
4552 */
4566 /*
4567 * Go ahead and decrement r_mapcount now, which is
4568 * the primary purpose of this function.
4569 *
4570 * When r_mapcnt goes to zero, we need to call
4571 * smbfs_rele_fid, but can't do that here, so
4572 * set a flag telling the async task to do it.
4573 */
4585 }
4587 /*
4588 * Remove some pages from an mmap'd vnode. Flush any
4589 * dirty pages in the unmapped range.
4590 */
4591 /* ARGSUSED */
4592 static void
4594 {
4606 /* Decremented r_mapcnt in smbfs_delmap */
4608 /*
4609 * Initiate a page flush and potential commit if there are
4610 * pages, the file system was not mounted readonly, the segment
4611 * was mapped shared, and the pages themselves were writeable.
4612 *
4613 * mark RDIRTY here, will be used to check if a file is dirty when
4614 * unmount smbfs
4615 */
4623 /*
4624 * Need to finish the putpage before we
4625 * close the OtW FID needed for I/O.
4626 */
4629 }
4635 /*
4636 * If r_mapcnt went to zero, drop our FID ref now.
4637 * On the last fidref, this does an OtW close.
4638 */
4649 }
4651 /* Release holds taken in smbfs_delmap */
4656 }
4658 /* No smbfs_pageio() or smbfs_dispose() ops. */
4660 /* misc. ******************************************************** */
4663 /*
4664 * XXX
4665 * This op may need to support PSARC 2007/440, nbmand changes for CIFS Service.
4666 */
4667 static int
4671 {
4677 else
4679 }
4681 /*
4682 * Free storage space associated with the specified vnode. The portion
4683 * to be freed is specified by bfp->l_start and bfp->l_len (already
4684 * normalized to a "whence" of 0).
4685 *
4686 * Called by fcntl(fd, F_FREESP, lkp) for libc:ftruncate, etc.
4687 */
4688 /* ARGSUSED */
4689 static int
4692 {
4704 /* Caller (fcntl) has checked v_type */
4709 /*
4710 * Like NFS3, no 32-bit offset checks here.
4711 * Our SMB layer takes care to return EFBIG
4712 * when it has to fallback to a 32-bit call.
4713 */
4721 /*
4722 * ftruncate should not change the ctime and
4723 * mtime if we truncate the file to its
4724 * previous size.
4725 */
4733 /* SMBFS_VNEVENT... */
4736 }
4739 }
4742 /* ARGSUSED */
4743 static int
4745 {
4748 }
4751 /* ARGSUSED */
4752 static int
4755 {
4774 else
4779 /* We only ever report one link to an object */
4784 /*
4785 * Always indicate that ACLs are enabled and
4786 * that we support ACE_T format, otherwise
4787 * libsec will ask for ACLENT_T format data
4788 * which we don't support.
4789 */
4801 }
4810 /*
4811 * Windows times are tenths of microseconds
4812 * (multiples of 100 nanoseconds).
4813 */
4819 }
4821 }
4823 /* ARGSUSED */
4824 static int
4827 {
4831 uint_t mask;
4842 /*
4843 * Our _pathconf indicates _ACL_ACE_ENABLED,
4844 * so we should only see VSA_ACE, etc here.
4845 * Note: vn_create asks for VSA_DFACLCNT,
4846 * and it expects ENOSYS and empty data.
4847 */
4855 else
4862 }
4864 /* ARGSUSED */
4865 static int
4868 {
4872 uint_t mask;
4883 /*
4884 * Our _pathconf indicates _ACL_ACE_ENABLED,
4885 * so we should only see VSA_ACE, etc here.
4886 */
4894 /*
4895 * Allow only the mount owner to do this.
4896 * See comments at smbfs_access_rwx.
4897 */
4904 else
4908 }
4911 /*
4912 * XXX
4913 * This op should eventually support PSARC 2007/268.
4914 */
4915 static int
4918 {
4924 else
4926 }
4929 /*
4930 * Most unimplemented ops will return ENOSYS because of fs_nosys().
4931 * The only ops where that won't work are ACCESS (due to open(2)
4932 * failures) and ... (anything else left?)
4933 */
4972 #ifdef SMBFS_VNEVENT
4974 #endif
4975 };