syscall.c

xenomai 很好的linux实时补丁

    sem = (RT_SEM *)xnregistry_fetch(ph.opaque);

    if (!sem)
	return -ESRCH;

    __xn_copy_from_user(curr,&timeout,(void __user *)__xn_reg_arg2(regs),sizeof(timeout));

    return rt_sem_p(sem,timeout);
}

/*
 * int __rt_sem_v(RT_SEM_PLACEHOLDER *ph)
 */

static int __rt_sem_v (struct task_struct *curr, struct pt_regs *regs)

{
    RT_SEM_PLACEHOLDER ph;
    RT_SEM *sem;

    if (!__xn_access_ok(curr,VERIFY_READ,__xn_reg_arg1(regs),sizeof(ph)))
	return -EFAULT;

    __xn_copy_from_user(curr,&ph,(void __user *)__xn_reg_arg1(regs),sizeof(ph));

    sem = (RT_SEM *)xnregistry_fetch(ph.opaque);

    if (!sem)
	return -ESRCH;

    return rt_sem_v(sem);
}

/*
 * int __rt_sem_broadcast(RT_SEM_PLACEHOLDER *ph)
 */

static int __rt_sem_broadcast (struct task_struct *curr, struct pt_regs *regs)

{
    RT_SEM_PLACEHOLDER ph;
    RT_SEM *sem;

    if (!__xn_access_ok(curr,VERIFY_READ,__xn_reg_arg1(regs),sizeof(ph)))
	return -EFAULT;

    __xn_copy_from_user(curr,&ph,(void __user *)__xn_reg_arg1(regs),sizeof(ph));

    sem = (RT_SEM *)xnregistry_fetch(ph.opaque);

    if (!sem)
	return -ESRCH;

    return rt_sem_broadcast(sem);
}

/*
 * int __rt_sem_inquire(RT_SEM_PLACEHOLDER *ph,
 *                      RT_SEM_INFO *infop)
 */

static int __rt_sem_inquire (struct task_struct *curr, struct pt_regs *regs)

{
    RT_SEM_PLACEHOLDER ph;
    RT_SEM_INFO info;
    RT_SEM *sem;
    int err;

    if (!__xn_access_ok(curr,VERIFY_READ,__xn_reg_arg1(regs),sizeof(ph)))
	return -EFAULT;

    if (!__xn_access_ok(curr,VERIFY_WRITE,__xn_reg_arg2(regs),sizeof(info)))
	return -EFAULT;

    __xn_copy_from_user(curr,&ph,(void __user *)__xn_reg_arg1(regs),sizeof(ph));

    sem = (RT_SEM *)xnregistry_fetch(ph.opaque);

    if (!sem)
	return -ESRCH;

    err = rt_sem_inquire(sem,&info);

    if (!err)
	__xn_copy_to_user(curr,(void __user *)__xn_reg_arg2(regs),&info,sizeof(info));

    return err;
}

#else /* !CONFIG_XENO_OPT_NATIVE_SEM */

#define __rt_sem_create    __rt_call_not_available
#define __rt_sem_bind      __rt_call_not_available
#define __rt_sem_delete    __rt_call_not_available
#define __rt_sem_p         __rt_call_not_available
#define __rt_sem_v         __rt_call_not_available
#define __rt_sem_broadcast __rt_call_not_available
#define __rt_sem_inquire   __rt_call_not_available

#endif /* CONFIG_XENO_OPT_NATIVE_SEM */

#ifdef CONFIG_XENO_OPT_NATIVE_EVENT

/*
 * int __rt_event_create(RT_EVENT_PLACEHOLDER *ph,
 *                       const char *name,
 *                       unsigned ivalue,
 *                       int mode)
 */

static int __rt_event_create (struct task_struct *curr, struct pt_regs *regs)

{
    char name[XNOBJECT_NAME_LEN];
    RT_EVENT_PLACEHOLDER ph;
    unsigned ivalue;
    RT_EVENT *event;
    int err, mode;

    if (!__xn_access_ok(curr,VERIFY_WRITE,__xn_reg_arg1(regs),sizeof(ph)))
	return -EFAULT;

    if (__xn_reg_arg2(regs))
	{
	if (!__xn_access_ok(curr,VERIFY_READ,__xn_reg_arg2(regs),sizeof(name)))
	    return -EFAULT;

	__xn_strncpy_from_user(curr,name,(const char __user *)__xn_reg_arg2(regs),sizeof(name) - 1);
	name[sizeof(name) - 1] = '\0';
	}
    else
	*name = '\0';

    /* Initial event mask value. */
    ivalue = (unsigned)__xn_reg_arg3(regs);
    /* Creation mode. */
    mode = (int)__xn_reg_arg4(regs);

    event = (RT_EVENT *)xnmalloc(sizeof(*event));

    if (!event)
	return -ENOMEM;

    err = rt_event_create(event,name,ivalue,mode);

    if (err == 0)
	{
	event->cpid = curr->pid;
	/* Copy back the registry handle to the ph struct. */
	ph.opaque = event->handle;
	__xn_copy_to_user(curr,(void __user *)__xn_reg_arg1(regs),&ph,sizeof(ph));
	}
    else
	xnfree(event);

    return err;
}

