WebSVN – HelenOS – Diff – /branches/sparc/kernel/generic/src/lib/func.c


/*
 * Copyright (c) 2001-2004 Jakub Jermar
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * - Redistributions of source code must retain the above copyright
 *   notice, this list of conditions and the following disclaimer.
 * - 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.
 * - The name of the author may not be used to endorse or promote products
 *   derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
 */
 
/** @addtogroup generic
 * @{
 */
 
/**
 * @file
 * @brief   Miscellaneous functions.
 */
 
#include <func.h>
#include <print.h>
#include <cpu.h>
#include <arch/asm.h>
#include <arch.h>
#include <console/kconsole.h>
 
atomic_t haltstate = {0}; /**< Halt flag */
 
 
/** Halt wrapper
 *
 * Set halt flag and halt the cpu.
 *
 */
void halt()
{
#ifdef CONFIG_DEBUG
    bool rundebugger = false;
 
 
 
    if (!atomic_get(&haltstate)) {
        atomic_set(&haltstate, 1);
        rundebugger = true;
    }
#else
    atomic_set(&haltstate, 1);
#endif
 
    interrupts_disable();
   
#if (defined(CONFIG_DEBUG)) && (defined(CONFIG_KCONSOLE))
    if (rundebugger)
 
        kconsole("panic", "\nLast resort kernel console ready\n", false);
#endif
   
 
    if (CPU)
        printf("cpu%u: halted\n", CPU->id);
    else
        printf("cpu: halted\n");
    cpu_halt();
}
 
/** Return number of characters in a string.
 *
 * @param str NULL terminated string.
 *
 * @return Number of characters in str.
 */
size_t strlen(const char *str)
{
    int i;
   
    for (i = 0; str[i]; i++)
        ;
   
    return i;
}
 
/** Compare two NULL terminated strings
 *
 * Do a char-by-char comparison of two NULL terminated strings.
 * The strings are considered equal iff they consist of the same
 * characters on the minimum of their lengths.
 *
 * @param src First string to compare.
 * @param dst Second string to compare.
 *
 * @return 0 if the strings are equal, -1 if first is smaller, 1 if second smaller.
 *
 */
int strcmp(const char *src, const char *dst)
{
    for (; *src && *dst; src++, dst++) {
        if (*src < *dst)
            return -1;
        if (*src > *dst)
            return 1;
    }
    if (*src == *dst)
        return 0;
    if (!*src)
        return -1;
    return 1;
}
 
 
/** Compare two NULL terminated strings
 *
 * Do a char-by-char comparison of two NULL terminated strings.
 * The strings are considered equal iff they consist of the same
 * characters on the minimum of their lengths and specified maximal
 * length.
 *
 * @param src First string to compare.
 * @param dst Second string to compare.
 * @param len Maximal length for comparison.
 *
 * @return 0 if the strings are equal, -1 if first is smaller, 1 if second smaller.
 *
 */
int strncmp(const char *src, const char *dst, size_t len)
{
    unsigned int i;
   
    for (i = 0; (*src) && (*dst) && (i < len); src++, dst++, i++) {
        if (*src < *dst)
            return -1;
        if (*src > *dst)
            return 1;
    }
    if (i == len || *src == *dst)
        return 0;
    if (!*src)
        return -1;
    return 1;
}
 
 
 
/** Copy NULL terminated string.
 *
 * Copy at most 'len' characters from string 'src' to 'dest'.
 * If 'src' is shorter than 'len', '\0' is inserted behind the
 * last copied character.
 *
 * @param src Source string.
 * @param dest Destination buffer.
 * @param len Size of destination buffer.
 */
void strncpy(char *dest, const char *src, size_t len)
{
    unsigned int i;
    for (i = 0; i < len; i++) {
        if (!(dest[i] = src[i]))
            return;
    }
    dest[i-1] = '\0';
}
 
