Lines Matching defs:clone
39 * issue clone operations instead of write operations. This currently exists to
91 * to the send root. Having the user specify more than 16 clone roots is not
106 * leaf is accessible and we can use for clone operations.
1336 /* First check if the root is in the list of accepted clone sources */
1344 /* This is our own reference, bail out as we can't clone from it. */
1357 * clone operation, as the source extent does not exist yet at
1363 * We clone from the inode currently being sent as long as the
1365 * to clone from an extent that does not exist yet at the
1380 * we clone more optimally and end up doing less writes and getting
1487 * allowed to clone. Cache the new entry as it's still useful to avoid
1526 * clone source - meaning no clone roots were given in the
1539 * operations instead of clone operations when an extent has more than
1561 * Given an inode, offset and extent item, it finds a good clone for a clone
1563 * sure that the returned clone is usable at the point where sending is at the
1591 * so we don't do anything here because clone operations can not clone
1612 * Setup the clone roots.
1657 * If have a single clone root, then it's the send root and we can tell
1662 * in the list of clone roots.
1679 * relocation. So act as if we haven't found any clone sources
1708 * Choose the root from which we can clone more bytes, to
1717 * We found an optimal clone candidate (any inode from
5362 * Send a clone command to user space.
5406 * our clone source as that is what we will look for when doing a
5716 * the extent that we couldn't clone in clone_range().
5884 * zero file offset, but it may not be possible to clone in the
5910 * We can't send a clone operation for the entire range if we find
5913 * So check for that and do a mix of clone and regular write/copy
5926 * has a higher inode number than foo) we blindly send a clone operation
6037 * We can't clone the last block, when its size is not
6040 * trying to clone or will silently corrupt the data in
6046 * So issue a clone of the aligned down range plus a
6076 * If we are at i_size of the clone source inode and we
6077 * can not clone from it, terminate the loop. This is
6109 * and using the send root as the clone root, we must stop once
6110 * the current clone offset reaches the current eof of the file
6111 * at the receiver, otherwise we would issue an invalid clone
7381 * if we can clone file ranges.
7410 struct extent_buffer *clone;
7412 clone = btrfs_clone_extent_buffer(path->nodes[level]);
7413 if (!clone)
7417 path->nodes[level] = clone;
7558 * The exception are the root nodes, for which we always have a clone, see
7564 * restart the start from the current commit roots and clone the new leaves so
7566 * make us clone the wrong data in case there are new extents using the old
7602 * If the lowest level nodes are leaves, clone them so that they can be
7620 * Now clone the root nodes (unless they happen to be the leaves we have
7741 * We clone the root node of the send and parent roots to prevent races
7745 * So we clone them, under the commit root semaphore, to be race free.
8115 * easily exhaust memory. Max number of clone sources is about 200K.
8300 * Clones from send_root are allowed, but only if the clone source
8302 * for possible clone sources.