1 /* -*- mode: C; c-file-style: "gnu" -*- */
2 /* dbus-resources.c Resource tracking/limits
3 *
4 * Copyright (C) 2003 Red Hat Inc.
5 *
6 * Licensed under the Academic Free License version 2.1
7 *
8 * This program 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 * This program 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21 *
22 */
23 #include <dbus/dbus-resources.h>
24 #include <dbus/dbus-internals.h>
25
26 /**
27 * @defgroup DBusResources Resource limits related code
28 * @ingroup DBusInternals
29 * @brief DBusCounter and other stuff related to resource limits
30 *
31 * Types and functions related to tracking resource limits,
32 * such as the maximum amount of memory a connection can use
33 * for messages, etc.
34 */
35
36 /**
37 * @defgroup DBusResourcesInternals Resource limits implementation details
38 * @ingroup DBusInternals
39 * @brief Resource limits implementation details
40 *
41 * Implementation details of resource limits code.
42 *
43 * @{
44 */
45
46 /**
47 * @brief Internals of DBusCounter.
48 *
49 * DBusCounter internals. DBusCounter is an opaque object, it must be
50 * used via accessor functions.
51 */
52 struct DBusCounter
53 {
54 int refcount; /**< reference count */
55
56 long value; /**< current counter value */
57
58 long notify_guard_value; /**< call notify function when crossing this value */
59 DBusCounterNotifyFunction notify_function; /**< notify function */
60 void *notify_data; /**< data for notify function */
61 };
62
63 /** @} */ /* end of resource limits internals docs */
64
65 /**
66 * @addtogroup DBusResources
67 * @{
68 */
69
70 /**
71 * Creates a new DBusCounter. DBusCounter is used
72 * to count usage of some resource such as memory.
73 *
74 * @returns new counter or #NULL on failure
75 */
76 DBusCounter*
_dbus_counter_new(void)77 _dbus_counter_new (void)
78 {
79 DBusCounter *counter;
80
81 counter = dbus_new (DBusCounter, 1);
82 if (counter == NULL)
83 return NULL;
84
85 counter->refcount = 1;
86 counter->value = 0;
87
88 counter->notify_guard_value = 0;
89 counter->notify_function = NULL;
90 counter->notify_data = NULL;
91
92 return counter;
93 }
94
95 /**
96 * Increments refcount of the counter
97 *
98 * @param counter the counter
99 * @returns the counter
100 */
101 DBusCounter *
_dbus_counter_ref(DBusCounter * counter)102 _dbus_counter_ref (DBusCounter *counter)
103 {
104 _dbus_assert (counter->refcount > 0);
105
106 counter->refcount += 1;
107
108 return counter;
109 }
110
111 /**
112 * Decrements refcount of the counter and possibly
113 * finalizes the counter.
114 *
115 * @param counter the counter
116 */
117 void
_dbus_counter_unref(DBusCounter * counter)118 _dbus_counter_unref (DBusCounter *counter)
119 {
120 _dbus_assert (counter->refcount > 0);
121
122 counter->refcount -= 1;
123
124 if (counter->refcount == 0)
125 {
126
127 dbus_free (counter);
128 }
129 }
130
131 /**
132 * Adjusts the value of the counter by the given
133 * delta which may be positive or negative.
134 * Calls the notify function from _dbus_counter_set_notify()
135 * if that function has been specified.
136 *
137 * @param counter the counter
138 * @param delta value to add to the counter's current value
139 */
140 void
_dbus_counter_adjust(DBusCounter * counter,long delta)141 _dbus_counter_adjust (DBusCounter *counter,
142 long delta)
143 {
144 long old = counter->value;
145
146 counter->value += delta;
147
148 #if 0
149 _dbus_verbose ("Adjusting counter %ld by %ld = %ld\n",
150 old, delta, counter->value);
151 #endif
152
153 if (counter->notify_function != NULL &&
154 ((old < counter->notify_guard_value &&
155 counter->value >= counter->notify_guard_value) ||
156 (old >= counter->notify_guard_value &&
157 counter->value < counter->notify_guard_value)))
158 (* counter->notify_function) (counter, counter->notify_data);
159 }
160
161 /**
162 * Gets the current value of the counter.
163 *
164 * @param counter the counter
165 * @returns its current value
166 */
167 long
_dbus_counter_get_value(DBusCounter * counter)168 _dbus_counter_get_value (DBusCounter *counter)
169 {
170 return counter->value;
171 }
172
173 /**
174 * Sets the notify function for this counter; the notify function is
175 * called whenever the counter's value crosses the guard value in
176 * either direction (moving up, or moving down).
177 *
178 * @param counter the counter
179 * @param guard_value the value we're notified if the counter crosses
180 * @param function function to call in order to notify
181 * @param user_data data to pass to the function
182 */
183 void
_dbus_counter_set_notify(DBusCounter * counter,long guard_value,DBusCounterNotifyFunction function,void * user_data)184 _dbus_counter_set_notify (DBusCounter *counter,
185 long guard_value,
186 DBusCounterNotifyFunction function,
187 void *user_data)
188 {
189 counter->notify_guard_value = guard_value;
190 counter->notify_function = function;
191 counter->notify_data = user_data;
192 }
193
194 /** @} */ /* end of resource limits exported API */
195