[thirdparty/systemd.git] / src / udev / udevadm-info.c

/*
 * Copyright (C) 2004-2009 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, either version 2 of the License, or
 * (at your option) any later version.
 *
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <stddef.h>
#include <ctype.h>
#include <stdarg.h>
#include <unistd.h>
#include <dirent.h>
#include <errno.h>
#include <getopt.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <sys/types.h>

#include "udev.h"
#include "udev-util.h"

static bool skip_attribute(const char *name)
{
        static const char* const skip[] = {
                "uevent",
                "dev",
                "modalias",
                "resource",
                "driver",
                "subsystem",
                "module",
        };
        unsigned int i;

        for (i = 0; i < ELEMENTSOF(skip); i++)
                if (streq(name, skip[i]))
                        return true;
        return false;
}

static void print_all_attributes(struct udev_device *device, const char *key)
{
        struct udev_list_entry *sysattr;

        udev_list_entry_foreach(sysattr, udev_device_get_sysattr_list_entry(device)) {
                const char *name;
                const char *value;
                size_t len;

                name = udev_list_entry_get_name(sysattr);
                if (skip_attribute(name))
                        continue;

                value = udev_device_get_sysattr_value(device, name);
                if (value == NULL)
                        continue;

                /* skip any values that look like a path */
                if (value[0] == '/')
                        continue;

                /* skip nonprintable attributes */
                len = strlen(value);
                while (len > 0 && isprint(value[len-1]))
                        len--;
                if (len > 0)
                        continue;

                printf("    %s{%s}==\"%s\"\n", key, name, value);
        }
        printf("\n");
}

static int print_device_chain(struct udev_device *device)
{
        struct udev_device *device_parent;
        const char *str;

        printf("\n"
               "Udevadm info starts with the device specified by the devpath and then\n"
               "walks up the chain of parent devices. It prints for every device\n"
               "found, all possible attributes in the udev rules key format.\n"
               "A rule to match, can be composed by the attributes of the device\n"
               "and the attributes from one single parent device.\n"
               "\n");

        printf("  looking at device '%s':\n", udev_device_get_devpath(device));
        printf("    KERNEL==\"%s\"\n", udev_device_get_sysname(device));
        str = udev_device_get_subsystem(device);
        if (str == NULL)
                str = "";
        printf("    SUBSYSTEM==\"%s\"\n", str);
        str = udev_device_get_driver(device);
        if (str == NULL)
                str = "";
        printf("    DRIVER==\"%s\"\n", str);
        print_all_attributes(device, "ATTR");

        device_parent = device;
        do {
                device_parent = udev_device_get_parent(device_parent);
                if (device_parent == NULL)
                        break;
                printf("  looking at parent device '%s':\n", udev_device_get_devpath(device_parent));
                printf("    KERNELS==\"%s\"\n", udev_device_get_sysname(device_parent));
                str = udev_device_get_subsystem(device_parent);
                if (str == NULL)
                        str = "";
                printf("    SUBSYSTEMS==\"%s\"\n", str);
                str = udev_device_get_driver(device_parent);
                if (str == NULL)
                        str = "";
                printf("    DRIVERS==\"%s\"\n", str);
                print_all_attributes(device_parent, "ATTRS");
        } while (device_parent != NULL);

        return 0;
}

static void print_record(struct udev_device *device)
{
        const char *str;
        int i;
        struct udev_list_entry *list_entry;

        printf("P: %s\n", udev_device_get_devpath(device));

        str = udev_device_get_devnode(device);
        if (str != NULL)
                printf("N: %s\n", str + strlen("/dev/"));

        i = udev_device_get_devlink_priority(device);
        if (i != 0)
                printf("L: %i\n", i);

        udev_list_entry_foreach(list_entry, udev_device_get_devlinks_list_entry(device))
                printf("S: %s\n", udev_list_entry_get_name(list_entry) + strlen("/dev/"));

        udev_list_entry_foreach(list_entry, udev_device_get_properties_list_entry(device))
                printf("E: %s=%s\n",
                       udev_list_entry_get_name(list_entry),
                       udev_list_entry_get_value(list_entry));
        printf("\n");
}

static int stat_device(const char *name, bool export, const char *prefix)
{
        struct stat statbuf;

        if (stat(name, &statbuf) != 0)
                return -1;

        if (export) {
                if (prefix == NULL)
                        prefix = "INFO_";
                printf("%sMAJOR=%d\n"
                       "%sMINOR=%d\n",
                       prefix, major(statbuf.st_dev),
                       prefix, minor(statbuf.st_dev));
        } else
                printf("%d:%d\n", major(statbuf.st_dev), minor(statbuf.st_dev));
        return 0;
}

