s3-vfs: Use the system. namespace for fake ACLs
[kai/samba.git] / source3 / modules / perfcount_test.c
1 /*
2  * Unix SMB/CIFS implementation.
3  * Test module for perfcounters
4  *
5  * Copyright (C) Todd Stecher 2008
6  *
7  * This program is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 3 of the License, or
10  * (at your option) any later version.
11  *
12  * This program is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, see <http://www.gnu.org/licenses/>.
19  */
20
21 #include "includes.h"
22 #include "smbd/smbd.h"
23
24 #define PARM_PC_TEST_TYPE               "pc_test"
25 #define PARM_DUMPON_COUNT               "count"
26 #define PARM_DUMPON_COUNT_DEFAULT       50
27
28 struct perfcount_test_identity {
29         uid_t uid;
30         char *user;
31         char *domain;
32 };
33
34 struct perfcount_test_counter {
35         int op;
36         int sub_op;
37         int ioctl;
38         uint64_t bytes_in;
39         uint64_t bytes_out;
40         int count;
41
42         struct perfcount_test_counter *next;
43         struct perfcount_test_counter *prev;
44 };
45
46 struct perfcount_test_context {
47
48         /* wip:  identity */
49         struct perfcount_test_identity *id;
50         struct perfcount_test_counter *ops;
51 };
52
53 #define MAX_OP 256
54 struct perfcount_test_counter *g_list[MAX_OP];
55
56 int count;
57
58 /* determine frequency of dumping results */
59 int count_mod = 1;
60
61 static void perfcount_test_add_counters(struct perfcount_test_context *ctxt)
62 {
63         struct perfcount_test_counter *head;
64         struct perfcount_test_counter *ptc;
65         struct perfcount_test_counter *tmp;
66         bool found;
67
68         for (ptc = ctxt->ops; ptc != NULL; ) {
69
70                 found = false;
71
72                 if (ptc->op > MAX_OP)
73                         continue;
74
75                 for (head = g_list[ptc->op]; head != NULL; head = head->next) {
76                         if ((ptc->sub_op == head->sub_op) &&
77                             (ptc->ioctl == head->ioctl)) {
78                                 head->bytes_in += ptc->bytes_in;
79                                 head->bytes_out += ptc->bytes_out;
80                                 head->count++;
81                                 tmp = ptc->next;
82                                 DLIST_REMOVE(ctxt->ops, ptc);
83                                 SAFE_FREE(ptc);
84                                 ptc = tmp;
85                                 found = true;
86                                 break;
87                         }
88                 }
89
90                 /* not in global tracking list - add it */
91                 if (!found) {
92                         tmp = ptc->next;
93                         DLIST_REMOVE(ctxt->ops, ptc);
94                         ptc->count = 1;
95                         DLIST_ADD(g_list[ptc->op], ptc);
96                         ptc = tmp;
97                 }
98         }
99
100 }
101
102 #if 0
103
104 static void perfcount_test_dump_id(struct perfcount_test_identity *id, int lvl)
105 {
106         if (!id)
107                 return;
108
109         DEBUG(lvl,("uid - %d\n", id->uid));
110         DEBUG(lvl,("user - %s\n", id->user));
111         DEBUG(lvl,("domain - %s\n", id->domain));
112 }
113
114 #endif
115
116 static const char *trans_subop_table[] = {
117         "unknown", "trans:create", "trans:ioctl", "trans:set sd",
118         "trans:change notify", "trans: rename", "trans:get sd",
119         "trans:get quota", "trans:set quota"
120 };
121
122 static const char *trans2_subop_table[] = {
123         "trans2:open", "trans2:find first", "trans2:find next",
124         "trans2:q fsinfo", "trans2:set fsinfo", "trans2:q path info",
125         "trans2:set pathinfo", "trans2:fs ctl", "trans2: io ctl",
126         "trans2:find notify first", "trans2:find notify next",
127         "trans2:mkdir", "trans2:sess setup", "trans2:get dfs referral",
128         "trans2:report dfs inconsistent"
129 };
130
131 static const char *smb_subop_name(int op, int subop)
132 {
133         /* trans */
134         if (op == 0x25) {
135                 if (subop > sizeof(trans_subop_table) /
136                     sizeof(trans_subop_table[0])) {
137                         return "unknown";
138                 }
139                 return trans_subop_table[subop];
140         } else if (op == 0x32) {
141                 if (subop > sizeof(trans2_subop_table) /
142                     sizeof(trans2_subop_table[0])) {
143                         return "unknown";
144                 }
145                 return trans2_subop_table[subop];
146         }
147
148         return "unknown";
149 }
150
151 static void perfcount_test_dump_counter(struct perfcount_test_counter *ptc,
152                                         int lvl)
153 {
154         DEBUG(lvl, ("OP: %s\n", smb_fn_name(ptc->op)));
155         if (ptc->sub_op > 0) {
156                 DEBUG(lvl, ("SUBOP: %s\n",
157                         smb_subop_name(ptc->op, ptc->sub_op)));
158         }
159
160         if (ptc->ioctl > 0) {
161                 DEBUG(lvl, ("IOCTL: %d\n", ptc->ioctl));
162         }
163
164         DEBUG(lvl, ("Count: %d\n\n", ptc->count));
165 }
166
167 static void perfcount_test_dump_counters(void)
168 {
169         int i;
170         struct perfcount_test_counter *head;
171
172         count_mod = lp_parm_int(0, PARM_PC_TEST_TYPE, PARM_DUMPON_COUNT,
173             PARM_DUMPON_COUNT_DEFAULT);
174
175         if ((count++ % count_mod) != 0)
176                 return;
177
178         DEBUG(0,("#####  Dumping Performance Counters #####\n"));
179
180         for (i=0; i < MAX_OP; i++) {
181                 struct perfcount_test_counter *next;
182                 for (head = g_list[i]; head != NULL; head = next) {
183                         next = head->next;
184                         perfcount_test_dump_counter(head, 0);
185                         SAFE_FREE(head);
186                 }
187                 g_list[i] = NULL;
188         }
189 }
190
191 /*  operations */
192 static void perfcount_test_start(struct smb_perfcount_data *pcd)
193 {
194         struct perfcount_test_context *ctxt;
195         struct perfcount_test_counter *ctr;
196         /*
197          * there shouldn't already be a context here - if so,
198          * there's an unbalanced call to start / end.
199          */
200         if (pcd->context) {
201                 DEBUG(0,("perfcount_test_start - starting "
202                          "initialized context - %p\n", pcd));
203                 return;
204         }
205
206         ctxt = SMB_MALLOC_P(struct perfcount_test_context);
207         if (!ctxt)
208                 return;
209
210         ZERO_STRUCTP(ctxt);
211
212         /* create 'default' context */
213         ctr = SMB_MALLOC_P(struct perfcount_test_counter);
214         if (!ctr) {
215                 SAFE_FREE(ctxt);
216                 return;
217         }
218
219         ZERO_STRUCTP(ctr);
220         ctr->op = ctr->sub_op = ctr->ioctl = -1;
221         DLIST_ADD(ctxt->ops, ctr);
222
223         pcd->context = (void*)ctxt;
224 }
225
226 static void perfcount_test_add(struct smb_perfcount_data *pcd)
227 {
228         struct perfcount_test_context *ctxt =
229                 (struct perfcount_test_context *)pcd->context;
230         struct perfcount_test_counter *ctr;
231
232         if (pcd->context == NULL)
233                 return;
234
235         ctr = SMB_MALLOC_P(struct perfcount_test_counter);
236         if (!ctr) {
237                 return;
238         }
239
240         DLIST_ADD(ctxt->ops, ctr);
241
242 }
243
244 static void perfcount_test_set_op(struct smb_perfcount_data *pcd, int op)
245 {
246         struct perfcount_test_context *ctxt =
247                 (struct perfcount_test_context *)pcd->context;
248
249         if (pcd->context == NULL)
250                 return;
251
252         ctxt->ops->op = op;
253 }
254
255 static void perfcount_test_set_subop(struct smb_perfcount_data *pcd, int sub_op)
256 {
257         struct perfcount_test_context *ctxt =
258                 (struct perfcount_test_context *)pcd->context;
259
260         if (pcd->context == NULL)
261                 return;
262
263         ctxt->ops->sub_op = sub_op;
264 }
265
266 static void perfcount_test_set_ioctl(struct smb_perfcount_data *pcd, int io_ctl)
267 {
268         struct perfcount_test_context *ctxt =
269                 (struct perfcount_test_context *)pcd->context;
270         if (pcd->context == NULL)
271                 return;
272
273         ctxt->ops->ioctl = io_ctl;
274 }
275
276 static void perfcount_test_set_msglen_in(struct smb_perfcount_data *pcd,
277                                          uint64_t bytes_in)
278 {
279         struct perfcount_test_context *ctxt =
280                 (struct perfcount_test_context *)pcd->context;
281         if (pcd->context == NULL)
282                 return;
283
284         ctxt->ops->bytes_in = bytes_in;
285 }
286
287 static void perfcount_test_set_msglen_out(struct smb_perfcount_data *pcd,
288                                           uint64_t bytes_out)
289 {
290         struct perfcount_test_context *ctxt =
291                 (struct perfcount_test_context *)pcd->context;
292
293         if (pcd->context == NULL)
294                 return;
295
296         ctxt->ops->bytes_out = bytes_out;
297 }
298
299 static void perfcount_test_copy_context(struct smb_perfcount_data *pcd,
300                                         struct smb_perfcount_data *new_pcd)
301 {
302         struct perfcount_test_context *ctxt =
303                 (struct perfcount_test_context *)pcd->context;
304         struct perfcount_test_context *new_ctxt;
305
306         struct perfcount_test_counter *ctr;
307         struct perfcount_test_counter *new_ctr;
308
309         if (pcd->context == NULL)
310                 return;
311
312         new_ctxt = SMB_MALLOC_P(struct perfcount_test_context);
313         if (!new_ctxt) {
314                 return;
315         }
316
317         memcpy(new_ctxt, ctxt, sizeof(struct perfcount_test_context));
318
319         for (ctr = ctxt->ops; ctr != NULL; ctr = ctr->next) {
320                 new_ctr = SMB_MALLOC_P(struct perfcount_test_counter);
321                 if (!new_ctr) {
322                         goto error;
323                 }
324
325                 memcpy(new_ctr, ctr, sizeof(struct perfcount_test_counter));
326                 new_ctr->next = NULL;
327                 new_ctr->prev = NULL;
328                 DLIST_ADD(new_ctxt->ops, new_ctr);
329         }
330
331         new_pcd->context = new_ctxt;
332         return;
333
334 error:
335
336         for (ctr = new_ctxt->ops; ctr != NULL; ) {
337                 new_ctr = ctr->next;
338                 SAFE_FREE(ctr);
339                 ctr = new_ctr;
340         }
341
342         SAFE_FREE(new_ctxt);
343 }
344
345 /*
346  * For perf reasons, its best to use some global state
347  * when an operation is deferred, we need to alloc a copy.
348  */
349 static void perfcount_test_defer_op(struct smb_perfcount_data *pcd,
350                                     struct smb_perfcount_data *def_pcd)
351 {
352         /* we don't do anything special to deferred ops */
353         return;
354 }
355
356 static void perfcount_test_end(struct smb_perfcount_data *pcd)
357 {
358         struct perfcount_test_context *ctxt =
359                 (struct perfcount_test_context *)pcd->context;
360         if (pcd->context == NULL)
361                 return;
362
363         /* @bug - we don't store outbytes right for chained cmds */
364         perfcount_test_add_counters(ctxt);
365         perfcount_test_dump_counters();
366         pcd->context = NULL;
367         SAFE_FREE(ctxt);
368 }
369
370
371 static struct smb_perfcount_handlers perfcount_test_handlers = {
372         perfcount_test_start,
373         perfcount_test_add,
374         perfcount_test_set_op,
375         perfcount_test_set_subop,
376         perfcount_test_set_ioctl,
377         perfcount_test_set_msglen_in,
378         perfcount_test_set_msglen_out,
379         perfcount_test_copy_context,
380         perfcount_test_defer_op,
381         perfcount_test_end
382 };
383
384 NTSTATUS samba_init_module(void)
385 {
386         return smb_register_perfcounter(SMB_PERFCOUNTER_INTERFACE_VERSION,
387                                         "pc_test", &perfcount_test_handlers);
388 }