[deliverable/linux.git] / net / tipc / log.c

/*
 * net/tipc/log.c: TIPC print buffer routines for debugging
 *
 * Copyright (c) 1996-2006, Ericsson AB
 * Copyright (c) 2005-2007, Wind River Systems
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. Neither the names of the copyright holders nor the names of its
 *    contributors may be used to endorse or promote products derived from
 *    this software without specific prior written permission.
 *
 * Alternatively, this software may be distributed under the terms of the
 * GNU General Public License ("GPL") version 2 as published by the Free
 * Software Foundation.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

#include "core.h"
#include "config.h"
#include "log.h"

/*
 * TIPC pre-defines the following print buffers:
 *
 * TIPC_NULL : null buffer (i.e. print nowhere)
 * TIPC_CONS : system console
 * TIPC_LOG  : TIPC log buffer
 *
 * Additional user-defined print buffers are also permitted.
 */
static struct print_buf null_buf = { NULL, 0, NULL, 0 };
struct print_buf *const TIPC_NULL = &null_buf;

static struct print_buf cons_buf = { NULL, 0, NULL, 1 };
struct print_buf *const TIPC_CONS = &cons_buf;

static struct print_buf log_buf = { NULL, 0, NULL, 1 };
struct print_buf *const TIPC_LOG = &log_buf;

/*
 * Locking policy when using print buffers.
 *
 * 1) tipc_printf() uses 'print_lock' to protect against concurrent access to
 * 'print_string' when writing to a print buffer. This also protects against
 * concurrent writes to the print buffer being written to.
 *
 * 2) tipc_log_XXX() leverages the aforementioned use of 'print_lock' to
 * protect against all types of concurrent operations on their associated
 * print buffer (not just write operations).
 *
 * Note: All routines of the form tipc_printbuf_XXX() are lock-free, and rely
 * on the caller to prevent simultaneous use of the print buffer(s) being
 * manipulated.
 */
static DEFINE_SPINLOCK(print_lock);

static void tipc_printbuf_move(struct print_buf *pb_to,
			       struct print_buf *pb_from);

/**
 * tipc_printbuf_init - initialize print buffer to empty
 * @pb: pointer to print buffer structure
 * @raw: pointer to character array used by print buffer
 * @size: size of character array
 *
 * Note: If the character array is too small (or absent), the print buffer
 * becomes a null device that discards anything written to it.
 */
void tipc_printbuf_init(struct print_buf *pb, char *raw, u32 size)
{
	pb->buf = raw;
	pb->crs = raw;
	pb->size = size;
	pb->echo = 0;

	if (size < TIPC_PB_MIN_SIZE) {
		pb->buf = NULL;
	} else if (raw) {
		pb->buf[0] = 0;
		pb->buf[size - 1] = ~0;
	}
}

/**
 * tipc_printbuf_reset - reinitialize print buffer to empty state
 * @pb: pointer to print buffer structure
 */
static void tipc_printbuf_reset(struct print_buf *pb)
{
	if (pb->buf) {
		pb->crs = pb->buf;
		pb->buf[0] = 0;
		pb->buf[pb->size - 1] = ~0;
	}
}

/**
 * tipc_printbuf_empty - test if print buffer is in empty state
 * @pb: pointer to print buffer structure
 *
 * Returns non-zero if print buffer is empty.
 */
static int tipc_printbuf_empty(struct print_buf *pb)
{
	return !pb->buf || (pb->crs == pb->buf);
}

/**
 * tipc_printbuf_validate - check for print buffer overflow
 * @pb: pointer to print buffer structure
 *
 * Verifies that a print buffer has captured all data written to it.
 * If data has been lost, linearize buffer and prepend an error message
 *
 * Returns length of print buffer data string (including trailing NUL)
 */
int tipc_printbuf_validate(struct print_buf *pb)
{
	char *err = "\n\n*** PRINT BUFFER OVERFLOW ***\n\n";
	char *cp_buf;
	struct print_buf cb;

	if (!pb->buf)
		return 0;

	if (pb->buf[pb->size - 1] == 0) {
		cp_buf = kmalloc(pb->size, GFP_ATOMIC);
		if (cp_buf) {
			tipc_printbuf_init(&cb, cp_buf, pb->size);
			tipc_printbuf_move(&cb, pb);
			tipc_printbuf_move(pb, &cb);
			kfree(cp_buf);
			memcpy(pb->buf, err, strlen(err));
		} else {
			tipc_printbuf_reset(pb);
			tipc_printf(pb, err);
		}
	}
	return pb->crs - pb->buf + 1;
}

