From c087025f22ff04b0530a1220064b4825b17bb8e4 Mon Sep 17 00:00:00 2001 From: John Spray Date: Tue, 17 Mar 2015 12:29:31 +0000 Subject: [PATCH] mds: improved doxygen comments in StrayManager Signed-off-by: John Spray --- src/mds/StrayManager.cc | 100 +------------------------- src/mds/StrayManager.h | 155 ++++++++++++++++++++++++++++++++++++++-- 2 files changed, 154 insertions(+), 101 deletions(-) diff --git a/src/mds/StrayManager.cc b/src/mds/StrayManager.cc index 6c2294974fef1..c9423673ddc3e 100644 --- a/src/mds/StrayManager.cc +++ b/src/mds/StrayManager.cc @@ -75,12 +75,6 @@ public: } }; -/** - * Purge a dentry from a stray directory. This function - * is called once eval_stray is satisfied and StrayManager - * throttling is also satisfied. There is no going back - * at this stage! - */ void StrayManager::purge(CDentry *dn, uint32_t op_allowance) { CDentry::linkage_t *dnl = dn->get_projected_linkage(); @@ -203,11 +197,6 @@ public: } }; -/** - * Completion handler for a Filer::purge on a stray inode. - * - * - */ void StrayManager::_purge_stray_purged( CDentry *dn, uint32_t ops_allowance, bool only_head) { @@ -320,15 +309,6 @@ void StrayManager::_purge_stray_logged(CDentry *dn, version_t pdv, LogSegment *l } } - -/** - * Enqueue a purge operation on a dentry that has passed the tests - * in eval_stray. This may start the operation inline if the throttle - * allowances are already available. - * - * @param trunc false to purge dentry (normal), true to just truncate - * inode (snapshots) - */ void StrayManager::enqueue(CDentry *dn, bool trunc) { CDentry::linkage_t *dnl = dn->get_projected_linkage(); @@ -365,11 +345,6 @@ void StrayManager::enqueue(CDentry *dn, bool trunc) } } - -/** - * Iteratively call _consume on items from the ready_for_purge - * list until it returns false (throttle limit reached) - */ void StrayManager::_advance() { std::list::iterator i; @@ -386,10 +361,9 @@ void StrayManager::_advance() ready_for_purge.erase(ready_for_purge.begin(), i); } -/** - * Attempt to purge an inode, if throttling permits - * it. Note that there are compromises to how - * the throttling works, in interests of simplicity: +/* + * Note that there are compromises to how throttling + * is implemented here, in the interests of simplicity: * * If insufficient ops are available to execute * the next item on the queue, we block even if * there are items further down the queue requiring @@ -404,9 +378,6 @@ void StrayManager::_advance() * required by a single inode is greater than the * limit, for example directories with very many * fragments. - * - * Return true if we successfully consumed resource, - * false if insufficient resource was available. */ bool StrayManager::_consume(CDentry *dn, bool trunc, uint32_t ops_required) { @@ -451,13 +422,6 @@ bool StrayManager::_consume(CDentry *dn, bool trunc, uint32_t ops_required) return true; } - -/** - * Return the maximum number of concurrent RADOS ops that - * may be executed while purging this inode. - * - * @param trunc true if it's a truncate, false if it's a purge - */ uint32_t StrayManager::_calculate_ops_required(CInode *in, bool trunc) { uint32_t ops_required = 0; @@ -550,19 +514,6 @@ struct C_MDC_EvalStray : public StrayManagerContext { } }; -/** - * Evaluate a stray dentry for purging or reintegration. - * - * If the inode has no linkage, and no more references, then - * we may decide to purge it. - * - * If the inode still has linkage, then it means someone else - * (a hard link) is still referring to it, and we should - * think about reintegrating that inode into the remote dentry. - * - * @returns true if the dentry will be purged (caller should never - * take more refs after this happens), else false. - */ bool StrayManager::eval_stray(CDentry *dn, bool delay) { dout(10) << "eval_stray " << *dn << dendl; @@ -717,17 +668,6 @@ void StrayManager::eval_remote_stray(CDentry *stray_dn, CDentry *remote_dn) } } - - -/** - * When hard links exist to an inode whose primary dentry - * is unlinked, the inode gets a stray primary dentry. - * - * We may later "reintegrate" the inode into a remaining - * non-stray dentry (one of what was previously a remote - * dentry) by issuing a rename from the stray to the other - * dentry. - */ void StrayManager::reintegrate_stray(CDentry *straydn, CDentry *rdn) { dout(10) << __func__ << " " << *straydn << " into " << *rdn << dendl; @@ -748,23 +688,6 @@ void StrayManager::reintegrate_stray(CDentry *straydn, CDentry *rdn) mds->send_message_mds(req, rdn->authority().first); } - -/** - * Given a dentry within one of my stray directories, - * send it off to a stray directory in another MDS. - * - * This is for use: - * * Case A: when shutting down a rank, we migrate strays - * away from ourselves rather than waiting for purge - * * Case B: when a client request has a trace that refers to - * a stray inode on another MDS, we migrate that inode from - * there to here, in order that we can later re-integrate it - * here. - * - * In case B, the receiver should be calling into eval_stray - * on completion of mv (i.e. inode put), resulting in a subsequent - * reintegration. - */ void StrayManager::migrate_stray(CDentry *dn, mds_rank_t to) { CInode *in = dn->get_linkage()->get_inode(); @@ -803,15 +726,6 @@ void StrayManager::migrate_stray(CDentry *dn, mds_rank_t to) update_op_limit(); } - -/** - * For any strays that are enqueued for purge, but - * currently blocked on throttling, clear their - * purging status. Used during MDS rank shutdown - * so that it can migrate these strays instead - * of waiting for them to trickle through the - * queue. - */ void StrayManager::abort_queue() { for (std::list::iterator i = ready_for_purge.begin(); @@ -889,11 +803,6 @@ void StrayManager::truncate(CDentry *dn, uint32_t op_allowance) gather.activate(); } - -/** - * Callback: we have logged the update to an inode's metadata - * reflecting it's newly-zeroed length. - */ void StrayManager::_truncate_stray_logged(CDentry *dn, LogSegment *ls) { CInode *in = dn->get_projected_linkage()->get_inode(); @@ -919,9 +828,6 @@ const char** StrayManager::get_tracked_conf_keys() const return KEYS; } - -// Subscribe to the per-PG ops throttle config event, and do a cool calculation -// of (throttle * pg_num / (mds_num)) void StrayManager::handle_conf_change(const struct md_config_t *conf, const std::set &changed) { diff --git a/src/mds/StrayManager.h b/src/mds/StrayManager.h index a1e3bc02bfc0e..ca5c612981c30 100644 --- a/src/mds/StrayManager.h +++ b/src/mds/StrayManager.h @@ -57,9 +57,26 @@ class StrayManager : public md_config_obs_t uint64_t num_strays_delayed; void truncate(CDentry *dn, uint32_t op_allowance); + + /** + * Purge a dentry from a stray directory. This function + * is called once eval_stray is satisfied and StrayManager + * throttling is also satisfied. There is no going back + * at this stage! + */ void purge(CDentry *dn, uint32_t op_allowance); + + /** + * Completion handler for a Filer::purge on a stray inode. + */ void _purge_stray_purged(CDentry *dn, uint32_t ops, bool only_head); + void _purge_stray_logged(CDentry *dn, version_t pdv, LogSegment *ls); + + /** + * Callback: we have logged the update to an inode's metadata + * reflecting it's newly-zeroed length. + */ void _truncate_stray_logged(CDentry *dn, LogSegment *ls); friend class StrayManagerIOContext; @@ -69,30 +86,160 @@ class StrayManager : public md_config_obs_t friend class C_TruncateStrayLogged; friend class C_IO_PurgeStrayPurged; + /** + * Enqueue a purge operation on a dentry that has passed the tests + * in eval_stray. This may start the operation inline if the throttle + * allowances are already available. + * + * @param trunc false to purge dentry (normal), true to just truncate + * inode (snapshots) + */ + void enqueue(CDentry *dn, bool trunc); + + /** + * Iteratively call _consume on items from the ready_for_purge + * list until it returns false (throttle limit reached) + */ void _advance(); + + /** + * Attempt to purge an inode, if throttling permits + * its. + * + * Return true if we successfully consumed resource, + * false if insufficient resource was available. + */ bool _consume(CDentry *dn, bool trunc, uint32_t ops_required); + + /** + * Return the maximum number of concurrent RADOS ops that + * may be executed while purging this inode. + * + * @param trunc true if it's a truncate, false if it's a purge + */ uint32_t _calculate_ops_required(CInode *in, bool trunc); + /** + * When hard links exist to an inode whose primary dentry + * is unlinked, the inode gets a stray primary dentry. + * + * We may later "reintegrate" the inode into a remaining + * non-stray dentry (one of what was previously a remote + * dentry) by issuing a rename from the stray to the other + * dentry. + */ void reintegrate_stray(CDentry *dn, CDentry *rlink); - // My public interface is for consumption by MDCache public: + StrayManager(MDS *mds); + void set_logger(PerfCounters *l) {logger = l;} - void enqueue(CDentry *dn, bool trunc); + /** + * Where eval_stray was previously invoked with delay=true, call + * eval_stray again for any dentries that were put on the + * delayed_eval_stray list as a result of the original call. + * + * Used so that various places can call eval_stray(delay=true) during + * an operation to identify dentries of interest, and then call + * this function later during trim in order to do the final + * evaluation (and resulting actions) while not in the middle of another + * metadata operation. + */ void advance_delayed(); + + /** + * Evaluate a stray dentry for purging or reintegration. + * + * purging: If the inode has no linkage, and no more references, then + * we may decide to purge it. + * + * reintegration: If the inode still has linkage, then it means someone else + * (a hard link) is still referring to it, and we should + * think about reintegrating that inode into the remote dentry. + * + * @returns true if the dentry will be purged (caller should never + * take more refs after this happens), else false. + */ bool eval_stray(CDentry *dn, bool delay=false); + + /** + * When a metadata op touches a remote dentry that points to + * a stray, call in here to evaluate it for migration (move + * a stray residing on another MDS to this MDS) or reintegration + * (move a stray dentry's inode into a non-stray hardlink dentry and + * clean up the stray). + * + * @param stray_dn a stray dentry whose inode has been referenced + * by a remote dentry + * @param remote_dn (optional) which remote dentry was touched + * in an operation that led us here: this is used + * as a hint for which remote to reintegrate into + * if there are multiple remotes. + */ void eval_remote_stray(CDentry *stray_dn, CDentry *remote_dn=NULL); + + /** + * Given a dentry within one of my stray directories, + * send it off to a stray directory in another MDS. + * + * This is for use: + * * Case A: when shutting down a rank, we migrate strays + * away from ourselves rather than waiting for purge + * * Case B: when a client request has a trace that refers to + * a stray inode on another MDS, we migrate that inode from + * there to here, in order that we can later re-integrate it + * here. + * + * In case B, the receiver should be calling into eval_stray + * on completion of mv (i.e. inode put), resulting in a subsequent + * reintegration. + */ void migrate_stray(CDentry *dn, mds_rank_t dest); - StrayManager(MDS *mds); - void set_logger(PerfCounters *l) {logger = l;} + /** + * Update stats to reflect a newly created stray dentry. Needed + * because stats on strays live here, but creation happens + * in Server or MDCache. For our purposes "creation" includes + * loading a stray from a dirfrag and migrating a stray from + * another MDS, in addition to creations per-se. + */ void notify_stray_created(); + + /** + * Update stats to reflect a removed stray dentry. Needed because + * stats on strays live here, but removal happens in Server or + * MDCache. Also includes migration (rename) of strays from + * this MDS to another MDS. + */ void notify_stray_removed(); + + /** + * For any strays that are enqueued for purge, but + * currently blocked on throttling, clear their + * purging status. Used during MDS rank shutdown + * so that it can migrate these strays instead + * of waiting for them to trickle through the + * queue. + */ void abort_queue(); + /* + * Calculate our local RADOS op throttle limit based on + * (mds_max_purge_ops_per_pg / number_of_mds) * number_of_pg + * + * Call this whenever one of those operands changes. + */ void update_op_limit(); + + /** + * Subscribe to changes on mds_max_purge_ops + */ virtual const char** get_tracked_conf_keys() const; + + /** + * Call update_op_limit if mds_max_purge_ops changes + */ virtual void handle_conf_change(const struct md_config_t *conf, const std::set &changed); }; -- 2.39.5