xref: /illumos-gate/usr/src/boot/efi/libefi/efipart.c (revision f334afcf)
1e3026534SToomas Soome /*
2199767f8SToomas Soome  * Copyright (c) 2010 Marcel Moolenaar
3199767f8SToomas Soome  * All rights reserved.
4199767f8SToomas Soome  *
5199767f8SToomas Soome  * Redistribution and use in source and binary forms, with or without
6199767f8SToomas Soome  * modification, are permitted provided that the following conditions
7199767f8SToomas Soome  * are met:
8199767f8SToomas Soome  * 1. Redistributions of source code must retain the above copyright
9199767f8SToomas Soome  *    notice, this list of conditions and the following disclaimer.
10199767f8SToomas Soome  * 2. Redistributions in binary form must reproduce the above copyright
11199767f8SToomas Soome  *    notice, this list of conditions and the following disclaimer in the
12199767f8SToomas Soome  *    documentation and/or other materials provided with the distribution.
13199767f8SToomas Soome  *
14199767f8SToomas Soome  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15199767f8SToomas Soome  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16199767f8SToomas Soome  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17199767f8SToomas Soome  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18199767f8SToomas Soome  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19199767f8SToomas Soome  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20199767f8SToomas Soome  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21199767f8SToomas Soome  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22199767f8SToomas Soome  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23199767f8SToomas Soome  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24199767f8SToomas Soome  * SUCH DAMAGE.
25199767f8SToomas Soome  */
26199767f8SToomas Soome 
27199767f8SToomas Soome #include <sys/cdefs.h>
28199767f8SToomas Soome 
29edb35047SToomas Soome #include <sys/disk.h>
30199767f8SToomas Soome #include <sys/param.h>
31199767f8SToomas Soome #include <sys/time.h>
32dbacaf56SToomas Soome #include <sys/queue.h>
33199767f8SToomas Soome #include <stddef.h>
34199767f8SToomas Soome #include <stdarg.h>
35199767f8SToomas Soome 
36199767f8SToomas Soome #include <bootstrap.h>
37199767f8SToomas Soome 
38199767f8SToomas Soome #include <efi.h>
39199767f8SToomas Soome #include <efilib.h>
401f54f0bbSToomas Soome #include <efichar.h>
41*f334afcfSToomas Soome #include <efidevp.h>
42*f334afcfSToomas Soome #include <Protocol/BlockIo.h>
43*f334afcfSToomas Soome #include <Protocol/BlockIo2.h>
44dbacaf56SToomas Soome #include <disk.h>
45199767f8SToomas Soome 
46*f334afcfSToomas Soome EFI_GUID gEfiBlockIoProtocolGuid = EFI_BLOCK_IO_PROTOCOL_GUID;
47*f334afcfSToomas Soome EFI_GUID gEfiBlockIo2ProtocolGuid = EFI_BLOCK_IO2_PROTOCOL_GUID;
48199767f8SToomas Soome 
49c54162e4SToomas Soome typedef bool (*pd_test_cb_t)(pdinfo_t *, pdinfo_t *);
50dbacaf56SToomas Soome static int efipart_initfd(void);
51dbacaf56SToomas Soome static int efipart_initcd(void);
52dbacaf56SToomas Soome static int efipart_inithd(void);
53c54162e4SToomas Soome static void efipart_cdinfo_add(pdinfo_t *);
54dbacaf56SToomas Soome 
5538dea910SToomas Soome static int efipart_strategy(void *, int, daddr_t, size_t, char *, size_t *);
5638dea910SToomas Soome static int efipart_realstrategy(void *, int, daddr_t, size_t, char *, size_t *);
57dbacaf56SToomas Soome 
58199767f8SToomas Soome static int efipart_open(struct open_file *, ...);
59199767f8SToomas Soome static int efipart_close(struct open_file *);
600f2f3e99SToomas Soome static int efipart_ioctl(struct open_file *, unsigned long, void *);
61199767f8SToomas Soome 
62dbacaf56SToomas Soome static int efipart_printfd(int);
63dbacaf56SToomas Soome static int efipart_printcd(int);
64dbacaf56SToomas Soome static int efipart_printhd(int);
65dbacaf56SToomas Soome 
66dbacaf56SToomas Soome /* EISA PNP ID's for floppy controllers */
67dbacaf56SToomas Soome #define	PNP0604	0x604
68dbacaf56SToomas Soome #define	PNP0700	0x700
69dbacaf56SToomas Soome #define	PNP0701	0x701
70dbacaf56SToomas Soome 
712b292e00SToomas Soome /* Bounce buffer max size */
722b292e00SToomas Soome #define	BIO_BUFFER_SIZE	0x4000
732b292e00SToomas Soome 
74dbacaf56SToomas Soome struct devsw efipart_fddev = {
75dbacaf56SToomas Soome 	.dv_name = "fd",
76dbacaf56SToomas Soome 	.dv_type = DEVT_FD,
77dbacaf56SToomas Soome 	.dv_init = efipart_initfd,
78dbacaf56SToomas Soome 	.dv_strategy = efipart_strategy,
79dbacaf56SToomas Soome 	.dv_open = efipart_open,
80dbacaf56SToomas Soome 	.dv_close = efipart_close,
81dbacaf56SToomas Soome 	.dv_ioctl = efipart_ioctl,
82dbacaf56SToomas Soome 	.dv_print = efipart_printfd,
83dbacaf56SToomas Soome 	.dv_cleanup = NULL
84dbacaf56SToomas Soome };
85dbacaf56SToomas Soome 
86dbacaf56SToomas Soome struct devsw efipart_cddev = {
87dbacaf56SToomas Soome 	.dv_name = "cd",
88dbacaf56SToomas Soome 	.dv_type = DEVT_CD,
89dbacaf56SToomas Soome 	.dv_init = efipart_initcd,
90dbacaf56SToomas Soome 	.dv_strategy = efipart_strategy,
91dbacaf56SToomas Soome 	.dv_open = efipart_open,
92dbacaf56SToomas Soome 	.dv_close = efipart_close,
93dbacaf56SToomas Soome 	.dv_ioctl = efipart_ioctl,
94dbacaf56SToomas Soome 	.dv_print = efipart_printcd,
95dbacaf56SToomas Soome 	.dv_cleanup = NULL
96dbacaf56SToomas Soome };
97dbacaf56SToomas Soome 
98dbacaf56SToomas Soome struct devsw efipart_hddev = {
99dbacaf56SToomas Soome 	.dv_name = "disk",
100199767f8SToomas Soome 	.dv_type = DEVT_DISK,
101dbacaf56SToomas Soome 	.dv_init = efipart_inithd,
102199767f8SToomas Soome 	.dv_strategy = efipart_strategy,
103199767f8SToomas Soome 	.dv_open = efipart_open,
104199767f8SToomas Soome 	.dv_close = efipart_close,
105edb35047SToomas Soome 	.dv_ioctl = efipart_ioctl,
106dbacaf56SToomas Soome 	.dv_print = efipart_printhd,
107199767f8SToomas Soome 	.dv_cleanup = NULL
108199767f8SToomas Soome };
109199767f8SToomas Soome 
1100f2f3e99SToomas Soome static pdinfo_list_t fdinfo = STAILQ_HEAD_INITIALIZER(fdinfo);
1110f2f3e99SToomas Soome static pdinfo_list_t cdinfo = STAILQ_HEAD_INITIALIZER(cdinfo);
1120f2f3e99SToomas Soome static pdinfo_list_t hdinfo = STAILQ_HEAD_INITIALIZER(hdinfo);
113dbacaf56SToomas Soome 
1140f2f3e99SToomas Soome /*
1150f2f3e99SToomas Soome  * efipart_inithandles() is used to build up the pdinfo list from
1160f2f3e99SToomas Soome  * block device handles. Then each devsw init callback is used to
1170f2f3e99SToomas Soome  * pick items from pdinfo and move to proper device list.
1180f2f3e99SToomas Soome  * In ideal world, we should end up with empty pdinfo once all
1190f2f3e99SToomas Soome  * devsw initializers are called.
1200f2f3e99SToomas Soome  */
1210f2f3e99SToomas Soome static pdinfo_list_t pdinfo = STAILQ_HEAD_INITIALIZER(pdinfo);
122dbacaf56SToomas Soome 
123eea30b26SToomas Soome pdinfo_list_t *
efiblk_get_pdinfo_list(struct devsw * dev)124eea30b26SToomas Soome efiblk_get_pdinfo_list(struct devsw *dev)
125199767f8SToomas Soome {
126eea30b26SToomas Soome 	if (dev->dv_type == DEVT_DISK)
127eea30b26SToomas Soome 		return (&hdinfo);
128eea30b26SToomas Soome 	if (dev->dv_type == DEVT_CD)
129eea30b26SToomas Soome 		return (&cdinfo);
130eea30b26SToomas Soome 	if (dev->dv_type == DEVT_FD)
131eea30b26SToomas Soome 		return (&fdinfo);
132eea30b26SToomas Soome 	return (NULL);
133eea30b26SToomas Soome }
134eea30b26SToomas Soome 
135e3026534SToomas Soome /* XXX this gets called way way too often, investigate */
136eea30b26SToomas Soome pdinfo_t *
efiblk_get_pdinfo(struct devdesc * dev)137eea30b26SToomas Soome efiblk_get_pdinfo(struct devdesc *dev)
138eea30b26SToomas Soome {
139eea30b26SToomas Soome 	pdinfo_list_t *pdi;
140eea30b26SToomas Soome 	pdinfo_t *pd = NULL;
141eea30b26SToomas Soome 
142eea30b26SToomas Soome 	pdi = efiblk_get_pdinfo_list(dev->d_dev);
143eea30b26SToomas Soome 	if (pdi == NULL)
144eea30b26SToomas Soome 		return (pd);
145199767f8SToomas Soome 
146dbacaf56SToomas Soome 	STAILQ_FOREACH(pd, pdi, pd_link) {
147eea30b26SToomas Soome 		if (pd->pd_unit == dev->d_unit)
148dbacaf56SToomas Soome 			return (pd);
149dbacaf56SToomas Soome 	}
150eea30b26SToomas Soome 	return (pd);
151dbacaf56SToomas Soome }
152199767f8SToomas Soome 
153e3026534SToomas Soome static bool
same_handle(pdinfo_t * pd,EFI_HANDLE h)154e3026534SToomas Soome same_handle(pdinfo_t *pd, EFI_HANDLE h)
155e3026534SToomas Soome {
156e3026534SToomas Soome 
157e3026534SToomas Soome 	return (pd->pd_handle == h || pd->pd_alias == h);
158e3026534SToomas Soome }
159e3026534SToomas Soome 
160e3026534SToomas Soome pdinfo_t *
efiblk_get_pdinfo_by_handle(EFI_HANDLE h)161e3026534SToomas Soome efiblk_get_pdinfo_by_handle(EFI_HANDLE h)
162e3026534SToomas Soome {
163e3026534SToomas Soome 	pdinfo_t *dp, *pp;
164e3026534SToomas Soome 
165e3026534SToomas Soome 	/*
166e3026534SToomas Soome 	 * Check hard disks, then cd, then floppy
167e3026534SToomas Soome 	 */
168e3026534SToomas Soome 	STAILQ_FOREACH(dp, &hdinfo, pd_link) {
169e3026534SToomas Soome 		if (same_handle(dp, h))
170e3026534SToomas Soome 			return (dp);
171e3026534SToomas Soome 		STAILQ_FOREACH(pp, &dp->pd_part, pd_link) {
172e3026534SToomas Soome 			if (same_handle(pp, h))
173e3026534SToomas Soome 				return (pp);
174e3026534SToomas Soome 		}
175e3026534SToomas Soome 	}
176e3026534SToomas Soome 	STAILQ_FOREACH(dp, &cdinfo, pd_link) {
177e3026534SToomas Soome 		if (same_handle(dp, h))
178e3026534SToomas Soome 			return (dp);
1790f2f3e99SToomas Soome 		STAILQ_FOREACH(pp, &dp->pd_part, pd_link) {
1800f2f3e99SToomas Soome 			if (same_handle(pp, h))
1810f2f3e99SToomas Soome 				return (pp);
1820f2f3e99SToomas Soome 		}
183e3026534SToomas Soome 	}
184e3026534SToomas Soome 	STAILQ_FOREACH(dp, &fdinfo, pd_link) {
185e3026534SToomas Soome 		if (same_handle(dp, h))
186e3026534SToomas Soome 			return (dp);
187e3026534SToomas Soome 	}
188e3026534SToomas Soome 	return (NULL);
189e3026534SToomas Soome }
190e3026534SToomas Soome 
191199767f8SToomas Soome static int
efiblk_pdinfo_count(pdinfo_list_t * pdi)192dbacaf56SToomas Soome efiblk_pdinfo_count(pdinfo_list_t *pdi)
193dbacaf56SToomas Soome {
194dbacaf56SToomas Soome 	pdinfo_t *pd;
195dbacaf56SToomas Soome 	int i = 0;
196dbacaf56SToomas Soome 
197dbacaf56SToomas Soome 	STAILQ_FOREACH(pd, pdi, pd_link) {
198dbacaf56SToomas Soome 		i++;
199dbacaf56SToomas Soome 	}
200dbacaf56SToomas Soome 	return (i);
201dbacaf56SToomas Soome }
202dbacaf56SToomas Soome 
203c54162e4SToomas Soome static pdinfo_t *
efipart_find_parent(pdinfo_list_t * pdi,EFI_DEVICE_PATH * devpath)204c54162e4SToomas Soome efipart_find_parent(pdinfo_list_t *pdi, EFI_DEVICE_PATH *devpath)
205c54162e4SToomas Soome {
206c54162e4SToomas Soome 	pdinfo_t *pd;
207c54162e4SToomas Soome 	EFI_DEVICE_PATH *parent;
208c54162e4SToomas Soome 
209c54162e4SToomas Soome 	/* We want to find direct parent */
210c54162e4SToomas Soome 	parent = efi_devpath_trim(devpath);
211c54162e4SToomas Soome 	/* We should not get out of memory here but be careful. */
212c54162e4SToomas Soome 	if (parent == NULL)
213c54162e4SToomas Soome 		return (NULL);
214c54162e4SToomas Soome 
215c54162e4SToomas Soome 	STAILQ_FOREACH(pd, pdi, pd_link) {
216c54162e4SToomas Soome 		/* We must have exact match. */
217c54162e4SToomas Soome 		if (efi_devpath_match(pd->pd_devpath, parent))
218c54162e4SToomas Soome 			break;
219c54162e4SToomas Soome 	}
220c54162e4SToomas Soome 	free(parent);
221c54162e4SToomas Soome 	return (pd);
222c54162e4SToomas Soome }
223c54162e4SToomas Soome 
224c54162e4SToomas Soome /*
225c54162e4SToomas Soome  * Return true when we should ignore this device.
226c54162e4SToomas Soome  */
227c54162e4SToomas Soome static bool
efipart_ignore_device(EFI_HANDLE h,EFI_BLOCK_IO * blkio,EFI_DEVICE_PATH * devpath)228c54162e4SToomas Soome efipart_ignore_device(EFI_HANDLE h, EFI_BLOCK_IO *blkio,
229c54162e4SToomas Soome     EFI_DEVICE_PATH *devpath)
230c54162e4SToomas Soome {
231c54162e4SToomas Soome 	EFI_DEVICE_PATH *node, *parent;
232c54162e4SToomas Soome 
233c54162e4SToomas Soome 	/*
234c54162e4SToomas Soome 	 * We assume the block size 512 or greater power of 2.
235c54162e4SToomas Soome 	 * Also skip devices with block size > 64k (16 is max
236c54162e4SToomas Soome 	 * ashift supported by zfs).
237c54162e4SToomas Soome 	 * iPXE is known to insert stub BLOCK IO device with
238c54162e4SToomas Soome 	 * BlockSize 1.
239c54162e4SToomas Soome 	 */
240c54162e4SToomas Soome 	if (blkio->Media->BlockSize < 512 ||
241c54162e4SToomas Soome 	    blkio->Media->BlockSize > (1 << 16) ||
242c54162e4SToomas Soome 	    !powerof2(blkio->Media->BlockSize)) {
243c54162e4SToomas Soome 		efi_close_devpath(h);
244c54162e4SToomas Soome 		return (true);
245c54162e4SToomas Soome 	}
246c54162e4SToomas Soome 
247c54162e4SToomas Soome 	/* Allowed values are 0, 1 and power of 2. */
248c54162e4SToomas Soome 	if (blkio->Media->IoAlign > 1 &&
249c54162e4SToomas Soome 	    !powerof2(blkio->Media->IoAlign)) {
250c54162e4SToomas Soome 		efi_close_devpath(h);
251c54162e4SToomas Soome 		return (true);
252c54162e4SToomas Soome 	}
253c54162e4SToomas Soome 
254c54162e4SToomas Soome 	/*
255c54162e4SToomas Soome 	 * With device tree setup:
256c54162e4SToomas Soome 	 * PciRoot(0x0)/Pci(0x14,0x0)/USB(0x5,0)/USB(0x2,0x0)
257c54162e4SToomas Soome 	 * PciRoot(0x0)/Pci(0x14,0x0)/USB(0x5,0)/USB(0x2,0x0)/Unit(0x1)
258c54162e4SToomas Soome 	 * PciRoot(0x0)/Pci(0x14,0x0)/USB(0x5,0)/USB(0x2,0x0)/Unit(0x2)
259c54162e4SToomas Soome 	 * PciRoot(0x0)/Pci(0x14,0x0)/USB(0x5,0)/USB(0x2,0x0)/Unit(0x3)
260c54162e4SToomas Soome 	 * PciRoot(0x0)/Pci(0x14,0x0)/USB(0x5,0)/USB(0x2,0x0)/Unit(0x3)/CDROM..
261c54162e4SToomas Soome 	 * PciRoot(0x0)/Pci(0x14,0x0)/USB(0x5,0)/USB(0x2,0x0)/Unit(0x3)/CDROM..
262c54162e4SToomas Soome 	 * PciRoot(0x0)/Pci(0x14,0x0)/USB(0x5,0)/USB(0x2,0x0)/Unit(0x4)
263c54162e4SToomas Soome 	 * PciRoot(0x0)/Pci(0x14,0x0)/USB(0x5,0)/USB(0x2,0x0)/Unit(0x5)
264c54162e4SToomas Soome 	 * PciRoot(0x0)/Pci(0x14,0x0)/USB(0x5,0)/USB(0x2,0x0)/Unit(0x6)
265c54162e4SToomas Soome 	 * PciRoot(0x0)/Pci(0x14,0x0)/USB(0x5,0)/USB(0x2,0x0)/Unit(0x7)
266c54162e4SToomas Soome 	 *
267c54162e4SToomas Soome 	 * In above exmple only Unit(0x3) has media, all other nodes are
268c54162e4SToomas Soome 	 * missing media and should not be used.
269c54162e4SToomas Soome 	 *
270c54162e4SToomas Soome 	 * No media does not always mean there is no device, but in above
271c54162e4SToomas Soome 	 * case, we can not really assume there is any device.
272c54162e4SToomas Soome 	 * Therefore, if this node is USB, or this node is Unit (LUN) and
273c54162e4SToomas Soome 	 * direct parent is USB and we have no media, we will ignore this
274c54162e4SToomas Soome 	 * device.
2759d0a7db0SToomas Soome 	 *
2769d0a7db0SToomas Soome 	 * Variation of the same situation, but with SCSI devices:
2779d0a7db0SToomas Soome 	 * PciRoot(0x0)/Pci(0x1a,0x0)/USB(0x1,0)/USB(0x3,0x0)/SCSI(0x0,0x1)
2789d0a7db0SToomas Soome 	 * PciRoot(0x0)/Pci(0x1a,0x0)/USB(0x1,0)/USB(0x3,0x0)/SCSI(0x0,0x2)
2799d0a7db0SToomas Soome 	 * PciRoot(0x0)/Pci(0x1a,0x0)/USB(0x1,0)/USB(0x3,0x0)/SCSI(0x0,0x3)
2809d0a7db0SToomas Soome 	 * PciRoot(0x0)/Pci(0x1a,0x0)/USB(0x1,0)/USB(0x3,0x0)/SCSI(0x0,0x3)/CD..
2819d0a7db0SToomas Soome 	 * PciRoot(0x0)/Pci(0x1a,0x0)/USB(0x1,0)/USB(0x3,0x0)/SCSI(0x0,0x3)/CD..
2829d0a7db0SToomas Soome 	 * PciRoot(0x0)/Pci(0x1a,0x0)/USB(0x1,0)/USB(0x3,0x0)/SCSI(0x0,0x4)
2839d0a7db0SToomas Soome 	 *
2849d0a7db0SToomas Soome 	 * Here above the SCSI luns 1,2 and 4 have no media.
285c54162e4SToomas Soome 	 */
286c54162e4SToomas Soome 
287c54162e4SToomas Soome 	/* Do not ignore device with media. */
288c54162e4SToomas Soome 	if (blkio->Media->MediaPresent)
289c54162e4SToomas Soome 		return (false);
290c54162e4SToomas Soome 
291c54162e4SToomas Soome 	node = efi_devpath_last_node(devpath);
292c54162e4SToomas Soome 	if (node == NULL)
293c54162e4SToomas Soome 		return (false);
294c54162e4SToomas Soome 
295c54162e4SToomas Soome 	/* USB without media present */
296c54162e4SToomas Soome 	if (DevicePathType(node) == MESSAGING_DEVICE_PATH &&
297c54162e4SToomas Soome 	    DevicePathSubType(node) == MSG_USB_DP) {
298c54162e4SToomas Soome 		efi_close_devpath(h);
299c54162e4SToomas Soome 		return (true);
300c54162e4SToomas Soome 	}
301c54162e4SToomas Soome 
302c54162e4SToomas Soome 	parent = efi_devpath_trim(devpath);
303c54162e4SToomas Soome 	if (parent != NULL) {
304c54162e4SToomas Soome 		bool parent_is_usb = false;
305c54162e4SToomas Soome 
306c54162e4SToomas Soome 		node = efi_devpath_last_node(parent);
307c54162e4SToomas Soome 		if (node == NULL) {
308c54162e4SToomas Soome 			free(parent);
309c54162e4SToomas Soome 			return (false);
310c54162e4SToomas Soome 		}
311c54162e4SToomas Soome 		if (DevicePathType(node) == MESSAGING_DEVICE_PATH &&
312c54162e4SToomas Soome 		    DevicePathSubType(node) == MSG_USB_DP)
313c54162e4SToomas Soome 			parent_is_usb = true;
314c54162e4SToomas Soome 		free(parent);
315c54162e4SToomas Soome 
316c54162e4SToomas Soome 		node = efi_devpath_last_node(devpath);
317c54162e4SToomas Soome 		if (node == NULL)
318c54162e4SToomas Soome 			return (false);
319c54162e4SToomas Soome 		if (parent_is_usb &&
3209d0a7db0SToomas Soome 		    DevicePathType(node) == MESSAGING_DEVICE_PATH) {
3219d0a7db0SToomas Soome 			/*
3229d0a7db0SToomas Soome 			 * no media, parent is USB and devicepath is
3239d0a7db0SToomas Soome 			 * LUN or SCSI.
3249d0a7db0SToomas Soome 			 */
3259d0a7db0SToomas Soome 			if (DevicePathSubType(node) ==
3269d0a7db0SToomas Soome 			    MSG_DEVICE_LOGICAL_UNIT_DP ||
3279d0a7db0SToomas Soome 			    DevicePathSubType(node) == MSG_SCSI_DP) {
3289d0a7db0SToomas Soome 				efi_close_devpath(h);
3299d0a7db0SToomas Soome 				return (true);
3309d0a7db0SToomas Soome 			}
331c54162e4SToomas Soome 		}
332c54162e4SToomas Soome 	}
333c54162e4SToomas Soome 	return (false);
334c54162e4SToomas Soome }
335c54162e4SToomas Soome 
336c00b6c91SToomas Soome int
efipart_inithandles(void)337dbacaf56SToomas Soome efipart_inithandles(void)
338199767f8SToomas Soome {
33969764de3SToomas Soome 	uint_t i, nin;
340dbacaf56SToomas Soome 	EFI_HANDLE *hin;
3410f2f3e99SToomas Soome 	EFI_DEVICE_PATH *devpath;
3420f2f3e99SToomas Soome 	EFI_BLOCK_IO *blkio;
343dbacaf56SToomas Soome 	EFI_STATUS status;
3440f2f3e99SToomas Soome 	pdinfo_t *pd;
345dbacaf56SToomas Soome 
3460f2f3e99SToomas Soome 	if (!STAILQ_EMPTY(&pdinfo))
3470f2f3e99SToomas Soome 		return (0);
348199767f8SToomas Soome 
349*f334afcfSToomas Soome 	status = efi_get_protocol_handles(&gEfiBlockIoProtocolGuid, &nin, &hin);
350199767f8SToomas Soome 	if (EFI_ERROR(status))
351199767f8SToomas Soome 		return (efi_status_to_errno(status));
352199767f8SToomas Soome 
353c00b6c91SToomas Soome #ifdef EFIPART_DEBUG
3540f2f3e99SToomas Soome 	printf("%s: Got %d BLOCK IO MEDIA handle(s)\n", __func__, nin);
355c00b6c91SToomas Soome #endif
356dbacaf56SToomas Soome 
357f58b22cfSToomas Soome 	for (i = 0; i < nin; i++) {
358f58b22cfSToomas Soome 		/*
3590f2f3e99SToomas Soome 		 * Get devpath and open protocol.
3600f2f3e99SToomas Soome 		 * We should not get errors here
361f58b22cfSToomas Soome 		 */
3620f2f3e99SToomas Soome 		if ((devpath = efi_lookup_devpath(hin[i])) == NULL)
3630f2f3e99SToomas Soome 			continue;
364f58b22cfSToomas Soome 
365*f334afcfSToomas Soome 		status = OpenProtocolByHandle(hin[i], &gEfiBlockIoProtocolGuid,
366bf693dc9SToomas Soome 		    (void **)&blkio);
3670f2f3e99SToomas Soome 		if (EFI_ERROR(status)) {
368*f334afcfSToomas Soome 			printf("error %lu\n", DECODE_ERROR(status));
3690f2f3e99SToomas Soome 			continue;
370f58b22cfSToomas Soome 		}
3716c6e04f2SToomas Soome 
372c54162e4SToomas Soome 		if (efipart_ignore_device(hin[i], blkio, devpath))
3730f2f3e99SToomas Soome 			continue;
3742b292e00SToomas Soome 
3750f2f3e99SToomas Soome 		/* This is bad. */
3760f2f3e99SToomas Soome 		if ((pd = calloc(1, sizeof (*pd))) == NULL) {
3770f2f3e99SToomas Soome 			printf("efipart_inithandles: Out of memory.\n");
3780f2f3e99SToomas Soome 			free(hin);
3790f2f3e99SToomas Soome 			return (ENOMEM);
3800f2f3e99SToomas Soome 		}
3810f2f3e99SToomas Soome 		STAILQ_INIT(&pd->pd_part);
382199767f8SToomas Soome 
3830f2f3e99SToomas Soome 		pd->pd_handle = hin[i];
3840f2f3e99SToomas Soome 		pd->pd_devpath = devpath;
3850f2f3e99SToomas Soome 		pd->pd_blkio = blkio;
3860f2f3e99SToomas Soome 		STAILQ_INSERT_TAIL(&pdinfo, pd, pd_link);
387dbacaf56SToomas Soome 	}
3880f2f3e99SToomas Soome 
389c54162e4SToomas Soome 	/*
390c54162e4SToomas Soome 	 * Walk pdinfo and set parents based on device path.
391c54162e4SToomas Soome 	 */
392c54162e4SToomas Soome 	STAILQ_FOREACH(pd, &pdinfo, pd_link) {
393c54162e4SToomas Soome 		pd->pd_parent = efipart_find_parent(&pdinfo, pd->pd_devpath);
394c54162e4SToomas Soome 	}
3950f2f3e99SToomas Soome 	free(hin);
396dbacaf56SToomas Soome 	return (0);
397dbacaf56SToomas Soome }
398199767f8SToomas Soome 
399c54162e4SToomas Soome /*
400c54162e4SToomas Soome  * Get node identified by pd_test() from plist.
401c54162e4SToomas Soome  */
402c54162e4SToomas Soome static pdinfo_t *
efipart_get_pd(pdinfo_list_t * plist,pd_test_cb_t pd_test,pdinfo_t * data)403c54162e4SToomas Soome efipart_get_pd(pdinfo_list_t *plist, pd_test_cb_t pd_test, pdinfo_t *data)
404c54162e4SToomas Soome {
405c54162e4SToomas Soome 	pdinfo_t *pd;
406c54162e4SToomas Soome 
407c54162e4SToomas Soome 	STAILQ_FOREACH(pd, plist, pd_link) {
408c54162e4SToomas Soome 		if (pd_test(pd, data))
409c54162e4SToomas Soome 			break;
410c54162e4SToomas Soome 	}
411c54162e4SToomas Soome 
412c54162e4SToomas Soome 	return (pd);
413c54162e4SToomas Soome }
414c54162e4SToomas Soome 
4150f2f3e99SToomas Soome static ACPI_HID_DEVICE_PATH *
efipart_floppy(EFI_DEVICE_PATH * node)4160f2f3e99SToomas Soome efipart_floppy(EFI_DEVICE_PATH *node)
417dbacaf56SToomas Soome {
418dbacaf56SToomas Soome 	ACPI_HID_DEVICE_PATH *acpi;
419dbacaf56SToomas Soome 
4200f2f3e99SToomas Soome 	if (DevicePathType(node) == ACPI_DEVICE_PATH &&
4210f2f3e99SToomas Soome 	    DevicePathSubType(node) == ACPI_DP) {
4220f2f3e99SToomas Soome 		acpi = (ACPI_HID_DEVICE_PATH *) node;
4230f2f3e99SToomas Soome 		if (acpi->HID == EISA_PNP_ID(PNP0604) ||
4240f2f3e99SToomas Soome 		    acpi->HID == EISA_PNP_ID(PNP0700) ||
4250f2f3e99SToomas Soome 		    acpi->HID == EISA_PNP_ID(PNP0701)) {
4260f2f3e99SToomas Soome 			return (acpi);
427199767f8SToomas Soome 		}
428dbacaf56SToomas Soome 	}
4290f2f3e99SToomas Soome 	return (NULL);
4300f2f3e99SToomas Soome }
4310f2f3e99SToomas Soome 
432c54162e4SToomas Soome static bool
efipart_testfd(pdinfo_t * fd,pdinfo_t * data __unused)433c54162e4SToomas Soome efipart_testfd(pdinfo_t *fd, pdinfo_t *data __unused)
4340f2f3e99SToomas Soome {
435c54162e4SToomas Soome 	EFI_DEVICE_PATH *node;
4360f2f3e99SToomas Soome 
437c54162e4SToomas Soome 	node = efi_devpath_last_node(fd->pd_devpath);
438c54162e4SToomas Soome 	if (node == NULL)
439c54162e4SToomas Soome 		return (false);
440c54162e4SToomas Soome 
441c54162e4SToomas Soome 	if (efipart_floppy(node) != NULL)
442c54162e4SToomas Soome 		return (true);
443c54162e4SToomas Soome 
444c54162e4SToomas Soome 	return (false);
445dbacaf56SToomas Soome }
446199767f8SToomas Soome 
447dbacaf56SToomas Soome static int
efipart_initfd(void)448dbacaf56SToomas Soome efipart_initfd(void)
449dbacaf56SToomas Soome {
4500f2f3e99SToomas Soome 	EFI_DEVICE_PATH *node;
4510f2f3e99SToomas Soome 	ACPI_HID_DEVICE_PATH *acpi;
4520f2f3e99SToomas Soome 	pdinfo_t *parent, *fd;
453dbacaf56SToomas Soome 
454c54162e4SToomas Soome 	while ((fd = efipart_get_pd(&pdinfo, efipart_testfd, NULL)) != NULL) {
4550f2f3e99SToomas Soome 		if ((node = efi_devpath_last_node(fd->pd_devpath)) == NULL)
4560f2f3e99SToomas Soome 			continue;
457dbacaf56SToomas Soome 
4580f2f3e99SToomas Soome 		if ((acpi = efipart_floppy(node)) == NULL)
4590f2f3e99SToomas Soome 			continue;
4600f2f3e99SToomas Soome 
4610f2f3e99SToomas Soome 		STAILQ_REMOVE(&pdinfo, fd, pdinfo, pd_link);
462c54162e4SToomas Soome 		parent = fd->pd_parent;
4630f2f3e99SToomas Soome 		if (parent != NULL) {
4640f2f3e99SToomas Soome 			STAILQ_REMOVE(&pdinfo, parent, pdinfo, pd_link);
4650f2f3e99SToomas Soome 			parent->pd_alias = fd->pd_handle;
4660f2f3e99SToomas Soome 			parent->pd_unit = acpi->UID;
4670f2f3e99SToomas Soome 			free(fd);
4680f2f3e99SToomas Soome 			fd = parent;
4690f2f3e99SToomas Soome 		} else {
4700f2f3e99SToomas Soome 			fd->pd_unit = acpi->UID;
4710f2f3e99SToomas Soome 		}
4720f2f3e99SToomas Soome 		fd->pd_devsw = &efipart_fddev;
4730f2f3e99SToomas Soome 		STAILQ_INSERT_TAIL(&fdinfo, fd, pd_link);
4740f2f3e99SToomas Soome 	}
475dbacaf56SToomas Soome 
476dbacaf56SToomas Soome 	bcache_add_dev(efiblk_pdinfo_count(&fdinfo));
477dbacaf56SToomas Soome 	return (0);
478dbacaf56SToomas Soome }
479dbacaf56SToomas Soome 
480dbacaf56SToomas Soome /*
481dbacaf56SToomas Soome  * Add or update entries with new handle data.
482dbacaf56SToomas Soome  */
4830f2f3e99SToomas Soome static void
efipart_cdinfo_add(pdinfo_t * cd)4840f2f3e99SToomas Soome efipart_cdinfo_add(pdinfo_t *cd)
485dbacaf56SToomas Soome {
486c54162e4SToomas Soome 	pdinfo_t *parent, *pd, *last;
487c54162e4SToomas Soome 
488c54162e4SToomas Soome 	if (cd == NULL)
489c54162e4SToomas Soome 		return;
490c54162e4SToomas Soome 
491c54162e4SToomas Soome 	parent = cd->pd_parent;
492c54162e4SToomas Soome 	/* Make sure we have parent added */
493c54162e4SToomas Soome 	efipart_cdinfo_add(parent);
494c54162e4SToomas Soome 
495c54162e4SToomas Soome 	STAILQ_FOREACH(pd, &pdinfo, pd_link) {
496c54162e4SToomas Soome 		if (efi_devpath_match(pd->pd_devpath, cd->pd_devpath)) {
497c54162e4SToomas Soome 			STAILQ_REMOVE(&pdinfo, cd, pdinfo, pd_link);
498c54162e4SToomas Soome 			break;
499dbacaf56SToomas Soome 		}
500dbacaf56SToomas Soome 	}
501c54162e4SToomas Soome 	if (pd == NULL) {
502c54162e4SToomas Soome 		/* This device is already added. */
503c54162e4SToomas Soome 		return;
504c54162e4SToomas Soome 	}
505c54162e4SToomas Soome 
506c54162e4SToomas Soome 	if (parent != NULL) {
507c54162e4SToomas Soome 		last = STAILQ_LAST(&parent->pd_part, pdinfo, pd_link);
508c54162e4SToomas Soome 		if (last != NULL)
509c54162e4SToomas Soome 			cd->pd_unit = last->pd_unit + 1;
510c54162e4SToomas Soome 		else
511c54162e4SToomas Soome 			cd->pd_unit = 0;
512c54162e4SToomas Soome 		cd->pd_devsw = &efipart_cddev;
513c54162e4SToomas Soome 		STAILQ_INSERT_TAIL(&parent->pd_part, cd, pd_link);
514c54162e4SToomas Soome 		return;
515c54162e4SToomas Soome 	}
516dbacaf56SToomas Soome 
5170f2f3e99SToomas Soome 	last = STAILQ_LAST(&cdinfo, pdinfo, pd_link);
5180f2f3e99SToomas Soome 	if (last != NULL)
5190f2f3e99SToomas Soome 		cd->pd_unit = last->pd_unit + 1;
5200f2f3e99SToomas Soome 	else
5210f2f3e99SToomas Soome 		cd->pd_unit = 0;
522dbacaf56SToomas Soome 
523e3026534SToomas Soome 	cd->pd_devsw = &efipart_cddev;
524dbacaf56SToomas Soome 	STAILQ_INSERT_TAIL(&cdinfo, cd, pd_link);
5250f2f3e99SToomas Soome }
5260f2f3e99SToomas Soome 
5270f2f3e99SToomas Soome static bool
efipart_testcd(pdinfo_t * cd,pdinfo_t * data __unused)528c54162e4SToomas Soome efipart_testcd(pdinfo_t *cd, pdinfo_t *data __unused)
5290f2f3e99SToomas Soome {
530c54162e4SToomas Soome 	EFI_DEVICE_PATH *node;
531c54162e4SToomas Soome 
532c54162e4SToomas Soome 	node = efi_devpath_last_node(cd->pd_devpath);
533c54162e4SToomas Soome 	if (node == NULL)
534c54162e4SToomas Soome 		return (false);
535c54162e4SToomas Soome 
536c54162e4SToomas Soome 	if (efipart_floppy(node) != NULL)
537c54162e4SToomas Soome 		return (false);
538c54162e4SToomas Soome 
5390f2f3e99SToomas Soome 	if (DevicePathType(node) == MEDIA_DEVICE_PATH &&
5400f2f3e99SToomas Soome 	    DevicePathSubType(node) == MEDIA_CDROM_DP) {
5410f2f3e99SToomas Soome 		return (true);
5420f2f3e99SToomas Soome 	}
5430f2f3e99SToomas Soome 
5440f2f3e99SToomas Soome 	/* cd drive without the media. */
545c54162e4SToomas Soome 	if (cd->pd_blkio->Media->RemovableMedia &&
546c54162e4SToomas Soome 	    !cd->pd_blkio->Media->MediaPresent) {
5470f2f3e99SToomas Soome 		return (true);
5480f2f3e99SToomas Soome 	}
5490f2f3e99SToomas Soome 
5500f2f3e99SToomas Soome 	return (false);
551dbacaf56SToomas Soome }
552dbacaf56SToomas Soome 
553c54162e4SToomas Soome /*
554c54162e4SToomas Soome  * Test if pd is parent for device.
555c54162e4SToomas Soome  */
556c54162e4SToomas Soome static bool
efipart_testchild(pdinfo_t * dev,pdinfo_t * pd)557c54162e4SToomas Soome efipart_testchild(pdinfo_t *dev, pdinfo_t *pd)
558dbacaf56SToomas Soome {
559c54162e4SToomas Soome 	/* device with no parent. */
560c54162e4SToomas Soome 	if (dev->pd_parent == NULL)
561c54162e4SToomas Soome 		return (false);
562dbacaf56SToomas Soome 
563c54162e4SToomas Soome 	if (efi_devpath_match(dev->pd_parent->pd_devpath, pd->pd_devpath)) {
564c54162e4SToomas Soome 		return (true);
565dbacaf56SToomas Soome 	}
566c54162e4SToomas Soome 	return (false);
567199767f8SToomas Soome }
568199767f8SToomas Soome 
569199767f8SToomas Soome static int
efipart_initcd(void)570dbacaf56SToomas Soome efipart_initcd(void)
571199767f8SToomas Soome {
572c54162e4SToomas Soome 	pdinfo_t *cd;
573c54162e4SToomas Soome 
574c54162e4SToomas Soome 	while ((cd = efipart_get_pd(&pdinfo, efipart_testcd, NULL)) != NULL)
575c54162e4SToomas Soome 		efipart_cdinfo_add(cd);
576dbacaf56SToomas Soome 
577c54162e4SToomas Soome 	/* Find all children of CD devices we did add above. */
578c54162e4SToomas Soome 	STAILQ_FOREACH(cd, &cdinfo, pd_link) {
579c54162e4SToomas Soome 		pdinfo_t *child;
580c54162e4SToomas Soome 
581c54162e4SToomas Soome 		for (child = efipart_get_pd(&pdinfo, efipart_testchild, cd);
582c54162e4SToomas Soome 		    child != NULL;
583c54162e4SToomas Soome 		    child = efipart_get_pd(&pdinfo, efipart_testchild, cd))
584c54162e4SToomas Soome 			efipart_cdinfo_add(child);
585c54162e4SToomas Soome 	}
586dbacaf56SToomas Soome 	bcache_add_dev(efiblk_pdinfo_count(&cdinfo));
587dbacaf56SToomas Soome 	return (0);
588dbacaf56SToomas Soome }
589dbacaf56SToomas Soome 
590c54162e4SToomas Soome static void
efipart_hdinfo_add_node(pdinfo_t * hd,EFI_DEVICE_PATH * node)59193d2b6f2SToomas Soome efipart_hdinfo_add_node(pdinfo_t *hd, EFI_DEVICE_PATH *node)
592dbacaf56SToomas Soome {
593c54162e4SToomas Soome 	pdinfo_t *parent, *ptr;
59493d2b6f2SToomas Soome 
59593d2b6f2SToomas Soome 	if (node == NULL)
596c54162e4SToomas Soome 		return;
59793d2b6f2SToomas Soome 
598c54162e4SToomas Soome 	parent = hd->pd_parent;
599c54162e4SToomas Soome 	/*
600c54162e4SToomas Soome 	 * If the node is not MEDIA_HARDDRIVE_DP, it is sub-partition.
601c54162e4SToomas Soome 	 * This can happen with Vendor nodes, and since we do not know
602c54162e4SToomas Soome 	 * the more about those nodes, we just count them.
603c54162e4SToomas Soome 	 */
60493d2b6f2SToomas Soome 	if (DevicePathSubType(node) != MEDIA_HARDDRIVE_DP) {
605c54162e4SToomas Soome 		ptr = STAILQ_LAST(&parent->pd_part, pdinfo, pd_link);
60693d2b6f2SToomas Soome 		if (ptr != NULL)
60793d2b6f2SToomas Soome 			hd->pd_unit = ptr->pd_unit + 1;
60893d2b6f2SToomas Soome 		else
60993d2b6f2SToomas Soome 			hd->pd_unit = 0;
61093d2b6f2SToomas Soome 	} else {
61193d2b6f2SToomas Soome 		hd->pd_unit = ((HARDDRIVE_DEVICE_PATH *)node)->PartitionNumber;
612dbacaf56SToomas Soome 	}
613dbacaf56SToomas Soome 
614e3026534SToomas Soome 	hd->pd_devsw = &efipart_hddev;
615c54162e4SToomas Soome 	STAILQ_INSERT_TAIL(&parent->pd_part, hd, pd_link);
616dbacaf56SToomas Soome }
617dbacaf56SToomas Soome 
618dbacaf56SToomas Soome /*
619dbacaf56SToomas Soome  * The MEDIA_FILEPATH_DP has device name.
620dbacaf56SToomas Soome  * From U-Boot sources it looks like names are in the form
621dbacaf56SToomas Soome  * of typeN:M, where type is interface type, N is disk id
622dbacaf56SToomas Soome  * and M is partition id.
623dbacaf56SToomas Soome  */
6240f2f3e99SToomas Soome static void
efipart_hdinfo_add_filepath(pdinfo_t * hd,FILEPATH_DEVICE_PATH * node)6250f2f3e99SToomas Soome efipart_hdinfo_add_filepath(pdinfo_t *hd, FILEPATH_DEVICE_PATH *node)
626dbacaf56SToomas Soome {
627dbacaf56SToomas Soome 	char *pathname, *p;
6280f2f3e99SToomas Soome 	int len;
6290f2f3e99SToomas Soome 	pdinfo_t *last;
630dbacaf56SToomas Soome 
631dbacaf56SToomas Soome 	last = STAILQ_LAST(&hdinfo, pdinfo, pd_link);
632dbacaf56SToomas Soome 	if (last != NULL)
6330f2f3e99SToomas Soome 		hd->pd_unit = last->pd_unit + 1;
634dbacaf56SToomas Soome 	else
6350f2f3e99SToomas Soome 		hd->pd_unit = 0;
636dbacaf56SToomas Soome 
637dbacaf56SToomas Soome 	/* FILEPATH_DEVICE_PATH has 0 terminated string */
6381f54f0bbSToomas Soome 	len = ucs2len(node->PathName);
639dbacaf56SToomas Soome 	if ((pathname = malloc(len + 1)) == NULL) {
640dbacaf56SToomas Soome 		printf("Failed to add disk, out of memory\n");
6410f2f3e99SToomas Soome 		free(hd);
6420f2f3e99SToomas Soome 		return;
643dbacaf56SToomas Soome 	}
644dbacaf56SToomas Soome 	cpy16to8(node->PathName, pathname, len + 1);
645dbacaf56SToomas Soome 	p = strchr(pathname, ':');
646dbacaf56SToomas Soome 
647dbacaf56SToomas Soome 	/*
648dbacaf56SToomas Soome 	 * Assume we are receiving handles in order, first disk handle,
649dbacaf56SToomas Soome 	 * then partitions for this disk. If this assumption proves
650dbacaf56SToomas Soome 	 * false, this code would need update.
651dbacaf56SToomas Soome 	 */
652dbacaf56SToomas Soome 	if (p == NULL) {	/* no colon, add the disk */
6530f2f3e99SToomas Soome 		hd->pd_devsw = &efipart_hddev;
6540f2f3e99SToomas Soome 		STAILQ_INSERT_TAIL(&hdinfo, hd, pd_link);
655dbacaf56SToomas Soome 		free(pathname);
6560f2f3e99SToomas Soome 		return;
657dbacaf56SToomas Soome 	}
658dbacaf56SToomas Soome 	p++;	/* skip the colon */
659dbacaf56SToomas Soome 	errno = 0;
6600f2f3e99SToomas Soome 	hd->pd_unit = (int)strtol(p, NULL, 0);
661dbacaf56SToomas Soome 	if (errno != 0) {
662dbacaf56SToomas Soome 		printf("Bad unit number for partition \"%s\"\n", pathname);
663dbacaf56SToomas Soome 		free(pathname);
6640f2f3e99SToomas Soome 		free(hd);
6650f2f3e99SToomas Soome 		return;
666dbacaf56SToomas Soome 	}
667dbacaf56SToomas Soome 
668dbacaf56SToomas Soome 	/*
669dbacaf56SToomas Soome 	 * We should have disk registered, if not, we are receiving
670dbacaf56SToomas Soome 	 * handles out of order, and this code should be reworked
671dbacaf56SToomas Soome 	 * to create "blank" disk for partition, and to find the
672dbacaf56SToomas Soome 	 * disk based on PathName compares.
673dbacaf56SToomas Soome 	 */
674dbacaf56SToomas Soome 	if (last == NULL) {
675dbacaf56SToomas Soome 		printf("BUG: No disk for partition \"%s\"\n", pathname);
676dbacaf56SToomas Soome 		free(pathname);
6770f2f3e99SToomas Soome 		free(hd);
6780f2f3e99SToomas Soome 		return;
679dbacaf56SToomas Soome 	}
680dbacaf56SToomas Soome 	/* Add the partition. */
6810f2f3e99SToomas Soome 	hd->pd_parent = last;
6820f2f3e99SToomas Soome 	hd->pd_devsw = &efipart_hddev;
6830f2f3e99SToomas Soome 	STAILQ_INSERT_TAIL(&last->pd_part, hd, pd_link);
684dbacaf56SToomas Soome 	free(pathname);
685dbacaf56SToomas Soome }
686dbacaf56SToomas Soome 
687dbacaf56SToomas Soome static void
efipart_hdinfo_add(pdinfo_t * hd)688c54162e4SToomas Soome efipart_hdinfo_add(pdinfo_t *hd)
689dbacaf56SToomas Soome {
690c54162e4SToomas Soome 	pdinfo_t *parent, *pd, *last;
691c54162e4SToomas Soome 	EFI_DEVICE_PATH *node;
692dbacaf56SToomas Soome 
693c54162e4SToomas Soome 	if (hd == NULL)
694c54162e4SToomas Soome 		return;
695f58b22cfSToomas Soome 
696c54162e4SToomas Soome 	parent = hd->pd_parent;
697c54162e4SToomas Soome 	/* Make sure we have parent added */
698c54162e4SToomas Soome 	efipart_hdinfo_add(parent);
699dbacaf56SToomas Soome 
700c54162e4SToomas Soome 	STAILQ_FOREACH(pd, &pdinfo, pd_link) {
701c54162e4SToomas Soome 		if (efi_devpath_match(pd->pd_devpath, hd->pd_devpath)) {
7020f2f3e99SToomas Soome 			STAILQ_REMOVE(&pdinfo, hd, pdinfo, pd_link);
703c54162e4SToomas Soome 			break;
7040f2f3e99SToomas Soome 		}
705c54162e4SToomas Soome 	}
706c54162e4SToomas Soome 	if (pd == NULL) {
707c54162e4SToomas Soome 		/* This device is already added. */
708c54162e4SToomas Soome 		return;
709c54162e4SToomas Soome 	}
710dbacaf56SToomas Soome 
711c54162e4SToomas Soome 	if ((node = efi_devpath_last_node(hd->pd_devpath)) == NULL)
712c54162e4SToomas Soome 		return;
7130f2f3e99SToomas Soome 
714c54162e4SToomas Soome 	if (DevicePathType(node) == MEDIA_DEVICE_PATH &&
715c54162e4SToomas Soome 	    DevicePathSubType(node) == MEDIA_FILEPATH_DP) {
716c54162e4SToomas Soome 		efipart_hdinfo_add_filepath(hd,
717c54162e4SToomas Soome 		    (FILEPATH_DEVICE_PATH *)node);
718c54162e4SToomas Soome 		return;
719c54162e4SToomas Soome 	}
720f58b22cfSToomas Soome 
721c54162e4SToomas Soome 	if (parent != NULL) {
722c54162e4SToomas Soome 		efipart_hdinfo_add_node(hd, node);
723c54162e4SToomas Soome 		return;
724c54162e4SToomas Soome 	}
725f58b22cfSToomas Soome 
726c54162e4SToomas Soome 	last = STAILQ_LAST(&hdinfo, pdinfo, pd_link);
727c54162e4SToomas Soome 	if (last != NULL)
728c54162e4SToomas Soome 		hd->pd_unit = last->pd_unit + 1;
729c54162e4SToomas Soome 	else
730c54162e4SToomas Soome 		hd->pd_unit = 0;
731f58b22cfSToomas Soome 
732c54162e4SToomas Soome 	/* Add the disk. */
733c54162e4SToomas Soome 	hd->pd_devsw = &efipart_hddev;
734c54162e4SToomas Soome 	STAILQ_INSERT_TAIL(&hdinfo, hd, pd_link);
735c54162e4SToomas Soome }
7360f2f3e99SToomas Soome 
737c54162e4SToomas Soome static bool
efipart_testhd(pdinfo_t * hd,pdinfo_t * data __unused)738c54162e4SToomas Soome efipart_testhd(pdinfo_t *hd, pdinfo_t *data __unused)
739c54162e4SToomas Soome {
740c54162e4SToomas Soome 	if (efipart_testfd(hd, NULL))
741c54162e4SToomas Soome 		return (false);
7420f2f3e99SToomas Soome 
743c54162e4SToomas Soome 	if (efipart_testcd(hd, NULL))
744c54162e4SToomas Soome 		return (false);
745dbacaf56SToomas Soome 
746c54162e4SToomas Soome 	/* Anything else must be HD. */
747c54162e4SToomas Soome 	return (true);
748dbacaf56SToomas Soome }
749dbacaf56SToomas Soome 
750dbacaf56SToomas Soome static int
efipart_inithd(void)751dbacaf56SToomas Soome efipart_inithd(void)
752dbacaf56SToomas Soome {
753c54162e4SToomas Soome 	pdinfo_t *hd;
754dbacaf56SToomas Soome 
755c54162e4SToomas Soome 	while ((hd = efipart_get_pd(&pdinfo, efipart_testhd, NULL)) != NULL)
756c54162e4SToomas Soome 		efipart_hdinfo_add(hd);
757dbacaf56SToomas Soome 
758dbacaf56SToomas Soome 	bcache_add_dev(efiblk_pdinfo_count(&hdinfo));
759dbacaf56SToomas Soome 	return (0);
760dbacaf56SToomas Soome }
761dbacaf56SToomas Soome 
762dbacaf56SToomas Soome static int
efipart_print_common(struct devsw * dev,pdinfo_list_t * pdlist,int verbose)763dbacaf56SToomas Soome efipart_print_common(struct devsw *dev, pdinfo_list_t *pdlist, int verbose)
764dbacaf56SToomas Soome {
765199767f8SToomas Soome 	int ret = 0;
766dbacaf56SToomas Soome 	EFI_BLOCK_IO *blkio;
767dbacaf56SToomas Soome 	EFI_STATUS status;
768dbacaf56SToomas Soome 	EFI_HANDLE h;
769dbacaf56SToomas Soome 	pdinfo_t *pd;
770dbacaf56SToomas Soome 	CHAR16 *text;
771dbacaf56SToomas Soome 	struct disk_devdesc pd_dev;
772dbacaf56SToomas Soome 	char line[80];
773dbacaf56SToomas Soome 
774dbacaf56SToomas Soome 	if (STAILQ_EMPTY(pdlist))
775dbacaf56SToomas Soome 		return (0);
776199767f8SToomas Soome 
777dbacaf56SToomas Soome 	printf("%s devices:", dev->dv_name);
778502b33a5SToomas Soome 	if ((ret = pager_output("\n")) != 0)
779502b33a5SToomas Soome 		return (ret);
780502b33a5SToomas Soome 
781dbacaf56SToomas Soome 	STAILQ_FOREACH(pd, pdlist, pd_link) {
782dbacaf56SToomas Soome 		h = pd->pd_handle;
783dbacaf56SToomas Soome 		if (verbose) {	/* Output the device path. */
784dbacaf56SToomas Soome 			text = efi_devpath_name(efi_lookup_devpath(h));
785dbacaf56SToomas Soome 			if (text != NULL) {
786dbacaf56SToomas Soome 				printf("  %S", text);
787dbacaf56SToomas Soome 				efi_free_devpath_name(text);
788dbacaf56SToomas Soome 				if ((ret = pager_output("\n")) != 0)
789dbacaf56SToomas Soome 					break;
790dbacaf56SToomas Soome 			}
791dbacaf56SToomas Soome 		}
7920f2f3e99SToomas Soome 		snprintf(line, sizeof (line),
793dbacaf56SToomas Soome 		    "    %s%d", dev->dv_name, pd->pd_unit);
794dbacaf56SToomas Soome 		printf("%s:", line);
795*f334afcfSToomas Soome 		status = OpenProtocolByHandle(h, &gEfiBlockIoProtocolGuid,
796*f334afcfSToomas Soome 		    (void **)&blkio);
797199767f8SToomas Soome 		if (!EFI_ERROR(status)) {
798dbacaf56SToomas Soome 			printf("    %llu",
799dbacaf56SToomas Soome 			    blkio->Media->LastBlock == 0? 0:
800dbacaf56SToomas Soome 			    (unsigned long long) (blkio->Media->LastBlock + 1));
801dbacaf56SToomas Soome 			if (blkio->Media->LastBlock != 0) {
802dbacaf56SToomas Soome 				printf(" X %u", blkio->Media->BlockSize);
803dbacaf56SToomas Soome 			}
804dbacaf56SToomas Soome 			printf(" blocks");
805dbacaf56SToomas Soome 			if (blkio->Media->MediaPresent) {
806dbacaf56SToomas Soome 				if (blkio->Media->RemovableMedia)
807dbacaf56SToomas Soome 					printf(" (removable)");
808dbacaf56SToomas Soome 			} else {
809dbacaf56SToomas Soome 				printf(" (no media)");
810dbacaf56SToomas Soome 			}
811dbacaf56SToomas Soome 			if ((ret = pager_output("\n")) != 0)
812dbacaf56SToomas Soome 				break;
813dbacaf56SToomas Soome 			if (!blkio->Media->MediaPresent)
814dbacaf56SToomas Soome 				continue;
815dbacaf56SToomas Soome 
816dbacaf56SToomas Soome 			pd->pd_blkio = blkio;
81776b35943SToomas Soome 			pd_dev.dd.d_dev = dev;
81876b35943SToomas Soome 			pd_dev.dd.d_unit = pd->pd_unit;
8199a34674dSToomas Soome 			pd_dev.d_slice = D_SLICENONE;
8209a34674dSToomas Soome 			pd_dev.d_partition = D_PARTNONE;
821dbacaf56SToomas Soome 			ret = disk_open(&pd_dev, blkio->Media->BlockSize *
822dbacaf56SToomas Soome 			    (blkio->Media->LastBlock + 1),
823dbacaf56SToomas Soome 			    blkio->Media->BlockSize);
824dbacaf56SToomas Soome 			if (ret == 0) {
825dbacaf56SToomas Soome 				ret = disk_print(&pd_dev, line, verbose);
826dbacaf56SToomas Soome 				disk_close(&pd_dev);
827dbacaf56SToomas Soome 				if (ret != 0)
828dbacaf56SToomas Soome 					return (ret);
829dbacaf56SToomas Soome 			} else {
830dbacaf56SToomas Soome 				/* Do not fail from disk_open() */
831dbacaf56SToomas Soome 				ret = 0;
832dbacaf56SToomas Soome 			}
833dbacaf56SToomas Soome 		} else {
834dbacaf56SToomas Soome 			if ((ret = pager_output("\n")) != 0)
835dbacaf56SToomas Soome 				break;
836199767f8SToomas Soome 		}
837199767f8SToomas Soome 	}
838199767f8SToomas Soome 	return (ret);
839199767f8SToomas Soome }
840199767f8SToomas Soome 
841dbacaf56SToomas Soome static int
efipart_printfd(int verbose)842dbacaf56SToomas Soome efipart_printfd(int verbose)
843dbacaf56SToomas Soome {
844dbacaf56SToomas Soome 	return (efipart_print_common(&efipart_fddev, &fdinfo, verbose));
845dbacaf56SToomas Soome }
846dbacaf56SToomas Soome 
847dbacaf56SToomas Soome static int
efipart_printcd(int verbose)848dbacaf56SToomas Soome efipart_printcd(int verbose)
849dbacaf56SToomas Soome {
850dbacaf56SToomas Soome 	return (efipart_print_common(&efipart_cddev, &cdinfo, verbose));
851dbacaf56SToomas Soome }
852dbacaf56SToomas Soome 
853dbacaf56SToomas Soome static int
efipart_printhd(int verbose)854dbacaf56SToomas Soome efipart_printhd(int verbose)
855dbacaf56SToomas Soome {
856dbacaf56SToomas Soome 	return (efipart_print_common(&efipart_hddev, &hdinfo, verbose));
857dbacaf56SToomas Soome }
858dbacaf56SToomas Soome 
859199767f8SToomas Soome static int
efipart_open(struct open_file * f,...)860199767f8SToomas Soome efipart_open(struct open_file *f, ...)
861199767f8SToomas Soome {
862199767f8SToomas Soome 	va_list args;
863dbacaf56SToomas Soome 	struct disk_devdesc *dev;
864dbacaf56SToomas Soome 	pdinfo_t *pd;
865199767f8SToomas Soome 	EFI_BLOCK_IO *blkio;
866199767f8SToomas Soome 	EFI_STATUS status;
867199767f8SToomas Soome 
868199767f8SToomas Soome 	va_start(args, f);
8690f2f3e99SToomas Soome 	dev = va_arg(args, struct disk_devdesc *);
870199767f8SToomas Soome 	va_end(args);
871dbacaf56SToomas Soome 	if (dev == NULL)
872dbacaf56SToomas Soome 		return (EINVAL);
873199767f8SToomas Soome 
874eea30b26SToomas Soome 	pd = efiblk_get_pdinfo((struct devdesc *)dev);
875dbacaf56SToomas Soome 	if (pd == NULL)
8760f2f3e99SToomas Soome 		return (EIO);
877dbacaf56SToomas Soome 
878dbacaf56SToomas Soome 	if (pd->pd_blkio == NULL) {
879*f334afcfSToomas Soome 		status = OpenProtocolByHandle(pd->pd_handle,
880*f334afcfSToomas Soome 		    &gEfiBlockIoProtocolGuid,
881dbacaf56SToomas Soome 		    (void **)&pd->pd_blkio);
882dbacaf56SToomas Soome 		if (EFI_ERROR(status))
883dbacaf56SToomas Soome 			return (efi_status_to_errno(status));
884dbacaf56SToomas Soome 	}
885199767f8SToomas Soome 
886dbacaf56SToomas Soome 	blkio = pd->pd_blkio;
887199767f8SToomas Soome 	if (!blkio->Media->MediaPresent)
888199767f8SToomas Soome 		return (EAGAIN);
889199767f8SToomas Soome 
890dbacaf56SToomas Soome 	pd->pd_open++;
891dbacaf56SToomas Soome 	if (pd->pd_bcache == NULL)
892dbacaf56SToomas Soome 		pd->pd_bcache = bcache_allocate();
893dbacaf56SToomas Soome 
89476b35943SToomas Soome 	if (dev->dd.d_dev->dv_type == DEVT_DISK) {
895dbacaf56SToomas Soome 		int rc;
896dbacaf56SToomas Soome 
897dbacaf56SToomas Soome 		rc = disk_open(dev,
898dbacaf56SToomas Soome 		    blkio->Media->BlockSize * (blkio->Media->LastBlock + 1),
899dbacaf56SToomas Soome 		    blkio->Media->BlockSize);
900dbacaf56SToomas Soome 		if (rc != 0) {
901dbacaf56SToomas Soome 			pd->pd_open--;
902dbacaf56SToomas Soome 			if (pd->pd_open == 0) {
903dbacaf56SToomas Soome 				pd->pd_blkio = NULL;
904dbacaf56SToomas Soome 				bcache_free(pd->pd_bcache);
905dbacaf56SToomas Soome 				pd->pd_bcache = NULL;
906dbacaf56SToomas Soome 			}
907dbacaf56SToomas Soome 		}
908dbacaf56SToomas Soome 		return (rc);
909dbacaf56SToomas Soome 	}
910199767f8SToomas Soome 	return (0);
911199767f8SToomas Soome }
912199767f8SToomas Soome 
913199767f8SToomas Soome static int
efipart_close(struct open_file * f)914199767f8SToomas Soome efipart_close(struct open_file *f)
915199767f8SToomas Soome {
916dbacaf56SToomas Soome 	struct disk_devdesc *dev;
917dbacaf56SToomas Soome 	pdinfo_t *pd;
918199767f8SToomas Soome 
919dbacaf56SToomas Soome 	dev = (struct disk_devdesc *)(f->f_devdata);
920dbacaf56SToomas Soome 	if (dev == NULL)
921dbacaf56SToomas Soome 		return (EINVAL);
922dbacaf56SToomas Soome 
923eea30b26SToomas Soome 	pd = efiblk_get_pdinfo((struct devdesc *)dev);
924dbacaf56SToomas Soome 	if (pd == NULL)
925199767f8SToomas Soome 		return (EINVAL);
926199767f8SToomas Soome 
927dbacaf56SToomas Soome 	pd->pd_open--;
928dbacaf56SToomas Soome 	if (pd->pd_open == 0) {
929dbacaf56SToomas Soome 		pd->pd_blkio = NULL;
930dbacaf56SToomas Soome 		bcache_free(pd->pd_bcache);
931dbacaf56SToomas Soome 		pd->pd_bcache = NULL;
932199767f8SToomas Soome 	}
93376b35943SToomas Soome 	if (dev->dd.d_dev->dv_type == DEVT_DISK)
934dbacaf56SToomas Soome 		return (disk_close(dev));
935199767f8SToomas Soome 	return (0);
936199767f8SToomas Soome }
937199767f8SToomas Soome 
938edb35047SToomas Soome static int
efipart_ioctl(struct open_file * f,unsigned long cmd,void * data)9390f2f3e99SToomas Soome efipart_ioctl(struct open_file *f, unsigned long cmd, void *data)
940edb35047SToomas Soome {
941dbacaf56SToomas Soome 	struct disk_devdesc *dev;
942dbacaf56SToomas Soome 	pdinfo_t *pd;
943dbacaf56SToomas Soome 	int rc;
944edb35047SToomas Soome 
945dbacaf56SToomas Soome 	dev = (struct disk_devdesc *)(f->f_devdata);
946dbacaf56SToomas Soome 	if (dev == NULL)
947edb35047SToomas Soome 		return (EINVAL);
948dbacaf56SToomas Soome 
949eea30b26SToomas Soome 	pd = efiblk_get_pdinfo((struct devdesc *)dev);
950dbacaf56SToomas Soome 	if (pd == NULL)
951dbacaf56SToomas Soome 		return (EINVAL);
952dbacaf56SToomas Soome 
95376b35943SToomas Soome 	if (dev->dd.d_dev->dv_type == DEVT_DISK) {
954dbacaf56SToomas Soome 		rc = disk_ioctl(dev, cmd, data);
955dbacaf56SToomas Soome 		if (rc != ENOTTY)
956dbacaf56SToomas Soome 			return (rc);
957dbacaf56SToomas Soome 	}
958edb35047SToomas Soome 
959edb35047SToomas Soome 	switch (cmd) {
960edb35047SToomas Soome 	case DIOCGSECTORSIZE:
9610f2f3e99SToomas Soome 		*(uint_t *)data = pd->pd_blkio->Media->BlockSize;
962edb35047SToomas Soome 		break;
963edb35047SToomas Soome 	case DIOCGMEDIASIZE:
964dbacaf56SToomas Soome 		*(uint64_t *)data = pd->pd_blkio->Media->BlockSize *
965dbacaf56SToomas Soome 		    (pd->pd_blkio->Media->LastBlock + 1);
966edb35047SToomas Soome 		break;
967edb35047SToomas Soome 	default:
968edb35047SToomas Soome 		return (ENOTTY);
969edb35047SToomas Soome 	}
970edb35047SToomas Soome 
971edb35047SToomas Soome 	return (0);
972edb35047SToomas Soome }
973edb35047SToomas Soome 
974199767f8SToomas Soome /*
975199767f8SToomas Soome  * efipart_readwrite()
976199767f8SToomas Soome  * Internal equivalent of efipart_strategy(), which operates on the
977199767f8SToomas Soome  * media-native block size. This function expects all I/O requests
978199767f8SToomas Soome  * to be within the media size and returns an error if such is not
979199767f8SToomas Soome  * the case.
980199767f8SToomas Soome  */
981199767f8SToomas Soome static int
efipart_readwrite(EFI_BLOCK_IO * blkio,int rw,daddr_t blk,daddr_t nblks,char * buf)982199767f8SToomas Soome efipart_readwrite(EFI_BLOCK_IO *blkio, int rw, daddr_t blk, daddr_t nblks,
983199767f8SToomas Soome     char *buf)
984199767f8SToomas Soome {
985199767f8SToomas Soome 	EFI_STATUS status;
986199767f8SToomas Soome 
987199767f8SToomas Soome 	if (blkio == NULL)
988199767f8SToomas Soome 		return (ENXIO);
989199767f8SToomas Soome 	if (blk < 0 || blk > blkio->Media->LastBlock)
990199767f8SToomas Soome 		return (EIO);
991199767f8SToomas Soome 	if ((blk + nblks - 1) > blkio->Media->LastBlock)
992199767f8SToomas Soome 		return (EIO);
993199767f8SToomas Soome 
9943dab2501SToomas Soome 	switch (rw & F_MASK) {
995199767f8SToomas Soome 	case F_READ:
996199767f8SToomas Soome 		status = blkio->ReadBlocks(blkio, blkio->Media->MediaId, blk,
997199767f8SToomas Soome 		    nblks * blkio->Media->BlockSize, buf);
998199767f8SToomas Soome 		break;
999199767f8SToomas Soome 	case F_WRITE:
1000199767f8SToomas Soome 		if (blkio->Media->ReadOnly)
1001199767f8SToomas Soome 			return (EROFS);
1002199767f8SToomas Soome 		status = blkio->WriteBlocks(blkio, blkio->Media->MediaId, blk,
1003199767f8SToomas Soome 		    nblks * blkio->Media->BlockSize, buf);
1004199767f8SToomas Soome 		break;
1005199767f8SToomas Soome 	default:
1006199767f8SToomas Soome 		return (ENOSYS);
1007199767f8SToomas Soome 	}
1008199767f8SToomas Soome 
1009dbacaf56SToomas Soome 	if (EFI_ERROR(status)) {
1010dbacaf56SToomas Soome 		printf("%s: rw=%d, blk=%ju size=%ju status=%lu\n", __func__, rw,
1011*f334afcfSToomas Soome 		    blk, nblks, DECODE_ERROR(status));
1012dbacaf56SToomas Soome 	}
1013199767f8SToomas Soome 	return (efi_status_to_errno(status));
1014199767f8SToomas Soome }
1015199767f8SToomas Soome 
1016199767f8SToomas Soome static int
efipart_strategy(void * devdata,int rw,daddr_t blk,size_t size,char * buf,size_t * rsize)101738dea910SToomas Soome efipart_strategy(void *devdata, int rw, daddr_t blk, size_t size,
101838dea910SToomas Soome     char *buf, size_t *rsize)
1019199767f8SToomas Soome {
1020199767f8SToomas Soome 	struct bcache_devdata bcd;
1021dbacaf56SToomas Soome 	struct disk_devdesc *dev;
1022dbacaf56SToomas Soome 	pdinfo_t *pd;
1023dbacaf56SToomas Soome 
1024dbacaf56SToomas Soome 	dev = (struct disk_devdesc *)devdata;
1025dbacaf56SToomas Soome 	if (dev == NULL)
1026dbacaf56SToomas Soome 		return (EINVAL);
1027dbacaf56SToomas Soome 
1028eea30b26SToomas Soome 	pd = efiblk_get_pdinfo((struct devdesc *)dev);
1029dbacaf56SToomas Soome 	if (pd == NULL)
1030dbacaf56SToomas Soome 		return (EINVAL);
1031dbacaf56SToomas Soome 
1032dbacaf56SToomas Soome 	if (pd->pd_blkio->Media->RemovableMedia &&
1033dbacaf56SToomas Soome 	    !pd->pd_blkio->Media->MediaPresent)
1034dbacaf56SToomas Soome 		return (ENXIO);
1035199767f8SToomas Soome 
1036199767f8SToomas Soome 	bcd.dv_strategy = efipart_realstrategy;
1037199767f8SToomas Soome 	bcd.dv_devdata = devdata;
1038dbacaf56SToomas Soome 	bcd.dv_cache = pd->pd_bcache;
1039dbacaf56SToomas Soome 
104076b35943SToomas Soome 	if (dev->dd.d_dev->dv_type == DEVT_DISK) {
1041da5223b9SToomas Soome 		daddr_t offset;
1042da5223b9SToomas Soome 
1043da5223b9SToomas Soome 		offset = dev->d_offset * pd->pd_blkio->Media->BlockSize;
1044da5223b9SToomas Soome 		offset /= 512;
1045da5223b9SToomas Soome 		return (bcache_strategy(&bcd, rw, blk + offset,
1046dbacaf56SToomas Soome 		    size, buf, rsize));
1047dbacaf56SToomas Soome 	}
104838dea910SToomas Soome 	return (bcache_strategy(&bcd, rw, blk, size, buf, rsize));
1049199767f8SToomas Soome }
1050199767f8SToomas Soome 
1051199767f8SToomas Soome static int
efipart_realstrategy(void * devdata,int rw,daddr_t blk,size_t size,char * buf,size_t * rsize)105238dea910SToomas Soome efipart_realstrategy(void *devdata, int rw, daddr_t blk, size_t size,
105338dea910SToomas Soome     char *buf, size_t *rsize)
1054199767f8SToomas Soome {
1055dbacaf56SToomas Soome 	struct disk_devdesc *dev = (struct disk_devdesc *)devdata;
1056dbacaf56SToomas Soome 	pdinfo_t *pd;
1057199767f8SToomas Soome 	EFI_BLOCK_IO *blkio;
1058dbacaf56SToomas Soome 	uint64_t off, disk_blocks, d_offset = 0;
1059199767f8SToomas Soome 	char *blkbuf;
10602b292e00SToomas Soome 	size_t blkoff, blksz, bio_size;
10612b292e00SToomas Soome 	unsigned ioalign;
10622b292e00SToomas Soome 	bool need_buf;
10632b292e00SToomas Soome 	int rc;
1064dbacaf56SToomas Soome 	uint64_t diskend, readstart;
1065199767f8SToomas Soome 
1066199767f8SToomas Soome 	if (dev == NULL || blk < 0)
1067199767f8SToomas Soome 		return (EINVAL);
1068199767f8SToomas Soome 
1069eea30b26SToomas Soome 	pd = efiblk_get_pdinfo((struct devdesc *)dev);
1070dbacaf56SToomas Soome 	if (pd == NULL)
1071dbacaf56SToomas Soome 		return (EINVAL);
1072dbacaf56SToomas Soome 
1073dbacaf56SToomas Soome 	blkio = pd->pd_blkio;
1074199767f8SToomas Soome 	if (blkio == NULL)
1075199767f8SToomas Soome 		return (ENXIO);
1076199767f8SToomas Soome 
1077199767f8SToomas Soome 	if (size == 0 || (size % 512) != 0)
1078199767f8SToomas Soome 		return (EIO);
1079199767f8SToomas Soome 
1080199767f8SToomas Soome 	off = blk * 512;
1081dbacaf56SToomas Soome 	/*
1082dbacaf56SToomas Soome 	 * Get disk blocks, this value is either for whole disk or for
1083dbacaf56SToomas Soome 	 * partition.
1084dbacaf56SToomas Soome 	 */
1085dbacaf56SToomas Soome 	disk_blocks = 0;
108676b35943SToomas Soome 	if (dev->dd.d_dev->dv_type == DEVT_DISK) {
1087dbacaf56SToomas Soome 		if (disk_ioctl(dev, DIOCGMEDIASIZE, &disk_blocks) == 0) {
1088dbacaf56SToomas Soome 			/* DIOCGMEDIASIZE does return bytes. */
1089dbacaf56SToomas Soome 			disk_blocks /= blkio->Media->BlockSize;
1090dbacaf56SToomas Soome 		}
1091dbacaf56SToomas Soome 		d_offset = dev->d_offset;
1092dbacaf56SToomas Soome 	}
1093dbacaf56SToomas Soome 	if (disk_blocks == 0)
1094dbacaf56SToomas Soome 		disk_blocks = blkio->Media->LastBlock + 1 - d_offset;
1095dbacaf56SToomas Soome 
1096199767f8SToomas Soome 	/* make sure we don't read past disk end */
1097dbacaf56SToomas Soome 	if ((off + size) / blkio->Media->BlockSize > d_offset + disk_blocks) {
1098dbacaf56SToomas Soome 		diskend = d_offset + disk_blocks;
1099dbacaf56SToomas Soome 		readstart = off / blkio->Media->BlockSize;
1100dbacaf56SToomas Soome 
1101dbacaf56SToomas Soome 		if (diskend <= readstart) {
1102dbacaf56SToomas Soome 			if (rsize != NULL)
1103dbacaf56SToomas Soome 				*rsize = 0;
1104dbacaf56SToomas Soome 
1105dbacaf56SToomas Soome 			return (EIO);
1106dbacaf56SToomas Soome 		}
1107dbacaf56SToomas Soome 		size = diskend - readstart;
1108199767f8SToomas Soome 		size = size * blkio->Media->BlockSize;
1109199767f8SToomas Soome 	}
1110199767f8SToomas Soome 
11112b292e00SToomas Soome 	need_buf = true;
11122b292e00SToomas Soome 	/* Do we need bounce buffer? */
1113a5f66292SToomas Soome 	if ((size % blkio->Media->BlockSize == 0) &&
1114a5f66292SToomas Soome 	    (off % blkio->Media->BlockSize == 0))
11152b292e00SToomas Soome 		need_buf = false;
11162b292e00SToomas Soome 
11172b292e00SToomas Soome 	/* Do we have IO alignment requirement? */
11182b292e00SToomas Soome 	ioalign = blkio->Media->IoAlign;
11192b292e00SToomas Soome 	if (ioalign == 0)
11202b292e00SToomas Soome 		ioalign++;
11212b292e00SToomas Soome 
11222b292e00SToomas Soome 	if (ioalign > 1 && (uintptr_t)buf != roundup2((uintptr_t)buf, ioalign))
11232b292e00SToomas Soome 		need_buf = true;
11242b292e00SToomas Soome 
11252b292e00SToomas Soome 	if (need_buf) {
11262b292e00SToomas Soome 		for (bio_size = BIO_BUFFER_SIZE; bio_size > 0;
11272b292e00SToomas Soome 		    bio_size -= blkio->Media->BlockSize) {
11282b292e00SToomas Soome 			blkbuf = memalign(ioalign, bio_size);
11292b292e00SToomas Soome 			if (blkbuf != NULL)
11302b292e00SToomas Soome 				break;
11312b292e00SToomas Soome 		}
11322b292e00SToomas Soome 	} else {
11332b292e00SToomas Soome 		blkbuf = buf;
11342b292e00SToomas Soome 		bio_size = size;
11352b292e00SToomas Soome 	}
1136199767f8SToomas Soome 
1137199767f8SToomas Soome 	if (blkbuf == NULL)
1138199767f8SToomas Soome 		return (ENOMEM);
1139199767f8SToomas Soome 
11402b292e00SToomas Soome 	if (rsize != NULL)
11412b292e00SToomas Soome 		*rsize = size;
11422b292e00SToomas Soome 
11432b292e00SToomas Soome 	rc = 0;
1144199767f8SToomas Soome 	blk = off / blkio->Media->BlockSize;
1145199767f8SToomas Soome 	blkoff = off % blkio->Media->BlockSize;
11462b292e00SToomas Soome 
1147199767f8SToomas Soome 	while (size > 0) {
11482b292e00SToomas Soome 		size_t x = min(size, bio_size);
11492b292e00SToomas Soome 
11502b292e00SToomas Soome 		if (x < blkio->Media->BlockSize)
11512b292e00SToomas Soome 			x = 1;
11522b292e00SToomas Soome 		else
11532b292e00SToomas Soome 			x /= blkio->Media->BlockSize;
11542b292e00SToomas Soome 
11552b292e00SToomas Soome 		switch (rw & F_MASK) {
11562b292e00SToomas Soome 		case F_READ:
11572b292e00SToomas Soome 			blksz = blkio->Media->BlockSize * x - blkoff;
11582b292e00SToomas Soome 			if (size < blksz)
11592b292e00SToomas Soome 				blksz = size;
11602b292e00SToomas Soome 
11612b292e00SToomas Soome 			rc = efipart_readwrite(blkio, rw, blk, x, blkbuf);
11622b292e00SToomas Soome 			if (rc != 0)
11632b292e00SToomas Soome 				goto error;
11642b292e00SToomas Soome 
11652b292e00SToomas Soome 			if (need_buf)
11662b292e00SToomas Soome 				bcopy(blkbuf + blkoff, buf, blksz);
1167199767f8SToomas Soome 			break;
11682b292e00SToomas Soome 		case F_WRITE:
11692b292e00SToomas Soome 			rc = 0;
11702b292e00SToomas Soome 			if (blkoff != 0) {
11712b292e00SToomas Soome 				/*
11722b292e00SToomas Soome 				 * We got offset to sector, read 1 sector to
11732b292e00SToomas Soome 				 * blkbuf.
11742b292e00SToomas Soome 				 */
11752b292e00SToomas Soome 				x = 1;
11762b292e00SToomas Soome 				blksz = blkio->Media->BlockSize - blkoff;
11772b292e00SToomas Soome 				blksz = min(blksz, size);
11782b292e00SToomas Soome 				rc = efipart_readwrite(blkio, F_READ, blk, x,
11792b292e00SToomas Soome 				    blkbuf);
11802b292e00SToomas Soome 			} else if (size < blkio->Media->BlockSize) {
11812b292e00SToomas Soome 				/*
11822b292e00SToomas Soome 				 * The remaining block is not full
11832b292e00SToomas Soome 				 * sector. Read 1 sector to blkbuf.
11842b292e00SToomas Soome 				 */
11852b292e00SToomas Soome 				x = 1;
11862b292e00SToomas Soome 				blksz = size;
11872b292e00SToomas Soome 				rc = efipart_readwrite(blkio, F_READ, blk, x,
11882b292e00SToomas Soome 				    blkbuf);
11892b292e00SToomas Soome 			} else {
11902b292e00SToomas Soome 				/* We can write full sector(s). */
11912b292e00SToomas Soome 				blksz = blkio->Media->BlockSize * x;
11922b292e00SToomas Soome 			}
11932b292e00SToomas Soome 
11942b292e00SToomas Soome 			if (rc != 0)
11952b292e00SToomas Soome 				goto error;
11962b292e00SToomas Soome 			/*
11972b292e00SToomas Soome 			 * Put your Data In, Put your Data out,
11982b292e00SToomas Soome 			 * Put your Data In, and shake it all about
11992b292e00SToomas Soome 			 */
12002b292e00SToomas Soome 			if (need_buf)
12012b292e00SToomas Soome 				bcopy(buf, blkbuf + blkoff, blksz);
12022b292e00SToomas Soome 			rc = efipart_readwrite(blkio, F_WRITE, blk, x, blkbuf);
12032b292e00SToomas Soome 			if (rc != 0)
12042b292e00SToomas Soome 				goto error;
12052b292e00SToomas Soome 			break;
12062b292e00SToomas Soome 		default:
12072b292e00SToomas Soome 			/* DO NOTHING */
12082b292e00SToomas Soome 			rc = EROFS;
12092b292e00SToomas Soome 			goto error;
12102b292e00SToomas Soome 		}
12112b292e00SToomas Soome 
12122b292e00SToomas Soome 		blkoff = 0;
1213199767f8SToomas Soome 		buf += blksz;
1214199767f8SToomas Soome 		size -= blksz;
12152b292e00SToomas Soome 		blk += x;
1216199767f8SToomas Soome 	}
1217199767f8SToomas Soome 
12182b292e00SToomas Soome error:
12192b292e00SToomas Soome 	if (rsize != NULL)
12202b292e00SToomas Soome 		*rsize -= size;
12212b292e00SToomas Soome 
12222b292e00SToomas Soome 	if (need_buf)
12232b292e00SToomas Soome 		free(blkbuf);
12242b292e00SToomas Soome 	return (rc);
1225199767f8SToomas Soome }
1226