Tagged “linux”

A Systemd Unit That Refused To Stay Dead

The systemd Unit That Refused to Stay Dead

Moving Root Onto ZFS

The Service That Wouldn't Stay Stopped

A Kernel Panic I Could Actually Reproduce

A Runaway Process, And The cgroup That Caught It

When logrotate Wins the Rotation but Loses the Logs

cgroups v2 and a Runaway Process

how cgroups v2 caught a runaway before it took the box down

making peace with rootless podman

how much swap, and why i stopped arguing about it

a kernel panic that finally held still long enough to catch

when journald quietly ate forty gigabytes

moving root onto zfs and not regretting it

the day journald quietly ate forty gigabytes

when journald quietly ate twelve gigs

how much swap, finally answered for my own boxes

moving root onto zfs without losing my nerve

the year i stopped writing iptables rules by hand

when the writeback storm hits and everything stalls

the process that ate a box and the cgroup that didn't

stopping journald from eating the disk

the service that wouldn't die, and the restart loop that hid it

poking at io_uring for an afternoon

moving root onto zfs without losing my nerve

the rollback that turned a bad upgrade into a non-event

taming journald disk usage

how much swap, and the answer nobody on the internet agrees on

running containers rootless without it ruining my week

putting a runaway process back in its box with cgroups v2

when the box freezes for a second, look at dirty_ratio

when the writeback stalls everything

a kernel panic i could actually reproduce

when journald ate half my root partition

a kernel panic i could actually reproduce

io_uring, and the joy of not making a syscall per read

rootless containers, and making peace with subuid

the process that ate the box, and the cgroup that fenced it in

the app that kept writing to a deleted log file

nftables instead of iptables, finally

yes i still run swap, even with plenty of ram

when the page cache fights back

how btrfs snapshots gave me my weekend back

btrfs snapshots saved my weekend

rewriting the firewall in nftables

when a busy box stalls every thirty seconds, look at dirty_ratio

when the app won't reopen its logs

i finally moved the firewall to nftables

the runaway process that cgroups v2 quietly contained

the day journald ate the root partition

the systemd unit that would not stay dead

putting root on zfs, and why i would do it again

the service that would not die

putting a leash on a process that ate the box

the rare gift of a kernel panic that reproduces on demand

when logrotate quietly stops working because the app won't reopen

rootless podman, and the uid map that finally clicked

when logrotate and your app disagree about SIGHUP

how much swap does a homelab actually need

when logrotate and a deaf daemon disagree

a btrfs snapshot bought back my saturday

when the write cache fights back: tuning dirty_ratio

stop letting journald eat your root partition

the service that would not die

rootless podman without the rage

stopping journald from eating the disk

when one process ate the box, and cgroups v2 finally fenced it in

btrfs snapshots saved my weekend

a fence round the process that kept eating the box

moving root onto zfs and not regretting it

the service that resurrected itself every ten seconds

the log file that grew forever because nobody told the app

moving root onto zfs and not regretting it

i finally moved off iptables

the afternoon one PHP worker tried to eat the box

logrotate did its job, the app kept writing to a deleted file

i finally rewrote my firewall in nftables

rootless containers without losing my mind

the runaway process that cgroups v2 caught for me

the log that wouldn't rotate

the journal grew until the disk noticed

the rollback that turned a disaster into a five minute job

stop journald from eating the disk

rootless containers, and the few things that bite

taming journald disk usage

the swap debate, settled for my homelab

getting rootless containers working without losing my mind

i finally moved off iptables, and it was overdue

when the box freezes for a second every minute

caging a runaway process with cgroups v2

how much swap, and why i stopped arguing about it

a btrfs snapshot turned a wrecked upgrade into a five-second rollback

the app that politely ignored logrotate

taming writeback with dirty_ratio

the rare luxury of a kernel panic that came back on demand

the bits of root-on-zfs nobody warns you about

moving root onto zfs and not regretting it

how much swap, and why i stopped arguing about it

how much swap, and why i finally stopped arguing about it

when logrotate works but the app keeps writing to the deleted file

the long version: why your write-heavy box stalls, and how to stop it

the page cache was lying to me about disk writes

