lvm/dm - clean up debug, fix open bug
[dragonfly.git] / contrib / lvm2 / dist / lib / device / dev-cache.c
1 /*      $NetBSD: dev-cache.c,v 1.4 2009/12/02 00:58:03 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 "dev-cache.h"
20 #include "lvm-types.h"
21 #include "btree.h"
22 #include "filter.h"
23 #include "filter-persistent.h"
24 #include "toolcontext.h"
25
26 #include <unistd.h>
27 #include <sys/param.h>
28 #include <dirent.h>
29
30 #ifdef __NetBSD__
31 #include "netbsd.h"
32 #endif
33
34 struct dev_iter {
35         struct btree_iter *current;
36         struct dev_filter *filter;
37 };
38
39 struct dir_list {
40         struct dm_list list;
41         char dir[0];
42 };
43
44 static struct {
45         struct dm_pool *mem;
46         struct dm_hash_table *names;
47         struct btree *devices;
48         struct dm_regex *preferred_names_matcher;
49
50         int has_scanned;
51         struct dm_list dirs;
52         struct dm_list files;
53
54 } _cache;
55
56 #define _alloc(x) dm_pool_zalloc(_cache.mem, (x))
57 #define _free(x) dm_pool_free(_cache.mem, (x))
58 #define _strdup(x) dm_pool_strdup(_cache.mem, (x))
59
60 static int _insert(const char *path, int rec);
61
62 struct device *dev_create_file(const char *filename, struct device *dev,
63                                struct str_list *alias, int use_malloc)
64 {
65         int allocate = !dev;
66
67         if (allocate) {
68                 if (use_malloc) {
69                         if (!(dev = dm_malloc(sizeof(*dev)))) {
70                                 log_error("struct device allocation failed");
71                                 return NULL;
72                         }
73                         if (!(alias = dm_malloc(sizeof(*alias)))) {
74                                 log_error("struct str_list allocation failed");
75                                 dm_free(dev);
76                                 return NULL;
77                         }
78                         if (!(alias->str = dm_strdup(filename))) {
79                                 log_error("filename strdup failed");
80                                 dm_free(dev);
81                                 dm_free(alias);
82                                 return NULL;
83                         }
84                         dev->flags = DEV_ALLOCED;
85                 } else {
86                         if (!(dev = _alloc(sizeof(*dev)))) {
87                                 log_error("struct device allocation failed");
88                                 return NULL;
89                         }
90                         if (!(alias = _alloc(sizeof(*alias)))) {
91                                 log_error("struct str_list allocation failed");
92                                 _free(dev);
93                                 return NULL;
94                         }
95                         if (!(alias->str = _strdup(filename))) {
96                                 log_error("filename strdup failed");
97                                 return NULL;
98                         }
99                 }
100         } else if (!(alias->str = dm_strdup(filename))) {
101                 log_error("filename strdup failed");
102                 return NULL;
103         }
104
105         dev->flags |= DEV_REGULAR;
106         dm_list_init(&dev->aliases);
107         dm_list_add(&dev->aliases, &alias->list);
108         dev->end = UINT64_C(0);
109         dev->dev = 0;
110         dev->fd = -1;
111         dev->open_count = 0;
112         dev->block_size = -1;
113         dev->read_ahead = -1;
114         memset(dev->pvid, 0, sizeof(dev->pvid));
115         dm_list_init(&dev->open_list);
116
117         return dev;
118 }
119
120 static struct device *_dev_create(dev_t d)
121 {
122         struct device *dev;
123
124         if (!(dev = _alloc(sizeof(*dev)))) {
125                 log_error("struct device allocation failed");
126                 return NULL;
127         }
128         dev->flags = 0;
129         dm_list_init(&dev->aliases);
130         dev->dev = d;
131         dev->fd = -1;
132         dev->open_count = 0;
133         dev->block_size = -1;
134         dev->read_ahead = -1;
135         dev->end = UINT64_C(0);
136         memset(dev->pvid, 0, sizeof(dev->pvid));
137         dm_list_init(&dev->open_list);
138
139         return dev;
140 }
141
142 void dev_set_preferred_name(struct str_list *sl, struct device *dev)
143 {
144         /*
145          * Don't interfere with ordering specified in config file.
146          */
147         if (_cache.preferred_names_matcher)
148                 return;
149
150         log_debug("%s: New preferred name", sl->str);
151         dm_list_del(&sl->list);
152         dm_list_add_h(&dev->aliases, &sl->list);
153 }
154
155 /* Return 1 if we prefer path1 else return 0 */
156 static int _compare_paths(const char *path0, const char *path1)
157 {
158         int slash0 = 0, slash1 = 0;
159         int m0, m1;
160         const char *p;
161         char p0[PATH_MAX], p1[PATH_MAX];
162         char *s0, *s1;
163         struct stat stat0, stat1;
164
165         /*
166          * FIXME Better to compare patterns one-at-a-time against all names.
167          */
168         if (_cache.preferred_names_matcher) {
169                 m0 = dm_regex_match(_cache.preferred_names_matcher, path0);
170                 m1 = dm_regex_match(_cache.preferred_names_matcher, path1);
171
172                 if (m0 != m1) {
173                         if (m0 < 0)
174                                 return 1;
175                         if (m1 < 0)
176                                 return 0;
177                         if (m0 < m1)
178                                 return 1;
179                         if (m1 < m0)
180                                 return 0;
181                 }
182         }
183
184         /*
185          * Built-in rules.
186          */
187
188         /* Return the path with fewer slashes */
189         for (p = path0; p++; p = (const char *) strchr(p, '/'))
190                 slash0++;
191
192         for (p = path1; p++; p = (const char *) strchr(p, '/'))
193                 slash1++;
194
195         if (slash0 < slash1)
196                 return 0;
197         if (slash1 < slash0)
198                 return 1;
199
200         strncpy(p0, path0, PATH_MAX);
201         strncpy(p1, path1, PATH_MAX);
202         s0 = &p0[0] + 1;
203         s1 = &p1[0] + 1;
204
205         /* We prefer symlinks - they exist for a reason!
206          * So we prefer a shorter path before the first symlink in the name.
207          * FIXME Configuration option to invert this? */
208         while (s0) {
209                 s0 = strchr(s0, '/');
210                 s1 = strchr(s1, '/');
211                 if (s0) {
212                         *s0 = '\0';
213                         *s1 = '\0';
214                 }
215                 if (lstat(p0, &stat0)) {
216                         log_sys_very_verbose("lstat", p0);
217                         return 1;
218                 }
219                 if (lstat(p1, &stat1)) {
220                         log_sys_very_verbose("lstat", p1);
221                         return 0;
222                 }
223                 if (S_ISLNK(stat0.st_mode) && !S_ISLNK(stat1.st_mode))
224                         return 0;
225                 if (!S_ISLNK(stat0.st_mode) && S_ISLNK(stat1.st_mode))
226                         return 1;
227                 if (s0) {
228                         *s0++ = '/';
229                         *s1++ = '/';
230                 }
231         }
232
233         /* ASCII comparison */
234         if (strcmp(path0, path1) < 0)
235                 return 0;
236         else
237                 return 1;
238 }
239
240 static int _add_alias(struct device *dev, const char *path)
241 {
242         struct str_list *sl = _alloc(sizeof(*sl));
243         struct str_list *strl;
244         const char *oldpath;
245         int prefer_old = 1;
246
247         if (!sl)
248                 return_0;
249
250         /* Is name already there? */
251         dm_list_iterate_items(strl, &dev->aliases) {
252                 if (!strcmp(strl->str, path)) {
253                         log_debug("%s: Already in device cache", path);
254                         return 1;
255                 }
256         }
257
258         if (!(sl->str = dm_pool_strdup(_cache.mem, path)))
259                 return_0;
260
261         if (!dm_list_empty(&dev->aliases)) {
262                 oldpath = dm_list_item(dev->aliases.n, struct str_list)->str;
263                 prefer_old = _compare_paths(path, oldpath);
264                 log_debug("%s: Aliased to %s in device cache%s",
265                           path, oldpath, prefer_old ? "" : " (preferred name)");
266
267         } else
268                 log_debug("%s: Added to device cache", path);
269
270         if (prefer_old)
271                 dm_list_add(&dev->aliases, &sl->list);
272         else
273                 dm_list_add_h(&dev->aliases, &sl->list);
274
275         return 1;
276 }
277
278 /*
279  * Either creates a new dev, or adds an alias to
280  * an existing dev.
281  */
282 static int _insert_dev(const char *path, dev_t d)
283 {
284         struct device *dev;
285         static dev_t loopfile_count = 0;
286         int loopfile = 0;
287
288         /* Generate pretend device numbers for loopfiles */
289         if (!d) {
290                 if (dm_hash_lookup(_cache.names, path))
291                         return 1;
292                 d = ++loopfile_count;
293                 loopfile = 1;
294         }
295
296         /* is this device already registered ? */
297         if (!(dev = (struct device *) btree_lookup(_cache.devices,
298                                                    (uint32_t) d))) {
299                 /* create new device */
300                 if (loopfile) {
301                         if (!(dev = dev_create_file(path, NULL, NULL, 0)))
302                                 return_0;
303                 } else if (!(dev = _dev_create(d)))
304                         return_0;
305
306                 if (!(btree_insert(_cache.devices, (uint32_t) d, dev))) {
307                         log_error("Couldn't insert device into binary tree.");
308                         _free(dev);
309                         return 0;
310                 }
311         }
312
313         if (!loopfile && !_add_alias(dev, path)) {
314                 log_error("Couldn't add alias to dev cache.");
315                 return 0;
316         }
317
318         if (!dm_hash_insert(_cache.names, path, dev)) {
319                 log_error("Couldn't add name to hash in dev cache.");
320                 return 0;
321         }
322
323         return 1;
324 }
325
326 static char *_join(const char *dir, const char *name)
327 {
328         size_t len = strlen(dir) + strlen(name) + 2;
329         char *r = dm_malloc(len);
330         if (r)
331                 snprintf(r, len, "%s/%s", dir, name);
332
333         return r;
334 }
335
336 /*
337  * Get rid of extra slashes in the path string.
338  */
339 static void _collapse_slashes(char *str)
340 {
341         char *ptr;
342         int was_slash = 0;
343
344         for (ptr = str; *ptr; ptr++) {
345                 if (*ptr == '/') {
346                         if (was_slash)
347                                 continue;
348
349                         was_slash = 1;
350                 } else
351                         was_slash = 0;
352                 *str++ = *ptr;
353         }
354
355         *str = *ptr;
356 }
357
358 static int _insert_dir(const char *dir)
359 {
360         int n, dirent_count, r = 1;
361         struct dirent **dirent;
362         char *path;
363
364         dirent_count = scandir(dir, &dirent, NULL, alphasort);
365         if (dirent_count > 0) {
366                 for (n = 0; n < dirent_count; n++) {
367                         if (dirent[n]->d_name[0] == '.') {
368                                 free(dirent[n]);
369                                 continue;
370                         }
371
372                         if (!(path = _join(dir, dirent[n]->d_name)))
373                                 return_0;
374
375                         _collapse_slashes(path);
376                         r &= _insert(path, 1);
377                         dm_free(path);
378
379                         free(dirent[n]);
380                 }
381                 free(dirent);
382         }
383
384         return r;
385 }
386
387 static int _insert_file(const char *path)
388 {
389         struct stat info;
390
391         if (stat(path, &info) < 0) {
392                 log_sys_very_verbose("stat", path);
393                 return 0;
394         }
395
396         if (!S_ISREG(info.st_mode)) {
397                 log_debug("%s: Not a regular file", path);
398                 return 0;
399         }
400
401         if (!_insert_dev(path, 0))
402                 return_0;
403
404         return 1;
405 }
406
407 static int _insert(const char *path, int rec)
408 {
409         struct stat info;
410         int r = 0;
411
412         if (stat(path, &info) < 0) {
413                 log_sys_very_verbose("stat", path);
414                 return 0;
415         }
416
417         if (S_ISDIR(info.st_mode)) {    /* add a directory */
418                 /* check it's not a symbolic link */
419                 if (lstat(path, &info) < 0) {
420                         log_sys_very_verbose("lstat", path);
421                         return 0;
422                 }
423
424                 if (S_ISLNK(info.st_mode)) {
425                         log_debug("%s: Symbolic link to directory", path);
426                         return 0;
427                 }
428
429                 if (rec)
430                         r = _insert_dir(path);
431
432         } else {
433                 /* add a device */
434 #ifdef __NetBSD__
435                 /*
436                  * In NetBSD we have two different types of devices
437                  * raw and block. I can insert only  existing
438                  * raw and block device.
439                  */
440                 if (S_ISBLK(info.st_mode)) {
441                         log_debug("%s: Not a raw device", path);
442                         return_0;
443                 }
444                 if (nbsd_check_dev(MAJOR(info.st_rdev),path) < 0) {
445                         log_debug("%s: Not a known raw device", path);
446                         return_0;
447                 }
448 #elif defined(__DragonFly__)
449                 /*
450                  * This never happens, but oh well...
451                  */
452                 if (S_ISBLK(info.st_mode)) {
453                         log_debug("%s: Not a raw device", path);
454                         return_0;
455                 }
456
457                 /*
458                  * We avoid adding devctl to the cache because reading from it
459                  * locks lvm up. devctl doesn't seem to be caught later in the
460                  * filter because it has major number 0, and lvm seems to assume
461                  * dm also has major 0.
462                  */
463                 if (!strcmp(path, "/dev/devctl")) {
464                         log_debug("%s: It's devctl, no interest");
465                         return_0;
466                 }
467
468                 if (!strncmp(path, "/dev/tun", strlen("/dev/tun"))) {
469                         log_debug("%s: Not adding tun devices");
470                         return_0;
471                 }
472
473                 if (!strncmp(path, "/dev/cd", strlen("/dev/cd")) ||
474                     !strncmp(path, "/dev/acd", strlen("/dev/acd"))) {
475                         log_debug("%s: Not adding CD drives");
476                         return_0;
477                 }
478
479                 if (!strcmp(path, "/dev/vn")) {
480                         log_debug("%s: Not adding vn autoclone dev");
481                         return_0;
482                 }
483
484                 if (!strncmp(path, "/dev/md", strlen("/dev/md"))) {
485                         log_debug("%s: Not adding malloc disks");
486                         return_0;
487                 }
488
489                 if (!strncmp(path, "/dev/fd", strlen("/dev/fd"))) {
490                         log_debug("%s: Not adding floppy disks or fds");
491                         return_0;
492                 }
493 #else
494                 if (!S_ISBLK(info.st_mode))
495                         log_debug("%s: Not a block device", path);
496 #endif
497                 if (!_insert_dev(path, info.st_rdev)) {
498                         return_0;
499                 }
500
501                 r = 1;
502         }
503
504         return r;
505 }
506
507 static void _full_scan(int dev_scan)
508 {
509         struct dir_list *dl;
510
511         if (_cache.has_scanned && !dev_scan)
512                 return;
513
514         dm_list_iterate_items(dl, &_cache.dirs)
515                 _insert_dir(dl->dir);
516
517         dm_list_iterate_items(dl, &_cache.files)
518                 _insert_file(dl->dir);
519
520         _cache.has_scanned = 1;
521         init_full_scan_done(1);
522 }
523
524 int dev_cache_has_scanned(void)
525 {
526         return _cache.has_scanned;
527 }
528
529 void dev_cache_scan(int do_scan)
530 {
531         if (!do_scan)
532                 _cache.has_scanned = 1;
533         else
534                 _full_scan(1);
535 }
536
537 static int _init_preferred_names(struct cmd_context *cmd)
538 {
539         const struct config_node *cn;
540         struct config_value *v;
541         struct dm_pool *scratch = NULL;
542         char **regex;
543         unsigned count = 0;
544         int i, r = 0;
545
546         _cache.preferred_names_matcher = NULL;
547
548         if (!(cn = find_config_tree_node(cmd, "devices/preferred_names")) ||
549             cn->v->type == CFG_EMPTY_ARRAY) {
550                 log_very_verbose("devices/preferred_names not found in config file: "
551                                  "using built-in preferences");
552                 return 1;
553         }
554
555         for (v = cn->v; v; v = v->next) {
556                 if (v->type != CFG_STRING) {
557                         log_error("preferred_names patterns must be enclosed in quotes");
558                         return 0;
559                 }
560
561                 count++;
562         }
563
564         if (!(scratch = dm_pool_create("preferred device name matcher", 1024)))
565                 return_0;
566
567         if (!(regex = dm_pool_alloc(scratch, sizeof(*regex) * count))) {
568                 log_error("Failed to allocate preferred device name "
569                           "pattern list.");
570                 goto out;
571         }
572
573         for (v = cn->v, i = count - 1; v; v = v->next, i--) {
574                 if (!(regex[i] = dm_pool_strdup(scratch, v->v.str))) {
575                         log_error("Failed to allocate a preferred device name "
576                                   "pattern.");
577                         goto out;
578                 }
579         }
580
581         if (!(_cache.preferred_names_matcher =
582                 dm_regex_create(_cache.mem,(const char **) regex, count))) {
583                 log_error("Preferred device name pattern matcher creation failed.");
584                 goto out;
585         }
586
587         r = 1;
588
589 out:
590         dm_pool_destroy(scratch);
591
592         return r;
593 }
594
595 int dev_cache_init(struct cmd_context *cmd)
596 {
597         _cache.names = NULL;
598         _cache.has_scanned = 0;
599
600         if (!(_cache.mem = dm_pool_create("dev_cache", 10 * 1024)))
601                 return_0;
602
603         if (!(_cache.names = dm_hash_create(128))) {
604                 dm_pool_destroy(_cache.mem);
605                 _cache.mem = 0;
606                 return_0;
607         }
608
609         if (!(_cache.devices = btree_create(_cache.mem))) {
610                 log_error("Couldn't create binary tree for dev-cache.");
611                 goto bad;
612         }
613
614         dm_list_init(&_cache.dirs);
615         dm_list_init(&_cache.files);
616
617         if (!_init_preferred_names(cmd))
618                 goto_bad;
619
620         return 1;
621
622       bad:
623         dev_cache_exit();
624         return 0;
625 }
626
627 static void _check_closed(struct device *dev)
628 {
629         if (dev->fd >= 0)
630                 log_error("Device '%s' has been left open.", dev_name(dev));
631 }
632
633 static void _check_for_open_devices(void)
634 {
635         dm_hash_iter(_cache.names, (dm_hash_iterate_fn) _check_closed);
636 }
637
638 void dev_cache_exit(void)
639 {
640         if (_cache.names)
641                 _check_for_open_devices();
642
643         if (_cache.preferred_names_matcher)
644                 _cache.preferred_names_matcher = NULL;
645
646         if (_cache.mem) {
647                 dm_pool_destroy(_cache.mem);
648                 _cache.mem = NULL;
649         }
650
651         if (_cache.names) {
652                 dm_hash_destroy(_cache.names);
653                 _cache.names = NULL;
654         }
655
656         _cache.devices = NULL;
657         _cache.has_scanned = 0;
658         dm_list_init(&_cache.dirs);
659         dm_list_init(&_cache.files);
660 }
661
662 int dev_cache_add_dir(const char *path)
663 {
664         struct dir_list *dl;
665         struct stat st;
666
667         if (stat(path, &st)) {
668                 log_error("Ignoring %s: %s", path, strerror(errno));
669                 /* But don't fail */
670                 return 1;
671         }
672
673         if (!S_ISDIR(st.st_mode)) {
674                 log_error("Ignoring %s: Not a directory", path);
675                 return 1;
676         }
677
678         if (!(dl = _alloc(sizeof(*dl) + strlen(path) + 1))) {
679                 log_error("dir_list allocation failed");
680                 return 0;
681         }
682
683         strcpy(dl->dir, path);
684         dm_list_add(&_cache.dirs, &dl->list);
685         return 1;
686 }
687
688 int dev_cache_add_loopfile(const char *path)
689 {
690         struct dir_list *dl;
691         struct stat st;
692
693         if (stat(path, &st)) {
694                 log_error("Ignoring %s: %s", path, strerror(errno));
695                 /* But don't fail */
696                 return 1;
697         }
698
699         if (!S_ISREG(st.st_mode)) {
700                 log_error("Ignoring %s: Not a regular file", path);
701                 return 1;
702         }
703
704         if (!(dl = _alloc(sizeof(*dl) + strlen(path) + 1))) {
705                 log_error("dir_list allocation failed for file");
706                 return 0;
707         }
708
709         strcpy(dl->dir, path);
710         dm_list_add(&_cache.files, &dl->list);
711         return 1;
712 }
713
714 /* Check cached device name is still valid before returning it */
715 /* This should be a rare occurrence */
716 /* set quiet if the cache is expected to be out-of-date */
717 /* FIXME Make rest of code pass/cache struct device instead of dev_name */
718 const char *dev_name_confirmed(struct device *dev, int quiet)
719 {
720         struct stat buf;
721         const char *name;
722         int r;
723
724         if ((dev->flags & DEV_REGULAR))
725                 return dev_name(dev);
726
727         while ((r = stat(name = dm_list_item(dev->aliases.n,
728                                           struct str_list)->str, &buf)) ||
729                (buf.st_rdev != dev->dev)) {
730                 if (r < 0) {
731                         if (quiet)
732                                 log_sys_debug("stat", name);
733                         else
734                                 log_sys_error("stat", name);
735                 }
736                 if (quiet)
737                         log_debug("Path %s no longer valid for device(%d,%d)",
738                                   name, (int) MAJOR(dev->dev),
739                                   (int) MINOR(dev->dev));
740                 else
741                         log_error("Path %s no longer valid for device(%d,%d)",
742                                   name, (int) MAJOR(dev->dev),
743                                   (int) MINOR(dev->dev));
744
745                 /* Remove the incorrect hash entry */
746                 dm_hash_remove(_cache.names, name);
747
748                 /* Leave list alone if there isn't an alternative name */
749                 /* so dev_name will always find something to return. */
750                 /* Otherwise add the name to the correct device. */
751                 if (dm_list_size(&dev->aliases) > 1) {
752                         dm_list_del(dev->aliases.n);
753                         if (!r)
754                                 _insert(name, 0);
755                         continue;
756                 }
757
758                 /* Scanning issues this inappropriately sometimes. */
759                 log_debug("Aborting - please provide new pathname for what "
760                           "used to be %s", name);
761                 return NULL;
762         }
763
764         return dev_name(dev);
765 }
766
767 struct device *dev_cache_get(const char *name, struct dev_filter *f)
768 {
769         struct stat buf;
770         struct device *d = (struct device *) dm_hash_lookup(_cache.names, name);
771
772         if (d && (d->flags & DEV_REGULAR))
773                 return d;
774
775         /* If the entry's wrong, remove it */
776         if (d && (stat(name, &buf) || (buf.st_rdev != d->dev))) {
777                 dm_hash_remove(_cache.names, name);
778                 d = NULL;
779         }
780
781         if (!d) {
782                 _insert(name, 0);
783                 d = (struct device *) dm_hash_lookup(_cache.names, name);
784                 if (!d) {
785                         _full_scan(0);
786                         d = (struct device *) dm_hash_lookup(_cache.names, name);
787                 }
788         }
789
790         return (d && (!f || (d->flags & DEV_REGULAR) ||
791                       f->passes_filter(f, d))) ? d : NULL;
792 }
793
794 struct dev_iter *dev_iter_create(struct dev_filter *f, int dev_scan)
795 {
796         struct dev_iter *di = dm_malloc(sizeof(*di));
797
798         if (!di) {
799                 log_error("dev_iter allocation failed");
800                 return NULL;
801         }
802
803         if (dev_scan && !trust_cache()) {
804                 /* Flag gets reset between each command */
805                 if (!full_scan_done())
806                         persistent_filter_wipe(f); /* Calls _full_scan(1) */
807         } else
808                 _full_scan(0);
809
810         di->current = btree_first(_cache.devices);
811         di->filter = f;
812
813         return di;
814 }
815
816 void dev_iter_destroy(struct dev_iter *iter)
817 {
818         dm_free(iter);
819 }
820
821 static struct device *_iter_next(struct dev_iter *iter)
822 {
823         struct device *d = btree_get_data(iter->current);
824         iter->current = btree_next(iter->current);
825         return d;
826 }
827
828 struct device *dev_iter_get(struct dev_iter *iter)
829 {
830         while (iter->current) {
831                 struct device *d = _iter_next(iter);
832                 if (!iter->filter || (d->flags & DEV_REGULAR) ||
833                     iter->filter->passes_filter(iter->filter, d))
834                         return d;
835         }
836
837         return NULL;
838 }
839
840 int dev_fd(struct device *dev)
841 {
842         return dev->fd;
843 }
844
845 const char *dev_name(const struct device *dev)
846 {
847         return (dev) ? dm_list_item(dev->aliases.n, struct str_list)->str :
848             "unknown device";
849 }