util-linux/volume_id/volume_id.c

/*
 * volume_id - reads filesystem label and uuid
 *
 * Copyright (C) 2005 Kay Sievers <kay.sievers@vrfy.org>
 *
 *	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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 */

#include "volume_id_internal.h"


/* Some detection routines do not set label or uuid anyway,
 * so they are disabled. */

/* Looks for partitions, we don't use it: */
#define ENABLE_FEATURE_VOLUMEID_MAC           0
/* #define ENABLE_FEATURE_VOLUMEID_MSDOS      0 - NB: this one
 * was not properly added to probe table anyway - ??! */

/* None of RAIDs have label or uuid, except LinuxRAID: */
#define ENABLE_FEATURE_VOLUMEID_HIGHPOINTRAID 0
#define ENABLE_FEATURE_VOLUMEID_ISWRAID       0
#define ENABLE_FEATURE_VOLUMEID_LSIRAID       0
#define ENABLE_FEATURE_VOLUMEID_LVM           0
#define ENABLE_FEATURE_VOLUMEID_NVIDIARAID    0
#define ENABLE_FEATURE_VOLUMEID_PROMISERAID   0
#define ENABLE_FEATURE_VOLUMEID_SILICONRAID   0
#define ENABLE_FEATURE_VOLUMEID_VIARAID       0

/* These filesystems also have no label or uuid: */
#define ENABLE_FEATURE_VOLUMEID_MINIX         0
#define ENABLE_FEATURE_VOLUMEID_HPFS          0
#define ENABLE_FEATURE_VOLUMEID_UFS           0


typedef int (*raid_probe_fptr)(struct volume_id *id, uint64_t off, uint64_t size);
typedef int (*probe_fptr)(struct volume_id *id, uint64_t off);

static const raid_probe_fptr raid1[] = {
#if ENABLE_FEATURE_VOLUMEID_LINUXRAID
	volume_id_probe_linux_raid,
#endif
#if ENABLE_FEATURE_VOLUMEID_ISWRAID
	volume_id_probe_intel_software_raid,
#endif
#if ENABLE_FEATURE_VOLUMEID_LSIRAID
	volume_id_probe_lsi_mega_raid,
#endif
#if ENABLE_FEATURE_VOLUMEID_VIARAID
	volume_id_probe_via_raid,
#endif
#if ENABLE_FEATURE_VOLUMEID_SILICONRAID
	volume_id_probe_silicon_medley_raid,
#endif
#if ENABLE_FEATURE_VOLUMEID_NVIDIARAID
	volume_id_probe_nvidia_raid,
#endif
#if ENABLE_FEATURE_VOLUMEID_PROMISERAID
	volume_id_probe_promise_fasttrack_raid,
#endif
#if ENABLE_FEATURE_VOLUMEID_HIGHPOINTRAID
	volume_id_probe_highpoint_45x_raid,
#endif
};

static const probe_fptr raid2[] = {
#if ENABLE_FEATURE_VOLUMEID_LVM
	volume_id_probe_lvm1,
	volume_id_probe_lvm2,
#endif
#if ENABLE_FEATURE_VOLUMEID_HIGHPOINTRAID
	volume_id_probe_highpoint_37x_raid,
#endif
#if ENABLE_FEATURE_VOLUMEID_LUKS
	volume_id_probe_luks,
#endif
};

/* signature in the first block, only small buffer needed */
static const probe_fptr fs1[] = {
#if ENABLE_FEATURE_VOLUMEID_FAT
	volume_id_probe_vfat,
#endif
#if ENABLE_FEATURE_VOLUMEID_MAC
	volume_id_probe_mac_partition_map,
#endif
#if ENABLE_FEATURE_VOLUMEID_XFS
	volume_id_probe_xfs,
#endif
};

