fusiondev.c

linux下的fusion程序,可以和directfb配合使用

     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_channel, send.msg_size, send.msg_data,
                                             NULL, NULL, 0);
     }

     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;
     FusionSkirmishWait wait;
     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;

          case _IOC_NR(FUSION_SKIRMISH_WAIT):
               if (copy_from_user (&wait, (FusionSkirmishWait*) arg, sizeof(wait)))
                    return -EFAULT;

               return fusion_skirmish_wait_ (dev, wait.id, fusion_id, wait.timeout);

          case _IOC_NR(FUSION_SKIRMISH_NOTIFY):
               if (get_user (id, (int*) arg))
                    return -EFAULT;

               return fusion_skirmish_notify_ (dev, id, fusion_id);
     }

     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))