Whamcloud - gitweb
Branch HEAD
[fs/lustre-release.git] / libcfs / libcfs / util / l_ioctl.c
1 /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
2  * vim:expandtab:shiftwidth=8:tabstop=8:
3  *
4  * Copyright (C) 2001, 2002 Cluster File Systems, Inc.
5  *
6  *   This file is part of Portals, http://www.sf.net/projects/lustre/
7  *
8  *   Portals is free software; you can redistribute it and/or
9  *   modify it under the terms of version 2 of the GNU General Public
10  *   License as published by the Free Software Foundation.
11  *
12  *   Portals is distributed in the hope that it will be useful,
13  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
14  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  *   GNU General Public License for more details.
16  *
17  *   You should have received a copy of the GNU General Public License
18  *   along with Portals; if not, write to the Free Software
19  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20  *
21  */
22
23 #define __USE_FILE_OFFSET64
24
25 #include <libcfs/libcfsutil.h>
26
27 #include <lnet/api-support.h>
28 #include <lnet/lnetctl.h>
29
30 static ioc_handler_t  do_ioctl;                 /* forward ref */
31 static ioc_handler_t *current_ioc_handler = &do_ioctl;
32
33 struct ioc_dev {
34         const char * dev_name;
35         int dev_fd;
36         int dev_major;
37         int dev_minor;
38 };
39
40 static struct ioc_dev ioc_dev_list[10];
41
42 struct dump_hdr {
43         int magic;
44         int dev_id;
45         unsigned int opc;
46 };
47
48 char *dump_filename;
49
50 void
51 set_ioc_handler (ioc_handler_t *handler)
52 {
53         if (handler == NULL)
54                 current_ioc_handler = do_ioctl;
55         else
56                 current_ioc_handler = handler;
57 }
58
59 /* Catamount has no <linux/kdev_t.h>, so just define it here */
60 #ifndef MKDEV
61 # define MKDEV(a,b) (((a) << 8) | (b))
62 #endif
63
64 static int
65 open_ioc_dev(int dev_id) 
66 {
67         const char * dev_name;
68
69         if (dev_id < 0 || 
70             dev_id >= sizeof(ioc_dev_list) / sizeof(ioc_dev_list[0]))
71                 return -EINVAL;
72
73         dev_name = ioc_dev_list[dev_id].dev_name;
74         if (dev_name == NULL) {
75                 fprintf(stderr, "unknown device id: %d\n", dev_id);
76                 return -EINVAL;
77         }
78
79         if (ioc_dev_list[dev_id].dev_fd < 0) {
80                 int fd = open(dev_name, O_RDWR);
81
82                 /* Make the /dev/ node if we need to */
83                 if (fd < 0 && errno == ENOENT) {
84                         if (mknod(dev_name, 
85                                   S_IFCHR|S_IWUSR|S_IRUSR,
86                                   MKDEV(ioc_dev_list[dev_id].dev_major,
87                                         ioc_dev_list[dev_id].dev_minor)) == 0)
88                                 fd = open(dev_name, O_RDWR);
89                         else
90                                 fprintf(stderr, "mknod %s failed: %s\n",
91                                         dev_name, strerror(errno));
92                 }
93
94                 if (fd < 0) {
95                         fprintf(stderr, "opening %s failed: %s\n"
96                                 "hint: the kernel modules may not be loaded\n",
97                                 dev_name, strerror(errno));
98                         return fd;
99                 }
100                 ioc_dev_list[dev_id].dev_fd = fd;
101         }
102
103         return ioc_dev_list[dev_id].dev_fd;
104 }
105
106
107 static int 
108 do_ioctl(int dev_id, unsigned int opc, void *buf)
109 {
110         int fd, rc;
111         
112         fd = open_ioc_dev(dev_id);
113         if (fd < 0) 
114                 return fd;
115
116         rc = ioctl(fd, opc, buf);
117         return rc;
118         
119 }
120
121 static FILE *
122 get_dump_file() 
123 {
124         FILE *fp = NULL;
125         
126         if (!dump_filename) {
127                 fprintf(stderr, "no dump filename\n");
128         } else 
129                 fp = fopen(dump_filename, "a");
130         return fp;
131 }
132
133 /*
134  * The dump file should start with a description of which devices are
135  * used, but for now it will assumed whatever app reads the file will
136  * know what to do. */
137 int 
138 dump(int dev_id, unsigned int opc, void *buf)
139 {
140         FILE *fp;
141         struct dump_hdr dump_hdr;
142         struct libcfs_ioctl_hdr * ioc_hdr = (struct  libcfs_ioctl_hdr *) buf;
143         int rc;
144         
145         printf("dumping opc %x to %s\n", opc, dump_filename);
146         
147
148         dump_hdr.magic = 0xdeadbeef;
149         dump_hdr.dev_id = dev_id;
150         dump_hdr.opc = opc;
151
152         fp = get_dump_file();
153         if (fp == NULL) {
154                 fprintf(stderr, "%s: %s\n", dump_filename, 
155                         strerror(errno));
156                 return -EINVAL;
157         }
158         
159         rc = fwrite(&dump_hdr, sizeof(dump_hdr), 1, fp);
160         if (rc == 1)
161                 rc = fwrite(buf, ioc_hdr->ioc_len, 1, fp);
162         fclose(fp);
163         if (rc != 1) {
164                 fprintf(stderr, "%s: %s\n", dump_filename,
165                         strerror(errno));
166                 return -EINVAL;
167         }
168
169         return 0;
170 }
171
172 /* register a device to send ioctls to.  */
173 int 
174 register_ioc_dev(int dev_id, const char * dev_name, int major, int minor) 
175 {
176
177         if (dev_id < 0 || 
178             dev_id >= sizeof(ioc_dev_list) / sizeof(ioc_dev_list[0]))
179                 return -EINVAL;
180
181         unregister_ioc_dev(dev_id);
182
183         ioc_dev_list[dev_id].dev_name = dev_name;
184         ioc_dev_list[dev_id].dev_fd = -1;
185         ioc_dev_list[dev_id].dev_major = major;
186         ioc_dev_list[dev_id].dev_minor = minor;
187  
188         return dev_id;
189 }
190
191 void
192 unregister_ioc_dev(int dev_id) 
193 {
194
195         if (dev_id < 0 || 
196             dev_id >= sizeof(ioc_dev_list) / sizeof(ioc_dev_list[0]))
197                 return;
198         if (ioc_dev_list[dev_id].dev_name != NULL &&
199             ioc_dev_list[dev_id].dev_fd >= 0) 
200                 close(ioc_dev_list[dev_id].dev_fd);
201
202         ioc_dev_list[dev_id].dev_name = NULL;
203         ioc_dev_list[dev_id].dev_fd = -1;
204 }
205
206 /* If this file is set, then all ioctl buffers will be 
207    appended to the file. */
208 int
209 set_ioctl_dump(char * file)
210 {
211         if (dump_filename)
212                 free(dump_filename);
213         
214         dump_filename = strdup(file);
215         if (dump_filename == NULL)
216                 abort();
217
218         set_ioc_handler(&dump);
219         return 0;
220 }
221
222 int
223 l_ioctl(int dev_id, unsigned int opc, void *buf)
224 {
225         return current_ioc_handler(dev_id, opc, buf);
226 }
227
228 /* Read an ioctl dump file, and call the ioc_func for each ioctl buffer
229  * in the file.  For example:
230  *
231  * parse_dump("lctl.dump", l_ioctl);
232  *
233  * Note: if using l_ioctl, then you also need to register_ioc_dev() for 
234  * each device used in the dump.
235  */
236 int 
237 parse_dump(char * dump_file, ioc_handler_t ioc_func)
238 {
239         int line =0;
240         struct stat st;
241         char *start, *buf, *end;
242 #ifndef __CYGWIN__
243         int fd;
244 #else
245         HANDLE fd, hmap;
246         DWORD size;
247 #endif
248         
249 #ifndef __CYGWIN__
250         fd = open(dump_file, O_RDONLY);
251         if (fd < 0) {
252                 fprintf(stderr, "couldn't open %s: %s\n", dump_file, 
253                         strerror(errno));
254                 exit(1);
255         }
256
257         if (fstat(fd, &st)) { 
258                 perror("stat fails");
259                 exit(1);
260         }
261
262         if (st.st_size < 1) {
263                 fprintf(stderr, "KML is empty\n");
264                 exit(1);
265         }
266
267         start = buf = mmap(NULL, st.st_size, PROT_READ, MAP_PRIVATE , fd, 0);
268         end = start + st.st_size;
269         close(fd);
270         if (start == MAP_FAILED) {
271                 fprintf(stderr, "can't create file mapping\n");
272                 exit(1);
273         }
274 #else
275         fd = CreateFile(dump_file, GENERIC_READ, FILE_SHARE_READ, NULL,
276                         OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
277         size = GetFileSize(fd, NULL);
278         if (size < 1) {
279                 fprintf(stderr, "KML is empty\n");
280                 exit(1);
281         }
282
283         hmap = CreateFileMapping(fd, NULL, PAGE_READONLY, 0,0, NULL);
284         start = buf = MapViewOfFile(hmap, FILE_MAP_READ, 0, 0, 0);
285         end = buf + size;
286         CloseHandle(fd);
287         if (start == NULL) {
288                 fprintf(stderr, "can't create file mapping\n");
289                 exit(1);
290         }
291 #endif /* __CYGWIN__ */
292
293         while (buf < end) {
294                 struct dump_hdr *dump_hdr = (struct dump_hdr *) buf;
295                 struct libcfs_ioctl_hdr * data;
296                 char tmp[8096];
297                 int rc;
298
299                 line++;
300
301                 data = (struct libcfs_ioctl_hdr *) (buf + sizeof(*dump_hdr));
302                 if (buf + data->ioc_len > end ) {
303                         fprintf(stderr, "dump file overflow, %p + %d > %p\n", buf,
304                                 data->ioc_len, end);
305                         return -1;
306                 }
307 #if 0
308                 printf ("dump_hdr: %lx data: %lx\n",
309                         (unsigned long)dump_hdr - (unsigned long)buf, (unsigned long)data - (unsigned long)buf);
310
311                 printf("%d: opcode %x len: %d  ver: %x ", line, dump_hdr->opc,
312                        data->ioc_len, data->ioc_version);
313 #endif
314
315                 memcpy(tmp, data, data->ioc_len);
316
317                 rc = ioc_func(dump_hdr->dev_id, dump_hdr->opc, tmp);
318                 if (rc) {
319                         printf("failed: %d\n", rc);
320                         exit(1);
321                 }
322
323                 buf += data->ioc_len + sizeof(*dump_hdr);
324         }
325
326 #ifndef __CYGWIN__
327         munmap(start, end - start);
328 #else
329         UnmapViewOfFile(start);
330         CloseHandle(hmap);
331 #endif
332
333         return 0;
334 }
335
336 int 
337 jt_ioc_dump(int argc, char **argv)
338 {
339         if (argc > 2) {
340                 fprintf(stderr, "usage: %s [hostname]\n", argv[0]);
341                 return 0;
342         }
343         printf("setting dumpfile to: %s\n", argv[1]);
344         
345         set_ioctl_dump(argv[1]);
346         return 0;
347 }
348
349 int libcfs_ioctl_pack(struct libcfs_ioctl_data *data, char **pbuf,
350                                     int max)
351 {
352         char *ptr;
353         struct libcfs_ioctl_data *overlay;
354         data->ioc_len = libcfs_ioctl_packlen(data);
355         data->ioc_version = LIBCFS_IOCTL_VERSION;
356
357         if (*pbuf && libcfs_ioctl_packlen(data) > max)
358                 return 1;
359         if (*pbuf == NULL) {
360                 *pbuf = malloc(data->ioc_len);
361         }
362         if (!*pbuf)
363                 return 1;
364         overlay = (struct libcfs_ioctl_data *)*pbuf;
365         memcpy(*pbuf, data, sizeof(*data));
366
367         ptr = overlay->ioc_bulk;
368         if (data->ioc_inlbuf1)
369                 LOGL(data->ioc_inlbuf1, data->ioc_inllen1, ptr);
370         if (data->ioc_inlbuf2)
371                 LOGL(data->ioc_inlbuf2, data->ioc_inllen2, ptr);
372         if (libcfs_ioctl_is_invalid(overlay))
373                 return 1;
374
375         return 0;
376 }
377