[PATCH] remove source4/smbd/process_thread.c

Michael Adam obnox at samba.org
Wed Jul 30 08:12:35 MDT 2014


I support this patchset, but I guess
others more involved in that code in the past
than me should also be heard. :-)

Cheers - Michael

On 2014-07-30 at 12:35 +0200, Volker Lendecke wrote:
> Hi!
> 
> Attached find some patches for $SUBJECT. Explanations for
> those with emotional ties to this code are inside the commit
> messages. :-)
> 
> Comments/Reviews?
> 
> Thanks,
> 
> Volker
> 
> -- 
> SerNet GmbH, Bahnhofsallee 1b, 37081 Göttingen
> phone: +49-551-370000-0, fax: +49-551-370000-9
> AG Göttingen, HRB 2816, GF: Dr. Johannes Loxen
> http://www.sernet.de, mailto:kontakt at sernet.de

> From 069c77b7da3c36102cd6190eee644ec5db58edb7 Mon Sep 17 00:00:00 2001
> From: Volker Lendecke <vl at samba.org>
> Date: Wed, 30 Jul 2014 10:13:41 +0000
> Subject: [PATCH 1/2] 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 <vl at samba.org>
> ---
>  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 ad264c9..0000000
> --- 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 <myersjj at samba.org>
> -   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 <http://www.gnu.org/licenses/>.
> -*/
> -
> -#include "includes.h"
> -#include "version.h"
> -#include <pthread.h>
> -#ifdef HAVE_BACKTRACE
> -#include <execinfo.h>
> -#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<num_addresses; i++) {
> -				DEBUG(1,("log_suspicious_usage: %s%s\n", DEBUGTAB(1), bt_symbols[i]));
> -			}
> -			free(bt_symbols);
> -		}
> -	}
> -#endif
> -}
> -
> -/*****************************************************************
> - 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)
> -{
> -	printf("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<num_addresses; i++) {
> -				printf("log_suspicious_usage: %s%s\n", DEBUGTAB(1), bt_symbols[i]);
> -			}
> -			free(bt_symbols);
> -		}
> -	}
> -#endif
> -}
> -
> -static uint32_t thread_get_task_id(void)
> -{
> -	return (uint32_t)pthread_self();
> -}
> -
> -static void thread_log_task_id(int fd)
> -{
> -	char *s= NULL;
> -
> -	asprintf(&s, "thread[%u][%s]:\n", 
> -		(uint32_t)pthread_self(),
> -		(const char *)pthread_getspecific(title_key));
> -	if (!s) return;
> -	write(fd, s, strlen(s));
> -	free(s);
> -}
> -
> -/****************************************************************************
> -catch serious errors
> -****************************************************************************/
> -static void thread_sig_fault(int sig)
> -{
> -	DEBUG(0,("===============================================================\n"));
> -	DEBUG(0,("TERMINAL ERROR: Recursive signal %d in thread [%u][%s] (%s)\n",
> -		sig,(uint32_t)pthread_self(),
> -		(const char *)pthread_getspecific(title_key),
> -		SAMBA_VERSION_STRING));
> -	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, thread_sig_fault);
> -#endif
> -#ifdef SIGBUS
> -	CatchSignal(SIGBUS, thread_sig_fault);
> -#endif
> -#ifdef SIGABRT
> -	CatchSignal(SIGABRT, thread_sig_fault);
> -#endif
> -}
> -
> -/*******************************************************************
> -report a fault in a thread
> -********************************************************************/
> -static void thread_fault_handler(int sig)
> -{
> -	static int counter;
> -	
> -	/* 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 [%u] [%s] (%s)\n",
> -		sig,(uint32_t)pthread_self(),
> -		(const char *)pthread_getspecific(title_key),
> -		SAMBA_VERSION_STRING));
> -	DEBUG(0,("Please read the file BUGS.txt in the distribution\n"));
> -	DEBUG(0,("===============================================================\n"));
> -#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<num_addresses; i++) {
> -				DEBUG(1,("fault_report: %s%s\n", DEBUGTAB(1), bt_symbols[i]));
> -			}
> -			free(bt_symbols);
> -		}
> -	}
> -#endif
> -	pthread_exit(NULL); /* terminate failing thread only */
> -}
> -
> -/*
> -  called when the process model is selected
> -*/
> -static void thread_model_init(void)
> -{
> -	struct mutex_ops m_ops;
> -	struct debug_ops d_ops;
> -
> -	ZERO_STRUCT(m_ops);
> -	ZERO_STRUCT(d_ops);
> -
> -	pthread_key_create(&title_key, NULL);
> -	pthread_setspecific(title_key, NULL);
> -
> -	/* 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;
> -	d_ops.log_task_id = thread_log_task_id;
> -
> -	register_debug_handlers("thread", &d_ops);
> -}
> -
> -
> -static const struct model_ops thread_ops = {
> -	.name			= "thread",
> -	.model_init		= thread_model_init,
> -	.accept_connection	= thread_accept_connection,
> -	.new_task               = thread_new_task,
> -	.terminate              = thread_terminate,
> -	.set_title		= thread_set_title,
> -};
> -
> -/*
> -  initialise the thread process model, registering ourselves with the model subsystem
> - */
> -NTSTATUS process_model_thread_init(void)
> -{
> -	NTSTATUS ret;
> -
> -	/* register ourselves with the PROCESS_MODEL subsystem. */
> -	ret = register_process_model(&thread_ops);
> -	if (!NT_STATUS_IS_OK(ret)) {
> -		DEBUG(0,("Failed to register process_model 'thread'!\n"));
> -		return ret;
> -	}
> -
> -	return ret;
> -}
> diff --git a/source4/smbd/wscript_build b/source4/smbd/wscript_build
> index 5be4d2b..12d4e8b 100644
> --- a/source4/smbd/wscript_build
> +++ b/source4/smbd/wscript_build
> @@ -44,17 +44,6 @@ bld.SAMBA_MODULE('process_model_standard',
>                   internal_module=False
>                   )
>  
> -
> -bld.SAMBA_MODULE('process_model_thread',
> -                 source='process_thread.c',
> -                 subsystem='process_model',
> -                 init_function='process_model_thread_init',
> -                 enabled=False,
> -                 deps='pthread samba-sockets cluster process_model',
> -                 internal_module=False
> -                 )
> -
> -
>  bld.SAMBA_MODULE('process_model_prefork',
>                   source='process_prefork.c',
>                   subsystem='process_model',
> -- 
> 1.8.1.2
> 
> 
> From 6217129f248287e86285160c89d1e2ee626e51e4 Mon Sep 17 00:00:00 2001
> From: Volker Lendecke <vl at samba.org>
> Date: Wed, 30 Jul 2014 10:19:58 +0000
> Subject: [PATCH 2/2] debug: Remove thread-related code from debug.c
> 
> Signed-off-by: Volker Lendecke <vl at samba.org>
> ---
>  lib/util/debug.c | 54 ------------------------------------------------------
>  lib/util/debug.h | 34 ----------------------------------
>  2 files changed, 88 deletions(-)
> 
> diff --git a/lib/util/debug.c b/lib/util/debug.c
> index a46b275..e222843 100644
> --- a/lib/util/debug.c
> +++ b/lib/util/debug.c
> @@ -1067,57 +1067,3 @@ bool dbghdrclass(int level, int cls, const char *location, const char *func)
>  	SAFE_FREE(msgbuf);
>  	return ret;
>  }
> -
> -
> -/* the registered mutex handlers */
> -static struct {
> -	const char *name;
> -	struct debug_ops ops;
> -} debug_handlers;
> -
> -/**
> -  log suspicious usage - print comments and backtrace
> -*/	
> -_PUBLIC_ void log_suspicious_usage(const char *from, const char *info)
> -{
> -	if (!debug_handlers.ops.log_suspicious_usage) return;
> -
> -	debug_handlers.ops.log_suspicious_usage(from, info);
> -}
> -
> -
> -/**
> -  print suspicious usage - print comments and backtrace
> -*/	
> -_PUBLIC_ void print_suspicious_usage(const char* from, const char* info)
> -{
> -	if (!debug_handlers.ops.print_suspicious_usage) return;
> -
> -	debug_handlers.ops.print_suspicious_usage(from, info);
> -}
> -
> -_PUBLIC_ uint32_t get_task_id(void)
> -{
> -	if (debug_handlers.ops.get_task_id) {
> -		return debug_handlers.ops.get_task_id();
> -	}
> -	return getpid();
> -}
> -
> -_PUBLIC_ void log_task_id(void)
> -{
> -	if (!debug_handlers.ops.log_task_id) return;
> -
> -	if (!reopen_logs_internal()) return;
> -
> -	debug_handlers.ops.log_task_id(state.fd);
> -}
> -
> -/**
> -  register a set of debug handlers. 
> -*/
> -_PUBLIC_ void register_debug_handlers(const char *name, struct debug_ops *ops)
> -{
> -	debug_handlers.name = name;
> -	debug_handlers.ops = *ops;
> -}
> diff --git a/lib/util/debug.h b/lib/util/debug.h
> index f7ebfc0..f393f1b 100644
> --- a/lib/util/debug.h
> +++ b/lib/util/debug.h
> @@ -250,38 +250,4 @@ typedef void (*debug_callback_fn)(void *private_ptr, int level, const char *msg)
>   */
>  void debug_set_callback(void *private_ptr, debug_callback_fn fn);
>  
> -/**
> -  log suspicious usage - print comments and backtrace
> -*/	
> -_PUBLIC_ void log_suspicious_usage(const char *from, const char *info);
> -
> -/**
> -  print suspicious usage - print comments and backtrace
> -*/	
> -_PUBLIC_ void print_suspicious_usage(const char* from, const char* info);
> -_PUBLIC_ uint32_t get_task_id(void);
> -_PUBLIC_ void log_task_id(void);
> -
> -/* the debug operations structure - contains function pointers to
> -   various debug implementations of each operation */
> -struct debug_ops {
> -	/* function to log (using DEBUG) suspicious usage of data structure */
> -	void (*log_suspicious_usage)(const char* from, const char* info);
> -
> -	/* function to log (using printf) suspicious usage of data structure.
> -	 * To be used in circumstances when using DEBUG would cause loop. */
> -	void (*print_suspicious_usage)(const char* from, const char* info);
> -
> -	/* function to return process/thread id */
> -	uint32_t (*get_task_id)(void);
> -
> -	/* function to log process/thread id */
> -	void (*log_task_id)(int fd);
> -};
> -
> -/**
> -  register a set of debug handlers. 
> -*/
> -_PUBLIC_ void register_debug_handlers(const char *name, struct debug_ops *ops);
> -
>  #endif
> -- 
> 1.8.1.2
> 

-------------- next part --------------
A non-text attachment was scrubbed...
Name: signature.asc
Type: application/pgp-signature
Size: 198 bytes
Desc: Digital signature
URL: <http://lists.samba.org/pipermail/samba-technical/attachments/20140730/ed0243bf/attachment.pgp>


More information about the samba-technical mailing list