--- /dev/null
+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
++
projects / buildroot.git / commitdiff