Changeset 4579

Show
Ignore:
Timestamp:
11/05/08 12:29:56 (2 months ago)
Author:
martin
Message:

replaced most pthread_mutex/cond_t by wrapped mutex/condvar_t variant

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • trunk/src/charon/config/peer_cfg.c

    r4276 r4579  
    1919 
    2020#include <string.h> 
    21 #include <pthread.h> 
    2221 
    2322#include "peer_cfg.h" 
    2423 
     24#include <utils/mutex.h> 
    2525#include <utils/linked_list.h> 
    2626#include <utils/identification.h> 
    …… 
    7878     * mutex to lock access to list of child_cfgs 
    7979     */ 
    80     pthread_mutex_t mutex; 
     80    mutex_t *mutex; 
    8181     
    8282    /** 
    …… 
    198198static void add_child_cfg(private_peer_cfg_t *this, child_cfg_t *child_cfg) 
    199199{ 
    200     pthread_mutex_lock(&this->mutex); 
     200    this->mutex->lock(this->mutex); 
    201201    this->child_cfgs->insert_last(this->child_cfgs, child_cfg); 
    202     pthread_mutex_unlock(&this->mutex); 
     202    this->mutex->unlock(this->mutex); 
    203203} 
    204204 
    …… 
    208208static void remove_child_cfg(private_peer_cfg_t *this, enumerator_t *enumerator) 
    209209{ 
    210     pthread_mutex_lock(&this->mutex); 
     210    this->mutex->lock(this->mutex); 
    211211    this->child_cfgs->remove_at(this->child_cfgs, enumerator); 
    212     pthread_mutex_unlock(&this->mutex); 
     212    this->mutex->unlock(this->mutex); 
    213213} 
    214214 
    …… 
    220220    enumerator_t *enumerator; 
    221221 
    222     pthread_mutex_lock(&this->mutex); 
     222    this->mutex->lock(this->mutex); 
    223223    enumerator = this->child_cfgs->create_enumerator(this->child_cfgs); 
    224224    return enumerator_create_cleaner(enumerator, 
    225                                      (void*)pthread_mutex_unlock, &this->mutex); 
     225                                     (void*)this->mutex->unlock, this->mutex); 
    226226} 
    227227 
    …… 
    481481        DESTROY_IF(this->peer_id); 
    482482#endif /* ME */ 
     483        this->mutex->destroy(this->mutex); 
    483484        free(this->name); 
    484485        free(this->pool); 
    …… 
    537538    this->ike_cfg = ike_cfg; 
    538539    this->child_cfgs = linked_list_create(); 
    539     pthread_mutex_init(&this->mutex, NULL); 
     540    this->mutex = mutex_create(MUTEX_DEFAULT); 
    540541    this->my_id = my_id; 
    541542    this->other_id = other_id; 

  • trunk/src/charon/network/sender.c

    r3742 r4579  
    2525#include <network/socket.h> 
    2626#include <processing/jobs/callback_job.h> 
     27#include <utils/mutex.h> 
    2728 
    2829 
    …… 
    5152     * mutex to synchronize access to list 
    5253     */ 
    53     pthread_mutex_t mutex; 
     54    mutex_t *mutex; 
    5455 
    5556    /** 
    5657     * condvar to signal for packets added to list 
    5758     */ 
    58     pthread_cond_t gotone; 
     59    condvar_t *got; 
    5960     
    6061    /** 
    6162     * condvar to signal for packets sent 
    6263     */ 
    63     pthread_cond_t sentone; 
     64    condvar_t *sent; 
    6465}; 
    6566 
    …… 
    7576    DBG1(DBG_NET, "sending packet: from %#H to %#H", src, dst); 
    7677     
    77     pthread_mutex_lock(&this->mutex); 
     78    this->mutex->lock(this->mutex); 
    7879    this->list->insert_last(this->list, packet); 
    79     pthread_cond_signal(&this->gotone); 
    80     pthread_mutex_unlock(&this->mutex); 
     80    this->got->signal(this->got); 
     81    this->mutex->unlock(this->mutex); 
    8182} 
    8283 
    …… 
    8990    int oldstate; 
    9091     
    91     pthread_mutex_lock(&this->mutex); 
     92    this->mutex->lock(this->mutex); 
    9293    while (this->list->get_count(this->list) == 0) 
    9394    { 
    9495        /* add cleanup handler, wait for packet, remove cleanup handler */ 
    95         pthread_cleanup_push((void(*)(void*))pthread_mutex_unlock, (void*)&this->mutex); 
     96        pthread_cleanup_push((void(*)(void*))this->mutex->unlock, this->mutex); 
    9697        pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, &oldstate); 
    9798         
    98         pthread_cond_wait(&this->gotone, &this->mutex); 
     99        this->got->wait(this->got, this->mutex); 
    99100         
    100101        pthread_setcancelstate(oldstate, NULL); 
    …… 
    102103    } 
    103104    this->list->remove_first(this->list, (void**)&packet); 
    104     pthread_cond_signal(&this->sentone); 
    105     pthread_mutex_unlock(&this->mutex); 
     105    this->sent->signal(this->sent); 
     106    this->mutex->unlock(this->mutex); 
    106107     
    107108    charon->socket->send(charon->socket, packet); 
    …… 
    116117{ 
    117118    /* send all packets in the queue */ 
    118     pthread_mutex_lock(&this->mutex); 
     119    this->mutex->lock(this->mutex); 
    119120    while (this->list->get_count(this->list)) 
    120121    { 
    121         pthread_cond_wait(&this->sentone, &this->mutex); 
     122        this->sent->wait(this->sent, this->mutex); 
    122123    } 
    123     pthread_mutex_unlock(&this->mutex); 
    124     pthread_mutex_destroy(&this->mutex); 
     124    this->mutex->unlock(this->mutex); 
     125    this->got->destroy(this->got); 
     126    this->sent->destroy(this->sent); 
     127    this->mutex->destroy(this->mutex); 
    125128    this->job->cancel(this->job); 
    126129    this->list->destroy(this->list); 
    …… 
    134137{ 
    135138    private_sender_t *this = malloc_thing(private_sender_t); 
    136  
     139     
    137140    this->public.send = (void(*)(sender_t*,packet_t*))send_; 
    138141    this->public.destroy = (void(*)(sender_t*)) destroy; 
    139  
     142     
    140143    this->list = linked_list_create(); 
    141     pthread_mutex_init(&this->mutex, NULL); 
    142     pthread_cond_init(&this->gotone, NULL); 
    143     pthread_cond_init(&this->sentone, NULL); 
    144  
     144    this->mutex = mutex_create(MUTEX_DEFAULT); 
     145    this->got = condvar_create(CONDVAR_DEFAULT); 
     146    this->sent = condvar_create(CONDVAR_DEFAULT); 
     147     
    145148    this->job = callback_job_create((callback_job_cb_t)send_packets, 
    146149                                    this, NULL, NULL); 
    147150    charon->processor->queue_job(charon->processor, (job_t*)this->job); 
    148  
     151     
    149152    return &this->public; 
    150153} 

  • trunk/src/charon/plugins/kernel_netlink/kernel_netlink_ipsec.c

    r4576 r4579  
    3838 
    3939#include <daemon.h> 
     40#include <utils/mutex.h> 
    4041#include <utils/linked_list.h> 
    4142#include <processing/jobs/callback_job.h> 
    …… 
    253254     * mutex to lock access to various lists 
    254255     */ 
    255     pthread_mutex_t mutex; 
     256    mutex_t *mutex; 
    256257     
    257258    /** 
    …… 
    13751376     
    13761377    /* find the policy, which matches EXACTLY */ 
    1377     pthread_mutex_lock(&this->mutex); 
     1378    this->mutex->lock(this->mutex); 
    13781379    iterator = this->policies->create_iterator(this->policies, TRUE); 
    13791380    while (iterator->iterate(iterator, (void**)&current)) 
    …… 
    14191420    policy_info->action = XFRM_POLICY_ALLOW; 
    14201421    policy_info->share = XFRM_SHARE_ANY; 
    1421     pthread_mutex_unlock(&this->mutex); 
     1422    this->mutex->unlock(this->mutex); 
    14221423     
    14231424    /* policies don't expire */ 
    …… 
    16351636     
    16361637    /* find the policy */ 
    1637     pthread_mutex_lock(&this->mutex); 
     1638    this->mutex->lock(this->mutex); 
    16381639    enumerator = this->policies->create_enumerator(this->policies); 
    16391640    while (enumerator->enumerate(enumerator, &current)) 
    …… 
    16471648                /* is used by more SAs, keep in kernel */ 
    16481649                DBG2(DBG_KNL, "policy still used by another CHILD_SA, not removed"); 
    1649                 pthread_mutex_unlock(&this->mutex); 
     1650                this->mutex->unlock(this->mutex); 
    16501651                enumerator->destroy(enumerator); 
    16511652                return SUCCESS; 
    …… 
    16561657        } 
    16571658    } 
    1658     pthread_mutex_unlock(&this->mutex); 
     1659    this->mutex->unlock(this->mutex); 
    16591660    enumerator->destroy(enumerator); 
    16601661    if (!to_delete) 
    …… 
    17101711    this->socket_xfrm->destroy(this->socket_xfrm); 
    17111712    this->policies->destroy(this->policies); 
     1713    this->mutex->destroy(this->mutex); 
    17121714    free(this); 
    17131715} 
    …… 
    17341736    /* private members */ 
    17351737    this->policies = linked_list_create(); 
    1736     pthread_mutex_init(&this->mutex, NULL); 
     1738    this->mutex = mutex_create(MUTEX_DEFAULT); 
    17371739    this->install_routes = lib->settings->get_bool(lib->settings, 
    17381740                    "charon.install_routes", TRUE); 

  • trunk/src/charon/plugins/kernel_netlink/kernel_netlink_net.c

    r4576 r4579  
    3030 
    3131#include <daemon.h> 
     32#include <utils/mutex.h> 
    3233#include <utils/linked_list.h> 
    3334#include <processing/jobs/callback_job.h> 
    …… 
    117118     * mutex to lock access to various lists 
    118119     */ 
    119     pthread_mutex_t mutex; 
     120    mutex_t *mutex; 
    120121     
    121122    /** 
    122123     * condition variable to signal virtual IP add/removal 
    123124     */ 
    124     pthread_cond_t cond; 
     125    condvar_t *condvar; 
    125126     
    126127    /** 
    …… 
    254255    } 
    255256     
    256     pthread_mutex_lock(&this->mutex); 
     257    this->mutex->lock(this->mutex); 
    257258    switch (hdr->nlmsg_type) 
    258259    { 
    …… 
    316317        } 
    317318    } 
    318     pthread_mutex_unlock(&this->mutex); 
     319    this->mutex->unlock(this->mutex); 
    319320     
    320321    /* send an update to all IKE_SAs */ 
    …… 
    374375    } 
    375376     
    376     pthread_mutex_lock(&this->mutex); 
     377    this->mutex->lock(this->mutex); 
    377378    ifaces = this->ifaces->create_enumerator(this->ifaces); 
    378379    while (ifaces->enumerate(ifaces, &iface)) 
    …… 
    432433    } 
    433434    ifaces->destroy(ifaces); 
    434     pthread_mutex_unlock(&this->mutex); 
     435    this->mutex->unlock(this->mutex); 
    435436    host->destroy(host); 
    436437     
    …… 
    471472    if (host) 
    472473    { 
     474        this->mutex->lock(this->mutex); 
    473475        if (!get_vip_refcount(this, host)) 
    474476        {   /* ignore routes added for virtual IPs */ 
    475477            fire_roam_job(this, FALSE); 
    476478        } 
     479        this->mutex->unlock(this->mutex); 
    477480        host->destroy(host); 
    478481    } 
    …… 
    525528            case RTM_DELADDR: 
    526529                process_addr(this, hdr, TRUE); 
    527                 pthread_cond_broadcast(&this->cond); 
     530                this->condvar->broadcast(this->condvar); 
    528531                break; 
    529532            case RTM_NEWLINK: 
    530533            case RTM_DELLINK: 
    531534                process_link(this, hdr, TRUE); 
    532                 pthread_cond_broadcast(&this->cond); 
     535                this->condvar->broadcast(this->condvar); 
    533536                break; 
    534537            case RTM_NEWROUTE: 
    …… 
    561564static void address_enumerator_destroy(address_enumerator_t *data) 
    562565{ 
    563     pthread_mutex_unlock(&data->this->mutex); 
     566    data->this->mutex->unlock(data->this->mutex); 
    564567    free(data); 
    565568} 
    …… 
    615618    data->include_virtual_ips = include_virtual_ips; 
    616619     
    617     pthread_mutex_lock(&this->mutex); 
     620    this->mutex->lock(this->mutex); 
    618621    return enumerator_create_nested( 
    619622                enumerator_create_filter(this->ifaces->create_enumerator(this->ifaces), 
    …… 
    634637    DBG2(DBG_KNL, "getting interface name for %H", ip); 
    635638     
    636     pthread_mutex_lock(&this->mutex); 
     639    this->mutex->lock(this->mutex); 
    637640    ifaces = this->ifaces->create_enumerator(this->ifaces); 
    638641    while (ifaces->enumerate(ifaces, &iface)) 
    …… 
    654657    } 
    655658    ifaces->destroy(ifaces); 
    656     pthread_mutex_unlock(&this->mutex); 
     659    this->mutex->unlock(this->mutex); 
    657660     
    658661    if (name) 
    …… 
    678681    DBG2(DBG_KNL, "getting iface index for %s", name); 
    679682     
    680     pthread_mutex_lock(&this->mutex); 
     683    this->mutex->lock(this->mutex); 
    681684    ifaces = this->ifaces->create_enumerator(this->ifaces); 
    682685    while (ifaces->enumerate(ifaces, &iface)) 
    …… 
    689692    } 
    690693    ifaces->destroy(ifaces); 
    691     pthread_mutex_unlock(&this->mutex); 
     694    this->mutex->unlock(this->mutex); 
    692695 
    693696    if (ifindex == 0) 
    …… 
    770773        return NULL; 
    771774    } 
     775    this->mutex->lock(this->mutex); 
    772776    current = out; 
    773777    while (NLMSG_OK(current, len)) 
    …… 
    847851                    { 
    848852                        /* no source addr, get one from the interfaces */ 
    849                         pthread_mutex_lock(&this->mutex); 
    850853                        ifaces = this->ifaces->create_enumerator(this->ifaces); 
    851854                        while (ifaces->enumerate(ifaces, &iface)) 
    …… 
    871874                        } 
    872875                        ifaces->destroy(ifaces); 
    873                         pthread_mutex_unlock(&this->mutex); 
    874876                    } 
    875877                } 
    …… 
    883885    } 
    884886    free(out); 
     887    this->mutex->unlock(this->mutex); 
    885888     
    886889    if (nexthop) 
    …… 
    958961    DBG2(DBG_KNL, "adding virtual IP %H", virtual_ip); 
    959962     
    960     pthread_mutex_lock(&this->mutex); 
     963    this->mutex->lock(this->mutex); 
    961964    ifaces = this->ifaces->create_enumerator(this->ifaces); 
    962965    while (ifaces->enumerate(ifaces, &iface)) 
    …… 
    978981                addrs->destroy(addrs); 
    979982                ifaces->destroy(ifaces); 
    980                 pthread_mutex_unlock(&this->mutex); 
     983                this->mutex->unlock(this->mutex); 
    981984                return SUCCESS; 
    982985            } 
    …… 
    9991002                while (get_vip_refcount(this, virtual_ip) == 0) 
    10001003                {   /* wait until address appears */ 
    1001                     pthread_cond_wait(&this->cond, &this->mutex); 
     1004                    this->condvar->wait(this->condvar, this->mutex); 
    10021005                } 
    10031006                ifaces->destroy(ifaces); 
    1004                 pthread_mutex_unlock(&this->mutex); 
     1007                this->mutex->unlock(this->mutex); 
    10051008                return SUCCESS; 
    10061009            } 
    10071010            ifaces->destroy(ifaces); 
    1008             pthread_mutex_unlock(&this->mutex); 
     1011            this->mutex->unlock(this->mutex); 
    10091012            DBG1(DBG_KNL, "adding virtual IP %H failed", virtual_ip); 
    10101013            return FAILED; 
    …… 
    10121015    } 
    10131016    ifaces->destroy(ifaces); 
    1014     pthread_mutex_unlock(&this->mutex); 
     1017    this->mutex->unlock(this->mutex); 
    10151018     
    10161019    DBG1(DBG_KNL, "interface address %H not found, unable to install" 
    …… 
    10321035    DBG2(DBG_KNL, "deleting virtual IP %H", virtual_ip); 
    10331036     
    1034     pthread_mutex_lock(&this->mutex); 
     1037    this->mutex->lock(this->mutex); 
    10351038    ifaces = this->ifaces->create_enumerator(this->ifaces); 
    10361039    while (ifaces->enumerate(ifaces, &iface)) 
    …… 
    10501053                        while (get_vip_refcount(this, virtual_ip) > 0) 
    10511054                        { 
    1052                             pthread_cond_wait(&this->cond, &this->mutex); 
     1055                            this->condvar->wait(this->condvar, this->mutex); 
    10531056                        } 
    10541057                    } 
    10551058                    addrs->destroy(addrs); 
    10561059                    ifaces->destroy(ifaces); 
    1057                     pthread_mutex_unlock(&this->mutex); 
     1060                    this->mutex->unlock(this->mutex); 
    10581061                    return status; 
    10591062                } 
    …… 
    10661069                addrs->destroy(addrs); 
    10671070                ifaces->destroy(ifaces); 
    1068                 pthread_mutex_unlock(&this->mutex); 
     1071                this->mutex->unlock(this->mutex); 
    10691072                return SUCCESS; 
    10701073            } 
    …… 
    10731076    } 
    10741077    ifaces->destroy(ifaces); 
    1075     pthread_mutex_unlock(&this->mutex); 
     1078    this->mutex->unlock(this->mutex); 
    10761079     
    10771080    DBG2(DBG_KNL, "virtual IP %H not cached, unable to delete", virtual_ip); 
    …… 
    12331236    free(out); 
    12341237     
    1235     pthread_mutex_lock(&this->mutex); 
     1238    this->mutex->lock(this->mutex); 
    12361239    ifaces = this->ifaces->create_enumerator(this->ifaces); 
    12371240    while (ifaces->enumerate(ifaces, &iface)) 
    …… 
    12491252    } 
    12501253    ifaces->destroy(ifaces); 
    1251     pthread_mutex_unlock(&this->mutex); 
     1254    this->mutex->unlock(this->mutex); 
    12521255    return SUCCESS; 
    12531256} 
    …… 
    13021305    this->socket->destroy(this->socket); 
    13031306    this->ifaces->destroy_function(this->ifaces, (void*)iface_entry_destroy); 
     1307    this->condvar->destroy(this->condvar); 
     1308    this->mutex->destroy(this->mutex); 
    13041309    free(this); 
    13051310} 
    …… 
    13261331    /* private members */ 
    13271332    this->ifaces = linked_list_create(); 
    1328     pthread_mutex_init(&this->mutex, NULL); 
    1329     pthread_cond_init(&this->cond, NULL); 
     1333    this->mutex = mutex_create(MUTEX_DEFAULT); 
     1334    this->condvar = condvar_create(CONDVAR_DEFAULT); 
    13301335    timerclear(&this->last_roam); 
    13311336    this->routing_table = lib->settings->get_int(lib->settings, 

  • trunk/src/charon/plugins/kernel_netlink/kernel_netlink_shared.c

    r4576 r4579  
    2121#include <errno.h> 
    2222#include <unistd.h> 
    23 #include <pthread.h> 
    2423 
    2524#include "kernel_netlink_shared.h" 
    2625 
    2726#include <daemon.h> 
     27#include <utils/mutex.h> 
    2828 
    2929typedef struct private_netlink_socket_t private_netlink_socket_t; 
    …… 
    4141     * mutex to lock access to netlink socket 
    4242     */ 
    43     pthread_mutex_t mutex; 
     43    mutex_t *mutex; 
    4444 
    4545    /** 
    …… 
    6565    struct nlmsghdr *msg, peek; 
    6666     
    67     pthread_mutex_lock(&this->mutex); 
     67    this->mutex->lock(this->mutex); 
    6868     
    6969    in->nlmsg_seq = ++this->seq; 
    …… 
    8787                continue; 
    8888            } 
    89             pthread_mutex_unlock(&this->mutex); 
     89            this->mutex->unlock(this->mutex); 
    9090            DBG1(DBG_KNL, "error sending to netlink socket: %s", strerror(errno)); 
    9191            return FAILED; 
    …… 
    119119            } 
    120120            DBG1(DBG_KNL, "error reading from netlink socket: %s", strerror(errno)); 
    121             pthread_mutex_unlock(&this->mutex); 
     121            this->mutex->unlock(this->mutex); 
    122122            free(result.ptr); 
    123123            return FAILED; 
    …… 
    126126        { 
    127127            DBG1(DBG_KNL, "received corrupted netlink message"); 
    128             pthread_mutex_unlock(&this->mutex); 
     128            this->mutex->unlock(this->mutex); 
    129129            free(result.ptr); 
    130130            return FAILED; 
    …… 
    137137                continue; 
    138138            } 
    139             pthread_mutex_unlock(&this->mutex); 
     139            this->mutex->unlock(this->mutex); 
    140140            free(result.ptr); 
    141141            return FAILED; 
    …… 
    163163    *out = (struct nlmsghdr*)result.ptr; 
    164164     
    165     pthread_mutex_unlock(&this->mutex); 
     165    this->mutex->unlock(this->mutex); 
    166166     
    167167    return SUCCESS; 
    …… 
    223223{ 
    224224    close(this->socket); 
     225    this->mutex->destroy(this->mutex); 
    225226    free(this); 
    226227} 
    …… 
    240241    /* private members */ 
    241242    this->seq = 200; 
    242     pthread_mutex_init(&this->mutex, NULL); 
     243    this->mutex = mutex_create(MUTEX_DEFAULT); 
    243244     
    244245    memset(&addr, 0, sizeof(addr)); 

  • trunk/src/charon/plugins/kernel_pfkey/kernel_pfkey_ipsec.c

    r4561 r4579  
    3131#include <daemon.h> 
    3232#include <utils/host.h> 
     33#include <utils/mutex.h> 
    3334#include <processing/jobs/callback_job.h> 
    3435#include <processing/jobs/acquire_job.h> 
    …… 
    8485     * mutex to lock access to various lists 
    8586     */ 
    86     pthread_mutex_t mutex; 
     87    mutex_t *mutex; 
    8788     
    8889    /** 
    …… 
    104105     * mutex to lock access to the PF_KEY socket 
    105106     */ 
    106     pthread_mutex_t mutex_pfkey; 
    107      
     107    mutex_t *mutex_pfkey; 
    108108     
    109109    /** 
    …… 
    112112    int socket; 
    113113     
    114      
    115114    /** 
    116115     * PF_KEY socket to receive acquire and expire events 
    117116     */ 
    118117    int socket_events; 
    119      
    120118     
    121119    /** 
    …… 
    636634    int in_len, len; 
    637635     
    638     pthread_mutex_lock(&this->mutex_pfkey); 
     636    this->mutex_pfkey->lock(this->mutex_pfkey); 
    639637 
    640638    in->sadb_msg_seq = ++this->seq; 
    …… 
    654652                continue; 
    655653            } 
    656             pthread_mutex_unlock(&this->mutex_pfkey); 
     654            this->mutex_pfkey->unlock(this->mutex_pfkey); 
    657655            DBG1(DBG_KNL, "error sending to PF_KEY socket: %s", strerror(errno)); 
    658656            return FAILED; 
    …… 
    676674            } 
    677675            DBG1(DBG_KNL, "error reading from PF_KEY socket: %s", strerror(errno)); 
    678             pthread_mutex_unlock(&this->mutex_pfkey); 
     676            this->mutex_pfkey->unlock(this->mutex_pfkey); 
    679677            return FAILED; 
    680678        } 
    …… 
    683681        { 
    684682            DBG1(DBG_KNL, "received corrupted PF_KEY message"); 
    685             pthread_mutex_unlock(&this->mutex_pfkey); 
     683            this->mutex_pfkey->unlock(this->mutex_pfkey); 
    686684            return FAILED; 
    687685        } 
    …… 
    689687        { 
    690688            DBG1(DBG_KNL, "buffer was too small to receive the complete PF_KEY message"); 
    691             pthread_mutex_unlock(&this->mutex_pfkey); 
     689            this->mutex_pfkey->unlock(this->mutex_pfkey); 
    692690            return FAILED; 
    693691        } 
    …… 
    705703                continue; 
    706704            } 
    707             pthread_mutex_unlock(&this->mutex_pfkey); 
     705            this->mutex_pfkey->unlock(this->mutex_pfkey); 
    708706            return FAILED; 
    709707        } 
    …… 
    721719    memcpy(*out, buf, len); 
    722720         
    723     pthread_mutex_unlock(&this->mutex_pfkey); 
     721    this->mutex_pfkey->unlock(this->mutex_pfkey); 
    724722     
    725723    return SUCCESS; 
    …… 
    765763     
    766764    index = response.x_policy->sadb_x_policy_id; 
    767     pthread_mutex_lock(&this->mutex); 
     765    this->mutex->lock(this->mutex); 
    768766    if (this->policies->find_first(this->policies, 
    769767            (linked_list_match_t)policy_entry_match_byindex, (void**)&policy, &index) == SUCCESS) 
    …… 
    778776    src_ts = sadb_address2ts(response.src); 
    779777    dst_ts = sadb_address2ts(response.dst); 
    780     pthread_mutex_unlock(&this->mutex); 
     778    this->mutex->unlock(this->mutex); 
    781779     
    782780    DBG1(DBG_KNL, "creating acquire job for policy %R === %R with reqid {%u}", 
    …… 
    14291427     
    14301428    /* find a matching policy */ 
    1431     pthread_mutex_lock(&this->mutex); 
     1429    this->mutex->lock(this->mutex); 
    14321430    if (this->policies->find_first(this->policies, 
    14331431            (linked_list_match_t)policy_entry_equals, (void**)&found, policy) == SUCCESS) 
    …… 
    15081506    PFKEY_EXT_ADD(msg, addr); 
    15091507     
    1510     pthread_mutex_unlock(&this->mutex); 
     1508    this->mutex->unlock(this->mutex); 
    15111509     
    15121510    if (pfkey_send(this, msg, &out, &len) != SUCCESS) 
    …… 
    15321530    } 
    15331531     
    1534     pthread_mutex_lock(&this->mutex); 
     1532    this->mutex->lock(this->mutex); 
    15351533     
    15361534    /* we try to find the policy again and update the kernel index */ 
    …… 
    15391537        DBG2(DBG_KNL, "unable to update index, the policy %R === %R %N is " 
    15401538                "already gone, ignoring", src_ts, dst_ts, policy_dir_names, direction); 
    1541         pthread_mutex_unlock(&this->mutex); 
     1539        this->mutex->unlock(this->mutex); 
    15421540        free(out); 
    15431541        return SUCCESS; 
    …… 
    15941592    }    
    15951593     
    1596     pthread_mutex_unlock(&this->mutex);    
     1594    this->mutex->unlock(this->mutex);  
    15971595     
    15981596    return SUCCESS; 
    …… 
    16221620     
    16231621    /* find a matching policy */ 
    1624     pthread_mutex_lock(&this->mutex); 
     1622    this->mutex->lock(this->mutex); 
    16251623    if (this->policies->find_first(this->policies, 
    16261624            (linked_list_match_t)policy_entry_equals, (void**)&found, policy) != SUCCESS) 
    …… 
    16291627                       dst_ts, policy_dir_names, direction); 
    16301628        policy_entry_destroy(policy); 
    1631         pthread_mutex_unlock(&this->mutex); 
     1629        this->mutex->unlock(this->mutex); 
    16321630        return NOT_FOUND; 
    16331631    } 
    …… 
    16651663    PFKEY_EXT_ADD(msg, addr); 
    16661664     
    1667     pthread_mutex_unlock(&this->mutex); 
     1665    this->mutex->unlock(this->mutex); 
    16681666     
    16691667    if (pfkey_send(this, msg, &out, &len) != SUCCESS) 
    …… 
    17191717     
    17201718    /* find a matching policy */ 
    1721     pthread_mutex_lock(&this->mutex); 
     1719    this->mutex->lock(this->mutex); 
    17221720    if (this->policies->find_first(this->policies, 
    17231721            (linked_list_match_t)policy_entry_equals, (void**)&found, policy) == SUCCESS) 
    …… 
    17281726            DBG2(DBG_KNL, "policy still used by another CHILD_SA, not removed");     
    17291727            policy_entry_destroy(policy); 
    1730             pthread_mutex_unlock(&this->mutex); 
     1728            this->mutex->unlock(this->mutex); 
    17311729            return SUCCESS; 
    17321730        } 
    …… 
    17411739                       dst_ts, policy_dir_names, direction); 
    17421740        policy_entry_destroy(policy); 
    1743         pthread_mutex_unlock(&this->mutex); 
     1741        this->mutex->unlock(this->mutex); 
    17441742        return NOT_FOUND; 
    17451743    } 
    1746     pthread_mutex_unlock(&this->mutex); 
     1744    this->mutex->unlock(this->mutex); 
    17471745         
    17481746    memset(&request, 0, sizeof(request)); 
    …… 
    18531851    close(this->socket_events); 
    18541852    this->policies->destroy_function(this->policies, (void*)policy_entry_destroy); 
     1853    this->mutex->destroy(this->mutex); 
     1854    this->mutex_pfkey->destroy(this->mutex_pfkey); 
    18551855    free(this); 
    18561856} 
    …… 
    18771877    /* private members */ 
    18781878    this->policies = linked_list_create(); 
    1879     pthread_mutex_init(&this->mutex, NULL); 
    1880     this->install_routes = lib->settings->get_bool(lib->settings, "charon.install_routes", TRUE); 
    1881     pthread_mutex_init(&this->mutex_pfkey, NULL); 
     1879    this->mutex = mutex_create(MUTEX_DEFAULT); 
     1880    this->mutex_pfkey = mutex_create(MUTEX_DEFAULT); 
     1881    this->install_routes = lib->settings->get_bool(lib->settings, 
     1882                                                "charon.install_routes", TRUE); 
    18821883    this->seq = 0; 
    18831884     

  • trunk/src/charon/processing/jobs/callback_job.c

    r4576 r4579  
    2121 
    2222#include <daemon.h> 
     23#include <utils/mutex.h> 
    2324 
    2425typedef struct private_callback_job_t private_callback_job_t; 
    …… 
    5253     */ 
    5354    pthread_t thread; 
    54  
     55     
    5556    /** 
    5657     * mutex to access jobs interna 
    5758     */ 
    58     pthread_mutex_t mutex; 
    59  
     59    mutex_t *mutex; 
     60     
    6061    /** 
    6162     * list of asociated child jobs 
    …… 
    7980    } 
    8081    this->children->destroy(this->children); 
     82    this->mutex->destroy(this->mutex); 
    8183    free(this); 
    8284} 
    …… 
    9294        private_callback_job_t *child; 
    9395         
    94         pthread_mutex_lock(&this->parent->mutex); 
     96        this->parent->mutex->lock(this->parent->mutex); 
    9597        iterator = this->parent->children->create_iterator(this->parent->children, TRUE); 
    9698        while (iterator->iterate(iterator, (void**)&child)) 
    …… 
    103105        } 
    104106        iterator->destroy(iterator); 
    105         pthread_mutex_unlock(&this->parent->mutex); 
     107        this->parent->mutex->unlock(this->parent->mutex); 
    106108    } 
    107109} 
    …… 
    114116    pthread_t thread; 
    115117     
    116     pthread_mutex_lock(&this->mutex); 
     118    this->mutex->lock(this->mutex); 
    117119    thread = this->thread; 
    118120     
    119121    /* terminate its children */ 
    120122    this->children->invoke_offset(this->children, offsetof(callback_job_t, cancel)); 
    121     pthread_mutex_unlock(&this->mutex); 
     123    this->mutex->unlock(this->mutex); 
    122124     
    123125    /* terminate thread */ 
    …… 
    136138    bool cleanup = FALSE; 
    137139 
    138     pthread_mutex_lock(&this->mutex); 
     140    this->mutex->lock(this->mutex); 
    139141    this->thread = pthread_self(); 
    140     pthread_mutex_unlock(&this->mutex); 
     142    this->mutex->unlock(this->mutex); 
    141143     
    142144    pthread_cleanup_push((void*)destroy, this); 
    …… 
    183185 
    184186    /* private variables */ 
    185     pthread_mutex_init(&this->mutex, NULL); 
     187    this->mutex = mutex_create(MUTEX_DEFAULT); 
    186188    this->callback = cb; 
    187189    this->data = data; 
    …… 
    194196    if (parent) 
    195197    { 
    196         pthread_mutex_lock(&this->parent->mutex); 
     198        this->parent->mutex->lock(this->parent->mutex); 
    197199        this->parent->children->insert_last(this->parent->children, this); 
    198         pthread_mutex_unlock(&this->parent->mutex); 
     200        this->parent->mutex->unlock(this->parent->mutex); 
    199201    } 
    200202     

  • trunk/src/charon/processing/processor.c

    r3742 r4579  
    2525 
    2626#include <daemon.h> 
     27#include <utils/mutex.h> 
    2728#include <utils/linked_list.h> 
    2829 
    …… 
    6263     * access to linked_list is locked through this mutex 
    6364     */ 
    64     pthread_mutex_t mutex; 
     65    mutex_t *mutex; 
    6566 
    6667    /** 
    6768     * Condvar to wait for new jobs 
    6869     */ 
    69     pthread_cond_t jobadded; 
     70    condvar_t *job_added; 
    7071     
    7172    /** 
    7273     * Condvar to wait for terminated threads 
    7374     */ 
    74     pthread_cond_t threadterminated; 
     75    condvar_t *thread_terminated; 
    7576}; 
    7677 
    …… 
    8687    if (pthread_create(&thread, NULL, (void*)process_jobs, this) != 0) 
    8788    { 
    88         pthread_mutex_lock(&this->mutex); 
     89        this->mutex->lock(this->mutex); 
    8990        this->total_threads--; 
    90         pthread_cond_broadcast(&this->threadterminated); 
    91         pthread_mutex_unlock(&this->mutex); 
     91        this->thread_terminated->broadcast(this->thread_terminated); 
     92        this->mutex->unlock(this->mutex); 
    9293    } 
    9394} 
    …… 
    104105    DBG2(DBG_JOB, "started worker thread, thread_ID: %06u", (int)pthread_self()); 
    105106     
    106     pthread_mutex_lock(&this->mutex); 
     107    this->mutex->lock(this->mutex); 
    107108    while (this->desired_threads >= this->total_threads) 
    108109    { 
    …… 
    112113        { 
    113114            this->idle_threads++; 
    114             pthread_cond_wait(&this->jobadded, &this->mutex); 
     115            this->job_added->wait(this->job_added, this->mutex); 
    115116            this->idle_threads--; 
    116117            continue; 
    117118        } 
    118119        this->list->remove_first(this->list, (void**)&job); 
    119         pthread_mutex_unlock(&this->mutex); 
     120        this->mutex->unlock(this->mutex); 
    120121        /* terminated threads are restarted, so we have a constant pool */ 
    121122        pthread_cleanup_push((void*)restart, this); 
    122123        job->execute(job); 
    123124        pthread_cleanup_pop(0); 
    124         pthread_mutex_lock(&this->mutex); 
     125        this->mutex->lock(this->mutex); 
    125126    } 
    126127    this->total_threads--; 
    127     pthread_cond_signal(&this->threadterminated); 
    128     pthread_mutex_unlock(&this->mutex); 
     128    this->thread_terminated->signal(this->thread_terminated); 
     129    this