xref: /linux/drivers/block/aoe/aoecmd.c (revision 9429ec96c2718c0d1e3317cf60a87a0405223814) 
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 }
1085