/*
 * int __rt_event_bind(RT_EVENT_PLACEHOLDER *ph,
 *                     const char *name,
 *                     RTIME *timeoutp)
 */

static int __rt_event_bind (struct task_struct *curr, struct pt_regs *regs)

{
    RT_EVENT_PLACEHOLDER ph;
    int err;

    if (!__xn_access_ok(curr,VERIFY_WRITE,__xn_reg_arg1(regs),sizeof(ph)))
	return -EFAULT;

    err = __rt_bind_helper(curr,regs,&ph.opaque,XENO_EVENT_MAGIC,NULL);

    if (!err)
	__xn_copy_to_user(curr,(void __user *)__xn_reg_arg1(regs),&ph,sizeof(ph));

    return err;
}

/*
 * int __rt_event_delete(RT_EVENT_PLACEHOLDER *ph)
 */

static int __rt_event_delete (struct task_struct *curr, struct pt_regs *regs)

{
    RT_EVENT_PLACEHOLDER ph;
    RT_EVENT *event;
    int err;

    if (!__xn_access_ok(curr,VERIFY_READ,__xn_reg_arg1(regs),sizeof(ph)))
	return -EFAULT;

    __xn_copy_from_user(curr,&ph,(void __user *)__xn_reg_arg1(regs),sizeof(ph));

    event = (RT_EVENT *)xnregistry_fetch(ph.opaque);

    if (!event)
	return -ESRCH;

    err = rt_event_delete(event);

    if (!err && event->cpid)
	xnfree(event);

    return err;
}

/*
 * int __rt_event_wait(RT_EVENT_PLACEHOLDER *ph,
                       unsigned long mask,
                       unsigned long *mask_r,
                       int mode,
 *                     RTIME *timeoutp)
 */

static int __rt_event_wait (struct task_struct *curr, struct pt_regs *regs)

{
    unsigned long mask, mask_r;
    RT_EVENT_PLACEHOLDER ph;
    RT_EVENT *event;
    RTIME timeout;
    int mode, err;

    if (!__xn_access_ok(curr,VERIFY_READ,__xn_reg_arg1(regs),sizeof(ph)) ||
	!__xn_access_ok(curr,VERIFY_WRITE,__xn_reg_arg3(regs),sizeof(mask_r)))
	return -EFAULT;

    __xn_copy_from_user(curr,&ph,(void __user *)__xn_reg_arg1(regs),sizeof(ph));

    event = (RT_EVENT *)xnregistry_fetch(ph.opaque);

    if (!event)
	return -ESRCH;

    mask = (unsigned long)__xn_reg_arg2(regs);
    mode = (int)__xn_reg_arg4(regs);
    __xn_copy_from_user(curr,&timeout,(void __user *)__xn_reg_arg5(regs),sizeof(timeout));

    err = rt_event_wait(event,mask,&mask_r,mode,timeout);

    __xn_copy_to_user(curr,(void __user *)__xn_reg_arg3(regs),&mask_r,sizeof(mask_r));

    return err;
}

/*
 * int __rt_event_signal(RT_EVENT_PLACEHOLDER *ph,
 *                       unsigned long mask)
 */

static int __rt_event_signal (struct task_struct *curr, struct pt_regs *regs)

{
    RT_EVENT_PLACEHOLDER ph;
    unsigned long mask;
    RT_EVENT *event;

    if (!__xn_access_ok(curr,VERIFY_READ,__xn_reg_arg1(regs),sizeof(ph)))
	return -EFAULT;

    __xn_copy_from_user(curr,&ph,(void __user *)__xn_reg_arg1(regs),sizeof(ph));

    event = (RT_EVENT *)xnregistry_fetch(ph.opaque);

    if (!event)
	return -ESRCH;

    mask = (unsigned long)__xn_reg_arg2(regs);

    return rt_event_signal(event,mask);
}

/*
 * int __rt_event_clear(RT_EVENT_PLACEHOLDER *ph,
 *                      unsigned long mask,
 *                      unsigned long *mask_r)
 */

static int __rt_event_clear (struct task_struct *curr, struct pt_regs *regs)

