2 * linux/arch/alpha/kernel/osf_sys.c
4 * Copyright (C) 1995 Linus Torvalds
8 * This file handles some of the stranger OSF/1 system call interfaces.
9 * Some of the system calls expect a non-C calling standard, others have
10 * special parameter blocks..
13 #include <linux/errno.h>
14 #include <linux/sched/signal.h>
15 #include <linux/sched/mm.h>
16 #include <linux/sched/task_stack.h>
17 #include <linux/sched/cputime.h>
18 #include <linux/kernel.h>
20 #include <linux/smp.h>
21 #include <linux/stddef.h>
22 #include <linux/syscalls.h>
23 #include <linux/unistd.h>
24 #include <linux/ptrace.h>
25 #include <linux/user.h>
26 #include <linux/utsname.h>
27 #include <linux/time.h>
28 #include <linux/timex.h>
29 #include <linux/major.h>
30 #include <linux/stat.h>
31 #include <linux/mman.h>
32 #include <linux/shm.h>
33 #include <linux/poll.h>
34 #include <linux/file.h>
35 #include <linux/types.h>
36 #include <linux/ipc.h>
37 #include <linux/namei.h>
38 #include <linux/uio.h>
39 #include <linux/vfs.h>
40 #include <linux/rcupdate.h>
41 #include <linux/slab.h>
45 #include <linux/uaccess.h>
46 #include <asm/sysinfo.h>
47 #include <asm/thread_info.h>
48 #include <asm/hwrpb.h>
49 #include <asm/processor.h>
52 * Brk needs to return an error. Still support Linux's brk(0) query idiom,
53 * which OSF programs just shouldn't be doing. We're still not quite
54 * identical to OSF as we don't return 0 on success, but doing otherwise
55 * would require changes to libc. Hopefully this is good enough.
57 SYSCALL_DEFINE1(osf_brk
, unsigned long, brk
)
59 unsigned long retval
= sys_brk(brk
);
60 if (brk
&& brk
!= retval
)
66 * This is pure guess-work..
68 SYSCALL_DEFINE4(osf_set_program_attributes
, unsigned long, text_start
,
69 unsigned long, text_len
, unsigned long, bss_start
,
70 unsigned long, bss_len
)
75 mm
->end_code
= bss_start
+ bss_len
;
76 mm
->start_brk
= bss_start
+ bss_len
;
77 mm
->brk
= bss_start
+ bss_len
;
79 printk("set_program_attributes(%lx %lx %lx %lx)\n",
80 text_start
, text_len
, bss_start
, bss_len
);
86 * OSF/1 directory handling functions...
88 * The "getdents()" interface is much more sane: the "basep" stuff is
89 * braindamage (it can't really handle filesystems where the directory
90 * offset differences aren't the same as "d_reclen").
92 #define NAME_OFFSET offsetof (struct osf_dirent, d_name)
96 unsigned short d_reclen
;
97 unsigned short d_namlen
;
101 struct osf_dirent_callback
{
102 struct dir_context ctx
;
103 struct osf_dirent __user
*dirent
;
110 osf_filldir(struct dir_context
*ctx
, const char *name
, int namlen
,
111 loff_t offset
, u64 ino
, unsigned int d_type
)
113 struct osf_dirent __user
*dirent
;
114 struct osf_dirent_callback
*buf
=
115 container_of(ctx
, struct osf_dirent_callback
, ctx
);
116 unsigned int reclen
= ALIGN(NAME_OFFSET
+ namlen
+ 1, sizeof(u32
));
119 buf
->error
= -EINVAL
; /* only used if we fail */
120 if (reclen
> buf
->count
)
123 if (sizeof(d_ino
) < sizeof(ino
) && d_ino
!= ino
) {
124 buf
->error
= -EOVERFLOW
;
128 if (put_user(offset
, buf
->basep
))
132 dirent
= buf
->dirent
;
133 if (put_user(d_ino
, &dirent
->d_ino
) ||
134 put_user(namlen
, &dirent
->d_namlen
) ||
135 put_user(reclen
, &dirent
->d_reclen
) ||
136 copy_to_user(dirent
->d_name
, name
, namlen
) ||
137 put_user(0, dirent
->d_name
+ namlen
))
139 dirent
= (void __user
*)dirent
+ reclen
;
140 buf
->dirent
= dirent
;
141 buf
->count
-= reclen
;
144 buf
->error
= -EFAULT
;
148 SYSCALL_DEFINE4(osf_getdirentries
, unsigned int, fd
,
149 struct osf_dirent __user
*, dirent
, unsigned int, count
,
150 long __user
*, basep
)
153 struct fd arg
= fdget_pos(fd
);
154 struct osf_dirent_callback buf
= {
155 .ctx
.actor
= osf_filldir
,
164 error
= iterate_dir(arg
.file
, &buf
.ctx
);
167 if (count
!= buf
.count
)
168 error
= count
- buf
.count
;
176 SYSCALL_DEFINE6(osf_mmap
, unsigned long, addr
, unsigned long, len
,
177 unsigned long, prot
, unsigned long, flags
, unsigned long, fd
,
180 unsigned long ret
= -EINVAL
;
183 if (flags
& (_MAP_HASSEMAPHORE
| _MAP_INHERIT
| _MAP_UNALIGNED
))
184 printk("%s: unimplemented OSF mmap flags %04lx\n",
185 current
->comm
, flags
);
187 if ((off
+ PAGE_ALIGN(len
)) < off
)
189 if (off
& ~PAGE_MASK
)
191 ret
= sys_mmap_pgoff(addr
, len
, prot
, flags
, fd
, off
>> PAGE_SHIFT
);
200 unsigned short st_nlink
;
201 short st_nlink_reserved
;
221 int st_atime_reserved
;
223 int st_mtime_reserved
;
225 int st_ctime_reserved
;
231 * The OSF/1 statfs structure is much larger, but this should
232 * match the beginning, at least.
244 __kernel_fsid_t f_fsid
;
247 struct osf_statfs64
{
257 __kernel_fsid_t f_fsid
;
276 linux_to_osf_stat(struct kstat
*lstat
, struct osf_stat __user
*osf_stat
)
278 struct osf_stat tmp
= { 0 };
280 tmp
.st_dev
= lstat
->dev
;
281 tmp
.st_mode
= lstat
->mode
;
282 tmp
.st_nlink
= lstat
->nlink
;
283 tmp
.st_uid
= from_kuid_munged(current_user_ns(), lstat
->uid
);
284 tmp
.st_gid
= from_kgid_munged(current_user_ns(), lstat
->gid
);
285 tmp
.st_rdev
= lstat
->rdev
;
286 tmp
.st_ldev
= lstat
->rdev
;
287 tmp
.st_size
= lstat
->size
;
288 tmp
.st_uatime
= lstat
->atime
.tv_nsec
/ 1000;
289 tmp
.st_umtime
= lstat
->mtime
.tv_nsec
/ 1000;
290 tmp
.st_uctime
= lstat
->ctime
.tv_nsec
/ 1000;
291 tmp
.st_ino
= lstat
->ino
;
292 tmp
.st_atime
= lstat
->atime
.tv_sec
;
293 tmp
.st_mtime
= lstat
->mtime
.tv_sec
;
294 tmp
.st_ctime
= lstat
->ctime
.tv_sec
;
295 tmp
.st_blksize
= lstat
->blksize
;
296 tmp
.st_blocks
= lstat
->blocks
;
298 return copy_to_user(osf_stat
, &tmp
, sizeof(tmp
)) ? -EFAULT
: 0;
302 linux_to_osf_statfs(struct kstatfs
*linux_stat
, struct osf_statfs __user
*osf_stat
,
303 unsigned long bufsiz
)
305 struct osf_statfs tmp_stat
;
307 tmp_stat
.f_type
= linux_stat
->f_type
;
308 tmp_stat
.f_flags
= 0; /* mount flags */
309 tmp_stat
.f_fsize
= linux_stat
->f_frsize
;
310 tmp_stat
.f_bsize
= linux_stat
->f_bsize
;
311 tmp_stat
.f_blocks
= linux_stat
->f_blocks
;
312 tmp_stat
.f_bfree
= linux_stat
->f_bfree
;
313 tmp_stat
.f_bavail
= linux_stat
->f_bavail
;
314 tmp_stat
.f_files
= linux_stat
->f_files
;
315 tmp_stat
.f_ffree
= linux_stat
->f_ffree
;
316 tmp_stat
.f_fsid
= linux_stat
->f_fsid
;
317 if (bufsiz
> sizeof(tmp_stat
))
318 bufsiz
= sizeof(tmp_stat
);
319 return copy_to_user(osf_stat
, &tmp_stat
, bufsiz
) ? -EFAULT
: 0;
323 linux_to_osf_statfs64(struct kstatfs
*linux_stat
, struct osf_statfs64 __user
*osf_stat
,
324 unsigned long bufsiz
)
326 struct osf_statfs64 tmp_stat
= { 0 };
328 tmp_stat
.f_type
= linux_stat
->f_type
;
329 tmp_stat
.f_fsize
= linux_stat
->f_frsize
;
330 tmp_stat
.f_bsize
= linux_stat
->f_bsize
;
331 tmp_stat
.f_blocks
= linux_stat
->f_blocks
;
332 tmp_stat
.f_bfree
= linux_stat
->f_bfree
;
333 tmp_stat
.f_bavail
= linux_stat
->f_bavail
;
334 tmp_stat
.f_files
= linux_stat
->f_files
;
335 tmp_stat
.f_ffree
= linux_stat
->f_ffree
;
336 tmp_stat
.f_fsid
= linux_stat
->f_fsid
;
337 if (bufsiz
> sizeof(tmp_stat
))
338 bufsiz
= sizeof(tmp_stat
);
339 return copy_to_user(osf_stat
, &tmp_stat
, bufsiz
) ? -EFAULT
: 0;
342 SYSCALL_DEFINE3(osf_statfs
, const char __user
*, pathname
,
343 struct osf_statfs __user
*, buffer
, unsigned long, bufsiz
)
345 struct kstatfs linux_stat
;
346 int error
= user_statfs(pathname
, &linux_stat
);
348 error
= linux_to_osf_statfs(&linux_stat
, buffer
, bufsiz
);
352 SYSCALL_DEFINE2(osf_stat
, char __user
*, name
, struct osf_stat __user
*, buf
)
357 error
= vfs_stat(name
, &stat
);
361 return linux_to_osf_stat(&stat
, buf
);
364 SYSCALL_DEFINE2(osf_lstat
, char __user
*, name
, struct osf_stat __user
*, buf
)
369 error
= vfs_lstat(name
, &stat
);
373 return linux_to_osf_stat(&stat
, buf
);
376 SYSCALL_DEFINE2(osf_fstat
, int, fd
, struct osf_stat __user
*, buf
)
381 error
= vfs_fstat(fd
, &stat
);
385 return linux_to_osf_stat(&stat
, buf
);
388 SYSCALL_DEFINE3(osf_fstatfs
, unsigned long, fd
,
389 struct osf_statfs __user
*, buffer
, unsigned long, bufsiz
)
391 struct kstatfs linux_stat
;
392 int error
= fd_statfs(fd
, &linux_stat
);
394 error
= linux_to_osf_statfs(&linux_stat
, buffer
, bufsiz
);
398 SYSCALL_DEFINE3(osf_statfs64
, char __user
*, pathname
,
399 struct osf_statfs64 __user
*, buffer
, unsigned long, bufsiz
)
401 struct kstatfs linux_stat
;
402 int error
= user_statfs(pathname
, &linux_stat
);
404 error
= linux_to_osf_statfs64(&linux_stat
, buffer
, bufsiz
);
408 SYSCALL_DEFINE3(osf_fstatfs64
, unsigned long, fd
,
409 struct osf_statfs64 __user
*, buffer
, unsigned long, bufsiz
)
411 struct kstatfs linux_stat
;
412 int error
= fd_statfs(fd
, &linux_stat
);
414 error
= linux_to_osf_statfs64(&linux_stat
, buffer
, bufsiz
);
419 * Uhh.. OSF/1 mount parameters aren't exactly obvious..
421 * Although to be frank, neither are the native Linux/i386 ones..
424 char __user
*devname
;
430 char __user
*devname
;
434 /* This has lots more here, which Linux handles with the option block
435 but I'm too lazy to do the translation into ASCII. */
439 char __user
*devname
;
445 * We can't actually handle ufs yet, so we translate UFS mounts to
446 * ext2fs mounts. I wouldn't mind a UFS filesystem, but the UFS
447 * layout is so braindead it's a major headache doing it.
449 * Just how long ago was it written? OTOH our UFS driver may be still
450 * unhappy with OSF UFS. [CHECKME]
453 osf_ufs_mount(const char __user
*dirname
,
454 struct ufs_args __user
*args
, int flags
)
457 struct cdfs_args tmp
;
458 struct filename
*devname
;
461 if (copy_from_user(&tmp
, args
, sizeof(tmp
)))
463 devname
= getname(tmp
.devname
);
464 retval
= PTR_ERR(devname
);
467 retval
= do_mount(devname
->name
, dirname
, "ext2", flags
, NULL
);
474 osf_cdfs_mount(const char __user
*dirname
,
475 struct cdfs_args __user
*args
, int flags
)
478 struct cdfs_args tmp
;
479 struct filename
*devname
;
482 if (copy_from_user(&tmp
, args
, sizeof(tmp
)))
484 devname
= getname(tmp
.devname
);
485 retval
= PTR_ERR(devname
);
488 retval
= do_mount(devname
->name
, dirname
, "iso9660", flags
, NULL
);
495 osf_procfs_mount(const char __user
*dirname
,
496 struct procfs_args __user
*args
, int flags
)
498 struct procfs_args tmp
;
500 if (copy_from_user(&tmp
, args
, sizeof(tmp
)))
503 return do_mount("", dirname
, "proc", flags
, NULL
);
506 SYSCALL_DEFINE4(osf_mount
, unsigned long, typenr
, const char __user
*, path
,
507 int, flag
, void __user
*, data
)
513 retval
= osf_ufs_mount(path
, data
, flag
);
516 retval
= osf_cdfs_mount(path
, data
, flag
);
519 retval
= osf_procfs_mount(path
, data
, flag
);
523 printk("osf_mount(%ld, %x)\n", typenr
, flag
);
529 SYSCALL_DEFINE1(osf_utsname
, char __user
*, name
)
535 if (copy_to_user(name
+ 0, utsname()->sysname
, 32))
537 if (copy_to_user(name
+ 32, utsname()->nodename
, 32))
539 if (copy_to_user(name
+ 64, utsname()->release
, 32))
541 if (copy_to_user(name
+ 96, utsname()->version
, 32))
543 if (copy_to_user(name
+ 128, utsname()->machine
, 32))
552 SYSCALL_DEFINE0(getpagesize
)
557 SYSCALL_DEFINE0(getdtablesize
)
559 return sysctl_nr_open
;
563 * For compatibility with OSF/1 only. Use utsname(2) instead.
565 SYSCALL_DEFINE2(osf_getdomainname
, char __user
*, name
, int, namelen
)
570 if (!access_ok(VERIFY_WRITE
, name
, namelen
))
578 for (i
= 0; i
< len
; ++i
) {
579 __put_user(utsname()->domainname
[i
], name
+ i
);
580 if (utsname()->domainname
[i
] == '\0')
589 * The following stuff should move into a header file should it ever
590 * be labeled "officially supported." Right now, there is just enough
591 * support to avoid applications (such as tar) printing error
592 * messages. The attributes are not really implemented.
596 * Values for Property list entry flag
598 #define PLE_PROPAGATE_ON_COPY 0x1 /* cp(1) will copy entry
600 #define PLE_FLAG_MASK 0x1 /* Valid flag values */
601 #define PLE_FLAG_ALL -1 /* All flag value */
603 struct proplistname_args
{
604 unsigned int pl_mask
;
605 unsigned int pl_numnames
;
624 struct proplistname_args __user
*name_args
;
627 int __user
*min_buf_size
;
631 struct proplistname_args __user
*name_args
;
634 int __user
*min_buf_size
;
639 struct proplistname_args __user
*name_args
;
643 struct proplistname_args __user
*name_args
;
648 PL_SET
= 1, PL_FSET
= 2,
649 PL_GET
= 3, PL_FGET
= 4,
650 PL_DEL
= 5, PL_FDEL
= 6
653 SYSCALL_DEFINE2(osf_proplist_syscall
, enum pl_code
, code
,
654 union pl_args __user
*, args
)
657 int __user
*min_buf_size_ptr
;
661 if (get_user(error
, &args
->set
.nbytes
))
665 if (get_user(error
, &args
->fset
.nbytes
))
669 error
= get_user(min_buf_size_ptr
, &args
->get
.min_buf_size
);
672 error
= put_user(0, min_buf_size_ptr
);
675 error
= get_user(min_buf_size_ptr
, &args
->fget
.min_buf_size
);
678 error
= put_user(0, min_buf_size_ptr
);
691 SYSCALL_DEFINE2(osf_sigstack
, struct sigstack __user
*, uss
,
692 struct sigstack __user
*, uoss
)
694 unsigned long usp
= rdusp();
695 unsigned long oss_sp
= current
->sas_ss_sp
+ current
->sas_ss_size
;
696 unsigned long oss_os
= on_sig_stack(usp
);
703 if (get_user(ss_sp
, &uss
->ss_sp
))
706 /* If the current stack was set with sigaltstack, don't
707 swap stacks while we are on it. */
709 if (current
->sas_ss_sp
&& on_sig_stack(usp
))
712 /* Since we don't know the extent of the stack, and we don't
713 track onstack-ness, but rather calculate it, we must
714 presume a size. Ho hum this interface is lossy. */
715 current
->sas_ss_sp
= (unsigned long)ss_sp
- SIGSTKSZ
;
716 current
->sas_ss_size
= SIGSTKSZ
;
721 if (! access_ok(VERIFY_WRITE
, uoss
, sizeof(*uoss
))
722 || __put_user(oss_sp
, &uoss
->ss_sp
)
723 || __put_user(oss_os
, &uoss
->ss_onstack
))
732 SYSCALL_DEFINE3(osf_sysinfo
, int, command
, char __user
*, buf
, long, count
)
734 const char *sysinfo_table
[] = {
740 "alpha", /* instruction set architecture */
741 "dummy", /* hardware serial number */
742 "dummy", /* hardware manufacturer */
743 "dummy", /* secure RPC domain */
745 unsigned long offset
;
747 long len
, err
= -EINVAL
;
750 if (offset
>= ARRAY_SIZE(sysinfo_table
)) {
751 /* Digital UNIX has a few unpublished interfaces here */
752 printk("sysinfo(%d)", command
);
757 res
= sysinfo_table
[offset
];
759 if ((unsigned long)len
> (unsigned long)count
)
761 if (copy_to_user(buf
, res
, len
))
770 SYSCALL_DEFINE5(osf_getsysinfo
, unsigned long, op
, void __user
*, buffer
,
771 unsigned long, nbytes
, int __user
*, start
, void __user
*, arg
)
774 struct percpu_struct
*cpu
;
777 case GSI_IEEE_FP_CONTROL
:
778 /* Return current software fp control & status bits. */
779 /* Note that DU doesn't verify available space here. */
781 w
= current_thread_info()->ieee_state
& IEEE_SW_MASK
;
782 w
= swcr_update_status(w
, rdfpcr());
783 if (put_user(w
, (unsigned long __user
*) buffer
))
787 case GSI_IEEE_STATE_AT_SIGNAL
:
789 * Not sure anybody will ever use this weird stuff. These
790 * ops can be used (under OSF/1) to set the fpcr that should
791 * be used when a signal handler starts executing.
796 if (nbytes
< sizeof(unsigned int))
798 w
= current_thread_info()->status
& UAC_BITMASK
;
799 if (put_user(w
, (unsigned int __user
*)buffer
))
804 if (nbytes
< sizeof(unsigned long))
806 cpu
= (struct percpu_struct
*)
807 ((char*)hwrpb
+ hwrpb
->processor_offset
);
809 if (put_user(w
, (unsigned long __user
*)buffer
))
814 if (nbytes
> sizeof(*hwrpb
))
816 if (copy_to_user(buffer
, hwrpb
, nbytes
) != 0)
827 SYSCALL_DEFINE5(osf_setsysinfo
, unsigned long, op
, void __user
*, buffer
,
828 unsigned long, nbytes
, int __user
*, start
, void __user
*, arg
)
831 case SSI_IEEE_FP_CONTROL
: {
832 unsigned long swcr
, fpcr
;
836 * Alpha Architecture Handbook 4.7.7.3:
837 * To be fully IEEE compiant, we must track the current IEEE
838 * exception state in software, because spurious bits can be
839 * set in the trap shadow of a software-complete insn.
842 if (get_user(swcr
, (unsigned long __user
*)buffer
))
844 state
= ¤t_thread_info()->ieee_state
;
846 /* Update softare trap enable bits. */
847 *state
= (*state
& ~IEEE_SW_MASK
) | (swcr
& IEEE_SW_MASK
);
849 /* Update the real fpcr. */
850 fpcr
= rdfpcr() & FPCR_DYN_MASK
;
851 fpcr
|= ieee_swcr_to_fpcr(swcr
);
857 case SSI_IEEE_RAISE_EXCEPTION
: {
858 unsigned long exc
, swcr
, fpcr
, fex
;
861 if (get_user(exc
, (unsigned long __user
*)buffer
))
863 state
= ¤t_thread_info()->ieee_state
;
864 exc
&= IEEE_STATUS_MASK
;
866 /* Update softare trap enable bits. */
867 swcr
= (*state
& IEEE_SW_MASK
) | exc
;
870 /* Update the real fpcr. */
872 fpcr
|= ieee_swcr_to_fpcr(swcr
);
875 /* If any exceptions set by this call, and are unmasked,
876 send a signal. Old exceptions are not signaled. */
877 fex
= (exc
>> IEEE_STATUS_TO_EXCSUM_SHIFT
) & swcr
;
882 if (fex
& IEEE_TRAP_ENABLE_DNO
) si_code
= FPE_FLTUND
;
883 if (fex
& IEEE_TRAP_ENABLE_INE
) si_code
= FPE_FLTRES
;
884 if (fex
& IEEE_TRAP_ENABLE_UNF
) si_code
= FPE_FLTUND
;
885 if (fex
& IEEE_TRAP_ENABLE_OVF
) si_code
= FPE_FLTOVF
;
886 if (fex
& IEEE_TRAP_ENABLE_DZE
) si_code
= FPE_FLTDIV
;
887 if (fex
& IEEE_TRAP_ENABLE_INV
) si_code
= FPE_FLTINV
;
889 info
.si_signo
= SIGFPE
;
891 info
.si_code
= si_code
;
892 info
.si_addr
= NULL
; /* FIXME */
893 send_sig_info(SIGFPE
, &info
, current
);
898 case SSI_IEEE_STATE_AT_SIGNAL
:
899 case SSI_IEEE_IGNORE_STATE_AT_SIGNAL
:
901 * Not sure anybody will ever use this weird stuff. These
902 * ops can be used (under OSF/1) to set the fpcr that should
903 * be used when a signal handler starts executing.
908 unsigned __user
*p
= buffer
;
911 for (i
= 0, p
= buffer
; i
< nbytes
; ++i
, p
+= 2) {
912 unsigned v
, w
, status
;
914 if (get_user(v
, p
) || get_user(w
, p
+ 1))
919 status
= current_thread_info()->status
;
920 status
= (status
& ~UAC_BITMASK
) | w
;
921 current_thread_info()->status
= status
;
941 /* Translations due to the fact that OSF's time_t is an int. Which
942 affects all sorts of things, like timeval and itimerval. */
944 extern struct timezone sys_tz
;
953 struct timeval32 it_interval
;
954 struct timeval32 it_value
;
958 get_tv32(struct timeval
*o
, struct timeval32 __user
*i
)
960 return (!access_ok(VERIFY_READ
, i
, sizeof(*i
)) ||
961 (__get_user(o
->tv_sec
, &i
->tv_sec
) |
962 __get_user(o
->tv_usec
, &i
->tv_usec
)));
966 put_tv32(struct timeval32 __user
*o
, struct timeval
*i
)
968 return (!access_ok(VERIFY_WRITE
, o
, sizeof(*o
)) ||
969 (__put_user(i
->tv_sec
, &o
->tv_sec
) |
970 __put_user(i
->tv_usec
, &o
->tv_usec
)));
974 get_it32(struct itimerval
*o
, struct itimerval32 __user
*i
)
976 return (!access_ok(VERIFY_READ
, i
, sizeof(*i
)) ||
977 (__get_user(o
->it_interval
.tv_sec
, &i
->it_interval
.tv_sec
) |
978 __get_user(o
->it_interval
.tv_usec
, &i
->it_interval
.tv_usec
) |
979 __get_user(o
->it_value
.tv_sec
, &i
->it_value
.tv_sec
) |
980 __get_user(o
->it_value
.tv_usec
, &i
->it_value
.tv_usec
)));
984 put_it32(struct itimerval32 __user
*o
, struct itimerval
*i
)
986 return (!access_ok(VERIFY_WRITE
, o
, sizeof(*o
)) ||
987 (__put_user(i
->it_interval
.tv_sec
, &o
->it_interval
.tv_sec
) |
988 __put_user(i
->it_interval
.tv_usec
, &o
->it_interval
.tv_usec
) |
989 __put_user(i
->it_value
.tv_sec
, &o
->it_value
.tv_sec
) |
990 __put_user(i
->it_value
.tv_usec
, &o
->it_value
.tv_usec
)));
994 jiffies_to_timeval32(unsigned long jiffies
, struct timeval32
*value
)
996 value
->tv_usec
= (jiffies
% HZ
) * (1000000L / HZ
);
997 value
->tv_sec
= jiffies
/ HZ
;
1000 SYSCALL_DEFINE2(osf_gettimeofday
, struct timeval32 __user
*, tv
,
1001 struct timezone __user
*, tz
)
1005 do_gettimeofday(&ktv
);
1006 if (put_tv32(tv
, &ktv
))
1010 if (copy_to_user(tz
, &sys_tz
, sizeof(sys_tz
)))
1016 SYSCALL_DEFINE2(osf_settimeofday
, struct timeval32 __user
*, tv
,
1017 struct timezone __user
*, tz
)
1019 struct timespec kts
;
1020 struct timezone ktz
;
1023 if (get_tv32((struct timeval
*)&kts
, tv
))
1025 kts
.tv_nsec
*= 1000;
1028 if (copy_from_user(&ktz
, tz
, sizeof(*tz
)))
1032 return do_sys_settimeofday(tv
? &kts
: NULL
, tz
? &ktz
: NULL
);
1035 asmlinkage
long sys_ni_posix_timers(void);
1037 SYSCALL_DEFINE2(osf_getitimer
, int, which
, struct itimerval32 __user
*, it
)
1039 struct itimerval kit
;
1042 if (!IS_ENABLED(CONFIG_POSIX_TIMERS
))
1043 return sys_ni_posix_timers();
1045 error
= do_getitimer(which
, &kit
);
1046 if (!error
&& put_it32(it
, &kit
))
1052 SYSCALL_DEFINE3(osf_setitimer
, int, which
, struct itimerval32 __user
*, in
,
1053 struct itimerval32 __user
*, out
)
1055 struct itimerval kin
, kout
;
1058 if (!IS_ENABLED(CONFIG_POSIX_TIMERS
))
1059 return sys_ni_posix_timers();
1062 if (get_it32(&kin
, in
))
1065 memset(&kin
, 0, sizeof(kin
));
1067 error
= do_setitimer(which
, &kin
, out
? &kout
: NULL
);
1071 if (put_it32(out
, &kout
))
1078 SYSCALL_DEFINE2(osf_utimes
, const char __user
*, filename
,
1079 struct timeval32 __user
*, tvs
)
1081 struct timespec tv
[2];
1084 struct timeval ktvs
[2];
1085 if (get_tv32(&ktvs
[0], &tvs
[0]) ||
1086 get_tv32(&ktvs
[1], &tvs
[1]))
1089 if (ktvs
[0].tv_usec
< 0 || ktvs
[0].tv_usec
>= 1000000 ||
1090 ktvs
[1].tv_usec
< 0 || ktvs
[1].tv_usec
>= 1000000)
1093 tv
[0].tv_sec
= ktvs
[0].tv_sec
;
1094 tv
[0].tv_nsec
= 1000 * ktvs
[0].tv_usec
;
1095 tv
[1].tv_sec
= ktvs
[1].tv_sec
;
1096 tv
[1].tv_nsec
= 1000 * ktvs
[1].tv_usec
;
1099 return do_utimes(AT_FDCWD
, filename
, tvs
? tv
: NULL
, 0);
1102 SYSCALL_DEFINE5(osf_select
, int, n
, fd_set __user
*, inp
, fd_set __user
*, outp
,
1103 fd_set __user
*, exp
, struct timeval32 __user
*, tvp
)
1105 struct timespec end_time
, *to
= NULL
;
1111 if (!access_ok(VERIFY_READ
, tvp
, sizeof(*tvp
))
1112 || __get_user(sec
, &tvp
->tv_sec
)
1113 || __get_user(usec
, &tvp
->tv_usec
)) {
1117 if (sec
< 0 || usec
< 0)
1120 if (poll_select_set_timeout(to
, sec
, usec
* NSEC_PER_USEC
))
1125 /* OSF does not copy back the remaining time. */
1126 return core_sys_select(n
, inp
, outp
, exp
, to
);
1130 struct timeval32 ru_utime
; /* user time used */
1131 struct timeval32 ru_stime
; /* system time used */
1132 long ru_maxrss
; /* maximum resident set size */
1133 long ru_ixrss
; /* integral shared memory size */
1134 long ru_idrss
; /* integral unshared data size */
1135 long ru_isrss
; /* integral unshared stack size */
1136 long ru_minflt
; /* page reclaims */
1137 long ru_majflt
; /* page faults */
1138 long ru_nswap
; /* swaps */
1139 long ru_inblock
; /* block input operations */
1140 long ru_oublock
; /* block output operations */
1141 long ru_msgsnd
; /* messages sent */
1142 long ru_msgrcv
; /* messages received */
1143 long ru_nsignals
; /* signals received */
1144 long ru_nvcsw
; /* voluntary context switches */
1145 long ru_nivcsw
; /* involuntary " */
1148 SYSCALL_DEFINE2(osf_getrusage
, int, who
, struct rusage32 __user
*, ru
)
1152 unsigned long utime_jiffies
, stime_jiffies
;
1154 if (who
!= RUSAGE_SELF
&& who
!= RUSAGE_CHILDREN
)
1157 memset(&r
, 0, sizeof(r
));
1160 task_cputime(current
, &utime
, &stime
);
1161 utime_jiffies
= nsecs_to_jiffies(utime
);
1162 stime_jiffies
= nsecs_to_jiffies(stime
);
1163 jiffies_to_timeval32(utime_jiffies
, &r
.ru_utime
);
1164 jiffies_to_timeval32(stime_jiffies
, &r
.ru_stime
);
1165 r
.ru_minflt
= current
->min_flt
;
1166 r
.ru_majflt
= current
->maj_flt
;
1168 case RUSAGE_CHILDREN
:
1169 utime_jiffies
= nsecs_to_jiffies(current
->signal
->cutime
);
1170 stime_jiffies
= nsecs_to_jiffies(current
->signal
->cstime
);
1171 jiffies_to_timeval32(utime_jiffies
, &r
.ru_utime
);
1172 jiffies_to_timeval32(stime_jiffies
, &r
.ru_stime
);
1173 r
.ru_minflt
= current
->signal
->cmin_flt
;
1174 r
.ru_majflt
= current
->signal
->cmaj_flt
;
1178 return copy_to_user(ru
, &r
, sizeof(r
)) ? -EFAULT
: 0;
1181 SYSCALL_DEFINE4(osf_wait4
, pid_t
, pid
, int __user
*, ustatus
, int, options
,
1182 struct rusage32 __user
*, ur
)
1186 unsigned int status
= 0;
1187 mm_segment_t old_fs
;
1190 return sys_wait4(pid
, ustatus
, options
, NULL
);
1195 ret
= sys_wait4(pid
, (unsigned int __user
*) &status
, options
,
1196 (struct rusage __user
*) &r
);
1199 if (!access_ok(VERIFY_WRITE
, ur
, sizeof(*ur
)))
1203 err
|= put_user(status
, ustatus
);
1204 err
|= __put_user(r
.ru_utime
.tv_sec
, &ur
->ru_utime
.tv_sec
);
1205 err
|= __put_user(r
.ru_utime
.tv_usec
, &ur
->ru_utime
.tv_usec
);
1206 err
|= __put_user(r
.ru_stime
.tv_sec
, &ur
->ru_stime
.tv_sec
);
1207 err
|= __put_user(r
.ru_stime
.tv_usec
, &ur
->ru_stime
.tv_usec
);
1208 err
|= __put_user(r
.ru_maxrss
, &ur
->ru_maxrss
);
1209 err
|= __put_user(r
.ru_ixrss
, &ur
->ru_ixrss
);
1210 err
|= __put_user(r
.ru_idrss
, &ur
->ru_idrss
);
1211 err
|= __put_user(r
.ru_isrss
, &ur
->ru_isrss
);
1212 err
|= __put_user(r
.ru_minflt
, &ur
->ru_minflt
);
1213 err
|= __put_user(r
.ru_majflt
, &ur
->ru_majflt
);
1214 err
|= __put_user(r
.ru_nswap
, &ur
->ru_nswap
);
1215 err
|= __put_user(r
.ru_inblock
, &ur
->ru_inblock
);
1216 err
|= __put_user(r
.ru_oublock
, &ur
->ru_oublock
);
1217 err
|= __put_user(r
.ru_msgsnd
, &ur
->ru_msgsnd
);
1218 err
|= __put_user(r
.ru_msgrcv
, &ur
->ru_msgrcv
);
1219 err
|= __put_user(r
.ru_nsignals
, &ur
->ru_nsignals
);
1220 err
|= __put_user(r
.ru_nvcsw
, &ur
->ru_nvcsw
);
1221 err
|= __put_user(r
.ru_nivcsw
, &ur
->ru_nivcsw
);
1223 return err
? err
: ret
;
1227 * I don't know what the parameters are: the first one
1228 * seems to be a timeval pointer, and I suspect the second
1229 * one is the time remaining.. Ho humm.. No documentation.
1231 SYSCALL_DEFINE2(osf_usleep_thread
, struct timeval32 __user
*, sleep
,
1232 struct timeval32 __user
*, remain
)
1235 unsigned long ticks
;
1237 if (get_tv32(&tmp
, sleep
))
1240 ticks
= timeval_to_jiffies(&tmp
);
1242 ticks
= schedule_timeout_interruptible(ticks
);
1245 jiffies_to_timeval(ticks
, &tmp
);
1246 if (put_tv32(remain
, &tmp
))
1257 unsigned int modes
; /* mode selector */
1258 long offset
; /* time offset (usec) */
1259 long freq
; /* frequency offset (scaled ppm) */
1260 long maxerror
; /* maximum error (usec) */
1261 long esterror
; /* estimated error (usec) */
1262 int status
; /* clock command/status */
1263 long constant
; /* pll time constant */
1264 long precision
; /* clock precision (usec) (read only) */
1265 long tolerance
; /* clock frequency tolerance (ppm)
1268 struct timeval32 time
; /* (read only) */
1269 long tick
; /* (modified) usecs between clock ticks */
1271 long ppsfreq
; /* pps frequency (scaled ppm) (ro) */
1272 long jitter
; /* pps jitter (us) (ro) */
1273 int shift
; /* interval duration (s) (shift) (ro) */
1274 long stabil
; /* pps stability (scaled ppm) (ro) */
1275 long jitcnt
; /* jitter limit exceeded (ro) */
1276 long calcnt
; /* calibration intervals (ro) */
1277 long errcnt
; /* calibration errors (ro) */
1278 long stbcnt
; /* stability limit exceeded (ro) */
1280 int :32; int :32; int :32; int :32;
1281 int :32; int :32; int :32; int :32;
1282 int :32; int :32; int :32; int :32;
1285 SYSCALL_DEFINE1(old_adjtimex
, struct timex32 __user
*, txc_p
)
1290 /* copy relevant bits of struct timex. */
1291 if (copy_from_user(&txc
, txc_p
, offsetof(struct timex32
, time
)) ||
1292 copy_from_user(&txc
.tick
, &txc_p
->tick
, sizeof(struct timex32
) -
1293 offsetof(struct timex32
, tick
)))
1296 ret
= do_adjtimex(&txc
);
1300 /* copy back to timex32 */
1301 if (copy_to_user(txc_p
, &txc
, offsetof(struct timex32
, time
)) ||
1302 (copy_to_user(&txc_p
->tick
, &txc
.tick
, sizeof(struct timex32
) -
1303 offsetof(struct timex32
, tick
))) ||
1304 (put_tv32(&txc_p
->time
, &txc
.time
)))
1310 /* Get an address range which is currently unmapped. Similar to the
1311 generic version except that we know how to honor ADDR_LIMIT_32BIT. */
1313 static unsigned long
1314 arch_get_unmapped_area_1(unsigned long addr
, unsigned long len
,
1315 unsigned long limit
)
1317 struct vm_unmapped_area_info info
;
1321 info
.low_limit
= addr
;
1322 info
.high_limit
= limit
;
1323 info
.align_mask
= 0;
1324 info
.align_offset
= 0;
1325 return vm_unmapped_area(&info
);
1329 arch_get_unmapped_area(struct file
*filp
, unsigned long addr
,
1330 unsigned long len
, unsigned long pgoff
,
1331 unsigned long flags
)
1333 unsigned long limit
;
1335 /* "32 bit" actually means 31 bit, since pointers sign extend. */
1336 if (current
->personality
& ADDR_LIMIT_32BIT
)
1344 if (flags
& MAP_FIXED
)
1347 /* First, see if the given suggestion fits.
1349 The OSF/1 loader (/sbin/loader) relies on us returning an
1350 address larger than the requested if one exists, which is
1351 a terribly broken way to program.
1353 That said, I can see the use in being able to suggest not
1354 merely specific addresses, but regions of memory -- perhaps
1355 this feature should be incorporated into all ports? */
1358 addr
= arch_get_unmapped_area_1 (PAGE_ALIGN(addr
), len
, limit
);
1359 if (addr
!= (unsigned long) -ENOMEM
)
1363 /* Next, try allocating at TASK_UNMAPPED_BASE. */
1364 addr
= arch_get_unmapped_area_1 (PAGE_ALIGN(TASK_UNMAPPED_BASE
),
1366 if (addr
!= (unsigned long) -ENOMEM
)
1369 /* Finally, try allocating in low memory. */
1370 addr
= arch_get_unmapped_area_1 (PAGE_SIZE
, len
, limit
);
1375 #ifdef CONFIG_OSF4_COMPAT
1377 /* Clear top 32 bits of iov_len in the user's buffer for
1378 compatibility with old versions of OSF/1 where iov_len
1379 was defined as int. */
1381 osf_fix_iov_len(const struct iovec __user
*iov
, unsigned long count
)
1385 for (i
= 0 ; i
< count
; i
++) {
1386 int __user
*iov_len_high
= (int __user
*)&iov
[i
].iov_len
+ 1;
1388 if (put_user(0, iov_len_high
))
1394 SYSCALL_DEFINE3(osf_readv
, unsigned long, fd
,
1395 const struct iovec __user
*, vector
, unsigned long, count
)
1397 if (unlikely(personality(current
->personality
) == PER_OSF4
))
1398 if (osf_fix_iov_len(vector
, count
))
1400 return sys_readv(fd
, vector
, count
);
1403 SYSCALL_DEFINE3(osf_writev
, unsigned long, fd
,
1404 const struct iovec __user
*, vector
, unsigned long, count
)
1406 if (unlikely(personality(current
->personality
) == PER_OSF4
))
1407 if (osf_fix_iov_len(vector
, count
))
1409 return sys_writev(fd
, vector
, count
);
1414 SYSCALL_DEFINE2(osf_getpriority
, int, which
, int, who
)
1416 int prio
= sys_getpriority(which
, who
);
1418 /* Return value is the unbiased priority, i.e. 20 - prio.
1419 This does result in negative return values, so signal
1421 force_successful_syscall_return();
1427 SYSCALL_DEFINE0(getxuid
)
1429 current_pt_regs()->r20
= sys_geteuid();
1430 return sys_getuid();
1433 SYSCALL_DEFINE0(getxgid
)
1435 current_pt_regs()->r20
= sys_getegid();
1436 return sys_getgid();
1439 SYSCALL_DEFINE0(getxpid
)
1441 current_pt_regs()->r20
= sys_getppid();
1442 return sys_getpid();
1445 SYSCALL_DEFINE0(alpha_pipe
)
1448 int res
= do_pipe_flags(fd
, 0);
1450 /* The return values are in $0 and $20. */
1451 current_pt_regs()->r20
= fd
[1];
1457 SYSCALL_DEFINE1(sethae
, unsigned long, val
)
1459 current_pt_regs()->hae
= val
;