[deliverable/linux.git] / drivers / staging / lustre / lustre / include / lustre_export.h

/*
 * GPL HEADER START
 *
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 only,
 * as published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License version 2 for more details (a copy is included
 * in the LICENSE file that accompanied this code).
 *
 * You should have received a copy of the GNU General Public License
 * version 2 along with this program; If not, see
 * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
 *
 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
 * CA 95054 USA or visit www.sun.com if you need additional information or
 * have any questions.
 *
 * GPL HEADER END
 */
/*
 * Copyright (c) 2002, 2010, Oracle and/or its affiliates. All rights reserved.
 * Use is subject to license terms.
 *
 * Copyright (c) 2011, 2012, Intel Corporation.
 */
/*
 * This file is part of Lustre, http://www.lustre.org/
 * Lustre is a trademark of Sun Microsystems, Inc.
 */
/** \defgroup obd_export PortalRPC export definitions
 *
 * @{
 */

#ifndef __EXPORT_H
#define __EXPORT_H

/** \defgroup export export
 *
 * @{
 */

#include "lprocfs_status.h"
#include "lustre/lustre_idl.h"
#include "lustre_dlm.h"

struct mds_client_data;
struct mdt_client_data;
struct mds_idmap_table;
struct mdt_idmap_table;

/**
 * Target-specific export data
 */
struct tg_export_data {
	/** Protects led_lcd below */
	struct mutex		ted_lcd_lock;
	/** Per-client data for each export */
	struct lsd_client_data	*ted_lcd;
	/** Offset of record in last_rcvd file */
	loff_t			ted_lr_off;
	/** Client index in last_rcvd file */
	int			ted_lr_idx;
};

/**
 * MDT-specific export data
 */
struct mdt_export_data {
	struct tg_export_data	med_ted;
	/** List of all files opened by client on this MDT */
	struct list_head		med_open_head;
	spinlock_t		med_open_lock; /* med_open_head, mfd_list */
	/** Bitmask of all ibit locks this MDT understands */
	__u64			med_ibits_known;
	struct mutex		med_idmap_mutex;
	struct lustre_idmap_table *med_idmap;
};

struct ec_export_data { /* echo client */
	struct list_head eced_locks;
};

/* In-memory access to client data from OST struct */
/** Filter (oss-side) specific import data */
struct filter_export_data {
	struct tg_export_data	fed_ted;
	spinlock_t		fed_lock;	/**< protects fed_mod_list */
	long		       fed_dirty;    /* in bytes */
	long		       fed_grant;    /* in bytes */
	struct list_head		 fed_mod_list; /* files being modified */
	int			fed_mod_count;/* items in fed_writing list */
	long		       fed_pending;  /* bytes just being written */
	__u32		      fed_group;
	__u8		       fed_pagesize; /* log2 of client page size */
};

struct mgs_export_data {
	struct list_head		med_clients;	/* mgc fs client via this exp */
	spinlock_t		med_lock;	/* protect med_clients */
};

/**
 * per-NID statistics structure.
 * It tracks access patterns to this export on a per-client-NID basis
 */
struct nid_stat {
	lnet_nid_t	       nid;
	struct hlist_node	 nid_hash;
	struct list_head	       nid_list;
	struct obd_device       *nid_obd;
	struct proc_dir_entry   *nid_proc;
	struct lprocfs_stats    *nid_stats;
	struct lprocfs_stats    *nid_ldlm_stats;
	atomic_t	     nid_exp_ref_count; /* for obd_nid_stats_hash
							   exp_nid_stats */
};

#define nidstat_getref(nidstat)						\
do {									   \
	atomic_inc(&(nidstat)->nid_exp_ref_count);			 \
} while(0)

#define nidstat_putref(nidstat)						\
do {									   \
	atomic_dec(&(nidstat)->nid_exp_ref_count);			 \
	LASSERTF(atomic_read(&(nidstat)->nid_exp_ref_count) >= 0,	  \
		 "stat %p nid_exp_ref_count < 0\n", nidstat);		  \
} while(0)

