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 #include "bitops.h" /* $(top_srcdir)/include/ */
35 #include "libblkid-tiny.h"
37 #include <libubox/list.h>
41 * This describes the attributes of a specific device.
42 * We can traverse all of the tags by bid_tags (linking to the tag bit_names).
43 * The bid_label and bid_uuid fields are shortcuts to the LABEL and UUID tag
44 * values, if they exist.
46 struct blkid_struct_dev
48 struct list_head bid_devs
; /* All devices in the cache */
49 struct list_head bid_tags
; /* All tags for this device */
50 blkid_cache bid_cache
; /* Dev belongs to this cache */
51 char *bid_name
; /* Device inode pathname */
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 * Low-level probe result
129 const char *name
; /* value name */
130 unsigned char *data
; /* value data */
131 size_t len
; /* length of value data */
133 struct blkid_chain
*chain
; /* owner */
134 struct list_head prvals
; /* list of results */
137 /* Moved to libblkid-tiny.h because it's needed outside of the private impl. */
140 * Filesystem / Raid magic strings
144 const char *magic
; /* magic string */
145 unsigned int len
; /* length of magic */
147 long kboff
; /* kilobyte offset of superblock */
148 unsigned int sboff
; /* byte offset within superblock */
152 * Filesystem / Raid description
156 const char *name
; /* fs, raid or partition table name */
157 int usage
; /* BLKID_USAGE_* flag */
158 int flags
; /* BLKID_IDINFO_* flags */
159 int minsz
; /* minimal device size */
162 int (*probefunc
)(blkid_probe pr
, const struct blkid_idmag
*mag
);
164 struct blkid_idmag magics
[]; /* NULL or array with magic strings */
168 #define BLKID_NONE_MAGIC {{ NULL }}
171 * tolerant FS - can share the same device with more filesystems (e.g. typical
172 * on CD-ROMs). We need this flag to detect ambivalent results (e.g. valid fat
173 * and valid linux swap on the same device).
175 #define BLKID_IDINFO_TOLERANT (1 << 1)
177 struct blkid_bufinfo
{
181 struct list_head bufs
; /* list of buffers */
184 /* Replaced by a smaller struct in libblkid-tiny.h */
187 * Low-level probing control struct
189 struct blkid_struct_probe
191 int fd
; /* device file descriptor */
192 blkid_loff_t off
; /* begin of data on the device */
193 blkid_loff_t size
; /* end of data on the device */
194 size_t mmap_granularity
; /* minimal size of mmaped buffer (PAGE_SIZE) */
196 dev_t devno
; /* device number (st.st_rdev) */
197 dev_t disk_devno
; /* devno of the whole-disk or 0 */
198 unsigned int blkssz
; /* sector size (BLKSSZGET ioctl) */
199 mode_t mode
; /* struct stat.sb_mode */
201 int flags
; /* private libray flags */
202 int prob_flags
; /* always zeroized by blkid_do_*() */
204 blkid_loff_t wipe_off
; /* begin of the wiped area */
205 blkid_loff_t wipe_size
; /* size of the wiped area */
206 struct blkid_chain
*wipe_chain
; /* superblock, partition, ... */
208 struct list_head buffers
; /* list of buffers */
210 struct blkid_chain chains
[BLKID_NCHAINS
]; /* array of chains */
211 struct blkid_chain
*cur_chain
; /* current chain */
213 struct list_head values
; /* results */
215 struct blkid_struct_probe
*parent
; /* for clones */
216 struct blkid_struct_probe
*disk_probe
; /* whole-disk probing */
220 /* private flags library flags */
221 #define BLKID_FL_PRIVATE_FD (1 << 1) /* see blkid_new_probe_from_filename() */
222 #define BLKID_FL_TINY_DEV (1 << 2) /* <= 1.47MiB (floppy or so) */
223 #define BLKID_FL_CDROM_DEV (1 << 3) /* is a CD/DVD drive */
224 #define BLKID_FL_NOSCAN_DEV (1 << 4) /* do not scan this device */
226 /* private per-probing flags */
227 #define BLKID_PROBE_FL_IGNORE_PT (1 << 1) /* ignore partition table */
229 extern blkid_probe
blkid_clone_probe(blkid_probe parent
);
230 extern blkid_probe
blkid_probe_get_wholedisk_probe(blkid_probe pr
);
233 * Evaluation methods (for blkid_eval_* API)
243 * Library config options
245 struct blkid_config
{
246 int eval
[__BLKID_EVAL_LAST
]; /* array with EVALUATION=<udev,cache> options */
247 int nevals
; /* number of elems in eval array */
248 int uevent
; /* SEND_UEVENT=<yes|not> option */
249 char *cachefile
; /* CACHE_FILE=<path> option */
252 extern struct blkid_config
*blkid_read_config(const char *filename
)
253 __ul_attribute__((warn_unused_result
));
254 extern void blkid_free_config(struct blkid_config
*conf
);
257 * Minimum number of seconds between device probes, even when reading
258 * from the cache. This is to avoid re-probing all devices which were
259 * just probed by another program that does not share the cache.
261 #define BLKID_PROBE_MIN 2
264 * Time in seconds an entry remains verified in the in-memory cache
265 * before being reverified (in case of long-running processes that
266 * keep a cache in memory and continue to use it for a long time).
268 #define BLKID_PROBE_INTERVAL 200
270 /* This describes an entire blkid cache file and probed devices.
271 * We can traverse all of the found devices via bic_list.
272 * We can traverse all of the tag types by bic_tags, which hold empty tags
273 * for each tag type. Those tags can be used as list_heads for iterating
274 * through all devices with a specific tag type (e.g. LABEL).
276 struct blkid_struct_cache
278 struct list_head bic_devs
; /* List head of all devices */
279 struct list_head bic_tags
; /* List head of all tag types */
280 time_t bic_time
; /* Last probe time */
281 time_t bic_ftime
; /* Mod time of the cachefile */
282 unsigned int bic_flags
; /* Status flags of the cache */
283 char *bic_filename
; /* filename of cache */
284 blkid_probe probe
; /* low-level probing stuff */
287 #define BLKID_BIC_FL_PROBED 0x0002 /* We probed /proc/partition devices */
288 #define BLKID_BIC_FL_CHANGED 0x0004 /* Cache has changed from disk */
291 #define BLKID_CONFIG_FILE "/etc/blkid.conf"
293 /* cache file on systemds with /run */
294 #define BLKID_RUNTIME_TOPDIR "/run"
295 #define BLKID_RUNTIME_DIR BLKID_RUNTIME_TOPDIR "/blkid"
296 #define BLKID_CACHE_FILE BLKID_RUNTIME_DIR "/blkid.tab"
299 #define BLKID_CACHE_FILE_OLD "/etc/blkid.tab"
301 #define BLKID_PROBE_OK 0
302 #define BLKID_PROBE_NONE 1
304 #define BLKID_ERR_IO 5
305 #define BLKID_ERR_PROC 9
306 #define BLKID_ERR_MEM 12
307 #define BLKID_ERR_CACHE 14
308 #define BLKID_ERR_DEV 19
309 #define BLKID_ERR_PARAM 22
310 #define BLKID_ERR_BIG 27
313 * Priority settings for different types of devices
315 #define BLKID_PRI_UBI 50
316 #define BLKID_PRI_DM 40
317 #define BLKID_PRI_EVMS 30
318 #define BLKID_PRI_LVM 20
319 #define BLKID_PRI_MD 10
322 #define BLKID_DEBUG_HELP (1 << 0)
323 #define BLKID_DEBUG_INIT (1 << 1)
324 #define BLKID_DEBUG_CACHE (1 << 2)
325 #define BLKID_DEBUG_CONFIG (1 << 3)
326 #define BLKID_DEBUG_DEV (1 << 4)
327 #define BLKID_DEBUG_DEVNAME (1 << 5)
328 #define BLKID_DEBUG_DEVNO (1 << 6)
329 #define BLKID_DEBUG_EVALUATE (1 << 7)
330 #define BLKID_DEBUG_LOWPROBE (1 << 8)
331 #define BLKID_DEBUG_PROBE (1 << 9)
332 #define BLKID_DEBUG_READ (1 << 10)
333 #define BLKID_DEBUG_SAVE (1 << 11)
334 #define BLKID_DEBUG_TAG (1 << 12)
335 #define BLKID_DEBUG_BUFFER (1 << 13)
336 #define BLKID_DEBUG_ALL 0xFFFF /* (1 << 16) aka FFFF is expected by API */
338 UL_DEBUG_DECLARE_MASK(libblkid
);
339 #define DBG(m, x) __UL_DBG(libblkid, BLKID_DEBUG_, m, x)
340 #define ON_DBG(m, x) __UL_DBG_CALL(libblkid, BLKID_DEBUG_, m, x)
342 extern void blkid_debug_dump_dev(blkid_dev dev
);
343 extern void blkid_debug_dump_tag(blkid_tag tag
);
345 #define DBG(m, x) do {} while (0)
351 struct dir_list
*next
;
353 extern void blkid__scan_dir(char *, dev_t
, struct dir_list
**, char **)
354 __attribute__((nonnull(1,4)));
355 extern int blkid_driver_has_major(const char *drvname
, int major
)
356 __attribute__((warn_unused_result
));
359 extern blkid_loff_t
blkid_llseek(int fd
, blkid_loff_t offset
, int whence
);
362 extern void blkid_read_cache(blkid_cache cache
)
363 __attribute__((nonnull
));
366 extern int blkid_flush_cache(blkid_cache cache
)
367 __attribute__((nonnull
));
370 extern char *blkid_safe_getenv(const char *arg
)
371 __attribute__((nonnull
))
372 __attribute__((warn_unused_result
));
374 extern char *blkid_get_cache_filename(struct blkid_config
*conf
)
375 __attribute__((warn_unused_result
));
377 * Functions to create and find a specific tag type: tag.c
379 extern void blkid_free_tag(blkid_tag tag
);
380 extern blkid_tag
blkid_find_tag_dev(blkid_dev dev
, const char *type
)
381 __attribute__((nonnull
))
382 __attribute__((warn_unused_result
));
384 extern int blkid_set_tag(blkid_dev dev
, const char *name
,
385 const char *value
, const int vlength
)
386 __attribute__((nonnull(1,2)));
389 * Functions to create and find a specific tag type: dev.c
391 extern blkid_dev
blkid_new_dev(void)
392 __attribute__((warn_unused_result
));
393 extern void blkid_free_dev(blkid_dev dev
);
396 extern int blkid_probe_is_tiny(blkid_probe pr
)
397 __attribute__((nonnull
))
398 __attribute__((warn_unused_result
));
399 extern int blkid_probe_is_cdrom(blkid_probe pr
)
400 __attribute__((nonnull
))
401 __attribute__((warn_unused_result
));
403 extern unsigned char *blkid_probe_get_buffer(blkid_probe pr
,
404 blkid_loff_t off
, blkid_loff_t len
)
405 __attribute__((nonnull
))
406 __attribute__((warn_unused_result
));
408 extern unsigned char *blkid_probe_get_sector(blkid_probe pr
, unsigned int sector
)
409 __attribute__((nonnull
))
410 __attribute__((warn_unused_result
));
412 extern int blkid_probe_get_dimension(blkid_probe pr
,
413 blkid_loff_t
*off
, blkid_loff_t
*size
)
414 __attribute__((nonnull
));
416 extern int blkid_probe_set_dimension(blkid_probe pr
,
417 blkid_loff_t off
, blkid_loff_t size
)
418 __attribute__((nonnull
));
420 extern int blkid_probe_get_idmag(blkid_probe pr
, const struct blkid_idinfo
*id
,
421 blkid_loff_t
*offset
, const struct blkid_idmag
**res
)
422 __attribute__((nonnull(1)));
424 /* returns superblok according to 'struct blkid_idmag' */
425 #define blkid_probe_get_sb(_pr, _mag, type) \
426 ((type *) blkid_probe_get_buffer((_pr),\
427 (_mag)->kboff << 10, sizeof(type)))
429 extern blkid_partlist
blkid_probe_get_partlist(blkid_probe pr
)
430 __attribute__((nonnull
))
431 __attribute__((warn_unused_result
));
433 extern int blkid_probe_is_covered_by_pt(blkid_probe pr
,
434 blkid_loff_t offset
, blkid_loff_t size
)
435 __attribute__((warn_unused_result
));
437 extern void blkid_probe_chain_reset_values(blkid_probe pr
, struct blkid_chain
*chn
)
438 __attribute__((nonnull
));
439 extern int blkid_probe_chain_save_values(blkid_probe pr
,
440 struct blkid_chain
*chn
,
441 struct list_head
*vals
)
442 __attribute__((nonnull
));
444 extern struct blkid_prval
*blkid_probe_assign_value(blkid_probe pr
,
446 __attribute__((nonnull
))
447 __attribute__((warn_unused_result
));
449 extern void blkid_probe_free_value(struct blkid_prval
*v
);
452 extern void blkid_probe_append_values_list(blkid_probe pr
,
453 struct list_head
*vals
)
454 __attribute__((nonnull
));
456 extern void blkid_probe_free_values_list(struct list_head
*vals
);
458 extern struct blkid_chain
*blkid_probe_get_chain(blkid_probe pr
)
459 __attribute__((nonnull
))
460 __attribute__((warn_unused_result
));
462 extern struct blkid_prval
*blkid_probe_last_value(blkid_probe pr
);
464 extern struct blkid_prval
*__blkid_probe_get_value(blkid_probe pr
, int num
)
465 __attribute__((nonnull
))
466 __attribute__((warn_unused_result
));
468 extern struct blkid_prval
*__blkid_probe_lookup_value(blkid_probe pr
, const char *name
)
469 __attribute__((nonnull
))
470 __attribute__((warn_unused_result
));
472 extern unsigned long *blkid_probe_get_filter(blkid_probe pr
, int chain
, int create
)
473 __attribute__((nonnull
))
474 __attribute__((warn_unused_result
));
476 extern int __blkid_probe_invert_filter(blkid_probe pr
, int chain
)
477 __attribute__((nonnull
));
478 extern int __blkid_probe_reset_filter(blkid_probe pr
, int chain
)
479 __attribute__((nonnull
));
480 extern int __blkid_probe_filter_types(blkid_probe pr
, int chain
, int flag
, char *names
[])
481 __attribute__((nonnull
));
483 extern void *blkid_probe_get_binary_data(blkid_probe pr
, struct blkid_chain
*chn
)
484 __attribute__((nonnull
))
485 __attribute__((warn_unused_result
));
487 extern struct blkid_prval
*blkid_probe_new_val(void)
488 __attribute__((warn_unused_result
));
489 extern int blkid_probe_set_value(blkid_probe pr
, const char *name
,
490 unsigned char *data
, size_t len
)
491 __attribute__((nonnull
));
492 extern int blkid_probe_value_set_data(struct blkid_prval
*v
,
493 unsigned char *data
, size_t len
)
494 __attribute__((nonnull
));
496 extern int blkid_probe_vsprintf_value(blkid_probe pr
, const char *name
,
497 const char *fmt
, va_list ap
)
498 __attribute__((nonnull
));
500 extern int blkid_probe_sprintf_value(blkid_probe pr
, const char *name
,
501 const char *fmt
, ...)
502 __attribute__((nonnull
))
503 __attribute__ ((__format__ (__printf__
, 3, 4)));
505 extern int blkid_probe_set_magic(blkid_probe pr
, blkid_loff_t offset
,
506 size_t len
, unsigned char *magic
)
507 __attribute__((nonnull
));
509 extern int blkid_probe_verify_csum(blkid_probe pr
, uint64_t csum
, uint64_t expected
)
510 __attribute__((nonnull
));
512 extern void blkid_unparse_uuid(const unsigned char *uuid
, char *str
, size_t len
)
513 __attribute__((nonnull
));
514 extern int blkid_uuid_is_empty(const unsigned char *buf
, size_t len
);
516 extern size_t blkid_rtrim_whitespace(unsigned char *str
)
517 __attribute__((nonnull
));
518 extern size_t blkid_ltrim_whitespace(unsigned char *str
)
519 __attribute__((nonnull
));
521 extern void blkid_probe_set_wiper(blkid_probe pr
, blkid_loff_t off
,
523 __attribute__((nonnull
));
524 extern int blkid_probe_is_wiped(blkid_probe pr
, struct blkid_chain
**chn
,
525 blkid_loff_t off
, blkid_loff_t size
)
526 __attribute__((nonnull
))
527 __attribute__((warn_unused_result
));
528 extern void blkid_probe_use_wiper(blkid_probe pr
, blkid_loff_t off
, blkid_loff_t size
)
529 __attribute__((nonnull
));
531 /* filter bitmap macros */
532 #define blkid_bmp_wordsize (8 * sizeof(unsigned long))
533 #define blkid_bmp_idx_bit(item) (1UL << ((item) % blkid_bmp_wordsize))
534 #define blkid_bmp_idx_byte(item) ((item) / blkid_bmp_wordsize)
536 #define blkid_bmp_set_item(bmp, item) \
537 ((bmp)[ blkid_bmp_idx_byte(item) ] |= blkid_bmp_idx_bit(item))
539 #define blkid_bmp_unset_item(bmp, item) \
540 ((bmp)[ blkid_bmp_idx_byte(item) ] &= ~blkid_bmp_idx_bit(item))
542 #define blkid_bmp_get_item(bmp, item) \
543 ((bmp)[ blkid_bmp_idx_byte(item) ] & blkid_bmp_idx_bit(item))
545 #define blkid_bmp_nwords(max_items) \
546 (((max_items) + blkid_bmp_wordsize) / blkid_bmp_wordsize)
548 #define blkid_bmp_nbytes(max_items) \
549 (blkid_bmp_nwords(max_items) * sizeof(unsigned long))
552 extern unsigned char *blkid_encode_alloc(size_t count
, size_t *reslen
);
553 extern size_t blkid_encode_to_utf8(int enc
, unsigned char *dest
, size_t len
,
554 const unsigned char *src
, size_t count
)
555 __attribute__((nonnull
));
557 #define BLKID_ENC_UTF16BE 0
558 #define BLKID_ENC_UTF16LE 1
560 #endif /* _BLKID_BLKIDP_H */