auth: If verbose_proctitle=yes, show auth request counts in ps.

 - wait: waiting for auth client to do something (either continue multistep
auth mechanism or issue master request for a finished auth)
 - passdb: waiting for passdb lookup to finish
 - userdb: waiting for userdb lookup to finish

--HG--
branch : HEAD

diff --git a/src/auth/auth-common.h b/src/auth/auth-common.h
index 06dca43d5e076458a6e99b0c6ef6b786ff290e2e..250a5c9a38278f4fb0386c22414a8c8fef910610 100644 (file)
--- a/src/auth/auth-common.h
+++ b/src/auth/auth-common.h
@@ -8,4 +8,6 @@ extern bool worker, shutdown_request;
 extern time_t process_start_time;
 extern struct auth_penalty *auth_penalty;
 
+void auth_refresh_proctitle(void);
+
 #endif

diff --git a/src/auth/auth-master-connection.c b/src/auth/auth-master-connection.c
index ac5e942d8d458105200319fe57d37f24ff1907ac..fb4ec380f00d78fb51d6dbadfe1fc6a90668d5a1 100644 (file)
--- a/src/auth/auth-master-connection.c
+++ b/src/auth/auth-master-connection.c
@@ -214,7 +214,7 @@ master_input_user(struct auth_master_connection *conn, const char *args)
                auth_request_log_info(auth_request, "userdb", "%s", error);
                user_callback(USERDB_RESULT_USER_UNKNOWN, auth_request);
        } else {
-               auth_request->state = AUTH_REQUEST_STATE_USERDB;
+               auth_request_set_state(auth_request, AUTH_REQUEST_STATE_USERDB);
                auth_request_lookup_user(auth_request, user_callback);
        }
        return TRUE;
@@ -274,7 +274,8 @@ master_input_pass(struct auth_master_connection *conn, const char *args)
                pass_callback(PASSDB_RESULT_USER_UNKNOWN,
                              NULL, 0, auth_request);
        } else {
-               auth_request->state = AUTH_REQUEST_STATE_MECH_CONTINUE;
+               auth_request_set_state(auth_request,
+                                      AUTH_REQUEST_STATE_MECH_CONTINUE);
                auth_request_lookup_credentials(auth_request, "",
                                                pass_callback);
        }

