1 /*
2 * Test to see how quickly we can scan the inode table (not doing
3 * anything else)
4 */
5
6 #include "config.h"
7 #include <string.h>
8 #include <fcntl.h>
9 #include <ctype.h>
10 #include <termios.h>
11 #include <time.h>
12 #ifdef HAVE_GETOPT_H
13 #include <getopt.h>
14 #endif
15 #include <unistd.h>
16 #ifdef HAVE_ERRNO_H
17 #include <errno.h>
18 #endif
19 #include <sys/ioctl.h>
20 #ifdef HAVE_MALLOC_H
21 #include <malloc.h>
22 #endif
23 #include <sys/time.h>
24 #include <sys/resource.h>
25
26 #if EXT2_FLAT_INCLUDES
27 #include "ext2_fs.h"
28 #include "ext2fs.h"
29 #include "blkid.h"
30 #else
31 #include "ext2fs/ext2_fs.h"
32 #include "ext2fs/ext2fs.h"
33 #include "blkid/blkid.h"
34 #endif
35
36 #include "et/com_err.h"
37 #include "../version.h"
38
39 struct resource_track {
40 struct timeval time_start;
41 struct timeval user_start;
42 struct timeval system_start;
43 void *brk_start;
44 unsigned long long bytes_read;
45 unsigned long long bytes_written;
46 };
47
48 extern int isatty(int);
49
50 const char * program_name = "iscan";
51 const char * device_name = NULL;
52
53 int yflag = 0;
54 int nflag = 0;
55 int preen = 0;
56 int inode_buffer_blocks = 0;
57 int invalid_bitmaps = 0;
58
59 struct resource_track global_rtrack;
60
init_resource_track(struct resource_track * track,io_channel channel)61 void init_resource_track(struct resource_track *track, io_channel channel)
62 {
63 #ifdef HAVE_GETRUSAGE
64 struct rusage r;
65 #endif
66 io_stats io_start = 0;
67
68 track->brk_start = sbrk(0);
69 gettimeofday(&track->time_start, 0);
70 #ifdef HAVE_GETRUSAGE
71 #ifdef sun
72 memset(&r, 0, sizeof(struct rusage));
73 #endif
74 getrusage(RUSAGE_SELF, &r);
75 track->user_start = r.ru_utime;
76 track->system_start = r.ru_stime;
77 #else
78 track->user_start.tv_sec = track->user_start.tv_usec = 0;
79 track->system_start.tv_sec = track->system_start.tv_usec = 0;
80 #endif
81 track->bytes_read = 0;
82 track->bytes_written = 0;
83 if (channel && channel->manager && channel->manager->get_stats)
84 channel->manager->get_stats(channel, &io_start);
85 if (io_start) {
86 track->bytes_read = io_start->bytes_read;
87 track->bytes_written = io_start->bytes_written;
88 }
89 }
90
timeval_subtract(struct timeval * tv1,struct timeval * tv2)91 static float timeval_subtract(struct timeval *tv1,
92 struct timeval *tv2)
93 {
94 return ((tv1->tv_sec - tv2->tv_sec) +
95 ((float) (tv1->tv_usec - tv2->tv_usec)) / 1000000);
96 }
97
print_resource_track(const char * desc,struct resource_track * track,io_channel channel)98 void print_resource_track(const char *desc,
99 struct resource_track *track, io_channel channel)
100 {
101 #ifdef HAVE_GETRUSAGE
102 struct rusage r;
103 #endif
104 struct timeval time_end;
105
106 gettimeofday(&time_end, 0);
107
108 if (desc)
109 printf("%s: ", desc);
110
111 #define kbytes(x) (((unsigned long long)(x) + 1023) / 1024)
112 #ifdef HAVE_MALLINFO2
113 if (1) {
114 struct mallinfo2 malloc_info = mallinfo2();
115
116 printf("Memory used: %lluk/%lluk (%lluk/%lluk), ",
117 kbytes(malloc_info.arena), kbytes(malloc_info.hblkhd),
118 kbytes(malloc_info.uordblks),
119 kbytes(malloc_info.fordblks));
120 } else
121 #elif defined HAVE_MALLINFO
122 /* don't use mallinfo() if over 2GB used, since it returns "int" */
123 if ((char *)sbrk(0) - (char *)track->brk_start < 2LL << 30) {
124 struct mallinfo malloc_info = mallinfo();
125
126 printf("Memory used: %lluk/%lluk (%lluk/%lluk), ",
127 kbytes(malloc_info.arena), kbytes(malloc_info.hblkhd),
128 kbytes(malloc_info.uordblks),
129 kbytes(malloc_info.fordblks));
130 } else
131 #endif
132 printf("Memory used: %lluk, ",
133 kbytes(((char *)sbrk(0)) - ((char *)track->brk_start)));
134
135 #ifdef HAVE_GETRUSAGE
136 getrusage(RUSAGE_SELF, &r);
137
138 printf("time: %5.2f/%5.2f/%5.2f\n",
139 timeval_subtract(&time_end, &track->time_start),
140 timeval_subtract(&r.ru_utime, &track->user_start),
141 timeval_subtract(&r.ru_stime, &track->system_start));
142 #else
143 printf("elapsed time: %6.3f\n",
144 timeval_subtract(&time_end, &track->time_start));
145 #endif
146 #define mbytes(x) (((x) + 1048575) / 1048576)
147 if (channel && channel->manager && channel->manager->get_stats) {
148 io_stats delta = 0;
149 unsigned long long bytes_read = 0;
150 unsigned long long bytes_written = 0;
151
152 if (desc)
153 printf("%s: ", desc);
154
155 channel->manager->get_stats(channel, &delta);
156 if (delta) {
157 bytes_read = delta->bytes_read - track->bytes_read;
158 bytes_written = delta->bytes_written -
159 track->bytes_written;
160 }
161 printf("I/O read: %lluMB, write: %lluMB, "
162 "rate: %.2fMB/s\n",
163 mbytes(bytes_read), mbytes(bytes_written),
164 (double)mbytes(bytes_read + bytes_written) /
165 timeval_subtract(&time_end, &track->time_start));
166 }
167 }
168
usage(void)169 static void usage(void)
170 {
171 fprintf(stderr,
172 "Usage: %s [-F] [-I inode_buffer_blocks] device\n",
173 program_name);
174 exit(1);
175 }
176
PRS(int argc,char * argv[])177 static void PRS(int argc, char *argv[])
178 {
179 int flush = 0;
180 int c;
181 #ifdef MTRACE
182 extern void *mallwatch;
183 #endif
184 errcode_t retval;
185
186 setbuf(stdout, NULL);
187 setbuf(stderr, NULL);
188 initialize_ext2_error_table();
189
190 if (argc && *argv)
191 program_name = *argv;
192 while ((c = getopt (argc, argv, "FI")) != EOF)
193 switch (c) {
194 case 'F':
195 flush = 1;
196 break;
197 case 'I':
198 inode_buffer_blocks = atoi(optarg);
199 break;
200 default:
201 usage ();
202 }
203 device_name = argv[optind];
204 if (flush) {
205 int fd = open(device_name, O_RDONLY, 0);
206
207 if (fd < 0) {
208 com_err("open", errno,
209 "while opening %s for flushing", device_name);
210 exit(1);
211 }
212 if ((retval = ext2fs_sync_device(fd, 1))) {
213 com_err("ext2fs_sync_device", retval,
214 "while trying to flush %s", device_name);
215 exit(1);
216 }
217 close(fd);
218 }
219 }
220
main(int argc,char * argv[])221 int main (int argc, char *argv[])
222 {
223 errcode_t retval = 0;
224 int exit_value = 0;
225 ext2_filsys fs;
226 ext2_ino_t ino;
227 __u32 num_inodes = 0;
228 struct ext2_inode inode;
229 ext2_inode_scan scan;
230
231 PRS(argc, argv);
232
233 retval = ext2fs_open(device_name, 0,
234 0, 0, unix_io_manager, &fs);
235 if (retval) {
236 com_err(program_name, retval, "while trying to open '%s'",
237 device_name);
238 exit(1);
239 }
240
241 init_resource_track(&global_rtrack, fs->io);
242
243 retval = ext2fs_open_inode_scan(fs, inode_buffer_blocks, &scan);
244 if (retval) {
245 com_err(program_name, retval, "while opening inode scan");
246 exit(1);
247 }
248
249 while (1) {
250 retval = ext2fs_get_next_inode(scan, &ino, &inode);
251 if (retval) {
252 com_err(program_name, retval,
253 "while getting next inode");
254 exit(1);
255 }
256 if (ino == 0)
257 break;
258 num_inodes++;
259 }
260
261 print_resource_track(NULL, &global_rtrack, fs->io);
262 printf("%u inodes scanned.\n", num_inodes);
263
264 exit(0);
265 }
266