[PATCH] new version of libsysfs patch
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
This commit is contained in:
parent
3370fb2152
commit
fe3fe3b29f
|
@ -1,15 +1,15 @@
|
||||||
# Makefile for libsysfs.a
|
# Makefile for libsysfs.a
|
||||||
# Copyright (c) International Business Machines Corp., 2003
|
# Copyright (c) International Business Machines Corp., 2003
|
||||||
|
|
||||||
H_INCLUDE=../include
|
H_INCLUDE=.
|
||||||
LIB_INCLUDE=.
|
LIB_INCLUDE=.
|
||||||
OBJS=sysfs_bus.o sysfs_class.o sysfs_device.o sysfs_dir.o sysfs_driver.o \
|
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
|
# Install directory
|
||||||
|
|
||||||
# Options
|
# Options
|
||||||
CFLAGS=-O2 -Wall -ansi -g
|
CFLAGS=-O2 -Wall -g
|
||||||
|
|
||||||
# sysfs library
|
# sysfs library
|
||||||
LIBSYSFS=libsysfs.a
|
LIBSYSFS=libsysfs.a
|
||||||
|
@ -38,5 +38,8 @@ sysfs_driver.o: sysfs_driver.c
|
||||||
sysfs_utils.o: sysfs_utils.c
|
sysfs_utils.o: sysfs_utils.c
|
||||||
$(CC) -I$(H_INCLUDE) -I$(LIB_INCLUDE) $(CFLAGS) -c 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:
|
clean:
|
||||||
$(RM) *.o *~ core $(LIBSYSFS)
|
$(RM) *.o *~ core $(LIBSYSFS)
|
||||||
|
|
|
@ -0,0 +1,343 @@
|
||||||
|
/*
|
||||||
|
* 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));
|
||||||
|
}
|
|
@ -0,0 +1,195 @@
|
||||||
|
/*
|
||||||
|
* 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_ */
|
|
@ -3,7 +3,7 @@
|
||||||
*
|
*
|
||||||
* Header Definitions for libsysfs
|
* 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
|
* This library is free software; you can redistribute it and/or
|
||||||
* modify it under the terms of the GNU Lesser General Public
|
* modify it under the terms of the GNU Lesser General Public
|
||||||
|
@ -24,6 +24,7 @@
|
||||||
#define _LIBSYSFS_H_
|
#define _LIBSYSFS_H_
|
||||||
|
|
||||||
#include <sys/types.h>
|
#include <sys/types.h>
|
||||||
|
#include "dlist.h"
|
||||||
|
|
||||||
/*
|
/*
|
||||||
* Generic #defines go here..
|
* Generic #defines go here..
|
||||||
|
@ -32,11 +33,17 @@
|
||||||
#define SYSFS_PROC_MNTS "/proc/mounts"
|
#define SYSFS_PROC_MNTS "/proc/mounts"
|
||||||
#define SYSFS_BUS_DIR "/bus"
|
#define SYSFS_BUS_DIR "/bus"
|
||||||
#define SYSFS_CLASS_DIR "/class"
|
#define SYSFS_CLASS_DIR "/class"
|
||||||
|
#define SYSFS_BLOCK_DIR "/block"
|
||||||
#define SYSFS_DEVICES_DIR "/devices"
|
#define SYSFS_DEVICES_DIR "/devices"
|
||||||
#define SYSFS_DEVICES_NAME "devices"
|
#define SYSFS_DEVICES_NAME "devices"
|
||||||
#define SYSFS_DRIVERS_DIR "/drivers"
|
#define SYSFS_DRIVERS_DIR "/drivers"
|
||||||
#define SYSFS_DRIVERS_NAME "drivers"
|
#define SYSFS_DRIVERS_NAME "drivers"
|
||||||
#define SYSFS_NAME_ATTRIBUTE "name"
|
#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_PATH_MAX 255
|
||||||
#define SYSFS_NAME_LEN 50
|
#define SYSFS_NAME_LEN 50
|
||||||
|
@ -46,65 +53,84 @@
|
||||||
#define SYSFS_METHOD_STORE 0x02 /* attr can be changed by user */
|
#define SYSFS_METHOD_STORE 0x02 /* attr can be changed by user */
|
||||||
|
|
||||||
struct sysfs_attribute {
|
struct sysfs_attribute {
|
||||||
struct sysfs_attribute *next;
|
unsigned char *value;
|
||||||
char path[SYSFS_PATH_MAX];
|
|
||||||
char *value;
|
|
||||||
unsigned short len; /* value length */
|
unsigned short len; /* value length */
|
||||||
unsigned short method; /* show and store */
|
unsigned short method; /* show and store */
|
||||||
|
unsigned char name[SYSFS_NAME_LEN];
|
||||||
|
unsigned char path[SYSFS_PATH_MAX];
|
||||||
};
|
};
|
||||||
|
|
||||||
struct sysfs_dlink {
|
struct sysfs_link {
|
||||||
struct sysfs_dlink *next;
|
unsigned char name[SYSFS_NAME_LEN];
|
||||||
char name[SYSFS_NAME_LEN];
|
unsigned char path[SYSFS_PATH_MAX];
|
||||||
struct sysfs_directory *target;
|
unsigned char target[SYSFS_PATH_MAX];
|
||||||
};
|
};
|
||||||
|
|
||||||
struct sysfs_directory {
|
struct sysfs_directory {
|
||||||
struct sysfs_directory *next;
|
struct dlist *subdirs;
|
||||||
char path[SYSFS_PATH_MAX];
|
struct dlist *links;
|
||||||
struct sysfs_directory *subdirs;
|
struct dlist *attributes;
|
||||||
struct sysfs_dlink *links;
|
unsigned char name[SYSFS_NAME_LEN];
|
||||||
struct sysfs_attribute *attributes;
|
unsigned char path[SYSFS_PATH_MAX];
|
||||||
};
|
};
|
||||||
|
|
||||||
struct sysfs_driver {
|
struct sysfs_driver {
|
||||||
struct sysfs_driver *next;
|
struct dlist *devices;
|
||||||
char name[SYSFS_NAME_LEN];
|
unsigned char name[SYSFS_NAME_LEN];
|
||||||
struct sysfs_directory *directory;
|
unsigned char path[SYSFS_PATH_MAX];
|
||||||
struct sysfs_device *device;
|
|
||||||
|
/* for internal use only */
|
||||||
|
struct sysfs_directory *directory;
|
||||||
};
|
};
|
||||||
|
|
||||||
struct sysfs_device {
|
struct sysfs_device {
|
||||||
struct sysfs_device *next;
|
struct sysfs_device *parent;
|
||||||
char name[SYSFS_NAME_LEN];
|
struct dlist *children;
|
||||||
char bus_id[SYSFS_NAME_LEN];
|
unsigned char name[SYSFS_NAME_LEN];
|
||||||
struct sysfs_driver *driver;
|
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_directory *directory;
|
||||||
struct sysfs_device *parent;
|
|
||||||
struct sysfs_device *children;
|
|
||||||
};
|
};
|
||||||
|
|
||||||
struct sysfs_bus {
|
struct sysfs_bus {
|
||||||
struct sysfs_bus *next;
|
struct dlist *drivers;
|
||||||
char name[SYSFS_NAME_LEN];
|
struct dlist *devices;
|
||||||
struct sysfs_directory *directory;
|
unsigned char name[SYSFS_NAME_LEN];
|
||||||
struct sysfs_driver *drivers;
|
unsigned char path[SYSFS_PATH_MAX];
|
||||||
struct sysfs_device *devices;
|
|
||||||
|
/* internal use only */
|
||||||
|
struct sysfs_directory *directory;
|
||||||
};
|
};
|
||||||
|
|
||||||
struct sysfs_class_device {
|
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_device *sysdevice; /* NULL if virtual */
|
||||||
struct sysfs_driver *driver; /* NULL if not implemented */
|
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 {
|
||||||
struct sysfs_class *next;
|
struct dlist *devices;
|
||||||
char name[SYSFS_NAME_LEN];
|
unsigned char name[SYSFS_NAME_LEN];
|
||||||
struct sysfs_directory *directory;
|
unsigned char path[SYSFS_PATH_MAX];
|
||||||
struct sysfs_class_device *devices;
|
|
||||||
|
/* for internal use only */
|
||||||
|
struct sysfs_directory *directory;
|
||||||
};
|
};
|
||||||
|
|
||||||
#ifdef __cplusplus
|
#ifdef __cplusplus
|
||||||
|
@ -114,46 +140,108 @@ extern "C" {
|
||||||
/*
|
/*
|
||||||
* Function Prototypes
|
* Function Prototypes
|
||||||
*/
|
*/
|
||||||
extern int sysfs_get_mnt_path(char *mnt_path, size_t len);
|
extern int sysfs_get_mnt_path(unsigned 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_name_from_path(const unsigned char *path,
|
||||||
extern int sysfs_get_link(const char *path, char *target, size_t len);
|
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 */
|
/* sysfs directory and file access */
|
||||||
extern void sysfs_close_attribute(struct sysfs_attribute *sysattr);
|
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(struct sysfs_attribute *sysattr);
|
||||||
extern int sysfs_read_attribute_value(const char *attrpath, char *value,
|
extern int sysfs_read_attribute_value(const unsigned char *attrpath,
|
||||||
size_t vsize);
|
unsigned char *value, size_t vsize);
|
||||||
extern char *sysfs_get_value_from_attributes(struct sysfs_attribute *attr,
|
extern int sysfs_write_attribute(struct sysfs_attribute *sysattr,
|
||||||
const char * name);
|
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 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 int sysfs_read_directory(struct sysfs_directory *sysdir);
|
||||||
extern void sysfs_close_dlink(struct sysfs_dlink *dlink);
|
extern int sysfs_read_all_subdirs(struct sysfs_directory *sysdir);
|
||||||
extern struct sysfs_dlink *sysfs_open_dlink(const char *linkpath);
|
extern struct sysfs_directory *sysfs_get_subdirectory
|
||||||
extern int sysfs_read_dlinks(struct sysfs_dlink *dlink);
|
(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 */
|
/* sysfs driver access */
|
||||||
extern void sysfs_close_driver(struct sysfs_driver *driver);
|
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 */
|
/* 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(struct sysfs_device *dev);
|
||||||
extern void sysfs_close_device_tree(struct sysfs_device *dev);
|
extern struct sysfs_device *sysfs_open_device(const unsigned char *path);
|
||||||
extern struct sysfs_device *sysfs_open_device(const char *path);
|
|
||||||
extern struct sysfs_device *sysfs_open_device_tree(const char *path);
|
|
||||||
extern struct sysfs_attribute *sysfs_get_device_attr
|
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 */
|
/* generic sysfs bus access */
|
||||||
extern void sysfs_close_bus(struct sysfs_bus *bus);
|
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 */
|
/* generic sysfs class access */
|
||||||
extern void sysfs_close_class_device(struct sysfs_class_device *dev);
|
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 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
|
#ifdef __cplusplus
|
||||||
}
|
}
|
||||||
|
|
|
@ -3,7 +3,7 @@
|
||||||
*
|
*
|
||||||
* Internal Header Definitions for libsysfs
|
* 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
|
* This library is free software; you can redistribute it and/or
|
||||||
* modify it under the terms of the GNU Lesser General Public
|
* modify it under the terms of the GNU Lesser General Public
|
||||||
|
|
|
@ -3,7 +3,7 @@
|
||||||
*
|
*
|
||||||
* Generic bus utility functions for libsysfs
|
* 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
|
* This library is free software; you can redistribute it and/or
|
||||||
* modify it under the terms of the GNU Lesser General Public
|
* modify it under the terms of the GNU Lesser General Public
|
||||||
|
@ -23,28 +23,62 @@
|
||||||
#include "libsysfs.h"
|
#include "libsysfs.h"
|
||||||
#include "sysfs.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
|
* sysfs_close_bus: close single bus
|
||||||
* @bus: bus structure
|
* @bus: bus structure
|
||||||
*/
|
*/
|
||||||
void sysfs_close_bus(struct sysfs_bus *bus)
|
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 != NULL) {
|
||||||
if (bus->directory != NULL)
|
if (bus->directory != NULL)
|
||||||
sysfs_close_directory(bus->directory);
|
sysfs_close_directory(bus->directory);
|
||||||
for (curdev = bus->devices; curdev != NULL;
|
if (bus->devices)
|
||||||
curdev = nextdev) {
|
dlist_destroy(bus->devices);
|
||||||
nextdev = curdev->next;
|
if (bus->drivers)
|
||||||
sysfs_close_device(curdev);
|
dlist_destroy(bus->drivers);
|
||||||
}
|
|
||||||
for (curdrv = bus->drivers; curdrv != NULL;
|
|
||||||
curdrv = nextdrv) {
|
|
||||||
nextdrv = curdrv->next;
|
|
||||||
sysfs_close_driver(curdrv);
|
|
||||||
}
|
|
||||||
free(bus);
|
free(bus);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -62,10 +96,10 @@ static struct sysfs_bus *alloc_bus(void)
|
||||||
* open_bus_dir: opens up sysfs bus directory
|
* open_bus_dir: opens up sysfs bus directory
|
||||||
* returns sysfs_directory struct with success and NULL with error
|
* 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;
|
struct sysfs_directory *busdir = NULL;
|
||||||
char buspath[SYSFS_PATH_MAX];
|
unsigned char buspath[SYSFS_PATH_MAX];
|
||||||
|
|
||||||
if (name == NULL) {
|
if (name == NULL) {
|
||||||
errno = EINVAL;
|
errno = EINVAL;
|
||||||
|
@ -74,7 +108,7 @@ static struct sysfs_directory *open_bus_dir(const char *name)
|
||||||
|
|
||||||
memset(buspath, 0, SYSFS_PATH_MAX);
|
memset(buspath, 0, SYSFS_PATH_MAX);
|
||||||
if ((sysfs_get_mnt_path(buspath, SYSFS_PATH_MAX)) != 0) {
|
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;
|
return NULL;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -84,53 +118,22 @@ static struct sysfs_directory *open_bus_dir(const char *name)
|
||||||
busdir = sysfs_open_directory(buspath);
|
busdir = sysfs_open_directory(buspath);
|
||||||
if (busdir == NULL) {
|
if (busdir == NULL) {
|
||||||
errno = EINVAL;
|
errno = EINVAL;
|
||||||
dprintf(stderr,"Bus %s not supported on this system\n",
|
dprintf("Bus %s not supported on this system\n",
|
||||||
name);
|
name);
|
||||||
return NULL;
|
return NULL;
|
||||||
}
|
}
|
||||||
if ((sysfs_read_directory(busdir)) != 0) {
|
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);
|
buspath);
|
||||||
sysfs_close_directory(busdir);
|
sysfs_close_directory(busdir);
|
||||||
return NULL;
|
return NULL;
|
||||||
}
|
}
|
||||||
/* read in devices and drivers subdirs */
|
/* read in devices and drivers subdirs */
|
||||||
for (cur = busdir->subdirs; cur != NULL; cur = next) {
|
sysfs_read_all_subdirs(busdir);
|
||||||
next = cur->next;
|
|
||||||
if ((sysfs_read_directory(cur)) != 0)
|
|
||||||
continue;
|
|
||||||
}
|
|
||||||
|
|
||||||
return 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
|
* get_all_bus_devices: gets all devices for bus
|
||||||
* @bus: bus to get devices for
|
* @bus: bus to get devices for
|
||||||
|
@ -140,29 +143,33 @@ static int get_all_bus_devices(struct sysfs_bus *bus)
|
||||||
{
|
{
|
||||||
struct sysfs_device *bdev = NULL;
|
struct sysfs_device *bdev = NULL;
|
||||||
struct sysfs_directory *cur = NULL;
|
struct sysfs_directory *cur = NULL;
|
||||||
struct sysfs_dlink *curl = NULL, *nextl = NULL;
|
struct sysfs_link *curl = NULL;
|
||||||
char dirname[SYSFS_NAME_LEN];
|
|
||||||
|
|
||||||
if (bus == NULL || bus->directory == NULL) {
|
if (bus == NULL || bus->directory == NULL) {
|
||||||
errno = EINVAL;
|
errno = EINVAL;
|
||||||
return -1;
|
return -1;
|
||||||
}
|
}
|
||||||
for (cur = bus->directory->subdirs; cur != NULL; cur = cur->next) {
|
if (bus->directory->subdirs == NULL)
|
||||||
memset(dirname, 0, SYSFS_NAME_LEN);
|
return 0;
|
||||||
if ((sysfs_get_name_from_path(cur->path, dirname,
|
|
||||||
SYSFS_NAME_LEN)) != 0)
|
dlist_for_each_data(bus->directory->subdirs, cur,
|
||||||
|
struct sysfs_directory) {
|
||||||
|
if (strcmp(cur->name, SYSFS_DEVICES_NAME) != 0)
|
||||||
continue;
|
continue;
|
||||||
if (strcmp(dirname, SYSFS_DEVICES_NAME) != 0)
|
if (cur->links == NULL)
|
||||||
continue;
|
continue;
|
||||||
for (curl = cur->links; curl != NULL; curl = nextl) {
|
dlist_for_each_data(cur->links, curl, struct sysfs_link) {
|
||||||
nextl = curl->next;
|
bdev = sysfs_open_device(curl->target);
|
||||||
bdev = sysfs_open_device(curl->target->path);
|
|
||||||
if (bdev == NULL) {
|
if (bdev == NULL) {
|
||||||
dprintf(stderr, "Error opening device at %s\n",
|
dprintf("Error opening device at %s\n",
|
||||||
curl->target->path);
|
curl->target);
|
||||||
continue;
|
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);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -177,31 +184,35 @@ static int get_all_bus_devices(struct sysfs_bus *bus)
|
||||||
static int get_all_bus_drivers(struct sysfs_bus *bus)
|
static int get_all_bus_drivers(struct sysfs_bus *bus)
|
||||||
{
|
{
|
||||||
struct sysfs_driver *driver = NULL;
|
struct sysfs_driver *driver = NULL;
|
||||||
struct sysfs_directory *cur = NULL, *next = NULL;
|
struct sysfs_directory *cur = NULL;
|
||||||
struct sysfs_directory *cursub = NULL, *nextsub = NULL;
|
struct sysfs_directory *cursub = NULL;
|
||||||
char dirname[SYSFS_NAME_LEN];
|
|
||||||
|
|
||||||
if (bus == NULL || bus->directory == NULL) {
|
if (bus == NULL || bus->directory == NULL) {
|
||||||
errno = EINVAL;
|
errno = EINVAL;
|
||||||
return -1;
|
return -1;
|
||||||
}
|
}
|
||||||
for (cur = bus->directory->subdirs; cur != NULL; cur = next) {
|
if (bus->directory->subdirs == NULL)
|
||||||
next = cur->next;
|
return 0;
|
||||||
memset(dirname, 0, SYSFS_NAME_LEN);
|
|
||||||
if ((sysfs_get_name_from_path(cur->path, dirname,
|
dlist_for_each_data(bus->directory->subdirs, cur,
|
||||||
SYSFS_NAME_LEN)) != 0)
|
struct sysfs_directory) {
|
||||||
|
if (strcmp(cur->name, SYSFS_DRIVERS_NAME) != 0)
|
||||||
continue;
|
continue;
|
||||||
if (strcmp(dirname, SYSFS_DRIVERS_NAME) != 0)
|
if (cur->subdirs == NULL)
|
||||||
continue;
|
continue;
|
||||||
for (cursub = cur->subdirs; cursub != NULL; cursub = nextsub) {
|
dlist_for_each_data(cur->subdirs, cursub,
|
||||||
nextsub = cursub->next;
|
struct sysfs_directory) {
|
||||||
driver = sysfs_open_driver(cursub->path);
|
driver = sysfs_open_driver(cursub->path);
|
||||||
if (driver == NULL) {
|
if (driver == NULL) {
|
||||||
dprintf(stderr, "Error opening driver at %s\n",
|
dprintf("Error opening driver at %s\n",
|
||||||
cursub->path);
|
cursub->path);
|
||||||
continue;
|
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);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -214,20 +225,22 @@ static int get_all_bus_drivers(struct sysfs_bus *bus)
|
||||||
* @busid: busid of device to match
|
* @busid: busid of device to match
|
||||||
* returns 1 if found and 0 if not found
|
* 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;
|
int found = 0;
|
||||||
|
|
||||||
if (driver == NULL || driver->directory == NULL || busid == NULL) {
|
if (driver == NULL || driver->directory == NULL || busid == NULL) {
|
||||||
errno = EINVAL;
|
errno = EINVAL;
|
||||||
return found;
|
return found;
|
||||||
}
|
}
|
||||||
for (cur = driver->directory->links; cur != NULL && found == 0;
|
if (driver->directory->links != NULL) {
|
||||||
cur = next) {
|
dlist_for_each_data(driver->directory->links, cur,
|
||||||
next = cur->next;
|
struct sysfs_link) {
|
||||||
if ((strcmp(cur->name, busid)) == 0)
|
if ((strcmp(cur->name, busid)) == 0)
|
||||||
found++;
|
found++;
|
||||||
|
}
|
||||||
}
|
}
|
||||||
return found;
|
return found;
|
||||||
}
|
}
|
||||||
|
@ -238,19 +251,22 @@ static int match_bus_device_to_driver(struct sysfs_driver *driver, char *busid)
|
||||||
*/
|
*/
|
||||||
static void link_bus_devices_to_drivers(struct sysfs_bus *bus)
|
static void link_bus_devices_to_drivers(struct sysfs_bus *bus)
|
||||||
{
|
{
|
||||||
struct sysfs_device *dev = NULL, *nextdev = NULL;
|
struct sysfs_device *dev = NULL;
|
||||||
struct sysfs_driver *drv = NULL, *nextdrv = NULL;
|
struct sysfs_driver *drv = NULL;
|
||||||
|
|
||||||
if (bus != NULL && bus->devices != NULL && bus->drivers != NULL) {
|
if (bus != NULL && bus->devices != NULL && bus->drivers != NULL) {
|
||||||
for (dev = bus->devices; dev != NULL; dev = nextdev) {
|
dlist_for_each_data(bus->devices, dev, struct sysfs_device) {
|
||||||
nextdev = dev->next;
|
dlist_for_each_data(bus->drivers, drv,
|
||||||
|
struct sysfs_driver) {
|
||||||
for (drv = bus->drivers; drv != NULL; drv = nextdrv) {
|
|
||||||
nextdrv = drv->next;
|
|
||||||
if ((match_bus_device_to_driver(drv,
|
if ((match_bus_device_to_driver(drv,
|
||||||
dev->bus_id)) != 0) {
|
dev->bus_id)) != 0) {
|
||||||
dev->driver = drv;
|
strncpy(dev->driver_name, drv->name,
|
||||||
drv->device = dev;
|
SYSFS_NAME_LEN);
|
||||||
|
if (drv->devices == NULL)
|
||||||
|
drv->devices = dlist_new
|
||||||
|
(sizeof(struct
|
||||||
|
sysfs_device));
|
||||||
|
dlist_unshift(drv->devices, dev);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -261,7 +277,7 @@ static void link_bus_devices_to_drivers(struct sysfs_bus *bus)
|
||||||
* sysfs_open_bus: opens specific bus and all its devices on system
|
* sysfs_open_bus: opens specific bus and all its devices on system
|
||||||
* returns sysfs_bus structure with success or NULL with error.
|
* 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_bus *bus = NULL;
|
||||||
struct sysfs_directory *busdir = NULL;
|
struct sysfs_directory *busdir = NULL;
|
||||||
|
@ -273,25 +289,26 @@ struct sysfs_bus *sysfs_open_bus(const char *name)
|
||||||
|
|
||||||
bus = alloc_bus();
|
bus = alloc_bus();
|
||||||
if (bus == NULL) {
|
if (bus == NULL) {
|
||||||
perror("malloc");
|
dprintf("calloc failed\n");
|
||||||
return NULL;
|
return NULL;
|
||||||
}
|
}
|
||||||
strcpy(bus->name, name);
|
strcpy(bus->name, name);
|
||||||
busdir = open_bus_dir(name);
|
busdir = open_bus_dir(name);
|
||||||
if (busdir == NULL) {
|
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);
|
name);
|
||||||
sysfs_close_bus(bus);
|
sysfs_close_bus(bus);
|
||||||
return NULL;
|
return NULL;
|
||||||
}
|
}
|
||||||
|
strcpy(bus->path, busdir->path);
|
||||||
bus->directory = busdir;
|
bus->directory = busdir;
|
||||||
if ((get_all_bus_devices(bus)) != 0) {
|
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);
|
sysfs_close_bus(bus);
|
||||||
return NULL;
|
return NULL;
|
||||||
}
|
}
|
||||||
if ((get_all_bus_drivers(bus)) != 0) {
|
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);
|
sysfs_close_bus(bus);
|
||||||
return NULL;
|
return NULL;
|
||||||
}
|
}
|
||||||
|
@ -299,3 +316,198 @@ struct sysfs_bus *sysfs_open_bus(const char *name)
|
||||||
|
|
||||||
return bus;
|
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;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
|
@ -3,7 +3,7 @@
|
||||||
*
|
*
|
||||||
* Generic class utility functions for libsysfs
|
* 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
|
* This library is free software; you can redistribute it and/or
|
||||||
* modify it under the terms of the GNU Lesser General Public
|
* modify it under the terms of the GNU Lesser General Public
|
||||||
|
@ -23,6 +23,28 @@
|
||||||
#include "libsysfs.h"
|
#include "libsysfs.h"
|
||||||
#include "sysfs.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.
|
* sysfs_close_class_device: closes a single class device.
|
||||||
* @dev: class device to close.
|
* @dev: class device to close.
|
||||||
|
@ -46,15 +68,11 @@ void sysfs_close_class_device(struct sysfs_class_device *dev)
|
||||||
*/
|
*/
|
||||||
void sysfs_close_class(struct sysfs_class *cls)
|
void sysfs_close_class(struct sysfs_class *cls)
|
||||||
{
|
{
|
||||||
struct sysfs_class_device *cur = NULL, *next = NULL;
|
|
||||||
|
|
||||||
if (cls != NULL) {
|
if (cls != NULL) {
|
||||||
if (cls->directory != NULL)
|
if (cls->directory != NULL)
|
||||||
sysfs_close_directory(cls->directory);
|
sysfs_close_directory(cls->directory);
|
||||||
for (cur = cls->devices; cur != NULL; cur = next) {
|
if (cls->devices != NULL)
|
||||||
next = cur->next;
|
dlist_destroy(cls->devices);
|
||||||
sysfs_close_class_device(cur);
|
|
||||||
}
|
|
||||||
free(cls);
|
free(cls);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -82,10 +100,10 @@ static struct sysfs_class *alloc_class(void)
|
||||||
* open_class_dir: opens up sysfs class directory
|
* open_class_dir: opens up sysfs class directory
|
||||||
* returns sysfs_directory struct with success and NULL with error
|
* 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;
|
struct sysfs_directory *classdir = NULL;
|
||||||
char classpath[SYSFS_PATH_MAX];
|
unsigned char classpath[SYSFS_PATH_MAX];
|
||||||
|
|
||||||
if (name == NULL) {
|
if (name == NULL) {
|
||||||
errno = EINVAL;
|
errno = EINVAL;
|
||||||
|
@ -94,7 +112,7 @@ static struct sysfs_directory *open_class_dir(const char *name)
|
||||||
|
|
||||||
memset(classpath, 0, SYSFS_PATH_MAX);
|
memset(classpath, 0, SYSFS_PATH_MAX);
|
||||||
if ((sysfs_get_mnt_path(classpath, SYSFS_PATH_MAX)) != 0) {
|
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;
|
return NULL;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -104,13 +122,11 @@ static struct sysfs_directory *open_class_dir(const char *name)
|
||||||
classdir = sysfs_open_directory(classpath);
|
classdir = sysfs_open_directory(classpath);
|
||||||
if (classdir == NULL) {
|
if (classdir == NULL) {
|
||||||
errno = EINVAL;
|
errno = EINVAL;
|
||||||
dprintf(stderr,"Class %s not supported on this system\n",
|
dprintf("Class %s not supported on this system\n", name);
|
||||||
name);
|
|
||||||
return NULL;
|
return NULL;
|
||||||
}
|
}
|
||||||
if ((sysfs_read_directory(classdir)) != 0) {
|
if ((sysfs_read_directory(classdir)) != 0) {
|
||||||
dprintf(stderr, "Error reading %s class dir %s\n", name,
|
dprintf("Error reading %s class dir %s\n", name, classpath);
|
||||||
classpath);
|
|
||||||
sysfs_close_directory(classdir);
|
sysfs_close_directory(classdir);
|
||||||
return NULL;
|
return NULL;
|
||||||
}
|
}
|
||||||
|
@ -123,14 +139,13 @@ static struct sysfs_directory *open_class_dir(const char *name)
|
||||||
* @path: path to class device.
|
* @path: path to class device.
|
||||||
* returns struct sysfs_class_device with success and NULL with error.
|
* 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_class_device *cdev = NULL;
|
||||||
struct sysfs_directory *dir = NULL, *cur = NULL;
|
struct sysfs_directory *dir = NULL;
|
||||||
struct sysfs_dlink *curl = NULL;
|
struct sysfs_link *curl = NULL;
|
||||||
struct sysfs_device *sdev = NULL;
|
struct sysfs_device *sdev = NULL;
|
||||||
struct sysfs_driver *drv = NULL;
|
struct sysfs_driver *drv = NULL;
|
||||||
char temp[SYSFS_NAME_LEN];
|
|
||||||
|
|
||||||
if (path == NULL) {
|
if (path == NULL) {
|
||||||
errno = EINVAL;
|
errno = EINVAL;
|
||||||
|
@ -138,74 +153,69 @@ struct sysfs_class_device *sysfs_open_class_device(const char *path)
|
||||||
}
|
}
|
||||||
cdev = alloc_class_device();
|
cdev = alloc_class_device();
|
||||||
if (cdev == NULL) {
|
if (cdev == NULL) {
|
||||||
perror("malloc");
|
dprintf("calloc failed\n");
|
||||||
return NULL;
|
return NULL;
|
||||||
}
|
}
|
||||||
memset(temp, 0, SYSFS_NAME_LEN);
|
if ((sysfs_get_name_from_path(path, cdev->name, SYSFS_NAME_LEN)) != 0) {
|
||||||
if ((sysfs_get_name_from_path(path, temp, SYSFS_NAME_LEN)) != 0) {
|
|
||||||
errno = EINVAL;
|
errno = EINVAL;
|
||||||
dprintf(stderr, "Invalid class device path %s\n", path);
|
dprintf("Invalid class device path %s\n", path);
|
||||||
sysfs_close_class_device(cdev);
|
sysfs_close_class_device(cdev);
|
||||||
return NULL;
|
return NULL;
|
||||||
}
|
}
|
||||||
strcpy(cdev->name, temp);
|
|
||||||
|
|
||||||
dir = sysfs_open_directory(path);
|
dir = sysfs_open_directory(path);
|
||||||
if (dir == NULL) {
|
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);
|
sysfs_close_class_device(cdev);
|
||||||
return NULL;
|
return NULL;
|
||||||
}
|
}
|
||||||
if ((sysfs_read_directory(dir)) != 0) {
|
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_directory(dir);
|
||||||
sysfs_close_class_device(cdev);
|
sysfs_close_class_device(cdev);
|
||||||
return NULL;
|
return NULL;
|
||||||
}
|
}
|
||||||
|
sysfs_read_all_subdirs(dir);
|
||||||
cdev->directory = 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 */
|
/* get driver and device, if implemented */
|
||||||
curl = cdev->directory->links;
|
if (cdev->directory->links != NULL) {
|
||||||
while (curl != NULL) {
|
dlist_for_each_data(cdev->directory->links, curl,
|
||||||
if (strncmp(curl->name, SYSFS_DEVICES_NAME, 6) == 0) {
|
struct sysfs_link) {
|
||||||
sdev = sysfs_open_device(curl->target->path);
|
if (strncmp(curl->name, SYSFS_DEVICES_NAME, 6) == 0) {
|
||||||
if (sdev != NULL) {
|
sdev = sysfs_open_device(curl->target);
|
||||||
cdev->sysdevice = sdev;
|
if (sdev != NULL) {
|
||||||
if (cdev->driver != NULL)
|
cdev->sysdevice = sdev;
|
||||||
sdev->driver = cdev->driver;
|
if (cdev->driver != NULL)
|
||||||
}
|
strncpy(sdev->driver_name,
|
||||||
} else if (strncmp(curl->name, SYSFS_DRIVERS_NAME, 6) == 0) {
|
cdev->driver->name,
|
||||||
drv = sysfs_open_driver(curl->target->path);
|
SYSFS_NAME_LEN);
|
||||||
if (drv != NULL) {
|
}
|
||||||
cdev->driver = drv;
|
} else if (strncmp(curl->name,
|
||||||
if (cdev->sysdevice != NULL)
|
SYSFS_DRIVERS_NAME, 6) == 0) {
|
||||||
drv->device = cdev->sysdevice;
|
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;
|
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
|
* get_all_class_devices: gets all devices for class
|
||||||
* @class: class to get devices for
|
* @class: class to get devices for
|
||||||
|
@ -214,23 +224,27 @@ static void add_dev_to_class(struct sysfs_class *cls,
|
||||||
static int get_all_class_devices(struct sysfs_class *cls)
|
static int get_all_class_devices(struct sysfs_class *cls)
|
||||||
{
|
{
|
||||||
struct sysfs_class_device *dev = NULL;
|
struct sysfs_class_device *dev = NULL;
|
||||||
struct sysfs_directory *cur = NULL, *next = NULL;
|
struct sysfs_directory *cur = NULL;
|
||||||
|
|
||||||
if (cls == NULL || cls->directory == NULL) {
|
if (cls == NULL || cls->directory == NULL) {
|
||||||
errno = EINVAL;
|
errno = EINVAL;
|
||||||
return -1;
|
return -1;
|
||||||
}
|
}
|
||||||
for (cur = cls->directory->subdirs; cur != NULL; cur = next) {
|
if (cls->directory->subdirs == NULL)
|
||||||
next = cur->next;
|
return 0;
|
||||||
|
dlist_for_each_data(cls->directory->subdirs, cur,
|
||||||
|
struct sysfs_directory) {
|
||||||
dev = sysfs_open_class_device(cur->path);
|
dev = sysfs_open_class_device(cur->path);
|
||||||
if (dev == NULL) {
|
if (dev == NULL) {
|
||||||
dprintf(stderr, "Error opening device at %s\n",
|
dprintf("Error opening device at %s\n", cur->path);
|
||||||
cur->path);
|
|
||||||
continue;
|
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;
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -238,7 +252,7 @@ static int get_all_class_devices(struct sysfs_class *cls)
|
||||||
* sysfs_open_class: opens specific class and all its devices on system
|
* sysfs_open_class: opens specific class and all its devices on system
|
||||||
* returns sysfs_class structure with success or NULL with error.
|
* 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_class *cls = NULL;
|
||||||
struct sysfs_directory *classdir = NULL;
|
struct sysfs_directory *classdir = NULL;
|
||||||
|
@ -250,24 +264,268 @@ struct sysfs_class *sysfs_open_class(const char *name)
|
||||||
|
|
||||||
cls = alloc_class();
|
cls = alloc_class();
|
||||||
if (cls == NULL) {
|
if (cls == NULL) {
|
||||||
perror("malloc");
|
dprintf("calloc failed\n");
|
||||||
return NULL;
|
return NULL;
|
||||||
}
|
}
|
||||||
strcpy(cls->name, name);
|
strcpy(cls->name, name);
|
||||||
classdir = open_class_dir(name);
|
classdir = open_class_dir(name);
|
||||||
if (classdir == NULL) {
|
if (classdir == NULL) {
|
||||||
dprintf(stderr,
|
dprintf("Invalid class, %s not supported on this system\n",
|
||||||
"Invalid class, %s not supported on this system\n",
|
|
||||||
name);
|
name);
|
||||||
sysfs_close_class(cls);
|
sysfs_close_class(cls);
|
||||||
return NULL;
|
return NULL;
|
||||||
}
|
}
|
||||||
cls->directory = classdir;
|
cls->directory = classdir;
|
||||||
|
strcpy(cls->path, classdir->path);
|
||||||
if ((get_all_class_devices(cls)) != 0) {
|
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);
|
sysfs_close_class(cls);
|
||||||
return NULL;
|
return NULL;
|
||||||
}
|
}
|
||||||
|
|
||||||
return cls;
|
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;
|
||||||
|
}
|
||||||
|
|
|
@ -3,7 +3,7 @@
|
||||||
*
|
*
|
||||||
* Generic device utility functions for libsysfs
|
* 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
|
* This library is free software; you can redistribute it and/or
|
||||||
* modify it under the terms of the GNU Lesser General Public
|
* modify it under the terms of the GNU Lesser General Public
|
||||||
|
@ -23,6 +23,42 @@
|
||||||
#include "libsysfs.h"
|
#include "libsysfs.h"
|
||||||
#include "sysfs.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
|
* sysfs_close_device: closes and cleans up a device
|
||||||
* @dev = device to clean up
|
* @dev = device to clean up
|
||||||
|
@ -30,11 +66,10 @@
|
||||||
void sysfs_close_device(struct sysfs_device *dev)
|
void sysfs_close_device(struct sysfs_device *dev)
|
||||||
{
|
{
|
||||||
if (dev != NULL) {
|
if (dev != NULL) {
|
||||||
dev->next = NULL;
|
|
||||||
dev->driver = NULL;
|
|
||||||
if (dev->directory != NULL)
|
if (dev->directory != NULL)
|
||||||
sysfs_close_directory(dev->directory);
|
sysfs_close_directory(dev->directory);
|
||||||
dev->children = NULL;
|
if (dev->children != NULL && dev->children->count == 0)
|
||||||
|
dlist_destroy(dev->children);
|
||||||
free(dev);
|
free(dev);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -55,24 +90,20 @@ static struct sysfs_device *alloc_device(void)
|
||||||
* returns sysfs_attribute reference with success or NULL with error.
|
* returns sysfs_attribute reference with success or NULL with error.
|
||||||
*/
|
*/
|
||||||
struct sysfs_attribute *sysfs_get_device_attr(struct sysfs_device *dev,
|
struct sysfs_attribute *sysfs_get_device_attr(struct sysfs_device *dev,
|
||||||
const char *name)
|
const unsigned char *name)
|
||||||
{
|
{
|
||||||
struct sysfs_attribute *cur = NULL;
|
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;
|
errno = EINVAL;
|
||||||
return NULL;
|
return NULL;
|
||||||
}
|
}
|
||||||
for (cur = dev->directory->attributes; cur != NULL; cur = cur->next) {
|
|
||||||
if ((sysfs_get_name_from_path(cur->path, attrname,
|
cur = sysfs_get_directory_attribute(dev->directory,
|
||||||
SYSFS_NAME_LEN)) != 0)
|
(unsigned char *)name);
|
||||||
continue;
|
if (cur != NULL)
|
||||||
if (strcmp(name, attrname) != 0)
|
|
||||||
continue;
|
|
||||||
|
|
||||||
return cur;
|
return cur;
|
||||||
}
|
|
||||||
|
|
||||||
return NULL;
|
return NULL;
|
||||||
}
|
}
|
||||||
|
@ -82,11 +113,10 @@ struct sysfs_attribute *sysfs_get_device_attr(struct sysfs_device *dev,
|
||||||
* @path: path to device, this is the /sys/devices/ path
|
* @path: path to device, this is the /sys/devices/ path
|
||||||
* returns sysfs_device structure with success or NULL with error
|
* 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_device *dev = NULL;
|
||||||
struct sysfs_directory *sdir = NULL;
|
struct sysfs_directory *sdir = NULL;
|
||||||
char *p = NULL;
|
|
||||||
|
|
||||||
if (path == NULL) {
|
if (path == NULL) {
|
||||||
errno = EINVAL;
|
errno = EINVAL;
|
||||||
|
@ -94,73 +124,36 @@ struct sysfs_device *sysfs_open_device(const char *path)
|
||||||
}
|
}
|
||||||
dev = alloc_device();
|
dev = alloc_device();
|
||||||
if (dev == NULL) {
|
if (dev == NULL) {
|
||||||
dprintf(stderr, "Error allocating device at %s\n", path);
|
dprintf("Error allocating device at %s\n", path);
|
||||||
return NULL;
|
return NULL;
|
||||||
}
|
}
|
||||||
sdir = sysfs_open_directory(path);
|
sdir = sysfs_open_directory(path);
|
||||||
if (sdir == NULL) {
|
if (sdir == NULL) {
|
||||||
dprintf(stderr, "Invalid device at %s\n", path);
|
dprintf("Invalid device at %s\n", path);
|
||||||
errno = EINVAL;
|
errno = EINVAL;
|
||||||
sysfs_close_device(dev);
|
sysfs_close_device(dev);
|
||||||
return NULL;
|
return NULL;
|
||||||
}
|
}
|
||||||
if ((sysfs_read_directory(sdir)) != 0) {
|
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_directory(sdir);
|
||||||
sysfs_close_device(dev);
|
sysfs_close_device(dev);
|
||||||
return NULL;
|
return NULL;
|
||||||
}
|
}
|
||||||
dev->directory = sdir;
|
dev->directory = sdir;
|
||||||
sysfs_get_name_from_path(sdir->path, dev->bus_id, SYSFS_NAME_LEN);
|
strcpy(dev->bus_id, sdir->name);
|
||||||
/* get device name */
|
strcpy(dev->path, sdir->path);
|
||||||
p = sysfs_get_value_from_attributes(sdir->attributes,
|
|
||||||
SYSFS_NAME_ATTRIBUTE);
|
/*
|
||||||
if (p != NULL) {
|
* The "name" attribute no longer exists... return the device's
|
||||||
strncpy(dev->name, p, SYSFS_NAME_LEN);
|
* sysfs representation instead, in the "dev->name" field, which
|
||||||
p = dev->name + strlen(dev->name) - 1;
|
* implies that the dev->name and dev->bus_id contain same data.
|
||||||
if ((strlen(dev->name) > 0) && *p == '\n')
|
*/
|
||||||
*p = '\0';
|
strncpy(dev->name, sdir->name, SYSFS_NAME_LEN);
|
||||||
}
|
|
||||||
|
|
||||||
return dev;
|
return dev;
|
||||||
}
|
}
|
||||||
|
|
||||||
/**
|
|
||||||
* sysfs_close_device_tree: closes every device in the supplied tree,
|
|
||||||
* closing children only.
|
|
||||||
* @devroot: device root of tree.
|
|
||||||
*/
|
|
||||||
void sysfs_close_device_tree(struct sysfs_device *devroot)
|
|
||||||
{
|
|
||||||
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);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
sysfs_close_device(devroot);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* add_device_child_to_parent: adds child device to parent
|
|
||||||
* @parent: parent device.
|
|
||||||
* @child: child device to add.
|
|
||||||
*/
|
|
||||||
static void add_device_child_to_parent(struct sysfs_device *parent,
|
|
||||||
struct sysfs_device *child)
|
|
||||||
{
|
|
||||||
if (parent != NULL && child != NULL) {
|
|
||||||
child->next = parent->children;
|
|
||||||
parent->children = child;
|
|
||||||
child->parent = parent;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* sysfs_open_device_tree: opens root device and all of its children,
|
* sysfs_open_device_tree: opens root device and all of its children,
|
||||||
* creating a tree of devices. Only opens children.
|
* creating a tree of devices. Only opens children.
|
||||||
|
@ -168,7 +161,7 @@ static void add_device_child_to_parent(struct sysfs_device *parent,
|
||||||
* returns struct sysfs_device and its children with success or NULL with
|
* returns struct sysfs_device and its children with success or NULL with
|
||||||
* error.
|
* error.
|
||||||
*/
|
*/
|
||||||
struct sysfs_device *sysfs_open_device_tree(const char *path)
|
static struct sysfs_device *sysfs_open_device_tree(const unsigned char *path)
|
||||||
{
|
{
|
||||||
struct sysfs_device *rootdev = NULL, *new = NULL;
|
struct sysfs_device *rootdev = NULL, *new = NULL;
|
||||||
struct sysfs_directory *cur = NULL;
|
struct sysfs_directory *cur = NULL;
|
||||||
|
@ -179,21 +172,367 @@ struct sysfs_device *sysfs_open_device_tree(const char *path)
|
||||||
}
|
}
|
||||||
rootdev = sysfs_open_device(path);
|
rootdev = sysfs_open_device(path);
|
||||||
if (rootdev == NULL) {
|
if (rootdev == NULL) {
|
||||||
dprintf(stderr, "Error opening root device at %s\n", path);
|
dprintf("Error opening root device at %s\n", path);
|
||||||
return NULL;
|
return NULL;
|
||||||
}
|
}
|
||||||
cur = rootdev->directory->subdirs;
|
if (rootdev->directory->subdirs != NULL) {
|
||||||
while (cur != NULL) {
|
dlist_for_each_data(rootdev->directory->subdirs, cur,
|
||||||
new = sysfs_open_device_tree(cur->path);
|
struct sysfs_directory) {
|
||||||
if (new == NULL) {
|
new = sysfs_open_device_tree(cur->path);
|
||||||
dprintf(stderr, "Error opening device tree at %s\n",
|
if (new == NULL) {
|
||||||
cur->path);
|
dprintf("Error opening device tree at %s\n",
|
||||||
sysfs_close_device_tree(rootdev);
|
cur->path);
|
||||||
return NULL;
|
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);
|
||||||
}
|
}
|
||||||
add_device_child_to_parent(rootdev, new);
|
|
||||||
cur = cur->next;
|
|
||||||
}
|
}
|
||||||
|
|
||||||
return rootdev;
|
return rootdev;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* sysfs_close_root_device: closes root and all devices
|
||||||
|
* @root: root device to close
|
||||||
|
*/
|
||||||
|
void sysfs_close_root_device(struct sysfs_root_device *root)
|
||||||
|
{
|
||||||
|
if (root != NULL) {
|
||||||
|
if (root->devices != NULL)
|
||||||
|
dlist_destroy(root->devices);
|
||||||
|
if (root->directory != NULL)
|
||||||
|
sysfs_close_directory(root->directory);
|
||||||
|
free(root);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* 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
|
||||||
|
*/
|
||||||
|
static struct sysfs_directory *open_root_device_dir(const unsigned char *name)
|
||||||
|
{
|
||||||
|
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 (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;
|
||||||
|
}
|
||||||
|
|
||||||
|
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;
|
||||||
|
}
|
||||||
|
|
||||||
|
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;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
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_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;
|
||||||
|
}
|
||||||
|
|
|
@ -3,7 +3,7 @@
|
||||||
*
|
*
|
||||||
* Directory utility functions for libsysfs
|
* 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
|
* This library is free software; you can redistribute it and/or
|
||||||
* modify it under the terms of the GNU Lesser General Public
|
* modify it under the terms of the GNU Lesser General Public
|
||||||
|
@ -23,6 +23,81 @@
|
||||||
#include "libsysfs.h"
|
#include "libsysfs.h"
|
||||||
#include "sysfs.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
|
* sysfs_close_attribute: closes and cleans up attribute
|
||||||
* @sysattr: attribute to close.
|
* @sysattr: attribute to close.
|
||||||
|
@ -51,7 +126,7 @@ static struct sysfs_attribute *alloc_attribute(void)
|
||||||
* @path: path to attribute.
|
* @path: path to attribute.
|
||||||
* returns sysfs_attribute struct with success and NULL with error.
|
* 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 sysfs_attribute *sysattr = NULL;
|
||||||
struct stat fileinfo;
|
struct stat fileinfo;
|
||||||
|
@ -62,13 +137,22 @@ struct sysfs_attribute *sysfs_open_attribute(const char *path)
|
||||||
}
|
}
|
||||||
sysattr = alloc_attribute();
|
sysattr = alloc_attribute();
|
||||||
if (sysattr == NULL) {
|
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;
|
return NULL;
|
||||||
}
|
}
|
||||||
strncpy(sysattr->path, path, sizeof(sysattr->path));
|
strncpy(sysattr->path, path, sizeof(sysattr->path));
|
||||||
if ((stat(sysattr->path, &fileinfo)) != 0) {
|
if ((stat(sysattr->path, &fileinfo)) != 0) {
|
||||||
perror("stat");
|
dprintf("Stat failed: No such attribute?\n");
|
||||||
sysattr->method = 0;
|
sysattr->method = 0;
|
||||||
|
free(sysattr);
|
||||||
|
sysattr = NULL;
|
||||||
} else {
|
} else {
|
||||||
if (fileinfo.st_mode & S_IRUSR)
|
if (fileinfo.st_mode & S_IRUSR)
|
||||||
sysattr->method |= SYSFS_METHOD_SHOW;
|
sysattr->method |= SYSFS_METHOD_SHOW;
|
||||||
|
@ -79,6 +163,87 @@ struct sysfs_attribute *sysfs_open_attribute(const char *path)
|
||||||
return sysattr;
|
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
|
* sysfs_read_attribute: reads value from attribute
|
||||||
* @sysattr: attribute to read
|
* @sysattr: attribute to read
|
||||||
|
@ -86,8 +251,8 @@ struct sysfs_attribute *sysfs_open_attribute(const char *path)
|
||||||
*/
|
*/
|
||||||
int sysfs_read_attribute(struct sysfs_attribute *sysattr)
|
int sysfs_read_attribute(struct sysfs_attribute *sysattr)
|
||||||
{
|
{
|
||||||
char *fbuf = NULL;
|
unsigned char *fbuf = NULL;
|
||||||
char *vbuf = NULL;
|
unsigned char *vbuf = NULL;
|
||||||
size_t length = 0;
|
size_t length = 0;
|
||||||
int pgsize = 0;
|
int pgsize = 0;
|
||||||
int fd;
|
int fd;
|
||||||
|
@ -97,34 +262,33 @@ int sysfs_read_attribute(struct sysfs_attribute *sysattr)
|
||||||
return -1;
|
return -1;
|
||||||
}
|
}
|
||||||
if (!(sysattr->method & SYSFS_METHOD_SHOW)) {
|
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);
|
sysattr->path);
|
||||||
return -1;
|
return -1;
|
||||||
}
|
}
|
||||||
pgsize = getpagesize();
|
pgsize = getpagesize();
|
||||||
fbuf = (char *)calloc(1, pgsize+1);
|
fbuf = (unsigned char *)calloc(1, pgsize+1);
|
||||||
if (fbuf == NULL) {
|
if (fbuf == NULL) {
|
||||||
perror("calloc");
|
dprintf("calloc failed\n");
|
||||||
return -1;
|
return -1;
|
||||||
}
|
}
|
||||||
if ((fd = open(sysattr->path, O_RDONLY)) < 0) {
|
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);
|
free(fbuf);
|
||||||
return -1;
|
return -1;
|
||||||
}
|
}
|
||||||
length = read(fd, fbuf, pgsize);
|
length = read(fd, fbuf, pgsize);
|
||||||
if (length < 0) {
|
if (length < 0) {
|
||||||
dprintf (stderr, "Error reading from attribute %s\n",
|
dprintf("Error reading from attribute %s\n", sysattr->path);
|
||||||
sysattr->path);
|
|
||||||
close(fd);
|
close(fd);
|
||||||
free(fbuf);
|
free(fbuf);
|
||||||
return -1;
|
return -1;
|
||||||
}
|
}
|
||||||
sysattr->len = length;
|
sysattr->len = length;
|
||||||
close(fd);
|
close(fd);
|
||||||
vbuf = (char *)realloc(fbuf, length+1);
|
vbuf = (unsigned char *)realloc(fbuf, length+1);
|
||||||
if (vbuf == NULL) {
|
if (vbuf == NULL) {
|
||||||
perror("realloc");
|
dprintf("realloc failed\n");
|
||||||
free(fbuf);
|
free(fbuf);
|
||||||
return -1;
|
return -1;
|
||||||
}
|
}
|
||||||
|
@ -142,7 +306,8 @@ int sysfs_read_attribute(struct sysfs_attribute *sysattr)
|
||||||
* @vsize: size of value buffer
|
* @vsize: size of value buffer
|
||||||
* returns 0 with success and -1 with error.
|
* 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;
|
struct sysfs_attribute *attr = NULL;
|
||||||
size_t length = 0;
|
size_t length = 0;
|
||||||
|
@ -154,19 +319,18 @@ int sysfs_read_attribute_value(const char *attrpath, char *value, size_t vsize)
|
||||||
|
|
||||||
attr = sysfs_open_attribute(attrpath);
|
attr = sysfs_open_attribute(attrpath);
|
||||||
if (attr == NULL) {
|
if (attr == NULL) {
|
||||||
dprintf(stderr, "Invalid attribute path %s\n", attrpath);
|
dprintf("Invalid attribute path %s\n", attrpath);
|
||||||
errno = EINVAL;
|
errno = EINVAL;
|
||||||
return -1;
|
return -1;
|
||||||
}
|
}
|
||||||
if((sysfs_read_attribute(attr)) != 0 || attr->value == NULL) {
|
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);
|
sysfs_close_attribute(attr);
|
||||||
return -1;
|
return -1;
|
||||||
}
|
}
|
||||||
length = strlen(attr->value);
|
length = strlen(attr->value);
|
||||||
if (length > vsize)
|
if (length > vsize)
|
||||||
dprintf(stderr,
|
dprintf("Value length %d is larger than supplied buffer %d\n",
|
||||||
"Value length %d is larger than supplied buffer %d\n",
|
|
||||||
length, vsize);
|
length, vsize);
|
||||||
strncpy(value, attr->value, vsize);
|
strncpy(value, attr->value, vsize);
|
||||||
sysfs_close_attribute(attr);
|
sysfs_close_attribute(attr);
|
||||||
|
@ -179,87 +343,32 @@ int sysfs_read_attribute_value(const char *attrpath, char *value, size_t vsize)
|
||||||
* attribute name, return its value
|
* attribute name, return its value
|
||||||
* @attr: attribute to search
|
* @attr: attribute to search
|
||||||
* @name: name to look for
|
* @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,
|
unsigned char *sysfs_get_value_from_attributes(struct dlist *attr,
|
||||||
const char *name)
|
const unsigned char *name)
|
||||||
{
|
{
|
||||||
struct sysfs_attribute *cur = NULL;
|
struct sysfs_attribute *cur = NULL;
|
||||||
char tmpname[SYSFS_NAME_LEN];
|
|
||||||
|
|
||||||
if (attr == NULL || name == NULL) {
|
if (attr == NULL || name == NULL) {
|
||||||
errno = EINVAL;
|
errno = EINVAL;
|
||||||
return NULL;
|
return NULL;
|
||||||
}
|
}
|
||||||
cur = attr;
|
dlist_for_each_data(attr, cur, struct sysfs_attribute) {
|
||||||
while (cur != NULL) {
|
if (strcmp(cur->name, name) == 0)
|
||||||
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)
|
|
||||||
return cur->value;
|
return cur->value;
|
||||||
cur = cur->next;
|
|
||||||
}
|
}
|
||||||
return NULL;
|
return NULL;
|
||||||
}
|
}
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* add_subdir_to_dir: adds subdirectory to directory's subdirs
|
* sysfs_close_link: closes and cleans up link.
|
||||||
* @sysdir: directory to add subdir to
|
* @ln: link to close.
|
||||||
* @subdir: subdirectory to add.
|
|
||||||
*/
|
*/
|
||||||
static void add_subdir_to_dir(struct sysfs_directory *sysdir,
|
void sysfs_close_link(struct sysfs_link *ln)
|
||||||
struct sysfs_directory *subdir)
|
|
||||||
{
|
{
|
||||||
if (sysdir != NULL && subdir != NULL) {
|
if (ln != NULL)
|
||||||
subdir->next = sysdir->subdirs;
|
free(ln);
|
||||||
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;
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
|
|
||||||
/**
|
/**
|
||||||
|
@ -268,35 +377,13 @@ static void add_dlink_to_dir(struct sysfs_directory *sysdir,
|
||||||
*/
|
*/
|
||||||
void sysfs_close_directory(struct sysfs_directory *sysdir)
|
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 != NULL) {
|
||||||
if (sysdir->subdirs != NULL) {
|
if (sysdir->subdirs != NULL)
|
||||||
for (sdir = sysdir->subdirs; sdir != NULL;
|
dlist_destroy(sysdir->subdirs);
|
||||||
sdir = dnext) {
|
if (sysdir->links != NULL)
|
||||||
dnext = sdir->next;
|
dlist_destroy(sysdir->links);
|
||||||
sysfs_close_directory(sdir);
|
if (sysdir->attributes != NULL)
|
||||||
}
|
dlist_destroy(sysdir->attributes);
|
||||||
}
|
|
||||||
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);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
free(sysdir);
|
free(sysdir);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -312,12 +399,35 @@ static struct sysfs_directory *alloc_directory(void)
|
||||||
}
|
}
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* alloc_dlink: allocates and initializes directory link structure
|
* alloc_link: allocates and initializes link structure
|
||||||
* returns struct sysfs_dlink with success or NULL with error.
|
* returns struct sysfs_link with success or NULL with error.
|
||||||
*/
|
*/
|
||||||
static struct sysfs_dlink *alloc_dlink(void)
|
static struct sysfs_link *alloc_link(void)
|
||||||
{
|
{
|
||||||
return (struct sysfs_dlink *)calloc(1, sizeof(struct sysfs_dlink));
|
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.
|
||||||
|
*/
|
||||||
|
int sysfs_read_all_subdirs(struct sysfs_directory *sysdir)
|
||||||
|
{
|
||||||
|
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;
|
||||||
}
|
}
|
||||||
|
|
||||||
/**
|
/**
|
||||||
|
@ -326,7 +436,7 @@ static struct sysfs_dlink *alloc_dlink(void)
|
||||||
* @path: path of directory to open.
|
* @path: path of directory to open.
|
||||||
* returns: struct sysfs_directory * with success and NULL on error.
|
* 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;
|
struct sysfs_directory *sdir = NULL;
|
||||||
|
|
||||||
|
@ -336,7 +446,12 @@ struct sysfs_directory *sysfs_open_directory(const char *path)
|
||||||
}
|
}
|
||||||
sdir = alloc_directory();
|
sdir = alloc_directory();
|
||||||
if (sdir == NULL) {
|
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;
|
return NULL;
|
||||||
}
|
}
|
||||||
strncpy(sdir->path, path, sizeof(sdir->path));
|
strncpy(sdir->path, path, sizeof(sdir->path));
|
||||||
|
@ -345,46 +460,33 @@ struct sysfs_directory *sysfs_open_directory(const char *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.
|
* @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_link *ln = NULL;
|
||||||
struct sysfs_directory *tdir = NULL;
|
|
||||||
char name[SYSFS_NAME_LEN];
|
|
||||||
char target[SYSFS_PATH_MAX];
|
|
||||||
|
|
||||||
if (linkpath == NULL) {
|
if (linkpath == NULL || strlen(linkpath) > SYSFS_PATH_MAX) {
|
||||||
errno = EINVAL;
|
errno = EINVAL;
|
||||||
return NULL;
|
return NULL;
|
||||||
}
|
}
|
||||||
|
|
||||||
memset(name, 0, SYSFS_NAME_LEN);
|
ln = alloc_link();
|
||||||
memset(target, 0, SYSFS_PATH_MAX);
|
if (ln == NULL) {
|
||||||
if ((sysfs_get_name_from_path(linkpath, name, SYSFS_NAME_LEN)) != 0
|
dprintf("Error allocating link %s\n", linkpath);
|
||||||
|| (sysfs_get_link(linkpath, target, SYSFS_PATH_MAX)) != 0) {
|
return NULL;
|
||||||
|
}
|
||||||
|
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;
|
errno = EINVAL;
|
||||||
dprintf(stderr, "Invalid link path %s\n", linkpath);
|
dprintf("Invalid link path %s\n", linkpath);
|
||||||
return NULL;
|
return NULL;
|
||||||
}
|
}
|
||||||
dlink = alloc_dlink();
|
|
||||||
if (dlink == NULL) {
|
|
||||||
dprintf(stderr,
|
|
||||||
"Error allocating directory link %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;
|
||||||
}
|
}
|
||||||
|
|
||||||
/**
|
/**
|
||||||
|
@ -399,8 +501,8 @@ int sysfs_read_directory(struct sysfs_directory *sysdir)
|
||||||
struct stat astats;
|
struct stat astats;
|
||||||
struct sysfs_attribute *attr = NULL;
|
struct sysfs_attribute *attr = NULL;
|
||||||
struct sysfs_directory *subdir = NULL;
|
struct sysfs_directory *subdir = NULL;
|
||||||
struct sysfs_dlink *dlink = NULL;
|
struct sysfs_link *ln = NULL;
|
||||||
char file_path[SYSFS_PATH_MAX];
|
unsigned char file_path[SYSFS_PATH_MAX];
|
||||||
int retval = 0;
|
int retval = 0;
|
||||||
|
|
||||||
if (sysdir == NULL) {
|
if (sysdir == NULL) {
|
||||||
|
@ -409,7 +511,7 @@ int sysfs_read_directory(struct sysfs_directory *sysdir)
|
||||||
}
|
}
|
||||||
dir = opendir(sysdir->path);
|
dir = opendir(sysdir->path);
|
||||||
if (dir == NULL) {
|
if (dir == NULL) {
|
||||||
perror("opendir");
|
dprintf("Error opening directory %s\n", sysdir->path);
|
||||||
return -1;
|
return -1;
|
||||||
}
|
}
|
||||||
while(((dirent = readdir(dir)) != NULL) && retval == 0) {
|
while(((dirent = readdir(dir)) != NULL) && retval == 0) {
|
||||||
|
@ -422,45 +524,57 @@ int sysfs_read_directory(struct sysfs_directory *sysdir)
|
||||||
strncat(file_path, "/", sizeof(file_path));
|
strncat(file_path, "/", sizeof(file_path));
|
||||||
strncat(file_path, dirent->d_name, sizeof(file_path));
|
strncat(file_path, dirent->d_name, sizeof(file_path));
|
||||||
if ((lstat(file_path, &astats)) != 0) {
|
if ((lstat(file_path, &astats)) != 0) {
|
||||||
perror("stat");
|
dprintf("stat failed\n");
|
||||||
continue;
|
continue;
|
||||||
}
|
}
|
||||||
if (S_ISREG(astats.st_mode)) {
|
if (S_ISREG(astats.st_mode)) {
|
||||||
attr = sysfs_open_attribute(file_path);
|
attr = sysfs_open_attribute(file_path);
|
||||||
if (attr == NULL) {
|
if (attr == NULL) {
|
||||||
dprintf (stderr, "Error opening attribute %s\n",
|
dprintf("Error opening attribute %s\n",
|
||||||
file_path);
|
file_path);
|
||||||
retval = -1;
|
retval = -1;
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
if (attr->method & SYSFS_METHOD_SHOW) {
|
if (attr->method & SYSFS_METHOD_SHOW) {
|
||||||
if ((sysfs_read_attribute(attr)) != 0) {
|
if ((sysfs_read_attribute(attr)) != 0) {
|
||||||
dprintf (stderr,
|
dprintf("Error reading attribute %s\n",
|
||||||
"Error reading attribute %s\n",
|
|
||||||
file_path);
|
file_path);
|
||||||
sysfs_close_attribute(attr);
|
sysfs_close_attribute(attr);
|
||||||
continue;
|
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)) {
|
} else if (S_ISDIR(astats.st_mode)) {
|
||||||
subdir = sysfs_open_directory(file_path);
|
subdir = sysfs_open_directory(file_path);
|
||||||
if (subdir == NULL) {
|
if (subdir == NULL) {
|
||||||
dprintf (stderr, "Error opening directory %s\n",
|
dprintf("Error opening directory %s\n",
|
||||||
file_path);
|
file_path);
|
||||||
retval = -1;
|
retval = -1;
|
||||||
break;
|
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)) {
|
} else if (S_ISLNK(astats.st_mode)) {
|
||||||
dlink = sysfs_open_dlink(file_path);
|
ln = sysfs_open_link(file_path);
|
||||||
if (dlink == NULL) {
|
if (ln == NULL) {
|
||||||
dprintf(stderr, "Error opening link %s\n",
|
dprintf("Error opening link %s\n", file_path);
|
||||||
file_path);
|
|
||||||
retval = -1;
|
retval = -1;
|
||||||
break;
|
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);
|
closedir(dir);
|
||||||
|
@ -468,29 +582,123 @@ int sysfs_read_directory(struct sysfs_directory *sysdir)
|
||||||
}
|
}
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* sysfs_read_dlinks: reads a directory link's target directory. Can
|
* sysfs_get_directory_attribute: retrieves attribute attrname
|
||||||
* supply a linked list of links.
|
* @dir: directory to retrieve attribute from
|
||||||
* @dlink: directory link to read.
|
* @attrname: name of attribute to look for
|
||||||
* returns 0 with success or -1 with error.
|
* 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 (dlink == NULL || dlink->target == NULL) {
|
|
||||||
|
if (dir == NULL || attrname == NULL) {
|
||||||
errno = EINVAL;
|
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;
|
|
||||||
}
|
|
||||||
cur = cur->next;
|
|
||||||
}
|
}
|
||||||
|
|
||||||
return 0;
|
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;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* 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 NULL;
|
||||||
|
}
|
||||||
|
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;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
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;
|
||||||
}
|
}
|
||||||
|
|
|
@ -3,7 +3,7 @@
|
||||||
*
|
*
|
||||||
* Driver utility functions for libsysfs
|
* 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
|
* This library is free software; you can redistribute it and/or
|
||||||
* modify it under the terms of the GNU Lesser General Public
|
* modify it under the terms of the GNU Lesser General Public
|
||||||
|
@ -23,19 +23,46 @@
|
||||||
#include "libsysfs.h"
|
#include "libsysfs.h"
|
||||||
#include "sysfs.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
|
* sysfs_close_driver: closes and cleans up driver structure
|
||||||
|
* NOTE: This routine does not deallocate devices list
|
||||||
* @driver: driver to close
|
* @driver: driver to close
|
||||||
*/
|
*/
|
||||||
void sysfs_close_driver(struct sysfs_driver *driver)
|
void sysfs_close_driver(struct sysfs_driver *driver)
|
||||||
{
|
{
|
||||||
if (driver != NULL) {
|
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)
|
if (driver->directory != NULL)
|
||||||
sysfs_close_directory(driver->directory);
|
sysfs_close_directory(driver->directory);
|
||||||
free(driver);
|
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
|
* alloc_driver: allocates and initializes driver
|
||||||
* returns struct sysfs_driver with success and NULL with error.
|
* returns struct sysfs_driver with success and NULL with error.
|
||||||
|
@ -50,11 +77,10 @@ static struct sysfs_driver *alloc_driver(void)
|
||||||
* @path: path to driver directory
|
* @path: path to driver directory
|
||||||
* returns struct sysfs_driver with success and NULL with error
|
* 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_driver *driver = NULL;
|
||||||
struct sysfs_directory *sdir = NULL;
|
struct sysfs_directory *sdir = NULL;
|
||||||
char devname[SYSFS_NAME_LEN];
|
|
||||||
|
|
||||||
if (path == NULL) {
|
if (path == NULL) {
|
||||||
errno = EINVAL;
|
errno = EINVAL;
|
||||||
|
@ -62,28 +88,280 @@ struct sysfs_driver *sysfs_open_driver(const char *path)
|
||||||
}
|
}
|
||||||
sdir = sysfs_open_directory(path);
|
sdir = sysfs_open_directory(path);
|
||||||
if (sdir == NULL) {
|
if (sdir == NULL) {
|
||||||
dprintf (stderr, "Error opening directory %s\n", path);
|
dprintf("Error opening directory %s\n", path);
|
||||||
return NULL;
|
return NULL;
|
||||||
}
|
}
|
||||||
if ((sysfs_read_directory(sdir)) != 0) {
|
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);
|
sysfs_close_directory(sdir);
|
||||||
return NULL;
|
return NULL;
|
||||||
}
|
}
|
||||||
driver = alloc_driver();
|
driver = alloc_driver();
|
||||||
if (driver == NULL) {
|
if (driver == NULL) {
|
||||||
dprintf(stderr, "Error allocating driver at %s\n", path);
|
dprintf("Error allocating driver at %s\n", path);
|
||||||
sysfs_close_directory(sdir);
|
sysfs_close_directory(sdir);
|
||||||
return NULL;
|
return NULL;
|
||||||
}
|
}
|
||||||
if ((sysfs_get_name_from_path(path, devname, SYSFS_NAME_LEN)) != 0) {
|
strcpy(driver->name, sdir->name);
|
||||||
dprintf (stderr, "Error reading directory %s\n", path);
|
|
||||||
sysfs_close_directory(sdir);
|
|
||||||
free(driver);
|
|
||||||
return NULL;
|
|
||||||
}
|
|
||||||
strncpy(driver->name, devname, sizeof(driver->name));
|
|
||||||
driver->directory = sdir;
|
driver->directory = sdir;
|
||||||
|
strcpy(driver->path, sdir->path);
|
||||||
|
|
||||||
return driver;
|
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;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
|
@ -3,7 +3,7 @@
|
||||||
*
|
*
|
||||||
* System utility functions for libsysfs
|
* 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
|
* This library is free software; you can redistribute it and/or
|
||||||
* modify it under the terms of the GNU Lesser General Public
|
* modify it under the terms of the GNU Lesser General Public
|
||||||
|
@ -30,8 +30,8 @@
|
||||||
* @len: size of mnt_path
|
* @len: size of mnt_path
|
||||||
* returns 0 with success and -1 with error.
|
* returns 0 with success and -1 with error.
|
||||||
*/
|
*/
|
||||||
static int sysfs_get_fs_mnt_path(const char *fs_type, char *mnt_path,
|
static int sysfs_get_fs_mnt_path(const unsigned char *fs_type,
|
||||||
size_t len)
|
unsigned char *mnt_path, size_t len)
|
||||||
{
|
{
|
||||||
FILE *mnt;
|
FILE *mnt;
|
||||||
struct mntent *mntent;
|
struct mntent *mntent;
|
||||||
|
@ -45,7 +45,7 @@ static int sysfs_get_fs_mnt_path(const char *fs_type, char *mnt_path,
|
||||||
}
|
}
|
||||||
|
|
||||||
if ((mnt = setmntent(SYSFS_PROC_MNTS, "r")) == NULL) {
|
if ((mnt = setmntent(SYSFS_PROC_MNTS, "r")) == NULL) {
|
||||||
dprintf(stderr, "Error getting mount information\n");
|
dprintf("Error getting mount information\n");
|
||||||
return -1;
|
return -1;
|
||||||
}
|
}
|
||||||
while (ret == 0 && dirlen == 0 && (mntent = getmntent(mnt)) != NULL) {
|
while (ret == 0 && dirlen == 0 && (mntent = getmntent(mnt)) != NULL) {
|
||||||
|
@ -54,15 +54,14 @@ static int sysfs_get_fs_mnt_path(const char *fs_type, char *mnt_path,
|
||||||
if (dirlen <= (len - 1)) {
|
if (dirlen <= (len - 1)) {
|
||||||
strcpy(mnt_path, mntent->mnt_dir);
|
strcpy(mnt_path, mntent->mnt_dir);
|
||||||
} else {
|
} else {
|
||||||
dprintf(stderr,
|
dprintf("Error - mount path too long\n");
|
||||||
"Error - mount path too long\n");
|
|
||||||
ret = -1;
|
ret = -1;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
endmntent(mnt);
|
endmntent(mnt);
|
||||||
if (dirlen == 0 && ret == 0) {
|
if (dirlen == 0 && ret == 0) {
|
||||||
dprintf(stderr, "Filesystem %s not found!\n", fs_type);
|
dprintf("Filesystem %s not found!\n", fs_type);
|
||||||
errno = EINVAL;
|
errno = EINVAL;
|
||||||
ret = -1;
|
ret = -1;
|
||||||
}
|
}
|
||||||
|
@ -75,7 +74,7 @@ static int sysfs_get_fs_mnt_path(const char *fs_type, char *mnt_path,
|
||||||
* @len: size of mnt_path
|
* @len: size of mnt_path
|
||||||
* returns 0 with success and -1 with error.
|
* 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;
|
int ret = -1;
|
||||||
|
|
||||||
|
@ -93,9 +92,10 @@ int sysfs_get_mnt_path(char *mnt_path, size_t len)
|
||||||
* @name: where to put name
|
* @name: where to put name
|
||||||
* @len: size of 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) {
|
if (path == NULL || name == NULL) {
|
||||||
errno = EINVAL;
|
errno = EINVAL;
|
||||||
|
@ -118,11 +118,11 @@ int sysfs_get_name_from_path(const char *path, char *name, size_t len)
|
||||||
* @target: where to put name
|
* @target: where to put name
|
||||||
* @len: size of 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];
|
unsigned char devdir[SYSFS_PATH_MAX];
|
||||||
char linkpath[SYSFS_PATH_MAX];
|
unsigned char linkpath[SYSFS_PATH_MAX];
|
||||||
char *d = NULL;
|
unsigned char *d = NULL;
|
||||||
|
|
||||||
if (path == NULL || target == NULL) {
|
if (path == NULL || target == NULL) {
|
||||||
errno = EINVAL;
|
errno = EINVAL;
|
||||||
|
@ -133,7 +133,7 @@ int sysfs_get_link(const char *path, char *target, size_t len)
|
||||||
memset(linkpath, 0, SYSFS_PATH_MAX);
|
memset(linkpath, 0, SYSFS_PATH_MAX);
|
||||||
|
|
||||||
if ((sysfs_get_mnt_path(devdir, SYSFS_PATH_MAX)) != 0) {
|
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 -1;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -154,3 +154,136 @@ int sysfs_get_link(const char *path, char *target, size_t len)
|
||||||
|
|
||||||
return 0;
|
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;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
56
namedev.c
56
namedev.c
|
@ -547,7 +547,7 @@ static int get_attr(struct sysfs_class_device *class_dev, struct device_attr *at
|
||||||
|
|
||||||
attr->mode = 0;
|
attr->mode = 0;
|
||||||
if (class_dev->sysdevice) {
|
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);
|
dbg_parse("class_dev->sysdevice->bus_id = '%s'", class_dev->sysdevice->bus_id);
|
||||||
} else {
|
} else {
|
||||||
dbg_parse("class_dev->name = '%s'", class_dev->name);
|
dbg_parse("class_dev->name = '%s'", class_dev->name);
|
||||||
|
@ -557,19 +557,21 @@ static int get_attr(struct sysfs_class_device *class_dev, struct device_attr *at
|
||||||
switch (dev->type) {
|
switch (dev->type) {
|
||||||
case LABEL:
|
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'",
|
dbg_parse("LABEL: match file '%s' with value '%s'",
|
||||||
dev->sysfs_file, dev->sysfs_value);
|
dev->sysfs_file, dev->sysfs_value);
|
||||||
/* try to find the attribute in the class device directory */
|
/* try to find the attribute in the class device directory */
|
||||||
temp = sysfs_get_value_from_attributes(class_dev->directory->attributes, dev->sysfs_file);
|
tmpattr = sysfs_get_classdev_attr(class_dev, dev->sysfs_file);
|
||||||
if (temp)
|
if (tmpattr)
|
||||||
goto label_found;
|
goto label_found;
|
||||||
|
|
||||||
/* look in the class device device directory if present */
|
/* look in the class device device directory if present */
|
||||||
if (class_dev->sysdevice) {
|
if (class_dev->sysdevice) {
|
||||||
temp = sysfs_get_value_from_attributes(class_dev->sysdevice->directory->attributes, dev->sysfs_file);
|
tmpattr = sysfs_get_classdev_attr(class_dev, dev->sysfs_file);
|
||||||
if (temp)
|
if (tmpattr)
|
||||||
goto label_found;
|
goto label_found;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -577,14 +579,13 @@ static int get_attr(struct sysfs_class_device *class_dev, struct device_attr *at
|
||||||
* as block partitions don't point to the physical device. Need to fix that
|
* as block partitions don't point to the physical device. Need to fix that
|
||||||
* up in the kernel...
|
* up in the kernel...
|
||||||
*/
|
*/
|
||||||
if (strstr(class_dev->directory->path, "block")) {
|
if (strstr(class_dev->path, "block")) {
|
||||||
dbg_parse("looking at block device...");
|
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];
|
char path[SYSFS_PATH_MAX];
|
||||||
struct sysfs_class_device *class_dev_parent;
|
|
||||||
|
|
||||||
dbg_parse("really is a partition...");
|
dbg_parse("really is a partition...");
|
||||||
strcpy(path, class_dev->directory->path);
|
strcpy(path, class_dev->path);
|
||||||
temp = strrchr(path, '/');
|
temp = strrchr(path, '/');
|
||||||
*temp = 0x00;
|
*temp = 0x00;
|
||||||
dbg_parse("looking for a class device at '%s'", path);
|
dbg_parse("looking for a class device at '%s'", path);
|
||||||
|
@ -596,35 +597,36 @@ static int get_attr(struct sysfs_class_device *class_dev, struct device_attr *at
|
||||||
dbg_parse("class_dev_parent->name = %s", class_dev_parent->name);
|
dbg_parse("class_dev_parent->name = %s", class_dev_parent->name);
|
||||||
|
|
||||||
/* try to find the attribute in the class device directory */
|
/* try to find the attribute in the class device directory */
|
||||||
temp = sysfs_get_value_from_attributes(class_dev_parent->directory->attributes, dev->sysfs_file);
|
tmpattr = sysfs_get_classdev_attr(class_dev_parent, dev->sysfs_file);
|
||||||
if (temp) {
|
if (tmpattr)
|
||||||
//sysfs_close_class_device(class_dev_parent);
|
|
||||||
goto label_found;
|
goto label_found;
|
||||||
}
|
|
||||||
|
|
||||||
/* look in the class device device directory if present */
|
/* look in the class device device directory if present */
|
||||||
if (class_dev_parent->sysdevice) {
|
if (class_dev_parent->sysdevice) {
|
||||||
temp = sysfs_get_value_from_attributes(class_dev_parent->sysdevice->directory->attributes, dev->sysfs_file);
|
tmpattr = sysfs_get_classdev_attr(class_dev_parent, dev->sysfs_file);
|
||||||
if (temp) {
|
if (tmpattr)
|
||||||
// sysfs_close_class_device(class_dev_parent);
|
|
||||||
goto label_found;
|
goto label_found;
|
||||||
}
|
|
||||||
}
|
}
|
||||||
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
if (class_dev_parent)
|
||||||
|
sysfs_close_class_device(class_dev_parent);
|
||||||
|
|
||||||
continue;
|
continue;
|
||||||
|
|
||||||
label_found:
|
label_found:
|
||||||
temp[strlen(temp)-1] = 0x00;
|
tmpattr->value[strlen(tmpattr->value)-1] = 0x00;
|
||||||
dbg_parse("file '%s' found with value '%s' compare with '%s'", dev->sysfs_file, temp, dev->sysfs_value);
|
dbg_parse("file '%s' found with value '%s' compare with '%s'", dev->sysfs_file, tmpattr->value, dev->sysfs_value);
|
||||||
if (strcmp(dev->sysfs_value, temp) != 0)
|
if (strcmp(dev->sysfs_value, tmpattr->value) != 0) {
|
||||||
|
if (class_dev_parent)
|
||||||
|
sysfs_close_class_device(class_dev_parent);
|
||||||
continue;
|
continue;
|
||||||
|
}
|
||||||
|
|
||||||
strcpy(attr->name, dev->attr.name);
|
strcpy(attr->name, dev->attr.name);
|
||||||
if (isdigit(class_dev->directory->path[strlen(class_dev->directory->path)-1])) {
|
if (isdigit(class_dev->path[strlen(class_dev->path)-1])) {
|
||||||
temp[0] = class_dev->directory->path[strlen(class_dev->directory->path)-1];
|
temp = &class_dev->path[strlen(class_dev->path)-1];
|
||||||
temp[1] = 0x00;
|
|
||||||
strcat(attr->name, temp);
|
strcat(attr->name, temp);
|
||||||
}
|
}
|
||||||
if (dev->attr.mode != 0) {
|
if (dev->attr.mode != 0) {
|
||||||
|
@ -635,6 +637,8 @@ label_found:
|
||||||
dbg_parse("file '%s' with value '%s' becomes '%s' - owner = %s, group = %s, mode = %#o",
|
dbg_parse("file '%s' with value '%s' becomes '%s' - owner = %s, group = %s, mode = %#o",
|
||||||
dev->sysfs_file, dev->sysfs_value, attr->name,
|
dev->sysfs_file, dev->sysfs_value, attr->name,
|
||||||
dev->attr.owner, dev->attr.group, dev->attr.mode);
|
dev->attr.owner, dev->attr.group, dev->attr.mode);
|
||||||
|
if (class_dev_parent)
|
||||||
|
sysfs_close_class_device(class_dev_parent);
|
||||||
goto done;
|
goto done;
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
|
@ -646,7 +650,7 @@ label_found:
|
||||||
found = 0;
|
found = 0;
|
||||||
if (!class_dev->sysdevice)
|
if (!class_dev->sysdevice)
|
||||||
continue;
|
continue;
|
||||||
strcpy(path, class_dev->sysdevice->directory->path);
|
strcpy(path, class_dev->sysdevice->path);
|
||||||
temp = strrchr(path, '/');
|
temp = strrchr(path, '/');
|
||||||
dbg_parse("NUMBER path = '%s'", path);
|
dbg_parse("NUMBER path = '%s'", path);
|
||||||
dbg_parse("NUMBER temp = '%s' id = '%s'", temp, dev->id);
|
dbg_parse("NUMBER temp = '%s' id = '%s'", temp, dev->id);
|
||||||
|
@ -682,7 +686,7 @@ label_found:
|
||||||
if (!class_dev->sysdevice)
|
if (!class_dev->sysdevice)
|
||||||
continue;
|
continue;
|
||||||
found = 0;
|
found = 0;
|
||||||
strcpy(path, class_dev->sysdevice->directory->path);
|
strcpy(path, class_dev->sysdevice->path);
|
||||||
temp = strrchr(path, '/');
|
temp = strrchr(path, '/');
|
||||||
dbg_parse("TOPOLOGY path = '%s'", path);
|
dbg_parse("TOPOLOGY path = '%s'", path);
|
||||||
dbg_parse("TOPOLOGY temp = '%s' place = '%s'", temp, dev->place);
|
dbg_parse("TOPOLOGY temp = '%s' place = '%s'", temp, dev->place);
|
||||||
|
|
Loading…
Reference in New Issue