enum obd_option {
	OBD_OPT_FORCE =	 0x0001,
	OBD_OPT_FAILOVER =      0x0002,
	OBD_OPT_ABORT_RECOV =   0x0004,
};

/**
 * Export structure. Represents target-side of connection in portals.
 * Also used in Lustre to connect between layers on the same node when
 * there is no network-connection in-between.
 * For every connected client there is an export structure on the server
 * attached to the same obd device.
 */
struct obd_export {
	/**
	 * Export handle, it's id is provided to client on connect
	 * Subsequent client RPCs contain this handle id to identify
	 * what export they are talking to.
	 */
	struct portals_handle     exp_handle;
	atomic_t	      exp_refcount;
	/**
	 * Set of counters below is to track where export references are
	 * kept. The exp_rpc_count is used for reconnect handling also,
	 * the cb_count and locks_count are for debug purposes only for now.
	 * The sum of them should be less than exp_refcount by 3
	 */
	atomic_t	      exp_rpc_count; /* RPC references */
	atomic_t	      exp_cb_count; /* Commit callback references */
	/** Number of queued replay requests to be processes */
	atomic_t		  exp_replay_count;
	atomic_t	      exp_locks_count; /** Lock references */
#if LUSTRE_TRACKS_LOCK_EXP_REFS
	struct list_head		exp_locks_list;
	spinlock_t		  exp_locks_list_guard;
#endif
	/** UUID of client connected to this export */
	struct obd_uuid	   exp_client_uuid;
	/** To link all exports on an obd device */
	struct list_head		exp_obd_chain;
	struct hlist_node	  exp_uuid_hash; /** uuid-export hash*/
	struct hlist_node	  exp_nid_hash; /** nid-export hash */
	/**
	 * All exports eligible for ping evictor are linked into a list
	 * through this field in "most time since last request on this export"
	 * order
	 * protected by obd_dev_lock
	 */
	struct list_head		exp_obd_chain_timed;
	/** Obd device of this export */
	struct obd_device	*exp_obd;
	/**
	 * "reverse" import to send requests (e.g. from ldlm) back to client
	 * exp_lock protect its change
	 */
	struct obd_import	*exp_imp_reverse;
	struct nid_stat	  *exp_nid_stats;
	struct lprocfs_stats     *exp_md_stats;
	/** Active connection */
	struct ptlrpc_connection *exp_connection;
	/** Connection count value from last successful reconnect rpc */
	__u32		     exp_conn_cnt;
	/** Hash list of all ldlm locks granted on this export */
	struct cfs_hash	       *exp_lock_hash;
	/**
	 * Hash list for Posix lock deadlock detection, added with
	 * ldlm_lock::l_exp_flock_hash.
	 */
	struct cfs_hash	       *exp_flock_hash;
	struct list_head		exp_outstanding_replies;
	struct list_head		exp_uncommitted_replies;
	spinlock_t		  exp_uncommitted_replies_lock;
	/** Last committed transno for this export */
	__u64		     exp_last_committed;
	/** When was last request received */
	unsigned long		exp_last_request_time;
	/** On replay all requests waiting for replay are linked here */
	struct list_head		exp_req_replay_queue;
	/**
	 * protects exp_flags, exp_outstanding_replies and the change
	 * of exp_imp_reverse
	 */
	spinlock_t		  exp_lock;
	/** Compatibility flags for this export are embedded into
	 *  exp_connect_data */
	struct obd_connect_data   exp_connect_data;
	enum obd_option	   exp_flags;
	unsigned long	     exp_failed:1,
				  exp_in_recovery:1,
				  exp_disconnected:1,
				  exp_connecting:1,
				  /** VBR: export missed recovery */
				  exp_delayed:1,
				  /** VBR: failed version checking */
				  exp_vbr_failed:1,
				  exp_req_replay_needed:1,
				  exp_lock_replay_needed:1,
				  exp_need_sync:1,
				  exp_flvr_changed:1,
				  exp_flvr_adapt:1,
				  exp_libclient:1, /* liblustre client? */
				  /* client timed out and tried to reconnect,
				   * but couldn't because of active rpcs */
				  exp_abort_active_req:1,
				  /* if to swap nidtbl entries for 2.2 clients.
				   * Only used by the MGS to fix LU-1644. */
				  exp_need_mne_swab:1;
	/* also protected by exp_lock */
	enum lustre_sec_part      exp_sp_peer;
	struct sptlrpc_flavor     exp_flvr;	     /* current */
	struct sptlrpc_flavor     exp_flvr_old[2];      /* about-to-expire */
	unsigned long		exp_flvr_expire[2];   /* seconds */