static int export_devices(struct udev *udev)
{
        struct udev_enumerate *udev_enumerate;
        struct udev_list_entry *list_entry;

        udev_enumerate = udev_enumerate_new(udev);
        if (udev_enumerate == NULL)
                return -1;
        udev_enumerate_scan_devices(udev_enumerate);
        udev_list_entry_foreach(list_entry, udev_enumerate_get_list_entry(udev_enumerate)) {
                struct udev_device *device;

                device = udev_device_new_from_syspath(udev, udev_list_entry_get_name(list_entry));
                if (device != NULL) {
                        print_record(device);
                        udev_device_unref(device);
                }
        }
        udev_enumerate_unref(udev_enumerate);
        return 0;
}

static void cleanup_dir(DIR *dir, mode_t mask, int depth)
{
        struct dirent *dent;

        if (depth <= 0)
                return;

        for (dent = readdir(dir); dent != NULL; dent = readdir(dir)) {
                struct stat stats;

                if (dent->d_name[0] == '.')
                        continue;
                if (fstatat(dirfd(dir), dent->d_name, &stats, AT_SYMLINK_NOFOLLOW) != 0)
                        continue;
                if ((stats.st_mode & mask) != 0)
                        continue;
                if (S_ISDIR(stats.st_mode)) {
                        DIR *dir2;

                        dir2 = fdopendir(openat(dirfd(dir), dent->d_name, O_RDONLY|O_NONBLOCK|O_DIRECTORY|O_CLOEXEC));
                        if (dir2 != NULL) {
                                cleanup_dir(dir2, mask, depth-1);
                                closedir(dir2);
                        }
                        unlinkat(dirfd(dir), dent->d_name, AT_REMOVEDIR);
                } else {
                        unlinkat(dirfd(dir), dent->d_name, 0);
                }
        }
}

static void cleanup_db(struct udev *udev)
{
        DIR *dir;

        unlink("/run/udev/queue.bin");

        dir = opendir("/run/udev/data");
        if (dir != NULL) {
                cleanup_dir(dir, S_ISVTX, 1);
                closedir(dir);
        }

        dir = opendir("/run/udev/links");
        if (dir != NULL) {
                cleanup_dir(dir, 0, 2);
                closedir(dir);
        }

        dir = opendir("/run/udev/tags");
        if (dir != NULL) {
                cleanup_dir(dir, 0, 2);
                closedir(dir);
        }

        dir = opendir("/run/udev/static_node-tags");
        if (dir != NULL) {
                cleanup_dir(dir, 0, 2);
                closedir(dir);
        }

        dir = opendir("/run/udev/watch");
        if (dir != NULL) {
                cleanup_dir(dir, 0, 1);
                closedir(dir);
        }
}

static struct udev_device *find_device(struct udev *udev, const char *id, const char *prefix)
{
        char name[UTIL_PATH_SIZE];

        if (prefix && !startswith(id, prefix)) {
                strscpyl(name, sizeof(name), prefix, id, NULL);
                id = name;
        }

        if (startswith(id, "/dev/")) {
                struct stat statbuf;
                char type;

                if (stat(id, &statbuf) < 0)
                        return NULL;

                if (S_ISBLK(statbuf.st_mode))
                        type = 'b';
                else if (S_ISCHR(statbuf.st_mode))
                        type = 'c';
                else
                        return NULL;

                return udev_device_new_from_devnum(udev, type, statbuf.st_rdev);
        } else if (startswith(id, "/sys/"))
                return udev_device_new_from_syspath(udev, id);
        else
                return NULL;
}

