5c9c7c1a3d4cfd42e35caa5d662ba1742c6fd995
[linux-2.6.git] / drivers / block / aoe / aoecmd.c
1 /* Copyright (c) 2004 Coraid, Inc.  See COPYING for GPL terms. */
2 /*
3  * aoecmd.c
4  * Filesystem request handling methods
5  */
6
7 #include <linux/hdreg.h>
8 #include <linux/blkdev.h>
9 #include <linux/skbuff.h>
10 #include <linux/netdevice.h>
11 #include <asm/unaligned.h>
12 #include "aoe.h"
13
14 #define TIMERTICK (HZ / 10)
15 #define MINTIMER (2 * TIMERTICK)
16 #define MAXTIMER (HZ << 1)
17 #define MAXWAIT (60 * 3)        /* After MAXWAIT seconds, give up and fail dev */
18
19 static struct sk_buff *
20 new_skb(struct net_device *if_dev, ulong len)
21 {
22         struct sk_buff *skb;
23
24         skb = alloc_skb(len, GFP_ATOMIC);
25         if (skb) {
26                 skb->nh.raw = skb->mac.raw = skb->data;
27                 skb->dev = if_dev;
28                 skb->protocol = __constant_htons(ETH_P_AOE);
29                 skb->priority = 0;
30                 skb_put(skb, len);
31                 skb->next = skb->prev = NULL;
32
33                 /* tell the network layer not to perform IP checksums
34                  * or to get the NIC to do it
35                  */
36                 skb->ip_summed = CHECKSUM_NONE;
37         }
38         return skb;
39 }
40
41 static struct sk_buff *
42 skb_prepare(struct aoedev *d, struct frame *f)
43 {
44         struct sk_buff *skb;
45         char *p;
46
47         skb = new_skb(d->ifp, f->ndata + f->writedatalen);
48         if (!skb) {
49                 printk(KERN_INFO "aoe: skb_prepare: failure to allocate skb\n");
50                 return NULL;
51         }
52
53         p = skb->mac.raw;
54         memcpy(p, f->data, f->ndata);
55
56         if (f->writedatalen) {
57                 p += sizeof(struct aoe_hdr) + sizeof(struct aoe_atahdr);
58                 memcpy(p, f->bufaddr, f->writedatalen);
59         }
60
61         return skb;
62 }
63
64 static struct frame *
65 getframe(struct aoedev *d, int tag)
66 {
67         struct frame *f, *e;
68
69         f = d->frames;
70         e = f + d->nframes;
71         for (; f<e; f++)
72                 if (f->tag == tag)
73                         return f;
74         return NULL;
75 }
76
77 /*
78  * Leave the top bit clear so we have tagspace for userland.
79  * The bottom 16 bits are the xmit tick for rexmit/rttavg processing.
80  * This driver reserves tag -1 to mean "unused frame."
81  */
82 static int
83 newtag(struct aoedev *d)
84 {
85         register ulong n;
86
87         n = jiffies & 0xffff;
88         return n |= (++d->lasttag & 0x7fff) << 16;
89 }
90
91 static int
92 aoehdr_atainit(struct aoedev *d, struct aoe_hdr *h)
93 {
94         u32 host_tag = newtag(d);
95
96         memcpy(h->src, d->ifp->dev_addr, sizeof h->src);
97         memcpy(h->dst, d->addr, sizeof h->dst);
98         h->type = __constant_cpu_to_be16(ETH_P_AOE);
99         h->verfl = AOE_HVER;
100         h->major = cpu_to_be16(d->aoemajor);
101         h->minor = d->aoeminor;
102         h->cmd = AOECMD_ATA;
103         h->tag = cpu_to_be32(host_tag);
104
105         return host_tag;
106 }
107
108 static void
109 aoecmd_ata_rw(struct aoedev *d, struct frame *f)
110 {
111         struct aoe_hdr *h;
112         struct aoe_atahdr *ah;
113         struct buf *buf;
114         struct sk_buff *skb;
115         ulong bcnt;
116         register sector_t sector;
117         char writebit, extbit;
118
119         writebit = 0x10;
120         extbit = 0x4;
121
122         buf = d->inprocess;
123
124         sector = buf->sector;
125         bcnt = buf->bv_resid;
126         if (bcnt > MAXATADATA)
127                 bcnt = MAXATADATA;
128
129         /* initialize the headers & frame */
130         h = (struct aoe_hdr *) f->data;
131         ah = (struct aoe_atahdr *) (h+1);
132         f->ndata = sizeof *h + sizeof *ah;
133         memset(h, 0, f->ndata);
134         f->tag = aoehdr_atainit(d, h);
135         f->waited = 0;
136         f->buf = buf;
137         f->bufaddr = buf->bufaddr;
138
139         /* set up ata header */
140         ah->scnt = bcnt >> 9;
141         ah->lba0 = sector;
142         ah->lba1 = sector >>= 8;
143         ah->lba2 = sector >>= 8;
144         ah->lba3 = sector >>= 8;
145         if (d->flags & DEVFL_EXT) {
146                 ah->aflags |= AOEAFL_EXT;
147                 ah->lba4 = sector >>= 8;
148                 ah->lba5 = sector >>= 8;
149         } else {
150                 extbit = 0;
151                 ah->lba3 &= 0x0f;
152                 ah->lba3 |= 0xe0;       /* LBA bit + obsolete 0xa0 */
153         }
154
155         if (bio_data_dir(buf->bio) == WRITE) {
156                 ah->aflags |= AOEAFL_WRITE;
157                 f->writedatalen = bcnt;
158         } else {
159                 writebit = 0;
160                 f->writedatalen = 0;
161         }
162
163         ah->cmdstat = WIN_READ | writebit | extbit;
164
165         /* mark all tracking fields and load out */
166         buf->nframesout += 1;
167         buf->bufaddr += bcnt;
168         buf->bv_resid -= bcnt;
169 /* printk(KERN_INFO "aoe: bv_resid=%ld\n", buf->bv_resid); */
170         buf->resid -= bcnt;
171         buf->sector += bcnt >> 9;
172         if (buf->resid == 0) {
173                 d->inprocess = NULL;
174         } else if (buf->bv_resid == 0) {
175                 buf->bv++;
176                 buf->bv_resid = buf->bv->bv_len;
177                 buf->bufaddr = page_address(buf->bv->bv_page) + buf->bv->bv_offset;
178         }
179
180         skb = skb_prepare(d, f);
181         if (skb) {
182                 skb->next = NULL;
183                 if (d->sendq_hd)
184                         d->sendq_tl->next = skb;
185                 else
186                         d->sendq_hd = skb;
187                 d->sendq_tl = skb;
188         }
189 }
190
191 /* enters with d->lock held */
192 void
193 aoecmd_work(struct aoedev *d)
194 {
195         struct frame *f;
196         struct buf *buf;
197 loop:
198         f = getframe(d, FREETAG);
199         if (f == NULL)
200                 return;
201         if (d->inprocess == NULL) {
202                 if (list_empty(&d->bufq))
203                         return;
204                 buf = container_of(d->bufq.next, struct buf, bufs);
205                 list_del(d->bufq.next);
206 /*printk(KERN_INFO "aoecmd_work: bi_size=%ld\n", buf->bio->bi_size); */
207                 d->inprocess = buf;
208         }
209         aoecmd_ata_rw(d, f);
210         goto loop;
211 }
212
213 static void
214 rexmit(struct aoedev *d, struct frame *f)
215 {
216         struct sk_buff *skb;
217         struct aoe_hdr *h;
218         char buf[128];
219         u32 n;
220
221         n = newtag(d);
222
223         snprintf(buf, sizeof buf,
224                 "%15s e%ld.%ld oldtag=%08x@%08lx newtag=%08x\n",
225                 "retransmit",
226                 d->aoemajor, d->aoeminor, f->tag, jiffies, n);
227         aoechr_error(buf);
228
229         h = (struct aoe_hdr *) f->data;
230         f->tag = n;
231         h->tag = cpu_to_be32(n);
232
233         skb = skb_prepare(d, f);
234         if (skb) {
235                 skb->next = NULL;
236                 if (d->sendq_hd)
237                         d->sendq_tl->next = skb;
238                 else
239                         d->sendq_hd = skb;
240                 d->sendq_tl = skb;
241         }
242 }
243
244 static int
245 tsince(int tag)
246 {
247         int n;
248
249         n = jiffies & 0xffff;
250         n -= tag & 0xffff;
251         if (n < 0)
252                 n += 1<<16;
253         return n;
254 }
255
256 static void
257 rexmit_timer(ulong vp)
258 {
259         struct aoedev *d;
260         struct frame *f, *e;
261         struct sk_buff *sl;
262         register long timeout;
263         ulong flags, n;
264
265         d = (struct aoedev *) vp;
266         sl = NULL;
267
268         /* timeout is always ~150% of the moving average */
269         timeout = d->rttavg;
270         timeout += timeout >> 1;
271
272         spin_lock_irqsave(&d->lock, flags);
273
274         if (d->flags & DEVFL_TKILL) {
275 tdie:           spin_unlock_irqrestore(&d->lock, flags);
276                 return;
277         }
278         f = d->frames;
279         e = f + d->nframes;
280         for (; f<e; f++) {
281                 if (f->tag != FREETAG && tsince(f->tag) >= timeout) {
282                         n = f->waited += timeout;
283                         n /= HZ;
284                         if (n > MAXWAIT) { /* waited too long.  device failure. */
285                                 aoedev_downdev(d);
286                                 goto tdie;
287                         }
288                         rexmit(d, f);
289                 }
290         }
291
292         sl = d->sendq_hd;
293         d->sendq_hd = d->sendq_tl = NULL;
294         if (sl) {
295                 n = d->rttavg <<= 1;
296                 if (n > MAXTIMER)
297                         d->rttavg = MAXTIMER;
298         }
299
300         d->timer.expires = jiffies + TIMERTICK;
301         add_timer(&d->timer);
302
303         spin_unlock_irqrestore(&d->lock, flags);
304
305         aoenet_xmit(sl);
306 }
307
308 static void
309 ataid_complete(struct aoedev *d, unsigned char *id)
310 {
311         u64 ssize;
312         u16 n;
313
314         /* word 83: command set supported */
315         n = le16_to_cpu(get_unaligned((__le16 *) &id[83<<1]));
316
317         /* word 86: command set/feature enabled */
318         n |= le16_to_cpu(get_unaligned((__le16 *) &id[86<<1]));
319
320         if (n & (1<<10)) {      /* bit 10: LBA 48 */
321                 d->flags |= DEVFL_EXT;
322
323                 /* word 100: number lba48 sectors */
324                 ssize = le64_to_cpu(get_unaligned((__le64 *) &id[100<<1]));
325
326                 /* set as in ide-disk.c:init_idedisk_capacity */
327                 d->geo.cylinders = ssize;
328                 d->geo.cylinders /= (255 * 63);
329                 d->geo.heads = 255;
330                 d->geo.sectors = 63;
331         } else {
332                 d->flags &= ~DEVFL_EXT;
333
334                 /* number lba28 sectors */
335                 ssize = le32_to_cpu(get_unaligned((__le32 *) &id[60<<1]));
336
337                 /* NOTE: obsolete in ATA 6 */
338                 d->geo.cylinders = le16_to_cpu(get_unaligned((__le16 *) &id[54<<1]));
339                 d->geo.heads = le16_to_cpu(get_unaligned((__le16 *) &id[55<<1]));
340                 d->geo.sectors = le16_to_cpu(get_unaligned((__le16 *) &id[56<<1]));
341         }
342         d->ssize = ssize;
343         d->geo.start = 0;
344         if (d->gd != NULL) {
345                 d->gd->capacity = ssize;
346                 d->flags |= DEVFL_UP;
347                 return;
348         }
349         if (d->flags & DEVFL_WORKON) {
350                 printk(KERN_INFO "aoe: ataid_complete: can't schedule work, it's already on!  "
351                         "(This really shouldn't happen).\n");
352                 return;
353         }
354         INIT_WORK(&d->work, aoeblk_gdalloc, d);
355         schedule_work(&d->work);
356         d->flags |= DEVFL_WORKON;
357 }
358
359 static void
360 calc_rttavg(struct aoedev *d, int rtt)
361 {
362         register long n;
363
364         n = rtt;
365         if (n < MINTIMER)
366                 n = MINTIMER;
367         else if (n > MAXTIMER)
368                 n = MAXTIMER;
369
370         /* g == .25; cf. Congestion Avoidance and Control, Jacobson & Karels; 1988 */
371         n -= d->rttavg;
372         d->rttavg += n >> 2;
373 }
374
375 void
376 aoecmd_ata_rsp(struct sk_buff *skb)
377 {
378         struct aoedev *d;
379         struct aoe_hdr *hin;
380         struct aoe_atahdr *ahin, *ahout;
381         struct frame *f;
382         struct buf *buf;
383         struct sk_buff *sl;
384         register long n;
385         ulong flags;
386         char ebuf[128];
387         u16 aoemajor;
388
389         hin = (struct aoe_hdr *) skb->mac.raw;
390         aoemajor = be16_to_cpu(hin->major);
391         d = aoedev_by_aoeaddr(aoemajor, hin->minor);
392         if (d == NULL) {
393                 snprintf(ebuf, sizeof ebuf, "aoecmd_ata_rsp: ata response "
394                         "for unknown device %d.%d\n",
395                          aoemajor, hin->minor);
396                 aoechr_error(ebuf);
397                 return;
398         }
399
400         spin_lock_irqsave(&d->lock, flags);
401
402         f = getframe(d, be32_to_cpu(hin->tag));
403         if (f == NULL) {
404                 spin_unlock_irqrestore(&d->lock, flags);
405                 snprintf(ebuf, sizeof ebuf,
406                         "%15s e%d.%d    tag=%08x@%08lx\n",
407                         "unexpected rsp",
408                         be16_to_cpu(hin->major),
409                         hin->minor,
410                         be32_to_cpu(hin->tag),
411                         jiffies);
412                 aoechr_error(ebuf);
413                 return;
414         }
415
416         calc_rttavg(d, tsince(f->tag));
417
418         ahin = (struct aoe_atahdr *) (hin+1);
419         ahout = (struct aoe_atahdr *) (f->data + sizeof(struct aoe_hdr));
420         buf = f->buf;
421
422         if (ahin->cmdstat & 0xa9) {     /* these bits cleared on success */
423                 printk(KERN_CRIT "aoe: aoecmd_ata_rsp: ata error cmd=%2.2Xh "
424                         "stat=%2.2Xh from e%ld.%ld\n", 
425                         ahout->cmdstat, ahin->cmdstat,
426                         d->aoemajor, d->aoeminor);
427                 if (buf)
428                         buf->flags |= BUFFL_FAIL;
429         } else {
430                 switch (ahout->cmdstat) {
431                 case WIN_READ:
432                 case WIN_READ_EXT:
433                         n = ahout->scnt << 9;
434                         if (skb->len - sizeof *hin - sizeof *ahin < n) {
435                                 printk(KERN_CRIT "aoe: aoecmd_ata_rsp: runt "
436                                         "ata data size in read.  skb->len=%d\n",
437                                         skb->len);
438                                 /* fail frame f?  just returning will rexmit. */
439                                 spin_unlock_irqrestore(&d->lock, flags);
440                                 return;
441                         }
442                         memcpy(f->bufaddr, ahin+1, n);
443                 case WIN_WRITE:
444                 case WIN_WRITE_EXT:
445                         break;
446                 case WIN_IDENTIFY:
447                         if (skb->len - sizeof *hin - sizeof *ahin < 512) {
448                                 printk(KERN_INFO "aoe: aoecmd_ata_rsp: runt data size "
449                                         "in ataid.  skb->len=%d\n", skb->len);
450                                 spin_unlock_irqrestore(&d->lock, flags);
451                                 return;
452                         }
453                         ataid_complete(d, (char *) (ahin+1));
454                         /* d->flags |= DEVFL_WC_UPDATE; */
455                         break;
456                 default:
457                         printk(KERN_INFO "aoe: aoecmd_ata_rsp: unrecognized "
458                                "outbound ata command %2.2Xh for %d.%d\n", 
459                                ahout->cmdstat,
460                                be16_to_cpu(hin->major),
461                                hin->minor);
462                 }
463         }
464
465         if (buf) {
466                 buf->nframesout -= 1;
467                 if (buf->nframesout == 0 && buf->resid == 0) {
468                         unsigned long duration = jiffies - buf->start_time;
469                         unsigned long n_sect = buf->bio->bi_size >> 9;
470                         struct gendisk *disk = d->gd;
471
472                         if (bio_data_dir(buf->bio) == WRITE) {
473                                 disk_stat_inc(disk, writes);
474                                 disk_stat_add(disk, write_ticks, duration);
475                                 disk_stat_add(disk, write_sectors, n_sect);
476                         } else {
477                                 disk_stat_inc(disk, reads);
478                                 disk_stat_add(disk, read_ticks, duration);
479                                 disk_stat_add(disk, read_sectors, n_sect);
480                         }
481                         disk_stat_add(disk, io_ticks, duration);
482                         n = (buf->flags & BUFFL_FAIL) ? -EIO : 0;
483                         bio_endio(buf->bio, buf->bio->bi_size, n);
484                         mempool_free(buf, d->bufpool);
485                 }
486         }
487
488         f->buf = NULL;
489         f->tag = FREETAG;
490
491         aoecmd_work(d);
492
493         sl = d->sendq_hd;
494         d->sendq_hd = d->sendq_tl = NULL;
495
496         spin_unlock_irqrestore(&d->lock, flags);
497
498         aoenet_xmit(sl);
499 }
500
501 void
502 aoecmd_cfg(ushort aoemajor, unsigned char aoeminor)
503 {
504         struct aoe_hdr *h;
505         struct aoe_cfghdr *ch;
506         struct sk_buff *skb, *sl;
507         struct net_device *ifp;
508
509         sl = NULL;
510
511         read_lock(&dev_base_lock);
512         for (ifp = dev_base; ifp; dev_put(ifp), ifp = ifp->next) {
513                 dev_hold(ifp);
514                 if (!is_aoe_netif(ifp))
515                         continue;
516
517                 skb = new_skb(ifp, sizeof *h + sizeof *ch);
518                 if (skb == NULL) {
519                         printk(KERN_INFO "aoe: aoecmd_cfg: skb alloc failure\n");
520                         continue;
521                 }
522                 h = (struct aoe_hdr *) skb->mac.raw;
523                 memset(h, 0, sizeof *h + sizeof *ch);
524
525                 memset(h->dst, 0xff, sizeof h->dst);
526                 memcpy(h->src, ifp->dev_addr, sizeof h->src);
527                 h->type = __constant_cpu_to_be16(ETH_P_AOE);
528                 h->verfl = AOE_HVER;
529                 h->major = cpu_to_be16(aoemajor);
530                 h->minor = aoeminor;
531                 h->cmd = AOECMD_CFG;
532
533                 skb->next = sl;
534                 sl = skb;
535         }
536         read_unlock(&dev_base_lock);
537
538         aoenet_xmit(sl);
539 }
540  
541 /*
542  * Since we only call this in one place (and it only prepares one frame)
543  * we just return the skb.  Usually we'd chain it up to the aoedev sendq.
544  */
545 static struct sk_buff *
546 aoecmd_ata_id(struct aoedev *d)
547 {
548         struct aoe_hdr *h;
549         struct aoe_atahdr *ah;
550         struct frame *f;
551         struct sk_buff *skb;
552
553         f = getframe(d, FREETAG);
554         if (f == NULL) {
555                 printk(KERN_CRIT "aoe: aoecmd_ata_id: can't get a frame.  "
556                         "This shouldn't happen.\n");
557                 return NULL;
558         }
559
560         /* initialize the headers & frame */
561         h = (struct aoe_hdr *) f->data;
562         ah = (struct aoe_atahdr *) (h+1);
563         f->ndata = sizeof *h + sizeof *ah;
564         memset(h, 0, f->ndata);
565         f->tag = aoehdr_atainit(d, h);
566         f->waited = 0;
567         f->writedatalen = 0;
568
569         /* this message initializes the device, so we reset the rttavg */
570         d->rttavg = MAXTIMER;
571
572         /* set up ata header */
573         ah->scnt = 1;
574         ah->cmdstat = WIN_IDENTIFY;
575         ah->lba3 = 0xa0;
576
577         skb = skb_prepare(d, f);
578
579         /* we now want to start the rexmit tracking */
580         d->flags &= ~DEVFL_TKILL;
581         d->timer.data = (ulong) d;
582         d->timer.function = rexmit_timer;
583         d->timer.expires = jiffies + TIMERTICK;
584         add_timer(&d->timer);
585
586         return skb;
587 }
588  
589 void
590 aoecmd_cfg_rsp(struct sk_buff *skb)
591 {
592         struct aoedev *d;
593         struct aoe_hdr *h;
594         struct aoe_cfghdr *ch;
595         ulong flags, sysminor, aoemajor;
596         u16 bufcnt;
597         struct sk_buff *sl;
598         enum { MAXFRAMES = 8 };
599
600         h = (struct aoe_hdr *) skb->mac.raw;
601         ch = (struct aoe_cfghdr *) (h+1);
602
603         /*
604          * Enough people have their dip switches set backwards to
605          * warrant a loud message for this special case.
606          */
607         aoemajor = be16_to_cpu(h->major);
608         if (aoemajor == 0xfff) {
609                 printk(KERN_CRIT "aoe: aoecmd_cfg_rsp: Warning: shelf "
610                         "address is all ones.  Check shelf dip switches\n");
611                 return;
612         }
613
614         sysminor = SYSMINOR(aoemajor, h->minor);
615         if (sysminor * AOE_PARTITIONS + AOE_PARTITIONS > MINORMASK) {
616                 printk(KERN_INFO
617                         "aoe: e%ld.%d: minor number too large\n", 
618                         aoemajor, (int) h->minor);
619                 return;
620         }
621
622         bufcnt = be16_to_cpu(ch->bufcnt);
623         if (bufcnt > MAXFRAMES) /* keep it reasonable */
624                 bufcnt = MAXFRAMES;
625
626         d = aoedev_set(sysminor, h->src, skb->dev, bufcnt);
627         if (d == NULL) {
628                 printk(KERN_INFO "aoe: aoecmd_cfg_rsp: device set failure\n");
629                 return;
630         }
631
632         spin_lock_irqsave(&d->lock, flags);
633
634         if (d->flags & (DEVFL_UP | DEVFL_CLOSEWAIT)) {
635                 spin_unlock_irqrestore(&d->lock, flags);
636                 return;
637         }
638
639         d->fw_ver = be16_to_cpu(ch->fwver);
640
641         /* we get here only if the device is new */
642         sl = aoecmd_ata_id(d);
643
644         spin_unlock_irqrestore(&d->lock, flags);
645
646         aoenet_xmit(sl);
647 }
648