Date: Fri, 29 Sep 2023 16:43:21 -0700
From: Vinicius Costa Gomes <vinicius.gomes@...el.com>
To: Xabier Marquiegui <reibax@...il.com>, netdev@...r.kernel.org
Cc: richardcochran@...il.com, horms@...nel.org,
 chrony-dev@...ony.tuxfamily.org, mlichvar@...hat.com, reibax@...il.com,
 ntp-lists@...tcorallo.com, alex.maftei@....com, davem@...emloft.net,
 rrameshbabu@...dia.com, shuah@...nel.org
Subject: Re: [PATCH net-next v3 2/3] ptp: support multiple timestamp event
 readers

Xabier Marquiegui <reibax@...il.com> writes:

> Use linked lists to create one event queue per open file. This enables
> simultaneous readers for timestamp event queues.
>
> Signed-off-by: Xabier Marquiegui <reibax@...il.com>
> Suggested-by: Richard Cochran <richardcochran@...il.com>
> ---
> v3:
>   - fix use of safe and non safe linked lists for loops
>   - introduce new posix_clock private_data and ida object ids for better
>     dicrimination of timestamp consumers
>   - safer resource release procedures
> v2: https://lore.kernel.org/netdev/20230912220217.2008895-2-reibax@gmail.com/
>   - fix ptp_poll() return value
>   - Style changes to comform to checkpatch strict suggestions
>   - more coherent ptp_read error exit routines
> v1: https://lore.kernel.org/netdev/20230906104754.1324412-3-reibax@gmail.com/
>
>  drivers/ptp/ptp_chardev.c   | 134 ++++++++++++++++++++++++++++--------
>  drivers/ptp/ptp_clock.c     |  61 +++++++++++++---
>  drivers/ptp/ptp_private.h   |  38 +++++++---
>  drivers/ptp/ptp_sysfs.c     |  10 ++-
>  include/linux/posix-clock.h |  24 ++++---
>  kernel/time/posix-clock.c   |  43 +++++++++---
>  6 files changed, 239 insertions(+), 71 deletions(-)
>
> diff --git a/drivers/ptp/ptp_chardev.c b/drivers/ptp/ptp_chardev.c
> index 197edf1179f1..65e7acaa40a9 100644
> --- a/drivers/ptp/ptp_chardev.c
> +++ b/drivers/ptp/ptp_chardev.c
> @@ -101,14 +101,74 @@ int ptp_set_pinfunc(struct ptp_clock *ptp, unsigned int pin,
>  	return 0;
>  }
>  
> -int ptp_open(struct posix_clock *pc, fmode_t fmode)
> +int ptp_open(struct posix_clock_user *pcuser, fmode_t fmode)
>  {
> +	struct ptp_clock *ptp =
> +		container_of(pcuser->clk, struct ptp_clock, clock);
> +	struct ida *ida = ptp_get_tsevq_ida(ptp);
> +	struct timestamp_event_queue *queue;
> +
> +	if (!ida)
> +		return -EINVAL;
> +	queue = kzalloc(sizeof(*queue), GFP_KERNEL);
> +	if (!queue)
> +		return -EINVAL;
> +	queue->close_req = false;
> +	queue->reader_pid = task_pid_nr(current);
> +	spin_lock_init(&queue->lock);
> +	queue->ida = ida;
> +	queue->oid = ida_alloc(ida, GFP_KERNEL);
> +	if (queue->oid < 0) {
> +		kfree(queue);
> +		return queue->oid;

This looks wrong, accessing queue after free'ing it.

> +	}
> +	list_add_tail(&queue->qlist, &ptp->tsevqs);
> +	pcuser->private_clkdata = queue;
> +
>  	return 0;
>  }
>  
> -long ptp_ioctl(struct posix_clock *pc, unsigned int cmd, unsigned long arg)
> +int ptp_release(struct posix_clock_user *pcuser)
> +{
> +	struct ptp_clock *ptp =
> +		container_of(pcuser->clk, struct ptp_clock, clock);
> +	struct timestamp_event_queue *queue = pcuser->private_clkdata;
> +
> +	if (queue) {
> +		queue->close_req = true;
> +		list_move_tail(&queue->qlist, &ptp->closed_tsevqs);
> +		pcuser->private_clkdata = NULL;
> +	}
> +	return 0;
> +}
> +
> +void ptp_flush_users(struct posix_clock *pc)
>  {
>  	struct ptp_clock *ptp = container_of(pc, struct ptp_clock, clock);
> +	struct timestamp_event_queue *tsevq, *tsevq_nxt;
> +	unsigned long flags;
> +
> +	if (mutex_lock_interruptible(&ptp->close_mux))
> +		return;
> +
> +	list_for_each_entry_safe(tsevq, tsevq_nxt, &ptp->closed_tsevqs, qlist) {
> +		spin_lock_irqsave(&tsevq->lock, flags);
> +		if (tsevq->ida)
> +			ida_free(tsevq->ida, (unsigned int)tsevq->oid);
> +		tsevq->ida = NULL;
> +		list_del(&tsevq->qlist);
> +		spin_unlock_irqrestore(&tsevq->lock, flags);
> +		kfree(tsevq);
> +	}
> +
> +	mutex_unlock(&ptp->close_mux);
> +}
> +
> +long ptp_ioctl(struct posix_clock_user *pcuser, unsigned int cmd,
> +	       unsigned long arg)
> +{
> +	struct ptp_clock *ptp =
> +		container_of(pcuser->clk, struct ptp_clock, clock);
>  	struct ptp_sys_offset_extended *extoff = NULL;
>  	struct ptp_sys_offset_precise precise_offset;
>  	struct system_device_crosststamp xtstamp;
> @@ -432,65 +492,75 @@ long ptp_ioctl(struct posix_clock *pc, unsigned int cmd, unsigned long arg)
>  	return err;
>  }
>  
> -__poll_t ptp_poll(struct posix_clock *pc, struct file *fp, poll_table *wait)
> +__poll_t ptp_poll(struct posix_clock_user *pcuser, struct file *fp,
> +		  poll_table *wait)
>  {
> -	struct ptp_clock *ptp = container_of(pc, struct ptp_clock, clock);
> +	struct ptp_clock *ptp =
> +		container_of(pcuser->clk, struct ptp_clock, clock);
>  	struct timestamp_event_queue *queue;
>  
> -	poll_wait(fp, &ptp->tsev_wq, wait);
> +	queue = pcuser->private_clkdata;
> +	if (!queue)
> +		return EPOLLERR;
>  
> -	/* Extract only the first element in the queue list
> -	 * TODO: Identify the relevant queue
> -	 */
> -	queue = list_entry(&ptp->tsevqs, struct timestamp_event_queue, qlist);
> +	poll_wait(fp, &ptp->tsev_wq, wait);
>  
>  	return queue_cnt(queue) ? EPOLLIN : 0;
>  }
>  
>  #define EXTTS_BUFSIZE (PTP_BUF_TIMESTAMPS * sizeof(struct ptp_extts_event))
>  
> -ssize_t ptp_read(struct posix_clock *pc,
> -		 uint rdflags, char __user *buf, size_t cnt)
> +ssize_t ptp_read(struct posix_clock_user *pcuser, uint rdflags,
> +		 char __user *buf, size_t cnt)
>  {
> -	struct ptp_clock *ptp = container_of(pc, struct ptp_clock, clock);
> +	struct ptp_clock *ptp =
> +		container_of(pcuser->clk, struct ptp_clock, clock);
>  	struct timestamp_event_queue *queue;
>  	struct ptp_extts_event *event;
>  	unsigned long flags;
>  	size_t qcnt, i;
>  	int result;
>  
> -	/* Extract only the first element in the queue list
> -	 * TODO: Identify the relevant queue
> -	 */
> -	queue = list_first_entry(&ptp->tsevqs, struct timestamp_event_queue,
> -				 qlist);
> +	queue = pcuser->private_clkdata;
> +	if (!queue) {
> +		result = -EINVAL;
> +		goto exit;
> +	}
>  
> -	if (cnt % sizeof(struct ptp_extts_event) != 0)
> -		return -EINVAL;
> +	if (queue->close_req) {
> +		result = -EPIPE;
> +		goto exit;
> +	}
> +
> +	if (!queue->ida) {
> +		result = -ENODEV;
> +		goto exit;
> +	}
> +
> +	if (cnt % sizeof(struct ptp_extts_event) != 0) {
> +		result = -EINVAL;
> +		goto exit;
> +	}
>  
>  	if (cnt > EXTTS_BUFSIZE)
>  		cnt = EXTTS_BUFSIZE;
>  
>  	cnt = cnt / sizeof(struct ptp_extts_event);
>  
> -	if (mutex_lock_interruptible(&ptp->tsevq_mux))
> -		return -ERESTARTSYS;
> -
>  	if (wait_event_interruptible(ptp->tsev_wq,
>  				     ptp->defunct || queue_cnt(queue))) {
> -		mutex_unlock(&ptp->tsevq_mux);
>  		return -ERESTARTSYS;
>  	}
>  
>  	if (ptp->defunct) {
> -		mutex_unlock(&ptp->tsevq_mux);
> -		return -ENODEV;
> +		result = -ENODEV;
> +		goto exit;
>  	}
>  
>  	event = kmalloc(EXTTS_BUFSIZE, GFP_KERNEL);
>  	if (!event) {
> -		mutex_unlock(&ptp->tsevq_mux);
> -		return -ENOMEM;
> +		result = -ENOMEM;
> +		goto exit;
>  	}
>  
>  	spin_lock_irqsave(&queue->lock, flags);
> @@ -509,12 +579,16 @@ ssize_t ptp_read(struct posix_clock *pc,
>  
>  	cnt = cnt * sizeof(struct ptp_extts_event);
>  
> -	mutex_unlock(&ptp->tsevq_mux);
> -
>  	result = cnt;
> -	if (copy_to_user(buf, event, cnt))
> +	if (copy_to_user(buf, event, cnt)) {
>  		result = -EFAULT;
> +		goto free_event;
> +	}
>  
> +free_event:
>  	kfree(event);
> +exit:
> +	if (result < 0)
> +		ptp_release(pcuser);
>  	return result;
>  }
> diff --git a/drivers/ptp/ptp_clock.c b/drivers/ptp/ptp_clock.c
> index 8996ff500392..9e271ad66933 100644
> --- a/drivers/ptp/ptp_clock.c
> +++ b/drivers/ptp/ptp_clock.c
> @@ -15,6 +15,7 @@
>  #include <linux/slab.h>
>  #include <linux/syscalls.h>
>  #include <linux/uaccess.h>
> +#include <linux/delay.h>
>  #include <uapi/linux/sched/types.h>
>  
>  #include "ptp_private.h"
> @@ -162,20 +163,51 @@ static struct posix_clock_operations ptp_clock_ops = {
>  	.clock_settime	= ptp_clock_settime,
>  	.ioctl		= ptp_ioctl,
>  	.open		= ptp_open,
> +	.release	= ptp_release,
> +	.flush_users	= ptp_flush_users,
>  	.poll		= ptp_poll,
>  	.read		= ptp_read,
>  };
>  
>  static void ptp_clean_queue_list(struct ptp_clock *ptp)
>  {
> -	struct timestamp_event_queue *element;
> -	struct list_head *pos, *next;
> +	struct timestamp_event_queue *tsevq;
> +	struct ptp_clock_event event;
> +	unsigned long flags;
> +	int cnt;
> +
> +	memset(&event, 0, sizeof(event));
> +	/* Request close of all open files */
> +	list_for_each_entry(tsevq, &ptp->tsevqs, qlist) {
> +		tsevq->close_req = true;
> +		/* Make sure the queue is fed so that the reader is notified */
> +		enqueue_external_timestamp(tsevq, &event);
> +	}
> +	wake_up_interruptible(&ptp->tsev_wq);
>  
> -	list_for_each_safe(pos, next, &ptp->tsevqs) {
> -		element = list_entry(pos, struct timestamp_event_queue, qlist);
> -		list_del(pos);
> -		kfree(element);
> +	/* Wait for all to close */
> +	cnt = list_count_nodes(&ptp->tsevqs);
> +	while (cnt > 1) {
> +		msleep(20);
> +		cnt = list_count_nodes(&ptp->tsevqs);
>  	}
> +	cnt = list_count_nodes(&ptp->closed_tsevqs);
> +	while (cnt > 1) {
> +		msleep(20);
> +		cnt = list_count_nodes(&ptp->closed_tsevqs);
> +	}
> +
> +	/* Delete first entry */
> +	tsevq = list_first_entry(&ptp->tsevqs, struct timestamp_event_queue,
> +				 qlist);
> +
> +	spin_lock_irqsave(&tsevq->lock, flags);
> +	ida_destroy(tsevq->ida);
> +	kfree(tsevq->ida);
> +	tsevq->ida = NULL;
> +	list_del(&tsevq->qlist);
> +	spin_unlock_irqrestore(&tsevq->lock, flags);
> +	kfree(tsevq);
>  }
>  
>  static void ptp_clock_release(struct device *dev)
> @@ -184,11 +216,11 @@ static void ptp_clock_release(struct device *dev)
>  
>  	ptp_cleanup_pin_groups(ptp);
>  	kfree(ptp->vclock_index);
> -	mutex_destroy(&ptp->tsevq_mux);
>  	mutex_destroy(&ptp->pincfg_mux);
>  	mutex_destroy(&ptp->n_vclocks_mux);
>  	ptp_clean_queue_list(ptp);
>  	ida_free(&ptp_clocks_map, ptp->index);
> +	mutex_destroy(&ptp->close_mux);
>  	kfree(ptp);
>  }
>  
> @@ -243,15 +275,23 @@ struct ptp_clock *ptp_clock_register(struct ptp_clock_info *info,
>  	ptp->devid = MKDEV(major, index);
>  	ptp->index = index;
>  	INIT_LIST_HEAD(&ptp->tsevqs);
> +	INIT_LIST_HEAD(&ptp->closed_tsevqs);
>  	queue = kzalloc(sizeof(*queue), GFP_KERNEL);
>  	if (!queue)
>  		goto no_memory_queue;
> +	queue->close_req = false;
> +	queue->ida = kzalloc(sizeof(*queue->ida), GFP_KERNEL);
> +	if (!queue->ida)
> +		goto no_memory_queue;
> +	ida_init(queue->ida);
>  	spin_lock_init(&queue->lock);
>  	list_add_tail(&queue->qlist, &ptp->tsevqs);
> -	/* TODO - Transform or delete this mutex */
> -	mutex_init(&ptp->tsevq_mux);
> +	queue->oid = ida_alloc(queue->ida, GFP_KERNEL);
> +	if (queue->oid < 0)
> +		goto ida_err;
>  	mutex_init(&ptp->pincfg_mux);
>  	mutex_init(&ptp->n_vclocks_mux);
> +	mutex_init(&ptp->close_mux);
>  	init_waitqueue_head(&ptp->tsev_wq);
>  
>  	if (ptp->info->getcycles64 || ptp->info->getcyclesx64) {
> @@ -350,9 +390,10 @@ struct ptp_clock *ptp_clock_register(struct ptp_clock_info *info,
>  	if (ptp->kworker)
>  		kthread_destroy_worker(ptp->kworker);
>  kworker_err:
> -	mutex_destroy(&ptp->tsevq_mux);
>  	mutex_destroy(&ptp->pincfg_mux);
>  	mutex_destroy(&ptp->n_vclocks_mux);
> +	mutex_destroy(&ptp->close_mux);
> +ida_err:
>  	ptp_clean_queue_list(ptp);
>  no_memory_queue:
>  	ida_free(&ptp_clocks_map, index);
> diff --git a/drivers/ptp/ptp_private.h b/drivers/ptp/ptp_private.h
> index 314c21c39f6a..529d3d421ba0 100644
> --- a/drivers/ptp/ptp_private.h
> +++ b/drivers/ptp/ptp_private.h
> @@ -16,6 +16,7 @@
>  #include <linux/ptp_clock_kernel.h>
>  #include <linux/time.h>
>  #include <linux/list.h>
> +#include <linux/idr.h>
>  
>  #define PTP_MAX_TIMESTAMPS 128
>  #define PTP_BUF_TIMESTAMPS 30
> @@ -26,7 +27,12 @@ struct timestamp_event_queue {
>  	int head;
>  	int tail;
>  	spinlock_t lock;
> +	struct posix_clock_user *pcreader;
>  	struct list_head qlist;
> +	pid_t reader_pid;
> +	struct ida *ida;
> +	int oid;
> +	bool close_req;
>  };
>  
>  struct ptp_clock {
> @@ -38,7 +44,8 @@ struct ptp_clock {
>  	struct pps_device *pps_source;
>  	long dialed_frequency; /* remembers the frequency adjustment */
>  	struct list_head tsevqs; /* timestamp fifo list */
> -	struct mutex tsevq_mux; /* one process at a time reading the fifo */
> +	struct list_head closed_tsevqs; /* close pending timestamp fifo lists */
> +	struct mutex close_mux; /* protect user clean procecdures */
>  	struct mutex pincfg_mux; /* protect concurrent info->pin_config access */
>  	wait_queue_head_t tsev_wq;
>  	int defunct; /* tells readers to go away when clock is being removed */
> @@ -109,6 +116,17 @@ static inline bool ptp_clock_freerun(struct ptp_clock *ptp)
>  	return ptp_vclock_in_use(ptp);
>  }
>  
> +/* Find the tsevq object id handler */
> +static inline struct ida *ptp_get_tsevq_ida(struct ptp_clock *ptp)
> +{
> +	struct timestamp_event_queue *queue;
> +
> +	queue = list_first_entry(&ptp->tsevqs, struct timestamp_event_queue,
> +				 qlist);
> +
> +	return queue->ida;
> +}
> +
>  extern struct class *ptp_class;
>  
>  /*
> @@ -119,16 +137,20 @@ extern struct class *ptp_class;
>  int ptp_set_pinfunc(struct ptp_clock *ptp, unsigned int pin,
>  		    enum ptp_pin_function func, unsigned int chan);
>  
> -long ptp_ioctl(struct posix_clock *pc,
> -	       unsigned int cmd, unsigned long arg);
> +long ptp_ioctl(struct posix_clock_user *pcuser, unsigned int cmd,
> +	       unsigned long arg);
> +
> +int ptp_open(struct posix_clock_user *pcuser, fmode_t fmode);
> +
> +int ptp_release(struct posix_clock_user *pcuser);
>  
> -int ptp_open(struct posix_clock *pc, fmode_t fmode);
> +void ptp_flush_users(struct posix_clock *pc);
>  
> -ssize_t ptp_read(struct posix_clock *pc,
> -		 uint flags, char __user *buf, size_t cnt);
> +ssize_t ptp_read(struct posix_clock_user *pcuser, uint flags, char __user *buf,
> +		 size_t cnt);
>  
> -__poll_t ptp_poll(struct posix_clock *pc,
> -	      struct file *fp, poll_table *wait);
> +__poll_t ptp_poll(struct posix_clock_user *pcuser, struct file *fp,
> +		  poll_table *wait);
>  
>  /*
>   * see ptp_sysfs.c
> diff --git a/drivers/ptp/ptp_sysfs.c b/drivers/ptp/ptp_sysfs.c
> index 2675f383cd0a..c02aaba729e0 100644
> --- a/drivers/ptp/ptp_sysfs.c
> +++ b/drivers/ptp/ptp_sysfs.c
> @@ -81,15 +81,14 @@ static ssize_t extts_fifo_show(struct device *dev,
>  	size_t qcnt;
>  	int cnt = 0;
>  
> +	cnt = list_count_nodes(&ptp->tsevqs);
> +	if (cnt <= 0)
> +		goto out;
> +
>  	/* The sysfs fifo will always draw from the fist queue */
>  	queue = list_first_entry(&ptp->tsevqs, struct timestamp_event_queue,
>  				 qlist);
>  
> -	memset(&event, 0, sizeof(event));
> -
> -	if (mutex_lock_interruptible(&ptp->tsevq_mux))
> -		return -ERESTARTSYS;
> -
>  	spin_lock_irqsave(&queue->lock, flags);
>  	qcnt = queue_cnt(queue);
>  	if (qcnt) {
> @@ -104,7 +103,6 @@ static ssize_t extts_fifo_show(struct device *dev,
>  	cnt = snprintf(page, PAGE_SIZE, "%u %lld %u\n",
>  		       event.index, event.t.sec, event.t.nsec);
>  out:
> -	mutex_unlock(&ptp->tsevq_mux);
>  	return cnt;
>  }
>  static DEVICE_ATTR(fifo, 0444, extts_fifo_show, NULL);
> diff --git a/include/linux/posix-clock.h b/include/linux/posix-clock.h
> index 468328b1e1dd..8f844ac28aa8 100644
> --- a/include/linux/posix-clock.h
> +++ b/include/linux/posix-clock.h
> @@ -14,6 +14,7 @@
>  #include <linux/rwsem.h>
>  
>  struct posix_clock;
> +struct posix_clock_user;
>  
>  /**
>   * struct posix_clock_operations - functional interface to the clock
> @@ -50,18 +51,20 @@ struct posix_clock_operations {
>  	/*
>  	 * Optional character device methods:
>  	 */
> -	long    (*ioctl)   (struct posix_clock *pc,
> -			    unsigned int cmd, unsigned long arg);
> +	long (*ioctl)(struct posix_clock_user *pcuser, unsigned int cmd,
> +		      unsigned long arg);
>  
> -	int     (*open)    (struct posix_clock *pc, fmode_t f_mode);
> +	int (*open)(struct posix_clock_user *pcuser, fmode_t f_mode);
>  
> -	__poll_t (*poll)   (struct posix_clock *pc,
> -			    struct file *file, poll_table *wait);
> +	__poll_t (*poll)(struct posix_clock_user *pcuser, struct file *file,
> +			 poll_table *wait);
>  
> -	int     (*release) (struct posix_clock *pc);
> +	int (*release)(struct posix_clock_user *pcuser);
>  
> -	ssize_t (*read)    (struct posix_clock *pc,
> -			    uint flags, char __user *buf, size_t cnt);
> +	void (*flush_users)(struct posix_clock *pc);
> +
> +	ssize_t (*read)(struct posix_clock_user *pcuser, uint flags,
> +			char __user *buf, size_t cnt);
>  };
>  
>  /**
> @@ -90,6 +93,11 @@ struct posix_clock {
>  	bool zombie;
>  };
>  
> +struct posix_clock_user {
> +	struct posix_clock *clk;
> +	void *private_clkdata;
> +};
> +
>  /**
>   * posix_clock_register() - register a new clock
>   * @clk:   Pointer to the clock. Caller must provide 'ops' field
> diff --git a/kernel/time/posix-clock.c b/kernel/time/posix-clock.c
> index 77c0c2370b6d..8ae76492f7ea 100644
> --- a/kernel/time/posix-clock.c
> +++ b/kernel/time/posix-clock.c
> @@ -19,7 +19,12 @@
>   */
>  static struct posix_clock *get_posix_clock(struct file *fp)
>  {
> -	struct posix_clock *clk = fp->private_data;
> +	struct posix_clock_user *pcuser = fp->private_data;
> +	struct posix_clock *clk;
> +
> +	if (!pcuser)
> +		return NULL;
> +	clk = pcuser->clk;
>  
>  	down_read(&clk->rwsem);
>  
> @@ -39,6 +44,7 @@ static void put_posix_clock(struct posix_clock *clk)
>  static ssize_t posix_clock_read(struct file *fp, char __user *buf,
>  				size_t count, loff_t *ppos)
>  {
> +	struct posix_clock_user *pcuser = fp->private_data;
>  	struct posix_clock *clk = get_posix_clock(fp);
>  	int err = -EINVAL;
>  
> @@ -46,7 +52,7 @@ static ssize_t posix_clock_read(struct file *fp, char __user *buf,
>  		return -ENODEV;
>  
>  	if (clk->ops.read)
> -		err = clk->ops.read(clk, fp->f_flags, buf, count);
> +		err = clk->ops.read(pcuser, fp->f_flags, buf, count);
>  
>  	put_posix_clock(clk);
>  
> @@ -55,6 +61,7 @@ static ssize_t posix_clock_read(struct file *fp, char __user *buf,
>  
>  static __poll_t posix_clock_poll(struct file *fp, poll_table *wait)
>  {
> +	struct posix_clock_user *pcuser = fp->private_data;
>  	struct posix_clock *clk = get_posix_clock(fp);
>  	__poll_t result = 0;
>  
> @@ -62,7 +69,7 @@ static __poll_t posix_clock_poll(struct file *fp, poll_table *wait)
>  		return EPOLLERR;
>  
>  	if (clk->ops.poll)
> -		result = clk->ops.poll(clk, fp, wait);
> +		result = clk->ops.poll(pcuser, fp, wait);
>  
>  	put_posix_clock(clk);
>  
> @@ -72,6 +79,7 @@ static __poll_t posix_clock_poll(struct file *fp, poll_table *wait)
>  static long posix_clock_ioctl(struct file *fp,
>  			      unsigned int cmd, unsigned long arg)
>  {
> +	struct posix_clock_user *pcuser = fp->private_data;
>  	struct posix_clock *clk = get_posix_clock(fp);
>  	int err = -ENOTTY;
>  
> @@ -79,7 +87,7 @@ static long posix_clock_ioctl(struct file *fp,
>  		return -ENODEV;
>  
>  	if (clk->ops.ioctl)
> -		err = clk->ops.ioctl(clk, cmd, arg);
> +		err = clk->ops.ioctl(pcuser, cmd, arg);
>  
>  	put_posix_clock(clk);
>  
> @@ -90,6 +98,7 @@ static long posix_clock_ioctl(struct file *fp,
>  static long posix_clock_compat_ioctl(struct file *fp,
>  				     unsigned int cmd, unsigned long arg)
>  {
> +	struct posix_clock_user *pcuser = fp->private_data;
>  	struct posix_clock *clk = get_posix_clock(fp);
>  	int err = -ENOTTY;
>  
> @@ -97,7 +106,7 @@ static long posix_clock_compat_ioctl(struct file *fp,
>  		return -ENODEV;
>  
>  	if (clk->ops.ioctl)
> -		err = clk->ops.ioctl(clk, cmd, arg);
> +		err = clk->ops.ioctl(pcuser, cmd, arg);
>  
>  	put_posix_clock(clk);
>  
> @@ -110,6 +119,7 @@ static int posix_clock_open(struct inode *inode, struct file *fp)
>  	int err;
>  	struct posix_clock *clk =
>  		container_of(inode->i_cdev, struct posix_clock, cdev);
> +	struct posix_clock_user *pcuser;
>  
>  	down_read(&clk->rwsem);
>  
> @@ -117,14 +127,20 @@ static int posix_clock_open(struct inode *inode, struct file *fp)
>  		err = -ENODEV;
>  		goto out;
>  	}
> +	pcuser = kzalloc(sizeof(*pcuser), GFP_KERNEL);
> +	if (!pcuser) {
> +		err = -ENOMEM;
> +		goto out;
> +	}
> +	pcuser->clk = clk;
> +	fp->private_data = pcuser;
>  	if (clk->ops.open)
> -		err = clk->ops.open(clk, fp->f_mode);
> +		err = clk->ops.open(pcuser, fp->f_mode);
>  	else
>  		err = 0;
>  
>  	if (!err) {
>  		get_device(clk->dev);
> -		fp->private_data = clk;
>  	}
>  out:
>  	up_read(&clk->rwsem);
> @@ -133,14 +149,23 @@ static int posix_clock_open(struct inode *inode, struct file *fp)
>  
>  static int posix_clock_release(struct inode *inode, struct file *fp)
>  {
> -	struct posix_clock *clk = fp->private_data;
> +	struct posix_clock_user *pcuser = fp->private_data;
> +	struct posix_clock *clk;
>  	int err = 0;
>  
> +	if (!pcuser)
> +		return -ENODEV;
> +	clk = pcuser->clk;
> +
>  	if (clk->ops.release)
> -		err = clk->ops.release(clk);
> +		err = clk->ops.release(pcuser);
>  
>  	put_device(clk->dev);
>  
> +	if (clk->ops.flush_users)
> +		clk->ops.flush_users(clk);
> +
> +	kfree(pcuser);
>  	fp->private_data = NULL;
>  
>  	return err;
> -- 
> 2.34.1
>

-- 
Vinicius

Powered by blists - more mailing lists