	/** protects exp_hp_rpcs */
	spinlock_t		  exp_rpc_lock;
	struct list_head		  exp_hp_rpcs;	/* (potential) HP RPCs */

	/** blocking dlm lock list, protected by exp_bl_list_lock */
	struct list_head		exp_bl_list;
	spinlock_t		  exp_bl_list_lock;

	/** Target specific data */
	union {
		struct tg_export_data     eu_target_data;
		struct mdt_export_data    eu_mdt_data;
		struct filter_export_data eu_filter_data;
		struct ec_export_data     eu_ec_data;
		struct mgs_export_data    eu_mgs_data;
	} u;
};

#define exp_target_data u.eu_target_data
#define exp_mdt_data    u.eu_mdt_data
#define exp_filter_data u.eu_filter_data
#define exp_ec_data     u.eu_ec_data

static inline __u64 *exp_connect_flags_ptr(struct obd_export *exp)
{
	return &exp->exp_connect_data.ocd_connect_flags;
}

static inline __u64 exp_connect_flags(struct obd_export *exp)
{
	return *exp_connect_flags_ptr(exp);
}

static inline int exp_max_brw_size(struct obd_export *exp)
{
	LASSERT(exp != NULL);
	if (exp_connect_flags(exp) & OBD_CONNECT_BRW_SIZE)
		return exp->exp_connect_data.ocd_brw_size;

	return ONE_MB_BRW_SIZE;
}

static inline int exp_connect_multibulk(struct obd_export *exp)
{
	return exp_max_brw_size(exp) > ONE_MB_BRW_SIZE;
}

static inline int exp_expired(struct obd_export *exp, long age)
{
	LASSERT(exp->exp_delayed);
	return time_before(cfs_time_add(exp->exp_last_request_time, age),
			   get_seconds());
}

static inline int exp_connect_cancelset(struct obd_export *exp)
{
	LASSERT(exp != NULL);
	return !!(exp_connect_flags(exp) & OBD_CONNECT_CANCELSET);
}

static inline int exp_connect_lru_resize(struct obd_export *exp)
{
	LASSERT(exp != NULL);
	return !!(exp_connect_flags(exp) & OBD_CONNECT_LRU_RESIZE);
}

static inline int exp_connect_rmtclient(struct obd_export *exp)
{
	LASSERT(exp != NULL);
	return !!(exp_connect_flags(exp) & OBD_CONNECT_RMT_CLIENT);
}

static inline int client_is_remote(struct obd_export *exp)
{
	struct obd_import *imp = class_exp2cliimp(exp);

	return !!(imp->imp_connect_data.ocd_connect_flags &
		  OBD_CONNECT_RMT_CLIENT);
}

static inline int exp_connect_vbr(struct obd_export *exp)
{
	LASSERT(exp != NULL);
	LASSERT(exp->exp_connection);
	return !!(exp_connect_flags(exp) & OBD_CONNECT_VBR);
}

static inline int exp_connect_som(struct obd_export *exp)
{
	LASSERT(exp != NULL);
	return !!(exp_connect_flags(exp) & OBD_CONNECT_SOM);
}

static inline int exp_connect_umask(struct obd_export *exp)
{
	return !!(exp_connect_flags(exp) & OBD_CONNECT_UMASK);
}

static inline int imp_connect_lru_resize(struct obd_import *imp)
{
	struct obd_connect_data *ocd;

	LASSERT(imp != NULL);
	ocd = &imp->imp_connect_data;
	return !!(ocd->ocd_connect_flags & OBD_CONNECT_LRU_RESIZE);
}

