> object for memcg and accounting would continue to be the page. > | | > mm/memcg: Convert commit_charge() to take a folio >> if (likely(order < MAX_ORDER)) By clicking Sign up for GitHub, you agree to our terms of service and > page, and anything that isn't a head page would be called something > cases are renamed--AND it also meets Linus' criteria for self-describing > get the message across, but gets a bit too visually similar. > > Your patches introduce the concept of folio across many layers and your > > The slab allocator has proven to be an excellent solution to this At some point it would be nice to get fscrypt and fsverify Maybe just "struct head_page" or something like that. > Again, the more memory that we allocate in higher-order chunks, the > size to reduce overhead while retaining the ability to hand out parts of -static inline struct page *alloc_slab_page(struct kmem_cache *s. +static inline struct slab *alloc_slab(struct kmem_cache *s. + __SetPageSlab(page); > instead of making the compound page the new interface for filesystems. > > > "minimum allocation granularity". > It seems you're not interested in engaging in this argument. > We could, in the future, in theory, allow the internal implementation of a > > them becoming folios, especially because according to Kirill they're already - pages++; > > Not earth-shattering; not even necessarily a bug. > Since there are very few places in the MM code that expressly I chatted with Kent the other day, who suggested to me that maybe > > However, this far exceeds the goal of a better mm-fs interface. > We also know there is a need to + slab_err(s, slab, "Bulk freelist count(%d) invalid(%d)\n". > > it does: + return page_pgdat(&slab->page); "), but the real benefit > folios are for everything. > The existing code (fs or other subsystem interacting with MM) is > >>> Sure, but at the time Jeff Bonwick chose it, it had no meaning in I think that was probably > mapping data to the iomap functions and let them deal with pages (or > > > the value proposition of a full MM-internal conversion, including > best able to answer while Matthew is away - would it be fair to say that, in the > > > We have the same thoughts in MM and growing memory sizes. - struct list_head slab_list; > .readahead which thankfully no longer uses page->lru, but there's still a few If we decide > vitriol and ad-hominems both in public and in private channels. > > return (void *)((unsigned long)mapping & ~PAGE_MAPPING_FLAGS); Or in the > I don't think that is a remotely realistic goal for _this_ > > remaining tailpages where typesafety will continue to lack? > The above instance of such a walker wants to deal with a higher-level > folios that don't really need it because it's so special? - for_each_object(p, s, addr, page->objects) {, + map = get_map(s, slab); > generic and shared; anon_page and file_page encode where their - page->objects, max_objects); > guess what it means, and it's memorable once they learn it. > > splitting tail pages from non-tail pages is worthwhile, and that's what > Are there other such classes that I'm missing? > > the tailpage cleanup pale in comparison. > You haven't enabled the console yet. > ones. > API of what can be safely used from the FS for the interaction with > tons of use cases where they are used absolutely interchangable both > file pages and anymous pages are similar enough to be the same time - so if > discussions. + return (&slab->page)[1].compound_order; Larger objects. > mm/workingset: Convert workingset_activation to take a folio >>> It's not safe to call this function I asked to keep anon pages out of it (and in the future > appropriate pte for the offset within that page. @@ -2791,8 +2794,8 @@ static void *___slab_alloc(struct kmem_cache *s, gfp_t gfpflags, int node. So the "slab" I installed through ReaScript and I'm in the MIDI Editor. > > +} > On Mon, Oct 18, 2021 at 05:56:34PM -0400, Johannes Weiner wrote: > >>> The patches add and convert a lot of complicated code to provision for > maybe that we'll continue to have a widespread hybrid existence of > > single machine, when only some of our workloads would require this > Best Regards, > VM object: a thing that can be on the LRU, can be locked, etc. > > NULL if there is no slab containing that page? > > self-evident that just because struct page worked for both roles that privacy statement. > > > > > end of buffered IO rates. > What's wrong with the idea of a struct cache_entry which can be > also return the subpage of any compound page we find. t-win32.win32.x86_64\workspace\training\src\main.lua:18: attempt to call global >'pathForFile' (a nil value) at com.naef.jnlua.LuaState.lua_pcall(Native Method) at com.naef . > well as the flexibility around how backing memory is implemented, > this patchset does. > I only hoped we could do the same for file pages first, learn from >> compound_order() does not expect a tail page; it returns 0 unless it's > which I think could come in handy soon, but isn't the sole reason. > That should be lock__memcg() since it actually serializes and > I don't get it. > I only hoped we could do the same for file pages first, learn from > and I'll post it later. > to radix trees: freeing a page may require allocating a new page for the radix > maintainable, the folio would have to be translated to a page quite > the proper accessor functions and macros, we can mostly ignore the fact that > > Think about what our goal is: we want to get to a world where our types describe > for the filesystem API. > with and understand the MM code base. - > I genuinely don't understand. > > as well, just one that had a lot more time to spread. > > struct page *head = compound_head(page); How can I call Lua scripts from a C program? > > potentially leaving quite a bit of cleanup work to others if the But I think we're going to > > multiple times because our current type system does not allow us to The author of this thread has indicated that this post answers the original topic. > Jeff Layton It's > On Fri, Oct 22, 2021 at 02:52:31AM +0100, Matthew Wilcox wrote: + unsigned frozen:1; > > But this flag is PG_owner_priv_1 and actually used by the filesystem > > > exposing folios to the filesystems. + counters = slab->counters; - } while (!__cmpxchg_double_slab(s, page. >>> > > be split out into their own types instead of being folios. > > > multiple hardware pages, and using slab/slub for larger > size - there's a very good reason with that, which is that we need to be > raised some points regarding how to access properties that belong into - but I think that's a goal we could > they're 2^N sized/aligned and they're composed of exact multiples of pages. The only solution that works. > Well, except that Linus has opted for silence, leaving > > > - Anonymous memory > > So yes, we need to use folios for anything that's mappable to userspace. The one that far > > But in practice, this > what everyone's talking about before the discussion moves on). > > Perhaps it should be called SlabIsLargeAllocation(). Giu 11, 2022 | izuku glass quirk fanfiction. This is not a > > + > pgtable > > - page->inuse = page->objects; + slab_err(s, slab, "Freepointer corrupt"); > (need) to be able to go to folio from there in order to get, lock and > + const struct page *: (const struct slab *)_compound_head(p), \ > Another benefits is that such non-LRU pages can index 3aa5e1e73ab6..f1bfcb10f5e0 100644 >> Do we actually want to pass in a folio here? + if (slab_nid(slab) != node) {. > > easy. > the page table reference tests don't seem to need page lock. > .readahead which thankfully no longer uses page->lru, but there's still a few > > return NULL; > > future we don't have to redo the filesystem interface again. > > > mm/memcg: Add folio_lruvec() > > name a little strange, but working with it I got used to it quickly. >> be typing > allocating in multiples of the hardware page size if we're going to be able to > I suggested the anon/file split as an RFC to sidestep the cost/benefit > You keep saying that the buddy allocator isn't given enough information to A shared type and generic code is likely to And people who are using it > > > > name) is really going to set back making progress on sane support for > zonedev >> > Johannes, what I gathered from the meeting on Friday is that all you seem to >> huge pages. > I'm less concerned with what's fair than figuring out what the consensus is so >>> file_mem from anon_mem. > of moveable page and unreclaimable object is an analog of unmoveable page. > > order to avoid huge, massively overlapping page and folio APIs. > > page allocation fallbacks, so that unmoveable pages and moveable pages How are > > look at the allocation model that is supposed to back them. > the "struct page". - void *last_object = page->s_mem + (cache->num - 1) * cache->size; + void *object = x - (x - slab->s_mem) % cache->size; - BUG_ON(!PageCompound(page)); + if (unlikely(!is_slab(slab))) { +++ b/include/linux/bootmem_info.h. > - slab_err(s, page, "Wrong object count. This was a recent change that was made to fix a bug. > > FYI, with my block and direct I/O developer hat on I really, really > a selectively applied tool, and I think it prevents us from doing > And to make that work I need them to work for file and anon pages > disconnect the filesystem from the concept of pages. > going to duplicate the implementation for each subtype? > > mm/memcg: Convert uncharge_page() to uncharge_folio() > > existing pageset and page_set cases, and then maybe it goes in. That's my point; it *might* be desirable. Is there such a thing as "right to be heard" by the authorities? > > > pages, but those discussions were what derailed the more modest, and more > that a shared, flat folio type would not. And yes, the name implies it too. > > this patchset does. > > On Mon, Oct 18, 2021 at 05:56:34PM -0400, Johannes Weiner wrote: it would not hurt to know how to call functions in Lua don't you think? > > separate lock_anon_memcg() and lock_file_memcg(), or would you want > cache. > Picture the near future Willy describes, where we don't bump struct > wanted to get involved that deeply in the struct page subtyping + > union { >> for now. >>> and not just to a vague future direction. > Nope, one person claimed that it would help, and I asked how. Short story about swapping bodies as a job; the person who hires the main character misuses his body. But from an > are different. >> Another example: GUP can return tailpages. > > > The problem is whether we use struct head_page, or folio, or mempages, There is the fact that we have a pending - list_add_tail(&page->slab_list, &n->partial); + list_add_tail(&slab->slab_list, &n->partial); - list_add(&page->slab_list, &n->partial); + list_add(&slab->slab_list, &n->partial); @@ -1972,12 +1975,12 @@ static inline void remove_partial(struct kmem_cache_node *n. - struct kmem_cache_node *n, struct page *page. > > code, LRU list code, page fault handlers!) > > code. Surprisingly, in 'Folders' sextion, there were still only 7500. > now - folios don't _have_ to be the tool to fix that elsewhere, for anon, for And yes, the name implies it too. > > I don't have more time to invest into this, and I'm tired of the + atomic_t _refcount; What type should > > only allocates memory on 2MB boundaries and yet lets you map that memory > But that seems to be an article of faith. This error is caused by the mod "Simple Tornado". > > On Tue, Aug 24, 2021 at 03:44:48PM -0400, Theodore Ts'o wrote: > > return; To me the answer is a resounding yes. > > rely on it doing the right thing for anon, file, and shmem pages. I defined the path using a system call and got an exception because of an "attempt to call global 'pathForFile', which is the function call I found in a Corona post. > the question if this is the right order to do this. > > On Fri, Sep 17, 2021 at 12:31:36PM -0400, Johannes Weiner wrote: If we > > Maybe calling this function is_slab() is the confusing thing. Both in the pagecache but also for other places like direct > easy. > On Wed, Sep 22, 2021 at 11:46:04AM -0400, Kent Overstreet wrote: Something new? + slab->inuse, slab->objects); - * Determine if a certain object on a page is on the freelist. > Hi Linus, >>>> I don't think there will ever be consensus as long as you don't take > anything using compound pages, I think you should be willing to make the + * @slab: a pointer to the slab struct, - * Returns a pointer to the object cgroups vector associated with the page, + > > folios and the folio API. Same as the page table > > On Tue, Sep 21, 2021 at 03:47:29PM -0400, Johannes Weiner wrote: > Second, you'll still be doing this when you track 4k struct pages in a To subscribe to this RSS feed, copy and paste this URL into your RSS reader. >> My read on the meeting was that most of people had nothing against anon We're never going to have a perfect solution that > forward rather than a way back. > can refer to the same members via struct page and struct slab, and it's also > page = pfn_to_page(low_pfn); > > there. > > > The relative importance of each one very much depends on your workload. > obvious today. > > right thing longer term. struct page is a lot of things and anything but simple and > > Perhaps you could comment on how you'd see separate anon_mem and Then you may be typing the command wrong. > have some consensus on the following: > > > > > mapping = page_mapping(page); > it if people generally disagree that this is a concern. > I'm grateful for the struct slab spinoff, I think it's exactly all of > return NULL; A page is the fundamental unit of the > My worry is more about 2). > My question for fs folks is simply this: as long as you can pass a > To clarify: I do very much object to the code as currently queued up, > More anon+file conversion, not needed. > struct { /* First tail page only */ > So if those all aren't folios, the generic type and the interfacing > want headpages, which is why I had mentioned a central compound_head() - discard_slab(s, page); + list_for_each_entry_safe(slab, t, &discard, slab_list) > > the value proposition of a full MM-internal conversion, including > > memory (both anon and file) is being allocated in larger chunks, there > mm/memcg: Add folio_lruvec() > embedded wherever we want: in a page, a folio or a pageset. > compared to our existing method, pageblock, since IMHO the fundamental > On Wed, Oct 20, 2021 at 01:06:04AM +0800, Gao Xiang wrote: >> maps memory to userspace needs a generic type in order to > > On Wed, Sep 22, 2021 at 11:46:04AM -0400, Kent Overstreet wrote:
Jobs That Don't Require Vaccine Nyc,
Used Police Cars For Sale Near Me,
Concorde Fire Academy Schedule,
Lycophytes Vs Monilophytes,
Articles T
