| blob | fcffd952ed55cef00d590e5146d868e80406efde |
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 (c) 2013, Joyent, Inc. All rights reserved.
25 */
27 /* Copyright (c) 1983, 1984, 1985, 1986, 1987, 1988, 1989 AT&T */
28 /* All Rights Reserved */
30 /*
31 * Portions of this source code were derived from Berkeley 4.3 BSD
32 * under license from the Regents of the University of California.
33 */
35 #include <sys/types.h>
36 #include <sys/t_lock.h>
37 #include <sys/ksynch.h>
38 #include <sys/param.h>
39 #include <sys/time.h>
40 #include <sys/systm.h>
41 #include <sys/sysmacros.h>
42 #include <sys/resource.h>
43 #include <sys/signal.h>
44 #include <sys/cred.h>
45 #include <sys/user.h>
46 #include <sys/buf.h>
47 #include <sys/vfs.h>
48 #include <sys/vfs_opreg.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 <fs/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 */
194 /* NOTE: "not blkd" below means that the operation isn't blocked by lockfs */
235 NULL, NULL
236 };
238 #define MAX_BACKFILE_COUNT 9999
240 /*
241 * Created by ufs_dumpctl() to store a file's disk block info into memory.
242 * Used by ufs_dump() to dump data to disk directly.
243 */
249 };
253 /*
254 * Previously there was no special action required for ordinary files.
255 * (Devices are handled through the device file system.)
256 * Now we support Large Files and Large File API requires open to
257 * fail if file is large.
258 * We could take care to prevent data corruption
259 * by doing an atomic check of size and truncate if file is opened with
260 * FTRUNC flag set but traditionally this is being done by the vfs/vnode
261 * layers. So taking care of truncation here is a change in the existing
262 * semantics of VOP_OPEN and therefore we chose not to implement any thing
263 * here. The check for the size of the file > 2GB is being done at the
264 * vfs layer in routine vn_open().
265 */
267 /* ARGSUSED */
268 static int
270 {
272 }
274 /*ARGSUSED*/
275 static int
278 {
282 /*
283 * Push partially filled cluster at last close.
284 * ``last close'' is approximated because the dnlc
285 * may have a hold on the vnode.
286 * Checking for VBAD here will also act as a forced umount check.
287 */
295 }
296 }
299 }
301 /*ARGSUSED*/
302 static int
305 {
314 /*
315 * Mandatory locking needs to be done before ufs_lockfs_begin()
316 * and TRANS_BEGIN_SYNC() calls since mandatory locks can sleep.
317 */
319 /*
320 * ufs_getattr ends up being called by chklock
321 */
326 }
333 /*
334 * In the case that a directory is opened for reading as a file
335 * (eg "cat .") with the O_RSYNC, O_SYNC and O_DSYNC flags set.
336 * The locking order had to be changed to avoid a deadlock with
337 * an update taking place on that directory at the same time.
338 */
349 }
355 error);
358 TOP_READ_SIZE);
360 }
362 /*
363 * Only transact reads to files opened for sync-read and
364 * sync-write on a file system that is not write locked.
365 *
366 * The ``not write locked'' check prevents problems with
367 * enabling/disabling logging on a busy file system. E.g.,
368 * logging exists at the beginning of the read but does not
369 * at the end.
370 *
371 */
375 error);
378 }
386 TOP_READ_SIZE);
387 }
388 }
392 }
393 out:
396 }
404 static int
406 {
409 /*
410 * If the FDSYNC flag is set then ignore the global
411 * ufs_allow_shared_writes in this case.
412 */
415 /*
416 * Filter to determine if this request is suitable as a
417 * concurrent rewrite. This write must not allocate blocks
418 * by extending the file or filling in holes. No use trying
419 * through FSYNC descriptors as the inode will be synchronously
420 * updated after the write. The uio structure has not yet been
421 * checked for sanity, so assume nothing.
422 */
428 shared_write);
429 }
431 /*ARGSUSED*/
432 static int
435 {
448 retry_mandlock:
449 /*
450 * Mandatory locking needs to be done before ufs_lockfs_begin()
451 * and TRANS_BEGIN_[A]SYNC() calls since mandatory locks can sleep.
452 * Check for forced unmounts normally done in ufs_lockfs_begin().
453 */
457 }
462 /*
463 * ufs_getattr ends up being called by chklock
464 */
469 }
471 /* i_rwlock can change in chklock */
475 /*
476 * Check for fast-path special case of directio re-writes.
477 */
489 uint_t i_flag_save;
493 /*
494 * Special treatment of access times for re-writes.
495 * If IMOD is not already set, then convert it
496 * to IMODACC for this operation. This defers
497 * entering a delta into the log until the inode
498 * is flushed. This mimics what is done for read
499 * operations and inode access time.
500 */
509 }
515 }
519 }
524 /*
525 * Mandatory locking could have been enabled
526 * after dropping the i_rwlock.
527 */
530 }
536 /*
537 * Amount of log space needed for this write
538 */
542 /*
543 * Throttle writes.
544 */
548 ufs_throttles++;
550 }
552 }
554 /*
555 * Enter Transaction
556 *
557 * If the write is a rewrite there is no need to open a transaction
558 * if the FDSYNC flag is set and not the FSYNC. In this case just
559 * set the IMODACC flag to modify do the update at a later time
560 * thus avoiding the overhead of the logging transaction that is
561 * not required.
562 */
566 uint_t i_flag_save;
577 }
583 terr);
585 }
586 }
590 }
592 /*
593 * Write the file
594 */
598 /*
599 * In append mode start at end of file.
600 */
602 }
604 /*
605 * Mild optimisation, don't call ufs_trans_write() unless we have to
606 * Also, suppress file system full messages if we will retry.
607 */
614 }
620 /*
621 * Leave Transaction
622 */
629 resv);
632 }
635 }
637 }
638 out:
640 /*
641 * Any blocks tied up in pending deletes?
642 */
646 }
652 }
654 /*
655 * Don't cache write blocks to files with the sticky bit set.
656 * Used to keep swap files from blowing the page cache on a server.
657 */
660 /*
661 * Free behind hacks. The pager is busted.
662 * XXX - need to pass the information down to writedone() in a flag like B_SEQ
663 * or B_FREE_IF_TIGHT_ON_MEMORY.
664 */
669 /*
670 * While we should, in most cases, cache the pages for write, we
671 * may also want to cache the pages for read as long as they are
672 * frequently re-usable.
673 *
674 * If cache_read_ahead = 1, the pages for read will go to the tail
675 * of the cache list when they are released, otherwise go to the head.
676 */
679 /*
680 * Freebehind exists so that as we read large files sequentially we
681 * don't consume most of memory with pages from a few files. It takes
682 * longer to re-read from disk multiple small files as it does reading
683 * one large one sequentially. As system memory grows customers need
684 * to retain bigger chunks of files in memory. The advent of the
685 * cachelist opens up of the possibility freeing pages to the head or
686 * tail of the list.
687 *
688 * Not freeing a page is a bet that the page will be read again before
689 * it's segmap slot is needed for something else. If we loose the bet,
690 * it means some other thread is burdened with the page free we did
691 * not do. If we win we save a free and reclaim.
692 *
693 * Freeing it at the tail vs the head of cachelist is a bet that the
694 * page will survive until the next read. It's also saying that this
695 * page is more likely to be re-used than a page freed some time ago
696 * and never reclaimed.
697 *
698 * Freebehind maintains a range of file offset [smallfile1; smallfile2]
699 *
700 * 0 < offset < smallfile1 : pages are not freed.
701 * smallfile1 < offset < smallfile2 : pages freed to tail of cachelist.
702 * smallfile2 < offset : pages freed to head of cachelist.
703 *
704 * The range is computed at most once per second and depends on
705 * freemem and ncpus_online. Both parameters are bounded to be
706 * >= smallfile && >= smallfile64.
707 *
708 * smallfile1 = (free memory / ncpu) / 1000
709 * smallfile2 = (free memory / ncpu) / 10
710 *
711 * A few examples values:
712 *
713 * Free Mem (in Bytes) [smallfile1; smallfile2] [smallfile1; smallfile2]
714 * ncpus_online = 4 ncpus_online = 64
715 * ------------------ ----------------------- -----------------------
716 * 1G [256K; 25M] [32K; 1.5M]
717 * 10G [2.5M; 250M] [156K; 15M]
718 * 100G [25M; 2.5G] [1.5M; 150M]
719 *
720 */
722 #define SMALLFILE1_D 1000
723 #define SMALLFILE2_D 10
730 /*
731 * wrip does the real work of write requests for ufs.
732 */
733 int
735 {
737 u_offset_t off;
738 u_offset_t old_i_size;
742 caddr_t base;
745 uint_t flags;
754 /*
755 * ip->i_size is incremented before the uiomove
756 * is done on a write. If the move fails (bad user
757 * address) reset ip->i_size.
758 * The better way would be to increment ip->i_size
759 * only if the uiomove succeeds.
760 */
762 o_mode_t type;
767 /*
768 * check for forced unmount - should not happen as
769 * the request passed the lockfs checks.
770 */
778 /* check for valid filetype */
783 }
785 /*
786 * the actual limit of UFS file size
787 * is UFS_MAXOFFSET_T
788 */
800 }
802 /*
803 * if largefiles are disallowed, the limit is
804 * the pre-largefiles value of 2GB
805 */
808 else
813 }
816 }
826 }
827 /*
828 * Try to go direct
829 */
834 /*
835 * If ufs_directio wrote to the file or set the flags,
836 * we need to update i_seq, but it may be deferred.
837 */
842 }
845 }
847 /*
848 * Behavior with respect to dropping/reacquiring vfs_dqrwlock:
849 *
850 * o shadow inodes: vfs_dqrwlock is not held at all
851 * o quota updates: vfs_dqrwlock is read or write held
852 * o other updates: vfs_dqrwlock is read held
853 *
854 * The first case is the only one where we do not hold
855 * vfs_dqrwlock at all while entering wrip().
856 * We must make sure not to downgrade/drop vfs_dqrwlock if we
857 * have it as writer, i.e. if we are updating the quota inode.
858 * There is no potential deadlock scenario in this case as
859 * ufs_getpage() takes care of this and avoids reacquiring
860 * vfs_dqrwlock in that case.
861 *
862 * This check is done here since the above conditions do not change
863 * and we possibly loop below, so save a few cycles.
864 */
870 }
872 /*
873 * Large Files: We cast MAXBMASK to offset_t
874 * inorder to mask out the higher bits. Since offset_t
875 * is a signed value, the high order bit set in MAXBMASK
876 * value makes it do the right thing by having all bits 1
877 * in the higher word. May be removed for _SOLARIS64_.
878 */
893 }
894 /*
895 * since uoff + n >= limit,
896 * therefore n >= limit - uoff, and n is an int
897 * so it is safe to cast it to an int
898 */
900 }
902 /*
903 * We are extending the length of the file.
904 * bmap is used so that we are sure that
905 * if we need to allocate new blocks, that it
906 * is done here before we up the file size.
907 */
910 /*
911 * bmap_write never drops i_contents so if
912 * the flags are set it changed the file.
913 */
917 }
920 /*
921 * There is a window of vulnerability here.
922 * The sequence of operations: allocate file
923 * system blocks, uiomove the data into pages,
924 * and then update the size of the file in the
925 * inode, must happen atomically. However, due
926 * to current locking constraints, this can not
927 * be done.
928 */
932 /*
933 * If we are writing from the beginning of
934 * the mapping, we can just create the
935 * pages without having to read them.
936 */
939 /*
940 * Going to do a whole mappings worth,
941 * so we can just create the pages w/o
942 * having to read them in. But before
943 * we do that, we need to make sure any
944 * needed blocks are allocated first.
945 */
949 /*
950 * bmap_write never drops i_contents so if
951 * the flags are set it changed the file.
952 */
956 }
960 /*
961 * check if the new created page needed the
962 * allocation of new disk blocks.
963 */
968 /*
969 * In sync mode flush the indirect blocks which
970 * may have been allocated and not written on
971 * disk. In above cases bmap_write will allocate
972 * in sync mode.
973 */
978 }
979 }
981 /*
982 * At this point we can enter ufs_getpage() in one
983 * of two ways:
984 * 1) segmap_getmapflt() calls ufs_getpage() when the
985 * forcefault parameter is true (pagecreate == 0)
986 * 2) uiomove() causes a page fault.
987 *
988 * We have to drop the contents lock to prevent the VM
989 * system from trying to reacquire it in ufs_getpage()
990 * should the uiomove cause a pagefault.
991 *
992 * We have to drop the reader vfs_dqrwlock here as well.
993 */
999 }
1004 /*
1005 * Touch the page and fault it in if it is not in core
1006 * before segmap_getmapflt or vpm_data_copy can lock it.
1007 * This is to avoid the deadlock if the buffer is mapped
1008 * to the same file through mmap which we want to write.
1009 */
1013 /*
1014 * Copy data. If new pages are created, part of
1015 * the page that is not written will be initizliazed
1016 * with zeros.
1017 */
1025 /*
1026 * segmap_pagecreate() returns 1 if it calls
1027 * page_create_va() to allocate any pages.
1028 */
1035 }
1037 /*
1038 * If "newpage" is set, then a new page was created and it
1039 * does not contain valid data, so it needs to be initialized
1040 * at this point.
1041 * Otherwise the page contains old data, which was overwritten
1042 * partially or as a whole in uiomove.
1043 * If there is only one iovec structure within uio, then
1044 * on error uiomove will not be able to update uio->uio_loffset
1045 * and we would zero the whole page here!
1046 *
1047 * If uiomove fails because of an error, the old valid data
1048 * is kept instead of filling the rest of the page with zero's.
1049 */
1052 /*
1053 * We created pages w/o initializing them completely,
1054 * thus we need to zero the part that wasn't set up.
1055 * This happens on most EOF write cases and if
1056 * we had some sort of error during the uiomove.
1057 */
1065 }
1067 /*
1068 * Unlock the pages allocated by page_create_va()
1069 * in segmap_pagecreate()
1070 */
1074 /*
1075 * If the size of the file changed, then update the
1076 * size field in the inode now. This can't be done
1077 * before the call to segmap_pageunlock or there is
1078 * a potential deadlock with callers to ufs_putpage().
1079 * They will be holding i_contents and trying to lock
1080 * a page, while this thread is holding a page locked
1081 * and trying to acquire i_contents.
1082 */
1088 /*
1089 * file has grown larger than 2GB. Set flag
1090 * in superblock to indicate this, if it
1091 * is not already set.
1092 */
1100 }
1106 }
1109 /*
1110 * If we failed on a write, we may have already
1111 * allocated file blocks as well as pages. It's
1112 * hard to undo the block allocation, but we must
1113 * be sure to invalidate any pages that may have
1114 * been allocated.
1115 *
1116 * If the page was created without initialization
1117 * then we must check if it should be possible
1118 * to destroy the new page and to keep the old data
1119 * on the disk.
1120 *
1121 * It is possible to destroy the page without
1122 * having to write back its contents only when
1123 * - the size of the file keeps unchanged
1124 * - bmap_write() did not allocate new disk blocks
1125 * it is possible to create big files using "seek" and
1126 * write to the end of the file. A "write" to a
1127 * position before the end of the file would not
1128 * change the size of the file but it would allocate
1129 * new disk blocks.
1130 * - uiomove intended to overwrite the whole page.
1131 * - a new page was created (newpage == 1).
1132 */
1135 newpage) {
1137 /* unwind what uiomove eventually last did */
1140 /*
1141 * destroy the page, do not write ambiguous
1142 * data to the disk.
1143 */
1146 /*
1147 * write the page back to the disk, if dirty,
1148 * and remove the page from the cache.
1149 */
1151 }
1154 /*
1155 * Flush pages.
1156 */
1160 }
1163 /*
1164 * Force write back for synchronous write cases.
1165 */
1167 /*
1168 * If the sticky bit is set but the
1169 * execute bit is not set, we do a
1170 * synchronous write back and free
1171 * the page when done. We set up swap
1172 * files to be handled this way to
1173 * prevent servers from keeping around
1174 * the client's swap pages too long.
1175 * XXX - there ought to be a better way.
1176 */
1179 SM_DONTNEED;
1183 }
1185 /*
1186 * Have written a whole block.
1187 * Start an asynchronous write and
1188 * mark the buffer to indicate that
1189 * it won't be needed again soon.
1190 */
1192 }
1194 /*
1195 * Flush pages.
1196 */
1200 }
1201 /*
1202 * If the operation failed and is synchronous,
1203 * then we need to unwind what uiomove() last
1204 * did so we can potentially return an error to
1205 * the caller. If this write operation was
1206 * done in two pieces and the first succeeded,
1207 * then we won't return an error for the second
1208 * piece that failed. However, we only want to
1209 * return a resid value that reflects what was
1210 * really done.
1211 *
1212 * Failures for non-synchronous operations can
1213 * be ignored since the page subsystem will
1214 * retry the operation until it succeeds or the
1215 * file system is unmounted.
1216 */
1223 }
1224 }
1225 }
1227 /*
1228 * Re-acquire contents lock.
1229 * If it was dropped, reacquire reader vfs_dqrwlock as well.
1230 */
1235 /*
1236 * If the uiomove() failed or if a synchronous
1237 * page push failed, fix up i_size.
1238 */
1241 /*
1242 * The uiomove failed, and we
1243 * allocated blocks,so get rid
1244 * of them.
1245 */
1247 }
1249 /*
1250 * XXX - Can this be out of the loop?
1251 */
1253 /*
1254 * Only do one increase of i_seq for multiple
1255 * pieces. Because we drop locks, record
1256 * the fact that we changed the timestamp and
1257 * are deferring the increase in case another thread
1258 * pushes our timestamp update.
1259 */
1269 /*
1270 * Clear Set-UID & Set-GID bits on
1271 * successful write if not privileged
1272 * and at least one of the execute bits
1273 * is set. If we always clear Set-GID,
1274 * mandatory file and record locking is
1275 * unuseable.
1276 */
1278 }
1279 }
1280 /*
1281 * In the case the FDSYNC flag is set and this is a
1282 * "rewrite" we won't log a delta.
1283 * The FSYNC flag overrides all cases.
1284 */
1287 }
1290 out:
1291 /*
1292 * Make sure i_seq is increased at least once per write
1293 */
1297 }
1299 /*
1300 * Inode is updated according to this table -
1301 *
1302 * FSYNC FDSYNC(posix.4)
1303 * --------------------------
1304 * always@ IATTCHG|IBDWRITE
1305 *
1306 * @ - If we are doing synchronous write the only time we should
1307 * not be sync'ing the ip here is if we have the stickyhack
1308 * activated, the file is marked with the sticky bit and
1309 * no exec bit, the file length has not been changed and
1310 * no new blocks have been allocated during this write.
1311 */
1314 /*
1315 * we have eliminated nosync
1316 */
1320 }
1321 }
1323 /*
1324 * If we've already done a partial-write, terminate
1325 * the write but return no error unless the error is ENOSPC
1326 * because the caller can detect this and free resources and
1327 * try again.
1328 */
1335 }
1337 /*
1338 * rdip does the real work of read requests for ufs.
1339 */
1340 int
1342 {
1343 u_offset_t off;
1344 caddr_t base;
1352 uint_t flags;
1354 krw_t rwtype;
1355 o_mode_t type;
1369 /* check for valid filetype */
1374 }
1379 }
1382 }
1385 }
1392 }
1393 /*
1394 * Try to go direct
1395 */
1400 }
1405 offset_t diff;
1418 }
1422 /*
1423 * We update smallfile2 and smallfile1 at most every second.
1424 */
1437 }
1442 /*
1443 * At this point we can enter ufs_getpage() in one of two
1444 * ways:
1445 * 1) segmap_getmapflt() calls ufs_getpage() when the
1446 * forcefault parameter is true (value of 1 is passed)
1447 * 2) uiomove() causes a page fault.
1448 *
1449 * We cannot hold onto an i_contents reader lock without
1450 * risking deadlock in ufs_getpage() so drop a reader lock.
1451 * The ufs_getpage() dolock logic already allows for a
1452 * thread holding i_contents as writer to work properly
1453 * so we keep a writer lock.
1454 */
1459 /*
1460 * Copy data.
1461 */
1468 }
1472 /*
1473 * If reading sequential we won't need this
1474 * buffer again soon. For offsets in range
1475 * [smallfile1, smallfile2] release the pages
1476 * at the tail of the cache list, larger
1477 * offsets are released at the head.
1478 */
1484 }
1485 /*
1486 * In POSIX SYNC (FSYNC and FDSYNC) read mode,
1487 * we want to make sure that the page which has
1488 * been read, is written on disk if it is dirty.
1489 * And corresponding indirect blocks should also
1490 * be flushed out.
1491 */
1495 }
1500 }
1506 }
1507 }
1512 out:
1513 /*
1514 * Inode is updated according to this table if FRSYNC is set.
1515 *
1516 * FSYNC FDSYNC(posix.4)
1517 * --------------------------
1518 * always IATTCHG|IBDWRITE
1519 */
1520 /*
1521 * The inode is not updated if we're logging and the inode is a
1522 * directory with FRSYNC, FSYNC and FDSYNC flags set.
1523 */
1527 }
1533 }
1534 }
1535 }
1536 /*
1537 * If we've already done a partial read, terminate
1538 * the read but return no error.
1539 */
1545 }
1547 /* ARGSUSED */
1548 static int
1557 {
1563 offset_t off;
1570 /*
1571 * forcibly unmounted
1572 */
1586 }
1594 }
1596 }
1600 /*
1601 * file system locking
1602 */
1610 }
1611 #ifdef _SYSCALL32_IMPL
1614 /* Translate ILP32 lockfs to LP64 lockfs */
1624 }
1630 comment =
1636 }
1639 }
1644 DATAMODEL_NATIVE) {
1647 }
1648 #ifdef _SYSCALL32_IMPL
1651 /* Translate LP64 to ILP32 lockfs */
1665 }
1671 }
1675 /*
1676 * get file system locking status
1677 */
1683 }
1684 #ifdef _SYSCALL32_IMPL
1687 /* Translate ILP32 lockfs to LP64 lockfs */
1697 }
1712 }
1713 #ifdef _SYSCALL32_IMPL
1715 /* Translate LP64 to ILP32 lockfs */
1726 }
1737 /*
1738 * set access time
1739 */
1741 /*
1742 * if mounted w/o atime, return quietly.
1743 * I briefly thought about returning ENOSYS, but
1744 * figured that most apps would consider this fatal
1745 * but the idea is to make this as seamless as poss.
1746 */
1751 ULOCKFS_SETATTR_MASK);
1759 }
1768 }
1772 /*
1773 * set delayed-io
1774 */
1778 /*
1779 * get delayed-io
1780 */
1784 /*
1785 * inode open
1786 */
1788 ULOCKFS_VGET_MASK);
1796 }
1800 /*
1801 * file system flush (push w/invalidate)
1802 */
1808 /*
1809 * Contract-private interface for Legato
1810 * Purge this vnode from the DNLC and decide
1811 * if this vnode is busy (*arg == 1) or not
1812 * (*arg == 0)
1813 */
1823 /*
1824 * Tune the file system (aka setting fs attributes)
1825 */
1827 ULOCKFS_SETATTR_MASK);
1851 {
1866 }
1868 /*
1869 * Do copyout even if there is an error because
1870 * the details of error is stored in fcp.
1871 */
1876 }
1879 {
1888 }
1900 /*
1901 * The following 3 ioctls are for TSufs support
1902 * although could potentially be used elsewhere
1903 */
1917 {
1923 /* Copy stucture if statistics are being kept */
1926 }
1932 }
1938 /* offset paramater is in/out */
1947 {
1948 /*
1949 * This is a project private ufs ioctl() to mark
1950 * the inode as that belonging to a compressed
1951 * file. This is used to mark individual
1952 * compressed files in a miniroot archive.
1953 * The files compressed in this manner are
1954 * automatically decompressed by the dcfs filesystem
1955 * (via an interception in ufs_lookup - see decompvp())
1956 * which is layered on top of ufs on a system running
1957 * from the archive. See uts/common/fs/dcfs for details.
1958 * This ioctl only marks the file as compressed - the
1959 * actual compression is done by fiocompress (a
1960 * userland utility) which invokes this ioctl().
1961 */
1965 ULOCKFS_SETATTR_MASK);
1972 }
1980 }
1984 }
1988 }
1989 }
1992 /* ARGSUSED */
1993 static int
1996 {
2002 /*
2003 * for performance, if only the size is requested don't bother
2004 * with anything else.
2005 */
2008 }
2010 /*
2011 * inlined lockfs checks
2012 */
2017 }
2020 /*
2021 * Return all the attributes. This should be refined so
2022 * that it only returns what's asked for.
2023 */
2025 /*
2026 * Copy from inode table.
2027 */
2030 /*
2031 * If there is an ACL and there is a mask entry, then do the
2032 * extra work that completes the equivalent of an acltomode(3)
2033 * call. According to POSIX P1003.1e, the acl mask should be
2034 * returned in the group permissions field.
2035 *
2036 * - start with the original permission and mode bits (from above)
2037 * - clear the group owner bits
2038 * - add in the mask bits.
2039 */
2044 }
2053 else
2079 }
2084 out:
2086 }
2088 /*
2089 * Special wrapper to provide a callback for secpolicy_vnode_setattr().
2090 * The i_contents lock is already held by the caller and we need to
2091 * declare the inode as 'void *' argument.
2092 */
2093 static int
2095 {
2099 }
2101 /*ARGSUSED4*/
2102 static int
2109 {
2126 timestruc_t now;
2127 vattr_t oldva;
2131 /*
2132 * Cannot set these attributes.
2133 */
2137 /*
2138 * check for forced unmount
2139 */
2147 again:
2158 /*
2159 * Acquire i_rwlock before TRANS_BEGIN_CSYNC() if this is a file.
2160 * This follows the protocol for read()/write().
2161 */
2163 /*
2164 * ufs_tryirwlock uses rw_tryenter and checks for SLOCK to
2165 * avoid i_rwlock, ufs_lockfs_begin deadlock. If deadlock
2166 * possible, retries the operation.
2167 */
2173 }
2175 }
2177 /*
2178 * Truncate file. Must have write permission and not be a directory.
2179 */
2185 }
2194 }
2198 }
2204 }
2206 /*
2207 * Acquire i_rwlock after TRANS_BEGIN_CSYNC() if this is a directory.
2208 * This follows the protocol established by
2209 * ufs_link/create/remove/rename/mkdir/rmdir/symlink.
2210 */
2213 retry_dir);
2217 }
2219 /*
2220 * Grab quota lock if we are changing the file's owner.
2221 */
2225 }
2241 /*
2242 * Change file access modes.
2243 */
2252 else
2255 }
2256 }
2259 /*
2260 * Don't change ownership of the quota inode.
2261 */
2266 }
2268 /*
2269 * No real ownership change.
2270 */
2274 }
2275 /*
2276 * Remove the blocks and the file, from the old user's
2277 * quota.
2278 */
2289 }
2293 /*
2294 * There is a real ownership change.
2295 */
2297 /*
2298 * Add the blocks and the file to the new
2299 * user's quota.
2300 */
2307 }
2308 }
2311 }
2314 }
2315 /*
2316 * Change file access or modified times.
2317 */
2319 /* Check that the time value is within ufs range */
2324 }
2326 /*
2327 * if the "noaccess" mount option is set and only atime
2328 * update is requested, do nothing. No error is returned.
2329 */
2338 }
2344 /*
2345 * In 2038, ctime sticks forever..
2346 */
2352 }
2355 }
2358 }
2360 skip_atime:
2361 /*
2362 * The presence of a shadow inode may indicate an ACL, but does
2363 * not imply an ACL. Future FSD types should be handled here too
2364 * and check for the presence of the attribute-specific data
2365 * before referencing it.
2366 */
2368 /*
2369 * XXX if ufs_iupdat is changed to sandbagged write fix
2370 * ufs_acl_setattr to push ip to keep acls consistent
2371 *
2372 * Suppress out of inodes messages if we will retry.
2373 */
2378 }
2380 update_inode:
2381 /*
2382 * Setattr always increases the sequence number
2383 */
2386 /*
2387 * if nfsd and not logging; push synchronously
2388 */
2393 }
2398 }
2406 trans_size);
2409 }
2411 }
2412 out:
2413 /*
2414 * If out of inodes or blocks, see if we can free something
2415 * up from the delete queue.
2416 */
2425 }
2429 }
2433 }
2435 }
2437 /*ARGSUSED*/
2438 static int
2441 {
2447 /*
2448 * The ufs_iaccess function wants to be called with
2449 * mode bits expressed as "ufs specific" bits.
2450 * I.e., VWRITE|VREAD|VEXEC do not make sense to
2451 * ufs_iaccess() but IWRITE|IREAD|IEXEC do.
2452 * But since they're the same we just pass the vnode mode
2453 * bit but just verify that assumption at compile time.
2454 */
2455 #if IWRITE != VWRITE || IREAD != VREAD || IEXEC != VEXEC
2457 #endif
2459 }
2461 /* ARGSUSED */
2462 static int
2465 {
2475 }
2477 /*
2478 * If the symbolic link is empty there is nothing to read.
2479 * Fast-track these empty symbolic links
2480 */
2484 }
2490 /*
2491 * The ip->i_rwlock protects the data blocks used for FASTSYMLINK
2492 */
2493 again:
2505 }
2511 }
2514 }
2518 ino_t ino;
2538 }
2540 /* can this be a fast symlink and is it a user buffer? */
2546 /*
2547 * setup a kernel buffer to read link into. this
2548 * is to fix a race condition where the user buffer
2549 * got corrupted before copying it into the inode.
2550 */
2566 }
2573 }
2584 /*
2585 * free page
2586 */
2593 /* error, clear garbage left behind */
2598 }
2599 }
2601 /* now, copy it into the user buffer */
2605 }
2608 }
2609 out:
2612 }
2613 nolockout:
2615 }
2617 /* ARGSUSED */
2618 static int
2621 {
2632 /*
2633 * First push out any data pages
2634 */
2641 }
2643 /*
2644 * Delta any delayed inode times updates
2645 * and push inode to log.
2646 * All other inode deltas will have already been delta'd
2647 * and will be pushed during the commit.
2648 */
2653 TOP_SYNCIP_SIZE);
2654 }
2663 TOP_SYNCIP_SIZE);
2664 }
2665 }
2667 /*
2668 * Commit the Moby transaction
2669 *
2670 * Deltas have already been made so we just need to
2671 * commit them with a synchronous transaction.
2672 * TRANS_BEGIN_SYNC() will return an error
2673 * if there are no deltas to commit, for an
2674 * empty transaction.
2675 */
2678 error);
2682 }
2684 TOP_COMMIT_SIZE);
2685 }
2689 /* Just update the inode only */
2693 /* Do data-synchronous writes */
2695 else
2696 /* Do synchronous writes */
2703 }
2704 out:
2707 }
2709 }
2711 /*ARGSUSED*/
2712 static void
2714 {
2716 }
2718 /*
2719 * Unix file system operations having to do with directory manipulation.
2720 */
2722 /* ARGSUSED */
2723 static int
2727 {
2736 /*
2737 * Check flags for type of lookup (regular file or attribute file)
2738 */
2744 /*
2745 * If not mounted with XATTR support then return EINVAL
2746 */
2750 /*
2751 * We don't allow recursive attributes...
2752 * Maybe someday we will.
2753 */
2756 }
2763 }
2767 }
2769 /*
2770 * Check accessibility of directory.
2771 */
2776 }
2780 }
2784 }
2786 /*
2787 * Check for a null component, which we should treat as
2788 * looking at dvp from within it's parent, so we don't
2789 * need a call to ufs_iaccess(), as it has already been
2790 * done.
2791 */
2797 }
2799 /*
2800 * Check for "." ie itself. this is a quick check and
2801 * avoids adding "." into the dnlc (which have been seen
2802 * to occupy >10% of the cache).
2803 */
2805 /*
2806 * Don't return without checking accessibility
2807 * of the directory. We only need the lock if
2808 * we are going to return it.
2809 */
2813 }
2815 }
2817 /*
2818 * Fast path: Check the directory name lookup cache.
2819 */
2821 /*
2822 * Check accessibility of directory.
2823 */
2827 }
2832 }
2836 }
2838 /*
2839 * Keep the idle queue from getting too long by
2840 * idling two inodes before attempting to allocate another.
2841 * This operation must be performed before entering
2842 * lockfs or a transaction.
2843 */
2848 }
2850 retry_lookup:
2851 /*
2852 * Check accessibility of directory.
2853 */
2864 fastpath:
2869 /*
2870 * If vnode is a device return special vnode instead.
2871 */
2876 cr);
2880 else
2885 /*
2886 * Compressed file, substitute dcfs vnode
2887 */
2892 else
2894 }
2895 }
2898 }
2903 out:
2905 }
2907 /*ARGSUSED*/
2908 static int
2912 {
2928 again:
2940 }
2946 /*
2947 * Null component name refers to the directory itself.
2948 */
2950 /*
2951 * Even though this is an error case, we need to grab the
2952 * quota lock since the error handling code below is common.
2953 */
2960 /*
2961 * ufs_tryirwlock_trans uses rw_tryenter and checks for SLOCK
2962 * to avoid i_rwlock, ufs_lockfs_begin deadlock. If deadlock
2963 * possible, retries the operation.
2964 */
2966 retry_dir);
2975 }
2983 }
2985 /*
2986 * Suppress file system full message if we will retry
2987 */
2995 }
2997 }
2999 }
3004 }
3005 }
3007 /*
3008 * If the file already exists and this is a non-exclusive create,
3009 * check permissions and allow access for non-directories.
3010 * Read-only create of an existing directory is also allowed.
3011 * We fail an exclusive create of anything which already exists.
3012 */
3022 else
3024 }
3030 }
3031 /*
3032 * If the error EEXIST was set, then i_seq can not
3033 * have been updated. The sequence number interface
3034 * is defined such that a non-error VOP_CREATE must
3035 * increase the dir va_seq it by at least one. If we
3036 * have cleared the error, increase i_seq. Note that
3037 * we are increasing the dir i_seq and in rare cases
3038 * ip may actually be from the dvp, so we already have
3039 * the locks and it will not be subject to truncation.
3040 * In case we have to update i_seq of the parent
3041 * directory dip, we have to defer it till we have
3042 * released our locks on ip due to lock ordering requirements.
3043 */
3046 else
3051 /*
3052 * Truncate regular files, if requested by caller.
3053 * Grab i_rwlock to make sure no one else is
3054 * currently writing to the file (we promised
3055 * bmap we would do this).
3056 * Must get the locks in the correct order.
3057 */
3063 /*
3064 * Large Files: Why this check here?
3065 * Though we do it in vn_create() we really
3066 * want to guarantee that we do not destroy
3067 * Large file data by atomically checking
3068 * the size while holding the contents
3069 * lock.
3070 */
3078 }
3080 truncflag++;
3086 retry_file);
3090 }
3092 RW_READER);
3095 cr);
3097 }
3099 }
3102 }
3103 }
3104 }
3110 }
3112 }
3119 /*
3120 * If vnode is a device return special vnode instead.
3121 */
3130 }
3133 }
3134 unlock:
3136 /*
3137 * Do the deferred update of the parent directory's sequence
3138 * number now.
3139 */
3146 }
3152 trans_size);
3154 /*
3155 * If we haven't had a more interesting failure
3156 * already, then anything that might've happened
3157 * here should be reported.
3158 */
3161 }
3170 }
3173 }
3178 /*
3179 * If no inodes available, try to free one up out of the
3180 * pending delete queue.
3181 */
3186 }
3188 out:
3190 }
3193 /*ARGSUSED*/
3194 static int
3197 {
3207 /*
3208 * don't let the delete queue get too long
3209 */
3213 }
3219 /* Only send the event if there were no errors */
3223 }
3225 retry_remove:
3234 /*
3235 * ufs_tryirwlock_trans uses rw_tryenter and checks for SLOCK
3236 * to avoid i_rwlock, ufs_lockfs_begin deadlock. If deadlock
3237 * possible, retries the operation.
3238 */
3249 }
3251 out:
3253 }
3255 /*
3256 * Link a file or a directory. Only privileged processes are allowed to
3257 * make links to directories.
3258 */
3259 /*ARGSUSED*/
3260 static int
3263 {
3275 retry_link:
3287 /*
3288 * Make sure link for extended attributes is valid
3289 * We only support hard linking of attr in ATTRDIR to ATTRDIR
3290 *
3291 * Make certain we don't attempt to look at a device node as
3292 * a ufs inode.
3293 */
3302 }
3310 }
3312 /*
3313 * ufs_tryirwlock_trans uses rw_tryenter and checks for SLOCK
3314 * to avoid i_rwlock, ufs_lockfs_begin deadlock. If deadlock
3315 * possible, retries the operation.
3316 */
3324 unlock:
3328 }
3332 }
3333 out:
3335 }
3342 /*
3343 * Rename a file or directory.
3344 * We are given the vnode and entry string of the source and the
3345 * vnode and entry string of the place we want to move the source
3346 * to (the target). The essential operation is:
3347 * unlink(target);
3348 * link(source, target);
3349 * unlink(source);
3350 * but "atomically". Can't do full commit without saving state in
3351 * the inode on disk, which isn't feasible at this time. Best we
3352 * can do is always guarantee that the TARGET exists.
3353 */
3355 /*ARGSUSED*/
3356 static int
3365 {
3376 timestruc_t now;
3399 /*
3400 * Notify the target directory of the rename event
3401 * if source and target directories are not the same.
3402 */
3408 }
3416 retry_rename:
3430 /*
3431 * We only allow renaming of attributes from ATTRDIR to ATTRDIR.
3432 */
3436 }
3438 /*
3439 * Check accessibility of directory.
3440 */
3444 /*
3445 * Look up inode of file we're supposed to rename.
3446 */
3454 }
3456 }
3459 }
3461 /*
3462 * Lock both the source and target directories (they may be
3463 * the same) to provide the atomicity semantics that was
3464 * previously provided by the per file system vfs_rename_lock
3465 *
3466 * with vfs_rename_lock removed to allow simultaneous renames
3467 * within a file system, ufs_dircheckpath can deadlock while
3468 * traversing back to ensure that source is not a parent directory
3469 * of target parent directory. This is because we get into
3470 * ufs_dircheckpath with the sdp and tdp locks held as RW_WRITER.
3471 * If the tdp and sdp of the simultaneous renames happen to be
3472 * in the path of each other, it can lead to a deadlock. This
3473 * can be avoided by getting the locks as RW_READER here and then
3474 * upgrading to RW_WRITER after completing the ufs_dircheckpath.
3475 *
3476 * We hold the target directory's i_rwlock after calling
3477 * ufs_lockfs_begin but in many other operations (like ufs_readdir)
3478 * VOP_RWLOCK is explicitly called by the filesystem independent code
3479 * before calling the file system operation. In these cases the order
3480 * is reversed (i.e i_rwlock is taken first and then ufs_lockfs_begin
3481 * is called). This is fine as long as ufs_lockfs_begin acts as a VOP
3482 * counter but with ufs_quiesce setting the SLOCK bit this becomes a
3483 * synchronizing object which might lead to a deadlock. So we use
3484 * rw_tryenter instead of rw_enter. If we fail to get this lock and
3485 * find that SLOCK bit is set, we call ufs_lockfs_end and restart the
3486 * operation.
3487 */
3488 retry:
3491 retry_firstlock:
3493 /*
3494 * We didn't get the lock. Check if the SLOCK is set in the
3495 * ufsvfs. If yes, we might be in a deadlock. Safer to give up
3496 * and wait for SLOCK to be cleared.
3497 */
3501 trans_size);
3506 /*
3507 * SLOCK isn't set so this is a genuine synchronization
3508 * case. Let's try again after giving them a breather.
3509 */
3512 }
3513 }
3514 /*
3515 * Need to check if the tdp and sdp are same !!!
3516 */
3518 /*
3519 * We didn't get the lock. Check if the SLOCK is set in the
3520 * ufsvfs. If yes, we might be in a deadlock. Safer to give up
3521 * and wait for SLOCK to be cleared.
3522 */
3527 trans_size);
3532 /*
3533 * So we couldn't get the second level peer lock *and*
3534 * the SLOCK bit isn't set. Too bad we can be
3535 * contentding with someone wanting these locks otherway
3536 * round. Reverse the locks in case there is a heavy
3537 * contention for the second level lock.
3538 */
3542 ufs_rename_retry_cnt++;
3544 }
3545 }
3550 }
3551 /*
3552 * Make sure we can delete the source entry. This requires
3553 * write permission on the containing directory.
3554 * Check for sticky directories.
3555 */
3563 }
3565 /*
3566 * If this is a rename of a directory and the parent is
3567 * different (".." must be changed), then the source
3568 * directory must not be in the directory hierarchy
3569 * above the target, as this would orphan everything
3570 * below the source directory. Also the user must have
3571 * write permission in the source so as to be able to
3572 * change "..".
3573 */
3576 ino_t inum;
3582 }
3587 /*
3588 * If we got EAGAIN ufs_dircheckpath detected a
3589 * potential deadlock and backed out. We need
3590 * to retry the operation since sdp and tdp have
3591 * to be released to avoid the deadlock.
3592 */
3598 ufs_rename_dircheck_retry_cnt++;
3600 }
3602 }
3606 }
3609 /*
3610 * Check for renaming '.' or '..' or alias of '.'
3611 */
3615 }
3617 /*
3618 * Simultaneous renames can deadlock in ufs_dircheckpath since it
3619 * tries to traverse back the file tree with both tdp and sdp held
3620 * as RW_WRITER. To avoid that we have to hold the tdp and sdp locks
3621 * as RW_READERS till ufs_dircheckpath is done.
3622 * Now that ufs_dircheckpath is done with, we can upgrade the locks
3623 * to RW_WRITER.
3624 */
3626 /*
3627 * The upgrade failed. We got to give away the lock
3628 * as to avoid deadlocking with someone else who is
3629 * waiting for writer lock. With the lock gone, we
3630 * cannot be sure the checks done above will hold
3631 * good when we eventually get them back as writer.
3632 * So if we can't upgrade we drop the locks and retry
3633 * everything again.
3634 */
3639 ufs_rename_upgrade_retry_cnt++;
3641 }
3644 /*
3645 * The upgrade failed. We got to give away the lock
3646 * as to avoid deadlocking with someone else who is
3647 * waiting for writer lock. With the lock gone, we
3648 * cannot be sure the checks done above will hold
3649 * good when we eventually get them back as writer.
3650 * So if we can't upgrade we drop the locks and retry
3651 * everything again.
3652 */
3656 ufs_rename_upgrade_retry_cnt++;
3658 }
3659 }
3661 /*
3662 * Now that all the locks are held check to make sure another thread
3663 * didn't slip in and take out the sip.
3664 */
3676 }
3681 /*
3682 * If the inode was found need to drop the v_count
3683 * so as not to keep the filesystem from being
3684 * unmounted at a later time.
3685 */
3687 }
3689 /*
3690 * Release the slot.fbp that has the page mapped and
3691 * locked SE_SHARED, and could be used in in
3692 * ufs_direnter_lr() which needs to get the SE_EXCL lock
3693 * on said page.
3694 */
3698 }
3699 }
3701 /*
3702 * Link source to the target.
3703 */
3705 /*
3706 * ESAME isn't really an error; it indicates that the
3707 * operation should not be done because the source and target
3708 * are the same file, but that no error should be reported.
3709 */
3713 }
3715 /*
3716 * Unlink the source.
3717 * Remove the source entry. ufs_dirremove() checks that the entry
3718 * still reflects sip, and returns an error if it doesn't.
3719 * If the entry has changed just forget about it. Release
3720 * the source inode.
3721 */
3726 errout:
3733 }
3737 unlock:
3741 }
3743 out:
3745 }
3747 /*ARGSUSED*/
3748 static int
3752 {
3765 /*
3766 * Can't make directory in attr hidden dir
3767 */
3771 again:
3781 /*
3782 * ufs_tryirwlock_trans uses rw_tryenter and checks for SLOCK
3783 * to avoid i_rwlock, ufs_lockfs_begin deadlock. If deadlock
3784 * possible, retries the operation.
3785 */
3795 trans_size);
3797 }
3799 }
3814 }
3815 out:
3820 }
3823 }
3825 /*ARGSUSED*/
3826 static int
3829 {
3839 /*
3840 * don't let the delete queue get too long
3841 */
3845 }
3851 /* Only send the event if there were no errors */
3855 }
3857 retry_rmdir:
3866 /*
3867 * ufs_tryirwlock_trans uses rw_tryenter and checks for SLOCK
3868 * to avoid i_rwlock, ufs_lockfs_begin deadlock. If deadlock
3869 * possible, retries the operation.
3870 */
3880 trans_size);
3882 }
3884 out:
3886 }
3888 /* ARGSUSED */
3889 static int
3897 {
3905 caddr_t outbuf;
3907 uint_t offset;
3920 }
3922 /*
3923 * Check if we have been called with a valid iov_len
3924 * and bail out if not, otherwise we may potentially loop
3925 * forever further down.
3926 */
3930 }
3932 /*
3933 * Large Files: When we come here we are guaranteed that
3934 * uio_offset can be used safely. The high word is zero.
3935 */
3945 /* Large Files: directory files should not be "large" */
3949 /* Force offset to be valid (to guard against bogus lseek() values) */
3952 /* Quit if at end of file or link count of zero (posix) */
3958 }
3960 /*
3961 * Get space to change directory entries into fs independent format.
3962 * Do fast alloc for the most commonly used-request size (filesystem
3963 * block size).
3964 */
3972 }
3974 nextblk:
3977 /* Truncate request to file size */
3981 /* Comply with MAXBSIZE boundary restrictions of fbread() */
3985 /*
3986 * Read in the next chunk.
3987 * We are still holding the i_rwlock.
3988 */
3996 }
4006 }
4007 /* Transform to file-system independent format */
4009 /*
4010 * If the current directory entry is mangled, then skip
4011 * to the next block. It would be nice to set the FSBAD
4012 * flag in the super-block so that a fsck is forced on
4013 * next reboot, but locking is a problem.
4014 */
4018 }
4020 /* Skip to requested offset and skip empty entries */
4022 ushort_t this_reclen =
4024 /* Buffer too small for any entries */
4029 }
4030 /* If would overrun the buffer, quit */
4033 }
4034 /* Take this entry */
4039 /* use strncpy(9f) to zero out uninitialized bytes */
4049 }
4057 }
4058 }
4059 /* Release the chunk */
4062 /* Read whole block, but got no entries, read another if not eof */
4064 /*
4065 * Large Files: casting i_size to int here is not a problem
4066 * because directory sizes are always less than MAXOFF32_T.
4067 * See assertion above.
4068 */
4073 /* Copy out the entry data */
4082 update_inode:
4089 unlock:
4092 }
4093 out:
4095 }
4097 /*ARGSUSED*/
4098 static int
4107 {
4118 /*
4119 * No symlinks in attrdirs at this time
4120 */
4124 again:
4137 /*
4138 * We must create the inode before the directory entry, to avoid
4139 * racing with readlink(). ufs_dirmakeinode requires that we
4140 * hold the quota lock as reader, and directory locks as writer.
4141 */
4147 /*
4148 * Suppress any out of inodes messages if we will retry on
4149 * ENOSP
4150 */
4165 /*
4166 * OK. The inode has been created. Write out the data of the
4167 * symbolic link. Since symbolic links are metadata, and should
4168 * remain consistent across a system crash, we need to force the
4169 * data out synchronously.
4170 *
4171 * (This is a change from the semantics in earlier releases, which
4172 * only created symbolic links synchronously if the semi-documented
4173 * 'syncdir' option was set, or if we were being invoked by the NFS
4174 * server, which requires symbolic links to be created synchronously.)
4175 *
4176 * We need to pass in a pointer for the residual length; otherwise
4177 * ufs_rdwri() will always return EIO if it can't write the data,
4178 * even if the error was really ENOSPC or EDQUOT.
4179 */
4187 /*
4188 * Suppress file system full messages if we will retry
4189 */
4202 }
4204 /*
4205 * If the link's data is small enough, we can cache it in the inode.
4206 * This is a "fast symbolic link". We don't use the first direct
4207 * block because that's actually used to point at the symbolic link's
4208 * contents on disk; but we know that none of the other direct or
4209 * indirect blocks can be used because symbolic links are restricted
4210 * to be smaller than a file system block.
4211 */
4220 /* error, clear garbage left behind */
4225 }
4226 }
4231 /*
4232 * OK. We've successfully created the symbolic link. All that
4233 * remains is to insert it into the appropriate directory.
4234 */
4240 /*
4241 * Fall through into remove-on-error code. We're either done, or we
4242 * need to remove the inode (if we couldn't insert it).
4243 */
4245 remove:
4253 }
4255 unlock:
4263 trans_size);
4267 }
4269 /*
4270 * We may have failed due to lack of an inode or of a block to
4271 * store the target in. Try flushing the delete queue to free
4272 * logically-available things up and try again.
4273 */
4278 }
4280 out:
4282 }
4284 /*
4285 * Ufs specific routine used to do ufs io.
4286 */
4287 int
4291 {
4319 }
4325 }
4327 }
4329 /*ARGSUSED*/
4330 static int
4332 {
4342 }
4351 }
4353 /* ARGSUSED2 */
4354 static int
4356 {
4361 /*
4362 * Read case is easy.
4363 */
4367 }
4369 /*
4370 * Caller has requested a writer lock, but that inhibits any
4371 * concurrency in the VOPs that follow. Acquire the lock shared
4372 * and defer exclusive access until it is known to be needed in
4373 * other VOP handlers. Some cases can be determined here.
4374 */
4376 /*
4377 * If directio is not set, there is no chance of concurrency,
4378 * so just acquire the lock exclusive. Beware of a forced
4379 * unmount before looking at the mount option.
4380 */
4387 }
4389 /*
4390 * Mandatory locking forces acquiring i_rwlock exclusive.
4391 */
4395 }
4397 /*
4398 * Acquire the lock shared in case a concurrent write follows.
4399 * Mandatory locking could have become enabled before the lock
4400 * was acquired. Re-check and upgrade if needed.
4401 */
4407 }
4409 }
4411 /*ARGSUSED*/
4412 static void
4414 {
4418 }
4420 /* ARGSUSED */
4421 static int
4424 {
4426 }
4428 /* ARGSUSED */
4429 static int
4433 {
4439 /*
4440 * If file is being mapped, disallow frlock.
4441 * XXX I am not holding tlock while checking i_mapcnt because the
4442 * current locking strategy drops all locks before calling fs_frlock.
4443 * So, mapcnt could change before we enter fs_frlock making is
4444 * meaningless to have held tlock in the first place.
4445 */
4449 }
4451 /* ARGSUSED */
4452 static int
4455 {
4463 ULOCKFS_SPACE_MASK);
4472 ULOCKFS_FALLOCATE_MASK);
4482 }
4484 }
4486 /*
4487 * Used to determine if read ahead should be done. Also used to
4488 * to determine when write back occurs.
4489 */
4490 #define CLUSTSZ(ip) ((ip)->i_ufsvfs->vfs_ioclustsz)
4492 /*
4493 * A faster version of ufs_getpage.
4494 *
4495 * We optimize by inlining the pvn_getpages iterator, eliminating
4496 * calls to bmap_read if file doesn't have UFS holes, and avoiding
4497 * the overhead of page_exists().
4498 *
4499 * When files has UFS_HOLES and ufs_getpage is called with S_READ,
4500 * we set *protp to PROT_READ to avoid calling bmap_read. This approach
4501 * victimizes performance when a file with UFS holes is faulted
4502 * first in the S_READ mode, and then in the S_WRITE mode. We will get
4503 * two MMU faults in this case.
4504 *
4505 * XXX - the inode fields which control the sequential mode are not
4506 * protected by any mutex. The read ahead will act wild if
4507 * multiple processes will access the file concurrently and
4508 * some of them in sequential mode. One particulary bad case
4509 * is if another thread will change the value of i_nextrio between
4510 * the time this thread tests the i_nextrio value and then reads it
4511 * again to use it as the offset for the read ahead.
4512 */
4513 /*ARGSUSED*/
4514 static int
4518 {
4520 u_offset_t pgoff;
4521 u_offset_t eoff;
4527 caddr_t pgaddr;
4528 krw_t rwtype;
4543 /*
4544 * Obey the lockfs protocol
4545 */
4555 /*
4556 * Try to start a transaction, will return if blocking is
4557 * expected to occur and the address space is not the
4558 * kernel address space.
4559 */
4565 /*
4566 * Use EDEADLK here because the VM code
4567 * can normally never see this error.
4568 */
4572 }
4575 }
4576 }
4581 }
4587 /*
4588 * If this thread owns the lock, i.e., this thread grabbed it
4589 * as writer somewhere above, then we don't need to grab the
4590 * lock as reader in this routine.
4591 */
4594 retrylock:
4596 /*
4597 * Grab the quota lock if we need to call
4598 * bmap_write() below (with i_contents as writer).
4599 */
4603 }
4605 /*
4606 * We may be getting called as a side effect of a bmap using
4607 * fbread() when the blocks might be being allocated and the
4608 * size has not yet been up'ed. In this case we want to be
4609 * able to return zero pages if we get back UFS_HOLE from
4610 * calling bmap for a non write case here. We also might have
4611 * to read some frags from the disk into a page if we are
4612 * extending the number of frags for a given lbn in bmap().
4613 * Large Files: The read of i_size here is atomic because
4614 * i_contents is held here. If dolock is zero, the lock
4615 * is held in bmap routines.
4616 */
4624 }
4627 }
4629 /*
4630 * Must hold i_contents lock throughout the call to pvn_getpages
4631 * since locked pages are returned from each call to ufs_getapage.
4632 * Must *not* return locked pages and then try for contents lock
4633 * due to lock ordering requirements (inode > page)
4634 */
4640 u_offset_t offset;
4642 /*
4643 * We must acquire the RW_WRITER lock in order to
4644 * call bmap_write().
4645 */
4649 /*
4650 * Grab the quota lock before
4651 * upgrading i_contents, but if we can't grab it
4652 * don't wait here due to lock order:
4653 * vfs_dqrwlock > i_contents.
4654 */
4660 }
4666 }
4667 }
4669 /*
4670 * May be allocating disk blocks for holes here as
4671 * a result of mmap faults. write(2) does the bmap_write
4672 * in rdip/wrip, not here. We are not dealing with frags
4673 * in this case.
4674 */
4675 /*
4676 * Large Files: We cast fs_bmask field to offset_t
4677 * just as we do for MAXBMASK because uoff is a 64-bit
4678 * data type. fs_bmask will still be a 32-bit type
4679 * as we cannot change any ondisk data structures.
4680 */
4692 }
4693 }
4695 /*
4696 * Can be a reader from now on.
4697 */
4700 /*
4701 * We can release vfs_dqrwlock early so do it, but make
4702 * sure we don't try to release it again at the bottom.
4703 */
4707 }
4708 }
4710 /*
4711 * We remove PROT_WRITE in cases when the file has UFS holes
4712 * because we don't want to call bmap_read() to check each
4713 * page if it is backed with a disk block.
4714 */
4720 /*
4721 * The loop looks up pages in the range [off, off + len).
4722 * For each page, we first check if we should initiate an asynchronous
4723 * read ahead before we call page_lookup (we may sleep in page_lookup
4724 * for a previously initiated disk read).
4725 */
4730 u_offset_t nextrio;
4731 se_t se;
4736 /* Handle async getpage (faultahead) */
4743 }
4744 /*
4745 * Check if we should initiate read ahead of next cluster.
4746 * We call page_exists only when we need to confirm that
4747 * we have the current page before we initiate the read ahead.
4748 */
4754 /*
4755 * We always read ahead the next cluster of data
4756 * starting from i_nextrio. If the page (vp,nextrio)
4757 * is actually in core at this point, the routine
4758 * ufs_getpage_ra() will stop pre-fetching data
4759 * until we read that page in a synchronized manner
4760 * through ufs_getpage_miss(). So, we should increase
4761 * i_nextrio if the page (vp, nextrio) exists.
4762 */
4765 }
4766 }
4769 /*
4770 * We found the page in the page cache.
4771 */
4778 /*
4779 * We have to create the page, or read it from disk.
4780 */
4786 pl++;
4791 }
4792 }
4793 }
4795 /*
4796 * Return pages up to plsz if they are in the page cache.
4797 * We cannot return pages if there is a chance that they are
4798 * backed with a UFS hole and rw is S_WRITE or S_CREATE.
4799 */
4816 }
4817 }
4823 error:
4825 /*
4826 * Release any pages we have locked.
4827 */
4832 }
4834 update_inode:
4835 /*
4836 * If the inode is not already marked for IACC (in rdip() for read)
4837 * and the inode is not marked for no access time update (in wrip()
4838 * for write) then update the inode access time and mod time now.
4839 */
4849 }
4850 }
4851 }
4857 }
4859 unlock:
4864 }
4866 }
4867 out:
4869 }
4871 /*
4872 * ufs_getpage_miss is called when ufs_getpage missed the page in the page
4873 * cache. The page is either read from the disk, or it's created.
4874 * A page is created (without disk read) if rw == S_CREATE, or if
4875 * the page is not backed with a real disk block (UFS hole).
4876 */
4877 /* ARGSUSED */
4878 static int
4881 {
4884 daddr_t bn;
4891 /*
4892 * Figure out whether the page can be created, or must be
4893 * must be read from the disk.
4894 */
4904 /*
4905 * If its also a fallocated block that hasn't been written to
4906 * yet, we will treat it just like a UFS_HOLE and create
4907 * a zero page for it
4908 */
4911 }
4918 }
4925 u_offset_t io_off;
4926 uint_t xlen;
4930 /*
4931 * If access is not in sequential order, we read from disk
4932 * in bsize units.
4933 *
4934 * We limit the size of the transfer to bsize if we are reading
4935 * from the beginning of the file. Note in this situation we
4936 * will hedge our bets and initiate an async read ahead of
4937 * the second block.
4938 */
4945 /*
4946 * Some other thread has entered the page.
4947 * ufs_getpage will retry page_lookup.
4948 */
4952 }
4954 /*
4955 * Zero part of the page which we are not
4956 * going to read from the disk.
4957 */
4979 }
4983 /*
4984 * If the file access is sequential, initiate read ahead
4985 * of the next cluster.
4986 */
4995 }
4996 }
5000 }
5002 /*
5003 * Read ahead a cluster from the disk. Returns the length in bytes.
5004 */
5005 static int
5007 {
5014 daddr_t bn;
5021 /*
5022 * If the directio advisory is in effect on this file,
5023 * then do not do buffered read ahead. Read ahead makes
5024 * it more difficult on threads using directio as they
5025 * will be forced to flush the pages from this vnode.
5026 */
5032 /*
5033 * Is this test needed?
5034 */
5040 /*
5041 * If its a UFS_HOLE or a fallocated block, do not perform
5042 * any read ahead's since there probably is nothing to read ahead
5043 */
5047 /*
5048 * Limit the transfer size to bsize if this is the 2nd block.
5049 */
5057 /*
5058 * Zero part of page which we are not going to read from disk
5059 */
5082 }
5085 }
5088 /*
5089 * Flags are composed of {B_INVAL, B_FREE, B_DONTNEED, B_FORCE, B_ASYNC}
5090 *
5091 * LMXXX - the inode really ought to contain a pointer to one of these
5092 * async args. Stuff gunk in there and just hand the whole mess off.
5093 * This would replace i_delaylen, i_delayoff.
5094 */
5095 /*ARGSUSED*/
5096 static int
5099 {
5105 }
5107 /*
5108 * XXX - Why should this check be made here?
5109 */
5113 }
5118 }
5124 /*
5125 * If nobody stalled, start a new cluster.
5126 */
5132 }
5133 /*
5134 * If we have a full cluster or they are not contig,
5135 * then push last cluster and start over.
5136 */
5139 u_offset_t doff;
5149 /* LMXXX - flags are new val, not old */
5151 }
5152 /*
5153 * There is something there, it's not full, and
5154 * it is contig.
5155 */
5159 }
5160 /*
5161 * Must have weird flags or we are not clustering.
5162 */
5163 }
5167 errout:
5169 }
5171 /*
5172 * If len == 0, do from off to EOF.
5173 *
5174 * The normal cases should be len == 0 & off == 0 (entire vp list),
5175 * len == MAXBSIZE (from segmap_release actions), and len == PAGESIZE
5176 * (from pageout).
5177 */
5178 /*ARGSUSED*/
5179 static int
5182 offset_t off,
5186 {
5187 u_offset_t io_off;
5188 u_offset_t eoff;
5197 /*
5198 * Acquire the readers/write inode lock before locking
5199 * any pages in this inode.
5200 * The inode lock is held during i/o.
5201 */
5206 }
5209 /*
5210 * Must synchronize this thread and any possible thread
5211 * operating in the window of vulnerability in wrip().
5212 * It is dangerous to allow both a thread doing a putpage
5213 * and a thread writing, so serialize them. The exception
5214 * is when the thread in wrip() does something which causes
5215 * a putpage operation. Then, the thread must be allowed
5216 * to continue. It may encounter a bmap_read problem in
5217 * ufs_putapage, but that is handled in ufs_putapage.
5218 * Allow async writers to proceed, we don't want to block
5219 * the pageout daemon.
5220 */
5227 /*
5228 * If there is no thread in the critical
5229 * section of wrip(), then proceed.
5230 * Otherwise, wait until there isn't one.
5231 */
5235 }
5237 /*
5238 * Bounce async writers when we have a writer
5239 * working on this file so we don't deadlock
5240 * the pageout daemon.
5241 */
5245 }
5248 }
5249 }
5250 }
5256 }
5259 /*
5260 * Search the entire vp list for pages >= off.
5261 */
5265 /*
5266 * Loop over all offsets in the range looking for
5267 * pages to deal with.
5268 */
5271 else
5275 /*
5276 * If we are not invalidating, synchronously
5277 * freeing or writing pages, use the routine
5278 * page_lookup_nowait() to prevent reclaiming
5279 * them from the free list.
5280 */
5288 }
5299 /*
5300 * "io_off" and "io_len" are returned as
5301 * the range of pages we actually wrote.
5302 * This allows us to skip ahead more quickly
5303 * since several pages may've been dealt
5304 * with by this iteration of the loop.
5305 */
5306 }
5307 }
5308 }
5310 /*
5311 * We have just sync'ed back all the pages on
5312 * the inode, turn off the IMODTIME flag.
5313 */
5317 }
5321 }
5323 static void
5325 {
5341 }
5345 }
5347 /*
5348 * Write out a single page, possibly klustering adjacent
5349 * dirty pages. The inode lock must be held.
5350 *
5351 * LMXXX - bsize < pagesize not done.
5352 */
5353 /*ARGSUSED*/
5354 int
5362 {
5363 u_offset_t io_off;
5364 u_offset_t off;
5370 daddr_t bn;
5380 }
5385 /*
5386 * If the modified time on the inode has not already been
5387 * set elsewhere (e.g. for write/setattr) we set the time now.
5388 * This gives us approximate modified times for mmap'ed files
5389 * which are modified via stores in the user address space.
5390 */
5397 }
5399 /*
5400 * Align the request to a block boundry (for old file systems),
5401 * and go ask bmap() how contiguous things are for this file.
5402 */
5409 /*
5410 * logging device is in error mode; simply return EIO
5411 */
5415 }
5416 /*
5417 * Oops, the thread in the window in wrip() did some
5418 * sort of operation which caused a putpage in the bad
5419 * range. In this case, just return an error which will
5420 * cause the software modified bit on the page to set
5421 * and the page will get written out again later.
5422 */
5426 }
5427 /*
5428 * If the pager is trying to push a page in the bad range
5429 * just tell him to try again later when things are better.
5430 */
5434 }
5437 }
5439 /*
5440 * If it is an fallocate'd block, reverse the negativity since
5441 * we are now writing to it
5442 */
5449 }
5451 /*
5452 * Take the length (of contiguous bytes) passed back from bmap()
5453 * and _try_ and get a set of pages covering that extent.
5454 */
5457 /*
5458 * May have run out of memory and not clustered backwards.
5459 * off p_offset
5460 * [ pp - 1 ][ pp ]
5461 * [ block ]
5462 * We told bmap off, so we have to adjust the bn accordingly.
5463 */
5467 }
5469 /*
5470 * bmap was carefull to tell us the right size so use that.
5471 * There might be unallocated frags at the end.
5472 * LMXXX - bzero the end of the page? We must be writing after EOF.
5473 */
5477 }
5479 /*
5480 * Handle the case where we are writing the last page after EOF.
5481 *
5482 * XXX - just a patch for i-mt3.
5483 */
5488 }
5500 /*
5501 * File contents of shadow or quota inodes are metadata, and updates
5502 * to these need to be put into a logging transaction. All direct
5503 * callers in UFS do that, but fsflush can come here _before_ the
5504 * normal codepath. An example would be updating ACL information, for
5505 * which the normal codepath would be:
5506 * ufs_si_store()
5507 * ufs_rdwri()
5508 * wrip()
5509 * segmap_release()
5510 * VOP_PUTPAGE()
5511 * Here, fsflush can pick up the dirty page before segmap_release()
5512 * forces it out. If that happens, there's no transaction.
5513 * We therefore need to test whether a transaction exists, and if not
5514 * create one - for fsflush.
5515 */
5516 dotrans =
5524 }
5531 }
5532 }
5536 }
5538 /* write throttle */
5556 }
5567 }
5571 }
5575 out:
5583 out_trace:
5585 }
5590 /* ARGSUSED */
5591 static int
5593 offset_t off,
5597 uchar_t prot,
5598 uchar_t maxprot,
5599 uint_t flags,
5602 {
5607 k_sigset_t smask;
5613 }
5618 }
5623 }
5625 retry_map:
5627 /*
5628 * If file is being locked, disallow mapping.
5629 */
5633 }
5636 /*
5637 * Note that if we are retrying (because ufs_lockfs_trybegin failed in
5638 * the previous attempt), some other thread could have grabbed
5639 * the same VA range if MAP_FIXED is set. In that case, choose_addr
5640 * would unmap the valid VA range, that is ok.
5641 */
5646 }
5648 /*
5649 * a_lock has to be acquired before entering the lockfs protocol
5650 * because that is the order in which pagefault works. Also we cannot
5651 * block on a_lock here because this waiting writer will prevent
5652 * further readers like ufs_read from progressing and could cause
5653 * deadlock between ufs_read/ufs_map/pagefault when a quiesce is
5654 * pending.
5655 */
5657 ufs_map_alock_retry_cnt++;
5659 }
5661 /*
5662 * We can't hold as->a_lock and wait for lockfs to succeed because
5663 * the proc tools might hang on a_lock, so call ufs_lockfs_trybegin()
5664 * instead.
5665 */
5667 /*
5668 * ufs_lockfs_trybegin() did not succeed. It is safer to give up
5669 * as->a_lock and wait for ulp->ul_fs_lock status to change.
5670 */
5671 ufs_map_lockfs_retry_cnt++;
5689 }
5690 }
5691 }
5694 }
5711 out:
5713 }
5715 /* ARGSUSED */
5716 static int
5718 offset_t off,
5720 caddr_t addr,
5722 uchar_t prot,
5723 uchar_t maxprot,
5724 uint_t flags,
5727 {
5732 }
5738 }
5740 /*ARGSUSED*/
5741 static int
5745 {
5750 }
5757 }
5758 /*
5759 * Return the answer requested to poll() for non-device files
5760 */
5763 /* ARGSUSED */
5764 int
5767 {
5776 }
5799 }
5803 out:
5807 }
5809 /* ARGSUSED */
5810 static int
5813 {
5826 /*
5827 * Have to handle _PC_NAME_MAX here, because the normal way
5828 * [fs_pathconf() -> VOP_STATVFS() -> ufs_statvfs()]
5829 * results in a lock ordering reversal between
5830 * ufs_lockfs_{begin,end}() and
5831 * ufs_thread_{suspend,continue}().
5832 *
5833 * Keep in sync with ufs_statvfs().
5834 */
5842 else
5849 error =
5852 /* Start transaction */
5856 }
5857 /*
5858 * Is directory empty
5859 */
5877 }
5882 }
5885 }
5903 /*
5904 * UFS keeps only microsecond timestamp resolution.
5905 * This is historical and will probably never change.
5906 */
5913 }
5917 }
5919 }
5923 /*ARGSUSED*/
5924 static int
5927 {
5932 daddr_t bn;
5943 }
5946 /*
5947 * We need a better check. Ideally, we would use another
5948 * vnodeops so that hlocked and forcibly unmounted file
5949 * systems would return EIO where appropriate and w/o the
5950 * need for these checks.
5951 */
5955 /*
5956 * For vmpss (pp can be NULL) case respect the quiesce protocol.
5957 * ul_lock must be taken before locking pages so we can't use it here
5958 * if pp is non NULL because segvn already locked pages
5959 * SE_EXCL. Instead we rely on the fact that a forced umount or
5960 * applying a filesystem lock via ufs_fiolfs() will block in the
5961 * implicit call to ufs_flush() until we unlock the pages after the
5962 * return to segvn. Other ufs_quiesce() callers keep ufs_quiesce_pend
5963 * above 0 until they are done. We have to be careful not to increment
5964 * ul_vnops_cnt here after forceful unmount hlocks the file system.
5965 *
5966 * If pp is NULL use ul_lock to make sure we don't increment
5967 * ul_vnops_cnt after forceful unmount hlocks the file system.
5968 */
5976 }
5978 }
5986 }
5987 }
5990 /*
5991 * segvn may call VOP_PAGEIO() instead of VOP_GETPAGE() to
5992 * handle a fault against a segment that maps vnode pages with
5993 * large mappings. Segvn creates pages and holds them locked
5994 * SE_EXCL during VOP_PAGEIO() call. In this case we have to
5995 * use rw_tryenter() to avoid a potential deadlock since in
5996 * lock order i_contents needs to be taken first.
5997 * Segvn will retry via VOP_GETPAGE() if VOP_PAGEIO() fails.
5998 */
6005 }
6006 }
6008 /*
6009 * Return an error to segvn because the pagefault request is beyond
6010 * PAGESIZE rounded EOF.
6011 */
6018 }
6025 }
6031 }
6033 /*
6034 * Break the io request into chunks, one for each contiguous
6035 * stretch of disk blocks in the target file.
6036 */
6048 }
6051 }
6054 /*
6055 * Zero out a page beyond EOF, when the last block of
6056 * a file is a UFS fragment so that ufs_pageio() can be used
6057 * instead of ufs_getpage() to handle faults against
6058 * segvn segments that use large pages.
6059 */
6064 }
6079 else
6083 ufs_pageio_reads++;
6084 else
6085 ufs_pageio_writes++;
6088 else
6090 /*
6091 * If the request is not B_ASYNC, wait for i/o to complete
6092 * and re-assemble the page list to return to the caller.
6093 * If it is B_ASYNC we leave the page list in pieces and
6094 * cleanup() will dispose of them.
6095 */
6102 }
6108 }
6112 /* Cleanup unprocessed parts of list */
6116 else
6119 /* Re-assemble list and let caller clean up */
6122 }
6123 }
6131 }
6138 }
6140 /*
6141 * Called when the kernel is in a frozen state to dump data
6142 * directly to the device. It uses a private dump data structure,
6143 * set up by dump_ctl, to locate the correct disk block to which to dump.
6144 */
6145 /*ARGSUSED*/
6146 static int
6149 {
6150 u_offset_t file_size;
6158 /*
6159 * forced unmount case
6160 */
6163 /*
6164 * Validate the inode that it has not been modified since
6165 * the dump structure is allocated.
6166 */
6174 }
6177 /*
6178 * See that the file has room for this write
6179 */
6185 /*
6186 * Find the physical disk block numbers from the dump
6187 * private data structure directly and write out the data
6188 * in contiguous block lumps
6189 */
6197 nfsbs++;
6199 }
6206 }
6209 }
6211 /*
6212 * Prepare the file system before and after the dump operation.
6213 *
6214 * action = DUMP_ALLOC:
6215 * Preparation before dump, allocate dump private data structure
6216 * to hold all the direct and indirect block info for dump.
6217 *
6218 * action = DUMP_FREE:
6219 * Clean up after dump, deallocate the dump private data structure.
6220 *
6221 * action = DUMP_SCAN:
6222 * Scan dump_info for *blkp DEV_BSIZE blocks of contig fs space;
6223 * if found, the starting file-relative DEV_BSIZE lbn is written
6224 * to *bklp; that lbn is intended for use with VOP_DUMP()
6225 */
6226 /*ARGSUSED*/
6227 static int
6229 {
6239 /*
6240 * check for forced unmount
6241 */
6246 /*
6247 * alloc and record dump_info
6248 */
6260 }
6262 /*
6263 * calculate and allocate space needed according to i_size
6264 */
6271 }
6273 /* Start saving the info */
6278 /* Direct Blocks */
6282 /* Indirect Blocks */
6295 }
6305 }
6306 }
6307 /* and time stamp the information */
6314 /*
6315 * free dump_info
6316 */
6324 /*
6325 * scan dump_info
6326 */
6336 /*
6337 * scan dblk[] entries; contig fs space is found when:
6338 * ((current blkno + frags per block) == next blkno)
6339 */
6343 n++;
6344 else
6346 dblk++;
6347 nextblk++;
6348 }
6350 /*
6351 * index is where size bytes of contig space begins;
6352 * conversion from index to the file's DEV_BSIZE lbn
6353 * is equivalent to: (index * fs_bsize) / DEV_BSIZE
6354 */
6360 }
6362 }
6364 /*
6365 * Recursive helper function for ufs_dumpctl(). It follows the indirect file
6366 * system blocks until it reaches the the disk block addresses, which are
6367 * then stored into the given buffer, storeblk.
6368 */
6372 {
6382 }
6384 }
6393 }
6400 }
6402 }
6404 /* ARGSUSED */
6405 static int
6408 {
6417 /*
6418 * Only grab locks if needed - they're not needed to check vsa_mask
6419 * or if the mask contains no acl flags.
6420 */
6423 ULOCKFS_GETATTR_MASK))
6432 }
6434 }
6436 /* ARGSUSED */
6437 static int
6440 {
6453 /* Abort now if the request is either empty or invalid. */
6460 }
6462 /*
6463 * Following convention, if this is a directory then we acquire the
6464 * inode's i_rwlock after starting a UFS logging transaction;
6465 * otherwise, we acquire it beforehand. Since we were called (and
6466 * must therefore return) with the lock held, we will have to drop it,
6467 * and later reacquire it, if operating on a directory.
6468 */
6473 /* Upgrade the lock if required. */
6477 }
6478 }
6480 again:
6486 }
6488 /*
6489 * Check that the file system supports this operation. Note that
6490 * ufs_lockfs_begin() will have checked that the file system had
6491 * not been forcibly unmounted.
6492 */
6496 }
6500 }
6506 }
6511 }
6515 /* Do the actual work. */
6517 /*
6518 * Suppress out of inodes messages if we will retry.
6519 */
6526 out:
6529 /*
6530 * top_end_async() can eventually call
6531 * top_end_sync(), which can block. We must
6532 * therefore observe the lock-ordering protocol
6533 * here as well.
6534 */
6538 }
6540 }
6542 }
6543 /*
6544 * If no inodes available, try scaring a logically-
6545 * free one out of the delete queue to someplace
6546 * that we can find it.
6547 */
6554 }
6556 }
6557 /*
6558 * If we need to reacquire the lock then it is safe to do so
6559 * as a reader. This is because ufs_rwunlock(), which will be
6560 * called by our caller after we return, does not differentiate
6561 * between shared and exclusive locks.
6562 */
6566 }
6569 }
6571 /*
6572 * Locate the vnode to be used for an event notification. As this will
6573 * be called prior to the name space change perform basic verification
6574 * that the change will be allowed.
6575 */
6577 static int
6580 {
6600 }
6601 }
6603 /*
6604 * Check accessibility and write access of parent directory as we
6605 * only want to post the event if we're able to make a change.
6606 */
6614 }
6618 }
6620 /*
6621 * Keep the idle queue from getting too long by idling two
6622 * inodes before attempting to allocate another.
6623 * This operation must be performed before entering lockfs
6624 * or a transaction.
6625 */
6630 }
6634 retry_lookup:
6641 }
6645 }
6651 }