From mboxrd@z Thu Jan  1 00:00:00 1970
Return-Path: <SRS0=yP1V=Y7=vger.kernel.org=linux-rdma-owner@kernel.org>
X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on
	aws-us-west-2-korg-lkml-1.web.codeaurora.org
X-Spam-Level: 
X-Spam-Status: No, score=-5.4 required=3.0 tests=DKIMWL_WL_HIGH,DKIM_SIGNED,
	DKIM_VALID,DKIM_VALID_AU,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,
	MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS,USER_AGENT_SANE_1
	autolearn=unavailable autolearn_force=no version=3.4.0
Received: from mail.kernel.org (mail.kernel.org [198.145.29.99])
	by smtp.lore.kernel.org (Postfix) with ESMTP id F1117FC6196
	for <linux-rdma@archiver.kernel.org>; Thu,  7 Nov 2019 00:23:29 +0000 (UTC)
Received: from vger.kernel.org (vger.kernel.org [209.132.180.67])
	by mail.kernel.org (Postfix) with ESMTP id AD64A217F5
	for <linux-rdma@archiver.kernel.org>; Thu,  7 Nov 2019 00:23:29 +0000 (UTC)
Authentication-Results: mail.kernel.org;
	dkim=pass (2048-bit key) header.d=nvidia.com header.i=@nvidia.com header.b="KiQQ4LDy"
Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand
        id S1727944AbfKGAX3 (ORCPT <rfc822;linux-rdma@archiver.kernel.org>);
        Wed, 6 Nov 2019 19:23:29 -0500
Received: from hqemgate16.nvidia.com ([216.228.121.65]:15704 "EHLO
        hqemgate16.nvidia.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org
        with ESMTP id S1725989AbfKGAX3 (ORCPT
        <rfc822;linux-rdma@vger.kernel.org>); Wed, 6 Nov 2019 19:23:29 -0500
Received: from hqpgpgate102.nvidia.com (Not Verified[216.228.121.13]) by hqemgate16.nvidia.com (using TLS: TLSv1.2, DES-CBC3-SHA)
        id <B5dc363c20005>; Wed, 06 Nov 2019 16:22:27 -0800
Received: from hqmail.nvidia.com ([172.20.161.6])
  by hqpgpgate102.nvidia.com (PGP Universal service);
  Wed, 06 Nov 2019 16:23:23 -0800
X-PGP-Universal: processed;
        by hqpgpgate102.nvidia.com on Wed, 06 Nov 2019 16:23:23 -0800
Received: from [10.110.48.28] (10.124.1.5) by HQMAIL107.nvidia.com
 (172.20.187.13) with Microsoft SMTP Server (TLS) id 15.0.1473.3; Thu, 7 Nov
 2019 00:23:21 +0000
Subject: Re: [PATCH v2 02/15] mm/mmu_notifier: add an interval tree notifier
To:     Jason Gunthorpe <jgg@ziepe.ca>, <linux-mm@kvack.org>,
        Jerome Glisse <jglisse@redhat.com>,
        Ralph Campbell <rcampbell@nvidia.com>, <Felix.Kuehling@amd.com>
CC:     <linux-rdma@vger.kernel.org>, <dri-devel@lists.freedesktop.org>,
        <amd-gfx@lists.freedesktop.org>,
        Alex Deucher <alexander.deucher@amd.com>,
        Ben Skeggs <bskeggs@redhat.com>,
        Boris Ostrovsky <boris.ostrovsky@oracle.com>,
        =?UTF-8?Q?Christian_K=c3=b6nig?= <christian.koenig@amd.com>,
        David Zhou <David1.Zhou@amd.com>,
        "Dennis Dalessandro" <dennis.dalessandro@intel.com>,
        Juergen Gross <jgross@suse.com>,
        Mike Marciniszyn <mike.marciniszyn@intel.com>,
        Oleksandr Andrushchenko <oleksandr_andrushchenko@epam.com>,
        Petr Cvek <petrcvekcz@gmail.com>,
        Stefano Stabellini <sstabellini@kernel.org>,
        <nouveau@lists.freedesktop.org>, <xen-devel@lists.xenproject.org>,
        "Christoph Hellwig" <hch@infradead.org>,
        Jason Gunthorpe <jgg@mellanox.com>,
        "Andrea Arcangeli" <aarcange@redhat.com>,
        Michal Hocko <mhocko@kernel.org>
References: <20191028201032.6352-1-jgg@ziepe.ca>
 <20191028201032.6352-3-jgg@ziepe.ca>
X-Nvconfidentiality: public
From:   John Hubbard <jhubbard@nvidia.com>
Message-ID: <35c2b322-004e-0e18-87e4-1920dc71bfd5@nvidia.com>
Date:   Wed, 6 Nov 2019 16:23:21 -0800
User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:60.0) Gecko/20100101
 Thunderbird/60.8.0
MIME-Version: 1.0
In-Reply-To: <20191028201032.6352-3-jgg@ziepe.ca>
X-Originating-IP: [10.124.1.5]
X-ClientProxiedBy: HQMAIL105.nvidia.com (172.20.187.12) To
 HQMAIL107.nvidia.com (172.20.187.13)
Content-Type: text/plain; charset="utf-8"
Content-Language: en-US
Content-Transfer-Encoding: 7bit
DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=nvidia.com; s=n1;
        t=1573086147; bh=wcGT9xMQYHuXfFscUQsjE5NTf0ZA6XJfn+TCAYtZiBE=;
        h=X-PGP-Universal:Subject:To:CC:References:X-Nvconfidentiality:From:
         Message-ID:Date:User-Agent:MIME-Version:In-Reply-To:
         X-Originating-IP:X-ClientProxiedBy:Content-Type:Content-Language:
         Content-Transfer-Encoding;
        b=KiQQ4LDyxKXYIitiaRH6a8gsJ4dGhAyOwYM7DFJdAyGJJBY3oq01CkMaJ9YchQ48q
         S8p0H+M/dgsvISqRDU5deHEqFujQiLM0nmjKtDoHgycaWrEdOq/u72/QWCG3GbqPzt
         DwaP7KV1LZDeFUTiiuyaLyiDSDtdJrpAIjhBmR3DZbzX2ylQyNbRl4t1hyWAb9gKNW
         6MSsYSuHvzmEbihgwRd3FUAb81gqORq9QD9eTo+r61EpuB2TYaHUJWpVNalIVlzBaV
         XPVEiITQ6xu6lP175Mfr/LRZjaj3XWM5EbZ8Z3JfPKLHjUlDKu0PNeaVfd/ppHUsju
         uXdrdN8657ruQ==
Sender: linux-rdma-owner@vger.kernel.org
Precedence: bulk
List-ID: <linux-rdma.vger.kernel.org>
X-Mailing-List: linux-rdma@vger.kernel.org

