|
|
@@ -1,6265 +0,0 @@
|
|
|
-diff -urN linux-2.6.22.1-0rig/drivers/char/fusion/call.c linux-2.6.22.1/drivers/char/fusion/call.c
|
|
|
---- linux-2.6.22.1-0rig/drivers/char/fusion/call.c 1970-01-01 01:00:00.000000000 +0100
|
|
|
-+++ linux-2.6.22.1/drivers/char/fusion/call.c 2007-01-20 05:03:01.000000000 +0100
|
|
|
-@@ -0,0 +1,478 @@
|
|
|
-+/*
|
|
|
-+ * Fusion Kernel Module
|
|
|
-+ *
|
|
|
-+ * (c) Copyright 2002-2003 Convergence GmbH
|
|
|
-+ *
|
|
|
-+ * Written by Denis Oliver Kropp <dok@directfb.org>
|
|
|
-+ *
|
|
|
-+ *
|
|
|
-+ * This program is free software; you can redistribute it and/or
|
|
|
-+ * modify it under the terms of the GNU General Public License
|
|
|
-+ * as published by the Free Software Foundation; either version
|
|
|
-+ * 2 of the License, or (at your option) any later version.
|
|
|
-+ */
|
|
|
-+
|
|
|
-+#ifdef HAVE_LINUX_CONFIG_H
|
|
|
-+#include <linux/config.h>
|
|
|
-+#endif
|
|
|
-+#include <linux/types.h>
|
|
|
-+#include <linux/kernel.h>
|
|
|
-+#include <linux/slab.h>
|
|
|
-+#include <linux/smp_lock.h>
|
|
|
-+#include <linux/sched.h>
|
|
|
-+
|
|
|
-+#include <linux/fusion.h>
|
|
|
-+
|
|
|
-+#include "fusiondev.h"
|
|
|
-+#include "fusionee.h"
|
|
|
-+#include "list.h"
|
|
|
-+#include "call.h"
|
|
|
-+
|
|
|
-+typedef struct {
|
|
|
-+ FusionLink link;
|
|
|
-+
|
|
|
-+ Fusionee *caller;
|
|
|
-+
|
|
|
-+ int ret_val;
|
|
|
-+
|
|
|
-+ bool executed;
|
|
|
-+
|
|
|
-+ wait_queue_head_t wait;
|
|
|
-+} FusionCallExecution;
|
|
|
-+
|
|
|
-+typedef struct {
|
|
|
-+ FusionLink link;
|
|
|
-+
|
|
|
-+ struct semaphore lock;
|
|
|
-+
|
|
|
-+ int id; /* call id */
|
|
|
-+
|
|
|
-+ int pid; /* owner pid */
|
|
|
-+ int fusion_id; /* owner fusion id */
|
|
|
-+
|
|
|
-+ void *handler;
|
|
|
-+ void *ctx;
|
|
|
-+
|
|
|
-+ FusionLink *executions; /* prepending! */
|
|
|
-+ FusionLink *last; /* points to the last item of executions */
|
|
|
-+
|
|
|
-+ int count; /* number of calls ever made */
|
|
|
-+} FusionCall;
|
|
|
-+
|
|
|
-+/******************************************************************************/
|
|
|
-+
|
|
|
-+static int lookup_call (FusionDev *dev, int id, FusionCall **ret_call);
|
|
|
-+static int lock_call (FusionDev *dev, int id, FusionCall **ret_call);
|
|
|
-+static void unlock_call (FusionCall *call);
|
|
|
-+
|
|
|
-+static FusionCallExecution *add_execution (FusionCall *call,
|
|
|
-+ Fusionee *caller,
|
|
|
-+ FusionCallExecute *execute);
|
|
|
-+static void remove_execution (FusionCall *call,
|
|
|
-+ FusionCallExecution *execution);
|
|
|
-+static void free_all_executions (FusionCall *call);
|
|
|
-+
|
|
|
-+/******************************************************************************/
|
|
|
-+
|
|
|
-+static int
|
|
|
-+fusion_call_read_proc (char *buf, char **start, off_t offset,
|
|
|
-+ int len, int *eof, void *private)
|
|
|
-+{
|
|
|
-+ FusionLink *l, *e;
|
|
|
-+ FusionDev *dev = private;
|
|
|
-+ int written = 0;
|
|
|
-+
|
|
|
-+ if (down_interruptible (&dev->call.lock))
|
|
|
-+ return -EINTR;
|
|
|
-+
|
|
|
-+ fusion_list_foreach (l, dev->call.list) {
|
|
|
-+ bool idle = true;
|
|
|
-+ FusionCall *call = (FusionCall*) l;
|
|
|
-+
|
|
|
-+ if (call->executions)
|
|
|
-+ idle = ((FusionCallExecution*) call->executions)->executed;
|
|
|
-+
|
|
|
-+ written += sprintf(buf+written,
|
|
|
-+ "(%5d) 0x%08x (%d calls) %s",
|
|
|
-+ call->pid, call->id, call->count,
|
|
|
-+ idle ? "idle" : "executing");
|
|
|
-+
|
|
|
-+ fusion_list_foreach (e, call->executions) {
|
|
|
-+ FusionCallExecution *exec = (FusionCallExecution *) e;
|
|
|
-+
|
|
|
-+ written += sprintf(buf+written, " [0x%08lx]", exec->caller ? fusionee_id( exec->caller ) : 0);
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ written += sprintf(buf+written, "\n");
|
|
|
-+
|
|
|
-+ if (written < offset) {
|
|
|
-+ offset -= written;
|
|
|
-+ written = 0;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ if (written >= len)
|
|
|
-+ break;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ up (&dev->call.lock);
|
|
|
-+
|
|
|
-+ *start = buf + offset;
|
|
|
-+ written -= offset;
|
|
|
-+ if (written > len) {
|
|
|
-+ *eof = 0;
|
|
|
-+ return len;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ *eof = 1;
|
|
|
-+ return(written<0) ? 0 : written;
|
|
|
-+}
|
|
|
-+
|
|
|
-+int
|
|
|
-+fusion_call_init (FusionDev *dev)
|
|
|
-+{
|
|
|
-+ create_proc_read_entry("calls", 0, dev->proc_dir,
|
|
|
-+ fusion_call_read_proc, dev);
|
|
|
-+
|
|
|
-+ init_MUTEX(&dev->call.lock);
|
|
|
-+
|
|
|
-+ return 0;
|
|
|
-+}
|
|
|
-+
|
|
|
-+void
|
|
|
-+fusion_call_deinit (FusionDev *dev)
|
|
|
-+{
|
|
|
-+ FusionLink *l;
|
|
|
-+
|
|
|
-+ down (&dev->call.lock);
|
|
|
-+
|
|
|
-+ remove_proc_entry ("calls", dev->proc_dir);
|
|
|
-+
|
|
|
-+ l = dev->call.list;
|
|
|
-+ while (l) {
|
|
|
-+ FusionLink *next = l->next;
|
|
|
-+ FusionCall *call = (FusionCall *) l;
|
|
|
-+
|
|
|
-+ free_all_executions (call);
|
|
|
-+
|
|
|
-+ kfree (call);
|
|
|
-+
|
|
|
-+ l = next;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ up (&dev->call.lock);
|
|
|
-+}
|
|
|
-+
|
|
|
-+/******************************************************************************/
|
|
|
-+
|
|
|
-+int
|
|
|
-+fusion_call_new (FusionDev *dev, int fusion_id, FusionCallNew *call_new)
|
|
|
-+{
|
|
|
-+ FusionCall *call;
|
|
|
-+
|
|
|
-+ call = kmalloc (sizeof(FusionCall), GFP_KERNEL);
|
|
|
-+ if (!call)
|
|
|
-+ return -ENOMEM;
|
|
|
-+
|
|
|
-+ memset (call, 0, sizeof(FusionCall));
|
|
|
-+
|
|
|
-+ if (down_interruptible (&dev->call.lock)) {
|
|
|
-+ kfree (call);
|
|
|
-+ return -EINTR;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ call->id = dev->call.ids++;
|
|
|
-+ call->pid = current->pid;
|
|
|
-+ call->fusion_id = fusion_id;
|
|
|
-+ call->handler = call_new->handler;
|
|
|
-+ call->ctx = call_new->ctx;
|
|
|
-+
|
|
|
-+ init_MUTEX (&call->lock);
|
|
|
-+
|
|
|
-+ fusion_list_prepend (&dev->call.list, &call->link);
|
|
|
-+
|
|
|
-+ up (&dev->call.lock);
|
|
|
-+
|
|
|
-+ call_new->call_id = call->id;
|
|
|
-+
|
|
|
-+ return 0;
|
|
|
-+}
|
|
|
-+
|
|
|
-+int
|
|
|
-+fusion_call_execute (FusionDev *dev, Fusionee *fusionee, FusionCallExecute *execute)
|
|
|
-+{
|
|
|
-+ int ret;
|
|
|
-+ FusionCall *call;
|
|
|
-+ FusionCallExecution *execution;
|
|
|
-+ FusionCallMessage message;
|
|
|
-+
|
|
|
-+ ret = lock_call (dev, execute->call_id, &call);
|
|
|
-+ if (ret)
|
|
|
-+ return ret;
|
|
|
-+
|
|
|
-+ execution = add_execution (call, fusionee, execute);
|
|
|
-+ if (!execution) {
|
|
|
-+ unlock_call (call);
|
|
|
-+ return -ENOMEM;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ /* Send call message. */
|
|
|
-+ message.handler = call->handler;
|
|
|
-+ message.ctx = call->ctx;
|
|
|
-+
|
|
|
-+ message.caller = fusionee ? fusionee_id( fusionee ) : 0;
|
|
|
-+
|
|
|
-+ message.call_arg = execute->call_arg;
|
|
|
-+ message.call_ptr = execute->call_ptr;
|
|
|
-+
|
|
|
-+ ret = fusionee_send_message (dev, fusionee, call->fusion_id, FMT_CALL,
|
|
|
-+ call->id, sizeof(message), &message);
|
|
|
-+ if (ret) {
|
|
|
-+ remove_execution (call, execution);
|
|
|
-+ kfree (execution);
|
|
|
-+ unlock_call (call);
|
|
|
-+ return ret;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ call->count++;
|
|
|
-+
|
|
|
-+ if (fusionee && !(execute->flags & FCEF_ONEWAY)) {
|
|
|
-+ /* TODO: implement timeout */
|
|
|
-+ fusion_sleep_on (&execution->wait, &call->lock, 0);
|
|
|
-+
|
|
|
-+ ret = lock_call (dev, execute->call_id, &call);
|
|
|
-+ if (ret)
|
|
|
-+ return ret == -EINVAL ? -EIDRM : ret;
|
|
|
-+
|
|
|
-+ if (signal_pending(current)) {
|
|
|
-+ execution->caller = 0;
|
|
|
-+ unlock_call (call);
|
|
|
-+ return -EINTR;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ execute->ret_val = execution->ret_val;
|
|
|
-+
|
|
|
-+ remove_execution (call, execution);
|
|
|
-+
|
|
|
-+ kfree (execution);
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ unlock_call (call);
|
|
|
-+
|
|
|
-+ return 0;
|
|
|
-+}
|
|
|
-+
|
|
|
-+int
|
|
|
-+fusion_call_return (FusionDev *dev, int fusion_id, FusionCallReturn *call_ret)
|
|
|
-+{
|
|
|
-+ int ret;
|
|
|
-+ FusionLink *l;
|
|
|
-+ FusionCall *call;
|
|
|
-+
|
|
|
-+ ret = lock_call (dev, call_ret->call_id, &call);
|
|
|
-+ if (ret)
|
|
|
-+ return ret;
|
|
|
-+
|
|
|
-+ l = call->last;
|
|
|
-+ while (l) {
|
|
|
-+ FusionCallExecution *execution = (FusionCallExecution*) l;
|
|
|
-+
|
|
|
-+ if (execution->executed) {
|
|
|
-+ l = l->prev;
|
|
|
-+ continue;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ if (execution->caller) {
|
|
|
-+ execution->ret_val = call_ret->val;
|
|
|
-+ execution->executed = true;
|
|
|
-+
|
|
|
-+ wake_up_interruptible_all (&execution->wait);
|
|
|
-+ }
|
|
|
-+ else {
|
|
|
-+ remove_execution (call, execution);
|
|
|
-+
|
|
|
-+ kfree (execution);
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ unlock_call (call);
|
|
|
-+
|
|
|
-+ return 0;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ unlock_call (call);
|
|
|
-+
|
|
|
-+ return -EIO;
|
|
|
-+}
|
|
|
-+
|
|
|
-+int
|
|
|
-+fusion_call_destroy (FusionDev *dev, int fusion_id, int call_id)
|
|
|
-+{
|
|
|
-+ int ret;
|
|
|
-+ FusionCall *call;
|
|
|
-+
|
|
|
-+ ret = lookup_call (dev, call_id, &call);
|
|
|
-+ if (ret)
|
|
|
-+ return ret;
|
|
|
-+
|
|
|
-+ if (call->fusion_id != fusion_id) {
|
|
|
-+ up (&dev->call.lock);
|
|
|
-+ return -EIO;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ if (down_interruptible (&call->lock)) {
|
|
|
-+ up (&dev->call.lock);
|
|
|
-+ return -EINTR;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ fusion_list_remove (&dev->call.list, &call->link);
|
|
|
-+
|
|
|
-+ free_all_executions (call);
|
|
|
-+
|
|
|
-+ up (&dev->call.lock);
|
|
|
-+
|
|
|
-+ up (&call->lock);
|
|
|
-+
|
|
|
-+ kfree (call);
|
|
|
-+
|
|
|
-+ return 0;
|
|
|
-+}
|
|
|
-+
|
|
|
-+void
|
|
|
-+fusion_call_destroy_all (FusionDev *dev, int fusion_id)
|
|
|
-+{
|
|
|
-+ FusionLink *l;
|
|
|
-+
|
|
|
-+ down (&dev->call.lock);
|
|
|
-+
|
|
|
-+ l = dev->call.list;
|
|
|
-+
|
|
|
-+ while (l) {
|
|
|
-+ FusionLink *next = l->next;
|
|
|
-+ FusionCall *call = (FusionCall *) l;
|
|
|
-+
|
|
|
-+ down (&call->lock);
|
|
|
-+
|
|
|
-+ if (call->fusion_id == fusion_id) {
|
|
|
-+ free_all_executions (call);
|
|
|
-+
|
|
|
-+ fusion_list_remove (&dev->call.list, &call->link);
|
|
|
-+
|
|
|
-+ up (&call->lock);
|
|
|
-+
|
|
|
-+ kfree (call);
|
|
|
-+ }
|
|
|
-+ else
|
|
|
-+ up (&call->lock);
|
|
|
-+
|
|
|
-+ l = next;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ up (&dev->call.lock);
|
|
|
-+}
|
|
|
-+
|
|
|
-+/******************************************************************************/
|
|
|
-+
|
|
|
-+static int
|
|
|
-+lookup_call (FusionDev *dev, int id, FusionCall **ret_call)
|
|
|
-+{
|
|
|
-+ FusionLink *l;
|
|
|
-+
|
|
|
-+ if (down_interruptible (&dev->call.lock))
|
|
|
-+ return -EINTR;
|
|
|
-+
|
|
|
-+ fusion_list_foreach (l, dev->call.list) {
|
|
|
-+ FusionCall *call = (FusionCall *) l;
|
|
|
-+
|
|
|
-+ if (call->id == id) {
|
|
|
-+ *ret_call = call;
|
|
|
-+ return 0;
|
|
|
-+ }
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ up (&dev->call.lock);
|
|
|
-+
|
|
|
-+ return -EINVAL;
|
|
|
-+}
|
|
|
-+
|
|
|
-+static int
|
|
|
-+lock_call (FusionDev *dev, int id, FusionCall **ret_call)
|
|
|
-+{
|
|
|
-+ int ret;
|
|
|
-+ FusionCall *call;
|
|
|
-+
|
|
|
-+ ret = lookup_call (dev, id, &call);
|
|
|
-+ if (ret)
|
|
|
-+ return ret;
|
|
|
-+
|
|
|
-+ if (call) {
|
|
|
-+ fusion_list_move_to_front (&dev->call.list, &call->link);
|
|
|
-+
|
|
|
-+ if (down_interruptible (&call->lock)) {
|
|
|
-+ up (&dev->call.lock);
|
|
|
-+ return -EINTR;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ up (&dev->call.lock);
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ *ret_call = call;
|
|
|
-+
|
|
|
-+ return 0;
|
|
|
-+}
|
|
|
-+
|
|
|
-+static void
|
|
|
-+unlock_call (FusionCall *call)
|
|
|
-+{
|
|
|
-+ up (&call->lock);
|
|
|
-+}
|
|
|
-+
|
|
|
-+static FusionCallExecution *
|
|
|
-+add_execution (FusionCall *call,
|
|
|
-+ Fusionee *caller,
|
|
|
-+ FusionCallExecute *execute)
|
|
|
-+{
|
|
|
-+ FusionCallExecution *execution;
|
|
|
-+
|
|
|
-+ /* Allocate execution. */
|
|
|
-+ execution = kmalloc (sizeof(FusionCallExecution), GFP_KERNEL);
|
|
|
-+ if (!execution)
|
|
|
-+ return NULL;
|
|
|
-+
|
|
|
-+ /* Initialize execution. */
|
|
|
-+ memset (execution, 0, sizeof(FusionCallExecution));
|
|
|
-+
|
|
|
-+ execution->caller = caller;
|
|
|
-+
|
|
|
-+ init_waitqueue_head (&execution->wait);
|
|
|
-+
|
|
|
-+ /* Add execution. */
|
|
|
-+ fusion_list_prepend (&call->executions, &execution->link);
|
|
|
-+
|
|
|
-+ if (!call->last)
|
|
|
-+ call->last = &execution->link;
|
|
|
-+
|
|
|
-+ return execution;
|
|
|
-+}
|
|
|
-+
|
|
|
-+static void
|
|
|
-+remove_execution (FusionCall *call,
|
|
|
-+ FusionCallExecution *execution)
|
|
|
-+{
|
|
|
-+ if (call->last == &execution->link)
|
|
|
-+ call->last = execution->link.prev;
|
|
|
-+
|
|
|
-+ fusion_list_remove (&call->executions, &execution->link);
|
|
|
-+}
|
|
|
-+
|
|
|
-+static void
|
|
|
-+free_all_executions (FusionCall *call)
|
|
|
-+{
|
|
|
-+ while (call->last) {
|
|
|
-+ FusionCallExecution *execution = (FusionCallExecution *) call->last;
|
|
|
-+
|
|
|
-+ remove_execution (call, execution);
|
|
|
-+
|
|
|
-+ wake_up_interruptible_all (&execution->wait);
|
|
|
-+
|
|
|
-+ kfree (execution);
|
|
|
-+ }
|
|
|
-+}
|
|
|
-diff -urN linux-2.6.22.1-0rig/drivers/char/fusion/call.h linux-2.6.22.1/drivers/char/fusion/call.h
|
|
|
---- linux-2.6.22.1-0rig/drivers/char/fusion/call.h 1970-01-01 01:00:00.000000000 +0100
|
|
|
-+++ linux-2.6.22.1/drivers/char/fusion/call.h 2007-01-20 05:03:01.000000000 +0100
|
|
|
-@@ -0,0 +1,52 @@
|
|
|
-+/*
|
|
|
-+ * Fusion Kernel Module
|
|
|
-+ *
|
|
|
-+ * (c) Copyright 2002-2003 Convergence GmbH
|
|
|
-+ *
|
|
|
-+ * Written by Denis Oliver Kropp <dok@directfb.org>
|
|
|
-+ *
|
|
|
-+ *
|
|
|
-+ * This program is free software; you can redistribute it and/or
|
|
|
-+ * modify it under the terms of the GNU General Public License
|
|
|
-+ * as published by the Free Software Foundation; either version
|
|
|
-+ * 2 of the License, or (at your option) any later version.
|
|
|
-+ */
|
|
|
-+
|
|
|
-+#ifndef __FUSION__CALL_H__
|
|
|
-+#define __FUSION__CALL_H__
|
|
|
-+
|
|
|
-+#include <linux/fusion.h>
|
|
|
-+
|
|
|
-+#include "fusiondev.h"
|
|
|
-+
|
|
|
-+/* module init/cleanup */
|
|
|
-+
|
|
|
-+int fusion_call_init (FusionDev *dev);
|
|
|
-+void fusion_call_deinit (FusionDev *dev);
|
|
|
-+
|
|
|
-+
|
|
|
-+/* public API */
|
|
|
-+
|
|
|
-+int fusion_call_new (FusionDev *dev,
|
|
|
-+ int fusion_id,
|
|
|
-+ FusionCallNew *call);
|
|
|
-+
|
|
|
-+int fusion_call_execute (FusionDev *dev,
|
|
|
-+ Fusionee *fusionee, /* NULL if call is from kernel */
|
|
|
-+ FusionCallExecute *execute);
|
|
|
-+
|
|
|
-+int fusion_call_return (FusionDev *dev,
|
|
|
-+ int fusion_id,
|
|
|
-+ FusionCallReturn *call_ret);
|
|
|
-+
|
|
|
-+int fusion_call_destroy (FusionDev *dev,
|
|
|
-+ int fusion_id,
|
|
|
-+ int call_id);
|
|
|
-+
|
|
|
-+
|
|
|
-+/* internal functions */
|
|
|
-+
|
|
|
-+void fusion_call_destroy_all (FusionDev *dev,
|
|
|
-+ int fusion_id);
|
|
|
-+
|
|
|
-+#endif
|
|
|
-diff -urN linux-2.6.22.1-0rig/drivers/char/fusion/.cvsignore linux-2.6.22.1/drivers/char/fusion/.cvsignore
|
|
|
---- linux-2.6.22.1-0rig/drivers/char/fusion/.cvsignore 1970-01-01 01:00:00.000000000 +0100
|
|
|
-+++ linux-2.6.22.1/drivers/char/fusion/.cvsignore 2005-10-29 07:11:10.000000000 +0200
|
|
|
-@@ -0,0 +1,6 @@
|
|
|
-+*.o.flags
|
|
|
-+*.cmd
|
|
|
-+Makefile
|
|
|
-+fusion.ko
|
|
|
-+fusion.mod.c
|
|
|
-+.tmp_versions
|
|
|
-diff -urN linux-2.6.22.1-0rig/drivers/char/fusion/entries.c linux-2.6.22.1/drivers/char/fusion/entries.c
|
|
|
---- linux-2.6.22.1-0rig/drivers/char/fusion/entries.c 1970-01-01 01:00:00.000000000 +0100
|
|
|
-+++ linux-2.6.22.1/drivers/char/fusion/entries.c 2007-03-08 14:02:04.000000000 +0100
|
|
|
-@@ -0,0 +1,438 @@
|
|
|
-+/*
|
|
|
-+ * Fusion Kernel Module
|
|
|
-+ *
|
|
|
-+ * (c) Copyright 2002-2003 Convergence GmbH
|
|
|
-+ *
|
|
|
-+ * Written by Denis Oliver Kropp <dok@directfb.org>
|
|
|
-+ *
|
|
|
-+ *
|
|
|
-+ * This program is free software; you can redistribute it and/or
|
|
|
-+ * modify it under the terms of the GNU General Public License
|
|
|
-+ * as published by the Free Software Foundation; either version
|
|
|
-+ * 2 of the License, or (at your option) any later version.
|
|
|
-+ */
|
|
|
-+
|
|
|
-+#ifdef HAVE_LINUX_CONFIG_H
|
|
|
-+#include <linux/config.h>
|
|
|
-+#endif
|
|
|
-+#include <linux/types.h>
|
|
|
-+#include <linux/kernel.h>
|
|
|
-+#include <linux/slab.h>
|
|
|
-+#include <linux/smp_lock.h>
|
|
|
-+#include <linux/sched.h>
|
|
|
-+#include <linux/time.h>
|
|
|
-+#include <linux/version.h>
|
|
|
-+
|
|
|
-+#include <linux/fusion.h>
|
|
|
-+
|
|
|
-+#include "fusiondev.h"
|
|
|
-+#include "entries.h"
|
|
|
-+
|
|
|
-+
|
|
|
-+void
|
|
|
-+fusion_entries_init( FusionEntries *entries,
|
|
|
-+ FusionEntryClass *class,
|
|
|
-+ void *ctx )
|
|
|
-+{
|
|
|
-+ FUSION_ASSERT( entries != NULL );
|
|
|
-+ FUSION_ASSERT( class != NULL );
|
|
|
-+ FUSION_ASSERT( class->object_size >= sizeof(FusionEntry) );
|
|
|
-+
|
|
|
-+ memset( entries, 0, sizeof(FusionEntries) );
|
|
|
-+
|
|
|
-+ entries->class = class;
|
|
|
-+ entries->ctx = ctx;
|
|
|
-+
|
|
|
-+ init_MUTEX( &entries->lock );
|
|
|
-+}
|
|
|
-+
|
|
|
-+void
|
|
|
-+fusion_entries_deinit( FusionEntries *entries )
|
|
|
-+{
|
|
|
-+ FusionLink *tmp;
|
|
|
-+ FusionEntry *entry;
|
|
|
-+ FusionEntryClass *class;
|
|
|
-+
|
|
|
-+ FUSION_ASSERT( entries != NULL );
|
|
|
-+ FUSION_ASSERT( entries->class != NULL );
|
|
|
-+
|
|
|
-+ class = entries->class;
|
|
|
-+
|
|
|
-+ down( &entries->lock );
|
|
|
-+
|
|
|
-+ fusion_list_foreach_safe (entry, tmp, entries->list) {
|
|
|
-+ if (class->Destroy)
|
|
|
-+ class->Destroy( entry, entries->ctx );
|
|
|
-+
|
|
|
-+ kfree( entry );
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ up( &entries->lock );
|
|
|
-+}
|
|
|
-+
|
|
|
-+int
|
|
|
-+fusion_entries_read_proc(char *buf, char **start, off_t offset,
|
|
|
-+ int len, int *eof, void *private)
|
|
|
-+{
|
|
|
-+ FusionEntry *entry;
|
|
|
-+ FusionEntryClass *class;
|
|
|
-+ FusionEntries *entries = private;
|
|
|
-+ int written = 0;
|
|
|
-+ struct timeval now;
|
|
|
-+
|
|
|
-+ FUSION_ASSERT( entries != NULL );
|
|
|
-+ FUSION_ASSERT( entries->class != NULL );
|
|
|
-+
|
|
|
-+ class = entries->class;
|
|
|
-+
|
|
|
-+ if (!class->Print)
|
|
|
-+ return -ENOTSUPP;
|
|
|
-+
|
|
|
-+ if (down_interruptible (&entries->lock))
|
|
|
-+ return -EINTR;
|
|
|
-+
|
|
|
-+ do_gettimeofday( &now );
|
|
|
-+
|
|
|
-+ fusion_list_foreach (entry, entries->list) {
|
|
|
-+ if (entry->last_lock.tv_sec) {
|
|
|
-+ int diff = ((now.tv_sec - entry->last_lock.tv_sec) * 1000 +
|
|
|
-+ (now.tv_usec - entry->last_lock.tv_usec) / 1000);
|
|
|
-+
|
|
|
-+ if (diff < 1000) {
|
|
|
-+ written += sprintf( buf + written, "%3d ms ", diff );
|
|
|
-+ }
|
|
|
-+ else if (diff < 1000000) {
|
|
|
-+ written += sprintf( buf + written, "%3d.%d s ",
|
|
|
-+ diff / 1000, (diff % 1000) / 100 );
|
|
|
-+ }
|
|
|
-+ else {
|
|
|
-+ diff = ( now.tv_sec - entry->last_lock.tv_sec +
|
|
|
-+ (now.tv_usec - entry->last_lock.tv_usec) / 1000000);
|
|
|
-+
|
|
|
-+ written += sprintf( buf + written, "%3d.%d h ",
|
|
|
-+ diff / 3600, (diff % 3600) / 360 );
|
|
|
-+ }
|
|
|
-+ }
|
|
|
-+ else
|
|
|
-+ written += sprintf( buf + written, " -.- " );
|
|
|
-+
|
|
|
-+
|
|
|
-+ written += sprintf( buf + written, "(%5d) 0x%08x ", entry->pid, entry->id );
|
|
|
-+
|
|
|
-+ written += sprintf( buf + written, "%-24s ", entry->name[0] ? entry->name : "" );
|
|
|
-+
|
|
|
-+ written += class->Print( entry, entries->ctx, buf + written );
|
|
|
-+
|
|
|
-+ if (written < offset) {
|
|
|
-+ offset -= written;
|
|
|
-+ written = 0;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ if (written >= len)
|
|
|
-+ break;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ up (&entries->lock);
|
|
|
-+
|
|
|
-+ *start = buf + offset;
|
|
|
-+ written -= offset;
|
|
|
-+ if (written > len) {
|
|
|
-+ *eof = 0;
|
|
|
-+ return len;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ *eof = 1;
|
|
|
-+
|
|
|
-+ return (written<0) ? 0 : written;
|
|
|
-+}
|
|
|
-+
|
|
|
-+int
|
|
|
-+fusion_entry_create( FusionEntries *entries,
|
|
|
-+ int *ret_id,
|
|
|
-+ void *create_ctx )
|
|
|
-+{
|
|
|
-+ int ret;
|
|
|
-+ FusionEntry *entry;
|
|
|
-+ FusionEntryClass *class;
|
|
|
-+
|
|
|
-+ FUSION_ASSERT( entries != NULL );
|
|
|
-+ FUSION_ASSERT( entries->class != NULL );
|
|
|
-+ FUSION_ASSERT( ret_id != NULL );
|
|
|
-+
|
|
|
-+ class = entries->class;
|
|
|
-+
|
|
|
-+ entry = kmalloc( class->object_size, GFP_KERNEL );
|
|
|
-+ if (!entry)
|
|
|
-+ return -ENOMEM;
|
|
|
-+
|
|
|
-+ memset( entry, 0, class->object_size );
|
|
|
-+
|
|
|
-+ if (down_interruptible( &entries->lock )) {
|
|
|
-+ kfree( entry );
|
|
|
-+ return -EINTR;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ entry->entries = entries;
|
|
|
-+ entry->id = entries->ids++;
|
|
|
-+ entry->pid = current->pid;
|
|
|
-+
|
|
|
-+ init_MUTEX( &entry->lock );
|
|
|
-+
|
|
|
-+ init_waitqueue_head( &entry->wait );
|
|
|
-+
|
|
|
-+ if (class->Init) {
|
|
|
-+ ret = class->Init( entry, entries->ctx, create_ctx );
|
|
|
-+ if (ret) {
|
|
|
-+ up( &entries->lock );
|
|
|
-+ kfree( entry );
|
|
|
-+ return ret;
|
|
|
-+ }
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ fusion_list_prepend( &entries->list, &entry->link );
|
|
|
-+
|
|
|
-+ up( &entries->lock );
|
|
|
-+
|
|
|
-+ *ret_id = entry->id;
|
|
|
-+
|
|
|
-+ return 0;
|
|
|
-+}
|
|
|
-+
|
|
|
-+int
|
|
|
-+fusion_entry_destroy( FusionEntries *entries,
|
|
|
-+ int id )
|
|
|
-+{
|
|
|
-+ FusionEntry *entry;
|
|
|
-+ FusionEntryClass *class;
|
|
|
-+
|
|
|
-+ FUSION_ASSERT( entries != NULL );
|
|
|
-+ FUSION_ASSERT( entries->class != NULL );
|
|
|
-+
|
|
|
-+ class = entries->class;
|
|
|
-+
|
|
|
-+ /* Lock entries. */
|
|
|
-+ if (down_interruptible( &entries->lock ))
|
|
|
-+ return -EINTR;
|
|
|
-+
|
|
|
-+ /* Lookup the entry. */
|
|
|
-+ fusion_list_foreach (entry, entries->list) {
|
|
|
-+ if (entry->id == id)
|
|
|
-+ break;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ /* Check if no entry was found. */
|
|
|
-+ if (!entry) {
|
|
|
-+ up( &entries->lock );
|
|
|
-+ return -EINVAL;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ /* Lock the entry. */
|
|
|
-+ if (down_interruptible( &entry->lock )) {
|
|
|
-+ up( &entries->lock );
|
|
|
-+ return -EINTR;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ /* Destroy it now. */
|
|
|
-+ fusion_entry_destroy_locked( entries, entry );
|
|
|
-+
|
|
|
-+ /* Unlock entries. */
|
|
|
-+ up( &entries->lock );
|
|
|
-+
|
|
|
-+ return 0;
|
|
|
-+}
|
|
|
-+
|
|
|
-+void
|
|
|
-+fusion_entry_destroy_locked( FusionEntries *entries,
|
|
|
-+ FusionEntry *entry )
|
|
|
-+{
|
|
|
-+ FusionEntryClass *class;
|
|
|
-+
|
|
|
-+ FUSION_ASSERT( entries != NULL );
|
|
|
-+ FUSION_ASSERT( entries->class != NULL );
|
|
|
-+
|
|
|
-+ class = entries->class;
|
|
|
-+
|
|
|
-+ /* Remove the entry from the list. */
|
|
|
-+ fusion_list_remove( &entries->list, &entry->link );
|
|
|
-+
|
|
|
-+ /* Wake up any waiting process. */
|
|
|
-+ wake_up_interruptible_all( &entry->wait );
|
|
|
-+
|
|
|
-+ /* Call the destroy function. */
|
|
|
-+ if (class->Destroy)
|
|
|
-+ class->Destroy( entry, entries->ctx );
|
|
|
-+
|
|
|
-+ /* Unlock the entry. */
|
|
|
-+ up( &entry->lock );
|
|
|
-+
|
|
|
-+ /* Deallocate the entry. */
|
|
|
-+ kfree( entry );
|
|
|
-+}
|
|
|
-+
|
|
|
-+int
|
|
|
-+fusion_entry_set_info( FusionEntries *entries,
|
|
|
-+ const FusionEntryInfo *info )
|
|
|
-+{
|
|
|
-+ int ret;
|
|
|
-+ FusionEntry *entry;
|
|
|
-+
|
|
|
-+ FUSION_ASSERT( entries != NULL );
|
|
|
-+ FUSION_ASSERT( info != NULL );
|
|
|
-+
|
|
|
-+ ret = fusion_entry_lock( entries, info->id, false, &entry );
|
|
|
-+ if (ret)
|
|
|
-+ return ret;
|
|
|
-+
|
|
|
-+ snprintf( entry->name, FUSION_ENTRY_INFO_NAME_LENGTH, info->name );
|
|
|
-+
|
|
|
-+ fusion_entry_unlock( entry );
|
|
|
-+
|
|
|
-+ return 0;
|
|
|
-+}
|
|
|
-+
|
|
|
-+int
|
|
|
-+fusion_entry_get_info( FusionEntries *entries,
|
|
|
-+ FusionEntryInfo *info )
|
|
|
-+{
|
|
|
-+ int ret;
|
|
|
-+ FusionEntry *entry;
|
|
|
-+
|
|
|
-+ FUSION_ASSERT( entries != NULL );
|
|
|
-+ FUSION_ASSERT( info != NULL );
|
|
|
-+
|
|
|
-+ ret = fusion_entry_lock( entries, info->id, false, &entry );
|
|
|
-+ if (ret)
|
|
|
-+ return ret;
|
|
|
-+
|
|
|
-+ snprintf( info->name, FUSION_ENTRY_INFO_NAME_LENGTH, entry->name );
|
|
|
-+
|
|
|
-+ fusion_entry_unlock( entry );
|
|
|
-+
|
|
|
-+ return 0;
|
|
|
-+}
|
|
|
-+
|
|
|
-+int
|
|
|
-+fusion_entry_lock( FusionEntries *entries,
|
|
|
-+ int id,
|
|
|
-+ bool keep_entries_lock,
|
|
|
-+ FusionEntry **ret_entry )
|
|
|
-+{
|
|
|
-+ FusionEntry *entry;
|
|
|
-+
|
|
|
-+ FUSION_ASSERT( entries != NULL );
|
|
|
-+ FUSION_ASSERT( ret_entry != NULL );
|
|
|
-+
|
|
|
-+ /* Lock entries. */
|
|
|
-+ if (down_interruptible( &entries->lock ))
|
|
|
-+ return -EINTR;
|
|
|
-+
|
|
|
-+ /* Lookup the entry. */
|
|
|
-+ fusion_list_foreach (entry, entries->list) {
|
|
|
-+ if (entry->id == id)
|
|
|
-+ break;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ /* Check if no entry was found. */
|
|
|
-+ if (!entry) {
|
|
|
-+ up( &entries->lock );
|
|
|
-+ return -EINVAL;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ FUSION_ASSUME( entry->lock_pid != current->pid );
|
|
|
-+
|
|
|
-+ /* Move the entry to the front of all entries. */
|
|
|
-+ fusion_list_move_to_front( &entries->list, &entry->link );
|
|
|
-+
|
|
|
-+ /* Lock the entry. */
|
|
|
-+ if (down_interruptible( &entry->lock )) {
|
|
|
-+ up( &entries->lock );
|
|
|
-+ return -EINTR;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ /* Mark as locked. */
|
|
|
-+ entry->lock_pid = current->pid;
|
|
|
-+
|
|
|
-+ /* Keep timestamp, but use the slightly
|
|
|
-+ inexact version to avoid performance impacts. */
|
|
|
-+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 0) && defined _STRUCT_TIMESPEC
|
|
|
-+ entry->last_lock.tv_sec = xtime.tv_sec;
|
|
|
-+ entry->last_lock.tv_usec = xtime.tv_nsec / 1000;
|
|
|
-+#else
|
|
|
-+ entry->last_lock = xtime;
|
|
|
-+#endif
|
|
|
-+
|
|
|
-+ /* Unlock entries. */
|
|
|
-+ if (!keep_entries_lock)
|
|
|
-+ up( &entries->lock );
|
|
|
-+
|
|
|
-+ /* Return the locked entry. */
|
|
|
-+ *ret_entry = entry;
|
|
|
-+
|
|
|
-+ return 0;
|
|
|
-+}
|
|
|
-+
|
|
|
-+void
|
|
|
-+fusion_entry_unlock( FusionEntry *entry )
|
|
|
-+{
|
|
|
-+ FUSION_ASSERT( entry != NULL );
|
|
|
-+ FUSION_ASSUME( entry->lock_pid == current->pid );
|
|
|
-+
|
|
|
-+ entry->lock_pid = 0;
|
|
|
-+
|
|
|
-+ /* Unlock the entry. */
|
|
|
-+ up( &entry->lock );
|
|
|
-+}
|
|
|
-+
|
|
|
-+int
|
|
|
-+fusion_entry_wait( FusionEntry *entry, long *timeout )
|
|
|
-+{
|
|
|
-+ int ret;
|
|
|
-+ int id;
|
|
|
-+ FusionEntries *entries;
|
|
|
-+ FusionEntry *entry2;
|
|
|
-+
|
|
|
-+ FUSION_ASSERT( entry != NULL );
|
|
|
-+ FUSION_ASSERT( entry->entries != NULL );
|
|
|
-+ FUSION_ASSUME( entry->lock_pid == current->pid );
|
|
|
-+
|
|
|
-+ id = entry->id;
|
|
|
-+ entries = entry->entries;
|
|
|
-+
|
|
|
-+ entry->waiters++;
|
|
|
-+
|
|
|
-+ entry->lock_pid = 0;
|
|
|
-+ fusion_sleep_on( &entry->wait, &entry->lock, timeout );
|
|
|
-+
|
|
|
-+ entry->waiters--;
|
|
|
-+
|
|
|
-+ if (signal_pending(current))
|
|
|
-+ return -EINTR;
|
|
|
-+
|
|
|
-+ if (timeout && !*timeout)
|
|
|
-+ return -ETIMEDOUT;
|
|
|
-+
|
|
|
-+ ret = fusion_entry_lock( entries, id, false, &entry2 );
|
|
|
-+ switch (ret) {
|
|
|
-+ case -EINVAL:
|
|
|
-+ return -EIDRM;
|
|
|
-+
|
|
|
-+ case 0:
|
|
|
-+ if (entry != entry2)
|
|
|
-+ BUG();
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ return ret;
|
|
|
-+}
|
|
|
-+
|
|
|
-+void
|
|
|
-+fusion_entry_notify( FusionEntry *entry, bool all )
|
|
|
-+{
|
|
|
-+ FUSION_ASSERT( entry != NULL );
|
|
|
-+ FUSION_ASSUME( entry->lock_pid == current->pid );
|
|
|
-+
|
|
|
-+ if (all)
|
|
|
-+ wake_up_interruptible_all( &entry->wait );
|
|
|
-+ else
|
|
|
-+ wake_up_interruptible( &entry->wait );
|
|
|
-+}
|
|
|
-+
|
|
|
-diff -urN linux-2.6.22.1-0rig/drivers/char/fusion/entries.h linux-2.6.22.1/drivers/char/fusion/entries.h
|
|
|
---- linux-2.6.22.1-0rig/drivers/char/fusion/entries.h 1970-01-01 01:00:00.000000000 +0100
|
|
|
-+++ linux-2.6.22.1/drivers/char/fusion/entries.h 2006-09-03 13:50:55.000000000 +0200
|
|
|
-@@ -0,0 +1,179 @@
|
|
|
-+/*
|
|
|
-+ * Fusion Kernel Module
|
|
|
-+ *
|
|
|
-+ * (c) Copyright 2002-2003 Convergence GmbH
|
|
|
-+ *
|
|
|
-+ * Written by Denis Oliver Kropp <dok@directfb.org>
|
|
|
-+ *
|
|
|
-+ *
|
|
|
-+ * This program is free software; you can redistribute it and/or
|
|
|
-+ * modify it under the terms of the GNU General Public License
|
|
|
-+ * as published by the Free Software Foundation; either version
|
|
|
-+ * 2 of the License, or (at your option) any later version.
|
|
|
-+ */
|
|
|
-+
|
|
|
-+#ifndef __FUSION__ENTRIES_H__
|
|
|
-+#define __FUSION__ENTRIES_H__
|
|
|
-+
|
|
|
-+#include "types.h"
|
|
|
-+#include "list.h"
|
|
|
-+
|
|
|
-+
|
|
|
-+typedef struct __FD_FusionEntry FusionEntry;
|
|
|
-+
|
|
|
-+
|
|
|
-+typedef const struct {
|
|
|
-+ int object_size;
|
|
|
-+
|
|
|
-+ int (*Init) ( FusionEntry *entry, void *ctx, void *create_ctx );
|
|
|
-+ void (*Destroy)( FusionEntry *entry, void *ctx );
|
|
|
-+ int (*Print) ( FusionEntry *entry, void *ctx, char *buf );
|
|
|
-+} FusionEntryClass;
|
|
|
-+
|
|
|
-+
|
|
|
-+typedef struct {
|
|
|
-+ FusionEntryClass *class;
|
|
|
-+ void *ctx;
|
|
|
-+
|
|
|
-+ FusionLink *list;
|
|
|
-+ int ids;
|
|
|
-+ struct semaphore lock;
|
|
|
-+} FusionEntries;
|
|
|
-+
|
|
|
-+
|
|
|
-+struct __FD_FusionEntry {
|
|
|
-+ FusionLink link;
|
|
|
-+
|
|
|
-+ FusionEntries *entries;
|
|
|
-+
|
|
|
-+ int id;
|
|
|
-+ pid_t pid;
|
|
|
-+
|
|
|
-+ pid_t lock_pid;
|
|
|
-+
|
|
|
-+ struct semaphore lock;
|
|
|
-+ wait_queue_head_t wait;
|
|
|
-+ int waiters;
|
|
|
-+
|
|
|
-+ struct timeval last_lock;
|
|
|
-+
|
|
|
-+ char name[FUSION_ENTRY_INFO_NAME_LENGTH];
|
|
|
-+};
|
|
|
-+
|
|
|
-+
|
|
|
-+/* Entries Init & DeInit */
|
|
|
-+
|
|
|
-+void fusion_entries_init ( FusionEntries *entries,
|
|
|
-+ FusionEntryClass *class,
|
|
|
-+ void *ctx );
|
|
|
-+
|
|
|
-+void fusion_entries_deinit( FusionEntries *entries );
|
|
|
-+
|
|
|
-+
|
|
|
-+/* '/proc' support */
|
|
|
-+
|
|
|
-+int fusion_entries_read_proc( char *buf, char **start, off_t offset,
|
|
|
-+ int len, int *eof, void *private );
|
|
|
-+
|
|
|
-+
|
|
|
-+/* Create & Destroy */
|
|
|
-+
|
|
|
-+int fusion_entry_create ( FusionEntries *entries,
|
|
|
-+ int *ret_id,
|
|
|
-+ void *create_ctx );
|
|
|
-+
|
|
|
-+int fusion_entry_destroy ( FusionEntries *entries,
|
|
|
-+ int id );
|
|
|
-+
|
|
|
-+void fusion_entry_destroy_locked( FusionEntries *entries,
|
|
|
-+ FusionEntry *entry );
|
|
|
-+
|
|
|
-+/* Information */
|
|
|
-+
|
|
|
-+int fusion_entry_set_info( FusionEntries *entries,
|
|
|
-+ const FusionEntryInfo *info );
|
|
|
-+
|
|
|
-+int fusion_entry_get_info( FusionEntries *entries,
|
|
|
-+ FusionEntryInfo *info );
|
|
|
-+
|
|
|
-+
|
|
|
-+/* Lock & Unlock */
|
|
|
-+
|
|
|
-+int fusion_entry_lock ( FusionEntries *entries,
|
|
|
-+ int id,
|
|
|
-+ bool keep_entries_lock,
|
|
|
-+ FusionEntry **ret_entry );
|
|
|
-+
|
|
|
-+void fusion_entry_unlock ( FusionEntry *entry );
|
|
|
-+
|
|
|
-+
|
|
|
-+/** Wait & Notify **/
|
|
|
-+
|
|
|
-+/*
|
|
|
-+ * Wait for the entry to be notified with an optional timeout.
|
|
|
-+ *
|
|
|
-+ * The entry
|
|
|
-+ * (1) has to be locked prior to calling this function.
|
|
|
-+ * (2) is temporarily unlocked while being waited for.
|
|
|
-+ *
|
|
|
-+ * If this function returns an error, the entry is not locked again!
|
|
|
-+ *
|
|
|
-+ * Possible errors are:
|
|
|
-+ * -EIDRM Entry has been removed while being waited for.
|
|
|
-+ * -ETIMEDOUT Timeout occured.
|
|
|
-+ * -EINTR A signal has been received.
|
|
|
-+ */
|
|
|
-+int fusion_entry_wait ( FusionEntry *entry,
|
|
|
-+ long *timeout );
|
|
|
-+
|
|
|
-+/*
|
|
|
-+ * Wake up one or all processes waiting for the entry to be notified.
|
|
|
-+ *
|
|
|
-+ * The entry has to be locked prior to calling this function.
|
|
|
-+ */
|
|
|
-+void fusion_entry_notify ( FusionEntry *entry,
|
|
|
-+ bool all );
|
|
|
-+
|
|
|
-+
|
|
|
-+#define FUSION_ENTRY_CLASS( Type, name, init_func, destroy_func, print_func ) \
|
|
|
-+ \
|
|
|
-+ static FusionEntryClass name##_class = { \
|
|
|
-+ .object_size = sizeof(Type), \
|
|
|
-+ .Init = init_func, \
|
|
|
-+ .Destroy = destroy_func, \
|
|
|
-+ .Print = print_func \
|
|
|
-+ }; \
|
|
|
-+ \
|
|
|
-+ static inline int fusion_##name##_lock( FusionEntries *entries, \
|
|
|
-+ int id, \
|
|
|
-+ bool keep, \
|
|
|
-+ Type **ret_##name ) \
|
|
|
-+ { \
|
|
|
-+ int ret; \
|
|
|
-+ FusionEntry *entry; \
|
|
|
-+ \
|
|
|
-+ ret = fusion_entry_lock( entries, id, keep, &entry ); \
|
|
|
-+ \
|
|
|
-+ if (!ret) \
|
|
|
-+ *ret_##name = (Type *) entry; \
|
|
|
-+ \
|
|
|
-+ return ret; \
|
|
|
-+ } \
|
|
|
-+ \
|
|
|
-+ static inline void fusion_##name##_unlock( Type *name ) \
|
|
|
-+ { \
|
|
|
-+ fusion_entry_unlock( (FusionEntry*) name ); \
|
|
|
-+ } \
|
|
|
-+ \
|
|
|
-+ static inline int fusion_##name##_wait( Type *name, long *timeout ) \
|
|
|
-+ { \
|
|
|
-+ return fusion_entry_wait( (FusionEntry*) name, timeout ); \
|
|
|
-+ } \
|
|
|
-+ \
|
|
|
-+ static inline void fusion_##name##_notify( Type *name, bool all ) \
|
|
|
-+ { \
|
|
|
-+ fusion_entry_notify( (FusionEntry*) name, all ); \
|
|
|
-+ }
|
|
|
-+
|
|
|
-+
|
|
|
-+#endif
|
|
|
-diff -urN linux-2.6.22.1-0rig/drivers/char/fusion/fifo.c linux-2.6.22.1/drivers/char/fusion/fifo.c
|
|
|
---- linux-2.6.22.1-0rig/drivers/char/fusion/fifo.c 1970-01-01 01:00:00.000000000 +0100
|
|
|
-+++ linux-2.6.22.1/drivers/char/fusion/fifo.c 2003-06-16 19:47:03.000000000 +0200
|
|
|
-@@ -0,0 +1,53 @@
|
|
|
-+/*
|
|
|
-+ * Fusion Kernel Module
|
|
|
-+ *
|
|
|
-+ * (c) Copyright 2002-2003 Convergence GmbH
|
|
|
-+ *
|
|
|
-+ * Written by Denis Oliver Kropp <dok@directfb.org>
|
|
|
-+ *
|
|
|
-+ *
|
|
|
-+ * This program is free software; you can redistribute it and/or
|
|
|
-+ * modify it under the terms of the GNU General Public License
|
|
|
-+ * as published by the Free Software Foundation; either version
|
|
|
-+ * 2 of the License, or (at your option) any later version.
|
|
|
-+ */
|
|
|
-+
|
|
|
-+#include <linux/types.h>
|
|
|
-+
|
|
|
-+#include "fifo.h"
|
|
|
-+
|
|
|
-+void
|
|
|
-+fusion_fifo_put (FusionFifo *fifo, FusionLink *link)
|
|
|
-+{
|
|
|
-+ link->prev = fifo->last;
|
|
|
-+ link->next = NULL;
|
|
|
-+
|
|
|
-+ if (fifo->last)
|
|
|
-+ fifo->last->next = link;
|
|
|
-+ else
|
|
|
-+ fifo->first = link;
|
|
|
-+
|
|
|
-+ fifo->last = link;
|
|
|
-+
|
|
|
-+ fifo->count++;
|
|
|
-+}
|
|
|
-+
|
|
|
-+FusionLink *
|
|
|
-+fusion_fifo_get (FusionFifo *fifo)
|
|
|
-+{
|
|
|
-+ FusionLink *first = fifo->first;
|
|
|
-+
|
|
|
-+ if (!first)
|
|
|
-+ return NULL;
|
|
|
-+
|
|
|
-+ fifo->first = first->next;
|
|
|
-+
|
|
|
-+ if (fifo->last == first)
|
|
|
-+ fifo->last = NULL;
|
|
|
-+ else
|
|
|
-+ fifo->first->prev = NULL;
|
|
|
-+
|
|
|
-+ fifo->count--;
|
|
|
-+
|
|
|
-+ return first;
|
|
|
-+}
|
|
|
-diff -urN linux-2.6.22.1-0rig/drivers/char/fusion/fifo.h linux-2.6.22.1/drivers/char/fusion/fifo.h
|
|
|
---- linux-2.6.22.1-0rig/drivers/char/fusion/fifo.h 1970-01-01 01:00:00.000000000 +0100
|
|
|
-+++ linux-2.6.22.1/drivers/char/fusion/fifo.h 2003-06-16 19:47:03.000000000 +0200
|
|
|
-@@ -0,0 +1,36 @@
|
|
|
-+/*
|
|
|
-+ * Fusion Kernel Module
|
|
|
-+ *
|
|
|
-+ * (c) Copyright 2002-2003 Convergence GmbH
|
|
|
-+ *
|
|
|
-+ * Written by Denis Oliver Kropp <dok@directfb.org>
|
|
|
-+ *
|
|
|
-+ *
|
|
|
-+ * This program is free software; you can redistribute it and/or
|
|
|
-+ * modify it under the terms of the GNU General Public License
|
|
|
-+ * as published by the Free Software Foundation; either version
|
|
|
-+ * 2 of the License, or (at your option) any later version.
|
|
|
-+ */
|
|
|
-+
|
|
|
-+#ifndef __FUSION__FIFO_H__
|
|
|
-+#define __FUSION__FIFO_H__
|
|
|
-+
|
|
|
-+#include "types.h"
|
|
|
-+#include "list.h"
|
|
|
-+
|
|
|
-+typedef struct {
|
|
|
-+ FusionLink *first;
|
|
|
-+ FusionLink *last;
|
|
|
-+
|
|
|
-+ int count;
|
|
|
-+} FusionFifo;
|
|
|
-+
|
|
|
-+void fusion_fifo_put (FusionFifo *fifo,
|
|
|
-+ FusionLink *link);
|
|
|
-+
|
|
|
-+FusionLink *fusion_fifo_get (FusionFifo *fifo);
|
|
|
-+
|
|
|
-+int fusion_fifo_count (FusionFifo *fifo);
|
|
|
-+
|
|
|
-+#endif /* __FUSION__LIST_H__ */
|
|
|
-+
|
|
|
-diff -urN linux-2.6.22.1-0rig/drivers/char/fusion/fusiondev.c linux-2.6.22.1/drivers/char/fusion/fusiondev.c
|
|
|
---- linux-2.6.22.1-0rig/drivers/char/fusion/fusiondev.c 1970-01-01 01:00:00.000000000 +0100
|
|
|
-+++ linux-2.6.22.1/drivers/char/fusion/fusiondev.c 2007-03-08 14:02:47.000000000 +0100
|
|
|
-@@ -0,0 +1,1187 @@
|
|
|
-+/*
|
|
|
-+ * Fusion Kernel Module
|
|
|
-+ *
|
|
|
-+ * (c) Copyright 2002-2003 Convergence GmbH
|
|
|
-+ *
|
|
|
-+ * Written by Denis Oliver Kropp <dok@directfb.org>
|
|
|
-+ *
|
|
|
-+ *
|
|
|
-+ * This program is free software; you can redistribute it and/or
|
|
|
-+ * modify it under the terms of the GNU General Public License
|
|
|
-+ * as published by the Free Software Foundation; either version
|
|
|
-+ * 2 of the License, or (at your option) any later version.
|
|
|
-+ */
|
|
|
-+
|
|
|
-+#include <linux/version.h>
|
|
|
-+#include <linux/module.h>
|
|
|
-+#ifdef HAVE_LINUX_CONFIG_H
|
|
|
-+#include <linux/config.h>
|
|
|
-+#endif
|
|
|
-+#include <linux/types.h>
|
|
|
-+#include <linux/kernel.h>
|
|
|
-+#include <linux/fs.h>
|
|
|
-+#include <linux/slab.h>
|
|
|
-+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 18)
|
|
|
-+#include <linux/devfs_fs_kernel.h>
|
|
|
-+#endif
|
|
|
-+#if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 19)
|
|
|
-+#include <linux/page-flags.h>
|
|
|
-+#include <linux/mm.h>
|
|
|
-+#endif
|
|
|
-+
|
|
|
-+#include <linux/proc_fs.h>
|
|
|
-+#include <linux/poll.h>
|
|
|
-+#include <linux/init.h>
|
|
|
-+#include <asm/io.h>
|
|
|
-+#include <asm/uaccess.h>
|
|
|
-+
|
|
|
-+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 2)
|
|
|
-+#include <linux/device.h>
|
|
|
-+#endif
|
|
|
-+
|
|
|
-+#include <linux/fusion.h>
|
|
|
-+
|
|
|
-+#include "call.h"
|
|
|
-+#include "fusiondev.h"
|
|
|
-+#include "fusionee.h"
|
|
|
-+#include "property.h"
|
|
|
-+#include "reactor.h"
|
|
|
-+#include "ref.h"
|
|
|
-+#include "skirmish.h"
|
|
|
-+#include "shmpool.h"
|
|
|
-+
|
|
|
-+#if 0
|
|
|
-+#define DEBUG(x...) printk (KERN_DEBUG "Fusion: " x)
|
|
|
-+#else
|
|
|
-+#define DEBUG(x...) do {} while (0)
|
|
|
-+#endif
|
|
|
-+
|
|
|
-+#ifndef FUSION_MAJOR
|
|
|
-+#define FUSION_MAJOR 252
|
|
|
-+#endif
|
|
|
-+
|
|
|
-+MODULE_LICENSE("GPL");
|
|
|
-+MODULE_AUTHOR("Denis Oliver Kropp <dok@directfb.org>");
|
|
|
-+
|
|
|
-+struct proc_dir_entry *proc_fusion_dir;
|
|
|
-+
|
|
|
-+#define NUM_MINORS 8
|
|
|
-+
|
|
|
-+static FusionDev *fusion_devs[NUM_MINORS] = { 0 };
|
|
|
-+static DECLARE_MUTEX(devs_lock);
|
|
|
-+
|
|
|
-+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 0)
|
|
|
-+static devfs_handle_t devfs_handles[NUM_MINORS];
|
|
|
-+static inline unsigned iminor(struct inode *inode)
|
|
|
-+{
|
|
|
-+ return MINOR(inode->i_rdev);
|
|
|
-+}
|
|
|
-+#endif
|
|
|
-+
|
|
|
-+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 2)
|
|
|
-+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 13)
|
|
|
-+static struct class *fusion_class;
|
|
|
-+#else
|
|
|
-+static struct class_simple *fusion_class;
|
|
|
-+#endif
|
|
|
-+#endif
|
|
|
-+
|
|
|
-+/******************************************************************************/
|
|
|
-+
|
|
|
-+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 0)
|
|
|
-+void
|
|
|
-+fusion_sleep_on(wait_queue_head_t *q, struct semaphore *lock, signed long *timeout)
|
|
|
-+{
|
|
|
-+ DEFINE_WAIT(wait);
|
|
|
-+
|
|
|
-+ prepare_to_wait( q, &wait, TASK_INTERRUPTIBLE );
|
|
|
-+
|
|
|
-+ up( lock );
|
|
|
-+
|
|
|
-+ if (timeout)
|
|
|
-+ *timeout = schedule_timeout(*timeout);
|
|
|
-+ else
|
|
|
-+ schedule();
|
|
|
-+
|
|
|
-+ finish_wait( q, &wait );
|
|
|
-+}
|
|
|
-+#else
|
|
|
-+void
|
|
|
-+fusion_sleep_on(wait_queue_head_t *q, struct semaphore *lock, signed long *timeout)
|
|
|
-+{
|
|
|
-+ wait_queue_t wait;
|
|
|
-+
|
|
|
-+ init_waitqueue_entry (&wait, current);
|
|
|
-+
|
|
|
-+ current->state = TASK_INTERRUPTIBLE;
|
|
|
-+
|
|
|
-+ write_lock (&q->lock);
|
|
|
-+ __add_wait_queue (q, &wait);
|
|
|
-+ write_unlock (&q->lock);
|
|
|
-+
|
|
|
-+ up (lock);
|
|
|
-+
|
|
|
-+ if (timeout)
|
|
|
-+ *timeout = schedule_timeout(*timeout);
|
|
|
-+ else
|
|
|
-+ schedule();
|
|
|
-+
|
|
|
-+ write_lock (&q->lock);
|
|
|
-+ __remove_wait_queue (q, &wait);
|
|
|
-+ write_unlock (&q->lock);
|
|
|
-+}
|
|
|
-+#endif
|
|
|
-+
|
|
|
-+/******************************************************************************/
|
|
|
-+
|
|
|
-+static int
|
|
|
-+fusiondev_stat_read_proc(char *buf, char **start, off_t offset,
|
|
|
-+ int len, int *eof, void *private)
|
|
|
-+{
|
|
|
-+ FusionDev *dev = private;
|
|
|
-+ int written = 0;
|
|
|
-+
|
|
|
-+ written += snprintf( buf, len,
|
|
|
-+ "lease/purchase cede attach detach "
|
|
|
-+ "ref up ref down prevail/swoop dismiss\n" );
|
|
|
-+ if (written < offset) {
|
|
|
-+ offset -= written;
|
|
|
-+ written = 0;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ if (written < len) {
|
|
|
-+ written += snprintf( buf+written, len - written,
|
|
|
-+ "%10d %10d %10d %10d %10d %10d %10d %10d\n",
|
|
|
-+ dev->stat.property_lease_purchase,
|
|
|
-+ dev->stat.property_cede,
|
|
|
-+ dev->stat.reactor_attach,
|
|
|
-+ dev->stat.reactor_detach,
|
|
|
-+ dev->stat.ref_up,
|
|
|
-+ dev->stat.ref_down,
|
|
|
-+ dev->stat.skirmish_prevail_swoop,
|
|
|
-+ dev->stat.skirmish_dismiss );
|
|
|
-+ if (written < offset) {
|
|
|
-+ offset -= written;
|
|
|
-+ written = 0;
|
|
|
-+ }
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ *start = buf + offset;
|
|
|
-+ written -= offset;
|
|
|
-+ if (written > len) {
|
|
|
-+ *eof = 0;
|
|
|
-+ return len;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ *eof = 1;
|
|
|
-+ return(written<0) ? 0 : written;
|
|
|
-+}
|
|
|
-+
|
|
|
-+/******************************************************************************/
|
|
|
-+
|
|
|
-+static int
|
|
|
-+fusiondev_init (FusionDev *dev)
|
|
|
-+{
|
|
|
-+ int ret;
|
|
|
-+
|
|
|
-+ init_MUTEX( &dev->enter_lock );
|
|
|
-+ init_waitqueue_head( &dev->enter_wait );
|
|
|
-+
|
|
|
-+ ret = fusionee_init (dev);
|
|
|
-+ if (ret)
|
|
|
-+ goto error_fusionee;
|
|
|
-+
|
|
|
-+ ret = fusion_ref_init (dev);
|
|
|
-+ if (ret)
|
|
|
-+ goto error_ref;
|
|
|
-+
|
|
|
-+ ret = fusion_skirmish_init (dev);
|
|
|
-+ if (ret)
|
|
|
-+ goto error_skirmish;
|
|
|
-+
|
|
|
-+ ret = fusion_property_init (dev);
|
|
|
-+ if (ret)
|
|
|
-+ goto error_property;
|
|
|
-+
|
|
|
-+ ret = fusion_reactor_init (dev);
|
|
|
-+ if (ret)
|
|
|
-+ goto error_reactor;
|
|
|
-+
|
|
|
-+ ret = fusion_shmpool_init (dev);
|
|
|
-+ if (ret)
|
|
|
-+ goto error_shmpool;
|
|
|
-+
|
|
|
-+ ret = fusion_call_init (dev);
|
|
|
-+ if (ret)
|
|
|
-+ goto error_call;
|
|
|
-+
|
|
|
-+ create_proc_read_entry( "stat", 0, dev->proc_dir,
|
|
|
-+ fusiondev_stat_read_proc, dev );
|
|
|
-+
|
|
|
-+ return 0;
|
|
|
-+
|
|
|
-+
|
|
|
-+error_call:
|
|
|
-+ fusion_shmpool_deinit (dev);
|
|
|
-+
|
|
|
-+error_shmpool:
|
|
|
-+ fusion_reactor_deinit (dev);
|
|
|
-+
|
|
|
-+error_reactor:
|
|
|
-+ fusion_property_deinit (dev);
|
|
|
-+
|
|
|
-+error_property:
|
|
|
-+ fusion_skirmish_deinit (dev);
|
|
|
-+
|
|
|
-+error_skirmish:
|
|
|
-+ fusion_ref_deinit (dev);
|
|
|
-+
|
|
|
-+error_ref:
|
|
|
-+ fusionee_deinit (dev);
|
|
|
-+
|
|
|
-+error_fusionee:
|
|
|
-+ return ret;
|
|
|
-+}
|
|
|
-+
|
|
|
-+static void
|
|
|
-+fusiondev_deinit (FusionDev *dev)
|
|
|
-+{
|
|
|
-+ remove_proc_entry ("stat", dev->proc_dir);
|
|
|
-+
|
|
|
-+ fusion_call_deinit (dev);
|
|
|
-+ fusion_shmpool_deinit (dev);
|
|
|
-+ fusion_reactor_deinit (dev);
|
|
|
-+ fusion_property_deinit (dev);
|
|
|
-+ fusion_skirmish_deinit (dev);
|
|
|
-+ fusion_ref_deinit (dev);
|
|
|
-+ fusionee_deinit (dev);
|
|
|
-+
|
|
|
-+ if (dev->shared_area) {
|
|
|
-+ ClearPageReserved( virt_to_page(dev->shared_area) );
|
|
|
-+ free_page( dev->shared_area );
|
|
|
-+ }
|
|
|
-+}
|
|
|
-+
|
|
|
-+/******************************************************************************/
|
|
|
-+
|
|
|
-+static int
|
|
|
-+fusion_open (struct inode *inode, struct file *file)
|
|
|
-+{
|
|
|
-+ int ret;
|
|
|
-+ Fusionee *fusionee;
|
|
|
-+ int minor = iminor(inode);
|
|
|
-+
|
|
|
-+ DEBUG( "fusion_open( %p, %d )\n", file, atomic_read(&file->f_count) );
|
|
|
-+
|
|
|
-+ if (down_interruptible (&devs_lock))
|
|
|
-+ return -EINTR;
|
|
|
-+
|
|
|
-+ if (!fusion_devs[minor]) {
|
|
|
-+ char buf[4];
|
|
|
-+
|
|
|
-+ fusion_devs[minor] = kmalloc (sizeof(FusionDev), GFP_KERNEL);
|
|
|
-+ if (!fusion_devs[minor]) {
|
|
|
-+ up (&devs_lock);
|
|
|
-+ return -ENOMEM;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ memset (fusion_devs[minor], 0, sizeof(FusionDev));
|
|
|
-+
|
|
|
-+ snprintf (buf, 4, "%d", minor);
|
|
|
-+
|
|
|
-+ fusion_devs[minor]->proc_dir = proc_mkdir (buf, proc_fusion_dir);
|
|
|
-+ fusion_devs[minor]->index = minor;
|
|
|
-+
|
|
|
-+ ret = fusiondev_init (fusion_devs[minor]);
|
|
|
-+ if (ret) {
|
|
|
-+ remove_proc_entry (buf, proc_fusion_dir);
|
|
|
-+
|
|
|
-+ kfree (fusion_devs[minor]);
|
|
|
-+ fusion_devs[minor] = NULL;
|
|
|
-+
|
|
|
-+ up (&devs_lock);
|
|
|
-+
|
|
|
-+ return ret;
|
|
|
-+ }
|
|
|
-+ }
|
|
|
-+ else if (file->f_flags & O_EXCL) {
|
|
|
-+ if (fusion_devs[minor]->fusionee.last_id) {
|
|
|
-+ up (&devs_lock);
|
|
|
-+ return -EBUSY;
|
|
|
-+ }
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ ret = fusionee_new (fusion_devs[minor], !!(file->f_flags & O_APPEND), &fusionee);
|
|
|
-+ if (ret) {
|
|
|
-+ if (!fusion_devs[minor]->refs) {
|
|
|
-+ fusiondev_deinit (fusion_devs[minor]);
|
|
|
-+
|
|
|
-+ remove_proc_entry (fusion_devs[minor]->proc_dir->name,
|
|
|
-+ proc_fusion_dir);
|
|
|
-+
|
|
|
-+ kfree (fusion_devs[minor]);
|
|
|
-+ fusion_devs[minor] = NULL;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ up (&devs_lock);
|
|
|
-+
|
|
|
-+ return ret;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ fusion_devs[minor]->refs++;
|
|
|
-+
|
|
|
-+ up (&devs_lock);
|
|
|
-+
|
|
|
-+
|
|
|
-+ file->private_data = fusionee;
|
|
|
-+
|
|
|
-+ return 0;
|
|
|
-+}
|
|
|
-+
|
|
|
-+static int
|
|
|
-+fusion_release (struct inode *inode, struct file *file)
|
|
|
-+{
|
|
|
-+ int minor = iminor(inode);
|
|
|
-+ Fusionee *fusionee = file->private_data;
|
|
|
-+
|
|
|
-+ DEBUG( "fusion_release( %p, %d )\n", file, atomic_read(&file->f_count) );
|
|
|
-+
|
|
|
-+ fusionee_destroy (fusion_devs[minor], fusionee);
|
|
|
-+
|
|
|
-+ down (&devs_lock);
|
|
|
-+
|
|
|
-+ if (! --fusion_devs[minor]->refs) {
|
|
|
-+ fusiondev_deinit (fusion_devs[minor]);
|
|
|
-+
|
|
|
-+ remove_proc_entry (fusion_devs[minor]->proc_dir->name,
|
|
|
-+ proc_fusion_dir);
|
|
|
-+
|
|
|
-+ kfree (fusion_devs[minor]);
|
|
|
-+ fusion_devs[minor] = NULL;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ up (&devs_lock);
|
|
|
-+
|
|
|
-+ return 0;
|
|
|
-+}
|
|
|
-+
|
|
|
-+static int
|
|
|
-+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 18)
|
|
|
-+fusion_flush (struct file *file, fl_owner_t id)
|
|
|
-+#else
|
|
|
-+fusion_flush (struct file *file)
|
|
|
-+#endif
|
|
|
-+{
|
|
|
-+ Fusionee *fusionee = file->private_data;
|
|
|
-+ FusionDev *dev = fusion_devs[iminor(file->f_dentry->d_inode)];
|
|
|
-+
|
|
|
-+ (void) fusionee;
|
|
|
-+
|
|
|
-+ DEBUG( "fusion_flush( %p, %d, 0x%08x %d )\n", file, atomic_read(&file->f_count), fusionee_id(fusionee), current->pid );
|
|
|
-+
|
|
|
-+ if (current->flags & PF_EXITING)
|
|
|
-+ fusion_skirmish_dismiss_all_from_pid (dev, current->pid);
|
|
|
-+
|
|
|
-+ return 0;
|
|
|
-+}
|
|
|
-+
|
|
|
-+static ssize_t
|
|
|
-+fusion_read (struct file *file, char *buf, size_t count, loff_t *ppos)
|
|
|
-+{
|
|
|
-+ Fusionee *fusionee = file->private_data;
|
|
|
-+ FusionDev *dev = fusion_devs[iminor(file->f_dentry->d_inode)];
|
|
|
-+
|
|
|
-+ DEBUG( "fusion_read( %p, %d, %d )\n", file, atomic_read(&file->f_count), count );
|
|
|
-+
|
|
|
-+ return fusionee_get_messages (dev, fusionee, buf, count,
|
|
|
-+ !(file->f_flags & O_NONBLOCK));
|
|
|
-+}
|
|
|
-+
|
|
|
-+static unsigned int
|
|
|
-+fusion_poll (struct file *file, poll_table * wait)
|
|
|
-+{
|
|
|
-+ Fusionee *fusionee = file->private_data;
|
|
|
-+ FusionDev *dev = fusion_devs[iminor(file->f_dentry->d_inode)];
|
|
|
-+
|
|
|
-+ DEBUG( "fusion_poll( %p, %d )\n", file, atomic_read(&file->f_count) );
|
|
|
-+
|
|
|
-+ return fusionee_poll (dev, fusionee, file, wait);
|
|
|
-+}
|
|
|
-+
|
|
|
-+static int
|
|
|
-+lounge_ioctl (struct file *file, FusionDev *dev, Fusionee *fusionee,
|
|
|
-+ unsigned int cmd, unsigned long arg)
|
|
|
-+{
|
|
|
-+ int ret;
|
|
|
-+ FusionEnter enter;
|
|
|
-+ FusionKill kill;
|
|
|
-+ FusionEntryInfo info;
|
|
|
-+ FusionFork fork = {0};
|
|
|
-+
|
|
|
-+ switch (_IOC_NR(cmd)) {
|
|
|
-+ case _IOC_NR(FUSION_ENTER):
|
|
|
-+ if (copy_from_user (&enter, (FusionEnter*) arg, sizeof(enter)))
|
|
|
-+ return -EFAULT;
|
|
|
-+
|
|
|
-+ ret = fusionee_enter( dev, &enter, fusionee );
|
|
|
-+ if (ret)
|
|
|
-+ return ret;
|
|
|
-+
|
|
|
-+ if (copy_to_user ((FusionEnter*) arg, &enter, sizeof(enter)))
|
|
|
-+ return -EFAULT;
|
|
|
-+
|
|
|
-+ return 0;
|
|
|
-+
|
|
|
-+ case _IOC_NR(FUSION_UNBLOCK):
|
|
|
-+ if (fusionee_id( fusionee ) != FUSION_ID_MASTER)
|
|
|
-+ return -EPERM;
|
|
|
-+
|
|
|
-+ if (down_interruptible( &dev->enter_lock ))
|
|
|
-+ return -EINTR;
|
|
|
-+
|
|
|
-+ dev->enter_ok = 1;
|
|
|
-+
|
|
|
-+ wake_up_interruptible_all( &dev->enter_wait );
|
|
|
-+
|
|
|
-+ up( &dev->enter_lock );
|
|
|
-+
|
|
|
-+ return 0;
|
|
|
-+
|
|
|
-+ case _IOC_NR(FUSION_KILL):
|
|
|
-+ if (copy_from_user (&kill, (FusionKill*) arg, sizeof(kill)))
|
|
|
-+ return -EFAULT;
|
|
|
-+
|
|
|
-+ return fusionee_kill (dev, fusionee,
|
|
|
-+ kill.fusion_id, kill.signal, kill.timeout_ms);
|
|
|
-+
|
|
|
-+ case _IOC_NR(FUSION_ENTRY_SET_INFO):
|
|
|
-+ if (copy_from_user (&info, (FusionEntryInfo*) arg, sizeof(info)))
|
|
|
-+ return -EFAULT;
|
|
|
-+
|
|
|
-+ switch (info.type) {
|
|
|
-+ case FT_SKIRMISH:
|
|
|
-+ return fusion_entry_set_info (&dev->skirmish, &info);
|
|
|
-+
|
|
|
-+ case FT_PROPERTY:
|
|
|
-+ return fusion_entry_set_info (&dev->properties, &info);
|
|
|
-+
|
|
|
-+ case FT_REACTOR:
|
|
|
-+ return fusion_entry_set_info (&dev->reactor, &info);
|
|
|
-+
|
|
|
-+ case FT_REF:
|
|
|
-+ return fusion_entry_set_info (&dev->ref, &info);
|
|
|
-+
|
|
|
-+ case FT_SHMPOOL:
|
|
|
-+ return fusion_entry_set_info (&dev->shmpool, &info);
|
|
|
-+
|
|
|
-+ default:
|
|
|
-+ return -ENOSYS;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ case _IOC_NR(FUSION_ENTRY_GET_INFO):
|
|
|
-+ if (copy_from_user (&info, (FusionEntryInfo*) arg, sizeof(info)))
|
|
|
-+ return -EFAULT;
|
|
|
-+
|
|
|
-+ switch (info.type) {
|
|
|
-+ case FT_SKIRMISH:
|
|
|
-+ ret = fusion_entry_get_info (&dev->skirmish, &info);
|
|
|
-+ break;
|
|
|
-+
|
|
|
-+ case FT_PROPERTY:
|
|
|
-+ ret = fusion_entry_get_info (&dev->properties, &info);
|
|
|
-+ break;
|
|
|
-+
|
|
|
-+ case FT_REACTOR:
|
|
|
-+ ret = fusion_entry_get_info (&dev->reactor, &info);
|
|
|
-+ break;
|
|
|
-+
|
|
|
-+ case FT_REF:
|
|
|
-+ ret = fusion_entry_get_info (&dev->ref, &info);
|
|
|
-+ break;
|
|
|
-+
|
|
|
-+ case FT_SHMPOOL:
|
|
|
-+ ret = fusion_entry_get_info (&dev->shmpool, &info);
|
|
|
-+ break;
|
|
|
-+
|
|
|
-+ default:
|
|
|
-+ return -ENOSYS;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ if (ret)
|
|
|
-+ return ret;
|
|
|
-+
|
|
|
-+ if (copy_to_user ((FusionEntryInfo*) arg, &info, sizeof(info)))
|
|
|
-+ return -EFAULT;
|
|
|
-+
|
|
|
-+ return 0;
|
|
|
-+
|
|
|
-+ case _IOC_NR(FUSION_FORK):
|
|
|
-+ if (copy_from_user( &fork, (FusionFork*) arg, sizeof(fork) ))
|
|
|
-+ return -EFAULT;
|
|
|
-+
|
|
|
-+ ret = fusionee_fork( dev, &fork, fusionee );
|
|
|
-+ if (ret)
|
|
|
-+ return ret;
|
|
|
-+
|
|
|
-+ if (copy_to_user( (FusionFork*) arg, &fork, sizeof(fork) ))
|
|
|
-+ return -EFAULT;
|
|
|
-+
|
|
|
-+ return 0;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ return -ENOSYS;
|
|
|
-+}
|
|
|
-+
|
|
|
-+static int
|
|
|
-+messaging_ioctl (FusionDev *dev, Fusionee *fusionee,
|
|
|
-+ unsigned int cmd, unsigned long arg)
|
|
|
-+{
|
|
|
-+ FusionSendMessage send;
|
|
|
-+
|
|
|
-+ switch (_IOC_NR(cmd)) {
|
|
|
-+ case _IOC_NR(FUSION_SEND_MESSAGE):
|
|
|
-+ if (copy_from_user (&send, (FusionSendMessage*) arg, sizeof(send)))
|
|
|
-+ return -EFAULT;
|
|
|
-+
|
|
|
-+ if (send.msg_size <= 0)
|
|
|
-+ return -EINVAL;
|
|
|
-+
|
|
|
-+ /* message data > 64k should be stored in shared memory */
|
|
|
-+ if (send.msg_size > 0x10000)
|
|
|
-+ return -EMSGSIZE;
|
|
|
-+
|
|
|
-+ return fusionee_send_message (dev, fusionee, send.fusion_id, FMT_SEND,
|
|
|
-+ send.msg_id, send.msg_size, send.msg_data);
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ return -ENOSYS;
|
|
|
-+}
|
|
|
-+
|
|
|
-+static int
|
|
|
-+call_ioctl (FusionDev *dev, Fusionee *fusionee,
|
|
|
-+ unsigned int cmd, unsigned long arg)
|
|
|
-+{
|
|
|
-+ int id;
|
|
|
-+ int ret;
|
|
|
-+ FusionCallNew call;
|
|
|
-+ FusionCallExecute execute;
|
|
|
-+ FusionCallReturn call_ret;
|
|
|
-+ FusionID fusion_id = fusionee_id( fusionee );
|
|
|
-+
|
|
|
-+ switch (_IOC_NR(cmd)) {
|
|
|
-+ case _IOC_NR(FUSION_CALL_NEW):
|
|
|
-+ if (copy_from_user (&call, (FusionCallNew*) arg, sizeof(call)))
|
|
|
-+ return -EFAULT;
|
|
|
-+
|
|
|
-+ ret = fusion_call_new (dev, fusion_id, &call);
|
|
|
-+ if (ret)
|
|
|
-+ return ret;
|
|
|
-+
|
|
|
-+ if (put_user (call.call_id, (int*) arg)) {
|
|
|
-+ fusion_call_destroy (dev, fusion_id, call.call_id);
|
|
|
-+ return -EFAULT;
|
|
|
-+ }
|
|
|
-+ return 0;
|
|
|
-+
|
|
|
-+ case _IOC_NR(FUSION_CALL_EXECUTE):
|
|
|
-+ if (copy_from_user (&execute, (FusionCallExecute*) arg, sizeof(execute)))
|
|
|
-+ return -EFAULT;
|
|
|
-+
|
|
|
-+ ret = fusion_call_execute (dev, fusionee, &execute);
|
|
|
-+ if (ret)
|
|
|
-+ return ret;
|
|
|
-+
|
|
|
-+ if (put_user (execute.ret_val, (int*) arg))
|
|
|
-+ return -EFAULT;
|
|
|
-+ return 0;
|
|
|
-+
|
|
|
-+ case _IOC_NR(FUSION_CALL_RETURN):
|
|
|
-+ if (copy_from_user (&call_ret, (FusionCallReturn*) arg, sizeof(call_ret)))
|
|
|
-+ return -EFAULT;
|
|
|
-+
|
|
|
-+ return fusion_call_return (dev, fusion_id, &call_ret);
|
|
|
-+
|
|
|
-+ case _IOC_NR(FUSION_CALL_DESTROY):
|
|
|
-+ if (get_user (id, (int*) arg))
|
|
|
-+ return -EFAULT;
|
|
|
-+
|
|
|
-+ return fusion_call_destroy (dev, fusion_id, id);
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ return -ENOSYS;
|
|
|
-+}
|
|
|
-+
|
|
|
-+static int
|
|
|
-+ref_ioctl (FusionDev *dev, Fusionee *fusionee,
|
|
|
-+ unsigned int cmd, unsigned long arg)
|
|
|
-+{
|
|
|
-+ int id;
|
|
|
-+ int ret;
|
|
|
-+ int refs;
|
|
|
-+ FusionRefWatch watch;
|
|
|
-+ FusionRefInherit inherit;
|
|
|
-+ FusionID fusion_id = fusionee_id( fusionee );
|
|
|
-+
|
|
|
-+ switch (_IOC_NR(cmd)) {
|
|
|
-+ case _IOC_NR(FUSION_REF_NEW):
|
|
|
-+ ret = fusion_ref_new (dev, &id);
|
|
|
-+ if (ret)
|
|
|
-+ return ret;
|
|
|
-+
|
|
|
-+ if (put_user (id, (int*) arg)) {
|
|
|
-+ fusion_ref_destroy (dev, id);
|
|
|
-+ return -EFAULT;
|
|
|
-+ }
|
|
|
-+ return 0;
|
|
|
-+
|
|
|
-+ case _IOC_NR(FUSION_REF_UP):
|
|
|
-+ if (get_user (id, (int*) arg))
|
|
|
-+ return -EFAULT;
|
|
|
-+
|
|
|
-+ return fusion_ref_up (dev, id, fusion_id);
|
|
|
-+
|
|
|
-+ case _IOC_NR(FUSION_REF_UP_GLOBAL):
|
|
|
-+ if (get_user (id, (int*) arg))
|
|
|
-+ return -EFAULT;
|
|
|
-+
|
|
|
-+ return fusion_ref_up (dev, id, 0);
|
|
|
-+
|
|
|
-+ case _IOC_NR(FUSION_REF_DOWN):
|
|
|
-+ if (get_user (id, (int*) arg))
|
|
|
-+ return -EFAULT;
|
|
|
-+
|
|
|
-+ return fusion_ref_down (dev, id, fusion_id);
|
|
|
-+
|
|
|
-+ case _IOC_NR(FUSION_REF_DOWN_GLOBAL):
|
|
|
-+ if (get_user (id, (int*) arg))
|
|
|
-+ return -EFAULT;
|
|
|
-+
|
|
|
-+ return fusion_ref_down (dev, id, 0);
|
|
|
-+
|
|
|
-+ case _IOC_NR(FUSION_REF_ZERO_LOCK):
|
|
|
-+ if (get_user (id, (int*) arg))
|
|
|
-+ return -EFAULT;
|
|
|
-+
|
|
|
-+ return fusion_ref_zero_lock (dev, id, fusion_id);
|
|
|
-+
|
|
|
-+ case _IOC_NR(FUSION_REF_ZERO_TRYLOCK):
|
|
|
-+ if (get_user (id, (int*) arg))
|
|
|
-+ return -EFAULT;
|
|
|
-+
|
|
|
-+ return fusion_ref_zero_trylock (dev, id, fusion_id);
|
|
|
-+
|
|
|
-+ case _IOC_NR(FUSION_REF_UNLOCK):
|
|
|
-+ if (get_user (id, (int*) arg))
|
|
|
-+ return -EFAULT;
|
|
|
-+
|
|
|
-+ return fusion_ref_zero_unlock (dev, id, fusion_id);
|
|
|
-+
|
|
|
-+ case _IOC_NR(FUSION_REF_STAT):
|
|
|
-+ if (get_user (id, (int*) arg))
|
|
|
-+ return -EFAULT;
|
|
|
-+
|
|
|
-+ ret = fusion_ref_stat (dev, id, &refs);
|
|
|
-+ if (ret)
|
|
|
-+ return ret;
|
|
|
-+
|
|
|
-+ return refs;
|
|
|
-+
|
|
|
-+ case _IOC_NR(FUSION_REF_WATCH):
|
|
|
-+ if (copy_from_user (&watch, (FusionRefWatch*) arg, sizeof(watch)))
|
|
|
-+ return -EFAULT;
|
|
|
-+
|
|
|
-+ return fusion_ref_watch (dev, watch.id, watch.call_id, watch.call_arg);
|
|
|
-+
|
|
|
-+ case _IOC_NR(FUSION_REF_INHERIT):
|
|
|
-+ if (copy_from_user (&inherit, (FusionRefInherit*) arg, sizeof(inherit)))
|
|
|
-+ return -EFAULT;
|
|
|
-+
|
|
|
-+ return fusion_ref_inherit (dev, inherit.id, inherit.from);
|
|
|
-+
|
|
|
-+ case _IOC_NR(FUSION_REF_DESTROY):
|
|
|
-+ if (get_user (id, (int*) arg))
|
|
|
-+ return -EFAULT;
|
|
|
-+
|
|
|
-+ return fusion_ref_destroy (dev, id);
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ return -ENOSYS;
|
|
|
-+}
|
|
|
-+
|
|
|
-+static int
|
|
|
-+skirmish_ioctl (FusionDev *dev, Fusionee *fusionee,
|
|
|
-+ unsigned int cmd, unsigned long arg)
|
|
|
-+{
|
|
|
-+ int id;
|
|
|
-+ int ret;
|
|
|
-+ int lock_count;
|
|
|
-+ FusionID fusion_id = fusionee_id( fusionee );
|
|
|
-+
|
|
|
-+ switch (_IOC_NR(cmd)) {
|
|
|
-+ case _IOC_NR(FUSION_SKIRMISH_NEW):
|
|
|
-+ ret = fusion_skirmish_new (dev, &id);
|
|
|
-+ if (ret)
|
|
|
-+ return ret;
|
|
|
-+
|
|
|
-+ if (put_user (id, (int*) arg)) {
|
|
|
-+ fusion_skirmish_destroy (dev, id);
|
|
|
-+ return -EFAULT;
|
|
|
-+ }
|
|
|
-+ return 0;
|
|
|
-+
|
|
|
-+ case _IOC_NR(FUSION_SKIRMISH_PREVAIL):
|
|
|
-+ if (get_user (id, (int*) arg))
|
|
|
-+ return -EFAULT;
|
|
|
-+
|
|
|
-+ return fusion_skirmish_prevail (dev, id, fusion_id);
|
|
|
-+
|
|
|
-+ case _IOC_NR(FUSION_SKIRMISH_SWOOP):
|
|
|
-+ if (get_user (id, (int*) arg))
|
|
|
-+ return -EFAULT;
|
|
|
-+
|
|
|
-+ return fusion_skirmish_swoop (dev, id, fusion_id);
|
|
|
-+
|
|
|
-+ case _IOC_NR(FUSION_SKIRMISH_DISMISS):
|
|
|
-+ if (get_user (id, (int*) arg))
|
|
|
-+ return -EFAULT;
|
|
|
-+
|
|
|
-+ return fusion_skirmish_dismiss (dev, id, fusion_id);
|
|
|
-+
|
|
|
-+ case _IOC_NR(FUSION_SKIRMISH_DESTROY):
|
|
|
-+ if (get_user (id, (int*) arg))
|
|
|
-+ return -EFAULT;
|
|
|
-+
|
|
|
-+ return fusion_skirmish_destroy (dev, id);
|
|
|
-+
|
|
|
-+ case _IOC_NR(FUSION_SKIRMISH_LOCK_COUNT):
|
|
|
-+ if (get_user (id, (int*) arg))
|
|
|
-+ return -EFAULT;
|
|
|
-+
|
|
|
-+ ret = fusion_skirmish_lock_count (dev, id, fusion_id, &lock_count);
|
|
|
-+ if (put_user(lock_count, ((int*)arg)+1))
|
|
|
-+ return -EFAULT;
|
|
|
-+
|
|
|
-+ return ret;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ return -ENOSYS;
|
|
|
-+}
|
|
|
-+
|
|
|
-+static int
|
|
|
-+property_ioctl (FusionDev *dev, Fusionee *fusionee,
|
|
|
-+ unsigned int cmd, unsigned long arg)
|
|
|
-+{
|
|
|
-+ int id;
|
|
|
-+ int ret;
|
|
|
-+ FusionID fusion_id = fusionee_id( fusionee );
|
|
|
-+
|
|
|
-+ switch (_IOC_NR(cmd)) {
|
|
|
-+ case _IOC_NR(FUSION_PROPERTY_NEW):
|
|
|
-+ ret = fusion_property_new (dev, &id);
|
|
|
-+ if (ret)
|
|
|
-+ return ret;
|
|
|
-+
|
|
|
-+ if (put_user (id, (int*) arg)) {
|
|
|
-+ fusion_property_destroy (dev, id);
|
|
|
-+ return -EFAULT;
|
|
|
-+ }
|
|
|
-+ return 0;
|
|
|
-+
|
|
|
-+ case _IOC_NR(FUSION_PROPERTY_LEASE):
|
|
|
-+ if (get_user (id, (int*) arg))
|
|
|
-+ return -EFAULT;
|
|
|
-+
|
|
|
-+ return fusion_property_lease (dev, id, fusion_id);
|
|
|
-+
|
|
|
-+ case _IOC_NR(FUSION_PROPERTY_PURCHASE):
|
|
|
-+ if (get_user (id, (int*) arg))
|
|
|
-+ return -EFAULT;
|
|
|
-+
|
|
|
-+ return fusion_property_purchase (dev, id, fusion_id);
|
|
|
-+
|
|
|
-+ case _IOC_NR(FUSION_PROPERTY_CEDE):
|
|
|
-+ if (get_user (id, (int*) arg))
|
|
|
-+ return -EFAULT;
|
|
|
-+
|
|
|
-+ return fusion_property_cede (dev, id, fusion_id);
|
|
|
-+
|
|
|
-+ case _IOC_NR(FUSION_PROPERTY_HOLDUP):
|
|
|
-+ if (get_user (id, (int*) arg))
|
|
|
-+ return -EFAULT;
|
|
|
-+
|
|
|
-+ return fusion_property_holdup (dev, id, fusionee);
|
|
|
-+
|
|
|
-+ case _IOC_NR(FUSION_PROPERTY_DESTROY):
|
|
|
-+ if (get_user (id, (int*) arg))
|
|
|
-+ return -EFAULT;
|
|
|
-+
|
|
|
-+ return fusion_property_destroy (dev, id);
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ return -ENOSYS;
|
|
|
-+}
|
|
|
-+
|
|
|
-+static int
|
|
|
-+reactor_ioctl (FusionDev *dev, Fusionee *fusionee,
|
|
|
-+ unsigned int cmd, unsigned long arg)
|
|
|
-+{
|
|
|
-+ int id;
|
|
|
-+ int ret;
|
|
|
-+ FusionReactorDispatch dispatch;
|
|
|
-+ FusionID fusion_id = fusionee_id( fusionee );
|
|
|
-+
|
|
|
-+ switch (_IOC_NR(cmd)) {
|
|
|
-+ case _IOC_NR(FUSION_REACTOR_NEW):
|
|
|
-+ ret = fusion_reactor_new (dev, &id);
|
|
|
-+ if (ret)
|
|
|
-+ return ret;
|
|
|
-+
|
|
|
-+ if (put_user (id, (int*) arg)) {
|
|
|
-+ fusion_reactor_destroy (dev, id);
|
|
|
-+ return -EFAULT;
|
|
|
-+ }
|
|
|
-+ return 0;
|
|
|
-+
|
|
|
-+ case _IOC_NR(FUSION_REACTOR_ATTACH):
|
|
|
-+ if (get_user (id, (int*) arg))
|
|
|
-+ return -EFAULT;
|
|
|
-+
|
|
|
-+ return fusion_reactor_attach (dev, id, fusion_id);
|
|
|
-+
|
|
|
-+ case _IOC_NR(FUSION_REACTOR_DETACH):
|
|
|
-+ if (get_user (id, (int*) arg))
|
|
|
-+ return -EFAULT;
|
|
|
-+
|
|
|
-+ return fusion_reactor_detach (dev, id, fusion_id);
|
|
|
-+
|
|
|
-+ case _IOC_NR(FUSION_REACTOR_DISPATCH):
|
|
|
-+ if (copy_from_user (&dispatch,
|
|
|
-+ (FusionReactorDispatch*) arg, sizeof(dispatch)))
|
|
|
-+ return -EFAULT;
|
|
|
-+
|
|
|
-+ if (dispatch.msg_size <= 0)
|
|
|
-+ return -EINVAL;
|
|
|
-+
|
|
|
-+ /* message data > 64k should be stored in shared memory */
|
|
|
-+ if (dispatch.msg_size > 0x10000)
|
|
|
-+ return -EMSGSIZE;
|
|
|
-+
|
|
|
-+ return fusion_reactor_dispatch (dev, dispatch.reactor_id,
|
|
|
-+ dispatch.self ? NULL : fusionee,
|
|
|
-+ dispatch.msg_size, dispatch.msg_data);
|
|
|
-+
|
|
|
-+ case _IOC_NR(FUSION_REACTOR_DESTROY):
|
|
|
-+ if (get_user (id, (int*) arg))
|
|
|
-+ return -EFAULT;
|
|
|
-+
|
|
|
-+ return fusion_reactor_destroy (dev, id);
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ return -ENOSYS;
|
|
|
-+}
|
|
|
-+
|
|
|
-+static int
|
|
|
-+shmpool_ioctl (FusionDev *dev, Fusionee *fusionee,
|
|
|
-+ unsigned int cmd, unsigned long arg)
|
|
|
-+{
|
|
|
-+ int id;
|
|
|
-+ int ret;
|
|
|
-+ FusionSHMPoolNew pool;
|
|
|
-+ FusionSHMPoolAttach attach;
|
|
|
-+ FusionSHMPoolDispatch dispatch;
|
|
|
-+ FusionID fusion_id = fusionee_id( fusionee );
|
|
|
-+
|
|
|
-+ switch (_IOC_NR(cmd)) {
|
|
|
-+ case _IOC_NR(FUSION_SHMPOOL_NEW):
|
|
|
-+ if (copy_from_user (&pool, (FusionSHMPoolNew*) arg, sizeof(pool)))
|
|
|
-+ return -EFAULT;
|
|
|
-+
|
|
|
-+ ret = fusion_shmpool_new (dev, &pool);
|
|
|
-+ if (ret)
|
|
|
-+ return ret;
|
|
|
-+
|
|
|
-+ if (copy_to_user ((FusionSHMPoolNew*) arg, &pool, sizeof(pool))) {
|
|
|
-+ fusion_shmpool_destroy (dev, pool.pool_id);
|
|
|
-+ return -EFAULT;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ return 0;
|
|
|
-+
|
|
|
-+ case _IOC_NR(FUSION_SHMPOOL_ATTACH):
|
|
|
-+ if (copy_from_user (&attach,
|
|
|
-+ (FusionSHMPoolAttach*) arg, sizeof(attach)))
|
|
|
-+ return -EFAULT;
|
|
|
-+
|
|
|
-+ ret = fusion_shmpool_attach (dev, &attach, fusion_id);
|
|
|
-+ if (ret)
|
|
|
-+ return ret;
|
|
|
-+
|
|
|
-+ if (copy_to_user ((FusionSHMPoolAttach*) arg, &attach, sizeof(attach))) {
|
|
|
-+ fusion_shmpool_detach (dev, attach.pool_id, fusion_id);
|
|
|
-+ return -EFAULT;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ return 0;
|
|
|
-+
|
|
|
-+ case _IOC_NR(FUSION_SHMPOOL_DETACH):
|
|
|
-+ if (get_user (id, (int*) arg))
|
|
|
-+ return -EFAULT;
|
|
|
-+
|
|
|
-+ return fusion_shmpool_detach (dev, id, fusion_id);
|
|
|
-+
|
|
|
-+ case _IOC_NR(FUSION_SHMPOOL_DISPATCH):
|
|
|
-+ if (copy_from_user (&dispatch,
|
|
|
-+ (FusionSHMPoolDispatch*) arg, sizeof(dispatch)))
|
|
|
-+ return -EFAULT;
|
|
|
-+
|
|
|
-+ return fusion_shmpool_dispatch (dev, &dispatch, fusionee);
|
|
|
-+
|
|
|
-+ case _IOC_NR(FUSION_SHMPOOL_DESTROY):
|
|
|
-+ if (get_user (id, (int*) arg))
|
|
|
-+ return -EFAULT;
|
|
|
-+
|
|
|
-+ return fusion_shmpool_destroy (dev, id);
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ return -ENOSYS;
|
|
|
-+}
|
|
|
-+
|
|
|
-+static int
|
|
|
-+fusion_ioctl (struct inode *inode, struct file *file,
|
|
|
-+ unsigned int cmd, unsigned long arg)
|
|
|
-+{
|
|
|
-+ Fusionee *fusionee = file->private_data;
|
|
|
-+ FusionDev *dev = fusion_devs[iminor(inode)];
|
|
|
-+
|
|
|
-+ DEBUG( "fusion_ioctl (0x%08x)\n", cmd );
|
|
|
-+
|
|
|
-+ switch (_IOC_TYPE(cmd)) {
|
|
|
-+ case FT_LOUNGE:
|
|
|
-+ return lounge_ioctl( file, dev, fusionee, cmd, arg );
|
|
|
-+
|
|
|
-+ case FT_MESSAGING:
|
|
|
-+ return messaging_ioctl( dev, fusionee, cmd, arg );
|
|
|
-+
|
|
|
-+ case FT_CALL:
|
|
|
-+ return call_ioctl( dev, fusionee, cmd, arg );
|
|
|
-+
|
|
|
-+ case FT_REF:
|
|
|
-+ return ref_ioctl( dev, fusionee, cmd, arg );
|
|
|
-+
|
|
|
-+ case FT_SKIRMISH:
|
|
|
-+ return skirmish_ioctl( dev, fusionee, cmd, arg );
|
|
|
-+
|
|
|
-+ case FT_PROPERTY:
|
|
|
-+ return property_ioctl( dev, fusionee, cmd, arg );
|
|
|
-+
|
|
|
-+ case FT_REACTOR:
|
|
|
-+ return reactor_ioctl( dev, fusionee, cmd, arg );
|
|
|
-+
|
|
|
-+ case FT_SHMPOOL:
|
|
|
-+ return shmpool_ioctl( dev, fusionee, cmd, arg );
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ return -ENOSYS;
|
|
|
-+}
|
|
|
-+
|
|
|
-+static int
|
|
|
-+fusion_mmap( struct file *file,
|
|
|
-+ struct vm_area_struct *vma )
|
|
|
-+{
|
|
|
-+ Fusionee *fusionee = file->private_data;
|
|
|
-+ FusionDev *dev = fusion_devs[iminor(file->f_dentry->d_inode)];
|
|
|
-+ unsigned int size;
|
|
|
-+
|
|
|
-+ if (vma->vm_pgoff != 0)
|
|
|
-+ return -EINVAL;
|
|
|
-+
|
|
|
-+ size = vma->vm_end - vma->vm_start;
|
|
|
-+ if (!size || size > PAGE_SIZE)
|
|
|
-+ return -EINVAL;
|
|
|
-+
|
|
|
-+ if (!dev->shared_area) {
|
|
|
-+ if (fusionee_id( fusionee ) != FUSION_ID_MASTER)
|
|
|
-+ return -EPERM;
|
|
|
-+
|
|
|
-+ dev->shared_area = get_zeroed_page( GFP_KERNEL );
|
|
|
-+ if (!dev->shared_area)
|
|
|
-+ return -ENOMEM;
|
|
|
-+
|
|
|
-+ SetPageReserved( virt_to_page(dev->shared_area) );
|
|
|
-+ }
|
|
|
-+
|
|
|
-+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 0)
|
|
|
-+ return remap_pfn_range( vma, vma->vm_start,
|
|
|
-+ virt_to_phys((void*)dev->shared_area) >> PAGE_SHIFT,
|
|
|
-+ PAGE_SIZE, vma->vm_page_prot );
|
|
|
-+#else
|
|
|
-+ return io_remap_page_range( vma->vm_start,
|
|
|
-+ virt_to_phys((void*)dev->shared_area),
|
|
|
-+ PAGE_SIZE, vma->vm_page_prot );
|
|
|
-+#endif
|
|
|
-+}
|
|
|
-+
|
|
|
-+static struct file_operations fusion_fops = {
|
|
|
-+ .owner = THIS_MODULE,
|
|
|
-+ .open = fusion_open,
|
|
|
-+ .flush = fusion_flush,
|
|
|
-+ .release = fusion_release,
|
|
|
-+ .read = fusion_read,
|
|
|
-+ .poll = fusion_poll,
|
|
|
-+ .ioctl = fusion_ioctl,
|
|
|
-+ .mmap = fusion_mmap
|
|
|
-+};
|
|
|
-+
|
|
|
-+/******************************************************************************/
|
|
|
-+
|
|
|
-+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 0)
|
|
|
-+static int __init
|
|
|
-+register_devices(void)
|
|
|
-+{
|
|
|
-+ int i;
|
|
|
-+
|
|
|
-+ if (register_chrdev (FUSION_MAJOR, "fusion", &fusion_fops)) {
|
|
|
-+ printk (KERN_ERR "fusion: unable to get major %d\n", FUSION_MAJOR);
|
|
|
-+ return -EIO;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 2)
|
|
|
-+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 13)
|
|
|
-+ fusion_class = class_create (THIS_MODULE, "fusion");
|
|
|
-+#else
|
|
|
-+ fusion_class = class_simple_create (THIS_MODULE, "fusion");
|
|
|
-+#endif
|
|
|
-+ if (IS_ERR(fusion_class)) {
|
|
|
-+ unregister_chrdev (FUSION_MAJOR, "fusion");
|
|
|
-+ return PTR_ERR(fusion_class);
|
|
|
-+ }
|
|
|
-+#endif
|
|
|
-+
|
|
|
-+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 18)
|
|
|
-+ devfs_mk_dir("fusion");
|
|
|
-+#endif
|
|
|
-+
|
|
|
-+ for (i=0; i<NUM_MINORS; i++) {
|
|
|
-+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 15)
|
|
|
-+ class_device_create (fusion_class,
|
|
|
-+ NULL,
|
|
|
-+ MKDEV(FUSION_MAJOR, i),
|
|
|
-+ NULL, "fusion%d", i);
|
|
|
-+#elif LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 13)
|
|
|
-+ class_device_create (fusion_class,
|
|
|
-+ MKDEV(FUSION_MAJOR, i),
|
|
|
-+ NULL, "fusion%d", i);
|
|
|
-+#elif LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 2)
|
|
|
-+ class_simple_device_add (fusion_class,
|
|
|
-+ MKDEV(FUSION_MAJOR, i),
|
|
|
-+ NULL, "fusion%d", i);
|
|
|
-+#endif
|
|
|
-+
|
|
|
-+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 18)
|
|
|
-+ devfs_mk_cdev (MKDEV(FUSION_MAJOR, i),
|
|
|
-+ S_IFCHR | S_IRUSR | S_IWUSR,
|
|
|
-+ "fusion/%d", i);
|
|
|
-+#endif
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ return 0;
|
|
|
-+}
|
|
|
-+#else
|
|
|
-+static int __init
|
|
|
-+register_devices(void)
|
|
|
-+{
|
|
|
-+ int i;
|
|
|
-+ char buf[16];
|
|
|
-+
|
|
|
-+ if (devfs_register_chrdev (FUSION_MAJOR, "fusion", &fusion_fops)) {
|
|
|
-+ printk (KERN_ERR "fusion: unable to get major %d\n", FUSION_MAJOR);
|
|
|
-+ return -EIO;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ for (i=0; i<NUM_MINORS; i++) {
|
|
|
-+ snprintf (buf, 16, "fusion/%d", i);
|
|
|
-+
|
|
|
-+ devfs_handles[i] = devfs_register (NULL, buf, DEVFS_FL_DEFAULT,
|
|
|
-+ FUSION_MAJOR, i,
|
|
|
-+ S_IFCHR | S_IRUSR | S_IWUSR,
|
|
|
-+ &fusion_fops, NULL);
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ return 0;
|
|
|
-+}
|
|
|
-+#endif
|
|
|
-+
|
|
|
-+int __init
|
|
|
-+fusion_init(void)
|
|
|
-+{
|
|
|
-+ int ret;
|
|
|
-+
|
|
|
-+ ret = register_devices();
|
|
|
-+ if (ret)
|
|
|
-+ return ret;
|
|
|
-+
|
|
|
-+ proc_fusion_dir = proc_mkdir ("fusion", NULL);
|
|
|
-+
|
|
|
-+ return 0;
|
|
|
-+}
|
|
|
-+
|
|
|
-+/******************************************************************************/
|
|
|
-+
|
|
|
-+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 0)
|
|
|
-+static void __exit
|
|
|
-+deregister_devices(void)
|
|
|
-+{
|
|
|
-+ int i;
|
|
|
-+
|
|
|
-+ unregister_chrdev (FUSION_MAJOR, "fusion");
|
|
|
-+
|
|
|
-+ for (i=0; i<NUM_MINORS; i++) {
|
|
|
-+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 2)
|
|
|
-+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 13)
|
|
|
-+ class_device_destroy (fusion_class, MKDEV(FUSION_MAJOR, i));
|
|
|
-+#else
|
|
|
-+ class_simple_device_remove (MKDEV(FUSION_MAJOR, i));
|
|
|
-+#endif
|
|
|
-+#endif
|
|
|
-+
|
|
|
-+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 18)
|
|
|
-+ devfs_remove ("fusion/%d", i);
|
|
|
-+#endif
|
|
|
-+ }
|
|
|
-+
|
|
|
-+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 2)
|
|
|
-+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 13)
|
|
|
-+ class_destroy (fusion_class);
|
|
|
-+#else
|
|
|
-+ class_simple_destroy (fusion_class);
|
|
|
-+#endif
|
|
|
-+#endif
|
|
|
-+
|
|
|
-+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 18)
|
|
|
-+ devfs_remove ("fusion");
|
|
|
-+#endif
|
|
|
-+}
|
|
|
-+#else
|
|
|
-+static void __exit
|
|
|
-+deregister_devices(void)
|
|
|
-+{
|
|
|
-+ int i;
|
|
|
-+
|
|
|
-+ devfs_unregister_chrdev (FUSION_MAJOR, "fusion");
|
|
|
-+
|
|
|
-+ for (i=0; i<NUM_MINORS; i++)
|
|
|
-+ devfs_unregister (devfs_handles[i]);
|
|
|
-+}
|
|
|
-+#endif
|
|
|
-+
|
|
|
-+void __exit
|
|
|
-+fusion_exit(void)
|
|
|
-+{
|
|
|
-+ deregister_devices();
|
|
|
-+
|
|
|
-+ remove_proc_entry ("fusion", NULL);
|
|
|
-+}
|
|
|
-+
|
|
|
-+module_init(fusion_init);
|
|
|
-+module_exit(fusion_exit);
|
|
|
-+
|
|
|
-diff -urN linux-2.6.22.1-0rig/drivers/char/fusion/fusiondev.h linux-2.6.22.1/drivers/char/fusion/fusiondev.h
|
|
|
---- linux-2.6.22.1-0rig/drivers/char/fusion/fusiondev.h 1970-01-01 01:00:00.000000000 +0100
|
|
|
-+++ linux-2.6.22.1/drivers/char/fusion/fusiondev.h 2006-08-04 18:28:01.000000000 +0200
|
|
|
-@@ -0,0 +1,83 @@
|
|
|
-+/*
|
|
|
-+ * Fusion Kernel Module
|
|
|
-+ *
|
|
|
-+ * (c) Copyright 2002-2003 Convergence GmbH
|
|
|
-+ *
|
|
|
-+ * Written by Denis Oliver Kropp <dok@directfb.org>
|
|
|
-+ *
|
|
|
-+ *
|
|
|
-+ * This program is free software; you can redistribute it and/or
|
|
|
-+ * modify it under the terms of the GNU General Public License
|
|
|
-+ * as published by the Free Software Foundation; either version
|
|
|
-+ * 2 of the License, or (at your option) any later version.
|
|
|
-+ */
|
|
|
-+
|
|
|
-+#ifndef __FUSIONDEV_H__
|
|
|
-+#define __FUSIONDEV_H__
|
|
|
-+
|
|
|
-+#include <linux/proc_fs.h>
|
|
|
-+
|
|
|
-+#include "entries.h"
|
|
|
-+#include "list.h"
|
|
|
-+
|
|
|
-+#define FUSION_ASSERT(exp) if (!(exp)) BUG()
|
|
|
-+#define FUSION_ASSUME(exp) if (!(exp)) printk( KERN_ERR "fusiondev: assumption '" #exp "' failed!\n" )
|
|
|
-+
|
|
|
-+typedef struct {
|
|
|
-+ int refs;
|
|
|
-+ int index;
|
|
|
-+
|
|
|
-+ struct semaphore enter_lock;
|
|
|
-+ int enter_ok;
|
|
|
-+ wait_queue_head_t enter_wait;
|
|
|
-+
|
|
|
-+ unsigned long shared_area;
|
|
|
-+
|
|
|
-+ struct proc_dir_entry *proc_dir;
|
|
|
-+
|
|
|
-+ struct {
|
|
|
-+ int property_lease_purchase;
|
|
|
-+ int property_cede;
|
|
|
-+
|
|
|
-+ int reactor_attach;
|
|
|
-+ int reactor_detach;
|
|
|
-+
|
|
|
-+ int ref_up;
|
|
|
-+ int ref_down;
|
|
|
-+
|
|
|
-+ int skirmish_prevail_swoop;
|
|
|
-+ int skirmish_dismiss;
|
|
|
-+
|
|
|
-+ int shmpool_attach;
|
|
|
-+ int shmpool_detach;
|
|
|
-+ } stat;
|
|
|
-+
|
|
|
-+ struct {
|
|
|
-+ int ids;
|
|
|
-+ FusionLink *list;
|
|
|
-+ struct semaphore lock;
|
|
|
-+ } call;
|
|
|
-+
|
|
|
-+ struct {
|
|
|
-+ int last_id;
|
|
|
-+ FusionLink *list;
|
|
|
-+ struct semaphore lock;
|
|
|
-+ wait_queue_head_t wait;
|
|
|
-+ } fusionee;
|
|
|
-+
|
|
|
-+ FusionEntries properties;
|
|
|
-+ FusionEntries reactor;
|
|
|
-+ FusionEntries ref;
|
|
|
-+ FusionEntries shmpool;
|
|
|
-+ FusionEntries skirmish;
|
|
|
-+} FusionDev;
|
|
|
-+
|
|
|
-+/*
|
|
|
-+ * Special version of interruptible_sleep_on() that unlocks the mutex
|
|
|
-+ * after adding the entry to the queue (just before schedule).
|
|
|
-+ */
|
|
|
-+void fusion_sleep_on (wait_queue_head_t *q,
|
|
|
-+ struct semaphore *lock,
|
|
|
-+ signed long *timeout_ms);
|
|
|
-+
|
|
|
-+#endif
|
|
|
-diff -urN linux-2.6.22.1-0rig/drivers/char/fusion/fusionee.c linux-2.6.22.1/drivers/char/fusion/fusionee.c
|
|
|
---- linux-2.6.22.1-0rig/drivers/char/fusion/fusionee.c 1970-01-01 01:00:00.000000000 +0100
|
|
|
-+++ linux-2.6.22.1/drivers/char/fusion/fusionee.c 2007-01-29 00:31:00.000000000 +0100
|
|
|
-@@ -0,0 +1,584 @@
|
|
|
-+/*
|
|
|
-+ * Fusion Kernel Module
|
|
|
-+ *
|
|
|
-+ * (c) Copyright 2002-2003 Convergence GmbH
|
|
|
-+ *
|
|
|
-+ * Written by Denis Oliver Kropp <dok@directfb.org>
|
|
|
-+ *
|
|
|
-+ *
|
|
|
-+ * This program is free software; you can redistribute it and/or
|
|
|
-+ * modify it under the terms of the GNU General Public License
|
|
|
-+ * as published by the Free Software Foundation; either version
|
|
|
-+ * 2 of the License, or (at your option) any later version.
|
|
|
-+ */
|
|
|
-+
|
|
|
-+#ifdef HAVE_LINUX_CONFIG_H
|
|
|
-+#include <linux/config.h>
|
|
|
-+#endif
|
|
|
-+#include <linux/types.h>
|
|
|
-+#include <linux/kernel.h>
|
|
|
-+#include <linux/slab.h>
|
|
|
-+#include <linux/smp_lock.h>
|
|
|
-+#include <asm/uaccess.h>
|
|
|
-+
|
|
|
-+#include <linux/fusion.h>
|
|
|
-+
|
|
|
-+#include "call.h"
|
|
|
-+#include "fifo.h"
|
|
|
-+#include "list.h"
|
|
|
-+#include "fusiondev.h"
|
|
|
-+#include "fusionee.h"
|
|
|
-+#include "property.h"
|
|
|
-+#include "reactor.h"
|
|
|
-+#include "ref.h"
|
|
|
-+#include "skirmish.h"
|
|
|
-+#include "shmpool.h"
|
|
|
-+
|
|
|
-+#if 0
|
|
|
-+#define DEBUG(x...) printk (KERN_DEBUG "Fusion: " x)
|
|
|
-+#else
|
|
|
-+#define DEBUG(x...) do {} while (0)
|
|
|
-+#endif
|
|
|
-+
|
|
|
-+struct __Fusion_Fusionee {
|
|
|
-+ FusionLink link;
|
|
|
-+
|
|
|
-+ struct semaphore lock;
|
|
|
-+
|
|
|
-+ FusionID id;
|
|
|
-+ int pid;
|
|
|
-+
|
|
|
-+ FusionFifo messages;
|
|
|
-+
|
|
|
-+ int rcv_total; /* Total number of messages received. */
|
|
|
-+ int snd_total; /* Total number of messages sent. */
|
|
|
-+
|
|
|
-+ wait_queue_head_t wait;
|
|
|
-+
|
|
|
-+ bool force_slave;
|
|
|
-+};
|
|
|
-+
|
|
|
-+typedef struct {
|
|
|
-+ FusionLink link;
|
|
|
-+
|
|
|
-+ FusionMessageType type;
|
|
|
-+ FusionID id;
|
|
|
-+ int size;
|
|
|
-+ void *data;
|
|
|
-+} Message;
|
|
|
-+
|
|
|
-+/******************************************************************************/
|
|
|
-+
|
|
|
-+static int lookup_fusionee (FusionDev *dev, FusionID id, Fusionee **ret_fusionee);
|
|
|
-+static int lock_fusionee (FusionDev *dev, FusionID id, Fusionee **ret_fusionee);
|
|
|
-+static void unlock_fusionee (Fusionee *fusionee);
|
|
|
-+
|
|
|
-+/******************************************************************************/
|
|
|
-+
|
|
|
-+static int
|
|
|
-+fusionees_read_proc(char *buf, char **start, off_t offset,
|
|
|
-+ int len, int *eof, void *private)
|
|
|
-+{
|
|
|
-+ FusionLink *l;
|
|
|
-+ FusionDev *dev = private;
|
|
|
-+ int written = 0;
|
|
|
-+
|
|
|
-+ if (down_interruptible (&dev->fusionee.lock))
|
|
|
-+ return -EINTR;
|
|
|
-+
|
|
|
-+ fusion_list_foreach (l, dev->fusionee.list) {
|
|
|
-+ Fusionee *fusionee = (Fusionee*) l;
|
|
|
-+
|
|
|
-+ written += sprintf(buf+written, "(%5d) 0x%08lx (%4d messages waiting, %7d received, %7d sent)\n",
|
|
|
-+ fusionee->pid, fusionee->id, fusionee->messages.count, fusionee->rcv_total, fusionee->snd_total);
|
|
|
-+ if (written < offset) {
|
|
|
-+ offset -= written;
|
|
|
-+ written = 0;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ if (written >= len)
|
|
|
-+ break;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ up (&dev->fusionee.lock);
|
|
|
-+
|
|
|
-+ *start = buf + offset;
|
|
|
-+ written -= offset;
|
|
|
-+ if (written > len) {
|
|
|
-+ *eof = 0;
|
|
|
-+ return len;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ *eof = 1;
|
|
|
-+ return(written<0) ? 0 : written;
|
|
|
-+}
|
|
|
-+
|
|
|
-+int
|
|
|
-+fusionee_init (FusionDev *dev)
|
|
|
-+{
|
|
|
-+ init_waitqueue_head (&dev->fusionee.wait);
|
|
|
-+
|
|
|
-+ init_MUTEX (&dev->fusionee.lock);
|
|
|
-+
|
|
|
-+ create_proc_read_entry("fusionees", 0, dev->proc_dir,
|
|
|
-+ fusionees_read_proc, dev);
|
|
|
-+
|
|
|
-+ return 0;
|
|
|
-+}
|
|
|
-+
|
|
|
-+void
|
|
|
-+fusionee_deinit (FusionDev *dev)
|
|
|
-+{
|
|
|
-+ FusionLink *l;
|
|
|
-+
|
|
|
-+ down (&dev->fusionee.lock);
|
|
|
-+
|
|
|
-+ remove_proc_entry ("fusionees", dev->proc_dir);
|
|
|
-+
|
|
|
-+ l = dev->fusionee.list;
|
|
|
-+ while (l) {
|
|
|
-+ FusionLink *next = l->next;
|
|
|
-+ Fusionee *fusionee = (Fusionee *) l;
|
|
|
-+
|
|
|
-+ while (fusionee->messages.count) {
|
|
|
-+ Message *message = (Message*) fusion_fifo_get (&fusionee->messages);
|
|
|
-+
|
|
|
-+ kfree (message);
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ kfree (fusionee);
|
|
|
-+
|
|
|
-+ l = next;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ up (&dev->fusionee.lock);
|
|
|
-+}
|
|
|
-+
|
|
|
-+/******************************************************************************/
|
|
|
-+
|
|
|
-+int
|
|
|
-+fusionee_new( FusionDev *dev,
|
|
|
-+ bool force_slave,
|
|
|
-+ Fusionee **ret_fusionee )
|
|
|
-+{
|
|
|
-+ Fusionee *fusionee;
|
|
|
-+
|
|
|
-+ fusionee = kmalloc (sizeof(Fusionee), GFP_KERNEL);
|
|
|
-+ if (!fusionee)
|
|
|
-+ return -ENOMEM;
|
|
|
-+
|
|
|
-+ memset (fusionee, 0, sizeof(Fusionee));
|
|
|
-+
|
|
|
-+ if (down_interruptible (&dev->fusionee.lock)) {
|
|
|
-+ kfree (fusionee);
|
|
|
-+ return -EINTR;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ fusionee->pid = current->pid;
|
|
|
-+ fusionee->force_slave = force_slave;
|
|
|
-+
|
|
|
-+ init_MUTEX (&fusionee->lock);
|
|
|
-+
|
|
|
-+ init_waitqueue_head (&fusionee->wait);
|
|
|
-+
|
|
|
-+ fusion_list_prepend (&dev->fusionee.list, &fusionee->link);
|
|
|
-+
|
|
|
-+ up (&dev->fusionee.lock);
|
|
|
-+
|
|
|
-+ *ret_fusionee = fusionee;
|
|
|
-+
|
|
|
-+ return 0;
|
|
|
-+}
|
|
|
-+
|
|
|
-+int
|
|
|
-+fusionee_enter( FusionDev *dev,
|
|
|
-+ FusionEnter *enter,
|
|
|
-+ Fusionee *fusionee )
|
|
|
-+{
|
|
|
-+ if (enter->api.major != FUSION_API_MAJOR || enter->api.minor > FUSION_API_MINOR)
|
|
|
-+ return -ENOPROTOOPT;
|
|
|
-+
|
|
|
-+ if (down_interruptible( &dev->enter_lock ))
|
|
|
-+ return -EINTR;
|
|
|
-+
|
|
|
-+ if (dev->fusionee.last_id || fusionee->force_slave) {
|
|
|
-+ while (!dev->enter_ok) {
|
|
|
-+ fusion_sleep_on( &dev->enter_wait, &dev->enter_lock, NULL );
|
|
|
-+
|
|
|
-+ if (signal_pending(current))
|
|
|
-+ return -EINTR;
|
|
|
-+
|
|
|
-+ if (down_interruptible( &dev->enter_lock ))
|
|
|
-+ return -EINTR;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ FUSION_ASSERT( dev->fusionee.last_id != 0 );
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ fusionee->id = ++dev->fusionee.last_id;
|
|
|
-+
|
|
|
-+ up( &dev->enter_lock );
|
|
|
-+
|
|
|
-+ enter->fusion_id = fusionee->id;
|
|
|
-+
|
|
|
-+ return 0;
|
|
|
-+}
|
|
|
-+
|
|
|
-+int
|
|
|
-+fusionee_fork( FusionDev *dev,
|
|
|
-+ FusionFork *fork,
|
|
|
-+ Fusionee *fusionee )
|
|
|
-+{
|
|
|
-+ int ret;
|
|
|
-+
|
|
|
-+ ret = fusion_shmpool_fork_all( dev, fusionee->id, fork->fusion_id );
|
|
|
-+ if (ret)
|
|
|
-+ return ret;
|
|
|
-+
|
|
|
-+ ret = fusion_reactor_fork_all( dev, fusionee->id, fork->fusion_id );
|
|
|
-+ if (ret)
|
|
|
-+ return ret;
|
|
|
-+
|
|
|
-+ ret = fusion_ref_fork_all_local( dev, fusionee->id, fork->fusion_id );
|
|
|
-+ if (ret)
|
|
|
-+ return ret;
|
|
|
-+
|
|
|
-+ fork->fusion_id = fusionee->id;
|
|
|
-+
|
|
|
-+ return 0;
|
|
|
-+}
|
|
|
-+
|
|
|
-+int
|
|
|
-+fusionee_send_message (FusionDev *dev,
|
|
|
-+ Fusionee *sender,
|
|
|
-+ FusionID recipient,
|
|
|
-+ FusionMessageType msg_type,
|
|
|
-+ int msg_id,
|
|
|
-+ int msg_size,
|
|
|
-+ const void *msg_data)
|
|
|
-+{
|
|
|
-+ int ret;
|
|
|
-+ Message *message;
|
|
|
-+ Fusionee *fusionee;
|
|
|
-+
|
|
|
-+ DEBUG( "fusionee_send_message (%d -> %d, type %d, id %d, size %d)\n",
|
|
|
-+ fusionee->id, recipient, msg_type, msg_id, msg_size );
|
|
|
-+
|
|
|
-+ ret = lookup_fusionee (dev, recipient, &fusionee);
|
|
|
-+ if (ret)
|
|
|
-+ return ret;
|
|
|
-+
|
|
|
-+ if (down_interruptible (&fusionee->lock)) {
|
|
|
-+ up (&dev->fusionee.lock);
|
|
|
-+ return -EINTR;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ if (sender && sender != fusionee) {
|
|
|
-+ if (down_interruptible (&sender->lock)) {
|
|
|
-+ unlock_fusionee (fusionee);
|
|
|
-+ up (&dev->fusionee.lock);
|
|
|
-+ return -EINTR;
|
|
|
-+ }
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ up (&dev->fusionee.lock);
|
|
|
-+
|
|
|
-+
|
|
|
-+ message = kmalloc (sizeof(Message) + msg_size, GFP_KERNEL);
|
|
|
-+ if (!message) {
|
|
|
-+ if (sender && sender != fusionee)
|
|
|
-+ unlock_fusionee (sender);
|
|
|
-+ unlock_fusionee (fusionee);
|
|
|
-+ return -ENOMEM;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ message->data = message + 1;
|
|
|
-+
|
|
|
-+ if (msg_type == FMT_CALL || msg_type == FMT_SHMPOOL)
|
|
|
-+ memcpy (message->data, msg_data, msg_size);
|
|
|
-+ else if (copy_from_user (message->data, msg_data, msg_size)) {
|
|
|
-+ kfree (message);
|
|
|
-+ if (sender && sender != fusionee)
|
|
|
-+ unlock_fusionee (sender);
|
|
|
-+ unlock_fusionee (fusionee);
|
|
|
-+ return -EFAULT;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ message->type = msg_type;
|
|
|
-+ message->id = msg_id;
|
|
|
-+ message->size = msg_size;
|
|
|
-+
|
|
|
-+ fusion_fifo_put (&fusionee->messages, &message->link);
|
|
|
-+
|
|
|
-+ fusionee->rcv_total++;
|
|
|
-+ if (sender)
|
|
|
-+ sender->snd_total++;
|
|
|
-+
|
|
|
-+ wake_up_interruptible_all (&fusionee->wait);
|
|
|
-+
|
|
|
-+ if (sender && sender != fusionee)
|
|
|
-+ unlock_fusionee (sender);
|
|
|
-+
|
|
|
-+ unlock_fusionee (fusionee);
|
|
|
-+
|
|
|
-+ return 0;
|
|
|
-+}
|
|
|
-+
|
|
|
-+int
|
|
|
-+fusionee_get_messages (FusionDev *dev,
|
|
|
-+ Fusionee *fusionee,
|
|
|
-+ void *buf,
|
|
|
-+ int buf_size,
|
|
|
-+ bool block)
|
|
|
-+{
|
|
|
-+ int written = 0;
|
|
|
-+
|
|
|
-+ if (down_interruptible (&fusionee->lock))
|
|
|
-+ return -EINTR;
|
|
|
-+
|
|
|
-+ while (!fusionee->messages.count) {
|
|
|
-+ if (!block) {
|
|
|
-+ unlock_fusionee (fusionee);
|
|
|
-+ return -EAGAIN;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ fusion_sleep_on (&fusionee->wait, &fusionee->lock, 0);
|
|
|
-+
|
|
|
-+ if (signal_pending(current))
|
|
|
-+ return -EINTR;
|
|
|
-+
|
|
|
-+ if (down_interruptible (&fusionee->lock))
|
|
|
-+ return -EINTR;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ while (fusionee->messages.count) {
|
|
|
-+ FusionReadMessage header;
|
|
|
-+ Message *message = (Message*) fusionee->messages.first;
|
|
|
-+ int bytes = message->size + sizeof(header);
|
|
|
-+
|
|
|
-+ if (bytes > buf_size) {
|
|
|
-+ if (!written) {
|
|
|
-+ unlock_fusionee (fusionee);
|
|
|
-+ return -EMSGSIZE;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ break;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ header.msg_type = message->type;
|
|
|
-+ header.msg_id = message->id;
|
|
|
-+ header.msg_size = message->size;
|
|
|
-+
|
|
|
-+ if (copy_to_user (buf, &header, sizeof(header)) ||
|
|
|
-+ copy_to_user (buf + sizeof(header), message->data, message->size)) {
|
|
|
-+ unlock_fusionee (fusionee);
|
|
|
-+ return -EFAULT;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ written += bytes;
|
|
|
-+ buf += bytes;
|
|
|
-+ buf_size -= bytes;
|
|
|
-+
|
|
|
-+ fusion_fifo_get (&fusionee->messages);
|
|
|
-+
|
|
|
-+ kfree (message);
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ unlock_fusionee (fusionee);
|
|
|
-+
|
|
|
-+ return written;
|
|
|
-+}
|
|
|
-+
|
|
|
-+unsigned int
|
|
|
-+fusionee_poll (FusionDev *dev,
|
|
|
-+ Fusionee *fusionee,
|
|
|
-+ struct file *file,
|
|
|
-+ poll_table *wait)
|
|
|
-+{
|
|
|
-+ int ret;
|
|
|
-+ FusionID id = fusionee->id;
|
|
|
-+
|
|
|
-+ poll_wait (file, &fusionee->wait, wait);
|
|
|
-+
|
|
|
-+
|
|
|
-+ ret = lock_fusionee (dev, id, &fusionee);
|
|
|
-+ if (ret)
|
|
|
-+ return POLLERR;
|
|
|
-+
|
|
|
-+ if (fusionee->messages.count) {
|
|
|
-+ unlock_fusionee (fusionee);
|
|
|
-+
|
|
|
-+ return POLLIN | POLLRDNORM;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ unlock_fusionee (fusionee);
|
|
|
-+
|
|
|
-+ return 0;
|
|
|
-+}
|
|
|
-+
|
|
|
-+int
|
|
|
-+fusionee_kill (FusionDev *dev,
|
|
|
-+ Fusionee *fusionee,
|
|
|
-+ FusionID target,
|
|
|
-+ int signal,
|
|
|
-+ int timeout_ms)
|
|
|
-+{
|
|
|
-+ long timeout = -1;
|
|
|
-+
|
|
|
-+ while (true) {
|
|
|
-+ FusionLink *l;
|
|
|
-+ int killed = 0;
|
|
|
-+
|
|
|
-+ if (down_interruptible (&dev->fusionee.lock))
|
|
|
-+ return -EINTR;
|
|
|
-+
|
|
|
-+ fusion_list_foreach (l, dev->fusionee.list) {
|
|
|
-+ Fusionee *f = (Fusionee*) l;
|
|
|
-+
|
|
|
-+ if (f != fusionee && (!target || target == f->id)) {
|
|
|
-+ kill_proc (f->pid, signal, 0);
|
|
|
-+ killed++;
|
|
|
-+ }
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ if (!killed || timeout_ms < 0) {
|
|
|
-+ up (&dev->fusionee.lock);
|
|
|
-+ break;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ if (timeout_ms) {
|
|
|
-+ switch (timeout) {
|
|
|
-+ case 0: /* timed out */
|
|
|
-+ up (&dev->fusionee.lock);
|
|
|
-+ return -ETIMEDOUT;
|
|
|
-+
|
|
|
-+ case -1: /* setup timeout */
|
|
|
-+ timeout = (timeout_ms * HZ + 500) / 1000;
|
|
|
-+ if (!timeout)
|
|
|
-+ timeout = 1;
|
|
|
-+
|
|
|
-+ /* fall through */
|
|
|
-+
|
|
|
-+ default:
|
|
|
-+ fusion_sleep_on (&dev->fusionee.wait,
|
|
|
-+ &dev->fusionee.lock, &timeout);
|
|
|
-+ break;
|
|
|
-+ }
|
|
|
-+ }
|
|
|
-+ else
|
|
|
-+ fusion_sleep_on (&dev->fusionee.wait, &dev->fusionee.lock, NULL);
|
|
|
-+
|
|
|
-+ if (signal_pending(current))
|
|
|
-+ return -EINTR;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ return 0;
|
|
|
-+}
|
|
|
-+
|
|
|
-+void
|
|
|
-+fusionee_destroy (FusionDev *dev,
|
|
|
-+ Fusionee *fusionee)
|
|
|
-+{
|
|
|
-+ /* Lock list. */
|
|
|
-+ down (&dev->fusionee.lock);
|
|
|
-+
|
|
|
-+ /* Lock fusionee. */
|
|
|
-+ down (&fusionee->lock);
|
|
|
-+
|
|
|
-+ /* Remove from list. */
|
|
|
-+ fusion_list_remove (&dev->fusionee.list, &fusionee->link);
|
|
|
-+
|
|
|
-+ /* Wake up waiting killer. */
|
|
|
-+ wake_up_interruptible_all (&dev->fusionee.wait);
|
|
|
-+
|
|
|
-+ /* Unlock list. */
|
|
|
-+ up (&dev->fusionee.lock);
|
|
|
-+
|
|
|
-+
|
|
|
-+ /* Release locks, references, ... */
|
|
|
-+ fusion_call_destroy_all (dev, fusionee->id);
|
|
|
-+ fusion_skirmish_dismiss_all (dev, fusionee->id);
|
|
|
-+ fusion_reactor_detach_all (dev, fusionee->id);
|
|
|
-+ fusion_property_cede_all (dev, fusionee->id);
|
|
|
-+ fusion_ref_clear_all_local (dev, fusionee->id);
|
|
|
-+ fusion_shmpool_detach_all (dev, fusionee->id);
|
|
|
-+
|
|
|
-+ /* Free all pending messages. */
|
|
|
-+ while (fusionee->messages.count) {
|
|
|
-+ Message *message = (Message*) fusion_fifo_get (&fusionee->messages);
|
|
|
-+
|
|
|
-+ kfree (message);
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ /* Unlock fusionee. */
|
|
|
-+ up (&fusionee->lock);
|
|
|
-+
|
|
|
-+
|
|
|
-+ /* Free fusionee data. */
|
|
|
-+ kfree (fusionee);
|
|
|
-+}
|
|
|
-+
|
|
|
-+FusionID
|
|
|
-+fusionee_id( const Fusionee *fusionee )
|
|
|
-+{
|
|
|
-+ return fusionee->id;
|
|
|
-+}
|
|
|
-+
|
|
|
-+/******************************************************************************/
|
|
|
-+
|
|
|
-+static int
|
|
|
-+lookup_fusionee (FusionDev *dev,
|
|
|
-+ FusionID id,
|
|
|
-+ Fusionee **ret_fusionee)
|
|
|
-+{
|
|
|
-+ FusionLink *l;
|
|
|
-+
|
|
|
-+ if (down_interruptible (&dev->fusionee.lock))
|
|
|
-+ return -EINTR;
|
|
|
-+
|
|
|
-+ fusion_list_foreach (l, dev->fusionee.list) {
|
|
|
-+ Fusionee *fusionee = (Fusionee *) l;
|
|
|
-+
|
|
|
-+ if (fusionee->id == id) {
|
|
|
-+ *ret_fusionee = fusionee;
|
|
|
-+ return 0;
|
|
|
-+ }
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ up (&dev->fusionee.lock);
|
|
|
-+
|
|
|
-+ return -EINVAL;
|
|
|
-+}
|
|
|
-+
|
|
|
-+static int
|
|
|
-+lock_fusionee (FusionDev *dev,
|
|
|
-+ FusionID id,
|
|
|
-+ Fusionee **ret_fusionee)
|
|
|
-+{
|
|
|
-+ int ret;
|
|
|
-+ Fusionee *fusionee;
|
|
|
-+
|
|
|
-+ ret = lookup_fusionee (dev, id, &fusionee);
|
|
|
-+ if (ret)
|
|
|
-+ return ret;
|
|
|
-+
|
|
|
-+ fusion_list_move_to_front (&dev->fusionee.list, &fusionee->link);
|
|
|
-+
|
|
|
-+ if (down_interruptible (&fusionee->lock)) {
|
|
|
-+ up (&dev->fusionee.lock);
|
|
|
-+ return -EINTR;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ up (&dev->fusionee.lock);
|
|
|
-+
|
|
|
-+ *ret_fusionee = fusionee;
|
|
|
-+
|
|
|
-+ return 0;
|
|
|
-+}
|
|
|
-+
|
|
|
-+static void
|
|
|
-+unlock_fusionee (Fusionee *fusionee)
|
|
|
-+{
|
|
|
-+ up (&fusionee->lock);
|
|
|
-+}
|
|
|
-+
|
|
|
-diff -urN linux-2.6.22.1-0rig/drivers/char/fusion/fusionee.h linux-2.6.22.1/drivers/char/fusion/fusionee.h
|
|
|
---- linux-2.6.22.1-0rig/drivers/char/fusion/fusionee.h 1970-01-01 01:00:00.000000000 +0100
|
|
|
-+++ linux-2.6.22.1/drivers/char/fusion/fusionee.h 2007-01-23 22:19:25.000000000 +0100
|
|
|
-@@ -0,0 +1,75 @@
|
|
|
-+/*
|
|
|
-+ * Fusion Kernel Module
|
|
|
-+ *
|
|
|
-+ * (c) Copyright 2002-2003 Convergence GmbH
|
|
|
-+ *
|
|
|
-+ * Written by Denis Oliver Kropp <dok@directfb.org>
|
|
|
-+ *
|
|
|
-+ *
|
|
|
-+ * This program is free software; you can redistribute it and/or
|
|
|
-+ * modify it under the terms of the GNU General Public License
|
|
|
-+ * as published by the Free Software Foundation; either version
|
|
|
-+ * 2 of the License, or (at your option) any later version.
|
|
|
-+ */
|
|
|
-+
|
|
|
-+#ifndef __FUSIONEE_H__
|
|
|
-+#define __FUSIONEE_H__
|
|
|
-+
|
|
|
-+#include <linux/poll.h>
|
|
|
-+#include <linux/fusion.h>
|
|
|
-+
|
|
|
-+#include "fusiondev.h"
|
|
|
-+#include "types.h"
|
|
|
-+
|
|
|
-+/* module init/cleanup */
|
|
|
-+
|
|
|
-+int fusionee_init (FusionDev *dev);
|
|
|
-+void fusionee_deinit (FusionDev *dev);
|
|
|
-+
|
|
|
-+
|
|
|
-+/* internal functions */
|
|
|
-+
|
|
|
-+int fusionee_new (FusionDev *dev,
|
|
|
-+ bool force_slave,
|
|
|
-+ Fusionee **ret_fusionee);
|
|
|
-+
|
|
|
-+int fusionee_enter (FusionDev *dev,
|
|
|
-+ FusionEnter *enter,
|
|
|
-+ Fusionee *fusionee);
|
|
|
-+
|
|
|
-+int fusionee_fork (FusionDev *dev,
|
|
|
-+ FusionFork *fork,
|
|
|
-+ Fusionee *fusionee);
|
|
|
-+
|
|
|
-+int fusionee_send_message (FusionDev *dev,
|
|
|
-+ Fusionee *fusionee,
|
|
|
-+ FusionID recipient,
|
|
|
-+ FusionMessageType msg_type,
|
|
|
-+ int msg_id,
|
|
|
-+ int msg_size,
|
|
|
-+ const void *msg_data);
|
|
|
-+
|
|
|
-+int fusionee_get_messages (FusionDev *dev,
|
|
|
-+ Fusionee *fusionee,
|
|
|
-+ void *buf,
|
|
|
-+ int buf_size,
|
|
|
-+ bool block);
|
|
|
-+
|
|
|
-+unsigned
|
|
|
-+int fusionee_poll (FusionDev *dev,
|
|
|
-+ Fusionee *fusionee,
|
|
|
-+ struct file *file,
|
|
|
-+ poll_table *wait);
|
|
|
-+
|
|
|
-+int fusionee_kill (FusionDev *dev,
|
|
|
-+ Fusionee *fusionee,
|
|
|
-+ FusionID target,
|
|
|
-+ int signal,
|
|
|
-+ int timeout_ms);
|
|
|
-+
|
|
|
-+void fusionee_destroy (FusionDev *dev,
|
|
|
-+ Fusionee *fusionee);
|
|
|
-+
|
|
|
-+FusionID fusionee_id( const Fusionee *fusionee );
|
|
|
-+
|
|
|
-+#endif
|
|
|
-diff -urN linux-2.6.22.1-0rig/drivers/char/fusion/Kconfig linux-2.6.22.1/drivers/char/fusion/Kconfig
|
|
|
---- linux-2.6.22.1-0rig/drivers/char/fusion/Kconfig 1970-01-01 01:00:00.000000000 +0100
|
|
|
-+++ linux-2.6.22.1/drivers/char/fusion/Kconfig 2007-08-12 19:33:38.000000000 +0200
|
|
|
-@@ -0,0 +1,8 @@
|
|
|
-+config FUSION_DEVICE
|
|
|
-+ tristate "Fusion device for DirectFB"
|
|
|
-+ default m
|
|
|
-+ ---help---
|
|
|
-+ The fusion device is a software device allowing the DirectFB
|
|
|
-+ (Direct Frame Buffer) to support multiple applications
|
|
|
-+ It is safe to say N unless you need to run several DirectFB
|
|
|
-+ applications concurrently.
|
|
|
-diff -urN linux-2.6.22.1-0rig/drivers/char/fusion/list.c linux-2.6.22.1/drivers/char/fusion/list.c
|
|
|
---- linux-2.6.22.1-0rig/drivers/char/fusion/list.c 1970-01-01 01:00:00.000000000 +0100
|
|
|
-+++ linux-2.6.22.1/drivers/char/fusion/list.c 2003-06-16 19:47:03.000000000 +0200
|
|
|
-@@ -0,0 +1,62 @@
|
|
|
-+/*
|
|
|
-+ * Fusion Kernel Module
|
|
|
-+ *
|
|
|
-+ * (c) Copyright 2002-2003 Convergence GmbH
|
|
|
-+ *
|
|
|
-+ * Written by Denis Oliver Kropp <dok@directfb.org>
|
|
|
-+ *
|
|
|
-+ *
|
|
|
-+ * This program is free software; you can redistribute it and/or
|
|
|
-+ * modify it under the terms of the GNU General Public License
|
|
|
-+ * as published by the Free Software Foundation; either version
|
|
|
-+ * 2 of the License, or (at your option) any later version.
|
|
|
-+ */
|
|
|
-+
|
|
|
-+#include <linux/types.h>
|
|
|
-+
|
|
|
-+#include "list.h"
|
|
|
-+
|
|
|
-+void
|
|
|
-+fusion_list_prepend (FusionLink **list, FusionLink *link)
|
|
|
-+{
|
|
|
-+ link->prev = NULL;
|
|
|
-+ link->next = *list;
|
|
|
-+
|
|
|
-+ if (*list)
|
|
|
-+ (*list)->prev = link;
|
|
|
-+
|
|
|
-+ *list = link;
|
|
|
-+}
|
|
|
-+
|
|
|
-+void
|
|
|
-+fusion_list_remove (FusionLink **list, FusionLink *link)
|
|
|
-+{
|
|
|
-+ if (link->prev)
|
|
|
-+ link->prev->next = link->next;
|
|
|
-+ else
|
|
|
-+ *list = link->next;
|
|
|
-+
|
|
|
-+ if (link->next)
|
|
|
-+ link->next->prev = link->prev;
|
|
|
-+
|
|
|
-+ link->next = link->prev = NULL;
|
|
|
-+}
|
|
|
-+
|
|
|
-+void
|
|
|
-+fusion_list_move_to_front (FusionLink **list, FusionLink *link)
|
|
|
-+{
|
|
|
-+ if (*list == link)
|
|
|
-+ return;
|
|
|
-+
|
|
|
-+ link->prev->next = link->next;
|
|
|
-+
|
|
|
-+ if (link->next)
|
|
|
-+ link->next->prev = link->prev;
|
|
|
-+
|
|
|
-+ link->prev = NULL;
|
|
|
-+ link->next = *list;
|
|
|
-+
|
|
|
-+ (*list)->prev = link;
|
|
|
-+
|
|
|
-+ *list = link;
|
|
|
-+}
|
|
|
-diff -urN linux-2.6.22.1-0rig/drivers/char/fusion/list.h linux-2.6.22.1/drivers/char/fusion/list.h
|
|
|
---- linux-2.6.22.1-0rig/drivers/char/fusion/list.h 1970-01-01 01:00:00.000000000 +0100
|
|
|
-+++ linux-2.6.22.1/drivers/char/fusion/list.h 2004-08-17 19:24:36.000000000 +0200
|
|
|
-@@ -0,0 +1,39 @@
|
|
|
-+/*
|
|
|
-+ * Fusion Kernel Module
|
|
|
-+ *
|
|
|
-+ * (c) Copyright 2002-2003 Convergence GmbH
|
|
|
-+ *
|
|
|
-+ * Written by Denis Oliver Kropp <dok@directfb.org>
|
|
|
-+ *
|
|
|
-+ *
|
|
|
-+ * This program is free software; you can redistribute it and/or
|
|
|
-+ * modify it under the terms of the GNU General Public License
|
|
|
-+ * as published by the Free Software Foundation; either version
|
|
|
-+ * 2 of the License, or (at your option) any later version.
|
|
|
-+ */
|
|
|
-+
|
|
|
-+#ifndef __FUSION__LIST_H__
|
|
|
-+#define __FUSION__LIST_H__
|
|
|
-+
|
|
|
-+typedef struct _FusionLink {
|
|
|
-+ struct _FusionLink *next;
|
|
|
-+ struct _FusionLink *prev;
|
|
|
-+} FusionLink;
|
|
|
-+
|
|
|
-+void fusion_list_prepend (FusionLink **list, FusionLink *link);
|
|
|
-+void fusion_list_remove (FusionLink **list, FusionLink *link);
|
|
|
-+void fusion_list_move_to_front (FusionLink **list, FusionLink *link);
|
|
|
-+
|
|
|
-+
|
|
|
-+#define fusion_list_foreach(elem, list) \
|
|
|
-+ for (elem = (void*)(list); \
|
|
|
-+ elem; \
|
|
|
-+ elem = (void*)(((FusionLink*)(elem))->next))
|
|
|
-+
|
|
|
-+#define fusion_list_foreach_safe(elem, temp, list) \
|
|
|
-+ for (elem = (void*)(list), temp = ((elem) ? (void*)(((FusionLink*)(elem))->next) : NULL); \
|
|
|
-+ elem; \
|
|
|
-+ elem = (void*)(temp), temp = ((elem) ? (void*)(((FusionLink*)(elem))->next) : NULL))
|
|
|
-+
|
|
|
-+#endif /* __FUSION__LIST_H__ */
|
|
|
-+
|
|
|
-diff -urN linux-2.6.22.1-0rig/drivers/char/fusion/Makefile linux-2.6.22.1/drivers/char/fusion/Makefile
|
|
|
---- linux-2.6.22.1-0rig/drivers/char/fusion/Makefile 1970-01-01 01:00:00.000000000 +0100
|
|
|
-+++ linux-2.6.22.1/drivers/char/fusion/Makefile 2005-10-29 02:38:05.000000000 +0200
|
|
|
-@@ -0,0 +1,3 @@
|
|
|
-+obj-$(CONFIG_FUSION_DEVICE) += fusion.o
|
|
|
-+
|
|
|
-+fusion-y := call.o entries.o fifo.o fusiondev.o fusionee.o list.o property.o reactor.o ref.o skirmish.o shmpool.o
|
|
|
-diff -urN linux-2.6.22.1-0rig/drivers/char/fusion/property.c linux-2.6.22.1/drivers/char/fusion/property.c
|
|
|
---- linux-2.6.22.1-0rig/drivers/char/fusion/property.c 1970-01-01 01:00:00.000000000 +0100
|
|
|
-+++ linux-2.6.22.1/drivers/char/fusion/property.c 2007-01-20 05:03:01.000000000 +0100
|
|
|
-@@ -0,0 +1,340 @@
|
|
|
-+/*
|
|
|
-+ * Fusion Kernel Module
|
|
|
-+ *
|
|
|
-+ * (c) Copyright 2002-2003 Convergence GmbH
|
|
|
-+ *
|
|
|
-+ * Written by Denis Oliver Kropp <dok@directfb.org>
|
|
|
-+ *
|
|
|
-+ *
|
|
|
-+ * This program is free software; you can redistribute it and/or
|
|
|
-+ * modify it under the terms of the GNU General Public License
|
|
|
-+ * as published by the Free Software Foundation; either version
|
|
|
-+ * 2 of the License, or (at your option) any later version.
|
|
|
-+ */
|
|
|
-+
|
|
|
-+#ifdef HAVE_LINUX_CONFIG_H
|
|
|
-+#include <linux/config.h>
|
|
|
-+#endif
|
|
|
-+#include <linux/types.h>
|
|
|
-+#include <linux/kernel.h>
|
|
|
-+#include <linux/slab.h>
|
|
|
-+#include <linux/smp_lock.h>
|
|
|
-+#include <linux/sched.h>
|
|
|
-+
|
|
|
-+#ifndef yield
|
|
|
-+#define yield schedule
|
|
|
-+#endif
|
|
|
-+
|
|
|
-+#include <linux/fusion.h>
|
|
|
-+
|
|
|
-+#include "entries.h"
|
|
|
-+#include "fusiondev.h"
|
|
|
-+#include "fusionee.h"
|
|
|
-+#include "list.h"
|
|
|
-+#include "property.h"
|
|
|
-+
|
|
|
-+typedef enum {
|
|
|
-+ FUSION_PROPERTY_AVAILABLE = 0,
|
|
|
-+ FUSION_PROPERTY_LEASED,
|
|
|
-+ FUSION_PROPERTY_PURCHASED
|
|
|
-+} FusionPropertyState;
|
|
|
-+
|
|
|
-+typedef struct {
|
|
|
-+ FusionEntry entry;
|
|
|
-+
|
|
|
-+ FusionPropertyState state;
|
|
|
-+ int fusion_id; /* non-zero if leased/purchased */
|
|
|
-+ unsigned long purchase_stamp;
|
|
|
-+ int lock_pid;
|
|
|
-+ int count; /* lock counter */
|
|
|
-+} FusionProperty;
|
|
|
-+
|
|
|
-+static int
|
|
|
-+fusion_property_print( FusionEntry *entry,
|
|
|
-+ void *ctx,
|
|
|
-+ char *buf )
|
|
|
-+{
|
|
|
-+ FusionProperty *property = (FusionProperty*) entry;
|
|
|
-+
|
|
|
-+ if (property->state != FUSION_PROPERTY_AVAILABLE) {
|
|
|
-+ return sprintf( buf, "%s by 0x%08x (%d) %dx\n",
|
|
|
-+ property->state == FUSION_PROPERTY_LEASED ? "leased" : "purchased",
|
|
|
-+ property->fusion_id, property->lock_pid, property->count );
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ return sprintf( buf, "\n" );
|
|
|
-+}
|
|
|
-+
|
|
|
-+FUSION_ENTRY_CLASS( FusionProperty, property, NULL, NULL, fusion_property_print )
|
|
|
-+
|
|
|
-+/******************************************************************************/
|
|
|
-+
|
|
|
-+int
|
|
|
-+fusion_property_init( FusionDev *dev )
|
|
|
-+{
|
|
|
-+ fusion_entries_init( &dev->properties, &property_class, dev );
|
|
|
-+
|
|
|
-+ create_proc_read_entry( "properties", 0, dev->proc_dir,
|
|
|
-+ fusion_entries_read_proc, &dev->properties );
|
|
|
-+
|
|
|
-+ return 0;
|
|
|
-+}
|
|
|
-+
|
|
|
-+void
|
|
|
-+fusion_property_deinit( FusionDev *dev )
|
|
|
-+{
|
|
|
-+ remove_proc_entry( "properties", dev->proc_dir );
|
|
|
-+
|
|
|
-+ fusion_entries_deinit( &dev->properties );
|
|
|
-+}
|
|
|
-+
|
|
|
-+/******************************************************************************/
|
|
|
-+
|
|
|
-+int
|
|
|
-+fusion_property_new( FusionDev *dev, int *ret_id )
|
|
|
-+{
|
|
|
-+ return fusion_entry_create( &dev->properties, ret_id, NULL );
|
|
|
-+}
|
|
|
-+
|
|
|
-+int
|
|
|
-+fusion_property_lease( FusionDev *dev, int id, int fusion_id )
|
|
|
-+{
|
|
|
-+ int ret;
|
|
|
-+ FusionProperty *property;
|
|
|
-+ long timeout = -1;
|
|
|
-+
|
|
|
-+ dev->stat.property_lease_purchase++;
|
|
|
-+
|
|
|
-+ ret = fusion_property_lock( &dev->properties, id, false, &property );
|
|
|
-+ if (ret)
|
|
|
-+ return ret;
|
|
|
-+
|
|
|
-+ while (true) {
|
|
|
-+ switch (property->state) {
|
|
|
-+ case FUSION_PROPERTY_AVAILABLE:
|
|
|
-+ property->state = FUSION_PROPERTY_LEASED;
|
|
|
-+ property->fusion_id = fusion_id;
|
|
|
-+ property->lock_pid = current->pid;
|
|
|
-+ property->count = 1;
|
|
|
-+
|
|
|
-+ fusion_property_unlock( property );
|
|
|
-+ return 0;
|
|
|
-+
|
|
|
-+ case FUSION_PROPERTY_LEASED:
|
|
|
-+ if (property->lock_pid == current->pid) {
|
|
|
-+ property->count++;
|
|
|
-+
|
|
|
-+ fusion_property_unlock( property );
|
|
|
-+ return 0;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ ret = fusion_property_wait( property, NULL );
|
|
|
-+ if (ret)
|
|
|
-+ return ret;
|
|
|
-+
|
|
|
-+ break;
|
|
|
-+
|
|
|
-+ case FUSION_PROPERTY_PURCHASED:
|
|
|
-+ if (property->lock_pid == current->pid) {
|
|
|
-+ fusion_property_unlock( property );
|
|
|
-+ return -EIO;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ if (timeout == -1) {
|
|
|
-+ if (jiffies - property->purchase_stamp > HZ / 10) {
|
|
|
-+ fusion_property_unlock( property );
|
|
|
-+ return -EAGAIN;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ timeout = HZ / 10;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ ret = fusion_property_wait( property, &timeout );
|
|
|
-+ if (ret)
|
|
|
-+ return ret;
|
|
|
-+
|
|
|
-+ break;
|
|
|
-+
|
|
|
-+ default:
|
|
|
-+ BUG();
|
|
|
-+ }
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ BUG();
|
|
|
-+
|
|
|
-+ /* won't reach this */
|
|
|
-+ return -1;
|
|
|
-+}
|
|
|
-+
|
|
|
-+int
|
|
|
-+fusion_property_purchase( FusionDev *dev, int id, int fusion_id )
|
|
|
-+{
|
|
|
-+ int ret;
|
|
|
-+ FusionProperty *property;
|
|
|
-+ signed long timeout = -1;
|
|
|
-+
|
|
|
-+ dev->stat.property_lease_purchase++;
|
|
|
-+
|
|
|
-+ ret = fusion_property_lock( &dev->properties, id, false, &property );
|
|
|
-+ if (ret)
|
|
|
-+ return ret;
|
|
|
-+
|
|
|
-+ while (true) {
|
|
|
-+ switch (property->state) {
|
|
|
-+ case FUSION_PROPERTY_AVAILABLE:
|
|
|
-+ property->state = FUSION_PROPERTY_PURCHASED;
|
|
|
-+ property->fusion_id = fusion_id;
|
|
|
-+ property->purchase_stamp = jiffies;
|
|
|
-+ property->lock_pid = current->pid;
|
|
|
-+ property->count = 1;
|
|
|
-+
|
|
|
-+ fusion_property_notify( property, true );
|
|
|
-+
|
|
|
-+ fusion_property_unlock( property );
|
|
|
-+ return 0;
|
|
|
-+
|
|
|
-+ case FUSION_PROPERTY_LEASED:
|
|
|
-+ if (property->lock_pid == current->pid) {
|
|
|
-+ fusion_property_unlock( property );
|
|
|
-+ return -EIO;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ ret = fusion_property_wait( property, NULL );
|
|
|
-+ if (ret)
|
|
|
-+ return ret;
|
|
|
-+
|
|
|
-+ break;
|
|
|
-+
|
|
|
-+ case FUSION_PROPERTY_PURCHASED:
|
|
|
-+ if (property->lock_pid == current->pid) {
|
|
|
-+ property->count++;
|
|
|
-+
|
|
|
-+ fusion_property_unlock( property );
|
|
|
-+ return 0;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ if (timeout == -1) {
|
|
|
-+ if (jiffies - property->purchase_stamp > HZ) {
|
|
|
-+ fusion_property_unlock( property );
|
|
|
-+ return -EAGAIN;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ timeout = HZ;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ ret = fusion_property_wait( property, &timeout );
|
|
|
-+ if (ret)
|
|
|
-+ return ret;
|
|
|
-+
|
|
|
-+ break;
|
|
|
-+
|
|
|
-+ default:
|
|
|
-+ BUG();
|
|
|
-+ }
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ BUG();
|
|
|
-+
|
|
|
-+ /* won't reach this */
|
|
|
-+ return -1;
|
|
|
-+}
|
|
|
-+
|
|
|
-+int
|
|
|
-+fusion_property_cede( FusionDev *dev, int id, int fusion_id )
|
|
|
-+{
|
|
|
-+ int ret;
|
|
|
-+ FusionProperty *property;
|
|
|
-+ bool purchased;
|
|
|
-+
|
|
|
-+ dev->stat.property_cede++;
|
|
|
-+
|
|
|
-+ ret = fusion_property_lock( &dev->properties, id, false, &property );
|
|
|
-+ if (ret)
|
|
|
-+ return ret;
|
|
|
-+
|
|
|
-+ if (property->lock_pid != current->pid) {
|
|
|
-+ fusion_property_unlock( property );
|
|
|
-+ return -EIO;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ if (--property->count) {
|
|
|
-+ fusion_property_unlock( property );
|
|
|
-+ return 0;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ purchased = (property->state == FUSION_PROPERTY_PURCHASED);
|
|
|
-+
|
|
|
-+ property->state = FUSION_PROPERTY_AVAILABLE;
|
|
|
-+ property->fusion_id = 0;
|
|
|
-+ property->lock_pid = 0;
|
|
|
-+
|
|
|
-+ fusion_property_notify( property, true );
|
|
|
-+
|
|
|
-+ fusion_property_unlock( property );
|
|
|
-+
|
|
|
-+ if (purchased)
|
|
|
-+ yield();
|
|
|
-+
|
|
|
-+ return 0;
|
|
|
-+}
|
|
|
-+
|
|
|
-+int
|
|
|
-+fusion_property_holdup( FusionDev *dev, int id, Fusionee *fusionee )
|
|
|
-+{
|
|
|
-+ int ret;
|
|
|
-+ FusionProperty *property;
|
|
|
-+ FusionID fusion_id = fusionee_id( fusionee );
|
|
|
-+
|
|
|
-+ if (fusion_id > 1)
|
|
|
-+ return -EPERM;
|
|
|
-+
|
|
|
-+ ret = fusion_property_lock( &dev->properties, id, false, &property );
|
|
|
-+ if (ret)
|
|
|
-+ return ret;
|
|
|
-+
|
|
|
-+ if (property->state == FUSION_PROPERTY_PURCHASED) {
|
|
|
-+ if (property->fusion_id == fusion_id) {
|
|
|
-+ fusion_property_unlock( property );
|
|
|
-+ return -EIO;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ fusionee_kill( dev, fusionee, property->fusion_id, SIGKILL, -1 );
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ fusion_property_unlock( property );
|
|
|
-+
|
|
|
-+ return 0;
|
|
|
-+}
|
|
|
-+
|
|
|
-+int
|
|
|
-+fusion_property_destroy( FusionDev *dev, int id )
|
|
|
-+{
|
|
|
-+ return fusion_entry_destroy( &dev->properties, id );
|
|
|
-+}
|
|
|
-+
|
|
|
-+void
|
|
|
-+fusion_property_cede_all( FusionDev *dev, int fusion_id )
|
|
|
-+{
|
|
|
-+ FusionLink *l;
|
|
|
-+
|
|
|
-+ down( &dev->properties.lock );
|
|
|
-+
|
|
|
-+ fusion_list_foreach (l, dev->properties.list) {
|
|
|
-+ FusionProperty *property = (FusionProperty *) l;
|
|
|
-+
|
|
|
-+ down( &property->entry.lock );
|
|
|
-+
|
|
|
-+ if (property->fusion_id == fusion_id) {
|
|
|
-+ property->state = FUSION_PROPERTY_AVAILABLE;
|
|
|
-+ property->fusion_id = 0;
|
|
|
-+ property->lock_pid = 0;
|
|
|
-+
|
|
|
-+ wake_up_interruptible_all (&property->entry.wait);
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ up( &property->entry.lock );
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ up( &dev->properties.lock );
|
|
|
-+}
|
|
|
-+
|
|
|
-diff -urN linux-2.6.22.1-0rig/drivers/char/fusion/property.h linux-2.6.22.1/drivers/char/fusion/property.h
|
|
|
---- linux-2.6.22.1-0rig/drivers/char/fusion/property.h 1970-01-01 01:00:00.000000000 +0100
|
|
|
-+++ linux-2.6.22.1/drivers/char/fusion/property.h 2007-01-20 05:03:01.000000000 +0100
|
|
|
-@@ -0,0 +1,58 @@
|
|
|
-+/*
|
|
|
-+ * Fusion Kernel Module
|
|
|
-+ *
|
|
|
-+ * (c) Copyright 2002-2003 Convergence GmbH
|
|
|
-+ *
|
|
|
-+ * Written by Denis Oliver Kropp <dok@directfb.org>
|
|
|
-+ *
|
|
|
-+ *
|
|
|
-+ * This program is free software; you can redistribute it and/or
|
|
|
-+ * modify it under the terms of the GNU General Public License
|
|
|
-+ * as published by the Free Software Foundation; either version
|
|
|
-+ * 2 of the License, or (at your option) any later version.
|
|
|
-+ */
|
|
|
-+
|
|
|
-+#ifndef __FUSION__PROPERTY_H__
|
|
|
-+#define __FUSION__PROPERTY_H__
|
|
|
-+
|
|
|
-+#include "fusiondev.h"
|
|
|
-+#include "types.h"
|
|
|
-+
|
|
|
-+
|
|
|
-+/* module init/cleanup */
|
|
|
-+
|
|
|
-+int fusion_property_init (FusionDev *dev);
|
|
|
-+void fusion_property_deinit (FusionDev *dev);
|
|
|
-+
|
|
|
-+
|
|
|
-+/* public API */
|
|
|
-+
|
|
|
-+int fusion_property_new (FusionDev *dev,
|
|
|
-+ int *ret_id);
|
|
|
-+
|
|
|
-+int fusion_property_lease (FusionDev *dev,
|
|
|
-+ int id,
|
|
|
-+ int fusion_id);
|
|
|
-+
|
|
|
-+int fusion_property_purchase (FusionDev *dev,
|
|
|
-+ int id,
|
|
|
-+ int fusion_id);
|
|
|
-+
|
|
|
-+int fusion_property_cede (FusionDev *dev,
|
|
|
-+ int id,
|
|
|
-+ int fusion_id);
|
|
|
-+
|
|
|
-+int fusion_property_holdup (FusionDev *dev,
|
|
|
-+ int id,
|
|
|
-+ Fusionee *fusionee);
|
|
|
-+
|
|
|
-+int fusion_property_destroy (FusionDev *dev,
|
|
|
-+ int id);
|
|
|
-+
|
|
|
-+
|
|
|
-+/* internal functions */
|
|
|
-+
|
|
|
-+void fusion_property_cede_all (FusionDev *dev,
|
|
|
-+ int fusion_id);
|
|
|
-+
|
|
|
-+#endif
|
|
|
-diff -urN linux-2.6.22.1-0rig/drivers/char/fusion/reactor.c linux-2.6.22.1/drivers/char/fusion/reactor.c
|
|
|
---- linux-2.6.22.1-0rig/drivers/char/fusion/reactor.c 1970-01-01 01:00:00.000000000 +0100
|
|
|
-+++ linux-2.6.22.1/drivers/char/fusion/reactor.c 2007-01-20 05:03:01.000000000 +0100
|
|
|
-@@ -0,0 +1,367 @@
|
|
|
-+/*
|
|
|
-+ * Fusion Kernel Module
|
|
|
-+ *
|
|
|
-+ * (c) Copyright 2002-2003 Convergence GmbH
|
|
|
-+ *
|
|
|
-+ * Written by Denis Oliver Kropp <dok@directfb.org>
|
|
|
-+ *
|
|
|
-+ *
|
|
|
-+ * This program is free software; you can redistribute it and/or
|
|
|
-+ * modify it under the terms of the GNU General Public License
|
|
|
-+ * as published by the Free Software Foundation; either version
|
|
|
-+ * 2 of the License, or (at your option) any later version.
|
|
|
-+ */
|
|
|
-+
|
|
|
-+#ifdef HAVE_LINUX_CONFIG_H
|
|
|
-+#include <linux/config.h>
|
|
|
-+#endif
|
|
|
-+#include <linux/types.h>
|
|
|
-+#include <linux/kernel.h>
|
|
|
-+#include <linux/slab.h>
|
|
|
-+#include <linux/smp_lock.h>
|
|
|
-+#include <linux/sched.h>
|
|
|
-+
|
|
|
-+#include <linux/fusion.h>
|
|
|
-+
|
|
|
-+#include "fusiondev.h"
|
|
|
-+#include "fusionee.h"
|
|
|
-+#include "list.h"
|
|
|
-+#include "reactor.h"
|
|
|
-+
|
|
|
-+typedef struct {
|
|
|
-+ FusionLink link;
|
|
|
-+
|
|
|
-+ int fusion_id;
|
|
|
-+
|
|
|
-+ int count; /* number of attach calls */
|
|
|
-+} ReactorNode;
|
|
|
-+
|
|
|
-+typedef struct {
|
|
|
-+ FusionEntry entry;
|
|
|
-+
|
|
|
-+ FusionLink *nodes;
|
|
|
-+
|
|
|
-+ int dispatch_count;
|
|
|
-+
|
|
|
-+ bool destroyed;
|
|
|
-+} FusionReactor;
|
|
|
-+
|
|
|
-+/******************************************************************************/
|
|
|
-+
|
|
|
-+static int fork_node ( FusionReactor *reactor,
|
|
|
-+ FusionID fusion_id,
|
|
|
-+ FusionID from_id );
|
|
|
-+
|
|
|
-+static void free_all_nodes( FusionReactor *reactor );
|
|
|
-+
|
|
|
-+/******************************************************************************/
|
|
|
-+
|
|
|
-+static inline ReactorNode *
|
|
|
-+get_node (FusionReactor *reactor,
|
|
|
-+ FusionID fusion_id)
|
|
|
-+{
|
|
|
-+ ReactorNode *node;
|
|
|
-+
|
|
|
-+ fusion_list_foreach (node, reactor->nodes) {
|
|
|
-+ if (node->fusion_id == fusion_id)
|
|
|
-+ return node;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ return NULL;
|
|
|
-+}
|
|
|
-+
|
|
|
-+/******************************************************************************/
|
|
|
-+
|
|
|
-+static void
|
|
|
-+fusion_reactor_destruct( FusionEntry *entry,
|
|
|
-+ void *ctx )
|
|
|
-+{
|
|
|
-+ FusionReactor *reactor = (FusionReactor*) entry;
|
|
|
-+
|
|
|
-+ free_all_nodes( reactor );
|
|
|
-+}
|
|
|
-+
|
|
|
-+static int
|
|
|
-+fusion_reactor_print( FusionEntry *entry,
|
|
|
-+ void *ctx,
|
|
|
-+ char *buf )
|
|
|
-+{
|
|
|
-+ int num = 0;
|
|
|
-+ FusionReactor *reactor = (FusionReactor*) entry;
|
|
|
-+ FusionLink *node = reactor->nodes;
|
|
|
-+
|
|
|
-+ fusion_list_foreach (node, reactor->nodes) {
|
|
|
-+ num++;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ return sprintf( buf, "%5dx dispatch, %d nodes%s\n", reactor->dispatch_count, num,
|
|
|
-+ reactor->destroyed ? " DESTROYED" : "" );
|
|
|
-+}
|
|
|
-+
|
|
|
-+
|
|
|
-+FUSION_ENTRY_CLASS( FusionReactor, reactor, NULL,
|
|
|
-+ fusion_reactor_destruct, fusion_reactor_print )
|
|
|
-+
|
|
|
-+/******************************************************************************/
|
|
|
-+
|
|
|
-+int
|
|
|
-+fusion_reactor_init (FusionDev *dev)
|
|
|
-+{
|
|
|
-+ fusion_entries_init( &dev->reactor, &reactor_class, dev );
|
|
|
-+
|
|
|
-+ create_proc_read_entry( "reactors", 0, dev->proc_dir,
|
|
|
-+ fusion_entries_read_proc, &dev->reactor );
|
|
|
-+
|
|
|
-+ return 0;
|
|
|
-+}
|
|
|
-+
|
|
|
-+void
|
|
|
-+fusion_reactor_deinit (FusionDev *dev)
|
|
|
-+{
|
|
|
-+ remove_proc_entry ("reactors", dev->proc_dir);
|
|
|
-+
|
|
|
-+ fusion_entries_deinit( &dev->reactor );
|
|
|
-+}
|
|
|
-+
|
|
|
-+/******************************************************************************/
|
|
|
-+
|
|
|
-+int
|
|
|
-+fusion_reactor_new (FusionDev *dev, int *ret_id)
|
|
|
-+{
|
|
|
-+ return fusion_entry_create( &dev->reactor, ret_id, NULL );
|
|
|
-+}
|
|
|
-+
|
|
|
-+int
|
|
|
-+fusion_reactor_attach (FusionDev *dev, int id, FusionID fusion_id)
|
|
|
-+{
|
|
|
-+ int ret;
|
|
|
-+ ReactorNode *node;
|
|
|
-+ FusionReactor *reactor;
|
|
|
-+
|
|
|
-+ ret = fusion_reactor_lock( &dev->reactor, id, false, &reactor );
|
|
|
-+ if (ret)
|
|
|
-+ return ret;
|
|
|
-+
|
|
|
-+ if (reactor->destroyed) {
|
|
|
-+ fusion_reactor_unlock( reactor );
|
|
|
-+ return -EIDRM;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ dev->stat.reactor_attach++;
|
|
|
-+
|
|
|
-+ node = get_node (reactor, fusion_id);
|
|
|
-+ if (!node) {
|
|
|
-+ node = kmalloc (sizeof(ReactorNode), GFP_KERNEL);
|
|
|
-+ if (!node) {
|
|
|
-+ fusion_reactor_unlock( reactor );
|
|
|
-+ return -ENOMEM;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ node->fusion_id = fusion_id;
|
|
|
-+ node->count = 1;
|
|
|
-+
|
|
|
-+ fusion_list_prepend (&reactor->nodes, &node->link);
|
|
|
-+ }
|
|
|
-+ else
|
|
|
-+ node->count++;
|
|
|
-+
|
|
|
-+ fusion_reactor_unlock( reactor );
|
|
|
-+
|
|
|
-+ return 0;
|
|
|
-+}
|
|
|
-+
|
|
|
-+int
|
|
|
-+fusion_reactor_detach (FusionDev *dev, int id, FusionID fusion_id)
|
|
|
-+{
|
|
|
-+ int ret;
|
|
|
-+ ReactorNode *node;
|
|
|
-+ FusionReactor *reactor;
|
|
|
-+
|
|
|
-+ ret = fusion_reactor_lock( &dev->reactor, id, true, &reactor );
|
|
|
-+ if (ret)
|
|
|
-+ return ret;
|
|
|
-+
|
|
|
-+ dev->stat.reactor_detach++;
|
|
|
-+
|
|
|
-+ node = get_node (reactor, fusion_id);
|
|
|
-+ if (!node) {
|
|
|
-+ fusion_reactor_unlock( reactor );
|
|
|
-+ up( &dev->reactor.lock );
|
|
|
-+ return -EIO;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ if (! --node->count) {
|
|
|
-+ fusion_list_remove (&reactor->nodes, &node->link);
|
|
|
-+ kfree (node);
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ if (reactor->destroyed && !reactor->nodes)
|
|
|
-+ fusion_entry_destroy_locked( &dev->reactor, &reactor->entry );
|
|
|
-+ else
|
|
|
-+ fusion_reactor_unlock( reactor );
|
|
|
-+
|
|
|
-+ up( &dev->reactor.lock );
|
|
|
-+
|
|
|
-+ return 0;
|
|
|
-+}
|
|
|
-+
|
|
|
-+int
|
|
|
-+fusion_reactor_dispatch (FusionDev *dev, int id, Fusionee *fusionee,
|
|
|
-+ int msg_size, const void *msg_data)
|
|
|
-+{
|
|
|
-+ int ret;
|
|
|
-+ FusionLink *l;
|
|
|
-+ FusionReactor *reactor;
|
|
|
-+ FusionID fusion_id = fusionee ? fusionee_id( fusionee ) : 0;
|
|
|
-+
|
|
|
-+ ret = fusion_reactor_lock( &dev->reactor, id, false, &reactor );
|
|
|
-+ if (ret)
|
|
|
-+ return ret;
|
|
|
-+
|
|
|
-+ if (reactor->destroyed) {
|
|
|
-+ fusion_reactor_unlock( reactor );
|
|
|
-+ return -EIDRM;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ reactor->dispatch_count++;
|
|
|
-+
|
|
|
-+ fusion_list_foreach (l, reactor->nodes) {
|
|
|
-+ ReactorNode *node = (ReactorNode *) l;
|
|
|
-+
|
|
|
-+ if (node->fusion_id == fusion_id)
|
|
|
-+ continue;
|
|
|
-+
|
|
|
-+ fusionee_send_message (dev, fusionee, node->fusion_id, FMT_REACTOR,
|
|
|
-+ reactor->entry.id, msg_size, msg_data);
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ fusion_reactor_unlock( reactor );
|
|
|
-+
|
|
|
-+ return 0;
|
|
|
-+}
|
|
|
-+
|
|
|
-+int
|
|
|
-+fusion_reactor_destroy (FusionDev *dev, int id)
|
|
|
-+{
|
|
|
-+ int ret;
|
|
|
-+ FusionReactor *reactor;
|
|
|
-+
|
|
|
-+ ret = fusion_reactor_lock( &dev->reactor, id, true, &reactor );
|
|
|
-+ if (ret)
|
|
|
-+ return ret;
|
|
|
-+
|
|
|
-+ if (reactor->destroyed) {
|
|
|
-+ fusion_reactor_unlock( reactor );
|
|
|
-+ up( &dev->reactor.lock );
|
|
|
-+ return -EIDRM;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ reactor->destroyed = true;
|
|
|
-+
|
|
|
-+ if (!reactor->nodes)
|
|
|
-+ fusion_entry_destroy_locked( &dev->reactor, &reactor->entry );
|
|
|
-+ else
|
|
|
-+ fusion_reactor_unlock( reactor );
|
|
|
-+
|
|
|
-+ up( &dev->reactor.lock );
|
|
|
-+
|
|
|
-+ return 0;
|
|
|
-+}
|
|
|
-+
|
|
|
-+void
|
|
|
-+fusion_reactor_detach_all (FusionDev *dev, FusionID fusion_id)
|
|
|
-+{
|
|
|
-+ FusionLink *l, *n;
|
|
|
-+
|
|
|
-+ down (&dev->reactor.lock);
|
|
|
-+
|
|
|
-+ fusion_list_foreach_safe (l, n, dev->reactor.list) {
|
|
|
-+ ReactorNode *node;
|
|
|
-+ FusionReactor *reactor = (FusionReactor *) l;
|
|
|
-+
|
|
|
-+ down (&reactor->entry.lock);
|
|
|
-+
|
|
|
-+ fusion_list_foreach (node, reactor->nodes) {
|
|
|
-+ if (node->fusion_id == fusion_id) {
|
|
|
-+ fusion_list_remove (&reactor->nodes, &node->link);
|
|
|
-+ kfree (node);
|
|
|
-+ break;
|
|
|
-+ }
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ if (reactor->destroyed && !reactor->nodes)
|
|
|
-+ fusion_entry_destroy_locked( &dev->reactor, &reactor->entry );
|
|
|
-+ else
|
|
|
-+ up (&reactor->entry.lock);
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ up (&dev->reactor.lock);
|
|
|
-+}
|
|
|
-+
|
|
|
-+int
|
|
|
-+fusion_reactor_fork_all (FusionDev *dev, FusionID fusion_id, FusionID from_id)
|
|
|
-+{
|
|
|
-+ FusionLink *l;
|
|
|
-+ int ret = 0;
|
|
|
-+
|
|
|
-+ down (&dev->reactor.lock);
|
|
|
-+
|
|
|
-+ fusion_list_foreach (l, dev->reactor.list) {
|
|
|
-+ FusionReactor *reactor = (FusionReactor *) l;
|
|
|
-+
|
|
|
-+ ret = fork_node (reactor, fusion_id, from_id);
|
|
|
-+ if (ret)
|
|
|
-+ break;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ up (&dev->reactor.lock);
|
|
|
-+
|
|
|
-+ return ret;
|
|
|
-+}
|
|
|
-+
|
|
|
-+/******************************************************************************/
|
|
|
-+
|
|
|
-+static int
|
|
|
-+fork_node (FusionReactor *reactor, FusionID fusion_id, FusionID from_id)
|
|
|
-+{
|
|
|
-+ ReactorNode *node;
|
|
|
-+
|
|
|
-+ down (&reactor->entry.lock);
|
|
|
-+
|
|
|
-+ fusion_list_foreach (node, reactor->nodes) {
|
|
|
-+ if (node->fusion_id == from_id) {
|
|
|
-+ ReactorNode *new_node;
|
|
|
-+
|
|
|
-+ new_node = kmalloc (sizeof(ReactorNode), GFP_KERNEL);
|
|
|
-+ if (!new_node) {
|
|
|
-+ up (&reactor->entry.lock);
|
|
|
-+ return -ENOMEM;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ new_node->fusion_id = fusion_id;
|
|
|
-+ new_node->count = node->count;
|
|
|
-+
|
|
|
-+ fusion_list_prepend (&reactor->nodes, &new_node->link);
|
|
|
-+
|
|
|
-+ break;
|
|
|
-+ }
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ up (&reactor->entry.lock);
|
|
|
-+
|
|
|
-+ return 0;
|
|
|
-+}
|
|
|
-+
|
|
|
-+static void
|
|
|
-+free_all_nodes (FusionReactor *reactor)
|
|
|
-+
|
|
|
-+{
|
|
|
-+ FusionLink *n;
|
|
|
-+ ReactorNode *node;
|
|
|
-+
|
|
|
-+ fusion_list_foreach_safe (node, n, reactor->nodes) {
|
|
|
-+ kfree (node);
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ reactor->nodes = NULL;
|
|
|
-+}
|
|
|
-diff -urN linux-2.6.22.1-0rig/drivers/char/fusion/reactor.h linux-2.6.22.1/drivers/char/fusion/reactor.h
|
|
|
---- linux-2.6.22.1-0rig/drivers/char/fusion/reactor.h 1970-01-01 01:00:00.000000000 +0100
|
|
|
-+++ linux-2.6.22.1/drivers/char/fusion/reactor.h 2007-01-20 05:03:01.000000000 +0100
|
|
|
-@@ -0,0 +1,59 @@
|
|
|
-+/*
|
|
|
-+ * Fusion Kernel Module
|
|
|
-+ *
|
|
|
-+ * (c) Copyright 2002-2003 Convergence GmbH
|
|
|
-+ *
|
|
|
-+ * Written by Denis Oliver Kropp <dok@directfb.org>
|
|
|
-+ *
|
|
|
-+ *
|
|
|
-+ * This program is free software; you can redistribute it and/or
|
|
|
-+ * modify it under the terms of the GNU General Public License
|
|
|
-+ * as published by the Free Software Foundation; either version
|
|
|
-+ * 2 of the License, or (at your option) any later version.
|
|
|
-+ */
|
|
|
-+
|
|
|
-+#ifndef __FUSION__REACTOR_H__
|
|
|
-+#define __FUSION__REACTOR_H__
|
|
|
-+
|
|
|
-+#include "fusiondev.h"
|
|
|
-+#include "types.h"
|
|
|
-+
|
|
|
-+
|
|
|
-+/* module init/cleanup */
|
|
|
-+
|
|
|
-+int fusion_reactor_init (FusionDev *dev);
|
|
|
-+void fusion_reactor_deinit (FusionDev *dev);
|
|
|
-+
|
|
|
-+
|
|
|
-+/* public API */
|
|
|
-+
|
|
|
-+int fusion_reactor_new (FusionDev *dev,
|
|
|
-+ int *id);
|
|
|
-+
|
|
|
-+int fusion_reactor_attach (FusionDev *dev,
|
|
|
-+ int id,
|
|
|
-+ FusionID fusion_id);
|
|
|
-+
|
|
|
-+int fusion_reactor_detach (FusionDev *dev,
|
|
|
-+ int id,
|
|
|
-+ FusionID fusion_id);
|
|
|
-+
|
|
|
-+int fusion_reactor_dispatch (FusionDev *dev,
|
|
|
-+ int id,
|
|
|
-+ Fusionee *fusionee,
|
|
|
-+ int msg_size,
|
|
|
-+ const void *msg_data);
|
|
|
-+
|
|
|
-+int fusion_reactor_destroy (FusionDev *dev,
|
|
|
-+ int id);
|
|
|
-+
|
|
|
-+
|
|
|
-+/* internal functions */
|
|
|
-+
|
|
|
-+void fusion_reactor_detach_all (FusionDev *dev,
|
|
|
-+ FusionID fusion_id);
|
|
|
-+
|
|
|
-+int fusion_reactor_fork_all (FusionDev *dev,
|
|
|
-+ FusionID fusion_id,
|
|
|
-+ FusionID from_id);
|
|
|
-+#endif
|
|
|
-diff -urN linux-2.6.22.1-0rig/drivers/char/fusion/ref.c linux-2.6.22.1/drivers/char/fusion/ref.c
|
|
|
---- linux-2.6.22.1-0rig/drivers/char/fusion/ref.c 1970-01-01 01:00:00.000000000 +0100
|
|
|
-+++ linux-2.6.22.1/drivers/char/fusion/ref.c 2007-01-06 14:09:45.000000000 +0100
|
|
|
-@@ -0,0 +1,680 @@
|
|
|
-+/*
|
|
|
-+ * Fusion Kernel Module
|
|
|
-+ *
|
|
|
-+ * (c) Copyright 2002-2003 Convergence GmbH
|
|
|
-+ *
|
|
|
-+ * Written by Denis Oliver Kropp <dok@directfb.org>
|
|
|
-+ *
|
|
|
-+ *
|
|
|
-+ * This program is free software; you can redistribute it and/or
|
|
|
-+ * modify it under the terms of the GNU General Public License
|
|
|
-+ * as published by the Free Software Foundation; either version
|
|
|
-+ * 2 of the License, or (at your option) any later version.
|
|
|
-+ */
|
|
|
-+
|
|
|
-+#ifdef HAVE_LINUX_CONFIG_H
|
|
|
-+#include <linux/config.h>
|
|
|
-+#endif
|
|
|
-+#include <linux/types.h>
|
|
|
-+#include <linux/kernel.h>
|
|
|
-+#include <linux/slab.h>
|
|
|
-+#include <linux/smp_lock.h>
|
|
|
-+#include <linux/sched.h>
|
|
|
-+
|
|
|
-+#include <linux/fusion.h>
|
|
|
-+
|
|
|
-+#include "fusiondev.h"
|
|
|
-+#include "list.h"
|
|
|
-+#include "call.h"
|
|
|
-+#include "ref.h"
|
|
|
-+
|
|
|
-+typedef struct __Fusion_FusionRef FusionRef;
|
|
|
-+
|
|
|
-+typedef struct {
|
|
|
-+ FusionLink link;
|
|
|
-+ FusionID fusion_id;
|
|
|
-+ int refs;
|
|
|
-+} LocalRef;
|
|
|
-+
|
|
|
-+typedef struct {
|
|
|
-+ FusionLink link;
|
|
|
-+ FusionRef *ref;
|
|
|
-+} Inheritor;
|
|
|
-+
|
|
|
-+struct __Fusion_FusionRef {
|
|
|
-+ FusionEntry entry;
|
|
|
-+
|
|
|
-+ int global;
|
|
|
-+ int local;
|
|
|
-+
|
|
|
-+ int locked; /* non-zero fusion id of lock owner */
|
|
|
-+
|
|
|
-+ bool watched; /* true if watch has been installed */
|
|
|
-+ int call_id; /* id of call registered with a watch */
|
|
|
-+ int call_arg; /* optional call parameter */
|
|
|
-+
|
|
|
-+ FusionRef *inherited;
|
|
|
-+ FusionLink *inheritors;
|
|
|
-+
|
|
|
-+ FusionLink *local_refs;
|
|
|
-+};
|
|
|
-+
|
|
|
-+/**********************************************************************************************************************/
|
|
|
-+
|
|
|
-+static int add_local ( FusionRef *ref, FusionID fusion_id, int add );
|
|
|
-+static void clear_local ( FusionDev *dev, FusionRef *ref, FusionID fusion_id );
|
|
|
-+static int fork_local ( FusionDev *dev, FusionRef *ref, FusionID fusion_id, FusionID from_id );
|
|
|
-+static void free_all_local ( FusionRef *ref );
|
|
|
-+
|
|
|
-+static int propagate_local ( FusionDev *dev, FusionRef *ref, int diff );
|
|
|
-+
|
|
|
-+static void notify_ref ( FusionDev *dev, FusionRef *ref );
|
|
|
-+
|
|
|
-+static int add_inheritor ( FusionRef *ref, FusionRef *from );
|
|
|
-+static void remove_inheritor( FusionRef *ref, FusionRef *from );
|
|
|
-+static void drop_inheritors ( FusionDev *dev, FusionRef *ref );
|
|
|
-+
|
|
|
-+/**********************************************************************************************************************/
|
|
|
-+
|
|
|
-+static void
|
|
|
-+fusion_ref_destruct( FusionEntry *entry,
|
|
|
-+ void *ctx )
|
|
|
-+{
|
|
|
-+ FusionRef *ref = (FusionRef*) entry;
|
|
|
-+ FusionDev *dev = (FusionDev*) ctx;
|
|
|
-+
|
|
|
-+ drop_inheritors( dev, ref );
|
|
|
-+
|
|
|
-+ if (ref->inherited)
|
|
|
-+ remove_inheritor( ref, ref->inherited );
|
|
|
-+
|
|
|
-+ free_all_local( ref );
|
|
|
-+}
|
|
|
-+
|
|
|
-+static int
|
|
|
-+fusion_ref_print( FusionEntry *entry,
|
|
|
-+ void *ctx,
|
|
|
-+ char *buf )
|
|
|
-+{
|
|
|
-+ FusionRef *ref = (FusionRef*) entry;
|
|
|
-+
|
|
|
-+ if (ref->locked)
|
|
|
-+ return sprintf( buf, "%2d %2d (locked by %d)\n", ref->global, ref->local, ref->locked );
|
|
|
-+
|
|
|
-+ return sprintf( buf, "%2d %2d\n", ref->global, ref->local );
|
|
|
-+}
|
|
|
-+
|
|
|
-+FUSION_ENTRY_CLASS( FusionRef, ref, NULL,
|
|
|
-+ fusion_ref_destruct, fusion_ref_print );
|
|
|
-+
|
|
|
-+/**********************************************************************************************************************/
|
|
|
-+
|
|
|
-+int
|
|
|
-+fusion_ref_init( FusionDev *dev )
|
|
|
-+{
|
|
|
-+ fusion_entries_init( &dev->ref, &ref_class, dev );
|
|
|
-+
|
|
|
-+ create_proc_read_entry( "refs", 0, dev->proc_dir, fusion_entries_read_proc, &dev->ref );
|
|
|
-+
|
|
|
-+ return 0;
|
|
|
-+}
|
|
|
-+
|
|
|
-+void
|
|
|
-+fusion_ref_deinit( FusionDev *dev )
|
|
|
-+{
|
|
|
-+ remove_proc_entry( "refs", dev->proc_dir );
|
|
|
-+
|
|
|
-+ fusion_entries_deinit( &dev->ref );
|
|
|
-+}
|
|
|
-+
|
|
|
-+/**********************************************************************************************************************/
|
|
|
-+
|
|
|
-+int
|
|
|
-+fusion_ref_new( FusionDev *dev, int *ret_id )
|
|
|
-+{
|
|
|
-+ return fusion_entry_create( &dev->ref, ret_id, NULL );
|
|
|
-+}
|
|
|
-+
|
|
|
-+int
|
|
|
-+fusion_ref_up (FusionDev *dev, int id, FusionID fusion_id)
|
|
|
-+{
|
|
|
-+ int ret;
|
|
|
-+ FusionRef *ref;
|
|
|
-+
|
|
|
-+ ret = fusion_ref_lock( &dev->ref, id, true, &ref );
|
|
|
-+ if (ret)
|
|
|
-+ return ret;
|
|
|
-+
|
|
|
-+ dev->stat.ref_up++;
|
|
|
-+
|
|
|
-+ if (ref->locked) {
|
|
|
-+ ret = -EAGAIN;
|
|
|
-+ goto out;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ if (fusion_id) {
|
|
|
-+ ret = add_local (ref, fusion_id, 1);
|
|
|
-+ if (ret)
|
|
|
-+ goto out;
|
|
|
-+
|
|
|
-+ ret = propagate_local( dev, ref, 1 );
|
|
|
-+ }
|
|
|
-+ else
|
|
|
-+ ref->global++;
|
|
|
-+
|
|
|
-+
|
|
|
-+out:
|
|
|
-+ fusion_ref_unlock( ref );
|
|
|
-+ up( &dev->ref.lock );
|
|
|
-+
|
|
|
-+ return ret;
|
|
|
-+}
|
|
|
-+
|
|
|
-+int
|
|
|
-+fusion_ref_down (FusionDev *dev, int id, FusionID fusion_id)
|
|
|
-+{
|
|
|
-+ int ret;
|
|
|
-+ FusionRef *ref;
|
|
|
-+
|
|
|
-+ ret = fusion_ref_lock( &dev->ref, id, true, &ref );
|
|
|
-+ if (ret)
|
|
|
-+ return ret;
|
|
|
-+
|
|
|
-+ dev->stat.ref_down++;
|
|
|
-+
|
|
|
-+ if (ref->locked) {
|
|
|
-+ ret = -EAGAIN;
|
|
|
-+ goto out;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ if (fusion_id) {
|
|
|
-+ ret = -EIO;
|
|
|
-+ if (!ref->local)
|
|
|
-+ goto out;
|
|
|
-+
|
|
|
-+ ret = add_local (ref, fusion_id, -1);
|
|
|
-+ if (ret)
|
|
|
-+ goto out;
|
|
|
-+
|
|
|
-+ ret = propagate_local( dev, ref, -1 );
|
|
|
-+ }
|
|
|
-+ else {
|
|
|
-+ if (!ref->global) {
|
|
|
-+ ret = -EIO;
|
|
|
-+ goto out;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ ref->global--;
|
|
|
-+
|
|
|
-+ if (ref->local + ref->global == 0)
|
|
|
-+ notify_ref (dev, ref);
|
|
|
-+ }
|
|
|
-+
|
|
|
-+
|
|
|
-+out:
|
|
|
-+ fusion_ref_unlock( ref );
|
|
|
-+ up( &dev->ref.lock );
|
|
|
-+
|
|
|
-+ return ret;
|
|
|
-+}
|
|
|
-+
|
|
|
-+int
|
|
|
-+fusion_ref_zero_lock (FusionDev *dev, int id, FusionID fusion_id)
|
|
|
-+{
|
|
|
-+ int ret;
|
|
|
-+ FusionRef *ref;
|
|
|
-+
|
|
|
-+ ret = fusion_ref_lock( &dev->ref, id, false, &ref );
|
|
|
-+ if (ret)
|
|
|
-+ return ret;
|
|
|
-+
|
|
|
-+ while (true) {
|
|
|
-+ if (ref->watched) {
|
|
|
-+ fusion_ref_unlock( ref );
|
|
|
-+ return -EACCES;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ if (ref->locked) {
|
|
|
-+ fusion_ref_unlock( ref );
|
|
|
-+ return ref->locked == fusion_id ? -EIO : -EAGAIN;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ if (ref->global || ref->local) {
|
|
|
-+ ret = fusion_ref_wait( ref, NULL );
|
|
|
-+ if (ret)
|
|
|
-+ return ret;
|
|
|
-+ }
|
|
|
-+ else
|
|
|
-+ break;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ ref->locked = fusion_id;
|
|
|
-+
|
|
|
-+ fusion_ref_unlock( ref );
|
|
|
-+
|
|
|
-+ return 0;
|
|
|
-+}
|
|
|
-+
|
|
|
-+int
|
|
|
-+fusion_ref_zero_trylock (FusionDev *dev, int id, FusionID fusion_id)
|
|
|
-+{
|
|
|
-+ int ret;
|
|
|
-+ FusionRef *ref;
|
|
|
-+
|
|
|
-+ ret = fusion_ref_lock( &dev->ref, id, false, &ref );
|
|
|
-+ if (ret)
|
|
|
-+ return ret;
|
|
|
-+
|
|
|
-+ if (ref->locked) {
|
|
|
-+ fusion_ref_unlock( ref );
|
|
|
-+ return ref->locked == fusion_id ? -EIO : -EAGAIN;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ if (ref->global || ref->local)
|
|
|
-+ ret = -ETOOMANYREFS;
|
|
|
-+ else
|
|
|
-+ ref->locked = fusion_id;
|
|
|
-+
|
|
|
-+ fusion_ref_unlock( ref );
|
|
|
-+
|
|
|
-+ return ret;
|
|
|
-+}
|
|
|
-+
|
|
|
-+int
|
|
|
-+fusion_ref_zero_unlock (FusionDev *dev, int id, FusionID fusion_id)
|
|
|
-+{
|
|
|
-+ int ret;
|
|
|
-+ FusionRef *ref;
|
|
|
-+
|
|
|
-+ ret = fusion_ref_lock( &dev->ref, id, false, &ref );
|
|
|
-+ if (ret)
|
|
|
-+ return ret;
|
|
|
-+
|
|
|
-+ if (ref->locked != fusion_id) {
|
|
|
-+ fusion_ref_unlock( ref );
|
|
|
-+ return -EIO;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ ref->locked = 0;
|
|
|
-+
|
|
|
-+ fusion_ref_unlock( ref );
|
|
|
-+
|
|
|
-+ return 0;
|
|
|
-+}
|
|
|
-+
|
|
|
-+int
|
|
|
-+fusion_ref_stat (FusionDev *dev, int id, int *refs)
|
|
|
-+{
|
|
|
-+ int ret;
|
|
|
-+ FusionRef *ref;
|
|
|
-+
|
|
|
-+ ret = fusion_ref_lock( &dev->ref, id, false, &ref );
|
|
|
-+ if (ret)
|
|
|
-+ return ret;
|
|
|
-+
|
|
|
-+ *refs = ref->global + ref->local;
|
|
|
-+
|
|
|
-+ fusion_ref_unlock( ref );
|
|
|
-+
|
|
|
-+ return 0;
|
|
|
-+}
|
|
|
-+
|
|
|
-+int
|
|
|
-+fusion_ref_watch (FusionDev *dev,
|
|
|
-+ int id,
|
|
|
-+ int call_id,
|
|
|
-+ int call_arg)
|
|
|
-+{
|
|
|
-+ int ret;
|
|
|
-+ FusionRef *ref;
|
|
|
-+
|
|
|
-+ ret = fusion_ref_lock( &dev->ref, id, false, &ref );
|
|
|
-+ if (ret)
|
|
|
-+ return ret;
|
|
|
-+
|
|
|
-+ if (ref->entry.pid != current->pid) {
|
|
|
-+ fusion_ref_unlock( ref );
|
|
|
-+ return -EACCES;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ if (ref->global + ref->local == 0) {
|
|
|
-+ fusion_ref_unlock( ref );
|
|
|
-+ return -EIO;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ if (ref->watched) {
|
|
|
-+ fusion_ref_unlock( ref );
|
|
|
-+ return -EBUSY;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ ref->watched = true;
|
|
|
-+ ref->call_id = call_id;
|
|
|
-+ ref->call_arg = call_arg;
|
|
|
-+
|
|
|
-+ fusion_ref_notify( ref, true );
|
|
|
-+
|
|
|
-+ fusion_ref_unlock( ref );
|
|
|
-+
|
|
|
-+ return 0;
|
|
|
-+}
|
|
|
-+
|
|
|
-+int
|
|
|
-+fusion_ref_inherit (FusionDev *dev,
|
|
|
-+ int id,
|
|
|
-+ int from_id)
|
|
|
-+{
|
|
|
-+ int ret;
|
|
|
-+ FusionRef *ref;
|
|
|
-+ FusionRef *from = NULL;
|
|
|
-+
|
|
|
-+ ret = fusion_ref_lock( &dev->ref, id, true, &ref );
|
|
|
-+ if (ret)
|
|
|
-+ return ret;
|
|
|
-+
|
|
|
-+ ret = -EBUSY;
|
|
|
-+ if (ref->inherited)
|
|
|
-+ goto out;
|
|
|
-+
|
|
|
-+ ret = -EINVAL;
|
|
|
-+ fusion_list_foreach (from, dev->ref.list) {
|
|
|
-+ if (from->entry.id == from_id) {
|
|
|
-+ if (down_interruptible( &from->entry.lock )) {
|
|
|
-+ ret = -EINTR;
|
|
|
-+ from = NULL;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ break;
|
|
|
-+ }
|
|
|
-+ }
|
|
|
-+ if (!from)
|
|
|
-+ goto out;
|
|
|
-+
|
|
|
-+ ret = add_inheritor( ref, from );
|
|
|
-+ if (ret)
|
|
|
-+ goto out;
|
|
|
-+
|
|
|
-+ ret = propagate_local( dev, ref, from->local );
|
|
|
-+ if (ret)
|
|
|
-+ goto out;
|
|
|
-+
|
|
|
-+ ref->inherited = from;
|
|
|
-+
|
|
|
-+out:
|
|
|
-+ if (from)
|
|
|
-+ up( &from->entry.lock );
|
|
|
-+
|
|
|
-+ fusion_ref_unlock( ref );
|
|
|
-+ up ( &dev->ref.lock );
|
|
|
-+
|
|
|
-+ return ret;
|
|
|
-+}
|
|
|
-+
|
|
|
-+int
|
|
|
-+fusion_ref_destroy (FusionDev *dev, int id)
|
|
|
-+{
|
|
|
-+ return fusion_entry_destroy( &dev->ref, id );
|
|
|
-+}
|
|
|
-+
|
|
|
-+void
|
|
|
-+fusion_ref_clear_all_local( FusionDev *dev, FusionID fusion_id )
|
|
|
-+{
|
|
|
-+ FusionRef *ref;
|
|
|
-+
|
|
|
-+ down( &dev->ref.lock );
|
|
|
-+
|
|
|
-+ fusion_list_foreach (ref, dev->ref.list)
|
|
|
-+ clear_local( dev, ref, fusion_id );
|
|
|
-+
|
|
|
-+ up( &dev->ref.lock );
|
|
|
-+}
|
|
|
-+
|
|
|
-+int
|
|
|
-+fusion_ref_fork_all_local( FusionDev *dev, FusionID fusion_id, FusionID from_id )
|
|
|
-+{
|
|
|
-+ FusionRef *ref;
|
|
|
-+ int ret = 0;
|
|
|
-+
|
|
|
-+ down( &dev->ref.lock );
|
|
|
-+
|
|
|
-+ fusion_list_foreach (ref, dev->ref.list) {
|
|
|
-+ ret = fork_local( dev, ref, fusion_id, from_id );
|
|
|
-+ if (ret)
|
|
|
-+ break;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ up( &dev->ref.lock );
|
|
|
-+
|
|
|
-+ return ret;
|
|
|
-+}
|
|
|
-+
|
|
|
-+/**********************************************************************************************************************/
|
|
|
-+
|
|
|
-+static int
|
|
|
-+add_local (FusionRef *ref, FusionID fusion_id, int add)
|
|
|
-+{
|
|
|
-+ FusionLink *l;
|
|
|
-+ LocalRef *local;
|
|
|
-+
|
|
|
-+ fusion_list_foreach (l, ref->local_refs) {
|
|
|
-+ local = (LocalRef *) l;
|
|
|
-+
|
|
|
-+ if (local->fusion_id == fusion_id) {
|
|
|
-+ fusion_list_move_to_front( &ref->local_refs, l );
|
|
|
-+
|
|
|
-+ if (local->refs + add < 0)
|
|
|
-+ return -EIO;
|
|
|
-+
|
|
|
-+ local->refs += add;
|
|
|
-+ return 0;
|
|
|
-+ }
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ /* Can only create local node if value is positive. */
|
|
|
-+ if (add <= 0)
|
|
|
-+ return -EIO;
|
|
|
-+
|
|
|
-+ local = kmalloc (sizeof(LocalRef), GFP_KERNEL);
|
|
|
-+ if (!local)
|
|
|
-+ return -ENOMEM;
|
|
|
-+
|
|
|
-+ local->fusion_id = fusion_id;
|
|
|
-+ local->refs = add;
|
|
|
-+
|
|
|
-+ fusion_list_prepend (&ref->local_refs, &local->link);
|
|
|
-+
|
|
|
-+ return 0;
|
|
|
-+}
|
|
|
-+
|
|
|
-+static void
|
|
|
-+clear_local (FusionDev *dev, FusionRef *ref, FusionID fusion_id)
|
|
|
-+{
|
|
|
-+ FusionLink *l;
|
|
|
-+
|
|
|
-+ down (&ref->entry.lock);
|
|
|
-+
|
|
|
-+ if (ref->locked == fusion_id) {
|
|
|
-+ ref->locked = 0;
|
|
|
-+ wake_up_interruptible_all (&ref->entry.wait);
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ fusion_list_foreach (l, ref->local_refs) {
|
|
|
-+ LocalRef *local = (LocalRef *) l;
|
|
|
-+
|
|
|
-+ if (local->fusion_id == fusion_id) {
|
|
|
-+ if (local->refs)
|
|
|
-+ propagate_local( dev, ref, - local->refs );
|
|
|
-+
|
|
|
-+ fusion_list_remove( &ref->local_refs, l );
|
|
|
-+
|
|
|
-+ kfree (l);
|
|
|
-+ break;
|
|
|
-+ }
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ up (&ref->entry.lock);
|
|
|
-+}
|
|
|
-+
|
|
|
-+static int
|
|
|
-+fork_local (FusionDev *dev, FusionRef *ref, FusionID fusion_id, FusionID from_id)
|
|
|
-+{
|
|
|
-+ FusionLink *l;
|
|
|
-+ int ret = 0;
|
|
|
-+
|
|
|
-+ down (&ref->entry.lock);
|
|
|
-+
|
|
|
-+ fusion_list_foreach (l, ref->local_refs) {
|
|
|
-+ LocalRef *local = (LocalRef *) l;
|
|
|
-+
|
|
|
-+ if (local->fusion_id == from_id) {
|
|
|
-+ if (local->refs) {
|
|
|
-+ LocalRef *new_local;
|
|
|
-+
|
|
|
-+ new_local = kmalloc (sizeof(LocalRef), GFP_KERNEL);
|
|
|
-+ if (!new_local) {
|
|
|
-+ ret = -ENOMEM;
|
|
|
-+ break;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ new_local->fusion_id = fusion_id;
|
|
|
-+ new_local->refs = local->refs;
|
|
|
-+
|
|
|
-+ fusion_list_prepend( &ref->local_refs, &new_local->link );
|
|
|
-+
|
|
|
-+ propagate_local( dev, ref, local->refs );
|
|
|
-+ }
|
|
|
-+ break;
|
|
|
-+ }
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ up (&ref->entry.lock);
|
|
|
-+
|
|
|
-+ return ret;
|
|
|
-+}
|
|
|
-+
|
|
|
-+static void
|
|
|
-+free_all_local (FusionRef *ref)
|
|
|
-+{
|
|
|
-+ FusionLink *l = ref->local_refs;
|
|
|
-+
|
|
|
-+ while (l) {
|
|
|
-+ FusionLink *next = l->next;
|
|
|
-+
|
|
|
-+ kfree (l);
|
|
|
-+
|
|
|
-+ l = next;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ ref->local_refs = NULL;
|
|
|
-+}
|
|
|
-+
|
|
|
-+static void
|
|
|
-+notify_ref (FusionDev *dev, FusionRef *ref)
|
|
|
-+{
|
|
|
-+ if (ref->watched) {
|
|
|
-+ FusionCallExecute execute;
|
|
|
-+
|
|
|
-+ execute.call_id = ref->call_id;
|
|
|
-+ execute.call_arg = ref->call_arg;
|
|
|
-+ execute.call_ptr = NULL;
|
|
|
-+
|
|
|
-+ fusion_call_execute (dev, 0, &execute);
|
|
|
-+ }
|
|
|
-+ else
|
|
|
-+ wake_up_interruptible_all (&ref->entry.wait);
|
|
|
-+}
|
|
|
-+
|
|
|
-+static int
|
|
|
-+propagate_local( FusionDev *dev, FusionRef *ref, int diff )
|
|
|
-+{
|
|
|
-+ FusionLink *l;
|
|
|
-+
|
|
|
-+ /* Recurse into inheritors. */
|
|
|
-+ fusion_list_foreach (l, ref->inheritors) {
|
|
|
-+ FusionRef *inheritor = ((Inheritor*) l)->ref;
|
|
|
-+
|
|
|
-+ if (down_interruptible( &inheritor->entry.lock )) {
|
|
|
-+ printk( KERN_ERR "fusion_ref: propagate_local() interrupted!\n" );
|
|
|
-+ //return -EINTR;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ propagate_local( dev, inheritor, diff );
|
|
|
-+
|
|
|
-+ up( &inheritor->entry.lock );
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ /* Apply difference. */
|
|
|
-+ ref->local += diff;
|
|
|
-+
|
|
|
-+ /* Notify zero count. */
|
|
|
-+ if (ref->local + ref->global == 0)
|
|
|
-+ notify_ref( dev, ref );
|
|
|
-+
|
|
|
-+ return 0;
|
|
|
-+}
|
|
|
-+
|
|
|
-+static int
|
|
|
-+add_inheritor(FusionRef *ref, FusionRef *from)
|
|
|
-+{
|
|
|
-+ Inheritor *inheritor;
|
|
|
-+
|
|
|
-+ inheritor = kmalloc (sizeof(Inheritor), GFP_KERNEL);
|
|
|
-+ if (!inheritor)
|
|
|
-+ return -ENOMEM;
|
|
|
-+
|
|
|
-+ inheritor->ref = ref;
|
|
|
-+
|
|
|
-+ fusion_list_prepend( &from->inheritors, &inheritor->link );
|
|
|
-+
|
|
|
-+ return 0;
|
|
|
-+}
|
|
|
-+
|
|
|
-+static void
|
|
|
-+remove_inheritor(FusionRef *ref, FusionRef *from)
|
|
|
-+{
|
|
|
-+ FusionLink *l;
|
|
|
-+
|
|
|
-+ down( &from->entry.lock );
|
|
|
-+
|
|
|
-+ fusion_list_foreach (l, from->inheritors) {
|
|
|
-+ Inheritor *inheritor = (Inheritor*) l;
|
|
|
-+
|
|
|
-+ if (inheritor->ref == ref) {
|
|
|
-+ fusion_list_remove( &from->inheritors, &inheritor->link );
|
|
|
-+
|
|
|
-+ kfree( l );
|
|
|
-+ break;
|
|
|
-+ }
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ up( &from->entry.lock );
|
|
|
-+}
|
|
|
-+
|
|
|
-+static void
|
|
|
-+drop_inheritors( FusionDev *dev, FusionRef *ref )
|
|
|
-+{
|
|
|
-+ FusionLink *l = ref->inheritors;
|
|
|
-+
|
|
|
-+ while (l) {
|
|
|
-+ FusionLink *next = l->next;
|
|
|
-+ FusionRef *inheritor = ((Inheritor*) l)->ref;
|
|
|
-+
|
|
|
-+ if (down_interruptible( &inheritor->entry.lock )) {
|
|
|
-+ printk( KERN_ERR "fusion_ref: drop_inheritors() interrupted!\n" );
|
|
|
-+ //return;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ propagate_local( dev, inheritor, - ref->local );
|
|
|
-+
|
|
|
-+ inheritor->inherited = NULL;
|
|
|
-+
|
|
|
-+ up( &inheritor->entry.lock );
|
|
|
-+
|
|
|
-+
|
|
|
-+ kfree (l);
|
|
|
-+
|
|
|
-+ l = next;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ ref->inheritors = NULL;
|
|
|
-+}
|
|
|
-+
|
|
|
-diff -urN linux-2.6.22.1-0rig/drivers/char/fusion/ref.h linux-2.6.22.1/drivers/char/fusion/ref.h
|
|
|
---- linux-2.6.22.1-0rig/drivers/char/fusion/ref.h 1970-01-01 01:00:00.000000000 +0100
|
|
|
-+++ linux-2.6.22.1/drivers/char/fusion/ref.h 2006-08-14 11:16:54.000000000 +0200
|
|
|
-@@ -0,0 +1,79 @@
|
|
|
-+/*
|
|
|
-+ * Fusion Kernel Module
|
|
|
-+ *
|
|
|
-+ * (c) Copyright 2002-2003 Convergence GmbH
|
|
|
-+ *
|
|
|
-+ * Written by Denis Oliver Kropp <dok@directfb.org>
|
|
|
-+ *
|
|
|
-+ *
|
|
|
-+ * This program is free software; you can redistribute it and/or
|
|
|
-+ * modify it under the terms of the GNU General Public License
|
|
|
-+ * as published by the Free Software Foundation; either version
|
|
|
-+ * 2 of the License, or (at your option) any later version.
|
|
|
-+ */
|
|
|
-+
|
|
|
-+#ifndef __FUSION__REF_H__
|
|
|
-+#define __FUSION__REF_H__
|
|
|
-+
|
|
|
-+#include "fusiondev.h"
|
|
|
-+#include "types.h"
|
|
|
-+
|
|
|
-+
|
|
|
-+/* module init/cleanup */
|
|
|
-+
|
|
|
-+int fusion_ref_init (FusionDev *dev);
|
|
|
-+void fusion_ref_deinit (FusionDev *dev);
|
|
|
-+
|
|
|
-+
|
|
|
-+/* public API */
|
|
|
-+
|
|
|
-+int fusion_ref_new (FusionDev *dev,
|
|
|
-+ int *id);
|
|
|
-+
|
|
|
-+int fusion_ref_up (FusionDev *dev,
|
|
|
-+ int id,
|
|
|
-+ FusionID fusion_id);
|
|
|
-+
|
|
|
-+int fusion_ref_down (FusionDev *dev,
|
|
|
-+ int id,
|
|
|
-+ FusionID fusion_id);
|
|
|
-+
|
|
|
-+int fusion_ref_zero_lock (FusionDev *dev,
|
|
|
-+ int id,
|
|
|
-+ FusionID fusion_id);
|
|
|
-+
|
|
|
-+int fusion_ref_zero_trylock (FusionDev *dev,
|
|
|
-+ int id,
|
|
|
-+ FusionID fusion_id);
|
|
|
-+
|
|
|
-+int fusion_ref_zero_unlock (FusionDev *dev,
|
|
|
-+ int id,
|
|
|
-+ FusionID fusion_id);
|
|
|
-+
|
|
|
-+int fusion_ref_stat (FusionDev *dev,
|
|
|
-+ int id,
|
|
|
-+ int *refs);
|
|
|
-+
|
|
|
-+int fusion_ref_watch (FusionDev *dev,
|
|
|
-+ int id,
|
|
|
-+ int call_id,
|
|
|
-+ int call_arg);
|
|
|
-+
|
|
|
-+int fusion_ref_inherit (FusionDev *dev,
|
|
|
-+ int id,
|
|
|
-+ int from);
|
|
|
-+
|
|
|
-+int fusion_ref_destroy (FusionDev *dev,
|
|
|
-+ int id);
|
|
|
-+
|
|
|
-+
|
|
|
-+/* internal functions */
|
|
|
-+
|
|
|
-+void fusion_ref_clear_all_local (FusionDev *dev,
|
|
|
-+ FusionID fusion_id);
|
|
|
-+
|
|
|
-+int fusion_ref_fork_all_local (FusionDev *dev,
|
|
|
-+ FusionID fusion_id,
|
|
|
-+ FusionID from_id);
|
|
|
-+
|
|
|
-+#endif
|
|
|
-diff -urN linux-2.6.22.1-0rig/drivers/char/fusion/shmpool.c linux-2.6.22.1/drivers/char/fusion/shmpool.c
|
|
|
---- linux-2.6.22.1-0rig/drivers/char/fusion/shmpool.c 1970-01-01 01:00:00.000000000 +0100
|
|
|
-+++ linux-2.6.22.1/drivers/char/fusion/shmpool.c 2007-01-20 05:03:01.000000000 +0100
|
|
|
-@@ -0,0 +1,444 @@
|
|
|
-+/*
|
|
|
-+ * Fusion Kernel Module
|
|
|
-+ *
|
|
|
-+ * (c) Copyright 2002-2003 Convergence GmbH
|
|
|
-+ *
|
|
|
-+ * Written by Denis Oliver Kropp <dok@directfb.org>
|
|
|
-+ *
|
|
|
-+ *
|
|
|
-+ * This program is free software; you can redistribute it and/or
|
|
|
-+ * modify it under the terms of the GNU General Public License
|
|
|
-+ * as published by the Free Software Foundation; either version
|
|
|
-+ * 2 of the License, or (at your option) any later version.
|
|
|
-+ */
|
|
|
-+
|
|
|
-+#ifdef HAVE_LINUX_CONFIG_H
|
|
|
-+#include <linux/config.h>
|
|
|
-+#endif
|
|
|
-+#include <linux/types.h>
|
|
|
-+#include <linux/kernel.h>
|
|
|
-+#include <linux/slab.h>
|
|
|
-+#include <linux/smp_lock.h>
|
|
|
-+#include <linux/sched.h>
|
|
|
-+
|
|
|
-+#include <linux/fusion.h>
|
|
|
-+
|
|
|
-+#include "fusiondev.h"
|
|
|
-+#include "fusionee.h"
|
|
|
-+#include "list.h"
|
|
|
-+#include "shmpool.h"
|
|
|
-+
|
|
|
-+
|
|
|
-+#define SHM_BASE 0x20010000 /* virtual base address */
|
|
|
-+#define SHM_SIZE 0x1FFEF000 /* size of virtual address space */
|
|
|
-+
|
|
|
-+
|
|
|
-+typedef struct {
|
|
|
-+ FusionLink link;
|
|
|
-+ unsigned long next_base;
|
|
|
-+} AddrEntry;
|
|
|
-+
|
|
|
-+
|
|
|
-+typedef struct {
|
|
|
-+ FusionLink link;
|
|
|
-+
|
|
|
-+ FusionID fusion_id;
|
|
|
-+
|
|
|
-+ int count; /* number of attach calls */
|
|
|
-+} SHMPoolNode;
|
|
|
-+
|
|
|
-+typedef struct {
|
|
|
-+ FusionEntry entry;
|
|
|
-+
|
|
|
-+ int max_size;
|
|
|
-+
|
|
|
-+ void *addr_base;
|
|
|
-+ int size;
|
|
|
-+
|
|
|
-+ AddrEntry *addr_entry;
|
|
|
-+
|
|
|
-+ FusionLink *nodes;
|
|
|
-+
|
|
|
-+ int dispatch_count;
|
|
|
-+} FusionSHMPool;
|
|
|
-+
|
|
|
-+/******************************************************************************/
|
|
|
-+
|
|
|
-+static SHMPoolNode *get_node ( FusionSHMPool *shmpool,
|
|
|
-+ FusionID fusion_id );
|
|
|
-+
|
|
|
-+static void remove_node ( FusionSHMPool *shmpool,
|
|
|
-+ FusionID fusion_id );
|
|
|
-+
|
|
|
-+static int fork_node ( FusionSHMPool *shmpool,
|
|
|
-+ FusionID fusion_id,
|
|
|
-+ FusionID from_id );
|
|
|
-+
|
|
|
-+static void free_all_nodes( FusionSHMPool *shmpool );
|
|
|
-+
|
|
|
-+/******************************************************************************/
|
|
|
-+
|
|
|
-+
|
|
|
-+static DECLARE_MUTEX (addr_lock);
|
|
|
-+static FusionLink *addr_entries;
|
|
|
-+static unsigned long addr_base = SHM_BASE;
|
|
|
-+
|
|
|
-+/******************************************************************************/
|
|
|
-+
|
|
|
-+static AddrEntry *
|
|
|
-+add_addr_entry( unsigned long next_base )
|
|
|
-+{
|
|
|
-+ AddrEntry *entry = kmalloc( sizeof(AddrEntry), GFP_KERNEL );
|
|
|
-+
|
|
|
-+ entry->next_base = next_base;
|
|
|
-+
|
|
|
-+ fusion_list_prepend( &addr_entries, &entry->link );
|
|
|
-+
|
|
|
-+ return entry;
|
|
|
-+}
|
|
|
-+
|
|
|
-+/******************************************************************************/
|
|
|
-+
|
|
|
-+static int
|
|
|
-+fusion_shmpool_construct( FusionEntry *entry,
|
|
|
-+ void *ctx,
|
|
|
-+ void *create_ctx )
|
|
|
-+{
|
|
|
-+ FusionSHMPool *shmpool = (FusionSHMPool*) entry;
|
|
|
-+ FusionSHMPoolNew *poolnew = create_ctx;
|
|
|
-+
|
|
|
-+ down( &addr_lock );
|
|
|
-+
|
|
|
-+ if (addr_base + poolnew->max_size >= SHM_BASE + SHM_SIZE) {
|
|
|
-+ up( &addr_lock );
|
|
|
-+ printk( KERN_WARNING "%s: virtual address space exhausted! (FIXME)\n", __FUNCTION__ );
|
|
|
-+ return -ENOSPC;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ shmpool->max_size = poolnew->max_size;
|
|
|
-+ shmpool->addr_base = poolnew->addr_base = (void*) addr_base;
|
|
|
-+
|
|
|
-+ addr_base += PAGE_ALIGN(poolnew->max_size) + PAGE_SIZE; /* fence page */
|
|
|
-+
|
|
|
-+ shmpool->addr_entry = add_addr_entry( addr_base );
|
|
|
-+
|
|
|
-+ up( &addr_lock );
|
|
|
-+
|
|
|
-+ return 0;
|
|
|
-+}
|
|
|
-+
|
|
|
-+static void
|
|
|
-+fusion_shmpool_destruct( FusionEntry *entry,
|
|
|
-+ void *ctx )
|
|
|
-+{
|
|
|
-+ AddrEntry *addr_entry;
|
|
|
-+ FusionSHMPool *shmpool = (FusionSHMPool*) entry;
|
|
|
-+
|
|
|
-+ free_all_nodes( shmpool );
|
|
|
-+
|
|
|
-+
|
|
|
-+ down( &addr_lock );
|
|
|
-+
|
|
|
-+ fusion_list_remove( &addr_entries, &shmpool->addr_entry->link );
|
|
|
-+
|
|
|
-+
|
|
|
-+ /*
|
|
|
-+ * free trailing address space
|
|
|
-+ */
|
|
|
-+
|
|
|
-+ addr_base = SHM_BASE;
|
|
|
-+
|
|
|
-+ fusion_list_foreach (addr_entry, addr_entries) {
|
|
|
-+ if (addr_entry->next_base > addr_base)
|
|
|
-+ addr_base = addr_entry->next_base;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ up( &addr_lock );
|
|
|
-+}
|
|
|
-+
|
|
|
-+static int
|
|
|
-+fusion_shmpool_print( FusionEntry *entry,
|
|
|
-+ void *ctx,
|
|
|
-+ char *buf )
|
|
|
-+{
|
|
|
-+ int num = 0;
|
|
|
-+ FusionSHMPool *shmpool = (FusionSHMPool*) entry;
|
|
|
-+ FusionLink *node = shmpool->nodes;
|
|
|
-+
|
|
|
-+ fusion_list_foreach (node, shmpool->nodes) {
|
|
|
-+ num++;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ return sprintf( buf, "0x%p [0x%x] - 0x%x, %dx dispatch, %d nodes\n",
|
|
|
-+ shmpool->addr_base, shmpool->max_size, shmpool->size,
|
|
|
-+ shmpool->dispatch_count, num );
|
|
|
-+}
|
|
|
-+
|
|
|
-+
|
|
|
-+FUSION_ENTRY_CLASS( FusionSHMPool, shmpool, fusion_shmpool_construct,
|
|
|
-+ fusion_shmpool_destruct, fusion_shmpool_print )
|
|
|
-+
|
|
|
-+/******************************************************************************/
|
|
|
-+
|
|
|
-+int
|
|
|
-+fusion_shmpool_init (FusionDev *dev)
|
|
|
-+{
|
|
|
-+ fusion_entries_init( &dev->shmpool, &shmpool_class, dev );
|
|
|
-+
|
|
|
-+ create_proc_read_entry( "shmpools", 0, dev->proc_dir,
|
|
|
-+ fusion_entries_read_proc, &dev->shmpool );
|
|
|
-+
|
|
|
-+ return 0;
|
|
|
-+}
|
|
|
-+
|
|
|
-+void
|
|
|
-+fusion_shmpool_deinit (FusionDev *dev)
|
|
|
-+{
|
|
|
-+ remove_proc_entry ("shmpools", dev->proc_dir);
|
|
|
-+
|
|
|
-+ fusion_entries_deinit( &dev->shmpool );
|
|
|
-+}
|
|
|
-+
|
|
|
-+/******************************************************************************/
|
|
|
-+
|
|
|
-+int
|
|
|
-+fusion_shmpool_new (FusionDev *dev,
|
|
|
-+ FusionSHMPoolNew *pool)
|
|
|
-+{
|
|
|
-+ if (pool->max_size <= 0)
|
|
|
-+ return -EINVAL;
|
|
|
-+
|
|
|
-+ return fusion_entry_create( &dev->shmpool, &pool->pool_id, pool );
|
|
|
-+}
|
|
|
-+
|
|
|
-+int
|
|
|
-+fusion_shmpool_attach (FusionDev *dev,
|
|
|
-+ FusionSHMPoolAttach *attach,
|
|
|
-+ FusionID fusion_id)
|
|
|
-+{
|
|
|
-+ int ret;
|
|
|
-+ SHMPoolNode *node;
|
|
|
-+ FusionSHMPool *shmpool;
|
|
|
-+
|
|
|
-+ ret = fusion_shmpool_lock( &dev->shmpool, attach->pool_id, false, &shmpool );
|
|
|
-+ if (ret)
|
|
|
-+ return ret;
|
|
|
-+
|
|
|
-+ dev->stat.shmpool_attach++;
|
|
|
-+
|
|
|
-+ node = get_node (shmpool, fusion_id);
|
|
|
-+ if (!node) {
|
|
|
-+ node = kmalloc (sizeof(SHMPoolNode), GFP_KERNEL);
|
|
|
-+ if (!node) {
|
|
|
-+ fusion_shmpool_unlock( shmpool );
|
|
|
-+ return -ENOMEM;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ node->fusion_id = fusion_id;
|
|
|
-+ node->count = 1;
|
|
|
-+
|
|
|
-+ fusion_list_prepend (&shmpool->nodes, &node->link);
|
|
|
-+ }
|
|
|
-+ else
|
|
|
-+ node->count++;
|
|
|
-+
|
|
|
-+ attach->addr_base = shmpool->addr_base;
|
|
|
-+ attach->size = shmpool->size;
|
|
|
-+
|
|
|
-+ fusion_shmpool_unlock( shmpool );
|
|
|
-+
|
|
|
-+ return 0;
|
|
|
-+}
|
|
|
-+
|
|
|
-+int
|
|
|
-+fusion_shmpool_detach (FusionDev *dev, int id, FusionID fusion_id)
|
|
|
-+{
|
|
|
-+ int ret;
|
|
|
-+ SHMPoolNode *node;
|
|
|
-+ FusionSHMPool *shmpool;
|
|
|
-+
|
|
|
-+ ret = fusion_shmpool_lock( &dev->shmpool, id, false, &shmpool );
|
|
|
-+ if (ret)
|
|
|
-+ return ret;
|
|
|
-+
|
|
|
-+ dev->stat.shmpool_detach++;
|
|
|
-+
|
|
|
-+ node = get_node (shmpool, fusion_id);
|
|
|
-+ if (!node) {
|
|
|
-+ fusion_shmpool_unlock( shmpool );
|
|
|
-+ return -EIO;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ if (! --node->count) {
|
|
|
-+ fusion_list_remove (&shmpool->nodes, &node->link);
|
|
|
-+ kfree (node);
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ fusion_shmpool_unlock( shmpool );
|
|
|
-+
|
|
|
-+ return 0;
|
|
|
-+}
|
|
|
-+
|
|
|
-+int
|
|
|
-+fusion_shmpool_dispatch( FusionDev *dev,
|
|
|
-+ FusionSHMPoolDispatch *dispatch,
|
|
|
-+ Fusionee *fusionee )
|
|
|
-+{
|
|
|
-+ int ret;
|
|
|
-+ FusionLink *l;
|
|
|
-+ FusionSHMPool *shmpool;
|
|
|
-+ FusionSHMPoolMessage message;
|
|
|
-+ FusionID fusion_id = fusionee_id( fusionee );
|
|
|
-+
|
|
|
-+ if (dispatch->size <= 0)
|
|
|
-+ return -EINVAL;
|
|
|
-+
|
|
|
-+ ret = fusion_shmpool_lock( &dev->shmpool, dispatch->pool_id, false, &shmpool );
|
|
|
-+ if (ret)
|
|
|
-+ return ret;
|
|
|
-+
|
|
|
-+ message.type = FSMT_REMAP;
|
|
|
-+ message.size = dispatch->size;
|
|
|
-+
|
|
|
-+ shmpool->dispatch_count++;
|
|
|
-+
|
|
|
-+ shmpool->size = dispatch->size;
|
|
|
-+
|
|
|
-+ fusion_list_foreach (l, shmpool->nodes) {
|
|
|
-+ SHMPoolNode *node = (SHMPoolNode *) l;
|
|
|
-+
|
|
|
-+ if (node->fusion_id == fusion_id)
|
|
|
-+ continue;
|
|
|
-+
|
|
|
-+ fusionee_send_message (dev, fusionee, node->fusion_id, FMT_SHMPOOL,
|
|
|
-+ shmpool->entry.id, sizeof(message), &message);
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ fusion_shmpool_unlock( shmpool );
|
|
|
-+
|
|
|
-+ return 0;
|
|
|
-+}
|
|
|
-+
|
|
|
-+int
|
|
|
-+fusion_shmpool_destroy (FusionDev *dev, int id)
|
|
|
-+{
|
|
|
-+ return fusion_entry_destroy( &dev->shmpool, id );
|
|
|
-+}
|
|
|
-+
|
|
|
-+void
|
|
|
-+fusion_shmpool_detach_all (FusionDev *dev, FusionID fusion_id)
|
|
|
-+{
|
|
|
-+ FusionLink *l;
|
|
|
-+
|
|
|
-+ down (&dev->shmpool.lock);
|
|
|
-+
|
|
|
-+ fusion_list_foreach (l, dev->shmpool.list) {
|
|
|
-+ FusionSHMPool *shmpool = (FusionSHMPool *) l;
|
|
|
-+
|
|
|
-+ remove_node (shmpool, fusion_id);
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ up (&dev->shmpool.lock);
|
|
|
-+}
|
|
|
-+
|
|
|
-+int
|
|
|
-+fusion_shmpool_fork_all( FusionDev *dev,
|
|
|
-+ FusionID fusion_id,
|
|
|
-+ FusionID from_id )
|
|
|
-+{
|
|
|
-+ FusionLink *l;
|
|
|
-+ int ret = 0;
|
|
|
-+
|
|
|
-+ down (&dev->shmpool.lock);
|
|
|
-+
|
|
|
-+ fusion_list_foreach (l, dev->shmpool.list) {
|
|
|
-+ FusionSHMPool *shmpool = (FusionSHMPool *) l;
|
|
|
-+
|
|
|
-+ ret = fork_node( shmpool, fusion_id, from_id );
|
|
|
-+ if (ret)
|
|
|
-+ break;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ up (&dev->shmpool.lock);
|
|
|
-+
|
|
|
-+ return ret;
|
|
|
-+}
|
|
|
-+
|
|
|
-+/******************************************************************************/
|
|
|
-+
|
|
|
-+static SHMPoolNode *
|
|
|
-+get_node (FusionSHMPool *shmpool,
|
|
|
-+ FusionID fusion_id)
|
|
|
-+{
|
|
|
-+ SHMPoolNode *node;
|
|
|
-+
|
|
|
-+ fusion_list_foreach (node, shmpool->nodes) {
|
|
|
-+ if (node->fusion_id == fusion_id)
|
|
|
-+ return node;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ return NULL;
|
|
|
-+}
|
|
|
-+
|
|
|
-+static void
|
|
|
-+remove_node (FusionSHMPool *shmpool, FusionID fusion_id)
|
|
|
-+{
|
|
|
-+ SHMPoolNode *node;
|
|
|
-+
|
|
|
-+ down (&shmpool->entry.lock);
|
|
|
-+
|
|
|
-+ fusion_list_foreach (node, shmpool->nodes) {
|
|
|
-+ if (node->fusion_id == fusion_id) {
|
|
|
-+ fusion_list_remove (&shmpool->nodes, &node->link);
|
|
|
-+ break;
|
|
|
-+ }
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ up (&shmpool->entry.lock);
|
|
|
-+}
|
|
|
-+
|
|
|
-+static int
|
|
|
-+fork_node (FusionSHMPool *shmpool, FusionID fusion_id, FusionID from_id)
|
|
|
-+{
|
|
|
-+ int ret = 0;
|
|
|
-+ SHMPoolNode *node;
|
|
|
-+
|
|
|
-+ down (&shmpool->entry.lock);
|
|
|
-+
|
|
|
-+ fusion_list_foreach (node, shmpool->nodes) {
|
|
|
-+ if (node->fusion_id == from_id) {
|
|
|
-+ SHMPoolNode *new_node;
|
|
|
-+
|
|
|
-+ new_node = kmalloc (sizeof(SHMPoolNode), GFP_KERNEL);
|
|
|
-+ if (!new_node) {
|
|
|
-+ ret = -ENOMEM;
|
|
|
-+ break;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ new_node->fusion_id = fusion_id;
|
|
|
-+ new_node->count = node->count;
|
|
|
-+
|
|
|
-+ fusion_list_prepend (&shmpool->nodes, &new_node->link);
|
|
|
-+
|
|
|
-+ break;
|
|
|
-+ }
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ up (&shmpool->entry.lock);
|
|
|
-+
|
|
|
-+ return ret;
|
|
|
-+}
|
|
|
-+
|
|
|
-+static void
|
|
|
-+free_all_nodes (FusionSHMPool *shmpool)
|
|
|
-+
|
|
|
-+{
|
|
|
-+ FusionLink *n;
|
|
|
-+ SHMPoolNode *node;
|
|
|
-+
|
|
|
-+ fusion_list_foreach_safe (node, n, shmpool->nodes) {
|
|
|
-+ kfree (node);
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ shmpool->nodes = NULL;
|
|
|
-+}
|
|
|
-diff -urN linux-2.6.22.1-0rig/drivers/char/fusion/shmpool.h linux-2.6.22.1/drivers/char/fusion/shmpool.h
|
|
|
---- linux-2.6.22.1-0rig/drivers/char/fusion/shmpool.h 1970-01-01 01:00:00.000000000 +0100
|
|
|
-+++ linux-2.6.22.1/drivers/char/fusion/shmpool.h 2007-01-20 05:03:01.000000000 +0100
|
|
|
-@@ -0,0 +1,59 @@
|
|
|
-+/*
|
|
|
-+ * Fusion Kernel Module
|
|
|
-+ *
|
|
|
-+ * (c) Copyright 2002-2003 Convergence GmbH
|
|
|
-+ *
|
|
|
-+ * Written by Denis Oliver Kropp <dok@directfb.org>
|
|
|
-+ *
|
|
|
-+ *
|
|
|
-+ * This program is free software; you can redistribute it and/or
|
|
|
-+ * modify it under the terms of the GNU General Public License
|
|
|
-+ * as published by the Free Software Foundation; either version
|
|
|
-+ * 2 of the License, or (at your option) any later version.
|
|
|
-+ */
|
|
|
-+
|
|
|
-+#ifndef __FUSION__SHMPOOL_H__
|
|
|
-+#define __FUSION__SHMPOOL_H__
|
|
|
-+
|
|
|
-+#include "fusiondev.h"
|
|
|
-+#include "types.h"
|
|
|
-+
|
|
|
-+
|
|
|
-+/* module init/cleanup */
|
|
|
-+
|
|
|
-+int fusion_shmpool_init (FusionDev *dev);
|
|
|
-+void fusion_shmpool_deinit (FusionDev *dev);
|
|
|
-+
|
|
|
-+
|
|
|
-+/* public API */
|
|
|
-+
|
|
|
-+int fusion_shmpool_new (FusionDev *dev,
|
|
|
-+ FusionSHMPoolNew *pool);
|
|
|
-+
|
|
|
-+int fusion_shmpool_attach (FusionDev *dev,
|
|
|
-+ FusionSHMPoolAttach *attach,
|
|
|
-+ FusionID fusion_id);
|
|
|
-+
|
|
|
-+int fusion_shmpool_detach (FusionDev *dev,
|
|
|
-+ int id,
|
|
|
-+ FusionID fusion_id);
|
|
|
-+
|
|
|
-+int fusion_shmpool_dispatch (FusionDev *dev,
|
|
|
-+ FusionSHMPoolDispatch *dispatch,
|
|
|
-+ Fusionee *fusionee );
|
|
|
-+
|
|
|
-+int fusion_shmpool_destroy (FusionDev *dev,
|
|
|
-+ int id);
|
|
|
-+
|
|
|
-+
|
|
|
-+/* internal functions */
|
|
|
-+
|
|
|
-+void fusion_shmpool_detach_all (FusionDev *dev,
|
|
|
-+ FusionID fusion_id);
|
|
|
-+
|
|
|
-+int fusion_shmpool_fork_all (FusionDev *dev,
|
|
|
-+ FusionID fusion_id,
|
|
|
-+ FusionID from_id);
|
|
|
-+
|
|
|
-+#endif
|
|
|
-+
|
|
|
-diff -urN linux-2.6.22.1-0rig/drivers/char/fusion/skirmish.c linux-2.6.22.1/drivers/char/fusion/skirmish.c
|
|
|
---- linux-2.6.22.1-0rig/drivers/char/fusion/skirmish.c 1970-01-01 01:00:00.000000000 +0100
|
|
|
-+++ linux-2.6.22.1/drivers/char/fusion/skirmish.c 2007-01-06 14:09:45.000000000 +0100
|
|
|
-@@ -0,0 +1,397 @@
|
|
|
-+/*
|
|
|
-+ * Fusion Kernel Module
|
|
|
-+ *
|
|
|
-+ * (c) Copyright 2002-2003 Convergence GmbH
|
|
|
-+ *
|
|
|
-+ * Written by Denis Oliver Kropp <dok@directfb.org>
|
|
|
-+ *
|
|
|
-+ *
|
|
|
-+ * This program is free software; you can redistribute it and/or
|
|
|
-+ * modify it under the terms of the GNU General Public License
|
|
|
-+ * as published by the Free Software Foundation; either version
|
|
|
-+ * 2 of the License, or (at your option) any later version.
|
|
|
-+ */
|
|
|
-+
|
|
|
-+#ifdef HAVE_LINUX_CONFIG_H
|
|
|
-+#include <linux/config.h>
|
|
|
-+#endif
|
|
|
-+#include <linux/types.h>
|
|
|
-+#include <linux/kernel.h>
|
|
|
-+#include <linux/slab.h>
|
|
|
-+#include <linux/smp_lock.h>
|
|
|
-+#include <linux/sched.h>
|
|
|
-+
|
|
|
-+#include <linux/fusion.h>
|
|
|
-+
|
|
|
-+#include "fusiondev.h"
|
|
|
-+#include "fusionee.h"
|
|
|
-+#include "list.h"
|
|
|
-+#include "skirmish.h"
|
|
|
-+
|
|
|
-+
|
|
|
-+#define MAX_PRE_ACQUISITIONS 32
|
|
|
-+
|
|
|
-+
|
|
|
-+typedef struct __FUSION_FusionSkirmish FusionSkirmish;
|
|
|
-+
|
|
|
-+struct __FUSION_FusionSkirmish {
|
|
|
-+ FusionEntry entry;
|
|
|
-+
|
|
|
-+ int lock_fid; /* non-zero if locked */
|
|
|
-+ int lock_pid;
|
|
|
-+ int lock_count;
|
|
|
-+
|
|
|
-+ int lock_total;
|
|
|
-+
|
|
|
-+#ifdef FUSION_DEBUG_SKIRMISH_DEADLOCK
|
|
|
-+ int pre_acquis[MAX_PRE_ACQUISITIONS];
|
|
|
-+
|
|
|
-+ bool outer;
|
|
|
-+#endif
|
|
|
-+};
|
|
|
-+
|
|
|
-+static int
|
|
|
-+fusion_skirmish_print( FusionEntry *entry,
|
|
|
-+ void *ctx,
|
|
|
-+ char *buf )
|
|
|
-+{
|
|
|
-+ int written = 0;
|
|
|
-+ FusionSkirmish *skirmish = (FusionSkirmish*) entry;
|
|
|
-+
|
|
|
-+#ifdef FUSION_DEBUG_SKIRMISH_DEADLOCK
|
|
|
-+ int i, n;
|
|
|
-+
|
|
|
-+
|
|
|
-+ for (i=0, n=0; i<MAX_PRE_ACQUISITIONS; i++) {
|
|
|
-+ if (skirmish->pre_acquis[i]) {
|
|
|
-+ n++;
|
|
|
-+ }
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ written += sprintf( buf + written, "[%2d]%s", n, skirmish->outer ? "." : " " );
|
|
|
-+
|
|
|
-+ for (i=0, n=0; i<MAX_PRE_ACQUISITIONS; i++) {
|
|
|
-+ if (skirmish->pre_acquis[i]) {
|
|
|
-+ written += sprintf( buf + written, "%s%02x", n ? "," : "", skirmish->pre_acquis[i] - 1 );
|
|
|
-+
|
|
|
-+ n++;
|
|
|
-+ }
|
|
|
-+ }
|
|
|
-+#endif
|
|
|
-+
|
|
|
-+ if (skirmish->lock_fid) {
|
|
|
-+ if (skirmish->entry.waiters)
|
|
|
-+ return sprintf( buf + written, " - %dx [0x%08x] (%d) %d WAITING\n",
|
|
|
-+ skirmish->lock_count, skirmish->lock_fid,
|
|
|
-+ skirmish->lock_pid, skirmish->entry.waiters ) + written;
|
|
|
-+ else
|
|
|
-+ return sprintf( buf + written, " - %dx [0x%08x] (%d)\n",
|
|
|
-+ skirmish->lock_count, skirmish->lock_fid,
|
|
|
-+ skirmish->lock_pid ) + written;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ return sprintf( buf + written, "\n" ) + written;
|
|
|
-+}
|
|
|
-+
|
|
|
-+FUSION_ENTRY_CLASS( FusionSkirmish, skirmish, NULL, NULL, fusion_skirmish_print )
|
|
|
-+
|
|
|
-+/******************************************************************************/
|
|
|
-+
|
|
|
-+int
|
|
|
-+fusion_skirmish_init (FusionDev *dev)
|
|
|
-+{
|
|
|
-+ fusion_entries_init( &dev->skirmish, &skirmish_class, dev );
|
|
|
-+
|
|
|
-+ create_proc_read_entry( "skirmishs", 0, dev->proc_dir,
|
|
|
-+ fusion_entries_read_proc, &dev->skirmish );
|
|
|
-+
|
|
|
-+ return 0;
|
|
|
-+}
|
|
|
-+
|
|
|
-+void
|
|
|
-+fusion_skirmish_deinit (FusionDev *dev)
|
|
|
-+{
|
|
|
-+ remove_proc_entry ("skirmishs", dev->proc_dir);
|
|
|
-+
|
|
|
-+ fusion_entries_deinit( &dev->skirmish );
|
|
|
-+}
|
|
|
-+
|
|
|
-+/******************************************************************************/
|
|
|
-+
|
|
|
-+int
|
|
|
-+fusion_skirmish_new (FusionDev *dev, int *ret_id)
|
|
|
-+{
|
|
|
-+ return fusion_entry_create( &dev->skirmish, ret_id, NULL );
|
|
|
-+}
|
|
|
-+
|
|
|
-+int
|
|
|
-+fusion_skirmish_prevail (FusionDev *dev, int id, int fusion_id)
|
|
|
-+{
|
|
|
-+ int ret;
|
|
|
-+ FusionSkirmish *skirmish;
|
|
|
-+#ifdef FUSION_DEBUG_SKIRMISH_DEADLOCK
|
|
|
-+ FusionSkirmish *s;
|
|
|
-+ int i;
|
|
|
-+ bool outer = true;
|
|
|
-+#endif
|
|
|
-+
|
|
|
-+ dev->stat.skirmish_prevail_swoop++;
|
|
|
-+
|
|
|
-+ ret = fusion_skirmish_lock( &dev->skirmish, id, true, &skirmish );
|
|
|
-+ if (ret)
|
|
|
-+ return ret;
|
|
|
-+
|
|
|
-+ if (skirmish->lock_pid == current->pid) {
|
|
|
-+ skirmish->lock_count++;
|
|
|
-+ skirmish->lock_total++;
|
|
|
-+ fusion_skirmish_unlock( skirmish );
|
|
|
-+ up( &dev->skirmish.lock );
|
|
|
-+ return 0;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+#ifdef FUSION_DEBUG_SKIRMISH_DEADLOCK
|
|
|
-+ /* look in currently acquired skirmishs for this one being
|
|
|
-+ a pre-acquisition, indicating a potential deadlock */
|
|
|
-+ fusion_list_foreach (s, dev->skirmish.list) {
|
|
|
-+ if (s->lock_pid != current->pid)
|
|
|
-+ continue;
|
|
|
-+
|
|
|
-+ outer = false;
|
|
|
-+
|
|
|
-+ for (i=0; i<MAX_PRE_ACQUISITIONS; i++) {
|
|
|
-+ if (s->pre_acquis[i] == id + 1) {
|
|
|
-+ printk( KERN_DEBUG "FusionSkirmish: Potential deadlock "
|
|
|
-+ "between locked 0x%x and to be locked 0x%x in world %d!\n",
|
|
|
-+ s->entry.id, skirmish->entry.id, dev->index );
|
|
|
-+ }
|
|
|
-+ }
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ if (outer)
|
|
|
-+ skirmish->outer = true;
|
|
|
-+
|
|
|
-+ /* remember all previously acquired skirmishs being pre-acquisitions for
|
|
|
-+ this one, to detect potential deadlocks due to a lock order twist */
|
|
|
-+ fusion_list_foreach (s, dev->skirmish.list) {
|
|
|
-+ int free = -1;
|
|
|
-+
|
|
|
-+ if (s->lock_pid != current->pid)
|
|
|
-+ continue;
|
|
|
-+
|
|
|
-+ for (i=0; i<MAX_PRE_ACQUISITIONS; i++) {
|
|
|
-+ if (skirmish->pre_acquis[i]) {
|
|
|
-+ if (skirmish->pre_acquis[i] == s->entry.id + 1) {
|
|
|
-+ break;
|
|
|
-+ }
|
|
|
-+ }
|
|
|
-+ else
|
|
|
-+ free = i;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ /* not found? */
|
|
|
-+ if (i == MAX_PRE_ACQUISITIONS) {
|
|
|
-+ if (free != -1) {
|
|
|
-+ skirmish->pre_acquis[free] = s->entry.id + 1;
|
|
|
-+ }
|
|
|
-+ else {
|
|
|
-+ printk( KERN_DEBUG "FusionSkirmish: Too many pre-acquisitions to remember.\n" );
|
|
|
-+
|
|
|
-+ printk( KERN_DEBUG " [ '%s' ] <- ", skirmish->entry.name );
|
|
|
-+
|
|
|
-+ for (i=0; i<MAX_PRE_ACQUISITIONS; i++)
|
|
|
-+ printk( "0x%03x ", skirmish->pre_acquis[i] - 1 );
|
|
|
-+
|
|
|
-+ printk( "\n" );
|
|
|
-+ }
|
|
|
-+ }
|
|
|
-+ }
|
|
|
-+#endif
|
|
|
-+
|
|
|
-+ up( &dev->skirmish.lock );
|
|
|
-+
|
|
|
-+ while (skirmish->lock_pid) {
|
|
|
-+ ret = fusion_skirmish_wait( skirmish, NULL );
|
|
|
-+ if (ret)
|
|
|
-+ return ret;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ skirmish->lock_fid = fusion_id;
|
|
|
-+ skirmish->lock_pid = current->pid;
|
|
|
-+ skirmish->lock_count = 1;
|
|
|
-+
|
|
|
-+ skirmish->lock_total++;
|
|
|
-+
|
|
|
-+ fusion_skirmish_unlock( skirmish );
|
|
|
-+
|
|
|
-+ return 0;
|
|
|
-+}
|
|
|
-+
|
|
|
-+int
|
|
|
-+fusion_skirmish_swoop (FusionDev *dev, int id, int fusion_id)
|
|
|
-+{
|
|
|
-+ int ret;
|
|
|
-+ FusionSkirmish *skirmish;
|
|
|
-+
|
|
|
-+ ret = fusion_skirmish_lock( &dev->skirmish, id, false, &skirmish );
|
|
|
-+ if (ret)
|
|
|
-+ return ret;
|
|
|
-+
|
|
|
-+ dev->stat.skirmish_prevail_swoop++;
|
|
|
-+
|
|
|
-+ if (skirmish->lock_fid) {
|
|
|
-+ if (skirmish->lock_pid == current->pid) {
|
|
|
-+ skirmish->lock_count++;
|
|
|
-+ skirmish->lock_total++;
|
|
|
-+ fusion_skirmish_unlock( skirmish );
|
|
|
-+ return 0;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ fusion_skirmish_unlock( skirmish );
|
|
|
-+
|
|
|
-+ return -EAGAIN;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ skirmish->lock_fid = fusion_id;
|
|
|
-+ skirmish->lock_pid = current->pid;
|
|
|
-+ skirmish->lock_count = 1;
|
|
|
-+
|
|
|
-+ skirmish->lock_total++;
|
|
|
-+
|
|
|
-+ fusion_skirmish_unlock( skirmish );
|
|
|
-+
|
|
|
-+ return 0;
|
|
|
-+}
|
|
|
-+
|
|
|
-+int
|
|
|
-+fusion_skirmish_lock_count (FusionDev *dev, int id, int fusion_id, int *ret_lock_count)
|
|
|
-+{
|
|
|
-+ int ret;
|
|
|
-+ FusionSkirmish *skirmish;
|
|
|
-+
|
|
|
-+ ret = fusion_skirmish_lock( &dev->skirmish, id, false, &skirmish );
|
|
|
-+ if (ret)
|
|
|
-+ return ret;
|
|
|
-+
|
|
|
-+ if (skirmish->lock_fid == fusion_id &&
|
|
|
-+ skirmish->lock_pid == current->pid)
|
|
|
-+ {
|
|
|
-+ *ret_lock_count = skirmish->lock_count;
|
|
|
-+ }
|
|
|
-+ else
|
|
|
-+ {
|
|
|
-+ *ret_lock_count = 0;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ fusion_skirmish_unlock( skirmish );
|
|
|
-+
|
|
|
-+ return 0;
|
|
|
-+}
|
|
|
-+
|
|
|
-+int
|
|
|
-+fusion_skirmish_dismiss (FusionDev *dev, int id, int fusion_id)
|
|
|
-+{
|
|
|
-+ int ret;
|
|
|
-+ FusionSkirmish *skirmish;
|
|
|
-+
|
|
|
-+ ret = fusion_skirmish_lock( &dev->skirmish, id, false, &skirmish );
|
|
|
-+ if (ret)
|
|
|
-+ return ret;
|
|
|
-+
|
|
|
-+ dev->stat.skirmish_dismiss++;
|
|
|
-+
|
|
|
-+ if (skirmish->lock_pid != current->pid) {
|
|
|
-+ fusion_skirmish_unlock( skirmish );
|
|
|
-+ return -EIO;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ if (--skirmish->lock_count == 0) {
|
|
|
-+ skirmish->lock_fid = 0;
|
|
|
-+ skirmish->lock_pid = 0;
|
|
|
-+
|
|
|
-+ fusion_skirmish_notify( skirmish, true );
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ fusion_skirmish_unlock( skirmish );
|
|
|
-+
|
|
|
-+ return 0;
|
|
|
-+}
|
|
|
-+
|
|
|
-+int
|
|
|
-+fusion_skirmish_destroy (FusionDev *dev, int id)
|
|
|
-+{
|
|
|
-+#ifdef FUSION_DEBUG_SKIRMISH_DEADLOCK
|
|
|
-+ int i;
|
|
|
-+ FusionSkirmish *s;
|
|
|
-+
|
|
|
-+ /* Lock entries. */
|
|
|
-+ if (down_interruptible( &dev->skirmish.lock ))
|
|
|
-+ return -EINTR;
|
|
|
-+
|
|
|
-+ /* remove from all pre-acquisition lists */
|
|
|
-+ fusion_list_foreach (s, dev->skirmish.list) {
|
|
|
-+ for (i=0; i<MAX_PRE_ACQUISITIONS; i++) {
|
|
|
-+ if (s->pre_acquis[i] == id + 1)
|
|
|
-+ s->pre_acquis[i] = 0;
|
|
|
-+ }
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ up( &dev->skirmish.lock );
|
|
|
-+
|
|
|
-+ /* FIXME: gap? */
|
|
|
-+#endif
|
|
|
-+
|
|
|
-+ return fusion_entry_destroy( &dev->skirmish, id );
|
|
|
-+}
|
|
|
-+
|
|
|
-+void
|
|
|
-+fusion_skirmish_dismiss_all (FusionDev *dev, int fusion_id)
|
|
|
-+{
|
|
|
-+ FusionLink *l;
|
|
|
-+
|
|
|
-+ down (&dev->skirmish.lock);
|
|
|
-+
|
|
|
-+ fusion_list_foreach (l, dev->skirmish.list) {
|
|
|
-+ FusionSkirmish *skirmish = (FusionSkirmish *) l;
|
|
|
-+
|
|
|
-+ down (&skirmish->entry.lock);
|
|
|
-+
|
|
|
-+ if (skirmish->lock_fid == fusion_id) {
|
|
|
-+ skirmish->lock_fid = 0;
|
|
|
-+ skirmish->lock_pid = 0;
|
|
|
-+ skirmish->lock_count = 0;
|
|
|
-+
|
|
|
-+ wake_up_interruptible_all (&skirmish->entry.wait);
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ up (&skirmish->entry.lock);
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ up (&dev->skirmish.lock);
|
|
|
-+}
|
|
|
-+
|
|
|
-+void
|
|
|
-+fusion_skirmish_dismiss_all_from_pid (FusionDev *dev, int pid)
|
|
|
-+{
|
|
|
-+ FusionLink *l;
|
|
|
-+
|
|
|
-+ down (&dev->skirmish.lock);
|
|
|
-+
|
|
|
-+ fusion_list_foreach (l, dev->skirmish.list) {
|
|
|
-+ FusionSkirmish *skirmish = (FusionSkirmish *) l;
|
|
|
-+
|
|
|
-+ down (&skirmish->entry.lock);
|
|
|
-+
|
|
|
-+ if (skirmish->lock_pid == pid) {
|
|
|
-+ skirmish->lock_fid = 0;
|
|
|
-+ skirmish->lock_pid = 0;
|
|
|
-+ skirmish->lock_count = 0;
|
|
|
-+
|
|
|
-+ wake_up_interruptible_all (&skirmish->entry.wait);
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ up (&skirmish->entry.lock);
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ up (&dev->skirmish.lock);
|
|
|
-+}
|
|
|
-+
|
|
|
-diff -urN linux-2.6.22.1-0rig/drivers/char/fusion/skirmish.h linux-2.6.22.1/drivers/char/fusion/skirmish.h
|
|
|
---- linux-2.6.22.1-0rig/drivers/char/fusion/skirmish.h 1970-01-01 01:00:00.000000000 +0100
|
|
|
-+++ linux-2.6.22.1/drivers/char/fusion/skirmish.h 2006-06-30 10:54:55.000000000 +0200
|
|
|
-@@ -0,0 +1,62 @@
|
|
|
-+/*
|
|
|
-+ * Fusion Kernel Module
|
|
|
-+ *
|
|
|
-+ * (c) Copyright 2002-2003 Convergence GmbH
|
|
|
-+ *
|
|
|
-+ * Written by Denis Oliver Kropp <dok@directfb.org>
|
|
|
-+ *
|
|
|
-+ *
|
|
|
-+ * This program is free software; you can redistribute it and/or
|
|
|
-+ * modify it under the terms of the GNU General Public License
|
|
|
-+ * as published by the Free Software Foundation; either version
|
|
|
-+ * 2 of the License, or (at your option) any later version.
|
|
|
-+ */
|
|
|
-+
|
|
|
-+#ifndef __FUSION__SKIRMISH_H__
|
|
|
-+#define __FUSION__SKIRMISH_H__
|
|
|
-+
|
|
|
-+#include "fusiondev.h"
|
|
|
-+#include "types.h"
|
|
|
-+
|
|
|
-+
|
|
|
-+/* module init/cleanup */
|
|
|
-+
|
|
|
-+int fusion_skirmish_init (FusionDev *dev);
|
|
|
-+void fusion_skirmish_deinit (FusionDev *dev);
|
|
|
-+
|
|
|
-+
|
|
|
-+/* public API */
|
|
|
-+
|
|
|
-+int fusion_skirmish_new (FusionDev *dev,
|
|
|
-+ int *id);
|
|
|
-+
|
|
|
-+int fusion_skirmish_prevail (FusionDev *dev,
|
|
|
-+ int id,
|
|
|
-+ int fusion_id);
|
|
|
-+
|
|
|
-+int fusion_skirmish_swoop (FusionDev *dev,
|
|
|
-+ int id,
|
|
|
-+ int fusion_id);
|
|
|
-+
|
|
|
-+int fusion_skirmish_lock_count (FusionDev *dev,
|
|
|
-+ int id,
|
|
|
-+ int fusion_id,
|
|
|
-+ int *ret_lock_count);
|
|
|
-+
|
|
|
-+int fusion_skirmish_dismiss (FusionDev *dev,
|
|
|
-+ int id,
|
|
|
-+ int fusion_id);
|
|
|
-+
|
|
|
-+int fusion_skirmish_destroy (FusionDev *dev,
|
|
|
-+ int id);
|
|
|
-+
|
|
|
-+
|
|
|
-+/* internal functions */
|
|
|
-+
|
|
|
-+void fusion_skirmish_dismiss_all (FusionDev *dev,
|
|
|
-+ int fusion_id);
|
|
|
-+
|
|
|
-+void fusion_skirmish_dismiss_all_from_pid (FusionDev *dev,
|
|
|
-+ int pid);
|
|
|
-+
|
|
|
-+#endif
|
|
|
-diff -urN linux-2.6.22.1-0rig/drivers/char/fusion/types.h linux-2.6.22.1/drivers/char/fusion/types.h
|
|
|
---- linux-2.6.22.1-0rig/drivers/char/fusion/types.h 1970-01-01 01:00:00.000000000 +0100
|
|
|
-+++ linux-2.6.22.1/drivers/char/fusion/types.h 2007-01-20 05:03:01.000000000 +0100
|
|
|
-@@ -0,0 +1,29 @@
|
|
|
-+/*
|
|
|
-+ * Fusion Kernel Module
|
|
|
-+ *
|
|
|
-+ * (c) Copyright 2002 Convergence GmbH
|
|
|
-+ *
|
|
|
-+ * Written by Denis Oliver Kropp <dok@directfb.org>
|
|
|
-+ *
|
|
|
-+ *
|
|
|
-+ * This program is free software; you can redistribute it and/or
|
|
|
-+ * modify it under the terms of the GNU General Public License
|
|
|
-+ * as published by the Free Software Foundation; either version
|
|
|
-+ * 2 of the License, or (at your option) any later version.
|
|
|
-+ */
|
|
|
-+
|
|
|
-+#ifndef __FUSION__TYPES_H__
|
|
|
-+#define __FUSION__TYPES_H__
|
|
|
-+
|
|
|
-+#include <linux/version.h>
|
|
|
-+
|
|
|
-+#if LINUX_VERSION_CODE <= KERNEL_VERSION(2, 6, 18)
|
|
|
-+typedef enum {
|
|
|
-+ false = 0,
|
|
|
-+ true = !false
|
|
|
-+} bool;
|
|
|
-+#endif
|
|
|
-+
|
|
|
-+typedef struct __Fusion_Fusionee Fusionee;
|
|
|
-+
|
|
|
-+#endif
|
|
|
-diff -urN linux-2.6.22.1-0rig/drivers/char/Kconfig linux-2.6.22.1/drivers/char/Kconfig
|
|
|
---- linux-2.6.22.1-0rig/drivers/char/Kconfig 2007-07-10 20:56:30.000000000 +0200
|
|
|
-+++ linux-2.6.22.1/drivers/char/Kconfig 2007-08-12 19:30:42.000000000 +0200
|
|
|
-@@ -484,6 +484,8 @@
|
|
|
- All modern Linux systems use the Unix98 ptys. Say Y unless
|
|
|
- you're on an embedded system and want to conserve memory.
|
|
|
-
|
|
|
-+source "drivers/char/fusion/Kconfig"
|
|
|
-+
|
|
|
- config LEGACY_PTYS
|
|
|
- bool "Legacy (BSD) PTY support"
|
|
|
- default y
|
|
|
-diff -urN linux-2.6.22.1-0rig/drivers/char/Makefile linux-2.6.22.1/drivers/char/Makefile
|
|
|
---- linux-2.6.22.1-0rig/drivers/char/Makefile 2007-07-10 20:56:30.000000000 +0200
|
|
|
-+++ linux-2.6.22.1/drivers/char/Makefile 2007-08-12 19:45:20.000000000 +0200
|
|
|
-@@ -100,6 +100,7 @@
|
|
|
- obj-$(CONFIG_DRM) += drm/
|
|
|
- obj-$(CONFIG_PCMCIA) += pcmcia/
|
|
|
- obj-$(CONFIG_IPMI_HANDLER) += ipmi/
|
|
|
-+obj-$(CONFIG_FUSION_DEVICE) += fusion/
|
|
|
-
|
|
|
- obj-$(CONFIG_HANGCHECK_TIMER) += hangcheck-timer.o
|
|
|
- obj-$(CONFIG_TCG_TPM) += tpm/
|
|
|
-diff -urN linux-2.6.22.1-0rig/include/linux/fusion.h linux-2.6.22.1/include/linux/fusion.h
|
|
|
---- linux-2.6.22.1-0rig/include/linux/fusion.h 1970-01-01 01:00:00.000000000 +0100
|
|
|
-+++ linux-2.6.22.1/include/linux/fusion.h 2007-01-29 01:43:50.000000000 +0100
|
|
|
-@@ -0,0 +1,277 @@
|
|
|
-+#ifndef __LINUX__FUSION_H__
|
|
|
-+#define __LINUX__FUSION_H__
|
|
|
-+
|
|
|
-+#include <asm/ioctl.h>
|
|
|
-+
|
|
|
-+/*
|
|
|
-+ * Fusion Kernel Device API Version
|
|
|
-+ */
|
|
|
-+#define FUSION_API_MAJOR 3 /* Increased if backward compatibility is dropped. */
|
|
|
-+#define FUSION_API_MINOR 2 /* Increased if new features are added. */
|
|
|
-+
|
|
|
-+/*
|
|
|
-+ * The Fusion ID is a unique identifier for one process consisting of threads.
|
|
|
-+ */
|
|
|
-+typedef unsigned long FusionID;
|
|
|
-+
|
|
|
-+#define FUSION_ID_MASTER 1 /* This is the fusion id of the master (first process). */
|
|
|
-+
|
|
|
-+/*
|
|
|
-+ * Entering a world
|
|
|
-+ */
|
|
|
-+typedef struct {
|
|
|
-+ struct {
|
|
|
-+ int major; /* Must be set to FUSION_API_MAJOR before entering. */
|
|
|
-+ int minor; /* Must be set to FUSION_API_MINOR before entering. */
|
|
|
-+ } api;
|
|
|
-+
|
|
|
-+ FusionID fusion_id; /* Returns the fusion id of the entering process. */
|
|
|
-+} FusionEnter;
|
|
|
-+
|
|
|
-+/*
|
|
|
-+ * Forking in world
|
|
|
-+ */
|
|
|
-+typedef struct {
|
|
|
-+ FusionID fusion_id; /* Returns the fusion id of the new (forked) fusionee. */
|
|
|
-+} FusionFork;
|
|
|
-+
|
|
|
-+/*
|
|
|
-+ * Sending a message
|
|
|
-+ */
|
|
|
-+typedef struct {
|
|
|
-+ FusionID fusion_id; /* recipient */
|
|
|
-+
|
|
|
-+ int msg_id; /* optional message identifier */
|
|
|
-+ int msg_size; /* message size, must be greater than zero */
|
|
|
-+ const void *msg_data; /* message data, must not be NULL */
|
|
|
-+} FusionSendMessage;
|
|
|
-+
|
|
|
-+/*
|
|
|
-+ * Receiving a message
|
|
|
-+ */
|
|
|
-+typedef enum {
|
|
|
-+ FMT_SEND, /* msg_id is an optional custom id */
|
|
|
-+ FMT_CALL, /* msg_id is the call id */
|
|
|
-+ FMT_REACTOR, /* msg_id is the reactor id */
|
|
|
-+ FMT_SHMPOOL /* msg_id is the pool id */
|
|
|
-+} FusionMessageType;
|
|
|
-+
|
|
|
-+typedef struct {
|
|
|
-+ FusionMessageType msg_type; /* type (origin) of message */
|
|
|
-+
|
|
|
-+ int msg_id; /* message id (custom id or call/reactor/pool id) */
|
|
|
-+ int msg_size; /* size of the following message data */
|
|
|
-+
|
|
|
-+ /* message data follows */
|
|
|
-+} FusionReadMessage;
|
|
|
-+
|
|
|
-+/*
|
|
|
-+ * Dispatching a message via a reactor
|
|
|
-+ */
|
|
|
-+typedef struct {
|
|
|
-+ int reactor_id;
|
|
|
-+ int self;
|
|
|
-+
|
|
|
-+ int msg_size; /* message size, must be greater than zero */
|
|
|
-+ const void *msg_data; /* message data, must not be NULL */
|
|
|
-+} FusionReactorDispatch;
|
|
|
-+
|
|
|
-+/*
|
|
|
-+ * Calling (synchronous RPC)
|
|
|
-+ */
|
|
|
-+typedef struct {
|
|
|
-+ int call_id; /* new call id returned */
|
|
|
-+
|
|
|
-+ void *handler; /* function pointer of handler to install */
|
|
|
-+ void *ctx; /* optional handler context */
|
|
|
-+} FusionCallNew;
|
|
|
-+
|
|
|
-+typedef enum {
|
|
|
-+ FCEF_NONE = 0x00000000,
|
|
|
-+ FCEF_ONEWAY = 0x00000001,
|
|
|
-+ FCEF_ALL = 0x00000001
|
|
|
-+} FusionCallExecFlags;
|
|
|
-+
|
|
|
-+typedef struct {
|
|
|
-+ int ret_val; /* return value of the call */
|
|
|
-+
|
|
|
-+ int call_id; /* id of the requested call, each call has a fixed owner */
|
|
|
-+
|
|
|
-+ int call_arg; /* optional int argument */
|
|
|
-+ void *call_ptr; /* optional pointer argument (shared memory) */
|
|
|
-+
|
|
|
-+ FusionCallExecFlags flags; /* execution flags */
|
|
|
-+} FusionCallExecute;
|
|
|
-+
|
|
|
-+typedef struct {
|
|
|
-+ int call_id; /* id of currently executing call */
|
|
|
-+
|
|
|
-+ int val; /* value to return */
|
|
|
-+} FusionCallReturn;
|
|
|
-+
|
|
|
-+typedef struct {
|
|
|
-+ void *handler; /* function pointer of handler to call */
|
|
|
-+ void *ctx; /* optional handler context */
|
|
|
-+
|
|
|
-+ int caller; /* fusion id of the caller or zero if called from Fusion */
|
|
|
-+ int call_arg; /* optional call parameter */
|
|
|
-+ void *call_ptr; /* optional call parameter */
|
|
|
-+} FusionCallMessage;
|
|
|
-+
|
|
|
-+/*
|
|
|
-+ * Watching a reference
|
|
|
-+ *
|
|
|
-+ * This information is needed to have a specific call being executed if the
|
|
|
-+ * reference count reaches zero. Currently one watch per reference is allowed.
|
|
|
-+ *
|
|
|
-+ * The call is made by Fusion and therefor has a caller id of zero.
|
|
|
-+ *
|
|
|
-+ */
|
|
|
-+typedef struct {
|
|
|
-+ int id; /* id of the reference to watch */
|
|
|
-+
|
|
|
-+ int call_id; /* id of the call to execute */
|
|
|
-+ int call_arg; /* optional call parameter, e.g. the id of a user
|
|
|
-+ space resource associated with that reference */
|
|
|
-+} FusionRefWatch;
|
|
|
-+
|
|
|
-+/*
|
|
|
-+ * Inheriting local count from other reference
|
|
|
-+ */
|
|
|
-+typedef struct {
|
|
|
-+ int id; /* own reference id */
|
|
|
-+ int from; /* id of the reference to inherit from */
|
|
|
-+} FusionRefInherit;
|
|
|
-+
|
|
|
-+/*
|
|
|
-+ * Killing other fusionees (experimental)
|
|
|
-+ */
|
|
|
-+typedef struct {
|
|
|
-+ FusionID fusion_id; /* fusionee to kill, zero means all but ourself */
|
|
|
-+ int signal; /* signal to be delivered, e.g. SIGTERM */
|
|
|
-+ int timeout_ms; /* -1 means no timeout, 0 means infinite, otherwise the
|
|
|
-+ max. time to wait until the fusionee(s) terminated */
|
|
|
-+} FusionKill;
|
|
|
-+
|
|
|
-+
|
|
|
-+/*
|
|
|
-+ * Shared memory pools
|
|
|
-+ */
|
|
|
-+typedef struct {
|
|
|
-+ int max_size; /* Maximum size that this pool will be allowed to grow to. */
|
|
|
-+
|
|
|
-+ int pool_id; /* Returns the new pool id. */
|
|
|
-+ void *addr_base; /* Returns the base of the reserved virtual memory address space. */
|
|
|
-+} FusionSHMPoolNew;
|
|
|
-+
|
|
|
-+typedef struct {
|
|
|
-+ int pool_id; /* The id of the pool to attach to. */
|
|
|
-+
|
|
|
-+ void *addr_base; /* Returns the base of the reserved virtual memory address space. */
|
|
|
-+ int size; /* Returns the current size of the pool. */
|
|
|
-+} FusionSHMPoolAttach;
|
|
|
-+
|
|
|
-+typedef struct {
|
|
|
-+ int pool_id; /* The id of the pool to notify. */
|
|
|
-+
|
|
|
-+ int size; /* New size of the pool. */
|
|
|
-+} FusionSHMPoolDispatch;
|
|
|
-+
|
|
|
-+typedef enum {
|
|
|
-+ FSMT_REMAP, /* Remap the pool due to a change of its size. */
|
|
|
-+ FSMT_UNMAP /* Unmap the pool due to its destruction. */
|
|
|
-+} FusionSHMPoolMessageType;
|
|
|
-+
|
|
|
-+typedef struct {
|
|
|
-+ FusionSHMPoolMessageType type; /* Type of the message. */
|
|
|
-+
|
|
|
-+ int size; /* New size of the pool, if type is FSMT_REMAP. */
|
|
|
-+} FusionSHMPoolMessage;
|
|
|
-+
|
|
|
-+
|
|
|
-+/*
|
|
|
-+ * Fusion types
|
|
|
-+ */
|
|
|
-+typedef enum {
|
|
|
-+ FT_LOUNGE,
|
|
|
-+ FT_MESSAGING,
|
|
|
-+ FT_CALL,
|
|
|
-+ FT_REF,
|
|
|
-+ FT_SKIRMISH,
|
|
|
-+ FT_PROPERTY,
|
|
|
-+ FT_REACTOR,
|
|
|
-+ FT_SHMPOOL
|
|
|
-+} FusionType;
|
|
|
-+
|
|
|
-+
|
|
|
-+/*
|
|
|
-+ * Set attributes like 'name' for an entry of the specified type.
|
|
|
-+ */
|
|
|
-+#define FUSION_ENTRY_INFO_NAME_LENGTH 24
|
|
|
-+
|
|
|
-+typedef struct {
|
|
|
-+ FusionType type;
|
|
|
-+ int id;
|
|
|
-+
|
|
|
-+ char name[FUSION_ENTRY_INFO_NAME_LENGTH];
|
|
|
-+} FusionEntryInfo;
|
|
|
-+
|
|
|
-+
|
|
|
-+
|
|
|
-+#define FUSION_ENTER _IOR(FT_LOUNGE, 0x00, FusionEnter)
|
|
|
-+#define FUSION_UNBLOCK _IO (FT_LOUNGE, 0x01)
|
|
|
-+#define FUSION_KILL _IOW(FT_LOUNGE, 0x02, FusionKill)
|
|
|
-+
|
|
|
-+#define FUSION_ENTRY_SET_INFO _IOW(FT_LOUNGE, 0x03, FusionEntryInfo)
|
|
|
-+#define FUSION_ENTRY_GET_INFO _IOW(FT_LOUNGE, 0x04, FusionEntryInfo)
|
|
|
-+
|
|
|
-+#define FUSION_FORK _IOW(FT_LOUNGE, 0x05, FusionFork)
|
|
|
-+
|
|
|
-+#define FUSION_SEND_MESSAGE _IOW(FT_MESSAGING, 0x00, FusionSendMessage)
|
|
|
-+
|
|
|
-+#define FUSION_CALL_NEW _IOW(FT_CALL, 0x00, FusionCallNew)
|
|
|
-+#define FUSION_CALL_EXECUTE _IOW(FT_CALL, 0x01, FusionCallExecute)
|
|
|
-+#define FUSION_CALL_RETURN _IOW(FT_CALL, 0x02, FusionCallReturn)
|
|
|
-+#define FUSION_CALL_DESTROY _IOW(FT_CALL, 0x03, int)
|
|
|
-+
|
|
|
-+#define FUSION_REF_NEW _IOW(FT_REF, 0x00, int)
|
|
|
-+#define FUSION_REF_UP _IOW(FT_REF, 0x01, int)
|
|
|
-+#define FUSION_REF_UP_GLOBAL _IOW(FT_REF, 0x02, int)
|
|
|
-+#define FUSION_REF_DOWN _IOW(FT_REF, 0x03, int)
|
|
|
-+#define FUSION_REF_DOWN_GLOBAL _IOW(FT_REF, 0x04, int)
|
|
|
-+#define FUSION_REF_ZERO_LOCK _IOW(FT_REF, 0x05, int)
|
|
|
-+#define FUSION_REF_ZERO_TRYLOCK _IOW(FT_REF, 0x06, int)
|
|
|
-+#define FUSION_REF_UNLOCK _IOW(FT_REF, 0x07, int)
|
|
|
-+#define FUSION_REF_STAT _IOW(FT_REF, 0x08, int)
|
|
|
-+#define FUSION_REF_WATCH _IOW(FT_REF, 0x09, FusionRefWatch)
|
|
|
-+#define FUSION_REF_INHERIT _IOW(FT_REF, 0x0A, FusionRefInherit)
|
|
|
-+#define FUSION_REF_DESTROY _IOW(FT_REF, 0x0B, int)
|
|
|
-+
|
|
|
-+#define FUSION_SKIRMISH_NEW _IOW(FT_SKIRMISH, 0x00, int)
|
|
|
-+#define FUSION_SKIRMISH_PREVAIL _IOW(FT_SKIRMISH, 0x01, int)
|
|
|
-+#define FUSION_SKIRMISH_SWOOP _IOW(FT_SKIRMISH, 0x02, int)
|
|
|
-+#define FUSION_SKIRMISH_DISMISS _IOW(FT_SKIRMISH, 0x03, int)
|
|
|
-+#define FUSION_SKIRMISH_DESTROY _IOW(FT_SKIRMISH, 0x04, int)
|
|
|
-+#define FUSION_SKIRMISH_LOCK_COUNT _IOW(FT_SKIRMISH, 0x05, int)
|
|
|
-+
|
|
|
-+#define FUSION_PROPERTY_NEW _IOW(FT_PROPERTY, 0x00, int)
|
|
|
-+#define FUSION_PROPERTY_LEASE _IOW(FT_PROPERTY, 0x01, int)
|
|
|
-+#define FUSION_PROPERTY_PURCHASE _IOW(FT_PROPERTY, 0x02, int)
|
|
|
-+#define FUSION_PROPERTY_CEDE _IOW(FT_PROPERTY, 0x03, int)
|
|
|
-+#define FUSION_PROPERTY_HOLDUP _IOW(FT_PROPERTY, 0x04, int)
|
|
|
-+#define FUSION_PROPERTY_DESTROY _IOW(FT_PROPERTY, 0x05, int)
|
|
|
-+
|
|
|
-+#define FUSION_REACTOR_NEW _IOW(FT_REACTOR, 0x00, int)
|
|
|
-+#define FUSION_REACTOR_ATTACH _IOW(FT_REACTOR, 0x01, int)
|
|
|
-+#define FUSION_REACTOR_DETACH _IOW(FT_REACTOR, 0x02, int)
|
|
|
-+#define FUSION_REACTOR_DISPATCH _IOW(FT_REACTOR, 0x03, FusionReactorDispatch)
|
|
|
-+#define FUSION_REACTOR_DESTROY _IOW(FT_REACTOR, 0x04, int)
|
|
|
-+
|
|
|
-+#define FUSION_SHMPOOL_NEW _IOW(FT_SHMPOOL, 0x00, FusionSHMPoolNew)
|
|
|
-+#define FUSION_SHMPOOL_ATTACH _IOW(FT_SHMPOOL, 0x01, FusionSHMPoolAttach)
|
|
|
-+#define FUSION_SHMPOOL_DETACH _IOW(FT_SHMPOOL, 0x02, int)
|
|
|
-+#define FUSION_SHMPOOL_DISPATCH _IOW(FT_SHMPOOL, 0x03, FusionSHMPoolDispatch)
|
|
|
-+#define FUSION_SHMPOOL_DESTROY _IOW(FT_SHMPOOL, 0x04, int)
|
|
|
-+
|
|
|
-+#endif
|
|
|
-+
|
Ulf Samuelsson