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