8 ms·

RIP pthread_cancel

• whatifitoldyou 1y ago
  pthread_cancel is never the answer. Abrupt thread cancelation is always a risk for leaks and/or even worse, deadlocks. No matter of it was blocked in one libc function. The function is not one instruction you don't know what the poor thread was doing when it was killed.
• pizlonator 1y ago
  At first I wondered if musl does it better, so I checked, and the version I have disables cancellation in the guts of `getaddrinfo`. I've always thought APIs like `pthread_cancel` are too nasty to use. Glad to see well documented evidence of my crank opinion
  • pengaru 1y ago
    The asynchronous cancellation in particular is difficult to use correctly, but is also one of the most useful aspects of the api in situations where appropriate. Imagine cpu-bound worker threads that do nothing but consume work via condition variables and spend long periods of time in hot compute-only loops working on said work... Instead of adding a conditional in the compute you're probably not interested in slowing down at all, you turn on async cancellation and pthread_cancel() the workers when you need to interrupt what's going on. But it's worth noting pthread_cancel() is also rarely supported anywhere outside first-class pthreads-capable systems like modern linux. So if you have any intention of running elsewhere, forget about it. Thread cancellation support in general is actually somewhat rare IME.
    • epcoa 1y ago
      > But it's worth noting pthread_cancel() is also rarely supported anywhere outside first-class pthreads-capable systems like modern linux Having written some of the implementation for a non x86 commercial Unix well over 30 years ago now (yeah, I know), pthread_cancel is not that rare. A carve out like “modern linux” is io_uring or even inotify and epoll. AIX and HP-UX, fuck even OSF/1 had pthread_cancel. Windows has TerminateThread. Most RTOS have some kind of thread level task killing interface. While they have different semantics than pthread_cancel, that doesn’t really affect the example you’re giving - they can all be used for the “cpu-bound worker”
      • pizlonator 1y ago
        pthreads has `pthread_kill`, which is like `TerminateThread`. `pthread_cancel` is different
      • lll-o-lll 1y ago
        I’m not familiar with pthread_cancel, but I am with TerminateThread. It’s not something that can be used safely: ever. Raymond Chen has written a few times about it, including the history. > Originally, there was no Terminate­Thread function. The original designers felt strongly that no such function should exist because there was no safe way to terminate a thread, and there’s no point having a function that cannot be called safely. But people screamed that they needed the Terminate­Thread function, even though it wasn’t safe, so the operating system designers caved and added the function because people demanded it. Of course, those people who insisted that they needed Terminate­Thread now regret having been given it.
    • hedora 1y ago
      Assuming it’s OK to take 10msec to cancel, that conditional can be a well-predicted branch and a read of a cached memory address every 10msec. On a 1GHz processor, that’s a one cycle instruction that’s run every 10 million cycles. Unless the conditional or the cached read is the straw that breaks the back of the cache, there’s no way it’ll be measurable.
      • achierius 1y ago
        How do you insert a branch "every 10ms" without some sort of hardware-provided interrupt? If your code is running in a hot loop, you would have to insert that branch into the hot loop (even well-predicted branches add a few cycles, and can do things like break up decode groups) or have the hot loop bail out every once in a while to go execute the branch and code, which would mean tiling your interior hot loop and thus adding probably significant overhead that way. Also, you say "cached memory address" but I can almost guarantee that unless you're doing that load a lot more frequently than once every 10 milliseconds the inner loop is going to knock that address out of l1 and probably l2 by the time you get back around to it.
        • hedora 1y ago
          You put the check outside the innermost loop. Put it up one or two loops instead, and reason that the check runs frequently enough and also infrequently enough. Also, don’t you have to hit a pthread cancellation point for pthread_cancel to take effect? Those are way more expensive than a branch, but if you want the exact behavior, you could do “if (done) { break; } else { pthread_??? }”
          • pengaru 1y ago
            > Also, don’t you have to hit a pthread cancellation point for pthread_cancel to take effect? No, the whole point here is async cancellation - you don't test for it and you don't enter a cancellation point. Excerpt from pthread_setcancelstate(3): > Asynchronous cancelability > Setting the cancelability type to PTHREAD_CANCEL_ASYNCHRONOUS is rarely useful. > Since the thread could be canceled at any time, it cannot safely reserve resources > (e.g., allocating memory with malloc(3)), acquire mutexes, semaphores, or locks, and > so on. Reserving resources is unsafe because the application has no way of knowing > what the state of these resources is when the thread is canceled; that is, did cance- > lation occur before the resources were reserved, while they were reserved, or after > they were released? Furthermore, some internal data structures (e.g., the linked > list of free blocks managed by the malloc(3) family of functions) may be left in an > inconsistent state if cancelation occurs in the middle of the function call. Conse- > quently, clean-up handlers cease to be useful. > > Functions that can be safely asynchronously canceled are called async-cancel-safe > functions. POSIX.1-2001 and POSIX.1-2008 require only that pthread_cancel(3), > pthread_setcancelstate(), and pthread_setcanceltype() be async-cancel-safe. In gen- > eral, other library functions can't be safely called from an asynchronously cance- > lable thread. > > One of the few circumstances in which asynchronous cancelability is useful is for > cancelation of a thread that is in a pure compute-bound loop.
    • sthustfo 1y ago
      asynchronous cancellation (when compared to deferred) is only recommended in scenarios where the thread does not share any data, semaphore or conditional variables with other threads. The target thread tends to cleanup any data within the thread cleanup handlers via pthread_cleanup_pop(). If not, the entire application might end up going down. Async cancellation has a very narrow application scope imho.
