API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Jul 12th, 2018
160
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Diff 13.43 KB | None | 0 0
raw download clone embed print report
  1. diff --git a/fs/aio.c b/fs/aio.c
  2. index e8623a5e8736..f86781a9cb79 100644
  3. --- a/fs/aio.c
  4. +++ b/fs/aio.c
  5. @@ -1865,6 +1865,7 @@ static long do_io_getevents(aio_context_t ctx_id,
  6.   * specifies an infinite timeout. Note that the timeout pointed to by
  7.   * timeout is relative.  Will fail with -ENOSYS if not implemented.
  8.   */
  9. +#if defined(CONFIG_COMPAT_32BIT_TIME) || defined(CONFIG_64BIT)
  10.  SYSCALL_DEFINE5(io_getevents, aio_context_t, ctx_id,
  11.         long, min_nr,
  12.         long, nr,
  13. @@ -1882,6 +1883,7 @@ SYSCALL_DEFINE5(io_getevents, aio_context_t, ctx_id,
  14.         ret = -EINTR;
  15.     return ret;
  16.  }
  17. +#endif
  18.  
  19.  SYSCALL_DEFINE6(io_pgetevents,
  20.         aio_context_t, ctx_id,
  21. @@ -1928,6 +1930,52 @@ SYSCALL_DEFINE6(io_pgetevents,
  22.     return ret;
  23.  }
  24.  
  25. +#if defined(CONFIG_COMPAT_32BIT_TIME) && !defined(CONFIG_64BIT)
  26. +SYSCALL_DEFINE6(io_pgetevents_time32,
  27. +       compat_aio_context_t, ctx_id,
  28. +       long, min_nr,
  29. +       long, nr,
  30. +       struct io_event __user *, events,
  31. +       struct __kernel_old_timespec __user *, timeout,
  32. +       const struct __aio_sigset __user *, usig)
  33. +{
  34. +   struct __aio_sigset ksig = { NULL, };
  35. +   sigset_t ksigmask, sigsaved;
  36. +   struct timespec64 t;
  37. +   int ret;
  38. +
  39. +   if (timeout && get_old_timespec(&t, timeout))
  40. +       return -EFAULT;
  41. +
  42. +   if (usig && copy_from_user(&ksig, usig, sizeof(ksig)))
  43. +       return -EFAULT;
  44. +
  45. +   if (ksig.sigmask) {
  46. +       if (ksig.sigsetsize != sizeof(ksig))
  47. +           return -EINVAL;
  48. +       if (copy_from_user(&ksigmask, ksig.sigmask, sizeof(ksigmask)))
  49. +           return -EFAULT;
  50. +       sigdelsetmask(&ksigmask, sigmask(SIGKILL) | sigmask(SIGSTOP));
  51. +       sigprocmask(SIG_SETMASK, &ksigmask, &sigsaved);
  52. +   }
  53. +
  54. +   ret = do_io_getevents(ctx_id, min_nr, nr, events, timeout ? &t : NULL);
  55. +   if (signal_pending(current)) {
  56. +       if (ksig.sigmask) {
  57. +           current->saved_sigmask = sigsaved;
  58. +           set_restore_sigmask();
  59. +       }
  60. +       if (!ret)
  61. +           ret = -ERESTARTNOHAND;
  62. +   } else {
  63. +       if (ksig.sigmask)
  64. +           sigprocmask(SIG_SETMASK, &sigsaved, NULL);
  65. +   }
  66. +
  67. +   return ret;
  68. +}
  69. +#endif
  70. +
  71.  #ifdef CONFIG_COMPAT
  72.  struct __compat_aio_sigset {
  73.     compat_sigset_t __user  *sigmask;
  74. @@ -1977,25 +2025,8 @@ COMPAT_SYSCALL_DEFINE6(io_pgetevents_time64,
  75.  
  76.     return ret;
  77.  }
  78. -#endif
  79. -
  80. -#ifdef CONFIG_COMPAT_32BIT_TIME
  81. -#ifndef CONFIG_COMPAT
  82. -#define compat_sigset_t sigset_t
  83. -struct __compat_aio_sigset {
  84. -   compat_sigset_t __user  *sigmask;
  85. -   compat_size_t       sigsetsize;
  86. -};
  87. -
  88. -static inline int get_compat_sigset(sigset_t *set, const sigset_t __user *compat)
  89. -{
  90. -        if (copy_from_user(set, compat, sizeof *set))
  91. -                return -EFAULT;
  92. -
  93. -        return 0;
  94. -}
  95. -#endif
  96.  
  97. +#if defined(CONFIG_COMPAT_32BIT_TIME)
  98.  COMPAT_SYSCALL_DEFINE5(io_getevents, compat_aio_context_t, ctx_id,
  99.                compat_long_t, min_nr,
  100.                compat_long_t, nr,
  101. @@ -2057,4 +2088,5 @@ COMPAT_SYSCALL_DEFINE6(io_pgetevents,
  102.  
  103.     return ret;
  104.  }
  105. -#endif
  106. +#endif /* CONFIG_COMPAT_32BIT_TIME */
  107. +#endif /* CONFIG_COMPAT */
  108. diff --git a/fs/select.c b/fs/select.c
  109. index ffea9a4d8dda..24293bd589ee 100644
  110. --- a/fs/select.c
  111. +++ b/fs/select.c
  112. @@ -1095,7 +1095,171 @@ SYSCALL_DEFINE5(ppoll, struct pollfd __user *, ufds, unsigned int, nfds,
  113.     return ret;
  114.  }
  115.  
  116. -#if defined(CONFIG_COMPAT_32BIT_TIME) || defined(CONFIG_COMPAT)
  117. +#if defined(CONFIG_COMPAT_32BIT_TIME) && !defined(CONFIG_64BIT)
  118. +static
  119. +int poll_select_copy_remaining_time32(struct timespec64 *end_time, void __user *p,
  120. +                     int timeval, int ret)
  121. +{
  122. +   struct timespec64 ts;
  123. +
  124. +   if (!p)
  125. +       return ret;
  126. +
  127. +   if (current->personality & STICKY_TIMEOUTS)
  128. +       goto sticky;
  129. +
  130. +   /* No update for zero timeout */
  131. +   if (!end_time->tv_sec && !end_time->tv_nsec)
  132. +       return ret;
  133. +
  134. +   ktime_get_ts64(&ts);
  135. +   ts = timespec64_sub(*end_time, ts);
  136. +   if (ts.tv_sec < 0)
  137. +       ts.tv_sec = ts.tv_nsec = 0;
  138. +
  139. +   if (timeval) {
  140. +       struct __kernel_old_timeval rtv;
  141. +
  142. +       rtv.tv_sec = ts.tv_sec;
  143. +       rtv.tv_usec = ts.tv_nsec / NSEC_PER_USEC;
  144. +
  145. +       if (!copy_to_user(p, &rtv, sizeof(rtv)))
  146. +           return ret;
  147. +   } else {
  148. +       if (!put_old_timespec(&ts, p))
  149. +           return ret;
  150. +   }
  151. +   /*
  152. +    * If an application puts its timeval in read-only memory, we
  153. +    * don't want the Linux-specific update to the timeval to
  154. +    * cause a fault after the select has completed
  155. +    * successfully. However, because we're not updating the
  156. +    * timeval, we can't restart the system call.
  157. +    */
  158. +
  159. +sticky:
  160. +   if (ret == -ERESTARTNOHAND)
  161. +       ret = -EINTR;
  162. +   return ret;
  163. +}
  164. +
  165. +static long do_pselect_time32(int n, fd_set __user *inp,
  166. +   fd_set __user *outp, fd_set __user *exp,
  167. +   struct __kernel_old_timespec __user *tsp,
  168. +   const sigset_t __user *sigmask, size_t sigsetsize)
  169. +{
  170. +   sigset_t ksigmask, sigsaved;
  171. +   struct timespec64 ts, end_time, *to = NULL;
  172. +   int ret;
  173. +
  174. +   if (tsp) {
  175. +       if (get_old_timespec(&ts, tsp))
  176. +           return -EFAULT;
  177. +
  178. +       to = &end_time;
  179. +       if (poll_select_set_timeout(to, ts.tv_sec, ts.tv_nsec))
  180. +           return -EINVAL;
  181. +   }
  182. +
  183. +   if (sigmask) {
  184. +       if (sigsetsize != sizeof(sigset_t))
  185. +           return -EINVAL;
  186. +       if (copy_from_user(&ksigmask, sigmask, sizeof(ksigmask)))
  187. +           return -EFAULT;
  188. +
  189. +       sigdelsetmask(&ksigmask, sigmask(SIGKILL)|sigmask(SIGSTOP));
  190. +       sigprocmask(SIG_SETMASK, &ksigmask, &sigsaved);
  191. +   }
  192. +
  193. +   ret = core_sys_select(n, inp, outp, exp, to);
  194. +   ret = poll_select_copy_remaining_time32(&end_time, tsp, 0, ret);
  195. +
  196. +   if (ret == -ERESTARTNOHAND) {
  197. +       /*
  198. +        * Don't restore the signal mask yet. Let do_signal() deliver
  199. +        * the signal on the way back to userspace, before the signal
  200. +        * mask is restored.
  201. +        */
  202. +       if (sigmask) {
  203. +           memcpy(&current->saved_sigmask, &sigsaved,
  204. +                   sizeof(sigsaved));
  205. +           set_restore_sigmask();
  206. +       }
  207. +   } else if (sigmask)
  208. +       sigprocmask(SIG_SETMASK, &sigsaved, NULL);
  209. +
  210. +   return ret;
  211. +}
  212. +
  213. +SYSCALL_DEFINE6(pselect6_time32, int, n, fd_set __user *, inp,
  214. +   fd_set __user *, outp, fd_set __user *, exp,
  215. +   struct __kernel_old_timespec __user *, tsp, void __user *, sig)
  216. +{
  217. +   size_t sigsetsize = 0;
  218. +   sigset_t __user *up = NULL;
  219. +
  220. +   if (sig) {
  221. +       if (!access_ok(VERIFY_READ, sig, sizeof(void *)+sizeof(size_t))
  222. +           || __get_user(up, (sigset_t __user * __user *)sig)
  223. +           || __get_user(sigsetsize,
  224. +               (size_t __user *)(sig+sizeof(void *))))
  225. +           return -EFAULT;
  226. +   }
  227. +   return do_pselect_time32(n, inp, outp, exp, tsp, up, sigsetsize);
  228. +}
  229. +
  230. +SYSCALL_DEFINE5(ppoll_time32, struct pollfd __user *, ufds,
  231. +   unsigned int,  nfds, struct __kernel_old_timespec __user *, tsp,
  232. +   const sigset_t __user *, sigmask, size_t, sigsetsize)
  233. +{
  234. +   sigset_t ksigmask, sigsaved;
  235. +   struct timespec64 ts, end_time, *to = NULL;
  236. +   int ret;
  237. +
  238. +   if (tsp) {
  239. +       if (get_old_timespec(&ts, tsp))
  240. +           return -EFAULT;
  241. +
  242. +       to = &end_time;
  243. +       if (poll_select_set_timeout(to, ts.tv_sec, ts.tv_nsec))
  244. +           return -EINVAL;
  245. +   }
  246. +
  247. +   if (sigmask) {
  248. +       if (sigsetsize != sizeof(sigset_t))
  249. +           return -EINVAL;
  250. +       if (copy_from_user(&ksigmask, sigmask, sizeof (ksigmask)))
  251. +           return -EFAULT;
  252. +
  253. +       sigdelsetmask(&ksigmask, sigmask(SIGKILL)|sigmask(SIGSTOP));
  254. +       sigprocmask(SIG_SETMASK, &ksigmask, &sigsaved);
  255. +   }
  256. +
  257. +   ret = do_sys_poll(ufds, nfds, to);
  258. +
  259. +   /* We can restart this syscall, usually */
  260. +   if (ret == -EINTR) {
  261. +       /*
  262. +        * Don't restore the signal mask yet. Let do_signal() deliver
  263. +        * the signal on the way back to userspace, before the signal
  264. +        * mask is restored.
  265. +        */
  266. +       if (sigmask) {
  267. +           memcpy(&current->saved_sigmask, &sigsaved,
  268. +               sizeof(sigsaved));
  269. +           set_restore_sigmask();
  270. +       }
  271. +       ret = -ERESTARTNOHAND;
  272. +   } else if (sigmask)
  273. +       sigprocmask(SIG_SETMASK, &sigsaved, NULL);
  274. +
  275. +   ret = poll_select_copy_remaining_time32(&end_time, tsp, 0, ret);
  276. +
  277. +   return ret;
  278. +}
  279. +#endif /* CONFIG_COMPAT_32BIT_TIME && !CONFIG_64BIT */
  280. +
  281. +#ifdef CONFIG_COMPAT
  282.  #define __COMPAT_NFDBITS       (8 * sizeof(compat_ulong_t))
  283.  
  284.  static
  285. @@ -1145,7 +1309,6 @@ int compat_poll_select_copy_remaining(struct timespec64 *end_time, void __user *
  286.     return ret;
  287.  }
  288.  
  289. -#ifdef CONFIG_COMPAT
  290.  /*
  291.   * Ooo, nasty.  We need here to frob 32-bit unsigned longs to
  292.   * 64-bit unsigned longs.
  293. @@ -1170,18 +1333,6 @@ int compat_set_fd_set(unsigned long nr, compat_ulong_t __user *ufdset,
  294.         return 0;
  295.     return compat_put_bitmap(ufdset, fdset, nr);
  296.  }
  297. -#else
  298. -#define compat_get_fd_set get_fd_set
  299. -#define compat_set_fd_set set_fd_set
  300. -#define compat_sigset_t sigset_t
  301. -static inline int get_compat_sigset(sigset_t *set, const sigset_t __user *compat)
  302. -{
  303. -        if (copy_from_user(set, compat, sizeof *set))
  304. -                return -EFAULT;
  305. -
  306. -        return 0;
  307. -}
  308. -#endif
  309.  
  310.  /*
  311.   * This is a virtual copy of sys_select from fs/select.c and probably
  312. @@ -1266,7 +1417,6 @@ static int compat_core_sys_select(int n, compat_ulong_t __user *inp,
  313.  out_nofds:
  314.     return ret;
  315.  }
  316. -#endif
  317.  
  318.  #ifdef CONFIG_COMPAT_32BIT_TIME
  319.  static int do_compat_select(int n, compat_ulong_t __user *inp,
  320. @@ -1437,7 +1587,6 @@ COMPAT_SYSCALL_DEFINE5(ppoll, struct pollfd __user *, ufds,
  321.  }
  322.  #endif
  323.  
  324. -#ifdef CONFIG_COMPAT
  325.  static long do_compat_pselect_time64(int n, compat_ulong_t __user *inp,
  326.     compat_ulong_t __user *outp, compat_ulong_t __user *exp,
  327.     struct __kernel_timespec __user *tsp, compat_sigset_t __user *sigmask,
  328. diff --git a/kernel/signal.c b/kernel/signal.c
  329. index 332f019dc421..d3e855a0dc45 100644
  330. --- a/kernel/signal.c
  331. +++ b/kernel/signal.c
  332. @@ -3140,6 +3140,40 @@ SYSCALL_DEFINE4(rt_sigtimedwait, const sigset_t __user *, uthese,
  333.     return ret;
  334.  }
  335.  
  336. +#if defined(CONFIG_COMPAT_32BIT_TIME) && !defined(CONFIG_64BIT)
  337. +SYSCALL_DEFINE4(rt_sigtimedwait_time32, sigset_t __user *, uthese,
  338. +       struct siginfo __user *, uinfo,
  339. +       struct __kernel_old_timespec __user *, uts,
  340. +       size_t, sigsetsize)
  341. +{
  342. +   sigset_t s;
  343. +   struct timespec64 t;
  344. +   siginfo_t info;
  345. +   long ret;
  346. +
  347. +   if (sigsetsize != sizeof(sigset_t))
  348. +       return -EINVAL;
  349. +
  350. +   if (copy_from_user(&s, uthese, sizeof(s)))
  351. +       return -EFAULT;
  352. +
  353. +   if (uts) {
  354. +       if (get_old_timespec(&t, uts))
  355. +           return -EFAULT;
  356. +   }
  357. +
  358. +   ret = do_sigtimedwait(&s, &info, uts ? &t : NULL);
  359. +
  360. +   if (ret > 0 && uinfo) {
  361. +       if (copy_siginfo_to_user(uinfo, &info))
  362. +           ret = -EFAULT;
  363. +   }
  364. +
  365. +   return ret;
  366. +}
  367. +#endif
  368. +
  369. +#ifdef CONFIG_COMPAT
  370.  #ifdef CONFIG_COMPAT_32BIT_TIME
  371.  COMPAT_SYSCALL_DEFINE4(rt_sigtimedwait, compat_sigset_t __user *, uthese,
  372.         struct compat_siginfo __user *, uinfo,
  373. @@ -3172,7 +3206,6 @@ COMPAT_SYSCALL_DEFINE4(rt_sigtimedwait, compat_sigset_t __user *, uthese,
  374.  }
  375.  #endif
  376.  
  377. -#ifdef CONFIG_COMPAT
  378.  COMPAT_SYSCALL_DEFINE4(rt_sigtimedwait_time64, compat_sigset_t __user *, uthese,
  379.         struct compat_siginfo __user *, uinfo,
  380.         struct __kernel_timespec __user *, uts, compat_size_t, sigsetsize)
  381. diff --git a/net/compat.c b/net/compat.c
  382. index 5af2af1b9723..54d5f4e749e0 100644
  383. --- a/net/compat.c
  384. +++ b/net/compat.c
  385. @@ -841,6 +841,37 @@ COMPAT_SYSCALL_DEFINE5(recvmmsg_time64, int, fd, struct compat_mmsghdr __user *,
  386.     return __compat_sys_recvmmsg_time64(fd, mmsg, vlen, flags, timeout);
  387.  }
  388.  
  389. +#ifdef CONFIG_COMPAT_32BIT_TIME
  390. +int __compat_sys_recvmmsg(int fd, struct mmsghdr __user *mmsg,
  391. +             unsigned int vlen, unsigned int flags,
  392. +             struct compat_timespec __user *timeout)
  393. +{
  394. +   int datagrams;
  395. +   struct timespec64 ktspec;
  396. +
  397. +   if (timeout == NULL)
  398. +       return __sys_recvmmsg(fd, (struct mmsghdr __user *)mmsg, vlen,
  399. +                     flags | MSG_CMSG_COMPAT, NULL);
  400. +
  401. +   if (compat_get_timespec64(&ktspec, timeout))
  402. +       return -EFAULT;
  403. +
  404. +   datagrams = __sys_recvmmsg(fd, (struct mmsghdr __user *)mmsg, vlen,
  405. +                  flags | MSG_CMSG_COMPAT, &ktspec);
  406. +   if (datagrams > 0 && compat_put_timespec64(&ktspec, timeout))
  407. +       datagrams = -EFAULT;
  408. +
  409. +   return datagrams;
  410. +}
  411. +
  412. +COMPAT_SYSCALL_DEFINE5(recvmmsg, int, fd, struct mmsghdr __user *, mmsg,
  413. +              unsigned int, vlen, unsigned int, flags,
  414. +              struct compat_timespec __user *, timeout)
  415. +{
  416. +   return __compat_sys_recvmmsg(fd, mmsg, vlen, flags, timeout);
  417. +}
  418. +#endif
  419. +
  420.  COMPAT_SYSCALL_DEFINE2(socketcall, int, call, u32 __user *, args)
  421.  {
  422.     u32 a[AUDITSC_ARGS];
  423. diff --git a/net/socket.c b/net/socket.c
  424. index f4b6be81c6af..5d3e24e84974 100644
  425. --- a/net/socket.c
  426. +++ b/net/socket.c
  427. @@ -2474,33 +2474,36 @@ SYSCALL_DEFINE5(recvmmsg, int, fd, struct mmsghdr __user *, mmsg,
  428.  }
  429.  
  430.  #ifdef CONFIG_COMPAT_32BIT_TIME
  431. -int __compat_sys_recvmmsg(int fd, struct mmsghdr __user *mmsg,
  432. +int __sys_recvmmsg_time32(int fd, struct mmsghdr __user *mmsg,
  433.               unsigned int vlen, unsigned int flags,
  434. -             struct compat_timespec __user *timeout)
  435. +             struct __kernel_old_timespec __user *timeout)
  436.  {
  437.     int datagrams;
  438.     struct timespec64 ktspec;
  439.  
  440. +   if (flags & MSG_CMSG_COMPAT)
  441. +       return -EINVAL;
  442. +
  443.     if (timeout == NULL)
  444.         return __sys_recvmmsg(fd, (struct mmsghdr __user *)mmsg, vlen,
  445. -                     flags | MSG_CMSG_COMPAT, NULL);
  446. +                     flags, NULL);
  447.  
  448. -   if (compat_get_timespec64(&ktspec, timeout))
  449. +   if (get_old_timespec(&ktspec, timeout))
  450.         return -EFAULT;
  451.  
  452.     datagrams = __sys_recvmmsg(fd, (struct mmsghdr __user *)mmsg, vlen,
  453. -                  flags | MSG_CMSG_COMPAT, &ktspec);
  454. -   if (datagrams > 0 && compat_put_timespec64(&ktspec, timeout))
  455. +                  flags , &ktspec);
  456. +   if (datagrams > 0 && put_old_timespec(&ktspec, timeout))
  457.         datagrams = -EFAULT;
  458.  
  459.     return datagrams;
  460.  }
  461.  
  462. -COMPAT_SYSCALL_DEFINE5(recvmmsg, int, fd, struct mmsghdr __user *, mmsg,
  463. +SYSCALL_DEFINE5(recvmmsg_time32, int, fd, struct mmsghdr __user *, mmsg,
  464.                unsigned int, vlen, unsigned int, flags,
  465. -              struct compat_timespec __user *, timeout)
  466. +              struct __kernel_old_timespec __user *, timeout)
  467.  {
  468. -   return __compat_sys_recvmmsg(fd, mmsg, vlen, flags, timeout);
  469. +   return __sys_recvmmsg_time32(fd, mmsg, vlen, flags, timeout);
  470.  }
  471.  #endif
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!