[linux.git] / drivers / block / aoe / aoedev.c

/* Copyright (c) 2007 Coraid, Inc.  See COPYING for GPL terms. */
/*
 * aoedev.c
 * AoE device utility functions; maintains device list.
 */

#include <linux/hdreg.h>
#include <linux/blkdev.h>
#include <linux/netdevice.h>
#include <linux/delay.h>
#include <linux/slab.h>
#include "aoe.h"

static void dummy_timer(ulong);
static void aoedev_freedev(struct aoedev *);
static void freetgt(struct aoedev *d, struct aoetgt *t);
static void skbpoolfree(struct aoedev *d);

static struct aoedev *devlist;
static DEFINE_SPINLOCK(devlist_lock);

struct aoedev *
aoedev_by_aoeaddr(int maj, int min)
{
	struct aoedev *d;
	ulong flags;

	spin_lock_irqsave(&devlist_lock, flags);

	for (d=devlist; d; d=d->next)
		if (d->aoemajor == maj && d->aoeminor == min)
			break;

	spin_unlock_irqrestore(&devlist_lock, flags);
	return d;
}

static void
dummy_timer(ulong vp)
{
	struct aoedev *d;

	d = (struct aoedev *)vp;
	if (d->flags & DEVFL_TKILL)
		return;
	d->timer.expires = jiffies + HZ;
	add_timer(&d->timer);
}

void
aoedev_downdev(struct aoedev *d)
{
	struct aoetgt **t, **te;
	struct frame *f, *e;
	struct buf *buf;
	struct bio *bio;

	t = d->targets;
	te = t + NTARGETS;
	for (; t < te && *t; t++) {
		f = (*t)->frames;
		e = f + (*t)->nframes;
		for (; f < e; f->tag = FREETAG, f->buf = NULL, f++) {
			if (f->tag == FREETAG || f->buf == NULL)
				continue;
			buf = f->buf;
			bio = buf->bio;
			if (--buf->nframesout == 0
			&& buf != d->inprocess) {
				mempool_free(buf, d->bufpool);
				bio_endio(bio, -EIO);
			}
		}
		(*t)->maxout = (*t)->nframes;
		(*t)->nout = 0;
	}
	buf = d->inprocess;
	if (buf) {
		bio = buf->bio;
		mempool_free(buf, d->bufpool);
		bio_endio(bio, -EIO);
	}
	d->inprocess = NULL;
	d->htgt = NULL;

	while (!list_empty(&d->bufq)) {
		buf = container_of(d->bufq.next, struct buf, bufs);
		list_del(d->bufq.next);
		bio = buf->bio;
		mempool_free(buf, d->bufpool);
		bio_endio(bio, -EIO);
	}

	if (d->gd)
		set_capacity(d->gd, 0);

	d->flags &= ~DEVFL_UP;
}

static void
aoedev_freedev(struct aoedev *d)
{
	struct aoetgt **t, **e;

	cancel_work_sync(&d->work);
	if (d->gd) {
		aoedisk_rm_sysfs(d);
		del_gendisk(d->gd);
		put_disk(d->gd);
	}
	t = d->targets;
	e = t + NTARGETS;
	for (; t < e && *t; t++)
		freetgt(d, *t);
	if (d->bufpool)
		mempool_destroy(d->bufpool);
	skbpoolfree(d);
	blk_cleanup_queue(d->blkq);
	kfree(d);
}

int
aoedev_flush(const char __user *str, size_t cnt)
{
	ulong flags;
	struct aoedev *d, **dd;
	struct aoedev *rmd = NULL;
	char buf[16];
	int all = 0;

	if (cnt >= 3) {
		if (cnt > sizeof buf)
			cnt = sizeof buf;
		if (copy_from_user(buf, str, cnt))
			return -EFAULT;
		all = !strncmp(buf, "all", 3);
	}

	spin_lock_irqsave(&devlist_lock, flags);
	dd = &devlist;
	while ((d = *dd)) {
		spin_lock(&d->lock);
		if ((!all && (d->flags & DEVFL_UP))
		|| (d->flags & (DEVFL_GDALLOC|DEVFL_NEWSIZE))
		|| d->nopen) {
			spin_unlock(&d->lock);
			dd = &d->next;
			continue;
		}
		*dd = d->next;
		aoedev_downdev(d);
		d->flags |= DEVFL_TKILL;
		spin_unlock(&d->lock);
		d->next = rmd;
		rmd = d;
	}
	spin_unlock_irqrestore(&devlist_lock, flags);
	while ((d = rmd)) {
		rmd = d->next;
		del_timer_sync(&d->timer);
		aoedev_freedev(d);	/* must be able to sleep */
	}
	return 0;
}

