cow
if (dev->cow.file) {
dev->cow.bitmap, dev->cow.bitmap_offset,
dev->cow.bitmap_len);
if (dev->cow.file)
io_req->fds[0] = dev->cow.fd;
io_req->offsets[1] = dev->cow.data_offset;
struct cow cow;
.cow = DEFAULT_COW, \
ubd_dev->cow.file = backing_file;
if (ubd_dev->file && ubd_dev->cow.file) {
file = ubd_dev->cow.file;
static int path_requires_switch(char *from_cmdline, char *from_cow, char *cow)
from_cmdline, from_cow, cow);
if(ubd_dev->cow.file == NULL)
os_close_file(ubd_dev->cow.fd);
vfree(ubd_dev->cow.bitmap);
ubd_dev->cow.bitmap = NULL;
create_ptr = (ubd_dev->cow.file != NULL) ? &create_cow : NULL;
back_ptr = ubd_dev->no_cow ? NULL : &ubd_dev->cow.file;
back_ptr, &ubd_dev->cow.bitmap_offset,
&ubd_dev->cow.bitmap_len, &ubd_dev->cow.data_offset,
fd = create_cow_file(ubd_dev->file, ubd_dev->cow.file,
&ubd_dev->cow.bitmap_offset,
&ubd_dev->cow.bitmap_len,
&ubd_dev->cow.data_offset);
"\"%s\"\n", ubd_dev->file, ubd_dev->cow.file);
if(ubd_dev->cow.file != NULL){
ubd_dev->cow.bitmap = vmalloc(ubd_dev->cow.bitmap_len);
if(ubd_dev->cow.bitmap == NULL){
err = read_cow_bitmap(ubd_dev->fd, ubd_dev->cow.bitmap,
ubd_dev->cow.bitmap_offset,
ubd_dev->cow.bitmap_len);
err = open_ubd_file(ubd_dev->cow.file, &flags, ubd_dev->shared, NULL,
ubd_dev->cow.fd = err;
if (ubd_dev->cow.file)
if(ubd_dev->cow.file != NULL){
CONFIG_CHUNK(str, size, len, ubd_dev->cow.file, 1);
src.bdev = s->cow->bdev;
r = dm_get_device(ti, cow_path, dm_table_get_mode(ti->table), &s->cow);
if (s->cow->bdev && s->cow->bdev == s->origin->bdev) {
dm_put_device(ti, s->cow);
dm_put_device(ti, s->cow);
dest.bdev = s->cow->bdev;
return s->cow;
bio_set_dev(bio, s->cow->bdev);
dest.bdev = s->cow->bdev;
bio_set_dev(bio, s->cow->bdev);
bio_set_dev(bio, s->cow->bdev);
DMEMIT("%s %s", snap->origin->name, snap->cow->name);
DMEMIT(",snap_cow_name=%s", snap->cow->name);
r = fn(ti, snap->cow, 0, get_dev_size(snap->cow->bdev), data);
if (!bdev_equal(s->cow->bdev, snap->cow->bdev))
struct dm_dev *cow;
cow_dev_size = get_dev_size(s->cow->bdev);
int ins_len, int cow)
BUG_ON(!cow && ins_len);
ASSERT(!p->nowait || !cow);
if (!cow)
if (cow && (p->keep_locks || p->lowest_level))
if (cow) {
struct extent_buffer *cow;
cow = btrfs_alloc_tree_block(trans, root, 0, new_root_objectid,
if (IS_ERR(cow))
return PTR_ERR(cow);
copy_extent_buffer_full(cow, buf);
btrfs_set_header_bytenr(cow, cow->start);
btrfs_set_header_generation(cow, trans->transid);
btrfs_set_header_backref_rev(cow, BTRFS_MIXED_BACKREF_REV);
btrfs_clear_header_flag(cow, BTRFS_HEADER_FLAG_WRITTEN |
btrfs_set_header_flag(cow, BTRFS_HEADER_FLAG_RELOC);
btrfs_set_header_owner(cow, new_root_objectid);
write_extent_buffer_fsid(cow, fs_info->fs_devices->metadata_uuid);
btrfs_tree_unlock(cow);
free_extent_buffer(cow);
ret = btrfs_inc_ref(trans, root, cow, is_reloc_root);
btrfs_tree_unlock(cow);
free_extent_buffer(cow);
btrfs_mark_buffer_dirty(trans, cow);
*cow_ret = cow;
struct extent_buffer *cow,
ret = btrfs_inc_ref(trans, root, cow, true);
ret = btrfs_inc_ref(trans, root, cow, is_reloc_root);
ret = btrfs_inc_ref(trans, root, cow, is_reloc_root);
struct extent_buffer *cow;
cow = btrfs_alloc_tree_block(trans, root, parent_start,
if (IS_ERR(cow))
return PTR_ERR(cow);
copy_extent_buffer_full(cow, buf);
btrfs_set_header_bytenr(cow, cow->start);
btrfs_set_header_generation(cow, trans->transid);
btrfs_set_header_backref_rev(cow, BTRFS_MIXED_BACKREF_REV);
btrfs_clear_header_flag(cow, BTRFS_HEADER_FLAG_WRITTEN |
btrfs_set_header_flag(cow, BTRFS_HEADER_FLAG_RELOC);
btrfs_set_header_owner(cow, btrfs_root_id(root));
write_extent_buffer_fsid(cow, fs_info->fs_devices->metadata_uuid);
ret = update_ref_for_cow(trans, root, buf, cow, &last_ref);
ret = btrfs_reloc_cow_block(trans, root, buf, cow);
ret = btrfs_tree_mod_log_insert_root(root->node, cow, true);
refcount_inc(&cow->refs);
rcu_assign_pointer(root->node, cow);
cow->start);
trace_btrfs_cow_block(root, buf, cow);
btrfs_mark_buffer_dirty(trans, cow);
btrfs_inhibit_eb_writeback(trans, cow);
*cow_ret = cow;
btrfs_tree_unlock(cow);
free_extent_buffer(cow);
int ins_len, int cow);
const int cow = (mod != 0);
ret = btrfs_search_slot(trans, root, key, path, ins_len, cow);
u64 bytenr, int cow)
ret = btrfs_search_slot(trans, root, &file_key, path, 0, cow);
int cow = mod != 0;
return btrfs_search_slot(trans, root, &file_key, path, ins_len, cow);
ret = btrfs_search_slot(trans, root, &key, path, 0, cow);
int ins_len, int cow)
ret = btrfs_search_slot(trans, root, key, p, ins_len, cow);
struct btrfs_path *path, int cow)
struct btrfs_path *path, int cow);
int cow = mod != 0;
ret = btrfs_search_slot(trans, root, location, path, ins_len, cow);
static int add_async_extent(struct async_chunk *cow, u64 start, u64 ram_size,
list_add_tail(&async_extent->list, &cow->extents);
bool cow = false;
if (cow) {
if (cow) {
if (!cow) {
cow = true;
struct extent_buffer *cow)
refcount_inc(&cow->refs);
node->eb = cow;
node->new_bytenr = cow->start;
ret = replace_file_extents(trans, rc, root, cow);
struct extent_buffer *cow);
bool cow = write && iomap->flags & IOMAP_F_SHARED;
if (iomap->flags & IOMAP_F_NEW || cow) {
if (cow)
if (cow) {
const struct extent_buffer *cow),
TP_ARGS(root, buf, cow),
__entry->cow_start = cow->start;
__entry->cow_level = btrfs_header_level(cow);
bool cow = is_cow_mapping(src_vma->vm_flags);
if (cow) {
if (!softleaf_is_migration_read(softleaf) && cow) {
if (cow) {
if (cow) {
goto cow;
goto cow;
cow:
goto cow;
goto cow;
cow: