← Back to branch summary

~zulcss/samba/server-dailies-3.4

« back to all changes in this revision

Viewing changes to source4/torture/rpc/bench.c

  • Committer: Chuck Short
  • Date: 2010-09-28 20:38:39 UTC
  • Revision ID: zulcss@ubuntu.com-20100928203839-pgjulytsi9ue63x1
Initial version

Show diffs side-by-side

added added

removed removed

Lines of Context:
source4/torture/rpc/bench.c
 
1
/* 
 
2
   Unix SMB/CIFS implementation.
 
3
 
 
4
   simple RPC benchmark
 
5
 
 
6
   Copyright (C) Andrew Tridgell 2005
 
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 3 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, see <http://www.gnu.org/licenses/>.
 
20
*/
 
21
 
 
22
#include "includes.h"
 
23
#include "torture/torture.h"
 
24
#include "librpc/gen_ndr/ndr_srvsvc_c.h"
 
25
#include "torture/rpc/rpc.h"
 
26
 
 
27
/**************************/
 
28
/* srvsvc_NetShare        */
 
29
/**************************/
 
30
static bool test_NetShareEnumAll(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx)
 
31
{
 
32
        NTSTATUS status;
 
33
        struct srvsvc_NetShareEnumAll r;
 
34
        struct srvsvc_NetShareInfoCtr info_ctr;
 
35
        struct srvsvc_NetShareCtr0 c0;
 
36
        struct srvsvc_NetShareCtr1 c1;
 
37
        struct srvsvc_NetShareCtr2 c2;
 
38
        struct srvsvc_NetShareCtr501 c501;
 
39
        struct srvsvc_NetShareCtr502 c502;
 
40
        uint32_t totalentries = 0;
 
41
        uint32_t levels[] = {0, 1, 2, 501, 502};
 
42
        int i;
 
43
        bool ret = true;
 
44
        uint32_t resume_handle;
 
45
 
 
46
        ZERO_STRUCT(info_ctr);
 
47
 
 
48
        r.in.server_unc = talloc_asprintf(mem_ctx,"\\\\%s",dcerpc_server_name(p));
 
49
        r.in.info_ctr = &info_ctr;
 
50
        r.in.max_buffer = (uint32_t)-1;
 
51
        r.in.resume_handle = &resume_handle;
 
52
        r.out.resume_handle = &resume_handle;
 
53
        r.out.totalentries = &totalentries;
 
54
        r.out.info_ctr = &info_ctr;
 
55
 
 
56
        for (i=0;i<ARRAY_SIZE(levels);i++) {
 
57
                resume_handle = 0;
 
58
                info_ctr.level = levels[i];
 
59
 
 
60
                switch (info_ctr.level) {
 
61
                case 0:
 
62
                        ZERO_STRUCT(c0);
 
63
                        info_ctr.ctr.ctr0 = &c0;
 
64
                        break;
 
65
                case 1:
 
66
                        ZERO_STRUCT(c1);
 
67
                        info_ctr.ctr.ctr1 = &c1;
 
68
                        break;
 
69
                case 2:
 
70
                        ZERO_STRUCT(c2);
 
71
                        info_ctr.ctr.ctr2 = &c2;
 
72
                        break;
 
73
                case 501:
 
74
                        ZERO_STRUCT(c501);
 
75
                        info_ctr.ctr.ctr501 = &c501;
 
76
                        break;
 
77
                case 502:
 
78
                        ZERO_STRUCT(c502);
 
79
                        info_ctr.ctr.ctr502 = &c502;
 
80
                        break;
 
81
                }
 
82
 
 
83
                status = dcerpc_srvsvc_NetShareEnumAll(p, mem_ctx, &r);
 
84
                if (!NT_STATUS_IS_OK(status)) {
 
85
                        printf("NetShareEnumAll level %u failed - %s\n", info_ctr.level, nt_errstr(status));
 
86
                        ret = false;
 
87
                        continue;
 
88
                }
 
89
                if (!W_ERROR_IS_OK(r.out.result)) {
 
90
                        printf("NetShareEnumAll level %u failed - %s\n", info_ctr.level, win_errstr(r.out.result));
 
91
                        continue;
 
92
                }
 
93
        }
 
94
 
 
95
        return ret;
 
96
}
 
97
 
 
98
/*
 
99
  benchmark srvsvc netshareenumall queries
 
100
*/
 
101
static bool bench_NetShareEnumAll(struct torture_context *tctx, struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx)
 
102
{
 
103
        struct timeval tv = timeval_current();
 
104
        bool ret = true;
 
105
        int timelimit = torture_setting_int(tctx, "timelimit", 10);
 
106
        int count=0;
 
107
 
 
108
        printf("Running for %d seconds\n", timelimit);
 
109
        while (timeval_elapsed(&tv) < timelimit) {
 
110
                TALLOC_CTX *tmp_ctx = talloc_new(mem_ctx);
 
111
                if (!test_NetShareEnumAll(p, tmp_ctx)) break;
 
112
                talloc_free(tmp_ctx);
 
113
                count++;
 
114
                if (count % 50 == 0) {
 
115
                        if (torture_setting_bool(tctx, "progress", true)) {
 
116
                                printf("%.1f queries per second  \r", 
 
117
                                       count / timeval_elapsed(&tv));
 
118
                        }
 
119
                }
 
120
        }
 
121
 
 
122
        printf("%.1f queries per second  \n", count / timeval_elapsed(&tv));
 
123
 
 
124
        return ret;
 
125
}
 
126
 
 
127
 
 
128
bool torture_bench_rpc(struct torture_context *torture)
 
129
{
 
130
        NTSTATUS status;
 
131
        struct dcerpc_pipe *p;
 
132
        TALLOC_CTX *mem_ctx;
 
133
        bool ret = true;
 
134
 
 
135
        mem_ctx = talloc_init("torture_rpc_srvsvc");
 
136
 
 
137
        status = torture_rpc_connection(torture, 
 
138
                                        &p,
 
139
                                        &ndr_table_srvsvc);
 
140
        if (!NT_STATUS_IS_OK(status)) {
 
141
                talloc_free(mem_ctx);
 
142
                return false;
 
143
        }
 
144
 
 
145
        if (!bench_NetShareEnumAll(torture, p, mem_ctx)) {
 
146
                ret = false;
 
147
        }
 
148
 
 
149
        talloc_free(mem_ctx);
 
150
 
 
151
        return ret;
 
152
}