2 * udev database library
12 #include "udev_version.h"
18 static TDB_CONTEXT *udevdb;
21 * busdb_record - bus and id are keys to look up name of device
28 * classdb_record - class name and class device name used as keys to find
31 struct classdb_record {
36 * namedb_record - device name is key, remaining udevice info stored here.
38 struct namedb_record {
39 char sysfs_path[PATH_SIZE];
40 char class_dev_name[NAME_SIZE];
41 char class_name[NAME_SIZE];
44 char driver[NAME_SIZE];
52 * udevdb_close: close udev database
54 static void udevdb_close(void)
63 * udevdb_open: opens udev's database
64 * @method: database can either be in memory - UDEVDB_INTERNAL - or
65 * written to a file with UDEVDB_DEFAULT.
67 static int udevdb_open(int method)
69 udevdb = tdb_open(UDEV_CONFIG_DIR UDEV_DB, 0, method, O_RDWR | O_CREAT, 0644);
71 if (method == UDEVDB_INTERNAL)
72 dbg("Unable to initialize in-memory database");
74 dbg("Unable to initialize database at %s", UDEV_CONFIG_DIR UDEV_DB);
83 static struct busdb_record *busdb_fetch(const char *bus, const char *id)
86 char keystr[BUS_SIZE+ID_SIZE+2];
87 struct busdb_record *rec = NULL;
89 if (bus == NULL || id == NULL)
91 if (strlen(bus) >= BUS_SIZE || strlen(id) >= ID_SIZE)
94 memset(keystr, 0, (BUS_SIZE+ID_SIZE+2));
96 strcat(keystr, UDEVDB_DEL);
99 key.dptr = (void *)keystr;
100 key.dsize = strlen(keystr) + 1;
102 data = tdb_fetch(udevdb, key);
103 if (data.dptr == NULL || data.dsize == 0)
106 rec = (struct busdb_record *)malloc(sizeof(struct busdb_record));
112 memcpy(rec, data.dptr, sizeof(struct busdb_record));
121 static struct classdb_record *classdb_fetch(const char *cls,
125 char keystr[NAME_SIZE+NAME_SIZE+2];
126 struct classdb_record *rec = NULL;
128 if (cls == NULL || cls_dev == NULL)
130 if (strlen(cls) >= NAME_SIZE || strlen(cls_dev) >= NAME_SIZE)
133 memset(keystr, 0, (NAME_SIZE+NAME_SIZE+2));
135 strcat(keystr, UDEVDB_DEL);
136 strcat(keystr, cls_dev);
138 key.dptr = (void *)keystr;
139 key.dsize = strlen(keystr) + 1;
141 data = tdb_fetch(udevdb, key);
142 if (data.dptr == NULL || data.dsize == 0)
145 rec = (struct classdb_record *)malloc(sizeof(struct classdb_record));
151 memcpy(rec, data.dptr, sizeof(struct classdb_record));
160 static struct namedb_record *namedb_fetch(const char *name)
163 char nm_keystr[NAME_SIZE];
164 struct namedb_record *nrec = NULL;
168 if (strlen(name) >= NAME_SIZE)
171 memset(nm_keystr, 0, NAME_SIZE);
172 strcpy(nm_keystr, name);
174 key.dptr = (void *)nm_keystr;
175 key.dsize = strlen(nm_keystr) + 1;
177 data = tdb_fetch(udevdb, key);
178 if (data.dptr == NULL || data.dsize == 0)
181 nrec = (struct namedb_record *)malloc(sizeof(struct namedb_record));
187 memcpy(nrec, data.dptr, sizeof(struct namedb_record));
196 static int busdb_store(const struct udevice *dev)
199 char keystr[BUS_SIZE+ID_SIZE+2];
200 struct busdb_record rec;
206 memset(keystr, 0, (BUS_SIZE+ID_SIZE+2));
207 strcpy(keystr, dev->bus_name);
208 strcat(keystr, UDEVDB_DEL);
209 strcat(keystr, dev->bus_id);
211 key.dptr = (void *)keystr;
212 key.dsize = strlen(keystr) + 1;
214 strcpy(rec.name, dev->name);
216 data.dptr = (void *) &rec;
217 data.dsize = sizeof(rec);
219 retval = tdb_store(udevdb, key, data, TDB_REPLACE);
226 static int classdb_store(const struct udevice *dev)
229 char keystr[NAME_SIZE+NAME_SIZE+2];
230 struct classdb_record rec;
236 memset(keystr, 0, (NAME_SIZE+NAME_SIZE+2));
237 strcpy(keystr, dev->class_name);
238 strcat(keystr, UDEVDB_DEL);
239 strcat(keystr, dev->class_dev_name);
241 key.dptr = (void *)keystr;
242 key.dsize = strlen(keystr) + 1;
244 strcpy(rec.name, dev->name);
246 data.dptr = (void *) &rec;
247 data.dsize = sizeof(rec);
249 retval = tdb_store(udevdb, key, data, TDB_REPLACE);
256 static int namedb_store(const struct udevice *dev)
259 char keystr[NAME_SIZE];
260 struct namedb_record rec;
266 memset(keystr, 0, NAME_SIZE);
267 strcpy(keystr, dev->name);
269 key.dptr = (void *)keystr;
270 key.dsize = strlen(keystr) + 1;
272 strcpy(rec.sysfs_path, dev->sysfs_path);
273 strcpy(rec.bus, dev->bus_name);
274 strcpy(rec.id, dev->bus_id);
275 strcpy(rec.class_dev_name, dev->class_dev_name);
276 strcpy(rec.class_name, dev->class_name);
277 strcpy(rec.driver, dev->driver);
278 rec.type = dev->type;
279 rec.major = dev->major;
280 rec.minor = dev->minor;
281 rec.mode = dev->mode;
283 data.dptr = (void *) &rec;
284 data.dsize = sizeof(rec);
286 retval = tdb_store(udevdb, key, data, TDB_REPLACE);
293 static int busdb_delete(const char *bus, const char *id)
296 char keystr[BUS_SIZE+ID_SIZE+2];
299 if (bus == NULL || id == NULL)
301 if (strlen(bus) >= BUS_SIZE || strlen(id) >= ID_SIZE)
304 memset(keystr, 0, (BUS_SIZE+ID_SIZE+2));
306 strcat(keystr, UDEVDB_DEL);
309 key.dptr = (void *)keystr;
310 key.dsize = strlen(keystr) + 1;
312 retval = tdb_delete(udevdb, key);
319 static int classdb_delete(const char *cls, const char *cls_dev)
322 char keystr[NAME_SIZE+NAME_SIZE+2];
325 if (cls == NULL || cls_dev == NULL)
327 if (strlen(cls) >= NAME_SIZE || strlen(cls_dev) >= NAME_SIZE)
330 memset(keystr, 0, (NAME_SIZE+NAME_SIZE+2));
332 strcat(keystr, UDEVDB_DEL);
333 strcat(keystr, cls_dev);
335 key.dptr = (void *)keystr;
336 key.dsize = strlen(keystr) + 1;
338 retval = tdb_delete(udevdb, key);
345 static int namedb_delete(const char *name)
348 char keystr[NAME_SIZE];
353 if (strlen(name) >= NAME_SIZE)
356 memset(keystr, 0, NAME_SIZE);
357 strcpy(keystr, name);
359 key.dptr = (void *)keystr;
360 key.dsize = strlen(keystr) + 1;
362 retval = tdb_delete(udevdb, key);
367 * udevdb_delete_udevice
369 int udevdb_delete_udevice(const char *name)
371 struct namedb_record *nrec = NULL;
376 nrec = namedb_fetch(name);
380 busdb_delete(nrec->bus, nrec->id);
381 classdb_delete(nrec->class_name, nrec->class_dev_name);
389 * udevdb_add_udevice: adds udevice to database
391 int udevdb_add_udevice(const struct udevice *dev)
396 if ((busdb_store(dev)) != 0)
398 if ((classdb_store(dev)) != 0)
400 if ((namedb_store(dev)) != 0)
407 * udevdb_get_device: grab's device by name
409 struct udevice *udevdb_get_udevice(const char *name)
411 struct namedb_record *nrec = NULL;
412 struct udevice *dev = NULL;
417 nrec = namedb_fetch(name);
421 dev = (struct udevice *)malloc(sizeof(struct udevice));
427 strcpy(dev->name, name);
428 strcpy(dev->sysfs_path, nrec->sysfs_path);
429 strcpy(dev->class_dev_name, nrec->class_dev_name);
430 strcpy(dev->class_name, nrec->class_name);
431 strcpy(dev->bus_name, nrec->bus);
432 strcpy(dev->bus_id, nrec->id);
433 dev->type = nrec->type;
434 dev->major = nrec->major;
435 dev->minor = nrec->minor;
436 dev->mode = nrec->mode;
444 * udevdb_get_device_by_bus
446 struct udevice *udevdb_get_udevice_by_bus(const char *bus, const char *id)
448 struct busdb_record *brec = NULL;
449 struct udevice *dev = NULL;
451 if (bus == NULL || id == NULL)
454 brec = busdb_fetch(bus, id);
458 dev = udevdb_get_udevice(brec->name);
465 * udevdb_get_udevice_by_class
467 struct udevice *udevdb_get_udevice_by_class(const char *cls,
470 struct classdb_record *crec = NULL;
471 struct udevice *dev = NULL;
473 if (cls == NULL || cls_dev == NULL)
476 crec = classdb_fetch(cls, cls_dev);
480 dev = udevdb_get_udevice(crec->name);
487 * udevdb_exit: closes database
489 void udevdb_exit(void)
495 * udevdb_init: initializes database
497 int udevdb_init(int init_flag)
499 if (init_flag != UDEVDB_DEFAULT && init_flag != UDEVDB_INTERNAL)
502 return udevdb_open(init_flag);