1. 根目录:
2. drivers
3. staging
4. dgap
5. dgap_trace.c

/*
 * Copyright 2003 Digi International (www.digi.com)
 *	Scott H Kilau <Scott_Kilau at digi dot com>
 *
 * 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, or (at your option)
 * any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY, EXPRESS OR IMPLIED; 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.
 *
 *
 *	NOTE TO LINUX KERNEL HACKERS:  DO NOT REFORMAT THIS CODE!
 *
 *	This is shared code between Digi's CVS archive and the
 *	Linux Kernel sources.
 *	Changing the source just for reformatting needlessly breaks
 *	our CVS diff history.
 *
 *	Send any bug fixes/changes to:  Eng.Linux at digi dot com.
 *	Thank you.
 *
 */

/* $Id: dgap_trace.c,v 1.1 2009/10/23 14:01:57 markh Exp $ */

#include <linux/kernel.h>
#include <linux/sched.h>	/* For jiffies, task states */
#include <linux/interrupt.h>	/* For tasklet and interrupt structs/defines */
#include <linux/vmalloc.h>

#include "dgap_driver.h"
#include "dgap_trace.h"

#define TRC_TO_CONSOLE 1

/* file level globals */
static char *dgap_trcbuf;		/* the ringbuffer */

#if defined(TRC_TO_KMEM)
static int dgap_trcbufi = 0;		/* index of the tilde at the end of */
#endif

extern int dgap_trcbuf_size;		/* size of the ringbuffer */

#if defined(TRC_TO_KMEM)
static DEFINE_SPINLOCK(dgap_tracef_lock);
#endif

#if 0

#if !defined(TRC_TO_KMEM) && !defined(TRC_TO_CONSOLE)
void dgap_tracef(const char *fmt, ...)
{
	return;
}

#else /* !defined(TRC_TO_KMEM) && !defined(TRC_TO_CONSOLE) */

void dgap_tracef(const char *fmt, ...)
{
	va_list	         ap;
	char  	         buf[TRC_MAXMSG+1];
	size_t		 lenbuf;
	int		 i;
	static int	 failed = FALSE;
# if defined(TRC_TO_KMEM)
	unsigned long	 flags;
#endif

	if(failed)
		return;
# if defined(TRC_TO_KMEM)
	DGAP_LOCK(dgap_tracef_lock, flags);
#endif

	/* Format buf using fmt and arguments contained in ap. */
	va_start(ap, fmt);
	i = vsprintf(buf, fmt,  ap);
	va_end(ap);
	lenbuf = strlen(buf);

# if defined(TRC_TO_KMEM)
	{
		static int	 initd=0;

		/*
		 * Now, in addition to (or instead of) printing this stuff out
		 * (which is a buffered operation), also tuck it away into a
		 * corner of memory which can be examined post-crash in kdb.
		 */
		if (!initd) {
			dgap_trcbuf = (char *) vmalloc(dgap_trcbuf_size);
			if(!dgap_trcbuf) {
				failed = TRUE;
				printk("dgap: tracing init failed!\n");
				return;
			}

			memset(dgap_trcbuf, '\0',  dgap_trcbuf_size);
			dgap_trcbufi = 0;
			initd++;

			printk("dgap: tracing enabled - " TRC_DTRC
				" 0x%lx 0x%x\n",
				(unsigned long)dgap_trcbuf,
				dgap_trcbuf_size);
		}

#  if defined(TRC_ON_OVERFLOW_WRAP_AROUND)
		/*
		 * This is the less CPU-intensive way to do things.  We simply
		 * wrap around before we fall off the end of the buffer.  A
		 * tilde (~) demarcates the current end of the trace.
		 *
		 * This method should be used if you are concerned about race
		 * conditions as it is less likely to affect the timing of
		 * things.
		 */

		if (dgap_trcbufi + lenbuf >= dgap_trcbuf_size) {
			/* We are wrapping, so wipe out the last tilde. */
			dgap_trcbuf[dgap_trcbufi] = '\0';
			/* put the new string at the beginning of the buffer */
			dgap_trcbufi = 0;
		}

		strcpy(&dgap_trcbuf[dgap_trcbufi], buf);
		dgap_trcbufi += lenbuf;
		dgap_trcbuf[dgap_trcbufi] = '~';

#  elif defined(TRC_ON_OVERFLOW_SHIFT_BUFFER)
		/*
		 * This is the more CPU-intensive way to do things.  If we
		 * venture into the last 1/8 of the buffer, we shift the
		 * last 7/8 of the buffer forward, wiping out the first 1/8.
		 * Advantage: No wrap-around, only truncation from the
		 * beginning.
		 *
		 * This method should not be used if you are concerned about
		 * timing changes affecting the behaviour of the driver (ie,
		 * race conditions).
		 */
		strcpy(&dgap_trcbuf[dgap_trcbufi], buf);
		dgap_trcbufi += lenbuf;
		dgap_trcbuf[dgap_trcbufi] = '~';
		dgap_trcbuf[dgap_trcbufi+1] = '\0';

		/* If we're near the end of the trace buffer... */
		if (dgap_trcbufi > (dgap_trcbuf_size/8)*7) {
			/* Wipe out the first eighth to make some more room. */
			strcpy(dgap_trcbuf, &dgap_trcbuf[dgap_trcbuf_size/8]);
			dgap_trcbufi = strlen(dgap_trcbuf)-1;
			/* Plop overflow message at the top of the buffer. */
			bcopy(TRC_OVERFLOW, dgap_trcbuf, strlen(TRC_OVERFLOW));
		}
#  else
#   error "TRC_ON_OVERFLOW_WRAP_AROUND or TRC_ON_OVERFLOW_SHIFT_BUFFER?"
#  endif
	}
	DGAP_UNLOCK(dgap_tracef_lock, flags);

# endif /* defined(TRC_TO_KMEM) */
}

#endif /* !defined(TRC_TO_KMEM) && !defined(TRC_TO_CONSOLE) */

#endif

/*
 * dgap_tracer_free()
 *
 *
 */
void dgap_tracer_free(void)
{
	if(dgap_trcbuf)
		vfree(dgap_trcbuf);
}