Release 4.7 block/blk-sysfs.c

Directory: block
/*
 * Functions related to sysfs handling
 */
#include <linux/kernel.h>
#include <linux/slab.h>
#include <linux/module.h>
#include <linux/bio.h>
#include <linux/blkdev.h>
#include <linux/backing-dev.h>
#include <linux/blktrace_api.h>
#include <linux/blk-mq.h>
#include <linux/blk-cgroup.h>

#include "blk.h"
#include "blk-mq.h"


struct queue_sysfs_entry {
	
struct attribute attr;
	
ssize_t (*show)(struct request_queue *, char *);
	
ssize_t (*store)(struct request_queue *, const char *, size_t);
};


static ssize_t

queue_var_show(unsigned long var, char *page)
{
	return sprintf(page, "%lu\n", var);
}

Contributors
Person Tokens Prop Commits CommitProp
jens axboe jens axboe 22 91.67% 1 50.00%
xiaotian feng xiaotian feng 2 8.33% 1 50.00%
Total 24 100.00% 2 100.00%


static ssize_t

queue_var_store(unsigned long *var, const char *page, size_t count)
{
	int err;
	unsigned long v;

	err = kstrtoul(page, 10, &v);
	if (err || v > UINT_MAX)
		return -EINVAL;

	*var = v;

	return count;
}

Contributors
Person Tokens Prop Commits CommitProp
jens axboe jens axboe 29 50.00% 1 33.33%
dave reisner dave reisner 28 48.28% 1 33.33%
jingoo han jingoo han 1 1.72% 1 33.33%
Total 58 100.00% 3 100.00%



static ssize_t queue_requests_show(struct request_queue *q, char *page)
{
	return queue_var_show(q->nr_requests, (page));
}

Contributors
Person Tokens Prop Commits CommitProp
jens axboe jens axboe 27 100.00% 1 100.00%
Total 27 100.00% 1 100.00%


static ssize_t