static inline int exp_connect_layout(struct obd_export *exp)
{
	return !!(exp_connect_flags(exp) & OBD_CONNECT_LAYOUTLOCK);
}

static inline bool exp_connect_lvb_type(struct obd_export *exp)
{
	LASSERT(exp != NULL);
	if (exp_connect_flags(exp) & OBD_CONNECT_LVB_TYPE)
		return true;
	else
		return false;
}

static inline bool imp_connect_lvb_type(struct obd_import *imp)
{
	struct obd_connect_data *ocd;

	LASSERT(imp != NULL);
	ocd = &imp->imp_connect_data;
	if (ocd->ocd_connect_flags & OBD_CONNECT_LVB_TYPE)
		return true;
	else
		return false;
}

static inline __u64 exp_connect_ibits(struct obd_export *exp)
{
	struct obd_connect_data *ocd;

	ocd = &exp->exp_connect_data;
	return ocd->ocd_ibits_known;
}

static inline bool imp_connect_disp_stripe(struct obd_import *imp)
{
	struct obd_connect_data *ocd;

	LASSERT(imp != NULL);
	ocd = &imp->imp_connect_data;
	return ocd->ocd_connect_flags & OBD_CONNECT_DISP_STRIPE;
}

extern struct obd_export *class_conn2export(struct lustre_handle *conn);
extern struct obd_device *class_conn2obd(struct lustre_handle *conn);

/** @} export */

#endif /* __EXPORT_H */
/** @} obd_export */
Commit	Line	Data
d7e09d03 PT	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) 2002, 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	/** \defgroup obd_export PortalRPC export definitions
	37	*
	38	* @{
	39	*/
	40
	41	#ifndef __EXPORT_H
	42	#define __EXPORT_H
	43
	44	/** \defgroup export export
	45	*
	46	* @{
	47	*/
	48
1accaadf GKH	49	#include "lprocfs_status.h"
	50	#include "lustre/lustre_idl.h"
	51	#include "lustre_dlm.h"