static int uinfo(struct udev *udev, int argc, char *argv[])
{
        _cleanup_udev_device_unref_ struct udev_device *device = NULL;
        bool root = 0;
        bool export = 0;
        const char *export_prefix = NULL;
        char name[UTIL_PATH_SIZE];
        struct udev_list_entry *list_entry;
        int c;

        static const struct option options[] = {
                { "name",              required_argument, NULL, 'n' },
                { "path",              required_argument, NULL, 'p' },
                { "query",             required_argument, NULL, 'q' },
                { "attribute-walk",    no_argument,       NULL, 'a' },
                { "cleanup-db",        no_argument,       NULL, 'c' },
                { "export-db",         no_argument,       NULL, 'e' },
                { "root",              no_argument,       NULL, 'r' },
                { "device-id-of-file", required_argument, NULL, 'd' },
                { "export",            no_argument,       NULL, 'x' },
                { "export-prefix",     required_argument, NULL, 'P' },
                { "version",           no_argument,       NULL, 'V' },
                { "help",              no_argument,       NULL, 'h' },
                {}
        };

        static const char *usage =
                "Usage: udevadm info [OPTIONS] [DEVPATH|FILE]\n"
                " -q,--query=TYPE             query device information:\n"
                "      name                     name of device node\n"
                "      symlink                  pointing to node\n"
                "      path                     sys device path\n"
                "      property                 the device properties\n"
                "      all                      all values\n"
                " -p,--path=SYSPATH           sys device path used for query or attribute walk\n"
                " -n,--name=NAME              node or symlink name used for query or attribute walk\n"
                " -r,--root                   prepend dev directory to path names\n"
                " -a,--attribute-walk         print all key matches walking along the chain\n"
                "                             of parent devices\n"
                " -d,--device-id-of-file=FILE print major:minor of device containing this file\n"
                " -x,--export                 export key/value pairs\n"
                " -P,--export-prefix          export the key name with a prefix\n"
                " -e,--export-db              export the content of the udev database\n"
                " -c,--cleanup-db             cleanup the udev database\n"
                "    --version                print version of the program\n"
                " -h,--help                   print this message\n";

        enum action_type {
                ACTION_QUERY,
                ACTION_ATTRIBUTE_WALK,
                ACTION_DEVICE_ID_FILE,
        } action = ACTION_QUERY;

        enum query_type {
                QUERY_NAME,
                QUERY_PATH,
                QUERY_SYMLINK,
                QUERY_PROPERTY,
                QUERY_ALL,
        } query = QUERY_ALL;

        while ((c = getopt_long(argc, argv, "aced:n:p:q:rxP:RVh", options, NULL)) >= 0)
                switch (c) {
                case 'n': {
                        if (device != NULL) {
                                fprintf(stderr, "device already specified\n");
                                return 2;
                        }

                        device = find_device(udev, optarg, "/dev/");
                        if (device == NULL) {
                                fprintf(stderr, "device node not found\n");
                                return 2;
                        }
                        break;
                }
                case 'p':
                        if (device != NULL) {
                                fprintf(stderr, "device already specified\n");
                                return 2;
                        }

                        device = find_device(udev, optarg, "/sys");
                        if (device == NULL) {
                                fprintf(stderr, "syspath not found\n");
                                return 2;
                        }
                        break;
                case 'q':
                        action = ACTION_QUERY;
                        if (streq(optarg, "property") || streq(optarg, "env"))
                                query = QUERY_PROPERTY;
                        else if (streq(optarg, "name"))
                                query = QUERY_NAME;
                        else if (streq(optarg, "symlink"))
                                query = QUERY_SYMLINK;
                        else if (streq(optarg, "path"))
                                query = QUERY_PATH;
                        else if (streq(optarg, "all"))
                                query = QUERY_ALL;
                        else {
                                fprintf(stderr, "unknown query type\n");
                                return 3;
                        }
                        break;
                case 'r':
                        root = true;
                        break;
                case 'd':
                        action = ACTION_DEVICE_ID_FILE;
                        strscpy(name, sizeof(name), optarg);
                        break;
                case 'a':
                        action = ACTION_ATTRIBUTE_WALK;
                        break;
                case 'e':
                        export_devices(udev);
                        return 0;
                case 'c':
                        cleanup_db(udev);
                        return 0;
                case 'x':
                        export = true;
                        break;
                case 'P':
                        export_prefix = optarg;
                        break;
                case 'V':
                        printf("%s\n", VERSION);
                        return 0;
                case 'h':
                        printf("%s\n", usage);
                        return 0;
                default:
                        return 1;
                }

        switch (action) {
        case ACTION_QUERY:
                if (!device) {
                        if (!argv[optind]) {
                                fprintf(stderr, "%s\n", usage);
                                return 2;
                        }
                        device = find_device(udev, argv[optind], NULL);
                        if (!device) {
                                fprintf(stderr, "Unknown device, --name=, --path=, or absolute path in /dev/ or /sys expected.\n");
                                return 4;
                        }
                }

                switch(query) {
                case QUERY_NAME: {
                        const char *node = udev_device_get_devnode(device);

                        if (node == NULL) {
                                fprintf(stderr, "no device node found\n");
                                return 5;
                        }

                        if (root)
                                printf("%s\n", udev_device_get_devnode(device));
                        else
                                printf("%s\n", udev_device_get_devnode(device) + strlen("/dev/"));
                        break;
                }
                case QUERY_SYMLINK:
                        list_entry = udev_device_get_devlinks_list_entry(device);
                        while (list_entry != NULL) {
                                if (root)
                                        printf("%s", udev_list_entry_get_name(list_entry));
                                else
                                        printf("%s", udev_list_entry_get_name(list_entry) + strlen("/dev/"));
                                list_entry = udev_list_entry_get_next(list_entry);
                                if (list_entry != NULL)
                                        printf(" ");
                        }
                        printf("\n");
                        break;
                case QUERY_PATH:
                        printf("%s\n", udev_device_get_devpath(device));
                        return 0;
                case QUERY_PROPERTY:
                        list_entry = udev_device_get_properties_list_entry(device);
                        while (list_entry != NULL) {
                                if (export) {
                                        const char *prefix = export_prefix;

                                        if (prefix == NULL)
                                                prefix = "";
                                        printf("%s%s='%s'\n", prefix,
                                               udev_list_entry_get_name(list_entry),
                                               udev_list_entry_get_value(list_entry));
                                } else {
                                        printf("%s=%s\n", udev_list_entry_get_name(list_entry), udev_list_entry_get_value(list_entry));
                                }
                                list_entry = udev_list_entry_get_next(list_entry);
                        }
                        break;
                case QUERY_ALL:
                        print_record(device);
                        break;
                default:
                        assert_not_reached("unknown query type");
                }
                break;
        case ACTION_ATTRIBUTE_WALK:
                if (!device && argv[optind]) {
                        device = find_device(udev, argv[optind], NULL);
                        if (!device) {
                                fprintf(stderr, "Unknown device, absolute path in /dev/ or /sys expected.\n");
                                return 4;
                        }
                }
                if (!device) {
                        fprintf(stderr, "Unknown device, --name=, --path=, or absolute path in /dev/ or /sys expected.\n");
                        return 4;
                }
                print_device_chain(device);
                break;
        case ACTION_DEVICE_ID_FILE:
                if (stat_device(name, export, export_prefix) != 0)
                        return 1;
                break;
        }

        return 0;
}

