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 "config.h" 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 if (!(dev = (blkid_dev) calloc(1, sizeof(struct blkid_struct_dev)))) 24 return NULL; 25 26 INIT_LIST_HEAD(&dev->bid_devs); 27 INIT_LIST_HEAD(&dev->bid_tags); 28 29 return dev; 30 } 31 32 void blkid_free_dev(blkid_dev dev) 33 { 34 if (!dev) 35 return; 36 37 DBG(DEBUG_DEV, 38 printf(" freeing dev %s (%s)\n", dev->bid_name, dev->bid_type ? 39 dev->bid_type : "(null)")); 40 DBG(DEBUG_DEV, blkid_debug_dump_dev(dev)); 41 42 list_del(&dev->bid_devs); 43 while (!list_empty(&dev->bid_tags)) { 44 blkid_tag tag = list_entry(dev->bid_tags.next, 45 struct blkid_struct_tag, 46 bit_tags); 47 blkid_free_tag(tag); 48 } 49 free(dev->bid_name); 50 free(dev); 51 } 52 53 /* 54 * Given a blkid device, return its name 55 */ 56 extern const char *blkid_dev_devname(blkid_dev dev) 57 { 58 return dev->bid_name; 59 } 60 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); 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 106 struct 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 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; 123 iter->search_type = 0; 124 iter->search_value = 0; 125 } 126 return (iter); 127 } 128 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 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 free(new_type); 141 free(new_value); 142 return -1; 143 } 144 strcpy(new_type, search_type); 145 strcpy(new_value, search_value); 146 free(iter->search_type); 147 free(iter->search_value); 148 iter->search_type = new_type; 149 iter->search_value = new_value; 150 return 0; 151 } 152 153 /* 154 * Return 0 on success, -1 on error 155 */ 156 extern int blkid_dev_next(blkid_dev_iterate iter, 157 blkid_dev *ret_dev) 158 { 159 blkid_dev dev; 160 161 *ret_dev = 0; 162 if (!iter || iter->magic != DEV_ITERATE_MAGIC) 163 return -1; 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; 167 if (iter->search_type && 168 !blkid_dev_has_tag(dev, iter->search_type, 169 iter->search_value)) 170 continue; 171 *ret_dev = dev; 172 return 0; 173 } 174 return -1; 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 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); 196 fprintf(stderr, "\tList all devices and exit\n"); 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) { 219 fprintf(stderr, "Invalid debug mask: %s\n", 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 254
