block: move stats from disk to part0
[linux-2.6.git] / drivers / block / aoe / aoecmd.c
1 /* Copyright (c) 2007 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 <linux/genhd.h>
12 #include <linux/moduleparam.h>
13 #include <net/net_namespace.h>
14 #include <asm/unaligned.h>
15 #include "aoe.h"
16
17 static int aoe_deadsecs = 60 * 3;
18 module_param(aoe_deadsecs, int, 0644);
19 MODULE_PARM_DESC(aoe_deadsecs, "After aoe_deadsecs seconds, give up and fail dev.");
20
21 static int aoe_maxout = 16;
22 module_param(aoe_maxout, int, 0644);
23 MODULE_PARM_DESC(aoe_maxout,
24         "Only aoe_maxout outstanding packets for every MAC on eX.Y.");
25
26 static struct sk_buff *
27 new_skb(ulong len)
28 {
29         struct sk_buff *skb;
30
31         skb = alloc_skb(len, GFP_ATOMIC);
32         if (skb) {
33                 skb_reset_mac_header(skb);
34                 skb_reset_network_header(skb);
35                 skb->protocol = __constant_htons(ETH_P_AOE);
36                 skb->priority = 0;
37                 skb->next = skb->prev = NULL;
38
39                 /* tell the network layer not to perform IP checksums
40                  * or to get the NIC to do it
41                  */
42                 skb->ip_summed = CHECKSUM_NONE;
43         }
44         return skb;
45 }
46
47 static struct frame *
48 getframe(struct aoetgt *t, int tag)
49 {
50         struct frame *f, *e;
51
52         f = t->frames;
53         e = f + t->nframes;
54         for (; f<e; f++)
55                 if (f->tag == tag)
56                         return f;
57         return NULL;
58 }
59
60 /*
61  * Leave the top bit clear so we have tagspace for userland.
62  * The bottom 16 bits are the xmit tick for rexmit/rttavg processing.
63  * This driver reserves tag -1 to mean "unused frame."
64  */
65 static int
66 newtag(struct aoetgt *t)
67 {
68         register ulong n;
69
70         n = jiffies & 0xffff;
71         return n |= (++t->lasttag & 0x7fff) << 16;
72 }
73
74 static int
75 aoehdr_atainit(struct aoedev *d, struct aoetgt *t, struct aoe_hdr *h)
76 {
77         u32 host_tag = newtag(t);
78
79         memcpy(h->src, t->ifp->nd->dev_addr, sizeof h->src);
80         memcpy(h->dst, t->addr, sizeof h->dst);
81         h->type = __constant_cpu_to_be16(ETH_P_AOE);
82         h->verfl = AOE_HVER;
83         h->major = cpu_to_be16(d->aoemajor);
84         h->minor = d->aoeminor;
85         h->cmd = AOECMD_ATA;
86         h->tag = cpu_to_be32(host_tag);
87
88         return host_tag;
89 }
90
91 static inline void
92 put_lba(struct aoe_atahdr *ah, sector_t lba)
93 {
94         ah->lba0 = lba;
95         ah->lba1 = lba >>= 8;
96         ah->lba2 = lba >>= 8;
97         ah->lba3 = lba >>= 8;
98         ah->lba4 = lba >>= 8;
99         ah->lba5 = lba >>= 8;
100 }
101
102 static void
103 ifrotate(struct aoetgt *t)
104 {
105         t->ifp++;
106         if (t->ifp >= &t->ifs[NAOEIFS] || t->ifp->nd == NULL)
107                 t->ifp = t->ifs;
108         if (t->ifp->nd == NULL) {
109                 printk(KERN_INFO "aoe: no interface to rotate to\n");
110                 BUG();
111         }
112 }
113
114 static void
115 skb_pool_put(struct aoedev *d, struct sk_buff *skb)
116 {
117         if (!d->skbpool_hd)
118                 d->skbpool_hd = skb;
119         else
120                 d->skbpool_tl->next = skb;
121         d->skbpool_tl = skb;
122 }
123
124 static struct sk_buff *
125 skb_pool_get(struct aoedev *d)
126 {
127         struct sk_buff *skb;
128
129         skb = d->skbpool_hd;
130         if (skb && atomic_read(&skb_shinfo(skb)->dataref) == 1) {
131                 d->skbpool_hd = skb->next;
132                 skb->next = NULL;
133                 return skb;
134         }
135         if (d->nskbpool < NSKBPOOLMAX
136         && (skb = new_skb(ETH_ZLEN))) {
137                 d->nskbpool++;
138                 return skb;
139         }
140         return NULL;
141 }
142
143 /* freeframe is where we do our load balancing so it's a little hairy. */
144 static struct frame *
145 freeframe(struct aoedev *d)
146 {
147         struct frame *f, *e, *rf;
148         struct aoetgt **t;
149         struct sk_buff *skb;
150
151         if (d->targets[0] == NULL) {    /* shouldn't happen, but I'm paranoid */
152                 printk(KERN_ERR "aoe: NULL TARGETS!\n");
153                 return NULL;
154         }
155         t = d->tgt;
156         t++;
157         if (t >= &d->targets[NTARGETS] || !*t)
158                 t = d->targets;
159         for (;;) {
160                 if ((*t)->nout < (*t)->maxout
161                 && t != d->htgt
162                 && (*t)->ifp->nd) {
163                         rf = NULL;
164                         f = (*t)->frames;
165                         e = f + (*t)->nframes;
166                         for (; f < e; f++) {
167                                 if (f->tag != FREETAG)
168                                         continue;
169                                 skb = f->skb;
170                                 if (!skb
171                                 && !(f->skb = skb = new_skb(ETH_ZLEN)))
172                                         continue;
173                                 if (atomic_read(&skb_shinfo(skb)->dataref)
174                                         != 1) {
175                                         if (!rf)
176                                                 rf = f;
177                                         continue;
178                                 }
179 gotone:                         skb_shinfo(skb)->nr_frags = skb->data_len = 0;
180                                 skb_trim(skb, 0);
181                                 d->tgt = t;
182                                 ifrotate(*t);
183                                 return f;
184                         }
185                         /* Work can be done, but the network layer is
186                            holding our precious packets.  Try to grab
187                            one from the pool. */
188                         f = rf;
189                         if (f == NULL) {        /* more paranoia */
190                                 printk(KERN_ERR
191                                         "aoe: freeframe: %s.\n",
192                                         "unexpected null rf");
193                                 d->flags |= DEVFL_KICKME;
194                                 return NULL;
195                         }
196                         skb = skb_pool_get(d);
197                         if (skb) {
198                                 skb_pool_put(d, f->skb);
199                                 f->skb = skb;
200                                 goto gotone;
201                         }
202                         (*t)->dataref++;
203                         if ((*t)->nout == 0)
204                                 d->flags |= DEVFL_KICKME;
205                 }
206                 if (t == d->tgt)        /* we've looped and found nada */
207                         break;
208                 t++;
209                 if (t >= &d->targets[NTARGETS] || !*t)
210                         t = d->targets;
211         }
212         return NULL;
213 }
214
215 static int
216 aoecmd_ata_rw(struct aoedev *d)
217 {
218         struct frame *f;
219         struct aoe_hdr *h;
220         struct aoe_atahdr *ah;
221         struct buf *buf;
222         struct bio_vec *bv;
223         struct aoetgt *t;
224         struct sk_buff *skb;
225         ulong bcnt;
226         char writebit, extbit;
227
228         writebit = 0x10;
229         extbit = 0x4;
230
231         f = freeframe(d);
232         if (f == NULL)
233                 return 0;
234         t = *d->tgt;
235         buf = d->inprocess;
236         bv = buf->bv;
237         bcnt = t->ifp->maxbcnt;
238         if (bcnt == 0)
239                 bcnt = DEFAULTBCNT;
240         if (bcnt > buf->bv_resid)
241                 bcnt = buf->bv_resid;
242         /* initialize the headers & frame */
243         skb = f->skb;
244         h = (struct aoe_hdr *) skb_mac_header(skb);
245         ah = (struct aoe_atahdr *) (h+1);
246         skb_put(skb, sizeof *h + sizeof *ah);
247         memset(h, 0, skb->len);
248         f->tag = aoehdr_atainit(d, t, h);
249         t->nout++;
250         f->waited = 0;
251         f->buf = buf;
252         f->bufaddr = page_address(bv->bv_page) + buf->bv_off;
253         f->bcnt = bcnt;
254         f->lba = buf->sector;
255
256         /* set up ata header */
257         ah->scnt = bcnt >> 9;
258         put_lba(ah, buf->sector);
259         if (d->flags & DEVFL_EXT) {
260                 ah->aflags |= AOEAFL_EXT;
261         } else {
262                 extbit = 0;
263                 ah->lba3 &= 0x0f;
264                 ah->lba3 |= 0xe0;       /* LBA bit + obsolete 0xa0 */
265         }
266         if (bio_data_dir(buf->bio) == WRITE) {
267                 skb_fill_page_desc(skb, 0, bv->bv_page, buf->bv_off, bcnt);
268                 ah->aflags |= AOEAFL_WRITE;
269                 skb->len += bcnt;
270                 skb->data_len = bcnt;
271                 t->wpkts++;
272         } else {
273                 t->rpkts++;
274                 writebit = 0;
275         }
276
277         ah->cmdstat = WIN_READ | writebit | extbit;
278
279         /* mark all tracking fields and load out */
280         buf->nframesout += 1;
281         buf->bv_off += bcnt;
282         buf->bv_resid -= bcnt;
283         buf->resid -= bcnt;
284         buf->sector += bcnt >> 9;
285         if (buf->resid == 0) {
286                 d->inprocess = NULL;
287         } else if (buf->bv_resid == 0) {
288                 buf->bv = ++bv;
289                 buf->bv_resid = bv->bv_len;
290                 WARN_ON(buf->bv_resid == 0);
291                 buf->bv_off = bv->bv_offset;
292         }
293
294         skb->dev = t->ifp->nd;
295         skb = skb_clone(skb, GFP_ATOMIC);
296         if (skb) {
297                 if (d->sendq_hd)
298                         d->sendq_tl->next = skb;
299                 else
300                         d->sendq_hd = skb;
301                 d->sendq_tl = skb;
302         }
303         return 1;
304 }
305
306 /* some callers cannot sleep, and they can call this function,
307  * transmitting the packets later, when interrupts are on
308  */
309 static struct sk_buff *
310 aoecmd_cfg_pkts(ushort aoemajor, unsigned char aoeminor, struct sk_buff **tail)
311 {
312         struct aoe_hdr *h;
313         struct aoe_cfghdr *ch;
314         struct sk_buff *skb, *sl, *sl_tail;
315         struct net_device *ifp;
316
317         sl = sl_tail = NULL;
318
319         read_lock(&dev_base_lock);
320         for_each_netdev(&init_net, ifp) {
321                 dev_hold(ifp);
322                 if (!is_aoe_netif(ifp))
323                         goto cont;
324
325                 skb = new_skb(sizeof *h + sizeof *ch);
326                 if (skb == NULL) {
327                         printk(KERN_INFO "aoe: skb alloc failure\n");
328                         goto cont;
329                 }
330                 skb_put(skb, sizeof *h + sizeof *ch);
331                 skb->dev = ifp;
332                 if (sl_tail == NULL)
333                         sl_tail = skb;
334                 h = (struct aoe_hdr *) skb_mac_header(skb);
335                 memset(h, 0, sizeof *h + sizeof *ch);
336
337                 memset(h->dst, 0xff, sizeof h->dst);
338                 memcpy(h->src, ifp->dev_addr, sizeof h->src);
339                 h->type = __constant_cpu_to_be16(ETH_P_AOE);
340                 h->verfl = AOE_HVER;
341                 h->major = cpu_to_be16(aoemajor);
342                 h->minor = aoeminor;
343                 h->cmd = AOECMD_CFG;
344
345                 skb->next = sl;
346                 sl = skb;
347 cont:
348                 dev_put(ifp);
349         }
350         read_unlock(&dev_base_lock);
351
352         if (tail != NULL)
353                 *tail = sl_tail;
354         return sl;
355 }
356
357 static void
358 resend(struct aoedev *d, struct aoetgt *t, struct frame *f)
359 {
360         struct sk_buff *skb;
361         struct aoe_hdr *h;
362         struct aoe_atahdr *ah;
363         char buf[128];
364         u32 n;
365
366         ifrotate(t);
367         n = newtag(t);
368         skb = f->skb;
369         h = (struct aoe_hdr *) skb_mac_header(skb);
370         ah = (struct aoe_atahdr *) (h+1);
371
372         snprintf(buf, sizeof buf,
373                 "%15s e%ld.%d oldtag=%08x@%08lx newtag=%08x "
374                 "s=%012llx d=%012llx nout=%d\n",
375                 "retransmit", d->aoemajor, d->aoeminor, f->tag, jiffies, n,
376                 mac_addr(h->src),
377                 mac_addr(h->dst), t->nout);
378         aoechr_error(buf);
379
380         f->tag = n;
381         h->tag = cpu_to_be32(n);
382         memcpy(h->dst, t->addr, sizeof h->dst);
383         memcpy(h->src, t->ifp->nd->dev_addr, sizeof h->src);
384
385         switch (ah->cmdstat) {
386         default:
387                 break;
388         case WIN_READ:
389         case WIN_READ_EXT:
390         case WIN_WRITE:
391         case WIN_WRITE_EXT:
392                 put_lba(ah, f->lba);
393
394                 n = f->bcnt;
395                 if (n > DEFAULTBCNT)
396                         n = DEFAULTBCNT;
397                 ah->scnt = n >> 9;
398                 if (ah->aflags & AOEAFL_WRITE) {
399                         skb_fill_page_desc(skb, 0, virt_to_page(f->bufaddr),
400                                 offset_in_page(f->bufaddr), n);
401                         skb->len = sizeof *h + sizeof *ah + n;
402                         skb->data_len = n;
403                 }
404         }
405         skb->dev = t->ifp->nd;
406         skb = skb_clone(skb, GFP_ATOMIC);
407         if (skb == NULL)
408                 return;
409         if (d->sendq_hd)
410                 d->sendq_tl->next = skb;
411         else
412                 d->sendq_hd = skb;
413         d->sendq_tl = skb;
414 }
415
416 static int
417 tsince(int tag)
418 {
419         int n;
420
421         n = jiffies & 0xffff;
422         n -= tag & 0xffff;
423         if (n < 0)
424                 n += 1<<16;
425         return n;
426 }
427
428 static struct aoeif *
429 getif(struct aoetgt *t, struct net_device *nd)
430 {
431         struct aoeif *p, *e;
432
433         p = t->ifs;
434         e = p + NAOEIFS;
435         for (; p < e; p++)
436                 if (p->nd == nd)
437                         return p;
438         return NULL;
439 }
440
441 static struct aoeif *
442 addif(struct aoetgt *t, struct net_device *nd)
443 {
444         struct aoeif *p;
445
446         p = getif(t, NULL);
447         if (!p)
448                 return NULL;
449         p->nd = nd;
450         p->maxbcnt = DEFAULTBCNT;
451         p->lost = 0;
452         p->lostjumbo = 0;
453         return p;
454 }
455
456 static void
457 ejectif(struct aoetgt *t, struct aoeif *ifp)
458 {
459         struct aoeif *e;
460         ulong n;
461
462         e = t->ifs + NAOEIFS - 1;
463         n = (e - ifp) * sizeof *ifp;
464         memmove(ifp, ifp+1, n);
465         e->nd = NULL;
466 }
467
468 static int
469 sthtith(struct aoedev *d)
470 {
471         struct frame *f, *e, *nf;
472         struct sk_buff *skb;
473         struct aoetgt *ht = *d->htgt;
474
475         f = ht->frames;
476         e = f + ht->nframes;
477         for (; f < e; f++) {
478                 if (f->tag == FREETAG)
479                         continue;
480                 nf = freeframe(d);
481                 if (!nf)
482                         return 0;
483                 skb = nf->skb;
484                 *nf = *f;
485                 f->skb = skb;
486                 f->tag = FREETAG;
487                 nf->waited = 0;
488                 ht->nout--;
489                 (*d->tgt)->nout++;
490                 resend(d, *d->tgt, nf);
491         }
492         /* he's clean, he's useless.  take away his interfaces */
493         memset(ht->ifs, 0, sizeof ht->ifs);
494         d->htgt = NULL;
495         return 1;
496 }
497
498 static inline unsigned char
499 ata_scnt(unsigned char *packet) {
500         struct aoe_hdr *h;
501         struct aoe_atahdr *ah;
502
503         h = (struct aoe_hdr *) packet;
504         ah = (struct aoe_atahdr *) (h+1);
505         return ah->scnt;
506 }
507
508 static void
509 rexmit_timer(ulong vp)
510 {
511         struct aoedev *d;
512         struct aoetgt *t, **tt, **te;
513         struct aoeif *ifp;
514         struct frame *f, *e;
515         struct sk_buff *sl;
516         register long timeout;
517         ulong flags, n;
518
519         d = (struct aoedev *) vp;
520         sl = NULL;
521
522         /* timeout is always ~150% of the moving average */
523         timeout = d->rttavg;
524         timeout += timeout >> 1;
525
526         spin_lock_irqsave(&d->lock, flags);
527
528         if (d->flags & DEVFL_TKILL) {
529                 spin_unlock_irqrestore(&d->lock, flags);
530                 return;
531         }
532         tt = d->targets;
533         te = tt + NTARGETS;
534         for (; tt < te && *tt; tt++) {
535                 t = *tt;
536                 f = t->frames;
537                 e = f + t->nframes;
538                 for (; f < e; f++) {
539                         if (f->tag == FREETAG
540                         || tsince(f->tag) < timeout)
541                                 continue;
542                         n = f->waited += timeout;
543                         n /= HZ;
544                         if (n > aoe_deadsecs) {
545                                 /* waited too long.  device failure. */
546                                 aoedev_downdev(d);
547                                 break;
548                         }
549
550                         if (n > HELPWAIT /* see if another target can help */
551                         && (tt != d->targets || d->targets[1]))
552                                 d->htgt = tt;
553
554                         if (t->nout == t->maxout) {
555                                 if (t->maxout > 1)
556                                         t->maxout--;
557                                 t->lastwadj = jiffies;
558                         }
559
560                         ifp = getif(t, f->skb->dev);
561                         if (ifp && ++ifp->lost > (t->nframes << 1)
562                         && (ifp != t->ifs || t->ifs[1].nd)) {
563                                 ejectif(t, ifp);
564                                 ifp = NULL;
565                         }
566
567                         if (ata_scnt(skb_mac_header(f->skb)) > DEFAULTBCNT / 512
568                         && ifp && ++ifp->lostjumbo > (t->nframes << 1)
569                         && ifp->maxbcnt != DEFAULTBCNT) {
570                                 printk(KERN_INFO
571                                         "aoe: e%ld.%d: "
572                                         "too many lost jumbo on "
573                                         "%s:%012llx - "
574                                         "falling back to %d frames.\n",
575                                         d->aoemajor, d->aoeminor,
576                                         ifp->nd->name, mac_addr(t->addr),
577                                         DEFAULTBCNT);
578                                 ifp->maxbcnt = 0;
579                         }
580                         resend(d, t, f);
581                 }
582
583                 /* window check */
584                 if (t->nout == t->maxout
585                 && t->maxout < t->nframes
586                 && (jiffies - t->lastwadj)/HZ > 10) {
587                         t->maxout++;
588                         t->lastwadj = jiffies;
589                 }
590         }
591
592         if (d->sendq_hd) {
593                 n = d->rttavg <<= 1;
594                 if (n > MAXTIMER)
595                         d->rttavg = MAXTIMER;
596         }
597
598         if (d->flags & DEVFL_KICKME || d->htgt) {
599                 d->flags &= ~DEVFL_KICKME;
600                 aoecmd_work(d);
601         }
602
603         sl = d->sendq_hd;
604         d->sendq_hd = d->sendq_tl = NULL;
605
606         d->timer.expires = jiffies + TIMERTICK;
607         add_timer(&d->timer);
608
609         spin_unlock_irqrestore(&d->lock, flags);
610
611         aoenet_xmit(sl);
612 }
613
614 /* enters with d->lock held */
615 void
616 aoecmd_work(struct aoedev *d)
617 {
618         struct buf *buf;
619 loop:
620         if (d->htgt && !sthtith(d))
621                 return;
622         if (d->inprocess == NULL) {
623                 if (list_empty(&d->bufq))
624                         return;
625                 buf = container_of(d->bufq.next, struct buf, bufs);
626                 list_del(d->bufq.next);
627                 d->inprocess = buf;
628         }
629         if (aoecmd_ata_rw(d))
630                 goto loop;
631 }
632
633 /* this function performs work that has been deferred until sleeping is OK
634  */
635 void
636 aoecmd_sleepwork(struct work_struct *work)
637 {
638         struct aoedev *d = container_of(work, struct aoedev, work);
639
640         if (d->flags & DEVFL_GDALLOC)
641                 aoeblk_gdalloc(d);
642
643         if (d->flags & DEVFL_NEWSIZE) {
644                 struct block_device *bd;
645                 unsigned long flags;
646                 u64 ssize;
647
648                 ssize = get_capacity(d->gd);
649                 bd = bdget_disk(d->gd, 0);
650
651                 if (bd) {
652                         mutex_lock(&bd->bd_inode->i_mutex);
653                         i_size_write(bd->bd_inode, (loff_t)ssize<<9);
654                         mutex_unlock(&bd->bd_inode->i_mutex);
655                         bdput(bd);
656                 }
657                 spin_lock_irqsave(&d->lock, flags);
658                 d->flags |= DEVFL_UP;
659                 d->flags &= ~DEVFL_NEWSIZE;
660                 spin_unlock_irqrestore(&d->lock, flags);
661         }
662 }
663
664 static void
665 ataid_complete(struct aoedev *d, struct aoetgt *t, unsigned char *id)
666 {
667         u64 ssize;
668         u16 n;
669
670         /* word 83: command set supported */
671         n = get_unaligned_le16(&id[83 << 1]);
672
673         /* word 86: command set/feature enabled */
674         n |= get_unaligned_le16(&id[86 << 1]);
675
676         if (n & (1<<10)) {      /* bit 10: LBA 48 */
677                 d->flags |= DEVFL_EXT;
678
679                 /* word 100: number lba48 sectors */
680                 ssize = get_unaligned_le64(&id[100 << 1]);
681
682                 /* set as in ide-disk.c:init_idedisk_capacity */
683                 d->geo.cylinders = ssize;
684                 d->geo.cylinders /= (255 * 63);
685                 d->geo.heads = 255;
686                 d->geo.sectors = 63;
687         } else {
688                 d->flags &= ~DEVFL_EXT;
689
690                 /* number lba28 sectors */
691                 ssize = get_unaligned_le32(&id[60 << 1]);
692
693                 /* NOTE: obsolete in ATA 6 */
694                 d->geo.cylinders = get_unaligned_le16(&id[54 << 1]);
695                 d->geo.heads = get_unaligned_le16(&id[55 << 1]);
696                 d->geo.sectors = get_unaligned_le16(&id[56 << 1]);
697         }
698
699         if (d->ssize != ssize)
700                 printk(KERN_INFO
701                         "aoe: %012llx e%ld.%d v%04x has %llu sectors\n",
702                         mac_addr(t->addr),
703                         d->aoemajor, d->aoeminor,
704                         d->fw_ver, (long long)ssize);
705         d->ssize = ssize;
706         d->geo.start = 0;
707         if (d->flags & (DEVFL_GDALLOC|DEVFL_NEWSIZE))
708                 return;
709         if (d->gd != NULL) {
710                 set_capacity(d->gd, ssize);
711                 d->flags |= DEVFL_NEWSIZE;
712         } else
713                 d->flags |= DEVFL_GDALLOC;
714         schedule_work(&d->work);
715 }
716
717 static void
718 calc_rttavg(struct aoedev *d, int rtt)
719 {
720         register long n;
721
722         n = rtt;
723         if (n < 0) {
724                 n = -rtt;
725                 if (n < MINTIMER)
726                         n = MINTIMER;
727                 else if (n > MAXTIMER)
728                         n = MAXTIMER;
729                 d->mintimer += (n - d->mintimer) >> 1;
730         } else if (n < d->mintimer)
731                 n = d->mintimer;
732         else if (n > MAXTIMER)
733                 n = MAXTIMER;
734
735         /* g == .25; cf. Congestion Avoidance and Control, Jacobson & Karels; 1988 */
736         n -= d->rttavg;
737         d->rttavg += n >> 2;
738 }
739
740 static struct aoetgt *
741 gettgt(struct aoedev *d, char *addr)
742 {
743         struct aoetgt **t, **e;
744
745         t = d->targets;
746         e = t + NTARGETS;
747         for (; t < e && *t; t++)
748                 if (memcmp((*t)->addr, addr, sizeof((*t)->addr)) == 0)
749                         return *t;
750         return NULL;
751 }
752
753 static inline void
754 diskstats(struct gendisk *disk, struct bio *bio, ulong duration, sector_t sector)
755 {
756         unsigned long n_sect = bio->bi_size >> 9;
757         const int rw = bio_data_dir(bio);
758         struct hd_struct *part;
759         int cpu;
760
761         cpu = part_stat_lock();
762         part = disk_map_sector_rcu(disk, sector);
763
764         part_stat_inc(cpu, part, ios[rw]);
765         part_stat_add(cpu, part, ticks[rw], duration);
766         part_stat_add(cpu, part, sectors[rw], n_sect);
767         part_stat_add(cpu, part, io_ticks, duration);
768
769         part_stat_unlock();
770 }
771
772 void
773 aoecmd_ata_rsp(struct sk_buff *skb)
774 {
775         struct aoedev *d;
776         struct aoe_hdr *hin, *hout;
777         struct aoe_atahdr *ahin, *ahout;
778         struct frame *f;
779         struct buf *buf;
780         struct sk_buff *sl;
781         struct aoetgt *t;
782         struct aoeif *ifp;
783         register long n;
784         ulong flags;
785         char ebuf[128];
786         u16 aoemajor;
787
788         hin = (struct aoe_hdr *) skb_mac_header(skb);
789         aoemajor = get_unaligned_be16(&hin->major);
790         d = aoedev_by_aoeaddr(aoemajor, hin->minor);
791         if (d == NULL) {
792                 snprintf(ebuf, sizeof ebuf, "aoecmd_ata_rsp: ata response "
793                         "for unknown device %d.%d\n",
794                          aoemajor, hin->minor);
795                 aoechr_error(ebuf);
796                 return;
797         }
798
799         spin_lock_irqsave(&d->lock, flags);
800
801         n = get_unaligned_be32(&hin->tag);
802         t = gettgt(d, hin->src);
803         if (t == NULL) {
804                 printk(KERN_INFO "aoe: can't find target e%ld.%d:%012llx\n",
805                         d->aoemajor, d->aoeminor, mac_addr(hin->src));
806                 spin_unlock_irqrestore(&d->lock, flags);
807                 return;
808         }
809         f = getframe(t, n);
810         if (f == NULL) {
811                 calc_rttavg(d, -tsince(n));
812                 spin_unlock_irqrestore(&d->lock, flags);
813                 snprintf(ebuf, sizeof ebuf,
814                         "%15s e%d.%d    tag=%08x@%08lx\n",
815                         "unexpected rsp",
816                         get_unaligned_be16(&hin->major),
817                         hin->minor,
818                         get_unaligned_be32(&hin->tag),
819                         jiffies);
820                 aoechr_error(ebuf);
821                 return;
822         }
823
824         calc_rttavg(d, tsince(f->tag));
825
826         ahin = (struct aoe_atahdr *) (hin+1);
827         hout = (struct aoe_hdr *) skb_mac_header(f->skb);
828         ahout = (struct aoe_atahdr *) (hout+1);
829         buf = f->buf;
830
831         if (ahin->cmdstat & 0xa9) {     /* these bits cleared on success */
832                 printk(KERN_ERR
833                         "aoe: ata error cmd=%2.2Xh stat=%2.2Xh from e%ld.%d\n",
834                         ahout->cmdstat, ahin->cmdstat,
835                         d->aoemajor, d->aoeminor);
836                 if (buf)
837                         buf->flags |= BUFFL_FAIL;
838         } else {
839                 if (d->htgt && t == *d->htgt) /* I'll help myself, thank you. */
840                         d->htgt = NULL;
841                 n = ahout->scnt << 9;
842                 switch (ahout->cmdstat) {
843                 case WIN_READ:
844                 case WIN_READ_EXT:
845                         if (skb->len - sizeof *hin - sizeof *ahin < n) {
846                                 printk(KERN_ERR
847                                         "aoe: %s.  skb->len=%d need=%ld\n",
848                                         "runt data size in read", skb->len, n);
849                                 /* fail frame f?  just returning will rexmit. */
850                                 spin_unlock_irqrestore(&d->lock, flags);
851                                 return;
852                         }
853                         memcpy(f->bufaddr, ahin+1, n);
854                 case WIN_WRITE:
855                 case WIN_WRITE_EXT:
856                         ifp = getif(t, skb->dev);
857                         if (ifp) {
858                                 ifp->lost = 0;
859                                 if (n > DEFAULTBCNT)
860                                         ifp->lostjumbo = 0;
861                         }
862                         if (f->bcnt -= n) {
863                                 f->lba += n >> 9;
864                                 f->bufaddr += n;
865                                 resend(d, t, f);
866                                 goto xmit;
867                         }
868                         break;
869                 case WIN_IDENTIFY:
870                         if (skb->len - sizeof *hin - sizeof *ahin < 512) {
871                                 printk(KERN_INFO
872                                         "aoe: runt data size in ataid.  skb->len=%d\n",
873                                         skb->len);
874                                 spin_unlock_irqrestore(&d->lock, flags);
875                                 return;
876                         }
877                         ataid_complete(d, t, (char *) (ahin+1));
878                         break;
879                 default:
880                         printk(KERN_INFO
881                                 "aoe: unrecognized ata command %2.2Xh for %d.%d\n",
882                                 ahout->cmdstat,
883                                 get_unaligned_be16(&hin->major),
884                                 hin->minor);
885                 }
886         }
887
888         if (buf && --buf->nframesout == 0 && buf->resid == 0) {
889                 diskstats(d->gd, buf->bio, jiffies - buf->stime, buf->sector);
890                 n = (buf->flags & BUFFL_FAIL) ? -EIO : 0;
891                 bio_endio(buf->bio, n);
892                 mempool_free(buf, d->bufpool);
893         }
894
895         f->buf = NULL;
896         f->tag = FREETAG;
897         t->nout--;
898
899         aoecmd_work(d);
900 xmit:
901         sl = d->sendq_hd;
902         d->sendq_hd = d->sendq_tl = NULL;
903
904         spin_unlock_irqrestore(&d->lock, flags);
905         aoenet_xmit(sl);
906 }
907
908 void
909 aoecmd_cfg(ushort aoemajor, unsigned char aoeminor)
910 {
911         struct sk_buff *sl;
912
913         sl = aoecmd_cfg_pkts(aoemajor, aoeminor, NULL);
914
915         aoenet_xmit(sl);
916 }
917  
918 struct sk_buff *
919 aoecmd_ata_id(struct aoedev *d)
920 {
921         struct aoe_hdr *h;
922         struct aoe_atahdr *ah;
923         struct frame *f;
924         struct sk_buff *skb;
925         struct aoetgt *t;
926
927         f = freeframe(d);
928         if (f == NULL)
929                 return NULL;
930
931         t = *d->tgt;
932
933         /* initialize the headers & frame */
934         skb = f->skb;
935         h = (struct aoe_hdr *) skb_mac_header(skb);
936         ah = (struct aoe_atahdr *) (h+1);
937         skb_put(skb, sizeof *h + sizeof *ah);
938         memset(h, 0, skb->len);
939         f->tag = aoehdr_atainit(d, t, h);
940         t->nout++;
941         f->waited = 0;
942
943         /* set up ata header */
944         ah->scnt = 1;
945         ah->cmdstat = WIN_IDENTIFY;
946         ah->lba3 = 0xa0;
947
948         skb->dev = t->ifp->nd;
949
950         d->rttavg = MAXTIMER;
951         d->timer.function = rexmit_timer;
952
953         return skb_clone(skb, GFP_ATOMIC);
954 }
955  
956 static struct aoetgt *
957 addtgt(struct aoedev *d, char *addr, ulong nframes)
958 {
959         struct aoetgt *t, **tt, **te;
960         struct frame *f, *e;
961
962         tt = d->targets;
963         te = tt + NTARGETS;
964         for (; tt < te && *tt; tt++)
965                 ;
966
967         if (tt == te) {
968                 printk(KERN_INFO
969                         "aoe: device addtgt failure; too many targets\n");
970                 return NULL;
971         }
972         t = kcalloc(1, sizeof *t, GFP_ATOMIC);
973         f = kcalloc(nframes, sizeof *f, GFP_ATOMIC);
974         if (!t || !f) {
975                 kfree(f);
976                 kfree(t);
977                 printk(KERN_INFO "aoe: cannot allocate memory to add target\n");
978                 return NULL;
979         }
980
981         t->nframes = nframes;
982         t->frames = f;
983         e = f + nframes;
984         for (; f < e; f++)
985                 f->tag = FREETAG;
986         memcpy(t->addr, addr, sizeof t->addr);
987         t->ifp = t->ifs;
988         t->maxout = t->nframes;
989         return *tt = t;
990 }
991
992 void
993 aoecmd_cfg_rsp(struct sk_buff *skb)
994 {
995         struct aoedev *d;
996         struct aoe_hdr *h;
997         struct aoe_cfghdr *ch;
998         struct aoetgt *t;
999         struct aoeif *ifp;
1000         ulong flags, sysminor, aoemajor;
1001         struct sk_buff *sl;
1002         u16 n;
1003
1004         h = (struct aoe_hdr *) skb_mac_header(skb);
1005         ch = (struct aoe_cfghdr *) (h+1);
1006
1007         /*
1008          * Enough people have their dip switches set backwards to
1009          * warrant a loud message for this special case.
1010          */
1011         aoemajor = get_unaligned_be16(&h->major);
1012         if (aoemajor == 0xfff) {
1013                 printk(KERN_ERR "aoe: Warning: shelf address is all ones.  "
1014                         "Check shelf dip switches.\n");
1015                 return;
1016         }
1017
1018         sysminor = SYSMINOR(aoemajor, h->minor);
1019         if (sysminor * AOE_PARTITIONS + AOE_PARTITIONS > MINORMASK) {
1020                 printk(KERN_INFO "aoe: e%ld.%d: minor number too large\n",
1021                         aoemajor, (int) h->minor);
1022                 return;
1023         }
1024
1025         n = be16_to_cpu(ch->bufcnt);
1026         if (n > aoe_maxout)     /* keep it reasonable */
1027                 n = aoe_maxout;
1028
1029         d = aoedev_by_sysminor_m(sysminor);
1030         if (d == NULL) {
1031                 printk(KERN_INFO "aoe: device sysminor_m failure\n");
1032                 return;
1033         }
1034
1035         spin_lock_irqsave(&d->lock, flags);
1036
1037         t = gettgt(d, h->src);
1038         if (!t) {
1039                 t = addtgt(d, h->src, n);
1040                 if (!t) {
1041                         spin_unlock_irqrestore(&d->lock, flags);
1042                         return;
1043                 }
1044         }
1045         ifp = getif(t, skb->dev);
1046         if (!ifp) {
1047                 ifp = addif(t, skb->dev);
1048                 if (!ifp) {
1049                         printk(KERN_INFO
1050                                 "aoe: device addif failure; "
1051                                 "too many interfaces?\n");
1052                         spin_unlock_irqrestore(&d->lock, flags);
1053                         return;
1054                 }
1055         }
1056         if (ifp->maxbcnt) {
1057                 n = ifp->nd->mtu;
1058                 n -= sizeof (struct aoe_hdr) + sizeof (struct aoe_atahdr);
1059                 n /= 512;
1060                 if (n > ch->scnt)
1061                         n = ch->scnt;
1062                 n = n ? n * 512 : DEFAULTBCNT;
1063                 if (n != ifp->maxbcnt) {
1064                         printk(KERN_INFO
1065                                 "aoe: e%ld.%d: setting %d%s%s:%012llx\n",
1066                                 d->aoemajor, d->aoeminor, n,
1067                                 " byte data frames on ", ifp->nd->name,
1068                                 mac_addr(t->addr));
1069                         ifp->maxbcnt = n;
1070                 }
1071         }
1072
1073         /* don't change users' perspective */
1074         if (d->nopen) {
1075                 spin_unlock_irqrestore(&d->lock, flags);
1076                 return;
1077         }
1078         d->fw_ver = be16_to_cpu(ch->fwver);
1079
1080         sl = aoecmd_ata_id(d);
1081
1082         spin_unlock_irqrestore(&d->lock, flags);
1083
1084         aoenet_xmit(sl);
1085 }
1086
1087 void
1088 aoecmd_cleanslate(struct aoedev *d)
1089 {
1090         struct aoetgt **t, **te;
1091         struct aoeif *p, *e;
1092
1093         d->mintimer = MINTIMER;
1094
1095         t = d->targets;
1096         te = t + NTARGETS;
1097         for (; t < te && *t; t++) {
1098                 (*t)->maxout = (*t)->nframes;
1099                 p = (*t)->ifs;
1100                 e = p + NAOEIFS;
1101                 for (; p < e; p++) {
1102                         p->lostjumbo = 0;
1103                         p->lost = 0;
1104                         p->maxbcnt = DEFAULTBCNT;
1105                 }
1106         }
1107 }