syscall.c

来自「xenomai 很好的linux实时补丁」· C语言 代码 · 共 2,154 行 · 第 1/4 页

                      &sval,
                      sizeof(sval));
    return 0;
}

int __sem_destroy (struct task_struct *curr, struct pt_regs *regs)

{
    union __xeno_sem sm, *usm;
    int err;

    usm = (union __xeno_sem *) __xn_reg_arg1(regs);

    if (!__xn_access_ok(curr,VERIFY_READ,(void __user *) usm,sizeof(*usm)))
        return -EFAULT;

    __xn_copy_from_user(curr,
                        &sm.shadow_sem,
                        (void __user*)&usm->shadow_sem,
                        sizeof(sm.shadow_sem));

    err = sem_destroy(&sm.native_sem);

    if (err)
        return -thread_get_errno();

    __xn_copy_to_user(curr,
                      (void __user *)&usm->shadow_sem,
                      &sm.shadow_sem,
                      sizeof(usm->shadow_sem));

    return 0;
}

int __sem_open (struct task_struct *curr, struct pt_regs *regs)
{
    union __xeno_sem *sm, *usm;
    char name[PSE51_MAXNAME];
    unsigned long uaddr;
    int oflags;
    long len;
    spl_t s;
    
    if (!__xn_access_ok(curr,VERIFY_WRITE,__xn_reg_arg1(regs),sizeof(usm)))
        return -EFAULT;

    __xn_copy_from_user(curr,
                        &usm,
                        (void __user *)__xn_reg_arg1(regs),
                        sizeof(usm));
    
    if (!__xn_access_ok(curr,VERIFY_WRITE,(void __user *)usm,sizeof(*usm)))
        return -EFAULT;

    len = __xn_strncpy_from_user(curr,
                                 name,
                                 (char *) __xn_reg_arg2(regs),
                                 sizeof(name));

    if (len < 0)
        return len;

    if (len >= sizeof(name))
        return -ENAMETOOLONG;

    oflags = __xn_reg_arg3(regs);

    xnlock_get_irqsave(&nklock, s);

    if (!(oflags & O_CREAT))
        sm = (union __xeno_sem *) sem_open(name, oflags);
    else
        sm = (union __xeno_sem *) sem_open(name,
                                           oflags,
                                           (mode_t) __xn_reg_arg4(regs),
                                           (unsigned) __xn_reg_arg5(regs));

    if (sm == SEM_FAILED)
        {
        xnlock_put_irqrestore(&nklock, s);
        return -thread_get_errno();
        }

    uaddr = pse51_usem_open(&sm->shadow_sem, curr->mm, (unsigned long)usm);

    xnlock_put_irqrestore(&nklock, s);

    if (uaddr == (unsigned long) usm)
        /* First binding by this process. */
        __xn_copy_to_user(curr,
                          (void __user *)&usm->shadow_sem,
                          &sm->shadow_sem,
                          sizeof(usm->shadow_sem));
    else
        /* Semaphore already bound by this process in user-space. */
        __xn_copy_to_user(curr,
                          (void __user *)__xn_reg_arg1(regs),
                          &uaddr,
                          sizeof(unsigned long));

    return 0;
}

int __sem_close (struct task_struct *curr, struct pt_regs *regs)
{
    union __xeno_sem sm, *usm;
    int closed, err;
    spl_t s;
    
    usm = (union __xeno_sem *) __xn_reg_arg1(regs);

    if (!__xn_access_ok(curr,VERIFY_READ,(void __user *) usm,sizeof(*usm)))
        return -EFAULT;

    __xn_copy_from_user(curr,
                        &sm.shadow_sem,
                        (void __user*)&usm->shadow_sem,
                        sizeof(sm.shadow_sem));

    xnlock_get_irqsave(&nklock, s);

    closed = pse51_usem_close(&usm->shadow_sem, curr->mm);

    if (closed < 0)
        {
        xnlock_put_irqrestore(&nklock, s);
        return closed;
        }

    err = sem_close(&sm.native_sem);

    xnlock_put_irqrestore(&nklock, s);

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

        return 0;
        }

    return -thread_get_errno();
}

