xref: /dflybsd-src/contrib/lvm2/dist/libdm/ioctl/libdm_netbsd.c (revision 86d7f5d305c6adaa56ff4582ece9859d73106103)
1*86d7f5d3SJohn Marino /*      $NetBSD: libdm_netbsd.c,v 1.5 2009/12/05 11:42:24 haad Exp $        */
2*86d7f5d3SJohn Marino 
3*86d7f5d3SJohn Marino /*
4*86d7f5d3SJohn Marino  * Copyright (c) 1996, 1997, 1998, 1999, 2002 The NetBSD Foundation, Inc.
5*86d7f5d3SJohn Marino  * All rights reserved.
6*86d7f5d3SJohn Marino  *
7*86d7f5d3SJohn Marino  * This code is derived from software contributed to The NetBSD Foundation
8*86d7f5d3SJohn Marino  * by Adam Hamsik.
9*86d7f5d3SJohn Marino  *
10*86d7f5d3SJohn Marino  * Redistribution and use in source and binary forms, with or without
11*86d7f5d3SJohn Marino  * modification, are permitted provided that the following conditions
12*86d7f5d3SJohn Marino  * are met:
13*86d7f5d3SJohn Marino  * 1. Redistributions of source code must retain the above copyright
14*86d7f5d3SJohn Marino  *    notice, this list of conditions and the following disclaimer.
15*86d7f5d3SJohn Marino  * 2. Redistributions in binary form must reproduce the above copyright
16*86d7f5d3SJohn Marino  *    notice, this list of conditions and the following disclaimer in the
17*86d7f5d3SJohn Marino  *    documentation and/or other materials provided with the distribution.
18*86d7f5d3SJohn Marino  *
19*86d7f5d3SJohn Marino  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
20*86d7f5d3SJohn Marino  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
21*86d7f5d3SJohn Marino  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
22*86d7f5d3SJohn Marino  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
23*86d7f5d3SJohn Marino  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
24*86d7f5d3SJohn Marino  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
25*86d7f5d3SJohn Marino  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
26*86d7f5d3SJohn Marino  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
27*86d7f5d3SJohn Marino  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
28*86d7f5d3SJohn Marino  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29*86d7f5d3SJohn Marino  * POSSIBILITY OF SUCH DAMAGE.
30*86d7f5d3SJohn Marino  */
31*86d7f5d3SJohn Marino 
32*86d7f5d3SJohn Marino 
33*86d7f5d3SJohn Marino #include <sys/ioctl.h>
34*86d7f5d3SJohn Marino #include <sys/types.h>
35*86d7f5d3SJohn Marino #include <sys/sysctl.h>
36*86d7f5d3SJohn Marino 
37*86d7f5d3SJohn Marino #include <err.h>
38*86d7f5d3SJohn Marino #include <errno.h>
39*86d7f5d3SJohn Marino 
40*86d7f5d3SJohn Marino #include <stdio.h>
41*86d7f5d3SJohn Marino #include <stdlib.h>
42*86d7f5d3SJohn Marino #include <unistd.h>
43*86d7f5d3SJohn Marino 
44*86d7f5d3SJohn Marino #include <dev/dm/netbsd-dm.h>
45*86d7f5d3SJohn Marino 
46*86d7f5d3SJohn Marino #include <dm-ioctl.h>
47*86d7f5d3SJohn Marino 
48*86d7f5d3SJohn Marino #include "lib.h"
49*86d7f5d3SJohn Marino #include "libdm-netbsd.h"
50*86d7f5d3SJohn Marino 
51*86d7f5d3SJohn Marino #define DMI_SIZE 16 * 1024
52*86d7f5d3SJohn Marino 
53*86d7f5d3SJohn Marino static int dm_list_versions(prop_dictionary_t, struct dm_ioctl *);
54*86d7f5d3SJohn Marino static int dm_list_devices(prop_dictionary_t, struct dm_ioctl *);
55*86d7f5d3SJohn Marino static int dm_dev_deps(prop_dictionary_t, struct dm_ioctl *);
56*86d7f5d3SJohn Marino static int dm_table_status(prop_dictionary_t, struct dm_ioctl *);
57*86d7f5d3SJohn Marino 
58*86d7f5d3SJohn Marino int
nbsd_get_dm_major(uint32_t * major,int type)59*86d7f5d3SJohn Marino nbsd_get_dm_major(uint32_t *major,  int type)
60*86d7f5d3SJohn Marino {
61*86d7f5d3SJohn Marino 	size_t val_len,i;
62*86d7f5d3SJohn Marino 	struct kinfo_drivers *kd;
63*86d7f5d3SJohn Marino 
64*86d7f5d3SJohn Marino 	if (sysctlbyname("kern.drivers",NULL,&val_len,NULL,0) < 0) {
65*86d7f5d3SJohn Marino 		printf("sysctlbyname failed");
66*86d7f5d3SJohn Marino 		return 0;
67*86d7f5d3SJohn Marino 	}
68*86d7f5d3SJohn Marino 
69*86d7f5d3SJohn Marino 	if ((kd = malloc (val_len)) == NULL){
70*86d7f5d3SJohn Marino 		printf("malloc kd info error\n");
71*86d7f5d3SJohn Marino 		return 0;
72*86d7f5d3SJohn Marino 	}
73*86d7f5d3SJohn Marino 
74*86d7f5d3SJohn Marino 	if (sysctlbyname("kern.drivers", kd, &val_len, NULL, 0) < 0) {
75*86d7f5d3SJohn Marino 		printf("sysctlbyname failed kd");
76*86d7f5d3SJohn Marino 		return 0;
77*86d7f5d3SJohn Marino 	}
78*86d7f5d3SJohn Marino 
79*86d7f5d3SJohn Marino 	for (i = 0, val_len /= sizeof(*kd); i < val_len; i++) {
80*86d7f5d3SJohn Marino 
81*86d7f5d3SJohn Marino 		if (strncmp(kd[i].d_name,DM_NAME,strlen(kd[i].d_name)) == 0){
82*86d7f5d3SJohn Marino 
83*86d7f5d3SJohn Marino 			if (type == DM_CHAR_MAJOR)
84*86d7f5d3SJohn Marino 				/* Set major to dm-driver char major number. */
85*86d7f5d3SJohn Marino 				*major = kd[i].d_cmajor;
86*86d7f5d3SJohn Marino 			else
87*86d7f5d3SJohn Marino 				if (type == DM_BLOCK_MAJOR)
88*86d7f5d3SJohn Marino 					*major = kd[i].d_bmajor;
89*86d7f5d3SJohn Marino 
90*86d7f5d3SJohn Marino 			free(kd);
91*86d7f5d3SJohn Marino 
92*86d7f5d3SJohn Marino 			return 1;
93*86d7f5d3SJohn Marino 		}
94*86d7f5d3SJohn Marino 	}
95*86d7f5d3SJohn Marino 
96*86d7f5d3SJohn Marino 	free(kd);
97*86d7f5d3SJohn Marino 
98*86d7f5d3SJohn Marino 	return 0;
99*86d7f5d3SJohn Marino }
100*86d7f5d3SJohn Marino 
101*86d7f5d3SJohn Marino int
nbsd_dmi_add_version(const int * version,prop_dictionary_t dm_dict)102*86d7f5d3SJohn Marino nbsd_dmi_add_version(const int *version, prop_dictionary_t dm_dict)
103*86d7f5d3SJohn Marino {
104*86d7f5d3SJohn Marino 	prop_array_t ver;
105*86d7f5d3SJohn Marino 	size_t i;
106*86d7f5d3SJohn Marino 
107*86d7f5d3SJohn Marino 	if ((ver = prop_array_create()) == NULL)
108*86d7f5d3SJohn Marino 		return -1;
109*86d7f5d3SJohn Marino 
110*86d7f5d3SJohn Marino        	for (i=0;i<3;i++)
111*86d7f5d3SJohn Marino 		prop_array_set_uint32(ver,i,version[i]);
112*86d7f5d3SJohn Marino 
113*86d7f5d3SJohn Marino 	if ((prop_dictionary_set(dm_dict,"version",ver)) == false)
114*86d7f5d3SJohn Marino 		return -1;
115*86d7f5d3SJohn Marino 
116*86d7f5d3SJohn Marino 	prop_object_release(ver);
117*86d7f5d3SJohn Marino 
118*86d7f5d3SJohn Marino 	return 0;
119*86d7f5d3SJohn Marino }
120*86d7f5d3SJohn Marino 
121*86d7f5d3SJohn Marino struct dm_ioctl*
nbsd_dm_dict_to_dmi(prop_dictionary_t dm_dict,const int cmd)122*86d7f5d3SJohn Marino nbsd_dm_dict_to_dmi(prop_dictionary_t dm_dict,const int cmd)
123*86d7f5d3SJohn Marino {
124*86d7f5d3SJohn Marino 	struct dm_ioctl *dmi;
125*86d7f5d3SJohn Marino 	prop_array_t ver;
126*86d7f5d3SJohn Marino 
127*86d7f5d3SJohn Marino 	size_t i;
128*86d7f5d3SJohn Marino 	int r;
129*86d7f5d3SJohn Marino 	char *name, *uuid;
130*86d7f5d3SJohn Marino 	uint32_t major,minor;
131*86d7f5d3SJohn Marino 
132*86d7f5d3SJohn Marino 	name = NULL;
133*86d7f5d3SJohn Marino 	uuid = NULL;
134*86d7f5d3SJohn Marino 	minor = 0;
135*86d7f5d3SJohn Marino 
136*86d7f5d3SJohn Marino 	nbsd_get_dm_major(&major, DM_BLOCK_MAJOR);
137*86d7f5d3SJohn Marino 
138*86d7f5d3SJohn Marino 	if (!(dmi = dm_malloc(DMI_SIZE)))
139*86d7f5d3SJohn Marino 		return NULL;
140*86d7f5d3SJohn Marino 
141*86d7f5d3SJohn Marino 	memset(dmi,0,DMI_SIZE);
142*86d7f5d3SJohn Marino 
143*86d7f5d3SJohn Marino 	prop_dictionary_get_int32(dm_dict, DM_IOCTL_OPEN, &dmi->open_count);
144*86d7f5d3SJohn Marino 	prop_dictionary_get_uint32(dm_dict, DM_IOCTL_EVENT, &dmi->event_nr);
145*86d7f5d3SJohn Marino 	prop_dictionary_get_uint32(dm_dict, DM_IOCTL_FLAGS, &dmi->flags);
146*86d7f5d3SJohn Marino 	prop_dictionary_get_uint32(dm_dict, DM_IOCTL_TARGET_COUNT,
147*86d7f5d3SJohn Marino 		&dmi->target_count);
148*86d7f5d3SJohn Marino 
149*86d7f5d3SJohn Marino 	if (prop_dictionary_get_uint32(dm_dict, DM_IOCTL_MINOR, &minor))
150*86d7f5d3SJohn Marino 		dmi->dev = MKDEV(major, minor);
151*86d7f5d3SJohn Marino 	else
152*86d7f5d3SJohn Marino 		dmi->dev = 0;
153*86d7f5d3SJohn Marino 
154*86d7f5d3SJohn Marino 	/* Copy name and uuid to dm_ioctl. */
155*86d7f5d3SJohn Marino 	if (prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_NAME,
156*86d7f5d3SJohn Marino 		(const char **)&name)){
157*86d7f5d3SJohn Marino 		strlcpy(dmi->name, name, DM_NAME_LEN);
158*86d7f5d3SJohn Marino 	} else
159*86d7f5d3SJohn Marino 		dmi->name[0] = '\0';
160*86d7f5d3SJohn Marino 
161*86d7f5d3SJohn Marino 	if (prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_UUID,
162*86d7f5d3SJohn Marino 		(const char **)&uuid)){
163*86d7f5d3SJohn Marino 		strlcpy(dmi->uuid, uuid, DM_UUID_LEN);
164*86d7f5d3SJohn Marino 	}  else
165*86d7f5d3SJohn Marino 		dmi->uuid[0] = '\0';
166*86d7f5d3SJohn Marino 
167*86d7f5d3SJohn Marino 	/* dmi parsing values, size of dmi block and offset to data. */
168*86d7f5d3SJohn Marino 	dmi->data_size  = DMI_SIZE;
169*86d7f5d3SJohn Marino 	dmi->data_start = sizeof(struct dm_ioctl);
170*86d7f5d3SJohn Marino 
171*86d7f5d3SJohn Marino 	/* Get kernel version from dm_dict. */
172*86d7f5d3SJohn Marino 	ver = prop_dictionary_get(dm_dict,DM_IOCTL_VERSION);
173*86d7f5d3SJohn Marino 
174*86d7f5d3SJohn Marino 	for(i=0; i<3; i++)
175*86d7f5d3SJohn Marino 		prop_array_get_uint32(ver,i,&dmi->version[i]);
176*86d7f5d3SJohn Marino 
177*86d7f5d3SJohn Marino 	switch (cmd){
178*86d7f5d3SJohn Marino 
179*86d7f5d3SJohn Marino 	case DM_LIST_VERSIONS:
180*86d7f5d3SJohn Marino 		r = dm_list_versions(dm_dict,dmi);
181*86d7f5d3SJohn Marino 		if (r >= 0)
182*86d7f5d3SJohn Marino 			dmi->target_count = r;
183*86d7f5d3SJohn Marino 		break;
184*86d7f5d3SJohn Marino 
185*86d7f5d3SJohn Marino 	case DM_LIST_DEVICES:
186*86d7f5d3SJohn Marino 		r = dm_list_devices(dm_dict,dmi);
187*86d7f5d3SJohn Marino 		if (r >= 0)
188*86d7f5d3SJohn Marino 			dmi->target_count = r;
189*86d7f5d3SJohn Marino 		break;
190*86d7f5d3SJohn Marino 
191*86d7f5d3SJohn Marino 	case DM_TABLE_STATUS:
192*86d7f5d3SJohn Marino 		r = dm_table_status(dm_dict,dmi);
193*86d7f5d3SJohn Marino 		if (r >= 0)
194*86d7f5d3SJohn Marino 			dmi->target_count = r;
195*86d7f5d3SJohn Marino 		break;
196*86d7f5d3SJohn Marino 
197*86d7f5d3SJohn Marino 	case DM_TABLE_DEPS:
198*86d7f5d3SJohn Marino 		r = dm_dev_deps(dm_dict,dmi);
199*86d7f5d3SJohn Marino 		if (r >= 0)
200*86d7f5d3SJohn Marino 			dmi->target_count = r;
201*86d7f5d3SJohn Marino 		break;
202*86d7f5d3SJohn Marino 	}
203*86d7f5d3SJohn Marino 
204*86d7f5d3SJohn Marino 	return dmi;
205*86d7f5d3SJohn Marino }
206*86d7f5d3SJohn Marino 
207*86d7f5d3SJohn Marino /*
208*86d7f5d3SJohn Marino  * Parse dm_dict when targets command was called and fill dm_ioctl buffer with it.
209*86d7f5d3SJohn Marino  *
210*86d7f5d3SJohn Marino  * Return number of targets or if failed <0 error.
211*86d7f5d3SJohn Marino  */
212*86d7f5d3SJohn Marino 
213*86d7f5d3SJohn Marino static int
dm_list_versions(prop_dictionary_t dm_dict,struct dm_ioctl * dmi)214*86d7f5d3SJohn Marino dm_list_versions(prop_dictionary_t dm_dict, struct dm_ioctl *dmi)
215*86d7f5d3SJohn Marino {
216*86d7f5d3SJohn Marino 	struct dm_target_versions *dmtv,*odmtv;
217*86d7f5d3SJohn Marino 
218*86d7f5d3SJohn Marino 	prop_array_t targets,ver;
219*86d7f5d3SJohn Marino 	prop_dictionary_t target_dict;
220*86d7f5d3SJohn Marino 	prop_object_iterator_t iter;
221*86d7f5d3SJohn Marino 
222*86d7f5d3SJohn Marino 	char *name;
223*86d7f5d3SJohn Marino 	size_t j,i,slen,rec_size;
224*86d7f5d3SJohn Marino 
225*86d7f5d3SJohn Marino 	odmtv = NULL;
226*86d7f5d3SJohn Marino 	name = NULL;
227*86d7f5d3SJohn Marino 	j = 0;
228*86d7f5d3SJohn Marino 
229*86d7f5d3SJohn Marino 	dmtv = (struct dm_target_versions *)((uint8_t *)dmi + dmi->data_start);
230*86d7f5d3SJohn Marino 
231*86d7f5d3SJohn Marino /*	printf("dmi: vers: %d.%d.%d data_size: %d data_start: %d name: %s t_count: %d\n",
232*86d7f5d3SJohn Marino 	    dmi->version[0],dmi->version[1],dmi->version[2],dmi->data_size,dmi->data_start,
233*86d7f5d3SJohn Marino 	    dmi->name,dmi->target_count);
234*86d7f5d3SJohn Marino 
235*86d7f5d3SJohn Marino 	printf("dmi: size: %d -- %p --- %p \n",sizeof(struct dm_ioctl),dmi,dmi+dmi->data_start);
236*86d7f5d3SJohn Marino 	printf("dmtv: size: %p --- %p\n",dmtv,(struct dm_target_versions *)(dmi+312));*/
237*86d7f5d3SJohn Marino 
238*86d7f5d3SJohn Marino 	/* get prop_array of target_version dictionaries */
239*86d7f5d3SJohn Marino 	if ((targets = prop_dictionary_get(dm_dict,DM_IOCTL_CMD_DATA))){
240*86d7f5d3SJohn Marino 
241*86d7f5d3SJohn Marino 		iter = prop_array_iterator(targets);
242*86d7f5d3SJohn Marino 		if (!iter)
243*86d7f5d3SJohn Marino 			err(EXIT_FAILURE,"dm_list_versions %s",__func__);
244*86d7f5d3SJohn Marino 
245*86d7f5d3SJohn Marino 		while((target_dict = prop_object_iterator_next(iter)) != NULL){
246*86d7f5d3SJohn Marino 			j++;
247*86d7f5d3SJohn Marino 
248*86d7f5d3SJohn Marino 			prop_dictionary_get_cstring_nocopy(target_dict,
249*86d7f5d3SJohn Marino 			    DM_TARGETS_NAME,(const char **)&name);
250*86d7f5d3SJohn Marino 
251*86d7f5d3SJohn Marino 			slen = strlen(name) + 1;
252*86d7f5d3SJohn Marino 			rec_size = sizeof(struct dm_target_versions) + slen + 1;
253*86d7f5d3SJohn Marino 
254*86d7f5d3SJohn Marino 			if (rec_size > dmi->data_size)
255*86d7f5d3SJohn Marino 				return -ENOMEM;
256*86d7f5d3SJohn Marino 
257*86d7f5d3SJohn Marino 			ver = prop_dictionary_get(target_dict,DM_TARGETS_VERSION);
258*86d7f5d3SJohn Marino 
259*86d7f5d3SJohn Marino 			for (i=0; i<3; i++)
260*86d7f5d3SJohn Marino 				prop_array_get_uint32(ver,i,&dmtv->version[i]);
261*86d7f5d3SJohn Marino 
262*86d7f5d3SJohn Marino 			dmtv->next = rec_size;
263*86d7f5d3SJohn Marino 
264*86d7f5d3SJohn Marino 			strlcpy(dmtv->name,name,slen);
265*86d7f5d3SJohn Marino 
266*86d7f5d3SJohn Marino 			odmtv = dmtv;
267*86d7f5d3SJohn Marino 
268*86d7f5d3SJohn Marino 			dmtv =(struct dm_target_versions *)((uint8_t *)dmtv + rec_size);
269*86d7f5d3SJohn Marino 		}
270*86d7f5d3SJohn Marino 
271*86d7f5d3SJohn Marino 		if (odmtv != NULL)
272*86d7f5d3SJohn Marino 			odmtv->next = 0;
273*86d7f5d3SJohn Marino 	}
274*86d7f5d3SJohn Marino 
275*86d7f5d3SJohn Marino 	prop_object_iterator_release(iter);
276*86d7f5d3SJohn Marino 	return j;
277*86d7f5d3SJohn Marino }
278*86d7f5d3SJohn Marino 
279*86d7f5d3SJohn Marino /*
280*86d7f5d3SJohn Marino  * List all available dm devices in system.
281*86d7f5d3SJohn Marino  */
282*86d7f5d3SJohn Marino static int
dm_list_devices(prop_dictionary_t dm_dict,struct dm_ioctl * dmi)283*86d7f5d3SJohn Marino dm_list_devices(prop_dictionary_t dm_dict, struct dm_ioctl *dmi)
284*86d7f5d3SJohn Marino {
285*86d7f5d3SJohn Marino 	struct dm_name_list *dml,*odml;
286*86d7f5d3SJohn Marino 
287*86d7f5d3SJohn Marino 	prop_array_t targets;
288*86d7f5d3SJohn Marino 	prop_dictionary_t target_dict;
289*86d7f5d3SJohn Marino 	prop_object_iterator_t iter;
290*86d7f5d3SJohn Marino 
291*86d7f5d3SJohn Marino 	uint32_t minor;
292*86d7f5d3SJohn Marino 	uint32_t major;
293*86d7f5d3SJohn Marino 
294*86d7f5d3SJohn Marino 	char *name;
295*86d7f5d3SJohn Marino 	size_t j,slen,rec_size;
296*86d7f5d3SJohn Marino 
297*86d7f5d3SJohn Marino 	odml = NULL;
298*86d7f5d3SJohn Marino 	name = NULL;
299*86d7f5d3SJohn Marino 	minor = 0;
300*86d7f5d3SJohn Marino 	j = 0;
301*86d7f5d3SJohn Marino 
302*86d7f5d3SJohn Marino 	nbsd_get_dm_major(&major,DM_BLOCK_MAJOR);
303*86d7f5d3SJohn Marino 
304*86d7f5d3SJohn Marino 	dml = (struct dm_name_list *)((uint8_t *)dmi + dmi->data_start);
305*86d7f5d3SJohn Marino 
306*86d7f5d3SJohn Marino 	if ((targets = prop_dictionary_get(dm_dict,DM_IOCTL_CMD_DATA))){
307*86d7f5d3SJohn Marino 
308*86d7f5d3SJohn Marino 		iter = prop_array_iterator(targets);
309*86d7f5d3SJohn Marino 		if (!iter)
310*86d7f5d3SJohn Marino 			err(EXIT_FAILURE,"dm_list_devices %s",__func__);
311*86d7f5d3SJohn Marino 
312*86d7f5d3SJohn Marino 		while((target_dict = prop_object_iterator_next(iter)) != NULL){
313*86d7f5d3SJohn Marino 
314*86d7f5d3SJohn Marino 			prop_dictionary_get_cstring_nocopy(target_dict,
315*86d7f5d3SJohn Marino 			    DM_DEV_NAME,(const char **)&name);
316*86d7f5d3SJohn Marino 
317*86d7f5d3SJohn Marino 			prop_dictionary_get_uint32(target_dict,DM_DEV_DEV,&minor);
318*86d7f5d3SJohn Marino 
319*86d7f5d3SJohn Marino 			dml->dev = MKDEV(major,minor);
320*86d7f5d3SJohn Marino 
321*86d7f5d3SJohn Marino 			slen = strlen(name) + 1;
322*86d7f5d3SJohn Marino 			rec_size = sizeof(struct dm_name_list) + slen + 1;
323*86d7f5d3SJohn Marino 
324*86d7f5d3SJohn Marino 			if (rec_size > dmi->data_size)
325*86d7f5d3SJohn Marino 				return -ENOMEM;
326*86d7f5d3SJohn Marino 
327*86d7f5d3SJohn Marino 			dml->next = rec_size;
328*86d7f5d3SJohn Marino 
329*86d7f5d3SJohn Marino 			strlcpy(dml->name,name,slen);
330*86d7f5d3SJohn Marino 
331*86d7f5d3SJohn Marino 			odml = dml;
332*86d7f5d3SJohn Marino 
333*86d7f5d3SJohn Marino 			dml =(struct dm_name_list *)((uint8_t *)dml + rec_size);
334*86d7f5d3SJohn Marino 
335*86d7f5d3SJohn Marino 			j++;
336*86d7f5d3SJohn Marino 		}
337*86d7f5d3SJohn Marino 
338*86d7f5d3SJohn Marino 		if (odml != NULL)
339*86d7f5d3SJohn Marino 			odml->next = 0;
340*86d7f5d3SJohn Marino 	}
341*86d7f5d3SJohn Marino 	prop_object_iterator_release(iter);
342*86d7f5d3SJohn Marino 	return j;
343*86d7f5d3SJohn Marino }
344*86d7f5d3SJohn Marino 
345*86d7f5d3SJohn Marino /*
346*86d7f5d3SJohn Marino  * Print status of each table, target arguments, start sector,
347*86d7f5d3SJohn Marino  * size and target name.
348*86d7f5d3SJohn Marino  */
349*86d7f5d3SJohn Marino static int
dm_table_status(prop_dictionary_t dm_dict,struct dm_ioctl * dmi)350*86d7f5d3SJohn Marino dm_table_status(prop_dictionary_t dm_dict,struct dm_ioctl *dmi)
351*86d7f5d3SJohn Marino {
352*86d7f5d3SJohn Marino 	struct dm_target_spec *dmts, *odmts;
353*86d7f5d3SJohn Marino 
354*86d7f5d3SJohn Marino 	prop_array_t targets;
355*86d7f5d3SJohn Marino 	prop_dictionary_t target_dict;
356*86d7f5d3SJohn Marino 	prop_object_iterator_t iter;
357*86d7f5d3SJohn Marino 
358*86d7f5d3SJohn Marino 	char *type,*params,*params_start;
359*86d7f5d3SJohn Marino 
360*86d7f5d3SJohn Marino 	bool prm;
361*86d7f5d3SJohn Marino 	size_t j,plen,rec_size,next;
362*86d7f5d3SJohn Marino 
363*86d7f5d3SJohn Marino 	j = 0;
364*86d7f5d3SJohn Marino 	next = 0;
365*86d7f5d3SJohn Marino 	params = NULL;
366*86d7f5d3SJohn Marino 	odmts = NULL;
367*86d7f5d3SJohn Marino 	rec_size = 0;
368*86d7f5d3SJohn Marino 	plen = -1;
369*86d7f5d3SJohn Marino 	prm = false;
370*86d7f5d3SJohn Marino 
371*86d7f5d3SJohn Marino 	dmts = (struct dm_target_spec *)((uint8_t *)dmi + dmi->data_start);
372*86d7f5d3SJohn Marino 
373*86d7f5d3SJohn Marino 	if ((targets = prop_dictionary_get(dm_dict,DM_IOCTL_CMD_DATA))){
374*86d7f5d3SJohn Marino 
375*86d7f5d3SJohn Marino 		iter = prop_array_iterator(targets);
376*86d7f5d3SJohn Marino 		if (!iter)
377*86d7f5d3SJohn Marino 			err(EXIT_FAILURE,"dm_table_status %s",__func__);
378*86d7f5d3SJohn Marino 
379*86d7f5d3SJohn Marino 		while((target_dict = prop_object_iterator_next(iter)) != NULL){
380*86d7f5d3SJohn Marino 
381*86d7f5d3SJohn Marino 			prop_dictionary_get_cstring_nocopy(target_dict,
382*86d7f5d3SJohn Marino 			    DM_TABLE_TYPE,(const char **)&type);
383*86d7f5d3SJohn Marino 
384*86d7f5d3SJohn Marino 			prm = prop_dictionary_get_cstring_nocopy(target_dict,
385*86d7f5d3SJohn Marino 			    DM_TABLE_PARAMS,(const char **)&params);
386*86d7f5d3SJohn Marino 
387*86d7f5d3SJohn Marino 			prop_dictionary_get_uint64(target_dict,DM_TABLE_START,&dmts->sector_start);
388*86d7f5d3SJohn Marino 			prop_dictionary_get_uint64(target_dict,DM_TABLE_LENGTH,&dmts->length);
389*86d7f5d3SJohn Marino 			prop_dictionary_get_int32(target_dict,DM_TABLE_STAT,&dmts->status);
390*86d7f5d3SJohn Marino 
391*86d7f5d3SJohn Marino 			if (prm)
392*86d7f5d3SJohn Marino 				plen = strlen(params) + 1;
393*86d7f5d3SJohn Marino 
394*86d7f5d3SJohn Marino 			rec_size = sizeof(struct dm_target_spec) + plen;
395*86d7f5d3SJohn Marino 
396*86d7f5d3SJohn Marino 			/*
397*86d7f5d3SJohn Marino 			 * In linux when copying table status from kernel next is
398*86d7f5d3SJohn Marino 			 * number of bytes from the start of the first dm_target_spec
399*86d7f5d3SJohn Marino 			 * structure. I don't know why but, it has to be done this way.
400*86d7f5d3SJohn Marino 			 */
401*86d7f5d3SJohn Marino 			next += rec_size;
402*86d7f5d3SJohn Marino 
403*86d7f5d3SJohn Marino 			if (rec_size > dmi->data_size)
404*86d7f5d3SJohn Marino 				return -ENOMEM;
405*86d7f5d3SJohn Marino 
406*86d7f5d3SJohn Marino 			dmts->next = next;
407*86d7f5d3SJohn Marino 
408*86d7f5d3SJohn Marino 			strlcpy(dmts->target_type, type, DM_MAX_TYPE_NAME);
409*86d7f5d3SJohn Marino 
410*86d7f5d3SJohn Marino 			params_start = (char *)dmts + sizeof(struct dm_target_spec);
411*86d7f5d3SJohn Marino 
412*86d7f5d3SJohn Marino 			if (prm)
413*86d7f5d3SJohn Marino 				strlcpy(params_start, params, plen);
414*86d7f5d3SJohn Marino 			else
415*86d7f5d3SJohn Marino 				params_start = "\0";
416*86d7f5d3SJohn Marino 
417*86d7f5d3SJohn Marino 
418*86d7f5d3SJohn Marino 			odmts = dmts;
419*86d7f5d3SJohn Marino 
420*86d7f5d3SJohn Marino 			dmts = (struct dm_target_spec *)((uint8_t *)dmts + rec_size);
421*86d7f5d3SJohn Marino 
422*86d7f5d3SJohn Marino 			j++;
423*86d7f5d3SJohn Marino 
424*86d7f5d3SJohn Marino 		}
425*86d7f5d3SJohn Marino 
426*86d7f5d3SJohn Marino 		if (odmts != NULL)
427*86d7f5d3SJohn Marino 			odmts->next = 0;
428*86d7f5d3SJohn Marino 	}
429*86d7f5d3SJohn Marino 	prop_object_iterator_release(iter);
430*86d7f5d3SJohn Marino 
431*86d7f5d3SJohn Marino 	return j;
432*86d7f5d3SJohn Marino }
433*86d7f5d3SJohn Marino 
434*86d7f5d3SJohn Marino /*
435*86d7f5d3SJohn Marino  * Print dm device dependiences, get minor/major number for
436*86d7f5d3SJohn Marino  * devices. From kernel I will receive major:minor number of
437*86d7f5d3SJohn Marino  * block device used with target. I have to translate it to
438*86d7f5d3SJohn Marino  * raw device numbers and use them, because all other parts of lvm2
439*86d7f5d3SJohn Marino  * uses raw devices internaly.
440*86d7f5d3SJohn Marino  */
441*86d7f5d3SJohn Marino static int
dm_dev_deps(prop_dictionary_t dm_dict,struct dm_ioctl * dmi)442*86d7f5d3SJohn Marino dm_dev_deps(prop_dictionary_t dm_dict, struct dm_ioctl *dmi)
443*86d7f5d3SJohn Marino {
444*86d7f5d3SJohn Marino 	struct dm_target_deps *dmtd;
445*86d7f5d3SJohn Marino 	struct kinfo_drivers *kd;
446*86d7f5d3SJohn Marino 
447*86d7f5d3SJohn Marino 	prop_array_t targets;
448*86d7f5d3SJohn Marino 	prop_object_iterator_t iter;
449*86d7f5d3SJohn Marino 
450*86d7f5d3SJohn Marino 	uint32_t major;
451*86d7f5d3SJohn Marino 
452*86d7f5d3SJohn Marino 	size_t val_len, i, j;
453*86d7f5d3SJohn Marino 
454*86d7f5d3SJohn Marino 	uint64_t dev_tmp;
455*86d7f5d3SJohn Marino 
456*86d7f5d3SJohn Marino 	dev_tmp = 0;
457*86d7f5d3SJohn Marino 	j = 0;
458*86d7f5d3SJohn Marino 	i = 0;
459*86d7f5d3SJohn Marino 
460*86d7f5d3SJohn Marino 	if (sysctlbyname("kern.drivers",NULL,&val_len,NULL,0) < 0) {
461*86d7f5d3SJohn Marino 		printf("sysctlbyname failed");
462*86d7f5d3SJohn Marino 		return 0;
463*86d7f5d3SJohn Marino 	}
464*86d7f5d3SJohn Marino 
465*86d7f5d3SJohn Marino 	if ((kd = malloc (val_len)) == NULL){
466*86d7f5d3SJohn Marino 		printf("malloc kd info error\n");
467*86d7f5d3SJohn Marino 		return 0;
468*86d7f5d3SJohn Marino 	}
469*86d7f5d3SJohn Marino 
470*86d7f5d3SJohn Marino 	if (sysctlbyname("kern.drivers", kd, &val_len, NULL, 0) < 0) {
471*86d7f5d3SJohn Marino 		printf("sysctlbyname failed kd");
472*86d7f5d3SJohn Marino 		return 0;
473*86d7f5d3SJohn Marino 	}
474*86d7f5d3SJohn Marino 
475*86d7f5d3SJohn Marino 	dmtd = (struct dm_target_deps *)((uint8_t *)dmi + dmi->data_start);
476*86d7f5d3SJohn Marino 
477*86d7f5d3SJohn Marino 	if ((targets = prop_dictionary_get(dm_dict, DM_IOCTL_CMD_DATA))){
478*86d7f5d3SJohn Marino 
479*86d7f5d3SJohn Marino 		iter = prop_array_iterator(targets);
480*86d7f5d3SJohn Marino 		if (!iter)
481*86d7f5d3SJohn Marino 			err(EXIT_FAILURE,"dm_target_deps %s", __func__);
482*86d7f5d3SJohn Marino 
483*86d7f5d3SJohn Marino 		while((prop_object_iterator_next(iter)) != NULL){
484*86d7f5d3SJohn Marino 
485*86d7f5d3SJohn Marino 			prop_array_get_uint64(targets, j, &dev_tmp);
486*86d7f5d3SJohn Marino 
487*86d7f5d3SJohn Marino 			for (i = 0, val_len /= sizeof(*kd); i < val_len; i++){
488*86d7f5d3SJohn Marino 				if (kd[i].d_bmajor == MAJOR(dev_tmp)) {
489*86d7f5d3SJohn Marino 					major = kd[i].d_cmajor;
490*86d7f5d3SJohn Marino 					break;
491*86d7f5d3SJohn Marino 				}
492*86d7f5d3SJohn Marino 			}
493*86d7f5d3SJohn Marino 
494*86d7f5d3SJohn Marino 			dmtd->dev[j] = MKDEV(major,MINOR(dev_tmp));
495*86d7f5d3SJohn Marino 
496*86d7f5d3SJohn Marino 			j++;
497*86d7f5d3SJohn Marino 		}
498*86d7f5d3SJohn Marino 	}
499*86d7f5d3SJohn Marino 
500*86d7f5d3SJohn Marino 	dmtd->count = j;
501*86d7f5d3SJohn Marino 
502*86d7f5d3SJohn Marino 	prop_object_iterator_release(iter);
503*86d7f5d3SJohn Marino 
504*86d7f5d3SJohn Marino 	return j;
505*86d7f5d3SJohn Marino }
506