/* I'm not really sure that this is a realistic problem, but if the
network driver goes gonzo let's just leak memory after complaining. */
static void
skbfree(struct sk_buff *skb)
{
	enum { Sms = 100, Tms = 3*1000};
	int i = Tms / Sms;

	if (skb == NULL)
		return;
	while (atomic_read(&skb_shinfo(skb)->dataref) != 1 && i-- > 0)
		msleep(Sms);
	if (i < 0) {
		printk(KERN_ERR
			"aoe: %s holds ref: %s\n",
			skb->dev ? skb->dev->name : "netif",
			"cannot free skb -- memory leaked.");
		return;
	}
	skb_shinfo(skb)->nr_frags = skb->data_len = 0;
	skb_trim(skb, 0);
	dev_kfree_skb(skb);
}

static void
skbpoolfree(struct aoedev *d)
{
	struct sk_buff *skb, *tmp;

	skb_queue_walk_safe(&d->skbpool, skb, tmp)
		skbfree(skb);

	__skb_queue_head_init(&d->skbpool);
}

/* find it or malloc it */
struct aoedev *
aoedev_by_sysminor_m(ulong sysminor)
{
	struct aoedev *d;
	ulong flags;

	spin_lock_irqsave(&devlist_lock, flags);

	for (d=devlist; d; d=d->next)
		if (d->sysminor == sysminor)
			break;
	if (d)
		goto out;
	d = kcalloc(1, sizeof *d, GFP_ATOMIC);
	if (!d)
		goto out;
	INIT_WORK(&d->work, aoecmd_sleepwork);
	spin_lock_init(&d->lock);
	skb_queue_head_init(&d->sendq);
	skb_queue_head_init(&d->skbpool);
	init_timer(&d->timer);
	d->timer.data = (ulong) d;
	d->timer.function = dummy_timer;
	d->timer.expires = jiffies + HZ;
	add_timer(&d->timer);
	d->bufpool = NULL;	/* defer to aoeblk_gdalloc */
	d->tgt = d->targets;
	INIT_LIST_HEAD(&d->bufq);
	d->sysminor = sysminor;
	d->aoemajor = AOEMAJOR(sysminor);
	d->aoeminor = AOEMINOR(sysminor);
	d->mintimer = MINTIMER;
	d->next = devlist;
	devlist = d;
 out:
	spin_unlock_irqrestore(&devlist_lock, flags);
	return d;
}

static void
freetgt(struct aoedev *d, struct aoetgt *t)
{
	struct frame *f, *e;

	f = t->frames;
	e = f + t->nframes;
	for (; f < e; f++)
		skbfree(f->skb);
	kfree(t->frames);
	kfree(t);
}

void
aoedev_exit(void)
{
	struct aoedev *d;
	ulong flags;

	while ((d = devlist)) {
		devlist = d->next;

		spin_lock_irqsave(&d->lock, flags);
		aoedev_downdev(d);
		d->flags |= DEVFL_TKILL;
		spin_unlock_irqrestore(&d->lock, flags);

		del_timer_sync(&d->timer);
		aoedev_freedev(d);
	}
}

int __init
aoedev_init(void)
{
	return 0;
}
Commit	Line	Data
52e112b3	1	/* Copyright (c) 2007 Coraid, Inc. See COPYING for GPL terms. */
1da177e4 LT	2	/*
	3	* aoedev.c
	4	* AoE device utility functions; maintains device list.
	5	*/
	6
	7	#include <linux/hdreg.h>
	8	#include <linux/blkdev.h>
	9	#include <linux/netdevice.h>
9bb237b6	10	#include <linux/delay.h>
5a0e3ad6	11	#include <linux/slab.h>
1da177e4 LT	12	#include "aoe.h"
1da177e4 LT	13
262bf541 EC	14	static void dummy_timer(ulong);
262bf541 EC	15	static void aoedev_freedev(struct aoedev *);
9bb237b6 EC	16	static void freetgt(struct aoedev d, struct aoetgt t);
9bb237b6 EC	17	static void skbpoolfree(struct aoedev *d);
262bf541	18
1da177e4	19	static struct aoedev *devlist;
476aed38	20	static DEFINE_SPINLOCK(devlist_lock);
1da177e4 LT	21
1da177e4 LT	22	struct aoedev *
32465c65	23	aoedev_by_aoeaddr(int maj, int min)
1da177e4 LT	24	{
	25	struct aoedev *d;
	26	ulong flags;
	27
	28	spin_lock_irqsave(&devlist_lock, flags);
	29
	30	for (d=devlist; d; d=d->next)
32465c65	31	if (d->aoemajor == maj && d->aoeminor == min)
1da177e4 LT	32	break;
	33
	34	spin_unlock_irqrestore(&devlist_lock, flags);
	35	return d;
	36	}
	37
