/src/kamailio/src/core/locking.c

Source
/*
 * Copyright (C) 2016 kamailio.org
 *
 * This file is part of Kamailio, a free SIP server.
 *
 * SPDX-License-Identifier: GPL-2.0-or-later
 *
 * Kamailio is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version
 *
 * Kamailio is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 */

#include <stdlib.h>
#include <string.h>

#include "mem/shm.h"

#include "locking.h"

/**
 *
 */
rec_lock_t *rec_lock_alloc()
{
  return shm_malloc(sizeof(rec_lock_t));
}

/**
 *
 */
rec_lock_t *rec_lock_init(rec_lock_t *rlock)
{
  memset(rlock, 0, sizeof(rec_lock_t));
  if(lock_init(&rlock->lock) == 0) {
    return NULL;
  }
  return rlock;
}

/**
 *
 */
void rec_lock_destroy(rec_lock_t *rlock)
{
  lock_destroy(&rlock->lock);
  memset(rlock, 0, sizeof(rec_lock_t));
}

/**
 *
 */
void rec_lock_dealloc(rec_lock_t *rlock)
{
  shm_free(rlock);
}

/**
 *
 */
void rec_lock_get(rec_lock_t *rlock)
{
  int mypid;

  mypid = my_pid();
  if(likely(atomic_get(&rlock->locker_pid) != mypid)) {
    lock_get(&rlock->lock);
    atomic_set(&rlock->locker_pid, mypid);
  } else {
    /* locked within the same process that executed us */
    rlock->rec_lock_level++;
  }
}

/**
 *
 */
void rec_lock_release(rec_lock_t *rlock)
{
  if(likely(rlock->rec_lock_level == 0)) {
    atomic_set(&rlock->locker_pid, 0);
    lock_release(&rlock->lock);
  } else {
    /* recursive locked => decrease lock count */
    rlock->rec_lock_level--;
  }
}

/**
 *
 */
rec_lock_set_t *rec_lock_set_alloc(int n)
{
  rec_lock_set_t *ls;
  ls = (rec_lock_set_t *)shm_malloc(
      sizeof(rec_lock_set_t) + n * sizeof(rec_lock_t));
  if(ls == 0) {
    SHM_MEM_CRITICAL;
  } else {
    ls->locks = (rec_lock_t *)((char *)ls + sizeof(rec_lock_set_t));
    ls->size = n;
  }
  return ls;
}

/**
 *
 */
rec_lock_set_t *rec_lock_set_init(rec_lock_set_t *lset)
{
  int r;
  for(r = 0; r < lset->size; r++)
    if(rec_lock_init(&lset->locks[r]) == 0)
      return 0;
  return lset;
}

/**
 *
 */
void rec_lock_set_destroy(rec_lock_set_t *lset)
{
  return;
}

/**
 *
 */
void rec_lock_set_dealloc(rec_lock_set_t *lset)
{
  shm_free((void *)lset);
  return;
}

/**
 *
 */
void rec_lock_set_get(rec_lock_set_t *lset, int i)
{
  rec_lock_get(&lset->locks[i]);
  return;
}

/**
 *
 */
void rec_lock_set_release(rec_lock_set_t *lset, int i)
{
  rec_lock_release(&lset->locks[i]);
  return;
}

