drivers/block/aoe/aoecmd.c

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