3ae1c24e EC	38	static void
	39	dummy_timer(ulong vp)
	40	{
	41	struct aoedev *d;
	42
	43	d = (struct aoedev *)vp;
	44	if (d->flags & DEVFL_TKILL)
	45	return;
	46	d->timer.expires = jiffies + HZ;
	47	add_timer(&d->timer);
	48	}
	49
1da177e4 LT	50	void
	51	aoedev_downdev(struct aoedev *d)
	52	{
68e0d42f	53	struct aoetgt t, te;
1da177e4 LT	54	struct frame f, e;
	55	struct buf *buf;
	56	struct bio *bio;
	57
68e0d42f EC	58	t = d->targets;
	59	te = t + NTARGETS;
	60	for (; t < te && *t; t++) {
	61	f = (*t)->frames;
	62	e = f + (*t)->nframes;
	63	for (; f < e; f->tag = FREETAG, f->buf = NULL, f++) {
	64	if (f->tag == FREETAG \|\| f->buf == NULL)
	65	continue;
	66	buf = f->buf;
	67	bio = buf->bio;
	68	if (--buf->nframesout == 0
	69	&& buf != d->inprocess) {
	70	mempool_free(buf, d->bufpool);
	71	bio_endio(bio, -EIO);
	72	}
1da177e4	73	}
68e0d42f EC	74	(t)->maxout = (t)->nframes;
	75	(*t)->nout = 0;
	76	}
	77	buf = d->inprocess;
	78	if (buf) {
	79	bio = buf->bio;
	80	mempool_free(buf, d->bufpool);
	81	bio_endio(bio, -EIO);
1da177e4 LT	82	}
1da177e4 LT	83	d->inprocess = NULL;
68e0d42f	84	d->htgt = NULL;
1da177e4 LT	85
	86	while (!list_empty(&d->bufq)) {
	87	buf = container_of(d->bufq.next, struct buf, bufs);
	88	list_del(d->bufq.next);
	89	bio = buf->bio;
	90	mempool_free(buf, d->bufpool);
6712ecf8	91	bio_endio(bio, -EIO);
1da177e4 LT	92	}
1da177e4 LT	93
1da177e4	94	if (d->gd)
80795aef	95	set_capacity(d->gd, 0);
1da177e4	96
68e0d42f	97	d->flags &= ~DEVFL_UP;
1da177e4 LT	98	}
1da177e4 LT	99
262bf541 EC	100	static void
	101	aoedev_freedev(struct aoedev *d)
	102	{
	103	struct aoetgt t, e;
	104
5ad21a33	105	cancel_work_sync(&d->work);
262bf541 EC	106	if (d->gd) {
	107	aoedisk_rm_sysfs(d);
	108	del_gendisk(d->gd);
	109	put_disk(d->gd);
	110	}
	111	t = d->targets;
	112	e = t + NTARGETS;
	113	for (; t < e && *t; t++)
9bb237b6	114	freetgt(d, *t);
262bf541 EC	115	if (d->bufpool)
262bf541 EC	116	mempool_destroy(d->bufpool);
9bb237b6	117	skbpoolfree(d);
7135a71b	118	blk_cleanup_queue(d->blkq);
262bf541 EC	119	kfree(d);
	120	}
	121
	122	int
	123	aoedev_flush(const char __user *str, size_t cnt)
	124	{
	125	ulong flags;
	126	struct aoedev d, *dd;
	127	struct aoedev *rmd = NULL;
	128	char buf[16];
	129	int all = 0;
	130
	131	if (cnt >= 3) {
	132	if (cnt > sizeof buf)
	133	cnt = sizeof buf;
	134	if (copy_from_user(buf, str, cnt))
	135	return -EFAULT;
	136	all = !strncmp(buf, "all", 3);
	137	}
	138
262bf541 EC	139	spin_lock_irqsave(&devlist_lock, flags);
	140	dd = &devlist;
	141	while ((d = *dd)) {
	142	spin_lock(&d->lock);
	143	if ((!all && (d->flags & DEVFL_UP))
	144	\|\| (d->flags & (DEVFL_GDALLOC\|DEVFL_NEWSIZE))
	145	\|\| d->nopen) {
	146	spin_unlock(&d->lock);
	147	dd = &d->next;
	148	continue;
	149	}
	150	*dd = d->next;
	151	aoedev_downdev(d);
	152	d->flags \|= DEVFL_TKILL;
	153	spin_unlock(&d->lock);
	154	d->next = rmd;
	155	rmd = d;
	156	}
	157	spin_unlock_irqrestore(&devlist_lock, flags);
	158	while ((d = rmd)) {
	159	rmd = d->next;
	160	del_timer_sync(&d->timer);
	161	aoedev_freedev(d); /* must be able to sleep */
	162	}
	163	return 0;
	164	}
	165
