1/*-
2 * Copyright (c) 2013  Peter Grehan <grehan@freebsd.org>
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 *    notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 *    notice, this list of conditions and the following disclaimer in the
12 *    documentation and/or other materials provided with the distribution.
13 *
14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND
15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24 * SUCH DAMAGE.
25 *
26 * $FreeBSD: releng/11.0/usr.sbin/bhyve/block_if.c 300843 2016-05-27 11:46:54Z bapt $
27 */
28
29#include <sys/cdefs.h>
30__FBSDID("$FreeBSD: releng/11.0/usr.sbin/bhyve/block_if.c 300843 2016-05-27 11:46:54Z bapt $");
31
32#include <sys/param.h>
33#include <sys/queue.h>
34#include <sys/errno.h>
35#include <sys/stat.h>
36#include <sys/ioctl.h>
37#include <sys/disk.h>
38
39#include <assert.h>
40#include <err.h>
41#include <fcntl.h>
42#include <stdio.h>
43#include <stdlib.h>
44#include <string.h>
45#include <pthread.h>
46#include <pthread_np.h>
47#include <signal.h>
48#include <unistd.h>
49
50#include <machine/atomic.h>
51
52#include "bhyverun.h"
53#include "mevent.h"
54#include "block_if.h"
55
56#define BLOCKIF_SIG	0xb109b109
57
58#define BLOCKIF_NUMTHR	8
59#define BLOCKIF_MAXREQ	(64 + BLOCKIF_NUMTHR)
60
61enum blockop {
62	BOP_READ,
63	BOP_WRITE,
64	BOP_FLUSH,
65	BOP_DELETE
66};
67
68enum blockstat {
69	BST_FREE,
70	BST_BLOCK,
71	BST_PEND,
72	BST_BUSY,
73	BST_DONE
74};
75
76struct blockif_elem {
77	TAILQ_ENTRY(blockif_elem) be_link;
78	struct blockif_req  *be_req;
79	enum blockop	     be_op;
80	enum blockstat	     be_status;
81	pthread_t            be_tid;
82	off_t		     be_block;
83};
84
85struct blockif_ctxt {
86	int			bc_magic;
87	int			bc_fd;
88	int			bc_ischr;
89	int			bc_isgeom;
90	int			bc_candelete;
91	int			bc_rdonly;
92	off_t			bc_size;
93	int			bc_sectsz;
94	int			bc_psectsz;
95	int			bc_psectoff;
96	int			bc_closing;
97	pthread_t		bc_btid[BLOCKIF_NUMTHR];
98        pthread_mutex_t		bc_mtx;
99        pthread_cond_t		bc_cond;
100
101	/* Request elements and free/pending/busy queues */
102	TAILQ_HEAD(, blockif_elem) bc_freeq;
103	TAILQ_HEAD(, blockif_elem) bc_pendq;
104	TAILQ_HEAD(, blockif_elem) bc_busyq;
105	struct blockif_elem	bc_reqs[BLOCKIF_MAXREQ];
106};
107
108static pthread_once_t blockif_once = PTHREAD_ONCE_INIT;
109
110struct blockif_sig_elem {
111	pthread_mutex_t			bse_mtx;
112	pthread_cond_t			bse_cond;
113	int				bse_pending;
114	struct blockif_sig_elem		*bse_next;
115};
116
117static struct blockif_sig_elem *blockif_bse_head;
118
119static int
120blockif_enqueue(struct blockif_ctxt *bc, struct blockif_req *breq,
121		enum blockop op)
122{
123	struct blockif_elem *be, *tbe;
124	off_t off;
125	int i;
126
127	be = TAILQ_FIRST(&bc->bc_freeq);
128	assert(be != NULL);
129	assert(be->be_status == BST_FREE);
130	TAILQ_REMOVE(&bc->bc_freeq, be, be_link);
131	be->be_req = breq;
132	be->be_op = op;
133	switch (op) {
134	case BOP_READ:
135	case BOP_WRITE:
136	case BOP_DELETE:
137		off = breq->br_offset;
138		for (i = 0; i < breq->br_iovcnt; i++)
139			off += breq->br_iov[i].iov_len;
140		break;
141	default:
142		off = OFF_MAX;
143	}
144	be->be_block = off;
145	TAILQ_FOREACH(tbe, &bc->bc_pendq, be_link) {
146		if (tbe->be_block == breq->br_offset)
147			break;
148	}
149	if (tbe == NULL) {
150		TAILQ_FOREACH(tbe, &bc->bc_busyq, be_link) {
151			if (tbe->be_block == breq->br_offset)
152				break;
153		}
154	}
155	if (tbe == NULL)
156		be->be_status = BST_PEND;
157	else
158		be->be_status = BST_BLOCK;
159	TAILQ_INSERT_TAIL(&bc->bc_pendq, be, be_link);
160	return (be->be_status == BST_PEND);
161}
162
163static int
164blockif_dequeue(struct blockif_ctxt *bc, pthread_t t, struct blockif_elem **bep)
165{
166	struct blockif_elem *be;
167
168	TAILQ_FOREACH(be, &bc->bc_pendq, be_link) {
169		if (be->be_status == BST_PEND)
170			break;
171		assert(be->be_status == BST_BLOCK);
172	}
173	if (be == NULL)
174		return (0);
175	TAILQ_REMOVE(&bc->bc_pendq, be, be_link);
176	be->be_status = BST_BUSY;
177	be->be_tid = t;
178	TAILQ_INSERT_TAIL(&bc->bc_busyq, be, be_link);
179	*bep = be;
180	return (1);
181}
182
183static void
184blockif_complete(struct blockif_ctxt *bc, struct blockif_elem *be)
185{
186	struct blockif_elem *tbe;
187
188	if (be->be_status == BST_DONE || be->be_status == BST_BUSY)
189		TAILQ_REMOVE(&bc->bc_busyq, be, be_link);
190	else
191		TAILQ_REMOVE(&bc->bc_pendq, be, be_link);
192	TAILQ_FOREACH(tbe, &bc->bc_pendq, be_link) {
193		if (tbe->be_req->br_offset == be->be_block)
194			tbe->be_status = BST_PEND;
195	}
196	be->be_tid = 0;
197	be->be_status = BST_FREE;
198	be->be_req = NULL;
199	TAILQ_INSERT_TAIL(&bc->bc_freeq, be, be_link);
200}
201
202static void
203blockif_proc(struct blockif_ctxt *bc, struct blockif_elem *be, uint8_t *buf)
204{
205	struct blockif_req *br;
206	off_t arg[2];
207	ssize_t clen, len, off, boff, voff;
208	int i, err;
209
210	br = be->be_req;
211	if (br->br_iovcnt <= 1)
212		buf = NULL;
213	err = 0;
214	switch (be->be_op) {
215	case BOP_READ:
216		if (buf == NULL) {
217			if ((len = preadv(bc->bc_fd, br->br_iov, br->br_iovcnt,
218				   br->br_offset)) < 0)
219				err = errno;
220			else
221				br->br_resid -= len;
222			break;
223		}
224		i = 0;
225		off = voff = 0;
226		while (br->br_resid > 0) {
227			len = MIN(br->br_resid, MAXPHYS);
228			if (pread(bc->bc_fd, buf, len, br->br_offset +
229			    off) < 0) {
230				err = errno;
231				break;
232			}
233			boff = 0;
234			do {
235				clen = MIN(len - boff, br->br_iov[i].iov_len -
236				    voff);
237				memcpy(br->br_iov[i].iov_base + voff,
238				    buf + boff, clen);
239				if (clen < br->br_iov[i].iov_len - voff)
240					voff += clen;
241				else {
242					i++;
243					voff = 0;
244				}
245				boff += clen;
246			} while (boff < len);
247			off += len;
248			br->br_resid -= len;
249		}
250		break;
251	case BOP_WRITE:
252		if (bc->bc_rdonly) {
253			err = EROFS;
254			break;
255		}
256		if (buf == NULL) {
257			if ((len = pwritev(bc->bc_fd, br->br_iov, br->br_iovcnt,
258				    br->br_offset)) < 0)
259				err = errno;
260			else
261				br->br_resid -= len;
262			break;
263		}
264		i = 0;
265		off = voff = 0;
266		while (br->br_resid > 0) {
267			len = MIN(br->br_resid, MAXPHYS);
268			boff = 0;
269			do {
270				clen = MIN(len - boff, br->br_iov[i].iov_len -
271				    voff);
272				memcpy(buf + boff,
273				    br->br_iov[i].iov_base + voff, clen);
274				if (clen < br->br_iov[i].iov_len - voff)
275					voff += clen;
276				else {
277					i++;
278					voff = 0;
279				}
280				boff += clen;
281			} while (boff < len);
282			if (pwrite(bc->bc_fd, buf, len, br->br_offset +
283			    off) < 0) {
284				err = errno;
285				break;
286			}
287			off += len;
288			br->br_resid -= len;
289		}
290		break;
291	case BOP_FLUSH:
292		if (bc->bc_ischr) {
293			if (ioctl(bc->bc_fd, DIOCGFLUSH))
294				err = errno;
295		} else if (fsync(bc->bc_fd))
296			err = errno;
297		break;
298	case BOP_DELETE:
299		if (!bc->bc_candelete)
300			err = EOPNOTSUPP;
301		else if (bc->bc_rdonly)
302			err = EROFS;
303		else if (bc->bc_ischr) {
304			arg[0] = br->br_offset;
305			arg[1] = br->br_resid;
306			if (ioctl(bc->bc_fd, DIOCGDELETE, arg))
307				err = errno;
308			else
309				br->br_resid = 0;
310		} else
311			err = EOPNOTSUPP;
312		break;
313	default:
314		err = EINVAL;
315		break;
316	}
317
318	be->be_status = BST_DONE;
319
320	(*br->br_callback)(br, err);
321}
322
323static void *
324blockif_thr(void *arg)
325{
326	struct blockif_ctxt *bc;
327	struct blockif_elem *be;
328	pthread_t t;
329	uint8_t *buf;
330
331	bc = arg;
332	if (bc->bc_isgeom)
333		buf = malloc(MAXPHYS);
334	else
335		buf = NULL;
336	t = pthread_self();
337
338	pthread_mutex_lock(&bc->bc_mtx);
339	for (;;) {
340		while (blockif_dequeue(bc, t, &be)) {
341			pthread_mutex_unlock(&bc->bc_mtx);
342			blockif_proc(bc, be, buf);
343			pthread_mutex_lock(&bc->bc_mtx);
344			blockif_complete(bc, be);
345		}
346		/* Check ctxt status here to see if exit requested */
347		if (bc->bc_closing)
348			break;
349		pthread_cond_wait(&bc->bc_cond, &bc->bc_mtx);
350	}
351	pthread_mutex_unlock(&bc->bc_mtx);
352
353	if (buf)
354		free(buf);
355	pthread_exit(NULL);
356	return (NULL);
357}
358
359static void
360blockif_sigcont_handler(int signal, enum ev_type type, void *arg)
361{
362	struct blockif_sig_elem *bse;
363
364	for (;;) {
365		/*
366		 * Process the entire list even if not intended for
367		 * this thread.
368		 */
369		do {
370			bse = blockif_bse_head;
371			if (bse == NULL)
372				return;
373		} while (!atomic_cmpset_ptr((uintptr_t *)&blockif_bse_head,
374					    (uintptr_t)bse,
375					    (uintptr_t)bse->bse_next));
376
377		pthread_mutex_lock(&bse->bse_mtx);
378		bse->bse_pending = 0;
379		pthread_cond_signal(&bse->bse_cond);
380		pthread_mutex_unlock(&bse->bse_mtx);
381	}
382}
383
384static void
385blockif_init(void)
386{
387	mevent_add(SIGCONT, EVF_SIGNAL, blockif_sigcont_handler, NULL);
388	(void) signal(SIGCONT, SIG_IGN);
389}
390
391struct blockif_ctxt *
392blockif_open(const char *optstr, const char *ident)
393{
394	char tname[MAXCOMLEN + 1];
395	char name[MAXPATHLEN];
396	char *nopt, *xopts, *cp;
397	struct blockif_ctxt *bc;
398	struct stat sbuf;
399	struct diocgattr_arg arg;
400	off_t size, psectsz, psectoff;
401	int extra, fd, i, sectsz;
402	int nocache, sync, ro, candelete, geom, ssopt, pssopt;
403
404	pthread_once(&blockif_once, blockif_init);
405
406	fd = -1;
407	ssopt = 0;
408	nocache = 0;
409	sync = 0;
410	ro = 0;
411
412	/*
413	 * The first element in the optstring is always a pathname.
414	 * Optional elements follow
415	 */
416	nopt = xopts = strdup(optstr);
417	while (xopts != NULL) {
418		cp = strsep(&xopts, ",");
419		if (cp == nopt)		/* file or device pathname */
420			continue;
421		else if (!strcmp(cp, "nocache"))
422			nocache = 1;
423		else if (!strcmp(cp, "sync") || !strcmp(cp, "direct"))
424			sync = 1;
425		else if (!strcmp(cp, "ro"))
426			ro = 1;
427		else if (sscanf(cp, "sectorsize=%d/%d", &ssopt, &pssopt) == 2)
428			;
429		else if (sscanf(cp, "sectorsize=%d", &ssopt) == 1)
430			pssopt = ssopt;
431		else {
432			fprintf(stderr, "Invalid device option \"%s\"\n", cp);
433			goto err;
434		}
435	}
436
437	extra = 0;
438	if (nocache)
439		extra |= O_DIRECT;
440	if (sync)
441		extra |= O_SYNC;
442
443	fd = open(nopt, (ro ? O_RDONLY : O_RDWR) | extra);
444	if (fd < 0 && !ro) {
445		/* Attempt a r/w fail with a r/o open */
446		fd = open(nopt, O_RDONLY | extra);
447		ro = 1;
448	}
449
450	if (fd < 0) {
451		warn("Could not open backing file: %s", nopt);
452		goto err;
453	}
454
455        if (fstat(fd, &sbuf) < 0) {
456		warn("Could not stat backing file %s", nopt);
457		goto err;
458        }
459
460        /*
461	 * Deal with raw devices
462	 */
463        size = sbuf.st_size;
464	sectsz = DEV_BSIZE;
465	psectsz = psectoff = 0;
466	candelete = geom = 0;
467	if (S_ISCHR(sbuf.st_mode)) {
468		if (ioctl(fd, DIOCGMEDIASIZE, &size) < 0 ||
469		    ioctl(fd, DIOCGSECTORSIZE, &sectsz)) {
470			perror("Could not fetch dev blk/sector size");
471			goto err;
472		}
473		assert(size != 0);
474		assert(sectsz != 0);
475		if (ioctl(fd, DIOCGSTRIPESIZE, &psectsz) == 0 && psectsz > 0)
476			ioctl(fd, DIOCGSTRIPEOFFSET, &psectoff);
477		strlcpy(arg.name, "GEOM::candelete", sizeof(arg.name));
478		arg.len = sizeof(arg.value.i);
479		if (ioctl(fd, DIOCGATTR, &arg) == 0)
480			candelete = arg.value.i;
481		if (ioctl(fd, DIOCGPROVIDERNAME, name) == 0)
482			geom = 1;
483	} else
484		psectsz = sbuf.st_blksize;
485
486	if (ssopt != 0) {
487		if (!powerof2(ssopt) || !powerof2(pssopt) || ssopt < 512 ||
488		    ssopt > pssopt) {
489			fprintf(stderr, "Invalid sector size %d/%d\n",
490			    ssopt, pssopt);
491			goto err;
492		}
493
494		/*
495		 * Some backend drivers (e.g. cd0, ada0) require that the I/O
496		 * size be a multiple of the device's sector size.
497		 *
498		 * Validate that the emulated sector size complies with this
499		 * requirement.
500		 */
501		if (S_ISCHR(sbuf.st_mode)) {
502			if (ssopt < sectsz || (ssopt % sectsz) != 0) {
503				fprintf(stderr, "Sector size %d incompatible "
504				    "with underlying device sector size %d\n",
505				    ssopt, sectsz);
506				goto err;
507			}
508		}
509
510		sectsz = ssopt;
511		psectsz = pssopt;
512		psectoff = 0;
513	}
514
515	bc = calloc(1, sizeof(struct blockif_ctxt));
516	if (bc == NULL) {
517		perror("calloc");
518		goto err;
519	}
520
521	bc->bc_magic = BLOCKIF_SIG;
522	bc->bc_fd = fd;
523	bc->bc_ischr = S_ISCHR(sbuf.st_mode);
524	bc->bc_isgeom = geom;
525	bc->bc_candelete = candelete;
526	bc->bc_rdonly = ro;
527	bc->bc_size = size;
528	bc->bc_sectsz = sectsz;
529	bc->bc_psectsz = psectsz;
530	bc->bc_psectoff = psectoff;
531	pthread_mutex_init(&bc->bc_mtx, NULL);
532	pthread_cond_init(&bc->bc_cond, NULL);
533	TAILQ_INIT(&bc->bc_freeq);
534	TAILQ_INIT(&bc->bc_pendq);
535	TAILQ_INIT(&bc->bc_busyq);
536	for (i = 0; i < BLOCKIF_MAXREQ; i++) {
537		bc->bc_reqs[i].be_status = BST_FREE;
538		TAILQ_INSERT_HEAD(&bc->bc_freeq, &bc->bc_reqs[i], be_link);
539	}
540
541	for (i = 0; i < BLOCKIF_NUMTHR; i++) {
542		pthread_create(&bc->bc_btid[i], NULL, blockif_thr, bc);
543		snprintf(tname, sizeof(tname), "blk-%s-%d", ident, i);
544		pthread_set_name_np(bc->bc_btid[i], tname);
545	}
546
547	return (bc);
548err:
549	if (fd >= 0)
550		close(fd);
551	return (NULL);
552}
553
554static int
555blockif_request(struct blockif_ctxt *bc, struct blockif_req *breq,
556		enum blockop op)
557{
558	int err;
559
560	err = 0;
561
562	pthread_mutex_lock(&bc->bc_mtx);
563	if (!TAILQ_EMPTY(&bc->bc_freeq)) {
564		/*
565		 * Enqueue and inform the block i/o thread
566		 * that there is work available
567		 */
568		if (blockif_enqueue(bc, breq, op))
569			pthread_cond_signal(&bc->bc_cond);
570	} else {
571		/*
572		 * Callers are not allowed to enqueue more than
573		 * the specified blockif queue limit. Return an
574		 * error to indicate that the queue length has been
575		 * exceeded.
576		 */
577		err = E2BIG;
578	}
579	pthread_mutex_unlock(&bc->bc_mtx);
580
581	return (err);
582}
583
584int
585blockif_read(struct blockif_ctxt *bc, struct blockif_req *breq)
586{
587
588	assert(bc->bc_magic == BLOCKIF_SIG);
589	return (blockif_request(bc, breq, BOP_READ));
590}
591
592int
593blockif_write(struct blockif_ctxt *bc, struct blockif_req *breq)
594{
595
596	assert(bc->bc_magic == BLOCKIF_SIG);
597	return (blockif_request(bc, breq, BOP_WRITE));
598}
599
600int
601blockif_flush(struct blockif_ctxt *bc, struct blockif_req *breq)
602{
603
604	assert(bc->bc_magic == BLOCKIF_SIG);
605	return (blockif_request(bc, breq, BOP_FLUSH));
606}
607
608int
609blockif_delete(struct blockif_ctxt *bc, struct blockif_req *breq)
610{
611
612	assert(bc->bc_magic == BLOCKIF_SIG);
613	return (blockif_request(bc, breq, BOP_DELETE));
614}
615
616int
617blockif_cancel(struct blockif_ctxt *bc, struct blockif_req *breq)
618{
619	struct blockif_elem *be;
620
621	assert(bc->bc_magic == BLOCKIF_SIG);
622
623	pthread_mutex_lock(&bc->bc_mtx);
624	/*
625	 * Check pending requests.
626	 */
627	TAILQ_FOREACH(be, &bc->bc_pendq, be_link) {
628		if (be->be_req == breq)
629			break;
630	}
631	if (be != NULL) {
632		/*
633		 * Found it.
634		 */
635		blockif_complete(bc, be);
636		pthread_mutex_unlock(&bc->bc_mtx);
637
638		return (0);
639	}
640
641	/*
642	 * Check in-flight requests.
643	 */
644	TAILQ_FOREACH(be, &bc->bc_busyq, be_link) {
645		if (be->be_req == breq)
646			break;
647	}
648	if (be == NULL) {
649		/*
650		 * Didn't find it.
651		 */
652		pthread_mutex_unlock(&bc->bc_mtx);
653		return (EINVAL);
654	}
655
656	/*
657	 * Interrupt the processing thread to force it return
658	 * prematurely via it's normal callback path.
659	 */
660	while (be->be_status == BST_BUSY) {
661		struct blockif_sig_elem bse, *old_head;
662
663		pthread_mutex_init(&bse.bse_mtx, NULL);
664		pthread_cond_init(&bse.bse_cond, NULL);
665
666		bse.bse_pending = 1;
667
668		do {
669			old_head = blockif_bse_head;
670			bse.bse_next = old_head;
671		} while (!atomic_cmpset_ptr((uintptr_t *)&blockif_bse_head,
672					    (uintptr_t)old_head,
673					    (uintptr_t)&bse));
674
675		pthread_kill(be->be_tid, SIGCONT);
676
677		pthread_mutex_lock(&bse.bse_mtx);
678		while (bse.bse_pending)
679			pthread_cond_wait(&bse.bse_cond, &bse.bse_mtx);
680		pthread_mutex_unlock(&bse.bse_mtx);
681	}
682
683	pthread_mutex_unlock(&bc->bc_mtx);
684
685	/*
686	 * The processing thread has been interrupted.  Since it's not
687	 * clear if the callback has been invoked yet, return EBUSY.
688	 */
689	return (EBUSY);
690}
691
692int
693blockif_close(struct blockif_ctxt *bc)
694{
695	void *jval;
696	int i;
697
698	assert(bc->bc_magic == BLOCKIF_SIG);
699
700	/*
701	 * Stop the block i/o thread
702	 */
703	pthread_mutex_lock(&bc->bc_mtx);
704	bc->bc_closing = 1;
705	pthread_mutex_unlock(&bc->bc_mtx);
706	pthread_cond_broadcast(&bc->bc_cond);
707	for (i = 0; i < BLOCKIF_NUMTHR; i++)
708		pthread_join(bc->bc_btid[i], &jval);
709
710	/* XXX Cancel queued i/o's ??? */
711
712	/*
713	 * Release resources
714	 */
715	bc->bc_magic = 0;
716	close(bc->bc_fd);
717	free(bc);
718
719	return (0);
720}
721
722/*
723 * Return virtual C/H/S values for a given block. Use the algorithm
724 * outlined in the VHD specification to calculate values.
725 */
726void
727blockif_chs(struct blockif_ctxt *bc, uint16_t *c, uint8_t *h, uint8_t *s)
728{
729	off_t sectors;		/* total sectors of the block dev */
730	off_t hcyl;		/* cylinders times heads */
731	uint16_t secpt;		/* sectors per track */
732	uint8_t heads;
733
734	assert(bc->bc_magic == BLOCKIF_SIG);
735
736	sectors = bc->bc_size / bc->bc_sectsz;
737
738	/* Clamp the size to the largest possible with CHS */
739	if (sectors > 65535UL*16*255)
740		sectors = 65535UL*16*255;
741
742	if (sectors >= 65536UL*16*63) {
743		secpt = 255;
744		heads = 16;
745		hcyl = sectors / secpt;
746	} else {
747		secpt = 17;
748		hcyl = sectors / secpt;
749		heads = (hcyl + 1023) / 1024;
750
751		if (heads < 4)
752			heads = 4;
753
754		if (hcyl >= (heads * 1024) || heads > 16) {
755			secpt = 31;
756			heads = 16;
757			hcyl = sectors / secpt;
758		}
759		if (hcyl >= (heads * 1024)) {
760			secpt = 63;
761			heads = 16;
762			hcyl = sectors / secpt;
763		}
764	}
765
766	*c = hcyl / heads;
767	*h = heads;
768	*s = secpt;
769}
770
771/*
772 * Accessors
773 */
774off_t
775blockif_size(struct blockif_ctxt *bc)
776{
777
778	assert(bc->bc_magic == BLOCKIF_SIG);
779	return (bc->bc_size);
780}
781
782int
783blockif_sectsz(struct blockif_ctxt *bc)
784{
785
786	assert(bc->bc_magic == BLOCKIF_SIG);
787	return (bc->bc_sectsz);
788}
789
790void
791blockif_psectsz(struct blockif_ctxt *bc, int *size, int *off)
792{
793
794	assert(bc->bc_magic == BLOCKIF_SIG);
795	*size = bc->bc_psectsz;
796	*off = bc->bc_psectoff;
797}
798
799int
800blockif_queuesz(struct blockif_ctxt *bc)
801{
802
803	assert(bc->bc_magic == BLOCKIF_SIG);
804	return (BLOCKIF_MAXREQ - 1);
805}
806
807int
808blockif_is_ro(struct blockif_ctxt *bc)
809{
810
811	assert(bc->bc_magic == BLOCKIF_SIG);
812	return (bc->bc_rdonly);
813}
814
815int
816blockif_candelete(struct blockif_ctxt *bc)
817{
818
819	assert(bc->bc_magic == BLOCKIF_SIG);
820	return (bc->bc_candelete);
821}
822