path: root/usr/src/uts/common/tnf/tnf_buf.c

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright (c) 1994-2000 by Sun Microsystems, Inc.
 * All rights reserved.
 */

#pragma ident	"%Z%%M%	%I%	%E% SMI"

#include <sys/types.h>
#include <sys/param.h>
#include <sys/systm.h>		/* for bzero */
#include <sys/machlock.h>
#include <sys/spl.h>
#include <sys/promif.h>
#include <sys/debug.h>

#include "tnf_buf.h"

/*
 * Defines
 */

#define	TNFW_B_ALLOC_LO		0x1
#define	TNFW_B_MAXALLOCTRY 	32

#define	TNF_MAXALLOC		(TNF_BLOCK_SIZE - sizeof (tnf_block_header_t))

/*
 * Globals
 */

TNFW_B_STATE tnfw_b_state = TNFW_B_NOBUFFER | TNFW_B_STOPPED;

/*
 * Locals
 */

static int	spinlock_spl;

/*
 * Declarations
 */

static tnf_block_header_t *tnfw_b_alloc_block(tnf_buf_file_header_t *,
    enum tnf_alloc_mode);

/*
 * (Private) Allocate a new block.  Return NULL on failure and mark
 * tracing as broken.  'istag' is non-zero if the block is to be
 * non-reclaimable.  All blocks are returned A-locked.
 */

static tnf_block_header_t *
tnfw_b_alloc_block(tnf_buf_file_header_t *fh, enum tnf_alloc_mode istag)
{
	tnf_block_header_t 	*block;
	ulong_t			bcount;
	ulong_t			tmp_bn, bn, new_bn;
	ulong_t			tmp_gen, gen, new_gen;
	ulong_t			next;
	int			i;
	lock_t			*lp;
	ushort_t		spl;

	if (tnfw_b_state != TNFW_B_RUNNING)
		return (NULL);

	lp = &fh->lock;

	/*
	 * Check reserved area first for tag block allocations
	 * Tag allocations are rare, so we move the code out of line
	 */
	if (istag)
		goto try_reserved;

try_loop:
	/*
	 * Search for a block, using hint as starting point.
	 */

	bcount = fh->com.block_count;	/* total block count */

	gen = fh->next_alloc.gen;
	bn = fh->next_alloc.block[gen & TNFW_B_ALLOC_LO];

	for (i = 0; i < TNFW_B_MAXALLOCTRY; i++) {

		/*
		 * Calculate next (not this) block to look for.
		 * Needed for updating the hint.
		 */
		if ((new_bn = bn + 1) >= bcount) {
			new_bn = TNFW_B_DATA_BLOCK_BEGIN >> TNF_BLOCK_SHIFT;
			new_gen = gen + 1;
		} else
			new_gen = gen;

		/*
		 * Try to reserve candidate block
		 */
		/* LINTED pointer cast may result in improper alignment */
		block = (tnf_block_header_t *)
			((char *)fh + (bn << TNF_BLOCK_SHIFT));

		if (lock_try(&block->A_lock))
			if (block->generation < gen &&
			    lock_try(&block->B_lock))
				goto update_hint;
			else
				lock_clear(&block->A_lock);

		/* Reload hint values */
		gen = fh->next_alloc.gen;
		bn = fh->next_alloc.block[gen & TNFW_B_ALLOC_LO];

		/* adjust if we know a little better than the hint */
		if ((new_bn > bn && new_gen == gen) || new_gen > gen) {
			gen = new_gen;
			bn = new_bn;
		}
	}

	goto loop_fail;

update_hint:
	/*
	 * Re-read the hint and update it only if we'll be increasing it.
	 */
	lock_set_spl(lp, spinlock_spl, &spl);
	tmp_gen = fh->next_alloc.gen;
	tmp_bn = fh->next_alloc.block[tmp_gen & TNFW_B_ALLOC_LO];

	if ((new_gen == tmp_gen && new_bn > tmp_bn) || new_gen > tmp_gen) {
		/*
		 * Order is important here!  It is the write to
		 * next_alloc.gen that atomically records the new
		 * value.
		 */
		fh->next_alloc.block[new_gen & TNFW_B_ALLOC_LO] = new_bn;
		fh->next_alloc.gen = new_gen;
	}
	lock_clear_splx(lp, spl);

got_block:
	/*
	 * Initialize and return the block
	 */
	/* ASSERT(block->tag == TNF_BLOCK_HEADER_TAG); */
	block->bytes_valid = sizeof (tnf_block_header_t);
	block->next_block = NULL;
	/* LINTED assignment of 64-bit integer to 32-bit integer */
	block->generation = istag ? TNF_TAG_GENERATION_NUM : gen;
	/* ASSERT(LOCK_HELD(&block->A_lock); */
	lock_clear(&block->B_lock);
	return (block);

try_reserved:
	/*
	 * Look for a free tag block in reserved area
	 */
	next = fh->next_tag_alloc;
	while (next < (TNFW_B_DATA_BLOCK_BEGIN >> TNF_BLOCK_SHIFT)) {
		/* LINTED pointer cast may result in improper alignment */
		block = (tnf_block_header_t *)
			((char *)fh + (next << TNF_BLOCK_SHIFT));
		next++;
		/*
		 * See if block is unclaimed.
		 * Don't bother clearing the A-lock if the
		 * block was claimed and released, since it
		 * will never be reallocated anyway.
		 */
		if (lock_try(&block->A_lock) &&
		    block->generation == 0) {
			lock_set_spl(lp, spinlock_spl, &spl);
			if (next > fh->next_tag_alloc)
				fh->next_tag_alloc = next;
			lock_clear_splx(lp, spl);
			goto got_block;
		}
	}
	goto try_loop;

loop_fail:
	/*
	 * Only get here if we failed the for loop
	 */
	ASSERT(i == TNFW_B_MAXALLOCTRY);
	tnfw_b_state = TNFW_B_BROKEN;
#ifdef DEBUG
	prom_printf("kernel probes: alloc_block failed\n");
#endif
	return (NULL);

}

