1 /***
2 This file is part of PulseAudio.
3
4 Copyright 2009 Tanu Kaskinen
5
6 PulseAudio is free software; you can redistribute it and/or modify
7 it under the terms of the GNU Lesser General Public License as published
8 by the Free Software Foundation; either version 2.1 of the License,
9 or (at your option) any later version.
10
11 PulseAudio is distributed in the hope that it will be useful, but
12 WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 General Public License for more details.
15
16 You should have received a copy of the GNU Lesser General Public License
17 along with PulseAudio; if not, see <http://www.gnu.org/licenses/>.
18 ***/
19
20 #ifdef HAVE_CONFIG_H
21 #include <config.h>
22 #endif
23
24 #include <dbus/dbus.h>
25
26 #include <pulsecore/core-scache.h>
27 #include <pulsecore/core-util.h>
28 #include <pulsecore/dbus-util.h>
29 #include <pulsecore/protocol-dbus.h>
30
31 #include "iface-memstats.h"
32
33 #define OBJECT_NAME "memstats"
34
35 static void handle_get_current_memblocks(DBusConnection *conn, DBusMessage *msg, void *userdata);
36 static void handle_get_current_memblocks_size(DBusConnection *conn, DBusMessage *msg, void *userdata);
37 static void handle_get_accumulated_memblocks(DBusConnection *conn, DBusMessage *msg, void *userdata);
38 static void handle_get_accumulated_memblocks_size(DBusConnection *conn, DBusMessage *msg, void *userdata);
39 static void handle_get_sample_cache_size(DBusConnection *conn, DBusMessage *msg, void *userdata);
40
41 static void handle_get_all(DBusConnection *conn, DBusMessage *msg, void *userdata);
42
43 struct pa_dbusiface_memstats {
44 pa_core *core;
45 char *path;
46 pa_dbus_protocol *dbus_protocol;
47 };
48
49 enum property_handler_index {
50 PROPERTY_HANDLER_CURRENT_MEMBLOCKS,
51 PROPERTY_HANDLER_CURRENT_MEMBLOCKS_SIZE,
52 PROPERTY_HANDLER_ACCUMULATED_MEMBLOCKS,
53 PROPERTY_HANDLER_ACCUMULATED_MEMBLOCKS_SIZE,
54 PROPERTY_HANDLER_SAMPLE_CACHE_SIZE,
55 PROPERTY_HANDLER_MAX
56 };
57
58 static pa_dbus_property_handler property_handlers[PROPERTY_HANDLER_MAX] = {
59 [PROPERTY_HANDLER_CURRENT_MEMBLOCKS] = { .property_name = "CurrentMemblocks", .type = "u", .get_cb = handle_get_current_memblocks, .set_cb = NULL },
60 [PROPERTY_HANDLER_CURRENT_MEMBLOCKS_SIZE] = { .property_name = "CurrentMemblocksSize", .type = "u", .get_cb = handle_get_current_memblocks_size, .set_cb = NULL },
61 [PROPERTY_HANDLER_ACCUMULATED_MEMBLOCKS] = { .property_name = "AccumulatedMemblocks", .type = "u", .get_cb = handle_get_accumulated_memblocks, .set_cb = NULL },
62 [PROPERTY_HANDLER_ACCUMULATED_MEMBLOCKS_SIZE] = { .property_name = "AccumulatedMemblocksSize", .type = "u", .get_cb = handle_get_accumulated_memblocks_size, .set_cb = NULL },
63 [PROPERTY_HANDLER_SAMPLE_CACHE_SIZE] = { .property_name = "SampleCacheSize", .type = "u", .get_cb = handle_get_sample_cache_size, .set_cb = NULL }
64 };
65
66 static pa_dbus_interface_info memstats_interface_info = {
67 .name = PA_DBUSIFACE_MEMSTATS_INTERFACE,
68 .method_handlers = NULL,
69 .n_method_handlers = 0,
70 .property_handlers = property_handlers,
71 .n_property_handlers = PROPERTY_HANDLER_MAX,
72 .get_all_properties_cb = handle_get_all,
73 .signals = NULL,
74 .n_signals = 0
75 };
76
handle_get_current_memblocks(DBusConnection * conn,DBusMessage * msg,void * userdata)77 static void handle_get_current_memblocks(DBusConnection *conn, DBusMessage *msg, void *userdata) {
78 pa_dbusiface_memstats *m = userdata;
79 const pa_mempool_stat *stat;
80 dbus_uint32_t current_memblocks;
81
82 pa_assert(conn);
83 pa_assert(msg);
84 pa_assert(m);
85
86 stat = pa_mempool_get_stat(m->core->mempool);
87
88 current_memblocks = pa_atomic_load(&stat->n_allocated);
89
90 pa_dbus_send_basic_variant_reply(conn, msg, DBUS_TYPE_UINT32, ¤t_memblocks);
91 }
92
handle_get_current_memblocks_size(DBusConnection * conn,DBusMessage * msg,void * userdata)93 static void handle_get_current_memblocks_size(DBusConnection *conn, DBusMessage *msg, void *userdata) {
94 pa_dbusiface_memstats *m = userdata;
95 const pa_mempool_stat *stat;
96 dbus_uint32_t current_memblocks_size;
97
98 pa_assert(conn);
99 pa_assert(msg);
100 pa_assert(m);
101
102 stat = pa_mempool_get_stat(m->core->mempool);
103
104 current_memblocks_size = pa_atomic_load(&stat->allocated_size);
105
106 pa_dbus_send_basic_variant_reply(conn, msg, DBUS_TYPE_UINT32, ¤t_memblocks_size);
107 }
108
handle_get_accumulated_memblocks(DBusConnection * conn,DBusMessage * msg,void * userdata)109 static void handle_get_accumulated_memblocks(DBusConnection *conn, DBusMessage *msg, void *userdata) {
110 pa_dbusiface_memstats *m = userdata;
111 const pa_mempool_stat *stat;
112 dbus_uint32_t accumulated_memblocks;
113
114 pa_assert(conn);
115 pa_assert(msg);
116 pa_assert(m);
117
118 stat = pa_mempool_get_stat(m->core->mempool);
119
120 accumulated_memblocks = pa_atomic_load(&stat->n_accumulated);
121
122 pa_dbus_send_basic_variant_reply(conn, msg, DBUS_TYPE_UINT32, &accumulated_memblocks);
123 }
124
handle_get_accumulated_memblocks_size(DBusConnection * conn,DBusMessage * msg,void * userdata)125 static void handle_get_accumulated_memblocks_size(DBusConnection *conn, DBusMessage *msg, void *userdata) {
126 pa_dbusiface_memstats *m = userdata;
127 const pa_mempool_stat *stat;
128 dbus_uint32_t accumulated_memblocks_size;
129
130 pa_assert(conn);
131 pa_assert(msg);
132 pa_assert(m);
133
134 stat = pa_mempool_get_stat(m->core->mempool);
135
136 accumulated_memblocks_size = pa_atomic_load(&stat->accumulated_size);
137
138 pa_dbus_send_basic_variant_reply(conn, msg, DBUS_TYPE_UINT32, &accumulated_memblocks_size);
139 }
140
handle_get_sample_cache_size(DBusConnection * conn,DBusMessage * msg,void * userdata)141 static void handle_get_sample_cache_size(DBusConnection *conn, DBusMessage *msg, void *userdata) {
142 pa_dbusiface_memstats *m = userdata;
143 dbus_uint32_t sample_cache_size;
144
145 pa_assert(conn);
146 pa_assert(msg);
147 pa_assert(m);
148
149 sample_cache_size = pa_scache_total_size(m->core);
150
151 pa_dbus_send_basic_variant_reply(conn, msg, DBUS_TYPE_UINT32, &sample_cache_size);
152 }
153
handle_get_all(DBusConnection * conn,DBusMessage * msg,void * userdata)154 static void handle_get_all(DBusConnection *conn, DBusMessage *msg, void *userdata) {
155 pa_dbusiface_memstats *m = userdata;
156 const pa_mempool_stat *stat;
157 dbus_uint32_t current_memblocks;
158 dbus_uint32_t current_memblocks_size;
159 dbus_uint32_t accumulated_memblocks;
160 dbus_uint32_t accumulated_memblocks_size;
161 dbus_uint32_t sample_cache_size;
162 DBusMessage *reply = NULL;
163 DBusMessageIter msg_iter;
164 DBusMessageIter dict_iter;
165
166 pa_assert(conn);
167 pa_assert(msg);
168 pa_assert(m);
169
170 stat = pa_mempool_get_stat(m->core->mempool);
171
172 current_memblocks = pa_atomic_load(&stat->n_allocated);
173 current_memblocks_size = pa_atomic_load(&stat->allocated_size);
174 accumulated_memblocks = pa_atomic_load(&stat->n_accumulated);
175 accumulated_memblocks_size = pa_atomic_load(&stat->accumulated_size);
176 sample_cache_size = pa_scache_total_size(m->core);
177
178 pa_assert_se((reply = dbus_message_new_method_return(msg)));
179
180 dbus_message_iter_init_append(reply, &msg_iter);
181 pa_assert_se(dbus_message_iter_open_container(&msg_iter, DBUS_TYPE_ARRAY, "{sv}", &dict_iter));
182
183 pa_dbus_append_basic_variant_dict_entry(&dict_iter, property_handlers[PROPERTY_HANDLER_CURRENT_MEMBLOCKS].property_name, DBUS_TYPE_UINT32, ¤t_memblocks);
184 pa_dbus_append_basic_variant_dict_entry(&dict_iter, property_handlers[PROPERTY_HANDLER_CURRENT_MEMBLOCKS_SIZE].property_name, DBUS_TYPE_UINT32, ¤t_memblocks_size);
185 pa_dbus_append_basic_variant_dict_entry(&dict_iter, property_handlers[PROPERTY_HANDLER_ACCUMULATED_MEMBLOCKS].property_name, DBUS_TYPE_UINT32, &accumulated_memblocks);
186 pa_dbus_append_basic_variant_dict_entry(&dict_iter, property_handlers[PROPERTY_HANDLER_ACCUMULATED_MEMBLOCKS_SIZE].property_name, DBUS_TYPE_UINT32, &accumulated_memblocks_size);
187 pa_dbus_append_basic_variant_dict_entry(&dict_iter, property_handlers[PROPERTY_HANDLER_SAMPLE_CACHE_SIZE].property_name, DBUS_TYPE_UINT32, &sample_cache_size);
188
189 pa_assert_se(dbus_message_iter_close_container(&msg_iter, &dict_iter));
190
191 pa_assert_se(dbus_connection_send(conn, reply, NULL));
192
193 dbus_message_unref(reply);
194 }
195
pa_dbusiface_memstats_new(pa_dbusiface_core * dbus_core,pa_core * core)196 pa_dbusiface_memstats *pa_dbusiface_memstats_new(pa_dbusiface_core *dbus_core, pa_core *core) {
197 pa_dbusiface_memstats *m;
198
199 pa_assert(dbus_core);
200 pa_assert(core);
201
202 m = pa_xnew(pa_dbusiface_memstats, 1);
203 m->core = core;
204 m->path = pa_sprintf_malloc("%s/%s", PA_DBUS_CORE_OBJECT_PATH, OBJECT_NAME);
205 m->dbus_protocol = pa_dbus_protocol_get(core);
206
207 pa_assert_se(pa_dbus_protocol_add_interface(m->dbus_protocol, m->path, &memstats_interface_info, m) >= 0);
208
209 return m;
210 }
211
pa_dbusiface_memstats_free(pa_dbusiface_memstats * m)212 void pa_dbusiface_memstats_free(pa_dbusiface_memstats *m) {
213 pa_assert(m);
214
215 pa_assert_se(pa_dbus_protocol_remove_interface(m->dbus_protocol, m->path, memstats_interface_info.name) >= 0);
216
217 pa_xfree(m->path);
218
219 pa_dbus_protocol_unref(m->dbus_protocol);
220
221 pa_xfree(m);
222 }
223
pa_dbusiface_memstats_get_path(pa_dbusiface_memstats * m)224 const char *pa_dbusiface_memstats_get_path(pa_dbusiface_memstats *m) {
225 pa_assert(m);
226
227 return m->path;
228 }
229