| blob | 1e66844aadada4c8a1c78cb59643c2d0f793f814 |
1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
22 /*
23 * Copyright (c) 1984, 2010, Oracle and/or its affiliates. All rights reserved.
24 * Copyright 2015, Joyent, Inc.
25 * Copyright (c) 2016 by Delphix. All rights reserved.
26 */
28 /* Copyright (c) 1983, 1984, 1985, 1986, 1987, 1988, 1989 AT&T */
29 /* All Rights Reserved */
31 /*
32 * Portions of this source code were derived from Berkeley 4.3 BSD
33 * under license from the Regents of the University of California.
34 */
36 #include <sys/types.h>
37 #include <sys/t_lock.h>
38 #include <sys/ksynch.h>
39 #include <sys/param.h>
40 #include <sys/time.h>
41 #include <sys/systm.h>
42 #include <sys/sysmacros.h>
43 #include <sys/resource.h>
44 #include <sys/signal.h>
45 #include <sys/cred.h>
46 #include <sys/user.h>
47 #include <sys/buf.h>
48 #include <sys/vfs.h>
49 #include <sys/vnode.h>
50 #include <sys/proc.h>
51 #include <sys/disp.h>
52 #include <sys/file.h>
53 #include <sys/fcntl.h>
54 #include <sys/flock.h>
55 #include <sys/atomic.h>
56 #include <sys/kmem.h>
57 #include <sys/uio.h>
58 #include <sys/dnlc.h>
59 #include <sys/conf.h>
60 #include <sys/mman.h>
61 #include <sys/pathname.h>
62 #include <sys/debug.h>
63 #include <sys/vmsystm.h>
64 #include <sys/cmn_err.h>
65 #include <sys/filio.h>
66 #include <sys/policy.h>
68 #include <sys/fs/ufs_fs.h>
69 #include <sys/fs/ufs_lockfs.h>
70 #include <sys/fs/ufs_filio.h>
71 #include <sys/fs/ufs_inode.h>
72 #include <sys/fs/ufs_fsdir.h>
73 #include <sys/fs/ufs_quota.h>
74 #include <sys/fs/ufs_log.h>
75 #include <sys/fs/ufs_snap.h>
76 #include <sys/fs/ufs_trans.h>
77 #include <sys/fs/ufs_panic.h>
78 #include <sys/fs/ufs_bio.h>
80 #include <sys/errno.h>
81 #include <sys/fssnap_if.h>
82 #include <sys/unistd.h>
83 #include <sys/sunddi.h>
87 #include <vm/hat.h>
88 #include <vm/page.h>
89 #include <vm/pvn.h>
90 #include <vm/as.h>
91 #include <vm/seg.h>
92 #include <vm/seg_map.h>
93 #include <vm/seg_vn.h>
94 #include <vm/seg_kmem.h>
95 #include <vm/rm.h>
96 #include <sys/swap.h>
98 #include <sys/fs_subr.h>
100 #include <sys/fs/decomp.h>
109 caller_context_t *);
117 caller_context_t *);
119 caller_context_t *);
121 caller_context_t *);
143 caller_context_t *);
152 caller_context_t *);
159 caller_context_t *);
168 caller_context_t *);
170 caller_context_t *);
172 caller_context_t *);
179 caller_context_t *);
181 caller_context_t *);
187 /*
188 * For lockfs: ulockfs begin/end is now inlined in the ufs_xxx functions.
189 *
190 * XXX - ULOCKFS in fs_pathconf and ufs_ioctl is not inlined yet.
191 *
192 * NOTE: "not blkd" below means that the operation isn't blocked by lockfs
193 */
235 };
237 #define MAX_BACKFILE_COUNT 9999
239 /*
240 * Created by ufs_dumpctl() to store a file's disk block info into memory.
241 * Used by ufs_dump() to dump data to disk directly.
242 */
248 };
252 /*
253 * Previously there was no special action required for ordinary files.
254 * (Devices are handled through the device file system.)
255 * Now we support Large Files and Large File API requires open to
256 * fail if file is large.
257 * We could take care to prevent data corruption
258 * by doing an atomic check of size and truncate if file is opened with
259 * FTRUNC flag set but traditionally this is being done by the vfs/vnode
260 * layers. So taking care of truncation here is a change in the existing
261 * semantics of fop_open and therefore we chose not to implement any thing
262 * here. The check for the size of the file > 2GB is being done at the
263 * vfs layer in routine vn_open().
264 */
266 /* ARGSUSED */
267 static int
269 {
271 }
273 /*ARGSUSED*/
274 static int
277 {
281 /*
282 * Push partially filled cluster at last close.
283 * ``last close'' is approximated because the dnlc
284 * may have a hold on the vnode.
285 * Checking for VBAD here will also act as a forced umount check.
286 */
294 }
295 }
298 }
300 /*ARGSUSED*/
301 static int
304 {
313 /*
314 * Mandatory locking needs to be done before ufs_lockfs_begin()
315 * and TRANS_BEGIN_SYNC() calls since mandatory locks can sleep.
316 */
318 /*
319 * ufs_getattr ends up being called by chklock
320 */
325 }
332 /*
333 * In the case that a directory is opened for reading as a file
334 * (eg "cat .") with the O_RSYNC, O_SYNC and O_DSYNC flags set.
335 * The locking order had to be changed to avoid a deadlock with
336 * an update taking place on that directory at the same time.
337 */
348 }
357 TOP_READ_SIZE);
359 }
361 /*
362 * Only transact reads to files opened for sync-read and
363 * sync-write on a file system that is not write locked.
364 *
365 * The ``not write locked'' check prevents problems with
366 * enabling/disabling logging on a busy file system. E.g.,
367 * logging exists at the beginning of the read but does not
368 * at the end.
369 *
370 */
377 }
385 TOP_READ_SIZE);
386 }
387 }
391 }
392 out:
395 }
403 static int
405 {
408 /*
409 * If the FDSYNC flag is set then ignore the global
410 * ufs_allow_shared_writes in this case.
411 */
414 /*
415 * Filter to determine if this request is suitable as a
416 * concurrent rewrite. This write must not allocate blocks
417 * by extending the file or filling in holes. No use trying
418 * through FSYNC descriptors as the inode will be synchronously
419 * updated after the write. The uio structure has not yet been
420 * checked for sanity, so assume nothing.
421 */
427 shared_write);
428 }
430 /*ARGSUSED*/
431 static int
434 {
447 retry_mandlock:
448 /*
449 * Mandatory locking needs to be done before ufs_lockfs_begin()
450 * and TRANS_BEGIN_[A]SYNC() calls since mandatory locks can sleep.
451 * Check for forced unmounts normally done in ufs_lockfs_begin().
452 */
456 }
461 /*
462 * ufs_getattr ends up being called by chklock
463 */
468 }
470 /* i_rwlock can change in chklock */
474 /*
475 * Check for fast-path special case of directio re-writes.
476 */
488 uint_t i_flag_save;
492 /*
493 * Special treatment of access times for re-writes.
494 * If IMOD is not already set, then convert it
495 * to IMODACC for this operation. This defers
496 * entering a delta into the log until the inode
497 * is flushed. This mimics what is done for read
498 * operations and inode access time.
499 */
508 }
514 }
518 }
523 /*
524 * Mandatory locking could have been enabled
525 * after dropping the i_rwlock.
526 */
529 }
535 /*
536 * Amount of log space needed for this write
537 */
541 /*
542 * Throttle writes.
543 */
547 ufs_throttles++;
549 }
551 }
553 /*
554 * Enter Transaction
555 *
556 * If the write is a rewrite there is no need to open a transaction
557 * if the FDSYNC flag is set and not the FSYNC. In this case just
558 * set the IMODACC flag to modify do the update at a later time
559 * thus avoiding the overhead of the logging transaction that is
560 * not required.
561 */
565 uint_t i_flag_save;
576 }
584 }
585 }
589 }
591 /*
592 * Write the file
593 */
597 /*
598 * In append mode start at end of file.
599 */
601 }
603 /*
604 * Mild optimisation, don't call ufs_trans_write() unless we have to
605 * Also, suppress file system full messages if we will retry.
606 */
613 }
619 /*
620 * Leave Transaction
621 */
631 }
634 }
636 }
637 out:
639 /*
640 * Any blocks tied up in pending deletes?
641 */
645 }
651 }
653 /*
654 * Don't cache write blocks to files with the sticky bit set.
655 * Used to keep swap files from blowing the page cache on a server.
656 */
659 /*
660 * Free behind hacks. The pager is busted.
661 * XXX - need to pass the information down to writedone() in a flag like B_SEQ
662 * or B_FREE_IF_TIGHT_ON_MEMORY.
663 */
668 /*
669 * While we should, in most cases, cache the pages for write, we
670 * may also want to cache the pages for read as long as they are
671 * frequently re-usable.
672 *
673 * If cache_read_ahead = 1, the pages for read will go to the tail
674 * of the cache list when they are released, otherwise go to the head.
675 */
678 /*
679 * Freebehind exists so that as we read large files sequentially we
680 * don't consume most of memory with pages from a few files. It takes
681 * longer to re-read from disk multiple small files as it does reading
682 * one large one sequentially. As system memory grows customers need
683 * to retain bigger chunks of files in memory. The advent of the
684 * cachelist opens up of the possibility freeing pages to the head or
685 * tail of the list.
686 *
687 * Not freeing a page is a bet that the page will be read again before
688 * it's segmap slot is needed for something else. If we loose the bet,
689 * it means some other thread is burdened with the page free we did
690 * not do. If we win we save a free and reclaim.
691 *
692 * Freeing it at the tail vs the head of cachelist is a bet that the
693 * page will survive until the next read. It's also saying that this
694 * page is more likely to be re-used than a page freed some time ago
695 * and never reclaimed.
696 *
697 * Freebehind maintains a range of file offset [smallfile1; smallfile2]
698 *
699 * 0 < offset < smallfile1 : pages are not freed.
700 * smallfile1 < offset < smallfile2 : pages freed to tail of cachelist.
701 * smallfile2 < offset : pages freed to head of cachelist.
702 *
703 * The range is computed at most once per second and depends on
704 * freemem and ncpus_online. Both parameters are bounded to be
705 * >= smallfile && >= smallfile64.
706 *
707 * smallfile1 = (free memory / ncpu) / 1000
708 * smallfile2 = (free memory / ncpu) / 10
709 *
710 * A few examples values:
711 *
712 * Free Mem (in Bytes) [smallfile1; smallfile2] [smallfile1; smallfile2]
713 * ncpus_online = 4 ncpus_online = 64
714 * ------------------ ----------------------- -----------------------
715 * 1G [256K; 25M] [32K; 1.5M]
716 * 10G [2.5M; 250M] [156K; 15M]
717 * 100G [25M; 2.5G] [1.5M; 150M]
718 *
719 */
721 #define SMALLFILE1_D 1000
722 #define SMALLFILE2_D 10
729 /*
730 * wrip does the real work of write requests for ufs.
731 */
732 int
734 {
736 uoff_t off;
737 uoff_t old_i_size;
741 caddr_t base;
744 uint_t flags;
753 /*
754 * ip->i_size is incremented before the uiomove
755 * is done on a write. If the move fails (bad user
756 * address) reset ip->i_size.
757 * The better way would be to increment ip->i_size
758 * only if the uiomove succeeds.
759 */
761 o_mode_t type;
766 /*
767 * check for forced unmount - should not happen as
768 * the request passed the lockfs checks.
769 */
777 /* check for valid filetype */
782 }
784 /*
785 * the actual limit of UFS file size
786 * is UFS_MAXOFFSET_T
787 */
799 }
801 /*
802 * if largefiles are disallowed, the limit is
803 * the pre-largefiles value of 2GB
804 */
807 else
812 }
815 }
825 }
826 /*
827 * Try to go direct
828 */
833 /*
834 * If ufs_directio wrote to the file or set the flags,
835 * we need to update i_seq, but it may be deferred.
836 */
841 }
844 }
846 /*
847 * Behavior with respect to dropping/reacquiring vfs_dqrwlock:
848 *
849 * o shadow inodes: vfs_dqrwlock is not held at all
850 * o quota updates: vfs_dqrwlock is read or write held
851 * o other updates: vfs_dqrwlock is read held
852 *
853 * The first case is the only one where we do not hold
854 * vfs_dqrwlock at all while entering wrip().
855 * We must make sure not to downgrade/drop vfs_dqrwlock if we
856 * have it as writer, i.e. if we are updating the quota inode.
857 * There is no potential deadlock scenario in this case as
858 * ufs_getpage() takes care of this and avoids reacquiring
859 * vfs_dqrwlock in that case.
860 *
861 * This check is done here since the above conditions do not change
862 * and we possibly loop below, so save a few cycles.
863 */
869 }
871 /*
872 * Large Files: We cast MAXBMASK to offset_t
873 * inorder to mask out the higher bits. Since offset_t
874 * is a signed value, the high order bit set in MAXBMASK
875 * value makes it do the right thing by having all bits 1
876 * in the higher word. May be removed for _SOLARIS64_.
877 */
892 }
893 /*
894 * since uoff + n >= limit,
895 * therefore n >= limit - uoff, and n is an int
896 * so it is safe to cast it to an int
897 */
899 }
901 /*
902 * We are extending the length of the file.
903 * bmap is used so that we are sure that
904 * if we need to allocate new blocks, that it
905 * is done here before we up the file size.
906 */
909 /*
910 * bmap_write never drops i_contents so if
911 * the flags are set it changed the file.
912 */
916 }
919 /*
920 * There is a window of vulnerability here.
921 * The sequence of operations: allocate file
922 * system blocks, uiomove the data into pages,
923 * and then update the size of the file in the
924 * inode, must happen atomically. However, due
925 * to current locking constraints, this can not
926 * be done.
927 */
931 /*
932 * If we are writing from the beginning of
933 * the mapping, we can just create the
934 * pages without having to read them.
935 */
938 /*
939 * Going to do a whole mappings worth,
940 * so we can just create the pages w/o
941 * having to read them in. But before
942 * we do that, we need to make sure any
943 * needed blocks are allocated first.
944 */
948 /*
949 * bmap_write never drops i_contents so if
950 * the flags are set it changed the file.
951 */
955 }
959 /*
960 * check if the new created page needed the
961 * allocation of new disk blocks.
962 */
967 /*
968 * In sync mode flush the indirect blocks which
969 * may have been allocated and not written on
970 * disk. In above cases bmap_write will allocate
971 * in sync mode.
972 */
977 }
978 }
980 /*
981 * At this point we can enter ufs_getpage() in one
982 * of two ways:
983 * 1) segmap_getmapflt() calls ufs_getpage() when the
984 * forcefault parameter is true (pagecreate == 0)
985 * 2) uiomove() causes a page fault.
986 *
987 * We have to drop the contents lock to prevent the VM
988 * system from trying to reacquire it in ufs_getpage()
989 * should the uiomove cause a pagefault.
990 *
991 * We have to drop the reader vfs_dqrwlock here as well.
992 */
998 }
1003 /*
1004 * Touch the page and fault it in if it is not in core
1005 * before segmap_getmapflt or vpm_data_copy can lock it.
1006 * This is to avoid the deadlock if the buffer is mapped
1007 * to the same file through mmap which we want to write.
1008 */
1012 /*
1013 * Copy data. If new pages are created, part of
1014 * the page that is not written will be initizliazed
1015 * with zeros.
1016 */
1024 /*
1025 * segmap_pagecreate() returns 1 if it calls
1026 * page_create_va() to allocate any pages.
1027 */
1034 }
1036 /*
1037 * If "newpage" is set, then a new page was created and it
1038 * does not contain valid data, so it needs to be initialized
1039 * at this point.
1040 * Otherwise the page contains old data, which was overwritten
1041 * partially or as a whole in uiomove.
1042 * If there is only one iovec structure within uio, then
1043 * on error uiomove will not be able to update uio->uio_loffset
1044 * and we would zero the whole page here!
1045 *
1046 * If uiomove fails because of an error, the old valid data
1047 * is kept instead of filling the rest of the page with zero's.
1048 */
1051 /*
1052 * We created pages w/o initializing them completely,
1053 * thus we need to zero the part that wasn't set up.
1054 * This happens on most EOF write cases and if
1055 * we had some sort of error during the uiomove.
1056 */
1064 }
1066 /*
1067 * Unlock the pages allocated by page_create_va()
1068 * in segmap_pagecreate()
1069 */
1073 /*
1074 * If the size of the file changed, then update the
1075 * size field in the inode now. This can't be done
1076 * before the call to segmap_pageunlock or there is
1077 * a potential deadlock with callers to ufs_putpage().
1078 * They will be holding i_contents and trying to lock
1079 * a page, while this thread is holding a page locked
1080 * and trying to acquire i_contents.
1081 */
1087 /*
1088 * file has grown larger than 2GB. Set flag
1089 * in superblock to indicate this, if it
1090 * is not already set.
1091 */
1099 }
1105 }
1108 /*
1109 * If we failed on a write, we may have already
1110 * allocated file blocks as well as pages. It's
1111 * hard to undo the block allocation, but we must
1112 * be sure to invalidate any pages that may have
1113 * been allocated.
1114 *
1115 * If the page was created without initialization
1116 * then we must check if it should be possible
1117 * to destroy the new page and to keep the old data
1118 * on the disk.
1119 *
1120 * It is possible to destroy the page without
1121 * having to write back its contents only when
1122 * - the size of the file keeps unchanged
1123 * - bmap_write() did not allocate new disk blocks
1124 * it is possible to create big files using "seek" and
1125 * write to the end of the file. A "write" to a
1126 * position before the end of the file would not
1127 * change the size of the file but it would allocate
1128 * new disk blocks.
1129 * - uiomove intended to overwrite the whole page.
1130 * - a new page was created (newpage == 1).
1131 */
1134 newpage) {
1136 /* unwind what uiomove eventually last did */
1139 /*
1140 * destroy the page, do not write ambiguous
1141 * data to the disk.
1142 */
1145 /*
1146 * write the page back to the disk, if dirty,
1147 * and remove the page from the cache.
1148 */
1150 }
1153 /*
1154 * Flush pages.
1155 */
1159 }
1162 /*
1163 * Force write back for synchronous write cases.
1164 */
1166 /*
1167 * If the sticky bit is set but the
1168 * execute bit is not set, we do a
1169 * synchronous write back and free
1170 * the page when done. We set up swap
1171 * files to be handled this way to
1172 * prevent servers from keeping around
1173 * the client's swap pages too long.
1174 * XXX - there ought to be a better way.
1175 */
1178 SM_DONTNEED;
1182 }
1184 /*
1185 * Have written a whole block.
1186 * Start an asynchronous write and
1187 * mark the buffer to indicate that
1188 * it won't be needed again soon.
1189 */
1191 }
1193 /*
1194 * Flush pages.
1195 */
1199 }
1200 /*
1201 * If the operation failed and is synchronous,
1202 * then we need to unwind what uiomove() last
1203 * did so we can potentially return an error to
1204 * the caller. If this write operation was
1205 * done in two pieces and the first succeeded,
1206 * then we won't return an error for the second
1207 * piece that failed. However, we only want to
1208 * return a resid value that reflects what was
1209 * really done.
1210 *
1211 * Failures for non-synchronous operations can
1212 * be ignored since the page subsystem will
1213 * retry the operation until it succeeds or the
1214 * file system is unmounted.
1215 */
1222 }
1223 }
1224 }
1226 /*
1227 * Re-acquire contents lock.
1228 * If it was dropped, reacquire reader vfs_dqrwlock as well.
1229 */
1234 /*
1235 * If the uiomove() failed or if a synchronous
1236 * page push failed, fix up i_size.
1237 */
1240 /*
1241 * The uiomove failed, and we
1242 * allocated blocks,so get rid
1243 * of them.
1244 */
1246 }
1248 /*
1249 * XXX - Can this be out of the loop?
1250 */
1252 /*
1253 * Only do one increase of i_seq for multiple
1254 * pieces. Because we drop locks, record
1255 * the fact that we changed the timestamp and
1256 * are deferring the increase in case another thread
1257 * pushes our timestamp update.
1258 */
1268 /*
1269 * Clear Set-UID & Set-GID bits on
1270 * successful write if not privileged
1271 * and at least one of the execute bits
1272 * is set. If we always clear Set-GID,
1273 * mandatory file and record locking is
1274 * unuseable.
1275 */
1277 }
1278 }
1279 /*
1280 * In the case the FDSYNC flag is set and this is a
1281 * "rewrite" we won't log a delta.
1282 * The FSYNC flag overrides all cases.
1283 */
1286 }
1289 out:
1290 /*
1291 * Make sure i_seq is increased at least once per write
1292 */
1296 }
1298 /*
1299 * Inode is updated according to this table -
1300 *
1301 * FSYNC FDSYNC(posix.4)
1302 * --------------------------
1303 * always@ IATTCHG|IBDWRITE
1304 *
1305 * @ - If we are doing synchronous write the only time we should
1306 * not be sync'ing the ip here is if we have the stickyhack
1307 * activated, the file is marked with the sticky bit and
1308 * no exec bit, the file length has not been changed and
1309 * no new blocks have been allocated during this write.
1310 */
1313 /*
1314 * we have eliminated nosync
1315 */
1319 }
1320 }
1322 /*
1323 * If we've already done a partial-write, terminate
1324 * the write but return no error unless the error is ENOSPC
1325 * because the caller can detect this and free resources and
1326 * try again.
1327 */
1334 }
1336 /*
1337 * rdip does the real work of read requests for ufs.
1338 */
1339 int
1341 {
1342 uoff_t off;
1343 caddr_t base;
1351 uint_t flags;
1353 krw_t rwtype;
1354 o_mode_t type;
1368 /* check for valid filetype */
1373 }
1378 }
1381 }
1384 }
1391 }
1392 /*
1393 * Try to go direct
1394 */
1399 }
1404 offset_t diff;
1417 }
1421 /*
1422 * We update smallfile2 and smallfile1 at most every second.
1423 */
1436 }
1441 /*
1442 * At this point we can enter ufs_getpage() in one of two
1443 * ways:
1444 * 1) segmap_getmapflt() calls ufs_getpage() when the
1445 * forcefault parameter is true (value of 1 is passed)
1446 * 2) uiomove() causes a page fault.
1447 *
1448 * We cannot hold onto an i_contents reader lock without
1449 * risking deadlock in ufs_getpage() so drop a reader lock.
1450 * The ufs_getpage() dolock logic already allows for a
1451 * thread holding i_contents as writer to work properly
1452 * so we keep a writer lock.
1453 */
1458 /*
1459 * Copy data.
1460 */
1467 }
1471 /*
1472 * If reading sequential we won't need this
1473 * buffer again soon. For offsets in range
1474 * [smallfile1, smallfile2] release the pages
1475 * at the tail of the cache list, larger
1476 * offsets are released at the head.
1477 */
1483 }
1484 /*
1485 * In POSIX SYNC (FSYNC and FDSYNC) read mode,
1486 * we want to make sure that the page which has
1487 * been read, is written on disk if it is dirty.
1488 * And corresponding indirect blocks should also
1489 * be flushed out.
1490 */
1494 }
1499 }
1505 }
1506 }
1511 out:
1512 /*
1513 * Inode is updated according to this table if FRSYNC is set.
1514 *
1515 * FSYNC FDSYNC(posix.4)
1516 * --------------------------
1517 * always IATTCHG|IBDWRITE
1518 */
1519 /*
1520 * The inode is not updated if we're logging and the inode is a
1521 * directory with FRSYNC, FSYNC and FDSYNC flags set.
1522 */
1526 }
1532 }
1533 }
1534 }
1535 /*
1536 * If we've already done a partial read, terminate
1537 * the read but return no error.
1538 */
1544 }
1546 /* ARGSUSED */
1547 static int
1556 {
1562 offset_t off;
1569 /*
1570 * forcibly unmounted
1571 */
1585 }
1593 }
1595 }
1599 /*
1600 * file system locking
1601 */
1609 }
1610 #ifdef _SYSCALL32_IMPL
1613 /* Translate ILP32 lockfs to LP64 lockfs */
1623 }
1629 comment =
1635 }
1638 }
1643 DATAMODEL_NATIVE) {
1646 }
1647 #ifdef _SYSCALL32_IMPL
1650 /* Translate LP64 to ILP32 lockfs */
1664 }
1670 }
1674 /*
1675 * get file system locking status
1676 */
1682 }
1683 #ifdef _SYSCALL32_IMPL
1686 /* Translate ILP32 lockfs to LP64 lockfs */
1696 }
1711 }
1712 #ifdef _SYSCALL32_IMPL
1714 /* Translate LP64 to ILP32 lockfs */
1725 }
1736 /*
1737 * set access time
1738 */
1740 /*
1741 * if mounted w/o atime, return quietly.
1742 * I briefly thought about returning ENOSYS, but
1743 * figured that most apps would consider this fatal
1744 * but the idea is to make this as seamless as poss.
1745 */
1750 ULOCKFS_SETATTR_MASK);
1758 }
1767 }
1771 /*
1772 * set delayed-io
1773 */
1777 /*
1778 * get delayed-io
1779 */
1783 /*
1784 * inode open
1785 */
1787 ULOCKFS_VGET_MASK);
1795 }
1799 /*
1800 * file system flush (push w/invalidate)
1801 */
1807 /*
1808 * Contract-private interface for Legato
1809 * Purge this vnode from the DNLC and decide
1810 * if this vnode is busy (*arg == 1) or not
1811 * (*arg == 0)
1812 */
1822 /*
1823 * Tune the file system (aka setting fs attributes)
1824 */
1826 ULOCKFS_SETATTR_MASK);
1850 {
1865 }
1867 /*
1868 * Do copyout even if there is an error because
1869 * the details of error is stored in fcp.
1870 */
1875 }
1878 {
1887 }
1899 /*
1900 * The following 3 ioctls are for TSufs support
1901 * although could potentially be used elsewhere
1902 */
1916 {
1922 /* Copy stucture if statistics are being kept */
1925 }
1931 }
1937 /* offset paramater is in/out */
1946 {
1947 /*
1948 * This is a project private ufs ioctl() to mark
1949 * the inode as that belonging to a compressed
1950 * file. This is used to mark individual
1951 * compressed files in a miniroot archive.
1952 * The files compressed in this manner are
1953 * automatically decompressed by the dcfs filesystem
1954 * (via an interception in ufs_lookup - see decompvp())
1955 * which is layered on top of ufs on a system running
1956 * from the archive. See uts/common/fs/dcfs for details.
1957 * This ioctl only marks the file as compressed - the
1958 * actual compression is done by fiocompress (a
1959 * userland utility) which invokes this ioctl().
1960 */
1964 ULOCKFS_SETATTR_MASK);
1971 }
1979 }
1983 }
1987 }
1988 }
1991 /* ARGSUSED */
1992 static int
1995 {
2001 /*
2002 * for performance, if only the size is requested don't bother
2003 * with anything else.
2004 */
2007 }
2009 /*
2010 * inlined lockfs checks
2011 */
2016 }
2019 /*
2020 * Return all the attributes. This should be refined so
2021 * that it only returns what's asked for.
2022 */
2024 /*
2025 * Copy from inode table.
2026 */
2029 /*
2030 * If there is an ACL and there is a mask entry, then do the
2031 * extra work that completes the equivalent of an acltomode(3)
2032 * call. According to POSIX P1003.1e, the acl mask should be
2033 * returned in the group permissions field.
2034 *
2035 * - start with the original permission and mode bits (from above)
2036 * - clear the group owner bits
2037 * - add in the mask bits.
2038 */
2043 }
2052 else
2078 }
2083 out:
2085 }
2087 /*
2088 * Special wrapper to provide a callback for secpolicy_vnode_setattr().
2089 * The i_contents lock is already held by the caller and we need to
2090 * declare the inode as 'void *' argument.
2091 */
2092 static int
2094 {
2098 }
2100 /*ARGSUSED4*/
2101 static int
2108 {
2125 timestruc_t now;
2126 vattr_t oldva;
2130 /*
2131 * Cannot set these attributes.
2132 */
2136 /*
2137 * check for forced unmount
2138 */
2146 again:
2157 /*
2158 * Acquire i_rwlock before TRANS_BEGIN_CSYNC() if this is a file.
2159 * This follows the protocol for read()/write().
2160 */
2162 /*
2163 * ufs_tryirwlock uses rw_tryenter and checks for SLOCK to
2164 * avoid i_rwlock, ufs_lockfs_begin deadlock. If deadlock
2165 * possible, retries the operation.
2166 */
2172 }
2174 }
2176 /*
2177 * Truncate file. Must have write permission and not be a directory.
2178 */
2184 }
2193 }
2197 }
2203 }
2205 /*
2206 * Acquire i_rwlock after TRANS_BEGIN_CSYNC() if this is a directory.
2207 * This follows the protocol established by
2208 * ufs_link/create/remove/rename/mkdir/rmdir/symlink.
2209 */
2214 trans_size);
2218 }
2220 /*
2221 * Grab quota lock if we are changing the file's owner.
2222 */
2226 }
2242 /*
2243 * Change file access modes.
2244 */
2253 else
2256 }
2257 }
2260 /*
2261 * Don't change ownership of the quota inode.
2262 */
2267 }
2269 /*
2270 * No real ownership change.
2271 */
2275 }
2276 /*
2277 * Remove the blocks and the file, from the old user's
2278 * quota.
2279 */
2290 }
2294 /*
2295 * There is a real ownership change.
2296 */
2298 /*
2299 * Add the blocks and the file to the new
2300 * user's quota.
2301 */
2308 }
2309 }
2312 }
2315 }
2316 /*
2317 * Change file access or modified times.
2318 */
2320 /* Check that the time value is within ufs range */
2325 }
2327 /*
2328 * if the "noaccess" mount option is set and only atime
2329 * update is requested, do nothing. No error is returned.
2330 */
2339 }
2345 /*
2346 * In 2038, ctime sticks forever..
2347 */
2353 }
2356 }
2359 }
2361 skip_atime:
2362 /*
2363 * The presence of a shadow inode may indicate an ACL, but does
2364 * not imply an ACL. Future FSD types should be handled here too
2365 * and check for the presence of the attribute-specific data
2366 * before referencing it.
2367 */
2369 /*
2370 * XXX if ufs_iupdat is changed to sandbagged write fix
2371 * ufs_acl_setattr to push ip to keep acls consistent
2372 *
2373 * Suppress out of inodes messages if we will retry.
2374 */
2379 }
2381 update_inode:
2382 /*
2383 * Setattr always increases the sequence number
2384 */
2387 /*
2388 * if nfsd and not logging; push synchronously
2389 */
2394 }
2399 }
2407 trans_size);
2410 }
2412 }
2413 out:
2414 /*
2415 * If out of inodes or blocks, see if we can free something
2416 * up from the delete queue.
2417 */
2426 }
2430 }
2434 }
2436 }
2438 /*ARGSUSED*/
2439 static int
2442 {
2448 /*
2449 * The ufs_iaccess function wants to be called with
2450 * mode bits expressed as "ufs specific" bits.
2451 * I.e., VWRITE|VREAD|VEXEC do not make sense to
2452 * ufs_iaccess() but IWRITE|IREAD|IEXEC do.
2453 * But since they're the same we just pass the vnode mode
2454 * bit but just verify that assumption at compile time.
2455 */
2456 #if IWRITE != VWRITE || IREAD != VREAD || IEXEC != VEXEC
2458 #endif
2460 }
2462 /* ARGSUSED */
2463 static int
2466 {
2476 }
2478 /*
2479 * If the symbolic link is empty there is nothing to read.
2480 * Fast-track these empty symbolic links
2481 */
2485 }
2491 /*
2492 * The ip->i_rwlock protects the data blocks used for FASTSYMLINK
2493 */
2494 again:
2506 }
2512 }
2515 }
2519 ino_t ino;
2539 }
2541 /* can this be a fast symlink and is it a user buffer? */
2547 /*
2548 * setup a kernel buffer to read link into. this
2549 * is to fix a race condition where the user buffer
2550 * got corrupted before copying it into the inode.
2551 */
2567 }
2574 }
2585 /*
2586 * free page
2587 */
2594 /* error, clear garbage left behind */
2599 }
2600 }
2602 /* now, copy it into the user buffer */
2606 }
2609 }
2610 out:
2613 }
2614 nolockout:
2616 }
2618 /* ARGSUSED */
2619 static int
2622 {
2633 /*
2634 * First push out any data pages
2635 */
2642 }
2644 /*
2645 * Delta any delayed inode times updates
2646 * and push inode to log.
2647 * All other inode deltas will have already been delta'd
2648 * and will be pushed during the commit.
2649 */
2654 TOP_SYNCIP_SIZE);
2655 }
2664 TOP_SYNCIP_SIZE);
2665 }
2666 }
2668 /*
2669 * Commit the Moby transaction
2670 *
2671 * Deltas have already been made so we just need to
2672 * commit them with a synchronous transaction.
2673 * TRANS_BEGIN_SYNC() will return an error
2674 * if there are no deltas to commit, for an
2675 * empty transaction.
2676 */
2683 }
2685 TOP_COMMIT_SIZE);
2686 }
2690 /* Just update the inode only */
2694 /* Do data-synchronous writes */
2696 else
2697 /* Do synchronous writes */
2704 }
2705 out:
2708 }
2710 }
2712 /*ARGSUSED*/
2713 static void
2715 {
2717 }
2719 /*
2720 * Unix file system operations having to do with directory manipulation.
2721 */
2723 /* ARGSUSED */
2724 static int
2728 {
2737 /*
2738 * Check flags for type of lookup (regular file or attribute file)
2739 */
2745 /*
2746 * If not mounted with XATTR support then return EINVAL
2747 */
2751 /*
2752 * We don't allow recursive attributes...
2753 * Maybe someday we will.
2754 */
2757 }
2764 }
2768 }
2770 /*
2771 * Check accessibility of directory.
2772 */
2777 }
2781 }
2785 }
2787 /*
2788 * Check for a null component, which we should treat as
2789 * looking at dvp from within it's parent, so we don't
2790 * need a call to ufs_iaccess(), as it has already been
2791 * done.
2792 */
2798 }
2800 /*
2801 * Check for "." ie itself. this is a quick check and
2802 * avoids adding "." into the dnlc (which have been seen
2803 * to occupy >10% of the cache).
2804 */
2806 /*
2807 * Don't return without checking accessibility
2808 * of the directory. We only need the lock if
2809 * we are going to return it.
2810 */
2814 }
2816 }
2818 /*
2819 * Fast path: Check the directory name lookup cache.
2820 */
2822 /*
2823 * Check accessibility of directory.
2824 */
2828 }
2833 }
2837 }
2839 /*
2840 * Keep the idle queue from getting too long by
2841 * idling two inodes before attempting to allocate another.
2842 * This operation must be performed before entering
2843 * lockfs or a transaction.
2844 */
2849 }
2851 retry_lookup:
2852 /*
2853 * Check accessibility of directory.
2854 */
2865 fastpath:
2870 /*
2871 * If vnode is a device return special vnode instead.
2872 */
2877 cr);
2881 else
2886 /*
2887 * Compressed file, substitute dcfs vnode
2888 */
2893 else
2895 }
2896 }
2899 }
2904 out:
2906 }
2908 /*ARGSUSED*/
2909 static int
2913 {
2929 again:
2941 }
2947 /*
2948 * Null component name refers to the directory itself.
2949 */
2951 /*
2952 * Even though this is an error case, we need to grab the
2953 * quota lock since the error handling code below is common.
2954 */
2961 /*
2962 * ufs_tryirwlock_trans uses rw_tryenter and checks for SLOCK
2963 * to avoid i_rwlock, ufs_lockfs_begin deadlock. If deadlock
2964 * possible, retries the operation.
2965 */
2969 trans_size);
2978 }
2986 }
2988 /*
2989 * Suppress file system full message if we will retry
2990 */
2997 trans_size);
2999 }
3001 }
3003 }
3008 }
3009 }
3011 /*
3012 * If the file already exists and this is a non-exclusive create,
3013 * check permissions and allow access for non-directories.
3014 * Read-only create of an existing directory is also allowed.
3015 * We fail an exclusive create of anything which already exists.
3016 */
3026 else
3028 }
3034 }
3035 /*
3036 * If the error EEXIST was set, then i_seq can not
3037 * have been updated. The sequence number interface
3038 * is defined such that a non-error fop_create must
3039 * increase the dir va_seq it by at least one. If we
3040 * have cleared the error, increase i_seq. Note that
3041 * we are increasing the dir i_seq and in rare cases
3042 * ip may actually be from the dvp, so we already have
3043 * the locks and it will not be subject to truncation.
3044 * In case we have to update i_seq of the parent
3045 * directory dip, we have to defer it till we have
3046 * released our locks on ip due to lock ordering requirements.
3047 */
3050 else
3055 /*
3056 * Truncate regular files, if requested by caller.
3057 * Grab i_rwlock to make sure no one else is
3058 * currently writing to the file (we promised
3059 * bmap we would do this).
3060 * Must get the locks in the correct order.
3061 */
3067 /*
3068 * Large Files: Why this check here?
3069 * Though we do it in vn_create() we really
3070 * want to guarantee that we do not destroy
3071 * Large file data by atomically checking
3072 * the size while holding the contents
3073 * lock.
3074 */
3082 }
3084 truncflag++;
3090 RW_WRITER,
3091 TOP_CREATE,
3092 ufsvfsp,
3094 issync,
3095 trans_size);
3099 }
3101 RW_READER);
3104 cr);
3106 }
3108 }
3111 }
3112 }
3113 }
3119 }
3121 }
3128 /*
3129 * If vnode is a device return special vnode instead.
3130 */
3139 }
3142 }
3143 unlock:
3145 /*
3146 * Do the deferred update of the parent directory's sequence
3147 * number now.
3148 */
3155 }
3161 trans_size);
3163 /*
3164 * If we haven't had a more interesting failure
3165 * already, then anything that might've happened
3166 * here should be reported.
3167 */
3170 }
3179 }
3182 }
3187 /*
3188 * If no inodes available, try to free one up out of the
3189 * pending delete queue.
3190 */
3195 }
3197 out:
3199 }
3202 /*ARGSUSED*/
3203 static int
3206 {
3216 /*
3217 * don't let the delete queue get too long
3218 */
3222 }
3228 /* Only send the event if there were no errors */
3232 }
3234 retry_remove:
3243 /*
3244 * ufs_tryirwlock_trans uses rw_tryenter and checks for SLOCK
3245 * to avoid i_rwlock, ufs_lockfs_begin deadlock. If deadlock
3246 * possible, retries the operation.
3247 */
3258 trans_size);
3260 }
3262 out:
3264 }
3266 /*
3267 * Link a file or a directory. Only privileged processes are allowed to
3268 * make links to directories.
3269 */
3270 /*ARGSUSED*/
3271 static int
3274 {
3286 retry_link:
3298 /*
3299 * Make sure link for extended attributes is valid
3300 * We only support hard linking of attr in ATTRDIR to ATTRDIR
3301 *
3302 * Make certain we don't attempt to look at a device node as
3303 * a ufs inode.
3304 */
3313 }
3321 }
3323 /*
3324 * ufs_tryirwlock_trans uses rw_tryenter and checks for SLOCK
3325 * to avoid i_rwlock, ufs_lockfs_begin deadlock. If deadlock
3326 * possible, retries the operation.
3327 */
3330 trans_size);
3336 unlock:
3340 }
3344 }
3345 out:
3347 }
3354 /*
3355 * Rename a file or directory.
3356 * We are given the vnode and entry string of the source and the
3357 * vnode and entry string of the place we want to move the source
3358 * to (the target). The essential operation is:
3359 * unlink(target);
3360 * link(source, target);
3361 * unlink(source);
3362 * but "atomically". Can't do full commit without saving state in
3363 * the inode on disk, which isn't feasible at this time. Best we
3364 * can do is always guarantee that the TARGET exists.
3365 */
3367 /*ARGSUSED*/
3368 static int
3377 {
3388 timestruc_t now;
3404 /* Must do this before taking locks in case of DNLC miss */
3412 /*
3413 * Notify the target directory of the rename event
3414 * if source and target directories are not the same.
3415 */
3421 }
3426 retry_rename:
3440 /*
3441 * We only allow renaming of attributes from ATTRDIR to ATTRDIR.
3442 */
3446 }
3448 /*
3449 * Check accessibility of directory.
3450 */
3454 /*
3455 * Look up inode of file we're supposed to rename.
3456 */
3464 }
3466 }
3469 }
3471 /*
3472 * Lock both the source and target directories (they may be
3473 * the same) to provide the atomicity semantics that was
3474 * previously provided by the per file system vfs_rename_lock
3475 *
3476 * with vfs_rename_lock removed to allow simultaneous renames
3477 * within a file system, ufs_dircheckpath can deadlock while
3478 * traversing back to ensure that source is not a parent directory
3479 * of target parent directory. This is because we get into
3480 * ufs_dircheckpath with the sdp and tdp locks held as RW_WRITER.
3481 * If the tdp and sdp of the simultaneous renames happen to be
3482 * in the path of each other, it can lead to a deadlock. This
3483 * can be avoided by getting the locks as RW_READER here and then
3484 * upgrading to RW_WRITER after completing the ufs_dircheckpath.
3485 *
3486 * We hold the target directory's i_rwlock after calling
3487 * ufs_lockfs_begin but in many other operations (like ufs_readdir)
3488 * fop_rwlock is explicitly called by the filesystem independent code
3489 * before calling the file system operation. In these cases the order
3490 * is reversed (i.e i_rwlock is taken first and then ufs_lockfs_begin
3491 * is called). This is fine as long as ufs_lockfs_begin acts as a VOP
3492 * counter but with ufs_quiesce setting the SLOCK bit this becomes a
3493 * synchronizing object which might lead to a deadlock. So we use
3494 * rw_tryenter instead of rw_enter. If we fail to get this lock and
3495 * find that SLOCK bit is set, we call ufs_lockfs_end and restart the
3496 * operation.
3497 */
3498 retry:
3501 retry_firstlock:
3503 /*
3504 * We didn't get the lock. Check if the SLOCK is set in the
3505 * ufsvfs. If yes, we might be in a deadlock. Safer to give up
3506 * and wait for SLOCK to be cleared.
3507 */
3511 trans_size);
3516 /*
3517 * SLOCK isn't set so this is a genuine synchronization
3518 * case. Let's try again after giving them a breather.
3519 */
3522 }
3523 }
3524 /*
3525 * Need to check if the tdp and sdp are same !!!
3526 */
3528 /*
3529 * We didn't get the lock. Check if the SLOCK is set in the
3530 * ufsvfs. If yes, we might be in a deadlock. Safer to give up
3531 * and wait for SLOCK to be cleared.
3532 */
3537 trans_size);
3542 /*
3543 * So we couldn't get the second level peer lock *and*
3544 * the SLOCK bit isn't set. Too bad we can be
3545 * contentding with someone wanting these locks otherway
3546 * round. Reverse the locks in case there is a heavy
3547 * contention for the second level lock.
3548 */
3552 ufs_rename_retry_cnt++;
3554 }
3555 }
3560 }
3561 /*
3562 * Make sure we can delete the source entry. This requires
3563 * write permission on the containing directory.
3564 * Check for sticky directories.
3565 */
3573 }
3575 /*
3576 * If this is a rename of a directory and the parent is
3577 * different (".." must be changed), then the source
3578 * directory must not be in the directory hierarchy
3579 * above the target, as this would orphan everything
3580 * below the source directory. Also the user must have
3581 * write permission in the source so as to be able to
3582 * change "..".
3583 */
3586 ino_t inum;
3592 }
3597 /*
3598 * If we got EAGAIN ufs_dircheckpath detected a
3599 * potential deadlock and backed out. We need
3600 * to retry the operation since sdp and tdp have
3601 * to be released to avoid the deadlock.
3602 */
3608 ufs_rename_dircheck_retry_cnt++;
3610 }
3612 }
3616 }
3619 /*
3620 * Check for renaming '.' or '..' or alias of '.'
3621 */
3625 }
3627 /*
3628 * Simultaneous renames can deadlock in ufs_dircheckpath since it
3629 * tries to traverse back the file tree with both tdp and sdp held
3630 * as RW_WRITER. To avoid that we have to hold the tdp and sdp locks
3631 * as RW_READERS till ufs_dircheckpath is done.
3632 * Now that ufs_dircheckpath is done with, we can upgrade the locks
3633 * to RW_WRITER.
3634 */
3636 /*
3637 * The upgrade failed. We got to give away the lock
3638 * as to avoid deadlocking with someone else who is
3639 * waiting for writer lock. With the lock gone, we
3640 * cannot be sure the checks done above will hold
3641 * good when we eventually get them back as writer.
3642 * So if we can't upgrade we drop the locks and retry
3643 * everything again.
3644 */
3649 ufs_rename_upgrade_retry_cnt++;
3651 }
3654 /*
3655 * The upgrade failed. We got to give away the lock
3656 * as to avoid deadlocking with someone else who is
3657 * waiting for writer lock. With the lock gone, we
3658 * cannot be sure the checks done above will hold
3659 * good when we eventually get them back as writer.
3660 * So if we can't upgrade we drop the locks and retry
3661 * everything again.
3662 */
3666 ufs_rename_upgrade_retry_cnt++;
3668 }
3669 }
3671 /*
3672 * Now that all the locks are held check to make sure another thread
3673 * didn't slip in and take out the sip.
3674 */
3686 }
3691 /*
3692 * If the inode was found need to drop the v_count
3693 * so as not to keep the filesystem from being
3694 * unmounted at a later time.
3695 */
3697 }
3699 /*
3700 * Release the slot.fbp that has the page mapped and
3701 * locked SE_SHARED, and could be used in in
3702 * ufs_direnter_lr() which needs to get the SE_EXCL lock
3703 * on said page.
3704 */
3708 }
3709 }
3711 /*
3712 * Link source to the target.
3713 */
3715 /*
3716 * ESAME isn't really an error; it indicates that the
3717 * operation should not be done because the source and target
3718 * are the same file, but that no error should be reported.
3719 */
3723 }
3728 /*
3729 * Unlink the source.
3730 * Remove the source entry. ufs_dirremove() checks that the entry
3731 * still reflects sip, and returns an error if it doesn't.
3732 * If the entry has changed just forget about it. Release
3733 * the source inode.
3734 */
3741 /*
3742 * Notify the target directory of the rename event
3743 * if source and target directories are not the same.
3744 */
3747 }
3749 errout:
3756 }
3758 unlock:
3766 trans_size);
3768 }
3771 }
3773 /*ARGSUSED*/
3774 static int
3778 {
3791 /*
3792 * Can't make directory in attr hidden dir
3793 */
3797 again:
3807 /*
3808 * ufs_tryirwlock_trans uses rw_tryenter and checks for SLOCK
3809 * to avoid i_rwlock, ufs_lockfs_begin deadlock. If deadlock
3810 * possible, retries the operation.
3811 */
3814 trans_size);
3823 trans_size);
3825 }
3827 }
3842 }
3843 out:
3848 }
3851 }
3853 /*ARGSUSED*/
3854 static int
3857 {
3867 /*
3868 * don't let the delete queue get too long
3869 */
3873 }
3879 /* Only send the event if there were no errors */
3883 }
3885 retry_rmdir:
3894 /*
3895 * ufs_tryirwlock_trans uses rw_tryenter and checks for SLOCK
3896 * to avoid i_rwlock, ufs_lockfs_begin deadlock. If deadlock
3897 * possible, retries the operation.
3898 */
3901 trans_size);
3910 trans_size);
3912 }
3914 out:
3916 }
3918 /* ARGSUSED */
3919 static int
3927 {
3935 caddr_t outbuf;
3937 uint_t offset;
3950 }
3952 /*
3953 * Check if we have been called with a valid iov_len
3954 * and bail out if not, otherwise we may potentially loop
3955 * forever further down.
3956 */
3960 }
3962 /*
3963 * Large Files: When we come here we are guaranteed that
3964 * uio_offset can be used safely. The high word is zero.
3965 */
3975 /* Large Files: directory files should not be "large" */
3979 /* Force offset to be valid (to guard against bogus lseek() values) */
3982 /* Quit if at end of file or link count of zero (posix) */
3988 }
3990 /*
3991 * Get space to change directory entries into fs independent format.
3992 * Do fast alloc for the most commonly used-request size (filesystem
3993 * block size).
3994 */
4002 }
4004 nextblk:
4007 /* Truncate request to file size */
4011 /* Comply with MAXBSIZE boundary restrictions of fbread() */
4015 /*
4016 * Read in the next chunk.
4017 * We are still holding the i_rwlock.
4018 */
4026 }
4036 }
4037 /* Transform to file-system independent format */
4039 /*
4040 * If the current directory entry is mangled, then skip
4041 * to the next block. It would be nice to set the FSBAD
4042 * flag in the super-block so that a fsck is forced on
4043 * next reboot, but locking is a problem.
4044 */
4048 }
4050 /* Skip to requested offset and skip empty entries */
4052 ushort_t this_reclen =
4054 /* Buffer too small for any entries */
4059 }
4060 /* If would overrun the buffer, quit */
4063 }
4064 /* Take this entry */
4069 /* use strncpy(9f) to zero out uninitialized bytes */
4079 }
4087 }
4088 }
4089 /* Release the chunk */
4092 /* Read whole block, but got no entries, read another if not eof */
4094 /*
4095 * Large Files: casting i_size to int here is not a problem
4096 * because directory sizes are always less than MAXOFF32_T.
4097 * See assertion above.
4098 */
4103 /* Copy out the entry data */
4112 update_inode:
4119 unlock:
4122 }
4123 out:
4125 }
4127 /*ARGSUSED*/
4128 static int
4137 {
4148 /*
4149 * No symlinks in attrdirs at this time
4150 */
4154 again:
4167 /*
4168 * We must create the inode before the directory entry, to avoid
4169 * racing with readlink(). ufs_dirmakeinode requires that we
4170 * hold the quota lock as reader, and directory locks as writer.
4171 */
4177 /*
4178 * Suppress any out of inodes messages if we will retry on
4179 * ENOSP
4180 */
4195 /*
4196 * OK. The inode has been created. Write out the data of the
4197 * symbolic link. Since symbolic links are metadata, and should
4198 * remain consistent across a system crash, we need to force the
4199 * data out synchronously.
4200 *
4201 * (This is a change from the semantics in earlier releases, which
4202 * only created symbolic links synchronously if the semi-documented
4203 * 'syncdir' option was set, or if we were being invoked by the NFS
4204 * server, which requires symbolic links to be created synchronously.)
4205 *
4206 * We need to pass in a pointer for the residual length; otherwise
4207 * ufs_rdwri() will always return EIO if it can't write the data,
4208 * even if the error was really ENOSPC or EDQUOT.
4209 */
4217 /*
4218 * Suppress file system full messages if we will retry
4219 */
4232 }
4234 /*
4235 * If the link's data is small enough, we can cache it in the inode.
4236 * This is a "fast symbolic link". We don't use the first direct
4237 * block because that's actually used to point at the symbolic link's
4238 * contents on disk; but we know that none of the other direct or
4239 * indirect blocks can be used because symbolic links are restricted
4240 * to be smaller than a file system block.
4241 */
4250 /* error, clear garbage left behind */
4255 }
4256 }
4261 /*
4262 * OK. We've successfully created the symbolic link. All that
4263 * remains is to insert it into the appropriate directory.
4264 */
4270 /*
4271 * Fall through into remove-on-error code. We're either done, or we
4272 * need to remove the inode (if we couldn't insert it).
4273 */
4275 remove:
4283 }
4285 unlock:
4293 trans_size);
4297 }
4299 /*
4300 * We may have failed due to lack of an inode or of a block to
4301 * store the target in. Try flushing the delete queue to free
4302 * logically-available things up and try again.
4303 */
4308 }
4310 out:
4312 }
4314 /*
4315 * Ufs specific routine used to do ufs io.
4316 */
4317 int
4321 {
4349 }
4355 }
4357 }
4359 /*ARGSUSED*/
4360 static int
4362 {
4372 }
4381 }
4383 /* ARGSUSED2 */
4384 static int
4386 {
4391 /*
4392 * Read case is easy.
4393 */
4397 }
4399 /*
4400 * Caller has requested a writer lock, but that inhibits any
4401 * concurrency in the VOPs that follow. Acquire the lock shared
4402 * and defer exclusive access until it is known to be needed in
4403 * other VOP handlers. Some cases can be determined here.
4404 */
4406 /*
4407 * If directio is not set, there is no chance of concurrency,
4408 * so just acquire the lock exclusive. Beware of a forced
4409 * unmount before looking at the mount option.
4410 */
4417 }
4419 /*
4420 * Mandatory locking forces acquiring i_rwlock exclusive.
4421 */
4425 }
4427 /*
4428 * Acquire the lock shared in case a concurrent write follows.
4429 * Mandatory locking could have become enabled before the lock
4430 * was acquired. Re-check and upgrade if needed.
4431 */
4437 }
4439 }
4441 /*ARGSUSED*/
4442 static void
4444 {
4448 }
4450 /* ARGSUSED */
4451 static int
4454 {
4456 }
4458 /* ARGSUSED */
4459 static int
4463 {
4469 /*
4470 * If file is being mapped, disallow frlock.
4471 * XXX I am not holding tlock while checking i_mapcnt because the
4472 * current locking strategy drops all locks before calling fs_frlock.
4473 * So, mapcnt could change before we enter fs_frlock making is
4474 * meaningless to have held tlock in the first place.
4475 */
4479 }
4481 /* ARGSUSED */
4482 static int
4485 {
4493 ULOCKFS_SPACE_MASK);
4502 ULOCKFS_FALLOCATE_MASK);
4512 }
4514 }
4516 /*
4517 * Used to determine if read ahead should be done. Also used to
4518 * to determine when write back occurs.
4519 */
4520 #define CLUSTSZ(ip) ((ip)->i_ufsvfs->vfs_ioclustsz)
4522 /*
4523 * A faster version of ufs_getpage.
4524 *
4525 * We optimize by inlining the pvn_getpages iterator, eliminating
4526 * calls to bmap_read if file doesn't have UFS holes, and avoiding
4527 * the overhead of page_exists().
4528 *
4529 * When files has UFS_HOLES and ufs_getpage is called with S_READ,
4530 * we set *protp to PROT_READ to avoid calling bmap_read. This approach
4531 * victimizes performance when a file with UFS holes is faulted
4532 * first in the S_READ mode, and then in the S_WRITE mode. We will get
4533 * two MMU faults in this case.
4534 *
4535 * XXX - the inode fields which control the sequential mode are not
4536 * protected by any mutex. The read ahead will act wild if
4537 * multiple processes will access the file concurrently and
4538 * some of them in sequential mode. One particulary bad case
4539 * is if another thread will change the value of i_nextrio between
4540 * the time this thread tests the i_nextrio value and then reads it
4541 * again to use it as the offset for the read ahead.
4542 */
4543 /*ARGSUSED*/
4544 static int
4548 {
4550 uoff_t pgoff;
4551 uoff_t eoff;
4557 caddr_t pgaddr;
4558 krw_t rwtype;
4573 /*
4574 * Obey the lockfs protocol
4575 */
4585 /*
4586 * Try to start a transaction, will return if blocking is
4587 * expected to occur and the address space is not the
4588 * kernel address space.
4589 */
4595 /*
4596 * Use EDEADLK here because the VM code
4597 * can normally never see this error.
4598 */
4602 }
4605 }
4606 }
4611 }
4617 /*
4618 * If this thread owns the lock, i.e., this thread grabbed it
4619 * as writer somewhere above, then we don't need to grab the
4620 * lock as reader in this routine.
4621 */
4624 retrylock:
4626 /*
4627 * Grab the quota lock if we need to call
4628 * bmap_write() below (with i_contents as writer).
4629 */
4633 }
4635 /*
4636 * We may be getting called as a side effect of a bmap using
4637 * fbread() when the blocks might be being allocated and the
4638 * size has not yet been up'ed. In this case we want to be
4639 * able to return zero pages if we get back UFS_HOLE from
4640 * calling bmap for a non write case here. We also might have
4641 * to read some frags from the disk into a page if we are
4642 * extending the number of frags for a given lbn in bmap().
4643 * Large Files: The read of i_size here is atomic because
4644 * i_contents is held here. If dolock is zero, the lock
4645 * is held in bmap routines.
4646 */
4654 }
4657 }
4659 /*
4660 * Must hold i_contents lock throughout the call to pvn_getpages
4661 * since locked pages are returned from each call to ufs_getapage.
4662 * Must *not* return locked pages and then try for contents lock
4663 * due to lock ordering requirements (inode > page)
4664 */
4670 uoff_t offset;
4672 /*
4673 * We must acquire the RW_WRITER lock in order to
4674 * call bmap_write().
4675 */
4679 /*
4680 * Grab the quota lock before
4681 * upgrading i_contents, but if we can't grab it
4682 * don't wait here due to lock order:
4683 * vfs_dqrwlock > i_contents.
4684 */
4690 }
4696 }
4697 }
4699 /*
4700 * May be allocating disk blocks for holes here as
4701 * a result of mmap faults. write(2) does the bmap_write
4702 * in rdip/wrip, not here. We are not dealing with frags
4703 * in this case.
4704 */
4705 /*
4706 * Large Files: We cast fs_bmask field to offset_t
4707 * just as we do for MAXBMASK because uoff is a 64-bit
4708 * data type. fs_bmask will still be a 32-bit type
4709 * as we cannot change any ondisk data structures.
4710 */
4722 }
4723 }
4725 /*
4726 * Can be a reader from now on.
4727 */
4730 /*
4731 * We can release vfs_dqrwlock early so do it, but make
4732 * sure we don't try to release it again at the bottom.
4733 */
4737 }
4738 }
4740 /*
4741 * We remove PROT_WRITE in cases when the file has UFS holes
4742 * because we don't want to call bmap_read() to check each
4743 * page if it is backed with a disk block.
4744 */
4750 /*
4751 * The loop looks up pages in the range [off, off + len).
4752 * For each page, we first check if we should initiate an asynchronous
4753 * read ahead before we call page_lookup (we may sleep in page_lookup
4754 * for a previously initiated disk read).
4755 */
4760 uoff_t nextrio;
4761 se_t se;
4766 /* Handle async getpage (faultahead) */
4773 }
4774 /*
4775 * Check if we should initiate read ahead of next cluster.
4776 * We call page_exists only when we need to confirm that
4777 * we have the current page before we initiate the read ahead.
4778 */
4784 /*
4785 * We always read ahead the next cluster of data
4786 * starting from i_nextrio. If the page (vp,nextrio)
4787 * is actually in core at this point, the routine
4788 * ufs_getpage_ra() will stop pre-fetching data
4789 * until we read that page in a synchronized manner
4790 * through ufs_getpage_miss(). So, we should increase
4791 * i_nextrio if the page (vp, nextrio) exists.
4792 */
4795 }
4796 }
4799 /*
4800 * We found the page in the page cache.
4801 */
4808 /*
4809 * We have to create the page, or read it from disk.
4810 */
4816 pl++;
4821 }
4822 }
4823 }
4825 /*
4826 * Return pages up to plsz if they are in the page cache.
4827 * We cannot return pages if there is a chance that they are
4828 * backed with a UFS hole and rw is S_WRITE or S_CREATE.
4829 */
4845 }
4846 }
4852 error:
4854 /*
4855 * Release any pages we have locked.
4856 */
4861 }
4863 update_inode:
4864 /*
4865 * If the inode is not already marked for IACC (in rdip() for read)
4866 * and the inode is not marked for no access time update (in wrip()
4867 * for write) then update the inode access time and mod time now.
4868 */
4878 }
4879 }
4880 }
4886 }
4888 unlock:
4893 }
4895 }
4896 out:
4898 }
4900 /*
4901 * ufs_getpage_miss is called when ufs_getpage missed the page in the page
4902 * cache. The page is either read from the disk, or it's created.
4903 * A page is created (without disk read) if rw == S_CREATE, or if
4904 * the page is not backed with a real disk block (UFS hole).
4905 */
4906 /* ARGSUSED */
4907 static int
4910 {
4913 daddr_t bn;
4920 /*
4921 * Figure out whether the page can be created, or must be
4922 * must be read from the disk.
4923 */
4933 /*
4934 * If its also a fallocated block that hasn't been written to
4935 * yet, we will treat it just like a UFS_HOLE and create
4936 * a zero page for it
4937 */
4940 }
4947 }
4954 uoff_t io_off;
4955 uint_t xlen;
4959 /*
4960 * If access is not in sequential order, we read from disk
4961 * in bsize units.
4962 *
4963 * We limit the size of the transfer to bsize if we are reading
4964 * from the beginning of the file. Note in this situation we
4965 * will hedge our bets and initiate an async read ahead of
4966 * the second block.
4967 */
4974 /*
4975 * Some other thread has entered the page.
4976 * ufs_getpage will retry page_lookup.
4977 */
4981 }
4983 /*
4984 * Zero part of the page which we are not
4985 * going to read from the disk.
4986 */
5008 }
5012 /*
5013 * If the file access is sequential, initiate read ahead
5014 * of the next cluster.
5015 */
5024 }
5025 }
5029 }
5031 /*
5032 * Read ahead a cluster from the disk. Returns the length in bytes.
5033 */
5034 static int
5036 {
5043 daddr_t bn;
5050 /*
5051 * If the directio advisory is in effect on this file,
5052 * then do not do buffered read ahead. Read ahead makes
5053 * it more difficult on threads using directio as they
5054 * will be forced to flush the pages from this vnode.
5055 */
5061 /*
5062 * Is this test needed?
5063 */
5069 /*
5070 * If its a UFS_HOLE or a fallocated block, do not perform
5071 * any read ahead's since there probably is nothing to read ahead
5072 */
5076 /*
5077 * Limit the transfer size to bsize if this is the 2nd block.
5078 */
5086 /*
5087 * Zero part of page which we are not going to read from disk
5088 */
5111 }
5114 }
5117 /*
5118 * Flags are composed of {B_INVAL, B_FREE, B_DONTNEED, B_FORCE, B_ASYNC}
5119 *
5120 * LMXXX - the inode really ought to contain a pointer to one of these
5121 * async args. Stuff gunk in there and just hand the whole mess off.
5122 * This would replace i_delaylen, i_delayoff.
5123 */
5124 /*ARGSUSED*/
5125 static int
5128 {
5134 }
5136 /*
5137 * XXX - Why should this check be made here?
5138 */
5142 }
5147 }
5153 /*
5154 * If nobody stalled, start a new cluster.
5155 */
5161 }
5162 /*
5163 * If we have a full cluster or they are not contig,
5164 * then push last cluster and start over.
5165 */
5168 uoff_t doff;
5178 /* LMXXX - flags are new val, not old */
5180 }
5181 /*
5182 * There is something there, it's not full, and
5183 * it is contig.
5184 */
5188 }
5189 /*
5190 * Must have weird flags or we are not clustering.
5191 */
5192 }
5196 errout:
5198 }
5200 /*
5201 * If len == 0, do from off to EOF.
5202 *
5203 * The normal cases should be len == 0 & off == 0 (entire vp list),
5204 * len == MAXBSIZE (from segmap_release actions), and len == PAGESIZE
5205 * (from pageout).
5206 */
5207 /*ARGSUSED*/
5208 static int
5211 offset_t off,
5215 {
5216 uoff_t io_off;
5217 uoff_t eoff;
5226 /*
5227 * Acquire the readers/write inode lock before locking
5228 * any pages in this inode.
5229 * The inode lock is held during i/o.
5230 */
5235 }
5238 /*
5239 * Must synchronize this thread and any possible thread
5240 * operating in the window of vulnerability in wrip().
5241 * It is dangerous to allow both a thread doing a putpage
5242 * and a thread writing, so serialize them. The exception
5243 * is when the thread in wrip() does something which causes
5244 * a putpage operation. Then, the thread must be allowed
5245 * to continue. It may encounter a bmap_read problem in
5246 * ufs_putapage, but that is handled in ufs_putapage.
5247 * Allow async writers to proceed, we don't want to block
5248 * the pageout daemon.
5249 */
5256 /*
5257 * If there is no thread in the critical
5258 * section of wrip(), then proceed.
5259 * Otherwise, wait until there isn't one.
5260 */
5264 }
5266 /*
5267 * Bounce async writers when we have a writer
5268 * working on this file so we don't deadlock
5269 * the pageout daemon.
5270 */
5274 }
5277 }
5278 }
5279 }
5285 }
5288 /*
5289 * Search the entire vp list for pages >= off.
5290 */
5294 /*
5295 * Loop over all offsets in the range looking for
5296 * pages to deal with.
5297 */
5300 else
5304 /*
5305 * If we are not invalidating, synchronously
5306 * freeing or writing pages, use the routine
5307 * page_lookup_nowait() to prevent reclaiming
5308 * them from the free list.
5309 */
5315 io_off,
5317 }
5328 /*
5329 * "io_off" and "io_len" are returned as
5330 * the range of pages we actually wrote.
5331 * This allows us to skip ahead more quickly
5332 * since several pages may've been dealt
5333 * with by this iteration of the loop.
5334 */
5335 }
5336 }
5337 }
5339 /*
5340 * We have just sync'ed back all the pages on
5341 * the inode, turn off the IMODTIME flag.
5342 */
5346 }
5350 }
5352 static void
5354 {
5372 }
5376 }
5378 /*
5379 * Write out a single page, possibly klustering adjacent
5380 * dirty pages. The inode lock must be held.
5381 *
5382 * LMXXX - bsize < pagesize not done.
5383 */
5384 /*ARGSUSED*/
5385 int
5393 {
5394 uoff_t io_off;
5395 uoff_t off;
5401 daddr_t bn;
5411 }
5416 /*
5417 * If the modified time on the inode has not already been
5418 * set elsewhere (e.g. for write/setattr) we set the time now.
5419 * This gives us approximate modified times for mmap'ed files
5420 * which are modified via stores in the user address space.
5421 */
5428 }
5430 /*
5431 * Align the request to a block boundry (for old file systems),
5432 * and go ask bmap() how contiguous things are for this file.
5433 */
5440 /*
5441 * logging device is in error mode; simply return EIO
5442 */
5446 }
5447 /*
5448 * Oops, the thread in the window in wrip() did some
5449 * sort of operation which caused a putpage in the bad
5450 * range. In this case, just return an error which will
5451 * cause the software modified bit on the page to set
5452 * and the page will get written out again later.
5453 */
5457 }
5458 /*
5459 * If the pager is trying to push a page in the bad range
5460 * just tell it to try again later when things are better.
5461 */
5465 }
5468 }
5470 /*
5471 * If it is an fallocate'd block, reverse the negativity since
5472 * we are now writing to it
5473 */
5480 }
5482 /*
5483 * Take the length (of contiguous bytes) passed back from bmap()
5484 * and _try_ and get a set of pages covering that extent.
5485 */
5488 /*
5489 * May have run out of memory and not clustered backwards.
5490 * off p_offset
5491 * [ pp - 1 ][ pp ]
5492 * [ block ]
5493 * We told bmap off, so we have to adjust the bn accordingly.
5494 */
5498 }
5500 /*
5501 * bmap was carefull to tell us the right size so use that.
5502 * There might be unallocated frags at the end.
5503 * LMXXX - bzero the end of the page? We must be writing after EOF.
5504 */
5508 }
5510 /*
5511 * Handle the case where we are writing the last page after EOF.
5512 *
5513 * XXX - just a patch for i-mt3.
5514 */
5519 }
5531 /*
5532 * File contents of shadow or quota inodes are metadata, and updates
5533 * to these need to be put into a logging transaction. All direct
5534 * callers in UFS do that, but fsflush can come here _before_ the
5535 * normal codepath. An example would be updating ACL information, for
5536 * which the normal codepath would be:
5537 * ufs_si_store()
5538 * ufs_rdwri()
5539 * wrip()
5540 * segmap_release()
5541 * fop_putpage()
5542 * Here, fsflush can pick up the dirty page before segmap_release()
5543 * forces it out. If that happens, there's no transaction.
5544 * We therefore need to test whether a transaction exists, and if not
5545 * create one - for fsflush.
5546 */
5547 dotrans =
5555 }
5562 }
5563 }
5567 }
5569 /* write throttle */
5587 }
5598 }
5602 }
5606 out:
5614 out_trace:
5616 }
5621 /* ARGSUSED */
5622 static int
5624 offset_t off,
5628 uchar_t prot,
5629 uchar_t maxprot,
5630 uint_t flags,
5633 {
5638 k_sigset_t smask;
5644 }
5649 }
5654 }
5656 retry_map:
5658 /*
5659 * If file is being locked, disallow mapping.
5660 */
5664 }
5667 /*
5668 * Note that if we are retrying (because ufs_lockfs_trybegin failed in
5669 * the previous attempt), some other thread could have grabbed
5670 * the same VA range if MAP_FIXED is set. In that case, choose_addr
5671 * would unmap the valid VA range, that is ok.
5672 */
5677 }
5679 /*
5680 * a_lock has to be acquired before entering the lockfs protocol
5681 * because that is the order in which pagefault works. Also we cannot
5682 * block on a_lock here because this waiting writer will prevent
5683 * further readers like ufs_read from progressing and could cause
5684 * deadlock between ufs_read/ufs_map/pagefault when a quiesce is
5685 * pending.
5686 */
5688 ufs_map_alock_retry_cnt++;
5690 }
5692 /*
5693 * We can't hold as->a_lock and wait for lockfs to succeed because
5694 * the proc tools might hang on a_lock, so call ufs_lockfs_trybegin()
5695 * instead.
5696 */
5698 /*
5699 * ufs_lockfs_trybegin() did not succeed. It is safer to give up
5700 * as->a_lock and wait for ulp->ul_fs_lock status to change.
5701 */
5702 ufs_map_lockfs_retry_cnt++;
5720 }
5721 }
5722 }
5725 }
5742 out:
5744 }
5746 /* ARGSUSED */
5747 static int
5749 offset_t off,
5751 caddr_t addr,
5753 uchar_t prot,
5754 uchar_t maxprot,
5755 uint_t flags,
5758 {
5763 }
5769 }
5771 /*ARGSUSED*/
5772 static int
5776 {
5781 }
5788 }
5789 /*
5790 * Return the answer requested to poll() for non-device files
5791 */
5794 /* ARGSUSED */
5795 int
5798 {
5807 }
5830 }
5834 out:
5838 }
5840 /* ARGSUSED */
5841 static int
5844 {
5857 /*
5858 * Have to handle _PC_NAME_MAX here, because the normal way
5859 * [fs_pathconf() -> VOP_STATVFS() -> ufs_statvfs()]
5860 * results in a lock ordering reversal between
5861 * ufs_lockfs_{begin,end}() and
5862 * ufs_thread_{suspend,continue}().
5863 *
5864 * Keep in sync with ufs_statvfs().
5865 */
5873 else
5880 error =
5883 /* Start transaction */
5886 TOP_RMDIR,
5887 TOP_RMDIR_SIZE);
5888 }
5889 /*
5890 * Is directory empty
5891 */
5909 TOP_RMDIR_SIZE);
5910 }
5915 }
5918 }
5936 /*
5937 * UFS keeps only microsecond timestamp resolution.
5938 * This is historical and will probably never change.
5939 */
5946 }
5950 }
5952 }
5956 /*ARGSUSED*/
5957 static int
5960 {
5965 daddr_t bn;
5976 }
5979 /*
5980 * We need a better check. Ideally, we would use another
5981 * vnodeops so that hlocked and forcibly unmounted file
5982 * systems would return EIO where appropriate and w/o the
5983 * need for these checks.
5984 */
5988 /*
5989 * For vmpss (pp can be NULL) case respect the quiesce protocol.
5990 * ul_lock must be taken before locking pages so we can't use it here
5991 * if pp is non NULL because segvn already locked pages
5992 * SE_EXCL. Instead we rely on the fact that a forced umount or
5993 * applying a filesystem lock via ufs_fiolfs() will block in the
5994 * implicit call to ufs_flush() until we unlock the pages after the
5995 * return to segvn. Other ufs_quiesce() callers keep ufs_quiesce_pend
5996 * above 0 until they are done. We have to be careful not to increment
5997 * ul_vnops_cnt here after forceful unmount hlocks the file system.
5998 *
5999 * If pp is NULL use ul_lock to make sure we don't increment
6000 * ul_vnops_cnt after forceful unmount hlocks the file system.
6001 */
6009 }
6011 }
6019 }
6020 }
6023 /*
6024 * segvn may call fop_pageio() instead of fop_getpage() to
6025 * handle a fault against a segment that maps vnode pages with
6026 * large mappings. Segvn creates pages and holds them locked
6027 * SE_EXCL during fop_pageio() call. In this case we have to
6028 * use rw_tryenter() to avoid a potential deadlock since in
6029 * lock order i_contents needs to be taken first.
6030 * Segvn will retry via fop_getpage() if fop_pageio() fails.
6031 */
6038 }
6039 }
6041 /*
6042 * Return an error to segvn because the pagefault request is beyond
6043 * PAGESIZE rounded EOF.
6044 */
6051 }
6058 }
6064 }
6066 /*
6067 * Break the io request into chunks, one for each contiguous
6068 * stretch of disk blocks in the target file.
6069 */
6081 }
6084 }
6087 /*
6088 * Zero out a page beyond EOF, when the last block of
6089 * a file is a UFS fragment so that ufs_pageio() can be used
6090 * instead of ufs_getpage() to handle faults against
6091 * segvn segments that use large pages.
6092 */
6097 }
6112 else
6116 ufs_pageio_reads++;
6117 else
6118 ufs_pageio_writes++;
6121 else
6123 /*
6124 * If the request is not B_ASYNC, wait for i/o to complete
6125 * and re-assemble the page list to return to the caller.
6126 * If it is B_ASYNC we leave the page list in pieces and
6127 * cleanup() will dispose of them.
6128 */
6135 }
6141 }
6145 /* Cleanup unprocessed parts of list */
6149 else
6152 /* Re-assemble list and let caller clean up */
6155 }
6156 }
6164 }
6171 }
6173 /*
6174 * Called when the kernel is in a frozen state to dump data
6175 * directly to the device. It uses a private dump data structure,
6176 * set up by dump_ctl, to locate the correct disk block to which to dump.
6177 */
6178 /*ARGSUSED*/
6179 static int
6182 {
6183 uoff_t file_size;
6191 /*
6192 * forced unmount case
6193 */
6196 /*
6197 * Validate the inode that it has not been modified since
6198 * the dump structure is allocated.
6199 */
6207 }
6210 /*
6211 * See that the file has room for this write
6212 */
6218 /*
6219 * Find the physical disk block numbers from the dump
6220 * private data structure directly and write out the data
6221 * in contiguous block lumps
6222 */
6230 nfsbs++;
6232 }
6239 }
6242 }
6244 /*
6245 * Prepare the file system before and after the dump operation.
6246 *
6247 * action = DUMP_ALLOC:
6248 * Preparation before dump, allocate dump private data structure
6249 * to hold all the direct and indirect block info for dump.
6250 *
6251 * action = DUMP_FREE:
6252 * Clean up after dump, deallocate the dump private data structure.
6253 *
6254 * action = DUMP_SCAN:
6255 * Scan dump_info for *blkp DEV_BSIZE blocks of contig fs space;
6256 * if found, the starting file-relative DEV_BSIZE lbn is written
6257 * to *bklp; that lbn is intended for use with fop_dump()
6258 */
6259 /*ARGSUSED*/
6260 static int
6262 {
6272 /*
6273 * check for forced unmount
6274 */
6279 /*
6280 * alloc and record dump_info
6281 */
6293 }
6295 /*
6296 * calculate and allocate space needed according to i_size
6297 */
6304 }
6306 /* Start saving the info */
6311 /* Direct Blocks */
6315 /* Indirect Blocks */
6328 }
6338 }
6339 }
6340 /* and time stamp the information */
6347 /*
6348 * free dump_info
6349 */
6357 /*
6358 * scan dump_info
6359 */
6369 /*
6370 * scan dblk[] entries; contig fs space is found when:
6371 * ((current blkno + frags per block) == next blkno)
6372 */
6376 n++;
6377 else
6379 dblk++;
6380 nextblk++;
6381 }
6383 /*
6384 * index is where size bytes of contig space begins;
6385 * conversion from index to the file's DEV_BSIZE lbn
6386 * is equivalent to: (index * fs_bsize) / DEV_BSIZE
6387 */
6393 }
6395 }
6397 /*
6398 * Recursive helper function for ufs_dumpctl(). It follows the indirect file
6399 * system blocks until it reaches the the disk block addresses, which are
6400 * then stored into the given buffer, storeblk.
6401 */
6405 {
6415 }
6417 }
6426 }
6433 }
6435 }
6437 /* ARGSUSED */
6438 static int
6441 {
6450 /*
6451 * Only grab locks if needed - they're not needed to check vsa_mask
6452 * or if the mask contains no acl flags.
6453 */
6456 ULOCKFS_GETATTR_MASK))
6465 }
6467 }
6469 /* ARGSUSED */
6470 static int
6473 {
6486 /* Abort now if the request is either empty or invalid. */
6493 }
6495 /*
6496 * Following convention, if this is a directory then we acquire the
6497 * inode's i_rwlock after starting a UFS logging transaction;
6498 * otherwise, we acquire it beforehand. Since we were called (and
6499 * must therefore return) with the lock held, we will have to drop it,
6500 * and later reacquire it, if operating on a directory.
6501 */
6506 /* Upgrade the lock if required. */
6510 }
6511 }
6513 again:
6519 }
6521 /*
6522 * Check that the file system supports this operation. Note that
6523 * ufs_lockfs_begin() will have checked that the file system had
6524 * not been forcibly unmounted.
6525 */
6529 }
6533 }
6539 }
6544 }
6548 /* Do the actual work. */
6550 /*
6551 * Suppress out of inodes messages if we will retry.
6552 */
6559 out:
6562 /*
6563 * top_end_async() can eventually call
6564 * top_end_sync(), which can block. We must
6565 * therefore observe the lock-ordering protocol
6566 * here as well.
6567 */
6571 }
6573 }
6575 }
6576 /*
6577 * If no inodes available, try scaring a logically-
6578 * free one out of the delete queue to someplace
6579 * that we can find it.
6580 */
6587 }
6589 }
6590 /*
6591 * If we need to reacquire the lock then it is safe to do so
6592 * as a reader. This is because ufs_rwunlock(), which will be
6593 * called by our caller after we return, does not differentiate
6594 * between shared and exclusive locks.
6595 */
6599 }
6602 }
6604 /*
6605 * Locate the vnode to be used for an event notification. As this will
6606 * be called prior to the name space change perform basic verification
6607 * that the change will be allowed.
6608 */
6610 static int
6613 {
6633 }
6634 }
6636 /*
6637 * Check accessibility and write access of parent directory as we
6638 * only want to post the event if we're able to make a change.
6639 */
6647 }
6651 }
6653 /*
6654 * Keep the idle queue from getting too long by idling two
6655 * inodes before attempting to allocate another.
6656 * This operation must be performed before entering lockfs
6657 * or a transaction.
6658 */
6663 }
6667 retry_lookup:
6674 }
6678 }
6684 }