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