{
    unsigned long mask, mask_r;
    RT_EVENT_PLACEHOLDER ph;
    RT_EVENT *event;
    int err;

    if (!__xn_access_ok(curr,VERIFY_READ,__xn_reg_arg1(regs),sizeof(ph)))
	return -EFAULT;

    if (__xn_reg_arg3(regs) &&
	!__xn_access_ok(curr,VERIFY_WRITE,__xn_reg_arg3(regs),sizeof(mask_r)))
	return -EFAULT;

    __xn_copy_from_user(curr,&ph,(void __user *)__xn_reg_arg1(regs),sizeof(ph));

    event = (RT_EVENT *)xnregistry_fetch(ph.opaque);

    if (!event)
	return -ESRCH;

    mask = (unsigned long)__xn_reg_arg2(regs);

    err = rt_event_clear(event,mask,&mask_r);

    if (!err && __xn_reg_arg3(regs))
	__xn_copy_to_user(curr,(void __user *)__xn_reg_arg3(regs),&mask_r,sizeof(mask_r));

    return err;
}

/*
 * int __rt_event_inquire(RT_EVENT_PLACEHOLDER *ph,
 *                        RT_EVENT_INFO *infop)
 */

static int __rt_event_inquire (struct task_struct *curr, struct pt_regs *regs)

{
    RT_EVENT_PLACEHOLDER ph;
    RT_EVENT_INFO info;
    RT_EVENT *event;
    int err;

    if (!__xn_access_ok(curr,VERIFY_READ,__xn_reg_arg1(regs),sizeof(ph)))
	return -EFAULT;

    if (!__xn_access_ok(curr,VERIFY_WRITE,__xn_reg_arg2(regs),sizeof(info)))
	return -EFAULT;

    __xn_copy_from_user(curr,&ph,(void __user *)__xn_reg_arg1(regs),sizeof(ph));

    event = (RT_EVENT *)xnregistry_fetch(ph.opaque);

    if (!event)
	return -ESRCH;

    err = rt_event_inquire(event,&info);

    if (!err)
	__xn_copy_to_user(curr,(void __user *)__xn_reg_arg2(regs),&info,sizeof(info));

    return err;
}

#else /* !CONFIG_XENO_OPT_NATIVE_EVENT */

#define __rt_event_create  __rt_call_not_available
#define __rt_event_bind    __rt_call_not_available
#define __rt_event_delete  __rt_call_not_available
#define __rt_event_wait    __rt_call_not_available
#define __rt_event_signal  __rt_call_not_available
#define __rt_event_clear   __rt_call_not_available
#define __rt_event_inquire __rt_call_not_available

#endif /* CONFIG_XENO_OPT_NATIVE_EVENT */

#ifdef CONFIG_XENO_OPT_NATIVE_MUTEX

/*
 * int __rt_mutex_create(RT_MUTEX_PLACEHOLDER *ph,
 *                       const char *name)
 */

static int __rt_mutex_create (struct task_struct *curr, struct pt_regs *regs)

{
    char name[XNOBJECT_NAME_LEN];
    RT_MUTEX_PLACEHOLDER ph;
    RT_MUTEX *mutex;
    int err;

    if (!__xn_access_ok(curr,VERIFY_WRITE,__xn_reg_arg1(regs),sizeof(ph)))
	return -EFAULT;

    if (__xn_reg_arg2(regs))
	{
	if (!__xn_access_ok(curr,VERIFY_READ,__xn_reg_arg2(regs),sizeof(name)))
	    return -EFAULT;

	__xn_strncpy_from_user(curr,name,(const char __user *)__xn_reg_arg2(regs),sizeof(name) - 1);
	name[sizeof(name) - 1] = '\0';
	}
    else
	*name = '\0';

    mutex = (RT_MUTEX *)xnmalloc(sizeof(*mutex));

    if (!mutex)
	return -ENOMEM;

    err = rt_mutex_create(mutex,name);

    if (err == 0)
	{
	mutex->cpid = curr->pid;
	/* Copy back the registry handle to the ph struct. */
	ph.opaque = mutex->handle;
	__xn_copy_to_user(curr,(void __user *)__xn_reg_arg1(regs),&ph,sizeof(ph));
	}
    else
	xnfree(mutex);

    return err;
}

/*
 * int __rt_mutex_bind(RT_MUTEX_PLACEHOLDER *ph,
 *                     const char *name,
 *                     RTIME *timeoutp)
 */

static int __rt_mutex_bind (struct task_struct *curr, struct pt_regs *regs)

{
    RT_MUTEX_PLACEHOLDER ph;
    int err;

    if (!__xn_access_ok(curr,VERIFY_WRITE,__xn_reg_arg1(regs),sizeof(ph)))
	return -EFAULT;

    err = __rt_bind_helper(curr,regs,&ph.opaque,XENO_MUTEX_MAGIC,NULL);

    if (!err)
	__xn_copy_to_user(curr,(void __user *)__xn_reg_arg1(regs),&ph,sizeof(ph));

    return err;
}