/* fill buffer with maximum */
static const probe_fptr fs2[] = {
#if ENABLE_FEATURE_VOLUMEID_LINUXSWAP
	volume_id_probe_linux_swap,
#endif
#if ENABLE_FEATURE_VOLUMEID_EXT
	volume_id_probe_ext,
#endif
#if ENABLE_FEATURE_VOLUMEID_REISERFS
	volume_id_probe_reiserfs,
#endif
#if ENABLE_FEATURE_VOLUMEID_JFS
	volume_id_probe_jfs,
#endif
#if ENABLE_FEATURE_VOLUMEID_UDF
	volume_id_probe_udf,
#endif
#if ENABLE_FEATURE_VOLUMEID_ISO9660
	volume_id_probe_iso9660,
#endif
#if ENABLE_FEATURE_VOLUMEID_HFS
	volume_id_probe_hfs_hfsplus,
#endif
#if ENABLE_FEATURE_VOLUMEID_UFS
	volume_id_probe_ufs,
#endif
#if ENABLE_FEATURE_VOLUMEID_NTFS
	volume_id_probe_ntfs,
#endif
#if ENABLE_FEATURE_VOLUMEID_CRAMFS
	volume_id_probe_cramfs,
#endif
#if ENABLE_FEATURE_VOLUMEID_ROMFS
	volume_id_probe_romfs,
#endif
#if ENABLE_FEATURE_VOLUMEID_HPFS
	volume_id_probe_hpfs,
#endif
#if ENABLE_FEATURE_VOLUMEID_SYSV
	volume_id_probe_sysv,
#endif
#if ENABLE_FEATURE_VOLUMEID_MINIX
	volume_id_probe_minix,
#endif
#if ENABLE_FEATURE_VOLUMEID_OCFS2
	volume_id_probe_ocfs2,
#endif
};

int volume_id_probe_all(struct volume_id *id, uint64_t off, uint64_t size)
{
	unsigned i;

	if (id == NULL)
		return -EINVAL;

	/* probe for raid first, cause fs probes may be successful on raid members */
	if (size) {
		for (i = 0; i < ARRAY_SIZE(raid1); i++)
			if (raid1[i](id, off, size) == 0)
				goto ret;
	}

	for (i = 0; i < ARRAY_SIZE(raid2); i++)
		if (raid2[i](id, off) == 0)
			goto ret;

	/* signature in the first block, only small buffer needed */
	for (i = 0; i < ARRAY_SIZE(fs1); i++)
		if (fs1[i](id, off) == 0)
			goto ret;

	/* fill buffer with maximum */
	volume_id_get_buffer(id, 0, SB_BUFFER_SIZE);

	for (i = 0; i < ARRAY_SIZE(fs2); i++)
		if (fs2[i](id, off) == 0)
			goto ret;
	return -1;

 ret:
	/* If the filestystem in recognized, we free the allocated buffers,
	   otherwise they will stay in place for the possible next probe call */
	volume_id_free_buffer(id);

	return 0;
}

/* open volume by device node */
struct volume_id *volume_id_open_node(int fd)
{
	struct volume_id *id;

	id = xzalloc(sizeof(struct volume_id));
	id->fd = fd;
	///* close fd on device close */
	//id->fd_close = 1;
	return id;
}

#ifdef UNUSED
/* open volume by major/minor */
struct volume_id *volume_id_open_dev_t(dev_t devt)
{
	struct volume_id *id;
	char *tmp_node[VOLUME_ID_PATH_MAX];

	tmp_node = xasprintf("/dev/.volume_id-%u-%u-%u",
		(unsigned)getpid(), (unsigned)major(devt), (unsigned)minor(devt));

	/* create temporary node to open block device */
	unlink(tmp_node);
	if (mknod(tmp_node, (S_IFBLK | 0600), devt) != 0)
		bb_perror_msg_and_die("cannot mknod(%s)", tmp_node);

	id = volume_id_open_node(tmp_node);
	unlink(tmp_node);
	free(tmp_node);
	return id;
}
#endif

