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

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

cobalt/kernel: Use COBALT_SYSCALL instead of COBALT_SYSCALL_DECL

The latter has the same effect as the former for quite a while, and now
it also has the same parameters. There is no need for a separate macro.

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

---

 kernel/cobalt/posix/clock.h   |   20 ++++++-------
 kernel/cobalt/posix/cond.h    |   28 +++++++++----------
 kernel/cobalt/posix/event.h   |   38 ++++++++++++-------------
 kernel/cobalt/posix/io.h      |   52 +++++++++++++++++-----------------
 kernel/cobalt/posix/monitor.h |   32 ++++++++++-----------
 kernel/cobalt/posix/mqueue.h  |   30 ++++++++++----------
 kernel/cobalt/posix/mutex.h   |   32 ++++++++++-----------
 kernel/cobalt/posix/sched.h   |   28 +++++++++----------
 kernel/cobalt/posix/sem.h     |   62 ++++++++++++++++++++---------------------
 kernel/cobalt/posix/signal.h  |   28 +++++++++----------
 kernel/cobalt/posix/syscall.h |    6 +---
 kernel/cobalt/posix/thread.h  |   46 +++++++++++++++---------------
 kernel/cobalt/posix/timer.h   |   24 ++++++++--------
 kernel/cobalt/posix/timerfd.h |   16 +++++------
 14 files changed, 219 insertions(+), 223 deletions(-)

diff --git a/kernel/cobalt/posix/clock.h b/kernel/cobalt/posix/clock.h
index c810c1e..98f4508 100644
--- a/kernel/cobalt/posix/clock.h
+++ b/kernel/cobalt/posix/clock.h
@@ -97,19 +97,19 @@ int __cobalt_clock_nanosleep(clockid_t clock_id, int flags,
                             const struct timespec *rqt,
                             struct timespec *rmt);
 
-COBALT_SYSCALL_DECL(clock_getres,
-                   (clockid_t clock_id, struct timespec __user *u_ts));
+COBALT_SYSCALL(clock_getres,
+              (clockid_t clock_id, struct timespec __user *u_ts));
 
-COBALT_SYSCALL_DECL(clock_gettime,
-                   (clockid_t clock_id, struct timespec __user *u_ts));
+COBALT_SYSCALL(clock_gettime,
+              (clockid_t clock_id, struct timespec __user *u_ts));
 
-COBALT_SYSCALL_DECL(clock_settime,
-                   (clockid_t clock_id, const struct timespec __user *u_ts));
+COBALT_SYSCALL(clock_settime,
+              (clockid_t clock_id, const struct timespec __user *u_ts));
 
-COBALT_SYSCALL_DECL(clock_nanosleep,
-                   (clockid_t clock_id, int flags,
-                    const struct timespec __user *u_rqt,
-                    struct timespec __user *u_rmt));
+COBALT_SYSCALL(clock_nanosleep,
+              (clockid_t clock_id, int flags,
+               const struct timespec __user *u_rqt,
+               struct timespec __user *u_rmt));
 
 int cobalt_clock_register(struct xnclock *clock,
                          clockid_t *clk_id);
diff --git a/kernel/cobalt/posix/cond.h b/kernel/cobalt/posix/cond.h
index c7a9be4..2e4f862 100644
--- a/kernel/cobalt/posix/cond.h
+++ b/kernel/cobalt/posix/cond.h
@@ -45,23 +45,23 @@ int __cobalt_cond_wait_prologue(struct cobalt_cond_shadow 
__user *u_cnd,
                                void __user *u_ts,
                                int (*fetch_timeout)(struct timespec *ts,
                                                     const void __user *u_ts));
-COBALT_SYSCALL_DECL(cond_init,
-                   (struct cobalt_cond_shadow __user *u_cnd,
-                    const struct cobalt_condattr __user *u_attr));
+COBALT_SYSCALL(cond_init,
+              (struct cobalt_cond_shadow __user *u_cnd,
+               const struct cobalt_condattr __user *u_attr));
 
-COBALT_SYSCALL_DECL(cond_destroy,
-                   (struct cobalt_cond_shadow __user *u_cnd));
+COBALT_SYSCALL(cond_destroy,
+              (struct cobalt_cond_shadow __user *u_cnd));
 