int __sem_unlink (struct task_struct *curr, struct pt_regs *regs)
{
    char name[PSE51_MAXNAME];
    long len;
    
    len = __xn_strncpy_from_user(curr,
                                 name,
                                 (char *) __xn_reg_arg1(regs),
                                 sizeof(name));

    if (len < 0)
        return len;

    if (len >= sizeof(name))
        return -ENAMETOOLONG;

    return sem_unlink(name) == 0 ? 0 : -thread_get_errno();
}

int __clock_getres (struct task_struct *curr, struct pt_regs *regs)

{
    struct timespec ts;
    clockid_t clock_id;
    int err;

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

    clock_id = __xn_reg_arg1(regs);

    err = clock_getres(clock_id,&ts);

    if (!err)
        __xn_copy_to_user(curr,
                          (void __user *)__xn_reg_arg2(regs),
                          &ts,
                          sizeof(ts));
    return err ? -thread_get_errno() : 0;
}

int __clock_gettime (struct task_struct *curr, struct pt_regs *regs)

{
    struct timespec ts;
    clockid_t clock_id;
    int err;

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

    clock_id = __xn_reg_arg1(regs);

    err = clock_gettime(clock_id,&ts);

    if (!err)
        __xn_copy_to_user(curr,
                          (void __user *)__xn_reg_arg2(regs),
                          &ts,
                          sizeof(ts));
    return err ? -thread_get_errno() : 0;
}

int __clock_settime (struct task_struct *curr, struct pt_regs *regs)

{
    struct timespec ts;
    clockid_t clock_id;

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

    clock_id = __xn_reg_arg1(regs);

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

    return clock_settime(clock_id,&ts) ? -thread_get_errno() : 0;
}

int __clock_nanosleep (struct task_struct *curr, struct pt_regs *regs)

{
    struct timespec rqt, rmt, *rmtp = NULL;
    clockid_t clock_id;
    int flags, err;

    if (!__xn_access_ok(curr,VERIFY_READ,__xn_reg_arg3(regs),sizeof(rqt)))
        return -EFAULT;

    if (__xn_reg_arg4(regs))
        {
        if (!__xn_access_ok(curr,VERIFY_WRITE,__xn_reg_arg4(regs),sizeof(rmt)))
            return -EFAULT;

        rmtp = &rmt;
        }

    clock_id = __xn_reg_arg1(regs);

    flags = (int)__xn_reg_arg2(regs);

    __xn_copy_from_user(curr,
                        &rqt,
                        (void __user *)__xn_reg_arg3(regs),
                        sizeof(rqt));

    err = clock_nanosleep(clock_id,flags,&rqt,rmtp);

    if (err != EINTR)
        return -err;

    if (rmtp)
        __xn_copy_to_user(curr,
                          (void __user *)__xn_reg_arg4(regs),
                          rmtp,
                          sizeof(*rmtp));
    return -EINTR;
}

int __mutex_init (struct task_struct *curr, struct pt_regs *regs)

{
    union __xeno_mutex mx, *umx;
    pthread_mutexattr_t attr;
    int err;

    umx = (union __xeno_mutex *) __xn_reg_arg1(regs);

    if (!__xn_access_ok(curr,VERIFY_WRITE,(void __user *) umx,sizeof(*umx)))
        return -EFAULT;

    /* Recursive + PIP forced. */
    pthread_mutexattr_init(&attr);
    pthread_mutexattr_settype(&attr,PTHREAD_MUTEX_RECURSIVE);
    pthread_mutexattr_setprotocol(&attr,PTHREAD_PRIO_INHERIT);
    err = pthread_mutex_init(&mx.native_mutex,&attr);

    if (err)
        return -err;

    __xn_copy_to_user(curr,
                      (void __user *) &umx->shadow_mutex,
                      &mx.shadow_mutex,
                      sizeof(umx->shadow_mutex));
    return 0;
}

int __mutex_destroy (struct task_struct *curr, struct pt_regs *regs)

