<nikolapdp>
though it would've rebooted anyway, i was mostly waiting for linux to let me bind the bloody port
<nikolapdp>
that's a great name
goliath has quit [Quit: SIGSEGV]
frkzoid has quit [Ping timeout: 260 seconds]
eschaton has quit [Remote host closed the connection]
eschaton has joined #osdev
<heat_>
wooo i can now swap out mapped pages
<heat_>
i am happy
navi has quit [Ping timeout: 272 seconds]
<Ermine>
conngrats
<chiselfuse>
geist: well navigating for this manual is kind of whack unlike the intel one. so if you can find a link to an official page that always serves the latest please send it to me. mine is revision 4.07 dated June 2023, all 5 volumes. https://0x0.st/XA2D.pdfnn
<heat_>
chiselfuse, if you don't like it just use the intel SDM *shrug*
<kazinsal>
the AMD manuals also have a lot of model specific bringup information iirc
<kazinsal>
so they can be pretty densely packed with stuff that makes you go "hwa"
<heat_>
aren't those the BKDG ones?
<heat_>
(rip)
<kazinsal>
yeah those were great
<zzo38>
Some of my ideas relating to operating system design: scorpion://zzo38computer.org/blog/c_OPERATING_SYSTEM_DESIGN.scorp
<bslsk05>
zzo38computer.org: 404 Not Found
<heat_>
what's a scorpion protocol
<chiselfuse>
heat_: i actually find the amd ones more intuitive. i just remember them not really having a page for them, just a weird js search thing with weird titles for documents
<zzo38>
Simple explanation: Use port 1517. Send R and then a space and then the full URL and then carriage return and line feed. A full explanation is available at scorpion://zzo38computer.org/specification.txt and is also available on GitHub as well.
<bslsk05>
zzo38computer.org: 404 Not Found
<chiselfuse>
compared to intel where they tell you what each document consists of
<zzo38>
I had also set up a NNTP for discussion of the operating system design that I was doing.
<chiselfuse>
zzo38: it only spits back the title of the document, not the bytes
<chiselfuse>
i'm tempted to </dev/urandom the telnet
<zzo38>
It is a binary file format (although the specification file is a plain text file, in order to avoid the problem that it is difficult to implement if you do not already have an implementation)
<zzo38>
The NNTP is: nntp://zzo38computer.org/un2.org.zzo38computer.osdesign
<bslsk05>
zzo38computer.org: 404 Not Found
<chiselfuse>
zzo38: i'm able to pull the spec but the c_OPERATING_SYSTEM_DESIGN.scorp is just two lines of text
<chiselfuse>
zzo38: is that a group on usenet that you have a proxy for available via nntp?
<zzo38>
No; it is a local newsgroup (although discussion can also be made on Usenet, and I have posted some there too)
<zzo38>
Also, c_OPERATING_SYSTEM_DESIGN.scorp is the Scorpion document file format (not a plain text file) and contains links to the actual articles.
<zzo38>
(The specification, a program to download (using this and many other protocols, including Gemini, etc) the files, and also the fonts, is also available on GitHub.)
<chiselfuse>
zzo38: well the links in the *.scorp file look like just titles, how can i use the as links?
<zzo38>
The specification file explains it, but as far as I know the programs to display the file are not completely written yet anyways
<chiselfuse>
w/e slrn failed to build
<zzo38>
I had also written some thing relating to operating system design on Usenet (at comp.os.misc) although some of my ideas have changed over time
<chiselfuse>
heat_: anyways it looks like this empty space couldn't be a redzone because in this picture the redzone is on the lower address side of the stack frame, whereas here the empty space is on the higher address side and not even all the way because it's crammed between rbx and the rest
<heat_>
no, it is the red zone
<heat_>
-96(%rbp) is below the stack and above -128(%rsp)
<heat_>
anyway it's late and i gtg
heat_ has quit [Ping timeout: 264 seconds]
janemba has joined #osdev
Gooberpatrol66 has quit [Quit: Konversation terminated!]
tomaw has quit [Remote host closed the connection]
tomaw_ has joined #osdev
tomaw_ is now known as tomaw
MiningMarsh has joined #osdev
<sortie>
Hello
* sortie
is speedrunning implementing POSIX.1-2024
<sortie>
Sortix actually advanced enough that a lot of POSIX 2024 was already implemented before it was even released
<nikolapdp>
how much is different between it and the previous one
<sortie>
People were laughing at me when I implemented O_CLOFORK back in the day, and now it's actually in POSIX, and I'm probably actually the first operating system to implement it.
<sortie>
nikolapdp: POSIX 2024 is honestly a mild upgrade to POSIX 2008, compared how POSIX 2008 was a big upgrade on POSIX 2001
<sortie>
There's a lot of goodies in here though. I'm still going through the pdf and noting down all the new stuff. They have tables of new stuff in there, which are wildly inaccurate, and lots of new stuff is in there that they don't say is new unless you look at individual CHANGE HISTORY sections
<sortie>
It's newly standardized, was an extension before
<zid>
memmemmmem isn't C? :o
<zid>
huh
<zid>
yea, HUGE GAP
<nikolapdp>
?
<sortie>
New POSIX 2024 features I already had in Sortix for a long time: getentropy, ppoll, qsort_r, reallocarray, strlcpy, strlcat, wcslcpy, wcslcat, dup3, pipe2, <endian.h>, O_CLOFORK, FD_CLOFORK, F_DUPFD_CLOFORK
<sortie>
nikolapdp: Yeah I'm making a list of stuff as scan through the standard
<nikolapdp>
nice
<nikolapdp>
oh are we getting more _r functions
<sortie>
Just qsort_r
<nikolapdp>
ah
<zid>
when do we get qsort as a gcc builtin
<nikolapdp>
my guess is no
<zid>
C++ people always make fun of C for it :(
<nikolapdp>
how so
<zid>
qsort slower than termplates
<nikolapdp>
lel
<sortie>
M_*l there's also a bunch of new long double constants, such as M_El with a high precision value of e
<zid>
it needs a builtin to work fast
<sortie>
neato bind to port 0 is now standardized as allocating a random port
<dostoyevsky2>
nikolapdp: Are you already porting docker to pdp11?
<nikolapdp>
why would i
<nikolapdp>
i don't even like docker
<dostoyevsky2>
idk bsd2.11 alone seems a bit boring in the long run, no?
<nikolapdp>
nope
<dostoyevsky2>
also, no systemd
<nikolapdp>
good
<dostoyevsky2>
I mean k8s won't even run without docker
<sortie>
There's also a new PTHREAD_NULL, looks like it's just (pthread_t) 0
<nikolapdp>
what's that for
<nikolapdp>
initializer?
<sortie>
A value that's unequal to any other thread id
<nikolapdp>
ah oki
<dostoyevsky2>
nikolapdp: If you had X11 then maybe 2024 could be the year of the pdp11 desktop
<sortie>
REG_MINIMAL is also new for regcomp, preferring the shortest leftmost match
<sortie>
SIGWINCH is now also standard which is nice (terminal size changed)
<sortie>
Literally implemented that earlier this week lol
<sortie>
Before I knew POSIX added it
netbsduser has quit [Ping timeout: 252 seconds]
xenos1984 has quit [Read error: Connection reset by peer]
goliath has quit [Quit: SIGSEGV]
<dostoyevsky2>
hmmm.. wikipedia lists Linux as mostly Linux compliant... I thought they'd be fully compliant
<nikolapdp>
linux is mostly linux compliant?
<dostoyevsky2>
erm... wikipedia lists Linux as mostly POSIX compliant
<nikolapdp>
heh
<nikolapdp>
i was wondering what linux compliance meant :P
<nortti>
gnu tooling makes some posix-noncompliant choices by default. see e.g. POSIXLY_CORRECT environment variable
<sortie>
dostoyevsky2, there are also some various system level interfaces where Linux does things slightly differently, sometimes intentionally because it's better, or due to historical accidents that cannot be fixed, or because they refuse to do what POSIX mandates
<dostoyevsky2>
Oh yeah, like sizes defaulting to 512bytes for df/du in POSIX
<sortie>
For instance, the Linux kernel mailing list has a whole discussion and the consensus is that they refuse to implement O_CLOFORK even though POSIX just standardized it
<bslsk05>
lore.kernel.org: Re: [PATCH v2] Implement close-on-fork - Matthew Wilcox
<bslsk05>
lore.kernel.org: Re: [PATCH v2] Implement close-on-fork - Al Viro
<sortie>
That is a big refusal though, most of it is more subtle differences
<sortie>
Plus then there's a ton of error conditions and subtle behaviors that the standard technically specifies which the implementations may not implement correctly
<sortie>
The standard is 4107 pages so no surprise if any implementation gets anything wrong even if they tried
<nortti>
including stuff that's unix-certified, as heat_'s filesystem testsuite has shown
<dostoyevsky2>
sortie: I always wondered how you are actually supposed to write portable shell scripts if there are always subtle differences between unix-like systems... so maybe posix actually might offer some guidance there
<sortie>
POSIX is a huge part of the solution there
<sortie>
POSIX defines a lot of the semantics of how the command line utilities work
<sortie>
These generally agree. It's usually just a few well known things like 512/1024 defaults that differ.
xenos1984 has joined #osdev
<sortie>
Although admittedly if you want to write a portable shell script, you usually end up relying on a few defaults that are consensus
<sortie>
*few details
<sortie>
E.g. POSIX has almost no opinion on the filesystem hiearchy
<sortie>
“Austin Group Defects 188 and 1394 are applied, changing getenv( ) to be thread-safe.” ← Oh hey getenv is thread safe now.
<mjg>
... :d
<mjg>
1. don't use getenv
<sortie>
getenv is fine
<mjg>
in a mt prog?
<mjg>
worst case you getenv your stuff upfront
<mjg>
and be done with it
<mjg>
there is nothing *sensible* a program can do for "mt-safe" state of getenv to be relevant
<sortie>
getenv is fine in a multi threaded program
<sortie>
It's setenv that's the problem in a multithreaded program
<nikolapdp>
well, using both
<sortie>
In such a program, you want to either carefully setenv after e.g. fork, or better yet, iterate environ and construct your own amended environment
<sortie>
nikolapdp: Two concurrent setenv's will also explode, even if getenv is never used
<nikolapdp>
true
<mjg>
setenv is my point
<mjg>
like wtf is either getenv implementation doing or the program doing for the "mt status" of that routine to matter
MiningMarsh has joined #osdev
<mjg>
any program trying to fuck with itself by calling setenv in one thread and getenv in another deserves to see arbitrary bs or crash
<mjg>
setenv is only of any use if you are about to exec
<sortie>
The important part is that POSIX defined that getenv is never safe in multi threaded programs, and now they define reality that it is actually safe if used correctly
<mjg>
on that front getenv is of any sensibility when you set up the program
<sortie>
So it's only setenv that is the unsafe one
<mjg>
do they explicitly specify mixing both does not work?
<zid>
so presumably to be compliant before, you had to getenv everything into a local copy before all the threads started, then implment your own thready setlocalenv?
<sortie>
They only need to say that setenv is not thread safe
<zid>
now you only need to do that if you use setenv, not if you use threads
<mjg>
all that env stuff is a shite concept anyway
<sortie>
The environment is a solution to particular problems
<mjg>
well the concept is not utterly bogus on its own, but the realities of hte implementiont definitely are
<mjg>
total classic with env is typos in var name
<sortie>
The environment is not a solution to most problems
<mjg>
which is impossible to check for
<zid>
yea I'm not sure you'd ever actually do what I described
<zid>
cus.. why fuckin bother
<sortie>
It is unfortunately a bit overused by people that should've used options or configuration files
<mjg>
yep
<zid>
It's useful for option injection into makefiles and stuff at least
<mjg>
fortunately we are at least past the era where env was inherited from /etc/init.d/apache start lol
<mjg>
or whatever the fuck you decided to start
<zid>
ld.so taking a bunch of env options is great
<mjg>
total classic: stuff works started from the shell, does not work on reboot
<mjg>
all of env stuff is self-induced trouble
<mjg>
i am not even going to rant about the loader
<sortie>
Oh hey MAP_ANON and MAP_ANONYMOUS are POSIX now
<mjg>
is posix even moving to a direction where you can write a fast network program in it
air has quit [Ping timeout: 268 seconds]
<dostoyevsky2>
so If I have multiple threads and they'd be using getenv/setenv as a k/v database to nosql between each other that would be possible now with the new posix 2024?
<mjg>
mon
<zid>
no because setenv is still no good
<mjg>
getenv and setenv code tends to be slower than faster
<mjg>
it is not meant to be used much
<zid>
but at least getenv is guarenteed to work if you don't do dumb shit!
<sortie>
mjg: Best it has to offer is ppoll
<mjg>
right
<mjg>
part of the point i'm making here is that posix can't provide a fast multiplexing routine
<sortie>
Which was sorely needed, so a poll main loop can also handle signals
<mjg>
the de facto standard is epoll becuase linux, but epoll is utter dogshit which even linux people concede
<mjg>
so you would need tomsething like kqueue
<mjg>
but good luck convincing linux to add it
<sortie>
mjg: In POSIX's defense, this is a good thing. It's up to BSD & Linux to build a good API and get consensus on it.
<mjg>
et voila, you will never be able to make a non-sucky posix program handling multiple fds
<sortie>
I promise it will be worse if POSIX invented an API for you.
<sortie>
posix_kpoll
<mjg>
it will never happen because linux got a "it is shite but ultimately works" api
<nikolapdp>
that's not wrong
<mjg>
sortie: general point being the standard is linux, continued posix existence is some committee cicrlejerk
<sortie>
mjg: Yeahj I disagree
<mjg>
linux can decide to nak anything they want and there it goes
<sortie>
They did do that with O_CLOFORK
<mjg>
well see O_CLOFORK for an example yhou linked yourself
<sortie>
It'll be interesting to see how that plays out
<mjg>
one dude over there had the right point: fork + exec is a shite model
<mjg>
so O_CLOFORK only deals with a self-induced problem
<sortie>
posix_spawn does exist
<mjg>
that's vfork + exec in practice
<mjg>
:d
<mjg>
i don't know how good that is even if not implemented like that
<mjg>
oooff spawn de facto requires the forking step?
<nikolapdp>
how so
<mjg>
The posix_spawn() and posix_spawnp() functions support a small, well-defined set of system tasks that the child process can accomplish before it executes the executable file.
<clever>
that reminds me, i was messing with risc-v32 musl nommu, and discovered a rather glaring flaw in linux (and musl)
<clever>
its nommu, so you must use vfork, no fork for you!
<clever>
1: musl lacked some vfork stuff on rv32, so it defaulted to standard fork()
<clever>
2: linux allowed that, trashed its own state, and paniced :P
<immibis>
mjg: it can be implemented as fork/stuff/exec, but it can also be implemented as a complete unit by the kernel
<sortie>
Sortix is probably the first system have MSG_CMSG_CLOFORK lol
<immibis>
compromise: all FDs are closed on exec except the ones you meant to keep, but FDs can be stored in environment variables
<mjg>
sortie: looks like solaris has it
<mjg>
when did you add it
<sortie>
mjg: 2021-12-28 it looks like (but probably older, file descriptor passing was WIP for many years) but OK that is because I didn't have file descriptor passing for the longest time
<sortie>
Alright that gets me through 270 pages of POSIX-1.2024 defining every single header in POSIX and I found all the new interfaces and definitions.
node1 has quit [Ping timeout: 250 seconds]
<sortie>
Fun fact: The official list of new POSIX functions is missing half of the new functions.
<immibis>
should have called it POFIVEANDAHALF
<sortie>
It really says something that off the top of my head I can tell whether any given symbol is in POSIX or not
<immibis>
i'll shut up now
<mjg>
so i think i got a decent idea
<mjg>
how to handle fds vs exec
<sortie>
20 commits today to implement POSIX 2024. Nice.
<mjg>
there could be a system call to create an empty file descriptor table, giving you a fd to interact with it
<mjg>
you could fcntl whatever fds you have into it
<sortie>
closefrom(2)
<mjg>
create whatever layout you want
<mjg>
finally when doing an exec or shit you would tell the kernel you already have a table and which fd represents it
<mjg>
there
<mjg>
arbitrary fucking state of the table sorted out
<mjg>
nobody sneaking in any fds unless you have code actively trying to fuck itsel over
<mjg>
... by modifying the new table in unwanted ways
<childlikempress>
posix 2024? they're still making new posixen? why??
<mjg>
ofc make it illegal to install the fd into it
<mjg>
fdt able it
<mjg>
childlikempress: maybe they are prepping to fuck up mutexes even mroe
<sortie>
Only change they did was pthread_mutex_clockwait which was a key improvement
<mjg>
nobody sane uses pthread mutexes mate
<sortie>
childlikempress: It's important to gradually evolve the standard, make some fixes to it, add stuff there's new consensus on among implementations, etc
<mjg>
who even claims to implement posix anymore
<mjg>
apart from solaris
<sortie>
That part is actually fairly irrelevant
<dostoyevsky2>
mjg: aix hpux irix
<mjg>
what makes it important to evolve the standard
<sortie>
Yes nobody actually gets those certs as far as I know
<sortie>
But the important part is that all of the community operating systems have a document to look to when there's disagreement on semantics
<sortie>
It also helps new players such as me get up to speed
<mjg>
if you want a speed up pass lkp
<mjg>
erm ltp
<sortie>
The biggest value is to people that want to write portable applications
<mjg>
this would be a great argument up until about 2005 or so
<mjg>
who cares now
<sortie>
Again, me.
<sortie>
Just because you don't see any value to you does not mean it doesn't have a big value
<sortie>
I ported over 80 pieces of key software to my OS
<mjg>
i am saying the people out there writing stuff only eer target linux
<sortie>
POSIX is why that is possible
<dostoyevsky2>
sortie: seems to be solved by newer programming languages to write more portable code
<mjg>
linux being quasi-posix is what made it possible
<sortie>
More or less, probably more on the less side
<sortie>
But rather that a lot of key programs *are still being written to be portable to operating systems in practice*
<sortie>
Say perl, python, or sshd doesn't compile on my OS? If I'm following POSIX, I can file a bug.
<sortie>
You gotta remember that 99% of software doesn't matter
<sortie>
So what there's a trash heap of Linux specific stuff?
<mjg>
if something like python cares about it that's interesting
<sortie>
Doesn't really matter
<childlikempress>
'can file a bug' only if perl/python/sshd claims to support posix
<mjg>
sshd being a bsd project and perl being an old yeller i see why they would are about some portability
<sortie>
childlikempress, generally every single piece of core operating system software cares about being portable to Linux and the BSDs
<mjg>
does posix copy_file_range?
<childlikempress>
posix compatible firefox when
<sortie>
childlikempress: Graphics is out of the scope of POSIX
<mjg>
ah the c standard route
<sortie>
Again these programs generally does not care about POSIX specifically, or restrict themselves to POSIX, but they care about being portable to the common operating systems.
<mjg>
i agree something rust runs on a surprising number of systems
<mjg>
pertyt niche at times even by bsd standards
<sortie>
So if they end up using a Linux extension, you can file a bug saying that's not in POSIX, and perhaps you can find a way to make it more POSIX compatible. Or you can implement the extension. I do that too.
<mjg>
but then if you check the amount of hacks in there you will see the posix thing is not thinging
<sortie>
What actually matters is "the consensus Unix interface where Linux & BSD agree"
<sortie>
It's a real thing that evolves as each system propose extensions and if they're any good, the other ones will implement them, and then sometimes those gets submitted to POSIX if there's consensus
<sortie>
A lot of the new stuff in POSIX 2024 is stuff that got consensus and then got standardized so the last remaining systems have to add it too
<dostoyevsky2>
> Very few BSD and Linux-based operating systems are submitted for compliance with the Single UNIX Specification, although system developers generally aim for compliance with POSIX standards, which form the core of the Single UNIX Specification.
<dostoyevsky2>
I wonder if they could do something about making more OpenSource OSes compliant also
<dostoyevsky2>
But I guess in practice it just works well enough
<childlikempress>
mjg: re mutex, tbh i don't care if posix fucks it up further; just spec futexes :P
<childlikempress>
actually c++ apparently has them, but they screwed it up :p
<heat_>
mornin linux useren
<mjg>
mornin?
<sortie>
Hello heat_
<heat_>
yes mjg it's 00:04
<sortie>
heat_, many new POSIX 2024 discoveries, I tagged you in a bunch
<heat_>
aka MORNING
<heat_>
i see there's a big backlog
<sortie>
heat_: I found wild things in there :D
<heat_>
>file lock
<heat_>
useless
<dostoyevsky2>
sortie: Wild things is exactly the stuff you want to find in standards
<heat_>
64-bit time_t is problematic on many systems but okay i guess
<sortie>
heat_: 32-bit time_t is gonna be problematic in (checks notes) 14 years so...
<dostoyevsky2>
Are any members of opensource OSes actually in the POSIX comittee?
<heat_>
yes
<heat_>
red hat has a guy
<heat_>
i think
<dostoyevsky2>
but they can't certify any linux/bsd as POSIX compatible?
<sortie>
Lest I give anyone here bad ideas, anyone can submit proposals to POSIX
<heat_>
linux is not POSIX compatible
<heat_>
sortie, yes and our love4boobies friend just made POSIX useless with O_CLOFORK
<mjg>
:d
navi has quit [Ping timeout: 268 seconds]
<sortie>
heat_: It remains to be seen how that plays out. I am curious.
<heat_>
if anyone is not stubborn and changes their mind frequently, it's linux maintainers!
<sortie>
If Linux refuses, they might end up putting it in an option
<heat_>
seriously what's LOG_UPTO
<heat_>
is it like LOG_UPDOG
<sortie>
Nothing much, you?
<heat_>
lol
<heat_>
is it actually a thing though?
<heat_>
it is. fuck that lol
<sortie>
<syslog.h> LOG_UPTO(pri) mask for all priorities from LOG_EMERG through pri inclusive in the order listed in the list of priority symbolic constants below. Any additional implementation-defined priorities not included in the list below shall not be included in the mask.
<dostoyevsky2>
sortie: I amma submit a batman() system call to let the OS project a bat symbol on the clouds, e.g. AWS or GCP or Azure
<heat_>
dostoyevsky2, also note that POSIX certification is near-useless and would mean you can't update any of the involved software
op has joined #osdev
<heat_>
and you also need to pay the big dollars to the cartel the great austin group
<sortie>
niht
<sortie>
heat_: Beself.
<heat_>
sortie, niht
<sortie>
heat will take it from here.
<mjg>
is DOCKER posix compliant?
<sortie>
is DOCKER a sandwich or soup?
<heat_>
is DOCKER a fruit or a vegetable
<sortie>
is DOCKER a container or a whale
<mjg>
what was first: webdev or docker
<heat_>
webdev
<dostoyevsky2>
mjg: I think you capslocked that sentence incorrectly
<heat_>
no dostoyevsky2 you need to pay us big dollars so you can get the certification testsuite for the DOCKER(TM) trademark
<heat_>
hth
<mjg>
are DOCKER containers posix-ceritified?
<mjg>
i am not running shit until they are
<heat_>
depends
<heat_>
adelie linux is trying to be POSIX certified i think
<mjg>
? :D
<dostoyevsky2>
mjg: Docker doesn't even run on posix-compliant OSes... It's linux only, if you run docker anywhere else it's wrapped into a linux vm
<mjg>
but the stuff inside might be only using posix interfaces
<heat_>
this branch is full of similar hacks to make it POSIX compliant, cuz the kernel surely isn't
<Ermine>
oh, mjgspeak got on urban dictionary?
<heat_>
quick someone add OPTIMAL and depessimize
<mjg>
dude
<mjg>
i picked up 'mon' from somewhere
<mjg>
just like 'depessimize' and some of the other stuff
<heat_>
al viro's school of english
<heat_>
plonk
<heat_>
or was it plop? whatever
<mjg>
that's where i picked up 'cunt'
<mjg>
plonk mofo
<mjg>
here is a mneominic for you
<mjg>
remember what you want to write and know it's the other thing
<mjg>
done
<heat_>
mneominic lol typo haha get owned
<mjg>
johny mnemonic
<mjg>
(actual movie too)
<mjg>
btw Ermine do you think 'mofo' is mjgspeak?
<mjg>
arguably 'mofer' is
<Ermine>
idr anyone else using either of those words
<Ermine>
so yes
<heat_>
i say mofer
<heat_>
checkmate
<Ermine>
you say OPTIMAL too
<mjg>
you picked it up from me dawg
<heat_>
depemissimize
<heat_>
depessimize
<mjg>
Ermine: 'mofo' is defo standard
<mjg>
haha typo lol owned
* Ermine
picks an illumos distro
<mjg>
('defo' is also standard)
<heat_>
i typo'd, my life is ruined smh
<mjg>
now which fucker came up with KERNAL
<mjg>
was not me
<heat_>
osdev forum trolls saying kernal
<Ermine>
some commodore mofer
<mjg>
mon
<Ermine>
:]
<heat_>
mon when are you and dalias clashing? i can't wait
<Ermine>
> The Open Source Enterprise Server OS with just the features you need
snappy has quit [Ping timeout: 252 seconds]
<heat_>
tell me in advance so i can go buy some popcorn
<Ermine>
yeah we need to get popcorn ready
<Ermine>
Now I wonder if anybody uses illumos in real world setups
<heat_>
yes
<zid>
If they did it wouldn't be a real world setup
<heat_>
oxide
<zid>
it'd be a toy setup
<Ermine>
So we can contact them and ask to use onyx instead
<heat_>
mr cantrill have you considered ditching your bad unix for mine? thanks
<mjg>
joyent used to... then samsung reprovisioned everything as linux
<mjg>
how did that happen
<heat_>
joyent lost its joy and became ent
<mjg>
the new illumos fork is named HELIOS
<Ermine>
sadgent
<mjg>
the one from oxide
<childlikempress>
bitches born after 1990 can't joy, all they know is ent😔
<zid>
what's ent
<Ermine>
f u bitch
<zid>
I'm born before 1990, shouldn't I know
<mjg>
i'm neither born after 1990 nor a bitch
<heat_>
mjg: isn't helios something else?
<mjg>
heat_: you may be thinking about their rust microkernel or some shit
<heat_>
i am
<mjg>
i don't remember how they call that
<Ermine>
s/rust/hare
<mjg>
probably bonwick's arse
<Ermine>
Drew's microkernel
<heat_>
bonwick's not with them :(
op has quit [Remote host closed the connection]
<mjg>
"hubris"
<heat_>
last i read bonwick went heavy into storage
<heat_>
and now he's like an investor or some shit
<mjg>
he made big bucks scamming EMC into buying it
<heat_>
it's what happens when you take the zfs crack
<mjg>
or maybe they scammed htemselves
<mjg>
it was not zfs
<zid>
ZFS users are 20x more likely to have suffered catastrophic data loss
<zid>
just saying
<mjg>
was some custom hw+sw solution for some weird-ass i/o setup
<zid>
correlation there
<mjg>
which turned out to not have any market for
* Ermine
downloads openindiana
<mjg>
it required the end application to explicitly know how to use it
<mjg>
Ermine: dafuq
<heat_>
indiana voted top 5 worst US states
<mjg>
and top 5 worst illumos distros
<Ermine>
there isn't OpenWest Virginia
<mjg>
(there are 5)
<Ermine>
and no OpenOregon
<heat_>
OpenUtah
<mjg>
there is however OpenAlabama
<heat_>
OpenOhio
<mjg>
i hear they have an init system in php
<Ermine>
Wait, are all OSen OpenOhio?
<heat_>
onyx is openutah
<heat_>
we do be soakin out here
<Ermine>
there are 9 illumos distros though
<heat_>
mjg, mon explain something
<mjg>
:O
<mjg>
nein
<heat_>
what kind of workload causes a cow chain/fork chain or whatever
<mjg>
some of that shit is de facto dead MON
<mjg>
heat_: you mean how do you end up with deep vm object chains?
<heat_>
yes
<heat_>
or analogous problems
<mjg>
to my undestanding this only happens with userspace actively trying to be PESSIMAL
<heat_>
what kind of workload does fork->fork->fork->fork->fork->fork
<heat_>
ok so why is it a big problem?
<mjg>
they *can* do it
snappy has joined #osdev
<Ermine>
Don't superservers fit the description?
<mjg>
what superservers
<heat_>
In the actual program (running as a daemon), a child is reading data
<heat_>
while its parent is processing the previously read data. At any time
<heat_>
exiting and new processes being fork()ed.
<heat_>
there are only a few processes in existence, with older processes
<Ermine>
they fork for each connection
<heat_>
i'm flabbergasted
<mjg>
Ermine: if they exit or exec after that's of no consequence
<Ermine>
never saw deep process trees
<heat_>
anyway i'm asking cuz linux has rediscovered this stupid problem (for anon_vmas and anon_vma_chains) quite a few times, in different forms
<mjg>
i don't know what linux is doing with anything there
<mjg>
i was talking ze bsd land
<mjg>
with ze mach vm
<heat_>
anon_vma_chain was a change around 2010 cuz "yoo what if you fork 1000 processes, and CoW a different page each process, now an anon page rmap lookup needs to go through 1000 processes!"
<heat_>
which is the kind of problem that makes me wonder wtf is up in the real world that these are real problems
Left_Turn has quit [Read error: Connection reset by peer]
<bslsk05>
'i n f i n i t e DRAGON DREAM FEET - The original' by LENNOZ (00:00:24)
<heat_>
and then in that message i posted, someone figured out that fork->fork->fork->fork->fork creates a deepening chain of anon_vmas (and they had to solve that)
<heat_>
somewhere they also realized linked lists are not okay and now they're using an interval tree, which is OPTIMAL but it again makes me wonder what the actual scale of these issues is
<bslsk05>
'Zlad! - Elektronik Supersonik (Official Video) [HD REUPLOAD]' by Working Dog Productions (00:03:05)
<heat_>
it is worth noting that this is anon memory hence FORK
<mjg>
i don't know of any legitimate usage where a forked process forks again and so on