2 * udev database library
15 static TDB_CONTEXT *udevdb;
18 * busdb_record - bus and id are keys to look up name of device
25 * classdb_record - class name and class device name used as keys to find
28 struct classdb_record {
33 * namedb_record - device name is key, remaining udevice info stored here.
35 struct namedb_record {
36 char sysfs_path[PATH_SIZE];
37 char class_dev_name[NAME_SIZE];
38 char class_name[NAME_SIZE];
41 char driver[NAME_SIZE];
49 * udevdb_close: close udev database
51 static void udevdb_close(void)
60 * udevdb_open: opens udev's database
61 * @method: database can either be in memory - UDEVDB_INTERNAL - or
62 * written to a file with UDEVDB_DEFAULT.
64 static int udevdb_open(int method)
66 udevdb = tdb_open(UDEVDB, 0, method, O_RDWR | O_CREAT, 0644);
75 static struct busdb_record *busdb_fetch(const char *bus, const char *id)
78 char keystr[BUS_SIZE+ID_SIZE+2];
79 struct busdb_record *rec = NULL;
81 if (bus == NULL || id == NULL)
83 if (strlen(bus) >= BUS_SIZE || strlen(id) >= ID_SIZE)
86 memset(keystr, 0, (BUS_SIZE+ID_SIZE+2));
88 strcat(keystr, UDEVDB_DEL);
91 key.dptr = (void *)keystr;
92 key.dsize = strlen(keystr) + 1;
94 data = tdb_fetch(udevdb, key);
95 if (data.dptr == NULL || data.dsize == 0)
98 rec = (struct busdb_record *)malloc(sizeof(struct busdb_record));
104 memcpy(rec, data.dptr, sizeof(struct busdb_record));
113 static struct classdb_record *classdb_fetch(const char *cls,
117 char keystr[NAME_SIZE+NAME_SIZE+2];
118 struct classdb_record *rec = NULL;
120 if (cls == NULL || cls_dev == NULL)
122 if (strlen(cls) >= NAME_SIZE || strlen(cls_dev) >= NAME_SIZE)
125 memset(keystr, 0, (NAME_SIZE+NAME_SIZE+2));
127 strcat(keystr, UDEVDB_DEL);
128 strcat(keystr, cls_dev);
130 key.dptr = (void *)keystr;
131 key.dsize = strlen(keystr) + 1;
133 data = tdb_fetch(udevdb, key);
134 if (data.dptr == NULL || data.dsize == 0)
137 rec = (struct classdb_record *)malloc(sizeof(struct classdb_record));
143 memcpy(rec, data.dptr, sizeof(struct classdb_record));
152 static struct namedb_record *namedb_fetch(const char *name)
155 char nm_keystr[NAME_SIZE];
156 struct namedb_record *nrec = NULL;
160 if (strlen(name) >= NAME_SIZE)
163 memset(nm_keystr, 0, NAME_SIZE);
164 strcpy(nm_keystr, name);
166 key.dptr = (void *)nm_keystr;
167 key.dsize = strlen(nm_keystr) + 1;
169 data = tdb_fetch(udevdb, key);
170 if (data.dptr == NULL || data.dsize == 0)
173 nrec = (struct namedb_record *)malloc(sizeof(struct namedb_record));
179 memcpy(nrec, data.dptr, sizeof(struct namedb_record));
188 static int busdb_store(const struct udevice *dev)
191 char keystr[BUS_SIZE+ID_SIZE+2];
192 struct busdb_record rec;
198 memset(keystr, 0, (BUS_SIZE+ID_SIZE+2));
199 strcpy(keystr, dev->bus_name);
200 strcat(keystr, UDEVDB_DEL);
201 strcat(keystr, dev->bus_id);
203 key.dptr = (void *)keystr;
204 key.dsize = strlen(keystr) + 1;
206 strcpy(rec.name, dev->name);
208 data.dptr = (void *) &rec;
209 data.dsize = sizeof(rec);
211 retval = tdb_store(udevdb, key, data, TDB_REPLACE);
218 static int classdb_store(const struct udevice *dev)
221 char keystr[NAME_SIZE+NAME_SIZE+2];
222 struct classdb_record rec;
228 memset(keystr, 0, (NAME_SIZE+NAME_SIZE+2));
229 strcpy(keystr, dev->class_name);
230 strcat(keystr, UDEVDB_DEL);
231 strcat(keystr, dev->class_dev_name);
233 key.dptr = (void *)keystr;
234 key.dsize = strlen(keystr) + 1;
236 strcpy(rec.name, dev->name);
238 data.dptr = (void *) &rec;
239 data.dsize = sizeof(rec);
241 retval = tdb_store(udevdb, key, data, TDB_REPLACE);
248 static int namedb_store(const struct udevice *dev)
251 char keystr[NAME_SIZE];
252 struct namedb_record rec;
258 memset(keystr, 0, NAME_SIZE);
259 strcpy(keystr, dev->name);
261 key.dptr = (void *)keystr;
262 key.dsize = strlen(keystr) + 1;
264 strcpy(rec.sysfs_path, dev->sysfs_path);
265 strcpy(rec.bus, dev->bus_name);
266 strcpy(rec.id, dev->bus_id);
267 strcpy(rec.class_dev_name, dev->class_dev_name);
268 strcpy(rec.class_name, dev->class_name);
269 strcpy(rec.driver, dev->driver);
270 rec.type = dev->type;
271 rec.major = dev->major;
272 rec.minor = dev->minor;
273 rec.mode = dev->mode;
275 data.dptr = (void *) &rec;
276 data.dsize = sizeof(rec);
278 retval = tdb_store(udevdb, key, data, TDB_REPLACE);
285 static int busdb_delete(const char *bus, const char *id)
288 char keystr[BUS_SIZE+ID_SIZE+2];
291 if (bus == NULL || id == NULL)
293 if (strlen(bus) >= BUS_SIZE || strlen(id) >= ID_SIZE)
296 memset(keystr, 0, (BUS_SIZE+ID_SIZE+2));
298 strcat(keystr, UDEVDB_DEL);
301 key.dptr = (void *)keystr;
302 key.dsize = strlen(keystr) + 1;
304 retval = tdb_delete(udevdb, key);
311 static int classdb_delete(const char *cls, const char *cls_dev)
314 char keystr[NAME_SIZE+NAME_SIZE+2];
317 if (cls == NULL || cls_dev == NULL)
319 if (strlen(cls) >= NAME_SIZE || strlen(cls_dev) >= NAME_SIZE)
322 memset(keystr, 0, (NAME_SIZE+NAME_SIZE+2));
324 strcat(keystr, UDEVDB_DEL);
325 strcat(keystr, cls_dev);
327 key.dptr = (void *)keystr;
328 key.dsize = strlen(keystr) + 1;
330 retval = tdb_delete(udevdb, key);
337 static int namedb_delete(const char *name)
340 char keystr[NAME_SIZE];
345 if (strlen(name) >= NAME_SIZE)
348 memset(keystr, 0, NAME_SIZE);
349 strcpy(keystr, name);
351 key.dptr = (void *)keystr;
352 key.dsize = strlen(keystr) + 1;
354 retval = tdb_delete(udevdb, key);
359 * udevdb_delete_udevice
361 int udevdb_delete_udevice(const char *name)
363 struct namedb_record *nrec = NULL;
368 nrec = namedb_fetch(name);
372 busdb_delete(nrec->bus, nrec->id);
373 classdb_delete(nrec->class_name, nrec->class_dev_name);
381 * udevdb_add_udevice: adds udevice to database
383 int udevdb_add_udevice(const struct udevice *dev)
388 if ((busdb_store(dev)) != 0)
390 if ((classdb_store(dev)) != 0)
392 if ((namedb_store(dev)) != 0)
399 * udevdb_get_device: grab's device by name
401 struct udevice *udevdb_get_udevice(const char *name)
403 struct namedb_record *nrec = NULL;
404 struct udevice *dev = NULL;
409 nrec = namedb_fetch(name);
413 dev = (struct udevice *)malloc(sizeof(struct udevice));
419 strcpy(dev->name, name);
420 strcpy(dev->sysfs_path, nrec->sysfs_path);
421 strcpy(dev->class_dev_name, nrec->class_dev_name);
422 strcpy(dev->class_name, nrec->class_name);
423 strcpy(dev->bus_name, nrec->bus);
424 strcpy(dev->bus_id, nrec->id);
425 dev->type = nrec->type;
426 dev->major = nrec->major;
427 dev->minor = nrec->minor;
428 dev->mode = nrec->mode;
436 * udevdb_get_device_by_bus
438 struct udevice *udevdb_get_udevice_by_bus(const char *bus, const char *id)
440 struct busdb_record *brec = NULL;
441 struct udevice *dev = NULL;
443 if (bus == NULL || id == NULL)
446 brec = busdb_fetch(bus, id);
450 dev = udevdb_get_udevice(brec->name);
457 * udevdb_get_udevice_by_class
459 struct udevice *udevdb_get_udevice_by_class(const char *cls,
462 struct classdb_record *crec = NULL;
463 struct udevice *dev = NULL;
465 if (cls == NULL || cls_dev == NULL)
468 crec = classdb_fetch(cls, cls_dev);
472 dev = udevdb_get_udevice(crec->name);
479 * udevdb_exit: closes database
481 void udevdb_exit(void)
487 * udevdb_init: initializes database
489 int udevdb_init(int init_flag)
491 if (init_flag != UDEVDB_DEFAULT && init_flag != UDEVDB_INTERNAL)
494 return udevdb_open(init_flag);