| blob | 5a5e035e5d388a0fa844c9c66a47cf92dd2db1e7 |
1 /*
2 * Copyright (c) 2000-2006 Silicon Graphics, Inc.
3 * All Rights Reserved.
4 *
5 * This program is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU General Public License as
7 * published by the Free Software Foundation.
8 *
9 * This program is distributed in the hope that it would be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write the Free Software Foundation,
16 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
17 */
18 #include <linux/log2.h>
59 /*
60 * Used in xfs_itruncate(). This is the maximum number of extents
61 * freed from a file in a single transaction.
62 */
63 #define XFS_ITRUNC_MAX_EXTENTS 2
70 #ifdef DEBUG
71 /*
72 * Make sure that the extents in the given memory buffer
73 * are valid.
74 */
75 STATIC void
79 xfs_exntfmt_t fmt)
80 {
81 xfs_bmbt_irec_t irec;
82 xfs_bmbt_rec_host_t rec;
92 }
93 }
95 #define xfs_validate_extents(ifp, nrecs, fmt)
98 /*
99 * Check that none of the inode's in the buffer have a next
100 * unlinked field of 0.
101 */
102 #if defined(DEBUG)
103 void
107 {
119 "Detected a bogus zero next_unlinked field in incore inode buffer 0x%p. About to pop an ASSERT.",
120 bp);
122 }
123 }
124 }
125 #endif
127 /*
128 * Find the buffer associated with the given inode map
129 * We do basic validation checks on the buffer once it has been
130 * retrieved from disk.
131 */
132 STATIC int
138 uint buf_flags,
139 uint iget_flags)
140 {
151 "xfs_imap_to_bp: xfs_trans_read_buf()returned "
156 }
158 }
160 /*
161 * Validate the magic number and version of every inode in the buffer
162 * (if DEBUG kernel) or the first inode in the buffer, otherwise.
163 */
164 #ifdef DEBUG
168 #endif
179 XFS_ERRTAG_ITOBP_INOTOBP,
180 XFS_RANDOM_ITOBP_INOTOBP))) {
184 }
187 #ifdef DEBUG
189 "Device %s - bad inode magic/vsn "
194 #endif
197 }
198 }
202 /*
203 * Mark the buffer as an inode buffer now that it looks good
204 */
209 }
211 /*
212 * This routine is called to map an inode number within a file
213 * system to the buffer containing the on-disk version of the
214 * inode. It returns a pointer to the buffer containing the
215 * on-disk inode in the bpp parameter, and in the dip parameter
216 * it returns a pointer to the on-disk inode within that buffer.
217 *
218 * If a non-zero error is returned, then the contents of bpp and
219 * dipp are undefined.
220 *
221 * Use xfs_imap() to determine the size and location of the
222 * buffer to read from disk.
223 */
224 int
228 xfs_ino_t ino,
232 uint imap_flags)
233 {
251 }
254 /*
255 * This routine is called to map an inode to the buffer containing
256 * the on-disk version of the inode. It returns a pointer to the
257 * buffer containing the on-disk inode in the bpp parameter, and in
258 * the dip parameter it returns a pointer to the on-disk inode within
259 * that buffer.
260 *
261 * If a non-zero error is returned, then the contents of bpp and
262 * dipp are undefined.
263 *
264 * The inode is expected to already been mapped to its buffer and read
265 * in once, thus we can use the mapping information stored in the inode
266 * rather than calling xfs_imap(). This allows us to avoid the overhead
267 * of looking at the inode btree for small block file systems
268 * (see xfs_imap()).
269 */
270 int
277 uint buf_flags)
278 {
293 }
298 }
300 /*
301 * Move inode type and inode format specific information from the
302 * on-disk inode to the in-core inode. For fifos, devs, and sockets
303 * this means set if_rdev to the proper value. For files, directories,
304 * and symlinks this means to bring in the in-line data or extent
305 * pointers. For a file in B-tree format, only the root is immediately
306 * brought in-core. The rest will be in-lined in if_extents when it
307 * is first referenced (see xfs_iread_extents()).
308 */
309 STATIC int
313 {
317 xfs_fsize_t di_size;
335 }
345 }
356 }
367 /*
368 * no local regular files yet
369 */
372 "corrupt inode %Lu "
376 XFS_ERRLEVEL_LOW,
379 }
384 "corrupt inode %Lu "
389 XFS_ERRLEVEL_LOW,
392 }
407 }
413 }
416 }
438 }
443 }
445 }
447 /*
448 * The file is in-lined in the on-disk inode.
449 * If it fits into if_inline_data, then copy
450 * it there, otherwise allocate a buffer for it
451 * and copy the data there. Either way, set
452 * if_data to point at the data.
453 * If we allocate a buffer for the data, make
454 * sure that its size is a multiple of 4 and
455 * record the real size in i_real_bytes.
456 */
457 STATIC int
463 {
467 /*
468 * If the size is unreasonable, then something
469 * is wrong and we just bail out rather than crash in
470 * kmem_alloc() or memcpy() below.
471 */
474 "corrupt inode %Lu "
481 }
491 }
499 }
501 /*
502 * The file consists of a set of extents all
503 * of which fit into the on-disk inode.
504 * If there are few enough extents to fit into
505 * the if_inline_ext, then copy them there.
506 * Otherwise allocate a buffer for them and copy
507 * them into it. Either way, set if_extents
508 * to point at the extents.
509 */
510 STATIC int
515 {
526 /*
527 * If the number of extents is unreasonable, then something
528 * is wrong and we just bail out rather than crash in
529 * kmem_alloc() or memcpy() below.
530 */
538 }
545 else
556 }
563 XFS_ERRLEVEL_LOW,
566 }
567 }
570 }
572 /*
573 * The file has too many extents to fit into
574 * the inode, so they are in B-tree format.
575 * Allocate a buffer for the root of the B-tree
576 * and copy the root into it. The i_extents
577 * field will remain NULL until all of the
578 * extents are read in (when they are needed).
579 */
580 STATIC int
585 {
588 /* REFERENCED */
597 /*
598 * blow out if -- fork has less extents than can fit in
599 * fork (fork shouldn't be a btree format), root btree
600 * block has more records than can fit into the fork,
601 * or the number of extents is greater than the number of
602 * blocks.
603 */
614 }
619 /*
620 * Copy and convert from the on-disk structure
621 * to the in-memory structure.
622 */
630 }
632 void
636 {
665 }
667 void
671 {
700 }
702 STATIC uint
704 __uint16_t di_flags)
705 {
737 }
740 }
742 uint
745 {
750 }
752 uint
755 {
758 }
760 /*
761 * Read the disk inode attributes into the in-core inode structure.
762 */
763 int
768 xfs_daddr_t bno,
769 uint iget_flags)
770 {
775 /*
776 * Fill in the location information in the in-core inode.
777 */
784 /*
785 * Get pointers to the on-disk inode and the buffer containing it.
786 */
793 /*
794 * If we got something that isn't an inode it means someone
795 * (nfs or dmi) has a stale handle.
796 */
798 #ifdef DEBUG
800 "dip->di_magic (0x%x) != "
803 XFS_DINODE_MAGIC);
807 }
809 /*
810 * If the on-disk inode is already linked to a directory
811 * entry, copy all of the inode into the in-core inode.
812 * xfs_iformat() handles copying in the inode format
813 * specific information.
814 * Otherwise, just get the truly permanent information.
815 */
820 #ifdef DEBUG
823 error);
826 }
832 /*
833 * Make sure to pull in the mode here as well in
834 * case the inode is released without being used.
835 * This ensures that xfs_inactive() will see that
836 * the inode is already free and not try to mess
837 * with the uninitialized part of it.
838 */
840 /*
841 * Initialize the per-fork minima and maxima for a new
842 * inode here. xfs_iformat will do it for old inodes.
843 */
846 }
848 /*
849 * The inode format changed when we moved the link count and
850 * made it 32 bits long. If this is an old format inode,
851 * convert it in memory to look like a new one. If it gets
852 * flushed to disk we will convert back before flushing or
853 * logging it. We zero out the new projid field and the old link
854 * count field. We'll handle clearing the pad field (the remains
855 * of the old uuid field) when we actually convert the inode to
856 * the new format. We don't change the version number so that we
857 * can distinguish this from a real new format inode.
858 */
863 }
868 /*
869 * Mark the buffer containing the inode as something to keep
870 * around for a while. This helps to keep recently accessed
871 * meta-data in-core longer.
872 */
875 /*
876 * Use xfs_trans_brelse() to release the buffer containing the
877 * on-disk inode, because it was acquired with xfs_trans_read_buf()
878 * in xfs_itobp() above. If tp is NULL, this is just a normal
879 * brelse(). If we're within a transaction, then xfs_trans_brelse()
880 * will only release the buffer if it is not dirty within the
881 * transaction. It will be OK to release the buffer in this case,
882 * because inodes on disk are never destroyed and we will be
883 * locking the new in-core inode before putting it in the hash
884 * table where other processes can find it. Thus we don't have
885 * to worry about the inode being changed just because we released
886 * the buffer.
887 */
888 out_brelse:
891 }
893 /*
894 * Read in extents from a btree-format inode.
895 * Allocate and fill in if_extents. Real work is done in xfs_bmap.c.
896 */
897 int
902 {
905 xfs_extnum_t nextents;
912 }
917 /*
918 * We know that the size is valid (it's checked in iformat_btree)
919 */
929 }
932 }
934 /*
935 * Allocate an inode on disk and return a copy of its in-core version.
936 * The in-core inode is locked exclusively. Set mode, nlink, and rdev
937 * appropriately within the inode. The uid and gid for the inode are
938 * set according to the contents of the given cred structure.
939 *
940 * Use xfs_dialloc() to allocate the on-disk inode. If xfs_dialloc()
941 * has a free inode available, call xfs_iget()
942 * to obtain the in-core version of the allocated inode. Finally,
943 * fill in the inode and log its initial contents. In this case,
944 * ialloc_context would be set to NULL and call_again set to false.
945 *
946 * If xfs_dialloc() does not have an available inode,
947 * it will replenish its supply by doing an allocation. Since we can
948 * only do one allocation within a transaction without deadlocks, we
949 * must commit the current transaction before returning the inode itself.
950 * In this case, therefore, we will set call_again to true and return.
951 * The caller should then commit the current transaction, start a new
952 * transaction, and call xfs_ialloc() again to actually get the inode.
953 *
954 * To ensure that some other process does not grab the inode that
955 * was allocated during the first call to xfs_ialloc(), this routine
956 * also returns the [locked] bp pointing to the head of the freelist
957 * as ialloc_context. The caller should hold this buffer across
958 * the commit and pass it back into this routine on the second call.
959 *
960 * If we are allocating quota inodes, we do not have a parent inode
961 * to attach to or associate with (i.e. pip == NULL) because they
962 * are not linked into the directory structure - they are attached
963 * directly to the superblock - and so have no parent.
964 */
965 int
969 mode_t mode,
970 xfs_nlink_t nlink,
971 xfs_dev_t rdev,
973 xfs_prid_t prid,
978 {
979 xfs_ino_t ino;
981 uint flags;
983 timespec_t tv;
986 /*
987 * Call the space management code to pick
988 * the on-disk inode to be allocated.
989 */
997 }
1000 /*
1001 * Get the in-core inode with the lock held exclusively.
1002 * This is because we're setting fields here we need
1003 * to prevent others from looking at until we're done.
1004 */
1020 /*
1021 * If the superblock version is up to where we support new format
1022 * inodes and this is currently an old format inode, then change
1023 * the inode version number now. This way we only do the conversion
1024 * here rather than here and in the flush/logging code.
1025 */
1029 /*
1030 * We've already zeroed the old link count, the projid field,
1031 * and the pad field.
1032 */
1033 }
1035 /*
1036 * Project ids won't be stored on disk if we are using a version 1 inode.
1037 */
1045 }
1046 }
1048 /*
1049 * If the group ID of the new file does not match the effective group
1050 * ID or one of the supplementary group IDs, the S_ISGID bit is cleared
1051 * (and only if the irix_sgid_inherit compatibility variable is set).
1052 */
1057 }
1070 /*
1071 * di_gen will have been taken care of in xfs_iread.
1072 */
1089 /*
1090 * we can't set up filestreams until after the VFS inode
1091 * is set up properly.
1092 */
1095 /* fall through */
1106 }
1113 }
1114 }
1116 xfs_inherit_noatime)
1119 xfs_inherit_nodump)
1122 xfs_inherit_sync)
1125 xfs_inherit_nosymlinks)
1130 xfs_inherit_nodefrag)
1135 }
1136 /* FALLTHROUGH */
1145 }
1146 /*
1147 * Attribute fork settings for new inode.
1148 */
1152 /*
1153 * Log the new values stuffed into the inode.
1154 */
1157 /* now that we have an i_mode we can setup inode ops and unlock */
1160 /* now we have set up the vfs inode we can associate the filestream */
1167 }
1171 }
1173 /*
1174 * Check to make sure that there are no blocks allocated to the
1175 * file beyond the size of the file. We don't check this for
1176 * files with fixed size extents or real time extents, but we
1177 * at least do it for regular files.
1178 */
1179 #ifdef DEBUG
1180 void
1184 xfs_fsize_t isize)
1185 {
1186 xfs_fileoff_t map_first;
1201 /*
1202 * The filesystem could be shutting down, so bmapi may return
1203 * an error.
1204 */
1208 map_first),
1214 }
1217 /*
1218 * Calculate the last possible buffered byte in a file. This must
1219 * include data that was buffered beyond the EOF by the write code.
1220 * This also needs to deal with overflowing the xfs_fsize_t type
1221 * which can happen for sizes near the limit.
1222 *
1223 * We also need to take into account any blocks beyond the EOF. It
1224 * may be the case that they were buffered by a write which failed.
1225 * In that case the pages will still be in memory, but the inode size
1226 * will never have been updated.
1227 */
1228 xfs_fsize_t
1231 {
1233 xfs_fsize_t last_byte;
1234 xfs_fileoff_t last_block;
1235 xfs_fileoff_t size_last_block;
1241 /*
1242 * Only check for blocks beyond the EOF if the extents have
1243 * been read in. This eliminates the need for the inode lock,
1244 * and it also saves us from looking when it really isn't
1245 * necessary.
1246 */
1249 XFS_DATA_FORK);
1252 }
1255 }
1262 }
1266 }
1268 }
1270 #if defined(XFS_RW_TRACE)
1271 STATIC void
1276 xfs_fsize_t new_size,
1277 xfs_off_t toss_start,
1278 xfs_off_t toss_finish)
1279 {
1282 }
1301 }
1302 #else
1303 #define xfs_itrunc_trace(tag, ip, flag, new_size, toss_start, toss_finish)
1304 #endif
1306 /*
1307 * Start the truncation of the file to new_size. The new size
1308 * must be smaller than the current size. This routine will
1309 * clear the buffer and page caches of file data in the removed
1310 * range, and xfs_itruncate_finish() will remove the underlying
1311 * disk blocks.
1312 *
1313 * The inode must have its I/O lock locked EXCLUSIVELY, and it
1314 * must NOT have the inode lock held at all. This is because we're
1315 * calling into the buffer/page cache code and we can't hold the
1316 * inode lock when we do so.
1317 *
1318 * We need to wait for any direct I/Os in flight to complete before we
1319 * proceed with the truncate. This is needed to prevent the extents
1320 * being read or written by the direct I/Os from being removed while the
1321 * I/O is in flight as there is no other method of synchronising
1322 * direct I/O with the truncate operation. Also, because we hold
1323 * the IOLOCK in exclusive mode, we prevent new direct I/Os from being
1324 * started until the truncate completes and drops the lock. Essentially,
1325 * the xfs_ioend_wait() call forms an I/O barrier that provides strict
1326 * ordering between direct I/Os and the truncate operation.
1327 *
1328 * The flags parameter can have either the value XFS_ITRUNC_DEFINITE
1329 * or XFS_ITRUNC_MAYBE. The XFS_ITRUNC_MAYBE value should be used
1330 * in the case that the caller is locking things out of order and
1331 * may not be able to call xfs_itruncate_finish() with the inode lock
1332 * held without dropping the I/O lock. If the caller must drop the
1333 * I/O lock before calling xfs_itruncate_finish(), then xfs_itruncate_start()
1334 * must be called again with all the same restrictions as the initial
1335 * call.
1336 */
1337 int
1340 uint flags,
1341 xfs_fsize_t new_size)
1342 {
1343 xfs_fsize_t last_byte;
1344 xfs_off_t toss_start;
1355 /* wait for the completion of any pending DIOs */
1359 /*
1360 * Call toss_pages or flushinval_pages to get rid of pages
1361 * overlapping the region being removed. We have to use
1362 * the less efficient flushinval_pages in the case that the
1363 * caller may not be able to finish the truncate without
1364 * dropping the inode's I/O lock. Make sure
1365 * to catch any pages brought in by buffers overlapping
1366 * the EOF by searching out beyond the isize by our
1367 * block size. We round new_size up to a block boundary
1368 * so that we don't toss things on the same block as
1369 * new_size but before it.
1370 *
1371 * Before calling toss_page or flushinval_pages, make sure to
1372 * call remapf() over the same region if the file is mapped.
1373 * This frees up mapped file references to the pages in the
1374 * given range and for the flushinval_pages case it ensures
1375 * that we get the latest mapped changes flushed out.
1376 */
1380 /*
1381 * The place to start tossing is beyond our maximum
1382 * file size, so there is no way that the data extended
1383 * out there.
1384 */
1386 }
1389 last_byte);
1397 }
1398 }
1400 #ifdef DEBUG
1403 }
1404 #endif
1406 }
1408 /*
1409 * Shrink the file to the given new_size. The new size must be smaller than
1410 * the current size. This will free up the underlying blocks in the removed
1411 * range after a call to xfs_itruncate_start() or xfs_atruncate_start().
1412 *
1413 * The transaction passed to this routine must have made a permanent log
1414 * reservation of at least XFS_ITRUNCATE_LOG_RES. This routine may commit the
1415 * given transaction and start new ones, so make sure everything involved in
1416 * the transaction is tidy before calling here. Some transaction will be
1417 * returned to the caller to be committed. The incoming transaction must
1418 * already include the inode, and both inode locks must be held exclusively.
1419 * The inode must also be "held" within the transaction. On return the inode
1420 * will be "held" within the returned transaction. This routine does NOT
1421 * require any disk space to be reserved for it within the transaction.
1422 *
1423 * The fork parameter must be either xfs_attr_fork or xfs_data_fork, and it
1424 * indicates the fork which is to be truncated. For the attribute fork we only
1425 * support truncation to size 0.
1426 *
1427 * We use the sync parameter to indicate whether or not the first transaction
1428 * we perform might have to be synchronous. For the attr fork, it needs to be
1429 * so if the unlink of the inode is not yet known to be permanent in the log.
1430 * This keeps us from freeing and reusing the blocks of the attribute fork
1431 * before the unlink of the inode becomes permanent.
1432 *
1433 * For the data fork, we normally have to run synchronously if we're being
1434 * called out of the inactive path or we're being called out of the create path
1435 * where we're truncating an existing file. Either way, the truncate needs to
1436 * be sync so blocks don't reappear in the file with altered data in case of a
1437 * crash. wsync filesystems can run the first case async because anything that
1438 * shrinks the inode has to run sync so by the time we're called here from
1439 * inactive, the inode size is permanently set to 0.
1440 *
1441 * Calls from the truncate path always need to be sync unless we're in a wsync
1442 * filesystem and the file has already been unlinked.
1443 *
1444 * The caller is responsible for correctly setting the sync parameter. It gets
1445 * too hard for us to guess here which path we're being called out of just
1446 * based on inode state.
1447 *
1448 * If we get an error, we must return with the inode locked and linked into the
1449 * current transaction. This keeps things simple for the higher level code,
1450 * because it always knows that the inode is locked and held in the transaction
1451 * that returns to it whether errors occur or not. We don't mark the inode
1452 * dirty on error so that transactions can be easily aborted if possible.
1453 */
1454 int
1458 xfs_fsize_t new_size,
1461 {
1462 xfs_fsblock_t first_block;
1463 xfs_fileoff_t first_unmap_block;
1464 xfs_fileoff_t last_block;
1470 xfs_bmap_free_t free_list;
1486 /*
1487 * We only support truncating the entire attribute fork.
1488 */
1491 }
1494 /*
1495 * The first thing we do is set the size to new_size permanently
1496 * on disk. This way we don't have to worry about anyone ever
1497 * being able to look at the data being freed even in the face
1498 * of a crash. What we're getting around here is the case where
1499 * we free a block, it is allocated to another file, it is written
1500 * to, and then we crash. If the new data gets written to the
1501 * file but the log buffers containing the free and reallocation
1502 * don't, then we'd end up with garbage in the blocks being freed.
1503 * As long as we make the new_size permanent before actually
1504 * freeing any blocks it doesn't matter if they get writtten to.
1505 *
1506 * The callers must signal into us whether or not the size
1507 * setting here must be synchronous. There are a few cases
1508 * where it doesn't have to be synchronous. Those cases
1509 * occur if the file is unlinked and we know the unlink is
1510 * permanent or if the blocks being truncated are guaranteed
1511 * to be beyond the inode eof (regardless of the link count)
1512 * and the eof value is permanent. Both of these cases occur
1513 * only on wsync-mounted filesystems. In those cases, we're
1514 * guaranteed that no user will ever see the data in the blocks
1515 * that are being truncated so the truncate can run async.
1516 * In the free beyond eof case, the file may wind up with
1517 * more blocks allocated to it than it needs if we crash
1518 * and that won't get fixed until the next time the file
1519 * is re-opened and closed but that's ok as that shouldn't
1520 * be too many blocks.
1521 *
1522 * However, we can't just make all wsync xactions run async
1523 * because there's one call out of the create path that needs
1524 * to run sync where it's truncating an existing file to size
1525 * 0 whose size is > 0.
1526 *
1527 * It's probably possible to come up with a test in this
1528 * routine that would correctly distinguish all the above
1529 * cases from the values of the function parameters and the
1530 * inode state but for sanity's sake, I've decided to let the
1531 * layers above just tell us. It's simpler to correctly figure
1532 * out in the layer above exactly under what conditions we
1533 * can run async and I think it's easier for others read and
1534 * follow the logic in case something has to be changed.
1535 * cscope is your friend -- rcc.
1536 *
1537 * The attribute fork is much simpler.
1538 *
1539 * For the attribute fork we allow the caller to tell us whether
1540 * the unlink of the inode that led to this call is yet permanent
1541 * in the on disk log. If it is not and we will be freeing extents
1542 * in this inode then we make the first transaction synchronous
1543 * to make sure that the unlink is permanent by the time we free
1544 * the blocks.
1545 */
1548 /*
1549 * If we are not changing the file size then do
1550 * not update the on-disk file size - we may be
1551 * called from xfs_inactive_free_eofblocks(). If we
1552 * update the on-disk file size and then the system
1553 * crashes before the contents of the file are
1554 * flushed to disk then the files may be full of
1555 * holes (ie NULL files bug).
1556 */
1561 }
1562 }
1567 }
1573 /*
1574 * Since it is possible for space to become allocated beyond
1575 * the end of the file (in a crash where the space is allocated
1576 * but the inode size is not yet updated), simply remove any
1577 * blocks which show up between the new EOF and the maximum
1578 * possible file size. If the first block to be removed is
1579 * beyond the maximum file size (ie it is the same as last_block),
1580 * then there is nothing to do.
1581 */
1589 }
1591 /*
1592 * Free up up to XFS_ITRUNC_MAX_EXTENTS. xfs_bunmapi()
1593 * will tell us whether it freed the entire range or
1594 * not. If this is a synchronous mount (wsync),
1595 * then we can tell bunmapi to keep all the
1596 * transactions asynchronous since the unlink
1597 * transaction that made this inode inactive has
1598 * already hit the disk. There's no danger of
1599 * the freed blocks being reused, there being a
1600 * crash, and the reused blocks suddenly reappearing
1601 * in this file with garbage in them once recovery
1602 * runs.
1603 */
1609 XFS_ITRUNC_MAX_EXTENTS,
1613 /*
1614 * If the bunmapi call encounters an error,
1615 * return to the caller where the transaction
1616 * can be properly aborted. We just need to
1617 * make sure we're not holding any resources
1618 * that we were not when we came in.
1619 */
1622 }
1624 /*
1625 * Duplicate the transaction that has the permanent
1626 * reservation and commit the old transaction.
1627 */
1631 /* link the inode into the next xact in the chain */
1635 }
1638 /*
1639 * If the bmap finish call encounters an error, return
1640 * to the caller where the transaction can be properly
1641 * aborted. We just need to make sure we're not
1642 * holding any resources that we were not when we came
1643 * in.
1644 *
1645 * Aborting from this point might lose some blocks in
1646 * the file system, but oh well.
1647 */
1650 }
1653 /*
1654 * Mark the inode dirty so it will be logged and
1655 * moved forward in the log as part of every commit.
1656 */
1658 }
1664 /* link the inode into the next transaction in the chain */
1670 /*
1671 * transaction commit worked ok so we can drop the extra ticket
1672 * reference that we gained in xfs_trans_dup()
1673 */
1677 XFS_TRANS_PERM_LOG_RES,
1678 XFS_ITRUNCATE_LOG_COUNT);
1681 }
1682 /*
1683 * Only update the size in the case of the data fork, but
1684 * always re-log the inode so that our permanent transaction
1685 * can keep on rolling it forward in the log.
1686 */
1689 /*
1690 * If we are not changing the file size then do
1691 * not update the on-disk file size - we may be
1692 * called from xfs_inactive_free_eofblocks(). If we
1693 * update the on-disk file size and then the system
1694 * crashes before the contents of the file are
1695 * flushed to disk then the files may be full of
1696 * holes (ie NULL files bug).
1697 */
1701 }
1702 }
1712 }
1714 /*
1715 * This is called when the inode's link count goes to 0.
1716 * We place the on-disk inode on a list in the AGI. It
1717 * will be pulled from this list when the inode is freed.
1718 */
1719 int
1723 {
1729 xfs_agino_t agino;
1740 /*
1741 * Get the agi buffer first. It ensures lock ordering
1742 * on the list.
1743 */
1749 /*
1750 * Get the index into the agi hash table for the
1751 * list this inode will go on.
1752 */
1760 /*
1761 * There is already another inode in the bucket we need
1762 * to add ourselves to. Add us at the front of the list.
1763 * Here we put the head pointer into our next pointer,
1764 * and then we fall through to point the head at us.
1765 */
1771 /* both on-disk, don't endian flip twice */
1779 }
1781 /*
1782 * Point the bucket head pointer at the inode being inserted.
1783 */
1791 }
1793 /*
1794 * Pull the on-disk inode from the AGI unlinked list.
1795 */
1796 STATIC int
1800 {
1801 xfs_ino_t next_ino;
1807 xfs_agnumber_t agno;
1808 xfs_agino_t agino;
1809 xfs_agino_t next_agino;
1819 /*
1820 * Get the agi buffer first. It ensures lock ordering
1821 * on the list.
1822 */
1829 /*
1830 * Get the index into the agi hash table for the
1831 * list this inode will go on.
1832 */
1840 /*
1841 * We're at the head of the list. Get the inode's
1842 * on-disk buffer to see if there is anyone after us
1843 * on the list. Only modify our next pointer if it
1844 * is not already NULLAGINO. This saves us the overhead
1845 * of dealing with the buffer when there is no need to
1846 * change it.
1847 */
1854 }
1867 }
1868 /*
1869 * Point the bucket head pointer at the next inode.
1870 */
1879 /*
1880 * We need to search the list for the inode being freed.
1881 */
1885 /*
1886 * If the last inode wasn't the one pointing to
1887 * us, then release its buffer since we're not
1888 * going to do anything with it.
1889 */
1892 }
1901 }
1905 }
1906 /*
1907 * Now last_ibp points to the buffer previous to us on
1908 * the unlinked list. Pull us from the list.
1909 */
1916 }
1930 }
1931 /*
1932 * Point the previous inode on the list to the next inode.
1933 */
1941 }
1943 }
1945 STATIC void
1949 xfs_ino_t inum)
1950 {
1956 xfs_daddr_t blkno;
1972 }
1981 /*
1982 * Look for each inode in memory and attempt to lock it,
1983 * we can be racing with flush and tail pushing here.
1984 * any inode we get the locks on, add to an array of
1985 * inode items to process later.
1986 *
1987 * The get the buffer lock, we could beat a flush
1988 * or tail pushing thread to the lock here, in which
1989 * case they will go looking for the inode buffer
1990 * and fail, we need some other form of interlock
1991 * here.
1992 */
1999 /* Inode not in memory or we found it already,
2000 * nothing to do
2001 */
2005 }
2010 }
2012 /* If we can get the locks then add it to the
2013 * list, otherwise by the time we get the bp lock
2014 * below it will already be attached to the
2015 * inode buffer.
2016 */
2018 /* This inode will already be locked - by us, lets
2019 * keep it that way.
2020 */
2029 }
2030 }
2033 }
2044 }
2047 }
2048 }
2050 }
2054 XFS_BUF_LOCK);
2067 pre_flushed++;
2068 }
2070 }
2081 }
2094 }
2095 }
2100 }
2104 }
2106 /*
2107 * This is called to return an inode to the inode free list.
2108 * The inode should already be truncated to 0 length and have
2109 * no pages associated with it. This routine also assumes that
2110 * the inode is already a part of the transaction.
2111 *
2112 * The on-disk copy of the inode will have been added to the list
2113 * of unlinked inodes in the AGI. We need to remove the inode from
2114 * that list atomically with respect to freeing it here.
2115 */
2116 int
2121 {
2124 xfs_ino_t first_ino;
2137 /*
2138 * Pull the on-disk inode from the AGI unlinked list.
2139 */
2143 }
2148 }
2157 /*
2158 * Bump the generation count so no one will be confused
2159 * by reincarnations of this inode.
2160 */
2169 /*
2170 * Clear the on-disk di_mode. This is to prevent xfs_bulkstat
2171 * from picking up this inode when it is reclaimed (its incore state
2172 * initialzed but not flushed to disk yet). The in-core di_mode is
2173 * already cleared and a corresponding transaction logged.
2174 * The hack here just synchronizes the in-core to on-disk
2175 * di_mode value in advance before the actual inode sync to disk.
2176 * This is OK because the inode is already unlinked and would never
2177 * change its di_mode again for this inode generation.
2178 * This is a temporary hack that would require a proper fix
2179 * in the future.
2180 */
2185 }
2188 }
2190 /*
2191 * Reallocate the space for if_broot based on the number of records
2192 * being added or deleted as indicated in rec_diff. Move the records
2193 * and pointers in if_broot to fit the new size. When shrinking this
2194 * will eliminate holes between the records and pointers created by
2195 * the caller. When growing this will create holes to be filled in
2196 * by the caller.
2197 *
2198 * The caller must not request to add more records than would fit in
2199 * the on-disk inode root. If the if_broot is currently NULL, then
2200 * if we adding records one will be allocated. The caller must also
2201 * not request that the number of records go below zero, although
2202 * it can go to zero.
2203 *
2204 * ip -- the inode whose if_broot area is changing
2205 * ext_diff -- the change in the number of records, positive or negative,
2206 * requested for the if_broot array.
2207 */
2208 void
2213 {
2223 /*
2224 * Handle the degenerate case quietly.
2225 */
2228 }
2232 /*
2233 * If there wasn't any memory allocated before, just
2234 * allocate it now and get out.
2235 */
2241 }
2243 /*
2244 * If there is already an existing if_broot, then we need
2245 * to realloc() it and shift the pointers to their new
2246 * location. The records don't change location because
2247 * they are kept butted up against the btree block header.
2248 */
2254 KM_SLEEP);
2264 }
2266 /*
2267 * rec_diff is less than 0. In this case, we are shrinking the
2268 * if_broot buffer. It must already exist. If we go to zero
2269 * records, just get rid of the root and clear the status bit.
2270 */
2277 else
2281 /*
2282 * First copy over the btree block header.
2283 */
2288 }
2290 /*
2291 * Only copy the records and pointers if there are any.
2292 */
2294 /*
2295 * First copy the records.
2296 */
2301 /*
2302 * Then copy the pointers.
2303 */
2309 }
2316 }
2319 /*
2320 * This is called when the amount of space needed for if_data
2321 * is increased or decreased. The change in size is indicated by
2322 * the number of bytes that need to be added or deleted in the
2323 * byte_diff parameter.
2324 *
2325 * If the amount of space needed has decreased below the size of the
2326 * inline buffer, then switch to using the inline buffer. Otherwise,
2327 * use kmem_realloc() or kmem_alloc() to adjust the size of the buffer
2328 * to what is needed.
2329 *
2330 * ip -- the inode whose if_data area is changing
2331 * byte_diff -- the change in the number of bytes, positive or negative,
2332 * requested for the if_data array.
2333 */
2334 void
2339 {
2346 }
2355 }
2359 /*
2360 * If the valid extents/data can fit in if_inline_ext/data,
2361 * copy them from the malloc'd vector and free it.
2362 */
2368 new_size);
2371 }
2374 /*
2375 * Stuck with malloc/realloc.
2376 * For inline data, the underlying buffer must be
2377 * a multiple of 4 bytes in size so that it can be
2378 * logged and stay on word boundaries. We enforce
2379 * that here.
2380 */
2386 /*
2387 * Only do the realloc if the underlying size
2388 * is really changing.
2389 */
2393 real_size,
2395 KM_SLEEP);
2396 }
2402 }
2403 }
2407 }
2409 void
2413 {
2420 }
2422 /*
2423 * If the format is local, then we can't have an extents
2424 * array so just look for an inline data array. If we're
2425 * not local then we may or may not have an extents list,
2426 * so check and free it up if we do.
2427 */
2435 }
2442 }
2449 }
2450 }
2452 /*
2453 * Increment the pin count of the given buffer.
2454 * This value is protected by ipinlock spinlock in the mount structure.
2455 */
2456 void
2459 {
2463 }
2465 /*
2466 * Decrement the pin count of the given inode, and wake up
2467 * anyone in xfs_iwait_unpin() if the count goes to 0. The
2468 * inode must have been previously pinned with a call to xfs_ipin().
2469 */
2470 void
2473 {
2478 }
2480 /*
2481 * This is called to unpin an inode. It can be directed to wait or to return
2482 * immediately without waiting for the inode to be unpinned. The caller must
2483 * have the inode locked in at least shared mode so that the buffer cannot be
2484 * subsequently pinned once someone is waiting for it to be unpinned.
2485 */
2486 STATIC void
2490 {
2497 /* Give the log a push to start the unpinning I/O */
2502 }
2507 {
2509 }
2514 {
2516 }
2519 /*
2520 * xfs_iextents_copy()
2521 *
2522 * This is called to copy the REAL extents (as opposed to the delayed
2523 * allocation extents) from the inode into the given buffer. It
2524 * returns the number of bytes copied into the buffer.
2525 *
2526 * If there are no delayed allocation extents, then we can just
2527 * memcpy() the extents into the buffer. Otherwise, we need to
2528 * examine each extent in turn and skip those which are delayed.
2529 */
2530 int
2535 {
2540 xfs_fsblock_t start_block;
2550 /*
2551 * There are some delayed allocation extents in the
2552 * inode, so copy the extents one at a time and skip
2553 * the delayed ones. There must be at least one
2554 * non-delayed extent.
2555 */
2561 /*
2562 * It's a delayed allocation extent, so skip it.
2563 */
2565 }
2567 /* Translate to on disk format */
2570 dp++;
2571 copied++;
2572 }
2577 }
2579 /*
2580 * Each of the following cases stores data into the same region
2581 * of the on-disk inode, so only one of them can be valid at
2582 * any given time. While it is possible to have conflicting formats
2583 * and log flags, e.g. having XFS_ILOG_?DATA set when the fork is
2584 * in EXTENTS format, this can only happen when the fork has
2585 * changed formats after being modified but before being flushed.
2586 * In these cases, the format always takes precedence, because the
2587 * format indicates the current state of the fork.
2588 */
2589 /*ARGSUSED*/
2590 STATIC void
2597 {
2601 #ifdef XFS_TRANS_DEBUG
2603 #endif
2614 /*
2615 * This can happen if we gave up in iformat in an error path,
2616 * for the attribute fork.
2617 */
2621 }
2631 }
2645 whichfork);
2646 }
2655 XFS_BROOT_SIZE_ADJ));
2659 }
2666 }
2675 }
2681 }
2682 }
2684 STATIC int
2688 {
2713 /* really need a gang lookup range call here */
2723 /* if the inode lies outside this cluster, we're done. */
2726 /*
2727 * Do an un-protected check to see if the inode is dirty and
2728 * is a candidate for flushing. These checks will be repeated
2729 * later after the appropriate locks are acquired.
2730 */
2734 /*
2735 * Try to get locks. If any are unavailable or it is pinned,
2736 * then this inode cannot be flushed and is skipped.
2737 */
2744 }
2749 }
2751 /*
2752 * arriving here means that this inode can be flushed. First
2753 * re-check that it's dirty before flushing.
2754 */
2761 }
2762 clcount++;
2765 }
2767 }
2772 }
2774 out_free:
2780 cluster_corrupt_out:
2781 /*
2782 * Corruption detected in the clustering loop. Invalidate the
2783 * inode buffer and shut down the filesystem.
2784 */
2786 /*
2787 * Clean up the buffer. If it was B_DELWRI, just release it --
2788 * brelse can handle it with no problems. If not, shut down the
2789 * filesystem before releasing the buffer.
2790 */
2798 /*
2799 * Just like incore_relse: if we have b_iodone functions,
2800 * mark the buffer as an error and call them. Otherwise
2801 * mark it as stale and brelse.
2802 */
2812 }
2813 }
2815 /*
2816 * Unlocks the flush lock
2817 */
2821 }
2823 /*
2824 * xfs_iflush() will write a modified inode's changes out to the
2825 * inode's on disk home. The caller must have the inode lock held
2826 * in at least shared mode and the inode flush completion must be
2827 * active as well. The inode lock will still be held upon return from
2828 * the call and the caller is free to unlock it.
2829 * The inode flush will be completed when the inode reaches the disk.
2830 * The flags indicate how the inode's buffer should be written out.
2831 */
2832 int
2835 uint flags)
2836 {
2855 /*
2856 * If the inode isn't dirty, then just release the inode
2857 * flush lock and do nothing.
2858 */
2862 }
2864 /*
2865 * We can't flush the inode until it is unpinned, so wait for it if we
2866 * are allowed to block. We know noone new can pin it, because we are
2867 * holding the inode lock shared and you need to hold it exclusively to
2868 * pin the inode.
2869 *
2870 * If we are not allowed to block, force the log out asynchronously so
2871 * that when we come back the inode will be unpinned. If other inodes
2872 * in the same cluster are dirty, they will probably write the inode
2873 * out for us if they occur after the log force completes.
2874 */
2879 }
2882 /*
2883 * This may have been unpinned because the filesystem is shutting
2884 * down forcibly. If that's the case we must not write this inode
2885 * to disk, because the log record didn't make it to disk!
2886 */
2893 }
2895 /*
2896 * Decide how buffer will be flushed out. This is done before
2897 * the call to xfs_iflush_int because this field is zeroed by it.
2898 */
2900 /*
2901 * Flush out the inode buffer according to the directions
2902 * of the caller. In the cases where the caller has given
2903 * us a choice choose the non-delwri case. This is because
2904 * the inode is in the AIL and we need to get it out soon.
2905 */
2923 }
2942 }
2943 }
2945 /*
2946 * Get the buffer containing the on-disk inode.
2947 */
2953 }
2955 /*
2956 * First flush out the inode that xfs_iflush was called with.
2957 */
2962 /*
2963 * If the buffer is pinned then push on the log now so we won't
2964 * get stuck waiting in the write for too long.
2965 */
2969 /*
2970 * inode clustering:
2971 * see if other inodes can be gathered into this write
2972 */
2983 }
2986 corrupt_out:
2989 cluster_corrupt_out:
2990 /*
2991 * Unlocks the flush lock
2992 */
2995 }
2998 STATIC int
3002 {
3006 #ifdef XFS_TRANS_DEBUG
3008 #endif
3019 /*
3020 * If the inode isn't dirty, then just release the inode
3021 * flush lock and do nothing.
3022 */
3026 }
3028 /* set *dip = inode's place in the buffer */
3031 /*
3032 * Clear i_update_core before copying out the data.
3033 * This is for coordination with our timestamp updates
3034 * that don't hold the inode lock. They will always
3035 * update the timestamps BEFORE setting i_update_core,
3036 * so if we clear i_update_core after they set it we
3037 * are guaranteed to see their updates to the timestamps.
3038 * I believe that this depends on strongly ordered memory
3039 * semantics, but we have that. We use the SYNCHRONIZE
3040 * macro to make sure that the compiler does not reorder
3041 * the i_update_core access below the data copy below.
3042 */
3046 /*
3047 * Make sure to get the latest atime from the Linux inode.
3048 */
3057 }
3064 }
3074 }
3085 }
3086 }
3089 XFS_RANDOM_IFLUSH_5)) {
3095 ip);
3097 }
3104 }
3105 /*
3106 * bump the flush iteration count, used to detect flushes which
3107 * postdate a log record during recovery.
3108 */
3112 /*
3113 * Copy the dirty parts of the inode into the on-disk
3114 * inode. We always copy out the core of the inode,
3115 * because if the inode is dirty at all the core must
3116 * be.
3117 */
3120 /* Wrap, we never let the log put out DI_MAX_FLUSH */
3124 /*
3125 * If this is really an old format inode and the superblock version
3126 * has not been updated to support only new format inodes, then
3127 * convert back to the old inode format. If the superblock version
3128 * has been updated, then make the conversion permanent.
3129 */
3133 /*
3134 * Convert it back.
3135 */
3139 /*
3140 * The superblock version has already been bumped,
3141 * so just make the conversion to the new inode
3142 * format permanent.
3143 */
3152 }
3153 }
3160 /*
3161 * We've recorded everything logged in the inode, so we'd
3162 * like to clear the ilf_fields bits so we don't log and
3163 * flush things unnecessarily. However, we can't stop
3164 * logging all this information until the data we've copied
3165 * into the disk buffer is written to disk. If we did we might
3166 * overwrite the copy of the inode in the log with all the
3167 * data after re-logging only part of it, and in the face of
3168 * a crash we wouldn't have all the data we need to recover.
3169 *
3170 * What we do is move the bits to the ili_last_fields field.
3171 * When logging the inode, these bits are moved back to the
3172 * ilf_fields field. In the xfs_iflush_done() routine we
3173 * clear ili_last_fields, since we know that the information
3174 * those bits represent is permanently on disk. As long as
3175 * the flush completes before the inode is logged again, then
3176 * both ilf_fields and ili_last_fields will be cleared.
3177 *
3178 * We can play with the ilf_fields bits here, because the inode
3179 * lock must be held exclusively in order to set bits there
3180 * and the flush lock protects the ili_last_fields bits.
3181 * Set ili_logged so the flush done
3182 * routine can tell whether or not to look in the AIL.
3183 * Also, store the current LSN of the inode so that we can tell
3184 * whether the item has moved in the AIL from xfs_iflush_done().
3185 * In order to read the lsn we need the AIL lock, because
3186 * it is a 64 bit value that cannot be read atomically.
3187 */
3196 /*
3197 * Attach the function xfs_iflush_done to the inode's
3198 * buffer. This will remove the inode from the AIL
3199 * and unlock the inode's flush lock when the inode is
3200 * completely written to disk.
3201 */
3208 /*
3209 * We're flushing an inode which is not in the AIL and has
3210 * not been logged but has i_update_core set. For this
3211 * case we can use a B_DELWRI flush and immediately drop
3212 * the inode flush lock because we can avoid the whole
3213 * AIL state thing. It's OK to drop the flush lock now,
3214 * because we've already locked the buffer and to do anything
3215 * you really need both.
3216 */
3221 }
3223 }
3227 corrupt_out:
3229 }
3233 #ifdef XFS_ILOCK_TRACE
3234 void
3236 {
3245 }
3246 #endif
3248 /*
3249 * Return a pointer to the extent record at file index idx.
3250 */
3251 xfs_bmbt_rec_host_t *
3255 {
3270 }
3271 }
3273 /*
3274 * Insert new item(s) into the extent records for incore inode
3275 * fork 'ifp'. 'count' new items are inserted at index 'idx'.
3276 */
3277 void
3283 {
3290 }
3292 /*
3293 * This is called when the amount of space required for incore file
3294 * extents needs to be increased. The ext_diff parameter stores the
3295 * number of new extents being added and the idx parameter contains
3296 * the extent index where the new extents will be added. If the new
3297 * extents are being appended, then we just need to (re)allocate and
3298 * initialize the space. Otherwise, if the new extents are being
3299 * inserted into the middle of the existing entries, a bit more work
3300 * is required to make room for the new extents to be inserted. The
3301 * caller is responsible for filling in the new extent entries upon
3302 * return.
3303 */
3304 void
3309 {
3318 /*
3319 * If the new number of extents (nextents + ext_diff)
3320 * fits inside the inode, then continue to use the inline
3321 * extent buffer.
3322 */
3329 }
3333 }
3334 /*
3335 * Otherwise use a linear (direct) extent list.
3336 * If the extents are currently inside the inode,
3337 * xfs_iext_realloc_direct will switch us from
3338 * inline to direct extent allocation mode.
3339 */
3347 }
3348 }
3349 /* Indirection array */
3362 }
3363 /* Extents fit in target extent page */
3371 }
3374 }
3375 /* Insert a new extent page */
3379 }
3380 /*
3381 * If extent(s) are being appended to the last page in
3382 * the indirection array and the new extent(s) don't fit
3383 * in the page, then erp is NULL and erp_idx is set to
3384 * the next index needed in the indirection array.
3385 */
3394 erp_idx++;
3395 }
3396 }
3397 }
3398 }
3400 }
3402 /*
3403 * This is called when incore extents are being added to the indirection
3404 * array and the new extents do not fit in the target extent list. The
3405 * erp_idx parameter contains the irec index for the target extent list
3406 * in the indirection array, and the idx parameter contains the extent
3407 * index within the list. The number of extents being added is stored
3408 * in the count parameter.
3409 *
3410 * |-------| |-------|
3411 * | | | | idx - number of extents before idx
3412 * | idx | | count |
3413 * | | | | count - number of extents being inserted at idx
3414 * |-------| |-------|
3415 * | count | | nex2 | nex2 - number of extents after idx + count
3416 * |-------| |-------|
3417 */
3418 void
3424 {
3438 /*
3439 * Save second part of target extent list
3440 * (all extents past */
3448 }
3450 /*
3451 * Add the new extents to the end of the target
3452 * list, then allocate new irec record(s) and
3453 * extent buffer(s) as needed to store the rest
3454 * of the new extents.
3455 */
3462 }
3464 erp_idx++;
3470 }
3472 /* Add nex2 extents back to indirection array */
3474 xfs_extnum_t ext_avail;
3480 /*
3481 * If nex2 extents fit in the current page, append
3482 * nex2_ep after the new extents.
3483 */
3486 }
3487 /*
3488 * Otherwise, check if space is available in the
3489 * next page.
3490 */
3494 erp_idx++;
3495 erp++;
3496 /* Create a hole for nex2 extents */
3499 }
3500 /*
3501 * Final choice, create a new extent page for
3502 * nex2 extents.
3503 */
3505 erp_idx++;
3507 }
3512 }
3513 }
3515 /*
3516 * This is called when the amount of space required for incore file
3517 * extents needs to be decreased. The ext_diff parameter stores the
3518 * number of extents to be removed and the idx parameter contains
3519 * the extent index where the extents will be removed from.
3520 *
3521 * If the amount of space needed has decreased below the linear
3522 * limit, XFS_IEXT_BUFSZ, then switch to using the contiguous
3523 * extent array. Otherwise, use kmem_realloc() to adjust the
3524 * size to what is needed.
3525 */
3526 void
3531 {
3547 }
3549 }
3551 /*
3552 * This removes ext_diff extents from the inline buffer, beginning
3553 * at extent index idx.
3554 */
3555 void
3560 {
3579 }
3580 }
3582 /*
3583 * This removes ext_diff extents from a linear (direct) extent list,
3584 * beginning at extent index idx. If the extents are being removed
3585 * from the end of the list (ie. truncate) then we just need to re-
3586 * allocate the list to remove the extra space. Otherwise, if the
3587 * extents are being removed from the middle of the existing extent
3588 * entries, then we first need to move the extent records beginning
3589 * at idx + ext_diff up in the list to overwrite the records being
3590 * removed, then remove the extra space via kmem_realloc.
3591 */
3592 void
3597 {
3609 }
3610 /* Move extents up in the list (if needed) */
3616 }
3619 /*
3620 * Reallocate the direct extent list. If the extents
3621 * will fit inside the inode then xfs_iext_realloc_direct
3622 * will switch from direct to inline extent allocation
3623 * mode for us.
3624 */
3627 }
3629 /*
3630 * This is called when incore extents are being removed from the
3631 * indirection array and the extents being removed span multiple extent
3632 * buffers. The idx parameter contains the file extent index where we
3633 * want to begin removing extents, and the count parameter contains
3634 * how many extents need to be removed.
3635 *
3636 * |-------| |-------|
3637 * | nex1 | | | nex1 - number of extents before idx
3638 * |-------| | count |
3639 * | | | | count - number of extents being removed at idx
3640 * | count | |-------|
3641 * | | | nex2 | nex2 - number of extents after idx + count
3642 * |-------| |-------|
3643 */
3644 void
3649 {
3668 /*
3669 * Check for deletion of entire list;
3670 * xfs_iext_irec_remove() updates extent offsets.
3671 */
3678 XFS_IEXT_BUFSZ);
3684 }
3685 }
3686 /* Move extents up (if needed) */
3691 }
3692 /* Zero out rest of page */
3695 /* Update remaining counters */
3700 erp_idx++;
3701 erp++;
3702 }
3705 }
3707 /*
3708 * Create, destroy, or resize a linear (direct) block of extents.
3709 */
3710 void
3714 {
3723 /* Free extent records */
3726 }
3727 /* Resize direct extent list and zero any new bytes */
3729 /* Check if extents will fit inside the inode */
3735 }
3738 }
3742 rnew_size,
3744 }
3749 }
3750 }
3751 /*
3752 * Switch from the inline extent buffer to a direct
3753 * extent list. Be sure to include the inline extent
3754 * bytes in new_size.
3755 */
3760 }
3762 }
3765 }
3767 /*
3768 * Switch from linear (direct) extent records to inline buffer.
3769 */
3770 void
3774 {
3777 /*
3778 * The inline buffer was zeroed when we switched
3779 * from inline to direct extent allocation mode,
3780 * so we don't need to clear it here.
3781 */
3787 }
3789 /*
3790 * Switch from inline buffer to linear (direct) extent records.
3791 * new_size should already be rounded up to the next power of 2
3792 * by the caller (when appropriate), so use new_size as it is.
3793 * However, since new_size may be rounded up, we can't update
3794 * if_bytes here. It is the caller's responsibility to update
3795 * if_bytes upon return.
3796 */
3797 void
3801 {
3809 }
3811 }
3813 /*
3814 * Resize an extent indirection array to new_size bytes.
3815 */
3816 void
3820 {
3835 }
3836 }
3838 /*
3839 * Switch from indirection array to linear (direct) extent allocations.
3840 */
3841 void
3844 {
3864 }
3865 }
3867 /*
3868 * Free incore file extents.
3869 */
3870 void
3873 {
3881 }
3888 }
3892 }
3894 /*
3895 * Return a pointer to the extent record for file system block bno.
3896 */
3902 {
3917 }
3920 /* Find target extent list */
3928 }
3929 /* Binary search extent records */
3940 /* Convert back to file-based extent index */
3943 }
3946 }
3947 }
3948 /* Convert back to file-based extent index */
3951 }
3957 }
3958 }
3961 }
3963 /*
3964 * Return a pointer to the indirection array entry containing the
3965 * extent record for filesystem block bno. Store the index of the
3966 * target irec in *erp_idxp.
3967 */
3973 {
3997 }
3998 }
4001 }
4003 /*
4004 * Return a pointer to the indirection array entry containing the
4005 * extent record at file extent index *idxp. Store the index of the
4006 * target irec in *erp_idxp and store the page index of the target
4007 * extent record in *idxp.
4008 */
4009 xfs_ext_irec_t *
4015 {
4032 /* Binary search extent irec's */
4048 erp_idx++;
4054 }
4055 }
4059 }
4061 /*
4062 * Allocate and initialize an indirection array once the space needed
4063 * for incore extents increases above XFS_IEXT_BUFSZ.
4064 */
4065 void
4068 {
4084 }
4095 }
4097 /*
4098 * Allocate and initialize a new entry in the indirection array.
4099 */
4100 xfs_ext_irec_t *
4104 {
4112 /* Resize indirection array */
4115 /*
4116 * Move records down in the array so the
4117 * new page can use erp_idx.
4118 */
4122 }
4125 /* Initialize new extent record */
4134 }
4136 /*
4137 * Remove a record from the indirection array.
4138 */
4139 void
4143 {
4155 }
4156 /* Compact extent records */
4160 }
4161 /*
4162 * Manually free the last extent record from the indirection
4163 * array. A call to xfs_iext_realloc_indirect() with a size
4164 * of zero would result in a call to xfs_iext_destroy() which
4165 * would in turn call this function again, creating a nasty
4166 * infinite loop.
4167 */
4173 }
4175 }
4177 /*
4178 * This is called to clean up large amounts of unused memory allocated
4179 * by the indirection array. Before compacting anything though, verify
4180 * that the indirection array is still needed and switch back to the
4181 * linear extent list (or even the inline buffer) if possible. The
4182 * compaction policy is as follows:
4183 *
4184 * Full Compaction: Extents fit into a single page (or inline buffer)
4185 * Partial Compaction: Extents occupy less than 50% of allocated space
4186 * No Compaction: Extents occupy at least 50% of allocated space
4187 */
4188 void
4191 {
4208 }
4209 }
4211 /*
4212 * Combine extents from neighboring extent pages.
4213 */
4214 void
4217 {
4233 /*
4234 * Free page before removing extent record
4235 * so er_extoffs don't get modified in
4236 * xfs_iext_irec_remove.
4237 */
4243 erp_idx++;
4244 }
4245 }
4246 }
4248 /*
4249 * This is called to update the er_extoff field in the indirection
4250 * array when extents have been added or removed from one of the
4251 * extent lists. erp_idx contains the irec index to begin updating
4252 * at and ext_diff contains the number of extents that were added
4253 * or removed.
4254 */
4255 void
4260 {
4268 }
4269 }