lib/blkid/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 #include <sys/types.h>
  17 #include <stdio.h>
  18
  19 #include <blkid/blkid.h>
  20
  21 #include <blkid/list.h>
  22
  23 #ifdef __GNUC__
  24 #define __BLKID_ATTR(x) __attribute__(x)
  25 #else
  26 #define __BLKID_ATTR(x)
  27 #endif
  28
  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 struct blkid_struct_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         blkid_cache             bid_cache;      /* Dev belongs to this cache */
  41         char                    *bid_name;      /* Device inode pathname */
  42         char                    *bid_type;      /* Preferred device TYPE */
  43         int                     bid_pri;        /* Device priority */
  44         dev_t                   bid_devno;      /* Device major/minor number */
  45         time_t                  bid_time;       /* Last update time of device */
  46         unsigned int            bid_flags;      /* Device status bitflags */
  47         char                    *bid_label;     /* Shortcut to device LABEL */
  48         char                    *bid_uuid;      /* Shortcut to binary UUID */
  49 };
  50
  51 #define BLKID_BID_FL_VERIFIED   0x0001  /* Device data validated from disk */
  52 #define BLKID_BID_FL_INVALID    0x0004  /* Device is invalid */
  53
  54 /*
  55  * Each tag defines a NAME=value pair for a particular device.  The tags
  56  * are linked via bit_names for a single device, so that traversing the
  57  * names list will get you a list of all tags associated with a device.
  58  * They are also linked via bit_values for all devices, so one can easily
  59  * search all tags with a given NAME for a specific value.
  60  */
  61 struct blkid_struct_tag
  62 {
  63         struct list_head        bit_tags;       /* All tags for this device */
  64         struct list_head        bit_names;      /* All tags with given NAME */
  65         char                    *bit_name;      /* NAME of tag (shared) */
  66         char                    *bit_val;       /* value of tag */
  67         blkid_dev               bit_dev;        /* pointer to device */
  68 };
  69 typedef struct blkid_struct_tag *blkid_tag;
  70
  71 /*
  72  * Minimum number of seconds between device probes, even when reading
  73  * from the cache.  This is to avoid re-probing all devices which were
  74  * just probed by another program that does not share the cache.
  75  */
  76 #define BLKID_PROBE_MIN         2
  77
  78 /*
  79  * Time in seconds an entry remains verified in the in-memory cache
  80  * before being reverified (in case of long-running processes that
  81  * keep a cache in memory and continue to use it for a long time).
  82  */
  83 #define BLKID_PROBE_INTERVAL    200
  84
  85 /* This describes an entire blkid cache file and probed devices.
  86  * We can traverse all of the found devices via bic_list.
  87  * We can traverse all of the tag types by bic_tags, which hold empty tags
  88  * for each tag type.  Those tags can be used as list_heads for iterating
  89  * through all devices with a specific tag type (e.g. LABEL).
  90  */
  91 struct blkid_struct_cache
  92 {
  93         struct list_head        bic_devs;       /* List head of all devices */
  94         struct list_head        bic_tags;       /* List head of all tag types */
  95         time_t                  bic_time;       /* Last probe time */
  96         time_t                  bic_ftime;      /* Mod time of the cachefile */
  97         unsigned int            bic_flags;      /* Status flags of the cache */
  98         char                    *bic_filename;  /* filename of cache */
  99 };
 100
 101 #define BLKID_BIC_FL_PROBED     0x0002  /* We probed /proc/partition devices */
 102 #define BLKID_BIC_FL_CHANGED    0x0004  /* Cache has changed from disk */
 103
 104 extern char *blkid_strdup(const char *s);
 105 extern char *blkid_strndup(const char *s, const int length);
 106
 107 #define BLKID_CACHE_FILE "/etc/blkid.tab"
 108 extern const char *blkid_devdirs[];
 109
 110 #define BLKID_ERR_IO     5
 111 #define BLKID_ERR_PROC   9
 112 #define BLKID_ERR_MEM   12
 113 #define BLKID_ERR_CACHE 14
 114 #define BLKID_ERR_DEV   19
 115 #define BLKID_ERR_PARAM 22
 116 #define BLKID_ERR_BIG   27
 117
 118 /*
 119  * Priority settings for different types of devices
 120  */
 121 #define BLKID_PRI_EVMS  30
 122 #define BLKID_PRI_LVM   20
 123 #define BLKID_PRI_MD    10
 124
 125 #if defined(TEST_PROGRAM) && !defined(CONFIG_BLKID_DEBUG)
 126 #define CONFIG_BLKID_DEBUG
 127 #endif
 128
 129 #define DEBUG_CACHE     0x0001
 130 #define DEBUG_DUMP      0x0002
 131 #define DEBUG_DEV       0x0004
 132 #define DEBUG_DEVNAME   0x0008
 133 #define DEBUG_DEVNO     0x0010
 134 #define DEBUG_PROBE     0x0020
 135 #define DEBUG_READ      0x0040
 136 #define DEBUG_RESOLVE   0x0080
 137 #define DEBUG_SAVE      0x0100
 138 #define DEBUG_TAG       0x0200
 139 #define DEBUG_INIT      0x8000
 140 #define DEBUG_ALL       0xFFFF
 141
 142 #ifdef CONFIG_BLKID_DEBUG
 143 #include <stdio.h>
 144 extern int      blkid_debug_mask;
 145 #define DBG(m,x)        if ((m) & blkid_debug_mask) x;
 146 #else
 147 #define DBG(m,x)
 148 #endif
 149
 150 #ifdef CONFIG_BLKID_DEBUG
 151 static __inline__ void DEB_DUMP_TAG(int mask, blkid_tag tag)
 152 {
 153         if (!(mask & blkid_debug_mask))
 154                 return;
 155
 156         if (!tag) {
 157                 printf("    tag: NULL\n");
 158                 return;
 159         }
 160
 161         printf("    tag: %s=\"%s\"\n", tag->bit_name, tag->bit_val);
 162 }
 163
 164 static __inline__ void DEB_DUMP_DEV(int mask, blkid_dev dev)
 165 {
 166         struct list_head *p;
 167
 168         if (!(mask & blkid_debug_mask))
 169                 return;
 170
 171         if (!dev) {
 172                 printf("  dev: NULL\n");
 173                 return;
 174         }
 175
 176         printf("  dev: name = %s\n", dev->bid_name);
 177         printf("  dev: DEVNO=\"0x%0Lx\"\n", dev->bid_devno);
 178         printf("  dev: TIME=\"%lu\"\n", dev->bid_time);
 179         printf("  dev: PRI=\"%d\"\n", dev->bid_pri);
 180         printf("  dev: flags = 0x%08X\n", dev->bid_flags);
 181
 182         list_for_each(p, &dev->bid_tags) {
 183                 blkid_tag tag = list_entry(p, struct blkid_struct_tag, bit_tags);
 184                 DEB_DUMP_TAG(mask, tag);
 185         }
 186         printf("\n");
 187 }
 188
 189 static __inline__ void DEB_DUMP_CACHE(int mask, blkid_cache cache)
 190 {
 191         struct list_head *p;
 192
 193         if (!cache || !(mask & blkid_debug_mask)) {
 194                 printf("cache: NULL\n");
 195                 return;
 196         }
 197
 198         printf("cache: time = %lu\n", cache->bic_time);
 199         printf("cache: flags = 0x%08X\n", cache->bic_flags);
 200
 201         list_for_each(p, &cache->bic_devs) {
 202                 blkid_dev dev = list_entry(p, struct blkid_struct_dev, bid_devs);
 203                 DEB_DUMP_DEV(mask, dev);
 204         }
 205 }
 206 #else
 207 #define DEB_DUMP_TAG(mask, tag) do {} while (0)
 208 #define DEB_DUMP_DEV(mask, dev) do {} while (0)
 209 #define DEB_DUMP_CACHE(mask, cache) do {} while (0)
 210 #endif
 211
 212 /* lseek.c */
 213 extern blkid_loff_t blkid_llseek(int fd, blkid_loff_t offset, int whence);
 214
 215 /* probe.c */
 216 extern blkid_dev blkid_verify_devname(blkid_cache cache, blkid_dev dev);
 217
 218 /* read.c */
 219 extern void blkid_read_cache(blkid_cache cache);
 220
 221 /* save.c */
 222 extern int blkid_flush_cache(blkid_cache cache);
 223
 224 /*
 225  * Functions to create and find a specific tag type: tag.c
 226  */
 227 extern void blkid_free_tag(blkid_tag tag);
 228 extern blkid_tag blkid_find_tag_dev(blkid_dev dev, const char *type);
 229 extern int blkid_set_tag(blkid_dev dev, const char *name,
 230                          const char *value, const int vlength);
 231
 232 /*
 233  * Functions to create and find a specific tag type: dev.c
 234  */
 235 extern blkid_dev blkid_new_dev(void);
 236 extern void blkid_free_dev(blkid_dev dev);
 237
 238 #ifdef __cplusplus
 239 }
 240 #endif
 241
 242 #endif /* _BLKID_BLKIDP_H */