busybox/util-linux/volume_id/get_devname.c
Denys Vlasenko 689d0650ab libbb: shrink recursive_action() by reducing memory pressure
function                                             old     new   delta
recursive_action1                                      -     316    +316
file_action_grep                                     161     164      +3
add_to_prg_cache_if_socket                           202     205      +3
depmod_main                                          509     511      +2
writeFileToTarball                                   488     489      +1
parse_module                                         281     282      +1
fileAction                                           207     208      +1
act                                                  189     190      +1
add_to_dirlist                                        65      64      -1
writeTarFile                                         196     194      -2
uuidcache_init                                        47      45      -2
uuidcache_check_device                               109     107      -2
true_action                                            8       6      -2
run_parts_main                                       310     308      -2
netstat_main                                         534     532      -2
lsusb_main                                            29      27      -2
lspci_main                                            45      43      -2
initial_scan                                         138     136      -2
grep_main                                            845     843      -2
find_main                                            482     480      -2
config_file_action                                   437     435      -2
chmod_main                                           142     140      -2
dirAction                                             14      10      -4
diff_main                                           1544    1540      -4
chown_main                                           154     148      -6
skip_dir                                             136     129      -7
dir_act                                              191     184      -7
recursive_action                                     453      69    -384
------------------------------------------------------------------------------
(add/remove: 1/0 grow/shrink: 7/20 up/down: 328/-439)        Total: -111 bytes

Signed-off-by: Denys Vlasenko <vda.linux@googlemail.com>
2020-10-01 21:52:16 +02:00

322 lines
7.3 KiB
C

