lustre/osd-ldiskfs/osd_internal.h

   1 /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
   2  * vim:expandtab:shiftwidth=8:tabstop=8:
   3  *
   4  * GPL HEADER START
   5  *
   6  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License version 2 only,
  10  * as published by the Free Software Foundation.
  11  *
  12  * This program is distributed in the hope that it will be useful, but
  13  * WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * General Public License version 2 for more details (a copy is included
  16  * in the LICENSE file that accompanied this code).
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * version 2 along with this program; If not, see
  20  * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
  21  *
  22  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
  23  * CA 95054 USA or visit www.sun.com if you need additional information or
  24  * have any questions.
  25  *
  26  * GPL HEADER END
  27  */
  28 /*
  29  * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
  30  * Use is subject to license terms.
  31  *
  32  * Copyright (c) 2011, 2012, Whamcloud, Inc.
  33  */
  34 /*
  35  * This file is part of Lustre, http://www.lustre.org/
  36  * Lustre is a trademark of Sun Microsystems, Inc.
  37  *
  38  * lustre/osd/osd_internal.h
  39  *
  40  * Shared definitions and declarations for osd module
  41  *
  42  * Author: Nikita Danilov <nikita@clusterfs.com>
  43  */
  44
  45 #ifndef _OSD_INTERNAL_H
  46 #define _OSD_INTERNAL_H
  47
  48 #if defined(__KERNEL__)
  49
  50 /* struct rw_semaphore */
  51 #include <linux/rwsem.h>
  52 /* struct dentry */
  53 #include <linux/dcache.h>
  54 /* struct dirent64 */
  55 #include <linux/dirent.h>
  56
  57 #include <ldiskfs/ldiskfs.h>
  58 #include <ldiskfs/ldiskfs_jbd2.h>
  59 #ifdef HAVE_LDISKFS_JOURNAL_CALLBACK_ADD
  60 # define journal_callback ldiskfs_journal_cb_entry
  61 # define osd_journal_callback_set(handle, func, jcb) \
  62          ldiskfs_journal_callback_add(handle, func, jcb)
  63 #else
  64 # define osd_journal_callback_set(handle, func, jcb) \
  65          jbd2_journal_callback_set(handle, func, jcb)
  66 #endif
  67
  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
  79 struct inode;
  80
  81 #define OSD_OII_NOGEN (0)
  82 #define OSD_COUNTERS (0)
  83
  84 /** Enable thandle usage statistics */
  85 #define OSD_THANDLE_STATS (0)
  86
  87 #ifdef HAVE_QUOTA_SUPPORT
  88 struct osd_ctxt {
  89         __u32 oc_uid;
  90         __u32 oc_gid;
  91         cfs_kernel_cap_t oc_cap;
  92 };
  93 #endif
  94
  95 struct osd_directory {
  96         struct iam_container od_container;
  97         struct iam_descr     od_descr;
  98 };
  99
 100 struct osd_object {
 101         struct dt_object        oo_dt;
 102         /**
 103          * Inode for file system object represented by this osd_object. This
 104          * inode is pinned for the whole duration of lu_object life.
 105          *
 106          * Not modified concurrently (either setup early during object
 107          * creation, or assigned by osd_object_create() under write lock).
 108          */
 109         struct inode           *oo_inode;
 110         /**
 111          * to protect index ops.
 112          */
 113         struct htree_lock_head *oo_hl_head;
 114         cfs_rw_semaphore_t      oo_ext_idx_sem;
 115         cfs_rw_semaphore_t      oo_sem;
 116         struct osd_directory   *oo_dir;
 117         /** protects inode attributes. */
 118         cfs_spinlock_t          oo_guard;
 119         /**
 120          * Following two members are used to indicate the presence of dot and
 121          * dotdot in the given directory. This is required for interop mode
 122          * (b11826).
 123          */
 124         int                     oo_compat_dot_created;
 125         int                     oo_compat_dotdot_created;
 126
 127         const struct lu_env    *oo_owner;
 128 #ifdef CONFIG_LOCKDEP
 129         struct lockdep_map      oo_dep_map;
 130 #endif
 131 };
 132
 133 #ifdef HAVE_LDISKFS_PDO
 134
 135 #define osd_ldiskfs_find_entry(dir, dentry, de, lock)   \
 136         ll_ldiskfs_find_entry(dir, dentry, de, lock)
 137 #define osd_ldiskfs_add_entry(handle, child, cinode, hlock) \
 138         ldiskfs_add_entry(handle, child, cinode, hlock)
 139
 140 #else /* HAVE_LDISKFS_PDO */
 141
 142 struct htree_lock {
 143         int     dummy;
 144 };
 145
 146 struct htree_lock_head {
 147         int     dummy;
 148 };
 149
 150 #define ldiskfs_htree_lock(lock, head, inode, op)  do { LBUG(); } while (0)
 151 #define ldiskfs_htree_unlock(lock)                 do { LBUG(); } while (0)
 152
 153 static inline struct htree_lock_head *ldiskfs_htree_lock_head_alloc(int dep)
 154 {
 155         LBUG();
 156         return NULL;
 157 }
 158
 159 #define ldiskfs_htree_lock_head_free(lh)           do { LBUG(); } while (0)
 160
 161 #define LDISKFS_DUMMY_HTREE_LOCK        0xbabecafe
 162
 163 static inline struct htree_lock *ldiskfs_htree_lock_alloc(void)
 164 {
 165         return (struct htree_lock *)LDISKFS_DUMMY_HTREE_LOCK;
 166 }
 167
 168 static inline void ldiskfs_htree_lock_free(struct htree_lock *lk)
 169 {
 170         LASSERT((unsigned long)lk == LDISKFS_DUMMY_HTREE_LOCK);
 171 }
 172
 173 #define HTREE_HBITS_DEF         0
 174
 175 #define osd_ldiskfs_find_entry(dir, dentry, de, lock)   \
 176         ll_ldiskfs_find_entry(dir, dentry, de)
 177 #define osd_ldiskfs_add_entry(handle, child, cinode, lock) \
 178         ldiskfs_add_entry(handle, child, cinode)
 179
 180 #endif /* HAVE_LDISKFS_PDO */
 181
 182 extern const int osd_dto_credits_noquota[];
 183
 184 /*
 185  * osd device.
 186  */
 187 struct osd_device {
 188         /* super-class */
 189         struct dt_device          od_dt_dev;
 190         /* information about underlying file system */
 191         struct lustre_mount_info *od_mount;
 192         /*
 193          * XXX temporary stuff for object index: directory where every object
 194          * is named by its fid.
 195          */
 196         struct dt_object         *od_obj_area;
 197         /* object index */
 198         struct osd_oi            *od_oi_table;
 199         /* total number of OI containers */
 200         int                       od_oi_count;
 201         /*
 202          * Fid Capability
 203          */
 204         unsigned int              od_fl_capa:1;
 205         unsigned long             od_capa_timeout;
 206         __u32                     od_capa_alg;
 207         struct lustre_capa_key   *od_capa_keys;
 208         cfs_hlist_head_t         *od_capa_hash;
 209
 210         cfs_proc_dir_entry_t     *od_proc_entry;
 211         struct lprocfs_stats     *od_stats;
 212         /*
 213          * statfs optimization: we cache a bit.
 214          */
 215         cfs_time_t                od_osfs_age;
 216         cfs_kstatfs_t             od_kstatfs;
 217         cfs_spinlock_t            od_osfs_lock;
 218
 219         /**
 220          * The following flag indicates, if it is interop mode or not.
 221          * It will be initialized, using mount param.
 222          */
 223         __u32                     od_iop_mode;
 224 };
 225
 226 #define OSD_TRACK_DECLARES
 227 #ifdef OSD_TRACK_DECLARES
 228 #define OSD_DECLARE_OP(oh, op)   {                               \
 229         LASSERT(oh->ot_handle == NULL);                          \
 230         ((oh)->ot_declare_ ##op)++; }
 231 #define OSD_EXEC_OP(handle, op)     {                            \
 232         struct osd_thandle *oh;                                  \
 233         oh = container_of0(handle, struct osd_thandle, ot_super);\
 234         LASSERT((oh)->ot_declare_ ##op > 0);                     \
 235         ((oh)->ot_declare_ ##op)--; }
 236 #else
 237 #define OSD_DECLARE_OP(oh, op)
 238 #define OSD_EXEC_OP(oh, op)
 239 #endif
 240
 241 /* There are at most 10 uid/gids are affected in a transaction, and
 242  * that's rename case:
 243  * - 2 for source parent uid & gid;
 244  * - 2 for source child uid & gid ('..' entry update when the child
 245  *   is directory);
 246  * - 2 for target parent uid & gid;
 247  * - 2 for target child uid & gid (if the target child exists);
 248  * - 2 for root uid & gid (last_rcvd, llog, etc);
 249  *
 250  * The 0 to (OSD_MAX_UGID_CNT - 1) bits of ot_id_type is for indicating
 251  * the id type of each id in the ot_id_array.
 252  */
 253 #define OSD_MAX_UGID_CNT        10
 254
 255 struct osd_thandle {
 256         struct thandle          ot_super;
 257         handle_t               *ot_handle;
 258         struct journal_callback ot_jcb;
 259         cfs_list_t              ot_dcb_list;
 260         /* Link to the device, for debugging. */
 261         struct lu_ref_link     *ot_dev_link;
 262         unsigned short          ot_credits;
 263         unsigned short          ot_id_cnt;
 264         unsigned short          ot_id_type;
 265         uid_t                   ot_id_array[OSD_MAX_UGID_CNT];
 266
 267 #ifdef OSD_TRACK_DECLARES
 268         unsigned char           ot_declare_attr_set;
 269         unsigned char           ot_declare_punch;
 270         unsigned char           ot_declare_xattr_set;
 271         unsigned char           ot_declare_create;
 272         unsigned char           ot_declare_destroy;
 273         unsigned char           ot_declare_ref_add;
 274         unsigned char           ot_declare_ref_del;
 275         unsigned char           ot_declare_write;
 276         unsigned char           ot_declare_insert;
 277         unsigned char           ot_declare_delete;
 278 #endif
 279
 280 #if OSD_THANDLE_STATS
 281         /** time when this handle was allocated */
 282         cfs_time_t oth_alloced;
 283
 284         /** time when this thanle was started */
 285         cfs_time_t oth_started;
 286 #endif
 287 };
 288
 289 /**
 290  * Basic transaction credit op
 291  */
 292 enum dt_txn_op {
 293         DTO_INDEX_INSERT,
 294         DTO_INDEX_DELETE,
 295         DTO_INDEX_UPDATE,
 296         DTO_OBJECT_CREATE,
 297         DTO_OBJECT_DELETE,
 298         DTO_ATTR_SET_BASE,
 299         DTO_XATTR_SET,
 300         DTO_LOG_REC, /**< XXX temporary: dt layer knows nothing about llog. */
 301         DTO_WRITE_BASE,
 302         DTO_WRITE_BLOCK,
 303         DTO_ATTR_SET_CHOWN,
 304
 305         DTO_NR
 306 };
 307
 308 /*
 309  * osd dev stats
 310  */
 311
 312 #ifdef LPROCFS
 313 enum {
 314 #if OSD_THANDLE_STATS
 315         LPROC_OSD_THANDLE_STARTING,
 316         LPROC_OSD_THANDLE_OPEN,
 317         LPROC_OSD_THANDLE_CLOSING,
 318 #endif
 319         LPROC_OSD_NR
 320 };
 321 #endif
 322
 323 /**
 324  * Storage representation for fids.
 325  *
 326  * Variable size, first byte contains the length of the whole record.
 327  */
 328 struct osd_fid_pack {
 329         unsigned char fp_len;
 330         char fp_area[sizeof(struct lu_fid)];
 331 };
 332
 333 struct osd_it_ea_dirent {
 334         struct lu_fid   oied_fid;
 335         __u64           oied_ino;
 336         __u64           oied_off;
 337         unsigned short  oied_namelen;
 338         unsigned int    oied_type;
 339         char            oied_name[0];
 340 } __attribute__((packed));
 341
 342 /**
 343  * as osd_it_ea_dirent (in memory dirent struct for osd) is greater
 344  * than lu_dirent struct. osd readdir reads less number of dirent than
 345  * required for mdd dir page. so buffer size need to be increased so that
 346  * there  would be one ext3 readdir for every mdd readdir page.
 347  */
 348
 349 #define OSD_IT_EA_BUFSIZE       (CFS_PAGE_SIZE + CFS_PAGE_SIZE/4)
 350
 351 /**
 352  * This is iterator's in-memory data structure in interoperability
 353  * mode (i.e. iterator over ldiskfs style directory)
 354  */
 355 struct osd_it_ea {
 356         struct osd_object   *oie_obj;
 357         /** used in ldiskfs iterator, to stored file pointer */
 358         struct file          oie_file;
 359         /** how many entries have been read-cached from storage */
 360         int                  oie_rd_dirent;
 361         /** current entry is being iterated by caller */
 362         int                  oie_it_dirent;
 363         /** current processing entry */
 364         struct osd_it_ea_dirent *oie_dirent;
 365         /** buffer to hold entries, size == OSD_IT_EA_BUFSIZE */
 366         void                *oie_buf;
 367 };
 368
 369 /**
 370  * Iterator's in-memory data structure for IAM mode.
 371  */
 372 struct osd_it_iam {
 373         struct osd_object     *oi_obj;
 374         struct iam_path_descr *oi_ipd;
 375         struct iam_iterator    oi_it;
 376 };
 377
 378 struct osd_thread_info {
 379         const struct lu_env   *oti_env;
 380         /**
 381          * used for index operations.
 382          */
 383         struct dentry          oti_obj_dentry;
 384         struct dentry          oti_child_dentry;
 385
 386         /** dentry for Iterator context. */
 387         struct dentry          oti_it_dentry;
 388         struct htree_lock     *oti_hlock;
 389
 390         struct lu_fid          oti_fid;
 391         struct osd_inode_id    oti_id;
 392         /*
 393          * XXX temporary: for ->i_op calls.
 394          */
 395         struct timespec        oti_time;
 396         /*
 397          * XXX temporary: fake struct file for osd_object_sync
 398          */
 399         struct file            oti_file;
 400         /*
 401          * XXX temporary: for capa operations.
 402          */
 403         struct lustre_capa_key oti_capa_key;
 404         struct lustre_capa     oti_capa;
 405
 406         /** osd_device reference, initialized in osd_trans_start() and
 407             used in osd_trans_stop() */
 408         struct osd_device     *oti_dev;
 409
 410         /**
 411          * following ipd and it structures are used for osd_index_iam_lookup()
 412          * these are defined separately as we might do index operation
 413          * in open iterator session.
 414          */
 415
 416         /** osd iterator context used for iterator session */
 417
 418         union {
 419                 struct osd_it_iam      oti_it;
 420                 /** ldiskfs iterator data structure, see osd_it_ea_{init, fini} */
 421                 struct osd_it_ea       oti_it_ea;
 422         };
 423
 424         /** pre-allocated buffer used by oti_it_ea, size OSD_IT_EA_BUFSIZE */
 425         void                  *oti_it_ea_buf;
 426
 427         /** IAM iterator for index operation. */
 428         struct iam_iterator    oti_idx_it;
 429
 430         /** union to guarantee that ->oti_ipd[] has proper alignment. */
 431         union {
 432                 char           oti_it_ipd[DX_IPD_MAX_SIZE];
 433                 long long      oti_alignment_lieutenant;
 434         };
 435
 436         union {
 437                 char           oti_idx_ipd[DX_IPD_MAX_SIZE];
 438                 long long      oti_alignment_lieutenant_colonel;
 439         };
 440
 441
 442         int                    oti_r_locks;
 443         int                    oti_w_locks;
 444         int                    oti_txns;
 445         /** used in osd_fid_set() to put xattr */
 446         struct lu_buf          oti_buf;
 447         /** used in osd_ea_fid_set() to set fid into common ea */
 448         struct lustre_mdt_attrs oti_mdt_attrs;
 449 #ifdef HAVE_QUOTA_SUPPORT
 450         struct osd_ctxt        oti_ctxt;
 451 #endif
 452         struct lu_env          oti_obj_delete_tx_env;
 453 #define OSD_FID_REC_SZ 32
 454         char                   oti_ldp[OSD_FID_REC_SZ];
 455         char                   oti_ldp2[OSD_FID_REC_SZ];
 456 };
 457
 458 extern int ldiskfs_pdo;
 459
 460 #ifdef LPROCFS
 461 /* osd_lproc.c */
 462 void lprocfs_osd_init_vars(struct lprocfs_static_vars *lvars);
 463 int osd_procfs_init(struct osd_device *osd, const char *name);
 464 int osd_procfs_fini(struct osd_device *osd);
 465 void osd_lprocfs_time_start(const struct lu_env *env);
 466 void osd_lprocfs_time_end(const struct lu_env *env,
 467                           struct osd_device *osd, int op);
 468 #endif
 469 int osd_statfs(const struct lu_env *env, struct dt_device *dev,
 470                cfs_kstatfs_t *sfs);
 471 int osd_object_auth(const struct lu_env *env, struct dt_object *dt,
 472                     struct lustre_capa *capa, __u64 opc);
 473
 474 /*
 475  * Invariants, assertions.
 476  */
 477
 478 /*
 479  * XXX: do not enable this, until invariant checking code is made thread safe
 480  * in the face of pdirops locking.
 481  */
 482 #define OSD_INVARIANT_CHECKS (0)
 483
 484 #if OSD_INVARIANT_CHECKS
 485 static inline int osd_invariant(const struct osd_object *obj)
 486 {
 487         return
 488                 obj != NULL &&
 489                 ergo(obj->oo_inode != NULL,
 490                      obj->oo_inode->i_sb == osd_sb(osd_obj2dev(obj)) &&
 491                      atomic_read(&obj->oo_inode->i_count) > 0) &&
 492                 ergo(obj->oo_dir != NULL &&
 493                      obj->oo_dir->od_conationer.ic_object != NULL,
 494                      obj->oo_dir->od_conationer.ic_object == obj->oo_inode);
 495 }
 496 #else
 497 #define osd_invariant(obj) (1)
 498 #endif
 499
 500 /* The on-disk extN format reserves inodes 0-11 for internal filesystem
 501  * use, and these inodes will be invisible on client side, so the valid
 502  * sequence for IGIF fid is 12-0xffffffff. But root inode (2#) will be seen
 503  * on server side (osd), and it should be valid too here.
 504  */
 505 #define OSD_ROOT_SEQ            2
 506 static inline int osd_fid_is_root(const struct lu_fid *fid)
 507 {
 508         return fid_seq(fid) == OSD_ROOT_SEQ;
 509 }
 510
 511 static inline int osd_fid_is_igif(const struct lu_fid *fid)
 512 {
 513         return fid_is_igif(fid) || osd_fid_is_root(fid);
 514 }
 515
 516 static inline struct osd_oi *
 517 osd_fid2oi(struct osd_device *osd, const struct lu_fid *fid)
 518 {
 519         if (!fid_is_norm(fid))
 520                 return NULL;
 521
 522         LASSERT(osd->od_oi_table != NULL && osd->od_oi_count >= 1);
 523         /* It can work even od_oi_count equals to 1 although it's unexpected,
 524          * the only reason we set it to 1 is for performance measurement */
 525         return &osd->od_oi_table[fid->f_seq & (osd->od_oi_count - 1)];
 526 }
 527
 528 /*
 529  * Helpers.
 530  */
 531 extern const struct lu_device_operations  osd_lu_ops;
 532
 533 static inline int lu_device_is_osd(const struct lu_device *d)
 534 {
 535         return ergo(d != NULL && d->ld_ops != NULL, d->ld_ops == &osd_lu_ops);
 536 }
 537
 538 static inline struct osd_device *osd_dt_dev(const struct dt_device *d)
 539 {
 540         LASSERT(lu_device_is_osd(&d->dd_lu_dev));
 541         return container_of0(d, struct osd_device, od_dt_dev);
 542 }
 543
 544 static inline struct osd_device *osd_dev(const struct lu_device *d)
 545 {
 546         LASSERT(lu_device_is_osd(d));
 547         return osd_dt_dev(container_of0(d, struct dt_device, dd_lu_dev));
 548 }
 549
 550 static inline struct osd_device *osd_obj2dev(const struct osd_object *o)
 551 {
 552         return osd_dev(o->oo_dt.do_lu.lo_dev);
 553 }
 554
 555 static inline struct super_block *osd_sb(const struct osd_device *dev)
 556 {
 557         return dev->od_mount->lmi_mnt->mnt_sb;
 558 }
 559
 560 static inline int osd_object_is_root(const struct osd_object *obj)
 561 {
 562         return osd_sb(osd_obj2dev(obj))->s_root->d_inode == obj->oo_inode;
 563 }
 564
 565 static inline struct osd_object *osd_obj(const struct lu_object *o)
 566 {
 567         LASSERT(lu_device_is_osd(o->lo_dev));
 568         return container_of0(o, struct osd_object, oo_dt.do_lu);
 569 }
 570
 571 static inline struct osd_object *osd_dt_obj(const struct dt_object *d)
 572 {
 573         return osd_obj(&d->do_lu);
 574 }
 575
 576 static inline struct lu_device *osd2lu_dev(struct osd_device *osd)
 577 {
 578         return &osd->od_dt_dev.dd_lu_dev;
 579 }
 580
 581 static inline journal_t *osd_journal(const struct osd_device *dev)
 582 {
 583         return LDISKFS_SB(osd_sb(dev))->s_journal;
 584 }
 585
 586 extern const struct dt_body_operations osd_body_ops;
 587 extern struct lu_context_key osd_key;
 588
 589 static inline struct osd_thread_info *osd_oti_get(const struct lu_env *env)
 590 {
 591         return lu_context_key_get(&env->le_ctx, &osd_key);
 592 }
 593
 594 #endif /* __KERNEL__ */
 595 #endif /* _OSD_INTERNAL_H */