[thirdparty/util-linux.git] / libblkid / src / blkid.h.in

/*
 * blkid.h - Interface for libblkid, a library to identify block devices
 *
 * Copyright (C) 2001 Andreas Dilger
 * Copyright (C) 2003 Theodore Ts'o
 * Copyright (C) 2008 Karel Zak <kzak@redhat.com>
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 */

#ifndef _BLKID_BLKID_H
#define _BLKID_BLKID_H

#include <stdint.h>
#include <sys/types.h>

#ifdef __cplusplus
extern "C" {
#endif

#define BLKID_VERSION   "@LIBBLKID_VERSION@"
#define BLKID_DATE      "@LIBBLKID_DATE@"

/**
 * blkid_dev:
 *
 * The device object keeps information about one device
 */
typedef struct blkid_struct_dev *blkid_dev;

/**
 * blkid_cache:
 *
 * information about all system devices
 */
typedef struct blkid_struct_cache *blkid_cache;

/**
 * blkid_probe:
 *
 * low-level probing setting
 */
typedef struct blkid_struct_probe *blkid_probe;

/**
 * blkid_topology:
 *
 * device topology information
 */
typedef struct blkid_struct_topology *blkid_topology;

/**
 * blkid_partlist
 *
 * list of all detected partitions and partitions tables
 */
typedef struct blkid_struct_partlist *blkid_partlist;

/**
 * blkid_partition:
 *
 * information about a partition
 */
typedef struct blkid_struct_partition *blkid_partition;

/**
 * blkid_parttable:
 *
 * information about a partition table
 */
typedef struct blkid_struct_parttable *blkid_parttable;

/**
 * blkid_loff_t:
 *
 * 64-bit signed number for offsets and sizes
 */
typedef int64_t blkid_loff_t;

/**
 * blkid_tag_iterate:
 *
 * tags iterator for high-level (blkid_cache) API
 */
typedef struct blkid_struct_tag_iterate *blkid_tag_iterate;

/**
 * blkid_dev_iterate:
 *
 * devices iterator for high-level (blkid_cache) API
 */
typedef struct blkid_struct_dev_iterate *blkid_dev_iterate;

/*
 * Flags for blkid_get_dev
 *
 * BLKID_DEV_CREATE	Create an empty device structure if not found
 *			in the cache.
 * BLKID_DEV_VERIFY	Make sure the device structure corresponds
 *			with reality.
 * BLKID_DEV_FIND	Just look up a device entry, and return NULL
 *			if it is not found.
 * BLKID_DEV_NORMAL	Get a valid device structure, either from the
 *			cache or by probing the device.
 */
#define BLKID_DEV_FIND		0x0000
#define BLKID_DEV_CREATE	0x0001
#define BLKID_DEV_VERIFY	0x0002
#define BLKID_DEV_NORMAL	(BLKID_DEV_CREATE | BLKID_DEV_VERIFY)


#ifndef __GNUC_PREREQ
# if defined __GNUC__ && defined __GNUC_MINOR__
#  define __GNUC_PREREQ(maj, min)  ((__GNUC__ << 16) + __GNUC_MINOR__ >= ((maj) << 16) + (min))
# else
#  define __GNUC_PREREQ(maj, min) 0
# endif
#endif

#ifndef __ul_attribute__
# if __GNUC_PREREQ (3, 4)
#  define __ul_attribute__(_a_) __attribute__(_a_)
# else
#  define __ul_attribute__(_a_)
# endif
#endif

/* init.c */
extern void blkid_init_debug(int mask);

/* cache.c */
extern void blkid_put_cache(blkid_cache cache);
extern int blkid_get_cache(blkid_cache *cache, const char *filename);
extern void blkid_gc_cache(blkid_cache cache);

/* dev.c */
extern const char *blkid_dev_devname(blkid_dev dev)
			__ul_attribute__((warn_unused_result));

extern blkid_dev_iterate blkid_dev_iterate_begin(blkid_cache cache);
extern int blkid_dev_set_search(blkid_dev_iterate iter,
				const char *search_type, const char *search_value);
extern int blkid_dev_next(blkid_dev_iterate iterate, blkid_dev *dev);
extern void blkid_dev_iterate_end(blkid_dev_iterate iterate);

/* devno.c */
extern char *blkid_devno_to_devname(dev_t devno)
			__ul_attribute__((warn_unused_result));
extern int blkid_devno_to_wholedisk(dev_t dev, char *diskname,
                        size_t len, dev_t *diskdevno)
			__ul_attribute__((warn_unused_result));

/* devname.c */
extern int blkid_probe_all(blkid_cache cache);
extern int blkid_probe_all_new(blkid_cache cache);
extern int blkid_probe_all_removable(blkid_cache cache);

extern blkid_dev blkid_get_dev(blkid_cache cache, const char *devname, int flags);

/* getsize.c */
extern blkid_loff_t blkid_get_dev_size(int fd);

/* verify.c */
extern blkid_dev blkid_verify(blkid_cache cache, blkid_dev dev);

/* read.c */

/* resolve.c */
extern char *blkid_get_tag_value(blkid_cache cache, const char *tagname,
				       const char *devname)
			__ul_attribute__((warn_unused_result));
extern char *blkid_get_devname(blkid_cache cache, const char *token,
			       const char *value)
			__ul_attribute__((warn_unused_result));

/* tag.c */
extern blkid_tag_iterate blkid_tag_iterate_begin(blkid_dev dev);
extern int blkid_tag_next(blkid_tag_iterate iterate,
			      const char **type, const char **value);
extern void blkid_tag_iterate_end(blkid_tag_iterate iterate);
extern int blkid_dev_has_tag(blkid_dev dev, const char *type, const char *value);

extern blkid_dev blkid_find_dev_with_tag(blkid_cache cache,
					 const char *type,
					 const char *value);

extern int blkid_parse_tag_string(const char *token, char **ret_type, char **ret_val);

/* version.c */
extern int blkid_parse_version_string(const char *ver_string)
			__ul_attribute__((nonnull));
extern int blkid_get_library_version(const char **ver_string,
				     const char **date_string);

/* encode.c */
extern int blkid_encode_string(const char *str, char *str_enc, size_t len);
extern int blkid_safe_string(const char *str, char *str_safe, size_t len);

/* evaluate.c */
extern int blkid_send_uevent(const char *devname, const char *action);
extern char *blkid_evaluate_tag(const char *token, const char *value,
				blkid_cache *cache)
			__ul_attribute__((warn_unused_result));
extern char *blkid_evaluate_spec(const char *spec, blkid_cache *cache)
			__ul_attribute__((warn_unused_result));

/* probe.c */
extern blkid_probe blkid_new_probe(void)
			__ul_attribute__((warn_unused_result));
extern blkid_probe blkid_new_probe_from_filename(const char *filename)
			__ul_attribute__((warn_unused_result))
			__ul_attribute__((nonnull));
extern void blkid_free_probe(blkid_probe pr);

extern void blkid_reset_probe(blkid_probe pr);
extern int blkid_probe_reset_buffers(blkid_probe pr);
extern int blkid_probe_hide_range(blkid_probe pr, uint64_t off, uint64_t len);

extern int blkid_probe_set_device(blkid_probe pr, int fd,
	                blkid_loff_t off, blkid_loff_t size)
			__ul_attribute__((nonnull));

extern dev_t blkid_probe_get_devno(blkid_probe pr)
			__ul_attribute__((nonnull));

extern dev_t blkid_probe_get_wholedisk_devno(blkid_probe pr)
			__ul_attribute__((nonnull));

extern int blkid_probe_is_wholedisk(blkid_probe pr)
			__ul_attribute__((nonnull));

extern blkid_loff_t blkid_probe_get_size(blkid_probe pr)
			__ul_attribute__((nonnull));
extern blkid_loff_t blkid_probe_get_offset(blkid_probe pr)
			__ul_attribute__((nonnull));
extern unsigned int blkid_probe_get_sectorsize(blkid_probe pr)
			__ul_attribute__((nonnull));
extern int blkid_probe_set_sectorsize(blkid_probe pr, unsigned int sz)
			__ul_attribute__((nonnull));
extern blkid_loff_t blkid_probe_get_sectors(blkid_probe pr)
			__ul_attribute__((nonnull));

extern int blkid_probe_get_fd(blkid_probe pr)
			__ul_attribute__((nonnull));

extern int blkid_probe_set_hint(blkid_probe pr, const char *name, uint64_t value)
			__ul_attribute__((nonnull));
extern void blkid_probe_reset_hints(blkid_probe pr)
			__ul_attribute__((nonnull));

/*
 * superblocks probing
 */
extern int blkid_known_fstype(const char *fstype)
			__ul_attribute__((nonnull));

extern int blkid_superblocks_get_name(size_t idx, const char **name, int *usage);

extern int blkid_probe_enable_superblocks(blkid_probe pr, int enable)
			__ul_attribute__((nonnull));

#define BLKID_SUBLKS_LABEL	(1 << 1) /* read LABEL from superblock */
#define BLKID_SUBLKS_LABELRAW	(1 << 2) /* read and define LABEL_RAW result value*/
#define BLKID_SUBLKS_UUID	(1 << 3) /* read UUID from superblock */
#define BLKID_SUBLKS_UUIDRAW	(1 << 4) /* read and define UUID_RAW result value */
#define BLKID_SUBLKS_TYPE	(1 << 5) /* define TYPE result value */
#define BLKID_SUBLKS_SECTYPE	(1 << 6) /* define compatible fs type (second type) */
#define BLKID_SUBLKS_USAGE	(1 << 7) /* define USAGE result value */
#define BLKID_SUBLKS_VERSION	(1 << 8) /* read FS type from superblock */
#define BLKID_SUBLKS_MAGIC	(1 << 9) /* define SBMAGIC and SBMAGIC_OFFSET */
#define BLKID_SUBLKS_BADCSUM	(1 << 10) /* allow a bad checksum */
#define BLKID_SUBLKS_FSINFO	(1 << 11) /* read and define fs properties from superblock */

#define BLKID_SUBLKS_DEFAULT	(BLKID_SUBLKS_LABEL | BLKID_SUBLKS_UUID | \
				 BLKID_SUBLKS_TYPE | BLKID_SUBLKS_SECTYPE)

