sys_oabi-compat.c 12 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /*
  3. * arch/arm/kernel/sys_oabi-compat.c
  4. *
  5. * Compatibility wrappers for syscalls that are used from
  6. * old ABI user space binaries with an EABI kernel.
  7. *
  8. * Author: Nicolas Pitre
  9. * Created: Oct 7, 2005
  10. * Copyright: MontaVista Software, Inc.
  11. */
  12. /*
  13. * The legacy ABI and the new ARM EABI have different rules making some
  14. * syscalls incompatible especially with structure arguments.
  15. * Most notably, Eabi says 64-bit members should be 64-bit aligned instead of
  16. * simply word aligned. EABI also pads structures to the size of the largest
  17. * member it contains instead of the invariant 32-bit.
  18. *
  19. * The following syscalls are affected:
  20. *
  21. * sys_stat64:
  22. * sys_lstat64:
  23. * sys_fstat64:
  24. * sys_fstatat64:
  25. *
  26. * struct stat64 has different sizes and some members are shifted
  27. * Compatibility wrappers are needed for them and provided below.
  28. *
  29. * sys_fcntl64:
  30. *
  31. * struct flock64 has different sizes and some members are shifted
  32. * A compatibility wrapper is needed and provided below.
  33. *
  34. * sys_statfs64:
  35. * sys_fstatfs64:
  36. *
  37. * struct statfs64 has extra padding with EABI growing its size from
  38. * 84 to 88. This struct is now __attribute__((packed,aligned(4)))
  39. * with a small assembly wrapper to force the sz argument to 84 if it is 88
  40. * to avoid copying the extra padding over user space unexpecting it.
  41. *
  42. * sys_newuname:
  43. *
  44. * struct new_utsname has no padding with EABI. No problem there.
  45. *
  46. * sys_epoll_ctl:
  47. * sys_epoll_wait:
  48. *
  49. * struct epoll_event has its second member shifted also affecting the
  50. * structure size. Compatibility wrappers are needed and provided below.
  51. *
  52. * sys_ipc:
  53. * sys_semop:
  54. * sys_semtimedop:
  55. *
  56. * struct sembuf loses its padding with EABI. Since arrays of them are
  57. * used they have to be copyed to remove the padding. Compatibility wrappers
  58. * provided below.
  59. *
  60. * sys_bind:
  61. * sys_connect:
  62. * sys_sendmsg:
  63. * sys_sendto:
  64. * sys_socketcall:
  65. *
  66. * struct sockaddr_un loses its padding with EABI. Since the size of the
  67. * structure is used as a validation test in unix_mkname(), we need to
  68. * change the length argument to 110 whenever it is 112. Compatibility
  69. * wrappers provided below.
  70. */
  71. #include <linux/syscalls.h>
  72. #include <linux/errno.h>
  73. #include <linux/fs.h>
  74. #include <linux/cred.h>
  75. #include <linux/fcntl.h>
  76. #include <linux/eventpoll.h>
  77. #include <linux/sem.h>
  78. #include <linux/socket.h>
  79. #include <linux/net.h>
  80. #include <linux/ipc.h>
  81. #include <linux/uaccess.h>
  82. #include <linux/slab.h>
  83. struct oldabi_stat64 {
  84. unsigned long long st_dev;
  85. unsigned int __pad1;
  86. unsigned long __st_ino;
  87. unsigned int st_mode;
  88. unsigned int st_nlink;
  89. unsigned long st_uid;
  90. unsigned long st_gid;
  91. unsigned long long st_rdev;
  92. unsigned int __pad2;
  93. long long st_size;
  94. unsigned long st_blksize;
  95. unsigned long long st_blocks;
  96. unsigned long st_atime;
  97. unsigned long st_atime_nsec;
  98. unsigned long st_mtime;
  99. unsigned long st_mtime_nsec;
  100. unsigned long st_ctime;
  101. unsigned long st_ctime_nsec;
  102. unsigned long long st_ino;
  103. } __attribute__ ((packed,aligned(4)));
  104. static long cp_oldabi_stat64(struct kstat *stat,
  105. struct oldabi_stat64 __user *statbuf)
  106. {
  107. struct oldabi_stat64 tmp;
  108. tmp.st_dev = huge_encode_dev(stat->dev);
  109. tmp.__pad1 = 0;
  110. tmp.__st_ino = stat->ino;
  111. tmp.st_mode = stat->mode;
  112. tmp.st_nlink = stat->nlink;
  113. tmp.st_uid = from_kuid_munged(current_user_ns(), stat->uid);
  114. tmp.st_gid = from_kgid_munged(current_user_ns(), stat->gid);
  115. tmp.st_rdev = huge_encode_dev(stat->rdev);
  116. tmp.st_size = stat->size;
  117. tmp.st_blocks = stat->blocks;
  118. tmp.__pad2 = 0;
  119. tmp.st_blksize = stat->blksize;
  120. tmp.st_atime = stat->atime.tv_sec;
  121. tmp.st_atime_nsec = stat->atime.tv_nsec;
  122. tmp.st_mtime = stat->mtime.tv_sec;
  123. tmp.st_mtime_nsec = stat->mtime.tv_nsec;
  124. tmp.st_ctime = stat->ctime.tv_sec;
  125. tmp.st_ctime_nsec = stat->ctime.tv_nsec;
  126. tmp.st_ino = stat->ino;
  127. return copy_to_user(statbuf,&tmp,sizeof(tmp)) ? -EFAULT : 0;
  128. }
  129. asmlinkage long sys_oabi_stat64(const char __user * filename,
  130. struct oldabi_stat64 __user * statbuf)
  131. {
  132. struct kstat stat;
  133. int error = vfs_stat(filename, &stat);
  134. if (!error)
  135. error = cp_oldabi_stat64(&stat, statbuf);
  136. return error;
  137. }
  138. asmlinkage long sys_oabi_lstat64(const char __user * filename,
  139. struct oldabi_stat64 __user * statbuf)
  140. {
  141. struct kstat stat;
  142. int error = vfs_lstat(filename, &stat);
  143. if (!error)
  144. error = cp_oldabi_stat64(&stat, statbuf);
  145. return error;
  146. }
  147. asmlinkage long sys_oabi_fstat64(unsigned long fd,
  148. struct oldabi_stat64 __user * statbuf)
  149. {
  150. struct kstat stat;
  151. int error = vfs_fstat(fd, &stat);
  152. if (!error)
  153. error = cp_oldabi_stat64(&stat, statbuf);
  154. return error;
  155. }
  156. asmlinkage long sys_oabi_fstatat64(int dfd,
  157. const char __user *filename,
  158. struct oldabi_stat64 __user *statbuf,
  159. int flag)
  160. {
  161. struct kstat stat;
  162. int error;
  163. error = vfs_fstatat(dfd, filename, &stat, flag);
  164. if (error)
  165. return error;
  166. return cp_oldabi_stat64(&stat, statbuf);
  167. }
  168. struct oabi_flock64 {
  169. short l_type;
  170. short l_whence;
  171. loff_t l_start;
  172. loff_t l_len;
  173. pid_t l_pid;
  174. } __attribute__ ((packed,aligned(4)));
  175. static long do_locks(unsigned int fd, unsigned int cmd,
  176. unsigned long arg)
  177. {
  178. struct flock64 kernel;
  179. struct oabi_flock64 user;
  180. mm_segment_t fs;
  181. long ret;
  182. if (copy_from_user(&user, (struct oabi_flock64 __user *)arg,
  183. sizeof(user)))
  184. return -EFAULT;
  185. kernel.l_type = user.l_type;
  186. kernel.l_whence = user.l_whence;
  187. kernel.l_start = user.l_start;
  188. kernel.l_len = user.l_len;
  189. kernel.l_pid = user.l_pid;
  190. fs = get_fs();
  191. set_fs(KERNEL_DS);
  192. ret = sys_fcntl64(fd, cmd, (unsigned long)&kernel);
  193. set_fs(fs);
  194. if (!ret && (cmd == F_GETLK64 || cmd == F_OFD_GETLK)) {
  195. user.l_type = kernel.l_type;
  196. user.l_whence = kernel.l_whence;
  197. user.l_start = kernel.l_start;
  198. user.l_len = kernel.l_len;
  199. user.l_pid = kernel.l_pid;
  200. if (copy_to_user((struct oabi_flock64 __user *)arg,
  201. &user, sizeof(user)))
  202. ret = -EFAULT;
  203. }
  204. return ret;
  205. }
  206. asmlinkage long sys_oabi_fcntl64(unsigned int fd, unsigned int cmd,
  207. unsigned long arg)
  208. {
  209. switch (cmd) {
  210. case F_OFD_GETLK:
  211. case F_OFD_SETLK:
  212. case F_OFD_SETLKW:
  213. case F_GETLK64:
  214. case F_SETLK64:
  215. case F_SETLKW64:
  216. return do_locks(fd, cmd, arg);
  217. default:
  218. return sys_fcntl64(fd, cmd, arg);
  219. }
  220. }
  221. struct oabi_epoll_event {
  222. __u32 events;
  223. __u64 data;
  224. } __attribute__ ((packed,aligned(4)));
  225. #ifdef CONFIG_EPOLL
  226. asmlinkage long sys_oabi_epoll_ctl(int epfd, int op, int fd,
  227. struct oabi_epoll_event __user *event)
  228. {
  229. struct oabi_epoll_event user;
  230. struct epoll_event kernel;
  231. if (ep_op_has_event(op) &&
  232. copy_from_user(&user, event, sizeof(user)))
  233. return -EFAULT;
  234. kernel.events = user.events;
  235. kernel.data = user.data;
  236. return do_epoll_ctl(epfd, op, fd, &kernel, false);
  237. }
  238. asmlinkage long sys_oabi_epoll_wait(int epfd,
  239. struct oabi_epoll_event __user *events,
  240. int maxevents, int timeout)
  241. {
  242. struct epoll_event *kbuf;
  243. struct oabi_epoll_event e;
  244. mm_segment_t fs;
  245. long ret, err, i;
  246. if (maxevents <= 0 ||
  247. maxevents > (INT_MAX/sizeof(*kbuf)) ||
  248. maxevents > (INT_MAX/sizeof(*events)))
  249. return -EINVAL;
  250. if (!access_ok(events, sizeof(*events) * maxevents))
  251. return -EFAULT;
  252. kbuf = kmalloc_array(maxevents, sizeof(*kbuf), GFP_KERNEL);
  253. if (!kbuf)
  254. return -ENOMEM;
  255. fs = get_fs();
  256. set_fs(KERNEL_DS);
  257. ret = sys_epoll_wait(epfd, kbuf, maxevents, timeout);
  258. set_fs(fs);
  259. err = 0;
  260. for (i = 0; i < ret; i++) {
  261. e.events = kbuf[i].events;
  262. e.data = kbuf[i].data;
  263. err = __copy_to_user(events, &e, sizeof(e));
  264. if (err)
  265. break;
  266. events++;
  267. }
  268. kfree(kbuf);
  269. return err ? -EFAULT : ret;
  270. }
  271. #else
  272. asmlinkage long sys_oabi_epoll_ctl(int epfd, int op, int fd,
  273. struct oabi_epoll_event __user *event)
  274. {
  275. return -EINVAL;
  276. }
  277. asmlinkage long sys_oabi_epoll_wait(int epfd,
  278. struct oabi_epoll_event __user *events,
  279. int maxevents, int timeout)
  280. {
  281. return -EINVAL;
  282. }
  283. #endif
  284. struct oabi_sembuf {
  285. unsigned short sem_num;
  286. short sem_op;
  287. short sem_flg;
  288. unsigned short __pad;
  289. };
  290. asmlinkage long sys_oabi_semtimedop(int semid,
  291. struct oabi_sembuf __user *tsops,
  292. unsigned nsops,
  293. const struct old_timespec32 __user *timeout)
  294. {
  295. struct sembuf *sops;
  296. struct old_timespec32 local_timeout;
  297. long err;
  298. int i;
  299. if (nsops < 1 || nsops > SEMOPM)
  300. return -EINVAL;
  301. if (!access_ok(tsops, sizeof(*tsops) * nsops))
  302. return -EFAULT;
  303. sops = kmalloc_array(nsops, sizeof(*sops), GFP_KERNEL);
  304. if (!sops)
  305. return -ENOMEM;
  306. err = 0;
  307. for (i = 0; i < nsops; i++) {
  308. struct oabi_sembuf osb;
  309. err |= __copy_from_user(&osb, tsops, sizeof(osb));
  310. sops[i].sem_num = osb.sem_num;
  311. sops[i].sem_op = osb.sem_op;
  312. sops[i].sem_flg = osb.sem_flg;
  313. tsops++;
  314. }
  315. if (timeout) {
  316. /* copy this as well before changing domain protection */
  317. err |= copy_from_user(&local_timeout, timeout, sizeof(*timeout));
  318. timeout = &local_timeout;
  319. }
  320. if (err) {
  321. err = -EFAULT;
  322. } else {
  323. mm_segment_t fs = get_fs();
  324. set_fs(KERNEL_DS);
  325. err = sys_semtimedop_time32(semid, sops, nsops, timeout);
  326. set_fs(fs);
  327. }
  328. kfree(sops);
  329. return err;
  330. }
  331. asmlinkage long sys_oabi_semop(int semid, struct oabi_sembuf __user *tsops,
  332. unsigned nsops)
  333. {
  334. return sys_oabi_semtimedop(semid, tsops, nsops, NULL);
  335. }
  336. asmlinkage int sys_oabi_ipc(uint call, int first, int second, int third,
  337. void __user *ptr, long fifth)
  338. {
  339. switch (call & 0xffff) {
  340. case SEMOP:
  341. return sys_oabi_semtimedop(first,
  342. (struct oabi_sembuf __user *)ptr,
  343. second, NULL);
  344. case SEMTIMEDOP:
  345. return sys_oabi_semtimedop(first,
  346. (struct oabi_sembuf __user *)ptr,
  347. second,
  348. (const struct old_timespec32 __user *)fifth);
  349. default:
  350. return sys_ipc(call, first, second, third, ptr, fifth);
  351. }
  352. }
  353. asmlinkage long sys_oabi_bind(int fd, struct sockaddr __user *addr, int addrlen)
  354. {
  355. sa_family_t sa_family;
  356. if (addrlen == 112 &&
  357. get_user(sa_family, &addr->sa_family) == 0 &&
  358. sa_family == AF_UNIX)
  359. addrlen = 110;
  360. return sys_bind(fd, addr, addrlen);
  361. }
  362. asmlinkage long sys_oabi_connect(int fd, struct sockaddr __user *addr, int addrlen)
  363. {
  364. sa_family_t sa_family;
  365. if (addrlen == 112 &&
  366. get_user(sa_family, &addr->sa_family) == 0 &&
  367. sa_family == AF_UNIX)
  368. addrlen = 110;
  369. return sys_connect(fd, addr, addrlen);
  370. }
  371. asmlinkage long sys_oabi_sendto(int fd, void __user *buff,
  372. size_t len, unsigned flags,
  373. struct sockaddr __user *addr,
  374. int addrlen)
  375. {
  376. sa_family_t sa_family;
  377. if (addrlen == 112 &&
  378. get_user(sa_family, &addr->sa_family) == 0 &&
  379. sa_family == AF_UNIX)
  380. addrlen = 110;
  381. return sys_sendto(fd, buff, len, flags, addr, addrlen);
  382. }
  383. asmlinkage long sys_oabi_sendmsg(int fd, struct user_msghdr __user *msg, unsigned flags)
  384. {
  385. struct sockaddr __user *addr;
  386. int msg_namelen;
  387. sa_family_t sa_family;
  388. if (msg &&
  389. get_user(msg_namelen, &msg->msg_namelen) == 0 &&
  390. msg_namelen == 112 &&
  391. get_user(addr, &msg->msg_name) == 0 &&
  392. get_user(sa_family, &addr->sa_family) == 0 &&
  393. sa_family == AF_UNIX)
  394. {
  395. /*
  396. * HACK ALERT: there is a limit to how much backward bending
  397. * we should do for what is actually a transitional
  398. * compatibility layer. This already has known flaws with
  399. * a few ioctls that we don't intend to fix. Therefore
  400. * consider this blatent hack as another one... and take care
  401. * to run for cover. In most cases it will "just work fine".
  402. * If it doesn't, well, tough.
  403. */
  404. put_user(110, &msg->msg_namelen);
  405. }
  406. return sys_sendmsg(fd, msg, flags);
  407. }
  408. asmlinkage long sys_oabi_socketcall(int call, unsigned long __user *args)
  409. {
  410. unsigned long r = -EFAULT, a[6];
  411. switch (call) {
  412. case SYS_BIND:
  413. if (copy_from_user(a, args, 3 * sizeof(long)) == 0)
  414. r = sys_oabi_bind(a[0], (struct sockaddr __user *)a[1], a[2]);
  415. break;
  416. case SYS_CONNECT:
  417. if (copy_from_user(a, args, 3 * sizeof(long)) == 0)
  418. r = sys_oabi_connect(a[0], (struct sockaddr __user *)a[1], a[2]);
  419. break;
  420. case SYS_SENDTO:
  421. if (copy_from_user(a, args, 6 * sizeof(long)) == 0)
  422. r = sys_oabi_sendto(a[0], (void __user *)a[1], a[2], a[3],
  423. (struct sockaddr __user *)a[4], a[5]);
  424. break;
  425. case SYS_SENDMSG:
  426. if (copy_from_user(a, args, 3 * sizeof(long)) == 0)
  427. r = sys_oabi_sendmsg(a[0], (struct user_msghdr __user *)a[1], a[2]);
  428. break;
  429. default:
  430. r = sys_socketcall(call, args);
  431. }
  432. return r;
  433. }