bcache: Kill dead cgroup code (3f5e0a34) · Commits · EulixOS / Software / Kernel

drivers/md/bcache/Kconfig

+0 −8

Original line number	Diff line number	Diff line
		@@ -24,11 +24,3 @@ config BCACHE_CLOSURES_DEBUG
		Keeps all active closures in a linked list and provides a debugfs
		interface to list them, which makes it possible to see asynchronous
		operations that get stuck.

		# cgroup code needs to be updated:
		#
		#config CGROUP_BCACHE
		# bool "Cgroup controls for bcache"
		# depends on BCACHE && BLK_CGROUP
		# ---help---
		# TODO

drivers/md/bcache/btree.c

+0 −4

Original line number	Diff line number	Diff line
		@@ -68,15 +68,11 @@
		* alloc_bucket() cannot fail. This should be true but is not completely
		* obvious.
		*
		* Make sure all allocations get charged to the root cgroup
		*
		* Plugging?
		*
		* If data write is less than hard sector size of ssd, round up offset in open
		* bucket to the next whole sector
		*
		* Also lookup by cgroup in get_open_bucket()
		*
		* Superblock needs to be fleshed out for multiple cache devices
		*
		* Add a sysfs tunable for the number of writeback IOs in flight

drivers/md/bcache/request.c

+0 −169

Original line number	Diff line number	Diff line
		@@ -12,11 +12,9 @@
		#include "request.h"
		#include "writeback.h"

		#include <linux/cgroup.h>
		#include <linux/module.h>
		#include <linux/hash.h>
		#include <linux/random.h>
		#include "blk-cgroup.h"

		#include <trace/events/bcache.h>

		@@ -27,171 +25,13 @@ struct kmem_cache *bch_search_cache;

		static void bch_data_insert_start(struct closure *);

		/* Cgroup interface */

		#ifdef CONFIG_CGROUP_BCACHE
		static struct bch_cgroup bcache_default_cgroup = { .cache_mode = -1 };

		static struct bch_cgroup cgroup_to_bcache(struct cgroup cgroup)
		{
		struct cgroup_subsys_state *css;
		return cgroup &&
		(css = cgroup_subsys_state(cgroup, bcache_subsys_id))
		? container_of(css, struct bch_cgroup, css)
		: &bcache_default_cgroup;
		}

		struct bch_cgroup bch_bio_to_cgroup(struct bio bio)
		{
		struct cgroup_subsys_state *css = bio->bi_css
		? cgroup_subsys_state(bio->bi_css->cgroup, bcache_subsys_id)
		: task_subsys_state(current, bcache_subsys_id);

		return css
		? container_of(css, struct bch_cgroup, css)
		: &bcache_default_cgroup;
		}

		static ssize_t cache_mode_read(struct cgroup cgrp, struct cftype cft,
		struct file *file,
		char __user buf, size_t nbytes, loff_t ppos)
		{
		char tmp[1024];
		int len = bch_snprint_string_list(tmp, PAGE_SIZE, bch_cache_modes,
		cgroup_to_bcache(cgrp)->cache_mode + 1);

		if (len < 0)
		return len;

		return simple_read_from_buffer(buf, nbytes, ppos, tmp, len);
		}

		static int cache_mode_write(struct cgroup cgrp, struct cftype cft,
		const char *buf)
		{
		int v = bch_read_string_list(buf, bch_cache_modes);
		if (v < 0)
		return v;

		cgroup_to_bcache(cgrp)->cache_mode = v - 1;
		return 0;
		}

		static u64 bch_verify_read(struct cgroup cgrp, struct cftype cft)
		{
		return cgroup_to_bcache(cgrp)->verify;
		}

		static int bch_verify_write(struct cgroup cgrp, struct cftype cft, u64 val)
		{
		cgroup_to_bcache(cgrp)->verify = val;
		return 0;
		}

		static u64 bch_cache_hits_read(struct cgroup cgrp, struct cftype cft)
		{
		struct bch_cgroup *bcachecg = cgroup_to_bcache(cgrp);
		return atomic_read(&bcachecg->stats.cache_hits);
		}

		static u64 bch_cache_misses_read(struct cgroup cgrp, struct cftype cft)
		{
		struct bch_cgroup *bcachecg = cgroup_to_bcache(cgrp);
		return atomic_read(&bcachecg->stats.cache_misses);
		}

		static u64 bch_cache_bypass_hits_read(struct cgroup *cgrp,
		struct cftype *cft)
		{
		struct bch_cgroup *bcachecg = cgroup_to_bcache(cgrp);
		return atomic_read(&bcachecg->stats.cache_bypass_hits);
		}

		static u64 bch_cache_bypass_misses_read(struct cgroup *cgrp,
		struct cftype *cft)
		{
		struct bch_cgroup *bcachecg = cgroup_to_bcache(cgrp);
		return atomic_read(&bcachecg->stats.cache_bypass_misses);
		}

		static struct cftype bch_files[] = {
		{
		.name = "cache_mode",
		.read = cache_mode_read,
		.write_string = cache_mode_write,
		},
		{
		.name = "verify",
		.read_u64 = bch_verify_read,
		.write_u64 = bch_verify_write,
		},
		{
		.name = "cache_hits",
		.read_u64 = bch_cache_hits_read,
		},
		{
		.name = "cache_misses",
		.read_u64 = bch_cache_misses_read,
		},
		{
		.name = "cache_bypass_hits",
		.read_u64 = bch_cache_bypass_hits_read,
		},
		{
		.name = "cache_bypass_misses",
		.read_u64 = bch_cache_bypass_misses_read,
		},
		{ } /* terminate */
		};

		static void init_bch_cgroup(struct bch_cgroup *cg)
		{
		cg->cache_mode = -1;
		}

		static struct cgroup_subsys_state bcachecg_create(struct cgroup cgroup)
		{
		struct bch_cgroup *cg;

		cg = kzalloc(sizeof(*cg), GFP_KERNEL);
		if (!cg)
		return ERR_PTR(-ENOMEM);
		init_bch_cgroup(cg);
		return &cg->css;
		}

		static void bcachecg_destroy(struct cgroup *cgroup)
		{
		struct bch_cgroup *cg = cgroup_to_bcache(cgroup);
		kfree(cg);
		}

		struct cgroup_subsys bcache_subsys = {
		.create = bcachecg_create,
		.destroy = bcachecg_destroy,
		.subsys_id = bcache_subsys_id,
		.name = "bcache",
		.module = THIS_MODULE,
		};
		EXPORT_SYMBOL_GPL(bcache_subsys);
		#endif

		static unsigned cache_mode(struct cached_dev dc, struct bio bio)
		{
		#ifdef CONFIG_CGROUP_BCACHE
		int r = bch_bio_to_cgroup(bio)->cache_mode;
		if (r >= 0)
		return r;
		#endif
		return BDEV_CACHE_MODE(&dc->sb);
		}

		static bool verify(struct cached_dev dc, struct bio bio)
		{
		#ifdef CONFIG_CGROUP_BCACHE
		if (bch_bio_to_cgroup(bio)->verify)
		return true;
		#endif
		return dc->verify;
		}

		@@ -1305,9 +1145,6 @@ void bch_flash_dev_request_init(struct bcache_device *d)

		void bch_request_exit(void)
		{
		#ifdef CONFIG_CGROUP_BCACHE
		cgroup_unload_subsys(&bcache_subsys);
		#endif
		if (bch_search_cache)
		kmem_cache_destroy(bch_search_cache);
		}
		@@ -1318,11 +1155,5 @@ int __init bch_request_init(void)
		if (!bch_search_cache)
		return -ENOMEM;

		#ifdef CONFIG_CGROUP_BCACHE
		cgroup_load_subsys(&bcache_subsys);
		init_bch_cgroup(&bcache_default_cgroup);

		cgroup_add_cftypes(&bcache_subsys, bch_files);
		#endif
		return 0;
		}