-COBALT_SYSCALL_DECL(cond_wait_prologue,
-                   (struct cobalt_cond_shadow __user *u_cnd,
-                    struct cobalt_mutex_shadow __user *u_mx,
-                    int *u_err,
-                    unsigned int timed,
-                    struct timespec __user *u_ts));
+COBALT_SYSCALL(cond_wait_prologue,
+              (struct cobalt_cond_shadow __user *u_cnd,
+               struct cobalt_mutex_shadow __user *u_mx,
+               int *u_err,
+               unsigned int timed,
+               struct timespec __user *u_ts));
 
-COBALT_SYSCALL_DECL(cond_wait_epilogue,
-                   (struct cobalt_cond_shadow __user *u_cnd,
-                    struct cobalt_mutex_shadow __user *u_mx));
+COBALT_SYSCALL(cond_wait_epilogue,
+              (struct cobalt_cond_shadow __user *u_cnd,
+               struct cobalt_mutex_shadow __user *u_mx));
 
 int cobalt_cond_deferred_signals(struct cobalt_cond *cond);
 
diff --git a/kernel/cobalt/posix/event.h b/kernel/cobalt/posix/event.h
index 28d4516..1424c67 100644
--- a/kernel/cobalt/posix/event.h
+++ b/kernel/cobalt/posix/event.h
@@ -41,29 +41,29 @@ int __cobalt_event_wait(struct cobalt_event_shadow __user 
*u_event,
                        unsigned int __user *u_bits_r,
                        int mode, const struct timespec *ts);
 
-COBALT_SYSCALL_DECL(event_init,
-                   (struct cobalt_event_shadow __user *u_evtsh,
-                    unsigned int value,
-                    int flags));
+COBALT_SYSCALL(event_init,
+              (struct cobalt_event_shadow __user *u_evtsh,
+               unsigned int value,
+               int flags));
 
-COBALT_SYSCALL_DECL(event_wait,
-                   (struct cobalt_event_shadow __user *u_evtsh,
-                    unsigned int bits,
-                    unsigned int __user *u_bits_r,
-                    int mode,
-                    const struct timespec __user *u_ts));
+COBALT_SYSCALL(event_wait,
+              (struct cobalt_event_shadow __user *u_evtsh,
+               unsigned int bits,
+               unsigned int __user *u_bits_r,
+               int mode,
+               const struct timespec __user *u_ts));
 
-COBALT_SYSCALL_DECL(event_sync,
-                   (struct cobalt_event_shadow __user *u_evtsh));
+COBALT_SYSCALL(event_sync,
+              (struct cobalt_event_shadow __user *u_evtsh));
 
-COBALT_SYSCALL_DECL(event_destroy,
-                   (struct cobalt_event_shadow __user *u_evtsh));
+COBALT_SYSCALL(event_destroy,
+              (struct cobalt_event_shadow __user *u_evtsh));
 
-COBALT_SYSCALL_DECL(event_inquire,
-                   (struct cobalt_event_shadow __user *u_event,
-                    struct cobalt_event_info __user *u_info,
-                    pid_t __user *u_waitlist,
-                    size_t waitsz));
+COBALT_SYSCALL(event_inquire,
+              (struct cobalt_event_shadow __user *u_event,
+               struct cobalt_event_info __user *u_info,
+               pid_t __user *u_waitlist,
+               size_t waitsz));
 
 void cobalt_event_reclaim(struct cobalt_resnode *node,
                          spl_t s);
diff --git a/kernel/cobalt/posix/io.h b/kernel/cobalt/posix/io.h
index 3189acf..fb715bc 100644
--- a/kernel/cobalt/posix/io.h
+++ b/kernel/cobalt/posix/io.h
@@ -28,41 +28,41 @@ int __cobalt_first_fd_valid_p(fd_set 
*fds[XNSELECT_MAX_TYPES], int nfds);
 int __cobalt_select_bind_all(struct xnselector *selector,
                             fd_set *fds[XNSELECT_MAX_TYPES], int nfds);
 
-COBALT_SYSCALL_DECL(open,
-                   (const char __user *u_path, int oflag));
+COBALT_SYSCALL(open,
+              (const char __user *u_path, int oflag));
 
