Release 4.8 mm/backing-dev.c

Directory: mm
#include <linux/wait.h>
#include <linux/backing-dev.h>
#include <linux/kthread.h>
#include <linux/freezer.h>
#include <linux/fs.h>
#include <linux/pagemap.h>
#include <linux/mm.h>
#include <linux/sched.h>
#include <linux/module.h>
#include <linux/writeback.h>
#include <linux/device.h>
#include <trace/events/writeback.h>


static atomic_long_t bdi_seq = ATOMIC_LONG_INIT(0);


struct backing_dev_info noop_backing_dev_info = {
	.name		= "noop",
	.capabilities	= BDI_CAP_NO_ACCT_AND_WRITEBACK,
};

EXPORT_SYMBOL_GPL(noop_backing_dev_info);


static struct class *bdi_class;

/*
 * bdi_lock protects updates to bdi_list. bdi_list has RCU reader side
 * locking.
 */

DEFINE_SPINLOCK(bdi_lock);

LIST_HEAD(bdi_list);

/* bdi_wq serves all asynchronous writeback tasks */

struct workqueue_struct *bdi_wq;

#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);
}

Contributors
Person Tokens Prop Commits CommitProp
miklos szeredi miklos szeredi 17 100.00% 1 100.00%
Total 17 100.00% 1 100.00%



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);


#define K(x) ((x) << (PAGE_SHIFT - 10))
	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);

#undef K

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
miklos szeredi miklos szeredi 95 32.20% 1 6.67%
jens axboe jens axboe 85 28.81% 1 6.67%
fengguang wu fengguang wu 41 13.90% 3 20.00%
theodore tso theodore tso 25 8.47% 1 6.67%
tejun heo tejun heo 20 6.78% 4 26.67%
christoph hellwig christoph hellwig 11 3.73% 2 13.33%
jan kara jan kara 11 3.73% 1 6.67%
dave chinner dave chinner 4 1.36% 1 6.67%
david rientjes david rientjes 3 1.02% 1 6.67%
Total 295 100.00% 15 100.00%



static int bdi_debug_stats_open(struct inode *inode, struct file *file)
{
	return single_open(file, bdi_debug_stats_show, inode->i_private);
}

Contributors
Person Tokens Prop Commits CommitProp
miklos szeredi miklos szeredi 28 100.00% 1 100.00%
Total 28 100.00% 1 100.00%


static const struct file_operations bdi_debug_stats_fops = {
	.open		= bdi_debug_stats_open,
	.read		= seq_read,
	.llseek		= seq_lseek,
	.release	= single_release,
};



static void bdi_debug_register(struct backing_dev_info *bdi, const char *name)
{
	bdi->debug_dir = debugfs_create_dir(name, bdi_debug_root);
	bdi->debug_stats = debugfs_create_file("stats", 0444, bdi->debug_dir,
					       bdi, &bdi_debug_stats_fops);
}

Contributors
Person Tokens Prop Commits CommitProp
miklos szeredi miklos szeredi 47 100.00% 1 100.00%
Total 47 100.00% 1 100.00%



static void bdi_debug_unregister(struct backing_dev_info *bdi)
{
	debugfs_remove(bdi->debug_stats);
	debugfs_remove(bdi->debug_dir);
}
Contributors
Person Tokens Prop Commits CommitProp
miklos szeredi miklos szeredi 25 100.00% 1 100.00%
Total 25 100.00% 1 100.00%

#else


static inline void bdi_debug_init(void)
{
}
Contributors
Person Tokens Prop Commits CommitProp
miklos szeredi miklos szeredi 8 100.00% 1 100.00%
Total 8 100.00% 1 100.00%



static inline void bdi_debug_register(struct backing_dev_info *bdi,
				      const char *name)
{
}
Contributors
Person Tokens Prop Commits CommitProp
miklos szeredi miklos szeredi 16 100.00% 1 100.00%
Total 16 100.00% 1 100.00%



static inline void bdi_debug_unregister(struct backing_dev_info *bdi)
{
}
Contributors
Person Tokens Prop Commits CommitProp
miklos szeredi miklos szeredi 11 100.00% 1 100.00%
Total 11 100.00% 1 100.00%

#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;
}

Contributors
Person Tokens Prop Commits CommitProp
peter zijlstra peter zijlstra 66 85.71% 1 50.00%
namjae jeon namjae jeon 11 14.29% 1 50.00%
Total 77 100.00% 2 100.00%


#define K(pages) ((pages) << (PAGE_SHIFT - 10))