• rwmj 1y ago
  Netscape used to start a new thread (or maybe it was a subprocess?) to handle DNS lookups, because the API at the time (gethostbyname) was blocking. It's kind of amazing that we're 30 years on and this is still a problem.
  • fpoling 1y ago
    In 1996 it was a subprocess. Linux Threads appeared only later that year.
  • nly 1y ago
    If you want DNS resolution to obey user/system preferences then you need to use the system provided API
    • rwmj 1y ago
      For sure! The only problem is there should be a non-blocking system-provided API and there isn't.
      • foota 1y ago
        System provided is maybe a strange word to use here since getaddrinfo is a libc function, not a system call.
        • rwmj 1y ago
          POSIX as the system, of course.
        • froh 1y ago
          the system API is not syscalls but libc. so why does it feel strange?
    • Seattle3503 1y ago
      In this case it isn't in the kernel, but in glibc. Could someone implement an equivalent alternative? Do any language runtimes re-implement DNS resolution?
• Aardwolf 1y ago
  Maybe this is naive, but could there just be some amount of worker threads that run forever, wait for and take jobs when needed, and message when the jobs are done? Don't need to be canceled, don't block
  • danappelxx 1y ago
    If the DNS resolution call blocks the thread, then you need N worker threads to perform N DNS calls. Threads aren’t free, so this is suboptimal. OTOH some thread pools e.g. libdispatch on Apple operating systems will spawn new threads on demand to prevent starvation, so this _can_ be viable. Though of course this can lead to thread explosion which may be even more problematic depending on the use case. In libcurl’s situation, spawning a million threads is probably even worse than a memory leak, which is worse than long timeouts. In general, what you really want is for the API call to be nonblocking so you’re not forced to burn a thread.
  • ComputerGuru 1y ago
    This is, essentially, what the previous (largely pathetic) excuse for true asynchronous I/O on Linux did with the libc aio(7) interface to essentially fake support for truly asynchronous file IO. It wasn’t great.
  • variadix 1y ago
    Yeah, I’m not sure I see the problem (other than that threads are more expensive than e.g. file descriptors, but this is a moot point without a better API). You define how many requests in flight you want to allow and that sets the cap on how many worker threads you spawn/use, you could also support an unbounded number in flight this way by lazily spawning worker threads per requests. Cancellation/kill interfaces for multithreading are pretty much always a footgun. Even for multiprocessing on modern machines, if you’re doing something non-trivial and decide to use SIGKILL to terminate a worker process, it’s easy to leave e.g. file system resources in a bad state.
