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 }