drivers/staging/lustre/lustre/include/lustre_export.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.gnu.org/licenses/gpl-2.0.html
  19  *
  20  * GPL HEADER END
  21  */
  22 /*
  23  * Copyright (c) 2002, 2010, Oracle and/or its affiliates. All rights reserved.
  24  * Use is subject to license terms.
  25  *
  26  * Copyright (c) 2011, 2015, Intel Corporation.
  27  */
  28 /*
  29  * This file is part of Lustre, http://www.lustre.org/
  30  * Lustre is a trademark of Sun Microsystems, Inc.
  31  */
  32 /** \defgroup obd_export PortalRPC export definitions
  33  *
  34  * @{
  35  */
  36
  37 #ifndef __EXPORT_H
  38 #define __EXPORT_H
  39
  40 /** \defgroup export export
  41  *
  42  * @{
  43  */
  44
  45 #include "lprocfs_status.h"
  46 #include "lustre/lustre_idl.h"
  47 #include "lustre_dlm.h"
  48
  49 enum obd_option {
  50         OBD_OPT_FORCE =  0x0001,
  51         OBD_OPT_FAILOVER =      0x0002,
  52         OBD_OPT_ABORT_RECOV =   0x0004,
  53 };
  54
  55 /**
  56  * Export structure. Represents target-side of connection in portals.
  57  * Also used in Lustre to connect between layers on the same node when
  58  * there is no network-connection in-between.
  59  * For every connected client there is an export structure on the server
  60  * attached to the same obd device.
  61  */
  62 struct obd_export {
  63         /**
  64          * Export handle, it's id is provided to client on connect
  65          * Subsequent client RPCs contain this handle id to identify
  66          * what export they are talking to.
  67          */
  68         struct portals_handle     exp_handle;
  69         atomic_t              exp_refcount;
  70         /**
  71          * Set of counters below is to track where export references are
  72          * kept. The exp_rpc_count is used for reconnect handling also,
  73          * the cb_count and locks_count are for debug purposes only for now.
  74          * The sum of them should be less than exp_refcount by 3
  75          */
  76         atomic_t              exp_rpc_count; /* RPC references */
  77         atomic_t              exp_cb_count; /* Commit callback references */
  78         /** Number of queued replay requests to be processes */
  79         atomic_t                  exp_replay_count;
  80         atomic_t              exp_locks_count; /** Lock references */
  81 #if LUSTRE_TRACKS_LOCK_EXP_REFS
  82         struct list_head                exp_locks_list;
  83         spinlock_t                exp_locks_list_guard;
  84 #endif
  85         /** UUID of client connected to this export */
  86         struct obd_uuid    exp_client_uuid;
  87         /** To link all exports on an obd device */
  88         struct list_head                exp_obd_chain;
  89         struct hlist_node         exp_uuid_hash; /** uuid-export hash*/
  90         /** Obd device of this export */
  91         struct obd_device       *exp_obd;
  92         /**
  93          * "reverse" import to send requests (e.g. from ldlm) back to client
  94          * exp_lock protect its change
  95          */
  96         struct obd_import       *exp_imp_reverse;
  97         struct lprocfs_stats     *exp_md_stats;
  98         /** Active connection */
  99         struct ptlrpc_connection *exp_connection;
 100         /** Connection count value from last successful reconnect rpc */
 101         __u32                exp_conn_cnt;
 102         /** Hash list of all ldlm locks granted on this export */
 103         struct cfs_hash        *exp_lock_hash;
 104         /**
 105          * Hash list for Posix lock deadlock detection, added with
 106          * ldlm_lock::l_exp_flock_hash.
 107          */
 108         struct cfs_hash        *exp_flock_hash;
 109         struct list_head                exp_outstanding_replies;
 110         struct list_head                exp_uncommitted_replies;
 111         spinlock_t                exp_uncommitted_replies_lock;
 112         /** Last committed transno for this export */
 113         __u64                exp_last_committed;
 114         /** On replay all requests waiting for replay are linked here */
 115         struct list_head                exp_req_replay_queue;
 116         /**
 117          * protects exp_flags, exp_outstanding_replies and the change
 118          * of exp_imp_reverse
 119          */
 120         spinlock_t                exp_lock;
 121         /** Compatibility flags for this export are embedded into
 122          *  exp_connect_data
 123          */
 124         struct obd_connect_data   exp_connect_data;
 125         enum obd_option    exp_flags;
 126         unsigned long        exp_failed:1,
 127                                   exp_disconnected:1,
 128                                   exp_connecting:1,
 129                                   exp_flvr_changed:1,
 130                                   exp_flvr_adapt:1;
 131         /* also protected by exp_lock */
 132         enum lustre_sec_part      exp_sp_peer;
 133         struct sptlrpc_flavor     exp_flvr;          /* current */
 134         struct sptlrpc_flavor     exp_flvr_old[2];      /* about-to-expire */
 135         time64_t                  exp_flvr_expire[2];   /* seconds */
 136
 137         /** protects exp_hp_rpcs */
 138         spinlock_t                exp_rpc_lock;
 139         struct list_head                  exp_hp_rpcs;  /* (potential) HP RPCs */
 140
 141         /** blocking dlm lock list, protected by exp_bl_list_lock */
 142         struct list_head                exp_bl_list;
 143         spinlock_t                exp_bl_list_lock;
 144 };
 145
 146 static inline __u64 *exp_connect_flags_ptr(struct obd_export *exp)
 147 {
 148         return &exp->exp_connect_data.ocd_connect_flags;
 149 }
 150
 151 static inline __u64 exp_connect_flags(struct obd_export *exp)
 152 {
 153         return *exp_connect_flags_ptr(exp);
 154 }
 155
 156 static inline int exp_max_brw_size(struct obd_export *exp)
 157 {
 158         if (exp_connect_flags(exp) & OBD_CONNECT_BRW_SIZE)
 159                 return exp->exp_connect_data.ocd_brw_size;
 160
 161         return ONE_MB_BRW_SIZE;
 162 }
 163
 164 static inline int exp_connect_multibulk(struct obd_export *exp)
 165 {
 166         return exp_max_brw_size(exp) > ONE_MB_BRW_SIZE;
 167 }
 168
 169 static inline int exp_connect_cancelset(struct obd_export *exp)
 170 {
 171         return !!(exp_connect_flags(exp) & OBD_CONNECT_CANCELSET);
 172 }
 173
 174 static inline int exp_connect_lru_resize(struct obd_export *exp)
 175 {
 176         return !!(exp_connect_flags(exp) & OBD_CONNECT_LRU_RESIZE);
 177 }
 178
 179 static inline int exp_connect_vbr(struct obd_export *exp)
 180 {
 181         return !!(exp_connect_flags(exp) & OBD_CONNECT_VBR);
 182 }
 183
 184 static inline int exp_connect_som(struct obd_export *exp)
 185 {
 186         return !!(exp_connect_flags(exp) & OBD_CONNECT_SOM);
 187 }
 188
 189 static inline int exp_connect_umask(struct obd_export *exp)
 190 {
 191         return !!(exp_connect_flags(exp) & OBD_CONNECT_UMASK);
 192 }
 193
 194 static inline int imp_connect_lru_resize(struct obd_import *imp)
 195 {
 196         struct obd_connect_data *ocd;
 197
 198         ocd = &imp->imp_connect_data;
 199         return !!(ocd->ocd_connect_flags & OBD_CONNECT_LRU_RESIZE);
 200 }
 201
 202 static inline int exp_connect_layout(struct obd_export *exp)
 203 {
 204         return !!(exp_connect_flags(exp) & OBD_CONNECT_LAYOUTLOCK);
 205 }
 206
 207 static inline bool exp_connect_lvb_type(struct obd_export *exp)
 208 {
 209         if (exp_connect_flags(exp) & OBD_CONNECT_LVB_TYPE)
 210                 return true;
 211         else
 212                 return false;
 213 }
 214
 215 static inline bool imp_connect_lvb_type(struct obd_import *imp)
 216 {
 217         struct obd_connect_data *ocd;
 218
 219         ocd = &imp->imp_connect_data;
 220         if (ocd->ocd_connect_flags & OBD_CONNECT_LVB_TYPE)
 221                 return true;
 222         else
 223                 return false;
 224 }
 225
 226 static inline __u64 exp_connect_ibits(struct obd_export *exp)
 227 {
 228         struct obd_connect_data *ocd;
 229
 230         ocd = &exp->exp_connect_data;
 231         return ocd->ocd_ibits_known;
 232 }
 233
 234 static inline bool imp_connect_disp_stripe(struct obd_import *imp)
 235 {
 236         struct obd_connect_data *ocd;
 237
 238         ocd = &imp->imp_connect_data;
 239         return ocd->ocd_connect_flags & OBD_CONNECT_DISP_STRIPE;
 240 }
 241
 242 struct obd_export *class_conn2export(struct lustre_handle *conn);
 243
 244 #define KKUC_CT_DATA_MAGIC      0x092013cea
 245 struct kkuc_ct_data {
 246         __u32           kcd_magic;
 247         struct obd_uuid kcd_uuid;
 248         __u32           kcd_archive;
 249 };
 250
 251 /** @} export */
 252
 253 #endif /* __EXPORT_H */
 254 /** @} obd_export */