osf_sys.c 30 KB

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