drivers/staging/lustre/lustre/include/obd.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, 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 __OBD_H
  38 #define __OBD_H
  39
  40 #include <linux/obd.h>
  41
  42 #define IOC_OSC_TYPE     'h'
  43 #define IOC_OSC_MIN_NR       20
  44 #define IOC_OSC_SET_ACTIVE   _IOWR(IOC_OSC_TYPE, 21, struct obd_device *)
  45 #define IOC_OSC_MAX_NR       50
  46
  47 #define IOC_MDC_TYPE     'i'
  48 #define IOC_MDC_MIN_NR       20
  49 #define IOC_MDC_MAX_NR       50
  50
  51 #include <lustre/lustre_idl.h>
  52 #include <lu_ref.h>
  53 #include <lustre_lib.h>
  54 #include <lustre_export.h>
  55 #include <lustre_fld.h>
  56 #include <lustre_capa.h>
  57
  58 #include <linux/libcfs/bitmap.h>
  59
  60
  61 #define MAX_OBD_DEVICES 8192
  62
  63 struct osc_async_rc {
  64         int     ar_rc;
  65         int     ar_force_sync;
  66         __u64   ar_min_xid;
  67 };
  68
  69 struct lov_oinfo {               /* per-stripe data structure */
  70         struct ost_id   loi_oi;    /* object ID/Sequence on the target OST */
  71         int loi_ost_idx;           /* OST stripe index in lov_tgt_desc->tgts */
  72         int loi_ost_gen;           /* generation of this loi_ost_idx */
  73
  74         unsigned long loi_kms_valid:1;
  75         __u64 loi_kms;       /* known minimum size */
  76         struct ost_lvb loi_lvb;
  77         struct osc_async_rc     loi_ar;
  78 };
  79
  80 static inline void loi_kms_set(struct lov_oinfo *oinfo, __u64 kms)
  81 {
  82         oinfo->loi_kms = kms;
  83         oinfo->loi_kms_valid = 1;
  84 }
  85
  86 static inline void loi_init(struct lov_oinfo *loi)
  87 {
  88 }
  89
  90 struct lov_stripe_md {
  91         atomic_t     lsm_refc;
  92         spinlock_t      lsm_lock;
  93         pid_t       lsm_lock_owner; /* debugging */
  94
  95         /* maximum possible file size, might change as OSTs status changes,
  96          * e.g. disconnected, deactivated */
  97         __u64       lsm_maxbytes;
  98         struct {
  99                 /* Public members. */
 100                 struct ost_id lw_object_oi; /* lov object id/seq */
 101
 102                 /* LOV-private members start here -- only for use in lov/. */
 103                 __u32 lw_magic;
 104                 __u32 lw_stripe_size;      /* size of the stripe */
 105                 __u32 lw_pattern;         /* striping pattern (RAID0, RAID1) */
 106                 __u16 lw_stripe_count;  /* number of objects being striped over */
 107                 __u16 lw_layout_gen;       /* generation of the layout */
 108                 char  lw_pool_name[LOV_MAXPOOLNAME]; /* pool name */
 109         } lsm_wire;
 110
 111         struct lov_oinfo *lsm_oinfo[0];
 112 };
 113
 114 #define lsm_oi           lsm_wire.lw_object_oi
 115 #define lsm_magic       lsm_wire.lw_magic
 116 #define lsm_layout_gen   lsm_wire.lw_layout_gen
 117 #define lsm_stripe_size  lsm_wire.lw_stripe_size
 118 #define lsm_pattern      lsm_wire.lw_pattern
 119 #define lsm_stripe_count lsm_wire.lw_stripe_count
 120 #define lsm_pool_name    lsm_wire.lw_pool_name
 121
 122 struct obd_info;
 123
 124 typedef int (*obd_enqueue_update_f)(void *cookie, int rc);
 125
 126 /* obd info for a particular level (lov, osc). */
 127 struct obd_info {
 128         /* Lock policy. It keeps an extent which is specific for a particular
 129          * OSC. (e.g. lov_prep_enqueue_set initialises extent of the policy,
 130          * and osc_enqueue passes it into ldlm_lock_match & ldlm_cli_enqueue. */
 131         ldlm_policy_data_t      oi_policy;
 132         /* Flags used for set request specific flags:
 133            - while lock handling, the flags obtained on the enqueue
 134            request are set here.
 135            - while stats, the flags used for control delay/resend.
 136            - while setattr, the flags used for distinguish punch operation
 137          */
 138         __u64              oi_flags;
 139         /* Lock handle specific for every OSC lock. */
 140         struct lustre_handle   *oi_lockh;
 141         /* lsm data specific for every OSC. */
 142         struct lov_stripe_md   *oi_md;
 143         /* obdo data specific for every OSC, if needed at all. */
 144         struct obdo         *oi_oa;
 145         /* statfs data specific for every OSC, if needed at all. */
 146         struct obd_statfs      *oi_osfs;
 147         /* An update callback which is called to update some data on upper
 148          * level. E.g. it is used for update lsm->lsm_oinfo at every recieved
 149          * request in osc level for enqueue requests. It is also possible to
 150          * update some caller data from LOV layer if needed. */
 151         obd_enqueue_update_f    oi_cb_up;
 152         /* oss capability, its type is obd_capa in client to avoid copy.
 153          * in contrary its type is lustre_capa in OSS. */
 154         void               *oi_capa;
 155         /* transfer jobid from ost_sync() to filter_sync()... */
 156         char               *oi_jobid;
 157 };
 158
 159 /* compare all relevant fields. */
 160 static inline int lov_stripe_md_cmp(struct lov_stripe_md *m1,
 161                                     struct lov_stripe_md *m2)
 162 {
 163         /*
 164          * ->lsm_wire contains padding, but it should be zeroed out during
 165          * allocation.
 166          */
 167         return memcmp(&m1->lsm_wire, &m2->lsm_wire, sizeof m1->lsm_wire);
 168 }
 169
 170 static inline int lov_lum_lsm_cmp(struct lov_user_md *lum,
 171                                   struct lov_stripe_md  *lsm)
 172 {
 173         if (lsm->lsm_magic != lum->lmm_magic)
 174                 return 1;
 175         if ((lsm->lsm_stripe_count != 0) && (lum->lmm_stripe_count != 0) &&
 176             (lsm->lsm_stripe_count != lum->lmm_stripe_count))
 177                 return 2;
 178         if ((lsm->lsm_stripe_size != 0) && (lum->lmm_stripe_size != 0) &&
 179             (lsm->lsm_stripe_size != lum->lmm_stripe_size))
 180                 return 3;
 181         if ((lsm->lsm_pattern != 0) && (lum->lmm_pattern != 0) &&
 182             (lsm->lsm_pattern != lum->lmm_pattern))
 183                 return 4;
 184         if ((lsm->lsm_magic == LOV_MAGIC_V3) &&
 185             (strncmp(lsm->lsm_pool_name,
 186                      ((struct lov_user_md_v3 *)lum)->lmm_pool_name,
 187                      LOV_MAXPOOLNAME) != 0))
 188                 return 5;
 189         return 0;
 190 }
 191
 192 static inline int lov_lum_swab_if_needed(struct lov_user_md_v3 *lumv3,
 193                                          int *lmm_magic,
 194                                          struct lov_user_md *lum)
 195 {
 196         if (lum && copy_from_user(lumv3, lum,sizeof(struct lov_user_md_v1)))
 197                 return -EFAULT;
 198
 199         *lmm_magic = lumv3->lmm_magic;
 200
 201         if (*lmm_magic == __swab32(LOV_USER_MAGIC_V1)) {
 202                 lustre_swab_lov_user_md_v1((struct lov_user_md_v1 *)lumv3);
 203                 *lmm_magic = LOV_USER_MAGIC_V1;
 204         } else if (*lmm_magic == LOV_USER_MAGIC_V3) {
 205                 if (lum && copy_from_user(lumv3, lum, sizeof(*lumv3)))
 206                         return -EFAULT;
 207         } else if (*lmm_magic == __swab32(LOV_USER_MAGIC_V3)) {
 208                 if (lum && copy_from_user(lumv3, lum, sizeof(*lumv3)))
 209                         return -EFAULT;
 210                 lustre_swab_lov_user_md_v3(lumv3);
 211                 *lmm_magic = LOV_USER_MAGIC_V3;
 212         } else if (*lmm_magic != LOV_USER_MAGIC_V1) {
 213                 CDEBUG(D_IOCTL,
 214                        "bad userland LOV MAGIC: %#08x != %#08x nor %#08x\n",
 215                        *lmm_magic, LOV_USER_MAGIC_V1, LOV_USER_MAGIC_V3);
 216                        return -EINVAL;
 217         }
 218         return 0;
 219 }
 220
 221 void lov_stripe_lock(struct lov_stripe_md *md);
 222 void lov_stripe_unlock(struct lov_stripe_md *md);
 223
 224 struct obd_type {
 225         struct list_head typ_chain;
 226         struct obd_ops *typ_dt_ops;
 227         struct md_ops *typ_md_ops;
 228         proc_dir_entry_t *typ_procroot;
 229         char *typ_name;
 230         int  typ_refcnt;
 231         struct lu_device_type *typ_lu;
 232         spinlock_t obd_type_lock;
 233 };
 234
 235 struct brw_page {
 236         obd_off  off;
 237         struct page *pg;
 238         int count;
 239         obd_flag flag;
 240 };
 241
 242 /* Individual type definitions */
 243
 244 struct ost_server_data;
 245
 246 struct osd_properties {
 247         size_t osd_max_ea_size;
 248 };
 249
 250 #define OBT_MAGIC       0xBDDECEAE
 251 /* hold common fields for "target" device */
 252 struct obd_device_target {
 253         __u32                obt_magic;
 254         __u32                obt_instance;
 255         struct super_block       *obt_sb;
 256         /** last_rcvd file */
 257         struct file           *obt_rcvd_filp;
 258         __u64                obt_mount_count;
 259         struct rw_semaphore       obt_rwsem;
 260         struct vfsmount   *obt_vfsmnt;
 261         struct file           *obt_health_check_filp;
 262         struct osd_properties     obt_osd_properties;
 263         struct obd_job_stats      obt_jobstats;
 264 };
 265
 266 /* llog contexts */
 267 enum llog_ctxt_id {
 268         LLOG_CONFIG_ORIG_CTXT  =  0,
 269         LLOG_CONFIG_REPL_CTXT,
 270         LLOG_MDS_OST_ORIG_CTXT,
 271         LLOG_MDS_OST_REPL_CTXT,
 272         LLOG_SIZE_ORIG_CTXT,
 273         LLOG_SIZE_REPL_CTXT,
 274         LLOG_RD1_ORIG_CTXT,
 275         LLOG_RD1_REPL_CTXT,
 276         LLOG_TEST_ORIG_CTXT,
 277         LLOG_TEST_REPL_CTXT,
 278         LLOG_LOVEA_ORIG_CTXT,
 279         LLOG_LOVEA_REPL_CTXT,
 280         LLOG_CHANGELOG_ORIG_CTXT,      /**< changelog generation on mdd */
 281         LLOG_CHANGELOG_REPL_CTXT,      /**< changelog access on clients */
 282         LLOG_CHANGELOG_USER_ORIG_CTXT, /**< for multiple changelog consumers */
 283         LLOG_MAX_CTXTS
 284 };
 285
 286 #define FILTER_SUBDIR_COUNT      32         /* set to zero for no subdirs */
 287
 288 struct filter_subdirs {
 289         struct dentry *dentry[FILTER_SUBDIR_COUNT];
 290 };
 291
 292
 293 struct filter_ext {
 294         __u64           fe_start;
 295         __u64           fe_end;
 296 };
 297
 298 struct filter_obd {
 299         /* NB this field MUST be first */
 300         struct obd_device_target fo_obt;
 301         const char              *fo_fstype;
 302
 303         int                     fo_group_count;
 304         struct dentry           *fo_dentry_O;
 305         struct dentry           **fo_dentry_O_groups;
 306         struct filter_subdirs   *fo_dentry_O_sub;
 307         struct mutex            fo_init_lock;   /* group initialization lock*/
 308         int                     fo_committed_group;
 309
 310         spinlock_t              fo_objidlock;   /* protect fo_lastobjid */
 311
 312         unsigned long           fo_destroys_in_progress;
 313         struct mutex            fo_create_locks[FILTER_SUBDIR_COUNT];
 314
 315         struct list_head fo_export_list;
 316         int               fo_subdir_count;
 317
 318         obd_size             fo_tot_dirty;      /* protected by obd_osfs_lock */
 319         obd_size             fo_tot_granted;    /* all values in bytes */
 320         obd_size             fo_tot_pending;
 321         int               fo_tot_granted_clients;
 322
 323         obd_size             fo_readcache_max_filesize;
 324         spinlock_t              fo_flags_lock;
 325         unsigned int     fo_read_cache:1,   /**< enable read-only cache */
 326                              fo_writethrough_cache:1,/**< read cache writes */
 327                              fo_mds_ost_sync:1, /**< MDS-OST orphan recovery*/
 328                              fo_raid_degraded:1;/**< RAID device degraded */
 329
 330         struct obd_import   *fo_mdc_imp;
 331         struct obd_uuid      fo_mdc_uuid;
 332         struct lustre_handle fo_mdc_conn;
 333         struct file     **fo_last_objid_files;
 334         __u64          *fo_last_objids; /* last created objid for groups,
 335                                               * protected by fo_objidlock */
 336
 337         struct mutex            fo_alloc_lock;
 338
 339         atomic_t         fo_r_in_flight;
 340         atomic_t         fo_w_in_flight;
 341
 342         /*
 343          * per-filter pool of kiobuf's allocated by filter_common_setup() and
 344          * torn down by filter_cleanup().
 345          *
 346          * This pool contains kiobuf used by
 347          * filter_{prep,commit}rw_{read,write}() and is shared by all OST
 348          * threads.
 349          *
 350          * Locking: protected by internal lock of cfs_hash, pool can be
 351          * found from this hash table by t_id of ptlrpc_thread.
 352          */
 353         struct cfs_hash         *fo_iobuf_hash;
 354
 355         struct brw_stats         fo_filter_stats;
 356
 357         int                   fo_fmd_max_num; /* per exp filter_mod_data */
 358         int                   fo_fmd_max_age; /* jiffies to fmd expiry */
 359         unsigned long       fo_syncjournal:1, /* sync journal on writes */
 360                                  fo_sync_lock_cancel:2;/* sync on lock cancel */
 361
 362
 363         /* sptlrpc stuff */
 364         rwlock_t                fo_sptlrpc_lock;
 365         struct sptlrpc_rule_set  fo_sptlrpc_rset;
 366
 367         /* capability related */
 368         unsigned int         fo_fl_oss_capa;
 369         struct list_head               fo_capa_keys;
 370         struct hlist_head       *fo_capa_hash;
 371         int                   fo_sec_level;
 372 };
 373
 374 struct timeout_item {
 375         enum timeout_event ti_event;
 376         cfs_time_t       ti_timeout;
 377         timeout_cb_t       ti_cb;
 378         void          *ti_cb_data;
 379         struct list_head         ti_obd_list;
 380         struct list_head         ti_chain;
 381 };
 382
 383 #define OSC_MAX_RIF_DEFAULT       8
 384 #define MDS_OSC_MAX_RIF_DEFAULT   50
 385 #define OSC_MAX_RIF_MAX  256
 386 #define OSC_MAX_DIRTY_DEFAULT  (OSC_MAX_RIF_DEFAULT * 4)
 387 #define OSC_MAX_DIRTY_MB_MAX   2048     /* arbitrary, but < MAX_LONG bytes */
 388 #define OSC_DEFAULT_RESENDS      10
 389
 390 /* possible values for fo_sync_lock_cancel */
 391 enum {
 392         NEVER_SYNC_ON_CANCEL = 0,
 393         BLOCKING_SYNC_ON_CANCEL = 1,
 394         ALWAYS_SYNC_ON_CANCEL = 2,
 395         NUM_SYNC_ON_CANCEL_STATES
 396 };
 397
 398 #define MDC_MAX_RIF_DEFAULT       8
 399 #define MDC_MAX_RIF_MAX  512
 400
 401 struct mdc_rpc_lock;
 402 struct obd_import;
 403 struct client_obd {
 404         struct rw_semaphore  cl_sem;
 405         struct obd_uuid   cl_target_uuid;
 406         struct obd_import       *cl_import; /* ptlrpc connection state */
 407         int                   cl_conn_count;
 408         /* max_mds_easize is purely a performance thing so we don't have to
 409          * call obd_size_diskmd() all the time. */
 410         int                   cl_default_mds_easize;
 411         int                   cl_max_mds_easize;
 412         int                   cl_max_mds_cookiesize;
 413
 414         enum lustre_sec_part     cl_sp_me;
 415         enum lustre_sec_part     cl_sp_to;
 416         struct sptlrpc_flavor    cl_flvr_mgc;   /* fixed flavor of mgc->mgs */
 417
 418         /* the grant values are protected by loi_list_lock below */
 419         long                 cl_dirty;   /* all _dirty_ in bytes */
 420         long                 cl_dirty_max;     /* allowed w/o rpc */
 421         long                 cl_dirty_transit; /* dirty synchronous */
 422         long                 cl_avail_grant;   /* bytes of credit for ost */
 423         long                 cl_lost_grant;    /* lost credits (trunc) */
 424
 425         /* since we allocate grant by blocks, we don't know how many grant will
 426          * be used to add a page into cache. As a solution, we reserve maximum
 427          * grant before trying to dirty a page and unreserve the rest.
 428          * See osc_{reserve|unreserve}_grant for details. */
 429         long             cl_reserved_grant;
 430         struct list_head           cl_cache_waiters; /* waiting for cache/grant */
 431         cfs_time_t         cl_next_shrink_grant;   /* jiffies */
 432         struct list_head           cl_grant_shrink_list;  /* Timeout event list */
 433         int               cl_grant_shrink_interval; /* seconds */
 434
 435         /* A chunk is an optimal size used by osc_extent to determine
 436          * the extent size. A chunk is max(PAGE_CACHE_SIZE, OST block size) */
 437         int               cl_chunkbits;
 438         int               cl_chunk;
 439         int               cl_extent_tax; /* extent overhead, by bytes */
 440
 441         /* keep track of objects that have lois that contain pages which
 442          * have been queued for async brw.  this lock also protects the
 443          * lists of osc_client_pages that hang off of the loi */
 444         /*
 445          * ->cl_loi_list_lock protects consistency of
 446          * ->cl_loi_{ready,read,write}_list. ->ap_make_ready() and
 447          * ->ap_completion() call-backs are executed under this lock. As we
 448          * cannot guarantee that these call-backs never block on all platforms
 449          * (as a matter of fact they do block on Mac OS X), type of
 450          * ->cl_loi_list_lock is platform dependent: it's a spin-lock on Linux
 451          * and blocking mutex on Mac OS X. (Alternative is to make this lock
 452          * blocking everywhere, but we don't want to slow down fast-path of
 453          * our main platform.)
 454          *
 455          * Exact type of ->cl_loi_list_lock is defined in arch/obd.h together
 456          * with client_obd_list_{un,}lock() and
 457          * client_obd_list_lock_{init,done}() functions.
 458          *
 459          * NB by Jinshan: though field names are still _loi_, but actually
 460          * osc_object{}s are in the list.
 461          */
 462         client_obd_lock_t       cl_loi_list_lock;
 463         struct list_head               cl_loi_ready_list;
 464         struct list_head               cl_loi_hp_ready_list;
 465         struct list_head               cl_loi_write_list;
 466         struct list_head               cl_loi_read_list;
 467         int                   cl_r_in_flight;
 468         int                   cl_w_in_flight;
 469         /* just a sum of the loi/lop pending numbers to be exported by /proc */
 470         atomic_t             cl_pending_w_pages;
 471         atomic_t             cl_pending_r_pages;
 472         __u32                    cl_max_pages_per_rpc;
 473         int                   cl_max_rpcs_in_flight;
 474         struct obd_histogram     cl_read_rpc_hist;
 475         struct obd_histogram     cl_write_rpc_hist;
 476         struct obd_histogram     cl_read_page_hist;
 477         struct obd_histogram     cl_write_page_hist;
 478         struct obd_histogram     cl_read_offset_hist;
 479         struct obd_histogram     cl_write_offset_hist;
 480
 481         /* lru for osc caching pages */
 482         struct cl_client_cache  *cl_cache;
 483         struct list_head                 cl_lru_osc; /* member of cl_cache->ccc_lru */
 484         atomic_t                *cl_lru_left;
 485         atomic_t                 cl_lru_busy;
 486         atomic_t                 cl_lru_shrinkers;
 487         atomic_t                 cl_lru_in_list;
 488         struct list_head                 cl_lru_list; /* lru page list */
 489         client_obd_lock_t        cl_lru_list_lock; /* page list protector */
 490
 491         /* number of in flight destroy rpcs is limited to max_rpcs_in_flight */
 492         atomic_t             cl_destroy_in_flight;
 493         wait_queue_head_t             cl_destroy_waitq;
 494
 495         struct mdc_rpc_lock     *cl_rpc_lock;
 496         struct mdc_rpc_lock     *cl_close_lock;
 497
 498         /* mgc datastruct */
 499         struct semaphore         cl_mgc_sem;
 500         struct vfsmount  *cl_mgc_vfsmnt;
 501         struct dentry      *cl_mgc_configs_dir;
 502         atomic_t             cl_mgc_refcount;
 503         struct obd_export       *cl_mgc_mgsexp;
 504
 505         /* checksumming for data sent over the network */
 506         unsigned int         cl_checksum:1; /* 0 = disabled, 1 = enabled */
 507         /* supported checksum types that are worked out at connect time */
 508         __u32               cl_supp_cksum_types;
 509         /* checksum algorithm to be used */
 510         cksum_type_t         cl_cksum_type;
 511
 512         /* also protected by the poorly named _loi_list_lock lock above */
 513         struct osc_async_rc      cl_ar;
 514
 515         /* used by quotacheck when the servers are older than 2.4 */
 516         int                   cl_qchk_stat; /* quotacheck stat of the peer */
 517 #define CL_NOT_QUOTACHECKED 1   /* client->cl_qchk_stat init value */
 518 #if LUSTRE_VERSION_CODE >= OBD_OCD_VERSION(2, 7, 50, 0)
 519 #warning "please consider removing quotacheck compatibility code"
 520 #endif
 521
 522         /* sequence manager */
 523         struct lu_client_seq    *cl_seq;
 524
 525         atomic_t             cl_resends; /* resend count */
 526
 527         /* ptlrpc work for writeback in ptlrpcd context */
 528         void                *cl_writeback_work;
 529         /* hash tables for osc_quota_info */
 530         cfs_hash_t            *cl_quota_hash[MAXQUOTAS];
 531 };
 532 #define obd2cli_tgt(obd) ((char *)(obd)->u.cli.cl_target_uuid.uuid)
 533
 534 struct obd_id_info {
 535         __u32   idx;
 536         obd_id  *data;
 537 };
 538
 539 /* */
 540
 541 struct echo_obd {
 542         struct obd_device_target eo_obt;
 543         struct obdo             eo_oa;
 544         spinlock_t               eo_lock;
 545         __u64                    eo_lastino;
 546         struct lustre_handle    eo_nl_lock;
 547         atomic_t                eo_prep;
 548 };
 549
 550 struct ost_obd {
 551         struct ptlrpc_service   *ost_service;
 552         struct ptlrpc_service   *ost_create_service;
 553         struct ptlrpc_service   *ost_io_service;
 554         struct ptlrpc_service   *ost_seq_service;
 555         struct mutex            ost_health_mutex;
 556 };
 557
 558 struct echo_client_obd {
 559         struct obd_export       *ec_exp;   /* the local connection to osc/lov */
 560         spinlock_t              ec_lock;
 561         struct list_head           ec_objects;
 562         struct list_head           ec_locks;
 563         int               ec_nstripes;
 564         __u64           ec_unique;
 565 };
 566
 567 struct lov_qos_oss {
 568         struct obd_uuid     lqo_uuid;       /* ptlrpc's c_remote_uuid */
 569         struct list_head          lqo_oss_list;   /* link to lov_qos */
 570         __u64          lqo_bavail;     /* total bytes avail on OSS */
 571         __u64          lqo_penalty;    /* current penalty */
 572         __u64          lqo_penalty_per_obj;/* penalty decrease every obj*/
 573         time_t        lqo_used;       /* last used time, seconds */
 574         __u32          lqo_ost_count;  /* number of osts on this oss */
 575 };
 576
 577 struct ltd_qos {
 578         struct lov_qos_oss *ltq_oss;     /* oss info */
 579         __u64          ltq_penalty;     /* current penalty */
 580         __u64          ltq_penalty_per_obj; /* penalty decrease every obj*/
 581         __u64          ltq_weight;      /* net weighting */
 582         time_t        ltq_used; /* last used time, seconds */
 583         unsigned int    ltq_usable:1;    /* usable for striping */
 584 };
 585
 586 /* Generic subset of OSTs */
 587 struct ost_pool {
 588         __u32         *op_array;      /* array of index of
 589                                                    lov_obd->lov_tgts */
 590         unsigned int    op_count;      /* number of OSTs in the array */
 591         unsigned int    op_size;       /* allocated size of lp_array */
 592         struct rw_semaphore op_rw_sem;     /* to protect ost_pool use */
 593 };
 594
 595 /* Round-robin allocator data */
 596 struct lov_qos_rr {
 597         __u32          lqr_start_idx;   /* start index of new inode */
 598         __u32          lqr_offset_idx;  /* aliasing for start_idx  */
 599         int              lqr_start_count; /* reseed counter */
 600         struct ost_pool     lqr_pool;   /* round-robin optimized list */
 601         unsigned long       lqr_dirty:1;     /* recalc round-robin list */
 602 };
 603
 604 /* allow statfs data caching for 1 second */
 605 #define OBD_STATFS_CACHE_SECONDS 1
 606
 607 struct lov_statfs_data {
 608         struct obd_info   lsd_oi;
 609         struct obd_statfs lsd_statfs;
 610 };
 611 /* Stripe placement optimization */
 612 struct lov_qos {
 613         struct list_head          lq_oss_list; /* list of OSSs that targets use */
 614         struct rw_semaphore lq_rw_sem;
 615         __u32          lq_active_oss_count;
 616         unsigned int    lq_prio_free;   /* priority for free space */
 617         unsigned int    lq_threshold_rr;/* priority for rr */
 618         struct lov_qos_rr   lq_rr;        /* round robin qos data */
 619         unsigned long       lq_dirty:1,     /* recalc qos data */
 620                             lq_same_space:1,/* the ost's all have approx.
 621                                                the same space avail */
 622                             lq_reset:1,     /* zero current penalties */
 623                             lq_statfs_in_progress:1; /* statfs op in
 624                                                         progress */
 625         /* qos statfs data */
 626         struct lov_statfs_data *lq_statfs_data;
 627         wait_queue_head_t        lq_statfs_waitq; /* waitqueue to notify statfs
 628                                               * requests completion */
 629 };
 630
 631 struct lov_tgt_desc {
 632         struct list_head          ltd_kill;
 633         struct obd_uuid     ltd_uuid;
 634         struct obd_device  *ltd_obd;
 635         struct obd_export  *ltd_exp;
 636         struct ltd_qos      ltd_qos;     /* qos info per target */
 637         __u32          ltd_gen;
 638         __u32          ltd_index;   /* index in lov_obd->tgts */
 639         unsigned long       ltd_active:1,/* is this target up for requests */
 640                             ltd_activate:1,/* should  target be activated */
 641                             ltd_reap:1;  /* should this target be deleted */
 642 };
 643
 644 /* Pool metadata */
 645 #define pool_tgt_size(_p)   _p->pool_obds.op_size
 646 #define pool_tgt_count(_p)  _p->pool_obds.op_count
 647 #define pool_tgt_array(_p)  _p->pool_obds.op_array
 648 #define pool_tgt_rw_sem(_p) _p->pool_obds.op_rw_sem
 649
 650 struct pool_desc {
 651         char              pool_name[LOV_MAXPOOLNAME + 1]; /* name of pool */
 652         struct ost_pool       pool_obds;              /* pool members */
 653         atomic_t          pool_refcount;          /* pool ref. counter */
 654         struct lov_qos_rr     pool_rr;          /* round robin qos */
 655         struct hlist_node      pool_hash;             /* access by poolname */
 656         struct list_head            pool_list;        /* serial access */
 657         proc_dir_entry_t *pool_proc_entry;      /* file in /proc */
 658         struct obd_device    *pool_lobd;              /* obd of the lov/lod to which
 659                                                        * this pool belongs */
 660 };
 661
 662 struct lov_obd {
 663         struct lov_desc  desc;
 664         struct lov_tgt_desc   **lov_tgts;             /* sparse array */
 665         struct ost_pool  lov_packed;        /* all OSTs in a packed
 666                                                           array */
 667         struct mutex            lov_lock;
 668         struct obd_connect_data lov_ocd;
 669         atomic_t            lov_refcount;
 670         __u32              lov_tgt_count;        /* how many OBD's */
 671         __u32              lov_active_tgt_count;  /* how many active */
 672         __u32              lov_death_row;/* tgts scheduled to be deleted */
 673         __u32              lov_tgt_size;   /* size of tgts array */
 674         int                  lov_connects;
 675         int                  lov_pool_count;
 676         cfs_hash_t           *lov_pools_hash_body; /* used for key access */
 677         struct list_head              lov_pool_list; /* used for sequential access */
 678         proc_dir_entry_t   *lov_pool_proc_entry;
 679         enum lustre_sec_part    lov_sp_me;
 680
 681         /* Cached LRU and unstable data from upper layer */
 682         void                   *lov_cache;
 683
 684         struct rw_semaphore     lov_notify_lock;
 685 };
 686
 687 struct lmv_tgt_desc {
 688         struct obd_uuid         ltd_uuid;
 689         struct obd_export       *ltd_exp;
 690         int                     ltd_idx;
 691         struct mutex            ltd_fid_mutex;
 692         unsigned long           ltd_active:1; /* target up for requests */
 693 };
 694
 695 enum placement_policy {
 696         PLACEMENT_CHAR_POLICY   = 0,
 697         PLACEMENT_NID_POLICY    = 1,
 698         PLACEMENT_INVAL_POLICY  = 2,
 699         PLACEMENT_MAX_POLICY
 700 };
 701
 702 typedef enum placement_policy placement_policy_t;
 703
 704 struct lmv_obd {
 705         int                     refcount;
 706         struct lu_client_fld    lmv_fld;
 707         spinlock_t              lmv_lock;
 708         placement_policy_t      lmv_placement;
 709         struct lmv_desc         desc;
 710         struct obd_uuid         cluuid;
 711         struct obd_export       *exp;
 712
 713         struct mutex            init_mutex;
 714         int                     connected;
 715         int                     max_easize;
 716         int                     max_def_easize;
 717         int                     max_cookiesize;
 718         int                     server_timeout;
 719
 720         int                     tgts_size; /* size of tgts array */
 721         struct lmv_tgt_desc     **tgts;
 722
 723         struct obd_connect_data conn_data;
 724 };
 725
 726 struct niobuf_local {
 727         __u64           lnb_file_offset;
 728         __u32           lnb_page_offset;
 729         __u32           len;
 730         __u32           flags;
 731         struct page     *page;
 732         struct dentry   *dentry;
 733         int             lnb_grant_used;
 734         int             rc;
 735 };
 736
 737 #define LUSTRE_FLD_NAME  "fld"
 738 #define LUSTRE_SEQ_NAME  "seq"
 739
 740 #define LUSTRE_MDD_NAME  "mdd"
 741 #define LUSTRE_OSD_LDISKFS_NAME "osd-ldiskfs"
 742 #define LUSTRE_OSD_ZFS_NAME     "osd-zfs"
 743 #define LUSTRE_VVP_NAME  "vvp"
 744 #define LUSTRE_LMV_NAME  "lmv"
 745 #define LUSTRE_SLP_NAME  "slp"
 746 #define LUSTRE_LOD_NAME         "lod"
 747 #define LUSTRE_OSP_NAME         "osp"
 748 #define LUSTRE_LWP_NAME         "lwp"
 749
 750 /* obd device type names */
 751  /* FIXME all the references to LUSTRE_MDS_NAME should be swapped with LUSTRE_MDT_NAME */
 752 #define LUSTRE_MDS_NAME  "mds"
 753 #define LUSTRE_MDT_NAME  "mdt"
 754 #define LUSTRE_MDC_NAME  "mdc"
 755 #define LUSTRE_OSS_NAME  "ost"       /* FIXME change name to oss */
 756 #define LUSTRE_OST_NAME  "obdfilter" /* FIXME change name to ost */
 757 #define LUSTRE_OSC_NAME  "osc"
 758 #define LUSTRE_LOV_NAME  "lov"
 759 #define LUSTRE_MGS_NAME  "mgs"
 760 #define LUSTRE_MGC_NAME  "mgc"
 761
 762 #define LUSTRE_ECHO_NAME        "obdecho"
 763 #define LUSTRE_ECHO_CLIENT_NAME "echo_client"
 764 #define LUSTRE_QMT_NAME  "qmt"
 765
 766 /* Constant obd names (post-rename) */
 767 #define LUSTRE_MDS_OBDNAME "MDS"
 768 #define LUSTRE_OSS_OBDNAME "OSS"
 769 #define LUSTRE_MGS_OBDNAME "MGS"
 770 #define LUSTRE_MGC_OBDNAME "MGC"
 771
 772 static inline int is_osp_on_mdt(char *name)
 773 {
 774         char   *ptr;
 775
 776         ptr = strrchr(name, '-');
 777         if (ptr == NULL) {
 778                 CERROR("%s is not a obdname\n", name);
 779                 return 0;
 780         }
 781
 782         /* 1.8 OSC/OSP name on MDT is fsname-OSTxxxx-osc */
 783         if (strncmp(ptr + 1, "osc", 3) == 0)
 784                 return 1;
 785
 786         if (strncmp(ptr + 1, "MDT", 3) != 0)
 787                 return 0;
 788
 789         while (*(--ptr) != '-' && ptr != name);
 790
 791         if (ptr == name)
 792                 return 0;
 793
 794         if (strncmp(ptr + 1, LUSTRE_OSP_NAME, strlen(LUSTRE_OSP_NAME)) != 0 &&
 795             strncmp(ptr + 1, LUSTRE_OSC_NAME, strlen(LUSTRE_OSC_NAME)) != 0)
 796                 return 0;
 797
 798         return 1;
 799 }
 800
 801 /* Don't conflict with on-wire flags OBD_BRW_WRITE, etc */
 802 #define N_LOCAL_TEMP_PAGE 0x10000000
 803
 804 struct obd_trans_info {
 805         __u64               oti_transno;
 806         __u64               oti_xid;
 807         /* Only used on the server side for tracking acks. */
 808         struct oti_req_ack_lock {
 809                 struct lustre_handle lock;
 810                 __u32           mode;
 811         }                       oti_ack_locks[4];
 812         void                *oti_handle;
 813         struct llog_cookie       oti_onecookie;
 814         struct llog_cookie      *oti_logcookies;
 815         int                   oti_numcookies;
 816         /** synchronous write is needed */
 817         unsigned long            oti_sync_write:1;
 818
 819         /* initial thread handling transaction */
 820         struct ptlrpc_thread *   oti_thread;
 821         __u32               oti_conn_cnt;
 822         /** VBR: versions */
 823         __u64               oti_pre_version;
 824         /** JobID */
 825         char                *oti_jobid;
 826
 827         struct obd_uuid  *oti_ost_uuid;
 828 };
 829
 830 static inline void oti_init(struct obd_trans_info *oti,
 831                             struct ptlrpc_request *req)
 832 {
 833         if (oti == NULL)
 834                 return;
 835         memset(oti, 0, sizeof(*oti));
 836
 837         if (req == NULL)
 838                 return;
 839
 840         oti->oti_xid = req->rq_xid;
 841         /** VBR: take versions from request */
 842         if (req->rq_reqmsg != NULL &&
 843             lustre_msg_get_flags(req->rq_reqmsg) & MSG_REPLAY) {
 844                 __u64 *pre_version = lustre_msg_get_versions(req->rq_reqmsg);
 845                 oti->oti_pre_version = pre_version ? pre_version[0] : 0;
 846                 oti->oti_transno = lustre_msg_get_transno(req->rq_reqmsg);
 847         }
 848
 849         /** called from mds_create_objects */
 850         if (req->rq_repmsg != NULL)
 851                 oti->oti_transno = lustre_msg_get_transno(req->rq_repmsg);
 852         oti->oti_thread = req->rq_svc_thread;
 853         if (req->rq_reqmsg != NULL)
 854                 oti->oti_conn_cnt = lustre_msg_get_conn_cnt(req->rq_reqmsg);
 855 }
 856
 857 static inline void oti_alloc_cookies(struct obd_trans_info *oti,int num_cookies)
 858 {
 859         if (!oti)
 860                 return;
 861
 862         if (num_cookies == 1)
 863                 oti->oti_logcookies = &oti->oti_onecookie;
 864         else
 865                 OBD_ALLOC_LARGE(oti->oti_logcookies,
 866                                 num_cookies * sizeof(oti->oti_onecookie));
 867
 868         oti->oti_numcookies = num_cookies;
 869 }
 870
 871 static inline void oti_free_cookies(struct obd_trans_info *oti)
 872 {
 873         if (!oti || !oti->oti_logcookies)
 874                 return;
 875
 876         if (oti->oti_logcookies == &oti->oti_onecookie)
 877                 LASSERT(oti->oti_numcookies == 1);
 878         else
 879                 OBD_FREE_LARGE(oti->oti_logcookies,
 880                                oti->oti_numcookies*sizeof(oti->oti_onecookie));
 881         oti->oti_logcookies = NULL;
 882         oti->oti_numcookies = 0;
 883 }
 884
 885 /*
 886  * Events signalled through obd_notify() upcall-chain.
 887  */
 888 enum obd_notify_event {
 889         /* target added */
 890         OBD_NOTIFY_CREATE,
 891         /* Device connect start */
 892         OBD_NOTIFY_CONNECT,
 893         /* Device activated */
 894         OBD_NOTIFY_ACTIVE,
 895         /* Device deactivated */
 896         OBD_NOTIFY_INACTIVE,
 897         /* Device disconnected */
 898         OBD_NOTIFY_DISCON,
 899         /* Connect data for import were changed */
 900         OBD_NOTIFY_OCD,
 901         /* Sync request */
 902         OBD_NOTIFY_SYNC_NONBLOCK,
 903         OBD_NOTIFY_SYNC,
 904         /* Configuration event */
 905         OBD_NOTIFY_CONFIG,
 906         /* Administratively deactivate/activate event */
 907         OBD_NOTIFY_DEACTIVATE,
 908         OBD_NOTIFY_ACTIVATE
 909 };
 910
 911 /*
 912  * Data structure used to pass obd_notify()-event to non-obd listeners (llite
 913  * and liblustre being main examples).
 914  */
 915 struct obd_notify_upcall {
 916         int (*onu_upcall)(struct obd_device *host, struct obd_device *watched,
 917                           enum obd_notify_event ev, void *owner, void *data);
 918         /* Opaque datum supplied by upper layer listener */
 919         void *onu_owner;
 920 };
 921
 922 struct target_recovery_data {
 923         svc_handler_t           trd_recovery_handler;
 924         pid_t                   trd_processing_task;
 925         struct completion       trd_starting;
 926         struct completion       trd_finishing;
 927 };
 928
 929 struct obd_llog_group {
 930         int             olg_seq;
 931         struct llog_ctxt  *olg_ctxts[LLOG_MAX_CTXTS];
 932         wait_queue_head_t       olg_waitq;
 933         spinlock_t         olg_lock;
 934         struct mutex       olg_cat_processing;
 935 };
 936
 937 /* corresponds to one of the obd's */
 938 #define OBD_DEVICE_MAGIC        0XAB5CD6EF
 939 #define OBD_DEV_BY_DEVNAME      0xffffd0de
 940
 941 struct obd_device {
 942         struct obd_type *obd_type;
 943         __u32              obd_magic;
 944
 945         /* common and UUID name of this device */
 946         char                obd_name[MAX_OBD_NAME];
 947         struct obd_uuid  obd_uuid;
 948
 949         struct lu_device       *obd_lu_dev;
 950
 951         int                  obd_minor;
 952         /* bitfield modification is protected by obd_dev_lock */
 953         unsigned long obd_attached:1,      /* finished attach */
 954                       obd_set_up:1,     /* finished setup */
 955                       obd_recovering:1,    /* there are recoverable clients */
 956                       obd_abort_recovery:1,/* recovery expired */
 957                       obd_version_recov:1, /* obd uses version checking */
 958                       obd_replayable:1,    /* recovery is enabled; inform clients */
 959                       obd_no_transno:1,    /* no committed-transno notification */
 960                       obd_no_recov:1,      /* fail instead of retry messages */
 961                       obd_stopping:1,      /* started cleanup */
 962                       obd_starting:1,      /* started setup */
 963                       obd_force:1,       /* cleanup with > 0 obd refcount */
 964                       obd_fail:1,         /* cleanup with failover */
 965                       obd_async_recov:1,   /* allow asynchronous orphan cleanup */
 966                       obd_no_conn:1,       /* deny new connections */
 967                       obd_inactive:1,      /* device active/inactive
 968                                            * (for /proc/status only!!) */
 969                       obd_no_ir:1,       /* no imperative recovery. */
 970                       obd_process_conf:1;  /* device is processing mgs config */
 971         /* use separate field as it is set in interrupt to don't mess with
 972          * protection of other bits using _bh lock */
 973         unsigned long obd_recovery_expired:1;
 974         /* uuid-export hash body */
 975         cfs_hash_t           *obd_uuid_hash;
 976         /* nid-export hash body */
 977         cfs_hash_t           *obd_nid_hash;
 978         /* nid stats body */
 979         cfs_hash_t           *obd_nid_stats_hash;
 980         struct list_head              obd_nid_stats;
 981         atomic_t            obd_refcount;
 982         wait_queue_head_t            obd_refcount_waitq;
 983         struct list_head              obd_exports;
 984         struct list_head              obd_unlinked_exports;
 985         struct list_head              obd_delayed_exports;
 986         int                  obd_num_exports;
 987         spinlock_t              obd_nid_lock;
 988         struct ldlm_namespace  *obd_namespace;
 989         struct ptlrpc_client    obd_ldlm_client; /* XXX OST/MDS only */
 990         /* a spinlock is OK for what we do now, may need a semaphore later */
 991         spinlock_t              obd_dev_lock; /* protect OBD bitfield above */
 992         struct mutex            obd_dev_mutex;
 993         __u64                   obd_last_committed;
 994         struct fsfilt_operations *obd_fsops;
 995         spinlock_t              obd_osfs_lock;
 996         struct obd_statfs       obd_osfs;       /* locked by obd_osfs_lock */
 997         __u64                   obd_osfs_age;
 998         struct lvfs_run_ctxt    obd_lvfs_ctxt;
 999         struct obd_llog_group   obd_olg;        /* default llog group */
1000         struct obd_device       *obd_observer;
1001         struct rw_semaphore     obd_observer_link_sem;
1002         struct obd_notify_upcall obd_upcall;
1003         struct obd_export       *obd_self_export;
1004         /* list of exports in LRU order, for ping evictor, with obd_dev_lock */
1005         struct list_head              obd_exports_timed;
1006         time_t            obd_eviction_timer; /* for ping evictor */
1007
1008         int                           obd_max_recoverable_clients;
1009         atomic_t                     obd_connected_clients;
1010         int                           obd_stale_clients;
1011         int                           obd_delayed_clients;
1012         /* this lock protects all recovery list_heads, timer and
1013          * obd_next_recovery_transno value */
1014         spinlock_t                       obd_recovery_task_lock;
1015         __u64                       obd_next_recovery_transno;
1016         int                           obd_replayed_requests;
1017         int                           obd_requests_queued_for_recovery;
1018         wait_queue_head_t                     obd_next_transno_waitq;
1019         /* protected by obd_recovery_task_lock */
1020         timer_list_t                  obd_recovery_timer;
1021         time_t                     obd_recovery_start; /* seconds */
1022         time_t                     obd_recovery_end; /* seconds, for lprocfs_status */
1023         int                           obd_recovery_time_hard;
1024         int                           obd_recovery_timeout;
1025         int                           obd_recovery_ir_factor;
1026
1027         /* new recovery stuff from CMD2 */
1028         struct target_recovery_data      obd_recovery_data;
1029         int                           obd_replayed_locks;
1030         atomic_t                     obd_req_replay_clients;
1031         atomic_t                     obd_lock_replay_clients;
1032         /* all lists are protected by obd_recovery_task_lock */
1033         struct list_head                       obd_req_replay_queue;
1034         struct list_head                       obd_lock_replay_queue;
1035         struct list_head                       obd_final_req_queue;
1036         int                           obd_recovery_stage;
1037
1038         union {
1039                 struct obd_device_target obt;
1040                 struct filter_obd filter;
1041                 struct client_obd cli;
1042                 struct ost_obd ost;
1043                 struct echo_client_obd echo_client;
1044                 struct echo_obd echo;
1045                 struct lov_obd lov;
1046                 struct lmv_obd lmv;
1047         } u;
1048         /* Fields used by LProcFS */
1049         unsigned int       obd_cntr_base;
1050         struct lprocfs_stats  *obd_stats;
1051
1052         unsigned int       md_cntr_base;
1053         struct lprocfs_stats  *md_stats;
1054
1055         proc_dir_entry_t  *obd_proc_entry;
1056         void              *obd_proc_private; /* type private PDEs */
1057         proc_dir_entry_t  *obd_proc_exports_entry;
1058         proc_dir_entry_t  *obd_svc_procroot;
1059         struct lprocfs_stats  *obd_svc_stats;
1060         atomic_t           obd_evict_inprogress;
1061         wait_queue_head_t           obd_evict_inprogress_waitq;
1062         struct list_head             obd_evict_list; /* protected with pet_lock */
1063
1064         /**
1065          * Ldlm pool part. Save last calculated SLV and Limit.
1066          */
1067         rwlock_t                obd_pool_lock;
1068         int                 obd_pool_limit;
1069         __u64             obd_pool_slv;
1070
1071         /**
1072          * A list of outstanding class_incref()'s against this obd. For
1073          * debugging.
1074          */
1075         struct lu_ref     obd_reference;
1076
1077         int                    obd_conn_inprogress;
1078 };
1079
1080 #define OBD_LLOG_FL_SENDNOW     0x0001
1081 #define OBD_LLOG_FL_EXIT        0x0002
1082
1083 enum obd_cleanup_stage {
1084 /* Special case hack for MDS LOVs */
1085         OBD_CLEANUP_EARLY,
1086 /* can be directly mapped to .ldto_device_fini() */
1087         OBD_CLEANUP_EXPORTS,
1088 };
1089
1090 /* get/set_info keys */
1091 #define KEY_ASYNC              "async"
1092 #define KEY_BLOCKSIZE_BITS      "blocksize_bits"
1093 #define KEY_BLOCKSIZE      "blocksize"
1094 #define KEY_CAPA_KEY        "capa_key"
1095 #define KEY_CHANGELOG_CLEAR     "changelog_clear"
1096 #define KEY_FID2PATH        "fid2path"
1097 #define KEY_CHECKSUM        "checksum"
1098 #define KEY_CLEAR_FS        "clear_fs"
1099 #define KEY_CONN_DATA      "conn_data"
1100 #define KEY_EVICT_BY_NID        "evict_by_nid"
1101 #define KEY_FIEMAP            "fiemap"
1102 #define KEY_FLUSH_CTX      "flush_ctx"
1103 #define KEY_GRANT_SHRINK        "grant_shrink"
1104 #define KEY_HSM_COPYTOOL_SEND   "hsm_send"
1105 #define KEY_INIT_RECOV_BACKUP   "init_recov_bk"
1106 #define KEY_INIT_RECOV    "initial_recov"
1107 #define KEY_INTERMDS        "inter_mds"
1108 #define KEY_LAST_ID          "last_id"
1109 #define KEY_LAST_FID            "last_fid"
1110 #define KEY_LOCK_TO_STRIPE      "lock_to_stripe"
1111 #define KEY_LOVDESC          "lovdesc"
1112 #define KEY_LOV_IDX          "lov_idx"
1113 #define KEY_MAX_EASIZE    "max_easize"
1114 #define KEY_MDS_CONN        "mds_conn"
1115 #define KEY_MGSSEC            "mgssec"
1116 #define KEY_NEXT_ID          "next_id"
1117 #define KEY_READ_ONLY      "read-only"
1118 #define KEY_REGISTER_TARGET     "register_target"
1119 #define KEY_SET_FS            "set_fs"
1120 #define KEY_TGT_COUNT      "tgt_count"
1121 /*      KEY_SET_INFO in lustre_idl.h */
1122 #define KEY_SPTLRPC_CONF        "sptlrpc_conf"
1123 #define KEY_CONNECT_FLAG        "connect_flags"
1124 #define KEY_SYNC_LOCK_CANCEL    "sync_lock_cancel"
1125
1126 #define KEY_CACHE_SET           "cache_set"
1127 #define KEY_CACHE_LRU_SHRINK    "cache_lru_shrink"
1128 #define KEY_CHANGELOG_INDEX     "changelog_index"
1129
1130 struct lu_context;
1131
1132 /* /!\ must be coherent with include/linux/namei.h on patched kernel */
1133 #define IT_OPEN     (1 << 0)
1134 #define IT_CREAT    (1 << 1)
1135 #define IT_READDIR  (1 << 2)
1136 #define IT_GETATTR  (1 << 3)
1137 #define IT_LOOKUP   (1 << 4)
1138 #define IT_UNLINK   (1 << 5)
1139 #define IT_TRUNC    (1 << 6)
1140 #define IT_GETXATTR (1 << 7)
1141 #define IT_EXEC     (1 << 8)
1142 #define IT_PIN      (1 << 9)
1143 #define IT_LAYOUT   (1 << 10)
1144 #define IT_QUOTA_DQACQ (1 << 11)
1145 #define IT_QUOTA_CONN  (1 << 12)
1146
1147 static inline int it_to_lock_mode(struct lookup_intent *it)
1148 {
1149         /* CREAT needs to be tested before open (both could be set) */
1150         if (it->it_op & IT_CREAT)
1151                 return LCK_CW;
1152         else if (it->it_op & (IT_READDIR | IT_GETATTR | IT_OPEN | IT_LOOKUP |
1153                               IT_LAYOUT))
1154                 return LCK_CR;
1155
1156         LASSERTF(0, "Invalid it_op: %d\n", it->it_op);
1157         return -EINVAL;
1158 }
1159
1160 struct md_op_data {
1161         struct lu_fid      op_fid1; /* operation fid1 (usualy parent) */
1162         struct lu_fid      op_fid2; /* operation fid2 (usualy child) */
1163         struct lu_fid      op_fid3; /* 2 extra fids to find conflicting */
1164         struct lu_fid      op_fid4; /* to the operation locks. */
1165         mdsno_t          op_mds;  /* what mds server open will go to */
1166         struct lustre_handle    op_handle;
1167         obd_time                op_mod_time;
1168         const char           *op_name;
1169         int                  op_namelen;
1170         __u32              op_mode;
1171         struct lmv_stripe_md   *op_mea1;
1172         struct lmv_stripe_md   *op_mea2;
1173         __u32              op_suppgids[2];
1174         __u32              op_fsuid;
1175         __u32              op_fsgid;
1176         cfs_cap_t              op_cap;
1177         void               *op_data;
1178
1179         /* iattr fields and blocks. */
1180         struct iattr        op_attr;
1181         unsigned int        op_attr_flags;
1182         __u64              op_valid;
1183         loff_t            op_attr_blocks;
1184
1185         /* Size-on-MDS epoch and flags. */
1186         __u64              op_ioepoch;
1187         __u32              op_flags;
1188
1189         /* Capa fields */
1190         struct obd_capa *op_capa1;
1191         struct obd_capa *op_capa2;
1192
1193         /* Various operation flags. */
1194         __u32              op_bias;
1195
1196         /* Operation type */
1197         __u32              op_opc;
1198
1199         /* Used by readdir */
1200         __u64              op_offset;
1201
1202         /* Used by readdir */
1203         __u32              op_npages;
1204
1205         /* used to transfer info between the stacks of MD client
1206          * see enum op_cli_flags */
1207         __u32                   op_cli_flags;
1208 };
1209
1210 enum op_cli_flags {
1211         CLI_SET_MEA     = 1 << 0,
1212         CLI_RM_ENTRY    = 1 << 1,
1213 };
1214
1215 struct md_enqueue_info;
1216 /* metadata stat-ahead */
1217 typedef int (* md_enqueue_cb_t)(struct ptlrpc_request *req,
1218                                 struct md_enqueue_info *minfo,
1219                                 int rc);
1220
1221 /* seq client type */
1222 enum lu_cli_type {
1223         LUSTRE_SEQ_METADATA = 1,
1224         LUSTRE_SEQ_DATA
1225 };
1226
1227 struct md_enqueue_info {
1228         struct md_op_data       mi_data;
1229         struct lookup_intent    mi_it;
1230         struct lustre_handle    mi_lockh;
1231         struct inode       *mi_dir;
1232         md_enqueue_cb_t  mi_cb;
1233         __u64              mi_cbdata;
1234         unsigned int        mi_generation;
1235 };
1236
1237 struct obd_ops {
1238         module_t *o_owner;
1239         int (*o_iocontrol)(unsigned int cmd, struct obd_export *exp, int len,
1240                            void *karg, void *uarg);
1241         int (*o_get_info)(const struct lu_env *env, struct obd_export *,
1242                           __u32 keylen, void *key, __u32 *vallen, void *val,
1243                           struct lov_stripe_md *lsm);
1244         int (*o_set_info_async)(const struct lu_env *, struct obd_export *,
1245                                 __u32 keylen, void *key,
1246                                 __u32 vallen, void *val,
1247                                 struct ptlrpc_request_set *set);
1248         int (*o_attach)(struct obd_device *dev, obd_count len, void *data);
1249         int (*o_detach)(struct obd_device *dev);
1250         int (*o_setup) (struct obd_device *dev, struct lustre_cfg *cfg);
1251         int (*o_precleanup)(struct obd_device *dev,
1252                             enum obd_cleanup_stage cleanup_stage);
1253         int (*o_cleanup)(struct obd_device *dev);
1254         int (*o_process_config)(struct obd_device *dev, obd_count len,
1255                                 void *data);
1256         int (*o_postrecov)(struct obd_device *dev);
1257         int (*o_add_conn)(struct obd_import *imp, struct obd_uuid *uuid,
1258                           int priority);
1259         int (*o_del_conn)(struct obd_import *imp, struct obd_uuid *uuid);
1260         /* connect to the target device with given connection
1261          * data. @ocd->ocd_connect_flags is modified to reflect flags actually
1262          * granted by the target, which are guaranteed to be a subset of flags
1263          * asked for. If @ocd == NULL, use default parameters. */
1264         int (*o_connect)(const struct lu_env *env,
1265                          struct obd_export **exp, struct obd_device *src,
1266                          struct obd_uuid *cluuid, struct obd_connect_data *ocd,
1267                          void *localdata);
1268         int (*o_reconnect)(const struct lu_env *env,
1269                            struct obd_export *exp, struct obd_device *src,
1270                            struct obd_uuid *cluuid,
1271                            struct obd_connect_data *ocd,
1272                            void *localdata);
1273         int (*o_disconnect)(struct obd_export *exp);
1274
1275         /* Initialize/finalize fids infrastructure. */
1276         int (*o_fid_init)(struct obd_device *obd,
1277                           struct obd_export *exp, enum lu_cli_type type);
1278         int (*o_fid_fini)(struct obd_device *obd);
1279
1280         /* Allocate new fid according to passed @hint. */
1281         int (*o_fid_alloc)(struct obd_export *exp, struct lu_fid *fid,
1282                            struct md_op_data *op_data);
1283
1284         /*
1285          * Object with @fid is getting deleted, we may want to do something
1286          * about this.
1287          */
1288         int (*o_statfs)(const struct lu_env *, struct obd_export *exp,
1289                         struct obd_statfs *osfs, __u64 max_age, __u32 flags);
1290         int (*o_statfs_async)(struct obd_export *exp, struct obd_info *oinfo,
1291                               __u64 max_age, struct ptlrpc_request_set *set);
1292         int (*o_packmd)(struct obd_export *exp, struct lov_mds_md **disk_tgt,
1293                         struct lov_stripe_md *mem_src);
1294         int (*o_unpackmd)(struct obd_export *exp,struct lov_stripe_md **mem_tgt,
1295                           struct lov_mds_md *disk_src, int disk_len);
1296         int (*o_preallocate)(struct lustre_handle *, obd_count *req,
1297                              obd_id *ids);
1298         /* FIXME: add fid capability support for create & destroy! */
1299         int (*o_precreate)(struct obd_export *exp);
1300         int (*o_create)(const struct lu_env *env, struct obd_export *exp,
1301                         struct obdo *oa, struct lov_stripe_md **ea,
1302                         struct obd_trans_info *oti);
1303         int (*o_create_async)(struct obd_export *exp,  struct obd_info *oinfo,
1304                               struct lov_stripe_md **ea,
1305                               struct obd_trans_info *oti);
1306         int (*o_destroy)(const struct lu_env *env, struct obd_export *exp,
1307                          struct obdo *oa, struct lov_stripe_md *ea,
1308                          struct obd_trans_info *oti, struct obd_export *md_exp,
1309                          void *capa);
1310         int (*o_setattr)(const struct lu_env *, struct obd_export *exp,
1311                          struct obd_info *oinfo, struct obd_trans_info *oti);
1312         int (*o_setattr_async)(struct obd_export *exp, struct obd_info *oinfo,
1313                                struct obd_trans_info *oti,
1314                                struct ptlrpc_request_set *rqset);
1315         int (*o_getattr)(const struct lu_env *env, struct obd_export *exp,
1316                          struct obd_info *oinfo);
1317         int (*o_getattr_async)(struct obd_export *exp, struct obd_info *oinfo,
1318                                struct ptlrpc_request_set *set);
1319         int (*o_brw)(int rw, struct obd_export *exp, struct obd_info *oinfo,
1320                      obd_count oa_bufs, struct brw_page *pgarr,
1321                      struct obd_trans_info *oti);
1322         int (*o_merge_lvb)(struct obd_export *exp, struct lov_stripe_md *lsm,
1323                            struct ost_lvb *lvb, int kms_only);
1324         int (*o_adjust_kms)(struct obd_export *exp, struct lov_stripe_md *lsm,
1325                             obd_off size, int shrink);
1326         int (*o_punch)(const struct lu_env *, struct obd_export *exp,
1327                        struct obd_info *oinfo, struct obd_trans_info *oti,
1328                        struct ptlrpc_request_set *rqset);
1329         int (*o_sync)(const struct lu_env *env, struct obd_export *exp,
1330                       struct obd_info *oinfo, obd_size start, obd_size end,
1331                       struct ptlrpc_request_set *set);
1332         int (*o_migrate)(struct lustre_handle *conn, struct lov_stripe_md *dst,
1333                          struct lov_stripe_md *src, obd_size start,
1334                          obd_size end, struct obd_trans_info *oti);
1335         int (*o_copy)(struct lustre_handle *dstconn, struct lov_stripe_md *dst,
1336                       struct lustre_handle *srconn, struct lov_stripe_md *src,
1337                       obd_size start, obd_size end, struct obd_trans_info *);
1338         int (*o_iterate)(struct lustre_handle *conn,
1339                          int (*)(obd_id, obd_seq, void *),
1340                          obd_id *startid, obd_seq seq, void *data);
1341         int (*o_preprw)(const struct lu_env *env, int cmd,
1342                         struct obd_export *exp, struct obdo *oa, int objcount,
1343                         struct obd_ioobj *obj, struct niobuf_remote *remote,
1344                         int *nr_pages, struct niobuf_local *local,
1345                         struct obd_trans_info *oti, struct lustre_capa *capa);
1346         int (*o_commitrw)(const struct lu_env *env, int cmd,
1347                           struct obd_export *exp, struct obdo *oa,
1348                           int objcount, struct obd_ioobj *obj,
1349                           struct niobuf_remote *remote, int pages,
1350                           struct niobuf_local *local,
1351                           struct obd_trans_info *oti, int rc);
1352         int (*o_enqueue)(struct obd_export *, struct obd_info *oinfo,
1353                          struct ldlm_enqueue_info *einfo,
1354                          struct ptlrpc_request_set *rqset);
1355         int (*o_change_cbdata)(struct obd_export *, struct lov_stripe_md *,
1356                                ldlm_iterator_t it, void *data);
1357         int (*o_find_cbdata)(struct obd_export *, struct lov_stripe_md *,
1358                              ldlm_iterator_t it, void *data);
1359         int (*o_cancel)(struct obd_export *, struct lov_stripe_md *md,
1360                         __u32 mode, struct lustre_handle *);
1361         int (*o_cancel_unused)(struct obd_export *, struct lov_stripe_md *,
1362                                ldlm_cancel_flags_t flags, void *opaque);
1363         int (*o_init_export)(struct obd_export *exp);
1364         int (*o_destroy_export)(struct obd_export *exp);
1365         int (*o_extent_calc)(struct obd_export *, struct lov_stripe_md *,
1366                              int cmd, obd_off *);
1367
1368         /* llog related obd_methods */
1369         int (*o_llog_init)(struct obd_device *obd, struct obd_llog_group *grp,
1370                            struct obd_device *disk_obd, int *idx);
1371         int (*o_llog_finish)(struct obd_device *obd, int count);
1372         int (*o_llog_connect)(struct obd_export *, struct llogd_conn_body *);
1373
1374         /* metadata-only methods */
1375         int (*o_pin)(struct obd_export *, const struct lu_fid *fid,
1376                      struct obd_capa *, struct obd_client_handle *, int flag);
1377         int (*o_unpin)(struct obd_export *, struct obd_client_handle *, int);
1378
1379         int (*o_import_event)(struct obd_device *, struct obd_import *,
1380                               enum obd_import_event);
1381
1382         int (*o_notify)(struct obd_device *obd, struct obd_device *watched,
1383                         enum obd_notify_event ev, void *data);
1384
1385         int (*o_health_check)(const struct lu_env *env, struct obd_device *);
1386         struct obd_uuid *(*o_get_uuid) (struct obd_export *exp);
1387
1388         /* quota methods */
1389         int (*o_quotacheck)(struct obd_device *, struct obd_export *,
1390                             struct obd_quotactl *);
1391         int (*o_quotactl)(struct obd_device *, struct obd_export *,
1392                           struct obd_quotactl *);
1393
1394         int (*o_ping)(const struct lu_env *, struct obd_export *exp);
1395
1396         /* pools methods */
1397         int (*o_pool_new)(struct obd_device *obd, char *poolname);
1398         int (*o_pool_del)(struct obd_device *obd, char *poolname);
1399         int (*o_pool_add)(struct obd_device *obd, char *poolname,
1400                           char *ostname);
1401         int (*o_pool_rem)(struct obd_device *obd, char *poolname,
1402                           char *ostname);
1403         void (*o_getref)(struct obd_device *obd);
1404         void (*o_putref)(struct obd_device *obd);
1405         /*
1406          * NOTE: If adding ops, add another LPROCFS_OBD_OP_INIT() line
1407          * to lprocfs_alloc_obd_stats() in obdclass/lprocfs_status.c.
1408          * Also, add a wrapper function in include/linux/obd_class.h. */
1409 };
1410
1411 enum {
1412         LUSTRE_OPC_MKDIR    = (1 << 0),
1413         LUSTRE_OPC_SYMLINK  = (1 << 1),
1414         LUSTRE_OPC_MKNOD    = (1 << 2),
1415         LUSTRE_OPC_CREATE   = (1 << 3),
1416         LUSTRE_OPC_ANY      = (1 << 4)
1417 };
1418
1419 /* lmv structures */
1420 #define MEA_MAGIC_LAST_CHAR      0xb2221ca1
1421 #define MEA_MAGIC_ALL_CHARS      0xb222a11c
1422 #define MEA_MAGIC_HASH_SEGMENT   0xb222a11b
1423
1424 #define MAX_HASH_SIZE_32         0x7fffffffUL
1425 #define MAX_HASH_SIZE       0x7fffffffffffffffULL
1426 #define MAX_HASH_HIGHEST_BIT     0x1000000000000000ULL
1427
1428 struct lustre_md {
1429         struct mdt_body  *body;
1430         struct lov_stripe_md    *lsm;
1431         struct lmv_stripe_md    *mea;
1432 #ifdef CONFIG_FS_POSIX_ACL
1433         struct posix_acl        *posix_acl;
1434 #endif
1435         struct mdt_remote_perm  *remote_perm;
1436         struct obd_capa  *mds_capa;
1437         struct obd_capa  *oss_capa;
1438 };
1439
1440 struct md_open_data {
1441         struct obd_client_handle *mod_och;
1442         struct ptlrpc_request    *mod_open_req;
1443         struct ptlrpc_request    *mod_close_req;
1444         atomic_t              mod_refcount;
1445 };
1446
1447 struct lookup_intent;
1448
1449 struct md_ops {
1450         int (*m_getstatus)(struct obd_export *, struct lu_fid *,
1451                            struct obd_capa **);
1452         int (*m_null_inode)(struct obd_export *, const struct lu_fid *);
1453         int (*m_find_cbdata)(struct obd_export *, const struct lu_fid *,
1454                              ldlm_iterator_t, void *);
1455         int (*m_close)(struct obd_export *, struct md_op_data *,
1456                        struct md_open_data *, struct ptlrpc_request **);
1457         int (*m_create)(struct obd_export *, struct md_op_data *,
1458                         const void *, int, int, __u32, __u32, cfs_cap_t,
1459                         __u64, struct ptlrpc_request **);
1460         int (*m_done_writing)(struct obd_export *, struct md_op_data  *,
1461                               struct md_open_data *);
1462         int (*m_enqueue)(struct obd_export *, struct ldlm_enqueue_info *,
1463                          struct lookup_intent *, struct md_op_data *,
1464                          struct lustre_handle *, void *, int,
1465                          struct ptlrpc_request **, __u64);
1466         int (*m_getattr)(struct obd_export *, struct md_op_data *,
1467                          struct ptlrpc_request **);
1468         int (*m_getattr_name)(struct obd_export *, struct md_op_data *,
1469                               struct ptlrpc_request **);
1470         int (*m_intent_lock)(struct obd_export *, struct md_op_data *,
1471                              void *, int, struct lookup_intent *, int,
1472                              struct ptlrpc_request **,
1473                              ldlm_blocking_callback, __u64);
1474         int (*m_link)(struct obd_export *, struct md_op_data *,
1475                       struct ptlrpc_request **);
1476         int (*m_rename)(struct obd_export *, struct md_op_data *,
1477                         const char *, int, const char *, int,
1478                         struct ptlrpc_request **);
1479         int (*m_is_subdir)(struct obd_export *, const struct lu_fid *,
1480                            const struct lu_fid *,
1481                            struct ptlrpc_request **);
1482         int (*m_setattr)(struct obd_export *, struct md_op_data *, void *,
1483                          int , void *, int, struct ptlrpc_request **,
1484                          struct md_open_data **mod);
1485         int (*m_sync)(struct obd_export *, const struct lu_fid *,
1486                       struct obd_capa *, struct ptlrpc_request **);
1487         int (*m_readpage)(struct obd_export *, struct md_op_data *,
1488                           struct page **, struct ptlrpc_request **);
1489
1490         int (*m_unlink)(struct obd_export *, struct md_op_data *,
1491                         struct ptlrpc_request **);
1492
1493         int (*m_setxattr)(struct obd_export *, const struct lu_fid *,
1494                           struct obd_capa *, obd_valid, const char *,
1495                           const char *, int, int, int, __u32,
1496                           struct ptlrpc_request **);
1497
1498         int (*m_getxattr)(struct obd_export *, const struct lu_fid *,
1499                           struct obd_capa *, obd_valid, const char *,
1500                           const char *, int, int, int,
1501                           struct ptlrpc_request **);
1502
1503         int (*m_init_ea_size)(struct obd_export *, int, int, int);
1504
1505         int (*m_get_lustre_md)(struct obd_export *, struct ptlrpc_request *,
1506                                struct obd_export *, struct obd_export *,
1507                                struct lustre_md *);
1508
1509         int (*m_free_lustre_md)(struct obd_export *, struct lustre_md *);
1510
1511         int (*m_set_open_replay_data)(struct obd_export *,
1512                                       struct obd_client_handle *,
1513                                       struct ptlrpc_request *);
1514         int (*m_clear_open_replay_data)(struct obd_export *,
1515                                         struct obd_client_handle *);
1516         int (*m_set_lock_data)(struct obd_export *, __u64 *, void *, __u64 *);
1517
1518         ldlm_mode_t (*m_lock_match)(struct obd_export *, __u64,
1519                                     const struct lu_fid *, ldlm_type_t,
1520                                     ldlm_policy_data_t *, ldlm_mode_t,
1521                                     struct lustre_handle *);
1522
1523         int (*m_cancel_unused)(struct obd_export *, const struct lu_fid *,
1524                                ldlm_policy_data_t *, ldlm_mode_t,
1525                                ldlm_cancel_flags_t flags, void *opaque);
1526         int (*m_renew_capa)(struct obd_export *, struct obd_capa *oc,
1527                             renew_capa_cb_t cb);
1528         int (*m_unpack_capa)(struct obd_export *, struct ptlrpc_request *,
1529                              const struct req_msg_field *, struct obd_capa **);
1530
1531         int (*m_get_remote_perm)(struct obd_export *, const struct lu_fid *,
1532                                  struct obd_capa *, __u32,
1533                                  struct ptlrpc_request **);
1534
1535         int (*m_intent_getattr_async)(struct obd_export *,
1536                                       struct md_enqueue_info *,
1537                                       struct ldlm_enqueue_info *);
1538
1539         int (*m_revalidate_lock)(struct obd_export *, struct lookup_intent *,
1540                                  struct lu_fid *, __u64 *bits);
1541
1542         /*
1543          * NOTE: If adding ops, add another LPROCFS_MD_OP_INIT() line to
1544          * lprocfs_alloc_md_stats() in obdclass/lprocfs_status.c. Also, add a
1545          * wrapper function in include/linux/obd_class.h.
1546          */
1547 };
1548
1549 struct lsm_operations {
1550         void (*lsm_free)(struct lov_stripe_md *);
1551         int (*lsm_destroy)(struct lov_stripe_md *, struct obdo *oa,
1552                            struct obd_export *md_exp);
1553         void (*lsm_stripe_by_index)(struct lov_stripe_md *, int *, obd_off *,
1554                                     obd_off *);
1555         void (*lsm_stripe_by_offset)(struct lov_stripe_md *, int *, obd_off *,
1556                                      obd_off *);
1557         int (*lsm_lmm_verify) (struct lov_mds_md *lmm, int lmm_bytes,
1558                                __u16 *stripe_count);
1559         int (*lsm_unpackmd) (struct lov_obd *lov, struct lov_stripe_md *lsm,
1560                              struct lov_mds_md *lmm);
1561 };
1562
1563 extern const struct lsm_operations lsm_v1_ops;
1564 extern const struct lsm_operations lsm_v3_ops;
1565 static inline const struct lsm_operations *lsm_op_find(int magic)
1566 {
1567         switch(magic) {
1568         case LOV_MAGIC_V1:
1569                return &lsm_v1_ops;
1570         case LOV_MAGIC_V3:
1571                return &lsm_v3_ops;
1572         default:
1573                CERROR("Cannot recognize lsm_magic %08x\n", magic);
1574                return NULL;
1575         }
1576 }
1577
1578 /* Requests for obd_extent_calc() */
1579 #define OBD_CALC_STRIPE_START   1
1580 #define OBD_CALC_STRIPE_END     2
1581
1582 static inline struct lustre_capa *oinfo_capa(struct obd_info *oinfo)
1583 {
1584         return oinfo->oi_capa;
1585 }
1586
1587 static inline struct md_open_data *obd_mod_alloc(void)
1588 {
1589         struct md_open_data *mod;
1590         OBD_ALLOC_PTR(mod);
1591         if (mod == NULL)
1592                 return NULL;
1593         atomic_set(&mod->mod_refcount, 1);
1594         return mod;
1595 }
1596
1597 #define obd_mod_get(mod) atomic_inc(&(mod)->mod_refcount)
1598 #define obd_mod_put(mod)                                        \
1599 ({                                                            \
1600         if (atomic_dec_and_test(&(mod)->mod_refcount)) {          \
1601                 if ((mod)->mod_open_req)                          \
1602                         ptlrpc_req_finished((mod)->mod_open_req);   \
1603                 OBD_FREE_PTR(mod);                            \
1604         }                                                      \
1605 })
1606
1607 void obdo_from_inode(struct obdo *dst, struct inode *src, obd_flag valid);
1608 void obdo_set_parent_fid(struct obdo *dst, const struct lu_fid *parent);
1609
1610 /* return 1 if client should be resend request */
1611 static inline int client_should_resend(int resend, struct client_obd *cli)
1612 {
1613         return atomic_read(&cli->cl_resends) ?
1614                atomic_read(&cli->cl_resends) > resend : 1;
1615 }
1616
1617 /**
1618  * Return device name for this device
1619  *
1620  * XXX: lu_device is declared before obd_device, while a pointer pointing
1621  * back to obd_device in lu_device, so this helper function defines here
1622  * instead of in lu_object.h
1623  */
1624 static inline const char *lu_dev_name(const struct lu_device *lu_dev)
1625 {
1626         return lu_dev->ld_obd->obd_name;
1627 }
1628
1629 static inline bool filename_is_volatile(const char *name, int namelen, int *idx)
1630 {
1631         const char      *start;
1632         char            *end;
1633
1634         if (strncmp(name, LUSTRE_VOLATILE_HDR, LUSTRE_VOLATILE_HDR_LEN) != 0)
1635                 return false;
1636
1637         /* caller does not care of idx */
1638         if (idx == NULL)
1639                 return true;
1640
1641         /* volatile file, the MDT can be set from name */
1642         /* name format is LUSTRE_VOLATILE_HDR:[idx]: */
1643         /* if no MDT is specified, use std way */
1644         if (namelen < LUSTRE_VOLATILE_HDR_LEN + 2)
1645                 goto bad_format;
1646         /* test for no MDT idx case */
1647         if ((*(name + LUSTRE_VOLATILE_HDR_LEN) == ':') &&
1648             (*(name + LUSTRE_VOLATILE_HDR_LEN + 1) == ':')) {
1649                 *idx = -1;
1650                 return true;
1651         }
1652         /* we have an idx, read it */
1653         start = name + LUSTRE_VOLATILE_HDR_LEN + 1;
1654         *idx = strtoul(start, &end, 0);
1655         /* error cases:
1656          * no digit, no trailing :, negative value
1657          */
1658         if (((*idx == 0) && (end == start)) ||
1659             (*end != ':') || (*idx < 0))
1660                 goto bad_format;
1661
1662         return true;
1663 bad_format:
1664         /* bad format of mdt idx, we cannot return an error
1665          * to caller so we use hash algo */
1666         CERROR("Bad volatile file name format: %s\n",
1667                name + LUSTRE_VOLATILE_HDR_LEN);
1668         return false;
1669 }
1670
1671 static inline int cli_brw_size(struct obd_device *obd)
1672 {
1673         LASSERT(obd != NULL);
1674         return obd->u.cli.cl_max_pages_per_rpc << PAGE_CACHE_SHIFT;
1675 }
1676
1677 #endif /* __OBD_H */