Lines Matching defs:inode
172 * infos of the currently processed inode. In case of deleted inodes,
173 * these are the values from the deleted inode.
197 * The inode we are currently processing. It's not NULL only when we
198 * need to issue write commands for data extents from this inode.
200 struct inode *cur_inode;
208 * directories such that a directory with a lower inode number was
209 * the parent of a directory with a higher inode number, and the one
211 * directory with lower inode number when we finish processing it - we
212 * must process the directory with higher inode number first, then
213 * rename/move it and then rename/move the directory with lower inode
242 * "c" has lower inode number, but we can't move it (2nd mv operation)
243 * before we move "d", which has higher inode number.
249 /* Indexed by parent directory inode number. */
253 * Reverse index, indexed by the inode number of a directory that
296 * Indexed by the inode number of the directory to be deleted.
324 * was waiting for this directory inode to be moved first. Therefore
342 * The key in the entry is an inode number, and the generation matches
343 * the inode's generation.
394 "Send: inconsistent snapshot, found %s %s for inode %llu without updated inode item, send root is %llu, parent root is %llu",
919 * Helper function to retrieve some fields from an inode item.
1232 * Retrieve the first path of an inode. If an inode has more then one
1352 * behind the current inode/offset.
1356 * If the source inode was not yet processed we can't issue a
1363 * We clone from the inode currently being sent as long as the
1561 * Given an inode, offset and extent item, it finds a good clone for a clone
1565 * inode+offset.
1590 * With fallocate we can get prealloc extents beyond the inode's i_size,
1593 * destination inode.
1717 * We found an optimal clone candidate (any inode from
1760 * An empty symlink inode. Can happen in rare error paths when
1761 * creating a symlink (transaction committed before the inode
1762 * eviction handler removed the symlink inode items and a crash
1768 "Found empty symlink inode %llu at root %llu",
2113 * inode/gen in who_ino/who_gen.
2115 * to make sure later references to the overwritten inode are possible.
2116 * Orphanizing is however only required for the first ref of an inode.
2141 * @parent_root_dir_gen was set to 0 if the inode does not exist in the
2176 * Checks if the ref was overwritten by an already processed inode. This is
2200 * @send_root_dir_gen was set to 0 if the inode does not exist in the
2221 /* It's the same inode, so no overwrite happened. */
2228 * The current inode being processed might have been the one that caused
2229 * inode 'ino' to be orphanized, therefore check if ow_inode matches
2230 * the current inode being processed.
2249 * Same as did_overwrite_ref, but also checks if it is the first ref of an inode
2294 * Returns 1 if the inode is not existent or got overwritten. In that case, the
2331 * If the inode is not existent yet, add the orphan name and return 1.
2348 * Depending on whether the inode was already processed or not, use
2361 * Check if the ref was overwritten by an inode's ref that was processed
2410 * Magic happens here. This function returns the first ref to an inode as it
2412 * We walk the path up to the root. For every inode in between, we check if it
2415 * If we encounter an inode that was deleted at this point in time, we use the
2420 * 1. When an inode is freshly created and thus no valid refs are available yet
2425 * 3. When an inode is moved around or gets new links, it may overwrite the ref
2426 * of an unprocessed inode. If in that case the first ref would be
2427 * overwritten, the overwritten inode gets "orphanized". Later when we
2428 * process this overwritten inode, it is restored at a new place by moving
2429 * the orphan inode.
2775 * send_utimes() for each respective inode, because we might be finishing
2776 * processing an inode that is a directory and it just got renamed, and existing
2780 * cache when inserting, do it after we finish processing each inode at
2832 * a valid path yet because we did not process the refs yet. So, the inode
2878 btrfs_warn(sctx->send_root->fs_info, "unexpected inode type %o",
2989 * Only creates the inode if it is:
3087 * ref of an unprocessed inode gets overwritten and for all non empty
3186 * We check this by iterating all dir items and checking if the inode behind
3219 * Find the inode number associated with the last dir index
3220 * entry. This is very likely the inode with the highest number
3633 * The parent inode might have been deleted in the send snapshot
3721 * (in the send root) with a higher inode number than ours (sctx->cur_ino) was
3743 * Here we can not rename 258 from 'b' to 'a' without the rename of inode 257
3745 * inode 259 from 'c' to 'x'. So the order of rename commands the send stream
3795 * di_key.objectid has the number of the inode that has a dentry in the
3797 * renamed to. We need to check if that inode is in the send root as
3798 * well and if it is currently marked as an inode with a pending rename,
3800 * that it happens after that other inode is renamed.
3818 /* Different inode, no need to delay the rename of sctx->cur_ino */
3842 * Check if inode ino2, or any of its ancestors, is inode ino1.
3874 * Check if inode ino1 is an ancestor of inode ino2 in the given root for any
3981 * Our current directory inode may not yet be renamed/moved because some
3992 * If the current inode is an ancestor of ino in the
3994 * current inode, otherwise don't delayed the rename
4093 * When processing the new references for an inode we may orphanize an existing
4094 * directory inode because its old name conflicts with one of the new references
4095 * of the current inode. Later, when processing another new reference of our
4096 * inode, we might need to orphanize another inode, but the path we have in the
4118 * When processing inode 257 we compute the name for inode 259 as "d1", and we
4119 * cache it in the name cache. Later when we start processing inode 258, when
4123 * orphanizing inode 259, since its old reference causes a conflict. Then we
4125 * orphanize inode 260, as its old reference conflicts with ours - but for the
4194 * First, check if the first ref of the current inode was overwritten
4195 * before. If yes, we know that the current inode was already orphanized
4229 * inode. This needs to happen first because a new reference may conflict
4254 * Processing the new reference for inode 257 with name "b" may happen
4257 * hard link "b", inode 259 was already orphanized, since the generated
4259 * We are processing inode 257, so only later when processing 259 we do
4272 * unprocessed inode. If yes, orphanize the overwritten inode.
4315 * Make sure we clear our orphanized inode's
4317 * inode ow_inode might be an ancestor of some
4318 * other inode that will be orphanized as well
4319 * later and has an inode number greater than
4395 * If that did not happen, check if a previous inode
4433 * inode, move it and update valid_path. If not, link or move
4434 * it depending on the inode mode.
4460 * We might have previously orphanized an inode
4461 * which is an ancestor of our current inode,
4521 * We have a non dir inode. Go through all deleted refs and
4537 * ancestor inode.
4553 * If the inode is still orphan, unlink the orphan. This may
4554 * happen when a previous inode did overwrite the first ref
4555 * of this inode and no new refs were added for the current
4556 * inode. Unlinking does not mean that the inode is deleted in
4557 * all cases. There may still be links to this inode in other
4571 * We also update the inode stats of the parent dirs here.
4801 * Record and process all refs at once. Needed when an inode changes the
4855 * re-creating this inode and will be rename'ing it into place once we
5176 struct inode *inode;
5179 inode = btrfs_iget(fs_info->sb, sctx->cur_ino, sctx->send_root);
5180 if (IS_ERR(inode))
5181 return PTR_ERR(inode);
5183 ret = btrfs_get_verity_descriptor(inode, NULL, 0);
5200 ret = btrfs_get_verity_descriptor(inode, sctx->verity_descriptor, ret);
5220 iput(inode);
5301 "send: IO error at offset %llu for inode %llu root %llu",
5324 * Read some bytes from the current inode/file and send a write command to
5483 * Don't go beyond the inode's i_size due to prealloc extents that start
5527 struct inode *inode;
5536 inode = btrfs_iget(fs_info->sb, sctx->cur_ino, root);
5537 if (IS_ERR(inode))
5538 return PTR_ERR(inode);
5583 iput(inode);
5592 struct inode *inode;
5603 inode = btrfs_iget(fs_info->sb, sctx->cur_ino, root);
5604 if (IS_ERR(inode))
5605 return PTR_ERR(inode);
5662 ret = btrfs_encoded_read_regular_fill_pages(BTRFS_I(inode), offset,
5688 iput(inode);
5743 * It's very likely there are no pages from this inode in the page
5750 * if the inode's mapping nrpages is 0 when we first open it, and
5833 /* There is no xattr for this inode */
5926 * has a higher inode number than foo) we blindly send a clone operation
6076 * If we are at i_size of the clone source inode and we
6086 * inode is not sector size aligned. That will make the
6471 * file extent items for our current inode. These leafs have
6645 * inode into account.
6647 * On the other hand, if our current inode is a directory and couldn't
6649 * a higher inode number, we can only move/rename our current inode
6651 * the old path (pre move/rename) of our current inode, and the
6765 * inode's move/rename, now do their move/rename operations.
6774 * the inode before. If our inode is a directory and it's
6781 * If the current inode is a non-empty directory, delay issuing
6845 * Set send_progress to current inode. This will tell all get_cur_xxx
6846 * functions that the current inode's refs are not updated yet. Later,
6875 * the inode as deleted+reused because it would generate a
6953 * We need to do some special handling in case the inode was
6955 * means that the original inode was deleted and new inode
6956 * reused the same inum. So we have to treat the old inode as
6961 * First, process the inode as if it was deleted.
6978 * Now process the inode as if it was new.
7009 * inode as if they were all new.
7105 * We have found an extent item that changed without the inode item
7111 * updates the inode item, but it only changes the iversion (sequence
7112 * field in the inode item) of the inode, so if a file is deduplicated
7114 * iversion becomes the same in both snapshots, whence the inode item is
7976 * therefore can see inode items that don't exist in the current root anymore,
8071 long btrfs_ioctl_send(struct inode *inode, struct btrfs_ioctl_send_args *arg)
8074 struct btrfs_root *send_root = BTRFS_I(inode)->root;