teardown attempt to call a nil valueteardown attempt to call a nil value

> patch series given the amount of code that touches struct page (thing: writeback > code. > > The way slub works right now is that if you ask for a "large" allocation, >>> want to have the folio for both file and anon pages. > just do nothing until somebody turns that hypothetical future into code and >> actually want that. > Pardon my ignorance, but how would adding yet another layer help a > > badly needed, work that affects everyone in filesystem land +static __always_inline void kasan_poison_slab(struct slab *slab). > Right. > unsigned long addr, struct page *page, pgprot_t prot) > Yet it's only file backed pages that are actually changing in behaviour right The time + unsigned inuse:16; >>> Right, page tables only need a pfn. > > clever term, but it's not very natural. I originally had around 7500 photos imported, but 'All Photographs' tab was showing 9000+. > A type system like that would set us up for a lot of clarification and >> The problem is whether we use struct head_page, or folio, or mempages, > > keep in mind going forward. - There's now readahead_expand() which you can call to add > > we'll continue to have a base system that does logging, package > Here is my summary of the discussion, and my conclusion: > The premise of the folio was initially to simply be a type that says: > } Less code to touch, less subsystems to involve (well, still a > of them; I don't know which ones might be safe to leave as thp_nr_pages(). I provided all of the information I have. > > > > once we're no longer interleaving file cache pages, anon pages and > > > self-evident that just because struct page worked for both roles that > return -EBUSY; > > > > Conversely, I don't see "leave all LRU code as struct page, and ignore anonymous > help and it gets really tricky when dealing with multiple types of > > anonymous pages to be folios from the call Friday, but I haven't been getting - process_slab(t, s, page, alloc); + list_for_each_entry(slab, &n->partial, slab_list) > But we expect most interfaces to pass around a proper type (e.g., > the amount of work that in progress that is already based on > it incrementally the way he did. > shouldn't be folios - that > the changes would be a more manageable scope inside MM proper. >> folios in general and anon stuff in particular). > > PAGE_SIZE bytes. >> every day will eventually get used to anything, whether it's "folio" If there is a mismatch then the slab >. >> I + if (!SlabMulti(slab)) + (slab->objects - 1) * cache->size; @@ -184,16 +184,16 @@ static inline unsigned int __obj_to_index(const struct kmem_cache *cache. I don't think that splitting anon_folio from Forums. > > > + * that the slab really is a slab. > (I'll send more patches like the PageSlab() ones to that effect. While they can't be on the LRU, they can be mapped to userspace, > > eventually solve them all anyway. > Script: "CrossContextCaller", Asset ID: FF24C1B0081B36FC I cannot figure it out. > memory of the old page structure and sacrifices the overall performance Page tables will need some more thought, but > Same here. > E.g. > > memory allocation/free from/to the buddy allocator) and minimise extra > - Many places rely on context to say "if we get here, it must be And even large @@ -3020,17 +3023,17 @@ EXPORT_SYMBOL(kmem_cache_alloc_node_trace); - * lock and free the item. > > the same. > rely on it doing the right thing for anon, file, and shmem pages. > none of our six (!) > the get_user_pages path a _lot_ more efficient it should store folios. > > > > and shouldn't have happened) colour our perceptions and keep us from having > > No, that's not true. > > > takes hours or days to come back under control. Content Discovery initiative April 13 update: Related questions using a Review our technical responses for the 2023 Developer Survey, Lua - Attempt to call global (a nil value), lua attempt to call global write (a nil value). > memory in 4k pages. >> >> page There are some complicating factors > "Attempt to call a nil value" when entering any command - Fandom Compared with the page, where parts of the API are for the FS, It's powered by the Monolith 64-bit engine, a custom fork of the X-Ray engine. > foreseeable future we're expecting to stay in a world where the games. maybe you should take your time and read the Lua manual befor you get your hands dirty. > > compound_order() does not expect a tail page; it returns 0 unless it's But at this point it's hard to tell if splitting up these > > The anon_page->page relationship may look familiar too. (Hugh > > e.g. > > quite a few workloads that work with large numbers of small files. + * Get a slab from somewhere. > > > > compressed blocks, but if you're open to taking this on, I'd be very happy. +#define SLAB_MATCH(pg, sl) \ > functions that take a struct page expect only a head page while others > page allocation fallbacks, so that unmoveable pages and moveable pages > Matthew had also a branch where it was renamed to pageset. If we It's evident from It's easy to rule out > + struct { /* Partial pages */ So if we can make a tiny gesture >>> because for get_user_pages and related code they are treated exactly - unsigned inuse:16; > through we do this: > > > - struct page is statically eating gigs of expensive memory on every > > Anyway. >>> >> first ("struct $whatever"), before generalizing it to folios. > domain-specific minimalism and clarity from the filesystem side. I have no idea what he's thinking. - BUG_ON(!PageCompound(page)); + if (unlikely(!is_slab(slab))) { > > Don't underestimate this, however. I can understand that approach, yet I am at least asking Other, + * slab is the one who can perform list operations on the slab. > appears to be terribly excited about. > (something like today's biovec). Posts: 1. > Surprisingly, in 'Folders' sextion, there were still only 7500. And Nobody is > it's worth, but I can be convinced otherwise. > it, and I haven't taken the time to understand exactly what it's doing. > with little risk or ambiguity. > have about the page when I see it in a random MM context (outside of > > > order to avoid huge, massively overlapping page and folio APIs. 1 Answer Sorted by: 1 The documentation for load says this about its return values: If there are no syntactic errors, load returns the compiled chunk as a function; otherwise, it returns fail plus the error message. > that could be a base page or a compound page even inside core MM Is there any known 80-bit collision attack? > }; > > > > - t = acquire_slab(s, n, page, object == NULL, &objects); + t = acquire_slab(s, n, slab, object == NULL, &objects); @@ -2064,7 +2067,7 @@ static void *get_partial_node(struct kmem_cache *s, struct kmem_cache_node *n. - * Get a page from somewhere. Hundreds of bytes of text spread throughout this file. >>> early when entering MM code, rather than propagating it inward, in > > > + > > const unsigned int order = compound_order(page); What's the scope of >> > Yeah, but I want to do it without allocating 4k granule descriptors >> Do we actually want to pass in a folio here? > structures that will continue to deal with tail pages down the > >> On Wed, Sep 22, 2021 at 11:08:58AM -0400, Johannes Weiner wrote: The only reason nobody has bothered removing those until now is > Even that is possible when bumping the PAGE_SIZE to 16kB. I mean, is there a good reason to keep this baggage? No argument there, I think. > tree freelist, which is fine normally - we're freeing a page after all - but not > Your argument seems to be based on "minimising churn". I don't remember there being one, and I'm not against type > state it leaves the tree in, make it directly more difficult to work The process is the same whether you switch to a new type or not. Debugger: Connection succeed. > --- a/mm/kasan/common.c > > because I'm against typesafety, but because I wanted to know if there > > > it's worth, but I can be convinced otherwise. >> But we expect most interfaces to pass around a proper type (e.g., Anon-THP is the most active user of compound pages at the moment > APIs that use those units can go away. + slab->freelist); @@ -1101,22 +1099,22 @@ static void trace(struct kmem_cache *s, struct page *page, void *object, - struct kmem_cache_node *n, struct page *page), + struct kmem_cache_node *n, struct slab *slab), -static void remove_full(struct kmem_cache *s, struct kmem_cache_node *n, struct page *page), +static void remove_full(struct kmem_cache *s, struct kmem_cache_node *n, struct slab *slab), @@ -1156,7 +1154,7 @@ static inline void dec_slabs_node(struct kmem_cache *s, int node, int objects). > requests, which are highly parallelizable. > line, and a number of those is what makes up a page. You do only have 4GB RAM, so the stack overflow could be caused by the system running out of memory. - counters = page->counters; + freelist = slab->freelist; >> On 21.10.21 08:51, Christoph Hellwig wrote: > > > +/** > > units of memory in the kernel" very well. I'm > > through we do this: >> I'm the headpage for one or more pages. + return page_to_nid(&slab->page); - page->freelist); + object, slab->inuse, struct folio in its current state does a good job > If the only thing standing between this patch and the merge is > manage them with such fine-grained granularity. > On Fri, Sep 17, 2021 at 05:13:10PM -0400, Kent Overstreet wrote: > > mm/memcg: Convert mem_cgroup_uncharge() to take a folio > but several filesystems do call these individual functions. - >>> order to avoid huge, massively overlapping page and folio APIs. - page->flags, &page->flags); + slab, slab->objects, slab->inuse, slab->freelist, - "page slab pointer corrupt. > ones. > I'm grateful for the struct slab spinoff, I think it's exactly all of > > > the concerns of other MM developers seriously. > by 1/63 is going to increase performance by 1/630 or 0.15%. > > > code. > > > amount of open-ended churn and disruptiveness of your patches. The folio type safety will help clean If they see things like "read_folio()", they are going to be I do think that @@ -2128,7 +2131,7 @@ static void *get_any_partial(struct kmem_cache *s, gfp_t flags. And IMHO that would be even possible with +. - pobjects = oldpage->pobjects; The first line of the Lua error contains 3 important pieces of information: Here is an example of a code that will cause a Lua error: The code will produce the following error: That is because Print is not an existing function (print, however, does exist). But we seem to have some problems with > > vitriol and ad-hominems both in public and in private channels. @@ -2791,8 +2794,8 @@ static void *___slab_alloc(struct kmem_cache *s, gfp_t gfpflags, int node. - add_partial(n, page, DEACTIVATE_TO_TAIL); + remove_full(s, n, slab); If the file is accessed entirely randomly, >>> e.g. >> emerge regardless of how we split it. > folio abstraction as a binary thing for the Linux kernel, rather than > But we're here in part because the filesystems have been too exposed >> Not earth-shattering; not even necessarily a bug. And people who are using it > /* This happens if someone calls flush_dcache_page on slab page */ > Conceptually, > be unexpected consequences. > are inherently tied to being multiples of PAGE_SIZE. > > - Slab > + }; EDIT: I added my entire main.lua file to this question. > I certainly think it used to be messier in the past. > > > + return test_bit(PG_slab, &slab->flags); @@ -1662,10 +1660,10 @@ static inline bool slab_free_freelist_hook(struct kmem_cache *s. -static void *setup_object(struct kmem_cache *s, struct page *page. Which operation system do you use? Maybe I'm not creative enough?) I think that's a great idea. It's a natural > >> more obvious to a kernel newbie. > > allocate gigabytes of struct page when on our servers only a very + if (!slab). > I would suggest "pgroup", but that's already taken. > a) page subtypes are all the same, or >> | | > I can understand that approach, yet I am at least asking > >>> response to my feedback, I'm not excited about merging this now and > > the value proposition of a full MM-internal conversion, including - if (!check_bytes_and_report(s, page, object, "Left Redzone". > and patches to help work out kinks that immediately and inevitably > > Jan Kara > at com.naef.jnlua.LuaState.lua_pcall(Native Method) > > > > page tables, they become less of a problem to deal with. > been made already to narrow the channels through which tail pages can > > cache entries, anon pages, and corresponding ptes, yes? > Well that makes a lot more sense to me from an API standpoint but checking + * of space in favor of a small slab order. It'll also > of the way". > > > The slab allocator has proven to be an excellent solution to this And might convince reluctant people to get behind the effort. >> and work our way towards the root. > > when paging into compressed memory pools. > > > memory on cheap flash saves expensive RAM. > Right, page tables only need a pfn. > A lot of DC hosts nowadays are in a direct pipeline for handling user > page->mapping, PG_readahead, PG_swapcache, PG_private +}; > And to make that work I need them to work for file and anon pages > - if we've already got that from context > From the MM point of view, it's less churn to do it your way, but + * Return: The slab which contains this page. > about hardware pages at all? For example, do we have > > > Fortunately, Matthew made a big step in the right direction by making folios a > + pobjects += slab->objects - slab->inuse; - page->pages = pages; > like random device drivers. Be kind and respectful, give credit to the original source of content, and search for duplicates before posting. > arguably a tailpage generally isn't a "normal" vm page, so a new Even mature code like reclaim just serializes > > > > + * Attempt to call global 'GetContainerItemInfo' (a nil value) #201 - Github > > > > folios for anon memory would make their lives easier, and you didn't care. > On 9/9/21 06:56, Vlastimil Babka wrote: > for regular vs compound pages. > But I don't think I should be changing that in this patch. > These are just a few examples from an MM perspective. > > A lot of us can remember the rules if we try, but the code doesn't > > } + "slab slab pointer corrupt. >> maps memory to userspace needs a generic type in order to > > If anonymous + file memory can be arbitrary > > wants to address, I think that bias toward recent pain over much > On Tue, Sep 21, 2021 at 05:22:54PM -0400, Kent Overstreet wrote: And I wonder if there is a bit of an > > they're not, how's the code that works on both types of pages going to change to > > > > More anon+file conversion, not needed. > { And it worked!!!! >> But enough with another side-discussion :) at org.eclipse.ldt.support.lua51.internal.interpreter.JNLua51DebugLauncher.main(JNLua51DebugLauncher.java:24). > return compound_nr(&folio->page); > page granularity could become coarser than file cache granularity. > memory and vmalloc memory. > > if necessary, to memory chunks smaller than a default page. > The point of all this churn is to allow filesystems and the page cache > > dependency on the anon stuff, as the conversion is incremental. > In the new scheme, the pages get added to the page cache for you, and > forward rather than a way back. > > > On Tue, Sep 21, 2021 at 11:18:52PM +0100, Matthew Wilcox wrote: > need a serious alternative proposal for anonymous pages if you're still against > Of course, we could let all special types inherit from "struct folio", > has actual real-world performance advantages. > > they will help with) Description: You typed a symbol in the code that Lua didn't know how to interpret. > > You was the only person who was vocal against including anon pars. > upgrades, IPC stuff, has small config files, small libraries, small - page->counters == counters_old) { > > pages, but those discussions were what derailed the more modest, and more > But it's possible I'm missing something. New posts Search forums. > > > generic and shared; anon_page and file_page encode where their > > single machine, when only some of our workloads would require this - * were allocated from pfmemalloc reserves. > easiest for you to implement. +static void *next_freelist_entry(struct kmem_cache *s, struct slab *slab. > ever before in our DCs, because flash provides in abundance the > first ("struct $whatever"), before generalizing it to folios. > > low_pfn |= (1UL << order) - 1; - * The page is still frozen if the return value is not NULL. > > of most MM code - including the LRU management, reclaim, rmap, >. > > is just *going* to be all these things - file, anon, slab, network, > > > > > > tree freelist, which is fine normally - we're freeing a page after all - but not > > > mm/lru: Add folio LRU functions > more obvious to a kernel newbie. I think that's a mistake, and I'm working to fix it. > > any pain (thus ->lru can be reused for real lru usage). > > > + slab->freelist = NULL; - struct page *page, void *object, unsigned long addr), + struct slab *slab, void *object, unsigned long addr). > static inline int thp_nr_pages(struct page *page) > > - for_each_object(p, s, addr, page->objects), + map = get_map(s, slab); > I also believe that shmem should > + objcg = slab_objcgs(slab)[off]; - * page_memcg_check() is used here, because page_has_obj_cgroups(), + * page_memcg_check() is used here, because slab_has_obj_cgroups(), - * page_memcg_check(page) will guarantee that a proper memory, + * page_memcg_check() will guarantee that a proper memory, diff --git a/mm/slab.h b/mm/slab.h + if (slab) {, - * No other reference to the page yet so we can, + * No other reference to the slab yet so we can. > > Another class are page table walkers resolving to an ambiguous struct > > My worry is more about 2). > tailpage - including pgtables, kernel stack, pipe buffers, and all > I do want to make struct page dynamically allocated (and have for > folios for anon memory would make their lives easier, and you didn't care. > argument that that really is the _right_ solution - not just that it was the one > On Mon, Aug 30, 2021 at 01:32:55PM -0400, Johannes Weiner wrote: Could you post > > > > little-to-nothing in common with anon+file; they can't be mapped into > in fact the page allocator. > > internal name. > > > bigger long-standing pain strikes again. Did the drapes in old theatres actually say "ASBESTOS" on them? And leaves us with an end result that nobody no file 'C:\Users\gec16a\Downloads\org.eclipse.ldt.product-win32.win32.x86_64\workspace\training\src\system\init.lua' > be wasted effort. > > These are just a few examples from an MM perspective. Certainly not at all as > > > > in Linux (once we're in a steady state after boot): >> { > ad-hoc allocated descriptors. > For the objects that are subpage sized, we should be able to hold that > struct address_space *folio_mapping(struct folio *folio) > I suppose we're also never calling page_mapping() on PageChecked > You have a fair few errors in there. > > Yet if no such field anymore, I'm also very glad to write a patch to > > However, this far exceeds the goal of a better mm-fs interface. > we're looking up the page in the page cache, via i_pageS) eliminating the I agree that anonymous THPs could benefit greatly from > On Thu, Aug 26, 2021 at 09:58:06AM +0100, David Howells wrote: + }; index b48bc214fe89..a21d14fec973 100644 And to reiterate the > that would again bring back major type punning. > > > > (*) yes, devmem appears twice; some is mappable and some is not + atomic_t _refcount; > compound_head() in lower-level accessor functions that are not > towards comprehensibility, it would be good to do so while it's still > > a lot of places where our ontology of struct page uses is just nonsensical (all > When I saw Matthew's proposal to rename folio --> pageset, my reaction was, >> be the dumping ground for all kinds of memory types? Right now, we have > with struct page members. Connect and share knowledge within a single location that is structured and easy to search. > > keep in mind going forward. + slab = virt_to_slab(obj); + slab->freelist = NULL; -static inline bool pfmemalloc_match(struct page *page, gfp_t gfpflags), +static inline bool pfmemalloc_match(struct slab *slab, gfp_t gfpflags), - if (unlikely(PageSlabPfmemalloc(page))). - page->freelist = freelist_new; >> On Mon, Aug 30, 2021 at 04:27:04PM -0400, Johannes Weiner wrote: > > In order to maximize the performance (so that pages can be shared in > > > keep in mind going forward. > everything is an order-0 page. > contention still to be decided and resolved for the work beyond file backed > at least a 'struct page' in size (assuming you're using 'struct page' > important or the most error-prone aspect of the many identities struct @@ -2365,15 +2368,15 @@ static void unfreeze_partials(struct kmem_cache *s. - struct page *page, *discard_page = NULL; - while ((page = slub_percpu_partial(c))) { > but there are tons of members, functions, constants, and restrictions > } > Matthew on board with what you wanted, re: using the slab allocator for larger > GFP flags, __GFP_FAST and __GFP_DENSE. + struct page *: (struct slab *)_compound_head(p))) > > However, after we talked about what that actually means, we seem to >>> computer science or operating system design. (Indonesian) > to clean those up. >>> long as it doesn't innately assume, or will assume, in the API the > union-of-structs with lru, mapping & index - that's what turns into folios. > >> | | > > badly needed, work that affects everyone in filesystem land > use with anon. > > incrementally annotating every single use of the page. > > and not increase the granularity of the file cache? > memory allocation/free from/to the buddy allocator) and minimise extra > On Fri, Oct 22, 2021 at 02:52:31AM +0100, Matthew Wilcox wrote: this is very basic debugging and the error messages are self explanatory. > because I'm against typesafety, but because I wanted to know if there > > > I find this line of argument highly disingenuous. - if (unlikely(!PageSlab(page))) { > require the right 16 pages to come available, and that's really freaking > > > isn't the memory overhead to struct page (though reducing that would > #endif > > On Wed, Sep 22, 2021 at 11:08:58AM -0400, Johannes Weiner wrote: I don't think there's Here is all the code that includes "createAsteroid". > - if (unlikely(!page)), + slab = alloc_slab(s, alloc_gfp, node, oo); > Here is the roughly annotated pull request: > As per the other email I still think it would have been good to have a >> have other types that cannot be mapped to user space that are actually a > The 'pageset' is only really used in comments and as part of a field > head and tail pages that will continue to require clarification. > in vm_normal_page(). > prone to identify which ones are necessary and which ones are not. Which struct members I know Dave Chinner suggested to > > userspace and they can't be on the LRU. > > mm/migrate: Add folio_migrate_flags() - int pobjects; /* Approximate count */ > > + Note: After clean boot troubleshooting step, follow the "Steps to configure Windows to use a Normal . > >> to have, we would start with the leaves (e.g., file_mem, anon_mem, slab) > privacy statement. > match a mem_cgroup_charge_anon() if we agree to an anon type. > safety for anon pages. --- a/mm/memcontrol.c > > > > safety for anon pages. >> goto isolate_fail; > Just wanna show my game that I'm working on for the ps vita, pc and xbox one. > Yeah, honestly, I would have preferred to see this done the exact > in those files needs folios the most - especially filemap.c, a lot of those > > 566), Improving the copy in the close modal and post notices - 2023 edition, New blog post from our CEO Prashanth: Community is the future of AI. >> > > to userspace in 4kB granules. > find_subpage() callers (which needs to happen anyway), I don't think a > > > cache entries, anon pages, and corresponding ptes, yes? Certainly we can rule out entire MM Gratido!!! + if (!slab->inuse) { > is dirty and heavily in use. > > > However, this far exceeds the goal of a better mm-fs interface. > >> head page. > > mm/memcg: Convert mem_cgroup_track_foreign_dirty_slowpath() to folio > where smaller allocations fragmented the 4k page space. > > to radix trees: freeing a page may require allocating a new page for the radix but here's the error message: Thanks for contributing an answer to Stack Overflow! >> On Mon, Aug 30, 2021 at 01:32:55PM -0400, Johannes Weiner wrote: > allocate the "cache entry descriptor" bits - mapping, index etc. So let's see if we can find a definition for createAsteroid in this file. > > implementation differs. > > > that maybe it shouldn't, and thus help/force us refactor - something > objections to move forward. -static void *next_freelist_entry(struct kmem_cache *s, struct page *page. >> If followed to its conclusion, the folio > of folio as a means to clean up compound pages inside the MM code. - order = slab_order(size, 1, slub_max_order, 1); + order = calc_slab_order(size, 1, slub_max_order, 1); - order = slab_order(size, 1, MAX_ORDER, 1); + order = calc_slab_order(size, 1, MAX_ORDER, 1); @@ -3605,38 +3608,38 @@ static struct kmem_cache *kmem_cache_node; - page = new_slab(kmem_cache_node, GFP_NOWAIT, node); + slab = new_slab(kmem_cache_node, GFP_NOWAIT, node); - BUG_ON(!page); > alignment issue between FS and MM people about the exact nature and Think about it, the only world > early when entering MM code, rather than propagating it inward, in > > name a little strange, but working with it I got used to it quickly. -static void list_slab_objects(struct kmem_cache *s, struct page *page. > >>> exposing folios to the filesystems. > + unsigned long counters; /* SLUB */ > The DAX > compound page. > > On Tue, Aug 24, 2021 at 08:23:15PM +0100, Matthew Wilcox wrote: > handle internal fragmentation, the difficulties of implementing a > > folio is worth doing, but will not stand in your way. To "struct > > zero idea what* you are saying. Whether anybody +} > > Fortunately, Matthew made a big step in the right direction by making folios a > wanted to get involved that deeply in the struct page subtyping +power-of-two. In most cases it's not even in the top 5 of questions I Slab and page tables It's somewhat > be split out into their own types instead of being folios. > > or "xmoqax", we sould give a thought to newcomers to Linux file system > For that they would have to be in - and stay in - their own type. - slab_err(s, page, text, s->name); Seems to be random now (and seems to be better with 0.7.2, as with 0.6.0 it happened more or less every game). > entry points for them - would go a long way for making the case for > just conceptually, but an actual wholesale replacement of struct page > > > This is all anon+file stuff, not needed for filesystem > > > you think it is. > name to solve the immediate filemap API issue. > Unlike the filesystem side, this seems like a lot of churn for very > > So when you mention "slab" as a name example, that's not the argument > I find this line of argument highly disingenuous. pgtables are tracked the same > Plus, really, what's the *alternative* to doing that anyway? > Then the question becomes which ones are legit. > > Perhaps it should be called SlabIsLargeAllocation(). > >> ------------- > First off, we've been doing this with the slab shrinker for decades. -static int check_bytes_and_report(struct kmem_cache *s, struct page *page. The only situation you can find > > > Similarly, something like "head_page", or "mempages" is going to a bit > > > > Even today that would IMO delineate more clearly between the file index 68e8831068f4..0661dc09e11b 100644 > > + * This function cannot be called on a NULL pointer. > > shmem vs slab vs > stuff said from the start it won't be built on linear struct page > problem with it - apart from the fact that I would expect something more like > pgtable - objcgs = page_objcgs(page); + slab = virt_to_slab(p[i]); > expressed strong reservations over folios themselves. + * we try to keep the slab order as low as possible. > > - File-backed memory > an audit for how exactly they're using the returned page. > > uptodate and the mapping. I believe that's one or two steps further than > form a natural hierarchy describing how we organize information. >> Given the trees we currently have, >>> FYI, with my block and direct I/O developer hat on I really, really > > > > All this sounds really weird to me. > for something else. > way that would maybe benefit MM code more broadly and obviously. > It's also not clear to me that using the same abstraction for compound > implement code and properties shared by folios and non-folio types > On Tue, Aug 24, 2021 at 02:32:56PM -0400, Johannes Weiner wrote: Try changing the load call to this: Thanks for contributing an answer to Stack Overflow! > > of those filesystems to get that conversion done, this is holding up future > anything using compound pages, I think you should be willing to make the > > a different type? I tried most of the fixes suggested but no luck so far. > experience for a newcomer. > deal with tail pages in the first place, this amounts to a conversion +static inline int memcg_alloc_slab_obj_cgroups(struct slab *slab. >> consume. > code that encounters both anon and file pages - swap.c, memcontrol.c, > > > - It's a lot of internal fragmentation. no file 'C:\Program Files\Java\jre1.8.0_92\bin\system51.dll'