Re: [PATCH v0 2/2] perf, pt, coresight: Fix address filters for vmas with non-zero offset

[Arnaldo Carvalho de Melo <acme@redhat.com>]

Adding Mathieu to the CC list.

Em Fri, Feb 15, 2019 at 01:56:55PM +0200, Alexander Shishkin escreveu:
> Currently, the address range calculation for file-based filters works as
> long as the vma that maps the matching part of the object file starts from
> offset zero into the file (vm_pgoff==0). Otherwise, the resulting filter
> range would be off by vm_pgoff pages. Another related problem is that in
> case of a partially matching vma, that is, a vma that matches part of a
> filter region, the filter range size wouldn't be adjusted.
> 
> Fix the arithmetics around address filter range calculations, taking into
> account vma offset, so that the entire calculation is done before the
> filter configuration is passed to the PMU drivers instead of having those
> drivers do the final bit of arithmetics.
> 
> Based on the patch by Adrian Hunter <adrian.hunter.intel.com>.
> 
> Signed-off-by: Alexander Shishkin <alexander.shishkin@linux.intel.com>
> Fixes: 375637bc5249 ("perf/core: Introduce address range filtering")
> Reported-by: Adrian Hunter <adrian.hunter@intel.com>
> ---
>  arch/x86/events/intel/pt.c                    |  9 ++-
>  .../hwtracing/coresight/coresight-etm-perf.c  |  7 +-
>  include/linux/perf_event.h                    |  7 +-
>  kernel/events/core.c                          | 81 +++++++++++--------
>  4 files changed, 62 insertions(+), 42 deletions(-)
> 
> diff --git a/arch/x86/events/intel/pt.c b/arch/x86/events/intel/pt.c
> index cb4c10fdf793..c0c44c055eaa 100644
> --- a/arch/x86/events/intel/pt.c
> +++ b/arch/x86/events/intel/pt.c
> @@ -1223,7 +1223,8 @@ static int pt_event_addr_filters_validate(struct list_head *filters)
>  static void pt_event_addr_filters_sync(struct perf_event *event)
>  {
>  	struct perf_addr_filters_head *head = perf_event_addr_filters(event);
> -	unsigned long msr_a, msr_b, *offs = event->addr_filters_offs;
> +	unsigned long msr_a, msr_b;
> +	struct perf_addr_filter_range *fr = event->addr_filter_ranges;
>  	struct pt_filters *filters = event->hw.addr_filters;
>  	struct perf_addr_filter *filter;
>  	int range = 0;
> @@ -1232,12 +1233,12 @@ static void pt_event_addr_filters_sync(struct perf_event *event)
>  		return;
>  
>  	list_for_each_entry(filter, &head->list, entry) {
> -		if (filter->path.dentry && !offs[range]) {
> +		if (filter->path.dentry && !fr[range].start) {
>  			msr_a = msr_b = 0;
>  		} else {
>  			/* apply the offset */
> -			msr_a = filter->offset + offs[range];
> -			msr_b = filter->size + msr_a - 1;
> +			msr_a = fr[range].start;
> +			msr_b = msr_a + fr[range].size - 1;
>  		}
>  
>  		filters->filter[range].msr_a  = msr_a;
> diff --git a/drivers/hwtracing/coresight/coresight-etm-perf.c b/drivers/hwtracing/coresight/coresight-etm-perf.c
> index 8c88bf0a1e5f..4d5a2b9f9d6a 100644
> --- a/drivers/hwtracing/coresight/coresight-etm-perf.c
> +++ b/drivers/hwtracing/coresight/coresight-etm-perf.c
> @@ -433,15 +433,16 @@ static int etm_addr_filters_validate(struct list_head *filters)
>  static void etm_addr_filters_sync(struct perf_event *event)
>  {
>  	struct perf_addr_filters_head *head = perf_event_addr_filters(event);
> -	unsigned long start, stop, *offs = event->addr_filters_offs;
> +	unsigned long start, stop;
> +	struct perf_addr_filter_range *fr = event->addr_filter_ranges;
>  	struct etm_filters *filters = event->hw.addr_filters;
>  	struct etm_filter *etm_filter;
>  	struct perf_addr_filter *filter;
>  	int i = 0;
>  
>  	list_for_each_entry(filter, &head->list, entry) {
> -		start = filter->offset + offs[i];
> -		stop = start + filter->size;
> +		start = fr[i].start;
> +		stop = start + fr[i].size;
>  		etm_filter = &filters->etm_filter[i];
>  
>  		switch (filter->action) {
> diff --git a/include/linux/perf_event.h b/include/linux/perf_event.h
> index d9c3610e0e25..6ebc72f65017 100644
> --- a/include/linux/perf_event.h
> +++ b/include/linux/perf_event.h
> @@ -490,6 +490,11 @@ struct perf_addr_filters_head {
>  	unsigned int		nr_file_filters;
>  };
>  
> +struct perf_addr_filter_range {
> +	unsigned long		start;
> +	unsigned long		size;
> +};
> +
>  /**
>   * enum perf_event_state - the states of an event:
>   */
> @@ -666,7 +671,7 @@ struct perf_event {
>  	/* address range filters */
>  	struct perf_addr_filters_head	addr_filters;
>  	/* vma address array for file-based filders */
> -	unsigned long			*addr_filters_offs;
> +	struct perf_addr_filter_range	*addr_filter_ranges;
>  	unsigned long			addr_filters_gen;
>  
>  	void (*destroy)(struct perf_event *);
> diff --git a/kernel/events/core.c b/kernel/events/core.c
> index 2d89efc0a3e0..16609f6737da 100644
> --- a/kernel/events/core.c
> +++ b/kernel/events/core.c
> @@ -2799,7 +2799,7 @@ static int perf_event_stop(struct perf_event *event, int restart)
>   *
>   * (p1) when userspace mappings change as a result of (1) or (2) or (3) below,
>   *      we update the addresses of corresponding vmas in
> - *	event::addr_filters_offs array and bump the event::addr_filters_gen;
> + *	event::addr_filter_ranges array and bump the event::addr_filters_gen;
>   * (p2) when an event is scheduled in (pmu::add), it calls
>   *      perf_event_addr_filters_sync() which calls pmu::addr_filters_sync()
>   *      if the generation has changed since the previous call.
> @@ -4446,7 +4446,7 @@ static void _free_event(struct perf_event *event)
>  
>  	perf_event_free_bpf_prog(event);
>  	perf_addr_filters_splice(event, NULL);
> -	kfree(event->addr_filters_offs);
> +	kfree(event->addr_filter_ranges);
>  
>  	if (event->destroy)
>  		event->destroy(event);
> @@ -6687,7 +6687,8 @@ static void perf_event_addr_filters_exec(struct perf_event *event, void *data)
>  	raw_spin_lock_irqsave(&ifh->lock, flags);
>  	list_for_each_entry(filter, &ifh->list, entry) {
>  		if (filter->path.dentry) {
> -			event->addr_filters_offs[count] = 0;
> +			event->addr_filter_ranges[count].start = 0;
> +			event->addr_filter_ranges[count].size = 0;
>  			restart++;
>  		}
>  
> @@ -7367,28 +7368,47 @@ static bool perf_addr_filter_match(struct perf_addr_filter *filter,
>  	return true;
>  }
>  
> +static bool perf_addr_filter_vma_adjust(struct perf_addr_filter *filter,
> +					struct vm_area_struct *vma,
> +					struct perf_addr_filter_range *fr)
> +{
> +	unsigned long vma_size = vma->vm_end - vma->vm_start;
> +	unsigned long off = vma->vm_pgoff << PAGE_SHIFT;
> +	struct file *file = vma->vm_file;
> +
> +	if (!perf_addr_filter_match(filter, file, off, vma_size))
> +		return false;
> +
> +	if (filter->offset < off) {
> +		fr->start = vma->vm_start;
> +		fr->size = min(vma_size, filter->size - (off - filter->offset));
> +	} else {
> +		fr->start = vma->vm_start + filter->offset - off;
> +		fr->size = min(vma->vm_end - fr->start, filter->size);
> +	}
> +
> +	return true;
> +}
> +
>  static void __perf_addr_filters_adjust(struct perf_event *event, void *data)
>  {
>  	struct perf_addr_filters_head *ifh = perf_event_addr_filters(event);
>  	struct vm_area_struct *vma = data;
> -	unsigned long off = vma->vm_pgoff << PAGE_SHIFT, flags;
> -	struct file *file = vma->vm_file;
>  	struct perf_addr_filter *filter;
>  	unsigned int restart = 0, count = 0;
> +	unsigned long flags;
>  
>  	if (!has_addr_filter(event))
>  		return;
>  
> -	if (!file)
> +	if (!vma->vm_file)
>  		return;
>  
>  	raw_spin_lock_irqsave(&ifh->lock, flags);
>  	list_for_each_entry(filter, &ifh->list, entry) {
> -		if (perf_addr_filter_match(filter, file, off,
> -					     vma->vm_end - vma->vm_start)) {
> -			event->addr_filters_offs[count] = vma->vm_start;
> +		if (perf_addr_filter_vma_adjust(filter, vma,
> +						&event->addr_filter_ranges[count]))
>  			restart++;
> -		}
>  
>  		count++;
>  	}
> @@ -8978,26 +8998,19 @@ static void perf_addr_filters_splice(struct perf_event *event,
>   * @filter; if so, adjust filter's address range.
>   * Called with mm::mmap_sem down for reading.
>   */
> -static unsigned long perf_addr_filter_apply(struct perf_addr_filter *filter,
> -					    struct mm_struct *mm)
> +static void perf_addr_filter_apply(struct perf_addr_filter *filter,
> +				   struct mm_struct *mm,
> +				   struct perf_addr_filter_range *fr)
>  {
>  	struct vm_area_struct *vma;
>  
>  	for (vma = mm->mmap; vma; vma = vma->vm_next) {
> -		struct file *file = vma->vm_file;
> -		unsigned long off = vma->vm_pgoff << PAGE_SHIFT;
> -		unsigned long vma_size = vma->vm_end - vma->vm_start;
> -
> -		if (!file)
> +		if (!vma->vm_file)
>  			continue;
>  
> -		if (!perf_addr_filter_match(filter, file, off, vma_size))
> -			continue;
> -
> -		return vma->vm_start;
> +		if (perf_addr_filter_vma_adjust(filter, vma, fr))
> +			return;
>  	}
> -
> -	return 0;
>  }
>  
>  /*
> @@ -9031,15 +9044,15 @@ static void perf_event_addr_filters_apply(struct perf_event *event)
>  
>  	raw_spin_lock_irqsave(&ifh->lock, flags);
>  	list_for_each_entry(filter, &ifh->list, entry) {
> -		event->addr_filters_offs[count] = 0;
> +		event->addr_filter_ranges[count].start = 0;
> +		event->addr_filter_ranges[count].size = 0;
>  
>  		/*
>  		 * Adjust base offset if the filter is associated to a binary
>  		 * that needs to be mapped:
>  		 */
>  		if (filter->path.dentry)
> -			event->addr_filters_offs[count] =
> -				perf_addr_filter_apply(filter, mm);
> +			perf_addr_filter_apply(filter, mm, &event->addr_filter_ranges[count]);
>  
>  		count++;
>  	}
> @@ -10305,10 +10318,10 @@ perf_event_alloc(struct perf_event_attr *attr, int cpu,
>  		goto err_pmu;
>  
>  	if (has_addr_filter(event)) {
> -		event->addr_filters_offs = kcalloc(pmu->nr_addr_filters,
> -						   sizeof(unsigned long),
> -						   GFP_KERNEL);
> -		if (!event->addr_filters_offs) {
> +		event->addr_filter_ranges = kcalloc(pmu->nr_addr_filters,
> +						    sizeof(struct perf_addr_filter_range),
> +						    GFP_KERNEL);
> +		if (!event->addr_filter_ranges) {
>  			err = -ENOMEM;
>  			goto err_per_task;
>  		}
> @@ -10321,9 +10334,9 @@ perf_event_alloc(struct perf_event_attr *attr, int cpu,
>  			struct perf_addr_filters_head *ifh = perf_event_addr_filters(event);
>  
>  			raw_spin_lock_irq(&ifh->lock);
> -			memcpy(event->addr_filters_offs,
> -			       event->parent->addr_filters_offs,
> -			       pmu->nr_addr_filters * sizeof(unsigned long));
> +			memcpy(event->addr_filter_ranges,
> +			       event->parent->addr_filter_ranges,
> +			       pmu->nr_addr_filters * sizeof(struct perf_addr_filter_range));
>  			raw_spin_unlock_irq(&ifh->lock);
>  		}
>  
> @@ -10345,7 +10358,7 @@ perf_event_alloc(struct perf_event_attr *attr, int cpu,
>  	return event;
>  
>  err_addr_filters:
> -	kfree(event->addr_filters_offs);
> +	kfree(event->addr_filter_ranges);
>  
>  err_per_task:
>  	exclusive_event_destroy(event);
> -- 
> 2.20.1