1 /* $NetBSD: filter-persistent.c,v 1.1.1.2 2009/12/02 00:26:46 haad Exp $ */ 2 3 /* 4 * Copyright (C) 2001-2004 Sistina Software, Inc. All rights reserved. 5 * Copyright (C) 2004-2007 Red Hat, Inc. All rights reserved. 6 * 7 * This file is part of LVM2. 8 * 9 * This copyrighted material is made available to anyone wishing to use, 10 * modify, copy, or redistribute it subject to the terms and conditions 11 * of the GNU Lesser General Public License v.2.1. 12 * 13 * You should have received a copy of the GNU Lesser General Public License 14 * along with this program; if not, write to the Free Software Foundation, 15 * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 16 */ 17 18 #include "lib.h" 19 #include "config.h" 20 #include "dev-cache.h" 21 #include "filter-persistent.h" 22 #include "lvm-file.h" 23 #include "lvm-string.h" 24 25 #include <sys/stat.h> 26 #include <fcntl.h> 27 #include <unistd.h> 28 29 struct pfilter { 30 char *file; 31 struct dm_hash_table *devices; 32 struct dev_filter *real; 33 time_t ctime; 34 }; 35 36 /* 37 * The hash table holds one of these two states 38 * against each entry. 39 */ 40 #define PF_BAD_DEVICE ((void *) 1) 41 #define PF_GOOD_DEVICE ((void *) 2) 42 43 static int _init_hash(struct pfilter *pf) 44 { 45 if (pf->devices) 46 dm_hash_destroy(pf->devices); 47 48 if (!(pf->devices = dm_hash_create(128))) 49 return_0; 50 51 return 1; 52 } 53 54 int persistent_filter_wipe(struct dev_filter *f) 55 { 56 struct pfilter *pf = (struct pfilter *) f->private; 57 58 log_verbose("Wiping cache of LVM-capable devices"); 59 dm_hash_wipe(pf->devices); 60 61 /* Trigger complete device scan */ 62 dev_cache_scan(1); 63 64 return 1; 65 } 66 67 static int _read_array(struct pfilter *pf, struct config_tree *cft, 68 const char *path, void *data) 69 { 70 const struct config_node *cn; 71 struct config_value *cv; 72 73 if (!(cn = find_config_node(cft->root, path))) { 74 log_very_verbose("Couldn't find %s array in '%s'", 75 path, pf->file); 76 return 0; 77 } 78 79 /* 80 * iterate through the array, adding 81 * devices as we go. 82 */ 83 for (cv = cn->v; cv; cv = cv->next) { 84 if (cv->type != CFG_STRING) { 85 log_verbose("Devices array contains a value " 86 "which is not a string ... ignoring"); 87 continue; 88 } 89 90 if (!dm_hash_insert(pf->devices, cv->v.str, data)) 91 log_verbose("Couldn't add '%s' to filter ... ignoring", 92 cv->v.str); 93 /* Populate dev_cache ourselves */ 94 dev_cache_get(cv->v.str, NULL); 95 } 96 return 1; 97 } 98 99 int persistent_filter_load(struct dev_filter *f, struct config_tree **cft_out) 100 { 101 struct pfilter *pf = (struct pfilter *) f->private; 102 struct config_tree *cft; 103 struct stat info; 104 int r = 0; 105 106 if (!stat(pf->file, &info)) 107 pf->ctime = info.st_ctime; 108 else { 109 log_very_verbose("%s: stat failed: %s", pf->file, 110 strerror(errno)); 111 return_0; 112 } 113 114 if (!(cft = create_config_tree(pf->file, 1))) 115 return_0; 116 117 if (!read_config_file(cft)) 118 goto_out; 119 120 _read_array(pf, cft, "persistent_filter_cache/valid_devices", 121 PF_GOOD_DEVICE); 122 /* We don't gain anything by holding invalid devices */ 123 /* _read_array(pf, cft, "persistent_filter_cache/invalid_devices", 124 PF_BAD_DEVICE); */ 125 126 /* Did we find anything? */ 127 if (dm_hash_get_num_entries(pf->devices)) { 128 /* We populated dev_cache ourselves */ 129 dev_cache_scan(0); 130 r = 1; 131 } 132 133 log_very_verbose("Loaded persistent filter cache from %s", pf->file); 134 135 out: 136 if (r && cft_out) 137 *cft_out = cft; 138 else 139 destroy_config_tree(cft); 140 return r; 141 } 142 143 static void _write_array(struct pfilter *pf, FILE *fp, const char *path, 144 void *data) 145 { 146 void *d; 147 int first = 1; 148 char *buf, *str; 149 struct dm_hash_node *n; 150 151 for (n = dm_hash_get_first(pf->devices); n; 152 n = dm_hash_get_next(pf->devices, n)) { 153 d = dm_hash_get_data(pf->devices, n); 154 155 if (d != data) 156 continue; 157 158 if (!first) 159 fprintf(fp, ",\n"); 160 else { 161 fprintf(fp, "\t%s=[\n", path); 162 first = 0; 163 } 164 165 str = dm_hash_get_key(pf->devices, n); 166 if (!(buf = alloca(escaped_len(str)))) { 167 log_error("persistent filter device path stack " 168 "allocation failed"); 169 return; 170 } 171 fprintf(fp, "\t\t\"%s\"", escape_double_quotes(buf, str)); 172 } 173 174 if (!first) 175 fprintf(fp, "\n\t]\n"); 176 177 return; 178 } 179 180 int persistent_filter_dump(struct dev_filter *f) 181 { 182 struct pfilter *pf; 183 char *tmp_file; 184 struct stat info, info2; 185 struct config_tree *cft = NULL; 186 FILE *fp; 187 int lockfd; 188 int r = 0; 189 190 if (!f) 191 return_0; 192 pf = (struct pfilter *) f->private; 193 194 if (!dm_hash_get_num_entries(pf->devices)) { 195 log_very_verbose("Internal persistent device cache empty " 196 "- not writing to %s", pf->file); 197 return 0; 198 } 199 if (!dev_cache_has_scanned()) { 200 log_very_verbose("Device cache incomplete - not writing " 201 "to %s", pf->file); 202 return 0; 203 } 204 205 log_very_verbose("Dumping persistent device cache to %s", pf->file); 206 207 while (1) { 208 if ((lockfd = fcntl_lock_file(pf->file, F_WRLCK, 0)) < 0) 209 return_0; 210 211 /* 212 * Ensure we locked the file we expected 213 */ 214 if (fstat(lockfd, &info)) { 215 log_sys_error("fstat", pf->file); 216 goto out; 217 } 218 if (stat(pf->file, &info2)) { 219 log_sys_error("stat", pf->file); 220 goto out; 221 } 222 223 if (is_same_inode(info, info2)) 224 break; 225 226 fcntl_unlock_file(lockfd); 227 } 228 229 /* 230 * If file contents changed since we loaded it, merge new contents 231 */ 232 if (info.st_ctime != pf->ctime) 233 /* Keep cft open to avoid losing lock */ 234 persistent_filter_load(f, &cft); 235 236 tmp_file = alloca(strlen(pf->file) + 5); 237 sprintf(tmp_file, "%s.tmp", pf->file); 238 239 if (!(fp = fopen(tmp_file, "w"))) { 240 /* EACCES has been reported over NFS */ 241 if (errno != EROFS && errno != EACCES) 242 log_sys_error("fopen", tmp_file); 243 goto out; 244 } 245 246 fprintf(fp, "# This file is automatically maintained by lvm.\n\n"); 247 fprintf(fp, "persistent_filter_cache {\n"); 248 249 _write_array(pf, fp, "valid_devices", PF_GOOD_DEVICE); 250 /* We don't gain anything by remembering invalid devices */ 251 /* _write_array(pf, fp, "invalid_devices", PF_BAD_DEVICE); */ 252 253 fprintf(fp, "}\n"); 254 if (lvm_fclose(fp, tmp_file)) 255 goto_out; 256 257 if (rename(tmp_file, pf->file)) 258 log_error("%s: rename to %s failed: %s", tmp_file, pf->file, 259 strerror(errno)); 260 261 r = 1; 262 263 out: 264 fcntl_unlock_file(lockfd); 265 266 if (cft) 267 destroy_config_tree(cft); 268 269 return r; 270 } 271 272 static int _lookup_p(struct dev_filter *f, struct device *dev) 273 { 274 struct pfilter *pf = (struct pfilter *) f->private; 275 void *l = dm_hash_lookup(pf->devices, dev_name(dev)); 276 struct str_list *sl; 277 278 if (!l) { 279 l = pf->real->passes_filter(pf->real, dev) ? 280 PF_GOOD_DEVICE : PF_BAD_DEVICE; 281 282 dm_list_iterate_items(sl, &dev->aliases) 283 dm_hash_insert(pf->devices, sl->str, l); 284 285 } else if (l == PF_BAD_DEVICE) 286 log_debug("%s: Skipping (cached)", dev_name(dev)); 287 288 return (l == PF_BAD_DEVICE) ? 0 : 1; 289 } 290 291 static void _persistent_destroy(struct dev_filter *f) 292 { 293 struct pfilter *pf = (struct pfilter *) f->private; 294 295 dm_hash_destroy(pf->devices); 296 dm_free(pf->file); 297 pf->real->destroy(pf->real); 298 dm_free(pf); 299 dm_free(f); 300 } 301 302 struct dev_filter *persistent_filter_create(struct dev_filter *real, 303 const char *file) 304 { 305 struct pfilter *pf; 306 struct dev_filter *f = NULL; 307 308 if (!(pf = dm_malloc(sizeof(*pf)))) 309 return_NULL; 310 memset(pf, 0, sizeof(*pf)); 311 312 if (!(pf->file = dm_malloc(strlen(file) + 1))) 313 goto_bad; 314 315 strcpy(pf->file, file); 316 pf->real = real; 317 318 if (!(_init_hash(pf))) { 319 log_error("Couldn't create hash table for persistent filter."); 320 goto bad; 321 } 322 323 if (!(f = dm_malloc(sizeof(*f)))) 324 goto_bad; 325 326 f->passes_filter = _lookup_p; 327 f->destroy = _persistent_destroy; 328 f->private = pf; 329 330 return f; 331 332 bad: 333 dm_free(pf->file); 334 if (pf->devices) 335 dm_hash_destroy(pf->devices); 336 dm_free(pf); 337 dm_free(f); 338 return NULL; 339 } 340