-COBALT_SYSCALL_DECL(socket,
-                   (int protocol_family,
-                    int socket_type, int protocol));
+COBALT_SYSCALL(socket,
+              (int protocol_family,
+               int socket_type, int protocol));
 
-COBALT_SYSCALL_DECL(close, (int fd));
+COBALT_SYSCALL(close, (int fd));
 
-COBALT_SYSCALL_DECL(fcntl, (int fd, int cmd, int arg));
+COBALT_SYSCALL(fcntl, (int fd, int cmd, int arg));
 
-COBALT_SYSCALL_DECL(ioctl,
-                   (int fd, unsigned int request, void __user *arg));
+COBALT_SYSCALL(ioctl,
+              (int fd, unsigned int request, void __user *arg));
 
-COBALT_SYSCALL_DECL(read,
-                   (int fd, void __user *buf, size_t size));
+COBALT_SYSCALL(read,
+              (int fd, void __user *buf, size_t size));
 
-COBALT_SYSCALL_DECL(write,
-                   (int fd, const void __user *buf, size_t size));
+COBALT_SYSCALL(write,
+              (int fd, const void __user *buf, size_t size));
 
-COBALT_SYSCALL_DECL(recvmsg,
-                   (int fd, struct msghdr __user *umsg, int flags));
+COBALT_SYSCALL(recvmsg,
+              (int fd, struct msghdr __user *umsg, int flags));
 
-COBALT_SYSCALL_DECL(sendmsg,
-                   (int fd, struct msghdr __user *umsg, int flags));
+COBALT_SYSCALL(sendmsg,
+              (int fd, struct msghdr __user *umsg, int flags));
 
-COBALT_SYSCALL_DECL(mmap,
-                   (int fd, struct _rtdm_mmap_request __user *u_rma,
-                    void __user * __user *u_addrp));
+COBALT_SYSCALL(mmap,
+              (int fd, struct _rtdm_mmap_request __user *u_rma,
+               void __user * __user *u_addrp));
 
-COBALT_SYSCALL_DECL(select,
-                   (int nfds,
-                    fd_set __user *u_rfds,
-                    fd_set __user *u_wfds,
-                    fd_set __user *u_xfds,
-                    struct timeval __user *u_tv));
+COBALT_SYSCALL(select,
+              (int nfds,
+               fd_set __user *u_rfds,
+               fd_set __user *u_wfds,
+               fd_set __user *u_xfds,
+               struct timeval __user *u_tv));
 
 #endif /* !_COBALT_POSIX_IO_H */
diff --git a/kernel/cobalt/posix/monitor.h b/kernel/cobalt/posix/monitor.h
index 8b321aa..8581736 100644
--- a/kernel/cobalt/posix/monitor.h
+++ b/kernel/cobalt/posix/monitor.h
@@ -42,27 +42,27 @@ int __cobalt_monitor_wait(struct cobalt_monitor_shadow 
__user *u_mon,
                          int event, const struct timespec *ts,
                          int __user *u_ret);
 
-COBALT_SYSCALL_DECL(monitor_init,
-                   (struct cobalt_monitor_shadow __user *u_monsh,
-                    clockid_t clk_id,
-                    int flags));
+COBALT_SYSCALL(monitor_init,
+              (struct cobalt_monitor_shadow __user *u_monsh,
+               clockid_t clk_id,
+               int flags));
 
-COBALT_SYSCALL_DECL(monitor_enter,
-                   (struct cobalt_monitor_shadow __user *u_monsh));
+COBALT_SYSCALL(monitor_enter,
+              (struct cobalt_monitor_shadow __user *u_monsh));
 
-COBALT_SYSCALL_DECL(monitor_sync,
-                   (struct cobalt_monitor_shadow __user *u_monsh));
+COBALT_SYSCALL(monitor_sync,
+              (struct cobalt_monitor_shadow __user *u_monsh));
 
-COBALT_SYSCALL_DECL(monitor_exit,
-                   (struct cobalt_monitor_shadow __user *u_monsh));
+COBALT_SYSCALL(monitor_exit,
+              (struct cobalt_monitor_shadow __user *u_monsh));
 
