projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
[SPARC64]: constify of_get_property return: arch/sparc64
[deliverable/linux.git] / arch / sparc64 / solaris / misc.c
CommitLineData
1da177e4
LT		 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
1da177e4
LT		 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>
de2a84f2 14#include <linux/tty.h>
1da177e4
LT		 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>
25c7581b 26#include <asm/prom.h>
1da177e4
LT		 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 */
37int 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
55static 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 {
1250ca4c 80 struct inode * inode = file->f_path.dentry->d_inode;
1da177e4
LT		 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;
d61e16df 94 else if (len > STACK_TOP32 || addr > STACK_TOP32 - len)
1da177e4
LT		 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)
d61e16df 106 retval = ((retval < STACK_TOP32) ? 0 : retval);
1da177e4
LT		 107
108out_putf:
109 if (file)
110 fput(file);
111out:
112 return (u32) retval;
113}
114
115asmlinkage 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
120asmlinkage 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
134asmlinkage int solaris_brk(u32 brk)
135{
136 int (*sunos_brk)(u32) = (int (*)(u32))SUNOS(17);
137
138 return sunos_brk(brk);
139}
140
141static 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
169struct sol_uname {
170 char sysname[9];
171 char nodename[9];
172 char release[9];
173 char version[9];
174 char machine[9];
175};
176
177struct sol_utsname {
178 char sysname[257];
179 char nodename[257];
180 char release[257];
181 char version[257];
182 char machine[257];
183};
184
185static 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
25c7581b 198static char *platform(char *buffer, int sz)
1da177e4 199{
25c7581b 200 struct device_node *dp = of_find_node_by_path("/");
1da177e4
LT		 201 int len;
202
203 *buffer = 0;
25c7581b
DM		 204 len = strlen(dp->name);
205 if (len > sz)
206 len = sz;
207 memcpy(buffer, dp->name, len);
208 buffer[len] = 0;
1da177e4
LT		 209 if (*buffer) {
210 char *p;
211
212 for (p = buffer; *p; p++)
213 if (*p == '/' || *p == ' ') *p = '_';
214 return buffer;
215 }
216
217 return "sun4u";
218}
219
25c7581b 220static char *serial(char *buffer, int sz)
1da177e4 221{
25c7581b 222 struct device_node *dp = of_find_node_by_path("/options");
1da177e4
LT		 223 int len;
224
1da177e4 225 *buffer = 0;
25c7581b 226 if (dp) {
6a23acf3
SR		 227 const char *val =
228 of_get_property(dp, "system-board-serial#", &len);
25c7581b
DM		 229
230 if (val && len > 0) {
231 if (len > sz)
232 len = sz;
233 memcpy(buffer, val, len);
234 buffer[len] = 0;
235 }
236 }
1da177e4
LT		 237 if (!*buffer)
238 return "4512348717234";
239 else
240 return buffer;
241}
242
243asmlinkage 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);
e9ff3990 253 err |= set_utsfield(v->nodename, utsname()->nodename,
1da177e4
LT		 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
269asmlinkage 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);
e9ff3990 277 err |= set_utsfield(v->nodename, utsname()->nodename, 1, 1);
1da177e4
LT		 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
297asmlinkage 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);
e9ff3990 309 for (p = utsname()->nodename, q = buffer;
1da177e4
LT		 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;
25c7581b
DM		 319 case SI_HW_SERIAL: r = serial(buffer, sizeof(buffer)); break;
320 case SI_PLATFORM: r = platform(buffer, sizeof(buffer)); break;
1da177e4
LT		 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
363asmlinkage int solaris_sysconf(int id)
364{
365 switch (id) {
366 case SOLARIS_CONFIG_NGROUPS: return NGROUPS_MAX;
1d51c69f
RM		 367 case SOLARIS_CONFIG_CHILD_MAX:
368 return current->signal->rlim[RLIMIT_NPROC].rlim_cur;
369 case SOLARIS_CONFIG_OPEN_FILES:
370 return current->signal->rlim[RLIMIT_NOFILE].rlim_cur;
1da177e4
LT		 371 case SOLARIS_CONFIG_POSIX_VER: return 199309;
372 case SOLARIS_CONFIG_PAGESIZE: return PAGE_SIZE;
373 case SOLARIS_CONFIG_XOPEN_VER: return 3;
374 case SOLARIS_CONFIG_CLK_TCK:
375 case SOLARIS_CONFIG_PROF_TCK:
376 return sparc64_get_clock_tick(smp_processor_id());
377#ifdef CONFIG_SMP
378 case SOLARIS_CONFIG_NPROC_CONF: return NR_CPUS;
379 case SOLARIS_CONFIG_NPROC_ONLN: return num_online_cpus();
380#else
381 case SOLARIS_CONFIG_NPROC_CONF: return 1;
382 case SOLARIS_CONFIG_NPROC_ONLN: return 1;
383#endif
384 case SOLARIS_CONFIG_SIGRT_MIN: return 37;
385 case SOLARIS_CONFIG_SIGRT_MAX: return 44;
386 case SOLARIS_CONFIG_PHYS_PAGES:
387 case SOLARIS_CONFIG_AVPHYS_PAGES:
388 {
389 struct sysinfo s;
390
391 si_meminfo(&s);
392 if (id == SOLARIS_CONFIG_PHYS_PAGES)
393 return s.totalram >>= PAGE_SHIFT;
394 else
395 return s.freeram >>= PAGE_SHIFT;
396 }
397 /* XXX support these as well -jj */
398 case SOLARIS_CONFIG_AIO_LISTIO_MAX: return -EINVAL;
399 case SOLARIS_CONFIG_AIO_MAX: return -EINVAL;
400 case SOLARIS_CONFIG_AIO_PRIO_DELTA_MAX: return -EINVAL;
401 case SOLARIS_CONFIG_DELAYTIMER_MAX: return -EINVAL;
402 case SOLARIS_CONFIG_MQ_OPEN_MAX: return -EINVAL;
403 case SOLARIS_CONFIG_MQ_PRIO_MAX: return -EINVAL;
404 case SOLARIS_CONFIG_RTSIG_MAX: return -EINVAL;
405 case SOLARIS_CONFIG_SEM_NSEMS_MAX: return -EINVAL;
406 case SOLARIS_CONFIG_SEM_VALUE_MAX: return -EINVAL;
407 case SOLARIS_CONFIG_SIGQUEUE_MAX: return -EINVAL;
408 case SOLARIS_CONFIG_TIMER_MAX: return -EINVAL;
409 default: return -EINVAL;
410 }
411}
412
413asmlinkage int solaris_procids(int cmd, s32 pid, s32 pgid)
414{
415 int ret;
416
417 switch (cmd) {
418 case 0: /* getpgrp */
419 return process_group(current);
420 case 1: /* setpgrp */
421 {
422 int (*sys_setpgid)(pid_t,pid_t) =
423 (int (*)(pid_t,pid_t))SYS(setpgid);
424
425 /* can anyone explain me the difference between
426 Solaris setpgrp and setsid? */
427 ret = sys_setpgid(0, 0);
428 if (ret) return ret;
24ec839c 429 proc_clear_tty(current);
1da177e4
LT		 430 return process_group(current);
431 }
432 case 2: /* getsid */
433 {
434 int (*sys_getsid)(pid_t) = (int (*)(pid_t))SYS(getsid);
435 return sys_getsid(pid);
436 }
437 case 3: /* setsid */
438 {
439 int (*sys_setsid)(void) = (int (*)(void))SYS(setsid);
440 return sys_setsid();
441 }
442 case 4: /* getpgid */
443 {
444 int (*sys_getpgid)(pid_t) = (int (*)(pid_t))SYS(getpgid);
445 return sys_getpgid(pid);
446 }
447 case 5: /* setpgid */
448 {
449 int (*sys_setpgid)(pid_t,pid_t) =
450 (int (*)(pid_t,pid_t))SYS(setpgid);
451 return sys_setpgid(pid,pgid);
452 }
453 }
454 return -EINVAL;
455}
456
457asmlinkage int solaris_gettimeofday(u32 tim)
458{
459 int (*sys_gettimeofday)(struct timeval *, struct timezone *) =
460 (int (*)(struct timeval *, struct timezone *))SYS(gettimeofday);
461
462 return sys_gettimeofday((struct timeval *)(u64)tim, NULL);
463}
464
465#define RLIM_SOL_INFINITY32 0x7fffffff
466#define RLIM_SOL_SAVED_MAX32 0x7ffffffe
467#define RLIM_SOL_SAVED_CUR32 0x7ffffffd
468#define RLIM_SOL_INFINITY ((u64)-3)
469#define RLIM_SOL_SAVED_MAX ((u64)-2)
470#define RLIM_SOL_SAVED_CUR ((u64)-1)
471#define RESOURCE32(x) ((x > RLIM_INFINITY32) ? RLIM_INFINITY32 : x)
472#define RLIMIT_SOL_NOFILE 5
473#define RLIMIT_SOL_VMEM 6
474
475struct rlimit32 {
476 u32 rlim_cur;
477 u32 rlim_max;
478};
479
480asmlinkage int solaris_getrlimit(unsigned int resource, struct rlimit32 __user *rlim)
481{
482 struct rlimit r;
483 int ret;
484 mm_segment_t old_fs = get_fs ();
485 int (*sys_getrlimit)(unsigned int, struct rlimit *) =
486 (int (*)(unsigned int, struct rlimit *))SYS(getrlimit);
487
488 if (resource > RLIMIT_SOL_VMEM)
489 return -EINVAL;
490 switch (resource) {
491 case RLIMIT_SOL_NOFILE: resource = RLIMIT_NOFILE; break;
492 case RLIMIT_SOL_VMEM: resource = RLIMIT_AS; break;
493 default: break;
494 }
495 set_fs (KERNEL_DS);
496 ret = sys_getrlimit(resource, &r);
497 set_fs (old_fs);
498 if (!ret) {
499 if (r.rlim_cur == RLIM_INFINITY)
500 r.rlim_cur = RLIM_SOL_INFINITY32;
501 else if ((u64)r.rlim_cur > RLIM_SOL_INFINITY32)
502 r.rlim_cur = RLIM_SOL_SAVED_CUR32;
503 if (r.rlim_max == RLIM_INFINITY)
504 r.rlim_max = RLIM_SOL_INFINITY32;
505 else if ((u64)r.rlim_max > RLIM_SOL_INFINITY32)
506 r.rlim_max = RLIM_SOL_SAVED_MAX32;
507 ret = put_user (r.rlim_cur, &rlim->rlim_cur);
508 ret |= __put_user (r.rlim_max, &rlim->rlim_max);
509 }
510 return ret;
511}
512
513asmlinkage int solaris_setrlimit(unsigned int resource, struct rlimit32 __user *rlim)
514{
515 struct rlimit r, rold;
516 int ret;
517 mm_segment_t old_fs = get_fs ();
518 int (*sys_getrlimit)(unsigned int, struct rlimit __user *) =
519 (int (*)(unsigned int, struct rlimit __user *))SYS(getrlimit);
520 int (*sys_setrlimit)(unsigned int, struct rlimit __user *) =
521 (int (*)(unsigned int, struct rlimit __user *))SYS(setrlimit);
522
523 if (resource > RLIMIT_SOL_VMEM)
524 return -EINVAL;
525 switch (resource) {
526 case RLIMIT_SOL_NOFILE: resource = RLIMIT_NOFILE; break;
527 case RLIMIT_SOL_VMEM: resource = RLIMIT_AS; break;
528 default: break;
529 }
530 if (get_user (r.rlim_cur, &rlim->rlim_cur) ||
531 __get_user (r.rlim_max, &rlim->rlim_max))
532 return -EFAULT;
533 set_fs (KERNEL_DS);
534 ret = sys_getrlimit(resource, &rold);
535 if (!ret) {
536 if (r.rlim_cur == RLIM_SOL_INFINITY32)
537 r.rlim_cur = RLIM_INFINITY;
538 else if (r.rlim_cur == RLIM_SOL_SAVED_CUR32)
539 r.rlim_cur = rold.rlim_cur;
540 else if (r.rlim_cur == RLIM_SOL_SAVED_MAX32)
541 r.rlim_cur = rold.rlim_max;
542 if (r.rlim_max == RLIM_SOL_INFINITY32)
543 r.rlim_max = RLIM_INFINITY;
544 else if (r.rlim_max == RLIM_SOL_SAVED_CUR32)
545 r.rlim_max = rold.rlim_cur;
546 else if (r.rlim_max == RLIM_SOL_SAVED_MAX32)
547 r.rlim_max = rold.rlim_max;
548 ret = sys_setrlimit(resource, &r);
549 }
550 set_fs (old_fs);
551 return ret;
552}
553
554asmlinkage int solaris_getrlimit64(unsigned int resource, struct rlimit __user *rlim)
555{
556 struct rlimit r;
557 int ret;
558 mm_segment_t old_fs = get_fs ();
559 int (*sys_getrlimit)(unsigned int, struct rlimit __user *) =
560 (int (*)(unsigned int, struct rlimit __user *))SYS(getrlimit);
561
562 if (resource > RLIMIT_SOL_VMEM)
563 return -EINVAL;
564 switch (resource) {
565 case RLIMIT_SOL_NOFILE: resource = RLIMIT_NOFILE; break;
566 case RLIMIT_SOL_VMEM: resource = RLIMIT_AS; break;
567 default: break;
568 }
569 set_fs (KERNEL_DS);
570 ret = sys_getrlimit(resource, &r);
571 set_fs (old_fs);
572 if (!ret) {
573 if (r.rlim_cur == RLIM_INFINITY)
574 r.rlim_cur = RLIM_SOL_INFINITY;
575 if (r.rlim_max == RLIM_INFINITY)
576 r.rlim_max = RLIM_SOL_INFINITY;
577 ret = put_user (r.rlim_cur, &rlim->rlim_cur);
578 ret |= __put_user (r.rlim_max, &rlim->rlim_max);
579 }
580 return ret;
581}
582
583asmlinkage int solaris_setrlimit64(unsigned int resource, struct rlimit __user *rlim)
584{
585 struct rlimit r, rold;
586 int ret;
587 mm_segment_t old_fs = get_fs ();
588 int (*sys_getrlimit)(unsigned int, struct rlimit __user *) =
589 (int (*)(unsigned int, struct rlimit __user *))SYS(getrlimit);
590 int (*sys_setrlimit)(unsigned int, struct rlimit __user *) =
591 (int (*)(unsigned int, struct rlimit __user *))SYS(setrlimit);
592
593 if (resource > RLIMIT_SOL_VMEM)
594 return -EINVAL;
595 switch (resource) {
596 case RLIMIT_SOL_NOFILE: resource = RLIMIT_NOFILE; break;
597 case RLIMIT_SOL_VMEM: resource = RLIMIT_AS; break;
598 default: break;
599 }
600 if (get_user (r.rlim_cur, &rlim->rlim_cur) ||
601 __get_user (r.rlim_max, &rlim->rlim_max))
602 return -EFAULT;
603 set_fs (KERNEL_DS);
604 ret = sys_getrlimit(resource, &rold);
605 if (!ret) {
606 if (r.rlim_cur == RLIM_SOL_INFINITY)
607 r.rlim_cur = RLIM_INFINITY;
608 else if (r.rlim_cur == RLIM_SOL_SAVED_CUR)
609 r.rlim_cur = rold.rlim_cur;
610 else if (r.rlim_cur == RLIM_SOL_SAVED_MAX)
611 r.rlim_cur = rold.rlim_max;
612 if (r.rlim_max == RLIM_SOL_INFINITY)
613 r.rlim_max = RLIM_INFINITY;
614 else if (r.rlim_max == RLIM_SOL_SAVED_CUR)
615 r.rlim_max = rold.rlim_cur;
616 else if (r.rlim_max == RLIM_SOL_SAVED_MAX)
617 r.rlim_max = rold.rlim_max;
618 ret = sys_setrlimit(resource, &r);
619 }
620 set_fs (old_fs);
621 return ret;
622}
623
624struct sol_ntptimeval {
625 struct compat_timeval time;
626 s32 maxerror;
627 s32 esterror;
628};
629
630struct sol_timex {
631 u32 modes;
632 s32 offset;
633 s32 freq;
634 s32 maxerror;
635 s32 esterror;
636 s32 status;
637 s32 constant;
638 s32 precision;
639 s32 tolerance;
640 s32 ppsfreq;
641 s32 jitter;
642 s32 shift;
643 s32 stabil;
644 s32 jitcnt;
645 s32 calcnt;
646 s32 errcnt;
647 s32 stbcnt;
648};
649
650asmlinkage int solaris_ntp_gettime(struct sol_ntptimeval __user *ntp)
651{
652 int (*sys_adjtimex)(struct timex __user *) =
653 (int (*)(struct timex __user *))SYS(adjtimex);
654 struct timex t;
655 int ret;
656 mm_segment_t old_fs = get_fs();
657
658 set_fs(KERNEL_DS);
659 t.modes = 0;
660 ret = sys_adjtimex(&t);
661 set_fs(old_fs);
662 if (ret < 0)
663 return ret;
664 ret = put_user (t.time.tv_sec, &ntp->time.tv_sec);
665 ret |= __put_user (t.time.tv_usec, &ntp->time.tv_usec);
666 ret |= __put_user (t.maxerror, &ntp->maxerror);
667 ret |= __put_user (t.esterror, &ntp->esterror);
668 return ret;
669}
670
671asmlinkage int solaris_ntp_adjtime(struct sol_timex __user *txp)
672{
673 int (*sys_adjtimex)(struct timex __user *) =
674 (int (*)(struct timex __user *))SYS(adjtimex);
675 struct timex t;
676 int ret, err;
677 mm_segment_t old_fs = get_fs();
678
679 ret = get_user (t.modes, &txp->modes);
680 ret |= __get_user (t.offset, &txp->offset);
681 ret |= __get_user (t.freq, &txp->freq);
682 ret |= __get_user (t.maxerror, &txp->maxerror);
683 ret |= __get_user (t.esterror, &txp->esterror);
684 ret |= __get_user (t.status, &txp->status);
685 ret |= __get_user (t.constant, &txp->constant);
686 set_fs(KERNEL_DS);
687 ret = sys_adjtimex(&t);
688 set_fs(old_fs);
689 if (ret < 0)
690 return ret;
691 err = put_user (t.offset, &txp->offset);
692 err |= __put_user (t.freq, &txp->freq);
693 err |= __put_user (t.maxerror, &txp->maxerror);
694 err |= __put_user (t.esterror, &txp->esterror);
695 err |= __put_user (t.status, &txp->status);
696 err |= __put_user (t.constant, &txp->constant);
697 err |= __put_user (t.precision, &txp->precision);
698 err |= __put_user (t.tolerance, &txp->tolerance);
699 err |= __put_user (t.ppsfreq, &txp->ppsfreq);
700 err |= __put_user (t.jitter, &txp->jitter);
701 err |= __put_user (t.shift, &txp->shift);
702 err |= __put_user (t.stabil, &txp->stabil);
703 err |= __put_user (t.jitcnt, &txp->jitcnt);
704 err |= __put_user (t.calcnt, &txp->calcnt);
705 err |= __put_user (t.errcnt, &txp->errcnt);
706 err |= __put_user (t.stbcnt, &txp->stbcnt);
707 if (err)
708 return -EFAULT;
709 return ret;
710}
711
712asmlinkage int do_sol_unimplemented(struct pt_regs *regs)
713{
714 printk ("Unimplemented Solaris syscall %d %08x %08x %08x %08x\n",
715 (int)regs->u_regs[UREG_G1],
716 (int)regs->u_regs[UREG_I0],
717 (int)regs->u_regs[UREG_I1],
718 (int)regs->u_regs[UREG_I2],
719 (int)regs->u_regs[UREG_I3]);
720 return -ENOSYS;
721}
722
723asmlinkage void solaris_register(void)
724{
725 set_personality(PER_SVR4);
726}
727
728extern long solaris_to_linux_signals[], linux_to_solaris_signals[];
729
730struct exec_domain solaris_exec_domain = {
731 .name = "Solaris",
732 .handler = NULL,
733 .pers_low = 1, /* PER_SVR4 personality */
734 .pers_high = 1,
735 .signal_map = solaris_to_linux_signals,
736 .signal_invmap =linux_to_solaris_signals,
737 .module = THIS_MODULE,
738 .next = NULL
739};
740
741extern int init_socksys(void);
742
1da177e4
LT		 743MODULE_AUTHOR("Jakub Jelinek (jj@ultra.linux.cz), Patrik Rak (prak3264@ss1000.ms.mff.cuni.cz)");
744MODULE_DESCRIPTION("Solaris binary emulation module");
745MODULE_LICENSE("GPL");
746
1da177e4
LT		 747extern u32 tl0_solaris[8];
748#define update_ttable(x) \
749 tl0_solaris[3] = (((long)(x) - (long)tl0_solaris - 3) >> 2) | 0x40000000; \
4f07118f
DM		 750 wmb(); \
751 __asm__ __volatile__ ("flush %0" : : "r" (&tl0_solaris[3]))
1da177e4
LT		 752
753extern u32 solaris_sparc_syscall[];
754extern u32 solaris_syscall[];
755extern void cleanup_socksys(void);
756
757extern u32 entry64_personality_patch;
758
a4c0291a 759static int __init solaris_init(void)
1da177e4
LT		 760{
761 int ret;
762
763 SOLDD(("Solaris module at %p\n", solaris_sparc_syscall));
764 register_exec_domain(&solaris_exec_domain);
765 if ((ret = init_socksys())) {
766 unregister_exec_domain(&solaris_exec_domain);
767 return ret;
768 }
769 update_ttable(solaris_sparc_syscall);
770 entry64_personality_patch |=
771 (offsetof(struct task_struct, personality) +
772 (sizeof(unsigned long) - 1));
4f07118f
DM		 773 wmb();
774 __asm__ __volatile__("flush %0"
1da177e4
LT		 775 : : "r" (&entry64_personality_patch));
776 return 0;
777}
778
a4c0291a 779static void __exit solaris_exit(void)
1da177e4
LT		 780{
781 update_ttable(solaris_syscall);
782 cleanup_socksys();
783 unregister_exec_domain(&solaris_exec_domain);
784}
785
a4c0291a
DM		 786module_init(solaris_init);
787module_exit(solaris_exit);
Linux kernel - Deliverables
This page took 0.257097 seconds and 5 git commands to generate.