On 10/28/19 1:10 PM, Jason Gunthorpe wrote:
...
>  include/linux/mmu_notifier.h |  98 +++++++
>  mm/Kconfig                   |   1 +
>  mm/mmu_notifier.c            | 533 +++++++++++++++++++++++++++++++++--
>  3 files changed, 607 insertions(+), 25 deletions(-)
> 
> diff --git a/include/linux/mmu_notifier.h b/include/linux/mmu_notifier.h
> index 12bd603d318ce7..51b92ba013ddce 100644
> --- a/include/linux/mmu_notifier.h
> +++ b/include/linux/mmu_notifier.h
> @@ -6,10 +6,12 @@
>  #include <linux/spinlock.h>
>  #include <linux/mm_types.h>
>  #include <linux/srcu.h>
> +#include <linux/interval_tree.h>
>  
>  struct mmu_notifier_mm;
>  struct mmu_notifier;
>  struct mmu_notifier_range;
> +struct mmu_range_notifier;

Hi Jason,

Nice design, I love the seq foundation! So far, I'm not able to spot anything
actually wrong with the implementation, sorry about that. 

Generally my reaction is: given that the design is complex, try to mitigate 
that with documentation and naming. So the comments are in these areas:

1. There is a rather severe naming overlap (not technically a naming conflict,
but still) with existing mmn work, which already has, for example:

    struct mmu_notifier_range

...and you're adding:

    struct mmu_range_notifier

...so I'll try to help sort that out.

2. I'm also seeing a couple of things that are really hard for the reader
verify are correct (abuse and battery of the low bit in .invalidate_seq, 
for example, haha), so I have some recommendations there.

