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