#define BDI_SHOW(name, expr)						\
static ssize_t name##_show(struct device *dev,                          \
                           struct device_attribute *attr, char *page)   \
{                                                                       \
        struct backing_dev_info *bdi = dev_get_drvdata(dev);            \
                                                                        \
        return snprintf(page, PAGE_SIZE-1, "%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;
}
Contributors
Person Tokens Prop Commits CommitProp
peter zijlstra peter zijlstra 73 87.95% 1 50.00%
namjae jeon namjae jeon 10 12.05% 1 50.00%
Total 83 100.00% 2 100.00%

BDI_SHOW(min_ratio, 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;
}
Contributors
Person Tokens Prop Commits CommitProp
peter zijlstra peter zijlstra 73 87.95% 1 50.00%
namjae jeon namjae jeon 10 12.05% 1 50.00%
Total 83 100.00% 2 100.00%

BDI_SHOW(max_ratio, bdi->max_ratio)



static ssize_t stable_pages_required_show(struct device *dev,
					  struct device_attribute *attr,
					  char *page)
{
	struct backing_dev_info *bdi = dev_get_drvdata(dev);

	return snprintf(page, PAGE_SIZE-1, "%d\n",
			bdi_cap_stable_pages_required(bdi) ? 1 : 0);
}
Contributors
Person Tokens Prop Commits CommitProp
darrick j. wong darrick j. wong 51 100.00% 1 100.00%
Total 51 100.00% 1 100.00%

static DEVICE_ATTR_RO(stable_pages_required);


static struct attribute *bdi_dev_attrs[] = {
	&dev_attr_read_ahead_kb.attr,
	&dev_attr_min_ratio.attr,
	&dev_attr_max_ratio.attr,
	&dev_attr_stable_pages_required.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;
}
Contributors
Person Tokens Prop Commits CommitProp
peter zijlstra peter zijlstra 25 58.14% 1 25.00%
anton blanchard anton blanchard 13 30.23% 1 25.00%
miklos szeredi miklos szeredi 3 6.98% 1 25.00%
greg kroah-hartman greg kroah-hartman 2 4.65% 1 25.00%
Total 43 100.00% 4 100.00%


postcore_initcall(bdi_class_init);



static int __init default_bdi_init(void)
{
	int err;

	bdi_wq = alloc_workqueue("writeback", WQ_MEM_RECLAIM | WQ_FREEZABLE |
					      WQ_UNBOUND | WQ_SYSFS, 0);
	if (!bdi_wq)
		return -ENOMEM;

	err = bdi_init(&noop_backing_dev_info);

	return err;
}
Contributors
Person Tokens Prop Commits CommitProp
tejun heo tejun heo 26 53.06% 2 50.00%
jens axboe jens axboe 20 40.82% 1 25.00%
jan kara jan kara 3 6.12% 1 25.00%
Total 49 100.00% 4 100.00%


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_bh(&wb->work_lock);
	if (test_bit(WB_registered, &wb->state))
		queue_delayed_work(bdi_wq, &wb->dwork, timeout);
	spin_unlock_bh(&wb->work_lock);
}

Contributors
Person Tokens Prop Commits CommitProp
artem bityutskiy artem bityutskiy 27 42.86% 1 16.67%
jan kara jan kara 22 34.92% 1 16.67%
tejun heo tejun heo 13 20.63% 3 50.00%
derek basehore derek basehore 1 1.59% 1 16.67%
Total 63 100.00% 6 100.00%

