1 /*
2 * blktrace output analysis: generate a timeline & gather statistics
3 *
4 * Copyright (C) 2006 Alan D. Brunelle <Alan.Brunelle@hp.com>
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 as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19 *
20 */
21 #include <errno.h>
22 #include <stdio.h>
23 #include <string.h>
24 #include <unistd.h>
25 #include <sys/types.h>
26 #include <sys/stat.h>
27 #include <sys/time.h>
28 #include <sys/resource.h>
29 #include <fcntl.h>
30
31 #define INLINE_DECLARE
32 #include "globals.h"
33
34 struct file_info {
35 struct list_head head;
36 FILE *ofp;
37 char *oname;
38 };
39
40 struct buf_info {
41 struct list_head head;
42 void *buf;
43 };
44
45 LIST_HEAD(files_to_clean);
46 LIST_HEAD(all_bufs);
47
clean_files(void)48 static void clean_files(void)
49 {
50 struct list_head *p, *q;
51
52 list_for_each_safe(p, q, &files_to_clean) {
53 struct stat buf;
54 struct file_info *fip = list_entry(p, struct file_info, head);
55
56 fclose(fip->ofp);
57 if (!stat(fip->oname, &buf) && (buf.st_size == 0))
58 unlink(fip->oname);
59
60 list_del(&fip->head);
61 free(fip->oname);
62 free(fip);
63 }
64 }
65
clean_bufs(void)66 static void clean_bufs(void)
67 {
68 struct list_head *p, *q;
69
70 list_for_each_safe(p, q, &all_bufs) {
71 struct buf_info *bip = list_entry(p, struct buf_info, head);
72
73 list_del(&bip->head);
74 free(bip->buf);
75 free(bip);
76 }
77 }
78
79 /*
80 * Due to the N(devs) parts of a lot of the output features provided
81 * by btt, it will fail opens on large(ish) systems. Here we try to
82 * keep bumping our open file limits, and if those fail, we return NULL.
83 *
84 * Root users will probably be OK with this, others...
85 */
increase_limit(int resource,rlim_t increase)86 static int increase_limit(int resource, rlim_t increase)
87 {
88 struct rlimit rlim;
89 int save_errno = errno;
90
91 if (!getrlimit(resource, &rlim)) {
92 rlim.rlim_cur += increase;
93 if (rlim.rlim_cur >= rlim.rlim_max)
94 rlim.rlim_max = rlim.rlim_cur + increase;
95
96 if (!setrlimit(resource, &rlim))
97 return 1;
98 }
99
100 errno = save_errno;
101 return 0;
102 }
103
handle_open_failure(void)104 static int handle_open_failure(void)
105 {
106 if (errno == ENFILE || errno == EMFILE)
107 return increase_limit(RLIMIT_NOFILE, 16);
108
109 return 0;
110 }
111
add_file(FILE * fp,char * oname)112 void add_file(FILE *fp, char *oname)
113 {
114 struct file_info *fip = malloc(sizeof(*fip));
115
116 fip->ofp = fp;
117 fip->oname = oname;
118 list_add_tail(&fip->head, &files_to_clean);
119 }
120
add_buf(void * buf)121 void add_buf(void *buf)
122 {
123 struct buf_info *bip = malloc(sizeof(*bip));
124
125 bip->buf = buf;
126 list_add_tail(&bip->head, &all_bufs);
127 }
128
clean_allocs(void)129 void clean_allocs(void)
130 {
131 clean_files();
132 clean_bufs();
133 }
134
make_dev_hdr(char * pad,size_t len,struct d_info * dip,int add_parens)135 char *make_dev_hdr(char *pad, size_t len, struct d_info *dip, int add_parens)
136 {
137 if (dip->devmap)
138 snprintf(pad, len, "%s", dip->devmap);
139 else if (add_parens)
140 snprintf(pad, len, "(%3d,%3d)",
141 MAJOR(dip->device), MINOR(dip->device));
142 else
143 snprintf(pad, len, "%d,%d",
144 MAJOR(dip->device), MINOR(dip->device));
145
146 return pad;
147 }
148
mkhandle(struct d_info * dip,char * str,size_t len)149 char *mkhandle(struct d_info *dip, char *str, size_t len)
150 {
151 return make_dev_hdr(str, len, dip, 0);
152 }
153
my_fopen(const char * path,const char * mode)154 FILE *my_fopen(const char *path, const char *mode)
155 {
156 FILE *fp;
157
158 do {
159 fp = fopen(path, mode);
160 } while (fp == NULL && handle_open_failure());
161
162 return fp;
163 }
164
my_open(const char * path,int flags)165 int my_open(const char *path, int flags)
166 {
167 int fd;
168
169 do {
170 fd = open(path, flags);
171 } while (fd < 0 && handle_open_failure());
172
173 return fd;
174 }
175
dbg_ping(void)176 void dbg_ping(void) {}
177