Module: xenomai-jki
Branch: for-forge
Commit: 99736c29a21a5e5536f8db9e580fd11cdb0eb0f2
URL:    
http://git.xenomai.org/?p=xenomai-jki.git;a=commit;h=99736c29a21a5e5536f8db9e580fd11cdb0eb0f2

Author: Jan Kiszka <jan.kis...@siemens.com>
Date:   Thu Jul  2 17:12:39 2015 +0200

cobalt/kernel: Remove unused mode parameter from COBALT_SYSCALL

Signed-off-by: Jan Kiszka <jan.kis...@siemens.com>

---

 kernel/cobalt/posix/clock.c   |    8 ++++----
 kernel/cobalt/posix/cond.c    |    8 ++++----
 kernel/cobalt/posix/event.c   |   10 +++++-----
 kernel/cobalt/posix/io.c      |   22 +++++++++++-----------
 kernel/cobalt/posix/monitor.c |   12 ++++++------
 kernel/cobalt/posix/mqueue.c  |   14 +++++++-------
 kernel/cobalt/posix/mutex.c   |   14 +++++++-------
 kernel/cobalt/posix/nsem.c    |    6 +++---
 kernel/cobalt/posix/sched.c   |   12 ++++++------
 kernel/cobalt/posix/sem.c     |   18 +++++++++---------
 kernel/cobalt/posix/signal.c  |   12 ++++++------
 kernel/cobalt/posix/syscall.c |   18 +++++++++---------
 kernel/cobalt/posix/syscall.h |    2 +-
 kernel/cobalt/posix/thread.c  |   18 +++++++++---------
 kernel/cobalt/posix/timer.c   |   10 +++++-----
 kernel/cobalt/posix/timerfd.c |    6 +++---
 16 files changed, 95 insertions(+), 95 deletions(-)

diff --git a/kernel/cobalt/posix/clock.c b/kernel/cobalt/posix/clock.c
index 7fd148a..45686dd 100644
--- a/kernel/cobalt/posix/clock.c
+++ b/kernel/cobalt/posix/clock.c
@@ -129,7 +129,7 @@ int __cobalt_clock_getres(clockid_t clock_id, struct 
timespec *ts)
        return 0;
 }
 
