Whamcloud - gitweb
LU-12853 ptlrpc: zero session enviroment
[fs/lustre-release.git] / lnet / utils / routerstat.c
1 /*
2  * GPL HEADER START
3  *
4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License version 2 only,
8  * as published by the Free Software Foundation.
9  *
10  * This program is distributed in the hope that it will be useful, but
11  * WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  * General Public License version 2 for more details (a copy is included
14  * in the LICENSE file that accompanied this code).
15  *
16  * You should have received a copy of the GNU General Public License
17  * version 2 along with this program; If not, see
18  * http://www.gnu.org/licenses/gpl-2.0.html
19  *
20  * GPL HEADER END
21  */
22 /*
23  * Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved.
24  * Use is subject to license terms.
25  *
26  * Copyright (c) 2011, Intel Corporation.
27  */
28 /*
29  * This file is part of Lustre, http://www.lustre.org/
30  * Lustre is a trademark of Sun Microsystems, Inc.
31  */
32
33 #include <errno.h>
34 #include <fcntl.h>
35 #include <glob.h>
36 #include <limits.h>
37 #include <stdio.h>
38 #include <stdlib.h>
39 #include <string.h>
40 #include <sys/types.h>
41 #include <sys/time.h>
42 #include <unistd.h>
43
44 #include <libcfs/util/param.h>
45
46 double
47 timenow ()
48 {
49    struct timeval tv;
50
51    gettimeofday (&tv, NULL);
52    return (tv.tv_sec + tv.tv_usec / 1000000.0);
53 }
54
55 typedef struct {
56         unsigned long        msgs_alloc;
57         unsigned long        msgs_max;
58         unsigned long        errors;
59         unsigned long        send_count;
60         unsigned long        recv_count;
61         unsigned long        route_count;
62         unsigned long        drop_count;
63         unsigned long long   send_length;
64         unsigned long long   recv_length;
65         unsigned long long   route_length;
66         unsigned long long   drop_length;
67 } counters_t;
68
69 unsigned long long subull(unsigned long long a, unsigned long long b)
70 {
71         if (a < b)
72                 return -1ULL - b + a + 1;
73
74         return a - b;
75 }
76
77 unsigned long long subul(unsigned long a, unsigned long b)
78 {
79         if (a < b)
80                 return -1UL - b + a + 1;
81
82         return a - b;
83 }
84
85 double rul(unsigned long a, double secs)
86 {
87         return (double)a/secs;
88 }
89
90 double rull(unsigned long long a, double secs)
91 {
92         return (double)a/secs;
93 }
94
95 void
96 do_stat (int fd)
97 {
98    static char  buffer[1024];
99    static double last = 0.0;
100    static counters_t old_counter;
101    double now;
102    double t;
103    counters_t new_counter;
104    counters_t counter;
105    int    n;
106
107    lseek (fd, 0, SEEK_SET);
108    now = timenow();
109    n = read(fd, buffer, sizeof(buffer) - 1);
110    if (n < 0)
111    {
112       fprintf (stderr, "Can't read statfile\n");
113       exit (1);
114    }
115    buffer[n] = 0;
116
117    n = sscanf(buffer, "%lu %lu %lu %lu %lu %lu %lu %llu %llu %llu %llu",
118                &new_counter.msgs_alloc, &new_counter.msgs_max,
119                &new_counter.errors, 
120                &new_counter.send_count, &new_counter.recv_count,
121                &new_counter.route_count, &new_counter.drop_count,
122                &new_counter.send_length, &new_counter.recv_length,
123                &new_counter.route_length, &new_counter.drop_length);
124    if (n < 11)
125    {
126       fprintf (stderr, "Can't parse statfile\n");
127       exit (1);
128    }
129
130    if (last == 0.0) {
131                 printf("M %lu(%lu) E %lu S %llu/%lu R %llu/%lu F %llu/%lu "
132                        "D %llu/%lu\n",
133                    new_counter.msgs_alloc, new_counter.msgs_max,
134                    new_counter.errors,
135                    new_counter.send_length, new_counter.send_count,
136                    new_counter.recv_length, new_counter.recv_count,
137                    new_counter.route_length, new_counter.route_count,
138                    new_counter.drop_length, new_counter.drop_count);
139    } else {
140            t = now - last;
141
142            counter.msgs_alloc = new_counter.msgs_alloc;
143            counter.msgs_max = new_counter.msgs_max;
144
145            counter.errors = subul(new_counter.errors, old_counter.errors);
146            counter.send_count = subul(new_counter.send_count, old_counter.send_count);
147            counter.recv_count = subul(new_counter.recv_count, old_counter.recv_count);
148            counter.route_count = subul(new_counter.route_count, old_counter.route_count);
149            counter.drop_count = subul(new_counter.drop_count, old_counter.drop_count);
150            counter.send_length = subull(new_counter.send_length, old_counter.send_length);
151            counter.recv_length = subull(new_counter.recv_length, old_counter.recv_length);
152            counter.route_length = subull(new_counter.route_length, old_counter.route_length);
153            counter.drop_length = subull(new_counter.drop_length, old_counter.drop_length);
154
155            printf ("M %3lu(%3lu) E %0.0f S %7.2f/%6.0f R %7.2f/%6.0f F %7.2f/%6.0f D %4.2f/%0.0f\n",
156                    counter.msgs_alloc, counter.msgs_max,
157                    rul(counter.errors,t),
158                    rull(counter.send_length,t*1024.0*1024.0), rul(counter.send_count, t),
159                    rull(counter.recv_length,t*1024.0*1024.0), rul(counter.recv_count, t),
160                    rull(counter.route_length,t*1024.0*1024.0), rul(counter.route_count, t),
161                    rull(counter.drop_length,t*1024.0*1024.0), rul(counter.drop_count, t));
162    }
163
164    old_counter = new_counter;
165    fflush (stdout);
166
167    lseek (fd, 0, SEEK_SET);
168    last = timenow();
169 }
170
171 int main(int argc, char **argv)
172 {
173         int interval = 0;
174         glob_t path;
175         int fd;
176
177         if (argc > 1)
178                 interval = atoi(argv[1]);
179
180         if (cfs_get_param_paths(&path, "stats") != 0) {
181                 fprintf(stderr, "LNet stats not available\n");
182                 return 1;
183         }
184
185         fd = open(path.gl_pathv[0], O_RDONLY);
186         if (fd < 0) {
187                 fprintf(stderr, "failed to open '%s': %s\n", path.gl_pathv[0],
188                         strerror(errno));
189                 cfs_free_param_data(&path);
190                 return 1;
191         }
192         cfs_free_param_data(&path);
193
194         do_stat(fd);
195         if (interval == 0)
196                 return 0;
197
198         while (1) {
199                 sleep(interval);
200                 do_stat(fd);
201         }
202         /* Never reached */
203 }