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 } 278