extern int blkid_probe_set_superblocks_flags(blkid_probe pr, int flags)
			__ul_attribute__((nonnull));
extern int blkid_probe_reset_superblocks_filter(blkid_probe pr)
			__ul_attribute__((nonnull));
extern int blkid_probe_invert_superblocks_filter(blkid_probe pr)
			__ul_attribute__((nonnull));

/**
 * BLKID_FLTR_NOTIN
 */
#define BLKID_FLTR_NOTIN		1
/**
 * BLKID_FLTR_ONLYIN
 */
#define BLKID_FLTR_ONLYIN		2
extern int blkid_probe_filter_superblocks_type(blkid_probe pr, int flag, char *names[])
			__ul_attribute__((nonnull));

#define BLKID_USAGE_FILESYSTEM		(1 << 1)
#define BLKID_USAGE_RAID		(1 << 2)
#define BLKID_USAGE_CRYPTO		(1 << 3)
#define BLKID_USAGE_OTHER		(1 << 4)
extern int blkid_probe_filter_superblocks_usage(blkid_probe pr, int flag, int usage)
			__ul_attribute__((nonnull));

/*
 * topology probing
 */
extern int blkid_probe_enable_topology(blkid_probe pr, int enable)
			__ul_attribute__((nonnull));

/* binary interface */
extern blkid_topology blkid_probe_get_topology(blkid_probe pr)
			__ul_attribute__((nonnull));

