| blob | fe4015adffb96ba996cbf8762decb5d8c9663b4d |
1 /*
2 * Copyright (c) 2007-2008 The DragonFly Project. All rights reserved.
3 *
4 * This code is derived from software contributed to The DragonFly Project
5 * by Matthew Dillon <dillon@backplane.com>
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 *
11 * 1. Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in
15 * the documentation and/or other materials provided with the
16 * distribution.
17 * 3. Neither the name of The DragonFly Project nor the names of its
18 * contributors may be used to endorse or promote products derived
19 * from this software without specific, prior written permission.
20 *
21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
24 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
25 * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
26 * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
27 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
28 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
29 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
30 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
31 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
32 * SUCH DAMAGE.
33 */
35 #include <sys/mountctl.h>
36 #include <sys/namecache.h>
37 #include <sys/buf2.h>
38 #include <vfs/fifofs/fifo.h>
42 /*
43 * USERFS VNOPS
44 */
116 };
130 };
145 };
147 static __inline
148 void
150 {
153 }
161 /*
162 * hammer_vop_fsync { vp, waitfor }
163 *
164 * fsync() an inode to disk and wait for it to be completely committed
165 * such that the information would not be undone if a crash occured after
166 * return.
167 *
168 * NOTE: HAMMER's fsync()'s are going to remain expensive until we implement
169 * a REDO log. A sysctl is provided to relax HAMMER's fsync()
170 * operation.
171 *
172 * Ultimately the combination of a REDO log and use of fast storage
173 * to front-end cluster caches will make fsync fast, but it aint
174 * here yet. And, in anycase, we need real transactional
175 * all-or-nothing features which are not restricted to a single file.
176 */
177 static
178 int
180 {
188 /*
189 * Fsync rule relaxation (default is either full synchronous flush
190 * or REDO semantics with synchronous flush).
191 */
195 mode0:
196 /* no REDO, full synchronous flush */
199 mode1:
200 /* no REDO, full asynchronous flush */
205 /* REDO semantics, synchronous flush */
211 /* REDO semantics, relaxed asynchronous flush */
219 /* ignore the fsync() system call */
223 /* we have to do something */
228 }
230 /*
231 * Fast fsync only needs to flush the UNDO/REDO fifo if
232 * HAMMER_INODE_REDO is non-zero and the only modifications
233 * made to the file are write or write-extends.
234 */
244 }
246 /*
247 * REDO is enabled by fsync(), the idea being we really only
248 * want to lay down REDO records when programs are using
249 * fsync() heavily. The first fsync() on the file starts
250 * the gravy train going and later fsync()s keep it hot by
251 * resetting the redo_count.
252 *
253 * We weren't running REDOs before now so we have to fall
254 * through and do a full fsync of what we have.
255 */
260 }
261 }
262 skip:
264 /*
265 * Do a full flush sequence.
266 *
267 * Attempt to release the vnode while waiting for the inode to
268 * finish flushing. This can really mess up inactive->reclaim
269 * sequences so only do it if the vnode is active.
270 *
271 * WARNING! The VX lock functions must be used. vn_lock() will
272 * fail when this is part of a VOP_RECLAIM sequence.
273 */
285 }
289 }
294 }
296 /*
297 * hammer_vop_read { vp, uio, ioflag, cred }
298 *
299 * MPSAFE (for the cache safe does not require fs_token)
300 */
301 static
302 int
304 {
306 hammer_inode_t ip;
307 hammer_mount_t hmp;
308 off_t offset;
328 /*
329 * Attempt to shortcut directly to the VM object using lwbufs.
330 * This is much faster than instantiating buffer cache buffers.
331 */
340 /*
341 * Allow the UIO's size to override the sequential heuristic.
342 */
349 /*
350 * If reading or writing a huge amount of data we have to break
351 * atomicy and allow the operation to be interrupted by a signal
352 * or it can DOS the machine.
353 */
356 /*
357 * Access the data typically in HAMMER_BUFSIZE blocks via the
358 * buffer cache, but HAMMER may use a variable block size based
359 * on the offset.
360 *
361 * XXX Temporary hack, delay the start transaction while we remain
362 * MPSAFE. NOTE: ino_data.size cannot change while vnode is
363 * locked-shared.
364 */
376 /*
377 * MPSAFE
378 */
384 }
388 }
390 /*
391 * MPUNSAFE
392 */
396 }
398 /*
399 * NOTE: A valid bp has already been acquired, but was not
400 * B_CACHE.
401 */
403 /*
404 * Use file_limit to prevent cluster_read() from
405 * creating buffers of the wrong block size past
406 * the demarc.
407 */
412 }
423 }
427 }
428 skip:
434 }
445 /*
446 * Set B_AGE, data has a lower priority than meta-data.
447 *
448 * Use a hold/unlock/drop sequence to run the uiomove
449 * with the buffer unlocked, avoiding deadlocks against
450 * read()s on mmap()'d spaces.
451 */
459 }
461 finished:
463 /*
464 * Try to update the atime with just the inode lock for maximum
465 * concurrency. If we can't shortcut it we have to get the full
466 * blown transaction.
467 */
471 }
483 }
484 }
486 }
488 /*
489 * hammer_vop_write { vp, uio, ioflag, cred }
490 */
491 static
492 int
494 {
496 hammer_inode_t ip;
497 hammer_mount_t hmp;
498 thread_t td;
502 off_t base_offset;
524 /*
525 * Create a transaction to cover the operations we perform.
526 */
530 /*
531 * Use v_lastwrite_ts if file not open for writing
532 * (i.e. a late msync)
533 */
540 }
543 }
545 /*
546 * Check append mode
547 */
551 /*
552 * Check for illegal write offsets. Valid range is 0...2^63-1.
553 *
554 * NOTE: the base_off assignment is required to work around what
555 * I consider to be a GCC-4 optimization bug.
556 */
560 }
565 }
572 }
574 /*
575 * If reading or writing a huge amount of data we have to break
576 * atomicy and allow the operation to be interrupted by a signal
577 * or it can DOS the machine.
578 *
579 * Preset redo_count so we stop generating REDOs earlier if the
580 * limit is exceeded.
581 *
582 * redo_count is heuristical, SMP races are ok
583 */
588 }
590 /*
591 * Access the data typically in HAMMER_BUFSIZE blocks via the
592 * buffer cache, but HAMMER may use a variable block size based
593 * on the offset.
594 */
601 off_t nsize;
610 /*
611 * Control the number of pending records associated with
612 * this inode. If too many have accumulated start a
613 * flush. Try to maintain a pipeline with the flusher.
614 *
615 * NOTE: It is possible for other sources to grow the
616 * records but not necessarily issue another flush,
617 * so use a timeout and ensure that a re-flush occurs.
618 */
626 }
628 }
630 /*
631 * Do not allow HAMMER to blow out the buffer cache. Very
632 * large UIOs can lockout other processes due to bwillwrite()
633 * mechanics.
634 *
635 * The hammer inode is not locked during these operations.
636 * The vnode is locked which can interfere with the pageout
637 * daemon for non-UIO_NOCOPY writes but should not interfere
638 * with the buffer cache. Even so, we cannot afford to
639 * allow the pageout daemon to build up too many dirty buffer
640 * cache buffers.
641 *
642 * Only call this if we aren't being recursively called from
643 * a virtual disk device (vn), else we may deadlock.
644 */
648 /*
649 * Calculate the blocksize at the current offset and figure
650 * out how much we can actually write.
651 */
661 }
666 else
670 nsize,
675 trivial);
678 }
681 /*
682 * Issuing a write with the same data backing the
683 * buffer. Instantiate the buffer to collect the
684 * backing vm pages, then read-in any missing bits.
685 *
686 * This case is used by vop_stdputpages().
687 */
694 }
696 /*
697 * Even though we are entirely overwriting the buffer
698 * we may still have to zero it out to avoid a
699 * mmap/write visibility issue.
700 */
705 /*
706 * If the base offset of the buffer is beyond the
707 * file EOF, we don't have to issue a read.
708 */
713 /*
714 * Partial overwrite, read in any missing bits then
715 * replace the portion being written.
716 */
720 }
726 /*
727 * Generate REDO records if enabled and redo_count will not
728 * exceeded the limit.
729 *
730 * If redo_count exceeds the limit we stop generating records
731 * and clear HAMMER_INODE_REDO. This will cause the next
732 * fsync() to do a full meta-data sync instead of just an
733 * UNDO/REDO fifo update.
734 *
735 * When clearing HAMMER_INODE_REDO any pre-existing REDOs
736 * will still be tracked. The tracks will be terminated
737 * when the related meta-data (including possible data
738 * modifications which are not tracked via REDO) is
739 * flushed.
740 */
746 HAMMER_REDO_WRITE,
751 }
752 }
754 /*
755 * If we screwed up we have to undo any VM size changes we
756 * made.
757 */
765 }
768 }
778 }
783 /*
784 * Once we dirty the buffer any cached zone-X offset
785 * becomes invalid. HAMMER NOTE: no-history mode cannot
786 * allow overwriting over the same data sector unless
787 * we provide UNDOs for the old data, which we don't.
788 */
793 /*
794 * Final buffer disposition.
795 *
796 * Because meta-data updates are deferred, HAMMER is
797 * especially sensitive to excessive bdwrite()s because
798 * the I/O stream is not broken up by disk reads. So the
799 * buffer cache simply cannot keep up.
800 *
801 * WARNING! blksize is variable. cluster_write() is
802 * expected to not blow up if it encounters
803 * buffers that do not match the passed blksize.
804 *
805 * NOTE! Hammer shouldn't need to bawrite()/cluster_write().
806 * The ip->rsv_recs check should burst-flush the data.
807 * If we queue it immediately the buf could be left
808 * locked on the device queue for a very long time.
809 *
810 * However, failing to flush a dirty buffer out when
811 * issued from the pageout daemon can result in a low
812 * memory deadlock against bio_page_alloc(), so we
813 * have to bawrite() on IO_ASYNC as well.
814 *
815 * NOTE! To avoid degenerate stalls due to mismatched block
816 * sizes we only honor IO_DIRECT on the write which
817 * abuts the end of the buffer. However, we must
818 * honor IO_SYNC in case someone is silly enough to
819 * configure a HAMMER file as swap, or when HAMMER
820 * is serving NFS (for commits). Ick ick.
821 */
837 else
842 }
843 }
848 }
850 /*
851 * hammer_vop_access { vp, mode, cred }
852 *
853 * MPSAFE - does not require fs_token
854 */
855 static
856 int
858 {
860 uid_t uid;
861 gid_t gid;
870 }
872 /*
873 * hammer_vop_advlock { vp, id, op, fl, flags }
874 *
875 * MPSAFE - does not require fs_token
876 */
877 static
878 int
880 {
884 }
886 /*
887 * hammer_vop_close { vp, fflag }
888 *
889 * We can only sync-on-close for normal closes. XXX disabled for now.
890 */
891 static
892 int
894 {
895 #if 0
904 else
907 HAMMER_INODE_CLOSEASYNC);
909 }
910 }
911 #endif
913 }
915 /*
916 * hammer_vop_ncreate { nch, dvp, vpp, cred, vap }
917 *
918 * The operating system has already ensured that the directory entry
919 * does not exist and done all appropriate namespace locking.
920 */
921 static
922 int
924 {
926 hammer_inode_t dip;
927 hammer_inode_t nip;
929 hammer_mount_t hmp;
941 /*
942 * Create a transaction to cover the operations we perform.
943 */
947 /*
948 * Create a new filesystem object of the requested type. The
949 * returned inode will be referenced and shared-locked to prevent
950 * it from being moved to the flusher.
951 */
961 }
963 /*
964 * Add the new filesystem object to the directory. This will also
965 * bump the inode's link count.
966 */
969 nip);
973 /*
974 * Finish up.
975 */
987 }
989 }
992 }
994 /*
995 * hammer_vop_getattr { vp, vap }
996 *
997 * Retrieve an inode's attribute information. When accessing inodes
998 * historically we fake the atime field to ensure consistent results.
999 * The atime field is stored in the B-Tree element and allowed to be
1000 * updated without cycling the element.
1001 *
1002 * MPSAFE - does not require fs_token
1003 */
1004 static
1005 int
1007 {
1011 /*
1012 * We want the fsid to be different when accessing a filesystem
1013 * with different as-of's so programs like diff don't think
1014 * the files are the same.
1015 *
1016 * We also want the fsid to be the same when comparing snapshots,
1017 * or when comparing mirrors (which might be backed by different
1018 * physical devices). HAMMER fsids are based on the PFS's
1019 * shared_uuid field.
1020 *
1021 * XXX there is a chance of collision here. The va_fsid reported
1022 * by stat is different from the more involved fsid used in the
1023 * mount structure.
1024 */
1038 /*
1039 * Special case for @@PFS softlinks. The actual size of the
1040 * expanded softlink is "@@0x%016llx:%05d" == 26 bytes.
1041 * or for MAX_TID is "@@-1:%05d" == 10 bytes.
1042 *
1043 * Note that userspace hammer command does not allow users to
1044 * create a @@PFS softlink under an existing other PFS (id!=0)
1045 * so the ip localization here for @@PFS softlink is always 0.
1046 */
1054 else
1056 }
1058 /*
1059 * We must provide a consistent atime and mtime for snapshots
1060 * so people can do a 'tar cf - ... | md5' on them and get
1061 * consistent results.
1062 */
1069 }
1080 }
1088 VA_FSID_UUID_VALID;
1098 }
1101 }
1103 /*
1104 * hammer_vop_nresolve { nch, dvp, cred }
1105 *
1106 * Locate the requested directory entry.
1107 */
1108 static
1109 int
1111 {
1114 hammer_mount_t hmp;
1115 hammer_inode_t dip;
1116 hammer_inode_t ip;
1117 hammer_tid_t asof;
1130 /*
1131 * Misc initialization, plus handle as-of name extensions. Look for
1132 * the '@@' extension. Note that as-of files and directories cannot
1133 * be modified.
1134 */
1154 }
1158 }
1159 }
1162 /*
1163 * If this is a PFS we dive into the PFS root inode
1164 */
1174 }
1179 }
1181 }
1183 /*
1184 * If there is no path component the time extension is relative to dip.
1185 * e.g. "fubar/@@<snapshot>"
1186 *
1187 * "." is handled by the kernel, but ".@@<snapshot>" is not.
1188 * e.g. "fubar/.@@<snapshot>"
1189 *
1190 * ".." is handled by the kernel. We do not currently handle
1191 * "..@<snapshot>".
1192 */
1202 }
1207 }
1209 }
1211 /*
1212 * Calculate the namekey and setup the key range for the scan. This
1213 * works kinda like a chained hash table where the lower 32 bits
1214 * of the namekey synthesize the chain.
1215 *
1216 * The key range is inclusive of both key_beg and key_end.
1217 */
1236 /*
1237 * Scan all matching records (the chain), locate the one matching
1238 * the requested path component.
1239 *
1240 * The hammer_ip_*() functions merge in-memory records with on-disk
1241 * records for the purposes of the search.
1242 */
1257 }
1259 }
1260 }
1263 /*
1264 * Lookup the obj_id. This should always succeed. If it does not
1265 * the filesystem may be damaged and we return a dummy inode.
1266 */
1276 localization);
1281 }
1287 }
1292 }
1295 }
1296 done:
1300 }
1302 /*
1303 * hammer_vop_nlookupdotdot { dvp, vpp, cred }
1304 *
1305 * Locate the parent directory of a directory vnode.
1306 *
1307 * dvp is referenced but not locked. *vpp must be returned referenced and
1308 * locked. A parent_obj_id of 0 indicates that we are at the root.
1309 *
1310 * NOTE: as-of sequences are not linked into the directory structure. If
1311 * we are at the root with a different asof then the mount point, reload
1312 * the same directory with the mount point's asof. I'm not sure what this
1313 * will do to NFS. We encode ASOF stamps in NFS file handles so it might not
1314 * get confused, but it hasn't been tested.
1315 */
1316 static
1317 int
1319 {
1321 hammer_inode_t dip;
1322 hammer_inode_t ip;
1323 hammer_mount_t hmp;
1326 hammer_tid_t asof;
1333 /*
1334 * Whos are parent? This could be the root of a pseudo-filesystem
1335 * whos parent is in another localization domain.
1336 */
1341 else
1344 /*
1345 * It's probably a PFS root when dip->ino_data.parent_obj_id is 0.
1346 */
1359 }
1360 }
1372 }
1376 }
1378 /*
1379 * hammer_vop_nlink { nch, dvp, vp, cred }
1380 */
1381 static
1382 int
1384 {
1386 hammer_inode_t dip;
1387 hammer_inode_t ip;
1389 hammer_mount_t hmp;
1410 /*
1411 * Create a transaction to cover the operations we perform.
1412 */
1416 /*
1417 * Add the filesystem object to the directory. Note that neither
1418 * dip nor ip are referenced or locked, but their vnodes are
1419 * referenced. This function will bump the inode's link count.
1420 */
1423 ip);
1425 /*
1426 * Finish up.
1427 */
1431 }
1437 }
1439 /*
1440 * hammer_vop_nmkdir { nch, dvp, vpp, cred, vap }
1441 *
1442 * The operating system has already ensured that the directory entry
1443 * does not exist and done all appropriate namespace locking.
1444 */
1445 static
1446 int
1448 {
1450 hammer_inode_t dip;
1451 hammer_inode_t nip;
1453 hammer_mount_t hmp;
1465 /*
1466 * Create a transaction to cover the operations we perform.
1467 */
1471 /*
1472 * Create a new filesystem object of the requested type. The
1473 * returned inode will be referenced but not locked.
1474 */
1483 }
1484 /*
1485 * Add the new filesystem object to the directory. This will also
1486 * bump the inode's link count.
1487 */
1490 nip);
1494 /*
1495 * Finish up.
1496 */
1506 }
1507 }
1513 }
1515 /*
1516 * hammer_vop_nmknod { nch, dvp, vpp, cred, vap }
1517 *
1518 * The operating system has already ensured that the directory entry
1519 * does not exist and done all appropriate namespace locking.
1520 */
1521 static
1522 int
1524 {
1526 hammer_inode_t dip;
1527 hammer_inode_t nip;
1529 hammer_mount_t hmp;
1541 /*
1542 * Create a transaction to cover the operations we perform.
1543 */
1547 /*
1548 * Create a new filesystem object of the requested type. The
1549 * returned inode will be referenced but not locked.
1550 *
1551 * If mknod specifies a directory a pseudo-fs is created.
1552 */
1561 }
1563 /*
1564 * Add the new filesystem object to the directory. This will also
1565 * bump the inode's link count.
1566 */
1569 nip);
1571 /*
1572 * Finish up.
1573 */
1583 }
1584 }
1590 }
1592 /*
1593 * hammer_vop_open { vp, mode, cred, fp }
1594 *
1595 * MPSAFE (does not require fs_token)
1596 */
1597 static
1598 int
1600 {
1601 hammer_inode_t ip;
1608 }
1610 /*
1611 * hammer_vop_print { vp }
1612 */
1613 static
1614 int
1616 {
1618 }
1620 /*
1621 * hammer_vop_readdir { vp, uio, cred, *eofflag, *ncookies, off_t **cookies }
1622 */
1623 static
1624 int
1626 {
1629 hammer_inode_t ip;
1630 hammer_mount_t hmp;
1632 hammer_base_elm_t base;
1637 off_t saveoff;
1656 }
1661 /*
1662 * Handle artificial entries
1663 *
1664 * It should be noted that the minimum value for a directory
1665 * hash key on-media is 0x0000000100000000, so we can use anything
1666 * less then that to represent our 'special' key space.
1667 */
1679 }
1688 }
1697 }
1699 /*
1700 * Key range (begin and end inclusive) to scan. Directory keys
1701 * directly translate to a 64 bit 'seek' position.
1702 */
1734 dtype,
1746 }
1749 done:
1762 }
1769 }
1770 }
1773 }
1775 /*
1776 * hammer_vop_readlink { vp, uio, cred }
1777 */
1778 static
1779 int
1781 {
1784 hammer_inode_t ip;
1785 hammer_mount_t hmp;
1788 hammer_pseudofs_inmem_t pfsm;
1796 /*
1797 * Shortcut if the symlink data was stuffed into ino_data.
1798 *
1799 * Also expand special "@@PFS%05d" softlinks (expansion only
1800 * occurs for non-historical (current) accesses made from the
1801 * primary filesystem).
1802 *
1803 * Note that userspace hammer command does not allow users to
1804 * create a @@PFS softlink under an existing other PFS (id!=0)
1805 * so the ip localization here for @@PFS softlink is always 0.
1806 */
1825 /* vap->va_size == 26 */
1831 /* vap->va_size == 10 */
1835 }
1838 }
1842 }
1846 }
1848 /*
1849 * Long version
1850 */
1854 /*
1855 * Key range (begin and end inclusive) to scan. Directory keys
1856 * directly translate to a 64 bit 'seek' position.
1857 */
1859 HAMMER_LOCALIZE_MISC;
1874 HAMMER_SYMLINK_NAME_OFF);
1877 HAMMER_SYMLINK_NAME_OFF,
1879 }
1880 }
1885 }
1887 /*
1888 * hammer_vop_nremove { nch, dvp, cred }
1889 */
1890 static
1891 int
1893 {
1895 hammer_inode_t dip;
1896 hammer_mount_t hmp;
1905 }
1915 }
1917 /*
1918 * hammer_vop_nrename { fnch, tnch, fdvp, tdvp, cred }
1919 */
1920 static
1921 int
1923 {
1927 hammer_inode_t fdip;
1928 hammer_inode_t tdip;
1929 hammer_inode_t ip;
1930 hammer_mount_t hmp;
1967 /*
1968 * Remove tncp from the target directory and then link ip as
1969 * tncp. XXX pass trans to dounlink
1970 *
1971 * Force the inode sync-time to match the transaction so it is
1972 * in-sync with the creation of the target directory entry.
1973 */
1979 ip);
1984 }
1985 }
1989 /*
1990 * Locate the record in the originating directory and remove it.
1991 *
1992 * Calculate the namekey and setup the key range for the scan. This
1993 * works kinda like a chained hash table where the lower 32 bits
1994 * of the namekey synthesize the chain.
1995 *
1996 * The key range is inclusive of both key_beg and key_end.
1997 */
2000 retry:
2016 /*
2017 * Scan all matching records (the chain), locate the one matching
2018 * the requested path component.
2019 *
2020 * The hammer_ip_*() functions merge in-memory records with on-disk
2021 * records for the purposes of the search.
2022 */
2032 }
2034 }
2036 /*
2037 * If all is ok we have to get the inode so we can adjust nlinks.
2038 *
2039 * WARNING: hammer_ip_del_direntry() may have to terminate the
2040 * cursor to avoid a recursion. It's ok to call hammer_done_cursor()
2041 * twice.
2042 */
2046 /*
2047 * XXX A deadlock here will break rename's atomicy for the purposes
2048 * of crash recovery.
2049 */
2053 }
2055 /*
2056 * Cleanup and tell the kernel that the rename succeeded.
2057 *
2058 * NOTE: ip->vp, if non-NULL, cannot be directly referenced
2059 * without formally acquiring the vp since the vp might
2060 * have zero refs on it, or in the middle of a reclaim,
2061 * etc.
2062 */
2077 }
2079 }
2080 }
2082 failed:
2086 }
2088 /*
2089 * hammer_vop_nrmdir { nch, dvp, cred }
2090 */
2091 static
2092 int
2094 {
2096 hammer_inode_t dip;
2097 hammer_mount_t hmp;
2106 }
2116 }
2118 /*
2119 * hammer_vop_markatime { vp, cred }
2120 */
2121 static
2122 int
2124 {
2126 hammer_inode_t ip;
2127 hammer_mount_t hmp;
2146 }
2148 /*
2149 * hammer_vop_setattr { vp, vap, cred }
2150 */
2151 static
2152 int
2154 {
2156 hammer_inode_t ip;
2158 hammer_mount_t hmp;
2164 #if 0
2166 #endif
2182 }
2199 }
2203 }
2204 }
2206 }
2210 }
2215 hammer_uuid_t uuid_uid;
2216 hammer_uuid_t uuid_gid;
2232 }
2234 }
2235 }
2242 /*
2243 * Log the operation if in fast-fsync mode or if
2244 * there are unterminated redo write records present.
2245 *
2246 * The second check is needed so the recovery code
2247 * properly truncates write redos even if nominal
2248 * REDO operations is turned off due to excessive
2249 * writes, because the related records might be
2250 * destroyed and never lay down a TERM_WRITE.
2251 */
2256 HAMMER_REDO_TRUNC,
2258 }
2261 /*
2262 * XXX break atomicy, we can deadlock the backend
2263 * if we do not release the lock. Probably not a
2264 * big deal here.
2265 */
2268 blksize,
2284 }
2287 /* XXX safe to use SDIRTY instead of DDIRTY here? */
2291 /*
2292 * On-media truncation is cached in the inode until
2293 * the inode is synchronized. We must immediately
2294 * handle any frontend records.
2295 */
2304 }
2305 }
2307 #if 0
2308 /*
2309 * When truncating, nvtruncbuf() may have cleaned out
2310 * a portion of the last block on-disk in the buffer
2311 * cache. We must clean out any frontend records
2312 * for blocks beyond the new last block.
2313 */
2319 }
2320 #endif
2329 }
2340 }
2342 }
2347 }
2353 }
2366 }
2367 }
2368 done:
2375 }
2377 /*
2378 * hammer_vop_nsymlink { nch, dvp, vpp, cred, vap, target }
2379 */
2380 static
2381 int
2383 {
2385 hammer_inode_t dip;
2386 hammer_inode_t nip;
2387 hammer_record_t record;
2389 hammer_mount_t hmp;
2404 /*
2405 * Create a transaction to cover the operations we perform.
2406 */
2410 /*
2411 * Create a new filesystem object of the requested type. The
2412 * returned inode will be referenced but not locked.
2413 */
2423 }
2425 /*
2426 * Add a record representing the symlink. symlink stores the link
2427 * as pure data, not a string, and is no \0 terminated.
2428 */
2439 HAMMER_LOCALIZE_MISC;
2446 }
2448 /*
2449 * Set the file size to the length of the link.
2450 */
2454 }
2455 }
2460 /*
2461 * Finish up.
2462 */
2473 }
2474 }
2478 }
2480 /*
2481 * hammer_vop_nwhiteout { nch, dvp, cred, flags }
2482 */
2483 static
2484 int
2486 {
2488 hammer_inode_t dip;
2489 hammer_mount_t hmp;
2498 }
2508 }
2510 /*
2511 * hammer_vop_ioctl { vp, command, data, fflag, cred }
2512 */
2513 static
2514 int
2516 {
2526 }
2528 static
2529 int
2531 {
2538 };
2539 hammer_mount_t hmp;
2556 else
2561 /*
2562 * Call standard mountctl VOP function
2563 * so we get user mount flags.
2564 */
2576 }
2583 }
2586 }
2588 /*
2589 * hammer_vop_strategy { vp, bio }
2590 *
2591 * Strategy call, used for regular file read & write only. Note that the
2592 * bp may represent a cluster.
2593 *
2594 * To simplify operation and allow better optimizations in the future,
2595 * this code does not make any assumptions with regards to buffer alignment
2596 * or size.
2597 */
2598 static
2599 int
2601 {
2619 }
2621 /* hammer_dump_dedup_cache(((hammer_inode_t)ap->a_vp->v_data)->hmp); */
2624 }
2626 /*
2627 * Read from a regular file. Iterate the related records and fill in the
2628 * BIO/BUF. Gaps are zero-filled.
2629 *
2630 * The support code in hammer_object.c should be used to deal with mixed
2631 * in-memory and on-disk records.
2632 *
2633 * NOTE: Can be called from the cluster code with an oversized buf.
2634 *
2635 * XXX atime update
2636 */
2637 static
2638 int
2640 {
2642 hammer_inode_t ip;
2643 hammer_inode_t dip;
2644 hammer_mount_t hmp;
2646 hammer_base_elm_t base;
2647 hammer_off_t disk_offset;
2665 /*
2666 * The zone-2 disk offset may have been set by the cluster code via
2667 * a BMAP operation, or else should be NOOFFSET.
2668 *
2669 * Checking the high bits for a match against zone-2 should suffice.
2670 *
2671 * In cases where a lot of data duplication is present it may be
2672 * more beneficial to drop through and doubule-buffer through the
2673 * device.
2674 */
2682 }
2684 /*
2685 * Try to shortcut requests for double_buffer mode too.
2686 * Since this mode runs through the device buffer cache
2687 * only compatible buffer sizes (meaning those generated
2688 * by normal filesystem buffers) are legal.
2689 */
2695 }
2696 }
2698 /*
2699 * Well, that sucked. Do it the hard way. If all the stars are
2700 * aligned we may still be able to issue a direct-read.
2701 */
2706 /*
2707 * Key range (begin and end inclusive) to scan. Note that the key's
2708 * stored in the actual records represent BASE+LEN, not BASE. The
2709 * first record containing bio_offset will have a key > bio_offset.
2710 */
2712 HAMMER_LOCALIZE_MISC;
2723 #if 0
2729 #endif
2730 {
2737 else
2739 }
2742 /*
2743 * Set NOSWAPCACHE for cursor data extraction if double buffering
2744 * is disabled or (if the file is not marked cacheable via chflags
2745 * and vm.swapcache_use_chflags is enabled).
2746 */
2749 vm_swapcache_use_chflags)) {
2751 }
2757 /*
2758 * Get the base file offset of the record. The key for
2759 * data records is (base + bytes) rather then (base).
2760 */
2764 /*
2765 * Calculate the gap, if any, and zero-fill it.
2766 *
2767 * n is the offset of the start of the record verses our
2768 * current seek offset in the bio.
2769 */
2777 }
2779 /*
2780 * Calculate the data offset in the record and the number
2781 * of bytes we can copy.
2782 *
2783 * There are two degenerate cases. First, boff may already
2784 * be at bp->b_bufsize. Secondly, the data offset within
2785 * the record may exceed the record's size.
2786 */
2795 }
2797 /*
2798 * Deal with cached truncations. This cool bit of code
2799 * allows truncate()/ftruncate() to avoid having to sync
2800 * the file.
2801 *
2802 * If the frontend is truncated then all backend records are
2803 * subject to the frontend's truncation.
2804 *
2805 * If the backend is truncated then backend records on-disk
2806 * (but not in-memory) are subject to the backend's
2807 * truncation. In-memory records owned by the backend
2808 * represent data written after the truncation point on the
2809 * backend and must not be truncated.
2810 *
2811 * Truncate operations deal with frontend buffer cache
2812 * buffers and frontend-owned in-memory records synchronously.
2813 */
2821 }
2822 }
2829 }
2830 }
2832 /*
2833 * Try to issue a direct read into our bio if possible,
2834 * otherwise resolve the element data into a hammer_buffer
2835 * and copy.
2836 *
2837 * The buffer on-disk should be zerod past any real
2838 * truncation point, but may not be for any synthesized
2839 * truncation point from above.
2840 *
2841 * NOTE: disk_offset is only valid if the cursor data is
2842 * on-disk.
2843 */
2850 /*
2851 * Direct read case
2852 */
2860 /*
2861 * Async I/O case for reading from backing store
2862 * and copying the data to the filesystem buffer.
2863 * live-dedup has to verify the data anyway if it
2864 * gets a hit later so we can just add the entry
2865 * now.
2866 */
2880 }
2881 }
2885 /*
2886 * We have to be sure that the only elements added to the
2887 * dedup cache are those which are already on-media.
2888 */
2892 /*
2893 * Iterate until we have filled the request.
2894 */
2899 }
2901 /*
2902 * There may have been a gap after the last record
2903 */
2909 /* boff = bp->b_bufsize; */
2910 }
2912 /*
2913 * Disallow swapcache operation on the vnode buffer if double
2914 * buffering is enabled, the swapcache will get the data via
2915 * the block device buffer.
2916 */
2920 /*
2921 * Cleanup
2922 */
2929 done:
2930 /*
2931 * Cache the b-tree node for the last data read in cache[1].
2932 *
2933 * If we hit the file EOF then also cache the node in the
2934 * governing directory's cache[3], it will be used to initialize
2935 * the new inode's cache[1] for any inodes looked up via the directory.
2936 *
2937 * This doesn't reduce disk accesses since the B-Tree chain is
2938 * likely cached, but it does reduce cpu overhead when looking
2939 * up file offsets for cpdup/tar/cpio style iterations.
2940 */
2949 }
2950 }
2955 }
2957 /*
2958 * BMAP operation - used to support cluster_read() only.
2959 *
2960 * (struct vnode *vp, off_t loffset, off_t *doffsetp, int *runp, int *runb)
2961 *
2962 * This routine may return EOPNOTSUPP if the opration is not supported for
2963 * the specified offset. The contents of the pointer arguments do not
2964 * need to be initialized in that case.
2965 *
2966 * If a disk address is available and properly aligned return 0 with
2967 * *doffsetp set to the zone-2 address, and *runp / *runb set appropriately
2968 * to the run-length relative to that offset. Callers may assume that
2969 * *doffsetp is valid if 0 is returned, even if *runp is not sufficiently
2970 * large, so return EOPNOTSUPP if it is not sufficiently large.
2971 */
2972 static
2973 int
2975 {
2977 hammer_inode_t ip;
2978 hammer_mount_t hmp;
2980 hammer_base_elm_t base;
2987 hammer_off_t last_disk_offset;
2988 hammer_off_t disk_offset;
2996 /*
2997 * We can only BMAP regular files. We can't BMAP database files,
2998 * directories, etc.
2999 */
3003 /*
3004 * bmap is typically called with runp/runb both NULL when used
3005 * for writing. We do not support BMAP for writing atm.
3006 */
3010 /*
3011 * Scan the B-Tree to acquire blockmap addresses, then translate
3012 * to raw addresses.
3013 */
3019 /*
3020 * Key range (begin and end inclusive) to scan. Note that the key's
3021 * stored in the actual records represent BASE+LEN, not BASE. The
3022 * first record containing bio_offset will have a key > bio_offset.
3023 */
3025 HAMMER_LOCALIZE_MISC;
3032 else
3048 else
3058 /*
3059 * Get the base file offset of the record. The key for
3060 * data records is (base + bytes) rather then (base).
3061 *
3062 * NOTE: rec_offset + rec_len may exceed the end-of-file.
3063 * The extra bytes should be zero on-disk and the BMAP op
3064 * should still be ok.
3065 */
3070 /*
3071 * Incorporate any cached truncation.
3072 *
3073 * NOTE: Modifications to rec_len based on synthesized
3074 * truncation points remove the guarantee that any extended
3075 * data on disk is zero (since the truncations may not have
3076 * taken place on-media yet).
3077 */
3085 }
3086 }
3093 }
3094 }
3096 /*
3097 * Accumulate information. If we have hit a discontiguous
3098 * block reset base_offset unless we are already beyond the
3099 * requested offset. If we are, that's it, we stop.
3100 */
3111 }
3117 }
3120 }
3129 /*
3130 * If we couldn't find any records or the records we did find were
3131 * all behind the requested offset, return failure. A forward
3132 * truncation can leave a hole w/ no on-disk records.
3133 */
3137 /*
3138 * Figure out the block size at the requested offset and adjust
3139 * our limits so the cluster_read() does not create inappropriately
3140 * sized buffer cache buffers.
3141 */
3145 }
3150 }
3152 /*
3153 * Returning EOPNOTSUPP simply prevents the direct-IO optimization
3154 * from occuring.
3155 */
3159 /*
3160 * Only large-data zones can be direct-IOd
3161 */
3165 /*
3166 * doffsetp is not aligned or the forward run size does
3167 * not cover a whole buffer, disallow the direct I/O.
3168 */
3171 /*
3172 * We're good.
3173 */
3178 }
3182 }
3184 }
3186 }
3188 /*
3189 * Write to a regular file. Because this is a strategy call the OS is
3190 * trying to actually get data onto the media.
3191 */
3192 static
3193 int
3195 {
3196 hammer_record_t record;
3197 hammer_mount_t hmp;
3198 hammer_inode_t ip;
3218 }
3222 /*
3223 * Disallow swapcache operation on the vnode buffer if double
3224 * buffering is enabled, the swapcache will get the data via
3225 * the block device buffer.
3226 */
3230 /*
3231 * Interlock with inode destruction (no in-kernel or directory
3232 * topology visibility). If we queue new IO while trying to
3233 * destroy the inode we can deadlock the vtrunc call in
3234 * hammer_inode_unloadable_check().
3235 *
3236 * Besides, there's no point flushing a bp associated with an
3237 * inode that is being destroyed on-media and has no kernel
3238 * references.
3239 */
3246 }
3248 /*
3249 * Reserve space and issue a direct-write from the front-end.
3250 * NOTE: The direct_io code will hammer_bread/bcopy smaller
3251 * allocations.
3252 *
3253 * An in-memory record will be installed to reference the storage
3254 * until the flusher can get to it.
3255 *
3256 * Since we own the high level bio the front-end will not try to
3257 * do a direct-read until the write completes.
3258 *
3259 * NOTE: The only time we do not reserve a full-sized buffers
3260 * worth of data is if the file is small. We do not try to
3261 * allocate a fragment (from the small-data zone) at the end of
3262 * an otherwise large file as this can lead to wildly separated
3263 * data.
3264 */
3269 else
3275 /*
3276 * B_VFSFLAG1 indicates that a REDO_WRITE entry was generated
3277 * in hammer_vop_write(). We must flag the record so the proper
3278 * REDO_TERM_WRITE entry is generated during the flush.
3279 */
3284 }
3291 }
3299 }
3302 }
3304 /*
3305 * dounlink - disconnect a directory entry
3306 *
3307 * XXX whiteout support not really in yet
3308 */
3309 static int
3313 {
3315 hammer_inode_t dip;
3316 hammer_inode_t ip;
3317 hammer_mount_t hmp;
3323 /*
3324 * Calculate the namekey and setup the key range for the scan. This
3325 * works kinda like a chained hash table where the lower 32 bits
3326 * of the namekey synthesize the chain.
3327 *
3328 * The key range is inclusive of both key_beg and key_end.
3329 */
3339 retry:
3355 /*
3356 * Scan all matching records (the chain), locate the one matching
3357 * the requested path component. info->last_error contains the
3358 * error code on search termination and could be 0, ENOENT, or
3359 * something else.
3360 *
3361 * The hammer_ip_*() functions merge in-memory records with on-disk
3362 * records for the purposes of the search.
3363 */
3375 }
3377 }
3379 /*
3380 * If all is ok we have to get the inode so we can adjust nlinks.
3381 * To avoid a deadlock with the flusher we must release the inode
3382 * lock on the directory when acquiring the inode for the entry.
3383 *
3384 * If the target is a directory, it must be empty.
3385 */
3400 }
3402 /*
3403 * If isdir >= 0 we validate that the entry is or is not a
3404 * directory. If isdir < 0 we don't care.
3405 */
3413 }
3414 }
3416 /*
3417 * If we are trying to remove a directory the directory must
3418 * be empty.
3419 *
3420 * The check directory code can loop and deadlock/retry. Our
3421 * own cursor's node locks must be released to avoid a 3-way
3422 * deadlock with the flusher if the check directory code
3423 * blocks.
3424 *
3425 * If any changes whatsoever have been made to the cursor
3426 * set EDEADLK and retry.
3427 *
3428 * WARNING: See warnings in hammer_unlock_cursor()
3429 * function.
3430 */
3432 HAMMER_OBJTYPE_DIRECTORY) {
3441 }
3442 }
3444 /*
3445 * Delete the directory entry.
3446 *
3447 * WARNING: hammer_ip_del_direntry() may have to terminate
3448 * the cursor to avoid a deadlock. It is ok to call
3449 * hammer_done_cursor() twice.
3450 */
3454 }
3457 /*
3458 * Tell the namecache that we are now unlinked.
3459 */
3462 /*
3463 * NOTE: ip->vp, if non-NULL, cannot be directly
3464 * referenced without formally acquiring the
3465 * vp since the vp might have zero refs on it,
3466 * or in the middle of a reclaim, etc.
3467 *
3468 * NOTE: The cache_setunresolved() can rip the vp
3469 * out from under us since the vp may not have
3470 * any refs, in which case ip->vp will be NULL
3471 * from the outset.
3472 */
3480 #if 0
3481 /*
3482 * Don't do this, it can deadlock
3483 * on concurrent rm's of hardlinks.
3484 * Shouldn't be needed any more.
3485 */
3487 #endif
3490 }
3492 }
3493 }
3498 }
3503 }
3505 /************************************************************************
3506 * FIFO AND SPECFS OPS *
3507 ************************************************************************
3508 *
3509 */
3510 static int
3512 {
3513 /* XXX update itimes */
3515 }
3517 static int
3519 {
3523 /* XXX update access time */
3525 }
3527 static int
3529 {
3533 /* XXX update access time */
3535 }
3537 static
3538 int
3540 {
3547 }
3549 /************************************************************************
3550 * KQFILTER OPS *
3551 ************************************************************************
3552 *
3553 */
3569 static
3570 int
3572 {
3588 }
3595 }
3597 static void
3599 {
3603 }
3605 static int
3607 {
3611 off_t off;
3616 }
3624 }
3626 static int
3628 {
3633 }
3635 static int
3637 {
3643 }
3645 }