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