3. Documentation improvements, which easy to apply, with perhaps one exception.
(Here, because this a complicated area, documentation does make a difference,
so it's worth a little extra fuss.)

4. Other nits that don't matter too much, but just help polish things up
as usual.

>  
>  /**
>   * enum mmu_notifier_event - reason for the mmu notifier callback
> @@ -32,6 +34,9 @@ struct mmu_notifier_range;
>   * access flags). User should soft dirty the page in the end callback to make
>   * sure that anyone relying on soft dirtyness catch pages that might be written
>   * through non CPU mappings.
> + *
> + * @MMU_NOTIFY_RELEASE: used during mmu_range_notifier invalidate to signal that
> + * the mm refcount is zero and the range is no longer accessible.
>   */
>  enum mmu_notifier_event {
>  	MMU_NOTIFY_UNMAP = 0,
> @@ -39,6 +44,7 @@ enum mmu_notifier_event {
>  	MMU_NOTIFY_PROTECTION_VMA,
>  	MMU_NOTIFY_PROTECTION_PAGE,
>  	MMU_NOTIFY_SOFT_DIRTY,
> +	MMU_NOTIFY_RELEASE,
>  };


OK, let the naming debates begin! ha. Anyway, after careful study of the overall
patch, and some browsing of the larger patchset, it's clear that:

* The new "MMU range notifier" that you've created is, approximately, a new
object. It uses classic mmu notifiers inside, as an implementation detail, and
it does *similar* things (notifications) as mmn's. But it's certainly not the same
as mmn's, as shown later when you say the need to an entirely new ops struct, and 
data struct too.

Therefore, you need a separate events enum as well. This is important. MMN's
won't be issuing MMN_NOTIFY_RELEASE events, nor will MNR's be issuing the first
four prexisting MMU_NOTIFY_* items. So it would be a design mistake to glom them
together, unless you ultimately decided to merge these MMN and MNR objects (which
I don't really see any intention of, and that's fine).

So this should read:

enum mmu_range_notifier_event {
	MMU_NOTIFY_RELEASE,
};

...assuming that we stay with "mmu_range_notifier" as a core name for this 
whole thing.

Also, it is best moved down to be next to the new MNR structs, so that all the
MNR stuff is in one group.

Extra credit: IMHO, this clearly deserves to all be in a new mmu_range_notifier.h
header file, but I know that's extra work. Maybe later as a follow-up patch,
if anyone has the time.

>  
>  #define MMU_NOTIFIER_RANGE_BLOCKABLE (1 << 0)
> @@ -222,6 +228,26 @@ struct mmu_notifier {
>  	unsigned int users;
>  };
>  

That should also be moved down, next to the new structs.



A little bit above these next items, just above "struct mmu_notifier" (not shown here, 
it's outside the diff area), there is some documentation about classic MMNs. It would 
be nice if it were clearer that that documentation is not relevant to MNRs. Actually, 
this is another reason that a separate header file would be nice.

> +/**
> + * struct mmu_range_notifier_ops
> + * @invalidate: Upon return the caller must stop using any SPTEs within this
> + *              range, this function can sleep. Return false if blocking was
> + *              required but range is non-blocking
> + */

How about this (I'm not sure I fully understand the return value, though):

/**
 * struct mmu_range_notifier_ops
 * @invalidate: Upon return the caller must stop using any SPTEs within this
 * 		range.
 *
 * 		This function is permitted to sleep.
 *
 *      	@Return: false if blocking was required, but @range is
 *			non-blocking.
 *
 */


> +struct mmu_range_notifier_ops {
> +	bool (*invalidate)(struct mmu_range_notifier *mrn,
> +			   const struct mmu_notifier_range *range,
> +			   unsigned long cur_seq);
> +};
> +
> +struct mmu_range_notifier {
> +	struct interval_tree_node interval_tree;
> +	const struct mmu_range_notifier_ops *ops;
> +	struct hlist_node deferred_item;
> +	unsigned long invalidate_seq;
> +	struct mm_struct *mm;
> +};
> +

Again, now we have the new struct mmu_range_notifier, and the old 
struct mmu_notifier_range, and it's not good.

Ideas:

a) Live with it.

b) (Discarded, too many callers): rename old one. Nope.

c) Rename new one. Ideas:

    struct mmu_interval_notifier
    struct mmu_range_intersection
    ...other ideas?


>  #ifdef CONFIG_MMU_NOTIFIER
>  
>  #ifdef CONFIG_LOCKDEP
> @@ -263,6 +289,78 @@ extern int __mmu_notifier_register(struct mmu_notifier *mn,
>  				   struct mm_struct *mm);
>  extern void mmu_notifier_unregister(struct mmu_notifier *mn,
>  				    struct mm_struct *mm);
> +
> +unsigned long mmu_range_read_begin(struct mmu_range_notifier *mrn);
> +int mmu_range_notifier_insert(struct mmu_range_notifier *mrn,
> +			      unsigned long start, unsigned long length,
> +			      struct mm_struct *mm);
> +int mmu_range_notifier_insert_locked(struct mmu_range_notifier *mrn,
> +				     unsigned long start, unsigned long length,
> +				     struct mm_struct *mm);
> +void mmu_range_notifier_remove(struct mmu_range_notifier *mrn);
> +
> +/**
> + * mmu_range_set_seq - Save the invalidation sequence

How about:

 * mmu_range_set_seq - Set the .invalidate_seq to a new value.


> + * @mrn - The mrn passed to invalidate
> + * @cur_seq - The cur_seq passed to invalidate
> + *
> + * This must be called unconditionally from the invalidate callback of a
> + * struct mmu_range_notifier_ops under the same lock that is used to call
> + * mmu_range_read_retry(). It updates the sequence number for later use by
> + * mmu_range_read_retry().
> + *
> + * If the user does not call mmu_range_read_begin() or mmu_range_read_retry()

nit: "caller" is better than "user", when referring to...well, callers. "user" 
most often refers to user space, whereas a call stack and function calling is 
clearly what you're referring to here (and in other places, especially "user lock").

> + * then this call is not required.
> + */
> +static inline void mmu_range_set_seq(struct mmu_range_notifier *mrn,
> +				     unsigned long cur_seq)
> +{
> +	WRITE_ONCE(mrn->invalidate_seq, cur_seq);
> +}
> +
> +/**
> + * mmu_range_read_retry - End a read side critical section against a VA range
> + * mrn: The range under lock
> + * seq: The return of the paired mmu_range_read_begin()
> + *
> + * This MUST be called under a user provided lock that is also held
> + * unconditionally by op->invalidate() when it calls mmu_range_set_seq().
> + *
> + * Each call should be paired with a single mmu_range_read_begin() and
> + * should be used to conclude the read side.
> + *
> + * Returns true if an invalidation collided with this critical section, and
> + * the caller should retry.
> + */
> +static inline bool mmu_range_read_retry(struct mmu_range_notifier *mrn,
> +					unsigned long seq)
> +{
> +	return mrn->invalidate_seq != seq;
> +}
> +
> +/**
> + * mmu_range_check_retry - Test if a collision has occurred
> + * mrn: The range under lock
> + * seq: The return of the matching mmu_range_read_begin()
> + *
> + * This can be used in the critical section between mmu_range_read_begin() and
> + * mmu_range_read_retry().  A return of true indicates an invalidation has
> + * collided with this lock and a future mmu_range_read_retry() will return
> + * true.
> + *
> + * False is not reliable and only suggests a collision has not happened. It

let's say "suggests that a collision *may* not have occurred."  

...
> diff --git a/mm/mmu_notifier.c b/mm/mmu_notifier.c
> index 367670cfd02b7b..d02d3c8c223eb7 100644
> --- a/mm/mmu_notifier.c
> +++ b/mm/mmu_notifier.c
> @@ -12,6 +12,7 @@
>  #include <linux/export.h>
>  #include <linux/mm.h>
>  #include <linux/err.h>
> +#include <linux/interval_tree.h>
>  #include <linux/srcu.h>
>  #include <linux/rcupdate.h>
>  #include <linux/sched.h>
> @@ -36,10 +37,243 @@ struct lockdep_map __mmu_notifier_invalidate_range_start_map = {
>  struct mmu_notifier_mm {
>  	/* all mmu notifiers registered in this mm are queued in this list */
>  	struct hlist_head list;
> +	bool has_interval;
>  	/* to serialize the list modifications and hlist_unhashed */
>  	spinlock_t lock;
> +	unsigned long invalidate_seq;
> +	unsigned long active_invalidate_ranges;
> +	struct rb_root_cached itree;
> +	wait_queue_head_t wq;
> +	struct hlist_head deferred_list;
>  };
>  
> +/*
> + * This is a collision-retry read-side/write-side 'lock', a lot like a
> + * seqcount, however this allows multiple write-sides to hold it at
> + * once. Conceptually the write side is protecting the values of the PTEs in
> + * this mm, such that PTES cannot be read into SPTEs while any writer exists.

Just to be kind, can we say "SPTEs (shadow PTEs)", just this once? :)

> + *
> + * Note that the core mm creates nested invalidate_range_start()/end() regions
> + * within the same thread, and runs invalidate_range_start()/end() in parallel
> + * on multiple CPUs. This is designed to not reduce concurrency or block
> + * progress on the mm side.
> + *
> + * As a secondary function, holding the full write side also serves to prevent
> + * writers for the itree, this is an optimization to avoid extra locking
> + * during invalidate_range_start/end notifiers.
> + *
> + * The write side has two states, fully excluded:
> + *  - mm->active_invalidate_ranges != 0
> + *  - mnn->invalidate_seq & 1 == True
> + *  - some range on the mm_struct is being invalidated
> + *  - the itree is not allowed to change
> + *
> + * And partially excluded:
> + *  - mm->active_invalidate_ranges != 0

I assume this implies mnn->invalidate_seq & 1 == False in this case? If so,
let's say so. I'm probably getting that wrong, too.

> + *  - some range on the mm_struct is being invalidated
> + *  - the itree is allowed to change
> + *
> + * The later state avoids some expensive work on inv_end in the common case of
> + * no mrn monitoring the VA.
> + */
> +static bool mn_itree_is_invalidating(struct mmu_notifier_mm *mmn_mm)
> +{
> +	lockdep_assert_held(&mmn_mm->lock);
> +	return mmn_mm->invalidate_seq & 1;
> +}
> +
> +static struct mmu_range_notifier *
> +mn_itree_inv_start_range(struct mmu_notifier_mm *mmn_mm,
> +			 const struct mmu_notifier_range *range,
> +			 unsigned long *seq)
> +{
> +	struct interval_tree_node *node;
> +	struct mmu_range_notifier *res = NULL;
> +
> +	spin_lock(&mmn_mm->lock);
> +	mmn_mm->active_invalidate_ranges++;
> +	node = interval_tree_iter_first(&mmn_mm->itree, range->start,
> +					range->end - 1);
> +	if (node) {
> +		mmn_mm->invalidate_seq |= 1;


OK, this either needs more documentation and assertions, or a different
approach. Because I see addition, subtraction, AND, OR and booleans
all being applied to this field, and it's darn near hopeless to figure
out whether or not it really is even or odd at the right times.

Different approach: why not just add a mmn_mm->is_invalidating 
member variable? It's not like you're short of space in that struct.


> +		res = container_of(node, struct mmu_range_notifier,
> +				   interval_tree);
> +	}
> +
> +	*seq = mmn_mm->invalidate_seq;
> +	spin_unlock(&mmn_mm->lock);
> +	return res;
> +}
> +
> +static struct mmu_range_notifier *
> +mn_itree_inv_next(struct mmu_range_notifier *mrn,
> +		  const struct mmu_notifier_range *range)
> +{
> +	struct interval_tree_node *node;
> +
> +	node = interval_tree_iter_next(&mrn->interval_tree, range->start,
> +				       range->end - 1);
> +	if (!node)
> +		return NULL;
> +	return container_of(node, struct mmu_range_notifier, interval_tree);
> +}
> +
> +static void mn_itree_inv_end(struct mmu_notifier_mm *mmn_mm)
> +{
> +	struct mmu_range_notifier *mrn;
> +	struct hlist_node *next;
> +	bool need_wake = false;
> +
> +	spin_lock(&mmn_mm->lock);
> +	if (--mmn_mm->active_invalidate_ranges ||
> +	    !mn_itree_is_invalidating(mmn_mm)) {
> +		spin_unlock(&mmn_mm->lock);
> +		return;
> +	}
> +
> +	mmn_mm->invalidate_seq++;

Is this the right place for an assertion that this is now an even value?

> +	need_wake = true;
> +
> +	/*
> +	 * The inv_end incorporates a deferred mechanism like
> +	 * rtnl_lock(). Adds and removes are queued until the final inv_end

Let me point out that rtnl_lock() itself is a one-liner that calls mutex_lock().
But I suppose if one studies that file closely there is more. :)

...

> +unsigned long mmu_range_read_begin(struct mmu_range_notifier *mrn)
> +{
> +	struct mmu_notifier_mm *mmn_mm = mrn->mm->mmu_notifier_mm;
> +	unsigned long seq;
> +	bool is_invalidating;
> +
> +	/*
> +	 * If the mrn has a different seq value under the user_lock than we
> +	 * started with then it has collided.
> +	 *
> +	 * If the mrn currently has the same seq value as the mmn_mm seq, then
> +	 * it is currently between invalidate_start/end and is colliding.
> +	 *
> +	 * The locking looks broadly like this:
> +	 *   mn_tree_invalidate_start():          mmu_range_read_begin():
> +	 *                                         spin_lock
> +	 *                                          seq = READ_ONCE(mrn->invalidate_seq);
> +	 *                                          seq == mmn_mm->invalidate_seq
> +	 *                                         spin_unlock
> +	 *    spin_lock
> +	 *     seq = ++mmn_mm->invalidate_seq
> +	 *    spin_unlock
> +	 *     op->invalidate_range():
> +	 *       user_lock
> +	 *        mmu_range_set_seq()
> +	 *         mrn->invalidate_seq = seq
> +	 *       user_unlock
> +	 *
> +	 *                          [Required: mmu_range_read_retry() == true]
> +	 *
> +	 *   mn_itree_inv_end():
> +	 *    spin_lock
> +	 *     seq = ++mmn_mm->invalidate_seq
> +	 *    spin_unlock
> +	 *
> +	 *                                        user_lock
> +	 *                                         mmu_range_read_retry():
> +	 *                                          mrn->invalidate_seq != seq
> +	 *                                        user_unlock
> +	 *
> +	 * Barriers are not needed here as any races here are closed by an
> +	 * eventual mmu_range_read_retry(), which provides a barrier via the
> +	 * user_lock.
> +	 */
> +	spin_lock(&mmn_mm->lock);
> +	/* Pairs with the WRITE_ONCE in mmu_range_set_seq() */
> +	seq = READ_ONCE(mrn->invalidate_seq);
> +	is_invalidating = seq == mmn_mm->invalidate_seq;
> +	spin_unlock(&mmn_mm->lock);
> +
> +	/*
> +	 * mrn->invalidate_seq is always set to an odd value. This ensures

This claim just looks wrong the first N times one reads the code, given that
there is mmu_range_set_seq() to set it to an arbitrary value!  Maybe you mean

"is always set to an odd value when invalidating"??

> +	 * that if seq does wrap we will always clear the below sleep in some
> +	 * reasonable time as mmn_mm->invalidate_seq is even in the idle
> +	 * state.
> +	 */

Let's move that comment higher up. The code that follows it has nothing to
do with it, so it's confusing here.

...
> @@ -529,6 +852,166 @@ void mmu_notifier_put(struct mmu_notifier *mn)
>  }
>  EXPORT_SYMBOL_GPL(mmu_notifier_put);
>  
> +static int __mmu_range_notifier_insert(struct mmu_range_notifier *mrn,
> +				       unsigned long start,
> +				       unsigned long length,
> +				       struct mmu_notifier_mm *mmn_mm,
> +				       struct mm_struct *mm)
> +{
> +	mrn->mm = mm;
> +	RB_CLEAR_NODE(&mrn->interval_tree.rb);
> +	mrn->interval_tree.start = start;
> +	/*
> +	 * Note that the representation of the intervals in the interval tree
> +	 * considers the ending point as contained in the interval.

Thanks for that comment!

> +	 */
> +	if (length == 0 ||
> +	    check_add_overflow(start, length - 1, &mrn->interval_tree.last))
> +		return -EOVERFLOW;
> +
> +	/* pairs with mmdrop in mmu_range_notifier_remove() */
> +	mmgrab(mm);
> +
> +	/*
> +	 * If some invalidate_range_start/end region is going on in parallel
> +	 * we don't know what VA ranges are affected, so we must assume this
> +	 * new range is included.
> +	 *
> +	 * If the itree is invalidating then we are not allowed to change
> +	 * it. Retrying until invalidation is done is tricky due to the
> +	 * possibility for live lock, instead defer the add to the unlock so
> +	 * this algorithm is deterministic.
> +	 *
> +	 * In all cases the value for the mrn->mr_invalidate_seq should be
> +	 * odd, see mmu_range_read_begin()
> +	 */
> +	spin_lock(&mmn_mm->lock);
> +	if (mmn_mm->active_invalidate_ranges) {
> +		if (mn_itree_is_invalidating(mmn_mm))
> +			hlist_add_head(&mrn->deferred_item,
> +				       &mmn_mm->deferred_list);
> +		else {
> +			mmn_mm->invalidate_seq |= 1;
> +			interval_tree_insert(&mrn->interval_tree,
> +					     &mmn_mm->itree);
> +		}
> +		mrn->invalidate_seq = mmn_mm->invalidate_seq;
> +	} else {
> +		WARN_ON(mn_itree_is_invalidating(mmn_mm));
> +		mrn->invalidate_seq = mmn_mm->invalidate_seq - 1;

Ohhh, checkmate. I lose. Why is *subtracting* the right thing to do
for seq numbers here?  I'm acutely unhappy trying to figure this out.
I suspect it's another unfortunate side effect of trying to use the
lower bit of the seq number (even/odd) for something else.

> +		interval_tree_insert(&mrn->interval_tree, &mmn_mm->itree);
> +	}
> +	spin_unlock(&mmn_mm->lock);
> +	return 0;
> +}
> +
> +/**
> + * mmu_range_notifier_insert - Insert a range notifier
> + * @mrn: Range notifier to register
> + * @start: Starting virtual address to monitor
> + * @length: Length of the range to monitor
> + * @mm : mm_struct to attach to
> + *
> + * This function subscribes the range notifier for notifications from the mm.
> + * Upon return the ops related to mmu_range_notifier will be called whenever
> + * an event that intersects with the given range occurs.
> + *
> + * Upon return the range_notifier may not be present in the interval tree yet.
> + * The caller must use the normal range notifier locking flow via
> + * mmu_range_read_begin() to establish SPTEs for this range.
> + */
> +int mmu_range_notifier_insert(struct mmu_range_notifier *mrn,
> +			      unsigned long start, unsigned long length,
> +			      struct mm_struct *mm)
> +{
> +	struct mmu_notifier_mm *mmn_mm;
> +	int ret;

Hmmm, I think a later patch improperly changes the above to "int ret = 0;".
I'll check on that. It's correct here, though.

> +
> +	might_lock(&mm->mmap_sem);
> +
> +	mmn_mm = smp_load_acquire(&mm->mmu_notifier_mm);

What does the above pair with? Should have a comment that specifies that.

 
thanks,

John Hubbard
NVIDIA

From mboxrd@z Thu Jan  1 00:00:00 1970
From: John Hubbard <jhubbard@nvidia.com>
Subject: Re: [PATCH v2 02/15] mm/mmu_notifier: add an interval tree notifier
Date: Wed, 6 Nov 2019 16:23:21 -0800
Message-ID: <35c2b322-004e-0e18-87e4-1920dc71bfd5@nvidia.com>
References: <20191028201032.6352-1-jgg@ziepe.ca>
 <20191028201032.6352-3-jgg@ziepe.ca>
Mime-Version: 1.0
Content-Type: text/plain; charset="utf-8"
Content-Transfer-Encoding: base64
Return-path: <dri-devel-bounces@lists.freedesktop.org>
In-Reply-To: <20191028201032.6352-3-jgg@ziepe.ca>
Content-Language: en-US
List-Unsubscribe: <https://lists.freedesktop.org/mailman/options/dri-devel>,
 <mailto:dri-devel-request@lists.freedesktop.org?subject=unsubscribe>
List-Archive: <https://lists.freedesktop.org/archives/dri-devel>
List-Post: <mailto:dri-devel@lists.freedesktop.org>
List-Help: <mailto:dri-devel-request@lists.freedesktop.org?subject=help>
List-Subscribe: <https://lists.freedesktop.org/mailman/listinfo/dri-devel>,
 <mailto:dri-devel-request@lists.freedesktop.org?subject=subscribe>
Errors-To: dri-devel-bounces@lists.freedesktop.org
Sender: "dri-devel" <dri-devel-bounces@lists.freedesktop.org>
To: Jason Gunthorpe <jgg@ziepe.ca>, linux-mm@kvack.org, Jerome Glisse <jglisse@redhat.com>, Ralph Campbell <rcampbell@nvidia.com>, Felix.Kuehling@amd.com
Cc: Juergen Gross <jgross@suse.com>, Mike Marciniszyn <mike.marciniszyn@intel.com>, Stefano Stabellini <sstabellini@kernel.org>, Andrea Arcangeli <aarcange@redhat.com>, Oleksandr Andrushchenko <oleksandr_andrushchenko@epam.com>, linux-rdma@vger.kernel.org, nouveau@lists.freedesktop.org, Dennis Dalessandro <dennis.dalessandro@intel.com>, amd-gfx@lists.freedesktop.org, Michal Hocko <mhocko@kernel.org>, Christoph Hellwig <hch@infradead.org>, Jason Gunthorpe <jgg@mellanox.com>, dri-devel@lists.freedesktop.org, Alex Deucher <alexander.deucher@amd.com>, xen-devel@lists.xenproject.org, Boris Ostrovsky <boris.ostrovsky@oracle.com>, Petr Cvek <petrcvekcz@gmail.com>, =?UTF-8?Q?Christian_K=c3=b6nig?= <christian.koenig@amd.com>, Ben Skeggs <bskeggs@redhat.com>
List-Id: nouveau.vger.kernel.org
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From mboxrd@z Thu Jan  1 00:00:00 1970
Return-Path: <SRS0=dgzG=Y7=lists.freedesktop.org=dri-devel-bounces@kernel.org>
X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on
	aws-us-west-2-korg-lkml-1.web.codeaurora.org
X-Spam-Level: 
X-Spam-Status: No, score=-5.2 required=3.0 tests=HEADER_FROM_DIFFERENT_DOMAINS,
	INCLUDES_PATCH,MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS,USER_AGENT_SANE_1
	autolearn=unavailable autolearn_force=no version=3.4.0
Received: from mail.kernel.org (mail.kernel.org [198.145.29.99])
	by smtp.lore.kernel.org (Postfix) with ESMTP id 24751FA372C
	for <dri-devel@archiver.kernel.org>; Thu,  7 Nov 2019 00:23:27 +0000 (UTC)
Received: from gabe.freedesktop.org (gabe.freedesktop.org [131.252.210.177])
	(using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits))
	(No client certificate requested)
	by mail.kernel.org (Postfix) with ESMTPS id F14DE20869
	for <dri-devel@archiver.kernel.org>; Thu,  7 Nov 2019 00:23:26 +0000 (UTC)
DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org F14DE20869
Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=nvidia.com
Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=dri-devel-bounces@lists.freedesktop.org
Received: from gabe.freedesktop.org (localhost [127.0.0.1])
	by gabe.freedesktop.org (Postfix) with ESMTP id 488D26EE4F;
	Thu,  7 Nov 2019 00:23:26 +0000 (UTC)
Received: from hqemgate16.nvidia.com (hqemgate16.nvidia.com [216.228.121.65])
 by gabe.freedesktop.org (Postfix) with ESMTPS id 9217B6EE4D;
 Thu,  7 Nov 2019 00:23:24 +0000 (UTC)
Received: from hqpgpgate102.nvidia.com (Not Verified[216.228.121.13]) by
 hqemgate16.nvidia.com (using TLS: TLSv1.2, DES-CBC3-SHA)
 id <B5dc363c20005>; Wed, 06 Nov 2019 16:22:27 -0800
Received: from hqmail.nvidia.com ([172.20.161.6])
 by hqpgpgate102.nvidia.com (PGP Universal service);
 Wed, 06 Nov 2019 16:23:23 -0800
X-PGP-Universal: processed;
 by hqpgpgate102.nvidia.com on Wed, 06 Nov 2019 16:23:23 -0800
Received: from [10.110.48.28] (10.124.1.5) by HQMAIL107.nvidia.com
 (172.20.187.13) with Microsoft SMTP Server (TLS) id 15.0.1473.3; Thu, 7 Nov
 2019 00:23:21 +0000
