lustre/include/dt_object.h

   1 /*
   2  * GPL HEADER START
   3  *
   4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License version 2 only,
   8  * as published by the Free Software Foundation.
   9  *
  10  * This program is distributed in the hope that it will be useful, but
  11  * WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * General Public License version 2 for more details (a copy is included
  14  * in the LICENSE file that accompanied this code).
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * version 2 along with this program; If not, see
  18  * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
  19  *
  20  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
  21  * CA 95054 USA or visit www.sun.com if you need additional information or
  22  * have any questions.
  23  *
  24  * GPL HEADER END
  25  */
  26 /*
  27  * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
  28  * Use is subject to license terms.
  29  *
  30  * Copyright (c) 2011, 2013, Intel Corporation.
  31  */
  32 /*
  33  * This file is part of Lustre, http://www.lustre.org/
  34  * Lustre is a trademark of Sun Microsystems, Inc.
  35  */
  36
  37 #ifndef __LUSTRE_DT_OBJECT_H
  38 #define __LUSTRE_DT_OBJECT_H
  39
  40 /** \defgroup dt dt
  41  * Sub-class of lu_object with methods common for "data" objects in OST stack.
  42  *
  43  * Data objects behave like regular files: you can read/write them, get and
  44  * set their attributes. Implementation of dt interface is supposed to
  45  * implement some form of garbage collection, normally reference counting
  46  * (nlink) based one.
  47  *
  48  * Examples: osd (lustre/osd) is an implementation of dt interface.
  49  * @{
  50  */
  51
  52
  53 /*
  54  * super-class definitions.
  55  */
  56 #include <lu_object.h>
  57
  58 #include <libcfs/libcfs.h>
  59
  60 struct seq_file;
  61 struct proc_dir_entry;
  62 struct lustre_cfg;
  63
  64 struct thandle;
  65 struct dt_device;
  66 struct dt_object;
  67 struct dt_index_features;
  68 struct niobuf_local;
  69 struct niobuf_remote;
  70 struct ldlm_enqueue_info;
  71
  72 typedef enum {
  73         MNTOPT_USERXATTR        = 0x00000001,
  74         MNTOPT_ACL              = 0x00000002,
  75 } mntopt_t;
  76
  77 struct dt_device_param {
  78         unsigned           ddp_max_name_len;
  79         unsigned           ddp_max_nlink;
  80         unsigned           ddp_block_shift;
  81         mntopt_t           ddp_mntopts;
  82         unsigned           ddp_max_ea_size;
  83         void              *ddp_mnt; /* XXX: old code can retrieve mnt -bzzz */
  84         int                ddp_mount_type;
  85         unsigned long long ddp_maxbytes;
  86         /* percentage of available space to reserve for grant error margin */
  87         int                ddp_grant_reserved;
  88         /* per-inode space consumption */
  89         short              ddp_inodespace;
  90         /* per-fragment grant overhead to be used by client for grant
  91          * calculation */
  92         int                ddp_grant_frag;
  93 };
  94
  95 /**
  96  * Per-transaction commit callback function
  97  */
  98 struct dt_txn_commit_cb;
  99 typedef void (*dt_cb_t)(struct lu_env *env, struct thandle *th,
 100                         struct dt_txn_commit_cb *cb, int err);
 101 /**
 102  * Special per-transaction callback for cases when just commit callback
 103  * is needed and per-device callback are not convenient to use
 104  */
 105 #define TRANS_COMMIT_CB_MAGIC   0xa0a00a0a
 106 #define MAX_COMMIT_CB_STR_LEN   32
 107
 108 struct dt_txn_commit_cb {
 109         cfs_list_t      dcb_linkage;
 110         dt_cb_t         dcb_func;
 111         __u32           dcb_magic;
 112         char            dcb_name[MAX_COMMIT_CB_STR_LEN];
 113 };
 114
 115 /**
 116  * Operations on dt device.
 117  */
 118 struct dt_device_operations {
 119         /**
 120          * Return device-wide statistics.
 121          */
 122         int   (*dt_statfs)(const struct lu_env *env,
 123                            struct dt_device *dev, struct obd_statfs *osfs);
 124         /**
 125          * Create transaction, described by \a param.
 126          */
 127         struct thandle *(*dt_trans_create)(const struct lu_env *env,
 128                                            struct dt_device *dev);
 129         /**
 130          * Start transaction, described by \a param.
 131          */
 132         int   (*dt_trans_start)(const struct lu_env *env,
 133                                 struct dt_device *dev, struct thandle *th);
 134         /**
 135          * Finish previously started transaction.
 136          */
 137         int   (*dt_trans_stop)(const struct lu_env *env,
 138                                struct thandle *th);
 139         /**
 140          * Add commit callback to the transaction.
 141          */
 142         int   (*dt_trans_cb_add)(struct thandle *th,
 143                                  struct dt_txn_commit_cb *dcb);
 144         /**
 145          * Return fid of root index object.
 146          */
 147         int   (*dt_root_get)(const struct lu_env *env,
 148                              struct dt_device *dev, struct lu_fid *f);
 149         /**
 150          * Return device configuration data.
 151          */
 152         void  (*dt_conf_get)(const struct lu_env *env,
 153                              const struct dt_device *dev,
 154                              struct dt_device_param *param);
 155         /**
 156          *  handling device state, mostly for tests
 157          */
 158         int   (*dt_sync)(const struct lu_env *env, struct dt_device *dev);
 159         int   (*dt_ro)(const struct lu_env *env, struct dt_device *dev);
 160         /**
 161           * Start a transaction commit asynchronously
 162           *
 163           * \param env environment
 164           * \param dev dt_device to start commit on
 165           *
 166           * \return 0 success, negative value if error
 167           */
 168          int   (*dt_commit_async)(const struct lu_env *env,
 169                                   struct dt_device *dev);
 170         /**
 171          * Initialize capability context.
 172          */
 173         int   (*dt_init_capa_ctxt)(const struct lu_env *env,
 174                                    struct dt_device *dev,
 175                                    int mode, unsigned long timeout,
 176                                    __u32 alg, struct lustre_capa_key *keys);
 177 };
 178
 179 struct dt_index_features {
 180         /** required feature flags from enum dt_index_flags */
 181         __u32 dif_flags;
 182         /** minimal required key size */
 183         size_t dif_keysize_min;
 184         /** maximal required key size, 0 if no limit */
 185         size_t dif_keysize_max;
 186         /** minimal required record size */
 187         size_t dif_recsize_min;
 188         /** maximal required record size, 0 if no limit */
 189         size_t dif_recsize_max;
 190         /** pointer size for record */
 191         size_t dif_ptrsize;
 192 };
 193
 194 enum dt_index_flags {
 195         /** index supports variable sized keys */
 196         DT_IND_VARKEY = 1 << 0,
 197         /** index supports variable sized records */
 198         DT_IND_VARREC = 1 << 1,
 199         /** index can be modified */
 200         DT_IND_UPDATE = 1 << 2,
 201         /** index supports records with non-unique (duplicate) keys */
 202         DT_IND_NONUNQ = 1 << 3,
 203         /**
 204          * index support fixed-size keys sorted with natural numerical way
 205          * and is able to return left-side value if no exact value found
 206          */
 207         DT_IND_RANGE = 1 << 4,
 208 };
 209
 210 /**
 211  * Features, required from index to support file system directories (mapping
 212  * names to fids).
 213  */
 214 extern const struct dt_index_features dt_directory_features;
 215 extern const struct dt_index_features dt_otable_features;
 216 extern const struct dt_index_features dt_lfsck_features;
 217
 218 /* index features supported by the accounting objects */
 219 extern const struct dt_index_features dt_acct_features;
 220
 221 /* index features supported by the quota global indexes */
 222 extern const struct dt_index_features dt_quota_glb_features;
 223
 224 /* index features supported by the quota slave indexes */
 225 extern const struct dt_index_features dt_quota_slv_features;
 226
 227 /**
 228  * This is a general purpose dt allocation hint.
 229  * It now contains the parent object.
 230  * It can contain any allocation hint in the future.
 231  */
 232 struct dt_allocation_hint {
 233         struct dt_object           *dah_parent;
 234         __u32                       dah_mode;
 235 };
 236
 237 /**
 238  * object type specifier.
 239  */
 240
 241 enum dt_format_type {
 242         DFT_REGULAR,
 243         DFT_DIR,
 244         /** for mknod */
 245         DFT_NODE,
 246         /** for special index */
 247         DFT_INDEX,
 248         /** for symbolic link */
 249         DFT_SYM,
 250 };
 251
 252 /**
 253  * object format specifier.
 254  */
 255 struct dt_object_format {
 256         /** type for dt object */
 257         enum dt_format_type dof_type;
 258         union {
 259                 struct dof_regular {
 260                         int striped;
 261                 } dof_reg;
 262                 struct dof_dir {
 263                 } dof_dir;
 264                 struct dof_node {
 265                 } dof_node;
 266                 /**
 267                  * special index need feature as parameter to create
 268                  * special idx
 269                  */
 270                 struct dof_index {
 271                         const struct dt_index_features *di_feat;
 272                 } dof_idx;
 273         } u;
 274 };
 275
 276 enum dt_format_type dt_mode_to_dft(__u32 mode);
 277
 278 typedef __u64 dt_obj_version_t;
 279
 280 /**
 281  * Per-dt-object operations.
 282  */
 283 struct dt_object_operations {
 284         void  (*do_read_lock)(const struct lu_env *env,
 285                               struct dt_object *dt, unsigned role);
 286         void  (*do_write_lock)(const struct lu_env *env,
 287                                struct dt_object *dt, unsigned role);
 288         void  (*do_read_unlock)(const struct lu_env *env,
 289                                 struct dt_object *dt);
 290         void  (*do_write_unlock)(const struct lu_env *env,
 291                                  struct dt_object *dt);
 292         int  (*do_write_locked)(const struct lu_env *env,
 293                                 struct dt_object *dt);
 294         /**
 295          * Note: following ->do_{x,}attr_{set,get}() operations are very
 296          * similar to ->moo_{x,}attr_{set,get}() operations in struct
 297          * md_object_operations (see md_object.h). These operations are not in
 298          * lu_object_operations, because ->do_{x,}attr_set() versions take
 299          * transaction handle as an argument (this transaction is started by
 300          * caller). We might factor ->do_{x,}attr_get() into
 301          * lu_object_operations, but that would break existing symmetry.
 302          */
 303
 304         /**
 305          * Return standard attributes.
 306          *
 307          * precondition: lu_object_exists(&dt->do_lu);
 308          */
 309         int   (*do_attr_get)(const struct lu_env *env,
 310                              struct dt_object *dt, struct lu_attr *attr,
 311                              struct lustre_capa *capa);
 312         /**
 313          * Set standard attributes.
 314          *
 315          * precondition: dt_object_exists(dt);
 316          */
 317         int   (*do_declare_attr_set)(const struct lu_env *env,
 318                                      struct dt_object *dt,
 319                                      const struct lu_attr *attr,
 320                                      struct thandle *handle);
 321         int   (*do_attr_set)(const struct lu_env *env,
 322                              struct dt_object *dt,
 323                              const struct lu_attr *attr,
 324                              struct thandle *handle,
 325                              struct lustre_capa *capa);
 326         /**
 327          * Return a value of an extended attribute.
 328          *
 329          * precondition: dt_object_exists(dt);
 330          */
 331         int   (*do_xattr_get)(const struct lu_env *env, struct dt_object *dt,
 332                               struct lu_buf *buf, const char *name,
 333                               struct lustre_capa *capa);
 334         /**
 335          * Set value of an extended attribute.
 336          *
 337          * \a fl - flags from enum lu_xattr_flags
 338          *
 339          * precondition: dt_object_exists(dt);
 340          */
 341         int   (*do_declare_xattr_set)(const struct lu_env *env,
 342                                       struct dt_object *dt,
 343                                       const struct lu_buf *buf,
 344                                       const char *name, int fl,
 345                                       struct thandle *handle);
 346         int   (*do_xattr_set)(const struct lu_env *env,
 347                               struct dt_object *dt, const struct lu_buf *buf,
 348                               const char *name, int fl, struct thandle *handle,
 349                               struct lustre_capa *capa);
 350         /**
 351          * Delete existing extended attribute.
 352          *
 353          * precondition: dt_object_exists(dt);
 354          */
 355         int   (*do_declare_xattr_del)(const struct lu_env *env,
 356                                       struct dt_object *dt,
 357                                       const char *name, struct thandle *handle);
 358         int   (*do_xattr_del)(const struct lu_env *env,
 359                               struct dt_object *dt,
 360                               const char *name, struct thandle *handle,
 361                               struct lustre_capa *capa);
 362         /**
 363          * Place list of existing extended attributes into \a buf (which has
 364          * length len).
 365          *
 366          * precondition: dt_object_exists(dt);
 367          */
 368         int   (*do_xattr_list)(const struct lu_env *env,
 369                                struct dt_object *dt, struct lu_buf *buf,
 370                                struct lustre_capa *capa);
 371         /**
 372          * Init allocation hint using parent object and child mode.
 373          * (1) The \a parent might be NULL if this is a partial creation for
 374          *     remote object.
 375          * (2) The type of child is in \a child_mode.
 376          * (3) The result hint is stored in \a ah;
 377          */
 378         void  (*do_ah_init)(const struct lu_env *env,
 379                             struct dt_allocation_hint *ah,
 380                             struct dt_object *parent,
 381                             struct dt_object *child,
 382                             umode_t child_mode);
 383         /**
 384          * Create new object on this device.
 385          *
 386          * precondition: !dt_object_exists(dt);
 387          * postcondition: ergo(result == 0, dt_object_exists(dt));
 388          */
 389         int   (*do_declare_create)(const struct lu_env *env,
 390                                    struct dt_object *dt,
 391                                    struct lu_attr *attr,
 392                                    struct dt_allocation_hint *hint,
 393                                    struct dt_object_format *dof,
 394                                    struct thandle *th);
 395         int   (*do_create)(const struct lu_env *env, struct dt_object *dt,
 396                            struct lu_attr *attr,
 397                            struct dt_allocation_hint *hint,
 398                            struct dt_object_format *dof,
 399                            struct thandle *th);
 400
 401         /**
 402           Destroy object on this device
 403          * precondition: !dt_object_exists(dt);
 404          * postcondition: ergo(result == 0, dt_object_exists(dt));
 405          */
 406         int   (*do_declare_destroy)(const struct lu_env *env,
 407                                     struct dt_object *dt,
 408                                     struct thandle *th);
 409         int   (*do_destroy)(const struct lu_env *env, struct dt_object *dt,
 410                             struct thandle *th);
 411
 412         /**
 413          * Announce that this object is going to be used as an index. This
 414          * operation check that object supports indexing operations and
 415          * installs appropriate dt_index_operations vector on success.
 416          *
 417          * Also probes for features. Operation is successful if all required
 418          * features are supported.
 419          */
 420         int   (*do_index_try)(const struct lu_env *env,
 421                               struct dt_object *dt,
 422                               const struct dt_index_features *feat);
 423         /**
 424          * Add nlink of the object
 425          * precondition: dt_object_exists(dt);
 426          */
 427         int   (*do_declare_ref_add)(const struct lu_env *env,
 428                                     struct dt_object *dt, struct thandle *th);
 429         int   (*do_ref_add)(const struct lu_env *env,
 430                             struct dt_object *dt, struct thandle *th);
 431         /**
 432          * Del nlink of the object
 433          * precondition: dt_object_exists(dt);
 434          */
 435         int   (*do_declare_ref_del)(const struct lu_env *env,
 436                                     struct dt_object *dt, struct thandle *th);
 437         int   (*do_ref_del)(const struct lu_env *env,
 438                             struct dt_object *dt, struct thandle *th);
 439
 440         struct obd_capa *(*do_capa_get)(const struct lu_env *env,
 441                                         struct dt_object *dt,
 442                                         struct lustre_capa *old,
 443                                         __u64 opc);
 444         int (*do_object_sync)(const struct lu_env *, struct dt_object *);
 445         /**
 446          * Get object info of next level. Currently, only get inode from osd.
 447          * This is only used by quota b=16542
 448          * precondition: dt_object_exists(dt);
 449          */
 450         int (*do_data_get)(const struct lu_env *env, struct dt_object *dt,
 451                            void **data);
 452
 453         /**
 454          * Lock object.
 455          */
 456         int (*do_object_lock)(const struct lu_env *env, struct dt_object *dt,
 457                               struct lustre_handle *lh,
 458                               struct ldlm_enqueue_info *einfo,
 459                               void *policy);
 460 };
 461
 462 /**
 463  * Per-dt-object operations on "file body".
 464  */
 465 struct dt_body_operations {
 466         /**
 467          * precondition: dt_object_exists(dt);
 468          */
 469         ssize_t (*dbo_read)(const struct lu_env *env, struct dt_object *dt,
 470                             struct lu_buf *buf, loff_t *pos,
 471                             struct lustre_capa *capa);
 472         /**
 473          * precondition: dt_object_exists(dt);
 474          */
 475         ssize_t (*dbo_declare_write)(const struct lu_env *env,
 476                                      struct dt_object *dt,
 477                                      const loff_t size, loff_t pos,
 478                                      struct thandle *handle);
 479         ssize_t (*dbo_write)(const struct lu_env *env, struct dt_object *dt,
 480                              const struct lu_buf *buf, loff_t *pos,
 481                              struct thandle *handle, struct lustre_capa *capa,
 482                              int ignore_quota);
 483         /*
 484          * methods for zero-copy IO
 485          */
 486
 487         /*
 488          * precondition: dt_object_exists(dt);
 489          * returns:
 490          * < 0 - error code
 491          * = 0 - illegal
 492          * > 0 - number of local buffers prepared
 493          */
 494         int (*dbo_bufs_get)(const struct lu_env *env, struct dt_object *dt,
 495                             loff_t pos, ssize_t len, struct niobuf_local *lb,
 496                             int rw, struct lustre_capa *capa);
 497         /*
 498          * precondition: dt_object_exists(dt);
 499          */
 500         int (*dbo_bufs_put)(const struct lu_env *env, struct dt_object *dt,
 501                             struct niobuf_local *lb, int nr);
 502         /*
 503          * precondition: dt_object_exists(dt);
 504          */
 505         int (*dbo_write_prep)(const struct lu_env *env, struct dt_object *dt,
 506                               struct niobuf_local *lb, int nr);
 507         /*
 508          * precondition: dt_object_exists(dt);
 509          */
 510         int (*dbo_declare_write_commit)(const struct lu_env *env,
 511                                         struct dt_object *dt,
 512                                         struct niobuf_local *,
 513                                         int, struct thandle *);
 514         /*
 515          * precondition: dt_object_exists(dt);
 516          */
 517         int (*dbo_write_commit)(const struct lu_env *env, struct dt_object *dt,
 518                                 struct niobuf_local *, int, struct thandle *);
 519         /*
 520          * precondition: dt_object_exists(dt);
 521          */
 522         int (*dbo_read_prep)(const struct lu_env *env, struct dt_object *dt,
 523                              struct niobuf_local *lnb, int nr);
 524         int (*dbo_fiemap_get)(const struct lu_env *env, struct dt_object *dt,
 525                               struct ll_user_fiemap *fm);
 526         /**
 527          * Punch object's content
 528          * precondition: regular object, not index
 529          */
 530         int   (*dbo_declare_punch)(const struct lu_env *, struct dt_object *,
 531                                   __u64, __u64, struct thandle *th);
 532         int   (*dbo_punch)(const struct lu_env *env, struct dt_object *dt,
 533                           __u64 start, __u64 end, struct thandle *th,
 534                           struct lustre_capa *capa);
 535 };
 536
 537 /**
 538  * Incomplete type of index record.
 539  */
 540 struct dt_rec;
 541
 542 /**
 543  * Incomplete type of index key.
 544  */
 545 struct dt_key;
 546
 547 /**
 548  * Incomplete type of dt iterator.
 549  */
 550 struct dt_it;
 551
 552 /**
 553  * Per-dt-object operations on object as index.
 554  */
 555 struct dt_index_operations {
 556         /**
 557          * precondition: dt_object_exists(dt);
 558          */
 559         int (*dio_lookup)(const struct lu_env *env, struct dt_object *dt,
 560                           struct dt_rec *rec, const struct dt_key *key,
 561                           struct lustre_capa *capa);
 562         /**
 563          * precondition: dt_object_exists(dt);
 564          */
 565         int (*dio_declare_insert)(const struct lu_env *env,
 566                                   struct dt_object *dt,
 567                                   const struct dt_rec *rec,
 568                                   const struct dt_key *key,
 569                                   struct thandle *handle);
 570         int (*dio_insert)(const struct lu_env *env, struct dt_object *dt,
 571                           const struct dt_rec *rec, const struct dt_key *key,
 572                           struct thandle *handle, struct lustre_capa *capa,
 573                           int ignore_quota);
 574         /**
 575          * precondition: dt_object_exists(dt);
 576          */
 577         int (*dio_declare_delete)(const struct lu_env *env,
 578                                   struct dt_object *dt,
 579                                   const struct dt_key *key,
 580                                   struct thandle *handle);
 581         int (*dio_delete)(const struct lu_env *env, struct dt_object *dt,
 582                           const struct dt_key *key, struct thandle *handle,
 583                           struct lustre_capa *capa);
 584         /**
 585          * Iterator interface
 586          */
 587         struct dt_it_ops {
 588                 /**
 589                  * Allocate and initialize new iterator.
 590                  *
 591                  * precondition: dt_object_exists(dt);
 592                  */
 593                 struct dt_it *(*init)(const struct lu_env *env,
 594                                       struct dt_object *dt,
 595                                       __u32 attr,
 596                                       struct lustre_capa *capa);
 597                 void          (*fini)(const struct lu_env *env,
 598                                       struct dt_it *di);
 599                 int            (*get)(const struct lu_env *env,
 600                                       struct dt_it *di,
 601                                       const struct dt_key *key);
 602                 void           (*put)(const struct lu_env *env,
 603                                       struct dt_it *di);
 604                 int           (*next)(const struct lu_env *env,
 605                                       struct dt_it *di);
 606                 struct dt_key *(*key)(const struct lu_env *env,
 607                                       const struct dt_it *di);
 608                 int       (*key_size)(const struct lu_env *env,
 609                                       const struct dt_it *di);
 610                 int            (*rec)(const struct lu_env *env,
 611                                       const struct dt_it *di,
 612                                       struct dt_rec *rec,
 613                                       __u32 attr);
 614                 __u64        (*store)(const struct lu_env *env,
 615                                       const struct dt_it *di);
 616                 int           (*load)(const struct lu_env *env,
 617                                       const struct dt_it *di, __u64 hash);
 618                 int        (*key_rec)(const struct lu_env *env,
 619                                       const struct dt_it *di, void* key_rec);
 620         } dio_it;
 621 };
 622
 623 enum dt_otable_it_valid {
 624         DOIV_ERROR_HANDLE       = 0x0001,
 625         DOIV_DRYRUN             = 0x0002,
 626 };
 627
 628 enum dt_otable_it_flags {
 629         /* Exit when fail. */
 630         DOIF_FAILOUT    = 0x0001,
 631
 632         /* Reset iteration position to the device beginning. */
 633         DOIF_RESET      = 0x0002,
 634
 635         /* There is up layer component uses the iteration. */
 636         DOIF_OUTUSED    = 0x0004,
 637
 638         /* Check only without repairing. */
 639         DOIF_DRYRUN     = 0x0008,
 640 };
 641
 642 /* otable based iteration needs to use the common DT interation APIs.
 643  * To initialize the iteration, it needs call dio_it::init() firstly.
 644  * Here is how the otable based iteration should prepare arguments to
 645  * call dt_it_ops::init().
 646  *
 647  * For otable based iteration, the 32-bits 'attr' for dt_it_ops::init()
 648  * is composed of two parts:
 649  * low 16-bits is for valid bits, high 16-bits is for flags bits. */
 650 #define DT_OTABLE_IT_FLAGS_SHIFT        16
 651 #define DT_OTABLE_IT_FLAGS_MASK         0xffff0000
 652
 653 struct dt_device {
 654         struct lu_device                   dd_lu_dev;
 655         const struct dt_device_operations *dd_ops;
 656
 657         /**
 658          * List of dt_txn_callback (see below). This is not protected in any
 659          * way, because callbacks are supposed to be added/deleted only during
 660          * single-threaded start-up shut-down procedures.
 661          */
 662         cfs_list_t                         dd_txn_callbacks;
 663 };
 664
 665 int  dt_device_init(struct dt_device *dev, struct lu_device_type *t);
 666 void dt_device_fini(struct dt_device *dev);
 667
 668 static inline int lu_device_is_dt(const struct lu_device *d)
 669 {
 670         return ergo(d != NULL, d->ld_type->ldt_tags & LU_DEVICE_DT);
 671 }
 672
 673 static inline struct dt_device * lu2dt_dev(struct lu_device *l)
 674 {
 675         LASSERT(lu_device_is_dt(l));
 676         return container_of0(l, struct dt_device, dd_lu_dev);
 677 }
 678
 679 struct dt_object {
 680         struct lu_object                   do_lu;
 681         const struct dt_object_operations *do_ops;
 682         const struct dt_body_operations   *do_body_ops;
 683         const struct dt_index_operations  *do_index_ops;
 684 };
 685
 686 /*
 687  * In-core representation of per-device local object OID storage
 688  */
 689 struct local_oid_storage {
 690         /* all initialized llog systems on this node linked by this */
 691         cfs_list_t        los_list;
 692
 693         /* how many handle's reference this los has */
 694         cfs_atomic_t      los_refcount;
 695         struct dt_device *los_dev;
 696         struct dt_object *los_obj;
 697
 698         /* data used to generate new fids */
 699         struct mutex      los_id_lock;
 700         __u64             los_seq;
 701         __u32             los_last_oid;
 702 };
 703
 704 static inline struct lu_device *dt2lu_dev(struct dt_device *d)
 705 {
 706         return &d->dd_lu_dev;
 707 }
 708
 709 static inline struct dt_object *lu2dt(struct lu_object *l)
 710 {
 711         LASSERT(l == NULL || IS_ERR(l) || lu_device_is_dt(l->lo_dev));
 712         return container_of0(l, struct dt_object, do_lu);
 713 }
 714
 715 int  dt_object_init(struct dt_object *obj,
 716                     struct lu_object_header *h, struct lu_device *d);
 717
 718 void dt_object_fini(struct dt_object *obj);
 719
 720 static inline int dt_object_exists(const struct dt_object *dt)
 721 {
 722         return lu_object_exists(&dt->do_lu);
 723 }
 724
 725 static inline int dt_object_remote(const struct dt_object *dt)
 726 {
 727         return lu_object_remote(&dt->do_lu);
 728 }
 729
 730 static inline struct dt_object *lu2dt_obj(struct lu_object *o)
 731 {
 732         LASSERT(ergo(o != NULL, lu_device_is_dt(o->lo_dev)));
 733         return container_of0(o, struct dt_object, do_lu);
 734 }
 735
 736 /**
 737  * This is the general purpose transaction handle.
 738  * 1. Transaction Life Cycle
 739  *      This transaction handle is allocated upon starting a new transaction,
 740  *      and deallocated after this transaction is committed.
 741  * 2. Transaction Nesting
 742  *      We do _NOT_ support nested transaction. So, every thread should only
 743  *      have one active transaction, and a transaction only belongs to one
 744  *      thread. Due to this, transaction handle need no reference count.
 745  * 3. Transaction & dt_object locking
 746  *      dt_object locks should be taken inside transaction.
 747  * 4. Transaction & RPC
 748  *      No RPC request should be issued inside transaction.
 749  */
 750 struct thandle {
 751         /** the dt device on which the transactions are executed */
 752         struct dt_device *th_dev;
 753
 754         /** context for this transaction, tag is LCT_TX_HANDLE */
 755         struct lu_context th_ctx;
 756
 757         /** additional tags (layers can add in declare) */
 758         __u32             th_tags;
 759
 760         /** the last operation result in this transaction.
 761          * this value is used in recovery */
 762         __s32             th_result;
 763
 764         /** whether we need sync commit */
 765         unsigned int            th_sync:1;
 766
 767         /* local transation, no need to inform other layers */
 768         unsigned int            th_local:1;
 769
 770         /* In DNE, one transaction can be disassemblied into
 771          * updates on several different MDTs, and these updates
 772          * will be attached to th_remote_update_list per target.
 773          * Only single thread will access the list, no need lock
 774          */
 775         cfs_list_t              th_remote_update_list;
 776         struct update_request   *th_current_request;
 777 };
 778
 779 /**
 780  * Transaction call-backs.
 781  *
 782  * These are invoked by osd (or underlying transaction engine) when
 783  * transaction changes state.
 784  *
 785  * Call-backs are used by upper layers to modify transaction parameters and to
 786  * perform some actions on for each transaction state transition. Typical
 787  * example is mdt registering call-back to write into last-received file
 788  * before each transaction commit.
 789  */
 790 struct dt_txn_callback {
 791         int (*dtc_txn_start)(const struct lu_env *env,
 792                              struct thandle *txn, void *cookie);
 793         int (*dtc_txn_stop)(const struct lu_env *env,
 794                             struct thandle *txn, void *cookie);
 795         void (*dtc_txn_commit)(struct thandle *txn, void *cookie);
 796         void                *dtc_cookie;
 797         __u32                dtc_tag;
 798         cfs_list_t           dtc_linkage;
 799 };
 800
 801 void dt_txn_callback_add(struct dt_device *dev, struct dt_txn_callback *cb);
 802 void dt_txn_callback_del(struct dt_device *dev, struct dt_txn_callback *cb);
 803
 804 int dt_txn_hook_start(const struct lu_env *env,
 805                       struct dt_device *dev, struct thandle *txn);
 806 int dt_txn_hook_stop(const struct lu_env *env, struct thandle *txn);
 807 void dt_txn_hook_commit(struct thandle *txn);
 808
 809 int dt_try_as_dir(const struct lu_env *env, struct dt_object *obj);
 810
 811 /**
 812  * Callback function used for parsing path.
 813  * \see llo_store_resolve
 814  */
 815 typedef int (*dt_entry_func_t)(const struct lu_env *env,
 816                             const char *name,
 817                             void *pvt);
 818
 819 #define DT_MAX_PATH 1024
 820
 821 int dt_path_parser(const struct lu_env *env,
 822                    char *local, dt_entry_func_t entry_func,
 823                    void *data);
 824
 825 struct dt_object *
 826 dt_store_resolve(const struct lu_env *env, struct dt_device *dt,
 827                  const char *path, struct lu_fid *fid);
 828
 829 struct dt_object *dt_store_open(const struct lu_env *env,
 830                                 struct dt_device *dt,
 831                                 const char *dirname,
 832                                 const char *filename,
 833                                 struct lu_fid *fid);
 834
 835 struct dt_object *dt_find_or_create(const struct lu_env *env,
 836                                     struct dt_device *dt,
 837                                     const struct lu_fid *fid,
 838                                     struct dt_object_format *dof,
 839                                     struct lu_attr *attr);
 840
 841 struct dt_object *dt_locate_at(const struct lu_env *env,
 842                                struct dt_device *dev,
 843                                const struct lu_fid *fid,
 844                                struct lu_device *top_dev);
 845 static inline struct dt_object *
 846 dt_locate(const struct lu_env *env, struct dt_device *dev,
 847           const struct lu_fid *fid)
 848 {
 849         return dt_locate_at(env, dev, fid, dev->dd_lu_dev.ld_site->ls_top_dev);
 850 }
 851
 852
 853 int local_oid_storage_init(const struct lu_env *env, struct dt_device *dev,
 854                            const struct lu_fid *first_fid,
 855                            struct local_oid_storage **los);
 856 void local_oid_storage_fini(const struct lu_env *env,
 857                             struct local_oid_storage *los);
 858 int local_object_fid_generate(const struct lu_env *env,
 859                               struct local_oid_storage *los,
 860                               struct lu_fid *fid);
 861 int local_object_declare_create(const struct lu_env *env,
 862                                 struct local_oid_storage *los,
 863                                 struct dt_object *o,
 864                                 struct lu_attr *attr,
 865                                 struct dt_object_format *dof,
 866                                 struct thandle *th);
 867 int local_object_create(const struct lu_env *env,
 868                         struct local_oid_storage *los,
 869                         struct dt_object *o,
 870                         struct lu_attr *attr, struct dt_object_format *dof,
 871                         struct thandle *th);
 872 struct dt_object *local_file_find_or_create(const struct lu_env *env,
 873                                             struct local_oid_storage *los,
 874                                             struct dt_object *parent,
 875                                             const char *name, __u32 mode);
 876 struct dt_object *local_file_find_or_create_with_fid(const struct lu_env *env,
 877                                                      struct dt_device *dt,
 878                                                      const struct lu_fid *fid,
 879                                                      struct dt_object *parent,
 880                                                      const char *name,
 881                                                      __u32 mode);
 882 struct dt_object *
 883 local_index_find_or_create(const struct lu_env *env,
 884                            struct local_oid_storage *los,
 885                            struct dt_object *parent,
 886                            const char *name, __u32 mode,
 887                            const struct dt_index_features *ft);
 888 struct dt_object *
 889 local_index_find_or_create_with_fid(const struct lu_env *env,
 890                                     struct dt_device *dt,
 891                                     const struct lu_fid *fid,
 892                                     struct dt_object *parent,
 893                                     const char *name, __u32 mode,
 894                                     const struct dt_index_features *ft);
 895 int local_object_unlink(const struct lu_env *env, struct dt_device *dt,
 896                         struct dt_object *parent, const char *name);
 897
 898 static inline int dt_object_lock(const struct lu_env *env,
 899                                  struct dt_object *o, struct lustre_handle *lh,
 900                                  struct ldlm_enqueue_info *einfo,
 901                                  void *policy)
 902 {
 903         LASSERT(o);
 904         LASSERT(o->do_ops);
 905         LASSERT(o->do_ops->do_object_lock);
 906         return o->do_ops->do_object_lock(env, o, lh, einfo, policy);
 907 }
 908
 909 int dt_lookup_dir(const struct lu_env *env, struct dt_object *dir,
 910                   const char *name, struct lu_fid *fid);
 911
 912 static inline int dt_object_sync(const struct lu_env *env,
 913                                  struct dt_object *o)
 914 {
 915         LASSERT(o);
 916         LASSERT(o->do_ops);
 917         LASSERT(o->do_ops->do_object_sync);
 918         return o->do_ops->do_object_sync(env, o);
 919 }
 920
 921 int dt_declare_version_set(const struct lu_env *env, struct dt_object *o,
 922                            struct thandle *th);
 923 void dt_version_set(const struct lu_env *env, struct dt_object *o,
 924                     dt_obj_version_t version, struct thandle *th);
 925 dt_obj_version_t dt_version_get(const struct lu_env *env, struct dt_object *o);
 926
 927
 928 int dt_read(const struct lu_env *env, struct dt_object *dt,
 929             struct lu_buf *buf, loff_t *pos);
 930 int dt_record_read(const struct lu_env *env, struct dt_object *dt,
 931                    struct lu_buf *buf, loff_t *pos);
 932 int dt_record_write(const struct lu_env *env, struct dt_object *dt,
 933                     const struct lu_buf *buf, loff_t *pos, struct thandle *th);
 934 typedef int (*dt_index_page_build_t)(const struct lu_env *env,
 935                                      union lu_page *lp, int nob,
 936                                      const struct dt_it_ops *iops,
 937                                      struct dt_it *it, __u32 attr, void *arg);
 938 int dt_index_walk(const struct lu_env *env, struct dt_object *obj,
 939                   const struct lu_rdpg *rdpg, dt_index_page_build_t filler,
 940                   void *arg);
 941 int dt_index_read(const struct lu_env *env, struct dt_device *dev,
 942                   struct idx_info *ii, const struct lu_rdpg *rdpg);
 943
 944 static inline struct thandle *dt_trans_create(const struct lu_env *env,
 945                                               struct dt_device *d)
 946 {
 947         LASSERT(d->dd_ops->dt_trans_create);
 948         return d->dd_ops->dt_trans_create(env, d);
 949 }
 950
 951 static inline int dt_trans_start(const struct lu_env *env,
 952                                  struct dt_device *d, struct thandle *th)
 953 {
 954         LASSERT(d->dd_ops->dt_trans_start);
 955         return d->dd_ops->dt_trans_start(env, d, th);
 956 }
 957
 958 /* for this transaction hooks shouldn't be called */
 959 static inline int dt_trans_start_local(const struct lu_env *env,
 960                                        struct dt_device *d, struct thandle *th)
 961 {
 962         LASSERT(d->dd_ops->dt_trans_start);
 963         th->th_local = 1;
 964         return d->dd_ops->dt_trans_start(env, d, th);
 965 }
 966
 967 static inline int dt_trans_stop(const struct lu_env *env,
 968                                 struct dt_device *d, struct thandle *th)
 969 {
 970         LASSERT(d->dd_ops->dt_trans_stop);
 971         return d->dd_ops->dt_trans_stop(env, th);
 972 }
 973
 974 static inline int dt_trans_cb_add(struct thandle *th,
 975                                   struct dt_txn_commit_cb *dcb)
 976 {
 977         LASSERT(th->th_dev->dd_ops->dt_trans_cb_add);
 978         dcb->dcb_magic = TRANS_COMMIT_CB_MAGIC;
 979         return th->th_dev->dd_ops->dt_trans_cb_add(th, dcb);
 980 }
 981 /** @} dt */
 982
 983
 984 static inline int dt_declare_record_write(const struct lu_env *env,
 985                                           struct dt_object *dt,
 986                                           int size, loff_t pos,
 987                                           struct thandle *th)
 988 {
 989         int rc;
 990
 991         LASSERTF(dt != NULL, "dt is NULL when we want to write record\n");
 992         LASSERT(th != NULL);
 993         LASSERT(dt->do_body_ops);
 994         LASSERT(dt->do_body_ops->dbo_declare_write);
 995         rc = dt->do_body_ops->dbo_declare_write(env, dt, size, pos, th);
 996         return rc;
 997 }
 998
 999 static inline int dt_declare_create(const struct lu_env *env,
1000                                     struct dt_object *dt,
1001                                     struct lu_attr *attr,
1002                                     struct dt_allocation_hint *hint,
1003                                     struct dt_object_format *dof,
1004                                     struct thandle *th)
1005 {
1006         LASSERT(dt);
1007         LASSERT(dt->do_ops);
1008         LASSERT(dt->do_ops->do_declare_create);
1009         return dt->do_ops->do_declare_create(env, dt, attr, hint, dof, th);
1010 }
1011
1012 static inline int dt_create(const struct lu_env *env,
1013                                     struct dt_object *dt,
1014                                     struct lu_attr *attr,
1015                                     struct dt_allocation_hint *hint,
1016                                     struct dt_object_format *dof,
1017                                     struct thandle *th)
1018 {
1019         LASSERT(dt);
1020         LASSERT(dt->do_ops);
1021         LASSERT(dt->do_ops->do_create);
1022         return dt->do_ops->do_create(env, dt, attr, hint, dof, th);
1023 }
1024
1025 static inline int dt_declare_destroy(const struct lu_env *env,
1026                                      struct dt_object *dt,
1027                                      struct thandle *th)
1028 {
1029         LASSERT(dt);
1030         LASSERT(dt->do_ops);
1031         LASSERT(dt->do_ops->do_declare_destroy);
1032         return dt->do_ops->do_declare_destroy(env, dt, th);
1033 }
1034
1035 static inline int dt_destroy(const struct lu_env *env,
1036                              struct dt_object *dt,
1037                              struct thandle *th)
1038 {
1039         LASSERT(dt);
1040         LASSERT(dt->do_ops);
1041         LASSERT(dt->do_ops->do_destroy);
1042         return dt->do_ops->do_destroy(env, dt, th);
1043 }
1044
1045 static inline void dt_read_lock(const struct lu_env *env,
1046                                 struct dt_object *dt,
1047                                 unsigned role)
1048 {
1049         LASSERT(dt);
1050         LASSERT(dt->do_ops);
1051         LASSERT(dt->do_ops->do_read_lock);
1052         dt->do_ops->do_read_lock(env, dt, role);
1053 }
1054
1055 static inline void dt_write_lock(const struct lu_env *env,
1056                                 struct dt_object *dt,
1057                                 unsigned role)
1058 {
1059         LASSERT(dt);
1060         LASSERT(dt->do_ops);
1061         LASSERT(dt->do_ops->do_write_lock);
1062         dt->do_ops->do_write_lock(env, dt, role);
1063 }
1064
1065 static inline void dt_read_unlock(const struct lu_env *env,
1066                                 struct dt_object *dt)
1067 {
1068         LASSERT(dt);
1069         LASSERT(dt->do_ops);
1070         LASSERT(dt->do_ops->do_read_unlock);
1071         dt->do_ops->do_read_unlock(env, dt);
1072 }
1073
1074 static inline void dt_write_unlock(const struct lu_env *env,
1075                                 struct dt_object *dt)
1076 {
1077         LASSERT(dt);
1078         LASSERT(dt->do_ops);
1079         LASSERT(dt->do_ops->do_write_unlock);
1080         dt->do_ops->do_write_unlock(env, dt);
1081 }
1082
1083 static inline int dt_write_locked(const struct lu_env *env,
1084                                   struct dt_object *dt)
1085 {
1086         LASSERT(dt);
1087         LASSERT(dt->do_ops);
1088         LASSERT(dt->do_ops->do_write_locked);
1089         return dt->do_ops->do_write_locked(env, dt);
1090 }
1091
1092 static inline int dt_attr_get(const struct lu_env *env, struct dt_object *dt,
1093                               struct lu_attr *la, void *arg)
1094 {
1095         LASSERT(dt);
1096         LASSERT(dt->do_ops);
1097         LASSERT(dt->do_ops->do_attr_get);
1098         return dt->do_ops->do_attr_get(env, dt, la, arg);
1099 }
1100
1101 static inline int dt_declare_attr_set(const struct lu_env *env,
1102                                       struct dt_object *dt,
1103                                       const struct lu_attr *la,
1104                                       struct thandle *th)
1105 {
1106         LASSERT(dt);
1107         LASSERT(dt->do_ops);
1108         LASSERT(dt->do_ops->do_declare_attr_set);
1109         return dt->do_ops->do_declare_attr_set(env, dt, la, th);
1110 }
1111
1112 static inline int dt_attr_set(const struct lu_env *env, struct dt_object *dt,
1113                               const struct lu_attr *la, struct thandle *th,
1114                               struct lustre_capa *capa)
1115 {
1116         LASSERT(dt);
1117         LASSERT(dt->do_ops);
1118         LASSERT(dt->do_ops->do_attr_set);
1119         return dt->do_ops->do_attr_set(env, dt, la, th, capa);
1120 }
1121
1122 static inline int dt_declare_ref_add(const struct lu_env *env,
1123                                      struct dt_object *dt, struct thandle *th)
1124 {
1125         LASSERT(dt);
1126         LASSERT(dt->do_ops);
1127         LASSERT(dt->do_ops->do_declare_ref_add);
1128         return dt->do_ops->do_declare_ref_add(env, dt, th);
1129 }
1130
1131 static inline int dt_ref_add(const struct lu_env *env,
1132                              struct dt_object *dt, struct thandle *th)
1133 {
1134         LASSERT(dt);
1135         LASSERT(dt->do_ops);
1136         LASSERT(dt->do_ops->do_ref_add);
1137         return dt->do_ops->do_ref_add(env, dt, th);
1138 }
1139
1140 static inline int dt_declare_ref_del(const struct lu_env *env,
1141                                      struct dt_object *dt, struct thandle *th)
1142 {
1143         LASSERT(dt);
1144         LASSERT(dt->do_ops);
1145         LASSERT(dt->do_ops->do_declare_ref_del);
1146         return dt->do_ops->do_declare_ref_del(env, dt, th);
1147 }
1148
1149 static inline int dt_ref_del(const struct lu_env *env,
1150                              struct dt_object *dt, struct thandle *th)
1151 {
1152         LASSERT(dt);
1153         LASSERT(dt->do_ops);
1154         LASSERT(dt->do_ops->do_ref_del);
1155         return dt->do_ops->do_ref_del(env, dt, th);
1156 }
1157
1158 static inline struct obd_capa *dt_capa_get(const struct lu_env *env,
1159                                            struct dt_object *dt,
1160                                            struct lustre_capa *old, __u64 opc)
1161 {
1162         LASSERT(dt);
1163         LASSERT(dt->do_ops);
1164         LASSERT(dt->do_ops->do_capa_get);
1165         return dt->do_ops->do_capa_get(env, dt, old, opc);
1166 }
1167
1168 static inline int dt_bufs_get(const struct lu_env *env, struct dt_object *d,
1169                               struct niobuf_remote *rnb,
1170                               struct niobuf_local *lnb, int rw,
1171                               struct lustre_capa *capa)
1172 {
1173         LASSERT(d);
1174         LASSERT(d->do_body_ops);
1175         LASSERT(d->do_body_ops->dbo_bufs_get);
1176         return d->do_body_ops->dbo_bufs_get(env, d, rnb->offset,
1177                                             rnb->len, lnb, rw, capa);
1178 }
1179
1180 static inline int dt_bufs_put(const struct lu_env *env, struct dt_object *d,
1181                               struct niobuf_local *lnb, int n)
1182 {
1183         LASSERT(d);
1184         LASSERT(d->do_body_ops);
1185         LASSERT(d->do_body_ops->dbo_bufs_put);
1186         return d->do_body_ops->dbo_bufs_put(env, d, lnb, n);
1187 }
1188
1189 static inline int dt_write_prep(const struct lu_env *env, struct dt_object *d,
1190                                 struct niobuf_local *lnb, int n)
1191 {
1192         LASSERT(d);
1193         LASSERT(d->do_body_ops);
1194         LASSERT(d->do_body_ops->dbo_write_prep);
1195         return d->do_body_ops->dbo_write_prep(env, d, lnb, n);
1196 }
1197
1198 static inline int dt_declare_write_commit(const struct lu_env *env,
1199                                           struct dt_object *d,
1200                                           struct niobuf_local *lnb,
1201                                           int n, struct thandle *th)
1202 {
1203         LASSERTF(d != NULL, "dt is NULL when we want to declare write\n");
1204         LASSERT(th != NULL);
1205         return d->do_body_ops->dbo_declare_write_commit(env, d, lnb, n, th);
1206 }
1207
1208
1209 static inline int dt_write_commit(const struct lu_env *env,
1210                                   struct dt_object *d, struct niobuf_local *lnb,
1211                                   int n, struct thandle *th)
1212 {
1213         LASSERT(d);
1214         LASSERT(d->do_body_ops);
1215         LASSERT(d->do_body_ops->dbo_write_commit);
1216         return d->do_body_ops->dbo_write_commit(env, d, lnb, n, th);
1217 }
1218
1219 static inline int dt_read_prep(const struct lu_env *env, struct dt_object *d,
1220                                struct niobuf_local *lnb, int n)
1221 {
1222         LASSERT(d);
1223         LASSERT(d->do_body_ops);
1224         LASSERT(d->do_body_ops->dbo_read_prep);
1225         return d->do_body_ops->dbo_read_prep(env, d, lnb, n);
1226 }
1227
1228 static inline int dt_declare_punch(const struct lu_env *env,
1229                                    struct dt_object *dt, __u64 start,
1230                                    __u64 end, struct thandle *th)
1231 {
1232         LASSERT(dt);
1233         LASSERT(dt->do_body_ops);
1234         LASSERT(dt->do_body_ops->dbo_declare_punch);
1235         return dt->do_body_ops->dbo_declare_punch(env, dt, start, end, th);
1236 }
1237
1238 static inline int dt_punch(const struct lu_env *env, struct dt_object *dt,
1239                            __u64 start, __u64 end, struct thandle *th,
1240                            struct lustre_capa *capa)
1241 {
1242         LASSERT(dt);
1243         LASSERT(dt->do_body_ops);
1244         LASSERT(dt->do_body_ops->dbo_punch);
1245         return dt->do_body_ops->dbo_punch(env, dt, start, end, th, capa);
1246 }
1247
1248 static inline int dt_fiemap_get(const struct lu_env *env, struct dt_object *d,
1249                                 struct ll_user_fiemap *fm)
1250 {
1251         LASSERT(d);
1252         if (d->do_body_ops == NULL)
1253                 return -EPROTO;
1254         if (d->do_body_ops->dbo_fiemap_get == NULL)
1255                 return -EOPNOTSUPP;
1256         return d->do_body_ops->dbo_fiemap_get(env, d, fm);
1257 }
1258
1259 static inline int dt_statfs(const struct lu_env *env, struct dt_device *dev,
1260                             struct obd_statfs *osfs)
1261 {
1262         LASSERT(dev);
1263         LASSERT(dev->dd_ops);
1264         LASSERT(dev->dd_ops->dt_statfs);
1265         return dev->dd_ops->dt_statfs(env, dev, osfs);
1266 }
1267
1268 static inline int dt_root_get(const struct lu_env *env, struct dt_device *dev,
1269                               struct lu_fid *f)
1270 {
1271         LASSERT(dev);
1272         LASSERT(dev->dd_ops);
1273         LASSERT(dev->dd_ops->dt_root_get);
1274         return dev->dd_ops->dt_root_get(env, dev, f);
1275 }
1276
1277 static inline void dt_conf_get(const struct lu_env *env,
1278                                const struct dt_device *dev,
1279                                struct dt_device_param *param)
1280 {
1281         LASSERT(dev);
1282         LASSERT(dev->dd_ops);
1283         LASSERT(dev->dd_ops->dt_conf_get);
1284         return dev->dd_ops->dt_conf_get(env, dev, param);
1285 }
1286
1287 static inline int dt_sync(const struct lu_env *env, struct dt_device *dev)
1288 {
1289         LASSERT(dev);
1290         LASSERT(dev->dd_ops);
1291         LASSERT(dev->dd_ops->dt_sync);
1292         return dev->dd_ops->dt_sync(env, dev);
1293 }
1294
1295 static inline int dt_ro(const struct lu_env *env, struct dt_device *dev)
1296 {
1297         LASSERT(dev);
1298         LASSERT(dev->dd_ops);
1299         LASSERT(dev->dd_ops->dt_ro);
1300         return dev->dd_ops->dt_ro(env, dev);
1301 }
1302
1303 static inline int dt_declare_insert(const struct lu_env *env,
1304                                     struct dt_object *dt,
1305                                     const struct dt_rec *rec,
1306                                     const struct dt_key *key,
1307                                     struct thandle *th)
1308 {
1309         LASSERT(dt);
1310         LASSERT(dt->do_index_ops);
1311         LASSERT(dt->do_index_ops->dio_declare_insert);
1312         return dt->do_index_ops->dio_declare_insert(env, dt, rec, key, th);
1313 }
1314
1315 static inline int dt_insert(const struct lu_env *env,
1316                                     struct dt_object *dt,
1317                                     const struct dt_rec *rec,
1318                                     const struct dt_key *key,
1319                                     struct thandle *th,
1320                                     struct lustre_capa *capa,
1321                                     int noquota)
1322 {
1323         LASSERT(dt);
1324         LASSERT(dt->do_index_ops);
1325         LASSERT(dt->do_index_ops->dio_insert);
1326         return dt->do_index_ops->dio_insert(env, dt, rec, key, th,
1327                                             capa, noquota);
1328 }
1329
1330 static inline int dt_declare_xattr_del(const struct lu_env *env,
1331                                        struct dt_object *dt,
1332                                        const char *name,
1333                                        struct thandle *th)
1334 {
1335         LASSERT(dt);
1336         LASSERT(dt->do_ops);
1337         LASSERT(dt->do_ops->do_declare_xattr_del);
1338         return dt->do_ops->do_declare_xattr_del(env, dt, name, th);
1339 }
1340
1341 static inline int dt_xattr_del(const struct lu_env *env,
1342                                struct dt_object *dt, const char *name,
1343                                struct thandle *th,
1344                                struct lustre_capa *capa)
1345 {
1346         LASSERT(dt);
1347         LASSERT(dt->do_ops);
1348         LASSERT(dt->do_ops->do_xattr_del);
1349         return dt->do_ops->do_xattr_del(env, dt, name, th, capa);
1350 }
1351
1352 static inline int dt_declare_xattr_set(const struct lu_env *env,
1353                                       struct dt_object *dt,
1354                                       const struct lu_buf *buf,
1355                                       const char *name, int fl,
1356                                       struct thandle *th)
1357 {
1358         LASSERT(dt);
1359         LASSERT(dt->do_ops);
1360         LASSERT(dt->do_ops->do_declare_xattr_set);
1361         return dt->do_ops->do_declare_xattr_set(env, dt, buf, name, fl, th);
1362 }
1363
1364 static inline int dt_xattr_set(const struct lu_env *env,
1365                               struct dt_object *dt, const struct lu_buf *buf,
1366                               const char *name, int fl, struct thandle *th,
1367                               struct lustre_capa *capa)
1368 {
1369         LASSERT(dt);
1370         LASSERT(dt->do_ops);
1371         LASSERT(dt->do_ops->do_xattr_set);
1372         return dt->do_ops->do_xattr_set(env, dt, buf, name, fl, th, capa);
1373 }
1374
1375 static inline int dt_xattr_get(const struct lu_env *env,
1376                               struct dt_object *dt, struct lu_buf *buf,
1377                               const char *name, struct lustre_capa *capa)
1378 {
1379         LASSERT(dt);
1380         LASSERT(dt->do_ops);
1381         LASSERT(dt->do_ops->do_xattr_get);
1382         return dt->do_ops->do_xattr_get(env, dt, buf, name, capa);
1383 }
1384
1385 static inline int dt_xattr_list(const struct lu_env *env,
1386                                struct dt_object *dt, struct lu_buf *buf,
1387                                struct lustre_capa *capa)
1388 {
1389         LASSERT(dt);
1390         LASSERT(dt->do_ops);
1391         LASSERT(dt->do_ops->do_xattr_list);
1392         return dt->do_ops->do_xattr_list(env, dt, buf, capa);
1393 }
1394
1395 static inline int dt_declare_delete(const struct lu_env *env,
1396                                     struct dt_object *dt,
1397                                     const struct dt_key *key,
1398                                     struct thandle *th)
1399 {
1400         LASSERT(dt);
1401         LASSERT(dt->do_index_ops);
1402         LASSERT(dt->do_index_ops->dio_declare_delete);
1403         return dt->do_index_ops->dio_declare_delete(env, dt, key, th);
1404 }
1405
1406 static inline int dt_delete(const struct lu_env *env,
1407                             struct dt_object *dt,
1408                             const struct dt_key *key,
1409                             struct thandle *th,
1410                             struct lustre_capa *capa)
1411 {
1412         LASSERT(dt);
1413         LASSERT(dt->do_index_ops);
1414         LASSERT(dt->do_index_ops->dio_delete);
1415         return dt->do_index_ops->dio_delete(env, dt, key, th, capa);
1416 }
1417
1418 static inline int dt_commit_async(const struct lu_env *env,
1419                                   struct dt_device *dev)
1420 {
1421         LASSERT(dev);
1422         LASSERT(dev->dd_ops);
1423         LASSERT(dev->dd_ops->dt_commit_async);
1424         return dev->dd_ops->dt_commit_async(env, dev);
1425 }
1426
1427 static inline int dt_init_capa_ctxt(const struct lu_env *env,
1428                                     struct dt_device *dev,
1429                                     int mode, unsigned long timeout,
1430                                     __u32 alg, struct lustre_capa_key *keys)
1431 {
1432         LASSERT(dev);
1433         LASSERT(dev->dd_ops);
1434         LASSERT(dev->dd_ops->dt_init_capa_ctxt);
1435         return dev->dd_ops->dt_init_capa_ctxt(env, dev, mode,
1436                                               timeout, alg, keys);
1437 }
1438
1439 static inline int dt_lookup(const struct lu_env *env,
1440                             struct dt_object *dt,
1441                             struct dt_rec *rec,
1442                             const struct dt_key *key,
1443                             struct lustre_capa *capa)
1444 {
1445         int ret;
1446
1447         LASSERT(dt);
1448         LASSERT(dt->do_index_ops);
1449         LASSERT(dt->do_index_ops->dio_lookup);
1450
1451         ret = dt->do_index_ops->dio_lookup(env, dt, rec, key, capa);
1452         if (ret > 0)
1453                 ret = 0;
1454         else if (ret == 0)
1455                 ret = -ENOENT;
1456         return ret;
1457 }
1458
1459 #define LU221_BAD_TIME (0x80000000U + 24 * 3600)
1460
1461 struct dt_find_hint {
1462         struct lu_fid        *dfh_fid;
1463         struct dt_device     *dfh_dt;
1464         struct dt_object     *dfh_o;
1465 };
1466
1467 struct dt_thread_info {
1468         char                     dti_buf[DT_MAX_PATH];
1469         struct dt_find_hint      dti_dfh;
1470         struct lu_attr           dti_attr;
1471         struct lu_fid            dti_fid;
1472         struct dt_object_format  dti_dof;
1473         struct lustre_mdt_attrs  dti_lma;
1474         struct lu_buf            dti_lb;
1475         loff_t                   dti_off;
1476 };
1477
1478 extern struct lu_context_key dt_key;
1479
1480 static inline struct dt_thread_info *dt_info(const struct lu_env *env)
1481 {
1482         struct dt_thread_info *dti;
1483
1484         dti = lu_context_key_get(&env->le_ctx, &dt_key);
1485         LASSERT(dti);
1486         return dti;
1487 }
1488
1489 int dt_global_init(void);
1490 void dt_global_fini(void);
1491
1492 # ifdef LPROCFS
1493 int lprocfs_dt_rd_blksize(char *page, char **start, off_t off,
1494                           int count, int *eof, void *data);
1495 int lprocfs_dt_rd_kbytestotal(char *page, char **start, off_t off,
1496                               int count, int *eof, void *data);
1497 int lprocfs_dt_rd_kbytesfree(char *page, char **start, off_t off,
1498                              int count, int *eof, void *data);
1499 int lprocfs_dt_rd_kbytesavail(char *page, char **start, off_t off,
1500                               int count, int *eof, void *data);
1501 int lprocfs_dt_rd_filestotal(char *page, char **start, off_t off,
1502                              int count, int *eof, void *data);
1503 int lprocfs_dt_rd_filesfree(char *page, char **start, off_t off,
1504                             int count, int *eof, void *data);
1505 # endif /* LPROCFS */
1506
1507 #endif /* __LUSTRE_DT_OBJECT_H */