-COBALT_SYSCALL_DECL(monitor_wait,
-                   (struct cobalt_monitor_shadow __user *u_monsh,
-                    int event, const struct timespec __user *u_ts,
-                    int __user *u_ret));
+COBALT_SYSCALL(monitor_wait,
+              (struct cobalt_monitor_shadow __user *u_monsh,
+               int event, const struct timespec __user *u_ts,
+               int __user *u_ret));
 
-COBALT_SYSCALL_DECL(monitor_destroy,
-                   (struct cobalt_monitor_shadow __user *u_monsh));
+COBALT_SYSCALL(monitor_destroy,
+              (struct cobalt_monitor_shadow __user *u_monsh));
 
 void cobalt_monitor_reclaim(struct cobalt_resnode *node,
                            spl_t s);
diff --git a/kernel/cobalt/posix/mqueue.h b/kernel/cobalt/posix/mqueue.h
index acae2a4..eb78db9 100644
--- a/kernel/cobalt/posix/mqueue.h
+++ b/kernel/cobalt/posix/mqueue.h
@@ -49,26 +49,26 @@ int __cobalt_mq_timedreceive(mqd_t uqd, void __user *u_buf,
 
 int __cobalt_mq_notify(mqd_t fd, const struct sigevent *evp);
 
-COBALT_SYSCALL_DECL(mq_open,
-                   (const char __user *u_name, int oflags,
-                    mode_t mode, struct mq_attr __user *u_attr));
+COBALT_SYSCALL(mq_open,
+              (const char __user *u_name, int oflags,
+               mode_t mode, struct mq_attr __user *u_attr));
 
-COBALT_SYSCALL_DECL(mq_close, (mqd_t uqd));
+COBALT_SYSCALL(mq_close, (mqd_t uqd));
 
-COBALT_SYSCALL_DECL(mq_unlink, (const char __user *u_name));
+COBALT_SYSCALL(mq_unlink, (const char __user *u_name));
 
-COBALT_SYSCALL_DECL(mq_getattr, (mqd_t uqd, struct mq_attr __user *u_attr));
+COBALT_SYSCALL(mq_getattr, (mqd_t uqd, struct mq_attr __user *u_attr));
 
-COBALT_SYSCALL_DECL(mq_timedsend,
-                   (mqd_t uqd, const void __user *u_buf, size_t len,
-                    unsigned int prio, const struct timespec __user *u_ts));
+COBALT_SYSCALL(mq_timedsend,
+              (mqd_t uqd, const void __user *u_buf, size_t len,
+               unsigned int prio, const struct timespec __user *u_ts));
 
-COBALT_SYSCALL_DECL(mq_timedreceive,
-                   (mqd_t uqd, void __user *u_buf, ssize_t __user *u_len,
-                    unsigned int __user *u_prio,
-                    const struct timespec __user *u_ts));
+COBALT_SYSCALL(mq_timedreceive,
+              (mqd_t uqd, void __user *u_buf, ssize_t __user *u_len,
+               unsigned int __user *u_prio,
+               const struct timespec __user *u_ts));
 
-COBALT_SYSCALL_DECL(mq_notify,
-                   (mqd_t fd, const struct sigevent *__user evp));
+COBALT_SYSCALL(mq_notify,
+              (mqd_t fd, const struct sigevent *__user evp));
 
 #endif /* !_COBALT_POSIX_MQUEUE_H */
diff --git a/kernel/cobalt/posix/mutex.h b/kernel/cobalt/posix/mutex.h
index ac1c502..ad3d603 100644
--- a/kernel/cobalt/posix/mutex.h
+++ b/kernel/cobalt/posix/mutex.h
@@ -44,28 +44,28 @@ int __cobalt_mutex_acquire_unchecked(struct xnthread *cur,
                                     struct cobalt_mutex *mutex,
                                     const struct timespec *ts);
 
-COBALT_SYSCALL_DECL(mutex_check_init,
-                   (struct cobalt_mutex_shadow __user *u_mx));
+COBALT_SYSCALL(mutex_check_init,
+              (struct cobalt_mutex_shadow __user *u_mx));
 
-COBALT_SYSCALL_DECL(mutex_init,
-                   (struct cobalt_mutex_shadow __user *u_mx,
-                    const struct cobalt_mutexattr __user *u_attr));
+COBALT_SYSCALL(mutex_init,
+              (struct cobalt_mutex_shadow __user *u_mx,
+               const struct cobalt_mutexattr __user *u_attr));
 
-COBALT_SYSCALL_DECL(mutex_destroy,
-                   (struct cobalt_mutex_shadow __user *u_mx));
+COBALT_SYSCALL(mutex_destroy,
+              (struct cobalt_mutex_shadow __user *u_mx));
 
-COBALT_SYSCALL_DECL(mutex_trylock,
-                   (struct cobalt_mutex_shadow __user *u_mx));
+COBALT_SYSCALL(mutex_trylock,
+              (struct cobalt_mutex_shadow __user *u_mx));
 
-COBALT_SYSCALL_DECL(mutex_lock,
-                   (struct cobalt_mutex_shadow __user *u_mx));
+COBALT_SYSCALL(mutex_lock,
+              (struct cobalt_mutex_shadow __user *u_mx));
 
-COBALT_SYSCALL_DECL(mutex_timedlock,
-                   (struct cobalt_mutex_shadow __user *u_mx,
-                    const struct timespec __user *u_ts));
+COBALT_SYSCALL(mutex_timedlock,
+              (struct cobalt_mutex_shadow __user *u_mx,
+               const struct timespec __user *u_ts));
 
-COBALT_SYSCALL_DECL(mutex_unlock,
-                   (struct cobalt_mutex_shadow __user *u_mx));
+COBALT_SYSCALL(mutex_unlock,
+              (struct cobalt_mutex_shadow __user *u_mx));
 
 int cobalt_mutex_release(struct xnthread *cur,
                         struct cobalt_mutex *mutex);
diff --git a/kernel/cobalt/posix/sched.h b/kernel/cobalt/posix/sched.h
index ae7b618..23476d6 100644
--- a/kernel/cobalt/posix/sched.h
+++ b/kernel/cobalt/posix/sched.h
@@ -62,25 +62,25 @@ cobalt_sched_policy_param(union xnsched_policy_param *param,
                          int u_policy, const struct sched_param_ex *param_ex,
                          xnticks_t *tslice_r);
 
-COBALT_SYSCALL_DECL(sched_yield, (void));
+COBALT_SYSCALL(sched_yield, (void));
 
-COBALT_SYSCALL_DECL(sched_weightprio,
-                   (int policy, const struct sched_param_ex __user *u_param));
+COBALT_SYSCALL(sched_weightprio,
+              (int policy, const struct sched_param_ex __user *u_param));
 
-COBALT_SYSCALL_DECL(sched_minprio, (int policy));
+COBALT_SYSCALL(sched_minprio, (int policy));
 
-COBALT_SYSCALL_DECL(sched_maxprio, (int policy));
+COBALT_SYSCALL(sched_maxprio, (int policy));
 
-COBALT_SYSCALL_DECL(sched_setconfig_np,
-                   (int cpu,
-                    int policy,
-                    union sched_config __user *u_config,
-                    size_t len));
+COBALT_SYSCALL(sched_setconfig_np,
+              (int cpu,
+               int policy,
+               union sched_config __user *u_config,
+               size_t len));
 
-COBALT_SYSCALL_DECL(sched_getconfig_np,
-                   (int cpu, int policy,
-                    union sched_config __user *u_config,
-                    size_t len));
+COBALT_SYSCALL(sched_getconfig_np,
+              (int cpu, int policy,
+               union sched_config __user *u_config,
+               size_t len));
 
 void cobalt_sched_reclaim(struct cobalt_process *process);
 
diff --git a/kernel/cobalt/posix/sem.h b/kernel/cobalt/posix/sem.h
index a95b6c4..d4aafa4 100644
--- a/kernel/cobalt/posix/sem.h
+++ b/kernel/cobalt/posix/sem.h
@@ -76,48 +76,48 @@ struct cobalt_sem *
 __cobalt_sem_init(const char *name, struct cobalt_sem_shadow *sem,
                  int flags, unsigned value);
 
-COBALT_SYSCALL_DECL(sem_init,
-                   (struct cobalt_sem_shadow __user *u_sem,
-                    int flags, unsigned value));
+COBALT_SYSCALL(sem_init,
+              (struct cobalt_sem_shadow __user *u_sem,
+               int flags, unsigned value));
 
-COBALT_SYSCALL_DECL(sem_post,
-                   (struct cobalt_sem_shadow __user *u_sem));
+COBALT_SYSCALL(sem_post,
+              (struct cobalt_sem_shadow __user *u_sem));
 
-COBALT_SYSCALL_DECL(sem_wait,
-                   (struct cobalt_sem_shadow __user *u_sem));
+COBALT_SYSCALL(sem_wait,
+              (struct cobalt_sem_shadow __user *u_sem));
 
-COBALT_SYSCALL_DECL(sem_timedwait,
-                   (struct cobalt_sem_shadow __user *u_sem,
-                    struct timespec __user *u_ts));
+COBALT_SYSCALL(sem_timedwait,
+              (struct cobalt_sem_shadow __user *u_sem,
+               struct timespec __user *u_ts));
 
-COBALT_SYSCALL_DECL(sem_trywait,
-                   (struct cobalt_sem_shadow __user *u_sem));
+COBALT_SYSCALL(sem_trywait,
+              (struct cobalt_sem_shadow __user *u_sem));
 
-COBALT_SYSCALL_DECL(sem_getvalue,
-                   (struct cobalt_sem_shadow __user *u_sem,
-                    int __user *u_sval));
+COBALT_SYSCALL(sem_getvalue,
+              (struct cobalt_sem_shadow __user *u_sem,
+               int __user *u_sval));
 
-COBALT_SYSCALL_DECL(sem_destroy,
-                   (struct cobalt_sem_shadow __user *u_sem));
+COBALT_SYSCALL(sem_destroy,
+              (struct cobalt_sem_shadow __user *u_sem));
 
-COBALT_SYSCALL_DECL(sem_open,
-                   (struct cobalt_sem_shadow __user *__user *u_addrp,
-                    const char __user *u_name,
-                    int oflags, mode_t mode, unsigned int value));
+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));
 
