* Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved.
* Use is subject to license terms.
*
- * Copyright (c) 2011, 2012, Intel Corporation.
+ * Copyright (c) 2011, 2013, Intel Corporation.
*/
/*
* This file is part of Lustre, http://www.lustre.org/
struct ldlm_res_id;
struct ptlrpc_request_set;
extern int test_req_buffer_pressure;
+extern struct list_head ptlrpc_all_services;
extern struct mutex ptlrpc_all_services_mutex;
int ptlrpc_start_thread(struct ptlrpc_service_part *svcpt, int wait);
int ptlrpcd_start(int index, int max, const char *name, struct ptlrpcd_ctl *pc);
/* client.c */
+void ptlrpc_at_adj_net_latency(struct ptlrpc_request *req,
+ unsigned int service_time);
struct ptlrpc_bulk_desc *ptlrpc_new_bulk(unsigned npages, unsigned max_brw,
unsigned type, unsigned portal);
+int ptlrpc_request_cache_init(void);
+void ptlrpc_request_cache_fini(void);
+struct ptlrpc_request *ptlrpc_request_cache_alloc(gfp_t flags);
+void ptlrpc_request_cache_free(struct ptlrpc_request *req);
void ptlrpc_init_xid(void);
/* events.c */
*/
struct nrs_core {
/**
- * Protects nrs_core::nrs_heads, nrs_core::nrs_policies, serializes
- * external policy registration/unregistration, and NRS core lprocfs
- * operations.
+ * Protects nrs_core::nrs_policies, serializes external policy
+ * registration/unregistration, and NRS core lprocfs operations.
*/
struct mutex nrs_mutex;
- /* XXX: This is just for liblustre. Remove the #if defined directive
- * when the * "cfs_" prefix is dropped from cfs_list_head. */
-#if defined (__linux__) && defined(__KERNEL__)
- /**
- * List of all NRS heads on all service partitions of all services;
- * protected by nrs_core::nrs_mutex.
- */
- struct list_head nrs_heads;
/**
* List of all policy descriptors registered with NRS core; protected
* by nrs_core::nrs_mutex.
*/
struct list_head nrs_policies;
-#else
- struct cfs_list_head nrs_heads;
- struct cfs_list_head nrs_policies;
-#endif
-
};
int ptlrpc_service_nrs_setup(struct ptlrpc_service *svc);
void ptlrpc_nrs_req_initialize(struct ptlrpc_service_part *svcpt,
struct ptlrpc_request *req, bool hp);
void ptlrpc_nrs_req_finalize(struct ptlrpc_request *req);
-void ptlrpc_nrs_req_start_nolock(struct ptlrpc_request *req);
void ptlrpc_nrs_req_stop_nolock(struct ptlrpc_request *req);
void ptlrpc_nrs_req_add(struct ptlrpc_service_part *svcpt,
struct ptlrpc_request *req, bool hp);
+
struct ptlrpc_request *
-ptlrpc_nrs_req_poll_nolock(struct ptlrpc_service_part *svcpt,
- bool hp);
+ptlrpc_nrs_req_get_nolock0(struct ptlrpc_service_part *svcpt, bool hp,
+ bool peek, bool force);
+
+static inline struct ptlrpc_request *
+ptlrpc_nrs_req_get_nolock(struct ptlrpc_service_part *svcpt, bool hp,
+ bool force)
+{
+ return ptlrpc_nrs_req_get_nolock0(svcpt, hp, false, force);
+}
+
+static inline struct ptlrpc_request *
+ptlrpc_nrs_req_peek_nolock(struct ptlrpc_service_part *svcpt, bool hp)
+{
+ return ptlrpc_nrs_req_get_nolock0(svcpt, hp, true, false);
+}
+
void ptlrpc_nrs_req_del_nolock(struct ptlrpc_request *req);
bool ptlrpc_nrs_req_pending_nolock(struct ptlrpc_service_part *svcpt, bool hp);
+bool ptlrpc_nrs_req_throttling_nolock(struct ptlrpc_service_part *svcpt,
+ bool hp);
-int ptlrpc_nrs_policy_control(struct ptlrpc_service *svc,
+int ptlrpc_nrs_policy_control(const struct ptlrpc_service *svc,
enum ptlrpc_nrs_queue_type queue, char *name,
enum ptlrpc_nrs_ctl opc, bool single, void *arg);
int ptlrpc_nrs_init(void);
void ptlrpc_nrs_fini(void);
-static inline int
-nrs_svcpt_has_hp(struct ptlrpc_service_part *svcpt)
+static inline bool nrs_svcpt_has_hp(const struct ptlrpc_service_part *svcpt)
{
return svcpt->scp_nrs_hp != NULL;
}
-static inline int
-nrs_svc_has_hp(struct ptlrpc_service *svc)
+static inline bool nrs_svc_has_hp(const struct ptlrpc_service *svc)
{
/**
* If the first service partition has an HP NRS head, all service
return nrs_svcpt_has_hp(svc->srv_parts[0]);
}
-static inline struct ptlrpc_nrs *
-nrs_svcpt2nrs(struct ptlrpc_service_part *svcpt, bool hp)
+static inline
+struct ptlrpc_nrs *nrs_svcpt2nrs(struct ptlrpc_service_part *svcpt, bool hp)
{
LASSERT(ergo(hp, nrs_svcpt_has_hp(svcpt)));
return hp ? svcpt->scp_nrs_hp : &svcpt->scp_nrs_reg;
}
-static inline int
-nrs_pol2cptid(struct ptlrpc_nrs_policy *policy)
+static inline int nrs_pol2cptid(const struct ptlrpc_nrs_policy *policy)
{
return policy->pol_nrs->nrs_svcpt->scp_cpt;
}
-static inline struct ptlrpc_service *
-nrs_pol2svc(struct ptlrpc_nrs_policy *policy)
+static inline
+struct ptlrpc_service *nrs_pol2svc(struct ptlrpc_nrs_policy *policy)
{
return policy->pol_nrs->nrs_svcpt->scp_service;
}
-static inline struct ptlrpc_service_part *
-nrs_pol2svcpt(struct ptlrpc_nrs_policy *policy)
+static inline
+struct ptlrpc_service_part *nrs_pol2svcpt(struct ptlrpc_nrs_policy *policy)
{
return policy->pol_nrs->nrs_svcpt;
}
-static inline struct cfs_cpt_table *
-nrs_pol2cptab(struct ptlrpc_nrs_policy *policy)
+static inline
+struct cfs_cpt_table *nrs_pol2cptab(struct ptlrpc_nrs_policy *policy)
{
return nrs_pol2svc(policy)->srv_cptable;
}
return nrq->nr_res_ptrs[nrq->nr_res_idx];
}
-static inline struct ptlrpc_nrs_policy *
-nrs_request_policy(struct ptlrpc_nrs_request *nrq)
+static inline
+struct ptlrpc_nrs_policy *nrs_request_policy(struct ptlrpc_nrs_request *nrq)
{
return nrs_request_resource(nrq)->res_policy;
}
+#define NRS_LPROCFS_QUANTUM_NAME_REG "reg_quantum:"
+#define NRS_LPROCFS_QUANTUM_NAME_HP "hp_quantum:"
+
+/**
+ * the maximum size of nrs_crrn_client::cc_quantum and nrs_orr_data::od_quantum.
+ */
+#define LPROCFS_NRS_QUANTUM_MAX 65535
+
+/**
+ * Max valid command string is the size of the labels, plus "65535" twice, plus
+ * a separating space character.
+ */
+#define LPROCFS_NRS_WR_QUANTUM_MAX_CMD \
+ sizeof(NRS_LPROCFS_QUANTUM_NAME_REG __stringify(LPROCFS_NRS_QUANTUM_MAX) " " \
+ NRS_LPROCFS_QUANTUM_NAME_HP __stringify(LPROCFS_NRS_QUANTUM_MAX))
+
/* recovd_thread.c */
int ptlrpc_expire_one_request(struct ptlrpc_request *req, int async_unlink);
/* pers.c */
void ptlrpc_fill_bulk_md(lnet_md_t *md, struct ptlrpc_bulk_desc *desc,
int mdcnt);
-void ptlrpc_add_bulk_page(struct ptlrpc_bulk_desc *desc, cfs_page_t *page,
+void ptlrpc_add_bulk_page(struct ptlrpc_bulk_desc *desc, struct page *page,
int pageoffset, int len);
/* pack_generic.c */
void ptlrpc_pinger_commit_expected(struct obd_import *imp);
void ptlrpc_pinger_wake_up(void);
void ptlrpc_ping_import_soon(struct obd_import *imp);
-#ifdef __KERNEL__
int ping_evictor_wake(struct obd_export *exp);
-#else
-#define ping_evictor_wake(exp) 1
-#endif
/* sec_null.c */
int sptlrpc_null_init(void);
/* sec_bulk.c */
int sptlrpc_enc_pool_init(void);
void sptlrpc_enc_pool_fini(void);
-int sptlrpc_proc_read_enc_pool(char *page, char **start, off_t off, int count,
- int *eof, void *data);
+int sptlrpc_proc_enc_pool_seq_show(struct seq_file *m, void *v);
/* sec_lproc.c */
int sptlrpc_lproc_init(void);
int sptlrpc_conf_init(void);
void sptlrpc_conf_fini(void);
+struct dentry;
+struct vfsmount;
+int lustre_rename(struct dentry *dir, struct vfsmount *mnt, char *old_name,
+ char *new_name);
+
/* sec.c */
int sptlrpc_init(void);
void sptlrpc_fini(void);
-/* recov_thread.c */
-int llog_recov_init(void);
-void llog_recov_fini(void);
-
static inline int ll_rpc_recoverable_error(int rc)
{
- return (rc == -ENOTCONN || rc == -ENODEV);
+ return (rc == -ENOTCONN || rc == -ENODEV);
}
#ifdef HAVE_SERVER_SUPPORT
int tgt_mod_init(void);
void tgt_mod_exit(void);
-#else
+int nodemap_mod_init(void);
+void nodemap_mod_exit(void);
+#else /* HAVE_SERVER_SUPPORT */
static inline int tgt_mod_init(void)
{
return 0;
{
return;
}
-#endif
+
+static inline int nodemap_mod_init(void)
+{
+ return 0;
+}
+
+static inline void nodemap_mod_exit(void)
+{
+ return;
+}
+#endif /* !HAVE_SERVER_SUPPORT */
static inline void ptlrpc_reqset_put(struct ptlrpc_request_set *set)
{
- if (cfs_atomic_dec_and_test(&set->set_refcount))
- OBD_FREE_PTR(set);
+ if (atomic_dec_and_test(&set->set_refcount))
+ OBD_FREE_PTR(set);
}
#endif /* PTLRPC_INTERNAL_H */
git://git.whamcloud.com / fs / lustre-release.git / blobdiff