/*
 * 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,
		   int blkcg_id, 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);

	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);

	wb->congested = wb_congested_get_create(bdi, blkcg_id, gfp);
	if (!wb->congested)
		return -ENOMEM;

	err = fprop_local_init_percpu(&wb->completions, gfp);
	if (err)
		goto out_put_cong;

	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);
out_put_cong:
	wb_congested_put(wb->congested);
	return err;
}

Contributors
Person Tokens Prop Commits CommitProp
tejun heo tejun heo 197 72.69% 5 41.67%
jens axboe jens axboe 27 9.96% 2 16.67%
artem bityutskiy artem bityutskiy 25 9.23% 1 8.33%
peter zijlstra peter zijlstra 13 4.80% 1 8.33%
david chinner david chinner 4 1.48% 1 8.33%
jan kara jan kara 4 1.48% 1 8.33%
rasmus villemoes rasmus villemoes 1 0.37% 1 8.33%
Total 271 100.00% 12 100.00%

/*
 * 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_bh(&wb->work_lock);
	if (!test_and_clear_bit(WB_registered, &wb->state)) {
		spin_unlock_bh(&wb->work_lock);
		return;
	}
	spin_unlock_bh(&wb->work_lock);

	/*
         * 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));
}

Contributors
Person Tokens Prop Commits CommitProp
tejun heo tejun heo 35 41.18% 3 33.33%
jan kara jan kara 18 21.18% 1 11.11%
christoph hellwig christoph hellwig 16 18.82% 2 22.22%
jens axboe jens axboe 13 15.29% 2 22.22%
rabin vincent rabin vincent 3 3.53% 1 11.11%
Total 85 100.00% 9 100.00%



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);
	wb_congested_put(wb->congested);
}

Contributors
Person Tokens Prop Commits CommitProp
tejun heo tejun heo 57 89.06% 2 66.67%
artem bityutskiy artem bityutskiy 7 10.94% 1 33.33%
Total 64 100.00% 3 100.00%

#ifdef CONFIG_CGROUP_WRITEBACK

#include <linux/memcontrol.h>

/*
 * cgwb_lock protects bdi->cgwb_tree, bdi->cgwb_congested_tree,
 * blkcg->cgwb_list, and memcg->cgwb_list.  bdi->cgwb_tree is also RCU
 * protected.  cgwb_release_wait is used to wait for the completion of cgwb
 * releases from bdi destruction path.
 */
static DEFINE_SPINLOCK(cgwb_lock);
static DECLARE_WAIT_QUEUE_HEAD(cgwb_release_wait);

/**
 * wb_congested_get_create - get or create a wb_congested
 * @bdi: associated bdi
 * @blkcg_id: ID of the associated blkcg
 * @gfp: allocation mask
 *
 * Look up the wb_congested for @blkcg_id on @bdi.  If missing, create one.
 * The returned wb_congested has its reference count incremented.  Returns
 * NULL on failure.
 */

struct bdi_writeback_congested *

wb_congested_get_create(struct backing_dev_info *bdi, int blkcg_id, gfp_t gfp)
{
	struct bdi_writeback_congested *new_congested = NULL, *congested;
	struct rb_node **node, *parent;
	unsigned long flags;
retry:
	spin_lock_irqsave(&cgwb_lock, flags);

	node = &bdi->cgwb_congested_tree.rb_node;
	parent = NULL;

	while (*node != NULL) {
		parent = *node;
		congested = container_of(parent, struct bdi_writeback_congested,
					 rb_node);
		if (congested->blkcg_id < blkcg_id)
			node = &parent->rb_left;
		else if (congested->blkcg_id > blkcg_id)
			node = &parent->rb_right;
		else
			goto found;
	}

	if (new_congested) {
		/* !found and storage for new one already allocated, insert */
		congested = new_congested;
		new_congested = NULL;
		rb_link_node(&congested->rb_node, parent, node);
		rb_insert_color(&congested->rb_node, &bdi->cgwb_congested_tree);
		goto found;
	}

	spin_unlock_irqrestore(&cgwb_lock, flags);

	/* allocate storage for new one and retry */
	new_congested = kzalloc(sizeof(*new_congested), gfp);
	if (!new_congested)
		return NULL;

	atomic_set(&new_congested->refcnt, 0);
	new_congested->bdi = bdi;
	new_congested->blkcg_id = blkcg_id;
	goto retry;

found:
	atomic_inc(&congested->refcnt);
	spin_unlock_irqrestore(&cgwb_lock, flags);
	kfree(new_congested);
	return congested;
}

Contributors
Person Tokens Prop Commits CommitProp
tejun heo tejun heo 249 100.00% 1 100.00%
Total 249 100.00% 1 100.00%

/**
 * wb_congested_put - put a wb_congested
 * @congested: wb_congested to put
 *
 * Put @congested and destroy it if the refcnt reaches zero.
 */


void wb_congested_put(struct bdi_writeback_congested *congested)
{
	unsigned long flags;

	local_irq_save(flags);
	if (!atomic_dec_and_lock(&congested->refcnt, &cgwb_lock)) {
		local_irq_restore(flags);
		return;
	}

	/* bdi might already have been destroyed leaving @congested unlinked */
	if (congested->bdi) {
		rb_erase(&congested->rb_node,
			 &congested->bdi->cgwb_congested_tree);
		congested->bdi = NULL;
	}

	spin_unlock_irqrestore(&cgwb_lock, flags);
	kfree(congested);
}

