lustre/osd-ldiskfs/osd_internal.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, 2012, Whamcloud, Inc.
  31  */
  32 /*
  33  * This file is part of Lustre, http://www.lustre.org/
  34  * Lustre is a trademark of Sun Microsystems, Inc.
  35  *
  36  * lustre/osd/osd_internal.h
  37  *
  38  * Shared definitions and declarations for osd module
  39  *
  40  * Author: Nikita Danilov <nikita@clusterfs.com>
  41  */
  42
  43 #ifndef _OSD_INTERNAL_H
  44 #define _OSD_INTERNAL_H
  45
  46 #if defined(__KERNEL__)
  47
  48 /* struct rw_semaphore */
  49 #include <linux/rwsem.h>
  50 /* struct dentry */
  51 #include <linux/dcache.h>
  52 /* struct dirent64 */
  53 #include <linux/dirent.h>
  54
  55 #include <ldiskfs/ldiskfs.h>
  56 #include <ldiskfs/ldiskfs_jbd2.h>
  57 #ifdef HAVE_LDISKFS_JOURNAL_CALLBACK_ADD
  58 # define journal_callback ldiskfs_journal_cb_entry
  59 # define osd_journal_callback_set(handle, func, jcb) \
  60          ldiskfs_journal_callback_add(handle, func, jcb)
  61 #else
  62 # define osd_journal_callback_set(handle, func, jcb) \
  63          jbd2_journal_callback_set(handle, func, jcb)
  64 #endif
  65
  66 /* fsfilt_{get|put}_ops */
  67 #include <lustre_fsfilt.h>
  68
  69 /* LUSTRE_OSD_NAME */
  70 #include <obd.h>
  71 /* class_register_type(), class_unregister_type(), class_get_type() */
  72 #include <obd_class.h>
  73 #include <lustre_disk.h>
  74 #include <dt_object.h>
  75
  76 #include "osd_oi.h"
  77 #include "osd_iam.h"
  78 #include "osd_scrub.h"
  79
  80 struct inode;
  81
  82 #define OSD_COUNTERS (0)
  83
  84 /* Lustre special inode::i_state to indicate OI scrub skip this inode. */
  85 #define I_LUSTRE_NOSCRUB        (1 << 31)
  86
  87 /** Enable thandle usage statistics */
  88 #define OSD_THANDLE_STATS (0)
  89
  90 #ifdef HAVE_QUOTA_SUPPORT
  91 struct osd_ctxt {
  92         __u32 oc_uid;
  93         __u32 oc_gid;
  94         cfs_kernel_cap_t oc_cap;
  95 };
  96 #endif
  97
  98 struct osd_directory {
  99         struct iam_container od_container;
 100         struct iam_descr     od_descr;
 101 };
 102
 103 /*
 104  * Object Index (oi) instance.
 105  */
 106 struct osd_oi {
 107         /*
 108          * underlying index object, where fid->id mapping in stored.
 109          */
 110         struct inode         *oi_inode;
 111         struct osd_directory  oi_dir;
 112 };
 113
 114 extern const int osd_dto_credits_noquota[];
 115
 116 struct osd_object {
 117         struct dt_object        oo_dt;
 118         /**
 119          * Inode for file system object represented by this osd_object. This
 120          * inode is pinned for the whole duration of lu_object life.
 121          *
 122          * Not modified concurrently (either setup early during object
 123          * creation, or assigned by osd_object_create() under write lock).
 124          */
 125         struct inode           *oo_inode;
 126         /**
 127          * to protect index ops.
 128          */
 129         struct htree_lock_head *oo_hl_head;
 130         cfs_rw_semaphore_t      oo_ext_idx_sem;
 131         cfs_rw_semaphore_t      oo_sem;
 132         struct osd_directory   *oo_dir;
 133         /** protects inode attributes. */
 134         cfs_spinlock_t          oo_guard;
 135         /**
 136          * Following two members are used to indicate the presence of dot and
 137          * dotdot in the given directory. This is required for interop mode
 138          * (b11826).
 139          */
 140         int                     oo_compat_dot_created;
 141         int                     oo_compat_dotdot_created;
 142
 143         const struct lu_env    *oo_owner;
 144 #ifdef CONFIG_LOCKDEP
 145         struct lockdep_map      oo_dep_map;
 146 #endif
 147 };
 148
 149 #ifdef HAVE_LDISKFS_PDO
 150
 151 #define osd_ldiskfs_find_entry(dir, dentry, de, lock)   \
 152         ll_ldiskfs_find_entry(dir, dentry, de, lock)
 153 #define osd_ldiskfs_add_entry(handle, child, cinode, hlock) \
 154         ldiskfs_add_entry(handle, child, cinode, hlock)
 155
 156 #else /* HAVE_LDISKFS_PDO */
 157
 158 struct htree_lock {
 159         int     dummy;
 160 };
 161
 162 struct htree_lock_head {
 163         int     dummy;
 164 };
 165
 166 #define ldiskfs_htree_lock(lock, head, inode, op)  do { LBUG(); } while (0)
 167 #define ldiskfs_htree_unlock(lock)                 do { LBUG(); } while (0)
 168
 169 static inline struct htree_lock_head *ldiskfs_htree_lock_head_alloc(int dep)
 170 {
 171         LBUG();
 172         return NULL;
 173 }
 174
 175 #define ldiskfs_htree_lock_head_free(lh)           do { LBUG(); } while (0)
 176
 177 #define LDISKFS_DUMMY_HTREE_LOCK        0xbabecafe
 178
 179 static inline struct htree_lock *ldiskfs_htree_lock_alloc(void)
 180 {
 181         return (struct htree_lock *)LDISKFS_DUMMY_HTREE_LOCK;
 182 }
 183
 184 static inline void ldiskfs_htree_lock_free(struct htree_lock *lk)
 185 {
 186         LASSERT((unsigned long)lk == LDISKFS_DUMMY_HTREE_LOCK);
 187 }
 188
 189 #define HTREE_HBITS_DEF         0
 190
 191 #define osd_ldiskfs_find_entry(dir, dentry, de, lock)   \
 192         ll_ldiskfs_find_entry(dir, dentry, de)
 193 #define osd_ldiskfs_add_entry(handle, child, cinode, lock) \
 194         ldiskfs_add_entry(handle, child, cinode)
 195
 196 #endif /* HAVE_LDISKFS_PDO */
 197
 198 #define OSD_OTABLE_IT_CACHE_SIZE        128
 199 #define OSD_OTABLE_IT_CACHE_MASK        (~(OSD_OTABLE_IT_CACHE_SIZE - 1))
 200
 201 struct osd_inconsistent_item {
 202         /* link into osd_scrub::os_inconsistent_items,
 203          * protected by osd_scrub::os_lock. */
 204         cfs_list_t             oii_list;
 205
 206         /* The right FID <=> ino#/gen mapping. */
 207         struct osd_idmap_cache oii_cache;
 208
 209         unsigned int           oii_insert:1; /* insert or update mapping. */
 210 };
 211
 212 struct osd_otable_cache {
 213         struct osd_idmap_cache ooc_cache[OSD_OTABLE_IT_CACHE_SIZE];
 214
 215         /* Index for next cache slot to be filled. */
 216         int                    ooc_producer_idx;
 217
 218         /* Index for next cache slot to be returned by it::next(). */
 219         int                    ooc_consumer_idx;
 220
 221         /* How many items in ooc_cache. */
 222         int                    ooc_cached_items;
 223
 224         /* Position for up layer LFSCK iteration pre-loading. */
 225         __u32                  ooc_pos_preload;
 226 };
 227
 228 struct osd_otable_it {
 229         struct osd_device       *ooi_dev;
 230         struct osd_otable_cache  ooi_cache;
 231
 232         /* For osd_otable_it_key. */
 233         __u8                     ooi_key[16];
 234
 235         /* The following bits can be updated/checked w/o lock protection.
 236          * If more bits will be introduced in the future and need lock to
 237          * protect, please add comment. */
 238         unsigned long            ooi_used_outside:1, /* Some user out of OSD
 239                                                       * uses the iteration. */
 240                                  ooi_all_cached:1, /* No more entries can be
 241                                                     * filled into cache. */
 242                                  ooi_user_ready:1, /* The user out of OSD is
 243                                                     * ready to iterate. */
 244                                  ooi_waiting:1; /* it::next is waiting. */
 245 };
 246
 247 extern const int osd_dto_credits_noquota[];
 248
 249 /*
 250  * osd device.
 251  */
 252 struct osd_device {
 253         /* super-class */
 254         struct dt_device          od_dt_dev;
 255         /* information about underlying file system */
 256         struct lustre_mount_info *od_mount;
 257         struct vfsmount          *od_mnt;
 258         /* object index */
 259         struct osd_oi           **od_oi_table;
 260         /* total number of OI containers */
 261         int                       od_oi_count;
 262         /*
 263          * Fid Capability
 264          */
 265         unsigned int              od_fl_capa:1;
 266         unsigned long             od_capa_timeout;
 267         __u32                     od_capa_alg;
 268         struct lustre_capa_key   *od_capa_keys;
 269         cfs_hlist_head_t         *od_capa_hash;
 270
 271         cfs_proc_dir_entry_t     *od_proc_entry;
 272         struct lprocfs_stats     *od_stats;
 273         /*
 274          * statfs optimization: we cache a bit.
 275          */
 276         cfs_time_t                od_osfs_age;
 277         struct obd_statfs         od_statfs;
 278         cfs_spinlock_t            od_osfs_lock;
 279
 280         /**
 281          * The following flag indicates, if it is interop mode or not.
 282          * It will be initialized, using mount param.
 283          */
 284         __u32                     od_iop_mode;
 285
 286         struct fsfilt_operations *od_fsops;
 287
 288         /*
 289          * mapping for legacy OST objids
 290          */
 291         struct osd_compat_objid  *od_ost_map;
 292
 293         unsigned long long        od_readcache_max_filesize;
 294         int                       od_read_cache;
 295         int                       od_writethrough_cache;
 296
 297         struct brw_stats          od_brw_stats;
 298         cfs_atomic_t              od_r_in_flight;
 299         cfs_atomic_t              od_w_in_flight;
 300
 301         cfs_mutex_t               od_otable_mutex;
 302         struct osd_otable_it     *od_otable_it;
 303         struct osd_scrub          od_scrub;
 304 };
 305
 306 #define OSD_TRACK_DECLARES
 307 #ifdef OSD_TRACK_DECLARES
 308 #define OSD_DECLARE_OP(oh, op)   {                               \
 309         LASSERT(oh->ot_handle == NULL);                          \
 310         ((oh)->ot_declare_ ##op)++; }
 311 #define OSD_EXEC_OP(handle,op)      {                            \
 312         struct osd_thandle *oh;                                  \
 313         oh = container_of0(handle, struct osd_thandle, ot_super);\
 314         if (((oh)->ot_declare_ ##op) > 0) {                      \
 315                 ((oh)->ot_declare_ ##op)--;                      \
 316         }                                                        \
 317         }
 318 #else
 319 #define OSD_DECLARE_OP(oh, op)
 320 #define OSD_EXEC_OP(oh, op)
 321 #endif
 322
 323 /* There are at most 10 uid/gids are affected in a transaction, and
 324  * that's rename case:
 325  * - 2 for source parent uid & gid;
 326  * - 2 for source child uid & gid ('..' entry update when the child
 327  *   is directory);
 328  * - 2 for target parent uid & gid;
 329  * - 2 for target child uid & gid (if the target child exists);
 330  * - 2 for root uid & gid (last_rcvd, llog, etc);
 331  *
 332  * The 0 to (OSD_MAX_UGID_CNT - 1) bits of ot_id_type is for indicating
 333  * the id type of each id in the ot_id_array.
 334  */
 335 #define OSD_MAX_UGID_CNT        10
 336
 337 struct osd_thandle {
 338         struct thandle          ot_super;
 339         handle_t               *ot_handle;
 340         struct journal_callback ot_jcb;
 341         cfs_list_t              ot_dcb_list;
 342         /* Link to the device, for debugging. */
 343         struct lu_ref_link     *ot_dev_link;
 344         unsigned short          ot_credits;
 345         unsigned short          ot_id_cnt;
 346         unsigned short          ot_id_type;
 347         uid_t                   ot_id_array[OSD_MAX_UGID_CNT];
 348
 349 #ifdef OSD_TRACK_DECLARES
 350         unsigned char           ot_declare_attr_set;
 351         unsigned char           ot_declare_punch;
 352         unsigned char           ot_declare_xattr_set;
 353         unsigned char           ot_declare_create;
 354         unsigned char           ot_declare_destroy;
 355         unsigned char           ot_declare_ref_add;
 356         unsigned char           ot_declare_ref_del;
 357         unsigned char           ot_declare_write;
 358         unsigned char           ot_declare_insert;
 359         unsigned char           ot_declare_delete;
 360 #endif
 361
 362 #if OSD_THANDLE_STATS
 363         /** time when this handle was allocated */
 364         cfs_time_t oth_alloced;
 365
 366         /** time when this thanle was started */
 367         cfs_time_t oth_started;
 368 #endif
 369 };
 370
 371 /**
 372  * Basic transaction credit op
 373  */
 374 enum dt_txn_op {
 375         DTO_INDEX_INSERT,
 376         DTO_INDEX_DELETE,
 377         DTO_INDEX_UPDATE,
 378         DTO_OBJECT_CREATE,
 379         DTO_OBJECT_DELETE,
 380         DTO_ATTR_SET_BASE,
 381         DTO_XATTR_SET,
 382         DTO_LOG_REC, /**< XXX temporary: dt layer knows nothing about llog. */
 383         DTO_WRITE_BASE,
 384         DTO_WRITE_BLOCK,
 385         DTO_ATTR_SET_CHOWN,
 386
 387         DTO_NR
 388 };
 389
 390 /*
 391  * osd dev stats
 392  */
 393
 394 #ifdef LPROCFS
 395 enum {
 396         LPROC_OSD_READ_BYTES    = 0,
 397         LPROC_OSD_WRITE_BYTES   = 1,
 398         LPROC_OSD_GET_PAGE      = 2,
 399         LPROC_OSD_NO_PAGE       = 3,
 400         LPROC_OSD_CACHE_ACCESS  = 4,
 401         LPROC_OSD_CACHE_HIT     = 5,
 402         LPROC_OSD_CACHE_MISS    = 6,
 403
 404 #if OSD_THANDLE_STATS
 405         LPROC_OSD_THANDLE_STARTING,
 406         LPROC_OSD_THANDLE_OPEN,
 407         LPROC_OSD_THANDLE_CLOSING,
 408 #endif
 409         LPROC_OSD_LAST,
 410 };
 411 #endif
 412
 413 /**
 414  * Storage representation for fids.
 415  *
 416  * Variable size, first byte contains the length of the whole record.
 417  */
 418 struct osd_fid_pack {
 419         unsigned char fp_len;
 420         char fp_area[sizeof(struct lu_fid)];
 421 };
 422
 423 struct osd_it_ea_dirent {
 424         struct lu_fid   oied_fid;
 425         __u64           oied_ino;
 426         __u64           oied_off;
 427         unsigned short  oied_namelen;
 428         unsigned int    oied_type;
 429         char            oied_name[0];
 430 } __attribute__((packed));
 431
 432 /**
 433  * as osd_it_ea_dirent (in memory dirent struct for osd) is greater
 434  * than lu_dirent struct. osd readdir reads less number of dirent than
 435  * required for mdd dir page. so buffer size need to be increased so that
 436  * there  would be one ext3 readdir for every mdd readdir page.
 437  */
 438
 439 #define OSD_IT_EA_BUFSIZE       (CFS_PAGE_SIZE + CFS_PAGE_SIZE/4)
 440
 441 /**
 442  * This is iterator's in-memory data structure in interoperability
 443  * mode (i.e. iterator over ldiskfs style directory)
 444  */
 445 struct osd_it_ea {
 446         struct osd_object   *oie_obj;
 447         /** used in ldiskfs iterator, to stored file pointer */
 448         struct file          oie_file;
 449         /** how many entries have been read-cached from storage */
 450         int                  oie_rd_dirent;
 451         /** current entry is being iterated by caller */
 452         int                  oie_it_dirent;
 453         /** current processing entry */
 454         struct osd_it_ea_dirent *oie_dirent;
 455         /** buffer to hold entries, size == OSD_IT_EA_BUFSIZE */
 456         void                *oie_buf;
 457 };
 458
 459 /**
 460  * Iterator's in-memory data structure for IAM mode.
 461  */
 462 struct osd_it_iam {
 463         struct osd_object     *oi_obj;
 464         struct iam_path_descr *oi_ipd;
 465         struct iam_iterator    oi_it;
 466 };
 467
 468 #define MAX_BLOCKS_PER_PAGE (CFS_PAGE_SIZE / 512)
 469
 470 struct osd_iobuf {
 471         cfs_waitq_t        dr_wait;
 472         cfs_atomic_t       dr_numreqs;  /* number of reqs being processed */
 473         int                dr_max_pages;
 474         int                dr_npages;
 475         int                dr_error;
 476         int                dr_frags;
 477         unsigned int       dr_ignore_quota:1;
 478         unsigned int       dr_elapsed_valid:1; /* we really did count time */
 479         unsigned int       dr_rw:1;
 480         struct page       *dr_pages[PTLRPC_MAX_BRW_PAGES];
 481         unsigned long      dr_blocks[PTLRPC_MAX_BRW_PAGES*MAX_BLOCKS_PER_PAGE];
 482         unsigned long      dr_start_time;
 483         unsigned long      dr_elapsed;  /* how long io took */
 484         struct osd_device *dr_dev;
 485 };
 486
 487 struct osd_thread_info {
 488         const struct lu_env   *oti_env;
 489         /**
 490          * used for index operations.
 491          */
 492         struct dentry          oti_obj_dentry;
 493         struct dentry          oti_child_dentry;
 494
 495         /** dentry for Iterator context. */
 496         struct dentry          oti_it_dentry;
 497         struct htree_lock     *oti_hlock;
 498
 499         struct lu_fid          oti_fid;
 500         struct lu_fid          oti_fid2;
 501         struct osd_inode_id    oti_id;
 502         struct osd_inode_id    oti_id2;
 503         struct ost_id          oti_ostid;
 504
 505         /*
 506          * XXX temporary: for ->i_op calls.
 507          */
 508         struct timespec        oti_time;
 509         /*
 510          * XXX temporary: fake struct file for osd_object_sync
 511          */
 512         struct file            oti_file;
 513         /*
 514          * XXX temporary: for capa operations.
 515          */
 516         struct lustre_capa_key oti_capa_key;
 517         struct lustre_capa     oti_capa;
 518
 519         /** osd_device reference, initialized in osd_trans_start() and
 520             used in osd_trans_stop() */
 521         struct osd_device     *oti_dev;
 522
 523         /**
 524          * following ipd and it structures are used for osd_index_iam_lookup()
 525          * these are defined separately as we might do index operation
 526          * in open iterator session.
 527          */
 528
 529         /** osd iterator context used for iterator session */
 530
 531         union {
 532                 struct osd_it_iam      oti_it;
 533                 /** ldiskfs iterator data structure, see osd_it_ea_{init, fini} */
 534                 struct osd_it_ea       oti_it_ea;
 535         };
 536
 537         /** pre-allocated buffer used by oti_it_ea, size OSD_IT_EA_BUFSIZE */
 538         void                  *oti_it_ea_buf;
 539
 540         cfs_kstatfs_t          oti_ksfs;
 541
 542         /** IAM iterator for index operation. */
 543         struct iam_iterator    oti_idx_it;
 544
 545         /** union to guarantee that ->oti_ipd[] has proper alignment. */
 546         union {
 547                 char           oti_it_ipd[DX_IPD_MAX_SIZE];
 548                 long long      oti_alignment_lieutenant;
 549         };
 550
 551         union {
 552                 char           oti_idx_ipd[DX_IPD_MAX_SIZE];
 553                 long long      oti_alignment_lieutenant_colonel;
 554         };
 555
 556         struct osd_idmap_cache oti_cache;
 557
 558         int                    oti_r_locks;
 559         int                    oti_w_locks;
 560         int                    oti_txns;
 561         /** used in osd_fid_set() to put xattr */
 562         struct lu_buf          oti_buf;
 563         /** used in osd_ea_fid_set() to set fid into common ea */
 564         struct lustre_mdt_attrs oti_mdt_attrs;
 565         /** 0-copy IO */
 566         struct osd_iobuf       oti_iobuf;
 567         struct inode           oti_inode;
 568         int                    oti_created[PTLRPC_MAX_BRW_PAGES];
 569 #ifdef HAVE_QUOTA_SUPPORT
 570         struct osd_ctxt        oti_ctxt;
 571 #endif
 572         struct lu_env          oti_obj_delete_tx_env;
 573 #define OSD_FID_REC_SZ 32
 574         char                   oti_ldp[OSD_FID_REC_SZ];
 575         char                   oti_ldp2[OSD_FID_REC_SZ];
 576 };
 577
 578 extern int ldiskfs_pdo;
 579
 580 #ifdef LPROCFS
 581 /* osd_lproc.c */
 582 void lprocfs_osd_init_vars(struct lprocfs_static_vars *lvars);
 583 int osd_procfs_init(struct osd_device *osd, const char *name);
 584 int osd_procfs_fini(struct osd_device *osd);
 585 void osd_lprocfs_time_start(const struct lu_env *env);
 586 void osd_lprocfs_time_end(const struct lu_env *env,
 587                           struct osd_device *osd, int op);
 588 void osd_brw_stats_update(struct osd_device *osd, struct osd_iobuf *iobuf);
 589
 590 #endif
 591 int osd_statfs(const struct lu_env *env, struct dt_device *dev,
 592                struct obd_statfs *sfs);
 593 int osd_object_auth(const struct lu_env *env, struct dt_object *dt,
 594                     struct lustre_capa *capa, __u64 opc);
 595 void osd_declare_qid(struct dt_object *dt, struct osd_thandle *oh,
 596                      int type, uid_t id, struct inode *inode);
 597 struct inode *osd_iget(struct osd_thread_info *info, struct osd_device *dev,
 598                        struct osd_inode_id *id);
 599 struct inode *osd_iget_fid(struct osd_thread_info *info, struct osd_device *dev,
 600                            struct osd_inode_id *id, struct lu_fid *fid);
 601
 602 int osd_compat_init(struct osd_device *dev);
 603 void osd_compat_fini(struct osd_device *dev);
 604 int osd_compat_objid_lookup(struct osd_thread_info *info,
 605                             struct osd_device *osd,
 606                             const struct lu_fid *fid, struct osd_inode_id *id);
 607 int osd_compat_objid_insert(struct osd_thread_info *info,
 608                             struct osd_device *osd,
 609                             const struct lu_fid *fid,
 610                             const struct osd_inode_id *id, struct thandle *th);
 611 int osd_compat_objid_delete(struct osd_thread_info *info,
 612                             struct osd_device *osd,
 613                             const struct lu_fid *fid, struct thandle *th);
 614 int osd_compat_spec_lookup(struct osd_thread_info *info,
 615                            struct osd_device *osd,
 616                            const struct lu_fid *fid, struct osd_inode_id *id);
 617 int osd_compat_spec_insert(struct osd_thread_info *info,
 618                            struct osd_device *osd,
 619                            const struct lu_fid *fid,
 620                            const struct osd_inode_id *id, struct thandle *th);
 621
 622 void osd_scrub_file_reset(struct osd_scrub *scrub, __u8 *uuid, __u64 flags);
 623 int osd_scrub_file_store(struct osd_scrub *scrub);
 624 int osd_scrub_start(struct osd_device *dev);
 625 int osd_scrub_setup(const struct lu_env *env, struct osd_device *dev);
 626 void osd_scrub_cleanup(const struct lu_env *env, struct osd_device *dev);
 627 int osd_oii_insert(struct osd_device *dev, struct osd_idmap_cache *oic,
 628                    int insert);
 629 int osd_oii_lookup(struct osd_device *dev, const struct lu_fid *fid,
 630                    struct osd_inode_id *id);
 631
 632 /*
 633  * Invariants, assertions.
 634  */
 635
 636 /*
 637  * XXX: do not enable this, until invariant checking code is made thread safe
 638  * in the face of pdirops locking.
 639  */
 640 #define OSD_INVARIANT_CHECKS (0)
 641
 642 #if OSD_INVARIANT_CHECKS
 643 static inline int osd_invariant(const struct osd_object *obj)
 644 {
 645         return
 646                 obj != NULL &&
 647                 ergo(obj->oo_inode != NULL,
 648                      obj->oo_inode->i_sb == osd_sb(osd_obj2dev(obj)) &&
 649                      atomic_read(&obj->oo_inode->i_count) > 0) &&
 650                 ergo(obj->oo_dir != NULL &&
 651                      obj->oo_dir->od_conationer.ic_object != NULL,
 652                      obj->oo_dir->od_conationer.ic_object == obj->oo_inode);
 653 }
 654 #else
 655 #define osd_invariant(obj) (1)
 656 #endif
 657
 658 extern const struct dt_index_operations osd_otable_ops;
 659
 660 static inline int osd_oi_fid2idx(struct osd_device *dev,
 661                                  const struct lu_fid *fid)
 662 {
 663         return fid->f_seq & (dev->od_oi_count - 1);
 664 }
 665
 666 static inline struct osd_oi *osd_fid2oi(struct osd_device *osd,
 667                                         const struct lu_fid *fid)
 668 {
 669         LASSERTF(!fid_is_idif(fid), DFID"\n", PFID(fid));
 670         LASSERTF(!fid_is_igif(fid), DFID"\n", PFID(fid));
 671         LASSERT(osd->od_oi_table != NULL && osd->od_oi_count >= 1);
 672         /* It can work even od_oi_count equals to 1 although it's unexpected,
 673          * the only reason we set it to 1 is for performance measurement */
 674         return osd->od_oi_table[osd_oi_fid2idx(osd, fid)];
 675 }
 676
 677 extern const struct lu_device_operations  osd_lu_ops;
 678
 679 static inline int lu_device_is_osd(const struct lu_device *d)
 680 {
 681         return ergo(d != NULL && d->ld_ops != NULL, d->ld_ops == &osd_lu_ops);
 682 }
 683
 684 static inline struct osd_device *osd_dt_dev(const struct dt_device *d)
 685 {
 686         LASSERT(lu_device_is_osd(&d->dd_lu_dev));
 687         return container_of0(d, struct osd_device, od_dt_dev);
 688 }
 689
 690 static inline struct osd_device *osd_dev(const struct lu_device *d)
 691 {
 692         LASSERT(lu_device_is_osd(d));
 693         return osd_dt_dev(container_of0(d, struct dt_device, dd_lu_dev));
 694 }
 695
 696 static inline struct osd_device *osd_obj2dev(const struct osd_object *o)
 697 {
 698         return osd_dev(o->oo_dt.do_lu.lo_dev);
 699 }
 700
 701 static inline struct super_block *osd_sb(const struct osd_device *dev)
 702 {
 703         return dev->od_mount->lmi_mnt->mnt_sb;
 704 }
 705
 706 static inline int osd_object_is_root(const struct osd_object *obj)
 707 {
 708         return osd_sb(osd_obj2dev(obj))->s_root->d_inode == obj->oo_inode;
 709 }
 710
 711 static inline struct osd_object *osd_obj(const struct lu_object *o)
 712 {
 713         LASSERT(lu_device_is_osd(o->lo_dev));
 714         return container_of0(o, struct osd_object, oo_dt.do_lu);
 715 }
 716
 717 static inline struct osd_object *osd_dt_obj(const struct dt_object *d)
 718 {
 719         return osd_obj(&d->do_lu);
 720 }
 721
 722 static inline struct lu_device *osd2lu_dev(struct osd_device *osd)
 723 {
 724         return &osd->od_dt_dev.dd_lu_dev;
 725 }
 726
 727 static inline journal_t *osd_journal(const struct osd_device *dev)
 728 {
 729         return LDISKFS_SB(osd_sb(dev))->s_journal;
 730 }
 731
 732 extern const struct dt_body_operations osd_body_ops;
 733 extern struct lu_context_key osd_key;
 734
 735 static inline struct osd_thread_info *osd_oti_get(const struct lu_env *env)
 736 {
 737         return lu_context_key_get(&env->le_ctx, &osd_key);
 738 }
 739
 740 extern const struct dt_body_operations osd_body_ops_new;
 741
 742 /**
 743  * IAM Iterator
 744  */
 745 static inline
 746 struct iam_path_descr *osd_it_ipd_get(const struct lu_env *env,
 747                                       const struct iam_container *bag)
 748 {
 749         return bag->ic_descr->id_ops->id_ipd_alloc(bag,
 750                                            osd_oti_get(env)->oti_it_ipd);
 751 }
 752
 753 static inline
 754 struct iam_path_descr *osd_idx_ipd_get(const struct lu_env *env,
 755                                        const struct iam_container *bag)
 756 {
 757         return bag->ic_descr->id_ops->id_ipd_alloc(bag,
 758                                            osd_oti_get(env)->oti_idx_ipd);
 759 }
 760
 761 static inline void osd_ipd_put(const struct lu_env *env,
 762                                const struct iam_container *bag,
 763                                struct iam_path_descr *ipd)
 764 {
 765         bag->ic_descr->id_ops->id_ipd_free(ipd);
 766 }
 767
 768 int osd_ldiskfs_read(struct inode *inode, void *buf, int size, loff_t *offs);
 769 int osd_ldiskfs_write_record(struct inode *inode, void *buf, int bufsize,
 770                              loff_t *offs, handle_t *handle);
 771
 772 static inline
 773 struct dentry *osd_child_dentry_by_inode(const struct lu_env *env,
 774                                          struct inode *inode,
 775                                          const char *name, const int namelen)
 776 {
 777         struct osd_thread_info *info = osd_oti_get(env);
 778         struct dentry *child_dentry = &info->oti_child_dentry;
 779         struct dentry *obj_dentry = &info->oti_obj_dentry;
 780
 781         obj_dentry->d_inode = inode;
 782         obj_dentry->d_sb = inode->i_sb;
 783         obj_dentry->d_name.hash = 0;
 784
 785         child_dentry->d_name.hash = 0;
 786         child_dentry->d_parent = obj_dentry;
 787         child_dentry->d_name.name = name;
 788         child_dentry->d_name.len = namelen;
 789         return child_dentry;
 790 }
 791
 792 /**
 793  * Helper function to pack the fid, ldiskfs stores fid in packed format.
 794  */
 795 static inline
 796 void osd_fid_pack(struct osd_fid_pack *pack, const struct dt_rec *fid,
 797                   struct lu_fid *befider)
 798 {
 799         fid_cpu_to_be(befider, (struct lu_fid *)fid);
 800         memcpy(pack->fp_area, befider, sizeof(*befider));
 801         pack->fp_len =  sizeof(*befider) + 1;
 802 }
 803
 804 static inline
 805 int osd_fid_unpack(struct lu_fid *fid, const struct osd_fid_pack *pack)
 806 {
 807         int result;
 808
 809         result = 0;
 810         switch (pack->fp_len) {
 811         case sizeof *fid + 1:
 812                 memcpy(fid, pack->fp_area, sizeof *fid);
 813                 fid_be_to_cpu(fid, fid);
 814                 break;
 815         default:
 816                 CERROR("Unexpected packed fid size: %d\n", pack->fp_len);
 817                 result = -EIO;
 818         }
 819         return result;
 820 }
 821
 822 #endif /* __KERNEL__ */
 823 #endif /* _OSD_INTERNAL_H */