Whamcloud - gitweb
3a029b35ad34c4face338b129b11a7a93ebf1b83
[fs/lustre-release.git] / lustre / utils / obdctl.c
1 /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
2  * vim:expandtab:shiftwidth=8:tabstop=8:
3  *
4  *  Copyright (C) 2002 Cluster File Systems, Inc.
5  *   Author: Peter J. Braam <braam@clusterfs.com>
6  *   Author: Phil Schwan <phil@clusterfs.com>
7  *
8  *   This file is part of Lustre, http://www.lustre.org.
9  *
10  *   Lustre is free software; you can redistribute it and/or
11  *   modify it under the terms of version 2 of the GNU General Public
12  *   License as published by the Free Software Foundation.
13  *
14  *   Lustre is distributed in the hope that it will be useful,
15  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
16  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17  *   GNU General Public License for more details.
18  *
19  *   You should have received a copy of the GNU General Public License
20  *   along with Lustre; if not, write to the Free Software
21  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
22  *
23  */
24
25 #include <stdlib.h>
26 #include <sys/ioctl.h>
27 #include <fcntl.h>
28 #include <sys/socket.h>
29 #include <sys/types.h>
30 #include <sys/stat.h>
31 #include <stdio.h>
32 #define printk printf
33 #include <linux/lustre_lib.h>
34 #include <linux/lustre_idl.h>
35 #include <unistd.h>
36 #include <sys/un.h>
37 #include <sys/time.h>
38 #include <netinet/in.h>
39 #include <errno.h>
40 #include <string.h>
41
42 #define __KERNEL__
43 #include <linux/list.h>
44 #undef __KERNEL__
45
46 #include "parser.h"
47 #include <stdio.h>
48
49 int fd = -1;
50 int connid = -1;
51 char rawbuf[8192];
52 char *buf = rawbuf;
53 int max = 8192;
54
55 #define IOCINIT(data) do { memset(&data, 0, sizeof(data)); data.ioc_version = OBD_IOCTL_VERSION; data.ioc_conn1 = connid; data.ioc_len = sizeof(data); if (fd < 0) { printf("No device open, use device\n"); return 1;}} while (0)
56
57 /*
58     pack "LL LL LL LL LL LL LL L L L L L L L L L a60 a60 L L L", 
59     $obdo->{id}, 0, 
60     $obdo->{gr}, 0, 
61     $obdo->{atime}, 0, 
62     $obdo->{mtime}, 0 ,
63     $obdo->{ctime}, 0, 
64     $obdo->{size}, 0, 
65     $obdo->{blocks}, 0, 
66     $obdo->{blksize},
67     $obdo->{mode},
68     $obdo->{uid},
69     $obdo->{gid},
70     $obdo->{flags},
71     $obdo->{obdflags},
72     $obdo->{nlink},     
73     $obdo->{generation},        
74     $obdo->{valid},     
75     $obdo->{inline},
76     $obdo->{obdmd},
77     0, 0, # struct list_head 
78     0;  #  struct obd_ops 
79 }
80
81 */
82
83 char * obdo_print(struct obdo *obd)
84 {
85         char buf[1024];
86
87         sprintf(buf, "id: %Ld\ngrp: %Ld\natime: %Ld\nmtime: %Ld\nctime: %Ld\nsize: %Ld\nblocks: %Ld\nblksize: %d\nmode: %o\nuid: %d\ngid: %d\nflags: %x\nobdflags: %x\nnlink: %d,\nvalid %x\n",
88                 obd->o_id,
89                 obd->o_gr,
90                 obd->o_atime,
91                 obd->o_mtime,
92                 obd->o_ctime,
93                 obd->o_size,
94                 obd->o_blocks,
95                 obd->o_blksize,
96                 obd->o_mode,
97                 obd->o_uid,
98                 obd->o_gid,
99                 obd->o_flags,
100                 obd->o_obdflags,
101                 obd->o_nlink,
102                 obd->o_valid);
103         return strdup(buf);
104 }
105
106 static int jt_device(int argc, char **argv)
107 {
108         struct obd_ioctl_data data;
109         int rc;
110
111         memset(&data, 0, sizeof(data));
112         if ( argc != 2 ) {
113                 fprintf(stderr, "Usage: %s devno\n", argv[0]);
114                 return 1;
115         }
116
117         data.ioc_dev = atoi(argv[1]);
118
119         if (obd_ioctl_pack(&data, &buf, max)) { 
120                 printf("invalid ioctl\n"); 
121                 return 1;
122         }
123
124         if (fd == -1) 
125                 fd = open("/dev/obd", O_RDWR);
126         if (fd == -1) {
127                 printf("Opening /dev/obd: %s\n", strerror(errno));
128                 return 1;
129         }
130
131         rc = ioctl(fd, OBD_IOC_DEVICE , buf);
132         if (rc < 0) {
133                 printf("Device: %x %s\n", OBD_IOC_DEVICE, strerror(errno));
134                 return 1;
135         }
136
137         return 0;
138 }
139
140 static int jt_connect(int argc, char **argv)
141 {
142         struct obd_ioctl_data data;
143         int rc;
144
145         IOCINIT(data);
146
147         if ( argc != 1 ) {
148                 fprintf(stderr, "Usage: %s\n", argv[0]);
149                 return 1;
150         }
151
152         rc = ioctl(fd, OBD_IOC_CONNECT , &data);
153         if (rc < 0) {
154                 printf("Device: %x %s\n", OBD_IOC_CONNECT, strerror(errno));
155                 return 1;
156         }
157         connid = data.ioc_conn1;
158
159         return 0;
160 }
161
162 static int jt_disconnect(int argc, char **argv)
163 {
164         struct obd_ioctl_data data;
165         int rc;
166
167         IOCINIT(data);
168
169         if ( argc != 1 ) {
170                 fprintf(stderr, "Usage: %s\n", argv[0]);
171                 return 1;
172         }
173
174         rc = ioctl(fd, OBD_IOC_DISCONNECT , &data);
175         if (rc < 0) {
176                 printf("Device: %x %s\n", OBD_IOC_DISCONNECT, strerror(errno));
177                 return 1;
178         }
179         connid = -1;
180
181         return 0;
182 }
183
184
185 static int jt_detach(int argc, char **argv)
186 {
187         struct obd_ioctl_data data;
188         int rc;
189
190         IOCINIT(data);
191
192         if ( argc != 1 ) {
193                 fprintf(stderr, "Usage: %s\n", argv[0]);
194                 return 1;
195         }
196
197         if (obd_ioctl_pack(&data, &buf, max)) { 
198                 printf("invalid ioctl\n"); 
199                 return 1;
200         }
201
202         rc = ioctl(fd, OBD_IOC_DETACH , buf);
203         if (rc < 0) {
204                 printf("Detach: %s\n", strerror(errno));
205                 return 1;
206         }
207         return 0;
208 }
209
210 static int jt_cleanup(int argc, char **argv)
211 {
212         struct obd_ioctl_data data;
213         int rc;
214
215         IOCINIT(data);
216
217         if ( argc != 1 ) {
218                 fprintf(stderr, "Usage: %s\n", argv[0]);
219                 return 1;
220         }
221
222         rc = ioctl(fd, OBD_IOC_CLEANUP , &data);
223         if (rc < 0) {
224                 printf("Detach: %s\n", strerror(errno));
225                 return 1;
226         }
227         return 0;
228 }
229
230 static int jt_attach(int argc, char **argv)
231 {
232         struct obd_ioctl_data data;
233         int rc;
234
235         IOCINIT(data);
236
237         if ( argc != 2 && argc != 3  ) {
238                 fprintf(stderr, "Usage: %s type [data]\n", argv[0]);
239                 return 1;
240         }
241
242         data.ioc_inllen1 =  strlen(argv[1]) + 1;
243         data.ioc_inlbuf1 = argv[1];
244         if ( argc == 3 ) { 
245                 data.ioc_inllen2 = strlen(argv[2]) + 1;
246                 data.ioc_inlbuf2 = argv[2];
247         }
248
249         printf("attach len %d addr %p type %s data %s\n", data.ioc_len, buf, 
250                MKSTR(data.ioc_inlbuf1), MKSTR(data.ioc_inlbuf2));
251
252         if (obd_ioctl_pack(&data, &buf, max)) { 
253                 printf("invalid ioctl\n"); 
254                 return 1;
255         }
256         printf("attach len %d addr %p raw %p type %s data %s and %s\n", data.ioc_len, buf, rawbuf,
257                MKSTR(data.ioc_inlbuf1), MKSTR(data.ioc_inlbuf2), &buf[516]);
258
259         rc = ioctl(fd, OBD_IOC_ATTACH , buf);
260         if (rc < 0) {
261                 printf("Attach: %x %s\n", OBD_IOC_ATTACH, strerror(errno));
262                 return 1;
263         }
264         return 0;
265 }
266
267 static int jt_setup(int argc, char **argv)
268 {
269         struct obd_ioctl_data data;
270         int rc;
271
272         IOCINIT(data);
273
274         if ( argc > 3  ) {
275                 fprintf(stderr, "Usage: %s [device] [fstype]\n", argv[0]);
276                 return 1;
277         }
278
279         if (argc > 1) {
280                 data.ioc_inllen1 =  strlen(argv[1]) + 1;
281                 data.ioc_inlbuf1 = argv[1];
282                 data.ioc_dev = strtoul(argv[1], NULL, 0);
283         } else {
284                 data.ioc_dev = -1;
285         }
286         if ( argc == 3 ) { 
287                 data.ioc_inllen2 = strlen(argv[2]) + 1;
288                 data.ioc_inlbuf2 = argv[2];
289         }
290
291         printf("setup len %d addr %p device %s type %s\n", data.ioc_len, buf, 
292                MKSTR(data.ioc_inlbuf1), MKSTR(data.ioc_inlbuf2));
293
294         if (obd_ioctl_pack(&data, &buf, max)) { 
295                 printf("invalid ioctl\n"); 
296                 return 1;
297         }
298         printf("setup len %d addr %p raw %p device %s type %s\n", 
299                data.ioc_len, buf, rawbuf,
300                MKSTR(data.ioc_inlbuf1), MKSTR(data.ioc_inlbuf2));
301
302         rc = ioctl(fd, OBD_IOC_SETUP , buf);
303         if (rc < 0) {
304                 printf("setup: %x %s\n", OBD_IOC_SETUP, strerror(errno));
305                 return 1;
306         }
307         return 0;
308 }
309
310
311 static int jt_create(int argc, char **argv)
312 {
313         struct obd_ioctl_data data;
314         int num = 1;
315         int silent = 0;
316         int i;
317         int rc;
318
319         IOCINIT(data);
320         if (argc > 1) { 
321                 num = strtoul(argv[1], NULL, 0);
322         } else { 
323                 printf("usage %s num [mode] [silent]\n", argv[0]); 
324         }
325
326         if (argc > 2) { 
327                 data.ioc_obdo1.o_mode = strtoul(argv[2], NULL, 0);
328         } else { 
329                 data.ioc_obdo1.o_mode = 0100644;
330         }
331         data.ioc_obdo1.o_valid = OBD_MD_FLMODE;
332
333         if (argc > 3) { 
334                 silent = strtoul(argv[3], NULL, 0);
335         }
336                 
337         printf("Creating %d obdos\n", num);
338
339         for (i = 0 ; i<num ; i++) { 
340                 rc = ioctl(fd, OBD_IOC_CREATE , &data);
341                 if (rc < 0) {
342                         printf("Create: %x %s\n", OBD_IOC_CREATE, 
343                                strerror(errno));
344                         return 1;
345                 }
346                 printf("created obdo %Ld\n", data.ioc_obdo1.o_id);
347         }
348         return 0;
349 }
350
351 static int jt_setattr(int argc, char **argv)
352 {
353         struct obd_ioctl_data data;
354         int rc;
355
356         IOCINIT(data);
357         if (argc < 2) { 
358                 printf("usage: %s id mode\n", argv[0]); 
359                 return -1;
360         }
361
362         data.ioc_obdo1.o_id = strtoul(argv[1], NULL, 0);
363         data.ioc_obdo1.o_mode = strtoul(argv[2], NULL, 0);
364         data.ioc_obdo1.o_valid = OBD_MD_FLMODE; 
365
366         rc = ioctl(fd, OBD_IOC_SETATTR , &data);
367         if (rc < 0) {
368                 printf("setattr: %x %s\n", OBD_IOC_SETATTR, strerror(errno));
369         }
370         return rc;
371 }
372
373 static int jt_destroy(int argc, char **argv)
374 {
375         struct obd_ioctl_data data;
376         int rc;
377
378         IOCINIT(data);
379         if (argc < 1) { 
380                 printf("usage %s id\n", argv[0]); 
381         }
382
383         data.ioc_obdo1.o_id = strtoul(argv[1], NULL, 0);
384
385         rc = ioctl(fd, OBD_IOC_DESTROY , &data);
386         if (rc < 0) {
387                 printf("setattr: %x %s\n", OBD_IOC_DESTROY, strerror(errno));
388         }
389         return rc;
390 }
391
392 static int jt_multi_getattr(int argc, char **argv)
393 {
394         struct obd_ioctl_data data;
395         int count, i;
396         int rc;
397
398         IOCINIT(data);
399         if (argc == 2) { 
400                 count = strtoul(argv[1], NULL, 0);
401                 data.ioc_obdo1.o_valid = 0xffffffff;
402                 data.ioc_obdo1.o_id = 2;
403                 printf("getting %d attrs (testing only)\n", count);
404         } else { 
405                 printf("usage %s id\n", argv[0]); 
406                 return 0;
407         }
408
409         for (i = 0 ; i < count; i++) {
410                 rc = ioctl(fd, OBD_IOC_GETATTR , &data);
411                 if (rc) { 
412                         printf("Error: %s on i=%d\n", strerror(rc), i); 
413                         break;
414                 } else { 
415                         printf("attr number %d\n", i);
416                 }
417         }
418         return 0;
419 }
420
421 static int jt_getattr(int argc, char **argv)
422 {
423         struct obd_ioctl_data data;
424         int rc;
425
426         IOCINIT(data);
427         if (argc == 2) { 
428                 data.ioc_obdo1.o_id = strtoul(argv[1], NULL, 0);
429                 data.ioc_obdo1.o_valid = 0xffffffff;
430                 printf("getting attr for %Ld\n", data.ioc_obdo1.o_id);
431         } else { 
432                 printf("usage %s id\n", argv[0]); 
433                 return 0;
434         }
435
436         rc = ioctl(fd, OBD_IOC_GETATTR , &data);
437         if (rc) { 
438                 printf("Error: %s\n", strerror(rc)); 
439         } else { 
440                 printf("attr obdo %Ld, mode %o\n", data.ioc_obdo1.o_id, 
441                        data.ioc_obdo1.o_mode);
442         }
443         return 0;
444 }
445
446 command_t list[] = {
447         {"device", jt_device, 0, "set current device (args device no)"},
448         {"attach", jt_attach, 0, "name the typed of device (args: type data"},
449         {"setup", jt_setup, 0, "setup device (args: blkdev, data"},
450         {"detach", jt_detach, 0, "detach the current device (arg: )"},
451         {"cleanup", jt_cleanup, 0, "cleanup the current device (arg: )"},
452         {"create", jt_create, 0, "create [count [mode [silent]]]"},
453         {"destroy", jt_destroy, 0, "destroy id"},
454         {"test_getattr", jt_multi_getattr, 0, "test_getattr count [silent]"},
455         {"getattr", jt_getattr, 0, "getattr id"},
456         {"setattr", jt_setattr, 0, "setattr id mode"},
457         {"connect", jt_connect, 0, "connect - get a connection to device"},
458         {"disconnect", jt_disconnect, 0, "disconnect - break connection to device"},
459         {"help", Parser_help, 0, "help"},
460         {"exit", Parser_quit, 0, "quit"},
461         {"quit", Parser_quit, 0, "quit"},
462         { 0, 0, 0, NULL }
463 };
464
465 int main(int argc, char **argv)
466 {
467
468         if (argc > 1) { 
469                 return Parser_execarg(argc - 1, &argv[1], list);
470         }
471
472         Parser_init("obdctl > ", list);
473         Parser_commands();
474
475         return 0;
476 }
477