void free_volume_id(struct volume_id *id)
{
	if (id == NULL)
		return;

	//if (id->fd_close != 0) - always true
		close(id->fd);
	volume_id_free_buffer(id);
#ifdef UNUSED_PARTITION_CODE
	free(id->partitions);
#endif
	free(id);
}
1	niro	816	/*
2			* volume_id - reads filesystem label and uuid
3			*
4			* Copyright (C) 2005 Kay Sievers <kay.sievers@vrfy.org>
5			*
6			* This library is free software; you can redistribute it and/or
7			* modify it under the terms of the GNU Lesser General Public
8			* License as published by the Free Software Foundation; either
9			* version 2.1 of the License, or (at your option) any later version.
10			*
11			* This library is distributed in the hope that it will be useful,
12			* but WITHOUT ANY WARRANTY; without even the implied warranty of
13			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14			* Lesser General Public License for more details.
15			*
16			* You should have received a copy of the GNU Lesser General Public
17			* License along with this library; if not, write to the Free Software
18			* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19			*/
20
21			#include "volume_id_internal.h"
22
23
24			/* Some detection routines do not set label or uuid anyway,
25			* so they are disabled. */
26
27			/* Looks for partitions, we don't use it: */
28			#define ENABLE_FEATURE_VOLUMEID_MAC 0
29			/* #define ENABLE_FEATURE_VOLUMEID_MSDOS 0 - NB: this one
30			* was not properly added to probe table anyway - ??! */
31
32			/* None of RAIDs have label or uuid, except LinuxRAID: */
33			#define ENABLE_FEATURE_VOLUMEID_HIGHPOINTRAID 0
34			#define ENABLE_FEATURE_VOLUMEID_ISWRAID 0
35			#define ENABLE_FEATURE_VOLUMEID_LSIRAID 0
36			#define ENABLE_FEATURE_VOLUMEID_LVM 0
37			#define ENABLE_FEATURE_VOLUMEID_NVIDIARAID 0
38			#define ENABLE_FEATURE_VOLUMEID_PROMISERAID 0
39			#define ENABLE_FEATURE_VOLUMEID_SILICONRAID 0
40			#define ENABLE_FEATURE_VOLUMEID_VIARAID 0
41
42			/* These filesystems also have no label or uuid: */
43			#define ENABLE_FEATURE_VOLUMEID_MINIX 0
44			#define ENABLE_FEATURE_VOLUMEID_HPFS 0
45			#define ENABLE_FEATURE_VOLUMEID_UFS 0
46
47
48			typedef int (raid_probe_fptr)(struct volume_id id, uint64_t off, uint64_t size);
49			typedef int (probe_fptr)(struct volume_id id, uint64_t off);
50
51			static const raid_probe_fptr raid1[] = {
52			#if ENABLE_FEATURE_VOLUMEID_LINUXRAID
53			volume_id_probe_linux_raid,
54			#endif
55			#if ENABLE_FEATURE_VOLUMEID_ISWRAID
56			volume_id_probe_intel_software_raid,
57			#endif
58			#if ENABLE_FEATURE_VOLUMEID_LSIRAID
59			volume_id_probe_lsi_mega_raid,
60			#endif
61			#if ENABLE_FEATURE_VOLUMEID_VIARAID
62			volume_id_probe_via_raid,
63			#endif
64			#if ENABLE_FEATURE_VOLUMEID_SILICONRAID
65			volume_id_probe_silicon_medley_raid,
66			#endif
67			#if ENABLE_FEATURE_VOLUMEID_NVIDIARAID
68			volume_id_probe_nvidia_raid,
69			#endif
70			#if ENABLE_FEATURE_VOLUMEID_PROMISERAID
71			volume_id_probe_promise_fasttrack_raid,
72			#endif
73			#if ENABLE_FEATURE_VOLUMEID_HIGHPOINTRAID
74			volume_id_probe_highpoint_45x_raid,
75			#endif
76			};
77
78			static const probe_fptr raid2[] = {
79			#if ENABLE_FEATURE_VOLUMEID_LVM
80			volume_id_probe_lvm1,
81			volume_id_probe_lvm2,
82			#endif
83			#if ENABLE_FEATURE_VOLUMEID_HIGHPOINTRAID
84			volume_id_probe_highpoint_37x_raid,
85			#endif
86			#if ENABLE_FEATURE_VOLUMEID_LUKS
87			volume_id_probe_luks,
88			#endif
89			};
90
91			/* signature in the first block, only small buffer needed */
92			static const probe_fptr fs1[] = {
93			#if ENABLE_FEATURE_VOLUMEID_FAT
94			volume_id_probe_vfat,
95			#endif
96			#if ENABLE_FEATURE_VOLUMEID_MAC
97			volume_id_probe_mac_partition_map,
98			#endif
99			#if ENABLE_FEATURE_VOLUMEID_XFS
100			volume_id_probe_xfs,
101			#endif
102			};
103
104			/* fill buffer with maximum */
105			static const probe_fptr fs2[] = {
106			#if ENABLE_FEATURE_VOLUMEID_LINUXSWAP
107			volume_id_probe_linux_swap,
108			#endif
109			#if ENABLE_FEATURE_VOLUMEID_EXT
110			volume_id_probe_ext,
111			#endif
112			#if ENABLE_FEATURE_VOLUMEID_REISERFS
113			volume_id_probe_reiserfs,
114			#endif
115			#if ENABLE_FEATURE_VOLUMEID_JFS
116			volume_id_probe_jfs,
117			#endif
118			#if ENABLE_FEATURE_VOLUMEID_UDF
119			volume_id_probe_udf,
120			#endif
121			#if ENABLE_FEATURE_VOLUMEID_ISO9660
122			volume_id_probe_iso9660,
123			#endif
124			#if ENABLE_FEATURE_VOLUMEID_HFS
125			volume_id_probe_hfs_hfsplus,
126			#endif
127			#if ENABLE_FEATURE_VOLUMEID_UFS
128			volume_id_probe_ufs,
129			#endif
130			#if ENABLE_FEATURE_VOLUMEID_NTFS
131			volume_id_probe_ntfs,
132			#endif
133			#if ENABLE_FEATURE_VOLUMEID_CRAMFS
134			volume_id_probe_cramfs,
135			#endif
136			#if ENABLE_FEATURE_VOLUMEID_ROMFS
137			volume_id_probe_romfs,
138			#endif
139			#if ENABLE_FEATURE_VOLUMEID_HPFS
140			volume_id_probe_hpfs,
141			#endif
142			#if ENABLE_FEATURE_VOLUMEID_SYSV
143			volume_id_probe_sysv,
144			#endif
145			#if ENABLE_FEATURE_VOLUMEID_MINIX
146			volume_id_probe_minix,
147			#endif
148			#if ENABLE_FEATURE_VOLUMEID_OCFS2
149			volume_id_probe_ocfs2,
150			#endif
151			};
152
153			int volume_id_probe_all(struct volume_id *id, uint64_t off, uint64_t size)
154			{
155			unsigned i;
156
157			if (id == NULL)
158			return -EINVAL;
159
160			/* probe for raid first, cause fs probes may be successful on raid members */
161			if (size) {
162			for (i = 0; i < ARRAY_SIZE(raid1); i++)
163			if (raid1[i](id, off, size) == 0)
164			goto ret;
165			}
166
167			for (i = 0; i < ARRAY_SIZE(raid2); i++)
168			if (raid2[i](id, off) == 0)
169			goto ret;
170
171			/* signature in the first block, only small buffer needed */
172			for (i = 0; i < ARRAY_SIZE(fs1); i++)
173			if (fs1[i](id, off) == 0)
174			goto ret;
175
176			/* fill buffer with maximum */
177			volume_id_get_buffer(id, 0, SB_BUFFER_SIZE);
178
179			for (i = 0; i < ARRAY_SIZE(fs2); i++)
180			if (fs2[i](id, off) == 0)
181			goto ret;
182			return -1;
183
184			ret:
185			/* If the filestystem in recognized, we free the allocated buffers,
186			otherwise they will stay in place for the possible next probe call */
187			volume_id_free_buffer(id);
188
189			return 0;
190			}
191
192			/* open volume by device node */
193			struct volume_id *volume_id_open_node(int fd)
194			{
195			struct volume_id *id;
196
197			id = xzalloc(sizeof(struct volume_id));
198			id->fd = fd;
199			///* close fd on device close */
200			//id->fd_close = 1;
201			return id;
202			}
203
204			#ifdef UNUSED
205			/* open volume by major/minor */
206			struct volume_id *volume_id_open_dev_t(dev_t devt)
207			{
208			struct volume_id *id;
209			char *tmp_node[VOLUME_ID_PATH_MAX];
210
211			tmp_node = xasprintf("/dev/.volume_id-%u-%u-%u",
212			(unsigned)getpid(), (unsigned)major(devt), (unsigned)minor(devt));
213
214			/* create temporary node to open block device */
215			unlink(tmp_node);
216			if (mknod(tmp_node, (S_IFBLK \| 0600), devt) != 0)
217			bb_perror_msg_and_die("cannot mknod(%s)", tmp_node);
218
219			id = volume_id_open_node(tmp_node);
220			unlink(tmp_node);
221			free(tmp_node);
222			return id;
223			}
224			#endif
225
226			void free_volume_id(struct volume_id *id)
227			{
228			if (id == NULL)
229			return;
230
231			//if (id->fd_close != 0) - always true
232			close(id->fd);
233			volume_id_free_buffer(id);
234			#ifdef UNUSED_PARTITION_CODE
235			free(id->partitions);
236			#endif
237			free(id);
238			}