queue_requests_store(struct request_queue *q, const char *page, size_t count)
{
	unsigned long nr;
	int ret, err;

	if (!q->request_fn && !q->mq_ops)
		return -EINVAL;

	ret = queue_var_store(&nr, page, count);
	if (ret < 0)
		return ret;

	if (nr < BLKDEV_MIN_RQ)
		nr = BLKDEV_MIN_RQ;

	if (q->request_fn)
		err = blk_update_nr_requests(q, nr);
	else
		err = blk_mq_update_nr_requests(q, nr);

	if (err)
		return err;

	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
jens axboe jens axboe 99 90.00% 3 50.00%
dave reisner dave reisner 9 8.18% 1 16.67%
tejun heo tejun heo 1 0.91% 1 16.67%
tao ma tao ma 1 0.91% 1 16.67%
Total 110 100.00% 6 100.00%



static ssize_t queue_ra_show(struct request_queue *q, char *page)
{
	unsigned long ra_kb = q->backing_dev_info.ra_pages <<
					(PAGE_SHIFT - 10);

	return queue_var_show(ra_kb, (page));
}

Contributors
Person Tokens Prop Commits CommitProp
jens axboe jens axboe 38 92.68% 1 33.33%
xiaotian feng xiaotian feng 2 4.88% 1 33.33%
kirill a. shutemov kirill a. shutemov 1 2.44% 1 33.33%
Total 41 100.00% 3 100.00%


static ssize_t

queue_ra_store(struct request_queue *q, const char *page, size_t count)
{
	unsigned long ra_kb;
	ssize_t ret = queue_var_store(&ra_kb, page, count);

	if (ret < 0)
		return ret;

	q->backing_dev_info.ra_pages = ra_kb >> (PAGE_SHIFT - 10);

	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
jens axboe jens axboe 52 83.87% 1 33.33%
dave reisner dave reisner 9 14.52% 1 33.33%
kirill a. shutemov kirill a. shutemov 1 1.61% 1 33.33%
Total 62 100.00% 3 100.00%



static ssize_t queue_max_sectors_show(struct request_queue *q, char *page)
{
	int max_sectors_kb = queue_max_sectors(q) >> 1;

	return queue_var_show(max_sectors_kb, (page));
}

Contributors
Person Tokens Prop Commits CommitProp
jens axboe jens axboe 32 91.43% 1 50.00%
martin k. petersen martin k. petersen 3 8.57% 1 50.00%
Total 35 100.00% 2 100.00%



static ssize_t queue_max_segments_show(struct request_queue *q, char *page)
{
	return queue_var_show(queue_max_segments(q), (page));
}

Contributors
Person Tokens Prop Commits CommitProp
martin k. petersen martin k. petersen 28 100.00% 1 100.00%
Total 28 100.00% 1 100.00%



static ssize_t queue_max_integrity_segments_show(struct request_queue *q, char *page)
{
	return queue_var_show(q->limits.max_integrity_segments, (page));
}

Contributors
Person Tokens Prop Commits CommitProp
martin k. petersen martin k. petersen 29 100.00% 1 100.00%
Total 29 100.00% 1 100.00%



static ssize_t queue_max_segment_size_show(struct request_queue *q, char *page)
{
	if (blk_queue_cluster(q))
		return queue_var_show(queue_max_segment_size(q), (page));

	return queue_var_show(PAGE_SIZE, (page));
}

Contributors
Person Tokens Prop Commits CommitProp
martin k. petersen martin k. petersen 44 97.78% 2 66.67%
kirill a. shutemov kirill a. shutemov 1 2.22% 1 33.33%
Total 45 100.00% 3 100.00%



static ssize_t queue_logical_block_size_show(struct request_queue *q, char *page)
{
	return queue_var_show(queue_logical_block_size(q), page);
}

Contributors
Person Tokens Prop Commits CommitProp
martin k. petersen martin k. petersen 26 100.00% 2 100.00%
Total 26 100.00% 2 100.00%



static ssize_t queue_physical_block_size_show(struct request_queue *q, char *page)
{
	return queue_var_show(queue_physical_block_size(q), page);
}

Contributors
Person Tokens Prop Commits CommitProp
martin k. petersen martin k. petersen 26 100.00% 1 100.00%
Total 26 100.00% 1 100.00%



static ssize_t queue_io_min_show(struct request_queue *q, char *page)
{
	return queue_var_show(queue_io_min(q), page);
}

Contributors
Person Tokens Prop Commits CommitProp
martin k. petersen martin k. petersen 26 100.00% 1 100.00%
Total 26 100.00% 1 100.00%



static ssize_t queue_io_opt_show(struct request_queue *q, char *page)
{
	return queue_var_show(queue_io_opt(q), page);
}

Contributors
Person Tokens Prop Commits CommitProp
martin k. petersen martin k. petersen 26 100.00% 2 100.00%
Total 26 100.00% 2 100.00%



static ssize_t queue_discard_granularity_show(struct request_queue *q, char *page)
{
	return queue_var_show(q->limits.discard_granularity, page);
}

Contributors
Person Tokens Prop Commits CommitProp
martin k. petersen martin k. petersen 27 100.00% 1 100.00%
Total 27 100.00% 1 100.00%



static ssize_t queue_discard_max_hw_show(struct request_queue *q, char *page)
{

	return sprintf(page, "%llu\n",
		(unsigned long long)q->limits.max_hw_discard_sectors << 9);
}

Contributors
Person Tokens Prop Commits CommitProp
jens axboe jens axboe 27 75.00% 1 50.00%
alan one thousand gnomes alan one thousand gnomes 9 25.00% 1 50.00%
Total 36 100.00% 2 100.00%



static ssize_t queue_discard_max_show(struct request_queue *q, char *page)
{
	return sprintf(page, "%llu\n",
		       (unsigned long long)q->limits.max_discard_sectors << 9);
}

Contributors
Person Tokens Prop Commits CommitProp
martin k. petersen martin k. petersen 36 100.00% 2 100.00%
Total 36 100.00% 2 100.00%



static ssize_t queue_discard_max_store(struct request_queue *q,
				       const char *page, size_t count)
{
	unsigned long max_discard;
	ssize_t ret = queue_var_store(&max_discard, page, count);

	if (ret < 0)
		return ret;

	if (max_discard & (q->limits.discard_granularity - 1))
		return -EINVAL;

	max_discard >>= 9;
	if (max_discard > UINT_MAX)
		return -EINVAL;

	if (max_discard > q->limits.max_hw_discard_sectors)
		max_discard = q->limits.max_hw_discard_sectors;

	q->limits.max_discard_sectors = max_discard;
	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
jens axboe jens axboe 106 100.00% 1 100.00%
Total 106 100.00% 1 100.00%



static ssize_t queue_discard_zeroes_data_show(struct request_queue *q, char *page)
{
	return queue_var_show(queue_discard_zeroes_data(q), page);
}

Contributors
Person Tokens Prop Commits CommitProp
martin k. petersen martin k. petersen 26 100.00% 1 100.00%
Total 26 100.00% 1 100.00%



static ssize_t queue_write_same_max_show(struct request_queue *q, char *page)
{
	return sprintf(page, "%llu\n",
		(unsigned long long)q->limits.max_write_same_sectors << 9);
}


Contributors
Person Tokens Prop Commits CommitProp
martin k. petersen martin k. petersen 36 100.00% 1 100.00%
Total 36 100.00% 1 100.00%


static ssize_t

queue_max_sectors_store(struct request_queue *q, const char *page, size_t count)
{
	unsigned long max_sectors_kb,
		max_hw_sectors_kb = queue_max_hw_sectors(q) >> 1,
			page_kb = 1 << (PAGE_SHIFT - 10);
	ssize_t ret = queue_var_store(&max_sectors_kb, page, count);

	if (ret < 0)
		return ret;

	max_hw_sectors_kb = min_not_zero(max_hw_sectors_kb, (unsigned long)
					 q->limits.max_dev_sectors >> 1);

	if (max_sectors_kb > max_hw_sectors_kb || max_sectors_kb < page_kb)
		return -EINVAL;

	spin_lock_irq(q->queue_lock);
	q->limits.max_sectors = max_sectors_kb << 1;
	spin_unlock_irq(q->queue_lock);

	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
jens axboe jens axboe 87 70.16% 1 16.67%
martin k. petersen martin k. petersen 22 17.74% 2 33.33%
dave reisner dave reisner 9 7.26% 1 16.67%
nikanth karthikesan nikanth karthikesan 5 4.03% 1 16.67%
kirill a. shutemov kirill a. shutemov 1 0.81% 1 16.67%
Total 124 100.00% 6 100.00%



static ssize_t queue_max_hw_sectors_show(struct request_queue *q, char *page)
{
	int max_hw_sectors_kb = queue_max_hw_sectors(q) >> 1;

	return queue_var_show(max_hw_sectors_kb, (page));
}

Contributors
Person Tokens Prop Commits CommitProp
jens axboe jens axboe 32 91.43% 1 50.00%
martin k. petersen martin k. petersen 3 8.57% 1 50.00%
Total 35 100.00% 2 100.00%


#define QUEUE_SYSFS_BIT_FNS(name, flag, neg)				\
static ssize_t                                                          \
queue_show_##name(struct request_queue *q, char *page)                  \
{                                                                       \
        int bit;                                                        \
        bit = test_bit(QUEUE_FLAG_##flag, &q->queue_flags);             \
        return queue_var_show(neg ? !bit : bit, page);                  \
}                                                                       \
static ssize_t                                                          \
queue_store_##name(struct request_queue *q, const char *page, size_t count) \
{                                                                       \
        unsigned long val;                                              \
        ssize_t ret;                                                    \
        ret = queue_var_store(&val, page, count);                       \
        if (ret < 0)                                                    \
                 return ret;                                            \
        if (neg)                                                        \
                val = !val;                                             \
                                                                        \
        spin_lock_irq(q->queue_lock);                                   \
        if (val)                                                        \
                queue_flag_set(QUEUE_FLAG_##flag, q);                   \
        else                                                            \
                queue_flag_clear(QUEUE_FLAG_##flag, q);                 \
        spin_unlock_irq(q->queue_lock);                                 \
        return ret;                                                     \
}

QUEUE_SYSFS_BIT_FNS(nonrot, NONROT, 1);
QUEUE_SYSFS_BIT_FNS(random, ADD_RANDOM, 0);
QUEUE_SYSFS_BIT_FNS(iostats, IO_STAT, 0);

#undef QUEUE_SYSFS_BIT_FNS



static ssize_t queue_nomerges_show(struct request_queue *q, char *page)
{
	return queue_var_show((blk_queue_nomerges(q) << 1) |
			       blk_queue_noxmerges(q), page);
}

Contributors
Person Tokens Prop Commits CommitProp
alan d. brunelle alan d. brunelle 35 100.00% 2 100.00%
Total 35 100.00% 2 100.00%



static ssize_t queue_nomerges_store(struct request_queue *q, const char *page,
				    size_t count)
{
	unsigned long nm;
	ssize_t ret = queue_var_store(&nm, page, count);

	if (ret < 0)
		return ret;

	spin_lock_irq(q->queue_lock);
	queue_flag_clear(QUEUE_FLAG_NOMERGES, q);
	queue_flag_clear(QUEUE_FLAG_NOXMERGES, q);
	if (nm == 2)
		queue_flag_set(QUEUE_FLAG_NOMERGES, q);
	else if (nm)
		queue_flag_set(QUEUE_FLAG_NOXMERGES, q);
	spin_unlock_irq(q->queue_lock);

	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
alan d. brunelle alan d. brunelle 78 77.23% 2 50.00%
jens axboe jens axboe 14 13.86% 1 25.00%
dave reisner dave reisner 9 8.91% 1 25.00%
Total 101 100.00% 4 100.00%



static ssize_t queue_rq_affinity_show(struct request_queue *q, char *page)
{
	bool set = test_bit(QUEUE_FLAG_SAME_COMP, &q->queue_flags);
	bool force = test_bit(QUEUE_FLAG_SAME_FORCE, &q->queue_flags);

	return queue_var_show(set << force, page);
}

Contributors
Person Tokens Prop Commits CommitProp
jens axboe jens axboe 35 68.63% 1 33.33%
dan williams dan williams 15 29.41% 1 33.33%
xiaotian feng xiaotian feng 1 1.96% 1 33.33%
Total 51 100.00% 3 100.00%


static ssize_t

queue_rq_affinity_store(struct request_queue *q, const char *page, size_t count)
{
	ssize_t ret = -EINVAL;
#ifdef CONFIG_SMP
	unsigned long val;

	ret = queue_var_store(&val, page, count);
	if (ret < 0)
		return ret;

	spin_lock_irq(q->queue_lock);
	if (val == 2) {
		queue_flag_set(QUEUE_FLAG_SAME_COMP, q);
		queue_flag_set(QUEUE_FLAG_SAME_FORCE, q);
	} else if (val == 1) {
		queue_flag_set(QUEUE_FLAG_SAME_COMP, q);
		queue_flag_clear(QUEUE_FLAG_SAME_FORCE, q);
	} else if (val == 0) {
		queue_flag_clear(QUEUE_FLAG_SAME_COMP, q);
		queue_flag_clear(QUEUE_FLAG_SAME_FORCE, q);
	}
	spin_unlock_irq(q->queue_lock);
#endif
	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
jens axboe jens axboe 78 55.71% 1 20.00%
eric seppanen eric seppanen 27 19.29% 1 20.00%
dan williams dan williams 23 16.43% 1 20.00%
dave reisner dave reisner 9 6.43% 1 20.00%
christoph hellwig christoph hellwig 3 2.14% 1 20.00%
Total 140 100.00% 5 100.00%



static ssize_t queue_poll_show(struct request_queue *q, char *page)
{
	return queue_var_show(test_bit(QUEUE_FLAG_POLL, &q->queue_flags), page);
}

Contributors
Person Tokens Prop Commits CommitProp
jens axboe jens axboe 31 100.00% 1 100.00%
Total 31 100.00% 1 100.00%



static ssize_t queue_poll_store(struct request_queue *q, const char *page,
				size_t count)
{
	unsigned long poll_on;
	ssize_t ret;

	if (!q->mq_ops || !q->mq_ops->poll)
		return -EINVAL;

	ret = queue_var_store(&poll_on, page, count);
	if (ret < 0)
		return ret;

	spin_lock_irq(q->queue_lock);
	if (poll_on)
		queue_flag_set(QUEUE_FLAG_POLL, q);
	else
		queue_flag_clear(QUEUE_FLAG_POLL, q);
	spin_unlock_irq(q->queue_lock);

	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
jens axboe jens axboe 101 100.00% 1 100.00%
Total 101 100.00% 1 100.00%



static ssize_t queue_wc_show(struct request_queue *q, char *page)
{
	if (test_bit(QUEUE_FLAG_WC, &q->queue_flags))
		return sprintf(page, "write back\n");

	return sprintf(page, "write through\n");
}

Contributors
Person Tokens Prop Commits CommitProp
jens axboe jens axboe 43 100.00% 1 100.00%
Total 43 100.00% 1 100.00%



static ssize_t queue_wc_store(struct request_queue *q, const char *page,
			      size_t count)
{
	int set = -1;

	if (!strncmp(page, "write back", 10))
		set = 1;
	else if (!strncmp(page, "write through", 13) ||
		 !strncmp(page, "none", 4))
		set = 0;

	if (set == -1)
		return -EINVAL;

	spin_lock_irq(q->queue_lock);
	if (set)
		queue_flag_set(QUEUE_FLAG_WC, q);
	else
		queue_flag_clear(QUEUE_FLAG_WC, q);
	spin_unlock_irq(q->queue_lock);

	return count;
}

Contributors
Person Tokens Prop Commits CommitProp
jens axboe jens axboe 115 100.00% 1 100.00%
Total 115 100.00% 1 100.00%


static struct queue_sysfs_entry queue_requests_entry = {
	.attr = {.name = "nr_requests", .mode = S_IRUGO | S_IWUSR },
	.show = queue_requests_show,
	.store = queue_requests_store,
};


static struct queue_sysfs_entry queue_ra_entry = {
	.attr = {.name = "read_ahead_kb", .mode = S_IRUGO | S_IWUSR },
	.show = queue_ra_show,
	.store = queue_ra_store,
};


static struct queue_sysfs_entry queue_max_sectors_entry = {
	.attr = {.name = "max_sectors_kb", .mode = S_IRUGO | S_IWUSR },
	.show = queue_max_sectors_show,
	.store = queue_max_sectors_store,
};


static struct queue_sysfs_entry queue_max_hw_sectors_entry = {
	.attr = {.name = "max_hw_sectors_kb", .mode = S_IRUGO },
	.show = queue_max_hw_sectors_show,
};


static struct queue_sysfs_entry queue_max_segments_entry = {
	.attr = {.name = "max_segments", .mode = S_IRUGO },
	.show = queue_max_segments_show,
};


static struct queue_sysfs_entry queue_max_integrity_segments_entry = {
	.attr = {.name = "max_integrity_segments", .mode = S_IRUGO },
	.show = queue_max_integrity_segments_show,
};


static struct queue_sysfs_entry queue_max_segment_size_entry = {
	.attr = {.name = "max_segment_size", .mode = S_IRUGO },
	.show = queue_max_segment_size_show,
};


static struct queue_sysfs_entry queue_iosched_entry = {
	.attr = {.name = "scheduler", .mode = S_IRUGO | S_IWUSR },
	.show = elv_iosched_show,
	.store = elv_iosched_store,
};


static struct queue_sysfs_entry queue_hw_sector_size_entry = {
	.attr = {.name = "hw_sector_size", .mode = S_IRUGO },
	.show = queue_logical_block_size_show,
};


static struct queue_sysfs_entry queue_logical_block_size_entry = {
	.attr = {.name = "logical_block_size", .mode = S_IRUGO },
	.show = queue_logical_block_size_show,
};


static struct queue_sysfs_entry queue_physical_block_size_entry = {
	.attr = {.name = "physical_block_size", .mode = S_IRUGO },
	.show = queue_physical_block_size_show,
};


static struct queue_sysfs_entry queue_io_min_entry = {
	.attr = {.name = "minimum_io_size", .mode = S_IRUGO },
	.show = queue_io_min_show,
};


static struct queue_sysfs_entry queue_io_opt_entry = {
	.attr = {.name = "optimal_io_size", .mode = S_IRUGO },
	.show = queue_io_opt_show,
};


static struct queue_sysfs_entry queue_discard_granularity_entry = {
	.attr = {.name = "discard_granularity", .mode = S_IRUGO },
	.show = queue_discard_granularity_show,
};


static struct queue_sysfs_entry queue_discard_max_hw_entry = {
	.attr = {.name = "discard_max_hw_bytes", .mode = S_IRUGO },
	.show = queue_discard_max_hw_show,
};


static struct queue_sysfs_entry queue_discard_max_entry = {
	.attr = {.name = "discard_max_bytes", .mode = S_IRUGO | S_IWUSR },
	.show = queue_discard_max_show,
	.store = queue_discard_max_store,
};


static struct queue_sysfs_entry queue_discard_zeroes_data_entry = {
	.attr = {.name = "discard_zeroes_data", .mode = S_IRUGO },
	.show = queue_discard_zeroes_data_show,
};


static struct queue_sysfs_entry queue_write_same_max_entry = {
	.attr = {.name = "write_same_max_bytes", .mode = S_IRUGO },
	.show = queue_write_same_max_show,
};


static struct queue_sysfs_entry queue_nonrot_entry = {
	.attr = {.name = "rotational", .mode = S_IRUGO | S_IWUSR },
	.show = queue_show_nonrot,
	.store = queue_store_nonrot,
};


static struct queue_sysfs_entry queue_nomerges_entry = {
	.attr = {.name = "nomerges", .mode = S_IRUGO | S_IWUSR },
	.show = queue_nomerges_show,
	.store = queue_nomerges_store,
};


static struct queue_sysfs_entry queue_rq_affinity_entry = {
	.attr = {.name = "rq_affinity", .mode = S_IRUGO | S_IWUSR },
	.show = queue_rq_affinity_show,
	.store = queue_rq_affinity_store,
};


static struct queue_sysfs_entry queue_iostats_entry = {
	.attr = {.name = "iostats", .mode = S_IRUGO | S_IWUSR },
	.show = queue_show_iostats,
	.store = queue_store_iostats,
};


static struct queue_sysfs_entry queue_random_entry = {
	.attr = {.name = "add_random", .mode = S_IRUGO | S_IWUSR },
	.show = queue_show_random,
	.store = queue_store_random,
};


static struct queue_sysfs_entry queue_poll_entry = {
	.attr = {.name = "io_poll", .mode = S_IRUGO | S_IWUSR },
	.show = queue_poll_show,
	.store = queue_poll_store,
};


static struct queue_sysfs_entry queue_wc_entry = {
	.attr = {.name = "write_cache", .mode = S_IRUGO | S_IWUSR },
	.show = queue_wc_show,
	.store = queue_wc_store,
};


static struct attribute *default_attrs[] = {
	&queue_requests_entry.attr,
	&queue_ra_entry.attr,
	&queue_max_hw_sectors_entry.attr,
	&queue_max_sectors_entry.attr,
	&queue_max_segments_entry.attr,
	&queue_max_integrity_segments_entry.attr,
	&queue_max_segment_size_entry.attr,
	&queue_iosched_entry.attr,
	&queue_hw_sector_size_entry.attr,
	&queue_logical_block_size_entry.attr,
	&queue_physical_block_size_entry.attr,
	&queue_io_min_entry.attr,
	&queue_io_opt_entry.attr,
	&queue_discard_granularity_entry.attr,
	&queue_discard_max_entry.attr,
	&queue_discard_max_hw_entry.attr,
	&queue_discard_zeroes_data_entry.attr,
	&queue_write_same_max_entry.attr,
	&queue_nonrot_entry.attr,
	&queue_nomerges_entry.attr,
	&queue_rq_affinity_entry.attr,
	&queue_iostats_entry.attr,
	&queue_random_entry.attr,
	&queue_poll_entry.attr,
	&queue_wc_entry.attr,
	NULL,
};


#define to_queue(atr) container_of((atr), struct queue_sysfs_entry, attr)


static ssize_t

queue_attr_show(struct kobject *kobj, struct attribute *attr, char *page)
{
	struct queue_sysfs_entry *entry = to_queue(attr);
	struct request_queue *q =
		container_of(kobj, struct request_queue, kobj);
	ssize_t res;

	if (!entry->show)
		return -EIO;
	mutex_lock(&q->sysfs_lock);
	if (blk_queue_dying(q)) {
		mutex_unlock(&q->sysfs_lock);
		return -ENOENT;
	}
	res = entry->show(q, page);
	mutex_unlock(&q->sysfs_lock);
	return res;
}

Contributors
Person Tokens Prop Commits CommitProp
jens axboe jens axboe 109 99.09% 1 50.00%
bart van assche bart van assche 1 0.91% 1 50.00%
Total 110 100.00% 2 100.00%


static ssize_t

queue_attr_store(struct kobject *kobj, struct attribute *attr,
		    const char *page, size_t length)
{
	struct queue_sysfs_entry *entry = to_queue(attr);
	struct request_queue *q;
	ssize_t res;

	if (!entry->store)
		return -EIO;

	q = container_of(kobj, struct request_queue, kobj);
	mutex_lock(&q->sysfs_lock);
	if (blk_queue_dying(q)) {
		mutex_unlock(&q->sysfs_lock);
		return -ENOENT;
	}
	res = entry->store(q, page, length);
	mutex_unlock(&q->sysfs_lock);
	return res;
}

Contributors
Person Tokens Prop Commits CommitProp
jens axboe jens axboe 117 99.15% 2 66.67%
bart van assche bart van assche 1 0.85% 1 33.33%
Total 118 100.00% 3 100.00%



static void blk_free_queue_rcu(struct rcu_head *rcu_head)
{
	struct request_queue *q = container_of(rcu_head, struct request_queue,
					       rcu_head);
	kmem_cache_free(blk_requestq_cachep, q);
}

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

/**
 * blk_release_queue: - release a &struct request_queue when it is no longer needed
 * @kobj:    the kobj belonging to the request queue to be released
 *
 * Description:
 *     blk_release_queue is the pair to blk_init_queue() or
 *     blk_queue_make_request().  It should be called when a request queue is
 *     being released; typically when a block device is being de-registered.
 *     Currently, its primary task it to free all the &struct request
 *     structures that were allocated to the queue and the queue itself.
 *
 * Note:
 *     The low level driver must have finished any outstanding requests first
 *     via blk_cleanup_queue().
 **/


static void blk_release_queue(struct kobject *kobj)
{
	struct request_queue *q =
		container_of(kobj, struct request_queue, kobj);

	bdi_exit(&q->backing_dev_info);
	blkcg_exit_queue(q);

	if (q->elevator) {
		spin_lock_irq(q->queue_lock);
		ioc_clear_queue(q);
		spin_unlock_irq(q->queue_lock);
		elevator_exit(q->elevator);
	}

	blk_exit_rl(&q->root_rl);

	if (q->queue_tags)
		__blk_queue_free_tags(q);

	if (!q->mq_ops)
		blk_free_flush_queue(q->fq);
	else
		blk_mq_release(q);

	blk_trace_shutdown(q);

	if (q->bio_split)
		bioset_free(q->bio_split);

	ida_simple_remove(&blk_queue_ida, q->id);
	call_rcu(&q->rcu_head, blk_free_queue_rcu);
}

Contributors
Person Tokens Prop Commits CommitProp
jens axboe jens axboe 58 38.67% 2 13.33%
tejun heo tejun heo 54 36.00% 7 46.67%
kent overstreet kent overstreet 13 8.67% 1 6.67%
hannes reinecke hannes reinecke 11 7.33% 1 6.67%
ming lei ming lei 8 5.33% 2 13.33%
christoph hellwig christoph hellwig 5 3.33% 1 6.67%
bart van assche bart van assche 1 0.67% 1 6.67%
Total 150 100.00% 15 100.00%


static const struct sysfs_ops queue_sysfs_ops = {
	.show	= queue_attr_show,
	.store	= queue_attr_store,
};


struct kobj_type blk_queue_ktype = {
	.sysfs_ops	= &queue_sysfs_ops,
	.default_attrs	= default_attrs,
	.release	= blk_release_queue,
};



int blk_register_queue(struct gendisk *disk)
{
	int ret;
	struct device *dev = disk_to_dev(disk);
	struct request_queue *q = disk->queue;

	if (WARN_ON(!q))
		return -ENXIO;

	/*
         * SCSI probing may synchronously create and destroy a lot of
         * request_queues for non-existent devices.  Shutting down a fully
         * functional queue takes measureable wallclock time as RCU grace
         * periods are involved.  To avoid excessive latency in these
         * cases, a request_queue starts out in a degraded mode which is
         * faster to shut down and is made fully functional here as
         * request_queues for non-existent devices never get registered.
         */
	if (!blk_queue_init_done(q)) {
		queue_flag_set_unlocked(QUEUE_FLAG_INIT_DONE, q);
		percpu_ref_switch_to_percpu(&q->q_usage_counter);
		blk_queue_bypass_end(q);
	}

	ret = blk_trace_init_sysfs(dev);
	if (ret)
		return ret;

	ret = kobject_add(&q->kobj, kobject_get(&dev->kobj), "%s", "queue");
	if (ret < 0) {
		blk_trace_remove_sysfs(dev);
		return ret;
	}

	kobject_uevent(&q->kobj, KOBJ_ADD);

	if (q->mq_ops)
		blk_mq_register_disk(disk);

	if (!q->request_fn)
		return 0;

	ret = elv_register_queue(q);
	if (ret) {
		kobject_uevent(&q->kobj, KOBJ_REMOVE);
		kobject_del(&q->kobj);
		blk_trace_remove_sysfs(dev);
		kobject_put(&dev->kobj);
		return ret;
	}

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
jens axboe jens axboe 118 56.73% 2 14.29%
li zefan li zefan 25 12.02% 1 7.14%
tejun heo tejun heo 12 5.77% 3 21.43%
martin k. petersen martin k. petersen 10 4.81% 1 7.14%
alan stern alan stern 10 4.81% 1 7.14%
xiaotian feng xiaotian feng 8 3.85% 1 7.14%
akinobu mita akinobu mita 8 3.85% 1 7.14%
liu yuan liu yuan 8 3.85% 2 14.29%
dan williams dan williams 5 2.40% 1 7.14%
zdenek kabelac zdenek kabelac 4 1.92% 1 7.14%
Total 208 100.00% 14 100.00%



void blk_unregister_queue(struct gendisk *disk)
{
	struct request_queue *q = disk->queue;

	if (WARN_ON(!q))
		return;

	if (q->mq_ops)
		blk_mq_unregister_disk(disk);

	if (q->request_fn)
		elv_unregister_queue(q);

	kobject_uevent(&q->kobj, KOBJ_REMOVE);
	kobject_del(&q->kobj);
	blk_trace_remove_sysfs(disk_to_dev(disk));
	kobject_put(&disk_to_dev(disk)->kobj);
}
Contributors
Person Tokens Prop Commits CommitProp
jens axboe jens axboe 68 78.16% 2 40.00%
akinobu mita akinobu mita 8 9.20% 1 20.00%
zdenek kabelac zdenek kabelac 8 9.20% 1 20.00%
tejun heo tejun heo 3 3.45% 1 20.00%
Total 87 100.00% 5 100.00%

Overall Contributors
Person Tokens Prop Commits CommitProp
jens axboe jens axboe 2004 59.45% 13 18.06%
martin k. petersen martin k. petersen 752 22.31% 13 18.06%
alan d. brunelle alan d. brunelle 152 4.51% 2 2.78%
tejun heo tejun heo 113 3.35% 15 20.83%
dave reisner dave reisner 73 2.17% 1 1.39%
bartlomiej zolnierkiewicz bartlomiej zolnierkiewicz 54 1.60% 1 1.39%
dan williams dan williams 43 1.28% 2 2.78%
eric seppanen eric seppanen 27 0.80% 1 1.39%
li zefan li zefan 25 0.74% 1 1.39%
akinobu mita akinobu mita 16 0.47% 1 1.39%
kent overstreet kent overstreet 13 0.39% 1 1.39%
xiaotian feng xiaotian feng 13 0.39% 2 2.78%
zdenek kabelac zdenek kabelac 12 0.36% 1 1.39%
hannes reinecke hannes reinecke 11 0.33% 1 1.39%
alan stern alan stern 10 0.30% 1 1.39%
alan one thousand gnomes alan one thousand gnomes 9 0.27% 1 1.39%
christoph hellwig christoph hellwig 8 0.24% 2 2.78%
liu yuan liu yuan 8 0.24% 2 2.78%
ming lei ming lei 8 0.24% 2 2.78%
nikanth karthikesan nikanth karthikesan 5 0.15% 1 1.39%
kirill a. shutemov kirill a. shutemov 4 0.12% 1 1.39%
bart van assche bart van assche 4 0.12% 2 2.78%
lei ming lei ming 3 0.09% 1 1.39%
jingoo han jingoo han 1 0.03% 1 1.39%
tao ma tao ma 1 0.03% 1 1.39%
emese revfy emese revfy 1 0.03% 1 1.39%
arnd bergmann arnd bergmann 1 0.03% 1 1.39%
Total 3371 100.00% 72 100.00%
  Directory: block

Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
	Person	Tokens	Prop	Commits	CommitProp
jens axboe	jens axboe	22	91.67%	1	50.00%
xiaotian feng	xiaotian feng	2	8.33%	1	50.00%
	Total	24	100.00%	2	100.00%
cregit-Linux how code gets into the kernel

Release 4.7 block/blk-sysfs.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

Overall Contributors
