lustre/include/linux/lustre_idl.h

   1 /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
   2  * vim:expandtab:shiftwidth=8:tabstop=8:
   3  *
   4  *  Copyright (C) 2001 Cluster File Systems, Inc. <braam@clusterfs.com>
   5  *
   6  *   This file is part of Lustre, http://www.lustre.org.
   7  *
   8  *   Lustre 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  *   Lustre 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 Lustre; if not, write to the Free Software
  19  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20  *
  21  * (Un)packing of OST requests
  22  */
  23
  24 #ifndef __LUSTRE_IDL_H__
  25 #define __LUSTRE_IDL_H__
  26 #ifdef __KERNEL__
  27 #include <linux/ioctl.h>
  28 #include <asm/types.h>
  29
  30 #include <linux/types.h>
  31 #else
  32 #define __KERNEL__
  33 #include <linux/list.h>
  34 #undef __KERNEL__
  35 #include <stdint.h>
  36 #endif
  37 /*
  38  * this file contains all data structures used in Lustre interfaces:
  39  * - obdo and obd_request records
  40  * - mds_request records
  41  * - ldlm data
  42  * - ioctl's
  43  */
  44
  45 #define PTL_RPC_MSG_REQUEST 4711
  46 #define PTL_RPC_MSG_ERR 4712
  47
  48 struct lustre_msg {
  49         __u64 conn;
  50         __u64 token;
  51
  52         __u32 opc;
  53         __u32 xid;
  54         __u64 last_rcvd;
  55         __u64 last_committed;
  56         __u64 transno;
  57         __u32 status;
  58         __u32 type;
  59         __u32   connid;
  60         __u32   bufcount;
  61         __u32   buflens[0];
  62 };
  63
  64 /*
  65  *   OST requests: OBDO & OBD request records
  66  */
  67
  68 /* opcodes */
  69 #define OST_GETATTR    1
  70 #define OST_SETATTR    2
  71 #define OST_BRW        3
  72 #define OST_CREATE     4
  73 #define OST_DESTROY    5
  74 #define OST_GET_INFO   6
  75 #define OST_CONNECT    7
  76 #define OST_DISCONNECT 8
  77 #define OST_PUNCH      9
  78 #define OST_OPEN      10
  79 #define OST_CLOSE     11
  80
  81
  82 typedef uint64_t        obd_id;
  83 typedef uint64_t        obd_gr;
  84 typedef uint64_t        obd_time;
  85 typedef uint64_t        obd_size;
  86 typedef uint64_t        obd_off;
  87 typedef uint64_t        obd_blocks;
  88 typedef uint32_t        obd_blksize;
  89 typedef uint32_t        obd_mode;
  90 typedef uint32_t        obd_uid;
  91 typedef uint32_t        obd_gid;
  92 typedef uint32_t        obd_rdev;
  93 typedef uint32_t        obd_flag;
  94 typedef uint32_t        obd_count;
  95
  96 #define OBD_FL_INLINEDATA       (0x00000001UL)
  97 #define OBD_FL_OBDMDEXISTS      (0x00000002UL)
  98
  99 #define OBD_INLINESZ    60
 100 #define OBD_OBDMDSZ     60
 101 /* Note: 64-bit types are 64-bit aligned in structure */
 102 struct obdo {
 103         obd_id                  o_id;
 104         obd_gr                  o_gr;
 105         obd_time                o_atime;
 106         obd_time                o_mtime;
 107         obd_time                o_ctime;
 108         obd_size                o_size;
 109         obd_blocks              o_blocks;
 110         obd_blksize             o_blksize;
 111         obd_mode                o_mode;
 112         obd_uid                 o_uid;
 113         obd_gid                 o_gid;
 114         obd_flag                o_flags;
 115         obd_flag                o_obdflags;
 116         obd_count               o_nlink;
 117         obd_count               o_generation;
 118         obd_flag                o_valid;        /* hot fields in this obdo */
 119         char                    o_inline[OBD_INLINESZ];
 120         char                    o_obdmd[OBD_OBDMDSZ];
 121         struct list_head        o_list;
 122         struct obd_ops          *o_op;
 123 };
 124
 125 #define OBD_MD_FLALL    (~0UL)
 126 #define OBD_MD_FLID     (0x00000001UL)
 127 #define OBD_MD_FLATIME  (0x00000002UL)
 128 #define OBD_MD_FLMTIME  (0x00000004UL)
 129 #define OBD_MD_FLCTIME  (0x00000008UL)
 130 #define OBD_MD_FLSIZE   (0x00000010UL)
 131 #define OBD_MD_FLBLOCKS (0x00000020UL)
 132 #define OBD_MD_FLBLKSZ  (0x00000040UL)
 133 #define OBD_MD_FLMODE   (0x00000080UL)
 134 #define OBD_MD_FLTYPE   (0x00000100UL)
 135 #define OBD_MD_FLUID    (0x00000200UL)
 136 #define OBD_MD_FLGID    (0x00000400UL)
 137 #define OBD_MD_FLFLAGS  (0x00000800UL)
 138 #define OBD_MD_FLOBDFLG (0x00001000UL)
 139 #define OBD_MD_FLNLINK  (0x00002000UL)
 140 #define OBD_MD_FLGENER  (0x00004000UL)
 141 #define OBD_MD_FLINLINE (0x00008000UL)
 142 #define OBD_MD_FLOBDMD  (0x00010000UL)
 143 #define OBD_MD_FLOBJID  (0x00020000UL)
 144 #define OBD_MD_FLNOTOBD (~(OBD_MD_FLOBDMD | OBD_MD_FLOBDFLG | OBD_MD_FLBLOCKS))
 145
 146 /* request structure for OST's */
 147
 148 #define OST_REQ_HAS_OA1  0x1
 149
 150 struct ost_body {
 151         __u32   connid;
 152         __u32   data;
 153         struct  obdo oa;
 154 };
 155
 156 struct obd_ioobj {
 157         obd_id    ioo_id;
 158         obd_gr    ioo_gr;
 159         __u32     ioo_type;
 160         __u32     ioo_bufcnt;
 161 };
 162
 163 /*
 164  *   MDS REQ RECORDS
 165  */
 166
 167 /* opcodes */
 168 #define MDS_GETATTR   1
 169 #define MDS_OPEN      2
 170 #define MDS_CLOSE     3
 171 #define MDS_REINT     4
 172 #define MDS_READPAGE  5
 173 #define MDS_CONNECT   6
 174
 175 #define REINT_SETATTR 1
 176 #define REINT_CREATE  2
 177 #define REINT_LINK    3
 178 #define REINT_UNLINK  4
 179 #define REINT_RENAME  5
 180 #define REINT_MAX     5
 181
 182 struct ll_fid {
 183         __u64 id;
 184         __u32 generation;
 185         __u32 f_type;
 186 };
 187
 188 struct niobuf {
 189         __u64 addr;
 190         __u64 offset;
 191         __u32 len;
 192         __u32 flags;
 193         __u32 xid;
 194         void *page;
 195 };
 196
 197 struct mds_body {
 198         struct ll_fid  fid1;
 199         struct ll_fid  fid2;
 200         __u64          objid;
 201         __u64          size;
 202         __u32          valid;
 203         __u32          mode;
 204         __u32          uid;
 205         __u32          gid;
 206         __u32          mtime;
 207         __u32          ctime;
 208         __u32          atime;
 209         __u32          flags;
 210         __u32          major;
 211         __u32          minor;
 212         __u32          ino;
 213         __u32          nlink;
 214         __u32          generation;
 215         __u32          last_xid;
 216 };
 217
 218 /* MDS update records */
 219 struct mds_update_record_hdr {
 220         __u32 ur_opcode;
 221 };
 222
 223 struct mds_rec_setattr {
 224         __u32           sa_opcode;
 225         struct ll_fid   sa_fid;
 226         __u32           sa_valid;
 227         __u32           sa_mode;
 228         __u32           sa_uid;
 229         __u32           sa_gid;
 230         __u64           sa_size;
 231         __u64           sa_atime;
 232         __u64           sa_mtime;
 233         __u64           sa_ctime;
 234         __u32           sa_attr_flags;
 235 };
 236
 237 struct mds_rec_create {
 238         __u32           cr_opcode;
 239         struct ll_fid   cr_fid;
 240         __u32           cr_uid;
 241         __u32           cr_gid;
 242         __u64           cr_time;
 243         __u32           cr_mode;
 244         /* overloaded: id for create, tgtlen for symlink, rdev for mknod */
 245         __u64           cr_id;
 246 };
 247
 248 struct mds_rec_link {
 249         __u32           lk_opcode;
 250         struct ll_fid   lk_fid1;
 251         struct ll_fid   lk_fid2;
 252 };
 253
 254 struct mds_rec_unlink {
 255         __u32           ul_opcode;
 256         struct ll_fid   ul_fid1;
 257         struct ll_fid   ul_fid2;
 258 };
 259
 260 struct mds_rec_rename {
 261         __u32           rn_opcode;
 262         struct ll_fid   rn_fid1;
 263         struct ll_fid   rn_fid2;
 264 };
 265
 266
 267 /*
 268  *   LDLM requests:
 269  */
 270
 271 /* opcodes */
 272 #define LDLM_ENQUEUE       1
 273 #define LDLM_CONVERT       2
 274 #define LDLM_CANCEL        3
 275 #define LDLM_CALLBACK      4
 276
 277 #define RES_NAME_SIZE 3
 278 #define RES_VERSION_SIZE 4
 279
 280 /* lock types */
 281 typedef enum {
 282         LCK_EX = 1,
 283         LCK_PW,
 284         LCK_PR,
 285         LCK_CW,
 286         LCK_CR,
 287         LCK_NL
 288 } ldlm_mode_t;
 289
 290 struct ldlm_handle {
 291         __u64 addr;
 292         __u64 cookie;
 293 };
 294
 295 struct ldlm_extent {
 296         __u64 start;
 297         __u64 end;
 298 };
 299
 300 struct ldlm_resource_desc {
 301         __u32 lr_type;
 302         __u64 lr_name[RES_NAME_SIZE];
 303         __u64 lr_version[RES_VERSION_SIZE];
 304 };
 305
 306 struct ldlm_lock_desc {
 307         struct ldlm_resource_desc l_resource;
 308         ldlm_mode_t l_req_mode;
 309         ldlm_mode_t l_granted_mode;
 310         struct ldlm_extent l_extent;
 311         __u32 l_version[RES_VERSION_SIZE];
 312 };
 313
 314 struct ldlm_request {
 315         __u32 flags;
 316         struct ldlm_lock_desc lock_desc;
 317         struct ldlm_handle lock_handle1;
 318         struct ldlm_handle lock_handle2;
 319 };
 320
 321 struct ldlm_reply {
 322         __u32 flags;
 323         struct ldlm_handle lock_handle;
 324         struct ldlm_extent lock_extent;
 325 };
 326
 327 /*
 328  *   OBD IOCTLS
 329  */
 330
 331
 332 #define OBD_IOCTL_VERSION 0x00010001
 333
 334 struct obd_ioctl_data {
 335         uint32_t ioc_len;
 336         uint32_t ioc_version;
 337         uint32_t ioc_conn1;
 338         uint32_t ioc_conn2;
 339         struct obdo ioc_obdo1;
 340         struct obdo ioc_obdo2;
 341         obd_size         ioc_count;
 342         obd_off          ioc_offset;
 343         uint32_t         ioc_dev;
 344
 345         /* buffers the kernel will treat as user pointers */
 346         uint32_t ioc_plen1;
 347         char    *ioc_pbuf1;
 348         uint32_t ioc_plen2;
 349         char    *ioc_pbuf2;
 350
 351         /* two inline buffers */
 352         uint32_t ioc_inllen1;
 353         char    *ioc_inlbuf1;
 354         uint32_t ioc_inllen2;
 355         char    *ioc_inlbuf2;
 356
 357         char    ioc_bulk[0];
 358 };
 359
 360 struct obd_ioctl_hdr {
 361         uint32_t ioc_len;
 362         uint32_t ioc_version;
 363 };
 364
 365 static inline int obd_ioctl_packlen(struct obd_ioctl_data *data)
 366 {
 367         int len = sizeof(struct obd_ioctl_data);
 368         len += size_round(data->ioc_inllen1);
 369         len += size_round(data->ioc_inllen2);
 370         return len;
 371 }
 372
 373 static inline int obd_ioctl_is_invalid(struct obd_ioctl_data *data)
 374 {
 375         if (data->ioc_len > (1<<30)) {
 376                 printk("OBD ioctl: ioc_len larger than 1<<30\n");
 377                 return 1;
 378         }
 379         if (data->ioc_inllen1 > (1<<30)) {
 380                 printk("OBD ioctl: ioc_inllen1 larger than 1<<30\n");
 381                 return 1;
 382         }
 383         if (data->ioc_inllen2 > (1<<30)) {
 384                 printk("OBD ioctl: ioc_inllen2 larger than 1<<30\n");
 385                 return 1;
 386         }
 387         if (data->ioc_inlbuf1 && !data->ioc_inllen1) {
 388                 printk("OBD ioctl: inlbuf1 pointer but 0 length\n");
 389                 return 1;
 390         }
 391         if (data->ioc_inlbuf2 && !data->ioc_inllen2) {
 392                 printk("OBD ioctl: inlbuf2 pointer but 0 length\n");
 393                 return 1;
 394         }
 395         if (data->ioc_pbuf1 && !data->ioc_plen1) {
 396                 printk("OBD ioctl: pbuf1 pointer but 0 length\n");
 397                 return 1;
 398         }
 399         if (data->ioc_pbuf2 && !data->ioc_plen2) {
 400                 printk("OBD ioctl: pbuf2 pointer but 0 length\n");
 401                 return 1;
 402         }
 403         /*
 404         if (data->ioc_inllen1 && !data->ioc_inlbuf1) {
 405                 printk("OBD ioctl: inllen1 set but NULL pointer\n");
 406                 return 1;
 407         }
 408         if (data->ioc_inllen2 && !data->ioc_inlbuf2) {
 409                 printk("OBD ioctl: inllen2 set but NULL pointer\n");
 410                 return 1;
 411         }
 412         if (data->ioc_plen1 && !data->ioc_pbuf1) {
 413                 printk("OBD ioctl: plen1 set but NULL pointer\n");
 414                 return 1;
 415         }
 416         if (data->ioc_plen2 && !data->ioc_pbuf2) {
 417                 printk("OBD ioctl: plen2 set but NULL pointer\n");
 418                 return 1;
 419         }
 420         */
 421         if (obd_ioctl_packlen(data) != data->ioc_len ) {
 422                 printk("OBD ioctl: packlen exceeds ioc_len\n");
 423                 return 1;
 424         }
 425         if (data->ioc_inllen1 &&
 426             data->ioc_bulk[data->ioc_inllen1 - 1] != '\0') {
 427                 printk("OBD ioctl: inlbuf1 not 0 terminated\n");
 428                 return 1;
 429         }
 430         if (data->ioc_inllen2 &&
 431             data->ioc_bulk[size_round(data->ioc_inllen1) + data->ioc_inllen2 - 1] != '\0') {
 432                 printk("OBD ioctl: inlbuf2 not 0 terminated\n");
 433                 return 1;
 434         }
 435         return 0;
 436 }
 437
 438 #ifndef __KERNEL__
 439 static inline int obd_ioctl_pack(struct obd_ioctl_data *data, char **pbuf,
 440                                  int max)
 441 {
 442         char *ptr;
 443         struct obd_ioctl_data *overlay;
 444         data->ioc_len = obd_ioctl_packlen(data);
 445         data->ioc_version = OBD_IOCTL_VERSION;
 446
 447         if (*pbuf && obd_ioctl_packlen(data) > max)
 448                 return 1;
 449         if (*pbuf == NULL) {
 450                 *pbuf = malloc(data->ioc_len);
 451         }
 452         if (!*pbuf)
 453                 return 1;
 454         overlay = (struct obd_ioctl_data *)*pbuf;
 455         memcpy(*pbuf, data, sizeof(*data));
 456
 457         ptr = overlay->ioc_bulk;
 458         if (data->ioc_inlbuf1)
 459                 LOGL(data->ioc_inlbuf1, data->ioc_inllen1, ptr);
 460         if (data->ioc_inlbuf2)
 461                 LOGL(data->ioc_inlbuf2, data->ioc_inllen2, ptr);
 462         if (obd_ioctl_is_invalid(overlay))
 463                 return 1;
 464
 465         return 0;
 466 }
 467 #else
 468
 469
 470 /* buffer MUST be at least the size of obd_ioctl_hdr */
 471 static inline int obd_ioctl_getdata(char *buf, char *end, void *arg)
 472 {
 473         struct obd_ioctl_hdr *hdr;
 474         struct obd_ioctl_data *data;
 475         int err;
 476         ENTRY;
 477
 478         hdr = (struct obd_ioctl_hdr *)buf;
 479         data = (struct obd_ioctl_data *)buf;
 480
 481         err = copy_from_user(buf, (void *)arg, sizeof(*hdr));
 482         if ( err ) {
 483                 EXIT;
 484                 return err;
 485         }
 486
 487         if (hdr->ioc_version != OBD_IOCTL_VERSION) {
 488                 printk("OBD: version mismatch kernel vs application\n");
 489                 return -EINVAL;
 490         }
 491
 492         if (hdr->ioc_len + buf >= end) {
 493                 printk("OBD: user buffer exceeds kernel buffer\n");
 494                 return -EINVAL;
 495         }
 496
 497
 498         if (hdr->ioc_len < sizeof(struct obd_ioctl_data)) {
 499                 printk("OBD: user buffer too small for ioctl\n");
 500                 return -EINVAL;
 501         }
 502
 503         err = copy_from_user(buf, (void *)arg, hdr->ioc_len);
 504         if ( err ) {
 505                 EXIT;
 506                 return err;
 507         }
 508
 509         if (obd_ioctl_is_invalid(data)) {
 510                 printk("OBD: ioctl not correctly formatted\n");
 511                 return -EINVAL;
 512         }
 513
 514         if (data->ioc_inllen1) {
 515                 data->ioc_inlbuf1 = &data->ioc_bulk[0];
 516         }
 517
 518         if (data->ioc_inllen2) {
 519                 data->ioc_inlbuf2 = &data->ioc_bulk[0] + size_round(data->ioc_inllen1);
 520         }
 521
 522         EXIT;
 523         return 0;
 524 }
 525 #endif
 526
 527
 528 #define OBD_IOC_CREATE                 _IOR ('f',  3, long)
 529 #define OBD_IOC_SETUP                  _IOW ('f',  4, long)
 530 #define OBD_IOC_CLEANUP                _IO  ('f',  5      )
 531 #define OBD_IOC_DESTROY                _IOW ('f',  6, long)
 532 #define OBD_IOC_PREALLOCATE            _IOWR('f',  7, long)
 533 #define OBD_IOC_DEC_USE_COUNT          _IO  ('f',  8      )
 534 #define OBD_IOC_SETATTR                _IOW ('f',  9, long)
 535 #define OBD_IOC_GETATTR                _IOR ('f', 10, long)
 536 #define OBD_IOC_READ                   _IOWR('f', 11, long)
 537 #define OBD_IOC_WRITE                  _IOWR('f', 12, long)
 538 #define OBD_IOC_CONNECT                _IOR ('f', 13, long)
 539 #define OBD_IOC_DISCONNECT             _IOW ('f', 14, long)
 540 #define OBD_IOC_STATFS                 _IOWR('f', 15, long)
 541 #define OBD_IOC_SYNC                   _IOR ('f', 16, long)
 542 #define OBD_IOC_READ2                  _IOWR('f', 17, long)
 543 #define OBD_IOC_FORMAT                 _IOWR('f', 18, long)
 544 #define OBD_IOC_PARTITION              _IOWR('f', 19, long)
 545 #define OBD_IOC_ATTACH                 _IOWR('f', 20, long)
 546 #define OBD_IOC_DETACH                 _IOWR('f', 21, long)
 547 #define OBD_IOC_COPY                   _IOWR('f', 22, long)
 548 #define OBD_IOC_MIGR                   _IOWR('f', 23, long)
 549 #define OBD_IOC_PUNCH                  _IOWR('f', 24, long)
 550 #define OBD_IOC_DEVICE                 _IOWR('f', 25, long)
 551 #define OBD_IOC_MODULE_DEBUG           _IOWR('f', 26, long)
 552 #define OBD_IOC_BRW_READ               _IOWR('f', 27, long)
 553 #define OBD_IOC_BRW_WRITE              _IOWR('f', 28, long)
 554 #define OBD_IOC_NAME2DEV               _IOWR('f', 29, long)
 555 #define OBD_IOC_NEWDEV                 _IOWR('f', 30, long)
 556
 557 #define OBD_RECOVD_NEWCONN             _IOWR('f', 31, long)
 558
 559 #define OBD_IOC_DEC_FS_USE_COUNT       _IO  ('f', 32      )
 560
 561 #endif