2012-11-29 12:28:09 +08:00
|
|
|
/*
|
2012-11-02 16:10:12 +08:00
|
|
|
* fs/f2fs/data.c
|
|
|
|
|
*
|
|
|
|
|
* Copyright (c) 2012 Samsung Electronics Co., Ltd.
|
|
|
|
|
* http://www.samsung.com/
|
|
|
|
|
*
|
|
|
|
|
* This program is free software; you can redistribute it and/or modify
|
|
|
|
|
* it under the terms of the GNU General Public License version 2 as
|
|
|
|
|
* published by the Free Software Foundation.
|
|
|
|
|
*/
|
|
|
|
|
#include <linux/fs.h>
|
|
|
|
|
#include <linux/f2fs_fs.h>
|
|
|
|
|
#include <linux/buffer_head.h>
|
|
|
|
|
#include <linux/mpage.h>
|
|
|
|
|
#include <linux/writeback.h>
|
|
|
|
|
#include <linux/backing-dev.h>
|
f2fs: expose f2fs_write_cache_pages
If there are gced dirty pages and normal dirty pages in the mapping
of one inode, we might writeback them alternately with discontinuous
block address, resulting in low performance.
This patch introduces f2fs_write_cache_pages with codes copied from
write_cache_pages in mm/page-writeback.c.
In this function, we refactor flow with two steps:
1) writeback all cold type pages.
2) writeback all non-cold type pages.
By using this method, f2fs will writeback dirty pages with the same
temperature in bunch mode, it makes writeouted block being with
more continuous address, so they can be merged as much as possible
in f2fs bio cache, and also it will reduce the chance of submiting
small IO from block layer.
Test environment: 8g nokia sd card (very old sd card, but it shows
better effect when testing with this patch, and with a 32g kingston
sd card, I didn't see much more improvement).
Test step:
1. touch testfile;
2. truncate -s 512K testfile;
3. write all pages with odd index;
4. trigger gc by ioctl;
5. write all pages with even index;
6. time fsync testfile.
before:
real 0m0.402s
user 0m0.000s
sys 0m0.000s
after:
real 0m0.143s
user 0m0.004s
sys 0m0.004s
Signed-off-by: Chao Yu <chao2.yu@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2015-07-14 18:56:10 +08:00
|
|
|
#include <linux/pagevec.h>
|
2012-11-02 16:10:12 +08:00
|
|
|
#include <linux/blkdev.h>
|
|
|
|
|
#include <linux/bio.h>
|
2012-12-20 05:19:30 +08:00
|
|
|
#include <linux/prefetch.h>
|
2015-02-23 00:58:50 +08:00
|
|
|
#include <linux/uio.h>
|
2015-04-10 02:20:42 +08:00
|
|
|
#include <linux/cleancache.h>
|
2017-02-03 02:15:33 +08:00
|
|
|
#include <linux/sched/signal.h>
|
2012-11-02 16:10:12 +08:00
|
|
|
|
|
|
|
|
#include "f2fs.h"
|
|
|
|
|
#include "node.h"
|
|
|
|
|
#include "segment.h"
|
2014-12-18 12:04:08 +08:00
|
|
|
#include "trace.h"
|
2013-04-23 15:38:02 +08:00
|
|
|
#include <trace/events/f2fs.h>
|
2012-11-02 16:10:12 +08:00
|
|
|
|
f2fs: refactor read path to allow multiple postprocessing steps
Currently f2fs's ->readpage() and ->readpages() assume that either the
data undergoes no postprocessing, or decryption only. But with
fs-verity, there will be an additional authenticity verification step,
and it may be needed either by itself, or combined with decryption.
To support this, store a 'struct bio_post_read_ctx' in ->bi_private
which contains a work struct, a bitmask of postprocessing steps that are
enabled, and an indicator of the current step. The bio completion
routine, if there was no I/O error, enqueues the first postprocessing
step. When that completes, it continues to the next step. Pages that
fail any postprocessing step have PageError set. Once all steps have
completed, pages without PageError set are set Uptodate, and all pages
are unlocked.
Also replace f2fs_encrypted_file() with a new function
f2fs_post_read_required() in places like direct I/O and garbage
collection that really should be testing whether the file needs special
I/O processing, not whether it is encrypted specifically.
This may also be useful for other future f2fs features such as
compression.
Signed-off-by: Eric Biggers <ebiggers@google.com>
Reviewed-by: Chao Yu <yuchao0@huawei.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2018-04-19 02:09:48 +08:00
|
|
|
#define NUM_PREALLOC_POST_READ_CTXS 128
|
|
|
|
|
|
|
|
|
|
static struct kmem_cache *bio_post_read_ctx_cache;
|
|
|
|
|
static mempool_t *bio_post_read_ctx_pool;
|
|
|
|
|
|
f2fs: don't wait writeback for datas during checkpoint
Normally, while committing checkpoint, we will wait on all pages to be
writebacked no matter the page is data or metadata, so in scenario where
there are lots of data IO being submitted with metadata, we may suffer
long latency for waiting writeback during checkpoint.
Indeed, we only care about persistence for pages with metadata, but not
pages with data, as file system consistent are only related to metadate,
so in order to avoid encountering long latency in above scenario, let's
recognize and reference metadata in submitted IOs, wait writeback only
for metadatas.
Signed-off-by: Chao Yu <yuchao0@huawei.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2016-11-16 10:41:20 +08:00
|
|
|
static bool __is_cp_guaranteed(struct page *page)
|
|
|
|
|
{
|
|
|
|
|
struct address_space *mapping = page->mapping;
|
|
|
|
|
struct inode *inode;
|
|
|
|
|
struct f2fs_sb_info *sbi;
|
|
|
|
|
|
|
|
|
|
if (!mapping)
|
|
|
|
|
return false;
|
|
|
|
|
|
|
|
|
|
inode = mapping->host;
|
|
|
|
|
sbi = F2FS_I_SB(inode);
|
|
|
|
|
|
|
|
|
|
if (inode->i_ino == F2FS_META_INO(sbi) ||
|
|
|
|
|
inode->i_ino == F2FS_NODE_INO(sbi) ||
|
|
|
|
|
S_ISDIR(inode->i_mode) ||
|
2018-05-08 14:06:03 +08:00
|
|
|
(S_ISREG(inode->i_mode) &&
|
|
|
|
|
is_inode_flag_set(inode, FI_ATOMIC_FILE)) ||
|
f2fs: don't wait writeback for datas during checkpoint
Normally, while committing checkpoint, we will wait on all pages to be
writebacked no matter the page is data or metadata, so in scenario where
there are lots of data IO being submitted with metadata, we may suffer
long latency for waiting writeback during checkpoint.
Indeed, we only care about persistence for pages with metadata, but not
pages with data, as file system consistent are only related to metadate,
so in order to avoid encountering long latency in above scenario, let's
recognize and reference metadata in submitted IOs, wait writeback only
for metadatas.
Signed-off-by: Chao Yu <yuchao0@huawei.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2016-11-16 10:41:20 +08:00
|
|
|
is_cold_data(page))
|
|
|
|
|
return true;
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
|
f2fs: refactor read path to allow multiple postprocessing steps
Currently f2fs's ->readpage() and ->readpages() assume that either the
data undergoes no postprocessing, or decryption only. But with
fs-verity, there will be an additional authenticity verification step,
and it may be needed either by itself, or combined with decryption.
To support this, store a 'struct bio_post_read_ctx' in ->bi_private
which contains a work struct, a bitmask of postprocessing steps that are
enabled, and an indicator of the current step. The bio completion
routine, if there was no I/O error, enqueues the first postprocessing
step. When that completes, it continues to the next step. Pages that
fail any postprocessing step have PageError set. Once all steps have
completed, pages without PageError set are set Uptodate, and all pages
are unlocked.
Also replace f2fs_encrypted_file() with a new function
f2fs_post_read_required() in places like direct I/O and garbage
collection that really should be testing whether the file needs special
I/O processing, not whether it is encrypted specifically.
This may also be useful for other future f2fs features such as
compression.
Signed-off-by: Eric Biggers <ebiggers@google.com>
Reviewed-by: Chao Yu <yuchao0@huawei.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2018-04-19 02:09:48 +08:00
|
|
|
/* postprocessing steps for read bios */
|
|
|
|
|
enum bio_post_read_step {
|
|
|
|
|
STEP_INITIAL = 0,
|
|
|
|
|
STEP_DECRYPT,
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
struct bio_post_read_ctx {
|
|
|
|
|
struct bio *bio;
|
|
|
|
|
struct work_struct work;
|
|
|
|
|
unsigned int cur_step;
|
|
|
|
|
unsigned int enabled_steps;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
static void __read_end_io(struct bio *bio)
|
2013-11-30 11:51:14 +08:00
|
|
|
{
|
f2fs: refactor read path to allow multiple postprocessing steps
Currently f2fs's ->readpage() and ->readpages() assume that either the
data undergoes no postprocessing, or decryption only. But with
fs-verity, there will be an additional authenticity verification step,
and it may be needed either by itself, or combined with decryption.
To support this, store a 'struct bio_post_read_ctx' in ->bi_private
which contains a work struct, a bitmask of postprocessing steps that are
enabled, and an indicator of the current step. The bio completion
routine, if there was no I/O error, enqueues the first postprocessing
step. When that completes, it continues to the next step. Pages that
fail any postprocessing step have PageError set. Once all steps have
completed, pages without PageError set are set Uptodate, and all pages
are unlocked.
Also replace f2fs_encrypted_file() with a new function
f2fs_post_read_required() in places like direct I/O and garbage
collection that really should be testing whether the file needs special
I/O processing, not whether it is encrypted specifically.
This may also be useful for other future f2fs features such as
compression.
Signed-off-by: Eric Biggers <ebiggers@google.com>
Reviewed-by: Chao Yu <yuchao0@huawei.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2018-04-19 02:09:48 +08:00
|
|
|
struct page *page;
|
|
|
|
|
struct bio_vec *bv;
|
2014-01-31 03:19:05 +08:00
|
|
|
int i;
|
2013-11-30 11:51:14 +08:00
|
|
|
|
f2fs: refactor read path to allow multiple postprocessing steps
Currently f2fs's ->readpage() and ->readpages() assume that either the
data undergoes no postprocessing, or decryption only. But with
fs-verity, there will be an additional authenticity verification step,
and it may be needed either by itself, or combined with decryption.
To support this, store a 'struct bio_post_read_ctx' in ->bi_private
which contains a work struct, a bitmask of postprocessing steps that are
enabled, and an indicator of the current step. The bio completion
routine, if there was no I/O error, enqueues the first postprocessing
step. When that completes, it continues to the next step. Pages that
fail any postprocessing step have PageError set. Once all steps have
completed, pages without PageError set are set Uptodate, and all pages
are unlocked.
Also replace f2fs_encrypted_file() with a new function
f2fs_post_read_required() in places like direct I/O and garbage
collection that really should be testing whether the file needs special
I/O processing, not whether it is encrypted specifically.
This may also be useful for other future f2fs features such as
compression.
Signed-off-by: Eric Biggers <ebiggers@google.com>
Reviewed-by: Chao Yu <yuchao0@huawei.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2018-04-19 02:09:48 +08:00
|
|
|
bio_for_each_segment_all(bv, bio, i) {
|
|
|
|
|
page = bv->bv_page;
|
|
|
|
|
|
|
|
|
|
/* PG_error was set if any post_read step failed */
|
|
|
|
|
if (bio->bi_status || PageError(page)) {
|
|
|
|
|
ClearPageUptodate(page);
|
|
|
|
|
SetPageError(page);
|
|
|
|
|
} else {
|
|
|
|
|
SetPageUptodate(page);
|
|
|
|
|
}
|
|
|
|
|
unlock_page(page);
|
|
|
|
|
}
|
|
|
|
|
if (bio->bi_private)
|
|
|
|
|
mempool_free(bio->bi_private, bio_post_read_ctx_pool);
|
|
|
|
|
bio_put(bio);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void bio_post_read_processing(struct bio_post_read_ctx *ctx);
|
|
|
|
|
|
|
|
|
|
static void decrypt_work(struct work_struct *work)
|
|
|
|
|
{
|
|
|
|
|
struct bio_post_read_ctx *ctx =
|
|
|
|
|
container_of(work, struct bio_post_read_ctx, work);
|
|
|
|
|
|
|
|
|
|
fscrypt_decrypt_bio(ctx->bio);
|
|
|
|
|
|
|
|
|
|
bio_post_read_processing(ctx);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void bio_post_read_processing(struct bio_post_read_ctx *ctx)
|
|
|
|
|
{
|
|
|
|
|
switch (++ctx->cur_step) {
|
|
|
|
|
case STEP_DECRYPT:
|
|
|
|
|
if (ctx->enabled_steps & (1 << STEP_DECRYPT)) {
|
|
|
|
|
INIT_WORK(&ctx->work, decrypt_work);
|
|
|
|
|
fscrypt_enqueue_decrypt_work(&ctx->work);
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
ctx->cur_step++;
|
|
|
|
|
/* fall-through */
|
|
|
|
|
default:
|
|
|
|
|
__read_end_io(ctx->bio);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static bool f2fs_bio_post_read_required(struct bio *bio)
|
|
|
|
|
{
|
|
|
|
|
return bio->bi_private && !bio->bi_status;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void f2fs_read_end_io(struct bio *bio)
|
|
|
|
|
{
|
2016-09-18 23:30:07 +08:00
|
|
|
#ifdef CONFIG_F2FS_FAULT_INJECTION
|
2017-12-18 20:22:04 +08:00
|
|
|
if (time_to_inject(F2FS_P_SB(bio_first_page_all(bio)), FAULT_IO)) {
|
2017-02-25 11:08:28 +08:00
|
|
|
f2fs_show_injection_info(FAULT_IO);
|
2017-06-03 15:38:06 +08:00
|
|
|
bio->bi_status = BLK_STS_IOERR;
|
2017-02-25 11:08:28 +08:00
|
|
|
}
|
2016-09-18 23:30:07 +08:00
|
|
|
#endif
|
|
|
|
|
|
f2fs: refactor read path to allow multiple postprocessing steps
Currently f2fs's ->readpage() and ->readpages() assume that either the
data undergoes no postprocessing, or decryption only. But with
fs-verity, there will be an additional authenticity verification step,
and it may be needed either by itself, or combined with decryption.
To support this, store a 'struct bio_post_read_ctx' in ->bi_private
which contains a work struct, a bitmask of postprocessing steps that are
enabled, and an indicator of the current step. The bio completion
routine, if there was no I/O error, enqueues the first postprocessing
step. When that completes, it continues to the next step. Pages that
fail any postprocessing step have PageError set. Once all steps have
completed, pages without PageError set are set Uptodate, and all pages
are unlocked.
Also replace f2fs_encrypted_file() with a new function
f2fs_post_read_required() in places like direct I/O and garbage
collection that really should be testing whether the file needs special
I/O processing, not whether it is encrypted specifically.
This may also be useful for other future f2fs features such as
compression.
Signed-off-by: Eric Biggers <ebiggers@google.com>
Reviewed-by: Chao Yu <yuchao0@huawei.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2018-04-19 02:09:48 +08:00
|
|
|
if (f2fs_bio_post_read_required(bio)) {
|
|
|
|
|
struct bio_post_read_ctx *ctx = bio->bi_private;
|
2015-04-10 02:20:42 +08:00
|
|
|
|
f2fs: refactor read path to allow multiple postprocessing steps
Currently f2fs's ->readpage() and ->readpages() assume that either the
data undergoes no postprocessing, or decryption only. But with
fs-verity, there will be an additional authenticity verification step,
and it may be needed either by itself, or combined with decryption.
To support this, store a 'struct bio_post_read_ctx' in ->bi_private
which contains a work struct, a bitmask of postprocessing steps that are
enabled, and an indicator of the current step. The bio completion
routine, if there was no I/O error, enqueues the first postprocessing
step. When that completes, it continues to the next step. Pages that
fail any postprocessing step have PageError set. Once all steps have
completed, pages without PageError set are set Uptodate, and all pages
are unlocked.
Also replace f2fs_encrypted_file() with a new function
f2fs_post_read_required() in places like direct I/O and garbage
collection that really should be testing whether the file needs special
I/O processing, not whether it is encrypted specifically.
This may also be useful for other future f2fs features such as
compression.
Signed-off-by: Eric Biggers <ebiggers@google.com>
Reviewed-by: Chao Yu <yuchao0@huawei.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2018-04-19 02:09:48 +08:00
|
|
|
ctx->cur_step = STEP_INITIAL;
|
|
|
|
|
bio_post_read_processing(ctx);
|
|
|
|
|
return;
|
2015-04-10 02:20:42 +08:00
|
|
|
}
|
f2fs: refactor read path to allow multiple postprocessing steps
Currently f2fs's ->readpage() and ->readpages() assume that either the
data undergoes no postprocessing, or decryption only. But with
fs-verity, there will be an additional authenticity verification step,
and it may be needed either by itself, or combined with decryption.
To support this, store a 'struct bio_post_read_ctx' in ->bi_private
which contains a work struct, a bitmask of postprocessing steps that are
enabled, and an indicator of the current step. The bio completion
routine, if there was no I/O error, enqueues the first postprocessing
step. When that completes, it continues to the next step. Pages that
fail any postprocessing step have PageError set. Once all steps have
completed, pages without PageError set are set Uptodate, and all pages
are unlocked.
Also replace f2fs_encrypted_file() with a new function
f2fs_post_read_required() in places like direct I/O and garbage
collection that really should be testing whether the file needs special
I/O processing, not whether it is encrypted specifically.
This may also be useful for other future f2fs features such as
compression.
Signed-off-by: Eric Biggers <ebiggers@google.com>
Reviewed-by: Chao Yu <yuchao0@huawei.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2018-04-19 02:09:48 +08:00
|
|
|
|
|
|
|
|
__read_end_io(bio);
|
2015-04-10 02:20:42 +08:00
|
|
|
}
|
|
|
|
|
|
2015-07-20 21:29:37 +08:00
|
|
|
static void f2fs_write_end_io(struct bio *bio)
|
2013-11-30 11:51:14 +08:00
|
|
|
{
|
2014-02-03 09:50:22 +08:00
|
|
|
struct f2fs_sb_info *sbi = bio->bi_private;
|
2014-01-31 03:19:05 +08:00
|
|
|
struct bio_vec *bvec;
|
|
|
|
|
int i;
|
2013-11-30 11:51:14 +08:00
|
|
|
|
2014-01-31 03:19:05 +08:00
|
|
|
bio_for_each_segment_all(bvec, bio, i) {
|
2013-11-30 11:51:14 +08:00
|
|
|
struct page *page = bvec->bv_page;
|
f2fs: don't wait writeback for datas during checkpoint
Normally, while committing checkpoint, we will wait on all pages to be
writebacked no matter the page is data or metadata, so in scenario where
there are lots of data IO being submitted with metadata, we may suffer
long latency for waiting writeback during checkpoint.
Indeed, we only care about persistence for pages with metadata, but not
pages with data, as file system consistent are only related to metadate,
so in order to avoid encountering long latency in above scenario, let's
recognize and reference metadata in submitted IOs, wait writeback only
for metadatas.
Signed-off-by: Chao Yu <yuchao0@huawei.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2016-11-16 10:41:20 +08:00
|
|
|
enum count_type type = WB_DATA_TYPE(page);
|
2013-11-30 11:51:14 +08:00
|
|
|
|
2016-12-15 02:12:56 +08:00
|
|
|
if (IS_DUMMY_WRITTEN_PAGE(page)) {
|
|
|
|
|
set_page_private(page, (unsigned long)NULL);
|
|
|
|
|
ClearPagePrivate(page);
|
|
|
|
|
unlock_page(page);
|
|
|
|
|
mempool_free(page, sbi->write_io_dummy);
|
|
|
|
|
|
2017-06-03 15:38:06 +08:00
|
|
|
if (unlikely(bio->bi_status))
|
2016-12-15 02:12:56 +08:00
|
|
|
f2fs_stop_checkpoint(sbi, true);
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
|
2015-05-16 07:26:10 +08:00
|
|
|
fscrypt_pullback_bio_page(&page, true);
|
2015-04-24 03:04:33 +08:00
|
|
|
|
2017-06-03 15:38:06 +08:00
|
|
|
if (unlikely(bio->bi_status)) {
|
2016-10-12 04:56:01 +08:00
|
|
|
mapping_set_error(page->mapping, -EIO);
|
2018-01-01 08:26:38 +08:00
|
|
|
if (type == F2FS_WB_CP_DATA)
|
|
|
|
|
f2fs_stop_checkpoint(sbi, true);
|
2013-11-30 11:51:14 +08:00
|
|
|
}
|
2018-01-11 14:19:32 +08:00
|
|
|
|
|
|
|
|
f2fs_bug_on(sbi, page->mapping == NODE_MAPPING(sbi) &&
|
|
|
|
|
page->index != nid_of_node(page));
|
|
|
|
|
|
f2fs: don't wait writeback for datas during checkpoint
Normally, while committing checkpoint, we will wait on all pages to be
writebacked no matter the page is data or metadata, so in scenario where
there are lots of data IO being submitted with metadata, we may suffer
long latency for waiting writeback during checkpoint.
Indeed, we only care about persistence for pages with metadata, but not
pages with data, as file system consistent are only related to metadate,
so in order to avoid encountering long latency in above scenario, let's
recognize and reference metadata in submitted IOs, wait writeback only
for metadatas.
Signed-off-by: Chao Yu <yuchao0@huawei.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2016-11-16 10:41:20 +08:00
|
|
|
dec_page_count(sbi, type);
|
|
|
|
|
clear_cold_data(page);
|
2013-11-30 11:51:14 +08:00
|
|
|
end_page_writeback(page);
|
2014-01-31 03:19:05 +08:00
|
|
|
}
|
f2fs: don't wait writeback for datas during checkpoint
Normally, while committing checkpoint, we will wait on all pages to be
writebacked no matter the page is data or metadata, so in scenario where
there are lots of data IO being submitted with metadata, we may suffer
long latency for waiting writeback during checkpoint.
Indeed, we only care about persistence for pages with metadata, but not
pages with data, as file system consistent are only related to metadate,
so in order to avoid encountering long latency in above scenario, let's
recognize and reference metadata in submitted IOs, wait writeback only
for metadatas.
Signed-off-by: Chao Yu <yuchao0@huawei.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2016-11-16 10:41:20 +08:00
|
|
|
if (!get_pages(sbi, F2FS_WB_CP_DATA) &&
|
2016-05-18 07:23:36 +08:00
|
|
|
wq_has_sleeper(&sbi->cp_wait))
|
2013-11-30 11:51:14 +08:00
|
|
|
wake_up(&sbi->cp_wait);
|
|
|
|
|
|
|
|
|
|
bio_put(bio);
|
|
|
|
|
}
|
|
|
|
|
|
2016-10-07 10:02:05 +08:00
|
|
|
/*
|
|
|
|
|
* Return true, if pre_bio's bdev is same as its target device.
|
|
|
|
|
*/
|
|
|
|
|
struct block_device *f2fs_target_device(struct f2fs_sb_info *sbi,
|
|
|
|
|
block_t blk_addr, struct bio *bio)
|
|
|
|
|
{
|
|
|
|
|
struct block_device *bdev = sbi->sb->s_bdev;
|
|
|
|
|
int i;
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < sbi->s_ndevs; i++) {
|
|
|
|
|
if (FDEV(i).start_blk <= blk_addr &&
|
|
|
|
|
FDEV(i).end_blk >= blk_addr) {
|
|
|
|
|
blk_addr -= FDEV(i).start_blk;
|
|
|
|
|
bdev = FDEV(i).bdev;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
if (bio) {
|
2017-08-24 01:10:32 +08:00
|
|
|
bio_set_dev(bio, bdev);
|
2016-10-07 10:02:05 +08:00
|
|
|
bio->bi_iter.bi_sector = SECTOR_FROM_BLOCK(blk_addr);
|
|
|
|
|
}
|
|
|
|
|
return bdev;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int f2fs_target_device_index(struct f2fs_sb_info *sbi, block_t blkaddr)
|
|
|
|
|
{
|
|
|
|
|
int i;
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < sbi->s_ndevs; i++)
|
|
|
|
|
if (FDEV(i).start_blk <= blkaddr && FDEV(i).end_blk >= blkaddr)
|
|
|
|
|
return i;
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static bool __same_bdev(struct f2fs_sb_info *sbi,
|
|
|
|
|
block_t blk_addr, struct bio *bio)
|
|
|
|
|
{
|
2017-08-24 01:10:32 +08:00
|
|
|
struct block_device *b = f2fs_target_device(sbi, blk_addr, NULL);
|
|
|
|
|
return bio->bi_disk == b->bd_disk && bio->bi_partno == b->bd_partno;
|
2016-10-07 10:02:05 +08:00
|
|
|
}
|
|
|
|
|
|
2013-12-20 17:39:59 +08:00
|
|
|
/*
|
|
|
|
|
* Low-level block read/write IO operations.
|
|
|
|
|
*/
|
|
|
|
|
static struct bio *__bio_alloc(struct f2fs_sb_info *sbi, block_t blk_addr,
|
2018-01-09 19:33:39 +08:00
|
|
|
struct writeback_control *wbc,
|
2018-01-31 10:36:57 +08:00
|
|
|
int npages, bool is_read,
|
|
|
|
|
enum page_type type, enum temp_type temp)
|
2013-12-20 17:39:59 +08:00
|
|
|
{
|
|
|
|
|
struct bio *bio;
|
|
|
|
|
|
2017-10-28 16:52:31 +08:00
|
|
|
bio = f2fs_bio_alloc(sbi, npages, true);
|
2013-12-20 17:39:59 +08:00
|
|
|
|
2016-10-07 10:02:05 +08:00
|
|
|
f2fs_target_device(sbi, blk_addr, bio);
|
2018-01-31 10:36:57 +08:00
|
|
|
if (is_read) {
|
|
|
|
|
bio->bi_end_io = f2fs_read_end_io;
|
|
|
|
|
bio->bi_private = NULL;
|
|
|
|
|
} else {
|
|
|
|
|
bio->bi_end_io = f2fs_write_end_io;
|
|
|
|
|
bio->bi_private = sbi;
|
f2fs: clean up symbol namespace
As Ted reported:
"Hi, I was looking at f2fs's sources recently, and I noticed that there
is a very large number of non-static symbols which don't have a f2fs
prefix. There's well over a hundred (see attached below).
As one example, in fs/f2fs/dir.c there is:
unsigned char get_de_type(struct f2fs_dir_entry *de)
This function is clearly only useful for f2fs, but it has a generic
name. This means that if any other file system tries to have the same
symbol name, there will be a symbol conflict and the kernel would not
successfully build. It also means that when someone is looking f2fs
sources, it's not at all obvious whether a function such as
read_data_page(), invalidate_blocks(), is a generic kernel function
found in the fs, mm, or block layers, or a f2fs specific function.
You might want to fix this at some point. Hopefully Kent's bcachefs
isn't similarly using genericly named functions, since that might
cause conflicts with f2fs's functions --- but just as this would be a
problem that we would rightly insist that Kent fix, this is something
that we should have rightly insisted that f2fs should have fixed
before it was integrated into the mainline kernel.
acquire_orphan_inode
add_ino_entry
add_orphan_inode
allocate_data_block
allocate_new_segments
alloc_nid
alloc_nid_done
alloc_nid_failed
available_free_memory
...."
This patch adds "f2fs_" prefix for all non-static symbols in order to:
a) avoid conflict with other kernel generic symbols;
b) to indicate the function is f2fs specific one instead of generic
one;
Reported-by: Theodore Ts'o <tytso@mit.edu>
Signed-off-by: Chao Yu <yuchao0@huawei.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2018-05-30 00:20:41 +08:00
|
|
|
bio->bi_write_hint = f2fs_io_type_to_rw_hint(sbi, type, temp);
|
2018-01-31 10:36:57 +08:00
|
|
|
}
|
2018-01-09 19:33:39 +08:00
|
|
|
if (wbc)
|
|
|
|
|
wbc_init_bio(wbc, bio);
|
2013-12-20 17:39:59 +08:00
|
|
|
|
|
|
|
|
return bio;
|
|
|
|
|
}
|
|
|
|
|
|
2016-07-28 01:36:31 +08:00
|
|
|
static inline void __submit_bio(struct f2fs_sb_info *sbi,
|
|
|
|
|
struct bio *bio, enum page_type type)
|
2016-05-18 07:23:36 +08:00
|
|
|
{
|
2016-07-28 01:36:31 +08:00
|
|
|
if (!is_read_io(bio_op(bio))) {
|
2016-12-15 02:12:56 +08:00
|
|
|
unsigned int start;
|
|
|
|
|
|
|
|
|
|
if (type != DATA && type != NODE)
|
|
|
|
|
goto submit_io;
|
|
|
|
|
|
2018-02-06 12:31:17 +08:00
|
|
|
if (f2fs_sb_has_blkzoned(sbi->sb) && current->plug)
|
2018-02-06 08:21:45 +08:00
|
|
|
blk_finish_plug(current->plug);
|
|
|
|
|
|
2016-12-15 02:12:56 +08:00
|
|
|
start = bio->bi_iter.bi_size >> F2FS_BLKSIZE_BITS;
|
|
|
|
|
start %= F2FS_IO_SIZE(sbi);
|
|
|
|
|
|
|
|
|
|
if (start == 0)
|
|
|
|
|
goto submit_io;
|
|
|
|
|
|
|
|
|
|
/* fill dummy pages */
|
|
|
|
|
for (; start < F2FS_IO_SIZE(sbi); start++) {
|
|
|
|
|
struct page *page =
|
|
|
|
|
mempool_alloc(sbi->write_io_dummy,
|
|
|
|
|
GFP_NOIO | __GFP_ZERO | __GFP_NOFAIL);
|
|
|
|
|
f2fs_bug_on(sbi, !page);
|
|
|
|
|
|
|
|
|
|
SetPagePrivate(page);
|
|
|
|
|
set_page_private(page, (unsigned long)DUMMY_WRITTEN_PAGE);
|
|
|
|
|
lock_page(page);
|
|
|
|
|
if (bio_add_page(bio, page, PAGE_SIZE, 0) < PAGE_SIZE)
|
|
|
|
|
f2fs_bug_on(sbi, 1);
|
|
|
|
|
}
|
|
|
|
|
/*
|
|
|
|
|
* In the NODE case, we lose next block address chain. So, we
|
|
|
|
|
* need to do checkpoint in f2fs_sync_file.
|
|
|
|
|
*/
|
|
|
|
|
if (type == NODE)
|
|
|
|
|
set_sbi_flag(sbi, SBI_NEED_CP);
|
2016-06-05 05:25:24 +08:00
|
|
|
}
|
2016-12-15 02:12:56 +08:00
|
|
|
submit_io:
|
2016-12-22 04:13:03 +08:00
|
|
|
if (is_read_io(bio_op(bio)))
|
|
|
|
|
trace_f2fs_submit_read_bio(sbi->sb, type, bio);
|
|
|
|
|
else
|
|
|
|
|
trace_f2fs_submit_write_bio(sbi->sb, type, bio);
|
2016-06-06 03:31:41 +08:00
|
|
|
submit_bio(bio);
|
2016-05-18 07:23:36 +08:00
|
|
|
}
|
|
|
|
|
|
2013-12-11 12:54:01 +08:00
|
|
|
static void __submit_merged_bio(struct f2fs_bio_info *io)
|
2013-11-30 11:51:14 +08:00
|
|
|
{
|
2013-12-11 12:54:01 +08:00
|
|
|
struct f2fs_io_info *fio = &io->fio;
|
2013-11-30 11:51:14 +08:00
|
|
|
|
|
|
|
|
if (!io->bio)
|
|
|
|
|
return;
|
|
|
|
|
|
2016-12-22 04:13:03 +08:00
|
|
|
bio_set_op_attrs(io->bio, fio->op, fio->op_flags);
|
|
|
|
|
|
2016-06-06 03:31:55 +08:00
|
|
|
if (is_read_io(fio->op))
|
2016-12-22 04:13:03 +08:00
|
|
|
trace_f2fs_prepare_read_bio(io->sbi->sb, fio->type, io->bio);
|
2014-10-30 05:37:22 +08:00
|
|
|
else
|
2016-12-22 04:13:03 +08:00
|
|
|
trace_f2fs_prepare_write_bio(io->sbi->sb, fio->type, io->bio);
|
2016-06-06 03:31:55 +08:00
|
|
|
|
2016-07-28 01:36:31 +08:00
|
|
|
__submit_bio(io->sbi, io->bio, fio->type);
|
2013-11-30 11:51:14 +08:00
|
|
|
io->bio = NULL;
|
|
|
|
|
}
|
|
|
|
|
|
2017-02-02 08:51:22 +08:00
|
|
|
static bool __has_merged_page(struct f2fs_bio_info *io,
|
|
|
|
|
struct inode *inode, nid_t ino, pgoff_t idx)
|
2016-01-18 18:24:59 +08:00
|
|
|
{
|
|
|
|
|
struct bio_vec *bvec;
|
|
|
|
|
struct page *target;
|
|
|
|
|
int i;
|
|
|
|
|
|
f2fs: introduce f2fs_submit_merged_bio_cond
f2fs use single bio buffer per type data (META/NODE/DATA) for caching
writes locating in continuous block address as many as possible, after
submitting, these writes may be still cached in bio buffer, so we have
to flush cached writes in bio buffer by calling f2fs_submit_merged_bio.
Unfortunately, in the scenario of high concurrency, bio buffer could be
flushed by someone else before we submit it as below reasons:
a) there is no space in bio buffer.
b) add a request of different type (SYNC, ASYNC).
c) add a discontinuous block address.
For this condition, f2fs_submit_merged_bio will be devastating, because
it could break the following merging of writes in bio buffer, split one
big bio into two smaller one.
This patch introduces f2fs_submit_merged_bio_cond which can do a
conditional submitting with bio buffer, before submitting it will judge
whether:
- page in DATA type bio buffer is matching with specified page;
- page in DATA type bio buffer is belong to specified inode;
- page in NODE type bio buffer is belong to specified inode;
If there is no eligible page in bio buffer, we will skip submitting step,
result in gaining more chance to merge consecutive block IOs in bio cache.
Signed-off-by: Chao Yu <chao2.yu@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2016-01-18 18:28:11 +08:00
|
|
|
if (!io->bio)
|
2016-01-18 18:24:59 +08:00
|
|
|
return false;
|
f2fs: introduce f2fs_submit_merged_bio_cond
f2fs use single bio buffer per type data (META/NODE/DATA) for caching
writes locating in continuous block address as many as possible, after
submitting, these writes may be still cached in bio buffer, so we have
to flush cached writes in bio buffer by calling f2fs_submit_merged_bio.
Unfortunately, in the scenario of high concurrency, bio buffer could be
flushed by someone else before we submit it as below reasons:
a) there is no space in bio buffer.
b) add a request of different type (SYNC, ASYNC).
c) add a discontinuous block address.
For this condition, f2fs_submit_merged_bio will be devastating, because
it could break the following merging of writes in bio buffer, split one
big bio into two smaller one.
This patch introduces f2fs_submit_merged_bio_cond which can do a
conditional submitting with bio buffer, before submitting it will judge
whether:
- page in DATA type bio buffer is matching with specified page;
- page in DATA type bio buffer is belong to specified inode;
- page in NODE type bio buffer is belong to specified inode;
If there is no eligible page in bio buffer, we will skip submitting step,
result in gaining more chance to merge consecutive block IOs in bio cache.
Signed-off-by: Chao Yu <chao2.yu@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2016-01-18 18:28:11 +08:00
|
|
|
|
2017-02-02 08:51:22 +08:00
|
|
|
if (!inode && !ino)
|
f2fs: introduce f2fs_submit_merged_bio_cond
f2fs use single bio buffer per type data (META/NODE/DATA) for caching
writes locating in continuous block address as many as possible, after
submitting, these writes may be still cached in bio buffer, so we have
to flush cached writes in bio buffer by calling f2fs_submit_merged_bio.
Unfortunately, in the scenario of high concurrency, bio buffer could be
flushed by someone else before we submit it as below reasons:
a) there is no space in bio buffer.
b) add a request of different type (SYNC, ASYNC).
c) add a discontinuous block address.
For this condition, f2fs_submit_merged_bio will be devastating, because
it could break the following merging of writes in bio buffer, split one
big bio into two smaller one.
This patch introduces f2fs_submit_merged_bio_cond which can do a
conditional submitting with bio buffer, before submitting it will judge
whether:
- page in DATA type bio buffer is matching with specified page;
- page in DATA type bio buffer is belong to specified inode;
- page in NODE type bio buffer is belong to specified inode;
If there is no eligible page in bio buffer, we will skip submitting step,
result in gaining more chance to merge consecutive block IOs in bio cache.
Signed-off-by: Chao Yu <chao2.yu@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2016-01-18 18:28:11 +08:00
|
|
|
return true;
|
2016-01-18 18:24:59 +08:00
|
|
|
|
|
|
|
|
bio_for_each_segment_all(bvec, io->bio, i) {
|
|
|
|
|
|
2015-05-16 07:26:10 +08:00
|
|
|
if (bvec->bv_page->mapping)
|
2016-01-18 18:24:59 +08:00
|
|
|
target = bvec->bv_page;
|
2015-05-16 07:26:10 +08:00
|
|
|
else
|
|
|
|
|
target = fscrypt_control_page(bvec->bv_page);
|
2016-01-18 18:24:59 +08:00
|
|
|
|
2017-02-02 08:51:22 +08:00
|
|
|
if (idx != target->index)
|
|
|
|
|
continue;
|
|
|
|
|
|
f2fs: introduce f2fs_submit_merged_bio_cond
f2fs use single bio buffer per type data (META/NODE/DATA) for caching
writes locating in continuous block address as many as possible, after
submitting, these writes may be still cached in bio buffer, so we have
to flush cached writes in bio buffer by calling f2fs_submit_merged_bio.
Unfortunately, in the scenario of high concurrency, bio buffer could be
flushed by someone else before we submit it as below reasons:
a) there is no space in bio buffer.
b) add a request of different type (SYNC, ASYNC).
c) add a discontinuous block address.
For this condition, f2fs_submit_merged_bio will be devastating, because
it could break the following merging of writes in bio buffer, split one
big bio into two smaller one.
This patch introduces f2fs_submit_merged_bio_cond which can do a
conditional submitting with bio buffer, before submitting it will judge
whether:
- page in DATA type bio buffer is matching with specified page;
- page in DATA type bio buffer is belong to specified inode;
- page in NODE type bio buffer is belong to specified inode;
If there is no eligible page in bio buffer, we will skip submitting step,
result in gaining more chance to merge consecutive block IOs in bio cache.
Signed-off-by: Chao Yu <chao2.yu@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2016-01-18 18:28:11 +08:00
|
|
|
if (inode && inode == target->mapping->host)
|
|
|
|
|
return true;
|
|
|
|
|
if (ino && ino == ino_of_node(target))
|
2016-01-18 18:24:59 +08:00
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
|
f2fs: introduce f2fs_submit_merged_bio_cond
f2fs use single bio buffer per type data (META/NODE/DATA) for caching
writes locating in continuous block address as many as possible, after
submitting, these writes may be still cached in bio buffer, so we have
to flush cached writes in bio buffer by calling f2fs_submit_merged_bio.
Unfortunately, in the scenario of high concurrency, bio buffer could be
flushed by someone else before we submit it as below reasons:
a) there is no space in bio buffer.
b) add a request of different type (SYNC, ASYNC).
c) add a discontinuous block address.
For this condition, f2fs_submit_merged_bio will be devastating, because
it could break the following merging of writes in bio buffer, split one
big bio into two smaller one.
This patch introduces f2fs_submit_merged_bio_cond which can do a
conditional submitting with bio buffer, before submitting it will judge
whether:
- page in DATA type bio buffer is matching with specified page;
- page in DATA type bio buffer is belong to specified inode;
- page in NODE type bio buffer is belong to specified inode;
If there is no eligible page in bio buffer, we will skip submitting step,
result in gaining more chance to merge consecutive block IOs in bio cache.
Signed-off-by: Chao Yu <chao2.yu@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2016-01-18 18:28:11 +08:00
|
|
|
static bool has_merged_page(struct f2fs_sb_info *sbi, struct inode *inode,
|
2017-02-02 08:51:22 +08:00
|
|
|
nid_t ino, pgoff_t idx, enum page_type type)
|
f2fs: introduce f2fs_submit_merged_bio_cond
f2fs use single bio buffer per type data (META/NODE/DATA) for caching
writes locating in continuous block address as many as possible, after
submitting, these writes may be still cached in bio buffer, so we have
to flush cached writes in bio buffer by calling f2fs_submit_merged_bio.
Unfortunately, in the scenario of high concurrency, bio buffer could be
flushed by someone else before we submit it as below reasons:
a) there is no space in bio buffer.
b) add a request of different type (SYNC, ASYNC).
c) add a discontinuous block address.
For this condition, f2fs_submit_merged_bio will be devastating, because
it could break the following merging of writes in bio buffer, split one
big bio into two smaller one.
This patch introduces f2fs_submit_merged_bio_cond which can do a
conditional submitting with bio buffer, before submitting it will judge
whether:
- page in DATA type bio buffer is matching with specified page;
- page in DATA type bio buffer is belong to specified inode;
- page in NODE type bio buffer is belong to specified inode;
If there is no eligible page in bio buffer, we will skip submitting step,
result in gaining more chance to merge consecutive block IOs in bio cache.
Signed-off-by: Chao Yu <chao2.yu@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2016-01-18 18:28:11 +08:00
|
|
|
{
|
|
|
|
|
enum page_type btype = PAGE_TYPE_OF_BIO(type);
|
2017-05-11 02:18:25 +08:00
|
|
|
enum temp_type temp;
|
|
|
|
|
struct f2fs_bio_info *io;
|
|
|
|
|
bool ret = false;
|
f2fs: introduce f2fs_submit_merged_bio_cond
f2fs use single bio buffer per type data (META/NODE/DATA) for caching
writes locating in continuous block address as many as possible, after
submitting, these writes may be still cached in bio buffer, so we have
to flush cached writes in bio buffer by calling f2fs_submit_merged_bio.
Unfortunately, in the scenario of high concurrency, bio buffer could be
flushed by someone else before we submit it as below reasons:
a) there is no space in bio buffer.
b) add a request of different type (SYNC, ASYNC).
c) add a discontinuous block address.
For this condition, f2fs_submit_merged_bio will be devastating, because
it could break the following merging of writes in bio buffer, split one
big bio into two smaller one.
This patch introduces f2fs_submit_merged_bio_cond which can do a
conditional submitting with bio buffer, before submitting it will judge
whether:
- page in DATA type bio buffer is matching with specified page;
- page in DATA type bio buffer is belong to specified inode;
- page in NODE type bio buffer is belong to specified inode;
If there is no eligible page in bio buffer, we will skip submitting step,
result in gaining more chance to merge consecutive block IOs in bio cache.
Signed-off-by: Chao Yu <chao2.yu@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2016-01-18 18:28:11 +08:00
|
|
|
|
2017-05-11 02:18:25 +08:00
|
|
|
for (temp = HOT; temp < NR_TEMP_TYPE; temp++) {
|
|
|
|
|
io = sbi->write_io[btype] + temp;
|
|
|
|
|
|
|
|
|
|
down_read(&io->io_rwsem);
|
|
|
|
|
ret = __has_merged_page(io, inode, ino, idx);
|
|
|
|
|
up_read(&io->io_rwsem);
|
f2fs: introduce f2fs_submit_merged_bio_cond
f2fs use single bio buffer per type data (META/NODE/DATA) for caching
writes locating in continuous block address as many as possible, after
submitting, these writes may be still cached in bio buffer, so we have
to flush cached writes in bio buffer by calling f2fs_submit_merged_bio.
Unfortunately, in the scenario of high concurrency, bio buffer could be
flushed by someone else before we submit it as below reasons:
a) there is no space in bio buffer.
b) add a request of different type (SYNC, ASYNC).
c) add a discontinuous block address.
For this condition, f2fs_submit_merged_bio will be devastating, because
it could break the following merging of writes in bio buffer, split one
big bio into two smaller one.
This patch introduces f2fs_submit_merged_bio_cond which can do a
conditional submitting with bio buffer, before submitting it will judge
whether:
- page in DATA type bio buffer is matching with specified page;
- page in DATA type bio buffer is belong to specified inode;
- page in NODE type bio buffer is belong to specified inode;
If there is no eligible page in bio buffer, we will skip submitting step,
result in gaining more chance to merge consecutive block IOs in bio cache.
Signed-off-by: Chao Yu <chao2.yu@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2016-01-18 18:28:11 +08:00
|
|
|
|
2017-05-11 02:18:25 +08:00
|
|
|
/* TODO: use HOT temp only for meta pages now. */
|
|
|
|
|
if (ret || btype == META)
|
|
|
|
|
break;
|
|
|
|
|
}
|
f2fs: introduce f2fs_submit_merged_bio_cond
f2fs use single bio buffer per type data (META/NODE/DATA) for caching
writes locating in continuous block address as many as possible, after
submitting, these writes may be still cached in bio buffer, so we have
to flush cached writes in bio buffer by calling f2fs_submit_merged_bio.
Unfortunately, in the scenario of high concurrency, bio buffer could be
flushed by someone else before we submit it as below reasons:
a) there is no space in bio buffer.
b) add a request of different type (SYNC, ASYNC).
c) add a discontinuous block address.
For this condition, f2fs_submit_merged_bio will be devastating, because
it could break the following merging of writes in bio buffer, split one
big bio into two smaller one.
This patch introduces f2fs_submit_merged_bio_cond which can do a
conditional submitting with bio buffer, before submitting it will judge
whether:
- page in DATA type bio buffer is matching with specified page;
- page in DATA type bio buffer is belong to specified inode;
- page in NODE type bio buffer is belong to specified inode;
If there is no eligible page in bio buffer, we will skip submitting step,
result in gaining more chance to merge consecutive block IOs in bio cache.
Signed-off-by: Chao Yu <chao2.yu@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2016-01-18 18:28:11 +08:00
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2017-05-11 02:28:38 +08:00
|
|
|
static void __f2fs_submit_merged_write(struct f2fs_sb_info *sbi,
|
2017-05-11 02:18:25 +08:00
|
|
|
enum page_type type, enum temp_type temp)
|
2013-11-30 11:51:14 +08:00
|
|
|
{
|
|
|
|
|
enum page_type btype = PAGE_TYPE_OF_BIO(type);
|
2017-05-11 02:18:25 +08:00
|
|
|
struct f2fs_bio_info *io = sbi->write_io[btype] + temp;
|
2013-11-30 11:51:14 +08:00
|
|
|
|
2014-03-22 14:57:23 +08:00
|
|
|
down_write(&io->io_rwsem);
|
2013-12-11 12:54:01 +08:00
|
|
|
|
|
|
|
|
/* change META to META_FLUSH in the checkpoint procedure */
|
|
|
|
|
if (type >= META_FLUSH) {
|
|
|
|
|
io->fio.type = META_FLUSH;
|
2016-06-06 03:31:55 +08:00
|
|
|
io->fio.op = REQ_OP_WRITE;
|
2017-05-02 23:03:47 +08:00
|
|
|
io->fio.op_flags = REQ_META | REQ_PRIO | REQ_SYNC;
|
2016-11-01 21:40:10 +08:00
|
|
|
if (!test_opt(sbi, NOBARRIER))
|
2017-02-07 05:57:58 +08:00
|
|
|
io->fio.op_flags |= REQ_PREFLUSH | REQ_FUA;
|
2013-12-11 12:54:01 +08:00
|
|
|
}
|
|
|
|
|
__submit_merged_bio(io);
|
2014-03-22 14:57:23 +08:00
|
|
|
up_write(&io->io_rwsem);
|
2013-11-30 11:51:14 +08:00
|
|
|
}
|
|
|
|
|
|
2017-05-11 02:18:25 +08:00
|
|
|
static void __submit_merged_write_cond(struct f2fs_sb_info *sbi,
|
|
|
|
|
struct inode *inode, nid_t ino, pgoff_t idx,
|
|
|
|
|
enum page_type type, bool force)
|
f2fs: introduce f2fs_submit_merged_bio_cond
f2fs use single bio buffer per type data (META/NODE/DATA) for caching
writes locating in continuous block address as many as possible, after
submitting, these writes may be still cached in bio buffer, so we have
to flush cached writes in bio buffer by calling f2fs_submit_merged_bio.
Unfortunately, in the scenario of high concurrency, bio buffer could be
flushed by someone else before we submit it as below reasons:
a) there is no space in bio buffer.
b) add a request of different type (SYNC, ASYNC).
c) add a discontinuous block address.
For this condition, f2fs_submit_merged_bio will be devastating, because
it could break the following merging of writes in bio buffer, split one
big bio into two smaller one.
This patch introduces f2fs_submit_merged_bio_cond which can do a
conditional submitting with bio buffer, before submitting it will judge
whether:
- page in DATA type bio buffer is matching with specified page;
- page in DATA type bio buffer is belong to specified inode;
- page in NODE type bio buffer is belong to specified inode;
If there is no eligible page in bio buffer, we will skip submitting step,
result in gaining more chance to merge consecutive block IOs in bio cache.
Signed-off-by: Chao Yu <chao2.yu@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2016-01-18 18:28:11 +08:00
|
|
|
{
|
2017-05-11 02:18:25 +08:00
|
|
|
enum temp_type temp;
|
|
|
|
|
|
|
|
|
|
if (!force && !has_merged_page(sbi, inode, ino, idx, type))
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
for (temp = HOT; temp < NR_TEMP_TYPE; temp++) {
|
|
|
|
|
|
|
|
|
|
__f2fs_submit_merged_write(sbi, type, temp);
|
|
|
|
|
|
|
|
|
|
/* TODO: use HOT temp only for meta pages now. */
|
|
|
|
|
if (type >= META)
|
|
|
|
|
break;
|
|
|
|
|
}
|
f2fs: introduce f2fs_submit_merged_bio_cond
f2fs use single bio buffer per type data (META/NODE/DATA) for caching
writes locating in continuous block address as many as possible, after
submitting, these writes may be still cached in bio buffer, so we have
to flush cached writes in bio buffer by calling f2fs_submit_merged_bio.
Unfortunately, in the scenario of high concurrency, bio buffer could be
flushed by someone else before we submit it as below reasons:
a) there is no space in bio buffer.
b) add a request of different type (SYNC, ASYNC).
c) add a discontinuous block address.
For this condition, f2fs_submit_merged_bio will be devastating, because
it could break the following merging of writes in bio buffer, split one
big bio into two smaller one.
This patch introduces f2fs_submit_merged_bio_cond which can do a
conditional submitting with bio buffer, before submitting it will judge
whether:
- page in DATA type bio buffer is matching with specified page;
- page in DATA type bio buffer is belong to specified inode;
- page in NODE type bio buffer is belong to specified inode;
If there is no eligible page in bio buffer, we will skip submitting step,
result in gaining more chance to merge consecutive block IOs in bio cache.
Signed-off-by: Chao Yu <chao2.yu@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2016-01-18 18:28:11 +08:00
|
|
|
}
|
|
|
|
|
|
2017-05-11 02:28:38 +08:00
|
|
|
void f2fs_submit_merged_write(struct f2fs_sb_info *sbi, enum page_type type)
|
f2fs: introduce f2fs_submit_merged_bio_cond
f2fs use single bio buffer per type data (META/NODE/DATA) for caching
writes locating in continuous block address as many as possible, after
submitting, these writes may be still cached in bio buffer, so we have
to flush cached writes in bio buffer by calling f2fs_submit_merged_bio.
Unfortunately, in the scenario of high concurrency, bio buffer could be
flushed by someone else before we submit it as below reasons:
a) there is no space in bio buffer.
b) add a request of different type (SYNC, ASYNC).
c) add a discontinuous block address.
For this condition, f2fs_submit_merged_bio will be devastating, because
it could break the following merging of writes in bio buffer, split one
big bio into two smaller one.
This patch introduces f2fs_submit_merged_bio_cond which can do a
conditional submitting with bio buffer, before submitting it will judge
whether:
- page in DATA type bio buffer is matching with specified page;
- page in DATA type bio buffer is belong to specified inode;
- page in NODE type bio buffer is belong to specified inode;
If there is no eligible page in bio buffer, we will skip submitting step,
result in gaining more chance to merge consecutive block IOs in bio cache.
Signed-off-by: Chao Yu <chao2.yu@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2016-01-18 18:28:11 +08:00
|
|
|
{
|
2017-05-11 02:18:25 +08:00
|
|
|
__submit_merged_write_cond(sbi, NULL, 0, 0, type, true);
|
f2fs: introduce f2fs_submit_merged_bio_cond
f2fs use single bio buffer per type data (META/NODE/DATA) for caching
writes locating in continuous block address as many as possible, after
submitting, these writes may be still cached in bio buffer, so we have
to flush cached writes in bio buffer by calling f2fs_submit_merged_bio.
Unfortunately, in the scenario of high concurrency, bio buffer could be
flushed by someone else before we submit it as below reasons:
a) there is no space in bio buffer.
b) add a request of different type (SYNC, ASYNC).
c) add a discontinuous block address.
For this condition, f2fs_submit_merged_bio will be devastating, because
it could break the following merging of writes in bio buffer, split one
big bio into two smaller one.
This patch introduces f2fs_submit_merged_bio_cond which can do a
conditional submitting with bio buffer, before submitting it will judge
whether:
- page in DATA type bio buffer is matching with specified page;
- page in DATA type bio buffer is belong to specified inode;
- page in NODE type bio buffer is belong to specified inode;
If there is no eligible page in bio buffer, we will skip submitting step,
result in gaining more chance to merge consecutive block IOs in bio cache.
Signed-off-by: Chao Yu <chao2.yu@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2016-01-18 18:28:11 +08:00
|
|
|
}
|
|
|
|
|
|
2017-05-11 02:28:38 +08:00
|
|
|
void f2fs_submit_merged_write_cond(struct f2fs_sb_info *sbi,
|
2017-02-02 08:51:22 +08:00
|
|
|
struct inode *inode, nid_t ino, pgoff_t idx,
|
2017-05-11 02:28:38 +08:00
|
|
|
enum page_type type)
|
f2fs: introduce f2fs_submit_merged_bio_cond
f2fs use single bio buffer per type data (META/NODE/DATA) for caching
writes locating in continuous block address as many as possible, after
submitting, these writes may be still cached in bio buffer, so we have
to flush cached writes in bio buffer by calling f2fs_submit_merged_bio.
Unfortunately, in the scenario of high concurrency, bio buffer could be
flushed by someone else before we submit it as below reasons:
a) there is no space in bio buffer.
b) add a request of different type (SYNC, ASYNC).
c) add a discontinuous block address.
For this condition, f2fs_submit_merged_bio will be devastating, because
it could break the following merging of writes in bio buffer, split one
big bio into two smaller one.
This patch introduces f2fs_submit_merged_bio_cond which can do a
conditional submitting with bio buffer, before submitting it will judge
whether:
- page in DATA type bio buffer is matching with specified page;
- page in DATA type bio buffer is belong to specified inode;
- page in NODE type bio buffer is belong to specified inode;
If there is no eligible page in bio buffer, we will skip submitting step,
result in gaining more chance to merge consecutive block IOs in bio cache.
Signed-off-by: Chao Yu <chao2.yu@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2016-01-18 18:28:11 +08:00
|
|
|
{
|
2017-05-11 02:18:25 +08:00
|
|
|
__submit_merged_write_cond(sbi, inode, ino, idx, type, false);
|
f2fs: introduce f2fs_submit_merged_bio_cond
f2fs use single bio buffer per type data (META/NODE/DATA) for caching
writes locating in continuous block address as many as possible, after
submitting, these writes may be still cached in bio buffer, so we have
to flush cached writes in bio buffer by calling f2fs_submit_merged_bio.
Unfortunately, in the scenario of high concurrency, bio buffer could be
flushed by someone else before we submit it as below reasons:
a) there is no space in bio buffer.
b) add a request of different type (SYNC, ASYNC).
c) add a discontinuous block address.
For this condition, f2fs_submit_merged_bio will be devastating, because
it could break the following merging of writes in bio buffer, split one
big bio into two smaller one.
This patch introduces f2fs_submit_merged_bio_cond which can do a
conditional submitting with bio buffer, before submitting it will judge
whether:
- page in DATA type bio buffer is matching with specified page;
- page in DATA type bio buffer is belong to specified inode;
- page in NODE type bio buffer is belong to specified inode;
If there is no eligible page in bio buffer, we will skip submitting step,
result in gaining more chance to merge consecutive block IOs in bio cache.
Signed-off-by: Chao Yu <chao2.yu@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2016-01-18 18:28:11 +08:00
|
|
|
}
|
|
|
|
|
|
2017-05-11 02:28:38 +08:00
|
|
|
void f2fs_flush_merged_writes(struct f2fs_sb_info *sbi)
|
2016-02-24 17:17:55 +08:00
|
|
|
{
|
2017-05-11 02:28:38 +08:00
|
|
|
f2fs_submit_merged_write(sbi, DATA);
|
|
|
|
|
f2fs_submit_merged_write(sbi, NODE);
|
|
|
|
|
f2fs_submit_merged_write(sbi, META);
|
2016-02-24 17:17:55 +08:00
|
|
|
}
|
|
|
|
|
|
2013-11-30 11:51:14 +08:00
|
|
|
/*
|
|
|
|
|
* Fill the locked page with data located in the block address.
|
2017-04-06 03:49:44 +08:00
|
|
|
* A caller needs to unlock the page on failure.
|
2013-11-30 11:51:14 +08:00
|
|
|
*/
|
2015-04-24 05:38:15 +08:00
|
|
|
int f2fs_submit_page_bio(struct f2fs_io_info *fio)
|
2013-11-30 11:51:14 +08:00
|
|
|
{
|
|
|
|
|
struct bio *bio;
|
2015-05-16 07:26:10 +08:00
|
|
|
struct page *page = fio->encrypted_page ?
|
|
|
|
|
fio->encrypted_page : fio->page;
|
2013-11-30 11:51:14 +08:00
|
|
|
|
2018-03-08 16:29:13 +08:00
|
|
|
verify_block_addr(fio, fio->new_blkaddr);
|
2014-12-24 16:08:14 +08:00
|
|
|
trace_f2fs_submit_page_bio(page, fio);
|
2015-04-24 05:38:15 +08:00
|
|
|
f2fs_trace_ios(fio, 0);
|
2013-11-30 11:51:14 +08:00
|
|
|
|
|
|
|
|
/* Allocate a new bio */
|
2018-01-09 19:33:39 +08:00
|
|
|
bio = __bio_alloc(fio->sbi, fio->new_blkaddr, fio->io_wbc,
|
2018-01-31 10:36:57 +08:00
|
|
|
1, is_read_io(fio->op), fio->type, fio->temp);
|
2013-11-30 11:51:14 +08:00
|
|
|
|
mm, fs: get rid of PAGE_CACHE_* and page_cache_{get,release} macros
PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} macros were introduced *long* time
ago with promise that one day it will be possible to implement page
cache with bigger chunks than PAGE_SIZE.
This promise never materialized. And unlikely will.
We have many places where PAGE_CACHE_SIZE assumed to be equal to
PAGE_SIZE. And it's constant source of confusion on whether
PAGE_CACHE_* or PAGE_* constant should be used in a particular case,
especially on the border between fs and mm.
Global switching to PAGE_CACHE_SIZE != PAGE_SIZE would cause to much
breakage to be doable.
Let's stop pretending that pages in page cache are special. They are
not.
The changes are pretty straight-forward:
- <foo> << (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- <foo> >> (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} -> PAGE_{SIZE,SHIFT,MASK,ALIGN};
- page_cache_get() -> get_page();
- page_cache_release() -> put_page();
This patch contains automated changes generated with coccinelle using
script below. For some reason, coccinelle doesn't patch header files.
I've called spatch for them manually.
The only adjustment after coccinelle is revert of changes to
PAGE_CAHCE_ALIGN definition: we are going to drop it later.
There are few places in the code where coccinelle didn't reach. I'll
fix them manually in a separate patch. Comments and documentation also
will be addressed with the separate patch.
virtual patch
@@
expression E;
@@
- E << (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
expression E;
@@
- E >> (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
@@
- PAGE_CACHE_SHIFT
+ PAGE_SHIFT
@@
@@
- PAGE_CACHE_SIZE
+ PAGE_SIZE
@@
@@
- PAGE_CACHE_MASK
+ PAGE_MASK
@@
expression E;
@@
- PAGE_CACHE_ALIGN(E)
+ PAGE_ALIGN(E)
@@
expression E;
@@
- page_cache_get(E)
+ get_page(E)
@@
expression E;
@@
- page_cache_release(E)
+ put_page(E)
Signed-off-by: Kirill A. Shutemov <kirill.shutemov@linux.intel.com>
Acked-by: Michal Hocko <mhocko@suse.com>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2016-04-01 20:29:47 +08:00
|
|
|
if (bio_add_page(bio, page, PAGE_SIZE, 0) < PAGE_SIZE) {
|
2013-11-30 11:51:14 +08:00
|
|
|
bio_put(bio);
|
|
|
|
|
return -EFAULT;
|
|
|
|
|
}
|
2016-06-06 03:31:55 +08:00
|
|
|
bio_set_op_attrs(bio, fio->op, fio->op_flags);
|
2013-11-30 11:51:14 +08:00
|
|
|
|
2016-07-28 01:36:31 +08:00
|
|
|
__submit_bio(fio->sbi, bio, fio->type);
|
2017-03-31 12:02:46 +08:00
|
|
|
|
|
|
|
|
if (!is_read_io(fio->op))
|
|
|
|
|
inc_page_count(fio->sbi, WB_DATA_TYPE(fio->page));
|
2013-11-30 11:51:14 +08:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2018-05-28 23:47:18 +08:00
|
|
|
void f2fs_submit_page_write(struct f2fs_io_info *fio)
|
2013-11-30 11:51:14 +08:00
|
|
|
{
|
2015-04-24 05:38:15 +08:00
|
|
|
struct f2fs_sb_info *sbi = fio->sbi;
|
2013-12-11 12:54:01 +08:00
|
|
|
enum page_type btype = PAGE_TYPE_OF_BIO(fio->type);
|
2017-05-11 02:18:25 +08:00
|
|
|
struct f2fs_bio_info *io = sbi->write_io[btype] + fio->temp;
|
2015-04-24 03:04:33 +08:00
|
|
|
struct page *bio_page;
|
2013-11-30 11:51:14 +08:00
|
|
|
|
2017-05-11 02:28:38 +08:00
|
|
|
f2fs_bug_on(sbi, is_read_io(fio->op));
|
2013-11-30 11:51:14 +08:00
|
|
|
|
2017-05-19 23:37:01 +08:00
|
|
|
down_write(&io->io_rwsem);
|
|
|
|
|
next:
|
|
|
|
|
if (fio->in_list) {
|
|
|
|
|
spin_lock(&io->io_lock);
|
|
|
|
|
if (list_empty(&io->io_list)) {
|
|
|
|
|
spin_unlock(&io->io_lock);
|
2018-05-28 23:47:18 +08:00
|
|
|
goto out;
|
2017-05-19 23:37:01 +08:00
|
|
|
}
|
|
|
|
|
fio = list_first_entry(&io->io_list,
|
|
|
|
|
struct f2fs_io_info, list);
|
|
|
|
|
list_del(&fio->list);
|
|
|
|
|
spin_unlock(&io->io_lock);
|
|
|
|
|
}
|
2013-11-30 11:51:14 +08:00
|
|
|
|
2018-05-23 22:25:08 +08:00
|
|
|
if (is_valid_blkaddr(fio->old_blkaddr))
|
2018-03-08 16:29:13 +08:00
|
|
|
verify_block_addr(fio, fio->old_blkaddr);
|
|
|
|
|
verify_block_addr(fio, fio->new_blkaddr);
|
2013-11-30 11:51:14 +08:00
|
|
|
|
f2fs: don't wait writeback for datas during checkpoint
Normally, while committing checkpoint, we will wait on all pages to be
writebacked no matter the page is data or metadata, so in scenario where
there are lots of data IO being submitted with metadata, we may suffer
long latency for waiting writeback during checkpoint.
Indeed, we only care about persistence for pages with metadata, but not
pages with data, as file system consistent are only related to metadate,
so in order to avoid encountering long latency in above scenario, let's
recognize and reference metadata in submitted IOs, wait writeback only
for metadatas.
Signed-off-by: Chao Yu <yuchao0@huawei.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2016-11-16 10:41:20 +08:00
|
|
|
bio_page = fio->encrypted_page ? fio->encrypted_page : fio->page;
|
|
|
|
|
|
2017-10-07 22:02:21 +08:00
|
|
|
/* set submitted = true as a return value */
|
|
|
|
|
fio->submitted = true;
|
2017-02-04 09:44:04 +08:00
|
|
|
|
2017-05-11 02:28:38 +08:00
|
|
|
inc_page_count(sbi, WB_DATA_TYPE(bio_page));
|
2013-11-30 11:51:14 +08:00
|
|
|
|
f2fs: trace old block address for CoWed page
This patch enables to trace old block address of CoWed page for better
debugging.
f2fs_submit_page_mbio: dev = (1,0), ino = 1, page_index = 0x1d4f0, oldaddr = 0xfe8ab, newaddr = 0xfee90 rw = WRITE_SYNC, type = NODE
f2fs_submit_page_mbio: dev = (1,0), ino = 1, page_index = 0x1d4f8, oldaddr = 0xfe8b0, newaddr = 0xfee91 rw = WRITE_SYNC, type = NODE
f2fs_submit_page_mbio: dev = (1,0), ino = 1, page_index = 0x1d4fa, oldaddr = 0xfe8ae, newaddr = 0xfee92 rw = WRITE_SYNC, type = NODE
f2fs_submit_page_mbio: dev = (1,0), ino = 134824, page_index = 0x96, oldaddr = 0xf049b, newaddr = 0x2bbe rw = WRITE, type = DATA
f2fs_submit_page_mbio: dev = (1,0), ino = 134824, page_index = 0x97, oldaddr = 0xf049c, newaddr = 0x2bbf rw = WRITE, type = DATA
f2fs_submit_page_mbio: dev = (1,0), ino = 134824, page_index = 0x98, oldaddr = 0xf049d, newaddr = 0x2bc0 rw = WRITE, type = DATA
f2fs_submit_page_mbio: dev = (1,0), ino = 135260, page_index = 0x47, oldaddr = 0xffffffff, newaddr = 0xf2631 rw = WRITE, type = DATA
f2fs_submit_page_mbio: dev = (1,0), ino = 135260, page_index = 0x48, oldaddr = 0xffffffff, newaddr = 0xf2632 rw = WRITE, type = DATA
f2fs_submit_page_mbio: dev = (1,0), ino = 135260, page_index = 0x49, oldaddr = 0xffffffff, newaddr = 0xf2633 rw = WRITE, type = DATA
Signed-off-by: Chao Yu <chao2.yu@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2016-02-22 18:36:38 +08:00
|
|
|
if (io->bio && (io->last_block_in_bio != fio->new_blkaddr - 1 ||
|
2016-10-07 10:02:05 +08:00
|
|
|
(io->fio.op != fio->op || io->fio.op_flags != fio->op_flags) ||
|
|
|
|
|
!__same_bdev(sbi, fio->new_blkaddr, io->bio)))
|
2013-12-11 12:54:01 +08:00
|
|
|
__submit_merged_bio(io);
|
2013-11-30 11:51:14 +08:00
|
|
|
alloc_new:
|
|
|
|
|
if (io->bio == NULL) {
|
2016-12-15 02:12:56 +08:00
|
|
|
if ((fio->type == DATA || fio->type == NODE) &&
|
|
|
|
|
fio->new_blkaddr & F2FS_IO_SIZE_MASK(sbi)) {
|
2017-05-11 02:28:38 +08:00
|
|
|
dec_page_count(sbi, WB_DATA_TYPE(bio_page));
|
2018-05-28 23:47:18 +08:00
|
|
|
fio->retry = true;
|
|
|
|
|
goto skip;
|
2016-12-15 02:12:56 +08:00
|
|
|
}
|
2018-01-09 19:33:39 +08:00
|
|
|
io->bio = __bio_alloc(sbi, fio->new_blkaddr, fio->io_wbc,
|
2018-01-31 10:36:57 +08:00
|
|
|
BIO_MAX_PAGES, false,
|
|
|
|
|
fio->type, fio->temp);
|
2013-12-11 12:54:01 +08:00
|
|
|
io->fio = *fio;
|
2013-11-30 11:51:14 +08:00
|
|
|
}
|
|
|
|
|
|
2017-05-11 02:18:25 +08:00
|
|
|
if (bio_add_page(io->bio, bio_page, PAGE_SIZE, 0) < PAGE_SIZE) {
|
2013-12-11 12:54:01 +08:00
|
|
|
__submit_merged_bio(io);
|
2013-11-30 11:51:14 +08:00
|
|
|
goto alloc_new;
|
|
|
|
|
}
|
|
|
|
|
|
2018-01-09 19:33:39 +08:00
|
|
|
if (fio->io_wbc)
|
|
|
|
|
wbc_account_io(fio->io_wbc, bio_page, PAGE_SIZE);
|
|
|
|
|
|
f2fs: trace old block address for CoWed page
This patch enables to trace old block address of CoWed page for better
debugging.
f2fs_submit_page_mbio: dev = (1,0), ino = 1, page_index = 0x1d4f0, oldaddr = 0xfe8ab, newaddr = 0xfee90 rw = WRITE_SYNC, type = NODE
f2fs_submit_page_mbio: dev = (1,0), ino = 1, page_index = 0x1d4f8, oldaddr = 0xfe8b0, newaddr = 0xfee91 rw = WRITE_SYNC, type = NODE
f2fs_submit_page_mbio: dev = (1,0), ino = 1, page_index = 0x1d4fa, oldaddr = 0xfe8ae, newaddr = 0xfee92 rw = WRITE_SYNC, type = NODE
f2fs_submit_page_mbio: dev = (1,0), ino = 134824, page_index = 0x96, oldaddr = 0xf049b, newaddr = 0x2bbe rw = WRITE, type = DATA
f2fs_submit_page_mbio: dev = (1,0), ino = 134824, page_index = 0x97, oldaddr = 0xf049c, newaddr = 0x2bbf rw = WRITE, type = DATA
f2fs_submit_page_mbio: dev = (1,0), ino = 134824, page_index = 0x98, oldaddr = 0xf049d, newaddr = 0x2bc0 rw = WRITE, type = DATA
f2fs_submit_page_mbio: dev = (1,0), ino = 135260, page_index = 0x47, oldaddr = 0xffffffff, newaddr = 0xf2631 rw = WRITE, type = DATA
f2fs_submit_page_mbio: dev = (1,0), ino = 135260, page_index = 0x48, oldaddr = 0xffffffff, newaddr = 0xf2632 rw = WRITE, type = DATA
f2fs_submit_page_mbio: dev = (1,0), ino = 135260, page_index = 0x49, oldaddr = 0xffffffff, newaddr = 0xf2633 rw = WRITE, type = DATA
Signed-off-by: Chao Yu <chao2.yu@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2016-02-22 18:36:38 +08:00
|
|
|
io->last_block_in_bio = fio->new_blkaddr;
|
2015-04-24 05:38:15 +08:00
|
|
|
f2fs_trace_ios(fio, 0);
|
2017-05-19 23:37:01 +08:00
|
|
|
|
|
|
|
|
trace_f2fs_submit_page_write(fio->page, fio);
|
2018-05-28 23:47:18 +08:00
|
|
|
skip:
|
2017-05-19 23:37:01 +08:00
|
|
|
if (fio->in_list)
|
|
|
|
|
goto next;
|
2018-05-28 23:47:18 +08:00
|
|
|
out:
|
2014-03-22 14:57:23 +08:00
|
|
|
up_write(&io->io_rwsem);
|
2013-11-30 11:51:14 +08:00
|
|
|
}
|
|
|
|
|
|
2017-09-07 12:04:44 +08:00
|
|
|
static struct bio *f2fs_grab_read_bio(struct inode *inode, block_t blkaddr,
|
|
|
|
|
unsigned nr_pages)
|
|
|
|
|
{
|
|
|
|
|
struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
|
|
|
|
|
struct bio *bio;
|
f2fs: refactor read path to allow multiple postprocessing steps
Currently f2fs's ->readpage() and ->readpages() assume that either the
data undergoes no postprocessing, or decryption only. But with
fs-verity, there will be an additional authenticity verification step,
and it may be needed either by itself, or combined with decryption.
To support this, store a 'struct bio_post_read_ctx' in ->bi_private
which contains a work struct, a bitmask of postprocessing steps that are
enabled, and an indicator of the current step. The bio completion
routine, if there was no I/O error, enqueues the first postprocessing
step. When that completes, it continues to the next step. Pages that
fail any postprocessing step have PageError set. Once all steps have
completed, pages without PageError set are set Uptodate, and all pages
are unlocked.
Also replace f2fs_encrypted_file() with a new function
f2fs_post_read_required() in places like direct I/O and garbage
collection that really should be testing whether the file needs special
I/O processing, not whether it is encrypted specifically.
This may also be useful for other future f2fs features such as
compression.
Signed-off-by: Eric Biggers <ebiggers@google.com>
Reviewed-by: Chao Yu <yuchao0@huawei.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2018-04-19 02:09:48 +08:00
|
|
|
struct bio_post_read_ctx *ctx;
|
|
|
|
|
unsigned int post_read_steps = 0;
|
2017-09-07 12:04:44 +08:00
|
|
|
|
2017-10-28 16:52:31 +08:00
|
|
|
bio = f2fs_bio_alloc(sbi, min_t(int, nr_pages, BIO_MAX_PAGES), false);
|
f2fs: refactor read path to allow multiple postprocessing steps
Currently f2fs's ->readpage() and ->readpages() assume that either the
data undergoes no postprocessing, or decryption only. But with
fs-verity, there will be an additional authenticity verification step,
and it may be needed either by itself, or combined with decryption.
To support this, store a 'struct bio_post_read_ctx' in ->bi_private
which contains a work struct, a bitmask of postprocessing steps that are
enabled, and an indicator of the current step. The bio completion
routine, if there was no I/O error, enqueues the first postprocessing
step. When that completes, it continues to the next step. Pages that
fail any postprocessing step have PageError set. Once all steps have
completed, pages without PageError set are set Uptodate, and all pages
are unlocked.
Also replace f2fs_encrypted_file() with a new function
f2fs_post_read_required() in places like direct I/O and garbage
collection that really should be testing whether the file needs special
I/O processing, not whether it is encrypted specifically.
This may also be useful for other future f2fs features such as
compression.
Signed-off-by: Eric Biggers <ebiggers@google.com>
Reviewed-by: Chao Yu <yuchao0@huawei.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2018-04-19 02:09:48 +08:00
|
|
|
if (!bio)
|
2017-09-07 12:04:44 +08:00
|
|
|
return ERR_PTR(-ENOMEM);
|
|
|
|
|
f2fs_target_device(sbi, blkaddr, bio);
|
|
|
|
|
bio->bi_end_io = f2fs_read_end_io;
|
|
|
|
|
bio_set_op_attrs(bio, REQ_OP_READ, 0);
|
|
|
|
|
|
f2fs: refactor read path to allow multiple postprocessing steps
Currently f2fs's ->readpage() and ->readpages() assume that either the
data undergoes no postprocessing, or decryption only. But with
fs-verity, there will be an additional authenticity verification step,
and it may be needed either by itself, or combined with decryption.
To support this, store a 'struct bio_post_read_ctx' in ->bi_private
which contains a work struct, a bitmask of postprocessing steps that are
enabled, and an indicator of the current step. The bio completion
routine, if there was no I/O error, enqueues the first postprocessing
step. When that completes, it continues to the next step. Pages that
fail any postprocessing step have PageError set. Once all steps have
completed, pages without PageError set are set Uptodate, and all pages
are unlocked.
Also replace f2fs_encrypted_file() with a new function
f2fs_post_read_required() in places like direct I/O and garbage
collection that really should be testing whether the file needs special
I/O processing, not whether it is encrypted specifically.
This may also be useful for other future f2fs features such as
compression.
Signed-off-by: Eric Biggers <ebiggers@google.com>
Reviewed-by: Chao Yu <yuchao0@huawei.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2018-04-19 02:09:48 +08:00
|
|
|
if (f2fs_encrypted_file(inode))
|
|
|
|
|
post_read_steps |= 1 << STEP_DECRYPT;
|
|
|
|
|
if (post_read_steps) {
|
|
|
|
|
ctx = mempool_alloc(bio_post_read_ctx_pool, GFP_NOFS);
|
|
|
|
|
if (!ctx) {
|
|
|
|
|
bio_put(bio);
|
|
|
|
|
return ERR_PTR(-ENOMEM);
|
|
|
|
|
}
|
|
|
|
|
ctx->bio = bio;
|
|
|
|
|
ctx->enabled_steps = post_read_steps;
|
|
|
|
|
bio->bi_private = ctx;
|
|
|
|
|
|
|
|
|
|
/* wait the page to be moved by cleaning */
|
|
|
|
|
f2fs_wait_on_block_writeback(sbi, blkaddr);
|
|
|
|
|
}
|
|
|
|
|
|
2017-09-07 12:04:44 +08:00
|
|
|
return bio;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* This can handle encryption stuffs */
|
|
|
|
|
static int f2fs_submit_page_read(struct inode *inode, struct page *page,
|
|
|
|
|
block_t blkaddr)
|
|
|
|
|
{
|
|
|
|
|
struct bio *bio = f2fs_grab_read_bio(inode, blkaddr, 1);
|
|
|
|
|
|
|
|
|
|
if (IS_ERR(bio))
|
|
|
|
|
return PTR_ERR(bio);
|
|
|
|
|
|
|
|
|
|
if (bio_add_page(bio, page, PAGE_SIZE, 0) < PAGE_SIZE) {
|
|
|
|
|
bio_put(bio);
|
|
|
|
|
return -EFAULT;
|
|
|
|
|
}
|
|
|
|
|
__submit_bio(F2FS_I_SB(inode), bio, DATA);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2016-05-09 19:56:30 +08:00
|
|
|
static void __set_data_blkaddr(struct dnode_of_data *dn)
|
|
|
|
|
{
|
|
|
|
|
struct f2fs_node *rn = F2FS_NODE(dn->node_page);
|
|
|
|
|
__le32 *addr_array;
|
2017-07-19 00:19:06 +08:00
|
|
|
int base = 0;
|
|
|
|
|
|
|
|
|
|
if (IS_INODE(dn->node_page) && f2fs_has_extra_attr(dn->inode))
|
|
|
|
|
base = get_extra_isize(dn->inode);
|
2016-05-09 19:56:30 +08:00
|
|
|
|
|
|
|
|
/* Get physical address of data block */
|
|
|
|
|
addr_array = blkaddr_in_node(rn);
|
2017-07-19 00:19:06 +08:00
|
|
|
addr_array[base + dn->ofs_in_node] = cpu_to_le32(dn->data_blkaddr);
|
2016-05-09 19:56:30 +08:00
|
|
|
}
|
|
|
|
|
|
2012-11-29 12:28:09 +08:00
|
|
|
/*
|
2012-11-02 16:10:12 +08:00
|
|
|
* Lock ordering for the change of data block address:
|
|
|
|
|
* ->data_page
|
|
|
|
|
* ->node_page
|
|
|
|
|
* update block addresses in the node page
|
|
|
|
|
*/
|
f2fs: clean up symbol namespace
As Ted reported:
"Hi, I was looking at f2fs's sources recently, and I noticed that there
is a very large number of non-static symbols which don't have a f2fs
prefix. There's well over a hundred (see attached below).
As one example, in fs/f2fs/dir.c there is:
unsigned char get_de_type(struct f2fs_dir_entry *de)
This function is clearly only useful for f2fs, but it has a generic
name. This means that if any other file system tries to have the same
symbol name, there will be a symbol conflict and the kernel would not
successfully build. It also means that when someone is looking f2fs
sources, it's not at all obvious whether a function such as
read_data_page(), invalidate_blocks(), is a generic kernel function
found in the fs, mm, or block layers, or a f2fs specific function.
You might want to fix this at some point. Hopefully Kent's bcachefs
isn't similarly using genericly named functions, since that might
cause conflicts with f2fs's functions --- but just as this would be a
problem that we would rightly insist that Kent fix, this is something
that we should have rightly insisted that f2fs should have fixed
before it was integrated into the mainline kernel.
acquire_orphan_inode
add_ino_entry
add_orphan_inode
allocate_data_block
allocate_new_segments
alloc_nid
alloc_nid_done
alloc_nid_failed
available_free_memory
...."
This patch adds "f2fs_" prefix for all non-static symbols in order to:
a) avoid conflict with other kernel generic symbols;
b) to indicate the function is f2fs specific one instead of generic
one;
Reported-by: Theodore Ts'o <tytso@mit.edu>
Signed-off-by: Chao Yu <yuchao0@huawei.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2018-05-30 00:20:41 +08:00
|
|
|
void f2fs_set_data_blkaddr(struct dnode_of_data *dn)
|
2012-11-02 16:10:12 +08:00
|
|
|
{
|
2016-05-09 19:56:30 +08:00
|
|
|
f2fs_wait_on_page_writeback(dn->node_page, NODE, true);
|
|
|
|
|
__set_data_blkaddr(dn);
|
|
|
|
|
if (set_page_dirty(dn->node_page))
|
2016-01-08 05:23:12 +08:00
|
|
|
dn->node_changed = true;
|
2012-11-02 16:10:12 +08:00
|
|
|
}
|
|
|
|
|
|
2016-02-24 17:16:47 +08:00
|
|
|
void f2fs_update_data_blkaddr(struct dnode_of_data *dn, block_t blkaddr)
|
|
|
|
|
{
|
|
|
|
|
dn->data_blkaddr = blkaddr;
|
f2fs: clean up symbol namespace
As Ted reported:
"Hi, I was looking at f2fs's sources recently, and I noticed that there
is a very large number of non-static symbols which don't have a f2fs
prefix. There's well over a hundred (see attached below).
As one example, in fs/f2fs/dir.c there is:
unsigned char get_de_type(struct f2fs_dir_entry *de)
This function is clearly only useful for f2fs, but it has a generic
name. This means that if any other file system tries to have the same
symbol name, there will be a symbol conflict and the kernel would not
successfully build. It also means that when someone is looking f2fs
sources, it's not at all obvious whether a function such as
read_data_page(), invalidate_blocks(), is a generic kernel function
found in the fs, mm, or block layers, or a f2fs specific function.
You might want to fix this at some point. Hopefully Kent's bcachefs
isn't similarly using genericly named functions, since that might
cause conflicts with f2fs's functions --- but just as this would be a
problem that we would rightly insist that Kent fix, this is something
that we should have rightly insisted that f2fs should have fixed
before it was integrated into the mainline kernel.
acquire_orphan_inode
add_ino_entry
add_orphan_inode
allocate_data_block
allocate_new_segments
alloc_nid
alloc_nid_done
alloc_nid_failed
available_free_memory
...."
This patch adds "f2fs_" prefix for all non-static symbols in order to:
a) avoid conflict with other kernel generic symbols;
b) to indicate the function is f2fs specific one instead of generic
one;
Reported-by: Theodore Ts'o <tytso@mit.edu>
Signed-off-by: Chao Yu <yuchao0@huawei.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2018-05-30 00:20:41 +08:00
|
|
|
f2fs_set_data_blkaddr(dn);
|
2016-02-24 17:16:47 +08:00
|
|
|
f2fs_update_extent_cache(dn);
|
|
|
|
|
}
|
|
|
|
|
|
2016-05-09 19:56:30 +08:00
|
|
|
/* dn->ofs_in_node will be returned with up-to-date last block pointer */
|
f2fs: clean up symbol namespace
As Ted reported:
"Hi, I was looking at f2fs's sources recently, and I noticed that there
is a very large number of non-static symbols which don't have a f2fs
prefix. There's well over a hundred (see attached below).
As one example, in fs/f2fs/dir.c there is:
unsigned char get_de_type(struct f2fs_dir_entry *de)
This function is clearly only useful for f2fs, but it has a generic
name. This means that if any other file system tries to have the same
symbol name, there will be a symbol conflict and the kernel would not
successfully build. It also means that when someone is looking f2fs
sources, it's not at all obvious whether a function such as
read_data_page(), invalidate_blocks(), is a generic kernel function
found in the fs, mm, or block layers, or a f2fs specific function.
You might want to fix this at some point. Hopefully Kent's bcachefs
isn't similarly using genericly named functions, since that might
cause conflicts with f2fs's functions --- but just as this would be a
problem that we would rightly insist that Kent fix, this is something
that we should have rightly insisted that f2fs should have fixed
before it was integrated into the mainline kernel.
acquire_orphan_inode
add_ino_entry
add_orphan_inode
allocate_data_block
allocate_new_segments
alloc_nid
alloc_nid_done
alloc_nid_failed
available_free_memory
...."
This patch adds "f2fs_" prefix for all non-static symbols in order to:
a) avoid conflict with other kernel generic symbols;
b) to indicate the function is f2fs specific one instead of generic
one;
Reported-by: Theodore Ts'o <tytso@mit.edu>
Signed-off-by: Chao Yu <yuchao0@huawei.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2018-05-30 00:20:41 +08:00
|
|
|
int f2fs_reserve_new_blocks(struct dnode_of_data *dn, blkcnt_t count)
|
2012-11-02 16:10:12 +08:00
|
|
|
{
|
2014-09-03 06:31:18 +08:00
|
|
|
struct f2fs_sb_info *sbi = F2FS_I_SB(dn->inode);
|
2017-07-09 00:13:07 +08:00
|
|
|
int err;
|
2012-11-02 16:10:12 +08:00
|
|
|
|
2016-05-09 19:56:30 +08:00
|
|
|
if (!count)
|
|
|
|
|
return 0;
|
|
|
|
|
|
2016-05-21 01:13:22 +08:00
|
|
|
if (unlikely(is_inode_flag_set(dn->inode, FI_NO_ALLOC)))
|
2012-11-02 16:10:12 +08:00
|
|
|
return -EPERM;
|
2017-07-09 00:13:07 +08:00
|
|
|
if (unlikely((err = inc_valid_block_count(sbi, dn->inode, &count))))
|
|
|
|
|
return err;
|
2012-11-02 16:10:12 +08:00
|
|
|
|
2016-05-09 19:56:30 +08:00
|
|
|
trace_f2fs_reserve_new_blocks(dn->inode, dn->nid,
|
|
|
|
|
dn->ofs_in_node, count);
|
|
|
|
|
|
|
|
|
|
f2fs_wait_on_page_writeback(dn->node_page, NODE, true);
|
|
|
|
|
|
|
|
|
|
for (; count > 0; dn->ofs_in_node++) {
|
2017-07-19 00:19:06 +08:00
|
|
|
block_t blkaddr = datablock_addr(dn->inode,
|
|
|
|
|
dn->node_page, dn->ofs_in_node);
|
2016-05-09 19:56:30 +08:00
|
|
|
if (blkaddr == NULL_ADDR) {
|
|
|
|
|
dn->data_blkaddr = NEW_ADDR;
|
|
|
|
|
__set_data_blkaddr(dn);
|
|
|
|
|
count--;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (set_page_dirty(dn->node_page))
|
|
|
|
|
dn->node_changed = true;
|
2012-11-02 16:10:12 +08:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2016-05-09 19:56:30 +08:00
|
|
|
/* Should keep dn->ofs_in_node unchanged */
|
f2fs: clean up symbol namespace
As Ted reported:
"Hi, I was looking at f2fs's sources recently, and I noticed that there
is a very large number of non-static symbols which don't have a f2fs
prefix. There's well over a hundred (see attached below).
As one example, in fs/f2fs/dir.c there is:
unsigned char get_de_type(struct f2fs_dir_entry *de)
This function is clearly only useful for f2fs, but it has a generic
name. This means that if any other file system tries to have the same
symbol name, there will be a symbol conflict and the kernel would not
successfully build. It also means that when someone is looking f2fs
sources, it's not at all obvious whether a function such as
read_data_page(), invalidate_blocks(), is a generic kernel function
found in the fs, mm, or block layers, or a f2fs specific function.
You might want to fix this at some point. Hopefully Kent's bcachefs
isn't similarly using genericly named functions, since that might
cause conflicts with f2fs's functions --- but just as this would be a
problem that we would rightly insist that Kent fix, this is something
that we should have rightly insisted that f2fs should have fixed
before it was integrated into the mainline kernel.
acquire_orphan_inode
add_ino_entry
add_orphan_inode
allocate_data_block
allocate_new_segments
alloc_nid
alloc_nid_done
alloc_nid_failed
available_free_memory
...."
This patch adds "f2fs_" prefix for all non-static symbols in order to:
a) avoid conflict with other kernel generic symbols;
b) to indicate the function is f2fs specific one instead of generic
one;
Reported-by: Theodore Ts'o <tytso@mit.edu>
Signed-off-by: Chao Yu <yuchao0@huawei.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2018-05-30 00:20:41 +08:00
|
|
|
int f2fs_reserve_new_block(struct dnode_of_data *dn)
|
2016-05-09 19:56:30 +08:00
|
|
|
{
|
|
|
|
|
unsigned int ofs_in_node = dn->ofs_in_node;
|
|
|
|
|
int ret;
|
|
|
|
|
|
f2fs: clean up symbol namespace
As Ted reported:
"Hi, I was looking at f2fs's sources recently, and I noticed that there
is a very large number of non-static symbols which don't have a f2fs
prefix. There's well over a hundred (see attached below).
As one example, in fs/f2fs/dir.c there is:
unsigned char get_de_type(struct f2fs_dir_entry *de)
This function is clearly only useful for f2fs, but it has a generic
name. This means that if any other file system tries to have the same
symbol name, there will be a symbol conflict and the kernel would not
successfully build. It also means that when someone is looking f2fs
sources, it's not at all obvious whether a function such as
read_data_page(), invalidate_blocks(), is a generic kernel function
found in the fs, mm, or block layers, or a f2fs specific function.
You might want to fix this at some point. Hopefully Kent's bcachefs
isn't similarly using genericly named functions, since that might
cause conflicts with f2fs's functions --- but just as this would be a
problem that we would rightly insist that Kent fix, this is something
that we should have rightly insisted that f2fs should have fixed
before it was integrated into the mainline kernel.
acquire_orphan_inode
add_ino_entry
add_orphan_inode
allocate_data_block
allocate_new_segments
alloc_nid
alloc_nid_done
alloc_nid_failed
available_free_memory
...."
This patch adds "f2fs_" prefix for all non-static symbols in order to:
a) avoid conflict with other kernel generic symbols;
b) to indicate the function is f2fs specific one instead of generic
one;
Reported-by: Theodore Ts'o <tytso@mit.edu>
Signed-off-by: Chao Yu <yuchao0@huawei.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2018-05-30 00:20:41 +08:00
|
|
|
ret = f2fs_reserve_new_blocks(dn, 1);
|
2016-05-09 19:56:30 +08:00
|
|
|
dn->ofs_in_node = ofs_in_node;
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2013-11-10 23:13:18 +08:00
|
|
|
int f2fs_reserve_block(struct dnode_of_data *dn, pgoff_t index)
|
|
|
|
|
{
|
|
|
|
|
bool need_put = dn->inode_page ? false : true;
|
|
|
|
|
int err;
|
|
|
|
|
|
f2fs: clean up symbol namespace
As Ted reported:
"Hi, I was looking at f2fs's sources recently, and I noticed that there
is a very large number of non-static symbols which don't have a f2fs
prefix. There's well over a hundred (see attached below).
As one example, in fs/f2fs/dir.c there is:
unsigned char get_de_type(struct f2fs_dir_entry *de)
This function is clearly only useful for f2fs, but it has a generic
name. This means that if any other file system tries to have the same
symbol name, there will be a symbol conflict and the kernel would not
successfully build. It also means that when someone is looking f2fs
sources, it's not at all obvious whether a function such as
read_data_page(), invalidate_blocks(), is a generic kernel function
found in the fs, mm, or block layers, or a f2fs specific function.
You might want to fix this at some point. Hopefully Kent's bcachefs
isn't similarly using genericly named functions, since that might
cause conflicts with f2fs's functions --- but just as this would be a
problem that we would rightly insist that Kent fix, this is something
that we should have rightly insisted that f2fs should have fixed
before it was integrated into the mainline kernel.
acquire_orphan_inode
add_ino_entry
add_orphan_inode
allocate_data_block
allocate_new_segments
alloc_nid
alloc_nid_done
alloc_nid_failed
available_free_memory
...."
This patch adds "f2fs_" prefix for all non-static symbols in order to:
a) avoid conflict with other kernel generic symbols;
b) to indicate the function is f2fs specific one instead of generic
one;
Reported-by: Theodore Ts'o <tytso@mit.edu>
Signed-off-by: Chao Yu <yuchao0@huawei.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2018-05-30 00:20:41 +08:00
|
|
|
err = f2fs_get_dnode_of_data(dn, index, ALLOC_NODE);
|
2013-11-10 23:13:18 +08:00
|
|
|
if (err)
|
|
|
|
|
return err;
|
2013-12-27 16:04:17 +08:00
|
|
|
|
2013-11-10 23:13:18 +08:00
|
|
|
if (dn->data_blkaddr == NULL_ADDR)
|
f2fs: clean up symbol namespace
As Ted reported:
"Hi, I was looking at f2fs's sources recently, and I noticed that there
is a very large number of non-static symbols which don't have a f2fs
prefix. There's well over a hundred (see attached below).
As one example, in fs/f2fs/dir.c there is:
unsigned char get_de_type(struct f2fs_dir_entry *de)
This function is clearly only useful for f2fs, but it has a generic
name. This means that if any other file system tries to have the same
symbol name, there will be a symbol conflict and the kernel would not
successfully build. It also means that when someone is looking f2fs
sources, it's not at all obvious whether a function such as
read_data_page(), invalidate_blocks(), is a generic kernel function
found in the fs, mm, or block layers, or a f2fs specific function.
You might want to fix this at some point. Hopefully Kent's bcachefs
isn't similarly using genericly named functions, since that might
cause conflicts with f2fs's functions --- but just as this would be a
problem that we would rightly insist that Kent fix, this is something
that we should have rightly insisted that f2fs should have fixed
before it was integrated into the mainline kernel.
acquire_orphan_inode
add_ino_entry
add_orphan_inode
allocate_data_block
allocate_new_segments
alloc_nid
alloc_nid_done
alloc_nid_failed
available_free_memory
...."
This patch adds "f2fs_" prefix for all non-static symbols in order to:
a) avoid conflict with other kernel generic symbols;
b) to indicate the function is f2fs specific one instead of generic
one;
Reported-by: Theodore Ts'o <tytso@mit.edu>
Signed-off-by: Chao Yu <yuchao0@huawei.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2018-05-30 00:20:41 +08:00
|
|
|
err = f2fs_reserve_new_block(dn);
|
2013-12-27 16:04:17 +08:00
|
|
|
if (err || need_put)
|
2013-11-10 23:13:18 +08:00
|
|
|
f2fs_put_dnode(dn);
|
|
|
|
|
return err;
|
|
|
|
|
}
|
|
|
|
|
|
2015-08-05 15:52:16 +08:00
|
|
|
int f2fs_get_block(struct dnode_of_data *dn, pgoff_t index)
|
2012-11-02 16:10:12 +08:00
|
|
|
{
|
2017-02-23 17:18:05 +08:00
|
|
|
struct extent_info ei = {0,0,0};
|
2015-08-05 15:52:16 +08:00
|
|
|
struct inode *inode = dn->inode;
|
2015-03-19 19:26:02 +08:00
|
|
|
|
2015-08-05 15:52:16 +08:00
|
|
|
if (f2fs_lookup_extent_cache(inode, index, &ei)) {
|
|
|
|
|
dn->data_blkaddr = ei.blk + index - ei.fofs;
|
|
|
|
|
return 0;
|
2015-02-05 17:54:31 +08:00
|
|
|
}
|
2015-03-19 19:26:02 +08:00
|
|
|
|
2015-08-05 15:52:16 +08:00
|
|
|
return f2fs_reserve_block(dn, index);
|
2012-11-02 16:10:12 +08:00
|
|
|
}
|
|
|
|
|
|
f2fs: clean up symbol namespace
As Ted reported:
"Hi, I was looking at f2fs's sources recently, and I noticed that there
is a very large number of non-static symbols which don't have a f2fs
prefix. There's well over a hundred (see attached below).
As one example, in fs/f2fs/dir.c there is:
unsigned char get_de_type(struct f2fs_dir_entry *de)
This function is clearly only useful for f2fs, but it has a generic
name. This means that if any other file system tries to have the same
symbol name, there will be a symbol conflict and the kernel would not
successfully build. It also means that when someone is looking f2fs
sources, it's not at all obvious whether a function such as
read_data_page(), invalidate_blocks(), is a generic kernel function
found in the fs, mm, or block layers, or a f2fs specific function.
You might want to fix this at some point. Hopefully Kent's bcachefs
isn't similarly using genericly named functions, since that might
cause conflicts with f2fs's functions --- but just as this would be a
problem that we would rightly insist that Kent fix, this is something
that we should have rightly insisted that f2fs should have fixed
before it was integrated into the mainline kernel.
acquire_orphan_inode
add_ino_entry
add_orphan_inode
allocate_data_block
allocate_new_segments
alloc_nid
alloc_nid_done
alloc_nid_failed
available_free_memory
...."
This patch adds "f2fs_" prefix for all non-static symbols in order to:
a) avoid conflict with other kernel generic symbols;
b) to indicate the function is f2fs specific one instead of generic
one;
Reported-by: Theodore Ts'o <tytso@mit.edu>
Signed-off-by: Chao Yu <yuchao0@huawei.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2018-05-30 00:20:41 +08:00
|
|
|
struct page *f2fs_get_read_data_page(struct inode *inode, pgoff_t index,
|
2016-06-06 03:31:55 +08:00
|
|
|
int op_flags, bool for_write)
|
2012-11-02 16:10:12 +08:00
|
|
|
{
|
|
|
|
|
struct address_space *mapping = inode->i_mapping;
|
|
|
|
|
struct dnode_of_data dn;
|
|
|
|
|
struct page *page;
|
2017-02-23 17:18:05 +08:00
|
|
|
struct extent_info ei = {0,0,0};
|
2012-11-02 16:10:12 +08:00
|
|
|
int err;
|
2015-04-24 03:04:33 +08:00
|
|
|
|
2015-10-10 06:11:38 +08:00
|
|
|
page = f2fs_grab_cache_page(mapping, index, for_write);
|
2013-05-13 07:38:35 +08:00
|
|
|
if (!page)
|
|
|
|
|
return ERR_PTR(-ENOMEM);
|
|
|
|
|
|
2015-02-05 18:03:40 +08:00
|
|
|
if (f2fs_lookup_extent_cache(inode, index, &ei)) {
|
|
|
|
|
dn.data_blkaddr = ei.blk + index - ei.fofs;
|
|
|
|
|
goto got_it;
|
|
|
|
|
}
|
|
|
|
|
|
2012-11-02 16:10:12 +08:00
|
|
|
set_new_dnode(&dn, inode, NULL, NULL, 0);
|
f2fs: clean up symbol namespace
As Ted reported:
"Hi, I was looking at f2fs's sources recently, and I noticed that there
is a very large number of non-static symbols which don't have a f2fs
prefix. There's well over a hundred (see attached below).
As one example, in fs/f2fs/dir.c there is:
unsigned char get_de_type(struct f2fs_dir_entry *de)
This function is clearly only useful for f2fs, but it has a generic
name. This means that if any other file system tries to have the same
symbol name, there will be a symbol conflict and the kernel would not
successfully build. It also means that when someone is looking f2fs
sources, it's not at all obvious whether a function such as
read_data_page(), invalidate_blocks(), is a generic kernel function
found in the fs, mm, or block layers, or a f2fs specific function.
You might want to fix this at some point. Hopefully Kent's bcachefs
isn't similarly using genericly named functions, since that might
cause conflicts with f2fs's functions --- but just as this would be a
problem that we would rightly insist that Kent fix, this is something
that we should have rightly insisted that f2fs should have fixed
before it was integrated into the mainline kernel.
acquire_orphan_inode
add_ino_entry
add_orphan_inode
allocate_data_block
allocate_new_segments
alloc_nid
alloc_nid_done
alloc_nid_failed
available_free_memory
...."
This patch adds "f2fs_" prefix for all non-static symbols in order to:
a) avoid conflict with other kernel generic symbols;
b) to indicate the function is f2fs specific one instead of generic
one;
Reported-by: Theodore Ts'o <tytso@mit.edu>
Signed-off-by: Chao Yu <yuchao0@huawei.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2018-05-30 00:20:41 +08:00
|
|
|
err = f2fs_get_dnode_of_data(&dn, index, LOOKUP_NODE);
|
2015-07-16 04:08:21 +08:00
|
|
|
if (err)
|
|
|
|
|
goto put_err;
|
2012-11-02 16:10:12 +08:00
|
|
|
f2fs_put_dnode(&dn);
|
|
|
|
|
|
2013-12-06 14:00:58 +08:00
|
|
|
if (unlikely(dn.data_blkaddr == NULL_ADDR)) {
|
2015-07-16 04:08:21 +08:00
|
|
|
err = -ENOENT;
|
|
|
|
|
goto put_err;
|
2013-05-13 07:38:35 +08:00
|
|
|
}
|
2015-02-05 18:03:40 +08:00
|
|
|
got_it:
|
2015-05-01 08:00:33 +08:00
|
|
|
if (PageUptodate(page)) {
|
|
|
|
|
unlock_page(page);
|
2012-11-02 16:10:12 +08:00
|
|
|
return page;
|
2015-05-01 08:00:33 +08:00
|
|
|
}
|
2012-11-02 16:10:12 +08:00
|
|
|
|
2013-08-20 18:13:07 +08:00
|
|
|
/*
|
|
|
|
|
* A new dentry page is allocated but not able to be written, since its
|
|
|
|
|
* new inode page couldn't be allocated due to -ENOSPC.
|
|
|
|
|
* In such the case, its blkaddr can be remained as NEW_ADDR.
|
f2fs: clean up symbol namespace
As Ted reported:
"Hi, I was looking at f2fs's sources recently, and I noticed that there
is a very large number of non-static symbols which don't have a f2fs
prefix. There's well over a hundred (see attached below).
As one example, in fs/f2fs/dir.c there is:
unsigned char get_de_type(struct f2fs_dir_entry *de)
This function is clearly only useful for f2fs, but it has a generic
name. This means that if any other file system tries to have the same
symbol name, there will be a symbol conflict and the kernel would not
successfully build. It also means that when someone is looking f2fs
sources, it's not at all obvious whether a function such as
read_data_page(), invalidate_blocks(), is a generic kernel function
found in the fs, mm, or block layers, or a f2fs specific function.
You might want to fix this at some point. Hopefully Kent's bcachefs
isn't similarly using genericly named functions, since that might
cause conflicts with f2fs's functions --- but just as this would be a
problem that we would rightly insist that Kent fix, this is something
that we should have rightly insisted that f2fs should have fixed
before it was integrated into the mainline kernel.
acquire_orphan_inode
add_ino_entry
add_orphan_inode
allocate_data_block
allocate_new_segments
alloc_nid
alloc_nid_done
alloc_nid_failed
available_free_memory
...."
This patch adds "f2fs_" prefix for all non-static symbols in order to:
a) avoid conflict with other kernel generic symbols;
b) to indicate the function is f2fs specific one instead of generic
one;
Reported-by: Theodore Ts'o <tytso@mit.edu>
Signed-off-by: Chao Yu <yuchao0@huawei.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2018-05-30 00:20:41 +08:00
|
|
|
* see, f2fs_add_link -> f2fs_get_new_data_page ->
|
|
|
|
|
* f2fs_init_inode_metadata.
|
2013-08-20 18:13:07 +08:00
|
|
|
*/
|
|
|
|
|
if (dn.data_blkaddr == NEW_ADDR) {
|
mm, fs: get rid of PAGE_CACHE_* and page_cache_{get,release} macros
PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} macros were introduced *long* time
ago with promise that one day it will be possible to implement page
cache with bigger chunks than PAGE_SIZE.
This promise never materialized. And unlikely will.
We have many places where PAGE_CACHE_SIZE assumed to be equal to
PAGE_SIZE. And it's constant source of confusion on whether
PAGE_CACHE_* or PAGE_* constant should be used in a particular case,
especially on the border between fs and mm.
Global switching to PAGE_CACHE_SIZE != PAGE_SIZE would cause to much
breakage to be doable.
Let's stop pretending that pages in page cache are special. They are
not.
The changes are pretty straight-forward:
- <foo> << (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- <foo> >> (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} -> PAGE_{SIZE,SHIFT,MASK,ALIGN};
- page_cache_get() -> get_page();
- page_cache_release() -> put_page();
This patch contains automated changes generated with coccinelle using
script below. For some reason, coccinelle doesn't patch header files.
I've called spatch for them manually.
The only adjustment after coccinelle is revert of changes to
PAGE_CAHCE_ALIGN definition: we are going to drop it later.
There are few places in the code where coccinelle didn't reach. I'll
fix them manually in a separate patch. Comments and documentation also
will be addressed with the separate patch.
virtual patch
@@
expression E;
@@
- E << (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
expression E;
@@
- E >> (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
@@
- PAGE_CACHE_SHIFT
+ PAGE_SHIFT
@@
@@
- PAGE_CACHE_SIZE
+ PAGE_SIZE
@@
@@
- PAGE_CACHE_MASK
+ PAGE_MASK
@@
expression E;
@@
- PAGE_CACHE_ALIGN(E)
+ PAGE_ALIGN(E)
@@
expression E;
@@
- page_cache_get(E)
+ get_page(E)
@@
expression E;
@@
- page_cache_release(E)
+ put_page(E)
Signed-off-by: Kirill A. Shutemov <kirill.shutemov@linux.intel.com>
Acked-by: Michal Hocko <mhocko@suse.com>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2016-04-01 20:29:47 +08:00
|
|
|
zero_user_segment(page, 0, PAGE_SIZE);
|
2016-07-01 09:49:15 +08:00
|
|
|
if (!PageUptodate(page))
|
|
|
|
|
SetPageUptodate(page);
|
2015-05-01 08:00:33 +08:00
|
|
|
unlock_page(page);
|
2013-08-20 18:13:07 +08:00
|
|
|
return page;
|
|
|
|
|
}
|
2012-11-02 16:10:12 +08:00
|
|
|
|
2017-09-07 12:04:44 +08:00
|
|
|
err = f2fs_submit_page_read(inode, page, dn.data_blkaddr);
|
2013-03-08 20:29:23 +08:00
|
|
|
if (err)
|
2015-07-16 04:08:21 +08:00
|
|
|
goto put_err;
|
2015-05-01 08:00:33 +08:00
|
|
|
return page;
|
2015-07-16 04:08:21 +08:00
|
|
|
|
|
|
|
|
put_err:
|
|
|
|
|
f2fs_put_page(page, 1);
|
|
|
|
|
return ERR_PTR(err);
|
2015-05-01 08:00:33 +08:00
|
|
|
}
|
|
|
|
|
|
f2fs: clean up symbol namespace
As Ted reported:
"Hi, I was looking at f2fs's sources recently, and I noticed that there
is a very large number of non-static symbols which don't have a f2fs
prefix. There's well over a hundred (see attached below).
As one example, in fs/f2fs/dir.c there is:
unsigned char get_de_type(struct f2fs_dir_entry *de)
This function is clearly only useful for f2fs, but it has a generic
name. This means that if any other file system tries to have the same
symbol name, there will be a symbol conflict and the kernel would not
successfully build. It also means that when someone is looking f2fs
sources, it's not at all obvious whether a function such as
read_data_page(), invalidate_blocks(), is a generic kernel function
found in the fs, mm, or block layers, or a f2fs specific function.
You might want to fix this at some point. Hopefully Kent's bcachefs
isn't similarly using genericly named functions, since that might
cause conflicts with f2fs's functions --- but just as this would be a
problem that we would rightly insist that Kent fix, this is something
that we should have rightly insisted that f2fs should have fixed
before it was integrated into the mainline kernel.
acquire_orphan_inode
add_ino_entry
add_orphan_inode
allocate_data_block
allocate_new_segments
alloc_nid
alloc_nid_done
alloc_nid_failed
available_free_memory
...."
This patch adds "f2fs_" prefix for all non-static symbols in order to:
a) avoid conflict with other kernel generic symbols;
b) to indicate the function is f2fs specific one instead of generic
one;
Reported-by: Theodore Ts'o <tytso@mit.edu>
Signed-off-by: Chao Yu <yuchao0@huawei.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2018-05-30 00:20:41 +08:00
|
|
|
struct page *f2fs_find_data_page(struct inode *inode, pgoff_t index)
|
2015-05-01 08:00:33 +08:00
|
|
|
{
|
|
|
|
|
struct address_space *mapping = inode->i_mapping;
|
|
|
|
|
struct page *page;
|
|
|
|
|
|
|
|
|
|
page = find_get_page(mapping, index);
|
|
|
|
|
if (page && PageUptodate(page))
|
|
|
|
|
return page;
|
|
|
|
|
f2fs_put_page(page, 0);
|
|
|
|
|
|
f2fs: clean up symbol namespace
As Ted reported:
"Hi, I was looking at f2fs's sources recently, and I noticed that there
is a very large number of non-static symbols which don't have a f2fs
prefix. There's well over a hundred (see attached below).
As one example, in fs/f2fs/dir.c there is:
unsigned char get_de_type(struct f2fs_dir_entry *de)
This function is clearly only useful for f2fs, but it has a generic
name. This means that if any other file system tries to have the same
symbol name, there will be a symbol conflict and the kernel would not
successfully build. It also means that when someone is looking f2fs
sources, it's not at all obvious whether a function such as
read_data_page(), invalidate_blocks(), is a generic kernel function
found in the fs, mm, or block layers, or a f2fs specific function.
You might want to fix this at some point. Hopefully Kent's bcachefs
isn't similarly using genericly named functions, since that might
cause conflicts with f2fs's functions --- but just as this would be a
problem that we would rightly insist that Kent fix, this is something
that we should have rightly insisted that f2fs should have fixed
before it was integrated into the mainline kernel.
acquire_orphan_inode
add_ino_entry
add_orphan_inode
allocate_data_block
allocate_new_segments
alloc_nid
alloc_nid_done
alloc_nid_failed
available_free_memory
...."
This patch adds "f2fs_" prefix for all non-static symbols in order to:
a) avoid conflict with other kernel generic symbols;
b) to indicate the function is f2fs specific one instead of generic
one;
Reported-by: Theodore Ts'o <tytso@mit.edu>
Signed-off-by: Chao Yu <yuchao0@huawei.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2018-05-30 00:20:41 +08:00
|
|
|
page = f2fs_get_read_data_page(inode, index, 0, false);
|
2015-05-01 08:00:33 +08:00
|
|
|
if (IS_ERR(page))
|
|
|
|
|
return page;
|
|
|
|
|
|
|
|
|
|
if (PageUptodate(page))
|
|
|
|
|
return page;
|
|
|
|
|
|
|
|
|
|
wait_on_page_locked(page);
|
|
|
|
|
if (unlikely(!PageUptodate(page))) {
|
|
|
|
|
f2fs_put_page(page, 0);
|
|
|
|
|
return ERR_PTR(-EIO);
|
|
|
|
|
}
|
|
|
|
|
return page;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* If it tries to access a hole, return an error.
|
|
|
|
|
* Because, the callers, functions in dir.c and GC, should be able to know
|
|
|
|
|
* whether this page exists or not.
|
|
|
|
|
*/
|
f2fs: clean up symbol namespace
As Ted reported:
"Hi, I was looking at f2fs's sources recently, and I noticed that there
is a very large number of non-static symbols which don't have a f2fs
prefix. There's well over a hundred (see attached below).
As one example, in fs/f2fs/dir.c there is:
unsigned char get_de_type(struct f2fs_dir_entry *de)
This function is clearly only useful for f2fs, but it has a generic
name. This means that if any other file system tries to have the same
symbol name, there will be a symbol conflict and the kernel would not
successfully build. It also means that when someone is looking f2fs
sources, it's not at all obvious whether a function such as
read_data_page(), invalidate_blocks(), is a generic kernel function
found in the fs, mm, or block layers, or a f2fs specific function.
You might want to fix this at some point. Hopefully Kent's bcachefs
isn't similarly using genericly named functions, since that might
cause conflicts with f2fs's functions --- but just as this would be a
problem that we would rightly insist that Kent fix, this is something
that we should have rightly insisted that f2fs should have fixed
before it was integrated into the mainline kernel.
acquire_orphan_inode
add_ino_entry
add_orphan_inode
allocate_data_block
allocate_new_segments
alloc_nid
alloc_nid_done
alloc_nid_failed
available_free_memory
...."
This patch adds "f2fs_" prefix for all non-static symbols in order to:
a) avoid conflict with other kernel generic symbols;
b) to indicate the function is f2fs specific one instead of generic
one;
Reported-by: Theodore Ts'o <tytso@mit.edu>
Signed-off-by: Chao Yu <yuchao0@huawei.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2018-05-30 00:20:41 +08:00
|
|
|
struct page *f2fs_get_lock_data_page(struct inode *inode, pgoff_t index,
|
2015-10-10 06:11:38 +08:00
|
|
|
bool for_write)
|
2015-05-01 08:00:33 +08:00
|
|
|
{
|
|
|
|
|
struct address_space *mapping = inode->i_mapping;
|
|
|
|
|
struct page *page;
|
|
|
|
|
repeat:
|
f2fs: clean up symbol namespace
As Ted reported:
"Hi, I was looking at f2fs's sources recently, and I noticed that there
is a very large number of non-static symbols which don't have a f2fs
prefix. There's well over a hundred (see attached below).
As one example, in fs/f2fs/dir.c there is:
unsigned char get_de_type(struct f2fs_dir_entry *de)
This function is clearly only useful for f2fs, but it has a generic
name. This means that if any other file system tries to have the same
symbol name, there will be a symbol conflict and the kernel would not
successfully build. It also means that when someone is looking f2fs
sources, it's not at all obvious whether a function such as
read_data_page(), invalidate_blocks(), is a generic kernel function
found in the fs, mm, or block layers, or a f2fs specific function.
You might want to fix this at some point. Hopefully Kent's bcachefs
isn't similarly using genericly named functions, since that might
cause conflicts with f2fs's functions --- but just as this would be a
problem that we would rightly insist that Kent fix, this is something
that we should have rightly insisted that f2fs should have fixed
before it was integrated into the mainline kernel.
acquire_orphan_inode
add_ino_entry
add_orphan_inode
allocate_data_block
allocate_new_segments
alloc_nid
alloc_nid_done
alloc_nid_failed
available_free_memory
...."
This patch adds "f2fs_" prefix for all non-static symbols in order to:
a) avoid conflict with other kernel generic symbols;
b) to indicate the function is f2fs specific one instead of generic
one;
Reported-by: Theodore Ts'o <tytso@mit.edu>
Signed-off-by: Chao Yu <yuchao0@huawei.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2018-05-30 00:20:41 +08:00
|
|
|
page = f2fs_get_read_data_page(inode, index, 0, for_write);
|
2015-05-01 08:00:33 +08:00
|
|
|
if (IS_ERR(page))
|
|
|
|
|
return page;
|
2013-03-08 20:29:23 +08:00
|
|
|
|
2015-05-01 08:00:33 +08:00
|
|
|
/* wait for read completion */
|
2013-03-08 20:29:23 +08:00
|
|
|
lock_page(page);
|
2013-12-06 14:00:58 +08:00
|
|
|
if (unlikely(page->mapping != mapping)) {
|
2013-04-26 10:55:17 +08:00
|
|
|
f2fs_put_page(page, 1);
|
|
|
|
|
goto repeat;
|
2012-11-02 16:10:12 +08:00
|
|
|
}
|
2016-07-03 22:05:12 +08:00
|
|
|
if (unlikely(!PageUptodate(page))) {
|
|
|
|
|
f2fs_put_page(page, 1);
|
|
|
|
|
return ERR_PTR(-EIO);
|
|
|
|
|
}
|
2012-11-02 16:10:12 +08:00
|
|
|
return page;
|
|
|
|
|
}
|
|
|
|
|
|
2012-11-29 12:28:09 +08:00
|
|
|
/*
|
2012-11-02 16:10:12 +08:00
|
|
|
* Caller ensures that this data page is never allocated.
|
|
|
|
|
* A new zero-filled data page is allocated in the page cache.
|
f2fs: introduce a new global lock scheme
In the previous version, f2fs uses global locks according to the usage types,
such as directory operations, block allocation, block write, and so on.
Reference the following lock types in f2fs.h.
enum lock_type {
RENAME, /* for renaming operations */
DENTRY_OPS, /* for directory operations */
DATA_WRITE, /* for data write */
DATA_NEW, /* for data allocation */
DATA_TRUNC, /* for data truncate */
NODE_NEW, /* for node allocation */
NODE_TRUNC, /* for node truncate */
NODE_WRITE, /* for node write */
NR_LOCK_TYPE,
};
In that case, we lose the performance under the multi-threading environment,
since every types of operations must be conducted one at a time.
In order to address the problem, let's share the locks globally with a mutex
array regardless of any types.
So, let users grab a mutex and perform their jobs in parallel as much as
possbile.
For this, I propose a new global lock scheme as follows.
0. Data structure
- f2fs_sb_info -> mutex_lock[NR_GLOBAL_LOCKS]
- f2fs_sb_info -> node_write
1. mutex_lock_op(sbi)
- try to get an avaiable lock from the array.
- returns the index of the gottern lock variable.
2. mutex_unlock_op(sbi, index of the lock)
- unlock the given index of the lock.
3. mutex_lock_all(sbi)
- grab all the locks in the array before the checkpoint.
4. mutex_unlock_all(sbi)
- release all the locks in the array after checkpoint.
5. block_operations()
- call mutex_lock_all()
- sync_dirty_dir_inodes()
- grab node_write
- sync_node_pages()
Note that,
the pairs of mutex_lock_op()/mutex_unlock_op() and
mutex_lock_all()/mutex_unlock_all() should be used together.
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-22 15:21:29 +08:00
|
|
|
*
|
2013-12-21 18:02:14 +08:00
|
|
|
* Also, caller should grab and release a rwsem by calling f2fs_lock_op() and
|
|
|
|
|
* f2fs_unlock_op().
|
2015-07-14 18:14:06 +08:00
|
|
|
* Note that, ipage is set only by make_empty_dir, and if any error occur,
|
|
|
|
|
* ipage should be released by this function.
|
2012-11-02 16:10:12 +08:00
|
|
|
*/
|
f2fs: clean up symbol namespace
As Ted reported:
"Hi, I was looking at f2fs's sources recently, and I noticed that there
is a very large number of non-static symbols which don't have a f2fs
prefix. There's well over a hundred (see attached below).
As one example, in fs/f2fs/dir.c there is:
unsigned char get_de_type(struct f2fs_dir_entry *de)
This function is clearly only useful for f2fs, but it has a generic
name. This means that if any other file system tries to have the same
symbol name, there will be a symbol conflict and the kernel would not
successfully build. It also means that when someone is looking f2fs
sources, it's not at all obvious whether a function such as
read_data_page(), invalidate_blocks(), is a generic kernel function
found in the fs, mm, or block layers, or a f2fs specific function.
You might want to fix this at some point. Hopefully Kent's bcachefs
isn't similarly using genericly named functions, since that might
cause conflicts with f2fs's functions --- but just as this would be a
problem that we would rightly insist that Kent fix, this is something
that we should have rightly insisted that f2fs should have fixed
before it was integrated into the mainline kernel.
acquire_orphan_inode
add_ino_entry
add_orphan_inode
allocate_data_block
allocate_new_segments
alloc_nid
alloc_nid_done
alloc_nid_failed
available_free_memory
...."
This patch adds "f2fs_" prefix for all non-static symbols in order to:
a) avoid conflict with other kernel generic symbols;
b) to indicate the function is f2fs specific one instead of generic
one;
Reported-by: Theodore Ts'o <tytso@mit.edu>
Signed-off-by: Chao Yu <yuchao0@huawei.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2018-05-30 00:20:41 +08:00
|
|
|
struct page *f2fs_get_new_data_page(struct inode *inode,
|
2013-12-27 16:04:17 +08:00
|
|
|
struct page *ipage, pgoff_t index, bool new_i_size)
|
2012-11-02 16:10:12 +08:00
|
|
|
{
|
|
|
|
|
struct address_space *mapping = inode->i_mapping;
|
|
|
|
|
struct page *page;
|
|
|
|
|
struct dnode_of_data dn;
|
|
|
|
|
int err;
|
2016-01-02 14:03:47 +08:00
|
|
|
|
2015-10-10 06:11:38 +08:00
|
|
|
page = f2fs_grab_cache_page(mapping, index, true);
|
2015-07-14 18:14:06 +08:00
|
|
|
if (!page) {
|
|
|
|
|
/*
|
|
|
|
|
* before exiting, we should make sure ipage will be released
|
|
|
|
|
* if any error occur.
|
|
|
|
|
*/
|
|
|
|
|
f2fs_put_page(ipage, 1);
|
2015-04-30 02:18:42 +08:00
|
|
|
return ERR_PTR(-ENOMEM);
|
2015-07-14 18:14:06 +08:00
|
|
|
}
|
2012-11-02 16:10:12 +08:00
|
|
|
|
2013-12-27 16:04:17 +08:00
|
|
|
set_new_dnode(&dn, inode, ipage, NULL, 0);
|
2013-11-10 23:13:18 +08:00
|
|
|
err = f2fs_reserve_block(&dn, index);
|
2015-04-30 02:18:42 +08:00
|
|
|
if (err) {
|
|
|
|
|
f2fs_put_page(page, 1);
|
2012-11-02 16:10:12 +08:00
|
|
|
return ERR_PTR(err);
|
2013-12-27 16:04:17 +08:00
|
|
|
}
|
2015-04-30 02:18:42 +08:00
|
|
|
if (!ipage)
|
|
|
|
|
f2fs_put_dnode(&dn);
|
2012-11-02 16:10:12 +08:00
|
|
|
|
|
|
|
|
if (PageUptodate(page))
|
2015-04-30 02:18:42 +08:00
|
|
|
goto got_it;
|
2012-11-02 16:10:12 +08:00
|
|
|
|
|
|
|
|
if (dn.data_blkaddr == NEW_ADDR) {
|
mm, fs: get rid of PAGE_CACHE_* and page_cache_{get,release} macros
PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} macros were introduced *long* time
ago with promise that one day it will be possible to implement page
cache with bigger chunks than PAGE_SIZE.
This promise never materialized. And unlikely will.
We have many places where PAGE_CACHE_SIZE assumed to be equal to
PAGE_SIZE. And it's constant source of confusion on whether
PAGE_CACHE_* or PAGE_* constant should be used in a particular case,
especially on the border between fs and mm.
Global switching to PAGE_CACHE_SIZE != PAGE_SIZE would cause to much
breakage to be doable.
Let's stop pretending that pages in page cache are special. They are
not.
The changes are pretty straight-forward:
- <foo> << (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- <foo> >> (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} -> PAGE_{SIZE,SHIFT,MASK,ALIGN};
- page_cache_get() -> get_page();
- page_cache_release() -> put_page();
This patch contains automated changes generated with coccinelle using
script below. For some reason, coccinelle doesn't patch header files.
I've called spatch for them manually.
The only adjustment after coccinelle is revert of changes to
PAGE_CAHCE_ALIGN definition: we are going to drop it later.
There are few places in the code where coccinelle didn't reach. I'll
fix them manually in a separate patch. Comments and documentation also
will be addressed with the separate patch.
virtual patch
@@
expression E;
@@
- E << (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
expression E;
@@
- E >> (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
@@
- PAGE_CACHE_SHIFT
+ PAGE_SHIFT
@@
@@
- PAGE_CACHE_SIZE
+ PAGE_SIZE
@@
@@
- PAGE_CACHE_MASK
+ PAGE_MASK
@@
expression E;
@@
- PAGE_CACHE_ALIGN(E)
+ PAGE_ALIGN(E)
@@
expression E;
@@
- page_cache_get(E)
+ get_page(E)
@@
expression E;
@@
- page_cache_release(E)
+ put_page(E)
Signed-off-by: Kirill A. Shutemov <kirill.shutemov@linux.intel.com>
Acked-by: Michal Hocko <mhocko@suse.com>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2016-04-01 20:29:47 +08:00
|
|
|
zero_user_segment(page, 0, PAGE_SIZE);
|
2016-07-01 09:49:15 +08:00
|
|
|
if (!PageUptodate(page))
|
|
|
|
|
SetPageUptodate(page);
|
2012-11-02 16:10:12 +08:00
|
|
|
} else {
|
2015-04-24 03:04:33 +08:00
|
|
|
f2fs_put_page(page, 1);
|
2013-12-27 16:04:17 +08:00
|
|
|
|
2016-01-02 14:03:47 +08:00
|
|
|
/* if ipage exists, blkaddr should be NEW_ADDR */
|
|
|
|
|
f2fs_bug_on(F2FS_I_SB(inode), ipage);
|
f2fs: clean up symbol namespace
As Ted reported:
"Hi, I was looking at f2fs's sources recently, and I noticed that there
is a very large number of non-static symbols which don't have a f2fs
prefix. There's well over a hundred (see attached below).
As one example, in fs/f2fs/dir.c there is:
unsigned char get_de_type(struct f2fs_dir_entry *de)
This function is clearly only useful for f2fs, but it has a generic
name. This means that if any other file system tries to have the same
symbol name, there will be a symbol conflict and the kernel would not
successfully build. It also means that when someone is looking f2fs
sources, it's not at all obvious whether a function such as
read_data_page(), invalidate_blocks(), is a generic kernel function
found in the fs, mm, or block layers, or a f2fs specific function.
You might want to fix this at some point. Hopefully Kent's bcachefs
isn't similarly using genericly named functions, since that might
cause conflicts with f2fs's functions --- but just as this would be a
problem that we would rightly insist that Kent fix, this is something
that we should have rightly insisted that f2fs should have fixed
before it was integrated into the mainline kernel.
acquire_orphan_inode
add_ino_entry
add_orphan_inode
allocate_data_block
allocate_new_segments
alloc_nid
alloc_nid_done
alloc_nid_failed
available_free_memory
...."
This patch adds "f2fs_" prefix for all non-static symbols in order to:
a) avoid conflict with other kernel generic symbols;
b) to indicate the function is f2fs specific one instead of generic
one;
Reported-by: Theodore Ts'o <tytso@mit.edu>
Signed-off-by: Chao Yu <yuchao0@huawei.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2018-05-30 00:20:41 +08:00
|
|
|
page = f2fs_get_lock_data_page(inode, index, true);
|
2015-04-24 03:04:33 +08:00
|
|
|
if (IS_ERR(page))
|
2016-01-02 14:03:47 +08:00
|
|
|
return page;
|
2012-11-02 16:10:12 +08:00
|
|
|
}
|
2015-04-30 02:18:42 +08:00
|
|
|
got_it:
|
2015-09-11 14:43:52 +08:00
|
|
|
if (new_i_size && i_size_read(inode) <
|
2016-05-21 07:32:49 +08:00
|
|
|
((loff_t)(index + 1) << PAGE_SHIFT))
|
2016-05-21 00:22:03 +08:00
|
|
|
f2fs_i_size_write(inode, ((loff_t)(index + 1) << PAGE_SHIFT));
|
2012-11-02 16:10:12 +08:00
|
|
|
return page;
|
|
|
|
|
}
|
|
|
|
|
|
2017-11-28 08:23:00 +08:00
|
|
|
static int __allocate_data_block(struct dnode_of_data *dn, int seg_type)
|
2013-12-16 18:04:05 +08:00
|
|
|
{
|
2014-09-03 06:31:18 +08:00
|
|
|
struct f2fs_sb_info *sbi = F2FS_I_SB(dn->inode);
|
2013-12-16 18:04:05 +08:00
|
|
|
struct f2fs_summary sum;
|
|
|
|
|
struct node_info ni;
|
2014-09-16 10:32:16 +08:00
|
|
|
pgoff_t fofs;
|
2016-05-09 19:56:30 +08:00
|
|
|
blkcnt_t count = 1;
|
2017-07-09 00:13:07 +08:00
|
|
|
int err;
|
2013-12-16 18:04:05 +08:00
|
|
|
|
2016-05-21 01:13:22 +08:00
|
|
|
if (unlikely(is_inode_flag_set(dn->inode, FI_NO_ALLOC)))
|
2013-12-16 18:04:05 +08:00
|
|
|
return -EPERM;
|
f2fs: preallocate fallocated blocks for direct IO
Normally, due to DIO_SKIP_HOLES flag is set by default, blockdev_direct_IO in
f2fs_direct_IO tries to skip DIO in holes when writing inside i_size, this
makes us falling back to buffered IO which shows lower performance.
So in commit 59b802e5a453 ("f2fs: allocate data blocks in advance for
f2fs_direct_IO"), we improve perfromance by allocating data blocks in advance
if we meet holes no matter in i_size or not, since with it we can avoid falling
back to buffered IO.
But we forget to consider for unwritten fallocated block in this commit.
This patch tries to fix it for fallocate case, this helps to improve
performance.
Test result:
Storage info: sandisk ultra 64G micro sd card.
touch /mnt/f2fs/file
truncate -s 67108864 /mnt/f2fs/file
fallocate -o 0 -l 67108864 /mnt/f2fs/file
time dd if=/dev/zero of=/mnt/f2fs/file bs=1M count=64 conv=notrunc oflag=direct
Time before applying the patch:
67108864 bytes (67 MB) copied, 36.16 s, 1.9 MB/s
real 0m36.162s
user 0m0.000s
sys 0m0.180s
Time after applying the patch:
67108864 bytes (67 MB) copied, 27.7776 s, 2.4 MB/s
real 0m27.780s
user 0m0.000s
sys 0m0.036s
Signed-off-by: Chao Yu <chao2.yu@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2015-03-23 10:33:37 +08:00
|
|
|
|
2017-07-19 00:19:06 +08:00
|
|
|
dn->data_blkaddr = datablock_addr(dn->inode,
|
|
|
|
|
dn->node_page, dn->ofs_in_node);
|
f2fs: preallocate fallocated blocks for direct IO
Normally, due to DIO_SKIP_HOLES flag is set by default, blockdev_direct_IO in
f2fs_direct_IO tries to skip DIO in holes when writing inside i_size, this
makes us falling back to buffered IO which shows lower performance.
So in commit 59b802e5a453 ("f2fs: allocate data blocks in advance for
f2fs_direct_IO"), we improve perfromance by allocating data blocks in advance
if we meet holes no matter in i_size or not, since with it we can avoid falling
back to buffered IO.
But we forget to consider for unwritten fallocated block in this commit.
This patch tries to fix it for fallocate case, this helps to improve
performance.
Test result:
Storage info: sandisk ultra 64G micro sd card.
touch /mnt/f2fs/file
truncate -s 67108864 /mnt/f2fs/file
fallocate -o 0 -l 67108864 /mnt/f2fs/file
time dd if=/dev/zero of=/mnt/f2fs/file bs=1M count=64 conv=notrunc oflag=direct
Time before applying the patch:
67108864 bytes (67 MB) copied, 36.16 s, 1.9 MB/s
real 0m36.162s
user 0m0.000s
sys 0m0.180s
Time after applying the patch:
67108864 bytes (67 MB) copied, 27.7776 s, 2.4 MB/s
real 0m27.780s
user 0m0.000s
sys 0m0.036s
Signed-off-by: Chao Yu <chao2.yu@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2015-03-23 10:33:37 +08:00
|
|
|
if (dn->data_blkaddr == NEW_ADDR)
|
|
|
|
|
goto alloc;
|
|
|
|
|
|
2017-07-09 00:13:07 +08:00
|
|
|
if (unlikely((err = inc_valid_block_count(sbi, dn->inode, &count))))
|
|
|
|
|
return err;
|
2013-12-16 18:04:05 +08:00
|
|
|
|
f2fs: preallocate fallocated blocks for direct IO
Normally, due to DIO_SKIP_HOLES flag is set by default, blockdev_direct_IO in
f2fs_direct_IO tries to skip DIO in holes when writing inside i_size, this
makes us falling back to buffered IO which shows lower performance.
So in commit 59b802e5a453 ("f2fs: allocate data blocks in advance for
f2fs_direct_IO"), we improve perfromance by allocating data blocks in advance
if we meet holes no matter in i_size or not, since with it we can avoid falling
back to buffered IO.
But we forget to consider for unwritten fallocated block in this commit.
This patch tries to fix it for fallocate case, this helps to improve
performance.
Test result:
Storage info: sandisk ultra 64G micro sd card.
touch /mnt/f2fs/file
truncate -s 67108864 /mnt/f2fs/file
fallocate -o 0 -l 67108864 /mnt/f2fs/file
time dd if=/dev/zero of=/mnt/f2fs/file bs=1M count=64 conv=notrunc oflag=direct
Time before applying the patch:
67108864 bytes (67 MB) copied, 36.16 s, 1.9 MB/s
real 0m36.162s
user 0m0.000s
sys 0m0.180s
Time after applying the patch:
67108864 bytes (67 MB) copied, 27.7776 s, 2.4 MB/s
real 0m27.780s
user 0m0.000s
sys 0m0.036s
Signed-off-by: Chao Yu <chao2.yu@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2015-03-23 10:33:37 +08:00
|
|
|
alloc:
|
f2fs: clean up symbol namespace
As Ted reported:
"Hi, I was looking at f2fs's sources recently, and I noticed that there
is a very large number of non-static symbols which don't have a f2fs
prefix. There's well over a hundred (see attached below).
As one example, in fs/f2fs/dir.c there is:
unsigned char get_de_type(struct f2fs_dir_entry *de)
This function is clearly only useful for f2fs, but it has a generic
name. This means that if any other file system tries to have the same
symbol name, there will be a symbol conflict and the kernel would not
successfully build. It also means that when someone is looking f2fs
sources, it's not at all obvious whether a function such as
read_data_page(), invalidate_blocks(), is a generic kernel function
found in the fs, mm, or block layers, or a f2fs specific function.
You might want to fix this at some point. Hopefully Kent's bcachefs
isn't similarly using genericly named functions, since that might
cause conflicts with f2fs's functions --- but just as this would be a
problem that we would rightly insist that Kent fix, this is something
that we should have rightly insisted that f2fs should have fixed
before it was integrated into the mainline kernel.
acquire_orphan_inode
add_ino_entry
add_orphan_inode
allocate_data_block
allocate_new_segments
alloc_nid
alloc_nid_done
alloc_nid_failed
available_free_memory
...."
This patch adds "f2fs_" prefix for all non-static symbols in order to:
a) avoid conflict with other kernel generic symbols;
b) to indicate the function is f2fs specific one instead of generic
one;
Reported-by: Theodore Ts'o <tytso@mit.edu>
Signed-off-by: Chao Yu <yuchao0@huawei.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2018-05-30 00:20:41 +08:00
|
|
|
f2fs_get_node_info(sbi, dn->nid, &ni);
|
2013-12-16 18:04:05 +08:00
|
|
|
set_summary(&sum, dn->nid, dn->ofs_in_node, ni.version);
|
|
|
|
|
|
f2fs: clean up symbol namespace
As Ted reported:
"Hi, I was looking at f2fs's sources recently, and I noticed that there
is a very large number of non-static symbols which don't have a f2fs
prefix. There's well over a hundred (see attached below).
As one example, in fs/f2fs/dir.c there is:
unsigned char get_de_type(struct f2fs_dir_entry *de)
This function is clearly only useful for f2fs, but it has a generic
name. This means that if any other file system tries to have the same
symbol name, there will be a symbol conflict and the kernel would not
successfully build. It also means that when someone is looking f2fs
sources, it's not at all obvious whether a function such as
read_data_page(), invalidate_blocks(), is a generic kernel function
found in the fs, mm, or block layers, or a f2fs specific function.
You might want to fix this at some point. Hopefully Kent's bcachefs
isn't similarly using genericly named functions, since that might
cause conflicts with f2fs's functions --- but just as this would be a
problem that we would rightly insist that Kent fix, this is something
that we should have rightly insisted that f2fs should have fixed
before it was integrated into the mainline kernel.
acquire_orphan_inode
add_ino_entry
add_orphan_inode
allocate_data_block
allocate_new_segments
alloc_nid
alloc_nid_done
alloc_nid_failed
available_free_memory
...."
This patch adds "f2fs_" prefix for all non-static symbols in order to:
a) avoid conflict with other kernel generic symbols;
b) to indicate the function is f2fs specific one instead of generic
one;
Reported-by: Theodore Ts'o <tytso@mit.edu>
Signed-off-by: Chao Yu <yuchao0@huawei.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2018-05-30 00:20:41 +08:00
|
|
|
f2fs_allocate_data_block(sbi, NULL, dn->data_blkaddr, &dn->data_blkaddr,
|
2017-11-28 08:23:00 +08:00
|
|
|
&sum, seg_type, NULL, false);
|
f2fs: clean up symbol namespace
As Ted reported:
"Hi, I was looking at f2fs's sources recently, and I noticed that there
is a very large number of non-static symbols which don't have a f2fs
prefix. There's well over a hundred (see attached below).
As one example, in fs/f2fs/dir.c there is:
unsigned char get_de_type(struct f2fs_dir_entry *de)
This function is clearly only useful for f2fs, but it has a generic
name. This means that if any other file system tries to have the same
symbol name, there will be a symbol conflict and the kernel would not
successfully build. It also means that when someone is looking f2fs
sources, it's not at all obvious whether a function such as
read_data_page(), invalidate_blocks(), is a generic kernel function
found in the fs, mm, or block layers, or a f2fs specific function.
You might want to fix this at some point. Hopefully Kent's bcachefs
isn't similarly using genericly named functions, since that might
cause conflicts with f2fs's functions --- but just as this would be a
problem that we would rightly insist that Kent fix, this is something
that we should have rightly insisted that f2fs should have fixed
before it was integrated into the mainline kernel.
acquire_orphan_inode
add_ino_entry
add_orphan_inode
allocate_data_block
allocate_new_segments
alloc_nid
alloc_nid_done
alloc_nid_failed
available_free_memory
...."
This patch adds "f2fs_" prefix for all non-static symbols in order to:
a) avoid conflict with other kernel generic symbols;
b) to indicate the function is f2fs specific one instead of generic
one;
Reported-by: Theodore Ts'o <tytso@mit.edu>
Signed-off-by: Chao Yu <yuchao0@huawei.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2018-05-30 00:20:41 +08:00
|
|
|
f2fs_set_data_blkaddr(dn);
|
2013-12-16 18:04:05 +08:00
|
|
|
|
2014-09-16 10:32:16 +08:00
|
|
|
/* update i_size */
|
f2fs: clean up symbol namespace
As Ted reported:
"Hi, I was looking at f2fs's sources recently, and I noticed that there
is a very large number of non-static symbols which don't have a f2fs
prefix. There's well over a hundred (see attached below).
As one example, in fs/f2fs/dir.c there is:
unsigned char get_de_type(struct f2fs_dir_entry *de)
This function is clearly only useful for f2fs, but it has a generic
name. This means that if any other file system tries to have the same
symbol name, there will be a symbol conflict and the kernel would not
successfully build. It also means that when someone is looking f2fs
sources, it's not at all obvious whether a function such as
read_data_page(), invalidate_blocks(), is a generic kernel function
found in the fs, mm, or block layers, or a f2fs specific function.
You might want to fix this at some point. Hopefully Kent's bcachefs
isn't similarly using genericly named functions, since that might
cause conflicts with f2fs's functions --- but just as this would be a
problem that we would rightly insist that Kent fix, this is something
that we should have rightly insisted that f2fs should have fixed
before it was integrated into the mainline kernel.
acquire_orphan_inode
add_ino_entry
add_orphan_inode
allocate_data_block
allocate_new_segments
alloc_nid
alloc_nid_done
alloc_nid_failed
available_free_memory
...."
This patch adds "f2fs_" prefix for all non-static symbols in order to:
a) avoid conflict with other kernel generic symbols;
b) to indicate the function is f2fs specific one instead of generic
one;
Reported-by: Theodore Ts'o <tytso@mit.edu>
Signed-off-by: Chao Yu <yuchao0@huawei.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2018-05-30 00:20:41 +08:00
|
|
|
fofs = f2fs_start_bidx_of_node(ofs_of_node(dn->node_page), dn->inode) +
|
2014-09-16 10:32:16 +08:00
|
|
|
dn->ofs_in_node;
|
mm, fs: get rid of PAGE_CACHE_* and page_cache_{get,release} macros
PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} macros were introduced *long* time
ago with promise that one day it will be possible to implement page
cache with bigger chunks than PAGE_SIZE.
This promise never materialized. And unlikely will.
We have many places where PAGE_CACHE_SIZE assumed to be equal to
PAGE_SIZE. And it's constant source of confusion on whether
PAGE_CACHE_* or PAGE_* constant should be used in a particular case,
especially on the border between fs and mm.
Global switching to PAGE_CACHE_SIZE != PAGE_SIZE would cause to much
breakage to be doable.
Let's stop pretending that pages in page cache are special. They are
not.
The changes are pretty straight-forward:
- <foo> << (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- <foo> >> (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} -> PAGE_{SIZE,SHIFT,MASK,ALIGN};
- page_cache_get() -> get_page();
- page_cache_release() -> put_page();
This patch contains automated changes generated with coccinelle using
script below. For some reason, coccinelle doesn't patch header files.
I've called spatch for them manually.
The only adjustment after coccinelle is revert of changes to
PAGE_CAHCE_ALIGN definition: we are going to drop it later.
There are few places in the code where coccinelle didn't reach. I'll
fix them manually in a separate patch. Comments and documentation also
will be addressed with the separate patch.
virtual patch
@@
expression E;
@@
- E << (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
expression E;
@@
- E >> (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
@@
- PAGE_CACHE_SHIFT
+ PAGE_SHIFT
@@
@@
- PAGE_CACHE_SIZE
+ PAGE_SIZE
@@
@@
- PAGE_CACHE_MASK
+ PAGE_MASK
@@
expression E;
@@
- PAGE_CACHE_ALIGN(E)
+ PAGE_ALIGN(E)
@@
expression E;
@@
- page_cache_get(E)
+ get_page(E)
@@
expression E;
@@
- page_cache_release(E)
+ put_page(E)
Signed-off-by: Kirill A. Shutemov <kirill.shutemov@linux.intel.com>
Acked-by: Michal Hocko <mhocko@suse.com>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2016-04-01 20:29:47 +08:00
|
|
|
if (i_size_read(dn->inode) < ((loff_t)(fofs + 1) << PAGE_SHIFT))
|
2016-05-21 00:22:03 +08:00
|
|
|
f2fs_i_size_write(dn->inode,
|
mm, fs: get rid of PAGE_CACHE_* and page_cache_{get,release} macros
PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} macros were introduced *long* time
ago with promise that one day it will be possible to implement page
cache with bigger chunks than PAGE_SIZE.
This promise never materialized. And unlikely will.
We have many places where PAGE_CACHE_SIZE assumed to be equal to
PAGE_SIZE. And it's constant source of confusion on whether
PAGE_CACHE_* or PAGE_* constant should be used in a particular case,
especially on the border between fs and mm.
Global switching to PAGE_CACHE_SIZE != PAGE_SIZE would cause to much
breakage to be doable.
Let's stop pretending that pages in page cache are special. They are
not.
The changes are pretty straight-forward:
- <foo> << (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- <foo> >> (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} -> PAGE_{SIZE,SHIFT,MASK,ALIGN};
- page_cache_get() -> get_page();
- page_cache_release() -> put_page();
This patch contains automated changes generated with coccinelle using
script below. For some reason, coccinelle doesn't patch header files.
I've called spatch for them manually.
The only adjustment after coccinelle is revert of changes to
PAGE_CAHCE_ALIGN definition: we are going to drop it later.
There are few places in the code where coccinelle didn't reach. I'll
fix them manually in a separate patch. Comments and documentation also
will be addressed with the separate patch.
virtual patch
@@
expression E;
@@
- E << (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
expression E;
@@
- E >> (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
@@
- PAGE_CACHE_SHIFT
+ PAGE_SHIFT
@@
@@
- PAGE_CACHE_SIZE
+ PAGE_SIZE
@@
@@
- PAGE_CACHE_MASK
+ PAGE_MASK
@@
expression E;
@@
- PAGE_CACHE_ALIGN(E)
+ PAGE_ALIGN(E)
@@
expression E;
@@
- page_cache_get(E)
+ get_page(E)
@@
expression E;
@@
- page_cache_release(E)
+ put_page(E)
Signed-off-by: Kirill A. Shutemov <kirill.shutemov@linux.intel.com>
Acked-by: Michal Hocko <mhocko@suse.com>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2016-04-01 20:29:47 +08:00
|
|
|
((loff_t)(fofs + 1) << PAGE_SHIFT));
|
2013-12-16 18:04:05 +08:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2016-11-12 08:31:56 +08:00
|
|
|
int f2fs_preallocate_blocks(struct kiocb *iocb, struct iov_iter *from)
|
2015-02-10 04:09:53 +08:00
|
|
|
{
|
2016-02-04 05:09:09 +08:00
|
|
|
struct inode *inode = file_inode(iocb->ki_filp);
|
2016-01-26 15:38:29 +08:00
|
|
|
struct f2fs_map_blocks map;
|
2018-01-03 17:30:19 +08:00
|
|
|
int flag;
|
2016-11-12 08:31:56 +08:00
|
|
|
int err = 0;
|
2018-01-03 17:30:19 +08:00
|
|
|
bool direct_io = iocb->ki_flags & IOCB_DIRECT;
|
2015-02-10 04:09:53 +08:00
|
|
|
|
2017-09-29 22:43:23 +08:00
|
|
|
/* convert inline data for Direct I/O*/
|
2018-01-03 17:30:19 +08:00
|
|
|
if (direct_io) {
|
2017-09-29 22:43:23 +08:00
|
|
|
err = f2fs_convert_inline_inode(inode);
|
|
|
|
|
if (err)
|
|
|
|
|
return err;
|
|
|
|
|
}
|
|
|
|
|
|
2017-01-14 05:12:29 +08:00
|
|
|
if (is_inode_flag_set(inode, FI_NO_PREALLOC))
|
|
|
|
|
return 0;
|
|
|
|
|
|
2016-05-07 23:52:57 +08:00
|
|
|
map.m_lblk = F2FS_BLK_ALIGN(iocb->ki_pos);
|
2016-08-20 15:12:01 +08:00
|
|
|
map.m_len = F2FS_BYTES_TO_BLK(iocb->ki_pos + iov_iter_count(from));
|
|
|
|
|
if (map.m_len > map.m_lblk)
|
|
|
|
|
map.m_len -= map.m_lblk;
|
|
|
|
|
else
|
|
|
|
|
map.m_len = 0;
|
|
|
|
|
|
2016-01-26 15:42:58 +08:00
|
|
|
map.m_next_pgofs = NULL;
|
2018-01-11 14:42:30 +08:00
|
|
|
map.m_next_extent = NULL;
|
2017-11-28 08:23:00 +08:00
|
|
|
map.m_seg_type = NO_CHECK_TYPE;
|
2015-12-23 05:23:35 +08:00
|
|
|
|
2018-01-03 17:30:19 +08:00
|
|
|
if (direct_io) {
|
f2fs: clean up symbol namespace
As Ted reported:
"Hi, I was looking at f2fs's sources recently, and I noticed that there
is a very large number of non-static symbols which don't have a f2fs
prefix. There's well over a hundred (see attached below).
As one example, in fs/f2fs/dir.c there is:
unsigned char get_de_type(struct f2fs_dir_entry *de)
This function is clearly only useful for f2fs, but it has a generic
name. This means that if any other file system tries to have the same
symbol name, there will be a symbol conflict and the kernel would not
successfully build. It also means that when someone is looking f2fs
sources, it's not at all obvious whether a function such as
read_data_page(), invalidate_blocks(), is a generic kernel function
found in the fs, mm, or block layers, or a f2fs specific function.
You might want to fix this at some point. Hopefully Kent's bcachefs
isn't similarly using genericly named functions, since that might
cause conflicts with f2fs's functions --- but just as this would be a
problem that we would rightly insist that Kent fix, this is something
that we should have rightly insisted that f2fs should have fixed
before it was integrated into the mainline kernel.
acquire_orphan_inode
add_ino_entry
add_orphan_inode
allocate_data_block
allocate_new_segments
alloc_nid
alloc_nid_done
alloc_nid_failed
available_free_memory
...."
This patch adds "f2fs_" prefix for all non-static symbols in order to:
a) avoid conflict with other kernel generic symbols;
b) to indicate the function is f2fs specific one instead of generic
one;
Reported-by: Theodore Ts'o <tytso@mit.edu>
Signed-off-by: Chao Yu <yuchao0@huawei.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2018-05-30 00:20:41 +08:00
|
|
|
map.m_seg_type = f2fs_rw_hint_to_seg_type(iocb->ki_hint);
|
2018-03-08 18:34:38 +08:00
|
|
|
flag = f2fs_force_buffered_io(inode, WRITE) ?
|
2018-01-03 17:30:19 +08:00
|
|
|
F2FS_GET_BLOCK_PRE_AIO :
|
|
|
|
|
F2FS_GET_BLOCK_PRE_DIO;
|
|
|
|
|
goto map_blocks;
|
2017-11-28 08:23:00 +08:00
|
|
|
}
|
2017-07-19 00:19:05 +08:00
|
|
|
if (iocb->ki_pos + iov_iter_count(from) > MAX_INLINE_DATA(inode)) {
|
2016-11-12 08:31:56 +08:00
|
|
|
err = f2fs_convert_inline_inode(inode);
|
|
|
|
|
if (err)
|
|
|
|
|
return err;
|
2016-02-04 05:09:09 +08:00
|
|
|
}
|
2018-01-03 17:30:19 +08:00
|
|
|
if (f2fs_has_inline_data(inode))
|
2017-11-22 18:23:39 +08:00
|
|
|
return err;
|
2018-01-03 17:30:19 +08:00
|
|
|
|
|
|
|
|
flag = F2FS_GET_BLOCK_PRE_AIO;
|
|
|
|
|
|
|
|
|
|
map_blocks:
|
|
|
|
|
err = f2fs_map_blocks(inode, &map, 1, flag);
|
|
|
|
|
if (map.m_len > 0 && err == -ENOSPC) {
|
|
|
|
|
if (!direct_io)
|
|
|
|
|
set_inode_flag(inode, FI_NO_PREALLOC);
|
|
|
|
|
err = 0;
|
2017-11-22 18:23:39 +08:00
|
|
|
}
|
2016-11-12 08:31:56 +08:00
|
|
|
return err;
|
2015-02-10 04:09:53 +08:00
|
|
|
}
|
|
|
|
|
|
2017-03-13 20:22:18 +08:00
|
|
|
static inline void __do_map_lock(struct f2fs_sb_info *sbi, int flag, bool lock)
|
|
|
|
|
{
|
|
|
|
|
if (flag == F2FS_GET_BLOCK_PRE_AIO) {
|
|
|
|
|
if (lock)
|
|
|
|
|
down_read(&sbi->node_change);
|
|
|
|
|
else
|
|
|
|
|
up_read(&sbi->node_change);
|
|
|
|
|
} else {
|
|
|
|
|
if (lock)
|
|
|
|
|
f2fs_lock_op(sbi);
|
|
|
|
|
else
|
|
|
|
|
f2fs_unlock_op(sbi);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2012-11-29 12:28:09 +08:00
|
|
|
/*
|
2015-04-07 10:55:34 +08:00
|
|
|
* f2fs_map_blocks() now supported readahead/bmap/rw direct_IO with
|
|
|
|
|
* f2fs_map_blocks structure.
|
2013-12-21 18:02:14 +08:00
|
|
|
* If original data blocks are allocated, then give them to blockdev.
|
|
|
|
|
* Otherwise,
|
|
|
|
|
* a. preallocate requested block addresses
|
|
|
|
|
* b. do not use extent cache for better performance
|
|
|
|
|
* c. give the block addresses to blockdev
|
2012-11-02 16:10:12 +08:00
|
|
|
*/
|
2015-10-27 09:53:45 +08:00
|
|
|
int f2fs_map_blocks(struct inode *inode, struct f2fs_map_blocks *map,
|
2015-08-19 19:11:19 +08:00
|
|
|
int create, int flag)
|
2012-11-02 16:10:12 +08:00
|
|
|
{
|
2015-04-07 10:55:34 +08:00
|
|
|
unsigned int maxblocks = map->m_len;
|
2012-11-02 16:10:12 +08:00
|
|
|
struct dnode_of_data dn;
|
2015-09-21 20:17:52 +08:00
|
|
|
struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
|
2016-06-17 08:03:23 +08:00
|
|
|
int mode = create ? ALLOC_NODE : LOOKUP_NODE;
|
2016-05-09 19:56:30 +08:00
|
|
|
pgoff_t pgofs, end_offset, end;
|
2013-12-16 18:04:05 +08:00
|
|
|
int err = 0, ofs = 1;
|
2016-05-09 19:56:30 +08:00
|
|
|
unsigned int ofs_in_node, last_ofs_in_node;
|
|
|
|
|
blkcnt_t prealloc;
|
2017-02-23 17:18:05 +08:00
|
|
|
struct extent_info ei = {0,0,0};
|
2015-12-17 13:20:59 +08:00
|
|
|
block_t blkaddr;
|
2018-01-11 14:42:30 +08:00
|
|
|
unsigned int start_pgofs;
|
2012-11-02 16:10:12 +08:00
|
|
|
|
2016-08-20 15:12:01 +08:00
|
|
|
if (!maxblocks)
|
|
|
|
|
return 0;
|
|
|
|
|
|
2015-04-07 10:55:34 +08:00
|
|
|
map->m_len = 0;
|
|
|
|
|
map->m_flags = 0;
|
|
|
|
|
|
|
|
|
|
/* it only supports block size == page size */
|
|
|
|
|
pgofs = (pgoff_t)map->m_lblk;
|
2016-05-09 19:56:30 +08:00
|
|
|
end = pgofs + maxblocks;
|
2012-11-02 16:10:12 +08:00
|
|
|
|
2016-02-04 05:49:44 +08:00
|
|
|
if (!create && f2fs_lookup_extent_cache(inode, pgofs, &ei)) {
|
2015-04-07 10:55:34 +08:00
|
|
|
map->m_pblk = ei.blk + pgofs - ei.fofs;
|
|
|
|
|
map->m_len = min((pgoff_t)maxblocks, ei.fofs + ei.len - pgofs);
|
|
|
|
|
map->m_flags = F2FS_MAP_MAPPED;
|
2018-01-11 14:42:30 +08:00
|
|
|
if (map->m_next_extent)
|
|
|
|
|
*map->m_next_extent = pgofs + map->m_len;
|
2013-12-16 18:04:05 +08:00
|
|
|
goto out;
|
2015-02-05 17:50:30 +08:00
|
|
|
}
|
2013-12-16 18:04:05 +08:00
|
|
|
|
2016-01-26 15:37:38 +08:00
|
|
|
next_dnode:
|
2015-02-10 04:09:53 +08:00
|
|
|
if (create)
|
2017-03-13 20:22:18 +08:00
|
|
|
__do_map_lock(sbi, flag, true);
|
2012-11-02 16:10:12 +08:00
|
|
|
|
|
|
|
|
/* When reading holes, we need its node page */
|
|
|
|
|
set_new_dnode(&dn, inode, NULL, NULL, 0);
|
f2fs: clean up symbol namespace
As Ted reported:
"Hi, I was looking at f2fs's sources recently, and I noticed that there
is a very large number of non-static symbols which don't have a f2fs
prefix. There's well over a hundred (see attached below).
As one example, in fs/f2fs/dir.c there is:
unsigned char get_de_type(struct f2fs_dir_entry *de)
This function is clearly only useful for f2fs, but it has a generic
name. This means that if any other file system tries to have the same
symbol name, there will be a symbol conflict and the kernel would not
successfully build. It also means that when someone is looking f2fs
sources, it's not at all obvious whether a function such as
read_data_page(), invalidate_blocks(), is a generic kernel function
found in the fs, mm, or block layers, or a f2fs specific function.
You might want to fix this at some point. Hopefully Kent's bcachefs
isn't similarly using genericly named functions, since that might
cause conflicts with f2fs's functions --- but just as this would be a
problem that we would rightly insist that Kent fix, this is something
that we should have rightly insisted that f2fs should have fixed
before it was integrated into the mainline kernel.
acquire_orphan_inode
add_ino_entry
add_orphan_inode
allocate_data_block
allocate_new_segments
alloc_nid
alloc_nid_done
alloc_nid_failed
available_free_memory
...."
This patch adds "f2fs_" prefix for all non-static symbols in order to:
a) avoid conflict with other kernel generic symbols;
b) to indicate the function is f2fs specific one instead of generic
one;
Reported-by: Theodore Ts'o <tytso@mit.edu>
Signed-off-by: Chao Yu <yuchao0@huawei.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2018-05-30 00:20:41 +08:00
|
|
|
err = f2fs_get_dnode_of_data(&dn, pgofs, mode);
|
2013-12-26 15:55:22 +08:00
|
|
|
if (err) {
|
2016-05-05 19:13:02 +08:00
|
|
|
if (flag == F2FS_GET_BLOCK_BMAP)
|
|
|
|
|
map->m_pblk = 0;
|
2016-01-26 15:42:58 +08:00
|
|
|
if (err == -ENOENT) {
|
2013-12-16 18:04:05 +08:00
|
|
|
err = 0;
|
2016-01-26 15:42:58 +08:00
|
|
|
if (map->m_next_pgofs)
|
|
|
|
|
*map->m_next_pgofs =
|
f2fs: clean up symbol namespace
As Ted reported:
"Hi, I was looking at f2fs's sources recently, and I noticed that there
is a very large number of non-static symbols which don't have a f2fs
prefix. There's well over a hundred (see attached below).
As one example, in fs/f2fs/dir.c there is:
unsigned char get_de_type(struct f2fs_dir_entry *de)
This function is clearly only useful for f2fs, but it has a generic
name. This means that if any other file system tries to have the same
symbol name, there will be a symbol conflict and the kernel would not
successfully build. It also means that when someone is looking f2fs
sources, it's not at all obvious whether a function such as
read_data_page(), invalidate_blocks(), is a generic kernel function
found in the fs, mm, or block layers, or a f2fs specific function.
You might want to fix this at some point. Hopefully Kent's bcachefs
isn't similarly using genericly named functions, since that might
cause conflicts with f2fs's functions --- but just as this would be a
problem that we would rightly insist that Kent fix, this is something
that we should have rightly insisted that f2fs should have fixed
before it was integrated into the mainline kernel.
acquire_orphan_inode
add_ino_entry
add_orphan_inode
allocate_data_block
allocate_new_segments
alloc_nid
alloc_nid_done
alloc_nid_failed
available_free_memory
...."
This patch adds "f2fs_" prefix for all non-static symbols in order to:
a) avoid conflict with other kernel generic symbols;
b) to indicate the function is f2fs specific one instead of generic
one;
Reported-by: Theodore Ts'o <tytso@mit.edu>
Signed-off-by: Chao Yu <yuchao0@huawei.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2018-05-30 00:20:41 +08:00
|
|
|
f2fs_get_next_page_offset(&dn, pgofs);
|
2018-01-11 14:42:30 +08:00
|
|
|
if (map->m_next_extent)
|
|
|
|
|
*map->m_next_extent =
|
f2fs: clean up symbol namespace
As Ted reported:
"Hi, I was looking at f2fs's sources recently, and I noticed that there
is a very large number of non-static symbols which don't have a f2fs
prefix. There's well over a hundred (see attached below).
As one example, in fs/f2fs/dir.c there is:
unsigned char get_de_type(struct f2fs_dir_entry *de)
This function is clearly only useful for f2fs, but it has a generic
name. This means that if any other file system tries to have the same
symbol name, there will be a symbol conflict and the kernel would not
successfully build. It also means that when someone is looking f2fs
sources, it's not at all obvious whether a function such as
read_data_page(), invalidate_blocks(), is a generic kernel function
found in the fs, mm, or block layers, or a f2fs specific function.
You might want to fix this at some point. Hopefully Kent's bcachefs
isn't similarly using genericly named functions, since that might
cause conflicts with f2fs's functions --- but just as this would be a
problem that we would rightly insist that Kent fix, this is something
that we should have rightly insisted that f2fs should have fixed
before it was integrated into the mainline kernel.
acquire_orphan_inode
add_ino_entry
add_orphan_inode
allocate_data_block
allocate_new_segments
alloc_nid
alloc_nid_done
alloc_nid_failed
available_free_memory
...."
This patch adds "f2fs_" prefix for all non-static symbols in order to:
a) avoid conflict with other kernel generic symbols;
b) to indicate the function is f2fs specific one instead of generic
one;
Reported-by: Theodore Ts'o <tytso@mit.edu>
Signed-off-by: Chao Yu <yuchao0@huawei.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2018-05-30 00:20:41 +08:00
|
|
|
f2fs_get_next_page_offset(&dn, pgofs);
|
2016-01-26 15:42:58 +08:00
|
|
|
}
|
2013-12-16 18:04:05 +08:00
|
|
|
goto unlock_out;
|
2013-04-23 15:38:02 +08:00
|
|
|
}
|
2015-09-18 16:51:51 +08:00
|
|
|
|
2018-01-11 14:42:30 +08:00
|
|
|
start_pgofs = pgofs;
|
2016-05-09 19:56:30 +08:00
|
|
|
prealloc = 0;
|
2016-11-02 21:52:15 +08:00
|
|
|
last_ofs_in_node = ofs_in_node = dn.ofs_in_node;
|
2016-01-26 15:39:35 +08:00
|
|
|
end_offset = ADDRS_PER_PAGE(dn.node_page, inode);
|
2016-01-26 15:37:38 +08:00
|
|
|
|
|
|
|
|
next_block:
|
2017-07-19 00:19:06 +08:00
|
|
|
blkaddr = datablock_addr(dn.inode, dn.node_page, dn.ofs_in_node);
|
2016-01-26 15:37:38 +08:00
|
|
|
|
2018-05-23 22:25:08 +08:00
|
|
|
if (!is_valid_blkaddr(blkaddr)) {
|
2015-09-18 16:51:51 +08:00
|
|
|
if (create) {
|
2015-09-21 20:17:52 +08:00
|
|
|
if (unlikely(f2fs_cp_error(sbi))) {
|
|
|
|
|
err = -EIO;
|
2016-01-26 15:37:38 +08:00
|
|
|
goto sync_out;
|
2015-09-21 20:17:52 +08:00
|
|
|
}
|
2016-02-04 05:49:44 +08:00
|
|
|
if (flag == F2FS_GET_BLOCK_PRE_AIO) {
|
2016-05-09 19:56:30 +08:00
|
|
|
if (blkaddr == NULL_ADDR) {
|
|
|
|
|
prealloc++;
|
|
|
|
|
last_ofs_in_node = dn.ofs_in_node;
|
|
|
|
|
}
|
2016-02-04 05:49:44 +08:00
|
|
|
} else {
|
2017-11-28 08:23:00 +08:00
|
|
|
err = __allocate_data_block(&dn,
|
|
|
|
|
map->m_seg_type);
|
2016-10-11 22:57:03 +08:00
|
|
|
if (!err)
|
2016-05-21 01:13:22 +08:00
|
|
|
set_inode_flag(inode, FI_APPEND_WRITE);
|
2016-02-04 05:49:44 +08:00
|
|
|
}
|
2015-09-18 16:51:51 +08:00
|
|
|
if (err)
|
2016-01-26 15:37:38 +08:00
|
|
|
goto sync_out;
|
2017-02-23 19:55:05 +08:00
|
|
|
map->m_flags |= F2FS_MAP_NEW;
|
2016-01-26 15:37:38 +08:00
|
|
|
blkaddr = dn.data_blkaddr;
|
2015-09-18 16:51:51 +08:00
|
|
|
} else {
|
2016-05-05 19:13:02 +08:00
|
|
|
if (flag == F2FS_GET_BLOCK_BMAP) {
|
|
|
|
|
map->m_pblk = 0;
|
|
|
|
|
goto sync_out;
|
|
|
|
|
}
|
2018-01-11 14:42:30 +08:00
|
|
|
if (flag == F2FS_GET_BLOCK_PRECACHE)
|
|
|
|
|
goto sync_out;
|
2016-01-26 15:42:58 +08:00
|
|
|
if (flag == F2FS_GET_BLOCK_FIEMAP &&
|
|
|
|
|
blkaddr == NULL_ADDR) {
|
|
|
|
|
if (map->m_next_pgofs)
|
|
|
|
|
*map->m_next_pgofs = pgofs + 1;
|
2017-11-30 19:28:22 +08:00
|
|
|
goto sync_out;
|
2016-01-26 15:42:58 +08:00
|
|
|
}
|
2018-01-10 18:18:52 +08:00
|
|
|
if (flag != F2FS_GET_BLOCK_FIEMAP) {
|
|
|
|
|
/* for defragment case */
|
|
|
|
|
if (map->m_next_pgofs)
|
|
|
|
|
*map->m_next_pgofs = pgofs + 1;
|
2016-01-26 15:37:38 +08:00
|
|
|
goto sync_out;
|
2018-01-10 18:18:52 +08:00
|
|
|
}
|
2015-08-19 19:11:19 +08:00
|
|
|
}
|
|
|
|
|
}
|
2012-11-02 16:10:12 +08:00
|
|
|
|
2016-05-09 19:56:30 +08:00
|
|
|
if (flag == F2FS_GET_BLOCK_PRE_AIO)
|
|
|
|
|
goto skip;
|
|
|
|
|
|
2016-01-26 15:37:38 +08:00
|
|
|
if (map->m_len == 0) {
|
|
|
|
|
/* preallocated unwritten block should be mapped for fiemap. */
|
|
|
|
|
if (blkaddr == NEW_ADDR)
|
|
|
|
|
map->m_flags |= F2FS_MAP_UNWRITTEN;
|
|
|
|
|
map->m_flags |= F2FS_MAP_MAPPED;
|
|
|
|
|
|
|
|
|
|
map->m_pblk = blkaddr;
|
|
|
|
|
map->m_len = 1;
|
|
|
|
|
} else if ((map->m_pblk != NEW_ADDR &&
|
|
|
|
|
blkaddr == (map->m_pblk + ofs)) ||
|
2016-02-04 05:09:09 +08:00
|
|
|
(map->m_pblk == NEW_ADDR && blkaddr == NEW_ADDR) ||
|
2016-05-09 19:56:30 +08:00
|
|
|
flag == F2FS_GET_BLOCK_PRE_DIO) {
|
2016-01-26 15:37:38 +08:00
|
|
|
ofs++;
|
|
|
|
|
map->m_len++;
|
|
|
|
|
} else {
|
|
|
|
|
goto sync_out;
|
|
|
|
|
}
|
2013-12-16 18:04:05 +08:00
|
|
|
|
2016-05-09 19:56:30 +08:00
|
|
|
skip:
|
2013-12-16 18:04:05 +08:00
|
|
|
dn.ofs_in_node++;
|
|
|
|
|
pgofs++;
|
|
|
|
|
|
2016-05-09 19:56:30 +08:00
|
|
|
/* preallocate blocks in batch for one dnode page */
|
|
|
|
|
if (flag == F2FS_GET_BLOCK_PRE_AIO &&
|
|
|
|
|
(pgofs == end || dn.ofs_in_node == end_offset)) {
|
2015-12-17 13:20:59 +08:00
|
|
|
|
2016-05-09 19:56:30 +08:00
|
|
|
dn.ofs_in_node = ofs_in_node;
|
f2fs: clean up symbol namespace
As Ted reported:
"Hi, I was looking at f2fs's sources recently, and I noticed that there
is a very large number of non-static symbols which don't have a f2fs
prefix. There's well over a hundred (see attached below).
As one example, in fs/f2fs/dir.c there is:
unsigned char get_de_type(struct f2fs_dir_entry *de)
This function is clearly only useful for f2fs, but it has a generic
name. This means that if any other file system tries to have the same
symbol name, there will be a symbol conflict and the kernel would not
successfully build. It also means that when someone is looking f2fs
sources, it's not at all obvious whether a function such as
read_data_page(), invalidate_blocks(), is a generic kernel function
found in the fs, mm, or block layers, or a f2fs specific function.
You might want to fix this at some point. Hopefully Kent's bcachefs
isn't similarly using genericly named functions, since that might
cause conflicts with f2fs's functions --- but just as this would be a
problem that we would rightly insist that Kent fix, this is something
that we should have rightly insisted that f2fs should have fixed
before it was integrated into the mainline kernel.
acquire_orphan_inode
add_ino_entry
add_orphan_inode
allocate_data_block
allocate_new_segments
alloc_nid
alloc_nid_done
alloc_nid_failed
available_free_memory
...."
This patch adds "f2fs_" prefix for all non-static symbols in order to:
a) avoid conflict with other kernel generic symbols;
b) to indicate the function is f2fs specific one instead of generic
one;
Reported-by: Theodore Ts'o <tytso@mit.edu>
Signed-off-by: Chao Yu <yuchao0@huawei.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2018-05-30 00:20:41 +08:00
|
|
|
err = f2fs_reserve_new_blocks(&dn, prealloc);
|
2016-05-09 19:56:30 +08:00
|
|
|
if (err)
|
|
|
|
|
goto sync_out;
|
2013-12-16 18:04:05 +08:00
|
|
|
|
2016-05-09 19:56:30 +08:00
|
|
|
map->m_len += dn.ofs_in_node - ofs_in_node;
|
|
|
|
|
if (prealloc && dn.ofs_in_node != last_ofs_in_node + 1) {
|
|
|
|
|
err = -ENOSPC;
|
|
|
|
|
goto sync_out;
|
2015-12-23 17:11:43 +08:00
|
|
|
}
|
2016-05-09 19:56:30 +08:00
|
|
|
dn.ofs_in_node = end_offset;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (pgofs >= end)
|
|
|
|
|
goto sync_out;
|
|
|
|
|
else if (dn.ofs_in_node < end_offset)
|
|
|
|
|
goto next_block;
|
|
|
|
|
|
2018-01-11 14:42:30 +08:00
|
|
|
if (flag == F2FS_GET_BLOCK_PRECACHE) {
|
|
|
|
|
if (map->m_flags & F2FS_MAP_MAPPED) {
|
|
|
|
|
unsigned int ofs = start_pgofs - map->m_lblk;
|
|
|
|
|
|
|
|
|
|
f2fs_update_extent_cache_range(&dn,
|
|
|
|
|
start_pgofs, map->m_pblk + ofs,
|
|
|
|
|
map->m_len - ofs);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2016-05-09 19:56:30 +08:00
|
|
|
f2fs_put_dnode(&dn);
|
|
|
|
|
|
|
|
|
|
if (create) {
|
2017-03-13 20:22:18 +08:00
|
|
|
__do_map_lock(sbi, flag, false);
|
2016-10-11 22:57:03 +08:00
|
|
|
f2fs_balance_fs(sbi, dn.node_changed);
|
2012-11-02 16:10:12 +08:00
|
|
|
}
|
2016-05-09 19:56:30 +08:00
|
|
|
goto next_dnode;
|
2015-12-17 13:20:59 +08:00
|
|
|
|
2013-12-16 18:04:05 +08:00
|
|
|
sync_out:
|
2018-01-11 14:42:30 +08:00
|
|
|
if (flag == F2FS_GET_BLOCK_PRECACHE) {
|
|
|
|
|
if (map->m_flags & F2FS_MAP_MAPPED) {
|
|
|
|
|
unsigned int ofs = start_pgofs - map->m_lblk;
|
|
|
|
|
|
|
|
|
|
f2fs_update_extent_cache_range(&dn,
|
|
|
|
|
start_pgofs, map->m_pblk + ofs,
|
|
|
|
|
map->m_len - ofs);
|
|
|
|
|
}
|
|
|
|
|
if (map->m_next_extent)
|
|
|
|
|
*map->m_next_extent = pgofs + 1;
|
|
|
|
|
}
|
2012-11-02 16:10:12 +08:00
|
|
|
f2fs_put_dnode(&dn);
|
2013-12-16 18:04:05 +08:00
|
|
|
unlock_out:
|
2015-12-23 05:23:35 +08:00
|
|
|
if (create) {
|
2017-03-13 20:22:18 +08:00
|
|
|
__do_map_lock(sbi, flag, false);
|
2016-10-11 22:57:03 +08:00
|
|
|
f2fs_balance_fs(sbi, dn.node_changed);
|
2015-12-23 05:23:35 +08:00
|
|
|
}
|
2013-12-16 18:04:05 +08:00
|
|
|
out:
|
2015-04-07 10:55:34 +08:00
|
|
|
trace_f2fs_map_blocks(inode, map, err);
|
2013-12-16 18:04:05 +08:00
|
|
|
return err;
|
2012-11-02 16:10:12 +08:00
|
|
|
}
|
|
|
|
|
|
2018-03-08 18:34:38 +08:00
|
|
|
bool f2fs_overwrite_io(struct inode *inode, loff_t pos, size_t len)
|
|
|
|
|
{
|
|
|
|
|
struct f2fs_map_blocks map;
|
|
|
|
|
block_t last_lblk;
|
|
|
|
|
int err;
|
|
|
|
|
|
|
|
|
|
if (pos + len > i_size_read(inode))
|
|
|
|
|
return false;
|
|
|
|
|
|
|
|
|
|
map.m_lblk = F2FS_BYTES_TO_BLK(pos);
|
|
|
|
|
map.m_next_pgofs = NULL;
|
|
|
|
|
map.m_next_extent = NULL;
|
|
|
|
|
map.m_seg_type = NO_CHECK_TYPE;
|
|
|
|
|
last_lblk = F2FS_BLK_ALIGN(pos + len);
|
|
|
|
|
|
|
|
|
|
while (map.m_lblk < last_lblk) {
|
|
|
|
|
map.m_len = last_lblk - map.m_lblk;
|
|
|
|
|
err = f2fs_map_blocks(inode, &map, 0, F2FS_GET_BLOCK_DEFAULT);
|
|
|
|
|
if (err || map.m_len == 0)
|
|
|
|
|
return false;
|
|
|
|
|
map.m_lblk += map.m_len;
|
|
|
|
|
}
|
|
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
|
2015-04-07 10:55:34 +08:00
|
|
|
static int __get_data_block(struct inode *inode, sector_t iblock,
|
2016-01-26 15:42:58 +08:00
|
|
|
struct buffer_head *bh, int create, int flag,
|
2017-11-28 08:23:00 +08:00
|
|
|
pgoff_t *next_pgofs, int seg_type)
|
2015-04-07 10:55:34 +08:00
|
|
|
{
|
|
|
|
|
struct f2fs_map_blocks map;
|
2016-11-12 08:31:56 +08:00
|
|
|
int err;
|
2015-04-07 10:55:34 +08:00
|
|
|
|
|
|
|
|
map.m_lblk = iblock;
|
|
|
|
|
map.m_len = bh->b_size >> inode->i_blkbits;
|
2016-01-26 15:42:58 +08:00
|
|
|
map.m_next_pgofs = next_pgofs;
|
2018-01-11 14:42:30 +08:00
|
|
|
map.m_next_extent = NULL;
|
2017-11-28 08:23:00 +08:00
|
|
|
map.m_seg_type = seg_type;
|
2015-04-07 10:55:34 +08:00
|
|
|
|
2016-11-12 08:31:56 +08:00
|
|
|
err = f2fs_map_blocks(inode, &map, create, flag);
|
|
|
|
|
if (!err) {
|
2015-04-07 10:55:34 +08:00
|
|
|
map_bh(bh, inode->i_sb, map.m_pblk);
|
|
|
|
|
bh->b_state = (bh->b_state & ~F2FS_MAP_FLAGS) | map.m_flags;
|
2017-01-22 12:21:02 +08:00
|
|
|
bh->b_size = (u64)map.m_len << inode->i_blkbits;
|
2015-04-07 10:55:34 +08:00
|
|
|
}
|
2016-11-12 08:31:56 +08:00
|
|
|
return err;
|
2015-04-07 10:55:34 +08:00
|
|
|
}
|
|
|
|
|
|
2014-06-13 12:02:11 +08:00
|
|
|
static int get_data_block(struct inode *inode, sector_t iblock,
|
2016-01-26 15:42:58 +08:00
|
|
|
struct buffer_head *bh_result, int create, int flag,
|
|
|
|
|
pgoff_t *next_pgofs)
|
2015-08-19 19:11:19 +08:00
|
|
|
{
|
2016-01-26 15:42:58 +08:00
|
|
|
return __get_data_block(inode, iblock, bh_result, create,
|
2017-11-28 08:23:00 +08:00
|
|
|
flag, next_pgofs,
|
|
|
|
|
NO_CHECK_TYPE);
|
2015-08-19 19:11:19 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int get_data_block_dio(struct inode *inode, sector_t iblock,
|
2014-06-13 12:02:11 +08:00
|
|
|
struct buffer_head *bh_result, int create)
|
|
|
|
|
{
|
2015-08-19 19:11:19 +08:00
|
|
|
return __get_data_block(inode, iblock, bh_result, create,
|
2017-11-28 08:23:00 +08:00
|
|
|
F2FS_GET_BLOCK_DEFAULT, NULL,
|
f2fs: clean up symbol namespace
As Ted reported:
"Hi, I was looking at f2fs's sources recently, and I noticed that there
is a very large number of non-static symbols which don't have a f2fs
prefix. There's well over a hundred (see attached below).
As one example, in fs/f2fs/dir.c there is:
unsigned char get_de_type(struct f2fs_dir_entry *de)
This function is clearly only useful for f2fs, but it has a generic
name. This means that if any other file system tries to have the same
symbol name, there will be a symbol conflict and the kernel would not
successfully build. It also means that when someone is looking f2fs
sources, it's not at all obvious whether a function such as
read_data_page(), invalidate_blocks(), is a generic kernel function
found in the fs, mm, or block layers, or a f2fs specific function.
You might want to fix this at some point. Hopefully Kent's bcachefs
isn't similarly using genericly named functions, since that might
cause conflicts with f2fs's functions --- but just as this would be a
problem that we would rightly insist that Kent fix, this is something
that we should have rightly insisted that f2fs should have fixed
before it was integrated into the mainline kernel.
acquire_orphan_inode
add_ino_entry
add_orphan_inode
allocate_data_block
allocate_new_segments
alloc_nid
alloc_nid_done
alloc_nid_failed
available_free_memory
...."
This patch adds "f2fs_" prefix for all non-static symbols in order to:
a) avoid conflict with other kernel generic symbols;
b) to indicate the function is f2fs specific one instead of generic
one;
Reported-by: Theodore Ts'o <tytso@mit.edu>
Signed-off-by: Chao Yu <yuchao0@huawei.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2018-05-30 00:20:41 +08:00
|
|
|
f2fs_rw_hint_to_seg_type(
|
2017-11-28 08:23:00 +08:00
|
|
|
inode->i_write_hint));
|
2014-06-13 12:02:11 +08:00
|
|
|
}
|
|
|
|
|
|
2015-08-19 19:11:19 +08:00
|
|
|
static int get_data_block_bmap(struct inode *inode, sector_t iblock,
|
2014-06-13 12:02:11 +08:00
|
|
|
struct buffer_head *bh_result, int create)
|
|
|
|
|
{
|
2015-12-28 21:48:32 +08:00
|
|
|
/* Block number less than F2FS MAX BLOCKS */
|
2015-12-31 14:35:37 +08:00
|
|
|
if (unlikely(iblock >= F2FS_I_SB(inode)->max_file_blocks))
|
2015-12-28 21:48:32 +08:00
|
|
|
return -EFBIG;
|
|
|
|
|
|
2015-08-19 19:11:19 +08:00
|
|
|
return __get_data_block(inode, iblock, bh_result, create,
|
2017-11-28 08:23:00 +08:00
|
|
|
F2FS_GET_BLOCK_BMAP, NULL,
|
|
|
|
|
NO_CHECK_TYPE);
|
2014-06-13 12:02:11 +08:00
|
|
|
}
|
|
|
|
|
|
2015-05-09 10:30:32 +08:00
|
|
|
static inline sector_t logical_to_blk(struct inode *inode, loff_t offset)
|
|
|
|
|
{
|
|
|
|
|
return (offset >> inode->i_blkbits);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline loff_t blk_to_logical(struct inode *inode, sector_t blk)
|
|
|
|
|
{
|
|
|
|
|
return (blk << inode->i_blkbits);
|
|
|
|
|
}
|
|
|
|
|
|
2018-01-11 14:39:57 +08:00
|
|
|
static int f2fs_xattr_fiemap(struct inode *inode,
|
|
|
|
|
struct fiemap_extent_info *fieinfo)
|
|
|
|
|
{
|
|
|
|
|
struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
|
|
|
|
|
struct page *page;
|
|
|
|
|
struct node_info ni;
|
|
|
|
|
__u64 phys = 0, len;
|
|
|
|
|
__u32 flags;
|
|
|
|
|
nid_t xnid = F2FS_I(inode)->i_xattr_nid;
|
|
|
|
|
int err = 0;
|
|
|
|
|
|
|
|
|
|
if (f2fs_has_inline_xattr(inode)) {
|
|
|
|
|
int offset;
|
|
|
|
|
|
|
|
|
|
page = f2fs_grab_cache_page(NODE_MAPPING(sbi),
|
|
|
|
|
inode->i_ino, false);
|
|
|
|
|
if (!page)
|
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
f2fs: clean up symbol namespace
As Ted reported:
"Hi, I was looking at f2fs's sources recently, and I noticed that there
is a very large number of non-static symbols which don't have a f2fs
prefix. There's well over a hundred (see attached below).
As one example, in fs/f2fs/dir.c there is:
unsigned char get_de_type(struct f2fs_dir_entry *de)
This function is clearly only useful for f2fs, but it has a generic
name. This means that if any other file system tries to have the same
symbol name, there will be a symbol conflict and the kernel would not
successfully build. It also means that when someone is looking f2fs
sources, it's not at all obvious whether a function such as
read_data_page(), invalidate_blocks(), is a generic kernel function
found in the fs, mm, or block layers, or a f2fs specific function.
You might want to fix this at some point. Hopefully Kent's bcachefs
isn't similarly using genericly named functions, since that might
cause conflicts with f2fs's functions --- but just as this would be a
problem that we would rightly insist that Kent fix, this is something
that we should have rightly insisted that f2fs should have fixed
before it was integrated into the mainline kernel.
acquire_orphan_inode
add_ino_entry
add_orphan_inode
allocate_data_block
allocate_new_segments
alloc_nid
alloc_nid_done
alloc_nid_failed
available_free_memory
...."
This patch adds "f2fs_" prefix for all non-static symbols in order to:
a) avoid conflict with other kernel generic symbols;
b) to indicate the function is f2fs specific one instead of generic
one;
Reported-by: Theodore Ts'o <tytso@mit.edu>
Signed-off-by: Chao Yu <yuchao0@huawei.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2018-05-30 00:20:41 +08:00
|
|
|
f2fs_get_node_info(sbi, inode->i_ino, &ni);
|
2018-01-11 14:39:57 +08:00
|
|
|
|
|
|
|
|
phys = (__u64)blk_to_logical(inode, ni.blk_addr);
|
|
|
|
|
offset = offsetof(struct f2fs_inode, i_addr) +
|
|
|
|
|
sizeof(__le32) * (DEF_ADDRS_PER_INODE -
|
2018-01-17 16:31:36 +08:00
|
|
|
get_inline_xattr_addrs(inode));
|
2018-01-11 14:39:57 +08:00
|
|
|
|
|
|
|
|
phys += offset;
|
|
|
|
|
len = inline_xattr_size(inode);
|
|
|
|
|
|
|
|
|
|
f2fs_put_page(page, 1);
|
|
|
|
|
|
|
|
|
|
flags = FIEMAP_EXTENT_DATA_INLINE | FIEMAP_EXTENT_NOT_ALIGNED;
|
|
|
|
|
|
|
|
|
|
if (!xnid)
|
|
|
|
|
flags |= FIEMAP_EXTENT_LAST;
|
|
|
|
|
|
|
|
|
|
err = fiemap_fill_next_extent(fieinfo, 0, phys, len, flags);
|
|
|
|
|
if (err || err == 1)
|
|
|
|
|
return err;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (xnid) {
|
|
|
|
|
page = f2fs_grab_cache_page(NODE_MAPPING(sbi), xnid, false);
|
|
|
|
|
if (!page)
|
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
f2fs: clean up symbol namespace
As Ted reported:
"Hi, I was looking at f2fs's sources recently, and I noticed that there
is a very large number of non-static symbols which don't have a f2fs
prefix. There's well over a hundred (see attached below).
As one example, in fs/f2fs/dir.c there is:
unsigned char get_de_type(struct f2fs_dir_entry *de)
This function is clearly only useful for f2fs, but it has a generic
name. This means that if any other file system tries to have the same
symbol name, there will be a symbol conflict and the kernel would not
successfully build. It also means that when someone is looking f2fs
sources, it's not at all obvious whether a function such as
read_data_page(), invalidate_blocks(), is a generic kernel function
found in the fs, mm, or block layers, or a f2fs specific function.
You might want to fix this at some point. Hopefully Kent's bcachefs
isn't similarly using genericly named functions, since that might
cause conflicts with f2fs's functions --- but just as this would be a
problem that we would rightly insist that Kent fix, this is something
that we should have rightly insisted that f2fs should have fixed
before it was integrated into the mainline kernel.
acquire_orphan_inode
add_ino_entry
add_orphan_inode
allocate_data_block
allocate_new_segments
alloc_nid
alloc_nid_done
alloc_nid_failed
available_free_memory
...."
This patch adds "f2fs_" prefix for all non-static symbols in order to:
a) avoid conflict with other kernel generic symbols;
b) to indicate the function is f2fs specific one instead of generic
one;
Reported-by: Theodore Ts'o <tytso@mit.edu>
Signed-off-by: Chao Yu <yuchao0@huawei.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2018-05-30 00:20:41 +08:00
|
|
|
f2fs_get_node_info(sbi, xnid, &ni);
|
2018-01-11 14:39:57 +08:00
|
|
|
|
|
|
|
|
phys = (__u64)blk_to_logical(inode, ni.blk_addr);
|
|
|
|
|
len = inode->i_sb->s_blocksize;
|
|
|
|
|
|
|
|
|
|
f2fs_put_page(page, 1);
|
|
|
|
|
|
|
|
|
|
flags = FIEMAP_EXTENT_LAST;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (phys)
|
|
|
|
|
err = fiemap_fill_next_extent(fieinfo, 0, phys, len, flags);
|
|
|
|
|
|
|
|
|
|
return (err < 0 ? err : 0);
|
|
|
|
|
}
|
|
|
|
|
|
2014-06-08 03:30:14 +08:00
|
|
|
int f2fs_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,
|
|
|
|
|
u64 start, u64 len)
|
|
|
|
|
{
|
2015-05-09 10:30:32 +08:00
|
|
|
struct buffer_head map_bh;
|
|
|
|
|
sector_t start_blk, last_blk;
|
2016-01-26 15:42:58 +08:00
|
|
|
pgoff_t next_pgofs;
|
2015-05-09 10:30:32 +08:00
|
|
|
u64 logical = 0, phys = 0, size = 0;
|
|
|
|
|
u32 flags = 0;
|
|
|
|
|
int ret = 0;
|
|
|
|
|
|
2018-01-11 14:42:30 +08:00
|
|
|
if (fieinfo->fi_flags & FIEMAP_FLAG_CACHE) {
|
|
|
|
|
ret = f2fs_precache_extents(inode);
|
|
|
|
|
if (ret)
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2018-01-11 14:39:57 +08:00
|
|
|
ret = fiemap_check_flags(fieinfo, FIEMAP_FLAG_SYNC | FIEMAP_FLAG_XATTR);
|
2015-05-09 10:30:32 +08:00
|
|
|
if (ret)
|
|
|
|
|
return ret;
|
|
|
|
|
|
2018-01-11 14:37:35 +08:00
|
|
|
inode_lock(inode);
|
|
|
|
|
|
2018-01-11 14:39:57 +08:00
|
|
|
if (fieinfo->fi_flags & FIEMAP_FLAG_XATTR) {
|
|
|
|
|
ret = f2fs_xattr_fiemap(inode, fieinfo);
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
2015-10-16 02:34:49 +08:00
|
|
|
if (f2fs_has_inline_data(inode)) {
|
|
|
|
|
ret = f2fs_inline_data_fiemap(inode, fieinfo, start, len);
|
|
|
|
|
if (ret != -EAGAIN)
|
2018-01-11 14:37:35 +08:00
|
|
|
goto out;
|
2015-10-16 02:34:49 +08:00
|
|
|
}
|
|
|
|
|
|
2015-05-09 10:30:32 +08:00
|
|
|
if (logical_to_blk(inode, len) == 0)
|
|
|
|
|
len = blk_to_logical(inode, 1);
|
|
|
|
|
|
|
|
|
|
start_blk = logical_to_blk(inode, start);
|
|
|
|
|
last_blk = logical_to_blk(inode, start + len - 1);
|
2015-12-26 18:07:41 +08:00
|
|
|
|
2015-05-09 10:30:32 +08:00
|
|
|
next:
|
|
|
|
|
memset(&map_bh, 0, sizeof(struct buffer_head));
|
|
|
|
|
map_bh.b_size = len;
|
|
|
|
|
|
2015-08-19 19:11:19 +08:00
|
|
|
ret = get_data_block(inode, start_blk, &map_bh, 0,
|
2016-01-26 15:42:58 +08:00
|
|
|
F2FS_GET_BLOCK_FIEMAP, &next_pgofs);
|
2015-05-09 10:30:32 +08:00
|
|
|
if (ret)
|
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
|
|
/* HOLE */
|
|
|
|
|
if (!buffer_mapped(&map_bh)) {
|
2016-01-26 15:42:58 +08:00
|
|
|
start_blk = next_pgofs;
|
2016-10-11 22:57:04 +08:00
|
|
|
|
|
|
|
|
if (blk_to_logical(inode, start_blk) < blk_to_logical(inode,
|
|
|
|
|
F2FS_I_SB(inode)->max_file_blocks))
|
2015-12-26 18:07:41 +08:00
|
|
|
goto prep_next;
|
2016-10-11 22:57:04 +08:00
|
|
|
|
2015-12-26 18:07:41 +08:00
|
|
|
flags |= FIEMAP_EXTENT_LAST;
|
|
|
|
|
}
|
2015-05-09 10:30:32 +08:00
|
|
|
|
2016-01-08 20:19:27 +08:00
|
|
|
if (size) {
|
|
|
|
|
if (f2fs_encrypted_inode(inode))
|
|
|
|
|
flags |= FIEMAP_EXTENT_DATA_ENCRYPTED;
|
|
|
|
|
|
2015-12-26 18:07:41 +08:00
|
|
|
ret = fiemap_fill_next_extent(fieinfo, logical,
|
|
|
|
|
phys, size, flags);
|
2016-01-08 20:19:27 +08:00
|
|
|
}
|
2015-05-09 10:30:32 +08:00
|
|
|
|
2015-12-26 18:07:41 +08:00
|
|
|
if (start_blk > last_blk || ret)
|
|
|
|
|
goto out;
|
2015-05-09 10:30:32 +08:00
|
|
|
|
2015-12-26 18:07:41 +08:00
|
|
|
logical = blk_to_logical(inode, start_blk);
|
|
|
|
|
phys = blk_to_logical(inode, map_bh.b_blocknr);
|
|
|
|
|
size = map_bh.b_size;
|
|
|
|
|
flags = 0;
|
|
|
|
|
if (buffer_unwritten(&map_bh))
|
|
|
|
|
flags = FIEMAP_EXTENT_UNWRITTEN;
|
2015-05-09 10:30:32 +08:00
|
|
|
|
2015-12-26 18:07:41 +08:00
|
|
|
start_blk += logical_to_blk(inode, size);
|
2015-05-09 10:30:32 +08:00
|
|
|
|
2015-12-26 18:07:41 +08:00
|
|
|
prep_next:
|
2015-05-09 10:30:32 +08:00
|
|
|
cond_resched();
|
|
|
|
|
if (fatal_signal_pending(current))
|
|
|
|
|
ret = -EINTR;
|
|
|
|
|
else
|
|
|
|
|
goto next;
|
|
|
|
|
out:
|
|
|
|
|
if (ret == 1)
|
|
|
|
|
ret = 0;
|
|
|
|
|
|
2016-01-23 04:40:57 +08:00
|
|
|
inode_unlock(inode);
|
2015-05-09 10:30:32 +08:00
|
|
|
return ret;
|
2014-06-08 03:30:14 +08:00
|
|
|
}
|
|
|
|
|
|
2015-04-10 02:20:42 +08:00
|
|
|
/*
|
|
|
|
|
* This function was originally taken from fs/mpage.c, and customized for f2fs.
|
|
|
|
|
* Major change was from block_size == page_size in f2fs by default.
|
|
|
|
|
*/
|
|
|
|
|
static int f2fs_mpage_readpages(struct address_space *mapping,
|
|
|
|
|
struct list_head *pages, struct page *page,
|
|
|
|
|
unsigned nr_pages)
|
|
|
|
|
{
|
|
|
|
|
struct bio *bio = NULL;
|
|
|
|
|
sector_t last_block_in_bio = 0;
|
|
|
|
|
struct inode *inode = mapping->host;
|
|
|
|
|
const unsigned blkbits = inode->i_blkbits;
|
|
|
|
|
const unsigned blocksize = 1 << blkbits;
|
|
|
|
|
sector_t block_in_file;
|
|
|
|
|
sector_t last_block;
|
|
|
|
|
sector_t last_block_in_file;
|
|
|
|
|
sector_t block_nr;
|
|
|
|
|
struct f2fs_map_blocks map;
|
|
|
|
|
|
|
|
|
|
map.m_pblk = 0;
|
|
|
|
|
map.m_lblk = 0;
|
|
|
|
|
map.m_len = 0;
|
|
|
|
|
map.m_flags = 0;
|
2016-01-26 15:42:58 +08:00
|
|
|
map.m_next_pgofs = NULL;
|
2018-01-11 14:42:30 +08:00
|
|
|
map.m_next_extent = NULL;
|
2017-11-28 08:23:00 +08:00
|
|
|
map.m_seg_type = NO_CHECK_TYPE;
|
2015-04-10 02:20:42 +08:00
|
|
|
|
2017-11-25 11:46:18 +08:00
|
|
|
for (; nr_pages; nr_pages--) {
|
2015-04-10 02:20:42 +08:00
|
|
|
if (pages) {
|
2017-01-07 18:49:42 +08:00
|
|
|
page = list_last_entry(pages, struct page, lru);
|
2017-03-13 16:35:13 +08:00
|
|
|
|
|
|
|
|
prefetchw(&page->flags);
|
2015-04-10 02:20:42 +08:00
|
|
|
list_del(&page->lru);
|
|
|
|
|
if (add_to_page_cache_lru(page, mapping,
|
2016-07-27 06:24:53 +08:00
|
|
|
page->index,
|
|
|
|
|
readahead_gfp_mask(mapping)))
|
2015-04-10 02:20:42 +08:00
|
|
|
goto next_page;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
block_in_file = (sector_t)page->index;
|
|
|
|
|
last_block = block_in_file + nr_pages;
|
|
|
|
|
last_block_in_file = (i_size_read(inode) + blocksize - 1) >>
|
|
|
|
|
blkbits;
|
|
|
|
|
if (last_block > last_block_in_file)
|
|
|
|
|
last_block = last_block_in_file;
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Map blocks using the previous result first.
|
|
|
|
|
*/
|
|
|
|
|
if ((map.m_flags & F2FS_MAP_MAPPED) &&
|
|
|
|
|
block_in_file > map.m_lblk &&
|
|
|
|
|
block_in_file < (map.m_lblk + map.m_len))
|
|
|
|
|
goto got_it;
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Then do more f2fs_map_blocks() calls until we are
|
|
|
|
|
* done with this page.
|
|
|
|
|
*/
|
|
|
|
|
map.m_flags = 0;
|
|
|
|
|
|
|
|
|
|
if (block_in_file < last_block) {
|
|
|
|
|
map.m_lblk = block_in_file;
|
|
|
|
|
map.m_len = last_block - block_in_file;
|
|
|
|
|
|
2015-09-18 16:54:16 +08:00
|
|
|
if (f2fs_map_blocks(inode, &map, 0,
|
2017-08-09 17:27:30 +08:00
|
|
|
F2FS_GET_BLOCK_DEFAULT))
|
2015-04-10 02:20:42 +08:00
|
|
|
goto set_error_page;
|
|
|
|
|
}
|
|
|
|
|
got_it:
|
|
|
|
|
if ((map.m_flags & F2FS_MAP_MAPPED)) {
|
|
|
|
|
block_nr = map.m_pblk + block_in_file - map.m_lblk;
|
|
|
|
|
SetPageMappedToDisk(page);
|
|
|
|
|
|
|
|
|
|
if (!PageUptodate(page) && !cleancache_get_page(page)) {
|
|
|
|
|
SetPageUptodate(page);
|
|
|
|
|
goto confused;
|
|
|
|
|
}
|
|
|
|
|
} else {
|
mm, fs: get rid of PAGE_CACHE_* and page_cache_{get,release} macros
PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} macros were introduced *long* time
ago with promise that one day it will be possible to implement page
cache with bigger chunks than PAGE_SIZE.
This promise never materialized. And unlikely will.
We have many places where PAGE_CACHE_SIZE assumed to be equal to
PAGE_SIZE. And it's constant source of confusion on whether
PAGE_CACHE_* or PAGE_* constant should be used in a particular case,
especially on the border between fs and mm.
Global switching to PAGE_CACHE_SIZE != PAGE_SIZE would cause to much
breakage to be doable.
Let's stop pretending that pages in page cache are special. They are
not.
The changes are pretty straight-forward:
- <foo> << (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- <foo> >> (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} -> PAGE_{SIZE,SHIFT,MASK,ALIGN};
- page_cache_get() -> get_page();
- page_cache_release() -> put_page();
This patch contains automated changes generated with coccinelle using
script below. For some reason, coccinelle doesn't patch header files.
I've called spatch for them manually.
The only adjustment after coccinelle is revert of changes to
PAGE_CAHCE_ALIGN definition: we are going to drop it later.
There are few places in the code where coccinelle didn't reach. I'll
fix them manually in a separate patch. Comments and documentation also
will be addressed with the separate patch.
virtual patch
@@
expression E;
@@
- E << (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
expression E;
@@
- E >> (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
@@
- PAGE_CACHE_SHIFT
+ PAGE_SHIFT
@@
@@
- PAGE_CACHE_SIZE
+ PAGE_SIZE
@@
@@
- PAGE_CACHE_MASK
+ PAGE_MASK
@@
expression E;
@@
- PAGE_CACHE_ALIGN(E)
+ PAGE_ALIGN(E)
@@
expression E;
@@
- page_cache_get(E)
+ get_page(E)
@@
expression E;
@@
- page_cache_release(E)
+ put_page(E)
Signed-off-by: Kirill A. Shutemov <kirill.shutemov@linux.intel.com>
Acked-by: Michal Hocko <mhocko@suse.com>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2016-04-01 20:29:47 +08:00
|
|
|
zero_user_segment(page, 0, PAGE_SIZE);
|
2016-07-01 09:49:15 +08:00
|
|
|
if (!PageUptodate(page))
|
|
|
|
|
SetPageUptodate(page);
|
2015-04-10 02:20:42 +08:00
|
|
|
unlock_page(page);
|
|
|
|
|
goto next_page;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* This page will go to BIO. Do we need to send this
|
|
|
|
|
* BIO off first?
|
|
|
|
|
*/
|
2016-10-07 10:02:05 +08:00
|
|
|
if (bio && (last_block_in_bio != block_nr - 1 ||
|
|
|
|
|
!__same_bdev(F2FS_I_SB(inode), block_nr, bio))) {
|
2015-04-10 02:20:42 +08:00
|
|
|
submit_and_realloc:
|
2016-07-28 01:36:31 +08:00
|
|
|
__submit_bio(F2FS_I_SB(inode), bio, DATA);
|
2015-04-10 02:20:42 +08:00
|
|
|
bio = NULL;
|
|
|
|
|
}
|
|
|
|
|
if (bio == NULL) {
|
2017-09-07 12:04:44 +08:00
|
|
|
bio = f2fs_grab_read_bio(inode, block_nr, nr_pages);
|
2016-07-13 00:38:48 +08:00
|
|
|
if (IS_ERR(bio)) {
|
|
|
|
|
bio = NULL;
|
2015-04-10 02:20:42 +08:00
|
|
|
goto set_error_page;
|
2015-04-24 03:04:33 +08:00
|
|
|
}
|
2015-04-10 02:20:42 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (bio_add_page(bio, page, blocksize, 0) < blocksize)
|
|
|
|
|
goto submit_and_realloc;
|
|
|
|
|
|
|
|
|
|
last_block_in_bio = block_nr;
|
|
|
|
|
goto next_page;
|
|
|
|
|
set_error_page:
|
|
|
|
|
SetPageError(page);
|
mm, fs: get rid of PAGE_CACHE_* and page_cache_{get,release} macros
PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} macros were introduced *long* time
ago with promise that one day it will be possible to implement page
cache with bigger chunks than PAGE_SIZE.
This promise never materialized. And unlikely will.
We have many places where PAGE_CACHE_SIZE assumed to be equal to
PAGE_SIZE. And it's constant source of confusion on whether
PAGE_CACHE_* or PAGE_* constant should be used in a particular case,
especially on the border between fs and mm.
Global switching to PAGE_CACHE_SIZE != PAGE_SIZE would cause to much
breakage to be doable.
Let's stop pretending that pages in page cache are special. They are
not.
The changes are pretty straight-forward:
- <foo> << (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- <foo> >> (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} -> PAGE_{SIZE,SHIFT,MASK,ALIGN};
- page_cache_get() -> get_page();
- page_cache_release() -> put_page();
This patch contains automated changes generated with coccinelle using
script below. For some reason, coccinelle doesn't patch header files.
I've called spatch for them manually.
The only adjustment after coccinelle is revert of changes to
PAGE_CAHCE_ALIGN definition: we are going to drop it later.
There are few places in the code where coccinelle didn't reach. I'll
fix them manually in a separate patch. Comments and documentation also
will be addressed with the separate patch.
virtual patch
@@
expression E;
@@
- E << (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
expression E;
@@
- E >> (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
@@
- PAGE_CACHE_SHIFT
+ PAGE_SHIFT
@@
@@
- PAGE_CACHE_SIZE
+ PAGE_SIZE
@@
@@
- PAGE_CACHE_MASK
+ PAGE_MASK
@@
expression E;
@@
- PAGE_CACHE_ALIGN(E)
+ PAGE_ALIGN(E)
@@
expression E;
@@
- page_cache_get(E)
+ get_page(E)
@@
expression E;
@@
- page_cache_release(E)
+ put_page(E)
Signed-off-by: Kirill A. Shutemov <kirill.shutemov@linux.intel.com>
Acked-by: Michal Hocko <mhocko@suse.com>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2016-04-01 20:29:47 +08:00
|
|
|
zero_user_segment(page, 0, PAGE_SIZE);
|
2015-04-10 02:20:42 +08:00
|
|
|
unlock_page(page);
|
|
|
|
|
goto next_page;
|
|
|
|
|
confused:
|
|
|
|
|
if (bio) {
|
2016-07-28 01:36:31 +08:00
|
|
|
__submit_bio(F2FS_I_SB(inode), bio, DATA);
|
2015-04-10 02:20:42 +08:00
|
|
|
bio = NULL;
|
|
|
|
|
}
|
|
|
|
|
unlock_page(page);
|
|
|
|
|
next_page:
|
|
|
|
|
if (pages)
|
mm, fs: get rid of PAGE_CACHE_* and page_cache_{get,release} macros
PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} macros were introduced *long* time
ago with promise that one day it will be possible to implement page
cache with bigger chunks than PAGE_SIZE.
This promise never materialized. And unlikely will.
We have many places where PAGE_CACHE_SIZE assumed to be equal to
PAGE_SIZE. And it's constant source of confusion on whether
PAGE_CACHE_* or PAGE_* constant should be used in a particular case,
especially on the border between fs and mm.
Global switching to PAGE_CACHE_SIZE != PAGE_SIZE would cause to much
breakage to be doable.
Let's stop pretending that pages in page cache are special. They are
not.
The changes are pretty straight-forward:
- <foo> << (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- <foo> >> (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} -> PAGE_{SIZE,SHIFT,MASK,ALIGN};
- page_cache_get() -> get_page();
- page_cache_release() -> put_page();
This patch contains automated changes generated with coccinelle using
script below. For some reason, coccinelle doesn't patch header files.
I've called spatch for them manually.
The only adjustment after coccinelle is revert of changes to
PAGE_CAHCE_ALIGN definition: we are going to drop it later.
There are few places in the code where coccinelle didn't reach. I'll
fix them manually in a separate patch. Comments and documentation also
will be addressed with the separate patch.
virtual patch
@@
expression E;
@@
- E << (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
expression E;
@@
- E >> (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
@@
- PAGE_CACHE_SHIFT
+ PAGE_SHIFT
@@
@@
- PAGE_CACHE_SIZE
+ PAGE_SIZE
@@
@@
- PAGE_CACHE_MASK
+ PAGE_MASK
@@
expression E;
@@
- PAGE_CACHE_ALIGN(E)
+ PAGE_ALIGN(E)
@@
expression E;
@@
- page_cache_get(E)
+ get_page(E)
@@
expression E;
@@
- page_cache_release(E)
+ put_page(E)
Signed-off-by: Kirill A. Shutemov <kirill.shutemov@linux.intel.com>
Acked-by: Michal Hocko <mhocko@suse.com>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2016-04-01 20:29:47 +08:00
|
|
|
put_page(page);
|
2015-04-10 02:20:42 +08:00
|
|
|
}
|
|
|
|
|
BUG_ON(pages && !list_empty(pages));
|
|
|
|
|
if (bio)
|
2016-07-28 01:36:31 +08:00
|
|
|
__submit_bio(F2FS_I_SB(inode), bio, DATA);
|
2015-04-10 02:20:42 +08:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2012-11-02 16:10:12 +08:00
|
|
|
static int f2fs_read_data_page(struct file *file, struct page *page)
|
|
|
|
|
{
|
f2fs: handle inline data operations
Hook inline data read/write, truncate, fallocate, setattr, etc.
Files need meet following 2 requirement to inline:
1) file size is not greater than MAX_INLINE_DATA;
2) file doesn't pre-allocate data blocks by fallocate().
FI_INLINE_DATA will not be set while creating a new regular inode because
most of the files are bigger than ~3.4K. Set FI_INLINE_DATA only when
data is submitted to block layer, ranther than set it while creating a new
inode, this also avoids converting data from inline to normal data block
and vice versa.
While writting inline data to inode block, the first data block should be
released if the file has a block indexed by i_addr[0].
On the other hand, when a file operation is appied to a file with inline
data, we need to test if this file can remain inline by doing this
operation, otherwise it should be convert into normal file by reserving
a new data block, copying inline data to this new block and clear
FI_INLINE_DATA flag. Because reserve a new data block here will make use
of i_addr[0], if we save inline data in i_addr[0..872], then the first
4 bytes would be overwriten. This problem can be avoided simply by
not using i_addr[0] for inline data.
Signed-off-by: Huajun Li <huajun.li@intel.com>
Signed-off-by: Haicheng Li <haicheng.li@linux.intel.com>
Signed-off-by: Weihong Xu <weihong.xu@intel.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2013-11-10 23:13:20 +08:00
|
|
|
struct inode *inode = page->mapping->host;
|
2014-10-24 10:48:09 +08:00
|
|
|
int ret = -EAGAIN;
|
f2fs: handle inline data operations
Hook inline data read/write, truncate, fallocate, setattr, etc.
Files need meet following 2 requirement to inline:
1) file size is not greater than MAX_INLINE_DATA;
2) file doesn't pre-allocate data blocks by fallocate().
FI_INLINE_DATA will not be set while creating a new regular inode because
most of the files are bigger than ~3.4K. Set FI_INLINE_DATA only when
data is submitted to block layer, ranther than set it while creating a new
inode, this also avoids converting data from inline to normal data block
and vice versa.
While writting inline data to inode block, the first data block should be
released if the file has a block indexed by i_addr[0].
On the other hand, when a file operation is appied to a file with inline
data, we need to test if this file can remain inline by doing this
operation, otherwise it should be convert into normal file by reserving
a new data block, copying inline data to this new block and clear
FI_INLINE_DATA flag. Because reserve a new data block here will make use
of i_addr[0], if we save inline data in i_addr[0..872], then the first
4 bytes would be overwriten. This problem can be avoided simply by
not using i_addr[0] for inline data.
Signed-off-by: Huajun Li <huajun.li@intel.com>
Signed-off-by: Haicheng Li <haicheng.li@linux.intel.com>
Signed-off-by: Weihong Xu <weihong.xu@intel.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2013-11-10 23:13:20 +08:00
|
|
|
|
2014-05-06 16:53:08 +08:00
|
|
|
trace_f2fs_readpage(page, DATA);
|
|
|
|
|
|
2014-08-06 22:22:50 +08:00
|
|
|
/* If the file has inline data, try to read it directly */
|
f2fs: handle inline data operations
Hook inline data read/write, truncate, fallocate, setattr, etc.
Files need meet following 2 requirement to inline:
1) file size is not greater than MAX_INLINE_DATA;
2) file doesn't pre-allocate data blocks by fallocate().
FI_INLINE_DATA will not be set while creating a new regular inode because
most of the files are bigger than ~3.4K. Set FI_INLINE_DATA only when
data is submitted to block layer, ranther than set it while creating a new
inode, this also avoids converting data from inline to normal data block
and vice versa.
While writting inline data to inode block, the first data block should be
released if the file has a block indexed by i_addr[0].
On the other hand, when a file operation is appied to a file with inline
data, we need to test if this file can remain inline by doing this
operation, otherwise it should be convert into normal file by reserving
a new data block, copying inline data to this new block and clear
FI_INLINE_DATA flag. Because reserve a new data block here will make use
of i_addr[0], if we save inline data in i_addr[0..872], then the first
4 bytes would be overwriten. This problem can be avoided simply by
not using i_addr[0] for inline data.
Signed-off-by: Huajun Li <huajun.li@intel.com>
Signed-off-by: Haicheng Li <haicheng.li@linux.intel.com>
Signed-off-by: Weihong Xu <weihong.xu@intel.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2013-11-10 23:13:20 +08:00
|
|
|
if (f2fs_has_inline_data(inode))
|
|
|
|
|
ret = f2fs_read_inline_data(inode, page);
|
2014-10-24 10:48:09 +08:00
|
|
|
if (ret == -EAGAIN)
|
2015-04-10 02:20:42 +08:00
|
|
|
ret = f2fs_mpage_readpages(page->mapping, NULL, page, 1);
|
f2fs: handle inline data operations
Hook inline data read/write, truncate, fallocate, setattr, etc.
Files need meet following 2 requirement to inline:
1) file size is not greater than MAX_INLINE_DATA;
2) file doesn't pre-allocate data blocks by fallocate().
FI_INLINE_DATA will not be set while creating a new regular inode because
most of the files are bigger than ~3.4K. Set FI_INLINE_DATA only when
data is submitted to block layer, ranther than set it while creating a new
inode, this also avoids converting data from inline to normal data block
and vice versa.
While writting inline data to inode block, the first data block should be
released if the file has a block indexed by i_addr[0].
On the other hand, when a file operation is appied to a file with inline
data, we need to test if this file can remain inline by doing this
operation, otherwise it should be convert into normal file by reserving
a new data block, copying inline data to this new block and clear
FI_INLINE_DATA flag. Because reserve a new data block here will make use
of i_addr[0], if we save inline data in i_addr[0..872], then the first
4 bytes would be overwriten. This problem can be avoided simply by
not using i_addr[0] for inline data.
Signed-off-by: Huajun Li <huajun.li@intel.com>
Signed-off-by: Haicheng Li <haicheng.li@linux.intel.com>
Signed-off-by: Weihong Xu <weihong.xu@intel.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2013-11-10 23:13:20 +08:00
|
|
|
return ret;
|
2012-11-02 16:10:12 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int f2fs_read_data_pages(struct file *file,
|
|
|
|
|
struct address_space *mapping,
|
|
|
|
|
struct list_head *pages, unsigned nr_pages)
|
|
|
|
|
{
|
2017-09-24 02:45:42 +08:00
|
|
|
struct inode *inode = mapping->host;
|
2017-01-07 18:49:42 +08:00
|
|
|
struct page *page = list_last_entry(pages, struct page, lru);
|
2015-10-12 17:02:26 +08:00
|
|
|
|
|
|
|
|
trace_f2fs_readpages(inode, page, nr_pages);
|
f2fs: handle inline data operations
Hook inline data read/write, truncate, fallocate, setattr, etc.
Files need meet following 2 requirement to inline:
1) file size is not greater than MAX_INLINE_DATA;
2) file doesn't pre-allocate data blocks by fallocate().
FI_INLINE_DATA will not be set while creating a new regular inode because
most of the files are bigger than ~3.4K. Set FI_INLINE_DATA only when
data is submitted to block layer, ranther than set it while creating a new
inode, this also avoids converting data from inline to normal data block
and vice versa.
While writting inline data to inode block, the first data block should be
released if the file has a block indexed by i_addr[0].
On the other hand, when a file operation is appied to a file with inline
data, we need to test if this file can remain inline by doing this
operation, otherwise it should be convert into normal file by reserving
a new data block, copying inline data to this new block and clear
FI_INLINE_DATA flag. Because reserve a new data block here will make use
of i_addr[0], if we save inline data in i_addr[0..872], then the first
4 bytes would be overwriten. This problem can be avoided simply by
not using i_addr[0] for inline data.
Signed-off-by: Huajun Li <huajun.li@intel.com>
Signed-off-by: Haicheng Li <haicheng.li@linux.intel.com>
Signed-off-by: Weihong Xu <weihong.xu@intel.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2013-11-10 23:13:20 +08:00
|
|
|
|
|
|
|
|
/* If the file has inline data, skip readpages */
|
|
|
|
|
if (f2fs_has_inline_data(inode))
|
|
|
|
|
return 0;
|
|
|
|
|
|
2015-04-10 02:20:42 +08:00
|
|
|
return f2fs_mpage_readpages(mapping, pages, NULL, nr_pages);
|
2012-11-02 16:10:12 +08:00
|
|
|
}
|
|
|
|
|
|
2017-04-25 20:45:12 +08:00
|
|
|
static int encrypt_one_page(struct f2fs_io_info *fio)
|
|
|
|
|
{
|
|
|
|
|
struct inode *inode = fio->page->mapping->host;
|
|
|
|
|
gfp_t gfp_flags = GFP_NOFS;
|
|
|
|
|
|
2017-09-06 07:54:24 +08:00
|
|
|
if (!f2fs_encrypted_file(inode))
|
2017-04-25 20:45:12 +08:00
|
|
|
return 0;
|
|
|
|
|
|
f2fs: refactor read path to allow multiple postprocessing steps
Currently f2fs's ->readpage() and ->readpages() assume that either the
data undergoes no postprocessing, or decryption only. But with
fs-verity, there will be an additional authenticity verification step,
and it may be needed either by itself, or combined with decryption.
To support this, store a 'struct bio_post_read_ctx' in ->bi_private
which contains a work struct, a bitmask of postprocessing steps that are
enabled, and an indicator of the current step. The bio completion
routine, if there was no I/O error, enqueues the first postprocessing
step. When that completes, it continues to the next step. Pages that
fail any postprocessing step have PageError set. Once all steps have
completed, pages without PageError set are set Uptodate, and all pages
are unlocked.
Also replace f2fs_encrypted_file() with a new function
f2fs_post_read_required() in places like direct I/O and garbage
collection that really should be testing whether the file needs special
I/O processing, not whether it is encrypted specifically.
This may also be useful for other future f2fs features such as
compression.
Signed-off-by: Eric Biggers <ebiggers@google.com>
Reviewed-by: Chao Yu <yuchao0@huawei.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2018-04-19 02:09:48 +08:00
|
|
|
/* wait for GCed page writeback via META_MAPPING */
|
2017-09-06 08:04:35 +08:00
|
|
|
f2fs_wait_on_block_writeback(fio->sbi, fio->old_blkaddr);
|
2017-04-25 20:45:12 +08:00
|
|
|
|
|
|
|
|
retry_encrypt:
|
|
|
|
|
fio->encrypted_page = fscrypt_encrypt_page(inode, fio->page,
|
|
|
|
|
PAGE_SIZE, 0, fio->page->index, gfp_flags);
|
|
|
|
|
if (!IS_ERR(fio->encrypted_page))
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
/* flush pending IOs and wait for a while in the ENOMEM case */
|
|
|
|
|
if (PTR_ERR(fio->encrypted_page) == -ENOMEM) {
|
2017-05-11 02:28:38 +08:00
|
|
|
f2fs_flush_merged_writes(fio->sbi);
|
2017-04-25 20:45:12 +08:00
|
|
|
congestion_wait(BLK_RW_ASYNC, HZ/50);
|
|
|
|
|
gfp_flags |= __GFP_NOFAIL;
|
|
|
|
|
goto retry_encrypt;
|
|
|
|
|
}
|
|
|
|
|
return PTR_ERR(fio->encrypted_page);
|
|
|
|
|
}
|
|
|
|
|
|
2018-01-17 16:31:38 +08:00
|
|
|
static inline bool check_inplace_update_policy(struct inode *inode,
|
|
|
|
|
struct f2fs_io_info *fio)
|
2017-04-25 20:45:12 +08:00
|
|
|
{
|
2018-01-17 16:31:38 +08:00
|
|
|
struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
|
|
|
|
|
unsigned int policy = SM_I(sbi)->ipu_policy;
|
2017-04-25 20:45:12 +08:00
|
|
|
|
2018-01-17 16:31:38 +08:00
|
|
|
if (policy & (0x1 << F2FS_IPU_FORCE))
|
|
|
|
|
return true;
|
f2fs: clean up symbol namespace
As Ted reported:
"Hi, I was looking at f2fs's sources recently, and I noticed that there
is a very large number of non-static symbols which don't have a f2fs
prefix. There's well over a hundred (see attached below).
As one example, in fs/f2fs/dir.c there is:
unsigned char get_de_type(struct f2fs_dir_entry *de)
This function is clearly only useful for f2fs, but it has a generic
name. This means that if any other file system tries to have the same
symbol name, there will be a symbol conflict and the kernel would not
successfully build. It also means that when someone is looking f2fs
sources, it's not at all obvious whether a function such as
read_data_page(), invalidate_blocks(), is a generic kernel function
found in the fs, mm, or block layers, or a f2fs specific function.
You might want to fix this at some point. Hopefully Kent's bcachefs
isn't similarly using genericly named functions, since that might
cause conflicts with f2fs's functions --- but just as this would be a
problem that we would rightly insist that Kent fix, this is something
that we should have rightly insisted that f2fs should have fixed
before it was integrated into the mainline kernel.
acquire_orphan_inode
add_ino_entry
add_orphan_inode
allocate_data_block
allocate_new_segments
alloc_nid
alloc_nid_done
alloc_nid_failed
available_free_memory
...."
This patch adds "f2fs_" prefix for all non-static symbols in order to:
a) avoid conflict with other kernel generic symbols;
b) to indicate the function is f2fs specific one instead of generic
one;
Reported-by: Theodore Ts'o <tytso@mit.edu>
Signed-off-by: Chao Yu <yuchao0@huawei.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2018-05-30 00:20:41 +08:00
|
|
|
if (policy & (0x1 << F2FS_IPU_SSR) && f2fs_need_SSR(sbi))
|
2018-01-17 16:31:38 +08:00
|
|
|
return true;
|
|
|
|
|
if (policy & (0x1 << F2FS_IPU_UTIL) &&
|
|
|
|
|
utilization(sbi) > SM_I(sbi)->min_ipu_util)
|
|
|
|
|
return true;
|
f2fs: clean up symbol namespace
As Ted reported:
"Hi, I was looking at f2fs's sources recently, and I noticed that there
is a very large number of non-static symbols which don't have a f2fs
prefix. There's well over a hundred (see attached below).
As one example, in fs/f2fs/dir.c there is:
unsigned char get_de_type(struct f2fs_dir_entry *de)
This function is clearly only useful for f2fs, but it has a generic
name. This means that if any other file system tries to have the same
symbol name, there will be a symbol conflict and the kernel would not
successfully build. It also means that when someone is looking f2fs
sources, it's not at all obvious whether a function such as
read_data_page(), invalidate_blocks(), is a generic kernel function
found in the fs, mm, or block layers, or a f2fs specific function.
You might want to fix this at some point. Hopefully Kent's bcachefs
isn't similarly using genericly named functions, since that might
cause conflicts with f2fs's functions --- but just as this would be a
problem that we would rightly insist that Kent fix, this is something
that we should have rightly insisted that f2fs should have fixed
before it was integrated into the mainline kernel.
acquire_orphan_inode
add_ino_entry
add_orphan_inode
allocate_data_block
allocate_new_segments
alloc_nid
alloc_nid_done
alloc_nid_failed
available_free_memory
...."
This patch adds "f2fs_" prefix for all non-static symbols in order to:
a) avoid conflict with other kernel generic symbols;
b) to indicate the function is f2fs specific one instead of generic
one;
Reported-by: Theodore Ts'o <tytso@mit.edu>
Signed-off-by: Chao Yu <yuchao0@huawei.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2018-05-30 00:20:41 +08:00
|
|
|
if (policy & (0x1 << F2FS_IPU_SSR_UTIL) && f2fs_need_SSR(sbi) &&
|
2018-01-17 16:31:38 +08:00
|
|
|
utilization(sbi) > SM_I(sbi)->min_ipu_util)
|
|
|
|
|
return true;
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* IPU for rewrite async pages
|
|
|
|
|
*/
|
|
|
|
|
if (policy & (0x1 << F2FS_IPU_ASYNC) &&
|
|
|
|
|
fio && fio->op == REQ_OP_WRITE &&
|
|
|
|
|
!(fio->op_flags & REQ_SYNC) &&
|
|
|
|
|
!f2fs_encrypted_inode(inode))
|
|
|
|
|
return true;
|
|
|
|
|
|
|
|
|
|
/* this is only set during fdatasync */
|
|
|
|
|
if (policy & (0x1 << F2FS_IPU_FSYNC) &&
|
|
|
|
|
is_inode_flag_set(inode, FI_NEED_IPU))
|
|
|
|
|
return true;
|
|
|
|
|
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
|
f2fs: clean up symbol namespace
As Ted reported:
"Hi, I was looking at f2fs's sources recently, and I noticed that there
is a very large number of non-static symbols which don't have a f2fs
prefix. There's well over a hundred (see attached below).
As one example, in fs/f2fs/dir.c there is:
unsigned char get_de_type(struct f2fs_dir_entry *de)
This function is clearly only useful for f2fs, but it has a generic
name. This means that if any other file system tries to have the same
symbol name, there will be a symbol conflict and the kernel would not
successfully build. It also means that when someone is looking f2fs
sources, it's not at all obvious whether a function such as
read_data_page(), invalidate_blocks(), is a generic kernel function
found in the fs, mm, or block layers, or a f2fs specific function.
You might want to fix this at some point. Hopefully Kent's bcachefs
isn't similarly using genericly named functions, since that might
cause conflicts with f2fs's functions --- but just as this would be a
problem that we would rightly insist that Kent fix, this is something
that we should have rightly insisted that f2fs should have fixed
before it was integrated into the mainline kernel.
acquire_orphan_inode
add_ino_entry
add_orphan_inode
allocate_data_block
allocate_new_segments
alloc_nid
alloc_nid_done
alloc_nid_failed
available_free_memory
...."
This patch adds "f2fs_" prefix for all non-static symbols in order to:
a) avoid conflict with other kernel generic symbols;
b) to indicate the function is f2fs specific one instead of generic
one;
Reported-by: Theodore Ts'o <tytso@mit.edu>
Signed-off-by: Chao Yu <yuchao0@huawei.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2018-05-30 00:20:41 +08:00
|
|
|
bool f2fs_should_update_inplace(struct inode *inode, struct f2fs_io_info *fio)
|
2018-01-17 16:31:38 +08:00
|
|
|
{
|
2017-12-08 08:25:39 +08:00
|
|
|
if (f2fs_is_pinned_file(inode))
|
|
|
|
|
return true;
|
2018-01-17 16:31:38 +08:00
|
|
|
|
|
|
|
|
/* if this is cold file, we should overwrite to avoid fragmentation */
|
|
|
|
|
if (file_is_cold(inode))
|
|
|
|
|
return true;
|
|
|
|
|
|
|
|
|
|
return check_inplace_update_policy(inode, fio);
|
|
|
|
|
}
|
|
|
|
|
|
f2fs: clean up symbol namespace
As Ted reported:
"Hi, I was looking at f2fs's sources recently, and I noticed that there
is a very large number of non-static symbols which don't have a f2fs
prefix. There's well over a hundred (see attached below).
As one example, in fs/f2fs/dir.c there is:
unsigned char get_de_type(struct f2fs_dir_entry *de)
This function is clearly only useful for f2fs, but it has a generic
name. This means that if any other file system tries to have the same
symbol name, there will be a symbol conflict and the kernel would not
successfully build. It also means that when someone is looking f2fs
sources, it's not at all obvious whether a function such as
read_data_page(), invalidate_blocks(), is a generic kernel function
found in the fs, mm, or block layers, or a f2fs specific function.
You might want to fix this at some point. Hopefully Kent's bcachefs
isn't similarly using genericly named functions, since that might
cause conflicts with f2fs's functions --- but just as this would be a
problem that we would rightly insist that Kent fix, this is something
that we should have rightly insisted that f2fs should have fixed
before it was integrated into the mainline kernel.
acquire_orphan_inode
add_ino_entry
add_orphan_inode
allocate_data_block
allocate_new_segments
alloc_nid
alloc_nid_done
alloc_nid_failed
available_free_memory
...."
This patch adds "f2fs_" prefix for all non-static symbols in order to:
a) avoid conflict with other kernel generic symbols;
b) to indicate the function is f2fs specific one instead of generic
one;
Reported-by: Theodore Ts'o <tytso@mit.edu>
Signed-off-by: Chao Yu <yuchao0@huawei.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2018-05-30 00:20:41 +08:00
|
|
|
bool f2fs_should_update_outplace(struct inode *inode, struct f2fs_io_info *fio)
|
2018-01-17 16:31:38 +08:00
|
|
|
{
|
|
|
|
|
struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
|
|
|
|
|
|
|
|
|
|
if (test_opt(sbi, LFS))
|
|
|
|
|
return true;
|
|
|
|
|
if (S_ISDIR(inode->i_mode))
|
|
|
|
|
return true;
|
|
|
|
|
if (f2fs_is_atomic_file(inode))
|
|
|
|
|
return true;
|
|
|
|
|
if (fio) {
|
|
|
|
|
if (is_cold_data(fio->page))
|
|
|
|
|
return true;
|
|
|
|
|
if (IS_ATOMIC_WRITTEN_PAGE(fio->page))
|
|
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
|
2017-04-25 20:45:12 +08:00
|
|
|
static inline bool need_inplace_update(struct f2fs_io_info *fio)
|
|
|
|
|
{
|
|
|
|
|
struct inode *inode = fio->page->mapping->host;
|
|
|
|
|
|
f2fs: clean up symbol namespace
As Ted reported:
"Hi, I was looking at f2fs's sources recently, and I noticed that there
is a very large number of non-static symbols which don't have a f2fs
prefix. There's well over a hundred (see attached below).
As one example, in fs/f2fs/dir.c there is:
unsigned char get_de_type(struct f2fs_dir_entry *de)
This function is clearly only useful for f2fs, but it has a generic
name. This means that if any other file system tries to have the same
symbol name, there will be a symbol conflict and the kernel would not
successfully build. It also means that when someone is looking f2fs
sources, it's not at all obvious whether a function such as
read_data_page(), invalidate_blocks(), is a generic kernel function
found in the fs, mm, or block layers, or a f2fs specific function.
You might want to fix this at some point. Hopefully Kent's bcachefs
isn't similarly using genericly named functions, since that might
cause conflicts with f2fs's functions --- but just as this would be a
problem that we would rightly insist that Kent fix, this is something
that we should have rightly insisted that f2fs should have fixed
before it was integrated into the mainline kernel.
acquire_orphan_inode
add_ino_entry
add_orphan_inode
allocate_data_block
allocate_new_segments
alloc_nid
alloc_nid_done
alloc_nid_failed
available_free_memory
...."
This patch adds "f2fs_" prefix for all non-static symbols in order to:
a) avoid conflict with other kernel generic symbols;
b) to indicate the function is f2fs specific one instead of generic
one;
Reported-by: Theodore Ts'o <tytso@mit.edu>
Signed-off-by: Chao Yu <yuchao0@huawei.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2018-05-30 00:20:41 +08:00
|
|
|
if (f2fs_should_update_outplace(inode, fio))
|
2017-04-25 20:45:12 +08:00
|
|
|
return false;
|
|
|
|
|
|
f2fs: clean up symbol namespace
As Ted reported:
"Hi, I was looking at f2fs's sources recently, and I noticed that there
is a very large number of non-static symbols which don't have a f2fs
prefix. There's well over a hundred (see attached below).
As one example, in fs/f2fs/dir.c there is:
unsigned char get_de_type(struct f2fs_dir_entry *de)
This function is clearly only useful for f2fs, but it has a generic
name. This means that if any other file system tries to have the same
symbol name, there will be a symbol conflict and the kernel would not
successfully build. It also means that when someone is looking f2fs
sources, it's not at all obvious whether a function such as
read_data_page(), invalidate_blocks(), is a generic kernel function
found in the fs, mm, or block layers, or a f2fs specific function.
You might want to fix this at some point. Hopefully Kent's bcachefs
isn't similarly using genericly named functions, since that might
cause conflicts with f2fs's functions --- but just as this would be a
problem that we would rightly insist that Kent fix, this is something
that we should have rightly insisted that f2fs should have fixed
before it was integrated into the mainline kernel.
acquire_orphan_inode
add_ino_entry
add_orphan_inode
allocate_data_block
allocate_new_segments
alloc_nid
alloc_nid_done
alloc_nid_failed
available_free_memory
...."
This patch adds "f2fs_" prefix for all non-static symbols in order to:
a) avoid conflict with other kernel generic symbols;
b) to indicate the function is f2fs specific one instead of generic
one;
Reported-by: Theodore Ts'o <tytso@mit.edu>
Signed-off-by: Chao Yu <yuchao0@huawei.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2018-05-30 00:20:41 +08:00
|
|
|
return f2fs_should_update_inplace(inode, fio);
|
2017-04-25 20:45:12 +08:00
|
|
|
}
|
|
|
|
|
|
f2fs: clean up symbol namespace
As Ted reported:
"Hi, I was looking at f2fs's sources recently, and I noticed that there
is a very large number of non-static symbols which don't have a f2fs
prefix. There's well over a hundred (see attached below).
As one example, in fs/f2fs/dir.c there is:
unsigned char get_de_type(struct f2fs_dir_entry *de)
This function is clearly only useful for f2fs, but it has a generic
name. This means that if any other file system tries to have the same
symbol name, there will be a symbol conflict and the kernel would not
successfully build. It also means that when someone is looking f2fs
sources, it's not at all obvious whether a function such as
read_data_page(), invalidate_blocks(), is a generic kernel function
found in the fs, mm, or block layers, or a f2fs specific function.
You might want to fix this at some point. Hopefully Kent's bcachefs
isn't similarly using genericly named functions, since that might
cause conflicts with f2fs's functions --- but just as this would be a
problem that we would rightly insist that Kent fix, this is something
that we should have rightly insisted that f2fs should have fixed
before it was integrated into the mainline kernel.
acquire_orphan_inode
add_ino_entry
add_orphan_inode
allocate_data_block
allocate_new_segments
alloc_nid
alloc_nid_done
alloc_nid_failed
available_free_memory
...."
This patch adds "f2fs_" prefix for all non-static symbols in order to:
a) avoid conflict with other kernel generic symbols;
b) to indicate the function is f2fs specific one instead of generic
one;
Reported-by: Theodore Ts'o <tytso@mit.edu>
Signed-off-by: Chao Yu <yuchao0@huawei.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2018-05-30 00:20:41 +08:00
|
|
|
int f2fs_do_write_data_page(struct f2fs_io_info *fio)
|
2012-11-02 16:10:12 +08:00
|
|
|
{
|
2015-04-24 05:38:15 +08:00
|
|
|
struct page *page = fio->page;
|
2012-11-02 16:10:12 +08:00
|
|
|
struct inode *inode = page->mapping->host;
|
|
|
|
|
struct dnode_of_data dn;
|
2017-04-25 20:45:13 +08:00
|
|
|
struct extent_info ei = {0,0,0};
|
|
|
|
|
bool ipu_force = false;
|
2012-11-02 16:10:12 +08:00
|
|
|
int err = 0;
|
|
|
|
|
|
|
|
|
|
set_new_dnode(&dn, inode, NULL, NULL, 0);
|
2017-04-25 20:45:13 +08:00
|
|
|
if (need_inplace_update(fio) &&
|
|
|
|
|
f2fs_lookup_extent_cache(inode, page->index, &ei)) {
|
|
|
|
|
fio->old_blkaddr = ei.blk + page->index - ei.fofs;
|
2017-04-25 06:20:16 +08:00
|
|
|
|
2018-05-23 22:25:08 +08:00
|
|
|
if (is_valid_blkaddr(fio->old_blkaddr)) {
|
2017-04-25 20:45:13 +08:00
|
|
|
ipu_force = true;
|
2017-05-13 04:51:34 +08:00
|
|
|
fio->need_lock = LOCK_DONE;
|
2017-04-25 20:45:13 +08:00
|
|
|
goto got_it;
|
|
|
|
|
}
|
|
|
|
|
}
|
2017-04-27 00:17:21 +08:00
|
|
|
|
2017-06-22 08:52:39 +08:00
|
|
|
/* Deadlock due to between page->lock and f2fs_lock_op */
|
|
|
|
|
if (fio->need_lock == LOCK_REQ && !f2fs_trylock_op(fio->sbi))
|
|
|
|
|
return -EAGAIN;
|
2017-04-27 00:17:21 +08:00
|
|
|
|
f2fs: clean up symbol namespace
As Ted reported:
"Hi, I was looking at f2fs's sources recently, and I noticed that there
is a very large number of non-static symbols which don't have a f2fs
prefix. There's well over a hundred (see attached below).
As one example, in fs/f2fs/dir.c there is:
unsigned char get_de_type(struct f2fs_dir_entry *de)
This function is clearly only useful for f2fs, but it has a generic
name. This means that if any other file system tries to have the same
symbol name, there will be a symbol conflict and the kernel would not
successfully build. It also means that when someone is looking f2fs
sources, it's not at all obvious whether a function such as
read_data_page(), invalidate_blocks(), is a generic kernel function
found in the fs, mm, or block layers, or a f2fs specific function.
You might want to fix this at some point. Hopefully Kent's bcachefs
isn't similarly using genericly named functions, since that might
cause conflicts with f2fs's functions --- but just as this would be a
problem that we would rightly insist that Kent fix, this is something
that we should have rightly insisted that f2fs should have fixed
before it was integrated into the mainline kernel.
acquire_orphan_inode
add_ino_entry
add_orphan_inode
allocate_data_block
allocate_new_segments
alloc_nid
alloc_nid_done
alloc_nid_failed
available_free_memory
...."
This patch adds "f2fs_" prefix for all non-static symbols in order to:
a) avoid conflict with other kernel generic symbols;
b) to indicate the function is f2fs specific one instead of generic
one;
Reported-by: Theodore Ts'o <tytso@mit.edu>
Signed-off-by: Chao Yu <yuchao0@huawei.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2018-05-30 00:20:41 +08:00
|
|
|
err = f2fs_get_dnode_of_data(&dn, page->index, LOOKUP_NODE);
|
2012-11-02 16:10:12 +08:00
|
|
|
if (err)
|
2017-04-27 00:17:21 +08:00
|
|
|
goto out;
|
2012-11-02 16:10:12 +08:00
|
|
|
|
f2fs: support revoking atomic written pages
f2fs support atomic write with following semantics:
1. open db file
2. ioctl start atomic write
3. (write db file) * n
4. ioctl commit atomic write
5. close db file
With this flow we can avoid file becoming corrupted when abnormal power
cut, because we hold data of transaction in referenced pages linked in
inmem_pages list of inode, but without setting them dirty, so these data
won't be persisted unless we commit them in step 4.
But we should still hold journal db file in memory by using volatile
write, because our semantics of 'atomic write support' is incomplete, in
step 4, we could fail to submit all dirty data of transaction, once
partial dirty data was committed in storage, then after a checkpoint &
abnormal power-cut, db file will be corrupted forever.
So this patch tries to improve atomic write flow by adding a revoking flow,
once inner error occurs in committing, this gives another chance to try to
revoke these partial submitted data of current transaction, it makes
committing operation more like aotmical one.
If we're not lucky, once revoking operation was failed, EAGAIN will be
reported to user for suggesting doing the recovery with held journal file,
or retrying current transaction again.
Signed-off-by: Chao Yu <chao2.yu@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2016-02-06 14:40:34 +08:00
|
|
|
fio->old_blkaddr = dn.data_blkaddr;
|
2012-11-02 16:10:12 +08:00
|
|
|
|
|
|
|
|
/* This page is already truncated */
|
f2fs: trace old block address for CoWed page
This patch enables to trace old block address of CoWed page for better
debugging.
f2fs_submit_page_mbio: dev = (1,0), ino = 1, page_index = 0x1d4f0, oldaddr = 0xfe8ab, newaddr = 0xfee90 rw = WRITE_SYNC, type = NODE
f2fs_submit_page_mbio: dev = (1,0), ino = 1, page_index = 0x1d4f8, oldaddr = 0xfe8b0, newaddr = 0xfee91 rw = WRITE_SYNC, type = NODE
f2fs_submit_page_mbio: dev = (1,0), ino = 1, page_index = 0x1d4fa, oldaddr = 0xfe8ae, newaddr = 0xfee92 rw = WRITE_SYNC, type = NODE
f2fs_submit_page_mbio: dev = (1,0), ino = 134824, page_index = 0x96, oldaddr = 0xf049b, newaddr = 0x2bbe rw = WRITE, type = DATA
f2fs_submit_page_mbio: dev = (1,0), ino = 134824, page_index = 0x97, oldaddr = 0xf049c, newaddr = 0x2bbf rw = WRITE, type = DATA
f2fs_submit_page_mbio: dev = (1,0), ino = 134824, page_index = 0x98, oldaddr = 0xf049d, newaddr = 0x2bc0 rw = WRITE, type = DATA
f2fs_submit_page_mbio: dev = (1,0), ino = 135260, page_index = 0x47, oldaddr = 0xffffffff, newaddr = 0xf2631 rw = WRITE, type = DATA
f2fs_submit_page_mbio: dev = (1,0), ino = 135260, page_index = 0x48, oldaddr = 0xffffffff, newaddr = 0xf2632 rw = WRITE, type = DATA
f2fs_submit_page_mbio: dev = (1,0), ino = 135260, page_index = 0x49, oldaddr = 0xffffffff, newaddr = 0xf2633 rw = WRITE, type = DATA
Signed-off-by: Chao Yu <chao2.yu@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2016-02-22 18:36:38 +08:00
|
|
|
if (fio->old_blkaddr == NULL_ADDR) {
|
2015-02-26 11:25:01 +08:00
|
|
|
ClearPageUptodate(page);
|
2012-11-02 16:10:12 +08:00
|
|
|
goto out_writepage;
|
2015-02-26 11:25:01 +08:00
|
|
|
}
|
2017-04-25 20:45:13 +08:00
|
|
|
got_it:
|
2012-11-02 16:10:12 +08:00
|
|
|
/*
|
|
|
|
|
* If current allocation needs SSR,
|
|
|
|
|
* it had better in-place writes for updated data.
|
|
|
|
|
*/
|
2018-05-23 22:25:08 +08:00
|
|
|
if (ipu_force || (is_valid_blkaddr(fio->old_blkaddr) &&
|
|
|
|
|
need_inplace_update(fio))) {
|
2017-05-13 04:51:34 +08:00
|
|
|
err = encrypt_one_page(fio);
|
|
|
|
|
if (err)
|
|
|
|
|
goto out_writepage;
|
|
|
|
|
|
|
|
|
|
set_page_writeback(page);
|
2018-04-12 14:09:04 +08:00
|
|
|
ClearPageError(page);
|
2017-04-27 00:17:21 +08:00
|
|
|
f2fs_put_dnode(&dn);
|
2017-05-13 04:51:34 +08:00
|
|
|
if (fio->need_lock == LOCK_REQ)
|
2017-04-27 00:17:21 +08:00
|
|
|
f2fs_unlock_op(fio->sbi);
|
f2fs: clean up symbol namespace
As Ted reported:
"Hi, I was looking at f2fs's sources recently, and I noticed that there
is a very large number of non-static symbols which don't have a f2fs
prefix. There's well over a hundred (see attached below).
As one example, in fs/f2fs/dir.c there is:
unsigned char get_de_type(struct f2fs_dir_entry *de)
This function is clearly only useful for f2fs, but it has a generic
name. This means that if any other file system tries to have the same
symbol name, there will be a symbol conflict and the kernel would not
successfully build. It also means that when someone is looking f2fs
sources, it's not at all obvious whether a function such as
read_data_page(), invalidate_blocks(), is a generic kernel function
found in the fs, mm, or block layers, or a f2fs specific function.
You might want to fix this at some point. Hopefully Kent's bcachefs
isn't similarly using genericly named functions, since that might
cause conflicts with f2fs's functions --- but just as this would be a
problem that we would rightly insist that Kent fix, this is something
that we should have rightly insisted that f2fs should have fixed
before it was integrated into the mainline kernel.
acquire_orphan_inode
add_ino_entry
add_orphan_inode
allocate_data_block
allocate_new_segments
alloc_nid
alloc_nid_done
alloc_nid_failed
available_free_memory
...."
This patch adds "f2fs_" prefix for all non-static symbols in order to:
a) avoid conflict with other kernel generic symbols;
b) to indicate the function is f2fs specific one instead of generic
one;
Reported-by: Theodore Ts'o <tytso@mit.edu>
Signed-off-by: Chao Yu <yuchao0@huawei.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2018-05-30 00:20:41 +08:00
|
|
|
err = f2fs_inplace_write_data(fio);
|
2017-04-25 20:45:12 +08:00
|
|
|
trace_f2fs_do_write_data_page(fio->page, IPU);
|
2016-05-21 01:13:22 +08:00
|
|
|
set_inode_flag(inode, FI_UPDATE_WRITE);
|
2017-04-27 00:17:21 +08:00
|
|
|
return err;
|
2012-11-02 16:10:12 +08:00
|
|
|
}
|
2017-04-27 00:17:21 +08:00
|
|
|
|
2017-05-13 04:51:34 +08:00
|
|
|
if (fio->need_lock == LOCK_RETRY) {
|
|
|
|
|
if (!f2fs_trylock_op(fio->sbi)) {
|
|
|
|
|
err = -EAGAIN;
|
|
|
|
|
goto out_writepage;
|
|
|
|
|
}
|
|
|
|
|
fio->need_lock = LOCK_REQ;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
err = encrypt_one_page(fio);
|
|
|
|
|
if (err)
|
|
|
|
|
goto out_writepage;
|
|
|
|
|
|
|
|
|
|
set_page_writeback(page);
|
2018-04-12 14:09:04 +08:00
|
|
|
ClearPageError(page);
|
2017-05-13 04:51:34 +08:00
|
|
|
|
2017-04-27 00:17:21 +08:00
|
|
|
/* LFS mode write path */
|
f2fs: clean up symbol namespace
As Ted reported:
"Hi, I was looking at f2fs's sources recently, and I noticed that there
is a very large number of non-static symbols which don't have a f2fs
prefix. There's well over a hundred (see attached below).
As one example, in fs/f2fs/dir.c there is:
unsigned char get_de_type(struct f2fs_dir_entry *de)
This function is clearly only useful for f2fs, but it has a generic
name. This means that if any other file system tries to have the same
symbol name, there will be a symbol conflict and the kernel would not
successfully build. It also means that when someone is looking f2fs
sources, it's not at all obvious whether a function such as
read_data_page(), invalidate_blocks(), is a generic kernel function
found in the fs, mm, or block layers, or a f2fs specific function.
You might want to fix this at some point. Hopefully Kent's bcachefs
isn't similarly using genericly named functions, since that might
cause conflicts with f2fs's functions --- but just as this would be a
problem that we would rightly insist that Kent fix, this is something
that we should have rightly insisted that f2fs should have fixed
before it was integrated into the mainline kernel.
acquire_orphan_inode
add_ino_entry
add_orphan_inode
allocate_data_block
allocate_new_segments
alloc_nid
alloc_nid_done
alloc_nid_failed
available_free_memory
...."
This patch adds "f2fs_" prefix for all non-static symbols in order to:
a) avoid conflict with other kernel generic symbols;
b) to indicate the function is f2fs specific one instead of generic
one;
Reported-by: Theodore Ts'o <tytso@mit.edu>
Signed-off-by: Chao Yu <yuchao0@huawei.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2018-05-30 00:20:41 +08:00
|
|
|
f2fs_outplace_write_data(&dn, fio);
|
2017-04-27 00:17:21 +08:00
|
|
|
trace_f2fs_do_write_data_page(page, OPU);
|
|
|
|
|
set_inode_flag(inode, FI_APPEND_WRITE);
|
|
|
|
|
if (page->index == 0)
|
|
|
|
|
set_inode_flag(inode, FI_FIRST_BLOCK_WRITTEN);
|
2012-11-02 16:10:12 +08:00
|
|
|
out_writepage:
|
|
|
|
|
f2fs_put_dnode(&dn);
|
2017-04-27 00:17:21 +08:00
|
|
|
out:
|
2017-05-13 04:51:34 +08:00
|
|
|
if (fio->need_lock == LOCK_REQ)
|
2017-04-27 00:17:21 +08:00
|
|
|
f2fs_unlock_op(fio->sbi);
|
2012-11-02 16:10:12 +08:00
|
|
|
return err;
|
|
|
|
|
}
|
|
|
|
|
|
2017-02-04 09:44:04 +08:00
|
|
|
static int __write_data_page(struct page *page, bool *submitted,
|
2017-08-02 23:21:48 +08:00
|
|
|
struct writeback_control *wbc,
|
|
|
|
|
enum iostat_type io_type)
|
2012-11-02 16:10:12 +08:00
|
|
|
{
|
|
|
|
|
struct inode *inode = page->mapping->host;
|
2014-09-03 06:31:18 +08:00
|
|
|
struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
|
2012-11-02 16:10:12 +08:00
|
|
|
loff_t i_size = i_size_read(inode);
|
|
|
|
|
const pgoff_t end_index = ((unsigned long long) i_size)
|
mm, fs: get rid of PAGE_CACHE_* and page_cache_{get,release} macros
PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} macros were introduced *long* time
ago with promise that one day it will be possible to implement page
cache with bigger chunks than PAGE_SIZE.
This promise never materialized. And unlikely will.
We have many places where PAGE_CACHE_SIZE assumed to be equal to
PAGE_SIZE. And it's constant source of confusion on whether
PAGE_CACHE_* or PAGE_* constant should be used in a particular case,
especially on the border between fs and mm.
Global switching to PAGE_CACHE_SIZE != PAGE_SIZE would cause to much
breakage to be doable.
Let's stop pretending that pages in page cache are special. They are
not.
The changes are pretty straight-forward:
- <foo> << (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- <foo> >> (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} -> PAGE_{SIZE,SHIFT,MASK,ALIGN};
- page_cache_get() -> get_page();
- page_cache_release() -> put_page();
This patch contains automated changes generated with coccinelle using
script below. For some reason, coccinelle doesn't patch header files.
I've called spatch for them manually.
The only adjustment after coccinelle is revert of changes to
PAGE_CAHCE_ALIGN definition: we are going to drop it later.
There are few places in the code where coccinelle didn't reach. I'll
fix them manually in a separate patch. Comments and documentation also
will be addressed with the separate patch.
virtual patch
@@
expression E;
@@
- E << (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
expression E;
@@
- E >> (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
@@
- PAGE_CACHE_SHIFT
+ PAGE_SHIFT
@@
@@
- PAGE_CACHE_SIZE
+ PAGE_SIZE
@@
@@
- PAGE_CACHE_MASK
+ PAGE_MASK
@@
expression E;
@@
- PAGE_CACHE_ALIGN(E)
+ PAGE_ALIGN(E)
@@
expression E;
@@
- page_cache_get(E)
+ get_page(E)
@@
expression E;
@@
- page_cache_release(E)
+ put_page(E)
Signed-off-by: Kirill A. Shutemov <kirill.shutemov@linux.intel.com>
Acked-by: Michal Hocko <mhocko@suse.com>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2016-04-01 20:29:47 +08:00
|
|
|
>> PAGE_SHIFT;
|
2016-05-21 11:42:37 +08:00
|
|
|
loff_t psize = (page->index + 1) << PAGE_SHIFT;
|
f2fs: handle inline data operations
Hook inline data read/write, truncate, fallocate, setattr, etc.
Files need meet following 2 requirement to inline:
1) file size is not greater than MAX_INLINE_DATA;
2) file doesn't pre-allocate data blocks by fallocate().
FI_INLINE_DATA will not be set while creating a new regular inode because
most of the files are bigger than ~3.4K. Set FI_INLINE_DATA only when
data is submitted to block layer, ranther than set it while creating a new
inode, this also avoids converting data from inline to normal data block
and vice versa.
While writting inline data to inode block, the first data block should be
released if the file has a block indexed by i_addr[0].
On the other hand, when a file operation is appied to a file with inline
data, we need to test if this file can remain inline by doing this
operation, otherwise it should be convert into normal file by reserving
a new data block, copying inline data to this new block and clear
FI_INLINE_DATA flag. Because reserve a new data block here will make use
of i_addr[0], if we save inline data in i_addr[0..872], then the first
4 bytes would be overwriten. This problem can be avoided simply by
not using i_addr[0] for inline data.
Signed-off-by: Huajun Li <huajun.li@intel.com>
Signed-off-by: Haicheng Li <haicheng.li@linux.intel.com>
Signed-off-by: Weihong Xu <weihong.xu@intel.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2013-11-10 23:13:20 +08:00
|
|
|
unsigned offset = 0;
|
f2fs: introduce a new global lock scheme
In the previous version, f2fs uses global locks according to the usage types,
such as directory operations, block allocation, block write, and so on.
Reference the following lock types in f2fs.h.
enum lock_type {
RENAME, /* for renaming operations */
DENTRY_OPS, /* for directory operations */
DATA_WRITE, /* for data write */
DATA_NEW, /* for data allocation */
DATA_TRUNC, /* for data truncate */
NODE_NEW, /* for node allocation */
NODE_TRUNC, /* for node truncate */
NODE_WRITE, /* for node write */
NR_LOCK_TYPE,
};
In that case, we lose the performance under the multi-threading environment,
since every types of operations must be conducted one at a time.
In order to address the problem, let's share the locks globally with a mutex
array regardless of any types.
So, let users grab a mutex and perform their jobs in parallel as much as
possbile.
For this, I propose a new global lock scheme as follows.
0. Data structure
- f2fs_sb_info -> mutex_lock[NR_GLOBAL_LOCKS]
- f2fs_sb_info -> node_write
1. mutex_lock_op(sbi)
- try to get an avaiable lock from the array.
- returns the index of the gottern lock variable.
2. mutex_unlock_op(sbi, index of the lock)
- unlock the given index of the lock.
3. mutex_lock_all(sbi)
- grab all the locks in the array before the checkpoint.
4. mutex_unlock_all(sbi)
- release all the locks in the array after checkpoint.
5. block_operations()
- call mutex_lock_all()
- sync_dirty_dir_inodes()
- grab node_write
- sync_node_pages()
Note that,
the pairs of mutex_lock_op()/mutex_unlock_op() and
mutex_lock_all()/mutex_unlock_all() should be used together.
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-22 15:21:29 +08:00
|
|
|
bool need_balance_fs = false;
|
2012-11-02 16:10:12 +08:00
|
|
|
int err = 0;
|
2013-12-11 12:54:01 +08:00
|
|
|
struct f2fs_io_info fio = {
|
2015-04-24 05:38:15 +08:00
|
|
|
.sbi = sbi,
|
2017-09-29 13:59:38 +08:00
|
|
|
.ino = inode->i_ino,
|
2013-12-11 12:54:01 +08:00
|
|
|
.type = DATA,
|
2016-06-06 03:31:55 +08:00
|
|
|
.op = REQ_OP_WRITE,
|
2016-11-02 00:00:38 +08:00
|
|
|
.op_flags = wbc_to_write_flags(wbc),
|
2017-04-25 20:45:13 +08:00
|
|
|
.old_blkaddr = NULL_ADDR,
|
2015-04-24 05:38:15 +08:00
|
|
|
.page = page,
|
2015-04-24 03:04:33 +08:00
|
|
|
.encrypted_page = NULL,
|
2017-02-04 09:44:04 +08:00
|
|
|
.submitted = false,
|
2017-05-13 04:51:34 +08:00
|
|
|
.need_lock = LOCK_RETRY,
|
2017-08-02 23:21:48 +08:00
|
|
|
.io_type = io_type,
|
2018-01-09 19:33:39 +08:00
|
|
|
.io_wbc = wbc,
|
2013-12-11 12:54:01 +08:00
|
|
|
};
|
2012-11-02 16:10:12 +08:00
|
|
|
|
2014-05-06 16:48:26 +08:00
|
|
|
trace_f2fs_writepage(page, DATA);
|
|
|
|
|
|
2018-01-18 17:29:10 +08:00
|
|
|
/* we should bypass data pages to proceed the kworkder jobs */
|
|
|
|
|
if (unlikely(f2fs_cp_error(sbi))) {
|
|
|
|
|
mapping_set_error(page->mapping, -EIO);
|
2018-05-28 16:59:26 +08:00
|
|
|
/*
|
|
|
|
|
* don't drop any dirty dentry pages for keeping lastest
|
|
|
|
|
* directory structure.
|
|
|
|
|
*/
|
|
|
|
|
if (S_ISDIR(inode->i_mode))
|
|
|
|
|
goto redirty_out;
|
2018-01-18 17:29:10 +08:00
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
2017-06-29 23:20:45 +08:00
|
|
|
if (unlikely(is_sbi_flag_set(sbi, SBI_POR_DOING)))
|
|
|
|
|
goto redirty_out;
|
|
|
|
|
|
2012-11-02 16:10:12 +08:00
|
|
|
if (page->index < end_index)
|
f2fs: introduce a new global lock scheme
In the previous version, f2fs uses global locks according to the usage types,
such as directory operations, block allocation, block write, and so on.
Reference the following lock types in f2fs.h.
enum lock_type {
RENAME, /* for renaming operations */
DENTRY_OPS, /* for directory operations */
DATA_WRITE, /* for data write */
DATA_NEW, /* for data allocation */
DATA_TRUNC, /* for data truncate */
NODE_NEW, /* for node allocation */
NODE_TRUNC, /* for node truncate */
NODE_WRITE, /* for node write */
NR_LOCK_TYPE,
};
In that case, we lose the performance under the multi-threading environment,
since every types of operations must be conducted one at a time.
In order to address the problem, let's share the locks globally with a mutex
array regardless of any types.
So, let users grab a mutex and perform their jobs in parallel as much as
possbile.
For this, I propose a new global lock scheme as follows.
0. Data structure
- f2fs_sb_info -> mutex_lock[NR_GLOBAL_LOCKS]
- f2fs_sb_info -> node_write
1. mutex_lock_op(sbi)
- try to get an avaiable lock from the array.
- returns the index of the gottern lock variable.
2. mutex_unlock_op(sbi, index of the lock)
- unlock the given index of the lock.
3. mutex_lock_all(sbi)
- grab all the locks in the array before the checkpoint.
4. mutex_unlock_all(sbi)
- release all the locks in the array after checkpoint.
5. block_operations()
- call mutex_lock_all()
- sync_dirty_dir_inodes()
- grab node_write
- sync_node_pages()
Note that,
the pairs of mutex_lock_op()/mutex_unlock_op() and
mutex_lock_all()/mutex_unlock_all() should be used together.
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-22 15:21:29 +08:00
|
|
|
goto write;
|
2012-11-02 16:10:12 +08:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* If the offset is out-of-range of file size,
|
|
|
|
|
* this page does not have to be written to disk.
|
|
|
|
|
*/
|
mm, fs: get rid of PAGE_CACHE_* and page_cache_{get,release} macros
PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} macros were introduced *long* time
ago with promise that one day it will be possible to implement page
cache with bigger chunks than PAGE_SIZE.
This promise never materialized. And unlikely will.
We have many places where PAGE_CACHE_SIZE assumed to be equal to
PAGE_SIZE. And it's constant source of confusion on whether
PAGE_CACHE_* or PAGE_* constant should be used in a particular case,
especially on the border between fs and mm.
Global switching to PAGE_CACHE_SIZE != PAGE_SIZE would cause to much
breakage to be doable.
Let's stop pretending that pages in page cache are special. They are
not.
The changes are pretty straight-forward:
- <foo> << (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- <foo> >> (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} -> PAGE_{SIZE,SHIFT,MASK,ALIGN};
- page_cache_get() -> get_page();
- page_cache_release() -> put_page();
This patch contains automated changes generated with coccinelle using
script below. For some reason, coccinelle doesn't patch header files.
I've called spatch for them manually.
The only adjustment after coccinelle is revert of changes to
PAGE_CAHCE_ALIGN definition: we are going to drop it later.
There are few places in the code where coccinelle didn't reach. I'll
fix them manually in a separate patch. Comments and documentation also
will be addressed with the separate patch.
virtual patch
@@
expression E;
@@
- E << (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
expression E;
@@
- E >> (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
@@
- PAGE_CACHE_SHIFT
+ PAGE_SHIFT
@@
@@
- PAGE_CACHE_SIZE
+ PAGE_SIZE
@@
@@
- PAGE_CACHE_MASK
+ PAGE_MASK
@@
expression E;
@@
- PAGE_CACHE_ALIGN(E)
+ PAGE_ALIGN(E)
@@
expression E;
@@
- page_cache_get(E)
+ get_page(E)
@@
expression E;
@@
- page_cache_release(E)
+ put_page(E)
Signed-off-by: Kirill A. Shutemov <kirill.shutemov@linux.intel.com>
Acked-by: Michal Hocko <mhocko@suse.com>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2016-04-01 20:29:47 +08:00
|
|
|
offset = i_size & (PAGE_SIZE - 1);
|
2014-04-15 15:04:15 +08:00
|
|
|
if ((page->index >= end_index + 1) || !offset)
|
f2fs: introduce a new global lock scheme
In the previous version, f2fs uses global locks according to the usage types,
such as directory operations, block allocation, block write, and so on.
Reference the following lock types in f2fs.h.
enum lock_type {
RENAME, /* for renaming operations */
DENTRY_OPS, /* for directory operations */
DATA_WRITE, /* for data write */
DATA_NEW, /* for data allocation */
DATA_TRUNC, /* for data truncate */
NODE_NEW, /* for node allocation */
NODE_TRUNC, /* for node truncate */
NODE_WRITE, /* for node write */
NR_LOCK_TYPE,
};
In that case, we lose the performance under the multi-threading environment,
since every types of operations must be conducted one at a time.
In order to address the problem, let's share the locks globally with a mutex
array regardless of any types.
So, let users grab a mutex and perform their jobs in parallel as much as
possbile.
For this, I propose a new global lock scheme as follows.
0. Data structure
- f2fs_sb_info -> mutex_lock[NR_GLOBAL_LOCKS]
- f2fs_sb_info -> node_write
1. mutex_lock_op(sbi)
- try to get an avaiable lock from the array.
- returns the index of the gottern lock variable.
2. mutex_unlock_op(sbi, index of the lock)
- unlock the given index of the lock.
3. mutex_lock_all(sbi)
- grab all the locks in the array before the checkpoint.
4. mutex_unlock_all(sbi)
- release all the locks in the array after checkpoint.
5. block_operations()
- call mutex_lock_all()
- sync_dirty_dir_inodes()
- grab node_write
- sync_node_pages()
Note that,
the pairs of mutex_lock_op()/mutex_unlock_op() and
mutex_lock_all()/mutex_unlock_all() should be used together.
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-22 15:21:29 +08:00
|
|
|
goto out;
|
2012-11-02 16:10:12 +08:00
|
|
|
|
mm, fs: get rid of PAGE_CACHE_* and page_cache_{get,release} macros
PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} macros were introduced *long* time
ago with promise that one day it will be possible to implement page
cache with bigger chunks than PAGE_SIZE.
This promise never materialized. And unlikely will.
We have many places where PAGE_CACHE_SIZE assumed to be equal to
PAGE_SIZE. And it's constant source of confusion on whether
PAGE_CACHE_* or PAGE_* constant should be used in a particular case,
especially on the border between fs and mm.
Global switching to PAGE_CACHE_SIZE != PAGE_SIZE would cause to much
breakage to be doable.
Let's stop pretending that pages in page cache are special. They are
not.
The changes are pretty straight-forward:
- <foo> << (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- <foo> >> (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} -> PAGE_{SIZE,SHIFT,MASK,ALIGN};
- page_cache_get() -> get_page();
- page_cache_release() -> put_page();
This patch contains automated changes generated with coccinelle using
script below. For some reason, coccinelle doesn't patch header files.
I've called spatch for them manually.
The only adjustment after coccinelle is revert of changes to
PAGE_CAHCE_ALIGN definition: we are going to drop it later.
There are few places in the code where coccinelle didn't reach. I'll
fix them manually in a separate patch. Comments and documentation also
will be addressed with the separate patch.
virtual patch
@@
expression E;
@@
- E << (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
expression E;
@@
- E >> (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
@@
- PAGE_CACHE_SHIFT
+ PAGE_SHIFT
@@
@@
- PAGE_CACHE_SIZE
+ PAGE_SIZE
@@
@@
- PAGE_CACHE_MASK
+ PAGE_MASK
@@
expression E;
@@
- PAGE_CACHE_ALIGN(E)
+ PAGE_ALIGN(E)
@@
expression E;
@@
- page_cache_get(E)
+ get_page(E)
@@
expression E;
@@
- page_cache_release(E)
+ put_page(E)
Signed-off-by: Kirill A. Shutemov <kirill.shutemov@linux.intel.com>
Acked-by: Michal Hocko <mhocko@suse.com>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2016-04-01 20:29:47 +08:00
|
|
|
zero_user_segment(page, offset, PAGE_SIZE);
|
f2fs: introduce a new global lock scheme
In the previous version, f2fs uses global locks according to the usage types,
such as directory operations, block allocation, block write, and so on.
Reference the following lock types in f2fs.h.
enum lock_type {
RENAME, /* for renaming operations */
DENTRY_OPS, /* for directory operations */
DATA_WRITE, /* for data write */
DATA_NEW, /* for data allocation */
DATA_TRUNC, /* for data truncate */
NODE_NEW, /* for node allocation */
NODE_TRUNC, /* for node truncate */
NODE_WRITE, /* for node write */
NR_LOCK_TYPE,
};
In that case, we lose the performance under the multi-threading environment,
since every types of operations must be conducted one at a time.
In order to address the problem, let's share the locks globally with a mutex
array regardless of any types.
So, let users grab a mutex and perform their jobs in parallel as much as
possbile.
For this, I propose a new global lock scheme as follows.
0. Data structure
- f2fs_sb_info -> mutex_lock[NR_GLOBAL_LOCKS]
- f2fs_sb_info -> node_write
1. mutex_lock_op(sbi)
- try to get an avaiable lock from the array.
- returns the index of the gottern lock variable.
2. mutex_unlock_op(sbi, index of the lock)
- unlock the given index of the lock.
3. mutex_lock_all(sbi)
- grab all the locks in the array before the checkpoint.
4. mutex_unlock_all(sbi)
- release all the locks in the array after checkpoint.
5. block_operations()
- call mutex_lock_all()
- sync_dirty_dir_inodes()
- grab node_write
- sync_node_pages()
Note that,
the pairs of mutex_lock_op()/mutex_unlock_op() and
mutex_lock_all()/mutex_unlock_all() should be used together.
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-22 15:21:29 +08:00
|
|
|
write:
|
2014-12-09 22:08:59 +08:00
|
|
|
if (f2fs_is_drop_cache(inode))
|
|
|
|
|
goto out;
|
2016-04-15 07:48:52 +08:00
|
|
|
/* we should not write 0'th page having journal header */
|
|
|
|
|
if (f2fs_is_volatile_file(inode) && (!page->index ||
|
|
|
|
|
(!wbc->for_reclaim &&
|
f2fs: clean up symbol namespace
As Ted reported:
"Hi, I was looking at f2fs's sources recently, and I noticed that there
is a very large number of non-static symbols which don't have a f2fs
prefix. There's well over a hundred (see attached below).
As one example, in fs/f2fs/dir.c there is:
unsigned char get_de_type(struct f2fs_dir_entry *de)
This function is clearly only useful for f2fs, but it has a generic
name. This means that if any other file system tries to have the same
symbol name, there will be a symbol conflict and the kernel would not
successfully build. It also means that when someone is looking f2fs
sources, it's not at all obvious whether a function such as
read_data_page(), invalidate_blocks(), is a generic kernel function
found in the fs, mm, or block layers, or a f2fs specific function.
You might want to fix this at some point. Hopefully Kent's bcachefs
isn't similarly using genericly named functions, since that might
cause conflicts with f2fs's functions --- but just as this would be a
problem that we would rightly insist that Kent fix, this is something
that we should have rightly insisted that f2fs should have fixed
before it was integrated into the mainline kernel.
acquire_orphan_inode
add_ino_entry
add_orphan_inode
allocate_data_block
allocate_new_segments
alloc_nid
alloc_nid_done
alloc_nid_failed
available_free_memory
...."
This patch adds "f2fs_" prefix for all non-static symbols in order to:
a) avoid conflict with other kernel generic symbols;
b) to indicate the function is f2fs specific one instead of generic
one;
Reported-by: Theodore Ts'o <tytso@mit.edu>
Signed-off-by: Chao Yu <yuchao0@huawei.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2018-05-30 00:20:41 +08:00
|
|
|
f2fs_available_free_memory(sbi, BASE_CHECK))))
|
2014-12-09 22:08:59 +08:00
|
|
|
goto redirty_out;
|
2012-11-02 16:10:12 +08:00
|
|
|
|
f2fs: introduce a new global lock scheme
In the previous version, f2fs uses global locks according to the usage types,
such as directory operations, block allocation, block write, and so on.
Reference the following lock types in f2fs.h.
enum lock_type {
RENAME, /* for renaming operations */
DENTRY_OPS, /* for directory operations */
DATA_WRITE, /* for data write */
DATA_NEW, /* for data allocation */
DATA_TRUNC, /* for data truncate */
NODE_NEW, /* for node allocation */
NODE_TRUNC, /* for node truncate */
NODE_WRITE, /* for node write */
NR_LOCK_TYPE,
};
In that case, we lose the performance under the multi-threading environment,
since every types of operations must be conducted one at a time.
In order to address the problem, let's share the locks globally with a mutex
array regardless of any types.
So, let users grab a mutex and perform their jobs in parallel as much as
possbile.
For this, I propose a new global lock scheme as follows.
0. Data structure
- f2fs_sb_info -> mutex_lock[NR_GLOBAL_LOCKS]
- f2fs_sb_info -> node_write
1. mutex_lock_op(sbi)
- try to get an avaiable lock from the array.
- returns the index of the gottern lock variable.
2. mutex_unlock_op(sbi, index of the lock)
- unlock the given index of the lock.
3. mutex_lock_all(sbi)
- grab all the locks in the array before the checkpoint.
4. mutex_unlock_all(sbi)
- release all the locks in the array after checkpoint.
5. block_operations()
- call mutex_lock_all()
- sync_dirty_dir_inodes()
- grab node_write
- sync_node_pages()
Note that,
the pairs of mutex_lock_op()/mutex_unlock_op() and
mutex_lock_all()/mutex_unlock_all() should be used together.
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-22 15:21:29 +08:00
|
|
|
/* Dentry blocks are controlled by checkpoint */
|
2012-11-02 16:10:12 +08:00
|
|
|
if (S_ISDIR(inode->i_mode)) {
|
2017-05-13 04:51:34 +08:00
|
|
|
fio.need_lock = LOCK_DONE;
|
f2fs: clean up symbol namespace
As Ted reported:
"Hi, I was looking at f2fs's sources recently, and I noticed that there
is a very large number of non-static symbols which don't have a f2fs
prefix. There's well over a hundred (see attached below).
As one example, in fs/f2fs/dir.c there is:
unsigned char get_de_type(struct f2fs_dir_entry *de)
This function is clearly only useful for f2fs, but it has a generic
name. This means that if any other file system tries to have the same
symbol name, there will be a symbol conflict and the kernel would not
successfully build. It also means that when someone is looking f2fs
sources, it's not at all obvious whether a function such as
read_data_page(), invalidate_blocks(), is a generic kernel function
found in the fs, mm, or block layers, or a f2fs specific function.
You might want to fix this at some point. Hopefully Kent's bcachefs
isn't similarly using genericly named functions, since that might
cause conflicts with f2fs's functions --- but just as this would be a
problem that we would rightly insist that Kent fix, this is something
that we should have rightly insisted that f2fs should have fixed
before it was integrated into the mainline kernel.
acquire_orphan_inode
add_ino_entry
add_orphan_inode
allocate_data_block
allocate_new_segments
alloc_nid
alloc_nid_done
alloc_nid_failed
available_free_memory
...."
This patch adds "f2fs_" prefix for all non-static symbols in order to:
a) avoid conflict with other kernel generic symbols;
b) to indicate the function is f2fs specific one instead of generic
one;
Reported-by: Theodore Ts'o <tytso@mit.edu>
Signed-off-by: Chao Yu <yuchao0@huawei.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2018-05-30 00:20:41 +08:00
|
|
|
err = f2fs_do_write_data_page(&fio);
|
2014-02-17 18:29:27 +08:00
|
|
|
goto done;
|
|
|
|
|
}
|
f2fs: handle inline data operations
Hook inline data read/write, truncate, fallocate, setattr, etc.
Files need meet following 2 requirement to inline:
1) file size is not greater than MAX_INLINE_DATA;
2) file doesn't pre-allocate data blocks by fallocate().
FI_INLINE_DATA will not be set while creating a new regular inode because
most of the files are bigger than ~3.4K. Set FI_INLINE_DATA only when
data is submitted to block layer, ranther than set it while creating a new
inode, this also avoids converting data from inline to normal data block
and vice versa.
While writting inline data to inode block, the first data block should be
released if the file has a block indexed by i_addr[0].
On the other hand, when a file operation is appied to a file with inline
data, we need to test if this file can remain inline by doing this
operation, otherwise it should be convert into normal file by reserving
a new data block, copying inline data to this new block and clear
FI_INLINE_DATA flag. Because reserve a new data block here will make use
of i_addr[0], if we save inline data in i_addr[0..872], then the first
4 bytes would be overwriten. This problem can be avoided simply by
not using i_addr[0] for inline data.
Signed-off-by: Huajun Li <huajun.li@intel.com>
Signed-off-by: Haicheng Li <haicheng.li@linux.intel.com>
Signed-off-by: Weihong Xu <weihong.xu@intel.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2013-11-10 23:13:20 +08:00
|
|
|
|
2014-02-17 18:29:27 +08:00
|
|
|
if (!wbc->for_reclaim)
|
f2fs: introduce a new global lock scheme
In the previous version, f2fs uses global locks according to the usage types,
such as directory operations, block allocation, block write, and so on.
Reference the following lock types in f2fs.h.
enum lock_type {
RENAME, /* for renaming operations */
DENTRY_OPS, /* for directory operations */
DATA_WRITE, /* for data write */
DATA_NEW, /* for data allocation */
DATA_TRUNC, /* for data truncate */
NODE_NEW, /* for node allocation */
NODE_TRUNC, /* for node truncate */
NODE_WRITE, /* for node write */
NR_LOCK_TYPE,
};
In that case, we lose the performance under the multi-threading environment,
since every types of operations must be conducted one at a time.
In order to address the problem, let's share the locks globally with a mutex
array regardless of any types.
So, let users grab a mutex and perform their jobs in parallel as much as
possbile.
For this, I propose a new global lock scheme as follows.
0. Data structure
- f2fs_sb_info -> mutex_lock[NR_GLOBAL_LOCKS]
- f2fs_sb_info -> node_write
1. mutex_lock_op(sbi)
- try to get an avaiable lock from the array.
- returns the index of the gottern lock variable.
2. mutex_unlock_op(sbi, index of the lock)
- unlock the given index of the lock.
3. mutex_lock_all(sbi)
- grab all the locks in the array before the checkpoint.
4. mutex_unlock_all(sbi)
- release all the locks in the array after checkpoint.
5. block_operations()
- call mutex_lock_all()
- sync_dirty_dir_inodes()
- grab node_write
- sync_node_pages()
Note that,
the pairs of mutex_lock_op()/mutex_unlock_op() and
mutex_lock_all()/mutex_unlock_all() should be used together.
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-22 15:21:29 +08:00
|
|
|
need_balance_fs = true;
|
2016-09-02 03:02:51 +08:00
|
|
|
else if (has_not_enough_free_secs(sbi, 0, 0))
|
f2fs: introduce a new global lock scheme
In the previous version, f2fs uses global locks according to the usage types,
such as directory operations, block allocation, block write, and so on.
Reference the following lock types in f2fs.h.
enum lock_type {
RENAME, /* for renaming operations */
DENTRY_OPS, /* for directory operations */
DATA_WRITE, /* for data write */
DATA_NEW, /* for data allocation */
DATA_TRUNC, /* for data truncate */
NODE_NEW, /* for node allocation */
NODE_TRUNC, /* for node truncate */
NODE_WRITE, /* for node write */
NR_LOCK_TYPE,
};
In that case, we lose the performance under the multi-threading environment,
since every types of operations must be conducted one at a time.
In order to address the problem, let's share the locks globally with a mutex
array regardless of any types.
So, let users grab a mutex and perform their jobs in parallel as much as
possbile.
For this, I propose a new global lock scheme as follows.
0. Data structure
- f2fs_sb_info -> mutex_lock[NR_GLOBAL_LOCKS]
- f2fs_sb_info -> node_write
1. mutex_lock_op(sbi)
- try to get an avaiable lock from the array.
- returns the index of the gottern lock variable.
2. mutex_unlock_op(sbi, index of the lock)
- unlock the given index of the lock.
3. mutex_lock_all(sbi)
- grab all the locks in the array before the checkpoint.
4. mutex_unlock_all(sbi)
- release all the locks in the array after checkpoint.
5. block_operations()
- call mutex_lock_all()
- sync_dirty_dir_inodes()
- grab node_write
- sync_node_pages()
Note that,
the pairs of mutex_lock_op()/mutex_unlock_op() and
mutex_lock_all()/mutex_unlock_all() should be used together.
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-22 15:21:29 +08:00
|
|
|
goto redirty_out;
|
2017-03-25 08:05:13 +08:00
|
|
|
else
|
|
|
|
|
set_inode_flag(inode, FI_HOT_DATA);
|
2012-11-02 16:10:12 +08:00
|
|
|
|
2014-10-24 10:48:09 +08:00
|
|
|
err = -EAGAIN;
|
2017-02-23 20:31:20 +08:00
|
|
|
if (f2fs_has_inline_data(inode)) {
|
2014-10-24 10:48:09 +08:00
|
|
|
err = f2fs_write_inline_data(inode, page);
|
2017-02-23 20:31:20 +08:00
|
|
|
if (!err)
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
2017-04-27 00:17:21 +08:00
|
|
|
|
2017-05-13 04:51:34 +08:00
|
|
|
if (err == -EAGAIN) {
|
f2fs: clean up symbol namespace
As Ted reported:
"Hi, I was looking at f2fs's sources recently, and I noticed that there
is a very large number of non-static symbols which don't have a f2fs
prefix. There's well over a hundred (see attached below).
As one example, in fs/f2fs/dir.c there is:
unsigned char get_de_type(struct f2fs_dir_entry *de)
This function is clearly only useful for f2fs, but it has a generic
name. This means that if any other file system tries to have the same
symbol name, there will be a symbol conflict and the kernel would not
successfully build. It also means that when someone is looking f2fs
sources, it's not at all obvious whether a function such as
read_data_page(), invalidate_blocks(), is a generic kernel function
found in the fs, mm, or block layers, or a f2fs specific function.
You might want to fix this at some point. Hopefully Kent's bcachefs
isn't similarly using genericly named functions, since that might
cause conflicts with f2fs's functions --- but just as this would be a
problem that we would rightly insist that Kent fix, this is something
that we should have rightly insisted that f2fs should have fixed
before it was integrated into the mainline kernel.
acquire_orphan_inode
add_ino_entry
add_orphan_inode
allocate_data_block
allocate_new_segments
alloc_nid
alloc_nid_done
alloc_nid_failed
available_free_memory
...."
This patch adds "f2fs_" prefix for all non-static symbols in order to:
a) avoid conflict with other kernel generic symbols;
b) to indicate the function is f2fs specific one instead of generic
one;
Reported-by: Theodore Ts'o <tytso@mit.edu>
Signed-off-by: Chao Yu <yuchao0@huawei.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2018-05-30 00:20:41 +08:00
|
|
|
err = f2fs_do_write_data_page(&fio);
|
2017-05-13 04:51:34 +08:00
|
|
|
if (err == -EAGAIN) {
|
|
|
|
|
fio.need_lock = LOCK_REQ;
|
f2fs: clean up symbol namespace
As Ted reported:
"Hi, I was looking at f2fs's sources recently, and I noticed that there
is a very large number of non-static symbols which don't have a f2fs
prefix. There's well over a hundred (see attached below).
As one example, in fs/f2fs/dir.c there is:
unsigned char get_de_type(struct f2fs_dir_entry *de)
This function is clearly only useful for f2fs, but it has a generic
name. This means that if any other file system tries to have the same
symbol name, there will be a symbol conflict and the kernel would not
successfully build. It also means that when someone is looking f2fs
sources, it's not at all obvious whether a function such as
read_data_page(), invalidate_blocks(), is a generic kernel function
found in the fs, mm, or block layers, or a f2fs specific function.
You might want to fix this at some point. Hopefully Kent's bcachefs
isn't similarly using genericly named functions, since that might
cause conflicts with f2fs's functions --- but just as this would be a
problem that we would rightly insist that Kent fix, this is something
that we should have rightly insisted that f2fs should have fixed
before it was integrated into the mainline kernel.
acquire_orphan_inode
add_ino_entry
add_orphan_inode
allocate_data_block
allocate_new_segments
alloc_nid
alloc_nid_done
alloc_nid_failed
available_free_memory
...."
This patch adds "f2fs_" prefix for all non-static symbols in order to:
a) avoid conflict with other kernel generic symbols;
b) to indicate the function is f2fs specific one instead of generic
one;
Reported-by: Theodore Ts'o <tytso@mit.edu>
Signed-off-by: Chao Yu <yuchao0@huawei.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2018-05-30 00:20:41 +08:00
|
|
|
err = f2fs_do_write_data_page(&fio);
|
2017-05-13 04:51:34 +08:00
|
|
|
}
|
|
|
|
|
}
|
2017-10-09 17:55:19 +08:00
|
|
|
|
2018-01-17 16:31:37 +08:00
|
|
|
if (err) {
|
|
|
|
|
file_set_keep_isize(inode);
|
|
|
|
|
} else {
|
|
|
|
|
down_write(&F2FS_I(inode)->i_sem);
|
|
|
|
|
if (F2FS_I(inode)->last_disk_size < psize)
|
|
|
|
|
F2FS_I(inode)->last_disk_size = psize;
|
|
|
|
|
up_write(&F2FS_I(inode)->i_sem);
|
|
|
|
|
}
|
2017-04-27 00:17:21 +08:00
|
|
|
|
2014-02-17 18:29:27 +08:00
|
|
|
done:
|
|
|
|
|
if (err && err != -ENOENT)
|
|
|
|
|
goto redirty_out;
|
2012-11-02 16:10:12 +08:00
|
|
|
|
f2fs: introduce a new global lock scheme
In the previous version, f2fs uses global locks according to the usage types,
such as directory operations, block allocation, block write, and so on.
Reference the following lock types in f2fs.h.
enum lock_type {
RENAME, /* for renaming operations */
DENTRY_OPS, /* for directory operations */
DATA_WRITE, /* for data write */
DATA_NEW, /* for data allocation */
DATA_TRUNC, /* for data truncate */
NODE_NEW, /* for node allocation */
NODE_TRUNC, /* for node truncate */
NODE_WRITE, /* for node write */
NR_LOCK_TYPE,
};
In that case, we lose the performance under the multi-threading environment,
since every types of operations must be conducted one at a time.
In order to address the problem, let's share the locks globally with a mutex
array regardless of any types.
So, let users grab a mutex and perform their jobs in parallel as much as
possbile.
For this, I propose a new global lock scheme as follows.
0. Data structure
- f2fs_sb_info -> mutex_lock[NR_GLOBAL_LOCKS]
- f2fs_sb_info -> node_write
1. mutex_lock_op(sbi)
- try to get an avaiable lock from the array.
- returns the index of the gottern lock variable.
2. mutex_unlock_op(sbi, index of the lock)
- unlock the given index of the lock.
3. mutex_lock_all(sbi)
- grab all the locks in the array before the checkpoint.
4. mutex_unlock_all(sbi)
- release all the locks in the array after checkpoint.
5. block_operations()
- call mutex_lock_all()
- sync_dirty_dir_inodes()
- grab node_write
- sync_node_pages()
Note that,
the pairs of mutex_lock_op()/mutex_unlock_op() and
mutex_lock_all()/mutex_unlock_all() should be used together.
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-22 15:21:29 +08:00
|
|
|
out:
|
2014-09-13 06:53:45 +08:00
|
|
|
inode_dec_dirty_pages(inode);
|
2015-02-26 11:25:01 +08:00
|
|
|
if (err)
|
|
|
|
|
ClearPageUptodate(page);
|
f2fs: introduce f2fs_submit_merged_bio_cond
f2fs use single bio buffer per type data (META/NODE/DATA) for caching
writes locating in continuous block address as many as possible, after
submitting, these writes may be still cached in bio buffer, so we have
to flush cached writes in bio buffer by calling f2fs_submit_merged_bio.
Unfortunately, in the scenario of high concurrency, bio buffer could be
flushed by someone else before we submit it as below reasons:
a) there is no space in bio buffer.
b) add a request of different type (SYNC, ASYNC).
c) add a discontinuous block address.
For this condition, f2fs_submit_merged_bio will be devastating, because
it could break the following merging of writes in bio buffer, split one
big bio into two smaller one.
This patch introduces f2fs_submit_merged_bio_cond which can do a
conditional submitting with bio buffer, before submitting it will judge
whether:
- page in DATA type bio buffer is matching with specified page;
- page in DATA type bio buffer is belong to specified inode;
- page in NODE type bio buffer is belong to specified inode;
If there is no eligible page in bio buffer, we will skip submitting step,
result in gaining more chance to merge consecutive block IOs in bio cache.
Signed-off-by: Chao Yu <chao2.yu@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2016-01-18 18:28:11 +08:00
|
|
|
|
|
|
|
|
if (wbc->for_reclaim) {
|
2017-05-11 02:28:38 +08:00
|
|
|
f2fs_submit_merged_write_cond(sbi, inode, 0, page->index, DATA);
|
2017-03-25 08:05:13 +08:00
|
|
|
clear_inode_flag(inode, FI_HOT_DATA);
|
f2fs: clean up symbol namespace
As Ted reported:
"Hi, I was looking at f2fs's sources recently, and I noticed that there
is a very large number of non-static symbols which don't have a f2fs
prefix. There's well over a hundred (see attached below).
As one example, in fs/f2fs/dir.c there is:
unsigned char get_de_type(struct f2fs_dir_entry *de)
This function is clearly only useful for f2fs, but it has a generic
name. This means that if any other file system tries to have the same
symbol name, there will be a symbol conflict and the kernel would not
successfully build. It also means that when someone is looking f2fs
sources, it's not at all obvious whether a function such as
read_data_page(), invalidate_blocks(), is a generic kernel function
found in the fs, mm, or block layers, or a f2fs specific function.
You might want to fix this at some point. Hopefully Kent's bcachefs
isn't similarly using genericly named functions, since that might
cause conflicts with f2fs's functions --- but just as this would be a
problem that we would rightly insist that Kent fix, this is something
that we should have rightly insisted that f2fs should have fixed
before it was integrated into the mainline kernel.
acquire_orphan_inode
add_ino_entry
add_orphan_inode
allocate_data_block
allocate_new_segments
alloc_nid
alloc_nid_done
alloc_nid_failed
available_free_memory
...."
This patch adds "f2fs_" prefix for all non-static symbols in order to:
a) avoid conflict with other kernel generic symbols;
b) to indicate the function is f2fs specific one instead of generic
one;
Reported-by: Theodore Ts'o <tytso@mit.edu>
Signed-off-by: Chao Yu <yuchao0@huawei.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2018-05-30 00:20:41 +08:00
|
|
|
f2fs_remove_dirty_inode(inode);
|
2017-02-04 09:44:04 +08:00
|
|
|
submitted = NULL;
|
f2fs: introduce f2fs_submit_merged_bio_cond
f2fs use single bio buffer per type data (META/NODE/DATA) for caching
writes locating in continuous block address as many as possible, after
submitting, these writes may be still cached in bio buffer, so we have
to flush cached writes in bio buffer by calling f2fs_submit_merged_bio.
Unfortunately, in the scenario of high concurrency, bio buffer could be
flushed by someone else before we submit it as below reasons:
a) there is no space in bio buffer.
b) add a request of different type (SYNC, ASYNC).
c) add a discontinuous block address.
For this condition, f2fs_submit_merged_bio will be devastating, because
it could break the following merging of writes in bio buffer, split one
big bio into two smaller one.
This patch introduces f2fs_submit_merged_bio_cond which can do a
conditional submitting with bio buffer, before submitting it will judge
whether:
- page in DATA type bio buffer is matching with specified page;
- page in DATA type bio buffer is belong to specified inode;
- page in NODE type bio buffer is belong to specified inode;
If there is no eligible page in bio buffer, we will skip submitting step,
result in gaining more chance to merge consecutive block IOs in bio cache.
Signed-off-by: Chao Yu <chao2.yu@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2016-01-18 18:28:11 +08:00
|
|
|
}
|
|
|
|
|
|
2012-11-02 16:10:12 +08:00
|
|
|
unlock_page(page);
|
2017-04-21 04:51:57 +08:00
|
|
|
if (!S_ISDIR(inode->i_mode))
|
|
|
|
|
f2fs_balance_fs(sbi, need_balance_fs);
|
f2fs: introduce f2fs_submit_merged_bio_cond
f2fs use single bio buffer per type data (META/NODE/DATA) for caching
writes locating in continuous block address as many as possible, after
submitting, these writes may be still cached in bio buffer, so we have
to flush cached writes in bio buffer by calling f2fs_submit_merged_bio.
Unfortunately, in the scenario of high concurrency, bio buffer could be
flushed by someone else before we submit it as below reasons:
a) there is no space in bio buffer.
b) add a request of different type (SYNC, ASYNC).
c) add a discontinuous block address.
For this condition, f2fs_submit_merged_bio will be devastating, because
it could break the following merging of writes in bio buffer, split one
big bio into two smaller one.
This patch introduces f2fs_submit_merged_bio_cond which can do a
conditional submitting with bio buffer, before submitting it will judge
whether:
- page in DATA type bio buffer is matching with specified page;
- page in DATA type bio buffer is belong to specified inode;
- page in NODE type bio buffer is belong to specified inode;
If there is no eligible page in bio buffer, we will skip submitting step,
result in gaining more chance to merge consecutive block IOs in bio cache.
Signed-off-by: Chao Yu <chao2.yu@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2016-01-18 18:28:11 +08:00
|
|
|
|
2017-02-04 09:44:04 +08:00
|
|
|
if (unlikely(f2fs_cp_error(sbi))) {
|
2017-05-11 02:28:38 +08:00
|
|
|
f2fs_submit_merged_write(sbi, DATA);
|
2017-02-04 09:44:04 +08:00
|
|
|
submitted = NULL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (submitted)
|
|
|
|
|
*submitted = fio.submitted;
|
f2fs: introduce f2fs_submit_merged_bio_cond
f2fs use single bio buffer per type data (META/NODE/DATA) for caching
writes locating in continuous block address as many as possible, after
submitting, these writes may be still cached in bio buffer, so we have
to flush cached writes in bio buffer by calling f2fs_submit_merged_bio.
Unfortunately, in the scenario of high concurrency, bio buffer could be
flushed by someone else before we submit it as below reasons:
a) there is no space in bio buffer.
b) add a request of different type (SYNC, ASYNC).
c) add a discontinuous block address.
For this condition, f2fs_submit_merged_bio will be devastating, because
it could break the following merging of writes in bio buffer, split one
big bio into two smaller one.
This patch introduces f2fs_submit_merged_bio_cond which can do a
conditional submitting with bio buffer, before submitting it will judge
whether:
- page in DATA type bio buffer is matching with specified page;
- page in DATA type bio buffer is belong to specified inode;
- page in NODE type bio buffer is belong to specified inode;
If there is no eligible page in bio buffer, we will skip submitting step,
result in gaining more chance to merge consecutive block IOs in bio cache.
Signed-off-by: Chao Yu <chao2.yu@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2016-01-18 18:28:11 +08:00
|
|
|
|
2012-11-02 16:10:12 +08:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
redirty_out:
|
2014-04-15 15:04:15 +08:00
|
|
|
redirty_page_for_writepage(wbc, page);
|
2018-05-04 14:26:02 +08:00
|
|
|
/*
|
|
|
|
|
* pageout() in MM traslates EAGAIN, so calls handle_write_error()
|
|
|
|
|
* -> mapping_set_error() -> set_bit(AS_EIO, ...).
|
|
|
|
|
* file_write_and_wait_range() will see EIO error, which is critical
|
|
|
|
|
* to return value of fsync() followed by atomic_write failure to user.
|
|
|
|
|
*/
|
|
|
|
|
if (!err || wbc->for_reclaim)
|
2016-11-29 11:13:43 +08:00
|
|
|
return AOP_WRITEPAGE_ACTIVATE;
|
2016-05-30 12:18:23 +08:00
|
|
|
unlock_page(page);
|
|
|
|
|
return err;
|
2013-01-15 15:45:24 +08:00
|
|
|
}
|
|
|
|
|
|
2017-02-04 09:18:00 +08:00
|
|
|
static int f2fs_write_data_page(struct page *page,
|
|
|
|
|
struct writeback_control *wbc)
|
|
|
|
|
{
|
2017-08-02 23:21:48 +08:00
|
|
|
return __write_data_page(page, NULL, wbc, FS_DATA_IO);
|
2017-02-04 09:18:00 +08:00
|
|
|
}
|
|
|
|
|
|
f2fs: expose f2fs_write_cache_pages
If there are gced dirty pages and normal dirty pages in the mapping
of one inode, we might writeback them alternately with discontinuous
block address, resulting in low performance.
This patch introduces f2fs_write_cache_pages with codes copied from
write_cache_pages in mm/page-writeback.c.
In this function, we refactor flow with two steps:
1) writeback all cold type pages.
2) writeback all non-cold type pages.
By using this method, f2fs will writeback dirty pages with the same
temperature in bunch mode, it makes writeouted block being with
more continuous address, so they can be merged as much as possible
in f2fs bio cache, and also it will reduce the chance of submiting
small IO from block layer.
Test environment: 8g nokia sd card (very old sd card, but it shows
better effect when testing with this patch, and with a 32g kingston
sd card, I didn't see much more improvement).
Test step:
1. touch testfile;
2. truncate -s 512K testfile;
3. write all pages with odd index;
4. trigger gc by ioctl;
5. write all pages with even index;
6. time fsync testfile.
before:
real 0m0.402s
user 0m0.000s
sys 0m0.000s
after:
real 0m0.143s
user 0m0.004s
sys 0m0.004s
Signed-off-by: Chao Yu <chao2.yu@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2015-07-14 18:56:10 +08:00
|
|
|
/*
|
|
|
|
|
* This function was copied from write_cche_pages from mm/page-writeback.c.
|
|
|
|
|
* The major change is making write step of cold data page separately from
|
|
|
|
|
* warm/hot data page.
|
|
|
|
|
*/
|
|
|
|
|
static int f2fs_write_cache_pages(struct address_space *mapping,
|
2017-08-02 23:21:48 +08:00
|
|
|
struct writeback_control *wbc,
|
|
|
|
|
enum iostat_type io_type)
|
f2fs: expose f2fs_write_cache_pages
If there are gced dirty pages and normal dirty pages in the mapping
of one inode, we might writeback them alternately with discontinuous
block address, resulting in low performance.
This patch introduces f2fs_write_cache_pages with codes copied from
write_cache_pages in mm/page-writeback.c.
In this function, we refactor flow with two steps:
1) writeback all cold type pages.
2) writeback all non-cold type pages.
By using this method, f2fs will writeback dirty pages with the same
temperature in bunch mode, it makes writeouted block being with
more continuous address, so they can be merged as much as possible
in f2fs bio cache, and also it will reduce the chance of submiting
small IO from block layer.
Test environment: 8g nokia sd card (very old sd card, but it shows
better effect when testing with this patch, and with a 32g kingston
sd card, I didn't see much more improvement).
Test step:
1. touch testfile;
2. truncate -s 512K testfile;
3. write all pages with odd index;
4. trigger gc by ioctl;
5. write all pages with even index;
6. time fsync testfile.
before:
real 0m0.402s
user 0m0.000s
sys 0m0.000s
after:
real 0m0.143s
user 0m0.004s
sys 0m0.004s
Signed-off-by: Chao Yu <chao2.yu@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2015-07-14 18:56:10 +08:00
|
|
|
{
|
|
|
|
|
int ret = 0;
|
|
|
|
|
int done = 0;
|
|
|
|
|
struct pagevec pvec;
|
2018-06-04 23:20:36 +08:00
|
|
|
struct f2fs_sb_info *sbi = F2FS_M_SB(mapping);
|
f2fs: expose f2fs_write_cache_pages
If there are gced dirty pages and normal dirty pages in the mapping
of one inode, we might writeback them alternately with discontinuous
block address, resulting in low performance.
This patch introduces f2fs_write_cache_pages with codes copied from
write_cache_pages in mm/page-writeback.c.
In this function, we refactor flow with two steps:
1) writeback all cold type pages.
2) writeback all non-cold type pages.
By using this method, f2fs will writeback dirty pages with the same
temperature in bunch mode, it makes writeouted block being with
more continuous address, so they can be merged as much as possible
in f2fs bio cache, and also it will reduce the chance of submiting
small IO from block layer.
Test environment: 8g nokia sd card (very old sd card, but it shows
better effect when testing with this patch, and with a 32g kingston
sd card, I didn't see much more improvement).
Test step:
1. touch testfile;
2. truncate -s 512K testfile;
3. write all pages with odd index;
4. trigger gc by ioctl;
5. write all pages with even index;
6. time fsync testfile.
before:
real 0m0.402s
user 0m0.000s
sys 0m0.000s
after:
real 0m0.143s
user 0m0.004s
sys 0m0.004s
Signed-off-by: Chao Yu <chao2.yu@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2015-07-14 18:56:10 +08:00
|
|
|
int nr_pages;
|
|
|
|
|
pgoff_t uninitialized_var(writeback_index);
|
|
|
|
|
pgoff_t index;
|
|
|
|
|
pgoff_t end; /* Inclusive */
|
|
|
|
|
pgoff_t done_index;
|
2017-02-02 08:51:22 +08:00
|
|
|
pgoff_t last_idx = ULONG_MAX;
|
f2fs: expose f2fs_write_cache_pages
If there are gced dirty pages and normal dirty pages in the mapping
of one inode, we might writeback them alternately with discontinuous
block address, resulting in low performance.
This patch introduces f2fs_write_cache_pages with codes copied from
write_cache_pages in mm/page-writeback.c.
In this function, we refactor flow with two steps:
1) writeback all cold type pages.
2) writeback all non-cold type pages.
By using this method, f2fs will writeback dirty pages with the same
temperature in bunch mode, it makes writeouted block being with
more continuous address, so they can be merged as much as possible
in f2fs bio cache, and also it will reduce the chance of submiting
small IO from block layer.
Test environment: 8g nokia sd card (very old sd card, but it shows
better effect when testing with this patch, and with a 32g kingston
sd card, I didn't see much more improvement).
Test step:
1. touch testfile;
2. truncate -s 512K testfile;
3. write all pages with odd index;
4. trigger gc by ioctl;
5. write all pages with even index;
6. time fsync testfile.
before:
real 0m0.402s
user 0m0.000s
sys 0m0.000s
after:
real 0m0.143s
user 0m0.004s
sys 0m0.004s
Signed-off-by: Chao Yu <chao2.yu@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2015-07-14 18:56:10 +08:00
|
|
|
int cycled;
|
|
|
|
|
int range_whole = 0;
|
|
|
|
|
int tag;
|
|
|
|
|
|
2017-11-16 09:37:52 +08:00
|
|
|
pagevec_init(&pvec);
|
2016-05-26 11:57:16 +08:00
|
|
|
|
2017-03-25 08:05:13 +08:00
|
|
|
if (get_dirty_pages(mapping->host) <=
|
|
|
|
|
SM_I(F2FS_M_SB(mapping))->min_hot_blocks)
|
|
|
|
|
set_inode_flag(mapping->host, FI_HOT_DATA);
|
|
|
|
|
else
|
|
|
|
|
clear_inode_flag(mapping->host, FI_HOT_DATA);
|
|
|
|
|
|
f2fs: expose f2fs_write_cache_pages
If there are gced dirty pages and normal dirty pages in the mapping
of one inode, we might writeback them alternately with discontinuous
block address, resulting in low performance.
This patch introduces f2fs_write_cache_pages with codes copied from
write_cache_pages in mm/page-writeback.c.
In this function, we refactor flow with two steps:
1) writeback all cold type pages.
2) writeback all non-cold type pages.
By using this method, f2fs will writeback dirty pages with the same
temperature in bunch mode, it makes writeouted block being with
more continuous address, so they can be merged as much as possible
in f2fs bio cache, and also it will reduce the chance of submiting
small IO from block layer.
Test environment: 8g nokia sd card (very old sd card, but it shows
better effect when testing with this patch, and with a 32g kingston
sd card, I didn't see much more improvement).
Test step:
1. touch testfile;
2. truncate -s 512K testfile;
3. write all pages with odd index;
4. trigger gc by ioctl;
5. write all pages with even index;
6. time fsync testfile.
before:
real 0m0.402s
user 0m0.000s
sys 0m0.000s
after:
real 0m0.143s
user 0m0.004s
sys 0m0.004s
Signed-off-by: Chao Yu <chao2.yu@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2015-07-14 18:56:10 +08:00
|
|
|
if (wbc->range_cyclic) {
|
|
|
|
|
writeback_index = mapping->writeback_index; /* prev offset */
|
|
|
|
|
index = writeback_index;
|
|
|
|
|
if (index == 0)
|
|
|
|
|
cycled = 1;
|
|
|
|
|
else
|
|
|
|
|
cycled = 0;
|
|
|
|
|
end = -1;
|
|
|
|
|
} else {
|
mm, fs: get rid of PAGE_CACHE_* and page_cache_{get,release} macros
PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} macros were introduced *long* time
ago with promise that one day it will be possible to implement page
cache with bigger chunks than PAGE_SIZE.
This promise never materialized. And unlikely will.
We have many places where PAGE_CACHE_SIZE assumed to be equal to
PAGE_SIZE. And it's constant source of confusion on whether
PAGE_CACHE_* or PAGE_* constant should be used in a particular case,
especially on the border between fs and mm.
Global switching to PAGE_CACHE_SIZE != PAGE_SIZE would cause to much
breakage to be doable.
Let's stop pretending that pages in page cache are special. They are
not.
The changes are pretty straight-forward:
- <foo> << (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- <foo> >> (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} -> PAGE_{SIZE,SHIFT,MASK,ALIGN};
- page_cache_get() -> get_page();
- page_cache_release() -> put_page();
This patch contains automated changes generated with coccinelle using
script below. For some reason, coccinelle doesn't patch header files.
I've called spatch for them manually.
The only adjustment after coccinelle is revert of changes to
PAGE_CAHCE_ALIGN definition: we are going to drop it later.
There are few places in the code where coccinelle didn't reach. I'll
fix them manually in a separate patch. Comments and documentation also
will be addressed with the separate patch.
virtual patch
@@
expression E;
@@
- E << (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
expression E;
@@
- E >> (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
@@
- PAGE_CACHE_SHIFT
+ PAGE_SHIFT
@@
@@
- PAGE_CACHE_SIZE
+ PAGE_SIZE
@@
@@
- PAGE_CACHE_MASK
+ PAGE_MASK
@@
expression E;
@@
- PAGE_CACHE_ALIGN(E)
+ PAGE_ALIGN(E)
@@
expression E;
@@
- page_cache_get(E)
+ get_page(E)
@@
expression E;
@@
- page_cache_release(E)
+ put_page(E)
Signed-off-by: Kirill A. Shutemov <kirill.shutemov@linux.intel.com>
Acked-by: Michal Hocko <mhocko@suse.com>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2016-04-01 20:29:47 +08:00
|
|
|
index = wbc->range_start >> PAGE_SHIFT;
|
|
|
|
|
end = wbc->range_end >> PAGE_SHIFT;
|
f2fs: expose f2fs_write_cache_pages
If there are gced dirty pages and normal dirty pages in the mapping
of one inode, we might writeback them alternately with discontinuous
block address, resulting in low performance.
This patch introduces f2fs_write_cache_pages with codes copied from
write_cache_pages in mm/page-writeback.c.
In this function, we refactor flow with two steps:
1) writeback all cold type pages.
2) writeback all non-cold type pages.
By using this method, f2fs will writeback dirty pages with the same
temperature in bunch mode, it makes writeouted block being with
more continuous address, so they can be merged as much as possible
in f2fs bio cache, and also it will reduce the chance of submiting
small IO from block layer.
Test environment: 8g nokia sd card (very old sd card, but it shows
better effect when testing with this patch, and with a 32g kingston
sd card, I didn't see much more improvement).
Test step:
1. touch testfile;
2. truncate -s 512K testfile;
3. write all pages with odd index;
4. trigger gc by ioctl;
5. write all pages with even index;
6. time fsync testfile.
before:
real 0m0.402s
user 0m0.000s
sys 0m0.000s
after:
real 0m0.143s
user 0m0.004s
sys 0m0.004s
Signed-off-by: Chao Yu <chao2.yu@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2015-07-14 18:56:10 +08:00
|
|
|
if (wbc->range_start == 0 && wbc->range_end == LLONG_MAX)
|
|
|
|
|
range_whole = 1;
|
|
|
|
|
cycled = 1; /* ignore range_cyclic tests */
|
|
|
|
|
}
|
|
|
|
|
if (wbc->sync_mode == WB_SYNC_ALL || wbc->tagged_writepages)
|
|
|
|
|
tag = PAGECACHE_TAG_TOWRITE;
|
|
|
|
|
else
|
|
|
|
|
tag = PAGECACHE_TAG_DIRTY;
|
|
|
|
|
retry:
|
|
|
|
|
if (wbc->sync_mode == WB_SYNC_ALL || wbc->tagged_writepages)
|
|
|
|
|
tag_pages_for_writeback(mapping, index, end);
|
|
|
|
|
done_index = index;
|
|
|
|
|
while (!done && (index <= end)) {
|
|
|
|
|
int i;
|
|
|
|
|
|
2017-11-16 09:34:48 +08:00
|
|
|
nr_pages = pagevec_lookup_range_tag(&pvec, mapping, &index, end,
|
2017-11-16 09:35:19 +08:00
|
|
|
tag);
|
f2fs: expose f2fs_write_cache_pages
If there are gced dirty pages and normal dirty pages in the mapping
of one inode, we might writeback them alternately with discontinuous
block address, resulting in low performance.
This patch introduces f2fs_write_cache_pages with codes copied from
write_cache_pages in mm/page-writeback.c.
In this function, we refactor flow with two steps:
1) writeback all cold type pages.
2) writeback all non-cold type pages.
By using this method, f2fs will writeback dirty pages with the same
temperature in bunch mode, it makes writeouted block being with
more continuous address, so they can be merged as much as possible
in f2fs bio cache, and also it will reduce the chance of submiting
small IO from block layer.
Test environment: 8g nokia sd card (very old sd card, but it shows
better effect when testing with this patch, and with a 32g kingston
sd card, I didn't see much more improvement).
Test step:
1. touch testfile;
2. truncate -s 512K testfile;
3. write all pages with odd index;
4. trigger gc by ioctl;
5. write all pages with even index;
6. time fsync testfile.
before:
real 0m0.402s
user 0m0.000s
sys 0m0.000s
after:
real 0m0.143s
user 0m0.004s
sys 0m0.004s
Signed-off-by: Chao Yu <chao2.yu@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2015-07-14 18:56:10 +08:00
|
|
|
if (nr_pages == 0)
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < nr_pages; i++) {
|
|
|
|
|
struct page *page = pvec.pages[i];
|
2017-02-04 09:44:04 +08:00
|
|
|
bool submitted = false;
|
f2fs: expose f2fs_write_cache_pages
If there are gced dirty pages and normal dirty pages in the mapping
of one inode, we might writeback them alternately with discontinuous
block address, resulting in low performance.
This patch introduces f2fs_write_cache_pages with codes copied from
write_cache_pages in mm/page-writeback.c.
In this function, we refactor flow with two steps:
1) writeback all cold type pages.
2) writeback all non-cold type pages.
By using this method, f2fs will writeback dirty pages with the same
temperature in bunch mode, it makes writeouted block being with
more continuous address, so they can be merged as much as possible
in f2fs bio cache, and also it will reduce the chance of submiting
small IO from block layer.
Test environment: 8g nokia sd card (very old sd card, but it shows
better effect when testing with this patch, and with a 32g kingston
sd card, I didn't see much more improvement).
Test step:
1. touch testfile;
2. truncate -s 512K testfile;
3. write all pages with odd index;
4. trigger gc by ioctl;
5. write all pages with even index;
6. time fsync testfile.
before:
real 0m0.402s
user 0m0.000s
sys 0m0.000s
after:
real 0m0.143s
user 0m0.004s
sys 0m0.004s
Signed-off-by: Chao Yu <chao2.yu@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2015-07-14 18:56:10 +08:00
|
|
|
|
2018-05-23 22:25:09 +08:00
|
|
|
/* give a priority to WB_SYNC threads */
|
2018-06-04 23:20:36 +08:00
|
|
|
if (atomic_read(&sbi->wb_sync_req[DATA]) &&
|
2018-05-23 22:25:09 +08:00
|
|
|
wbc->sync_mode == WB_SYNC_NONE) {
|
|
|
|
|
done = 1;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
f2fs: expose f2fs_write_cache_pages
If there are gced dirty pages and normal dirty pages in the mapping
of one inode, we might writeback them alternately with discontinuous
block address, resulting in low performance.
This patch introduces f2fs_write_cache_pages with codes copied from
write_cache_pages in mm/page-writeback.c.
In this function, we refactor flow with two steps:
1) writeback all cold type pages.
2) writeback all non-cold type pages.
By using this method, f2fs will writeback dirty pages with the same
temperature in bunch mode, it makes writeouted block being with
more continuous address, so they can be merged as much as possible
in f2fs bio cache, and also it will reduce the chance of submiting
small IO from block layer.
Test environment: 8g nokia sd card (very old sd card, but it shows
better effect when testing with this patch, and with a 32g kingston
sd card, I didn't see much more improvement).
Test step:
1. touch testfile;
2. truncate -s 512K testfile;
3. write all pages with odd index;
4. trigger gc by ioctl;
5. write all pages with even index;
6. time fsync testfile.
before:
real 0m0.402s
user 0m0.000s
sys 0m0.000s
after:
real 0m0.143s
user 0m0.004s
sys 0m0.004s
Signed-off-by: Chao Yu <chao2.yu@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2015-07-14 18:56:10 +08:00
|
|
|
done_index = page->index;
|
2017-06-22 08:52:39 +08:00
|
|
|
retry_write:
|
f2fs: expose f2fs_write_cache_pages
If there are gced dirty pages and normal dirty pages in the mapping
of one inode, we might writeback them alternately with discontinuous
block address, resulting in low performance.
This patch introduces f2fs_write_cache_pages with codes copied from
write_cache_pages in mm/page-writeback.c.
In this function, we refactor flow with two steps:
1) writeback all cold type pages.
2) writeback all non-cold type pages.
By using this method, f2fs will writeback dirty pages with the same
temperature in bunch mode, it makes writeouted block being with
more continuous address, so they can be merged as much as possible
in f2fs bio cache, and also it will reduce the chance of submiting
small IO from block layer.
Test environment: 8g nokia sd card (very old sd card, but it shows
better effect when testing with this patch, and with a 32g kingston
sd card, I didn't see much more improvement).
Test step:
1. touch testfile;
2. truncate -s 512K testfile;
3. write all pages with odd index;
4. trigger gc by ioctl;
5. write all pages with even index;
6. time fsync testfile.
before:
real 0m0.402s
user 0m0.000s
sys 0m0.000s
after:
real 0m0.143s
user 0m0.004s
sys 0m0.004s
Signed-off-by: Chao Yu <chao2.yu@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2015-07-14 18:56:10 +08:00
|
|
|
lock_page(page);
|
|
|
|
|
|
|
|
|
|
if (unlikely(page->mapping != mapping)) {
|
|
|
|
|
continue_unlock:
|
|
|
|
|
unlock_page(page);
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (!PageDirty(page)) {
|
|
|
|
|
/* someone wrote it for us */
|
|
|
|
|
goto continue_unlock;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (PageWriteback(page)) {
|
|
|
|
|
if (wbc->sync_mode != WB_SYNC_NONE)
|
2016-01-20 23:43:51 +08:00
|
|
|
f2fs_wait_on_page_writeback(page,
|
|
|
|
|
DATA, true);
|
f2fs: expose f2fs_write_cache_pages
If there are gced dirty pages and normal dirty pages in the mapping
of one inode, we might writeback them alternately with discontinuous
block address, resulting in low performance.
This patch introduces f2fs_write_cache_pages with codes copied from
write_cache_pages in mm/page-writeback.c.
In this function, we refactor flow with two steps:
1) writeback all cold type pages.
2) writeback all non-cold type pages.
By using this method, f2fs will writeback dirty pages with the same
temperature in bunch mode, it makes writeouted block being with
more continuous address, so they can be merged as much as possible
in f2fs bio cache, and also it will reduce the chance of submiting
small IO from block layer.
Test environment: 8g nokia sd card (very old sd card, but it shows
better effect when testing with this patch, and with a 32g kingston
sd card, I didn't see much more improvement).
Test step:
1. touch testfile;
2. truncate -s 512K testfile;
3. write all pages with odd index;
4. trigger gc by ioctl;
5. write all pages with even index;
6. time fsync testfile.
before:
real 0m0.402s
user 0m0.000s
sys 0m0.000s
after:
real 0m0.143s
user 0m0.004s
sys 0m0.004s
Signed-off-by: Chao Yu <chao2.yu@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2015-07-14 18:56:10 +08:00
|
|
|
else
|
|
|
|
|
goto continue_unlock;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
BUG_ON(PageWriteback(page));
|
|
|
|
|
if (!clear_page_dirty_for_io(page))
|
|
|
|
|
goto continue_unlock;
|
|
|
|
|
|
2017-08-02 23:21:48 +08:00
|
|
|
ret = __write_data_page(page, &submitted, wbc, io_type);
|
f2fs: expose f2fs_write_cache_pages
If there are gced dirty pages and normal dirty pages in the mapping
of one inode, we might writeback them alternately with discontinuous
block address, resulting in low performance.
This patch introduces f2fs_write_cache_pages with codes copied from
write_cache_pages in mm/page-writeback.c.
In this function, we refactor flow with two steps:
1) writeback all cold type pages.
2) writeback all non-cold type pages.
By using this method, f2fs will writeback dirty pages with the same
temperature in bunch mode, it makes writeouted block being with
more continuous address, so they can be merged as much as possible
in f2fs bio cache, and also it will reduce the chance of submiting
small IO from block layer.
Test environment: 8g nokia sd card (very old sd card, but it shows
better effect when testing with this patch, and with a 32g kingston
sd card, I didn't see much more improvement).
Test step:
1. touch testfile;
2. truncate -s 512K testfile;
3. write all pages with odd index;
4. trigger gc by ioctl;
5. write all pages with even index;
6. time fsync testfile.
before:
real 0m0.402s
user 0m0.000s
sys 0m0.000s
after:
real 0m0.143s
user 0m0.004s
sys 0m0.004s
Signed-off-by: Chao Yu <chao2.yu@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2015-07-14 18:56:10 +08:00
|
|
|
if (unlikely(ret)) {
|
2016-11-29 11:13:43 +08:00
|
|
|
/*
|
|
|
|
|
* keep nr_to_write, since vfs uses this to
|
|
|
|
|
* get # of written pages.
|
|
|
|
|
*/
|
|
|
|
|
if (ret == AOP_WRITEPAGE_ACTIVATE) {
|
|
|
|
|
unlock_page(page);
|
|
|
|
|
ret = 0;
|
|
|
|
|
continue;
|
2017-06-22 08:52:39 +08:00
|
|
|
} else if (ret == -EAGAIN) {
|
|
|
|
|
ret = 0;
|
|
|
|
|
if (wbc->sync_mode == WB_SYNC_ALL) {
|
|
|
|
|
cond_resched();
|
|
|
|
|
congestion_wait(BLK_RW_ASYNC,
|
|
|
|
|
HZ/50);
|
|
|
|
|
goto retry_write;
|
|
|
|
|
}
|
|
|
|
|
continue;
|
2016-11-29 11:13:43 +08:00
|
|
|
}
|
2016-05-30 12:18:23 +08:00
|
|
|
done_index = page->index + 1;
|
|
|
|
|
done = 1;
|
|
|
|
|
break;
|
2017-02-04 09:44:04 +08:00
|
|
|
} else if (submitted) {
|
2017-02-02 08:51:22 +08:00
|
|
|
last_idx = page->index;
|
f2fs: expose f2fs_write_cache_pages
If there are gced dirty pages and normal dirty pages in the mapping
of one inode, we might writeback them alternately with discontinuous
block address, resulting in low performance.
This patch introduces f2fs_write_cache_pages with codes copied from
write_cache_pages in mm/page-writeback.c.
In this function, we refactor flow with two steps:
1) writeback all cold type pages.
2) writeback all non-cold type pages.
By using this method, f2fs will writeback dirty pages with the same
temperature in bunch mode, it makes writeouted block being with
more continuous address, so they can be merged as much as possible
in f2fs bio cache, and also it will reduce the chance of submiting
small IO from block layer.
Test environment: 8g nokia sd card (very old sd card, but it shows
better effect when testing with this patch, and with a 32g kingston
sd card, I didn't see much more improvement).
Test step:
1. touch testfile;
2. truncate -s 512K testfile;
3. write all pages with odd index;
4. trigger gc by ioctl;
5. write all pages with even index;
6. time fsync testfile.
before:
real 0m0.402s
user 0m0.000s
sys 0m0.000s
after:
real 0m0.143s
user 0m0.004s
sys 0m0.004s
Signed-off-by: Chao Yu <chao2.yu@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2015-07-14 18:56:10 +08:00
|
|
|
}
|
|
|
|
|
|
2018-05-23 22:25:09 +08:00
|
|
|
if (--wbc->nr_to_write <= 0 &&
|
2017-03-29 09:07:38 +08:00
|
|
|
wbc->sync_mode == WB_SYNC_NONE) {
|
f2fs: expose f2fs_write_cache_pages
If there are gced dirty pages and normal dirty pages in the mapping
of one inode, we might writeback them alternately with discontinuous
block address, resulting in low performance.
This patch introduces f2fs_write_cache_pages with codes copied from
write_cache_pages in mm/page-writeback.c.
In this function, we refactor flow with two steps:
1) writeback all cold type pages.
2) writeback all non-cold type pages.
By using this method, f2fs will writeback dirty pages with the same
temperature in bunch mode, it makes writeouted block being with
more continuous address, so they can be merged as much as possible
in f2fs bio cache, and also it will reduce the chance of submiting
small IO from block layer.
Test environment: 8g nokia sd card (very old sd card, but it shows
better effect when testing with this patch, and with a 32g kingston
sd card, I didn't see much more improvement).
Test step:
1. touch testfile;
2. truncate -s 512K testfile;
3. write all pages with odd index;
4. trigger gc by ioctl;
5. write all pages with even index;
6. time fsync testfile.
before:
real 0m0.402s
user 0m0.000s
sys 0m0.000s
after:
real 0m0.143s
user 0m0.004s
sys 0m0.004s
Signed-off-by: Chao Yu <chao2.yu@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2015-07-14 18:56:10 +08:00
|
|
|
done = 1;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
pagevec_release(&pvec);
|
|
|
|
|
cond_resched();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (!cycled && !done) {
|
|
|
|
|
cycled = 1;
|
|
|
|
|
index = 0;
|
|
|
|
|
end = writeback_index - 1;
|
|
|
|
|
goto retry;
|
|
|
|
|
}
|
|
|
|
|
if (wbc->range_cyclic || (range_whole && wbc->nr_to_write > 0))
|
|
|
|
|
mapping->writeback_index = done_index;
|
|
|
|
|
|
2017-02-02 08:51:22 +08:00
|
|
|
if (last_idx != ULONG_MAX)
|
2017-05-11 02:28:38 +08:00
|
|
|
f2fs_submit_merged_write_cond(F2FS_M_SB(mapping), mapping->host,
|
|
|
|
|
0, last_idx, DATA);
|
2016-09-29 18:50:11 +08:00
|
|
|
|
f2fs: expose f2fs_write_cache_pages
If there are gced dirty pages and normal dirty pages in the mapping
of one inode, we might writeback them alternately with discontinuous
block address, resulting in low performance.
This patch introduces f2fs_write_cache_pages with codes copied from
write_cache_pages in mm/page-writeback.c.
In this function, we refactor flow with two steps:
1) writeback all cold type pages.
2) writeback all non-cold type pages.
By using this method, f2fs will writeback dirty pages with the same
temperature in bunch mode, it makes writeouted block being with
more continuous address, so they can be merged as much as possible
in f2fs bio cache, and also it will reduce the chance of submiting
small IO from block layer.
Test environment: 8g nokia sd card (very old sd card, but it shows
better effect when testing with this patch, and with a 32g kingston
sd card, I didn't see much more improvement).
Test step:
1. touch testfile;
2. truncate -s 512K testfile;
3. write all pages with odd index;
4. trigger gc by ioctl;
5. write all pages with even index;
6. time fsync testfile.
before:
real 0m0.402s
user 0m0.000s
sys 0m0.000s
after:
real 0m0.143s
user 0m0.004s
sys 0m0.004s
Signed-off-by: Chao Yu <chao2.yu@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2015-07-14 18:56:10 +08:00
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2018-05-30 00:20:39 +08:00
|
|
|
static int __f2fs_write_data_pages(struct address_space *mapping,
|
2017-08-02 23:21:48 +08:00
|
|
|
struct writeback_control *wbc,
|
|
|
|
|
enum iostat_type io_type)
|
2012-11-02 16:10:12 +08:00
|
|
|
{
|
|
|
|
|
struct inode *inode = mapping->host;
|
2014-09-03 06:31:18 +08:00
|
|
|
struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
|
2016-07-14 10:33:19 +08:00
|
|
|
struct blk_plug plug;
|
2012-11-02 16:10:12 +08:00
|
|
|
int ret;
|
|
|
|
|
|
2013-04-03 10:38:00 +08:00
|
|
|
/* deal with chardevs and other special file */
|
|
|
|
|
if (!mapping->a_ops->writepage)
|
|
|
|
|
return 0;
|
|
|
|
|
|
2015-07-17 18:02:39 +08:00
|
|
|
/* skip writing if there is no dirty page in this inode */
|
|
|
|
|
if (!get_dirty_pages(inode) && wbc->sync_mode == WB_SYNC_NONE)
|
|
|
|
|
return 0;
|
|
|
|
|
|
2017-06-29 23:20:45 +08:00
|
|
|
/* during POR, we don't need to trigger writepage at all. */
|
|
|
|
|
if (unlikely(is_sbi_flag_set(sbi, SBI_POR_DOING)))
|
|
|
|
|
goto skip_write;
|
|
|
|
|
|
2015-10-09 01:40:07 +08:00
|
|
|
if (S_ISDIR(inode->i_mode) && wbc->sync_mode == WB_SYNC_NONE &&
|
|
|
|
|
get_dirty_pages(inode) < nr_pages_to_skip(sbi, DATA) &&
|
f2fs: clean up symbol namespace
As Ted reported:
"Hi, I was looking at f2fs's sources recently, and I noticed that there
is a very large number of non-static symbols which don't have a f2fs
prefix. There's well over a hundred (see attached below).
As one example, in fs/f2fs/dir.c there is:
unsigned char get_de_type(struct f2fs_dir_entry *de)
This function is clearly only useful for f2fs, but it has a generic
name. This means that if any other file system tries to have the same
symbol name, there will be a symbol conflict and the kernel would not
successfully build. It also means that when someone is looking f2fs
sources, it's not at all obvious whether a function such as
read_data_page(), invalidate_blocks(), is a generic kernel function
found in the fs, mm, or block layers, or a f2fs specific function.
You might want to fix this at some point. Hopefully Kent's bcachefs
isn't similarly using genericly named functions, since that might
cause conflicts with f2fs's functions --- but just as this would be a
problem that we would rightly insist that Kent fix, this is something
that we should have rightly insisted that f2fs should have fixed
before it was integrated into the mainline kernel.
acquire_orphan_inode
add_ino_entry
add_orphan_inode
allocate_data_block
allocate_new_segments
alloc_nid
alloc_nid_done
alloc_nid_failed
available_free_memory
...."
This patch adds "f2fs_" prefix for all non-static symbols in order to:
a) avoid conflict with other kernel generic symbols;
b) to indicate the function is f2fs specific one instead of generic
one;
Reported-by: Theodore Ts'o <tytso@mit.edu>
Signed-off-by: Chao Yu <yuchao0@huawei.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2018-05-30 00:20:41 +08:00
|
|
|
f2fs_available_free_memory(sbi, DIRTY_DENTS))
|
2015-10-09 01:40:07 +08:00
|
|
|
goto skip_write;
|
|
|
|
|
|
2015-10-27 09:53:45 +08:00
|
|
|
/* skip writing during file defragment */
|
2016-05-21 01:13:22 +08:00
|
|
|
if (is_inode_flag_set(inode, FI_DO_DEFRAG))
|
2015-10-27 09:53:45 +08:00
|
|
|
goto skip_write;
|
|
|
|
|
|
2016-02-04 16:14:00 +08:00
|
|
|
trace_f2fs_writepages(mapping->host, wbc, DATA);
|
|
|
|
|
|
2017-03-29 09:07:38 +08:00
|
|
|
/* to avoid spliting IOs due to mixed WB_SYNC_ALL and WB_SYNC_NONE */
|
|
|
|
|
if (wbc->sync_mode == WB_SYNC_ALL)
|
2018-06-04 23:20:36 +08:00
|
|
|
atomic_inc(&sbi->wb_sync_req[DATA]);
|
|
|
|
|
else if (atomic_read(&sbi->wb_sync_req[DATA]))
|
2017-03-29 09:07:38 +08:00
|
|
|
goto skip_write;
|
|
|
|
|
|
2016-07-14 10:33:19 +08:00
|
|
|
blk_start_plug(&plug);
|
2017-08-02 23:21:48 +08:00
|
|
|
ret = f2fs_write_cache_pages(mapping, wbc, io_type);
|
2016-07-14 10:33:19 +08:00
|
|
|
blk_finish_plug(&plug);
|
2017-03-29 09:07:38 +08:00
|
|
|
|
|
|
|
|
if (wbc->sync_mode == WB_SYNC_ALL)
|
2018-06-04 23:20:36 +08:00
|
|
|
atomic_dec(&sbi->wb_sync_req[DATA]);
|
2016-05-26 08:17:56 +08:00
|
|
|
/*
|
|
|
|
|
* if some pages were truncated, we cannot guarantee its mapping->host
|
|
|
|
|
* to detect pending bios.
|
|
|
|
|
*/
|
2013-12-11 12:54:01 +08:00
|
|
|
|
f2fs: clean up symbol namespace
As Ted reported:
"Hi, I was looking at f2fs's sources recently, and I noticed that there
is a very large number of non-static symbols which don't have a f2fs
prefix. There's well over a hundred (see attached below).
As one example, in fs/f2fs/dir.c there is:
unsigned char get_de_type(struct f2fs_dir_entry *de)
This function is clearly only useful for f2fs, but it has a generic
name. This means that if any other file system tries to have the same
symbol name, there will be a symbol conflict and the kernel would not
successfully build. It also means that when someone is looking f2fs
sources, it's not at all obvious whether a function such as
read_data_page(), invalidate_blocks(), is a generic kernel function
found in the fs, mm, or block layers, or a f2fs specific function.
You might want to fix this at some point. Hopefully Kent's bcachefs
isn't similarly using genericly named functions, since that might
cause conflicts with f2fs's functions --- but just as this would be a
problem that we would rightly insist that Kent fix, this is something
that we should have rightly insisted that f2fs should have fixed
before it was integrated into the mainline kernel.
acquire_orphan_inode
add_ino_entry
add_orphan_inode
allocate_data_block
allocate_new_segments
alloc_nid
alloc_nid_done
alloc_nid_failed
available_free_memory
...."
This patch adds "f2fs_" prefix for all non-static symbols in order to:
a) avoid conflict with other kernel generic symbols;
b) to indicate the function is f2fs specific one instead of generic
one;
Reported-by: Theodore Ts'o <tytso@mit.edu>
Signed-off-by: Chao Yu <yuchao0@huawei.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2018-05-30 00:20:41 +08:00
|
|
|
f2fs_remove_dirty_inode(inode);
|
2012-11-02 16:10:12 +08:00
|
|
|
return ret;
|
2014-03-18 12:43:05 +08:00
|
|
|
|
|
|
|
|
skip_write:
|
2014-09-13 06:53:45 +08:00
|
|
|
wbc->pages_skipped += get_dirty_pages(inode);
|
2016-02-04 16:14:00 +08:00
|
|
|
trace_f2fs_writepages(mapping->host, wbc, DATA);
|
2014-03-18 12:43:05 +08:00
|
|
|
return 0;
|
2012-11-02 16:10:12 +08:00
|
|
|
}
|
|
|
|
|
|
2017-08-02 23:21:48 +08:00
|
|
|
static int f2fs_write_data_pages(struct address_space *mapping,
|
|
|
|
|
struct writeback_control *wbc)
|
|
|
|
|
{
|
|
|
|
|
struct inode *inode = mapping->host;
|
|
|
|
|
|
|
|
|
|
return __f2fs_write_data_pages(mapping, wbc,
|
|
|
|
|
F2FS_I(inode)->cp_task == current ?
|
|
|
|
|
FS_CP_DATA_IO : FS_DATA_IO);
|
|
|
|
|
}
|
|
|
|
|
|
2014-07-02 13:25:04 +08:00
|
|
|
static void f2fs_write_failed(struct address_space *mapping, loff_t to)
|
|
|
|
|
{
|
|
|
|
|
struct inode *inode = mapping->host;
|
2015-12-29 05:48:11 +08:00
|
|
|
loff_t i_size = i_size_read(inode);
|
2014-07-02 13:25:04 +08:00
|
|
|
|
2015-12-29 05:48:11 +08:00
|
|
|
if (to > i_size) {
|
2017-05-18 11:06:45 +08:00
|
|
|
down_write(&F2FS_I(inode)->i_mmap_sem);
|
2015-12-29 05:48:11 +08:00
|
|
|
truncate_pagecache(inode, i_size);
|
f2fs: clean up symbol namespace
As Ted reported:
"Hi, I was looking at f2fs's sources recently, and I noticed that there
is a very large number of non-static symbols which don't have a f2fs
prefix. There's well over a hundred (see attached below).
As one example, in fs/f2fs/dir.c there is:
unsigned char get_de_type(struct f2fs_dir_entry *de)
This function is clearly only useful for f2fs, but it has a generic
name. This means that if any other file system tries to have the same
symbol name, there will be a symbol conflict and the kernel would not
successfully build. It also means that when someone is looking f2fs
sources, it's not at all obvious whether a function such as
read_data_page(), invalidate_blocks(), is a generic kernel function
found in the fs, mm, or block layers, or a f2fs specific function.
You might want to fix this at some point. Hopefully Kent's bcachefs
isn't similarly using genericly named functions, since that might
cause conflicts with f2fs's functions --- but just as this would be a
problem that we would rightly insist that Kent fix, this is something
that we should have rightly insisted that f2fs should have fixed
before it was integrated into the mainline kernel.
acquire_orphan_inode
add_ino_entry
add_orphan_inode
allocate_data_block
allocate_new_segments
alloc_nid
alloc_nid_done
alloc_nid_failed
available_free_memory
...."
This patch adds "f2fs_" prefix for all non-static symbols in order to:
a) avoid conflict with other kernel generic symbols;
b) to indicate the function is f2fs specific one instead of generic
one;
Reported-by: Theodore Ts'o <tytso@mit.edu>
Signed-off-by: Chao Yu <yuchao0@huawei.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2018-05-30 00:20:41 +08:00
|
|
|
f2fs_truncate_blocks(inode, i_size, true);
|
2017-05-18 11:06:45 +08:00
|
|
|
up_write(&F2FS_I(inode)->i_mmap_sem);
|
2014-07-02 13:25:04 +08:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2015-12-24 03:55:18 +08:00
|
|
|
static int prepare_write_begin(struct f2fs_sb_info *sbi,
|
|
|
|
|
struct page *page, loff_t pos, unsigned len,
|
|
|
|
|
block_t *blk_addr, bool *node_changed)
|
|
|
|
|
{
|
|
|
|
|
struct inode *inode = page->mapping->host;
|
|
|
|
|
pgoff_t index = page->index;
|
|
|
|
|
struct dnode_of_data dn;
|
|
|
|
|
struct page *ipage;
|
2015-12-24 05:48:58 +08:00
|
|
|
bool locked = false;
|
2017-02-23 17:18:05 +08:00
|
|
|
struct extent_info ei = {0,0,0};
|
2015-12-24 03:55:18 +08:00
|
|
|
int err = 0;
|
|
|
|
|
|
2016-02-04 05:49:44 +08:00
|
|
|
/*
|
|
|
|
|
* we already allocated all the blocks, so we don't need to get
|
|
|
|
|
* the block addresses when there is no need to fill the page.
|
|
|
|
|
*/
|
2017-01-14 05:12:29 +08:00
|
|
|
if (!f2fs_has_inline_data(inode) && len == PAGE_SIZE &&
|
|
|
|
|
!is_inode_flag_set(inode, FI_NO_PREALLOC))
|
2016-02-04 05:49:44 +08:00
|
|
|
return 0;
|
|
|
|
|
|
2015-12-24 05:48:58 +08:00
|
|
|
if (f2fs_has_inline_data(inode) ||
|
mm, fs: get rid of PAGE_CACHE_* and page_cache_{get,release} macros
PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} macros were introduced *long* time
ago with promise that one day it will be possible to implement page
cache with bigger chunks than PAGE_SIZE.
This promise never materialized. And unlikely will.
We have many places where PAGE_CACHE_SIZE assumed to be equal to
PAGE_SIZE. And it's constant source of confusion on whether
PAGE_CACHE_* or PAGE_* constant should be used in a particular case,
especially on the border between fs and mm.
Global switching to PAGE_CACHE_SIZE != PAGE_SIZE would cause to much
breakage to be doable.
Let's stop pretending that pages in page cache are special. They are
not.
The changes are pretty straight-forward:
- <foo> << (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- <foo> >> (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} -> PAGE_{SIZE,SHIFT,MASK,ALIGN};
- page_cache_get() -> get_page();
- page_cache_release() -> put_page();
This patch contains automated changes generated with coccinelle using
script below. For some reason, coccinelle doesn't patch header files.
I've called spatch for them manually.
The only adjustment after coccinelle is revert of changes to
PAGE_CAHCE_ALIGN definition: we are going to drop it later.
There are few places in the code where coccinelle didn't reach. I'll
fix them manually in a separate patch. Comments and documentation also
will be addressed with the separate patch.
virtual patch
@@
expression E;
@@
- E << (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
expression E;
@@
- E >> (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
@@
- PAGE_CACHE_SHIFT
+ PAGE_SHIFT
@@
@@
- PAGE_CACHE_SIZE
+ PAGE_SIZE
@@
@@
- PAGE_CACHE_MASK
+ PAGE_MASK
@@
expression E;
@@
- PAGE_CACHE_ALIGN(E)
+ PAGE_ALIGN(E)
@@
expression E;
@@
- page_cache_get(E)
+ get_page(E)
@@
expression E;
@@
- page_cache_release(E)
+ put_page(E)
Signed-off-by: Kirill A. Shutemov <kirill.shutemov@linux.intel.com>
Acked-by: Michal Hocko <mhocko@suse.com>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2016-04-01 20:29:47 +08:00
|
|
|
(pos & PAGE_MASK) >= i_size_read(inode)) {
|
2017-03-13 20:22:18 +08:00
|
|
|
__do_map_lock(sbi, F2FS_GET_BLOCK_PRE_AIO, true);
|
2015-12-24 05:48:58 +08:00
|
|
|
locked = true;
|
|
|
|
|
}
|
|
|
|
|
restart:
|
2015-12-24 03:55:18 +08:00
|
|
|
/* check inline_data */
|
f2fs: clean up symbol namespace
As Ted reported:
"Hi, I was looking at f2fs's sources recently, and I noticed that there
is a very large number of non-static symbols which don't have a f2fs
prefix. There's well over a hundred (see attached below).
As one example, in fs/f2fs/dir.c there is:
unsigned char get_de_type(struct f2fs_dir_entry *de)
This function is clearly only useful for f2fs, but it has a generic
name. This means that if any other file system tries to have the same
symbol name, there will be a symbol conflict and the kernel would not
successfully build. It also means that when someone is looking f2fs
sources, it's not at all obvious whether a function such as
read_data_page(), invalidate_blocks(), is a generic kernel function
found in the fs, mm, or block layers, or a f2fs specific function.
You might want to fix this at some point. Hopefully Kent's bcachefs
isn't similarly using genericly named functions, since that might
cause conflicts with f2fs's functions --- but just as this would be a
problem that we would rightly insist that Kent fix, this is something
that we should have rightly insisted that f2fs should have fixed
before it was integrated into the mainline kernel.
acquire_orphan_inode
add_ino_entry
add_orphan_inode
allocate_data_block
allocate_new_segments
alloc_nid
alloc_nid_done
alloc_nid_failed
available_free_memory
...."
This patch adds "f2fs_" prefix for all non-static symbols in order to:
a) avoid conflict with other kernel generic symbols;
b) to indicate the function is f2fs specific one instead of generic
one;
Reported-by: Theodore Ts'o <tytso@mit.edu>
Signed-off-by: Chao Yu <yuchao0@huawei.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2018-05-30 00:20:41 +08:00
|
|
|
ipage = f2fs_get_node_page(sbi, inode->i_ino);
|
2015-12-24 03:55:18 +08:00
|
|
|
if (IS_ERR(ipage)) {
|
|
|
|
|
err = PTR_ERR(ipage);
|
|
|
|
|
goto unlock_out;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
set_new_dnode(&dn, inode, ipage, ipage, 0);
|
|
|
|
|
|
|
|
|
|
if (f2fs_has_inline_data(inode)) {
|
2017-07-19 00:19:05 +08:00
|
|
|
if (pos + len <= MAX_INLINE_DATA(inode)) {
|
f2fs: clean up symbol namespace
As Ted reported:
"Hi, I was looking at f2fs's sources recently, and I noticed that there
is a very large number of non-static symbols which don't have a f2fs
prefix. There's well over a hundred (see attached below).
As one example, in fs/f2fs/dir.c there is:
unsigned char get_de_type(struct f2fs_dir_entry *de)
This function is clearly only useful for f2fs, but it has a generic
name. This means that if any other file system tries to have the same
symbol name, there will be a symbol conflict and the kernel would not
successfully build. It also means that when someone is looking f2fs
sources, it's not at all obvious whether a function such as
read_data_page(), invalidate_blocks(), is a generic kernel function
found in the fs, mm, or block layers, or a f2fs specific function.
You might want to fix this at some point. Hopefully Kent's bcachefs
isn't similarly using genericly named functions, since that might
cause conflicts with f2fs's functions --- but just as this would be a
problem that we would rightly insist that Kent fix, this is something
that we should have rightly insisted that f2fs should have fixed
before it was integrated into the mainline kernel.
acquire_orphan_inode
add_ino_entry
add_orphan_inode
allocate_data_block
allocate_new_segments
alloc_nid
alloc_nid_done
alloc_nid_failed
available_free_memory
...."
This patch adds "f2fs_" prefix for all non-static symbols in order to:
a) avoid conflict with other kernel generic symbols;
b) to indicate the function is f2fs specific one instead of generic
one;
Reported-by: Theodore Ts'o <tytso@mit.edu>
Signed-off-by: Chao Yu <yuchao0@huawei.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2018-05-30 00:20:41 +08:00
|
|
|
f2fs_do_read_inline_data(page, ipage);
|
2016-05-21 01:13:22 +08:00
|
|
|
set_inode_flag(inode, FI_DATA_EXIST);
|
2016-05-11 19:48:44 +08:00
|
|
|
if (inode->i_nlink)
|
|
|
|
|
set_inline_node(ipage);
|
2015-12-24 03:55:18 +08:00
|
|
|
} else {
|
|
|
|
|
err = f2fs_convert_inline_page(&dn, page);
|
|
|
|
|
if (err)
|
2015-12-24 05:48:58 +08:00
|
|
|
goto out;
|
|
|
|
|
if (dn.data_blkaddr == NULL_ADDR)
|
|
|
|
|
err = f2fs_get_block(&dn, index);
|
|
|
|
|
}
|
|
|
|
|
} else if (locked) {
|
|
|
|
|
err = f2fs_get_block(&dn, index);
|
|
|
|
|
} else {
|
|
|
|
|
if (f2fs_lookup_extent_cache(inode, index, &ei)) {
|
|
|
|
|
dn.data_blkaddr = ei.blk + index - ei.fofs;
|
|
|
|
|
} else {
|
|
|
|
|
/* hole case */
|
f2fs: clean up symbol namespace
As Ted reported:
"Hi, I was looking at f2fs's sources recently, and I noticed that there
is a very large number of non-static symbols which don't have a f2fs
prefix. There's well over a hundred (see attached below).
As one example, in fs/f2fs/dir.c there is:
unsigned char get_de_type(struct f2fs_dir_entry *de)
This function is clearly only useful for f2fs, but it has a generic
name. This means that if any other file system tries to have the same
symbol name, there will be a symbol conflict and the kernel would not
successfully build. It also means that when someone is looking f2fs
sources, it's not at all obvious whether a function such as
read_data_page(), invalidate_blocks(), is a generic kernel function
found in the fs, mm, or block layers, or a f2fs specific function.
You might want to fix this at some point. Hopefully Kent's bcachefs
isn't similarly using genericly named functions, since that might
cause conflicts with f2fs's functions --- but just as this would be a
problem that we would rightly insist that Kent fix, this is something
that we should have rightly insisted that f2fs should have fixed
before it was integrated into the mainline kernel.
acquire_orphan_inode
add_ino_entry
add_orphan_inode
allocate_data_block
allocate_new_segments
alloc_nid
alloc_nid_done
alloc_nid_failed
available_free_memory
...."
This patch adds "f2fs_" prefix for all non-static symbols in order to:
a) avoid conflict with other kernel generic symbols;
b) to indicate the function is f2fs specific one instead of generic
one;
Reported-by: Theodore Ts'o <tytso@mit.edu>
Signed-off-by: Chao Yu <yuchao0@huawei.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2018-05-30 00:20:41 +08:00
|
|
|
err = f2fs_get_dnode_of_data(&dn, index, LOOKUP_NODE);
|
2016-04-07 02:27:03 +08:00
|
|
|
if (err || dn.data_blkaddr == NULL_ADDR) {
|
2015-12-24 05:48:58 +08:00
|
|
|
f2fs_put_dnode(&dn);
|
2017-03-13 20:22:18 +08:00
|
|
|
__do_map_lock(sbi, F2FS_GET_BLOCK_PRE_AIO,
|
|
|
|
|
true);
|
2015-12-24 05:48:58 +08:00
|
|
|
locked = true;
|
|
|
|
|
goto restart;
|
|
|
|
|
}
|
2015-12-24 03:55:18 +08:00
|
|
|
}
|
|
|
|
|
}
|
2015-12-24 05:48:58 +08:00
|
|
|
|
2015-12-24 03:55:18 +08:00
|
|
|
/* convert_inline_page can make node_changed */
|
|
|
|
|
*blk_addr = dn.data_blkaddr;
|
|
|
|
|
*node_changed = dn.node_changed;
|
2015-12-24 05:48:58 +08:00
|
|
|
out:
|
2015-12-24 03:55:18 +08:00
|
|
|
f2fs_put_dnode(&dn);
|
|
|
|
|
unlock_out:
|
2015-12-24 05:48:58 +08:00
|
|
|
if (locked)
|
2017-03-13 20:22:18 +08:00
|
|
|
__do_map_lock(sbi, F2FS_GET_BLOCK_PRE_AIO, false);
|
2015-12-24 03:55:18 +08:00
|
|
|
return err;
|
|
|
|
|
}
|
|
|
|
|
|
2012-11-02 16:10:12 +08:00
|
|
|
static int f2fs_write_begin(struct file *file, struct address_space *mapping,
|
|
|
|
|
loff_t pos, unsigned len, unsigned flags,
|
|
|
|
|
struct page **pagep, void **fsdata)
|
|
|
|
|
{
|
|
|
|
|
struct inode *inode = mapping->host;
|
2014-09-03 06:31:18 +08:00
|
|
|
struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
|
2015-07-16 04:08:21 +08:00
|
|
|
struct page *page = NULL;
|
mm, fs: get rid of PAGE_CACHE_* and page_cache_{get,release} macros
PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} macros were introduced *long* time
ago with promise that one day it will be possible to implement page
cache with bigger chunks than PAGE_SIZE.
This promise never materialized. And unlikely will.
We have many places where PAGE_CACHE_SIZE assumed to be equal to
PAGE_SIZE. And it's constant source of confusion on whether
PAGE_CACHE_* or PAGE_* constant should be used in a particular case,
especially on the border between fs and mm.
Global switching to PAGE_CACHE_SIZE != PAGE_SIZE would cause to much
breakage to be doable.
Let's stop pretending that pages in page cache are special. They are
not.
The changes are pretty straight-forward:
- <foo> << (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- <foo> >> (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} -> PAGE_{SIZE,SHIFT,MASK,ALIGN};
- page_cache_get() -> get_page();
- page_cache_release() -> put_page();
This patch contains automated changes generated with coccinelle using
script below. For some reason, coccinelle doesn't patch header files.
I've called spatch for them manually.
The only adjustment after coccinelle is revert of changes to
PAGE_CAHCE_ALIGN definition: we are going to drop it later.
There are few places in the code where coccinelle didn't reach. I'll
fix them manually in a separate patch. Comments and documentation also
will be addressed with the separate patch.
virtual patch
@@
expression E;
@@
- E << (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
expression E;
@@
- E >> (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
@@
- PAGE_CACHE_SHIFT
+ PAGE_SHIFT
@@
@@
- PAGE_CACHE_SIZE
+ PAGE_SIZE
@@
@@
- PAGE_CACHE_MASK
+ PAGE_MASK
@@
expression E;
@@
- PAGE_CACHE_ALIGN(E)
+ PAGE_ALIGN(E)
@@
expression E;
@@
- page_cache_get(E)
+ get_page(E)
@@
expression E;
@@
- page_cache_release(E)
+ put_page(E)
Signed-off-by: Kirill A. Shutemov <kirill.shutemov@linux.intel.com>
Acked-by: Michal Hocko <mhocko@suse.com>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2016-04-01 20:29:47 +08:00
|
|
|
pgoff_t index = ((unsigned long long) pos) >> PAGE_SHIFT;
|
2018-01-15 17:16:46 +08:00
|
|
|
bool need_balance = false, drop_atomic = false;
|
2015-12-24 03:55:18 +08:00
|
|
|
block_t blkaddr = NULL_ADDR;
|
2012-11-02 16:10:12 +08:00
|
|
|
int err = 0;
|
|
|
|
|
|
2014-05-06 16:46:04 +08:00
|
|
|
trace_f2fs_write_begin(inode, pos, len, flags);
|
|
|
|
|
|
2017-10-19 10:05:57 +08:00
|
|
|
if (f2fs_is_atomic_file(inode) &&
|
f2fs: clean up symbol namespace
As Ted reported:
"Hi, I was looking at f2fs's sources recently, and I noticed that there
is a very large number of non-static symbols which don't have a f2fs
prefix. There's well over a hundred (see attached below).
As one example, in fs/f2fs/dir.c there is:
unsigned char get_de_type(struct f2fs_dir_entry *de)
This function is clearly only useful for f2fs, but it has a generic
name. This means that if any other file system tries to have the same
symbol name, there will be a symbol conflict and the kernel would not
successfully build. It also means that when someone is looking f2fs
sources, it's not at all obvious whether a function such as
read_data_page(), invalidate_blocks(), is a generic kernel function
found in the fs, mm, or block layers, or a f2fs specific function.
You might want to fix this at some point. Hopefully Kent's bcachefs
isn't similarly using genericly named functions, since that might
cause conflicts with f2fs's functions --- but just as this would be a
problem that we would rightly insist that Kent fix, this is something
that we should have rightly insisted that f2fs should have fixed
before it was integrated into the mainline kernel.
acquire_orphan_inode
add_ino_entry
add_orphan_inode
allocate_data_block
allocate_new_segments
alloc_nid
alloc_nid_done
alloc_nid_failed
available_free_memory
...."
This patch adds "f2fs_" prefix for all non-static symbols in order to:
a) avoid conflict with other kernel generic symbols;
b) to indicate the function is f2fs specific one instead of generic
one;
Reported-by: Theodore Ts'o <tytso@mit.edu>
Signed-off-by: Chao Yu <yuchao0@huawei.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2018-05-30 00:20:41 +08:00
|
|
|
!f2fs_available_free_memory(sbi, INMEM_PAGES)) {
|
2017-10-19 10:05:57 +08:00
|
|
|
err = -ENOMEM;
|
2018-01-15 17:16:46 +08:00
|
|
|
drop_atomic = true;
|
2017-10-19 10:05:57 +08:00
|
|
|
goto fail;
|
|
|
|
|
}
|
|
|
|
|
|
2014-11-26 02:59:45 +08:00
|
|
|
/*
|
|
|
|
|
* We should check this at this moment to avoid deadlock on inode page
|
|
|
|
|
* and #0 page. The locking rule for inline_data conversion should be:
|
|
|
|
|
* lock_page(page #0) -> lock_page(inode_page)
|
|
|
|
|
*/
|
|
|
|
|
if (index != 0) {
|
|
|
|
|
err = f2fs_convert_inline_inode(inode);
|
|
|
|
|
if (err)
|
|
|
|
|
goto fail;
|
|
|
|
|
}
|
2013-04-26 10:55:17 +08:00
|
|
|
repeat:
|
2017-02-18 01:55:55 +08:00
|
|
|
/*
|
|
|
|
|
* Do not use grab_cache_page_write_begin() to avoid deadlock due to
|
|
|
|
|
* wait_for_stable_page. Will wait that below with our IO control.
|
|
|
|
|
*/
|
2017-10-28 16:52:30 +08:00
|
|
|
page = f2fs_pagecache_get_page(mapping, index,
|
2017-02-18 01:55:55 +08:00
|
|
|
FGP_LOCK | FGP_WRITE | FGP_CREAT, GFP_NOFS);
|
2014-07-02 13:25:04 +08:00
|
|
|
if (!page) {
|
|
|
|
|
err = -ENOMEM;
|
|
|
|
|
goto fail;
|
|
|
|
|
}
|
2014-04-30 08:22:45 +08:00
|
|
|
|
2012-11-02 16:10:12 +08:00
|
|
|
*pagep = page;
|
|
|
|
|
|
2015-12-24 03:55:18 +08:00
|
|
|
err = prepare_write_begin(sbi, page, pos, len,
|
|
|
|
|
&blkaddr, &need_balance);
|
2014-10-18 11:33:55 +08:00
|
|
|
if (err)
|
2015-12-24 03:55:18 +08:00
|
|
|
goto fail;
|
2014-10-18 11:33:55 +08:00
|
|
|
|
2016-09-02 03:02:51 +08:00
|
|
|
if (need_balance && has_not_enough_free_secs(sbi, 0, 0)) {
|
2015-12-23 05:23:35 +08:00
|
|
|
unlock_page(page);
|
2016-01-08 06:15:04 +08:00
|
|
|
f2fs_balance_fs(sbi, true);
|
2015-12-23 05:23:35 +08:00
|
|
|
lock_page(page);
|
|
|
|
|
if (page->mapping != mapping) {
|
|
|
|
|
/* The page got truncated from under us */
|
|
|
|
|
f2fs_put_page(page, 1);
|
|
|
|
|
goto repeat;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2016-01-20 23:43:51 +08:00
|
|
|
f2fs_wait_on_page_writeback(page, DATA, false);
|
2014-10-24 10:48:09 +08:00
|
|
|
|
f2fs: refactor read path to allow multiple postprocessing steps
Currently f2fs's ->readpage() and ->readpages() assume that either the
data undergoes no postprocessing, or decryption only. But with
fs-verity, there will be an additional authenticity verification step,
and it may be needed either by itself, or combined with decryption.
To support this, store a 'struct bio_post_read_ctx' in ->bi_private
which contains a work struct, a bitmask of postprocessing steps that are
enabled, and an indicator of the current step. The bio completion
routine, if there was no I/O error, enqueues the first postprocessing
step. When that completes, it continues to the next step. Pages that
fail any postprocessing step have PageError set. Once all steps have
completed, pages without PageError set are set Uptodate, and all pages
are unlocked.
Also replace f2fs_encrypted_file() with a new function
f2fs_post_read_required() in places like direct I/O and garbage
collection that really should be testing whether the file needs special
I/O processing, not whether it is encrypted specifically.
This may also be useful for other future f2fs features such as
compression.
Signed-off-by: Eric Biggers <ebiggers@google.com>
Reviewed-by: Chao Yu <yuchao0@huawei.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2018-04-19 02:09:48 +08:00
|
|
|
/* wait for GCed page writeback via META_MAPPING */
|
|
|
|
|
if (f2fs_post_read_required(inode))
|
2017-09-06 08:04:35 +08:00
|
|
|
f2fs_wait_on_block_writeback(sbi, blkaddr);
|
2015-10-08 13:27:34 +08:00
|
|
|
|
2016-09-07 02:02:03 +08:00
|
|
|
if (len == PAGE_SIZE || PageUptodate(page))
|
|
|
|
|
return 0;
|
2012-11-02 16:10:12 +08:00
|
|
|
|
2016-12-20 11:11:35 +08:00
|
|
|
if (!(pos & (PAGE_SIZE - 1)) && (pos + len) >= i_size_read(inode)) {
|
|
|
|
|
zero_user_segment(page, len, PAGE_SIZE);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2015-12-24 03:55:18 +08:00
|
|
|
if (blkaddr == NEW_ADDR) {
|
mm, fs: get rid of PAGE_CACHE_* and page_cache_{get,release} macros
PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} macros were introduced *long* time
ago with promise that one day it will be possible to implement page
cache with bigger chunks than PAGE_SIZE.
This promise never materialized. And unlikely will.
We have many places where PAGE_CACHE_SIZE assumed to be equal to
PAGE_SIZE. And it's constant source of confusion on whether
PAGE_CACHE_* or PAGE_* constant should be used in a particular case,
especially on the border between fs and mm.
Global switching to PAGE_CACHE_SIZE != PAGE_SIZE would cause to much
breakage to be doable.
Let's stop pretending that pages in page cache are special. They are
not.
The changes are pretty straight-forward:
- <foo> << (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- <foo> >> (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} -> PAGE_{SIZE,SHIFT,MASK,ALIGN};
- page_cache_get() -> get_page();
- page_cache_release() -> put_page();
This patch contains automated changes generated with coccinelle using
script below. For some reason, coccinelle doesn't patch header files.
I've called spatch for them manually.
The only adjustment after coccinelle is revert of changes to
PAGE_CAHCE_ALIGN definition: we are going to drop it later.
There are few places in the code where coccinelle didn't reach. I'll
fix them manually in a separate patch. Comments and documentation also
will be addressed with the separate patch.
virtual patch
@@
expression E;
@@
- E << (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
expression E;
@@
- E >> (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
@@
- PAGE_CACHE_SHIFT
+ PAGE_SHIFT
@@
@@
- PAGE_CACHE_SIZE
+ PAGE_SIZE
@@
@@
- PAGE_CACHE_MASK
+ PAGE_MASK
@@
expression E;
@@
- PAGE_CACHE_ALIGN(E)
+ PAGE_ALIGN(E)
@@
expression E;
@@
- page_cache_get(E)
+ get_page(E)
@@
expression E;
@@
- page_cache_release(E)
+ put_page(E)
Signed-off-by: Kirill A. Shutemov <kirill.shutemov@linux.intel.com>
Acked-by: Michal Hocko <mhocko@suse.com>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2016-04-01 20:29:47 +08:00
|
|
|
zero_user_segment(page, 0, PAGE_SIZE);
|
2016-09-07 02:02:03 +08:00
|
|
|
SetPageUptodate(page);
|
2012-11-02 16:10:12 +08:00
|
|
|
} else {
|
2017-09-07 12:04:44 +08:00
|
|
|
err = f2fs_submit_page_read(inode, page, blkaddr);
|
|
|
|
|
if (err)
|
2016-07-03 22:05:11 +08:00
|
|
|
goto fail;
|
2014-03-29 15:30:40 +08:00
|
|
|
|
2013-03-08 20:29:23 +08:00
|
|
|
lock_page(page);
|
2013-12-06 14:00:58 +08:00
|
|
|
if (unlikely(page->mapping != mapping)) {
|
2013-04-26 10:55:17 +08:00
|
|
|
f2fs_put_page(page, 1);
|
|
|
|
|
goto repeat;
|
2012-11-02 16:10:12 +08:00
|
|
|
}
|
2016-07-03 22:05:12 +08:00
|
|
|
if (unlikely(!PageUptodate(page))) {
|
|
|
|
|
err = -EIO;
|
|
|
|
|
goto fail;
|
2015-04-24 03:04:33 +08:00
|
|
|
}
|
2012-11-02 16:10:12 +08:00
|
|
|
}
|
|
|
|
|
return 0;
|
2014-10-18 11:33:55 +08:00
|
|
|
|
2014-07-02 13:25:04 +08:00
|
|
|
fail:
|
2015-07-16 04:08:21 +08:00
|
|
|
f2fs_put_page(page, 1);
|
2014-07-02 13:25:04 +08:00
|
|
|
f2fs_write_failed(mapping, pos + len);
|
2018-01-15 17:16:46 +08:00
|
|
|
if (drop_atomic)
|
f2fs: clean up symbol namespace
As Ted reported:
"Hi, I was looking at f2fs's sources recently, and I noticed that there
is a very large number of non-static symbols which don't have a f2fs
prefix. There's well over a hundred (see attached below).
As one example, in fs/f2fs/dir.c there is:
unsigned char get_de_type(struct f2fs_dir_entry *de)
This function is clearly only useful for f2fs, but it has a generic
name. This means that if any other file system tries to have the same
symbol name, there will be a symbol conflict and the kernel would not
successfully build. It also means that when someone is looking f2fs
sources, it's not at all obvious whether a function such as
read_data_page(), invalidate_blocks(), is a generic kernel function
found in the fs, mm, or block layers, or a f2fs specific function.
You might want to fix this at some point. Hopefully Kent's bcachefs
isn't similarly using genericly named functions, since that might
cause conflicts with f2fs's functions --- but just as this would be a
problem that we would rightly insist that Kent fix, this is something
that we should have rightly insisted that f2fs should have fixed
before it was integrated into the mainline kernel.
acquire_orphan_inode
add_ino_entry
add_orphan_inode
allocate_data_block
allocate_new_segments
alloc_nid
alloc_nid_done
alloc_nid_failed
available_free_memory
...."
This patch adds "f2fs_" prefix for all non-static symbols in order to:
a) avoid conflict with other kernel generic symbols;
b) to indicate the function is f2fs specific one instead of generic
one;
Reported-by: Theodore Ts'o <tytso@mit.edu>
Signed-off-by: Chao Yu <yuchao0@huawei.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2018-05-30 00:20:41 +08:00
|
|
|
f2fs_drop_inmem_pages_all(sbi, false);
|
2014-07-02 13:25:04 +08:00
|
|
|
return err;
|
2012-11-02 16:10:12 +08:00
|
|
|
}
|
|
|
|
|
|
2013-06-27 12:04:08 +08:00
|
|
|
static int f2fs_write_end(struct file *file,
|
|
|
|
|
struct address_space *mapping,
|
|
|
|
|
loff_t pos, unsigned len, unsigned copied,
|
|
|
|
|
struct page *page, void *fsdata)
|
|
|
|
|
{
|
|
|
|
|
struct inode *inode = page->mapping->host;
|
|
|
|
|
|
2014-05-06 16:47:23 +08:00
|
|
|
trace_f2fs_write_end(inode, pos, len, copied);
|
|
|
|
|
|
2016-09-07 02:02:03 +08:00
|
|
|
/*
|
|
|
|
|
* This should be come from len == PAGE_SIZE, and we expect copied
|
|
|
|
|
* should be PAGE_SIZE. Otherwise, we treat it with zero copied and
|
|
|
|
|
* let generic_perform_write() try to copy data again through copied=0.
|
|
|
|
|
*/
|
|
|
|
|
if (!PageUptodate(page)) {
|
2016-12-20 11:11:35 +08:00
|
|
|
if (unlikely(copied != len))
|
2016-09-07 02:02:03 +08:00
|
|
|
copied = 0;
|
|
|
|
|
else
|
|
|
|
|
SetPageUptodate(page);
|
|
|
|
|
}
|
|
|
|
|
if (!copied)
|
|
|
|
|
goto unlock_out;
|
|
|
|
|
|
2014-10-10 04:19:53 +08:00
|
|
|
set_page_dirty(page);
|
2013-06-27 12:04:08 +08:00
|
|
|
|
2016-05-21 00:22:03 +08:00
|
|
|
if (pos + copied > i_size_read(inode))
|
|
|
|
|
f2fs_i_size_write(inode, pos + copied);
|
2016-09-07 02:02:03 +08:00
|
|
|
unlock_out:
|
2016-08-06 21:09:41 +08:00
|
|
|
f2fs_put_page(page, 1);
|
2016-01-09 08:57:48 +08:00
|
|
|
f2fs_update_time(F2FS_I_SB(inode), REQ_TIME);
|
2013-06-27 12:04:08 +08:00
|
|
|
return copied;
|
|
|
|
|
}
|
|
|
|
|
|
2015-03-16 19:33:52 +08:00
|
|
|
static int check_direct_IO(struct inode *inode, struct iov_iter *iter,
|
|
|
|
|
loff_t offset)
|
2013-12-26 19:15:09 +08:00
|
|
|
{
|
|
|
|
|
unsigned blocksize_mask = inode->i_sb->s_blocksize - 1;
|
|
|
|
|
|
|
|
|
|
if (offset & blocksize_mask)
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
2014-03-17 06:07:34 +08:00
|
|
|
if (iov_iter_alignment(iter) & blocksize_mask)
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
2013-12-26 19:15:09 +08:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2016-04-07 23:51:58 +08:00
|
|
|
static ssize_t f2fs_direct_IO(struct kiocb *iocb, struct iov_iter *iter)
|
2012-11-02 16:10:12 +08:00
|
|
|
{
|
2016-02-04 05:09:09 +08:00
|
|
|
struct address_space *mapping = iocb->ki_filp->f_mapping;
|
2014-07-02 13:25:04 +08:00
|
|
|
struct inode *inode = mapping->host;
|
2018-01-31 10:36:57 +08:00
|
|
|
struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
|
2014-07-02 13:25:04 +08:00
|
|
|
size_t count = iov_iter_count(iter);
|
2016-04-07 23:51:58 +08:00
|
|
|
loff_t offset = iocb->ki_pos;
|
2016-07-13 09:18:29 +08:00
|
|
|
int rw = iov_iter_rw(iter);
|
2014-07-02 13:25:04 +08:00
|
|
|
int err;
|
2018-01-31 10:36:57 +08:00
|
|
|
enum rw_hint hint = iocb->ki_hint;
|
2018-03-08 14:22:56 +08:00
|
|
|
int whint_mode = F2FS_OPTION(sbi).whint_mode;
|
2013-12-26 19:15:09 +08:00
|
|
|
|
2016-02-04 05:09:09 +08:00
|
|
|
err = check_direct_IO(inode, iter, offset);
|
2015-12-23 03:09:35 +08:00
|
|
|
if (err)
|
|
|
|
|
return err;
|
f2fs: handle inline data operations
Hook inline data read/write, truncate, fallocate, setattr, etc.
Files need meet following 2 requirement to inline:
1) file size is not greater than MAX_INLINE_DATA;
2) file doesn't pre-allocate data blocks by fallocate().
FI_INLINE_DATA will not be set while creating a new regular inode because
most of the files are bigger than ~3.4K. Set FI_INLINE_DATA only when
data is submitted to block layer, ranther than set it while creating a new
inode, this also avoids converting data from inline to normal data block
and vice versa.
While writting inline data to inode block, the first data block should be
released if the file has a block indexed by i_addr[0].
On the other hand, when a file operation is appied to a file with inline
data, we need to test if this file can remain inline by doing this
operation, otherwise it should be convert into normal file by reserving
a new data block, copying inline data to this new block and clear
FI_INLINE_DATA flag. Because reserve a new data block here will make use
of i_addr[0], if we save inline data in i_addr[0..872], then the first
4 bytes would be overwriten. This problem can be avoided simply by
not using i_addr[0] for inline data.
Signed-off-by: Huajun Li <huajun.li@intel.com>
Signed-off-by: Haicheng Li <haicheng.li@linux.intel.com>
Signed-off-by: Weihong Xu <weihong.xu@intel.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2013-11-10 23:13:20 +08:00
|
|
|
|
2018-03-08 18:34:38 +08:00
|
|
|
if (f2fs_force_buffered_io(inode, rw))
|
2016-06-04 10:29:38 +08:00
|
|
|
return 0;
|
2015-04-22 11:39:58 +08:00
|
|
|
|
2016-07-23 06:25:47 +08:00
|
|
|
trace_f2fs_direct_IO_enter(inode, offset, count, rw);
|
2014-07-31 21:11:22 +08:00
|
|
|
|
2018-01-31 10:36:57 +08:00
|
|
|
if (rw == WRITE && whint_mode == WHINT_MODE_OFF)
|
|
|
|
|
iocb->ki_hint = WRITE_LIFE_NOT_SET;
|
|
|
|
|
|
2018-04-24 10:55:28 +08:00
|
|
|
if (!down_read_trylock(&F2FS_I(inode)->i_gc_rwsem[rw])) {
|
2018-03-08 18:34:38 +08:00
|
|
|
if (iocb->ki_flags & IOCB_NOWAIT) {
|
|
|
|
|
iocb->ki_hint = hint;
|
|
|
|
|
err = -EAGAIN;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
2018-04-24 10:55:28 +08:00
|
|
|
down_read(&F2FS_I(inode)->i_gc_rwsem[rw]);
|
2018-03-08 18:34:38 +08:00
|
|
|
}
|
|
|
|
|
|
2016-04-07 23:51:58 +08:00
|
|
|
err = blockdev_direct_IO(iocb, inode, iter, get_data_block_dio);
|
2018-04-24 10:55:28 +08:00
|
|
|
up_read(&F2FS_I(inode)->i_gc_rwsem[rw]);
|
2016-07-13 09:18:29 +08:00
|
|
|
|
|
|
|
|
if (rw == WRITE) {
|
2018-01-31 10:36:57 +08:00
|
|
|
if (whint_mode == WHINT_MODE_OFF)
|
|
|
|
|
iocb->ki_hint = hint;
|
2017-08-02 23:21:48 +08:00
|
|
|
if (err > 0) {
|
|
|
|
|
f2fs_update_iostat(F2FS_I_SB(inode), APP_DIRECT_IO,
|
|
|
|
|
err);
|
2016-05-21 01:13:22 +08:00
|
|
|
set_inode_flag(inode, FI_UPDATE_WRITE);
|
2017-08-02 23:21:48 +08:00
|
|
|
} else if (err < 0) {
|
2016-04-19 05:07:44 +08:00
|
|
|
f2fs_write_failed(mapping, offset + count);
|
2017-08-02 23:21:48 +08:00
|
|
|
}
|
2016-04-19 05:07:44 +08:00
|
|
|
}
|
2014-07-31 21:11:22 +08:00
|
|
|
|
2018-03-08 18:34:38 +08:00
|
|
|
out:
|
2016-07-23 06:25:47 +08:00
|
|
|
trace_f2fs_direct_IO_exit(inode, offset, count, rw, err);
|
2014-07-31 21:11:22 +08:00
|
|
|
|
2014-07-02 13:25:04 +08:00
|
|
|
return err;
|
2012-11-02 16:10:12 +08:00
|
|
|
}
|
|
|
|
|
|
2015-02-05 17:44:29 +08:00
|
|
|
void f2fs_invalidate_page(struct page *page, unsigned int offset,
|
|
|
|
|
unsigned int length)
|
2012-11-02 16:10:12 +08:00
|
|
|
{
|
|
|
|
|
struct inode *inode = page->mapping->host;
|
2015-02-05 17:44:29 +08:00
|
|
|
struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
|
2014-09-13 06:53:45 +08:00
|
|
|
|
2015-02-05 17:44:29 +08:00
|
|
|
if (inode->i_ino >= F2FS_ROOT_INO(sbi) &&
|
mm, fs: get rid of PAGE_CACHE_* and page_cache_{get,release} macros
PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} macros were introduced *long* time
ago with promise that one day it will be possible to implement page
cache with bigger chunks than PAGE_SIZE.
This promise never materialized. And unlikely will.
We have many places where PAGE_CACHE_SIZE assumed to be equal to
PAGE_SIZE. And it's constant source of confusion on whether
PAGE_CACHE_* or PAGE_* constant should be used in a particular case,
especially on the border between fs and mm.
Global switching to PAGE_CACHE_SIZE != PAGE_SIZE would cause to much
breakage to be doable.
Let's stop pretending that pages in page cache are special. They are
not.
The changes are pretty straight-forward:
- <foo> << (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- <foo> >> (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} -> PAGE_{SIZE,SHIFT,MASK,ALIGN};
- page_cache_get() -> get_page();
- page_cache_release() -> put_page();
This patch contains automated changes generated with coccinelle using
script below. For some reason, coccinelle doesn't patch header files.
I've called spatch for them manually.
The only adjustment after coccinelle is revert of changes to
PAGE_CAHCE_ALIGN definition: we are going to drop it later.
There are few places in the code where coccinelle didn't reach. I'll
fix them manually in a separate patch. Comments and documentation also
will be addressed with the separate patch.
virtual patch
@@
expression E;
@@
- E << (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
expression E;
@@
- E >> (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
@@
- PAGE_CACHE_SHIFT
+ PAGE_SHIFT
@@
@@
- PAGE_CACHE_SIZE
+ PAGE_SIZE
@@
@@
- PAGE_CACHE_MASK
+ PAGE_MASK
@@
expression E;
@@
- PAGE_CACHE_ALIGN(E)
+ PAGE_ALIGN(E)
@@
expression E;
@@
- page_cache_get(E)
+ get_page(E)
@@
expression E;
@@
- page_cache_release(E)
+ put_page(E)
Signed-off-by: Kirill A. Shutemov <kirill.shutemov@linux.intel.com>
Acked-by: Michal Hocko <mhocko@suse.com>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2016-04-01 20:29:47 +08:00
|
|
|
(offset % PAGE_SIZE || length != PAGE_SIZE))
|
2014-09-13 06:53:45 +08:00
|
|
|
return;
|
|
|
|
|
|
2015-02-05 17:44:29 +08:00
|
|
|
if (PageDirty(page)) {
|
2016-10-11 22:57:01 +08:00
|
|
|
if (inode->i_ino == F2FS_META_INO(sbi)) {
|
2015-02-05 17:44:29 +08:00
|
|
|
dec_page_count(sbi, F2FS_DIRTY_META);
|
2016-10-11 22:57:01 +08:00
|
|
|
} else if (inode->i_ino == F2FS_NODE_INO(sbi)) {
|
2015-02-05 17:44:29 +08:00
|
|
|
dec_page_count(sbi, F2FS_DIRTY_NODES);
|
2016-10-11 22:57:01 +08:00
|
|
|
} else {
|
2015-02-05 17:44:29 +08:00
|
|
|
inode_dec_dirty_pages(inode);
|
f2fs: clean up symbol namespace
As Ted reported:
"Hi, I was looking at f2fs's sources recently, and I noticed that there
is a very large number of non-static symbols which don't have a f2fs
prefix. There's well over a hundred (see attached below).
As one example, in fs/f2fs/dir.c there is:
unsigned char get_de_type(struct f2fs_dir_entry *de)
This function is clearly only useful for f2fs, but it has a generic
name. This means that if any other file system tries to have the same
symbol name, there will be a symbol conflict and the kernel would not
successfully build. It also means that when someone is looking f2fs
sources, it's not at all obvious whether a function such as
read_data_page(), invalidate_blocks(), is a generic kernel function
found in the fs, mm, or block layers, or a f2fs specific function.
You might want to fix this at some point. Hopefully Kent's bcachefs
isn't similarly using genericly named functions, since that might
cause conflicts with f2fs's functions --- but just as this would be a
problem that we would rightly insist that Kent fix, this is something
that we should have rightly insisted that f2fs should have fixed
before it was integrated into the mainline kernel.
acquire_orphan_inode
add_ino_entry
add_orphan_inode
allocate_data_block
allocate_new_segments
alloc_nid
alloc_nid_done
alloc_nid_failed
available_free_memory
...."
This patch adds "f2fs_" prefix for all non-static symbols in order to:
a) avoid conflict with other kernel generic symbols;
b) to indicate the function is f2fs specific one instead of generic
one;
Reported-by: Theodore Ts'o <tytso@mit.edu>
Signed-off-by: Chao Yu <yuchao0@huawei.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2018-05-30 00:20:41 +08:00
|
|
|
f2fs_remove_dirty_inode(inode);
|
2016-10-11 22:57:01 +08:00
|
|
|
}
|
2015-02-05 17:44:29 +08:00
|
|
|
}
|
2015-08-07 18:42:09 +08:00
|
|
|
|
|
|
|
|
/* This is atomic written page, keep Private */
|
|
|
|
|
if (IS_ATOMIC_WRITTEN_PAGE(page))
|
f2fs: clean up symbol namespace
As Ted reported:
"Hi, I was looking at f2fs's sources recently, and I noticed that there
is a very large number of non-static symbols which don't have a f2fs
prefix. There's well over a hundred (see attached below).
As one example, in fs/f2fs/dir.c there is:
unsigned char get_de_type(struct f2fs_dir_entry *de)
This function is clearly only useful for f2fs, but it has a generic
name. This means that if any other file system tries to have the same
symbol name, there will be a symbol conflict and the kernel would not
successfully build. It also means that when someone is looking f2fs
sources, it's not at all obvious whether a function such as
read_data_page(), invalidate_blocks(), is a generic kernel function
found in the fs, mm, or block layers, or a f2fs specific function.
You might want to fix this at some point. Hopefully Kent's bcachefs
isn't similarly using genericly named functions, since that might
cause conflicts with f2fs's functions --- but just as this would be a
problem that we would rightly insist that Kent fix, this is something
that we should have rightly insisted that f2fs should have fixed
before it was integrated into the mainline kernel.
acquire_orphan_inode
add_ino_entry
add_orphan_inode
allocate_data_block
allocate_new_segments
alloc_nid
alloc_nid_done
alloc_nid_failed
available_free_memory
...."
This patch adds "f2fs_" prefix for all non-static symbols in order to:
a) avoid conflict with other kernel generic symbols;
b) to indicate the function is f2fs specific one instead of generic
one;
Reported-by: Theodore Ts'o <tytso@mit.edu>
Signed-off-by: Chao Yu <yuchao0@huawei.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2018-05-30 00:20:41 +08:00
|
|
|
return f2fs_drop_inmem_page(inode, page);
|
2015-08-07 18:42:09 +08:00
|
|
|
|
2016-04-29 20:09:15 +08:00
|
|
|
set_page_private(page, 0);
|
2012-11-02 16:10:12 +08:00
|
|
|
ClearPagePrivate(page);
|
|
|
|
|
}
|
|
|
|
|
|
2015-02-05 17:44:29 +08:00
|
|
|
int f2fs_release_page(struct page *page, gfp_t wait)
|
2012-11-02 16:10:12 +08:00
|
|
|
{
|
2015-01-31 03:39:08 +08:00
|
|
|
/* If this is dirty page, keep PagePrivate */
|
|
|
|
|
if (PageDirty(page))
|
|
|
|
|
return 0;
|
|
|
|
|
|
2015-08-07 18:42:09 +08:00
|
|
|
/* This is atomic written page, keep Private */
|
|
|
|
|
if (IS_ATOMIC_WRITTEN_PAGE(page))
|
|
|
|
|
return 0;
|
|
|
|
|
|
2016-04-29 20:09:15 +08:00
|
|
|
set_page_private(page, 0);
|
2012-11-02 16:10:12 +08:00
|
|
|
ClearPagePrivate(page);
|
2013-03-14 08:24:32 +08:00
|
|
|
return 1;
|
2012-11-02 16:10:12 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int f2fs_set_data_page_dirty(struct page *page)
|
|
|
|
|
{
|
|
|
|
|
struct address_space *mapping = page->mapping;
|
|
|
|
|
struct inode *inode = mapping->host;
|
|
|
|
|
|
2013-10-24 16:53:29 +08:00
|
|
|
trace_f2fs_set_page_dirty(page, DATA);
|
|
|
|
|
|
2016-07-01 09:49:15 +08:00
|
|
|
if (!PageUptodate(page))
|
|
|
|
|
SetPageUptodate(page);
|
2014-10-10 04:19:53 +08:00
|
|
|
|
2017-01-07 18:50:26 +08:00
|
|
|
if (f2fs_is_atomic_file(inode) && !f2fs_is_commit_atomic_write(inode)) {
|
2015-08-07 18:42:09 +08:00
|
|
|
if (!IS_ATOMIC_WRITTEN_PAGE(page)) {
|
f2fs: clean up symbol namespace
As Ted reported:
"Hi, I was looking at f2fs's sources recently, and I noticed that there
is a very large number of non-static symbols which don't have a f2fs
prefix. There's well over a hundred (see attached below).
As one example, in fs/f2fs/dir.c there is:
unsigned char get_de_type(struct f2fs_dir_entry *de)
This function is clearly only useful for f2fs, but it has a generic
name. This means that if any other file system tries to have the same
symbol name, there will be a symbol conflict and the kernel would not
successfully build. It also means that when someone is looking f2fs
sources, it's not at all obvious whether a function such as
read_data_page(), invalidate_blocks(), is a generic kernel function
found in the fs, mm, or block layers, or a f2fs specific function.
You might want to fix this at some point. Hopefully Kent's bcachefs
isn't similarly using genericly named functions, since that might
cause conflicts with f2fs's functions --- but just as this would be a
problem that we would rightly insist that Kent fix, this is something
that we should have rightly insisted that f2fs should have fixed
before it was integrated into the mainline kernel.
acquire_orphan_inode
add_ino_entry
add_orphan_inode
allocate_data_block
allocate_new_segments
alloc_nid
alloc_nid_done
alloc_nid_failed
available_free_memory
...."
This patch adds "f2fs_" prefix for all non-static symbols in order to:
a) avoid conflict with other kernel generic symbols;
b) to indicate the function is f2fs specific one instead of generic
one;
Reported-by: Theodore Ts'o <tytso@mit.edu>
Signed-off-by: Chao Yu <yuchao0@huawei.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2018-05-30 00:20:41 +08:00
|
|
|
f2fs_register_inmem_page(inode, page);
|
2015-08-07 18:42:09 +08:00
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
/*
|
|
|
|
|
* Previously, this page has been registered, we just
|
|
|
|
|
* return here.
|
|
|
|
|
*/
|
|
|
|
|
return 0;
|
2014-10-10 04:19:53 +08:00
|
|
|
}
|
|
|
|
|
|
2012-11-02 16:10:12 +08:00
|
|
|
if (!PageDirty(page)) {
|
2018-04-21 10:29:52 +08:00
|
|
|
__set_page_dirty_nobuffers(page);
|
f2fs: clean up symbol namespace
As Ted reported:
"Hi, I was looking at f2fs's sources recently, and I noticed that there
is a very large number of non-static symbols which don't have a f2fs
prefix. There's well over a hundred (see attached below).
As one example, in fs/f2fs/dir.c there is:
unsigned char get_de_type(struct f2fs_dir_entry *de)
This function is clearly only useful for f2fs, but it has a generic
name. This means that if any other file system tries to have the same
symbol name, there will be a symbol conflict and the kernel would not
successfully build. It also means that when someone is looking f2fs
sources, it's not at all obvious whether a function such as
read_data_page(), invalidate_blocks(), is a generic kernel function
found in the fs, mm, or block layers, or a f2fs specific function.
You might want to fix this at some point. Hopefully Kent's bcachefs
isn't similarly using genericly named functions, since that might
cause conflicts with f2fs's functions --- but just as this would be a
problem that we would rightly insist that Kent fix, this is something
that we should have rightly insisted that f2fs should have fixed
before it was integrated into the mainline kernel.
acquire_orphan_inode
add_ino_entry
add_orphan_inode
allocate_data_block
allocate_new_segments
alloc_nid
alloc_nid_done
alloc_nid_failed
available_free_memory
...."
This patch adds "f2fs_" prefix for all non-static symbols in order to:
a) avoid conflict with other kernel generic symbols;
b) to indicate the function is f2fs specific one instead of generic
one;
Reported-by: Theodore Ts'o <tytso@mit.edu>
Signed-off-by: Chao Yu <yuchao0@huawei.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2018-05-30 00:20:41 +08:00
|
|
|
f2fs_update_dirty_page(inode, page);
|
2012-11-02 16:10:12 +08:00
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2013-01-17 19:30:23 +08:00
|
|
|
static sector_t f2fs_bmap(struct address_space *mapping, sector_t block)
|
|
|
|
|
{
|
2014-04-22 13:34:01 +08:00
|
|
|
struct inode *inode = mapping->host;
|
|
|
|
|
|
2015-10-20 01:29:51 +08:00
|
|
|
if (f2fs_has_inline_data(inode))
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
/* make sure allocating whole blocks */
|
|
|
|
|
if (mapping_tagged(mapping, PAGECACHE_TAG_DIRTY))
|
|
|
|
|
filemap_write_and_wait(mapping);
|
|
|
|
|
|
2015-08-19 19:11:19 +08:00
|
|
|
return generic_block_bmap(mapping, block, get_data_block_bmap);
|
2015-02-05 17:54:31 +08:00
|
|
|
}
|
|
|
|
|
|
2016-09-20 05:03:27 +08:00
|
|
|
#ifdef CONFIG_MIGRATION
|
|
|
|
|
#include <linux/migrate.h>
|
|
|
|
|
|
|
|
|
|
int f2fs_migrate_page(struct address_space *mapping,
|
|
|
|
|
struct page *newpage, struct page *page, enum migrate_mode mode)
|
|
|
|
|
{
|
|
|
|
|
int rc, extra_count;
|
|
|
|
|
struct f2fs_inode_info *fi = F2FS_I(mapping->host);
|
|
|
|
|
bool atomic_written = IS_ATOMIC_WRITTEN_PAGE(page);
|
|
|
|
|
|
|
|
|
|
BUG_ON(PageWriteback(page));
|
|
|
|
|
|
|
|
|
|
/* migrating an atomic written page is safe with the inmem_lock hold */
|
2017-07-07 05:46:01 +08:00
|
|
|
if (atomic_written) {
|
|
|
|
|
if (mode != MIGRATE_SYNC)
|
|
|
|
|
return -EBUSY;
|
|
|
|
|
if (!mutex_trylock(&fi->inmem_lock))
|
|
|
|
|
return -EAGAIN;
|
|
|
|
|
}
|
2016-09-20 05:03:27 +08:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* A reference is expected if PagePrivate set when move mapping,
|
|
|
|
|
* however F2FS breaks this for maintaining dirty page counts when
|
|
|
|
|
* truncating pages. So here adjusting the 'extra_count' make it work.
|
|
|
|
|
*/
|
|
|
|
|
extra_count = (atomic_written ? 1 : 0) - page_has_private(page);
|
|
|
|
|
rc = migrate_page_move_mapping(mapping, newpage,
|
|
|
|
|
page, NULL, mode, extra_count);
|
|
|
|
|
if (rc != MIGRATEPAGE_SUCCESS) {
|
|
|
|
|
if (atomic_written)
|
|
|
|
|
mutex_unlock(&fi->inmem_lock);
|
|
|
|
|
return rc;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (atomic_written) {
|
|
|
|
|
struct inmem_pages *cur;
|
|
|
|
|
list_for_each_entry(cur, &fi->inmem_pages, list)
|
|
|
|
|
if (cur->page == page) {
|
|
|
|
|
cur->page = newpage;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
mutex_unlock(&fi->inmem_lock);
|
|
|
|
|
put_page(page);
|
|
|
|
|
get_page(newpage);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (PagePrivate(page))
|
|
|
|
|
SetPagePrivate(newpage);
|
|
|
|
|
set_page_private(newpage, page_private(page));
|
|
|
|
|
|
2017-09-09 07:12:06 +08:00
|
|
|
if (mode != MIGRATE_SYNC_NO_COPY)
|
|
|
|
|
migrate_page_copy(newpage, page);
|
|
|
|
|
else
|
|
|
|
|
migrate_page_states(newpage, page);
|
2016-09-20 05:03:27 +08:00
|
|
|
|
|
|
|
|
return MIGRATEPAGE_SUCCESS;
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
2012-11-02 16:10:12 +08:00
|
|
|
const struct address_space_operations f2fs_dblock_aops = {
|
|
|
|
|
.readpage = f2fs_read_data_page,
|
|
|
|
|
.readpages = f2fs_read_data_pages,
|
|
|
|
|
.writepage = f2fs_write_data_page,
|
|
|
|
|
.writepages = f2fs_write_data_pages,
|
|
|
|
|
.write_begin = f2fs_write_begin,
|
2013-06-27 12:04:08 +08:00
|
|
|
.write_end = f2fs_write_end,
|
2012-11-02 16:10:12 +08:00
|
|
|
.set_page_dirty = f2fs_set_data_page_dirty,
|
2015-02-05 17:44:29 +08:00
|
|
|
.invalidatepage = f2fs_invalidate_page,
|
|
|
|
|
.releasepage = f2fs_release_page,
|
2012-11-02 16:10:12 +08:00
|
|
|
.direct_IO = f2fs_direct_IO,
|
2013-01-17 19:30:23 +08:00
|
|
|
.bmap = f2fs_bmap,
|
2016-09-20 05:03:27 +08:00
|
|
|
#ifdef CONFIG_MIGRATION
|
|
|
|
|
.migratepage = f2fs_migrate_page,
|
|
|
|
|
#endif
|
2012-11-02 16:10:12 +08:00
|
|
|
};
|
f2fs: refactor read path to allow multiple postprocessing steps
Currently f2fs's ->readpage() and ->readpages() assume that either the
data undergoes no postprocessing, or decryption only. But with
fs-verity, there will be an additional authenticity verification step,
and it may be needed either by itself, or combined with decryption.
To support this, store a 'struct bio_post_read_ctx' in ->bi_private
which contains a work struct, a bitmask of postprocessing steps that are
enabled, and an indicator of the current step. The bio completion
routine, if there was no I/O error, enqueues the first postprocessing
step. When that completes, it continues to the next step. Pages that
fail any postprocessing step have PageError set. Once all steps have
completed, pages without PageError set are set Uptodate, and all pages
are unlocked.
Also replace f2fs_encrypted_file() with a new function
f2fs_post_read_required() in places like direct I/O and garbage
collection that really should be testing whether the file needs special
I/O processing, not whether it is encrypted specifically.
This may also be useful for other future f2fs features such as
compression.
Signed-off-by: Eric Biggers <ebiggers@google.com>
Reviewed-by: Chao Yu <yuchao0@huawei.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2018-04-19 02:09:48 +08:00
|
|
|
|
f2fs: clean up symbol namespace
As Ted reported:
"Hi, I was looking at f2fs's sources recently, and I noticed that there
is a very large number of non-static symbols which don't have a f2fs
prefix. There's well over a hundred (see attached below).
As one example, in fs/f2fs/dir.c there is:
unsigned char get_de_type(struct f2fs_dir_entry *de)
This function is clearly only useful for f2fs, but it has a generic
name. This means that if any other file system tries to have the same
symbol name, there will be a symbol conflict and the kernel would not
successfully build. It also means that when someone is looking f2fs
sources, it's not at all obvious whether a function such as
read_data_page(), invalidate_blocks(), is a generic kernel function
found in the fs, mm, or block layers, or a f2fs specific function.
You might want to fix this at some point. Hopefully Kent's bcachefs
isn't similarly using genericly named functions, since that might
cause conflicts with f2fs's functions --- but just as this would be a
problem that we would rightly insist that Kent fix, this is something
that we should have rightly insisted that f2fs should have fixed
before it was integrated into the mainline kernel.
acquire_orphan_inode
add_ino_entry
add_orphan_inode
allocate_data_block
allocate_new_segments
alloc_nid
alloc_nid_done
alloc_nid_failed
available_free_memory
...."
This patch adds "f2fs_" prefix for all non-static symbols in order to:
a) avoid conflict with other kernel generic symbols;
b) to indicate the function is f2fs specific one instead of generic
one;
Reported-by: Theodore Ts'o <tytso@mit.edu>
Signed-off-by: Chao Yu <yuchao0@huawei.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2018-05-30 00:20:41 +08:00
|
|
|
void f2fs_clear_radix_tree_dirty_tag(struct page *page)
|
2018-05-26 18:03:35 +08:00
|
|
|
{
|
|
|
|
|
struct address_space *mapping = page_mapping(page);
|
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
|
|
xa_lock_irqsave(&mapping->i_pages, flags);
|
|
|
|
|
radix_tree_tag_clear(&mapping->i_pages, page_index(page),
|
|
|
|
|
PAGECACHE_TAG_DIRTY);
|
|
|
|
|
xa_unlock_irqrestore(&mapping->i_pages, flags);
|
|
|
|
|
}
|
|
|
|
|
|
f2fs: refactor read path to allow multiple postprocessing steps
Currently f2fs's ->readpage() and ->readpages() assume that either the
data undergoes no postprocessing, or decryption only. But with
fs-verity, there will be an additional authenticity verification step,
and it may be needed either by itself, or combined with decryption.
To support this, store a 'struct bio_post_read_ctx' in ->bi_private
which contains a work struct, a bitmask of postprocessing steps that are
enabled, and an indicator of the current step. The bio completion
routine, if there was no I/O error, enqueues the first postprocessing
step. When that completes, it continues to the next step. Pages that
fail any postprocessing step have PageError set. Once all steps have
completed, pages without PageError set are set Uptodate, and all pages
are unlocked.
Also replace f2fs_encrypted_file() with a new function
f2fs_post_read_required() in places like direct I/O and garbage
collection that really should be testing whether the file needs special
I/O processing, not whether it is encrypted specifically.
This may also be useful for other future f2fs features such as
compression.
Signed-off-by: Eric Biggers <ebiggers@google.com>
Reviewed-by: Chao Yu <yuchao0@huawei.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2018-04-19 02:09:48 +08:00
|
|
|
int __init f2fs_init_post_read_processing(void)
|
|
|
|
|
{
|
|
|
|
|
bio_post_read_ctx_cache = KMEM_CACHE(bio_post_read_ctx, 0);
|
|
|
|
|
if (!bio_post_read_ctx_cache)
|
|
|
|
|
goto fail;
|
|
|
|
|
bio_post_read_ctx_pool =
|
|
|
|
|
mempool_create_slab_pool(NUM_PREALLOC_POST_READ_CTXS,
|
|
|
|
|
bio_post_read_ctx_cache);
|
|
|
|
|
if (!bio_post_read_ctx_pool)
|
|
|
|
|
goto fail_free_cache;
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
fail_free_cache:
|
|
|
|
|
kmem_cache_destroy(bio_post_read_ctx_cache);
|
|
|
|
|
fail:
|
|
|
|
|
return -ENOMEM;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void __exit f2fs_destroy_post_read_processing(void)
|
|
|
|
|
{
|
|
|
|
|
mempool_destroy(bio_post_read_ctx_pool);
|
|
|
|
|
kmem_cache_destroy(bio_post_read_ctx_cache);
|
|
|
|
|
}
|