| blob | 604b37048ebe67e8a5f67f7fe513dddb8d113b6f |
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 */
2620 }
2621 #ifdef SMBFS_VNEVENT
2622 /* Existing file was truncated */
2624 #endif
2625 /* invalidate pages done in smbfssetattr() */
2626 }
2627 /* Success! */
2630 }
2632 /*
2633 * The file did not exist. Need VWRITE in the directory.
2634 */
2639 /*
2640 * Now things get tricky. We also need to check the
2641 * requested open mode against the file we may create.
2642 * See comments at smbfs_access_rwx
2643 */
2648 /*
2649 * Now the code derived from Darwin,
2650 * but with greater use of NT_CREATE
2651 * disposition options. Much changed.
2652 *
2653 * Create (or open) a new child node.
2654 * Note we handled "." and ".." above.
2655 */
2660 /* Truncate regular files if requested. */
2665 else
2667 }
2675 /*
2676 * Should use the fid to get/set the size
2677 * while we have it opened here. See above.
2678 */
2685 /*
2686 * In the open case, the name may differ a little
2687 * from what we passed to create (case, etc.)
2688 * so call lookup to get the (opened) name.
2689 *
2690 * XXX: Could avoid this extra lookup if the
2691 * "createact" result from NT_CREATE says we
2692 * created the object.
2693 */
2698 /* update attr and directory cache */
2705 /* Success! */
2709 out:
2715 }
2717 /*
2718 * XXX
2719 * This op should support the new FIGNORECASE flag for case-insensitive
2720 * lookups, per PSARC 2007/244.
2721 */
2722 /* ARGSUSED */
2723 static int
2726 {
2739 /*
2740 * Verify access to the dirctory.
2741 */
2750 /* Lookup the file to remove. */
2753 /*
2754 * Do the real remove work
2755 */
2758 }
2764 }
2766 /*
2767 * smbfsremove does the real work of removing in SMBFS
2768 * Caller has done dir access checks etc.
2769 *
2770 * The normal way to delete a file over SMB is open it (with DELETE access),
2771 * set the "delete-on-close" flag, and close the file. The problem for Unix
2772 * applications is that they expect the file name to be gone once the unlink
2773 * completes, and the SMB server does not actually delete the file until ALL
2774 * opens of that file are closed. We can't assume our open handles are the
2775 * only open handles on a file we're deleting, so to be safe we'll try to
2776 * rename the file to a temporary name and then set delete-on-close. If we
2777 * fail to set delete-on-close (i.e. because other opens prevent it) then
2778 * undo the changes we made and give up with EBUSY. Note that we might have
2779 * permission to delete a file but lack permission to rename, so we want to
2780 * continue in cases where rename fails. As an optimization, only do the
2781 * rename when we have the file open.
2782 *
2783 * This is similar to what NFS does when deleting a file that has local opens,
2784 * but thanks to SMB delete-on-close, we don't need to keep track of when the
2785 * last local open goes away and send a delete. The server does that for us.
2786 */
2787 /* ARGSUSED */
2788 static int
2791 {
2801 /*
2802 * The dvp RWlock must be held as writer.
2803 */
2806 /* Never allow link/unlink directories on SMB. */
2810 /*
2811 * We need to flush any dirty pages which happen to
2812 * be hanging around before removing the file. This
2813 * shouldn't happen very often and mostly on file
2814 * systems mounted "nocto".
2815 */
2825 }
2826 }
2828 /* Shared lock for n_fid use in smbfs_smb_setdisp etc. */
2832 /*
2833 * Get a file handle with delete access.
2834 * Close this FID before return.
2835 */
2842 }
2845 /*
2846 * If we have the file open, try to rename it to a temporary name.
2847 * If we can't rename, continue on and try setting DoC anyway.
2848 */
2856 /* Keep going without the rename. */
2859 }
2860 }
2862 /*
2863 * Mark the file as delete-on-close. If we can't,
2864 * undo what we did and err out.
2865 */
2870 /*
2871 * Failed to set DoC. If we renamed, undo that.
2872 * Need np->n_rpath relative to parent (dnp).
2873 * Use parent path name length plus one for
2874 * the separator ('/' or ':')
2875 */
2887 }
2890 }
2891 /* Done! */
2894 #ifdef SMBFS_VNEVENT
2896 #endif
2898 out:
2907 /* Keep lookup from finding this node anymore. */
2909 }
2912 }
2915 /* ARGSUSED */
2916 static int
2919 {
2920 /* Not yet... */
2922 }
2925 /*
2926 * XXX
2927 * This op should support the new FIGNORECASE flag for case-insensitive
2928 * lookups, per PSARC 2007/244.
2929 */
2930 /* ARGSUSED */
2931 static int
2934 {
2955 /*
2956 * Check that everything is on the same filesystem.
2957 * vn_rename checks the fsid's, but in case we don't
2958 * fill those in correctly, check here too.
2959 */
2963 /*
2964 * Need write access on source and target.
2965 * Server takes care of most checks.
2966 */
2974 }
2976 /*
2977 * Need to lock both old/new dirs as writer.
2978 *
2979 * Avoid deadlock here on old vs new directory nodes
2980 * by always taking the locks in order of address.
2981 * The order is arbitrary, but must be consistent.
2982 */
2991 }
3000 }
3001 }
3004 /* Lookup the "old" name */
3007 /*
3008 * Do the real rename work
3009 */
3012 }
3019 }
3021 /*
3022 * smbfsrename does the real work of renaming in SMBFS
3023 * Caller has done dir access checks etc.
3024 */
3025 /* ARGSUSED */
3026 static int
3029 {
3037 /* Things our caller should have checked. */
3043 /*
3044 * Lookup the target file. If it exists, it needs to be
3045 * checked to see whether it is a mount point and whether
3046 * it is active (open).
3047 */
3050 /*
3051 * Target (nvp) already exists. Check that it
3052 * has the same type as the source. The server
3053 * will check this also, (and more reliably) but
3054 * this lets us return the correct error codes.
3055 */
3060 }
3065 }
3066 }
3068 /*
3069 * POSIX dictates that when the source and target
3070 * entries refer to the same file object, rename
3071 * must do nothing and exit without error.
3072 */
3076 }
3078 /*
3079 * Also must ensure the target is not a mount point,
3080 * and keep mount/umount away until we're done.
3081 */
3085 }
3090 }
3092 /*
3093 * CIFS may give a SHARING_VIOLATION error when
3094 * trying to rename onto an exising object,
3095 * so try to remove the target first.
3096 * (Only for files, not directories.)
3097 */
3101 }
3106 /*
3107 * OK, removed the target file. Continue as if
3108 * lookup target had failed (nvp == NULL).
3109 */
3119 /*
3120 * If the old name should no longer exist,
3121 * discard any cached attributes under it.
3122 */
3125 /* SMBFS_VNEVENT... */
3126 }
3128 out:
3133 }
3136 }
3138 /*
3139 * XXX
3140 * vsecattr_t is new to build 77, and we need to eventually support
3141 * it in order to create an ACL when an object is created.
3142 *
3143 * This op should support the new FIGNORECASE flag for case-insensitive
3144 * lookups, per PSARC 2007/244.
3145 */
3146 /* ARGSUSED */
3147 static int
3150 {
3170 /* Only plain files are allowed in V_XATTRDIR. */
3178 /*
3179 * Require write access in the containing directory.
3180 */
3203 /* Success! */
3206 out:
3214 }
3216 /*
3217 * XXX
3218 * This op should support the new FIGNORECASE flag for case-insensitive
3219 * lookups, per PSARC 2007/244.
3220 */
3221 /* ARGSUSED */
3222 static int
3225 {
3244 /*
3245 * Require w/x access in the containing directory.
3246 * Server handles all other access checks.
3247 */
3252 /*
3253 * First lookup the entry to be removed.
3254 */
3260 /*
3261 * Disallow rmdir of "." or current dir, or the FS root.
3262 * Also make sure it's a directory, not a mount point,
3263 * and lock to keep mount/umount away until we're done.
3264 */
3268 }
3272 }
3276 }
3281 }
3286 /*
3287 * Similar to smbfs_remove
3288 */
3295 }
3306 out:
3311 }
3316 }
3319 /* ARGSUSED */
3320 static int
3323 {
3324 /* Not yet... */
3326 }
3329 /* ARGSUSED */
3330 static int
3333 {
3346 /*
3347 * Require read access in the directory.
3348 */
3355 /*
3356 * Todo readdir cache here
3357 *
3358 * I am serializing the entire readdir opreation
3359 * now since we have not yet implemented readdir
3360 * cache. This fix needs to be revisited once
3361 * we implement readdir cache.
3362 */
3371 }
3373 /* ARGSUSED */
3374 static int
3377 {
3378 /*
3379 * Note: "limit" tells the SMB-level FindFirst/FindNext
3380 * functions how many directory entries to request in
3381 * each OtW call. It needs to be large enough so that
3382 * we don't make lots of tiny OtW requests, but there's
3383 * no point making it larger than the maximum number of
3384 * OtW entries that would fit in a maximum sized trans2
3385 * response (64k / 48). Beyond that, it's just tuning.
3386 * WinNT used 512, Win2k used 1366. We use 1000.
3387 */
3389 /* Largest possible dirent size. */
3396 ssize_t save_resid;
3400 ushort_t reclen;
3404 /* Make sure we serialize for n_dirseq use. */
3407 /*
3408 * Make sure smbfs_open filled in n_dirseq
3409 */
3413 /* Check for overflow of (32-bit) directory offset. */
3418 /* Require space for at least one dirent. */
3433 /*
3434 * Generate the "." and ".." entries here so we can
3435 * (1) make sure they appear (but only once), and
3436 * (2) deal with getting their I numbers which the
3437 * findnext below does only for normal names.
3438 */
3440 /*
3441 * Tricky bit filling in the first two:
3442 * offset 0 is ".", offset 1 is ".."
3443 * so strlen of these is offset+1.
3444 */
3453 /*
3454 * Want the real I-numbers for the "." and ".."
3455 * entries. For these two names, we know that
3456 * smbfslookup can get the nodes efficiently.
3457 */
3464 }
3465 /*
3466 * Note: d_off is the offset that a user-level program
3467 * should seek to for reading the NEXT directory entry.
3468 * See libc: readdir, telldir, seekdir
3469 */
3474 /*
3475 * Note: uiomove updates uio->uio_offset,
3476 * but we want it to be our "cookie" value,
3477 * which just counts dirents ignoring size.
3478 */
3480 }
3482 /*
3483 * If there was a backward seek, we have to reopen.
3484 */
3494 }
3495 /* free the old one */
3497 /* save the new one */
3502 }
3504 /*
3505 * Skip entries before the requested offset.
3506 */
3512 }
3514 /*
3515 * While there's room in the caller's buffer:
3516 * get a directory entry from SMB,
3517 * convert to a dirent, copyout.
3518 * We stop when there is no longer room for a
3519 * maximum sized dirent because we must decide
3520 * before we know anything about the next entry.
3521 */
3528 /* Sanity check the name length. */
3533 }
3535 /* See comment at smbfs_fastlookup above. */
3539 }
3551 /* See comment re. uio_offset above. */
3553 }
3555 out:
3556 /*
3557 * When we come to the end of a directory, the
3558 * SMB-level functions return ENOENT, but the
3559 * caller is not expecting an error return.
3560 *
3561 * Also note that we must delay the call to
3562 * smbfs_smb_findclose(np->n_dirseq, ...)
3563 * until smbfs_close so that all reads at the
3564 * end of the directory will return no data.
3565 */
3570 }
3571 /*
3572 * If we encountered an error (i.e. "access denied")
3573 * from the FindFirst call, we will have copied out
3574 * the "." and ".." entries leaving offset == 2.
3575 * In that case, restore the original offset/resid
3576 * so the caller gets no data with the error.
3577 */
3581 }
3588 }
3590 /*
3591 * Here NFS has: nfs3_bio
3592 * See smbfs_bio above.
3593 */
3595 /* ARGSUSED */
3596 static int
3598 {
3600 }
3603 /*
3604 * The pair of functions fop_rwlock, fop_rwunlock
3605 * are optional functions that are called by:
3606 * getdents, before/after fop_readdir
3607 * pread, before/after ... fop_read
3608 * pwrite, before/after ... fop_write
3609 * (other places)
3610 *
3611 * Careful here: None of the above check for any
3612 * error returns from fop_rwlock / fop_rwunlock!
3613 * In fact, the return value from _rwlock is NOT
3614 * an error code, but V_WRITELOCK_TRUE / _FALSE.
3615 *
3616 * Therefore, it's up to _this_ code to make sure
3617 * the lock state remains balanced, which means
3618 * we can't "bail out" on interrupts, etc.
3619 */
3621 /* ARGSUSED2 */
3622 static int
3624 {
3630 }
3635 }
3637 /* ARGSUSED */
3638 static void
3640 {
3644 }
3647 /* ARGSUSED */
3648 static int
3650 {
3661 /*
3662 * Because we stuff the readdir cookie into the offset field
3663 * someone may attempt to do an lseek with the cookie which
3664 * we want to succeed.
3665 */
3669 /* Like NFS3, just check for 63-bit overflow. */
3674 }
3676 /* mmap support ******************************************************** */
3678 #ifdef DEBUG
3680 #endif
3682 /*
3683 * Return all the pages from [off..off+len) in file
3684 * Like nfs3_getpage
3685 */
3686 /* ARGSUSED */
3687 static int
3691 {
3711 /*
3712 * Now valididate that the caches are up to date.
3713 */
3718 retry:
3721 /*
3722 * Don't create dirty pages faster than they
3723 * can be cleaned ... (etc. see nfs)
3724 *
3725 * Here NFS also tests:
3726 * (mi->mi_max_threads != 0 &&
3727 * rp->r_awcount > 2 * mi->mi_max_threads)
3728 */
3732 }
3734 /*
3735 * If we are getting called as a side effect of a write
3736 * operation the local file size might not be extended yet.
3737 * In this case we want to be able to return pages of zeroes.
3738 */
3742 }
3754 /*
3755 * Here NFS has: PURGE_STALE_FH(error, vp, cr);
3756 * In-line here as we only use it once.
3757 */
3769 }
3772 }
3774 /*
3775 * Called from pvn_getpages to get a particular page.
3776 * Like nfs3_getapage
3777 */
3778 /* ARGSUSED */
3779 static int
3783 {
3787 uint_t bsize;
3790 uoff_t lbn;
3791 uoff_t io_off;
3792 uoff_t blkoff;
3794 uint_t blksize;
3796 /* int readahead; */
3798 /* int ra_window; * readahead window */
3812 reread:
3824 /*
3825 * NFS queues up readahead work here.
3826 */
3828 again:
3833 /*
3834 * Block for this page is not allocated, or the offset
3835 * is beyond the current allocation size, or we're
3836 * allocating a swap slot and the page was not found,
3837 * so allocate it and return a zero page.
3838 */
3847 /*
3848 * Need to go to server to get a BLOCK, exception to
3849 * that being while reading at offset = 0 or doing
3850 * random i/o, in that case read only a PAGE.
3851 */
3855 /*
3856 * If only a block or less is left in
3857 * the file, read all that is remaining.
3858 */
3860 /*
3861 * Trying to access beyond EOF,
3862 * set up to get at least one page.
3863 */
3878 /*
3879 * Some other thread has entered the page,
3880 * so just use it.
3881 */
3885 /*
3886 * Now round the request size up to page boundaries.
3887 * This ensures that the entire page will be
3888 * initialized to zeroes if EOF is encountered.
3889 */
3895 /*
3896 * pageio_setup should have set b_addr to 0. This
3897 * is correct since we want to do I/O on a page
3898 * boundary. bp_mapin will use this addr to calculate
3899 * an offset, and then set b_addr to the kernel virtual
3900 * address it allocated for us.
3901 */
3911 /*
3912 * If doing a write beyond what we believe is EOF,
3913 * don't bother trying to read the pages from the
3914 * server, we'll just zero the pages here. We
3915 * don't check that the rw flag is S_WRITE here
3916 * because some implementations may attempt a
3917 * read access to the buffer before copying data.
3918 */
3926 }
3928 /*
3929 * Unmap the buffer before freeing it.
3930 */
3934 /* Here NFS3 updates all pp->p_fsdata */
3937 /*
3938 * If doing a write system call just return
3939 * zeroed pages, else user tried to get pages
3940 * beyond EOF, return error. We don't check
3941 * that the rw flag is S_WRITE here because
3942 * some implementations may attempt a read
3943 * access to the buffer before copying data.
3944 */
3947 else
3949 }
3955 }
3956 }
3957 }
3966 }
3971 /*
3972 * Page exists in the cache, acquire the appropriate lock.
3973 * If this fails, start all over again.
3974 */
3976 #ifdef DEBUG
3977 smbfs_lostpage++;
3978 #endif
3980 }
3984 }
3990 }
3992 /*
3993 * Here NFS has: nfs3_readahead
3994 * No read-ahead in smbfs yet.
3995 */
3997 /*
3998 * Flags are composed of {B_INVAL, B_FREE, B_DONTNEED, B_FORCE}
3999 * If len == 0, do from off to EOF.
4000 *
4001 * The normal cases should be len == 0 && off == 0 (entire vp list),
4002 * len == MAXBSIZE (from segmap_release actions), and len == PAGESIZE
4003 * (from pageout).
4004 *
4005 * Like nfs3_putpage + nfs_putpages
4006 */
4007 /* ARGSUSED */
4008 static int
4011 {
4015 uoff_t eoff;
4016 uoff_t io_off;
4034 /* Here NFS does rp->r_count (++/--) stuff. */
4036 /* Beginning of code from nfs_putpages. */
4041 /*
4042 * If ROUTOFSPACE is set, then all writes turn into B_INVAL
4043 * writes. B_FORCE is set to force the VM system to actually
4044 * invalidate the pages, even if the i/o failed. The pages
4045 * need to get invalidated because they can't be written out
4046 * because there isn't any space left on either the server's
4047 * file system or in the user's disk quota. The B_FREE bit
4048 * is cleared to avoid confusion as to whether this is a
4049 * request to place the page on the freelist or to destroy
4050 * it.
4051 */
4057 /*
4058 * If doing a full file synchronous operation, then clear
4059 * the RDIRTY bit. If a page gets dirtied while the flush
4060 * is happening, then RDIRTY will get set again. The
4061 * RDIRTY bit must get cleared before the flush so that
4062 * we don't lose this information.
4063 *
4064 * NFS has B_ASYNC vs sync stuff here.
4065 */
4075 /*
4076 * Search the entire vp list for pages >= off, and flush
4077 * the dirty pages.
4078 */
4082 /*
4083 * If an error occurred and the file was marked as dirty
4084 * before and we aren't forcibly invalidating pages, then
4085 * reset the RDIRTY flag.
4086 */
4092 }
4094 /*
4095 * Do a range from [off...off + len) looking for pages
4096 * to deal with.
4097 */
4107 }
4109 /*
4110 * If we are not invalidating, synchronously
4111 * freeing or writing pages use the routine
4112 * page_lookup_nowait() to prevent reclaiming
4113 * them from the free list.
4114 */
4122 }
4131 /*
4132 * "io_off" and "io_len" are returned as
4133 * the range of pages we actually wrote.
4134 * This allows us to skip ahead more quickly
4135 * since several pages may've been dealt
4136 * with by this iteration of the loop.
4137 */
4138 }
4139 }
4140 }
4143 }
4145 /*
4146 * Write out a single page, possibly klustering adjacent dirty pages.
4147 *
4148 * Like nfs3_putapage / nfs3_sync_putapage
4149 */
4150 static int
4153 {
4155 uoff_t io_off;
4156 uoff_t lbn_off;
4157 uoff_t lbn;
4159 uint_t bsize;
4170 /*
4171 * Find a kluster that fits in one block, or in
4172 * one page if pages are bigger than blocks. If
4173 * there is less file space allocated than a whole
4174 * page, we'll shorten the i/o request below.
4175 */
4179 /*
4180 * pvn_write_kluster shouldn't have returned a page with offset
4181 * behind the original page we were given. Verify that.
4182 */
4185 /*
4186 * Now pp will have the list of kept dirty pages marked for
4187 * write back. It will also handle invalidation and freeing
4188 * of pages that are not dirty. Check for page length rounding
4189 * problems.
4190 */
4194 }
4195 /*
4196 * The RMODINPROGRESS flag makes sure that smbfs_bio() sees a
4197 * consistent value of r_size. RMODINPROGRESS is set in writerp().
4198 * When RMODINPROGRESS is set it indicates that a uiomove() is in
4199 * progress and the r_size has not been made consistent with the
4200 * new size of the file. When the uiomove() completes the r_size is
4201 * updated and the RMODINPROGRESS flag is cleared.
4202 *
4203 * The RMODINPROGRESS flag makes sure that smbfs_bio() sees a
4204 * consistent value of r_size. Without this handshaking, it is
4205 * possible that smbfs_bio() picks up the old value of r_size
4206 * before the uiomove() in writerp() completes. This will result
4207 * in the write through smbfs_bio() being dropped.
4208 *
4209 * More precisely, there is a window between the time the uiomove()
4210 * completes and the time the r_size is updated. If a VOP_PUTPAGE()
4211 * operation intervenes in this window, the page will be picked up,
4212 * because it is dirty (it will be unlocked, unless it was
4213 * pagecreate'd). When the page is picked up as dirty, the dirty
4214 * bit is reset (pvn_getdirty()). In smbfs_write(), r_size is
4215 * checked. This will still be the old size. Therefore the page will
4216 * not be written out. When segmap_release() calls VOP_PUTPAGE(),
4217 * the page will be found to be clean and the write will be dropped.
4218 */
4225 /*
4226 * A write is in progress for this region of the file.
4227 * If we did not detect RMODINPROGRESS here then this
4228 * path through smbfs_putapage() would eventually go to
4229 * smbfs_bio() and may not write out all of the data
4230 * in the pages. We end up losing data. So we decide
4231 * to set the modified bit on each page in the page
4232 * list and mark the rnode with RDIRTY. This write
4233 * will be restarted at some later time.
4234 */
4242 }
4250 }
4252 }
4254 /*
4255 * NFS handles (flags & B_ASYNC) here...
4256 * (See nfs_async_putapage())
4257 *
4258 * This code section from: nfs3_sync_putapage()
4259 */
4272 }
4275 /*
4276 * If this was not an async thread, then try again to
4277 * write out the pages, but this time, also destroy
4278 * them whether or not the write is successful. This
4279 * will prevent memory from filling up with these
4280 * pages and destroying them is the only alternative
4281 * if they can't be written out.
4282 *
4283 * Don't do this if this is an async thread because
4284 * when the pages are unlocked in pvn_write_done,
4285 * some other thread could have come along, locked
4286 * them, and queued for an async thread. It would be
4287 * possible for all of the async threads to be tied
4288 * up waiting to lock the pages again and they would
4289 * all already be locked and waiting for an async
4290 * thread to handle them. Deadlock.
4291 */
4295 }
4303 }
4305 }
4307 /* Now more code from: nfs3_putapage */
4315 }
4317 /*
4318 * NFS has this in nfs_client.c (shared by v2,v3,...)
4319 * We have it here so smbfs_putapage can be file scope.
4320 */
4321 void
4323 {
4337 }
4338 /* Here NFSv3 has np->r_truncaddr = off; */
4348 }
4350 /* Like nfs3_map */
4352 /* ARGSUSED */
4353 static int
4357 {
4358 segvn_crargs_t vn_a;
4382 /*
4383 * NFS does close-to-open consistency stuff here.
4384 * Just get (possibly cached) attributes.
4385 */
4390 /*
4391 * Check to see if the vnode is currently marked as not cachable.
4392 * This means portions of the file are locked (through VOP_FRLOCK).
4393 * In this case the map request must be refused. We use
4394 * rp->r_lkserlock to avoid a race with concurrent lock requests.
4395 */
4396 /*
4397 * Atomically increment r_inmap after acquiring r_rwlock. The
4398 * idea here is to acquire r_rwlock to block read/write and
4399 * not to protect r_inmap. r_inmap will inform smbfs_read/write()
4400 * that we are in smbfs_map(). Now, r_rwlock is acquired in order
4401 * and we can prevent the deadlock that would have occurred
4402 * when smbfs_addmap() would have acquired it out of order.
4403 *
4404 * Since we are not protecting r_inmap by any lock, we do not
4405 * hold any lock when we decrement it. We atomically decrement
4406 * r_inmap after we release r_lkserlock. Note that rwlock is
4407 * re-entered as writer in smbfs_addmap (called via as_map).
4408 */
4418 }
4423 }
4425 /*
4426 * Don't allow concurrent locks and mapping if mandatory locking is
4427 * enabled.
4428 */
4433 }
4440 }
4456 done:
4460 }
4462 /*
4463 * This uses addmap/delmap functions to hold the SMB FID open as long as
4464 * there are pages mapped in this as/seg. Increment the FID refs. when
4465 * the maping count goes from zero to non-zero, and release the FID ref
4466 * when the maping count goes from non-zero to zero.
4467 */
4469 /* ARGSUSED */
4470 static int
4474 {
4478 /*
4479 * When r_mapcnt goes from zero to non-zero,
4480 * increment n_fidrefs
4481 */
4492 }
4495 }
4497 /*
4498 * Args passed to smbfs_delmap_async
4499 */
4501 taskq_ent_t dm_tqent;
4504 offset_t dm_off;
4505 caddr_t dm_addr;
4507 uint_t dm_prot;
4508 uint_t dm_maxprot;
4509 uint_t dm_flags;
4510 boolean_t dm_rele_fid;
4513 /*
4514 * Using delmap not only to release the SMB FID (as described above)
4515 * but to flush dirty pages as needed. Both of those do the actual
4516 * work in an async taskq job to avoid interfering with locks held
4517 * in the VM layer when this is called.
4518 */
4520 /* ARGSUSED */
4521 static int
4525 {
4532 /*
4533 * The VM layer may segvn_free the seg holding this vnode
4534 * before our callback has a chance run, so take a hold on
4535 * the vnode here and release it in the callback.
4536 * (same for the cred)
4537 */
4551 /*
4552 * Go ahead and decrement r_mapcount now, which is
4553 * the primary purpose of this function.
4554 *
4555 * When r_mapcnt goes to zero, we need to call
4556 * smbfs_rele_fid, but can't do that here, so
4557 * set a flag telling the async task to do it.
4558 */
4570 }
4572 /*
4573 * Remove some pages from an mmap'd vnode. Flush any
4574 * dirty pages in the unmapped range.
4575 */
4576 /* ARGSUSED */
4577 static void
4579 {
4591 /* Decremented r_mapcnt in smbfs_delmap */
4593 /*
4594 * Initiate a page flush and potential commit if there are
4595 * pages, the file system was not mounted readonly, the segment
4596 * was mapped shared, and the pages themselves were writeable.
4597 *
4598 * mark RDIRTY here, will be used to check if a file is dirty when
4599 * unmount smbfs
4600 */
4608 /*
4609 * Need to finish the putpage before we
4610 * close the OtW FID needed for I/O.
4611 */
4614 }
4620 /*
4621 * If r_mapcnt went to zero, drop our FID ref now.
4622 * On the last fidref, this does an OtW close.
4623 */
4634 }
4636 /* Release holds taken in smbfs_delmap */
4641 }
4643 /* No smbfs_pageio() or smbfs_dispose() ops. */
4645 /* misc. ******************************************************** */
4648 /*
4649 * XXX
4650 * This op may need to support PSARC 2007/440, nbmand changes for CIFS Service.
4651 */
4652 static int
4656 {
4662 else
4664 }
4666 /*
4667 * Free storage space associated with the specified vnode. The portion
4668 * to be freed is specified by bfp->l_start and bfp->l_len (already
4669 * normalized to a "whence" of 0).
4670 *
4671 * Called by fcntl(fd, F_FREESP, lkp) for libc:ftruncate, etc.
4672 */
4673 /* ARGSUSED */
4674 static int
4677 {
4689 /* Caller (fcntl) has checked v_type */
4694 /*
4695 * Like NFS3, no 32-bit offset checks here.
4696 * Our SMB layer takes care to return EFBIG
4697 * when it has to fallback to a 32-bit call.
4698 */
4706 /*
4707 * ftruncate should not change the ctime and
4708 * mtime if we truncate the file to its
4709 * previous size.
4710 */
4718 /* SMBFS_VNEVENT... */
4721 }
4724 }
4727 /* ARGSUSED */
4728 static int
4730 {
4733 }
4736 /* ARGSUSED */
4737 static int
4740 {
4759 else
4764 /* We only ever report one link to an object */
4769 /*
4770 * Always indicate that ACLs are enabled and
4771 * that we support ACE_T format, otherwise
4772 * libsec will ask for ACLENT_T format data
4773 * which we don't support.
4774 */
4786 }
4795 /*
4796 * Windows times are tenths of microseconds
4797 * (multiples of 100 nanoseconds).
4798 */
4804 }
4806 }
4808 /* ARGSUSED */
4809 static int
4812 {
4816 uint_t mask;
4827 /*
4828 * Our _pathconf indicates _ACL_ACE_ENABLED,
4829 * so we should only see VSA_ACE, etc here.
4830 * Note: vn_create asks for VSA_DFACLCNT,
4831 * and it expects ENOSYS and empty data.
4832 */
4840 else
4847 }
4849 /* ARGSUSED */
4850 static int
4853 {
4857 uint_t mask;
4868 /*
4869 * Our _pathconf indicates _ACL_ACE_ENABLED,
4870 * so we should only see VSA_ACE, etc here.
4871 */
4879 /*
4880 * Allow only the mount owner to do this.
4881 * See comments at smbfs_access_rwx.
4882 */
4889 else
4893 }
4896 /*
4897 * XXX
4898 * This op should eventually support PSARC 2007/268.
4899 */
4900 static int
4903 {
4909 else
4911 }
4914 /*
4915 * Most unimplemented ops will return ENOSYS because of fs_nosys().
4916 * The only ops where that won't work are ACCESS (due to open(2)
4917 * failures) and ... (anything else left?)
4918 */
4957 #ifdef SMBFS_VNEVENT
4959 #endif
4960 };