drivers/block/aoe/aoedev.c

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