Home | History | Annotate | Download | only in blkid
      1 /*
      2  * cache.c - allocation/initialization/free routines for cache
      3  *
      4  * Copyright (C) 2001 Andreas Dilger
      5  * Copyright (C) 2003 Theodore Ts'o
      6  *
      7  * %Begin-Header%
      8  * This file may be redistributed under the terms of the
      9  * GNU Lesser General Public License.
     10  * %End-Header%
     11  */
     12 
     13 #if HAVE_UNISTD_H
     14 #include <unistd.h>
     15 #endif
     16 #ifdef HAVE_ERRNO_H
     17 #include <errno.h>
     18 #endif
     19 #include <stdlib.h>
     20 #include <string.h>
     21 #ifdef HAVE_SYS_PRCTL_H
     22 #include <sys/prctl.h>
     23 #else
     24 #define PR_GET_DUMPABLE 3
     25 #endif
     26 #if (!defined(HAVE_PRCTL) && defined(linux))
     27 #include <sys/syscall.h>
     28 #endif
     29 #ifdef HAVE_SYS_STAT_H
     30 #include <sys/stat.h>
     31 #endif
     32 #include "blkidP.h"
     33 
     34 int blkid_debug_mask = 0;
     35 
     36 
     37 static char *safe_getenv(const char *arg)
     38 {
     39 	if ((getuid() != geteuid()) || (getgid() != getegid()))
     40 		return NULL;
     41 #if HAVE_PRCTL
     42 	if (prctl(PR_GET_DUMPABLE, 0, 0, 0, 0) == 0)
     43 		return NULL;
     44 #else
     45 #if (defined(linux) && defined(SYS_prctl))
     46 	if (syscall(SYS_prctl, PR_GET_DUMPABLE, 0, 0, 0, 0) == 0)
     47 		return NULL;
     48 #endif
     49 #endif
     50 
     51 #ifdef HAVE___SECURE_GETENV
     52 	return __secure_getenv(arg);
     53 #else
     54 	return getenv(arg);
     55 #endif
     56 }
     57 
     58 #if 0 /* ifdef CONFIG_BLKID_DEBUG */
     59 static blkid_debug_dump_cache(int mask, blkid_cache cache)
     60 {
     61 	struct list_head *p;
     62 
     63 	if (!cache) {
     64 		printf("cache: NULL\n");
     65 		return;
     66 	}
     67 
     68 	printf("cache: time = %lu\n", cache->bic_time);
     69 	printf("cache: flags = 0x%08X\n", cache->bic_flags);
     70 
     71 	list_for_each(p, &cache->bic_devs) {
     72 		blkid_dev dev = list_entry(p, struct blkid_struct_dev, bid_devs);
     73 		blkid_debug_dump_dev(dev);
     74 	}
     75 }
     76 #endif
     77 
     78 int blkid_get_cache(blkid_cache *ret_cache, const char *filename)
     79 {
     80 	blkid_cache cache;
     81 
     82 #ifdef CONFIG_BLKID_DEBUG
     83 	if (!(blkid_debug_mask & DEBUG_INIT)) {
     84 		char *dstr = getenv("BLKID_DEBUG");
     85 
     86 		if (dstr)
     87 			blkid_debug_mask = strtoul(dstr, 0, 0);
     88 		blkid_debug_mask |= DEBUG_INIT;
     89 	}
     90 #endif
     91 
     92 	DBG(DEBUG_CACHE, printf("creating blkid cache (using %s)\n",
     93 				filename ? filename : "default cache"));
     94 
     95 	if (!(cache = (blkid_cache) calloc(1, sizeof(struct blkid_struct_cache))))
     96 		return -BLKID_ERR_MEM;
     97 
     98 	INIT_LIST_HEAD(&cache->bic_devs);
     99 	INIT_LIST_HEAD(&cache->bic_tags);
    100 
    101 	if (filename && !strlen(filename))
    102 		filename = 0;
    103 	if (!filename)
    104 		filename = safe_getenv("BLKID_FILE");
    105 	if (!filename)
    106 		filename = BLKID_CACHE_FILE;
    107 	cache->bic_filename = blkid_strdup(filename);
    108 
    109 	blkid_read_cache(cache);
    110 
    111 	*ret_cache = cache;
    112 	return 0;
    113 }
    114 
    115 void blkid_put_cache(blkid_cache cache)
    116 {
    117 	if (!cache)
    118 		return;
    119 
    120 	(void) blkid_flush_cache(cache);
    121 
    122 	DBG(DEBUG_CACHE, printf("freeing cache struct\n"));
    123 
    124 	/* DBG(DEBUG_CACHE, blkid_debug_dump_cache(cache)); */
    125 
    126 	while (!list_empty(&cache->bic_devs)) {
    127 		blkid_dev dev = list_entry(cache->bic_devs.next,
    128 					   struct blkid_struct_dev,
    129 					    bid_devs);
    130 		blkid_free_dev(dev);
    131 	}
    132 
    133 	while (!list_empty(&cache->bic_tags)) {
    134 		blkid_tag tag = list_entry(cache->bic_tags.next,
    135 					   struct blkid_struct_tag,
    136 					   bit_tags);
    137 
    138 		while (!list_empty(&tag->bit_names)) {
    139 			blkid_tag bad = list_entry(tag->bit_names.next,
    140 						   struct blkid_struct_tag,
    141 						   bit_names);
    142 
    143 			DBG(DEBUG_CACHE, printf("warning: unfreed tag %s=%s\n",
    144 						bad->bit_name, bad->bit_val));
    145 			blkid_free_tag(bad);
    146 		}
    147 		blkid_free_tag(tag);
    148 	}
    149 	free(cache->bic_filename);
    150 
    151 	free(cache);
    152 }
    153 
    154 void blkid_gc_cache(blkid_cache cache)
    155 {
    156 	struct list_head *p, *pnext;
    157 	struct stat st;
    158 
    159 	if (!cache)
    160 		return;
    161 
    162 	list_for_each_safe(p, pnext, &cache->bic_devs) {
    163 		blkid_dev dev = list_entry(p, struct blkid_struct_dev, bid_devs);
    164 		if (!p)
    165 			break;
    166 		if (stat(dev->bid_name, &st) < 0) {
    167 			DBG(DEBUG_CACHE,
    168 			    printf("freeing %s\n", dev->bid_name));
    169 			blkid_free_dev(dev);
    170 			cache->bic_flags |= BLKID_BIC_FL_CHANGED;
    171 		} else {
    172 			DBG(DEBUG_CACHE,
    173 			    printf("Device %s exists\n", dev->bid_name));
    174 		}
    175 	}
    176 }
    177 
    178 
    179 #ifdef TEST_PROGRAM
    180 int main(int argc, char** argv)
    181 {
    182 	blkid_cache cache = NULL;
    183 	int ret;
    184 
    185 	blkid_debug_mask = DEBUG_ALL;
    186 	if ((argc > 2)) {
    187 		fprintf(stderr, "Usage: %s [filename] \n", argv[0]);
    188 		exit(1);
    189 	}
    190 
    191 	if ((ret = blkid_get_cache(&cache, argv[1])) < 0) {
    192 		fprintf(stderr, "error %d parsing cache file %s\n", ret,
    193 			argv[1] ? argv[1] : BLKID_CACHE_FILE);
    194 		exit(1);
    195 	}
    196 	if ((ret = blkid_get_cache(&cache, "/dev/null")) != 0) {
    197 		fprintf(stderr, "%s: error creating cache (%d)\n",
    198 			argv[0], ret);
    199 		exit(1);
    200 	}
    201 	if ((ret = blkid_probe_all(cache) < 0))
    202 		fprintf(stderr, "error probing devices\n");
    203 
    204 	blkid_put_cache(cache);
    205 
    206 	return ret;
    207 }
    208 #endif
    209