Contributors
Person Tokens Prop Commits CommitProp
tejun heo tejun heo 84 100.00% 2 100.00%
Total 84 100.00% 2 100.00%



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;

	spin_lock_irq(&cgwb_lock);
	list_del_rcu(&wb->bdi_node);
	spin_unlock_irq(&cgwb_lock);

	wb_shutdown(wb);

	css_put(wb->memcg_css);
	css_put(wb->blkcg_css);

	fprop_local_destroy_percpu(&wb->memcg_completions);
	percpu_ref_exit(&wb->refcnt);
	wb_exit(wb);
	kfree_rcu(wb, rcu);

	if (atomic_dec_and_test(&bdi->usage_cnt))
		wake_up_all(&cgwb_release_wait);
}

Contributors
Person Tokens Prop Commits CommitProp
tejun heo tejun heo 118 100.00% 3 100.00%
Total 118 100.00% 3 100.00%



static void cgwb_release(struct percpu_ref *refcnt)
{
	struct bdi_writeback *wb = container_of(refcnt, struct bdi_writeback,
						refcnt);
	schedule_work(&wb->release_work);
}

Contributors
Person Tokens Prop Commits CommitProp
tejun heo tejun heo 34 100.00% 1 100.00%
Total 34 100.00% 1 100.00%



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);
	percpu_ref_kill(&wb->refcnt);
}

Contributors
Person Tokens Prop Commits CommitProp
tejun heo tejun heo 61 100.00% 1 100.00%
Total 61 100.00% 1 100.00%



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 blkcg *blkcg;
	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);
	blkcg = css_to_blkcg(blkcg_css);
	memcg_cgwb_list = mem_cgroup_cgwb_list(memcg);
	blkcg_cgwb_list = &blkcg->cgwb_list;

	/* 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)
		return -ENOMEM;

	ret = wb_init(wb, bdi, blkcg_css->id, 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_WORK(&wb->release_work, cgwb_release_workfn);
	set_bit(WB_registered, &wb->state);

	/*
         * 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) {
			atomic_inc(&bdi->usage_cnt);
			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);
			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:
	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;
}

Contributors
Person Tokens Prop Commits CommitProp
tejun heo tejun heo 462 100.00% 5 100.00%
Total 462 100.00% 5 100.00%

/**
 * 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.  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_create(struct backing_dev_info *bdi,
				    struct cgroup_subsys_state *memcg_css,
				    gfp_t gfp)
{
	struct bdi_writeback *wb;

	might_sleep_if(gfpflags_allow_blocking(gfp));

	if (!memcg_css->parent)
		return &bdi->wb;

	do {
		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();
	} while (!wb && !cgwb_create(bdi, memcg_css, gfp));

	return wb;
}

Contributors
Person Tokens Prop Commits CommitProp
tejun heo tejun heo 135 97.83% 2 66.67%
mel gorman mel gorman 3 2.17% 1 33.33%
Total 138 100.00% 3 100.00%



static int cgwb_bdi_init(struct backing_dev_info *bdi)
{
	int ret;

	INIT_RADIX_TREE(&bdi->cgwb_tree, GFP_ATOMIC);
	bdi->cgwb_congested_tree = RB_ROOT;
	atomic_set(&bdi->usage_cnt, 1);

	ret = wb_init(&bdi->wb, bdi, 1, GFP_KERNEL);
	if (!ret) {
		bdi->wb.memcg_css = &root_mem_cgroup->css;
		bdi->wb.blkcg_css = blkcg_root_css;
	}
	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
tejun heo tejun heo 81 95.29% 2 66.67%
johannes weiner johannes weiner 4 4.71% 1 33.33%
Total 85 100.00% 3 100.00%



static void cgwb_bdi_destroy(struct backing_dev_info *bdi)
{
	struct radix_tree_iter iter;
	struct rb_node *rbn;
	void **slot;

	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);

	while ((rbn = rb_first(&bdi->cgwb_congested_tree))) {
		struct bdi_writeback_congested *congested =
			rb_entry(rbn, struct bdi_writeback_congested, rb_node);

		rb_erase(rbn, &bdi->cgwb_congested_tree);
		congested->bdi = NULL;	/* mark @congested unlinked */
	}

	spin_unlock_irq(&cgwb_lock);

	/*
         * All cgwb's and their congested states must be shutdown and
         * released before returning.  Drain the usage counter to wait for
         * all cgwb's and cgwb_congested's ever created on @bdi.
         */
	atomic_dec(&bdi->usage_cnt);
	wait_event(cgwb_release_wait, !atomic_read(&bdi->usage_cnt));
}