/**
 * tipc_printbuf_move - move print buffer contents to another print buffer
 * @pb_to: pointer to destination print buffer structure
 * @pb_from: pointer to source print buffer structure
 *
 * Current contents of destination print buffer (if any) are discarded.
 * Source print buffer becomes empty if a successful move occurs.
 */
static void tipc_printbuf_move(struct print_buf *pb_to,
			       struct print_buf *pb_from)
{
	int len;

	/* Handle the cases where contents can't be moved */
	if (!pb_to->buf)
		return;

	if (!pb_from->buf) {
		tipc_printbuf_reset(pb_to);
		return;
	}

	if (pb_to->size < pb_from->size) {
		strcpy(pb_to->buf, "*** PRINT BUFFER MOVE ERROR ***");
		pb_to->buf[pb_to->size - 1] = ~0;
		pb_to->crs = strchr(pb_to->buf, 0);
		return;
	}

	/* Copy data from char after cursor to end (if used) */
	len = pb_from->buf + pb_from->size - pb_from->crs - 2;
	if ((pb_from->buf[pb_from->size - 1] == 0) && (len > 0)) {
		strcpy(pb_to->buf, pb_from->crs + 1);
		pb_to->crs = pb_to->buf + len;
	} else
		pb_to->crs = pb_to->buf;

	/* Copy data from start to cursor (always) */
	len = pb_from->crs - pb_from->buf;
	strcpy(pb_to->crs, pb_from->buf);
	pb_to->crs += len;

	tipc_printbuf_reset(pb_from);
}

/**
 * tipc_printf - append formatted output to print buffer
 * @pb: pointer to print buffer
 * @fmt: formatted info to be printed
 */
void tipc_printf(struct print_buf *pb, const char *fmt, ...)
{
	int i;
	va_list args;
	char *buf;
	int len;

	buf = pb->crs;
	len = pb->buf + pb->size - pb->crs;
	va_start(args, fmt);
	i = vscnprintf(buf, len, fmt, args);
	va_end(args);
	pb->crs += i;
}

/**
 * tipc_log_resize - change the size of the TIPC log buffer
 * @log_size: print buffer size to use
 */
int tipc_log_resize(int log_size)
{
	int res = 0;

	spin_lock_bh(&print_lock);
	kfree(TIPC_LOG->buf);
	TIPC_LOG->buf = NULL;
	if (log_size) {
		if (log_size < TIPC_PB_MIN_SIZE)
			log_size = TIPC_PB_MIN_SIZE;
		res = TIPC_LOG->echo;
		tipc_printbuf_init(TIPC_LOG, kmalloc(log_size, GFP_ATOMIC),
				   log_size);
		TIPC_LOG->echo = res;
		res = !TIPC_LOG->buf;
	}
	spin_unlock_bh(&print_lock);

	return res;
}

/**
 * tipc_log_resize_cmd - reconfigure size of TIPC log buffer
 */
struct sk_buff *tipc_log_resize_cmd(const void *req_tlv_area, int req_tlv_space)
{
	u32 value;

	if (!TLV_CHECK(req_tlv_area, req_tlv_space, TIPC_TLV_UNSIGNED))
		return tipc_cfg_reply_error_string(TIPC_CFG_TLV_ERROR);

	value = ntohl(*(__be32 *)TLV_DATA(req_tlv_area));
	if (value > 32768)
		return tipc_cfg_reply_error_string(TIPC_CFG_INVALID_VALUE
						   " (log size must be 0-32768)");
	if (tipc_log_resize(value))
		return tipc_cfg_reply_error_string(
			"unable to create specified log (log size is now 0)");
	return tipc_cfg_reply_none();
}

/**
 * tipc_log_dump - capture TIPC log buffer contents in configuration message
 */
struct sk_buff *tipc_log_dump(void)
{
	struct sk_buff *reply;