{
    union __xeno_mutex mx, *umx;
    int err;

    umx = (union __xeno_mutex *) __xn_reg_arg1(regs);

    if (!__xn_access_ok(curr,VERIFY_READ,(void __user *) umx,sizeof(*umx)))
        return -EFAULT;

    __xn_copy_from_user(curr,
                        &mx.shadow_mutex,
                        (void __user *) &umx->shadow_mutex,
                        sizeof(mx.shadow_mutex));

    err = pthread_mutex_destroy(&mx.native_mutex);

    __xn_copy_to_user(curr,
                      (void __user *) &umx->shadow_mutex,
                      &mx.shadow_mutex,
                      sizeof(umx->shadow_mutex));
    return -err;
}

int __mutex_lock (struct task_struct *curr, struct pt_regs *regs)

{
    union __xeno_mutex mx, *umx;

    umx = (union __xeno_mutex *) __xn_reg_arg1(regs);

    if (!__xn_access_ok(curr,VERIFY_READ,(void __user *) umx,sizeof(*umx)))
        return -EFAULT;

    __xn_copy_from_user(curr,
                        &mx.shadow_mutex,
                        (void __user *) &umx->shadow_mutex,
                        sizeof(mx.shadow_mutex));

    return -pse51_mutex_timedlock_break(&mx.shadow_mutex, XN_INFINITE);
}

int __mutex_timedlock (struct task_struct *curr, struct pt_regs *regs)

{
    union __xeno_mutex mx, *umx;
    struct timespec ts;

    umx = (union __xeno_mutex *) __xn_reg_arg1(regs);

    if (!__xn_access_ok(curr,VERIFY_READ,(void __user *) umx,sizeof(*umx)))
        return -EFAULT;

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

    __xn_copy_from_user(curr,
                        &mx.shadow_mutex,
                        (void __user *) &umx->shadow_mutex,
                        sizeof(mx.shadow_mutex));

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

    return -pse51_mutex_timedlock_break(&mx.shadow_mutex,ts2ticks_ceil(&ts)+1);
}

int __mutex_trylock (struct task_struct *curr, struct pt_regs *regs)

{
    union __xeno_mutex mx, *umx;

    umx = (union __xeno_mutex *) __xn_reg_arg1(regs);

    if (!__xn_access_ok(curr,VERIFY_READ,(void __user *) umx,sizeof(*umx)))
        return -EFAULT;

    __xn_copy_from_user(curr,
                        &mx.shadow_mutex,
                        (void __user *) &umx->shadow_mutex,
                        sizeof(mx.shadow_mutex));

    return -pthread_mutex_trylock(&mx.native_mutex);
}

int __mutex_unlock (struct task_struct *curr, struct pt_regs *regs)

{
    union __xeno_mutex mx, *umx;

    umx = (union __xeno_mutex *) __xn_reg_arg1(regs);

    if (!__xn_access_ok(curr,VERIFY_READ,(void __user *) umx,sizeof(*umx)))
        return -EFAULT;

    __xn_copy_from_user(curr,
                        &mx.shadow_mutex,
                        (void __user *) &umx->shadow_mutex,
                        sizeof(mx.shadow_mutex));

    return -pthread_mutex_unlock(&mx.native_mutex);
}

int __cond_init (struct task_struct *curr, struct pt_regs *regs)

{
    union __xeno_cond cnd, *ucnd;
    int err;

    ucnd = (union __xeno_cond *) __xn_reg_arg1(regs);
    
    if (!__xn_access_ok(curr,VERIFY_WRITE,(void __user *) ucnd,sizeof(*ucnd)))
        return -EFAULT;

    /* Always use default attribute. */
    err = pthread_cond_init(&cnd.native_cond,NULL);

    if (err)
        return -err;

    __xn_copy_to_user(curr,
                      (void __user *) &ucnd->shadow_cond,
                      &cnd.shadow_cond,
                      sizeof(ucnd->shadow_cond));
    return 0;
}

int __cond_destroy (struct task_struct *curr, struct pt_regs *regs)

