libcore/luni/src/main/native/AsynchronousSocketCloseMonitor.cpp

   1 /*
   2  * Copyright (C) 2010 The Android Open Source Project
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #define LOG_TAG "AsynchronousSocketCloseMonitor"
  18
  19 #include "AsynchronousSocketCloseMonitor.h"
  20 #include "cutils/log.h"
  21
  22 #include <errno.h>
  23 #include <signal.h>
  24 #include <string.h>
  25
  26 /**
  27  * We use an intrusive doubly-linked list to keep track of blocked threads.
  28  * This gives us O(1) insertion and removal, and means we don't need to do any allocation.
  29  * (The objects themselves are stack-allocated.)
  30  * Waking potentially-blocked threads when a socket is closed is O(n) in the total number of
  31  * blocked threads (not the number of threads actually blocked on the socket in question).
  32  * For now at least, this seems like a good compromise for Android.
  33  */
  34 static pthread_mutex_t blockedThreadListMutex = PTHREAD_MUTEX_INITIALIZER;
  35 static AsynchronousSocketCloseMonitor* blockedThreadList = NULL;
  36
  37 /**
  38  * The specific signal chosen here is arbitrary.
  39  */
  40 static const int BLOCKED_THREAD_SIGNAL = SIGRTMIN + 2;
  41
  42 static void blockedThreadSignalHandler(int /*signal*/) {
  43     // Do nothing. We only sent this signal for its side-effect of interrupting syscalls.
  44 }
  45
  46 void AsynchronousSocketCloseMonitor::init() {
  47     // Ensure that the signal we send interrupts system calls but doesn't kill threads.
  48     // Using sigaction(2) lets us ensure that the SA_RESTART flag is not set.
  49     // (The whole reason we're sending this signal is to unblock system calls!)
  50     struct sigaction sa;
  51     memset(&sa, 0, sizeof(sa));
  52     sa.sa_handler = blockedThreadSignalHandler;
  53     sa.sa_flags = 0;
  54     int rc = sigaction(BLOCKED_THREAD_SIGNAL, &sa, NULL);
  55     if (rc == -1) {
  56         LOGE("setting blocked thread signal handler failed: %s", strerror(errno));
  57     }
  58 }
  59
  60 void AsynchronousSocketCloseMonitor::signalBlockedThreads(int fd) {
  61     ScopedPthreadMutexLock lock(&blockedThreadListMutex);
  62     for (AsynchronousSocketCloseMonitor* it = blockedThreadList; it != NULL; it = it->mNext) {
  63         if (it->mFd == fd) {
  64             pthread_kill(it->mThread, BLOCKED_THREAD_SIGNAL);
  65             // Keep going, because there may be more than one thread...
  66         }
  67     }
  68 }
  69
  70 AsynchronousSocketCloseMonitor::AsynchronousSocketCloseMonitor(int fd) {
  71     ScopedPthreadMutexLock lock(&blockedThreadListMutex);
  72     // Who are we, and what are we waiting for?
  73     mThread = pthread_self();
  74     mFd = fd;
  75     // Insert ourselves at the head of the intrusive doubly-linked list...
  76     mPrev = NULL;
  77     mNext = blockedThreadList;
  78     if (mNext != NULL) {
  79         mNext->mPrev = this;
  80     }
  81     blockedThreadList = this;
  82 }
  83
  84 AsynchronousSocketCloseMonitor::~AsynchronousSocketCloseMonitor() {
  85     ScopedPthreadMutexLock lock(&blockedThreadListMutex);
  86     // Unlink ourselves from the intrusive doubly-linked list...
  87     if (mNext != NULL) {
  88         mNext->mPrev = mPrev;
  89     }
  90     if (mPrev == NULL) {
  91         blockedThreadList = mNext;
  92     } else {
  93         mPrev->mNext = mNext;
  94     }
  95 }