	spin_lock_bh(&print_lock);
	if (!TIPC_LOG->buf) {
		spin_unlock_bh(&print_lock);
		reply = tipc_cfg_reply_ultra_string("log not activated\n");
	} else if (tipc_printbuf_empty(TIPC_LOG)) {
		spin_unlock_bh(&print_lock);
		reply = tipc_cfg_reply_ultra_string("log is empty\n");
	} else {
		struct tlv_desc *rep_tlv;
		struct print_buf pb;
		int str_len;

		str_len = min(TIPC_LOG->size, 32768u);
		spin_unlock_bh(&print_lock);
		reply = tipc_cfg_reply_alloc(TLV_SPACE(str_len));
		if (reply) {
			rep_tlv = (struct tlv_desc *)reply->data;
			tipc_printbuf_init(&pb, TLV_DATA(rep_tlv), str_len);
			spin_lock_bh(&print_lock);
			tipc_printbuf_move(&pb, TIPC_LOG);
			spin_unlock_bh(&print_lock);
			str_len = strlen(TLV_DATA(rep_tlv)) + 1;
			skb_put(reply, TLV_SPACE(str_len));
			TLV_SET(rep_tlv, TIPC_TLV_ULTRA_STRING, NULL, str_len);
		}
	}
	return reply;
}
Commit	Line	Data
	1	/*
	2	* net/tipc/log.c: TIPC print buffer routines for debugging
	3	*
	4	* Copyright (c) 1996-2006, Ericsson AB
	5	* Copyright (c) 2005-2007, Wind River Systems
	6	* All rights reserved.
	7	*
	8	* Redistribution and use in source and binary forms, with or without
	9	* modification, are permitted provided that the following conditions are met:
	10	*
	11	* 1. Redistributions of source code must retain the above copyright
	12	* notice, this list of conditions and the following disclaimer.
	13	* 2. Redistributions in binary form must reproduce the above copyright
	14	* notice, this list of conditions and the following disclaimer in the
	15	* documentation and/or other materials provided with the distribution.
	16	* 3. Neither the names of the copyright holders nor the names of its
	17	* contributors may be used to endorse or promote products derived from
	18	* this software without specific prior written permission.
	19	*
	20	* Alternatively, this software may be distributed under the terms of the
	21	* GNU General Public License ("GPL") version 2 as published by the Free
	22	* Software Foundation.
	23	*
	24	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
	25	* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	26	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
	27	* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
	28	* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
	29	* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
	30	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
	31	* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
	32	* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
	33	* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
	34	* POSSIBILITY OF SUCH DAMAGE.
	35	*/
	36
	37	#include "core.h"
	38	#include "config.h"
	39	#include "log.h"
	40
	41	/*
	42	* TIPC pre-defines the following print buffers:
	43	*
	44	* TIPC_NULL : null buffer (i.e. print nowhere)
	45	* TIPC_CONS : system console
	46	* TIPC_LOG : TIPC log buffer
	47	*
	48	* Additional user-defined print buffers are also permitted.
	49	*/
	50	static struct print_buf null_buf = { NULL, 0, NULL, 0 };
	51	struct print_buf *const TIPC_NULL = &null_buf;
	52
	53	static struct print_buf cons_buf = { NULL, 0, NULL, 1 };
	54	struct print_buf *const TIPC_CONS = &cons_buf;
	55
	56	static struct print_buf log_buf = { NULL, 0, NULL, 1 };
	57	struct print_buf *const TIPC_LOG = &log_buf;
	58
	59	/*
	60	* Locking policy when using print buffers.
	61	*
	62	* 1) tipc_printf() uses 'print_lock' to protect against concurrent access to
	63	* 'print_string' when writing to a print buffer. This also protects against
	64	* concurrent writes to the print buffer being written to.
	65	*
	66	* 2) tipc_log_XXX() leverages the aforementioned use of 'print_lock' to
	67	* protect against all types of concurrent operations on their associated
	68	* print buffer (not just write operations).
	69	*
	70	* Note: All routines of the form tipc_printbuf_XXX() are lock-free, and rely
	71	* on the caller to prevent simultaneous use of the print buffer(s) being
	72	* manipulated.
	73	*/
	74	static DEFINE_SPINLOCK(print_lock);
	75
	76	static void tipc_printbuf_move(struct print_buf *pb_to,
	77	struct print_buf *pb_from);
	78
	79	/**
	80	* tipc_printbuf_init - initialize print buffer to empty
	81	* @pb: pointer to print buffer structure
	82	* @raw: pointer to character array used by print buffer
	83	* @size: size of character array
	84	*
	85	* Note: If the character array is too small (or absent), the print buffer
	86	* becomes a null device that discards anything written to it.
	87	*/
	88	void tipc_printbuf_init(struct print_buf pb, char raw, u32 size)
	89	{
	90	pb->buf = raw;
	91	pb->crs = raw;
	92	pb->size = size;
	93	pb->echo = 0;
	94
	95	if (size < TIPC_PB_MIN_SIZE) {
	96	pb->buf = NULL;
	97	} else if (raw) {
	98	pb->buf[0] = 0;
	99	pb->buf[size - 1] = ~0;
	100	}
	101	}
	102
	103	/**
	104	* tipc_printbuf_reset - reinitialize print buffer to empty state
	105	* @pb: pointer to print buffer structure
	106	*/
	107	static void tipc_printbuf_reset(struct print_buf *pb)
	108	{
	109	if (pb->buf) {
	110	pb->crs = pb->buf;
	111	pb->buf[0] = 0;
	112	pb->buf[pb->size - 1] = ~0;
	113	}
	114	}
	115
	116	/**
	117	* tipc_printbuf_empty - test if print buffer is in empty state
	118	* @pb: pointer to print buffer structure
	119	*
	120	* Returns non-zero if print buffer is empty.
	121	*/
	122	static int tipc_printbuf_empty(struct print_buf *pb)
	123	{
	124	return !pb->buf \|\| (pb->crs == pb->buf);
	125	}
	126
	127	/**
	128	* tipc_printbuf_validate - check for print buffer overflow
	129	* @pb: pointer to print buffer structure
	130	*
	131	* Verifies that a print buffer has captured all data written to it.
	132	* If data has been lost, linearize buffer and prepend an error message
	133	*
	134	* Returns length of print buffer data string (including trailing NUL)
	135	*/
	136	int tipc_printbuf_validate(struct print_buf *pb)
	137	{
	138	char err = "\n\n PRINT BUFFER OVERFLOW *\n\n";
	139	char *cp_buf;
	140	struct print_buf cb;
	141
	142	if (!pb->buf)
	143	return 0;
	144
	145	if (pb->buf[pb->size - 1] == 0) {
	146	cp_buf = kmalloc(pb->size, GFP_ATOMIC);
	147	if (cp_buf) {
	148	tipc_printbuf_init(&cb, cp_buf, pb->size);
	149	tipc_printbuf_move(&cb, pb);
	150	tipc_printbuf_move(pb, &cb);
	151	kfree(cp_buf);
	152	memcpy(pb->buf, err, strlen(err));
	153	} else {
	154	tipc_printbuf_reset(pb);
	155	tipc_printf(pb, err);
	156	}
	157	}
	158	return pb->crs - pb->buf + 1;
	159	}
	160
	161	/**
	162	* tipc_printbuf_move - move print buffer contents to another print buffer
	163	* @pb_to: pointer to destination print buffer structure
	164	* @pb_from: pointer to source print buffer structure
	165	*
	166	* Current contents of destination print buffer (if any) are discarded.
	167	* Source print buffer becomes empty if a successful move occurs.
	168	*/
	169	static void tipc_printbuf_move(struct print_buf *pb_to,
	170	struct print_buf *pb_from)
	171	{
	172	int len;
	173
	174	/* Handle the cases where contents can't be moved */
	175	if (!pb_to->buf)
	176	return;
	177
	178	if (!pb_from->buf) {
	179	tipc_printbuf_reset(pb_to);
	180	return;
	181	}
	182
	183	if (pb_to->size < pb_from->size) {
	184	strcpy(pb_to->buf, "* PRINT BUFFER MOVE ERROR *");
	185	pb_to->buf[pb_to->size - 1] = ~0;
	186	pb_to->crs = strchr(pb_to->buf, 0);
	187	return;
	188	}
	189
	190	/* Copy data from char after cursor to end (if used) */
	191	len = pb_from->buf + pb_from->size - pb_from->crs - 2;
	192	if ((pb_from->buf[pb_from->size - 1] == 0) && (len > 0)) {
	193	strcpy(pb_to->buf, pb_from->crs + 1);
	194	pb_to->crs = pb_to->buf + len;
	195	} else
	196	pb_to->crs = pb_to->buf;
	197
	198	/* Copy data from start to cursor (always) */
	199	len = pb_from->crs - pb_from->buf;
	200	strcpy(pb_to->crs, pb_from->buf);
	201	pb_to->crs += len;
	202
	203	tipc_printbuf_reset(pb_from);
	204	}
	205
	206	/**
	207	* tipc_printf - append formatted output to print buffer
	208	* @pb: pointer to print buffer
	209	* @fmt: formatted info to be printed
	210	*/
	211	void tipc_printf(struct print_buf pb, const char fmt, ...)
	212	{
	213	int i;
	214	va_list args;
	215	char *buf;
	216	int len;
	217
	218	buf = pb->crs;
	219	len = pb->buf + pb->size - pb->crs;
	220	va_start(args, fmt);
	221	i = vscnprintf(buf, len, fmt, args);
	222	va_end(args);
	223	pb->crs += i;
	224	}
	225
	226	/**
	227	* tipc_log_resize - change the size of the TIPC log buffer
	228	* @log_size: print buffer size to use
	229	*/
	230	int tipc_log_resize(int log_size)
	231	{
	232	int res = 0;
	233
	234	spin_lock_bh(&print_lock);
	235	kfree(TIPC_LOG->buf);
	236	TIPC_LOG->buf = NULL;
	237	if (log_size) {
	238	if (log_size < TIPC_PB_MIN_SIZE)
	239	log_size = TIPC_PB_MIN_SIZE;
	240	res = TIPC_LOG->echo;
	241	tipc_printbuf_init(TIPC_LOG, kmalloc(log_size, GFP_ATOMIC),
	242	log_size);
	243	TIPC_LOG->echo = res;
	244	res = !TIPC_LOG->buf;
	245	}
	246	spin_unlock_bh(&print_lock);
	247
	248	return res;
	249	}
	250
	251	/**
	252	* tipc_log_resize_cmd - reconfigure size of TIPC log buffer
	253	*/
	254	struct sk_buff tipc_log_resize_cmd(const void req_tlv_area, int req_tlv_space)
	255	{
	256	u32 value;
	257
	258	if (!TLV_CHECK(req_tlv_area, req_tlv_space, TIPC_TLV_UNSIGNED))
	259	return tipc_cfg_reply_error_string(TIPC_CFG_TLV_ERROR);
	260
	261	value = ntohl((__be32 )TLV_DATA(req_tlv_area));
	262	if (value > 32768)
	263	return tipc_cfg_reply_error_string(TIPC_CFG_INVALID_VALUE
	264	" (log size must be 0-32768)");
	265	if (tipc_log_resize(value))
	266	return tipc_cfg_reply_error_string(
	267	"unable to create specified log (log size is now 0)");
	268	return tipc_cfg_reply_none();
	269	}
	270
	271	/**
	272	* tipc_log_dump - capture TIPC log buffer contents in configuration message
	273	*/
	274	struct sk_buff *tipc_log_dump(void)
	275	{
	276	struct sk_buff *reply;
	277
	278	spin_lock_bh(&print_lock);
	279	if (!TIPC_LOG->buf) {
	280	spin_unlock_bh(&print_lock);
	281	reply = tipc_cfg_reply_ultra_string("log not activated\n");
	282	} else if (tipc_printbuf_empty(TIPC_LOG)) {
	283	spin_unlock_bh(&print_lock);
	284	reply = tipc_cfg_reply_ultra_string("log is empty\n");
	285	} else {
	286	struct tlv_desc *rep_tlv;
	287	struct print_buf pb;
	288	int str_len;
	289
	290	str_len = min(TIPC_LOG->size, 32768u);
	291	spin_unlock_bh(&print_lock);
	292	reply = tipc_cfg_reply_alloc(TLV_SPACE(str_len));
	293	if (reply) {
	294	rep_tlv = (struct tlv_desc *)reply->data;
	295	tipc_printbuf_init(&pb, TLV_DATA(rep_tlv), str_len);
	296	spin_lock_bh(&print_lock);
	297	tipc_printbuf_move(&pb, TIPC_LOG);
	298	spin_unlock_bh(&print_lock);
	299	str_len = strlen(TLV_DATA(rep_tlv)) + 1;
	300	skb_put(reply, TLV_SPACE(str_len));
	301	TLV_SET(rep_tlv, TIPC_TLV_ULTRA_STRING, NULL, str_len);
	302	}
	303	}
	304	return reply;
	305	}