1 /* $Id: misc.c,v 1.36 2002/02/09 19:49:31 davem Exp $
2 * misc.c: Miscellaneous syscall emulation for Solaris
4 * Copyright (C) 1997,1998 Jakub Jelinek (jj@sunsite.mff.cuni.cz)
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>
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>
22 #include <asm/uaccess.h>
23 #include <asm/string.h>
24 #include <asm/oplib.h>
25 #include <asm/idprom.h>
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,
54 #define SOLARIS_NR_OPEN 256
56 static u32 do_solaris_mmap(u32 addr, u32 len, u32 prot, u32 flags, u32 fd, u64 off)
58 struct file *file = NULL;
59 unsigned long retval, ret_type;
61 /* Do we need it here? */
62 set_personality(PER_SVR4);
63 if (flags & MAP_NORESERVE) {
67 printk("%s: unimplemented Solaris MAP_NORESERVE mmap() flag\n",
71 flags &= ~MAP_NORESERVE;
74 if(!(flags & MAP_ANONYMOUS)) {
75 if(fd >= SOLARIS_NR_OPEN)
81 struct inode * inode = file->f_dentry->d_inode;
82 if(imajor(inode) == MEM_MAJOR &&
84 flags |= MAP_ANONYMOUS;
92 len = PAGE_ALIGN(len);
93 if(!(flags & MAP_FIXED))
95 else if (len > STACK_TOP32 || addr > STACK_TOP32 - len)
97 ret_type = flags & _MAP_NEW;
100 down_write(¤t->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(¤t->mm->mmap_sem);
107 retval = ((retval < STACK_TOP32) ? 0 : retval);
116 asmlinkage u32 solaris_mmap(u32 addr, u32 len, u32 prot, u32 flags, u32 fd, u32 off)
118 return do_solaris_mmap(addr, len, prot, flags, fd, (u64) off);
121 asmlinkage u32 solaris_mmap64(struct pt_regs *regs, u32 len, u32 prot, u32 flags, u32 fd, u32 offhi)
125 if (regs->u_regs[UREG_G1]) {
126 if (get_user (offlo, (u32 __user *)(long)((u32)regs->u_regs[UREG_I6] + 0x5c)))
129 if (get_user (offlo, (u32 __user *)(long)((u32)regs->u_regs[UREG_I6] + 0x60)))
132 return do_solaris_mmap((u32)regs->u_regs[UREG_I0], len, prot, flags, fd, (((u64)offhi)<<32)|offlo);
135 asmlinkage int solaris_brk(u32 brk)
137 int (*sunos_brk)(u32) = (int (*)(u32))SUNOS(17);
139 return sunos_brk(brk);
142 static int __set_utsfield(char __user *to, int to_size,
143 const char *from, int from_size,
144 int dotchop, int countfrom)
146 int len = countfrom ? (to_size > from_size ?
147 from_size : to_size) : to_size;
150 if (copy_to_user(to, from, len))
153 off = len < to_size? len: len - 1;
155 const char *p = strnchr(from, len, '.');
156 if (p) off = p - from;
159 if (__put_user('\0', to + off))
165 #define set_utsfield(to, from, dotchop, countfrom) \
166 __set_utsfield((to), sizeof(to), \
167 (from), sizeof(from), \
168 (dotchop), (countfrom))
186 static char *machine(void)
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";
199 static char *platform(char *buffer, int sz)
201 struct device_node *dp = of_find_node_by_path("/");
205 len = strlen(dp->name);
208 memcpy(buffer, dp->name, len);
213 for (p = buffer; *p; p++)
214 if (*p == '/' || *p == ' ') *p = '_';
221 static char *serial(char *buffer, int sz)
223 struct device_node *dp = of_find_node_by_path("/options");
228 char *val = of_get_property(dp, "system-board-serial#", &len);
230 if (val && len > 0) {
233 memcpy(buffer, val, len);
238 return "4512348717234";
243 asmlinkage int solaris_utssys(u32 buf, u32 flags, int which, u32 buf2)
245 struct sol_uname __user *v = A(buf);
249 case 0: /* old uname */
251 err = set_utsfield(v->sysname, "SunOS", 1, 0);
253 err |= set_utsfield(v->nodename, vx_new_uts(nodename),
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);
269 asmlinkage int solaris_utsname(u32 buf)
271 struct sol_utsname __user *v = A(buf);
274 /* Why should we not lie a bit? */
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);
283 return (err ? -EFAULT : 0);
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 */
297 asmlinkage int solaris_sysinfo(int cmd, u32 buf, s32 count)
303 /* Again, we cheat :)) */
305 case SI_SYSNAME: r = "SunOS"; break;
309 for (p = vx_new_uts(nodename), q = buffer;
310 q < r && *p && *p != '.'; *q++ = *p++);
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;
327 if (copy_to_user(A(buf), r, count - 1) ||
328 __put_user(0, (char __user *)A(buf) + count - 1))
331 if (copy_to_user(A(buf), r, len))
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
363 asmlinkage int solaris_sysconf(int 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());
376 case SOLARIS_CONFIG_NPROC_CONF: return NR_CPUS;
377 case SOLARIS_CONFIG_NPROC_ONLN: return num_online_cpus();
379 case SOLARIS_CONFIG_NPROC_CONF: return 1;
380 case SOLARIS_CONFIG_NPROC_ONLN: return 1;
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:
390 if (id == SOLARIS_CONFIG_PHYS_PAGES)
391 return s.totalram >>= PAGE_SHIFT;
393 return s.freeram >>= PAGE_SHIFT;
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;
411 asmlinkage int solaris_procids(int cmd, s32 pid, s32 pgid)
416 case 0: /* getpgrp */
417 return process_group(current);
418 case 1: /* setpgrp */
420 int (*sys_setpgid)(pid_t,pid_t) =
421 (int (*)(pid_t,pid_t))SYS(setpgid);
423 /* can anyone explain me the difference between
424 Solaris setpgrp and setsid? */
425 ret = sys_setpgid(0, 0);
427 proc_clear_tty(current);
428 return process_group(current);
432 int (*sys_getsid)(pid_t) = (int (*)(pid_t))SYS(getsid);
433 return sys_getsid(pid);
437 int (*sys_setsid)(void) = (int (*)(void))SYS(setsid);
440 case 4: /* getpgid */
442 int (*sys_getpgid)(pid_t) = (int (*)(pid_t))SYS(getpgid);
443 return sys_getpgid(pid);
445 case 5: /* setpgid */
447 int (*sys_setpgid)(pid_t,pid_t) =
448 (int (*)(pid_t,pid_t))SYS(setpgid);
449 return sys_setpgid(pid,pgid);
455 asmlinkage int solaris_gettimeofday(u32 tim)
457 int (*sys_gettimeofday)(struct timeval *, struct timezone *) =
458 (int (*)(struct timeval *, struct timezone *))SYS(gettimeofday);
460 return sys_gettimeofday((struct timeval *)(u64)tim, NULL);
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
478 asmlinkage int solaris_getrlimit(unsigned int resource, struct rlimit32 __user *rlim)
482 mm_segment_t old_fs = get_fs ();
483 int (*sys_getrlimit)(unsigned int, struct rlimit *) =
484 (int (*)(unsigned int, struct rlimit *))SYS(getrlimit);
486 if (resource > RLIMIT_SOL_VMEM)
489 case RLIMIT_SOL_NOFILE: resource = RLIMIT_NOFILE; break;
490 case RLIMIT_SOL_VMEM: resource = RLIMIT_AS; break;
494 ret = sys_getrlimit(resource, &r);
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);
511 asmlinkage int solaris_setrlimit(unsigned int resource, struct rlimit32 __user *rlim)
513 struct rlimit r, rold;
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);
521 if (resource > RLIMIT_SOL_VMEM)
524 case RLIMIT_SOL_NOFILE: resource = RLIMIT_NOFILE; break;
525 case RLIMIT_SOL_VMEM: resource = RLIMIT_AS; break;
528 if (get_user (r.rlim_cur, &rlim->rlim_cur) ||
529 __get_user (r.rlim_max, &rlim->rlim_max))
532 ret = sys_getrlimit(resource, &rold);
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);
552 asmlinkage int solaris_getrlimit64(unsigned int resource, struct rlimit __user *rlim)
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);
560 if (resource > RLIMIT_SOL_VMEM)
563 case RLIMIT_SOL_NOFILE: resource = RLIMIT_NOFILE; break;
564 case RLIMIT_SOL_VMEM: resource = RLIMIT_AS; break;
568 ret = sys_getrlimit(resource, &r);
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);
581 asmlinkage int solaris_setrlimit64(unsigned int resource, struct rlimit __user *rlim)
583 struct rlimit r, rold;
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);
591 if (resource > RLIMIT_SOL_VMEM)
594 case RLIMIT_SOL_NOFILE: resource = RLIMIT_NOFILE; break;
595 case RLIMIT_SOL_VMEM: resource = RLIMIT_AS; break;
598 if (get_user (r.rlim_cur, &rlim->rlim_cur) ||
599 __get_user (r.rlim_max, &rlim->rlim_max))
602 ret = sys_getrlimit(resource, &rold);
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);
622 struct sol_ntptimeval {
623 struct compat_timeval time;
648 asmlinkage int solaris_ntp_gettime(struct sol_ntptimeval __user *ntp)
650 int (*sys_adjtimex)(struct timex __user *) =
651 (int (*)(struct timex __user *))SYS(adjtimex);
654 mm_segment_t old_fs = get_fs();
658 ret = sys_adjtimex(&t);
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);
669 asmlinkage int solaris_ntp_adjtime(struct sol_timex __user *txp)
671 int (*sys_adjtimex)(struct timex __user *) =
672 (int (*)(struct timex __user *))SYS(adjtimex);
675 mm_segment_t old_fs = get_fs();
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);
685 ret = sys_adjtimex(&t);
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);
710 asmlinkage int do_sol_unimplemented(struct pt_regs *regs)
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]);
721 asmlinkage void solaris_register(void)
723 set_personality(PER_SVR4);
726 extern long solaris_to_linux_signals[], linux_to_solaris_signals[];
728 struct exec_domain solaris_exec_domain = {
731 .pers_low = 1, /* PER_SVR4 personality */
733 .signal_map = solaris_to_linux_signals,
734 .signal_invmap =linux_to_solaris_signals,
735 .module = THIS_MODULE,
739 extern int init_socksys(void);
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");
748 extern u32 tl0_solaris[8];
749 #define update_ttable(x) \
750 tl0_solaris[3] = (((long)(x) - (long)tl0_solaris - 3) >> 2) | 0x40000000; \
752 __asm__ __volatile__ ("flush %0" : : "r" (&tl0_solaris[3]))
756 extern u32 solaris_sparc_syscall[];
757 extern u32 solaris_syscall[];
758 extern void cleanup_socksys(void);
760 extern u32 entry64_personality_patch;
762 int init_module(void)
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);
772 update_ttable(solaris_sparc_syscall);
773 entry64_personality_patch |=
774 (offsetof(struct task_struct, personality) +
775 (sizeof(unsigned long) - 1));
777 __asm__ __volatile__("flush %0"
778 : : "r" (&entry64_personality_patch));
782 void cleanup_module(void)
784 update_ttable(solaris_syscall);
786 unregister_exec_domain(&solaris_exec_domain);
790 int init_solaris_emul(void)
792 register_exec_domain(&solaris_exec_domain);