Theodore Ts'o | e12f2ae | 2003-01-23 16:45:16 -0500 | [diff] [blame^] | 1 | /* |
| 2 | * blkid.h - Interface for libblkid, a library to identify block devices |
| 3 | * |
| 4 | * Copyright (C) 2001 Andreas Dilger |
| 5 | * |
| 6 | * %Begin-Header% |
| 7 | * This file may be redistributed under the terms of the |
| 8 | * GNU Lesser General Public License. |
| 9 | * %End-Header% |
| 10 | */ |
| 11 | |
| 12 | #ifndef _BLKID_BLKID_H |
| 13 | #define _BLKID_BLKID_H |
| 14 | |
| 15 | #include <sys/types.h> |
| 16 | #include <stdio.h> |
| 17 | |
| 18 | #ifdef __cplusplus |
| 19 | extern "C" { |
| 20 | #endif |
| 21 | |
| 22 | #define BLKID_VERSION "1.2.0" |
| 23 | #define BLKID_DATE "22-Nov-2001" |
| 24 | |
| 25 | #include "blkid/list.h" |
| 26 | #include "blkid/blkid_types.h" |
| 27 | |
| 28 | typedef __s64 blkid_loff_t; |
| 29 | |
| 30 | /* |
| 31 | * This describes the attributes of a specific device. |
| 32 | * We can traverse all of the tags by bid_tags (linking to the tag bit_names). |
| 33 | * The bid_label and bid_uuid fields are shortcuts to the LABEL and UUID tag |
| 34 | * values, if they exist. |
| 35 | */ |
| 36 | typedef struct blkid_dev |
| 37 | { |
| 38 | struct list_head bid_devs; /* All devices in the cache */ |
| 39 | struct list_head bid_tags; /* All tags for this device */ |
| 40 | char *bid_name; /* Device inode pathname */ |
| 41 | char *bid_type; /* Preferred device TYPE */ |
| 42 | blkid_loff_t bid_size; /* Filesystem size in bytes */ |
| 43 | blkid_loff_t bid_free; /* Filesystem free in bytes */ |
| 44 | blkid_loff_t bid_devsize; /* Device size in bytes */ |
| 45 | dev_t bid_devno; /* Device major/minor number */ |
| 46 | time_t bid_time; /* Last update time of device */ |
| 47 | unsigned int bid_id; /* Unique cache id for device */ |
| 48 | unsigned int bid_flags; /* Device status bitflags */ |
| 49 | char *bid_label; /* Shortcut to device LABEL */ |
| 50 | char *bid_uuid; /* Shortcut to binary UUID */ |
| 51 | unsigned long bid_unused[13]; /* Fields for future use */ |
| 52 | } blkid_dev; |
| 53 | |
| 54 | #define BLKID_BID_FL_VERIFIED 0x0001 /* Device data validated from disk */ |
| 55 | #define BLKID_BID_FL_MTYPE 0x0002 /* Device has multiple type matches */ |
| 56 | |
| 57 | /* |
| 58 | * Each tag defines a NAME=value pair for a particular device. The tags |
| 59 | * are linked via bit_names for a single device, so that traversing the |
| 60 | * names list will get you a list of all tags associated with a device. |
| 61 | * They are also linked via bit_values for all devices, so one can easily |
| 62 | * search all tags with a given NAME for a specific value. |
| 63 | */ |
| 64 | typedef struct blkid_tag |
| 65 | { |
| 66 | struct list_head bit_tags; /* All tags for this device */ |
| 67 | struct list_head bit_names; /* All tags with given NAME */ |
| 68 | char *bit_name; /* NAME of tag (shared) */ |
| 69 | char *bit_val; /* value of tag */ |
| 70 | struct blkid_dev *bit_dev; /* pointer to device */ |
| 71 | unsigned long bit_unused[9]; /* Fields for future use */ |
| 72 | } blkid_tag; |
| 73 | |
| 74 | /* |
| 75 | * Minimum number of seconds between device probes, even when reading |
| 76 | * from the cache. This is to avoid re-probing all devices which were |
| 77 | * just probed by another program that does not share the cache. |
| 78 | */ |
| 79 | #define BLKID_PROBE_MIN 2 |
| 80 | |
| 81 | /* |
| 82 | * Time in seconds an entry remains verified in the in-memory cache |
| 83 | * before being reverified (in case of long-running processes that |
| 84 | * keep a cache in memory and continue to use it for a long time). |
| 85 | */ |
| 86 | #define BLKID_PROBE_INTERVAL 200 |
| 87 | |
| 88 | /* This describes an entire blkid cache file and probed devices. |
| 89 | * We can traverse all of the found devices via bic_list. |
| 90 | * We can traverse all of the tag types by bic_tags, which hold empty tags |
| 91 | * for each tag type. Those tags can be used as list_heads for iterating |
| 92 | * through all devices with a specific tag type (e.g. LABEL). |
| 93 | */ |
| 94 | typedef struct blkid_cache |
| 95 | { |
| 96 | struct list_head bic_devs; /* List head of all devices */ |
| 97 | struct list_head bic_tags; /* List head of all tag types */ |
| 98 | time_t bic_time; /* Last probe time */ |
| 99 | unsigned int bic_idmax; /* Highest ID assigned */ |
| 100 | unsigned int bic_flags; /* Status flags of the cache */ |
| 101 | unsigned long bic_unused[9]; /* Fields for future use */ |
| 102 | } blkid_cache; |
| 103 | |
| 104 | #define BLKID_BIC_FL_PARSED 0x0001 /* We parsed a cache file */ |
| 105 | #define BLKID_BIC_FL_PROBED 0x0002 /* We probed /proc/partition devices */ |
| 106 | #define BLKID_BIC_FL_CHANGED 0x0004 /* Cache has changed from disk */ |
| 107 | |
| 108 | extern char *string_copy(const char *s); |
| 109 | extern char *stringn_copy(const char *s, const int length); |
| 110 | extern void string_free(char *s); |
| 111 | extern blkid_cache *blkid_new_cache(void); |
| 112 | extern void blkid_free_cache(blkid_cache *cache); |
| 113 | |
| 114 | #define BLKID_CACHE_FILE "/etc/blkid.tab" |
| 115 | extern const char *devdirs[]; |
| 116 | |
| 117 | #define BLKID_ERR_IO 5 |
| 118 | #define BLKID_ERR_PROC 9 |
| 119 | #define BLKID_ERR_MEM 12 |
| 120 | #define BLKID_ERR_CACHE 14 |
| 121 | #define BLKID_ERR_DEV 19 |
| 122 | #define BLKID_ERR_PARAM 22 |
| 123 | #define BLKID_ERR_BIG 27 |
| 124 | |
| 125 | #ifdef DEBUG |
| 126 | #define DEBUG_CACHE |
| 127 | #define DEBUG_DUMP |
| 128 | #define DEBUG_DEV |
| 129 | #define DEBUG_DEVNAME |
| 130 | #define DEBUG_DEVNO |
| 131 | #define DEBUG_PROBE |
| 132 | #define DEBUG_READ |
| 133 | #define DEBUG_RESOLVE |
| 134 | #define DEBUG_SAVE |
| 135 | #define DEBUG_TAG |
| 136 | #define CHECK_TAG |
| 137 | #endif |
| 138 | |
| 139 | #if defined(TEST_PROGRAM) && !defined(DEBUG_DUMP) |
| 140 | #define DEBUG_DUMP |
| 141 | #endif |
| 142 | |
| 143 | #ifdef DEBUG_DUMP |
| 144 | static inline void DEB_DUMP_TAG(blkid_tag *tag) |
| 145 | { |
| 146 | if (!tag) { |
| 147 | printf(" tag: NULL\n"); |
| 148 | return; |
| 149 | } |
| 150 | |
| 151 | printf(" tag: %s=\"%s\"\n", tag->bit_name, tag->bit_val); |
| 152 | } |
| 153 | |
| 154 | static inline void DEB_DUMP_DEV(blkid_dev *dev) |
| 155 | { |
| 156 | struct list_head *p; |
| 157 | |
| 158 | if (!dev) { |
| 159 | printf(" dev: NULL\n"); |
| 160 | return; |
| 161 | } |
| 162 | |
| 163 | printf(" dev: name = %s\n", dev->bid_name); |
| 164 | printf(" dev: DEVNO=\"0x%0Lx\"\n", dev->bid_devno); |
| 165 | printf(" dev: ID=\"%u\"\n", dev->bid_id); |
| 166 | printf(" dev: TIME=\"%lu\"\n", dev->bid_time); |
| 167 | printf(" dev: size = %Lu\n", dev->bid_size); |
| 168 | printf(" dev: flags = 0x%08X\n", dev->bid_flags); |
| 169 | |
| 170 | list_for_each(p, &dev->bid_tags) { |
| 171 | blkid_tag *tag = list_entry(p, blkid_tag, bit_tags); |
| 172 | DEB_DUMP_TAG(tag); |
| 173 | } |
| 174 | printf("\n"); |
| 175 | } |
| 176 | |
| 177 | static inline void DEB_DUMP_CACHE(blkid_cache *cache) |
| 178 | { |
| 179 | struct list_head *p; |
| 180 | |
| 181 | if (!cache) { |
| 182 | printf("cache: NULL\n"); |
| 183 | return; |
| 184 | } |
| 185 | |
| 186 | printf("cache: time = %lu\n", cache->bic_time); |
| 187 | printf("cache: idmax = %u\n", cache->bic_idmax); |
| 188 | printf("cache: flags = 0x%08X\n", cache->bic_flags); |
| 189 | |
| 190 | list_for_each(p, &cache->bic_devs) { |
| 191 | blkid_dev *dev = list_entry(p, blkid_dev, bid_devs); |
| 192 | DEB_DUMP_DEV(dev); |
| 193 | } |
| 194 | } |
| 195 | #else |
| 196 | #define DEB_DUMP_TAG(tag) do {} while (0) |
| 197 | #define DEB_DUMP_DEV(dev) do {} while (0) |
| 198 | #define DEB_DUMP_CACHE(cache) do {} while (0) |
| 199 | #endif |
| 200 | |
| 201 | /* |
| 202 | * Primitive disk functions: llseek.c, getsize.c |
| 203 | */ |
| 204 | extern blkid_loff_t blkid_llseek(int fd, blkid_loff_t offset, int whence); |
| 205 | extern blkid_loff_t blkid_get_dev_size(int fd); |
| 206 | |
| 207 | /* |
| 208 | * Getting data from the cache file: read.c |
| 209 | */ |
| 210 | int blkid_read_cache_line(blkid_cache *cache, blkid_dev **dev_p, char *cp); |
| 211 | int blkid_read_cache_file(blkid_cache **cache, FILE *file); |
| 212 | int blkid_read_cache(blkid_cache **cache, const char *filename); |
| 213 | |
| 214 | /* |
| 215 | * Save data to the cache file: save.c |
| 216 | */ |
| 217 | int blkid_save_cache_file(blkid_cache *cache, FILE *file); |
| 218 | int blkid_save_cache(blkid_cache *cache, char *filename); |
| 219 | |
| 220 | /* |
| 221 | * Identify a device by inode name: probe.c |
| 222 | */ |
| 223 | extern blkid_dev *blkid_devname_to_dev(const char *devname, |
| 224 | blkid_loff_t size); |
| 225 | |
| 226 | /* |
| 227 | * Locate a device by inode name: devname.c |
| 228 | */ |
| 229 | extern blkid_dev *blkid_find_devname(blkid_cache *cache, const char *devname); |
| 230 | extern blkid_dev *blkid_verify_devname(blkid_cache *cache, blkid_dev *dev); |
| 231 | extern blkid_dev *blkid_get_devname(blkid_cache *cache, const char *devname); |
| 232 | extern int blkid_probe_all(blkid_cache **cache); |
| 233 | |
| 234 | /* |
| 235 | * Locate a device by device major/minor number: devno.c |
| 236 | */ |
| 237 | extern char *blkid_devno_to_devname(dev_t devno); |
| 238 | extern blkid_dev *blkid_find_devno(blkid_cache *cache, dev_t devno); |
| 239 | extern blkid_dev *blkid_get_devno(blkid_cache *cache, dev_t devno); |
| 240 | |
| 241 | /* |
| 242 | * Functions to create and find a specific tag type: tag.c |
| 243 | */ |
| 244 | extern blkid_tag *blkid_new_tag(void); |
| 245 | extern void blkid_free_tag(blkid_tag *tag); |
| 246 | extern int blkid_create_tag(blkid_dev *dev, blkid_tag **tag, |
| 247 | const char *name, const char *value, |
| 248 | const int vlength); |
| 249 | extern blkid_tag *blkid_token_to_tag(const char *token); |
| 250 | extern blkid_tag *blkid_find_tv_tags(blkid_tag *head, const char *value); |
| 251 | extern blkid_tag *blkid_find_tag_dev(blkid_dev *dev, blkid_tag *tag); |
| 252 | extern blkid_tag *blkid_find_head_cache(blkid_cache *cache, blkid_tag *tag); |
| 253 | extern blkid_tag *blkid_find_tag_cache(blkid_cache *cache, blkid_tag *tag); |
| 254 | extern blkid_tag *blkid_get_tag_cache(blkid_cache *cache, blkid_tag *tag); |
| 255 | |
| 256 | /* |
| 257 | * Functions to create and find a specific tag type: dev.c |
| 258 | */ |
| 259 | extern blkid_dev *blkid_new_dev(void); |
| 260 | extern void blkid_free_dev(blkid_dev *dev); |
| 261 | extern blkid_dev *blkid_add_dev_to_cache(blkid_cache *cache, blkid_dev *dev); |
| 262 | |
| 263 | /* |
| 264 | * Helper functions for primarily single use: resolve.c |
| 265 | */ |
| 266 | extern char *blkid_get_tagname_devname(blkid_cache *cache, const char *tagname, |
| 267 | const char *devname); |
| 268 | extern char *blkid_get_token(blkid_cache *cache, const char *token, |
| 269 | const char *value); |
| 270 | |
| 271 | #ifdef __cplusplus |
| 272 | } |
| 273 | #endif |
| 274 | |
| 275 | #endif /* _BLKID_BLKID_H */ |