[apple/xnu.git] / osfmk / kern / ecc_logging.c

/*
 * Copyright (c) 2013 Apple Inc. All rights reserved.
 *
 * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
 *
 * This file contains Original Code and/or Modifications of Original Code
 * as defined in and that are subject to the Apple Public Source License
 * Version 2.0 (the 'License'). You may not use this file except in
 * compliance with the License. The rights granted to you under the License
 * may not be used to create, or enable the creation or redistribution of,
 * unlawful or unlicensed copies of an Apple operating system, or to
 * circumvent, violate, or enable the circumvention or violation of, any
 * terms of an Apple operating system software license agreement.
 *
 * Please obtain a copy of the License at
 * http://www.opensource.apple.com/apsl/ and read it before using this file.
 *
 * The Original Code and all software distributed under the License are
 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
 * Please see the License for the specific language governing rights and
 * limitations under the License.
 *
 * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
 */
#include <mach/mach_types.h>
#include <mach/host_info.h>
#include <kern/locks.h>
#include <kern/ecc.h>
#include <kern/spl.h>
#include <pexpert/pexpert.h>
#include <libkern/OSAtomic.h>

/*
 * ECC data.  Not really KPCs, but this still seems like the
 * best home for this code.
 *
 * Circular buffer of events.  When we fill up, drop data.
 */
#define ECC_EVENT_BUFFER_COUNT  5
struct ecc_event                ecc_data[ECC_EVENT_BUFFER_COUNT];
static uint32_t                 ecc_data_next_read;
static uint32_t                 ecc_data_next_write;
static boolean_t                ecc_data_empty = TRUE; // next read == next write : empty or full?
static lck_grp_t                *ecc_data_lock_group;
static lck_spin_t               ecc_data_lock;
static uint32_t                 ecc_correction_count;

void
ecc_log_init()
{
	ecc_data_lock_group = lck_grp_alloc_init("ecc-data", NULL);
	lck_spin_init(&ecc_data_lock, ecc_data_lock_group, NULL);
	OSMemoryBarrier();
}

uint32_t
ecc_log_get_correction_count()
{
	return ecc_correction_count;
}

kern_return_t
ecc_log_record_event(const struct ecc_event *ev)
{
	spl_t x;

	if (ev->count > ECC_EVENT_INFO_DATA_ENTRIES) {
		panic("Count of %u on ecc event is too large.", (unsigned)ev->count);
	}

	x = splhigh();
	lck_spin_lock(&ecc_data_lock);

	ecc_correction_count++;

	if (ecc_data_next_read == ecc_data_next_write && !ecc_data_empty) {
		lck_spin_unlock(&ecc_data_lock);
		splx(x);
		return KERN_FAILURE;
	}

	bcopy(ev, &ecc_data[ecc_data_next_write], sizeof(*ev));
	ecc_data_next_write++;
	ecc_data_next_write %= ECC_EVENT_BUFFER_COUNT;
	ecc_data_empty = FALSE;

	lck_spin_unlock(&ecc_data_lock);
	splx(x);

	return KERN_SUCCESS;
}


kern_return_t
ecc_log_get_next_event(struct ecc_event *ev)
{
	spl_t x;

	x = splhigh();
	lck_spin_lock(&ecc_data_lock);

	if (ecc_data_empty) {
		assert(ecc_data_next_write == ecc_data_next_read);

		lck_spin_unlock(&ecc_data_lock);
		splx(x);
		return KERN_FAILURE;
	}

	bcopy(&ecc_data[ecc_data_next_read], ev, sizeof(*ev));
	ecc_data_next_read++;
	ecc_data_next_read %= ECC_EVENT_BUFFER_COUNT;

	if (ecc_data_next_read == ecc_data_next_write) {
		ecc_data_empty = TRUE;
	}

	lck_spin_unlock(&ecc_data_lock);
	splx(x);

	return KERN_SUCCESS;
}
Commit	Line	Data
fe8ab488	1	/*
0a7de745 A	2	* Copyright (c) 2013 Apple Inc. All rights reserved.
	3	*
	4	* @APPLE_OSREFERENCE_LICENSE_HEADER_START@
	5	*
	6	* This file contains Original Code and/or Modifications of Original Code
	7	* as defined in and that are subject to the Apple Public Source License
	8	* Version 2.0 (the 'License'). You may not use this file except in
	9	* compliance with the License. The rights granted to you under the License
	10	* may not be used to create, or enable the creation or redistribution of,
	11	* unlawful or unlicensed copies of an Apple operating system, or to
	12	* circumvent, violate, or enable the circumvention or violation of, any
	13	* terms of an Apple operating system software license agreement.
	14	*
	15	* Please obtain a copy of the License at
	16	* http://www.opensource.apple.com/apsl/ and read it before using this file.
	17	*
	18	* The Original Code and all software distributed under the License are
	19	* distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
	20	* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
	21	* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
	22	* FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
	23	* Please see the License for the specific language governing rights and
	24	* limitations under the License.
	25	*
	26	* @APPLE_OSREFERENCE_LICENSE_HEADER_END@
	27	*/
