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