linux-hotplug.vger.kernel.org archive mirror
 help / color / mirror / Atom feed
* [PATCH] udev callout for reading filesystem labels
@ 2004-04-29 21:04 Kay Sievers
  2004-04-30 13:35 ` Kevin P. Fleming
                   ` (11 more replies)
  0 siblings, 12 replies; 15+ messages in thread
From: Kay Sievers @ 2004-04-29 21:04 UTC (permalink / raw)
  To: linux-hotplug

[-- Attachment #1: Type: text/plain, Size: 549 bytes --]

Hi,
here is a small udev toy, which enables udev to name partitions by
its filesystem label or uuid's.

The following udev rule:

  KERNEL="sd*", PROGRAM="/sbin/udev_volume_id -M%M -m%m -u", SYMLINK="%c"

creates a symlink with the uuid read from the filesystem. If no label or
uuid is found the program exits with nonzero and the rule will fail.

ext2, ext3, reiserfs, xfs, jfs, vfat, msdos volume labels are supported,
ntfs and swap partitions can be recognized.

It's possible to compile with klibc and the static binary takes 13kb.

thanks,
Kay

[-- Attachment #2: 01-volumeid.patch --]
[-- Type: text/plain, Size: 18817 bytes --]

diff -Nru a/extras/volume_id/Makefile b/extras/volume_id/Makefile
--- /dev/null	Wed Dec 31 16:00:00 1969
+++ b/extras/volume_id/Makefile	Thu Apr 29 22:47:11 2004
@@ -0,0 +1,50 @@
+# Makefile for udev_volume_id
+#
+# Copyright (C) 2004 Kay Sievers <kay@vrfy.org>
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; version 2 of the License.
+#
+
+PROG = udev_volume_id
+
+all:	$(PROG)
+
+prefix =
+exec_prefix =	${prefix}
+etcdir =	${prefix}/etc
+sbindir =	${exec_prefix}/sbin
+usrbindir =	${exec_prefix}/usr/bin
+usrsbindir =	${exec_prefix}/usr/sbin
+mandir =	${prefix}/usr/share/man
+devddir =	${etcdir}/dev.d/default
+configdir =	${etcdir}/udev/
+initdir = 	${etcdir}/init.d/
+srcdir = .
+
+INSTALL = /usr/bin/install -c
+INSTALL_PROGRAM = ${INSTALL}
+INSTALL_DATA  = ${INSTALL} -m 644
+INSTALL_SCRIPT = ${INSTALL_PROGRAM}
+
+override CFLAGS+=-Wall -fno-builtin
+OBJS = volume_id.o udev_volume_id.o
+HEADERS = volume_id.h
+
+$(OBJS): $(HEADERS)
+
+$(PROG): $(OBJS) $(HEADERS)
+	$(LD) $(LDFLAGS) -o $(PROG) $(CRT0) $(OBJS) $(LIB_OBJS) $(ARCH_LIB_OBJS)
+
+clean:
+	rm -f $(PROG) $(OBJS)
+
+spotless: clean
+
+install: all
+	$(INSTALL_PROGRAM) $(PROG) $(DESTDIR)$(usrsbindir)/$(PROG)
+
+uninstall:
+	- rm $(DESTDIR)$(usrsbindir)/$(PROG)
+
diff -Nru a/extras/volume_id/udev_volume_id.c b/extras/volume_id/udev_volume_id.c
--- /dev/null	Wed Dec 31 16:00:00 1969
+++ b/extras/volume_id/udev_volume_id.c	Thu Apr 29 22:47:11 2004
@@ -0,0 +1,120 @@
+/*
+ * udev_volume_id - udev callout to read filesystem label and uuid
+ *
+ * Copyright (C) 2004 Kay Sievers <kay.sievers@vrfy.org>
+ *
+ *	sample udev rule for creation of a symlink with the filsystem uuid:
+ *	KERNEL="sd*", PROGRAM="/sbin/udev_volume_id -M%M -m%m -u", SYMLINK="%c"
+ *
+ *	This program is free software; you can redistribute it and/or modify it
+ *	under the terms of the GNU General Public License as published by the
+ *	Free Software Foundation version 2 of the License.
+ * 
+ *	This program 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
+ *	General Public License for more details.
+ * 
+ *	You should have received a copy of the GNU General Public License along
+ *	with this program; if not, write to the Free Software Foundation, Inc.,
+ *	675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+#include "volume_id.h"
+
+int main(int argc, char *argv[])
+{
+	struct volume_id *vid;
+	const char help[] = "usage: udev_volume_id -m<minor> -M<major> [-t|-l|-u]\n";
+	int major = -1;
+	int minor = -1;
+	char *tail;
+	static const char short_options[] = "M:m:htlu";
+	int option;
+	char print = '\0';
+	int rc;
+
+
+	while (1) {
+		option = getopt(argc, argv, short_options);
+		if (option == -1)
+			break;
+
+		switch (option) {
+		case 'M':
+			major = (int) strtoul(optarg, &tail, 10);
+			if (tail[0] != '\0') {
+				printf("invalid major\n");
+				exit(1);
+			}
+			break;
+		case 'm':
+			minor = (int) strtoul(optarg, &tail, 10);
+			if (tail[0] != '\0') {
+				printf("invalid minor\n");
+				exit(1);
+			}
+			break;
+		case 't':
+			print = 't';
+			break;
+		case 'l':
+			print = 'l';
+			break;
+		case 'u':
+			print = 'u';
+			break;
+		case 'h':
+		case '?':
+		default:
+			printf(help);
+			exit(1);
+		}
+	}
+
+	if (major == -1 || minor == -1) {
+		printf(help);
+		exit(1);
+	}
+
+	vid = volume_id_open_dev_t(makedev(major, minor));
+	if (vid == NULL) {
+		printf("error open volume\n");
+		exit(1);
+	}
+
+	rc = volume_id_probe(vid, ALL);
+	if (rc != 0) {
+		printf("error probing volume\n");
+		exit(1);
+	}
+
+	switch (print) {
+	case 't':
+		printf("%s\n", vid->fs_name);
+		break;
+	case 'l':
+		if (vid->label_string[0] == '\0')
+			exit(2);
+		printf("%s\n", vid->label_string);
+		break;
+	case 'u':
+		if (vid->uuid_string[0] == '\0')
+			exit(2);
+		printf("%s\n", vid->uuid_string);
+		break;
+	default:
+		printf("T:%s\n", vid->fs_name);
+		printf("L:%s\n", vid->label_string);
+		printf("U:%s\n", vid->uuid_string);
+	}
+
+	volume_id_close(vid);
+
+	exit(0);
+}
diff -Nru a/extras/volume_id/volume_id.c b/extras/volume_id/volume_id.c
--- /dev/null	Wed Dec 31 16:00:00 1969
+++ b/extras/volume_id/volume_id.c	Thu Apr 29 22:47:11 2004
@@ -0,0 +1,550 @@
+/*
+ * volume_id - reads filesystem label and uuid
+ *
+ * Copyright (C) 2004 Kay Sievers <kay.sievers@vrfy.org>
+ *
+ *	The superblock structs are taken from the libblkid living inside
+ *	the e2fsprogs. This is a simple straightforward implementation for
+ *	reading the label strings of only the most common filesystems.
+ *	If you need a full featured library with attribute caching, support for
+ *	much more partition/media types or non-root data access, you may have
+ *	a look at:
+ *		http://e2fsprogs.sourceforge.net.
+ *
+ *	This program is free software; you can redistribute it and/or modify it
+ *	under the terms of the GNU General Public License as published by the
+ *	Free Software Foundation version 2 of the License.
+ *
+ *	This program 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
+ *	General Public License for more details.
+ *
+ *	You should have received a copy of the GNU General Public License along
+ *	with this program; if not, write to the Free Software Foundation, Inc.,
+ *	675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+#include <errno.h>
+#include <ctype.h>
+#include <fcntl.h>
+#include <sys/stat.h>
+#include <asm/types.h>
+
+#include "volume_id.h"
+
+
+#define bswap32(x) (__u32)((((__u32)(x) & 0xff000000u) >> 24) | \
+			   (((__u32)(x) & 0x00ff0000u) >>  8) | \
+			   (((__u32)(x) & 0x0000ff00u) <<  8) | \
+			   (((__u32)(x) & 0x000000ffu) << 24))
+
+#if (__BYTE_ORDER == __LITTLE_ENDIAN) 
+#define cpu_to_le32(x) (x)
+#elif (__BYTE_ORDER == __BIG_ENDIAN)
+#define cpu_to_le32(x) bswap32(x)
+#endif
+
+#define VOLUME_ID_BUFFER_SIZE		0x11000 /* reiser offset is 64k */
+
+
+static void set_label(struct volume_id *id, char *buf, int count)
+{
+	int i;
+
+	memcpy(id->label, buf, count);
+
+	memcpy(id->label_string, buf, count);
+
+	/* remove trailing whitespace */
+	i = strlen(id->label_string);
+	while (i--) {
+		if (! isspace(id->label_string[i]))
+			break;
+	}
+	id->label_string[i+1] = '\0';
+}
+
+static void set_uuid(struct volume_id *id, unsigned char *buf, int count)
+{
+	int i;
+
+	memcpy(id->uuid, buf, count);
+
+	/* create string if uuid is set */
+	for (i = 0; i < count; i++) 
+		if (buf[i] != 0)
+			goto set;
+	return;
+
+set:
+	switch(count) {
+	case 4:
+		sprintf(id->uuid_string, "%02X%02X-%02X%02X",
+			buf[3], buf[2], buf[1], buf[0]);
+		break;
+	case 16:
+		sprintf(id->uuid_string,
+			"%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x",
+			buf[0], buf[1], buf[2], buf[3],
+			buf[4], buf[5],
+			buf[6], buf[7],
+			buf[8], buf[9],
+			buf[10], buf[11], buf[12], buf[13], buf[14],buf[15]);
+		break;
+	}
+}
+
+static int open_superblock(struct volume_id *id)
+{
+	/* get buffer to read the first block */
+	if (id->buf == NULL) {
+		id->buf = malloc(VOLUME_ID_BUFFER_SIZE);
+		if (id->buf == NULL)
+			return -1;
+	}
+
+	/* try to read the first 64k, but at least the first block */
+	memset(id->buf, 0x00, VOLUME_ID_BUFFER_SIZE);
+	lseek(id->fd, 0, SEEK_SET);
+	if (read(id->fd, id->buf, VOLUME_ID_BUFFER_SIZE) < 0x200)
+		return -1;
+
+	return 0;
+}
+
+static void close_superblock(struct volume_id *id)
+{
+	if (id->buf != NULL) {
+		free(id->buf);
+		id->buf = NULL;
+	}
+}
+
+#define EXT3_FEATURE_COMPAT_HAS_JOURNAL		0x00000004
+#define EXT3_FEATURE_INCOMPAT_JOURNAL_DEV	0x00000008
+#define EXT_SUPERBLOCK_OFFSET			0x400
+static int probe_ext(struct volume_id *id)
+{
+	struct ext2_super_block {
+		__u32		s_inodes_count;
+		__u32		s_blocks_count;
+		__u32		s_r_blocks_count;
+		__u32		s_free_blocks_count;
+		__u32		s_free_inodes_count;
+		__u32		s_first_data_block;
+		__u32		s_log_block_size;
+		__u32		s_dummy3[7];
+		unsigned char	s_magic[2];
+		__u16		s_state;
+		__u32		s_dummy5[8];
+		__u32		s_feature_compat;
+		__u32		s_feature_incompat;
+		__u32		s_feature_ro_compat;
+		unsigned char	s_uuid[16];
+		char		s_volume_name[16];
+	} *es;
+
+	es = (struct ext2_super_block *) (id->buf + EXT_SUPERBLOCK_OFFSET);
+
+	if (es->s_magic[0] != 0123 ||
+	    es->s_magic[1] != 0357)
+		return -1;
+
+	set_label(id, es->s_volume_name, 16);
+	set_uuid(id, es->s_uuid, 16);
+
+	if ((cpu_to_le32(es->s_feature_compat) & EXT3_FEATURE_COMPAT_HAS_JOURNAL) != 0) {
+		id->fs_type = EXT3;
+		id->fs_name = "ext3";
+	} else {
+		id->fs_type = EXT2;
+		id->fs_name = "ext2";
+	}
+
+	return 0;
+}
+
+#define REISER1_SUPERBLOCK_OFFSET		0x2000
+#define REISER_SUPERBLOCK_OFFSET		0x10000
+static int probe_reiser(struct volume_id *id)
+{
+	struct reiser_super_block {
+		__u32		rs_blocks_count;
+		__u32		rs_free_blocks;
+		__u32		rs_root_block;
+		__u32		rs_journal_block;
+		__u32		rs_journal_dev;
+		__u32		rs_orig_journal_size;
+		__u32		rs_dummy2[5];
+		__u16		rs_blocksize;
+		__u16		rs_dummy3[3];
+		unsigned char	rs_magic[12];
+		__u32		rs_dummy4[5];
+		unsigned char	rs_uuid[16];
+		char		rs_label[16];
+	} *rs;
+
+	rs = (struct reiser_super_block *) &(id->buf[REISER1_SUPERBLOCK_OFFSET]);
+
+	if (strncmp(rs->rs_magic, "ReIsErFs", 8) == 0)
+		goto found;
+
+	rs = (struct reiser_super_block *) &(id->buf[REISER_SUPERBLOCK_OFFSET]);
+
+	if (strncmp(rs->rs_magic, "ReIsEr2Fs", 9) == 0)
+		goto found;
+	if (strncmp(rs->rs_magic, "ReIsEr3Fs", 9) == 0)
+		goto found;
+
+	return -1;
+
+found:
+	set_label(id, rs->rs_label, 16);
+	set_uuid(id, rs->rs_uuid, 16);
+
+	id->fs_type = REISER;
+	id->fs_name = "reiser";
+
+	return 0;
+}
+
+static int probe_xfs(struct volume_id *id)
+{
+	struct xfs_super_block {
+		unsigned char	xs_magic[4];
+		__u32		xs_blocksize;
+		__u64		xs_dblocks;
+		__u64		xs_rblocks;
+		__u32		xs_dummy1[2];
+		unsigned char	xs_uuid[16];
+		__u32		xs_dummy2[15];
+		char		xs_fname[12];
+		__u32		xs_dummy3[2];
+		__u64		xs_icount;
+		__u64		xs_ifree;
+		__u64		xs_fdblocks;
+	} *xs;
+
+	xs = (struct xfs_super_block *) id->buf;
+
+	if (strncmp(xs->xs_magic, "XFSB", 4) != 0)
+		return -1;
+
+	set_label(id, xs->xs_fname, 12);
+	set_uuid(id, xs->xs_uuid, 16);
+
+	id->fs_type = XFS;
+	id->fs_name = "xfs";
+
+	return 0;
+}
+
+#define JFS_SUPERBLOCK_OFFSET			0x8000
+static int probe_jfs(struct volume_id *id)
+{
+	struct jfs_super_block {
+		unsigned char	js_magic[4];
+		__u32		js_version;
+		__u64		js_size;
+		__u32		js_bsize;
+		__u32		js_dummy1;
+		__u32		js_pbsize;
+		__u32		js_dummy2[27];
+		unsigned char	js_uuid[16];
+		unsigned char	js_label[16];
+		unsigned char	js_loguuid[16];
+	} *js;
+
+	js = (struct jfs_super_block *) &(id->buf[JFS_SUPERBLOCK_OFFSET]);
+
+	if (strncmp(js->js_magic, "JFS1", 4) != 0)
+		return -1;
+
+	set_label(id, js->js_label, 16);
+	set_uuid(id, js->js_uuid, 16);
+
+	id->fs_type = JFS;
+	id->fs_name = "jfs";
+
+	return 0;
+}
+
+static int probe_vfat(struct volume_id *id)
+{
+	struct vfat_super_block {
+		unsigned char	vs_ignored[3];
+		unsigned char	vs_sysid[8];
+		unsigned char	vs_sector_size[2];
+		__u8		vs_cluster_size;
+		__u16		vs_reserved;
+		__u8		vs_fats;
+		unsigned char	vs_dir_entries[2];
+		unsigned char	vs_sectors[2];
+		unsigned char	vs_media;
+		__u16		vs_fat_length;
+		__u16		vs_secs_track;
+		__u16		vs_heads;
+		__u32		vs_hidden;
+		__u32		vs_total_sect;
+		__u32		vs_fat32_length;
+		__u16		vs_flags;
+		__u8		vs_version[2];
+		__u32		vs_root_cluster;
+		__u16		vs_insfo_sector;
+		__u16		vs_backup_boot;
+		__u16		vs_reserved2[6];
+		unsigned char	vs_unknown[3];
+		unsigned char	vs_serno[4];
+		char		vs_label[11];
+		unsigned char	vs_magic[8];
+		unsigned char	vs_dummy2[164];
+		unsigned char	vs_pmagic[2];
+	} *vs;
+
+	vs = (struct vfat_super_block *) id->buf;
+
+	if (strncmp(vs->vs_magic, "MSWIN", 5) == 0)
+		goto found;
+	if (strncmp(vs->vs_magic, "FAT32   ", 8) == 0)
+		goto found;
+	return -1;
+
+found:
+	memcpy(id->label, vs->vs_label, 11);
+	memcpy(id->uuid, vs->vs_serno, 4);
+
+	id->fs_type = VFAT;
+	id->fs_name = "vfat";
+
+	return 0;
+}
+
+static int probe_msdos(struct volume_id *id)
+{
+	struct msdos_super_block {
+		unsigned char	ms_ignored[3];
+		unsigned char	ms_sysid[8];
+		unsigned char	ms_sector_size[2];
+		__u8		ms_cluster_size;
+		__u16		ms_reserved;
+		__u8		ms_fats;
+		unsigned char	ms_dir_entries[2];
+		unsigned char	ms_sectors[2];
+		unsigned char	ms_media;
+		__u16		ms_fat_length;
+		__u16		ms_secs_track;
+		__u16		ms_heads;
+		__u32		ms_hidden;
+		__u32		ms_total_sect;
+		unsigned char	ms_unknown[3];
+		unsigned char	ms_serno[4];
+		char		ms_label[11];
+		unsigned char	ms_magic[8];
+		unsigned char	ms_dummy2[192];
+		unsigned char	ms_pmagic[2];
+	} *ms;
+
+	ms = (struct msdos_super_block *) id->buf;
+
+	if (strncmp(ms->ms_magic, "MSDOS", 5) == 0)
+		goto found;
+	if (strncmp(ms->ms_magic, "FAT16   ", 8) == 0)
+		goto found;
+	if (strncmp(ms->ms_magic, "FAT12   ", 8) == 0)
+		goto found;
+	return -1;
+
+found:
+	set_label(id, ms->ms_label, 11);
+	set_uuid(id, ms->ms_serno, 4);
+
+	id->fs_type = MSDOS;
+	id->fs_name = "msdos";
+
+	return 0;
+}
+
+static int probe_ntfs(struct volume_id *id)
+{
+	struct ntfs_super_block {
+		char jump[3];
+		char oem_id[4];
+	} *ns;
+
+	ns = (struct ntfs_super_block *) id->buf;
+
+	if (strncmp(ns->oem_id, "NTFS", 4) != 0)
+		return -1;
+
+	id->fs_type = NTFS;
+	id->fs_name = "ntfs";
+
+	return 0;
+}
+
+static int probe_swap(struct volume_id *id)
+{
+	int magic;
+
+	/* huhh, the swap signature is on the end of the PAGE_SIZE */
+	for (magic = 0x1000; magic <= 0x4000; magic <<= 1) {
+			if (strncmp(&(id->buf[magic -10]), "SWAP-SPACE", 10) == 0)
+				goto found;
+			if (strncmp(&(id->buf[magic -10]), "SWAPSPACE2", 10) == 0)
+				goto found;
+	}
+	return -1;
+
+found:
+	id->fs_type = SWAP;
+	id->fs_name = "swap";
+
+	return 0;
+}
+
+/* probe volume for filesystem type and try to read label+uuid */
+int volume_id_probe(struct volume_id *id, enum filesystem_type fs_type)
+{
+	int rc;
+
+	if (id == NULL)
+		return -EINVAL;
+
+	if (open_superblock(id) != 0)
+		return -EACCES;
+
+	switch (fs_type) {
+	case EXT3:
+	case EXT2:
+		rc = probe_ext(id);
+		break;
+	case REISER:
+		rc = probe_reiser(id);
+		break;
+	case XFS:
+		rc = probe_xfs(id);
+		break;
+	case JFS:
+		rc = probe_jfs(id);
+		break;
+	case MSDOS:
+		rc = probe_msdos(id);
+		break;
+	case VFAT:
+		rc = probe_vfat(id);
+		break;
+	case NTFS:
+		rc = probe_ntfs(id);
+		break;
+	case SWAP:
+		rc = probe_swap(id);
+		break;
+	default:
+		rc = probe_ext(id);
+		if (rc == 0)
+			break;
+		rc = probe_reiser(id);
+		if (rc == 0)
+			break;
+		rc = probe_xfs(id);
+		if (rc == 0)
+			break;
+		rc = probe_jfs(id);
+		if (rc == 0)
+			break;
+		rc = probe_msdos(id);
+		if (rc == 0)
+			break;
+		rc = probe_vfat(id);
+		if (rc == 0)
+			break;
+		rc = probe_ntfs(id);
+		if (rc == 0)
+			break;
+		rc = probe_swap(id);
+		if (rc == 0)
+			break;
+		rc = -1;
+	}
+
+	if (rc == 0)
+		close_superblock(id);
+
+	return rc;
+}
+
+/* open volume by already open file descriptor */
+struct volume_id *volume_id_open_fd(int fd)
+{
+	struct volume_id *id;
+
+	id = malloc(sizeof(struct volume_id));
+	if (id == NULL)
+		return NULL;
+	memset(id, 0x00, sizeof(struct volume_id));
+
+	id->fd = fd;
+
+	return id;
+}
+
+/* open volume by device node */
+struct volume_id *volume_id_open_node(const char *path)
+{
+	struct volume_id *id;
+	int fd;
+
+	fd = open(path, O_RDONLY);
+	if (fd < 0)
+		return NULL;
+
+	id = volume_id_open_fd(fd);
+	if (id == NULL)
+		return NULL;
+
+	/* close fd on device close */
+	id->fd_close = 1;
+
+	return id;
+}
+
+/* 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];
+
+	snprintf(tmp_node, VOLUME_ID_PATH_MAX,
+		 "/tmp/volume-%u-%u", major(devt), minor(devt));
+	tmp_node[VOLUME_ID_PATH_MAX] = '\0';
+
+	/* create tempory node to open the block device */
+	if (mknod(tmp_node, (S_IFBLK | 0600), devt) != 0)
+		return NULL;
+
+	id = volume_id_open_node(tmp_node);
+
+	unlink(tmp_node);
+
+	return id;
+}
+
+/* free allocated volume info */
+void volume_id_close(struct volume_id *id)
+{
+	if (id == NULL)
+		return;
+
+	if (id->fd_close != 0)
+		close(id->fd);
+
+	close_superblock(id);
+
+	free(id);
+}
diff -Nru a/extras/volume_id/volume_id.h b/extras/volume_id/volume_id.h
--- /dev/null	Wed Dec 31 16:00:00 1969
+++ b/extras/volume_id/volume_id.h	Thu Apr 29 22:47:11 2004
@@ -0,0 +1,72 @@
+/*
+ * volume_id - reads partition label and uuid
+ *
+ * Copyright (C) 2004 Kay Sievers <kay.sievers@vrfy.org>
+ *
+ *	This program is free software; you can redistribute it and/or modify it
+ *	under the terms of the GNU General Public License as published by the
+ *	Free Software Foundation version 2 of the License.
+ * 
+ *	This program 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
+ *	General Public License for more details.
+ * 
+ *	You should have received a copy of the GNU General Public License along
+ *	with this program; if not, write to the Free Software Foundation, Inc.,
+ *	675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ */
+
+#ifndef _VOLUME_ID_H_
+#define _VOLUME_ID_H_
+
+#define VOLUME_ID_VERSION		001
+
+#define VOLUME_ID_LABEL_SIZE		16
+#define VOLUME_ID_UUID_SIZE		16
+#define VOLUME_ID_UUID_STRING_SIZE	37
+#define VOLUME_ID_PATH_MAX		255
+
+
+enum filesystem_type {
+	ALL,
+	EXT2,
+	EXT3,
+	REISER,
+	XFS,
+	JFS,
+	MSDOS,
+	VFAT,
+	NTFS,
+	SWAP
+};
+
+struct volume_id {
+	char label[VOLUME_ID_LABEL_SIZE];
+	char label_string[VOLUME_ID_LABEL_SIZE+1];
+	unsigned char uuid[VOLUME_ID_UUID_SIZE];
+	char uuid_string[VOLUME_ID_UUID_STRING_SIZE];
+	enum filesystem_type fs_type;
+	char *fs_name;
+	int fd;
+	char *buf;
+	int fd_close;
+};
+
+/* open volume by already open file descriptor */
+extern struct volume_id *volume_id_open_fd(int fd);
+
+/* open volume by device node */
+extern struct volume_id *volume_id_open_node(const char *path);
+
+/* open volume by major/minor */
+extern struct volume_id *volume_id_open_dev_t(dev_t devt);
+
+/* probe volume for filesystem type and try to read label/uuid */
+extern int volume_id_probe(struct volume_id *id, enum filesystem_type fs_type);
+
+/* free allocated device info */
+extern void volume_id_close(struct volume_id *id);
+
+#endif

^ permalink raw reply	[flat|nested] 15+ messages in thread
* Re: Re: [PATCH] udev callout for reading filesystem labels
@ 2004-05-06 22:44 Arnd Bergmann
  2004-05-07 22:54 ` Arnd Bergmann
  0 siblings, 1 reply; 15+ messages in thread
From: Arnd Bergmann @ 2004-05-06 22:44 UTC (permalink / raw)
  To: linux-hotplug

[-- Attachment #1: Type: text/plain, Size: 1285 bytes --]

Kay Sievers <kay.sievers@vrfy.org> schrieb am 06.05.2004, 22:18:41:
> On Thu, May 06, 2004 at 11:30:23AM +0200, Arnd Bergmann wrote:
> > On Thursday 29 April 2004 23:04, Kay Sievers wrote:
> 
> Sure, we can do this. How much code do we need, for the parsing?

The attachment contains the code from the linux kernel that does
the equivalent, somewhat adapted to user interfaces (but probably
not functional due to lack of sleep). I'll try to do a working
patch tomorrow.

What would you do to find out the disk minor when udev is
called for a partition of the disk? Is this handled by udev
already or do we need additional logic in the callout program?

> > This looks like a malicious user can easily prevent it from working
> > by creating files in /tmp. You might need to use something similar
> > to tmpfile(3) here.
> 
> Hmm, I really like to be able to compile with klibc and it doesn't
> support tmpfile(). What about simply unlinking it, before creating the node?

Well, I did not mean tmpfile itself, just something similar enough. 
Unlinking the file certainly avoids the security problem, but it
sounds a little rude. Are you sure there is no race when udev is
called multiple times for the same device node and we unlink before
the other udev opens the node?

     Arnd <><

[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #2: dasdlabel.c --]
[-- Type: text/x-csrc; name=dasdlabel.c, Size: 5615 bytes --]

static unsigned char EBCtoASC[256] =
{
/* 0x00  NUL   SOH   STX   ETX  *SEL    HT  *RNL   DEL */
	0x00, 0x01, 0x02, 0x03, 0x07, 0x09, 0x07, 0x7F,
/* 0x08  -GE  -SPS  -RPT    VT    FF    CR    SO    SI */
	0x07, 0x07, 0x07, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
/* 0x10  DLE   DC1   DC2   DC3  -RES   -NL    BS  -POC
                                -ENP  ->LF             */
	0x10, 0x11, 0x12, 0x13, 0x07, 0x0A, 0x08, 0x07,
/* 0x18  CAN    EM  -UBS  -CU1  -IFS  -IGS  -IRS  -ITB
                                                  -IUS */
	0x18, 0x19, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
/* 0x20  -DS  -SOS    FS  -WUS  -BYP    LF   ETB   ESC
                                -INP                   */
	0x07, 0x07, 0x1C, 0x07, 0x07, 0x0A, 0x17, 0x1B,
/* 0x28  -SA  -SFE   -SM  -CSP  -MFA   ENQ   ACK   BEL
                     -SW                               */ 
	0x07, 0x07, 0x07, 0x07, 0x07, 0x05, 0x06, 0x07,
/* 0x30 ----  ----   SYN   -IR   -PP  -TRN  -NBS   EOT */
	0x07, 0x07, 0x16, 0x07, 0x07, 0x07, 0x07, 0x04,
/* 0x38 -SBS   -IT  -RFF  -CU3   DC4   NAK  ----   SUB */
	0x07, 0x07, 0x07, 0x07, 0x14, 0x15, 0x07, 0x1A,
/* 0x40   SP   RSP           ä              ----       */
	0x20, 0xFF, 0x83, 0x84, 0x85, 0xA0, 0x07, 0x86,
/* 0x48                      .     <     (     +     | */
	0x87, 0xA4, 0x9B, 0x2E, 0x3C, 0x28, 0x2B, 0x7C,
/* 0x50    &                                      ---- */
	0x26, 0x82, 0x88, 0x89, 0x8A, 0xA1, 0x8C, 0x07,
/* 0x58          ß     !     $     *     )     ;       */
	0x8D, 0xE1, 0x21, 0x24, 0x2A, 0x29, 0x3B, 0xAA,
/* 0x60    -     /  ----     Ä  ----  ----  ----       */
	0x2D, 0x2F, 0x07, 0x8E, 0x07, 0x07, 0x07, 0x8F,
/* 0x68             ----     ,     %     _     >     ? */ 
	0x80, 0xA5, 0x07, 0x2C, 0x25, 0x5F, 0x3E, 0x3F,
/* 0x70  ---        ----  ----  ----  ----  ----  ---- */
	0x07, 0x90, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
/* 0x78    *     `     :     #     @     '     =     " */
	0x70, 0x60, 0x3A, 0x23, 0x40, 0x27, 0x3D, 0x22,
/* 0x80    *     a     b     c     d     e     f     g */
	0x07, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67,
/* 0x88    h     i              ----  ----  ----       */
	0x68, 0x69, 0xAE, 0xAF, 0x07, 0x07, 0x07, 0xF1,
/* 0x90    °     j     k     l     m     n     o     p */
	0xF8, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F, 0x70,
/* 0x98    q     r                    ----        ---- */
	0x71, 0x72, 0xA6, 0xA7, 0x91, 0x07, 0x92, 0x07,
/* 0xA0          ~     s     t     u     v     w     x */
	0xE6, 0x7E, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78,
/* 0xA8    y     z              ----  ----  ----  ---- */
	0x79, 0x7A, 0xAD, 0xAB, 0x07, 0x07, 0x07, 0x07,
/* 0xB0    ^                    ----     §  ----       */
	0x5E, 0x9C, 0x9D, 0xFA, 0x07, 0x07, 0x07, 0xAC,
/* 0xB8       ----     [     ]  ----  ----  ----  ---- */
	0xAB, 0x07, 0x5B, 0x5D, 0x07, 0x07, 0x07, 0x07,
/* 0xC0    {     A     B     C     D     E     F     G */
	0x7B, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
/* 0xC8    H     I  ----           ö              ---- */
	0x48, 0x49, 0x07, 0x93, 0x94, 0x95, 0xA2, 0x07,
/* 0xD0    }     J     K     L     M     N     O     P */
	0x7D, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F, 0x50,
/* 0xD8    Q     R  ----           ü                   */
	0x51, 0x52, 0x07, 0x96, 0x81, 0x97, 0xA3, 0x98,
/* 0xE0    \           S     T     U     V     W     X */
	0x5C, 0xF6, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58,
/* 0xE8    Y     Z        ----     Ö  ----  ----  ---- */
	0x59, 0x5A, 0xFD, 0x07, 0x99, 0x07, 0x07, 0x07,
/* 0xF0    0     1     2     3     4     5     6     7 */
	0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
/* 0xF8    8     9  ----  ----     Ü  ----  ----  ---- */
	0x38, 0x39, 0x07, 0x07, 0x9A, 0x07, 0x07, 0x07
};