-COBALT_SYSCALL(clock_getres, current,
+COBALT_SYSCALL(clock_getres,
               (clockid_t clock_id, struct timespec __user *u_ts))
 {
        struct timespec ts;
@@ -176,7 +176,7 @@ int __cobalt_clock_gettime(clockid_t clock_id, struct 
timespec *ts)
        return 0;
 }
 
-COBALT_SYSCALL(clock_gettime, current,
+COBALT_SYSCALL(clock_gettime,
               (clockid_t clock_id, struct timespec __user *u_ts))
 {
        struct timespec ts;
@@ -221,7 +221,7 @@ int __cobalt_clock_settime(clockid_t clock_id, const struct 
timespec *ts)
        return 0;
 }
 
-COBALT_SYSCALL(clock_settime, current,
+COBALT_SYSCALL(clock_settime,
               (clockid_t clock_id, const struct timespec __user *u_ts))
 {
        struct timespec ts;
@@ -280,7 +280,7 @@ int __cobalt_clock_nanosleep(clockid_t clock_id, int flags,
        return ret;
 }
 
-COBALT_SYSCALL(clock_nanosleep, nonrestartable,
+COBALT_SYSCALL(clock_nanosleep,
               (clockid_t clock_id, int flags,
                const struct timespec __user *u_rqt,
                struct timespec __user *u_rmt))
diff --git a/kernel/cobalt/posix/cond.c b/kernel/cobalt/posix/cond.c
index 758444b..93caf29 100644
--- a/kernel/cobalt/posix/cond.c
+++ b/kernel/cobalt/posix/cond.c
@@ -225,7 +225,7 @@ unlock_and_return:
        return err;
 }
 
-COBALT_SYSCALL(cond_init, current,
+COBALT_SYSCALL(cond_init,
               (struct cobalt_cond_shadow __user *u_cnd,
                const struct cobalt_condattr __user *u_attr))
 {
@@ -248,7 +248,7 @@ COBALT_SYSCALL(cond_init, current,
        return cobalt_copy_to_user(u_cnd, &cnd, sizeof(*u_cnd));
 }
 
-COBALT_SYSCALL(cond_destroy, current,
+COBALT_SYSCALL(cond_destroy,
               (struct cobalt_cond_shadow __user *u_cnd))
 {
        struct cobalt_cond_shadow cnd;
@@ -344,7 +344,7 @@ int __cobalt_cond_wait_prologue(struct cobalt_cond_shadow 
__user *u_cnd,
 }
 
 /* pthread_cond_wait_prologue(cond, mutex, count_ptr, timed, timeout) */
-COBALT_SYSCALL(cond_wait_prologue, nonrestartable,
+COBALT_SYSCALL(cond_wait_prologue,
               (struct cobalt_cond_shadow __user *u_cnd,
                struct cobalt_mutex_shadow __user *u_mx,
                int *u_err,
@@ -355,7 +355,7 @@ COBALT_SYSCALL(cond_wait_prologue, nonrestartable,
                                           timed ? cond_fetch_timeout : NULL);
 }
 
-COBALT_SYSCALL(cond_wait_epilogue, primary,
+COBALT_SYSCALL(cond_wait_epilogue,
               (struct cobalt_cond_shadow __user *u_cnd,
                struct cobalt_mutex_shadow __user *u_mx))
 {
diff --git a/kernel/cobalt/posix/event.c b/kernel/cobalt/posix/event.c
index 6c99ea9..2c2d900 100644
--- a/kernel/cobalt/posix/event.c
+++ b/kernel/cobalt/posix/event.c
@@ -46,7 +46,7 @@ struct event_wait_context {
        int mode;
 };
 
-COBALT_SYSCALL(event_init, current,
+COBALT_SYSCALL(event_init,
               (struct cobalt_event_shadow __user *u_event,
                unsigned int value, int flags))
 {
@@ -186,7 +186,7 @@ out:
        return ret;
 }
 
-COBALT_SYSCALL(event_wait, primary,
+COBALT_SYSCALL(event_wait,
               (struct cobalt_event_shadow __user *u_event,
                unsigned int bits,
                unsigned int __user *u_bits_r,
@@ -205,7 +205,7 @@ COBALT_SYSCALL(event_wait, primary,
        return __cobalt_event_wait(u_event, bits, u_bits_r, mode, tsp);
 }
 
-COBALT_SYSCALL(event_sync, current,
+COBALT_SYSCALL(event_sync,
               (struct cobalt_event_shadow __user *u_event))
 {
        unsigned int bits, waitval, testval;
@@ -255,7 +255,7 @@ out:
        return ret;
 }
 
-COBALT_SYSCALL(event_destroy, current,
+COBALT_SYSCALL(event_destroy,
               (struct cobalt_event_shadow __user *u_event))
 {
        struct cobalt_event *event;
@@ -279,7 +279,7 @@ COBALT_SYSCALL(event_destroy, current,
        return 0;
 }
 
-COBALT_SYSCALL(event_inquire, current,
+COBALT_SYSCALL(event_inquire,
               (struct cobalt_event_shadow __user *u_event,
                struct cobalt_event_info __user *u_info,
                pid_t __user *u_waitlist,
diff --git a/kernel/cobalt/posix/io.c b/kernel/cobalt/posix/io.c
index cadc2d1..48c272c 100644
--- a/kernel/cobalt/posix/io.c
+++ b/kernel/cobalt/posix/io.c
@@ -26,7 +26,7 @@
 #include "clock.h"
 #include "io.h"
 
-COBALT_SYSCALL(open, lostage,
+COBALT_SYSCALL(open,
               (const char __user *u_path, int oflag))
 {
        struct filename *filename;
@@ -42,41 +42,41 @@ COBALT_SYSCALL(open, lostage,
        return ufd;
 }
 
-COBALT_SYSCALL(socket, lostage,
+COBALT_SYSCALL(socket,
               (int protocol_family, int socket_type, int protocol))
 {
        return __rtdm_dev_socket(protocol_family, socket_type, protocol);
 }
 
-COBALT_SYSCALL(close, lostage, (int fd))
+COBALT_SYSCALL(close, (int fd))
 {
        return rtdm_fd_close(fd, 0);
 }
 
-COBALT_SYSCALL(fcntl, current, (int fd, int cmd, int arg))
+COBALT_SYSCALL(fcntl, (int fd, int cmd, int arg))
 {
        return rtdm_fd_fcntl(fd, cmd, arg);
 }
 
-COBALT_SYSCALL(ioctl, probing,
+COBALT_SYSCALL(ioctl,
               (int fd, unsigned int request, void __user *arg))
 {
        return rtdm_fd_ioctl(fd, request, arg);
 }
 
-COBALT_SYSCALL(read, probing,
+COBALT_SYSCALL(read,
               (int fd, void __user *buf, size_t size))
 {
        return rtdm_fd_read(fd, buf, size);
 }
 
-COBALT_SYSCALL(write, probing,
+COBALT_SYSCALL(write,
               (int fd, const void __user *buf, size_t size))
 {
        return rtdm_fd_write(fd, buf, size);
 }
 
-COBALT_SYSCALL(recvmsg, probing,
+COBALT_SYSCALL(recvmsg,
               (int fd, struct msghdr __user *umsg, int flags))
 {
        struct msghdr m;
@@ -93,7 +93,7 @@ COBALT_SYSCALL(recvmsg, probing,
        return cobalt_copy_to_user(umsg, &m, sizeof(*umsg)) ?: ret;
 }
 
-COBALT_SYSCALL(sendmsg, probing,
+COBALT_SYSCALL(sendmsg,
               (int fd, struct msghdr __user *umsg, int flags))
 {
        struct msghdr m;
@@ -104,7 +104,7 @@ COBALT_SYSCALL(sendmsg, probing,
        return ret ?: rtdm_fd_sendmsg(fd, &m, flags);
 }
 
-COBALT_SYSCALL(mmap, lostage,
+COBALT_SYSCALL(mmap,
               (int fd, struct _rtdm_mmap_request __user *u_rma,
                void __user **u_addrp))
 {
@@ -170,7 +170,7 @@ int __cobalt_select_bind_all(struct xnselector *selector,
 }
 
 /* int select(int, fd_set *, fd_set *, fd_set *, struct timeval *) */
-COBALT_SYSCALL(select, nonrestartable,
+COBALT_SYSCALL(select,
               (int nfds,
                fd_set __user *u_rfds,
                fd_set __user *u_wfds,
diff --git a/kernel/cobalt/posix/monitor.c b/kernel/cobalt/posix/monitor.c
index f3662b6..c4fcab5 100644
--- a/kernel/cobalt/posix/monitor.c
+++ b/kernel/cobalt/posix/monitor.c
@@ -48,7 +48,7 @@
  * Implementation-wise, the monitor logic is shared with the Cobalt
  * thread object.
  */
-COBALT_SYSCALL(monitor_init, current,
+COBALT_SYSCALL(monitor_init,
               (struct cobalt_monitor_shadow __user *u_mon,
                clockid_t clk_id, int flags))
 {
@@ -142,7 +142,7 @@ static int monitor_enter(xnhandle_t handle, struct xnthread 
*curr)
        return 0;
 }
 
-COBALT_SYSCALL(monitor_enter, primary,
+COBALT_SYSCALL(monitor_enter,
               (struct cobalt_monitor_shadow __user *u_mon))
 {
        struct xnthread *curr = xnthread_current();
@@ -294,7 +294,7 @@ out:
        return ret;
 }
 
-COBALT_SYSCALL(monitor_wait, nonrestartable,
+COBALT_SYSCALL(monitor_wait,
               (struct cobalt_monitor_shadow __user *u_mon,
               int event, const struct timespec __user *u_ts,
               int __user *u_ret))
@@ -312,7 +312,7 @@ COBALT_SYSCALL(monitor_wait, nonrestartable,
        return __cobalt_monitor_wait(u_mon, event, tsp, u_ret);
 }
 
-COBALT_SYSCALL(monitor_sync, nonrestartable,
+COBALT_SYSCALL(monitor_sync,
               (struct cobalt_monitor_shadow __user *u_mon))
 {
        struct cobalt_monitor *mon;
@@ -341,7 +341,7 @@ COBALT_SYSCALL(monitor_sync, nonrestartable,
        return ret;
 }
 
-COBALT_SYSCALL(monitor_exit, primary,
+COBALT_SYSCALL(monitor_exit,
               (struct cobalt_monitor_shadow __user *u_mon))
 {
        struct cobalt_monitor *mon;
@@ -371,7 +371,7 @@ COBALT_SYSCALL(monitor_exit, primary,
        return ret;
 }
 
-COBALT_SYSCALL(monitor_destroy, primary,
+COBALT_SYSCALL(monitor_destroy,
               (struct cobalt_monitor_shadow __user *u_mon))
 {
        struct cobalt_monitor_state *state;
diff --git a/kernel/cobalt/posix/mqueue.c b/kernel/cobalt/posix/mqueue.c
index 5ffa5f9..3cc05ba 100644
--- a/kernel/cobalt/posix/mqueue.c
+++ b/kernel/cobalt/posix/mqueue.c
@@ -762,7 +762,7 @@ int __cobalt_mq_notify(mqd_t fd, const struct sigevent *evp)
        return ret;
 }
 
-COBALT_SYSCALL(mq_notify, primary,
+COBALT_SYSCALL(mq_notify,
               (mqd_t fd, const struct sigevent *__user evp))
 {
        struct sigevent sev;
@@ -806,7 +806,7 @@ int __cobalt_mq_open(const char __user *u_name, int oflags,
        return uqd;
 }
 
-COBALT_SYSCALL(mq_open, lostage,
+COBALT_SYSCALL(mq_open,
               (const char __user *u_name, int oflags,
                mode_t mode, struct mq_attr __user *u_attr))
 {
@@ -821,14 +821,14 @@ COBALT_SYSCALL(mq_open, lostage,
        return __cobalt_mq_open(u_name, oflags, mode, attr);
 }
 
-COBALT_SYSCALL(mq_close, lostage, (mqd_t uqd))
+COBALT_SYSCALL(mq_close, (mqd_t uqd))
 {
        trace_cobalt_mq_close(uqd);
 
        return mq_close(uqd);
 }
 
-COBALT_SYSCALL(mq_unlink, lostage, (const char __user *u_name))
+COBALT_SYSCALL(mq_unlink, (const char __user *u_name))
 {
        char name[COBALT_MAXNAME];
        unsigned len;
@@ -863,7 +863,7 @@ int __cobalt_mq_getattr(mqd_t uqd, struct mq_attr *attr)
        return 0;
 }
 
-COBALT_SYSCALL(mq_getattr, current,
+COBALT_SYSCALL(mq_getattr,
               (mqd_t uqd, struct mq_attr __user *u_attr))
 {
        struct mq_attr attr;
@@ -927,7 +927,7 @@ out:
        return ret;
 }
 
-COBALT_SYSCALL(mq_timedsend, primary,
+COBALT_SYSCALL(mq_timedsend,
               (mqd_t uqd, const void __user *u_buf, size_t len,
                unsigned int prio, const struct timespec __user *u_ts))
 {
@@ -986,7 +986,7 @@ fail:
        return ret;
 }
 
-COBALT_SYSCALL(mq_timedreceive, primary,
+COBALT_SYSCALL(mq_timedreceive,
               (mqd_t uqd, void __user *u_buf,
                ssize_t __user *u_len,
                unsigned int __user *u_prio,
diff --git a/kernel/cobalt/posix/mutex.c b/kernel/cobalt/posix/mutex.c
index 3d31fa2..e6c9602 100644
--- a/kernel/cobalt/posix/mutex.c
+++ b/kernel/cobalt/posix/mutex.c
@@ -195,7 +195,7 @@ out:
        return ret;
 }
 
-COBALT_SYSCALL(mutex_check_init, current,
+COBALT_SYSCALL(mutex_check_init,
               (struct cobalt_mutex_shadow __user *u_mx))
 {
        struct cobalt_mutex *mutex;
@@ -217,7 +217,7 @@ COBALT_SYSCALL(mutex_check_init, current,
        return err;
 }
 
-COBALT_SYSCALL(mutex_init, current,
+COBALT_SYSCALL(mutex_init,
               (struct cobalt_mutex_shadow __user *u_mx,
                const struct cobalt_mutexattr __user *u_attr))
 {
@@ -254,7 +254,7 @@ COBALT_SYSCALL(mutex_init, current,
        return cobalt_copy_to_user(u_mx, &mx, sizeof(*u_mx));
 }
 
-COBALT_SYSCALL(mutex_destroy, current,
+COBALT_SYSCALL(mutex_destroy,
               (struct cobalt_mutex_shadow __user *u_mx))
 {
        struct cobalt_mutex_shadow mx;
@@ -295,7 +295,7 @@ fail:
        return ret;
 }
 
-COBALT_SYSCALL(mutex_trylock, primary,
+COBALT_SYSCALL(mutex_trylock,
               (struct cobalt_mutex_shadow __user *u_mx))
 {
        struct xnthread *curr = xnthread_current();
@@ -335,7 +335,7 @@ COBALT_SYSCALL(mutex_trylock, primary,
        return err;
 }
 
-COBALT_SYSCALL(mutex_lock, primary,
+COBALT_SYSCALL(mutex_lock,
               (struct cobalt_mutex_shadow __user *u_mx))
 {
        return __cobalt_mutex_timedlock_break(u_mx, NULL, NULL);
@@ -348,14 +348,14 @@ static inline int mutex_fetch_timeout(struct timespec *ts,
                cobalt_copy_from_user(ts, u_ts, sizeof(*ts));
 }
 
-COBALT_SYSCALL(mutex_timedlock, primary,
+COBALT_SYSCALL(mutex_timedlock,
               (struct cobalt_mutex_shadow __user *u_mx,
                const struct timespec __user *u_ts))
 {
        return __cobalt_mutex_timedlock_break(u_mx, u_ts, mutex_fetch_timeout);
 }
 
-COBALT_SYSCALL(mutex_unlock, nonrestartable,
+COBALT_SYSCALL(mutex_unlock,
               (struct cobalt_mutex_shadow __user *u_mx))
 {
        struct cobalt_mutex *mutex;
diff --git a/kernel/cobalt/posix/nsem.c b/kernel/cobalt/posix/nsem.c
index 0cc6860..d89778a 100644
--- a/kernel/cobalt/posix/nsem.c
+++ b/kernel/cobalt/posix/nsem.c
@@ -210,7 +210,7 @@ __cobalt_sem_open(struct cobalt_sem_shadow __user *usm,
        return usm;
 }
 
-COBALT_SYSCALL(sem_open, lostage,
+COBALT_SYSCALL(sem_open,
               (struct cobalt_sem_shadow __user *__user *u_addrp,
                const char __user *u_name,
                int oflags, mode_t mode, unsigned int value))
@@ -227,7 +227,7 @@ COBALT_SYSCALL(sem_open, lostage,
        return __xn_put_user(usm, u_addrp) ? -EFAULT : 0;
 }
 
-COBALT_SYSCALL(sem_close, lostage,
+COBALT_SYSCALL(sem_close,
               (struct cobalt_sem_shadow __user *usm))
 {
        struct cobalt_process *process;
@@ -261,7 +261,7 @@ static inline int sem_unlink(const char *name)
        return 0;
 }
 
-COBALT_SYSCALL(sem_unlink, lostage,
+COBALT_SYSCALL(sem_unlink,
               (const char __user *u_name))
 {
        struct filename *filename;
diff --git a/kernel/cobalt/posix/sched.c b/kernel/cobalt/posix/sched.c
index 0e7d405..a24a938 100644
--- a/kernel/cobalt/posix/sched.c
+++ b/kernel/cobalt/posix/sched.c
@@ -121,7 +121,7 @@ cobalt_sched_policy_param(union xnsched_policy_param *param,
        return sched_class;
 }
 
-COBALT_SYSCALL(sched_minprio, current, (int policy))
+COBALT_SYSCALL(sched_minprio, (int policy))
 {
        int ret;
 
@@ -149,7 +149,7 @@ COBALT_SYSCALL(sched_minprio, current, (int policy))
        return ret;
 }
 
-COBALT_SYSCALL(sched_maxprio, current, (int policy))
+COBALT_SYSCALL(sched_maxprio, (int policy))
 {
        int ret;
 
@@ -183,7 +183,7 @@ COBALT_SYSCALL(sched_maxprio, current, (int policy))
        return ret;
 }
 
-COBALT_SYSCALL(sched_yield, primary, (void))
+COBALT_SYSCALL(sched_yield, (void))
 {
        struct cobalt_thread *curr = cobalt_current_thread();
        int ret = 0;
@@ -631,7 +631,7 @@ int __cobalt_sched_setconfig_np(int cpu, int policy,
        return ret;
 }
 
-COBALT_SYSCALL(sched_setconfig_np, conforming,
+COBALT_SYSCALL(sched_setconfig_np,
               (int cpu, int policy,
                union sched_config __user *u_config,
                size_t len))
@@ -672,7 +672,7 @@ ssize_t __cobalt_sched_getconfig_np(int cpu, int policy,
        return ret;
 }
 
-COBALT_SYSCALL(sched_getconfig_np, conforming,
+COBALT_SYSCALL(sched_getconfig_np,
               (int cpu, int policy,
                union sched_config __user *u_config,
                size_t len))
@@ -700,7 +700,7 @@ int __cobalt_sched_weightprio(int policy,
        return prio + sched_class->weight;
 }
 
-COBALT_SYSCALL(sched_weightprio, current,
+COBALT_SYSCALL(sched_weightprio,
               (int policy, const struct sched_param_ex __user *u_param))
 {
        struct sched_param_ex param_ex;
diff --git a/kernel/cobalt/posix/sem.c b/kernel/cobalt/posix/sem.c
index 7ade350..4ee9f16 100644
--- a/kernel/cobalt/posix/sem.c
+++ b/kernel/cobalt/posix/sem.c
@@ -402,7 +402,7 @@ static int sem_getvalue(xnhandle_t handle, int *value)
        return 0;
 }
 
-COBALT_SYSCALL(sem_init, current,
+COBALT_SYSCALL(sem_init,
               (struct cobalt_sem_shadow __user *u_sem,
                int flags, unsigned int value))
 {
@@ -423,7 +423,7 @@ COBALT_SYSCALL(sem_init, current,
        return cobalt_copy_to_user(u_sem, &sm, sizeof(*u_sem));
 }
 
-COBALT_SYSCALL(sem_post, current,
+COBALT_SYSCALL(sem_post,
               (struct cobalt_sem_shadow __user *u_sem))
 {
        xnhandle_t handle;
@@ -434,7 +434,7 @@ COBALT_SYSCALL(sem_post, current,
        return sem_post(handle);
 }
 
-COBALT_SYSCALL(sem_wait, primary,
+COBALT_SYSCALL(sem_wait,
               (struct cobalt_sem_shadow __user *u_sem))
 {
        xnhandle_t handle;
@@ -445,14 +445,14 @@ COBALT_SYSCALL(sem_wait, primary,
        return sem_wait(handle);
 }
 
-COBALT_SYSCALL(sem_timedwait, primary,
+COBALT_SYSCALL(sem_timedwait,
               (struct cobalt_sem_shadow __user *u_sem,
                struct timespec __user *u_ts))
 {
        return __cobalt_sem_timedwait(u_sem, u_ts, sem_fetch_timeout);
 }
 
-COBALT_SYSCALL(sem_trywait, primary,
+COBALT_SYSCALL(sem_trywait,
               (struct cobalt_sem_shadow __user *u_sem))
 {
        xnhandle_t handle;
@@ -463,7 +463,7 @@ COBALT_SYSCALL(sem_trywait, primary,
        return sem_trywait(handle);
 }
 
-COBALT_SYSCALL(sem_getvalue, current,
+COBALT_SYSCALL(sem_getvalue,
               (struct cobalt_sem_shadow __user *u_sem,
                int __user *u_sval))
 {
@@ -480,7 +480,7 @@ COBALT_SYSCALL(sem_getvalue, current,
        return cobalt_copy_to_user(u_sval, &sval, sizeof(sval));
 }
 
-COBALT_SYSCALL(sem_destroy, current,
+COBALT_SYSCALL(sem_destroy,
               (struct cobalt_sem_shadow __user *u_sem))
 {
        struct cobalt_sem_shadow sm;
@@ -498,7 +498,7 @@ COBALT_SYSCALL(sem_destroy, current,
        return cobalt_copy_to_user(u_sem, &sm, sizeof(*u_sem)) ?: err;
 }
 
-COBALT_SYSCALL(sem_broadcast_np, current,
+COBALT_SYSCALL(sem_broadcast_np,
               (struct cobalt_sem_shadow __user *u_sem))
 {
        struct cobalt_sem *sem;
@@ -517,7 +517,7 @@ COBALT_SYSCALL(sem_broadcast_np, current,
        return err;
 }
 
-COBALT_SYSCALL(sem_inquire, current,
+COBALT_SYSCALL(sem_inquire,
               (struct cobalt_sem_shadow __user *u_sem,
                struct cobalt_sem_info __user *u_info,
                pid_t __user *u_waitlist,
diff --git a/kernel/cobalt/posix/signal.c b/kernel/cobalt/posix/signal.c
index d6cda8e..575570b 100644
--- a/kernel/cobalt/posix/signal.c
+++ b/kernel/cobalt/posix/signal.c
@@ -375,7 +375,7 @@ int __cobalt_sigwait(sigset_t *set)
        return signal_wait(set, XN_INFINITE, NULL, NULL);
 }
 
-COBALT_SYSCALL(sigwait, primary,
+COBALT_SYSCALL(sigwait,
               (const sigset_t __user *u_set, int __user *u_sig))
 {
        sigset_t set;
@@ -410,7 +410,7 @@ int __cobalt_sigtimedwait(sigset_t *set,
        return signal_wait(set, ticks, u_si, put_siginfo);
 }
 
-COBALT_SYSCALL(sigtimedwait, nonrestartable,
+COBALT_SYSCALL(sigtimedwait,
               (const sigset_t __user *u_set,
                struct siginfo __user *u_si,
                const struct timespec __user *u_timeout))
@@ -436,7 +436,7 @@ int __cobalt_sigwaitinfo(sigset_t *set,
        return signal_wait(set, XN_INFINITE, u_si, put_siginfo);
 }
 
-COBALT_SYSCALL(sigwaitinfo, nonrestartable,
+COBALT_SYSCALL(sigwaitinfo,
               (const sigset_t __user *u_set, struct siginfo __user *u_si))
 {
        sigset_t set;
@@ -447,7 +447,7 @@ COBALT_SYSCALL(sigwaitinfo, nonrestartable,
        return __cobalt_sigwaitinfo(&set, u_si, signal_put_siginfo);
 }
 
-COBALT_SYSCALL(sigpending, primary, (old_sigset_t __user *u_set))
+COBALT_SYSCALL(sigpending, (old_sigset_t __user *u_set))
 {
        struct cobalt_thread *curr = cobalt_current_thread();
 
@@ -514,7 +514,7 @@ int __cobalt_kill(struct cobalt_thread *thread, int sig, 
int group) /* nklocked,
        return ret;
 }
 
-COBALT_SYSCALL(kill, conforming, (pid_t pid, int sig))
+COBALT_SYSCALL(kill, (pid_t pid, int sig))
 {
        struct cobalt_thread *thread;
        int ret;
@@ -578,7 +578,7 @@ out:
 }
 EXPORT_SYMBOL_GPL(__cobalt_sigqueue);
 
-COBALT_SYSCALL(sigqueue, conforming,
+COBALT_SYSCALL(sigqueue,
               (pid_t pid, int sig, const union sigval __user *u_value))
 {
        union sigval val;
diff --git a/kernel/cobalt/posix/syscall.c b/kernel/cobalt/posix/syscall.c
index 7494b7b..12ac647 100644
--- a/kernel/cobalt/posix/syscall.c
+++ b/kernel/cobalt/posix/syscall.c
@@ -98,7 +98,7 @@ static void prepare_for_signal(struct task_struct *p,
        xnthread_relax(notify, SIGDEBUG_MIGRATE_SIGNAL);
 }
 
-static COBALT_SYSCALL(migrate, current, (int domain))
+static COBALT_SYSCALL(migrate, (int domain))
 {
        struct xnthread *thread = xnthread_current();
 
@@ -128,7 +128,7 @@ static COBALT_SYSCALL(migrate, current, (int domain))
        return 0;
 }
 
-static COBALT_SYSCALL(trace, current,
+static COBALT_SYSCALL(trace,
                      (int op, unsigned long a1,
                       unsigned long a2, unsigned long a3))
 {
@@ -171,7 +171,7 @@ static COBALT_SYSCALL(trace, current,
        return ret;
 }
 
-static COBALT_SYSCALL(archcall, current,
+static COBALT_SYSCALL(archcall,
                      (unsigned long a1, unsigned long a2,
                       unsigned long a3, unsigned long a4,
                       unsigned long a5))
@@ -179,7 +179,7 @@ static COBALT_SYSCALL(archcall, current,
        return xnarch_local_syscall(a1, a2, a3, a4, a5);
 }
 
-static COBALT_SYSCALL(get_current, current,
+static COBALT_SYSCALL(get_current,
                      (xnhandle_t __user *u_handle))
 {
        struct xnthread *cur = xnthread_current();
@@ -191,7 +191,7 @@ static COBALT_SYSCALL(get_current, current,
                                      sizeof(*u_handle));
 }
 
-static COBALT_SYSCALL(backtrace, current,
+static COBALT_SYSCALL(backtrace,
                      (int nr, unsigned long __user *u_backtrace, int reason))
 {
        unsigned long backtrace[SIGSHADOW_BACKTRACE_DEPTH];
@@ -223,7 +223,7 @@ static COBALT_SYSCALL(backtrace, current,
        return 0;
 }
 
-static COBALT_SYSCALL(serialdbg, current,
+static COBALT_SYSCALL(serialdbg,
                      (const char __user *u_msg, int len))
 {
        char buf[128];
@@ -263,7 +263,7 @@ static void stringify_feature_set(unsigned long fset, char 
*buf, int size)
        }
 }
 
-static COBALT_SYSCALL(bind, lostage,
+static COBALT_SYSCALL(bind,
                      (struct cobalt_bindreq __user *u_breq))
 {
        unsigned long featreq, featmis;
@@ -320,7 +320,7 @@ static COBALT_SYSCALL(bind, lostage,
        return cobalt_bind_core();
 }
 
-static COBALT_SYSCALL(extend, lostage, (unsigned int magic))
+static COBALT_SYSCALL(extend, (unsigned int magic))
 {
        return cobalt_bind_personality(magic);
 }
@@ -459,7 +459,7 @@ static int start_services(void)
        return ret;
 }
 
-static COBALT_SYSCALL(corectl, probing,
+static COBALT_SYSCALL(corectl,
                      (int request, void __user *u_buf, size_t u_bufsz))
 {
        int ret;
diff --git a/kernel/cobalt/posix/syscall.h b/kernel/cobalt/posix/syscall.h
index d2b4442..1b8af79 100644
--- a/kernel/cobalt/posix/syscall.h
+++ b/kernel/cobalt/posix/syscall.h
@@ -21,7 +21,7 @@
 #include <cobalt/uapi/syscall.h>
 
 /* Regular (native) syscall handler implementation. */
-#define COBALT_SYSCALL(__name, __mode, __args) \
+#define COBALT_SYSCALL(__name, __args) \
        long cobalt_ ## __name __args
 
 /* Regular (native) syscall handler declaration. */
diff --git a/kernel/cobalt/posix/thread.c b/kernel/cobalt/posix/thread.c
index ad694aa..152b797 100644
--- a/kernel/cobalt/posix/thread.c
+++ b/kernel/cobalt/posix/thread.c
@@ -492,7 +492,7 @@ int __cobalt_thread_setschedparam_ex(unsigned long pth,
  * the Cobalt ABI. Useland changes scheduling parameters only via the
  * extended cobalt_thread_setschedparam_ex syscall.
  */
-COBALT_SYSCALL(thread_setschedparam_ex, conforming,
+COBALT_SYSCALL(thread_setschedparam_ex,
               (unsigned long pth,
                int policy,
                const struct sched_param_ex __user *u_param,
@@ -539,7 +539,7 @@ int __cobalt_thread_getschedparam_ex(unsigned long pth,
  * the Cobalt ABI. Useland retrieves scheduling parameters only via
  * the extended cobalt_thread_getschedparam_ex syscall.
  */
-COBALT_SYSCALL(thread_getschedparam_ex, current,
+COBALT_SYSCALL(thread_getschedparam_ex,
               (unsigned long pth,
                int __user *u_policy,
                struct sched_param_ex __user *u_param))
@@ -602,7 +602,7 @@ fail:
        return ret;
 }
 
-COBALT_SYSCALL(thread_create, init,
+COBALT_SYSCALL(thread_create,
               (unsigned long pth, int policy,
                struct sched_param_ex __user *u_param,
                int xid,
@@ -655,7 +655,7 @@ fail:
        return ERR_PTR(ret);
 }
 
-COBALT_SYSCALL(thread_setmode, primary,
+COBALT_SYSCALL(thread_setmode,
               (int clrmask, int setmask, int __user *u_mode_r))
 {
        int ret, old;
@@ -672,7 +672,7 @@ COBALT_SYSCALL(thread_setmode, primary,
        return 0;
 }
 
-COBALT_SYSCALL(thread_setname, current,
+COBALT_SYSCALL(thread_setname,
               (unsigned long pth, const char __user *u_name))
 {
        struct cobalt_local_hkey hkey;
@@ -712,7 +712,7 @@ COBALT_SYSCALL(thread_setname, current,
        return 0;
 }
 
-COBALT_SYSCALL(thread_kill, conforming,
+COBALT_SYSCALL(thread_kill,
               (unsigned long pth, int sig))
 {
        struct cobalt_local_hkey hkey;
@@ -737,7 +737,7 @@ COBALT_SYSCALL(thread_kill, conforming,
        return ret;
 }
 
-COBALT_SYSCALL(thread_join, primary, (unsigned long pth))
+COBALT_SYSCALL(thread_join, (unsigned long pth))
 {
        struct cobalt_local_hkey hkey;
        struct cobalt_thread *thread;
@@ -759,7 +759,7 @@ COBALT_SYSCALL(thread_join, primary, (unsigned long pth))
        return xnthread_join(&thread->threadbase, false);
 }
 
-COBALT_SYSCALL(thread_getpid, current, (unsigned long pth))
+COBALT_SYSCALL(thread_getpid, (unsigned long pth))
 {
        struct cobalt_local_hkey hkey;
        struct cobalt_thread *thread;
@@ -783,7 +783,7 @@ COBALT_SYSCALL(thread_getpid, current, (unsigned long pth))
        return pid;
 }
 
-COBALT_SYSCALL(thread_getstat, current,
+COBALT_SYSCALL(thread_getstat,
               (pid_t pid, struct cobalt_threadstat __user *u_stat))
 {
        struct cobalt_threadstat stat;
diff --git a/kernel/cobalt/posix/timer.c b/kernel/cobalt/posix/timer.c
index 0adc112..4429c7c 100644
--- a/kernel/cobalt/posix/timer.c
+++ b/kernel/cobalt/posix/timer.c
@@ -439,7 +439,7 @@ fail:
        return -EINVAL;
 }
 
-COBALT_SYSCALL(timer_delete, current, (timer_t timerid))
+COBALT_SYSCALL(timer_delete, (timer_t timerid))
 {
        return timer_delete(timerid);
 }
@@ -463,7 +463,7 @@ int __cobalt_timer_create(clockid_t clock,
        return 0;
 }
 
-COBALT_SYSCALL(timer_create, current,
+COBALT_SYSCALL(timer_create,
               (clockid_t clock,
                const struct sigevent __user *u_sev,
                timer_t __user *u_tm))
@@ -479,7 +479,7 @@ COBALT_SYSCALL(timer_create, current,
        return __cobalt_timer_create(clock, evp, u_tm);
 }
 
-COBALT_SYSCALL(timer_settime, primary,
+COBALT_SYSCALL(timer_settime,
               (timer_t tm, int flags,
                const struct itimerspec __user *u_newval,
                struct itimerspec __user *u_oldval))
@@ -505,7 +505,7 @@ COBALT_SYSCALL(timer_settime, primary,
        return 0;
 }
 
-COBALT_SYSCALL(timer_gettime, current,
+COBALT_SYSCALL(timer_gettime,
               (timer_t tm, struct itimerspec __user *u_val))
 {
        struct itimerspec val;
@@ -518,7 +518,7 @@ COBALT_SYSCALL(timer_gettime, current,
        return cobalt_copy_to_user(u_val, &val, sizeof(val));
 }
 
-COBALT_SYSCALL(timer_getoverrun, current, (timer_t timerid))
+COBALT_SYSCALL(timer_getoverrun, (timer_t timerid))
 {
        struct cobalt_timer *timer;
        struct cobalt_process *cc;
diff --git a/kernel/cobalt/posix/timerfd.c b/kernel/cobalt/posix/timerfd.c
index 90c4b3f..d671f29 100644
--- a/kernel/cobalt/posix/timerfd.c
+++ b/kernel/cobalt/posix/timerfd.c
@@ -162,7 +162,7 @@ static void timerfd_handler(struct xntimer *xntimer)
                xnthread_unblock(tfd->target);
 }
 
-COBALT_SYSCALL(timerfd_create, lostage, (int clockid, int flags))
+COBALT_SYSCALL(timerfd_create, (int clockid, int flags))
 {
        struct cobalt_tfd *tfd;
        struct xnthread *curr;
@@ -274,7 +274,7 @@ out:
        return ret;
 }
 
-COBALT_SYSCALL(timerfd_settime, primary,
+COBALT_SYSCALL(timerfd_settime,
               (int fd, int flags,
                const struct itimerspec __user *new_value,
                struct itimerspec __user *old_value))
@@ -318,7 +318,7 @@ int __cobalt_timerfd_gettime(int fd, struct itimerspec 
*value)
        return 0;
 }
 
-COBALT_SYSCALL(timerfd_gettime, current,
+COBALT_SYSCALL(timerfd_gettime,
               (int fd, struct itimerspec __user *curr_value))
 {
        struct itimerspec value;


_______________________________________________
Xenomai-git mailing list
Xenomai-git@xenomai.org
http://xenomai.org/mailman/listinfo/xenomai-git

Reply via email to