X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;f=lustre%2Fquota%2Fqsd_internal.h;h=518c525afa6c37114a086050494c719dfd11ac6b;hb=24c4f3a53b9ca5ec2c6f8c71e166f579d8838137;hp=c8295880816e326ce0ed5ca56c2f41e8a1de5bf1;hpb=318fd8d197ff607a032dac6ed9cb15922e44a53f;p=fs%2Flustre-release.git diff --git a/lustre/quota/qsd_internal.h b/lustre/quota/qsd_internal.h index c829588..518c525 100644 --- a/lustre/quota/qsd_internal.h +++ b/lustre/quota/qsd_internal.h @@ -21,7 +21,7 @@ * GPL HEADER END */ /* - * Copyright (c) 2012 Whamcloud, Inc. + * Copyright (c) 2012, 2013, Intel Corporation. * Use is subject to license terms. */ @@ -31,6 +31,7 @@ #define _QSD_INTERNAL_H struct qsd_type_info; +struct qsd_fsinfo; /* * A QSD instance implements quota enforcement support for a given OSD. @@ -52,7 +53,13 @@ struct qsd_instance { /* procfs directory where information related to the underlying slaves * are exported */ - cfs_proc_dir_entry_t *qsd_proc; + struct proc_dir_entry *qsd_proc; + + /* export used for the connection to quota master */ + struct obd_export *qsd_exp; + + /* ldlm namespace used for quota locks */ + struct ldlm_namespace *qsd_ns; /* on-disk directory where to store index files for this qsd instance */ struct dt_object *qsd_root; @@ -65,18 +72,49 @@ struct qsd_instance { * future. For the time being, we can just use an array. */ struct qsd_qtype_info *qsd_type_array[MAXQUOTAS]; + /* per-filesystem quota information */ + struct qsd_fsinfo *qsd_fsinfo; + + /* link into qfs_qsd_list of qfs_fsinfo */ + struct list_head qsd_link; + + /* list of lqe entry which might need quota space adjustment */ + struct list_head qsd_adjust_list; + + /* lock protecting adjust list */ + spinlock_t qsd_adjust_lock; + + /* dedicated thread for updating slave index files. */ + struct ptlrpc_thread qsd_upd_thread; + + /* list of update tasks */ + struct list_head qsd_upd_list; + /* r/w spinlock protecting: * - the state flags * - the qsd update list * - the deferred list - * - flags of the qsd_qtype_info - * - * probably way too much :( - */ - cfs_rwlock_t qsd_lock; + * - flags of the qsd_qtype_info */ + rwlock_t qsd_lock; + + /* Default quota settings which apply to all identifiers */ + /* when blk qunit reaches this value, later write reqs from client + * should be sync. b=16642 */ + unsigned long qsd_sync_threshold; + + /* how long a service thread can wait for quota space. + * value dynamically computed from obd_timeout and at_max if not + * enforced here (via procfs) */ + int qsd_timeout; unsigned long qsd_is_md:1, /* managing quota for mdt */ - qsd_stopping:1; /* qsd_instance is stopping */ + qsd_started:1, /* instance is now started */ + qsd_prepared:1, /* qsd_prepare() successfully + * called */ + qsd_exp_valid:1,/* qsd_exp is now valid */ + qsd_stopping:1, /* qsd_instance is stopping */ + qsd_acct_failed:1; /* failed to set up acct + * for one quota type */ }; /* @@ -86,7 +124,7 @@ struct qsd_instance { */ struct qsd_qtype_info { /* reference count incremented by each user of this structure */ - cfs_atomic_t qqi_ref; + atomic_t qqi_ref; /* quota type, either USRQUOTA or GRPQUOTA * immutable after creation. */ @@ -95,6 +133,9 @@ struct qsd_qtype_info { /* Global index FID to use for this quota type */ struct lu_fid qqi_fid; + /* Slave index FID allocated by the master */ + struct lu_fid qqi_slv_fid; + /* back pointer to qsd device * immutable after creation. */ struct qsd_instance *qqi_qsd; @@ -111,6 +152,21 @@ struct qsd_qtype_info { __u64 qqi_slv_ver; /* slave index version */ __u64 qqi_glb_ver; /* global index version */ + /* per quota ID information. All lquota entry are kept in a hash table + * and read from disk on cache miss. */ + struct lquota_site *qqi_site; + + /* Reintegration thread */ + struct ptlrpc_thread qqi_reint_thread; + + /* statistics on operations performed by this slave */ + struct lprocfs_stats *qqi_stats; + + /* deferred update for the global index copy */ + struct list_head qqi_deferred_glb; + /* deferred update for the slave index copy */ + struct list_head qqi_deferred_slv; + /* Various flags representing the current state of the slave for this * quota type. */ unsigned long qqi_glb_uptodate:1, /* global index uptodate @@ -124,6 +180,28 @@ struct qsd_qtype_info { }; /* + * Per-filesystem quota information + * Structure tracking quota enforcement status on a per-filesystem basis + */ +struct qsd_fsinfo { + /* filesystem name */ + char qfs_name[MTI_NAME_MAXLEN]; + + /* what type of quota is enabled for each resource type. */ + unsigned int qfs_enabled[LQUOTA_NR_RES]; + + /* list of all qsd_instance for this fs */ + struct list_head qfs_qsd_list; + struct mutex qfs_mutex; + + /* link to the global quota fsinfo list. */ + struct list_head qfs_link; + + /* reference count */ + int qfs_ref; +}; + +/* * Helper functions & prototypes */ @@ -137,25 +215,28 @@ static inline struct qsd_qtype_info *lqe2qqi(struct lquota_entry *lqe) /* qqi_getref/putref is used to track users of a qqi structure */ static inline void qqi_getref(struct qsd_qtype_info *qqi) { - cfs_atomic_inc(&qqi->qqi_ref); + atomic_inc(&qqi->qqi_ref); } static inline void qqi_putref(struct qsd_qtype_info *qqi) { - LASSERT(cfs_atomic_read(&qqi->qqi_ref) > 0); - cfs_atomic_dec(&qqi->qqi_ref); + LASSERT(atomic_read(&qqi->qqi_ref) > 0); + atomic_dec(&qqi->qqi_ref); } -/* all kind of operations supported by qsd_dqacq() */ -enum qsd_ops { - QSD_ADJ, /* adjust quota space based on current qunit */ - QSD_ACQ, /* acquire space for requests */ - QSD_REL, /* release all space quota space uncondionnally */ - QSD_REP, /* report space usage during reintegration */ -}; - #define QSD_RES_TYPE(qsd) ((qsd)->qsd_is_md ? LQUOTA_RES_MD : LQUOTA_RES_DT) +/* udpate record for slave & global index copy */ +struct qsd_upd_rec { + struct list_head qur_link; /* link into qsd_upd_list */ + union lquota_id qur_qid; + union lquota_rec qur_rec; + struct qsd_qtype_info *qur_qqi; + struct lquota_entry *qur_lqe; + __u64 qur_ver; + bool qur_global; +}; + /* Common data shared by qsd-level handlers. This is allocated per-thread to * reduce stack consumption. */ struct qsd_thread_info { @@ -166,7 +247,7 @@ struct qsd_thread_info { struct ldlm_enqueue_info qti_einfo; struct lustre_handle qti_lockh; __u64 qti_slv_ver; - union ldlm_wire_lvb qti_lvb; + struct lquota_lvb qti_lvb; union { struct quota_body qti_body; struct idx_info qti_ii; @@ -190,6 +271,24 @@ struct qsd_thread_info *qsd_info(const struct lu_env *env) return info; } +/* helper function to check whether a given quota type is enabled */ +static inline int qsd_type_enabled(struct qsd_instance *qsd, int type) +{ + int enabled, pool; + + LASSERT(qsd != NULL); + LASSERT(type < MAXQUOTAS); + + if (qsd->qsd_fsinfo == NULL) + return 0; + + pool = qsd->qsd_is_md ? LQUOTA_RES_MD : LQUOTA_RES_DT; + enabled = qsd->qsd_fsinfo->qfs_enabled[pool - LQUOTA_FIRST_RES]; + + return enabled & (1 << type); +} + +/* helper function to set new qunit and compute associated qtune value */ static inline void qsd_set_qunit(struct lquota_entry *lqe, __u64 qunit) { if (lqe->lqe_qunit == qunit) @@ -218,6 +317,25 @@ static inline void qsd_set_qunit(struct lquota_entry *lqe, __u64 qunit) lqe->lqe_nopreacq = false; } +/* helper function to set/clear edquot flag */ +static inline void qsd_set_edquot(struct lquota_entry *lqe, bool edquot) +{ + lqe->lqe_edquot = edquot; + if (edquot) + lqe->lqe_edquot_time = cfs_time_current_64(); +} + +#define QSD_WB_INTERVAL 60 /* 60 seconds */ + +/* helper function calculating how long a service thread should be waiting for + * quota space */ +static inline int qsd_wait_timeout(struct qsd_instance *qsd) +{ + if (qsd->qsd_timeout != 0) + return qsd->qsd_timeout; + return min_t(int, at_max / 2, obd_timeout / 2); +} + /* qsd_entry.c */ extern struct lquota_entry_operations qsd_lqe_ops; int qsd_refresh_usage(const struct lu_env *, struct lquota_entry *); @@ -243,28 +361,34 @@ typedef void (*qsd_req_completion_t) (const struct lu_env *, struct qsd_qtype_info *, struct quota_body *, struct quota_body *, struct lustre_handle *, - union ldlm_wire_lvb *, void *, int); + struct lquota_lvb *, void *, int); int qsd_send_dqacq(const struct lu_env *, struct obd_export *, struct quota_body *, bool, qsd_req_completion_t, struct qsd_qtype_info *, struct lustre_handle *, struct lquota_entry *); int qsd_intent_lock(const struct lu_env *, struct obd_export *, struct quota_body *, bool, int, qsd_req_completion_t, - struct qsd_qtype_info *, union ldlm_wire_lvb *, void *); + struct qsd_qtype_info *, struct lquota_lvb *, void *); int qsd_fetch_index(const struct lu_env *, struct obd_export *, - struct idx_info *, unsigned int, cfs_page_t **, bool *); + struct idx_info *, unsigned int, struct page **, bool *); /* qsd_writeback.c */ void qsd_bump_version(struct qsd_qtype_info *, __u64, bool); void qsd_upd_schedule(struct qsd_qtype_info *, struct lquota_entry *, union lquota_id *, union lquota_rec *, __u64, bool); +/* qsd_config.c */ +struct qsd_fsinfo *qsd_get_fsinfo(char *, bool); +void qsd_put_fsinfo(struct qsd_fsinfo *); +int qsd_process_config(struct lustre_cfg *); /* qsd_handler.c */ -/* XXX to be replaced with real function once qsd_handler landed */ -static inline int qsd_dqacq(const struct lu_env *env, struct lquota_entry *lqe, - enum qsd_ops op) -{ - return 0; -} +int qsd_adjust(const struct lu_env *, struct lquota_entry *); +/* qsd_writeback.c */ +void qsd_upd_schedule(struct qsd_qtype_info *, struct lquota_entry *, + union lquota_id *, union lquota_rec *, __u64, bool); +void qsd_bump_version(struct qsd_qtype_info *, __u64, bool); +int qsd_start_upd_thread(struct qsd_instance *); +void qsd_stop_upd_thread(struct qsd_instance *); +void qsd_adjust_schedule(struct lquota_entry *, bool, bool); #endif /* _QSD_INTERNAL_H */