6 * Copyright (C) 2003 Greg Kroah-Hartman <greg@kroah.com>
7 * Copyright (C) 2003 IBM Corp.
9 * This program is free software; you can redistribute it and/or modify it
10 * under the terms of the GNU General Public License as published by the
11 * Free Software Foundation version 2 of the License.
13 * This program is distributed in the hope that it will be useful, but
14 * WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * General Public License for more details.
18 * You should have received a copy of the GNU General Public License along
19 * with this program; if not, write to the Free Software Foundation, Inc.,
20 * 675 Mass Ave, Cambridge, MA 02139, USA.
25 * udev database library
35 #include "udev_version.h"
40 #include "libsysfs/libsysfs.h"
42 static TDB_CONTEXT *udevdb;
45 * busdb_record - bus and id are keys to look up name of device
52 * classdb_record - class name and class device name used as keys to find
55 struct classdb_record {
59 struct sysfsdb_record {
64 * namedb_record - device name is key, remaining udevice info stored here.
66 struct namedb_record {
67 char sysfs_dev_path[PATH_SIZE];
68 char class_dev_name[NAME_SIZE];
69 char class_name[NAME_SIZE];
72 char driver[NAME_SIZE];
80 * udevdb_close: close udev database
82 static void udevdb_close(void)
91 * udevdb_open: opens udev's database
92 * @method: database can either be in memory - UDEVDB_INTERNAL - or
93 * written to a file with UDEVDB_DEFAULT.
95 static int udevdb_open(int method)
97 udevdb = tdb_open(UDEV_CONFIG_DIR UDEV_DB, 0, method, O_RDWR | O_CREAT, 0644);
99 if (method == UDEVDB_INTERNAL)
100 dbg("Unable to initialize in-memory database");
102 dbg("Unable to initialize database at %s", UDEV_CONFIG_DIR UDEV_DB);
111 static struct busdb_record *busdb_fetch(const char *bus, const char *id)
114 char keystr[BUS_SIZE+ID_SIZE+2];
115 struct busdb_record *rec = NULL;
117 if (bus == NULL || id == NULL)
119 if (strlen(bus) >= BUS_SIZE || strlen(id) >= ID_SIZE)
122 memset(keystr, 0, (BUS_SIZE+ID_SIZE+2));
124 strcat(keystr, UDEVDB_DEL);
127 key.dptr = (void *)keystr;
128 key.dsize = strlen(keystr) + 1;
130 data = tdb_fetch(udevdb, key);
131 if (data.dptr == NULL || data.dsize == 0)
134 rec = (struct busdb_record *)malloc(sizeof(struct busdb_record));
140 memcpy(rec, data.dptr, sizeof(struct busdb_record));
149 static struct classdb_record *classdb_fetch(const char *cls,
153 char keystr[NAME_SIZE+NAME_SIZE+2];
154 struct classdb_record *rec = NULL;
156 if (cls == NULL || cls_dev == NULL)
158 if (strlen(cls) >= NAME_SIZE || strlen(cls_dev) >= NAME_SIZE)
161 memset(keystr, 0, (NAME_SIZE+NAME_SIZE+2));
163 strcat(keystr, UDEVDB_DEL);
164 strcat(keystr, cls_dev);
166 key.dptr = (void *)keystr;
167 key.dsize = strlen(keystr) + 1;
169 data = tdb_fetch(udevdb, key);
170 if (data.dptr == NULL || data.dsize == 0)
173 rec = (struct classdb_record *)malloc(sizeof(struct classdb_record));
179 memcpy(rec, data.dptr, sizeof(struct classdb_record));
185 static struct sysfsdb_record *sysfsdb_fetch(const char *path)
188 char keystr[PATH_SIZE+2];
189 struct sysfsdb_record *rec = NULL;
191 if (strlen(path) >= PATH_SIZE)
194 memset(keystr, 0, sizeof(keystr));
195 strcpy(keystr, path);
197 dbg("keystr = %s", keystr);
199 key.dptr = (void *)keystr;
200 key.dsize = strlen(keystr) + 1;
202 data = tdb_fetch(udevdb, key);
203 if (data.dptr == NULL || data.dsize == 0) {
204 dbg("tdb_fetch did not work :(");
208 rec = (struct sysfsdb_record *)malloc(sizeof(struct sysfsdb_record));
214 memcpy(rec, data.dptr, sizeof(struct sysfsdb_record));
223 static struct namedb_record *namedb_fetch(const char *name)
226 char nm_keystr[NAME_SIZE];
227 struct namedb_record *nrec = NULL;
231 if (strlen(name) >= NAME_SIZE)
234 memset(nm_keystr, 0, NAME_SIZE);
235 strcpy(nm_keystr, name);
237 key.dptr = (void *)nm_keystr;
238 key.dsize = strlen(nm_keystr) + 1;
240 data = tdb_fetch(udevdb, key);
241 if (data.dptr == NULL || data.dsize == 0)
244 nrec = (struct namedb_record *)malloc(sizeof(struct namedb_record));
250 memcpy(nrec, data.dptr, sizeof(struct namedb_record));
259 static int busdb_store(const struct udevice *dev)
262 char keystr[BUS_SIZE+ID_SIZE+2];
263 struct busdb_record rec;
269 memset(keystr, 0, (BUS_SIZE+ID_SIZE+2));
270 strcpy(keystr, dev->bus_name);
271 strcat(keystr, UDEVDB_DEL);
272 strcat(keystr, dev->bus_id);
274 key.dptr = (void *)keystr;
275 key.dsize = strlen(keystr) + 1;
277 strcpy(rec.name, dev->name);
279 data.dptr = (void *) &rec;
280 data.dsize = sizeof(rec);
282 retval = tdb_store(udevdb, key, data, TDB_REPLACE);
289 static int classdb_store(const struct udevice *dev)
292 char keystr[NAME_SIZE+NAME_SIZE+2];
293 struct classdb_record rec;
299 memset(keystr, 0, (NAME_SIZE+NAME_SIZE+2));
300 strcpy(keystr, dev->class_name);
301 strcat(keystr, UDEVDB_DEL);
302 strcat(keystr, dev->class_dev_name);
304 key.dptr = (void *)keystr;
305 key.dsize = strlen(keystr) + 1;
307 strcpy(rec.name, dev->name);
309 data.dptr = (void *) &rec;
310 data.dsize = sizeof(rec);
312 retval = tdb_store(udevdb, key, data, TDB_REPLACE);
316 static int sysfs_store(const char *path, const struct udevice *dev)
319 char keystr[PATH_SIZE+2];
320 struct sysfsdb_record rec;
326 memset(keystr, 0, sizeof(keystr));
327 strcpy(keystr, path);
328 dbg("keystr = %s", keystr);
330 key.dptr = (void *)keystr;
331 key.dsize = strlen(keystr) + 1;
333 strcpy(rec.name, dev->name);
335 data.dptr = (void *) &rec;
336 data.dsize = sizeof(rec);
338 retval = tdb_store(udevdb, key, data, TDB_REPLACE);
345 static int namedb_store(const struct udevice *dev)
348 char keystr[NAME_SIZE];
349 struct namedb_record rec;
355 memset(keystr, 0, NAME_SIZE);
356 strcpy(keystr, dev->name);
358 key.dptr = (void *)keystr;
359 key.dsize = strlen(keystr) + 1;
361 strcpy(rec.sysfs_dev_path, dev->sysfs_dev_path);
362 strcpy(rec.bus, dev->bus_name);
363 strcpy(rec.id, dev->bus_id);
364 strcpy(rec.class_dev_name, dev->class_dev_name);
365 strcpy(rec.class_name, dev->class_name);
366 strcpy(rec.driver, dev->driver);
367 rec.type = dev->type;
368 rec.major = dev->major;
369 rec.minor = dev->minor;
370 rec.mode = dev->mode;
372 data.dptr = (void *) &rec;
373 data.dsize = sizeof(rec);
375 retval = tdb_store(udevdb, key, data, TDB_REPLACE);
382 static int busdb_delete(const char *bus, const char *id)
385 char keystr[BUS_SIZE+ID_SIZE+2];
388 if (bus == NULL || id == NULL)
390 if (strlen(bus) >= BUS_SIZE || strlen(id) >= ID_SIZE)
393 memset(keystr, 0, (BUS_SIZE+ID_SIZE+2));
395 strcat(keystr, UDEVDB_DEL);
398 key.dptr = (void *)keystr;
399 key.dsize = strlen(keystr) + 1;
401 retval = tdb_delete(udevdb, key);
408 static int classdb_delete(const char *cls, const char *cls_dev)
411 char keystr[NAME_SIZE+NAME_SIZE+2];
414 if (cls == NULL || cls_dev == NULL)
416 if (strlen(cls) >= NAME_SIZE || strlen(cls_dev) >= NAME_SIZE)
419 memset(keystr, 0, (NAME_SIZE+NAME_SIZE+2));
421 strcat(keystr, UDEVDB_DEL);
422 strcat(keystr, cls_dev);
424 key.dptr = (void *)keystr;
425 key.dsize = strlen(keystr) + 1;
427 retval = tdb_delete(udevdb, key);
434 static int namedb_delete(const char *name)
437 char keystr[NAME_SIZE];
442 if (strlen(name) >= NAME_SIZE)
445 memset(keystr, 0, NAME_SIZE);
446 strcpy(keystr, name);
448 key.dptr = (void *)keystr;
449 key.dsize = strlen(keystr) + 1;
451 retval = tdb_delete(udevdb, key);
456 * udevdb_delete_udevice
458 int udevdb_delete_udevice(const char *name)
460 struct namedb_record *nrec = NULL;
465 nrec = namedb_fetch(name);
469 busdb_delete(nrec->bus, nrec->id);
470 classdb_delete(nrec->class_name, nrec->class_dev_name);
478 * udevdb_add_device: adds class device to database
480 int udevdb_add_device(const char *device, const struct sysfs_class_device *class_dev, const char *name, char type, int major, int minor, int mode)
482 struct udevice dbdev;
484 if (class_dev == NULL)
487 memset(&dbdev, 0, sizeof(dbdev));
488 strncpy(dbdev.name, name, NAME_SIZE);
489 if (class_dev->sysdevice) {
490 strncpy(dbdev.sysfs_dev_path, class_dev->sysdevice->directory->path, PATH_SIZE);
491 strncpy(dbdev.bus_id, class_dev->sysdevice->bus_id, ID_SIZE);
493 strncpy(dbdev.class_dev_name, class_dev->name, NAME_SIZE);
494 // if ((sysfs_get_name_from_path(subsystem, dbdev.class_name, NAME_SIZE)) != 0)
495 // strcpy(dbdev.class_name, "unknown");
496 strcpy(dbdev.bus_name, "unknown");
497 if (class_dev->driver != NULL)
498 strncpy(dbdev.driver, class_dev->driver->name, NAME_SIZE);
500 strcpy(dbdev.driver, "unknown");
506 if ((busdb_store(&dbdev)) != 0)
508 if ((classdb_store(&dbdev)) != 0)
510 if ((sysfs_store(device, &dbdev)) != 0)
512 if ((namedb_store(&dbdev)) != 0)
519 * udevdb_get_device: grab's device by name
521 struct udevice *udevdb_get_udevice(const char *name)
523 struct namedb_record *nrec = NULL;
524 struct udevice *dev = NULL;
529 nrec = namedb_fetch(name);
533 dev = (struct udevice *)malloc(sizeof(struct udevice));
539 strcpy(dev->name, name);
540 strcpy(dev->sysfs_dev_path, nrec->sysfs_dev_path);
541 strcpy(dev->class_dev_name, nrec->class_dev_name);
542 strcpy(dev->class_name, nrec->class_name);
543 strcpy(dev->bus_name, nrec->bus);
544 strcpy(dev->bus_id, nrec->id);
545 dev->type = nrec->type;
546 dev->major = nrec->major;
547 dev->minor = nrec->minor;
548 dev->mode = nrec->mode;
556 * udevdb_get_device_by_bus
558 struct udevice *udevdb_get_udevice_by_bus(const char *bus, const char *id)
560 struct busdb_record *brec = NULL;
561 struct udevice *dev = NULL;
563 if (bus == NULL || id == NULL)
566 brec = busdb_fetch(bus, id);
570 dev = udevdb_get_udevice(brec->name);
577 * udevdb_get_udevice_by_class
579 struct udevice *udevdb_get_udevice_by_class(const char *cls,
582 struct classdb_record *crec = NULL;
583 struct udevice *dev = NULL;
585 if (cls == NULL || cls_dev == NULL)
588 crec = classdb_fetch(cls, cls_dev);
592 dev = udevdb_get_udevice(crec->name);
599 char *udevdb_get_udevice_by_sysfs(const char *path)
601 struct sysfsdb_record *crec = NULL;
602 // struct udevice *dev = NULL;
607 crec = sysfsdb_fetch(path);
613 // dev = udevdb_get_udevice(crec->name);
620 * udevdb_exit: closes database
622 void udevdb_exit(void)
628 * udevdb_init: initializes database
630 int udevdb_init(int init_flag)
632 if (init_flag != UDEVDB_DEFAULT && init_flag != UDEVDB_INTERNAL)
635 return udevdb_open(init_flag);