auto import from //depot/cupcake/@135843

libc/stdio/flockfile.c

@@ -0,0 +1,212 @@
+/*
+ * Copyright (C) 2008 The Android Open Source Project
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *  * Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in
+ *    the documentation and/or other materials provided with the
+ *    distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+/* implement flockfile(), ftrylockfile() and funlockfile()
+ *
+ * we can't use the OpenBSD implementation which uses kernel-specific
+ * APIs not available on Linux.
+ *
+ * Ideally, this would be trivially implemented by adding a
+ * pthread_mutex_t field to struct __sFILE as defined in
+ * <stdio.h>.
+ *
+ * However, since we don't want to bring pthread into the mix
+ * as well as change the size of a public API/ABI structure,
+ * we're going to store the data out-of-band.
+ *
+ * we use a hash-table to map FILE* pointers to recursive mutexes
+ * fclose() will call __fremovelock() defined below to remove
+ * a pointer from the table.
+ *
+ * the behaviour, if fclose() is called while the corresponding
+ * file is locked is totally undefined.
+ */
+#include <stdio.h>
+#include <pthread.h>
+#include <string.h>
+
+/* a node in the hash table */
+typedef struct FileLock {
+    struct FileLock*  next;
+    FILE*             file;
+    pthread_mutex_t   mutex;
+} FileLock;
+
+/* use a static hash table. We assume that we're not going to
+ * lock a really large number of FILE* objects on an embedded
+ * system.
+ */
+#define  FILE_LOCK_BUCKETS  32
+
+typedef struct {
+    pthread_mutex_t   lock;
+    FileLock*         buckets[ FILE_LOCK_BUCKETS ];
+} LockTable;
+
+static LockTable*      _lockTable;
+static pthread_once_t  _lockTable_once = PTHREAD_ONCE_INIT;
+
+static void
+lock_table_init( void )
+{
+    _lockTable = malloc(sizeof(*_lockTable));
+    if (_lockTable != NULL) {
+        pthread_mutex_init(&_lockTable->lock, NULL);
+        memset(_lockTable->buckets, 0, sizeof(_lockTable->buckets));
+    }
+}
+
+static LockTable*
+lock_table_lock( void )
+{
+    pthread_once( &_lockTable_once, lock_table_init );
+    pthread_mutex_lock( &_lockTable->lock );
+    return _lockTable;
+}
+
+static void
+lock_table_unlock( LockTable*  t )
+{
+    pthread_mutex_unlock( &t->lock );
+}
+
+static FileLock**
+lock_table_lookup( LockTable*  t, FILE*  f )
+{
+    uint32_t    hash = (uint32_t)(void*)f;
+    FileLock**  pnode;
+
+    hash = (hash >> 2) ^ (hash << 17);
+    pnode = &t->buckets[hash % FILE_LOCK_BUCKETS];
+    for (;;) {
+        FileLock*  node = *pnode;
+        if (node == NULL || node->file == f)
+            break;
+        pnode = &node->next;
+    }
+    return pnode;
+}
+
+void
+flockfile(FILE * fp)
+{
+    LockTable*  t = lock_table_lock();
+
+    if (t != NULL) {
+        FileLock**  lookup = lock_table_lookup(t, fp);
+        FileLock*   lock   = *lookup;
+
+        if (lock == NULL) {
+            pthread_mutexattr_t  attr;
+
+            /* create a new node in the hash table */
+            lock = malloc(sizeof(*lock));
+            if (lock == NULL) {
+                lock_table_unlock(t);
+                return;
+            }
+            lock->next        = NULL;
+            lock->file        = fp;
+
+            pthread_mutexattr_init(&attr);
+            pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
+            pthread_mutex_init( &lock->mutex, &attr );
+
+            *lookup           = lock;
+        }
+        lock_table_unlock(t);
+
+        /* we assume that another thread didn't destroy 'lock'
+        * by calling fclose() on the FILE*. This can happen if
+        * the client is *really* buggy, but we don't care about
+        * such code here.
+        */
+        pthread_mutex_lock(&lock->mutex);
+    }
+}
+
+
+int
+ftrylockfile(FILE *fp)
+{
+    int         ret = -1;
+    LockTable*  t   = lock_table_lock();
+
+    if (t != NULL) {
+        FileLock**  lookup = lock_table_lookup(t, fp);
+        FileLock*   lock   = *lookup;
+
+        lock_table_unlock(t);
+
+        /* see above comment about why we assume that 'lock' can
+        * be accessed from here
+        */
+        if (lock != NULL && !pthread_mutex_trylock(&lock->mutex)) {
+            ret = 0;  /* signal success */
+        }
+    }
+    return ret;
+}
+
+void
+funlockfile(FILE * fp)
+{
+    LockTable*  t = lock_table_lock();
+
+    if (t != NULL) {
+        FileLock**  lookup = lock_table_lookup(t, fp);
+        FileLock*   lock   = *lookup;
+
+        if (lock != NULL)
+            pthread_mutex_unlock(&lock->mutex);
+
+        lock_table_unlock(t);
+    }
+}
+
+
+/* called from fclose() to remove the file lock */
+void
+__fremovelock(FILE*  fp)
+{
+    LockTable*  t = lock_table_lock();
+
+    if (t != NULL) {
+        FileLock**  lookup = lock_table_lookup(t, fp);
+        FileLock*   lock   = *lookup;
+
+        if (lock != NULL) {
+            *lookup   = lock->next;
+            lock->file = NULL;
+        }
+        lock_table_unlock(t);
+
+        if (lock != NULL)
+            free(lock);
+    }
+}