Contributors
Person Tokens Prop Commits CommitProp
tejun heo tejun heo 139 100.00% 3 100.00%
Total 139 100.00% 3 100.00%

/**
 * 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)
{
	LIST_HEAD(to_destroy);
	struct list_head *memcg_cgwb_list = mem_cgroup_cgwb_list(memcg);
	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);
}

Contributors
Person Tokens Prop Commits CommitProp
tejun heo tejun heo 52 77.61% 1 50.00%
artem bityutskiy artem bityutskiy 15 22.39% 1 50.00%
Total 67 100.00% 2 100.00%

/**
 * wb_blkcg_offline - kill all wb's associated with a blkcg being offlined
 * @blkcg: blkcg being offlined
 *
 * Also prevents creation of any new wb's associated with @blkcg.
 */


void wb_blkcg_offline(struct blkcg *blkcg)
{
	LIST_HEAD(to_destroy);
	struct bdi_writeback *wb, *next;

	spin_lock_irq(&cgwb_lock);
	list_for_each_entry_safe(wb, next, &blkcg->cgwb_list, blkcg_node)
		cgwb_kill(wb);
	blkcg->cgwb_list.next = NULL;	/* prevent new wb's */
	spin_unlock_irq(&cgwb_lock);
}

Contributors
Person Tokens Prop Commits CommitProp
tejun heo tejun heo 41 69.49% 1 25.00%
artem bityutskiy artem bityutskiy 12 20.34% 1 25.00%
christoph hellwig christoph hellwig 4 6.78% 1 25.00%
theodore tso theodore tso 2 3.39% 1 25.00%
Total 59 100.00% 4 100.00%

#else	/* CONFIG_CGROUP_WRITEBACK */



static int cgwb_bdi_init(struct backing_dev_info *bdi)
{
	int err;

	bdi->wb_congested = kzalloc(sizeof(*bdi->wb_congested), GFP_KERNEL);
	if (!bdi->wb_congested)
		return -ENOMEM;

	err = wb_init(&bdi->wb, bdi, 1, GFP_KERNEL);
	if (err) {
		kfree(bdi->wb_congested);
		return err;
	}
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
tejun heo tejun heo 77 100.00% 2 100.00%
Total 77 100.00% 2 100.00%



static void cgwb_bdi_destroy(struct backing_dev_info *bdi) { }

Contributors
Person Tokens Prop Commits CommitProp
tejun heo tejun heo 10 100.00% 1 100.00%
Total 10 100.00% 1 100.00%

#endif	/* CONFIG_CGROUP_WRITEBACK */



int bdi_init(struct backing_dev_info *bdi)
{
	int ret;

	bdi->dev = NULL;

	bdi->min_ratio = 0;
	bdi->max_ratio = 100;
	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);

	ret = cgwb_bdi_init(bdi);

	list_add_tail_rcu(&bdi->wb.bdi_node, &bdi->wb_list);

	return ret;
}
Contributors
Person Tokens Prop Commits CommitProp
tejun heo tejun heo 38 44.19% 4 40.00%
peter zijlstra peter zijlstra 33 38.37% 4 40.00%
jens axboe jens axboe 14 16.28% 1 10.00%
jan kara jan kara 1 1.16% 1 10.00%
Total 86 100.00% 10 100.00%


EXPORT_SYMBOL(bdi_init);



int bdi_register(struct backing_dev_info *bdi, struct device *parent,
		const char *fmt, ...)
{
	va_list args;
	struct device *dev;

	if (bdi->dev)	/* The driver needs to use separate queues per device */
		return 0;

	va_start(args, fmt);
	dev = device_create_vargs(bdi_class, parent, MKDEV(0, 0), bdi, fmt, args);
	va_end(args);
	if (IS_ERR(dev))
		return PTR_ERR(dev);

	bdi->dev = dev;

	bdi_debug_register(bdi, dev_name(dev));
	set_bit(WB_registered, &bdi->wb.state);

	spin_lock_bh(&bdi_lock);
	list_add_tail_rcu(&bdi->bdi_list, &bdi_list);
	spin_unlock_bh(&bdi_lock);

	trace_writeback_bdi_register(bdi);
	return 0;
}
Contributors
Person Tokens Prop Commits CommitProp
tejun heo tejun heo 93 63.70% 6 42.86%
peter zijlstra peter zijlstra 21 14.38% 2 14.29%
artem bityutskiy artem bityutskiy 18 12.33% 1 7.14%
fengguang wu fengguang wu 10 6.85% 3 21.43%
theodore tso theodore tso 2 1.37% 1 7.14%
christoph hellwig christoph hellwig 2 1.37% 1 7.14%
Total 146 100.00% 14 100.00%


