linux/arch/arm/kernel/sys_oabi-compat.c
<<
>>
Prefs
   1/*
   2 *  arch/arm/kernel/sys_oabi-compat.c
   3 *
   4 *  Compatibility wrappers for syscalls that are used from
   5 *  old ABI user space binaries with an EABI kernel.
   6 *
   7 *  Author:     Nicolas Pitre
   8 *  Created:    Oct 7, 2005
   9 *  Copyright:  MontaVista Software, Inc.
  10 *
  11 *  This program is free software; you can redistribute it and/or modify
  12 *  it under the terms of the GNU General Public License version 2 as
  13 *  published by the Free Software Foundation.
  14 */
  15
  16/*
  17 * The legacy ABI and the new ARM EABI have different rules making some
  18 * syscalls incompatible especially with structure arguments.
  19 * Most notably, Eabi says 64-bit members should be 64-bit aligned instead of
  20 * simply word aligned.  EABI also pads structures to the size of the largest
  21 * member it contains instead of the invariant 32-bit.
  22 *
  23 * The following syscalls are affected:
  24 *
  25 * sys_stat64:
  26 * sys_lstat64:
  27 * sys_fstat64:
  28 * sys_fstatat64:
  29 *
  30 *   struct stat64 has different sizes and some members are shifted
  31 *   Compatibility wrappers are needed for them and provided below.
  32 *
  33 * sys_fcntl64:
  34 *
  35 *   struct flock64 has different sizes and some members are shifted
  36 *   A compatibility wrapper is needed and provided below.
  37 *
  38 * sys_statfs64:
  39 * sys_fstatfs64:
  40 *
  41 *   struct statfs64 has extra padding with EABI growing its size from
  42 *   84 to 88.  This struct is now __attribute__((packed,aligned(4)))
  43 *   with a small assembly wrapper to force the sz argument to 84 if it is 88
  44 *   to avoid copying the extra padding over user space unexpecting it.
  45 *
  46 * sys_newuname:
  47 *
  48 *   struct new_utsname has no padding with EABI.  No problem there.
  49 *
  50 * sys_epoll_ctl:
  51 * sys_epoll_wait:
  52 *
  53 *   struct epoll_event has its second member shifted also affecting the
  54 *   structure size. Compatibility wrappers are needed and provided below.
  55 *
  56 * sys_ipc:
  57 * sys_semop:
  58 * sys_semtimedop:
  59 *
  60 *   struct sembuf loses its padding with EABI.  Since arrays of them are
  61 *   used they have to be copyed to remove the padding. Compatibility wrappers
  62 *   provided below.
  63 *
  64 * sys_bind:
  65 * sys_connect:
  66 * sys_sendmsg:
  67 * sys_sendto:
  68 * sys_socketcall:
  69 *
  70 *   struct sockaddr_un loses its padding with EABI.  Since the size of the
  71 *   structure is used as a validation test in unix_mkname(), we need to
  72 *   change the length argument to 110 whenever it is 112.  Compatibility
  73 *   wrappers provided below.
  74 */
  75
  76#include <linux/syscalls.h>
  77#include <linux/errno.h>
  78#include <linux/fs.h>
  79#include <linux/fcntl.h>
  80#include <linux/eventpoll.h>
  81#include <linux/sem.h>
  82#include <linux/socket.h>
  83#include <linux/net.h>
  84#include <linux/ipc.h>
  85#include <linux/uaccess.h>
  86#include <linux/slab.h>
  87
  88struct oldabi_stat64 {
  89        unsigned long long st_dev;
  90        unsigned int    __pad1;
  91        unsigned long   __st_ino;
  92        unsigned int    st_mode;
  93        unsigned int    st_nlink;
  94
  95        unsigned long   st_uid;
  96        unsigned long   st_gid;
  97
  98        unsigned long long st_rdev;
  99        unsigned int    __pad2;
 100
 101        long long       st_size;
 102        unsigned long   st_blksize;
 103        unsigned long long st_blocks;
 104
 105        unsigned long   st_atime;
 106        unsigned long   st_atime_nsec;
 107
 108        unsigned long   st_mtime;
 109        unsigned long   st_mtime_nsec;
 110
 111        unsigned long   st_ctime;
 112        unsigned long   st_ctime_nsec;
 113
 114        unsigned long long st_ino;
 115} __attribute__ ((packed,aligned(4)));
 116
 117static long cp_oldabi_stat64(struct kstat *stat,
 118                             struct oldabi_stat64 __user *statbuf)
 119{
 120        struct oldabi_stat64 tmp;
 121
 122        tmp.st_dev = huge_encode_dev(stat->dev);
 123        tmp.__pad1 = 0;
 124        tmp.__st_ino = stat->ino;
 125        tmp.st_mode = stat->mode;
 126        tmp.st_nlink = stat->nlink;
 127        tmp.st_uid = from_kuid_munged(current_user_ns(), stat->uid);
 128        tmp.st_gid = from_kgid_munged(current_user_ns(), stat->gid);
 129        tmp.st_rdev = huge_encode_dev(stat->rdev);
 130        tmp.st_size = stat->size;
 131        tmp.st_blocks = stat->blocks;
 132        tmp.__pad2 = 0;
 133        tmp.st_blksize = stat->blksize;
 134        tmp.st_atime = stat->atime.tv_sec;
 135        tmp.st_atime_nsec = stat->atime.tv_nsec;
 136        tmp.st_mtime = stat->mtime.tv_sec;
 137        tmp.st_mtime_nsec = stat->mtime.tv_nsec;
 138        tmp.st_ctime = stat->ctime.tv_sec;
 139        tmp.st_ctime_nsec = stat->ctime.tv_nsec;
 140        tmp.st_ino = stat->ino;
 141        return copy_to_user(statbuf,&tmp,sizeof(tmp)) ? -EFAULT : 0;
 142}
 143
 144asmlinkage long sys_oabi_stat64(const char __user * filename,
 145                                struct oldabi_stat64 __user * statbuf)
 146{
 147        struct kstat stat;
 148        int error = vfs_stat(filename, &stat);
 149        if (!error)
 150                error = cp_oldabi_stat64(&stat, statbuf);
 151        return error;
 152}
 153
 154asmlinkage long sys_oabi_lstat64(const char __user * filename,
 155                                 struct oldabi_stat64 __user * statbuf)
 156{
 157        struct kstat stat;
 158        int error = vfs_lstat(filename, &stat);
 159        if (!error)
 160                error = cp_oldabi_stat64(&stat, statbuf);
 161        return error;
 162}
 163
 164asmlinkage long sys_oabi_fstat64(unsigned long fd,
 165                                 struct oldabi_stat64 __user * statbuf)
 166{
 167        struct kstat stat;
 168        int error = vfs_fstat(fd, &stat);
 169        if (!error)
 170                error = cp_oldabi_stat64(&stat, statbuf);
 171        return error;
 172}
 173
 174asmlinkage long sys_oabi_fstatat64(int dfd,
 175                                   const char __user *filename,
 176                                   struct oldabi_stat64  __user *statbuf,
 177                                   int flag)
 178{
 179        struct kstat stat;
 180        int error;
 181
 182        error = vfs_fstatat(dfd, filename, &stat, flag);
 183        if (error)
 184                return error;
 185        return cp_oldabi_stat64(&stat, statbuf);
 186}
 187
 188struct oabi_flock64 {
 189        short   l_type;
 190        short   l_whence;
 191        loff_t  l_start;
 192        loff_t  l_len;
 193        pid_t   l_pid;
 194} __attribute__ ((packed,aligned(4)));
 195
 196asmlinkage long sys_oabi_fcntl64(unsigned int fd, unsigned int cmd,
 197                                 unsigned long arg)
 198{
 199        struct oabi_flock64 user;
 200        struct flock64 kernel;
 201        mm_segment_t fs = USER_DS; /* initialized to kill a warning */
 202        unsigned long local_arg = arg;
 203        int ret;
 204
 205        switch (cmd) {
 206        case F_OFD_GETLK:
 207        case F_OFD_SETLK:
 208        case F_OFD_SETLKW:
 209        case F_GETLK64:
 210        case F_SETLK64:
 211        case F_SETLKW64:
 212                if (copy_from_user(&user, (struct oabi_flock64 __user *)arg,
 213                                   sizeof(user)))
 214                        return -EFAULT;
 215                kernel.l_type   = user.l_type;
 216                kernel.l_whence = user.l_whence;
 217                kernel.l_start  = user.l_start;
 218                kernel.l_len    = user.l_len;
 219                kernel.l_pid    = user.l_pid;
 220                local_arg = (unsigned long)&kernel;
 221                fs = get_fs();
 222                set_fs(KERNEL_DS);
 223        }
 224
 225        ret = sys_fcntl64(fd, cmd, local_arg);
 226
 227        switch (cmd) {
 228        case F_GETLK64:
 229                if (!ret) {
 230                        user.l_type     = kernel.l_type;
 231                        user.l_whence   = kernel.l_whence;
 232                        user.l_start    = kernel.l_start;
 233                        user.l_len      = kernel.l_len;
 234                        user.l_pid      = kernel.l_pid;
 235                        if (copy_to_user((struct oabi_flock64 __user *)arg,
 236                                         &user, sizeof(user)))
 237                                ret = -EFAULT;
 238                }
 239        case F_SETLK64:
 240        case F_SETLKW64:
 241                set_fs(fs);
 242        }
 243
 244        return ret;
 245}
 246
 247struct oabi_epoll_event {
 248        __u32 events;
 249        __u64 data;
 250} __attribute__ ((packed,aligned(4)));
 251
 252asmlinkage long sys_oabi_epoll_ctl(int epfd, int op, int fd,
 253                                   struct oabi_epoll_event __user *event)
 254{
 255        struct oabi_epoll_event user;
 256        struct epoll_event kernel;
 257        mm_segment_t fs;
 258        long ret;
 259
 260        if (op == EPOLL_CTL_DEL)
 261                return sys_epoll_ctl(epfd, op, fd, NULL);
 262        if (copy_from_user(&user, event, sizeof(user)))
 263                return -EFAULT;
 264        kernel.events = user.events;
 265        kernel.data   = user.data;
 266        fs = get_fs();
 267        set_fs(KERNEL_DS);
 268        ret = sys_epoll_ctl(epfd, op, fd, &kernel);
 269        set_fs(fs);
 270        return ret;
 271}
 272
 273asmlinkage long sys_oabi_epoll_wait(int epfd,
 274                                    struct oabi_epoll_event __user *events,
 275                                    int maxevents, int timeout)
 276{
 277        struct epoll_event *kbuf;
 278        mm_segment_t fs;
 279        long ret, err, i;
 280
 281        if (maxevents <= 0 || maxevents > (INT_MAX/sizeof(struct epoll_event)))
 282                return -EINVAL;
 283        kbuf = kmalloc(sizeof(*kbuf) * maxevents, GFP_KERNEL);
 284        if (!kbuf)
 285                return -ENOMEM;
 286        fs = get_fs();
 287        set_fs(KERNEL_DS);
 288        ret = sys_epoll_wait(epfd, kbuf, maxevents, timeout);
 289        set_fs(fs);
 290        err = 0;
 291        for (i = 0; i < ret; i++) {
 292                __put_user_error(kbuf[i].events, &events->events, err);
 293                __put_user_error(kbuf[i].data,   &events->data,   err);
 294                events++;
 295        }
 296        kfree(kbuf);
 297        return err ? -EFAULT : ret;
 298}
 299
 300struct oabi_sembuf {
 301        unsigned short  sem_num;
 302        short           sem_op;
 303        short           sem_flg;
 304        unsigned short  __pad;
 305};
 306
 307asmlinkage long sys_oabi_semtimedop(int semid,
 308                                    struct oabi_sembuf __user *tsops,
 309                                    unsigned nsops,
 310                                    const struct timespec __user *timeout)
 311{
 312        struct sembuf *sops;
 313        struct timespec local_timeout;
 314        long err;
 315        int i;
 316
 317        if (nsops < 1 || nsops > SEMOPM)
 318                return -EINVAL;
 319        sops = kmalloc(sizeof(*sops) * nsops, GFP_KERNEL);
 320        if (!sops)
 321                return -ENOMEM;
 322        err = 0;
 323        for (i = 0; i < nsops; i++) {
 324                __get_user_error(sops[i].sem_num, &tsops->sem_num, err);
 325                __get_user_error(sops[i].sem_op,  &tsops->sem_op,  err);
 326                __get_user_error(sops[i].sem_flg, &tsops->sem_flg, err);
 327                tsops++;
 328        }
 329        if (timeout) {
 330                /* copy this as well before changing domain protection */
 331                err |= copy_from_user(&local_timeout, timeout, sizeof(*timeout));
 332                timeout = &local_timeout;
 333        }
 334        if (err) {
 335                err = -EFAULT;
 336        } else {
 337                mm_segment_t fs = get_fs();
 338                set_fs(KERNEL_DS);
 339                err = sys_semtimedop(semid, sops, nsops, timeout);
 340                set_fs(fs);
 341        }
 342        kfree(sops);
 343        return err;
 344}
 345
 346asmlinkage long sys_oabi_semop(int semid, struct oabi_sembuf __user *tsops,
 347                               unsigned nsops)
 348{
 349        return sys_oabi_semtimedop(semid, tsops, nsops, NULL);
 350}
 351
 352asmlinkage int sys_oabi_ipc(uint call, int first, int second, int third,
 353                            void __user *ptr, long fifth)
 354{
 355        switch (call & 0xffff) {
 356        case SEMOP:
 357                return  sys_oabi_semtimedop(first,
 358                                            (struct oabi_sembuf __user *)ptr,
 359                                            second, NULL);
 360        case SEMTIMEDOP:
 361                return  sys_oabi_semtimedop(first,
 362                                            (struct oabi_sembuf __user *)ptr,
 363                                            second,
 364                                            (const struct timespec __user *)fifth);
 365        default:
 366                return sys_ipc(call, first, second, third, ptr, fifth);
 367        }
 368}
 369
 370asmlinkage long sys_oabi_bind(int fd, struct sockaddr __user *addr, int addrlen)
 371{
 372        sa_family_t sa_family;
 373        if (addrlen == 112 &&
 374            get_user(sa_family, &addr->sa_family) == 0 &&
 375            sa_family == AF_UNIX)
 376                        addrlen = 110;
 377        return sys_bind(fd, addr, addrlen);
 378}
 379
 380asmlinkage long sys_oabi_connect(int fd, struct sockaddr __user *addr, int addrlen)
 381{
 382        sa_family_t sa_family;
 383        if (addrlen == 112 &&
 384            get_user(sa_family, &addr->sa_family) == 0 &&
 385            sa_family == AF_UNIX)
 386                        addrlen = 110;
 387        return sys_connect(fd, addr, addrlen);
 388}
 389
 390asmlinkage long sys_oabi_sendto(int fd, void __user *buff,
 391                                size_t len, unsigned flags,
 392                                struct sockaddr __user *addr,
 393                                int addrlen)
 394{
 395        sa_family_t sa_family;
 396        if (addrlen == 112 &&
 397            get_user(sa_family, &addr->sa_family) == 0 &&
 398            sa_family == AF_UNIX)
 399                        addrlen = 110;
 400        return sys_sendto(fd, buff, len, flags, addr, addrlen);
 401}
 402
 403asmlinkage long sys_oabi_sendmsg(int fd, struct user_msghdr __user *msg, unsigned flags)
 404{
 405        struct sockaddr __user *addr;
 406        int msg_namelen;
 407        sa_family_t sa_family;
 408        if (msg &&
 409            get_user(msg_namelen, &msg->msg_namelen) == 0 &&
 410            msg_namelen == 112 &&
 411            get_user(addr, &msg->msg_name) == 0 &&
 412            get_user(sa_family, &addr->sa_family) == 0 &&
 413            sa_family == AF_UNIX)
 414        {
 415                /*
 416                 * HACK ALERT: there is a limit to how much backward bending
 417                 * we should do for what is actually a transitional
 418                 * compatibility layer.  This already has known flaws with
 419                 * a few ioctls that we don't intend to fix.  Therefore
 420                 * consider this blatent hack as another one... and take care
 421                 * to run for cover.  In most cases it will "just work fine".
 422                 * If it doesn't, well, tough.
 423                 */
 424                put_user(110, &msg->msg_namelen);
 425        }
 426        return sys_sendmsg(fd, msg, flags);
 427}
 428
 429asmlinkage long sys_oabi_socketcall(int call, unsigned long __user *args)
 430{
 431        unsigned long r = -EFAULT, a[6];
 432
 433        switch (call) {
 434        case SYS_BIND:
 435                if (copy_from_user(a, args, 3 * sizeof(long)) == 0)
 436                        r = sys_oabi_bind(a[0], (struct sockaddr __user *)a[1], a[2]);
 437                break;
 438        case SYS_CONNECT:
 439                if (copy_from_user(a, args, 3 * sizeof(long)) == 0)
 440                        r = sys_oabi_connect(a[0], (struct sockaddr __user *)a[1], a[2]);
 441                break;
 442        case SYS_SENDTO:
 443                if (copy_from_user(a, args, 6 * sizeof(long)) == 0)
 444                        r = sys_oabi_sendto(a[0], (void __user *)a[1], a[2], a[3],
 445                                            (struct sockaddr __user *)a[4], a[5]);
 446                break;
 447        case SYS_SENDMSG:
 448                if (copy_from_user(a, args, 3 * sizeof(long)) == 0)
 449                        r = sys_oabi_sendmsg(a[0], (struct user_msghdr __user *)a[1], a[2]);
 450                break;
 451        default:
 452                r = sys_socketcall(call, args);
 453        }
 454
 455        return r;
 456}
 457