extern unsigned long blkid_topology_get_alignment_offset(blkid_topology tp)
			__ul_attribute__((nonnull));
extern unsigned long blkid_topology_get_minimum_io_size(blkid_topology tp)
			__ul_attribute__((nonnull));
extern unsigned long blkid_topology_get_optimal_io_size(blkid_topology tp)
			__ul_attribute__((nonnull));
extern unsigned long blkid_topology_get_logical_sector_size(blkid_topology tp)
			__ul_attribute__((nonnull));
extern unsigned long blkid_topology_get_physical_sector_size(blkid_topology tp)
			__ul_attribute__((nonnull));
extern unsigned long blkid_topology_get_dax(blkid_topology tp)
			__ul_attribute__((nonnull));
extern uint64_t blkid_topology_get_diskseq(blkid_topology tp)
			__ul_attribute__((nonnull));

/*
 * partitions probing
 */
extern int blkid_known_pttype(const char *pttype);
extern int blkid_partitions_get_name(const size_t idx, const char **name);

extern int blkid_probe_enable_partitions(blkid_probe pr, int enable)
			__ul_attribute__((nonnull));

extern int blkid_probe_reset_partitions_filter(blkid_probe pr)
			__ul_attribute__((nonnull));
extern int blkid_probe_invert_partitions_filter(blkid_probe pr)
			__ul_attribute__((nonnull));
extern int blkid_probe_filter_partitions_type(blkid_probe pr, int flag, char *names[])
			__ul_attribute__((nonnull));

/* partitions probing flags */
#define BLKID_PARTS_FORCE_GPT		(1 << 1)
#define BLKID_PARTS_ENTRY_DETAILS	(1 << 2)
#define BLKID_PARTS_MAGIC		(1 << 3)
extern int blkid_probe_set_partitions_flags(blkid_probe pr, int flags)
			__ul_attribute__((nonnull));

/* binary interface */
extern blkid_partlist blkid_probe_get_partitions(blkid_probe pr)
			__ul_attribute__((nonnull));

extern int blkid_partlist_numof_partitions(blkid_partlist ls)
			__ul_attribute__((nonnull));
extern blkid_parttable blkid_partlist_get_table(blkid_partlist ls)
			__ul_attribute__((nonnull));
extern blkid_partition blkid_partlist_get_partition(blkid_partlist ls, int n)
			__ul_attribute__((nonnull));
extern blkid_partition blkid_partlist_get_partition_by_partno(blkid_partlist ls, int n)
			__ul_attribute__((nonnull));
extern blkid_partition blkid_partlist_devno_to_partition(blkid_partlist ls, dev_t devno)
			__ul_attribute__((nonnull));
extern blkid_parttable blkid_partition_get_table(blkid_partition par)
			__ul_attribute__((nonnull));

extern const char *blkid_partition_get_name(blkid_partition par)
			__ul_attribute__((nonnull));
extern const char *blkid_partition_get_uuid(blkid_partition par)
			__ul_attribute__((nonnull));
extern int blkid_partition_get_partno(blkid_partition par)
			__ul_attribute__((nonnull));
extern blkid_loff_t blkid_partition_get_start(blkid_partition par)
			__ul_attribute__((nonnull));
extern blkid_loff_t blkid_partition_get_size(blkid_partition par)
			__ul_attribute__((nonnull));

extern int blkid_partition_get_type(blkid_partition par)
			__ul_attribute__((nonnull));
extern const char *blkid_partition_get_type_string(blkid_partition par)
			__ul_attribute__((nonnull));
extern unsigned long long blkid_partition_get_flags(blkid_partition par)
			__ul_attribute__((nonnull));

extern int blkid_partition_is_logical(blkid_partition par)
			__ul_attribute__((nonnull));
extern int blkid_partition_is_extended(blkid_partition par)
			__ul_attribute__((nonnull));
extern int blkid_partition_is_primary(blkid_partition par)
			__ul_attribute__((nonnull));

extern const char *blkid_parttable_get_type(blkid_parttable tab)
			__ul_attribute__((nonnull));
extern const char *blkid_parttable_get_id(blkid_parttable tab)
			__ul_attribute__((nonnull));
extern blkid_loff_t blkid_parttable_get_offset(blkid_parttable tab)
			__ul_attribute__((nonnull));
extern blkid_partition blkid_parttable_get_parent(blkid_parttable tab)
			__ul_attribute__((nonnull));

/*
 * NAME=value low-level interface
 */
extern int blkid_do_probe(blkid_probe pr)
			__ul_attribute__((nonnull));
extern int blkid_do_safeprobe(blkid_probe pr)
			__ul_attribute__((nonnull));
extern int blkid_do_fullprobe(blkid_probe pr)
			__ul_attribute__((nonnull));

/**
 * BLKID_PROBE_OK:
 *
 * probing return value; superblock (RAID, partiton table, ...) succesfully detected
 */
#define BLKID_PROBE_OK	0
/**
 * BLKID_PROBE_NONE:
 *
 * probing return value; found nothing
 */
#define BLKID_PROBE_NONE	1
/**
 * BLKID_PROBE_ERROR:
 *
 * probing return value; probing ends with en error (see errno for more details)
 */
#define BLKID_PROBE_ERROR	-1
/**
 * BLKID_PROBE_AMBIGUOUS:
 *
 * probing return value; more than one probing result, in this case, it's not
 * safe to use the device automaticaly and user intervention is recommended
 */
#define BLKID_PROBE_AMBIGUOUS	-2

extern int blkid_probe_numof_values(blkid_probe pr)
			__ul_attribute__((nonnull));
extern int blkid_probe_get_value(blkid_probe pr, int num, const char **name,
                        const char **data, size_t *len)
			__ul_attribute__((nonnull(1)));
extern int blkid_probe_lookup_value(blkid_probe pr, const char *name,
                        const char **data, size_t *len)
			__ul_attribute__((nonnull(1, 2)));
