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