-COBALT_SYSCALL_DECL(sem_close,
-                   (struct cobalt_sem_shadow __user *usm));
+COBALT_SYSCALL(sem_close,
+              (struct cobalt_sem_shadow __user *usm));
 
-COBALT_SYSCALL_DECL(sem_unlink, (const char __user *u_name));
+COBALT_SYSCALL(sem_unlink, (const char __user *u_name));
 
-COBALT_SYSCALL_DECL(sem_broadcast_np,
-                   (struct cobalt_sem_shadow __user *u_sem));
+COBALT_SYSCALL(sem_broadcast_np,
+              (struct cobalt_sem_shadow __user *u_sem));
 
-COBALT_SYSCALL_DECL(sem_inquire,
-                   (struct cobalt_sem_shadow __user *u_sem,
-                    struct cobalt_sem_info __user *u_info,
-                    pid_t __user *u_waitlist,
-                    size_t waitsz));
+COBALT_SYSCALL(sem_inquire,
+              (struct cobalt_sem_shadow __user *u_sem,
+               struct cobalt_sem_info __user *u_info,
+               pid_t __user *u_waitlist,
+               size_t waitsz));
 
 void cobalt_sem_reclaim(struct cobalt_resnode *node,
                        spl_t s);
diff --git a/kernel/cobalt/posix/signal.h b/kernel/cobalt/posix/signal.h
index 993c48b..8d574e0 100644
--- a/kernel/cobalt/posix/signal.h
+++ b/kernel/cobalt/posix/signal.h
@@ -92,25 +92,25 @@ int cobalt_signal_wait(sigset_t *set, struct siginfo *si,
 int __cobalt_kill(struct cobalt_thread *thread,
                  int sig, int group);
 
-COBALT_SYSCALL_DECL(sigwait,
-                   (const sigset_t __user *u_set, int __user *u_sig));
+COBALT_SYSCALL(sigwait,
+              (const sigset_t __user *u_set, int __user *u_sig));
 
-COBALT_SYSCALL_DECL(sigtimedwait,
-                   (const sigset_t __user *u_set,
-                    struct siginfo __user *u_si,
-                    const struct timespec __user *u_timeout));
+COBALT_SYSCALL(sigtimedwait,
+              (const sigset_t __user *u_set,
+               struct siginfo __user *u_si,
+               const struct timespec __user *u_timeout));
 
-COBALT_SYSCALL_DECL(sigwaitinfo,
-                   (const sigset_t __user *u_set,
-                    struct siginfo __user *u_si));
+COBALT_SYSCALL(sigwaitinfo,
+              (const sigset_t __user *u_set,
+               struct siginfo __user *u_si));
 
-COBALT_SYSCALL_DECL(sigpending,
-                   (old_sigset_t __user *u_set));
+COBALT_SYSCALL(sigpending,
+              (old_sigset_t __user *u_set));
 
-COBALT_SYSCALL_DECL(kill, (pid_t pid, int sig));
+COBALT_SYSCALL(kill, (pid_t pid, int sig));
 
-COBALT_SYSCALL_DECL(sigqueue,
-                   (pid_t pid, int sig, const union sigval __user *u_value));
+COBALT_SYSCALL(sigqueue,
+              (pid_t pid, int sig, const union sigval __user *u_value));
 
 int cobalt_signal_init(void);
 
diff --git a/kernel/cobalt/posix/syscall.h b/kernel/cobalt/posix/syscall.h
index 1b8af79..4151360 100644
--- a/kernel/cobalt/posix/syscall.h
+++ b/kernel/cobalt/posix/syscall.h
@@ -20,14 +20,10 @@
 
 #include <cobalt/uapi/syscall.h>
 
-/* Regular (native) syscall handler implementation. */
+/* Regular (native) syscall handler declaration/implementation. */
 #define COBALT_SYSCALL(__name, __args) \
        long cobalt_ ## __name __args
 
-/* Regular (native) syscall handler declaration. */
-#define COBALT_SYSCALL_DECL(__name, __args)    \
-       long cobalt_ ## __name __args
-
 #include <asm/xenomai/syscall32.h>
 
 #endif /* !_COBALT_POSIX_SYSCALL_H */
diff --git a/kernel/cobalt/posix/thread.h b/kernel/cobalt/posix/thread.h
index ffdf612..8f867ec 100644
--- a/kernel/cobalt/posix/thread.h
+++ b/kernel/cobalt/posix/thread.h
@@ -138,42 +138,42 @@ struct cobalt_thread *cobalt_thread_find_local(pid_t pid);
 
 struct cobalt_thread *cobalt_thread_lookup(unsigned long pth);
 
-COBALT_SYSCALL_DECL(thread_create,
-                   (unsigned long pth, int policy,
-                    struct sched_param_ex __user *u_param,
-                    int xid, __u32 __user *u_winoff));
+COBALT_SYSCALL(thread_create,
+              (unsigned long pth, int policy,
+               struct sched_param_ex __user *u_param,
+               int xid, __u32 __user *u_winoff));
 
 struct cobalt_thread *
 cobalt_thread_shadow(struct task_struct *p,
                     struct cobalt_local_hkey *lhkey,
                     __u32 __user *u_winoff);
 
-COBALT_SYSCALL_DECL(thread_setmode,
-                   (int clrmask, int setmask, int __user *u_mode_r));
+COBALT_SYSCALL(thread_setmode,
+              (int clrmask, int setmask, int __user *u_mode_r));
 
-COBALT_SYSCALL_DECL(thread_setname,
-                   (unsigned long pth, const char __user *u_name));
+COBALT_SYSCALL(thread_setname,
+              (unsigned long pth, const char __user *u_name));
 
-COBALT_SYSCALL_DECL(thread_kill, (unsigned long pth, int sig));
+COBALT_SYSCALL(thread_kill, (unsigned long pth, int sig));
 
-COBALT_SYSCALL_DECL(thread_join, (unsigned long pth));
+COBALT_SYSCALL(thread_join, (unsigned long pth));
 
-COBALT_SYSCALL_DECL(thread_getpid, (unsigned long pth));
+COBALT_SYSCALL(thread_getpid, (unsigned long pth));
 
-COBALT_SYSCALL_DECL(thread_getstat,
-                   (pid_t pid, struct cobalt_threadstat __user *u_stat));
+COBALT_SYSCALL(thread_getstat,
+              (pid_t pid, struct cobalt_threadstat __user *u_stat));
 
-COBALT_SYSCALL_DECL(thread_setschedparam_ex,
-                   (unsigned long pth,
-                    int policy,
-                    const struct sched_param_ex __user *u_param,
-                    __u32 __user *u_winoff,
-                    int __user *u_promoted));
+COBALT_SYSCALL(thread_setschedparam_ex,
+              (unsigned long pth,
+               int policy,
+               const struct sched_param_ex __user *u_param,
+               __u32 __user *u_winoff,
+               int __user *u_promoted));
 
-COBALT_SYSCALL_DECL(thread_getschedparam_ex,
-                   (unsigned long pth,
-                    int __user *u_policy,
-                    struct sched_param_ex __user *u_param));
+COBALT_SYSCALL(thread_getschedparam_ex,
+              (unsigned long pth,
+               int __user *u_policy,
+               struct sched_param_ex __user *u_param));
 
 void cobalt_thread_map(struct xnthread *curr);
 
diff --git a/kernel/cobalt/posix/timer.h b/kernel/cobalt/posix/timer.h
index f0b41f0..a12e281 100644
--- a/kernel/cobalt/posix/timer.h
+++ b/kernel/cobalt/posix/timer.h
@@ -65,21 +65,21 @@ int __cobalt_timer_settime(timer_t timerid, int flags,
 
 int __cobalt_timer_gettime(timer_t timerid, struct itimerspec *value);
 
-COBALT_SYSCALL_DECL(timer_create,
-                   (clockid_t clock,
-                    const struct sigevent __user *u_sev,
-                    timer_t __user *u_tm));
+COBALT_SYSCALL(timer_create,
+              (clockid_t clock,
+               const struct sigevent __user *u_sev,
+               timer_t __user *u_tm));
 
-COBALT_SYSCALL_DECL(timer_delete, (timer_t tm));
+COBALT_SYSCALL(timer_delete, (timer_t tm));
 
-COBALT_SYSCALL_DECL(timer_settime,
-                   (timer_t tm, int flags,
-                    const struct itimerspec __user *u_newval,
-                    struct itimerspec __user *u_oldval));
+COBALT_SYSCALL(timer_settime,
+              (timer_t tm, int flags,
+               const struct itimerspec __user *u_newval,
+               struct itimerspec __user *u_oldval));
 
-COBALT_SYSCALL_DECL(timer_gettime,
-                   (timer_t tm, struct itimerspec __user *u_val));
+COBALT_SYSCALL(timer_gettime,
+              (timer_t tm, struct itimerspec __user *u_val));
 
-COBALT_SYSCALL_DECL(timer_getoverrun, (timer_t tm));
+COBALT_SYSCALL(timer_getoverrun, (timer_t tm));
 
 #endif /* !_COBALT_POSIX_TIMER_H */
diff --git a/kernel/cobalt/posix/timerfd.h b/kernel/cobalt/posix/timerfd.h
index 5787ff6..317e619 100644
--- a/kernel/cobalt/posix/timerfd.h
+++ b/kernel/cobalt/posix/timerfd.h
@@ -28,15 +28,15 @@ int __cobalt_timerfd_settime(int fd, int flags,
 int __cobalt_timerfd_gettime(int fd,
                             struct itimerspec *value);
 
-COBALT_SYSCALL_DECL(timerfd_create,
-                   (int clockid, int flags));
+COBALT_SYSCALL(timerfd_create,
+              (int clockid, int flags));
 
-COBALT_SYSCALL_DECL(timerfd_settime,
-                   (int fd, int flags,
-                    const struct itimerspec __user *new_value,
-                    struct itimerspec __user *old_value));
+COBALT_SYSCALL(timerfd_settime,
+              (int fd, int flags,
+               const struct itimerspec __user *new_value,
+               struct itimerspec __user *old_value));
 
-COBALT_SYSCALL_DECL(timerfd_gettime,
-                   (int fd, struct itimerspec __user *curr_value));
+COBALT_SYSCALL(timerfd_gettime,
+              (int fd, struct itimerspec __user *curr_value));
 
 #endif /* TIMERFD_H */


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

Reply via email to