extern int blkid_probe_has_value(blkid_probe pr, const char *name)
			__ul_attribute__((nonnull));
extern int blkid_do_wipe(blkid_probe pr, int dryrun)
			__ul_attribute__((nonnull));
extern int blkid_probe_step_back(blkid_probe pr)
			__ul_attribute__((nonnull));

/*
 * Deprecated functions/macros
 */
#ifndef BLKID_DISABLE_DEPRECATED

#define BLKID_PROBREQ_LABEL     BLKID_SUBLKS_LABEL
#define BLKID_PROBREQ_LABELRAW  BLKID_SUBLKS_LABELRAW
#define BLKID_PROBREQ_UUID      BLKID_SUBLKS_UUID
#define BLKID_PROBREQ_UUIDRAW   BLKID_SUBLKS_UUIDRAW
#define BLKID_PROBREQ_TYPE      BLKID_SUBLKS_TYPE
#define BLKID_PROBREQ_SECTYPE   BLKID_SUBLKS_SECTYPE
#define BLKID_PROBREQ_USAGE     BLKID_SUBLKS_USAGE
#define BLKID_PROBREQ_VERSION   BLKID_SUBLKS_VERSION

extern int blkid_probe_set_request(blkid_probe pr, int flags)
			__ul_attribute__((deprecated));

extern int blkid_probe_filter_usage(blkid_probe pr, int flag, int usage)
			__ul_attribute__((deprecated));

extern int blkid_probe_filter_types(blkid_probe pr, int flag, char *names[])
			__ul_attribute__((deprecated));

extern int blkid_probe_invert_filter(blkid_probe pr)
			__ul_attribute__((deprecated));

extern int blkid_probe_reset_filter(blkid_probe pr)
			__ul_attribute__((deprecated));

#endif /* BLKID_DISABLE_DEPRECATED */

#ifdef __cplusplus
}
#endif

#endif /* _BLKID_BLKID_H */
Commit	Line	Data
a0948ffe KZ	1	/*
	2	* blkid.h - Interface for libblkid, a library to identify block devices
	3	*
	4	* Copyright (C) 2001 Andreas Dilger
	5	* Copyright (C) 2003 Theodore Ts'o
4a92038d	6	* Copyright (C) 2008 Karel Zak <kzak@redhat.com>
a0948ffe	7	*
4a92038d KZ	8	* This library is free software; you can redistribute it and/or
	9	* modify it under the terms of the GNU Lesser General Public
	10	* License as published by the Free Software Foundation; either
	11	* version 2.1 of the License, or (at your option) any later version.
	12	*
	13	* This library is distributed in the hope that it will be useful,
	14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	16	* Lesser General Public License for more details.
	17	*
	18	* You should have received a copy of the GNU Lesser General Public
	19	* License along with this library; if not, write to the Free Software
7cebf0bb	20	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
a0948ffe KZ	21	*/
	22
	23	#ifndef _BLKID_BLKID_H
	24	#define _BLKID_BLKID_H
	25
