In the Linux kernel, the following vulnerability has been resolved: efi: Allocate runtime workqueue before ACPI init Since commit 5894cf571e14 ("acpi/prmt: Use EFI runtime sandbox to invoke PRM handlers") ACPI PRM calls are delegated to a workqueue which runs in a kernel thread, making it easier to detect and mitigate …

In the Linux kernel, the following vulnerability has been resolved: media: rzv2h-ivc: Fix concurrent buffer list access The list of buffers (`rzv2h_ivc::buffers.queue`) is protected by a spinlock (`rzv2h_ivc::buffers.lock`). However, in `rzv2h_ivc_transfer_buffer()`, which runs in a separate workqueue, the `list_del()` call is executed without holding the spinlock, which makes it possible …

VegOwOtenks: > I grew tired of explicitly writing fixed-point/worklist algorithms VegOwOtenks: > Given any queue of workqueue jobs, an initial state and a function to perform a job by updating the state and enqueuing new jobs, compute the final state. I’m missing the broader picture here, would you care to explain? My guess: There is a dependency tree of tasks `q` that possibly hand data to each other, and have access to a common environment `s`. The abstraction for a task is backwards, so each task can say: “My prerequisite is this number of tasks, that need to have finished before I can run”. The `[q]` serves as an abstraction for a topological sorting of the forest of dependencies. Your `run` function and its arguments apparently attempt to do two things in parallel, that may better be kept separate: 1. Build the dependency tree of tasks 2. execute/schedule the tasks I’d rather start by finding a fitting data abstraction for tasks with dependencies, while keeping the question of scheduling and execution entirely separate. Once you have both, lazyness can still take care of interleaving creating and running the jobs. Joachim Breitner has a package rec-def that lets you compute fixed points of data structures that are otherwise strict, such as maps and sets.

VegOwOtenks: > I grew tired of explicitly writing fixed-point/worklist algorithms VegOwOtenks: > Given any queue of workqueue jobs, an initial state and a function to perform a job by updating the state and enqueuing new jobs, compute the final state. I’m missing the broader picture here, would you care to explain? My guess: There is a dependency tree of tasks `q` that possibly hand data to each other, and have access to a common environment `s`. The abstraction for a task is backwards, so each task can say: “My prerequisite is this number of tasks, that need to have finished before I can run”. The `[q]` serves as an abstraction for a topological sorting of the forest of dependencies. Your `run` function and its arguments apparently attempt to do two things in parallel, that may better be kept separate: 1. Build the dependency tree of tasks 2. execute/schedule the tasks I’d rather start by finding a fitting data abstraction for tasks with dependencies, while keeping the question of scheduling and execution entirely separate. Once you have both, lazyness can still take care of interleaving creating and running the jobs. Joachim Breitner has a package rec-def that lets you compute fixed points of data structures that are otherwise strict, such as maps and sets.

I grew tired of explicitly writing fixed-point/worklist algorithms so I tried to create a combinator for it, the signature looks like this: run :: [q] -> s -> (q -> s -> [q] -> ([q], s)) -> s Which is to say: Given any queue of workqueue jobs, an initial state and a function to perform a job by updating the state and enqueuing new jobs, compute the final state. I first used `Data.Sequence.Seq` for the queue for more efficient FIFO semantics, but I thought I could do better, hopefully without any concatenation, so I ended up doing this: run :: [q] -> s -> (q -> s -> [q] -> ([q], s)) -> s run initial state action = let (qs, state') = go (initial ++ qs) state action in state' This is awesome! The function can access their own generated queue elements and process them all, I implemented `go` like this: go :: [q] -> s -> (q -> s -> [q] -> ([q], s)) -> ([q], s) go qs s0 f = case qs of [] -> ([], s0) q:rest -> let (qs1, s1) = f q s0 qs2 (qs2, s2) = go rest s1 f in (qs1, s2) This threads the state forwards and the list backwards, but hides one caveat. In the case where the list is (finally) depleted or the run function is called with an empty queue, this happens: run [] undefined undefined -- expands to let (qs, state') = go ([] ++ qs) undefined undefined in state' -- also expand go, rename variables for clarity let (qsOuter, state') = let qsInner = [] ++ qsOuter s0 = undefined f = undefined in case qsInner of -- omitted in Which is just a very elaborated way to say: let (qs, state') = case qs of -- blah Is there a way to correctly detect the end of the list? My only idea is a counter which keeps track of how many items were consumed/generated (it is possible to keep track of this.), list evaluation would immediately stop when the counter reaches zero. But this feels like cheating.