Lines Matching defs:inode
99 * infos of the currently processed inode. In case of deleted inodes,
100 * these are the values from the deleted inode.
128 * directories such that a directory with a lower inode number was
129 * the parent of a directory with a higher inode number, and the one
131 * directory with lower inode number when we finish processing it - we
132 * must process the directory with higher inode number first, then
133 * rename/move it and then rename/move the directory with lower inode
162 * "c" has lower inode number, but we can't move it (2nd mv operation)
163 * before we move "d", which has higher inode number.
169 /* Indexed by parent directory inode number. */
173 * Reverse index, indexed by the inode number of a directory that
216 * Indexed by the inode number of the directory to be deleted.
235 * was waiting for this directory inode to be moved first. Therefore
308 "Send: inconsistent snapshot, found %s %s for inode %llu without updated inode item, send root is %llu, parent root is %llu",
817 * Helper function to retrieve some fields from an inode item.
1132 * Retrieve the first path of an inode. If an inode has more then one
1250 * behind the current inode/offset.
1254 * If the source inode was not yet processed we can't issue a
1261 * We clone from the inode currently being sent as long as the
1289 * Given an inode, offset and extent item, it finds a good clone for a clone
1293 * inode+offset.
1444 "did not find backref in send_root. inode=%llu, offset=%llu, disk_byte=%llu found extent=%llu",
1506 * An empty symlink inode. Can happen in rare error paths when
1507 * creating a symlink (transaction committed before the inode
1508 * eviction handler removed the symlink inode items and a crash
1514 "Found empty symlink inode %llu at root %llu",
1839 * inode/gen in who_ino/who_gen.
1841 * to make sure later references to the overwritten inode are possible.
1842 * Orphanizing is however only required for the first ref of an inode.
1912 * Checks if the ref was overwritten by an already processed inode. This is
1971 * The current inode being processed might have been the one that caused
1972 * inode 'ino' to be orphanized, therefore check if ow_inode matches
1973 * the current inode being processed.
1987 * Same as did_overwrite_ref, but also checks if it is the first ref of an inode
2139 * Returns 1 if the inode is not existent or got overwritten. In that case, the
2178 * If the inode is not existent yet, add the orphan name and return 1.
2195 * Depending on whether the inode was already processed or not, use
2208 * Check if the ref was overwritten by an inode's ref that was processed
2256 * Magic happens here. This function returns the first ref to an inode as it
2258 * We walk the path up to the root. For every inode in between, we check if it
2261 * If we encounter an inode that was deleted at this point in time, we use the
2266 * 1. When an inode is freshly created and thus no valid refs are available yet
2271 * 3. When an inode is moved around or gets new links, it may overwrite the ref
2272 * of an unprocessed inode. If in that case the first ref would be
2273 * overwritten, the overwritten inode gets "orphanized". Later when we
2274 * process this overwritten inode, it is restored at a new place by moving
2275 * the orphan inode.
2587 * a valid path yet because we did not process the refs yet. So, the inode
2630 btrfs_warn(sctx->send_root->fs_info, "unexpected inode type %o",
2738 * Only creates the inode if it is:
2838 * ref of an unprocessed inode gets overwritten and for all non empty
2936 * We check this by iterating all dir items and checking if the inode behind
3344 * The parent inode might have been deleted in the send snapshot
3434 * (in the send root) with a higher inode number than ours (sctx->cur_ino) was
3456 * Here we can not rename 258 from 'b' to 'a' without the rename of inode 257
3458 * inode 259 from 'c' to 'x'. So the order of rename commands the send stream
3508 * di_key.objectid has the number of the inode that has a dentry in the
3510 * renamed to. We need to check if that inode is in the send root as
3511 * well and if it is currently marked as an inode with a pending rename,
3513 * that it happens after that other inode is renamed.
3533 /* Different inode, no need to delay the rename of sctx->cur_ino */
3557 * Check if inode ino2, or any of its ancestors, is inode ino1.
3589 * Check if ino ino1 is an ancestor of inode ino2 in the given root for any
3708 * Our current directory inode may not yet be renamed/moved because some
3719 * If the current inode is an ancestor of ino in the
3721 * current inode, otherwise don't delayed the rename
3822 * When processing the new references for an inode we may orphanize an existing
3823 * directory inode because its old name conflicts with one of the new references
3824 * of the current inode. Later, when processing another new reference of our
3825 * inode, we might need to orphanize another inode, but the path we have in the
3847 * When processing inode 257 we compute the name for inode 259 as "d1", and we
3848 * cache it in the name cache. Later when we start processing inode 258, when
3852 * orphanizing inode 259, since its old reference causes a conflict. Then we
3854 * orphanize inode 260, as its old reference conflicts with ours - but for the
3924 * First, check if the first ref of the current inode was overwritten
3925 * before. If yes, we know that the current inode was already orphanized
3959 * inode. This needs to happen first because a new reference may conflict
3984 * Processing the new reference for inode 257 with name "b" may happen
3987 * hard link "b", inode 259 was already orphanized, since the generated
3989 * We are processing inode 257, so only later when processing 259 we do
4002 * unprocessed inode. If yes, orphanize the overwritten inode.
4048 * Make sure we clear our orphanized inode's
4050 * inode ow_inode might be an ancestor of some
4051 * other inode that will be orphanized as well
4052 * later and has an inode number greater than
4129 * If that did not happen, check if a previous inode
4166 * inode, move it and update valid_path. If not, link or move
4167 * it depending on the inode mode.
4193 * We might have previously orphanized an inode
4194 * which is an ancestor of our current inode,
4255 * We have a non dir inode. Go through all deleted refs and
4271 * ancestor inode.
4287 * If the inode is still orphan, unlink the orphan. This may
4288 * happen when a previous inode did overwrite the first ref
4289 * of this inode and no new refs were added for the current
4290 * inode. Unlinking does not mean that the inode is deleted in
4291 * all cases. There may still be links to this inode in other
4305 * We also update the inode stats of the parent dirs here.
4555 * Record and process all refs at once. Needed when an inode changes the
4624 * re-creating this inode and will be rename'ing it into place once we
4960 struct inode *inode;
4972 inode = btrfs_iget(fs_info->sb, sctx->cur_ino, root);
4973 if (IS_ERR(inode))
4974 return PTR_ERR(inode);
4980 file_ra_state_init(&sctx->ra, inode->i_mapping);
4986 page = find_lock_page(inode->i_mapping, index);
4988 page_cache_sync_readahead(inode->i_mapping, &sctx->ra,
4991 page = find_or_create_page(inode->i_mapping, index,
5000 page_cache_async_readahead(inode->i_mapping, &sctx->ra,
5010 "send: IO error at offset %llu for inode %llu root %llu",
5030 iput(inode);
5035 * Read some bytes from the current inode/file and send a write command to
5195 * Don't go beyond the inode's i_size due to prealloc extents that start
5280 /* There is no xattr for this inode */
5375 * has a higher inode number than foo) we blindly send a clone operation
5523 * If we are at i_size of the clone source inode and we
5533 * inode is not sector size aligned. That will make the
5917 * file extent items for our current inode. These leafs have
6108 * inode into account.
6110 * On the other hand, if our current inode is a directory and couldn't
6112 * a higher inode number, we can only move/rename our current inode
6114 * the old path (pre move/rename) of our current inode, and the
6199 * inode's move/rename, now do their move/rename operations.
6208 * the inode before. If our inode is a directory and it's
6237 * Issue unlink operations for all paths of the current inode found in the
6326 * Set send_progress to current inode. This will tell all get_cur_xxx
6327 * functions that the current inode's refs are not updated yet. Later,
6356 * the inode as deleted+reused because it would generate a
6373 * operation. So if we find such cases, ignore the inode and all its
6374 * items completely if it's a new inode, or if it's a changed inode
6376 * unlinked and all other the inode items are ignored.
6413 * We need to do some special handling in case the inode was
6415 * means that the original inode was deleted and new inode
6416 * reused the same inum. So we have to treat the old inode as
6421 * First, process the inode as if it was deleted.
6436 * Now process the inode as if it was new.
6461 * Now process all extents and xattrs of the inode as if
6557 * We have found an extent item that changed without the inode item
6563 * updates the inode item, but it only changes the iversion (sequence
6564 * field in the inode item) of the inode, so if a file is deduplicated
6566 * iversion becames the same in both snapshots, whence the inode item is
7143 * therefore can see inode items that don't exist in the current root anymore,