e1ad8bb3	26	#include <stdint.h>
a0948ffe	27	#include <sys/types.h>
a0948ffe KZ	28
	29	#ifdef __cplusplus
	30	extern "C" {
	31	#endif
	32
033cf439 KZ	33	#define BLKID_VERSION "@LIBBLKID_VERSION@"
	34	#define BLKID_DATE "@LIBBLKID_DATE@"
	35
488e52be KZ	36	/**
	37	* blkid_dev:
	38	*
	39	* The device object keeps information about one device
	40	*/
a0948ffe	41	typedef struct blkid_struct_dev *blkid_dev;
488e52be KZ	42
	43	/**
	44	* blkid_cache:
	45	*
	46	* information about all system devices
	47	*/
a0948ffe	48	typedef struct blkid_struct_cache *blkid_cache;
488e52be KZ	49
	50	/**
	51	* blkid_probe:
	52	*
	53	* low-level probing setting
	54	*/
51410fc6 KZ	55	typedef struct blkid_struct_probe *blkid_probe;
51410fc6 KZ	56
cc33d693 KZ	57	/**
	58	* blkid_topology:
	59	*
	60	* device topology information
	61	*/
	62	typedef struct blkid_struct_topology *blkid_topology;
	63
e4799a35 KZ	64	/**
	65	* blkid_partlist
	66	*
	67	* list of all detected partitions and partitions tables
	68	*/
	69	typedef struct blkid_struct_partlist *blkid_partlist;
	70
	71	/**
	72	* blkid_partition:
	73	*
	74	* information about a partition
	75	*/
	76	typedef struct blkid_struct_partition *blkid_partition;
	77
	78	/**
	79	* blkid_parttable:
	80	*
	81	* information about a partition table
	82	*/
	83	typedef struct blkid_struct_parttable *blkid_parttable;
	84
488e52be KZ	85	/**
	86	* blkid_loff_t:
	87	*
	88	* 64-bit signed number for offsets and sizes
	89	*/
e1ad8bb3	90	typedef int64_t blkid_loff_t;
a0948ffe	91
488e52be KZ	92	/**
	93	* blkid_tag_iterate:
	94	*
	95	* tags iterator for high-level (blkid_cache) API
	96	*/
a0948ffe	97	typedef struct blkid_struct_tag_iterate *blkid_tag_iterate;
488e52be KZ	98
	99	/**
	100	* blkid_dev_iterate:
	101	*
	102	* devices iterator for high-level (blkid_cache) API
	103	*/
a0948ffe KZ	104	typedef struct blkid_struct_dev_iterate *blkid_dev_iterate;
	105
	106	/*
	107	* Flags for blkid_get_dev
	108	*
	109	* BLKID_DEV_CREATE Create an empty device structure if not found
b227e3b7	110	* in the cache.
a0948ffe	111	* BLKID_DEV_VERIFY Make sure the device structure corresponds
b227e3b7	112	* with reality.
a0948ffe	113	* BLKID_DEV_FIND Just look up a device entry, and return NULL
b227e3b7	114	* if it is not found.
a0948ffe	115	* BLKID_DEV_NORMAL Get a valid device structure, either from the
b227e3b7	116	* cache or by probing the device.
a0948ffe KZ	117	*/
	118	#define BLKID_DEV_FIND 0x0000
	119	#define BLKID_DEV_CREATE 0x0001
	120	#define BLKID_DEV_VERIFY 0x0002
	121	#define BLKID_DEV_NORMAL (BLKID_DEV_CREATE \| BLKID_DEV_VERIFY)
	122
21eff114 OO	123
	124	#ifndef __GNUC_PREREQ
	125	# if defined __GNUC__ && defined __GNUC_MINOR__
	126	# define __GNUC_PREREQ(maj, min) ((__GNUC__ << 16) + __GNUC_MINOR__ >= ((maj) << 16) + (min))
	127	# else
	128	# define __GNUC_PREREQ(maj, min) 0
	129	# endif
	130	#endif
	131
	132	#ifndef __ul_attribute__
	133	# if __GNUC_PREREQ (3, 4)
	134	# define __ul_attribute__(_a_) __attribute__(_a_)
	135	# else
	136	# define __ul_attribute__(_a_)
	137	# endif
	138	#endif
	139
c54f54d6	140	/* init.c */
310f6728	141	extern void blkid_init_debug(int mask);
c54f54d6 JB	142
c54f54d6 JB	143	/* cache.c */
2e31fe23 KZ	144	extern void blkid_put_cache(blkid_cache cache);
	145	extern int blkid_get_cache(blkid_cache cache, const char filename);
	146	extern void blkid_gc_cache(blkid_cache cache);
a0948ffe KZ	147
a0948ffe KZ	148	/* dev.c */
21eff114	149	extern const char *blkid_dev_devname(blkid_dev dev)
21eff114	150	__ul_attribute__((warn_unused_result));
a0948ffe	151
2bb7a706	152	extern blkid_dev_iterate blkid_dev_iterate_begin(blkid_cache cache);
a0948ffe	153	extern int blkid_dev_set_search(blkid_dev_iterate iter,
f024c96c	154	const char search_type, const char search_value);
2e31fe23 KZ	155	extern int blkid_dev_next(blkid_dev_iterate iterate, blkid_dev *dev);
2e31fe23 KZ	156	extern void blkid_dev_iterate_end(blkid_dev_iterate iterate);
a0948ffe KZ	157
a0948ffe KZ	158	/* devno.c */
21eff114 OO	159	extern char *blkid_devno_to_devname(dev_t devno)
21eff114 OO	160	__ul_attribute__((warn_unused_result));
0d44d469	161	extern int blkid_devno_to_wholedisk(dev_t dev, char *diskname,
21eff114 OO	162	size_t len, dev_t *diskdevno)
21eff114 OO	163	__ul_attribute__((warn_unused_result));
a0948ffe KZ	164
a0948ffe KZ	165	/* devname.c */
2e31fe23 KZ	166	extern int blkid_probe_all(blkid_cache cache);
	167	extern int blkid_probe_all_new(blkid_cache cache);
	168	extern int blkid_probe_all_removable(blkid_cache cache);
	169
	170	extern blkid_dev blkid_get_dev(blkid_cache cache, const char *devname, int flags);
a0948ffe KZ	171
a0948ffe KZ	172	/* getsize.c */
2bb7a706	173	extern blkid_loff_t blkid_get_dev_size(int fd);
a0948ffe	174
51410fc6	175	/* verify.c */
2e31fe23	176	extern blkid_dev blkid_verify(blkid_cache cache, blkid_dev dev);
a0948ffe KZ	177
	178	/* read.c */
	179
	180	/* resolve.c */
	181	extern char blkid_get_tag_value(blkid_cache cache, const char tagname,
21eff114	182	const char *devname)
21eff114	183	__ul_attribute__((warn_unused_result));
a0948ffe	184	extern char blkid_get_devname(blkid_cache cache, const char token,
21eff114	185	const char *value)
21eff114	186	__ul_attribute__((warn_unused_result));
a0948ffe KZ	187
a0948ffe KZ	188	/* tag.c */
2bb7a706	189	extern blkid_tag_iterate blkid_tag_iterate_begin(blkid_dev dev);
a0948ffe	190	extern int blkid_tag_next(blkid_tag_iterate iterate,
2e31fe23 KZ	191	const char type, const char value);
2e31fe23 KZ	192	extern void blkid_tag_iterate_end(blkid_tag_iterate iterate);
2bb7a706	193	extern int blkid_dev_has_tag(blkid_dev dev, const char type, const char value);
2e31fe23	194
a0948ffe KZ	195	extern blkid_dev blkid_find_dev_with_tag(blkid_cache cache,
a0948ffe KZ	196	const char *type,
2bb7a706	197	const char *value);
2e31fe23 KZ	198
2e31fe23 KZ	199	extern int blkid_parse_tag_string(const char token, char ret_type, char *ret_val);
a0948ffe KZ	200
a0948ffe KZ	201	/* version.c */
21eff114	202	extern int blkid_parse_version_string(const char *ver_string)
2bb7a706	203	__ul_attribute__((nonnull));
a0948ffe	204	extern int blkid_get_library_version(const char **ver_string,
2e31fe23	205	const char **date_string);
a0948ffe	206
dd20a05a	207	/* encode.c */
2e31fe23 KZ	208	extern int blkid_encode_string(const char str, char str_enc, size_t len);
2e31fe23 KZ	209	extern int blkid_safe_string(const char str, char str_safe, size_t len);
51410fc6	210
892a404c	211	/* evaluate.c */
2e31fe23	212	extern int blkid_send_uevent(const char devname, const char action);
cee95a95	213	extern char blkid_evaluate_tag(const char token, const char *value,
21eff114	214	blkid_cache *cache)
21eff114 OO	215	__ul_attribute__((warn_unused_result));
21eff114 OO	216	extern char blkid_evaluate_spec(const char spec, blkid_cache *cache)
21eff114	217	__ul_attribute__((warn_unused_result));
892a404c	218
51410fc6	219	/* probe.c */
21eff114 OO	220	extern blkid_probe blkid_new_probe(void)
	221	__ul_attribute__((warn_unused_result));
	222	extern blkid_probe blkid_new_probe_from_filename(const char *filename)
7f787ced KZ	223	__ul_attribute__((warn_unused_result))
7f787ced KZ	224	__ul_attribute__((nonnull));
51410fc6	225	extern void blkid_free_probe(blkid_probe pr);
51410fc6	226
2e31fe23	227	extern void blkid_reset_probe(blkid_probe pr);
d2b0c658 KZ	228	extern int blkid_probe_reset_buffers(blkid_probe pr);
d2b0c658 KZ	229	extern int blkid_probe_hide_range(blkid_probe pr, uint64_t off, uint64_t len);
601fb1c1	230
21eff114	231	extern int blkid_probe_set_device(blkid_probe pr, int fd,
7f787ced KZ	232	blkid_loff_t off, blkid_loff_t size)
7f787ced KZ	233	__ul_attribute__((nonnull));
21eff114 OO	234
21eff114 OO	235	extern dev_t blkid_probe_get_devno(blkid_probe pr)
2bb7a706	236	__ul_attribute__((nonnull));
2e31fe23	237
21eff114	238	extern dev_t blkid_probe_get_wholedisk_devno(blkid_probe pr)
2bb7a706	239	__ul_attribute__((nonnull));
2e31fe23	240
21eff114	241	extern int blkid_probe_is_wholedisk(blkid_probe pr)
2bb7a706	242	__ul_attribute__((nonnull));
21eff114	243
7f787ced KZ	244	extern blkid_loff_t blkid_probe_get_size(blkid_probe pr)
	245	__ul_attribute__((nonnull));
	246	extern blkid_loff_t blkid_probe_get_offset(blkid_probe pr)
	247	__ul_attribute__((nonnull));
	248	extern unsigned int blkid_probe_get_sectorsize(blkid_probe pr)
	249	__ul_attribute__((nonnull));
76fab513 KZ	250	extern int blkid_probe_set_sectorsize(blkid_probe pr, unsigned int sz)
76fab513 KZ	251	__ul_attribute__((nonnull));
7f787ced KZ	252	extern blkid_loff_t blkid_probe_get_sectors(blkid_probe pr)
7f787ced KZ	253	__ul_attribute__((nonnull));
21eff114	254
7f787ced KZ	255	extern int blkid_probe_get_fd(blkid_probe pr)
7f787ced KZ	256	__ul_attribute__((nonnull));
56e961e2	257
67719fbb KZ	258	extern int blkid_probe_set_hint(blkid_probe pr, const char *name, uint64_t value)
67719fbb KZ	259	__ul_attribute__((nonnull));
248c239b KZ	260	extern void blkid_probe_reset_hints(blkid_probe pr)
248c239b KZ	261	__ul_attribute__((nonnull));
67719fbb	262
5657c25a KZ	263	/*
	264	* superblocks probing
	265	*/
7f787ced KZ	266	extern int blkid_known_fstype(const char *fstype)
7f787ced KZ	267	__ul_attribute__((nonnull));
21eff114	268
70db6c7e KZ	269	extern int blkid_superblocks_get_name(size_t idx, const char *name, int usage);
70db6c7e KZ	270
7f787ced KZ	271	extern int blkid_probe_enable_superblocks(blkid_probe pr, int enable)
7f787ced KZ	272	__ul_attribute__((nonnull));
b227e3b7	273
c9b2297e AA	274	#define BLKID_SUBLKS_LABEL (1 << 1) /* read LABEL from superblock */
	275	#define BLKID_SUBLKS_LABELRAW (1 << 2) /* read and define LABEL_RAW result value*/
	276	#define BLKID_SUBLKS_UUID (1 << 3) /* read UUID from superblock */
	277	#define BLKID_SUBLKS_UUIDRAW (1 << 4) /* read and define UUID_RAW result value */
	278	#define BLKID_SUBLKS_TYPE (1 << 5) /* define TYPE result value */
	279	#define BLKID_SUBLKS_SECTYPE (1 << 6) /* define compatible fs type (second type) */
	280	#define BLKID_SUBLKS_USAGE (1 << 7) /* define USAGE result value */
	281	#define BLKID_SUBLKS_VERSION (1 << 8) /* read FS type from superblock */
	282	#define BLKID_SUBLKS_MAGIC (1 << 9) /* define SBMAGIC and SBMAGIC_OFFSET */
	283	#define BLKID_SUBLKS_BADCSUM (1 << 10) /* allow a bad checksum */
	284	#define BLKID_SUBLKS_FSINFO (1 << 11) /* read and define fs properties from superblock */
5657c25a KZ	285
	286	#define BLKID_SUBLKS_DEFAULT (BLKID_SUBLKS_LABEL \| BLKID_SUBLKS_UUID \| \
	287	BLKID_SUBLKS_TYPE \| BLKID_SUBLKS_SECTYPE)
