thread.h

/*
 * Written by Gilles Chanteperdrix <gilles.chanteperdrix@xenomai.org>.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 */
#ifndef _COBALT_POSIX_THREAD_H
#define _COBALT_POSIX_THREAD_H
 
#include <linux/stdarg.h>
#include <linux/types.h>
#include <linux/time.h>
#include <linux/signal.h>
#include <cobalt/kernel/thread.h>
#include <cobalt/uapi/thread.h>
#include <cobalt/uapi/sched.h>
/* CAUTION: rtdm/cobalt.h reads this header. */
#include <xenomai/posix/syscall.h>
#include <xenomai/posix/extension.h>
 
#define PTHREAD_PROCESS_PRIVATE 0
#define PTHREAD_PROCESS_SHARED  1
 
#define PTHREAD_CREATE_JOINABLE 0
#define PTHREAD_CREATE_DETACHED 1
 
#define PTHREAD_INHERIT_SCHED  0
#define PTHREAD_EXPLICIT_SCHED 1
 
#define PTHREAD_MUTEX_NORMAL     0
#define PTHREAD_MUTEX_RECURSIVE  1
#define PTHREAD_MUTEX_ERRORCHECK 2
#define PTHREAD_MUTEX_DEFAULT    0
 
struct cobalt_thread;
struct cobalt_threadstat;
 
/*
 * pthread_mutexattr_t and pthread_condattr_t fit on 32 bits, for
 * compatibility with libc.
 */
 
/* The following definitions are copied from linuxthread pthreadtypes.h. */
struct _pthread_fastlock {
        long int __status;
        int __spinlock;
};
 
typedef struct {
        struct _pthread_fastlock __c_lock;
        long __c_waiting;
        char __padding[48 - sizeof (struct _pthread_fastlock)
                       - sizeof (long) - sizeof (long long)];
        long long __align;
} pthread_cond_t;
 
enum {
        PTHREAD_PRIO_NONE,
        PTHREAD_PRIO_INHERIT,
        PTHREAD_PRIO_PROTECT
};
 
typedef struct {
        int __m_reserved;
        int __m_count;
        long __m_owner;
        int __m_kind;
        struct _pthread_fastlock __m_lock;
} pthread_mutex_t;
 
struct cobalt_local_hkey {
        unsigned long u_pth;
        struct mm_struct *mm;
};
 
struct cobalt_thread {
        unsigned int magic;
        struct xnthread threadbase;
        struct cobalt_extref extref;
        struct cobalt_process *process;
        struct list_head next;  /* in global/process thread_list */
 
        sigset_t sigpending;
        struct list_head sigqueues[_NSIG]; /* in cobalt_sigpending */
        struct xnsynch sigwait;
        struct list_head signext;
 
        struct xnsynch monitor_synch;
        struct list_head monitor_link;
 
        struct cobalt_local_hkey hkey;
};
 
struct cobalt_sigwait_context {
        struct xnthread_wait_context wc;
        sigset_t *set;
        struct siginfo *si;
};
 
static inline struct cobalt_thread *cobalt_current_thread(void)
{
        struct xnthread *curr = xnthread_current();
        return curr ? container_of(curr, struct cobalt_thread, threadbase) : NULL;
}
 
int __cobalt_thread_create(unsigned long pth, int policy,
                           struct sched_param_ex __user *u_param,
                           int xid, __u32 __user *u_winoff);
 
int __cobalt_thread_setschedparam_ex(struct cobalt_thread *thread, int policy,
                                     const struct sched_param_ex *param_ex);
 
int cobalt_thread_setschedparam_ex(unsigned long pth,
                                   int policy,
                                   const struct sched_param_ex *param_ex,
                                   __u32 __user *u_winoff,
                                   int __user *u_promoted);
 
int cobalt_thread_getschedparam_ex(unsigned long pth,
                                   int *policy_r,
                                   struct sched_param_ex *param_ex);
 
int __cobalt_thread_getschedparam_ex(struct cobalt_thread *thread,
                                     int *policy_r,
                                     struct sched_param_ex *param_ex);
 
int cobalt_thread_setschedprio(unsigned long pth,
                               int prio,
                               __u32 __user *u_winoff,
                               int __user *u_promoted);
 
struct cobalt_thread *cobalt_thread_find(pid_t pid);
 
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));
 
struct cobalt_thread *
cobalt_thread_shadow(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_DECL(thread_setname,
                    (unsigned long pth, const char __user *u_name));
 
COBALT_SYSCALL_DECL(thread_kill, (unsigned long pth, int sig));
 
COBALT_SYSCALL_DECL(thread_join, (unsigned long pth));
 
COBALT_SYSCALL_DECL(thread_getpid, (unsigned long pth));
 
COBALT_SYSCALL_DECL(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_DECL(thread_getschedparam_ex,
                    (unsigned long pth,
                     int __user *u_policy,
                     struct sched_param_ex __user *u_param));
 
COBALT_SYSCALL_DECL(thread_setschedprio,
                    (unsigned long pth,
                     int prio,
                     __u32 __user *u_winoff,
                     int __user *u_promoted));
 
void cobalt_thread_map(struct xnthread *curr);
 
struct xnthread_personality *cobalt_thread_exit(struct xnthread *curr);
 
struct xnthread_personality *cobalt_thread_finalize(struct xnthread *zombie);
 
#ifdef CONFIG_XENO_OPT_COBALT_EXTENSION
 
int cobalt_thread_extend(struct cobalt_extension *ext,
                         void *priv);
 
void cobalt_thread_restrict(void);
 
static inline
int cobalt_thread_extended_p(const struct cobalt_thread *thread,
                             const struct cobalt_extension *ext)
{
        return thread->extref.extension == ext;
}
 
#else /* !CONFIG_XENO_OPT_COBALT_EXTENSION */
 
static inline
int cobalt_thread_extended_p(const struct cobalt_thread *thread,
                             const struct cobalt_extension *ext)
{
        return 0;
}
 
#endif /* !CONFIG_XENO_OPT_COBALT_EXTENSION */
 
extern xnticks_t cobalt_time_slice;
 
#endif /* !_COBALT_POSIX_THREAD_H */