const struct udevadm_cmd udevadm_info = {
        .name = "info",
        .cmd = uinfo,
        .help = "query sysfs or the udev database",
};
Commit	Line	Data
be9b51f6	1	/*
1298001e	2	* Copyright (C) 2004-2009 Kay Sievers <kay@vrfy.org>
be9b51f6	3	*
55e9959b KS	4	* This program is free software: you can redistribute it and/or modify
	5	* it under the terms of the GNU General Public License as published by
	6	* the Free Software Foundation, either version 2 of the License, or
	7	* (at your option) any later version.
be9b51f6	8	*
55e9959b KS	9	* This program is distributed in the hope that it will be useful,
	10	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	11	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	12	* GNU General Public License for more details.
	13	*
	14	* You should have received a copy of the GNU General Public License
	15	* along with this program. If not, see <http://www.gnu.org/licenses/>.
be9b51f6 KS	16	*/
	17
	18	#include <stdlib.h>
	19	#include <string.h>
	20	#include <stdio.h>
1aa1e248	21	#include <stddef.h>
034f35d7	22	#include <ctype.h>
87171e46 KS	23	#include <stdarg.h>
87171e46 KS	24	#include <unistd.h>
1aa1e248	25	#include <dirent.h>
87171e46	26	#include <errno.h>
11f1bb5a	27	#include <getopt.h>
e6c1a2bd	28	#include <fcntl.h>
492e76c9 KS	29	#include <sys/stat.h>
492e76c9 KS	30	#include <sys/types.h>
be9b51f6	31
869fc2f1	32	#include "udev.h"
44433ebd	33	#include "udev-util.h"
be9b51f6	34
20bee04c KS	35	static bool skip_attribute(const char *name)
20bee04c KS	36	{
46512cd9	37	static const char* const skip[] = {
912541b0 KS	38	"uevent",
	39	"dev",
	40	"modalias",
	41	"resource",
	42	"driver",
	43	"subsystem",
	44	"module",
	45	};
	46	unsigned int i;
	47
8fef0ff2	48	for (i = 0; i < ELEMENTSOF(skip); i++)
090be865	49	if (streq(name, skip[i]))
912541b0 KS	50	return true;
912541b0 KS	51	return false;
20bee04c KS	52	}
20bee04c KS	53
93b0f384	54	static void print_all_attributes(struct udev_device device, const char key)
be9b51f6	55	{
912541b0 KS	56	struct udev_list_entry *sysattr;
	57
	58	udev_list_entry_foreach(sysattr, udev_device_get_sysattr_list_entry(device)) {
	59	const char *name;
	60	const char *value;
	61	size_t len;
	62
	63	name = udev_list_entry_get_name(sysattr);
	64	if (skip_attribute(name))
	65	continue;
	66
	67	value = udev_device_get_sysattr_value(device, name);
	68	if (value == NULL)
	69	continue;
912541b0 KS	70
	71	/* skip any values that look like a path */
	72	if (value[0] == '/')
	73	continue;
	74
	75	/* skip nonprintable attributes */
	76	len = strlen(value);
	77	while (len > 0 && isprint(value[len-1]))
	78	len--;
baa30fbc	79	if (len > 0)
912541b0	80	continue;
912541b0 KS	81
	82	printf(" %s{%s}==\"%s\"\n", key, name, value);
	83	}
	84	printf("\n");
be9b51f6 KS	85	}
be9b51f6 KS	86
93b0f384	87	static int print_device_chain(struct udev_device *device)
87171e46	88	{
912541b0 KS	89	struct udev_device *device_parent;
	90	const char *str;
	91
	92	printf("\n"
	93	"Udevadm info starts with the device specified by the devpath and then\n"
	94	"walks up the chain of parent devices. It prints for every device\n"
	95	"found, all possible attributes in the udev rules key format.\n"
	96	"A rule to match, can be composed by the attributes of the device\n"
	97	"and the attributes from one single parent device.\n"
	98	"\n");
	99
	100	printf(" looking at device '%s':\n", udev_device_get_devpath(device));
	101	printf(" KERNEL==\"%s\"\n", udev_device_get_sysname(device));
	102	str = udev_device_get_subsystem(device);
	103	if (str == NULL)
	104	str = "";
	105	printf(" SUBSYSTEM==\"%s\"\n", str);
	106	str = udev_device_get_driver(device);
	107	if (str == NULL)
	108	str = "";
	109	printf(" DRIVER==\"%s\"\n", str);
	110	print_all_attributes(device, "ATTR");
	111
	112	device_parent = device;
	113	do {
	114	device_parent = udev_device_get_parent(device_parent);
	115	if (device_parent == NULL)
	116	break;
	117	printf(" looking at parent device '%s':\n", udev_device_get_devpath(device_parent));
	118	printf(" KERNELS==\"%s\"\n", udev_device_get_sysname(device_parent));
	119	str = udev_device_get_subsystem(device_parent);
	120	if (str == NULL)
	121	str = "";
	122	printf(" SUBSYSTEMS==\"%s\"\n", str);
	123	str = udev_device_get_driver(device_parent);
	124	if (str == NULL)
	125	str = "";
	126	printf(" DRIVERS==\"%s\"\n", str);
	127	print_all_attributes(device_parent, "ATTRS");
	128	} while (device_parent != NULL);
	129
	130	return 0;
1aa1e248 KS	131	}
1aa1e248 KS	132
93b0f384	133	static void print_record(struct udev_device *device)
31de3a2b	134	{
912541b0 KS	135	const char *str;
	136	int i;
	137	struct udev_list_entry *list_entry;
	138
	139	printf("P: %s\n", udev_device_get_devpath(device));
	140
912541b0 KS	141	str = udev_device_get_devnode(device);
912541b0 KS	142	if (str != NULL)
6ada823a	143	printf("N: %s\n", str + strlen("/dev/"));
912541b0 KS	144
	145	i = udev_device_get_devlink_priority(device);
	146	if (i != 0)
	147	printf("L: %i\n", i);
	148
6ada823a KS	149	udev_list_entry_foreach(list_entry, udev_device_get_devlinks_list_entry(device))
6ada823a KS	150	printf("S: %s\n", udev_list_entry_get_name(list_entry) + strlen("/dev/"));
912541b0 KS	151
	152	udev_list_entry_foreach(list_entry, udev_device_get_properties_list_entry(device))
	153	printf("E: %s=%s\n",
	154	udev_list_entry_get_name(list_entry),
	155	udev_list_entry_get_value(list_entry));
	156	printf("\n");
31de3a2b KS	157	}
31de3a2b KS	158
88163971	159	static int stat_device(const char name, bool export, const char prefix)
f338bac8	160	{
912541b0 KS	161	struct stat statbuf;
	162
	163	if (stat(name, &statbuf) != 0)
	164	return -1;
	165
	166	if (export) {
	167	if (prefix == NULL)
	168	prefix = "INFO_";
	169	printf("%sMAJOR=%d\n"
	170	"%sMINOR=%d\n",
	171	prefix, major(statbuf.st_dev),
	172	prefix, minor(statbuf.st_dev));
	173	} else
	174	printf("%d:%d\n", major(statbuf.st_dev), minor(statbuf.st_dev));
	175	return 0;
f338bac8 KS	176	}
f338bac8 KS	177
bf7ad0ea KS	178	static int export_devices(struct udev *udev)
bf7ad0ea KS	179	{
912541b0 KS	180	struct udev_enumerate *udev_enumerate;
	181	struct udev_list_entry *list_entry;
	182
	183	udev_enumerate = udev_enumerate_new(udev);
	184	if (udev_enumerate == NULL)
	185	return -1;
	186	udev_enumerate_scan_devices(udev_enumerate);
	187	udev_list_entry_foreach(list_entry, udev_enumerate_get_list_entry(udev_enumerate)) {
	188	struct udev_device *device;
	189
	190	device = udev_device_new_from_syspath(udev, udev_list_entry_get_name(list_entry));
	191	if (device != NULL) {
	192	print_record(device);
	193	udev_device_unref(device);
	194	}
	195	}
	196	udev_enumerate_unref(udev_enumerate);
	197	return 0;
bf7ad0ea KS	198	}
bf7ad0ea KS	199
9ead6627 KS	200	static void cleanup_dir(DIR *dir, mode_t mask, int depth)
9ead6627 KS	201	{
912541b0 KS	202	struct dirent *dent;
	203
	204	if (depth <= 0)
	205	return;
	206
	207	for (dent = readdir(dir); dent != NULL; dent = readdir(dir)) {
	208	struct stat stats;
	209
	210	if (dent->d_name[0] == '.')
	211	continue;
	212	if (fstatat(dirfd(dir), dent->d_name, &stats, AT_SYMLINK_NOFOLLOW) != 0)
	213	continue;
	214	if ((stats.st_mode & mask) != 0)
	215	continue;
	216	if (S_ISDIR(stats.st_mode)) {
	217	DIR *dir2;
	218
	219	dir2 = fdopendir(openat(dirfd(dir), dent->d_name, O_RDONLY\|O_NONBLOCK\|O_DIRECTORY\|O_CLOEXEC));
	220	if (dir2 != NULL) {
	221	cleanup_dir(dir2, mask, depth-1);
	222	closedir(dir2);
	223	}
	224	unlinkat(dirfd(dir), dent->d_name, AT_REMOVEDIR);
	225	} else {
	226	unlinkat(dirfd(dir), dent->d_name, 0);
	227	}
	228	}
9ead6627 KS	229	}
	230
	231	static void cleanup_db(struct udev *udev)
	232	{
912541b0 KS	233	DIR *dir;
912541b0 KS	234
6ada823a	235	unlink("/run/udev/queue.bin");
912541b0	236
6ada823a	237	dir = opendir("/run/udev/data");
912541b0 KS	238	if (dir != NULL) {
	239	cleanup_dir(dir, S_ISVTX, 1);
	240	closedir(dir);
	241	}
	242
6ada823a	243	dir = opendir("/run/udev/links");
912541b0 KS	244	if (dir != NULL) {
	245	cleanup_dir(dir, 0, 2);
	246	closedir(dir);
	247	}
	248
6ada823a	249	dir = opendir("/run/udev/tags");
912541b0 KS	250	if (dir != NULL) {
	251	cleanup_dir(dir, 0, 2);
	252	closedir(dir);
	253	}
	254
84b6ad70 TG	255	dir = opendir("/run/udev/static_node-tags");
	256	if (dir != NULL) {
	257	cleanup_dir(dir, 0, 2);
	258	closedir(dir);
	259	}
	260
6ada823a	261	dir = opendir("/run/udev/watch");
912541b0 KS	262	if (dir != NULL) {
	263	cleanup_dir(dir, 0, 1);
	264	closedir(dir);
	265	}
9ead6627 KS	266	}
9ead6627 KS	267
4f5d327a KS	268	static struct udev_device find_device(struct udev udev, const char id, const char prefix)
	269	{
	270	char name[UTIL_PATH_SIZE];
	271
	272	if (prefix && !startswith(id, prefix)) {
d5a89d7d	273	strscpyl(name, sizeof(name), prefix, id, NULL);
4f5d327a KS	274	id = name;
	275	}
	276
	277	if (startswith(id, "/dev/")) {
	278	struct stat statbuf;
	279	char type;
	280
	281	if (stat(id, &statbuf) < 0)
	282	return NULL;
	283
	284	if (S_ISBLK(statbuf.st_mode))
	285	type = 'b';
	286	else if (S_ISCHR(statbuf.st_mode))
	287	type = 'c';
	288	else
	289	return NULL;
	290
	291	return udev_device_new_from_devnum(udev, type, statbuf.st_rdev);
	292	} else if (startswith(id, "/sys/"))
	293	return udev_device_new_from_syspath(udev, id);
	294	else
	295	return NULL;
	296	}
	297