fe8ab488 A	28	#include <mach/mach_types.h>
	29	#include <mach/host_info.h>
	30	#include <kern/locks.h>
	31	#include <kern/ecc.h>
	32	#include <kern/spl.h>
	33	#include <pexpert/pexpert.h>
	34	#include <libkern/OSAtomic.h>
	35
	36	/*
	37	* ECC data. Not really KPCs, but this still seems like the
	38	* best home for this code.
	39	*
	40	* Circular buffer of events. When we fill up, drop data.
	41	*/
0a7de745 A	42	#define ECC_EVENT_BUFFER_COUNT 5
	43	struct ecc_event ecc_data[ECC_EVENT_BUFFER_COUNT];
	44	static uint32_t ecc_data_next_read;
	45	static uint32_t ecc_data_next_write;
	46	static boolean_t ecc_data_empty = TRUE; // next read == next write : empty or full?
	47	static lck_grp_t *ecc_data_lock_group;
	48	static lck_spin_t ecc_data_lock;
	49	static uint32_t ecc_correction_count;
fe8ab488 A	50
	51	void
	52	ecc_log_init()
	53	{
fe8ab488 A	54	ecc_data_lock_group = lck_grp_alloc_init("ecc-data", NULL);
	55	lck_spin_init(&ecc_data_lock, ecc_data_lock_group, NULL);
	56	OSMemoryBarrier();
	57	}
	58
fe8ab488 A	59	uint32_t
	60	ecc_log_get_correction_count()
	61	{
	62	return ecc_correction_count;
	63	}
	64
	65	kern_return_t
	66	ecc_log_record_event(const struct ecc_event *ev)
	67	{
	68	spl_t x;
	69
	70	if (ev->count > ECC_EVENT_INFO_DATA_ENTRIES) {
	71	panic("Count of %u on ecc event is too large.", (unsigned)ev->count);
	72	}
	73
	74	x = splhigh();
	75	lck_spin_lock(&ecc_data_lock);
	76
	77	ecc_correction_count++;
	78
0a7de745	79	if (ecc_data_next_read == ecc_data_next_write && !ecc_data_empty) {
fe8ab488 A	80	lck_spin_unlock(&ecc_data_lock);
	81	splx(x);
	82	return KERN_FAILURE;
	83	}
	84
	85	bcopy(ev, &ecc_data[ecc_data_next_write], sizeof(*ev));
	86	ecc_data_next_write++;
	87	ecc_data_next_write %= ECC_EVENT_BUFFER_COUNT;
	88	ecc_data_empty = FALSE;
	89
	90	lck_spin_unlock(&ecc_data_lock);
	91	splx(x);
	92
	93	return KERN_SUCCESS;
	94	}
	95
	96
	97	kern_return_t
	98	ecc_log_get_next_event(struct ecc_event *ev)
	99	{
	100	spl_t x;
	101
	102	x = splhigh();
	103	lck_spin_lock(&ecc_data_lock);
	104
0a7de745	105	if (ecc_data_empty) {
fe8ab488 A	106	assert(ecc_data_next_write == ecc_data_next_read);
	107
	108	lck_spin_unlock(&ecc_data_lock);
	109	splx(x);
	110	return KERN_FAILURE;
	111	}
	112
	113	bcopy(&ecc_data[ecc_data_next_read], ev, sizeof(*ev));
	114	ecc_data_next_read++;
	115	ecc_data_next_read %= ECC_EVENT_BUFFER_COUNT;
	116
	117	if (ecc_data_next_read == ecc_data_next_write) {
	118	ecc_data_empty = TRUE;
	119	}
	120
	121	lck_spin_unlock(&ecc_data_lock);
	122	splx(x);
	123
	124	return KERN_SUCCESS;
	125	}