9bb237b6 EC	166	/* I'm not really sure that this is a realistic problem, but if the
	167	network driver goes gonzo let's just leak memory after complaining. */
	168	static void
	169	skbfree(struct sk_buff *skb)
	170	{
	171	enum { Sms = 100, Tms = 3*1000};
	172	int i = Tms / Sms;
	173
	174	if (skb == NULL)
	175	return;
	176	while (atomic_read(&skb_shinfo(skb)->dataref) != 1 && i-- > 0)
	177	msleep(Sms);
94873111	178	if (i < 0) {
9bb237b6 EC	179	printk(KERN_ERR
	180	"aoe: %s holds ref: %s\n",
	181	skb->dev ? skb->dev->name : "netif",
	182	"cannot free skb -- memory leaked.");
	183	return;
	184	}
	185	skb_shinfo(skb)->nr_frags = skb->data_len = 0;
	186	skb_trim(skb, 0);
	187	dev_kfree_skb(skb);
	188	}
	189
	190	static void
	191	skbpoolfree(struct aoedev *d)
	192	{
e9bb8fb0	193	struct sk_buff skb, tmp;
9bb237b6	194
e9bb8fb0	195	skb_queue_walk_safe(&d->skbpool, skb, tmp)
9bb237b6	196	skbfree(skb);
e9bb8fb0 DM	197
e9bb8fb0 DM	198	__skb_queue_head_init(&d->skbpool);
9bb237b6 EC	199	}
9bb237b6 EC	200
3ae1c24e	201	/* find it or malloc it */
1da177e4	202	struct aoedev *
68e0d42f	203	aoedev_by_sysminor_m(ulong sysminor)
1da177e4 LT	204	{
	205	struct aoedev *d;
	206	ulong flags;
	207
	208	spin_lock_irqsave(&devlist_lock, flags);
	209
	210	for (d=devlist; d; d=d->next)
93d489fc	211	if (d->sysminor == sysminor)
1da177e4	212	break;
68e0d42f EC	213	if (d)
	214	goto out;
	215	d = kcalloc(1, sizeof *d, GFP_ATOMIC);
	216	if (!d)
	217	goto out;
	218	INIT_WORK(&d->work, aoecmd_sleepwork);
	219	spin_lock_init(&d->lock);
e9bb8fb0 DM	220	skb_queue_head_init(&d->sendq);
e9bb8fb0 DM	221	skb_queue_head_init(&d->skbpool);
68e0d42f EC	222	init_timer(&d->timer);
	223	d->timer.data = (ulong) d;
	224	d->timer.function = dummy_timer;
	225	d->timer.expires = jiffies + HZ;
	226	add_timer(&d->timer);
	227	d->bufpool = NULL; /* defer to aoeblk_gdalloc */
	228	d->tgt = d->targets;
	229	INIT_LIST_HEAD(&d->bufq);
	230	d->sysminor = sysminor;
	231	d->aoemajor = AOEMAJOR(sysminor);
	232	d->aoeminor = AOEMINOR(sysminor);
	233	d->mintimer = MINTIMER;
	234	d->next = devlist;
	235	devlist = d;
	236	out:
3ae1c24e	237	spin_unlock_irqrestore(&devlist_lock, flags);
1da177e4 LT	238	return d;
	239	}
	240
	241	static void
9bb237b6	242	freetgt(struct aoedev d, struct aoetgt t)
1da177e4	243	{
e407a7f6 EC	244	struct frame f, e;
e407a7f6 EC	245
68e0d42f EC	246	f = t->frames;
68e0d42f EC	247	e = f + t->nframes;
9bb237b6 EC	248	for (; f < e; f++)
9bb237b6 EC	249	skbfree(f->skb);
68e0d42f EC	250	kfree(t->frames);
	251	kfree(t);
	252	}
	253
1da177e4 LT	254	void
	255	aoedev_exit(void)
	256	{
	257	struct aoedev *d;
	258	ulong flags;
	259
1da177e4 LT	260	while ((d = devlist)) {
	261	devlist = d->next;
	262
	263	spin_lock_irqsave(&d->lock, flags);
	264	aoedev_downdev(d);
3ae1c24e	265	d->flags \|= DEVFL_TKILL;
1da177e4 LT	266	spin_unlock_irqrestore(&d->lock, flags);
	267
	268	del_timer_sync(&d->timer);
	269	aoedev_freedev(d);
	270	}
	271	}
	272
	273	int __init
	274	aoedev_init(void)
	275	{
1da177e4 LT	276	return 0;
1da177e4 LT	277	}