EXPORT_SYMBOL(bdi_register);



int bdi_register_dev(struct backing_dev_info *bdi, dev_t dev)
{
	return bdi_register(bdi, NULL, "%u:%u", MAJOR(dev), MINOR(dev));
}
Contributors
Person Tokens Prop Commits CommitProp
tejun heo tejun heo 22 66.67% 2 33.33%
peter zijlstra peter zijlstra 7 21.21% 1 16.67%
neil brown neil brown 2 6.06% 1 16.67%
christoph hellwig christoph hellwig 1 3.03% 1 16.67%
jens axboe jens axboe 1 3.03% 1 16.67%
Total 33 100.00% 6 100.00%


EXPORT_SYMBOL(bdi_register_dev);



int bdi_register_owner(struct backing_dev_info *bdi, struct device *owner)
{
	int rc;

	rc = bdi_register(bdi, NULL, "%u:%u", MAJOR(owner->devt),
			MINOR(owner->devt));
	if (rc)
		return rc;
	bdi->owner = owner;
	get_device(owner);
	return 0;
}
Contributors
Person Tokens Prop Commits CommitProp
dan williams dan williams 64 100.00% 1 100.00%
Total 64 100.00% 1 100.00%


EXPORT_SYMBOL(bdi_register_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);
	list_del_rcu(&bdi->bdi_list);
	spin_unlock_bh(&bdi_lock);

	synchronize_rcu_expedited();
}

Contributors
Person Tokens Prop Commits CommitProp
tejun heo tejun heo 25 73.53% 3 50.00%
jens axboe jens axboe 7 20.59% 1 16.67%
christoph hellwig christoph hellwig 1 2.94% 1 16.67%
artem bityutskiy artem bityutskiy 1 2.94% 1 16.67%
Total 34 100.00% 6 100.00%



void bdi_unregister(struct backing_dev_info *bdi)
{
	/* make sure nobody finds us on the bdi_list anymore */
	bdi_remove_from_list(bdi);
	wb_shutdown(&bdi->wb);
	cgwb_bdi_destroy(bdi);

	if (bdi->dev) {
		bdi_debug_unregister(bdi);
		device_unregister(bdi->dev);
		bdi->dev = NULL;
	}

	if (bdi->owner) {
		put_device(bdi->owner);
		bdi->owner = NULL;
	}
}

Contributors
Person Tokens Prop Commits CommitProp
dan williams dan williams 21 27.63% 1 10.00%
christoph hellwig christoph hellwig 20 26.32% 2 20.00%
peter zijlstra peter zijlstra 12 15.79% 2 20.00%
jens axboe jens axboe 12 15.79% 1 10.00%
tejun heo tejun heo 8 10.53% 3 30.00%
rabin vincent rabin vincent 3 3.95% 1 10.00%
Total 76 100.00% 10 100.00%



void bdi_exit(struct backing_dev_info *bdi)
{
	WARN_ON_ONCE(bdi->dev);
	wb_exit(&bdi->wb);
}

Contributors
Person Tokens Prop Commits CommitProp
tejun heo tejun heo 18 72.00% 3 60.00%
peter zijlstra peter zijlstra 7 28.00% 2 40.00%
Total 25 100.00% 5 100.00%



void bdi_destroy(struct backing_dev_info *bdi)
{
	bdi_unregister(bdi);
	bdi_exit(bdi);
}
Contributors
Person Tokens Prop Commits CommitProp
tejun heo tejun heo 20 100.00% 1 100.00%
Total 20 100.00% 1 100.00%


EXPORT_SYMBOL(bdi_destroy);

/*
 * For use from filesystems to quickly init and register a bdi associated
 * with dirty writeback
 */


int bdi_setup_and_register(struct backing_dev_info *bdi, char *name)
{
	int err;

	bdi->name = name;
	bdi->capabilities = 0;
	err = bdi_init(bdi);
	if (err)
		return err;

	err = bdi_register(bdi, NULL, "%.28s-%ld", name,
			   atomic_long_inc_return(&bdi_seq));
	if (err) {
		bdi_destroy(bdi);
		return err;
	}

	return 0;
}
Contributors
Person Tokens Prop Commits CommitProp
jens axboe jens axboe 75 94.94% 1 33.33%
kees cook kees cook 3 3.80% 1 33.33%
christoph hellwig christoph hellwig 1 1.27% 1 33.33%
Total 79 100.00% 3 100.00%


