| Message ID | 5525d56c5feff9b28c6caa93e03d8f198d7412ce.1696511486.git.reibax@gmail.com (mailing list archive) |
|---|---|
| State | Superseded |
| Delegated to: | Netdev Maintainers |
| Headers | show |
| Series | ptp: Support for multiple filtered timestamp event queue readers | expand |
On Thu, Oct 05, 2023 at 03:53:14PM +0200, Xabier Marquiegui wrote: > On systems with multiple timestamp event channels, some readers might > want to receive only a subset of those channels. > > This patch adds the necessary modifications to support timestamp event > channel filtering, including two IOCTL operations: > > - Clear all channels > - Enable one channel > > The mask modification operations will be applied exclusively on the > event queue assigned to the file descriptor used on the IOCTL operation, > so the typical procedure to have a reader receiving only a subset of the > enabled channels would be: > > - Open device file > - ioctl: clear all channels > - ioctl: enable one channel > - start reading > > Calling the enable one channel ioctl more than once will result in > multiple enabled channels. > > Signed-off-by: Xabier Marquiegui <reibax@gmail.com> > Suggested-by: Richard Cochran <richardcochran@gmail.com> > Suggested-by: Vinicius Costa Gomes <vinicius.gomes@intel.com> > --- > v4: > - split modifications in different patches for improved organization > - filter modifications exclusive to currently open instance for > simplicity and security > - expand mask to 2048 channels > - remove unnecessary tests > v3: https://lore.kernel.org/netdev/20230928133544.3642650-4-reibax@gmail.com/ > - filter application by object id, aided by process id > - friendlier testptp implementation of event queue channel filters > v2: https://lore.kernel.org/netdev/20230912220217.2008895-3-reibax@gmail.com/ > - fix testptp compilation error: unknown type name 'pid_t' > - rename mask variable for easier code traceability > - more detailed commit message with two examples > v1: https://lore.kernel.org/netdev/20230906104754.1324412-4-reibax@gmail.com/ > --- > drivers/ptp/ptp_chardev.c | 24 ++++++++++++++++++++++++ > drivers/ptp/ptp_clock.c | 12 ++++++++++-- > drivers/ptp/ptp_private.h | 3 +++ > include/uapi/linux/ptp_clock.h | 2 ++ > 4 files changed, 39 insertions(+), 2 deletions(-) > > diff --git a/drivers/ptp/ptp_chardev.c b/drivers/ptp/ptp_chardev.c > index abe94bb80cf6..dbbe551a044f 100644 > --- a/drivers/ptp/ptp_chardev.c > +++ b/drivers/ptp/ptp_chardev.c > @@ -110,6 +110,10 @@ int ptp_open(struct posix_clock_context *pccontext, fmode_t fmode) > queue = kzalloc(sizeof(*queue), GFP_KERNEL); > if (!queue) > return -EINVAL; > + queue->mask = bitmap_alloc(PTP_MAX_CHANNELS, GFP_KERNEL); > + if (!queue->mask) Hi Xabier, queue appears to be leaked here. As flagged by Smatch. > + return -EINVAL; > + bitmap_set(queue->mask, 0, PTP_MAX_CHANNELS); > spin_lock_init(&queue->lock); > list_add_tail(&queue->qlist, &ptp->tsevqs); > pccontext->private_clkdata = queue;
Xabier Marquiegui <reibax@gmail.com> writes: > On systems with multiple timestamp event channels, some readers might > want to receive only a subset of those channels. > > This patch adds the necessary modifications to support timestamp event > channel filtering, including two IOCTL operations: > > - Clear all channels > - Enable one channel > > The mask modification operations will be applied exclusively on the > event queue assigned to the file descriptor used on the IOCTL operation, > so the typical procedure to have a reader receiving only a subset of the > enabled channels would be: > > - Open device file > - ioctl: clear all channels > - ioctl: enable one channel > - start reading > > Calling the enable one channel ioctl more than once will result in > multiple enabled channels. > > Signed-off-by: Xabier Marquiegui <reibax@gmail.com> > Suggested-by: Richard Cochran <richardcochran@gmail.com> > Suggested-by: Vinicius Costa Gomes <vinicius.gomes@intel.com> > --- > v4: > - split modifications in different patches for improved organization > - filter modifications exclusive to currently open instance for > simplicity and security > - expand mask to 2048 channels > - remove unnecessary tests > v3: https://lore.kernel.org/netdev/20230928133544.3642650-4-reibax@gmail.com/ > - filter application by object id, aided by process id > - friendlier testptp implementation of event queue channel filters > v2: https://lore.kernel.org/netdev/20230912220217.2008895-3-reibax@gmail.com/ > - fix testptp compilation error: unknown type name 'pid_t' > - rename mask variable for easier code traceability > - more detailed commit message with two examples > v1: https://lore.kernel.org/netdev/20230906104754.1324412-4-reibax@gmail.com/ > --- > drivers/ptp/ptp_chardev.c | 24 ++++++++++++++++++++++++ > drivers/ptp/ptp_clock.c | 12 ++++++++++-- > drivers/ptp/ptp_private.h | 3 +++ > include/uapi/linux/ptp_clock.h | 2 ++ > 4 files changed, 39 insertions(+), 2 deletions(-) > > diff --git a/drivers/ptp/ptp_chardev.c b/drivers/ptp/ptp_chardev.c > index abe94bb80cf6..dbbe551a044f 100644 > --- a/drivers/ptp/ptp_chardev.c > +++ b/drivers/ptp/ptp_chardev.c > @@ -110,6 +110,10 @@ int ptp_open(struct posix_clock_context *pccontext, fmode_t fmode) > queue = kzalloc(sizeof(*queue), GFP_KERNEL); > if (!queue) > return -EINVAL; > + queue->mask = bitmap_alloc(PTP_MAX_CHANNELS, GFP_KERNEL); > + if (!queue->mask) > + return -EINVAL; > + bitmap_set(queue->mask, 0, PTP_MAX_CHANNELS); > spin_lock_init(&queue->lock); > list_add_tail(&queue->qlist, &ptp->tsevqs); > pccontext->private_clkdata = queue; > @@ -126,6 +130,7 @@ int ptp_release(struct posix_clock_context *pccontext) > spin_lock_irqsave(&queue->lock, flags); > list_del(&queue->qlist); > spin_unlock_irqrestore(&queue->lock, flags); > + bitmap_free(queue->mask); > kfree(queue); > } > return 0; > @@ -141,6 +146,7 @@ long ptp_ioctl(struct posix_clock_context *pccontext, unsigned int cmd, > struct system_device_crosststamp xtstamp; > struct ptp_clock_info *ops = ptp->info; > struct ptp_sys_offset *sysoff = NULL; > + struct timestamp_event_queue *tsevq; > struct ptp_system_timestamp sts; > struct ptp_clock_request req; > struct ptp_clock_caps caps; > @@ -150,6 +156,8 @@ long ptp_ioctl(struct posix_clock_context *pccontext, unsigned int cmd, > struct timespec64 ts; > int enable, err = 0; > > + tsevq = pccontext->private_clkdata; > + > switch (cmd) { > > case PTP_CLOCK_GETCAPS: > @@ -448,6 +456,22 @@ long ptp_ioctl(struct posix_clock_context *pccontext, unsigned int cmd, > mutex_unlock(&ptp->pincfg_mux); > break; > > + case PTP_MASK_CLEAR_ALL: > + bitmap_clear(tsevq->mask, 0, PTP_MAX_CHANNELS); > + break; > + > + case PTP_MASK_EN_SINGLE: > + if (copy_from_user(&i, (void __user *)arg, sizeof(i))) { > + err = -EFAULT; > + break; > + } > + if (i >= PTP_MAX_CHANNELS) { > + err = -EFAULT; > + break; > + } > + set_bit(i, tsevq->mask); > + break; > + > default: > err = -ENOTTY; > break; > diff --git a/drivers/ptp/ptp_clock.c b/drivers/ptp/ptp_clock.c > index 74f1ce2dbccb..ed16d9787ce9 100644 > --- a/drivers/ptp/ptp_clock.c > +++ b/drivers/ptp/ptp_clock.c > @@ -183,6 +183,7 @@ static void ptp_clock_release(struct device *dev) > spin_lock_irqsave(&tsevq->lock, flags); > list_del(&tsevq->qlist); > spin_unlock_irqrestore(&tsevq->lock, flags); > + bitmap_free(tsevq->mask); > kfree(tsevq); > ida_free(&ptp_clocks_map, ptp->index); > kfree(ptp); > @@ -243,6 +244,10 @@ struct ptp_clock *ptp_clock_register(struct ptp_clock_info *info, > if (!queue) > goto no_memory_queue; > list_add_tail(&queue->qlist, &ptp->tsevqs); > + queue->mask = bitmap_alloc(PTP_MAX_CHANNELS, GFP_KERNEL); > + if (!queue->mask) > + goto no_memory_bitmap; > + bitmap_set(queue->mask, 0, PTP_MAX_CHANNELS); Sorry that I only noticed a (possible) change in behavior now. Before this series, when there was a single queue, events where accumulated until the application reads the fd associated with the PTP device. i.e. it doesn't matter when the application calls open(). AFter this series events, are only accumulated after the queue associated with that fd is created, i.e. after open(). Events that happened before open() are lost (is this true? are we leaking them?). Is this a desired/wanted change? Is it possible that we have applications that depend on the "old" behavior? > spin_lock_init(&queue->lock); > mutex_init(&ptp->pincfg_mux); > mutex_init(&ptp->n_vclocks_mux); > @@ -346,6 +351,8 @@ struct ptp_clock *ptp_clock_register(struct ptp_clock_info *info, > kworker_err: > mutex_destroy(&ptp->pincfg_mux); > mutex_destroy(&ptp->n_vclocks_mux); > + bitmap_free(queue->mask); > +no_memory_bitmap: > list_del(&queue->qlist); > kfree(queue); > no_memory_queue: > @@ -400,9 +407,10 @@ void ptp_clock_event(struct ptp_clock *ptp, struct ptp_clock_event *event) > break; > > case PTP_CLOCK_EXTTS: > - /* Enqueue timestamp on all queues */ > + /* Enqueue timestamp on selected queues */ > list_for_each_entry(tsevq, &ptp->tsevqs, qlist) { > - enqueue_external_timestamp(tsevq, event); > + if (test_bit((unsigned int)event->index, tsevq->mask)) > + enqueue_external_timestamp(tsevq, event); > } > wake_up_interruptible(&ptp->tsev_wq); > break; > diff --git a/drivers/ptp/ptp_private.h b/drivers/ptp/ptp_private.h > index 9d5f3d95058e..ad4ce1b25c86 100644 > --- a/drivers/ptp/ptp_private.h > +++ b/drivers/ptp/ptp_private.h > @@ -16,10 +16,12 @@ > #include <linux/ptp_clock_kernel.h> > #include <linux/time.h> > #include <linux/list.h> > +#include <linux/bitmap.h> > > #define PTP_MAX_TIMESTAMPS 128 > #define PTP_BUF_TIMESTAMPS 30 > #define PTP_DEFAULT_MAX_VCLOCKS 20 > +#define PTP_MAX_CHANNELS 2048 > > struct timestamp_event_queue { > struct ptp_extts_event buf[PTP_MAX_TIMESTAMPS]; > @@ -27,6 +29,7 @@ struct timestamp_event_queue { > int tail; > spinlock_t lock; > struct list_head qlist; > + unsigned long *mask; > }; > > struct ptp_clock { > diff --git a/include/uapi/linux/ptp_clock.h b/include/uapi/linux/ptp_clock.h > index 05cc35fc94ac..da700999cad4 100644 > --- a/include/uapi/linux/ptp_clock.h > +++ b/include/uapi/linux/ptp_clock.h > @@ -224,6 +224,8 @@ struct ptp_pin_desc { > _IOWR(PTP_CLK_MAGIC, 17, struct ptp_sys_offset_precise) > #define PTP_SYS_OFFSET_EXTENDED2 \ > _IOWR(PTP_CLK_MAGIC, 18, struct ptp_sys_offset_extended) > +#define PTP_MASK_CLEAR_ALL _IO(PTP_CLK_MAGIC, 19) > +#define PTP_MASK_EN_SINGLE _IOW(PTP_CLK_MAGIC, 20, unsigned int) > > struct ptp_extts_event { > struct ptp_clock_time t; /* Time event occured. */ > -- > 2.34.1 >
Simon Horman said: > Hi Xabier, > > queue appears to be leaked here. > > As flagged by Smatch. Nice catch Simon. Thank you very much. I think I know how to fix it. I will keep it in mind for the next revision. Vinicius Costa Gomes said: > Sorry that I only noticed a (possible) change in behavior now. > > Before this series, when there was a single queue, events where > accumulated until the application reads the fd associated with the PTP > device. i.e. it doesn't matter when the application calls open(). You are totally correct about that observation. I had never thought of this angle until you mentioned it. Thank you for bringing it up. > AFter this series events, are only accumulated after the queue > associated with that fd is created, i.e. after open(). Events that > happened before open() are lost (is this true? are we leaking them?). Old events are indeed lost for a new reader, but I don't see how that could be causing a leak. The way it works is, we always have at least one queue: the one corresponding to sysfs. Whenever a new reader accesses the device, a new queue is created and starts to get fed with new coming timestamps alongside the rest of existing queues. > Is this a desired/wanted change? Is it possible that we have > applications that depend on the "old" behavior? I would really like to hear the voice of more experience people on this. On my limited experience this is a non-issue because I can control the sequencing and I am sure to have the reader ready before I trigger events, but you might be right that there might be some use-cases I didn't imagine that could be affected by this change in behavior. We could tweak the system a little bit by having an additional reference fifo with no readers. Whenever a new ptp_open happens, I could just copy the entire reference fifo to the new one. I guess this would bring back the need to have the fifo mutex. If this idea works we could be maintaining the same functionality, at the cost of making the system be more complex and slower. Is it worth it? I look forward to hearing opinions on this. Thank you everyone for your feedback.
Xabier Marquiegui <reibax@gmail.com> writes: > Simon Horman said: >> Hi Xabier, >> >> queue appears to be leaked here. >> >> As flagged by Smatch. > > Nice catch Simon. Thank you very much. I think I know how to fix it. I > will keep it in mind for the next revision. > > Vinicius Costa Gomes said: >> Sorry that I only noticed a (possible) change in behavior now. >> >> Before this series, when there was a single queue, events where >> accumulated until the application reads the fd associated with the PTP >> device. i.e. it doesn't matter when the application calls open(). > > You are totally correct about that observation. I had never thought of > this angle until you mentioned it. Thank you for bringing it up. > >> AFter this series events, are only accumulated after the queue >> associated with that fd is created, i.e. after open(). Events that >> happened before open() are lost (is this true? are we leaking them?). > > Old events are indeed lost for a new reader, but I don't see how that > could be causing a leak. The way it works is, we always have at least > one queue: the one corresponding to sysfs. > Ah, yeah! I forgot that sysfs is a separate events consumer. Disregard my comment about leaking events, then. > Whenever a new reader accesses the device, a new queue is created and > starts to get fed with new coming timestamps alongside the rest of > existing queues. > >> Is this a desired/wanted change? Is it possible that we have >> applications that depend on the "old" behavior? > > I would really like to hear the voice of more experience people on this. > On my limited experience this is a non-issue because I can control the > sequencing and I am sure to have the reader ready before I trigger events, > but you might be right that there might be some use-cases I didn't imagine > that could be affected by this change in behavior. > I am not a heavy user of these APIs, but I don't think this will break anything. Just thought it important to voice this so when we make this change in behavior we make it knowingly. (and my imagination could not produce any practical case that this would be a problem) But let's see what others say. > We could tweak the system a little bit by having an additional reference > fifo with no readers. Whenever a new ptp_open happens, I could just copy > the entire reference fifo to the new one. I guess this would bring back > the need to have the fifo mutex. > > If this idea works we could be maintaining the same functionality, at the > cost of making the system be more complex and slower. Is it worth it? Probably not. I would say that this change in behavior is fine/harmless. Just a matter of being aware of it. > > I look forward to hearing opinions on this. Thank you everyone for your > feedback. > Cheers,
On Fri, Oct 06, 2023 at 03:05:12PM -0700, Vinicius Costa Gomes wrote: > Sorry that I only noticed a (possible) change in behavior now. > > Before this series, when there was a single queue, events where > accumulated until the application reads the fd associated with the PTP > device. i.e. it doesn't matter when the application calls open(). > > AFter this series events, are only accumulated after the queue > associated with that fd is created, i.e. after open(). Events that > happened before open() are lost (is this true? are we leaking them?). > > Is this a desired/wanted change? Is it possible that we have > applications that depend on the "old" behavior? So the existing behavior is not very nice to user space. The is forced to clear the fifo after open, like this ts2phc_pps_sink.c: 117 static int ts2phc_pps_sink_clear_fifo(struct ts2phc_pps_sink *sink) 118 { 119 struct pollfd pfd = { 120 .events = POLLIN | POLLPRI, 121 .fd = sink->clock->fd, 122 }; 123 struct ptp_extts_event event; 124 int cnt, size; 125 126 while (1) { 127 cnt = poll(&pfd, 1, 0); 128 if (cnt < 0) { 129 if (EINTR == errno) { 130 continue; 131 } else { 132 pr_emerg("poll failed"); 133 return -1; 134 } 135 } else if (!cnt) { 136 break; 137 } 138 size = read(pfd.fd, &event, sizeof(event)); So, no one will miss the old behavior! Thanks, Richard
diff --git a/drivers/ptp/ptp_chardev.c b/drivers/ptp/ptp_chardev.c index abe94bb80cf6..dbbe551a044f 100644 --- a/drivers/ptp/ptp_chardev.c +++ b/drivers/ptp/ptp_chardev.c @@ -110,6 +110,10 @@ int ptp_open(struct posix_clock_context *pccontext, fmode_t fmode) queue = kzalloc(sizeof(*queue), GFP_KERNEL); if (!queue) return -EINVAL; + queue->mask = bitmap_alloc(PTP_MAX_CHANNELS, GFP_KERNEL); + if (!queue->mask) + return -EINVAL; + bitmap_set(queue->mask, 0, PTP_MAX_CHANNELS); spin_lock_init(&queue->lock); list_add_tail(&queue->qlist, &ptp->tsevqs); pccontext->private_clkdata = queue; @@ -126,6 +130,7 @@ int ptp_release(struct posix_clock_context *pccontext) spin_lock_irqsave(&queue->lock, flags); list_del(&queue->qlist); spin_unlock_irqrestore(&queue->lock, flags); + bitmap_free(queue->mask); kfree(queue); } return 0; @@ -141,6 +146,7 @@ long ptp_ioctl(struct posix_clock_context *pccontext, unsigned int cmd, struct system_device_crosststamp xtstamp; struct ptp_clock_info *ops = ptp->info; struct ptp_sys_offset *sysoff = NULL; + struct timestamp_event_queue *tsevq; struct ptp_system_timestamp sts; struct ptp_clock_request req; struct ptp_clock_caps caps; @@ -150,6 +156,8 @@ long ptp_ioctl(struct posix_clock_context *pccontext, unsigned int cmd, struct timespec64 ts; int enable, err = 0; + tsevq = pccontext->private_clkdata; + switch (cmd) { case PTP_CLOCK_GETCAPS: @@ -448,6 +456,22 @@ long ptp_ioctl(struct posix_clock_context *pccontext, unsigned int cmd, mutex_unlock(&ptp->pincfg_mux); break; + case PTP_MASK_CLEAR_ALL: + bitmap_clear(tsevq->mask, 0, PTP_MAX_CHANNELS); + break; + + case PTP_MASK_EN_SINGLE: + if (copy_from_user(&i, (void __user *)arg, sizeof(i))) { + err = -EFAULT; + break; + } + if (i >= PTP_MAX_CHANNELS) { + err = -EFAULT; + break; + } + set_bit(i, tsevq->mask); + break; + default: err = -ENOTTY; break; diff --git a/drivers/ptp/ptp_clock.c b/drivers/ptp/ptp_clock.c index 74f1ce2dbccb..ed16d9787ce9 100644 --- a/drivers/ptp/ptp_clock.c +++ b/drivers/ptp/ptp_clock.c @@ -183,6 +183,7 @@ static void ptp_clock_release(struct device *dev) spin_lock_irqsave(&tsevq->lock, flags); list_del(&tsevq->qlist); spin_unlock_irqrestore(&tsevq->lock, flags); + bitmap_free(tsevq->mask); kfree(tsevq); ida_free(&ptp_clocks_map, ptp->index); kfree(ptp); @@ -243,6 +244,10 @@ struct ptp_clock *ptp_clock_register(struct ptp_clock_info *info, if (!queue) goto no_memory_queue; list_add_tail(&queue->qlist, &ptp->tsevqs); + queue->mask = bitmap_alloc(PTP_MAX_CHANNELS, GFP_KERNEL); + if (!queue->mask) + goto no_memory_bitmap; + bitmap_set(queue->mask, 0, PTP_MAX_CHANNELS); spin_lock_init(&queue->lock); mutex_init(&ptp->pincfg_mux); mutex_init(&ptp->n_vclocks_mux); @@ -346,6 +351,8 @@ struct ptp_clock *ptp_clock_register(struct ptp_clock_info *info, kworker_err: mutex_destroy(&ptp->pincfg_mux); mutex_destroy(&ptp->n_vclocks_mux); + bitmap_free(queue->mask); +no_memory_bitmap: list_del(&queue->qlist); kfree(queue); no_memory_queue: @@ -400,9 +407,10 @@ void ptp_clock_event(struct ptp_clock *ptp, struct ptp_clock_event *event) break; case PTP_CLOCK_EXTTS: - /* Enqueue timestamp on all queues */ + /* Enqueue timestamp on selected queues */ list_for_each_entry(tsevq, &ptp->tsevqs, qlist) { - enqueue_external_timestamp(tsevq, event); + if (test_bit((unsigned int)event->index, tsevq->mask)) + enqueue_external_timestamp(tsevq, event); } wake_up_interruptible(&ptp->tsev_wq); break; diff --git a/drivers/ptp/ptp_private.h b/drivers/ptp/ptp_private.h index 9d5f3d95058e..ad4ce1b25c86 100644 --- a/drivers/ptp/ptp_private.h +++ b/drivers/ptp/ptp_private.h @@ -16,10 +16,12 @@ #include <linux/ptp_clock_kernel.h> #include <linux/time.h> #include <linux/list.h> +#include <linux/bitmap.h> #define PTP_MAX_TIMESTAMPS 128 #define PTP_BUF_TIMESTAMPS 30 #define PTP_DEFAULT_MAX_VCLOCKS 20 +#define PTP_MAX_CHANNELS 2048 struct timestamp_event_queue { struct ptp_extts_event buf[PTP_MAX_TIMESTAMPS]; @@ -27,6 +29,7 @@ struct timestamp_event_queue { int tail; spinlock_t lock; struct list_head qlist; + unsigned long *mask; }; struct ptp_clock { diff --git a/include/uapi/linux/ptp_clock.h b/include/uapi/linux/ptp_clock.h index 05cc35fc94ac..da700999cad4 100644 --- a/include/uapi/linux/ptp_clock.h +++ b/include/uapi/linux/ptp_clock.h @@ -224,6 +224,8 @@ struct ptp_pin_desc { _IOWR(PTP_CLK_MAGIC, 17, struct ptp_sys_offset_precise) #define PTP_SYS_OFFSET_EXTENDED2 \ _IOWR(PTP_CLK_MAGIC, 18, struct ptp_sys_offset_extended) +#define PTP_MASK_CLEAR_ALL _IO(PTP_CLK_MAGIC, 19) +#define PTP_MASK_EN_SINGLE _IOW(PTP_CLK_MAGIC, 20, unsigned int) struct ptp_extts_event { struct ptp_clock_time t; /* Time event occured. */
On systems with multiple timestamp event channels, some readers might want to receive only a subset of those channels. This patch adds the necessary modifications to support timestamp event channel filtering, including two IOCTL operations: - Clear all channels - Enable one channel The mask modification operations will be applied exclusively on the event queue assigned to the file descriptor used on the IOCTL operation, so the typical procedure to have a reader receiving only a subset of the enabled channels would be: - Open device file - ioctl: clear all channels - ioctl: enable one channel - start reading Calling the enable one channel ioctl more than once will result in multiple enabled channels. Signed-off-by: Xabier Marquiegui <reibax@gmail.com> Suggested-by: Richard Cochran <richardcochran@gmail.com> Suggested-by: Vinicius Costa Gomes <vinicius.gomes@intel.com> --- v4: - split modifications in different patches for improved organization - filter modifications exclusive to currently open instance for simplicity and security - expand mask to 2048 channels - remove unnecessary tests v3: https://lore.kernel.org/netdev/20230928133544.3642650-4-reibax@gmail.com/ - filter application by object id, aided by process id - friendlier testptp implementation of event queue channel filters v2: https://lore.kernel.org/netdev/20230912220217.2008895-3-reibax@gmail.com/ - fix testptp compilation error: unknown type name 'pid_t' - rename mask variable for easier code traceability - more detailed commit message with two examples v1: https://lore.kernel.org/netdev/20230906104754.1324412-4-reibax@gmail.com/ --- drivers/ptp/ptp_chardev.c | 24 ++++++++++++++++++++++++ drivers/ptp/ptp_clock.c | 12 ++++++++++-- drivers/ptp/ptp_private.h | 3 +++ include/uapi/linux/ptp_clock.h | 2 ++ 4 files changed, 39 insertions(+), 2 deletions(-)