51410fc6	288
7f787ced KZ	289	extern int blkid_probe_set_superblocks_flags(blkid_probe pr, int flags)
	290	__ul_attribute__((nonnull));
	291	extern int blkid_probe_reset_superblocks_filter(blkid_probe pr)
	292	__ul_attribute__((nonnull));
	293	extern int blkid_probe_invert_superblocks_filter(blkid_probe pr)
	294	__ul_attribute__((nonnull));
b227e3b7	295
fd7c9e35 KZ	296	/**
	297	* BLKID_FLTR_NOTIN
	298	*/
b227e3b7	299	#define BLKID_FLTR_NOTIN 1
fd7c9e35 KZ	300	/**
	301	* BLKID_FLTR_ONLYIN
	302	*/
b227e3b7	303	#define BLKID_FLTR_ONLYIN 2
7f787ced KZ	304	extern int blkid_probe_filter_superblocks_type(blkid_probe pr, int flag, char *names[])
7f787ced KZ	305	__ul_attribute__((nonnull));
b227e3b7	306
51410fc6 KZ	307	#define BLKID_USAGE_FILESYSTEM (1 << 1)
	308	#define BLKID_USAGE_RAID (1 << 2)
	309	#define BLKID_USAGE_CRYPTO (1 << 3)
	310	#define BLKID_USAGE_OTHER (1 << 4)
