Skip to content

L
linux
Commit b500a3e3 authored by David S. Miller's avatar David S. Miller
Browse files
Options

[SPARC64]: Use common sys_ipc() compat code. 

No need to duplicate it locally.  This also fixes
several arg sign extension bugs and the subsequent
ltp testsuite failures.
Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parent 7316512c
Show whitespace changes
Inline Side-by-side
Showing with 124 additions and 591 deletions
arch/sparc64/Kconfig
View file @ b500a3e3
...@@ -18,6 +18,11 @@ config TIME_INTERPOLATION ...@@ -18,6 +18,11 @@ config TIME_INTERPOLATION
source "init/Kconfig" source "init/Kconfig"
config SYSVIPC_COMPAT
bool
depends on COMPAT && SYSVIPC
default y
menu "General machine setup" menu "General machine setup"
config BBC_I2C config BBC_I2C
......
arch/sparc64/defconfig
View file @ b500a3e3
# #
# Automatically generated make config: don't edit # Automatically generated make config: don't edit
# Linux kernel version: 2.6.11-rc3 # Linux kernel version: 2.6.11-rc4
# Mon Feb 7 15:29:00 2005 # Thu Feb 17 15:32:19 2005
# #
CONFIG_64BIT=y CONFIG_64BIT=y
CONFIG_MMU=y CONFIG_MMU=y
...@@ -53,6 +53,7 @@ CONFIG_MODVERSIONS=y ...@@ -53,6 +53,7 @@ CONFIG_MODVERSIONS=y
CONFIG_MODULE_SRCVERSION_ALL=y CONFIG_MODULE_SRCVERSION_ALL=y
CONFIG_KMOD=y CONFIG_KMOD=y
CONFIG_STOP_MACHINE=y CONFIG_STOP_MACHINE=y
CONFIG_SYSVIPC_COMPAT=y
# #
# General machine setup # General machine setup
......
arch/sparc64/kernel/sys_sparc32.c
View file @ b500a3e3
...@@ -254,602 +254,70 @@ static inline long put_tv32(struct compat_timeval __user *o, struct timeval *i) ...@@ -254,602 +254,70 @@ static inline long put_tv32(struct compat_timeval __user *o, struct timeval *i)
__put_user(i->tv_usec, &o->tv_usec))); __put_user(i->tv_usec, &o->tv_usec)));
} }
struct msgbuf32 { s32 mtype; char mtext[1]; }; #ifdef CONFIG_SYSVIPC
asmlinkage long compat_sys_ipc(u32 call, u32 first, u32 second, u32 third, compat_uptr_t ptr, u32 fifth)
struct ipc_perm32 {
key_t key;
compat_uid_t uid;
compat_gid_t gid;
compat_uid_t cuid;
compat_gid_t cgid;
compat_mode_t mode;
unsigned short seq;
};
struct semid_ds32 {
struct ipc_perm32 sem_perm; /* permissions .. see ipc.h */
compat_time_t sem_otime; /* last semop time */
compat_time_t sem_ctime; /* last change time */
u32 sem_base; /* ptr to first semaphore in array */
u32 sem_pending; /* pending operations to be processed */
u32 sem_pending_last; /* last pending operation */
u32 undo; /* undo requests on this array */
unsigned short sem_nsems; /* no. of semaphores in array */
};
struct semid64_ds32 {
struct ipc64_perm sem_perm; /* this structure is the same on sparc32 and sparc64 */
unsigned int __pad1;
compat_time_t sem_otime;
unsigned int __pad2;
compat_time_t sem_ctime;
u32 sem_nsems;
u32 __unused1;
u32 __unused2;
};
struct msqid_ds32
{
struct ipc_perm32 msg_perm;
u32 msg_first;
u32 msg_last;
compat_time_t msg_stime;
compat_time_t msg_rtime;
compat_time_t msg_ctime;
u32 wwait;
u32 rwait;
unsigned short msg_cbytes;
unsigned short msg_qnum;
unsigned short msg_qbytes;
compat_ipc_pid_t msg_lspid;
compat_ipc_pid_t msg_lrpid;
};
struct msqid64_ds32 {
struct ipc64_perm msg_perm;
unsigned int __pad1;
compat_time_t msg_stime;
unsigned int __pad2;
compat_time_t msg_rtime;
unsigned int __pad3;
compat_time_t msg_ctime;
unsigned int msg_cbytes;
unsigned int msg_qnum;
unsigned int msg_qbytes;
compat_pid_t msg_lspid;
compat_pid_t msg_lrpid;
unsigned int __unused1;
unsigned int __unused2;
};
struct shmid_ds32 {
struct ipc_perm32 shm_perm;
int shm_segsz;
compat_time_t shm_atime;
compat_time_t shm_dtime;
compat_time_t shm_ctime;
compat_ipc_pid_t shm_cpid;
compat_ipc_pid_t shm_lpid;
unsigned short shm_nattch;
};
struct shmid64_ds32 {
struct ipc64_perm shm_perm;
unsigned int __pad1;
compat_time_t shm_atime;
unsigned int __pad2;
compat_time_t shm_dtime;
unsigned int __pad3;
compat_time_t shm_ctime;
compat_size_t shm_segsz;
compat_pid_t shm_cpid;
compat_pid_t shm_lpid;
unsigned int shm_nattch;
unsigned int __unused1;
unsigned int __unused2;
};
/*
* sys32_ipc() is the de-multiplexer for the SysV IPC calls in 32bit emulation..
*
* This is really horribly ugly.
*/
#define IPCOP_MASK(__x) (1UL << ((__x)&~IPC_64))
static int do_sys32_semctl(int first, int second, int third,
compat_uptr_t __user *uptr)
{
union semun fourth;
compat_uptr_t pad;
int err = -EINVAL;
if (!uptr)
goto out;
err = -EFAULT;
if (get_user(pad, uptr))
goto out;
if ((third & ~IPC_64) == SETVAL)
fourth.val = (int)pad;
else
fourth.__pad = compat_ptr(pad);
if (IPCOP_MASK (third) &
(IPCOP_MASK (IPC_INFO) | IPCOP_MASK (SEM_INFO) | IPCOP_MASK (GETVAL) |
IPCOP_MASK (GETPID) | IPCOP_MASK (GETNCNT) | IPCOP_MASK (GETZCNT) |
IPCOP_MASK (GETALL) | IPCOP_MASK (SETALL) | IPCOP_MASK (IPC_RMID))) {
err = sys_semctl (first, second, third, fourth);
} else if (third & IPC_64) {
struct semid64_ds s;
struct semid64_ds32 __user *usp = compat_ptr(pad);
mm_segment_t old_fs;
int need_back_translation;
if (third == (IPC_SET|IPC_64)) {
err = get_user (s.sem_perm.uid, &usp->sem_perm.uid);
err |= __get_user (s.sem_perm.gid, &usp->sem_perm.gid);
err |= __get_user (s.sem_perm.mode, &usp->sem_perm.mode);
if (err)
goto out;
fourth.__pad = (void __user *) &s;
}
need_back_translation =
(IPCOP_MASK (third) &
(IPCOP_MASK (SEM_STAT) | IPCOP_MASK (IPC_STAT))) != 0;
if (need_back_translation)
fourth.__pad = (void __user *) &s;
old_fs = get_fs ();
set_fs (KERNEL_DS);
err = sys_semctl (first, second, third, fourth);
set_fs (old_fs);
if (need_back_translation) {
int err2 = copy_to_user (&usp->sem_perm, &s.sem_perm, sizeof(struct ipc64_perm) + 2*sizeof(time_t));
err2 |= __put_user (s.sem_nsems, &usp->sem_nsems);
if (err2) err = -EFAULT;
}
} else {
struct semid_ds s;
struct semid_ds32 __user *usp = compat_ptr(pad);
mm_segment_t old_fs;
int need_back_translation;
if (third == IPC_SET) {
err = get_user (s.sem_perm.uid, &usp->sem_perm.uid);
err |= __get_user (s.sem_perm.gid, &usp->sem_perm.gid);
err |= __get_user (s.sem_perm.mode, &usp->sem_perm.mode);
if (err)
goto out;
fourth.__pad = (void __user *) &s;
}
need_back_translation =
(IPCOP_MASK (third) &
(IPCOP_MASK (SEM_STAT) | IPCOP_MASK (IPC_STAT))) != 0;
if (need_back_translation)
fourth.__pad = (void __user *) &s;
old_fs = get_fs ();
set_fs (KERNEL_DS);
err = sys_semctl (first, second, third, fourth);
set_fs (old_fs);
if (need_back_translation) {
int err2 = put_user (s.sem_perm.key, &usp->sem_perm.key);
err2 |= __put_user (high2lowuid(s.sem_perm.uid), &usp->sem_perm.uid);
err2 |= __put_user (high2lowgid(s.sem_perm.gid), &usp->sem_perm.gid);
err2 |= __put_user (high2lowuid(s.sem_perm.cuid), &usp->sem_perm.cuid);
err2 |= __put_user (high2lowgid(s.sem_perm.cgid), &usp->sem_perm.cgid);
err2 |= __put_user (s.sem_perm.mode, &usp->sem_perm.mode);
err2 |= __put_user (s.sem_perm.seq, &usp->sem_perm.seq);
err2 |= __put_user (s.sem_otime, &usp->sem_otime);
err2 |= __put_user (s.sem_ctime, &usp->sem_ctime);
err2 |= __put_user (s.sem_nsems, &usp->sem_nsems);
if (err2) err = -EFAULT;
}
}
out:
return err;
}
static int do_sys32_msgsnd(int first, int second, int third,
void __user *uptr)
{
struct msgbuf32 __user *up = uptr;
struct msgbuf *p;
mm_segment_t old_fs;
int err;
p = kmalloc(second + sizeof (struct msgbuf), GFP_USER);
if (!p)
return -ENOMEM;
err = -EFAULT;
if (get_user (p->mtype, &up->mtype) ||
__copy_from_user (p->mtext, &up->mtext, second))
goto out;
old_fs = get_fs ();
set_fs (KERNEL_DS);
err = sys_msgsnd (first, (struct msgbuf __user *) p,
second, third);
set_fs (old_fs);
out:
kfree (p);
return err;
}
static int do_sys32_msgrcv(int first, int second, int msgtyp, int third,
int version, void __user *uptr)
{
struct msgbuf32 __user *up;
struct msgbuf *p;
mm_segment_t old_fs;
int err;
if (!version) {
struct ipc_kludge __user *uipck = uptr;
struct ipc_kludge ipck;
err = -EINVAL;
if (!uptr)
goto out;
err = -EFAULT;
if (copy_from_user (&ipck, uipck,
sizeof (struct ipc_kludge)))
goto out;
uptr = compat_ptr(ipck.msgp);
msgtyp = ipck.msgtyp;
}
err = -ENOMEM;
p = kmalloc(second + sizeof (struct msgbuf), GFP_USER);
if (!p)
goto out;
old_fs = get_fs ();
set_fs (KERNEL_DS);
err = sys_msgrcv (first, (struct msgbuf __user *) p, second,
msgtyp, third);
set_fs (old_fs);
if (err < 0)
goto free_then_out;
up = uptr;
if (put_user (p->mtype, &up->mtype) ||
__copy_to_user (&up->mtext, p->mtext, err))
err = -EFAULT;
free_then_out:
kfree (p);
out:
return err;
}
static int do_sys32_msgctl(int first, int second, void __user *uptr)
{
int err;
if (IPCOP_MASK (second) &
(IPCOP_MASK (IPC_INFO) | IPCOP_MASK (MSG_INFO) |
IPCOP_MASK (IPC_RMID))) {
err = sys_msgctl (first, second, uptr);
} else if (second & IPC_64) {
struct msqid64_ds m;
struct msqid64_ds32 __user *up = uptr;
mm_segment_t old_fs;
if (second == (IPC_SET|IPC_64)) {
err = get_user (m.msg_perm.uid,
&up->msg_perm.uid);
err |= __get_user (m.msg_perm.gid,
&up->msg_perm.gid);
err |= __get_user (m.msg_perm.mode,
&up->msg_perm.mode);
err |= __get_user (m.msg_qbytes,
&up->msg_qbytes);
if (err)
goto out;
}
old_fs = get_fs ();
set_fs (KERNEL_DS);
err = sys_msgctl(first, second,
(struct msqid_ds __user *)&m);
set_fs (old_fs);
if (IPCOP_MASK (second) &
(IPCOP_MASK (MSG_STAT) | IPCOP_MASK (IPC_STAT))) {
int err2 = copy_to_user(&up->msg_perm,
&m.msg_perm,
(sizeof(struct ipc64_perm) + 3*sizeof(time_t)));
err2 |= __put_user (m.msg_cbytes,
&up->msg_cbytes);
err2 |= __put_user (m.msg_qnum, &up->msg_qnum);
err2 |= __put_user (m.msg_qbytes,
&up->msg_qbytes);
err2 |= __put_user (m.msg_lspid, &up->msg_lspid);
err2 |= __put_user (m.msg_lrpid, &up->msg_lrpid);
if (err2)
err = -EFAULT;
}
} else {
struct msqid_ds m;
struct msqid_ds32 __user *up = uptr;
mm_segment_t old_fs;
if (second == IPC_SET) {
err = get_user(m.msg_perm.uid,
&up->msg_perm.uid);
err |= __get_user(m.msg_perm.gid,
&up->msg_perm.gid);
err |= __get_user(m.msg_perm.mode,
&up->msg_perm.mode);
err |= __get_user(m.msg_qbytes,
&up->msg_qbytes);
if (err)
goto out;
}
old_fs = get_fs ();
set_fs (KERNEL_DS);
err = sys_msgctl(first, second,
(struct msqid_ds __user *) &m);
set_fs (old_fs);
if (IPCOP_MASK (second) &
(IPCOP_MASK (MSG_STAT) | IPCOP_MASK (IPC_STAT))) {
int err2 = put_user(m.msg_perm.key,
&up->msg_perm.key);
err2 |= __put_user(high2lowuid(m.msg_perm.uid),
&up->msg_perm.uid);
err2 |= __put_user(high2lowgid(m.msg_perm.gid),
&up->msg_perm.gid);
err2 |= __put_user(high2lowuid(m.msg_perm.cuid),
&up->msg_perm.cuid);
err2 |= __put_user(high2lowgid(m.msg_perm.cgid),
&up->msg_perm.cgid);
err2 |= __put_user(m.msg_perm.mode,
&up->msg_perm.mode);
err2 |= __put_user(m.msg_perm.seq,
&up->msg_perm.seq);
err2 |= __put_user(m.msg_stime, &up->msg_stime);
err2 |= __put_user(m.msg_rtime, &up->msg_rtime);
err2 |= __put_user(m.msg_ctime, &up->msg_ctime);
err2 |= __put_user(m.msg_cbytes,
&up->msg_cbytes);
err2 |= __put_user(m.msg_qnum, &up->msg_qnum);
err2 |= __put_user(m.msg_qbytes,
&up->msg_qbytes);
err2 |= __put_user(m.msg_lspid, &up->msg_lspid);
err2 |= __put_user(m.msg_lrpid, &up->msg_lrpid);
if (err2)
err = -EFAULT;
}
}
out:
return err;
}
static int do_sys32_shmat (int first, int second, int third, int version, void __user *uptr)
{
unsigned long raddr;
u32 __user *uaddr = compat_ptr((compat_uptr_t)third);
int err = -EINVAL;
if (version == 1)
goto out;
err = do_shmat (first, uptr, second, &raddr);
if (err)
goto out;
err = put_user (raddr, uaddr);
out:
return err;
}
static int do_sys32_shmctl(int first, int second, void __user *uptr)
{
int err;
if (IPCOP_MASK (second) &
(IPCOP_MASK (IPC_INFO) | IPCOP_MASK (SHM_LOCK) |
IPCOP_MASK (SHM_UNLOCK) | IPCOP_MASK (IPC_RMID))) {
if (second == (IPC_INFO|IPC_64)) {
/* So that we don't have to translate it */
second = IPC_INFO;
}
err = sys_shmctl(first, second, uptr);
} else if ((second & IPC_64) && second != (SHM_INFO|IPC_64)) {
struct shmid64_ds s;
struct shmid64_ds32 __user *up = uptr;
mm_segment_t old_fs;
if (second == (IPC_SET|IPC_64)) {
err = get_user(s.shm_perm.uid,
&up->shm_perm.uid);
err |= __get_user(s.shm_perm.gid,
&up->shm_perm.gid);
err |= __get_user(s.shm_perm.mode,
&up->shm_perm.mode);
if (err)
goto out;
}
old_fs = get_fs();
set_fs(KERNEL_DS);
err = sys_shmctl(first, second,
(struct shmid_ds __user *)&s);
set_fs(old_fs);
if (err < 0)
goto out;
/* Mask it even in this case so it becomes a CSE. */
if (IPCOP_MASK (second) &
(IPCOP_MASK (SHM_STAT) | IPCOP_MASK (IPC_STAT))) {
int err2 = copy_to_user(&up->shm_perm,
&s.shm_perm,
sizeof(struct ipc64_perm) + 3*sizeof(time_t));
err2 |= __put_user(s.shm_segsz, &up->shm_segsz);
err2 |= __put_user(s.shm_nattch,&up->shm_nattch);
err2 |= __put_user(s.shm_cpid, &up->shm_cpid);
err2 |= __put_user(s.shm_lpid, &up->shm_lpid);
if (err2)
err = -EFAULT;
}
} else {
struct shmid_ds s;
struct shmid_ds32 __user *up = uptr;
mm_segment_t old_fs;
second &= ~IPC_64;
if (second == IPC_SET) {
err = get_user(s.shm_perm.uid,
&up->shm_perm.uid);
err |= __get_user(s.shm_perm.gid,
&up->shm_perm.gid);
err |= __get_user(s.shm_perm.mode,
&up->shm_perm.mode);
if (err)
goto out;
}
old_fs = get_fs();
set_fs(KERNEL_DS);
err = sys_shmctl(first, second,
(struct shmid_ds __user *) &s);
set_fs(old_fs);
if (err < 0)
goto out;
/* Mask it even in this case so it becomes a CSE. */
if (second == SHM_INFO) {
struct shm_info32 {
int used_ids;
u32 shm_tot, shm_rss, shm_swp;
u32 swap_attempts, swap_successes;
};
struct shm_info32 __user *uip = uptr;
struct shm_info *kp = (struct shm_info *) &s;
int err2 = put_user(kp->used_ids,
&uip->used_ids);
err2 |= __put_user(kp->shm_tot, &uip->shm_tot);
err2 |= __put_user(kp->shm_rss, &uip->shm_rss);
err2 |= __put_user(kp->shm_swp, &uip->shm_swp);
err2 |= __put_user(kp->swap_attempts,
&uip->swap_attempts);
err2 |= __put_user(kp->swap_successes,
&uip->swap_successes);
if (err2)
err = -EFAULT;
} else if (IPCOP_MASK (second) &
(IPCOP_MASK (SHM_STAT) |
IPCOP_MASK (IPC_STAT))) {
int err2;
err2 = put_user(s.shm_perm.key,
&up->shm_perm.key);
err2 |= __put_user(high2lowuid(s.shm_perm.uid),
&up->shm_perm.uid);
err2 |= __put_user(high2lowuid(s.shm_perm.gid),
&up->shm_perm.gid);
err2 |= __put_user(high2lowuid(s.shm_perm.cuid),
&up->shm_perm.cuid);
err2 |= __put_user(high2lowuid(s.shm_perm.cgid),
&up->shm_perm.cgid);
err2 |= __put_user(s.shm_perm.mode,
&up->shm_perm.mode);
err2 |= __put_user(s.shm_perm.seq,
&up->shm_perm.seq);
err2 |= __put_user(s.shm_atime, &up->shm_atime);
err2 |= __put_user(s.shm_dtime, &up->shm_dtime);
err2 |= __put_user(s.shm_ctime, &up->shm_ctime);
err2 |= __put_user(s.shm_segsz, &up->shm_segsz);
err2 |= __put_user(s.shm_nattch,&up->shm_nattch);
err2 |= __put_user(s.shm_cpid, &up->shm_cpid);
err2 |= __put_user(s.shm_lpid, &up->shm_lpid);
if (err2)
err = -EFAULT;
}
}
out:
return err;
}
static int sys32_semtimedop(int semid, struct sembuf __user *tsems,
int nsems,
const struct compat_timespec __user *timeout32)
{ {
struct compat_timespec t32; int version;
struct timespec __user *t64;
t64 = compat_alloc_user_space(sizeof(*t64));
if (copy_from_user(&t32, timeout32, sizeof(t32)))
return -EFAULT;
if (put_user(t32.tv_sec, &t64->tv_sec) ||
put_user(t32.tv_nsec, &t64->tv_nsec))
return -EFAULT;
return sys_semtimedop(semid, tsems, nsems, t64);
}
asmlinkage long compat_sys_ipc(u32 call, int first, int second, int third, compat_uptr_t __ptr, u32 fifth)
{
int version, err;
void __user *ptr = compat_ptr(__ptr);
version = call >> 16; /* hack for backward compatibility */ version = call >> 16; /* hack for backward compatibility */
call &= 0xffff; call &= 0xffff;
if (call <= SEMCTL) {
switch (call) { switch (call) {
case SEMOP:
/* struct sembuf is the same on 32 and 64 :)) */
err = sys_semtimedop (first, ptr, second, NULL);
goto out;
case SEMTIMEDOP: case SEMTIMEDOP:
err = sys32_semtimedop(first, ptr, second, if (third)
compat_ptr(fifth)); /* sign extend semid */
return compat_sys_semtimedop((int)first,
compat_ptr(ptr), second,
compat_ptr(third));
/* else fall through for normal semop() */
case SEMOP:
/* struct sembuf is the same on 32 and 64bit :)) */
/* sign extend semid */
return sys_semtimedop((int)first, compat_ptr(ptr), second,
NULL);
case SEMGET: case SEMGET:
err = sys_semget(first, second, third); /* sign extend key, nsems */
goto out; return sys_semget((int)first, (int)second, third);
case SEMCTL: case SEMCTL:
err = do_sys32_semctl(first, second, third, ptr); /* sign extend semid, semnum */
goto out; return compat_sys_semctl((int)first, (int)second, third,
default: compat_ptr(ptr));
err = -ENOSYS;
goto out;
};
}
if (call <= MSGCTL) {
switch (call) {
case MSGSND: case MSGSND:
err = do_sys32_msgsnd(first, second, third, ptr); /* sign extend msqid */
goto out; return compat_sys_msgsnd((int)first, (int)second, third,
compat_ptr(ptr));
case MSGRCV: case MSGRCV:
err = do_sys32_msgrcv(first, second, fifth, /* sign extend msqid, msgtyp */
third, version, ptr); return compat_sys_msgrcv((int)first, second, (int)fifth,
goto out; third, version, compat_ptr(ptr));
case MSGGET: case MSGGET:
err = sys_msgget((key_t) first, second); /* sign extend key */
goto out; return sys_msgget((int)first, second);
case MSGCTL: case MSGCTL:
err = do_sys32_msgctl(first, second, ptr); /* sign extend msqid */
goto out; return compat_sys_msgctl((int)first, second, compat_ptr(ptr));
default:
err = -ENOSYS;
goto out;
};
}
if (call <= SHMCTL) {
switch (call) {
case SHMAT: case SHMAT:
err = do_sys32_shmat(first, second, third, /* sign extend shmid */
version, ptr); return compat_sys_shmat((int)first, second, third, version,
goto out; compat_ptr(ptr));
case SHMDT: case SHMDT:
err = sys_shmdt(ptr); return sys_shmdt(compat_ptr(ptr));
goto out;
case SHMGET: case SHMGET:
err = sys_shmget(first, (unsigned)second, third); /* sign extend key_t */
goto out; return sys_shmget((int)first, second, third);
case SHMCTL: case SHMCTL:
err = do_sys32_shmctl(first, second, ptr); /* sign extend shmid */
goto out; return compat_sys_shmctl((int)first, second, compat_ptr(ptr));
default: default:
err = -ENOSYS; return -ENOSYS;
goto out;
}; };
}
err = -ENOSYS;
out: return -ENOSYS;
return err;
} }
#endif
asmlinkage long sys32_truncate64(const char __user * path, unsigned long high, unsigned long low) asmlinkage long sys32_truncate64(const char __user * path, unsigned long high, unsigned long low)
{ {
......
include/asm-sparc64/compat.h
View file @ b500a3e3
...@@ -24,6 +24,7 @@ typedef u16 compat_ipc_pid_t; ...@@ -24,6 +24,7 @@ typedef u16 compat_ipc_pid_t;
typedef s32 compat_daddr_t; typedef s32 compat_daddr_t;
typedef u32 compat_caddr_t; typedef u32 compat_caddr_t;
typedef __kernel_fsid_t compat_fsid_t; typedef __kernel_fsid_t compat_fsid_t;
typedef s32 compat_key_t;
typedef s32 compat_int_t; typedef s32 compat_int_t;
typedef s32 compat_long_t; typedef s32 compat_long_t;
...@@ -139,4 +140,62 @@ static __inline__ void __user *compat_alloc_user_space(long len) ...@@ -139,4 +140,62 @@ static __inline__ void __user *compat_alloc_user_space(long len)
return (void __user *) (usp - len); return (void __user *) (usp - len);
} }
struct compat_ipc64_perm {
compat_key_t key;
__kernel_uid_t uid;
__kernel_gid_t gid;
__kernel_uid_t cuid;
__kernel_gid_t cgid;
unsigned short __pad1;
compat_mode_t mode;
unsigned short __pad2;
unsigned short seq;
unsigned long __unused1; /* yes they really are 64bit pads */
unsigned long __unused2;
};
struct compat_semid64_ds {
struct compat_ipc64_perm sem_perm;
unsigned int __pad1;
compat_time_t sem_otime;
unsigned int __pad2;
compat_time_t sem_ctime;
u32 sem_nsems;
u32 __unused1;
u32 __unused2;
};
struct compat_msqid64_ds {
struct compat_ipc64_perm msg_perm;
unsigned int __pad1;
compat_time_t msg_stime;
unsigned int __pad2;
compat_time_t msg_rtime;
unsigned int __pad3;
compat_time_t msg_ctime;
unsigned int msg_cbytes;
unsigned int msg_qnum;
unsigned int msg_qbytes;
compat_pid_t msg_lspid;
compat_pid_t msg_lrpid;
unsigned int __unused1;
unsigned int __unused2;
};
struct compat_shmid64_ds {
struct compat_ipc64_perm shm_perm;
unsigned int __pad1;
compat_time_t shm_atime;
unsigned int __pad2;
compat_time_t shm_dtime;
unsigned int __pad3;
compat_time_t shm_ctime;
compat_size_t shm_segsz;
compat_pid_t shm_cpid;
compat_pid_t shm_lpid;
unsigned int shm_nattch;
unsigned int __unused1;
unsigned int __unused2;
};
#endif /* _ASM_SPARC64_COMPAT_H */ #endif /* _ASM_SPARC64_COMPAT_H */
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7