kernel/time/posix-clock.c

   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
  15 #include "posix-timers.h"
  16
  17 static void delete_clock(struct kref *kref);
  18
  19 /*
  20  * Returns NULL if the posix_clock instance attached to 'fp' is old and stale.
  21  */
  22 static struct posix_clock *get_posix_clock(struct file *fp)
  23 {
  24         struct posix_clock *clk = fp->private_data;
  25
  26         down_read(&clk->rwsem);
  27
  28         if (!clk->zombie)
  29                 return clk;
  30
  31         up_read(&clk->rwsem);
  32
  33         return NULL;
  34 }
  35
  36 static void put_posix_clock(struct posix_clock *clk)
  37 {
  38         up_read(&clk->rwsem);
  39 }
  40
  41 static ssize_t posix_clock_read(struct file *fp, char __user *buf,
  42                                 size_t count, loff_t *ppos)
  43 {
  44         struct posix_clock *clk = get_posix_clock(fp);
  45         int err = -EINVAL;
  46
  47         if (!clk)
  48                 return -ENODEV;
  49
  50         if (clk->ops.read)
  51                 err = clk->ops.read(clk, fp->f_flags, buf, count);
  52
  53         put_posix_clock(clk);
  54
  55         return err;
  56 }
  57
  58 static __poll_t posix_clock_poll(struct file *fp, poll_table *wait)
  59 {
  60         struct posix_clock *clk = get_posix_clock(fp);
  61         __poll_t result = 0;
  62
  63         if (!clk)
  64                 return EPOLLERR;
  65
  66         if (clk->ops.poll)
  67                 result = clk->ops.poll(clk, fp, wait);
  68
  69         put_posix_clock(clk);
  70
  71         return result;
  72 }
  73
  74 static long posix_clock_ioctl(struct file *fp,
  75                               unsigned int cmd, unsigned long arg)
  76 {
  77         struct posix_clock *clk = get_posix_clock(fp);
  78         int err = -ENOTTY;
  79
  80         if (!clk)
  81                 return -ENODEV;
  82
  83         if (clk->ops.ioctl)
  84                 err = clk->ops.ioctl(clk, cmd, arg);
  85
  86         put_posix_clock(clk);
  87
  88         return err;
  89 }
  90
  91 #ifdef CONFIG_COMPAT
  92 static long posix_clock_compat_ioctl(struct file *fp,
  93                                      unsigned int cmd, unsigned long arg)
  94 {
  95         struct posix_clock *clk = get_posix_clock(fp);
  96         int err = -ENOTTY;
  97
  98         if (!clk)
  99                 return -ENODEV;
 100
 101         if (clk->ops.ioctl)
 102                 err = clk->ops.ioctl(clk, cmd, arg);
 103
 104         put_posix_clock(clk);
 105
 106         return err;
 107 }
 108 #endif
 109
 110 static int posix_clock_open(struct inode *inode, struct file *fp)
 111 {
 112         int err;
 113         struct posix_clock *clk =
 114                 container_of(inode->i_cdev, struct posix_clock, cdev);
 115
 116         down_read(&clk->rwsem);
 117
 118         if (clk->zombie) {
 119                 err = -ENODEV;
 120                 goto out;
 121         }
 122         if (clk->ops.open)
 123                 err = clk->ops.open(clk, fp->f_mode);
 124         else
 125                 err = 0;
 126
 127         if (!err) {
 128                 kref_get(&clk->kref);
 129                 fp->private_data = clk;
 130         }
 131 out:
 132         up_read(&clk->rwsem);
 133         return err;
 134 }
 135
 136 static int posix_clock_release(struct inode *inode, struct file *fp)
 137 {
 138         struct posix_clock *clk = fp->private_data;
 139         int err = 0;
 140
 141         if (clk->ops.release)
 142                 err = clk->ops.release(clk);
 143
 144         kref_put(&clk->kref, delete_clock);
 145
 146         fp->private_data = NULL;
 147
 148         return err;
 149 }
 150
 151 static const struct file_operations posix_clock_file_operations = {
 152         .owner          = THIS_MODULE,
 153         .llseek         = no_llseek,
 154         .read           = posix_clock_read,
 155         .poll           = posix_clock_poll,
 156         .unlocked_ioctl = posix_clock_ioctl,
 157         .open           = posix_clock_open,
 158         .release        = posix_clock_release,
 159 #ifdef CONFIG_COMPAT
 160         .compat_ioctl   = posix_clock_compat_ioctl,
 161 #endif
 162 };
 163
 164 int posix_clock_register(struct posix_clock *clk, dev_t devid)
 165 {
 166         int err;
 167
 168         kref_init(&clk->kref);
 169         init_rwsem(&clk->rwsem);
 170
 171         cdev_init(&clk->cdev, &posix_clock_file_operations);
 172         clk->cdev.owner = clk->ops.owner;
 173         err = cdev_add(&clk->cdev, devid, 1);
 174
 175         return err;
 176 }
 177 EXPORT_SYMBOL_GPL(posix_clock_register);
 178
 179 static void delete_clock(struct kref *kref)
 180 {
 181         struct posix_clock *clk = container_of(kref, struct posix_clock, kref);
 182
 183         if (clk->release)
 184                 clk->release(clk);
 185 }
 186
 187 void posix_clock_unregister(struct posix_clock *clk)
 188 {
 189         cdev_del(&clk->cdev);
 190
 191         down_write(&clk->rwsem);
 192         clk->zombie = true;
 193         up_write(&clk->rwsem);
 194
 195         kref_put(&clk->kref, delete_clock);
 196 }
 197 EXPORT_SYMBOL_GPL(posix_clock_unregister);
 198
 199 struct posix_clock_desc {
 200         struct file *fp;
 201         struct posix_clock *clk;
 202 };
 203
 204 static int get_clock_desc(const clockid_t id, struct posix_clock_desc *cd)
 205 {
 206         struct file *fp = fget(clockid_to_fd(id));
 207         int err = -EINVAL;
 208
 209         if (!fp)
 210                 return err;
 211
 212         if (fp->f_op->open != posix_clock_open || !fp->private_data)
 213                 goto out;
 214
 215         cd->fp = fp;
 216         cd->clk = get_posix_clock(fp);
 217
 218         err = cd->clk ? 0 : -ENODEV;
 219 out:
 220         if (err)
 221                 fput(fp);
 222         return err;
 223 }
 224
 225 static void put_clock_desc(struct posix_clock_desc *cd)
 226 {
 227         put_posix_clock(cd->clk);
 228         fput(cd->fp);
 229 }
 230
 231 static int pc_clock_adjtime(clockid_t id, struct __kernel_timex *tx)
 232 {
 233         struct posix_clock_desc cd;
 234         int err;
 235
 236         err = get_clock_desc(id, &cd);
 237         if (err)
 238                 return err;
 239
 240         if ((cd.fp->f_mode & FMODE_WRITE) == 0) {
 241                 err = -EACCES;
 242                 goto out;
 243         }
 244
 245         if (cd.clk->ops.clock_adjtime)
 246                 err = cd.clk->ops.clock_adjtime(cd.clk, tx);
 247         else
 248                 err = -EOPNOTSUPP;
 249 out:
 250         put_clock_desc(&cd);
 251
 252         return err;
 253 }
 254
 255 static int pc_clock_gettime(clockid_t id, struct timespec64 *ts)
 256 {
 257         struct posix_clock_desc cd;
 258         int err;
 259
 260         err = get_clock_desc(id, &cd);
 261         if (err)
 262                 return err;
 263
 264         if (cd.clk->ops.clock_gettime)
 265                 err = cd.clk->ops.clock_gettime(cd.clk, ts);
 266         else
 267                 err = -EOPNOTSUPP;
 268
 269         put_clock_desc(&cd);
 270
 271         return err;
 272 }
 273
 274 static int pc_clock_getres(clockid_t id, struct timespec64 *ts)
 275 {
 276         struct posix_clock_desc cd;
 277         int err;
 278
 279         err = get_clock_desc(id, &cd);
 280         if (err)
 281                 return err;
 282
 283         if (cd.clk->ops.clock_getres)
 284                 err = cd.clk->ops.clock_getres(cd.clk, ts);
 285         else
 286                 err = -EOPNOTSUPP;
 287
 288         put_clock_desc(&cd);
 289
 290         return err;
 291 }
 292
 293 static int pc_clock_settime(clockid_t id, const struct timespec64 *ts)
 294 {
 295         struct posix_clock_desc cd;
 296         int err;
 297
 298         err = get_clock_desc(id, &cd);
 299         if (err)
 300                 return err;
 301
 302         if ((cd.fp->f_mode & FMODE_WRITE) == 0) {
 303                 err = -EACCES;
 304                 goto out;
 305         }
 306
 307         if (cd.clk->ops.clock_settime)
 308                 err = cd.clk->ops.clock_settime(cd.clk, ts);
 309         else
 310                 err = -EOPNOTSUPP;
 311 out:
 312         put_clock_desc(&cd);
 313
 314         return err;
 315 }
 316
 317 const struct k_clock clock_posix_dynamic = {
 318         .clock_getres   = pc_clock_getres,
 319         .clock_set      = pc_clock_settime,
 320         .clock_get      = pc_clock_gettime,
 321         .clock_adj      = pc_clock_adjtime,
 322 };