7f787ced KZ	311	extern int blkid_probe_filter_superblocks_usage(blkid_probe pr, int flag, int usage)
7f787ced KZ	312	__ul_attribute__((nonnull));
51410fc6	313
cc33d693 KZ	314	/*
	315	* topology probing
	316	*/
7f787ced KZ	317	extern int blkid_probe_enable_topology(blkid_probe pr, int enable)
7f787ced KZ	318	__ul_attribute__((nonnull));
cc33d693 KZ	319
cc33d693 KZ	320	/* binary interface */
7f787ced KZ	321	extern blkid_topology blkid_probe_get_topology(blkid_probe pr)
7f787ced KZ	322	__ul_attribute__((nonnull));
21eff114 OO	323
21eff114 OO	324	extern unsigned long blkid_topology_get_alignment_offset(blkid_topology tp)
2bb7a706	325	__ul_attribute__((nonnull));
21eff114	326	extern unsigned long blkid_topology_get_minimum_io_size(blkid_topology tp)
2bb7a706	327	__ul_attribute__((nonnull));
21eff114	328	extern unsigned long blkid_topology_get_optimal_io_size(blkid_topology tp)
2bb7a706	329	__ul_attribute__((nonnull));
21eff114	330	extern unsigned long blkid_topology_get_logical_sector_size(blkid_topology tp)
2bb7a706	331	__ul_attribute__((nonnull));
21eff114	332	extern unsigned long blkid_topology_get_physical_sector_size(blkid_topology tp)
17c57e25 AI	333	__ul_attribute__((nonnull));
17c57e25 AI	334	extern unsigned long blkid_topology_get_dax(blkid_topology tp)
2bb7a706	335	__ul_attribute__((nonnull));
0cb7e078 TW	336	extern uint64_t blkid_topology_get_diskseq(blkid_topology tp)
0cb7e078 TW	337	__ul_attribute__((nonnull));
cc33d693	338
e4799a35 KZ	339	/*
	340	* partitions probing
	341	*/
2bb7a706	342	extern int blkid_known_pttype(const char *pttype);
635d9aa5	343	extern int blkid_partitions_get_name(const size_t idx, const char **name);
e4799a35	344
7f787ced KZ	345	extern int blkid_probe_enable_partitions(blkid_probe pr, int enable)
7f787ced KZ	346	__ul_attribute__((nonnull));
48805d56	347
7f787ced KZ	348	extern int blkid_probe_reset_partitions_filter(blkid_probe pr)
	349	__ul_attribute__((nonnull));
	350	extern int blkid_probe_invert_partitions_filter(blkid_probe pr)
	351	__ul_attribute__((nonnull));
	352	extern int blkid_probe_filter_partitions_type(blkid_probe pr, int flag, char *names[])
	353	__ul_attribute__((nonnull));
48805d56	354
e4799a35	355	/* partitions probing flags */
0c6dc615 KZ	356	#define BLKID_PARTS_FORCE_GPT (1 << 1)
0c6dc615 KZ	357	#define BLKID_PARTS_ENTRY_DETAILS (1 << 2)
3c83b3b2	358	#define BLKID_PARTS_MAGIC (1 << 3)
7f787ced KZ	359	extern int blkid_probe_set_partitions_flags(blkid_probe pr, int flags)
7f787ced KZ	360	__ul_attribute__((nonnull));
e4799a35 KZ	361
e4799a35 KZ	362	/* binary interface */
7f787ced KZ	363	extern blkid_partlist blkid_probe_get_partitions(blkid_probe pr)
7f787ced KZ	364	__ul_attribute__((nonnull));
21eff114	365
7f787ced KZ	366	extern int blkid_partlist_numof_partitions(blkid_partlist ls)
	367	__ul_attribute__((nonnull));
	368	extern blkid_parttable blkid_partlist_get_table(blkid_partlist ls)
	369	__ul_attribute__((nonnull));
	370	extern blkid_partition blkid_partlist_get_partition(blkid_partlist ls, int n)
	371	__ul_attribute__((nonnull));
	372	extern blkid_partition blkid_partlist_get_partition_by_partno(blkid_partlist ls, int n)
	373	__ul_attribute__((nonnull));
	374	extern blkid_partition blkid_partlist_devno_to_partition(blkid_partlist ls, dev_t devno)
	375	__ul_attribute__((nonnull));
	376	extern blkid_parttable blkid_partition_get_table(blkid_partition par)
	377	__ul_attribute__((nonnull));
2e31fe23	378
7f787ced KZ	379	extern const char *blkid_partition_get_name(blkid_partition par)
	380	__ul_attribute__((nonnull));
	381	extern const char *blkid_partition_get_uuid(blkid_partition par)
	382	__ul_attribute__((nonnull));
	383	extern int blkid_partition_get_partno(blkid_partition par)
	384	__ul_attribute__((nonnull));
	385	extern blkid_loff_t blkid_partition_get_start(blkid_partition par)
	386	__ul_attribute__((nonnull));
	387	extern blkid_loff_t blkid_partition_get_size(blkid_partition par)
	388	__ul_attribute__((nonnull));