when a snapshot turned a ruined saturday into a five-minute rollback

putting root on zfs, and what i actually gained

the service that wouldn't stay stopped

when journald quietly ate a third of the disk

i finally made my peace with swap

the runaway process, revisited: cpu and io weights in cgroups v2

cgroups v2 and a runaway process

when the writeback stalls everything

a runaway process and the cgroup that caught it

capping a runaway with one cgroups v2 line

a kernel panic that did me the courtesy of being repeatable

i finally moved my firewall to nftables

the rollback that turned a disaster into a footnote

the log that kept growing after rotation

how much swap, and the answer i finally stopped arguing about

when logrotate wins and the app keeps writing to the old file

io_uring, first impressions

the panic that turned up on demand

stop the kernel hoarding dirty pages

rootless containers, and the subuid rabbit hole

the night a build job ate the whole machine

a kernel panic I could actually reproduce

moving the firewall to nftables, at last

the unit that would not die

a systemd unit that refused to stay dead

i finally moved off iptables, and i'm not going back

when a box stalls every thirty seconds, look at dirty_ratio

putting root on zfs without regretting it

yes, i still give my servers swap

putting root on zfs, and why i finally bothered

the one panic that didn't waste my week

the panic that only showed up under load

a first poke at io_uring

the service that kept coming back

how much swap, then? what i actually do on my own boxes

the systemd unit that would not stay dead

when a write-heavy box stalls every thirty seconds

io_uring, first impressions from the bleeding edge

poking at io_uring on a fresh kernel

the rare gift of a kernel panic you can reproduce

how much swap, and the answer i stopped arguing about

switching to nftables, at last

i moved a firewall to nftables and stopped flinching

when logrotate wins the battle and the app keeps writing to the old file

the swap question, and why zram quietly won me over

yes i still run swap, and here is the one setting that matters

the log file that grew forever no matter what logrotate did

the rare gift of a kernel panic that happened on demand

moving the firewall to nftables, at long last

the unit that came back from the dead, repeatedly

journald ate the disk again, so i bounded it

i finally moved a box from iptables to nftables

when the journal quietly ate the disk

how much swap, and why i stopped arguing about it

when a busy box stalls every thirty seconds, look at dirty_ratio

moving root onto zfs, and the boot snag nobody warns you about

cgroups v2 caught the thing cgroups v1 kept letting through

io_uring is the async i/o interface linux always needed

the service i could not convince systemd to stop restarting

moving my root filesystem onto zfs without losing my nerve

when too much page cache becomes a problem

the service that wouldn't stay stopped

the service that came back from the dead every ten seconds

when the write-back stalls: tuning dirty_ratio on a busy box

when logrotate and a stubborn daemon disagree

a kernel panic with the decency to be repeatable

journald ate the disk, here is the one line that stops it

how much swap, asked for the hundredth time

a botched upgrade, and the btrfs snapshot that undid it in seconds

when the box freezes for five seconds and writeback is to blame

a botched upgrade, and the snapshot that undid it

penning in a runaway process with cgroups v2

stopping journald from eating the disk

tuning dirty_ratio on a box that writes a lot

a kernel panic i could actually reproduce

switching root onto zfs, carefully

when writeback stalls everything, look at dirty_ratio

moving the firewall to nftables, finally

a systemd unit that refused to stay dead

when logrotate and a stubborn daemon disagree

moving a small firewall from iptables to nftables

when logrotate rotates the file and the app keeps writing to nowhere

one rollback and the weekend was mine again

moving root onto zfs, and why i'd do it again

how much swap, and why I stopped arguing about it

the btrfs snapshot that turned a bad upgrade into a five-minute fix

getting the systemd journal to stop eating the disk

the service that kept coming back from the dead

when logrotate and a stubborn daemon disagree

how much swap, and why i stopped arguing about it

putting root on zfs and not regretting it

the log file that grew to forty gigabytes

moving a box from iptables to nftables at last

stopping journald from eating the disk

moving my root filesystem onto zfs

moving root onto zfs without losing my nerve

the day journald quietly ate the disk

logrotate vs the app that wouldn't let go

the weekend btrfs snapshots earned their keep

moving a root filesystem onto zfs on linux