summaryrefslogtreecommitdiff
path: root/source4/smbd/process_thread.c
diff options
context:
space:
mode:
authorAndrew Tridgell <tridge@samba.org>2003-08-13 01:53:07 +0000
committerAndrew Tridgell <tridge@samba.org>2003-08-13 01:53:07 +0000
commitcc3a6ea9920f30925a678c566b4af417da6d455b (patch)
tree60015a1a5f4b47ac3d133bdbbe32b75815595d4d /source4/smbd/process_thread.c
parent4d1f9d1def5bf5fea64722626028d94da49c654c (diff)
parentef2e26c91b80556af033d3335e55f5dfa6fff31d (diff)
downloadsamba-cc3a6ea9920f30925a678c566b4af417da6d455b.tar.gz
samba-cc3a6ea9920f30925a678c566b4af417da6d455b.tar.bz2
samba-cc3a6ea9920f30925a678c566b4af417da6d455b.zip
This commit was generated by cvs2svn to compensate for changes in r30,
which included commits to RCS files with non-trunk default branches. (This used to be commit 3a69cffb062d4f1238b8cae10481c1f2ea4d3d8b)
Diffstat (limited to 'source4/smbd/process_thread.c')
-rw-r--r--source4/smbd/process_thread.c410
1 files changed, 410 insertions, 0 deletions
diff --git a/source4/smbd/process_thread.c b/source4/smbd/process_thread.c
new file mode 100644
index 0000000000..cd8865f1e4
--- /dev/null
+++ b/source4/smbd/process_thread.c
@@ -0,0 +1,410 @@
+/*
+ Unix SMB/CIFS implementation.
+ thread model: standard (1 thread per client connection)
+ Copyright (C) Andrew Tridgell 2003
+ Copyright (C) James J Myers 2003 <myersjj@samba.org>
+
+ 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 2 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, write to the Free Software
+ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#include "includes.h"
+#include "pthread.h"
+#include "execinfo.h"
+
+static void *connection_thread(void *thread_parm)
+{
+ struct event_context *ev = thread_parm;
+ /* wait for action */
+ event_loop_wait(ev);
+
+#if 0
+ pthread_cleanup_pop(1); /* will invoke terminate_mt_connection() */
+#endif
+ return NULL;
+}
+
+static int get_id(struct request_context *req)
+{
+ return (int)pthread_self();
+}
+
+/*
+ called when a listening socket becomes readable
+*/
+static void accept_connection(struct event_context *ev, struct fd_event *fde, time_t t, uint16 flags)
+{
+ int accepted_fd, rc;
+ struct sockaddr addr;
+ socklen_t in_addrlen = sizeof(addr);
+ pthread_t thread_id;
+ pthread_attr_t thread_attr;
+ struct model_ops *model_ops = fde->private;
+
+ /* accept an incoming connection */
+ accepted_fd = accept(fde->fd,&addr,&in_addrlen);
+
+ if (accepted_fd == -1) {
+ DEBUG(0,("accept_connection_thread: accept: %s\n",
+ strerror(errno)));
+ return;
+ }
+
+ /* create new detached thread for this connection. The new
+ thread gets a new event_context with a single fd_event for
+ receiving from the new socket. We set that thread running
+ with the main event loop, then return. When we return the
+ main event_context is continued.
+ */
+ ev = event_context_init();
+ MUTEX_LOCK_BY_ID(MUTEX_SMBD);
+ init_smbsession(ev, model_ops, accepted_fd);
+ MUTEX_UNLOCK_BY_ID(MUTEX_SMBD);
+
+ pthread_attr_init(&thread_attr);
+ pthread_attr_setdetachstate(&thread_attr, PTHREAD_CREATE_DETACHED);
+ rc = pthread_create(&thread_id, &thread_attr, &connection_thread, ev);
+ 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, accepted_fd));
+ } else {
+ DEBUG(0,("accept_connection_thread: thread create failed for fd=%d, rc=%d\n", accepted_fd, rc));
+ }
+}
+
+/* called when a SMB connection goes down */
+static void terminate_connection(struct server_context *server, const char *reason)
+{
+ server_terminate(server);
+
+ /* terminate this thread */
+ pthread_exit(NULL); /* thread cleanup routine will do actual cleanup */
+}
+
+/*
+ mutex init function for thread model
+*/
+static int thread_mutex_init(mutex_t *mutex, const char *name)
+{
+ pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;
+ mutex->mutex = 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(mutex_t *mutex, const char *name)
+{
+ return pthread_mutex_destroy((pthread_mutex_t *)mutex->mutex);
+}
+
+static void mutex_start_timer(struct timeval *tp1)
+{
+ gettimeofday(tp1,NULL);
+}
+
+static double mutex_end_timer(struct timeval tp1)
+{
+ struct timeval tp2;
+ gettimeofday(&tp2,NULL);
+ return((tp2.tv_sec - tp1.tv_sec) +
+ (tp2.tv_usec - tp1.tv_usec)*1.0e-6);
+}
+
+/*
+ mutex lock function for thread model
+*/
+static int thread_mutex_lock(mutex_t *mutexP, const char *name)
+{
+ pthread_mutex_t *mutex = (pthread_mutex_t *)mutexP->mutex;
+ int rc;
+ double t;
+ struct timeval 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)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)pthread_self(), name, t);
+ return 0;
+ }
+ printf("mutex lock: thread %d, lock %s failed rc=%d\n",
+ (uint32)pthread_self(), name, rc);
+ SMB_ASSERT(errno == 0); /* force error */
+ }
+ return 0;
+}
+
+/*
+ mutex unlock for thread model
+*/
+static int thread_mutex_unlock(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(rwlock_t *rwlock, const char *name)
+{
+ pthread_rwlock_t m = PTHREAD_RWLOCK_INITIALIZER;
+ rwlock->rwlock = 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(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(rwlock_t *rwlockP, const char *name)
+{
+ pthread_rwlock_t *rwlock = (pthread_rwlock_t *)rwlockP->rwlock;
+ int rc;
+ double t;
+ struct timeval 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)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)pthread_self(), name, t);
+ return 0;
+ }
+ printf("rwlock lock_read: thread %d, lock %s failed rc=%d\n",
+ (uint32)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(rwlock_t *rwlockP, const char *name)
+{
+ pthread_rwlock_t *rwlock = (pthread_rwlock_t *)rwlockP->rwlock;
+ int rc;
+ double t;
+ struct timeval 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)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)pthread_self(), name, t);
+ return 0;
+ }
+ printf("rwlock lock_write: thread %d, lock %s failed rc=%d\n",
+ (uint32)pthread_self(), name, rc);
+ SMB_ASSERT(errno == 0); /* force error */
+ }
+ return 0;
+}
+
+
+/*
+ rwlock unlock for thread model
+*/
+static int thread_rwlock_unlock(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)
+{
+ void *addresses[10];
+ int num_addresses, i;
+ char **bt_symbols;
+
+ DEBUG(1,("log_suspicious_usage: from %s info='%s'\n", from, info));
+ num_addresses = backtrace(addresses, 8);
+ bt_symbols = backtrace_symbols(addresses, num_addresses);
+ for (i=0; i<num_addresses; i++) {
+ DEBUG(1,("log_suspicious_usage: %s%s\n", DEBUGTAB(1), bt_symbols[i]));
+ }
+ free(bt_symbols);
+}
+
+/*****************************************************************
+ Log suspicious usage to stdout (primarily for possible thread-unsafe behavior.
+ Used in mutex code where DEBUG calls would cause recursion.
+*****************************************************************/
+static void thread_print_suspicious_usage(const char* from, const char* info)
+{
+ void *addresses[10];
+ int num_addresses, i;
+ char **bt_symbols;
+
+ printf("log_suspicious_usage: from %s info='%s'\n", from, info);
+ num_addresses = backtrace(addresses, 8);
+ bt_symbols = backtrace_symbols(addresses, num_addresses);
+ for (i=0; i<num_addresses; i++) {
+ printf("log_suspicious_usage: %s%s\n", DEBUGTAB(1), bt_symbols[i]);
+ }
+ free(bt_symbols);
+}
+
+uint32 thread_get_task_id(void)
+{
+ return (uint32)pthread_self();
+}
+
+/****************************************************************************
+catch serious errors
+****************************************************************************/
+static void thread_sig_fault(int sig)
+{
+ DEBUG(0,("===============================================================\n"));
+ DEBUG(0,("TERMINAL ERROR: Recursive signal %d in thread %lu (%s)\n",sig,(unsigned long int)pthread_self(),SAMBA_VERSION));
+ DEBUG(0,("===============================================================\n"));
+ exit(1); /* kill the whole server for now */
+}
+
+/*******************************************************************
+setup our recursive fault handlers
+********************************************************************/
+static void thread_fault_setup(void)
+{
+#ifdef SIGSEGV
+ CatchSignal(SIGSEGV,SIGNAL_CAST thread_sig_fault);
+#endif
+#ifdef SIGBUS
+ CatchSignal(SIGBUS,SIGNAL_CAST thread_sig_fault);
+#endif
+}
+
+/*******************************************************************
+report a fault in a thread
+********************************************************************/
+static void thread_fault_handler(int sig)
+{
+ static int counter;
+ void *addresses[10];
+ int num_addresses, i;
+ char **bt_symbols;
+
+ /* try to catch recursive faults */
+ thread_fault_setup();
+
+ counter++; /* count number of faults that have occurred */
+
+ DEBUG(0,("===============================================================\n"));
+ DEBUG(0,("INTERNAL ERROR: Signal %d in thread %lu (%s)\n",sig,(unsigned long int)pthread_self(),SAMBA_VERSION));
+ DEBUG(0,("Please read the file BUGS.txt in the distribution\n"));
+ DEBUG(0,("===============================================================\n"));
+
+ num_addresses = backtrace(addresses, 10);
+ bt_symbols = backtrace_symbols(addresses, num_addresses);
+ for (i=0; i<num_addresses; i++) {
+ DEBUG(9,("fault_report: %s\n", bt_symbols[i]));
+ }
+ free(bt_symbols);
+ pthread_exit(NULL); /* terminate failing thread only */
+}
+
+/*
+ called when the process model is selected
+*/
+static void model_startup(void)
+{
+ struct mutex_ops m_ops;
+ struct debug_ops d_ops;
+
+ ZERO_STRUCT(m_ops);
+ ZERO_STRUCT(d_ops);
+
+ smbd_process_init();
+
+ /* register mutex/rwlock handlers */
+ m_ops.mutex_init = thread_mutex_init;
+ m_ops.mutex_lock = thread_mutex_lock;
+ m_ops.mutex_unlock = thread_mutex_unlock;
+ m_ops.mutex_destroy = thread_mutex_destroy;
+
+ m_ops.rwlock_init = thread_rwlock_init;
+ m_ops.rwlock_lock_write = thread_rwlock_lock_write;
+ m_ops.rwlock_lock_read = thread_rwlock_lock_read;
+ m_ops.rwlock_unlock = thread_rwlock_unlock;
+ m_ops.rwlock_destroy = thread_rwlock_destroy;
+
+ register_mutex_handlers("thread", &m_ops);
+
+ register_fault_handler("thread", thread_fault_handler);
+
+ d_ops.log_suspicious_usage = thread_log_suspicious_usage;
+ d_ops.print_suspicious_usage = thread_print_suspicious_usage;
+ d_ops.get_task_id = thread_get_task_id;
+
+ register_debug_handlers("thread", &d_ops);
+}
+
+/*
+ initialise the thread process model, registering ourselves with the model subsystem
+ */
+void process_model_thread_init(void)
+{
+ struct model_ops ops;
+
+ ZERO_STRUCT(ops);
+
+ /* fill in all the operations */
+ ops.model_startup = model_startup;
+ ops.accept_connection = accept_connection;
+ ops.terminate_connection = terminate_connection;
+ ops.exit_server = NULL;
+ ops.get_id = get_id;
+
+ /* register ourselves with the process model subsystem. We
+ register under the name 'thread'. */
+ register_process_model("thread", &ops);
+}