e71bf0d0ee
disk->part[] is protected by its matching bdev's lock. However, non-critical accesses like collecting stats and printing out sysfs and proc information used to be performed without any locking. As partitions can come and go dynamically, partitions can go away underneath those non-critical accesses. As some of those accesses are writes, this theoretically can lead to silent corruption. This patch fixes the race by using RCU for the partition array and dev reference counter to hold partitions. * Rename disk->part[] to disk->__part[] to make sure no one outside genhd layer proper accesses it directly. * Use RCU for disk->__part[] dereferencing. * Implement disk_{get|put}_part() which can be used to get and put partitions from gendisk respectively. * Iterators are implemented to help iterate through all partitions safely. * Functions which require RCU readlock are marked with _rcu suffix. * Use disk_put_part() in __blkdev_put() instead of directly putting the contained kobject. Signed-off-by: Tejun Heo <tj@kernel.org> Signed-off-by: Jens Axboe <jens.axboe@oracle.com>
1106 lines
23 KiB
C
1106 lines
23 KiB
C
/* Copyright (c) 2007 Coraid, Inc. See COPYING for GPL terms. */
|
|
/*
|
|
* aoecmd.c
|
|
* Filesystem request handling methods
|
|
*/
|
|
|
|
#include <linux/hdreg.h>
|
|
#include <linux/blkdev.h>
|
|
#include <linux/skbuff.h>
|
|
#include <linux/netdevice.h>
|
|
#include <linux/genhd.h>
|
|
#include <linux/moduleparam.h>
|
|
#include <net/net_namespace.h>
|
|
#include <asm/unaligned.h>
|
|
#include "aoe.h"
|
|
|
|
static int aoe_deadsecs = 60 * 3;
|
|
module_param(aoe_deadsecs, int, 0644);
|
|
MODULE_PARM_DESC(aoe_deadsecs, "After aoe_deadsecs seconds, give up and fail dev.");
|
|
|
|
static int aoe_maxout = 16;
|
|
module_param(aoe_maxout, int, 0644);
|
|
MODULE_PARM_DESC(aoe_maxout,
|
|
"Only aoe_maxout outstanding packets for every MAC on eX.Y.");
|
|
|
|
static struct sk_buff *
|
|
new_skb(ulong len)
|
|
{
|
|
struct sk_buff *skb;
|
|
|
|
skb = alloc_skb(len, GFP_ATOMIC);
|
|
if (skb) {
|
|
skb_reset_mac_header(skb);
|
|
skb_reset_network_header(skb);
|
|
skb->protocol = __constant_htons(ETH_P_AOE);
|
|
skb->priority = 0;
|
|
skb->next = skb->prev = NULL;
|
|
|
|
/* tell the network layer not to perform IP checksums
|
|
* or to get the NIC to do it
|
|
*/
|
|
skb->ip_summed = CHECKSUM_NONE;
|
|
}
|
|
return skb;
|
|
}
|
|
|
|
static struct frame *
|
|
getframe(struct aoetgt *t, int tag)
|
|
{
|
|
struct frame *f, *e;
|
|
|
|
f = t->frames;
|
|
e = f + t->nframes;
|
|
for (; f<e; f++)
|
|
if (f->tag == tag)
|
|
return f;
|
|
return NULL;
|
|
}
|
|
|
|
/*
|
|
* Leave the top bit clear so we have tagspace for userland.
|
|
* The bottom 16 bits are the xmit tick for rexmit/rttavg processing.
|
|
* This driver reserves tag -1 to mean "unused frame."
|
|
*/
|
|
static int
|
|
newtag(struct aoetgt *t)
|
|
{
|
|
register ulong n;
|
|
|
|
n = jiffies & 0xffff;
|
|
return n |= (++t->lasttag & 0x7fff) << 16;
|
|
}
|
|
|
|
static int
|
|
aoehdr_atainit(struct aoedev *d, struct aoetgt *t, struct aoe_hdr *h)
|
|
{
|
|
u32 host_tag = newtag(t);
|
|
|
|
memcpy(h->src, t->ifp->nd->dev_addr, sizeof h->src);
|
|
memcpy(h->dst, t->addr, sizeof h->dst);
|
|
h->type = __constant_cpu_to_be16(ETH_P_AOE);
|
|
h->verfl = AOE_HVER;
|
|
h->major = cpu_to_be16(d->aoemajor);
|
|
h->minor = d->aoeminor;
|
|
h->cmd = AOECMD_ATA;
|
|
h->tag = cpu_to_be32(host_tag);
|
|
|
|
return host_tag;
|
|
}
|
|
|
|
static inline void
|
|
put_lba(struct aoe_atahdr *ah, sector_t lba)
|
|
{
|
|
ah->lba0 = lba;
|
|
ah->lba1 = lba >>= 8;
|
|
ah->lba2 = lba >>= 8;
|
|
ah->lba3 = lba >>= 8;
|
|
ah->lba4 = lba >>= 8;
|
|
ah->lba5 = lba >>= 8;
|
|
}
|
|
|
|
static void
|
|
ifrotate(struct aoetgt *t)
|
|
{
|
|
t->ifp++;
|
|
if (t->ifp >= &t->ifs[NAOEIFS] || t->ifp->nd == NULL)
|
|
t->ifp = t->ifs;
|
|
if (t->ifp->nd == NULL) {
|
|
printk(KERN_INFO "aoe: no interface to rotate to\n");
|
|
BUG();
|
|
}
|
|
}
|
|
|
|
static void
|
|
skb_pool_put(struct aoedev *d, struct sk_buff *skb)
|
|
{
|
|
if (!d->skbpool_hd)
|
|
d->skbpool_hd = skb;
|
|
else
|
|
d->skbpool_tl->next = skb;
|
|
d->skbpool_tl = skb;
|
|
}
|
|
|
|
static struct sk_buff *
|
|
skb_pool_get(struct aoedev *d)
|
|
{
|
|
struct sk_buff *skb;
|
|
|
|
skb = d->skbpool_hd;
|
|
if (skb && atomic_read(&skb_shinfo(skb)->dataref) == 1) {
|
|
d->skbpool_hd = skb->next;
|
|
skb->next = NULL;
|
|
return skb;
|
|
}
|
|
if (d->nskbpool < NSKBPOOLMAX
|
|
&& (skb = new_skb(ETH_ZLEN))) {
|
|
d->nskbpool++;
|
|
return skb;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
/* freeframe is where we do our load balancing so it's a little hairy. */
|
|
static struct frame *
|
|
freeframe(struct aoedev *d)
|
|
{
|
|
struct frame *f, *e, *rf;
|
|
struct aoetgt **t;
|
|
struct sk_buff *skb;
|
|
|
|
if (d->targets[0] == NULL) { /* shouldn't happen, but I'm paranoid */
|
|
printk(KERN_ERR "aoe: NULL TARGETS!\n");
|
|
return NULL;
|
|
}
|
|
t = d->tgt;
|
|
t++;
|
|
if (t >= &d->targets[NTARGETS] || !*t)
|
|
t = d->targets;
|
|
for (;;) {
|
|
if ((*t)->nout < (*t)->maxout
|
|
&& t != d->htgt
|
|
&& (*t)->ifp->nd) {
|
|
rf = NULL;
|
|
f = (*t)->frames;
|
|
e = f + (*t)->nframes;
|
|
for (; f < e; f++) {
|
|
if (f->tag != FREETAG)
|
|
continue;
|
|
skb = f->skb;
|
|
if (!skb
|
|
&& !(f->skb = skb = new_skb(ETH_ZLEN)))
|
|
continue;
|
|
if (atomic_read(&skb_shinfo(skb)->dataref)
|
|
!= 1) {
|
|
if (!rf)
|
|
rf = f;
|
|
continue;
|
|
}
|
|
gotone: skb_shinfo(skb)->nr_frags = skb->data_len = 0;
|
|
skb_trim(skb, 0);
|
|
d->tgt = t;
|
|
ifrotate(*t);
|
|
return f;
|
|
}
|
|
/* Work can be done, but the network layer is
|
|
holding our precious packets. Try to grab
|
|
one from the pool. */
|
|
f = rf;
|
|
if (f == NULL) { /* more paranoia */
|
|
printk(KERN_ERR
|
|
"aoe: freeframe: %s.\n",
|
|
"unexpected null rf");
|
|
d->flags |= DEVFL_KICKME;
|
|
return NULL;
|
|
}
|
|
skb = skb_pool_get(d);
|
|
if (skb) {
|
|
skb_pool_put(d, f->skb);
|
|
f->skb = skb;
|
|
goto gotone;
|
|
}
|
|
(*t)->dataref++;
|
|
if ((*t)->nout == 0)
|
|
d->flags |= DEVFL_KICKME;
|
|
}
|
|
if (t == d->tgt) /* we've looped and found nada */
|
|
break;
|
|
t++;
|
|
if (t >= &d->targets[NTARGETS] || !*t)
|
|
t = d->targets;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
static int
|
|
aoecmd_ata_rw(struct aoedev *d)
|
|
{
|
|
struct frame *f;
|
|
struct aoe_hdr *h;
|
|
struct aoe_atahdr *ah;
|
|
struct buf *buf;
|
|
struct bio_vec *bv;
|
|
struct aoetgt *t;
|
|
struct sk_buff *skb;
|
|
ulong bcnt;
|
|
char writebit, extbit;
|
|
|
|
writebit = 0x10;
|
|
extbit = 0x4;
|
|
|
|
f = freeframe(d);
|
|
if (f == NULL)
|
|
return 0;
|
|
t = *d->tgt;
|
|
buf = d->inprocess;
|
|
bv = buf->bv;
|
|
bcnt = t->ifp->maxbcnt;
|
|
if (bcnt == 0)
|
|
bcnt = DEFAULTBCNT;
|
|
if (bcnt > buf->bv_resid)
|
|
bcnt = buf->bv_resid;
|
|
/* initialize the headers & frame */
|
|
skb = f->skb;
|
|
h = (struct aoe_hdr *) skb_mac_header(skb);
|
|
ah = (struct aoe_atahdr *) (h+1);
|
|
skb_put(skb, sizeof *h + sizeof *ah);
|
|
memset(h, 0, skb->len);
|
|
f->tag = aoehdr_atainit(d, t, h);
|
|
t->nout++;
|
|
f->waited = 0;
|
|
f->buf = buf;
|
|
f->bufaddr = page_address(bv->bv_page) + buf->bv_off;
|
|
f->bcnt = bcnt;
|
|
f->lba = buf->sector;
|
|
|
|
/* set up ata header */
|
|
ah->scnt = bcnt >> 9;
|
|
put_lba(ah, buf->sector);
|
|
if (d->flags & DEVFL_EXT) {
|
|
ah->aflags |= AOEAFL_EXT;
|
|
} else {
|
|
extbit = 0;
|
|
ah->lba3 &= 0x0f;
|
|
ah->lba3 |= 0xe0; /* LBA bit + obsolete 0xa0 */
|
|
}
|
|
if (bio_data_dir(buf->bio) == WRITE) {
|
|
skb_fill_page_desc(skb, 0, bv->bv_page, buf->bv_off, bcnt);
|
|
ah->aflags |= AOEAFL_WRITE;
|
|
skb->len += bcnt;
|
|
skb->data_len = bcnt;
|
|
t->wpkts++;
|
|
} else {
|
|
t->rpkts++;
|
|
writebit = 0;
|
|
}
|
|
|
|
ah->cmdstat = WIN_READ | writebit | extbit;
|
|
|
|
/* mark all tracking fields and load out */
|
|
buf->nframesout += 1;
|
|
buf->bv_off += bcnt;
|
|
buf->bv_resid -= bcnt;
|
|
buf->resid -= bcnt;
|
|
buf->sector += bcnt >> 9;
|
|
if (buf->resid == 0) {
|
|
d->inprocess = NULL;
|
|
} else if (buf->bv_resid == 0) {
|
|
buf->bv = ++bv;
|
|
buf->bv_resid = bv->bv_len;
|
|
WARN_ON(buf->bv_resid == 0);
|
|
buf->bv_off = bv->bv_offset;
|
|
}
|
|
|
|
skb->dev = t->ifp->nd;
|
|
skb = skb_clone(skb, GFP_ATOMIC);
|
|
if (skb) {
|
|
if (d->sendq_hd)
|
|
d->sendq_tl->next = skb;
|
|
else
|
|
d->sendq_hd = skb;
|
|
d->sendq_tl = skb;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
/* some callers cannot sleep, and they can call this function,
|
|
* transmitting the packets later, when interrupts are on
|
|
*/
|
|
static struct sk_buff *
|
|
aoecmd_cfg_pkts(ushort aoemajor, unsigned char aoeminor, struct sk_buff **tail)
|
|
{
|
|
struct aoe_hdr *h;
|
|
struct aoe_cfghdr *ch;
|
|
struct sk_buff *skb, *sl, *sl_tail;
|
|
struct net_device *ifp;
|
|
|
|
sl = sl_tail = NULL;
|
|
|
|
read_lock(&dev_base_lock);
|
|
for_each_netdev(&init_net, ifp) {
|
|
dev_hold(ifp);
|
|
if (!is_aoe_netif(ifp))
|
|
goto cont;
|
|
|
|
skb = new_skb(sizeof *h + sizeof *ch);
|
|
if (skb == NULL) {
|
|
printk(KERN_INFO "aoe: skb alloc failure\n");
|
|
goto cont;
|
|
}
|
|
skb_put(skb, sizeof *h + sizeof *ch);
|
|
skb->dev = ifp;
|
|
if (sl_tail == NULL)
|
|
sl_tail = skb;
|
|
h = (struct aoe_hdr *) skb_mac_header(skb);
|
|
memset(h, 0, sizeof *h + sizeof *ch);
|
|
|
|
memset(h->dst, 0xff, sizeof h->dst);
|
|
memcpy(h->src, ifp->dev_addr, sizeof h->src);
|
|
h->type = __constant_cpu_to_be16(ETH_P_AOE);
|
|
h->verfl = AOE_HVER;
|
|
h->major = cpu_to_be16(aoemajor);
|
|
h->minor = aoeminor;
|
|
h->cmd = AOECMD_CFG;
|
|
|
|
skb->next = sl;
|
|
sl = skb;
|
|
cont:
|
|
dev_put(ifp);
|
|
}
|
|
read_unlock(&dev_base_lock);
|
|
|
|
if (tail != NULL)
|
|
*tail = sl_tail;
|
|
return sl;
|
|
}
|
|
|
|
static void
|
|
resend(struct aoedev *d, struct aoetgt *t, struct frame *f)
|
|
{
|
|
struct sk_buff *skb;
|
|
struct aoe_hdr *h;
|
|
struct aoe_atahdr *ah;
|
|
char buf[128];
|
|
u32 n;
|
|
|
|
ifrotate(t);
|
|
n = newtag(t);
|
|
skb = f->skb;
|
|
h = (struct aoe_hdr *) skb_mac_header(skb);
|
|
ah = (struct aoe_atahdr *) (h+1);
|
|
|
|
snprintf(buf, sizeof buf,
|
|
"%15s e%ld.%d oldtag=%08x@%08lx newtag=%08x "
|
|
"s=%012llx d=%012llx nout=%d\n",
|
|
"retransmit", d->aoemajor, d->aoeminor, f->tag, jiffies, n,
|
|
mac_addr(h->src),
|
|
mac_addr(h->dst), t->nout);
|
|
aoechr_error(buf);
|
|
|
|
f->tag = n;
|
|
h->tag = cpu_to_be32(n);
|
|
memcpy(h->dst, t->addr, sizeof h->dst);
|
|
memcpy(h->src, t->ifp->nd->dev_addr, sizeof h->src);
|
|
|
|
switch (ah->cmdstat) {
|
|
default:
|
|
break;
|
|
case WIN_READ:
|
|
case WIN_READ_EXT:
|
|
case WIN_WRITE:
|
|
case WIN_WRITE_EXT:
|
|
put_lba(ah, f->lba);
|
|
|
|
n = f->bcnt;
|
|
if (n > DEFAULTBCNT)
|
|
n = DEFAULTBCNT;
|
|
ah->scnt = n >> 9;
|
|
if (ah->aflags & AOEAFL_WRITE) {
|
|
skb_fill_page_desc(skb, 0, virt_to_page(f->bufaddr),
|
|
offset_in_page(f->bufaddr), n);
|
|
skb->len = sizeof *h + sizeof *ah + n;
|
|
skb->data_len = n;
|
|
}
|
|
}
|
|
skb->dev = t->ifp->nd;
|
|
skb = skb_clone(skb, GFP_ATOMIC);
|
|
if (skb == NULL)
|
|
return;
|
|
if (d->sendq_hd)
|
|
d->sendq_tl->next = skb;
|
|
else
|
|
d->sendq_hd = skb;
|
|
d->sendq_tl = skb;
|
|
}
|
|
|
|
static int
|
|
tsince(int tag)
|
|
{
|
|
int n;
|
|
|
|
n = jiffies & 0xffff;
|
|
n -= tag & 0xffff;
|
|
if (n < 0)
|
|
n += 1<<16;
|
|
return n;
|
|
}
|
|
|
|
static struct aoeif *
|
|
getif(struct aoetgt *t, struct net_device *nd)
|
|
{
|
|
struct aoeif *p, *e;
|
|
|
|
p = t->ifs;
|
|
e = p + NAOEIFS;
|
|
for (; p < e; p++)
|
|
if (p->nd == nd)
|
|
return p;
|
|
return NULL;
|
|
}
|
|
|
|
static struct aoeif *
|
|
addif(struct aoetgt *t, struct net_device *nd)
|
|
{
|
|
struct aoeif *p;
|
|
|
|
p = getif(t, NULL);
|
|
if (!p)
|
|
return NULL;
|
|
p->nd = nd;
|
|
p->maxbcnt = DEFAULTBCNT;
|
|
p->lost = 0;
|
|
p->lostjumbo = 0;
|
|
return p;
|
|
}
|
|
|
|
static void
|
|
ejectif(struct aoetgt *t, struct aoeif *ifp)
|
|
{
|
|
struct aoeif *e;
|
|
ulong n;
|
|
|
|
e = t->ifs + NAOEIFS - 1;
|
|
n = (e - ifp) * sizeof *ifp;
|
|
memmove(ifp, ifp+1, n);
|
|
e->nd = NULL;
|
|
}
|
|
|
|
static int
|
|
sthtith(struct aoedev *d)
|
|
{
|
|
struct frame *f, *e, *nf;
|
|
struct sk_buff *skb;
|
|
struct aoetgt *ht = *d->htgt;
|
|
|
|
f = ht->frames;
|
|
e = f + ht->nframes;
|
|
for (; f < e; f++) {
|
|
if (f->tag == FREETAG)
|
|
continue;
|
|
nf = freeframe(d);
|
|
if (!nf)
|
|
return 0;
|
|
skb = nf->skb;
|
|
*nf = *f;
|
|
f->skb = skb;
|
|
f->tag = FREETAG;
|
|
nf->waited = 0;
|
|
ht->nout--;
|
|
(*d->tgt)->nout++;
|
|
resend(d, *d->tgt, nf);
|
|
}
|
|
/* he's clean, he's useless. take away his interfaces */
|
|
memset(ht->ifs, 0, sizeof ht->ifs);
|
|
d->htgt = NULL;
|
|
return 1;
|
|
}
|
|
|
|
static inline unsigned char
|
|
ata_scnt(unsigned char *packet) {
|
|
struct aoe_hdr *h;
|
|
struct aoe_atahdr *ah;
|
|
|
|
h = (struct aoe_hdr *) packet;
|
|
ah = (struct aoe_atahdr *) (h+1);
|
|
return ah->scnt;
|
|
}
|
|
|
|
static void
|
|
rexmit_timer(ulong vp)
|
|
{
|
|
struct aoedev *d;
|
|
struct aoetgt *t, **tt, **te;
|
|
struct aoeif *ifp;
|
|
struct frame *f, *e;
|
|
struct sk_buff *sl;
|
|
register long timeout;
|
|
ulong flags, n;
|
|
|
|
d = (struct aoedev *) vp;
|
|
sl = NULL;
|
|
|
|
/* timeout is always ~150% of the moving average */
|
|
timeout = d->rttavg;
|
|
timeout += timeout >> 1;
|
|
|
|
spin_lock_irqsave(&d->lock, flags);
|
|
|
|
if (d->flags & DEVFL_TKILL) {
|
|
spin_unlock_irqrestore(&d->lock, flags);
|
|
return;
|
|
}
|
|
tt = d->targets;
|
|
te = tt + NTARGETS;
|
|
for (; tt < te && *tt; tt++) {
|
|
t = *tt;
|
|
f = t->frames;
|
|
e = f + t->nframes;
|
|
for (; f < e; f++) {
|
|
if (f->tag == FREETAG
|
|
|| tsince(f->tag) < timeout)
|
|
continue;
|
|
n = f->waited += timeout;
|
|
n /= HZ;
|
|
if (n > aoe_deadsecs) {
|
|
/* waited too long. device failure. */
|
|
aoedev_downdev(d);
|
|
break;
|
|
}
|
|
|
|
if (n > HELPWAIT /* see if another target can help */
|
|
&& (tt != d->targets || d->targets[1]))
|
|
d->htgt = tt;
|
|
|
|
if (t->nout == t->maxout) {
|
|
if (t->maxout > 1)
|
|
t->maxout--;
|
|
t->lastwadj = jiffies;
|
|
}
|
|
|
|
ifp = getif(t, f->skb->dev);
|
|
if (ifp && ++ifp->lost > (t->nframes << 1)
|
|
&& (ifp != t->ifs || t->ifs[1].nd)) {
|
|
ejectif(t, ifp);
|
|
ifp = NULL;
|
|
}
|
|
|
|
if (ata_scnt(skb_mac_header(f->skb)) > DEFAULTBCNT / 512
|
|
&& ifp && ++ifp->lostjumbo > (t->nframes << 1)
|
|
&& ifp->maxbcnt != DEFAULTBCNT) {
|
|
printk(KERN_INFO
|
|
"aoe: e%ld.%d: "
|
|
"too many lost jumbo on "
|
|
"%s:%012llx - "
|
|
"falling back to %d frames.\n",
|
|
d->aoemajor, d->aoeminor,
|
|
ifp->nd->name, mac_addr(t->addr),
|
|
DEFAULTBCNT);
|
|
ifp->maxbcnt = 0;
|
|
}
|
|
resend(d, t, f);
|
|
}
|
|
|
|
/* window check */
|
|
if (t->nout == t->maxout
|
|
&& t->maxout < t->nframes
|
|
&& (jiffies - t->lastwadj)/HZ > 10) {
|
|
t->maxout++;
|
|
t->lastwadj = jiffies;
|
|
}
|
|
}
|
|
|
|
if (d->sendq_hd) {
|
|
n = d->rttavg <<= 1;
|
|
if (n > MAXTIMER)
|
|
d->rttavg = MAXTIMER;
|
|
}
|
|
|
|
if (d->flags & DEVFL_KICKME || d->htgt) {
|
|
d->flags &= ~DEVFL_KICKME;
|
|
aoecmd_work(d);
|
|
}
|
|
|
|
sl = d->sendq_hd;
|
|
d->sendq_hd = d->sendq_tl = NULL;
|
|
|
|
d->timer.expires = jiffies + TIMERTICK;
|
|
add_timer(&d->timer);
|
|
|
|
spin_unlock_irqrestore(&d->lock, flags);
|
|
|
|
aoenet_xmit(sl);
|
|
}
|
|
|
|
/* enters with d->lock held */
|
|
void
|
|
aoecmd_work(struct aoedev *d)
|
|
{
|
|
struct buf *buf;
|
|
loop:
|
|
if (d->htgt && !sthtith(d))
|
|
return;
|
|
if (d->inprocess == NULL) {
|
|
if (list_empty(&d->bufq))
|
|
return;
|
|
buf = container_of(d->bufq.next, struct buf, bufs);
|
|
list_del(d->bufq.next);
|
|
d->inprocess = buf;
|
|
}
|
|
if (aoecmd_ata_rw(d))
|
|
goto loop;
|
|
}
|
|
|
|
/* this function performs work that has been deferred until sleeping is OK
|
|
*/
|
|
void
|
|
aoecmd_sleepwork(struct work_struct *work)
|
|
{
|
|
struct aoedev *d = container_of(work, struct aoedev, work);
|
|
|
|
if (d->flags & DEVFL_GDALLOC)
|
|
aoeblk_gdalloc(d);
|
|
|
|
if (d->flags & DEVFL_NEWSIZE) {
|
|
struct block_device *bd;
|
|
unsigned long flags;
|
|
u64 ssize;
|
|
|
|
ssize = d->gd->capacity;
|
|
bd = bdget_disk(d->gd, 0);
|
|
|
|
if (bd) {
|
|
mutex_lock(&bd->bd_inode->i_mutex);
|
|
i_size_write(bd->bd_inode, (loff_t)ssize<<9);
|
|
mutex_unlock(&bd->bd_inode->i_mutex);
|
|
bdput(bd);
|
|
}
|
|
spin_lock_irqsave(&d->lock, flags);
|
|
d->flags |= DEVFL_UP;
|
|
d->flags &= ~DEVFL_NEWSIZE;
|
|
spin_unlock_irqrestore(&d->lock, flags);
|
|
}
|
|
}
|
|
|
|
static void
|
|
ataid_complete(struct aoedev *d, struct aoetgt *t, unsigned char *id)
|
|
{
|
|
u64 ssize;
|
|
u16 n;
|
|
|
|
/* word 83: command set supported */
|
|
n = get_unaligned_le16(&id[83 << 1]);
|
|
|
|
/* word 86: command set/feature enabled */
|
|
n |= get_unaligned_le16(&id[86 << 1]);
|
|
|
|
if (n & (1<<10)) { /* bit 10: LBA 48 */
|
|
d->flags |= DEVFL_EXT;
|
|
|
|
/* word 100: number lba48 sectors */
|
|
ssize = get_unaligned_le64(&id[100 << 1]);
|
|
|
|
/* set as in ide-disk.c:init_idedisk_capacity */
|
|
d->geo.cylinders = ssize;
|
|
d->geo.cylinders /= (255 * 63);
|
|
d->geo.heads = 255;
|
|
d->geo.sectors = 63;
|
|
} else {
|
|
d->flags &= ~DEVFL_EXT;
|
|
|
|
/* number lba28 sectors */
|
|
ssize = get_unaligned_le32(&id[60 << 1]);
|
|
|
|
/* NOTE: obsolete in ATA 6 */
|
|
d->geo.cylinders = get_unaligned_le16(&id[54 << 1]);
|
|
d->geo.heads = get_unaligned_le16(&id[55 << 1]);
|
|
d->geo.sectors = get_unaligned_le16(&id[56 << 1]);
|
|
}
|
|
|
|
if (d->ssize != ssize)
|
|
printk(KERN_INFO
|
|
"aoe: %012llx e%ld.%d v%04x has %llu sectors\n",
|
|
mac_addr(t->addr),
|
|
d->aoemajor, d->aoeminor,
|
|
d->fw_ver, (long long)ssize);
|
|
d->ssize = ssize;
|
|
d->geo.start = 0;
|
|
if (d->flags & (DEVFL_GDALLOC|DEVFL_NEWSIZE))
|
|
return;
|
|
if (d->gd != NULL) {
|
|
d->gd->capacity = ssize;
|
|
d->flags |= DEVFL_NEWSIZE;
|
|
} else
|
|
d->flags |= DEVFL_GDALLOC;
|
|
schedule_work(&d->work);
|
|
}
|
|
|
|
static void
|
|
calc_rttavg(struct aoedev *d, int rtt)
|
|
{
|
|
register long n;
|
|
|
|
n = rtt;
|
|
if (n < 0) {
|
|
n = -rtt;
|
|
if (n < MINTIMER)
|
|
n = MINTIMER;
|
|
else if (n > MAXTIMER)
|
|
n = MAXTIMER;
|
|
d->mintimer += (n - d->mintimer) >> 1;
|
|
} else if (n < d->mintimer)
|
|
n = d->mintimer;
|
|
else if (n > MAXTIMER)
|
|
n = MAXTIMER;
|
|
|
|
/* g == .25; cf. Congestion Avoidance and Control, Jacobson & Karels; 1988 */
|
|
n -= d->rttavg;
|
|
d->rttavg += n >> 2;
|
|
}
|
|
|
|
static struct aoetgt *
|
|
gettgt(struct aoedev *d, char *addr)
|
|
{
|
|
struct aoetgt **t, **e;
|
|
|
|
t = d->targets;
|
|
e = t + NTARGETS;
|
|
for (; t < e && *t; t++)
|
|
if (memcmp((*t)->addr, addr, sizeof((*t)->addr)) == 0)
|
|
return *t;
|
|
return NULL;
|
|
}
|
|
|
|
static inline void
|
|
diskstats(struct gendisk *disk, struct bio *bio, ulong duration, sector_t sector)
|
|
{
|
|
unsigned long n_sect = bio->bi_size >> 9;
|
|
const int rw = bio_data_dir(bio);
|
|
struct hd_struct *part;
|
|
|
|
rcu_read_lock();
|
|
|
|
part = disk_map_sector_rcu(disk, sector);
|
|
all_stat_inc(disk, part, ios[rw], sector);
|
|
all_stat_add(disk, part, ticks[rw], duration, sector);
|
|
all_stat_add(disk, part, sectors[rw], n_sect, sector);
|
|
all_stat_add(disk, part, io_ticks, duration, sector);
|
|
|
|
rcu_read_unlock();
|
|
}
|
|
|
|
void
|
|
aoecmd_ata_rsp(struct sk_buff *skb)
|
|
{
|
|
struct aoedev *d;
|
|
struct aoe_hdr *hin, *hout;
|
|
struct aoe_atahdr *ahin, *ahout;
|
|
struct frame *f;
|
|
struct buf *buf;
|
|
struct sk_buff *sl;
|
|
struct aoetgt *t;
|
|
struct aoeif *ifp;
|
|
register long n;
|
|
ulong flags;
|
|
char ebuf[128];
|
|
u16 aoemajor;
|
|
|
|
hin = (struct aoe_hdr *) skb_mac_header(skb);
|
|
aoemajor = get_unaligned_be16(&hin->major);
|
|
d = aoedev_by_aoeaddr(aoemajor, hin->minor);
|
|
if (d == NULL) {
|
|
snprintf(ebuf, sizeof ebuf, "aoecmd_ata_rsp: ata response "
|
|
"for unknown device %d.%d\n",
|
|
aoemajor, hin->minor);
|
|
aoechr_error(ebuf);
|
|
return;
|
|
}
|
|
|
|
spin_lock_irqsave(&d->lock, flags);
|
|
|
|
n = get_unaligned_be32(&hin->tag);
|
|
t = gettgt(d, hin->src);
|
|
if (t == NULL) {
|
|
printk(KERN_INFO "aoe: can't find target e%ld.%d:%012llx\n",
|
|
d->aoemajor, d->aoeminor, mac_addr(hin->src));
|
|
spin_unlock_irqrestore(&d->lock, flags);
|
|
return;
|
|
}
|
|
f = getframe(t, n);
|
|
if (f == NULL) {
|
|
calc_rttavg(d, -tsince(n));
|
|
spin_unlock_irqrestore(&d->lock, flags);
|
|
snprintf(ebuf, sizeof ebuf,
|
|
"%15s e%d.%d tag=%08x@%08lx\n",
|
|
"unexpected rsp",
|
|
get_unaligned_be16(&hin->major),
|
|
hin->minor,
|
|
get_unaligned_be32(&hin->tag),
|
|
jiffies);
|
|
aoechr_error(ebuf);
|
|
return;
|
|
}
|
|
|
|
calc_rttavg(d, tsince(f->tag));
|
|
|
|
ahin = (struct aoe_atahdr *) (hin+1);
|
|
hout = (struct aoe_hdr *) skb_mac_header(f->skb);
|
|
ahout = (struct aoe_atahdr *) (hout+1);
|
|
buf = f->buf;
|
|
|
|
if (ahin->cmdstat & 0xa9) { /* these bits cleared on success */
|
|
printk(KERN_ERR
|
|
"aoe: ata error cmd=%2.2Xh stat=%2.2Xh from e%ld.%d\n",
|
|
ahout->cmdstat, ahin->cmdstat,
|
|
d->aoemajor, d->aoeminor);
|
|
if (buf)
|
|
buf->flags |= BUFFL_FAIL;
|
|
} else {
|
|
if (d->htgt && t == *d->htgt) /* I'll help myself, thank you. */
|
|
d->htgt = NULL;
|
|
n = ahout->scnt << 9;
|
|
switch (ahout->cmdstat) {
|
|
case WIN_READ:
|
|
case WIN_READ_EXT:
|
|
if (skb->len - sizeof *hin - sizeof *ahin < n) {
|
|
printk(KERN_ERR
|
|
"aoe: %s. skb->len=%d need=%ld\n",
|
|
"runt data size in read", skb->len, n);
|
|
/* fail frame f? just returning will rexmit. */
|
|
spin_unlock_irqrestore(&d->lock, flags);
|
|
return;
|
|
}
|
|
memcpy(f->bufaddr, ahin+1, n);
|
|
case WIN_WRITE:
|
|
case WIN_WRITE_EXT:
|
|
ifp = getif(t, skb->dev);
|
|
if (ifp) {
|
|
ifp->lost = 0;
|
|
if (n > DEFAULTBCNT)
|
|
ifp->lostjumbo = 0;
|
|
}
|
|
if (f->bcnt -= n) {
|
|
f->lba += n >> 9;
|
|
f->bufaddr += n;
|
|
resend(d, t, f);
|
|
goto xmit;
|
|
}
|
|
break;
|
|
case WIN_IDENTIFY:
|
|
if (skb->len - sizeof *hin - sizeof *ahin < 512) {
|
|
printk(KERN_INFO
|
|
"aoe: runt data size in ataid. skb->len=%d\n",
|
|
skb->len);
|
|
spin_unlock_irqrestore(&d->lock, flags);
|
|
return;
|
|
}
|
|
ataid_complete(d, t, (char *) (ahin+1));
|
|
break;
|
|
default:
|
|
printk(KERN_INFO
|
|
"aoe: unrecognized ata command %2.2Xh for %d.%d\n",
|
|
ahout->cmdstat,
|
|
get_unaligned_be16(&hin->major),
|
|
hin->minor);
|
|
}
|
|
}
|
|
|
|
if (buf && --buf->nframesout == 0 && buf->resid == 0) {
|
|
diskstats(d->gd, buf->bio, jiffies - buf->stime, buf->sector);
|
|
n = (buf->flags & BUFFL_FAIL) ? -EIO : 0;
|
|
bio_endio(buf->bio, n);
|
|
mempool_free(buf, d->bufpool);
|
|
}
|
|
|
|
f->buf = NULL;
|
|
f->tag = FREETAG;
|
|
t->nout--;
|
|
|
|
aoecmd_work(d);
|
|
xmit:
|
|
sl = d->sendq_hd;
|
|
d->sendq_hd = d->sendq_tl = NULL;
|
|
|
|
spin_unlock_irqrestore(&d->lock, flags);
|
|
aoenet_xmit(sl);
|
|
}
|
|
|
|
void
|
|
aoecmd_cfg(ushort aoemajor, unsigned char aoeminor)
|
|
{
|
|
struct sk_buff *sl;
|
|
|
|
sl = aoecmd_cfg_pkts(aoemajor, aoeminor, NULL);
|
|
|
|
aoenet_xmit(sl);
|
|
}
|
|
|
|
struct sk_buff *
|
|
aoecmd_ata_id(struct aoedev *d)
|
|
{
|
|
struct aoe_hdr *h;
|
|
struct aoe_atahdr *ah;
|
|
struct frame *f;
|
|
struct sk_buff *skb;
|
|
struct aoetgt *t;
|
|
|
|
f = freeframe(d);
|
|
if (f == NULL)
|
|
return NULL;
|
|
|
|
t = *d->tgt;
|
|
|
|
/* initialize the headers & frame */
|
|
skb = f->skb;
|
|
h = (struct aoe_hdr *) skb_mac_header(skb);
|
|
ah = (struct aoe_atahdr *) (h+1);
|
|
skb_put(skb, sizeof *h + sizeof *ah);
|
|
memset(h, 0, skb->len);
|
|
f->tag = aoehdr_atainit(d, t, h);
|
|
t->nout++;
|
|
f->waited = 0;
|
|
|
|
/* set up ata header */
|
|
ah->scnt = 1;
|
|
ah->cmdstat = WIN_IDENTIFY;
|
|
ah->lba3 = 0xa0;
|
|
|
|
skb->dev = t->ifp->nd;
|
|
|
|
d->rttavg = MAXTIMER;
|
|
d->timer.function = rexmit_timer;
|
|
|
|
return skb_clone(skb, GFP_ATOMIC);
|
|
}
|
|
|
|
static struct aoetgt *
|
|
addtgt(struct aoedev *d, char *addr, ulong nframes)
|
|
{
|
|
struct aoetgt *t, **tt, **te;
|
|
struct frame *f, *e;
|
|
|
|
tt = d->targets;
|
|
te = tt + NTARGETS;
|
|
for (; tt < te && *tt; tt++)
|
|
;
|
|
|
|
if (tt == te) {
|
|
printk(KERN_INFO
|
|
"aoe: device addtgt failure; too many targets\n");
|
|
return NULL;
|
|
}
|
|
t = kcalloc(1, sizeof *t, GFP_ATOMIC);
|
|
f = kcalloc(nframes, sizeof *f, GFP_ATOMIC);
|
|
if (!t || !f) {
|
|
kfree(f);
|
|
kfree(t);
|
|
printk(KERN_INFO "aoe: cannot allocate memory to add target\n");
|
|
return NULL;
|
|
}
|
|
|
|
t->nframes = nframes;
|
|
t->frames = f;
|
|
e = f + nframes;
|
|
for (; f < e; f++)
|
|
f->tag = FREETAG;
|
|
memcpy(t->addr, addr, sizeof t->addr);
|
|
t->ifp = t->ifs;
|
|
t->maxout = t->nframes;
|
|
return *tt = t;
|
|
}
|
|
|
|
void
|
|
aoecmd_cfg_rsp(struct sk_buff *skb)
|
|
{
|
|
struct aoedev *d;
|
|
struct aoe_hdr *h;
|
|
struct aoe_cfghdr *ch;
|
|
struct aoetgt *t;
|
|
struct aoeif *ifp;
|
|
ulong flags, sysminor, aoemajor;
|
|
struct sk_buff *sl;
|
|
u16 n;
|
|
|
|
h = (struct aoe_hdr *) skb_mac_header(skb);
|
|
ch = (struct aoe_cfghdr *) (h+1);
|
|
|
|
/*
|
|
* Enough people have their dip switches set backwards to
|
|
* warrant a loud message for this special case.
|
|
*/
|
|
aoemajor = get_unaligned_be16(&h->major);
|
|
if (aoemajor == 0xfff) {
|
|
printk(KERN_ERR "aoe: Warning: shelf address is all ones. "
|
|
"Check shelf dip switches.\n");
|
|
return;
|
|
}
|
|
|
|
sysminor = SYSMINOR(aoemajor, h->minor);
|
|
if (sysminor * AOE_PARTITIONS + AOE_PARTITIONS > MINORMASK) {
|
|
printk(KERN_INFO "aoe: e%ld.%d: minor number too large\n",
|
|
aoemajor, (int) h->minor);
|
|
return;
|
|
}
|
|
|
|
n = be16_to_cpu(ch->bufcnt);
|
|
if (n > aoe_maxout) /* keep it reasonable */
|
|
n = aoe_maxout;
|
|
|
|
d = aoedev_by_sysminor_m(sysminor);
|
|
if (d == NULL) {
|
|
printk(KERN_INFO "aoe: device sysminor_m failure\n");
|
|
return;
|
|
}
|
|
|
|
spin_lock_irqsave(&d->lock, flags);
|
|
|
|
t = gettgt(d, h->src);
|
|
if (!t) {
|
|
t = addtgt(d, h->src, n);
|
|
if (!t) {
|
|
spin_unlock_irqrestore(&d->lock, flags);
|
|
return;
|
|
}
|
|
}
|
|
ifp = getif(t, skb->dev);
|
|
if (!ifp) {
|
|
ifp = addif(t, skb->dev);
|
|
if (!ifp) {
|
|
printk(KERN_INFO
|
|
"aoe: device addif failure; "
|
|
"too many interfaces?\n");
|
|
spin_unlock_irqrestore(&d->lock, flags);
|
|
return;
|
|
}
|
|
}
|
|
if (ifp->maxbcnt) {
|
|
n = ifp->nd->mtu;
|
|
n -= sizeof (struct aoe_hdr) + sizeof (struct aoe_atahdr);
|
|
n /= 512;
|
|
if (n > ch->scnt)
|
|
n = ch->scnt;
|
|
n = n ? n * 512 : DEFAULTBCNT;
|
|
if (n != ifp->maxbcnt) {
|
|
printk(KERN_INFO
|
|
"aoe: e%ld.%d: setting %d%s%s:%012llx\n",
|
|
d->aoemajor, d->aoeminor, n,
|
|
" byte data frames on ", ifp->nd->name,
|
|
mac_addr(t->addr));
|
|
ifp->maxbcnt = n;
|
|
}
|
|
}
|
|
|
|
/* don't change users' perspective */
|
|
if (d->nopen) {
|
|
spin_unlock_irqrestore(&d->lock, flags);
|
|
return;
|
|
}
|
|
d->fw_ver = be16_to_cpu(ch->fwver);
|
|
|
|
sl = aoecmd_ata_id(d);
|
|
|
|
spin_unlock_irqrestore(&d->lock, flags);
|
|
|
|
aoenet_xmit(sl);
|
|
}
|
|
|
|
void
|
|
aoecmd_cleanslate(struct aoedev *d)
|
|
{
|
|
struct aoetgt **t, **te;
|
|
struct aoeif *p, *e;
|
|
|
|
d->mintimer = MINTIMER;
|
|
|
|
t = d->targets;
|
|
te = t + NTARGETS;
|
|
for (; t < te && *t; t++) {
|
|
(*t)->maxout = (*t)->nframes;
|
|
p = (*t)->ifs;
|
|
e = p + NAOEIFS;
|
|
for (; p < e; p++) {
|
|
p->lostjumbo = 0;
|
|
p->lost = 0;
|
|
p->maxbcnt = DEFAULTBCNT;
|
|
}
|
|
}
|
|
}
|