dev.c revision bb47c2a4aff6ec6b9be7f30cd04cf7c858a84de4 
1/*
2 * dev.c - allocation/initialization/free routines for dev
3 *
4 * Copyright (C) 2001 Andreas Dilger
5 * Copyright (C) 2003 Theodore Ts'o
6 *
7 * %Begin-Header%
8 * This file may be redistributed under the terms of the
9 * GNU Lesser General Public License.
10 * %End-Header%
11 */
12
13#include <stdlib.h>
14#include <string.h>
15
16#include "blkidP.h"
17
18blkid_dev blkid_new_dev(void)
19{
20	blkid_dev dev;
21
22	if (!(dev = (blkid_dev) calloc(1, sizeof(struct blkid_struct_dev))))
23		return NULL;
24
25	INIT_LIST_HEAD(&dev->bid_devs);
26	INIT_LIST_HEAD(&dev->bid_tags);
27
28	return dev;
29}
30
31void blkid_free_dev(blkid_dev dev)
32{
33	if (!dev)
34		return;
35
36	DBG(DEBUG_DEV,
37	    printf("  freeing dev %s (%s)\n", dev->bid_name, dev->bid_type ?
38		   dev->bid_type : "(null)"));
39	DBG(DEBUG_DEV, blkid_debug_dump_dev(dev));
40
41	list_del(&dev->bid_devs);
42	while (!list_empty(&dev->bid_tags)) {
43		blkid_tag tag = list_entry(dev->bid_tags.next,
44					   struct blkid_struct_tag,
45					   bit_tags);
46		blkid_free_tag(tag);
47	}
48	if (dev->bid_name)
49		free(dev->bid_name);
50	free(dev);
51}
52
53/*
54 * Given a blkid device, return its name
55 */
56extern const char *blkid_dev_devname(blkid_dev dev)
57{
58	return dev->bid_name;
59}
60
61#ifdef CONFIG_BLKID_DEBUG
62void blkid_debug_dump_dev(blkid_dev dev)
63{
64	struct list_head *p;
65
66	if (!dev) {
67		printf("  dev: NULL\n");
68		return;
69	}
70
71	printf("  dev: name = %s\n", dev->bid_name);
72	printf("  dev: DEVNO=\"0x%0llx\"\n", (long long)dev->bid_devno);
73	printf("  dev: TIME=\"%ld\"\n", (long)dev->bid_time);
74	printf("  dev: PRI=\"%d\"\n", dev->bid_pri);
75	printf("  dev: flags = 0x%08X\n", dev->bid_flags);
76
77	list_for_each(p, &dev->bid_tags) {
78		blkid_tag tag = list_entry(p, struct blkid_struct_tag, bit_tags);
79		if (tag)
80			printf("    tag: %s=\"%s\"\n", tag->bit_name,
81			       tag->bit_val);
82		else
83			printf("    tag: NULL\n");
84	}
85	printf("\n");
86}
87#endif
88
89/*
90 * dev iteration routines for the public libblkid interface.
91 *
92 * These routines do not expose the list.h implementation, which are a
93 * contamination of the namespace, and which force us to reveal far, far
94 * too much of our internal implemenation.  I'm not convinced I want
95 * to keep list.h in the long term, anyway.  It's fine for kernel
96 * programming, but performance is not the #1 priority for this
97 * library, and I really don't like the tradeoff of type-safety for
98 * performance for this application.  [tytso:20030125.2007EST]
99 */
100
101/*
102 * This series of functions iterate over all devices in a blkid cache
103 */
104#define DEV_ITERATE_MAGIC	0x01a5284c
105
106struct blkid_struct_dev_iterate {
107	int			magic;
108	blkid_cache		cache;
109	char			*search_type;
110	char			*search_value;
111	struct list_head	*p;
112};
113
114extern blkid_dev_iterate blkid_dev_iterate_begin(blkid_cache cache)
115{
116	blkid_dev_iterate	iter;
117
118	iter = malloc(sizeof(struct blkid_struct_dev_iterate));
119	if (iter) {
120		iter->magic = DEV_ITERATE_MAGIC;
121		iter->cache = cache;
122		iter->p	= cache->bic_devs.next;
123		iter->search_type = 0;
124		iter->search_value = 0;
125	}
126	return (iter);
127}
128
129extern int blkid_dev_set_search(blkid_dev_iterate iter,
130				 char *search_type, char *search_value)
131{
132	char *new_type, *new_value;
133
134	if (!iter || iter->magic != DEV_ITERATE_MAGIC || !search_type ||
135	    !search_value)
136		return -1;
137	new_type = malloc(strlen(search_type)+1);
138	new_value = malloc(strlen(search_value)+1);
139	if (!new_type || !new_value) {
140		if (new_type)
141			free(new_type);
142		if (new_value)
143			free(new_value);
144		return -1;
145	}
146	strcpy(new_type, search_type);
147	strcpy(new_value, search_value);
148	if (iter->search_type)
149		free(iter->search_type);
150	if (iter->search_value)
151		free(iter->search_value);
152	iter->search_type = new_type;
153	iter->search_value = new_value;
154	return 0;
155}
156
157/*
158 * Return 0 on success, -1 on error
159 */
160extern int blkid_dev_next(blkid_dev_iterate iter,
161			  blkid_dev *ret_dev)
162{
163	blkid_dev		dev;
164
165	*ret_dev = 0;
166	if (!iter || iter->magic != DEV_ITERATE_MAGIC)
167		return -1;
168	while (iter->p != &iter->cache->bic_devs) {
169		dev = list_entry(iter->p, struct blkid_struct_dev, bid_devs);
170		iter->p = iter->p->next;
171		if (iter->search_type &&
172		    !blkid_dev_has_tag(dev, iter->search_type,
173				       iter->search_value))
174			continue;
175		*ret_dev = dev;
176		return 0;
177	}
178	return -1;
179}
180
181extern void blkid_dev_iterate_end(blkid_dev_iterate iter)
182{
183	if (!iter || iter->magic != DEV_ITERATE_MAGIC)
184		return;
185	iter->magic = 0;
186	free(iter);
187}
188
189#ifdef TEST_PROGRAM
190#ifdef HAVE_GETOPT_H
191#include <getopt.h>
192#else
193extern char *optarg;
194extern int optind;
195#endif
196
197void usage(char *prog)
198{
199	fprintf(stderr, "Usage: %s [-f blkid_file] [-m debug_mask]\n", prog);
200	fprintf(stderr, "\tList all devices and exit\n");
201	exit(1);
202}
203
204int main(int argc, char **argv)
205{
206	blkid_dev_iterate	iter;
207	blkid_cache 		cache = NULL;
208	blkid_dev		dev;
209	int			c, ret;
210	char			*tmp;
211	char			*file = NULL;
212	char			*search_type = NULL;
213	char			*search_value = NULL;
214
215	while ((c = getopt (argc, argv, "m:f:")) != EOF)
216		switch (c) {
217		case 'f':
218			file = optarg;
219			break;
220		case 'm':
221			blkid_debug_mask = strtoul (optarg, &tmp, 0);
222			if (*tmp) {
223				fprintf(stderr, "Invalid debug mask: %s\n",
224					optarg);
225				exit(1);
226			}
227			break;
228		case '?':
229			usage(argv[0]);
230		}
231	if (argc >= optind+2) {
232		search_type = argv[optind];
233		search_value = argv[optind+1];
234		optind += 2;
235	}
236	if (argc != optind)
237		usage(argv[0]);
238
239	if ((ret = blkid_get_cache(&cache, file)) != 0) {
240		fprintf(stderr, "%s: error creating cache (%d)\n",
241			argv[0], ret);
242		exit(1);
243	}
244
245	iter = blkid_dev_iterate_begin(cache);
246	if (search_type)
247		blkid_dev_set_search(iter, search_type, search_value);
248	while (blkid_dev_next(iter, &dev) == 0) {
249		printf("Device: %s\n", blkid_dev_devname(dev));
250	}
251	blkid_dev_iterate_end(iter);
252
253
254	blkid_put_cache(cache);
255	return (0);
256}
257#endif
258