/*
* Copyright (c) 2010 Lenka Trochtova
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* - Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* - Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* - The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/** @addtogroup devman
* @{
*/
#include <errno.h>
#include <io/log.h>
#include <loc.h>
#include "dev.h"
#include "devman.h"
#include "devtree.h"
#include "driver.h"
#include "fun.h"
#include "main.h"
#include "loc.h"
static fun_node_t *find_node_child(dev_tree_t *, fun_node_t *, const char *);
/* Function nodes */
/** Create a new function node.
*
* @return A function node structure.
*/
fun_node_t *create_fun_node(void)
{
fun_node_t *fun;
fun = calloc(1, sizeof(fun_node_t));
if (fun == NULL)
return NULL;
fun->state = FUN_INIT;
refcount_init(&fun->refcnt);
fibril_mutex_initialize(&fun->busy_lock);
link_initialize(&fun->dev_functions);
list_initialize(&fun->match_ids.ids);
return fun;
}
/** Delete a function node.
*
* @param fun The device node structure.
*/
void delete_fun_node(fun_node_t *fun)
{
assert(fun->dev == NULL);
assert(fun->child == NULL);
clean_match_ids(&fun->match_ids);
free(fun->name);
free(fun->pathname);
free(fun);
}
/** Increase function node reference count.
*
* @param fun Function node
*/
void fun_add_ref(fun_node_t *fun)
{
refcount_up(&fun->refcnt);
}
/** Decrease function node reference count.
*
* When the count drops to zero the function node is freed.
*
* @param fun Function node
*/
void fun_del_ref(fun_node_t *fun)
{
if (refcount_down(&fun->refcnt))
delete_fun_node(fun);
}
/** Make function busy for reconfiguration operations. */
void fun_busy_lock(fun_node_t *fun)
{
fibril_mutex_lock(&fun->busy_lock);
}
/** Mark end of reconfiguration operation. */
void fun_busy_unlock(fun_node_t *fun)
{
fibril_mutex_unlock(&fun->busy_lock);
}
/** Find the function node with the specified handle.
*
* @param tree The device tree where we look for the device node.
* @param handle The handle of the function.
* @return The function node.
*/
fun_node_t *find_fun_node_no_lock(dev_tree_t *tree, devman_handle_t handle)
{
fun_node_t *fun;
assert(fibril_rwlock_is_locked(&tree->rwlock));
ht_link_t *link = hash_table_find(&tree->devman_functions, &handle);
if (link == NULL)
return NULL;
fun = hash_table_get_inst(link, fun_node_t, devman_fun);
return fun;
}
/** Find the function node with the specified handle.
*
* @param tree The device tree where we look for the device node.
* @param handle The handle of the function.
* @return The function node.
*/
fun_node_t *find_fun_node(dev_tree_t *tree, devman_handle_t handle)
{
fun_node_t *fun = NULL;
fibril_rwlock_read_lock(&tree->rwlock);
fun = find_fun_node_no_lock(tree, handle);
if (fun != NULL)
fun_add_ref(fun);
fibril_rwlock_read_unlock(&tree->rwlock);
return fun;
}
/** Create and set device's full path in device tree.
*
* @param tree Device tree
* @param node The device's device node.
* @param parent The parent device node.
* @return True on success, false otherwise (insufficient
* resources etc.).
*/
bool set_fun_path(dev_tree_t *tree, fun_node_t *fun, fun_node_t *parent)
{
assert(fibril_rwlock_is_write_locked(&tree->rwlock));
assert(fun->name != NULL);
size_t pathsize = (str_size(fun->name) + 1);
if (parent != NULL)
pathsize += str_size(parent->pathname) + 1;
fun->pathname = (char *) malloc(pathsize);
if (fun->pathname == NULL) {
log_msg(LOG_DEFAULT, LVL_ERROR, "Failed to allocate device path.");
return false;
}
if (parent != NULL) {
str_cpy(fun->pathname, pathsize, parent->pathname);
str_append(fun->pathname, pathsize, "/");
str_append(fun->pathname, pathsize, fun->name);
} else {
str_cpy(fun->pathname, pathsize, fun->name);
}
return true;
}
/** Find function node with a specified path in the device tree.
*
* @param path The path of the function node in the device tree.
* @param tree The device tree.
* @return The function node if it is present in the tree, NULL
* otherwise.
*/
fun_node_t *find_fun_node_by_path(dev_tree_t *tree, char *path)
{
assert(path != NULL);
bool is_absolute = path[0] == '/';
if (!is_absolute) {
return NULL;
}
fibril_rwlock_read_lock(&tree->rwlock);
fun_node_t *fun = tree->root_node;
fun_add_ref(fun);
/*
* Relative path to the function from its parent (but with '/' at the
* beginning)
*/
char *rel_path = path;
char *next_path_elem = NULL;
bool cont = (rel_path[1] != '\0');
while (cont && fun != NULL) {
next_path_elem = get_path_elem_end(rel_path + 1);
if (next_path_elem[0] == '/') {
cont = true;
next_path_elem[0] = 0;
} else {
cont = false;
}
fun_node_t *cfun = find_node_child(tree, fun, rel_path + 1);
fun_del_ref(fun);
fun = cfun;
if (cont) {
/* Restore the original path. */
next_path_elem[0] = '/';
}
rel_path = next_path_elem;
}
fibril_rwlock_read_unlock(&tree->rwlock);
return fun;
}
/** Find function with a specified name belonging to given device.
*
* Device tree rwlock should be held at least for reading.
*
* @param tree Device tree
* @param dev Device the function belongs to.
* @param name Function name (not path).
* @return Function node.
* @retval NULL No function with given name.
*/
fun_node_t *find_fun_node_in_device(dev_tree_t *tree, dev_node_t *dev,
const char *name)
{
assert(name != NULL);
assert(fibril_rwlock_is_locked(&tree->rwlock));
list_foreach(dev->functions, dev_functions, fun_node_t, fun) {
if (str_cmp(name, fun->name) == 0) {
fun_add_ref(fun);
return fun;
}
}
return NULL;
}
/** Find child function node with a specified name.
*
* Device tree rwlock should be held at least for reading.
*
* @param tree Device tree
* @param parent The parent function node.
* @param name The name of the child function.
* @return The child function node.
*/
static fun_node_t *find_node_child(dev_tree_t *tree, fun_node_t *pfun,
const char *name)
{
return find_fun_node_in_device(tree, pfun->child, name);
}
static errno_t assign_driver_fibril(void *arg)
{
dev_node_t *dev_node = (dev_node_t *) arg;
assign_driver(dev_node, &drivers_list, &device_tree);
/* Delete one reference we got from the caller. */
dev_del_ref(dev_node);
return EOK;
}
errno_t fun_online(fun_node_t *fun)
{
dev_node_t *dev;
fibril_rwlock_write_lock(&device_tree.rwlock);
if (fun->state == FUN_ON_LINE) {
fibril_rwlock_write_unlock(&device_tree.rwlock);
log_msg(LOG_DEFAULT, LVL_WARN, "Function %s is already on line.",
fun->pathname);
return EOK;
}
if (fun->ftype == fun_inner) {
dev = create_dev_node();
if (dev == NULL) {
fibril_rwlock_write_unlock(&device_tree.rwlock);
return ENOMEM;
}
insert_dev_node(&device_tree, dev, fun);
}
log_msg(LOG_DEFAULT, LVL_DEBUG, "devman_add_function(fun=\"%s\")", fun->pathname);
if (fun->ftype == fun_inner) {
dev = fun->child;
assert(dev != NULL);
/* Give one reference over to assign_driver_fibril(). */
dev_add_ref(dev);
/*
* Try to find a suitable driver and assign it to the device. We do
* not want to block the current fibril that is used for processing
* incoming calls: we will launch a separate fibril to handle the
* driver assigning. That is because assign_driver can actually include
* task spawning which could take some time.
*/
fid_t assign_fibril = fibril_create(assign_driver_fibril, dev);
if (assign_fibril == 0) {
log_msg(LOG_DEFAULT, LVL_ERROR, "Failed to create fibril for "
"assigning driver.");
/* XXX Cleanup */
fibril_rwlock_write_unlock(&device_tree.rwlock);
return ENOMEM;
}
fibril_add_ready(assign_fibril);
} else
loc_register_tree_function(fun, &device_tree);
fun->state = FUN_ON_LINE;
fibril_rwlock_write_unlock(&device_tree.rwlock);
return EOK;
}
errno_t fun_offline(fun_node_t *fun)
{
errno_t rc;
fibril_rwlock_write_lock(&device_tree.rwlock);
if (fun->state == FUN_OFF_LINE) {
fibril_rwlock_write_unlock(&device_tree.rwlock);
log_msg(LOG_DEFAULT, LVL_WARN, "Function %s is already off line.",
fun->pathname);
return EOK;
}
if (fun->ftype == fun_inner) {
log_msg(LOG_DEFAULT, LVL_DEBUG, "Offlining inner function %s.",
fun->pathname);
if (fun->child != NULL) {
dev_node_t *dev = fun->child;
device_state_t dev_state;
dev_add_ref(dev);
dev_state = dev->state;
fibril_rwlock_write_unlock(&device_tree.rwlock);
/* If device is owned by driver, ask driver to give it up. */
if (dev_state == DEVICE_USABLE) {
rc = driver_dev_remove(&device_tree, dev);
if (rc != EOK) {
dev_del_ref(dev);
return ENOTSUP;
}
}
/* Verify that driver removed all functions */
fibril_rwlock_read_lock(&device_tree.rwlock);
if (!list_empty(&dev->functions)) {
fibril_rwlock_read_unlock(&device_tree.rwlock);
dev_del_ref(dev);
return EIO;
}
driver_t *driver = dev->drv;
fibril_rwlock_read_unlock(&device_tree.rwlock);
if (driver)
detach_driver(&device_tree, dev);
fibril_rwlock_write_lock(&device_tree.rwlock);
remove_dev_node(&device_tree, dev);
/* Delete ref created when node was inserted */
dev_del_ref(dev);
/* Delete ref created by dev_add_ref(dev) above */
dev_del_ref(dev);
}
} else {
/* Unregister from location service */
rc = loc_unregister_tree_function(fun, &device_tree);
if (rc != EOK) {
fibril_rwlock_write_unlock(&device_tree.rwlock);
log_msg(LOG_DEFAULT, LVL_ERROR, "Failed unregistering tree service.");
return EIO;
}
fun->service_id = 0;
}
fun->state = FUN_OFF_LINE;
fibril_rwlock_write_unlock(&device_tree.rwlock);
return EOK;
}
/** @}
*/