/*
 * Allocate size bytes from the trace buffer.  Return NULL on failure,
 * and mark tracing as broken.  We're guaranteed that the buffer will
 * not be deallocated while we're in this routine.
 * Allocation requests must be word-sized and are word-aligned.
 */

void *
tnfw_b_alloc(TNFW_B_WCB *wcb, size_t size, enum tnf_alloc_mode istag)
{
	TNFW_B_POS 		*pos;
	ushort_t		offset;
	void 			*destp;
	tnf_block_header_t	*block, *new_block;

	pos = &wcb->tnfw_w_pos;	/* common case */
	if (istag)
		pos = &wcb->tnfw_w_tag_pos;
	block = pos->tnfw_w_block;
	offset = pos->tnfw_w_write_off;
	/* Round size up to a multiple of 8. */
	size = (size + 7) & ~7;

	if (block == NULL || offset + size > TNF_BLOCK_SIZE) {

		/* Get a new block */
		/* LINTED pointer cast may result in improper alignment */
		new_block = tnfw_b_alloc_block(TNF_FILE_HEADER(), istag);
		if (new_block == NULL)
			/* tracing has been marked as broken at this point */
			return (NULL);

		/* ASSERT(size <= TNF_MAXALLOC); */

		/*
		 * If the old block is clean (i.e., we're in a new
		 * transaction), just release it.  Else, pad it out
		 * and attach it to the list of uncommitted blocks.
		 */
		if (block != NULL) {
			if (block->bytes_valid == offset &&
			    !pos->tnfw_w_dirty) {
				/* block is clean: release it */
				lock_clear(&block->A_lock);
			} else {
				/* block is dirty */
				ulong_t *p, *q;

				/* LINTED pointer cast */
				p = (ulong_t *)((char *)block + offset);
				/* LINTED pointer cast */
				q = (ulong_t *)((char *)block + TNF_BLOCK_SIZE);
				while (p < q)
					*p++ = TNF_NULL;

				/* append block to release list */
				new_block->next_block = block;

				/* we have at least one dirty block */
				pos->tnfw_w_dirty = 1;
			}
		}

		/* make new_block the current block */
		pos->tnfw_w_block = block = new_block;
		/* write_off is updated below */
		offset = sizeof (tnf_block_header_t);
		/* ASSERT(new_block->bytes_valid == offset); */
	}

	destp = (char *)block + offset;
	/* update write_off */
	pos->tnfw_w_write_off = offset + size;
	/*
	 * Unconditionally write a 0 into the last word allocated,
	 * in case we left an alignment gap.  (Assume that doing an
	 * unconditional write is cheaper than testing and branching
	 * around the write half the time.)
	 */
	/* LINTED pointer cast may result in improper alignment */
	*((int *)((char *)destp + size - sizeof (int))) = 0;
	return (destp);
}