2e31fe23	389
21eff114	390	extern int blkid_partition_get_type(blkid_partition par)
2bb7a706	391	__ul_attribute__((nonnull));
7f787ced KZ	392	extern const char *blkid_partition_get_type_string(blkid_partition par)
7f787ced KZ	393	__ul_attribute__((nonnull));
21eff114	394	extern unsigned long long blkid_partition_get_flags(blkid_partition par)
2bb7a706	395	__ul_attribute__((nonnull));
2e31fe23	396
21eff114	397	extern int blkid_partition_is_logical(blkid_partition par)
2bb7a706	398	__ul_attribute__((nonnull));
21eff114	399	extern int blkid_partition_is_extended(blkid_partition par)
2bb7a706	400	__ul_attribute__((nonnull));
21eff114	401	extern int blkid_partition_is_primary(blkid_partition par)
2bb7a706	402	__ul_attribute__((nonnull));
2e31fe23	403
7f787ced KZ	404	extern const char *blkid_parttable_get_type(blkid_parttable tab)
	405	__ul_attribute__((nonnull));
	406	extern const char *blkid_parttable_get_id(blkid_parttable tab)
	407	__ul_attribute__((nonnull));
	408	extern blkid_loff_t blkid_parttable_get_offset(blkid_parttable tab)
	409	__ul_attribute__((nonnull));
	410	extern blkid_partition blkid_parttable_get_parent(blkid_parttable tab)
	411	__ul_attribute__((nonnull));
e4799a35	412
b227e3b7 KZ	413	/*
	414	* NAME=value low-level interface
	415	*/
7f787ced KZ	416	extern int blkid_do_probe(blkid_probe pr)
	417	__ul_attribute__((nonnull));
	418	extern int blkid_do_safeprobe(blkid_probe pr)
	419	__ul_attribute__((nonnull));
	420	extern int blkid_do_fullprobe(blkid_probe pr)
	421	__ul_attribute__((nonnull));
21eff114	422
69b73820 KZ	423	/**
	424	* BLKID_PROBE_OK:
	425	*
	426	* probing return value; superblock (RAID, partiton table, ...) succesfully detected
	427	*/
	428	#define BLKID_PROBE_OK 0
	429	/**
	430	* BLKID_PROBE_NONE:
	431	*
	432	* probing return value; found nothing
	433	*/
	434	#define BLKID_PROBE_NONE 1
	435	/**
	436	* BLKID_PROBE_ERROR:
	437	*
	438	* probing return value; probing ends with en error (see errno for more details)
	439	*/
	440	#define BLKID_PROBE_ERROR -1
	441	/**
	442	* BLKID_PROBE_AMBIGUOUS:
	443	*
	444	* probing return value; more than one probing result, in this case, it's not
	445	* safe to use the device automaticaly and user intervention is recommended
	446	*/
	447	#define BLKID_PROBE_AMBIGUOUS -2
2bd739c9	448
7f787ced KZ	449	extern int blkid_probe_numof_values(blkid_probe pr)
7f787ced KZ	450	__ul_attribute__((nonnull));
51410fc6	451	extern int blkid_probe_get_value(blkid_probe pr, int num, const char **name,
7f787ced KZ	452	const char *data, size_t len)
7f787ced KZ	453	__ul_attribute__((nonnull(1)));
51410fc6	454	extern int blkid_probe_lookup_value(blkid_probe pr, const char *name,
7f787ced KZ	455	const char *data, size_t len)
7f787ced KZ	456	__ul_attribute__((nonnull(1, 2)));
21eff114	457	extern int blkid_probe_has_value(blkid_probe pr, const char *name)
2bb7a706	458	__ul_attribute__((nonnull));
7f787ced KZ	459	extern int blkid_do_wipe(blkid_probe pr, int dryrun)
	460	__ul_attribute__((nonnull));
	461	extern int blkid_probe_step_back(blkid_probe pr)
	462	__ul_attribute__((nonnull));
2b89be6c	463
fd7c9e35	464	/*
5657c25a KZ	465	* Deprecated functions/macros
5657c25a KZ	466	*/
fd7c9e35 KZ	467	#ifndef BLKID_DISABLE_DEPRECATED
fd7c9e35 KZ	468
5657c25a KZ	469	#define BLKID_PROBREQ_LABEL BLKID_SUBLKS_LABEL
	470	#define BLKID_PROBREQ_LABELRAW BLKID_SUBLKS_LABELRAW
	471	#define BLKID_PROBREQ_UUID BLKID_SUBLKS_UUID
	472	#define BLKID_PROBREQ_UUIDRAW BLKID_SUBLKS_UUIDRAW
	473	#define BLKID_PROBREQ_TYPE BLKID_SUBLKS_TYPE
	474	#define BLKID_PROBREQ_SECTYPE BLKID_SUBLKS_SECTYPE
	475	#define BLKID_PROBREQ_USAGE BLKID_SUBLKS_USAGE
	476	#define BLKID_PROBREQ_VERSION BLKID_SUBLKS_VERSION
	477
21eff114	478	extern int blkid_probe_set_request(blkid_probe pr, int flags)
21eff114 OO	479	__ul_attribute__((deprecated));
	480
	481	extern int blkid_probe_filter_usage(blkid_probe pr, int flag, int usage)
21eff114 OO	482	__ul_attribute__((deprecated));
	483
	484	extern int blkid_probe_filter_types(blkid_probe pr, int flag, char *names[])
21eff114 OO	485	__ul_attribute__((deprecated));
	486
	487	extern int blkid_probe_invert_filter(blkid_probe pr)
21eff114 OO	488	__ul_attribute__((deprecated));
	489
	490	extern int blkid_probe_reset_filter(blkid_probe pr)
21eff114	491	__ul_attribute__((deprecated));
5657c25a	492
fd7c9e35 KZ	493	#endif /* BLKID_DISABLE_DEPRECATED */
fd7c9e35 KZ	494
a0948ffe KZ	495	#ifdef __cplusplus
	496	}
	497	#endif
	498
	499	#endif /* _BLKID_BLKID_H */