/** Convert ascii representation to unative_t
 *
 * Supports 0x for hexa & 0 for octal notation.
 * Does not check for overflows, does not support negative numbers
 *
 * @param text Textual representation of number
 * @return Converted number or 0 if no valid number ofund
 */
unative_t atoi(const char *text)
{
    int base = 10;
    unative_t result = 0;
 
    if (text[0] == '0' && text[1] == 'x') {
        base = 16;
        text += 2;
    } else if (text[0] == '0')
        base = 8;
 
    while (*text) {
        if (base != 16 && \
            ((*text >= 'A' && *text <= 'F' )
             || (*text >='a' && *text <='f')))
            break;
        if (base == 8 && *text >='8')
            break;
 
        if (*text >= '0' && *text <= '9') {
            result *= base;
            result += *text - '0';
        } else if (*text >= 'A' && *text <= 'F') {
            result *= base;
            result += *text - 'A' + 10;
        } else if (*text >= 'a' && *text <= 'f') {
            result *= base;
            result += *text - 'a' + 10;
        } else
            break;
        text++;
    }
 
    return result;
}
 
 
void order(const uint64_t val, uint64_t *rv, char *suffix)
{
    if (val > 10000000000000000000ULL) {
        *rv = val / 1000000000000000000ULL;
        *suffix = 'Z';
    } else if (val > 1000000000000000000ULL) {
        *rv = val / 1000000000000000ULL;
        *suffix = 'E';
    } else if (val > 1000000000000000ULL) {
        *rv = val / 1000000000000ULL;
        *suffix = 'T';
    } else if (val > 1000000000000ULL) {
        *rv = val / 1000000000ULL;
        *suffix = 'G';
    } else if (val > 1000000000ULL) {
        *rv = val / 1000000ULL;
        *suffix = 'M';
    } else if (val > 1000000ULL) {
        *rv = val / 1000ULL;
        *suffix = 'k';
    } else {
        *rv = val;
        *suffix = ' ';
    }
}
 
/** @}
 */
 