Subject: Re: [PATCH v2 02/15] mm/mmu_notifier: add an interval tree notifier
To: Jason Gunthorpe <jgg@ziepe.ca>, <linux-mm@kvack.org>, Jerome Glisse
 <jglisse@redhat.com>, Ralph Campbell <rcampbell@nvidia.com>,
 <Felix.Kuehling@amd.com>
References: <20191028201032.6352-1-jgg@ziepe.ca>
 <20191028201032.6352-3-jgg@ziepe.ca>
X-Nvconfidentiality: public
From: John Hubbard <jhubbard@nvidia.com>
Message-ID: <35c2b322-004e-0e18-87e4-1920dc71bfd5@nvidia.com>
Date: Wed, 6 Nov 2019 16:23:21 -0800
User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:60.0) Gecko/20100101
 Thunderbird/60.8.0
MIME-Version: 1.0
In-Reply-To: <20191028201032.6352-3-jgg@ziepe.ca>
X-Originating-IP: [10.124.1.5]
X-ClientProxiedBy: HQMAIL105.nvidia.com (172.20.187.12) To
 HQMAIL107.nvidia.com (172.20.187.13)
Content-Language: en-US
X-Mailman-Original-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed;
 d=nvidia.com; s=n1; 
 t=1573086147; bh=wcGT9xMQYHuXfFscUQsjE5NTf0ZA6XJfn+TCAYtZiBE=;
 h=X-PGP-Universal:Subject:To:CC:References:X-Nvconfidentiality:From:
 Message-ID:Date:User-Agent:MIME-Version:In-Reply-To:
 X-Originating-IP:X-ClientProxiedBy:Content-Type:Content-Language:
 Content-Transfer-Encoding;
 b=KiQQ4LDyxKXYIitiaRH6a8gsJ4dGhAyOwYM7DFJdAyGJJBY3oq01CkMaJ9YchQ48q
 S8p0H+M/dgsvISqRDU5deHEqFujQiLM0nmjKtDoHgycaWrEdOq/u72/QWCG3GbqPzt
 DwaP7KV1LZDeFUTiiuyaLyiDSDtdJrpAIjhBmR3DZbzX2ylQyNbRl4t1hyWAb9gKNW
 6MSsYSuHvzmEbihgwRd3FUAb81gqORq9QD9eTo+r61EpuB2TYaHUJWpVNalIVlzBaV
 XPVEiITQ6xu6lP175Mfr/LRZjaj3XWM5EbZ8Z3JfPKLHjUlDKu0PNeaVfd/ppHUsju
 uXdrdN8657ruQ==