• nly 1y ago
  Why is running the DNS resolution thread a problem? It should be dequeuing resolution requests and pushing responses and sleeping when there is nothing to do When someone kills off the curl context surely you simply set a suicide flag on the thread and wake it up so it can be joined.
  • rwmj 1y ago
    One problem may be that fork() kills background threads, so now any program that uses libcurl + fork has to have a new API to restart the DNS thread (or use posix_atfork which is a big PITA), and that might break existing programs using curl.
    • loeg 1y ago
      A surmountable problem, sure.
      • rwmj 1y ago
        Sometimes. To give one counterexample, golang doesn't have a way to restart the threads it uses for I/O (apparently a decision the golang developers made), so if you're embedding golang code in another binary, it better not call fork. (The reason for this warning: https://gitlab.com/nbdkit/nbdkit/-/commit/2589e6da40939af9aea16a488e8f2aec411f3c5c https://gitlab.com/nbdkit/nbdkit/-/commit/2589e6da40939af9ae...)
        • loeg 1y ago
          This is a policy choice of Golang, but a C library like Curl (the topic of this thread) is not constrained by the policy choices of the Go developers. Curl could use MADV_WIPEONFORK or other primitives to restart its DNS thread automatically.
    • ComputerGuru 1y ago
      It’s not too much of an exaggeration to say that everything about using fork() instead of vfork() plus exec() is essentially fundamentally broken in modern osdev without a whole stack of hacks to try and patch individual issues one-by-one.
• throwaway81523 1y ago
  There might be a way to getaddrinfo asynchronously with io_uring by now. Otherwise just call the synchronous version in another thread and let it time out so the thread exits normally, right? Why bother with pthread_cancel?
  • 1over137 1y ago
    io_uring is a linux-ism, curl is cross-platform.
  • loeg 1y ago
    io_uring is for calling kernel APIs; this is a userspace API.
  • yxhuvud 1y ago
    No. Getaddrinfo is libc, not the kernel. It is of course possible, but complicated, to implement dns resolution with io_uring, but making it behave the same as glibc is very much a nontrivial piece of work.
  • gary_0 1y ago
    The problem is that the standard library function is specified to be blocking (and it's in userspace, so io_uring is not relevant). It's quite possible to do a non-blocking DNS lookup but you have to use a separate non-standard library (like c-ares).
• Someone 1y ago
  > Then it needs to sort them if there is more than one address. And in order to do that it needs to read /etc/gai.conf I don’t see why glibc would have to do that inside a call to getaddrinfo. can’t it do that once at library initialization? If it has to react to changes to that file while a process is running, couldn’t it have a separate thread for polling that file for changes, or use inotify for a separate thread to be called when it changes? Swapping in the new config atomically might be problematic, but I would think that is solvable. Even ignoring the issue mentioned it seems wasteful to open, parse, and close that file repeatedly.
  • loeg 1y ago
    I think the libc people might argue this level of functionality is just outside the scope of libc. (Arguably, it is a mistake for DNS to be part of libc, given how complicated it is.)
    • ComputerGuru 1y ago
      To be sure, complexity isn’t the determinator for whether something is or isn’t in scope for libc though.
      • loeg 1y ago
        Historically libcs have been leery of imposing threading on otherwise singlethreaded applications; and for similar reasons, try to minimize startup costs.
    • Someone 1y ago
      https://sourceware.org/glibc/ https://sourceware.org/glibc/ says “The GNU C Library is designed to be a backwards compatible, portable, and high performance ISO C library. It aims to follow all relevant standards including ISO C11, POSIX.1-2008, and IEEE 754-2008.” ⇒ I don’t think they make that argument.
      • loeg 1y ago
        The standards make no requirement that an implementation be good, performant, or even useful.
• jart 1y ago
  Why can't they help fix the C library in question? Cancelation is really tricky to implement for the C library author. It's one of those concepts that, like fork, has implications that pervade everything. Please give your C library maintainers a little leeway if they get cancelation wrong. Especially if it's just a memory leak.
  • RedShift1 1y ago
    I'm betting this code is so old and its behavior so ingrained everywhere else that nobody dares touching it.
    • jart 1y ago
      No it sounds like they just need to add a pthread_cleanup_push() call somewhere in the getaddrinfo() implementation. C libraries are not black magic. Nor are they holy code. We needn't fear them. It's the simplest part of the software stack.
• gary_0 1y ago
  [deleted]
  • okl 1y ago
    https://c-ares.org/ https://c-ares.org/
    • deleted 1y ago
      [deleted]
• comex 1y ago
  pthread_cancel is not a good design because it operates entirely separately from normal mechanisms of error handling and unwinding. (That is, if you’re using C. If you’re using C++ it can integrate with exception handling.) A better approach would have been to mimic how kernels internally handle signals received during syscalls. Receiving a signal is supposed to cancel the syscall. But from the kernel’s perspective, a syscall implementation is just some code. It can call other functions, acquire locks, wait for conditions, and do anything else you would expect code to do. All of that needs to be cleanly cancelled and unwound to avoid breaking the rest of the system. So it works like this: when a signal is sent to a thread, a persistent “interrupted” flag is set for that thread. Like with pthread_cancel, this doesn’t immediately interrupt the thread, but only has an effect once the thread calls one of a specific set of functions. For pthread_cancel, that set consists of a bunch of syscalls and other “cancellation points”. For kernel-internal code, it consists of most functions that wait for a condition. The difference is in what happens afterwards. In pthread_cancel’s case, the thread is immediately aborted with only designated cleanups running. In the kernel, the condition-waiting function simply returns an error code. The caller is expected to handle this like any other error code, i.e. by performing any necessary cleanup and then returning the same error code itself. This continues until the entire chain of calls has been unwound. Classic C manual error handling. It’s nothing special, but because interruption works the same way as regular error handling, it‘s more likely to “just work”. Once everything is unwound, the “interrupted” flag is cleared and the original signal can be handled. (The error code for interruption is usually EINTR, but don’t confuse this with EINTR handling in userspace, which is a mess. The difference is because userspace generally doesn’t want to abort operations upon receiving EINTR, and because from userspace’s perspective there’s no persistent flag.) pthread_cancel could have been designed the same way: cancellation points return an error code rather than forcibly unwinding. Admittedly, this system might not work quite as well in userspace as it does in kernels. Kernel code already needs to be scrupulous about proper error handling, whereas userspace code often just aborts if a syscall fails. Still, the system would work fine for well-written userspace code, which is more than can be said for pthread_cancel.
  • jcarrano 1y ago
    In libdill, cancelling a coroutine makes all blocking calls on that routine return immediately with ECANCELED. The code must check this condition and exit any loop and so eventually the coroutine finishes, having released all resources in the process.
• yardstick 1y ago
  It’s been decades, why doesn’t getaddrinfo have a standardised way to specify a timeout? Set a timeout to 10 seconds and life becomes a lot easier. Yes I know in Linux you can set the timeout in a config file. But really the dns setting should be configurable by the calling code. Some code requires fast lookups and doesn’t mind failing which, while others won’t mind waiting longer. It’s not a one size fits all thing.
  • o11c 1y ago
    On Linux you can do what you're asking with `getaddrinfo_a` + `gai_suspend`. As always, on non-Linux Unixen the answer is "screw you!"
    • surajrmal 1y ago
      The fact that a library as polific as libcurl doesn't use it and tried to resort to pthread_cancel, known to have serious problems, points to a larger problem. Either posix needs to incorporate an async getaddrinfo or there is an education problem that needs to be addressed.
    • sedatk 1y ago
      Just wanted to note that Windows doesn't have that problem either. Even Windows NT had async getaddrinfo() variants.
    • BobbyTables2 1y ago
      Wow, TIL ! Thanks!
    • throwawayoogux 1y ago
      OpenBSD has getaddrinfo_async since 5.6 (March 2014).
  • ComputerGuru 1y ago
    I disagree, there are too many variables and ultimately the end user would be th one that knows best. The proper solution isn’t having the library or application dev, who has no idea what kind of network connection the user is running, the type of dns server (caching or not, lan or remote, etc) or the name servers of the target domain and their performance or availability. This is all really the domain of the sysadmin. The solution is to make it a properly non-blocking api.
• albertzeyer 1y ago
  Why not use getaddrinfo_a / getaddrinfo_async_start / GetAddrInfoExW? Or just use some standalone DNS resolve code or library (which basically replicates getaddrinfo but supports this in an async way)? See also here the discussion: https://github.com/crystal-lang/crystal/issues/13619 https://github.com/crystal-lang/crystal/issues/13619
  • eliaspro 1y ago
    A standalone library would have to work with all the existing system facilities (e.g. NSS on Linux systems) to be not restricted to just resolv.conf entries, but to allow for all the various other methods of resolving names.
    • flopsamjetsam 1y ago
      libcurl's c-ares support would fit the bill?
• charcircuit 1y ago
  Why isn't DNS in a service on the operating system instead of libc? You'll want requests to be locally cache anyways. This also makes it easier to just abandon a RPC instead of stopping a thread you don't control.
  • cesarb 1y ago
    > Why isn't DNS in a service on the operating system instead of libc? On modern Linux systems, it is: systemd-resolved (https://www.freedesktop.org/software/systemd/man/latest/systemd-resolved.service.html https://www.freedesktop.org/software/systemd/man/latest/syst...) is a system service which can be queried through RPC (using dbus or varlink), through the traditional glibc APIs (using a NSS plugin), or even by being queried on the loopback interface as if it were a normal recursive DNS server (for compatibility with software which bypasses glibc and does direct DNS queries).
    • charcircuit 1y ago
      Well from the blogpost it looks like calling it via glibc does extra work than just querying the service.
    • kelnos 1y ago
      Not sure how standard that is, though. E.g. on Debian systemd-resolved isn't even installed by default, let alone enabled and set up as the default resolver.
• pajko 1y ago
  This is clearly an implementation error in getaddrinfo(). It should set up cleanup functions: https://man7.org/linux/man-pages/man3/pthread_cleanup_push.3.html https://man7.org/linux/man-pages/man3/pthread_cleanup_push.3...
• hacker_homie 1y ago
  what's old is new again, I loved java in the early 2000's trying to remotely stop a thread Thread.destroy() Thread.stop() Thread.suspend() so much potential for corrupted state.
• senderista 1y ago
  Relevant for Linux: https://www.imperialviolet.org/2005/06/01/asynchronous-dns-lookups-with-glibc.html https://www.imperialviolet.org/2005/06/01/asynchronous-dns-l...
• blaz0 1y ago
  I'm the author of the GitHub issue that the blog links to, and I'd like to thank Stefan for quickly acknowledging the problem and addressing the issue! I try to keep one of our internal applications up to date with the latest libcurl version within a day or two of a release, so we sometimes hit fresh problems while running our battery of tests. Ironically, our application has also struggled with blocking DNS resolution in the past, so I appreciate the discussion here. In case anyone is interested, here is a quick reference of the different asynchronous DNS resolution methods that you can use in a native code application for some of the most popular platforms: - Windows/Xbox: GetAddrInfoExW / GetAddrInfoExCancel - macOS/iOS: CFHostStartInfoResolution / CFHostCancelInfoResolution - Linux (glibc): getaddrinfo_a / gai_cancel - Android: android.net.DnsResolver.query (requires the use of JNI) - PS5: proprietary DNS resolver API
  • somat 1y ago
    If we are doing a survey. I found a few more. It feels like we need to get everyone together in a room and say "we will let you out when you decide on a standard non-blocking address lookup" What a mess. - OpenBSD: getaddrinfo_async / asr_abort https://man.openbsd.org/asr_run - FreeBSD: dnsres_getaddrinfo / found no way to abort https://man.freebsd.org/cgi/man.cgi?query=dnsres
  • jnwatson 1y ago
    As the article mentions, why not just delegate it to a library dedicated to the solution? c-ares is a solid, well-maintained library.
    • JosifA 1y ago
      Unfortunately, c-ares is not problem-free on all platforms. On iOS, its use triggers a local network access popup (it tries to reach your DNS server, which is often on your LAN). If a user denies acess, your app will simply not work. On Android, it's not compatible with some VPN apps. Those apps are to blame, but your users are going to blame you not them. So, at my previous company we ended up building libcurl with a threaded DNS resolver on both iOS and Android.
  • 1y ago
• enva2712 1y ago
  i’ve run into this issue with pthread_cancel it makes cleanup logic convoluted when you can’t easily pthread_cleanup_push, forcing you to either block on the join or signal cancellation and detach
• deleted 1y ago
  [deleted]
• rurban 1y ago
  Just use c-ares. Threads with signals are evil
• juliangmp 1y ago
  I feel like the entire pthread_cancel and cancellation point feature is only really useful when your application is exiting and resource management doesn't matter anymore. If you want to use it on a long running process, the thread that gets canceled must effectively be completely free of any resource allocation.... Unless of course you're making use of shared memory between processes, then you could still leak even when the entire process is shut down.