2 * blkidP.h - Internal interfaces for libblkid
4 * Copyright (C) 2001 Andreas Dilger
5 * Copyright (C) 2003 Theodore Ts'o
8 * This file may be redistributed under the terms of the
9 * GNU Lesser General Public License.
13 #ifndef _BLKID_BLKIDP_H
14 #define _BLKID_BLKIDP_H
16 /* Always confirm that /dev/disk-by symlinks match with LABEL/UUID on device */
17 /* #define CONFIG_BLKID_VERIFY_UDEV 1 */
19 #include <sys/types.h>
27 # define UUID_STR_LEN 37
31 #include "bitops.h" /* $(top_srcdir)/include/ */
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.
45 struct blkid_struct_dev
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 */
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() */
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.
73 struct blkid_struct_tag
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 */
81 typedef struct blkid_struct_tag
*blkid_tag
;
87 BLKID_CHAIN_SUBLKS
, /* FS/RAID superblocks (enabled by default) */
88 BLKID_CHAIN_TOPLGY
, /* Block device topology */
89 BLKID_CHAIN_PARTS
, /* Partition tables */
91 BLKID_NCHAINS
/* number of chains */
95 const struct blkid_chaindrv
*driver
; /* chain driver */
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 */
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 */
115 const struct blkid_idinfo
**idinfos
; /* description of probing functions */
116 const size_t nidinfos
; /* number of idinfos */
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 *);
125 extern const struct blkid_chaindrv superblocks_drv
;
126 extern const struct blkid_chaindrv topology_drv
;
127 extern const struct blkid_chaindrv partitions_drv
;
130 * Low-level probe result
134 const char *name
; /* value name */
135 unsigned char *data
; /* value data */
136 size_t len
; /* length of value data */
138 struct blkid_chain
*chain
; /* owner */
139 struct list_head prvals
; /* list of results */
143 * Filesystem / Raid magic strings
147 const char *magic
; /* magic string */
148 unsigned int len
; /* length of magic */
149 unsigned int hint
; /* hint for prober */
151 const char *hoff
; /* hint which contains byte offset to kboff */
152 long kboff
; /* kilobyte offset of superblock */
153 unsigned int sboff
; /* byte offset within superblock */
155 int is_zoned
; /* indicate magic location is calculated based on zone position */
156 long zonenum
; /* zone number which has superblock */
157 long kboff_inzone
; /* kilobyte offset of superblock in a zone */
161 * Filesystem / Raid description
165 const char *name
; /* fs, raid or partition table name */
166 int usage
; /* BLKID_USAGE_* flag */
167 int flags
; /* BLKID_IDINFO_* flags */
168 int minsz
; /* minimal device size */
171 int (*probefunc
)(blkid_probe pr
, const struct blkid_idmag
*mag
);
173 struct blkid_idmag magics
[]; /* NULL or array with magic strings */
176 #define BLKID_NONE_MAGIC {{ NULL }}
179 * tolerant FS - can share the same device with more filesystems (e.g. typical
180 * on CD-ROMs). We need this flag to detect ambivalent results (e.g. valid fat
181 * and valid linux swap on the same device).
183 #define BLKID_IDINFO_TOLERANT (1 << 1)
185 struct blkid_bufinfo
{
189 struct list_head bufs
; /* list of buffers */
198 struct list_head hints
;
202 * Low-level probing control struct
204 struct blkid_struct_probe
206 int fd
; /* device file descriptor */
207 uint64_t off
; /* begin of data on the device */
208 uint64_t size
; /* end of data on the device */
210 dev_t devno
; /* device number (st.st_rdev) */
211 dev_t disk_devno
; /* devno of the whole-disk or 0 */
212 unsigned int blkssz
; /* sector size (BLKSSZGET ioctl) */
213 mode_t mode
; /* struct stat.sb_mode */
214 uint64_t zone_size
; /* zone size (BLKGETZONESZ ioctl) */
216 int flags
; /* private library flags */
217 int prob_flags
; /* always zeroized by blkid_do_*() */
219 uint64_t wipe_off
; /* begin of the wiped area */
220 uint64_t wipe_size
; /* size of the wiped area */
221 struct blkid_chain
*wipe_chain
; /* superblock, partition, ... */
223 struct list_head buffers
; /* list of buffers */
224 struct list_head prunable_buffers
; /* list of prunable buffers */
225 struct list_head hints
;
227 struct blkid_chain chains
[BLKID_NCHAINS
]; /* array of chains */
228 struct blkid_chain
*cur_chain
; /* current chain */
230 struct list_head values
; /* results */
232 struct blkid_struct_probe
*parent
; /* for clones */
233 struct blkid_struct_probe
*disk_probe
; /* whole-disk probing */
236 /* private flags library flags */
237 #define BLKID_FL_PRIVATE_FD (1 << 1) /* see blkid_new_probe_from_filename() */
238 #define BLKID_FL_TINY_DEV (1 << 2) /* <= 1.47MiB (floppy or so) */
239 #define BLKID_FL_CDROM_DEV (1 << 3) /* is a CD/DVD drive */
240 #define BLKID_FL_NOSCAN_DEV (1 << 4) /* do not scan this device */
241 #define BLKID_FL_MODIF_BUFF (1 << 5) /* cached buffers has been modified */
242 #define BLKID_FL_OPAL_LOCKED (1 << 6) /* OPAL device is locked (I/O errors) */
244 /* private per-probing flags */
245 #define BLKID_PROBE_FL_IGNORE_PT (1 << 1) /* ignore partition table */
247 extern blkid_probe
blkid_clone_probe(blkid_probe parent
);
248 extern blkid_probe
blkid_probe_get_wholedisk_probe(blkid_probe pr
);
251 * Evaluation methods (for blkid_eval_* API)
261 * Library config options
263 struct blkid_config
{
264 int eval
[__BLKID_EVAL_LAST
]; /* array with EVALUATION=<udev,cache> options */
265 int nevals
; /* number of elems in eval array */
266 int uevent
; /* SEND_UEVENT=<yes|not> option */
267 char *cachefile
; /* CACHE_FILE=<path> option */
270 extern struct blkid_config
*blkid_read_config(const char *filename
)
271 __ul_attribute__((warn_unused_result
));
272 extern void blkid_free_config(struct blkid_config
*conf
);
275 * Minimum number of seconds between device probes, even when reading
276 * from the cache. This is to avoid re-probing all devices which were
277 * just probed by another program that does not share the cache.
279 #define BLKID_PROBE_MIN 2
282 * Time in seconds an entry remains verified in the in-memory cache
283 * before being reverified (in case of long-running processes that
284 * keep a cache in memory and continue to use it for a long time).
286 #define BLKID_PROBE_INTERVAL 200
288 /* This describes an entire blkid cache file and probed devices.
289 * We can traverse all of the found devices via bic_list.
290 * We can traverse all of the tag types by bic_tags, which hold empty tags
291 * for each tag type. Those tags can be used as list_heads for iterating
292 * through all devices with a specific tag type (e.g. LABEL).
294 struct blkid_struct_cache
296 struct list_head bic_devs
; /* List head of all devices */
297 struct list_head bic_tags
; /* List head of all tag types */
298 time_t bic_time
; /* Last probe time */
299 time_t bic_ftime
; /* Mod time of the cachefile */
300 unsigned int bic_flags
; /* Status flags of the cache */
301 char *bic_filename
; /* filename of cache */
302 blkid_probe probe
; /* low-level probing stuff */
305 #define BLKID_BIC_FL_PROBED 0x0002 /* We probed /proc/partition devices */
306 #define BLKID_BIC_FL_CHANGED 0x0004 /* Cache has changed from disk */
309 #define BLKID_CONFIG_FILE "/etc/blkid.conf"
311 /* cache file on systemds with /run */
312 #define BLKID_RUNTIME_TOPDIR "/run"
313 #define BLKID_RUNTIME_DIR BLKID_RUNTIME_TOPDIR "/blkid"
314 #define BLKID_CACHE_FILE BLKID_RUNTIME_DIR "/blkid.tab"
317 #define BLKID_CACHE_FILE_OLD "/etc/blkid.tab"
319 #define BLKID_ERR_IO 5
320 #define BLKID_ERR_SYSFS 9
321 #define BLKID_ERR_MEM 12
322 #define BLKID_ERR_CACHE 14
323 #define BLKID_ERR_DEV 19
324 #define BLKID_ERR_PARAM 22
325 #define BLKID_ERR_BIG 27
328 * Priority settings for different types of devices
330 #define BLKID_PRI_UBI 50
331 #define BLKID_PRI_DM 40
332 #define BLKID_PRI_EVMS 30
333 #define BLKID_PRI_LVM 20
334 #define BLKID_PRI_MD 10
336 #define BLKID_DEBUG_HELP (1 << 0)
337 #define BLKID_DEBUG_INIT (1 << 1)
338 #define BLKID_DEBUG_CACHE (1 << 2)
339 #define BLKID_DEBUG_CONFIG (1 << 3)
340 #define BLKID_DEBUG_DEV (1 << 4)
341 #define BLKID_DEBUG_DEVNAME (1 << 5)
342 #define BLKID_DEBUG_DEVNO (1 << 6)
343 #define BLKID_DEBUG_EVALUATE (1 << 7)
344 #define BLKID_DEBUG_LOWPROBE (1 << 8)
345 #define BLKID_DEBUG_PROBE (1 << 9)
346 #define BLKID_DEBUG_READ (1 << 10)
347 #define BLKID_DEBUG_SAVE (1 << 11)
348 #define BLKID_DEBUG_TAG (1 << 12)
349 #define BLKID_DEBUG_BUFFER (1 << 13)
350 #define BLKID_DEBUG_ALL 0xFFFF /* (1 << 16) aka FFFF is expected by API */
352 UL_DEBUG_DECLARE_MASK(libblkid
);
353 #define DBG(m, x) __UL_DBG(libblkid, BLKID_DEBUG_, m, x)
354 #define ON_DBG(m, x) __UL_DBG_CALL(libblkid, BLKID_DEBUG_, m, x)
356 #define UL_DEBUG_CURRENT_MASK UL_DEBUG_MASK(libblkid)
357 #include "debugobj.h"
359 extern void blkid_debug_dump_dev(blkid_dev dev
);
365 struct dir_list
*next
;
367 extern void blkid__scan_dir(char *, dev_t
, struct dir_list
**, char **)
368 __attribute__((nonnull(1,4)));
369 extern int blkid_driver_has_major(const char *drvname
, int drvmaj
)
370 __attribute__((warn_unused_result
));
373 extern void blkid_read_cache(blkid_cache cache
)
374 __attribute__((nonnull
));
377 extern int blkid_flush_cache(blkid_cache cache
)
378 __attribute__((nonnull
));
381 extern char *blkid_safe_getenv(const char *arg
)
382 __attribute__((nonnull
))
383 __attribute__((warn_unused_result
));
385 extern char *blkid_get_cache_filename(struct blkid_config
*conf
)
386 __attribute__((warn_unused_result
));
388 * Functions to create and find a specific tag type: tag.c
390 extern void blkid_free_tag(blkid_tag tag
);
391 extern blkid_tag
blkid_find_tag_dev(blkid_dev dev
, const char *type
)
392 __attribute__((nonnull
))
393 __attribute__((warn_unused_result
));
395 extern int blkid_set_tag(blkid_dev dev
, const char *name
,
396 const char *value
, const int vlength
)
397 __attribute__((nonnull(1,2)));
400 * Functions to create and find a specific tag type: dev.c
402 extern blkid_dev
blkid_new_dev(void)
403 __attribute__((warn_unused_result
));
404 extern void blkid_free_dev(blkid_dev dev
);
407 extern int blkid_probe_is_tiny(blkid_probe pr
)
408 __attribute__((nonnull
))
409 __attribute__((warn_unused_result
));
410 extern int blkid_probe_is_cdrom(blkid_probe pr
)
411 __attribute__((nonnull
))
412 __attribute__((warn_unused_result
));
413 extern int blkdid_probe_is_opal_locked(blkid_probe pr
)
414 __attribute__((nonnull
))
415 __attribute__((warn_unused_result
));
417 extern const unsigned char *blkid_probe_get_buffer(blkid_probe pr
,
418 uint64_t off
, uint64_t len
)
419 __attribute__((nonnull
))
420 __attribute__((warn_unused_result
));
422 extern const unsigned char *blkid_probe_get_sector(blkid_probe pr
, unsigned int sector
)
423 __attribute__((nonnull
))
424 __attribute__((warn_unused_result
));
426 extern int blkid_probe_get_dimension(blkid_probe pr
,
427 uint64_t *off
, uint64_t *size
)
428 __attribute__((nonnull
));
430 extern int blkid_probe_set_dimension(blkid_probe pr
,
431 uint64_t off
, uint64_t size
)
432 __attribute__((nonnull
));
434 extern int blkid_probe_get_idmag(blkid_probe pr
, const struct blkid_idinfo
*id
,
435 uint64_t *offset
, const struct blkid_idmag
**res
)
436 __attribute__((nonnull(1)));
438 extern void blkid_probe_prune_buffers(blkid_probe pr
);
440 /* returns superblock according to 'struct blkid_idmag' */
441 extern const unsigned char *blkid_probe_get_sb_buffer(blkid_probe pr
, const struct blkid_idmag
*mag
, size_t size
);
442 #define blkid_probe_get_sb(_pr, _mag, type) \
443 ((type *) blkid_probe_get_sb_buffer((_pr), _mag, sizeof(type)))
445 extern blkid_partlist
blkid_probe_get_partlist(blkid_probe pr
)
446 __attribute__((nonnull
))
447 __attribute__((warn_unused_result
));
449 extern int blkid_probe_is_covered_by_pt(blkid_probe pr
,
450 uint64_t offset
, uint64_t size
)
451 __attribute__((warn_unused_result
));
453 extern void blkid_probe_chain_reset_values(blkid_probe pr
, struct blkid_chain
*chn
)
454 __attribute__((nonnull
));
455 extern int blkid_probe_chain_save_values(blkid_probe pr
,
456 struct blkid_chain
*chn
,
457 struct list_head
*vals
)
458 __attribute__((nonnull
));
460 extern struct blkid_prval
*blkid_probe_assign_value(blkid_probe pr
,
462 __attribute__((nonnull
))
463 __attribute__((warn_unused_result
));
465 extern void blkid_probe_free_value(struct blkid_prval
*v
);
468 extern void blkid_probe_append_values_list(blkid_probe pr
,
469 struct list_head
*vals
)
470 __attribute__((nonnull
));
472 extern void blkid_probe_free_values_list(struct list_head
*vals
);
474 extern struct blkid_chain
*blkid_probe_get_chain(blkid_probe pr
)
475 __attribute__((nonnull
))
476 __attribute__((warn_unused_result
));
478 extern struct blkid_prval
*__blkid_probe_get_value(blkid_probe pr
, int num
)
479 __attribute__((nonnull
))
480 __attribute__((warn_unused_result
));
482 extern struct blkid_prval
*__blkid_probe_lookup_value(blkid_probe pr
, const char *name
)
483 __attribute__((nonnull
))
484 __attribute__((warn_unused_result
));
486 extern unsigned long *blkid_probe_get_filter(blkid_probe pr
, int chain
, int create
)
487 __attribute__((nonnull
))
488 __attribute__((warn_unused_result
));
490 extern int __blkid_probe_invert_filter(blkid_probe pr
, int chain
)
491 __attribute__((nonnull
));
492 extern int __blkid_probe_reset_filter(blkid_probe pr
, int chain
)
493 __attribute__((nonnull
));
494 extern int __blkid_probe_filter_types(blkid_probe pr
, int chain
, int flag
, char *names
[])
495 __attribute__((nonnull
));
497 extern void *blkid_probe_get_binary_data(blkid_probe pr
, struct blkid_chain
*chn
)
498 __attribute__((nonnull
))
499 __attribute__((warn_unused_result
));
501 extern struct blkid_prval
*blkid_probe_new_val(void)
502 __attribute__((warn_unused_result
));
503 extern int blkid_probe_set_value(blkid_probe pr
, const char *name
,
504 const unsigned char *data
, size_t len
)
505 __attribute__((nonnull
));
506 extern int blkid_probe_value_set_data(struct blkid_prval
*v
,
507 const unsigned char *data
, size_t len
)
508 __attribute__((nonnull
));
510 extern int blkid_probe_vsprintf_value(blkid_probe pr
, const char *name
,
511 const char *fmt
, va_list ap
)
512 __attribute__((nonnull
));
514 extern int blkid_probe_sprintf_value(blkid_probe pr
, const char *name
,
515 const char *fmt
, ...)
516 __attribute__((nonnull
))
517 __attribute__ ((__format__ (__printf__
, 3, 4)));
519 extern int blkid_probe_set_magic(blkid_probe pr
, uint64_t offset
,
520 size_t len
, const unsigned char *magic
)
521 __attribute__((nonnull
));
523 extern int blkid_probe_verify_csum(blkid_probe pr
, uint64_t csum
, uint64_t expected
)
524 __attribute__((nonnull
));
525 extern int blkid_probe_verify_csum_buf(blkid_probe pr
, size_t n
, const void *csum
,
526 const void *expected
) __attribute__((nonnull
));
528 extern void blkid_unparse_uuid(const unsigned char *uuid
, char *str
, size_t len
)
529 __attribute__((nonnull
));
530 extern int blkid_uuid_is_empty(const unsigned char *buf
, size_t len
);
532 extern size_t blkid_rtrim_whitespace(unsigned char *str
)
533 __attribute__((nonnull
));
534 extern size_t blkid_ltrim_whitespace(unsigned char *str
)
535 __attribute__((nonnull
));
537 extern void blkid_probe_set_wiper(blkid_probe pr
, uint64_t off
,
539 __attribute__((nonnull
));
540 extern int blkid_probe_is_wiped(blkid_probe pr
, struct blkid_chain
**chn
,
541 uint64_t off
, uint64_t size
)
542 __attribute__((nonnull
))
543 __attribute__((warn_unused_result
));
544 extern void blkid_probe_use_wiper(blkid_probe pr
, uint64_t off
, uint64_t size
)
545 __attribute__((nonnull
));
547 extern int blkid_probe_get_hint(blkid_probe pr
, const char *name
, uint64_t *value
)
548 __attribute__((nonnull(1,2)))
549 __attribute__((warn_unused_result
));
551 extern int blkid_probe_get_partitions_flags(blkid_probe pr
)
552 __attribute__((nonnull
));
554 /* filter bitmap macros */
555 #define blkid_bmp_wordsize (8 * sizeof(unsigned long))
556 #define blkid_bmp_idx_bit(item) (1UL << ((item) % blkid_bmp_wordsize))
557 #define blkid_bmp_idx_byte(item) ((item) / blkid_bmp_wordsize)
559 #define blkid_bmp_set_item(bmp, item) \
560 ((bmp)[ blkid_bmp_idx_byte(item) ] |= blkid_bmp_idx_bit(item))
562 #define blkid_bmp_unset_item(bmp, item) \
563 ((bmp)[ blkid_bmp_idx_byte(item) ] &= ~blkid_bmp_idx_bit(item))
565 #define blkid_bmp_get_item(bmp, item) \
566 ((bmp)[ blkid_bmp_idx_byte(item) ] & blkid_bmp_idx_bit(item))
568 #define blkid_bmp_nwords(max_items) \
569 (((max_items) + blkid_bmp_wordsize) / blkid_bmp_wordsize)
571 #define blkid_bmp_nbytes(max_items) \
572 (blkid_bmp_nwords(max_items) * sizeof(unsigned long))
574 #endif /* _BLKID_BLKIDP_H */