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 perfcount_test_init(void)
 385 {
 386         return smb_register_perfcounter(SMB_PERFCOUNTER_INTERFACE_VERSION,
 387                                         "pc_test", &perfcount_test_handlers);
 388 }