mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-09-12 13:55:32 +00:00
![Baokun Li](/assets/img/avatar_default.png)
KASAN report null-ptr-deref: ================================================================== BUG: KASAN: null-ptr-deref in bdi_split_work_to_wbs+0x5c5/0x7b0 Write of size 8 at addr 0000000000000000 by task sync/943 CPU: 5 PID: 943 Comm: sync Tainted: 6.3.0-rc5-next-20230406-dirty #461 Call Trace: <TASK> dump_stack_lvl+0x7f/0xc0 print_report+0x2ba/0x340 kasan_report+0xc4/0x120 kasan_check_range+0x1b7/0x2e0 __kasan_check_write+0x24/0x40 bdi_split_work_to_wbs+0x5c5/0x7b0 sync_inodes_sb+0x195/0x630 sync_inodes_one_sb+0x3a/0x50 iterate_supers+0x106/0x1b0 ksys_sync+0x98/0x160 [...] ================================================================== The race that causes the above issue is as follows: cpu1 cpu2 -------------------------|------------------------- inode_switch_wbs INIT_WORK(&isw->work, inode_switch_wbs_work_fn) queue_rcu_work(isw_wq, &isw->work) // queue_work async inode_switch_wbs_work_fn wb_put_many(old_wb, nr_switched) percpu_ref_put_many ref->data->release(ref) cgwb_release queue_work(cgwb_release_wq, &wb->release_work) // queue_work async &wb->release_work cgwb_release_workfn ksys_sync iterate_supers sync_inodes_one_sb sync_inodes_sb bdi_split_work_to_wbs kmalloc(sizeof(*work), GFP_ATOMIC) // alloc memory failed percpu_ref_exit ref->data = NULL kfree(data) wb_get(wb) percpu_ref_get(&wb->refcnt) percpu_ref_get_many(ref, 1) atomic_long_add(nr, &ref->data->count) atomic64_add(i, v) // trigger null-ptr-deref bdi_split_work_to_wbs() traverses &bdi->wb_list to split work into all wbs. If the allocation of new work fails, the on-stack fallback will be used and the reference count of the current wb is increased afterwards. If cgroup writeback membership switches occur before getting the reference count and the current wb is released as old_wd, then calling wb_get() or wb_put() will trigger the null pointer dereference above. This issue was introduced in v4.3-rc7 (see fix tag1). Both sync_inodes_sb() and __writeback_inodes_sb_nr() calls to bdi_split_work_to_wbs() can trigger this issue. For scenarios called via sync_inodes_sb(), originally commit7fc5854f8c
("writeback: synchronize sync(2) against cgroup writeback membership switches") reduced the possibility of the issue by adding wb_switch_rwsem, but in v5.14-rc1 (see fix tag2) removed the "inode_io_list_del_locked(inode, old_wb)" from inode_switch_wbs_work_fn() so that wb->state contains WB_has_dirty_io, thus old_wb is not skipped when traversing wbs in bdi_split_work_to_wbs(), and the issue becomes easily reproducible again. To solve this problem, percpu_ref_exit() is called under RCU protection to avoid race between cgwb_release_workfn() and bdi_split_work_to_wbs(). Moreover, replace wb_get() with wb_tryget() in bdi_split_work_to_wbs(), and skip the current wb if wb_tryget() fails because the wb has already been shutdown. Link: https://lkml.kernel.org/r/20230410130826.1492525-1-libaokun1@huawei.com Fixes:b817525a4a
("writeback: bdi_writeback iteration must not skip dying ones") Signed-off-by: Baokun Li <libaokun1@huawei.com> Reviewed-by: Jan Kara <jack@suse.cz> Acked-by: Tejun Heo <tj@kernel.org> Cc: Alexander Viro <viro@zeniv.linux.org.uk> Cc: Andreas Dilger <adilger.kernel@dilger.ca> Cc: Christian Brauner <brauner@kernel.org> Cc: Dennis Zhou <dennis@kernel.org> Cc: Hou Tao <houtao1@huawei.com> Cc: yangerkun <yangerkun@huawei.com> Cc: Zhang Yi <yi.zhang@huawei.com> Cc: Jens Axboe <axboe@kernel.dk> Cc: <stable@vger.kernel.org> Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
1130 lines
28 KiB
C
1130 lines
28 KiB
C
// SPDX-License-Identifier: GPL-2.0-only
|
|
|
|
#include <linux/blkdev.h>
|
|
#include <linux/wait.h>
|
|
#include <linux/rbtree.h>
|
|
#include <linux/kthread.h>
|
|
#include <linux/backing-dev.h>
|
|
#include <linux/blk-cgroup.h>
|
|
#include <linux/freezer.h>
|
|
#include <linux/fs.h>
|
|
#include <linux/pagemap.h>
|
|
#include <linux/mm.h>
|
|
#include <linux/sched/mm.h>
|
|
#include <linux/sched.h>
|
|
#include <linux/module.h>
|
|
#include <linux/writeback.h>
|
|
#include <linux/device.h>
|
|
#include <trace/events/writeback.h>
|
|
|
|
struct backing_dev_info noop_backing_dev_info;
|
|
EXPORT_SYMBOL_GPL(noop_backing_dev_info);
|
|
|
|
static struct class *bdi_class;
|
|
static const char *bdi_unknown_name = "(unknown)";
|
|
|
|
/*
|
|
* bdi_lock protects bdi_tree and updates to bdi_list. bdi_list has RCU
|
|
* reader side locking.
|
|
*/
|
|
DEFINE_SPINLOCK(bdi_lock);
|
|
static u64 bdi_id_cursor;
|
|
static struct rb_root bdi_tree = RB_ROOT;
|
|
LIST_HEAD(bdi_list);
|
|
|
|
/* bdi_wq serves all asynchronous writeback tasks */
|
|
struct workqueue_struct *bdi_wq;
|
|
|
|
#define K(x) ((x) << (PAGE_SHIFT - 10))
|
|
|
|
#ifdef CONFIG_DEBUG_FS
|
|
#include <linux/debugfs.h>
|
|
#include <linux/seq_file.h>
|
|
|
|
static struct dentry *bdi_debug_root;
|
|
|
|
static void bdi_debug_init(void)
|
|
{
|
|
bdi_debug_root = debugfs_create_dir("bdi", NULL);
|
|
}
|
|
|
|
static int bdi_debug_stats_show(struct seq_file *m, void *v)
|
|
{
|
|
struct backing_dev_info *bdi = m->private;
|
|
struct bdi_writeback *wb = &bdi->wb;
|
|
unsigned long background_thresh;
|
|
unsigned long dirty_thresh;
|
|
unsigned long wb_thresh;
|
|
unsigned long nr_dirty, nr_io, nr_more_io, nr_dirty_time;
|
|
struct inode *inode;
|
|
|
|
nr_dirty = nr_io = nr_more_io = nr_dirty_time = 0;
|
|
spin_lock(&wb->list_lock);
|
|
list_for_each_entry(inode, &wb->b_dirty, i_io_list)
|
|
nr_dirty++;
|
|
list_for_each_entry(inode, &wb->b_io, i_io_list)
|
|
nr_io++;
|
|
list_for_each_entry(inode, &wb->b_more_io, i_io_list)
|
|
nr_more_io++;
|
|
list_for_each_entry(inode, &wb->b_dirty_time, i_io_list)
|
|
if (inode->i_state & I_DIRTY_TIME)
|
|
nr_dirty_time++;
|
|
spin_unlock(&wb->list_lock);
|
|
|
|
global_dirty_limits(&background_thresh, &dirty_thresh);
|
|
wb_thresh = wb_calc_thresh(wb, dirty_thresh);
|
|
|
|
seq_printf(m,
|
|
"BdiWriteback: %10lu kB\n"
|
|
"BdiReclaimable: %10lu kB\n"
|
|
"BdiDirtyThresh: %10lu kB\n"
|
|
"DirtyThresh: %10lu kB\n"
|
|
"BackgroundThresh: %10lu kB\n"
|
|
"BdiDirtied: %10lu kB\n"
|
|
"BdiWritten: %10lu kB\n"
|
|
"BdiWriteBandwidth: %10lu kBps\n"
|
|
"b_dirty: %10lu\n"
|
|
"b_io: %10lu\n"
|
|
"b_more_io: %10lu\n"
|
|
"b_dirty_time: %10lu\n"
|
|
"bdi_list: %10u\n"
|
|
"state: %10lx\n",
|
|
(unsigned long) K(wb_stat(wb, WB_WRITEBACK)),
|
|
(unsigned long) K(wb_stat(wb, WB_RECLAIMABLE)),
|
|
K(wb_thresh),
|
|
K(dirty_thresh),
|
|
K(background_thresh),
|
|
(unsigned long) K(wb_stat(wb, WB_DIRTIED)),
|
|
(unsigned long) K(wb_stat(wb, WB_WRITTEN)),
|
|
(unsigned long) K(wb->write_bandwidth),
|
|
nr_dirty,
|
|
nr_io,
|
|
nr_more_io,
|
|
nr_dirty_time,
|
|
!list_empty(&bdi->bdi_list), bdi->wb.state);
|
|
|
|
return 0;
|
|
}
|
|
DEFINE_SHOW_ATTRIBUTE(bdi_debug_stats);
|
|
|
|
static void bdi_debug_register(struct backing_dev_info *bdi, const char *name)
|
|
{
|
|
bdi->debug_dir = debugfs_create_dir(name, bdi_debug_root);
|
|
|
|
debugfs_create_file("stats", 0444, bdi->debug_dir, bdi,
|
|
&bdi_debug_stats_fops);
|
|
}
|
|
|
|
static void bdi_debug_unregister(struct backing_dev_info *bdi)
|
|
{
|
|
debugfs_remove_recursive(bdi->debug_dir);
|
|
}
|
|
#else
|
|
static inline void bdi_debug_init(void)
|
|
{
|
|
}
|
|
static inline void bdi_debug_register(struct backing_dev_info *bdi,
|
|
const char *name)
|
|
{
|
|
}
|
|
static inline void bdi_debug_unregister(struct backing_dev_info *bdi)
|
|
{
|
|
}
|
|
#endif
|
|
|
|
static ssize_t read_ahead_kb_store(struct device *dev,
|
|
struct device_attribute *attr,
|
|
const char *buf, size_t count)
|
|
{
|
|
struct backing_dev_info *bdi = dev_get_drvdata(dev);
|
|
unsigned long read_ahead_kb;
|
|
ssize_t ret;
|
|
|
|
ret = kstrtoul(buf, 10, &read_ahead_kb);
|
|
if (ret < 0)
|
|
return ret;
|
|
|
|
bdi->ra_pages = read_ahead_kb >> (PAGE_SHIFT - 10);
|
|
|
|
return count;
|
|
}
|
|
|
|
#define BDI_SHOW(name, expr) \
|
|
static ssize_t name##_show(struct device *dev, \
|
|
struct device_attribute *attr, char *buf) \
|
|
{ \
|
|
struct backing_dev_info *bdi = dev_get_drvdata(dev); \
|
|
\
|
|
return sysfs_emit(buf, "%lld\n", (long long)expr); \
|
|
} \
|
|
static DEVICE_ATTR_RW(name);
|
|
|
|
BDI_SHOW(read_ahead_kb, K(bdi->ra_pages))
|
|
|
|
static ssize_t min_ratio_store(struct device *dev,
|
|
struct device_attribute *attr, const char *buf, size_t count)
|
|
{
|
|
struct backing_dev_info *bdi = dev_get_drvdata(dev);
|
|
unsigned int ratio;
|
|
ssize_t ret;
|
|
|
|
ret = kstrtouint(buf, 10, &ratio);
|
|
if (ret < 0)
|
|
return ret;
|
|
|
|
ret = bdi_set_min_ratio(bdi, ratio);
|
|
if (!ret)
|
|
ret = count;
|
|
|
|
return ret;
|
|
}
|
|
BDI_SHOW(min_ratio, bdi->min_ratio / BDI_RATIO_SCALE)
|
|
|
|
static ssize_t min_ratio_fine_store(struct device *dev,
|
|
struct device_attribute *attr, const char *buf, size_t count)
|
|
{
|
|
struct backing_dev_info *bdi = dev_get_drvdata(dev);
|
|
unsigned int ratio;
|
|
ssize_t ret;
|
|
|
|
ret = kstrtouint(buf, 10, &ratio);
|
|
if (ret < 0)
|
|
return ret;
|
|
|
|
ret = bdi_set_min_ratio_no_scale(bdi, ratio);
|
|
if (!ret)
|
|
ret = count;
|
|
|
|
return ret;
|
|
}
|
|
BDI_SHOW(min_ratio_fine, bdi->min_ratio)
|
|
|
|
static ssize_t max_ratio_store(struct device *dev,
|
|
struct device_attribute *attr, const char *buf, size_t count)
|
|
{
|
|
struct backing_dev_info *bdi = dev_get_drvdata(dev);
|
|
unsigned int ratio;
|
|
ssize_t ret;
|
|
|
|
ret = kstrtouint(buf, 10, &ratio);
|
|
if (ret < 0)
|
|
return ret;
|
|
|
|
ret = bdi_set_max_ratio(bdi, ratio);
|
|
if (!ret)
|
|
ret = count;
|
|
|
|
return ret;
|
|
}
|
|
BDI_SHOW(max_ratio, bdi->max_ratio / BDI_RATIO_SCALE)
|
|
|
|
static ssize_t max_ratio_fine_store(struct device *dev,
|
|
struct device_attribute *attr, const char *buf, size_t count)
|
|
{
|
|
struct backing_dev_info *bdi = dev_get_drvdata(dev);
|
|
unsigned int ratio;
|
|
ssize_t ret;
|
|
|
|
ret = kstrtouint(buf, 10, &ratio);
|
|
if (ret < 0)
|
|
return ret;
|
|
|
|
ret = bdi_set_max_ratio_no_scale(bdi, ratio);
|
|
if (!ret)
|
|
ret = count;
|
|
|
|
return ret;
|
|
}
|
|
BDI_SHOW(max_ratio_fine, bdi->max_ratio)
|
|
|
|
static ssize_t min_bytes_show(struct device *dev,
|
|
struct device_attribute *attr,
|
|
char *buf)
|
|
{
|
|
struct backing_dev_info *bdi = dev_get_drvdata(dev);
|
|
|
|
return sysfs_emit(buf, "%llu\n", bdi_get_min_bytes(bdi));
|
|
}
|
|
|
|
static ssize_t min_bytes_store(struct device *dev,
|
|
struct device_attribute *attr, const char *buf, size_t count)
|
|
{
|
|
struct backing_dev_info *bdi = dev_get_drvdata(dev);
|
|
u64 bytes;
|
|
ssize_t ret;
|
|
|
|
ret = kstrtoull(buf, 10, &bytes);
|
|
if (ret < 0)
|
|
return ret;
|
|
|
|
ret = bdi_set_min_bytes(bdi, bytes);
|
|
if (!ret)
|
|
ret = count;
|
|
|
|
return ret;
|
|
}
|
|
DEVICE_ATTR_RW(min_bytes);
|
|
|
|
static ssize_t max_bytes_show(struct device *dev,
|
|
struct device_attribute *attr,
|
|
char *buf)
|
|
{
|
|
struct backing_dev_info *bdi = dev_get_drvdata(dev);
|
|
|
|
return sysfs_emit(buf, "%llu\n", bdi_get_max_bytes(bdi));
|
|
}
|
|
|
|
static ssize_t max_bytes_store(struct device *dev,
|
|
struct device_attribute *attr, const char *buf, size_t count)
|
|
{
|
|
struct backing_dev_info *bdi = dev_get_drvdata(dev);
|
|
u64 bytes;
|
|
ssize_t ret;
|
|
|
|
ret = kstrtoull(buf, 10, &bytes);
|
|
if (ret < 0)
|
|
return ret;
|
|
|
|
ret = bdi_set_max_bytes(bdi, bytes);
|
|
if (!ret)
|
|
ret = count;
|
|
|
|
return ret;
|
|
}
|
|
DEVICE_ATTR_RW(max_bytes);
|
|
|
|
static ssize_t stable_pages_required_show(struct device *dev,
|
|
struct device_attribute *attr,
|
|
char *buf)
|
|
{
|
|
dev_warn_once(dev,
|
|
"the stable_pages_required attribute has been removed. Use the stable_writes queue attribute instead.\n");
|
|
return sysfs_emit(buf, "%d\n", 0);
|
|
}
|
|
static DEVICE_ATTR_RO(stable_pages_required);
|
|
|
|
static ssize_t strict_limit_store(struct device *dev,
|
|
struct device_attribute *attr, const char *buf, size_t count)
|
|
{
|
|
struct backing_dev_info *bdi = dev_get_drvdata(dev);
|
|
unsigned int strict_limit;
|
|
ssize_t ret;
|
|
|
|
ret = kstrtouint(buf, 10, &strict_limit);
|
|
if (ret < 0)
|
|
return ret;
|
|
|
|
ret = bdi_set_strict_limit(bdi, strict_limit);
|
|
if (!ret)
|
|
ret = count;
|
|
|
|
return ret;
|
|
}
|
|
|
|
static ssize_t strict_limit_show(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
struct backing_dev_info *bdi = dev_get_drvdata(dev);
|
|
|
|
return sysfs_emit(buf, "%d\n",
|
|
!!(bdi->capabilities & BDI_CAP_STRICTLIMIT));
|
|
}
|
|
static DEVICE_ATTR_RW(strict_limit);
|
|
|
|
static struct attribute *bdi_dev_attrs[] = {
|
|
&dev_attr_read_ahead_kb.attr,
|
|
&dev_attr_min_ratio.attr,
|
|
&dev_attr_min_ratio_fine.attr,
|
|
&dev_attr_max_ratio.attr,
|
|
&dev_attr_max_ratio_fine.attr,
|
|
&dev_attr_min_bytes.attr,
|
|
&dev_attr_max_bytes.attr,
|
|
&dev_attr_stable_pages_required.attr,
|
|
&dev_attr_strict_limit.attr,
|
|
NULL,
|
|
};
|
|
ATTRIBUTE_GROUPS(bdi_dev);
|
|
|
|
static __init int bdi_class_init(void)
|
|
{
|
|
bdi_class = class_create(THIS_MODULE, "bdi");
|
|
if (IS_ERR(bdi_class))
|
|
return PTR_ERR(bdi_class);
|
|
|
|
bdi_class->dev_groups = bdi_dev_groups;
|
|
bdi_debug_init();
|
|
|
|
return 0;
|
|
}
|
|
postcore_initcall(bdi_class_init);
|
|
|
|
static int __init default_bdi_init(void)
|
|
{
|
|
bdi_wq = alloc_workqueue("writeback", WQ_MEM_RECLAIM | WQ_UNBOUND |
|
|
WQ_SYSFS, 0);
|
|
if (!bdi_wq)
|
|
return -ENOMEM;
|
|
return 0;
|
|
}
|
|
subsys_initcall(default_bdi_init);
|
|
|
|
/*
|
|
* This function is used when the first inode for this wb is marked dirty. It
|
|
* wakes-up the corresponding bdi thread which should then take care of the
|
|
* periodic background write-out of dirty inodes. Since the write-out would
|
|
* starts only 'dirty_writeback_interval' centisecs from now anyway, we just
|
|
* set up a timer which wakes the bdi thread up later.
|
|
*
|
|
* Note, we wouldn't bother setting up the timer, but this function is on the
|
|
* fast-path (used by '__mark_inode_dirty()'), so we save few context switches
|
|
* by delaying the wake-up.
|
|
*
|
|
* We have to be careful not to postpone flush work if it is scheduled for
|
|
* earlier. Thus we use queue_delayed_work().
|
|
*/
|
|
void wb_wakeup_delayed(struct bdi_writeback *wb)
|
|
{
|
|
unsigned long timeout;
|
|
|
|
timeout = msecs_to_jiffies(dirty_writeback_interval * 10);
|
|
spin_lock_irq(&wb->work_lock);
|
|
if (test_bit(WB_registered, &wb->state))
|
|
queue_delayed_work(bdi_wq, &wb->dwork, timeout);
|
|
spin_unlock_irq(&wb->work_lock);
|
|
}
|
|
|
|
static void wb_update_bandwidth_workfn(struct work_struct *work)
|
|
{
|
|
struct bdi_writeback *wb = container_of(to_delayed_work(work),
|
|
struct bdi_writeback, bw_dwork);
|
|
|
|
wb_update_bandwidth(wb);
|
|
}
|
|
|
|
/*
|
|
* Initial write bandwidth: 100 MB/s
|
|
*/
|
|
#define INIT_BW (100 << (20 - PAGE_SHIFT))
|
|
|
|
static int wb_init(struct bdi_writeback *wb, struct backing_dev_info *bdi,
|
|
gfp_t gfp)
|
|
{
|
|
int i, err;
|
|
|
|
memset(wb, 0, sizeof(*wb));
|
|
|
|
wb->bdi = bdi;
|
|
wb->last_old_flush = jiffies;
|
|
INIT_LIST_HEAD(&wb->b_dirty);
|
|
INIT_LIST_HEAD(&wb->b_io);
|
|
INIT_LIST_HEAD(&wb->b_more_io);
|
|
INIT_LIST_HEAD(&wb->b_dirty_time);
|
|
spin_lock_init(&wb->list_lock);
|
|
|
|
atomic_set(&wb->writeback_inodes, 0);
|
|
wb->bw_time_stamp = jiffies;
|
|
wb->balanced_dirty_ratelimit = INIT_BW;
|
|
wb->dirty_ratelimit = INIT_BW;
|
|
wb->write_bandwidth = INIT_BW;
|
|
wb->avg_write_bandwidth = INIT_BW;
|
|
|
|
spin_lock_init(&wb->work_lock);
|
|
INIT_LIST_HEAD(&wb->work_list);
|
|
INIT_DELAYED_WORK(&wb->dwork, wb_workfn);
|
|
INIT_DELAYED_WORK(&wb->bw_dwork, wb_update_bandwidth_workfn);
|
|
wb->dirty_sleep = jiffies;
|
|
|
|
err = fprop_local_init_percpu(&wb->completions, gfp);
|
|
if (err)
|
|
return err;
|
|
|
|
for (i = 0; i < NR_WB_STAT_ITEMS; i++) {
|
|
err = percpu_counter_init(&wb->stat[i], 0, gfp);
|
|
if (err)
|
|
goto out_destroy_stat;
|
|
}
|
|
|
|
return 0;
|
|
|
|
out_destroy_stat:
|
|
while (i--)
|
|
percpu_counter_destroy(&wb->stat[i]);
|
|
fprop_local_destroy_percpu(&wb->completions);
|
|
return err;
|
|
}
|
|
|
|
static void cgwb_remove_from_bdi_list(struct bdi_writeback *wb);
|
|
|
|
/*
|
|
* Remove bdi from the global list and shutdown any threads we have running
|
|
*/
|
|
static void wb_shutdown(struct bdi_writeback *wb)
|
|
{
|
|
/* Make sure nobody queues further work */
|
|
spin_lock_irq(&wb->work_lock);
|
|
if (!test_and_clear_bit(WB_registered, &wb->state)) {
|
|
spin_unlock_irq(&wb->work_lock);
|
|
return;
|
|
}
|
|
spin_unlock_irq(&wb->work_lock);
|
|
|
|
cgwb_remove_from_bdi_list(wb);
|
|
/*
|
|
* Drain work list and shutdown the delayed_work. !WB_registered
|
|
* tells wb_workfn() that @wb is dying and its work_list needs to
|
|
* be drained no matter what.
|
|
*/
|
|
mod_delayed_work(bdi_wq, &wb->dwork, 0);
|
|
flush_delayed_work(&wb->dwork);
|
|
WARN_ON(!list_empty(&wb->work_list));
|
|
flush_delayed_work(&wb->bw_dwork);
|
|
}
|
|
|
|
static void wb_exit(struct bdi_writeback *wb)
|
|
{
|
|
int i;
|
|
|
|
WARN_ON(delayed_work_pending(&wb->dwork));
|
|
|
|
for (i = 0; i < NR_WB_STAT_ITEMS; i++)
|
|
percpu_counter_destroy(&wb->stat[i]);
|
|
|
|
fprop_local_destroy_percpu(&wb->completions);
|
|
}
|
|
|
|
#ifdef CONFIG_CGROUP_WRITEBACK
|
|
|
|
#include <linux/memcontrol.h>
|
|
|
|
/*
|
|
* cgwb_lock protects bdi->cgwb_tree, blkcg->cgwb_list, offline_cgwbs and
|
|
* memcg->cgwb_list. bdi->cgwb_tree is also RCU protected.
|
|
*/
|
|
static DEFINE_SPINLOCK(cgwb_lock);
|
|
static struct workqueue_struct *cgwb_release_wq;
|
|
|
|
static LIST_HEAD(offline_cgwbs);
|
|
static void cleanup_offline_cgwbs_workfn(struct work_struct *work);
|
|
static DECLARE_WORK(cleanup_offline_cgwbs_work, cleanup_offline_cgwbs_workfn);
|
|
|
|
static void cgwb_free_rcu(struct rcu_head *rcu_head)
|
|
{
|
|
struct bdi_writeback *wb = container_of(rcu_head,
|
|
struct bdi_writeback, rcu);
|
|
|
|
percpu_ref_exit(&wb->refcnt);
|
|
kfree(wb);
|
|
}
|
|
|
|
static void cgwb_release_workfn(struct work_struct *work)
|
|
{
|
|
struct bdi_writeback *wb = container_of(work, struct bdi_writeback,
|
|
release_work);
|
|
struct backing_dev_info *bdi = wb->bdi;
|
|
|
|
mutex_lock(&wb->bdi->cgwb_release_mutex);
|
|
wb_shutdown(wb);
|
|
|
|
css_put(wb->memcg_css);
|
|
css_put(wb->blkcg_css);
|
|
mutex_unlock(&wb->bdi->cgwb_release_mutex);
|
|
|
|
/* triggers blkg destruction if no online users left */
|
|
blkcg_unpin_online(wb->blkcg_css);
|
|
|
|
fprop_local_destroy_percpu(&wb->memcg_completions);
|
|
|
|
spin_lock_irq(&cgwb_lock);
|
|
list_del(&wb->offline_node);
|
|
spin_unlock_irq(&cgwb_lock);
|
|
|
|
wb_exit(wb);
|
|
bdi_put(bdi);
|
|
WARN_ON_ONCE(!list_empty(&wb->b_attached));
|
|
call_rcu(&wb->rcu, cgwb_free_rcu);
|
|
}
|
|
|
|
static void cgwb_release(struct percpu_ref *refcnt)
|
|
{
|
|
struct bdi_writeback *wb = container_of(refcnt, struct bdi_writeback,
|
|
refcnt);
|
|
queue_work(cgwb_release_wq, &wb->release_work);
|
|
}
|
|
|
|
static void cgwb_kill(struct bdi_writeback *wb)
|
|
{
|
|
lockdep_assert_held(&cgwb_lock);
|
|
|
|
WARN_ON(!radix_tree_delete(&wb->bdi->cgwb_tree, wb->memcg_css->id));
|
|
list_del(&wb->memcg_node);
|
|
list_del(&wb->blkcg_node);
|
|
list_add(&wb->offline_node, &offline_cgwbs);
|
|
percpu_ref_kill(&wb->refcnt);
|
|
}
|
|
|
|
static void cgwb_remove_from_bdi_list(struct bdi_writeback *wb)
|
|
{
|
|
spin_lock_irq(&cgwb_lock);
|
|
list_del_rcu(&wb->bdi_node);
|
|
spin_unlock_irq(&cgwb_lock);
|
|
}
|
|
|
|
static int cgwb_create(struct backing_dev_info *bdi,
|
|
struct cgroup_subsys_state *memcg_css, gfp_t gfp)
|
|
{
|
|
struct mem_cgroup *memcg;
|
|
struct cgroup_subsys_state *blkcg_css;
|
|
struct list_head *memcg_cgwb_list, *blkcg_cgwb_list;
|
|
struct bdi_writeback *wb;
|
|
unsigned long flags;
|
|
int ret = 0;
|
|
|
|
memcg = mem_cgroup_from_css(memcg_css);
|
|
blkcg_css = cgroup_get_e_css(memcg_css->cgroup, &io_cgrp_subsys);
|
|
memcg_cgwb_list = &memcg->cgwb_list;
|
|
blkcg_cgwb_list = blkcg_get_cgwb_list(blkcg_css);
|
|
|
|
/* look up again under lock and discard on blkcg mismatch */
|
|
spin_lock_irqsave(&cgwb_lock, flags);
|
|
wb = radix_tree_lookup(&bdi->cgwb_tree, memcg_css->id);
|
|
if (wb && wb->blkcg_css != blkcg_css) {
|
|
cgwb_kill(wb);
|
|
wb = NULL;
|
|
}
|
|
spin_unlock_irqrestore(&cgwb_lock, flags);
|
|
if (wb)
|
|
goto out_put;
|
|
|
|
/* need to create a new one */
|
|
wb = kmalloc(sizeof(*wb), gfp);
|
|
if (!wb) {
|
|
ret = -ENOMEM;
|
|
goto out_put;
|
|
}
|
|
|
|
ret = wb_init(wb, bdi, gfp);
|
|
if (ret)
|
|
goto err_free;
|
|
|
|
ret = percpu_ref_init(&wb->refcnt, cgwb_release, 0, gfp);
|
|
if (ret)
|
|
goto err_wb_exit;
|
|
|
|
ret = fprop_local_init_percpu(&wb->memcg_completions, gfp);
|
|
if (ret)
|
|
goto err_ref_exit;
|
|
|
|
wb->memcg_css = memcg_css;
|
|
wb->blkcg_css = blkcg_css;
|
|
INIT_LIST_HEAD(&wb->b_attached);
|
|
INIT_WORK(&wb->release_work, cgwb_release_workfn);
|
|
set_bit(WB_registered, &wb->state);
|
|
bdi_get(bdi);
|
|
|
|
/*
|
|
* The root wb determines the registered state of the whole bdi and
|
|
* memcg_cgwb_list and blkcg_cgwb_list's next pointers indicate
|
|
* whether they're still online. Don't link @wb if any is dead.
|
|
* See wb_memcg_offline() and wb_blkcg_offline().
|
|
*/
|
|
ret = -ENODEV;
|
|
spin_lock_irqsave(&cgwb_lock, flags);
|
|
if (test_bit(WB_registered, &bdi->wb.state) &&
|
|
blkcg_cgwb_list->next && memcg_cgwb_list->next) {
|
|
/* we might have raced another instance of this function */
|
|
ret = radix_tree_insert(&bdi->cgwb_tree, memcg_css->id, wb);
|
|
if (!ret) {
|
|
list_add_tail_rcu(&wb->bdi_node, &bdi->wb_list);
|
|
list_add(&wb->memcg_node, memcg_cgwb_list);
|
|
list_add(&wb->blkcg_node, blkcg_cgwb_list);
|
|
blkcg_pin_online(blkcg_css);
|
|
css_get(memcg_css);
|
|
css_get(blkcg_css);
|
|
}
|
|
}
|
|
spin_unlock_irqrestore(&cgwb_lock, flags);
|
|
if (ret) {
|
|
if (ret == -EEXIST)
|
|
ret = 0;
|
|
goto err_fprop_exit;
|
|
}
|
|
goto out_put;
|
|
|
|
err_fprop_exit:
|
|
bdi_put(bdi);
|
|
fprop_local_destroy_percpu(&wb->memcg_completions);
|
|
err_ref_exit:
|
|
percpu_ref_exit(&wb->refcnt);
|
|
err_wb_exit:
|
|
wb_exit(wb);
|
|
err_free:
|
|
kfree(wb);
|
|
out_put:
|
|
css_put(blkcg_css);
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* wb_get_lookup - get wb for a given memcg
|
|
* @bdi: target bdi
|
|
* @memcg_css: cgroup_subsys_state of the target memcg (must have positive ref)
|
|
*
|
|
* Try to get the wb for @memcg_css on @bdi. The returned wb has its
|
|
* refcount incremented.
|
|
*
|
|
* This function uses css_get() on @memcg_css and thus expects its refcnt
|
|
* to be positive on invocation. IOW, rcu_read_lock() protection on
|
|
* @memcg_css isn't enough. try_get it before calling this function.
|
|
*
|
|
* A wb is keyed by its associated memcg. As blkcg implicitly enables
|
|
* memcg on the default hierarchy, memcg association is guaranteed to be
|
|
* more specific (equal or descendant to the associated blkcg) and thus can
|
|
* identify both the memcg and blkcg associations.
|
|
*
|
|
* Because the blkcg associated with a memcg may change as blkcg is enabled
|
|
* and disabled closer to root in the hierarchy, each wb keeps track of
|
|
* both the memcg and blkcg associated with it and verifies the blkcg on
|
|
* each lookup. On mismatch, the existing wb is discarded and a new one is
|
|
* created.
|
|
*/
|
|
struct bdi_writeback *wb_get_lookup(struct backing_dev_info *bdi,
|
|
struct cgroup_subsys_state *memcg_css)
|
|
{
|
|
struct bdi_writeback *wb;
|
|
|
|
if (!memcg_css->parent)
|
|
return &bdi->wb;
|
|
|
|
rcu_read_lock();
|
|
wb = radix_tree_lookup(&bdi->cgwb_tree, memcg_css->id);
|
|
if (wb) {
|
|
struct cgroup_subsys_state *blkcg_css;
|
|
|
|
/* see whether the blkcg association has changed */
|
|
blkcg_css = cgroup_get_e_css(memcg_css->cgroup, &io_cgrp_subsys);
|
|
if (unlikely(wb->blkcg_css != blkcg_css || !wb_tryget(wb)))
|
|
wb = NULL;
|
|
css_put(blkcg_css);
|
|
}
|
|
rcu_read_unlock();
|
|
|
|
return wb;
|
|
}
|
|
|
|
/**
|
|
* wb_get_create - get wb for a given memcg, create if necessary
|
|
* @bdi: target bdi
|
|
* @memcg_css: cgroup_subsys_state of the target memcg (must have positive ref)
|
|
* @gfp: allocation mask to use
|
|
*
|
|
* Try to get the wb for @memcg_css on @bdi. If it doesn't exist, try to
|
|
* create one. See wb_get_lookup() for more details.
|
|
*/
|
|
struct bdi_writeback *wb_get_create(struct backing_dev_info *bdi,
|
|
struct cgroup_subsys_state *memcg_css,
|
|
gfp_t gfp)
|
|
{
|
|
struct bdi_writeback *wb;
|
|
|
|
might_alloc(gfp);
|
|
|
|
if (!memcg_css->parent)
|
|
return &bdi->wb;
|
|
|
|
do {
|
|
wb = wb_get_lookup(bdi, memcg_css);
|
|
} while (!wb && !cgwb_create(bdi, memcg_css, gfp));
|
|
|
|
return wb;
|
|
}
|
|
|
|
static int cgwb_bdi_init(struct backing_dev_info *bdi)
|
|
{
|
|
int ret;
|
|
|
|
INIT_RADIX_TREE(&bdi->cgwb_tree, GFP_ATOMIC);
|
|
mutex_init(&bdi->cgwb_release_mutex);
|
|
init_rwsem(&bdi->wb_switch_rwsem);
|
|
|
|
ret = wb_init(&bdi->wb, bdi, GFP_KERNEL);
|
|
if (!ret) {
|
|
bdi->wb.memcg_css = &root_mem_cgroup->css;
|
|
bdi->wb.blkcg_css = blkcg_root_css;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
static void cgwb_bdi_unregister(struct backing_dev_info *bdi)
|
|
{
|
|
struct radix_tree_iter iter;
|
|
void **slot;
|
|
struct bdi_writeback *wb;
|
|
|
|
WARN_ON(test_bit(WB_registered, &bdi->wb.state));
|
|
|
|
spin_lock_irq(&cgwb_lock);
|
|
radix_tree_for_each_slot(slot, &bdi->cgwb_tree, &iter, 0)
|
|
cgwb_kill(*slot);
|
|
spin_unlock_irq(&cgwb_lock);
|
|
|
|
mutex_lock(&bdi->cgwb_release_mutex);
|
|
spin_lock_irq(&cgwb_lock);
|
|
while (!list_empty(&bdi->wb_list)) {
|
|
wb = list_first_entry(&bdi->wb_list, struct bdi_writeback,
|
|
bdi_node);
|
|
spin_unlock_irq(&cgwb_lock);
|
|
wb_shutdown(wb);
|
|
spin_lock_irq(&cgwb_lock);
|
|
}
|
|
spin_unlock_irq(&cgwb_lock);
|
|
mutex_unlock(&bdi->cgwb_release_mutex);
|
|
}
|
|
|
|
/*
|
|
* cleanup_offline_cgwbs_workfn - try to release dying cgwbs
|
|
*
|
|
* Try to release dying cgwbs by switching attached inodes to the nearest
|
|
* living ancestor's writeback. Processed wbs are placed at the end
|
|
* of the list to guarantee the forward progress.
|
|
*/
|
|
static void cleanup_offline_cgwbs_workfn(struct work_struct *work)
|
|
{
|
|
struct bdi_writeback *wb;
|
|
LIST_HEAD(processed);
|
|
|
|
spin_lock_irq(&cgwb_lock);
|
|
|
|
while (!list_empty(&offline_cgwbs)) {
|
|
wb = list_first_entry(&offline_cgwbs, struct bdi_writeback,
|
|
offline_node);
|
|
list_move(&wb->offline_node, &processed);
|
|
|
|
/*
|
|
* If wb is dirty, cleaning up the writeback by switching
|
|
* attached inodes will result in an effective removal of any
|
|
* bandwidth restrictions, which isn't the goal. Instead,
|
|
* it can be postponed until the next time, when all io
|
|
* will be likely completed. If in the meantime some inodes
|
|
* will get re-dirtied, they should be eventually switched to
|
|
* a new cgwb.
|
|
*/
|
|
if (wb_has_dirty_io(wb))
|
|
continue;
|
|
|
|
if (!wb_tryget(wb))
|
|
continue;
|
|
|
|
spin_unlock_irq(&cgwb_lock);
|
|
while (cleanup_offline_cgwb(wb))
|
|
cond_resched();
|
|
spin_lock_irq(&cgwb_lock);
|
|
|
|
wb_put(wb);
|
|
}
|
|
|
|
if (!list_empty(&processed))
|
|
list_splice_tail(&processed, &offline_cgwbs);
|
|
|
|
spin_unlock_irq(&cgwb_lock);
|
|
}
|
|
|
|
/**
|
|
* wb_memcg_offline - kill all wb's associated with a memcg being offlined
|
|
* @memcg: memcg being offlined
|
|
*
|
|
* Also prevents creation of any new wb's associated with @memcg.
|
|
*/
|
|
void wb_memcg_offline(struct mem_cgroup *memcg)
|
|
{
|
|
struct list_head *memcg_cgwb_list = &memcg->cgwb_list;
|
|
struct bdi_writeback *wb, *next;
|
|
|
|
spin_lock_irq(&cgwb_lock);
|
|
list_for_each_entry_safe(wb, next, memcg_cgwb_list, memcg_node)
|
|
cgwb_kill(wb);
|
|
memcg_cgwb_list->next = NULL; /* prevent new wb's */
|
|
spin_unlock_irq(&cgwb_lock);
|
|
|
|
queue_work(system_unbound_wq, &cleanup_offline_cgwbs_work);
|
|
}
|
|
|
|
/**
|
|
* wb_blkcg_offline - kill all wb's associated with a blkcg being offlined
|
|
* @css: blkcg being offlined
|
|
*
|
|
* Also prevents creation of any new wb's associated with @blkcg.
|
|
*/
|
|
void wb_blkcg_offline(struct cgroup_subsys_state *css)
|
|
{
|
|
struct bdi_writeback *wb, *next;
|
|
struct list_head *list = blkcg_get_cgwb_list(css);
|
|
|
|
spin_lock_irq(&cgwb_lock);
|
|
list_for_each_entry_safe(wb, next, list, blkcg_node)
|
|
cgwb_kill(wb);
|
|
list->next = NULL; /* prevent new wb's */
|
|
spin_unlock_irq(&cgwb_lock);
|
|
}
|
|
|
|
static void cgwb_bdi_register(struct backing_dev_info *bdi)
|
|
{
|
|
spin_lock_irq(&cgwb_lock);
|
|
list_add_tail_rcu(&bdi->wb.bdi_node, &bdi->wb_list);
|
|
spin_unlock_irq(&cgwb_lock);
|
|
}
|
|
|
|
static int __init cgwb_init(void)
|
|
{
|
|
/*
|
|
* There can be many concurrent release work items overwhelming
|
|
* system_wq. Put them in a separate wq and limit concurrency.
|
|
* There's no point in executing many of these in parallel.
|
|
*/
|
|
cgwb_release_wq = alloc_workqueue("cgwb_release", 0, 1);
|
|
if (!cgwb_release_wq)
|
|
return -ENOMEM;
|
|
|
|
return 0;
|
|
}
|
|
subsys_initcall(cgwb_init);
|
|
|
|
#else /* CONFIG_CGROUP_WRITEBACK */
|
|
|
|
static int cgwb_bdi_init(struct backing_dev_info *bdi)
|
|
{
|
|
return wb_init(&bdi->wb, bdi, GFP_KERNEL);
|
|
}
|
|
|
|
static void cgwb_bdi_unregister(struct backing_dev_info *bdi) { }
|
|
|
|
static void cgwb_bdi_register(struct backing_dev_info *bdi)
|
|
{
|
|
list_add_tail_rcu(&bdi->wb.bdi_node, &bdi->wb_list);
|
|
}
|
|
|
|
static void cgwb_remove_from_bdi_list(struct bdi_writeback *wb)
|
|
{
|
|
list_del_rcu(&wb->bdi_node);
|
|
}
|
|
|
|
#endif /* CONFIG_CGROUP_WRITEBACK */
|
|
|
|
int bdi_init(struct backing_dev_info *bdi)
|
|
{
|
|
bdi->dev = NULL;
|
|
|
|
kref_init(&bdi->refcnt);
|
|
bdi->min_ratio = 0;
|
|
bdi->max_ratio = 100 * BDI_RATIO_SCALE;
|
|
bdi->max_prop_frac = FPROP_FRAC_BASE;
|
|
INIT_LIST_HEAD(&bdi->bdi_list);
|
|
INIT_LIST_HEAD(&bdi->wb_list);
|
|
init_waitqueue_head(&bdi->wb_waitq);
|
|
|
|
return cgwb_bdi_init(bdi);
|
|
}
|
|
|
|
struct backing_dev_info *bdi_alloc(int node_id)
|
|
{
|
|
struct backing_dev_info *bdi;
|
|
|
|
bdi = kzalloc_node(sizeof(*bdi), GFP_KERNEL, node_id);
|
|
if (!bdi)
|
|
return NULL;
|
|
|
|
if (bdi_init(bdi)) {
|
|
kfree(bdi);
|
|
return NULL;
|
|
}
|
|
bdi->capabilities = BDI_CAP_WRITEBACK | BDI_CAP_WRITEBACK_ACCT;
|
|
bdi->ra_pages = VM_READAHEAD_PAGES;
|
|
bdi->io_pages = VM_READAHEAD_PAGES;
|
|
timer_setup(&bdi->laptop_mode_wb_timer, laptop_mode_timer_fn, 0);
|
|
return bdi;
|
|
}
|
|
EXPORT_SYMBOL(bdi_alloc);
|
|
|
|
static struct rb_node **bdi_lookup_rb_node(u64 id, struct rb_node **parentp)
|
|
{
|
|
struct rb_node **p = &bdi_tree.rb_node;
|
|
struct rb_node *parent = NULL;
|
|
struct backing_dev_info *bdi;
|
|
|
|
lockdep_assert_held(&bdi_lock);
|
|
|
|
while (*p) {
|
|
parent = *p;
|
|
bdi = rb_entry(parent, struct backing_dev_info, rb_node);
|
|
|
|
if (bdi->id > id)
|
|
p = &(*p)->rb_left;
|
|
else if (bdi->id < id)
|
|
p = &(*p)->rb_right;
|
|
else
|
|
break;
|
|
}
|
|
|
|
if (parentp)
|
|
*parentp = parent;
|
|
return p;
|
|
}
|
|
|
|
/**
|
|
* bdi_get_by_id - lookup and get bdi from its id
|
|
* @id: bdi id to lookup
|
|
*
|
|
* Find bdi matching @id and get it. Returns NULL if the matching bdi
|
|
* doesn't exist or is already unregistered.
|
|
*/
|
|
struct backing_dev_info *bdi_get_by_id(u64 id)
|
|
{
|
|
struct backing_dev_info *bdi = NULL;
|
|
struct rb_node **p;
|
|
|
|
spin_lock_bh(&bdi_lock);
|
|
p = bdi_lookup_rb_node(id, NULL);
|
|
if (*p) {
|
|
bdi = rb_entry(*p, struct backing_dev_info, rb_node);
|
|
bdi_get(bdi);
|
|
}
|
|
spin_unlock_bh(&bdi_lock);
|
|
|
|
return bdi;
|
|
}
|
|
|
|
int bdi_register_va(struct backing_dev_info *bdi, const char *fmt, va_list args)
|
|
{
|
|
struct device *dev;
|
|
struct rb_node *parent, **p;
|
|
|
|
if (bdi->dev) /* The driver needs to use separate queues per device */
|
|
return 0;
|
|
|
|
vsnprintf(bdi->dev_name, sizeof(bdi->dev_name), fmt, args);
|
|
dev = device_create(bdi_class, NULL, MKDEV(0, 0), bdi, bdi->dev_name);
|
|
if (IS_ERR(dev))
|
|
return PTR_ERR(dev);
|
|
|
|
cgwb_bdi_register(bdi);
|
|
bdi->dev = dev;
|
|
|
|
bdi_debug_register(bdi, dev_name(dev));
|
|
set_bit(WB_registered, &bdi->wb.state);
|
|
|
|
spin_lock_bh(&bdi_lock);
|
|
|
|
bdi->id = ++bdi_id_cursor;
|
|
|
|
p = bdi_lookup_rb_node(bdi->id, &parent);
|
|
rb_link_node(&bdi->rb_node, parent, p);
|
|
rb_insert_color(&bdi->rb_node, &bdi_tree);
|
|
|
|
list_add_tail_rcu(&bdi->bdi_list, &bdi_list);
|
|
|
|
spin_unlock_bh(&bdi_lock);
|
|
|
|
trace_writeback_bdi_register(bdi);
|
|
return 0;
|
|
}
|
|
|
|
int bdi_register(struct backing_dev_info *bdi, const char *fmt, ...)
|
|
{
|
|
va_list args;
|
|
int ret;
|
|
|
|
va_start(args, fmt);
|
|
ret = bdi_register_va(bdi, fmt, args);
|
|
va_end(args);
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(bdi_register);
|
|
|
|
void bdi_set_owner(struct backing_dev_info *bdi, struct device *owner)
|
|
{
|
|
WARN_ON_ONCE(bdi->owner);
|
|
bdi->owner = owner;
|
|
get_device(owner);
|
|
}
|
|
|
|
/*
|
|
* Remove bdi from bdi_list, and ensure that it is no longer visible
|
|
*/
|
|
static void bdi_remove_from_list(struct backing_dev_info *bdi)
|
|
{
|
|
spin_lock_bh(&bdi_lock);
|
|
rb_erase(&bdi->rb_node, &bdi_tree);
|
|
list_del_rcu(&bdi->bdi_list);
|
|
spin_unlock_bh(&bdi_lock);
|
|
|
|
synchronize_rcu_expedited();
|
|
}
|
|
|
|
void bdi_unregister(struct backing_dev_info *bdi)
|
|
{
|
|
del_timer_sync(&bdi->laptop_mode_wb_timer);
|
|
|
|
/* make sure nobody finds us on the bdi_list anymore */
|
|
bdi_remove_from_list(bdi);
|
|
wb_shutdown(&bdi->wb);
|
|
cgwb_bdi_unregister(bdi);
|
|
|
|
/*
|
|
* If this BDI's min ratio has been set, use bdi_set_min_ratio() to
|
|
* update the global bdi_min_ratio.
|
|
*/
|
|
if (bdi->min_ratio)
|
|
bdi_set_min_ratio(bdi, 0);
|
|
|
|
if (bdi->dev) {
|
|
bdi_debug_unregister(bdi);
|
|
device_unregister(bdi->dev);
|
|
bdi->dev = NULL;
|
|
}
|
|
|
|
if (bdi->owner) {
|
|
put_device(bdi->owner);
|
|
bdi->owner = NULL;
|
|
}
|
|
}
|
|
EXPORT_SYMBOL(bdi_unregister);
|
|
|
|
static void release_bdi(struct kref *ref)
|
|
{
|
|
struct backing_dev_info *bdi =
|
|
container_of(ref, struct backing_dev_info, refcnt);
|
|
|
|
WARN_ON_ONCE(test_bit(WB_registered, &bdi->wb.state));
|
|
WARN_ON_ONCE(bdi->dev);
|
|
wb_exit(&bdi->wb);
|
|
kfree(bdi);
|
|
}
|
|
|
|
void bdi_put(struct backing_dev_info *bdi)
|
|
{
|
|
kref_put(&bdi->refcnt, release_bdi);
|
|
}
|
|
EXPORT_SYMBOL(bdi_put);
|
|
|
|
struct backing_dev_info *inode_to_bdi(struct inode *inode)
|
|
{
|
|
struct super_block *sb;
|
|
|
|
if (!inode)
|
|
return &noop_backing_dev_info;
|
|
|
|
sb = inode->i_sb;
|
|
#ifdef CONFIG_BLOCK
|
|
if (sb_is_blkdev_sb(sb))
|
|
return I_BDEV(inode)->bd_disk->bdi;
|
|
#endif
|
|
return sb->s_bdi;
|
|
}
|
|
EXPORT_SYMBOL(inode_to_bdi);
|
|
|
|
const char *bdi_dev_name(struct backing_dev_info *bdi)
|
|
{
|
|
if (!bdi || !bdi->dev)
|
|
return bdi_unknown_name;
|
|
return bdi->dev_name;
|
|
}
|
|
EXPORT_SYMBOL_GPL(bdi_dev_name);
|