Convert mke2fs, fsck, and tune2fs to use the blkid library.
PROG_SUBDIRS=e2fsck $(DEBUGFS_DIR) misc $(RESIZE_DIR) tests/progs $(EVMS_DIR)
SUBDIRS=util $(LIB_SUBDIRS) $(PROG_SUBDIRS) tests
-SUBS= lib/ext2fs/ext2_types.h
+SUBS= lib/ext2fs/ext2_types.h lib/blkid/blkid_types.h
TAR=tar
$(SUBSTITUTE) $(srcdir)/lib/ext2fs/ext2_types.h.in \
> lib/ext2fs/ext2_types.h
+lib/blkid/blkid_types.h: $(DEP_SUBSTITUTE) $(srcdir)/lib/blkid/blkid_types.h.in
+ $(SUBSTITUTE) $(srcdir)/lib/blkid/blkid_types.h.in \
+ > lib/blkid/blkid_types.h
+
mostlyclean-local:
$(RM) -f \#* *~ *.orig core MAKELOG
+2003-03-01 Theodore Ts'o <tytso@mit.edu>
+
+ * resolve.c (blkid_get_tag_value): If the passed-in cache is NULL,
+ then get and release a temporary cache as a convenience to
+ the calling application.
+ (blkid_get_devname): If the passed in token does not
+ contain an '=', and value is NULL, then return the passed
+ in token.
+
+ * read.c (blkid_read_cache): Don't return 0 since blkid_read_cache
+ now returns void.
+
+ * blkid.h: Add include of sys/types.h, since we use dev_t
+
2003-02-27 Theodore Ts'o <tytso@mit.edu>
* resolve.c (blkid_get_tag_value): Rename function (used to be
#ifndef _BLKID_BLKID_H
#define _BLKID_BLKID_H
+#include <sys/types.h>
#include <blkid/blkid_types.h>
#ifdef __cplusplus
* struct so that the cache can be populated.
*/
if ((fd = open(cache->bic_filename, O_RDONLY)) < 0)
- return 0;
+ return;
if (fstat(fd, &st) < 0)
goto errout;
if ((st.st_mtime == cache->bic_ftime) ||
cache->bic_flags &= ~BLKID_BIC_FL_CHANGED;
cache->bic_ftime = st.st_mtime;
- return 0;
+ return;
errout:
close(fd);
return;
{
blkid_tag found;
blkid_dev dev;
+ blkid_cache c = cache;
char *ret = NULL;
DBG(DEBUG_RESOLVE, printf("looking for %s on %s\n", tagname, devname));
if (!devname)
return NULL;
- if ((dev = blkid_get_dev(cache, devname, BLKID_DEV_NORMAL)) &&
+ if (!cache) {
+ if (blkid_get_cache(&c, NULL) < 0)
+ return NULL;
+ }
+
+ if ((dev = blkid_get_dev(c, devname, BLKID_DEV_NORMAL)) &&
(found = blkid_find_tag_dev(dev, tagname)))
ret = blkid_strdup(found->bit_val);
if (!cache)
- blkid_free_dev(dev);
+ blkid_put_cache(c);
return ret;
}
if (!token)
return NULL;
- DBG(DEBUG_RESOLVE,
- printf("looking for %s%c%s %s\n", token, value ? '=' : ' ',
- value ? value : "", cache ? "in cache" : "from disk"));
-
if (!cache) {
if (blkid_get_cache(&c, NULL) < 0)
return NULL;
}
+ DBG(DEBUG_RESOLVE,
+ printf("looking for %s%s%s %s\n", token, value ? "=" : "",
+ value ? value : "", cache ? "in cache" : "from disk"));
+
if (!value) {
+ if (!strchr(token, '='))
+ return blkid_strdup(token);
blkid_parse_tag_string(token, &t, &v);
if (!t || !v)
goto errout;
+2003-03-01 Theodore Ts'o <tytso@mit.edu>
+
+ * fsck.c, util.c, tune2fs.c, Makefile.in: Use the blkid library
+ instead of the specialized functions in
+ get-device-by-label.c and fstype.c.
+
+ * base_device.c (base_device): Take a const char* as an argument.
+
+ * blkid.c: Remove deprecated -d option,
+
2003-02-16 Theodore Ts'o <tytso@mit.edu>
* blkid.c: Update to reflect renaming of blkid_get_devname() to
UPROGS= chattr lsattr uuidgen
UMANPAGES= chattr.1 lsattr.1 uuidgen.1
-TUNE2FS_OBJS= tune2fs.o util.o get_device_by_label.o
+TUNE2FS_OBJS= tune2fs.o util.o
MKLPF_OBJS= mklost+found.o
-MKE2FS_OBJS= mke2fs.o util.o get_device_by_label.o
+MKE2FS_OBJS= mke2fs.o util.o
CHATTR_OBJS= chattr.o
LSATTR_OBJS= lsattr.o
UUIDGEN_OBJS= uuidgen.o
DUMPE2FS_OBJS= dumpe2fs.o
BADBLOCKS_OBJS= badblocks.o
E2IMAGE_OBJS= e2image.o
-FSCK_OBJS= fsck.o get_device_by_label.o base_device.o fstype.o
+FSCK_OBJS= fsck.o base_device.o
BLKID_OBJS= blkid.o
SRCS= $(srcdir)/tune2fs.c $(srcdir)/mklost+found.c $(srcdir)/mke2fs.c \
$(srcdir)/chattr.c $(srcdir)/lsattr.c $(srcdir)/dumpe2fs.c \
$(srcdir)/badblocks.c $(srcdir)/fsck.c $(srcdir)/util.c \
- $(srcdir)/uuidgen.c $(srcdir)/fstype.c $(srcdir)/blkid.c
+ $(srcdir)/uuidgen.c $(srcdir)/blkid.c
LIBS= $(LIBEXT2FS) $(LIBCOM_ERR)
DEPLIBS= $(LIBEXT2FS) $(LIBCOM_ERR)
findsuper: findsuper.o
$(CC) $(ALL_LDFLAGS) -o findsuper findsuper.o
-tune2fs: $(TUNE2FS_OBJS) $(DEPLIBS_E2P) $(DEPLIBUUID)
- $(CC) $(ALL_LDFLAGS) -o tune2fs $(TUNE2FS_OBJS) $(LIBS_E2P) $(LIBUUID)
+tune2fs: $(TUNE2FS_OBJS) $(DEPLIBS_E2P) $(DEPLIBUUID) $(DEPLIBS_BLKID)
+ $(CC) $(ALL_LDFLAGS) -o tune2fs $(TUNE2FS_OBJS) $(LIBS_BLKID) \
+ $(LIBS_E2P) $(LIBUUID)
blkid: $(BLKID_OBJS) $(DEPLIBS_E2P) $(DEPLIBS_BLKID)
$(CC) $(ALL_LDFLAGS) -o blkid $(BLKID_OBJS) $(LIBS_E2P) $(LIBS_BLKID)
$(CC) $(ALL_CFLAGS) $(ALL_LDFLAGS) $(srcdir)/base_device.c \
-DDEBUG -o base_device
-fstype: fstype.c
- $(CC) $(ALL_CFLAGS) $(ALL_LDFLAGS) -DTEST_PROGRAM $(srcdir)/fstype.c \
- get_device_by_label.o $(LIBUUID) $(LIBS) -o fstype
-
check:: base_device
./base_device < $(srcdir)/base_device.tst > base_device.out
cmp $(srcdir)/base_device.tst base_device.out
mklost+found: $(MKLPF_OBJS)
$(CC) $(ALL_LDFLAGS) -o mklost+found $(MKLPF_OBJS)
-mke2fs: $(MKE2FS_OBJS) $(DEPLIBS) $(LIBE2P) $(DEPLIBUUID)
- $(CC) $(ALL_LDFLAGS) -o mke2fs $(MKE2FS_OBJS) $(LIBS) $(LIBE2P) $(LIBUUID)
+mke2fs: $(MKE2FS_OBJS) $(DEPLIBS) $(LIBE2P) $(DEPLIBUUID) $(DEPLIBS_BLKID)
+ $(CC) $(ALL_LDFLAGS) -o mke2fs $(MKE2FS_OBJS) $(LIBS) $(LIBS_BLKID) \
+ $(LIBE2P) $(LIBUUID)
mke2fs.static: $(MKE2FS_OBJS) $(STATIC_DEPLIBS) $(STATIC_LIBE2P) $(DEPSTATIC_LIBUUID)
$(CC) $(ALL_LDFLAGS) -static -o mke2fs.static $(MKE2FS_OBJS) \
dumpe2fs: $(DUMPE2FS_OBJS) $(DEPLIBS_E2P) $(DEPLIBUUID)
$(CC) $(ALL_LDFLAGS) -o dumpe2fs $(DUMPE2FS_OBJS) $(LIBS_E2P) $(LIBUUID)
-fsck: $(FSCK_OBJS)
- $(CC) $(ALL_LDFLAGS) -o fsck $(FSCK_OBJS) $(LIBS)
+fsck: $(FSCK_OBJS) $(DEBLIBS_BLKID)
+ $(CC) $(ALL_LDFLAGS) -o fsck $(FSCK_OBJS) $(LIBS) $(LIBS_BLKID)
badblocks: $(BADBLOCKS_OBJS) $(DEPLIBS)
$(CC) $(ALL_LDFLAGS) -o badblocks $(BADBLOCKS_OBJS) $(LIBS)
$(top_srcdir)/lib/uuid/uuid.h $(top_srcdir)/lib/e2p/e2p.h \
$(srcdir)/jfs_user.h $(top_srcdir)/lib/ext2fs/kernel-jbd.h \
$(top_srcdir)/lib/ext2fs/jfs_compat.h $(top_srcdir)/lib/ext2fs/kernel-list.h \
- $(srcdir)/util.h $(srcdir)/get_device_by_label.h $(top_srcdir)/version.h \
+ $(srcdir)/util.h $(top_srcdir)/lib/blkid/blkid.h \
+ $(top_builddir)/lib/blkid/blkid_types.h $(top_srcdir)/version.h \
$(srcdir)/nls-enable.h
mklost+found.o: $(srcdir)/mklost+found.c $(top_srcdir)/lib/ext2fs/ext2_fs.h \
$(top_builddir)/lib/ext2fs/ext2_types.h $(top_srcdir)/version.h \
$(top_builddir)/lib/ext2fs/ext2_err.h $(top_srcdir)/lib/ext2fs/bitops.h \
$(srcdir)/nls-enable.h
fsck.o: $(srcdir)/fsck.c $(top_srcdir)/version.h $(srcdir)/nls-enable.h \
- $(srcdir)/fsck.h $(srcdir)/get_device_by_label.h
+ $(srcdir)/fsck.h $(top_srcdir)/lib/blkid/blkid.h \
+ $(top_builddir)/lib/blkid/blkid_types.h
util.o: $(srcdir)/util.c $(top_srcdir)/lib/et/com_err.h \
$(top_srcdir)/lib/e2p/e2p.h $(top_srcdir)/lib/ext2fs/ext2_fs.h \
$(top_builddir)/lib/ext2fs/ext2_types.h $(top_srcdir)/lib/ext2fs/ext2fs.h \
$(top_srcdir)/lib/ext2fs/ext2_io.h $(top_builddir)/lib/ext2fs/ext2_err.h \
$(top_srcdir)/lib/ext2fs/bitops.h $(srcdir)/nls-enable.h \
- $(srcdir)/get_device_by_label.h $(srcdir)/util.h
+ $(top_srcdir)/lib/blkid/blkid.h $(top_builddir)/lib/blkid/blkid_types.h \
+ $(srcdir)/util.h
uuidgen.o: $(srcdir)/uuidgen.c $(top_srcdir)/lib/uuid/uuid.h \
$(srcdir)/nls-enable.h
-fstype.o: $(srcdir)/fstype.c $(srcdir)/fsck.h
+blkid.o: $(srcdir)/blkid.c $(top_srcdir)/lib/blkid/blkid.h \
+ $(top_builddir)/lib/blkid/blkid_types.h
"host", "bus", "target", "lun", 0
};
-char *base_device(char *device)
+char *base_device(const char *device)
{
char *str, *cp;
const char **hier, *disk;
{
blkid_tag_iterate iter;
const char *type, *value;
- int i, first = 1, printed_type = 0;
+ int i, first = 1;
if (!dev)
return;
int i;
char c;
- while ((c = getopt (argc, argv, "c:d:f:hps:t:w:v")) != EOF)
+ while ((c = getopt (argc, argv, "c:f:hps:t:w:v")) != EOF)
switch (c) {
- case 'd': /* deprecated */
- if (numdev >= sizeof(devices) / sizeof(*devices)) {
- fprintf(stderr,
- "Too many devices specified\n");
- usage(err);
- }
- devices[numdev++] = optarg;
- break;
case 'c':
if (optarg && !*optarg)
read = NULL;
#include "../version.h"
#include "nls-enable.h"
#include "fsck.h"
-#include "get_device_by_label.h"
+#include "blkid/blkid.h"
#ifndef _PATH_MNTTAB
#define _PATH_MNTTAB "/etc/fstab"
int kill_sent = 0;
char *progname;
char *fstype = NULL;
-struct fs_info *filesys_info;
+struct fs_info *filesys_info = NULL, *filesys_last = NULL;
struct fsck_instance *instance_list;
const char *fsck_prefix_path = "/sbin:/sbin/fs.d:/sbin/fs:/etc/fs:/etc";
char *fsck_path = 0;
+blkid_cache cache = NULL;
+
+static char *string_copy(const char *s)
+{
+ char *ret;
+
+ if (!s)
+ return 0;
+ ret = malloc(strlen(s)+1);
+ if (ret)
+ strcpy(ret, s);
+ return ret;
+}
+
static int ignore(struct fs_info *);
static char *skip_over_blank(char *cp)
char *p, *q;
int ac, i;
+ if (!word)
+ return;
+
for (p = word, q = word; *p; p++, q++) {
*q = *p;
if (*p != '\\')
return;
}
+static struct fs_info *create_fs_device(char *device, char *mntpnt,
+ char *type, char *opts, int freq,
+ int passno)
+{
+ struct fs_info *fs;
+
+ if (!(fs = malloc(sizeof(struct fs_info))))
+ return NULL;
+
+ fs->device = string_copy(device);
+ fs->mountpt = string_copy(mntpnt);
+ fs->type = string_copy(type);
+ fs->opts = string_copy(opts ? opts : "");
+ fs->freq = freq;
+ fs->passno = passno;
+ fs->flags = 0;
+ fs->next = NULL;
+
+ if (!filesys_info)
+ filesys_info = fs;
+ else
+ filesys_last->next = fs;
+ filesys_last = fs;
+
+ return fs;
+}
+
+
+
static int parse_fstab_line(char *line, struct fs_info **ret_fs)
{
- char *device, *mntpnt, *type, *opts, *freq, *passno, *cp;
+ char *dev, *device, *mntpnt, *type, *opts, *freq, *passno, *cp;
+ char *t = NULL;
struct fs_info *fs;
*ret_fs = 0;
freq = parse_word(&cp);
passno = parse_word(&cp);
+ if (!device)
+ return 0; /* Allow blank lines */
+
+ if (!mntpnt || !type)
+ return -1;
+
parse_escape(device);
parse_escape(mntpnt);
parse_escape(type);
parse_escape(freq);
parse_escape(passno);
- if (!device)
- return 0; /* Allow blank lines */
-
- if (!mntpnt || !type)
- return -1;
+ dev = blkid_get_devname(cache, device, NULL);
+ if (dev)
+ device = dev;
- if (!(fs = malloc(sizeof(struct fs_info))))
+ if (strcmp(type, "auto") == 0 || (strchr(type, ',') != 0))
+ t = blkid_get_tag_value(cache, "TYPE", device);
+ if (t)
+ type = t;
+
+ fs = create_fs_device(device, mntpnt, type, opts,
+ freq ? atoi(freq) : -1,
+ passno ? atoi(passno) : -1);
+ if (dev)
+ free(dev);
+ if (t)
+ free(t);
+
+ if (!fs)
return -1;
-
- fs->device = string_copy(device);
- fs->mountpt = string_copy(mntpnt);
- fs->type = string_copy(type);
- fs->opts = string_copy(opts ? opts : "");
- fs->freq = freq ? atoi(freq) : -1;
- fs->passno = passno ? atoi(passno) : -1;
- fs->flags = 0;
- fs->next = NULL;
-
*ret_fs = fs;
-
return 0;
}
-/*
- * Interpret the device name if necessary
- */
-static char *interpret_device(char *spec)
-{
- char *dev = interpret_spec(spec);
-
- if (dev)
- return dev;
-
- /*
- * Check to see if this was because /proc/partitions isn't
- * found.
- */
- if (access("/proc/partitions", R_OK) < 0) {
- fprintf(stderr, "Couldn't open /proc/partitions: %s\n",
- strerror(errno));
- fprintf(stderr, "Is /proc mounted?\n");
- exit(EXIT_ERROR);
- }
- /*
- * Check to see if this is because we're not running as root
- */
- if (geteuid())
- fprintf(stderr,
- "Must be root to scan for matching filesystems: %s\n",
- spec);
- else
- fprintf(stderr, "Couldn't find matching filesystem: %s\n",
- spec);
- exit(EXIT_ERROR);
-}
-
-/*
- * Interpret filesystem auto type if necessary
- */
-static void interpret_type(struct fs_info *fs)
-{
- const char *type;
-
- if (strcmp(fs->type, "auto") == 0 ||
- (strchr(fs->type, ',') != 0)) {
- if (fs && strchr(fs->device, '='))
- fs->device = interpret_device(fs->device);
- type = identify_fs(fs->device, fs->type);
- if (type) {
- free(fs->type);
- fs->type = string_copy(type);
- } else
- fprintf(stderr, _("Could not determine "
- "filesystem type for %s\n"),
- fs->device);
- }
-}
-
-
/*
* Load the filesystem database from /etc/fstab
*/
char buf[1024];
int lineno = 0;
int old_fstab = 1;
- struct fs_info *fs, *fs_last = NULL;
+ struct fs_info *fs;
- filesys_info = NULL;
if ((f = fopen(filename, "r")) == NULL) {
fprintf(stderr, _("WARNING: couldn't open %s: %s\n"),
filename, strerror(errno));
}
if (!fs)
continue;
- if (!filesys_info)
- filesys_info = fs;
- else
- fs_last->next = fs;
- fs_last = fs;
if (fs->passno < 0)
fs->passno = 0;
else
return NULL;
for (fs = filesys_info; fs; fs = fs->next) {
- if (strchr(fs->device, '='))
- try_again++;
- if (!strcmp(filesys, fs->device) ||
- !strcmp(filesys, fs->mountpt))
- break;
- }
- if (fs && strchr(fs->device, '='))
- fs->device = interpret_device(fs->device);
-
- if (fs || !try_again)
- return fs;
-
- for (fs = filesys_info; fs; fs = fs->next) {
- fs->device = interpret_device(fs->device);
if (!strcmp(filesys, fs->device) ||
- !strcmp(filesys, fs->mountpt))
+ (fs->mountpt && !strcmp(filesys, fs->mountpt)))
break;
}
* Execute a particular fsck program, and link it into the list of
* child processes we are waiting for.
*/
-static int execute(const char *type, char *device, char *mntpt,
+static int execute(const char *type, const char *device, const char *mntpt,
int interactive)
{
char *s, *argv[80], prog[80];
* If the type isn't specified by the user, then use either the type
* specified in /etc/fstab, or DEFAULT_FSTYPE.
*/
-static void fsck_device(char *device, int interactive)
+static void fsck_device(struct fs_info *fs, int interactive)
{
const char *type = 0;
- struct fs_info *fsent;
int retval;
if (fstype && strncmp(fstype, "no", 2) &&
!strchr(fstype, ','))
type = fstype;
- if ((fsent = lookup(device))) {
- device = fsent->device;
- interpret_type(fsent);
- if (!type)
- type = fsent->type;
- }
- if (!type)
- type = DEFAULT_FSTYPE;
+ type = fs->type ? fs->type : DEFAULT_FSTYPE;
num_running++;
- retval = execute(type, device, fsent ? fsent->mountpt : 0,
- interactive);
+ retval = execute(type, fs->device, fs->mountpt, interactive);
if (retval) {
fprintf(stderr, _("%s: Error %d while executing fsck.%s "
- "for %s\n"), progname, retval, type, device);
+ "for %s\n"), progname, retval, type, fs->device);
num_running--;
}
}
if (fs->passno == 0)
return 1;
- interpret_type(fs);
-
/*
* If a specific fstype is specified, and it doesn't match,
* ignore it.
for (fs = filesys_info; fs; fs = fs->next) {
if (ignore(fs))
fs->flags |= FLAG_DONE;
- else
- fs->device = interpret_device(fs->device);
}
/*
}
if (fs) {
if (!skip_root && !ignore(fs)) {
- fsck_device(fs->device, 1);
+ fsck_device(fs, 1);
status |= wait_all(0);
if (status > EXIT_NONDESTRUCT)
return status;
/*
* Spawn off the fsck process
*/
- fsck_device(fs->device, serialize);
+ fsck_device(fs, serialize);
fs->flags |= FLAG_DONE;
/*
static void PRS(int argc, char *argv[])
{
int i, j;
- char *arg, *tmp;
+ char *arg, *dev, *tmp = 0;
char options[128];
int opt = 0;
int opts_for_fsck = 0;
arg = argv[i];
if (!arg)
continue;
- if ((arg[0] == '/' && !opts_for_fsck) ||
- (strncmp(arg, "LABEL=", 6) == 0) ||
- (strncmp(arg, "UUID=", 5) == 0)) {
+ if ((arg[0] == '/' && !opts_for_fsck) || strchr(arg, '=')) {
if (num_devices >= MAX_DEVICES) {
fprintf(stderr, _("%s: too many devices\n"),
progname);
exit(EXIT_ERROR);
}
- devices[num_devices++] =
- interpret_device(string_copy(arg));
+ dev = blkid_get_devname(cache, arg, NULL);
+ if (!dev && strchr(arg, '=')) {
+ /*
+ * Check to see if we failed because
+ * /proc/partitions isn't found.
+ */
+ if (access("/proc/partitions", R_OK) < 0) {
+ fprintf(stderr, "Couldn't open /proc/partitions: %s\n",
+ strerror(errno));
+ fprintf(stderr, "Is /proc mounted?\n");
+ exit(EXIT_ERROR);
+ }
+ /*
+ * Check to see if this is because
+ * we're not running as root
+ */
+ if (geteuid())
+ fprintf(stderr,
+ "Must be root to scan for matching filesystems: %s\n", arg);
+ else
+ fprintf(stderr,
+ "Couldn't find matching filesystem: %s\n", arg);
+ exit(EXIT_ERROR);
+ }
+ devices[num_devices++] = dev ? dev : string_copy(arg);
continue;
}
if (arg[0] != '-' || opts_for_fsck) {
int main(int argc, char *argv[])
{
- int i;
- int status = 0;
+ int i, status = 0;
int interactive = 0;
- char *oldpath = getenv("PATH");
+ char *type, *oldpath = getenv("PATH");
const char *fstab;
+ struct fs_info *fs;
#ifdef ENABLE_NLS
setlocale(LC_MESSAGES, "");
bindtextdomain(NLS_CAT_NAME, LOCALEDIR);
textdomain(NLS_CAT_NAME);
#endif
+ blkid_get_cache(&cache, NULL);
PRS(argc, argv);
if (!notitle)
}
break;
}
- fsck_device(devices[i], interactive);
+ fs = lookup(devices[i]);
+ if (!fs) {
+ type = blkid_get_tag_value(cache, "TYPE", devices[i]);
+ if (!type) {
+ fprintf(stderr, _("Could not determine "
+ "filesystem type for %s\n"),
+ devices[i]);
+ continue;
+ }
+ fs = create_fs_device(devices[i], 0, type, 0, -1, -1);
+ free(type);
+ if (!fs)
+ continue;
+ }
+ fsck_device(fs, interactive);
if (serialize ||
(max_running && (num_running >= max_running))) {
struct fsck_instance *inst;
}
status |= wait_all(0);
free(fsck_path);
+ blkid_put_cache(cache);
return status;
}
struct fsck_instance *next;
};
-extern char *base_device(char *device);
-extern char *string_copy(const char *s);
+extern char *base_device(const char *device);
extern const char *identify_fs(const char *fs_name, const char *fs_types);
+++ /dev/null
-/*
- * fstype.c
- *
- * Copyright (C) 2001 Theodore Ts'o.
- *
- * %Begin-Header%
- * This file may be redistributed under the terms of the GNU Public
- * License.
- * %End-Header%
- */
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#if HAVE_UNISTD_H
-#include <unistd.h>
-#endif
-#include <fcntl.h>
-#include <sys/types.h>
-
-#include "fsck.h"
-
-struct fs_magic {
- const char *fs_name;
- int offset;
- int len;
- const char *magic;
-};
-
-#define REISERFS_SUPER_MAGIC_STRING "ReIsErFs"
-#define REISER2FS_SUPER_MAGIC_STRING "ReIsEr2Fs"
-#define REISERFS_DISK_OFFSET_IN_BYTES ((64 * 1024) + 52)
-/* the spot for the super in versions 3.5 - 3.5.10 (inclusive) */
-#define REISERFS_OLD_DISK_OFFSET_IN_BYTES ((8 * 1024) + 52)
-
-struct fs_magic type_array[] = {
- { "ext2", 1024+56, 2, "\123\357" },
- { "ext3", 1024+56, 2, "\123\357" },
- { "reiserfs", REISERFS_DISK_OFFSET_IN_BYTES, 9,
- REISER2FS_SUPER_MAGIC_STRING },
- { "reiserfs", REISERFS_DISK_OFFSET_IN_BYTES, 8,
- REISERFS_SUPER_MAGIC_STRING },
- { "reiserfs", REISERFS_OLD_DISK_OFFSET_IN_BYTES, 9,
- REISER2FS_SUPER_MAGIC_STRING },
- { "reiserfs", REISERFS_OLD_DISK_OFFSET_IN_BYTES, 8,
- REISERFS_SUPER_MAGIC_STRING },
- { "minix", 1040, 2, "\177\023" },
- { "minix", 1040, 2, "\217\023" },
- { "minix", 1040, 2, "\150\044" },
- { "minix", 1040, 2, "\170\044" },
- { "xfs", 0, 4, "XFSB" },
- { 0, 0, 0, 0 }
-};
-
-const char *identify_fs(const char *fs_name, const char *fs_types)
-{
- char buf[73728], *s;
- const char *t;
- struct fs_magic *p;
- int fd;
-
- fd = open(fs_name, O_RDONLY);
- if (fd < 0)
- return NULL;
- if (lseek(fd, 0, SEEK_SET) < 0)
- return NULL;
- if (read(fd, buf, sizeof(buf)) != sizeof(buf))
- return NULL;
- close(fd);
- if (!fs_types || !strcmp(fs_types, "auto")) {
- for (p = type_array; p->fs_name; p++) {
- if (memcmp(p->magic, buf+p->offset, p->len) == 0)
- return p->fs_name;
- }
- } else {
- s = string_copy(fs_types);
- for (t = strtok(s, ","); t; t = strtok(NULL, ",")) {
- for (p = type_array; p->fs_name; p++) {
- if (strcmp(p->fs_name, t))
- continue;
- if (memcmp(p->magic, buf+p->offset,
- p->len) == 0) {
- free(s);
- return p->fs_name;
- }
- }
- }
- free(s);
- }
- return NULL;
-}
-
-#ifdef TEST_PROGRAM
-int main(int argc, char **argv)
-{
- const char *type;
-
- if (argc < 2 || argc > 3) {
- fprintf(stderr, "Usage: %s [type list] device\n", argv[0]);
- exit(1);
- }
- if (argc == 2) {
- type = identify_fs(argv[1], NULL);
- printf("%s is a %s filesystem\n", argv[1], type);
- } else {
- type = identify_fs(argv[2],argv[1]);
- printf("%s is a %s filesystem\n", argv[2], type);
- }
- return (0);
-}
-#endif
+++ /dev/null
-/*
- * get_device_by_label.h
- *
- * Copyright 1999 by Andries Brouwer
- * Copyright 1999, 2000 by Theodore Ts'o
- *
- * This file may be redistributed under the terms of the GNU Public
- * License.
- *
- * Taken from aeb's mount, 990619
- * Updated from aeb's mount, 20000725
- * Added call to ext2fs_find_block_device, so that we can find devices
- * even if devfs (ugh) is compiled in, but not mounted, since
- * this messes up /proc/partitions, by TYT.
- */
-
-#include <stdio.h>
-#include <string.h>
-#include <stdlib.h>
-#include <ctype.h>
-#include <fcntl.h>
-#include <unistd.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#ifdef HAVE_SYS_MKDEV_H
-#include <sys/mkdev.h>
-#endif
-#ifdef HAVE_SYS_SYSMACROS_H
-#include <sys/sysmacros.h>
-#endif
-#include <dirent.h>
-#include "nls-enable.h"
-#include "fsck.h"
-#include "get_device_by_label.h"
-
-/* function prototype from libext2 */
-extern char *ext2fs_find_block_device(dev_t device);
-
-#define PROC_PARTITIONS "/proc/partitions"
-#define PROC_EVMS_VOLUMES "/proc/evms/volumes"
-#define DEVLABELDIR "/dev"
-#define VG_DIR "/proc/lvm/VGs"
-
-#define EXT2_SUPER_MAGIC 0xEF53
-struct ext2_super_block {
- unsigned char s_dummy1[56];
- unsigned char s_magic[2];
- unsigned char s_dummy2[46];
- unsigned char s_uuid[16];
- unsigned char s_volume_name[16];
-};
-#define ext2magic(s) ((unsigned int) s.s_magic[0] + (((unsigned int) s.s_magic[1]) << 8))
-
-#define XFS_SUPER_MAGIC "XFSB"
-struct xfs_super_block {
- unsigned char s_magic[4];
- unsigned char s_dummy[28];
- unsigned char s_uuid[16];
- unsigned char s_dummy2[60];
- unsigned char s_fname[12];
-};
-
-struct reiserfs_super_block
-{
- /* Following entries are based on reiserfsutils 3.6.3
- * (Copyright Hans Reiser) since Linux kernel headers
- * (2.4.18) seemed not up-to-date. */
- unsigned char s_dummy1[52];
- unsigned char s_magic[10];
- unsigned char s_dummy2[10];
- unsigned char s_version[2];
- unsigned char s_dummy3[10];
- unsigned char s_uuid[16];
- unsigned char s_label[16];
- unsigned char s_unused[88];
-};
-
-#define REISER2FS_SUPER_MAGIC_STRING "ReIsEr2Fs" /* v. 3.6 */
-#define REISER3FS_SUPER_MAGIC_STRING "ReIsEr3Fs" /* Journal Relocation */
-#define REISERFS_DISK_OFFSET_IN_BYTES (64 * 1024)
-/* the spot for the super in versions 3.5 - 3.5.10 (inclusive) -
- * We'll use it in case volume has been converted. */
-#define REISERFS_OLD_DISK_OFFSET_IN_BYTES (8 * 1024)
-#define reiserversion(s) ((unsigned) (s).s_version[0] + (((unsigned) (s).s_version[1]) << 8))
-
-/* We're checking for ReiserFS v. 3.6 and RJ 3.6 SB */
-static int
-reiser_supports_uuid (struct reiserfs_super_block *sb)
-{
- return (strncmp(sb->s_magic, REISER2FS_SUPER_MAGIC_STRING,
- strlen (REISER2FS_SUPER_MAGIC_STRING)) == 0)
- || (strncmp(sb->s_magic, REISER3FS_SUPER_MAGIC_STRING,
- strlen (REISER3FS_SUPER_MAGIC_STRING)) == 0
- && reiserversion(*sb) == 2);
-}
-
-static struct uuidCache_s {
- struct uuidCache_s *next;
- char uuid[16];
- char *label;
- char *device;
-} *uuidCache = NULL;
-
-char *string_copy(const char *s)
-{
- char *ret;
-
- ret = malloc(strlen(s)+1);
- if (ret)
- strcpy(ret, s);
- return ret;
-}
-
-/* for now, only ext2, ext3, xfs and ReiserFS are supported */
-static int
-get_label_uuid(const char *device, char **label, char *uuid) {
-
- /* start with ext2/3, xfs and ReiserFS tests, taken from mount_guess_fstype */
- /* should merge these later */
- int fd;
- size_t label_size;
- unsigned char *sb_uuid = 0, *sb_label = 0;
- struct ext2_super_block e2sb;
- struct xfs_super_block xfsb;
- struct reiserfs_super_block rfsb;
-
- fd = open(device, O_RDONLY);
- if (fd < 0)
- return 1;
-
- if (lseek(fd, 1024, SEEK_SET) == 1024
- && read(fd, (char *) &e2sb, sizeof(e2sb)) == sizeof(e2sb)
- && (ext2magic(e2sb) == EXT2_SUPER_MAGIC)) {
- sb_uuid = e2sb.s_uuid;
- sb_label = e2sb.s_volume_name;
- label_size = sizeof(e2sb.s_volume_name);
- } else if (lseek(fd, 0, SEEK_SET) == 0
- && read(fd, (char *) &xfsb, sizeof(xfsb)) == sizeof(xfsb)
- && strncmp((char *) &xfsb.s_magic, XFS_SUPER_MAGIC, 4) == 0) {
- sb_uuid = xfsb.s_uuid;
- sb_label = xfsb.s_fname;
- label_size = sizeof(xfsb.s_fname);
- } else if ((lseek(fd, REISERFS_OLD_DISK_OFFSET_IN_BYTES, SEEK_SET)
- == REISERFS_OLD_DISK_OFFSET_IN_BYTES
- && read(fd, (char *) &rfsb, sizeof(rfsb)) == sizeof(rfsb)
- && (reiser_supports_uuid(&rfsb)))
- || (lseek(fd, REISERFS_DISK_OFFSET_IN_BYTES, SEEK_SET)
- == REISERFS_DISK_OFFSET_IN_BYTES
- && read(fd, (char *) &rfsb, sizeof(rfsb)) == sizeof(rfsb)
- && (reiser_supports_uuid(&rfsb)))) {
- sb_uuid = rfsb.s_uuid;
- sb_label = rfsb.s_label;
- label_size = sizeof(rfsb.s_label);
- } else {
- close(fd);
- return 1;
- }
-
- close(fd);
- if (sb_uuid)
- memcpy(uuid, sb_uuid, sizeof(e2sb.s_uuid));
- if (sb_label) {
- if ((*label = calloc(label_size + 1, 1)) != NULL)
- memcpy(*label, sb_label, label_size);
- }
- return 0;
-}
-
-#define CBBUF (16 * 1024)
-
-static void
-uuidcache_addentry(char *device, char *label, char *uuid) {
- struct uuidCache_s *last;
-
- if (!uuidCache) {
- last = uuidCache = malloc(sizeof(*uuidCache));
- } else {
- for (last = uuidCache; last->next; last = last->next) ;
- last->next = malloc(sizeof(*uuidCache));
- last = last->next;
- }
- last->next = NULL;
- last->device = device;
- last->label = label;
- memcpy(last->uuid, uuid, sizeof(last->uuid));
-}
-
-/*
- * This function initializes the UUID cache with devices from the LVM
- * proc hierarchy. We currently depend on the names of the LVM
- * hierarchy giving us the device structure in /dev. (XXX is this a
- * safe thing to do?)
- */
-#ifdef VG_DIR
-static void init_lvm(void)
-{
- DIR *vg_dir, *lv_list;
- char *vdirname, *lvm_device;
- char uuid[16], *label, *vname, *lname;
- struct dirent *vg_iter, *lv_iter;
-
- if ((vg_dir = opendir(VG_DIR)) == NULL)
- return;
-
- while ((vg_iter = readdir(vg_dir)) != 0) {
- vname = vg_iter->d_name;
- if (!strcmp(vname, ".") || !strcmp(vname, ".."))
- continue;
- vdirname = malloc(strlen(VG_DIR)+strlen(vname)+8);
- if (!vdirname) {
- closedir(vg_dir);
- return;
- }
- sprintf(vdirname, "%s/%s/LVs", VG_DIR, vname);
-
- lv_list = opendir(vdirname);
- free(vdirname);
- if (lv_list == NULL)
- return;
-
- while ((lv_iter = readdir(lv_list)) != 0) {
- lname = lv_iter->d_name;
- if (!strcmp(lname, ".") || !strcmp(lname, ".."))
- continue;
-
- lvm_device = malloc(strlen(DEVLABELDIR) +
- strlen(vname)+
- strlen(lname)+8);
- if (!lvm_device) {
- closedir(lv_list);
- closedir(vg_dir);
- return;
- }
- sprintf(lvm_device, "%s/%s/%s", DEVLABELDIR,
- vname, lname);
- if (!get_label_uuid(lvm_device, &label, uuid)) {
- uuidcache_addentry(string_copy(lvm_device),
- label, uuid);
- } else
- free(lvm_device);
- }
- closedir(lv_list);
- }
- closedir( vg_dir );
-}
-#endif
-
-static void
-read_partitions(void)
-{
- char line[100];
- char *s;
- int ma, mi, sz;
- static char ptname[100];
- FILE *procpt;
- char uuid[16], *label, *devname;
- char device[110];
- dev_t dev;
- struct stat statbuf;
- int firstPass;
- int handleOnFirst;
- char *iobuf;
-
- procpt = fopen(PROC_PARTITIONS, "r");
- if (!procpt)
- return;
-
- iobuf = (char *)malloc(CBBUF);
- if (iobuf)
- setvbuf(procpt, iobuf, _IOFBF, CBBUF);
-
- for (firstPass = 1; firstPass >= 0; firstPass--) {
- fseek(procpt, 0, SEEK_SET);
-
- while (fgets(line, sizeof(line), procpt)) {
- if (sscanf (line, " %d %d %d %[^\n ]",
- &ma, &mi, &sz, ptname) != 4)
- continue;
-
- /* skip extended partitions (heuristic: size 1) */
- if (sz == 1)
- continue;
-
- /* look only at md devices on first pass */
- handleOnFirst = !strncmp(ptname, "md", 2);
- if (firstPass != handleOnFirst)
- continue;
-
- /* skip entire disk (minor 0, 64, ... on ide;
- 0, 16, ... on sd) */
- /* heuristic: partition name ends in a digit */
- /* OR partition name starts with 'lvm' */
-
- for(s = ptname; *s; s++);
- if (isdigit(s[-1]) || !strncmp(ptname, "lvm", 3)) {
- /*
- * We first look in /dev for the device, but
- * if we don't find it, or if the stat
- * information doesn't check out, we use
- * ext2fs_find_block_device to find it.
- */
- sprintf(device, "%s/%s", DEVLABELDIR, ptname);
- dev = makedev(ma, mi);
- if ((stat(device, &statbuf) < 0) ||
- (statbuf.st_rdev != dev)) {
- devname = ext2fs_find_block_device(dev);
- } else
- devname = string_copy(device);
- if (!devname)
- continue;
-#ifdef DEBUG
- printf("Checking partition %s (%d, %d)\n",
- devname, ma, mi);
-#endif
- if (!get_label_uuid(devname, &label, uuid))
- uuidcache_addentry(devname, label, uuid);
- else
- free(devname);
- }
- }
- }
-
- fclose(procpt);
- if (iobuf)
- free(iobuf);
-}
-
-static void
-read_evms(void)
-{
- char line[100];
- int ma, mi, sz;
- FILE *procpt;
- char uuid[16], *label, *devname;
- char device[110];
- dev_t dev;
- struct stat statbuf;
-
- procpt = fopen(PROC_EVMS_VOLUMES, "r");
- if (!procpt)
- return;
- while (fgets(line, sizeof(line), procpt)) {
- if (sscanf (line, " %d %d %d %*s %*s %[^\n ]",
- &ma, &mi, &sz, device) != 4)
- continue;
-
- /*
- * We first look for the device in the named location,
- * but if we don't find it, or if the stat information
- * doesn't check out, we use ext2fs_find_block_device
- * to find it.
- */
- dev = makedev(ma, mi);
- if ((stat(device, &statbuf) < 0) || (statbuf.st_rdev != dev)) {
- devname = ext2fs_find_block_device(dev);
- } else
- devname = string_copy(device);
- if (!devname)
- continue;
-#ifdef DEBUG
- printf("Checking partition %s (%d, %d)\n",
- devname, ma, mi);
-#endif
- if (!get_label_uuid(devname, &label, uuid))
- uuidcache_addentry(devname, label, uuid);
- else
- free(devname);
- }
- fclose(procpt);
-}
-
-static void
-uuidcache_init(void)
-{
- if (uuidCache)
- return;
-
-#ifdef VG_DIR
- init_lvm();
-#endif
- read_evms();
- read_partitions();
-}
-
-#define UUID 1
-#define VOL 2
-
-static char *
-get_spec_by_x(int n, const char *t) {
- struct uuidCache_s *uc;
-
- uuidcache_init();
- uc = uuidCache;
-
- if (t == NULL)
- return NULL;
-
- while(uc) {
- switch (n) {
- case UUID:
- if (!memcmp(t, uc->uuid, sizeof(uc->uuid)))
- return string_copy(uc->device);
- break;
- case VOL:
- if (!strcmp(t, uc->label))
- return string_copy(uc->device);
- break;
- }
- uc = uc->next;
- }
- return NULL;
-}
-
-static char fromhex(char c)
-{
- if (isdigit(c))
- return (c - '0');
- else if (islower(c))
- return (c - 'a' + 10);
- else
- return (c - 'A' + 10);
-}
-
-char *
-get_spec_by_uuid(const char *s)
-{
- char uuid[16];
- int i;
-
- if (strlen(s) != 36 ||
- s[8] != '-' || s[13] != '-' || s[18] != '-' || s[23] != '-')
- goto bad_uuid;
- for (i=0; i<16; i++) {
- if (*s == '-') s++;
- if (!isxdigit(s[0]) || !isxdigit(s[1]))
- goto bad_uuid;
- uuid[i] = ((fromhex(s[0])<<4) | fromhex(s[1]));
- s += 2;
- }
- return get_spec_by_x(UUID, uuid);
-
- bad_uuid:
- fprintf(stderr, _("WARNING: %s: bad UUID\n"), s);
- return NULL;
-}
-
-char *
-get_spec_by_volume_label(const char *s) {
- return get_spec_by_x(VOL, s);
-}
-
-const char *
-get_volume_label_by_spec(const char *spec) {
- struct uuidCache_s *uc;
-
- uuidcache_init();
- uc = uuidCache;
-
- while(uc) {
- if (!strcmp(spec, uc->device))
- return uc->label;
- uc = uc->next;
- }
- return NULL;
-}
-
-/*
- * Interpret the device name if necessary.
- * Frees the pointer passed to it if we return a different device string.
- */
-char *interpret_spec(char *spec)
-{
- char *dev = NULL;
-
- if (!spec)
- return NULL;
-
- if (!strncmp(spec, "UUID=", 5))
- dev = get_spec_by_uuid(spec+5);
- else if (!strncmp(spec, "LABEL=", 6))
- dev = get_spec_by_volume_label(spec+6);
- else
- dev = string_copy(spec);
- return dev;
-}
-
-#ifdef DEBUG
-main(int argc, char **argv)
-{
- uuidcache_init();
-}
-#endif
+++ /dev/null
-/*
- * get_device_by_label.h
- *
- * Copyright 1999 by Andries Brouwer
- * Copyright 1999, 2000 by Theodore Ts'o
- *
- * This file may be redistributed under the terms of the GNU Public
- * License.
- */
-
-extern char *string_copy(const char *s);
-extern char *get_spec_by_uuid(const char *uuid);
-extern char *get_spec_by_volume_label(const char *volumelabel);
-extern const char *get_volume_label_by_spec(const char *spec);
-extern char *interpret_spec(char *spec);
#include "e2p/e2p.h"
#include "jfs_user.h"
#include "util.h"
-#include "get_device_by_label.h"
+#include "blkid/blkid.h"
#include "../version.h"
#include "nls-enable.h"
commit_remove_journal = 1; /* force removal even if error */
uuid_unparse(fs->super->s_journal_uuid, buf);
- journal_path = get_spec_by_uuid(buf);
+ journal_path = blkid_get_devname(NULL, "UUID", buf);
if (!journal_path) {
journal_path =
exit(1);
}
fs->super->s_journal_dev = 0;
- memset(fs->super->s_journal_uuid, 0,
- sizeof(fs->super->s_journal_uuid));
+ uuid_clear(fs->super->s_journal_uuid);
ext2fs_mark_super_dirty(fs);
printf(_("Journal removed\n"));
free(journal_path);
fprintf(stderr, "Usage: findfs LABEL=<label>|UUID=<uuid>\n");
exit(2);
}
- dev = interpret_spec(argv[1]);
+ dev = blkid_get_devname(NULL, argv[1], NULL);
if (!dev) {
fprintf(stderr, "Filesystem matching %s not found\n",
argv[1]);
#include "ext2fs/ext2_fs.h"
#include "ext2fs/ext2fs.h"
#include "nls-enable.h"
-#include "get_device_by_label.h"
+#include "blkid/blkid.h"
#include "util.h"
#ifndef HAVE_STRCASECMP
arg ? arg : "NONE");
#endif
if (strcmp(token, "device") == 0) {
- journal_device = interpret_spec(arg);
+ journal_device = blkid_get_devname(NULL, arg, NULL);
if (!journal_device) {
journal_usage++;
continue;
projects / thirdparty / e2fsprogs.git / commitdiff
