blob: e774c50b684273557767da0f72693f981eabac95 [file] [log] [blame]
Ed Cashinca47bbd2013-07-03 15:09:06 -07001/* Copyright (c) 2013 Coraid, Inc. See COPYING for GPL terms. */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002/*
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>
Ed L. Cashin9bb237b2008-02-08 04:20:05 -080010#include <linux/delay.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090011#include <linux/slab.h>
Ed Cashin0c966212012-10-04 17:16:40 -070012#include <linux/bitmap.h>
13#include <linux/kdev_t.h>
Ed Cashin4bcce1a2012-10-04 17:16:42 -070014#include <linux/moduleparam.h>
Andy Shevchenkoa88c1f02013-09-11 14:25:44 -070015#include <linux/string.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070016#include "aoe.h"
17
Ed L. Cashin262bf542008-02-08 04:20:03 -080018static void dummy_timer(ulong);
Ed L. Cashin9bb237b2008-02-08 04:20:05 -080019static void freetgt(struct aoedev *d, struct aoetgt *t);
20static void skbpoolfree(struct aoedev *d);
Ed L. Cashin262bf542008-02-08 04:20:03 -080021
Ed Cashin08b60622012-10-04 17:16:47 -070022static int aoe_dyndevs = 1;
Ed Cashin4bcce1a2012-10-04 17:16:42 -070023module_param(aoe_dyndevs, int, 0644);
24MODULE_PARM_DESC(aoe_dyndevs, "Use dynamic minor numbers for devices.");
25
Linus Torvalds1da177e2005-04-16 15:20:36 -070026static struct aoedev *devlist;
Andrew Morton476aed32008-02-08 04:20:10 -080027static DEFINE_SPINLOCK(devlist_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -070028
Ed Cashin0c966212012-10-04 17:16:40 -070029/* Because some systems will have one, many, or no
30 * - partitions,
31 * - slots per shelf,
32 * - or shelves,
33 * we need some flexibility in the way the minor numbers
34 * are allocated. So they are dynamic.
35 */
36#define N_DEVS ((1U<<MINORBITS)/AOE_PARTITIONS)
37
38static DEFINE_SPINLOCK(used_minors_lock);
39static DECLARE_BITMAP(used_minors, N_DEVS);
40
41static int
Ed Cashin4bcce1a2012-10-04 17:16:42 -070042minor_get_dyn(ulong *sysminor)
Ed Cashin0c966212012-10-04 17:16:40 -070043{
44 ulong flags;
45 ulong n;
46 int error = 0;
47
48 spin_lock_irqsave(&used_minors_lock, flags);
49 n = find_first_zero_bit(used_minors, N_DEVS);
50 if (n < N_DEVS)
51 set_bit(n, used_minors);
52 else
53 error = -1;
54 spin_unlock_irqrestore(&used_minors_lock, flags);
55
Ed Cashin4bcce1a2012-10-04 17:16:42 -070056 *sysminor = n * AOE_PARTITIONS;
Ed Cashin0c966212012-10-04 17:16:40 -070057 return error;
58}
59
Ed Cashin4bcce1a2012-10-04 17:16:42 -070060static int
61minor_get_static(ulong *sysminor, ulong aoemaj, int aoemin)
62{
63 ulong flags;
64 ulong n;
65 int error = 0;
66 enum {
67 /* for backwards compatibility when !aoe_dyndevs,
68 * a static number of supported slots per shelf */
69 NPERSHELF = 16,
70 };
71
Ed Cashine0b2bba2012-12-17 16:04:03 -080072 if (aoemin >= NPERSHELF) {
73 pr_err("aoe: %s %d slots per shelf\n",
74 "static minor device numbers support only",
75 NPERSHELF);
76 error = -1;
77 goto out;
78 }
79
Ed Cashin4bcce1a2012-10-04 17:16:42 -070080 n = aoemaj * NPERSHELF + aoemin;
Ed Cashine0b2bba2012-12-17 16:04:03 -080081 if (n >= N_DEVS) {
Ed Cashin4bcce1a2012-10-04 17:16:42 -070082 pr_err("aoe: %s with e%ld.%d\n",
83 "cannot use static minor device numbers",
84 aoemaj, aoemin);
85 error = -1;
Ed Cashine0b2bba2012-12-17 16:04:03 -080086 goto out;
Ed Cashin4bcce1a2012-10-04 17:16:42 -070087 }
88
Ed Cashine0b2bba2012-12-17 16:04:03 -080089 spin_lock_irqsave(&used_minors_lock, flags);
90 if (test_bit(n, used_minors)) {
91 pr_err("aoe: %s %lu\n",
92 "existing device already has static minor number",
93 n);
94 error = -1;
95 } else
96 set_bit(n, used_minors);
97 spin_unlock_irqrestore(&used_minors_lock, flags);
Ed Cashinb91316f2012-12-17 16:04:06 -080098 *sysminor = n * AOE_PARTITIONS;
Ed Cashine0b2bba2012-12-17 16:04:03 -080099out:
Ed Cashin4bcce1a2012-10-04 17:16:42 -0700100 return error;
101}
102
103static int
104minor_get(ulong *sysminor, ulong aoemaj, int aoemin)
105{
106 if (aoe_dyndevs)
107 return minor_get_dyn(sysminor);
108 else
109 return minor_get_static(sysminor, aoemaj, aoemin);
110}
111
Ed Cashin0c966212012-10-04 17:16:40 -0700112static void
113minor_free(ulong minor)
114{
115 ulong flags;
116
117 minor /= AOE_PARTITIONS;
118 BUG_ON(minor >= N_DEVS);
119
120 spin_lock_irqsave(&used_minors_lock, flags);
121 BUG_ON(!test_bit(minor, used_minors));
122 clear_bit(minor, used_minors);
123 spin_unlock_irqrestore(&used_minors_lock, flags);
124}
125
Ed Cashin69cf2d852012-10-04 17:16:23 -0700126/*
Ed Cashin0c966212012-10-04 17:16:40 -0700127 * Users who grab a pointer to the device with aoedev_by_aoeaddr
128 * automatically get a reference count and must be responsible
129 * for performing a aoedev_put. With the addition of async
130 * kthread processing I'm no longer confident that we can
Ed Cashin69cf2d852012-10-04 17:16:23 -0700131 * guarantee consistency in the face of device flushes.
132 *
133 * For the time being, we only bother to add extra references for
134 * frames sitting on the iocq. When the kthreads finish processing
135 * these frames, they will aoedev_put the device.
136 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700137
Ed Cashin69cf2d852012-10-04 17:16:23 -0700138void
139aoedev_put(struct aoedev *d)
140{
141 ulong flags;
142
143 spin_lock_irqsave(&devlist_lock, flags);
144 d->ref--;
145 spin_unlock_irqrestore(&devlist_lock, flags);
146}
147
Ed L. Cashin3ae1c242006-01-19 13:46:19 -0500148static void
149dummy_timer(ulong vp)
150{
151 struct aoedev *d;
152
153 d = (struct aoedev *)vp;
154 if (d->flags & DEVFL_TKILL)
155 return;
156 d->timer.expires = jiffies + HZ;
157 add_timer(&d->timer);
158}
159
Ed Cashin69cf2d852012-10-04 17:16:23 -0700160static void
161aoe_failip(struct aoedev *d)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700162{
Ed Cashin69cf2d852012-10-04 17:16:23 -0700163 struct request *rq;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700164 struct bio *bio;
Ed Cashin69cf2d852012-10-04 17:16:23 -0700165 unsigned long n;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700166
Ed Cashin69cf2d852012-10-04 17:16:23 -0700167 aoe_failbuf(d, d->ip.buf);
168
169 rq = d->ip.rq;
170 if (rq == NULL)
Ed Cashin896831f2012-10-04 17:16:21 -0700171 return;
Ed Cashin69cf2d852012-10-04 17:16:23 -0700172 while ((bio = d->ip.nxbio)) {
173 clear_bit(BIO_UPTODATE, &bio->bi_flags);
174 d->ip.nxbio = bio->bi_next;
175 n = (unsigned long) rq->special;
176 rq->special = (void *) --n;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700177 }
Ed Cashin69cf2d852012-10-04 17:16:23 -0700178 if ((unsigned long) rq->special == 0)
179 aoe_end_request(d, rq, 0);
Ed Cashin896831f2012-10-04 17:16:21 -0700180}
181
Ed Cashin3fc9b032012-12-17 16:03:51 -0800182static void
183downdev_frame(struct list_head *pos)
184{
185 struct frame *f;
186
187 f = list_entry(pos, struct frame, head);
188 list_del(pos);
189 if (f->buf) {
190 f->buf->nframesout--;
191 aoe_failbuf(f->t->d, f->buf);
192 }
193 aoe_freetframe(f);
194}
195
Ed Cashin896831f2012-10-04 17:16:21 -0700196void
197aoedev_downdev(struct aoedev *d)
198{
199 struct aoetgt *t, **tt, **te;
Ed Cashin896831f2012-10-04 17:16:21 -0700200 struct list_head *head, *pos, *nx;
Ed Cashin69cf2d852012-10-04 17:16:23 -0700201 struct request *rq;
Ed Cashin896831f2012-10-04 17:16:21 -0700202 int i;
203
Ed Cashin69cf2d852012-10-04 17:16:23 -0700204 d->flags &= ~DEVFL_UP;
205
Ed Cashin3fc9b032012-12-17 16:03:51 -0800206 /* clean out active and to-be-retransmitted buffers */
Ed Cashin64a80f52012-10-04 17:16:33 -0700207 for (i = 0; i < NFACTIVE; i++) {
208 head = &d->factive[i];
Ed Cashin3fc9b032012-12-17 16:03:51 -0800209 list_for_each_safe(pos, nx, head)
210 downdev_frame(pos);
Ed Cashin64a80f52012-10-04 17:16:33 -0700211 }
Ed Cashin3fc9b032012-12-17 16:03:51 -0800212 head = &d->rexmitq;
213 list_for_each_safe(pos, nx, head)
214 downdev_frame(pos);
215
Ed Cashin64a80f52012-10-04 17:16:33 -0700216 /* reset window dressings */
Ed Cashin896831f2012-10-04 17:16:21 -0700217 tt = d->targets;
Ed Cashin71114ec2012-12-17 16:04:11 -0800218 te = tt + d->ntargets;
Ed Cashin896831f2012-10-04 17:16:21 -0700219 for (; tt < te && (t = *tt); tt++) {
Ed Cashin3a0c40d2012-12-17 16:03:43 -0800220 aoecmd_wreset(t);
Ed Cashin896831f2012-10-04 17:16:21 -0700221 t->nout = 0;
222 }
223
Ed Cashin69cf2d852012-10-04 17:16:23 -0700224 /* clean out the in-process request (if any) */
225 aoe_failip(d);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700226
Ed Cashin69cf2d852012-10-04 17:16:23 -0700227 /* fast fail all pending I/O */
228 if (d->blkq) {
229 while ((rq = blk_peek_request(d->blkq))) {
230 blk_start_request(rq);
231 aoe_end_request(d, rq, 1);
232 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700233 }
234
Linus Torvalds1da177e2005-04-16 15:20:36 -0700235 if (d->gd)
Tejun Heo80795ae2008-08-25 19:56:07 +0900236 set_capacity(d->gd, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700237}
238
Ed Cashin4ba9aa72012-12-17 16:03:30 -0800239/* return whether the user asked for this particular
240 * device to be flushed
241 */
242static int
243user_req(char *s, size_t slen, struct aoedev *d)
244{
Andy Shevchenkoa88c1f02013-09-11 14:25:44 -0700245 const char *p;
Ed Cashin4ba9aa72012-12-17 16:03:30 -0800246 size_t lim;
247
248 if (!d->gd)
249 return 0;
Andy Shevchenkoa88c1f02013-09-11 14:25:44 -0700250 p = kbasename(d->gd->disk_name);
Ed Cashin4ba9aa72012-12-17 16:03:30 -0800251 lim = sizeof(d->gd->disk_name);
252 lim -= p - d->gd->disk_name;
253 if (slen < lim)
254 lim = slen;
255
256 return !strncmp(s, p, lim);
257}
258
Ed Cashine52a2932012-12-17 16:04:09 -0800259static void
260freedev(struct aoedev *d)
261{
262 struct aoetgt **t, **e;
263 int freeing = 0;
264 unsigned long flags;
265
266 spin_lock_irqsave(&d->lock, flags);
267 if (d->flags & DEVFL_TKILL
268 && !(d->flags & DEVFL_FREEING)) {
269 d->flags |= DEVFL_FREEING;
270 freeing = 1;
271 }
272 spin_unlock_irqrestore(&d->lock, flags);
273 if (!freeing)
274 return;
275
276 del_timer_sync(&d->timer);
277 if (d->gd) {
Ed Cashine8866cf2013-09-11 14:25:40 -0700278 aoedisk_rm_debugfs(d);
Ed Cashine52a2932012-12-17 16:04:09 -0800279 aoedisk_rm_sysfs(d);
280 del_gendisk(d->gd);
281 put_disk(d->gd);
282 blk_cleanup_queue(d->blkq);
283 }
284 t = d->targets;
Ed Cashin71114ec2012-12-17 16:04:11 -0800285 e = t + d->ntargets;
Ed Cashine52a2932012-12-17 16:04:09 -0800286 for (; t < e && *t; t++)
287 freetgt(d, *t);
288 if (d->bufpool)
289 mempool_destroy(d->bufpool);
290 skbpoolfree(d);
291 minor_free(d->sysminor);
292
293 spin_lock_irqsave(&d->lock, flags);
294 d->flags |= DEVFL_FREED;
295 spin_unlock_irqrestore(&d->lock, flags);
296}
297
298enum flush_parms {
299 NOT_EXITING = 0,
300 EXITING = 1,
301};
302
303static int
304flush(const char __user *str, size_t cnt, int exiting)
Ed L. Cashin262bf542008-02-08 04:20:03 -0800305{
306 ulong flags;
307 struct aoedev *d, **dd;
Ed L. Cashin262bf542008-02-08 04:20:03 -0800308 char buf[16];
309 int all = 0;
Ed Cashin4ba9aa72012-12-17 16:03:30 -0800310 int specified = 0; /* flush a specific device */
Ed Cashine52a2932012-12-17 16:04:09 -0800311 unsigned int skipflags;
Ed L. Cashin262bf542008-02-08 04:20:03 -0800312
Ed Cashine52a2932012-12-17 16:04:09 -0800313 skipflags = DEVFL_GDALLOC | DEVFL_NEWSIZE | DEVFL_TKILL;
314
315 if (!exiting && cnt >= 3) {
Ed L. Cashin262bf542008-02-08 04:20:03 -0800316 if (cnt > sizeof buf)
317 cnt = sizeof buf;
318 if (copy_from_user(buf, str, cnt))
319 return -EFAULT;
320 all = !strncmp(buf, "all", 3);
Ed Cashin4ba9aa72012-12-17 16:03:30 -0800321 if (!all)
322 specified = 1;
Ed L. Cashin262bf542008-02-08 04:20:03 -0800323 }
324
Ed Cashine52a2932012-12-17 16:04:09 -0800325 flush_scheduled_work();
326 /* pass one: without sleeping, do aoedev_downdev */
Ed L. Cashin262bf542008-02-08 04:20:03 -0800327 spin_lock_irqsave(&devlist_lock, flags);
Ed Cashine52a2932012-12-17 16:04:09 -0800328 for (d = devlist; d; d = d->next) {
Ed L. Cashin262bf542008-02-08 04:20:03 -0800329 spin_lock(&d->lock);
Ed Cashine52a2932012-12-17 16:04:09 -0800330 if (exiting) {
331 /* unconditionally take each device down */
332 } else if (specified) {
Ed Cashin4ba9aa72012-12-17 16:03:30 -0800333 if (!user_req(buf, cnt, d))
Ed Cashine52a2932012-12-17 16:04:09 -0800334 goto cont;
Ed Cashin4ba9aa72012-12-17 16:03:30 -0800335 } else if ((!all && (d->flags & DEVFL_UP))
Ed Cashine52a2932012-12-17 16:04:09 -0800336 || d->flags & skipflags
Ed Cashin69cf2d852012-10-04 17:16:23 -0700337 || d->nopen
Ed Cashin4ba9aa72012-12-17 16:03:30 -0800338 || d->ref)
Ed Cashine52a2932012-12-17 16:04:09 -0800339 goto cont;
Ed Cashin4ba9aa72012-12-17 16:03:30 -0800340
Ed L. Cashin262bf542008-02-08 04:20:03 -0800341 aoedev_downdev(d);
342 d->flags |= DEVFL_TKILL;
Ed Cashine52a2932012-12-17 16:04:09 -0800343cont:
Ed L. Cashin262bf542008-02-08 04:20:03 -0800344 spin_unlock(&d->lock);
Ed L. Cashin262bf542008-02-08 04:20:03 -0800345 }
346 spin_unlock_irqrestore(&devlist_lock, flags);
Ed Cashine52a2932012-12-17 16:04:09 -0800347
348 /* pass two: call freedev, which might sleep,
349 * for aoedevs marked with DEVFL_TKILL
350 */
351restart:
352 spin_lock_irqsave(&devlist_lock, flags);
353 for (d = devlist; d; d = d->next) {
354 spin_lock(&d->lock);
355 if (d->flags & DEVFL_TKILL
356 && !(d->flags & DEVFL_FREEING)) {
357 spin_unlock(&d->lock);
358 spin_unlock_irqrestore(&devlist_lock, flags);
359 freedev(d);
360 goto restart;
361 }
362 spin_unlock(&d->lock);
Ed L. Cashin262bf542008-02-08 04:20:03 -0800363 }
Ed Cashine52a2932012-12-17 16:04:09 -0800364
365 /* pass three: remove aoedevs marked with DEVFL_FREED */
366 for (dd = &devlist, d = *dd; d; d = *dd) {
367 struct aoedev *doomed = NULL;
368
369 spin_lock(&d->lock);
370 if (d->flags & DEVFL_FREED) {
371 *dd = d->next;
372 doomed = d;
373 } else {
374 dd = &d->next;
375 }
376 spin_unlock(&d->lock);
Ed Cashin71114ec2012-12-17 16:04:11 -0800377 if (doomed)
378 kfree(doomed->targets);
Ed Cashine52a2932012-12-17 16:04:09 -0800379 kfree(doomed);
380 }
381 spin_unlock_irqrestore(&devlist_lock, flags);
382
Ed L. Cashin262bf542008-02-08 04:20:03 -0800383 return 0;
384}
385
Ed Cashine52a2932012-12-17 16:04:09 -0800386int
387aoedev_flush(const char __user *str, size_t cnt)
388{
389 return flush(str, cnt, NOT_EXITING);
390}
391
Ed Cashin69cf2d852012-10-04 17:16:23 -0700392/* This has been confirmed to occur once with Tms=3*1000 due to the
393 * driver changing link and not processing its transmit ring. The
394 * problem is hard enough to solve by returning an error that I'm
395 * still punting on "solving" this.
396 */
Ed L. Cashin9bb237b2008-02-08 04:20:05 -0800397static void
398skbfree(struct sk_buff *skb)
399{
Ed Cashin69cf2d852012-10-04 17:16:23 -0700400 enum { Sms = 250, Tms = 30 * 1000};
Ed L. Cashin9bb237b2008-02-08 04:20:05 -0800401 int i = Tms / Sms;
402
403 if (skb == NULL)
404 return;
405 while (atomic_read(&skb_shinfo(skb)->dataref) != 1 && i-- > 0)
406 msleep(Sms);
Roel Kluin94873112009-03-04 00:07:57 -0800407 if (i < 0) {
Ed L. Cashin9bb237b2008-02-08 04:20:05 -0800408 printk(KERN_ERR
409 "aoe: %s holds ref: %s\n",
410 skb->dev ? skb->dev->name : "netif",
411 "cannot free skb -- memory leaked.");
412 return;
413 }
Ed Cashin3d5b0602012-10-04 17:16:20 -0700414 skb->truesize -= skb->data_len;
Ed L. Cashin9bb237b2008-02-08 04:20:05 -0800415 skb_shinfo(skb)->nr_frags = skb->data_len = 0;
416 skb_trim(skb, 0);
417 dev_kfree_skb(skb);
418}
419
420static void
421skbpoolfree(struct aoedev *d)
422{
David S. Millere9bb8fb2008-09-21 22:36:49 -0700423 struct sk_buff *skb, *tmp;
Ed L. Cashin9bb237b2008-02-08 04:20:05 -0800424
David S. Millere9bb8fb2008-09-21 22:36:49 -0700425 skb_queue_walk_safe(&d->skbpool, skb, tmp)
Ed L. Cashin9bb237b2008-02-08 04:20:05 -0800426 skbfree(skb);
David S. Millere9bb8fb2008-09-21 22:36:49 -0700427
428 __skb_queue_head_init(&d->skbpool);
Ed L. Cashin9bb237b2008-02-08 04:20:05 -0800429}
430
Ed Cashin0c966212012-10-04 17:16:40 -0700431/* find it or allocate it */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700432struct aoedev *
Ed Cashin0c966212012-10-04 17:16:40 -0700433aoedev_by_aoeaddr(ulong maj, int min, int do_alloc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700434{
435 struct aoedev *d;
Ed Cashin64a80f52012-10-04 17:16:33 -0700436 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700437 ulong flags;
Ed Cashin10935d02012-12-17 16:04:04 -0800438 ulong sysminor = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700439
440 spin_lock_irqsave(&devlist_lock, flags);
441
442 for (d=devlist; d; d=d->next)
Ed Cashin0c966212012-10-04 17:16:40 -0700443 if (d->aoemajor == maj && d->aoeminor == min) {
Ed Cashine52a2932012-12-17 16:04:09 -0800444 spin_lock(&d->lock);
445 if (d->flags & DEVFL_TKILL) {
446 spin_unlock(&d->lock);
447 d = NULL;
448 goto out;
449 }
Ed Cashin69cf2d852012-10-04 17:16:23 -0700450 d->ref++;
Ed Cashine52a2932012-12-17 16:04:09 -0800451 spin_unlock(&d->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700452 break;
Ed Cashin69cf2d852012-10-04 17:16:23 -0700453 }
Ed Cashin4bcce1a2012-10-04 17:16:42 -0700454 if (d || !do_alloc || minor_get(&sysminor, maj, min) < 0)
Ed L. Cashin68e0d422008-02-08 04:20:00 -0800455 goto out;
456 d = kcalloc(1, sizeof *d, GFP_ATOMIC);
457 if (!d)
458 goto out;
Ed Cashin71114ec2012-12-17 16:04:11 -0800459 d->targets = kcalloc(NTARGETS, sizeof(*d->targets), GFP_ATOMIC);
460 if (!d->targets) {
461 kfree(d);
Dan Carpenter31279b12012-12-17 16:04:21 -0800462 d = NULL;
Ed Cashin71114ec2012-12-17 16:04:11 -0800463 goto out;
464 }
465 d->ntargets = NTARGETS;
Ed L. Cashin68e0d422008-02-08 04:20:00 -0800466 INIT_WORK(&d->work, aoecmd_sleepwork);
467 spin_lock_init(&d->lock);
David S. Millere9bb8fb2008-09-21 22:36:49 -0700468 skb_queue_head_init(&d->skbpool);
Ed L. Cashin68e0d422008-02-08 04:20:00 -0800469 init_timer(&d->timer);
470 d->timer.data = (ulong) d;
471 d->timer.function = dummy_timer;
472 d->timer.expires = jiffies + HZ;
473 add_timer(&d->timer);
474 d->bufpool = NULL; /* defer to aoeblk_gdalloc */
475 d->tgt = d->targets;
Ed Cashin69cf2d852012-10-04 17:16:23 -0700476 d->ref = 1;
Ed Cashin64a80f52012-10-04 17:16:33 -0700477 for (i = 0; i < NFACTIVE; i++)
478 INIT_LIST_HEAD(&d->factive[i]);
Ed Cashin3a0c40d2012-12-17 16:03:43 -0800479 INIT_LIST_HEAD(&d->rexmitq);
Ed L. Cashin68e0d422008-02-08 04:20:00 -0800480 d->sysminor = sysminor;
Ed Cashin0c966212012-10-04 17:16:40 -0700481 d->aoemajor = maj;
482 d->aoeminor = min;
Ed Cashin3a0c40d2012-12-17 16:03:43 -0800483 d->rttavg = RTTAVG_INIT;
484 d->rttdev = RTTDEV_INIT;
Ed L. Cashin68e0d422008-02-08 04:20:00 -0800485 d->next = devlist;
486 devlist = d;
487 out:
Ed L. Cashin3ae1c242006-01-19 13:46:19 -0500488 spin_unlock_irqrestore(&devlist_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700489 return d;
490}
491
492static void
Ed L. Cashin9bb237b2008-02-08 04:20:05 -0800493freetgt(struct aoedev *d, struct aoetgt *t)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700494{
Ed Cashin896831f2012-10-04 17:16:21 -0700495 struct frame *f;
496 struct list_head *pos, *nx, *head;
Ed Cashin1b86fda2012-10-04 17:16:34 -0700497 struct aoeif *ifp;
498
499 for (ifp = t->ifs; ifp < &t->ifs[NAOEIFS]; ++ifp) {
500 if (!ifp->nd)
501 break;
502 dev_put(ifp->nd);
503 }
Ed L. Cashine407a7f2006-09-20 14:36:49 -0400504
Ed Cashin896831f2012-10-04 17:16:21 -0700505 head = &t->ffree;
506 list_for_each_safe(pos, nx, head) {
507 list_del(pos);
508 f = list_entry(pos, struct frame, head);
Ed L. Cashin9bb237b2008-02-08 04:20:05 -0800509 skbfree(f->skb);
Ed Cashin896831f2012-10-04 17:16:21 -0700510 kfree(f);
511 }
Ed L. Cashin68e0d422008-02-08 04:20:00 -0800512 kfree(t);
513}
514
Linus Torvalds1da177e2005-04-16 15:20:36 -0700515void
516aoedev_exit(void)
517{
Ed Cashine52a2932012-12-17 16:04:09 -0800518 flush_scheduled_work();
Ed Cashine52a2932012-12-17 16:04:09 -0800519 flush(NULL, 0, EXITING);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700520}
521
522int __init
523aoedev_init(void)
524{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700525 return 0;
526}