d7e09d03 PT	52
	53	struct mds_client_data;
	54	struct mdt_client_data;
	55	struct mds_idmap_table;
	56	struct mdt_idmap_table;
	57
	58	/**
	59	* Target-specific export data
	60	*/
	61	struct tg_export_data {
	62	/** Protects led_lcd below */
	63	struct mutex ted_lcd_lock;
	64	/** Per-client data for each export */
	65	struct lsd_client_data *ted_lcd;
	66	/** Offset of record in last_rcvd file */
	67	loff_t ted_lr_off;
	68	/** Client index in last_rcvd file */
	69	int ted_lr_idx;
	70	};
	71
	72	/**
	73	* MDT-specific export data
	74	*/
	75	struct mdt_export_data {
	76	struct tg_export_data med_ted;
	77	/** List of all files opened by client on this MDT */
	78	struct list_head med_open_head;
	79	spinlock_t med_open_lock; /* med_open_head, mfd_list */
	80	/** Bitmask of all ibit locks this MDT understands */
	81	__u64 med_ibits_known;
	82	struct mutex med_idmap_mutex;
	83	struct lustre_idmap_table *med_idmap;
	84	};
	85
	86	struct ec_export_data { /* echo client */
	87	struct list_head eced_locks;
	88	};
	89
	90	/* In-memory access to client data from OST struct */
	91	/** Filter (oss-side) specific import data */
	92	struct filter_export_data {
	93	struct tg_export_data fed_ted;
	94	spinlock_t fed_lock; /*< protects fed_mod_list /
	95	long fed_dirty; /* in bytes */
	96	long fed_grant; /* in bytes */
	97	struct list_head fed_mod_list; /* files being modified */
	98	int fed_mod_count;/* items in fed_writing list */
	99	long fed_pending; /* bytes just being written */
	100	__u32 fed_group;
	101	__u8 fed_pagesize; /* log2 of client page size */
	102	};
	103
	104	struct mgs_export_data {
	105	struct list_head med_clients; /* mgc fs client via this exp */
	106	spinlock_t med_lock; /* protect med_clients */
	107	};
	108
	109	/**
	110	* per-NID statistics structure.
	111	* It tracks access patterns to this export on a per-client-NID basis
	112	*/
	113	struct nid_stat {
	114	lnet_nid_t nid;
	115	struct hlist_node nid_hash;
116	struct list_head nid_list;
117	struct obd_device *nid_obd;
118	struct proc_dir_entry *nid_proc;
119	struct lprocfs_stats *nid_stats;
120	struct lprocfs_stats *nid_ldlm_stats;
121	atomic_t nid_exp_ref_count; /* for obd_nid_stats_hash
122	exp_nid_stats */
123	};
124
125	#define nidstat_getref(nidstat) \
126	do { \
127	atomic_inc(&(nidstat)->nid_exp_ref_count); \
128	} while(0)
129
130	#define nidstat_putref(nidstat) \
131	do { \
132	atomic_dec(&(nidstat)->nid_exp_ref_count); \
133	LASSERTF(atomic_read(&(nidstat)->nid_exp_ref_count) >= 0, \
134	"stat %p nid_exp_ref_count < 0\n", nidstat); \
135	} while(0)
136
137	enum obd_option {
138	OBD_OPT_FORCE = 0x0001,
139	OBD_OPT_FAILOVER = 0x0002,
140	OBD_OPT_ABORT_RECOV = 0x0004,
141	};
142
143	/**
144	* Export structure. Represents target-side of connection in portals.
145	* Also used in Lustre to connect between layers on the same node when
146	* there is no network-connection in-between.
147	* For every connected client there is an export structure on the server
148	* attached to the same obd device.
149	*/
150	struct obd_export {
151	/**
152	* Export handle, it's id is provided to client on connect
153	* Subsequent client RPCs contain this handle id to identify
154	* what export they are talking to.
155	*/
156	struct portals_handle exp_handle;
157	atomic_t exp_refcount;
158	/**
159	* Set of counters below is to track where export references are
160	* kept. The exp_rpc_count is used for reconnect handling also,
161	* the cb_count and locks_count are for debug purposes only for now.
162	* The sum of them should be less than exp_refcount by 3
163	*/
164	atomic_t exp_rpc_count; /* RPC references */
165	atomic_t exp_cb_count; /* Commit callback references */
166	/** Number of queued replay requests to be processes */
167	atomic_t exp_replay_count;
168	atomic_t exp_locks_count; /** Lock references */
169	#if LUSTRE_TRACKS_LOCK_EXP_REFS
170	struct list_head exp_locks_list;
171	spinlock_t exp_locks_list_guard;
172	#endif
173	/** UUID of client connected to this export */
174	struct obd_uuid exp_client_uuid;
175	/** To link all exports on an obd device */
176	struct list_head exp_obd_chain;
177	struct hlist_node exp_uuid_hash; /** uuid-export hash*/
178	struct hlist_node exp_nid_hash; /** nid-export hash */
179	/**
180	* All exports eligible for ping evictor are linked into a list
181	* through this field in "most time since last request on this export"
182	* order
183	* protected by obd_dev_lock
184	*/
185	struct list_head exp_obd_chain_timed;
186	/** Obd device of this export */
187	struct obd_device *exp_obd;
188	/**
189	* "reverse" import to send requests (e.g. from ldlm) back to client
190	* exp_lock protect its change
191	*/
192	struct obd_import *exp_imp_reverse;
193	struct nid_stat *exp_nid_stats;
194	struct lprocfs_stats *exp_md_stats;
17891183	195	/** Active connection */
d7e09d03	196	struct ptlrpc_connection *exp_connection;
17891183	197	/** Connection count value from last successful reconnect rpc */
d7e09d03 PT	198	__u32 exp_conn_cnt;
d7e09d03 PT	199	/** Hash list of all ldlm locks granted on this export */
6da6eabe	200	struct cfs_hash *exp_lock_hash;
d7e09d03 PT	201	/**
	202	* Hash list for Posix lock deadlock detection, added with
	203	* ldlm_lock::l_exp_flock_hash.
	204	*/
6da6eabe	205	struct cfs_hash *exp_flock_hash;
d7e09d03 PT	206	struct list_head exp_outstanding_replies;
	207	struct list_head exp_uncommitted_replies;
	208	spinlock_t exp_uncommitted_replies_lock;
	209	/** Last committed transno for this export */
	210	__u64 exp_last_committed;
	211	/** When was last request received */
a649ad1d	212	unsigned long exp_last_request_time;
d7e09d03 PT	213	/** On replay all requests waiting for replay are linked here */
	214	struct list_head exp_req_replay_queue;
	215	/**
	216	* protects exp_flags, exp_outstanding_replies and the change
	217	* of exp_imp_reverse
	218	*/
	219	spinlock_t exp_lock;
	220	/** Compatibility flags for this export are embedded into
	221	* exp_connect_data */
	222	struct obd_connect_data exp_connect_data;
	223	enum obd_option exp_flags;
	224	unsigned long exp_failed:1,
	225	exp_in_recovery:1,
	226	exp_disconnected:1,
	227	exp_connecting:1,
	228	/** VBR: export missed recovery */
	229	exp_delayed:1,
	230	/** VBR: failed version checking */
	231	exp_vbr_failed:1,
	232	exp_req_replay_needed:1,
	233	exp_lock_replay_needed:1,
	234	exp_need_sync:1,
	235	exp_flvr_changed:1,
	236	exp_flvr_adapt:1,
	237	exp_libclient:1, /* liblustre client? */
	238	/* client timed out and tried to reconnect,
	239	* but couldn't because of active rpcs */
	240	exp_abort_active_req:1,
	241	/* if to swap nidtbl entries for 2.2 clients.
	242	* Only used by the MGS to fix LU-1644. */
	243	exp_need_mne_swab:1;
	244	/* also protected by exp_lock */
	245	enum lustre_sec_part exp_sp_peer;
	246	struct sptlrpc_flavor exp_flvr; /* current */
	247	struct sptlrpc_flavor exp_flvr_old[2]; /* about-to-expire */
a649ad1d	248	unsigned long exp_flvr_expire[2]; /* seconds */
d7e09d03 PT	249
	250	/** protects exp_hp_rpcs */
	251	spinlock_t exp_rpc_lock;
	252	struct list_head exp_hp_rpcs; /* (potential) HP RPCs */
	253
	254	/** blocking dlm lock list, protected by exp_bl_list_lock */
	255	struct list_head exp_bl_list;
	256	spinlock_t exp_bl_list_lock;
	257
	258	/** Target specific data */
	259	union {
	260	struct tg_export_data eu_target_data;
	261	struct mdt_export_data eu_mdt_data;
	262	struct filter_export_data eu_filter_data;
	263	struct ec_export_data eu_ec_data;
	264	struct mgs_export_data eu_mgs_data;
	265	} u;
	266	};
	267
	268	#define exp_target_data u.eu_target_data
	269	#define exp_mdt_data u.eu_mdt_data
	270	#define exp_filter_data u.eu_filter_data
	271	#define exp_ec_data u.eu_ec_data
	272
	273	static inline __u64 exp_connect_flags_ptr(struct obd_export exp)
	274	{
	275	return &exp->exp_connect_data.ocd_connect_flags;
	276	}
	277
	278	static inline __u64 exp_connect_flags(struct obd_export *exp)
	279	{
	280	return *exp_connect_flags_ptr(exp);
	281	}
	282
	283	static inline int exp_max_brw_size(struct obd_export *exp)
	284	{
	285	LASSERT(exp != NULL);
	286	if (exp_connect_flags(exp) & OBD_CONNECT_BRW_SIZE)
	287	return exp->exp_connect_data.ocd_brw_size;
	288
	289	return ONE_MB_BRW_SIZE;
	290	}
	291
	292	static inline int exp_connect_multibulk(struct obd_export *exp)
	293	{
	294	return exp_max_brw_size(exp) > ONE_MB_BRW_SIZE;
	295	}
	296
