| blob | e213d446c24a6f7962bf1fda9bec9b1d75e5de87 |
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 */
21 /*
22 * Copyright (c) 1984, 2010, Oracle and/or its affiliates. All rights reserved.
23 */
25 /* Copyright (c) 1983, 1984, 1985, 1986, 1987, 1988, 1989 AT&T */
26 /* All Rights Reserved */
28 /*
29 * University Copyright- Copyright (c) 1982, 1986, 1988
30 * The Regents of the University of California
31 * All Rights Reserved
32 *
33 * University Acknowledgment- Portions of this document are derived from
34 * software developed by the University of California, Berkeley, and its
35 * contributors.
36 */
38 /*
39 * Directory manipulation routines.
40 *
41 * When manipulating directories, the i_rwlock provides serialization
42 * since directories cannot be mmapped. The i_contents lock is redundant.
43 */
45 #include <sys/types.h>
46 #include <sys/t_lock.h>
47 #include <sys/param.h>
48 #include <sys/systm.h>
49 #include <sys/signal.h>
50 #include <sys/cred.h>
51 #include <sys/proc.h>
52 #include <sys/disp.h>
53 #include <sys/user.h>
54 #include <sys/vfs.h>
55 #include <sys/vnode.h>
56 #include <sys/stat.h>
57 #include <sys/mode.h>
58 #include <sys/buf.h>
59 #include <sys/uio.h>
60 #include <sys/dnlc.h>
61 #include <sys/fs/ufs_inode.h>
62 #include <sys/fs/ufs_fs.h>
63 #include <sys/mount.h>
64 #include <sys/fs/ufs_fsdir.h>
65 #include <sys/fs/ufs_trans.h>
66 #include <sys/fs/ufs_panic.h>
67 #include <sys/fs/ufs_quota.h>
68 #include <sys/errno.h>
69 #include <sys/debug.h>
70 #include <vm/seg.h>
71 #include <sys/sysmacros.h>
72 #include <sys/cmn_err.h>
73 #include <sys/cpuvar.h>
74 #include <sys/unistd.h>
75 #include <sys/policy.h>
77 /*
78 * This is required since we're using P2ROUNDUP_TYPED on DIRBLKSIZ
79 */
80 #if !ISP2(DIRBLKSIZ)
82 #endif
84 /*
85 * A virgin directory.
86 */
90 };
92 #define LDIRSIZ(len) \
93 ((sizeof (struct direct) - (MAXNAMLEN + 1)) + ((len + 1 + 3) &~ 3))
94 #define MAX_DIR_NAME_LEN(len) \
95 (((len) - (sizeof (struct direct) - (MAXNAMLEN + 1))) - 1)
97 /*
98 * The dnlc directory cache allows a 64 bit handle for directory entries.
99 * For ufs we squeeze both the 32 bit inumber and a 32 bit disk offset
100 * into the handle. Note, a 32 bit offset allows a 4GB directory, which
101 * is way beyond what could be cached in memory by the directory
102 * caching routines. So we are quite safe with this limit.
103 * The macros below pack and unpack the handle.
104 */
105 #define H_TO_INO(h) (uint32_t)((h) & UINT_MAX)
106 #define H_TO_OFF(h) (off_t)((h) >> 32)
107 #define INO_OFF_TO_H(ino, off) (uint64_t)(((uint64_t)(off) << 32) | (ino))
109 /*
110 * The average size of a typical on disk directory entry is about 16 bytes
111 * and so defines AV_DIRECT_SHIFT : log2(16)
112 * This define is only used to approximate the number of entries
113 * is a directory. This is needed for dnlc_dir_start() which will immediately
114 * return an error if the value is not within its acceptable range of
115 * number of files in a directory.
116 */
117 #define AV_DIRECT_SHIFT 4
118 /*
119 * If the directory size (from i_size) is greater than the ufs_min_dir_cache
120 * tunable then we request dnlc directory caching.
121 * This has found to be profitable after 1024 file names.
122 */
125 /* The time point the dnlc directory caching was disabled */
127 /* directory caching disable duration */
130 #ifdef DEBUG
151 /*
152 * Check accessibility of directory against inquired mode and type.
153 * Execute access is required to search the directory.
154 * Access for write is interpreted as allowing
155 * deletion of files in the directory.
156 * Note, the reader i_contents lock will be acquired in
157 * ufs_iaccess().
158 */
159 int
161 {
167 }
169 /*
170 * Look for a given name in a directory. On successful return, *ipp
171 * will point to the VN_HELD inode.
172 * The caller is responsible for checking accessibility upfront
173 * via ufs_diraccess().
174 */
175 int
183 {
192 off_t offset;
204 ino_t chkino;
212 /*
213 * Check the directory name lookup cache, first for individual files
214 * then for complete directories.
215 */
218 /* vp is already held from dnlc_lookup */
222 }
225 }
229 /*
230 * Grab the reader lock on the directory data before checking
231 * the dnlc to avoid a race with ufs_dirremove() & friends.
232 *
233 * ufs_tryirwlock uses rw_tryenter and checks for SLOCK to
234 * avoid i_rwlock, ufs_lockfs_begin deadlock. If deadlock
235 * possible, retries the operation.
236 */
249 }
252 /*
253 * release the lock on the dir we are searching
254 * to avoid a deadlock when grabbing the
255 * i_contents lock in ufs_iget_alloced().
256 */
261 /*
262 * must recheck as we dropped dp->i_rwlock
263 */
265 RW_READER);
270 }
276 }
277 /* check failed, read the actual directory */
280 }
282 }
283 /* usual case of not "." nor ".." */
290 }
297 }
302 }
303 restart:
310 /*
311 * Attempt to cache any directories greater than the tunable
312 * ufs_min_cache_dir. If it fails due to memory shortage (DNOMEM),
313 * disable caching for this directory and record the system time.
314 * Any attempt after the disable time has expired will enable
315 * the caching again.
316 */
318 /*
319 * if the directory caching disable time has expired
320 * enable the caching again.
321 */
326 }
329 AV_DIRECT_SHIFT)) {
342 }
343 }
344 }
345 /*
346 * If caching we don't stop when the file has been
347 * found, but need to know later, so clear *ipp now
348 */
351 recheck:
357 /*
358 * Take care to look at dp->i_diroff only once, as it
359 * may be changing due to other threads/cpus.
360 */
364 }
376 }
378 }
379 }
384 searchloop:
386 /*
387 * If offset is on a block boundary,
388 * read the next directory block.
389 * Release previous if it exists.
390 */
394 }
399 }
401 /*
402 * If the offset to the next entry is invalid or if the
403 * next entry is a zero length record or if the record
404 * length is invalid, then skip to the next directory
405 * block. Complete validation checks are done if the
406 * record length is invalid.
407 *
408 * Full validation checks are slow so they are disabled
409 * by default. Complete checks can be run by patching
410 * "dirchk" to be true.
411 *
412 * We have to check the validity of entryoffsetinblock
413 * here because it can be set to i_diroff above.
414 */
425 }
427 }
431 /*
432 * Add named entries and free space into the directory cache
433 */
435 ushort_t extra;
436 off_t off2;
444 }
446 /*
447 * entries hold the previous offset except the
448 * 1st which holds the offset + 1
449 */
454 }
458 }
462 }
463 }
465 /*
466 * Check for a name match.
467 * We have the parent inode read locked with i_rwlock.
468 */
473 /*
474 * We have to release the fbp early here to avoid
475 * a possible deadlock situation where we have the
476 * fbp and want the directory inode and someone doing
477 * a ufs_direnter_* has the directory inode and wants
478 * the fbp. XXX - is this still needed?
479 */
485 /*
486 * Atomic update (read lock held)
487 */
496 }
498 /*
499 * if the inumber didn't change
500 * continue with already found inode.
501 */
506 /* *ipp is nulled at restart */
508 }
509 }
510 /*
511 * release the lock on the dir we are searching
512 * to avoid a deadlock when grabbing the
513 * i_contents lock in ufs_iget_alloced().
514 */
518 RW_READER);
520 cr);
523 RW_READER);
528 }
531 /*
532 * Since we released the lock on the directory,
533 * we must check that the same inode is still
534 * the ".." entry for this directory.
535 */
536 /*CSTYLED*/
538 /*
539 * Modification time changed on the
540 * directory, we must go check if
541 * the inumber changed for ".."
542 */
547 /*
548 * Forget directory caching
549 * for this rare case
550 */
553 }
555 }
562 }
565 RW_READER);
567 cr);
571 }
572 checkok:
575 /*
576 * If we are not caching then just return the entry
577 * otherwise complete loading up the cache
578 */
582 }
586 }
590 }
591 /*
592 * If we started in the middle of the directory and failed
593 * to find our target, we must check the beginning as well.
594 */
596 numdirpasses--;
600 }
602 /*
603 * If whole directory caching is on (or was originally on) then
604 * the entry may have been found.
605 */
610 }
611 }
615 }
617 bad:
619 /*
620 * err and *ipp can both be set if we were attempting to
621 * cache the directory, and we found the entry, then later
622 * while trying to complete the directory cache encountered
623 * a error (eg reading a directory sector).
624 */
627 }
635 }
637 /*
638 * Write a new directory entry for DE_CREATE or DE_MKDIR operations.
639 */
640 int
649 {
670 /* don't allow '/' characters in pathname component */
676 /*
677 * Check accessibility of target directory.
678 */
682 /*
683 * If name is "." or ".." then if this is a create look it up
684 * and return EEXIST.
685 */
688 /*
689 * ufs_dirlook will acquire the i_rwlock
690 */
698 /*
699 * ufs_tryirwlock uses rw_tryenter and checks for
700 * SLOCK to avoid i_rwlock, ufs_lockfs_begin deadlock.
701 * If deadlock possible, retries the operation.
702 */
704 RW_WRITER);
709 }
714 }
716 }
718 /*
719 * If target directory has not been removed, then we can consider
720 * allowing file to be created.
721 */
724 }
726 /*
727 * Search for the entry. Return VN_HELD tip if found.
728 */
742 /*
743 * The entry does not exist. Check write permission in
744 * directory to see if entry can be created.
745 */
748 /*
749 * Make new inode and directory entry.
750 */
756 }
759 /*
760 * Unmake the inode we just made.
761 */
771 }
782 }
783 }
785 out:
792 /*
793 * Drop vfs_dqrwlock before calling VN_RELE() on nip to
794 * avoid deadlock since ufs_delete() grabs vfs_dqrwlock as reader.
795 */
800 }
803 }
805 /*
806 * Write a new directory entry for DE_LINK, DE_SYMLINK or DE_RENAME operations.
807 */
808 int
816 {
823 /* don't allow '/' characters in pathname component */
830 /*
831 * If name is "." or ".." then if this is a create look it up
832 * and return EEXIST. Rename or link TO "." or ".." is forbidden.
833 */
838 }
840 }
841 /*
842 * For link and rename lock the source entry and check the link count
843 * to see if it has been removed while it was unlocked. If not, we
844 * increment the link count and force the inode to disk to make sure
845 * that it is there before any directory entry that points to it.
846 *
847 * In the case of a symbolic link, we are dealing with a new inode
848 * which does not yet have any links. We've created it with a link
849 * count of 1, and we don't want to increment it since this will be
850 * its first link.
851 *
852 * We are about to push the inode to disk. We make sure
853 * that the inode's data blocks are flushed first so the
854 * inode and it's data blocks are always in sync. This
855 * adds some robustness in in the event of a power failure
856 * or panic where sync fails. If we panic before the
857 * inode is updated, then the inode still refers to the
858 * old data blocks (or none for a new file). If we panic
859 * after the inode is updated, then the inode refers to
860 * the new data blocks.
861 *
862 * We do this before grabbing the i_contents lock because
863 * ufs_syncip() will want that lock. We could do the data
864 * syncing after the removal checks, but upon return from
865 * the data sync we would have to repeat the removal
866 * checks.
867 */
870 }
876 }
880 }
882 /*
883 * Sync the indirect blocks associated with the file
884 * for the same reasons as described above. Since this
885 * call wants the i_contents lock held for it we can do
886 * this here with no extra work.
887 */
891 }
901 /*
902 * If target directory has not been removed, then we can consider
903 * allowing file to be created.
904 */
908 }
910 /*
911 * Check accessibility of target directory.
912 */
916 /*
917 * Search for the entry. Return VN_HELD tip if found.
918 */
937 /*
938 * Can't link to an existing file.
939 */
944 }
946 /*
947 * The entry does not exist. Check write permission in
948 * directory to see if entry can be created.
949 */
953 cr);
954 }
956 out:
962 /*
963 * Drop vfs_dqrwlock before calling VN_RELE() on tip to
964 * avoid deadlock since ufs_delete() grabs vfs_dqrwlock as reader.
965 */
968 /*
969 * If we renamed a file over the top of an existing file,
970 * or linked a file to an existing file (or tried to),
971 * then release and delete (or just release) the inode.
972 */
976 out2:
978 /*
979 * Undo bumped link count.
980 */
990 }
991 }
993 }
995 /*
996 * Check for the existence of a name in a directory (unless noentry
997 * is set) , or else of an empty
998 * slot in which an entry may be made. If the requested name is found,
999 * then on return *ipp points at the inode and *offp contains
1000 * its offset in the directory. If the name is not found, then *ipp
1001 * will be NULL and *slotp will contain information about a directory slot in
1002 * which an entry may be made (either an empty slot, or the first position
1003 * past the end of the directory).
1004 * The target directory inode (tdp) is supplied write locked (i_rwlock).
1005 *
1006 * This may not be used on "." or "..", but aliases of "." are ok.
1007 */
1008 int
1017 {
1035 ino_t ep_ino;
1043 /*
1044 * First check if there is a complete cache of the directory.
1045 */
1050 /*
1051 * We know from the 1st level dnlc cache that the entry
1052 * doesn't exist, so don't bother searching the directory
1053 * cache, but just look for space (possibly in the directory
1054 * cache).
1055 */
1059 }
1070 }
1074 /* This is the first entry in the block */
1078 }
1084 }
1085 /*
1086 * Check the validity of the entry.
1087 * If it's bad, then throw away the cache and
1088 * continue without it. The dirmangled() routine
1089 * will then be called upon it.
1090 */
1096 }
1097 /*
1098 * Remember the returned offset is the offset of the
1099 * preceding record (unless this is the 1st record
1100 * in the DIRBLKSIZ sized block (disk sector)), then it's
1101 * offset + 1. Note, no real offsets are on odd boundaries.
1102 */
1109 /* get the next entry */
1111 /*
1112 * Check the validity of this entry as well
1113 * If it's bad, then throw away the cache and
1114 * continue without it. The dirmangled() routine
1115 * will then be called upon it.
1116 */
1123 }
1127 }
1135 /*
1136 * The caller gets to set the initial slot status to
1137 * indicate whether it's interested in getting a
1138 * empty slot. For example, the status can be set
1139 * to FOUND when an entry is being deleted.
1140 */
1144 }
1154 }
1155 /*
1156 * Check the validity of the entry.
1157 * If it's bad, then throw away the cache and
1158 * continue without it. The dirmangled() routine
1159 * will then be called upon it.
1160 */
1164 }
1165 /*
1166 * Remember the returned offset is the offset of the
1167 * containing record.
1168 */
1174 /*
1175 * Set end offset to 0. Truncation is handled
1176 * because the dnlc cache will blow away the
1177 * cached directory when an entry is removed
1178 * that drops the entries left to less than half
1179 * the minumum number (dnlc_min_dir_cache).
1180 */
1194 }
1196 }
1200 /*
1201 * if the directory caching disable time has expired
1202 * enable caching again.
1203 */
1208 }
1209 /*
1210 * Attempt to cache any directories greater than the tunable
1211 * ufs_min_cache_dir. If it fails due to memory shortage
1212 * (DNOMEM), disable caching for this directory and record
1213 * the system time. Any attempt after the disable time has
1214 * expired will enable the caching again.
1215 */
1231 }
1232 }
1233 }
1235 /*
1236 * No point in using i_diroff since we must search whole directory
1237 */
1244 /*
1245 * If offset is on a block boundary,
1246 * read the next directory block.
1247 * Release previous if it exists.
1248 */
1258 }
1260 }
1262 }
1263 /*
1264 * If still looking for a slot, and at a DIRBLKSIZ
1265 * boundary, have to start looking for free space
1266 * again.
1267 */
1271 }
1272 /*
1273 * If the next entry is a zero length record or if the
1274 * record length is invalid, then skip to the next
1275 * directory block. Complete validation checks are
1276 * done if the record length is invalid.
1277 *
1278 * Full validation checks are slow so they are disabled
1279 * by default. Complete checks can be run by patching
1280 * "dirchk" to be true.
1281 *
1282 * We do not have to check the validity of
1283 * entryoffsetinblk here because it starts out as zero
1284 * and is only incremented by d_reclen values that we
1285 * validate here.
1286 */
1297 }
1299 }
1301 /*
1302 * Add named entries and free space into the directory cache
1303 */
1305 ushort_t extra;
1306 off_t off2;
1313 }
1315 /*
1316 * entries hold the previous offset if
1317 * not the 1st one
1318 */
1323 }
1327 }
1331 }
1332 }
1334 /*
1335 * If an appropriate sized slot has not yet been found,
1336 * check to see if one is available.
1337 */
1353 }
1358 }
1359 }
1360 }
1361 /*
1362 * Check for a name match.
1363 */
1381 }
1382 }
1392 }
1398 }
1401 }
1409 }
1414 }
1415 }
1418 /*
1419 * We didn't find a slot; the new directory entry should be put
1420 * at the end of the directory. Return an indication of where
1421 * this is, and set "endoff" to zero; since we're going to have
1422 * to extend the directory, we're certainly not going to
1423 * truncate it.
1424 */
1429 /*
1430 * We found a slot, and will return an indication of where that
1431 * slot is, as any new directory entry will be put there.
1432 * Since that slot will become a useful entry, if the last
1433 * useful entry we found was before this one, update the offset
1434 * of the last useful entry.
1435 */
1439 }
1442 }
1446 /*
1447 * Rename the entry in the directory tdp so that it points to
1448 * sip instead of tip.
1449 */
1450 static int
1459 {
1461 off_t offset;
1468 /*
1469 * Short circuit rename of something to itself.
1470 */
1473 }
1475 /*
1476 * We're locking 2 peer level locks, so must use tryenter
1477 * on the 2nd to avoid deadlocks that would occur
1478 * if we renamed a->b and b->a concurrently.
1479 */
1480 retry:
1483 /*
1484 * drop tip and wait (sleep) until we stand a chance
1485 * of holding sip
1486 */
1489 /*
1490 * Reverse the lock grabs in case we have heavy
1491 * contention on the 2nd lock.
1492 */
1494 ufs_dirrename_retry_cnt++;
1497 }
1498 }
1500 /*
1501 * Check that everything is on the same filesystem.
1502 */
1507 }
1508 /*
1509 * Must have write permission to rewrite target entry.
1510 * Perform additional checks for sticky directories.
1511 */
1516 /*
1517 * Ensure source and target are compatible (both directories
1518 * or both not directories). If target is a directory it must
1519 * be empty and have no links to it; in addition it must not
1520 * be a mount point, and both the source and target must be
1521 * writable.
1522 */
1530 }
1531 /*
1532 * vn_vfsrlock will prevent mounts from using the directory
1533 * until we are done.
1534 */
1538 }
1543 }
1548 }
1552 }
1554 /*
1555 * Rewrite the inode pointer for target name entry
1556 * from the target inode (ip) to the source inode (sip).
1557 * This prevents the target entry from disappearing
1558 * during a crash. Mark the directory inode to reflect the changes.
1559 */
1567 }
1571 }
1576 else
1584 }
1591 /*
1592 * Decrement the link count of the target inode.
1593 * Fix the ".." entry in sip to point to dp.
1594 * This is done after the new entry is on the disk.
1595 */
1602 /*
1603 * The entry for tip no longer exists so I can unlock the
1604 * vfslock.
1605 */
1607 /*
1608 * Decrement target link count once more if it was a directory.
1609 */
1616 }
1619 /*
1620 * Renaming a directory with the parent different
1621 * requires that ".." be rewritten. The window is
1622 * still there for ".." to be inconsistent, but this
1623 * is unavoidable, and a lot shorter than when it was
1624 * done in a user process. We decrement the link
1625 * count in the new parent as appropriate to reflect
1626 * the just-removed target. If the parent is the
1627 * same, this is appropriate since the original
1628 * directory is going away. If the new parent is
1629 * different, ufs_dirfixdotdot() will bump the link count
1630 * back.
1631 */
1643 }
1646 out:
1650 }
1652 /*
1653 * Fix the ".." entry of the child directory so that it points
1654 * to the new parent directory instead of the old one. Routine
1655 * assumes that dp is a directory and that all the inodes are on
1656 * the same file system.
1657 */
1658 static int
1663 {
1672 /*
1673 * We hold the child directory's i_contents lock before calling
1674 * blkatoff so that we honor correct locking protocol which is
1675 * i_contents lock and then page lock. (blkatoff will call
1676 * ufs_getpage where we want the page lock)
1677 * We hold the child directory's i_rwlock before i_contents (as
1678 * per the locking protocol) since we are modifying the ".." entry
1679 * of the child directory.
1680 * We hold the i_rwlock and i_contents lock until we record
1681 * this directory delta to the log (via ufs_trans_dir) and have
1682 * done fbrelse.
1683 */
1694 }
1702 }
1704 /*
1705 * Increment the link count in the new parent inode and force it out.
1706 */
1710 }
1717 /*
1718 * Rewrite the child ".." entry and force it out.
1719 */
1729 else
1739 /*
1740 * Decrement the link count of the old parent inode and force it out.
1741 */
1754 bad:
1760 }
1762 /*
1763 * Enter the file sip in the directory tdp with name namep.
1764 */
1765 static int
1775 {
1779 off_t offset;
1781 ushort_t extra;
1785 /*
1786 * Prepare a new entry. If the caller has not supplied an
1787 * existing inode, make a new one.
1788 */
1794 }
1796 }
1797 /*
1798 * Check inode to be linked to see if it is in the
1799 * same filesystem.
1800 */
1804 }
1806 /*
1807 * If renaming a directory then fix up the ".." entry in the
1808 * directory to point to the new parent.
1809 */
1815 }
1817 /*
1818 * Fill in entry data.
1819 */
1826 /*
1827 * Note the offset supplied for any named entry is
1828 * the offset of the previous one, unless it's the 1st.
1829 * slotp->size is used to pass the length to
1830 * the previous entry.
1831 */
1836 }
1839 /*
1840 * Add back any usable unused space to the dnlc directory
1841 * cache.
1842 */
1847 }
1852 /* adjust the previous offset of the next entry */
1855 /*
1856 * Not a new block.
1857 *
1858 * Check the validity of the next entry.
1859 * If it's bad, then throw away the cache, and
1860 * continue as before directory caching.
1861 */
1868 }
1869 }
1870 }
1872 /*
1873 * Write out the directory block.
1874 */
1878 else
1882 /*
1883 * If this is a rename of a directory, then we have already
1884 * fixed the ".." entry to refer to the new parent. If err
1885 * is true at this point, we have failed to update the new
1886 * parent to refer to the renamed directory.
1887 * XXX - we need to unwind the ".." fix.
1888 */
1892 /*
1893 * Mark the directory inode to reflect the changes.
1894 * Truncate the directory to chop off blocks of empty entries.
1895 */
1902 /*
1903 * If the directory grew then dirprepareentry() will have
1904 * set IATTCHG in tdp->i_flag, then the directory inode must
1905 * be flushed out. This is because if fsync() is used later
1906 * the directory size must be correct, otherwise a crash would
1907 * cause fsck to move the file to lost+found. Also because later
1908 * a file may be linked in more than one directory, then there
1909 * is no way to flush the original directory. So it must be
1910 * flushed out on creation. See bug 4293809.
1911 */
1914 }
1919 cr);
1920 }
1921 }
1926 bad:
1933 }
1935 /*
1936 * Clear out entry prepared by dirprepareent.
1937 */
1941 /*
1942 * Don't touch err so we don't clobber the real error that got us here.
1943 */
1946 else
1950 }
1952 /*
1953 * Prepare a directory slot to receive an entry.
1954 */
1955 static int
1960 {
1962 off_t entryend;
1965 ushort_t dsize;
1970 /*
1971 * If we didn't find a slot, then indicate that the
1972 * new slot belongs at the end of the directory.
1973 * If we found a slot, then the new entry can be
1974 * put at slotp->offset.
1975 */
1981 "dirprepareentry: bad fs_fsize, DIRBLKSIZ: %d"
1985 }
1986 /*
1987 * Allocate the new block.
1988 */
1993 }
2000 /*
2001 * Adjust directory size, if needed. This should never
2002 * push the size past a new multiple of DIRBLKSIZ.
2003 * This is an artifact of the old (4.2BSD) way of initializing
2004 * directory sizes to be less than DIRBLKSIZ.
2005 */
2011 }
2013 /*
2014 * Get the block containing the space for the new directory entry.
2015 */
2021 }
2022 }
2027 /*
2028 * No space in the directory. slotp->offset will be on a
2029 * directory block boundary and we will write the new entry
2030 * into a fresh block.
2031 */
2036 /*
2037 * An entry of the required size has been found. Use it.
2038 */
2040 /* this is the 1st record in a block */
2050 }
2054 }
2056 }
2058 /*
2059 * Allocate and initialize a new inode that will go into directory tdp.
2060 * This routine is called from ufs_symlink(), as well as within this file.
2061 */
2062 int
2069 {
2073 ino_t ipref;
2075 timestruc_t now;
2083 /*
2084 * Allocate a new inode.
2085 */
2091 }
2094 else
2101 /*
2102 * We don't need to grab vfs_dqrwlock here because it is held
2103 * in ufs_direnter_*() above us.
2104 */
2113 }
2118 dev32_t dev32;
2120 /*
2121 * Don't allow a special file to be created with a
2122 * dev_t that cannot be represented by this filesystem
2123 * format on disk.
2124 */
2128 }
2136 }
2137 }
2144 }
2151 /*
2152 * To determine the group-id of the created file:
2153 * 1) If the gid is set in the attribute list (non-Sun & pre-4.0
2154 * clients are not likely to set the gid), then use it if
2155 * the process is privileged, belongs to the target group,
2156 * or the group is the same as the parent directory.
2157 * 2) If the filesystem was not mounted with the Old-BSD-compatible
2158 * GRPID option, and the directory's set-gid bit is clear,
2159 * then use the process's gid.
2160 * 3) Otherwise, set the group-id to the gid of the parent directory.
2161 */
2165 /*
2166 * XXX - is this only the case when a 4.0 NFS client, or a
2167 * client derived from that code, makes a call over the wire?
2168 */
2173 /*
2174 * For SunOS 5.0->5.4, the lines below read:
2175 *
2176 * ip->i_suid = (ip->i_uid > MAXUID) ? UID_LONG : ip->i_uid;
2177 * ip->i_sgid = (ip->i_gid > MAXUID) ? GID_LONG : ip->i_gid;
2178 *
2179 * where MAXUID was set to 60002. See notes on this in ufs_inode.c
2180 */
2186 /*
2187 * If we're creating a directory, and the parent directory has the
2188 * set-GID bit set, set it on the new directory.
2189 * Otherwise, if the user is neither privileged nor a member of the
2190 * file's new group, clear the file's set-GID bit.
2191 */
2198 }
2204 }
2206 /*
2207 * Extended attribute directories are not subject to quotas.
2208 */
2211 else
2218 }
2220 /*
2221 * generate the shadow inode and attach it to the new object
2222 */
2231 /*
2232 * clean up parent directory
2233 *
2234 * tdp->i_contents already locked from
2235 * ufs_direnter_*()
2236 */
2242 }
2244 }
2245 }
2247 /*
2248 * If the passed in attributes contain atime and/or mtime
2249 * settings, then use them instead of using the current
2250 * high resolution time.
2251 */
2264 /*
2265 * In 2038, ctime sticks forever..
2266 */
2272 }
2282 /*
2283 * If this is an attribute tag it as one.
2284 */
2287 }
2289 /*
2290 * push inode before it's name appears in a directory
2291 */
2297 fail:
2298 /* Throw away inode we just allocated. */
2307 }
2309 /*
2310 * Write a prototype directory into the empty inode ip, whose parent is dp.
2311 */
2312 static int
2318 {
2326 /*
2327 * Allocate space for the directory we're creating.
2328 */
2338 }
2344 /*
2345 * Update the tdp link count and write out the change.
2346 * This reflects the ".." entry we'll soon write.
2347 */
2356 /*
2357 * Initialize directory with "."
2358 * and ".." from static template.
2359 *
2360 * Since the parent directory is locked, we don't have to
2361 * worry about anything changing when we drop the write
2362 * lock on (ip).
2363 *
2364 */
2370 }
2372 /*
2373 * Now initialize the directory we're creating
2374 * with the "." and ".." entries.
2375 */
2384 }
2389 }
2393 fail:
2401 }
2403 /*
2404 * Delete a directory entry. If oip is nonzero the entry is checked
2405 * to make sure it still reflects oip.
2406 */
2407 int
2415 {
2423 ushort_t extra;
2435 }
2437 /*
2438 * return error when removing . and ..
2439 */
2445 }
2446 }
2450 retry:
2451 /*
2452 * Check accessibility of directory.
2453 */
2469 }
2474 }
2479 /*
2480 * vn_vfsrlock() prevents races between mount and rmdir.
2481 */
2485 }
2489 }
2490 /*
2491 * If we are removing a directory, get a lock on it.
2492 * Taking a writer lock prevents a parallel ufs_dirlook from
2493 * incorrectly entering a negative cache vnode entry in the dnlc
2494 * If the directory is empty, it will stay empty until
2495 * we can remove it.
2496 */
2498 /*
2499 * It is possible that a thread in rename would have
2500 * acquired this rwlock. To prevent a deadlock we
2501 * do a rw_tryenter. If we fail to get the lock
2502 * we drop all the locks we have acquired, wait
2503 * for 2 ticks and reacquire the
2504 * directory's (dp) i_rwlock and try again.
2505 * If we dont drop dp's i_rwlock then we will panic
2506 * with a "Deadlock: cycle in blocking chain"
2507 * since in ufs_dircheckpath we want dp's i_rwlock.
2508 * dp is guaranteed to exist since ufs_dirremove is
2509 * called after a VN_HOLD(dp) has been done.
2510 */
2511 ufs_dirremove_retry_cnt++;
2522 }
2523 }
2526 /*
2527 * Now check the restrictions that apply on sticky directories.
2528 */
2534 }
2537 /*
2538 * For rmdir(2), some special checks are required.
2539 * (a) Don't remove any alias of the parent (e.g. ".").
2540 * (b) Don't remove the current directory.
2541 * (c) Make sure the entry is (still) a directory.
2542 * (d) Make sure the directory is empty.
2543 */
2553 }
2560 }
2562 /*
2563 * unlink(2) requires a different check: allow only
2564 * privileged users to unlink a directory.
2565 */
2572 }
2573 }
2577 /*
2578 * Remove the cache'd entry, if any.
2579 */
2591 }
2593 /*
2594 * Collapse new free space into previous entry.
2595 * Note, the previous entry has already been
2596 * validated in ufs_dircheckforname().
2597 */
2605 }
2610 }
2614 }
2618 /* adjust the previous pointer in the next entry */
2621 /*
2622 * Not a new block.
2623 *
2624 * Check the validity of the entry.
2625 * If it's bad, then throw away the cache and
2626 * continue.
2627 */
2635 }
2636 }
2640 }
2642 /*
2643 * If the entry isn't the first in the directory, we must
2644 * reclaim the space of the now empty record by adding
2645 * the record size to the size of the previous entry.
2646 */
2648 /*
2649 * Collapse new free space into previous entry.
2650 */
2653 }
2654 }
2655 nocache:
2661 else
2665 /*
2666 * If we were removing a directory, it is 'gone' now, but we cannot
2667 * unlock it as a thread may be waiting for the lock in ufs_create. If
2668 * we did, it could then create a file in a deleted directory.
2669 */
2675 }
2686 /*
2687 * Now dispose of the inode.
2688 */
2690 /*
2691 * This is not done for IFATTRDIR's because they don't
2692 * have entries in the dnlc and the link counts are
2693 * not incremented when they are created.
2694 */
2696 /*
2697 * Decrement by 2 because we're trashing the "."
2698 * entry as well as removing the entry in dp.
2699 * Clear the directory entry, but there may be
2700 * other hard links so don't free the inode.
2701 * Decrement the dp linkcount because we're
2702 * trashing the ".." entry.
2703 */
2707 /*
2708 * XXX need to discard negative cache entries
2709 * for vp. See comment in ufs_delete().
2710 */
2713 /*
2714 * The return value is ignored here bacause if
2715 * the directory purge fails we don't want to
2716 * stop the delete. If ufs_dirpurgedotdot fails
2717 * the delete will continue with the preexiting
2718 * behavior.
2719 */
2723 }
2725 }
2737 out:
2740 }
2741 out_novfs:
2750 /*
2751 * Release (and delete) the inode after we drop vfs_dqrwlock to
2752 * avoid deadlock since ufs_delete() grabs vfs_dqrwlock as reader.
2753 */
2758 }
2760 /*
2761 * Return buffer with contents of block "offset"
2762 * from the beginning of directory "ip". If "res"
2763 * is non-zero, fill it in with a pointer to the
2764 * remaining space in the directory.
2765 *
2766 */
2768 int
2771 off_t offset,
2774 {
2777 daddr_t lbn;
2778 uint_t bsize;
2790 }
2795 }
2797 /*
2798 * Do consistency checking:
2799 * record length must be multiple of 4
2800 * entry must fit in rest of its DIRBLKSIZ block
2801 * record must be large enough to contain entry
2802 * name is not longer than MAXNAMLEN
2803 * name must be as long as advertised, and null terminated
2804 * NOTE: record length must not be zero (should be checked previously).
2805 * This routine is only called if dirchk is true.
2806 * It would be nice to set the FSBAD flag in the super-block when
2807 * this routine fails so that a fsck is forced on next reboot,
2808 * but locking is a problem.
2809 */
2810 static int
2815 off_t offset)
2816 {
2825 }
2827 }
2829 static void
2831 {
2834 }
2836 static int
2838 {
2842 }
2843 }
2845 }
2847 /*
2848 * Check if a directory is empty or not.
2849 */
2850 static int
2853 ino_t parentino,
2855 {
2857 }
2859 /*
2860 * clear the .. directory entry.
2861 */
2862 static int
2865 ino_t parentino,
2867 {
2869 }
2871 /*
2872 * Scan the directoy. If clr_dotdot is true clear the ..
2873 * directory else check to see if the directory is empty.
2874 *
2875 * Using a struct dirtemplate here is not precisely
2876 * what we want, but better than using a struct direct.
2877 *
2878 * clr_dotdot is used as a flag to tell us if we need
2879 * to clear the dotdot entry
2880 *
2881 * N.B.: does not handle corrupted directories.
2882 */
2883 static int
2886 ino_t parentino,
2889 {
2890 offset_t off;
2895 #define MINDIRSIZ (sizeof (struct dirtemplate) / 2)
2903 /*
2904 * Since we read MINDIRSIZ, residual must
2905 * be 0 unless we're at end of file.
2906 */
2910 }
2911 /* skip empty entries */
2914 /* accept only "." and ".." */
2918 }
2919 /*
2920 * At this point d_namlen must be 1 or 2.
2921 * 1 implies ".", 2 implies ".." if second
2922 * char is also "."
2923 */
2928 /*
2929 * If we're doing a purge we need to check for
2930 * the . and .. entries and clear the d_ino for ..
2931 *
2932 * if clr_dotdot is set ufs_dirscan does not
2933 * check for an empty directory.
2934 */
2936 /*
2937 * Have to actually zap the ..
2938 * entry in the directory, as
2939 * otherwise someone might have
2940 * dp as its cwd and try to
2941 * open .., which now points to
2942 * an unallocated inode.
2943 */
2948 }
2949 }
2952 }
2954 }
2958 /*
2959 * Check if source directory inode is in the path of the target directory.
2960 * Target is supplied locked.
2961 *
2962 * The source and target inode's should be different upon entry.
2963 */
2964 int
2966 ino_t source_ino,
2970 {
2976 ino_t dotdotino;
2987 }
2991 }
2992 /*
2993 * Search back through the directory tree, using the ".." entries.
2994 * Fail any attempt to move a directory into an ancestor directory.
2995 */
3008 }
3015 }
3020 }
3026 }
3033 }
3034 /*
3035 * Race to get the inode.
3036 */
3042 }
3044 /*
3045 * If the directory of the source inode (also a directory)
3046 * is the same as this next entry up the chain, then
3047 * we know the source directory itself can't be in the
3048 * chain. This also prevents a panic because we already
3049 * have sdp->i_rwlock locked.
3050 */
3055 }
3058 /*
3059 * If someone has set the WRITE_WANTED bit in this lock and if
3060 * this happens to be a sdp or tdp of another parallel rename
3061 * which is executing the same code and in similar situation
3062 * we end up in a 4 way deadlock. We need to make sure that
3063 * the WRITE_WANTED bit is not set.
3064 */
3065 retry_lock:
3067 /*
3068 * If the lock held as WRITER thats fine but if it
3069 * has WRITE_WANTED bit set we might end up in a
3070 * deadlock. If WRITE_WANTED is set we return
3071 * with EAGAIN else we just go back and try.
3072 */
3078 }
3082 /*
3083 * The lock is being write held. We could
3084 * just do a rw_enter here but there is a
3085 * window between the check and now, where
3086 * the status could have changed, so to
3087 * avoid looping we backoff and go back to
3088 * try for the lock.
3089 */
3091 dircheck_retry_cnt++;
3093 }
3094 }
3095 }
3098 }
3099 out:
3104 }
3105 }
3107 }
3109 int
3111 {
3112 offset_t off;
3117 #define MINDIRSIZ (sizeof (struct dirtemplate) / 2)
3125 /*
3126 * Since we read MINDIRSIZ, residual must
3127 * be 0 unless we're at end of file.
3128 */
3133 }
3134 /* skip empty entries */
3137 /*
3138 * At this point d_namlen must be 1 or 2.
3139 * 1 implies ".", 2 implies ".." if second
3140 * char is also "."
3141 */
3150 }
3153 }
3155 }
3158 /*
3159 * Allocate and initialize a new shadow inode to contain extended attributes.
3160 */
3161 int
3167 {
3177 /* 1 = taken outside the transaction, */
3178 /* 2 = taken inside the transaction */
3180 /*
3181 * Validate permission to create attribute directory
3182 */
3186 }
3191 /*
3192 * No need to re-init err after again:, since it's set before
3193 * the next use of it.
3194 */
3195 again:
3210 }
3219 /*
3220 * Acquire i_rwlock before TRANS_BEGIN_CSYNC() if this is a file.
3221 * This follows the protocol for read()/write().
3222 */
3226 }
3231 }
3233 /*
3234 * Acquire i_rwlock after TRANS_BEGIN_CSYNC() if this is a directory.
3235 * This follows the protocol established by
3236 * ufs_link/create/remove/rename/mkdir/rmdir/symlink.
3237 */
3241 }
3245 /*
3246 * Suppress out of inodes messages if we will retry.
3247 */
3258 /*
3259 * Now attach it to src file.
3260 */
3263 }
3291 }
3297 fail:
3305 }
3311 /*
3312 * No inodes? See if any are tied up in pending deletions.
3313 * This has to be done outside of any of the above, because
3314 * the draining operation can't be done from inside a transaction.
3315 */
3320 }
3323 }
3325 /*
3326 * clear the dotdot directory entry.
3327 * Used by ufs_dirscan when clr_dotdot
3328 * flag is set and we're deleting a
3329 * directory.
3330 */
3331 static int
3333 {
3343 }
3357 }
3364 }
3365 }
3368 }
3370 }