EXPORT_SYMBOL(bdi_setup_and_register);


static wait_queue_head_t congestion_wqh[2] = {
		__WAIT_QUEUE_HEAD_INITIALIZER(congestion_wqh[0]),
		__WAIT_QUEUE_HEAD_INITIALIZER(congestion_wqh[1])
	};

static atomic_t nr_wb_congested[2];



void clear_wb_congested(struct bdi_writeback_congested *congested, int sync)
{
	wait_queue_head_t *wqh = &congestion_wqh[sync];
	enum wb_congested_state bit;

	bit = sync ? WB_sync_congested : WB_async_congested;
	if (test_and_clear_bit(bit, &congested->state))
		atomic_dec(&nr_wb_congested[sync]);
	smp_mb__after_atomic();
	if (waitqueue_active(wqh))
		wake_up(wqh);
}
Contributors
Person Tokens Prop Commits CommitProp
andrew morton andrew morton 45 63.38% 1 12.50%
mel gorman mel gorman 11 15.49% 1 12.50%
tejun heo tejun heo 10 14.08% 3 37.50%
jens axboe jens axboe 3 4.23% 1 12.50%
xia kaixu xia kaixu 1 1.41% 1 12.50%
peter zijlstra peter zijlstra 1 1.41% 1 12.50%
Total 71 100.00% 8 100.00%


EXPORT_SYMBOL(clear_wb_congested);



void set_wb_congested(struct bdi_writeback_congested *congested, int sync)
{
	enum wb_congested_state bit;

	bit = sync ? WB_sync_congested : WB_async_congested;
	if (!test_and_set_bit(bit, &congested->state))
		atomic_inc(&nr_wb_congested[sync]);
}
Contributors
Person Tokens Prop Commits CommitProp
andrew morton andrew morton 25 53.19% 1 14.29%
mel gorman mel gorman 12 25.53% 1 14.29%
tejun heo tejun heo 7 14.89% 3 42.86%
jens axboe jens axboe 2 4.26% 1 14.29%
xia kaixu xia kaixu 1 2.13% 1 14.29%
Total 47 100.00% 7 100.00%


EXPORT_SYMBOL(set_wb_congested);

/**
 * congestion_wait - wait for a backing_dev to become uncongested
 * @sync: SYNC or ASYNC IO
 * @timeout: timeout in jiffies
 *
 * Waits for up to @timeout jiffies for a backing_dev (any backing_dev) to exit
 * write congestion.  If no backing_devs are congested then just wait for the
 * next write to be completed.
 */


long congestion_wait(int sync, long timeout)
{
	long ret;
	unsigned long start = jiffies;
	DEFINE_WAIT(wait);
	wait_queue_head_t *wqh = &congestion_wqh[sync];

	prepare_to_wait(wqh, &wait, TASK_UNINTERRUPTIBLE);
	ret = io_schedule_timeout(timeout);
	finish_wait(wqh, &wait);

	trace_writeback_congestion_wait(jiffies_to_usecs(timeout),
					jiffies_to_usecs(jiffies - start));

	return ret;
}
Contributors
Person Tokens Prop Commits CommitProp
andrew morton andrew morton 55 70.51% 1 33.33%
mel gorman mel gorman 21 26.92% 1 33.33%
jens axboe jens axboe 2 2.56% 1 33.33%
Total 78 100.00% 3 100.00%


EXPORT_SYMBOL(congestion_wait);

/**
 * wait_iff_congested - Conditionally wait for a backing_dev to become uncongested or a pgdat to complete writes
 * @pgdat: A pgdat to check if it is heavily congested
 * @sync: SYNC or ASYNC IO
 * @timeout: timeout in jiffies
 *
 * In the event of a congested backing_dev (any backing_dev) and the given
 * @pgdat has experienced recent congestion, this waits for up to @timeout
 * jiffies for either a BDI to exit congestion of the given @sync queue
 * or a write to complete.
 *
 * In the absence of pgdat congestion, cond_resched() is called to yield
 * the processor if necessary but otherwise does not sleep.
 *
 * The return value is 0 if the sleep is for the full timeout. Otherwise,
 * it is the number of jiffies that were still remaining when the function
 * returned. return_value == timeout implies the function did not sleep.
 */