diff --git a/src/auth/auth-request-handler.c b/src/auth/auth-request-handler.c
index 3d8396a5088b101baaff26dcff6a23a7939ea711..2475addb1386e28a1ceb542dbd95cbf6635a6ed1 100644 (file)
--- a/src/auth/auth-request-handler.c
+++ b/src/auth/auth-request-handler.c
@@ -491,7 +491,7 @@ static void userdb_callback(enum userdb_result result,
 
        i_assert(request->state == AUTH_REQUEST_STATE_USERDB);
 
-       request->state = AUTH_REQUEST_STATE_FINISHED;
+       auth_request_set_state(request, AUTH_REQUEST_STATE_FINISHED);
 
        if (request->userdb_lookup_failed)
                result = USERDB_RESULT_INTERNAL_FAILURE;
@@ -566,7 +566,7 @@ void auth_request_handler_master_request(struct auth_request_handler *handler,
                /* the request isn't being referenced anywhere anymore,
                   so we can do a bit of kludging.. replace the request's
                   old client_id with master's id. */
-               request->state = AUTH_REQUEST_STATE_USERDB;
+               auth_request_set_state(request, AUTH_REQUEST_STATE_USERDB);
                request->id = id;
                request->context = handler;
                request->master = master;

diff --git a/src/auth/auth-request.c b/src/auth/auth-request.c
index bff76fc4bc1ab46ad7b50bef4067b2edd11b8df9..ad79957d5985f627f436ecf2afbce6ecbff28d21 100644 (file)
--- a/src/auth/auth-request.c
+++ b/src/auth/auth-request.c
@@ -26,6 +26,8 @@
 
 #define CACHED_PASSWORD_SCHEME "SHA1"
 
+enum auth_request_state auth_request_state_count[AUTH_REQUEST_STATE_MAX];
+
 static void get_log_prefix(string_t *str, struct auth_request *auth_request,
                           const char *subsystem);
 
@@ -36,7 +38,9 @@ auth_request_new(const struct mech_module *mech,
        struct auth_request *request;
 
        request = mech->auth_new();
+
        request->state = AUTH_REQUEST_STATE_NEW;
+       auth_request_state_count[AUTH_REQUEST_STATE_NEW]++;
 
        request->refcount = 1;
        request->last_access = ioloop_time;
@@ -51,18 +55,34 @@ auth_request_new(const struct mech_module *mech,
 
 struct auth_request *auth_request_new_dummy(void)
 {
-       struct auth_request *auth_request;
+       struct auth_request *request;
        pool_t pool;
 
        pool = pool_alloconly_create("auth_request", 1024);
-       auth_request = p_new(pool, struct auth_request, 1);
-       auth_request->pool = pool;
+       request = p_new(pool, struct auth_request, 1);
+       request->pool = pool;
 
-       auth_request->refcount = 1;
-       auth_request->last_access = ioloop_time;
-       auth_request->set = global_auth_settings;
+       request->state = AUTH_REQUEST_STATE_NEW;
+       auth_request_state_count[AUTH_REQUEST_STATE_NEW]++;
 
-       return auth_request;
+       request->refcount = 1;
+       request->last_access = ioloop_time;
+       request->set = global_auth_settings;
+       return request;
+}
+
+void auth_request_set_state(struct auth_request *request,
+                           enum auth_request_state state)
+{
+       if (request->state == state)
+               return;
+
+       i_assert(auth_request_state_count[request->state] > 0);
+       auth_request_state_count[request->state]--;
+       auth_request_state_count[state]++;
+
+       request->state = state;
+       auth_refresh_proctitle();
 }
 
 void auth_request_init(struct auth_request *request)
@@ -91,7 +111,7 @@ void auth_request_success(struct auth_request *request,
                return;
        }
 
-       request->state = AUTH_REQUEST_STATE_FINISHED;
+       auth_request_set_state(request, AUTH_REQUEST_STATE_FINISHED);
        request->successful = TRUE;
        auth_request_refresh_last_access(request);
        request->callback(request, AUTH_CLIENT_RESULT_SUCCESS,
@@ -102,7 +122,7 @@ void auth_request_fail(struct auth_request *request)
 {
        i_assert(request->state == AUTH_REQUEST_STATE_MECH_CONTINUE);
 
-       request->state = AUTH_REQUEST_STATE_FINISHED;
+       auth_request_set_state(request, AUTH_REQUEST_STATE_FINISHED);
        auth_request_refresh_last_access(request);
        request->callback(request, AUTH_CLIENT_RESULT_FAILURE, NULL, 0);
 }
@@ -127,6 +147,9 @@ void auth_request_unref(struct auth_request **_request)
        if (--request->refcount > 0)
                return;
 
+       auth_request_state_count[request->state]--;
+       auth_refresh_proctitle();
+
        if (request->to_abort != NULL)
                timeout_remove(&request->to_abort);
        if (request->to_penalty != NULL)
@@ -224,7 +247,7 @@ void auth_request_initial(struct auth_request *request)
 {
        i_assert(request->state == AUTH_REQUEST_STATE_NEW);
 
-       request->state = AUTH_REQUEST_STATE_MECH_CONTINUE;
+       auth_request_set_state(request, AUTH_REQUEST_STATE_MECH_CONTINUE);
        request->mech->auth_initial(request, request->initial_response,
                                    request->initial_response_len);
 }
@@ -446,7 +469,7 @@ void auth_request_verify_plain_callback(enum passdb_result result,
 {
        i_assert(request->state == AUTH_REQUEST_STATE_PASSDB);
 
-       request->state = AUTH_REQUEST_STATE_MECH_CONTINUE;
+       auth_request_set_state(request, AUTH_REQUEST_STATE_MECH_CONTINUE);
 
        if (result != PASSDB_RESULT_INTERNAL_FAILURE)
                auth_request_save_cache(request, result);
@@ -526,7 +549,7 @@ void auth_request_verify_plain(struct auth_request *request,
                return;
        }
 
-       request->state = AUTH_REQUEST_STATE_PASSDB;
+       auth_request_set_state(request, AUTH_REQUEST_STATE_PASSDB);
        request->credentials_scheme = NULL;
 
        if (passdb->blocking)
@@ -569,7 +592,7 @@ void auth_request_lookup_credentials_callback(enum passdb_result result,
 
        i_assert(request->state == AUTH_REQUEST_STATE_PASSDB);
 
-       request->state = AUTH_REQUEST_STATE_MECH_CONTINUE;
+       auth_request_set_state(request, AUTH_REQUEST_STATE_MECH_CONTINUE);
 
        if (result != PASSDB_RESULT_INTERNAL_FAILURE)
                auth_request_save_cache(request, result);
@@ -622,7 +645,7 @@ void auth_request_lookup_credentials(struct auth_request *request,
                }
        }
 
-       request->state = AUTH_REQUEST_STATE_PASSDB;
+       auth_request_set_state(request, AUTH_REQUEST_STATE_PASSDB);
 
        if (passdb->iface.lookup_credentials == NULL) {
                /* this passdb doesn't support credentials */

diff --git a/src/auth/auth-request.h b/src/auth/auth-request.h
index 3d13a1ffd94d69f8ea8f1d399dee651ed0162e8a..5e9ba25d643365f166dfb2bb0a22727f79cd766f 100644 (file)
--- a/src/auth/auth-request.h
+++ b/src/auth/auth-request.h
@@ -13,7 +13,9 @@ enum auth_request_state {
        AUTH_REQUEST_STATE_PASSDB,
        AUTH_REQUEST_STATE_MECH_CONTINUE,
        AUTH_REQUEST_STATE_FINISHED,
-       AUTH_REQUEST_STATE_USERDB
+       AUTH_REQUEST_STATE_USERDB,
+
+       AUTH_REQUEST_STATE_MAX
 };
 
 typedef const char *
@@ -110,6 +112,8 @@ struct auth_request {
        /* ... mechanism specific data ... */
 };
 
+extern enum auth_request_state auth_request_state_count[AUTH_REQUEST_STATE_MAX];
+
 struct auth_request *
 auth_request_new(const struct mech_module *mech,
                 mech_callback_t *callback, void *context);
@@ -117,6 +121,9 @@ struct auth_request *auth_request_new_dummy(void);
 void auth_request_init(struct auth_request *request);
 struct auth *auth_request_get_auth(struct auth_request *request);
 
+void auth_request_set_state(struct auth_request *request,
+                           enum auth_request_state state);
+
 void auth_request_ref(struct auth_request *request);
 void auth_request_unref(struct auth_request **request);
 

diff --git a/src/auth/auth-settings.c b/src/auth/auth-settings.c
index a63f2e3bc2d5abaa3864327f6db76751c25b27ec..5dc8da36facd18b24ea787e615133f2cbe33bd8e 100644 (file)
--- a/src/auth/auth-settings.c
+++ b/src/auth/auth-settings.c
@@ -160,9 +160,12 @@ const struct setting_parser_info auth_userdb_setting_parser_info = {
 
 /* we're kind of kludging here to avoid "auth_" prefix in the struct fields */
 #undef DEF
+#undef DEF_NOPREFIX
 #undef DEFLIST
 #define DEF(type, name) \
        { type, "auth_"#name, offsetof(struct auth_settings, name), NULL }
+#define DEF_NOPREFIX(type, name) \
+       { type, #name, offsetof(struct auth_settings, name), NULL }
 #define DEFLIST(field, name, defines) \
        { SET_DEFLIST, name, offsetof(struct auth_settings, field), defines }
 
@@ -196,6 +199,8 @@ static const struct setting_define auth_setting_defines[] = {
        DEFLIST(passdbs, "passdb", &auth_passdb_setting_parser_info),
        DEFLIST(userdbs, "userdb", &auth_userdb_setting_parser_info),
 
+       DEF_NOPREFIX(SET_BOOL, verbose_proctitle),
+
        SETTING_DEFINE_LIST_END
 };
 
@@ -227,7 +232,9 @@ static const struct auth_settings auth_default_settings = {
        .worker_max_count = 30,
 
        .passdbs = ARRAY_INIT,
-       .userdbs = ARRAY_INIT
+       .userdbs = ARRAY_INIT,
+
+       .verbose_proctitle = FALSE
 };
 
 const struct setting_parser_info auth_setting_parser_info = {

diff --git a/src/auth/auth-settings.h b/src/auth/auth-settings.h
index 55dea737ebfabe5098fdd91329a27aef00ddc1a0..e1e69f2a60c9c6740b742ad73b52ff179bc6eb23 100644 (file)
--- a/src/auth/auth-settings.h
+++ b/src/auth/auth-settings.h
@@ -45,6 +45,8 @@ struct auth_settings {
        ARRAY_DEFINE(passdbs, struct auth_passdb_settings *);
        ARRAY_DEFINE(userdbs, struct auth_userdb_settings *);
 
+       bool verbose_proctitle;
+
        /* generated: */
        char username_chars_map[256];
        char username_translation_map[256];

diff --git a/src/auth/main.c b/src/auth/main.c
index 538c3223fb7b7b1936fe03abeb1b04c3ecde1717..d3627d6820778a8f6455b65ed1a865ee5a141179 100644 (file)
--- a/src/auth/main.c
+++ b/src/auth/main.c
@@ -10,6 +10,7 @@
 #include "sql-api.h"
 #include "module-dir.h"
 #include "randgen.h"
+#include "process-title.h"
 #include "settings-parser.h"
 #include "master-service.h"
 #include "master-service-settings.h"
@@ -45,6 +46,20 @@ static struct module *modules = NULL;
 static struct mechanisms_register *mech_reg;
 static ARRAY_DEFINE(listen_fd_types, enum auth_socket_type);
 
+void auth_refresh_proctitle(void)
+{
+       if (!global_auth_settings->verbose_proctitle)
+               return;
+
+       process_title_set(t_strdup_printf(
+               "[%u wait, %u passdb, %u userdb]",
+               auth_request_state_count[AUTH_REQUEST_STATE_NEW] +
+               auth_request_state_count[AUTH_REQUEST_STATE_MECH_CONTINUE] +
+               auth_request_state_count[AUTH_REQUEST_STATE_FINISHED],
+               auth_request_state_count[AUTH_REQUEST_STATE_PASSDB],
+               auth_request_state_count[AUTH_REQUEST_STATE_USERDB]));
+}
+
 static const char *const *read_global_settings(void)
 {
        struct master_service_settings_output set_output;
@@ -130,6 +145,7 @@ static void main_init(void)
                /* caching is handled only by the main auth process */
                passdb_cache_init(global_auth_settings);
        }
+       auth_refresh_proctitle();
 }
 
 static void main_deinit(void)

diff --git a/src/auth/userdb-static.c b/src/auth/userdb-static.c
index 1e63fabb47988858b3b5e48eafdb24c23e19ff10..84ab1476ccd6eb65ef0cd0393d2a4aae82a8cbae 100644 (file)
--- a/src/auth/userdb-static.c
+++ b/src/auth/userdb-static.c
@@ -158,7 +158,7 @@ static_credentials_callback(enum passdb_result result,
 
        auth_request->private_callback.userdb = ctx->old_callback;
        auth_request->context = ctx->old_context;
-       auth_request->state = AUTH_REQUEST_STATE_USERDB;
+       auth_request_set_state(auth_request, AUTH_REQUEST_STATE_USERDB);
 
        switch (result) {
        case PASSDB_RESULT_OK:
@@ -201,7 +201,8 @@ static void static_lookup(struct auth_request *auth_request,
                ctx->callback = callback;
 
                i_assert(auth_request->state == AUTH_REQUEST_STATE_USERDB);
-               auth_request->state = AUTH_REQUEST_STATE_MECH_CONTINUE;
+               auth_request_set_state(auth_request,
+                                      AUTH_REQUEST_STATE_MECH_CONTINUE);
 
                auth_request->context = ctx;
                auth_request_lookup_credentials(auth_request, "",