/* vi: set sw=4 ts=4: */
/*
* Support functions for mounting devices by label/uuid
*
* Copyright (C) 2006 by Jason Schoon <floydpink@gmail.com>
* Some portions cribbed from e2fsprogs, util-linux, dosfstools
*
* Licensed under GPLv2 or later, see file LICENSE in this source tree.
*/
//kbuild:lib-$(CONFIG_BLKID) += get_devname.o
//kbuild:lib-$(CONFIG_FINDFS) += get_devname.o
//kbuild:lib-$(CONFIG_FEATURE_MOUNT_LABEL) += get_devname.o
//kbuild:lib-$(CONFIG_FEATURE_SWAPONOFF_LABEL) += get_devname.o
#include <sys/mount.h> /* BLKGETSIZE64 */
#if !defined(BLKGETSIZE64)
# define BLKGETSIZE64 _IOR(0x12,114,size_t)
#endif
#include "volume_id_internal.h"
static struct uuidCache_s {
struct uuidCache_s *next;
// int major, minor;
char *device;
char *label;
char *uc_uuid; /* prefix makes it easier to grep for */
IF_FEATURE_BLKID_TYPE(const char *type;)
} *uuidCache;
#if !ENABLE_FEATURE_BLKID_TYPE
#define get_label_uuid(fd, label, uuid, type) \
get_label_uuid(fd, label, uuid)
#define uuidcache_addentry(device, label, uuid, type) \
uuidcache_addentry(device, label, uuid)
#endif
/* Returns !0 on error.
* Otherwise, returns malloc'ed strings for label and uuid
* (and they can't be NULL, although they can be "").
* NB: closes fd. */
static int
get_label_uuid(int fd, char **label, char **uuid, const char **type)
{
int rv = 1;
uint64_t size;
struct volume_id *vid;
/* fd is owned by vid now */
vid = volume_id_open_node(fd);
if (ioctl(/*vid->*/fd, BLKGETSIZE64, &size) != 0)
size = 0;
if (volume_id_probe_all(vid, /*0,*/ size) != 0)
goto ret;
if (vid->label[0] != '\0' || vid->uuid[0] != '\0'
#if ENABLE_FEATURE_BLKID_TYPE
|| vid->type != NULL
#endif
) {
*label = xstrndup(vid->label, sizeof(vid->label));
*uuid = xstrndup(vid->uuid, sizeof(vid->uuid));
#if ENABLE_FEATURE_BLKID_TYPE
*type = vid->type;
dbg("found label '%s', uuid '%s', type '%s'", *label, *uuid, *type);
#else
dbg("found label '%s', uuid '%s'", *label, *uuid);
#endif
rv = 0;
}
ret:
free_volume_id(vid); /* also closes fd */
return rv;
}
/* NB: we take ownership of (malloc'ed) label and uuid */
static void
uuidcache_addentry(char *device, /*int major, int minor,*/ char *label, char *uuid, const char *type)
{
struct uuidCache_s *last;
if (!uuidCache) {
last = uuidCache = xzalloc(sizeof(*uuidCache));
} else {
for (last = uuidCache; last->next; last = last->next)
continue;
last->next = xzalloc(sizeof(*uuidCache));
last = last->next;
}
/*last->next = NULL; - xzalloc did it*/
// last->major = major;
// last->minor = minor;
last->device = device;
last->label = label;
last->uc_uuid = uuid;
IF_FEATURE_BLKID_TYPE(last->type = type;)
}
/* If get_label_uuid() on device_name returns success,
* add a cache entry for this device.
* If device node does not exist, it will be temporarily created. */
static int FAST_FUNC
uuidcache_check_device(struct recursive_state *state UNUSED_PARAM,
const char *device,
struct stat *statbuf)
{
/* note: this check rejects links to devices, among other nodes */
if (!S_ISBLK(statbuf->st_mode)
#if ENABLE_FEATURE_VOLUMEID_UBIFS
&& !(S_ISCHR(statbuf->st_mode) && strncmp(bb_basename(device), "ubi", 3) == 0)
#endif
)
return TRUE;
/* Users report that mucking with floppies (especially non-present
* ones) is significant PITA. This is a horribly dirty hack,
* but it is very useful in real world.
* If this will ever need to be enabled, consider using O_NONBLOCK.
*/
if (major(statbuf->st_rdev) == 2)
return TRUE;
add_to_uuid_cache(device);
return TRUE;
}
static struct uuidCache_s*
uuidcache_init(int scan_devices)
{
dbg("DBG: uuidCache=%x, uuidCache");
if (uuidCache)
return uuidCache;
/* We were scanning /proc/partitions
* and /proc/sys/dev/cdrom/info here.
* Missed volume managers. I see that "standard" blkid uses these:
* /dev/mapper/control
* /proc/devices
* /proc/evms/volumes
* /proc/lvm/VGs
* This is unacceptably complex. Let's just scan /dev.
* (Maybe add scanning of /sys/block/XXX/dev for devices
* somehow not having their /dev/XXX entries created?) */
if (scan_devices) {
recursive_action("/dev", ACTION_RECURSE,
uuidcache_check_device, /* file_action */
NULL, /* dir_action */
NULL /* userData */
);
}
return uuidCache;
}
#define UUID 1
#define VOL 2
#ifdef UNUSED
static char *
get_spec_by_x(int n, const char *t, int *majorPtr, int *minorPtr)
{
struct uuidCache_s *uc;
uc = uuidcache_init(/*scan_devices:*/ 1);
while (uc) {
switch (n) {
case UUID:
if (strcmp(t, uc->uc_uuid) == 0) {
*majorPtr = uc->major;
*minorPtr = uc->minor;
return uc->device;
}
break;
case VOL:
if (strcmp(t, uc->label) == 0) {
*majorPtr = uc->major;
*minorPtr = uc->minor;
return uc->device;
}
break;
}
uc = uc->next;
}
return NULL;
}
static unsigned char
fromhex(char c)
{
if (isdigit(c))
return (c - '0');
return ((c|0x20) - 'a' + 10);
}
static char *
get_spec_by_uuid(const char *s, int *major, int *minor)
{
unsigned 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, (char *)uuid, major, minor);
bad_uuid:
fprintf(stderr, _("mount: bad UUID"));
return 0;
}
static char *
get_spec_by_volume_label(const char *s, int *major, int *minor)
{
return get_spec_by_x(VOL, s, major, minor);
}
#endif // UNUSED
/* Used by blkid */
void display_uuid_cache(int scan_devices)
{
struct uuidCache_s *uc;
uc = uuidcache_init(scan_devices);
while (uc) {
printf("%s:", uc->device);
if (uc->label[0])
printf(" LABEL=\"%s\"", uc->label);
if (uc->uc_uuid[0])
printf(" UUID=\"%s\"", uc->uc_uuid);
#if ENABLE_FEATURE_BLKID_TYPE
if (uc->type)
printf(" TYPE=\"%s\"", uc->type);
#endif
bb_putchar('\n');
uc = uc->next;
}
}
int add_to_uuid_cache(const char *device)
{
char *uuid = uuid; /* for compiler */
char *label = label;
#if ENABLE_FEATURE_BLKID_TYPE
const char *type = type;
#endif
int fd;
fd = open(device, O_RDONLY);
if (fd < 0)
return 0;
/* get_label_uuid() closes fd in all cases (success & failure) */
if (get_label_uuid(fd, &label, &uuid, &type) == 0) {
/* uuidcache_addentry() takes ownership of all four params */
uuidcache_addentry(xstrdup(device), /*ma, mi,*/ label, uuid, type);
return 1;
}
return 0;
}
/* Used by mount and findfs */
char *get_devname_from_label(const char *spec)
{
struct uuidCache_s *uc;
uc = uuidcache_init(/*scan_devices:*/ 1);
while (uc) {
if (uc->label[0] && strcmp(spec, uc->label) == 0) {
return xstrdup(uc->device);
}
uc = uc->next;
}
return NULL;
}
char *get_devname_from_uuid(const char *spec)
{
struct uuidCache_s *uc;
uc = uuidcache_init(/*scan_devices:*/ 1);
while (uc) {
/* case of hex numbers doesn't matter */
if (strcasecmp(spec, uc->uc_uuid) == 0) {
return xstrdup(uc->device);
}
uc = uc->next;
}
return NULL;
}
int resolve_mount_spec(char **fsname)
{
char *tmp = *fsname;
if (is_prefixed_with(*fsname, "UUID="))
tmp = get_devname_from_uuid(*fsname + 5);
else if (is_prefixed_with(*fsname, "LABEL="))
tmp = get_devname_from_label(*fsname + 6);
if (tmp == *fsname)
return 0; /* no UUID= or LABEL= prefix found */
if (tmp)
*fsname = tmp;
return 1;
}