1 /* Copyright (c) 2012 Coraid, Inc. See COPYING for GPL terms. */
4 * AoE device utility functions; maintains device list.
7 #include <linux/hdreg.h>
8 #include <linux/blkdev.h>
9 #include <linux/netdevice.h>
10 #include <linux/delay.h>
11 #include <linux/slab.h>
12 #include <linux/bitmap.h>
13 #include <linux/kdev_t.h>
14 #include <linux/moduleparam.h>
17 static void dummy_timer(ulong);
18 static void aoedev_freedev(struct aoedev *);
19 static void freetgt(struct aoedev *d, struct aoetgt *t);
20 static void skbpoolfree(struct aoedev *d);
22 static int aoe_dyndevs = 1;
23 module_param(aoe_dyndevs, int, 0644);
24 MODULE_PARM_DESC(aoe_dyndevs, "Use dynamic minor numbers for devices.");
26 static struct aoedev *devlist;
27 static DEFINE_SPINLOCK(devlist_lock);
29 /* Because some systems will have one, many, or no
33 * we need some flexibility in the way the minor numbers
34 * are allocated. So they are dynamic.
36 #define N_DEVS ((1U<<MINORBITS)/AOE_PARTITIONS)
38 static DEFINE_SPINLOCK(used_minors_lock);
39 static DECLARE_BITMAP(used_minors, N_DEVS);
42 minor_get_dyn(ulong *sysminor)
48 spin_lock_irqsave(&used_minors_lock, flags);
49 n = find_first_zero_bit(used_minors, N_DEVS);
51 set_bit(n, used_minors);
54 spin_unlock_irqrestore(&used_minors_lock, flags);
56 *sysminor = n * AOE_PARTITIONS;
61 minor_get_static(ulong *sysminor, ulong aoemaj, int aoemin)
67 /* for backwards compatibility when !aoe_dyndevs,
68 * a static number of supported slots per shelf */
72 n = aoemaj * NPERSHELF + aoemin;
73 if (aoemin >= NPERSHELF || n >= N_DEVS) {
74 pr_err("aoe: %s with e%ld.%d\n",
75 "cannot use static minor device numbers",
79 spin_lock_irqsave(&used_minors_lock, flags);
80 if (test_bit(n, used_minors)) {
81 pr_err("aoe: %s %lu\n",
82 "existing device already has static minor number",
86 set_bit(n, used_minors);
87 spin_unlock_irqrestore(&used_minors_lock, flags);
95 minor_get(ulong *sysminor, ulong aoemaj, int aoemin)
98 return minor_get_dyn(sysminor);
100 return minor_get_static(sysminor, aoemaj, aoemin);
104 minor_free(ulong minor)
108 minor /= AOE_PARTITIONS;
109 BUG_ON(minor >= N_DEVS);
111 spin_lock_irqsave(&used_minors_lock, flags);
112 BUG_ON(!test_bit(minor, used_minors));
113 clear_bit(minor, used_minors);
114 spin_unlock_irqrestore(&used_minors_lock, flags);
118 * Users who grab a pointer to the device with aoedev_by_aoeaddr
119 * automatically get a reference count and must be responsible
120 * for performing a aoedev_put. With the addition of async
121 * kthread processing I'm no longer confident that we can
122 * guarantee consistency in the face of device flushes.
124 * For the time being, we only bother to add extra references for
125 * frames sitting on the iocq. When the kthreads finish processing
126 * these frames, they will aoedev_put the device.
130 aoedev_put(struct aoedev *d)
134 spin_lock_irqsave(&devlist_lock, flags);
136 spin_unlock_irqrestore(&devlist_lock, flags);
140 dummy_timer(ulong vp)
144 d = (struct aoedev *)vp;
145 if (d->flags & DEVFL_TKILL)
147 d->timer.expires = jiffies + HZ;
148 add_timer(&d->timer);
152 aoe_failip(struct aoedev *d)
158 aoe_failbuf(d, d->ip.buf);
163 while ((bio = d->ip.nxbio)) {
164 clear_bit(BIO_UPTODATE, &bio->bi_flags);
165 d->ip.nxbio = bio->bi_next;
166 n = (unsigned long) rq->special;
167 rq->special = (void *) --n;
169 if ((unsigned long) rq->special == 0)
170 aoe_end_request(d, rq, 0);
174 aoedev_downdev(struct aoedev *d)
176 struct aoetgt *t, **tt, **te;
178 struct list_head *head, *pos, *nx;
182 d->flags &= ~DEVFL_UP;
184 /* clean out active buffers */
185 for (i = 0; i < NFACTIVE; i++) {
186 head = &d->factive[i];
187 list_for_each_safe(pos, nx, head) {
188 f = list_entry(pos, struct frame, head);
191 f->buf->nframesout--;
192 aoe_failbuf(d, f->buf);
197 /* reset window dressings */
200 for (; tt < te && (t = *tt); tt++) {
201 t->maxout = t->nframes;
205 /* clean out the in-process request (if any) */
209 /* fast fail all pending I/O */
211 while ((rq = blk_peek_request(d->blkq))) {
212 blk_start_request(rq);
213 aoe_end_request(d, rq, 1);
218 set_capacity(d->gd, 0);
222 aoedev_freedev(struct aoedev *d)
224 struct aoetgt **t, **e;
226 cancel_work_sync(&d->work);
231 blk_cleanup_queue(d->blkq);
235 for (; t < e && *t; t++)
238 mempool_destroy(d->bufpool);
240 minor_free(d->sysminor);
245 aoedev_flush(const char __user *str, size_t cnt)
248 struct aoedev *d, **dd;
249 struct aoedev *rmd = NULL;
254 if (cnt > sizeof buf)
256 if (copy_from_user(buf, str, cnt))
258 all = !strncmp(buf, "all", 3);
261 spin_lock_irqsave(&devlist_lock, flags);
265 if ((!all && (d->flags & DEVFL_UP))
266 || (d->flags & (DEVFL_GDALLOC|DEVFL_NEWSIZE))
269 spin_unlock(&d->lock);
275 d->flags |= DEVFL_TKILL;
276 spin_unlock(&d->lock);
280 spin_unlock_irqrestore(&devlist_lock, flags);
283 del_timer_sync(&d->timer);
284 aoedev_freedev(d); /* must be able to sleep */
289 /* This has been confirmed to occur once with Tms=3*1000 due to the
290 * driver changing link and not processing its transmit ring. The
291 * problem is hard enough to solve by returning an error that I'm
292 * still punting on "solving" this.
295 skbfree(struct sk_buff *skb)
297 enum { Sms = 250, Tms = 30 * 1000};
302 while (atomic_read(&skb_shinfo(skb)->dataref) != 1 && i-- > 0)
306 "aoe: %s holds ref: %s\n",
307 skb->dev ? skb->dev->name : "netif",
308 "cannot free skb -- memory leaked.");
311 skb->truesize -= skb->data_len;
312 skb_shinfo(skb)->nr_frags = skb->data_len = 0;
318 skbpoolfree(struct aoedev *d)
320 struct sk_buff *skb, *tmp;
322 skb_queue_walk_safe(&d->skbpool, skb, tmp)
325 __skb_queue_head_init(&d->skbpool);
328 /* find it or allocate it */
330 aoedev_by_aoeaddr(ulong maj, int min, int do_alloc)
337 spin_lock_irqsave(&devlist_lock, flags);
339 for (d=devlist; d; d=d->next)
340 if (d->aoemajor == maj && d->aoeminor == min) {
344 if (d || !do_alloc || minor_get(&sysminor, maj, min) < 0)
346 d = kcalloc(1, sizeof *d, GFP_ATOMIC);
349 INIT_WORK(&d->work, aoecmd_sleepwork);
350 spin_lock_init(&d->lock);
351 skb_queue_head_init(&d->skbpool);
352 init_timer(&d->timer);
353 d->timer.data = (ulong) d;
354 d->timer.function = dummy_timer;
355 d->timer.expires = jiffies + HZ;
356 add_timer(&d->timer);
357 d->bufpool = NULL; /* defer to aoeblk_gdalloc */
360 for (i = 0; i < NFACTIVE; i++)
361 INIT_LIST_HEAD(&d->factive[i]);
362 d->sysminor = sysminor;
365 d->mintimer = MINTIMER;
369 spin_unlock_irqrestore(&devlist_lock, flags);
374 freetgt(struct aoedev *d, struct aoetgt *t)
377 struct list_head *pos, *nx, *head;
380 for (ifp = t->ifs; ifp < &t->ifs[NAOEIFS]; ++ifp) {
387 list_for_each_safe(pos, nx, head) {
389 f = list_entry(pos, struct frame, head);
403 while ((d = devlist)) {
406 spin_lock_irqsave(&d->lock, flags);
408 d->flags |= DEVFL_TKILL;
409 spin_unlock_irqrestore(&d->lock, flags);
411 del_timer_sync(&d->timer);