void vtoc_ebcdic_dec (unsigned char *source, unsigned char *target, int l) 
{
        int i;

	for (i = 0; i < l; i++) 
	        target[i]=EBCtoASC[(unsigned char)(source[i])];
}

/* 
 * struct dasd_information_t
 * represents any data about the data, which is visible to userspace
 */
typedef struct dasd_information_t {
        unsigned int devno;         /* S/390 devno */
        unsigned int real_devno;    /* for aliases */
        unsigned int schid;         /* S/390 subchannel identifier */
        unsigned int cu_type  : 16; /* from SenseID */
        unsigned int cu_model :  8; /* from SenseID */
        unsigned int dev_type : 16; /* from SenseID */
        unsigned int dev_model : 8; /* from SenseID */
        unsigned int open_count; 
        unsigned int req_queue_len; 
        unsigned int chanq_len;     /* length of chanq */
        char type[4];               /* from discipline.name, 'none' for unknown */
        unsigned int status;        /* current device level */
        unsigned int label_block;   /* where to find the VOLSER */
        unsigned int FBA_layout;    /* fixed block size (like AIXVOL) */
        unsigned int characteristics_size;
        unsigned int confdata_size;
        char characteristics[64];   /* from read_device_characteristics */
        char configuration_data[256]; /* from read_configuration_data */
} dasd_information_t;


