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