b2d201bd	297	static inline int exp_expired(struct obd_export *exp, long age)
d7e09d03 PT	298	{
d7e09d03 PT	299	LASSERT(exp->exp_delayed);
699503bc GKH	300	return time_before(cfs_time_add(exp->exp_last_request_time, age),
699503bc GKH	301	get_seconds());
d7e09d03 PT	302	}
	303
	304	static inline int exp_connect_cancelset(struct obd_export *exp)
	305	{
	306	LASSERT(exp != NULL);
	307	return !!(exp_connect_flags(exp) & OBD_CONNECT_CANCELSET);
	308	}
	309
	310	static inline int exp_connect_lru_resize(struct obd_export *exp)
	311	{
	312	LASSERT(exp != NULL);
	313	return !!(exp_connect_flags(exp) & OBD_CONNECT_LRU_RESIZE);
	314	}
	315
	316	static inline int exp_connect_rmtclient(struct obd_export *exp)
	317	{
	318	LASSERT(exp != NULL);
	319	return !!(exp_connect_flags(exp) & OBD_CONNECT_RMT_CLIENT);
	320	}
	321
	322	static inline int client_is_remote(struct obd_export *exp)
	323	{
	324	struct obd_import *imp = class_exp2cliimp(exp);
	325
	326	return !!(imp->imp_connect_data.ocd_connect_flags &
	327	OBD_CONNECT_RMT_CLIENT);
	328	}
	329
	330	static inline int exp_connect_vbr(struct obd_export *exp)
	331	{
	332	LASSERT(exp != NULL);
	333	LASSERT(exp->exp_connection);
	334	return !!(exp_connect_flags(exp) & OBD_CONNECT_VBR);
	335	}
	336
	337	static inline int exp_connect_som(struct obd_export *exp)
	338	{
	339	LASSERT(exp != NULL);
	340	return !!(exp_connect_flags(exp) & OBD_CONNECT_SOM);
	341	}
	342
	343	static inline int exp_connect_umask(struct obd_export *exp)
	344	{
	345	return !!(exp_connect_flags(exp) & OBD_CONNECT_UMASK);
	346	}
	347
	348	static inline int imp_connect_lru_resize(struct obd_import *imp)
	349	{
	350	struct obd_connect_data *ocd;
	351
	352	LASSERT(imp != NULL);
	353	ocd = &imp->imp_connect_data;
	354	return !!(ocd->ocd_connect_flags & OBD_CONNECT_LRU_RESIZE);
	355	}
	356
	357	static inline int exp_connect_layout(struct obd_export *exp)
	358	{
	359	return !!(exp_connect_flags(exp) & OBD_CONNECT_LAYOUTLOCK);
	360	}
	361
	362	static inline bool exp_connect_lvb_type(struct obd_export *exp)
	363	{
	364	LASSERT(exp != NULL);
	365	if (exp_connect_flags(exp) & OBD_CONNECT_LVB_TYPE)
366	return true;
367	else
368	return false;
369	}
370
371	static inline bool imp_connect_lvb_type(struct obd_import *imp)
372	{
373	struct obd_connect_data *ocd;
374
375	LASSERT(imp != NULL);
376	ocd = &imp->imp_connect_data;
377	if (ocd->ocd_connect_flags & OBD_CONNECT_LVB_TYPE)
378	return true;
379	else
380	return false;
381	}
382
6caea2f9 AL	383	static inline __u64 exp_connect_ibits(struct obd_export *exp)
	384	{
	385	struct obd_connect_data *ocd;
	386
	387	ocd = &exp->exp_connect_data;
	388	return ocd->ocd_ibits_known;
	389	}
	390
63d42578 HZ	391	static inline bool imp_connect_disp_stripe(struct obd_import *imp)
	392	{
	393	struct obd_connect_data *ocd;
	394
	395	LASSERT(imp != NULL);
	396	ocd = &imp->imp_connect_data;
	397	return ocd->ocd_connect_flags & OBD_CONNECT_DISP_STRIPE;
	398	}
	399
d7e09d03 PT	400	extern struct obd_export class_conn2export(struct lustre_handle conn);
	401	extern struct obd_device class_conn2obd(struct lustre_handle conn);
	402
	403	/** @} export */
	404
	405	#endif /* __EXPORT_H */
	406	/** @} obd_export */