int ibm_partition(int fd, char *out)
{
	int blocksize;
	dasd_information_t info;
	char name[7] = {0,};
	unsigned char data[16];

	if (ioctl(fd, BIODASDINFO, (unsigned long)info) != 0)
		return errno;
	
	if (ioctl(fd, BLKSSZGET, (unsigned long)&blocksize))
		return errno;

	count = read(fd, &data, 16, info.label_block*blocksize);
	if (data == NULL)
		goto out_readerr;

	if ((!info.FBA_layout) && (!strcmp(info.type, "ECKD")))
		strncpy(name, data + 8, 6);
	else
		strncpy(name, data + 4, 6);

	vtoc_ebcdic_dec(name, out, 6);

	return 0;
}

^ permalink raw reply	[flat|nested] 15+ messages in thread
end of thread, other threads:[~2004-05-08 11:29 UTC | newest]

Thread overview: 15+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
2004-04-29 21:04 [PATCH] udev callout for reading filesystem labels Kay Sievers
2004-04-30 13:35 ` Kevin P. Fleming
2004-04-30 14:36 ` Oliver Neukum
2004-04-30 22:29 ` Greg KH
2004-05-05  1:14 ` Kay Sievers
2004-05-05 21:24 ` Greg KH
2004-05-06  9:30 ` Arnd Bergmann
2004-05-06 20:18 ` Kay Sievers
2004-05-06 22:59 ` Kay Sievers
2004-05-07 14:02 ` Kay Sievers
2004-05-07 18:25 ` Arnd Bergmann
2004-05-07 21:52 ` Kay Sievers
2004-05-08 11:29 ` Kay Sievers
  -- strict thread matches above, loose matches on Subject: below --
2004-05-06 22:44 Arnd Bergmann
2004-05-07 22:54 ` Arnd Bergmann

This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for NNTP newsgroup(s).