1985c76e	298	static int uinfo(struct udev udev, int argc, char argv[])
87171e46	299	{
44433ebd	300	_cleanup_udev_device_unref_ struct udev_device *device = NULL;
912541b0 KS	301	bool root = 0;
	302	bool export = 0;
	303	const char *export_prefix = NULL;
912541b0 KS	304	char name[UTIL_PATH_SIZE];
912541b0 KS	305	struct udev_list_entry *list_entry;
44433ebd	306	int c;
912541b0 KS	307
912541b0 KS	308	static const struct option options[] = {
7643ac9a ZJS	309	{ "name", required_argument, NULL, 'n' },
	310	{ "path", required_argument, NULL, 'p' },
	311	{ "query", required_argument, NULL, 'q' },
	312	{ "attribute-walk", no_argument, NULL, 'a' },
	313	{ "cleanup-db", no_argument, NULL, 'c' },
	314	{ "export-db", no_argument, NULL, 'e' },
	315	{ "root", no_argument, NULL, 'r' },
912541b0	316	{ "device-id-of-file", required_argument, NULL, 'd' },
7643ac9a ZJS	317	{ "export", no_argument, NULL, 'x' },
	318	{ "export-prefix", required_argument, NULL, 'P' },
	319	{ "version", no_argument, NULL, 'V' },
	320	{ "help", no_argument, NULL, 'h' },
912541b0 KS	321	{}
	322	};
	323
4f5d327a	324	static const char *usage =
7643ac9a ZJS	325	"Usage: udevadm info [OPTIONS] [DEVPATH\|FILE]\n"
7643ac9a ZJS	326	" -q,--query=TYPE query device information:\n"
4f5d327a KS	327	" name name of device node\n"
	328	" symlink pointing to node\n"
	329	" path sys device path\n"
	330	" property the device properties\n"
	331	" all all values\n"
7643ac9a ZJS	332	" -p,--path=SYSPATH sys device path used for query or attribute walk\n"
	333	" -n,--name=NAME node or symlink name used for query or attribute walk\n"
	334	" -r,--root prepend dev directory to path names\n"
	335	" -a,--attribute-walk print all key matches walking along the chain\n"
4f5d327a	336	" of parent devices\n"
7643ac9a ZJS	337	" -d,--device-id-of-file=FILE print major:minor of device containing this file\n"
	338	" -x,--export export key/value pairs\n"
	339	" -P,--export-prefix export the key name with a prefix\n"
	340	" -e,--export-db export the content of the udev database\n"
	341	" -c,--cleanup-db cleanup the udev database\n"
	342	" --version print version of the program\n"
	343	" -h,--help print this message\n";
4f5d327a	344
912541b0	345	enum action_type {
912541b0 KS	346	ACTION_QUERY,
912541b0 KS	347	ACTION_ATTRIBUTE_WALK,
912541b0	348	ACTION_DEVICE_ID_FILE,
4f5d327a	349	} action = ACTION_QUERY;
912541b0 KS	350
912541b0 KS	351	enum query_type {
912541b0 KS	352	QUERY_NAME,
	353	QUERY_PATH,
	354	QUERY_SYMLINK,
	355	QUERY_PROPERTY,
	356	QUERY_ALL,
4f5d327a	357	} query = QUERY_ALL;
912541b0	358
7643ac9a ZJS	359	while ((c = getopt_long(argc, argv, "aced:n:p:q:rxP:RVh", options, NULL)) >= 0)
7643ac9a ZJS	360	switch (c) {
4f5d327a	361	case 'n': {
912541b0 KS	362	if (device != NULL) {
912541b0 KS	363	fprintf(stderr, "device already specified\n");
44433ebd	364	return 2;
912541b0	365	}
4f5d327a KS	366
	367	device = find_device(udev, optarg, "/dev/");
	368	if (device == NULL) {
912541b0	369	fprintf(stderr, "device node not found\n");
44433ebd	370	return 2;
912541b0 KS	371	}
912541b0 KS	372	break;
4f5d327a	373	}
912541b0 KS	374	case 'p':
	375	if (device != NULL) {
	376	fprintf(stderr, "device already specified\n");
44433ebd	377	return 2;
912541b0	378	}
4f5d327a KS	379
4f5d327a KS	380	device = find_device(udev, optarg, "/sys");
912541b0	381	if (device == NULL) {
4f5d327a	382	fprintf(stderr, "syspath not found\n");
44433ebd	383	return 2;
912541b0 KS	384	}
	385	break;
	386	case 'q':
	387	action = ACTION_QUERY;
44433ebd	388	if (streq(optarg, "property") \|\| streq(optarg, "env"))
912541b0	389	query = QUERY_PROPERTY;
44433ebd	390	else if (streq(optarg, "name"))
912541b0	391	query = QUERY_NAME;
44433ebd	392	else if (streq(optarg, "symlink"))
912541b0	393	query = QUERY_SYMLINK;
44433ebd	394	else if (streq(optarg, "path"))
912541b0	395	query = QUERY_PATH;
44433ebd	396	else if (streq(optarg, "all"))
912541b0	397	query = QUERY_ALL;
44433ebd	398	else {
912541b0	399	fprintf(stderr, "unknown query type\n");
44433ebd	400	return 3;
912541b0 KS	401	}
	402	break;
	403	case 'r':
912541b0 KS	404	root = true;
912541b0 KS	405	break;
912541b0 KS	406	case 'd':
912541b0 KS	407	action = ACTION_DEVICE_ID_FILE;
d5a89d7d	408	strscpy(name, sizeof(name), optarg);
912541b0 KS	409	break;
	410	case 'a':
	411	action = ACTION_ATTRIBUTE_WALK;
	412	break;
	413	case 'e':
	414	export_devices(udev);
44433ebd	415	return 0;
912541b0 KS	416	case 'c':
912541b0 KS	417	cleanup_db(udev);
44433ebd	418	return 0;
912541b0 KS	419	case 'x':
	420	export = true;
	421	break;
	422	case 'P':
	423	export_prefix = optarg;
	424	break;
	425	case 'V':
	426	printf("%s\n", VERSION);
44433ebd	427	return 0;
912541b0	428	case 'h':
4f5d327a	429	printf("%s\n", usage);
44433ebd	430	return 0;
912541b0	431	default:
44433ebd	432	return 1;
912541b0	433	}
912541b0 KS	434
	435	switch (action) {
	436	case ACTION_QUERY:
4f5d327a KS	437	if (!device) {
	438	if (!argv[optind]) {
	439	fprintf(stderr, "%s\n", usage);
44433ebd	440	return 2;
4f5d327a KS	441	}
	442	device = find_device(udev, argv[optind], NULL);
	443	if (!device) {
	444	fprintf(stderr, "Unknown device, --name=, --path=, or absolute path in /dev/ or /sys expected.\n");
44433ebd	445	return 4;
4f5d327a	446	}
912541b0 KS	447	}
	448
	449	switch(query) {
	450	case QUERY_NAME: {
	451	const char *node = udev_device_get_devnode(device);
	452
	453	if (node == NULL) {
	454	fprintf(stderr, "no device node found\n");
44433ebd	455	return 5;
912541b0 KS	456	}
912541b0 KS	457
6ada823a	458	if (root)
912541b0	459	printf("%s\n", udev_device_get_devnode(device));
6ada823a KS	460	else
6ada823a KS	461	printf("%s\n", udev_device_get_devnode(device) + strlen("/dev/"));
912541b0 KS	462	break;
	463	}
	464	case QUERY_SYMLINK:
	465	list_entry = udev_device_get_devlinks_list_entry(device);
	466	while (list_entry != NULL) {
6ada823a	467	if (root)
912541b0	468	printf("%s", udev_list_entry_get_name(list_entry));
6ada823a KS	469	else
6ada823a KS	470	printf("%s", udev_list_entry_get_name(list_entry) + strlen("/dev/"));
912541b0 KS	471	list_entry = udev_list_entry_get_next(list_entry);
	472	if (list_entry != NULL)
	473	printf(" ");
	474	}
	475	printf("\n");
	476	break;
	477	case QUERY_PATH:
	478	printf("%s\n", udev_device_get_devpath(device));
44433ebd	479	return 0;
912541b0 KS	480	case QUERY_PROPERTY:
	481	list_entry = udev_device_get_properties_list_entry(device);
	482	while (list_entry != NULL) {
	483	if (export) {
	484	const char *prefix = export_prefix;
	485
	486	if (prefix == NULL)
	487	prefix = "";
	488	printf("%s%s='%s'\n", prefix,
	489	udev_list_entry_get_name(list_entry),
	490	udev_list_entry_get_value(list_entry));
	491	} else {
	492	printf("%s=%s\n", udev_list_entry_get_name(list_entry), udev_list_entry_get_value(list_entry));
	493	}
	494	list_entry = udev_list_entry_get_next(list_entry);
	495	}
	496	break;
	497	case QUERY_ALL:
	498	print_record(device);
	499	break;
	500	default:
bdd13f6b	501	assert_not_reached("unknown query type");
912541b0 KS	502	}
	503	break;
	504	case ACTION_ATTRIBUTE_WALK:
4f5d327a KS	505	if (!device && argv[optind]) {
	506	device = find_device(udev, argv[optind], NULL);
	507	if (!device) {
	508	fprintf(stderr, "Unknown device, absolute path in /dev/ or /sys expected.\n");
44433ebd	509	return 4;
4f5d327a KS	510	}
	511	}
	512	if (!device) {
	513	fprintf(stderr, "Unknown device, --name=, --path=, or absolute path in /dev/ or /sys expected.\n");
44433ebd	514	return 4;
912541b0 KS	515	}
	516	print_device_chain(device);
	517	break;
	518	case ACTION_DEVICE_ID_FILE:
	519	if (stat_device(name, export, export_prefix) != 0)
44433ebd	520	return 1;
912541b0	521	break;
912541b0	522	}
87171e46	523
44433ebd	524	return 0;
87171e46	525	}
1985c76e KS	526
1985c76e KS	527	const struct udevadm_cmd udevadm_info = {
912541b0 KS	528	.name = "info",
	529	.cmd = uinfo,
	530	.help = "query sysfs or the udev database",
1985c76e	531	};