]>
Commit | Line | Data |
---|---|---|
e12f2ae7 TT |
1 | /* |
2 | * dev.c - allocation/initialization/free routines for dev | |
3 | * | |
4 | * Copyright (C) 2001 Andreas Dilger | |
50b380b4 | 5 | * Copyright (C) 2003 Theodore Ts'o |
e12f2ae7 TT |
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 | ||
d1154eb4 | 13 | #include "config.h" |
e12f2ae7 TT |
14 | #include <stdlib.h> |
15 | #include <string.h> | |
16 | ||
7a603aa8 | 17 | #include "blkidP.h" |
e12f2ae7 | 18 | |
7a603aa8 | 19 | blkid_dev blkid_new_dev(void) |
e12f2ae7 | 20 | { |
7a603aa8 | 21 | blkid_dev dev; |
e12f2ae7 | 22 | |
7a603aa8 | 23 | if (!(dev = (blkid_dev) calloc(1, sizeof(struct blkid_struct_dev)))) |
e12f2ae7 TT |
24 | return NULL; |
25 | ||
26 | INIT_LIST_HEAD(&dev->bid_devs); | |
27 | INIT_LIST_HEAD(&dev->bid_tags); | |
28 | ||
29 | return dev; | |
30 | } | |
31 | ||
7a603aa8 | 32 | void blkid_free_dev(blkid_dev dev) |
e12f2ae7 TT |
33 | { |
34 | if (!dev) | |
35 | return; | |
36 | ||
f0a22d0f | 37 | DBG(DEBUG_DEV, |
bb47c2a4 TT |
38 | printf(" freeing dev %s (%s)\n", dev->bid_name, dev->bid_type ? |
39 | dev->bid_type : "(null)")); | |
78c7d0ef | 40 | DBG(DEBUG_DEV, blkid_debug_dump_dev(dev)); |
e12f2ae7 TT |
41 | |
42 | list_del(&dev->bid_devs); | |
43 | while (!list_empty(&dev->bid_tags)) { | |
7a603aa8 TT |
44 | blkid_tag tag = list_entry(dev->bid_tags.next, |
45 | struct blkid_struct_tag, | |
46 | bit_tags); | |
e12f2ae7 TT |
47 | blkid_free_tag(tag); |
48 | } | |
45e338f5 | 49 | free(dev->bid_name); |
e12f2ae7 TT |
50 | free(dev); |
51 | } | |
52 | ||
7a603aa8 TT |
53 | /* |
54 | * Given a blkid device, return its name | |
55 | */ | |
98999c39 | 56 | extern const char *blkid_dev_devname(blkid_dev dev) |
7a603aa8 TT |
57 | { |
58 | return dev->bid_name; | |
59 | } | |
60 | ||
78c7d0ef TT |
61 | #ifdef CONFIG_BLKID_DEBUG |
62 | void 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); | |
12a829dc MA |
72 | printf(" dev: DEVNO=\"0x%0llx\"\n", (long long)dev->bid_devno); |
73 | printf(" dev: TIME=\"%ld\"\n", (long)dev->bid_time); | |
78c7d0ef TT |
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); | |
55080a76 | 79 | if (tag) |
efc6f628 | 80 | printf(" tag: %s=\"%s\"\n", tag->bit_name, |
55080a76 TT |
81 | tag->bit_val); |
82 | else | |
83 | printf(" tag: NULL\n"); | |
78c7d0ef TT |
84 | } |
85 | printf("\n"); | |
86 | } | |
87 | #endif | |
88 | ||
7a603aa8 TT |
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 | |
055866d8 | 94 | * too much of our internal implementation. I'm not convinced I want |
7a603aa8 TT |
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 | |
efc6f628 | 105 | |
7a603aa8 TT |
106 | struct blkid_struct_dev_iterate { |
107 | int magic; | |
108 | blkid_cache cache; | |
c37543df TT |
109 | char *search_type; |
110 | char *search_value; | |
7a603aa8 TT |
111 | struct list_head *p; |
112 | }; | |
113 | ||
114 | extern 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; | |
c37543df TT |
123 | iter->search_type = 0; |
124 | iter->search_value = 0; | |
7a603aa8 TT |
125 | } |
126 | return (iter); | |
127 | } | |
128 | ||
c37543df TT |
129 | extern int blkid_dev_set_search(blkid_dev_iterate iter, |
130 | char *search_type, char *search_value) | |
131 | { | |
132 | char *new_type, *new_value; | |
133 | ||
efc6f628 | 134 | if (!iter || iter->magic != DEV_ITERATE_MAGIC || !search_type || |
c37543df TT |
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) { | |
45e338f5 JM |
140 | free(new_type); |
141 | free(new_value); | |
c37543df TT |
142 | return -1; |
143 | } | |
144 | strcpy(new_type, search_type); | |
145 | strcpy(new_value, search_value); | |
45e338f5 JM |
146 | free(iter->search_type); |
147 | free(iter->search_value); | |
c37543df TT |
148 | iter->search_type = new_type; |
149 | iter->search_value = new_value; | |
150 | return 0; | |
151 | } | |
152 | ||
7a603aa8 TT |
153 | /* |
154 | * Return 0 on success, -1 on error | |
155 | */ | |
156 | extern int blkid_dev_next(blkid_dev_iterate iter, | |
c37543df | 157 | blkid_dev *ret_dev) |
7a603aa8 | 158 | { |
c37543df TT |
159 | blkid_dev dev; |
160 | ||
161 | *ret_dev = 0; | |
162 | if (!iter || iter->magic != DEV_ITERATE_MAGIC) | |
7a603aa8 | 163 | return -1; |
c37543df TT |
164 | while (iter->p != &iter->cache->bic_devs) { |
165 | dev = list_entry(iter->p, struct blkid_struct_dev, bid_devs); | |
166 | iter->p = iter->p->next; | |
efc6f628 TT |
167 | if (iter->search_type && |
168 | !blkid_dev_has_tag(dev, iter->search_type, | |
c37543df TT |
169 | iter->search_value)) |
170 | continue; | |
171 | *ret_dev = dev; | |
172 | return 0; | |
173 | } | |
174 | return -1; | |
7a603aa8 TT |
175 | } |
176 | ||
177 | extern void blkid_dev_iterate_end(blkid_dev_iterate iter) | |
178 | { | |
179 | if (!iter || iter->magic != DEV_ITERATE_MAGIC) | |
180 | return; | |
181 | iter->magic = 0; | |
182 | free(iter); | |
183 | } | |
184 | ||
c37543df TT |
185 | #ifdef TEST_PROGRAM |
186 | #ifdef HAVE_GETOPT_H | |
187 | #include <getopt.h> | |
188 | #else | |
189 | extern char *optarg; | |
190 | extern int optind; | |
191 | #endif | |
192 | ||
193 | void usage(char *prog) | |
194 | { | |
195 | fprintf(stderr, "Usage: %s [-f blkid_file] [-m debug_mask]\n", prog); | |
12a829dc | 196 | fprintf(stderr, "\tList all devices and exit\n"); |
c37543df TT |
197 | exit(1); |
198 | } | |
199 | ||
200 | int main(int argc, char **argv) | |
201 | { | |
202 | blkid_dev_iterate iter; | |
203 | blkid_cache cache = NULL; | |
204 | blkid_dev dev; | |
205 | int c, ret; | |
206 | char *tmp; | |
207 | char *file = NULL; | |
208 | char *search_type = NULL; | |
209 | char *search_value = NULL; | |
210 | ||
211 | while ((c = getopt (argc, argv, "m:f:")) != EOF) | |
212 | switch (c) { | |
213 | case 'f': | |
214 | file = optarg; | |
215 | break; | |
216 | case 'm': | |
217 | blkid_debug_mask = strtoul (optarg, &tmp, 0); | |
218 | if (*tmp) { | |
efc6f628 | 219 | fprintf(stderr, "Invalid debug mask: %s\n", |
c37543df TT |
220 | optarg); |
221 | exit(1); | |
222 | } | |
223 | break; | |
224 | case '?': | |
225 | usage(argv[0]); | |
226 | } | |
227 | if (argc >= optind+2) { | |
228 | search_type = argv[optind]; | |
229 | search_value = argv[optind+1]; | |
230 | optind += 2; | |
231 | } | |
232 | if (argc != optind) | |
233 | usage(argv[0]); | |
234 | ||
235 | if ((ret = blkid_get_cache(&cache, file)) != 0) { | |
236 | fprintf(stderr, "%s: error creating cache (%d)\n", | |
237 | argv[0], ret); | |
238 | exit(1); | |
239 | } | |
240 | ||
241 | iter = blkid_dev_iterate_begin(cache); | |
242 | if (search_type) | |
243 | blkid_dev_set_search(iter, search_type, search_value); | |
244 | while (blkid_dev_next(iter, &dev) == 0) { | |
245 | printf("Device: %s\n", blkid_dev_devname(dev)); | |
246 | } | |
247 | blkid_dev_iterate_end(iter); | |
248 | ||
249 | ||
250 | blkid_put_cache(cache); | |
251 | return (0); | |
252 | } | |
253 | #endif |