Received-SPF: pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::1:20 as permitted sender) client-ip=2620:137:e000::1:20;
Date:   Tue, 20 Dec 2022 20:14:15 +0800
From:   Baoquan He <bhe@redhat.com>
To:     Lorenzo Stoakes <lstoakes@gmail.com>
Cc:     linux-kernel@vger.kernel.org, linux-mm@kvack.org, urezki@gmail.com,
        stephen.s.brennan@oracle.com, willy@infradead.org,
        akpm@linux-foundation.org, hch@infradead.org
Subject: Re: [PATCH v2 2/7] mm/vmalloc.c: add flags to mark vm_map_ram area
Message-ID: <Y6GnF51yd+d1qINF@MiWiFi-R3L-srv>
References: <20221217015435.73889-1-bhe@redhat.com>
 <20221217015435.73889-3-bhe@redhat.com>
 <Y52rllbXHMwbpJ8K@lucifer>
 <Y6AaPKT7mdVxdHRl@MiWiFi-R3L-srv>
 <Y6AqRauq6wEYK0n5@lucifer>
 <Y6BYD24wzAogqRyT@MiWiFi-R3L-srv>
 <Y6Bgt7k1H7Ez4EEb@lucifer>
MIME-Version: 1.0
Content-Type: text/plain; charset=us-ascii
Content-Disposition: inline
In-Reply-To: <Y6Bgt7k1H7Ez4EEb@lucifer>
Precedence: bulk

On 12/19/22 at 01:01pm, Lorenzo Stoakes wrote:
> On Mon, Dec 19, 2022 at 08:24:47PM +0800, Baoquan He wrote:
> > In fact, I should not do the checking, but do the clearing anyway. If I
> > change it as below, does it look better to you?
> >
> >
> > diff --git a/mm/vmalloc.c b/mm/vmalloc.c
> > index 5e578563784a..369b848d097a 100644
> > --- a/mm/vmalloc.c
> > +++ b/mm/vmalloc.c
> > @@ -2253,8 +2253,7 @@ void vm_unmap_ram(const void *mem, unsigned int count)
> >  	spin_lock(&vmap_area_lock);
> >  	va = __find_vmap_area((unsigned long)addr, &vmap_area_root);
> >  	BUG_ON(!va);
> > -	if (va)
> > -		va->flags &= ~VMAP_RAM;
> > +	va->flags &= ~VMAP_RAM;
> >  	spin_unlock(&vmap_area_lock);
> >  	debug_check_no_locks_freed((void *)va->va_start,
> >  				    (va->va_end - va->va_start));
> 
> This is better as it avoids the slightly contradictory situation of checking for
> a condition we've asserted is not the case, but I would still far prefer keeping
> this as-is and placing the unlock before the BUG_ON().
> 
> This avoids explicitly and knowingly holding a lock over a BUG_ON() and is
> simple to implement, e.g.:-
> 
>   	spin_lock(&vmap_area_lock);
>   	va = __find_vmap_area((unsigned long)addr, &vmap_area_root);
>  	if (va)
>  		va->flags &= ~VMAP_RAM;
>   	spin_unlock(&vmap_area_lock);
>   	BUG_ON(!va);

OK, I will change like this.

> 
> > > You are at this point clearing the VMAP_RAM flag though, so if it is unimportant
> > > what the flags are after this call, why are you clearing this one?
> >
> > With my understanding, We had better do the clearing. Currently, from
> > the code, not doing the clearing won't cause issue. If possible, I would
> > like to clear it as below draft code.
> >
> 
> Sure, it seems appropriate to clear it, I'm just unsure as to why you aren't
> just clearing both flags? Perhaps just set va->flags = 0?

Hmm, for the two kinds of vm_map_ram areas, their code paths are
different. for unmapping vmap_block vm_map_ram, it goes through
vb_free(). I can only do the clearing in free_vmap_block().

  -->vm_unmap_ram()
     -->vb_free()
        -->free_vmap_block()

For non vmap_block vm_map_ram area, I can do the clearing in
vm_unmap_ram().
  -->vm_unmap_ram()
     -->__find_vmap_area()
     -->free_unmap_vmap_area()

As said earlier, clearing va->flags when unmap vm_map_ram area, or
clearing va->vm in remove_vm_area(), these have better be done.
However, not clearing them won't cause issue currently. Because the
old vmap_area is inserted into free_vmap_area_root, when we allocate a
new vmap_area through alloc_vmap_area(), we will get q new vmap_area
from vmap_area_cachep, the old va->flags or va->vm won't be carried into
the new vmap_area. Clearing them is a good to have, just in case.

Rethinking about this, I may need to do the clearing when freeing
vmap_block. Otherwise, people will be confused why the clearing is not
done.

@@ -1815,6 +1815,7 @@ static void free_vmap_area_noflush(struct vmap_area *va)

        spin_lock(&vmap_area_lock);
        unlink_va(va, &vmap_area_root);
+       va->flags = 0;
        spin_unlock(&vmap_area_lock);

        nr_lazy = atomic_long_add_return((va->va_end - va->va_start) >>

> 
> > >
> > > It is just a little confusing, I wonder whether the VMAP_BLOCK flag is necessary
> > > at all, is it possible to just treat a non-VMAP_BLOCK VMAP_RAM area as if it
> > > were simply a fully occupied block? Do we gain much by the distinction?
> >
> > Yeah, VMAP_BLOCK flag is necessary. vmap_block contains used region,
> > or dirty/free regions. While the non-vmap_blcok vm_map_ram area is
> > similar with the non vm_map_ram area. When reading out vm_map_ram
> > regions, vmap_block regions need be treated differently.
> 
> OK looking through again closely I see you're absolutely right, I wondered
> whether you could somehow make a non-VMAP_BLOCK vread() operation be equivalent
> to a block one (only across the whole mapping), but I don't think you can.

Right, it's much easier to do the same handling on non-VMAP_BLOCK vm_map_ram
as the normal vmap area.