/*
 * int __rt_mutex_delete(RT_MUTEX_PLACEHOLDER *ph)
 */

static int __rt_mutex_delete (struct task_struct *curr, struct pt_regs *regs)

{
    RT_MUTEX_PLACEHOLDER ph;
    RT_MUTEX *mutex;
    int err;

    if (!__xn_access_ok(curr,VERIFY_READ,__xn_reg_arg1(regs),sizeof(ph)))
	return -EFAULT;

    __xn_copy_from_user(curr,&ph,(void __user *)__xn_reg_arg1(regs),sizeof(ph));

    mutex = (RT_MUTEX *)xnregistry_fetch(ph.opaque);

    if (!mutex)
	return -ESRCH;

    err = rt_mutex_delete(mutex);

    if (!err && mutex->cpid)
	xnfree(mutex);

    return err;
}

/*
 * int __rt_mutex_lock(RT_MUTEX_PLACEHOLDER *ph,
 *                     RTIME *timeoutp)
 *
 */

static int __rt_mutex_lock (struct task_struct *curr, struct pt_regs *regs)

{
    RT_MUTEX_PLACEHOLDER ph;
    RT_MUTEX *mutex;
    RTIME timeout;

    if (!__xn_access_ok(curr,VERIFY_READ,__xn_reg_arg1(regs),sizeof(ph)))
	return -EFAULT;

    __xn_copy_from_user(curr,&ph,(void __user *)__xn_reg_arg1(regs),sizeof(ph));
    __xn_copy_from_user(curr,&timeout,(void __user *)__xn_reg_arg2(regs),sizeof(timeout));

    mutex = (RT_MUTEX *)xnregistry_fetch(ph.opaque);

    if (!mutex)
	return -ESRCH;

    return rt_mutex_lock(mutex,timeout);
}

/*
 * int __rt_mutex_unlock(RT_MUTEX_PLACEHOLDER *ph)
 */

static int __rt_mutex_unlock (struct task_struct *curr, struct pt_regs *regs)

{
    RT_MUTEX_PLACEHOLDER ph;
    RT_MUTEX *mutex;

    if (!__xn_access_ok(curr,VERIFY_READ,__xn_reg_arg1(regs),sizeof(ph)))
	return -EFAULT;

    __xn_copy_from_user(curr,&ph,(void __user *)__xn_reg_arg1(regs),sizeof(ph));

    mutex = (RT_MUTEX *)xnregistry_fetch(ph.opaque);

    if (!mutex)
	return -ESRCH;

    return rt_mutex_unlock(mutex);
}

/*
 * int __rt_mutex_inquire(RT_MUTEX_PLACEHOLDER *ph,
 *                        RT_MUTEX_INFO *infop)
 */

static int __rt_mutex_inquire (struct task_struct *curr, struct pt_regs *regs)

{
    RT_MUTEX_PLACEHOLDER ph;
    RT_MUTEX_INFO info;
    RT_MUTEX *mutex;
    int err;

    if (!__xn_access_ok(curr,VERIFY_READ,__xn_reg_arg1(regs),sizeof(ph)))
	return -EFAULT;

    if (!__xn_access_ok(curr,VERIFY_WRITE,__xn_reg_arg2(regs),sizeof(info)))
	return -EFAULT;

    __xn_copy_from_user(curr,&ph,(void __user *)__xn_reg_arg1(regs),sizeof(ph));

    mutex = (RT_MUTEX *)xnregistry_fetch(ph.opaque);

    if (!mutex)
	return -ESRCH;

    err = rt_mutex_inquire(mutex,&info);

    if (!err)
	__xn_copy_to_user(curr,(void __user *)__xn_reg_arg2(regs),&info,sizeof(info));

    return err;
}

#else /* !CONFIG_XENO_OPT_NATIVE_MUTEX */

#define __rt_mutex_create  __rt_call_not_available
#define __rt_mutex_bind    __rt_call_not_available
#define __rt_mutex_delete  __rt_call_not_available
#define __rt_mutex_lock    __rt_call_not_available
#define __rt_mutex_unlock  __rt_call_not_available
#define __rt_mutex_inquire __rt_call_not_available

#endif /* CONFIG_XENO_OPT_NATIVE_MUTEX */

#ifdef CONFIG_XENO_OPT_NATIVE_COND

/*
 * int __rt_cond_create(RT_COND_PLACEHOLDER *ph,
 *                      const char *name)
 */

static int __rt_cond_create (struct task_struct *curr, struct pt_regs *regs)

{