| 1 | /* |
| 2 | * linux/arch/alpha/kernel/osf_sys.c |
| 3 | * |
| 4 | * Copyright (C) 1995 Linus Torvalds |
| 5 | */ |
| 6 | |
| 7 | /* |
| 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.. |
| 11 | */ |
| 12 | |
| 13 | #include <linux/errno.h> |
| 14 | #include <linux/sched.h> |
| 15 | #include <linux/kernel.h> |
| 16 | #include <linux/mm.h> |
| 17 | #include <linux/smp.h> |
| 18 | #include <linux/smp_lock.h> |
| 19 | #include <linux/stddef.h> |
| 20 | #include <linux/syscalls.h> |
| 21 | #include <linux/unistd.h> |
| 22 | #include <linux/ptrace.h> |
| 23 | #include <linux/slab.h> |
| 24 | #include <linux/user.h> |
| 25 | #include <linux/a.out.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 | |
| 42 | #include <asm/fpu.h> |
| 43 | #include <asm/io.h> |
| 44 | #include <asm/uaccess.h> |
| 45 | #include <asm/system.h> |
| 46 | #include <asm/sysinfo.h> |
| 47 | #include <asm/hwrpb.h> |
| 48 | #include <asm/processor.h> |
| 49 | |
| 50 | extern int do_pipe(int *); |
| 51 | |
| 52 | /* |
| 53 | * Brk needs to return an error. Still support Linux's brk(0) query idiom, |
| 54 | * which OSF programs just shouldn't be doing. We're still not quite |
| 55 | * identical to OSF as we don't return 0 on success, but doing otherwise |
| 56 | * would require changes to libc. Hopefully this is good enough. |
| 57 | */ |
| 58 | asmlinkage unsigned long |
| 59 | osf_brk(unsigned long brk) |
| 60 | { |
| 61 | unsigned long retval = sys_brk(brk); |
| 62 | if (brk && brk != retval) |
| 63 | retval = -ENOMEM; |
| 64 | return retval; |
| 65 | } |
| 66 | |
| 67 | /* |
| 68 | * This is pure guess-work.. |
| 69 | */ |
| 70 | asmlinkage int |
| 71 | osf_set_program_attributes(unsigned long text_start, unsigned long text_len, |
| 72 | unsigned long bss_start, unsigned long bss_len) |
| 73 | { |
| 74 | struct mm_struct *mm; |
| 75 | |
| 76 | lock_kernel(); |
| 77 | mm = current->mm; |
| 78 | mm->end_code = bss_start + bss_len; |
| 79 | mm->brk = bss_start + bss_len; |
| 80 | #if 0 |
| 81 | printk("set_program_attributes(%lx %lx %lx %lx)\n", |
| 82 | text_start, text_len, bss_start, bss_len); |
| 83 | #endif |
| 84 | unlock_kernel(); |
| 85 | return 0; |
| 86 | } |
| 87 | |
| 88 | /* |
| 89 | * OSF/1 directory handling functions... |
| 90 | * |
| 91 | * The "getdents()" interface is much more sane: the "basep" stuff is |
| 92 | * braindamage (it can't really handle filesystems where the directory |
| 93 | * offset differences aren't the same as "d_reclen"). |
| 94 | */ |
| 95 | #define NAME_OFFSET offsetof (struct osf_dirent, d_name) |
| 96 | |
| 97 | struct osf_dirent { |
| 98 | unsigned int d_ino; |
| 99 | unsigned short d_reclen; |
| 100 | unsigned short d_namlen; |
| 101 | char d_name[1]; |
| 102 | }; |
| 103 | |
| 104 | struct osf_dirent_callback { |
| 105 | struct osf_dirent __user *dirent; |
| 106 | long __user *basep; |
| 107 | unsigned int count; |
| 108 | int error; |
| 109 | }; |
| 110 | |
| 111 | static int |
| 112 | osf_filldir(void *__buf, const char *name, int namlen, loff_t offset, |
| 113 | u64 ino, unsigned int d_type) |
| 114 | { |
| 115 | struct osf_dirent __user *dirent; |
| 116 | struct osf_dirent_callback *buf = (struct osf_dirent_callback *) __buf; |
| 117 | unsigned int reclen = ALIGN(NAME_OFFSET + namlen + 1, sizeof(u32)); |
| 118 | unsigned int d_ino; |
| 119 | |
| 120 | buf->error = -EINVAL; /* only used if we fail */ |
| 121 | if (reclen > buf->count) |
| 122 | return -EINVAL; |
| 123 | d_ino = ino; |
| 124 | if (sizeof(d_ino) < sizeof(ino) && d_ino != ino) |
| 125 | return -EOVERFLOW; |
| 126 | if (buf->basep) { |
| 127 | if (put_user(offset, buf->basep)) |
| 128 | return -EFAULT; |
| 129 | buf->basep = NULL; |
| 130 | } |
| 131 | dirent = buf->dirent; |
| 132 | put_user(d_ino, &dirent->d_ino); |
| 133 | put_user(namlen, &dirent->d_namlen); |
| 134 | put_user(reclen, &dirent->d_reclen); |
| 135 | if (copy_to_user(dirent->d_name, name, namlen) || |
| 136 | put_user(0, dirent->d_name + namlen)) |
| 137 | return -EFAULT; |
| 138 | dirent = (void __user *)dirent + reclen; |
| 139 | buf->dirent = dirent; |
| 140 | buf->count -= reclen; |
| 141 | return 0; |
| 142 | } |
| 143 | |
| 144 | asmlinkage int |
| 145 | osf_getdirentries(unsigned int fd, struct osf_dirent __user *dirent, |
| 146 | unsigned int count, long __user *basep) |
| 147 | { |
| 148 | int error; |
| 149 | struct file *file; |
| 150 | struct osf_dirent_callback buf; |
| 151 | |
| 152 | error = -EBADF; |
| 153 | file = fget(fd); |
| 154 | if (!file) |
| 155 | goto out; |
| 156 | |
| 157 | buf.dirent = dirent; |
| 158 | buf.basep = basep; |
| 159 | buf.count = count; |
| 160 | buf.error = 0; |
| 161 | |
| 162 | error = vfs_readdir(file, osf_filldir, &buf); |
| 163 | if (error < 0) |
| 164 | goto out_putf; |
| 165 | |
| 166 | error = buf.error; |
| 167 | if (count != buf.count) |
| 168 | error = count - buf.count; |
| 169 | |
| 170 | out_putf: |
| 171 | fput(file); |
| 172 | out: |
| 173 | return error; |
| 174 | } |
| 175 | |
| 176 | #undef NAME_OFFSET |
| 177 | |
| 178 | asmlinkage unsigned long |
| 179 | osf_mmap(unsigned long addr, unsigned long len, unsigned long prot, |
| 180 | unsigned long flags, unsigned long fd, unsigned long off) |
| 181 | { |
| 182 | struct file *file = NULL; |
| 183 | unsigned long ret = -EBADF; |
| 184 | |
| 185 | #if 0 |
| 186 | if (flags & (_MAP_HASSEMAPHORE | _MAP_INHERIT | _MAP_UNALIGNED)) |
| 187 | printk("%s: unimplemented OSF mmap flags %04lx\n", |
| 188 | current->comm, flags); |
| 189 | #endif |
| 190 | if (!(flags & MAP_ANONYMOUS)) { |
| 191 | file = fget(fd); |
| 192 | if (!file) |
| 193 | goto out; |
| 194 | } |
| 195 | flags &= ~(MAP_EXECUTABLE | MAP_DENYWRITE); |
| 196 | down_write(¤t->mm->mmap_sem); |
| 197 | ret = do_mmap(file, addr, len, prot, flags, off); |
| 198 | up_write(¤t->mm->mmap_sem); |
| 199 | if (file) |
| 200 | fput(file); |
| 201 | out: |
| 202 | return ret; |
| 203 | } |
| 204 | |
| 205 | |
| 206 | /* |
| 207 | * The OSF/1 statfs structure is much larger, but this should |
| 208 | * match the beginning, at least. |
| 209 | */ |
| 210 | struct osf_statfs { |
| 211 | short f_type; |
| 212 | short f_flags; |
| 213 | int f_fsize; |
| 214 | int f_bsize; |
| 215 | int f_blocks; |
| 216 | int f_bfree; |
| 217 | int f_bavail; |
| 218 | int f_files; |
| 219 | int f_ffree; |
| 220 | __kernel_fsid_t f_fsid; |
| 221 | }; |
| 222 | |
| 223 | static int |
| 224 | linux_to_osf_statfs(struct kstatfs *linux_stat, struct osf_statfs __user *osf_stat, |
| 225 | unsigned long bufsiz) |
| 226 | { |
| 227 | struct osf_statfs tmp_stat; |
| 228 | |
| 229 | tmp_stat.f_type = linux_stat->f_type; |
| 230 | tmp_stat.f_flags = 0; /* mount flags */ |
| 231 | tmp_stat.f_fsize = linux_stat->f_frsize; |
| 232 | tmp_stat.f_bsize = linux_stat->f_bsize; |
| 233 | tmp_stat.f_blocks = linux_stat->f_blocks; |
| 234 | tmp_stat.f_bfree = linux_stat->f_bfree; |
| 235 | tmp_stat.f_bavail = linux_stat->f_bavail; |
| 236 | tmp_stat.f_files = linux_stat->f_files; |
| 237 | tmp_stat.f_ffree = linux_stat->f_ffree; |
| 238 | tmp_stat.f_fsid = linux_stat->f_fsid; |
| 239 | if (bufsiz > sizeof(tmp_stat)) |
| 240 | bufsiz = sizeof(tmp_stat); |
| 241 | return copy_to_user(osf_stat, &tmp_stat, bufsiz) ? -EFAULT : 0; |
| 242 | } |
| 243 | |
| 244 | static int |
| 245 | do_osf_statfs(struct dentry * dentry, struct osf_statfs __user *buffer, |
| 246 | unsigned long bufsiz) |
| 247 | { |
| 248 | struct kstatfs linux_stat; |
| 249 | int error = vfs_statfs(dentry, &linux_stat); |
| 250 | if (!error) |
| 251 | error = linux_to_osf_statfs(&linux_stat, buffer, bufsiz); |
| 252 | return error; |
| 253 | } |
| 254 | |
| 255 | asmlinkage int |
| 256 | osf_statfs(char __user *path, struct osf_statfs __user *buffer, unsigned long bufsiz) |
| 257 | { |
| 258 | struct nameidata nd; |
| 259 | int retval; |
| 260 | |
| 261 | retval = user_path_walk(path, &nd); |
| 262 | if (!retval) { |
| 263 | retval = do_osf_statfs(nd.dentry, buffer, bufsiz); |
| 264 | path_release(&nd); |
| 265 | } |
| 266 | return retval; |
| 267 | } |
| 268 | |
| 269 | asmlinkage int |
| 270 | osf_fstatfs(unsigned long fd, struct osf_statfs __user *buffer, unsigned long bufsiz) |
| 271 | { |
| 272 | struct file *file; |
| 273 | int retval; |
| 274 | |
| 275 | retval = -EBADF; |
| 276 | file = fget(fd); |
| 277 | if (file) { |
| 278 | retval = do_osf_statfs(file->f_path.dentry, buffer, bufsiz); |
| 279 | fput(file); |
| 280 | } |
| 281 | return retval; |
| 282 | } |
| 283 | |
| 284 | /* |
| 285 | * Uhh.. OSF/1 mount parameters aren't exactly obvious.. |
| 286 | * |
| 287 | * Although to be frank, neither are the native Linux/i386 ones.. |
| 288 | */ |
| 289 | struct ufs_args { |
| 290 | char __user *devname; |
| 291 | int flags; |
| 292 | uid_t exroot; |
| 293 | }; |
| 294 | |
| 295 | struct cdfs_args { |
| 296 | char __user *devname; |
| 297 | int flags; |
| 298 | uid_t exroot; |
| 299 | |
| 300 | /* This has lots more here, which Linux handles with the option block |
| 301 | but I'm too lazy to do the translation into ASCII. */ |
| 302 | }; |
| 303 | |
| 304 | struct procfs_args { |
| 305 | char __user *devname; |
| 306 | int flags; |
| 307 | uid_t exroot; |
| 308 | }; |
| 309 | |
| 310 | /* |
| 311 | * We can't actually handle ufs yet, so we translate UFS mounts to |
| 312 | * ext2fs mounts. I wouldn't mind a UFS filesystem, but the UFS |
| 313 | * layout is so braindead it's a major headache doing it. |
| 314 | * |
| 315 | * Just how long ago was it written? OTOH our UFS driver may be still |
| 316 | * unhappy with OSF UFS. [CHECKME] |
| 317 | */ |
| 318 | static int |
| 319 | osf_ufs_mount(char *dirname, struct ufs_args __user *args, int flags) |
| 320 | { |
| 321 | int retval; |
| 322 | struct cdfs_args tmp; |
| 323 | char *devname; |
| 324 | |
| 325 | retval = -EFAULT; |
| 326 | if (copy_from_user(&tmp, args, sizeof(tmp))) |
| 327 | goto out; |
| 328 | devname = getname(tmp.devname); |
| 329 | retval = PTR_ERR(devname); |
| 330 | if (IS_ERR(devname)) |
| 331 | goto out; |
| 332 | retval = do_mount(devname, dirname, "ext2", flags, NULL); |
| 333 | putname(devname); |
| 334 | out: |
| 335 | return retval; |
| 336 | } |
| 337 | |
| 338 | static int |
| 339 | osf_cdfs_mount(char *dirname, struct cdfs_args __user *args, int flags) |
| 340 | { |
| 341 | int retval; |
| 342 | struct cdfs_args tmp; |
| 343 | char *devname; |
| 344 | |
| 345 | retval = -EFAULT; |
| 346 | if (copy_from_user(&tmp, args, sizeof(tmp))) |
| 347 | goto out; |
| 348 | devname = getname(tmp.devname); |
| 349 | retval = PTR_ERR(devname); |
| 350 | if (IS_ERR(devname)) |
| 351 | goto out; |
| 352 | retval = do_mount(devname, dirname, "iso9660", flags, NULL); |
| 353 | putname(devname); |
| 354 | out: |
| 355 | return retval; |
| 356 | } |
| 357 | |
| 358 | static int |
| 359 | osf_procfs_mount(char *dirname, struct procfs_args __user *args, int flags) |
| 360 | { |
| 361 | struct procfs_args tmp; |
| 362 | |
| 363 | if (copy_from_user(&tmp, args, sizeof(tmp))) |
| 364 | return -EFAULT; |
| 365 | |
| 366 | return do_mount("", dirname, "proc", flags, NULL); |
| 367 | } |
| 368 | |
| 369 | asmlinkage int |
| 370 | osf_mount(unsigned long typenr, char __user *path, int flag, void __user *data) |
| 371 | { |
| 372 | int retval = -EINVAL; |
| 373 | char *name; |
| 374 | |
| 375 | lock_kernel(); |
| 376 | |
| 377 | name = getname(path); |
| 378 | retval = PTR_ERR(name); |
| 379 | if (IS_ERR(name)) |
| 380 | goto out; |
| 381 | switch (typenr) { |
| 382 | case 1: |
| 383 | retval = osf_ufs_mount(name, data, flag); |
| 384 | break; |
| 385 | case 6: |
| 386 | retval = osf_cdfs_mount(name, data, flag); |
| 387 | break; |
| 388 | case 9: |
| 389 | retval = osf_procfs_mount(name, data, flag); |
| 390 | break; |
| 391 | default: |
| 392 | printk("osf_mount(%ld, %x)\n", typenr, flag); |
| 393 | } |
| 394 | putname(name); |
| 395 | out: |
| 396 | unlock_kernel(); |
| 397 | return retval; |
| 398 | } |
| 399 | |
| 400 | asmlinkage int |
| 401 | osf_utsname(char __user *name) |
| 402 | { |
| 403 | int error; |
| 404 | |
| 405 | down_read(&uts_sem); |
| 406 | error = -EFAULT; |
| 407 | if (copy_to_user(name + 0, utsname()->sysname, 32)) |
| 408 | goto out; |
| 409 | if (copy_to_user(name + 32, utsname()->nodename, 32)) |
| 410 | goto out; |
| 411 | if (copy_to_user(name + 64, utsname()->release, 32)) |
| 412 | goto out; |
| 413 | if (copy_to_user(name + 96, utsname()->version, 32)) |
| 414 | goto out; |
| 415 | if (copy_to_user(name + 128, utsname()->machine, 32)) |
| 416 | goto out; |
| 417 | |
| 418 | error = 0; |
| 419 | out: |
| 420 | up_read(&uts_sem); |
| 421 | return error; |
| 422 | } |
| 423 | |
| 424 | asmlinkage unsigned long |
| 425 | sys_getpagesize(void) |
| 426 | { |
| 427 | return PAGE_SIZE; |
| 428 | } |
| 429 | |
| 430 | asmlinkage unsigned long |
| 431 | sys_getdtablesize(void) |
| 432 | { |
| 433 | return NR_OPEN; |
| 434 | } |
| 435 | |
| 436 | /* |
| 437 | * For compatibility with OSF/1 only. Use utsname(2) instead. |
| 438 | */ |
| 439 | asmlinkage int |
| 440 | osf_getdomainname(char __user *name, int namelen) |
| 441 | { |
| 442 | unsigned len; |
| 443 | int i; |
| 444 | |
| 445 | if (!access_ok(VERIFY_WRITE, name, namelen)) |
| 446 | return -EFAULT; |
| 447 | |
| 448 | len = namelen; |
| 449 | if (namelen > 32) |
| 450 | len = 32; |
| 451 | |
| 452 | down_read(&uts_sem); |
| 453 | for (i = 0; i < len; ++i) { |
| 454 | __put_user(utsname()->domainname[i], name + i); |
| 455 | if (utsname()->domainname[i] == '\0') |
| 456 | break; |
| 457 | } |
| 458 | up_read(&uts_sem); |
| 459 | |
| 460 | return 0; |
| 461 | } |
| 462 | |
| 463 | /* |
| 464 | * The following stuff should move into a header file should it ever |
| 465 | * be labeled "officially supported." Right now, there is just enough |
| 466 | * support to avoid applications (such as tar) printing error |
| 467 | * messages. The attributes are not really implemented. |
| 468 | */ |
| 469 | |
| 470 | /* |
| 471 | * Values for Property list entry flag |
| 472 | */ |
| 473 | #define PLE_PROPAGATE_ON_COPY 0x1 /* cp(1) will copy entry |
| 474 | by default */ |
| 475 | #define PLE_FLAG_MASK 0x1 /* Valid flag values */ |
| 476 | #define PLE_FLAG_ALL -1 /* All flag value */ |
| 477 | |
| 478 | struct proplistname_args { |
| 479 | unsigned int pl_mask; |
| 480 | unsigned int pl_numnames; |
| 481 | char **pl_names; |
| 482 | }; |
| 483 | |
| 484 | union pl_args { |
| 485 | struct setargs { |
| 486 | char __user *path; |
| 487 | long follow; |
| 488 | long nbytes; |
| 489 | char __user *buf; |
| 490 | } set; |
| 491 | struct fsetargs { |
| 492 | long fd; |
| 493 | long nbytes; |
| 494 | char __user *buf; |
| 495 | } fset; |
| 496 | struct getargs { |
| 497 | char __user *path; |
| 498 | long follow; |
| 499 | struct proplistname_args __user *name_args; |
| 500 | long nbytes; |
| 501 | char __user *buf; |
| 502 | int __user *min_buf_size; |
| 503 | } get; |
| 504 | struct fgetargs { |
| 505 | long fd; |
| 506 | struct proplistname_args __user *name_args; |
| 507 | long nbytes; |
| 508 | char __user *buf; |
| 509 | int __user *min_buf_size; |
| 510 | } fget; |
| 511 | struct delargs { |
| 512 | char __user *path; |
| 513 | long follow; |
| 514 | struct proplistname_args __user *name_args; |
| 515 | } del; |
| 516 | struct fdelargs { |
| 517 | long fd; |
| 518 | struct proplistname_args __user *name_args; |
| 519 | } fdel; |
| 520 | }; |
| 521 | |
| 522 | enum pl_code { |
| 523 | PL_SET = 1, PL_FSET = 2, |
| 524 | PL_GET = 3, PL_FGET = 4, |
| 525 | PL_DEL = 5, PL_FDEL = 6 |
| 526 | }; |
| 527 | |
| 528 | asmlinkage long |
| 529 | osf_proplist_syscall(enum pl_code code, union pl_args __user *args) |
| 530 | { |
| 531 | long error; |
| 532 | int __user *min_buf_size_ptr; |
| 533 | |
| 534 | lock_kernel(); |
| 535 | switch (code) { |
| 536 | case PL_SET: |
| 537 | if (get_user(error, &args->set.nbytes)) |
| 538 | error = -EFAULT; |
| 539 | break; |
| 540 | case PL_FSET: |
| 541 | if (get_user(error, &args->fset.nbytes)) |
| 542 | error = -EFAULT; |
| 543 | break; |
| 544 | case PL_GET: |
| 545 | error = get_user(min_buf_size_ptr, &args->get.min_buf_size); |
| 546 | if (error) |
| 547 | break; |
| 548 | error = put_user(0, min_buf_size_ptr); |
| 549 | break; |
| 550 | case PL_FGET: |
| 551 | error = get_user(min_buf_size_ptr, &args->fget.min_buf_size); |
| 552 | if (error) |
| 553 | break; |
| 554 | error = put_user(0, min_buf_size_ptr); |
| 555 | break; |
| 556 | case PL_DEL: |
| 557 | case PL_FDEL: |
| 558 | error = 0; |
| 559 | break; |
| 560 | default: |
| 561 | error = -EOPNOTSUPP; |
| 562 | break; |
| 563 | }; |
| 564 | unlock_kernel(); |
| 565 | return error; |
| 566 | } |
| 567 | |
| 568 | asmlinkage int |
| 569 | osf_sigstack(struct sigstack __user *uss, struct sigstack __user *uoss) |
| 570 | { |
| 571 | unsigned long usp = rdusp(); |
| 572 | unsigned long oss_sp = current->sas_ss_sp + current->sas_ss_size; |
| 573 | unsigned long oss_os = on_sig_stack(usp); |
| 574 | int error; |
| 575 | |
| 576 | if (uss) { |
| 577 | void __user *ss_sp; |
| 578 | |
| 579 | error = -EFAULT; |
| 580 | if (get_user(ss_sp, &uss->ss_sp)) |
| 581 | goto out; |
| 582 | |
| 583 | /* If the current stack was set with sigaltstack, don't |
| 584 | swap stacks while we are on it. */ |
| 585 | error = -EPERM; |
| 586 | if (current->sas_ss_sp && on_sig_stack(usp)) |
| 587 | goto out; |
| 588 | |
| 589 | /* Since we don't know the extent of the stack, and we don't |
| 590 | track onstack-ness, but rather calculate it, we must |
| 591 | presume a size. Ho hum this interface is lossy. */ |
| 592 | current->sas_ss_sp = (unsigned long)ss_sp - SIGSTKSZ; |
| 593 | current->sas_ss_size = SIGSTKSZ; |
| 594 | } |
| 595 | |
| 596 | if (uoss) { |
| 597 | error = -EFAULT; |
| 598 | if (! access_ok(VERIFY_WRITE, uoss, sizeof(*uoss)) |
| 599 | || __put_user(oss_sp, &uoss->ss_sp) |
| 600 | || __put_user(oss_os, &uoss->ss_onstack)) |
| 601 | goto out; |
| 602 | } |
| 603 | |
| 604 | error = 0; |
| 605 | out: |
| 606 | return error; |
| 607 | } |
| 608 | |
| 609 | asmlinkage long |
| 610 | osf_sysinfo(int command, char __user *buf, long count) |
| 611 | { |
| 612 | char *sysinfo_table[] = { |
| 613 | utsname()->sysname, |
| 614 | utsname()->nodename, |
| 615 | utsname()->release, |
| 616 | utsname()->version, |
| 617 | utsname()->machine, |
| 618 | "alpha", /* instruction set architecture */ |
| 619 | "dummy", /* hardware serial number */ |
| 620 | "dummy", /* hardware manufacturer */ |
| 621 | "dummy", /* secure RPC domain */ |
| 622 | }; |
| 623 | unsigned long offset; |
| 624 | char *res; |
| 625 | long len, err = -EINVAL; |
| 626 | |
| 627 | offset = command-1; |
| 628 | if (offset >= ARRAY_SIZE(sysinfo_table)) { |
| 629 | /* Digital UNIX has a few unpublished interfaces here */ |
| 630 | printk("sysinfo(%d)", command); |
| 631 | goto out; |
| 632 | } |
| 633 | |
| 634 | down_read(&uts_sem); |
| 635 | res = sysinfo_table[offset]; |
| 636 | len = strlen(res)+1; |
| 637 | if (len > count) |
| 638 | len = count; |
| 639 | if (copy_to_user(buf, res, len)) |
| 640 | err = -EFAULT; |
| 641 | else |
| 642 | err = 0; |
| 643 | up_read(&uts_sem); |
| 644 | out: |
| 645 | return err; |
| 646 | } |
| 647 | |
| 648 | asmlinkage unsigned long |
| 649 | osf_getsysinfo(unsigned long op, void __user *buffer, unsigned long nbytes, |
| 650 | int __user *start, void __user *arg) |
| 651 | { |
| 652 | unsigned long w; |
| 653 | struct percpu_struct *cpu; |
| 654 | |
| 655 | switch (op) { |
| 656 | case GSI_IEEE_FP_CONTROL: |
| 657 | /* Return current software fp control & status bits. */ |
| 658 | /* Note that DU doesn't verify available space here. */ |
| 659 | |
| 660 | w = current_thread_info()->ieee_state & IEEE_SW_MASK; |
| 661 | w = swcr_update_status(w, rdfpcr()); |
| 662 | if (put_user(w, (unsigned long __user *) buffer)) |
| 663 | return -EFAULT; |
| 664 | return 0; |
| 665 | |
| 666 | case GSI_IEEE_STATE_AT_SIGNAL: |
| 667 | /* |
| 668 | * Not sure anybody will ever use this weird stuff. These |
| 669 | * ops can be used (under OSF/1) to set the fpcr that should |
| 670 | * be used when a signal handler starts executing. |
| 671 | */ |
| 672 | break; |
| 673 | |
| 674 | case GSI_UACPROC: |
| 675 | if (nbytes < sizeof(unsigned int)) |
| 676 | return -EINVAL; |
| 677 | w = (current_thread_info()->flags >> UAC_SHIFT) & UAC_BITMASK; |
| 678 | if (put_user(w, (unsigned int __user *)buffer)) |
| 679 | return -EFAULT; |
| 680 | return 1; |
| 681 | |
| 682 | case GSI_PROC_TYPE: |
| 683 | if (nbytes < sizeof(unsigned long)) |
| 684 | return -EINVAL; |
| 685 | cpu = (struct percpu_struct*) |
| 686 | ((char*)hwrpb + hwrpb->processor_offset); |
| 687 | w = cpu->type; |
| 688 | if (put_user(w, (unsigned long __user*)buffer)) |
| 689 | return -EFAULT; |
| 690 | return 1; |
| 691 | |
| 692 | case GSI_GET_HWRPB: |
| 693 | if (nbytes < sizeof(*hwrpb)) |
| 694 | return -EINVAL; |
| 695 | if (copy_to_user(buffer, hwrpb, nbytes) != 0) |
| 696 | return -EFAULT; |
| 697 | return 1; |
| 698 | |
| 699 | default: |
| 700 | break; |
| 701 | } |
| 702 | |
| 703 | return -EOPNOTSUPP; |
| 704 | } |
| 705 | |
| 706 | asmlinkage unsigned long |
| 707 | osf_setsysinfo(unsigned long op, void __user *buffer, unsigned long nbytes, |
| 708 | int __user *start, void __user *arg) |
| 709 | { |
| 710 | switch (op) { |
| 711 | case SSI_IEEE_FP_CONTROL: { |
| 712 | unsigned long swcr, fpcr; |
| 713 | unsigned int *state; |
| 714 | |
| 715 | /* |
| 716 | * Alpha Architecture Handbook 4.7.7.3: |
| 717 | * To be fully IEEE compiant, we must track the current IEEE |
| 718 | * exception state in software, because spurious bits can be |
| 719 | * set in the trap shadow of a software-complete insn. |
| 720 | */ |
| 721 | |
| 722 | if (get_user(swcr, (unsigned long __user *)buffer)) |
| 723 | return -EFAULT; |
| 724 | state = ¤t_thread_info()->ieee_state; |
| 725 | |
| 726 | /* Update softare trap enable bits. */ |
| 727 | *state = (*state & ~IEEE_SW_MASK) | (swcr & IEEE_SW_MASK); |
| 728 | |
| 729 | /* Update the real fpcr. */ |
| 730 | fpcr = rdfpcr() & FPCR_DYN_MASK; |
| 731 | fpcr |= ieee_swcr_to_fpcr(swcr); |
| 732 | wrfpcr(fpcr); |
| 733 | |
| 734 | return 0; |
| 735 | } |
| 736 | |
| 737 | case SSI_IEEE_RAISE_EXCEPTION: { |
| 738 | unsigned long exc, swcr, fpcr, fex; |
| 739 | unsigned int *state; |
| 740 | |
| 741 | if (get_user(exc, (unsigned long __user *)buffer)) |
| 742 | return -EFAULT; |
| 743 | state = ¤t_thread_info()->ieee_state; |
| 744 | exc &= IEEE_STATUS_MASK; |
| 745 | |
| 746 | /* Update softare trap enable bits. */ |
| 747 | swcr = (*state & IEEE_SW_MASK) | exc; |
| 748 | *state |= exc; |
| 749 | |
| 750 | /* Update the real fpcr. */ |
| 751 | fpcr = rdfpcr(); |
| 752 | fpcr |= ieee_swcr_to_fpcr(swcr); |
| 753 | wrfpcr(fpcr); |
| 754 | |
| 755 | /* If any exceptions set by this call, and are unmasked, |
| 756 | send a signal. Old exceptions are not signaled. */ |
| 757 | fex = (exc >> IEEE_STATUS_TO_EXCSUM_SHIFT) & swcr; |
| 758 | if (fex) { |
| 759 | siginfo_t info; |
| 760 | int si_code = 0; |
| 761 | |
| 762 | if (fex & IEEE_TRAP_ENABLE_DNO) si_code = FPE_FLTUND; |
| 763 | if (fex & IEEE_TRAP_ENABLE_INE) si_code = FPE_FLTRES; |
| 764 | if (fex & IEEE_TRAP_ENABLE_UNF) si_code = FPE_FLTUND; |
| 765 | if (fex & IEEE_TRAP_ENABLE_OVF) si_code = FPE_FLTOVF; |
| 766 | if (fex & IEEE_TRAP_ENABLE_DZE) si_code = FPE_FLTDIV; |
| 767 | if (fex & IEEE_TRAP_ENABLE_INV) si_code = FPE_FLTINV; |
| 768 | |
| 769 | info.si_signo = SIGFPE; |
| 770 | info.si_errno = 0; |
| 771 | info.si_code = si_code; |
| 772 | info.si_addr = NULL; /* FIXME */ |
| 773 | send_sig_info(SIGFPE, &info, current); |
| 774 | } |
| 775 | return 0; |
| 776 | } |
| 777 | |
| 778 | case SSI_IEEE_STATE_AT_SIGNAL: |
| 779 | case SSI_IEEE_IGNORE_STATE_AT_SIGNAL: |
| 780 | /* |
| 781 | * Not sure anybody will ever use this weird stuff. These |
| 782 | * ops can be used (under OSF/1) to set the fpcr that should |
| 783 | * be used when a signal handler starts executing. |
| 784 | */ |
| 785 | break; |
| 786 | |
| 787 | case SSI_NVPAIRS: { |
| 788 | unsigned long v, w, i; |
| 789 | unsigned int old, new; |
| 790 | |
| 791 | for (i = 0; i < nbytes; ++i) { |
| 792 | |
| 793 | if (get_user(v, 2*i + (unsigned int __user *)buffer)) |
| 794 | return -EFAULT; |
| 795 | if (get_user(w, 2*i + 1 + (unsigned int __user *)buffer)) |
| 796 | return -EFAULT; |
| 797 | switch (v) { |
| 798 | case SSIN_UACPROC: |
| 799 | again: |
| 800 | old = current_thread_info()->flags; |
| 801 | new = old & ~(UAC_BITMASK << UAC_SHIFT); |
| 802 | new = new | (w & UAC_BITMASK) << UAC_SHIFT; |
| 803 | if (cmpxchg(¤t_thread_info()->flags, |
| 804 | old, new) != old) |
| 805 | goto again; |
| 806 | break; |
| 807 | |
| 808 | default: |
| 809 | return -EOPNOTSUPP; |
| 810 | } |
| 811 | } |
| 812 | return 0; |
| 813 | } |
| 814 | |
| 815 | default: |
| 816 | break; |
| 817 | } |
| 818 | |
| 819 | return -EOPNOTSUPP; |
| 820 | } |
| 821 | |
| 822 | /* Translations due to the fact that OSF's time_t is an int. Which |
| 823 | affects all sorts of things, like timeval and itimerval. */ |
| 824 | |
| 825 | extern struct timezone sys_tz; |
| 826 | |
| 827 | struct timeval32 |
| 828 | { |
| 829 | int tv_sec, tv_usec; |
| 830 | }; |
| 831 | |
| 832 | struct itimerval32 |
| 833 | { |
| 834 | struct timeval32 it_interval; |
| 835 | struct timeval32 it_value; |
| 836 | }; |
| 837 | |
| 838 | static inline long |
| 839 | get_tv32(struct timeval *o, struct timeval32 __user *i) |
| 840 | { |
| 841 | return (!access_ok(VERIFY_READ, i, sizeof(*i)) || |
| 842 | (__get_user(o->tv_sec, &i->tv_sec) | |
| 843 | __get_user(o->tv_usec, &i->tv_usec))); |
| 844 | } |
| 845 | |
| 846 | static inline long |
| 847 | put_tv32(struct timeval32 __user *o, struct timeval *i) |
| 848 | { |
| 849 | return (!access_ok(VERIFY_WRITE, o, sizeof(*o)) || |
| 850 | (__put_user(i->tv_sec, &o->tv_sec) | |
| 851 | __put_user(i->tv_usec, &o->tv_usec))); |
| 852 | } |
| 853 | |
| 854 | static inline long |
| 855 | get_it32(struct itimerval *o, struct itimerval32 __user *i) |
| 856 | { |
| 857 | return (!access_ok(VERIFY_READ, i, sizeof(*i)) || |
| 858 | (__get_user(o->it_interval.tv_sec, &i->it_interval.tv_sec) | |
| 859 | __get_user(o->it_interval.tv_usec, &i->it_interval.tv_usec) | |
| 860 | __get_user(o->it_value.tv_sec, &i->it_value.tv_sec) | |
| 861 | __get_user(o->it_value.tv_usec, &i->it_value.tv_usec))); |
| 862 | } |
| 863 | |
| 864 | static inline long |
| 865 | put_it32(struct itimerval32 __user *o, struct itimerval *i) |
| 866 | { |
| 867 | return (!access_ok(VERIFY_WRITE, o, sizeof(*o)) || |
| 868 | (__put_user(i->it_interval.tv_sec, &o->it_interval.tv_sec) | |
| 869 | __put_user(i->it_interval.tv_usec, &o->it_interval.tv_usec) | |
| 870 | __put_user(i->it_value.tv_sec, &o->it_value.tv_sec) | |
| 871 | __put_user(i->it_value.tv_usec, &o->it_value.tv_usec))); |
| 872 | } |
| 873 | |
| 874 | static inline void |
| 875 | jiffies_to_timeval32(unsigned long jiffies, struct timeval32 *value) |
| 876 | { |
| 877 | value->tv_usec = (jiffies % HZ) * (1000000L / HZ); |
| 878 | value->tv_sec = jiffies / HZ; |
| 879 | } |
| 880 | |
| 881 | asmlinkage int |
| 882 | osf_gettimeofday(struct timeval32 __user *tv, struct timezone __user *tz) |
| 883 | { |
| 884 | if (tv) { |
| 885 | struct timeval ktv; |
| 886 | do_gettimeofday(&ktv); |
| 887 | if (put_tv32(tv, &ktv)) |
| 888 | return -EFAULT; |
| 889 | } |
| 890 | if (tz) { |
| 891 | if (copy_to_user(tz, &sys_tz, sizeof(sys_tz))) |
| 892 | return -EFAULT; |
| 893 | } |
| 894 | return 0; |
| 895 | } |
| 896 | |
| 897 | asmlinkage int |
| 898 | osf_settimeofday(struct timeval32 __user *tv, struct timezone __user *tz) |
| 899 | { |
| 900 | struct timespec kts; |
| 901 | struct timezone ktz; |
| 902 | |
| 903 | if (tv) { |
| 904 | if (get_tv32((struct timeval *)&kts, tv)) |
| 905 | return -EFAULT; |
| 906 | } |
| 907 | if (tz) { |
| 908 | if (copy_from_user(&ktz, tz, sizeof(*tz))) |
| 909 | return -EFAULT; |
| 910 | } |
| 911 | |
| 912 | kts.tv_nsec *= 1000; |
| 913 | |
| 914 | return do_sys_settimeofday(tv ? &kts : NULL, tz ? &ktz : NULL); |
| 915 | } |
| 916 | |
| 917 | asmlinkage int |
| 918 | osf_getitimer(int which, struct itimerval32 __user *it) |
| 919 | { |
| 920 | struct itimerval kit; |
| 921 | int error; |
| 922 | |
| 923 | error = do_getitimer(which, &kit); |
| 924 | if (!error && put_it32(it, &kit)) |
| 925 | error = -EFAULT; |
| 926 | |
| 927 | return error; |
| 928 | } |
| 929 | |
| 930 | asmlinkage int |
| 931 | osf_setitimer(int which, struct itimerval32 __user *in, struct itimerval32 __user *out) |
| 932 | { |
| 933 | struct itimerval kin, kout; |
| 934 | int error; |
| 935 | |
| 936 | if (in) { |
| 937 | if (get_it32(&kin, in)) |
| 938 | return -EFAULT; |
| 939 | } else |
| 940 | memset(&kin, 0, sizeof(kin)); |
| 941 | |
| 942 | error = do_setitimer(which, &kin, out ? &kout : NULL); |
| 943 | if (error || !out) |
| 944 | return error; |
| 945 | |
| 946 | if (put_it32(out, &kout)) |
| 947 | return -EFAULT; |
| 948 | |
| 949 | return 0; |
| 950 | |
| 951 | } |
| 952 | |
| 953 | asmlinkage int |
| 954 | osf_utimes(char __user *filename, struct timeval32 __user *tvs) |
| 955 | { |
| 956 | struct timespec tv[2]; |
| 957 | |
| 958 | if (tvs) { |
| 959 | struct timeval ktvs[2]; |
| 960 | if (get_tv32(&ktvs[0], &tvs[0]) || |
| 961 | get_tv32(&ktvs[1], &tvs[1])) |
| 962 | return -EFAULT; |
| 963 | |
| 964 | if (ktvs[0].tv_usec < 0 || ktvs[0].tv_usec >= 1000000 || |
| 965 | ktvs[1].tv_usec < 0 || ktvs[1].tv_usec >= 1000000) |
| 966 | return -EINVAL; |
| 967 | |
| 968 | tv[0].tv_sec = ktvs[0].tv_sec; |
| 969 | tv[0].tv_nsec = 1000 * ktvs[0].tv_usec; |
| 970 | tv[1].tv_sec = ktvs[1].tv_sec; |
| 971 | tv[1].tv_nsec = 1000 * ktvs[1].tv_usec; |
| 972 | } |
| 973 | |
| 974 | return do_utimes(AT_FDCWD, filename, tvs ? tv : NULL, 0); |
| 975 | } |
| 976 | |
| 977 | #define MAX_SELECT_SECONDS \ |
| 978 | ((unsigned long) (MAX_SCHEDULE_TIMEOUT / HZ)-1) |
| 979 | |
| 980 | asmlinkage int |
| 981 | osf_select(int n, fd_set __user *inp, fd_set __user *outp, fd_set __user *exp, |
| 982 | struct timeval32 __user *tvp) |
| 983 | { |
| 984 | fd_set_bits fds; |
| 985 | char *bits; |
| 986 | size_t size; |
| 987 | long timeout; |
| 988 | int ret = -EINVAL; |
| 989 | struct fdtable *fdt; |
| 990 | int max_fds; |
| 991 | |
| 992 | timeout = MAX_SCHEDULE_TIMEOUT; |
| 993 | if (tvp) { |
| 994 | time_t sec, usec; |
| 995 | |
| 996 | if (!access_ok(VERIFY_READ, tvp, sizeof(*tvp)) |
| 997 | || __get_user(sec, &tvp->tv_sec) |
| 998 | || __get_user(usec, &tvp->tv_usec)) { |
| 999 | ret = -EFAULT; |
| 1000 | goto out_nofds; |
| 1001 | } |
| 1002 | |
| 1003 | if (sec < 0 || usec < 0) |
| 1004 | goto out_nofds; |
| 1005 | |
| 1006 | if ((unsigned long) sec < MAX_SELECT_SECONDS) { |
| 1007 | timeout = (usec + 1000000/HZ - 1) / (1000000/HZ); |
| 1008 | timeout += sec * (unsigned long) HZ; |
| 1009 | } |
| 1010 | } |
| 1011 | |
| 1012 | rcu_read_lock(); |
| 1013 | fdt = files_fdtable(current->files); |
| 1014 | max_fds = fdt->max_fds; |
| 1015 | rcu_read_unlock(); |
| 1016 | if (n < 0 || n > max_fds) |
| 1017 | goto out_nofds; |
| 1018 | |
| 1019 | /* |
| 1020 | * We need 6 bitmaps (in/out/ex for both incoming and outgoing), |
| 1021 | * since we used fdset we need to allocate memory in units of |
| 1022 | * long-words. |
| 1023 | */ |
| 1024 | ret = -ENOMEM; |
| 1025 | size = FDS_BYTES(n); |
| 1026 | bits = kmalloc(6 * size, GFP_KERNEL); |
| 1027 | if (!bits) |
| 1028 | goto out_nofds; |
| 1029 | fds.in = (unsigned long *) bits; |
| 1030 | fds.out = (unsigned long *) (bits + size); |
| 1031 | fds.ex = (unsigned long *) (bits + 2*size); |
| 1032 | fds.res_in = (unsigned long *) (bits + 3*size); |
| 1033 | fds.res_out = (unsigned long *) (bits + 4*size); |
| 1034 | fds.res_ex = (unsigned long *) (bits + 5*size); |
| 1035 | |
| 1036 | if ((ret = get_fd_set(n, inp->fds_bits, fds.in)) || |
| 1037 | (ret = get_fd_set(n, outp->fds_bits, fds.out)) || |
| 1038 | (ret = get_fd_set(n, exp->fds_bits, fds.ex))) |
| 1039 | goto out; |
| 1040 | zero_fd_set(n, fds.res_in); |
| 1041 | zero_fd_set(n, fds.res_out); |
| 1042 | zero_fd_set(n, fds.res_ex); |
| 1043 | |
| 1044 | ret = do_select(n, &fds, &timeout); |
| 1045 | |
| 1046 | /* OSF does not copy back the remaining time. */ |
| 1047 | |
| 1048 | if (ret < 0) |
| 1049 | goto out; |
| 1050 | if (!ret) { |
| 1051 | ret = -ERESTARTNOHAND; |
| 1052 | if (signal_pending(current)) |
| 1053 | goto out; |
| 1054 | ret = 0; |
| 1055 | } |
| 1056 | |
| 1057 | if (set_fd_set(n, inp->fds_bits, fds.res_in) || |
| 1058 | set_fd_set(n, outp->fds_bits, fds.res_out) || |
| 1059 | set_fd_set(n, exp->fds_bits, fds.res_ex)) |
| 1060 | ret = -EFAULT; |
| 1061 | |
| 1062 | out: |
| 1063 | kfree(bits); |
| 1064 | out_nofds: |
| 1065 | return ret; |
| 1066 | } |
| 1067 | |
| 1068 | struct rusage32 { |
| 1069 | struct timeval32 ru_utime; /* user time used */ |
| 1070 | struct timeval32 ru_stime; /* system time used */ |
| 1071 | long ru_maxrss; /* maximum resident set size */ |
| 1072 | long ru_ixrss; /* integral shared memory size */ |
| 1073 | long ru_idrss; /* integral unshared data size */ |
| 1074 | long ru_isrss; /* integral unshared stack size */ |
| 1075 | long ru_minflt; /* page reclaims */ |
| 1076 | long ru_majflt; /* page faults */ |
| 1077 | long ru_nswap; /* swaps */ |
| 1078 | long ru_inblock; /* block input operations */ |
| 1079 | long ru_oublock; /* block output operations */ |
| 1080 | long ru_msgsnd; /* messages sent */ |
| 1081 | long ru_msgrcv; /* messages received */ |
| 1082 | long ru_nsignals; /* signals received */ |
| 1083 | long ru_nvcsw; /* voluntary context switches */ |
| 1084 | long ru_nivcsw; /* involuntary " */ |
| 1085 | }; |
| 1086 | |
| 1087 | asmlinkage int |
| 1088 | osf_getrusage(int who, struct rusage32 __user *ru) |
| 1089 | { |
| 1090 | struct rusage32 r; |
| 1091 | |
| 1092 | if (who != RUSAGE_SELF && who != RUSAGE_CHILDREN) |
| 1093 | return -EINVAL; |
| 1094 | |
| 1095 | memset(&r, 0, sizeof(r)); |
| 1096 | switch (who) { |
| 1097 | case RUSAGE_SELF: |
| 1098 | jiffies_to_timeval32(current->utime, &r.ru_utime); |
| 1099 | jiffies_to_timeval32(current->stime, &r.ru_stime); |
| 1100 | r.ru_minflt = current->min_flt; |
| 1101 | r.ru_majflt = current->maj_flt; |
| 1102 | break; |
| 1103 | case RUSAGE_CHILDREN: |
| 1104 | jiffies_to_timeval32(current->signal->cutime, &r.ru_utime); |
| 1105 | jiffies_to_timeval32(current->signal->cstime, &r.ru_stime); |
| 1106 | r.ru_minflt = current->signal->cmin_flt; |
| 1107 | r.ru_majflt = current->signal->cmaj_flt; |
| 1108 | break; |
| 1109 | } |
| 1110 | |
| 1111 | return copy_to_user(ru, &r, sizeof(r)) ? -EFAULT : 0; |
| 1112 | } |
| 1113 | |
| 1114 | asmlinkage long |
| 1115 | osf_wait4(pid_t pid, int __user *ustatus, int options, |
| 1116 | struct rusage32 __user *ur) |
| 1117 | { |
| 1118 | struct rusage r; |
| 1119 | long ret, err; |
| 1120 | mm_segment_t old_fs; |
| 1121 | |
| 1122 | if (!ur) |
| 1123 | return sys_wait4(pid, ustatus, options, NULL); |
| 1124 | |
| 1125 | old_fs = get_fs(); |
| 1126 | |
| 1127 | set_fs (KERNEL_DS); |
| 1128 | ret = sys_wait4(pid, ustatus, options, (struct rusage __user *) &r); |
| 1129 | set_fs (old_fs); |
| 1130 | |
| 1131 | if (!access_ok(VERIFY_WRITE, ur, sizeof(*ur))) |
| 1132 | return -EFAULT; |
| 1133 | |
| 1134 | err = 0; |
| 1135 | err |= __put_user(r.ru_utime.tv_sec, &ur->ru_utime.tv_sec); |
| 1136 | err |= __put_user(r.ru_utime.tv_usec, &ur->ru_utime.tv_usec); |
| 1137 | err |= __put_user(r.ru_stime.tv_sec, &ur->ru_stime.tv_sec); |
| 1138 | err |= __put_user(r.ru_stime.tv_usec, &ur->ru_stime.tv_usec); |
| 1139 | err |= __put_user(r.ru_maxrss, &ur->ru_maxrss); |
| 1140 | err |= __put_user(r.ru_ixrss, &ur->ru_ixrss); |
| 1141 | err |= __put_user(r.ru_idrss, &ur->ru_idrss); |
| 1142 | err |= __put_user(r.ru_isrss, &ur->ru_isrss); |
| 1143 | err |= __put_user(r.ru_minflt, &ur->ru_minflt); |
| 1144 | err |= __put_user(r.ru_majflt, &ur->ru_majflt); |
| 1145 | err |= __put_user(r.ru_nswap, &ur->ru_nswap); |
| 1146 | err |= __put_user(r.ru_inblock, &ur->ru_inblock); |
| 1147 | err |= __put_user(r.ru_oublock, &ur->ru_oublock); |
| 1148 | err |= __put_user(r.ru_msgsnd, &ur->ru_msgsnd); |
| 1149 | err |= __put_user(r.ru_msgrcv, &ur->ru_msgrcv); |
| 1150 | err |= __put_user(r.ru_nsignals, &ur->ru_nsignals); |
| 1151 | err |= __put_user(r.ru_nvcsw, &ur->ru_nvcsw); |
| 1152 | err |= __put_user(r.ru_nivcsw, &ur->ru_nivcsw); |
| 1153 | |
| 1154 | return err ? err : ret; |
| 1155 | } |
| 1156 | |
| 1157 | /* |
| 1158 | * I don't know what the parameters are: the first one |
| 1159 | * seems to be a timeval pointer, and I suspect the second |
| 1160 | * one is the time remaining.. Ho humm.. No documentation. |
| 1161 | */ |
| 1162 | asmlinkage int |
| 1163 | osf_usleep_thread(struct timeval32 __user *sleep, struct timeval32 __user *remain) |
| 1164 | { |
| 1165 | struct timeval tmp; |
| 1166 | unsigned long ticks; |
| 1167 | |
| 1168 | if (get_tv32(&tmp, sleep)) |
| 1169 | goto fault; |
| 1170 | |
| 1171 | ticks = timeval_to_jiffies(&tmp); |
| 1172 | |
| 1173 | ticks = schedule_timeout_interruptible(ticks); |
| 1174 | |
| 1175 | if (remain) { |
| 1176 | jiffies_to_timeval(ticks, &tmp); |
| 1177 | if (put_tv32(remain, &tmp)) |
| 1178 | goto fault; |
| 1179 | } |
| 1180 | |
| 1181 | return 0; |
| 1182 | fault: |
| 1183 | return -EFAULT; |
| 1184 | } |
| 1185 | |
| 1186 | |
| 1187 | struct timex32 { |
| 1188 | unsigned int modes; /* mode selector */ |
| 1189 | long offset; /* time offset (usec) */ |
| 1190 | long freq; /* frequency offset (scaled ppm) */ |
| 1191 | long maxerror; /* maximum error (usec) */ |
| 1192 | long esterror; /* estimated error (usec) */ |
| 1193 | int status; /* clock command/status */ |
| 1194 | long constant; /* pll time constant */ |
| 1195 | long precision; /* clock precision (usec) (read only) */ |
| 1196 | long tolerance; /* clock frequency tolerance (ppm) |
| 1197 | * (read only) |
| 1198 | */ |
| 1199 | struct timeval32 time; /* (read only) */ |
| 1200 | long tick; /* (modified) usecs between clock ticks */ |
| 1201 | |
| 1202 | long ppsfreq; /* pps frequency (scaled ppm) (ro) */ |
| 1203 | long jitter; /* pps jitter (us) (ro) */ |
| 1204 | int shift; /* interval duration (s) (shift) (ro) */ |
| 1205 | long stabil; /* pps stability (scaled ppm) (ro) */ |
| 1206 | long jitcnt; /* jitter limit exceeded (ro) */ |
| 1207 | long calcnt; /* calibration intervals (ro) */ |
| 1208 | long errcnt; /* calibration errors (ro) */ |
| 1209 | long stbcnt; /* stability limit exceeded (ro) */ |
| 1210 | |
| 1211 | int :32; int :32; int :32; int :32; |
| 1212 | int :32; int :32; int :32; int :32; |
| 1213 | int :32; int :32; int :32; int :32; |
| 1214 | }; |
| 1215 | |
| 1216 | asmlinkage int |
| 1217 | sys_old_adjtimex(struct timex32 __user *txc_p) |
| 1218 | { |
| 1219 | struct timex txc; |
| 1220 | int ret; |
| 1221 | |
| 1222 | /* copy relevant bits of struct timex. */ |
| 1223 | if (copy_from_user(&txc, txc_p, offsetof(struct timex32, time)) || |
| 1224 | copy_from_user(&txc.tick, &txc_p->tick, sizeof(struct timex32) - |
| 1225 | offsetof(struct timex32, time))) |
| 1226 | return -EFAULT; |
| 1227 | |
| 1228 | ret = do_adjtimex(&txc); |
| 1229 | if (ret < 0) |
| 1230 | return ret; |
| 1231 | |
| 1232 | /* copy back to timex32 */ |
| 1233 | if (copy_to_user(txc_p, &txc, offsetof(struct timex32, time)) || |
| 1234 | (copy_to_user(&txc_p->tick, &txc.tick, sizeof(struct timex32) - |
| 1235 | offsetof(struct timex32, tick))) || |
| 1236 | (put_tv32(&txc_p->time, &txc.time))) |
| 1237 | return -EFAULT; |
| 1238 | |
| 1239 | return ret; |
| 1240 | } |
| 1241 | |
| 1242 | /* Get an address range which is currently unmapped. Similar to the |
| 1243 | generic version except that we know how to honor ADDR_LIMIT_32BIT. */ |
| 1244 | |
| 1245 | static unsigned long |
| 1246 | arch_get_unmapped_area_1(unsigned long addr, unsigned long len, |
| 1247 | unsigned long limit) |
| 1248 | { |
| 1249 | struct vm_area_struct *vma = find_vma(current->mm, addr); |
| 1250 | |
| 1251 | while (1) { |
| 1252 | /* At this point: (!vma || addr < vma->vm_end). */ |
| 1253 | if (limit - len < addr) |
| 1254 | return -ENOMEM; |
| 1255 | if (!vma || addr + len <= vma->vm_start) |
| 1256 | return addr; |
| 1257 | addr = vma->vm_end; |
| 1258 | vma = vma->vm_next; |
| 1259 | } |
| 1260 | } |
| 1261 | |
| 1262 | unsigned long |
| 1263 | arch_get_unmapped_area(struct file *filp, unsigned long addr, |
| 1264 | unsigned long len, unsigned long pgoff, |
| 1265 | unsigned long flags) |
| 1266 | { |
| 1267 | unsigned long limit; |
| 1268 | |
| 1269 | /* "32 bit" actually means 31 bit, since pointers sign extend. */ |
| 1270 | if (current->personality & ADDR_LIMIT_32BIT) |
| 1271 | limit = 0x80000000; |
| 1272 | else |
| 1273 | limit = TASK_SIZE; |
| 1274 | |
| 1275 | if (len > limit) |
| 1276 | return -ENOMEM; |
| 1277 | |
| 1278 | if (flags & MAP_FIXED) |
| 1279 | return addr; |
| 1280 | |
| 1281 | /* First, see if the given suggestion fits. |
| 1282 | |
| 1283 | The OSF/1 loader (/sbin/loader) relies on us returning an |
| 1284 | address larger than the requested if one exists, which is |
| 1285 | a terribly broken way to program. |
| 1286 | |
| 1287 | That said, I can see the use in being able to suggest not |
| 1288 | merely specific addresses, but regions of memory -- perhaps |
| 1289 | this feature should be incorporated into all ports? */ |
| 1290 | |
| 1291 | if (addr) { |
| 1292 | addr = arch_get_unmapped_area_1 (PAGE_ALIGN(addr), len, limit); |
| 1293 | if (addr != (unsigned long) -ENOMEM) |
| 1294 | return addr; |
| 1295 | } |
| 1296 | |
| 1297 | /* Next, try allocating at TASK_UNMAPPED_BASE. */ |
| 1298 | addr = arch_get_unmapped_area_1 (PAGE_ALIGN(TASK_UNMAPPED_BASE), |
| 1299 | len, limit); |
| 1300 | if (addr != (unsigned long) -ENOMEM) |
| 1301 | return addr; |
| 1302 | |
| 1303 | /* Finally, try allocating in low memory. */ |
| 1304 | addr = arch_get_unmapped_area_1 (PAGE_SIZE, len, limit); |
| 1305 | |
| 1306 | return addr; |
| 1307 | } |
| 1308 | |
| 1309 | #ifdef CONFIG_OSF4_COMPAT |
| 1310 | |
| 1311 | /* Clear top 32 bits of iov_len in the user's buffer for |
| 1312 | compatibility with old versions of OSF/1 where iov_len |
| 1313 | was defined as int. */ |
| 1314 | static int |
| 1315 | osf_fix_iov_len(const struct iovec __user *iov, unsigned long count) |
| 1316 | { |
| 1317 | unsigned long i; |
| 1318 | |
| 1319 | for (i = 0 ; i < count ; i++) { |
| 1320 | int __user *iov_len_high = (int __user *)&iov[i].iov_len + 1; |
| 1321 | |
| 1322 | if (put_user(0, iov_len_high)) |
| 1323 | return -EFAULT; |
| 1324 | } |
| 1325 | return 0; |
| 1326 | } |
| 1327 | |
| 1328 | asmlinkage ssize_t |
| 1329 | osf_readv(unsigned long fd, const struct iovec __user * vector, unsigned long count) |
| 1330 | { |
| 1331 | if (unlikely(personality(current->personality) == PER_OSF4)) |
| 1332 | if (osf_fix_iov_len(vector, count)) |
| 1333 | return -EFAULT; |
| 1334 | return sys_readv(fd, vector, count); |
| 1335 | } |
| 1336 | |
| 1337 | asmlinkage ssize_t |
| 1338 | osf_writev(unsigned long fd, const struct iovec __user * vector, unsigned long count) |
| 1339 | { |
| 1340 | if (unlikely(personality(current->personality) == PER_OSF4)) |
| 1341 | if (osf_fix_iov_len(vector, count)) |
| 1342 | return -EFAULT; |
| 1343 | return sys_writev(fd, vector, count); |
| 1344 | } |
| 1345 | |
| 1346 | #endif |