X-BeenThere: dri-devel@lists.freedesktop.org
X-Mailman-Version: 2.1.23
Precedence: list
List-Id: Direct Rendering Infrastructure - Development
 <dri-devel.lists.freedesktop.org>
List-Unsubscribe: <https://lists.freedesktop.org/mailman/options/dri-devel>,
 <mailto:dri-devel-request@lists.freedesktop.org?subject=unsubscribe>
List-Archive: <https://lists.freedesktop.org/archives/dri-devel>
List-Post: <mailto:dri-devel@lists.freedesktop.org>
List-Help: <mailto:dri-devel-request@lists.freedesktop.org?subject=help>
List-Subscribe: <https://lists.freedesktop.org/mailman/listinfo/dri-devel>,
 <mailto:dri-devel-request@lists.freedesktop.org?subject=subscribe>
Cc: Juergen Gross <jgross@suse.com>,
 Mike Marciniszyn <mike.marciniszyn@intel.com>,
 Stefano Stabellini <sstabellini@kernel.org>,
 Andrea Arcangeli <aarcange@redhat.com>,
 Oleksandr Andrushchenko <oleksandr_andrushchenko@epam.com>,
 linux-rdma@vger.kernel.org, nouveau@lists.freedesktop.org, Dennis
 Dalessandro <dennis.dalessandro@intel.com>, amd-gfx@lists.freedesktop.org,
 Michal Hocko <mhocko@kernel.org>, Christoph Hellwig <hch@infradead.org>,
 Jason Gunthorpe <jgg@mellanox.com>, dri-devel@lists.freedesktop.org,
 Alex Deucher <alexander.deucher@amd.com>, xen-devel@lists.xenproject.org,
 Boris Ostrovsky <boris.ostrovsky@oracle.com>, Petr Cvek <petrcvekcz@gmail.com>,
 =?UTF-8?Q?Christian_K=c3=b6nig?= <christian.koenig@amd.com>,
 Ben Skeggs <bskeggs@redhat.com>
Content-Type: text/plain; charset="utf-8"
Content-Transfer-Encoding: base64
Errors-To: dri-devel-bounces@lists.freedesktop.org
Sender: "dri-devel" <dri-devel-bounces@lists.freedesktop.org>
Message-ID: <20191107002321.HPPV8dJu8hvraGsc1LRkBH9fwMQ_NLPh4m57gv1o1VY@z>
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From mboxrd@z Thu Jan  1 00:00:00 1970
Return-Path: <SRS0=uIE0=Y7=lists.xenproject.org=xen-devel-bounces@kernel.org>
X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on
	aws-us-west-2-korg-lkml-1.web.codeaurora.org
X-Spam-Level: 
X-Spam-Status: No, score=-5.0 required=3.0 tests=DKIM_INVALID,DKIM_SIGNED,
	HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI,SPF_HELO_NONE,
	SPF_PASS,URIBL_BLOCKED,USER_AGENT_SANE_1 autolearn=ham autolearn_force=no
	version=3.4.0
Received: from mail.kernel.org (mail.kernel.org [198.145.29.99])
	by smtp.lore.kernel.org (Postfix) with ESMTP id 9E843FA372C
	for <xen-devel@archiver.kernel.org>; Thu,  7 Nov 2019 00:24:10 +0000 (UTC)
Received: from lists.xenproject.org (lists.xenproject.org [192.237.175.120])
	(using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits))
	(No client certificate requested)
	by mail.kernel.org (Postfix) with ESMTPS id 57583206DF
	for <xen-devel@archiver.kernel.org>; Thu,  7 Nov 2019 00:24:10 +0000 (UTC)
Authentication-Results: mail.kernel.org;
	dkim=fail reason="signature verification failed" (2048-bit key) header.d=nvidia.com header.i=@nvidia.com header.b="KiQQ4LDy"
DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 57583206DF
Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=nvidia.com
Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=xen-devel-bounces@lists.xenproject.org
Received: from localhost ([127.0.0.1] helo=lists.xenproject.org)
	by lists.xenproject.org with esmtp (Exim 4.89)
	(envelope-from <xen-devel-bounces@lists.xenproject.org>)
	id 1iSVaB-0007v9-V6; Thu, 07 Nov 2019 00:23:27 +0000
Received: from us1-rack-iad1.inumbo.com ([172.99.69.81])
 by lists.xenproject.org with esmtp (Exim 4.89) (envelope-from
 <SRS0=EOb2=Y7=nvidia.com=jhubbard@srs-us1.protection.inumbo.net>)
 id 1iSVaA-0007v4-8I
 for xen-devel@lists.xenproject.org; Thu, 07 Nov 2019 00:23:26 +0000