/*
 * Allocate a directory entry.
 */

/*ARGSUSED0*/
void *
tnfw_b_fw_alloc(TNFW_B_WCB *wcb)
{
	tnf_buf_file_header_t	*fh;
	lock_t			*lp;
	ushort_t		spl;
	caddr_t			cell;
	ulong_t			next;

	/* LINTED pointer cast may result in improper alignment */
	fh = TNF_FILE_HEADER();
	lp = &fh->lock;

	lock_set_spl(lp, spinlock_spl, &spl);
	next = fh->next_fw_alloc;
	if (next < TNFW_B_FW_ZONE) {
		cell = (caddr_t)fh + next;
		fh->next_fw_alloc = next + sizeof (tnf_ref32_t);
	} else
		cell = NULL;
	lock_clear_splx(lp, spl);

	return (cell);
}

/*
 * Initialize a buffer.
 */

void
tnfw_b_init_buffer(caddr_t buf, size_t size)
{
	int 	gen_shift;
	int 	i;
	ulong_t	b;
	ulong_t	blocks;
	tnf_block_header_t *block;
	tnf_buf_file_header_t *fh;

	/* Compute platform-specific spinlock_spl */
	spinlock_spl = __ipltospl(LOCK_LEVEL + 1);

	/* LINTED pointer cast may result in improper alignment */
	fh = (tnf_buf_file_header_t *)buf;

	/* LINTED logical expression always true: op "||" */
	ASSERT(TNF_DIRECTORY_SIZE > TNF_BLOCK_SIZE);

	/*
	 * This assertion is needed because we cannot change
	 * sys/tnf_com.h this late in the release cycle, but we need the
	 * interface in sys/machlock.h for locking operations.
	 */
	/* LINTED logical expression always true: op "||" */
	ASSERT(sizeof (tnf_byte_lock_t) == sizeof (lock_t));

	/* Calculate number of blocks */
	blocks = size >> TNF_BLOCK_SHIFT;

	/* Calculate generation shift */
	gen_shift = 0;
	b = 1;
	while (b < blocks) {
		b <<= 1;
		++gen_shift;
	}
	ASSERT(gen_shift < 32);

	/* fill in file header */
	/* magic number comes last */
	/* LINTED constant truncated by assignment */
	fh->com.tag = TNF_FILE_HEADER_TAG;
	fh->com.file_version = TNF_FILE_VERSION;
	fh->com.file_header_size = sizeof (tnf_file_header_t);
	fh->com.file_log_size = gen_shift + TNF_BLOCK_SHIFT;
	fh->com.block_header_size = sizeof (tnf_block_header_t);
	fh->com.block_size = TNF_BLOCK_SIZE;
	fh->com.directory_size = TNF_DIRECTORY_SIZE;
	/* LINTED assignment of 64-bit integer to 32-bit integer */
	fh->com.block_count = blocks;
	/* com.blocks_valid is unused */
	fh->next_alloc.gen = 1;
	fh->next_alloc.block[0] = 0;
	fh->next_alloc.block[1] = TNFW_B_DATA_BLOCK_BEGIN >> TNF_BLOCK_SHIFT;
	fh->next_tag_alloc = TNF_DIRECTORY_SIZE >> TNF_BLOCK_SHIFT;
	fh->next_fw_alloc = TNF_DIRENT_LAST + 4;
	LOCK_INIT_CLEAR(&fh->lock);

	(void) bzero(buf + sizeof (*fh), TNF_DIRECTORY_SIZE - sizeof (*fh));
	i = TNF_DIRECTORY_SIZE >> TNF_BLOCK_SHIFT;
	for (; i < blocks; ++i) {
		/* LINTED pointer cast may result in improper alignment */
		block =	(tnf_block_header_t *)(buf + (i << TNF_BLOCK_SHIFT));
		block->tag = (tnf_ref32_t)TNF_BLOCK_HEADER_TAG;
		block->generation = 0;
		block->bytes_valid = sizeof (tnf_block_header_t);
		LOCK_INIT_CLEAR(&block->A_lock);
		LOCK_INIT_CLEAR(&block->B_lock);
	}

	/* snap in magic number */
	fh->magic = TNF_MAGIC;
}