channel logs for 2004 - 2010 are archived at http://tunes.org/~nef/logs/old/ ·· can't be searched

#osdev2 = #osdev @ Libera from 23may2021 to present

#osdev @ OPN/FreeNode from 3apr2001 to 23may2021

all other channels are on OPN/FreeNode from 2004 to present

http://bespin.org/~qz/search/?view=1&c=osdev2&y=23&m=1&d=14

Saturday, 14 January 2023

00:00:00 <mjg> moon-child: i meant there is no rant from The Man
00:02:00 <heat> mjg, but anyway I think that kernel problems should be more interesting for a kernel position
00:02:00 <mjg> that was the warmup mofo
00:02:00 <heat> like "implement a hashtable"
00:02:00 <heat> which you would tear to shreds :v
00:02:00 <mjg> that is a bad problem mate
00:02:00 <heat> is it?
00:03:00 <mjg> i had a design question, afair for inotify-like solution
00:03:00 <heat> sure, but that's a design question
00:03:00 <mjg> the problem with 'hasthable' is people have no idea what they are doing
00:03:00 <heat> with my problem I'm asking you if you know how the kernel works and its constraints
00:03:00 <mjg> and even someone otherwise competent would do it poorly
00:03:00 <heat> like: you start allocating memory for nodes
00:04:00 <mjg> you can also easily derail yourself into how to resolve xconflicts
00:04:00 <heat> also something like a binary tree, where the naive userspace solution would be to use a bunch of recursion
00:04:00 <mjg> or the birthday paradox
00:05:00 <heat> IMO any of these problems because you can easily understand who understands the kernel and who doesn't
00:05:00 <heat> s/problems/problems are interesting/
00:06:00 <heat> if you understand that data structures and algos should be simple, mem allocation should be avoided and the stack is finite, that lgtm
00:08:00 <moon-child> recursion for tree should be ~ok if you can keep it balanced and so bound height
00:15:00 <mjg> heat: in that spirit you already failed by not asking about requirements
00:15:00 <mjg> should this have bounded capacity and if so how much is it
00:15:00 <mjg> what about multithreading
00:16:00 <mjg> what are you going to push onto the stack
00:16:00 <mjg> is it opaque objs?
00:16:00 <mjg> maybe they can contain linkage?
00:16:00 <heat> what are you talking about?
00:16:00 <heat> the stack problem?
00:16:00 <mjg> yea
00:16:00 <heat> if so, everything is detailed on the little interview website thing
00:16:00 <heat> you can ofc ask questions
00:16:00 <gorgonical> Quick question just to make sure I'm understanding: in ARM paging terms, a "page" is the smallest unit defined by your granularity (4, 16, 64kb), and is always the last level of the page tables. A "block" is when you use an intermediate level of the tables to map a larger region. E.g. what is usually called "large" or "huge" pages. Have I got that right?
00:17:00 <heat> gorgonical, yes
00:17:00 <gorgonical> That's what I thought, but the manual sure does not make that very clear. Thanks
00:17:00 <heat> the manual makes nothing clear
00:17:00 <mjg> it is clear to people on discord
00:17:00 <mjg> disclaimer: not a serious comment
00:17:00 <heat> freebsd discord when?
00:17:00 <mjg> there already is one
00:17:00 <heat> jk does freebsd even have a native discord
00:17:00 <geist> specifically the 4k/16k/64k is called a 'page granule' in arm64
00:17:00 <mjg> lemme show you something
00:18:00 <geist> ie, it'sthe smallest unit, larger pages can be made up of multiples of that
00:18:00 <heat> oh no not your penis again
00:18:00 <mjg> heat: there was a #freebsd channel on some network (efnet i think?)
00:18:00 <heat> i think there's one on libera?
00:18:00 <mjg> heat: fbsd wiki page had it listed as 'infested by teenagers, avoid'
00:18:00 <mjg> :d
00:18:00 <gorgonical> heat: I understand there's some savings in decoder circuits, but the idea that the table descriptor must have the first two bits as 11, but block descriptors must have 01, and then pages must have 11 again, is very confusing
00:18:00 <geist> gorgonical: ytou may also bump into it but there's a notion of a contigous run of pages at a level that's also a valid single unit of page
00:19:00 <geist> ie, between a leaf page and a block
00:19:00 <heat> gorgonical, yup
00:19:00 <gorgonical> insane
00:19:00 <heat> i did fall into that
00:19:00 <gorgonical> The manual doesn't even tell you what those bits do. The diagram just has the bits and their values for the format
00:19:00 <moon-child> https://wiki.freebsd.org/Discord awww, seemingly gone now
00:19:00 <bslsk05> ​wiki.freebsd.org: Discord - FreeBSD Wiki
00:19:00 <heat> "oh, pages surely are also a "block""
00:20:00 <geist> contiguous pages iirc
00:20:00 <heat> the arm arm is nuts IMO
00:20:00 <geist> gorgonical: not really going to help but FWIW i have a little table i put together here at https://newos.org/txt/arm64_pages.txt to remember it
00:20:00 <heat> needs a lot of digesting and going back on forth
00:20:00 <gorgonical> I am running into issues turning on the MMU with my kernel in secure state and I am figuring it's probably something to do with ifetch and the page talbes being wrong
00:20:00 <geist> ie, what all the intermediate page sizes are given the 3 different base page granules
00:21:00 <gorgonical> geist: thank you. I love collecting reference materials. Half of osdev for me is having the right docs
00:21:00 <geist> yah dunno what the quality of the wiki is on arm64
00:21:00 <geist> unrelated: https://youtu.be/KR3TbL3Tl6M 8 hours of defragging
00:21:00 <bslsk05> ​'8 Hours of defrag | hard disk defragmentation ASMR | Hard Disk Sound Effect | HDD sounds' by 8 Hours of (08:00:00)
00:23:00 <heat> oh god
00:23:00 <heat> >mechanical hdd sounds
00:23:00 <heat> i have some sort of ptsd after 8 years of using windows 10+ on mechanical 5400rpm hard drives
00:24:00 <geist> this is reasonably pleasant sounding disk, at least no spindle whine, but it does have a lot of fan noise
00:24:00 <heat> took 40 minutes to boot to desktop
00:24:00 <heat> it was nuts
00:25:00 <heat> i still don't understand how windows 10 grew so anti-mechanical-hdd
00:25:00 <heat> is this a kernel thing? idk
00:26:00 <heat> surely the boot process didn't get that much more complicated
00:27:00 <geist> yeah i have wondered about that. there must be some sort of non linear response to the size of the system going up for the boot stampede of more and more paralell processes all starting at once
00:28:00 <geist> you'd think, if a system is 50MB and it has to demand load it all n from a disk with high seek time it'd take X time, and if it grew to 100MB it'd be X*2
00:28:00 <heat> yeah maybe it did grow so parallel it's hard for mechanical hard drives to make progress
00:28:00 <geist> but it's almost like there's something non linear there
00:28:00 <geist> yah
00:28:00 <geist> i *do* remember in the 7 and vista days there was a lot of investment in boot time prefetching and whatnot, which iirc did help pretty noticably
00:28:00 <heat> if you have 20 threads all doing IO through a disk the seek times just goes through the roof?
00:28:00 <heat> s/goes/go
00:28:00 <geist> but i'm guessing everything modern just gives up and lets SSD deal
00:29:00 <geist> heat: yeah like there's some sort of performance collapse there because it's more likely when any given read request comes through the head is already moved somewhere else
00:29:00 <geist> vs it being a fairly linear progression of read requests for a single thread
00:29:00 <heat> yeah
00:29:00 <geist> but that's a pretty simplistic reduction of the problem. dunno what the real numbers are
00:30:00 <heat> which makes me wonder if this is a kernel problem? did the kernel just stop trying to make hdds happy?
00:30:00 <heat> because a hdd boot drive still feels a lot slower in general system operation, not just booting
00:30:00 <mjg> hm
00:31:00 <heat> tbf linux was and still is absolutely fine on mechanical
00:31:00 <geist> i think tats where it greatly =depend son what you're booting on linux
00:31:00 <geist> ie, booting on a hdd to a full modern gnome desktop or something is definitely pretty slow when on say a slow USB stick
00:31:00 <geist> can take a good minute to a working desktop. in as much as that's somewhat of an analogue to a slow HDD, it seems to stand
00:32:00 <heat> yeah maybe a USB stick or an sd card
00:32:00 <epony> phones boot slow too
00:32:00 <heat> I remember my desktop took like 40 seconds - 1 minute on that hdd
00:32:00 <epony> still faster than a smartphone
00:32:00 <geist> and to be honest, 40seconds to a minute is pretty fast
00:33:00 <heat> absolutely, it took 40 for a full boot in windows
00:33:00 <geist> for most of my usage of early windows machines in the 90s and early 2000s, that'd be average easily
00:33:00 <epony> you can do development in a VM but you have to setup your timings for real HW
00:33:00 <geist> a minute or so was pretty common
00:33:00 <heat> having used shitty computers for most of my life (including now) I can easily tolerate some wait time
00:33:00 <mjg> 2 minutes was standard man
00:33:00 <heat> but a full hour? I wanted to tear my hair out
00:33:00 <mjg> i remember an article from a magazine from the time period with ideas what to do during the 2 minutes
00:33:00 <mjg> like lol
00:34:00 <epony> even feature phones boots slow, and your car boots slow now
00:34:00 <heat> the whole system also locked up consistently in ways I didn't think was imaginable
00:34:00 <epony> the insta-on is for real HW
00:34:00 <heat> I even suspected disk controller failure
00:35:00 <epony> your broadband modem boots slow
00:35:00 <epony> and the TV decoder too
00:35:00 <epony> someday your monitor will boot slow too
00:35:00 <epony> just the battery shorts fast
00:37:00 <epony> windows can boot fast too, over network with virtualisation but there are some wait times here and there
00:38:00 <geist> all that boot time was what really made all the constant windows reboots that much more painful
00:38:00 <epony> a good design boots faster when it can but goes as much as needed when it has to on start up times of various deviecs and cues them up properly early on with a staggered mode
00:38:00 <geist> now it's less of a big deal, but back when you had to boot 5 times in a row on XP to install some thing was a super drag
00:38:00 <epony> yep Win9x was crashing every 50 hours or so, and more frequently
00:39:00 <epony> for the time Windows boots, normal people reinstall from scratch the entire OS with a fresh new snapshot
00:39:00 <epony> and boot at the same finish time
00:40:00 <mjg> now i'm curious what windows 95 was doing on boot
00:40:00 <epony> in naive sequential ordering (without fake parallelism)
00:40:00 <mjg> and let's be real, a lot of it was probably stupid
00:40:00 <epony> windows has always been stupid with the "registry"
00:41:00 <heat> geist, i still don't understand why windows itself needs multiple reboots to install itself
00:41:00 <epony> and it's anti-disassebmly and copy-protection stupidity
00:42:00 <epony> which goes to waste with the prick of a virus
00:42:00 <epony> it's designed in the same way "experience" as Apple shitware is
00:42:00 <epony> that's consumer software in a nutshell
00:43:00 <epony> games do the same
00:43:00 <epony> and office programs and browsers and cad/ide
00:45:00 <geist> heat: i think the classic issue was the fact that DOS and later windows would not let you replace a file that was open and in use. so for stuff ike system dlls and whatnot you'd find that there was an error copying it into place, so it would register a pending file move on the next boot
00:45:00 <geist> may be more complicated problems now with services restarting, etc, but classically that was the case
00:46:00 <epony> you'd fall from the chair if you calculate the net losses in finance and time lost of copy protection and anti-decompile measures
00:46:00 <geist> the problem didn't really exist in DOS per se, because you werent really running more than one program and at a time
00:46:00 <heat> yes that would make sense in normal system operation
00:46:00 <geist> multiple reboots, i dunno
00:46:00 <heat> but when installing windows? kinda weird ngl. although I don't know how the windows installer itself works
00:46:00 <epony> reordering and "instantiation" of records and databases, decompile and decrypt parts etc
00:47:00 <epony> it's a large pile of many such details
00:47:00 <heat> i assume it runs itself in the boot media directly so installing would just be a matter of creating a new partition and setting things up, copying shit and rebooting
00:48:00 <geist> yeah probably going through a few install phases
00:48:00 <epony> you think, but that's not how it goes when the business interests speak over the technical operations
00:48:00 <geist> well, it might then boot into itself, run more setup, download patches, then reboot after that, etc
00:49:00 <epony> download patches in the win9x epoch was not it
00:49:00 <epony> that's way way late after XP even
00:50:00 <epony> you'll see it in the system requirements and activation details
00:51:00 <epony> remember product activation ;-)
00:51:00 <epony> and how late networking setup is part of that process
00:51:00 <epony> and that Win9x install can not proceed without an actual floppy device in the system
00:52:00 <epony> even if it's not used
00:52:00 <epony> so the reboots are also for adding devices and frameworks for drivers, not just some drivers
00:54:00 <epony> it's a lot of these unreported events that are happening that make people lose patience and trust in the system, and not being aware what has been happening in the last 20 years of their computing life ;-)
00:54:00 <epony> desktop environments on Linux achieve the same level of stupidity easy and even surpass it
00:55:00 <epony> but at least you have some 'say' in it or some ability to 'view' logs / find out
00:56:00 <c2a2> twm ftw
00:56:00 <epony> the event logging was added for that reason
00:56:00 <epony> in windows systems but checking that and figuring it out is not the easiest of tasks with the primitive system view tools
00:56:00 <epony> so a large set of the management and control tooling is not available to consumers even in the "advanced" versions / releases
00:58:00 <epony> it's a very deep convolution guide how not to design systems for engineering and how to do it for consumer control and remote reproducible sequences
01:01:00 <epony> https://en.wikipedia.org/wiki/Booting_process_of_Windows
01:02:00 <epony> the TLDR in NTLDR stands for "a lot of crap"
01:02:00 <clever> lol
01:03:00 <epony> that concept of "overlay" (ovl files) is deep ingrained in how these things unrolled
01:04:00 <clever> what exactly was it overlaying?
01:04:00 <clever> binary patches to code?
01:04:00 <epony> system extensions
01:06:00 <epony> https://en.wikipedia.org/wiki/Overlay_file#Historical_use
01:10:00 <epony> and to make things a bit more excellent, there are alternative terms and terminology used for comcepts which are similar but implemented differently and used as de-factore terminology standard, which is not always correct as separation and definition
01:11:00 <epony> notable examples of these are related to memory, file systems and "paging"
01:12:00 <clever> ah yes, calling swap "virtual memory"
01:12:00 <epony> that and keeping previous generation legacy and not validating the system components when such is possible is a major deficit in the Windows systems in their 3.x 9x and NT epoch
01:13:00 <epony> at the same time making sure to mangle the boot records frequently as there can be only one ;-)
01:33:00 <mjg> you guys mentioned defrag
01:33:00 <mjg> this triggered somethin' https://www.youtube.com/watch?v=gY2RlnYcWY0
01:33:00 <bslsk05> ​'w3sp strafes [HD][Quake3 DeFRaG movie]' by xajjA (00:12:12)
01:37:00 <heat> ok im bored out of my mind looking at linux compile
01:38:00 <heat> poll: arithmetic on void *, yes or no?
01:38:00 <epony> the long term imprintment in brain-memory of the wait times for defragmentation to reorder reading from disk only to go to waste quickly after wring and copying things around, and also totally obliterated by decryption and copy protetion techniques that make everything slow
01:38:00 <geist> i personally thin you should be able to do it
01:38:00 <geist> but of course the spec says otherwise
01:39:00 <heat> geist, oh yeah quick q, on x86 it's not defined to set present and only then RW on a page table entry right?
01:39:00 <epony> or the "system trolling" like, we'll throw in a built-in defragmenter now that we've made sure it's useless for 10 years already
01:39:00 <epony> (same with the 'defender' and sysinternals)
01:42:00 <epony> (the other form of "application trolling" being the registry and hive databases and 'accessories' in place of something that actually works)
01:42:00 <moon-child> it's annoying to have to cast to char* and back, so I say yea probably. But it's definitely somewhat sticky
01:42:00 <epony> android and mac/i/os is doing the same
01:43:00 <epony> and if you believe arm does not have the same quirks as x86..
01:44:00 <epony> try running wondows on arm and android on x86 and spot the differences
01:46:00 <clever> epony: now imagine a no-mmu kernel, that can defrag ram!
01:47:00 <epony> muh copy protection is better than yours (apple protests and starts hitting itself on the head in successive product releases)
01:47:00 <epony> the RAM defragmentation is called JVM or LLVM
01:48:00 <clever> epony: both palmos and the rpi firmware do it, they call it a relocatable heap, and its exposed at a c level api, not a bytecode
01:48:00 <epony> maybe because they have to dump it on eMMC fast without reordering there
01:48:00 <clever> nope
01:48:00 <epony> cause you know NAND flash is shoddy
01:49:00 <clever> on palmos, its bacause there is no mmu, and if you fragment the free space, you cant allocate large objects
01:49:00 <epony> ah, like the overlay depot of wisdom
01:50:00 <clever> its worse on palmos, because its a multi-app environment
01:50:00 <clever> the rpi is a single-app env, but has to deal with allocating contiguous 1080 frames
01:50:00 <epony> so.. like 80ies 8bit PCs hardware with 90ies 16bit PCs software
01:50:00 <clever> yeah
01:51:00 <epony> I knew it!!!
01:51:00 <epony> but the SoC are like 10-20x 8bit PCs really in functional blocks
01:52:00 <clever> on both palmos and the rpi firmware, the allocate function returns a handle
01:52:00 <epony> and has accelerators and power management and entire small OSes in the SoC
01:52:00 <clever> the lock function locks an object, and returns its current physical addr
01:52:00 <clever> the unlock function unlocks it, and you must not use the phys addr again, until you lock and get a new one
01:52:00 <epony> getting away from the premises of RISC's register-register operation is not fun
01:52:00 <clever> any unlocked object, is free to be moved by defragmentation
01:53:00 <clever> and an object can be locked multiple times, so you have some refcnts going on
01:53:00 <clever> on the rpi version, there are also flags when you unlock
01:53:00 <clever> so you can tell the system, the data doesnt matter, but keep the buffer reserved
01:54:00 <epony> https://en.wikipedia.org/wiki/Load-store_architecture
01:54:00 <clever> that makes defrag faster, it moves the allocation around, but doesnt bother with the memcpy()
01:54:00 <epony> mhm, fast ;-) tell that to Winders
01:55:00 <heat> ugh
01:56:00 <epony> https://en.wikipedia.org/wiki/Register-memory_architecture
01:56:00 <heat> can speculative accesses create tlb entries?
01:56:00 <geist> yes
01:56:00 <heat> thank mr geist
01:56:00 <heat> the people who wrote this don't know what they're doing :////
01:56:00 <geist> that's one of the fundamental reasons speculation based attacks exist: you can use speculation to get TLB or cache or branch prediction entries and then observe their creation
01:58:00 <epony> transient execution is/was not supposed to mean it's a transitional phase of 15 years of failures that will pass..
02:01:00 <heat> what's with people employed by x86 vendors and not knowing how to write MMU code
02:02:00 <epony> i/o is not immune from this either
02:05:00 <epony> https://en.wikipedia.org/wiki/IOMMU#Disadvantages
02:06:00 <clever> epony: firewire says hello, lol
02:06:00 <clever> who thought that was a good idea??
02:06:00 <epony> the people writing drivers
02:07:00 <epony> for its time it was an improvement, much like caches and lookup tables
02:07:00 <epony> how correct and reliable / fine grained that is implemented makes the difference
02:07:00 <epony> and arm has the same problems
02:08:00 <epony> they are not unique and the result of intentional bad designs, just need more precision and separation
02:09:00 <epony> https://en.wikipedia.org/wiki/Page_table#The_translation_process
02:19:00 <epony> there are some "generational" things that are better skipped than tried and cried, like 386/486 and HW-virtualisation-v1 the first 15 years of great speculation
02:20:00 <epony> eXpecially when it's advertised as a 'security concept' a'la (P|Q)ubes
02:21:00 <epony> and "enter-priCe" cloud services (*aaS)
02:23:00 <epony> "we delayed our containers to give virtualisation a chance" -LieUNIX
02:24:00 <epony> sparc whizzing around with ldoms and jvms for decades
02:36:00 <heat> https://github.com/tianocore/edk2/blob/master/MdeModulePkg/Core/DxeIplPeim/X64/VirtualMemory.c
02:36:00 <bslsk05> ​github.com: edk2/VirtualMemory.c at master · tianocore/edk2 · GitHub
02:36:00 <heat> this is a fucking trash fire
02:37:00 <heat> C bit fields, union type punning, setting present bits and then other *required* bits, duped code after duped code
02:38:00 <heat> this file is then copied to other places in edk2 where they fuck it up even harder
02:46:00 <epony> basic i/o systems are advanced now
02:46:00 <epony> have interpreters and compilers and "overlays"
02:47:00 <epony> and databases and tables for hw enumeration and addressing
06:06:00 <geist> hmm, i forget, was somewhere here talking about the Zig programming language?
06:08:00 <kof123> i thought the creator used to hang here back on freenode </not helpful or relevant>
06:08:00 <geist> yeah that's what i was thinking
06:08:00 <zid> Take off every zig programming language
06:11:00 <geist> ah andrewrk rings a bell
06:12:00 <geist> i say this because someone at work was chatting about hacking with zig over the holidays and falling somewhat in love with it, pointing out i'd probably dig it
06:34:00 <klys> anyone know how to shop for a psu with pmbus?
06:35:00 <zid> first I am hearing of it
06:35:00 <zid> my psu does all th pmbus stuff but just over usb instead
06:36:00 <klys> should feature an spi connector to the bmc for ipmi
06:36:00 <zid> oh wait, it does have pmbus
06:36:00 <klys> my most recent psu purchase is 1800w, though could use one with some access to stats
06:36:00 <zid> it has both
06:37:00 <zid> 1800w? geez
06:37:00 <klys> I have a 1800w ups also
06:37:00 <zid> wait maybe it'ss omething else, is pmbus 4 or 5 pin dupont
06:38:00 <klys> probably 4pin with three connected wires out of the four
06:38:00 <zid> https://images.anandtech.com/doci/9625/CRRMix_17.JPG left side under 'corsair link digital' logo
06:38:00 <zid> I use the usb instead because I have a gajillion internal usb ports free and no pmbus
06:42:00 <klys> i found that supermicro does pmbus, for their 1u proprietary removable rigs that do go up to 1800 or 2000, though i'd hate to be working with this dealy: https://www.ebay.com/itm/304120762970
06:42:00 <bslsk05> ​www.ebay.com: Supermicro PDB-PT216-2824 23-Pairs Power Distributor Assembly for SC216 Chassis | eBay
06:42:00 <zid> yea does't surprise me that anything saying supermicro on it has cool server features
06:52:00 <klys> right so best bet is corsair ax1600i i guess
06:55:00 <zid> where do the pmbus pins go, super i/o?
06:58:00 <klys> the white plug in the upper right of this pic: https://www.servethehome.com/gigabyte-mz72-hb0-review-dual-amd-epyc-motherboard-with-10gbe/gigabyte-mz72-hb0-aspeed-bmc/
06:58:00 <bslsk05> ​www.servethehome.com: Gigabyte MZ72 HB0 ASPEED BMC - ServeTheHome
06:59:00 <zid> ye, chip on the left is probably a graphics
06:59:00 <klys> that's actually the bmc
06:59:00 <zid> dunno what the lattice chip is
06:59:00 <zid> fpga!?
06:59:00 <klys> well i thought it was
07:00:00 <klys> lspci does list aspeed graphics yes
07:00:00 <zid> You're missing a chip near the piezo speaker, scammed
07:02:00 <klys> hmm, this board doesn't do well at realtime audio as per the benchmarks
07:02:00 <zid> My board's prosumer gaming nonsense so it has fancy optoisolated audio
07:02:00 <zid> with a red led in the isolation channel
07:03:00 <klys> the cpu however will compile a full-fledged linux in a bit under 3 minutes, however.
07:04:00 <zid> http://images.bit-tech.net/content_images/2014/05/asus-maximus-vii-hero-review/hero-1280x1024.jpg It looks a bit like this
07:04:00 <zid> does your gigabyte do that? I thought not.
07:05:00 <klys> supremefx?
07:05:00 <zid> asus's hda in a can as far as I know
07:17:00 <klys> yeah asus does a 2u dual socket epyc3 server, https://dlcdnets.asus.com/pub/ASUS/server/RS720A-E11/Datasheet/RS720A-E11-RS24U_DataSheet_Milan_X_20220321.pdf
07:20:00 <zid> graphic: aspeed AST2600
07:20:00 <zid> it's always aspeed
07:21:00 <klys> i gather the bmc is running a kernel of some sort, arm-style
07:22:00 <zid> I want a combined superio bmc and graphics chip
07:22:00 <zid> we could call it the southrbridge or something
08:37:00 <raggi> geist: you probably would, the stdlib is a bit weak, but the language is decent. the builtins/intrinsics are a bit slow, but i think the toolchain is quite nice to work with (I've not done that much fancy wiht it yet)
09:15:00 <heat> https://lwn.net/SubscriberLink/919683/848de8f727c17c43/
09:15:00 <bslsk05> ​lwn.net: Support for Intel's LASS [LWN.net]
09:15:00 <heat> this is legitimately cool
09:15:00 <heat> even if absolutely boring and obvious
09:16:00 <heat> tldr with lass the cpu never accesses kernel addresses from user mode and user addresses from kernel mode, even when speculating
09:16:00 <heat> page table permissions be damned
09:17:00 <heat> it just uses the top (sign) bit as the kernel vs user bit
09:18:00 <moon-child> is there anything keeping you from putting the kernel in positive space and userspace negative?
09:18:00 <heat> with lass or without?
09:18:00 <moon-child> with lass
09:18:00 <heat> yes
09:19:00 <heat> deets in https://cdrdv2.intel.com/v1/dl/getContent/671368, chapter 11
09:19:00 <heat> A user-mode data access causes a LASS violation if it would access a linear address of which bit 63 is 1. It is
09:19:00 <heat> expected that the operating system will configure paging so that any such address is a supervisor-mode address.
09:19:00 <heat> A supervisor-mode data access may cause a LASS violation if it would access a linear address of which bit 63 is 0.
09:19:00 <heat> It is expected that the operating system will configure paging so that any such address is a user-mode address.
09:19:00 <moon-child> :\
09:20:00 <heat> i assume this is just simpler to implement
09:20:00 <heat> also, why would you ever
09:21:00 <moon-child> negative addresses means that you can do nantagging and don't have to fix up the pointers before dereferencing
09:21:00 <moon-child> now, I will say that I don't really like nantagging
09:21:00 <moon-child> but
09:21:00 <heat> normal codegen is very little compatible with the negative space
09:22:00 <heat> -2GB is a nasty hack
09:22:00 <moon-child> huh? How so?
09:22:00 <moon-child> why would it care?
09:22:00 <heat> -mcmodel!=kernel will break on -2GB
09:22:00 <heat> or any part of the address space for that matter
09:22:00 <heat> although I think PIC/PIE still work
09:23:00 <heat> normal toolchain tooling also breaks
09:23:00 <moon-child> good enough. Stuff is moving to pic-by-default anyway
09:23:00 <heat> ubsan for instance thinks any pointer op overflows
09:24:00 <moon-child> I mean not surprised if some stupid stuff depends on it. But doesn't seem like it should be that hard to fix. And addresses can still fit in 32 bits eg
09:24:00 <heat> yes but 1) why 2) stop
09:24:00 <heat> do you need more compelling arguments?
09:24:00 <heat> 3) intel is going to break your stupid setup in the future
09:24:00 <heat> 4) if that didn't move you, move to itanium or something
09:25:00 <heat> if mjg doesn't get it killed in the kernel in the meanwhile
09:25:00 <heat> mjg the murderer of the best architecture ever
09:25:00 <moon-child> :<
09:25:00 <moon-child> how could he
09:26:00 <heat> he, torvalds, tony luck and ardb are conspiring against the best thing to ever come out of intel
09:27:00 <heat> and the great venerable users of ia64, debian and gentoo CI
09:27:00 <moon-child> yeah I saw the thing
09:27:00 <heat> they've killed the second greatest debian feature before (GNU/kFreeBSD), don't let them take the best
09:28:00 <heat> the deep state also killed intel mpx before
09:28:00 <heat> those monsters
09:29:00 <heat> and the intel upgrade service
09:29:00 <heat> this is an amd-and-arm-consortium-led conspiracy I tell you
09:30:00 <heat> instead of removing ia64 they should remove intel 64 and ia-32e and x64
09:49:00 <zid> seems fairly defeatable though?
09:49:00 <zid> the lass thing
09:49:00 <zid> hmm maybe not
09:49:00 <zid> my idea was dumb
10:01:00 <mjg> so i spawned perf to p-g on my laptop
10:01:00 <mjg> top -g
10:01:00 <mjg> about 11% user and 3 % sys time
10:02:00 <mjg> who can guess what's the top of the profile
10:03:00 <geist> heat: re that LASS thing, i think ARM has something specific in one of the v8.x features
10:03:00 <mjg> it was perf itself, accounting for 8 percentage points of user time
10:03:00 <geist> something that basically lets you set a hard rule that stuff in TTBR1_x is not visible from user and hard stop here, before allowing anything to speculate
10:03:00 <geist> iirc it's a bit in TCR
10:04:00 <geist> s/specific/similar
10:07:00 <mjg> heat i 'm going to ask intel to donate itanium support to openbsd
10:08:00 <mjg> that should sort it out
10:19:00 <heat> geist, do you know what that mitigates against, exactly?
10:19:00 <heat> intel hasn't said yet
10:19:00 <heat> mjg, that sounds good to me
10:20:00 <heat> seriously, while I understand no one wants to maintain ia64 because it's silly and stupid, it's a venerable architecture that is silly and positively stupid
10:22:00 <Mutabah> heat: completely eliminates meltdown
10:22:00 <heat> meltdown yes, but the other ones?
10:23:00 <heat> "LASS seemed really cool when we were reeling from Meltdown. It would *obviously* have been a godsend five years ago. But, it's less clear what role it plays today and how important it is."
10:41:00 <epony> I like the transient execution faults that let you listen to the radio while reading other processes tokens and executing instructions on their return vectors they did not expect, do not know about and never find out what happened (or get the execution vector again, after they've been executed)
10:42:00 <epony> Intel would likely tell you that it donated support for OpenBSD in Windows.
10:42:00 <epony> and that Itanium was made for HP and it ran for 20 years there without you having access
10:43:00 <epony> so, not for you ;-)
10:45:00 <zid> gog: https://pbs.twimg.com/media/FmZ9jf3acAAopef.jpg
10:46:00 <gog> me
10:49:00 <zid> til that gog
10:49:00 <heat> gog
10:50:00 <heat> gog go go gogo gog gog
10:50:00 <gog> heat heat heat
10:50:00 <gog> bazel
10:51:00 <heat> 🅱️🅱️🅱️🅱️🅱️🅱️🅱️
10:51:00 <heat> decipher this
10:54:00 <gog> bazinga
10:55:00 <heat> you have deciphered my military grade encryption scheme
10:55:00 <heat> i must warn the NSA
10:57:00 <gog> it's cool they already know about me
11:00:00 <epony> but not only they know
11:02:00 <epony> the Chinese authorities, most of the American controlled international drug cartels and the thought police know too
11:13:00 <ddevault> hrm
11:14:00 <ddevault> if I set DAIF to 0b1111, why am I still getting IRQs from EL1 => EL1
11:22:00 <clever> ddevault: are you trying to service IRQ's in EL0?
11:22:00 <ddevault> yeah
11:23:00 <clever> i wasnt aware that was even an option, but the armv8 docs do imply it is
11:23:00 <ddevault> err, no
11:23:00 <ddevault> I want to service IRQs in EL1, but only while in EL0
11:23:00 <ddevault> I don't want interrupts from EL1 => EL1
11:23:00 <clever> ah
11:23:00 <clever> so you basically dont want pre-emption of any kind while in kernel mode
11:23:00 <ddevault> yeah
11:23:00 <ddevault> except for kernel faults, which just panic
11:24:00 <clever> and faults wouldnt respect the I bit
11:24:00 <ddevault> right
11:24:00 <ddevault> I have a lead, let me tug on it a bit and get back to you
11:24:00 <clever> i would think, just use the I bit to mask interrupts in the EL1 version of the reg, but in the saved reg that eret restores, have them unmasked
11:25:00 <clever> so whenever you eret back to EL0, irq's get unmasked, and it may go back to EL1 immediately
11:26:00 <ddevault> so the issue is that I was writing to the wrong bits of DAIF
11:27:00 <ddevault> adding a shift stops the interrupts from happening in EL1
11:27:00 <ddevault> but... also breaks syscalls after jumping to EL0. But SPSR_EL1 is 0
11:28:00 <ddevault> oh, no, I'm dumb
11:28:00 <ddevault> it didn't break syscalls
11:28:00 <ddevault> it just caused interrupts to fire in EL0
11:29:00 <ddevault> which goes to my as-of-yet unwritten infinite loop of an IRQ handler
11:29:00 <clever> ah, so it worked as intended?
11:29:00 <ddevault> yep
11:30:00 <clever> just recently, i got nerd-sniped into some GBA coding, ARM7TDMI, even older and more crippled then the armv6 from the rpi1, lol
11:30:00 <clever> it doesnt even have a VBAR, so irq's always go thru the "bios" rom
11:31:00 <clever> but after a bunch of messing around, i was able to get vsync irq's working
11:32:00 <clever> had to enable irq's at 4 different layers
11:32:00 <clever> hmmm, i assume this has a user vs kernel mode...
11:33:00 <clever> yeah, it does
11:58:00 <ddevault> bizzare, ELR_EL1 is always my userspace entry point regardless of when the interrupt occurs
11:58:00 <ddevault> ah, now it's not, but...
11:59:00 <ddevault> when gdb is attached
11:59:00 <ddevault> timer weridness?
11:59:00 <ddevault> no clue where IRQ 33 comes from
12:00:00 <ddevault> what kind of manual includes things like this https://l.sr.ht/szYL.png
12:03:00 <j`ey> i think irq33 is the timer..
12:03:00 <ddevault> https://l.sr.ht/HXq9.png
12:04:00 <ddevault> is 27
12:04:00 <ddevault> maybe I'm EOI'ing wrong
12:04:00 <ddevault> I get 27 if the timer is enabled, 33 if not
12:04:00 <j`ey> oh ok, I knew it was in a similar range
12:05:00 <ddevault> I read IAR from GICC, & 0x3FF to mask out reserved bits
12:05:00 <ddevault> then write that number to GICC_EOIR
12:05:00 <ddevault> which are respectively defined as 0x000C and 0x0010
12:06:00 <clever> i believe its up to the implementor of the chip, to assign those numbers
12:06:00 <clever> so you would need to find the docs for the soc your running on
12:06:00 <ddevault> qemu virt
12:07:00 <clever> ah, then you can either read the source for qemu, or just parse the DT it gives you
12:07:00 * clever looks
12:09:00 <ddevault> but yeah, it looks like the actual interrupts vary
12:09:00 <ddevault> what's interesting is
12:09:00 <ddevault> the device tree shows it as IRQ 1 (i.e. IAR == 0x33)
12:09:00 <ddevault> which fires if I don't enable the timer via CNTV_CTL_EL0
12:09:00 <ddevault> but if I do enable the timer, I get interrupt 27 instead
12:10:00 <ddevault> i.e. IAR == 27
12:10:00 <ddevault> maybe I'm getting both but 27 is a higher priority and I am not EOI'ing it properly
12:10:00 <clever> https://github.com/qemu/qemu/blob/master/hw/arm/virt.c#L363-L368
12:10:00 <bslsk05> ​github.com: qemu/virt.c at master · qemu/qemu · GitHub
12:10:00 <clever> ddevault: this generates the DTB for the timers, and fills in 4 irq numbers
12:10:00 <ddevault> ack
12:10:00 <ddevault> I have the qemu dts in front of me
12:11:00 <ddevault> in any case I don't really care which IRQs are firing
12:11:00 <ddevault> what I want to know is why I can't ack them properly and get userspace back online
12:11:00 <clever> https://github.com/qemu/qemu/blob/master/include/hw/arm/virt.h#L48-L51
12:11:00 <bslsk05> ​github.com: qemu/virt.h at master · qemu/qemu · GitHub
12:11:00 <clever> the header says the timers are irq 11, 13, 14, and 10
12:12:00 <ddevault> the non-secure IRQs, yeah
12:12:00 <ddevault> https://www.kernel.org/doc/Documentation/devicetree/bindings/arm/arch_timer.txt
12:13:00 <clever> secure el1 is 13, according to these names
12:13:00 <clever> ah, and that example dts exactly matches what qemu appears to be using
12:14:00 <ddevault> figured out 27
12:14:00 <clever> ddevault: some interrupts are also level triggered, so until you clear the cause (like resetting a timer), it wont stop
12:15:00 <ddevault> I need to reset TVAL or else it'll just continuously fire
12:15:00 <clever> what was 27?
12:15:00 <ddevault> that causes 27 to fire at 100 Hz, the desired behavior
12:15:00 <clever> ah, so my last hint was spot on!
12:15:00 <ddevault> but now I have to figure out 33
12:15:00 <clever> ah, close
12:15:00 <ddevault> yeah, good call :)
12:15:00 <ddevault> 33 is the timer from the dts
12:15:00 <ddevault> so... how do I shut that idiot off
12:15:00 <clever> ive run into similar problems before, the timer compare reg defaulted to 0, and i had the irq unmasked
12:16:00 <clever> after ~70 minutes, the 32bit timer reg overflowed, rolled back to 0, and fired an irq
12:16:00 <clever> hard to debug a weird fault, when it only faults after 70 minutes of uptime!
12:16:00 <ddevault> I bet
12:16:00 <clever> ideally, you should mask every irq your not prepared to deal with
12:16:00 <clever> thats a bug i found in linux on the rpi, it assumes irq's are already masked off
12:16:00 <ddevault> yeah
12:17:00 <clever> and the instant it enables irqs, it gets stuck in an infinite loop
12:17:00 <clever> with an event it cant clear
12:17:00 <clever> so my bootloader has to go thru, and mask off every irq, before passing control on
12:18:00 <ddevault> masking the IRQ is Good Enough for now
12:30:00 <ddevault> ayy https://l.sr.ht/4AdJ.png
12:32:00 <clever> ddevault: https://youtu.be/_j2L6nkO8MQ?t=1061 hellord is better! :D
12:32:00 <bslsk05> ​'Minicomputer Part 11: Running Real Centurion Code off the DIAG Card!' by Usagi Electric (00:24:28)
12:32:00 <ddevault> hah
12:34:00 <ddevault> now the annoying part, does it work on hardware
12:36:00 <ddevault> works on real hardware :D :D :D
12:36:00 <clever> :D
12:38:00 <ddevault> praise be to qemu
12:38:00 <epony> and Prometheus
12:40:00 <epony> https://www.youtube.com/watch?v=mbj1RFaoyLk
12:40:00 <bslsk05> ​'The Doors - Light My Fire' by TheDoorsVEVO (00:09:23)
12:43:00 <heat> yoooooo the arm people are here today
12:43:00 <heat> can't believe it
12:43:00 <heat> i though this was a riscv channel now
12:43:00 <heat> thought*
12:44:00 <heat> you'll see, when I work for sifive i'll make the meanest pentium 4 you'll ever see
12:45:00 <heat> you'll tremble with your cortex
12:45:00 <ddevault> I object to being called arm people
12:46:00 <ddevault> in 2 weeks my relationship with arm will be put on hold and I'll be back to x86_64
12:46:00 <ddevault> just a little fling, you see
12:46:00 <heat> does arms people work or do I need to mention your legs and core too
12:46:00 <ddevault> don't forget my fingers
12:47:00 <heat> i lost my fingers writing C
12:47:00 <heat> now I got little boot stubs
12:51:00 <epony> that's good enough for Python
12:52:00 <ddevault> need to rework this so that the yield syscall works properly
12:52:00 <ddevault> then I think I can fire up my kernel test suite and see how much of it works
12:53:00 <ddevault> then implement fault handlers and I think that the aarch64 port is complete, pending polish
12:53:00 <ddevault> oh I guess I still need to set up device memory capabilities and generalize IRQs
12:54:00 <ddevault> can cheese that for the demo though
14:15:00 <kaichiuchi> hi
14:30:00 <ddevault> wow https://l.sr.ht/9OrB.png
14:30:00 <ddevault> that was easy
14:55:00 <ddevault> + the skipped test https://l.sr.ht/NbBj.png
14:56:00 <ddevault> 41 days from zero to all tests passing on aarch64 :)
15:03:00 <clever> ddevault: nice
15:23:00 <mjg> heat: you you srs abut itanium
15:23:00 <mjg> no matter how good or bad an arch is, there is a time where it needs to be let go
15:23:00 <mjg> maintenance burden is a real thing
15:55:00 <zid> mjg: itanium has no maintainacen burden
15:55:00 <zid> only maint ecxtascy
15:58:00 <mjg> of all the things you can be high on
15:58:00 <mjg> itanium?
15:58:00 <mjg> ULTRASPARC MOTHERFUCKER
15:59:00 <mjg> ddevault: oh i missed your message above, nice work man, provided the tests actually owrk :p
16:02:00 <zid> alpha
16:02:00 <zid> who needs memory ordering when you have an lapah
16:02:00 <zid> ddevault: what was your fucky wucky bug in the end?
16:03:00 <mjg> alpha is too mainstream
18:47:00 <heat> mjg, i know it needs to be let go but like, sadge :((
18:48:00 <mjg> if you want to larp an arbitrary era from the past get netbsd
18:52:00 * geist yawns
18:54:00 <mjg> 'unsigned' is just int, innit?
18:54:00 <gog> yeh
19:05:00 <Ermine> unsigned innit
19:21:00 <sham1> typedef int innit
19:23:00 <mjg> #define itanium deadanium
19:23:00 <mjg> also known as itanic, heat
19:39:00 <heat> geist, he's making fun of our architecture
19:39:00 <heat> ban pls
19:40:00 <geist> :(
19:43:00 <heat> i've heard fuchsia only supports 64-bit architectures
19:44:00 <heat> turns out you've only been supporting 48-bit architectures these past few years
19:48:00 <geist> eeeyo!
19:49:00 <geist> or more specifically 49 bits and 48, arm and x86 respectively
19:49:00 <mjg> "our"?
19:49:00 <mjg> you are into itanium geist?
19:49:00 <geist> well, i'm into it as much as i'm into sparc or alpha or pa-risc or whatnot. neat things, used to even own one, but obviously not relevant to modern stuff
19:50:00 <mjg> whoa
19:50:00 <geist> itanium is a smorgasbord of crazy ideas that's fun to know about
19:50:00 <mjg> that i agree with, i had a glimpse
19:50:00 <mjg> in a way i'm happy it did not pan out tho :p
19:51:00 <mjg> cpus are pretty wonky perf-wise as is
19:51:00 <mjg> you never know what will set them off
19:52:00 <heat> "cpus are wonky, so make them pretend they're still a glorified 8086 so they run a PDP-11 programming language well"
19:52:00 <Ermine> where did I read this
19:52:00 <mjg> geist, he's making of our language
19:52:00 <mjg> ban pls
19:53:00 <mjg> fun*
19:53:00 * geist bans all of you
19:53:00 <heat> fun pls?
19:53:00 * mjg goes to discord
19:53:00 <mjg> i bet they have scalable kernels and hookers
19:54:00 <heat> only if you're in the illumos discord
19:54:00 <mjg> that fucking system
19:54:00 <mjg> fuck
19:54:00 <mjg> one of these days i'm going to do a long writeup why it does NOT scale
19:54:00 <geist> oh really? i
19:54:00 <mjg> on era-appropriate hardware
19:54:00 <geist> i've totally not heard of this before
19:54:00 <geist> you mean solaris, not scaling? wow!
19:54:00 <mjg> :]
19:55:00 <mjg> once i do it i'll only have to link
19:55:00 <geist> i bet you'll even get 10s of clicks too!
19:55:00 <mjg> i'll send it to tuhs man
19:55:00 <geist> hackaday will link it and then you'll get a wall of comments: 'lulz what is solaris?'
19:55:00 <mjg> SOLARIS CRATE
19:56:00 <heat> SOLARIS CRATE RUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUST
19:56:00 <mjg> maybe that will clickbait as rust is the hotness
19:56:00 <heat> BONWICK ZFS
19:56:00 <heat> zfs save-my-neglected-marriage
19:56:00 <theWeaver> lol i remebmber one time i did a wargaming challenge on a vm running an old version of solaris, and you could root it via LD_PRELOAD env var when executing setuid binaries
19:56:00 <theWeaver> most easiest root i ever did do
19:56:00 <mjg> theWeaver: oh ye they had a few of those
19:57:00 <mjg> but so did the gnu land, so....
19:57:00 <theWeaver> mjg: lol for real?
19:57:00 <mjg> yea
19:57:00 <geist> oh huh never occurred to me that you could LD_PRELOAD a setuid. makes totally sense
19:57:00 <mjg> one of these was partially courtesy of /proc
19:57:00 <heat> mjg, fyi netbsd doesn't really support ia64
19:57:00 <geist> obviously i guess it has to ignore LD_PRELOAD in that case?
19:57:00 <theWeaver> i only ever encountered that on solaris
19:57:00 <theWeaver> geist: i guess
19:57:00 <heat> geist, yes, you should ignore a bunch of env vars on AT_SECURE = 1
19:57:00 <mjg> theWeaver: oh sorry, it was not LD_PREALOD specifically, but a different LD_ var
19:57:00 <theWeaver> mjg: ah okay
19:57:00 <mjg> theWeaver: the loader would check if the dir pointed to it is owned by root and if so it would trust the content
19:57:00 <heat> glibc also ignores a bunch of things regarding their plugin system(s)
19:57:00 <theWeaver> yeah the solaris one i came across was literally LD_PRELOAD
19:58:00 <mjg> theWeaver: the problem is /proc/self/fd will be owned by root for root setuid, so they got fucked
19:58:00 <theWeaver> mjg: :o
19:58:00 <geist> i think the real problem was setuid, though i guess it simply solves a whole pile of problems
19:58:00 <theWeaver> hahhaa
19:58:00 <theWeaver> nice
19:58:00 <geist> (and adds a bunch of new ones)
19:58:00 <mjg> the real problem is need for setuid
19:58:00 <geist> right
19:58:00 <mjg> this does not have to exist today
19:59:00 <mjg> with allmighty init you could literally talk to init to change your password 'n shit
19:59:00 <theWeaver> mjg: so how do we deal with it, do admin shit with services that were already running as root?
19:59:00 <heat> i don't have a better alternative
19:59:00 <heat> doing creds over unix sockets? weird
19:59:00 <theWeaver> heat: how else u gonna play tho
19:59:00 <heat> and then a program ran under sudo would not be under its parent, etc
19:59:00 * mjg laughs in ptrace
20:00:00 <mjg> to solaris credit, that's the one unix which implements ptrace without reparenting the tracee
20:00:00 <geist> yah fuchsia side steps all of this stuff by just going in a completely different direction
20:00:00 <mjg> that i know of anyway
20:00:00 <geist> that probably has a completely different set of unknown unknowns
20:00:00 <heat> mjg, linux ptrace reparents?
20:01:00 <theWeaver> geist: fuchsia, is that the weird google shit?
20:01:00 <geist> indeed.
20:01:00 <heat> lol
20:01:00 <Griwes> lmao
20:01:00 <theWeaver> i think i heard rumours about it
20:01:00 <geist> pretty good summary heh
20:02:00 <mjg> heat: yea
20:02:00 <mjg> heat: this is why you even get ->real_parent in struct task
20:02:00 <mjg> fucking ptrace is part of why task management on linux does not scale
20:03:00 <heat> mjg, no? I think real_parent is for thread groups
20:03:00 <Ermine> I'm not a fan of Google, but I want Fuchsia to succeed
20:03:00 <theWeaver> i used to work with some google peeps
20:03:00 <theWeaver> and went to visit them at the london google office at tottenham court road or something
20:04:00 <theWeaver> apparently they have masseurs/masseuses in the office building
20:04:00 <theWeaver> where you can spend massage points
20:04:00 <theWeaver> if you do good work enough to earn said points
20:04:00 <theWeaver> good enough*
20:04:00 <heat> seems like they have 3 offices in london :P
20:04:00 <Ermine> GGG
20:05:00 <geist> theWeaver: this is all true, though you generally earn massage points by a simple passage of time
20:05:00 <heat> geist, time to ask why the seattle office doesn't have massages
20:05:00 <heat> the real uncomfortable questions
20:05:00 <geist> because the seattle office is somewhat scrappier
20:05:00 <theWeaver> geist: i also had coffee there
20:05:00 <theWeaver> made by one of the in-office paid baristas
20:05:00 <geist> the london office near kings cross station is really nice
20:05:00 <theWeaver> i was like wuuuut
20:05:00 <theWeaver> y'all even have fuckin baristas
20:05:00 <geist> we do
20:05:00 <theWeaver> geist: oh yeah so thi sone chick was also mega proud of the snack matrix
20:06:00 <theWeaver> a four by four matrix of draws
20:06:00 <geist> <- works at google, and also on fuchsia just to come clean
20:06:00 <theWeaver> with two types of snack per drawer
20:06:00 <theWeaver> geist: yeah i know where you work
20:06:00 <mjg> heat: no
20:06:00 <geist> okay, just making sure
20:06:00 <theWeaver> i also know you work on fuchsia
20:06:00 <theWeaver> geist: lets just say a lil kitty told me
20:06:00 <heat> so that weird google shit was just a potshot?
20:06:00 <geist> no that's fine, i just dont recognize your nick, so as far as i know you just popped in today 5 minutes ago
20:07:00 <theWeaver> geist: reasonable
20:07:00 <theWeaver> heat: indeed
20:07:00 <heat> mjg, have you seen that weird freebsd shit
20:07:00 <geist> it is indeed weird google shit, i will not deny that
20:07:00 <heat> they're all nuts!
20:07:00 <theWeaver> geist: i was majorly against google when i had to work with some of your people in my previous job
20:07:00 <theWeaver> but liiiiiike
20:08:00 <theWeaver> this was all google adds/google smart shopping/shopping ads on google/whatever crap
20:08:00 <theWeaver> and im very against all of this
20:08:00 <heat> esp. this guy "mjg" that likes going on and on and on about optimization and performance and pessimal sync primitives
20:08:00 <mjg> which one
20:09:00 <theWeaver> mjg: you, mofo
20:09:00 <mjg> OH
20:09:00 <geist> theWeaver: fair. yeah. i've worked at google for 11 years but never touched any part of that business
20:09:00 <heat> no? why would it be mjg
20:09:00 <mjg> the keyboard mofo
20:09:00 <mjg> heat: which weird shit in freebsd, motherfucker
20:10:00 <mjg> cause i can name some LSD products no problem
20:10:00 <heat> why don't you join gnuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuu slash linux
20:10:00 <theWeaver> geist: the funny thing was like before i started my first industry job i was like 'i dont wanna work for facebook, or FAANG, or do any *ads* shit' and then i join a small german ecommmerce company, and once i start i discover our first project was to integrate 'google smart shopping' into our backend
20:10:00 <mjg> you can't escape fangs
20:10:00 <theWeaver> and spent a year working on tihs bullshit and having weekly calls with google reps
20:11:00 <theWeaver> mjg: apparently not
20:13:00 <heat> i fail to understand how some/most #osdev'ers don't work in low level land
20:15:00 <theWeaver> heat: im only here cuz one of my gfs and some friends of mine hang out here, and when i was like 13 i wrote some C/ASM code for x86 machines that could boot off a floppy and set up memory mapping tables/long jump from 16bit to 32bit execution mode
20:15:00 <theWeaver> i am not really much of an osdevver, truth be told
20:15:00 <theWeaver> rn i work with Python in a team consisting mostly of machine learning peeps
20:17:00 <mjg> oh no
20:17:00 <theWeaver> mjg: indeed
20:17:00 <mjg> do you think they have people like this on discord?
20:17:00 <mjg> i think not!
20:18:00 <theWeaver> mjg: they probably do tho
20:18:00 <mjg> no man, discord is so much better
20:18:00 <mjg> trust me, i'm a guy on irc
20:18:00 <theWeaver> hey, i aint your man, buddy
20:18:00 <heat> discord people are either 12 year olds or geist
20:18:00 <theWeaver> i am in fact a female weaver
20:18:00 <heat> literally
20:18:00 <mjg> not my man or man ing eneral
20:18:00 <Ermine> heat: this requires actuall skills
20:18:00 <mjg> theWeaver: mild apologies
20:19:00 <heat> Ermine, what does?
20:19:00 <theWeaver> i prefer sincere ones but i'll take it
20:19:00 <mjg> theWeaver: i already handed off those ones earlier today
20:19:00 <Ermine> heat: working in low level land (esp. OSes)
20:19:00 <theWeaver> mjg: oic
20:19:00 <mjg> bad timing
20:19:00 <theWeaver> well, I'll live
20:20:00 <mjg> theWeaver: serious question though
20:20:00 <theWeaver> yeah?
20:20:00 <heat> Ermine, the other work also does?
20:20:00 <mjg> theWeaver: do you consider 'dawg', however informal it might be, to be male-only?
20:20:00 <theWeaver> i mean thats a tricky one
20:20:00 <heat> obviously you need to say 'dawgess'
20:20:00 <Ermine> heat: much less of it I think
20:20:00 <heat> Ermine, hard disagree
20:20:00 <theWeaver> but as someone who is annoyed by the catgirl tropes and strongly identifies as not-a-cat
20:20:00 <theWeaver> i think i can handle just being 'dawg'
20:21:00 <Ermine> Doing websites is easier
20:21:00 <mjg> i'm looking for an informal way to address someone
20:21:00 <mjg> which is gender-neutral
20:21:00 <heat> mjg, comrade
20:21:00 <theWeaver> mjg: pal
20:21:00 <theWeaver> buddy
20:21:00 <GeDaMo> Hey, you :P
20:21:00 <theWeaver> fren
20:21:00 <mjg> lad
20:21:00 <Ermine> Shitposting in #osdev is much more easier
20:21:00 <heat> also goes well with the eastern europe
20:21:00 <theWeaver> mjg: no lad is very much gendered
20:21:00 <theWeaver> no,
20:21:00 <mjg> pal is not?
20:21:00 <theWeaver> pal is not gendered
20:21:00 <mjg> i thought that's literally 'guy'
20:21:00 <theWeaver> a pal is merely a friend
20:21:00 <theWeaver> nope
20:21:00 <heat> pal is gendered
20:21:00 <theWeaver> heat: not it fuckin isn't
20:22:00 <heat> as much as dude is
20:22:00 <heat> absolutely
20:22:00 <Ermine> is ntsc gendered
20:22:00 <theWeaver> dude is very much gendered
20:22:00 <theWeaver> pal isn't
20:22:00 <heat> dude is not gendered
20:22:00 <theWeaver> definition of pal is simply: a friend
20:22:00 <heat> well, its only gendered if you want to
20:22:00 <theWeaver> definition of dude is: a man; a guy
20:22:00 <GeDaMo> «Borrowed from Angloromani pal (“brother, friend”), from Romani phral (“brother”), from Sanskrit भ्रातृ (bhrātṛ, “brother”).» https://en.wiktionary.org/wiki/pal
20:22:00 <bslsk05> ​en.wiktionary.org: pal - Wiktionary
20:23:00 <mjg> how about an irc acquiantance
20:23:00 <theWeaver> GeDaMo: aaaaaaaaaaah god damn it really
20:23:00 <mjg> what word would that be
20:23:00 <heat> fuckface
20:23:00 <theWeaver> why can there not be ungendered friend words
20:23:00 <GeDaMo> I also thought it wasn't gendered
20:23:00 <mjg> friendess
20:23:00 <theWeaver> ffs
20:23:00 <mjg> theWeaver: are you from an english speaking country?
20:23:00 <theWeaver> mjg: yea
20:23:00 <theWeaver> i grew up in england
20:23:00 <GeDaMo> You could always just use «friend» :P
20:24:00 <theWeaver> GeDaMo: i guess so yeah
20:24:00 <theWeaver> im just kinda bummed that pal isn't as gender neutral as i thought
20:24:00 <GeDaMo> 'friend' is how some robots in Asimov's stories refer to each other
20:24:00 <mjg> i identify as a pal
20:24:00 <heat> pal is also new-york-gendered
20:24:00 <theWeaver> heat: lmao
20:24:00 <heat> how to sound like an italian guy in new york 101
20:25:00 <theWeaver> lol
20:25:00 <geist> i'd say pal is probably as gendered as buddy
20:25:00 <mjg> how to sound like a non-italian guy in new york: quote italian mobsters from sopranos
20:26:00 <geist> which is to say slightly gendered, but mostly because it's a thing you expect guys to say to each other
20:26:00 <heat> what's the texas "pal"?
20:27:00 <heat> brooooooooother?
20:27:00 <theWeaver> geist: i also didn't really see buddy as very gendered
20:27:00 <mjg> can texans even hear words over all the gunshots?
20:27:00 <mjg> perhaps i should stick with "hello friends"
20:27:00 <heat> i told you, comrades
20:27:00 <theWeaver> i mean i usually use 'folks'
20:27:00 <geist> well there's the obvious 'yall' but that's different context
20:27:00 <heat> suits your eastern europeanness just fine
20:27:00 <GeDaMo> Hello, UTF-8 generators :P
20:27:00 <geist> yah folks probably
20:27:00 <theWeaver> but 'comrades' is pretty gender neutral too
20:28:00 <theWeaver> geist: yea i use 'yall' a fair bit as well
20:28:00 <Ermine> heat: what does suit eastern europeanness
20:28:00 <geist> somewhat gendered but thing i heard a lot in TX: 'hoss'
20:28:00 <heat> comrades
20:28:00 <theWeaver> at my work in my team peopl eoften say 'guys' to refer to the team which annoys me and three of us are women, and even tho many people say 'guys' is gender neutral i fkn hate it
20:29:00 * Ermine now has soviet march playing in head
20:29:00 <geist> yah guys is so easy but i'm really trying hard to not use it at work. i am successful like 90% of the time
20:29:00 <theWeaver> Ermine: my ancestors are from soviet lands
20:29:00 <theWeaver> or half of them are at least
20:29:00 <heat> last diversity training I've went to suggested 'yall' as an alternative
20:29:00 <heat> i am NOT saying yall
20:29:00 <heat> NO
20:29:00 <heat> absolutely fucking no way
20:30:00 <theWeaver> heat: too redneck for ya?
20:30:00 <geist> aww why not? yall is nice
20:30:00 <mjg> a'int that somethin
20:30:00 <heat> i'm too european for yalllllllll
20:30:00 <geist> look go back to middle english and bitch at those folks for removing a good second person plura
20:30:00 <mjg> theWeaver: heat *is* a european redneck
20:30:00 <Ermine> theWeaver: my all ancestors are all from there
20:30:00 <geist> thou, thine, etc
20:30:00 <theWeaver> Ermine: nice
20:31:00 <theWeaver> mjg: european... redneck?
20:31:00 * theWeaver does the calculations
20:31:00 <Ermine> idk whether I agree
20:31:00 <mjg> theWeaver: the equivalent
20:31:00 <mjg> but perhaps that's another mismatch in uderstadning the term
20:31:00 <heat> mjg, european redneck is literally poland
20:31:00 <mjg> heat: that is redneck central
20:31:00 <theWeaver> poland is pretty redneck yeah
20:31:00 <theWeaver> that makes sense
20:32:00 <theWeaver> next one is probalby uk
20:32:00 <mjg> if you consider russia as not present in europe
20:32:00 <heat> russia got cancelled from europe
20:32:00 <theWeaver> mjg: i think that ship has sailed
20:32:00 * mjg squats
20:32:00 <mjg> lemme find the video
20:32:00 <heat> adidas tracksuit?
20:33:00 <geist> okay, come on now
20:33:00 <Ermine> heat: :<
20:33:00 <mjg> https://www.youtube.com/watch?v=VLW1ieY4Izw
20:33:00 <bslsk05> ​'XS Project - Bochka, Bass, Kolbaser [Bass Boosted] (Russian Special)' by Manne Bass (00:03:05)
20:33:00 * geist tries to gently steer things back towards nice place
20:33:00 <theWeaver> bslsk05: HELL YEAH
20:33:00 <heat> bslsk05, bslsk
20:34:00 <heat> geist, is dang ol' really that common or is it just king of the hill
20:34:00 <mjg> ok, want something technical, i need a good name for a variable
20:34:00 <mjg> 100% serious
20:34:00 <geist> dang is. dang ol is not unheard of but most of that is very specifically a Daleism
20:34:00 <heat> mjg, variable for what?
20:35:00 <mjg> access() checks a bunch of stuff to find out if it needs to create new creds for the call
20:35:00 <theWeaver> mjg: fuckin tune
20:35:00 <mjg> but this can be pre-computed
20:35:00 <geist> dang is just a nicer version of damn really. like darn
20:35:00 <mjg> the q is how to name the precomputed var
20:35:00 <heat> both of those are southisms aren't they?
20:35:00 <mjg> vfs_access_need_new_cred does not really work, does it
20:35:00 <geist> well name it what it is
20:35:00 <heat> generic new york italians don't say darn
20:36:00 <mjg> geist: that result in a name so long it spans another repo
20:36:00 <heat> mjg, need_new_cred
20:36:00 <mjg> heat: but this is conditional on EACCESS being passed
20:36:00 <heat> whatevs
20:36:00 <mjg> aka vfs_need_new_cred_if_not_eaccess
20:36:00 <geist> i think some of that is because there's an undercurrent of politeness int he south, so in general you try to avoid curse words in general
20:36:00 <mjg> which i'm not rolling with
20:36:00 <Ermine> mjg: if you drink Jaguar you'll dance like this
20:36:00 <geist> so there's usually a whole pile of non curse word equivalents
20:36:00 <mjg> Ermine: i dance like this sober
20:37:00 <mjg> geist: bless your heart!
20:37:00 <heat> mjg, ncred, nc
20:37:00 <mjg> i hear that's like the worst insult you can get
20:37:00 <geist> exactly, though you can argue that's a midwestern thing too
20:37:00 <heat> nnc
20:37:00 <heat> all very BSD names here
20:37:00 <geist> heat: oh reminds me i think you were complaining about const arguments to functions. i've started to do that some too
20:37:00 <mjg> if the syscall was named differently at least therw ould not be this clash
20:37:00 <mjg> geist: complain or add const :)
20:37:00 <geist> though generally only in c++. it's a googleism that's slipping into my own code
20:38:00 <heat> geist, whyyyy
20:38:00 <geist> same as a const local variable
20:38:00 <theWeaver> geist: those google bastards
20:38:00 <geist> if you're not modifying it, mark it as const
20:38:00 <heat> it's way more unreadable and also "WHO CARES"
20:38:00 <heat> the caller doesn't. so why is it cluttering the argument list
20:38:00 <geist> you dont need it in the prototype, i only put it in the local
20:39:00 <heat> you don't?
20:39:00 <heat> is that entirely defined?
20:39:00 <geist> yah it doesn't leak out to the prototype
20:39:00 <geist> good question, but i suspect it is
20:39:00 <heat> that sounds saner but still, meh
20:39:00 <geist> what i dont precisely know is if it's well defined in C or if that's a C++ism that leaks over
20:40:00 <heat> i'm not really const-strict when it comes to local vars and whatnot
20:40:00 <geist> but yeah i dont like how it pollutes the arg list locally
20:40:00 <geist> i wasn't either, but i'm starting to come around to it. i think it's rust also leaking in to google work lately
20:40:00 <heat> int num = calculation(); and not const int num
20:40:00 <geist> being that rust is const by default
20:40:00 <Ermine> geist: you mean people use Rust idioms in C code?
20:40:00 <geist> oh absolutely
20:41:00 <heat> i use crates in C
20:41:00 <theWeaver> heat: who doesn't?
20:41:00 <heat> it's called "libtool"
20:41:00 <heat> great utility, every one should use it
20:41:00 <theWeaver> pog
20:41:00 <geist> i can't off the top of my head think of another one, but lots of consts is one of them
20:41:00 <geist> i think in C++ you see a lot more trait like C++ stuff, which i still dont 100% grok
20:41:00 <heat> lots of consts is also a C++ thing
20:42:00 <geist> yah definitely consting args to things that need to be is obviously a C++ thing
20:42:00 <theWeaver> aint everythin const in rust unless it's mut :^)
20:42:00 <geist> ie pointers to const stuff
20:42:00 <geist> where i've been burned a lot by lack of const in a function is things like
20:43:00 <geist> foo (int len) { some loop { len -= N; } return len; }
20:43:00 <geist> stuff where there's a loop or somethig that mutates the args and ruins the general assumption that the args are the same in the entire body
20:44:00 <geist> by marking it const in the arg list you have to make a copy, but it also gives you a guarantee that it isn't modified anywhere
20:44:00 <heat> yeah
20:45:00 <geist> so i've started to use it in cases like that, but not everywhere. just places where it'd generally be a trap that i or some future maintainer might do
20:46:00 <heat> word of the day "Eigenständigkeitserklärung"
20:46:00 <theWeaver> heat: https://crimew.gay/notice/ARZolrAMPH3hnqp7wG
20:47:00 <heat> lmao
20:47:00 <theWeaver> :3
22:35:00 <heat> mjg, is stress-ng a good stress tester?
22:37:00 <mjg> heat: i don't know
22:37:00 <mjg> heat: i do know stress2 from LSD is good
22:38:00 <heat> hmmm
22:38:00 <heat> ok thanks
22:38:00 <mjg> but in your case i would simply start with multithreaded vfsmix
22:38:00 <mjg> it's probably enough to crash
22:38:00 <mjg> ... and repro
22:39:00 <heat> i have done vfsmix and it doesn't crash, member?
22:40:00 <mjg> i rmeembert you said your write support is fucked
22:40:00 <mjg> and that you did not want to run it
22:42:00 <heat> on non-tmpfs sure
22:42:00 <heat> but I don't want to work on fs stuff
22:43:00 <heat> not now at least
22:43:00 <heat> i wanted to take a good look at cranor's thesis to see if I get some good ideas out of it
22:43:00 <heat> i assume there's at least a passing mention of writeback
23:12:00 <mjg> heat: remember mapple syroup will-it-scale regression?
23:12:00 <mjg> ./mmap1_threads -t 48
23:12:00 <mjg> 94.20% [kernel] [k] osq_lock
23:12:00 <mjg> 1.64% [kernel] [k] rwsem_spin_on_owner
23:12:00 <mjg> 0.28% [kernel] [k] rwsem_down_write_slowpath
23:12:00 <mjg> :d
23:18:00 <heat> mjg, whats osq_lock?
23:19:00 <mjg> it's their hand-rolled mcs which they can reak from
23:19:00 <mjg> bottom line is this is time spent spinning wiating
23:19:00 <mjg> yo moferz what's your non-ubuntu distro
23:19:00 <heat> arch linux
23:19:00 <heat> btw
23:20:00 <mjg> can you grep /boot/config* | grep -v 'not set'
23:20:00 <heat> yes
23:20:00 <heat> /boot/config isn't standard btw
23:20:00 <heat> these days you can just use /proc/config.gz
23:20:00 <mjg> whatever the name you got there
23:21:00 <heat> wait what exactly do you want?
23:21:00 <heat> the config?
23:21:00 <mjg> oh wrong oneliner, sorry
23:21:00 <mjg> grep CONFIG_DEBUG ... | grep -v 'not set'
23:21:00 <mjg> or '^CONFIG_DEBUG", whatever the fuck
23:22:00 <mjg> i just found that ubuntu config comes with quite a few
23:22:00 <heat> CONFIG_DEBUG_BUGVERBOSE=y
23:22:00 <heat> CONFIG_DEBUG_INFO=y
23:22:00 <heat> CONFIG_DEBUG_KERNEL=y
23:22:00 <heat> CONFIG_DEBUG_INFO_BTF=y
23:22:00 <heat> CONFIG_DEBUG_INFO_DWARF5=y
23:22:00 <heat> CONFIG_DEBUG_INFO_BTF_MODULES=y
23:22:00 <heat> CONFIG_DEBUG_FS=y
23:22:00 <heat> CONFIG_DEBUG_FS_ALLOW_ALL=y
23:22:00 <heat> CONFIG_DEBUG_RODATA_TEST=y
23:22:00 <heat> CONFIG_DEBUG_WX=y
23:22:00 <heat> CONFIG_DEBUG_MEMORY_INIT=y
23:22:00 <heat> CONFIG_DEBUG_SHIRQ=y
23:22:00 <heat> CONFIG_DEBUG_LIST=y
23:22:00 <heat> CONFIG_DEBUG_BOOT_PARAMS=y
23:23:00 <mjg> pro tip use dpaste.cm or somethin' kthx cool
23:23:00 <mjg> thanks though
23:23:00 <heat> idc
23:23:00 <mjg> this is not discord@!
23:23:00 <heat> no one's using this right now
23:24:00 <heat> anyway what lock are they spinning on?
23:25:00 <heat> and how did it regress from the sleepable rwsem it was using before
23:26:00 <mjg> i would have to boot that kernel
23:26:00 <mjg> point is, they are most likely doing some funky stuff single-thraded
23:26:00 <mjg> which can be avoided
23:26:00 <mjg> and which makes contention so much worse
23:26:00 <heat> what kernel?
23:26:00 <mjg> according to my perf top over 7% is memset alone
23:26:00 <mjg> 6.2-rc3
23:27:00 <heat> i'm on 6.1.5
23:27:00 <heat> does this work?
23:27:00 <mjg> not if you want to bench multithreaded
23:27:00 <mjg> on your setup
23:27:00 <mjg> which is liek 8?
23:27:00 <heat> yeah 8
23:28:00 <heat> i'm obviously not going to stretch it :v
23:28:00 <mjg> not much of a team player uh?
23:28:00 <heat> giv me new cpu
23:29:00 <mjg> lemme try some telepathy
23:29:00 <mjg> did anything materialize on your desk?
23:30:00 <heat> doesn't seem like it no
23:31:00 <heat> the warszawa school of wizardry is a scam
23:31:00 <LittleFox> does anyone happen to have a spec for PE/COFF relocation types for RISC-V?
23:32:00 <heat> should be in the microsoft doc?
23:32:00 <LittleFox> trying to add support for COFF + RISC-V to LLVM
23:32:00 <LittleFox> heat, sadly not
23:32:00 <LittleFox> there are three defined in edk2, but without any docs
23:32:00 <heat> *shrug*
23:32:00 <mjg> heat: looks like theo got a new server instead
23:32:00 <heat> mjg, btw 67.23% mmap1_threads [kernel.vmlinux] [k] osq_lock ◆
23:32:00 <heat> 11.06% mmap1_threads [kernel.vmlinux] [k] rwsem_spin_on_owner ▒
23:32:00 <heat> 1.92% mmap1_threads [kernel.vmlinux] [k] rwsem_down_write_slowpath ▒
23:33:00 <heat> on 8 threads
23:33:00 <LittleFox> hm, here are some at least: https://learn.microsoft.com/en-us/windows/win32/debug/pe-format#base-relocation-types
23:33:00 <bslsk05> ​learn.microsoft.com: PE Format - Win32 apps | Microsoft Learn
23:34:00 <LittleFox> but not in the section where I looked first: https://learn.microsoft.com/en-us/windows/win32/debug/pe-format#type-indicators
23:34:00 <bslsk05> ​learn.microsoft.com: PE Format - Win32 apps | Microsoft Learn
23:35:00 <mjg> heat: well ye of course it is going to contend on 8
23:35:00 <mjg> heat: my point was the original report was 52 threads
23:36:00 <mjg> different scale
23:36:00 <heat> well the point is it's already very visible on 8
23:36:00 <mjg> contention is, but you dn't know how much it regressed at that scale
23:36:00 <mjg> it would be much less
23:40:00 <heat> mjg, doesn't seem like it's taking advantage of rcu
23:40:00 <mjg> it probably can't for modifications
23:40:00 <mjg> what it could possibly do is rangelock
23:40:00 <heat> https://gist.github.com/heatd/486870d841656cc25639a7b1c3adfdcc
23:40:00 <bslsk05> ​gist.github.com: mmap-test1-linux-maple.svg · GitHub
23:41:00 <mjg> anyhow my point is that they are most likely doing single-threaded work which is not needed, all while holding the problematic lock
23:41:00 <heat> i just gave you the fg
23:41:00 <heat> enjoy
23:41:00 <mjg> and this where the massive slowdown showed up
23:42:00 <heat> i'm sure the maple tree needs a lot more memory allocation
23:42:00 <heat> the rb tree vm had the nodes completely embedded in the vm areas
23:44:00 <mjg> so mapple syroup is doing 256 byte-sized memsets
23:44:00 <mjg> A LOT
23:45:00 <heat> memset_erms btw :))))
23:45:00 <mjg> https://dpaste.com/HP7LVLTL3
23:45:00 <bslsk05> ​dpaste.com <no title>
23:45:00 <heat> just a plain rep stosb
23:46:00 <mjg> so now the q is if they have to be this big
23:46:00 <mjg> but more importantly
23:46:00 <mjg> @[ memset+5 getname_flags.part.0+48 getname_flags+69 vfs_fstatat+67 __do_sys_newfstatat+43 __x64_sys_newfstatat+32 do_syscall_64+93 entry_SYSCALL_64_after_hwframe+114
23:46:00 <mjg> , 4096]: 260
23:47:00 <mjg> why the fuck is getname_flags doing a page-sized memset
23:47:00 <mjg> is it some debug or wtf
23:48:00 <mjg> aha
23:49:00 <mjg> looks like attempted hardening(?)
23:50:00 <heat> it's kzalloc
23:50:00 <mjg> include/linux/fs.h:#define __getname() kmem_cache_alloc(names_cachep, GFP_KERNEL)
23:50:00 <mjg> this does not inherently zero
23:51:00 <heat> result = kzalloc(size, GFP_KERNEL);
23:51:00 <heat> this does
23:51:00 <mjg> where
23:51:00 <heat> kzalloc
23:51:00 <mjg> file + line please
23:51:00 <heat> kernel zero alloc
23:51:00 <mjg> where do you have getname doing it
23:51:00 <heat> fs/namei.c 171
23:51:00 <heat> in 6.1.6
23:51:00 <mjg> dude that's a fallback
23:51:00 <mjg> if (unlikely(len == EMBEDDED_NAME_MAX)) {
23:52:00 <mjg> zeroing i'm talking about is coming from getname
23:52:00 <mjg> disasm does not show memset, so i'm guessing it got tail called frmo the allocator
23:53:00 <mjg> slab_post_alloc_hook(cachep, objcg, flags, 1, &objp, init,
23:53:00 <mjg> cachep->object_size);
23:53:00 <mjg> here
23:55:00 <mjg> commit 6a9b88204cb00da2140afda27848b5d17a7402a3
23:55:00 <mjg> Author: David Windsor <dave@nullcore.net>
23:55:00 <mjg> Date: Sat Jun 10 22:50:30 2017 -0400
23:55:00 <mjg> vfs: Define usercopy region in names_cache slab caches
23:55:00 <mjg> In support of usercopy hardening, this patch defines the entire cache
23:55:00 <mjg> object in the names_cache slab cache as whitelisted, since it may entirely
23:55:00 <mjg> hold name strings to be copied to/from userspace.
23:55:00 <mjg> i'm guessing 'whitelisted' here means literally zeroed out
23:57:00 <heat> i don't know if it does
23:57:00 <heat> whitelisted here means that you can copy to/from user on these slabs