mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-08-27 03:10:12 +00:00
![Linus Torvalds](/assets/img/avatar_default.png)
-----BEGIN PGP SIGNATURE----- iQIzBAABCgAdFiEE8rQSAMVO+zA4DBdWxWXV+ddtWDsFAmLnyNUACgkQxWXV+ddt WDt9vA/9HcF+v5EkknyW07tatTap/Hm/ZB86Z5OZi6ikwIEcHsWhp3rUICejm88e GecDPIluDtCtyD6x4stuqkwOm22aDP5q2T9H6+gyw92ozyb436OV1Z8IrmftzXKY EpZO70PHZT+E6E/WYvyoTmmoCrjib7YlqCWZZhSLUFpsqqlOInmHEH49PW6KvM4r acUZ/RxHurKdmI3kNY6ECbAQl6CASvtTdYcVCx8fT2zN0azoLIQxpYa7n/9ca1R6 8WnYilCbLbNGtcUXvO2M3tMZ4/5kvxrwQsUn93ccCJYuiN0ASiDXbLZ2g4LZ+n56 JGu+y5v5oBwjpVf+46cuvnENP5BQ61594WPseiVjrqODWnPjN28XkcVC0XmPsiiZ lszeHO2cuIrIFoCah8ELMl8usu8+qxfXmPxIXtPu9rEyKsDtOjxVYc8SMXqLp0qQ qYtBoFm0JcZHqtZRpB+dhQ37/xXtH4ljUi/mI6x8iALVujeR273URs7yO9zgIdeW uZoFtbwpHFLUk+TL7Ku82/zOXp3fCwtDpNmlYbxeMbea/be3ShjncM4+mYzvHYri dYON2LFrq+mnRDqtIXTCaAYwX7zU8Y18Ev9QwlNll8dKlKwS89+jpqLoa+eVYy3c /HitHFza70KxmOj4dvDVZlzDpPvl7kW1UBkmskg4u3jnNWzedkM= =sS1q -----END PGP SIGNATURE----- Merge tag 'for-5.20-tag' of git://git.kernel.org/pub/scm/linux/kernel/git/kdave/linux Pull btrfs updates from David Sterba: "This brings some long awaited changes, the send protocol bump, otherwise lots of small improvements and fixes. The main core part is reworking bio handling, cleaning up the submission and endio and improving error handling. There are some changes outside of btrfs adding helpers or updating API, listed at the end of the changelog. Features: - sysfs: - export chunk size, in debug mode add tunable for setting its size - show zoned among features (was only in debug mode) - show commit stats (number, last/max/total duration) - send protocol updated to 2 - new commands: - ability write larger data chunks than 64K - send raw compressed extents (uses the encoded data ioctls), ie. no decompression on send side, no compression needed on receive side if supported - send 'otime' (inode creation time) among other timestamps - send file attributes (a.k.a file flags and xflags) - this is first version bump, backward compatibility on send and receive side is provided - there are still some known and wanted commands that will be implemented in the near future, another version bump will be needed, however we want to minimize that to avoid causing usability issues - print checksum type and implementation at mount time - don't print some messages at mount (mentioned as people asked about it), we want to print messages namely for new features so let's make some space for that - big metadata - this has been supported for a long time and is not a feature that's worth mentioning - skinny metadata - same reason, set by default by mkfs Performance improvements: - reduced amount of reserved metadata for delayed items - when inserted items can be batched into one leaf - when deleting batched directory index items - when deleting delayed items used for deletion - overall improved count of files/sec, decreased subvolume lock contention - metadata item access bounds checker micro-optimized, with a few percent of improved runtime for metadata-heavy operations - increase direct io limit for read to 256 sectors, improved throughput by 3x on sample workload Notable fixes: - raid56 - reduce parity writes, skip sectors of stripe when there are no data updates - restore reading from on-disk data instead of using stripe cache, this reduces chances to damage correct data due to RMW cycle - refuse to replay log with unknown incompat read-only feature bit set - zoned - fix page locking when COW fails in the middle of allocation - improved tracking of active zones, ZNS drives may limit the number and there are ENOSPC errors due to that limit and not actual lack of space - adjust maximum extent size for zone append so it does not cause late ENOSPC due to underreservation - mirror reading error messages show the mirror number - don't fallback to buffered IO for NOWAIT direct IO writes, we don't have the NOWAIT semantics for buffered io yet - send, fix sending link commands for existing file paths when there are deleted and created hardlinks for same files - repair all mirrors for profiles with more than 1 copy (raid1c34) - fix repair of compressed extents, unify where error detection and repair happen Core changes: - bio completion cleanups - don't double defer compression bios - simplify endio workqueues - add more data to btrfs_bio to avoid allocation for read requests - rework bio error handling so it's same what block layer does, the submission works and errors are consumed in endio - when asynchronous bio offload fails fall back to synchronous checksum calculation to avoid errors under writeback or memory pressure - new trace points - raid56 events - ordered extent operations - super block log_root_transid deprecated (never used) - mixed_backref and big_metadata sysfs feature files removed, they've been default for sufficiently long time, there are no known users and mixed_backref could be confused with mixed_groups Non-btrfs changes, API updates: - minor highmem API update to cover const arguments - switch all kmap/kmap_atomic to kmap_local - remove redundant flush_dcache_page() - address_space_operations::writepage callback removed - add bdev_max_segments() helper" * tag 'for-5.20-tag' of git://git.kernel.org/pub/scm/linux/kernel/git/kdave/linux: (163 commits) btrfs: don't call btrfs_page_set_checked in finish_compressed_bio_read btrfs: fix repair of compressed extents btrfs: remove the start argument to check_data_csum and export btrfs: pass a btrfs_bio to btrfs_repair_one_sector btrfs: simplify the pending I/O counting in struct compressed_bio btrfs: repair all known bad mirrors btrfs: merge btrfs_dev_stat_print_on_error with its only caller btrfs: join running log transaction when logging new name btrfs: simplify error handling in btrfs_lookup_dentry btrfs: send: always use the rbtree based inode ref management infrastructure btrfs: send: fix sending link commands for existing file paths btrfs: send: introduce recorded_ref_alloc and recorded_ref_free btrfs: zoned: wait until zone is finished when allocation didn't progress btrfs: zoned: write out partially allocated region btrfs: zoned: activate necessary block group btrfs: zoned: activate metadata block group on flush_space btrfs: zoned: disable metadata overcommit for zoned btrfs: zoned: introduce space_info->active_total_bytes btrfs: zoned: finish least available block group on data bg allocation btrfs: let can_allocate_chunk return error ...
3861 lines
105 KiB
C
3861 lines
105 KiB
C
// SPDX-License-Identifier: GPL-2.0
|
|
/*
|
|
* Copyright (C) 2007 Oracle. All rights reserved.
|
|
*/
|
|
|
|
#include <linux/fs.h>
|
|
#include <linux/pagemap.h>
|
|
#include <linux/time.h>
|
|
#include <linux/init.h>
|
|
#include <linux/string.h>
|
|
#include <linux/backing-dev.h>
|
|
#include <linux/falloc.h>
|
|
#include <linux/writeback.h>
|
|
#include <linux/compat.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/btrfs.h>
|
|
#include <linux/uio.h>
|
|
#include <linux/iversion.h>
|
|
#include <linux/fsverity.h>
|
|
#include "ctree.h"
|
|
#include "disk-io.h"
|
|
#include "transaction.h"
|
|
#include "btrfs_inode.h"
|
|
#include "print-tree.h"
|
|
#include "tree-log.h"
|
|
#include "locking.h"
|
|
#include "volumes.h"
|
|
#include "qgroup.h"
|
|
#include "compression.h"
|
|
#include "delalloc-space.h"
|
|
#include "reflink.h"
|
|
#include "subpage.h"
|
|
|
|
static struct kmem_cache *btrfs_inode_defrag_cachep;
|
|
/*
|
|
* when auto defrag is enabled we
|
|
* queue up these defrag structs to remember which
|
|
* inodes need defragging passes
|
|
*/
|
|
struct inode_defrag {
|
|
struct rb_node rb_node;
|
|
/* objectid */
|
|
u64 ino;
|
|
/*
|
|
* transid where the defrag was added, we search for
|
|
* extents newer than this
|
|
*/
|
|
u64 transid;
|
|
|
|
/* root objectid */
|
|
u64 root;
|
|
|
|
/*
|
|
* The extent size threshold for autodefrag.
|
|
*
|
|
* This value is different for compressed/non-compressed extents,
|
|
* thus needs to be passed from higher layer.
|
|
* (aka, inode_should_defrag())
|
|
*/
|
|
u32 extent_thresh;
|
|
};
|
|
|
|
static int __compare_inode_defrag(struct inode_defrag *defrag1,
|
|
struct inode_defrag *defrag2)
|
|
{
|
|
if (defrag1->root > defrag2->root)
|
|
return 1;
|
|
else if (defrag1->root < defrag2->root)
|
|
return -1;
|
|
else if (defrag1->ino > defrag2->ino)
|
|
return 1;
|
|
else if (defrag1->ino < defrag2->ino)
|
|
return -1;
|
|
else
|
|
return 0;
|
|
}
|
|
|
|
/* pop a record for an inode into the defrag tree. The lock
|
|
* must be held already
|
|
*
|
|
* If you're inserting a record for an older transid than an
|
|
* existing record, the transid already in the tree is lowered
|
|
*
|
|
* If an existing record is found the defrag item you
|
|
* pass in is freed
|
|
*/
|
|
static int __btrfs_add_inode_defrag(struct btrfs_inode *inode,
|
|
struct inode_defrag *defrag)
|
|
{
|
|
struct btrfs_fs_info *fs_info = inode->root->fs_info;
|
|
struct inode_defrag *entry;
|
|
struct rb_node **p;
|
|
struct rb_node *parent = NULL;
|
|
int ret;
|
|
|
|
p = &fs_info->defrag_inodes.rb_node;
|
|
while (*p) {
|
|
parent = *p;
|
|
entry = rb_entry(parent, struct inode_defrag, rb_node);
|
|
|
|
ret = __compare_inode_defrag(defrag, entry);
|
|
if (ret < 0)
|
|
p = &parent->rb_left;
|
|
else if (ret > 0)
|
|
p = &parent->rb_right;
|
|
else {
|
|
/* if we're reinserting an entry for
|
|
* an old defrag run, make sure to
|
|
* lower the transid of our existing record
|
|
*/
|
|
if (defrag->transid < entry->transid)
|
|
entry->transid = defrag->transid;
|
|
entry->extent_thresh = min(defrag->extent_thresh,
|
|
entry->extent_thresh);
|
|
return -EEXIST;
|
|
}
|
|
}
|
|
set_bit(BTRFS_INODE_IN_DEFRAG, &inode->runtime_flags);
|
|
rb_link_node(&defrag->rb_node, parent, p);
|
|
rb_insert_color(&defrag->rb_node, &fs_info->defrag_inodes);
|
|
return 0;
|
|
}
|
|
|
|
static inline int __need_auto_defrag(struct btrfs_fs_info *fs_info)
|
|
{
|
|
if (!btrfs_test_opt(fs_info, AUTO_DEFRAG))
|
|
return 0;
|
|
|
|
if (btrfs_fs_closing(fs_info))
|
|
return 0;
|
|
|
|
return 1;
|
|
}
|
|
|
|
/*
|
|
* insert a defrag record for this inode if auto defrag is
|
|
* enabled
|
|
*/
|
|
int btrfs_add_inode_defrag(struct btrfs_trans_handle *trans,
|
|
struct btrfs_inode *inode, u32 extent_thresh)
|
|
{
|
|
struct btrfs_root *root = inode->root;
|
|
struct btrfs_fs_info *fs_info = root->fs_info;
|
|
struct inode_defrag *defrag;
|
|
u64 transid;
|
|
int ret;
|
|
|
|
if (!__need_auto_defrag(fs_info))
|
|
return 0;
|
|
|
|
if (test_bit(BTRFS_INODE_IN_DEFRAG, &inode->runtime_flags))
|
|
return 0;
|
|
|
|
if (trans)
|
|
transid = trans->transid;
|
|
else
|
|
transid = inode->root->last_trans;
|
|
|
|
defrag = kmem_cache_zalloc(btrfs_inode_defrag_cachep, GFP_NOFS);
|
|
if (!defrag)
|
|
return -ENOMEM;
|
|
|
|
defrag->ino = btrfs_ino(inode);
|
|
defrag->transid = transid;
|
|
defrag->root = root->root_key.objectid;
|
|
defrag->extent_thresh = extent_thresh;
|
|
|
|
spin_lock(&fs_info->defrag_inodes_lock);
|
|
if (!test_bit(BTRFS_INODE_IN_DEFRAG, &inode->runtime_flags)) {
|
|
/*
|
|
* If we set IN_DEFRAG flag and evict the inode from memory,
|
|
* and then re-read this inode, this new inode doesn't have
|
|
* IN_DEFRAG flag. At the case, we may find the existed defrag.
|
|
*/
|
|
ret = __btrfs_add_inode_defrag(inode, defrag);
|
|
if (ret)
|
|
kmem_cache_free(btrfs_inode_defrag_cachep, defrag);
|
|
} else {
|
|
kmem_cache_free(btrfs_inode_defrag_cachep, defrag);
|
|
}
|
|
spin_unlock(&fs_info->defrag_inodes_lock);
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* pick the defragable inode that we want, if it doesn't exist, we will get
|
|
* the next one.
|
|
*/
|
|
static struct inode_defrag *
|
|
btrfs_pick_defrag_inode(struct btrfs_fs_info *fs_info, u64 root, u64 ino)
|
|
{
|
|
struct inode_defrag *entry = NULL;
|
|
struct inode_defrag tmp;
|
|
struct rb_node *p;
|
|
struct rb_node *parent = NULL;
|
|
int ret;
|
|
|
|
tmp.ino = ino;
|
|
tmp.root = root;
|
|
|
|
spin_lock(&fs_info->defrag_inodes_lock);
|
|
p = fs_info->defrag_inodes.rb_node;
|
|
while (p) {
|
|
parent = p;
|
|
entry = rb_entry(parent, struct inode_defrag, rb_node);
|
|
|
|
ret = __compare_inode_defrag(&tmp, entry);
|
|
if (ret < 0)
|
|
p = parent->rb_left;
|
|
else if (ret > 0)
|
|
p = parent->rb_right;
|
|
else
|
|
goto out;
|
|
}
|
|
|
|
if (parent && __compare_inode_defrag(&tmp, entry) > 0) {
|
|
parent = rb_next(parent);
|
|
if (parent)
|
|
entry = rb_entry(parent, struct inode_defrag, rb_node);
|
|
else
|
|
entry = NULL;
|
|
}
|
|
out:
|
|
if (entry)
|
|
rb_erase(parent, &fs_info->defrag_inodes);
|
|
spin_unlock(&fs_info->defrag_inodes_lock);
|
|
return entry;
|
|
}
|
|
|
|
void btrfs_cleanup_defrag_inodes(struct btrfs_fs_info *fs_info)
|
|
{
|
|
struct inode_defrag *defrag;
|
|
struct rb_node *node;
|
|
|
|
spin_lock(&fs_info->defrag_inodes_lock);
|
|
node = rb_first(&fs_info->defrag_inodes);
|
|
while (node) {
|
|
rb_erase(node, &fs_info->defrag_inodes);
|
|
defrag = rb_entry(node, struct inode_defrag, rb_node);
|
|
kmem_cache_free(btrfs_inode_defrag_cachep, defrag);
|
|
|
|
cond_resched_lock(&fs_info->defrag_inodes_lock);
|
|
|
|
node = rb_first(&fs_info->defrag_inodes);
|
|
}
|
|
spin_unlock(&fs_info->defrag_inodes_lock);
|
|
}
|
|
|
|
#define BTRFS_DEFRAG_BATCH 1024
|
|
|
|
static int __btrfs_run_defrag_inode(struct btrfs_fs_info *fs_info,
|
|
struct inode_defrag *defrag)
|
|
{
|
|
struct btrfs_root *inode_root;
|
|
struct inode *inode;
|
|
struct btrfs_ioctl_defrag_range_args range;
|
|
int ret = 0;
|
|
u64 cur = 0;
|
|
|
|
again:
|
|
if (test_bit(BTRFS_FS_STATE_REMOUNTING, &fs_info->fs_state))
|
|
goto cleanup;
|
|
if (!__need_auto_defrag(fs_info))
|
|
goto cleanup;
|
|
|
|
/* get the inode */
|
|
inode_root = btrfs_get_fs_root(fs_info, defrag->root, true);
|
|
if (IS_ERR(inode_root)) {
|
|
ret = PTR_ERR(inode_root);
|
|
goto cleanup;
|
|
}
|
|
|
|
inode = btrfs_iget(fs_info->sb, defrag->ino, inode_root);
|
|
btrfs_put_root(inode_root);
|
|
if (IS_ERR(inode)) {
|
|
ret = PTR_ERR(inode);
|
|
goto cleanup;
|
|
}
|
|
|
|
if (cur >= i_size_read(inode)) {
|
|
iput(inode);
|
|
goto cleanup;
|
|
}
|
|
|
|
/* do a chunk of defrag */
|
|
clear_bit(BTRFS_INODE_IN_DEFRAG, &BTRFS_I(inode)->runtime_flags);
|
|
memset(&range, 0, sizeof(range));
|
|
range.len = (u64)-1;
|
|
range.start = cur;
|
|
range.extent_thresh = defrag->extent_thresh;
|
|
|
|
sb_start_write(fs_info->sb);
|
|
ret = btrfs_defrag_file(inode, NULL, &range, defrag->transid,
|
|
BTRFS_DEFRAG_BATCH);
|
|
sb_end_write(fs_info->sb);
|
|
iput(inode);
|
|
|
|
if (ret < 0)
|
|
goto cleanup;
|
|
|
|
cur = max(cur + fs_info->sectorsize, range.start);
|
|
goto again;
|
|
|
|
cleanup:
|
|
kmem_cache_free(btrfs_inode_defrag_cachep, defrag);
|
|
return ret;
|
|
}
|
|
|
|
/*
|
|
* run through the list of inodes in the FS that need
|
|
* defragging
|
|
*/
|
|
int btrfs_run_defrag_inodes(struct btrfs_fs_info *fs_info)
|
|
{
|
|
struct inode_defrag *defrag;
|
|
u64 first_ino = 0;
|
|
u64 root_objectid = 0;
|
|
|
|
atomic_inc(&fs_info->defrag_running);
|
|
while (1) {
|
|
/* Pause the auto defragger. */
|
|
if (test_bit(BTRFS_FS_STATE_REMOUNTING,
|
|
&fs_info->fs_state))
|
|
break;
|
|
|
|
if (!__need_auto_defrag(fs_info))
|
|
break;
|
|
|
|
/* find an inode to defrag */
|
|
defrag = btrfs_pick_defrag_inode(fs_info, root_objectid,
|
|
first_ino);
|
|
if (!defrag) {
|
|
if (root_objectid || first_ino) {
|
|
root_objectid = 0;
|
|
first_ino = 0;
|
|
continue;
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
|
|
first_ino = defrag->ino + 1;
|
|
root_objectid = defrag->root;
|
|
|
|
__btrfs_run_defrag_inode(fs_info, defrag);
|
|
}
|
|
atomic_dec(&fs_info->defrag_running);
|
|
|
|
/*
|
|
* during unmount, we use the transaction_wait queue to
|
|
* wait for the defragger to stop
|
|
*/
|
|
wake_up(&fs_info->transaction_wait);
|
|
return 0;
|
|
}
|
|
|
|
/* simple helper to fault in pages and copy. This should go away
|
|
* and be replaced with calls into generic code.
|
|
*/
|
|
static noinline int btrfs_copy_from_user(loff_t pos, size_t write_bytes,
|
|
struct page **prepared_pages,
|
|
struct iov_iter *i)
|
|
{
|
|
size_t copied = 0;
|
|
size_t total_copied = 0;
|
|
int pg = 0;
|
|
int offset = offset_in_page(pos);
|
|
|
|
while (write_bytes > 0) {
|
|
size_t count = min_t(size_t,
|
|
PAGE_SIZE - offset, write_bytes);
|
|
struct page *page = prepared_pages[pg];
|
|
/*
|
|
* Copy data from userspace to the current page
|
|
*/
|
|
copied = copy_page_from_iter_atomic(page, offset, count, i);
|
|
|
|
/* Flush processor's dcache for this page */
|
|
flush_dcache_page(page);
|
|
|
|
/*
|
|
* if we get a partial write, we can end up with
|
|
* partially up to date pages. These add
|
|
* a lot of complexity, so make sure they don't
|
|
* happen by forcing this copy to be retried.
|
|
*
|
|
* The rest of the btrfs_file_write code will fall
|
|
* back to page at a time copies after we return 0.
|
|
*/
|
|
if (unlikely(copied < count)) {
|
|
if (!PageUptodate(page)) {
|
|
iov_iter_revert(i, copied);
|
|
copied = 0;
|
|
}
|
|
if (!copied)
|
|
break;
|
|
}
|
|
|
|
write_bytes -= copied;
|
|
total_copied += copied;
|
|
offset += copied;
|
|
if (offset == PAGE_SIZE) {
|
|
pg++;
|
|
offset = 0;
|
|
}
|
|
}
|
|
return total_copied;
|
|
}
|
|
|
|
/*
|
|
* unlocks pages after btrfs_file_write is done with them
|
|
*/
|
|
static void btrfs_drop_pages(struct btrfs_fs_info *fs_info,
|
|
struct page **pages, size_t num_pages,
|
|
u64 pos, u64 copied)
|
|
{
|
|
size_t i;
|
|
u64 block_start = round_down(pos, fs_info->sectorsize);
|
|
u64 block_len = round_up(pos + copied, fs_info->sectorsize) - block_start;
|
|
|
|
ASSERT(block_len <= U32_MAX);
|
|
for (i = 0; i < num_pages; i++) {
|
|
/* page checked is some magic around finding pages that
|
|
* have been modified without going through btrfs_set_page_dirty
|
|
* clear it here. There should be no need to mark the pages
|
|
* accessed as prepare_pages should have marked them accessed
|
|
* in prepare_pages via find_or_create_page()
|
|
*/
|
|
btrfs_page_clamp_clear_checked(fs_info, pages[i], block_start,
|
|
block_len);
|
|
unlock_page(pages[i]);
|
|
put_page(pages[i]);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* After btrfs_copy_from_user(), update the following things for delalloc:
|
|
* - Mark newly dirtied pages as DELALLOC in the io tree.
|
|
* Used to advise which range is to be written back.
|
|
* - Mark modified pages as Uptodate/Dirty and not needing COW fixup
|
|
* - Update inode size for past EOF write
|
|
*/
|
|
int btrfs_dirty_pages(struct btrfs_inode *inode, struct page **pages,
|
|
size_t num_pages, loff_t pos, size_t write_bytes,
|
|
struct extent_state **cached, bool noreserve)
|
|
{
|
|
struct btrfs_fs_info *fs_info = inode->root->fs_info;
|
|
int err = 0;
|
|
int i;
|
|
u64 num_bytes;
|
|
u64 start_pos;
|
|
u64 end_of_last_block;
|
|
u64 end_pos = pos + write_bytes;
|
|
loff_t isize = i_size_read(&inode->vfs_inode);
|
|
unsigned int extra_bits = 0;
|
|
|
|
if (write_bytes == 0)
|
|
return 0;
|
|
|
|
if (noreserve)
|
|
extra_bits |= EXTENT_NORESERVE;
|
|
|
|
start_pos = round_down(pos, fs_info->sectorsize);
|
|
num_bytes = round_up(write_bytes + pos - start_pos,
|
|
fs_info->sectorsize);
|
|
ASSERT(num_bytes <= U32_MAX);
|
|
|
|
end_of_last_block = start_pos + num_bytes - 1;
|
|
|
|
/*
|
|
* The pages may have already been dirty, clear out old accounting so
|
|
* we can set things up properly
|
|
*/
|
|
clear_extent_bit(&inode->io_tree, start_pos, end_of_last_block,
|
|
EXTENT_DELALLOC | EXTENT_DO_ACCOUNTING | EXTENT_DEFRAG,
|
|
0, 0, cached);
|
|
|
|
err = btrfs_set_extent_delalloc(inode, start_pos, end_of_last_block,
|
|
extra_bits, cached);
|
|
if (err)
|
|
return err;
|
|
|
|
for (i = 0; i < num_pages; i++) {
|
|
struct page *p = pages[i];
|
|
|
|
btrfs_page_clamp_set_uptodate(fs_info, p, start_pos, num_bytes);
|
|
btrfs_page_clamp_clear_checked(fs_info, p, start_pos, num_bytes);
|
|
btrfs_page_clamp_set_dirty(fs_info, p, start_pos, num_bytes);
|
|
}
|
|
|
|
/*
|
|
* we've only changed i_size in ram, and we haven't updated
|
|
* the disk i_size. There is no need to log the inode
|
|
* at this time.
|
|
*/
|
|
if (end_pos > isize)
|
|
i_size_write(&inode->vfs_inode, end_pos);
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* this drops all the extents in the cache that intersect the range
|
|
* [start, end]. Existing extents are split as required.
|
|
*/
|
|
void btrfs_drop_extent_cache(struct btrfs_inode *inode, u64 start, u64 end,
|
|
int skip_pinned)
|
|
{
|
|
struct extent_map *em;
|
|
struct extent_map *split = NULL;
|
|
struct extent_map *split2 = NULL;
|
|
struct extent_map_tree *em_tree = &inode->extent_tree;
|
|
u64 len = end - start + 1;
|
|
u64 gen;
|
|
int ret;
|
|
int testend = 1;
|
|
unsigned long flags;
|
|
int compressed = 0;
|
|
bool modified;
|
|
|
|
WARN_ON(end < start);
|
|
if (end == (u64)-1) {
|
|
len = (u64)-1;
|
|
testend = 0;
|
|
}
|
|
while (1) {
|
|
int no_splits = 0;
|
|
|
|
modified = false;
|
|
if (!split)
|
|
split = alloc_extent_map();
|
|
if (!split2)
|
|
split2 = alloc_extent_map();
|
|
if (!split || !split2)
|
|
no_splits = 1;
|
|
|
|
write_lock(&em_tree->lock);
|
|
em = lookup_extent_mapping(em_tree, start, len);
|
|
if (!em) {
|
|
write_unlock(&em_tree->lock);
|
|
break;
|
|
}
|
|
flags = em->flags;
|
|
gen = em->generation;
|
|
if (skip_pinned && test_bit(EXTENT_FLAG_PINNED, &em->flags)) {
|
|
if (testend && em->start + em->len >= start + len) {
|
|
free_extent_map(em);
|
|
write_unlock(&em_tree->lock);
|
|
break;
|
|
}
|
|
start = em->start + em->len;
|
|
if (testend)
|
|
len = start + len - (em->start + em->len);
|
|
free_extent_map(em);
|
|
write_unlock(&em_tree->lock);
|
|
continue;
|
|
}
|
|
compressed = test_bit(EXTENT_FLAG_COMPRESSED, &em->flags);
|
|
clear_bit(EXTENT_FLAG_PINNED, &em->flags);
|
|
clear_bit(EXTENT_FLAG_LOGGING, &flags);
|
|
modified = !list_empty(&em->list);
|
|
if (no_splits)
|
|
goto next;
|
|
|
|
if (em->start < start) {
|
|
split->start = em->start;
|
|
split->len = start - em->start;
|
|
|
|
if (em->block_start < EXTENT_MAP_LAST_BYTE) {
|
|
split->orig_start = em->orig_start;
|
|
split->block_start = em->block_start;
|
|
|
|
if (compressed)
|
|
split->block_len = em->block_len;
|
|
else
|
|
split->block_len = split->len;
|
|
split->orig_block_len = max(split->block_len,
|
|
em->orig_block_len);
|
|
split->ram_bytes = em->ram_bytes;
|
|
} else {
|
|
split->orig_start = split->start;
|
|
split->block_len = 0;
|
|
split->block_start = em->block_start;
|
|
split->orig_block_len = 0;
|
|
split->ram_bytes = split->len;
|
|
}
|
|
|
|
split->generation = gen;
|
|
split->flags = flags;
|
|
split->compress_type = em->compress_type;
|
|
replace_extent_mapping(em_tree, em, split, modified);
|
|
free_extent_map(split);
|
|
split = split2;
|
|
split2 = NULL;
|
|
}
|
|
if (testend && em->start + em->len > start + len) {
|
|
u64 diff = start + len - em->start;
|
|
|
|
split->start = start + len;
|
|
split->len = em->start + em->len - (start + len);
|
|
split->flags = flags;
|
|
split->compress_type = em->compress_type;
|
|
split->generation = gen;
|
|
|
|
if (em->block_start < EXTENT_MAP_LAST_BYTE) {
|
|
split->orig_block_len = max(em->block_len,
|
|
em->orig_block_len);
|
|
|
|
split->ram_bytes = em->ram_bytes;
|
|
if (compressed) {
|
|
split->block_len = em->block_len;
|
|
split->block_start = em->block_start;
|
|
split->orig_start = em->orig_start;
|
|
} else {
|
|
split->block_len = split->len;
|
|
split->block_start = em->block_start
|
|
+ diff;
|
|
split->orig_start = em->orig_start;
|
|
}
|
|
} else {
|
|
split->ram_bytes = split->len;
|
|
split->orig_start = split->start;
|
|
split->block_len = 0;
|
|
split->block_start = em->block_start;
|
|
split->orig_block_len = 0;
|
|
}
|
|
|
|
if (extent_map_in_tree(em)) {
|
|
replace_extent_mapping(em_tree, em, split,
|
|
modified);
|
|
} else {
|
|
ret = add_extent_mapping(em_tree, split,
|
|
modified);
|
|
ASSERT(ret == 0); /* Logic error */
|
|
}
|
|
free_extent_map(split);
|
|
split = NULL;
|
|
}
|
|
next:
|
|
if (extent_map_in_tree(em))
|
|
remove_extent_mapping(em_tree, em);
|
|
write_unlock(&em_tree->lock);
|
|
|
|
/* once for us */
|
|
free_extent_map(em);
|
|
/* once for the tree*/
|
|
free_extent_map(em);
|
|
}
|
|
if (split)
|
|
free_extent_map(split);
|
|
if (split2)
|
|
free_extent_map(split2);
|
|
}
|
|
|
|
/*
|
|
* this is very complex, but the basic idea is to drop all extents
|
|
* in the range start - end. hint_block is filled in with a block number
|
|
* that would be a good hint to the block allocator for this file.
|
|
*
|
|
* If an extent intersects the range but is not entirely inside the range
|
|
* it is either truncated or split. Anything entirely inside the range
|
|
* is deleted from the tree.
|
|
*
|
|
* Note: the VFS' inode number of bytes is not updated, it's up to the caller
|
|
* to deal with that. We set the field 'bytes_found' of the arguments structure
|
|
* with the number of allocated bytes found in the target range, so that the
|
|
* caller can update the inode's number of bytes in an atomic way when
|
|
* replacing extents in a range to avoid races with stat(2).
|
|
*/
|
|
int btrfs_drop_extents(struct btrfs_trans_handle *trans,
|
|
struct btrfs_root *root, struct btrfs_inode *inode,
|
|
struct btrfs_drop_extents_args *args)
|
|
{
|
|
struct btrfs_fs_info *fs_info = root->fs_info;
|
|
struct extent_buffer *leaf;
|
|
struct btrfs_file_extent_item *fi;
|
|
struct btrfs_ref ref = { 0 };
|
|
struct btrfs_key key;
|
|
struct btrfs_key new_key;
|
|
u64 ino = btrfs_ino(inode);
|
|
u64 search_start = args->start;
|
|
u64 disk_bytenr = 0;
|
|
u64 num_bytes = 0;
|
|
u64 extent_offset = 0;
|
|
u64 extent_end = 0;
|
|
u64 last_end = args->start;
|
|
int del_nr = 0;
|
|
int del_slot = 0;
|
|
int extent_type;
|
|
int recow;
|
|
int ret;
|
|
int modify_tree = -1;
|
|
int update_refs;
|
|
int found = 0;
|
|
struct btrfs_path *path = args->path;
|
|
|
|
args->bytes_found = 0;
|
|
args->extent_inserted = false;
|
|
|
|
/* Must always have a path if ->replace_extent is true */
|
|
ASSERT(!(args->replace_extent && !args->path));
|
|
|
|
if (!path) {
|
|
path = btrfs_alloc_path();
|
|
if (!path) {
|
|
ret = -ENOMEM;
|
|
goto out;
|
|
}
|
|
}
|
|
|
|
if (args->drop_cache)
|
|
btrfs_drop_extent_cache(inode, args->start, args->end - 1, 0);
|
|
|
|
if (args->start >= inode->disk_i_size && !args->replace_extent)
|
|
modify_tree = 0;
|
|
|
|
update_refs = (root->root_key.objectid != BTRFS_TREE_LOG_OBJECTID);
|
|
while (1) {
|
|
recow = 0;
|
|
ret = btrfs_lookup_file_extent(trans, root, path, ino,
|
|
search_start, modify_tree);
|
|
if (ret < 0)
|
|
break;
|
|
if (ret > 0 && path->slots[0] > 0 && search_start == args->start) {
|
|
leaf = path->nodes[0];
|
|
btrfs_item_key_to_cpu(leaf, &key, path->slots[0] - 1);
|
|
if (key.objectid == ino &&
|
|
key.type == BTRFS_EXTENT_DATA_KEY)
|
|
path->slots[0]--;
|
|
}
|
|
ret = 0;
|
|
next_slot:
|
|
leaf = path->nodes[0];
|
|
if (path->slots[0] >= btrfs_header_nritems(leaf)) {
|
|
BUG_ON(del_nr > 0);
|
|
ret = btrfs_next_leaf(root, path);
|
|
if (ret < 0)
|
|
break;
|
|
if (ret > 0) {
|
|
ret = 0;
|
|
break;
|
|
}
|
|
leaf = path->nodes[0];
|
|
recow = 1;
|
|
}
|
|
|
|
btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
|
|
|
|
if (key.objectid > ino)
|
|
break;
|
|
if (WARN_ON_ONCE(key.objectid < ino) ||
|
|
key.type < BTRFS_EXTENT_DATA_KEY) {
|
|
ASSERT(del_nr == 0);
|
|
path->slots[0]++;
|
|
goto next_slot;
|
|
}
|
|
if (key.type > BTRFS_EXTENT_DATA_KEY || key.offset >= args->end)
|
|
break;
|
|
|
|
fi = btrfs_item_ptr(leaf, path->slots[0],
|
|
struct btrfs_file_extent_item);
|
|
extent_type = btrfs_file_extent_type(leaf, fi);
|
|
|
|
if (extent_type == BTRFS_FILE_EXTENT_REG ||
|
|
extent_type == BTRFS_FILE_EXTENT_PREALLOC) {
|
|
disk_bytenr = btrfs_file_extent_disk_bytenr(leaf, fi);
|
|
num_bytes = btrfs_file_extent_disk_num_bytes(leaf, fi);
|
|
extent_offset = btrfs_file_extent_offset(leaf, fi);
|
|
extent_end = key.offset +
|
|
btrfs_file_extent_num_bytes(leaf, fi);
|
|
} else if (extent_type == BTRFS_FILE_EXTENT_INLINE) {
|
|
extent_end = key.offset +
|
|
btrfs_file_extent_ram_bytes(leaf, fi);
|
|
} else {
|
|
/* can't happen */
|
|
BUG();
|
|
}
|
|
|
|
/*
|
|
* Don't skip extent items representing 0 byte lengths. They
|
|
* used to be created (bug) if while punching holes we hit
|
|
* -ENOSPC condition. So if we find one here, just ensure we
|
|
* delete it, otherwise we would insert a new file extent item
|
|
* with the same key (offset) as that 0 bytes length file
|
|
* extent item in the call to setup_items_for_insert() later
|
|
* in this function.
|
|
*/
|
|
if (extent_end == key.offset && extent_end >= search_start) {
|
|
last_end = extent_end;
|
|
goto delete_extent_item;
|
|
}
|
|
|
|
if (extent_end <= search_start) {
|
|
path->slots[0]++;
|
|
goto next_slot;
|
|
}
|
|
|
|
found = 1;
|
|
search_start = max(key.offset, args->start);
|
|
if (recow || !modify_tree) {
|
|
modify_tree = -1;
|
|
btrfs_release_path(path);
|
|
continue;
|
|
}
|
|
|
|
/*
|
|
* | - range to drop - |
|
|
* | -------- extent -------- |
|
|
*/
|
|
if (args->start > key.offset && args->end < extent_end) {
|
|
BUG_ON(del_nr > 0);
|
|
if (extent_type == BTRFS_FILE_EXTENT_INLINE) {
|
|
ret = -EOPNOTSUPP;
|
|
break;
|
|
}
|
|
|
|
memcpy(&new_key, &key, sizeof(new_key));
|
|
new_key.offset = args->start;
|
|
ret = btrfs_duplicate_item(trans, root, path,
|
|
&new_key);
|
|
if (ret == -EAGAIN) {
|
|
btrfs_release_path(path);
|
|
continue;
|
|
}
|
|
if (ret < 0)
|
|
break;
|
|
|
|
leaf = path->nodes[0];
|
|
fi = btrfs_item_ptr(leaf, path->slots[0] - 1,
|
|
struct btrfs_file_extent_item);
|
|
btrfs_set_file_extent_num_bytes(leaf, fi,
|
|
args->start - key.offset);
|
|
|
|
fi = btrfs_item_ptr(leaf, path->slots[0],
|
|
struct btrfs_file_extent_item);
|
|
|
|
extent_offset += args->start - key.offset;
|
|
btrfs_set_file_extent_offset(leaf, fi, extent_offset);
|
|
btrfs_set_file_extent_num_bytes(leaf, fi,
|
|
extent_end - args->start);
|
|
btrfs_mark_buffer_dirty(leaf);
|
|
|
|
if (update_refs && disk_bytenr > 0) {
|
|
btrfs_init_generic_ref(&ref,
|
|
BTRFS_ADD_DELAYED_REF,
|
|
disk_bytenr, num_bytes, 0);
|
|
btrfs_init_data_ref(&ref,
|
|
root->root_key.objectid,
|
|
new_key.objectid,
|
|
args->start - extent_offset,
|
|
0, false);
|
|
ret = btrfs_inc_extent_ref(trans, &ref);
|
|
BUG_ON(ret); /* -ENOMEM */
|
|
}
|
|
key.offset = args->start;
|
|
}
|
|
/*
|
|
* From here on out we will have actually dropped something, so
|
|
* last_end can be updated.
|
|
*/
|
|
last_end = extent_end;
|
|
|
|
/*
|
|
* | ---- range to drop ----- |
|
|
* | -------- extent -------- |
|
|
*/
|
|
if (args->start <= key.offset && args->end < extent_end) {
|
|
if (extent_type == BTRFS_FILE_EXTENT_INLINE) {
|
|
ret = -EOPNOTSUPP;
|
|
break;
|
|
}
|
|
|
|
memcpy(&new_key, &key, sizeof(new_key));
|
|
new_key.offset = args->end;
|
|
btrfs_set_item_key_safe(fs_info, path, &new_key);
|
|
|
|
extent_offset += args->end - key.offset;
|
|
btrfs_set_file_extent_offset(leaf, fi, extent_offset);
|
|
btrfs_set_file_extent_num_bytes(leaf, fi,
|
|
extent_end - args->end);
|
|
btrfs_mark_buffer_dirty(leaf);
|
|
if (update_refs && disk_bytenr > 0)
|
|
args->bytes_found += args->end - key.offset;
|
|
break;
|
|
}
|
|
|
|
search_start = extent_end;
|
|
/*
|
|
* | ---- range to drop ----- |
|
|
* | -------- extent -------- |
|
|
*/
|
|
if (args->start > key.offset && args->end >= extent_end) {
|
|
BUG_ON(del_nr > 0);
|
|
if (extent_type == BTRFS_FILE_EXTENT_INLINE) {
|
|
ret = -EOPNOTSUPP;
|
|
break;
|
|
}
|
|
|
|
btrfs_set_file_extent_num_bytes(leaf, fi,
|
|
args->start - key.offset);
|
|
btrfs_mark_buffer_dirty(leaf);
|
|
if (update_refs && disk_bytenr > 0)
|
|
args->bytes_found += extent_end - args->start;
|
|
if (args->end == extent_end)
|
|
break;
|
|
|
|
path->slots[0]++;
|
|
goto next_slot;
|
|
}
|
|
|
|
/*
|
|
* | ---- range to drop ----- |
|
|
* | ------ extent ------ |
|
|
*/
|
|
if (args->start <= key.offset && args->end >= extent_end) {
|
|
delete_extent_item:
|
|
if (del_nr == 0) {
|
|
del_slot = path->slots[0];
|
|
del_nr = 1;
|
|
} else {
|
|
BUG_ON(del_slot + del_nr != path->slots[0]);
|
|
del_nr++;
|
|
}
|
|
|
|
if (update_refs &&
|
|
extent_type == BTRFS_FILE_EXTENT_INLINE) {
|
|
args->bytes_found += extent_end - key.offset;
|
|
extent_end = ALIGN(extent_end,
|
|
fs_info->sectorsize);
|
|
} else if (update_refs && disk_bytenr > 0) {
|
|
btrfs_init_generic_ref(&ref,
|
|
BTRFS_DROP_DELAYED_REF,
|
|
disk_bytenr, num_bytes, 0);
|
|
btrfs_init_data_ref(&ref,
|
|
root->root_key.objectid,
|
|
key.objectid,
|
|
key.offset - extent_offset, 0,
|
|
false);
|
|
ret = btrfs_free_extent(trans, &ref);
|
|
BUG_ON(ret); /* -ENOMEM */
|
|
args->bytes_found += extent_end - key.offset;
|
|
}
|
|
|
|
if (args->end == extent_end)
|
|
break;
|
|
|
|
if (path->slots[0] + 1 < btrfs_header_nritems(leaf)) {
|
|
path->slots[0]++;
|
|
goto next_slot;
|
|
}
|
|
|
|
ret = btrfs_del_items(trans, root, path, del_slot,
|
|
del_nr);
|
|
if (ret) {
|
|
btrfs_abort_transaction(trans, ret);
|
|
break;
|
|
}
|
|
|
|
del_nr = 0;
|
|
del_slot = 0;
|
|
|
|
btrfs_release_path(path);
|
|
continue;
|
|
}
|
|
|
|
BUG();
|
|
}
|
|
|
|
if (!ret && del_nr > 0) {
|
|
/*
|
|
* Set path->slots[0] to first slot, so that after the delete
|
|
* if items are move off from our leaf to its immediate left or
|
|
* right neighbor leafs, we end up with a correct and adjusted
|
|
* path->slots[0] for our insertion (if args->replace_extent).
|
|
*/
|
|
path->slots[0] = del_slot;
|
|
ret = btrfs_del_items(trans, root, path, del_slot, del_nr);
|
|
if (ret)
|
|
btrfs_abort_transaction(trans, ret);
|
|
}
|
|
|
|
leaf = path->nodes[0];
|
|
/*
|
|
* If btrfs_del_items() was called, it might have deleted a leaf, in
|
|
* which case it unlocked our path, so check path->locks[0] matches a
|
|
* write lock.
|
|
*/
|
|
if (!ret && args->replace_extent &&
|
|
path->locks[0] == BTRFS_WRITE_LOCK &&
|
|
btrfs_leaf_free_space(leaf) >=
|
|
sizeof(struct btrfs_item) + args->extent_item_size) {
|
|
|
|
key.objectid = ino;
|
|
key.type = BTRFS_EXTENT_DATA_KEY;
|
|
key.offset = args->start;
|
|
if (!del_nr && path->slots[0] < btrfs_header_nritems(leaf)) {
|
|
struct btrfs_key slot_key;
|
|
|
|
btrfs_item_key_to_cpu(leaf, &slot_key, path->slots[0]);
|
|
if (btrfs_comp_cpu_keys(&key, &slot_key) > 0)
|
|
path->slots[0]++;
|
|
}
|
|
btrfs_setup_item_for_insert(root, path, &key, args->extent_item_size);
|
|
args->extent_inserted = true;
|
|
}
|
|
|
|
if (!args->path)
|
|
btrfs_free_path(path);
|
|
else if (!args->extent_inserted)
|
|
btrfs_release_path(path);
|
|
out:
|
|
args->drop_end = found ? min(args->end, last_end) : args->end;
|
|
|
|
return ret;
|
|
}
|
|
|
|
static int extent_mergeable(struct extent_buffer *leaf, int slot,
|
|
u64 objectid, u64 bytenr, u64 orig_offset,
|
|
u64 *start, u64 *end)
|
|
{
|
|
struct btrfs_file_extent_item *fi;
|
|
struct btrfs_key key;
|
|
u64 extent_end;
|
|
|
|
if (slot < 0 || slot >= btrfs_header_nritems(leaf))
|
|
return 0;
|
|
|
|
btrfs_item_key_to_cpu(leaf, &key, slot);
|
|
if (key.objectid != objectid || key.type != BTRFS_EXTENT_DATA_KEY)
|
|
return 0;
|
|
|
|
fi = btrfs_item_ptr(leaf, slot, struct btrfs_file_extent_item);
|
|
if (btrfs_file_extent_type(leaf, fi) != BTRFS_FILE_EXTENT_REG ||
|
|
btrfs_file_extent_disk_bytenr(leaf, fi) != bytenr ||
|
|
btrfs_file_extent_offset(leaf, fi) != key.offset - orig_offset ||
|
|
btrfs_file_extent_compression(leaf, fi) ||
|
|
btrfs_file_extent_encryption(leaf, fi) ||
|
|
btrfs_file_extent_other_encoding(leaf, fi))
|
|
return 0;
|
|
|
|
extent_end = key.offset + btrfs_file_extent_num_bytes(leaf, fi);
|
|
if ((*start && *start != key.offset) || (*end && *end != extent_end))
|
|
return 0;
|
|
|
|
*start = key.offset;
|
|
*end = extent_end;
|
|
return 1;
|
|
}
|
|
|
|
/*
|
|
* Mark extent in the range start - end as written.
|
|
*
|
|
* This changes extent type from 'pre-allocated' to 'regular'. If only
|
|
* part of extent is marked as written, the extent will be split into
|
|
* two or three.
|
|
*/
|
|
int btrfs_mark_extent_written(struct btrfs_trans_handle *trans,
|
|
struct btrfs_inode *inode, u64 start, u64 end)
|
|
{
|
|
struct btrfs_fs_info *fs_info = trans->fs_info;
|
|
struct btrfs_root *root = inode->root;
|
|
struct extent_buffer *leaf;
|
|
struct btrfs_path *path;
|
|
struct btrfs_file_extent_item *fi;
|
|
struct btrfs_ref ref = { 0 };
|
|
struct btrfs_key key;
|
|
struct btrfs_key new_key;
|
|
u64 bytenr;
|
|
u64 num_bytes;
|
|
u64 extent_end;
|
|
u64 orig_offset;
|
|
u64 other_start;
|
|
u64 other_end;
|
|
u64 split;
|
|
int del_nr = 0;
|
|
int del_slot = 0;
|
|
int recow;
|
|
int ret = 0;
|
|
u64 ino = btrfs_ino(inode);
|
|
|
|
path = btrfs_alloc_path();
|
|
if (!path)
|
|
return -ENOMEM;
|
|
again:
|
|
recow = 0;
|
|
split = start;
|
|
key.objectid = ino;
|
|
key.type = BTRFS_EXTENT_DATA_KEY;
|
|
key.offset = split;
|
|
|
|
ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
|
|
if (ret < 0)
|
|
goto out;
|
|
if (ret > 0 && path->slots[0] > 0)
|
|
path->slots[0]--;
|
|
|
|
leaf = path->nodes[0];
|
|
btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
|
|
if (key.objectid != ino ||
|
|
key.type != BTRFS_EXTENT_DATA_KEY) {
|
|
ret = -EINVAL;
|
|
btrfs_abort_transaction(trans, ret);
|
|
goto out;
|
|
}
|
|
fi = btrfs_item_ptr(leaf, path->slots[0],
|
|
struct btrfs_file_extent_item);
|
|
if (btrfs_file_extent_type(leaf, fi) != BTRFS_FILE_EXTENT_PREALLOC) {
|
|
ret = -EINVAL;
|
|
btrfs_abort_transaction(trans, ret);
|
|
goto out;
|
|
}
|
|
extent_end = key.offset + btrfs_file_extent_num_bytes(leaf, fi);
|
|
if (key.offset > start || extent_end < end) {
|
|
ret = -EINVAL;
|
|
btrfs_abort_transaction(trans, ret);
|
|
goto out;
|
|
}
|
|
|
|
bytenr = btrfs_file_extent_disk_bytenr(leaf, fi);
|
|
num_bytes = btrfs_file_extent_disk_num_bytes(leaf, fi);
|
|
orig_offset = key.offset - btrfs_file_extent_offset(leaf, fi);
|
|
memcpy(&new_key, &key, sizeof(new_key));
|
|
|
|
if (start == key.offset && end < extent_end) {
|
|
other_start = 0;
|
|
other_end = start;
|
|
if (extent_mergeable(leaf, path->slots[0] - 1,
|
|
ino, bytenr, orig_offset,
|
|
&other_start, &other_end)) {
|
|
new_key.offset = end;
|
|
btrfs_set_item_key_safe(fs_info, path, &new_key);
|
|
fi = btrfs_item_ptr(leaf, path->slots[0],
|
|
struct btrfs_file_extent_item);
|
|
btrfs_set_file_extent_generation(leaf, fi,
|
|
trans->transid);
|
|
btrfs_set_file_extent_num_bytes(leaf, fi,
|
|
extent_end - end);
|
|
btrfs_set_file_extent_offset(leaf, fi,
|
|
end - orig_offset);
|
|
fi = btrfs_item_ptr(leaf, path->slots[0] - 1,
|
|
struct btrfs_file_extent_item);
|
|
btrfs_set_file_extent_generation(leaf, fi,
|
|
trans->transid);
|
|
btrfs_set_file_extent_num_bytes(leaf, fi,
|
|
end - other_start);
|
|
btrfs_mark_buffer_dirty(leaf);
|
|
goto out;
|
|
}
|
|
}
|
|
|
|
if (start > key.offset && end == extent_end) {
|
|
other_start = end;
|
|
other_end = 0;
|
|
if (extent_mergeable(leaf, path->slots[0] + 1,
|
|
ino, bytenr, orig_offset,
|
|
&other_start, &other_end)) {
|
|
fi = btrfs_item_ptr(leaf, path->slots[0],
|
|
struct btrfs_file_extent_item);
|
|
btrfs_set_file_extent_num_bytes(leaf, fi,
|
|
start - key.offset);
|
|
btrfs_set_file_extent_generation(leaf, fi,
|
|
trans->transid);
|
|
path->slots[0]++;
|
|
new_key.offset = start;
|
|
btrfs_set_item_key_safe(fs_info, path, &new_key);
|
|
|
|
fi = btrfs_item_ptr(leaf, path->slots[0],
|
|
struct btrfs_file_extent_item);
|
|
btrfs_set_file_extent_generation(leaf, fi,
|
|
trans->transid);
|
|
btrfs_set_file_extent_num_bytes(leaf, fi,
|
|
other_end - start);
|
|
btrfs_set_file_extent_offset(leaf, fi,
|
|
start - orig_offset);
|
|
btrfs_mark_buffer_dirty(leaf);
|
|
goto out;
|
|
}
|
|
}
|
|
|
|
while (start > key.offset || end < extent_end) {
|
|
if (key.offset == start)
|
|
split = end;
|
|
|
|
new_key.offset = split;
|
|
ret = btrfs_duplicate_item(trans, root, path, &new_key);
|
|
if (ret == -EAGAIN) {
|
|
btrfs_release_path(path);
|
|
goto again;
|
|
}
|
|
if (ret < 0) {
|
|
btrfs_abort_transaction(trans, ret);
|
|
goto out;
|
|
}
|
|
|
|
leaf = path->nodes[0];
|
|
fi = btrfs_item_ptr(leaf, path->slots[0] - 1,
|
|
struct btrfs_file_extent_item);
|
|
btrfs_set_file_extent_generation(leaf, fi, trans->transid);
|
|
btrfs_set_file_extent_num_bytes(leaf, fi,
|
|
split - key.offset);
|
|
|
|
fi = btrfs_item_ptr(leaf, path->slots[0],
|
|
struct btrfs_file_extent_item);
|
|
|
|
btrfs_set_file_extent_generation(leaf, fi, trans->transid);
|
|
btrfs_set_file_extent_offset(leaf, fi, split - orig_offset);
|
|
btrfs_set_file_extent_num_bytes(leaf, fi,
|
|
extent_end - split);
|
|
btrfs_mark_buffer_dirty(leaf);
|
|
|
|
btrfs_init_generic_ref(&ref, BTRFS_ADD_DELAYED_REF, bytenr,
|
|
num_bytes, 0);
|
|
btrfs_init_data_ref(&ref, root->root_key.objectid, ino,
|
|
orig_offset, 0, false);
|
|
ret = btrfs_inc_extent_ref(trans, &ref);
|
|
if (ret) {
|
|
btrfs_abort_transaction(trans, ret);
|
|
goto out;
|
|
}
|
|
|
|
if (split == start) {
|
|
key.offset = start;
|
|
} else {
|
|
if (start != key.offset) {
|
|
ret = -EINVAL;
|
|
btrfs_abort_transaction(trans, ret);
|
|
goto out;
|
|
}
|
|
path->slots[0]--;
|
|
extent_end = end;
|
|
}
|
|
recow = 1;
|
|
}
|
|
|
|
other_start = end;
|
|
other_end = 0;
|
|
btrfs_init_generic_ref(&ref, BTRFS_DROP_DELAYED_REF, bytenr,
|
|
num_bytes, 0);
|
|
btrfs_init_data_ref(&ref, root->root_key.objectid, ino, orig_offset,
|
|
0, false);
|
|
if (extent_mergeable(leaf, path->slots[0] + 1,
|
|
ino, bytenr, orig_offset,
|
|
&other_start, &other_end)) {
|
|
if (recow) {
|
|
btrfs_release_path(path);
|
|
goto again;
|
|
}
|
|
extent_end = other_end;
|
|
del_slot = path->slots[0] + 1;
|
|
del_nr++;
|
|
ret = btrfs_free_extent(trans, &ref);
|
|
if (ret) {
|
|
btrfs_abort_transaction(trans, ret);
|
|
goto out;
|
|
}
|
|
}
|
|
other_start = 0;
|
|
other_end = start;
|
|
if (extent_mergeable(leaf, path->slots[0] - 1,
|
|
ino, bytenr, orig_offset,
|
|
&other_start, &other_end)) {
|
|
if (recow) {
|
|
btrfs_release_path(path);
|
|
goto again;
|
|
}
|
|
key.offset = other_start;
|
|
del_slot = path->slots[0];
|
|
del_nr++;
|
|
ret = btrfs_free_extent(trans, &ref);
|
|
if (ret) {
|
|
btrfs_abort_transaction(trans, ret);
|
|
goto out;
|
|
}
|
|
}
|
|
if (del_nr == 0) {
|
|
fi = btrfs_item_ptr(leaf, path->slots[0],
|
|
struct btrfs_file_extent_item);
|
|
btrfs_set_file_extent_type(leaf, fi,
|
|
BTRFS_FILE_EXTENT_REG);
|
|
btrfs_set_file_extent_generation(leaf, fi, trans->transid);
|
|
btrfs_mark_buffer_dirty(leaf);
|
|
} else {
|
|
fi = btrfs_item_ptr(leaf, del_slot - 1,
|
|
struct btrfs_file_extent_item);
|
|
btrfs_set_file_extent_type(leaf, fi,
|
|
BTRFS_FILE_EXTENT_REG);
|
|
btrfs_set_file_extent_generation(leaf, fi, trans->transid);
|
|
btrfs_set_file_extent_num_bytes(leaf, fi,
|
|
extent_end - key.offset);
|
|
btrfs_mark_buffer_dirty(leaf);
|
|
|
|
ret = btrfs_del_items(trans, root, path, del_slot, del_nr);
|
|
if (ret < 0) {
|
|
btrfs_abort_transaction(trans, ret);
|
|
goto out;
|
|
}
|
|
}
|
|
out:
|
|
btrfs_free_path(path);
|
|
return ret;
|
|
}
|
|
|
|
/*
|
|
* on error we return an unlocked page and the error value
|
|
* on success we return a locked page and 0
|
|
*/
|
|
static int prepare_uptodate_page(struct inode *inode,
|
|
struct page *page, u64 pos,
|
|
bool force_uptodate)
|
|
{
|
|
struct folio *folio = page_folio(page);
|
|
int ret = 0;
|
|
|
|
if (((pos & (PAGE_SIZE - 1)) || force_uptodate) &&
|
|
!PageUptodate(page)) {
|
|
ret = btrfs_read_folio(NULL, folio);
|
|
if (ret)
|
|
return ret;
|
|
lock_page(page);
|
|
if (!PageUptodate(page)) {
|
|
unlock_page(page);
|
|
return -EIO;
|
|
}
|
|
|
|
/*
|
|
* Since btrfs_read_folio() will unlock the folio before it
|
|
* returns, there is a window where btrfs_release_folio() can be
|
|
* called to release the page. Here we check both inode
|
|
* mapping and PagePrivate() to make sure the page was not
|
|
* released.
|
|
*
|
|
* The private flag check is essential for subpage as we need
|
|
* to store extra bitmap using page->private.
|
|
*/
|
|
if (page->mapping != inode->i_mapping || !PagePrivate(page)) {
|
|
unlock_page(page);
|
|
return -EAGAIN;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* this just gets pages into the page cache and locks them down.
|
|
*/
|
|
static noinline int prepare_pages(struct inode *inode, struct page **pages,
|
|
size_t num_pages, loff_t pos,
|
|
size_t write_bytes, bool force_uptodate)
|
|
{
|
|
int i;
|
|
unsigned long index = pos >> PAGE_SHIFT;
|
|
gfp_t mask = btrfs_alloc_write_mask(inode->i_mapping);
|
|
int err = 0;
|
|
int faili;
|
|
|
|
for (i = 0; i < num_pages; i++) {
|
|
again:
|
|
pages[i] = find_or_create_page(inode->i_mapping, index + i,
|
|
mask | __GFP_WRITE);
|
|
if (!pages[i]) {
|
|
faili = i - 1;
|
|
err = -ENOMEM;
|
|
goto fail;
|
|
}
|
|
|
|
err = set_page_extent_mapped(pages[i]);
|
|
if (err < 0) {
|
|
faili = i;
|
|
goto fail;
|
|
}
|
|
|
|
if (i == 0)
|
|
err = prepare_uptodate_page(inode, pages[i], pos,
|
|
force_uptodate);
|
|
if (!err && i == num_pages - 1)
|
|
err = prepare_uptodate_page(inode, pages[i],
|
|
pos + write_bytes, false);
|
|
if (err) {
|
|
put_page(pages[i]);
|
|
if (err == -EAGAIN) {
|
|
err = 0;
|
|
goto again;
|
|
}
|
|
faili = i - 1;
|
|
goto fail;
|
|
}
|
|
wait_on_page_writeback(pages[i]);
|
|
}
|
|
|
|
return 0;
|
|
fail:
|
|
while (faili >= 0) {
|
|
unlock_page(pages[faili]);
|
|
put_page(pages[faili]);
|
|
faili--;
|
|
}
|
|
return err;
|
|
|
|
}
|
|
|
|
/*
|
|
* This function locks the extent and properly waits for data=ordered extents
|
|
* to finish before allowing the pages to be modified if need.
|
|
*
|
|
* The return value:
|
|
* 1 - the extent is locked
|
|
* 0 - the extent is not locked, and everything is OK
|
|
* -EAGAIN - need re-prepare the pages
|
|
* the other < 0 number - Something wrong happens
|
|
*/
|
|
static noinline int
|
|
lock_and_cleanup_extent_if_need(struct btrfs_inode *inode, struct page **pages,
|
|
size_t num_pages, loff_t pos,
|
|
size_t write_bytes,
|
|
u64 *lockstart, u64 *lockend,
|
|
struct extent_state **cached_state)
|
|
{
|
|
struct btrfs_fs_info *fs_info = inode->root->fs_info;
|
|
u64 start_pos;
|
|
u64 last_pos;
|
|
int i;
|
|
int ret = 0;
|
|
|
|
start_pos = round_down(pos, fs_info->sectorsize);
|
|
last_pos = round_up(pos + write_bytes, fs_info->sectorsize) - 1;
|
|
|
|
if (start_pos < inode->vfs_inode.i_size) {
|
|
struct btrfs_ordered_extent *ordered;
|
|
|
|
lock_extent_bits(&inode->io_tree, start_pos, last_pos,
|
|
cached_state);
|
|
ordered = btrfs_lookup_ordered_range(inode, start_pos,
|
|
last_pos - start_pos + 1);
|
|
if (ordered &&
|
|
ordered->file_offset + ordered->num_bytes > start_pos &&
|
|
ordered->file_offset <= last_pos) {
|
|
unlock_extent_cached(&inode->io_tree, start_pos,
|
|
last_pos, cached_state);
|
|
for (i = 0; i < num_pages; i++) {
|
|
unlock_page(pages[i]);
|
|
put_page(pages[i]);
|
|
}
|
|
btrfs_start_ordered_extent(ordered, 1);
|
|
btrfs_put_ordered_extent(ordered);
|
|
return -EAGAIN;
|
|
}
|
|
if (ordered)
|
|
btrfs_put_ordered_extent(ordered);
|
|
|
|
*lockstart = start_pos;
|
|
*lockend = last_pos;
|
|
ret = 1;
|
|
}
|
|
|
|
/*
|
|
* We should be called after prepare_pages() which should have locked
|
|
* all pages in the range.
|
|
*/
|
|
for (i = 0; i < num_pages; i++)
|
|
WARN_ON(!PageLocked(pages[i]));
|
|
|
|
return ret;
|
|
}
|
|
|
|
/*
|
|
* Check if we can do nocow write into the range [@pos, @pos + @write_bytes)
|
|
*
|
|
* @pos: File offset.
|
|
* @write_bytes: The length to write, will be updated to the nocow writeable
|
|
* range.
|
|
*
|
|
* This function will flush ordered extents in the range to ensure proper
|
|
* nocow checks.
|
|
*
|
|
* Return:
|
|
* > 0 If we can nocow, and updates @write_bytes.
|
|
* 0 If we can't do a nocow write.
|
|
* -EAGAIN If we can't do a nocow write because snapshoting of the inode's
|
|
* root is in progress.
|
|
* < 0 If an error happened.
|
|
*
|
|
* NOTE: Callers need to call btrfs_check_nocow_unlock() if we return > 0.
|
|
*/
|
|
int btrfs_check_nocow_lock(struct btrfs_inode *inode, loff_t pos,
|
|
size_t *write_bytes)
|
|
{
|
|
struct btrfs_fs_info *fs_info = inode->root->fs_info;
|
|
struct btrfs_root *root = inode->root;
|
|
u64 lockstart, lockend;
|
|
u64 num_bytes;
|
|
int ret;
|
|
|
|
if (!(inode->flags & (BTRFS_INODE_NODATACOW | BTRFS_INODE_PREALLOC)))
|
|
return 0;
|
|
|
|
if (!btrfs_drew_try_write_lock(&root->snapshot_lock))
|
|
return -EAGAIN;
|
|
|
|
lockstart = round_down(pos, fs_info->sectorsize);
|
|
lockend = round_up(pos + *write_bytes,
|
|
fs_info->sectorsize) - 1;
|
|
num_bytes = lockend - lockstart + 1;
|
|
|
|
btrfs_lock_and_flush_ordered_range(inode, lockstart, lockend, NULL);
|
|
ret = can_nocow_extent(&inode->vfs_inode, lockstart, &num_bytes,
|
|
NULL, NULL, NULL, false);
|
|
if (ret <= 0) {
|
|
ret = 0;
|
|
btrfs_drew_write_unlock(&root->snapshot_lock);
|
|
} else {
|
|
*write_bytes = min_t(size_t, *write_bytes ,
|
|
num_bytes - pos + lockstart);
|
|
}
|
|
unlock_extent(&inode->io_tree, lockstart, lockend);
|
|
|
|
return ret;
|
|
}
|
|
|
|
void btrfs_check_nocow_unlock(struct btrfs_inode *inode)
|
|
{
|
|
btrfs_drew_write_unlock(&inode->root->snapshot_lock);
|
|
}
|
|
|
|
static void update_time_for_write(struct inode *inode)
|
|
{
|
|
struct timespec64 now;
|
|
|
|
if (IS_NOCMTIME(inode))
|
|
return;
|
|
|
|
now = current_time(inode);
|
|
if (!timespec64_equal(&inode->i_mtime, &now))
|
|
inode->i_mtime = now;
|
|
|
|
if (!timespec64_equal(&inode->i_ctime, &now))
|
|
inode->i_ctime = now;
|
|
|
|
if (IS_I_VERSION(inode))
|
|
inode_inc_iversion(inode);
|
|
}
|
|
|
|
static int btrfs_write_check(struct kiocb *iocb, struct iov_iter *from,
|
|
size_t count)
|
|
{
|
|
struct file *file = iocb->ki_filp;
|
|
struct inode *inode = file_inode(file);
|
|
struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);
|
|
loff_t pos = iocb->ki_pos;
|
|
int ret;
|
|
loff_t oldsize;
|
|
loff_t start_pos;
|
|
|
|
/*
|
|
* Quickly bail out on NOWAIT writes if we don't have the nodatacow or
|
|
* prealloc flags, as without those flags we always have to COW. We will
|
|
* later check if we can really COW into the target range (using
|
|
* can_nocow_extent() at btrfs_get_blocks_direct_write()).
|
|
*/
|
|
if ((iocb->ki_flags & IOCB_NOWAIT) &&
|
|
!(BTRFS_I(inode)->flags & (BTRFS_INODE_NODATACOW | BTRFS_INODE_PREALLOC)))
|
|
return -EAGAIN;
|
|
|
|
current->backing_dev_info = inode_to_bdi(inode);
|
|
ret = file_remove_privs(file);
|
|
if (ret)
|
|
return ret;
|
|
|
|
/*
|
|
* We reserve space for updating the inode when we reserve space for the
|
|
* extent we are going to write, so we will enospc out there. We don't
|
|
* need to start yet another transaction to update the inode as we will
|
|
* update the inode when we finish writing whatever data we write.
|
|
*/
|
|
update_time_for_write(inode);
|
|
|
|
start_pos = round_down(pos, fs_info->sectorsize);
|
|
oldsize = i_size_read(inode);
|
|
if (start_pos > oldsize) {
|
|
/* Expand hole size to cover write data, preventing empty gap */
|
|
loff_t end_pos = round_up(pos + count, fs_info->sectorsize);
|
|
|
|
ret = btrfs_cont_expand(BTRFS_I(inode), oldsize, end_pos);
|
|
if (ret) {
|
|
current->backing_dev_info = NULL;
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static noinline ssize_t btrfs_buffered_write(struct kiocb *iocb,
|
|
struct iov_iter *i)
|
|
{
|
|
struct file *file = iocb->ki_filp;
|
|
loff_t pos;
|
|
struct inode *inode = file_inode(file);
|
|
struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);
|
|
struct page **pages = NULL;
|
|
struct extent_changeset *data_reserved = NULL;
|
|
u64 release_bytes = 0;
|
|
u64 lockstart;
|
|
u64 lockend;
|
|
size_t num_written = 0;
|
|
int nrptrs;
|
|
ssize_t ret;
|
|
bool only_release_metadata = false;
|
|
bool force_page_uptodate = false;
|
|
loff_t old_isize = i_size_read(inode);
|
|
unsigned int ilock_flags = 0;
|
|
|
|
if (iocb->ki_flags & IOCB_NOWAIT)
|
|
ilock_flags |= BTRFS_ILOCK_TRY;
|
|
|
|
ret = btrfs_inode_lock(inode, ilock_flags);
|
|
if (ret < 0)
|
|
return ret;
|
|
|
|
ret = generic_write_checks(iocb, i);
|
|
if (ret <= 0)
|
|
goto out;
|
|
|
|
ret = btrfs_write_check(iocb, i, ret);
|
|
if (ret < 0)
|
|
goto out;
|
|
|
|
pos = iocb->ki_pos;
|
|
nrptrs = min(DIV_ROUND_UP(iov_iter_count(i), PAGE_SIZE),
|
|
PAGE_SIZE / (sizeof(struct page *)));
|
|
nrptrs = min(nrptrs, current->nr_dirtied_pause - current->nr_dirtied);
|
|
nrptrs = max(nrptrs, 8);
|
|
pages = kmalloc_array(nrptrs, sizeof(struct page *), GFP_KERNEL);
|
|
if (!pages) {
|
|
ret = -ENOMEM;
|
|
goto out;
|
|
}
|
|
|
|
while (iov_iter_count(i) > 0) {
|
|
struct extent_state *cached_state = NULL;
|
|
size_t offset = offset_in_page(pos);
|
|
size_t sector_offset;
|
|
size_t write_bytes = min(iov_iter_count(i),
|
|
nrptrs * (size_t)PAGE_SIZE -
|
|
offset);
|
|
size_t num_pages;
|
|
size_t reserve_bytes;
|
|
size_t dirty_pages;
|
|
size_t copied;
|
|
size_t dirty_sectors;
|
|
size_t num_sectors;
|
|
int extents_locked;
|
|
|
|
/*
|
|
* Fault pages before locking them in prepare_pages
|
|
* to avoid recursive lock
|
|
*/
|
|
if (unlikely(fault_in_iov_iter_readable(i, write_bytes))) {
|
|
ret = -EFAULT;
|
|
break;
|
|
}
|
|
|
|
only_release_metadata = false;
|
|
sector_offset = pos & (fs_info->sectorsize - 1);
|
|
|
|
extent_changeset_release(data_reserved);
|
|
ret = btrfs_check_data_free_space(BTRFS_I(inode),
|
|
&data_reserved, pos,
|
|
write_bytes);
|
|
if (ret < 0) {
|
|
/*
|
|
* If we don't have to COW at the offset, reserve
|
|
* metadata only. write_bytes may get smaller than
|
|
* requested here.
|
|
*/
|
|
if (btrfs_check_nocow_lock(BTRFS_I(inode), pos,
|
|
&write_bytes) > 0)
|
|
only_release_metadata = true;
|
|
else
|
|
break;
|
|
}
|
|
|
|
num_pages = DIV_ROUND_UP(write_bytes + offset, PAGE_SIZE);
|
|
WARN_ON(num_pages > nrptrs);
|
|
reserve_bytes = round_up(write_bytes + sector_offset,
|
|
fs_info->sectorsize);
|
|
WARN_ON(reserve_bytes == 0);
|
|
ret = btrfs_delalloc_reserve_metadata(BTRFS_I(inode),
|
|
reserve_bytes,
|
|
reserve_bytes, false);
|
|
if (ret) {
|
|
if (!only_release_metadata)
|
|
btrfs_free_reserved_data_space(BTRFS_I(inode),
|
|
data_reserved, pos,
|
|
write_bytes);
|
|
else
|
|
btrfs_check_nocow_unlock(BTRFS_I(inode));
|
|
break;
|
|
}
|
|
|
|
release_bytes = reserve_bytes;
|
|
again:
|
|
/*
|
|
* This is going to setup the pages array with the number of
|
|
* pages we want, so we don't really need to worry about the
|
|
* contents of pages from loop to loop
|
|
*/
|
|
ret = prepare_pages(inode, pages, num_pages,
|
|
pos, write_bytes,
|
|
force_page_uptodate);
|
|
if (ret) {
|
|
btrfs_delalloc_release_extents(BTRFS_I(inode),
|
|
reserve_bytes);
|
|
break;
|
|
}
|
|
|
|
extents_locked = lock_and_cleanup_extent_if_need(
|
|
BTRFS_I(inode), pages,
|
|
num_pages, pos, write_bytes, &lockstart,
|
|
&lockend, &cached_state);
|
|
if (extents_locked < 0) {
|
|
if (extents_locked == -EAGAIN)
|
|
goto again;
|
|
btrfs_delalloc_release_extents(BTRFS_I(inode),
|
|
reserve_bytes);
|
|
ret = extents_locked;
|
|
break;
|
|
}
|
|
|
|
copied = btrfs_copy_from_user(pos, write_bytes, pages, i);
|
|
|
|
num_sectors = BTRFS_BYTES_TO_BLKS(fs_info, reserve_bytes);
|
|
dirty_sectors = round_up(copied + sector_offset,
|
|
fs_info->sectorsize);
|
|
dirty_sectors = BTRFS_BYTES_TO_BLKS(fs_info, dirty_sectors);
|
|
|
|
/*
|
|
* if we have trouble faulting in the pages, fall
|
|
* back to one page at a time
|
|
*/
|
|
if (copied < write_bytes)
|
|
nrptrs = 1;
|
|
|
|
if (copied == 0) {
|
|
force_page_uptodate = true;
|
|
dirty_sectors = 0;
|
|
dirty_pages = 0;
|
|
} else {
|
|
force_page_uptodate = false;
|
|
dirty_pages = DIV_ROUND_UP(copied + offset,
|
|
PAGE_SIZE);
|
|
}
|
|
|
|
if (num_sectors > dirty_sectors) {
|
|
/* release everything except the sectors we dirtied */
|
|
release_bytes -= dirty_sectors << fs_info->sectorsize_bits;
|
|
if (only_release_metadata) {
|
|
btrfs_delalloc_release_metadata(BTRFS_I(inode),
|
|
release_bytes, true);
|
|
} else {
|
|
u64 __pos;
|
|
|
|
__pos = round_down(pos,
|
|
fs_info->sectorsize) +
|
|
(dirty_pages << PAGE_SHIFT);
|
|
btrfs_delalloc_release_space(BTRFS_I(inode),
|
|
data_reserved, __pos,
|
|
release_bytes, true);
|
|
}
|
|
}
|
|
|
|
release_bytes = round_up(copied + sector_offset,
|
|
fs_info->sectorsize);
|
|
|
|
ret = btrfs_dirty_pages(BTRFS_I(inode), pages,
|
|
dirty_pages, pos, copied,
|
|
&cached_state, only_release_metadata);
|
|
|
|
/*
|
|
* If we have not locked the extent range, because the range's
|
|
* start offset is >= i_size, we might still have a non-NULL
|
|
* cached extent state, acquired while marking the extent range
|
|
* as delalloc through btrfs_dirty_pages(). Therefore free any
|
|
* possible cached extent state to avoid a memory leak.
|
|
*/
|
|
if (extents_locked)
|
|
unlock_extent_cached(&BTRFS_I(inode)->io_tree,
|
|
lockstart, lockend, &cached_state);
|
|
else
|
|
free_extent_state(cached_state);
|
|
|
|
btrfs_delalloc_release_extents(BTRFS_I(inode), reserve_bytes);
|
|
if (ret) {
|
|
btrfs_drop_pages(fs_info, pages, num_pages, pos, copied);
|
|
break;
|
|
}
|
|
|
|
release_bytes = 0;
|
|
if (only_release_metadata)
|
|
btrfs_check_nocow_unlock(BTRFS_I(inode));
|
|
|
|
btrfs_drop_pages(fs_info, pages, num_pages, pos, copied);
|
|
|
|
cond_resched();
|
|
|
|
balance_dirty_pages_ratelimited(inode->i_mapping);
|
|
|
|
pos += copied;
|
|
num_written += copied;
|
|
}
|
|
|
|
kfree(pages);
|
|
|
|
if (release_bytes) {
|
|
if (only_release_metadata) {
|
|
btrfs_check_nocow_unlock(BTRFS_I(inode));
|
|
btrfs_delalloc_release_metadata(BTRFS_I(inode),
|
|
release_bytes, true);
|
|
} else {
|
|
btrfs_delalloc_release_space(BTRFS_I(inode),
|
|
data_reserved,
|
|
round_down(pos, fs_info->sectorsize),
|
|
release_bytes, true);
|
|
}
|
|
}
|
|
|
|
extent_changeset_free(data_reserved);
|
|
if (num_written > 0) {
|
|
pagecache_isize_extended(inode, old_isize, iocb->ki_pos);
|
|
iocb->ki_pos += num_written;
|
|
}
|
|
out:
|
|
btrfs_inode_unlock(inode, ilock_flags);
|
|
return num_written ? num_written : ret;
|
|
}
|
|
|
|
static ssize_t check_direct_IO(struct btrfs_fs_info *fs_info,
|
|
const struct iov_iter *iter, loff_t offset)
|
|
{
|
|
const u32 blocksize_mask = fs_info->sectorsize - 1;
|
|
|
|
if (offset & blocksize_mask)
|
|
return -EINVAL;
|
|
|
|
if (iov_iter_alignment(iter) & blocksize_mask)
|
|
return -EINVAL;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static ssize_t btrfs_direct_write(struct kiocb *iocb, struct iov_iter *from)
|
|
{
|
|
struct file *file = iocb->ki_filp;
|
|
struct inode *inode = file_inode(file);
|
|
struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);
|
|
loff_t pos;
|
|
ssize_t written = 0;
|
|
ssize_t written_buffered;
|
|
size_t prev_left = 0;
|
|
loff_t endbyte;
|
|
ssize_t err;
|
|
unsigned int ilock_flags = 0;
|
|
|
|
if (iocb->ki_flags & IOCB_NOWAIT)
|
|
ilock_flags |= BTRFS_ILOCK_TRY;
|
|
|
|
/* If the write DIO is within EOF, use a shared lock */
|
|
if (iocb->ki_pos + iov_iter_count(from) <= i_size_read(inode))
|
|
ilock_flags |= BTRFS_ILOCK_SHARED;
|
|
|
|
relock:
|
|
err = btrfs_inode_lock(inode, ilock_flags);
|
|
if (err < 0)
|
|
return err;
|
|
|
|
err = generic_write_checks(iocb, from);
|
|
if (err <= 0) {
|
|
btrfs_inode_unlock(inode, ilock_flags);
|
|
return err;
|
|
}
|
|
|
|
err = btrfs_write_check(iocb, from, err);
|
|
if (err < 0) {
|
|
btrfs_inode_unlock(inode, ilock_flags);
|
|
goto out;
|
|
}
|
|
|
|
pos = iocb->ki_pos;
|
|
/*
|
|
* Re-check since file size may have changed just before taking the
|
|
* lock or pos may have changed because of O_APPEND in generic_write_check()
|
|
*/
|
|
if ((ilock_flags & BTRFS_ILOCK_SHARED) &&
|
|
pos + iov_iter_count(from) > i_size_read(inode)) {
|
|
btrfs_inode_unlock(inode, ilock_flags);
|
|
ilock_flags &= ~BTRFS_ILOCK_SHARED;
|
|
goto relock;
|
|
}
|
|
|
|
if (check_direct_IO(fs_info, from, pos)) {
|
|
btrfs_inode_unlock(inode, ilock_flags);
|
|
goto buffered;
|
|
}
|
|
|
|
/*
|
|
* The iov_iter can be mapped to the same file range we are writing to.
|
|
* If that's the case, then we will deadlock in the iomap code, because
|
|
* it first calls our callback btrfs_dio_iomap_begin(), which will create
|
|
* an ordered extent, and after that it will fault in the pages that the
|
|
* iov_iter refers to. During the fault in we end up in the readahead
|
|
* pages code (starting at btrfs_readahead()), which will lock the range,
|
|
* find that ordered extent and then wait for it to complete (at
|
|
* btrfs_lock_and_flush_ordered_range()), resulting in a deadlock since
|
|
* obviously the ordered extent can never complete as we didn't submit
|
|
* yet the respective bio(s). This always happens when the buffer is
|
|
* memory mapped to the same file range, since the iomap DIO code always
|
|
* invalidates pages in the target file range (after starting and waiting
|
|
* for any writeback).
|
|
*
|
|
* So here we disable page faults in the iov_iter and then retry if we
|
|
* got -EFAULT, faulting in the pages before the retry.
|
|
*/
|
|
again:
|
|
from->nofault = true;
|
|
err = btrfs_dio_rw(iocb, from, written);
|
|
from->nofault = false;
|
|
|
|
/* No increment (+=) because iomap returns a cumulative value. */
|
|
if (err > 0)
|
|
written = err;
|
|
|
|
if (iov_iter_count(from) > 0 && (err == -EFAULT || err > 0)) {
|
|
const size_t left = iov_iter_count(from);
|
|
/*
|
|
* We have more data left to write. Try to fault in as many as
|
|
* possible of the remainder pages and retry. We do this without
|
|
* releasing and locking again the inode, to prevent races with
|
|
* truncate.
|
|
*
|
|
* Also, in case the iov refers to pages in the file range of the
|
|
* file we want to write to (due to a mmap), we could enter an
|
|
* infinite loop if we retry after faulting the pages in, since
|
|
* iomap will invalidate any pages in the range early on, before
|
|
* it tries to fault in the pages of the iov. So we keep track of
|
|
* how much was left of iov in the previous EFAULT and fallback
|
|
* to buffered IO in case we haven't made any progress.
|
|
*/
|
|
if (left == prev_left) {
|
|
err = -ENOTBLK;
|
|
} else {
|
|
fault_in_iov_iter_readable(from, left);
|
|
prev_left = left;
|
|
goto again;
|
|
}
|
|
}
|
|
|
|
btrfs_inode_unlock(inode, ilock_flags);
|
|
|
|
/*
|
|
* If 'err' is -ENOTBLK or we have not written all data, then it means
|
|
* we must fallback to buffered IO.
|
|
*/
|
|
if ((err < 0 && err != -ENOTBLK) || !iov_iter_count(from))
|
|
goto out;
|
|
|
|
buffered:
|
|
/*
|
|
* If we are in a NOWAIT context, then return -EAGAIN to signal the caller
|
|
* it must retry the operation in a context where blocking is acceptable,
|
|
* since we currently don't have NOWAIT semantics support for buffered IO
|
|
* and may block there for many reasons (reserving space for example).
|
|
*/
|
|
if (iocb->ki_flags & IOCB_NOWAIT) {
|
|
err = -EAGAIN;
|
|
goto out;
|
|
}
|
|
|
|
pos = iocb->ki_pos;
|
|
written_buffered = btrfs_buffered_write(iocb, from);
|
|
if (written_buffered < 0) {
|
|
err = written_buffered;
|
|
goto out;
|
|
}
|
|
/*
|
|
* Ensure all data is persisted. We want the next direct IO read to be
|
|
* able to read what was just written.
|
|
*/
|
|
endbyte = pos + written_buffered - 1;
|
|
err = btrfs_fdatawrite_range(inode, pos, endbyte);
|
|
if (err)
|
|
goto out;
|
|
err = filemap_fdatawait_range(inode->i_mapping, pos, endbyte);
|
|
if (err)
|
|
goto out;
|
|
written += written_buffered;
|
|
iocb->ki_pos = pos + written_buffered;
|
|
invalidate_mapping_pages(file->f_mapping, pos >> PAGE_SHIFT,
|
|
endbyte >> PAGE_SHIFT);
|
|
out:
|
|
return err < 0 ? err : written;
|
|
}
|
|
|
|
static ssize_t btrfs_encoded_write(struct kiocb *iocb, struct iov_iter *from,
|
|
const struct btrfs_ioctl_encoded_io_args *encoded)
|
|
{
|
|
struct file *file = iocb->ki_filp;
|
|
struct inode *inode = file_inode(file);
|
|
loff_t count;
|
|
ssize_t ret;
|
|
|
|
btrfs_inode_lock(inode, 0);
|
|
count = encoded->len;
|
|
ret = generic_write_checks_count(iocb, &count);
|
|
if (ret == 0 && count != encoded->len) {
|
|
/*
|
|
* The write got truncated by generic_write_checks_count(). We
|
|
* can't do a partial encoded write.
|
|
*/
|
|
ret = -EFBIG;
|
|
}
|
|
if (ret || encoded->len == 0)
|
|
goto out;
|
|
|
|
ret = btrfs_write_check(iocb, from, encoded->len);
|
|
if (ret < 0)
|
|
goto out;
|
|
|
|
ret = btrfs_do_encoded_write(iocb, from, encoded);
|
|
out:
|
|
btrfs_inode_unlock(inode, 0);
|
|
return ret;
|
|
}
|
|
|
|
ssize_t btrfs_do_write_iter(struct kiocb *iocb, struct iov_iter *from,
|
|
const struct btrfs_ioctl_encoded_io_args *encoded)
|
|
{
|
|
struct file *file = iocb->ki_filp;
|
|
struct btrfs_inode *inode = BTRFS_I(file_inode(file));
|
|
ssize_t num_written, num_sync;
|
|
const bool sync = iocb_is_dsync(iocb);
|
|
|
|
/*
|
|
* If the fs flips readonly due to some impossible error, although we
|
|
* have opened a file as writable, we have to stop this write operation
|
|
* to ensure consistency.
|
|
*/
|
|
if (BTRFS_FS_ERROR(inode->root->fs_info))
|
|
return -EROFS;
|
|
|
|
if ((iocb->ki_flags & IOCB_NOWAIT) && !(iocb->ki_flags & IOCB_DIRECT))
|
|
return -EOPNOTSUPP;
|
|
|
|
if (sync)
|
|
atomic_inc(&inode->sync_writers);
|
|
|
|
if (encoded) {
|
|
num_written = btrfs_encoded_write(iocb, from, encoded);
|
|
num_sync = encoded->len;
|
|
} else if (iocb->ki_flags & IOCB_DIRECT) {
|
|
num_written = btrfs_direct_write(iocb, from);
|
|
num_sync = num_written;
|
|
} else {
|
|
num_written = btrfs_buffered_write(iocb, from);
|
|
num_sync = num_written;
|
|
}
|
|
|
|
btrfs_set_inode_last_sub_trans(inode);
|
|
|
|
if (num_sync > 0) {
|
|
num_sync = generic_write_sync(iocb, num_sync);
|
|
if (num_sync < 0)
|
|
num_written = num_sync;
|
|
}
|
|
|
|
if (sync)
|
|
atomic_dec(&inode->sync_writers);
|
|
|
|
current->backing_dev_info = NULL;
|
|
return num_written;
|
|
}
|
|
|
|
static ssize_t btrfs_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
|
|
{
|
|
return btrfs_do_write_iter(iocb, from, NULL);
|
|
}
|
|
|
|
int btrfs_release_file(struct inode *inode, struct file *filp)
|
|
{
|
|
struct btrfs_file_private *private = filp->private_data;
|
|
|
|
if (private && private->filldir_buf)
|
|
kfree(private->filldir_buf);
|
|
kfree(private);
|
|
filp->private_data = NULL;
|
|
|
|
/*
|
|
* Set by setattr when we are about to truncate a file from a non-zero
|
|
* size to a zero size. This tries to flush down new bytes that may
|
|
* have been written if the application were using truncate to replace
|
|
* a file in place.
|
|
*/
|
|
if (test_and_clear_bit(BTRFS_INODE_FLUSH_ON_CLOSE,
|
|
&BTRFS_I(inode)->runtime_flags))
|
|
filemap_flush(inode->i_mapping);
|
|
return 0;
|
|
}
|
|
|
|
static int start_ordered_ops(struct inode *inode, loff_t start, loff_t end)
|
|
{
|
|
int ret;
|
|
struct blk_plug plug;
|
|
|
|
/*
|
|
* This is only called in fsync, which would do synchronous writes, so
|
|
* a plug can merge adjacent IOs as much as possible. Esp. in case of
|
|
* multiple disks using raid profile, a large IO can be split to
|
|
* several segments of stripe length (currently 64K).
|
|
*/
|
|
blk_start_plug(&plug);
|
|
atomic_inc(&BTRFS_I(inode)->sync_writers);
|
|
ret = btrfs_fdatawrite_range(inode, start, end);
|
|
atomic_dec(&BTRFS_I(inode)->sync_writers);
|
|
blk_finish_plug(&plug);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static inline bool skip_inode_logging(const struct btrfs_log_ctx *ctx)
|
|
{
|
|
struct btrfs_inode *inode = BTRFS_I(ctx->inode);
|
|
struct btrfs_fs_info *fs_info = inode->root->fs_info;
|
|
|
|
if (btrfs_inode_in_log(inode, fs_info->generation) &&
|
|
list_empty(&ctx->ordered_extents))
|
|
return true;
|
|
|
|
/*
|
|
* If we are doing a fast fsync we can not bail out if the inode's
|
|
* last_trans is <= then the last committed transaction, because we only
|
|
* update the last_trans of the inode during ordered extent completion,
|
|
* and for a fast fsync we don't wait for that, we only wait for the
|
|
* writeback to complete.
|
|
*/
|
|
if (inode->last_trans <= fs_info->last_trans_committed &&
|
|
(test_bit(BTRFS_INODE_NEEDS_FULL_SYNC, &inode->runtime_flags) ||
|
|
list_empty(&ctx->ordered_extents)))
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
/*
|
|
* fsync call for both files and directories. This logs the inode into
|
|
* the tree log instead of forcing full commits whenever possible.
|
|
*
|
|
* It needs to call filemap_fdatawait so that all ordered extent updates are
|
|
* in the metadata btree are up to date for copying to the log.
|
|
*
|
|
* It drops the inode mutex before doing the tree log commit. This is an
|
|
* important optimization for directories because holding the mutex prevents
|
|
* new operations on the dir while we write to disk.
|
|
*/
|
|
int btrfs_sync_file(struct file *file, loff_t start, loff_t end, int datasync)
|
|
{
|
|
struct dentry *dentry = file_dentry(file);
|
|
struct inode *inode = d_inode(dentry);
|
|
struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);
|
|
struct btrfs_root *root = BTRFS_I(inode)->root;
|
|
struct btrfs_trans_handle *trans;
|
|
struct btrfs_log_ctx ctx;
|
|
int ret = 0, err;
|
|
u64 len;
|
|
bool full_sync;
|
|
|
|
trace_btrfs_sync_file(file, datasync);
|
|
|
|
btrfs_init_log_ctx(&ctx, inode);
|
|
|
|
/*
|
|
* Always set the range to a full range, otherwise we can get into
|
|
* several problems, from missing file extent items to represent holes
|
|
* when not using the NO_HOLES feature, to log tree corruption due to
|
|
* races between hole detection during logging and completion of ordered
|
|
* extents outside the range, to missing checksums due to ordered extents
|
|
* for which we flushed only a subset of their pages.
|
|
*/
|
|
start = 0;
|
|
end = LLONG_MAX;
|
|
len = (u64)LLONG_MAX + 1;
|
|
|
|
/*
|
|
* We write the dirty pages in the range and wait until they complete
|
|
* out of the ->i_mutex. If so, we can flush the dirty pages by
|
|
* multi-task, and make the performance up. See
|
|
* btrfs_wait_ordered_range for an explanation of the ASYNC check.
|
|
*/
|
|
ret = start_ordered_ops(inode, start, end);
|
|
if (ret)
|
|
goto out;
|
|
|
|
btrfs_inode_lock(inode, BTRFS_ILOCK_MMAP);
|
|
|
|
atomic_inc(&root->log_batch);
|
|
|
|
/*
|
|
* Always check for the full sync flag while holding the inode's lock,
|
|
* to avoid races with other tasks. The flag must be either set all the
|
|
* time during logging or always off all the time while logging.
|
|
*/
|
|
full_sync = test_bit(BTRFS_INODE_NEEDS_FULL_SYNC,
|
|
&BTRFS_I(inode)->runtime_flags);
|
|
|
|
/*
|
|
* Before we acquired the inode's lock and the mmap lock, someone may
|
|
* have dirtied more pages in the target range. We need to make sure
|
|
* that writeback for any such pages does not start while we are logging
|
|
* the inode, because if it does, any of the following might happen when
|
|
* we are not doing a full inode sync:
|
|
*
|
|
* 1) We log an extent after its writeback finishes but before its
|
|
* checksums are added to the csum tree, leading to -EIO errors
|
|
* when attempting to read the extent after a log replay.
|
|
*
|
|
* 2) We can end up logging an extent before its writeback finishes.
|
|
* Therefore after the log replay we will have a file extent item
|
|
* pointing to an unwritten extent (and no data checksums as well).
|
|
*
|
|
* So trigger writeback for any eventual new dirty pages and then we
|
|
* wait for all ordered extents to complete below.
|
|
*/
|
|
ret = start_ordered_ops(inode, start, end);
|
|
if (ret) {
|
|
btrfs_inode_unlock(inode, BTRFS_ILOCK_MMAP);
|
|
goto out;
|
|
}
|
|
|
|
/*
|
|
* We have to do this here to avoid the priority inversion of waiting on
|
|
* IO of a lower priority task while holding a transaction open.
|
|
*
|
|
* For a full fsync we wait for the ordered extents to complete while
|
|
* for a fast fsync we wait just for writeback to complete, and then
|
|
* attach the ordered extents to the transaction so that a transaction
|
|
* commit waits for their completion, to avoid data loss if we fsync,
|
|
* the current transaction commits before the ordered extents complete
|
|
* and a power failure happens right after that.
|
|
*
|
|
* For zoned filesystem, if a write IO uses a ZONE_APPEND command, the
|
|
* logical address recorded in the ordered extent may change. We need
|
|
* to wait for the IO to stabilize the logical address.
|
|
*/
|
|
if (full_sync || btrfs_is_zoned(fs_info)) {
|
|
ret = btrfs_wait_ordered_range(inode, start, len);
|
|
} else {
|
|
/*
|
|
* Get our ordered extents as soon as possible to avoid doing
|
|
* checksum lookups in the csum tree, and use instead the
|
|
* checksums attached to the ordered extents.
|
|
*/
|
|
btrfs_get_ordered_extents_for_logging(BTRFS_I(inode),
|
|
&ctx.ordered_extents);
|
|
ret = filemap_fdatawait_range(inode->i_mapping, start, end);
|
|
}
|
|
|
|
if (ret)
|
|
goto out_release_extents;
|
|
|
|
atomic_inc(&root->log_batch);
|
|
|
|
smp_mb();
|
|
if (skip_inode_logging(&ctx)) {
|
|
/*
|
|
* We've had everything committed since the last time we were
|
|
* modified so clear this flag in case it was set for whatever
|
|
* reason, it's no longer relevant.
|
|
*/
|
|
clear_bit(BTRFS_INODE_NEEDS_FULL_SYNC,
|
|
&BTRFS_I(inode)->runtime_flags);
|
|
/*
|
|
* An ordered extent might have started before and completed
|
|
* already with io errors, in which case the inode was not
|
|
* updated and we end up here. So check the inode's mapping
|
|
* for any errors that might have happened since we last
|
|
* checked called fsync.
|
|
*/
|
|
ret = filemap_check_wb_err(inode->i_mapping, file->f_wb_err);
|
|
goto out_release_extents;
|
|
}
|
|
|
|
/*
|
|
* We use start here because we will need to wait on the IO to complete
|
|
* in btrfs_sync_log, which could require joining a transaction (for
|
|
* example checking cross references in the nocow path). If we use join
|
|
* here we could get into a situation where we're waiting on IO to
|
|
* happen that is blocked on a transaction trying to commit. With start
|
|
* we inc the extwriter counter, so we wait for all extwriters to exit
|
|
* before we start blocking joiners. This comment is to keep somebody
|
|
* from thinking they are super smart and changing this to
|
|
* btrfs_join_transaction *cough*Josef*cough*.
|
|
*/
|
|
trans = btrfs_start_transaction(root, 0);
|
|
if (IS_ERR(trans)) {
|
|
ret = PTR_ERR(trans);
|
|
goto out_release_extents;
|
|
}
|
|
trans->in_fsync = true;
|
|
|
|
ret = btrfs_log_dentry_safe(trans, dentry, &ctx);
|
|
btrfs_release_log_ctx_extents(&ctx);
|
|
if (ret < 0) {
|
|
/* Fallthrough and commit/free transaction. */
|
|
ret = BTRFS_LOG_FORCE_COMMIT;
|
|
}
|
|
|
|
/* we've logged all the items and now have a consistent
|
|
* version of the file in the log. It is possible that
|
|
* someone will come in and modify the file, but that's
|
|
* fine because the log is consistent on disk, and we
|
|
* have references to all of the file's extents
|
|
*
|
|
* It is possible that someone will come in and log the
|
|
* file again, but that will end up using the synchronization
|
|
* inside btrfs_sync_log to keep things safe.
|
|
*/
|
|
btrfs_inode_unlock(inode, BTRFS_ILOCK_MMAP);
|
|
|
|
if (ret == BTRFS_NO_LOG_SYNC) {
|
|
ret = btrfs_end_transaction(trans);
|
|
goto out;
|
|
}
|
|
|
|
/* We successfully logged the inode, attempt to sync the log. */
|
|
if (!ret) {
|
|
ret = btrfs_sync_log(trans, root, &ctx);
|
|
if (!ret) {
|
|
ret = btrfs_end_transaction(trans);
|
|
goto out;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* At this point we need to commit the transaction because we had
|
|
* btrfs_need_log_full_commit() or some other error.
|
|
*
|
|
* If we didn't do a full sync we have to stop the trans handle, wait on
|
|
* the ordered extents, start it again and commit the transaction. If
|
|
* we attempt to wait on the ordered extents here we could deadlock with
|
|
* something like fallocate() that is holding the extent lock trying to
|
|
* start a transaction while some other thread is trying to commit the
|
|
* transaction while we (fsync) are currently holding the transaction
|
|
* open.
|
|
*/
|
|
if (!full_sync) {
|
|
ret = btrfs_end_transaction(trans);
|
|
if (ret)
|
|
goto out;
|
|
ret = btrfs_wait_ordered_range(inode, start, len);
|
|
if (ret)
|
|
goto out;
|
|
|
|
/*
|
|
* This is safe to use here because we're only interested in
|
|
* making sure the transaction that had the ordered extents is
|
|
* committed. We aren't waiting on anything past this point,
|
|
* we're purely getting the transaction and committing it.
|
|
*/
|
|
trans = btrfs_attach_transaction_barrier(root);
|
|
if (IS_ERR(trans)) {
|
|
ret = PTR_ERR(trans);
|
|
|
|
/*
|
|
* We committed the transaction and there's no currently
|
|
* running transaction, this means everything we care
|
|
* about made it to disk and we are done.
|
|
*/
|
|
if (ret == -ENOENT)
|
|
ret = 0;
|
|
goto out;
|
|
}
|
|
}
|
|
|
|
ret = btrfs_commit_transaction(trans);
|
|
out:
|
|
ASSERT(list_empty(&ctx.list));
|
|
err = file_check_and_advance_wb_err(file);
|
|
if (!ret)
|
|
ret = err;
|
|
return ret > 0 ? -EIO : ret;
|
|
|
|
out_release_extents:
|
|
btrfs_release_log_ctx_extents(&ctx);
|
|
btrfs_inode_unlock(inode, BTRFS_ILOCK_MMAP);
|
|
goto out;
|
|
}
|
|
|
|
static const struct vm_operations_struct btrfs_file_vm_ops = {
|
|
.fault = filemap_fault,
|
|
.map_pages = filemap_map_pages,
|
|
.page_mkwrite = btrfs_page_mkwrite,
|
|
};
|
|
|
|
static int btrfs_file_mmap(struct file *filp, struct vm_area_struct *vma)
|
|
{
|
|
struct address_space *mapping = filp->f_mapping;
|
|
|
|
if (!mapping->a_ops->read_folio)
|
|
return -ENOEXEC;
|
|
|
|
file_accessed(filp);
|
|
vma->vm_ops = &btrfs_file_vm_ops;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int hole_mergeable(struct btrfs_inode *inode, struct extent_buffer *leaf,
|
|
int slot, u64 start, u64 end)
|
|
{
|
|
struct btrfs_file_extent_item *fi;
|
|
struct btrfs_key key;
|
|
|
|
if (slot < 0 || slot >= btrfs_header_nritems(leaf))
|
|
return 0;
|
|
|
|
btrfs_item_key_to_cpu(leaf, &key, slot);
|
|
if (key.objectid != btrfs_ino(inode) ||
|
|
key.type != BTRFS_EXTENT_DATA_KEY)
|
|
return 0;
|
|
|
|
fi = btrfs_item_ptr(leaf, slot, struct btrfs_file_extent_item);
|
|
|
|
if (btrfs_file_extent_type(leaf, fi) != BTRFS_FILE_EXTENT_REG)
|
|
return 0;
|
|
|
|
if (btrfs_file_extent_disk_bytenr(leaf, fi))
|
|
return 0;
|
|
|
|
if (key.offset == end)
|
|
return 1;
|
|
if (key.offset + btrfs_file_extent_num_bytes(leaf, fi) == start)
|
|
return 1;
|
|
return 0;
|
|
}
|
|
|
|
static int fill_holes(struct btrfs_trans_handle *trans,
|
|
struct btrfs_inode *inode,
|
|
struct btrfs_path *path, u64 offset, u64 end)
|
|
{
|
|
struct btrfs_fs_info *fs_info = trans->fs_info;
|
|
struct btrfs_root *root = inode->root;
|
|
struct extent_buffer *leaf;
|
|
struct btrfs_file_extent_item *fi;
|
|
struct extent_map *hole_em;
|
|
struct extent_map_tree *em_tree = &inode->extent_tree;
|
|
struct btrfs_key key;
|
|
int ret;
|
|
|
|
if (btrfs_fs_incompat(fs_info, NO_HOLES))
|
|
goto out;
|
|
|
|
key.objectid = btrfs_ino(inode);
|
|
key.type = BTRFS_EXTENT_DATA_KEY;
|
|
key.offset = offset;
|
|
|
|
ret = btrfs_search_slot(trans, root, &key, path, 0, 1);
|
|
if (ret <= 0) {
|
|
/*
|
|
* We should have dropped this offset, so if we find it then
|
|
* something has gone horribly wrong.
|
|
*/
|
|
if (ret == 0)
|
|
ret = -EINVAL;
|
|
return ret;
|
|
}
|
|
|
|
leaf = path->nodes[0];
|
|
if (hole_mergeable(inode, leaf, path->slots[0] - 1, offset, end)) {
|
|
u64 num_bytes;
|
|
|
|
path->slots[0]--;
|
|
fi = btrfs_item_ptr(leaf, path->slots[0],
|
|
struct btrfs_file_extent_item);
|
|
num_bytes = btrfs_file_extent_num_bytes(leaf, fi) +
|
|
end - offset;
|
|
btrfs_set_file_extent_num_bytes(leaf, fi, num_bytes);
|
|
btrfs_set_file_extent_ram_bytes(leaf, fi, num_bytes);
|
|
btrfs_set_file_extent_offset(leaf, fi, 0);
|
|
btrfs_mark_buffer_dirty(leaf);
|
|
goto out;
|
|
}
|
|
|
|
if (hole_mergeable(inode, leaf, path->slots[0], offset, end)) {
|
|
u64 num_bytes;
|
|
|
|
key.offset = offset;
|
|
btrfs_set_item_key_safe(fs_info, path, &key);
|
|
fi = btrfs_item_ptr(leaf, path->slots[0],
|
|
struct btrfs_file_extent_item);
|
|
num_bytes = btrfs_file_extent_num_bytes(leaf, fi) + end -
|
|
offset;
|
|
btrfs_set_file_extent_num_bytes(leaf, fi, num_bytes);
|
|
btrfs_set_file_extent_ram_bytes(leaf, fi, num_bytes);
|
|
btrfs_set_file_extent_offset(leaf, fi, 0);
|
|
btrfs_mark_buffer_dirty(leaf);
|
|
goto out;
|
|
}
|
|
btrfs_release_path(path);
|
|
|
|
ret = btrfs_insert_file_extent(trans, root, btrfs_ino(inode),
|
|
offset, 0, 0, end - offset, 0, end - offset, 0, 0, 0);
|
|
if (ret)
|
|
return ret;
|
|
|
|
out:
|
|
btrfs_release_path(path);
|
|
|
|
hole_em = alloc_extent_map();
|
|
if (!hole_em) {
|
|
btrfs_drop_extent_cache(inode, offset, end - 1, 0);
|
|
btrfs_set_inode_full_sync(inode);
|
|
} else {
|
|
hole_em->start = offset;
|
|
hole_em->len = end - offset;
|
|
hole_em->ram_bytes = hole_em->len;
|
|
hole_em->orig_start = offset;
|
|
|
|
hole_em->block_start = EXTENT_MAP_HOLE;
|
|
hole_em->block_len = 0;
|
|
hole_em->orig_block_len = 0;
|
|
hole_em->compress_type = BTRFS_COMPRESS_NONE;
|
|
hole_em->generation = trans->transid;
|
|
|
|
do {
|
|
btrfs_drop_extent_cache(inode, offset, end - 1, 0);
|
|
write_lock(&em_tree->lock);
|
|
ret = add_extent_mapping(em_tree, hole_em, 1);
|
|
write_unlock(&em_tree->lock);
|
|
} while (ret == -EEXIST);
|
|
free_extent_map(hole_em);
|
|
if (ret)
|
|
btrfs_set_inode_full_sync(inode);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Find a hole extent on given inode and change start/len to the end of hole
|
|
* extent.(hole/vacuum extent whose em->start <= start &&
|
|
* em->start + em->len > start)
|
|
* When a hole extent is found, return 1 and modify start/len.
|
|
*/
|
|
static int find_first_non_hole(struct btrfs_inode *inode, u64 *start, u64 *len)
|
|
{
|
|
struct btrfs_fs_info *fs_info = inode->root->fs_info;
|
|
struct extent_map *em;
|
|
int ret = 0;
|
|
|
|
em = btrfs_get_extent(inode, NULL, 0,
|
|
round_down(*start, fs_info->sectorsize),
|
|
round_up(*len, fs_info->sectorsize));
|
|
if (IS_ERR(em))
|
|
return PTR_ERR(em);
|
|
|
|
/* Hole or vacuum extent(only exists in no-hole mode) */
|
|
if (em->block_start == EXTENT_MAP_HOLE) {
|
|
ret = 1;
|
|
*len = em->start + em->len > *start + *len ?
|
|
0 : *start + *len - em->start - em->len;
|
|
*start = em->start + em->len;
|
|
}
|
|
free_extent_map(em);
|
|
return ret;
|
|
}
|
|
|
|
static void btrfs_punch_hole_lock_range(struct inode *inode,
|
|
const u64 lockstart,
|
|
const u64 lockend,
|
|
struct extent_state **cached_state)
|
|
{
|
|
/*
|
|
* For subpage case, if the range is not at page boundary, we could
|
|
* have pages at the leading/tailing part of the range.
|
|
* This could lead to dead loop since filemap_range_has_page()
|
|
* will always return true.
|
|
* So here we need to do extra page alignment for
|
|
* filemap_range_has_page().
|
|
*/
|
|
const u64 page_lockstart = round_up(lockstart, PAGE_SIZE);
|
|
const u64 page_lockend = round_down(lockend + 1, PAGE_SIZE) - 1;
|
|
|
|
while (1) {
|
|
truncate_pagecache_range(inode, lockstart, lockend);
|
|
|
|
lock_extent_bits(&BTRFS_I(inode)->io_tree, lockstart, lockend,
|
|
cached_state);
|
|
/*
|
|
* We can't have ordered extents in the range, nor dirty/writeback
|
|
* pages, because we have locked the inode's VFS lock in exclusive
|
|
* mode, we have locked the inode's i_mmap_lock in exclusive mode,
|
|
* we have flushed all delalloc in the range and we have waited
|
|
* for any ordered extents in the range to complete.
|
|
* We can race with anyone reading pages from this range, so after
|
|
* locking the range check if we have pages in the range, and if
|
|
* we do, unlock the range and retry.
|
|
*/
|
|
if (!filemap_range_has_page(inode->i_mapping, page_lockstart,
|
|
page_lockend))
|
|
break;
|
|
|
|
unlock_extent_cached(&BTRFS_I(inode)->io_tree, lockstart,
|
|
lockend, cached_state);
|
|
}
|
|
|
|
btrfs_assert_inode_range_clean(BTRFS_I(inode), lockstart, lockend);
|
|
}
|
|
|
|
static int btrfs_insert_replace_extent(struct btrfs_trans_handle *trans,
|
|
struct btrfs_inode *inode,
|
|
struct btrfs_path *path,
|
|
struct btrfs_replace_extent_info *extent_info,
|
|
const u64 replace_len,
|
|
const u64 bytes_to_drop)
|
|
{
|
|
struct btrfs_fs_info *fs_info = trans->fs_info;
|
|
struct btrfs_root *root = inode->root;
|
|
struct btrfs_file_extent_item *extent;
|
|
struct extent_buffer *leaf;
|
|
struct btrfs_key key;
|
|
int slot;
|
|
struct btrfs_ref ref = { 0 };
|
|
int ret;
|
|
|
|
if (replace_len == 0)
|
|
return 0;
|
|
|
|
if (extent_info->disk_offset == 0 &&
|
|
btrfs_fs_incompat(fs_info, NO_HOLES)) {
|
|
btrfs_update_inode_bytes(inode, 0, bytes_to_drop);
|
|
return 0;
|
|
}
|
|
|
|
key.objectid = btrfs_ino(inode);
|
|
key.type = BTRFS_EXTENT_DATA_KEY;
|
|
key.offset = extent_info->file_offset;
|
|
ret = btrfs_insert_empty_item(trans, root, path, &key,
|
|
sizeof(struct btrfs_file_extent_item));
|
|
if (ret)
|
|
return ret;
|
|
leaf = path->nodes[0];
|
|
slot = path->slots[0];
|
|
write_extent_buffer(leaf, extent_info->extent_buf,
|
|
btrfs_item_ptr_offset(leaf, slot),
|
|
sizeof(struct btrfs_file_extent_item));
|
|
extent = btrfs_item_ptr(leaf, slot, struct btrfs_file_extent_item);
|
|
ASSERT(btrfs_file_extent_type(leaf, extent) != BTRFS_FILE_EXTENT_INLINE);
|
|
btrfs_set_file_extent_offset(leaf, extent, extent_info->data_offset);
|
|
btrfs_set_file_extent_num_bytes(leaf, extent, replace_len);
|
|
if (extent_info->is_new_extent)
|
|
btrfs_set_file_extent_generation(leaf, extent, trans->transid);
|
|
btrfs_mark_buffer_dirty(leaf);
|
|
btrfs_release_path(path);
|
|
|
|
ret = btrfs_inode_set_file_extent_range(inode, extent_info->file_offset,
|
|
replace_len);
|
|
if (ret)
|
|
return ret;
|
|
|
|
/* If it's a hole, nothing more needs to be done. */
|
|
if (extent_info->disk_offset == 0) {
|
|
btrfs_update_inode_bytes(inode, 0, bytes_to_drop);
|
|
return 0;
|
|
}
|
|
|
|
btrfs_update_inode_bytes(inode, replace_len, bytes_to_drop);
|
|
|
|
if (extent_info->is_new_extent && extent_info->insertions == 0) {
|
|
key.objectid = extent_info->disk_offset;
|
|
key.type = BTRFS_EXTENT_ITEM_KEY;
|
|
key.offset = extent_info->disk_len;
|
|
ret = btrfs_alloc_reserved_file_extent(trans, root,
|
|
btrfs_ino(inode),
|
|
extent_info->file_offset,
|
|
extent_info->qgroup_reserved,
|
|
&key);
|
|
} else {
|
|
u64 ref_offset;
|
|
|
|
btrfs_init_generic_ref(&ref, BTRFS_ADD_DELAYED_REF,
|
|
extent_info->disk_offset,
|
|
extent_info->disk_len, 0);
|
|
ref_offset = extent_info->file_offset - extent_info->data_offset;
|
|
btrfs_init_data_ref(&ref, root->root_key.objectid,
|
|
btrfs_ino(inode), ref_offset, 0, false);
|
|
ret = btrfs_inc_extent_ref(trans, &ref);
|
|
}
|
|
|
|
extent_info->insertions++;
|
|
|
|
return ret;
|
|
}
|
|
|
|
/*
|
|
* The respective range must have been previously locked, as well as the inode.
|
|
* The end offset is inclusive (last byte of the range).
|
|
* @extent_info is NULL for fallocate's hole punching and non-NULL when replacing
|
|
* the file range with an extent.
|
|
* When not punching a hole, we don't want to end up in a state where we dropped
|
|
* extents without inserting a new one, so we must abort the transaction to avoid
|
|
* a corruption.
|
|
*/
|
|
int btrfs_replace_file_extents(struct btrfs_inode *inode,
|
|
struct btrfs_path *path, const u64 start,
|
|
const u64 end,
|
|
struct btrfs_replace_extent_info *extent_info,
|
|
struct btrfs_trans_handle **trans_out)
|
|
{
|
|
struct btrfs_drop_extents_args drop_args = { 0 };
|
|
struct btrfs_root *root = inode->root;
|
|
struct btrfs_fs_info *fs_info = root->fs_info;
|
|
u64 min_size = btrfs_calc_insert_metadata_size(fs_info, 1);
|
|
u64 ino_size = round_up(inode->vfs_inode.i_size, fs_info->sectorsize);
|
|
struct btrfs_trans_handle *trans = NULL;
|
|
struct btrfs_block_rsv *rsv;
|
|
unsigned int rsv_count;
|
|
u64 cur_offset;
|
|
u64 len = end - start;
|
|
int ret = 0;
|
|
|
|
if (end <= start)
|
|
return -EINVAL;
|
|
|
|
rsv = btrfs_alloc_block_rsv(fs_info, BTRFS_BLOCK_RSV_TEMP);
|
|
if (!rsv) {
|
|
ret = -ENOMEM;
|
|
goto out;
|
|
}
|
|
rsv->size = btrfs_calc_insert_metadata_size(fs_info, 1);
|
|
rsv->failfast = true;
|
|
|
|
/*
|
|
* 1 - update the inode
|
|
* 1 - removing the extents in the range
|
|
* 1 - adding the hole extent if no_holes isn't set or if we are
|
|
* replacing the range with a new extent
|
|
*/
|
|
if (!btrfs_fs_incompat(fs_info, NO_HOLES) || extent_info)
|
|
rsv_count = 3;
|
|
else
|
|
rsv_count = 2;
|
|
|
|
trans = btrfs_start_transaction(root, rsv_count);
|
|
if (IS_ERR(trans)) {
|
|
ret = PTR_ERR(trans);
|
|
trans = NULL;
|
|
goto out_free;
|
|
}
|
|
|
|
ret = btrfs_block_rsv_migrate(&fs_info->trans_block_rsv, rsv,
|
|
min_size, false);
|
|
if (WARN_ON(ret))
|
|
goto out_trans;
|
|
trans->block_rsv = rsv;
|
|
|
|
cur_offset = start;
|
|
drop_args.path = path;
|
|
drop_args.end = end + 1;
|
|
drop_args.drop_cache = true;
|
|
while (cur_offset < end) {
|
|
drop_args.start = cur_offset;
|
|
ret = btrfs_drop_extents(trans, root, inode, &drop_args);
|
|
/* If we are punching a hole decrement the inode's byte count */
|
|
if (!extent_info)
|
|
btrfs_update_inode_bytes(inode, 0,
|
|
drop_args.bytes_found);
|
|
if (ret != -ENOSPC) {
|
|
/*
|
|
* The only time we don't want to abort is if we are
|
|
* attempting to clone a partial inline extent, in which
|
|
* case we'll get EOPNOTSUPP. However if we aren't
|
|
* clone we need to abort no matter what, because if we
|
|
* got EOPNOTSUPP via prealloc then we messed up and
|
|
* need to abort.
|
|
*/
|
|
if (ret &&
|
|
(ret != -EOPNOTSUPP ||
|
|
(extent_info && extent_info->is_new_extent)))
|
|
btrfs_abort_transaction(trans, ret);
|
|
break;
|
|
}
|
|
|
|
trans->block_rsv = &fs_info->trans_block_rsv;
|
|
|
|
if (!extent_info && cur_offset < drop_args.drop_end &&
|
|
cur_offset < ino_size) {
|
|
ret = fill_holes(trans, inode, path, cur_offset,
|
|
drop_args.drop_end);
|
|
if (ret) {
|
|
/*
|
|
* If we failed then we didn't insert our hole
|
|
* entries for the area we dropped, so now the
|
|
* fs is corrupted, so we must abort the
|
|
* transaction.
|
|
*/
|
|
btrfs_abort_transaction(trans, ret);
|
|
break;
|
|
}
|
|
} else if (!extent_info && cur_offset < drop_args.drop_end) {
|
|
/*
|
|
* We are past the i_size here, but since we didn't
|
|
* insert holes we need to clear the mapped area so we
|
|
* know to not set disk_i_size in this area until a new
|
|
* file extent is inserted here.
|
|
*/
|
|
ret = btrfs_inode_clear_file_extent_range(inode,
|
|
cur_offset,
|
|
drop_args.drop_end - cur_offset);
|
|
if (ret) {
|
|
/*
|
|
* We couldn't clear our area, so we could
|
|
* presumably adjust up and corrupt the fs, so
|
|
* we need to abort.
|
|
*/
|
|
btrfs_abort_transaction(trans, ret);
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (extent_info &&
|
|
drop_args.drop_end > extent_info->file_offset) {
|
|
u64 replace_len = drop_args.drop_end -
|
|
extent_info->file_offset;
|
|
|
|
ret = btrfs_insert_replace_extent(trans, inode, path,
|
|
extent_info, replace_len,
|
|
drop_args.bytes_found);
|
|
if (ret) {
|
|
btrfs_abort_transaction(trans, ret);
|
|
break;
|
|
}
|
|
extent_info->data_len -= replace_len;
|
|
extent_info->data_offset += replace_len;
|
|
extent_info->file_offset += replace_len;
|
|
}
|
|
|
|
/*
|
|
* We are releasing our handle on the transaction, balance the
|
|
* dirty pages of the btree inode and flush delayed items, and
|
|
* then get a new transaction handle, which may now point to a
|
|
* new transaction in case someone else may have committed the
|
|
* transaction we used to replace/drop file extent items. So
|
|
* bump the inode's iversion and update mtime and ctime except
|
|
* if we are called from a dedupe context. This is because a
|
|
* power failure/crash may happen after the transaction is
|
|
* committed and before we finish replacing/dropping all the
|
|
* file extent items we need.
|
|
*/
|
|
inode_inc_iversion(&inode->vfs_inode);
|
|
|
|
if (!extent_info || extent_info->update_times) {
|
|
inode->vfs_inode.i_mtime = current_time(&inode->vfs_inode);
|
|
inode->vfs_inode.i_ctime = inode->vfs_inode.i_mtime;
|
|
}
|
|
|
|
ret = btrfs_update_inode(trans, root, inode);
|
|
if (ret)
|
|
break;
|
|
|
|
btrfs_end_transaction(trans);
|
|
btrfs_btree_balance_dirty(fs_info);
|
|
|
|
trans = btrfs_start_transaction(root, rsv_count);
|
|
if (IS_ERR(trans)) {
|
|
ret = PTR_ERR(trans);
|
|
trans = NULL;
|
|
break;
|
|
}
|
|
|
|
ret = btrfs_block_rsv_migrate(&fs_info->trans_block_rsv,
|
|
rsv, min_size, false);
|
|
if (WARN_ON(ret))
|
|
break;
|
|
trans->block_rsv = rsv;
|
|
|
|
cur_offset = drop_args.drop_end;
|
|
len = end - cur_offset;
|
|
if (!extent_info && len) {
|
|
ret = find_first_non_hole(inode, &cur_offset, &len);
|
|
if (unlikely(ret < 0))
|
|
break;
|
|
if (ret && !len) {
|
|
ret = 0;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* If we were cloning, force the next fsync to be a full one since we
|
|
* we replaced (or just dropped in the case of cloning holes when
|
|
* NO_HOLES is enabled) file extent items and did not setup new extent
|
|
* maps for the replacement extents (or holes).
|
|
*/
|
|
if (extent_info && !extent_info->is_new_extent)
|
|
btrfs_set_inode_full_sync(inode);
|
|
|
|
if (ret)
|
|
goto out_trans;
|
|
|
|
trans->block_rsv = &fs_info->trans_block_rsv;
|
|
/*
|
|
* If we are using the NO_HOLES feature we might have had already an
|
|
* hole that overlaps a part of the region [lockstart, lockend] and
|
|
* ends at (or beyond) lockend. Since we have no file extent items to
|
|
* represent holes, drop_end can be less than lockend and so we must
|
|
* make sure we have an extent map representing the existing hole (the
|
|
* call to __btrfs_drop_extents() might have dropped the existing extent
|
|
* map representing the existing hole), otherwise the fast fsync path
|
|
* will not record the existence of the hole region
|
|
* [existing_hole_start, lockend].
|
|
*/
|
|
if (drop_args.drop_end <= end)
|
|
drop_args.drop_end = end + 1;
|
|
/*
|
|
* Don't insert file hole extent item if it's for a range beyond eof
|
|
* (because it's useless) or if it represents a 0 bytes range (when
|
|
* cur_offset == drop_end).
|
|
*/
|
|
if (!extent_info && cur_offset < ino_size &&
|
|
cur_offset < drop_args.drop_end) {
|
|
ret = fill_holes(trans, inode, path, cur_offset,
|
|
drop_args.drop_end);
|
|
if (ret) {
|
|
/* Same comment as above. */
|
|
btrfs_abort_transaction(trans, ret);
|
|
goto out_trans;
|
|
}
|
|
} else if (!extent_info && cur_offset < drop_args.drop_end) {
|
|
/* See the comment in the loop above for the reasoning here. */
|
|
ret = btrfs_inode_clear_file_extent_range(inode, cur_offset,
|
|
drop_args.drop_end - cur_offset);
|
|
if (ret) {
|
|
btrfs_abort_transaction(trans, ret);
|
|
goto out_trans;
|
|
}
|
|
|
|
}
|
|
if (extent_info) {
|
|
ret = btrfs_insert_replace_extent(trans, inode, path,
|
|
extent_info, extent_info->data_len,
|
|
drop_args.bytes_found);
|
|
if (ret) {
|
|
btrfs_abort_transaction(trans, ret);
|
|
goto out_trans;
|
|
}
|
|
}
|
|
|
|
out_trans:
|
|
if (!trans)
|
|
goto out_free;
|
|
|
|
trans->block_rsv = &fs_info->trans_block_rsv;
|
|
if (ret)
|
|
btrfs_end_transaction(trans);
|
|
else
|
|
*trans_out = trans;
|
|
out_free:
|
|
btrfs_free_block_rsv(fs_info, rsv);
|
|
out:
|
|
return ret;
|
|
}
|
|
|
|
static int btrfs_punch_hole(struct file *file, loff_t offset, loff_t len)
|
|
{
|
|
struct inode *inode = file_inode(file);
|
|
struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);
|
|
struct btrfs_root *root = BTRFS_I(inode)->root;
|
|
struct extent_state *cached_state = NULL;
|
|
struct btrfs_path *path;
|
|
struct btrfs_trans_handle *trans = NULL;
|
|
u64 lockstart;
|
|
u64 lockend;
|
|
u64 tail_start;
|
|
u64 tail_len;
|
|
u64 orig_start = offset;
|
|
int ret = 0;
|
|
bool same_block;
|
|
u64 ino_size;
|
|
bool truncated_block = false;
|
|
bool updated_inode = false;
|
|
|
|
btrfs_inode_lock(inode, BTRFS_ILOCK_MMAP);
|
|
|
|
ret = btrfs_wait_ordered_range(inode, offset, len);
|
|
if (ret)
|
|
goto out_only_mutex;
|
|
|
|
ino_size = round_up(inode->i_size, fs_info->sectorsize);
|
|
ret = find_first_non_hole(BTRFS_I(inode), &offset, &len);
|
|
if (ret < 0)
|
|
goto out_only_mutex;
|
|
if (ret && !len) {
|
|
/* Already in a large hole */
|
|
ret = 0;
|
|
goto out_only_mutex;
|
|
}
|
|
|
|
ret = file_modified(file);
|
|
if (ret)
|
|
goto out_only_mutex;
|
|
|
|
lockstart = round_up(offset, btrfs_inode_sectorsize(BTRFS_I(inode)));
|
|
lockend = round_down(offset + len,
|
|
btrfs_inode_sectorsize(BTRFS_I(inode))) - 1;
|
|
same_block = (BTRFS_BYTES_TO_BLKS(fs_info, offset))
|
|
== (BTRFS_BYTES_TO_BLKS(fs_info, offset + len - 1));
|
|
/*
|
|
* We needn't truncate any block which is beyond the end of the file
|
|
* because we are sure there is no data there.
|
|
*/
|
|
/*
|
|
* Only do this if we are in the same block and we aren't doing the
|
|
* entire block.
|
|
*/
|
|
if (same_block && len < fs_info->sectorsize) {
|
|
if (offset < ino_size) {
|
|
truncated_block = true;
|
|
ret = btrfs_truncate_block(BTRFS_I(inode), offset, len,
|
|
0);
|
|
} else {
|
|
ret = 0;
|
|
}
|
|
goto out_only_mutex;
|
|
}
|
|
|
|
/* zero back part of the first block */
|
|
if (offset < ino_size) {
|
|
truncated_block = true;
|
|
ret = btrfs_truncate_block(BTRFS_I(inode), offset, 0, 0);
|
|
if (ret) {
|
|
btrfs_inode_unlock(inode, BTRFS_ILOCK_MMAP);
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
/* Check the aligned pages after the first unaligned page,
|
|
* if offset != orig_start, which means the first unaligned page
|
|
* including several following pages are already in holes,
|
|
* the extra check can be skipped */
|
|
if (offset == orig_start) {
|
|
/* after truncate page, check hole again */
|
|
len = offset + len - lockstart;
|
|
offset = lockstart;
|
|
ret = find_first_non_hole(BTRFS_I(inode), &offset, &len);
|
|
if (ret < 0)
|
|
goto out_only_mutex;
|
|
if (ret && !len) {
|
|
ret = 0;
|
|
goto out_only_mutex;
|
|
}
|
|
lockstart = offset;
|
|
}
|
|
|
|
/* Check the tail unaligned part is in a hole */
|
|
tail_start = lockend + 1;
|
|
tail_len = offset + len - tail_start;
|
|
if (tail_len) {
|
|
ret = find_first_non_hole(BTRFS_I(inode), &tail_start, &tail_len);
|
|
if (unlikely(ret < 0))
|
|
goto out_only_mutex;
|
|
if (!ret) {
|
|
/* zero the front end of the last page */
|
|
if (tail_start + tail_len < ino_size) {
|
|
truncated_block = true;
|
|
ret = btrfs_truncate_block(BTRFS_I(inode),
|
|
tail_start + tail_len,
|
|
0, 1);
|
|
if (ret)
|
|
goto out_only_mutex;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (lockend < lockstart) {
|
|
ret = 0;
|
|
goto out_only_mutex;
|
|
}
|
|
|
|
btrfs_punch_hole_lock_range(inode, lockstart, lockend, &cached_state);
|
|
|
|
path = btrfs_alloc_path();
|
|
if (!path) {
|
|
ret = -ENOMEM;
|
|
goto out;
|
|
}
|
|
|
|
ret = btrfs_replace_file_extents(BTRFS_I(inode), path, lockstart,
|
|
lockend, NULL, &trans);
|
|
btrfs_free_path(path);
|
|
if (ret)
|
|
goto out;
|
|
|
|
ASSERT(trans != NULL);
|
|
inode_inc_iversion(inode);
|
|
inode->i_mtime = current_time(inode);
|
|
inode->i_ctime = inode->i_mtime;
|
|
ret = btrfs_update_inode(trans, root, BTRFS_I(inode));
|
|
updated_inode = true;
|
|
btrfs_end_transaction(trans);
|
|
btrfs_btree_balance_dirty(fs_info);
|
|
out:
|
|
unlock_extent_cached(&BTRFS_I(inode)->io_tree, lockstart, lockend,
|
|
&cached_state);
|
|
out_only_mutex:
|
|
if (!updated_inode && truncated_block && !ret) {
|
|
/*
|
|
* If we only end up zeroing part of a page, we still need to
|
|
* update the inode item, so that all the time fields are
|
|
* updated as well as the necessary btrfs inode in memory fields
|
|
* for detecting, at fsync time, if the inode isn't yet in the
|
|
* log tree or it's there but not up to date.
|
|
*/
|
|
struct timespec64 now = current_time(inode);
|
|
|
|
inode_inc_iversion(inode);
|
|
inode->i_mtime = now;
|
|
inode->i_ctime = now;
|
|
trans = btrfs_start_transaction(root, 1);
|
|
if (IS_ERR(trans)) {
|
|
ret = PTR_ERR(trans);
|
|
} else {
|
|
int ret2;
|
|
|
|
ret = btrfs_update_inode(trans, root, BTRFS_I(inode));
|
|
ret2 = btrfs_end_transaction(trans);
|
|
if (!ret)
|
|
ret = ret2;
|
|
}
|
|
}
|
|
btrfs_inode_unlock(inode, BTRFS_ILOCK_MMAP);
|
|
return ret;
|
|
}
|
|
|
|
/* Helper structure to record which range is already reserved */
|
|
struct falloc_range {
|
|
struct list_head list;
|
|
u64 start;
|
|
u64 len;
|
|
};
|
|
|
|
/*
|
|
* Helper function to add falloc range
|
|
*
|
|
* Caller should have locked the larger range of extent containing
|
|
* [start, len)
|
|
*/
|
|
static int add_falloc_range(struct list_head *head, u64 start, u64 len)
|
|
{
|
|
struct falloc_range *range = NULL;
|
|
|
|
if (!list_empty(head)) {
|
|
/*
|
|
* As fallocate iterates by bytenr order, we only need to check
|
|
* the last range.
|
|
*/
|
|
range = list_last_entry(head, struct falloc_range, list);
|
|
if (range->start + range->len == start) {
|
|
range->len += len;
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
range = kmalloc(sizeof(*range), GFP_KERNEL);
|
|
if (!range)
|
|
return -ENOMEM;
|
|
range->start = start;
|
|
range->len = len;
|
|
list_add_tail(&range->list, head);
|
|
return 0;
|
|
}
|
|
|
|
static int btrfs_fallocate_update_isize(struct inode *inode,
|
|
const u64 end,
|
|
const int mode)
|
|
{
|
|
struct btrfs_trans_handle *trans;
|
|
struct btrfs_root *root = BTRFS_I(inode)->root;
|
|
int ret;
|
|
int ret2;
|
|
|
|
if (mode & FALLOC_FL_KEEP_SIZE || end <= i_size_read(inode))
|
|
return 0;
|
|
|
|
trans = btrfs_start_transaction(root, 1);
|
|
if (IS_ERR(trans))
|
|
return PTR_ERR(trans);
|
|
|
|
inode->i_ctime = current_time(inode);
|
|
i_size_write(inode, end);
|
|
btrfs_inode_safe_disk_i_size_write(BTRFS_I(inode), 0);
|
|
ret = btrfs_update_inode(trans, root, BTRFS_I(inode));
|
|
ret2 = btrfs_end_transaction(trans);
|
|
|
|
return ret ? ret : ret2;
|
|
}
|
|
|
|
enum {
|
|
RANGE_BOUNDARY_WRITTEN_EXTENT,
|
|
RANGE_BOUNDARY_PREALLOC_EXTENT,
|
|
RANGE_BOUNDARY_HOLE,
|
|
};
|
|
|
|
static int btrfs_zero_range_check_range_boundary(struct btrfs_inode *inode,
|
|
u64 offset)
|
|
{
|
|
const u64 sectorsize = btrfs_inode_sectorsize(inode);
|
|
struct extent_map *em;
|
|
int ret;
|
|
|
|
offset = round_down(offset, sectorsize);
|
|
em = btrfs_get_extent(inode, NULL, 0, offset, sectorsize);
|
|
if (IS_ERR(em))
|
|
return PTR_ERR(em);
|
|
|
|
if (em->block_start == EXTENT_MAP_HOLE)
|
|
ret = RANGE_BOUNDARY_HOLE;
|
|
else if (test_bit(EXTENT_FLAG_PREALLOC, &em->flags))
|
|
ret = RANGE_BOUNDARY_PREALLOC_EXTENT;
|
|
else
|
|
ret = RANGE_BOUNDARY_WRITTEN_EXTENT;
|
|
|
|
free_extent_map(em);
|
|
return ret;
|
|
}
|
|
|
|
static int btrfs_zero_range(struct inode *inode,
|
|
loff_t offset,
|
|
loff_t len,
|
|
const int mode)
|
|
{
|
|
struct btrfs_fs_info *fs_info = BTRFS_I(inode)->root->fs_info;
|
|
struct extent_map *em;
|
|
struct extent_changeset *data_reserved = NULL;
|
|
int ret;
|
|
u64 alloc_hint = 0;
|
|
const u64 sectorsize = btrfs_inode_sectorsize(BTRFS_I(inode));
|
|
u64 alloc_start = round_down(offset, sectorsize);
|
|
u64 alloc_end = round_up(offset + len, sectorsize);
|
|
u64 bytes_to_reserve = 0;
|
|
bool space_reserved = false;
|
|
|
|
em = btrfs_get_extent(BTRFS_I(inode), NULL, 0, alloc_start,
|
|
alloc_end - alloc_start);
|
|
if (IS_ERR(em)) {
|
|
ret = PTR_ERR(em);
|
|
goto out;
|
|
}
|
|
|
|
/*
|
|
* Avoid hole punching and extent allocation for some cases. More cases
|
|
* could be considered, but these are unlikely common and we keep things
|
|
* as simple as possible for now. Also, intentionally, if the target
|
|
* range contains one or more prealloc extents together with regular
|
|
* extents and holes, we drop all the existing extents and allocate a
|
|
* new prealloc extent, so that we get a larger contiguous disk extent.
|
|
*/
|
|
if (em->start <= alloc_start &&
|
|
test_bit(EXTENT_FLAG_PREALLOC, &em->flags)) {
|
|
const u64 em_end = em->start + em->len;
|
|
|
|
if (em_end >= offset + len) {
|
|
/*
|
|
* The whole range is already a prealloc extent,
|
|
* do nothing except updating the inode's i_size if
|
|
* needed.
|
|
*/
|
|
free_extent_map(em);
|
|
ret = btrfs_fallocate_update_isize(inode, offset + len,
|
|
mode);
|
|
goto out;
|
|
}
|
|
/*
|
|
* Part of the range is already a prealloc extent, so operate
|
|
* only on the remaining part of the range.
|
|
*/
|
|
alloc_start = em_end;
|
|
ASSERT(IS_ALIGNED(alloc_start, sectorsize));
|
|
len = offset + len - alloc_start;
|
|
offset = alloc_start;
|
|
alloc_hint = em->block_start + em->len;
|
|
}
|
|
free_extent_map(em);
|
|
|
|
if (BTRFS_BYTES_TO_BLKS(fs_info, offset) ==
|
|
BTRFS_BYTES_TO_BLKS(fs_info, offset + len - 1)) {
|
|
em = btrfs_get_extent(BTRFS_I(inode), NULL, 0, alloc_start,
|
|
sectorsize);
|
|
if (IS_ERR(em)) {
|
|
ret = PTR_ERR(em);
|
|
goto out;
|
|
}
|
|
|
|
if (test_bit(EXTENT_FLAG_PREALLOC, &em->flags)) {
|
|
free_extent_map(em);
|
|
ret = btrfs_fallocate_update_isize(inode, offset + len,
|
|
mode);
|
|
goto out;
|
|
}
|
|
if (len < sectorsize && em->block_start != EXTENT_MAP_HOLE) {
|
|
free_extent_map(em);
|
|
ret = btrfs_truncate_block(BTRFS_I(inode), offset, len,
|
|
0);
|
|
if (!ret)
|
|
ret = btrfs_fallocate_update_isize(inode,
|
|
offset + len,
|
|
mode);
|
|
return ret;
|
|
}
|
|
free_extent_map(em);
|
|
alloc_start = round_down(offset, sectorsize);
|
|
alloc_end = alloc_start + sectorsize;
|
|
goto reserve_space;
|
|
}
|
|
|
|
alloc_start = round_up(offset, sectorsize);
|
|
alloc_end = round_down(offset + len, sectorsize);
|
|
|
|
/*
|
|
* For unaligned ranges, check the pages at the boundaries, they might
|
|
* map to an extent, in which case we need to partially zero them, or
|
|
* they might map to a hole, in which case we need our allocation range
|
|
* to cover them.
|
|
*/
|
|
if (!IS_ALIGNED(offset, sectorsize)) {
|
|
ret = btrfs_zero_range_check_range_boundary(BTRFS_I(inode),
|
|
offset);
|
|
if (ret < 0)
|
|
goto out;
|
|
if (ret == RANGE_BOUNDARY_HOLE) {
|
|
alloc_start = round_down(offset, sectorsize);
|
|
ret = 0;
|
|
} else if (ret == RANGE_BOUNDARY_WRITTEN_EXTENT) {
|
|
ret = btrfs_truncate_block(BTRFS_I(inode), offset, 0, 0);
|
|
if (ret)
|
|
goto out;
|
|
} else {
|
|
ret = 0;
|
|
}
|
|
}
|
|
|
|
if (!IS_ALIGNED(offset + len, sectorsize)) {
|
|
ret = btrfs_zero_range_check_range_boundary(BTRFS_I(inode),
|
|
offset + len);
|
|
if (ret < 0)
|
|
goto out;
|
|
if (ret == RANGE_BOUNDARY_HOLE) {
|
|
alloc_end = round_up(offset + len, sectorsize);
|
|
ret = 0;
|
|
} else if (ret == RANGE_BOUNDARY_WRITTEN_EXTENT) {
|
|
ret = btrfs_truncate_block(BTRFS_I(inode), offset + len,
|
|
0, 1);
|
|
if (ret)
|
|
goto out;
|
|
} else {
|
|
ret = 0;
|
|
}
|
|
}
|
|
|
|
reserve_space:
|
|
if (alloc_start < alloc_end) {
|
|
struct extent_state *cached_state = NULL;
|
|
const u64 lockstart = alloc_start;
|
|
const u64 lockend = alloc_end - 1;
|
|
|
|
bytes_to_reserve = alloc_end - alloc_start;
|
|
ret = btrfs_alloc_data_chunk_ondemand(BTRFS_I(inode),
|
|
bytes_to_reserve);
|
|
if (ret < 0)
|
|
goto out;
|
|
space_reserved = true;
|
|
btrfs_punch_hole_lock_range(inode, lockstart, lockend,
|
|
&cached_state);
|
|
ret = btrfs_qgroup_reserve_data(BTRFS_I(inode), &data_reserved,
|
|
alloc_start, bytes_to_reserve);
|
|
if (ret) {
|
|
unlock_extent_cached(&BTRFS_I(inode)->io_tree, lockstart,
|
|
lockend, &cached_state);
|
|
goto out;
|
|
}
|
|
ret = btrfs_prealloc_file_range(inode, mode, alloc_start,
|
|
alloc_end - alloc_start,
|
|
i_blocksize(inode),
|
|
offset + len, &alloc_hint);
|
|
unlock_extent_cached(&BTRFS_I(inode)->io_tree, lockstart,
|
|
lockend, &cached_state);
|
|
/* btrfs_prealloc_file_range releases reserved space on error */
|
|
if (ret) {
|
|
space_reserved = false;
|
|
goto out;
|
|
}
|
|
}
|
|
ret = btrfs_fallocate_update_isize(inode, offset + len, mode);
|
|
out:
|
|
if (ret && space_reserved)
|
|
btrfs_free_reserved_data_space(BTRFS_I(inode), data_reserved,
|
|
alloc_start, bytes_to_reserve);
|
|
extent_changeset_free(data_reserved);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static long btrfs_fallocate(struct file *file, int mode,
|
|
loff_t offset, loff_t len)
|
|
{
|
|
struct inode *inode = file_inode(file);
|
|
struct extent_state *cached_state = NULL;
|
|
struct extent_changeset *data_reserved = NULL;
|
|
struct falloc_range *range;
|
|
struct falloc_range *tmp;
|
|
struct list_head reserve_list;
|
|
u64 cur_offset;
|
|
u64 last_byte;
|
|
u64 alloc_start;
|
|
u64 alloc_end;
|
|
u64 alloc_hint = 0;
|
|
u64 locked_end;
|
|
u64 actual_end = 0;
|
|
u64 data_space_needed = 0;
|
|
u64 data_space_reserved = 0;
|
|
u64 qgroup_reserved = 0;
|
|
struct extent_map *em;
|
|
int blocksize = btrfs_inode_sectorsize(BTRFS_I(inode));
|
|
int ret;
|
|
|
|
/* Do not allow fallocate in ZONED mode */
|
|
if (btrfs_is_zoned(btrfs_sb(inode->i_sb)))
|
|
return -EOPNOTSUPP;
|
|
|
|
alloc_start = round_down(offset, blocksize);
|
|
alloc_end = round_up(offset + len, blocksize);
|
|
cur_offset = alloc_start;
|
|
|
|
/* Make sure we aren't being give some crap mode */
|
|
if (mode & ~(FALLOC_FL_KEEP_SIZE | FALLOC_FL_PUNCH_HOLE |
|
|
FALLOC_FL_ZERO_RANGE))
|
|
return -EOPNOTSUPP;
|
|
|
|
if (mode & FALLOC_FL_PUNCH_HOLE)
|
|
return btrfs_punch_hole(file, offset, len);
|
|
|
|
btrfs_inode_lock(inode, BTRFS_ILOCK_MMAP);
|
|
|
|
if (!(mode & FALLOC_FL_KEEP_SIZE) && offset + len > inode->i_size) {
|
|
ret = inode_newsize_ok(inode, offset + len);
|
|
if (ret)
|
|
goto out;
|
|
}
|
|
|
|
ret = file_modified(file);
|
|
if (ret)
|
|
goto out;
|
|
|
|
/*
|
|
* TODO: Move these two operations after we have checked
|
|
* accurate reserved space, or fallocate can still fail but
|
|
* with page truncated or size expanded.
|
|
*
|
|
* But that's a minor problem and won't do much harm BTW.
|
|
*/
|
|
if (alloc_start > inode->i_size) {
|
|
ret = btrfs_cont_expand(BTRFS_I(inode), i_size_read(inode),
|
|
alloc_start);
|
|
if (ret)
|
|
goto out;
|
|
} else if (offset + len > inode->i_size) {
|
|
/*
|
|
* If we are fallocating from the end of the file onward we
|
|
* need to zero out the end of the block if i_size lands in the
|
|
* middle of a block.
|
|
*/
|
|
ret = btrfs_truncate_block(BTRFS_I(inode), inode->i_size, 0, 0);
|
|
if (ret)
|
|
goto out;
|
|
}
|
|
|
|
/*
|
|
* We have locked the inode at the VFS level (in exclusive mode) and we
|
|
* have locked the i_mmap_lock lock (in exclusive mode). Now before
|
|
* locking the file range, flush all dealloc in the range and wait for
|
|
* all ordered extents in the range to complete. After this we can lock
|
|
* the file range and, due to the previous locking we did, we know there
|
|
* can't be more delalloc or ordered extents in the range.
|
|
*/
|
|
ret = btrfs_wait_ordered_range(inode, alloc_start,
|
|
alloc_end - alloc_start);
|
|
if (ret)
|
|
goto out;
|
|
|
|
if (mode & FALLOC_FL_ZERO_RANGE) {
|
|
ret = btrfs_zero_range(inode, offset, len, mode);
|
|
btrfs_inode_unlock(inode, BTRFS_ILOCK_MMAP);
|
|
return ret;
|
|
}
|
|
|
|
locked_end = alloc_end - 1;
|
|
lock_extent_bits(&BTRFS_I(inode)->io_tree, alloc_start, locked_end,
|
|
&cached_state);
|
|
|
|
btrfs_assert_inode_range_clean(BTRFS_I(inode), alloc_start, locked_end);
|
|
|
|
/* First, check if we exceed the qgroup limit */
|
|
INIT_LIST_HEAD(&reserve_list);
|
|
while (cur_offset < alloc_end) {
|
|
em = btrfs_get_extent(BTRFS_I(inode), NULL, 0, cur_offset,
|
|
alloc_end - cur_offset);
|
|
if (IS_ERR(em)) {
|
|
ret = PTR_ERR(em);
|
|
break;
|
|
}
|
|
last_byte = min(extent_map_end(em), alloc_end);
|
|
actual_end = min_t(u64, extent_map_end(em), offset + len);
|
|
last_byte = ALIGN(last_byte, blocksize);
|
|
if (em->block_start == EXTENT_MAP_HOLE ||
|
|
(cur_offset >= inode->i_size &&
|
|
!test_bit(EXTENT_FLAG_PREALLOC, &em->flags))) {
|
|
const u64 range_len = last_byte - cur_offset;
|
|
|
|
ret = add_falloc_range(&reserve_list, cur_offset, range_len);
|
|
if (ret < 0) {
|
|
free_extent_map(em);
|
|
break;
|
|
}
|
|
ret = btrfs_qgroup_reserve_data(BTRFS_I(inode),
|
|
&data_reserved, cur_offset, range_len);
|
|
if (ret < 0) {
|
|
free_extent_map(em);
|
|
break;
|
|
}
|
|
qgroup_reserved += range_len;
|
|
data_space_needed += range_len;
|
|
}
|
|
free_extent_map(em);
|
|
cur_offset = last_byte;
|
|
}
|
|
|
|
if (!ret && data_space_needed > 0) {
|
|
/*
|
|
* We are safe to reserve space here as we can't have delalloc
|
|
* in the range, see above.
|
|
*/
|
|
ret = btrfs_alloc_data_chunk_ondemand(BTRFS_I(inode),
|
|
data_space_needed);
|
|
if (!ret)
|
|
data_space_reserved = data_space_needed;
|
|
}
|
|
|
|
/*
|
|
* If ret is still 0, means we're OK to fallocate.
|
|
* Or just cleanup the list and exit.
|
|
*/
|
|
list_for_each_entry_safe(range, tmp, &reserve_list, list) {
|
|
if (!ret) {
|
|
ret = btrfs_prealloc_file_range(inode, mode,
|
|
range->start,
|
|
range->len, i_blocksize(inode),
|
|
offset + len, &alloc_hint);
|
|
/*
|
|
* btrfs_prealloc_file_range() releases space even
|
|
* if it returns an error.
|
|
*/
|
|
data_space_reserved -= range->len;
|
|
qgroup_reserved -= range->len;
|
|
} else if (data_space_reserved > 0) {
|
|
btrfs_free_reserved_data_space(BTRFS_I(inode),
|
|
data_reserved, range->start,
|
|
range->len);
|
|
data_space_reserved -= range->len;
|
|
qgroup_reserved -= range->len;
|
|
} else if (qgroup_reserved > 0) {
|
|
btrfs_qgroup_free_data(BTRFS_I(inode), data_reserved,
|
|
range->start, range->len);
|
|
qgroup_reserved -= range->len;
|
|
}
|
|
list_del(&range->list);
|
|
kfree(range);
|
|
}
|
|
if (ret < 0)
|
|
goto out_unlock;
|
|
|
|
/*
|
|
* We didn't need to allocate any more space, but we still extended the
|
|
* size of the file so we need to update i_size and the inode item.
|
|
*/
|
|
ret = btrfs_fallocate_update_isize(inode, actual_end, mode);
|
|
out_unlock:
|
|
unlock_extent_cached(&BTRFS_I(inode)->io_tree, alloc_start, locked_end,
|
|
&cached_state);
|
|
out:
|
|
btrfs_inode_unlock(inode, BTRFS_ILOCK_MMAP);
|
|
extent_changeset_free(data_reserved);
|
|
return ret;
|
|
}
|
|
|
|
static loff_t find_desired_extent(struct btrfs_inode *inode, loff_t offset,
|
|
int whence)
|
|
{
|
|
struct btrfs_fs_info *fs_info = inode->root->fs_info;
|
|
struct extent_map *em = NULL;
|
|
struct extent_state *cached_state = NULL;
|
|
loff_t i_size = inode->vfs_inode.i_size;
|
|
u64 lockstart;
|
|
u64 lockend;
|
|
u64 start;
|
|
u64 len;
|
|
int ret = 0;
|
|
|
|
if (i_size == 0 || offset >= i_size)
|
|
return -ENXIO;
|
|
|
|
/*
|
|
* offset can be negative, in this case we start finding DATA/HOLE from
|
|
* the very start of the file.
|
|
*/
|
|
start = max_t(loff_t, 0, offset);
|
|
|
|
lockstart = round_down(start, fs_info->sectorsize);
|
|
lockend = round_up(i_size, fs_info->sectorsize);
|
|
if (lockend <= lockstart)
|
|
lockend = lockstart + fs_info->sectorsize;
|
|
lockend--;
|
|
len = lockend - lockstart + 1;
|
|
|
|
lock_extent_bits(&inode->io_tree, lockstart, lockend, &cached_state);
|
|
|
|
while (start < i_size) {
|
|
em = btrfs_get_extent_fiemap(inode, start, len);
|
|
if (IS_ERR(em)) {
|
|
ret = PTR_ERR(em);
|
|
em = NULL;
|
|
break;
|
|
}
|
|
|
|
if (whence == SEEK_HOLE &&
|
|
(em->block_start == EXTENT_MAP_HOLE ||
|
|
test_bit(EXTENT_FLAG_PREALLOC, &em->flags)))
|
|
break;
|
|
else if (whence == SEEK_DATA &&
|
|
(em->block_start != EXTENT_MAP_HOLE &&
|
|
!test_bit(EXTENT_FLAG_PREALLOC, &em->flags)))
|
|
break;
|
|
|
|
start = em->start + em->len;
|
|
free_extent_map(em);
|
|
em = NULL;
|
|
cond_resched();
|
|
}
|
|
free_extent_map(em);
|
|
unlock_extent_cached(&inode->io_tree, lockstart, lockend,
|
|
&cached_state);
|
|
if (ret) {
|
|
offset = ret;
|
|
} else {
|
|
if (whence == SEEK_DATA && start >= i_size)
|
|
offset = -ENXIO;
|
|
else
|
|
offset = min_t(loff_t, start, i_size);
|
|
}
|
|
|
|
return offset;
|
|
}
|
|
|
|
static loff_t btrfs_file_llseek(struct file *file, loff_t offset, int whence)
|
|
{
|
|
struct inode *inode = file->f_mapping->host;
|
|
|
|
switch (whence) {
|
|
default:
|
|
return generic_file_llseek(file, offset, whence);
|
|
case SEEK_DATA:
|
|
case SEEK_HOLE:
|
|
btrfs_inode_lock(inode, BTRFS_ILOCK_SHARED);
|
|
offset = find_desired_extent(BTRFS_I(inode), offset, whence);
|
|
btrfs_inode_unlock(inode, BTRFS_ILOCK_SHARED);
|
|
break;
|
|
}
|
|
|
|
if (offset < 0)
|
|
return offset;
|
|
|
|
return vfs_setpos(file, offset, inode->i_sb->s_maxbytes);
|
|
}
|
|
|
|
static int btrfs_file_open(struct inode *inode, struct file *filp)
|
|
{
|
|
int ret;
|
|
|
|
filp->f_mode |= FMODE_NOWAIT | FMODE_BUF_RASYNC;
|
|
|
|
ret = fsverity_file_open(inode, filp);
|
|
if (ret)
|
|
return ret;
|
|
return generic_file_open(inode, filp);
|
|
}
|
|
|
|
static int check_direct_read(struct btrfs_fs_info *fs_info,
|
|
const struct iov_iter *iter, loff_t offset)
|
|
{
|
|
int ret;
|
|
int i, seg;
|
|
|
|
ret = check_direct_IO(fs_info, iter, offset);
|
|
if (ret < 0)
|
|
return ret;
|
|
|
|
if (!iter_is_iovec(iter))
|
|
return 0;
|
|
|
|
for (seg = 0; seg < iter->nr_segs; seg++)
|
|
for (i = seg + 1; i < iter->nr_segs; i++)
|
|
if (iter->iov[seg].iov_base == iter->iov[i].iov_base)
|
|
return -EINVAL;
|
|
return 0;
|
|
}
|
|
|
|
static ssize_t btrfs_direct_read(struct kiocb *iocb, struct iov_iter *to)
|
|
{
|
|
struct inode *inode = file_inode(iocb->ki_filp);
|
|
size_t prev_left = 0;
|
|
ssize_t read = 0;
|
|
ssize_t ret;
|
|
|
|
if (fsverity_active(inode))
|
|
return 0;
|
|
|
|
if (check_direct_read(btrfs_sb(inode->i_sb), to, iocb->ki_pos))
|
|
return 0;
|
|
|
|
btrfs_inode_lock(inode, BTRFS_ILOCK_SHARED);
|
|
again:
|
|
/*
|
|
* This is similar to what we do for direct IO writes, see the comment
|
|
* at btrfs_direct_write(), but we also disable page faults in addition
|
|
* to disabling them only at the iov_iter level. This is because when
|
|
* reading from a hole or prealloc extent, iomap calls iov_iter_zero(),
|
|
* which can still trigger page fault ins despite having set ->nofault
|
|
* to true of our 'to' iov_iter.
|
|
*
|
|
* The difference to direct IO writes is that we deadlock when trying
|
|
* to lock the extent range in the inode's tree during he page reads
|
|
* triggered by the fault in (while for writes it is due to waiting for
|
|
* our own ordered extent). This is because for direct IO reads,
|
|
* btrfs_dio_iomap_begin() returns with the extent range locked, which
|
|
* is only unlocked in the endio callback (end_bio_extent_readpage()).
|
|
*/
|
|
pagefault_disable();
|
|
to->nofault = true;
|
|
ret = btrfs_dio_rw(iocb, to, read);
|
|
to->nofault = false;
|
|
pagefault_enable();
|
|
|
|
/* No increment (+=) because iomap returns a cumulative value. */
|
|
if (ret > 0)
|
|
read = ret;
|
|
|
|
if (iov_iter_count(to) > 0 && (ret == -EFAULT || ret > 0)) {
|
|
const size_t left = iov_iter_count(to);
|
|
|
|
if (left == prev_left) {
|
|
/*
|
|
* We didn't make any progress since the last attempt,
|
|
* fallback to a buffered read for the remainder of the
|
|
* range. This is just to avoid any possibility of looping
|
|
* for too long.
|
|
*/
|
|
ret = read;
|
|
} else {
|
|
/*
|
|
* We made some progress since the last retry or this is
|
|
* the first time we are retrying. Fault in as many pages
|
|
* as possible and retry.
|
|
*/
|
|
fault_in_iov_iter_writeable(to, left);
|
|
prev_left = left;
|
|
goto again;
|
|
}
|
|
}
|
|
btrfs_inode_unlock(inode, BTRFS_ILOCK_SHARED);
|
|
return ret < 0 ? ret : read;
|
|
}
|
|
|
|
static ssize_t btrfs_file_read_iter(struct kiocb *iocb, struct iov_iter *to)
|
|
{
|
|
ssize_t ret = 0;
|
|
|
|
if (iocb->ki_flags & IOCB_DIRECT) {
|
|
ret = btrfs_direct_read(iocb, to);
|
|
if (ret < 0 || !iov_iter_count(to) ||
|
|
iocb->ki_pos >= i_size_read(file_inode(iocb->ki_filp)))
|
|
return ret;
|
|
}
|
|
|
|
return filemap_read(iocb, to, ret);
|
|
}
|
|
|
|
const struct file_operations btrfs_file_operations = {
|
|
.llseek = btrfs_file_llseek,
|
|
.read_iter = btrfs_file_read_iter,
|
|
.splice_read = generic_file_splice_read,
|
|
.write_iter = btrfs_file_write_iter,
|
|
.splice_write = iter_file_splice_write,
|
|
.mmap = btrfs_file_mmap,
|
|
.open = btrfs_file_open,
|
|
.release = btrfs_release_file,
|
|
.fsync = btrfs_sync_file,
|
|
.fallocate = btrfs_fallocate,
|
|
.unlocked_ioctl = btrfs_ioctl,
|
|
#ifdef CONFIG_COMPAT
|
|
.compat_ioctl = btrfs_compat_ioctl,
|
|
#endif
|
|
.remap_file_range = btrfs_remap_file_range,
|
|
};
|
|
|
|
void __cold btrfs_auto_defrag_exit(void)
|
|
{
|
|
kmem_cache_destroy(btrfs_inode_defrag_cachep);
|
|
}
|
|
|
|
int __init btrfs_auto_defrag_init(void)
|
|
{
|
|
btrfs_inode_defrag_cachep = kmem_cache_create("btrfs_inode_defrag",
|
|
sizeof(struct inode_defrag), 0,
|
|
SLAB_MEM_SPREAD,
|
|
NULL);
|
|
if (!btrfs_inode_defrag_cachep)
|
|
return -ENOMEM;
|
|
|
|
return 0;
|
|
}
|
|
|
|
int btrfs_fdatawrite_range(struct inode *inode, loff_t start, loff_t end)
|
|
{
|
|
int ret;
|
|
|
|
/*
|
|
* So with compression we will find and lock a dirty page and clear the
|
|
* first one as dirty, setup an async extent, and immediately return
|
|
* with the entire range locked but with nobody actually marked with
|
|
* writeback. So we can't just filemap_write_and_wait_range() and
|
|
* expect it to work since it will just kick off a thread to do the
|
|
* actual work. So we need to call filemap_fdatawrite_range _again_
|
|
* since it will wait on the page lock, which won't be unlocked until
|
|
* after the pages have been marked as writeback and so we're good to go
|
|
* from there. We have to do this otherwise we'll miss the ordered
|
|
* extents and that results in badness. Please Josef, do not think you
|
|
* know better and pull this out at some point in the future, it is
|
|
* right and you are wrong.
|
|
*/
|
|
ret = filemap_fdatawrite_range(inode->i_mapping, start, end);
|
|
if (!ret && test_bit(BTRFS_INODE_HAS_ASYNC_EXTENT,
|
|
&BTRFS_I(inode)->runtime_flags))
|
|
ret = filemap_fdatawrite_range(inode->i_mapping, start, end);
|
|
|
|
return ret;
|
|
}
|