From 83eac53c03511b8599f26a961f89dbd92425d9ab Mon Sep 17 00:00:00 2001 From: Volker Lendecke Date: Wed, 30 Jul 2014 10:13:41 +0000 Subject: smbd4: Remove process_model_thread This code has not seen any use or development for a while. While probably being a good source of inspiration, it will inevitably bit-rot. To really get to a multi-threaded process model, many of the Samba libraries have to be made thread-safe. Why this patch? Right now I am trying to clean up our debug system, and process_thread.c is the only reference to the _suspicious_ functions in debug.c. The alternative would be to factor those out of debug, but as this code is unused for so long, the alternative approach is to just remove it. If someone wants to restart development on a threaded process model, the code is still around in the git history and can be resurrected easily. Signed-off-by: Volker Lendecke Reviewed-by: Jeremy Allison Reviewed-by: Stefan Metzmacher --- source4/smbd/process_thread.c | 574 ------------------------------------------ source4/smbd/wscript_build | 11 - 2 files changed, 585 deletions(-) delete mode 100644 source4/smbd/process_thread.c diff --git a/source4/smbd/process_thread.c b/source4/smbd/process_thread.c deleted file mode 100644 index ad264c9156..0000000000 --- a/source4/smbd/process_thread.c +++ /dev/null @@ -1,574 +0,0 @@ -/* - Unix SMB/CIFS implementation. - - thread model: standard (1 thread per client connection) - - Copyright (C) Andrew Tridgell 2003-2005 - Copyright (C) James J Myers 2003 - Copyright (C) Stefan (metze) Metzmacher 2004 - - This program is free software; you can redistribute it and/or modify - it under the terms of the GNU General Public License as published by - the Free Software Foundation; either version 3 of the License, or - (at your option) any later version. - - 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 for more details. - - You should have received a copy of the GNU General Public License - along with this program. If not, see . -*/ - -#include "includes.h" -#include "version.h" -#include -#ifdef HAVE_BACKTRACE -#include -#endif -#include "system/wait.h" -#include "system/filesys.h" -#include "system/time.h" -#include "lib/events/events.h" -#include "lib/util/dlinklist.h" -#include "lib/util/mutex.h" -#include "smbd/process_model.h" - -static pthread_key_t title_key; - -struct new_conn_state { - struct tevent_context *ev; - struct socket_context *sock; - struct loadparm_context *lp_ctx; - void (*new_conn)(struct tevent_context *, struct loadparm_context *lp_ctx, struct socket_context *, uint32_t , void *); - void *private_data; -}; - -static void *thread_connection_fn(void *thread_parm) -{ - struct new_conn_state *new_conn = talloc_get_type(thread_parm, struct new_conn_state); - - new_conn->new_conn(new_conn->ev, new_conn->lp_ctx, new_conn->sock, pthread_self(), new_conn->private_data); - - /* run this connection from here */ - tevent_loop_wait(new_conn->ev); - - talloc_free(new_conn); - - return NULL; -} - -/* - called when a listening socket becomes readable -*/ -static void thread_accept_connection(struct tevent_context *ev, - struct loadparm_context *lp_ctx, - struct socket_context *sock, - void (*new_conn)(struct tevent_context *, - struct loadparm_context *, - struct socket_context *, - uint32_t , void *), - void *private_data) -{ - NTSTATUS status; - int rc; - pthread_t thread_id; - pthread_attr_t thread_attr; - struct new_conn_state *state; - struct tevent_context *ev2; - - ev2 = s4_event_context_init(ev); - if (ev2 == NULL) return; - - state = talloc(ev2, struct new_conn_state); - if (state == NULL) { - talloc_free(ev2); - return; - } - - state->new_conn = new_conn; - state->private_data = private_data; - state->lp_ctx = lp_ctx; - state->ev = ev2; - - /* accept an incoming connection. */ - status = socket_accept(sock, &state->sock); - if (!NT_STATUS_IS_OK(status)) { - talloc_free(ev2); - /* We need to throttle things until the system clears - enough resources to handle this new socket. If we - don't then we will spin filling the log and causing - more problems. We don't panic as this is probably a - temporary resource constraint */ - sleep(1); - return; - } - - talloc_steal(state, state->sock); - - pthread_attr_init(&thread_attr); - pthread_attr_setdetachstate(&thread_attr, PTHREAD_CREATE_DETACHED); - rc = pthread_create(&thread_id, &thread_attr, thread_connection_fn, state); - pthread_attr_destroy(&thread_attr); - if (rc == 0) { - DEBUG(4,("accept_connection_thread: created thread_id=%lu for fd=%d\n", - (unsigned long int)thread_id, socket_get_fd(sock))); - } else { - DEBUG(0,("accept_connection_thread: thread create failed for fd=%d, rc=%d\n", socket_get_fd(sock), rc)); - talloc_free(ev2); - } -} - - -struct new_task_state { - struct tevent_context *ev; - struct loadparm_context *lp_ctx; - void (*new_task)(struct tevent_context *, struct loadparm_context *, - uint32_t , void *); - void *private_data; -}; - -static void *thread_task_fn(void *thread_parm) -{ - struct new_task_state *new_task = talloc_get_type(thread_parm, struct new_task_state); - - new_task->new_task(new_task->ev, new_task->lp_ctx, pthread_self(), - new_task->private_data); - - /* run this connection from here */ - tevent_loop_wait(new_task->ev); - - talloc_free(new_task); - - return NULL; -} - -/* - called when a new task is needed -*/ -static void thread_new_task(struct tevent_context *ev, - struct loadparm_context *lp_ctx, - const char *service_name, - void (*new_task)(struct tevent_context *, - struct loadparm_context *, - uint32_t , void *), - void *private_data) -{ - int rc; - pthread_t thread_id; - pthread_attr_t thread_attr; - struct new_task_state *state; - struct tevent_context *ev2; - - ev2 = s4_event_context_init(ev); - if (ev2 == NULL) return; - - state = talloc(ev2, struct new_task_state); - if (state == NULL) { - talloc_free(ev2); - return; - } - - state->new_task = new_task; - state->lp_ctx = lp_ctx; - state->private_data = private_data; - state->ev = ev2; - - pthread_attr_init(&thread_attr); - pthread_attr_setdetachstate(&thread_attr, PTHREAD_CREATE_DETACHED); - rc = pthread_create(&thread_id, &thread_attr, thread_task_fn, state); - pthread_attr_destroy(&thread_attr); - if (rc == 0) { - DEBUG(4,("thread_new_task: created %s thread_id=%lu\n", - service_name, (unsigned long int)thread_id)); - } else { - DEBUG(0,("thread_new_task: thread create for %s failed rc=%d\n", service_name, rc)); - talloc_free(ev2); - } -} - -/* called when a task goes down */ -static void thread_terminate(struct tevent_context *event_ctx, struct loadparm_context *lp_ctx, const char *reason) -{ - DEBUG(10,("thread_terminate: reason[%s]\n",reason)); - - talloc_free(event_ctx); - - /* terminate this thread */ - pthread_exit(NULL); /* thread cleanup routine will do actual cleanup */ -} - -/* called to set a title of a task or connection */ -static void thread_set_title(struct tevent_context *ev, const char *title) -{ - char *old_title; - char *new_title; - - old_title = pthread_getspecific(title_key); - talloc_free(old_title); - - new_title = talloc_strdup(ev, title); - pthread_setspecific(title_key, new_title); -} - -/* - mutex init function for thread model -*/ -static int thread_mutex_init(smb_mutex_t *mutex, const char *name) -{ - pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER; - mutex->mutex = smb_memdup(&m, sizeof(m)); - if (! mutex->mutex) { - errno = ENOMEM; - return -1; - } - return pthread_mutex_init((pthread_mutex_t *)mutex->mutex, NULL); -} - -/* - mutex destroy function for thread model -*/ -static int thread_mutex_destroy(smb_mutex_t *mutex, const char *name) -{ - return pthread_mutex_destroy((pthread_mutex_t *)mutex->mutex); -} - -static void mutex_start_timer(struct timespec *tp1) -{ - clock_gettime_mono(tp1); -} - -static double mutex_end_timer(struct timespec tp1) -{ - struct timespec tp2; - - clock_gettime_mono(&tp2); - return((tp2.tv_sec - tp1.tv_sec) + - (tp2.tv_nsec - tp1.tv_nsec)*1.0e-9); -} - -/* - mutex lock function for thread model -*/ -static int thread_mutex_lock(smb_mutex_t *mutexP, const char *name) -{ - pthread_mutex_t *mutex = (pthread_mutex_t *)mutexP->mutex; - int rc; - double t; - struct timespec tp1; - /* Test below is ONLY for debugging */ - if ((rc = pthread_mutex_trylock(mutex))) { - if (rc == EBUSY) { - mutex_start_timer(&tp1); - printf("mutex lock: thread %d, lock %s not available\n", - (uint32_t)pthread_self(), name); - print_suspicious_usage("mutex_lock", name); - pthread_mutex_lock(mutex); - t = mutex_end_timer(tp1); - printf("mutex lock: thread %d, lock %s now available, waited %g seconds\n", - (uint32_t)pthread_self(), name, t); - return 0; - } - printf("mutex lock: thread %d, lock %s failed rc=%d\n", - (uint32_t)pthread_self(), name, rc); - SMB_ASSERT(errno == 0); /* force error */ - } - return 0; -} - -/* - mutex unlock for thread model -*/ -static int thread_mutex_unlock(smb_mutex_t *mutex, const char *name) -{ - return pthread_mutex_unlock((pthread_mutex_t *)mutex->mutex); -} - -/***************************************************************** - Read/write lock routines. -*****************************************************************/ -/* - rwlock init function for thread model -*/ -static int thread_rwlock_init(smb_rwlock_t *rwlock, const char *name) -{ - pthread_rwlock_t m = PTHREAD_RWLOCK_INITIALIZER; - rwlock->rwlock = smb_memdup(&m, sizeof(m)); - if (! rwlock->rwlock) { - errno = ENOMEM; - return -1; - } - return pthread_rwlock_init((pthread_rwlock_t *)rwlock->rwlock, NULL); -} - -/* - rwlock destroy function for thread model -*/ -static int thread_rwlock_destroy(smb_rwlock_t *rwlock, const char *name) -{ - return pthread_rwlock_destroy((pthread_rwlock_t *)rwlock->rwlock); -} - -/* - rwlock lock for read function for thread model -*/ -static int thread_rwlock_lock_read(smb_rwlock_t *rwlockP, const char *name) -{ - pthread_rwlock_t *rwlock = (pthread_rwlock_t *)rwlockP->rwlock; - int rc; - double t; - struct timespec tp1; - /* Test below is ONLY for debugging */ - if ((rc = pthread_rwlock_tryrdlock(rwlock))) { - if (rc == EBUSY) { - mutex_start_timer(&tp1); - printf("rwlock lock_read: thread %d, lock %s not available\n", - (uint32_t)pthread_self(), name); - print_suspicious_usage("rwlock_lock_read", name); - pthread_rwlock_rdlock(rwlock); - t = mutex_end_timer(tp1); - printf("rwlock lock_read: thread %d, lock %s now available, waited %g seconds\n", - (uint32_t)pthread_self(), name, t); - return 0; - } - printf("rwlock lock_read: thread %d, lock %s failed rc=%d\n", - (uint32_t)pthread_self(), name, rc); - SMB_ASSERT(errno == 0); /* force error */ - } - return 0; -} - -/* - rwlock lock for write function for thread model -*/ -static int thread_rwlock_lock_write(smb_rwlock_t *rwlockP, const char *name) -{ - pthread_rwlock_t *rwlock = (pthread_rwlock_t *)rwlockP->rwlock; - int rc; - double t; - struct timespec tp1; - /* Test below is ONLY for debugging */ - if ((rc = pthread_rwlock_trywrlock(rwlock))) { - if (rc == EBUSY) { - mutex_start_timer(&tp1); - printf("rwlock lock_write: thread %d, lock %s not available\n", - (uint32_t)pthread_self(), name); - print_suspicious_usage("rwlock_lock_write", name); - pthread_rwlock_wrlock(rwlock); - t = mutex_end_timer(tp1); - printf("rwlock lock_write: thread %d, lock %s now available, waited %g seconds\n", - (uint32_t)pthread_self(), name, t); - return 0; - } - printf("rwlock lock_write: thread %d, lock %s failed rc=%d\n", - (uint32_t)pthread_self(), name, rc); - SMB_ASSERT(errno == 0); /* force error */ - } - return 0; -} - - -/* - rwlock unlock for thread model -*/ -static int thread_rwlock_unlock(smb_rwlock_t *rwlock, const char *name) -{ - return pthread_rwlock_unlock((pthread_rwlock_t *)rwlock->rwlock); -} - -/***************************************************************** - Log suspicious usage (primarily for possible thread-unsafe behavior). -*****************************************************************/ -static void thread_log_suspicious_usage(const char* from, const char* info) -{ - DEBUG(1,("log_suspicious_usage: from %s info='%s'\n", from, info)); -#ifdef HAVE_BACKTRACE - { - void *addresses[10]; - int num_addresses = backtrace(addresses, 8); - char **bt_symbols = backtrace_symbols(addresses, num_addresses); - int i; - - if (bt_symbols) { - for (i=0; i