{
    union __xeno_cond cnd, *ucnd;
    int err;

    ucnd = (union __xeno_cond *) __xn_reg_arg1(regs);
    
    if (!__xn_access_ok(curr,VERIFY_READ,(void __user *) ucnd,sizeof(*ucnd)))
        return -EFAULT;

    __xn_copy_from_user(curr,
                        &cnd.shadow_cond,
                        (void __user *) &ucnd->shadow_cond,
                        sizeof(cnd.shadow_cond));

    err = pthread_cond_destroy(&cnd.native_cond);

    if (err)
        return -err;

    __xn_copy_to_user(curr,
                      (void __user *) &ucnd->shadow_cond,
                      &cnd.shadow_cond,
                      sizeof(ucnd->shadow_cond));
    return 0;
}

int __cond_wait (struct task_struct *curr, struct pt_regs *regs)

{
    union __xeno_cond cnd, *ucnd;
    union __xeno_mutex mx, *umx;

    ucnd = (union __xeno_cond *) __xn_reg_arg1(regs);
    umx = (union __xeno_mutex *) __xn_reg_arg2(regs);

    if (!__xn_access_ok(curr,VERIFY_READ,(void __user *) ucnd,sizeof(*ucnd)))
        return -EFAULT;

    if (!__xn_access_ok(curr,VERIFY_READ,(void __user *) umx,sizeof(*umx)))
        return -EFAULT;

    __xn_copy_from_user(curr,
                        &cnd.shadow_cond,
                        (void __user *) &ucnd->shadow_cond,
                        sizeof(cnd.shadow_cond));

    __xn_copy_from_user(curr,
                        &mx.shadow_mutex,
                        (void __user *) &umx->shadow_mutex,
                        sizeof(mx.shadow_mutex));

    return -pse51_cond_timedwait_internal(&cnd.shadow_cond,
                                          &mx.shadow_mutex,
                                          XN_INFINITE);
}

int __cond_timedwait (struct task_struct *curr, struct pt_regs *regs)

{
    union __xeno_cond cnd, *ucnd;
    union __xeno_mutex mx, *umx;
    struct timespec ts;

    ucnd = (union __xeno_cond *) __xn_reg_arg1(regs);
    umx = (union __xeno_mutex *) __xn_reg_arg2(regs);

    if (!__xn_access_ok(curr,VERIFY_READ,(void __user *) ucnd,sizeof(*ucnd)))
        return -EFAULT;

    if (!__xn_access_ok(curr,VERIFY_READ,(void __user *) umx,sizeof(*umx)))
        return -EFAULT;

    if (!__xn_access_ok(curr,VERIFY_READ,__xn_reg_arg3(regs),sizeof(ts)))
        return -EFAULT;

    __xn_copy_from_user(curr,
                        &cnd.shadow_cond,
                        (void __user *) &ucnd->shadow_cond,
                        sizeof(cnd.shadow_cond));

    __xn_copy_from_user(curr,
                        &mx.shadow_mutex,
                        (void __user *) &umx->shadow_mutex,
                        sizeof(mx.shadow_mutex));

    __xn_copy_from_user(curr,
                        &ts,
                        (void __user *)__xn_reg_arg3(regs),
                        sizeof(ts));

    return -pse51_cond_timedwait_internal(&cnd.shadow_cond,
                                          &mx.shadow_mutex,
                                          ts2ticks_ceil(&ts)+1);
}

int __cond_signal (struct task_struct *curr, struct pt_regs *regs)

{
    union __xeno_cond cnd, *ucnd;

    ucnd = (union __xeno_cond *) __xn_reg_arg1(regs);
    
    if (!__xn_access_ok(curr,VERIFY_READ,(void __user *) ucnd,sizeof(*ucnd)))
        return -EFAULT;

    __xn_copy_from_user(curr,
                        &cnd.shadow_cond,
                        (void __user *) &ucnd->shadow_cond,
                        sizeof(cnd.shadow_cond));

    return -pthread_cond_signal(&cnd.native_cond);