long wait_iff_congested(struct pglist_data *pgdat, int sync, long timeout)
{
	long ret;
	unsigned long start = jiffies;
	DEFINE_WAIT(wait);
	wait_queue_head_t *wqh = &congestion_wqh[sync];

	/*
         * If there is no congestion, or heavy congestion is not being
         * encountered in the current pgdat, yield if necessary instead
         * of sleeping on the congestion queue
         */
	if (atomic_read(&nr_wb_congested[sync]) == 0 ||
	    !test_bit(PGDAT_CONGESTED, &pgdat->flags)) {
		cond_resched();

		/* In case we scheduled, work out time remaining */
		ret = timeout - (jiffies - start);
		if (ret < 0)
			ret = 0;

		goto out;
	}

	/* Sleep until uncongested or a write happens */
	prepare_to_wait(wqh, &wait, TASK_UNINTERRUPTIBLE);
	ret = io_schedule_timeout(timeout);
	finish_wait(wqh, &wait);

out:
	trace_writeback_wait_iff_congested(jiffies_to_usecs(timeout),
					jiffies_to_usecs(jiffies - start));

	return ret;
}
Contributors
Person Tokens Prop Commits CommitProp
mel gorman mel gorman 134 95.71% 2 50.00%
johannes weiner johannes weiner 5 3.57% 1 25.00%
tejun heo tejun heo 1 0.71% 1 25.00%
Total 140 100.00% 4 100.00%


EXPORT_SYMBOL(wait_iff_congested);



int pdflush_proc_obsolete(struct ctl_table *table, int write,
			void __user *buffer, size_t *lenp, loff_t *ppos)
{
	char kbuf[] = "0\n";

	if (*ppos || *lenp < sizeof(kbuf)) {
		*lenp = 0;
		return 0;
	}

	if (copy_to_user(buffer, kbuf, sizeof(kbuf)))
		return -EFAULT;
	pr_warn_once("%s exported in /proc is scheduled for removal\n",
		     table->procname);

	*lenp = 2;
	*ppos += *lenp;
	return 2;
}
Contributors
Person Tokens Prop Commits CommitProp
wanpeng li wanpeng li 87 90.62% 1 33.33%
chen gang chen gang 8 8.33% 1 33.33%
joe perches joe perches 1 1.04% 1 33.33%
Total 96 100.00% 3 100.00%

Overall Contributors
Person Tokens Prop Commits CommitProp
tejun heo tejun heo 2190 51.66% 24 28.57%
peter zijlstra peter zijlstra 405 9.55% 6 7.14%
jens axboe jens axboe 305 7.20% 9 10.71%
miklos szeredi miklos szeredi 298 7.03% 1 1.19%
mel gorman mel gorman 193 4.55% 4 4.76%
andrew morton andrew morton 177 4.18% 1 1.19%
artem bityutskiy artem bityutskiy 105 2.48% 2 2.38%
dan williams dan williams 90 2.12% 1 1.19%
wanpeng li wanpeng li 87 2.05% 1 1.19%
jan kara jan kara 64 1.51% 5 5.95%
christoph hellwig christoph hellwig 56 1.32% 4 4.76%
darrick j. wong darrick j. wong 52 1.23% 1 1.19%
fengguang wu fengguang wu 51 1.20% 6 7.14%
greg kroah-hartman greg kroah-hartman 33 0.78% 1 1.19%
namjae jeon namjae jeon 31 0.73% 1 1.19%
theodore tso theodore tso 29 0.68% 1 1.19%
anton blanchard anton blanchard 13 0.31% 1 1.19%
joern engel joern engel 11 0.26% 1 1.19%
johannes weiner johannes weiner 9 0.21% 2 2.38%
chen gang chen gang 8 0.19% 1 1.19%
david chinner david chinner 7 0.17% 1 1.19%
rabin vincent rabin vincent 6 0.14% 2 2.38%
dave chinner dave chinner 4 0.09% 1 1.19%
neil brown neil brown 4 0.09% 1 1.19%
kees cook kees cook 3 0.07% 1 1.19%
david rientjes david rientjes 3 0.07% 1 1.19%
xia kaixu xia kaixu 2 0.05% 1 1.19%
joe perches joe perches 1 0.02% 1 1.19%
derek basehore derek basehore 1 0.02% 1 1.19%
rasmus villemoes rasmus villemoes 1 0.02% 1 1.19%
Total 4239 100.00% 84 100.00%
  Directory: mm

Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
	Person	Tokens	Prop	Commits	CommitProp
miklos szeredi	miklos szeredi	17	100.00%	1	100.00%
	Total	17	100.00%	1	100.00%
cregit-Linux how code gets into the kernel

Release 4.8 mm/backing-dev.c

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Overall Contributors
