clockid_to_kclock

static const struct k_clock *clockid_to_kclock(const clockid_t id)
{
    clockid_t idx = id;

    if (id < 0) {
        return (id & CLOCKFD_MASK) == CLOCKFD ?
            &clock_posix_dynamic : &clock_posix_cpu;
    }

    if (id >= ARRAY_SIZE(posix_clocks))
        return NULL;

    return posix_clocks[array_index_nospec(idx, ARRAY_SIZE(posix_clocks))];
}

static const struct k_clock * const posix_clocks[] = {
    [CLOCK_REALTIME]        = &clock_realtime,
    [CLOCK_MONOTONIC]        = &clock_monotonic,
    [CLOCK_PROCESS_CPUTIME_ID]    = &clock_process,
    [CLOCK_THREAD_CPUTIME_ID]    = &clock_thread,
    [CLOCK_MONOTONIC_RAW]        = &clock_monotonic_raw,
    [CLOCK_REALTIME_COARSE]        = &clock_realtime_coarse,
    [CLOCK_MONOTONIC_COARSE]    = &clock_monotonic_coarse,
    [CLOCK_BOOTTIME]        = &clock_boottime,
    [CLOCK_REALTIME_ALARM]        = &alarm_clock,
    [CLOCK_BOOTTIME_ALARM]        = &alarm_clock,
    [CLOCK_TAI]            = &clock_tai,
};

const struct k_clock clock_posix_dynamic = {
    .clock_getres    = pc_clock_getres,
    .clock_set    = pc_clock_settime,
    .clock_get    = pc_clock_gettime,
    .clock_adj    = pc_clock_adjtime,
};

static int pc_clock_gettime(clockid_t id, struct timespec64 *ts)
{
    struct posix_clock_desc cd;
    int err;

    err = get_clock_desc(id, &cd);
    if (err)
        return err;

    if (cd.clk->ops.clock_gettime)
        err = cd.clk->ops.clock_gettime(cd.clk, ts);
    else
        err = -EOPNOTSUPP;

    put_clock_desc(&cd);

    return err;
}

static int get_clock_desc(const clockid_t id, struct posix_clock_desc *cd)
{
    struct file *fp = fget(clockid_to_fd(id));
    int err = -EINVAL;

    if (!fp)
        return err;

    if (fp->f_op->open != posix_clock_open || !fp->private_data)
        goto out;

    cd->fp = fp;
    cd->clk = get_posix_clock(fp);

    err = cd->clk ? 0 : -ENODEV;
out:
    if (err)
        fput(fp);
    return err;
}

static inline int clockid_to_fd(const clockid_t clk)
{
    return ~(clk >> 3);
}

struct file *fget(unsigned int fd)
{
    return __fget(fd, FMODE_PATH, 1);
}

static struct file *__fget(unsigned int fd, fmode_t mask, unsigned int refs)
{
    struct files_struct *files = current->files;
    struct file *file;

    rcu_read_lock();
loop:
    file = fcheck_files(files, fd);
    if (file) {
        /* File object ref couldn't be taken.
         * dup2() atomicity guarantee is the reason
         * we loop to catch the new file (or NULL pointer)
         */
        if (file->f_mode & mask)
            file = NULL;
        else if (!get_file_rcu_many(file, refs))
            goto loop;
    }
    rcu_read_unlock();

    return file;
}

static struct posix_clock *get_posix_clock(struct file *fp)
{
    struct posix_clock *clk = fp->private_data;

    down_read(&clk->rwsem);

    if (!clk->zombie)
        return clk;

    up_read(&clk->rwsem);

    return NULL;
}

app:

#define CLOCKFD 3

#define FD_TO_CLOCKID(fd)       ((clockid_t) ((((unsigned int) ~fd) << 3) | CLOCKFD))

time_fd = open("/dev/ptp0", O_RDONLY);

struct timespec tp;

clock_gettime(FD_TO_CLOCKID(time_fd), &tp);