X-Inumbo-ID: cfd1995c-00f4-11ea-9631-bc764e2007e4
Received: from hqemgate16.nvidia.com (unknown [216.228.121.65])
 by us1-rack-iad1.inumbo.com (Halon) with ESMTPS
 id cfd1995c-00f4-11ea-9631-bc764e2007e4;
 Thu, 07 Nov 2019 00:23:25 +0000 (UTC)
Received: from hqpgpgate102.nvidia.com (Not Verified[216.228.121.13]) by
 hqemgate16.nvidia.com (using TLS: TLSv1.2, DES-CBC3-SHA)
 id <B5dc363c20005>; Wed, 06 Nov 2019 16:22:27 -0800
Received: from hqmail.nvidia.com ([172.20.161.6])
 by hqpgpgate102.nvidia.com (PGP Universal service);
 Wed, 06 Nov 2019 16:23:23 -0800
X-PGP-Universal: processed;
 by hqpgpgate102.nvidia.com on Wed, 06 Nov 2019 16:23:23 -0800
Received: from [10.110.48.28] (10.124.1.5) by HQMAIL107.nvidia.com
 (172.20.187.13) with Microsoft SMTP Server (TLS) id 15.0.1473.3; Thu, 7 Nov
 2019 00:23:21 +0000
To: Jason Gunthorpe <jgg@ziepe.ca>, <linux-mm@kvack.org>, Jerome Glisse
 <jglisse@redhat.com>, Ralph Campbell <rcampbell@nvidia.com>,
 <Felix.Kuehling@amd.com>
References: <20191028201032.6352-1-jgg@ziepe.ca>
 <20191028201032.6352-3-jgg@ziepe.ca>
X-Nvconfidentiality: public
From: John Hubbard <jhubbard@nvidia.com>
Message-ID: <35c2b322-004e-0e18-87e4-1920dc71bfd5@nvidia.com>
Date: Wed, 6 Nov 2019 16:23:21 -0800
User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:60.0) Gecko/20100101
 Thunderbird/60.8.0
MIME-Version: 1.0
In-Reply-To: <20191028201032.6352-3-jgg@ziepe.ca>
X-Originating-IP: [10.124.1.5]
X-ClientProxiedBy: HQMAIL105.nvidia.com (172.20.187.12) To
 HQMAIL107.nvidia.com (172.20.187.13)
Content-Language: en-US
DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=nvidia.com; s=n1;
 t=1573086147; bh=wcGT9xMQYHuXfFscUQsjE5NTf0ZA6XJfn+TCAYtZiBE=;
 h=X-PGP-Universal:Subject:To:CC:References:X-Nvconfidentiality:From:
 Message-ID:Date:User-Agent:MIME-Version:In-Reply-To:
 X-Originating-IP:X-ClientProxiedBy:Content-Type:Content-Language:
 Content-Transfer-Encoding;
 b=KiQQ4LDyxKXYIitiaRH6a8gsJ4dGhAyOwYM7DFJdAyGJJBY3oq01CkMaJ9YchQ48q
 S8p0H+M/dgsvISqRDU5deHEqFujQiLM0nmjKtDoHgycaWrEdOq/u72/QWCG3GbqPzt
 DwaP7KV1LZDeFUTiiuyaLyiDSDtdJrpAIjhBmR3DZbzX2ylQyNbRl4t1hyWAb9gKNW
 6MSsYSuHvzmEbihgwRd3FUAb81gqORq9QD9eTo+r61EpuB2TYaHUJWpVNalIVlzBaV
 XPVEiITQ6xu6lP175Mfr/LRZjaj3XWM5EbZ8Z3JfPKLHjUlDKu0PNeaVfd/ppHUsju
 uXdrdN8657ruQ==
Subject: Re: [Xen-devel] [PATCH v2 02/15] mm/mmu_notifier: add an interval
 tree notifier
X-BeenThere: xen-devel@lists.xenproject.org
X-Mailman-Version: 2.1.23
Precedence: list
List-Id: Xen developer discussion <xen-devel.lists.xenproject.org>
List-Unsubscribe: <https://lists.xenproject.org/mailman/options/xen-devel>,
 <mailto:xen-devel-request@lists.xenproject.org?subject=unsubscribe>
List-Post: <mailto:xen-devel@lists.xenproject.org>
List-Help: <mailto:xen-devel-request@lists.xenproject.org?subject=help>
List-Subscribe: <https://lists.xenproject.org/mailman/listinfo/xen-devel>,
 <mailto:xen-devel-request@lists.xenproject.org?subject=subscribe>
Cc: Juergen Gross <jgross@suse.com>, David Zhou <David1.Zhou@amd.com>,
 Mike Marciniszyn <mike.marciniszyn@intel.com>,
 Stefano Stabellini <sstabellini@kernel.org>,
 Andrea Arcangeli <aarcange@redhat.com>,
 Oleksandr Andrushchenko <oleksandr_andrushchenko@epam.com>,
 linux-rdma@vger.kernel.org, nouveau@lists.freedesktop.org, Dennis
 Dalessandro <dennis.dalessandro@intel.com>, amd-gfx@lists.freedesktop.org,
 Michal Hocko <mhocko@kernel.org>, Christoph Hellwig <hch@infradead.org>,
 Jason Gunthorpe <jgg@mellanox.com>, dri-devel@lists.freedesktop.org,
 Alex Deucher <alexander.deucher@amd.com>, xen-devel@lists.xenproject.org,
 Boris Ostrovsky <boris.ostrovsky@oracle.com>, Petr Cvek <petrcvekcz@gmail.com>,
 =?UTF-8?Q?Christian_K=c3=b6nig?= <christian.koenig@amd.com>,
 Ben Skeggs <bskeggs@redhat.com>
Content-Type: text/plain; charset="utf-8"
Content-Transfer-Encoding: base64
Errors-To: xen-devel-bounces@lists.xenproject.org
Sender: "Xen-devel" <xen-devel-bounces@lists.xenproject.org>
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From mboxrd@z Thu Jan  1 00:00:00 1970
Return-Path: <SRS0=ouc1=Y7=lists.freedesktop.org=amd-gfx-bounces@kernel.org>
X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on
	aws-us-west-2-korg-lkml-1.web.codeaurora.org
X-Spam-Level: 
X-Spam-Status: No, score=-5.2 required=3.0 tests=HEADER_FROM_DIFFERENT_DOMAINS,
	INCLUDES_PATCH,MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS,USER_AGENT_SANE_1
	autolearn=unavailable autolearn_force=no version=3.4.0
Received: from mail.kernel.org (mail.kernel.org [198.145.29.99])
	by smtp.lore.kernel.org (Postfix) with ESMTP id 6714AFA372C
	for <amd-gfx@archiver.kernel.org>; Thu,  7 Nov 2019 01:44:17 +0000 (UTC)
