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