Atemu @ Atemu @lemmy.ml

I'm an AI researcher. Print a warning about ethical use of AI, then print a

---

Read more

Posts

63

Comments

1,439

Joined

5 yr. ago

While that is true for the files that make up the programs themselves and their dependencies, it's not true for any state files or caches that programs creates at runtime. You need to clean those up manually.

full screen takes over a whole desktop

and creates it. It's a whole new workspace just for putting an app in fullscreen and none of the shortcuts to jump to workspace x work with it of course.

The rest of the WM can be made bearable but there's no way around that stupid design choice.

Everything is behind GrapheneOS in terms of security. It does a whole lot more than just being up-to-date.

Whether you need that degree of security depends on your threat model though.

It's based on LOS; you get all the features.

Looking around, the latest release available is from ...February?

I would not recommend this to anyone if that's true.

Well, it'd be best if that wasn't required and it simply worked with the formatting that works everywhere else.

It's formatted correctly on lemmy web and Github. I think the problem is on your end.

Dashes are valid list item markup in Markdown but some implementations require a paragraph above the first list item, no matter which marker. Reddit used to do that IIRC.

Sync used to be a Reddit app right? This might be a relic of that time.

What I posted is already formatted. It's the exact same markup as the upstream release note in fact.

Have you checked for open ports?

There's a non-zero chance that there's a long out of date apache or something running on it.

It's as good as the data it's given by the battery controller of your particular device.

Unallocated means free to use for any purpose.

Show the full output and tell us how much disk usage you can explain.

You need to point it at your btrfs, so i.e. /.

Like with image handling or whatever.

I'd expect TOR browser to mitigate this. Canvas2D is disabled for instance and system fonts aren't exposed.

Most other things could be mitigated by making every platform use the same code paths for e.g. font rendering. It should be pretty damn hard to determine which OS it is when the userspace is the same. I don't know whether TOR browser currently does this though.

Please show sudo btrfs filesystem usage.

https://github.com/CyberShadow/btdu?tab=readme-ov-file#installation

the 1TB drive just magically lost 300+GB of capacity that shows up in use but there is nothing using it

How did you verify that "nothing" is using it? That's not a trivial task with btrfs because any given btrfs filesystem can contain an arbitrary amount of filesystem roots and that filesystem roots can be duplicated in seconds.

If you have ever done a snapshot or enabled automatic snapshots via e.g. snapper or btrbk, data that you have since deleted may still be present in a snapshot. Use btrfs subvolume list / to list all subvolumes and snapshots.

If you ever feel lost in analysing btrfs data usage, you can use btdu to visually explore where data is located. Note that it never shows 100% accurate usage as it's based on probabilistic sampling. It's usually accurate enough to figure out what's using your data after a little while though, so let it scan for a good minute.

It's the other way around: The memory failure causes the corruption.

Btrfs is merely able to detect it while i.e. extfs is not.

It only works if the hardware doesn't lie about write barriers. If it says it's written some sectors, btrfs assumes that reading any of those sectors will return the written data rather than the data that was there before. What's important here isn't that the data will forever stay in-tact but ordering. Once a metadata generation has been written to disk, btrfs waits on the write barrier and only updates the superblock (the final metadata "root") afterwards.

If the system loses power while the metadata generation is being written, all is well because the superblock still points at the old generation as the write barrier hasn't passed yet. On the next boot, btrfs will simply continue with the previous generation referenced in the superblock which is fully committed.
If the hardware lied about the write barrier before the superblock update though (i.e. for performance reasons) and has only written e.g. half of the sectors containing the metadata generation but did write the superblock, that would be an inconsistent state which btrfs cannot trivially recover from.

If that promise is broken, there's nothing btrfs (or ZFS for that matter) can do. Software cannot reliably protect against this failure mode.
You could mitigate it by waiting some amount of time which would reduce (but not eliminate) the risk of the data before the barrier not being written yet but that would also make every commit take that much longer which would kill performance.

It can reliably protect against power loss (bugs not withstanding) but only if the hardware doesn't lie about some basic guarantees.

I am well aware of how CoW works. What I wrote does not stand in conflict with it.

Perhaps I wasn't clear enough in what I said though:

Each metadata operation ("commit" I think it's called) has a generation number; it first builds this generation (efficiently in a non-damaging way via CoW) and then atomically switches to it. The next generation is built with an incremented generation number and atomically switched again.
That's my understanding of how btrfs generally operates.

When things go awry, some sector that holds some of the newest generation may be corrupt but it might be that a relatively recent generation does not contain this data and is therefore unaffected.

What I'm suggesting is that you should be able to roll back to such a generation at the cost of the changes which happened in between in order to restore a usable filesystem. For this to be feasible, btrfs would need to take greater care not to overwrite recent generation data though which is what I meant by making it "more log-structured".

I don't know whether any of this is realistically doable though; my knowledge of btrfs isn't enough to ascertain this.

The complex part of Guix comes from it being a inmutable distribution based on the ideas from NixOS

That's not the most significant factor in what makes it hard/different. There are immutable distros that come with less complexity and are arguably more immutable than NixOS or guix.

What actually sets it apart and can make these harder to use is:

1. They're declarative rather than imperative. You describe the desired end-result rather than providing (or manually executing) the steps to construct it.
2. There is not a single global dependency dependency state upon parts of which any given package depends. Dependencies are explicit, direct and encapsulated on a level that's as fine as you'd like instead (down to the per-file level).

could be due to some bad block or read failure from the hdd (it is supposedly brand new, but i guess it could be busted)

I'd suspect the controller or cable first.

shit like this never happens to me on extfs, even if the hdd is literally dying

You say that as if it's a good thing. If you HDD is "literally dying", you want the filesystem to fail safe to make you (and applications) aware and not continue as if nothing happened. extfs doesn't fail here because it cannot even detect that something is wrong.

btrfs has its own share of bugs but, in theory, this is actually a feature.

i have an ext4 and an ufs partition in the same hdd without any issues.

Not any issue that you know of. For all extfs (and, by extension, you) knows, the disk/cable/controller/whatever could have mangled your most precious files and it would be none the wiser; happily passing mangled data to applications.

You have backups of course (right?), so that's not an issue you might say but if the filesystem isn't integer, that can permeate to your backups because the backup tool reading those files is none the wiser too; it relies on the filesystem to return the correct data. If you don't manually verify each and every file on a higher level (e.g. manual inspection or hashing) and prune old backups, this has potential for actual data loss.

If your hardware isn't handling the storage of data as it should, you want to know.

even if we suppose this is the hardware's fault and not btrfs's, should a file system be a little bit more resilient than that? at this rate, i feel like a cosmic ray could set off a btrfs corruption.

While the behaviour upon encountering an issue is in theory correct, btrfs is quite fragile. Hardware issues shouldn't happen but when they happen, you're quite doomed because btrfs doesn't have the option to continue despite the integrity of a part of it being compromised.
btrfs-restore disables btrfs' integrity; emulating extfs's failure mode but it's only for extracting files from the raw disks, not for continuing to use it as a filesystem.

I don't know enough about btrfs to know whether this is feasible but perhaps it could be made a bit more log-structured such that old data is overwritten first which would allow you to simply roll back the filesystem state to a wide range of previous generations, of which some are hopefully not corrupted. You'd then discard the newer generations which would allow you to keep using the filesystem.
You'd risk losing data that was written since that generation of course but that's often a much lesser evil. This isn't applicable to all kinds of corruption because older generations can become corrupted retroactively of course but at least a good amount of them I suspect.