Received: from gabe.freedesktop.org (gabe.freedesktop.org [131.252.210.177])
	(using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits))
	(No client certificate requested)
	by mail.kernel.org (Postfix) with ESMTPS id 3BA3B21D6C
	for <amd-gfx@archiver.kernel.org>; Thu,  7 Nov 2019 01:44:17 +0000 (UTC)
DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 3BA3B21D6C
Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=nvidia.com
Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=amd-gfx-bounces@lists.freedesktop.org
Received: from gabe.freedesktop.org (localhost [127.0.0.1])
	by gabe.freedesktop.org (Postfix) with ESMTP id EA09B6E34B;
	Thu,  7 Nov 2019 01:44:16 +0000 (UTC)
Received: from hqemgate16.nvidia.com (hqemgate16.nvidia.com [216.228.121.65])
 by gabe.freedesktop.org (Postfix) with ESMTPS id 9217B6EE4D;
 Thu,  7 Nov 2019 00:23:24 +0000 (UTC)
Received: from hqpgpgate102.nvidia.com (Not Verified[216.228.121.13]) by
 hqemgate16.nvidia.com (using TLS: TLSv1.2, DES-CBC3-SHA)
 id <B5dc363c20005>; Wed, 06 Nov 2019 16:22:27 -0800
Received: from hqmail.nvidia.com ([172.20.161.6])
 by hqpgpgate102.nvidia.com (PGP Universal service);
 Wed, 06 Nov 2019 16:23:23 -0800
X-PGP-Universal: processed;
 by hqpgpgate102.nvidia.com on Wed, 06 Nov 2019 16:23:23 -0800
Received: from [10.110.48.28] (10.124.1.5) by HQMAIL107.nvidia.com
 (172.20.187.13) with Microsoft SMTP Server (TLS) id 15.0.1473.3; Thu, 7 Nov
 2019 00:23:21 +0000
Subject: Re: [PATCH v2 02/15] mm/mmu_notifier: add an interval tree notifier
To: Jason Gunthorpe <jgg@ziepe.ca>, <linux-mm@kvack.org>, Jerome Glisse
 <jglisse@redhat.com>, Ralph Campbell <rcampbell@nvidia.com>,
 <Felix.Kuehling@amd.com>
References: <20191028201032.6352-1-jgg@ziepe.ca>
 <20191028201032.6352-3-jgg@ziepe.ca>
X-Nvconfidentiality: public
From: John Hubbard <jhubbard@nvidia.com>
Message-ID: <35c2b322-004e-0e18-87e4-1920dc71bfd5@nvidia.com>
Date: Wed, 6 Nov 2019 16:23:21 -0800
User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:60.0) Gecko/20100101
 Thunderbird/60.8.0
MIME-Version: 1.0
In-Reply-To: <20191028201032.6352-3-jgg@ziepe.ca>
X-Originating-IP: [10.124.1.5]
X-ClientProxiedBy: HQMAIL105.nvidia.com (172.20.187.12) To
 HQMAIL107.nvidia.com (172.20.187.13)
Content-Language: en-US
X-Mailman-Approved-At: Thu, 07 Nov 2019 01:44:16 +0000
X-Mailman-Original-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed;
 d=nvidia.com; s=n1; 
 t=1573086147; bh=wcGT9xMQYHuXfFscUQsjE5NTf0ZA6XJfn+TCAYtZiBE=;
 h=X-PGP-Universal:Subject:To:CC:References:X-Nvconfidentiality:From:
 Message-ID:Date:User-Agent:MIME-Version:In-Reply-To:
 X-Originating-IP:X-ClientProxiedBy:Content-Type:Content-Language:
 Content-Transfer-Encoding;
 b=KiQQ4LDyxKXYIitiaRH6a8gsJ4dGhAyOwYM7DFJdAyGJJBY3oq01CkMaJ9YchQ48q
 S8p0H+M/dgsvISqRDU5deHEqFujQiLM0nmjKtDoHgycaWrEdOq/u72/QWCG3GbqPzt
 DwaP7KV1LZDeFUTiiuyaLyiDSDtdJrpAIjhBmR3DZbzX2ylQyNbRl4t1hyWAb9gKNW
 6MSsYSuHvzmEbihgwRd3FUAb81gqORq9QD9eTo+r61EpuB2TYaHUJWpVNalIVlzBaV
 XPVEiITQ6xu6lP175Mfr/LRZjaj3XWM5EbZ8Z3JfPKLHjUlDKu0PNeaVfd/ppHUsju
 uXdrdN8657ruQ==
X-BeenThere: amd-gfx@lists.freedesktop.org
X-Mailman-Version: 2.1.23
Precedence: list
List-Id: Discussion list for AMD gfx <amd-gfx.lists.freedesktop.org>
List-Unsubscribe: <https://lists.freedesktop.org/mailman/options/amd-gfx>,
 <mailto:amd-gfx-request@lists.freedesktop.org?subject=unsubscribe>
List-Archive: <https://lists.freedesktop.org/archives/amd-gfx>
List-Post: <mailto:amd-gfx@lists.freedesktop.org>
List-Help: <mailto:amd-gfx-request@lists.freedesktop.org?subject=help>
List-Subscribe: <https://lists.freedesktop.org/mailman/listinfo/amd-gfx>,
 <mailto:amd-gfx-request@lists.freedesktop.org?subject=subscribe>
Cc: Juergen Gross <jgross@suse.com>, David Zhou <David1.Zhou@amd.com>,
 Mike Marciniszyn <mike.marciniszyn@intel.com>,
 Stefano Stabellini <sstabellini@kernel.org>,
 Andrea Arcangeli <aarcange@redhat.com>,
 Oleksandr Andrushchenko <oleksandr_andrushchenko@epam.com>,
 linux-rdma@vger.kernel.org, nouveau@lists.freedesktop.org, Dennis
 Dalessandro <dennis.dalessandro@intel.com>, amd-gfx@lists.freedesktop.org,
 Michal Hocko <mhocko@kernel.org>, Christoph Hellwig <hch@infradead.org>,
 Jason Gunthorpe <jgg@mellanox.com>, dri-devel@lists.freedesktop.org,
 Alex Deucher <alexander.deucher@amd.com>, xen-devel@lists.xenproject.org,
 Boris Ostrovsky <boris.ostrovsky@oracle.com>, Petr Cvek <petrcvekcz@gmail.com>,
 =?UTF-8?Q?Christian_K=c3=b6nig?= <christian.koenig@amd.com>,
 Ben Skeggs <bskeggs@redhat.com>
Content-Type: text/plain; charset="utf-8"
Content-Transfer-Encoding: base64
Errors-To: amd-gfx-bounces@lists.freedesktop.org
Sender: "amd-gfx" <amd-gfx-bounces@lists.freedesktop.org>
Message-ID: <20191107002321.sJ6aT6Db678tVAORY_xOqJF1IiHw4K6UKwY-tfHPG2o@z>
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