Home | History | Annotate | Download | only in blkid 
      1 /*
      2  * devname.c - get a dev by its device inode name
      3  *
      4  * Copyright (C) Andries Brouwer
      5  * Copyright (C) 1999, 2000, 2001, 2002, 2003 Theodore Ts'o
      6  * Copyright (C) 2001 Andreas Dilger
      7  *
      8  * %Begin-Header%
      9  * This file may be redistributed under the terms of the
     10  * GNU Lesser General Public License.
     11  * %End-Header%
     12  */
     13 
     14 #define _GNU_SOURCE 1
     15 
     16 #include <stdio.h>
     17 #include <string.h>
     18 #include <limits.h>
     19 #if HAVE_UNISTD_H
     20 #include <unistd.h>
     21 #endif
     22 #include <stdlib.h>
     23 #include <string.h>
     24 #include <ctype.h>
     25 #if HAVE_SYS_TYPES_H
     26 #include <sys/types.h>
     27 #endif
     28 #include <dirent.h>
     29 #if HAVE_SYS_STAT_H
     30 #include <sys/stat.h>
     31 #endif
     32 #if HAVE_ERRNO_H
     33 #include <errno.h>
     34 #endif
     35 #if HAVE_SYS_MKDEV_H
     36 #include <sys/mkdev.h>
     37 #endif
     38 #include <time.h>
     39 
     40 #include "blkidP.h"
     41 
     42 /*
     43  * Find a dev struct in the cache by device name, if available.
     44  *
     45  * If there is no entry with the specified device name, and the create
     46  * flag is set, then create an empty device entry.
     47  */
     48 blkid_dev blkid_get_dev(blkid_cache cache, const char *devname, int flags)
     49 {
     50 	blkid_dev dev = NULL, tmp;
     51 	struct list_head *p, *pnext;
     52 
     53 	if (!cache || !devname)
     54 		return NULL;
     55 
     56 	list_for_each(p, &cache->bic_devs) {
     57 		tmp = list_entry(p, struct blkid_struct_dev, bid_devs);
     58 		if (strcmp(tmp->bid_name, devname))
     59 			continue;
     60 
     61 		DBG(DEBUG_DEVNAME,
     62 		    printf("found devname %s in cache\n", tmp->bid_name));
     63 		dev = tmp;
     64 		break;
     65 	}
     66 
     67 	if (!dev && (flags & BLKID_DEV_CREATE)) {
     68 		if (access(devname, F_OK) < 0)
     69 			return NULL;
     70 		dev = blkid_new_dev();
     71 		if (!dev)
     72 			return NULL;
     73 		dev->bid_time = INT_MIN;
     74 		dev->bid_name = blkid_strdup(devname);
     75 		dev->bid_cache = cache;
     76 		list_add_tail(&dev->bid_devs, &cache->bic_devs);
     77 		cache->bic_flags |= BLKID_BIC_FL_CHANGED;
     78 	}
     79 
     80 	if (flags & BLKID_DEV_VERIFY) {
     81 		dev = blkid_verify(cache, dev);
     82 		if (!dev || !(dev->bid_flags & BLKID_BID_FL_VERIFIED))
     83 			return dev;
     84 		/*
     85 		 * If the device is verified, then search the blkid
     86 		 * cache for any entries that match on the type, uuid,
     87 		 * and label, and verify them; if a cache entry can
     88 		 * not be verified, then it's stale and so we remove
     89 		 * it.
     90 		 */
     91 		list_for_each_safe(p, pnext, &cache->bic_devs) {
     92 			blkid_dev dev2;
     93 			if (!p)
     94 				break;
     95 			dev2 = list_entry(p, struct blkid_struct_dev, bid_devs);
     96 			if (dev2->bid_flags & BLKID_BID_FL_VERIFIED)
     97 				continue;
     98 			if (!dev->bid_type || !dev2->bid_type ||
     99 			    strcmp(dev->bid_type, dev2->bid_type))
    100 				continue;
    101 			if (dev->bid_label && dev2->bid_label &&
    102 			    strcmp(dev->bid_label, dev2->bid_label))
    103 				continue;
    104 			if (dev->bid_uuid && dev2->bid_uuid &&
    105 			    strcmp(dev->bid_uuid, dev2->bid_uuid))
    106 				continue;
    107 			if ((dev->bid_label && !dev2->bid_label) ||
    108 			    (!dev->bid_label && dev2->bid_label) ||
    109 			    (dev->bid_uuid && !dev2->bid_uuid) ||
    110 			    (!dev->bid_uuid && dev2->bid_uuid))
    111 				continue;
    112 			dev2 = blkid_verify(cache, dev2);
    113 			if (dev2 && !(dev2->bid_flags & BLKID_BID_FL_VERIFIED))
    114 				blkid_free_dev(dev2);
    115 		}
    116 	}
    117 	return dev;
    118 }
    119 
    120 /* Directories where we will try to search for device names */
    121 static const char *dirlist[] = { "/dev", "/devfs", "/devices", NULL };
    122 
    123 static int is_dm_leaf(const char *devname)
    124 {
    125 	struct dirent	*de, *d_de;
    126 	DIR		*dir, *d_dir;
    127 	char		path[256];
    128 	int		ret = 1;
    129 
    130 	if ((dir = opendir("/sys/block")) == NULL)
    131 		return 0;
    132 	while ((de = readdir(dir)) != NULL) {
    133 		if (!strcmp(de->d_name, ".") || !strcmp(de->d_name, "..") ||
    134 		    !strcmp(de->d_name, devname) ||
    135 		    strncmp(de->d_name, "dm-", 3) ||
    136 		    strlen(de->d_name) > sizeof(path)-32)
    137 			continue;
    138 		sprintf(path, "/sys/block/%s/slaves", de->d_name);
    139 		if ((d_dir = opendir(path)) == NULL)
    140 			continue;
    141 		while ((d_de = readdir(d_dir)) != NULL) {
    142 			if (!strcmp(d_de->d_name, devname)) {
    143 				ret = 0;
    144 				break;
    145 			}
    146 		}
    147 		closedir(d_dir);
    148 		if (!ret)
    149 			break;
    150 	}
    151 	closedir(dir);
    152 	return ret;
    153 }
    154 
    155 /*
    156  * Since 2.6.29 (patch 784aae735d9b0bba3f8b9faef4c8b30df3bf0128) kernel sysfs
    157  * provides the real DM device names in /sys/block/<ptname>/dm/name
    158  */
    159 static char *get_dm_name(const char *ptname)
    160 {
    161 	FILE	*f;
    162 	size_t	sz;
    163 	char	path[256], name[256], *res = NULL;
    164 
    165 	snprintf(path, sizeof(path), "/sys/block/%s/dm/name", ptname);
    166 	if ((f = fopen(path, "r")) == NULL)
    167 		return NULL;
    168 
    169 	/* read "<name>\n" from sysfs */
    170 	if (fgets(name, sizeof(name), f) && (sz = strlen(name)) > 1) {
    171 		name[sz - 1] = '\0';
    172 		snprintf(path, sizeof(path), "/dev/mapper/%s", name);
    173 		res = blkid_strdup(path);
    174 	}
    175 	fclose(f);
    176 	return res;
    177 }
    178 
    179 /*
    180  * Probe a single block device to add to the device cache.
    181  */
    182 static void probe_one(blkid_cache cache, const char *ptname,
    183 		      dev_t devno, int pri, int only_if_new)
    184 {
    185 	blkid_dev dev = NULL;
    186 	struct list_head *p, *pnext;
    187 	const char **dir;
    188 	char *devname = NULL;
    189 
    190 	/* See if we already have this device number in the cache. */
    191 	list_for_each_safe(p, pnext, &cache->bic_devs) {
    192 		blkid_dev tmp = list_entry(p, struct blkid_struct_dev,
    193 					   bid_devs);
    194 		if (tmp->bid_devno == devno) {
    195 			if (only_if_new && !access(tmp->bid_name, F_OK))
    196 				return;
    197 			dev = blkid_verify(cache, tmp);
    198 			if (dev && (dev->bid_flags & BLKID_BID_FL_VERIFIED))
    199 				break;
    200 			dev = 0;
    201 		}
    202 	}
    203 	if (dev && dev->bid_devno == devno)
    204 		goto set_pri;
    205 
    206 	/* Try to translate private device-mapper dm-<N> names
    207 	 * to standard /dev/mapper/<name>.
    208 	 */
    209 	if (!strncmp(ptname, "dm-", 3) && isdigit(ptname[3])) {
    210 		devname = get_dm_name(ptname);
    211 		if (!devname)
    212 			blkid__scan_dir("/dev/mapper", devno, 0, &devname);
    213 		if (devname)
    214 			goto get_dev;
    215 	}
    216 
    217 	/*
    218 	 * Take a quick look at /dev/ptname for the device number.  We check
    219 	 * all of the likely device directories.  If we don't find it, or if
    220 	 * the stat information doesn't check out, use blkid_devno_to_devname()
    221 	 * to find it via an exhaustive search for the device major/minor.
    222 	 */
    223 	for (dir = dirlist; *dir; dir++) {
    224 		struct stat st;
    225 		char device[256];
    226 
    227 		sprintf(device, "%s/%s", *dir, ptname);
    228 		if ((dev = blkid_get_dev(cache, device, BLKID_DEV_FIND)) &&
    229 		    dev->bid_devno == devno)
    230 			goto set_pri;
    231 
    232 		if (stat(device, &st) == 0 && S_ISBLK(st.st_mode) &&
    233 		    st.st_rdev == devno) {
    234 			devname = blkid_strdup(device);
    235 			goto get_dev;
    236 		}
    237 	}
    238 	/* Do a short-cut scan of /dev/mapper first */
    239 	if (!devname)
    240 		devname = get_dm_name(ptname);
    241 	if (!devname)
    242 		blkid__scan_dir("/dev/mapper", devno, 0, &devname);
    243 	if (!devname) {
    244 		devname = blkid_devno_to_devname(devno);
    245 		if (!devname)
    246 			return;
    247 	}
    248 get_dev:
    249 	dev = blkid_get_dev(cache, devname, BLKID_DEV_NORMAL);
    250 	free(devname);
    251 set_pri:
    252 	if (dev) {
    253 		if (pri)
    254 			dev->bid_pri = pri;
    255 		else if (!strncmp(dev->bid_name, "/dev/mapper/", 11)) {
    256 			dev->bid_pri = BLKID_PRI_DM;
    257 			if (is_dm_leaf(ptname))
    258 				dev->bid_pri += 5;
    259 		} else if (!strncmp(ptname, "md", 2))
    260 			dev->bid_pri = BLKID_PRI_MD;
    261  	}
    262 	return;
    263 }
    264 
    265 #define PROC_PARTITIONS "/proc/partitions"
    266 #define VG_DIR		"/proc/lvm/VGs"
    267 
    268 /*
    269  * This function initializes the UUID cache with devices from the LVM
    270  * proc hierarchy.  We currently depend on the names of the LVM
    271  * hierarchy giving us the device structure in /dev.  (XXX is this a
    272  * safe thing to do?)
    273  */
    274 #ifdef VG_DIR
    275 static dev_t lvm_get_devno(const char *lvm_device)
    276 {
    277 	FILE *lvf;
    278 	char buf[1024];
    279 	int ma, mi;
    280 	dev_t ret = 0;
    281 
    282 	DBG(DEBUG_DEVNAME, printf("opening %s\n", lvm_device));
    283 	if ((lvf = fopen(lvm_device, "r")) == NULL) {
    284 		DBG(DEBUG_DEVNAME, printf("%s: (%d) %s\n", lvm_device, errno,
    285 					  strerror(errno)));
    286 		return 0;
    287 	}
    288 
    289 	while (fgets(buf, sizeof(buf), lvf)) {
    290 		if (sscanf(buf, "device: %d:%d", &ma, &mi) == 2) {
    291 			ret = makedev(ma, mi);
    292 			break;
    293 		}
    294 	}
    295 	fclose(lvf);
    296 
    297 	return ret;
    298 }
    299 
    300 static void lvm_probe_all(blkid_cache cache, int only_if_new)
    301 {
    302 	DIR		*vg_list;
    303 	struct dirent	*vg_iter;
    304 	int		vg_len = strlen(VG_DIR);
    305 	dev_t		dev;
    306 
    307 	if ((vg_list = opendir(VG_DIR)) == NULL)
    308 		return;
    309 
    310 	DBG(DEBUG_DEVNAME, printf("probing LVM devices under %s\n", VG_DIR));
    311 
    312 	while ((vg_iter = readdir(vg_list)) != NULL) {
    313 		DIR		*lv_list;
    314 		char		*vdirname;
    315 		char		*vg_name;
    316 		struct dirent	*lv_iter;
    317 
    318 		vg_name = vg_iter->d_name;
    319 		if (!strcmp(vg_name, ".") || !strcmp(vg_name, ".."))
    320 			continue;
    321 		vdirname = malloc(vg_len + strlen(vg_name) + 8);
    322 		if (!vdirname)
    323 			goto exit;
    324 		sprintf(vdirname, "%s/%s/LVs", VG_DIR, vg_name);
    325 
    326 		lv_list = opendir(vdirname);
    327 		free(vdirname);
    328 		if (lv_list == NULL)
    329 			continue;
    330 
    331 		while ((lv_iter = readdir(lv_list)) != NULL) {
    332 			char		*lv_name, *lvm_device;
    333 
    334 			lv_name = lv_iter->d_name;
    335 			if (!strcmp(lv_name, ".") || !strcmp(lv_name, ".."))
    336 				continue;
    337 
    338 			lvm_device = malloc(vg_len + strlen(vg_name) +
    339 					    strlen(lv_name) + 8);
    340 			if (!lvm_device) {
    341 				closedir(lv_list);
    342 				goto exit;
    343 			}
    344 			sprintf(lvm_device, "%s/%s/LVs/%s", VG_DIR, vg_name,
    345 				lv_name);
    346 			dev = lvm_get_devno(lvm_device);
    347 			sprintf(lvm_device, "%s/%s", vg_name, lv_name);
    348 			DBG(DEBUG_DEVNAME, printf("LVM dev %s: devno 0x%04X\n",
    349 						  lvm_device,
    350 						  (unsigned int) dev));
    351 			probe_one(cache, lvm_device, dev, BLKID_PRI_LVM,
    352 				  only_if_new);
    353 			free(lvm_device);
    354 		}
    355 		closedir(lv_list);
    356 	}
    357 exit:
    358 	closedir(vg_list);
    359 }
    360 #endif
    361 
    362 #define PROC_EVMS_VOLUMES "/proc/evms/volumes"
    363 
    364 static int
    365 evms_probe_all(blkid_cache cache, int only_if_new)
    366 {
    367 	char line[100];
    368 	int ma, mi, sz, num = 0;
    369 	FILE *procpt;
    370 	char device[110];
    371 
    372 	procpt = fopen(PROC_EVMS_VOLUMES, "r");
    373 	if (!procpt)
    374 		return 0;
    375 	while (fgets(line, sizeof(line), procpt)) {
    376 		if (sscanf (line, " %d %d %d %*s %*s %[^\n ]",
    377 			    &ma, &mi, &sz, device) != 4)
    378 			continue;
    379 
    380 		DBG(DEBUG_DEVNAME, printf("Checking partition %s (%d, %d)\n",
    381 					  device, ma, mi));
    382 
    383 		probe_one(cache, device, makedev(ma, mi), BLKID_PRI_EVMS,
    384 			  only_if_new);
    385 		num++;
    386 	}
    387 	fclose(procpt);
    388 	return num;
    389 }
    390 
    391 /*
    392  * Read the device data for all available block devices in the system.
    393  */
    394 static int probe_all(blkid_cache cache, int only_if_new)
    395 {
    396 	FILE *proc;
    397 	char line[1024];
    398 	char ptname0[128], ptname1[128], *ptname = 0;
    399 	char *ptnames[2];
    400 	dev_t devs[2];
    401 	int ma, mi;
    402 	unsigned long long sz;
    403 	int lens[2] = { 0, 0 };
    404 	int which = 0, last = 0;
    405 	struct list_head *p, *pnext;
    406 
    407 	ptnames[0] = ptname0;
    408 	ptnames[1] = ptname1;
    409 
    410 	if (!cache)
    411 		return -BLKID_ERR_PARAM;
    412 
    413 	if (cache->bic_flags & BLKID_BIC_FL_PROBED &&
    414 	    time(0) - cache->bic_time < BLKID_PROBE_INTERVAL)
    415 		return 0;
    416 
    417 	blkid_read_cache(cache);
    418 	evms_probe_all(cache, only_if_new);
    419 #ifdef VG_DIR
    420 	lvm_probe_all(cache, only_if_new);
    421 #endif
    422 
    423 	proc = fopen(PROC_PARTITIONS, "r");
    424 	if (!proc)
    425 		return -BLKID_ERR_PROC;
    426 
    427 	while (fgets(line, sizeof(line), proc)) {
    428 		last = which;
    429 		which ^= 1;
    430 		ptname = ptnames[which];
    431 
    432 		if (sscanf(line, " %d %d %llu %128[^\n ]",
    433 			   &ma, &mi, &sz, ptname) != 4)
    434 			continue;
    435 		devs[which] = makedev(ma, mi);
    436 
    437 		DBG(DEBUG_DEVNAME, printf("read partition name %s\n", ptname));
    438 
    439 		/* Skip whole disk devs unless they have no partitions.
    440 		 * If base name of device has changed, also
    441 		 * check previous dev to see if it didn't have a partn.
    442 		 * heuristic: partition name ends in a digit, & partition
    443 		 * names contain whole device name as substring.
    444 		 *
    445 		 * Skip extended partitions.
    446 		 * heuristic: size is 1
    447 		 *
    448 		 * FIXME: skip /dev/{ida,cciss,rd} whole-disk devs
    449 		 */
    450 
    451 		lens[which] = strlen(ptname);
    452 
    453 		/* ends in a digit, clearly a partition, so check */
    454 		if (isdigit(ptname[lens[which] - 1])) {
    455 			DBG(DEBUG_DEVNAME,
    456 			    printf("partition dev %s, devno 0x%04X\n",
    457 				   ptname, (unsigned int) devs[which]));
    458 
    459 			if (sz > 1)
    460 				probe_one(cache, ptname, devs[which], 0,
    461 					  only_if_new);
    462 			lens[which] = 0;	/* mark as checked */
    463 		}
    464 
    465 		/*
    466 		 * If last was a whole disk and we just found a partition
    467 		 * on it, remove the whole-disk dev from the cache if
    468 		 * it exists.
    469 		 */
    470 		if (lens[last] && !strncmp(ptnames[last], ptname, lens[last])) {
    471 			list_for_each_safe(p, pnext, &cache->bic_devs) {
    472 				blkid_dev tmp;
    473 
    474 				/* find blkid dev for the whole-disk devno */
    475 				tmp = list_entry(p, struct blkid_struct_dev,
    476 						 bid_devs);
    477 				if (tmp->bid_devno == devs[last]) {
    478 					DBG(DEBUG_DEVNAME,
    479 						printf("freeing %s\n",
    480 						       tmp->bid_name));
    481 					blkid_free_dev(tmp);
    482 					cache->bic_flags |= BLKID_BIC_FL_CHANGED;
    483 					break;
    484 				}
    485 			}
    486 			lens[last] = 0;
    487 		}
    488 		/*
    489 		 * If last was not checked because it looked like a whole-disk
    490 		 * dev, and the device's base name has changed,
    491 		 * check last as well.
    492 		 */
    493 		if (lens[last] && strncmp(ptnames[last], ptname, lens[last])) {
    494 			DBG(DEBUG_DEVNAME,
    495 			    printf("whole dev %s, devno 0x%04X\n",
    496 				   ptnames[last], (unsigned int) devs[last]));
    497 			probe_one(cache, ptnames[last], devs[last], 0,
    498 				  only_if_new);
    499 			lens[last] = 0;
    500 		}
    501 	}
    502 
    503 	/* Handle the last device if it wasn't partitioned */
    504 	if (lens[which])
    505 		probe_one(cache, ptname, devs[which], 0, only_if_new);
    506 
    507 	fclose(proc);
    508 	blkid_flush_cache(cache);
    509 	return 0;
    510 }
    511 
    512 int blkid_probe_all(blkid_cache cache)
    513 {
    514 	int ret;
    515 
    516 	DBG(DEBUG_PROBE, printf("Begin blkid_probe_all()\n"));
    517 	ret = probe_all(cache, 0);
    518 	cache->bic_time = time(0);
    519 	cache->bic_flags |= BLKID_BIC_FL_PROBED;
    520 	DBG(DEBUG_PROBE, printf("End blkid_probe_all()\n"));
    521 	return ret;
    522 }
    523 
    524 int blkid_probe_all_new(blkid_cache cache)
    525 {
    526 	int ret;
    527 
    528 	DBG(DEBUG_PROBE, printf("Begin blkid_probe_all_new()\n"));
    529 	ret = probe_all(cache, 1);
    530 	DBG(DEBUG_PROBE, printf("End blkid_probe_all_new()\n"));
    531 	return ret;
    532 }
    533 
    534 
    535 #ifdef TEST_PROGRAM
    536 int main(int argc, char **argv)
    537 {
    538 	blkid_cache cache = NULL;
    539 	int ret;
    540 
    541 	blkid_debug_mask = DEBUG_ALL;
    542 	if (argc != 1) {
    543 		fprintf(stderr, "Usage: %s\n"
    544 			"Probe all devices and exit\n", argv[0]);
    545 		exit(1);
    546 	}
    547 	if ((ret = blkid_get_cache(&cache, "/dev/null")) != 0) {
    548 		fprintf(stderr, "%s: error creating cache (%d)\n",
    549 			argv[0], ret);
    550 		exit(1);
    551 	}
    552 	if (blkid_probe_all(cache) < 0)
    553 		printf("%s: error probing devices\n", argv[0]);
    554 
    555 	blkid_put_cache(cache);
    556 	return (0);
    557 }
    558 #endif
    559