drivers/md/bcache/request.h

+0 −18

Original line number	Diff line number	Diff line
		#ifndef _BCACHE_REQUEST_H_
		#define _BCACHE_REQUEST_H_

		#include <linux/cgroup.h>

		struct data_insert_op {
		struct closure cl;
		struct cache_set *c;
		@@ -42,20 +40,4 @@ void bch_flash_dev_request_init(struct bcache_device *d);

		extern struct kmem_cache bch_search_cache, bch_passthrough_cache;

		struct bch_cgroup {
		#ifdef CONFIG_CGROUP_BCACHE
		struct cgroup_subsys_state css;
		#endif
		/*
		* We subtract one from the index into bch_cache_modes[], so that
		* default == -1; this makes it so the rest match up with d->cache_mode,
		* and we use d->cache_mode if cgrp->cache_mode < 0
		*/
		short cache_mode;
		bool verify;
		struct cache_stat_collector stats;
		};

		struct bch_cgroup bch_bio_to_cgroup(struct bio bio);

		#endif /* _BCACHE_REQUEST_H_ */

drivers/md/bcache/stats.c

+0 −3

Original line number	Diff line number	Diff line
		@@ -201,9 +201,6 @@ void bch_mark_cache_accounting(struct cache_set c, struct bcache_device d,
		struct cached_dev *dc = container_of(d, struct cached_dev, disk);
		mark_cache_stats(&dc->accounting.collector, hit, bypass);
		mark_cache_stats(&c->accounting.collector, hit, bypass);
		#ifdef CONFIG_CGROUP_BCACHE
		mark_cache_stats(&(bch_bio_to_cgroup(s->orig_bio)->stats), hit, bypass);
		#endif
		}

		void bch_mark_cache_readahead(struct cache_set c, struct bcache_device d)