arch/sparc64/solaris/misc.c

   1 /* $Id: misc.c,v 1.36 2002/02/09 19:49:31 davem Exp $
   2  * misc.c: Miscellaneous syscall emulation for Solaris
   3  *
   4  * Copyright (C) 1997,1998 Jakub Jelinek (jj@sunsite.mff.cuni.cz)
   5  */
   6
   7 #include <linux/config.h>
   8 #include <linux/module.h>
   9 #include <linux/types.h>
  10 #include <linux/smp_lock.h>
  11 #include <linux/utsname.h>
  12 #include <linux/limits.h>
  13 #include <linux/mm.h>
  14 #include <linux/smp.h>
  15 #include <linux/mman.h>
  16 #include <linux/file.h>
  17 #include <linux/timex.h>
  18 #include <linux/major.h>
  19 #include <linux/compat.h>
  20 #include <linux/vs_cvirt.h>
  21
  22 #include <asm/uaccess.h>
  23 #include <asm/string.h>
  24 #include <asm/oplib.h>
  25 #include <asm/idprom.h>
  26 #include <asm/smp.h>
  27
  28 #include "conv.h"
  29
  30 /* Conversion from Linux to Solaris errnos. 0-34 are identity mapped.
  31    Some Linux errnos (EPROCLIM, EDOTDOT, ERREMOTE, EUCLEAN, ENOTNAM,
  32    ENAVAIL, EISNAM, EREMOTEIO, ENOMEDIUM, EMEDIUMTYPE) have no Solaris
  33    equivalents. I return EINVAL in that case, which is very wrong. If
  34    someone suggest a better value for them, you're welcomed.
  35    On the other side, Solaris ECANCELED and ENOTSUP have no Linux equivalents,
  36    but that doesn't matter here. --jj */
  37 int solaris_err_table[] = {
  38 /* 0 */  0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
  39 /* 10 */  10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
  40 /* 20 */  20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
  41 /* 30 */  30, 31, 32, 33, 34, 22, 150, 149, 95, 96,
  42 /* 40 */  97, 98, 99, 120, 121, 122, 123, 124, 125, 126,
  43 /* 50 */ 127, 128, 129, 130, 131, 132, 133, 134, 143, 144,
  44 /* 60 */ 145, 146, 90, 78, 147, 148, 93, 22, 94, 49,
  45 /* 70 */ 151, 66, 60, 62, 63, 35, 77, 36, 45, 46,
  46 /* 80 */ 64, 22, 67, 68, 69, 70, 71, 74, 22, 82,
  47 /* 90 */ 89, 92, 79, 81, 37, 38, 39, 40, 41, 42,
  48 /* 100 */ 43, 44, 50, 51, 52, 53, 54, 55, 56, 57,
  49 /* 110 */ 87, 61, 84, 65, 83, 80, 91, 22, 22, 22,
  50 /* 120 */ 22, 22, 88, 86, 85, 22, 22,
  51 };
  52
  53 #define SOLARIS_NR_OPEN 256
  54
  55 static u32 do_solaris_mmap(u32 addr, u32 len, u32 prot, u32 flags, u32 fd, u64 off)
  56 {
  57         struct file *file = NULL;
  58         unsigned long retval, ret_type;
  59
  60         /* Do we need it here? */
  61         set_personality(PER_SVR4);
  62         if (flags & MAP_NORESERVE) {
  63                 static int cnt;
  64
  65                 if (cnt < 5) {
  66                         printk("%s:  unimplemented Solaris MAP_NORESERVE mmap() flag\n",
  67                                current->comm);
  68                         cnt++;
  69                 }
  70                 flags &= ~MAP_NORESERVE;
  71         }
  72         retval = -EBADF;
  73         if(!(flags & MAP_ANONYMOUS)) {
  74                 if(fd >= SOLARIS_NR_OPEN)
  75                         goto out;
  76                 file = fget(fd);
  77                 if (!file)
  78                         goto out;
  79                 else {
  80                         struct inode * inode = file->f_dentry->d_inode;
  81                         if(imajor(inode) == MEM_MAJOR &&
  82                            iminor(inode) == 5) {
  83                                 flags |= MAP_ANONYMOUS;
  84                                 fput(file);
  85                                 file = NULL;
  86                         }
  87                 }
  88         }
  89
  90         retval = -EINVAL;
  91         len = PAGE_ALIGN(len);
  92         if(!(flags & MAP_FIXED))
  93                 addr = 0;
  94         else if (len > STACK_TOP32 || addr > STACK_TOP32 - len)
  95                 goto out_putf;
  96         ret_type = flags & _MAP_NEW;
  97         flags &= ~_MAP_NEW;
  98
  99         down_write(&current->mm->mmap_sem);
 100         flags &= ~(MAP_EXECUTABLE | MAP_DENYWRITE);
 101         retval = do_mmap(file,
 102                          (unsigned long) addr, (unsigned long) len,
 103                          (unsigned long) prot, (unsigned long) flags, off);
 104         up_write(&current->mm->mmap_sem);
 105         if(!ret_type)
 106                 retval = ((retval < STACK_TOP32) ? 0 : retval);
 107
 108 out_putf:
 109         if (file)
 110                 fput(file);
 111 out:
 112         return (u32) retval;
 113 }
 114
 115 asmlinkage u32 solaris_mmap(u32 addr, u32 len, u32 prot, u32 flags, u32 fd, u32 off)
 116 {
 117         return do_solaris_mmap(addr, len, prot, flags, fd, (u64) off);
 118 }
 119
 120 asmlinkage u32 solaris_mmap64(struct pt_regs *regs, u32 len, u32 prot, u32 flags, u32 fd, u32 offhi)
 121 {
 122         u32 offlo;
 123
 124         if (regs->u_regs[UREG_G1]) {
 125                 if (get_user (offlo, (u32 __user *)(long)((u32)regs->u_regs[UREG_I6] + 0x5c)))
 126                         return -EFAULT;
 127         } else {
 128                 if (get_user (offlo, (u32 __user *)(long)((u32)regs->u_regs[UREG_I6] + 0x60)))
 129                         return -EFAULT;
 130         }
 131         return do_solaris_mmap((u32)regs->u_regs[UREG_I0], len, prot, flags, fd, (((u64)offhi)<<32)|offlo);
 132 }
 133
 134 asmlinkage int solaris_brk(u32 brk)
 135 {
 136         int (*sunos_brk)(u32) = (int (*)(u32))SUNOS(17);
 137
 138         return sunos_brk(brk);
 139 }
 140
 141 static int __set_utsfield(char __user *to, int to_size,
 142                           const char *from, int from_size,
 143                           int dotchop, int countfrom)
 144 {
 145         int len = countfrom ? (to_size > from_size ?
 146                                from_size : to_size) : to_size;
 147         int off;
 148
 149         if (copy_to_user(to, from, len))
 150                 return -EFAULT;
 151
 152         off = len < to_size? len: len - 1;
 153         if (dotchop) {
 154                 const char *p = strnchr(from, len, '.');
 155                 if (p) off = p - from;
 156         }
 157
 158         if (__put_user('\0', to + off))
 159                 return -EFAULT;
 160
 161         return 0;
 162 }
 163
 164 #define set_utsfield(to, from, dotchop, countfrom) \
 165         __set_utsfield((to), sizeof(to), \
 166                        (from), sizeof(from), \
 167                        (dotchop), (countfrom))
 168
 169 struct sol_uname {
 170         char sysname[9];
 171         char nodename[9];
 172         char release[9];
 173         char version[9];
 174         char machine[9];
 175 };
 176
 177 struct sol_utsname {
 178         char sysname[257];
 179         char nodename[257];
 180         char release[257];
 181         char version[257];
 182         char machine[257];
 183 };
 184
 185 static char *machine(void)
 186 {
 187         switch (sparc_cpu_model) {
 188         case sun4: return "sun4";
 189         case sun4c: return "sun4c";
 190         case sun4e: return "sun4e";
 191         case sun4m: return "sun4m";
 192         case sun4d: return "sun4d";
 193         case sun4u: return "sun4u";
 194         default: return "sparc";
 195         }
 196 }
 197
 198 static char *platform(char *buffer)
 199 {
 200         int len;
 201
 202         *buffer = 0;
 203         len = prom_getproperty(prom_root_node, "name", buffer, 256);
 204         if(len > 0)
 205                 buffer[len] = 0;
 206         if (*buffer) {
 207                 char *p;
 208
 209                 for (p = buffer; *p; p++)
 210                         if (*p == '/' || *p == ' ') *p = '_';
 211                 return buffer;
 212         }
 213
 214         return "sun4u";
 215 }
 216
 217 static char *serial(char *buffer)
 218 {
 219         int node = prom_getchild(prom_root_node);
 220         int len;
 221
 222         node = prom_searchsiblings(node, "options");
 223         *buffer = 0;
 224         len = prom_getproperty(node, "system-board-serial#", buffer, 256);
 225         if(len > 0)
 226                 buffer[len] = 0;
 227         if (!*buffer)
 228                 return "4512348717234";
 229         else
 230                 return buffer;
 231 }
 232
 233 asmlinkage int solaris_utssys(u32 buf, u32 flags, int which, u32 buf2)
 234 {
 235         struct sol_uname __user *v = A(buf);
 236         int err;
 237
 238         switch (which) {
 239         case 0: /* old uname */
 240                 /* Let's cheat */
 241                 err  = set_utsfield(v->sysname, "SunOS", 1, 0);
 242                 down_read(&uts_sem);
 243                 err |= set_utsfield(v->nodename, vx_new_uts(nodename),
 244                                     1, 1);
 245                 up_read(&uts_sem);
 246                 err |= set_utsfield(v->release, "2.6", 0, 0);
 247                 err |= set_utsfield(v->version, "Generic", 0, 0);
 248                 err |= set_utsfield(v->machine, machine(), 0, 0);
 249                 return (err ? -EFAULT : 0);
 250         case 2: /* ustat */
 251                 return -ENOSYS;
 252         case 3: /* fusers */
 253                 return -ENOSYS;
 254         default:
 255                 return -ENOSYS;
 256         }
 257 }
 258
 259 asmlinkage int solaris_utsname(u32 buf)
 260 {
 261         struct sol_utsname __user *v = A(buf);
 262         int err;
 263
 264         /* Why should we not lie a bit? */
 265         down_read(&uts_sem);
 266         err  = set_utsfield(v->sysname, "SunOS", 0, 0);
 267         err |= set_utsfield(v->nodename, vx_new_uts(nodename), 1, 1);
 268         err |= set_utsfield(v->release, "5.6", 0, 0);
 269         err |= set_utsfield(v->version, "Generic", 0, 0);
 270         err |= set_utsfield(v->machine, machine(), 0, 0);
 271         up_read(&uts_sem);
 272
 273         return (err ? -EFAULT : 0);
 274 }
 275
 276 #define SI_SYSNAME              1       /* return name of operating system */
 277 #define SI_HOSTNAME             2       /* return name of node */
 278 #define SI_RELEASE              3       /* return release of operating system */
 279 #define SI_VERSION              4       /* return version field of utsname */
 280 #define SI_MACHINE              5       /* return kind of machine */
 281 #define SI_ARCHITECTURE         6       /* return instruction set arch */
 282 #define SI_HW_SERIAL            7       /* return hardware serial number */
 283 #define SI_HW_PROVIDER          8       /* return hardware manufacturer */
 284 #define SI_SRPC_DOMAIN          9       /* return secure RPC domain */
 285 #define SI_PLATFORM             513     /* return platform identifier */
 286
 287 asmlinkage int solaris_sysinfo(int cmd, u32 buf, s32 count)
 288 {
 289         char *p, *q, *r;
 290         char buffer[256];
 291         int len;
 292
 293         /* Again, we cheat :)) */
 294         switch (cmd) {
 295         case SI_SYSNAME: r = "SunOS"; break;
 296         case SI_HOSTNAME:
 297                 r = buffer + 256;
 298                 down_read(&uts_sem);
 299                 for (p = vx_new_uts(nodename), q = buffer;
 300                      q < r && *p && *p != '.'; *q++ = *p++);
 301                 up_read(&uts_sem);
 302                 *q = 0;
 303                 r = buffer;
 304                 break;
 305         case SI_RELEASE: r = "5.6"; break;
 306         case SI_MACHINE: r = machine(); break;
 307         case SI_ARCHITECTURE: r = "sparc"; break;
 308         case SI_HW_PROVIDER: r = "Sun_Microsystems"; break;
 309         case SI_HW_SERIAL: r = serial(buffer); break;
 310         case SI_PLATFORM: r = platform(buffer); break;
 311         case SI_SRPC_DOMAIN: r = ""; break;
 312         case SI_VERSION: r = "Generic"; break;
 313         default: return -EINVAL;
 314         }
 315         len = strlen(r) + 1;
 316         if (count < len) {
 317                 if (copy_to_user(A(buf), r, count - 1) ||
 318                     __put_user(0, (char __user *)A(buf) + count - 1))
 319                         return -EFAULT;
 320         } else {
 321                 if (copy_to_user(A(buf), r, len))
 322                         return -EFAULT;
 323         }
 324         return len;
 325 }
 326
 327 #define SOLARIS_CONFIG_NGROUPS                  2
 328 #define SOLARIS_CONFIG_CHILD_MAX                3
 329 #define SOLARIS_CONFIG_OPEN_FILES               4
 330 #define SOLARIS_CONFIG_POSIX_VER                5
 331 #define SOLARIS_CONFIG_PAGESIZE                 6
 332 #define SOLARIS_CONFIG_CLK_TCK                  7
 333 #define SOLARIS_CONFIG_XOPEN_VER                8
 334 #define SOLARIS_CONFIG_PROF_TCK                 10
 335 #define SOLARIS_CONFIG_NPROC_CONF               11
 336 #define SOLARIS_CONFIG_NPROC_ONLN               12
 337 #define SOLARIS_CONFIG_AIO_LISTIO_MAX           13
 338 #define SOLARIS_CONFIG_AIO_MAX                  14
 339 #define SOLARIS_CONFIG_AIO_PRIO_DELTA_MAX       15
 340 #define SOLARIS_CONFIG_DELAYTIMER_MAX           16
 341 #define SOLARIS_CONFIG_MQ_OPEN_MAX              17
 342 #define SOLARIS_CONFIG_MQ_PRIO_MAX              18
 343 #define SOLARIS_CONFIG_RTSIG_MAX                19
 344 #define SOLARIS_CONFIG_SEM_NSEMS_MAX            20
 345 #define SOLARIS_CONFIG_SEM_VALUE_MAX            21
 346 #define SOLARIS_CONFIG_SIGQUEUE_MAX             22
 347 #define SOLARIS_CONFIG_SIGRT_MIN                23
 348 #define SOLARIS_CONFIG_SIGRT_MAX                24
 349 #define SOLARIS_CONFIG_TIMER_MAX                25
 350 #define SOLARIS_CONFIG_PHYS_PAGES               26
 351 #define SOLARIS_CONFIG_AVPHYS_PAGES             27
 352
 353 asmlinkage int solaris_sysconf(int id)
 354 {
 355         switch (id) {
 356         case SOLARIS_CONFIG_NGROUPS:    return NGROUPS_MAX;
 357         case SOLARIS_CONFIG_CHILD_MAX:  return -1; /* no limit */
 358         case SOLARIS_CONFIG_OPEN_FILES: return OPEN_MAX;
 359         case SOLARIS_CONFIG_POSIX_VER:  return 199309;
 360         case SOLARIS_CONFIG_PAGESIZE:   return PAGE_SIZE;
 361         case SOLARIS_CONFIG_XOPEN_VER:  return 3;
 362         case SOLARIS_CONFIG_CLK_TCK:
 363         case SOLARIS_CONFIG_PROF_TCK:
 364                 return sparc64_get_clock_tick(smp_processor_id());
 365 #ifdef CONFIG_SMP
 366         case SOLARIS_CONFIG_NPROC_CONF: return NR_CPUS;
 367         case SOLARIS_CONFIG_NPROC_ONLN: return num_online_cpus();
 368 #else
 369         case SOLARIS_CONFIG_NPROC_CONF: return 1;
 370         case SOLARIS_CONFIG_NPROC_ONLN: return 1;
 371 #endif
 372         case SOLARIS_CONFIG_SIGRT_MIN:          return 37;
 373         case SOLARIS_CONFIG_SIGRT_MAX:          return 44;
 374         case SOLARIS_CONFIG_PHYS_PAGES:
 375         case SOLARIS_CONFIG_AVPHYS_PAGES:
 376                 {
 377                         struct sysinfo s;
 378
 379                         si_meminfo(&s);
 380                         if (id == SOLARIS_CONFIG_PHYS_PAGES)
 381                                 return s.totalram >>= PAGE_SHIFT;
 382                         else
 383                                 return s.freeram >>= PAGE_SHIFT;
 384                 }
 385         /* XXX support these as well -jj */
 386         case SOLARIS_CONFIG_AIO_LISTIO_MAX:     return -EINVAL;
 387         case SOLARIS_CONFIG_AIO_MAX:            return -EINVAL;
 388         case SOLARIS_CONFIG_AIO_PRIO_DELTA_MAX: return -EINVAL;
 389         case SOLARIS_CONFIG_DELAYTIMER_MAX:     return -EINVAL;
 390         case SOLARIS_CONFIG_MQ_OPEN_MAX:        return -EINVAL;
 391         case SOLARIS_CONFIG_MQ_PRIO_MAX:        return -EINVAL;
 392         case SOLARIS_CONFIG_RTSIG_MAX:          return -EINVAL;
 393         case SOLARIS_CONFIG_SEM_NSEMS_MAX:      return -EINVAL;
 394         case SOLARIS_CONFIG_SEM_VALUE_MAX:      return -EINVAL;
 395         case SOLARIS_CONFIG_SIGQUEUE_MAX:       return -EINVAL;
 396         case SOLARIS_CONFIG_TIMER_MAX:          return -EINVAL;
 397         default: return -EINVAL;
 398         }
 399 }
 400
 401 asmlinkage int solaris_procids(int cmd, s32 pid, s32 pgid)
 402 {
 403         int ret;
 404
 405         switch (cmd) {
 406         case 0: /* getpgrp */
 407                 return process_group(current);
 408         case 1: /* setpgrp */
 409                 {
 410                         int (*sys_setpgid)(pid_t,pid_t) =
 411                                 (int (*)(pid_t,pid_t))SYS(setpgid);
 412
 413                         /* can anyone explain me the difference between
 414                            Solaris setpgrp and setsid? */
 415                         ret = sys_setpgid(0, 0);
 416                         if (ret) return ret;
 417                         current->signal->tty = NULL;
 418                         return process_group(current);
 419                 }
 420         case 2: /* getsid */
 421                 {
 422                         int (*sys_getsid)(pid_t) = (int (*)(pid_t))SYS(getsid);
 423                         return sys_getsid(pid);
 424                 }
 425         case 3: /* setsid */
 426                 {
 427                         int (*sys_setsid)(void) = (int (*)(void))SYS(setsid);
 428                         return sys_setsid();
 429                 }
 430         case 4: /* getpgid */
 431                 {
 432                         int (*sys_getpgid)(pid_t) = (int (*)(pid_t))SYS(getpgid);
 433                         return sys_getpgid(pid);
 434                 }
 435         case 5: /* setpgid */
 436                 {
 437                         int (*sys_setpgid)(pid_t,pid_t) =
 438                                 (int (*)(pid_t,pid_t))SYS(setpgid);
 439                         return sys_setpgid(pid,pgid);
 440                 }
 441         }
 442         return -EINVAL;
 443 }
 444
 445 asmlinkage int solaris_gettimeofday(u32 tim)
 446 {
 447         int (*sys_gettimeofday)(struct timeval *, struct timezone *) =
 448                 (int (*)(struct timeval *, struct timezone *))SYS(gettimeofday);
 449
 450         return sys_gettimeofday((struct timeval *)(u64)tim, NULL);
 451 }
 452
 453 #define RLIM_SOL_INFINITY32     0x7fffffff
 454 #define RLIM_SOL_SAVED_MAX32    0x7ffffffe
 455 #define RLIM_SOL_SAVED_CUR32    0x7ffffffd
 456 #define RLIM_SOL_INFINITY       ((u64)-3)
 457 #define RLIM_SOL_SAVED_MAX      ((u64)-2)
 458 #define RLIM_SOL_SAVED_CUR      ((u64)-1)
 459 #define RESOURCE32(x) ((x > RLIM_INFINITY32) ? RLIM_INFINITY32 : x)
 460 #define RLIMIT_SOL_NOFILE       5
 461 #define RLIMIT_SOL_VMEM         6
 462
 463 struct rlimit32 {
 464         u32     rlim_cur;
 465         u32     rlim_max;
 466 };
 467
 468 asmlinkage int solaris_getrlimit(unsigned int resource, struct rlimit32 __user *rlim)
 469 {
 470         struct rlimit r;
 471         int ret;
 472         mm_segment_t old_fs = get_fs ();
 473         int (*sys_getrlimit)(unsigned int, struct rlimit *) =
 474                 (int (*)(unsigned int, struct rlimit *))SYS(getrlimit);
 475
 476         if (resource > RLIMIT_SOL_VMEM)
 477                 return -EINVAL;
 478         switch (resource) {
 479         case RLIMIT_SOL_NOFILE: resource = RLIMIT_NOFILE; break;
 480         case RLIMIT_SOL_VMEM: resource = RLIMIT_AS; break;
 481         default: break;
 482         }
 483         set_fs (KERNEL_DS);
 484         ret = sys_getrlimit(resource, &r);
 485         set_fs (old_fs);
 486         if (!ret) {
 487                 if (r.rlim_cur == RLIM_INFINITY)
 488                         r.rlim_cur = RLIM_SOL_INFINITY32;
 489                 else if ((u64)r.rlim_cur > RLIM_SOL_INFINITY32)
 490                         r.rlim_cur = RLIM_SOL_SAVED_CUR32;
 491                 if (r.rlim_max == RLIM_INFINITY)
 492                         r.rlim_max = RLIM_SOL_INFINITY32;
 493                 else if ((u64)r.rlim_max > RLIM_SOL_INFINITY32)
 494                         r.rlim_max = RLIM_SOL_SAVED_MAX32;
 495                 ret = put_user (r.rlim_cur, &rlim->rlim_cur);
 496                 ret |= __put_user (r.rlim_max, &rlim->rlim_max);
 497         }
 498         return ret;
 499 }
 500
 501 asmlinkage int solaris_setrlimit(unsigned int resource, struct rlimit32 __user *rlim)
 502 {
 503         struct rlimit r, rold;
 504         int ret;
 505         mm_segment_t old_fs = get_fs ();
 506         int (*sys_getrlimit)(unsigned int, struct rlimit __user *) =
 507                 (int (*)(unsigned int, struct rlimit __user *))SYS(getrlimit);
 508         int (*sys_setrlimit)(unsigned int, struct rlimit __user *) =
 509                 (int (*)(unsigned int, struct rlimit __user *))SYS(setrlimit);
 510
 511         if (resource > RLIMIT_SOL_VMEM)
 512                 return -EINVAL;
 513         switch (resource) {
 514         case RLIMIT_SOL_NOFILE: resource = RLIMIT_NOFILE; break;
 515         case RLIMIT_SOL_VMEM: resource = RLIMIT_AS; break;
 516         default: break;
 517         }
 518         if (get_user (r.rlim_cur, &rlim->rlim_cur) ||
 519             __get_user (r.rlim_max, &rlim->rlim_max))
 520                 return -EFAULT;
 521         set_fs (KERNEL_DS);
 522         ret = sys_getrlimit(resource, &rold);
 523         if (!ret) {
 524                 if (r.rlim_cur == RLIM_SOL_INFINITY32)
 525                         r.rlim_cur = RLIM_INFINITY;
 526                 else if (r.rlim_cur == RLIM_SOL_SAVED_CUR32)
 527                         r.rlim_cur = rold.rlim_cur;
 528                 else if (r.rlim_cur == RLIM_SOL_SAVED_MAX32)
 529                         r.rlim_cur = rold.rlim_max;
 530                 if (r.rlim_max == RLIM_SOL_INFINITY32)
 531                         r.rlim_max = RLIM_INFINITY;
 532                 else if (r.rlim_max == RLIM_SOL_SAVED_CUR32)
 533                         r.rlim_max = rold.rlim_cur;
 534                 else if (r.rlim_max == RLIM_SOL_SAVED_MAX32)
 535                         r.rlim_max = rold.rlim_max;
 536                 ret = sys_setrlimit(resource, &r);
 537         }
 538         set_fs (old_fs);
 539         return ret;
 540 }
 541
 542 asmlinkage int solaris_getrlimit64(unsigned int resource, struct rlimit __user *rlim)
 543 {
 544         struct rlimit r;
 545         int ret;
 546         mm_segment_t old_fs = get_fs ();
 547         int (*sys_getrlimit)(unsigned int, struct rlimit __user *) =
 548                 (int (*)(unsigned int, struct rlimit __user *))SYS(getrlimit);
 549
 550         if (resource > RLIMIT_SOL_VMEM)
 551                 return -EINVAL;
 552         switch (resource) {
 553         case RLIMIT_SOL_NOFILE: resource = RLIMIT_NOFILE; break;
 554         case RLIMIT_SOL_VMEM: resource = RLIMIT_AS; break;
 555         default: break;
 556         }
 557         set_fs (KERNEL_DS);
 558         ret = sys_getrlimit(resource, &r);
 559         set_fs (old_fs);
 560         if (!ret) {
 561                 if (r.rlim_cur == RLIM_INFINITY)
 562                         r.rlim_cur = RLIM_SOL_INFINITY;
 563                 if (r.rlim_max == RLIM_INFINITY)
 564                         r.rlim_max = RLIM_SOL_INFINITY;
 565                 ret = put_user (r.rlim_cur, &rlim->rlim_cur);
 566                 ret |= __put_user (r.rlim_max, &rlim->rlim_max);
 567         }
 568         return ret;
 569 }
 570
 571 asmlinkage int solaris_setrlimit64(unsigned int resource, struct rlimit __user *rlim)
 572 {
 573         struct rlimit r, rold;
 574         int ret;
 575         mm_segment_t old_fs = get_fs ();
 576         int (*sys_getrlimit)(unsigned int, struct rlimit __user *) =
 577                 (int (*)(unsigned int, struct rlimit __user *))SYS(getrlimit);
 578         int (*sys_setrlimit)(unsigned int, struct rlimit __user *) =
 579                 (int (*)(unsigned int, struct rlimit __user *))SYS(setrlimit);
 580
 581         if (resource > RLIMIT_SOL_VMEM)
 582                 return -EINVAL;
 583         switch (resource) {
 584         case RLIMIT_SOL_NOFILE: resource = RLIMIT_NOFILE; break;
 585         case RLIMIT_SOL_VMEM: resource = RLIMIT_AS; break;
 586         default: break;
 587         }
 588         if (get_user (r.rlim_cur, &rlim->rlim_cur) ||
 589             __get_user (r.rlim_max, &rlim->rlim_max))
 590                 return -EFAULT;
 591         set_fs (KERNEL_DS);
 592         ret = sys_getrlimit(resource, &rold);
 593         if (!ret) {
 594                 if (r.rlim_cur == RLIM_SOL_INFINITY)
 595                         r.rlim_cur = RLIM_INFINITY;
 596                 else if (r.rlim_cur == RLIM_SOL_SAVED_CUR)
 597                         r.rlim_cur = rold.rlim_cur;
 598                 else if (r.rlim_cur == RLIM_SOL_SAVED_MAX)
 599                         r.rlim_cur = rold.rlim_max;
 600                 if (r.rlim_max == RLIM_SOL_INFINITY)
 601                         r.rlim_max = RLIM_INFINITY;
 602                 else if (r.rlim_max == RLIM_SOL_SAVED_CUR)
 603                         r.rlim_max = rold.rlim_cur;
 604                 else if (r.rlim_max == RLIM_SOL_SAVED_MAX)
 605                         r.rlim_max = rold.rlim_max;
 606                 ret = sys_setrlimit(resource, &r);
 607         }
 608         set_fs (old_fs);
 609         return ret;
 610 }
 611
 612 struct sol_ntptimeval {
 613         struct compat_timeval time;
 614         s32 maxerror;
 615         s32 esterror;
 616 };
 617
 618 struct sol_timex {
 619         u32 modes;
 620         s32 offset;
 621         s32 freq;
 622         s32 maxerror;
 623         s32 esterror;
 624         s32 status;
 625         s32 constant;
 626         s32 precision;
 627         s32 tolerance;
 628         s32 ppsfreq;
 629         s32 jitter;
 630         s32 shift;
 631         s32 stabil;
 632         s32 jitcnt;
 633         s32 calcnt;
 634         s32 errcnt;
 635         s32 stbcnt;
 636 };
 637
 638 asmlinkage int solaris_ntp_gettime(struct sol_ntptimeval __user *ntp)
 639 {
 640         int (*sys_adjtimex)(struct timex __user *) =
 641                 (int (*)(struct timex __user *))SYS(adjtimex);
 642         struct timex t;
 643         int ret;
 644         mm_segment_t old_fs = get_fs();
 645
 646         set_fs(KERNEL_DS);
 647         t.modes = 0;
 648         ret = sys_adjtimex(&t);
 649         set_fs(old_fs);
 650         if (ret < 0)
 651                 return ret;
 652         ret = put_user (t.time.tv_sec, &ntp->time.tv_sec);
 653         ret |= __put_user (t.time.tv_usec, &ntp->time.tv_usec);
 654         ret |= __put_user (t.maxerror, &ntp->maxerror);
 655         ret |= __put_user (t.esterror, &ntp->esterror);
 656         return ret;
 657 }
 658
 659 asmlinkage int solaris_ntp_adjtime(struct sol_timex __user *txp)
 660 {
 661         int (*sys_adjtimex)(struct timex __user *) =
 662                 (int (*)(struct timex __user *))SYS(adjtimex);
 663         struct timex t;
 664         int ret, err;
 665         mm_segment_t old_fs = get_fs();
 666
 667         ret = get_user (t.modes, &txp->modes);
 668         ret |= __get_user (t.offset, &txp->offset);
 669         ret |= __get_user (t.freq, &txp->freq);
 670         ret |= __get_user (t.maxerror, &txp->maxerror);
 671         ret |= __get_user (t.esterror, &txp->esterror);
 672         ret |= __get_user (t.status, &txp->status);
 673         ret |= __get_user (t.constant, &txp->constant);
 674         set_fs(KERNEL_DS);
 675         ret = sys_adjtimex(&t);
 676         set_fs(old_fs);
 677         if (ret < 0)
 678                 return ret;
 679         err = put_user (t.offset, &txp->offset);
 680         err |= __put_user (t.freq, &txp->freq);
 681         err |= __put_user (t.maxerror, &txp->maxerror);
 682         err |= __put_user (t.esterror, &txp->esterror);
 683         err |= __put_user (t.status, &txp->status);
 684         err |= __put_user (t.constant, &txp->constant);
 685         err |= __put_user (t.precision, &txp->precision);
 686         err |= __put_user (t.tolerance, &txp->tolerance);
 687         err |= __put_user (t.ppsfreq, &txp->ppsfreq);
 688         err |= __put_user (t.jitter, &txp->jitter);
 689         err |= __put_user (t.shift, &txp->shift);
 690         err |= __put_user (t.stabil, &txp->stabil);
 691         err |= __put_user (t.jitcnt, &txp->jitcnt);
 692         err |= __put_user (t.calcnt, &txp->calcnt);
 693         err |= __put_user (t.errcnt, &txp->errcnt);
 694         err |= __put_user (t.stbcnt, &txp->stbcnt);
 695         if (err)
 696                 return -EFAULT;
 697         return ret;
 698 }
 699
 700 asmlinkage int do_sol_unimplemented(struct pt_regs *regs)
 701 {
 702         printk ("Unimplemented Solaris syscall %d %08x %08x %08x %08x\n",
 703                         (int)regs->u_regs[UREG_G1],
 704                         (int)regs->u_regs[UREG_I0],
 705                         (int)regs->u_regs[UREG_I1],
 706                         (int)regs->u_regs[UREG_I2],
 707                         (int)regs->u_regs[UREG_I3]);
 708         return -ENOSYS;
 709 }
 710
 711 asmlinkage void solaris_register(void)
 712 {
 713         set_personality(PER_SVR4);
 714 }
 715
 716 extern long solaris_to_linux_signals[], linux_to_solaris_signals[];
 717
 718 struct exec_domain solaris_exec_domain = {
 719         .name =         "Solaris",
 720         .handler =      NULL,
 721         .pers_low =     1,              /* PER_SVR4 personality */
 722         .pers_high =    1,
 723         .signal_map =   solaris_to_linux_signals,
 724         .signal_invmap =linux_to_solaris_signals,
 725         .module =       THIS_MODULE,
 726         .next =         NULL
 727 };
 728
 729 extern int init_socksys(void);
 730
 731 #ifdef MODULE
 732
 733 MODULE_AUTHOR("Jakub Jelinek (jj@ultra.linux.cz), Patrik Rak (prak3264@ss1000.ms.mff.cuni.cz)");
 734 MODULE_DESCRIPTION("Solaris binary emulation module");
 735 MODULE_LICENSE("GPL");
 736
 737 #ifdef __sparc_v9__
 738 extern u32 tl0_solaris[8];
 739 #define update_ttable(x)                                                                                \
 740         tl0_solaris[3] = (((long)(x) - (long)tl0_solaris - 3) >> 2) | 0x40000000;                       \
 741         wmb();          \
 742         __asm__ __volatile__ ("flush %0" : : "r" (&tl0_solaris[3]))
 743 #else
 744 #endif
 745
 746 extern u32 solaris_sparc_syscall[];
 747 extern u32 solaris_syscall[];
 748 extern void cleanup_socksys(void);
 749
 750 extern u32 entry64_personality_patch;
 751
 752 int init_module(void)
 753 {
 754         int ret;
 755
 756         SOLDD(("Solaris module at %p\n", solaris_sparc_syscall));
 757         register_exec_domain(&solaris_exec_domain);
 758         if ((ret = init_socksys())) {
 759                 unregister_exec_domain(&solaris_exec_domain);
 760                 return ret;
 761         }
 762         update_ttable(solaris_sparc_syscall);
 763         entry64_personality_patch |=
 764                 (offsetof(struct task_struct, personality) +
 765                  (sizeof(unsigned long) - 1));
 766         wmb();
 767         __asm__ __volatile__("flush %0"
 768                              : : "r" (&entry64_personality_patch));
 769         return 0;
 770 }
 771
 772 void cleanup_module(void)
 773 {
 774         update_ttable(solaris_syscall);
 775         cleanup_socksys();
 776         unregister_exec_domain(&solaris_exec_domain);
 777 }
 778
 779 #else
 780 int init_solaris_emul(void)
 781 {
 782         register_exec_domain(&solaris_exec_domain);
 783         init_socksys();
 784         return 0;
 785 }
 786 #endif
 787