Line	Count	Source
1		/*
2		* Copyright (C) 2016 kamailio.org
3		*
4		* This file is part of Kamailio, a free SIP server.
5		*
6		* SPDX-License-Identifier: GPL-2.0-or-later
7		*
8		* Kamailio is free software; you can redistribute it and/or modify
9		* it under the terms of the GNU General Public License as published by
10		* the Free Software Foundation; either version 2 of the License, or
11		* (at your option) any later version
12		*
13		* Kamailio is distributed in the hope that it will be useful,
14		* but WITHOUT ANY WARRANTY; without even the implied warranty of
15		* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16		* GNU General Public License for more details.
17		*
18		* You should have received a copy of the GNU General Public License
19		* along with this program; if not, write to the Free Software
20		* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21		*/
22
23		#include <stdlib.h>
24		#include <string.h>
25
26		#include "mem/shm.h"
27
28		#include "locking.h"
29
30		/**
31		*
32		*/
33		rec_lock_t *rec_lock_alloc()
34	0	{
35	0	return shm_malloc(sizeof(rec_lock_t));
36	0	}
37
38		/**
39		*
40		*/
41		rec_lock_t rec_lock_init(rec_lock_t rlock)
42	0	{
43	0	memset(rlock, 0, sizeof(rec_lock_t));
44	0	if(lock_init(&rlock->lock) == 0) {
45	0	return NULL;
46	0	}
47	0	return rlock;
48	0	}
49
50		/**
51		*
52		*/
53		void rec_lock_destroy(rec_lock_t *rlock)
54	0	{
55	0	lock_destroy(&rlock->lock);
56	0	memset(rlock, 0, sizeof(rec_lock_t));
57	0	}
58
59		/**
60		*
61		*/
62		void rec_lock_dealloc(rec_lock_t *rlock)
63	0	{
64	0	shm_free(rlock);
65	0	}
66
67		/**
68		*
69		*/
70		void rec_lock_get(rec_lock_t *rlock)
71	0	{
72	0	int mypid;
73
74	0	mypid = my_pid();
75	0	if(likely(atomic_get(&rlock->locker_pid) != mypid)) {
76	0	lock_get(&rlock->lock);
77	0	atomic_set(&rlock->locker_pid, mypid);
78	0	} else {
79		/* locked within the same process that executed us */
80	0	rlock->rec_lock_level++;
81	0	}
82	0	}
83
84		/**
85		*
86		*/
87		void rec_lock_release(rec_lock_t *rlock)
88	0	{
89	0	if(likely(rlock->rec_lock_level == 0)) {
90	0	atomic_set(&rlock->locker_pid, 0);
91	0	lock_release(&rlock->lock);
92	0	} else {
93		/* recursive locked => decrease lock count */
94	0	rlock->rec_lock_level--;
95	0	}
96	0	}
97
98		/**
99		*
100		*/
101		rec_lock_set_t *rec_lock_set_alloc(int n)
102	0	{
103	0	rec_lock_set_t *ls;
104	0	ls = (rec_lock_set_t *)shm_malloc(
105	0	sizeof(rec_lock_set_t) + n * sizeof(rec_lock_t));
106	0	if(ls == 0) {
107	0	SHM_MEM_CRITICAL;
108	0	} else {
109	0	ls->locks = (rec_lock_t )((char )ls + sizeof(rec_lock_set_t));
110	0	ls->size = n;
111	0	}
112	0	return ls;
113	0	}
114
115		/**
116		*
117		*/
118		rec_lock_set_t rec_lock_set_init(rec_lock_set_t lset)
119	0	{
120	0	int r;
121	0	for(r = 0; r < lset->size; r++)
122	0	if(rec_lock_init(&lset->locks[r]) == 0)
123	0	return 0;
124	0	return lset;
125	0	}
126
127		/**
128		*
129		*/
130		void rec_lock_set_destroy(rec_lock_set_t *lset)
131	0	{
132	0	return;
133	0	}
134
135		/**
136		*
137		*/
138		void rec_lock_set_dealloc(rec_lock_set_t *lset)
139	0	{
140	0	shm_free((void *)lset);
141	0	return;
142	0	}
143
144		/**
145		*
146		*/
147		void rec_lock_set_get(rec_lock_set_t *lset, int i)
148	0	{
149	0	rec_lock_get(&lset->locks[i]);
150	0	return;
151	0	}
152
153		/**
154		*
155		*/
156		void rec_lock_set_release(rec_lock_set_t *lset, int i)
157	0	{
158	0	rec_lock_release(&lset->locks[i]);
159	0	return;
160	0	}

Coverage Report

Created: 2025-11-09 06:31