Here's the patch applying the latest libsysfs.
- adds the latest libsysfs code to udev
* new code includes dlist implementation, a generic linked list
implementation. Needed our own because LGPL
* rearranged structures
* provided more functions for accessing directory and attributes
- gets rid of ->directory->path references in namedev.c
- replaces sysfs_get_value_from_attributes with sysfs_get_classdev_attr
# Makefile for libsysfs.a
# Copyright (c) International Business Machines Corp., 2003
-H_INCLUDE=../include
+H_INCLUDE=.
LIB_INCLUDE=.
OBJS=sysfs_bus.o sysfs_class.o sysfs_device.o sysfs_dir.o sysfs_driver.o \
- sysfs_utils.o
+ sysfs_utils.o dlist.o
# Install directory
# Options
-CFLAGS=-O2 -Wall -ansi -g
+CFLAGS=-O2 -Wall -g
# sysfs library
LIBSYSFS=libsysfs.a
sysfs_utils.o: sysfs_utils.c
$(CC) -I$(H_INCLUDE) -I$(LIB_INCLUDE) $(CFLAGS) -c sysfs_utils.c
+dlist.o: dlist.c
+ $(CC) -I$(H_INCLUDE) -I$(LIB_INCLUDE) $(CFLAGS) -c dlist.c
+
clean:
$(RM) *.o *~ core $(LIBSYSFS)
--- /dev/null
+/*
+ * dlist.c
+ *
+ * Copyright (C) 2003 Eric J Bohm
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 021110307 USA
+ *
+ */
+
+
+/* Double linked list implementation.
+
+ * You allocate the data and give dlist the pointer.
+ * If your data is complex set the dlist->del_func to a an appropriate
+ * delete function. Otherwise dlist will just use free.
+
+*/
+#include "dlist.h"
+
+/*
+ * Return pointer to node at marker.
+ * else null if no nodes.
+ */
+
+inline void *dlist_mark(Dlist *list)
+{
+ if(list->marker!=NULL)
+ return(list->marker->data);
+ else
+ return(NULL);
+}
+
+/*
+ * Set marker to start.
+ */
+
+inline void dlist_start(Dlist *list)
+{
+ list->marker=list->head;
+}
+
+/*
+ * Set marker to end.
+ */
+
+inline void dlist_end(Dlist *list)
+{
+ list->marker=list->head;
+}
+
+/* internal use function
+ * quickie inline to consolidate the marker movement logic
+ * in one place
+ *
+ * when direction true it moves marker after
+ * when direction false it moves marker before.
+ * return pointer to data at new marker
+ * if nowhere to move the marker in desired direction return null
+ */
+inline void *_dlist_mark_move(Dlist *list,int direction)
+{
+ if(direction)
+ {
+ if( list->marker->next!=NULL)
+ list->marker=list->marker->next;
+ else
+ return(NULL);
+ }
+ else
+ {
+ if( list->marker->prev!=NULL)
+ list->marker=list->marker->prev;
+ else
+ return(NULL);
+ }
+ if(list->marker!=list->head)
+ return(list->marker->data);
+ else
+ return(NULL);
+}
+
+/*
+ * Create new linked list to store nodes of datasize.
+ * return null if list cannot be created.
+ */
+Dlist *dlist_new(size_t datasize)
+{
+ Dlist *list=NULL;
+ if((list=malloc(sizeof(Dlist))))
+ {
+ list->marker=NULL;
+ list->count=0L;
+ list->data_size=datasize;
+ list->del_func=free;
+ list->head=&(list->headnode);
+ list->head->prev=NULL;
+ list->head->next=NULL;
+ list->head->data=NULL;
+ }
+ return(list);
+}
+
+/*
+ * Create new linked list to store nodes of datasize set list
+ * data node delete function to the passed in del_func
+ * return null if list cannot be created.
+ */
+Dlist *dlist_new_with_delete(size_t datasize,void (*del_func)(void*))
+{
+ Dlist *list=NULL;
+ list=dlist_new(datasize);
+ if(list!=NULL)
+ list->del_func=del_func;
+ return(list);
+}
+
+
+/*
+ * remove marker node from list
+ * call data_delete function on data if registered.
+ * otherwise call free.
+ * when direction true it moves marker after
+ * when direction false it moves marker before.
+ * free marker node
+ * return nothing.
+ */
+void dlist_delete(Dlist *list,int direction)
+{
+ if((list->marker != list->head)&&(list->marker!=NULL))
+ {
+ DL_node *corpse;
+ corpse=list->marker;
+ _dlist_mark_move(list,direction);
+ if(list->head->next==corpse)
+ list->head->next=corpse->next;
+ if(list->head->prev==corpse)
+ list->head->prev=corpse->prev;
+ if(corpse->prev!=NULL) //should be impossible
+ corpse->prev->next=corpse->next;
+ if(corpse->next!=NULL) //should be impossible
+ corpse->next->prev=corpse->prev;
+ list->del_func(corpse->data);
+ list->count--;
+ free(corpse);
+ }
+}
+
+/*
+ * Insert node containing data at marker.
+ * If direction true it inserts after.
+ * If direction false it inserts before.
+ * move marker to inserted node
+ * return pointer to inserted node
+ */
+void *dlist_insert(Dlist *list,void *data,int direction)
+{
+ DL_node *new_node=NULL;
+ if(list==NULL || data==NULL)
+ return(NULL);
+ if(list->marker==NULL) //in case the marker ends up unset
+ list->marker=list->head;
+ if((new_node=malloc(sizeof(DL_node))))
+ {
+ new_node->data=data;
+ new_node->prev=NULL;
+ new_node->next=NULL;
+ list->count++;
+ if(list->head->next==NULL) //no l
+ {
+ list->head->next=list->head->prev=new_node;
+ new_node->prev=list->head;
+ new_node->next=list->head;
+ }
+ else if(direction)
+ {
+ new_node->next=list->marker->next;
+ new_node->prev=list->marker;
+ list->marker->next->prev=new_node;
+ list->marker->next=new_node;
+ }
+ else
+ {
+ new_node->prev=list->marker->prev;
+ new_node->next=list->marker;
+ list->marker->prev->next=new_node;
+ list->marker->prev=new_node;
+ }
+ list->marker=new_node;
+ }
+ else
+ {
+ return(NULL);
+ }
+ return(list->marker->data);
+}
+
+/*
+ * Remove DL_node from list without deallocating data.
+ * if marker == killme .
+ * when direction true it moves marker after
+ * when direction false it moves marker before.
+ * to previous if there is no next.
+ */
+void *_dlist_remove(Dlist *list,DL_node *killme,int direction)
+{
+ if(killme!=NULL)
+ {
+ void *killer_data=killme->data;
+ // take care of head and marker pointers.
+ if(list->marker==killme)
+ _dlist_mark_move(list,direction);
+ if(killme ==list->head->next)
+ list->head->next=killme->next;
+ if(killme==list->head->prev)
+ list->head->prev=killme->prev;
+ // remove from list
+ if(killme->prev !=NULL)
+ killme->prev->next=killme->next;
+ if(killme->next !=NULL)
+ killme->next->prev=killme->prev;
+ list->count--;
+ free(killme);
+ return(killer_data);
+ }
+ else
+ return (NULL);
+}
+
+
+/*
+ * Insert node containing data after end.
+ */
+void dlist_push(Dlist *list,void *data)
+{
+ list->marker=list->head->prev;
+ dlist_insert(list,data,1);
+}
+
+/*
+ * Insert node containing data at start.
+ */
+
+void dlist_unshift(Dlist *list,void *data)
+
+{
+ list->marker=list->head->next;
+ dlist_insert(list,data,0);
+}
+
+
+/*
+ * Remove end node from list.
+ * Return pointer to data in removed node.
+ * Null if no nodes.
+ */
+
+void *dlist_pop(Dlist *list)
+{
+ return(_dlist_remove(list,list->head->prev,0));
+}
+
+/*
+ * Remove start node from list.
+ * Return pointer to data in removed node.
+ * Null if no nodes.
+ */
+
+void *dlist_shift(Dlist *list)
+{
+ return(_dlist_remove(list,list->head->next,1));
+}
+
+
+/*
+ * destroy the list freeing all memory
+ */
+
+
+void dlist_destroy(Dlist *list)
+{
+ if(list !=NULL)
+ {
+ dlist_start(list);
+ dlist_next(list);
+ while (dlist_mark(list)) {
+ dlist_delete(list,1);
+ }
+ free(list);
+ }
+}
+
+/**
+ * Return void pointer to list_data element matching comp function criteria
+ * else null
+ * Does not move the marker.
+ */
+
+void *dlist_find_custom(struct dlist *list, void *target, int (*comp)(void *, void *))
+{
+ /* test the comp function on each node */
+ struct dl_node *nodepointer;
+ dlist_for_each_nomark(list,nodepointer)
+ if(comp(target,nodepointer->data))
+ return(nodepointer->data);
+ return(NULL);
+}
+
+/**
+ * Apply the node_operation function to each data node in the list
+ */
+void dlist_transform(struct dlist *list, void (*node_operation)(void *))
+{
+ struct dl_node *nodepointer;
+ dlist_for_each_nomark(list,nodepointer)
+ node_operation(nodepointer->data);
+}
+
+/**
+ * insert new into list in sorted order
+ * sorter function in form int sorter(new,ith)
+ * must return 1 for when new should go before ith
+ * else 0
+ * return pointer to inserted node
+ * NOTE: assumes list is already sorted
+ */
+void *dlist_insert_sorted(struct dlist *list, void *new, int (*sorter)(void *, void *))
+{
+ for(dlist_start(list),dlist_next(list); \
+ list->marker!=list->head && !sorter(new,list->marker->data);dlist_next(list));
+ return(dlist_insert_before(list,new));
+}
--- /dev/null
+/*
+ * dlist.h
+ *
+ * Copyright (C) 2003 Eric J Bohm
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ */
+#ifndef _DLIST_H_
+#define _DLIST_H_
+
+/* Double linked list header.
+
+* navigate your list with DLIST_PREV and DLIST_NEXT. These are macros
+* so function call overhead is minimized.
+
+* Supports perl style push, pop, shift, unshift list semantics.
+
+* You allocate the data and give dlist the pointer. If your data is
+* complex set the dlist->del_func to a an appropriate delete using
+* dlist_new_with_delete. Your delete function must match
+(void * )(del(void *)
+*Otherwise dlist will just use free.
+
+* NOTE: The small amount of pain involved in doing that allows us to
+* avoid copy in copy out semantics.
+
+* Dlist uses an internal mark pointer to keep track of where you are
+* in the list.
+
+* insert and delete take a directional parameter. Where direction
+* corresponds to the direction in which you want the list to go.
+* true direction corresponded to progressing forward in the last
+* false to regressing in the list.
+* so a dlist_insert(yourlist,item,1) will insert it after the mark
+* so a dlist_insert(yourlist,item,0) will insert it before the mark
+* any insert will move the mark to the new node regardless of the direction.
+
+* Just use the dlist_(insert|delete)_(before|after) macros if you do not want
+* to think about it.
+
+*/
+#include <malloc.h>
+typedef struct dl_node {
+ struct dl_node *prev;
+ struct dl_node *next;
+ void *data;
+} DL_node;
+
+typedef struct dlist {
+ DL_node *marker;
+ unsigned long count;
+ size_t data_size;
+ void (*del_func)(void *);
+ DL_node headnode;
+ DL_node *head;
+} Dlist;
+
+Dlist *dlist_new(size_t datasize);
+Dlist *dlist_new_with_delete(size_t datasize,void (*del_func)(void*));
+void *_dlist_mark_move(Dlist *list,int direction);
+void *dlist_mark(Dlist *);
+void dlist_start(Dlist *);
+void dlist_end(Dlist *);
+
+void *dlist_insert(Dlist *,void *,int) ;
+
+void *dlist_insert_sorted(struct dlist *list, void *new, int (*sorter)(void *, void *));
+
+void dlist_delete(Dlist *,int);
+
+void dlist_push(Dlist *,void *);
+
+void dlist_unshift(Dlist *,void *);
+
+void *dlist_pop(Dlist *);
+
+void *dlist_shift(Dlist *);
+
+void dlist_destroy(Dlist *);
+
+void *dlist_find_custom(struct dlist *list, void *target, int (*comp)(void *, void *));
+void dlist_transform(struct dlist *list, void (*node_operation)(void *));
+
+
+/*
+ * _dlist_remove is for internal use only
+ * _dlist_mark_move is for internal use only
+ */
+void *_dlist_remove(struct dlist *,struct dl_node *,int );
+
+#define dlist_prev(A) _dlist_mark_move((A),0)
+#define dlist_next(A) _dlist_mark_move((A),1)
+
+#define dlist_insert_before(A,B) dlist_insert((A),(B),0)
+#define dlist_insert_after(A,B) dlist_insert((A),(B),1)
+
+#define dlist_delete_before(A) dlist_delete((A),0)
+#define dlist_delete_after(A) dlist_delete((A),1)
+
+/**
+ * provide for loop header which iterates the mark from start to end
+ * list: the dlist pointer, use dlist_mark(list) to get iterator
+ */
+#define dlist_for_each(list) \
+ for(dlist_start(list),dlist_next(list); \
+ (list)->marker!=(list)->head;dlist_next(list))
+
+/**
+ * provide for loop header which iterates the mark from end to start
+ * list: the dlist pointer, use dlist_mark(list) to get iterator
+ */
+#define dlist_for_each_rev(list) \
+ for(dlist_end(list),dlist_prev(list); \
+ (list)->marker!=(list)->head;dlist_prev(list))
+
+/**
+ * provide for loop header which iterates through the list without moving mark
+ * list: the dlist_pointer
+ * iterator: dl_node pointer to iterate
+ */
+#define dlist_for_each_nomark(list,iterator) \
+ for((iterator)=(list)->head->next; (iterator)!=(list)->head; \
+ (iterator)=(iterator)->next)
+
+/**
+ * provide for loop header which iterates through the list without moving mark
+ * in reverse
+ * list: the dlist_pointer
+ * iterator: dl_node pointer to iterate
+ */
+#define dlist_for_each_nomark_rev(list,iterator) \
+ for((iterator)=(list)->head->prev; (iterator)!=(list)->head; \
+ (iterator)=(iterator)->prev)
+/**
+ * provide for loop header which iterates through the list providing a
+ * data iterator
+ * list: the dlist pointer
+ * data_iterator: the pointer of type datatype to iterate
+ * datatype: actual type of the contents in the dl_node->data
+ */
+
+#define dlist_for_each_data(list,data_iterator,datatype) \
+ for(dlist_start(list), (data_iterator)=(datatype *) dlist_next(list); \
+ (list)->marker!=(list)->head;(data_iterator)=(datatype *) dlist_next(list))
+
+/**
+ * provide for loop header which iterates through the list providing a
+ * data iterator in reverse
+ * list: the dlist pointer
+ * data_iterator: the pointer of type datatype to iterate
+ * datatype: actual type of the contents in the dl_node->data
+ */
+#define dlist_for_each_data_rev(list,data_iterator,datatype) \
+ for(dlist_end(list), (data_iterator)=(datatype *) dlist_prev(list); \
+ (list)->marker!=(list)->head;(data_iterator)=(datatype *) dlist_prev(list))
+
+/**
+ * provide for loop header which iterates through the list providing a
+ * data iterator without moving the mark
+ * list: the dlist pointer
+ * iterator: the dl_node pointer to iterate
+ * data_iterator: the pointer of type datatype to iterate
+ * datatype: actual type of the contents in the dl_node->data
+ */
+
+#define dlist_for_each_data_nomark(list,iterator,data_iterator,datatype) \
+ for((iterator)=(list)->head->next, (data_iterator)=(datatype *) (iterator)->data; \
+ (iterator)!=(list)->head;(iterator)=(iterator)->next,(data_iterator)=(datatype *) (iterator))
+
+/**
+ * provide for loop header which iterates through the list providing a
+ * data iterator in reverse without moving the mark
+ * list: the dlist pointer
+ * iterator: the dl_node pointer to iterate
+ * data_iterator: the pointer of type datatype to iterate
+ * datatype: actual type of the contents in the dl_node->data
+ */
+#define dlist_for_each_data_nomark_rev(list,iterator, data_iterator,datatype) \
+ for((iterator)=(list)->head->prev, (data_iterator)=(datatype *) (iterator)->data; \
+ (iterator)!=(list)->head;(iterator)=(iterator)->prev,(data_iterator)=(datatype *) (iterator))
+
+#endif /* _DLIST_H_ */
*
* Header Definitions for libsysfs
*
- * Copyright (C) 2003 International Business Machines, Inc.
+ * Copyright (C) IBM Corp. 2003
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
#define _LIBSYSFS_H_
#include <sys/types.h>
+#include "dlist.h"
/*
* Generic #defines go here..
#define SYSFS_PROC_MNTS "/proc/mounts"
#define SYSFS_BUS_DIR "/bus"
#define SYSFS_CLASS_DIR "/class"
+#define SYSFS_BLOCK_DIR "/block"
#define SYSFS_DEVICES_DIR "/devices"
#define SYSFS_DEVICES_NAME "devices"
#define SYSFS_DRIVERS_DIR "/drivers"
#define SYSFS_DRIVERS_NAME "drivers"
#define SYSFS_NAME_ATTRIBUTE "name"
+#define SYSFS_UNKNOWN "unknown"
+
+/* Some "block" subsystem specific #defines */
+#define SYSFS_QUEUE_NAME "queue"
+#define SYSFS_IOSCHED_NAME "iosched"
#define SYSFS_PATH_MAX 255
#define SYSFS_NAME_LEN 50
#define SYSFS_METHOD_STORE 0x02 /* attr can be changed by user */
struct sysfs_attribute {
- struct sysfs_attribute *next;
- char path[SYSFS_PATH_MAX];
- char *value;
+ unsigned char *value;
unsigned short len; /* value length */
unsigned short method; /* show and store */
+ unsigned char name[SYSFS_NAME_LEN];
+ unsigned char path[SYSFS_PATH_MAX];
};
-struct sysfs_dlink {
- struct sysfs_dlink *next;
- char name[SYSFS_NAME_LEN];
- struct sysfs_directory *target;
+struct sysfs_link {
+ unsigned char name[SYSFS_NAME_LEN];
+ unsigned char path[SYSFS_PATH_MAX];
+ unsigned char target[SYSFS_PATH_MAX];
};
struct sysfs_directory {
- struct sysfs_directory *next;
- char path[SYSFS_PATH_MAX];
- struct sysfs_directory *subdirs;
- struct sysfs_dlink *links;
- struct sysfs_attribute *attributes;
+ struct dlist *subdirs;
+ struct dlist *links;
+ struct dlist *attributes;
+ unsigned char name[SYSFS_NAME_LEN];
+ unsigned char path[SYSFS_PATH_MAX];
};
struct sysfs_driver {
- struct sysfs_driver *next;
- char name[SYSFS_NAME_LEN];
- struct sysfs_directory *directory;
- struct sysfs_device *device;
+ struct dlist *devices;
+ unsigned char name[SYSFS_NAME_LEN];
+ unsigned char path[SYSFS_PATH_MAX];
+
+ /* for internal use only */
+ struct sysfs_directory *directory;
};
struct sysfs_device {
- struct sysfs_device *next;
- char name[SYSFS_NAME_LEN];
- char bus_id[SYSFS_NAME_LEN];
- struct sysfs_driver *driver;
+ struct sysfs_device *parent;
+ struct dlist *children;
+ unsigned char name[SYSFS_NAME_LEN];
+ unsigned char bus_id[SYSFS_NAME_LEN];
+ unsigned char path[SYSFS_PATH_MAX];
+ unsigned char driver_name[SYSFS_NAME_LEN];
+
+ /* for internal use only */
+ struct sysfs_directory *directory;
+};
+
+struct sysfs_root_device {
+ struct dlist *devices;
+ unsigned char name[SYSFS_NAME_LEN];
+ unsigned char path[SYSFS_PATH_MAX];
+
+ /* for internal use only */
struct sysfs_directory *directory;
- struct sysfs_device *parent;
- struct sysfs_device *children;
};
struct sysfs_bus {
- struct sysfs_bus *next;
- char name[SYSFS_NAME_LEN];
- struct sysfs_directory *directory;
- struct sysfs_driver *drivers;
- struct sysfs_device *devices;
+ struct dlist *drivers;
+ struct dlist *devices;
+ unsigned char name[SYSFS_NAME_LEN];
+ unsigned char path[SYSFS_PATH_MAX];
+
+ /* internal use only */
+ struct sysfs_directory *directory;
};
struct sysfs_class_device {
- struct sysfs_class_device *next;
- char name[SYSFS_NAME_LEN];
- struct sysfs_directory *directory;
struct sysfs_device *sysdevice; /* NULL if virtual */
struct sysfs_driver *driver; /* NULL if not implemented */
+ unsigned char name[SYSFS_NAME_LEN];
+ unsigned char path[SYSFS_PATH_MAX];
+
+ /* for internal use only */
+ struct sysfs_directory *directory;
};
struct sysfs_class {
- struct sysfs_class *next;
- char name[SYSFS_NAME_LEN];
- struct sysfs_directory *directory;
- struct sysfs_class_device *devices;
+ struct dlist *devices;
+ unsigned char name[SYSFS_NAME_LEN];
+ unsigned char path[SYSFS_PATH_MAX];
+
+ /* for internal use only */
+ struct sysfs_directory *directory;
};
#ifdef __cplusplus
/*
* Function Prototypes
*/
-extern int sysfs_get_mnt_path(char *mnt_path, size_t len);
-extern int sysfs_get_name_from_path(const char *path, char *name, size_t len);
-extern int sysfs_get_link(const char *path, char *target, size_t len);
+extern int sysfs_get_mnt_path(unsigned char *mnt_path, size_t len);
+extern int sysfs_get_name_from_path(const unsigned char *path,
+ unsigned char *name, size_t len);
+extern int sysfs_get_link(const unsigned char *path, unsigned char *target,
+ size_t len);
+extern struct dlist *sysfs_open_subsystem_list(unsigned char *name);
+extern struct dlist *sysfs_open_bus_devices_list(unsigned char *name);
+extern void sysfs_close_list(struct dlist *list);
/* sysfs directory and file access */
extern void sysfs_close_attribute(struct sysfs_attribute *sysattr);
-extern struct sysfs_attribute *sysfs_open_attribute(const char *path);
+extern struct sysfs_attribute *sysfs_open_attribute(const unsigned char *path);
extern int sysfs_read_attribute(struct sysfs_attribute *sysattr);
-extern int sysfs_read_attribute_value(const char *attrpath, char *value,
- size_t vsize);
-extern char *sysfs_get_value_from_attributes(struct sysfs_attribute *attr,
- const char * name);
+extern int sysfs_read_attribute_value(const unsigned char *attrpath,
+ unsigned char *value, size_t vsize);
+extern int sysfs_write_attribute(struct sysfs_attribute *sysattr,
+ const unsigned char *new_value, size_t len);
+extern unsigned char *sysfs_get_value_from_attributes(struct dlist *attr,
+ const unsigned char * name);
extern void sysfs_close_directory(struct sysfs_directory *sysdir);
-extern struct sysfs_directory *sysfs_open_directory(const char *path);
+extern struct sysfs_directory *sysfs_open_directory(const unsigned char *path);
extern int sysfs_read_directory(struct sysfs_directory *sysdir);
-extern void sysfs_close_dlink(struct sysfs_dlink *dlink);
-extern struct sysfs_dlink *sysfs_open_dlink(const char *linkpath);
-extern int sysfs_read_dlinks(struct sysfs_dlink *dlink);
+extern int sysfs_read_all_subdirs(struct sysfs_directory *sysdir);
+extern struct sysfs_directory *sysfs_get_subdirectory
+ (struct sysfs_directory *dir, unsigned char *subname);
+extern void sysfs_close_link(struct sysfs_link *ln);
+extern struct sysfs_link *sysfs_open_link(const unsigned char *lnpath);
+extern struct sysfs_link *sysfs_get_directory_link(struct sysfs_directory *dir,
+ unsigned char *linkname);
+extern struct sysfs_link *sysfs_get_subdirectory_link
+ (struct sysfs_directory *dir, unsigned char *linkname);
+extern struct sysfs_attribute *sysfs_get_directory_attribute
+ (struct sysfs_directory *dir, unsigned char *attrname);
/* sysfs driver access */
extern void sysfs_close_driver(struct sysfs_driver *driver);
-extern struct sysfs_driver *sysfs_open_driver(const char *path);
+extern struct sysfs_driver *sysfs_open_driver(const unsigned char *path);
+extern struct sysfs_attribute *sysfs_get_driver_attr
+ (struct sysfs_driver *drv, const unsigned char *name);
+extern struct dlist *sysfs_get_driver_attributes(struct sysfs_driver *driver);
+extern struct dlist *sysfs_get_driver_links(struct sysfs_driver *driver);
+extern void sysfs_close_driver_by_name(struct sysfs_driver *driver);
+extern struct sysfs_driver *sysfs_open_driver_by_name
+ (const unsigned char *drv_name, const unsigned char *bus, size_t bsize);
+extern int sysfs_write_driver_attr(unsigned char *drv, unsigned char *attrib,
+ unsigned char *value, size_t len);
+extern int sysfs_read_driver_attr(unsigned char *drv, unsigned char *attrib,
+ unsigned char *value, size_t len);
/* generic sysfs device access */
+extern void sysfs_close_root_device(struct sysfs_root_device *root);
+extern struct sysfs_root_device *sysfs_open_root_device
+ (const unsigned char *name);
extern void sysfs_close_device(struct sysfs_device *dev);
-extern void sysfs_close_device_tree(struct sysfs_device *dev);
-extern struct sysfs_device *sysfs_open_device(const char *path);
-extern struct sysfs_device *sysfs_open_device_tree(const char *path);
+extern struct sysfs_device *sysfs_open_device(const unsigned char *path);
extern struct sysfs_attribute *sysfs_get_device_attr
- (struct sysfs_device *dev, const char *name);
+ (struct sysfs_device *dev, const unsigned char *name);
+extern struct dlist *sysfs_get_device_attributes(struct sysfs_device *device);
+extern struct sysfs_device *sysfs_open_device_by_id
+ (const unsigned char *bus_id, const unsigned char *bus, size_t bsize);
+extern int sysfs_write_device_attr(unsigned char *dev, unsigned char *attrib,
+ unsigned char *value, size_t len);
+extern int sysfs_read_device_attr(unsigned char *dev, unsigned char *attrib,
+ unsigned char *value, size_t len);
/* generic sysfs bus access */
extern void sysfs_close_bus(struct sysfs_bus *bus);
-extern struct sysfs_bus *sysfs_open_bus(const char *name);
+extern struct sysfs_bus *sysfs_open_bus(const unsigned char *name);
+extern struct sysfs_device *sysfs_get_bus_device(struct sysfs_bus *bus,
+ unsigned char *id);
+extern struct sysfs_driver *sysfs_get_bus_driver(struct sysfs_bus *bus,
+ unsigned char *drvname);
+extern struct dlist *sysfs_get_bus_attributes(struct sysfs_bus *bus);
+extern struct sysfs_attribute *sysfs_get_bus_attribute(struct sysfs_bus *bus,
+ unsigned char *attrname);
+extern struct sysfs_device *sysfs_open_bus_device(unsigned char *busname,
+ unsigned char *dev_id);
+extern int sysfs_find_device_bus(const unsigned char *dev_id,
+ unsigned char *busname, size_t bsize);
+extern int sysfs_find_driver_bus(const unsigned char *driver,
+ unsigned char *busname, size_t bsize);
/* generic sysfs class access */
extern void sysfs_close_class_device(struct sysfs_class_device *dev);
-extern struct sysfs_class_device *sysfs_open_class_device(const char *path);
+extern struct sysfs_class_device *sysfs_open_class_device
+ (const unsigned char *path);
extern void sysfs_close_class(struct sysfs_class *cls);
-extern struct sysfs_class *sysfs_open_class(const char *name);
+extern struct sysfs_class *sysfs_open_class(const unsigned char *name);
+extern struct sysfs_class_device *sysfs_get_class_device
+ (struct sysfs_class *class, unsigned char *name);
+extern struct sysfs_class_device *sysfs_open_class_device_by_name
+ (const unsigned char *class, unsigned char *name);
+extern struct dlist *sysfs_get_classdev_attributes
+ (struct sysfs_class_device *cdev);
+extern int sysfs_find_device_class(const unsigned char *bus_id,
+ unsigned char *classname, size_t bsize);
+extern struct sysfs_attribute *sysfs_get_classdev_attr
+ (struct sysfs_class_device *clsdev, const unsigned char *name);
+extern int sysfs_write_classdev_attr(unsigned char *dev, unsigned char *attrib,
+ unsigned char *value, size_t len);
+extern int sysfs_read_classdev_attr(unsigned char *dev, unsigned char *attrib,
+ unsigned char *value, size_t len);
#ifdef __cplusplus
}
*
* Internal Header Definitions for libsysfs
*
- * Copyright (C) 2003 International Business Machines, Inc.
+ * Copyright (C) IBM Corp. 2003
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
*
* Generic bus utility functions for libsysfs
*
- * Copyright (C) 2003 International Business Machines, Inc.
+ * Copyright (C) IBM Corp. 2003
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
#include "libsysfs.h"
#include "sysfs.h"
+static void sysfs_close_dev(void *dev)
+{
+ sysfs_close_device((struct sysfs_device *)dev);
+}
+
+static void sysfs_close_drv(void *drv)
+{
+ sysfs_close_driver((struct sysfs_driver *)drv);
+}
+
+/*
+ * compares devices' bus ids.
+ * @a: device id looking for
+ * @b: sysfs_device comparing being compared
+ * returns 1 if a==b->bus_id or 0 not equal
+ */
+static int bus_device_id_equal(void *a, void *b)
+{
+ if (a == NULL || b == NULL)
+ return 0;
+
+ if (strcmp(((unsigned char *)a), ((struct sysfs_device *)b)->bus_id)
+ == 0)
+ return 1;
+ return 0;
+}
+
+/*
+ * compares drivers' names.
+ * @a: driver name looking for
+ * @b: sysfs_driver comparing being compared
+ * returns 1 if a==b->name or 0 not equal
+ */
+static int bus_driver_name_equal(void *a, void *b)
+{
+ if (a == NULL || b == NULL)
+ return 0;
+
+ if (strcmp(((unsigned char *)a), ((struct sysfs_driver *)b)->name) == 0)
+ return 1;
+ return 0;
+}
+
/**
* sysfs_close_bus: close single bus
* @bus: bus structure
*/
void sysfs_close_bus(struct sysfs_bus *bus)
{
- struct sysfs_device *curdev = NULL, *nextdev = NULL;
- struct sysfs_driver *curdrv = NULL, *nextdrv = NULL;
-
if (bus != NULL) {
if (bus->directory != NULL)
sysfs_close_directory(bus->directory);
- for (curdev = bus->devices; curdev != NULL;
- curdev = nextdev) {
- nextdev = curdev->next;
- sysfs_close_device(curdev);
- }
- for (curdrv = bus->drivers; curdrv != NULL;
- curdrv = nextdrv) {
- nextdrv = curdrv->next;
- sysfs_close_driver(curdrv);
- }
+ if (bus->devices)
+ dlist_destroy(bus->devices);
+ if (bus->drivers)
+ dlist_destroy(bus->drivers);
free(bus);
}
}
* open_bus_dir: opens up sysfs bus directory
* returns sysfs_directory struct with success and NULL with error
*/
-static struct sysfs_directory *open_bus_dir(const char *name)
+static struct sysfs_directory *open_bus_dir(const unsigned char *name)
{
- struct sysfs_directory *busdir = NULL, *cur = NULL, *next = NULL;
- char buspath[SYSFS_PATH_MAX];
+ struct sysfs_directory *busdir = NULL;
+ unsigned char buspath[SYSFS_PATH_MAX];
if (name == NULL) {
errno = EINVAL;
memset(buspath, 0, SYSFS_PATH_MAX);
if ((sysfs_get_mnt_path(buspath, SYSFS_PATH_MAX)) != 0) {
- dprintf(stderr, "Sysfs not supported on this system\n");
+ dprintf("Sysfs not supported on this system\n");
return NULL;
}
busdir = sysfs_open_directory(buspath);
if (busdir == NULL) {
errno = EINVAL;
- dprintf(stderr,"Bus %s not supported on this system\n",
+ dprintf("Bus %s not supported on this system\n",
name);
return NULL;
}
if ((sysfs_read_directory(busdir)) != 0) {
- dprintf(stderr, "Error reading %s bus dir %s\n", name,
+ dprintf("Error reading %s bus dir %s\n", name,
buspath);
sysfs_close_directory(busdir);
return NULL;
}
/* read in devices and drivers subdirs */
- for (cur = busdir->subdirs; cur != NULL; cur = next) {
- next = cur->next;
- if ((sysfs_read_directory(cur)) != 0)
- continue;
- }
+ sysfs_read_all_subdirs(busdir);
return busdir;
}
-/**
- * add_dev_to_bus: adds a bus device to bus device list
- * @bus: bus to add the device
- * @dev: device to add
- */
-static void add_dev_to_bus(struct sysfs_bus *bus, struct sysfs_device *dev)
-{
- if (bus != NULL && dev != NULL) {
- dev->next = bus->devices;
- bus->devices = dev;
- }
-}
-
-/**
- * add_driver_to_bus: adds a bus driver to bus driver list
- * @bus: bus to add driver to
- * @driver: driver to add
- */
-static void add_driver_to_bus(struct sysfs_bus *bus,
- struct sysfs_driver *driver)
-{
- if (bus != NULL && driver != NULL) {
- driver->next = bus->drivers;
- bus->drivers = driver;
- }
-}
-
/**
* get_all_bus_devices: gets all devices for bus
* @bus: bus to get devices for
{
struct sysfs_device *bdev = NULL;
struct sysfs_directory *cur = NULL;
- struct sysfs_dlink *curl = NULL, *nextl = NULL;
- char dirname[SYSFS_NAME_LEN];
+ struct sysfs_link *curl = NULL;
if (bus == NULL || bus->directory == NULL) {
errno = EINVAL;
return -1;
}
- for (cur = bus->directory->subdirs; cur != NULL; cur = cur->next) {
- memset(dirname, 0, SYSFS_NAME_LEN);
- if ((sysfs_get_name_from_path(cur->path, dirname,
- SYSFS_NAME_LEN)) != 0)
+ if (bus->directory->subdirs == NULL)
+ return 0;
+
+ dlist_for_each_data(bus->directory->subdirs, cur,
+ struct sysfs_directory) {
+ if (strcmp(cur->name, SYSFS_DEVICES_NAME) != 0)
continue;
- if (strcmp(dirname, SYSFS_DEVICES_NAME) != 0)
+ if (cur->links == NULL)
continue;
- for (curl = cur->links; curl != NULL; curl = nextl) {
- nextl = curl->next;
- bdev = sysfs_open_device(curl->target->path);
+ dlist_for_each_data(cur->links, curl, struct sysfs_link) {
+ bdev = sysfs_open_device(curl->target);
if (bdev == NULL) {
- dprintf(stderr, "Error opening device at %s\n",
- curl->target->path);
+ dprintf("Error opening device at %s\n",
+ curl->target);
continue;
}
- add_dev_to_bus(bus, bdev);
+ if (bus->devices == NULL)
+ bus->devices = dlist_new_with_delete
+ (sizeof(struct sysfs_device),
+ sysfs_close_dev);
+ dlist_unshift(bus->devices, bdev);
}
}
static int get_all_bus_drivers(struct sysfs_bus *bus)
{
struct sysfs_driver *driver = NULL;
- struct sysfs_directory *cur = NULL, *next = NULL;
- struct sysfs_directory *cursub = NULL, *nextsub = NULL;
- char dirname[SYSFS_NAME_LEN];
+ struct sysfs_directory *cur = NULL;
+ struct sysfs_directory *cursub = NULL;
if (bus == NULL || bus->directory == NULL) {
errno = EINVAL;
return -1;
}
- for (cur = bus->directory->subdirs; cur != NULL; cur = next) {
- next = cur->next;
- memset(dirname, 0, SYSFS_NAME_LEN);
- if ((sysfs_get_name_from_path(cur->path, dirname,
- SYSFS_NAME_LEN)) != 0)
+ if (bus->directory->subdirs == NULL)
+ return 0;
+
+ dlist_for_each_data(bus->directory->subdirs, cur,
+ struct sysfs_directory) {
+ if (strcmp(cur->name, SYSFS_DRIVERS_NAME) != 0)
continue;
- if (strcmp(dirname, SYSFS_DRIVERS_NAME) != 0)
+ if (cur->subdirs == NULL)
continue;
- for (cursub = cur->subdirs; cursub != NULL; cursub = nextsub) {
- nextsub = cursub->next;
+ dlist_for_each_data(cur->subdirs, cursub,
+ struct sysfs_directory) {
driver = sysfs_open_driver(cursub->path);
if (driver == NULL) {
- dprintf(stderr, "Error opening driver at %s\n",
+ dprintf("Error opening driver at %s\n",
cursub->path);
continue;
}
- add_driver_to_bus(bus, driver);
+ if (bus->drivers == NULL)
+ bus->drivers = dlist_new_with_delete
+ (sizeof(struct sysfs_driver),
+ sysfs_close_drv);
+ dlist_unshift(bus->drivers, driver);
}
}
* @busid: busid of device to match
* returns 1 if found and 0 if not found
*/
-static int match_bus_device_to_driver(struct sysfs_driver *driver, char *busid)
+static int match_bus_device_to_driver(struct sysfs_driver *driver,
+ unsigned char *busid)
{
- struct sysfs_dlink *cur = NULL, *next = NULL;
+ struct sysfs_link *cur = NULL;
int found = 0;
if (driver == NULL || driver->directory == NULL || busid == NULL) {
errno = EINVAL;
return found;
}
- for (cur = driver->directory->links; cur != NULL && found == 0;
- cur = next) {
- next = cur->next;
- if ((strcmp(cur->name, busid)) == 0)
- found++;
+ if (driver->directory->links != NULL) {
+ dlist_for_each_data(driver->directory->links, cur,
+ struct sysfs_link) {
+ if ((strcmp(cur->name, busid)) == 0)
+ found++;
+ }
}
return found;
}
*/
static void link_bus_devices_to_drivers(struct sysfs_bus *bus)
{
- struct sysfs_device *dev = NULL, *nextdev = NULL;
- struct sysfs_driver *drv = NULL, *nextdrv = NULL;
+ struct sysfs_device *dev = NULL;
+ struct sysfs_driver *drv = NULL;
if (bus != NULL && bus->devices != NULL && bus->drivers != NULL) {
- for (dev = bus->devices; dev != NULL; dev = nextdev) {
- nextdev = dev->next;
-
- for (drv = bus->drivers; drv != NULL; drv = nextdrv) {
- nextdrv = drv->next;
+ dlist_for_each_data(bus->devices, dev, struct sysfs_device) {
+ dlist_for_each_data(bus->drivers, drv,
+ struct sysfs_driver) {
if ((match_bus_device_to_driver(drv,
- dev->bus_id)) != 0) {
- dev->driver = drv;
- drv->device = dev;
+ dev->bus_id)) != 0) {
+ strncpy(dev->driver_name, drv->name,
+ SYSFS_NAME_LEN);
+ if (drv->devices == NULL)
+ drv->devices = dlist_new
+ (sizeof(struct
+ sysfs_device));
+ dlist_unshift(drv->devices, dev);
}
}
}
* sysfs_open_bus: opens specific bus and all its devices on system
* returns sysfs_bus structure with success or NULL with error.
*/
-struct sysfs_bus *sysfs_open_bus(const char *name)
+struct sysfs_bus *sysfs_open_bus(const unsigned char *name)
{
struct sysfs_bus *bus = NULL;
struct sysfs_directory *busdir = NULL;
bus = alloc_bus();
if (bus == NULL) {
- perror("malloc");
+ dprintf("calloc failed\n");
return NULL;
}
strcpy(bus->name, name);
busdir = open_bus_dir(name);
if (busdir == NULL) {
- dprintf(stderr,"Invalid bus, %s not supported on this system\n",
+ dprintf("Invalid bus, %s not supported on this system\n",
name);
sysfs_close_bus(bus);
return NULL;
}
+ strcpy(bus->path, busdir->path);
bus->directory = busdir;
if ((get_all_bus_devices(bus)) != 0) {
- dprintf(stderr, "Error reading %s bus devices\n", name);
+ dprintf("Error reading %s bus devices\n", name);
sysfs_close_bus(bus);
return NULL;
}
if ((get_all_bus_drivers(bus)) != 0) {
- dprintf(stderr, "Error reading %s bus drivers\n", name);
+ dprintf("Error reading %s bus drivers\n", name);
sysfs_close_bus(bus);
return NULL;
}
return bus;
}
+
+/**
+ * sysfs_get_bus_device: Get specific device on bus using device's id
+ * @bus: bus to find device on
+ * @id: bus_id for device
+ * returns struct sysfs_device reference or NULL if not found.
+ */
+struct sysfs_device *sysfs_get_bus_device(struct sysfs_bus *bus,
+ unsigned char *id)
+{
+ if (bus == NULL || id == NULL) {
+ errno = EINVAL;
+ return NULL;
+ }
+
+ return (struct sysfs_device *)dlist_find_custom(bus->devices, id,
+ bus_device_id_equal);
+}
+
+/**
+ * sysfs_get_bus_driver: Get specific driver on bus using driver name
+ * @bus: bus to find driver on
+ * @drvname: name of driver
+ * returns struct sysfs_driver reference or NULL if not found.
+ */
+struct sysfs_driver *sysfs_get_bus_driver(struct sysfs_bus *bus,
+ unsigned char *drvname)
+{
+ if (bus == NULL || drvname == NULL) {
+ errno = EINVAL;
+ return NULL;
+ }
+
+ return (struct sysfs_driver *)dlist_find_custom(bus->drivers, drvname,
+ bus_driver_name_equal);
+}
+
+/**
+ * sysfs_get_bus_attributes: returns bus' dlist of attributes
+ * @bus: bus to get attributes for.
+ * returns dlist of attributes or NULL if there aren't any.
+ */
+struct dlist *sysfs_get_bus_attributes(struct sysfs_bus *bus)
+{
+ if (bus == NULL || bus->directory == NULL)
+ return NULL;
+ return bus->directory->attributes;
+}
+
+/**
+ * sysfs_get_bus_attribute: gets a specific bus attribute, if buses had
+ * attributes.
+ * @bus: bus to retrieve attribute from
+ * @attrname: attribute name to retrieve
+ * returns reference to sysfs_attribute if found or NULL if not found
+ */
+struct sysfs_attribute *sysfs_get_bus_attribute(struct sysfs_bus *bus,
+ unsigned char *attrname)
+{
+ if (bus == NULL || bus->directory == NULL || attrname == NULL) {
+ errno = EINVAL;
+ return NULL;
+ }
+ return sysfs_get_directory_attribute(bus->directory, attrname);
+}
+
+/**
+ * sysfs_open_bus_device: locates a device on a bus and returns it. Device
+ * must be closed using sysfs_close_device.
+ * @busname: Name of bus to search
+ * @dev_id: Id of device on bus.
+ * returns sysfs_device if found or NULL if not.
+ */
+struct sysfs_device *sysfs_open_bus_device(unsigned char *busname,
+ unsigned char *dev_id)
+{
+ struct sysfs_device *rdev = NULL;
+ char path[SYSFS_PATH_MAX];
+
+ if (busname == NULL || dev_id == NULL) {
+ errno = EINVAL;
+ return NULL;
+ }
+
+ memset(path, 0, SYSFS_PATH_MAX);
+ if (sysfs_get_mnt_path(path, SYSFS_PATH_MAX) != 0) {
+ dprintf("Error getting sysfs mount point\n");
+ return NULL;
+ }
+
+ strcat(path, SYSFS_BUS_DIR);
+ strcat(path, "/");
+ strcat(path, busname);
+ strcat(path, SYSFS_DEVICES_DIR);
+ strcat(path, "/");
+ strcat(path, dev_id);
+
+ rdev = sysfs_open_device(path);
+ if (rdev == NULL) {
+ dprintf("Error getting device %s on bus %s\n",
+ dev_id, busname);
+ return NULL;
+ }
+
+ return rdev;
+}
+
+/**
+ * sysfs_find_device_bus: locates the bus a device is on.
+ * @dev_id: device id.
+ * @busname: buffer to copy name to
+ * @bsize: buffer size
+ * returns 0 with success or -1 with error
+ */
+int sysfs_find_device_bus(const unsigned char *dev_id, unsigned char *busname,
+ size_t bsize)
+{
+ unsigned char subsys[SYSFS_NAME_LEN], *bus = NULL, *curdev = NULL;
+ struct dlist *buslist = NULL, *device_list = NULL;
+
+ if (dev_id == NULL || busname == NULL) {
+ errno = EINVAL;
+ return -1;
+ }
+
+ strcpy(subsys, SYSFS_BUS_DIR); /* subsys = /bus */
+ buslist = sysfs_open_subsystem_list(subsys);
+ if (buslist != NULL) {
+ dlist_for_each_data(buslist, bus, char) {
+ device_list = sysfs_open_bus_devices_list(bus);
+ if (device_list != NULL) {
+ dlist_for_each_data(device_list,
+ curdev, char) {
+ if (strcmp(dev_id, curdev) == 0) {
+ strncpy(busname,
+ bus, bsize);
+ sysfs_close_list(device_list);
+ sysfs_close_list(buslist);
+ return 0;
+ }
+ }
+ sysfs_close_list(device_list);
+ }
+ }
+ sysfs_close_list(buslist);
+ }
+ return -1;
+}
+
+/**
+ * sysfs_find_driver_bus: locates the bus the driver is on.
+ * @driver: name of the driver to locate
+ * @busname: buffer to copy name to
+ * @bsize: buffer size
+ * returns 0 with success, -1 with error
+ */
+int sysfs_find_driver_bus(const unsigned char *driver, unsigned char *busname,
+ size_t bsize)
+{
+ unsigned char subsys[SYSFS_PATH_MAX], *bus = NULL, *curdrv = NULL;
+ struct dlist *buslist = NULL, *drivers = NULL;
+
+ if (driver == NULL || busname == NULL) {
+ errno = EINVAL;
+ return -1;
+ }
+
+ memset(subsys, 0, SYSFS_PATH_MAX);
+ strcpy(subsys, SYSFS_BUS_DIR);
+ buslist = sysfs_open_subsystem_list(subsys);
+ if (buslist != NULL) {
+ dlist_for_each_data(buslist, bus, char) {
+ memset(subsys, 0, SYSFS_PATH_MAX);
+ strcpy(subsys, SYSFS_BUS_DIR);
+ strcat(subsys, "/");
+ strcat(subsys, bus);
+ strcat(subsys, SYSFS_DRIVERS_DIR);
+ drivers = sysfs_open_subsystem_list(subsys);
+ if (drivers != NULL) {
+ dlist_for_each_data(drivers, curdrv, char) {
+ if (strcmp(driver, curdrv) == 0) {
+ strncpy(busname, bus, bsize);
+ sysfs_close_list(drivers);
+ sysfs_close_list(buslist);
+ return 0;
+ }
+ }
+ sysfs_close_list(drivers);
+ }
+ }
+ sysfs_close_list(buslist);
+ }
+ return -1;
+}
+
*
* Generic class utility functions for libsysfs
*
- * Copyright (C) 2003 International Business Machines, Inc.
+ * Copyright (C) IBM Corp. 2003
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
#include "libsysfs.h"
#include "sysfs.h"
+void sysfs_close_cls_dev(void *dev)
+{
+ sysfs_close_class_device((struct sysfs_class_device *)dev);
+}
+
+/**
+ * class_name_equal: compares class_devices' name
+ * @a: class_name looking for
+ * @b: sysfs_class_device being compared
+ */
+static int class_name_equal(void *a, void *b)
+{
+ if (a == NULL || b == NULL)
+ return 0;
+
+ if (strcmp(((unsigned char *)a), ((struct sysfs_class_device *)b)->name)
+ == 0)
+ return 1;
+
+ return 0;
+}
+
/**
* sysfs_close_class_device: closes a single class device.
* @dev: class device to close.
*/
void sysfs_close_class(struct sysfs_class *cls)
{
- struct sysfs_class_device *cur = NULL, *next = NULL;
-
if (cls != NULL) {
if (cls->directory != NULL)
sysfs_close_directory(cls->directory);
- for (cur = cls->devices; cur != NULL; cur = next) {
- next = cur->next;
- sysfs_close_class_device(cur);
- }
+ if (cls->devices != NULL)
+ dlist_destroy(cls->devices);
free(cls);
}
}
* open_class_dir: opens up sysfs class directory
* returns sysfs_directory struct with success and NULL with error
*/
-static struct sysfs_directory *open_class_dir(const char *name)
+static struct sysfs_directory *open_class_dir(const unsigned char *name)
{
struct sysfs_directory *classdir = NULL;
- char classpath[SYSFS_PATH_MAX];
+ unsigned char classpath[SYSFS_PATH_MAX];
if (name == NULL) {
errno = EINVAL;
memset(classpath, 0, SYSFS_PATH_MAX);
if ((sysfs_get_mnt_path(classpath, SYSFS_PATH_MAX)) != 0) {
- dprintf(stderr, "Sysfs not supported on this system\n");
+ dprintf("Sysfs not supported on this system\n");
return NULL;
}
classdir = sysfs_open_directory(classpath);
if (classdir == NULL) {
errno = EINVAL;
- dprintf(stderr,"Class %s not supported on this system\n",
- name);
+ dprintf("Class %s not supported on this system\n", name);
return NULL;
}
if ((sysfs_read_directory(classdir)) != 0) {
- dprintf(stderr, "Error reading %s class dir %s\n", name,
- classpath);
+ dprintf("Error reading %s class dir %s\n", name, classpath);
sysfs_close_directory(classdir);
return NULL;
}
* @path: path to class device.
* returns struct sysfs_class_device with success and NULL with error.
*/
-struct sysfs_class_device *sysfs_open_class_device(const char *path)
+struct sysfs_class_device *sysfs_open_class_device(const unsigned char *path)
{
struct sysfs_class_device *cdev = NULL;
- struct sysfs_directory *dir = NULL, *cur = NULL;
- struct sysfs_dlink *curl = NULL;
+ struct sysfs_directory *dir = NULL;
+ struct sysfs_link *curl = NULL;
struct sysfs_device *sdev = NULL;
struct sysfs_driver *drv = NULL;
- char temp[SYSFS_NAME_LEN];
if (path == NULL) {
errno = EINVAL;
}
cdev = alloc_class_device();
if (cdev == NULL) {
- perror("malloc");
+ dprintf("calloc failed\n");
return NULL;
}
- memset(temp, 0, SYSFS_NAME_LEN);
- if ((sysfs_get_name_from_path(path, temp, SYSFS_NAME_LEN)) != 0) {
+ if ((sysfs_get_name_from_path(path, cdev->name, SYSFS_NAME_LEN)) != 0) {
errno = EINVAL;
- dprintf(stderr, "Invalid class device path %s\n", path);
+ dprintf("Invalid class device path %s\n", path);
sysfs_close_class_device(cdev);
return NULL;
}
- strcpy(cdev->name, temp);
dir = sysfs_open_directory(path);
if (dir == NULL) {
- dprintf(stderr, "Error opening class device at %s\n", path);
+ dprintf("Error opening class device at %s\n", path);
sysfs_close_class_device(cdev);
return NULL;
}
if ((sysfs_read_directory(dir)) != 0) {
- dprintf(stderr, "Error reading class device at %s\n", path);
+ dprintf("Error reading class device at %s\n", path);
sysfs_close_directory(dir);
sysfs_close_class_device(cdev);
return NULL;
}
+ sysfs_read_all_subdirs(dir);
cdev->directory = dir;
+ strcpy(cdev->path, dir->path);
- cur = cdev->directory->subdirs;
- while(cur != NULL) {
- sysfs_read_directory(cur);
- cur = cur->next;
- }
/* get driver and device, if implemented */
- curl = cdev->directory->links;
- while (curl != NULL) {
- if (strncmp(curl->name, SYSFS_DEVICES_NAME, 6) == 0) {
- sdev = sysfs_open_device(curl->target->path);
- if (sdev != NULL) {
- cdev->sysdevice = sdev;
- if (cdev->driver != NULL)
- sdev->driver = cdev->driver;
- }
- } else if (strncmp(curl->name, SYSFS_DRIVERS_NAME, 6) == 0) {
- drv = sysfs_open_driver(curl->target->path);
- if (drv != NULL) {
- cdev->driver = drv;
- if (cdev->sysdevice != NULL)
- drv->device = cdev->sysdevice;
+ if (cdev->directory->links != NULL) {
+ dlist_for_each_data(cdev->directory->links, curl,
+ struct sysfs_link) {
+ if (strncmp(curl->name, SYSFS_DEVICES_NAME, 6) == 0) {
+ sdev = sysfs_open_device(curl->target);
+ if (sdev != NULL) {
+ cdev->sysdevice = sdev;
+ if (cdev->driver != NULL)
+ strncpy(sdev->driver_name,
+ cdev->driver->name,
+ SYSFS_NAME_LEN);
+ }
+ } else if (strncmp(curl->name,
+ SYSFS_DRIVERS_NAME, 6) == 0) {
+ drv = sysfs_open_driver(curl->target);
+ if (drv != NULL) {
+ cdev->driver = drv;
+ if (cdev->sysdevice != NULL) {
+ strncpy(cdev->sysdevice->name,
+ drv->name,
+ SYSFS_NAME_LEN);
+ if (drv->devices == NULL)
+ drv->devices =
+ dlist_new
+ (sizeof(struct
+ sysfs_device));
+ dlist_unshift(drv->devices,
+ cdev->sysdevice);
+ }
+ }
}
}
- curl = curl->next;
}
return cdev;
}
-/**
- * add_dev_to_class: adds a class device to class list
- * @class: class to add the device
- * @dev: device to add
- */
-static void add_dev_to_class(struct sysfs_class *cls,
- struct sysfs_class_device *dev)
-{
- if (cls != NULL && dev != NULL) {
- dev->next = cls->devices;
- cls->devices = dev;
- }
-}
-
/**
* get_all_class_devices: gets all devices for class
* @class: class to get devices for
static int get_all_class_devices(struct sysfs_class *cls)
{
struct sysfs_class_device *dev = NULL;
- struct sysfs_directory *cur = NULL, *next = NULL;
+ struct sysfs_directory *cur = NULL;
if (cls == NULL || cls->directory == NULL) {
errno = EINVAL;
return -1;
}
- for (cur = cls->directory->subdirs; cur != NULL; cur = next) {
- next = cur->next;
+ if (cls->directory->subdirs == NULL)
+ return 0;
+ dlist_for_each_data(cls->directory->subdirs, cur,
+ struct sysfs_directory) {
dev = sysfs_open_class_device(cur->path);
if (dev == NULL) {
- dprintf(stderr, "Error opening device at %s\n",
- cur->path);
+ dprintf("Error opening device at %s\n", cur->path);
continue;
}
- add_dev_to_class(cls, dev);
+ if (cls->devices == NULL)
+ cls->devices = dlist_new_with_delete
+ (sizeof(struct sysfs_class_device),
+ sysfs_close_cls_dev);
+ dlist_unshift(cls->devices, dev);
}
-
return 0;
}
* sysfs_open_class: opens specific class and all its devices on system
* returns sysfs_class structure with success or NULL with error.
*/
-struct sysfs_class *sysfs_open_class(const char *name)
+struct sysfs_class *sysfs_open_class(const unsigned char *name)
{
struct sysfs_class *cls = NULL;
struct sysfs_directory *classdir = NULL;
cls = alloc_class();
if (cls == NULL) {
- perror("malloc");
+ dprintf("calloc failed\n");
return NULL;
}
strcpy(cls->name, name);
classdir = open_class_dir(name);
if (classdir == NULL) {
- dprintf(stderr,
- "Invalid class, %s not supported on this system\n",
+ dprintf("Invalid class, %s not supported on this system\n",
name);
sysfs_close_class(cls);
return NULL;
}
cls->directory = classdir;
+ strcpy(cls->path, classdir->path);
if ((get_all_class_devices(cls)) != 0) {
- dprintf(stderr, "Error reading %s class devices\n", name);
+ dprintf("Error reading %s class devices\n", name);
sysfs_close_class(cls);
return NULL;
}
return cls;
}
+
+/**
+ * sysfs_get_class_device: Get specific class device using the device's id
+ * @class: class to find device on
+ * @name: class name of the device
+ */
+struct sysfs_class_device *sysfs_get_class_device(struct sysfs_class *class,
+ unsigned char *name)
+{
+ if (class == NULL || name == NULL) {
+ errno = EINVAL;
+ return NULL;
+ }
+
+ return (struct sysfs_class_device *)dlist_find_custom(class->devices,
+ name, class_name_equal);
+}
+
+/**
+ * sysfs_open_class_device_by_name: Locates a specific class_device and returns it.
+ * Class_device must be closed using sysfs_close_class_device
+ * @classname: Class to search
+ * @name: name of the class_device
+ */
+struct sysfs_class_device *sysfs_open_class_device_by_name
+ (const unsigned char *classname, unsigned char *name)
+{
+ struct sysfs_class *class = NULL;
+ struct sysfs_class_device *cdev = NULL, *rcdev = NULL;
+
+ if (classname == NULL || name == NULL) {
+ errno = EINVAL;
+ return NULL;
+ }
+
+ class = sysfs_open_class(classname);
+ if (class == NULL) {
+ dprintf("Error opening class %s\n", classname);
+ return NULL;
+ }
+
+ cdev = sysfs_get_class_device(class, name);
+ if (cdev == NULL) {
+ dprintf("Error getting class device %s from class %s\n",
+ name, classname);
+ sysfs_close_class(class);
+ return NULL;
+ }
+
+ rcdev = sysfs_open_class_device(cdev->directory->path);
+ if (rcdev == NULL) {
+ dprintf("Error getting class device %s from class %s\n",
+ name, classname);
+ sysfs_close_class(class);
+ return NULL;
+ }
+ sysfs_close_class(class);
+
+ return rcdev;
+}
+
+/**
+ * sysfs_get_classdev_attributes: returns a dlist of attributes for
+ * the requested class_device
+ * @cdev: sysfs_class_dev for which attributes are needed
+ * returns a dlist of attributes if exists, NULL otherwise
+ */
+struct dlist *sysfs_get_classdev_attributes(struct sysfs_class_device *cdev)
+{
+ if (cdev == NULL || cdev->directory == NULL)
+ return NULL;
+
+ return (cdev->directory->attributes);
+}
+
+/**
+ * sysfs_find_device_class: locates the device the device is on
+ * @bus_id: device to look for
+ * @classname: buffer to copy class name to
+ * @bsize: size of buffer
+ * returns 0 with success and -1 with error
+ */
+int sysfs_find_device_class(const unsigned char *bus_id,
+ unsigned char *classname, size_t bsize)
+{
+ unsigned char class[SYSFS_NAME_LEN], clspath[SYSFS_NAME_LEN];
+ unsigned char *cls = NULL, *clsdev = NULL;
+ struct dlist *clslist = NULL, *clsdev_list = NULL;
+
+ if (bus_id == NULL || classname == NULL) {
+ errno = EINVAL;
+ return -1;
+ }
+
+ strcpy(class, SYSFS_CLASS_DIR);
+ clslist = sysfs_open_subsystem_list(class);
+ if (clslist != NULL) {
+ dlist_for_each_data(clslist, cls, char) {
+ memset(clspath, 0, SYSFS_NAME_LEN);
+ strcpy(clspath, SYSFS_CLASS_DIR);
+ strcat(clspath, "/");
+ strcat(clspath, cls);
+ clsdev_list = sysfs_open_subsystem_list(clspath);
+ if (clsdev_list != NULL) {
+ dlist_for_each_data(clsdev_list,
+ clsdev, char) {
+ if (strcmp(bus_id, clsdev) == 0) {
+ strncpy(classname,
+ cls, bsize);
+ sysfs_close_list(clsdev_list);
+ sysfs_close_list(clslist);
+ return 0;
+ }
+ }
+ sysfs_close_list(clsdev_list);
+ }
+ }
+ sysfs_close_list(clslist);
+ }
+ return -1;
+}
+
+/**
+ * sysfs_get_classdev_attr: searches class device's attributes by name
+ * @clsdev: class device to look through
+ * @name: attribute name to get
+ * returns sysfs_attribute reference with success or NULL with error
+ */
+struct sysfs_attribute *sysfs_get_classdev_attr
+ (struct sysfs_class_device *clsdev, const unsigned char *name)
+{
+ struct sysfs_attribute *cur = NULL;
+
+ if (clsdev == NULL || clsdev->directory == NULL ||
+ clsdev->directory->attributes == NULL || name == NULL) {
+ errno = EINVAL;
+ return NULL;
+ }
+
+ cur = sysfs_get_directory_attribute(clsdev->directory,
+ (unsigned char *)name);
+ if (cur != NULL)
+ return cur;
+
+ return NULL;
+}
+
+/**
+ * sysfs_write_classdev_attr: modify writable attribute value for the given
+ * class device
+ * @dev: class device name for which the attribute has to be changed
+ * @attrib: attribute to change
+ * @value: value to change to
+ * @len: size of buffer at "value"
+ * Returns 0 on success and -1 on error
+ */
+int sysfs_write_classdev_attr(unsigned char *dev, unsigned char *attrib,
+ unsigned char *value, size_t len)
+{
+ struct sysfs_class_device *clsdev = NULL;
+ struct sysfs_attribute *attribute = NULL;
+ unsigned char class_name[SYSFS_NAME_LEN];
+
+ if (dev == NULL || attrib == NULL || value == NULL) {
+ errno = EINVAL;
+ return -1;
+ }
+
+ memset(class_name, 0, SYSFS_NAME_LEN);
+ if ((sysfs_find_device_class(dev,
+ class_name, SYSFS_NAME_LEN)) < 0) {
+ dprintf("Class device %s not found\n", dev);
+ return -1;
+ }
+ clsdev = sysfs_open_class_device_by_name(class_name, dev);
+ if (clsdev == NULL) {
+ dprintf("Error opening %s in class %s\n", dev, class_name);
+ return -1;
+ }
+ attribute = sysfs_get_directory_attribute(clsdev->directory, attrib);
+ if (attribute == NULL) {
+ dprintf("Attribute %s not defined for device %s on class %s\n",
+ attrib, dev, class_name);
+ sysfs_close_class_device(clsdev);
+ return -1;
+ }
+ if ((sysfs_write_attribute(attribute, value, len)) < 0) {
+ dprintf("Error setting %s to %s\n", attrib, value);
+ sysfs_close_class_device(clsdev);
+ return -1;
+ }
+ sysfs_close_class_device(clsdev);
+ return 0;
+}
+
+/**
+ * sysfs_read_classdev_attr: read an attribute for a given class device
+ * @dev: class device name for which the attribute has to be read
+ * @attrib: attribute to read
+ * @value: buffer to return value to user
+ * @len: size of buffer at "value"
+ * Returns 0 on success and -1 on error
+ */
+int sysfs_read_classdev_attr(unsigned char *dev, unsigned char *attrib,
+ unsigned char *value, size_t len)
+{
+ struct sysfs_class_device *clsdev = NULL;
+ struct sysfs_attribute *attribute = NULL;
+ unsigned char class_name[SYSFS_NAME_LEN];
+
+ if (dev == NULL || attrib == NULL || value == NULL) {
+ errno = EINVAL;
+ return -1;
+ }
+
+ memset(class_name, 0, SYSFS_NAME_LEN);
+ if ((sysfs_find_device_class(dev,
+ class_name, SYSFS_NAME_LEN)) < 0) {
+ dprintf("Class device %s not found\n", dev);
+ return -1;
+ }
+ clsdev = sysfs_open_class_device_by_name(class_name, dev);
+ if (clsdev == NULL) {
+ dprintf("Error opening %s in class %s\n", dev, class_name);
+ return -1;
+ }
+ attribute = sysfs_get_directory_attribute(clsdev->directory, attrib);
+ if (attribute == NULL) {
+ dprintf("Attribute %s not defined for device %s on class %s\n",
+ attrib, dev, class_name);
+ sysfs_close_class_device(clsdev);
+ return -1;
+ }
+ if (attribute->len > len) {
+ dprintf("Value length %d is greater that suppled buffer %d\n",
+ attribute->len, len);
+ sysfs_close_class_device(clsdev);
+ return -1;
+ }
+ strncpy(value, attribute->value, attribute->len);
+ value[(attribute->len)+1] = 0;
+ sysfs_close_class_device(clsdev);
+ return 0;
+}
*
* Generic device utility functions for libsysfs
*
- * Copyright (C) 2003 International Business Machines, Inc.
+ * Copyright (C) IBM Corp. 2003
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
#include "libsysfs.h"
#include "sysfs.h"
+/**
+ * sysfs_close_device_tree: closes every device in the supplied tree,
+ * closing children only.
+ * @devroot: device root of tree.
+ */
+static void sysfs_close_device_tree(struct sysfs_device *devroot)
+{
+ if (devroot != NULL) {
+ if (devroot->children != NULL) {
+ struct sysfs_device *child = NULL;
+
+ dlist_for_each_data(devroot->children, child,
+ struct sysfs_device) {
+ sysfs_close_device_tree(child);
+ }
+ }
+ sysfs_close_device(devroot);
+ }
+}
+
+/**
+ * sysfs_del_device: routine for dlist integration
+ */
+static void sysfs_del_device(void *dev)
+{
+ sysfs_close_device((struct sysfs_device *)dev);
+}
+
+/**
+ * sysfs_close_dev_tree: routine for dlist integration
+ */
+static void sysfs_close_dev_tree(void *dev)
+{
+ sysfs_close_device_tree((struct sysfs_device *)dev);
+}
+
/**
* sysfs_close_device: closes and cleans up a device
* @dev = device to clean up
void sysfs_close_device(struct sysfs_device *dev)
{
if (dev != NULL) {
- dev->next = NULL;
- dev->driver = NULL;
if (dev->directory != NULL)
sysfs_close_directory(dev->directory);
- dev->children = NULL;
+ if (dev->children != NULL && dev->children->count == 0)
+ dlist_destroy(dev->children);
free(dev);
}
}
* returns sysfs_attribute reference with success or NULL with error.
*/
struct sysfs_attribute *sysfs_get_device_attr(struct sysfs_device *dev,
- const char *name)
+ const unsigned char *name)
{
struct sysfs_attribute *cur = NULL;
- char attrname[SYSFS_NAME_LEN];
- if (dev == NULL || dev->directory == NULL || name == NULL) {
+ if (dev == NULL || dev->directory == NULL
+ || dev->directory->attributes == NULL || name == NULL) {
errno = EINVAL;
return NULL;
}
- for (cur = dev->directory->attributes; cur != NULL; cur = cur->next) {
- if ((sysfs_get_name_from_path(cur->path, attrname,
- SYSFS_NAME_LEN)) != 0)
- continue;
- if (strcmp(name, attrname) != 0)
- continue;
-
+
+ cur = sysfs_get_directory_attribute(dev->directory,
+ (unsigned char *)name);
+ if (cur != NULL)
return cur;
- }
return NULL;
}
* @path: path to device, this is the /sys/devices/ path
* returns sysfs_device structure with success or NULL with error
*/
-struct sysfs_device *sysfs_open_device(const char *path)
+struct sysfs_device *sysfs_open_device(const unsigned char *path)
{
struct sysfs_device *dev = NULL;
struct sysfs_directory *sdir = NULL;
- char *p = NULL;
if (path == NULL) {
errno = EINVAL;
}
dev = alloc_device();
if (dev == NULL) {
- dprintf(stderr, "Error allocating device at %s\n", path);
+ dprintf("Error allocating device at %s\n", path);
return NULL;
}
sdir = sysfs_open_directory(path);
if (sdir == NULL) {
- dprintf(stderr, "Invalid device at %s\n", path);
+ dprintf("Invalid device at %s\n", path);
errno = EINVAL;
sysfs_close_device(dev);
return NULL;
}
if ((sysfs_read_directory(sdir)) != 0) {
- dprintf(stderr, "Error reading device directory at %s\n", path);
+ dprintf("Error reading device directory at %s\n", path);
sysfs_close_directory(sdir);
sysfs_close_device(dev);
return NULL;
}
dev->directory = sdir;
- sysfs_get_name_from_path(sdir->path, dev->bus_id, SYSFS_NAME_LEN);
- /* get device name */
- p = sysfs_get_value_from_attributes(sdir->attributes,
- SYSFS_NAME_ATTRIBUTE);
- if (p != NULL) {
- strncpy(dev->name, p, SYSFS_NAME_LEN);
- p = dev->name + strlen(dev->name) - 1;
- if ((strlen(dev->name) > 0) && *p == '\n')
- *p = '\0';
- }
+ strcpy(dev->bus_id, sdir->name);
+ strcpy(dev->path, sdir->path);
+
+ /*
+ * The "name" attribute no longer exists... return the device's
+ * sysfs representation instead, in the "dev->name" field, which
+ * implies that the dev->name and dev->bus_id contain same data.
+ */
+ strncpy(dev->name, sdir->name, SYSFS_NAME_LEN);
return dev;
}
/**
- * sysfs_close_device_tree: closes every device in the supplied tree,
- * closing children only.
- * @devroot: device root of tree.
+ * sysfs_open_device_tree: opens root device and all of its children,
+ * creating a tree of devices. Only opens children.
+ * @path: sysfs path to devices
+ * returns struct sysfs_device and its children with success or NULL with
+ * error.
*/
-void sysfs_close_device_tree(struct sysfs_device *devroot)
+static struct sysfs_device *sysfs_open_device_tree(const unsigned char *path)
{
- if (devroot != NULL) {
- if (devroot->children != NULL) {
- struct sysfs_device *child = NULL, *next = NULL;
-
- for (child = devroot->children; child != NULL;
- child = next) {
- next = child->next;
- sysfs_close_device_tree(child);
+ struct sysfs_device *rootdev = NULL, *new = NULL;
+ struct sysfs_directory *cur = NULL;
+
+ if (path == NULL) {
+ errno = EINVAL;
+ return NULL;
+ }
+ rootdev = sysfs_open_device(path);
+ if (rootdev == NULL) {
+ dprintf("Error opening root device at %s\n", path);
+ return NULL;
+ }
+ if (rootdev->directory->subdirs != NULL) {
+ dlist_for_each_data(rootdev->directory->subdirs, cur,
+ struct sysfs_directory) {
+ new = sysfs_open_device_tree(cur->path);
+ if (new == NULL) {
+ dprintf("Error opening device tree at %s\n",
+ cur->path);
+ sysfs_close_device_tree(rootdev);
+ return NULL;
}
+ if (rootdev->children == NULL)
+ rootdev->children = dlist_new_with_delete
+ (sizeof(struct sysfs_device),
+ sysfs_del_device);
+ dlist_unshift(rootdev->children, new);
}
- sysfs_close_device(devroot);
}
+
+ return rootdev;
}
/**
- * add_device_child_to_parent: adds child device to parent
- * @parent: parent device.
- * @child: child device to add.
+ * sysfs_close_root_device: closes root and all devices
+ * @root: root device to close
*/
-static void add_device_child_to_parent(struct sysfs_device *parent,
- struct sysfs_device *child)
+void sysfs_close_root_device(struct sysfs_root_device *root)
{
- if (parent != NULL && child != NULL) {
- child->next = parent->children;
- parent->children = child;
- child->parent = parent;
+ if (root != NULL) {
+ if (root->devices != NULL)
+ dlist_destroy(root->devices);
+ if (root->directory != NULL)
+ sysfs_close_directory(root->directory);
+ free(root);
}
}
/**
- * sysfs_open_device_tree: opens root device and all of its children,
- * creating a tree of devices. Only opens children.
- * @path: sysfs path to devices
- * returns struct sysfs_device and its children with success or NULL with
- * error.
+ * open_root_device_dir: opens up sysfs_directory for specific root dev
+ * @name: name of root
+ * returns struct sysfs_directory with success and NULL with error
*/
-struct sysfs_device *sysfs_open_device_tree(const char *path)
+static struct sysfs_directory *open_root_device_dir(const unsigned char *name)
{
- struct sysfs_device *rootdev = NULL, *new = NULL;
+ struct sysfs_directory *rdir = NULL;
+ unsigned char rootpath[SYSFS_PATH_MAX];
+
+ if (name == NULL) {
+ errno = EINVAL;
+ return NULL;
+ }
+
+ memset(rootpath, 0, SYSFS_PATH_MAX);
+ if (sysfs_get_mnt_path(rootpath, SYSFS_PATH_MAX) != 0) {
+ dprintf ("Sysfs not supported on this system\n");
+ return NULL;
+ }
+
+ strcat(rootpath, SYSFS_DEVICES_DIR);
+ strcat(rootpath, "/");
+ strcat(rootpath, name);
+ rdir = sysfs_open_directory(rootpath);
+ if (rdir == NULL) {
+ errno = EINVAL;
+ dprintf ("Root device %s not supported on this system\n",
+ name);
+ return NULL;
+ }
+ if (sysfs_read_directory(rdir) != 0) {
+ dprintf ("Error reading %s root device at dir %s\n", name,
+ rootpath);
+ sysfs_close_directory(rdir);
+ return NULL;
+ }
+
+ return rdir;
+}
+
+/**
+ * get_all_root_devices: opens up all the devices under this root device
+ * @root: root device to open devices for
+ * returns 0 with success and -1 with error
+ */
+static int get_all_root_devices(struct sysfs_root_device *root)
+{
+ struct sysfs_device *dev = NULL;
struct sysfs_directory *cur = NULL;
- if (path == NULL) {
+ if (root == NULL || root->directory == NULL) {
+ errno = EINVAL;
+ return -1;
+ }
+ if (root->directory->subdirs == NULL)
+ return 0;
+
+ dlist_for_each_data(root->directory->subdirs, cur,
+ struct sysfs_directory) {
+ dev = sysfs_open_device_tree(cur->path);
+ if (dev == NULL) {
+ dprintf ("Error opening device at %s\n", cur->path);
+ continue;
+ }
+ if (root->devices == NULL)
+ root->devices = dlist_new_with_delete
+ (sizeof(struct sysfs_device),
+ sysfs_close_dev_tree);
+ dlist_unshift(root->devices, dev);
+ }
+
+ return 0;
+}
+
+/**
+ * sysfs_open_root_device: opens sysfs devices root and all of its
+ * devices.
+ * @name: name of /sys/devices/root to open
+ * returns struct sysfs_root_device if success and NULL with error
+ */
+struct sysfs_root_device *sysfs_open_root_device(const unsigned char *name)
+{
+ struct sysfs_root_device *root = NULL;
+ struct sysfs_directory *rootdir = NULL;
+
+ if (name == NULL) {
errno = EINVAL;
return NULL;
}
- rootdev = sysfs_open_device(path);
- if (rootdev == NULL) {
- dprintf(stderr, "Error opening root device at %s\n", path);
+
+ root = (struct sysfs_root_device *)calloc
+ (1, sizeof(struct sysfs_root_device));
+ if (root == NULL) {
+ dprintf("calloc failure\n");
+ return NULL;
+ }
+ rootdir = open_root_device_dir(name);
+ if (rootdir == NULL) {
+ dprintf ("Invalid root device, %s not supported\n", name);
+ sysfs_close_root_device(root);
+ return NULL;
+ }
+ strcpy(root->path, rootdir->path);
+ root->directory = rootdir;
+ if (get_all_root_devices(root) != 0) {
+ dprintf ("Error retrieving devices for root %s\n", name);
+ sysfs_close_root_device(root);
+ return NULL;
+ }
+
+ return root;
+}
+
+/**
+ * sysfs_get_device_attributes: returns a dlist of attributes corresponding to
+ * the specific device
+ * @device: struct sysfs_device * for which attributes are to be returned
+ */
+struct dlist *sysfs_get_device_attributes(struct sysfs_device *device)
+{
+ if (device == NULL || device->directory == NULL)
+ return NULL;
+
+ return (device->directory->attributes);
+}
+
+/**
+ * sysfs_open_device_by_id: open a device by id (use the "bus" subsystem)
+ * @bus_id: bus_id of the device to open - has to be the "bus_id" in
+ * /sys/bus/xxx/devices
+ * @bus: bus the device belongs to
+ * @bsize: size of the bus buffer
+ * returns struct sysfs_device if found, NULL otherwise
+ * NOTE:
+ * 1. Use sysfs_close_device to close the device
+ * 2. Bus the device is on must be supplied
+ * Use sysfs_find_device_bus to get the bus name
+ */
+struct sysfs_device *sysfs_open_device_by_id(const unsigned char *bus_id,
+ const unsigned char *bus, size_t bsize)
+{
+ char sysfs_path[SYSFS_PATH_MAX], device_path[SYSFS_PATH_MAX];
+ struct sysfs_device *device = NULL;
+
+ if (bus_id == NULL || bus == NULL) {
+ errno = EINVAL;
+ return NULL;
+ }
+ memset(sysfs_path, 0, SYSFS_PATH_MAX);
+ if ((sysfs_get_mnt_path(sysfs_path, SYSFS_PATH_MAX)) != 0) {
+ dprintf("Error getting sysfs mount path\n");
+ return NULL;
+ }
+ strcat(sysfs_path, SYSFS_BUS_DIR);
+ strcat(sysfs_path, "/");
+ strncat(sysfs_path, bus, bsize);
+ strcat(sysfs_path, SYSFS_DEVICES_DIR);
+ strcat(sysfs_path, "/");
+ strcat(sysfs_path, bus_id);
+
+ /* devices under /sys/bus/xxx/devices are links to devices subsystem */
+ if ((sysfs_get_link(sysfs_path, device_path, SYSFS_PATH_MAX)) < 0) {
+ dprintf("Error getting device path\n");
+ return NULL;
+ }
+
+ device = sysfs_open_device(device_path);
+ if (device == NULL) {
+ dprintf("Error opening device %s\n", bus_id);
return NULL;
}
- cur = rootdev->directory->subdirs;
- while (cur != NULL) {
- new = sysfs_open_device_tree(cur->path);
- if (new == NULL) {
- dprintf(stderr, "Error opening device tree at %s\n",
- cur->path);
- sysfs_close_device_tree(rootdev);
- return NULL;
+
+ return device;
+}
+
+/**
+ * get_device_absolute_path: looks up the bus the device is on, gets
+ * absolute path to the device
+ * @device: device for which path is needed
+ * @path: buffer to store absolute path
+ * @psize: size of "path"
+ * Returns 0 on success -1 on failure
+ */
+static int get_device_absolute_path(const unsigned char *device,
+ unsigned char *path, size_t psize)
+{
+ unsigned char bus_name[SYSFS_NAME_LEN], bus_path[SYSFS_PATH_MAX];
+
+ if (device == NULL || path == NULL) {
+ errno = EINVAL;
+ return -1;
+ }
+
+ memset(bus_name, 0, SYSFS_NAME_LEN);
+ memset(bus_path, 0, SYSFS_NAME_LEN);
+ if ((sysfs_find_device_bus(device, bus_name, SYSFS_NAME_LEN)) != 0) {
+ dprintf("Device %s not found\n", device);
+ return -1;
+ }
+ if (sysfs_get_mnt_path(bus_path, SYSFS_PATH_MAX) != 0) {
+ dprintf ("Sysfs not supported on this system\n");
+ return -1;
+ }
+ strcat(bus_path, SYSFS_BUS_DIR);
+ strcat(bus_path, "/");
+ strcat(bus_path, bus_name);
+ strcat(bus_path, SYSFS_DEVICES_DIR);
+ strcat(bus_path, "/");
+ strcat(bus_path, device);
+ /*
+ * We now are at /sys/bus/"bus_name"/devices/"device" which is a link.
+ * Now read this link to reach to the device.
+ */
+ if ((sysfs_get_link(bus_path, path, SYSFS_PATH_MAX)) != 0) {
+ dprintf("Error getting to device %s\n", device);
+ return -1;
+ }
+ return 0;
+}
+
+/**
+ * sysfs_write_device_attr: modify a "writable" attribute for the given device
+ * @dev: device bus_id for which attribute has to be changed
+ * @attrib: attribute to change
+ * @value: value to change to
+ * @len: "value" length to write
+ * Returns 0 on success -1 on error
+ */
+int sysfs_write_device_attr(unsigned char *dev, unsigned char *attrib,
+ unsigned char *value, size_t len)
+{
+ struct sysfs_attribute *attribute = NULL;
+ unsigned char devpath[SYSFS_PATH_MAX];
+
+ if (dev == NULL || attrib == NULL || value == NULL) {
+ errno = EINVAL;
+ return -1;
+ }
+
+ memset(devpath, 0, SYSFS_PATH_MAX);
+ if ((get_device_absolute_path(dev, devpath, SYSFS_PATH_MAX)) != 0) {
+ dprintf("Error finding absolute path to device %s\n", dev);
+ return -1;
+ }
+ strcat(devpath, "/");
+ strcat(devpath, attrib);
+ attribute = sysfs_open_attribute(devpath);
+ if (attribute == NULL) {
+ dprintf("Attribute %s could not be retrieved for device %s\n",
+ attrib, dev);
+ return -1;
+ }
+ if (attribute->method & SYSFS_METHOD_SHOW) {
+ if ((sysfs_read_attribute(attribute)) != 0) {
+ dprintf("Error reading attribute %s for device %s\n",
+ attrib, dev);
+ sysfs_close_attribute(attribute);
+ return -1;
}
- add_device_child_to_parent(rootdev, new);
- cur = cur->next;
}
+ if ((sysfs_write_attribute(attribute, value, len)) < 0) {
+ dprintf("Error setting %s to %s\n", attrib, value);
+ sysfs_close_attribute(attribute);
+ return -1;
+ }
+ sysfs_close_attribute(attribute);
+ return 0;
+}
- return rootdev;
+/**
+ * sysfs_read_device_attr: read an attribute of the given device
+ * @dev: device bus_id for which attribute has to be changed
+ * @attrib: attribute to read
+ * @value: buffer to return value in
+ * @len: size of buffer available
+ * Returns 0 on success -1 on error
+ */
+int sysfs_read_device_attr(unsigned char *dev, unsigned char *attrib,
+ unsigned char *value, size_t len)
+{
+ struct sysfs_attribute *attribute = NULL;
+ unsigned char devpath[SYSFS_PATH_MAX];
+
+ if (dev == NULL || attrib == NULL || value == NULL) {
+ errno = EINVAL;
+ return -1;
+ }
+
+ memset(devpath, 0, SYSFS_PATH_MAX);
+ if ((get_device_absolute_path(dev, devpath, SYSFS_PATH_MAX)) != 0) {
+ dprintf("Error finding absolute path to device %s\n", dev);
+ return -1;
+ }
+ strcat(devpath, "/");
+ strcat(devpath, attrib);
+ attribute = sysfs_open_attribute(devpath);
+ if (attribute == NULL) {
+ dprintf("Error opening attribute %s for device %s\n",
+ attrib, dev);
+ return -1;
+ }
+ if (!(attribute->method & SYSFS_METHOD_SHOW)) {
+ dprintf("Show method not supported for attribute %s\n",
+ attrib);
+ sysfs_close_attribute(attribute);
+ return -1;
+ }
+ if ((sysfs_read_attribute(attribute)) != 0) {
+ dprintf("Error reading attribute %s for device %s\n",
+ attrib, dev);
+ sysfs_close_attribute(attribute);
+ return -1;
+ }
+ if (attribute->len > len) {
+ dprintf("Value length %d is larger than supplied buffer %d\n",
+ attribute->len, len);
+ sysfs_close_attribute(attribute);
+ return -1;
+ }
+ strncpy(value, attribute->value, attribute->len);
+ value[(attribute->len)+1] = 0;
+ sysfs_close_attribute(attribute);
+ return 0;
}
*
* Directory utility functions for libsysfs
*
- * Copyright (C) 2003 International Business Machines, Inc.
+ * Copyright (C) IBM Corp. 2003
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
#include "libsysfs.h"
#include "sysfs.h"
+/**
+ * sysfs_del_attribute: routine for dlist integration
+ */
+static void sysfs_del_attribute(void *attr)
+{
+ sysfs_close_attribute((struct sysfs_attribute *)attr);
+}
+
+/**
+ * sysfs_del_link: routine for dlist integration
+ */
+static void sysfs_del_link(void *ln)
+{
+ sysfs_close_link((struct sysfs_link *)ln);
+}
+
+/**
+ * sysfs_del_dir: routine for dlist integration
+ */
+static void sysfs_del_directory(void *dir)
+{
+ sysfs_close_directory((struct sysfs_directory *)dir);
+}
+
+/**
+ * dir_attribute_name_equal: compares dir attributes by name
+ * @a: attribute name for comparison
+ * @b: sysfs_attribute to be compared.
+ * returns 1 if a==b->name or 0 if not equal
+ */
+static int dir_attribute_name_equal(void *a, void *b)
+{
+ if (a == NULL || b == NULL)
+ return 0;
+
+ if (strcmp(((unsigned char *)a), ((struct sysfs_attribute *)b)->name)
+ == 0)
+ return 1;
+ return 0;
+}
+
+/**
+ * dir_link_name_equal: compares dir links by name
+ * @a: link name for comparison
+ * @b: sysfs_link to be compared.
+ * returns 1 if a==b->name or 0 if not equal
+ */
+static int dir_link_name_equal(void *a, void *b)
+{
+ if (a == NULL || b == NULL)
+ return 0;
+
+ if (strcmp(((unsigned char *)a), ((struct sysfs_link *)b)->name)
+ == 0)
+ return 1;
+ return 0;
+}
+
+/**
+ * dir_subdir_name_equal: compares subdirs by name
+ * @a: name of subdirectory to compare
+ * @b: sysfs_directory subdirectory to be compared
+ * returns 1 if a==b->name or 0 if not equal
+ */
+static int dir_subdir_name_equal(void *a, void *b)
+{
+ if (a == NULL || b == NULL)
+ return 0;
+
+ if (strcmp(((unsigned char *)a), ((struct sysfs_directory *)b)->name)
+ == 0)
+ return 1;
+ return 0;
+}
+
/**
* sysfs_close_attribute: closes and cleans up attribute
* @sysattr: attribute to close.
* @path: path to attribute.
* returns sysfs_attribute struct with success and NULL with error.
*/
-struct sysfs_attribute *sysfs_open_attribute(const char *path)
+struct sysfs_attribute *sysfs_open_attribute(const unsigned char *path)
{
struct sysfs_attribute *sysattr = NULL;
struct stat fileinfo;
}
sysattr = alloc_attribute();
if (sysattr == NULL) {
- dprintf(stderr, "Error allocating attribute at %s\n", path);
+ dprintf("Error allocating attribute at %s\n", path);
+ return NULL;
+ }
+ if (sysfs_get_name_from_path(path, sysattr->name, SYSFS_NAME_LEN)
+ != 0) {
+ dprintf("Error retrieving attribute name from path: %s\n",
+ path);
+ sysfs_close_attribute(sysattr);
return NULL;
}
strncpy(sysattr->path, path, sizeof(sysattr->path));
if ((stat(sysattr->path, &fileinfo)) != 0) {
- perror("stat");
+ dprintf("Stat failed: No such attribute?\n");
sysattr->method = 0;
+ free(sysattr);
+ sysattr = NULL;
} else {
if (fileinfo.st_mode & S_IRUSR)
sysattr->method |= SYSFS_METHOD_SHOW;
return sysattr;
}
+/**
+ * sysfs_write_attribute: write value to the attribute
+ * @sysattr: attribute to write
+ * @new_value: value to write
+ * @len: length of "new_value"
+ * returns 0 with success and -1 with error.
+ */
+int sysfs_write_attribute(struct sysfs_attribute *sysattr,
+ const unsigned char *new_value, size_t len)
+{
+ int fd;
+ int length;
+
+ if (sysattr == NULL || new_value == NULL || len == 0) {
+ errno = EINVAL;
+ return -1;
+ }
+
+ if (!(sysattr->method & SYSFS_METHOD_STORE)) {
+ dprintf ("Store method not supported for attribute %s\n",
+ sysattr->path);
+ return -1;
+ }
+ if (sysattr->method & SYSFS_METHOD_SHOW) {
+ if ((strncmp(sysattr->value, new_value, sysattr->len)) == 0) {
+ dprintf("Attribute %s already has the requested value %s\n",
+ sysattr->name, new_value);
+ return 0;
+ }
+ }
+ /*
+ * open O_WRONLY since some attributes have no "read" but only
+ * "write" permission
+ */
+ if ((fd = open(sysattr->path, O_WRONLY)) < 0) {
+ dprintf("Error reading attribute %s\n", sysattr->path);
+ return -1;
+ }
+
+ length = write(fd, new_value, len);
+ if (length < 0) {
+ dprintf("Error writing to the attribute %s - invalid value?\n",
+ sysattr->name);
+ close(fd);
+ return -1;
+ } else if (length != len) {
+ dprintf("Could not write %d bytes to attribute %s\n",
+ len, sysattr->name);
+ /*
+ * since we could not write user supplied number of bytes,
+ * restore the old value if one available
+ */
+ if (sysattr->method & SYSFS_METHOD_SHOW) {
+ length = write(fd, sysattr->value, sysattr->len);
+ close(fd);
+ return -1;
+ }
+ }
+
+ /*
+ * Validate length that has been copied. Alloc appropriate area
+ * in sysfs_attribute. Verify first if the attribute supports reading
+ * (show method). If it does not, do not bother
+ */
+ if (sysattr->method & SYSFS_METHOD_SHOW) {
+ if (length != sysattr->len) {
+ sysattr->value = (char *)realloc(sysattr->value,
+ length);
+ sysattr->len = length;
+ strncpy(sysattr->value, new_value, length);
+ } else {
+ /*"length" of the new value is same as old one */
+ strncpy(sysattr->value, new_value, length);
+ }
+ }
+
+ close(fd);
+ return 0;
+}
+
+
/**
* sysfs_read_attribute: reads value from attribute
* @sysattr: attribute to read
*/
int sysfs_read_attribute(struct sysfs_attribute *sysattr)
{
- char *fbuf = NULL;
- char *vbuf = NULL;
+ unsigned char *fbuf = NULL;
+ unsigned char *vbuf = NULL;
size_t length = 0;
int pgsize = 0;
int fd;
return -1;
}
if (!(sysattr->method & SYSFS_METHOD_SHOW)) {
- dprintf (stderr, "Show method not supported for attribute %s\n",
+ dprintf("Show method not supported for attribute %s\n",
sysattr->path);
return -1;
}
pgsize = getpagesize();
- fbuf = (char *)calloc(1, pgsize+1);
+ fbuf = (unsigned char *)calloc(1, pgsize+1);
if (fbuf == NULL) {
- perror("calloc");
+ dprintf("calloc failed\n");
return -1;
}
if ((fd = open(sysattr->path, O_RDONLY)) < 0) {
- dprintf (stderr, "Error reading attribute %s\n", sysattr->path);
+ dprintf("Error reading attribute %s\n", sysattr->path);
free(fbuf);
return -1;
}
length = read(fd, fbuf, pgsize);
if (length < 0) {
- dprintf (stderr, "Error reading from attribute %s\n",
- sysattr->path);
+ dprintf("Error reading from attribute %s\n", sysattr->path);
close(fd);
free(fbuf);
return -1;
}
sysattr->len = length;
close(fd);
- vbuf = (char *)realloc(fbuf, length+1);
+ vbuf = (unsigned char *)realloc(fbuf, length+1);
if (vbuf == NULL) {
- perror("realloc");
+ dprintf("realloc failed\n");
free(fbuf);
return -1;
}
* @vsize: size of value buffer
* returns 0 with success and -1 with error.
*/
-int sysfs_read_attribute_value(const char *attrpath, char *value, size_t vsize)
+int sysfs_read_attribute_value(const unsigned char *attrpath,
+ unsigned char *value, size_t vsize)
{
struct sysfs_attribute *attr = NULL;
size_t length = 0;
attr = sysfs_open_attribute(attrpath);
if (attr == NULL) {
- dprintf(stderr, "Invalid attribute path %s\n", attrpath);
+ dprintf("Invalid attribute path %s\n", attrpath);
errno = EINVAL;
return -1;
}
if((sysfs_read_attribute(attr)) != 0 || attr->value == NULL) {
- dprintf(stderr, "Error reading from attribute %s\n", attrpath);
+ dprintf("Error reading from attribute %s\n", attrpath);
sysfs_close_attribute(attr);
return -1;
}
length = strlen(attr->value);
if (length > vsize)
- dprintf(stderr,
- "Value length %d is larger than supplied buffer %d\n",
+ dprintf("Value length %d is larger than supplied buffer %d\n",
length, vsize);
strncpy(value, attr->value, vsize);
sysfs_close_attribute(attr);
* attribute name, return its value
* @attr: attribute to search
* @name: name to look for
- * returns char * value - could be NULL
+ * returns unsigned char * value - could be NULL
*/
-char *sysfs_get_value_from_attributes(struct sysfs_attribute *attr,
- const char *name)
+unsigned char *sysfs_get_value_from_attributes(struct dlist *attr,
+ const unsigned char *name)
{
struct sysfs_attribute *cur = NULL;
- char tmpname[SYSFS_NAME_LEN];
if (attr == NULL || name == NULL) {
errno = EINVAL;
return NULL;
- }
- cur = attr;
- while (cur != NULL) {
- memset(tmpname, 0, SYSFS_NAME_LEN);
- if ((sysfs_get_name_from_path(cur->path, tmpname,
- SYSFS_NAME_LEN)) != 0) {
- cur = cur->next;
- continue;
- }
- if (strcmp(tmpname, name) == 0)
+ }
+ dlist_for_each_data(attr, cur, struct sysfs_attribute) {
+ if (strcmp(cur->name, name) == 0)
return cur->value;
- cur = cur->next;
}
return NULL;
}
/**
- * add_subdir_to_dir: adds subdirectory to directory's subdirs
- * @sysdir: directory to add subdir to
- * @subdir: subdirectory to add.
+ * sysfs_close_link: closes and cleans up link.
+ * @ln: link to close.
*/
-static void add_subdir_to_dir(struct sysfs_directory *sysdir,
- struct sysfs_directory *subdir)
+void sysfs_close_link(struct sysfs_link *ln)
{
- if (sysdir != NULL && subdir != NULL) {
- subdir->next = sysdir->subdirs;
- sysdir->subdirs = subdir;
- }
-}
-
-/**
- * add_attr_to_dir: adds attribute to directory's attributes
- * @sysdir: directory to add attribute to
- * @sysattr: attribute to add.
- */
-static void add_attr_to_dir(struct sysfs_directory *sysdir,
- struct sysfs_attribute *sysattr)
-{
- if (sysdir != NULL && sysattr != NULL) {
- sysattr->next = sysdir->attributes;
- sysdir->attributes = sysattr;
- }
-}
-
-/**
- * sysfs_close_dlink: closes and cleans up directory link.
- * @dlink: directory link to close.
- */
-void sysfs_close_dlink(struct sysfs_dlink *dlink)
-{
- if (dlink != NULL) {
- dlink->next = NULL;
- if (dlink->target != NULL)
- sysfs_close_directory(dlink->target);
- free(dlink);
- }
-}
-
-/**
- * add_dlink_to_dir: adds directory link to directory's links list.
- * @sysdir: directory to add it to.
- * @dlink: link to add.
- */
-static void add_dlink_to_dir(struct sysfs_directory *sysdir,
- struct sysfs_dlink *dlink)
-{
- if (sysdir != NULL && dlink != NULL) {
- dlink->next = sysdir->links;
- sysdir->links = dlink;
- }
+ if (ln != NULL)
+ free(ln);
}
/**
*/
void sysfs_close_directory(struct sysfs_directory *sysdir)
{
- struct sysfs_directory *sdir = NULL, *dnext = NULL;
- struct sysfs_dlink *dlink = NULL, *nextl = NULL;
- struct sysfs_attribute *attr = NULL, *anext = NULL;
-
if (sysdir != NULL) {
- if (sysdir->subdirs != NULL) {
- for (sdir = sysdir->subdirs; sdir != NULL;
- sdir = dnext) {
- dnext = sdir->next;
- sysfs_close_directory(sdir);
- }
- }
- if (sysdir->links != NULL) {
- for (dlink = sysdir->links; dlink != NULL;
- dlink = nextl) {
- nextl = dlink->next;
- sysfs_close_dlink(dlink);
- }
- }
- if (sysdir->attributes != NULL) {
- for (attr = sysdir->attributes; attr != NULL;
- attr = anext) {
- anext = attr->next;
- /* sysfs_close_attribute(attr); */
- if (attr->value != NULL)
- free(attr->value);
- free(attr);
- }
- }
+ if (sysdir->subdirs != NULL)
+ dlist_destroy(sysdir->subdirs);
+ if (sysdir->links != NULL)
+ dlist_destroy(sysdir->links);
+ if (sysdir->attributes != NULL)
+ dlist_destroy(sysdir->attributes);
free(sysdir);
}
}
}
/**
- * alloc_dlink: allocates and initializes directory link structure
- * returns struct sysfs_dlink with success or NULL with error.
+ * alloc_link: allocates and initializes link structure
+ * returns struct sysfs_link with success or NULL with error.
+ */
+static struct sysfs_link *alloc_link(void)
+{
+ return (struct sysfs_link *)calloc(1, sizeof(struct sysfs_link));
+}
+
+/**
+ * sysfs_read_all_subdirs: calls sysfs_read_directory for all subdirs
+ * @sysdir: directory whose subdirs need reading.
+ * returns 0 with success and -1 with error.
*/
-static struct sysfs_dlink *alloc_dlink(void)
+int sysfs_read_all_subdirs(struct sysfs_directory *sysdir)
{
- return (struct sysfs_dlink *)calloc(1, sizeof(struct sysfs_dlink));
+ struct sysfs_directory *cursub = NULL;
+
+ if (sysdir == NULL) {
+ errno = EINVAL;
+ return -1;
+ }
+ if (sysdir->subdirs == NULL)
+ return 0;
+ dlist_for_each_data(sysdir->subdirs, cursub, struct sysfs_directory) {
+ if (sysfs_read_directory(cursub) != 0)
+ dprintf ("Error reading subdirectory %s\n",
+ cursub->name);
+ }
+ return 0;
}
/**
* @path: path of directory to open.
* returns: struct sysfs_directory * with success and NULL on error.
*/
-struct sysfs_directory *sysfs_open_directory(const char *path)
+struct sysfs_directory *sysfs_open_directory(const unsigned char *path)
{
struct sysfs_directory *sdir = NULL;
}
sdir = alloc_directory();
if (sdir == NULL) {
- dprintf(stderr, "Error allocating directory %s\n", path);
+ dprintf("Error allocating directory %s\n", path);
+ return NULL;
+ }
+ if (sysfs_get_name_from_path(path, sdir->name, SYSFS_NAME_LEN) != 0) {
+ dprintf("Error getting directory name from path: %s\n", path);
+ sysfs_close_directory(sdir);
return NULL;
}
strncpy(sdir->path, path, sizeof(sdir->path));
}
/**
- * sysfs_open_dlink: opens a sysfs directory link, creates struct, and returns
+ * sysfs_open_link: opens a sysfs link, creates struct, and returns
* @path: path of link to open.
- * returns: struct sysfs_dlink * with success and NULL on error.
+ * returns: struct sysfs_link * with success and NULL on error.
*/
-struct sysfs_dlink *sysfs_open_dlink(const char *linkpath)
+struct sysfs_link *sysfs_open_link(const unsigned char *linkpath)
{
- struct sysfs_dlink *dlink = NULL;
- struct sysfs_directory *tdir = NULL;
- char name[SYSFS_NAME_LEN];
- char target[SYSFS_PATH_MAX];
+ struct sysfs_link *ln = NULL;
- if (linkpath == NULL) {
+ if (linkpath == NULL || strlen(linkpath) > SYSFS_PATH_MAX) {
errno = EINVAL;
return NULL;
}
- memset(name, 0, SYSFS_NAME_LEN);
- memset(target, 0, SYSFS_PATH_MAX);
- if ((sysfs_get_name_from_path(linkpath, name, SYSFS_NAME_LEN)) != 0
- || (sysfs_get_link(linkpath, target, SYSFS_PATH_MAX)) != 0) {
- errno = EINVAL;
- dprintf(stderr, "Invalid link path %s\n", linkpath);
+ ln = alloc_link();
+ if (ln == NULL) {
+ dprintf("Error allocating link %s\n", linkpath);
return NULL;
}
- dlink = alloc_dlink();
- if (dlink == NULL) {
- dprintf(stderr,
- "Error allocating directory link %s\n", linkpath);
+ strcpy(ln->path, linkpath);
+ if ((sysfs_get_name_from_path(linkpath, ln->name, SYSFS_NAME_LEN)) != 0
+ || (sysfs_get_link(linkpath, ln->target, SYSFS_PATH_MAX)) != 0) {
+ errno = EINVAL;
+ dprintf("Invalid link path %s\n", linkpath);
return NULL;
}
- strcpy(dlink->name, name);
- tdir = sysfs_open_directory(target);
- if (tdir == NULL) {
- dprintf(stderr, "Invalid directory link target %s\n", target);
- sysfs_close_dlink(dlink);
- return NULL;
- }
- dlink->target = tdir;
- return dlink;
+ return ln;
}
/**
struct stat astats;
struct sysfs_attribute *attr = NULL;
struct sysfs_directory *subdir = NULL;
- struct sysfs_dlink *dlink = NULL;
- char file_path[SYSFS_PATH_MAX];
+ struct sysfs_link *ln = NULL;
+ unsigned char file_path[SYSFS_PATH_MAX];
int retval = 0;
if (sysdir == NULL) {
}
dir = opendir(sysdir->path);
if (dir == NULL) {
- perror("opendir");
+ dprintf("Error opening directory %s\n", sysdir->path);
return -1;
}
while(((dirent = readdir(dir)) != NULL) && retval == 0) {
strncat(file_path, "/", sizeof(file_path));
strncat(file_path, dirent->d_name, sizeof(file_path));
if ((lstat(file_path, &astats)) != 0) {
- perror("stat");
+ dprintf("stat failed\n");
continue;
}
if (S_ISREG(astats.st_mode)) {
attr = sysfs_open_attribute(file_path);
if (attr == NULL) {
- dprintf (stderr, "Error opening attribute %s\n",
+ dprintf("Error opening attribute %s\n",
file_path);
retval = -1;
break;
}
if (attr->method & SYSFS_METHOD_SHOW) {
if ((sysfs_read_attribute(attr)) != 0) {
- dprintf (stderr,
- "Error reading attribute %s\n",
+ dprintf("Error reading attribute %s\n",
file_path);
sysfs_close_attribute(attr);
continue;
}
}
- add_attr_to_dir(sysdir, attr);
+
+ if (sysdir->attributes == NULL) {
+ sysdir->attributes = dlist_new_with_delete
+ (sizeof(struct sysfs_attribute),
+ sysfs_del_attribute);
+ }
+ dlist_unshift(sysdir->attributes, attr);
} else if (S_ISDIR(astats.st_mode)) {
subdir = sysfs_open_directory(file_path);
if (subdir == NULL) {
- dprintf (stderr, "Error opening directory %s\n",
+ dprintf("Error opening directory %s\n",
file_path);
retval = -1;
break;
}
- add_subdir_to_dir(sysdir, subdir);
+ if (sysdir->subdirs == NULL)
+ sysdir->subdirs = dlist_new_with_delete
+ (sizeof(struct sysfs_directory),
+ sysfs_del_directory);
+ dlist_unshift(sysdir->subdirs, subdir);
} else if (S_ISLNK(astats.st_mode)) {
- dlink = sysfs_open_dlink(file_path);
- if (dlink == NULL) {
- dprintf(stderr, "Error opening link %s\n",
- file_path);
+ ln = sysfs_open_link(file_path);
+ if (ln == NULL) {
+ dprintf("Error opening link %s\n", file_path);
retval = -1;
break;
}
- add_dlink_to_dir(sysdir, dlink);
+ if (sysdir->links == NULL)
+ sysdir->links = dlist_new_with_delete
+ (sizeof(struct sysfs_link),
+ sysfs_del_link);
+ dlist_unshift(sysdir->links, ln);
}
}
closedir(dir);
}
/**
- * sysfs_read_dlinks: reads a directory link's target directory. Can
- * supply a linked list of links.
- * @dlink: directory link to read.
- * returns 0 with success or -1 with error.
+ * sysfs_get_directory_attribute: retrieves attribute attrname
+ * @dir: directory to retrieve attribute from
+ * @attrname: name of attribute to look for
+ * returns sysfs_attribute if found and NULL if not found
*/
-int sysfs_read_dlinks(struct sysfs_dlink *dlink)
+struct sysfs_attribute *sysfs_get_directory_attribute
+ (struct sysfs_directory *dir, unsigned char *attrname)
{
- struct sysfs_dlink *cur = NULL;
+ struct sysfs_directory *sdir = NULL;
+ struct sysfs_attribute *attr = NULL;
+
+ if (dir == NULL || attrname == NULL) {
+ errno = EINVAL;
+ return NULL;
+ }
+
+ attr = (struct sysfs_attribute *)dlist_find_custom(dir->attributes,
+ attrname, dir_attribute_name_equal);
+ if (attr != NULL)
+ return attr;
+
+ if (dir->subdirs != NULL) {
+ dlist_for_each_data(dir->subdirs, sdir,
+ struct sysfs_directory) {
+ if (sdir->attributes == NULL)
+ continue;
+ attr = sysfs_get_directory_attribute(sdir, attrname);
+ if (attr != NULL)
+ return attr;
+ }
+ }
+ return NULL;
+}
- if (dlink == NULL || dlink->target == NULL) {
+/**
+ * sysfs_get_directory_link: retrieves link from one directory list
+ * @dir: directory to retrieve link from
+ * @linkname: name of link to look for
+ * returns reference to sysfs_link if found and NULL if not found
+ */
+struct sysfs_link *sysfs_get_directory_link
+ (struct sysfs_directory *dir, unsigned char *linkname)
+{
+ if (dir == NULL || linkname == NULL) {
errno = EINVAL;
- return -1;
+ return NULL;
}
- cur = dlink;
- while (cur != NULL) {
- if ((sysfs_read_directory(cur->target)) != 0) {
- dprintf(stderr,
- "Error reading directory link target %s\n",
- dlink->name);
- return -1;
+ return (struct sysfs_link *)dlist_find_custom(dir->links,
+ linkname, dir_link_name_equal);
+}
+
+/**
+ * sysfs_get_subdirectory: retrieves subdirectory by name.
+ * @dir: directory to search for subdirectory.
+ * @subname: subdirectory name to get.
+ * returns reference to subdirectory or NULL if not found
+ */
+struct sysfs_directory *sysfs_get_subdirectory(struct sysfs_directory *dir,
+ unsigned char *subname)
+{
+ struct sysfs_directory *sub = NULL, *cursub = NULL;
+
+ if (dir == NULL || dir->subdirs == NULL || subname == NULL) {
+ errno = EINVAL;
+ return NULL;
+ }
+ sub = (struct sysfs_directory *)dlist_find_custom(dir->subdirs,
+ subname, dir_subdir_name_equal);
+ if (sub != NULL)
+ return sub;
+
+ if (dir->subdirs != NULL) {
+ dlist_for_each_data(dir->subdirs, cursub,
+ struct sysfs_directory) {
+ if (cursub->subdirs == NULL)
+ continue;
+ sub = sysfs_get_subdirectory(cursub, subname);
+ if (sub != NULL)
+ return sub;
}
- cur = cur->next;
}
-
- return 0;
+ return NULL;
+}
+
+/**
+ * sysfs_get_subdirectory_link: looks through all subdirs for specific link.
+ * @dir: directory and subdirectories to search for link.
+ * @linkname: link name to get.
+ * returns reference to link or NULL if not found
+ */
+struct sysfs_link *sysfs_get_subdirectory_link(struct sysfs_directory *dir,
+ unsigned char *linkname)
+{
+ struct sysfs_directory *cursub = NULL;
+ struct sysfs_link *ln = NULL;
+
+ if (dir == NULL || dir->links == NULL || linkname == NULL) {
+ errno = EINVAL;
+ return NULL;
+ }
+
+ ln = sysfs_get_directory_link(dir, linkname);
+ if (ln != NULL)
+ return ln;
+
+ if (dir->subdirs == NULL)
+ return NULL;
+
+ if (dir->subdirs != NULL) {
+ dlist_for_each_data(dir->subdirs, cursub,
+ struct sysfs_directory) {
+ if (cursub->subdirs == NULL)
+ continue;
+ ln = sysfs_get_subdirectory_link(cursub, linkname);
+ if (ln != NULL)
+ return ln;
+ }
+ }
+ return NULL;
}
*
* Driver utility functions for libsysfs
*
- * Copyright (C) 2003 International Business Machines, Inc.
+ * Copyright (C) IBM Corp. 2003
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
#include "libsysfs.h"
#include "sysfs.h"
+static void sysfs_close_driver_by_name_dev(void *device)
+{
+ sysfs_close_device((struct sysfs_device *)device);
+}
+
/**
* sysfs_close_driver: closes and cleans up driver structure
+ * NOTE: This routine does not deallocate devices list
* @driver: driver to close
*/
void sysfs_close_driver(struct sysfs_driver *driver)
{
if (driver != NULL) {
+ if (driver->devices != NULL) {
+ dlist_for_each(driver->devices)
+ dlist_shift(driver->devices);
+ free(driver->devices);
+ driver->devices = NULL;
+ }
if (driver->directory != NULL)
sysfs_close_directory(driver->directory);
free(driver);
}
}
+/**
+ * sysfs_close_driver_by_name: closes driver and deletes device lists too
+ * @driver: driver to close
+ */
+void sysfs_close_driver_by_name(struct sysfs_driver *driver)
+{
+ if (driver != NULL) {
+ if (driver->devices != NULL)
+ dlist_destroy(driver->devices);
+ if (driver->directory != NULL)
+ sysfs_close_directory(driver->directory);
+ free(driver);
+ }
+}
+
/**
* alloc_driver: allocates and initializes driver
* returns struct sysfs_driver with success and NULL with error.
* @path: path to driver directory
* returns struct sysfs_driver with success and NULL with error
*/
-struct sysfs_driver *sysfs_open_driver(const char *path)
+struct sysfs_driver *sysfs_open_driver(const unsigned char *path)
{
struct sysfs_driver *driver = NULL;
struct sysfs_directory *sdir = NULL;
- char devname[SYSFS_NAME_LEN];
if (path == NULL) {
errno = EINVAL;
}
sdir = sysfs_open_directory(path);
if (sdir == NULL) {
- dprintf (stderr, "Error opening directory %s\n", path);
+ dprintf("Error opening directory %s\n", path);
return NULL;
}
if ((sysfs_read_directory(sdir)) != 0) {
- dprintf (stderr, "Error reading directory %s\n", path);
+ dprintf("Error reading directory %s\n", path);
sysfs_close_directory(sdir);
return NULL;
}
driver = alloc_driver();
if (driver == NULL) {
- dprintf(stderr, "Error allocating driver at %s\n", path);
+ dprintf("Error allocating driver at %s\n", path);
sysfs_close_directory(sdir);
return NULL;
}
- if ((sysfs_get_name_from_path(path, devname, SYSFS_NAME_LEN)) != 0) {
- dprintf (stderr, "Error reading directory %s\n", path);
- sysfs_close_directory(sdir);
- free(driver);
- return NULL;
- }
- strncpy(driver->name, devname, sizeof(driver->name));
+ strcpy(driver->name, sdir->name);
driver->directory = sdir;
+ strcpy(driver->path, sdir->path);
return driver;
}
+
+/**
+ * sysfs_get_driver_attributes: gets list of attributes for the given driver
+ * @driver: sysfs_driver for which attributes are required
+ * returns a dlist of attributes corresponding to the driver if present
+ * NULL otherwise
+ */
+struct dlist *sysfs_get_driver_attributes(struct sysfs_driver *driver)
+{
+ if (driver == NULL || driver->directory == NULL)
+ return NULL;
+
+ return(driver->directory->attributes);
+}
+
+/**
+ * sysfs_get_driver_attr: searches driver's attributes by name
+ * @drv: driver to look through
+ * @name: attribute name to get
+ * returns sysfs_attribute reference on success or NULL with error
+ */
+struct sysfs_attribute *sysfs_get_driver_attr(struct sysfs_driver *drv,
+ const unsigned char *name)
+{
+ struct sysfs_attribute *cur = NULL;
+
+ if (drv == NULL || drv->directory == NULL
+ || drv->directory->attributes == NULL || name == NULL) {
+ errno = EINVAL;
+ return NULL;
+ }
+
+ cur = sysfs_get_directory_attribute(drv->directory,
+ (unsigned char *)name);
+ if (cur != NULL)
+ return cur;
+
+ return NULL;
+}
+
+/**
+ * sysfs_get_driver_links: gets list of links from the given driver
+ * @driver: sysfs_driver for which links list is required
+ * returns a dlist of links corresponding to the driver if present
+ * NULL otherwise
+ */
+struct dlist *sysfs_get_driver_links(struct sysfs_driver *driver)
+{
+ if (driver == NULL || driver->directory == NULL)
+ return NULL;
+
+ return(driver->directory->links);
+}
+
+/**
+ * sysfs_open_driver_by_name: open a driver by name and return the bus
+ * the driver is on.
+ * @drv_name: driver to open
+ * @bus: the driver bus
+ * @bsize: size of bus buffer
+ * returns struct sysfs_driver if found, NULL otherwise
+ * NOTE:
+ * 1. Need to call sysfs_close_driver_by_name to free up memory
+ * 2. Bus the driver is registered with must be supplied.
+ * Use sysfs_find_driver_bus() to obtain the bus name
+ */
+struct sysfs_driver *sysfs_open_driver_by_name(const unsigned char *drv_name,
+ const unsigned char *bus, size_t bsize)
+{
+ struct sysfs_driver *driver = NULL;
+ struct sysfs_device *device = NULL;
+ struct sysfs_link *curlink = NULL;
+ unsigned char path[SYSFS_PATH_MAX];
+
+ if (drv_name == NULL || bus == NULL) {
+ errno = EINVAL;
+ return NULL;
+ }
+
+ memset(path, 0, SYSFS_PATH_MAX);
+ if (sysfs_get_mnt_path(path, SYSFS_PATH_MAX) != 0) {
+ dprintf("Error getting sysfs mount path\n");
+ return NULL;
+ }
+ strcat(path, SYSFS_BUS_DIR);
+ strcat(path, "/");
+ strcat(path, bus);
+ strcat(path, SYSFS_DRIVERS_DIR);
+ strcat(path, "/");
+ strcat(path, drv_name);
+ driver = sysfs_open_driver(path);
+ if (driver == NULL) {
+ dprintf("Could not open driver %s\n", drv_name);
+ return NULL;
+ }
+ if (driver->directory->links != NULL) {
+ dlist_for_each_data(driver->directory->links, curlink,
+ struct sysfs_link) {
+ device = sysfs_open_device(curlink->target);
+ if (device == NULL) {
+ dprintf("Error opening device at %s\n",
+ curlink->target);
+ sysfs_close_driver_by_name(driver);
+ return NULL;
+ }
+ strcpy(device->driver_name, drv_name);
+ if (driver->devices == NULL)
+ driver->devices = dlist_new_with_delete
+ (sizeof(struct sysfs_device),
+ sysfs_close_driver_by_name_dev);
+ dlist_unshift(driver->devices, device);
+ }
+ }
+ return driver;
+}
+
+/**
+ * get_driver_path: looks up the bus the driver is on and builds path to
+ * the driver.
+ * @drv: driver to look for
+ * @path: buffer to return path to driver
+ * @psize: size of "path"
+ * Returns 0 on success and -1 on error
+ */
+static int get_driver_path(const unsigned char *drv,
+ unsigned char *path, size_t psize)
+{
+ unsigned char bus_name[SYSFS_NAME_LEN];
+
+ if (drv == NULL || path == NULL) {
+ errno = EINVAL;
+ return -1;
+ }
+ memset(bus_name, 0, SYSFS_NAME_LEN);
+ memset(path, 0, SYSFS_PATH_MAX);
+ if ((sysfs_find_driver_bus(drv, bus_name, SYSFS_NAME_LEN)) < 0) {
+ dprintf("Driver %s not found\n", drv);
+ return -1;
+ }
+ if (sysfs_get_mnt_path(path, SYSFS_PATH_MAX) != 0) {
+ dprintf("Error getting sysfs mount path\n");
+ return -1;
+ }
+ strcat(path, SYSFS_BUS_DIR);
+ strcat(path, "/");
+ strcat(path, bus_name);
+ strcat(path, SYSFS_DRIVERS_DIR);
+ strcat(path, "/");
+ strcat(path, drv);
+ fprintf(stdout, "get_driver_path %s\n", path);
+ return 0;
+}
+
+/**
+ * sysfs_write_driver_attr: modify "writable" driver attribute
+ * @drv: driver whose attribute has to be modified
+ * @attrib: Attribute to be modified
+ * @value: Value to change to
+ * Returns 0 on success -1 on failure
+ */
+int sysfs_write_driver_attr(unsigned char *drv, unsigned char *attrib,
+ unsigned char *value, size_t len)
+{
+ struct sysfs_attribute *attribute = NULL;
+ unsigned char path[SYSFS_PATH_MAX];
+
+ if (drv == NULL || attrib == NULL || value == NULL) {
+ errno = EINVAL;
+ return -1;
+ }
+
+ memset(path, 0, SYSFS_PATH_MAX);
+ if ((get_driver_path(drv, path, SYSFS_PATH_MAX)) != 0) {
+ dprintf("Error getting to driver %s\n", drv);
+ return -1;
+ }
+ strcat(path, "/");
+ strcat(path, attrib);
+ attribute = sysfs_open_attribute(path);
+ if (attribute == NULL) {
+ dprintf("Attribute %s could not be retrieved for driver %s\n",
+ attrib, drv);
+ return -1;
+ }
+ if (attribute->method & SYSFS_METHOD_SHOW) {
+ if ((sysfs_read_attribute(attribute)) != 0) {
+ dprintf("Error reading attribute %s for driver %s\n",
+ attrib, drv);
+ sysfs_close_attribute(attribute);
+ return -1;
+ }
+ }
+ if ((sysfs_write_attribute(attribute, value, len)) < 0) {
+ dprintf("Error setting %s to %s\n", attrib, value);
+ sysfs_close_attribute(attribute);
+ return -1;
+ }
+ sysfs_close_attribute(attribute);
+ return 0;
+}
+
+/**
+ * sysfs_read_driver_attr: read the user supplied driver attribute
+ * @drv: driver whose attribute has to be read
+ * @attrib: Attribute to be read
+ * @value: Buffer to return the read value
+ * @len: Length of the buffer "value"
+ * Returns 0 on success -1 on failure
+ */
+int sysfs_read_driver_attr(unsigned char *drv, unsigned char *attrib,
+ unsigned char *value, size_t len)
+{
+ struct sysfs_attribute *attribute = NULL;
+ unsigned char path[SYSFS_PATH_MAX];
+
+ if (drv == NULL || attrib == NULL || value == NULL) {
+ errno = EINVAL;
+ return -1;
+ }
+
+ memset(path, 0, SYSFS_NAME_LEN);
+ if ((get_driver_path(drv, path, SYSFS_PATH_MAX)) != 0) {
+ dprintf("Error getting to driver %s\n", drv);
+ return -1;
+ }
+ strcat(path, "/");
+ strcat(path, attrib);
+ attribute = sysfs_open_attribute(path);
+ if (attribute == NULL) {
+ dprintf("Error opening attribute %s for driver %s\n",
+ attrib, drv);
+ return -1;
+ }
+ if (!(attribute->method & SYSFS_METHOD_SHOW)) {
+ dprintf("Show method not supported for attribute %s\n",
+ attrib);
+ sysfs_close_attribute(attribute);
+ return -1;
+ }
+ if ((sysfs_read_attribute(attribute)) != 0) {
+ dprintf("Error reading attribute %s for driver %s\n",
+ attrib, drv);
+ sysfs_close_attribute(attribute);
+ return -1;
+ }
+ if (attribute->len > len) {
+ dprintf("Value length %d is larger than supplied buffer %d\n",
+ attribute->len, len);
+ sysfs_close_attribute(attribute);
+ return -1;
+ }
+ strncpy(value, attribute->value, attribute->len);
+ value[(attribute->len)+1] = 0;
+ sysfs_close_attribute(attribute);
+ return 0;
+}
+
*
* System utility functions for libsysfs
*
- * Copyright (C) 2003 International Business Machines, Inc.
+ * Copyright (C) IBM Corp. 2003
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* @len: size of mnt_path
* returns 0 with success and -1 with error.
*/
-static int sysfs_get_fs_mnt_path(const char *fs_type, char *mnt_path,
- size_t len)
+static int sysfs_get_fs_mnt_path(const unsigned char *fs_type,
+ unsigned char *mnt_path, size_t len)
{
FILE *mnt;
struct mntent *mntent;
}
if ((mnt = setmntent(SYSFS_PROC_MNTS, "r")) == NULL) {
- dprintf(stderr, "Error getting mount information\n");
+ dprintf("Error getting mount information\n");
return -1;
}
while (ret == 0 && dirlen == 0 && (mntent = getmntent(mnt)) != NULL) {
if (dirlen <= (len - 1)) {
strcpy(mnt_path, mntent->mnt_dir);
} else {
- dprintf(stderr,
- "Error - mount path too long\n");
+ dprintf("Error - mount path too long\n");
ret = -1;
}
}
}
endmntent(mnt);
if (dirlen == 0 && ret == 0) {
- dprintf(stderr, "Filesystem %s not found!\n", fs_type);
+ dprintf("Filesystem %s not found!\n", fs_type);
errno = EINVAL;
ret = -1;
}
* @len: size of mnt_path
* returns 0 with success and -1 with error.
*/
-int sysfs_get_mnt_path(char *mnt_path, size_t len)
+int sysfs_get_mnt_path(unsigned char *mnt_path, size_t len)
{
int ret = -1;
* @name: where to put name
* @len: size of name
*/
-int sysfs_get_name_from_path(const char *path, char *name, size_t len)
+int sysfs_get_name_from_path(const unsigned char *path, unsigned char *name,
+ size_t len)
{
- char *n = NULL;
+ unsigned char *n = NULL;
if (path == NULL || name == NULL) {
errno = EINVAL;
* @target: where to put name
* @len: size of name
*/
-int sysfs_get_link(const char *path, char *target, size_t len)
+int sysfs_get_link(const unsigned char *path, unsigned char *target, size_t len)
{
- char devdir[SYSFS_PATH_MAX];
- char linkpath[SYSFS_PATH_MAX];
- char *d = NULL;
+ unsigned char devdir[SYSFS_PATH_MAX];
+ unsigned char linkpath[SYSFS_PATH_MAX];
+ unsigned char *d = NULL;
if (path == NULL || target == NULL) {
errno = EINVAL;
memset(linkpath, 0, SYSFS_PATH_MAX);
if ((sysfs_get_mnt_path(devdir, SYSFS_PATH_MAX)) != 0) {
- dprintf(stderr, "Sysfs not supported on this system\n");
+ dprintf("Sysfs not supported on this system\n");
return -1;
}
return 0;
}
+
+
+/**
+ * sysfs_del_name: free function for sysfs_open_subsystem_list
+ * @name: memory area to be freed
+ */
+void sysfs_del_name(void *name)
+{
+ free(name);
+}
+
+
+/**
+ * sysfs_close_list: generic list free routine
+ * @list: dlist to free
+ * Returns nothing
+ */
+void sysfs_close_list(struct dlist *list)
+{
+ if (list != NULL)
+ dlist_destroy(list);
+}
+
+/**
+ * sysfs_open_subsystem_list: gets a list of all supported "name" subsystem
+ * details from the system
+ * @name: name of the subsystem, eg., "bus", "class", "devices"
+ * Returns a dlist of supported names or NULL if subsystem not supported
+ */
+struct dlist *sysfs_open_subsystem_list(unsigned char *name)
+{
+ unsigned char sysfs_path[SYSFS_PATH_MAX], *subsys_name = NULL;
+ struct sysfs_directory *dir = NULL, *cur = NULL;
+ struct dlist *list = NULL;
+
+ if (name == NULL)
+ return NULL;
+
+ if (sysfs_get_mnt_path(sysfs_path, SYSFS_PATH_MAX) != 0) {
+ dprintf("Error getting sysfs mount point\n");
+ return NULL;
+ }
+
+ strcat(sysfs_path, name);
+ dir = sysfs_open_directory(sysfs_path);
+ if (dir == NULL) {
+ dprintf("Error opening sysfs_directory at %s\n", sysfs_path);
+ return NULL;
+ }
+
+ if (sysfs_read_directory(dir) != 0) {
+ dprintf("Error reading sysfs_directory at %s\n", sysfs_path);
+ sysfs_close_directory(dir);
+ return NULL;
+ }
+
+ if (dir->subdirs != NULL) {
+ list = dlist_new_with_delete(SYSFS_NAME_LEN,
+ sysfs_del_name);
+ if (list == NULL) {
+ dprintf("Error creating list\n");
+ sysfs_close_directory(dir);
+ return NULL;
+ }
+
+ dlist_for_each_data(dir->subdirs, cur,
+ struct sysfs_directory) {
+ subsys_name = (char *)calloc(1, SYSFS_NAME_LEN);
+ strcpy(subsys_name, cur->name);
+ dlist_unshift(list, subsys_name);
+ }
+ }
+ sysfs_close_directory(dir);
+ return list;
+}
+
+
+/**
+ * sysfs_open_bus_devices_list: gets a list of all devices on "name" bus
+ * @name: name of the subsystem, eg., "pci", "scsi", "usb"
+ * Returns a dlist of supported names or NULL if subsystem not supported
+ */
+struct dlist *sysfs_open_bus_devices_list(unsigned char *name)
+{
+ unsigned char sysfs_path[SYSFS_PATH_MAX], *device_name = NULL;
+ struct sysfs_directory *dir = NULL;
+ struct sysfs_link *cur = NULL;
+ struct dlist *list = NULL;
+
+ if (name == NULL)
+ return NULL;
+
+ if (sysfs_get_mnt_path(sysfs_path, SYSFS_PATH_MAX) != 0) {
+ dprintf("Error getting sysfs mount point\n");
+ return NULL;
+ }
+
+ strcat(sysfs_path, SYSFS_BUS_DIR);
+ strcat(sysfs_path, "/");
+ strcat(sysfs_path, name);
+ strcat(sysfs_path, SYSFS_DEVICES_DIR);
+ dir = sysfs_open_directory(sysfs_path);
+ if (dir == NULL) {
+ dprintf("Error opening sysfs_directory at %s\n", sysfs_path);
+ return NULL;
+ }
+
+ if (sysfs_read_directory(dir) != 0) {
+ dprintf("Error reading sysfs_directory at %s\n", sysfs_path);
+ sysfs_close_directory(dir);
+ return NULL;
+ }
+
+ if (dir->links != NULL) {
+ list = dlist_new_with_delete(SYSFS_NAME_LEN,
+ sysfs_del_name);
+ if (list == NULL) {
+ dprintf("Error creating list\n");
+ sysfs_close_directory(dir);
+ return NULL;
+ }
+
+ dlist_for_each_data(dir->links, cur,
+ struct sysfs_link) {
+ device_name = (char *)calloc(1, SYSFS_NAME_LEN);
+ strcpy(device_name, cur->name);
+ dlist_unshift(list, device_name);
+ }
+ }
+ sysfs_close_directory(dir);
+ return list;
+}
+
attr->mode = 0;
if (class_dev->sysdevice) {
- dbg_parse("class_dev->sysdevice->directory->path = '%s'", class_dev->sysdevice->directory->path);
+ dbg_parse("class_dev->sysdevice->path = '%s'", class_dev->sysdevice->path);
dbg_parse("class_dev->sysdevice->bus_id = '%s'", class_dev->sysdevice->bus_id);
} else {
dbg_parse("class_dev->name = '%s'", class_dev->name);
switch (dev->type) {
case LABEL:
{
- char *temp;
+ struct sysfs_attribute *tmpattr = NULL;
+ struct sysfs_class_device *class_dev_parent = NULL;
+ char *temp = NULL;
dbg_parse("LABEL: match file '%s' with value '%s'",
dev->sysfs_file, dev->sysfs_value);
/* try to find the attribute in the class device directory */
- temp = sysfs_get_value_from_attributes(class_dev->directory->attributes, dev->sysfs_file);
- if (temp)
+ tmpattr = sysfs_get_classdev_attr(class_dev, dev->sysfs_file);
+ if (tmpattr)
goto label_found;
/* look in the class device device directory if present */
if (class_dev->sysdevice) {
- temp = sysfs_get_value_from_attributes(class_dev->sysdevice->directory->attributes, dev->sysfs_file);
- if (temp)
+ tmpattr = sysfs_get_classdev_attr(class_dev, dev->sysfs_file);
+ if (tmpattr)
goto label_found;
}
* as block partitions don't point to the physical device. Need to fix that
* up in the kernel...
*/
- if (strstr(class_dev->directory->path, "block")) {
+ if (strstr(class_dev->path, "block")) {
dbg_parse("looking at block device...");
- if (isdigit(class_dev->directory->path[strlen(class_dev->directory->path)-1])) {
+ if (isdigit(class_dev->path[strlen(class_dev->path)-1])) {
char path[SYSFS_PATH_MAX];
- struct sysfs_class_device *class_dev_parent;
dbg_parse("really is a partition...");
- strcpy(path, class_dev->directory->path);
+ strcpy(path, class_dev->path);
temp = strrchr(path, '/');
*temp = 0x00;
dbg_parse("looking for a class device at '%s'", path);
dbg_parse("class_dev_parent->name = %s", class_dev_parent->name);
/* try to find the attribute in the class device directory */
- temp = sysfs_get_value_from_attributes(class_dev_parent->directory->attributes, dev->sysfs_file);
- if (temp) {
- //sysfs_close_class_device(class_dev_parent);
+ tmpattr = sysfs_get_classdev_attr(class_dev_parent, dev->sysfs_file);
+ if (tmpattr)
goto label_found;
- }
/* look in the class device device directory if present */
if (class_dev_parent->sysdevice) {
- temp = sysfs_get_value_from_attributes(class_dev_parent->sysdevice->directory->attributes, dev->sysfs_file);
- if (temp) {
- // sysfs_close_class_device(class_dev_parent);
+ tmpattr = sysfs_get_classdev_attr(class_dev_parent, dev->sysfs_file);
+ if (tmpattr)
goto label_found;
- }
}
}
}
+ if (class_dev_parent)
+ sysfs_close_class_device(class_dev_parent);
+
continue;
label_found:
- temp[strlen(temp)-1] = 0x00;
- dbg_parse("file '%s' found with value '%s' compare with '%s'", dev->sysfs_file, temp, dev->sysfs_value);
- if (strcmp(dev->sysfs_value, temp) != 0)
+ tmpattr->value[strlen(tmpattr->value)-1] = 0x00;
+ dbg_parse("file '%s' found with value '%s' compare with '%s'", dev->sysfs_file, tmpattr->value, dev->sysfs_value);
+ if (strcmp(dev->sysfs_value, tmpattr->value) != 0) {
+ if (class_dev_parent)
+ sysfs_close_class_device(class_dev_parent);
continue;
+ }
strcpy(attr->name, dev->attr.name);
- if (isdigit(class_dev->directory->path[strlen(class_dev->directory->path)-1])) {
- temp[0] = class_dev->directory->path[strlen(class_dev->directory->path)-1];
- temp[1] = 0x00;
+ if (isdigit(class_dev->path[strlen(class_dev->path)-1])) {
+ temp = &class_dev->path[strlen(class_dev->path)-1];
strcat(attr->name, temp);
}
if (dev->attr.mode != 0) {
dbg_parse("file '%s' with value '%s' becomes '%s' - owner = %s, group = %s, mode = %#o",
dev->sysfs_file, dev->sysfs_value, attr->name,
dev->attr.owner, dev->attr.group, dev->attr.mode);
+ if (class_dev_parent)
+ sysfs_close_class_device(class_dev_parent);
goto done;
break;
}
found = 0;
if (!class_dev->sysdevice)
continue;
- strcpy(path, class_dev->sysdevice->directory->path);
+ strcpy(path, class_dev->sysdevice->path);
temp = strrchr(path, '/');
dbg_parse("NUMBER path = '%s'", path);
dbg_parse("NUMBER temp = '%s' id = '%s'", temp, dev->id);
if (!class_dev->sysdevice)
continue;
found = 0;
- strcpy(path, class_dev->sysdevice->directory->path);
+ strcpy(path, class_dev->sysdevice->path);
temp = strrchr(path, '/');
dbg_parse("TOPOLOGY path = '%s'", path);
dbg_parse("TOPOLOGY temp = '%s' place = '%s'", temp, dev->place);
projects / systemd / commitdiff