perf tools: Add debugfs utility routines for perf
[muen/linux.git] / tools / perf / util / debugfs.c
1 #include "util.h"
2 #include "debugfs.h"
3 #include "cache.h"
4
5 static int debugfs_premounted;
6 static char debugfs_mountpoint[MAX_PATH+1];
7
8 static const char *debugfs_known_mountpoints[] = {
9         "/sys/kernel/debug/",
10         "/debug/",
11         0,
12 };
13
14 /* use this to force a umount */
15 void debugfs_force_cleanup(void)
16 {
17         debugfs_find_mountpoint();
18         debugfs_premounted = 0;
19         debugfs_umount();
20 }
21
22 /* construct a full path to a debugfs element */
23 int debugfs_make_path(const char *element, char *buffer, int size)
24 {
25         int len;
26
27         if (strlen(debugfs_mountpoint) == 0) {
28                 buffer[0] = '\0';
29                 return -1;
30         }
31
32         len = strlen(debugfs_mountpoint) + strlen(element) + 1;
33         if (len >= size)
34                 return len+1;
35
36         snprintf(buffer, size-1, "%s/%s", debugfs_mountpoint, element);
37         return 0;
38 }
39
40 static int debugfs_found;
41
42 /* find the path to the mounted debugfs */
43 const char *debugfs_find_mountpoint(void)
44 {
45         const char **ptr;
46         char type[100];
47         FILE *fp;
48
49         if (debugfs_found)
50                 return (const char *) debugfs_mountpoint;
51
52         ptr = debugfs_known_mountpoints;
53         while (*ptr) {
54                 if (debugfs_valid_mountpoint(*ptr) == 0) {
55                         debugfs_found = 1;
56                         strcpy(debugfs_mountpoint, *ptr);
57                         return debugfs_mountpoint;
58                 }
59                 ptr++;
60         }
61
62         /* give up and parse /proc/mounts */
63         fp = fopen("/proc/mounts", "r");
64         if (fp == NULL)
65                 die("Can't open /proc/mounts for read");
66
67         while (fscanf(fp, "%*s %"
68                       STR(MAX_PATH)
69                       "s %99s %*s %*d %*d\n",
70                       debugfs_mountpoint, type) == 2) {
71                 if (strcmp(type, "debugfs") == 0)
72                         break;
73         }
74         fclose(fp);
75
76         if (strcmp(type, "debugfs") != 0)
77                 return NULL;
78
79         debugfs_found = 1;
80
81         return debugfs_mountpoint;
82 }
83
84 /* verify that a mountpoint is actually a debugfs instance */
85
86 int debugfs_valid_mountpoint(const char *debugfs)
87 {
88         struct statfs st_fs;
89
90         if (statfs(debugfs, &st_fs) < 0)
91                 return -ENOENT;
92         else if (st_fs.f_type != (long) DEBUGFS_MAGIC)
93                 return -ENOENT;
94
95         return 0;
96 }
97
98
99 int debugfs_valid_entry(const char *path)
100 {
101         struct stat st;
102
103         if (stat(path, &st))
104                 return -errno;
105
106         return 0;
107 }
108
109 /* mount the debugfs somewhere */
110
111 int debugfs_mount(const char *mountpoint)
112 {
113         char mountcmd[128];
114
115         /* see if it's already mounted */
116         if (debugfs_find_mountpoint()) {
117                 debugfs_premounted = 1;
118                 return 0;
119         }
120
121         /* if not mounted and no argument */
122         if (mountpoint == NULL) {
123                 /* see if environment variable set */
124                 mountpoint = getenv(PERF_DEBUGFS_ENVIRONMENT);
125                 /* if no environment variable, use default */
126                 if (mountpoint == NULL)
127                         mountpoint = "/sys/kernel/debug";
128         }
129
130         /* save the mountpoint */
131         strncpy(debugfs_mountpoint, mountpoint, sizeof(debugfs_mountpoint));
132
133         /* mount it */
134         snprintf(mountcmd, sizeof(mountcmd),
135                  "/bin/mount -t debugfs debugfs %s", mountpoint);
136         return system(mountcmd);
137 }
138
139 /* umount the debugfs */
140
141 int debugfs_umount(void)
142 {
143         char umountcmd[128];
144         int ret;
145
146         /* if it was already mounted, leave it */
147         if (debugfs_premounted)
148                 return 0;
149
150         /* make sure it's a valid mount point */
151         ret = debugfs_valid_mountpoint(debugfs_mountpoint);
152         if (ret)
153                 return ret;
154
155         snprintf(umountcmd, sizeof(umountcmd),
156                  "/bin/umount %s", debugfs_mountpoint);
157         return system(umountcmd);
158 }
159
160 int debugfs_write(const char *entry, const char *value)
161 {
162         char path[MAX_PATH+1];
163         int ret, count;
164         int fd;
165
166         /* construct the path */
167         snprintf(path, sizeof(path), "%s/%s", debugfs_mountpoint, entry);
168
169         /* verify that it exists */
170         ret = debugfs_valid_entry(path);
171         if (ret)
172                 return ret;
173
174         /* get how many chars we're going to write */
175         count = strlen(value);
176
177         /* open the debugfs entry */
178         fd = open(path, O_RDWR);
179         if (fd < 0)
180                 return -errno;
181
182         while (count > 0) {
183                 /* write it */
184                 ret = write(fd, value, count);
185                 if (ret <= 0) {
186                         if (ret == EAGAIN)
187                                 continue;
188                         close(fd);
189                         return -errno;
190                 }
191                 count -= ret;
192         }
193
194         /* close it */
195         close(fd);
196
197         /* return success */
198         return 0;
199 }
200
201 /*
202  * read a debugfs entry
203  * returns the number of chars read or a negative errno
204  */
205 int debugfs_read(const char *entry, char *buffer, size_t size)
206 {
207         char path[MAX_PATH+1];
208         int ret;
209         int fd;
210
211         /* construct the path */
212         snprintf(path, sizeof(path), "%s/%s", debugfs_mountpoint, entry);
213
214         /* verify that it exists */
215         ret = debugfs_valid_entry(path);
216         if (ret)
217                 return ret;
218
219         /* open the debugfs entry */
220         fd = open(path, O_RDONLY);
221         if (fd < 0)
222                 return -errno;
223
224         do {
225                 /* read it */
226                 ret = read(fd, buffer, size);
227                 if (ret == 0) {
228                         close(fd);
229                         return EOF;
230                 }
231         } while (ret < 0 && errno == EAGAIN);
232
233         /* close it */
234         close(fd);
235
236         /* make *sure* there's a null character at the end */
237         buffer[ret] = '\0';
238
239         /* return the number of chars read */
240         return ret;
241 }