1 /*
2 * blkidP.h - Internal interfaces for libblkid
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 #ifndef _BLKID_BLKIDP_H
14 #define _BLKID_BLKIDP_H
15
16 /* Always confirm that /dev/disk-by symlinks match with LABEL/UUID on device */
17 /* #define CONFIG_BLKID_VERIFY_UDEV 1 */
18
19 #include <sys/types.h>
20 #include <dirent.h>
21 #include <sys/stat.h>
22 #include <stdio.h>
23 #include <stdarg.h>
24 #include <stdint.h>
25
26 #ifndef UUID_STR_LEN
27 # define UUID_STR_LEN 37
28 #endif
29
30 #include "c.h"
31 #include "bitops.h" /* $(top_srcdir)/include/ */
32 #include "blkdev.h"
33
34 #include "debug.h"
35 #include "blkid.h"
36 #include "list.h"
37 #include "encode.h"
38
39 /*
40 * This describes the attributes of a specific device.
41 * We can traverse all of the tags by bid_tags (linking to the tag bit_names).
42 * The bid_label and bid_uuid fields are shortcuts to the LABEL and UUID tag
43 * values, if they exist.
44 */
45 struct blkid_struct_dev
46 {
47 struct list_head bid_devs; /* All devices in the cache */
48 struct list_head bid_tags; /* All tags for this device */
49 blkid_cache bid_cache; /* Dev belongs to this cache */
50 char *bid_name; /* Device real path (as used in cache) */
51 char *bid_xname; /* Device path as used by application (maybe symlink..) */
52 char *bid_type; /* Preferred device TYPE */
53 int bid_pri; /* Device priority */
54 dev_t bid_devno; /* Device major/minor number */
55 time_t bid_time; /* Last update time of device */
56 suseconds_t bid_utime; /* Last update time (microseconds) */
57 unsigned int bid_flags; /* Device status bitflags */
58 char *bid_label; /* Shortcut to device LABEL */
59 char *bid_uuid; /* Shortcut to binary UUID */
60 };
61
62 #define BLKID_BID_FL_VERIFIED 0x0001 /* Device data validated from disk */
63 #define BLKID_BID_FL_INVALID 0x0004 /* Device is invalid */
64 #define BLKID_BID_FL_REMOVABLE 0x0008 /* Device added by blkid_probe_all_removable() */
65
66 /*
67 * Each tag defines a NAME=value pair for a particular device. The tags
68 * are linked via bit_names for a single device, so that traversing the
69 * names list will get you a list of all tags associated with a device.
70 * They are also linked via bit_values for all devices, so one can easily
71 * search all tags with a given NAME for a specific value.
72 */
73 struct blkid_struct_tag
74 {
75 struct list_head bit_tags; /* All tags for this device */
76 struct list_head bit_names; /* All tags with given NAME */
77 char *bit_name; /* NAME of tag (shared) */
78 char *bit_val; /* value of tag */
79 blkid_dev bit_dev; /* pointer to device */
80 };
81 typedef struct blkid_struct_tag *blkid_tag;
82
83 /*
84 * Chain IDs
85 */
86 enum {
87 BLKID_CHAIN_SUBLKS, /* FS/RAID superblocks (enabled by default) */
88 BLKID_CHAIN_TOPLGY, /* Block device topology */
89 BLKID_CHAIN_PARTS, /* Partition tables */
90
91 BLKID_NCHAINS /* number of chains */
92 };
93
94 struct blkid_chain {
95 const struct blkid_chaindrv *driver; /* chain driver */
96
97 int enabled; /* boolean */
98 int flags; /* BLKID_<chain>_* */
99 int binary; /* boolean */
100 int idx; /* index of the current prober (or -1) */
101 unsigned long *fltr; /* filter or NULL */
102 void *data; /* private chain data or NULL */
103 };
104
105 /*
106 * Chain driver
107 */
108 struct blkid_chaindrv {
109 const size_t id; /* BLKID_CHAIN_* */
110 const char *name; /* name of chain (for debug purpose) */
111 const int dflt_flags; /* default chain flags */
112 const int dflt_enabled; /* default enabled boolean */
113 int has_fltr; /* boolean */
114
115 const struct blkid_idinfo **idinfos; /* description of probing functions */
116 const size_t nidinfos; /* number of idinfos */
117
118 /* driver operations */
119 int (*probe)(blkid_probe, struct blkid_chain *);
120 int (*safeprobe)(blkid_probe, struct blkid_chain *);
121 void (*free_data)(blkid_probe, void *);
122 };
123
124 /* chains */
125 extern const struct blkid_chaindrv superblocks_drv;
126 extern const struct blkid_chaindrv topology_drv;
127 extern const struct blkid_chaindrv partitions_drv;
128
129 /*
130 * Low-level probe result
131 */
132 struct blkid_prval
133 {
134 const char *name; /* value name */
135 unsigned char *data; /* value data */
136 size_t len; /* length of value data */
137
138 struct blkid_chain *chain; /* owner */
139 struct list_head prvals; /* list of results */
140 };
141
142 /*
143 * Filesystem / Raid magic strings
144 */
145 struct blkid_idmag
146 {
147 const char *magic; /* magic string */
148 unsigned int len; /* length of magic */
149
150 const char *hoff; /* hint which contains byte offset to kboff */
151 long kboff; /* kilobyte offset of superblock */
152 unsigned int sboff; /* byte offset within superblock */
153
154 int is_zoned; /* indicate magic location is calculated based on zone position */
155 long zonenum; /* zone number which has superblock */
156 long kboff_inzone; /* kilobyte offset of superblock in a zone */
157 };
158
159 /*
160 * Filesystem / Raid description
161 */
162 struct blkid_idinfo
163 {
164 const char *name; /* fs, raid or partition table name */
165 int usage; /* BLKID_USAGE_* flag */
166 int flags; /* BLKID_IDINFO_* flags */
167 int minsz; /* minimal device size */
168
169 /* probe function */
170 int (*probefunc)(blkid_probe pr, const struct blkid_idmag *mag);
171
172 struct blkid_idmag magics[]; /* NULL or array with magic strings */
173 };
174
175 #define BLKID_NONE_MAGIC {{ NULL }}
176
177 /*
178 * tolerant FS - can share the same device with more filesystems (e.g. typical
179 * on CD-ROMs). We need this flag to detect ambivalent results (e.g. valid fat
180 * and valid linux swap on the same device).
181 */
182 #define BLKID_IDINFO_TOLERANT (1 << 1)
183
184 struct blkid_bufinfo {
185 unsigned char *data;
186 uint64_t off;
187 uint64_t len;
188 struct list_head bufs; /* list of buffers */
189 };
190
191 /*
192 * Probing hint
193 */
194 struct blkid_hint {
195 char *name;
196 uint64_t value;
197 struct list_head hints;
198 };
199
200 /*
201 * Low-level probing control struct
202 */
203 struct blkid_struct_probe
204 {
205 int fd; /* device file descriptor */
206 uint64_t off; /* begin of data on the device */
207 uint64_t size; /* end of data on the device */
208
209 dev_t devno; /* device number (st.st_rdev) */
210 dev_t disk_devno; /* devno of the whole-disk or 0 */
211 unsigned int blkssz; /* sector size (BLKSSZGET ioctl) */
212 mode_t mode; /* struct stat.sb_mode */
213 uint64_t zone_size; /* zone size (BLKGETZONESZ ioctl) */
214
215 int flags; /* private library flags */
216 int prob_flags; /* always zeroized by blkid_do_*() */
217
218 uint64_t wipe_off; /* begin of the wiped area */
219 uint64_t wipe_size; /* size of the wiped area */
220 struct blkid_chain *wipe_chain; /* superblock, partition, ... */
221
222 struct list_head buffers; /* list of buffers */
223 struct list_head hints;
224
225 struct blkid_chain chains[BLKID_NCHAINS]; /* array of chains */
226 struct blkid_chain *cur_chain; /* current chain */
227
228 struct list_head values; /* results */
229
230 struct blkid_struct_probe *parent; /* for clones */
231 struct blkid_struct_probe *disk_probe; /* whole-disk probing */
232 };
233
234 /* private flags library flags */
235 #define BLKID_FL_PRIVATE_FD (1 << 1) /* see blkid_new_probe_from_filename() */
236 #define BLKID_FL_TINY_DEV (1 << 2) /* <= 1.47MiB (floppy or so) */
237 #define BLKID_FL_CDROM_DEV (1 << 3) /* is a CD/DVD drive */
238 #define BLKID_FL_NOSCAN_DEV (1 << 4) /* do not scan this device */
239 #define BLKID_FL_MODIF_BUFF (1 << 5) /* cached buffers has been modified */
240 #define BLKID_FL_OPAL_LOCKED (1 << 6) /* OPAL device is locked (I/O errors) */
241
242 /* private per-probing flags */
243 #define BLKID_PROBE_FL_IGNORE_PT (1 << 1) /* ignore partition table */
244
245 extern blkid_probe blkid_clone_probe(blkid_probe parent);
246 extern blkid_probe blkid_probe_get_wholedisk_probe(blkid_probe pr);
247
248 /*
249 * Evaluation methods (for blkid_eval_* API)
250 */
251 enum {
252 BLKID_EVAL_UDEV = 0,
253 BLKID_EVAL_SCAN,
254
255 __BLKID_EVAL_LAST
256 };
257
258 /*
259 * Library config options
260 */
261 struct blkid_config {
262 int eval[__BLKID_EVAL_LAST]; /* array with EVALUATION=<udev,cache> options */
263 int nevals; /* number of elems in eval array */
264 int uevent; /* SEND_UEVENT=<yes|not> option */
265 char *cachefile; /* CACHE_FILE=<path> option */
266 };
267
268 extern struct blkid_config *blkid_read_config(const char *filename)
269 __ul_attribute__((warn_unused_result));
270 extern void blkid_free_config(struct blkid_config *conf);
271
272 /*
273 * Minimum number of seconds between device probes, even when reading
274 * from the cache. This is to avoid re-probing all devices which were
275 * just probed by another program that does not share the cache.
276 */
277 #define BLKID_PROBE_MIN 2
278
279 /*
280 * Time in seconds an entry remains verified in the in-memory cache
281 * before being reverified (in case of long-running processes that
282 * keep a cache in memory and continue to use it for a long time).
283 */
284 #define BLKID_PROBE_INTERVAL 200
285
286 /* This describes an entire blkid cache file and probed devices.
287 * We can traverse all of the found devices via bic_list.
288 * We can traverse all of the tag types by bic_tags, which hold empty tags
289 * for each tag type. Those tags can be used as list_heads for iterating
290 * through all devices with a specific tag type (e.g. LABEL).
291 */
292 struct blkid_struct_cache
293 {
294 struct list_head bic_devs; /* List head of all devices */
295 struct list_head bic_tags; /* List head of all tag types */
296 time_t bic_time; /* Last probe time */
297 time_t bic_ftime; /* Mod time of the cachefile */
298 unsigned int bic_flags; /* Status flags of the cache */
299 char *bic_filename; /* filename of cache */
300 blkid_probe probe; /* low-level probing stuff */
301 };
302
303 #define BLKID_BIC_FL_PROBED 0x0002 /* We probed /proc/partition devices */
304 #define BLKID_BIC_FL_CHANGED 0x0004 /* Cache has changed from disk */
305
306 /* config file */
307 #define BLKID_CONFIG_FILE "/etc/blkid.conf"
308
309 /* cache file on systemds with /run */
310 #define BLKID_RUNTIME_TOPDIR "/run"
311 #define BLKID_RUNTIME_DIR BLKID_RUNTIME_TOPDIR "/blkid"
312 #define BLKID_CACHE_FILE BLKID_RUNTIME_DIR "/blkid.tab"
313
314 /* old systems */
315 #define BLKID_CACHE_FILE_OLD "/etc/blkid.tab"
316
317 #define BLKID_ERR_IO 5
318 #define BLKID_ERR_SYSFS 9
319 #define BLKID_ERR_MEM 12
320 #define BLKID_ERR_CACHE 14
321 #define BLKID_ERR_DEV 19
322 #define BLKID_ERR_PARAM 22
323 #define BLKID_ERR_BIG 27
324
325 /*
326 * Priority settings for different types of devices
327 */
328 #define BLKID_PRI_UBI 50
329 #define BLKID_PRI_DM 40
330 #define BLKID_PRI_EVMS 30
331 #define BLKID_PRI_LVM 20
332 #define BLKID_PRI_MD 10
333
334 #define BLKID_DEBUG_HELP (1 << 0)
335 #define BLKID_DEBUG_INIT (1 << 1)
336 #define BLKID_DEBUG_CACHE (1 << 2)
337 #define BLKID_DEBUG_CONFIG (1 << 3)
338 #define BLKID_DEBUG_DEV (1 << 4)
339 #define BLKID_DEBUG_DEVNAME (1 << 5)
340 #define BLKID_DEBUG_DEVNO (1 << 6)
341 #define BLKID_DEBUG_EVALUATE (1 << 7)
342 #define BLKID_DEBUG_LOWPROBE (1 << 8)
343 #define BLKID_DEBUG_PROBE (1 << 9)
344 #define BLKID_DEBUG_READ (1 << 10)
345 #define BLKID_DEBUG_SAVE (1 << 11)
346 #define BLKID_DEBUG_TAG (1 << 12)
347 #define BLKID_DEBUG_BUFFER (1 << 13)
348 #define BLKID_DEBUG_ALL 0xFFFF /* (1 << 16) aka FFFF is expected by API */
349
350 UL_DEBUG_DECLARE_MASK(libblkid);
351 #define DBG(m, x) __UL_DBG(libblkid, BLKID_DEBUG_, m, x)
352 #define ON_DBG(m, x) __UL_DBG_CALL(libblkid, BLKID_DEBUG_, m, x)
353
354 #define UL_DEBUG_CURRENT_MASK UL_DEBUG_MASK(libblkid)
355 #include "debugobj.h"
356
357 extern void blkid_debug_dump_dev(blkid_dev dev);
358
359
360 /* devno.c */
361 struct dir_list {
362 char *name;
363 struct dir_list *next;
364 };
365 extern void blkid__scan_dir(char *, dev_t, struct dir_list **, char **)
366 __attribute__((nonnull(1,4)));
367 extern int blkid_driver_has_major(const char *drvname, int drvmaj)
368 __attribute__((warn_unused_result));
369
370 /* read.c */
371 extern void blkid_read_cache(blkid_cache cache)
372 __attribute__((nonnull));
373
374 /* save.c */
375 extern int blkid_flush_cache(blkid_cache cache)
376 __attribute__((nonnull));
377
378 /* cache */
379 extern char *blkid_safe_getenv(const char *arg)
380 __attribute__((nonnull))
381 __attribute__((warn_unused_result));
382
383 extern char *blkid_get_cache_filename(struct blkid_config *conf)
384 __attribute__((warn_unused_result));
385 /*
386 * Functions to create and find a specific tag type: tag.c
387 */
388 extern void blkid_free_tag(blkid_tag tag);
389 extern blkid_tag blkid_find_tag_dev(blkid_dev dev, const char *type)
390 __attribute__((nonnull))
391 __attribute__((warn_unused_result));
392
393 extern int blkid_set_tag(blkid_dev dev, const char *name,
394 const char *value, const int vlength)
395 __attribute__((nonnull(1,2)));
396
397 /*
398 * Functions to create and find a specific tag type: dev.c
399 */
400 extern blkid_dev blkid_new_dev(void)
401 __attribute__((warn_unused_result));
402 extern void blkid_free_dev(blkid_dev dev);
403
404 /* probe.c */
405 extern int blkid_probe_is_tiny(blkid_probe pr)
406 __attribute__((nonnull))
407 __attribute__((warn_unused_result));
408 extern int blkid_probe_is_cdrom(blkid_probe pr)
409 __attribute__((nonnull))
410 __attribute__((warn_unused_result));
411 extern int blkdid_probe_is_opal_locked(blkid_probe pr)
412 __attribute__((nonnull))
413 __attribute__((warn_unused_result));
414
415 extern unsigned char *blkid_probe_get_buffer(blkid_probe pr,
416 uint64_t off, uint64_t len)
417 __attribute__((nonnull))
418 __attribute__((warn_unused_result));
419
420 extern unsigned char *blkid_probe_get_sector(blkid_probe pr, unsigned int sector)
421 __attribute__((nonnull))
422 __attribute__((warn_unused_result));
423
424 extern int blkid_probe_get_dimension(blkid_probe pr,
425 uint64_t *off, uint64_t *size)
426 __attribute__((nonnull));
427
428 extern int blkid_probe_set_dimension(blkid_probe pr,
429 uint64_t off, uint64_t size)
430 __attribute__((nonnull));
431
432 extern int blkid_probe_get_idmag(blkid_probe pr, const struct blkid_idinfo *id,
433 uint64_t *offset, const struct blkid_idmag **res)
434 __attribute__((nonnull(1)));
435
436 /* returns superblock according to 'struct blkid_idmag' */
437 extern unsigned char *blkid_probe_get_sb_buffer(blkid_probe pr, const struct blkid_idmag *mag, size_t size);
438 #define blkid_probe_get_sb(_pr, _mag, type) \
439 ((type *) blkid_probe_get_sb_buffer((_pr), _mag, sizeof(type)))
440
441 extern blkid_partlist blkid_probe_get_partlist(blkid_probe pr)
442 __attribute__((nonnull))
443 __attribute__((warn_unused_result));
444
445 extern int blkid_probe_is_covered_by_pt(blkid_probe pr,
446 uint64_t offset, uint64_t size)
447 __attribute__((warn_unused_result));
448
449 extern void blkid_probe_chain_reset_values(blkid_probe pr, struct blkid_chain *chn)
450 __attribute__((nonnull));
451 extern int blkid_probe_chain_save_values(blkid_probe pr,
452 struct blkid_chain *chn,
453 struct list_head *vals)
454 __attribute__((nonnull));
455
456 extern struct blkid_prval *blkid_probe_assign_value(blkid_probe pr,
457 const char *name)
458 __attribute__((nonnull))
459 __attribute__((warn_unused_result));
460
461 extern void blkid_probe_free_value(struct blkid_prval *v);
462
463
464 extern void blkid_probe_append_values_list(blkid_probe pr,
465 struct list_head *vals)
466 __attribute__((nonnull));
467
468 extern void blkid_probe_free_values_list(struct list_head *vals);
469
470 extern struct blkid_chain *blkid_probe_get_chain(blkid_probe pr)
471 __attribute__((nonnull))
472 __attribute__((warn_unused_result));
473
474 extern struct blkid_prval *__blkid_probe_get_value(blkid_probe pr, int num)
475 __attribute__((nonnull))
476 __attribute__((warn_unused_result));
477
478 extern struct blkid_prval *__blkid_probe_lookup_value(blkid_probe pr, const char *name)
479 __attribute__((nonnull))
480 __attribute__((warn_unused_result));
481
482 extern unsigned long *blkid_probe_get_filter(blkid_probe pr, int chain, int create)
483 __attribute__((nonnull))
484 __attribute__((warn_unused_result));
485
486 extern int __blkid_probe_invert_filter(blkid_probe pr, int chain)
487 __attribute__((nonnull));
488 extern int __blkid_probe_reset_filter(blkid_probe pr, int chain)
489 __attribute__((nonnull));
490 extern int __blkid_probe_filter_types(blkid_probe pr, int chain, int flag, char *names[])
491 __attribute__((nonnull));
492
493 extern void *blkid_probe_get_binary_data(blkid_probe pr, struct blkid_chain *chn)
494 __attribute__((nonnull))
495 __attribute__((warn_unused_result));
496
497 extern struct blkid_prval *blkid_probe_new_val(void)
498 __attribute__((warn_unused_result));
499 extern int blkid_probe_set_value(blkid_probe pr, const char *name,
500 const unsigned char *data, size_t len)
501 __attribute__((nonnull));
502 extern int blkid_probe_value_set_data(struct blkid_prval *v,
503 const unsigned char *data, size_t len)
504 __attribute__((nonnull));
505
506 extern int blkid_probe_vsprintf_value(blkid_probe pr, const char *name,
507 const char *fmt, va_list ap)
508 __attribute__((nonnull));
509
510 extern int blkid_probe_sprintf_value(blkid_probe pr, const char *name,
511 const char *fmt, ...)
512 __attribute__((nonnull))
513 __attribute__ ((__format__ (__printf__, 3, 4)));
514
515 extern int blkid_probe_set_magic(blkid_probe pr, uint64_t offset,
516 size_t len, const unsigned char *magic)
517 __attribute__((nonnull));
518
519 extern int blkid_probe_verify_csum(blkid_probe pr, uint64_t csum, uint64_t expected)
520 __attribute__((nonnull));
521 extern int blkid_probe_verify_csum_buf(blkid_probe pr, size_t n, const void *csum,
522 const void *expected) __attribute__((nonnull));
523
524 extern void blkid_unparse_uuid(const unsigned char *uuid, char *str, size_t len)
525 __attribute__((nonnull));
526 extern int blkid_uuid_is_empty(const unsigned char *buf, size_t len);
527
528 extern size_t blkid_rtrim_whitespace(unsigned char *str)
529 __attribute__((nonnull));
530 extern size_t blkid_ltrim_whitespace(unsigned char *str)
531 __attribute__((nonnull));
532
533 extern void blkid_probe_set_wiper(blkid_probe pr, uint64_t off,
534 uint64_t size)
535 __attribute__((nonnull));
536 extern int blkid_probe_is_wiped(blkid_probe pr, struct blkid_chain **chn,
537 uint64_t off, uint64_t size)
538 __attribute__((nonnull))
539 __attribute__((warn_unused_result));
540 extern void blkid_probe_use_wiper(blkid_probe pr, uint64_t off, uint64_t size)
541 __attribute__((nonnull));
542
543 extern int blkid_probe_get_hint(blkid_probe pr, const char *name, uint64_t *value)
544 __attribute__((nonnull(1,2)))
545 __attribute__((warn_unused_result));
546
547 extern int blkid_probe_get_partitions_flags(blkid_probe pr)
548 __attribute__((nonnull));
549
550 /* filter bitmap macros */
551 #define blkid_bmp_wordsize (8 * sizeof(unsigned long))
552 #define blkid_bmp_idx_bit(item) (1UL << ((item) % blkid_bmp_wordsize))
553 #define blkid_bmp_idx_byte(item) ((item) / blkid_bmp_wordsize)
554
555 #define blkid_bmp_set_item(bmp, item) \
556 ((bmp)[ blkid_bmp_idx_byte(item) ] |= blkid_bmp_idx_bit(item))
557
558 #define blkid_bmp_unset_item(bmp, item) \
559 ((bmp)[ blkid_bmp_idx_byte(item) ] &= ~blkid_bmp_idx_bit(item))
560
561 #define blkid_bmp_get_item(bmp, item) \
562 ((bmp)[ blkid_bmp_idx_byte(item) ] & blkid_bmp_idx_bit(item))
563
564 #define blkid_bmp_nwords(max_items) \
565 (((max_items) + blkid_bmp_wordsize) / blkid_bmp_wordsize)
566
567 #define blkid_bmp_nbytes(max_items) \
568 (blkid_bmp_nwords(max_items) * sizeof(unsigned long))
569
570 #endif /* _BLKID_BLKIDP_H */