Search logs:

channel logs for 2004 - 2010 are archived at ·· 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

Thursday, 7 September 2023

01:27:00 <colega> Hello
01:30:00 <heat> this looks correct right? for x86 jmp codegen
01:30:00 <bslsk05> ​ x86-label.c · GitHub
01:31:00 <zid> yea but it requires LE host
01:31:00 <heat> ->dest has dest_label - ip
01:31:00 <heat> ok good
01:31:00 <heat> find me a big endian x86
01:32:00 <zid> I don't approve of writing code that assumes things like that regardless, what if you wanna port our.. x86 jump_label_gen_branch to a dead risc cpu!?
01:33:00 <heat> no
01:33:00 <heat> i would only port it to dead VLIW cpus
01:34:00 <heat> gosh how do I patch a live system easily
01:34:00 <zid> down all APs
01:34:00 <heat> sounds bad
01:34:00 <zid> stop all processes
01:35:00 <heat> i could int3 it, sync icaches, write the real instruction, sync again?
01:37:00 <zid> I think you should unmap the page
01:37:00 <zid> write to it through a different mapping, and set up a special fault handler for anything that faults from the missing mapping
01:38:00 <heat> actually since i need an IPI anyway... broadcast to live CPUs, make em spin for the write, flush icache, resume?
01:38:00 <zid> flushing icache isn't needed on x86 btw
01:39:00 <heat> it is, on SMP
01:39:00 <zid> you and your fancy smp, geez
01:40:00 <heat> you need a serializing instruction
01:40:00 <heat> that does the trick on automagic x86
01:41:00 <zid> you don't even *need* one of those
01:41:00 <zid> it just helps certain cpus that don't snoop as aggressively
01:41:00 <zid> I don't even know which ones those are
01:41:00 <heat> you do, it's in the manual
01:42:00 <zid> yes, I am talking about *in practice*
01:42:00 <zid> only *some* cpus need it
01:42:00 <zid> which, in a manual, means all cpus need it
01:42:00 <zid> you can just execute mov [rip+4], blah quite handily and have it execute first try, on any cpu i've actually found
01:56:00 <heat> gosh i need to write this properly tomorrow
01:57:00 <heat> but in principle i have nearly-zero-cost branches
01:57:00 <heat> basically a similar idea to linux static_keys
01:58:00 <heat> just asm gotos that i int3 at compile-time and then patch really really early
01:58:00 <zid> yea I always wanted to do this for config options in my emulator
01:58:00 <zid> instead of if(blah_option) this;
01:58:00 <zid> or replacing chunks with a function pointer
01:59:00 <heat> keys that are true or on the "likely" value are just nice big fat 5-byte nops
02:00:00 <heat> then if they're enabled at runtime you just patch in a jmp/nop and that's it
02:01:00 <zid> are you explaining this to me?
02:01:00 <heat> idk
02:01:00 <heat> im just saying what i did
02:01:00 <zid> just like hearing yourself think, I see
02:02:00 <zid> maybe you can find a nice footballer and whisper this into his ear, really get him into you
02:02:00 <geist> no, i find it useful when reading things back
02:02:00 <geist> like, i'm following along with what heat is saying and then sitting here with a hmmmm expression on my face
02:02:00 <zid> I think it has half a shot
02:02:00 <geist> thumb and index finger to my chin, looking up
02:03:00 <heat> 🤔
02:03:00 <heat> i theorize that a call alternative could be possible and as such avoid a nop but that's microoptimization
02:04:00 <heat> i really doubt that some efficient nop sequences sprinkled on real code have measurable overhead
02:04:00 <heat> (see, i can say this and mjg can't interject because it's too late)
02:04:00 <zid> yea almost done unless you're heavily decode bound
02:05:00 <zid> done? none
02:05:00 <zid> and x86 can decode a *lot* of nops per second just fine
02:05:00 <zid> remember we have uop caches and shit
02:05:00 <zid> you'd only pay the penalty for a nop decode directly after a bad mispredict or something
02:05:00 <geist> so obvious question: how d yoimplement this on other arches?
02:06:00 <zid> The obviousier question is
02:06:00 <zid> where do the jumps come from
02:06:00 <zid> that's the real hard part
02:06:00 <zid> embedding control flow with asm("") and coming up with a label scheme, etc, is the gross part
02:07:00 <geist> indeed, and whatever sort of register allocation/code flow bubble it may need to generate in case a branch *may* be needed
02:07:00 <kof123> > find me a big endian x86 sort of Numeric values in VOS are always big endian, regardless of the endianness of the underlying hardware platform. On little endian servers with x86 processors, the compilers do a byte swap before reading or writing values to memory
02:07:00 <kof123> </cow tools>
02:08:00 <heat> geist, normally?
02:08:00 <zid> like, if you want an if(a) { b } getting the compiler to emit the b, and not having to write in asm, is hard
02:08:00 <geist> heat: yeah i guess?
02:08:00 <heat> i imagine the idea is similar, just different instructions
02:09:00 <geist> ah for each arch. yea
02:09:00 <geist> i mean you're basically replacing a nop with a branch, or a call?
02:10:00 <geist> is it intended to come back?
02:10:00 <heat> branch
02:10:00 <zid> E8 is jmp rel8
02:10:00 <zid> or was that call..
02:10:00 <zid> help heat
02:10:00 <zid> I wrote this code already but I can't remember
02:10:00 <heat> e8 is call
02:10:00 <heat> eb is short jmp, e9 is imm32 jmp
02:10:00 <zid> *eb* right
02:11:00 <geist> right, so then for other arches you have to have a nop large enough to satisfy that
02:11:00 <geist> on riscv that could be like a two word sequence
02:12:00 <zid> heat: Do u like my runtime patcher
02:12:00 <bslsk05> ​ patch.c · GitHub
02:12:00 <heat> this is my thing atm (patching is WIP in another file, but simple)
02:12:00 <bslsk05> ​ jump_label.h · GitHub
02:13:00 <zid> if(c != 0xE8)
02:13:00 <heat> that's cute but why WriteProcessMemory if its the same proc?
02:13:00 <zid> That's a fairly good point, just felt right, heh
02:13:00 <zid> if(c < 0x70 || c > 0x7B && (c != 0xE3 && c != 0xEB && c != 0xEB && c != 0xE9))
02:13:00 <zid> is a great line
02:14:00 <zid> I have no idea what it means
02:14:00 <heat> && c != 0xEB && c != 0xEB
02:14:00 <heat> better check it twice
02:14:00 <zid> ikr
02:14:00 <heat> might've changed in the meanwhile!
02:14:00 <zid> volatile unsigned char c;
02:14:00 <geist> hmm, what else was special about 0xeb
02:14:00 <geist> 0xEB sticks out somehow
02:14:00 <zid> yea we mentioned it 20 seconds ago
02:15:00 <heat> eb is jmp imm8
02:15:00 <geist> like it's the magic value... actually maybe it's like the first byte of a binary?
02:15:00 <geist> because branch....
02:15:00 <geist> is this where MZ comes from?
02:15:00 <heat> oh
02:15:00 <heat> FAT bootsector?
02:15:00 <zid> yea
02:15:00 <geist> aaah yeah maybe that's it, yeah
02:15:00 <zid> fat bootsector is my guess?
02:15:00 <geist> first byte of a bootsector, because jump
02:15:00 <zid> MZ is 4D 5A
02:16:00 <zid> dec bp pop dx?
02:16:00 <heat> yeah MZ isn't anything special
02:17:00 <heat> pretty sure the a.out magic also had special meaning for the PDP11
02:18:00 <heat> asm goto really is magic
02:18:00 <heat> fuckin nice
02:19:00 <geist> yeah the fun one is the MZ sequence is thankfully inert on arm64, so you can have a UEFI looking binary that you also allow offset 0 to be an entry point
02:19:00 <geist> then after the MZ sequence you toss in a real arm64 jump to the actual code
02:20:00 <heat> yeah i think riscv also has the same trick
02:21:00 <geist> yah haven't mapped out what MZ maps to
02:21:00 <heat> /*
02:21:00 <heat> * This instruction decodes to "MZ" ASCII required by UEFI.
02:21:00 <heat> */
02:21:00 <heat> s4,-13
02:21:00 <geist> oh noice
02:21:00 <geist> though without C extension it's a fault
02:23:00 <heat> oh that sucks
02:24:00 <heat> so you can't enable CONFIG_EFI without C
02:24:00 <geist> well, i think that's only if you also intend for it to be branched to at offset 0
02:26:00 <heat> yeah and that's the standard riscv64 linux boot protocol
02:26:00 <heat> which does not seem disableable
02:30:00 <heat> anyway i need to go to sleep, bye bye
02:31:00 <Hammdist> so I fixed my page tables. to debug, I put print statements in qemu's page table walker. turned out I was setting BLOCK flags where it should have been PAGE
02:32:00 <geist> oh that'll do it!
04:59:00 <Hammdist> hi all. I am now trying to execute a program at EL0 (aarch64). I -think- I'm dropping to L0 correctly, but when the program does an svc, this results in trap slot 4, not 8. to me, this indicates the el level was not actually changed properly. here is my el changing code: . any ideas? maybe not the exact problem but how to
04:59:00 <Hammdist> debug? is there a way to determine from gdb+qemu whether the drop to l0 was successful?
04:59:00 <bslsk05> ​ - View paste 6dKiM
05:00:00 <Hammdist> I know one apparently can't read currentel from qemu ... that is a bummer
05:01:00 <Hammdist> ah with -d int it tells me I returned to EL0. hmm
05:03:00 <Hammdist> ah -d int further reveals it's actually taking two exceptions so the first one might have the right address, but it faults further
06:40:00 <geist> ah there you go
06:40:00 <geist> yeah some sort of double fault would do it. suggestion: put an infinite loop in your 'from EL0' handler first, to see if it makes it
06:57:00 <kazinsal> god, someone linked me the 8088 MPH demo and I'd forgotten this masterpiece was 8 years ago
06:57:00 <kazinsal> 1024 colour stills and patterns and sprite emulation on a CGA
06:57:00 <kazinsal> also some fantastic music coming out of a beeper
07:15:00 <geist> oh yeah that was fantastic
07:16:00 <geist> speaking of slow, just got the old VAX running netbsd again
07:17:00 <geist> even with netbsd 3.0.3, circa 2007, it's already wayyy underpowered
07:17:00 <kazinsal> yeah, last time I booted mine up with netbsd 5 it took a solid 15 minutes before I had a console
07:17:00 <kazinsal> never managed to get ssh working on it, the crypto took longer than the TCP timeout
07:18:00 <geist> yep, just tried sshing into it now, but it has too old ciphers for modern linux to talk to it
07:18:00 <geist> telnet to the rescue
07:19:00 <geist> just have to enable it in inetd.conf
07:20:00 <kazinsal> yeah, my thought if I ever wanted to give vax access to a group of people would be to give them an account on a linux machine that would sync their account info to the vax and have a shell doing a passive telnet login to said vax
07:20:00 <geist> looks like a sizable amount of the 8088mph demo are a bunch of race the beam tricks
07:20:00 <kazinsal> but I never got around to it before my vax released the magic smoke
07:20:00 <geist> i couldn't get the scsi2sd thing working the other day so given that i may have fried it i ordered a new replacement. zuluscsi, looks neat
07:20:00 <geist> etc
07:21:00 <bslsk05> ​ ZuluSCSI V1.1
07:21:00 <geist> looks like the scsi2sds aren't in production anymore, but there are spiritual successors
07:21:00 <kazinsal> neat
07:21:00 <kazinsal> good thing to keep in the bookmarks folder, thanks
07:22:00 <kazinsal> kinda moot if this job application pans out -- not shipping a vax overseas -- but good to know in case it doesn't
07:28:00 <ddevault> anyone have a good way of making a FAT filesystem in a partitioned disk image from the command line?
07:28:00 <ddevault> ideally not depending on, like, qemu-nbd or something
07:29:00 <geist> command line of what? windows? linux?
07:29:00 <ddevault> unix
07:29:00 <geist> which unix?
07:29:00 <ddevault> posix
07:29:00 <ddevault> ...linux.
07:29:00 <kazinsal> mkdosfs
07:29:00 <geist> then no.
07:30:00 <geist> depending on if you're using linux, freebsd, netbsd, etc you could probably always make it a loopback device and then partition that
07:30:00 <ddevault> that's the nbd approach, more or less
07:30:00 <geist> or compute the partition offsets and build a subdevice loopback
07:30:00 <geist> other than that it's pretty difficult
07:30:00 <ddevault> computing offsets might work with mtools
07:30:00 <geist> that i know of
07:30:00 <geist> yeah if you could somehow say 'mtools, use this file and treat this range of it as a full disk'
07:31:00 <kazinsal> losetup the disk image, you now have a virtual raw block device
07:31:00 <kazinsal> fdisk or whatever that
07:31:00 <kazinsal> then mkdosfs the resulting partition
07:31:00 <ddevault> or set up a unpartitioned FAT filesystem with mtools and copy it into the partitioned image with dd at the appropriate offset
07:31:00 <geist> right, but i think there is some weirdness about whether or not you can partition a losetup
07:32:00 <kazinsal> it's been ages since I've tried it
07:32:00 <kazinsal> but I think if you losetup a raw image you can feed it to fdisk or parted
07:36:00 <klys> # apt-get install parted; partprobe /dev/loop0
07:39:00 <ddevault> yeah this approach works and is reasonably portable
07:40:00 <ddevault>
07:40:00 <bslsk05> ​ —
07:42:00 <ddevault> bleh, it doesn't use long filenames, I have to implement short names in my FAT driver
12:11:00 <Ermine> gog: may I pet you
12:11:00 <gog> yes
12:11:00 * Ermine pets gog
12:19:00 <mcrod> hi
12:19:00 <mcrod> gog may I also pet you
12:21:00 <gog> yes
12:23:00 * mcrod pets gog
12:27:00 <Ermine> I should consider upgrading my cpu. Kernel takes a lot of time to build
12:27:00 <zid> what about downgrading your kernel
12:29:00 <heat> yeah if you build a 2.4 it's much faster
12:29:00 <heat> problem solved
12:31:00 * gog prrpr
12:31:00 <Ermine> 0.0.1 will be even faster
12:31:00 <gog> didn't 0.0.1 use 386 tas switching
12:31:00 <Ermine> Also 2.4 is more Unixy
12:32:00 <heat> hey you know what's fast to build? onyx
12:32:00 <heat> subscribe to my onlyfans
12:32:00 <heat> watch me write x86 instruction patching using my feet
12:32:00 <Ermine> Yeah, its build speed is poggers
12:33:00 <heat> you know what dominates build time in the userspace portion?
12:33:00 <heat> googletest and nlohmann_json
12:33:00 <heat> header-only-library-moment
12:33:00 <Ermine> Also it dominates in the number of warnings emitted
12:34:00 <heat> yes because im not a userspace dev
12:34:00 <heat> sorry
12:34:00 <mcrod> heat: hi
12:34:00 <heat> a strategic sortix - onyx merger would be epic
12:34:00 <heat> mcrod, hi
12:34:00 <mcrod> i hate the xbox elite controller.
12:34:00 <mcrod> whoever designed it must've been a C++ programmer
12:35:00 <heat> is it bad?
12:35:00 <mcrod> adding features that you think are useful, but in reality are entirely cumbersome just by their very presence
12:35:00 <mcrod> er, makes the rest of the product*
12:35:00 <mcrod> it's very bad in my opinion
12:35:00 <mcrod> there are paddles on the back
12:35:00 <Ermine> Anyway, I have to wait kernel to finish building before I can reboot
12:35:00 <heat> yeah i have the normal later xbone one
12:35:00 <gog> what you call sortix is actually onyx/sortix
12:35:00 <gog> where onyx is the kernel
12:35:00 <heat> reversed
12:35:00 <gog> onyx-tranglix when
12:36:00 <mcrod> so when you're holding the controller you're probably touching the paddles
12:36:00 <Ermine> sortix/onyx then
12:53:00 <mcrod> i wrote so much C++ in my life that I'm almost forgetting how to do things in C
12:57:00 <heat> are u stupid
12:58:00 <gog> i write c#
12:58:00 <gog> it's making me dull
12:58:00 <heat> gog quick write me enterprise software
12:59:00 <gog> public class FactoryFactory {}
13:00:00 <mcrod> heat: no
13:00:00 <gog> i'm stupid
13:02:00 <Ermine> public class PrimordialFactory {}
13:03:00 <heat> public class LinoxKernalFactory {}
13:03:00 <heat> public class ____Factory
13:03:00 <zid> int class;
13:04:00 <zid> That's how you write C, mcrod.
13:04:00 <Ermine> public class OnyxFactoryToProduceLinuxFactory
13:04:00 <mcrod> zid: thanks. you're a big help.
13:04:00 <zid> I make sure to throw in as many int class; into my projects as I can get away with
13:04:00 <zid> just to make idiots' lives harder
13:04:00 <mcrod> you must be fun at parties
13:05:00 <zid> depends if the party is full of C++ programmers or not
13:05:00 <zid> it seems unlikely
13:05:00 <zid> they'd be too busy reading 180 pages of <<<<<
13:05:00 <heat> cppcon afterparties
13:05:00 <zid> because of a typo
13:11:00 <heat> here's a funny trick: don't cpuid for serialization, iret instead
13:12:00 <heat> cpuid can vmexit you :)
13:12:00 <zid> vmexit is one of those millenial metaphors for suicide right?
13:13:00 <heat> yes
13:19:00 <ChavGPT> that' waking up from the matrix mon
13:20:00 <ChavGPT> like in that movie
13:21:00 <nikolar> #define class struct
13:26:00 <ChavGPT> i'm reating my own programming language
13:26:00 <ChavGPT> it is going to have fearlezzz performance
13:31:00 <heat> ChavGPT, doze freebdsm have static_keys?
13:33:00 <gog>
13:33:00 <gog> ChavGPT:
13:35:00 <sham1> The book is probably made with ChatGPT as well. Efficiency!
13:35:00 <sham1> Hi, btw
13:35:00 <gog> hi sham1
13:35:00 <gog> i fixed a bug that the CEO was pressing us about
13:35:00 <gog> my boss couldn't figure it out
13:36:00 <sham1> Nice!
13:36:00 <gog> yes
13:36:00 <gog> maybe he won't fire me now
13:36:00 <gog> :D
13:36:00 <Ermine> good job!
13:36:00 <zid> so you're better than your boss confirmed
13:36:00 <zid> have you considered kicking him to the curb
13:36:00 <gog> he has told me he thinks i'm a better programmer
13:36:00 <zid> seize the means of the triple monitor spot
13:37:00 <gog> my education was different than his, but idk if i'm "better"
13:37:00 <gog> i'm definitely less experiened because he's been in the industry since leaving uni
13:37:00 <gog> whereas it took me an extra several years to start my career
13:37:00 <zid> what's a career
13:37:00 <gog> a series of jobs that you obsess and stress over
13:37:00 <zid> sounds bad
13:37:00 * zid bums
13:41:00 <mcrod> abstractions are hard.
13:42:00 <mcrod> I say hard loosely
13:42:00 <mcrod> but it's hard to write an abstraction for something you don't know much about
14:10:00 <zid> I just go data out
14:10:00 <zid> at some level, everything is a fancy memcpy
14:10:00 <zid> that's the inner function, the rest is options for how to call that function
14:14:00 <ChavGPT> whtat stic keys mon
14:15:00 <ChavGPT> i think i mentioned there is nothin' for patchin inline
14:15:00 <ChavGPT> there is however ifunc support
14:15:00 <heat>
14:15:00 <bslsk05> ​ Static Keys — The Linux Kernel documentation
14:16:00 <ChavGPT> 16:15 < ChavGPT> i think i mentioned there is nothin' for patchin inline
14:17:00 <heat> ok cool good to know
14:18:00 <ChavGPT> heat MO
14:19:00 <ChavGPT> 1. pick something freebsd does not ahve
14:19:00 <ChavGPT> 2. ask if it has it
14:19:00 <ChavGPT> 3. act innocent
14:19:00 <ChavGPT> i see you undermining good opinion about the project
14:19:00 <heat> do you think i remember everything you say?
14:19:00 <ChavGPT> you definitely remember "mofo" and "pessimal"
14:20:00 <ChavGPT> spaced repetition
14:20:00 <zid> heat is honoured that I remember *anything* he says
14:21:00 <ChavGPT> i just remember genz
14:21:00 <ChavGPT> Genzix would mak a great name for an os
14:22:00 <heat> ok i dont care i have static keys now haha
14:22:00 <Ermine> okboomix is good name too
14:23:00 <ChavGPT> heat: OH YE?
14:23:00 <ChavGPT> good for you mate
14:24:00 <zid> boomix is good
14:24:00 <Ermine> static keys are deprecated as per docs
14:24:00 <ChavGPT> plot twist: it's a windows clone
14:24:00 <heat> Ermine, wrong
14:24:00 <zid> wtf I just got a youtube ad
14:24:00 <zid> am I going to have to stop watching youtube
14:24:00 <ChavGPT> no ads on my firefox
14:24:00 <Ermine> ok ok
14:24:00 <heat> direct static key definition + access + some macros are
14:24:00 <zid> I assume it was just a blip in my blocker
14:24:00 <zid> heat what is an STATIC KEY
14:24:00 <ChavGPT> bit flip in adblock!
14:26:00 <heat> ChavGPT, look at the OPTIMALNESSSSSSSSSSSS
14:26:00 <bslsk05> ​ gist:eefdb4d59cedbda42e2e128a5284b6e8 · GitHub
14:26:00 <heat> i even handle short jumps
14:27:00 <heat> zid, what we were discussing last evening
14:27:00 <heat> rarely changed vars that directly change codegen using asm goto magic
14:27:00 <zid> what does that have to do with keys
14:27:00 <heat> they called it static_key, idk
14:28:00 <heat> ask the CEO of linux, al viro
14:28:00 <zid> al viro is the head of HR
14:28:00 <ChavGPT> he is the butt of hr
14:42:00 <zid> gog: I feel like you could benefit from this mindset
14:48:00 <mcrod> hey i do the same thing
14:58:00 <sham1> mcrod: how dare you
15:02:00 <mcrod> don't worry, my girlfriend calls me a heathen every time
15:08:00 <ddevault> making nice progress
15:09:00 <Ermine> good job ddevault !
15:10:00 <ddevault> thanks!
17:07:00 <Hammdist> hello. now my guest is trapping on swpal. is there an enabling bit for allowing the guest to perform swpal?
17:17:00 <ddevault> the swp instructions were removed from ARMv8-A
17:17:00 <ddevault> ref. The Big PDF, section 8.3.2
17:19:00 <Hammdist> hurr does that mean cortex-a53 is or isn't capable of swpal?
17:21:00 <Hammdist> well if there isn't an enabling bit it seems at least qemu thinks a53 should not be capable
17:29:00 <ddevault> is not, I think.
18:04:00 <qookie> Hammdist: ddevault: looking at the armarm, swp was added in v8.1, with FEAT_LSE
18:04:00 <ddevault> ah, alright
18:05:00 <qookie> so the cortex-a53 doesn't have it (nor does the a72, so none of the 64-bit rpis)
18:06:00 <Hammdist> then I guess I might have to emulate these instructions in my kernel as the compiler for the guest program has no feature switches for arm64 (it's a wishlist item)
18:07:00 <heat> what cursed compiler are you using
18:07:00 <Hammdist> it's a golang program
18:08:00 <heat> golang doesn't have feature switches??
18:08:00 <Hammdist> here is the open ticket regarding this:
18:09:00 <heat> >These instructions are already used after a capability check
18:09:00 <heat> so your capability check code is borked
18:11:00 <heat> geist, im going to add riscv64 static branching support next, the codegen looks kinda straight forward
18:11:00 <heat> you need 2 nops, one for the jal, one for the possible auipc
18:12:00 <Hammdist> hrrm I did look at the asm and it didn't look like there was a capability check in this case. maybe I'm wrong though. as far as how the program would test capability I did notice it reading midr_el1 but I just passed through the value available in kernel space. everything else would be up to qemu to declare capabilities correctly which I would
18:12:00 <Hammdist> think it does
18:12:00 <moon-child> owie! my personal computer!
18:13:00 <heat> wait, guest? this is a hypervisor?
18:14:00 <Hammdist> no the guest runs in el0, my kernel in el1
18:14:00 <heat> oh ok that's not a guest
18:14:00 <heat> just a program
18:14:00 <Hammdist> well the kernel is a program too I guess
18:15:00 <Hammdist> let me post the disasm of the code in question
18:18:00 <Hammdist>
18:20:00 <qookie> line 15 jumps over the swpal into the ldaxr/stlxr code path
18:20:00 <qookie> and both then merge at line 23
18:21:00 <Hammdist> ah hm. well that could be a check then. I was looking for a movbu like in the example
18:22:00 <Hammdist> guess I might have a look at the source code of this runtime.lock2
18:25:00 <heat> what exactly are you doing?
18:25:00 <heat> weren't you like, erm, doing basic board bringup a few weeks back?
18:26:00 <heat> how doz bord werk -> 2 weeks -> fully fledged go port?
18:27:00 <Hammdist> well I guess I copied a lot of existing MIT/BSD code from other kernels and I'm trying now to put together enough of a kernel to run go programs
18:30:00 <heat> frankenkernel?
18:30:00 <heat> sounds spoopy to me
18:30:00 <Ermine> frankix
18:36:00 <gorgonical> frankenstein's monstix
18:52:00 <gog> hi
18:53:00 <gorgonical> hello
18:58:00 <gog> i'm not as sad today as i was yesterdday
18:59:00 <gorgonical> that's good to hear
19:00:00 <Ermine> That's poggers
19:00:00 <gorgonical> have you ever signed the book at the top of mt esja?
19:00:00 <gog> no i haven't done the hike
19:00:00 <gog> i meant to this summer but life happens
19:00:00 <gog> next year
19:01:00 <gorgonical> I can recommend it. I was out there until like 11pm and it was still light because you live in fairyland
19:01:00 <gog> true
19:01:00 <zid> henlo
19:01:00 <zid> my internet was broken again today
19:01:00 <zid> I mean, the internet
19:01:00 <gog> henlo
19:01:00 <zid> what did you do while it was down?
19:02:00 <gorgonical> I went and got a haircut and ate pizza
19:02:00 <gorgonical> Day is complete imo
19:09:00 <zid>
19:09:00 <zid> See, the internet was down.
19:25:00 <Hammdist> well I got past the problem with the capability test - issue was I had made a copy of the stack data from a run of qemu to seed the execution of the l0 program. however I hadn't specified -cpu so instead of cortex-a53 it was probably using -cpu max or something. the capability was ultimately detected from the auxv data. fixed easily by specifying
19:25:00 <Hammdist> -cpu cortex-a53 to qemu user mode emulation and then copying the stack data again
19:36:00 <bl4ckb0ne> is there a common naming when refering to a { uintptr_t phys; size_t pages } kind of struct?
19:36:00 <gog> hi
19:36:00 <bl4ckb0ne> hi gog
19:36:00 <osdever> gog: Hello
19:36:00 <gog> i call mine struct memory_range
19:36:00 <osdever> Does anyone know how to FORCE x86_64-elf-gcc to build a shared library? The dirty bastard is creating static executables even when I say "-shared"
19:37:00 <bl4ckb0ne> efi uses memory_descriptor but its long
19:37:00 <gog> you could call it memrage or addr_range
19:37:00 <gog> or anything
19:37:00 <gog> there are no rules
19:37:00 <gorgonical> do a lewis carroll and invent wholly new, nonsense words
19:38:00 <gog> osdever: you'll need to invoke ld and do some Things
19:38:00 <gog> hang on
19:38:00 <gog>
19:38:00 <gog> need at least these flags
19:38:00 <gog> except general-regs-only
19:39:00 <gog> that's not necessary unless you're building interrupt handlers
19:40:00 <gog>
19:40:00 <gog> that's the actual link command
19:42:00 <osdever> gog: Thank you, I had feeling x86_64-elf-gcc filthily removes `-shared` from its invocation when invoking ld for some reason. I just confirming it with `-v` and I can make a shared library with your command
19:42:00 <gog> yeah it's because it's a bare target
19:42:00 <gog> and it doesn't have a spec file to make a shared library
19:42:00 <gog> you can nudge it to do the right thing
19:43:00 <gog> just takes a little more work
19:44:00 <bl4ckb0ne> uwu naming is hard
19:44:00 <gorgonical> bl4ckb0ne: an idea is to give all the important kernel structs ridiculous, old-timey names
19:44:00 <gorgonical> "the kernel has to allocate an archibald every time this happens"
19:44:00 <osdever> I want to manufacture my own toolchain but I fear if libgcc depends on hosted clib when built like that. My kernel is architected like the way of AmigaOS, with shared libraries essential... Until now I use host x86_64-linux toolchain which make a shared library, no problem
19:45:00 <bl4ckb0ne> memory region!
19:46:00 <bl4ckb0ne> at least thats what the uefi spec calls them
19:48:00 <gog> uwu
19:49:00 <osdever> I call it "Region"
19:49:00 <bl4ckb0ne> your a region
19:49:00 <gog> i'm gog
19:49:00 <bl4ckb0ne> hi gog
19:49:00 <gorgonical> you're very o-region-al
19:49:00 <gog> huehue
19:50:00 <osdever> bl4ckb0ne: This is the word on AmigaOS for continous physical memory spaces. "Region"
19:51:00 <bl4ckb0ne>
19:51:00 <bl4ckb0ne> region of the memory map
19:51:00 <osdever> You can see if you look in the ExecBase documentation, that's how they call its word, but you discovery them with structures called MemHeaders
19:53:00 <osdever> Sorry I need to go now. Thanks to God answering my question.
19:53:00 <osdever> * Gog
19:53:00 <gog> byeee
20:28:00 <heat> the more i think about that frankenkernel the more questions i have
20:29:00 <heat> did he just crib my kernel? is that all? i was using it as a reference anyway
20:29:00 <heat> he*
20:29:00 <zid> whose?
20:29:00 <heat> no way he has a custom kernel with random code
20:30:00 <heat> <Hammdist> well I guess I copied a lot of existing MIT/BSD code from other kernels and I'm trying now to put together enough of a kernel to run go programs
20:30:00 <zid> is that the same guy as a couple of months ago
20:30:00 <zid> who upset gog
20:30:00 <heat> taking random code from many kernels and frankensteining that shit together has to be more effort than actually writing it
20:30:00 <heat> no, i dont think so
20:30:00 <ChavGPT> which is why heat takes from just one kernel
20:30:00 <ChavGPT> innit
20:31:00 <heat> amen bruva
20:31:00 <heat> don't tell anyone else i steal from illumos
20:31:00 <netbsduser`> i have pilfered too many ideas from illumos
20:32:00 <ChavGPT> why not contribute to illumos
20:32:00 <netbsduser`> i have done
20:32:00 <heat> why would you ever steal from illumos
20:32:00 <heat> thats like stealing from any BSD
20:32:00 <heat> you're objectively worse off
20:33:00 <netbsduser`> illumos has a purer and more elegant vfs
20:33:00 <moon-child> I only use illumos's memcpy
20:33:00 <moon-child> best memcpy ever
20:33:00 <heat> "purer"
20:33:00 <heat> linux has a working and faster vfs
20:33:00 <heat> what now
20:34:00 <heat> purity means jack
20:34:00 <netbsduser`> bsd vfs uses the lock vnode op for actual synchronisation instead of just for file locking, it has a convoluted lifecycle, and an incomplete integration of the vfs in general (this is why the file ops struct exists)
20:34:00 <heat> thats why freebsd pmap is crap
20:34:00 <heat> purity and elegance!! but growing regions downwards is too hard :(
20:34:00 <zid> purity was made up by the patriarchy to make sure they weren't being cucked
20:34:00 <zid> true fact.
20:35:00 <heat> sorry, freebsd and netbsd and openbsd and dflybsd pmap
20:35:00 <heat> none of their designs ever fixed that
20:35:00 <netbsduser`> i always suspected freebsd had a decent pmap
20:35:00 <heat> IIRC either netbsd or openbsd didn't even merge regions
20:35:00 <heat> mmap(addr) and mmap(addr + pagesz) just had two separate mappings
20:35:00 <netbsduser`> they have transparent huge pages and even large pages support, absent from netbsd
20:35:00 <mcrod> parsing sucks
20:35:00 <mcrod> FUCK
20:35:00 <mcrod> FUCK!!!
20:36:00 <ChavGPT> only freebsd has huge pages
20:36:00 <ChavGPT> while bsd vfs is well known to be a clusterfuck
20:36:00 <heat> they store data redundantly and focus on nice beautiful data structures
20:36:00 <ChavGPT> i don't know illumos to be visibly better
20:36:00 <heat> why does private memory have fucking radix trees?
20:36:00 <netbsduser`> now freebsd does have a weakness in that their anonymous memory mechanism still uses the original shadow object chaining technique of mach, which is more hideous than netbsd's reference-counting technique
20:36:00 <mcrod> why is your name heat
20:37:00 <heat> stole it off of the miami heat
20:37:00 <heat> literally
20:37:00 <ChavGPT> ? :d
20:37:00 <heat> sue me floridians
20:37:00 <heat> i don't even want to go to florida
20:37:00 <ChavGPT> i should nickname myself vice then
20:37:00 <zid> I assumed you took it from the oestrus cycle of rabbits
20:37:00 <heat> netbsduser`, it's a huge weakness and that code is a huge clusterfuck
20:38:00 <netbsduser`> heat: you may scoff at it now, but when you want to efficiently port to a machine which deals in inverted page tables, you will learn to love the arch-independent representation of address spaces
20:38:00 <heat> you know how I'd do it?
20:38:00 <heat> radix-like page tables
20:39:00 <zid> I'd do it radish-like
20:39:00 <heat> linux is very portable and has none of that pmap crap
20:39:00 <netbsduser`> that's what's done on netbsd/alpha for the software-refilled TLBs
20:39:00 <heat> and most importantly, it's designed AROUND NORMAL FUCKING SYSTEMS
20:39:00 <heat> actually usable crap
20:40:00 <heat> x86, arm, riscv all use the same page table scheme
20:40:00 <zid> namely, number goes in, number goes out WITH FLAGS
20:40:00 <zid> you can't explain that
20:40:00 <netbsduser`> if you hit a seal in the face every day for 20 years, you may turn it into a rather fetching hat
20:40:00 <moon-child> I'm still sad power got rid of their hash table
20:40:00 <heat> why would you make everyone in the normal world bear your ✨beautiful design✨
20:41:00 <heat> bear? bare?
20:41:00 <heat> something
20:41:00 <heat> you get what i mean
20:41:00 <moon-child> bear
20:41:00 <zid> bare is naked, the rest are shared
20:41:00 <zid> bear/bear/bear/bear
20:41:00 <heat> ✨beautiful design✨ that is ✨pessimal✨
20:41:00 <netbsduser`> linux has enjoyed those 20 years and that's what its advantage today owes more to i think
20:42:00 <heat> current linux just has better designs than current BSD
20:42:00 <heat> and they fit the real world a lot better
20:42:00 <moon-child> government is forcing me to wear long sleeve shirts
20:42:00 <moon-child> this is bullshit
20:42:00 <moon-child> I want the right to have and bare arms
20:43:00 <netbsduser`> it was only around 2001 or so that linux had to invite matt dillon in to consult on their slow memory manager
20:43:00 <heat> in the vm example, windows takes a page off the same book and also deals directly with page tables and PTEs
20:43:00 <heat> good news, it's 2023
20:43:00 <netbsduser`> i forgot the details, i think linux was iterating over every single page table in the system to look for mappings of a page when it was decided to page it out
20:44:00 <netbsduser`> windows is radically different, their memory manager has no resemblance to anything ever powering a unix
20:46:00 <zid> windows xp was so aggressively swappy I used to have to disable it
20:46:00 <zid> because on a mech drive it meant the system would just pause for 100ms every 2 seconds under load
20:46:00 <netbsduser`> in the book about it they say it was designed so that a single spinlock would protect the majority of it and every operation carried out under that had to be O(1)
20:47:00 <heat> probably scales fine for their workloads
20:47:00 <heat> despite ChavGPT rolling in his grave or whatever they use to sleep in poland
20:48:00 <gog> no the guy that upset me was jafarlihi
20:48:00 <netbsduser`> they split up that lock some time ago but the new locking system isn't described in the windows internals books as far as i've read of them
20:48:00 <zid> heat: coffins
20:48:00 <heat> until late last year linux would have exclusive locks around the whole vm except when resolving page faults
20:49:00 <zid> ah yea gog
20:49:00 <zid> polish people sleep in coffins
20:49:00 <netbsduser`> heat: no way
20:49:00 <gog> i'm gonna ask my coworkers tomorrow
20:49:00 <gog> my polish coworkers
20:49:00 <gog> if they sleep in coffins
20:49:00 <gog> and tell them you said
20:49:00 <zid> heat check ur DMs babe
20:49:00 <heat> netbsduser`, yes way? it's the obvious alternative
20:49:00 <netbsduser`> i thought they had very small locks now in linux
20:50:00 <heat> i mean, its a lock per address space
20:50:00 <heat> but it's comparively big since mmap, mprotect, munmap serialized the shit out of everything
20:50:00 <netbsduser`> oh, that's more understandable
20:50:00 <heat> page faults ran concurrently with the mmap read lock held
20:51:00 <netbsduser`> i thought you meant global
20:51:00 <heat> i don't mean global global
20:51:00 <heat> that's hilariously bad
20:51:00 <heat> just process-global, which still sucks
20:52:00 <netbsduser`> that's why windows had to have its operations be O(1)
20:53:00 <netbsduser`> they had per-process mutexes (the working set mutex) but things like PTE changes, page moves queue, were under the global spinlock
20:53:00 <heat> yeah that sucks
20:54:00 <heat> fwiw afaik all other systems still have big rw locks around the address space
20:54:00 <heat> except LE LINUX
20:54:00 <heat> the dirty very ungood linux with its amateurish code
20:54:00 <netbsduser`> what's interesting is that we know Richard Rashid and other Mach people were big wheels around the creation of NT, and mach had much finer locking
20:55:00 <zid> Time is time
20:55:00 <zid> and windows wasn't really a big iron server platform
20:55:00 <heat> yeah
20:55:00 <zid> I don't see why you'd aim for more than "it doesn't choke up if 30 things are running"
20:55:00 <zid> if you're on the original NT dev team
20:55:00 <heat> if it works fine for chrome and word and call of duty you're alright
20:55:00 <netbsduser`> tru64 at least had much finer grained locking around address spaces (locks taken out against ranges in it), i read about it in the Design of the OSF/1 Operating System
20:57:00 <heat> turns out user programs are conservative when it comes to mmap and munmap so that's not a biggie anyway
20:57:00 <heat> netbsduser`, range locking isn't necessarily a win btw
20:58:00 <heat> this is a nice read
20:58:00 <netbsduser`> too much locking spoils the broth
20:58:00 <zid> Yea I was going to touch on something similar
20:58:00 <zid> you get to pick *where* you put the locks, but putting them on certain layers is good for *certain* operations only
20:59:00 <netbsduser`> heat: thanks, this looks like an entertaining article
20:59:00 <heat> there's also the radix vm work
20:59:00 <heat> i read the paper and found it absolute bollocks
20:59:00 <gog> meow
20:59:00 <heat> "yeah see, our thing is faster, it just needs 40x the memory"
21:00:00 <heat> meow meow gog meow
21:00:00 <gog> meow mrrp prr meow
21:00:00 <heat> aktushally
21:00:00 <heat> i am wondering now if you could keep a traditional rb tree behind a radix tree cache and have good results from that
21:01:00 <not_not> so should i write a compiler first or a nifty bootloader?
21:01:00 <heat> certainly lockless lookups would be nice
21:01:00 <zid> never write bootloaders, so, compiler
21:02:00 <heat> netbsduser`, anyway, linux did not go that route, they switched the rb tree with a maple tree (pretty much a btree with RCU helping it out) and added some bespoke vma locking i personally find horrendous
21:02:00 <heat> but the maple tree is nice
21:03:00 <heat> binary trees are not the bee's knees
21:03:00 <heat> *at all*
21:04:00 <not_not> why never write bootloaders tho?
21:05:00 <zid> I mean, if your idea of fun is chasing bugs in bios roms from chinese motherboard cloners from the 80s
21:05:00 <zid> feel free I guess
21:05:00 <gog> non binary trees
21:05:00 <not_not> good point
21:06:00 <zid> we thankfully have a small archive of fixups for broken bioses like that called 'the grub project'
21:06:00 <not_not> ye guess you can just use grub to boot into your kernel
21:06:00 <heat> gog, hey that's a btree!
21:06:00 <netbsduser`> i heard about the maple trees somewhere
21:06:00 <netbsduser`> haven't looked at them yet
21:07:00 <not_not> i love trees
21:07:00 <gog> you could just write weird experiments
21:07:00 <gog> like i do
21:07:00 <gog> and never really focus on anything
21:08:00 <not_not> im writing this weird experiment wich tries to make a computer do "not this, not this, not this ..... not not"
21:08:00 <not_not> and achive self awareness
21:14:00 <gorgonical> my computer does this thing where when i write a new img to my sd card it occasionally just wont write it
21:14:00 <gorgonical> and then it will fully stop and i don't know why. cat whatever.img > /dev/sdf2 and it just goes "yeah done instantly boss no worries"
21:14:00 <gorgonical> liar
21:15:00 <nikolar> sync?
21:15:00 <gorgonical> it does nothing
21:15:00 <gorgonical> unless you know of a supersync command or something
21:15:00 <heat> your sd card sounds dodgy
21:15:00 <nikolar> yeah i am not aware of anything like that
21:15:00 <heat> if sync isn't writing it out
21:16:00 <gorgonical> it's probably the writer
21:16:00 <gorgonical> multiple known good cards do it
21:17:00 <gorgonical> though it is an anker sd card reader
21:27:00 <immibis> i have a microsd card which accepts writes (in multiple readers) and doesn't actually write. never buying a sandisk card again
21:27:00 <immibis> this occurred after only about a week of actual usage
21:27:00 <gorgonical> fancy that, this one's a sandisk too
21:27:00 <gorgonical> the one that actually works is a samsung brand
21:27:00 <immibis> maybe in contrived scenarios a high-capacity sandisk card could be a good form of WORM media :)
21:28:00 <immibis> if you want to take 400gb of media to watch on vacation offline... it sure beats a stack of blu-rays
21:44:00 <gorgonical> christ i finally got interkernel ipis on real hardware
21:44:00 <geist> yeah that's really weird it's not writing
21:44:00 <gorgonical> it was so easy in qemu
21:45:00 <geist> it may cache behind for sure, though generally that's not the case with a raw device write on linux. i think it can cache but it usually syncs on close, i think
21:45:00 <gorgonical> geist: and fwiw i don't see any unusual messages about hw behavior in dmesg
21:45:00 <gog> meow
21:45:00 <heat> i don't believe it syncs on close
21:45:00 <geist> yah that is highly strange
21:46:00 <heat> AFAIK it doesn't sync
21:46:00 <gog> hi
21:46:00 <gorgonical> my gf is at a work event and i'm trying to convince myself to not just eat baguette and brie for dinner
21:46:00 <heat> (but i've never looked at the file_ops for those devs)
21:46:00 <heat> geist, also it most definitely caches
21:46:00 <geist> possibly, i thought i've seen a sync-on-close like behavior, but maybe not
21:47:00 <heat> let me checkkkk
21:47:00 <geist> but either way you should also eject the card properly before pulling it out, which will sync it anyway
21:48:00 <geist> mostly out of laziness i tend to use the Disk utility on ubuntu/mint linux with the 'restore from image' ui, which definitely puts a sync in at the end
21:48:00 <geist> or maybe even uses O_DIRECT
21:49:00 <heat> yeah
21:49:00 <heat> i usually use dd and the caching is visible there
21:50:00 <gorgonical> even dd does
21:50:00 <heat> if you dd something without oflag=sync(or is it direct? cant remember) the syncing up of the page cache is visible on lower-end storage like sd cards
21:50:00 <gorgonical> I know for a fact this pos doesn't write 700MB/s
21:51:00 <heat> yeah what you usually see is blistering speeds, then if the write is large enough it hangs for page writeback
21:51:00 <geist> over time it tends to collapse to the speed of the device, if you send it large enough data
21:51:00 <heat> (then it keeps writing the rest)
21:51:00 <geist> right
21:51:00 <gorgonical> additionally I do *not* see the led on the reader blink
21:51:00 <gorgonical> which it normally does when writing
21:51:00 <geist> hopefylly you're not just blissfully overwriting something else :)
21:52:00 <gorgonical> i have so much fear i compulsively check lsblk right before every time
21:55:00 <heat> once i accidentally dd'd to a device that wasn't there
21:55:00 <heat> so it just created a big tmpfs file in /dev lol
21:56:00 <gorgonical> now the samsung sd card is doing it too
21:56:00 <gorgonical> and the fixes on se are alllll over the place
22:05:00 <ChavGPT> heat: mofer not only linux still has a big rw lock around the address space
22:05:00 <ChavGPT> heat: but the first fault in the mmapped area reada locks it
22:06:00 <ChavGPT> linukkkz not scale
22:07:00 <heat> lunikkkkkkz is dropping the lock slowly calm the fuck down big fella
22:08:00 <heat> something something technical debt
22:08:00 <heat> even the current wave of per-vma refactoring had a buncha bugs
22:12:00 <netbsduser`> there was a big scandal recently around linux mm locking which i forgot the details of
22:12:00 <heat> there was a bug and they found it and they fixed it
22:12:00 <ChavGPT> it all works now
22:12:00 <heat> sadly it was already out in a stable release
22:12:00 <ChavGPT> just DOES NOT SCALE
22:13:00 <netbsduser`> it caused a major stink
22:13:00 <ChavGPT> kind of funny how magic testing failed to use it on a desktop innit
22:13:00 <heat> what
22:13:00 <ChavGPT> look mate, if you want i can show you a zfs data corruption bug by ahrens
22:13:00 <netbsduser`> testing what?
22:13:00 <netbsduser`> zfs is the last word in file systems
22:14:00 <ChavGPT> it would cause a stink if anybody was using it
22:14:00 <ChavGPT> heat: the bug was manifesting itself with crashing firefox
22:14:00 <ChavGPT> heat: or some other wtfbrowser
22:14:00 <ChavGPT> unless you mean a different bug
22:14:00 <ChavGPT> now that i mention it there was also stakc locking
22:15:00 <heat> no, the first bug report was a suse CI build of golang
22:16:00 <ChavGPT> and that bug was in stable?
22:17:00 <heat> yes
22:18:00 <ChavGPT> solid
22:18:00 <ChavGPT> lvm may suspend any logical volume anytime. If lvm suspend races with
22:18:00 <ChavGPT> unmount, it may be possible that the kernel writes to the filesystem after
22:18:00 <ChavGPT> unmount successfully returned.
22:19:00 <zid> because they sorted alphabetically
22:20:00 <heat> ChavGPT, this was the OG bug report:
22:22:00 <netbsduser`> jiri slaby, i remember that name
22:22:00 <netbsduser`> he got in trouble a few years ago for stripping the licence off openbsd's wifi drivers
22:23:00 <heat> good
22:23:00 <heat> we should strip openbsd off of openbsd
22:24:00 <ChavGPT> if i take a driver from openbsd, does it disappear from their tree?
22:25:00 <heat> i hope so
22:25:00 <heat> commit named "delete"
22:29:00 <Ermine> commit rm
22:29:00 <Ermine> err, commit "rm -rf ./*" when
22:29:00 <heat> yeah rm is probably a more openbsd commit name
22:29:00 <heat> the terser the better
22:29:00 <ChavGPT> make sure to not mention what
22:29:00 <heat> rule 1 of openbsd development: one must not be descriptive
22:29:00 <ChavGPT> literally "rm"
22:30:00 <ChavGPT> if you are feeling verbose you can "rm stuff"
22:30:00 <heat> if you're feeling particularly BSD you can play off rm as some new device's name
22:31:00 <heat> quick quiz what's rl(4)?
22:32:00 <ChavGPT> *not* realtek?
22:32:00 <heat> it is realtek
22:33:00 <zid> rotate left
22:33:00 <heat> you know what's also realtek? re(4)
22:33:00 <heat> there's also my favourite driver em(4) for the eminem PCIe adapter
22:33:00 <zid> rl meow.txt -> eow.txtm
22:34:00 <ChavGPT> ye man intel crads the best names
22:34:00 <ChavGPT> em igc igb
22:35:00 <gog> meow
22:35:00 * moon-child pets gog
22:35:00 * gog prr prprprrr
22:36:00 <ChavGPT> no nic driver named gog
22:36:00 * zid swaps gog's first and ultimate g
22:36:00 <zid> hahaha now you're called gog
22:36:00 <gog> my vid:did is 0420:6969
22:36:00 <ChavGPT> not only that
22:36:00 <ChavGPT> do you know the palindrome of gog?
22:36:00 <ChavGPT> it's gog
22:36:00 <ChavGPT> lol
22:37:00 * Ermine chokes from laughing
22:38:00 <heat> ChavGPT, pls explain why BSD people always refer to things by their man page name
22:38:00 <ChavGPT> it's an old idea therefore it's good
22:38:00 <heat> it's kind of(4) exausting(1) to(4) refer(3) to(4) shit(8) like(1) this(1)
22:38:00 <ChavGPT> lmao(69)
22:39:00 <ChavGPT> did you know solaris manpage sections also have a letter
22:39:00 <Ermine> rofl(420p)
22:39:00 <moon-child> to help you read(2) the fucking man(7)ual
22:39:00 <heat> BSD motherfuckers in talks about deep memory management will roll up and say "fork(2) is 1.1x faster"
22:40:00 <heat> (this is a lie, BSD motherfuckers do not talk about memory management, just vibes)
22:40:00 <Ermine> it will be funnier when it gets 0.9x faster
22:40:00 <heat> least pessimal BSD commit
22:40:00 <heat> or whatever they call it in CVS for those
22:41:00 <gorgonical> the rk3399 doesn't support ldaxr?
22:41:00 <gorgonical> wtf? lol
22:41:00 <Ermine> Maybe I should take a look at mm at onyx one day
22:41:00 <heat> go ahead
22:41:00 <heat> lots of it sucks and is due for a change
22:41:00 <gorgonical> my spinlock primitives are throwing implementation defined fault unsupp atomic insn
22:42:00 <bl4ckb0ne> isnt onyx a legend to scare the children
22:42:00 <Ermine> okay
22:42:00 <gorgonical> the more i use and learn about the rk3399 the less i like it
22:43:00 <heat> bl4ckb0ne, yeah it's to scare sortix users into not uninstalling
22:44:00 <bl4ckb0ne> frightening
22:44:00 <Ermine> booo!
22:45:00 <bl4ckb0ne> are sortix users the blue blokes that live in mushrooms
22:48:00 <heat> no they're the cloud people
22:48:00 <bl4ckb0ne> the same that run aws?
22:55:00 <zid> those are butt people
23:00:00 <bl4ckb0ne> are they related to the crab people
23:43:00 <Ermine> bl4ckb0ne: your nick is blue in my client btw
23:47:00 <bl4ckb0ne> im too tall to live in a mushroon