kmodloader: use the name of the module struct when unloading modules
[project/ubox.git] / 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
17 #define CONFIG_BLKID_DEBUG 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 #include "blkid.h"
31 #include <libubox/list.h>
32
33 /*
34  * This describes the attributes of a specific device.
35  * We can traverse all of the tags by bid_tags (linking to the tag bit_names).
36  * The bid_label and bid_uuid fields are shortcuts to the LABEL and UUID tag
37  * values, if they exist.
38  */
39 struct blkid_struct_dev
40 {
41         struct list_head        bid_devs;       /* All devices in the cache */
42         struct list_head        bid_tags;       /* All tags for this device */
43         blkid_cache             bid_cache;      /* Dev belongs to this cache */
44         char                    *bid_name;      /* Device inode pathname */
45         char                    *bid_type;      /* Preferred device TYPE */
46         int                     bid_pri;        /* Device priority */
47         dev_t                   bid_devno;      /* Device major/minor number */
48         time_t                  bid_time;       /* Last update time of device */
49         suseconds_t             bid_utime;      /* Last update time (microseconds) */
50         unsigned int            bid_flags;      /* Device status bitflags */
51         char                    *bid_label;     /* Shortcut to device LABEL */
52         char                    *bid_uuid;      /* Shortcut to binary UUID */
53 };
54
55 #define BLKID_BID_FL_VERIFIED   0x0001  /* Device data validated from disk */
56 #define BLKID_BID_FL_INVALID    0x0004  /* Device is invalid */
57 #define BLKID_BID_FL_REMOVABLE  0x0008  /* Device added by blkid_probe_all_removable() */
58
59 /*
60  * Each tag defines a NAME=value pair for a particular device.  The tags
61  * are linked via bit_names for a single device, so that traversing the
62  * names list will get you a list of all tags associated with a device.
63  * They are also linked via bit_values for all devices, so one can easily
64  * search all tags with a given NAME for a specific value.
65  */
66 struct blkid_struct_tag
67 {
68         struct list_head        bit_tags;       /* All tags for this device */
69         struct list_head        bit_names;      /* All tags with given NAME */
70         char                    *bit_name;      /* NAME of tag (shared) */
71         char                    *bit_val;       /* value of tag */
72         blkid_dev               bit_dev;        /* pointer to device */
73 };
74 typedef struct blkid_struct_tag *blkid_tag;
75
76 /*
77  * Chain IDs
78  */
79 enum {
80         BLKID_CHAIN_SUBLKS,     /* FS/RAID superblocks (enabled by default) */
81         BLKID_CHAIN_TOPLGY,     /* Block device topology */
82         BLKID_CHAIN_PARTS,      /* Partition tables */
83
84         BLKID_NCHAINS           /* number of chains */
85 };
86
87 struct blkid_chain {
88         const struct blkid_chaindrv *driver;    /* chain driver */
89
90         int             enabled;        /* boolean */
91         int             flags;          /* BLKID_<chain>_* */
92         int             binary;         /* boolean */
93         int             idx;            /* index of the current prober (or -1) */
94         unsigned long   *fltr;          /* filter or NULL */
95         void            *data;          /* private chain data or NULL */
96 };
97
98 /*
99  * Chain driver
100  */
101 struct blkid_chaindrv {
102         const size_t    id;             /* BLKID_CHAIN_* */
103         const char      *name;          /* name of chain (for debug purpose) */
104         const int       dflt_flags;     /* default chain flags */
105         const int       dflt_enabled;   /* default enabled boolean */
106         int             has_fltr;       /* boolean */
107
108         const struct blkid_idinfo **idinfos; /* description of probing functions */
109         const size_t    nidinfos;       /* number of idinfos */
110
111         /* driver operations */
112         int             (*probe)(blkid_probe, struct blkid_chain *);
113         int             (*safeprobe)(blkid_probe, struct blkid_chain *);
114         void            (*free_data)(blkid_probe, void *);
115 };
116
117 /*
118  * Low-level probe result
119  */
120 #define BLKID_PROBVAL_BUFSIZ    64
121
122 #define BLKID_NVALS_SUBLKS      14
123 #define BLKID_NVALS_TOPLGY      5
124 #define BLKID_NVALS_PARTS       13
125
126 /* Max number of all values in probing result */
127 #define BLKID_NVALS             (BLKID_NVALS_SUBLKS + \
128                                  BLKID_NVALS_TOPLGY + \
129                                  BLKID_NVALS_PARTS)
130
131 struct blkid_prval
132 {
133         const char      *name;                  /* value name */
134         unsigned char   data[BLKID_PROBVAL_BUFSIZ]; /* value data */
135         size_t          len;                    /* length of value data */
136
137         struct blkid_chain      *chain;         /* owner */
138 };
139
140 /*
141  * Filesystem / Raid magic strings
142  */
143 /*
144  * Filesystem / Raid description
145  */
146 #define BLKID_NONE_MAGIC        {{ NULL }}
147
148 /*
149  * tolerant FS - can share the same device with more filesystems (e.g. typical
150  * on CD-ROMs). We need this flag to detect ambivalent results (e.g. valid fat
151  * and valid linux swap on the same device).
152  */
153 #define BLKID_IDINFO_TOLERANT   (1 << 1)
154
155 struct blkid_bufinfo {
156         unsigned char           *data;
157         blkid_loff_t            off;
158         blkid_loff_t            len;
159         struct list_head        bufs;   /* list of buffers */
160 };
161
162 /* private flags library flags */
163 #define BLKID_FL_PRIVATE_FD     (1 << 1)        /* see blkid_new_probe_from_filename() */
164 #define BLKID_FL_TINY_DEV       (1 << 2)        /* <= 1.47MiB (floppy or so) */
165 #define BLKID_FL_CDROM_DEV      (1 << 3)        /* is a CD/DVD drive */
166
167 /* private per-probing flags */
168 #define BLKID_PROBE_FL_IGNORE_PT (1 << 1)       /* ignore partition table */
169
170 extern blkid_probe blkid_clone_probe(blkid_probe parent);
171 extern blkid_probe blkid_probe_get_wholedisk_probe(blkid_probe pr);
172
173 /*
174  * Evaluation methods (for blkid_eval_* API)
175  */
176 enum {
177         BLKID_EVAL_UDEV = 0,
178         BLKID_EVAL_SCAN,
179
180         __BLKID_EVAL_LAST
181 };
182
183 /*
184  * Library config options
185  */
186 struct blkid_config {
187         int eval[__BLKID_EVAL_LAST];    /* array with EVALUATION=<udev,cache> options */
188         int nevals;                     /* number of elems in eval array */
189         int uevent;                     /* SEND_UEVENT=<yes|not> option */
190         char *cachefile;                /* CACHE_FILE=<path> option */
191 };
192
193 extern struct blkid_config *blkid_read_config(const char *filename);
194 extern void blkid_free_config(struct blkid_config *conf);
195
196 /*
197  * Minimum number of seconds between device probes, even when reading
198  * from the cache.  This is to avoid re-probing all devices which were
199  * just probed by another program that does not share the cache.
200  */
201 #define BLKID_PROBE_MIN         2
202
203 /*
204  * Time in seconds an entry remains verified in the in-memory cache
205  * before being reverified (in case of long-running processes that
206  * keep a cache in memory and continue to use it for a long time).
207  */
208 #define BLKID_PROBE_INTERVAL    200
209
210 /* This describes an entire blkid cache file and probed devices.
211  * We can traverse all of the found devices via bic_list.
212  * We can traverse all of the tag types by bic_tags, which hold empty tags
213  * for each tag type.  Those tags can be used as list_heads for iterating
214  * through all devices with a specific tag type (e.g. LABEL).
215  */
216 struct blkid_struct_cache
217 {
218         struct list_head        bic_devs;       /* List head of all devices */
219         struct list_head        bic_tags;       /* List head of all tag types */
220         time_t                  bic_time;       /* Last probe time */
221         time_t                  bic_ftime;      /* Mod time of the cachefile */
222         unsigned int            bic_flags;      /* Status flags of the cache */
223         char                    *bic_filename;  /* filename of cache */
224         blkid_probe             probe;          /* low-level probing stuff */
225 };
226
227 #define BLKID_BIC_FL_PROBED     0x0002  /* We probed /proc/partition devices */
228 #define BLKID_BIC_FL_CHANGED    0x0004  /* Cache has changed from disk */
229
230 extern char *blkid_strdup(const char *s);
231 extern char *blkid_strndup(const char *s, const int length);
232 extern char *blkid_strconcat(const char *a, const char *b, const char *c);
233
234 /* config file */
235 #define BLKID_CONFIG_FILE       "/etc/blkid.conf"
236
237 /* cache file on systemds with /run */
238 #define BLKID_RUNTIME_TOPDIR    "/run"
239 #define BLKID_RUNTIME_DIR       BLKID_RUNTIME_TOPDIR "/blkid"
240 #define BLKID_CACHE_FILE        BLKID_RUNTIME_DIR "/blkid.tab"
241
242 /* old systems */
243 #define BLKID_CACHE_FILE_OLD    "/etc/blkid.tab"
244
245 #define BLKID_ERR_IO     5
246 #define BLKID_ERR_PROC   9
247 #define BLKID_ERR_MEM   12
248 #define BLKID_ERR_CACHE 14
249 #define BLKID_ERR_DEV   19
250 #define BLKID_ERR_PARAM 22
251 #define BLKID_ERR_BIG   27
252
253 /*
254  * Priority settings for different types of devices
255  */
256 #define BLKID_PRI_UBI   50
257 #define BLKID_PRI_DM    40
258 #define BLKID_PRI_EVMS  30
259 #define BLKID_PRI_LVM   20
260 #define BLKID_PRI_MD    10
261
262 #if defined(TEST_PROGRAM) && !defined(CONFIG_BLKID_DEBUG)
263 #define CONFIG_BLKID_DEBUG
264 #endif
265
266 #define DEBUG_CACHE     0x0001
267 #define DEBUG_DUMP      0x0002
268 #define DEBUG_DEV       0x0004
269 #define DEBUG_DEVNAME   0x0008
270 #define DEBUG_DEVNO     0x0010
271 #define DEBUG_PROBE     0x0020
272 #define DEBUG_READ      0x0040
273 #define DEBUG_RESOLVE   0x0080
274 #define DEBUG_SAVE      0x0100
275 #define DEBUG_TAG       0x0200
276 #define DEBUG_LOWPROBE  0x0400
277 #define DEBUG_CONFIG    0x0800
278 #define DEBUG_EVALUATE  0x1000
279 #define DEBUG_INIT      0x8000
280 #define DEBUG_ALL       0xFFFF
281
282 #ifdef CONFIG_BLKID_DEBUG
283 extern int blkid_debug_mask;
284 extern void blkid_init_debug(int mask);
285 extern void blkid_debug_dump_dev(blkid_dev dev);
286 extern void blkid_debug_dump_tag(blkid_tag tag);
287
288 #define DBG(m,x)        if ((m) & blkid_debug_mask) x;
289
290 #else /* !CONFIG_BLKID_DEBUG */
291 #define DBG(m,x)
292 #define blkid_init_debug(x)
293 #endif /* CONFIG_BLKID_DEBUG */
294
295 /* devno.c */
296 struct dir_list {
297         char    *name;
298         struct dir_list *next;
299 };
300 extern void blkid__scan_dir(char *, dev_t, struct dir_list **, char **);
301 extern int blkid_driver_has_major(const char *drvname, int major);
302
303 /* lseek.c */
304 extern blkid_loff_t blkid_llseek(int fd, blkid_loff_t offset, int whence);
305
306 /* read.c */
307 extern void blkid_read_cache(blkid_cache cache);
308
309 /* save.c */
310 extern int blkid_flush_cache(blkid_cache cache);
311
312 /* cache */
313 extern char *blkid_safe_getenv(const char *arg);
314 extern char *blkid_get_cache_filename(struct blkid_config *conf);
315
316 /*
317  * Functions to create and find a specific tag type: tag.c
318  */
319 extern void blkid_free_tag(blkid_tag tag);
320 extern blkid_tag blkid_find_tag_dev(blkid_dev dev, const char *type);
321 extern int blkid_set_tag(blkid_dev dev, const char *name,
322                          const char *value, const int vlength);
323
324 /*
325  * Functions to create and find a specific tag type: dev.c
326  */
327 extern blkid_dev blkid_new_dev(void);
328 extern void blkid_free_dev(blkid_dev dev);
329
330 /* probe.c */
331 extern int blkid_probe_is_tiny(blkid_probe pr);
332 extern int blkid_probe_is_cdrom(blkid_probe pr);
333 extern unsigned char *blkid_probe_get_buffer(blkid_probe pr,
334                                 blkid_loff_t off, blkid_loff_t len);
335
336 extern unsigned char *blkid_probe_get_sector(blkid_probe pr, unsigned int sector);
337
338 extern int blkid_probe_get_dimension(blkid_probe pr,
339                         blkid_loff_t *off, blkid_loff_t *size);
340
341 extern int blkid_probe_set_dimension(blkid_probe pr,
342                         blkid_loff_t off, blkid_loff_t size);
343
344 extern int blkid_probe_get_idmag(blkid_probe pr, const struct blkid_idinfo *id,
345                         blkid_loff_t *offset, const struct blkid_idmag **res);
346
347 /* returns superblok according to 'struct blkid_idmag' */
348 #define blkid_probe_get_sb(_pr, _mag, type) \
349                         ((type *) blkid_probe_get_buffer((_pr),\
350                                         (_mag)->kboff << 10, sizeof(type)))
351
352 extern blkid_partlist blkid_probe_get_partlist(blkid_probe pr);
353
354 extern int blkid_probe_is_covered_by_pt(blkid_probe pr,
355                                         blkid_loff_t offset, blkid_loff_t size);
356
357 extern void blkid_probe_chain_reset_vals(blkid_probe pr, struct blkid_chain *chn);
358 extern int blkid_probe_chain_copy_vals(blkid_probe pr, struct blkid_chain *chn,
359                                         struct blkid_prval *vals, int nvals);
360 extern struct blkid_prval *blkid_probe_assign_value(blkid_probe pr, const char *name);
361 extern int blkid_probe_reset_last_value(blkid_probe pr);
362 extern void blkid_probe_append_vals(blkid_probe pr, struct blkid_prval *vals, int nvals);
363
364 extern struct blkid_chain *blkid_probe_get_chain(blkid_probe pr);
365
366 extern struct blkid_prval *__blkid_probe_get_value(blkid_probe pr, int num);
367 extern struct blkid_prval *__blkid_probe_lookup_value(blkid_probe pr, const char *name);
368
369 extern unsigned long *blkid_probe_get_filter(blkid_probe pr, int chain, int create);
370 extern int __blkid_probe_invert_filter(blkid_probe pr, int chain);
371 extern int __blkid_probe_reset_filter(blkid_probe pr, int chain);
372 extern int __blkid_probe_filter_types(blkid_probe pr, int chain, int flag, char *names[]);
373
374 extern void *blkid_probe_get_binary_data(blkid_probe pr, struct blkid_chain *chn);
375
376 extern int blkid_probe_set_value(blkid_probe pr, const char *name,
377                 unsigned char *data, size_t len);
378 extern int blkid_probe_vsprintf_value(blkid_probe pr, const char *name,
379                 const char *fmt, va_list ap);
380 extern int blkid_probe_sprintf_value(blkid_probe pr, const char *name,
381                 const char *fmt, ...);
382 extern int blkid_probe_set_magic(blkid_probe pr, blkid_loff_t offset,
383                 size_t len, unsigned char *magic);
384
385 extern void blkid_unparse_uuid(const unsigned char *uuid, char *str, size_t len);
386 extern size_t blkid_rtrim_whitespace(unsigned char *str);
387
388 extern void blkid_probe_set_wiper(blkid_probe pr, blkid_loff_t off,
389                                   blkid_loff_t size);
390 extern int blkid_probe_is_wiped(blkid_probe pr, struct blkid_chain **chn,
391                                 blkid_loff_t off, blkid_loff_t size);
392 extern void blkid_probe_use_wiper(blkid_probe pr, blkid_loff_t off, blkid_loff_t size);
393
394 /* filter bitmap macros */
395 #define blkid_bmp_wordsize              (8 * sizeof(unsigned long))
396 #define blkid_bmp_idx_bit(item)         (1UL << ((item) % blkid_bmp_wordsize))
397 #define blkid_bmp_idx_byte(item)        ((item) / blkid_bmp_wordsize)
398
399 #define blkid_bmp_set_item(bmp, item)   \
400                 ((bmp)[ blkid_bmp_idx_byte(item) ] |= blkid_bmp_idx_bit(item))
401
402 #define blkid_bmp_unset_item(bmp, item) \
403                 ((bmp)[ blkid_bmp_idx_byte(item) ] &= ~blkid_bmp_idx_bit(item))
404
405 #define blkid_bmp_get_item(bmp, item)   \
406                 ((bmp)[ blkid_bmp_idx_byte(item) ] & blkid_bmp_idx_bit(item))
407
408 #define blkid_bmp_nwords(max_items) \
409                 (((max_items) + blkid_bmp_wordsize) / blkid_bmp_wordsize)
410
411 #define blkid_bmp_nbytes(max_items) \
412                 (blkid_bmp_nwords(max_items) * sizeof(unsigned long))
413
414 /* encode.c */
415 extern size_t blkid_encode_to_utf8(int enc, unsigned char *dest, size_t len,
416                         const unsigned char *src, size_t count);
417
418 #define BLKID_ENC_UTF16BE       0
419 #define BLKID_ENC_UTF16LE       1
420
421 #endif /* _BLKID_BLKIDP_H */