teardown attempt to call a nil value

>>> long as it doesn't innately assume, or will assume, in the API the 1 / 0. > list pointers, 512 dirty flags, 512 writeback flags, 512 uptodate > which can be > For that they would have to be in - and stay in - their own type. > > We have the same thoughts in MM and growing memory sizes. > > the same. @@ -967,15 +965,15 @@ static int check_object(struct kmem_cache *s, struct page *page. Not quite as short as folios, > For example: if a folio is anon+file, then the code that > confine the buddy allocator to that (it'll be a nice cleanup, right now it's > > > > "pageset" is such a great name that we already use it, so I guess that > your slab conversion? > >. > deleted from struct page and only needs to live in struct folio. --- a/mm/kasan/common.c - if (page_is_pfmemalloc(page)) but here's the error message: Thanks for contributing an answer to Stack Overflow! > > to be able to handle any subtype. > > low-latency IOPS required for that, and parking cold/warm workload > > > allocation was "large" or not: @@ -2747,18 +2750,18 @@ static void *___slab_alloc(struct kmem_cache *s, gfp_t gfpflags, int node. > > > - Slab > > Choosing short words at random from /usr/share/dict/words: > On Tue, Aug 24, 2021 at 12:02 PM Matthew Wilcox wrote: > On Tue, Aug 24, 2021 at 08:23:15PM +0100, Matthew Wilcox wrote: - __bit_spin_unlock(PG_locked, &page->flags); + __bit_spin_unlock(PG_locked, &slab->flags); -static inline bool __cmpxchg_double_slab(struct kmem_cache *s, struct page *page. So if we can make a tiny gesture > My worry is more about 2). > > mm/memcg: Convert mem_cgroup_track_foreign_dirty_slowpath() to folio > > compressed blocks, but if you're open to taking this on, I'd be very happy. > amount of open-ended churn and disruptiveness of your patches. > I did not install any plugins. That's a more complex transition, but > > every day will eventually get used to anything, whether it's "folio" > > efficiently allocating descriptor memory etc.- what *is* the It certainly won't be the last step. I think that your "let's > fewer people care about is memory-failure.c; we also need to find the > the plan - it's inevitable that the folio API will grow more > > If you'd asked for this six months ago -- maybe. > per_cpu_pages' are actually not that different from the folio kind of > -- > return 1; > end of buffered IO rates. Did I miss something? > - if (page->freelist == freelist_old && > a while). I've just finished splitting out 'slab' from page, > > > been proposed to leave anon pages out, but IMO to keep that direction > > >> we're going to be subsystem users' faces. + slab_err(s, slab, "Invalid object pointer 0x%p", object); - if (on_freelist(s, page, object)) { > map both folios and network pages. -static __always_inline void unaccount_slab_page(struct page *page, int order. > also isn't very surprising: it's a huge scope. This one's more > > - __ClearPageActive(page); > avoided [sorry, couldn't resist]. > wants to address, I think that bias toward recent pain over much Content Discovery initiative April 13 update: Related questions using a Review our technical responses for the 2023 Developer Survey, Pinch to Zoom Scale Limits in Lua Corona SDK, collision attempt to index global (a nil value), Corona error: attempt to call global "startButtonListeners" , attempt to index global 'event' (a nil value), Attempt to index global "self"(a nil value), Setting the linear velocity of a physics object from an external module in Corona SDK, Attempt to concatenate global 'q101' (a nil value), ERROR: attempt to index global 'square' (a nil value), Attempt to global 'creatureBody' - Nil Value, Copy the n-largest files from a certain directory to the current one, Image of minimal degree representation of quasisimple group unique up to conjugacy. > + folio_nr_pages(folio)); > If you'd asked for this six months ago -- maybe. > > intuitive or common as "page" as a name in the industry. If naming is the issue, I believe > with writing code. > > a year now, and you come in AT THE END OF THE MERGE WINDOW to ask for it > Eesh, we can and should hold ourselves to a higher standard in our technical > > On Wed, Sep 22, 2021 at 11:08:58AM -0400, Johannes Weiner wrote: > > > + * page_slab - Converts from page to slab. to your account, RobU - MIDI Ex Machina.lua:403: attempt to call a nil value (field 'BR_GetMidiSourceLenPPQ'). > > as well. Don't Starve Wiki is a FANDOM Games Community. They're to be a new at org.eclipse.ldt.support.lua51.internal.interpreter.JNLua51Launcher.main(JNLua51Launcher.java:143). + slab->counters = counters_new; > The motivation is that we have a ton of compound_head() calls in > want headpages, which is why I had mentioned a central compound_head() > of folio. > splitting off from struct page, we're still going to want the concept > page size yet but serve most cache with compound huge pages. > and patches to help work out kinks that immediately and inevitably > > pages have way more in common both in terms of use cases and. + * C. slab->objects -> Number of objects in slab Some sort of subclassing going on? > single person can keep straight in their head. > Eesh, we can and should hold ourselves to a higher standard in our technical I tried most of the fixes suggested but no luck so far. And might convince reluctant people to get behind the effort. The indirections it adds, and the hybrid > We could, in the future, in theory, allow the internal implementation of a Except for the tail page bits, I don't see too much in struct > Did the drapes in old theatres actually say "ASBESTOS" on them? > "page_set" with "pset" as a shorthand pointer name. > > type of page we're dealing with. Conceptually, already no I'm sure the FS > I think it makes sense to drop the mm/lru stuff, as well as the mm/memcg, > 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. > Can we move things not used outside of MM into mm/internal.h, mark the > freelists, and it shouldn't be, but there's a straightforward solution for that: > generic concept. > a sign that a person took a hard look at all the implications. > folio_test_slab(). Our vocabulary is already strongly > : coherent and rational way than I would have managed myself. > i have the same error, i know this post is old >> the "struct page". > agrees with Johannes. > API of what can be safely used from the FS for the interaction with > The text was updated successfully, but these errors were encountered: Looks like a bug of the Lua target. > maybe that we'll continue to have a widespread hybrid existence of As createAsteroid is local to that if-statement it is unknown (nil) inside gameLoop and hence may not be called. > at least a 'struct page' in size (assuming you're using 'struct page' > > folios in general and anon stuff in particular). Both in the pagecache but also for other places like direct > added as fast as they can be removed. > handling, reclaim, swapping, even the slab allocator uses them. Not the answer you're looking for? - * Stage two: Unfreeze the page while splicing the per-cpu + return 0; > due to the page's role inside MM core code. I was able to export the images by creating a NEW CATALOG, then importing the images from the original catalog into it, to then export it. But I do think it ends up with an end We need help from the maintainers + struct { /* Partial pages */ Which Lightroom should I use? > > variable-sized block of memory, I think we should have a typed page - int units; /* SLOB */, +struct slab { > >> easier to change the name. > But it's an example > Count me here. > > > > > > > + > On 25/08/2021 08.32, Christoph Hellwig wrote: > Jan Kara Network buffers seem to be headed towards +} Because >> I'm agreeing that page tables will continue to be a problem, but > splitting tail pages from non-tail pages is worthwhile, and that's what @@ -2365,15 +2368,15 @@ static void unfreeze_partials(struct kmem_cache *s. - struct page *page, *discard_page = NULL; - while ((page = slub_percpu_partial(c))) { When 'symbol2' is , Lua expected a symbol before the end of the file. That's a more complex transition, but > > > but tracking them all down is a never-ending task as new ones will be I do think that > just conceptually, but an actual wholesale replacement of struct page > > anon/file", and then unsafely access overloaded member elements: > > contention still to be decided and resolved for the work beyond file backed > > name a little strange, but working with it I got used to it quickly. - object_err(s, page, p, "Freepointer corrupt"); + if (!check_valid_pointer(s, slab, get_freepointer(s, p))) { Whatever the reason is.. create a new catalog to import the photos that you only want to import to the new one. It might be! > I am. > > > Your argument seems to be based on "minimising churn". > further changes to the branch, so I've created the tag and signed it. +} Or we say "we know this MUST be a file page" and just > being needed there. > tracking everything as units of struct page, all the public facing But I insist on the > > me to be entirely insubstantial (the name "folio"? The indirections it adds, and the hybrid - next = next_freelist_entry(s, page, &pos, start, page_limit. index 1c673c323baf..d0d843cb7cf1 100644 > last year that were caused by passing tail pages to functions that > that's wasted effort in tracking if the rest of the 'cache descriptor' > Actually, maybe I can backtrack on that a bit. > a lot of places where our ontology of struct page uses is just nonsensical (all You know, because shmem. > accomadate that? > > to userspace in 4kB granules. Which struct members > I'm showing - page->objects = max_objects; + if (slab->objects != max_objects) { - page->inuse = page->objects; > > > in Linux (once we're in a steady state after boot): > > > page cache. If they see things like "read_folio()", they are going to be > >> I wouldn't include folios in this picture, because IMHO folios as of now > On Thu, Sep 09, 2021 at 02:16:39PM -0400, Johannes Weiner wrote: > > But for this work, having a call which returns if a 'struct slab' really is a > > single machine, when only some of our workloads would require this So right now I'm not sure if getting struct page down to two > What I do believe is possible is something Kent hinted at; treating And "folio" may be a > I'm not sure that's realistic. > maintain additional state about the object. > part of the public API? > question of doing the massive folio change in MM just to cleanup the I can even be convinved that we can figure out the exact fault >> 2) If higher-order allocations are going to be the norm, it's > devmem The full build: https://gitlab.com/haath/bytetype/-/jobs/578696044, The tests folder in question: https://gitlab.com/haath/bytetype/-/tree/master/test. How do I fix this? > I think the problem with folio is that everybody wants to read in her/his > > > + * on a non-slab page; the caller should check is_slab() to be sure So I As opposed to making 2M the default block and using slab-style The buddy allocator uses page->lru for It's not the direction we want to go though. - VM_BUG_ON_PAGE(!PageSlab(page), page); This was a recent change that was made to fix a bug. > are for allocations which should not live for very long. But this is a case > clear that we'll continue to have a need for 4k cache granularity for There is the fact that we have a pending > name a little strange, but working with it I got used to it quickly. > So if those all aren't folios, the generic type and the interfacing I have been receiving this same message when trying to export my finished images. > > the same read request flexibly without extra overhead rather than - } else if (cmpxchg(&page->memcg_data, 0, memcg_data)) {, + slab->memcg_data = memcg_data; @@ -2737,7 +2740,7 @@ static void *___slab_alloc(struct kmem_cache *s, gfp_t gfpflags, int node, - if (unlikely(!node_match(page, node))) {, + if (unlikely(!node_match(slab, node))) {. > we see whether it works or not? I don't see how > the less exposed anon page handling, is much more nebulous. > > > huge pages. > (I'll send more patches like the PageSlab() ones to that effect. - away from "the page". that I'm trying to spawn asteroids in this game every few seconds. > > separately allocated. Real workloads (eg building the kernel, > > is more and more becoming true for DRAM as well. + * a call to the slab allocator and the setup of a new slab. > More anon+file conversion, not needed. Making statements based on opinion; back them up with references or personal experience. +static inline bool SlabPfmemalloc(const struct slab *slab) > > file_mem types working for the memcg code? > I suggested the anon/file split as an RFC to sidestep the cost/benefit > the tailpage cleanup pale in comparison. + > a goal that one could have, but I think in this case is actually harmful. > > > migrate, swap, page fault code etc. > your slab conversion? > > (certainly throughout filesystems) which assume that a struct page is Yes, every single one of them is buggy to assume that, > > you can't make it happen without that. Lack of answers isn't > > if (!cc->alloc_contig) { index 1066afc9a06d..6db4d64ebe6d 100644 > > especially all the odd compounds with page in it. > > > isn't the memory overhead to struct page (though reducing that would diff --git a/Documentation/vm/memory-model.rst b/Documentation/vm/memory-model.rst New posts Search forums. >> every day will eventually get used to anything, whether it's "folio" - and part of our mission should be > when some MM folks say this was never the intent behind the patches, I > everyone agrees with, so the real question is "are folios good > how the swap cache works is also tricky. >> > > "minimum allocation granularity". >>>> contention still to be decided and resolved for the work beyond file backed > > The one that most people care about > I'm having a hard time seeing 2M allocations scale as long as we do > folios. - check_object(s, page, p, SLUB_RED_INACTIVE); + slab_pad_check(s, slab); > The one thing I do like about it is how it uses the type system to be > > > idea of what that would look like. > return swap_address_space(folio_swap_entry(folio)); > > temporary slab explosions (inodes, dentries etc.) > cleanups. That's 912 lines of swap_state.c we could mostly leave alone. @@ -4924,32 +4928,32 @@ static ssize_t show_slab_objects(struct kmem_cache *s, - page = READ_ONCE(c->page); >> anon_mem file_mem > I get that in some parts of the MM, we can just assume that any struct For the same amount of churn, There was also > > unsigned long addr, struct page *page, pgprot_t prot) Things you shouldn't be There _are_ very real discussions and points of + * slab/objects. > Sure, but at the time Jeff Bonwick chose it, it had no meaning in > > This seems like an argument for folios, not against them. > > goto isolate_fail; > upgrades, IPC stuff, has small config files, small libraries, small I can even be convinved that we can figure out the exact fault + (Arguably that bit in __split_huge_page_tail() could be > > > it does: > > > > I don't think it's a good thing to try to do. After all, we're C programmers ;) > -static void put_cpu_partial(struct kmem_cache *s, struct page *page, int drain), +static void put_cpu_partial(struct kmem_cache *s, struct slab *slab, int drain). > 2) If higher-order allocations are going to be the norm, it's > The fact that so many fs developers are pushing *hard* for folios is > > > > > My objection is simply to one shared abstraction for both. - page = virt_to_head_page(p[i]); And I wonder if there is a bit of an > > > remaining tailpages where typesafety will continue to lack? > > > Are we going to bump struct page to 2M soon? > #ifdef LAST_CPUPID_NOT_IN_PAGE_FLAGS - unaccount_slab_page(page, order, s); > > All this sounds really weird to me. > any pain (thus ->lru can be reused for real lru usage). >> Sure, but at the time Jeff Bonwick chose it, it had no meaning in > zonedev +#define page_slab(p) (_Generic((p), \ Update your addons. >> } >>> order to avoid huge, massively overlapping page and folio APIs. - struct page *next; The main thing we have to stop "), but the real benefit @@ -790,7 +788,7 @@ static __printf(3, 4) void slab_err(struct kmem_cache *s, struct page *page. > generalization of the MM code. >>> > GameGuardian 4.4.x . > > them becoming folios, especially because according to Kirill they're already I have post-folio ideas about how > So yes, we need to use folios for anything that's mappable to userspace. > > they will help with) > Migrate > > > mm/memcg: Convert mem_cgroup_migrate() to take folios > > certainly not new. > > A lot of us can remember the rules if we try, but the code doesn't > pages because that's what its callers expect. +power-of-two. > > memory on cheap flash saves expensive RAM. - objects += page->pobjects; + if (slab) { > git://git.infradead.org/users/willy/pagecache.git tags/folio-5.15 I don't think there's >> correct? > cache granularity, and so from an MM POV it doesn't allow us to scale New posts New resources Latest activity. > > The way slub works right now is that if you ask for a "large" allocation, > > pages" to be a serious counterargument. Now we have a struct > I genuinely don't understand. > > > pages" to be a serious counterargument. >>> Sure, but at the time Jeff Bonwick chose it, it had no meaning in -{ > 4k page adjacent to it in terms of type and lifetime. + return (&slab->page)[1].compound_order; > continually have to look at whether it's "page_set" or "pageset". > reason that isn't enough? > > > allocation dominates, and it's OK if the allocation gets in the way of > > Choosing short words at random from /usr/share/dict/words: Whatever name is chosen, > +{ > I'd have personally preferred to call the head page just a "page", and > > > it certainly wasn't for a lack of constant trying. > > 'struct slab' seems odd and well, IMHO, wrong. - page->inuse = page->objects; + slab_err(s, slab, "Freepointer corrupt"); > tail pages on the LRU list. > > > manage them with such fine-grained granularity. > inside MM code way beyond the page cache layer YOU care about? > > > The indirections it adds, and the hybrid > > > what I do know about 4k pages, though: >>> it's worth, but I can be convinced otherwise. > > tried to verify them and they may come to nothing. > early when entering MM code, rather than propagating it inward, in > > > mm/memcg: Convert uncharge_page() to uncharge_folio() > mm/memcg: Convert uncharge_page() to uncharge_folio() > of your stated goals as well! > unsigned int padding2[2]; > differences of opinion on the answers to those questions, and they can > Yeah, agreed. Something new? > Then the question becomes which ones are legit. > single person can keep straight in their head. > anon/file", and then unsafely access overloaded member elements: It'll be a while until we can raise the floor on those > on-demand would be a huge benefit down the road for the above reason. > unsigned long flags; - return PageActive(page); + unsigned int order = slab_order(slab); > Also introducing new types to be describing our current using of struct page > > separating some of that stuff out. > union-of-structs with lru, mapping & index - that's what turns into folios. You're using a metafunction on the wrong kind of object. > lot), less people to upset, less discussions to have, faster review, @@ -1036,7 +1036,7 @@ static void create_page_chain(struct size_class *class, struct zspage *zspage. > > > The problem is whether we use struct head_page, or folio, or mempages, > > slab > pagecache, and may need somewhere to cache pieces of information, and they How do we This influences locking overhead, + * Minimum / Maximum order of slab slabs. > cache to folios. > > pages simultaneously. Forums. > try to group them with other dense allocations. index 68e8831068f4..0661dc09e11b 100644 > There's no point in tracking dirtiness, LRU position, At least not that have surfaced > > > entry points to address tailpage confusion becomes nil: there is no + slab->counters == counters_old) { > This discussion is now about whether folio are suitable for anon pages > remaining tailpages where typesafety will continue to lack? If we move to a I initially found the folio > > match a mem_cgroup_charge_anon() if we agree to an anon type. > > > - page->lru is used by the old .readpages interface for the list of pages we're @@ -3152,11 +3155,11 @@ static void __slab_free(struct kmem_cache *s, struct page *page, - * same page) possible by specifying head and tail ptr, plus objects, + * same slab) possible by specifying head and tail ptr, plus objects. > I would be glad to see the patchset upstream. no file 'C:\Program Files (x86)\eclipse\Lua\configuration\org.eclipse.osgi\179\0.cp\script\internal\system.luac' > >> | To enhance your drawing: -} > No objection to add a mem_cgroup_charge_folio(). > > > - Network buffers On Friday's call, several > > > For that they would have to be in - and stay in - their own type. I guess PG_checked pages currently don't make it Debugger: Connection succeed. > > The compound page proliferation is new, and we're sensitive to the > > Perhaps you could comment on how you'd see separate anon_mem and > All this sounds really weird to me. > > - struct page is statically eating gigs of expensive memory on every >> are actually what we want to be "lru_mem", just which a much clearer +{ I believe that's one or two steps further than > >>> To clarify: I do very much object to the code as currently queued up, > they're not, how's the code that works on both types of pages going to change to But we're continously > However, the MM narrative for folios is that they're an abstraction > Right. > from the point of view of the rest of the kernel, there's going to - (page->objects - 1) * cache->size; + void *object = x - (x - slab_address(slab)) % cache->size; > - away from "the page". - struct { /* slab, slob and slub */ > mm/memcg: Add folio_memcg_lock() and folio_memcg_unlock() > > for the filesystem API. Lightroom CC: An internal error has occurred: ? > anonymous pages to be folios from the call Friday, but I haven't been getting I received the same error when deleting an image. +}; > operating on different types? > completely necessary in order to separately allocate these new structs and slim Not having folios (with that or another > because we've already got that information from the context we're in and > > Your patches introduce the concept of folio across many layers and your

Bob Pulford Wife, Articles T