libblkid-tiny/blkidP.h

   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 #include "c.h"
  27 #include "bitops.h"     /* $(top_srcdir)/include/ */
  28 #include "blkdev.h"
  29
  30 #if 0
  31 #include "debug.h"
  32 #include "blkid.h"
  33 #include "list.h"
  34 #else
  35 #include "libblkid-tiny.h"
  36 #include "blkid.h"
  37 #include <libubox/list.h>
  38 #endif
  39
  40 /*
  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.
  45  */
  46 struct blkid_struct_dev
  47 {
  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 */
  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 /*
 125  * Low-level probe result
 126  */
 127 struct blkid_prval
 128 {
 129         const char      *name;          /* value name */
 130         unsigned char   *data;          /* value data */
 131         size_t          len;            /* length of value data */
 132
 133         struct blkid_chain      *chain;         /* owner */
 134         struct list_head        prvals;         /* list of results */
 135 };
 136
 137 /* Moved to libblkid-tiny.h because it's needed outside of the private impl. */
 138 #if 0
 139 /*
 140  * Filesystem / Raid magic strings
 141  */
 142 struct blkid_idmag
 143 {
 144         const char      *magic;         /* magic string */
 145         unsigned int    len;            /* length of magic */
 146
 147         long            kboff;          /* kilobyte offset of superblock */
 148         unsigned int    sboff;          /* byte offset within superblock */
 149 };
 150
 151 /*
 152  * Filesystem / Raid description
 153  */
 154 struct blkid_idinfo
 155 {
 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 */
 160
 161                                         /* probe function */
 162         int             (*probefunc)(blkid_probe pr, const struct blkid_idmag *mag);
 163
 164         struct blkid_idmag      magics[];       /* NULL or array with magic strings */
 165 };
 166 #endif
 167
 168 #define BLKID_NONE_MAGIC        {{ NULL }}
 169
 170 /*
 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).
 174  */
 175 #define BLKID_IDINFO_TOLERANT   (1 << 1)
 176
 177 struct blkid_bufinfo {
 178         unsigned char           *data;
 179         blkid_loff_t            off;
 180         blkid_loff_t            len;
 181         struct list_head        bufs;   /* list of buffers */
 182 };
 183
 184 /* Replaced by a smaller struct in libblkid-tiny.h */
 185 #if 0
 186 /*
 187  * Low-level probing control struct
 188  */
 189 struct blkid_struct_probe
 190 {
 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) */
 195
 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 */
 200
 201         int                     flags;          /* private libray flags */
 202         int                     prob_flags;     /* always zeroized by blkid_do_*() */
 203
 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, ... */
 207
 208         struct list_head        buffers;        /* list of buffers */
 209
 210         struct blkid_chain      chains[BLKID_NCHAINS];  /* array of chains */
 211         struct blkid_chain      *cur_chain;             /* current chain */
 212
 213         struct list_head        values;         /* results */
 214
 215         struct blkid_struct_probe *parent;      /* for clones */
 216         struct blkid_struct_probe *disk_probe;  /* whole-disk probing */
 217 };
 218 #endif
 219
 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 */
 225
 226 /* private per-probing flags */
 227 #define BLKID_PROBE_FL_IGNORE_PT (1 << 1)       /* ignore partition table */
 228
 229 extern blkid_probe blkid_clone_probe(blkid_probe parent);
 230 extern blkid_probe blkid_probe_get_wholedisk_probe(blkid_probe pr);
 231
 232 /*
 233  * Evaluation methods (for blkid_eval_* API)
 234  */
 235 enum {
 236         BLKID_EVAL_UDEV = 0,
 237         BLKID_EVAL_SCAN,
 238
 239         __BLKID_EVAL_LAST
 240 };
 241
 242 /*
 243  * Library config options
 244  */
 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 */
 250 };
 251
 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);
 255
 256 /*
 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.
 260  */
 261 #define BLKID_PROBE_MIN         2
 262
 263 /*
 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).
 267  */
 268 #define BLKID_PROBE_INTERVAL    200
 269
 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).
 275  */
 276 struct blkid_struct_cache
 277 {
 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 */
 285 };
 286
 287 #define BLKID_BIC_FL_PROBED     0x0002  /* We probed /proc/partition devices */
 288 #define BLKID_BIC_FL_CHANGED    0x0004  /* Cache has changed from disk */
 289
 290 /* config file */
 291 #define BLKID_CONFIG_FILE       "/etc/blkid.conf"
 292
 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"
 297
 298 /* old systems */
 299 #define BLKID_CACHE_FILE_OLD    "/etc/blkid.tab"
 300
 301 #define BLKID_PROBE_OK   0
 302 #define BLKID_PROBE_NONE 1
 303
 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
 311
 312 /*
 313  * Priority settings for different types of devices
 314  */
 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
 320
 321 #if 0
 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 */
 337
 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)
 341
 342 extern void blkid_debug_dump_dev(blkid_dev dev);
 343 extern void blkid_debug_dump_tag(blkid_tag tag);
 344 #else
 345 #define DBG(m, x)       do {} while (0)
 346 #endif
 347
 348 /* devno.c */
 349 struct dir_list {
 350         char    *name;
 351         struct dir_list *next;
 352 };
 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));
 357
 358 /* lseek.c */
 359 extern blkid_loff_t blkid_llseek(int fd, blkid_loff_t offset, int whence);
 360
 361 /* read.c */
 362 extern void blkid_read_cache(blkid_cache cache)
 363                         __attribute__((nonnull));
 364
 365 /* save.c */
 366 extern int blkid_flush_cache(blkid_cache cache)
 367                         __attribute__((nonnull));
 368
 369 /* cache */
 370 extern char *blkid_safe_getenv(const char *arg)
 371                         __attribute__((nonnull))
 372                         __attribute__((warn_unused_result));
 373
 374 extern char *blkid_get_cache_filename(struct blkid_config *conf)
 375                         __attribute__((warn_unused_result));
 376 /*
 377  * Functions to create and find a specific tag type: tag.c
 378  */
 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));
 383
 384 extern int blkid_set_tag(blkid_dev dev, const char *name,
 385                          const char *value, const int vlength)
 386                         __attribute__((nonnull(1,2)));
 387
 388 /*
 389  * Functions to create and find a specific tag type: dev.c
 390  */
 391 extern blkid_dev blkid_new_dev(void)
 392                         __attribute__((warn_unused_result));
 393 extern void blkid_free_dev(blkid_dev dev);
 394
 395 /* probe.c */
 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));
 402
 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));
 407
 408 extern unsigned char *blkid_probe_get_sector(blkid_probe pr, unsigned int sector)
 409                         __attribute__((nonnull))
 410                         __attribute__((warn_unused_result));
 411
 412 extern int blkid_probe_get_dimension(blkid_probe pr,
 413                         blkid_loff_t *off, blkid_loff_t *size)
 414                         __attribute__((nonnull));
 415
 416 extern int blkid_probe_set_dimension(blkid_probe pr,
 417                         blkid_loff_t off, blkid_loff_t size)
 418                         __attribute__((nonnull));
 419
 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)));
 423
 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)))
 428
 429 extern blkid_partlist blkid_probe_get_partlist(blkid_probe pr)
 430                         __attribute__((nonnull))
 431                         __attribute__((warn_unused_result));
 432
 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));
 436
 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));
 443
 444 extern struct blkid_prval *blkid_probe_assign_value(blkid_probe pr,
 445                                         const char *name)
 446                         __attribute__((nonnull))
 447                         __attribute__((warn_unused_result));
 448
 449 extern void blkid_probe_free_value(struct blkid_prval *v);
 450
 451
 452 extern void blkid_probe_append_values_list(blkid_probe pr,
 453                                     struct list_head *vals)
 454                         __attribute__((nonnull));
 455
 456 extern void blkid_probe_free_values_list(struct list_head *vals);
 457
 458 extern struct blkid_chain *blkid_probe_get_chain(blkid_probe pr)
 459                         __attribute__((nonnull))
 460                         __attribute__((warn_unused_result));
 461
 462 extern struct blkid_prval *blkid_probe_last_value(blkid_probe pr);
 463
 464 extern struct blkid_prval *__blkid_probe_get_value(blkid_probe pr, int num)
 465                         __attribute__((nonnull))
 466                         __attribute__((warn_unused_result));
 467
 468 extern struct blkid_prval *__blkid_probe_lookup_value(blkid_probe pr, const char *name)
 469                         __attribute__((nonnull))
 470                         __attribute__((warn_unused_result));
 471
 472 extern unsigned long *blkid_probe_get_filter(blkid_probe pr, int chain, int create)
 473                         __attribute__((nonnull))
 474                         __attribute__((warn_unused_result));
 475
 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));
 482
 483 extern void *blkid_probe_get_binary_data(blkid_probe pr, struct blkid_chain *chn)
 484                         __attribute__((nonnull))
 485                         __attribute__((warn_unused_result));
 486
 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));
 495
 496 extern int blkid_probe_vsprintf_value(blkid_probe pr, const char *name,
 497                                 const char *fmt, va_list ap)
 498                         __attribute__((nonnull));
 499
 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)));
 504
 505 extern int blkid_probe_set_magic(blkid_probe pr, blkid_loff_t offset,
 506                                 size_t len, unsigned char *magic)
 507                         __attribute__((nonnull));
 508
 509 extern int blkid_probe_verify_csum(blkid_probe pr, uint64_t csum, uint64_t expected)
 510                         __attribute__((nonnull));
 511
 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);
 515
 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));
 520
 521 extern void blkid_probe_set_wiper(blkid_probe pr, blkid_loff_t off,
 522                                   blkid_loff_t size)
 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));
 530
 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)
 535
 536 #define blkid_bmp_set_item(bmp, item)   \
 537                 ((bmp)[ blkid_bmp_idx_byte(item) ] |= blkid_bmp_idx_bit(item))
 538
 539 #define blkid_bmp_unset_item(bmp, item) \
 540                 ((bmp)[ blkid_bmp_idx_byte(item) ] &= ~blkid_bmp_idx_bit(item))
 541
 542 #define blkid_bmp_get_item(bmp, item)   \
 543                 ((bmp)[ blkid_bmp_idx_byte(item) ] & blkid_bmp_idx_bit(item))
 544
 545 #define blkid_bmp_nwords(max_items) \
 546                 (((max_items) + blkid_bmp_wordsize) / blkid_bmp_wordsize)
 547
 548 #define blkid_bmp_nbytes(max_items) \
 549                 (blkid_bmp_nwords(max_items) * sizeof(unsigned long))
 550
 551 /* encode.c */
 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));
 556
 557 #define BLKID_ENC_UTF16BE       0
 558 #define BLKID_ENC_UTF16LE       1
 559
 560 #endif /* _BLKID_BLKIDP_H */