posix-clock.c 5.6 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317
  1. // SPDX-License-Identifier: GPL-2.0+
  2. /*
  3. * Support for dynamic clock devices
  4. *
  5. * Copyright (C) 2010 OMICRON electronics GmbH
  6. */
  7. #include <linux/device.h>
  8. #include <linux/export.h>
  9. #include <linux/file.h>
  10. #include <linux/posix-clock.h>
  11. #include <linux/slab.h>
  12. #include <linux/syscalls.h>
  13. #include <linux/uaccess.h>
  14. #include "posix-timers.h"
  15. /*
  16. * Returns NULL if the posix_clock instance attached to 'fp' is old and stale.
  17. */
  18. static struct posix_clock *get_posix_clock(struct file *fp)
  19. {
  20. struct posix_clock *clk = fp->private_data;
  21. down_read(&clk->rwsem);
  22. if (!clk->zombie)
  23. return clk;
  24. up_read(&clk->rwsem);
  25. return NULL;
  26. }
  27. static void put_posix_clock(struct posix_clock *clk)
  28. {
  29. up_read(&clk->rwsem);
  30. }
  31. static ssize_t posix_clock_read(struct file *fp, char __user *buf,
  32. size_t count, loff_t *ppos)
  33. {
  34. struct posix_clock *clk = get_posix_clock(fp);
  35. int err = -EINVAL;
  36. if (!clk)
  37. return -ENODEV;
  38. if (clk->ops.read)
  39. err = clk->ops.read(clk, fp->f_flags, buf, count);
  40. put_posix_clock(clk);
  41. return err;
  42. }
  43. static __poll_t posix_clock_poll(struct file *fp, poll_table *wait)
  44. {
  45. struct posix_clock *clk = get_posix_clock(fp);
  46. __poll_t result = 0;
  47. if (!clk)
  48. return EPOLLERR;
  49. if (clk->ops.poll)
  50. result = clk->ops.poll(clk, fp, wait);
  51. put_posix_clock(clk);
  52. return result;
  53. }
  54. static long posix_clock_ioctl(struct file *fp,
  55. unsigned int cmd, unsigned long arg)
  56. {
  57. struct posix_clock *clk = get_posix_clock(fp);
  58. int err = -ENOTTY;
  59. if (!clk)
  60. return -ENODEV;
  61. if (clk->ops.ioctl)
  62. err = clk->ops.ioctl(clk, cmd, arg);
  63. put_posix_clock(clk);
  64. return err;
  65. }
  66. #ifdef CONFIG_COMPAT
  67. static long posix_clock_compat_ioctl(struct file *fp,
  68. unsigned int cmd, unsigned long arg)
  69. {
  70. struct posix_clock *clk = get_posix_clock(fp);
  71. int err = -ENOTTY;
  72. if (!clk)
  73. return -ENODEV;
  74. if (clk->ops.ioctl)
  75. err = clk->ops.ioctl(clk, cmd, arg);
  76. put_posix_clock(clk);
  77. return err;
  78. }
  79. #endif
  80. static int posix_clock_open(struct inode *inode, struct file *fp)
  81. {
  82. int err;
  83. struct posix_clock *clk =
  84. container_of(inode->i_cdev, struct posix_clock, cdev);
  85. down_read(&clk->rwsem);
  86. if (clk->zombie) {
  87. err = -ENODEV;
  88. goto out;
  89. }
  90. if (clk->ops.open)
  91. err = clk->ops.open(clk, fp->f_mode);
  92. else
  93. err = 0;
  94. if (!err) {
  95. get_device(clk->dev);
  96. fp->private_data = clk;
  97. }
  98. out:
  99. up_read(&clk->rwsem);
  100. return err;
  101. }
  102. static int posix_clock_release(struct inode *inode, struct file *fp)
  103. {
  104. struct posix_clock *clk = fp->private_data;
  105. int err = 0;
  106. if (clk->ops.release)
  107. err = clk->ops.release(clk);
  108. put_device(clk->dev);
  109. fp->private_data = NULL;
  110. return err;
  111. }
  112. static const struct file_operations posix_clock_file_operations = {
  113. .owner = THIS_MODULE,
  114. .llseek = no_llseek,
  115. .read = posix_clock_read,
  116. .poll = posix_clock_poll,
  117. .unlocked_ioctl = posix_clock_ioctl,
  118. .open = posix_clock_open,
  119. .release = posix_clock_release,
  120. #ifdef CONFIG_COMPAT
  121. .compat_ioctl = posix_clock_compat_ioctl,
  122. #endif
  123. };
  124. int posix_clock_register(struct posix_clock *clk, struct device *dev)
  125. {
  126. int err;
  127. init_rwsem(&clk->rwsem);
  128. cdev_init(&clk->cdev, &posix_clock_file_operations);
  129. err = cdev_device_add(&clk->cdev, dev);
  130. if (err) {
  131. pr_err("%s unable to add device %d:%d\n",
  132. dev_name(dev), MAJOR(dev->devt), MINOR(dev->devt));
  133. return err;
  134. }
  135. clk->cdev.owner = clk->ops.owner;
  136. clk->dev = dev;
  137. return 0;
  138. }
  139. EXPORT_SYMBOL_GPL(posix_clock_register);
  140. void posix_clock_unregister(struct posix_clock *clk)
  141. {
  142. cdev_device_del(&clk->cdev, clk->dev);
  143. down_write(&clk->rwsem);
  144. clk->zombie = true;
  145. up_write(&clk->rwsem);
  146. put_device(clk->dev);
  147. }
  148. EXPORT_SYMBOL_GPL(posix_clock_unregister);
  149. struct posix_clock_desc {
  150. struct file *fp;
  151. struct posix_clock *clk;
  152. };
  153. static int get_clock_desc(const clockid_t id, struct posix_clock_desc *cd)
  154. {
  155. struct file *fp = fget(clockid_to_fd(id));
  156. int err = -EINVAL;
  157. if (!fp)
  158. return err;
  159. if (fp->f_op->open != posix_clock_open || !fp->private_data)
  160. goto out;
  161. cd->fp = fp;
  162. cd->clk = get_posix_clock(fp);
  163. err = cd->clk ? 0 : -ENODEV;
  164. out:
  165. if (err)
  166. fput(fp);
  167. return err;
  168. }
  169. static void put_clock_desc(struct posix_clock_desc *cd)
  170. {
  171. put_posix_clock(cd->clk);
  172. fput(cd->fp);
  173. }
  174. static int pc_clock_adjtime(clockid_t id, struct __kernel_timex *tx)
  175. {
  176. struct posix_clock_desc cd;
  177. int err;
  178. err = get_clock_desc(id, &cd);
  179. if (err)
  180. return err;
  181. if ((cd.fp->f_mode & FMODE_WRITE) == 0) {
  182. err = -EACCES;
  183. goto out;
  184. }
  185. if (cd.clk->ops.clock_adjtime)
  186. err = cd.clk->ops.clock_adjtime(cd.clk, tx);
  187. else
  188. err = -EOPNOTSUPP;
  189. out:
  190. put_clock_desc(&cd);
  191. return err;
  192. }
  193. static int pc_clock_gettime(clockid_t id, struct timespec64 *ts)
  194. {
  195. struct posix_clock_desc cd;
  196. int err;
  197. err = get_clock_desc(id, &cd);
  198. if (err)
  199. return err;
  200. if (cd.clk->ops.clock_gettime)
  201. err = cd.clk->ops.clock_gettime(cd.clk, ts);
  202. else
  203. err = -EOPNOTSUPP;
  204. put_clock_desc(&cd);
  205. return err;
  206. }
  207. static int pc_clock_getres(clockid_t id, struct timespec64 *ts)
  208. {
  209. struct posix_clock_desc cd;
  210. int err;
  211. err = get_clock_desc(id, &cd);
  212. if (err)
  213. return err;
  214. if (cd.clk->ops.clock_getres)
  215. err = cd.clk->ops.clock_getres(cd.clk, ts);
  216. else
  217. err = -EOPNOTSUPP;
  218. put_clock_desc(&cd);
  219. return err;
  220. }
  221. static int pc_clock_settime(clockid_t id, const struct timespec64 *ts)
  222. {
  223. struct posix_clock_desc cd;
  224. int err;
  225. err = get_clock_desc(id, &cd);
  226. if (err)
  227. return err;
  228. if ((cd.fp->f_mode & FMODE_WRITE) == 0) {
  229. err = -EACCES;
  230. goto out;
  231. }
  232. if (cd.clk->ops.clock_settime)
  233. err = cd.clk->ops.clock_settime(cd.clk, ts);
  234. else
  235. err = -EOPNOTSUPP;
  236. out:
  237. put_clock_desc(&cd);
  238. return err;
  239. }
  240. const struct k_clock clock_posix_dynamic = {
  241. .clock_getres = pc_clock_getres,
  242. .clock_set = pc_clock_settime,
  243. .clock_get_timespec = pc_clock_gettime,
  244. .clock_adj = pc_clock_adjtime,
  245. };