Rev 3343	Rev 3742
1	/*	1	/*
2	* Copyright (c) 2001-2004 Jakub Jermar	2	* Copyright (c) 2001-2004 Jakub Jermar
3	* All rights reserved.	3	* All rights reserved.
4	*	4	*
5	* Redistribution and use in source and binary forms, with or without	5	* Redistribution and use in source and binary forms, with or without
6	* modification, are permitted provided that the following conditions	6	* modification, are permitted provided that the following conditions
7	* are met:	7	* are met:
8	*	8	*
9	* - Redistributions of source code must retain the above copyright	9	* - Redistributions of source code must retain the above copyright
10	* notice, this list of conditions and the following disclaimer.	10	* notice, this list of conditions and the following disclaimer.
11	* - Redistributions in binary form must reproduce the above copyright	11	* - Redistributions in binary form must reproduce the above copyright
12	* notice, this list of conditions and the following disclaimer in the	12	* notice, this list of conditions and the following disclaimer in the
13	* documentation and/or other materials provided with the distribution.	13	* documentation and/or other materials provided with the distribution.
14	* - The name of the author may not be used to endorse or promote products	14	* - The name of the author may not be used to endorse or promote products
15	* derived from this software without specific prior written permission.	15	* derived from this software without specific prior written permission.
16	*	16	*
17	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR	17	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES	18	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.	19	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20	* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,	20	* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT	21	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,	22	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY	23	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT	24	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF	25	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.	26	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27	*/	27	*/
28		28
29	/** @addtogroup generic	29	/** @addtogroup generic
30	* @{	30	* @{
31	*/	31	*/
32		32
33	/**	33	/**
34	* @file	34	* @file
35	* @brief Miscellaneous functions.	35	* @brief Miscellaneous functions.
36	*/	36	*/
37		37
38	#include <func.h>	38	#include <func.h>
39	#include <print.h>	39	#include <print.h>
40	#include <cpu.h>	40	#include <cpu.h>
41	#include <arch/asm.h>	41	#include <arch/asm.h>
42	#include <arch.h>	42	#include <arch.h>
43	#include <console/kconsole.h>	43	#include <console/kconsole.h>
44		44
45	atomic_t haltstate = {0}; /*< Halt flag /	45	atomic_t haltstate = {0}; /*< Halt flag /
46		46
47		47
48	/** Halt wrapper	48	/** Halt wrapper
49	*	49	*
50	* Set halt flag and halt the cpu.	50	* Set halt flag and halt the cpu.
51	*	51	*
52	*/	52	*/
53	void halt()	53	void halt()
54	{	54	{
55	#ifdef CONFIG_DEBUG	55	#ifdef CONFIG_DEBUG
56	bool rundebugger = false;	56	bool rundebugger = false;
57		57
58	// TODO test_and_set not defined on all arches	-
59	// if (!test_and_set(&haltstate))	-
60	if (!atomic_get(&haltstate)) {	58	if (!atomic_get(&haltstate)) {
61	atomic_set(&haltstate, 1);	59	atomic_set(&haltstate, 1);
62	rundebugger = true;	60	rundebugger = true;
63	}	61	}
64	#else	62	#else
65	atomic_set(&haltstate, 1);	63	atomic_set(&haltstate, 1);
66	#endif	64	#endif
67		65
68	interrupts_disable();	66	interrupts_disable();
-		67
69	#ifdef CONFIG_DEBUG	68	#if (defined(CONFIG_DEBUG)) && (defined(CONFIG_KCONSOLE))
70	if (rundebugger) {	69	if (rundebugger)
71	printf("\n");	-
72	kconsole("panic"); /* Run kconsole as a last resort to user */	70	kconsole("panic", "\nLast resort kernel console ready\n", false);
-		71	#endif
73	}	72
74	#endif	-
75	if (CPU)	73	if (CPU)
76	printf("cpu%u: halted\n", CPU->id);	74	printf("cpu%u: halted\n", CPU->id);
77	else	75	else
78	printf("cpu: halted\n");	76	printf("cpu: halted\n");
79	cpu_halt();	77	cpu_halt();
80	}	78	}
81		79
82	/** Return number of characters in a string.	80	/** Return number of characters in a string.
83	*	81	*
84	* @param str NULL terminated string.	82	* @param str NULL terminated string.
85	*	83	*
86	* @return Number of characters in str.	84	* @return Number of characters in str.
87	*/	85	*/
88	size_t strlen(const char *str)	86	size_t strlen(const char *str)
89	{	87	{
90	int i;	88	int i;
91		89
92	for (i = 0; str[i]; i++)	90	for (i = 0; str[i]; i++)
93	;	91	;
94		92
95	return i;	93	return i;
96	}	94	}
97		95
98	/** Compare two NULL terminated strings	96	/** Compare two NULL terminated strings
99	*	97	*
100	* Do a char-by-char comparison of two NULL terminated strings.	98	* Do a char-by-char comparison of two NULL terminated strings.
101	* The strings are considered equal iff they consist of the same	99	* The strings are considered equal iff they consist of the same
102	* characters on the minimum of their lengths.	100	* characters on the minimum of their lengths.
103	*	101	*
104	* @param src First string to compare.	102	* @param src First string to compare.
105	* @param dst Second string to compare.	103	* @param dst Second string to compare.
106	*	104	*
107	* @return 0 if the strings are equal, -1 if first is smaller, 1 if second smaller.	105	* @return 0 if the strings are equal, -1 if first is smaller, 1 if second smaller.
108	*	106	*
109	*/	107	*/
110	int strcmp(const char src, const char dst)	108	int strcmp(const char src, const char dst)
111	{	109	{
112	for (; src && dst; src++, dst++) {	110	for (; src && dst; src++, dst++) {
113	if (src < dst)	111	if (src < dst)
114	return -1;	112	return -1;
115	if (src > dst)	113	if (src > dst)
116	return 1;	114	return 1;
117	}	115	}
118	if (src == dst)	116	if (src == dst)
119	return 0;	117	return 0;
120	if (!*src)	118	if (!*src)
121	return -1;	119	return -1;
122	return 1;	120	return 1;
123	}	121	}
124		122
125		123
126	/** Compare two NULL terminated strings	124	/** Compare two NULL terminated strings
127	*	125	*
128	* Do a char-by-char comparison of two NULL terminated strings.	126	* Do a char-by-char comparison of two NULL terminated strings.
129	* The strings are considered equal iff they consist of the same	127	* The strings are considered equal iff they consist of the same
130	* characters on the minimum of their lengths and specified maximal	128	* characters on the minimum of their lengths and specified maximal
131	* length.	129	* length.
132	*	130	*
133	* @param src First string to compare.	131	* @param src First string to compare.
134	* @param dst Second string to compare.	132	* @param dst Second string to compare.
135	* @param len Maximal length for comparison.	133	* @param len Maximal length for comparison.
136	*	134	*
137	* @return 0 if the strings are equal, -1 if first is smaller, 1 if second smaller.	135	* @return 0 if the strings are equal, -1 if first is smaller, 1 if second smaller.
138	*	136	*
139	*/	137	*/
140	int strncmp(const char src, const char dst, size_t len)	138	int strncmp(const char src, const char dst, size_t len)
141	{	139	{
142	unsigned int i;	140	unsigned int i;
143		141
144	for (i = 0; (src) && (dst) && (i < len); src++, dst++, i++) {	142	for (i = 0; (src) && (dst) && (i < len); src++, dst++, i++) {
145	if (src < dst)	143	if (src < dst)
146	return -1;	144	return -1;
147	if (src > dst)	145	if (src > dst)
148	return 1;	146	return 1;
149	}	147	}
150	if (i == len \|\| src == dst)	148	if (i == len \|\| src == dst)
151	return 0;	149	return 0;
152	if (!*src)	150	if (!*src)
153	return -1;	151	return -1;
154	return 1;	152	return 1;
155	}	153	}
156		154
157		155
158		156
159	/** Copy NULL terminated string.	157	/** Copy NULL terminated string.
160	*	158	*
161	* Copy at most 'len' characters from string 'src' to 'dest'.	159	* Copy at most 'len' characters from string 'src' to 'dest'.
162	* If 'src' is shorter than 'len', '\0' is inserted behind the	160	* If 'src' is shorter than 'len', '\0' is inserted behind the
163	* last copied character.	161	* last copied character.
164	*	162	*
165	* @param src Source string.	163	* @param src Source string.
166	* @param dest Destination buffer.	164	* @param dest Destination buffer.
167	* @param len Size of destination buffer.	165	* @param len Size of destination buffer.
168	*/	166	*/
169	void strncpy(char dest, const char src, size_t len)	167	void strncpy(char dest, const char src, size_t len)
170	{	168	{
171	unsigned int i;	169	unsigned int i;
172	for (i = 0; i < len; i++) {	170	for (i = 0; i < len; i++) {
173	if (!(dest[i] = src[i]))	171	if (!(dest[i] = src[i]))
174	return;	172	return;
175	}	173	}
176	dest[i-1] = '\0';	174	dest[i-1] = '\0';
177	}	175	}
178		176
179	/** Convert ascii representation to unative_t	177	/** Convert ascii representation to unative_t
180	*	178	*
181	* Supports 0x for hexa & 0 for octal notation.	179	* Supports 0x for hexa & 0 for octal notation.
182	* Does not check for overflows, does not support negative numbers	180	* Does not check for overflows, does not support negative numbers
183	*	181	*
184	* @param text Textual representation of number	182	* @param text Textual representation of number
185	* @return Converted number or 0 if no valid number ofund	183	* @return Converted number or 0 if no valid number ofund
186	*/	184	*/
187	unative_t atoi(const char *text)	185	unative_t atoi(const char *text)
188	{	186	{
189	int base = 10;	187	int base = 10;
190	unative_t result = 0;	188	unative_t result = 0;
191		189
192	if (text[0] == '0' && text[1] == 'x') {	190	if (text[0] == '0' && text[1] == 'x') {
193	base = 16;	191	base = 16;
194	text += 2;	192	text += 2;
195	} else if (text[0] == '0')	193	} else if (text[0] == '0')
196	base = 8;	194	base = 8;
197		195
198	while (*text) {	196	while (*text) {
199	if (base != 16 && \	197	if (base != 16 && \
200	((text >= 'A' && text <= 'F' )	198	((text >= 'A' && text <= 'F' )
201	\|\| (text >='a' && text <='f')))	199	\|\| (text >='a' && text <='f')))
202	break;	200	break;
203	if (base == 8 && *text >='8')	201	if (base == 8 && *text >='8')
204	break;	202	break;
205		203
206	if (text >= '0' && text <= '9') {	204	if (text >= '0' && text <= '9') {
207	result *= base;	205	result *= base;
208	result += *text - '0';	206	result += *text - '0';
209	} else if (text >= 'A' && text <= 'F') {	207	} else if (text >= 'A' && text <= 'F') {
210	result *= base;	208	result *= base;
211	result += *text - 'A' + 10;	209	result += *text - 'A' + 10;
212	} else if (text >= 'a' && text <= 'f') {	210	} else if (text >= 'a' && text <= 'f') {
213	result *= base;	211	result *= base;
214	result += *text - 'a' + 10;	212	result += *text - 'a' + 10;
215	} else	213	} else
216	break;	214	break;
217	text++;	215	text++;
218	}	216	}
219		217
220	return result;	218	return result;
221	}	219	}
222		220
223		221
224	void order(const uint64_t val, uint64_t rv, char suffix)	222	void order(const uint64_t val, uint64_t rv, char suffix)
225	{	223	{
226	if (val > 10000000000000000000ULL) {	224	if (val > 10000000000000000000ULL) {
227	*rv = val / 1000000000000000000ULL;	225	*rv = val / 1000000000000000000ULL;
228	*suffix = 'Z';	226	*suffix = 'Z';
229	} else if (val > 1000000000000000000ULL) {	227	} else if (val > 1000000000000000000ULL) {
230	*rv = val / 1000000000000000ULL;	228	*rv = val / 1000000000000000ULL;
231	*suffix = 'E';	229	*suffix = 'E';
232	} else if (val > 1000000000000000ULL) {	230	} else if (val > 1000000000000000ULL) {
233	*rv = val / 1000000000000ULL;	231	*rv = val / 1000000000000ULL;
234	*suffix = 'T';	232	*suffix = 'T';
235	} else if (val > 1000000000000ULL) {	233	} else if (val > 1000000000000ULL) {
236	*rv = val / 1000000000ULL;	234	*rv = val / 1000000000ULL;
237	*suffix = 'G';	235	*suffix = 'G';
238	} else if (val > 1000000000ULL) {	236	} else if (val > 1000000000ULL) {
239	*rv = val / 1000000ULL;	237	*rv = val / 1000000ULL;
240	*suffix = 'M';	238	*suffix = 'M';
241	} else if (val > 1000000ULL) {	239	} else if (val > 1000000ULL) {
242	*rv = val / 1000ULL;	240	*rv = val / 1000ULL;
243	*suffix = 'k';	241	*suffix = 'k';
244	} else {	242	} else {
245	*rv = val;	243	*rv = val;
246	*suffix = ' ';	244	*suffix = ' ';
247	}	245	}
248	}	246	}
249		247
250	/** @}	248	/** @}
251	*/	249	*/
252		250

Subversion Repositories HelenOS

(root)/branches/sparc/kernel/generic/src/lib/func.c – Rev 3343 → 3742