N-sim v0.9.4

00001 
00014 /*
00015  * Copyright 2007. Los Alamos National Security, LLC. This material
00016  * was produced under U.S. Government contract DE-AC52-06NA25396 for
00017  * Los Alamos National Laboratory (LANL), which is operated by Los
00018  * Alamos National Security, LLC, for the Department of Energy. The
00019  * U.S. Government has rights to use, reproduce, and distribute this
00020  * software. NEITHER THE GOVERNMENT NOR LOS ALAMOS NATIONAL SECURITY,
00021  * LLC, MAKES ANY WARRANTY, EXPRESS OR IMPLIED, OR ASSUMES ANY LEGAL
00022  * LIABILITY FOR THE USE OF THIS SOFTWARE. If software is modified to
00023  * produce derivative works, such modified software should be clearly
00024  * marked, so as not to confuse it with the version available from LANL.
00025  *
00026  * Additionally, this program is free software; you can redistribute
00027  * it and/or modify it under the terms of the GNU General Public
00028  * License as published by the Free Software Foundation; version 2 of
00029  * the License. Accordingly, this program is distributed in the hope
00030  * it will be useful, but WITHOUT ANY WARRANTY; without even the
00031  * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
00032  * PURPOSE. See the GNU General Public License for more details.
00033  */
00034 
00035 
00036 #include <l4/thread/thread.h>
00037 #include <l4/lock/lock.h>
00038 #include <stdlib.h>
00039 #include <mutex.h>
00040 
00041 
00042 int mutex_init(mutex_t *m)
00043 {
00044         if (m == 0)
00045                 return -1;
00046         if (m->l4_mutex == 0) {
00047                 if ((m->l4_mutex = malloc(sizeof(l4lock_t))) == NULL)
00048                         return -1;
00049         }
00050         *((l4lock_t*)m->l4_mutex) = L4LOCK_UNLOCKED;
00051         return 0;
00052 }
00053 
00054 
00055 int mutex_lock(mutex_t *m)
00056 {
00057         if (m == 0)
00058                 return -1;
00059         l4lock_lock((l4lock_t*)m->l4_mutex);
00060         return 0;
00061 }
00062 
00063 
00064 int mutex_trylock(mutex_t *m)
00065 {
00066         if (m == 0)
00067                 return -1;
00068         return l4lock_try_lock((l4lock_t*)m->l4_mutex);
00069 }
00070 
00071 
00072 int mutex_unlock(mutex_t *m)
00073 {
00074         if (m == 0)
00075                 return -1;
00076         l4lock_unlock((l4lock_t*)m->l4_mutex);
00077         return 0;
00078 }
00079 
00080 
00081 int mutex_destroy(mutex_t *m)
00082 {
00083         int error = -1;
00084         if (m == 0)
00085                 return error;
00086 
00087         if (m->l4_mutex != 0 && 
00088             l4thread_equal(l4lock_owner((l4lock_t*)m->l4_mutex), 
00089                            l4thread_myself())) {
00090                 l4lock_unlock((l4lock_t*)m->l4_mutex);
00091                 free(m->l4_mutex);
00092                 m->l4_mutex = 0;
00093                 error = 0;
00094         }
00095         return error;
00096 }
/home/brennan/n-sim/OrbisQuartus/server/l4/mutex-l4.c
