WebSVN – HelenOS – Diff – /trunk/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 <typedefs.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;
 
//      TODO test_and_set not defined on all arches
//  if (!test_and_set(&haltstate))
    if (!atomic_get(&haltstate)) {
        atomic_set(&haltstate, 1);
        rundebugger = true;
    }
#else
    atomic_set(&haltstate, 1);
#endif
 
    interrupts_disable();
#ifdef CONFIG_DEBUG
    if (rundebugger) {
        printf("\n");
        kconsole("panic"); /* Run kconsole as a last resort to user */
    }
#endif      
    if (CPU)
        printf("cpu%d: 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)
{
    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)
{
    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 > 1000000000000000000LL) {
        *rv = val / 1000000000000000000LL;
        *suffix = 'E';
    } else if (val > 1000000000000LL) {
        *rv = val / 1000000000000LL;
        *suffix = 'T';
    } else if (val > 1000000LL) {
        *rv = val / 1000000LL;
        *suffix = 'M';
    } else {
        *rv = val;
        *suffix = ' ';
    }
}
 
/** @}
 */
 

Rev 2050	Rev 2071
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 <typedefs.h>	43	#include <typedefs.h>
44	#include <console/kconsole.h>	44	#include <console/kconsole.h>
45		45
46	atomic_t haltstate = {0}; /*< Halt flag /	46	atomic_t haltstate = {0}; /*< Halt flag /
47		47
48		48
49	/** Halt wrapper	49	/** Halt wrapper
50	*	50	*
51	* Set halt flag and halt the cpu.	51	* Set halt flag and halt the cpu.
52	*	52	*
53	*/	53	*/
54	void halt()	54	void halt()
55	{	55	{
56	#ifdef CONFIG_DEBUG	56	#ifdef CONFIG_DEBUG
57	bool rundebugger = false;	57	bool rundebugger = false;
58		58
59	// TODO test_and_set not defined on all arches	59	// TODO test_and_set not defined on all arches
60	// if (!test_and_set(&haltstate))	60	// if (!test_and_set(&haltstate))
61	if (!atomic_get(&haltstate)) {	61	if (!atomic_get(&haltstate)) {
62	atomic_set(&haltstate, 1);	62	atomic_set(&haltstate, 1);
63	rundebugger = true;	63	rundebugger = true;
64	}	64	}
65	#else	65	#else
66	atomic_set(&haltstate, 1);	66	atomic_set(&haltstate, 1);
67	#endif	67	#endif
68		68
69	interrupts_disable();	69	interrupts_disable();
70	#ifdef CONFIG_DEBUG	70	#ifdef CONFIG_DEBUG
71	if (rundebugger) {	71	if (rundebugger) {
72	printf("\n");	72	printf("\n");
73	kconsole("panic"); /* Run kconsole as a last resort to user */	73	kconsole("panic"); /* Run kconsole as a last resort to user */
74	}	74	}
75	#endif	75	#endif
76	if (CPU)	76	if (CPU)
77	printf("cpu%d: halted\n", CPU->id);	77	printf("cpu%d: halted\n", CPU->id);
78	else	78	else
79	printf("cpu: halted\n");	79	printf("cpu: halted\n");
80	cpu_halt();	80	cpu_halt();
81	}	81	}
82		82
83	/** Return number of characters in a string.	83	/** Return number of characters in a string.
84	*	84	*
85	* @param str NULL terminated string.	85	* @param str NULL terminated string.
86	*	86	*
87	* @return Number of characters in str.	87	* @return Number of characters in str.
88	*/	88	*/
89	size_t strlen(const char *str)	89	size_t strlen(const char *str)
90	{	90	{
91	int i;	91	int i;
92		92
93	for (i = 0; str[i]; i++)	93	for (i = 0; str[i]; i++)
94	;	94	;
95		95
96	return i;	96	return i;
97	}	97	}
98		98
99	/** Compare two NULL terminated strings	99	/** Compare two NULL terminated strings
100	*	100	*
101	* Do a char-by-char comparison of two NULL terminated strings.	101	* Do a char-by-char comparison of two NULL terminated strings.
102	* The strings are considered equal iff they consist of the same	102	* The strings are considered equal iff they consist of the same
103	* characters on the minimum of their lengths.	103	* characters on the minimum of their lengths.
104	*	104	*
105	* @param src First string to compare.	105	* @param src First string to compare.
106	* @param dst Second string to compare.	106	* @param dst Second string to compare.
107	*	107	*
108	* @return 0 if the strings are equal, -1 if first is smaller, 1 if second smaller.	108	* @return 0 if the strings are equal, -1 if first is smaller, 1 if second smaller.
109	*	109	*
110	*/	110	*/
111	int strcmp(const char src, const char dst)	111	int strcmp(const char src, const char dst)
112	{	112	{
113	for (; src && dst; src++, dst++) {	113	for (; src && dst; src++, dst++) {
114	if (src < dst)	114	if (src < dst)
115	return -1;	115	return -1;
116	if (src > dst)	116	if (src > dst)
117	return 1;	117	return 1;
118	}	118	}
119	if (src == dst)	119	if (src == dst)
120	return 0;	120	return 0;
121	if (!*src)	121	if (!*src)
122	return -1;	122	return -1;
123	return 1;	123	return 1;
124	}	124	}
125		125
126		126
127	/** Compare two NULL terminated strings	127	/** Compare two NULL terminated strings
128	*	128	*
129	* Do a char-by-char comparison of two NULL terminated strings.	129	* Do a char-by-char comparison of two NULL terminated strings.
130	* The strings are considered equal iff they consist of the same	130	* The strings are considered equal iff they consist of the same
131	* characters on the minimum of their lengths and specified maximal	131	* characters on the minimum of their lengths and specified maximal
132	* length.	132	* length.
133	*	133	*
134	* @param src First string to compare.	134	* @param src First string to compare.
135	* @param dst Second string to compare.	135	* @param dst Second string to compare.
136	* @param len Maximal length for comparison.	136	* @param len Maximal length for comparison.
137	*	137	*
138	* @return 0 if the strings are equal, -1 if first is smaller, 1 if second smaller.	138	* @return 0 if the strings are equal, -1 if first is smaller, 1 if second smaller.
139	*	139	*
140	*/	140	*/
141	int strncmp(const char src, const char dst, size_t len)	141	int strncmp(const char src, const char dst, size_t len)
142	{	142	{
143	int i;	143	int i;
144		144
145	for (i = 0; src && dst && i < len; src++, dst++, i++) {	145	for (i = 0; src && dst && i < len; src++, dst++, i++) {
146	if (src < dst)	146	if (src < dst)
147	return -1;	147	return -1;
148	if (src > dst)	148	if (src > dst)
149	return 1;	149	return 1;
150	}	150	}
151	if (i == len \|\| src == dst)	151	if (i == len \|\| src == dst)
152	return 0;	152	return 0;
153	if (!*src)	153	if (!*src)
154	return -1;	154	return -1;
155	return 1;	155	return 1;
156	}	156	}
157		157
158		158
159		159
160	/** Copy NULL terminated string.	160	/** Copy NULL terminated string.
161	*	161	*
162	* Copy at most 'len' characters from string 'src' to 'dest'.	162	* Copy at most 'len' characters from string 'src' to 'dest'.
163	* If 'src' is shorter than 'len', '\0' is inserted behind the	163	* If 'src' is shorter than 'len', '\0' is inserted behind the
164	* last copied character.	164	* last copied character.
165	*	165	*
166	* @param src Source string.	166	* @param src Source string.
167	* @param dest Destination buffer.	167	* @param dest Destination buffer.
168	* @param len Size of destination buffer.	168	* @param len Size of destination buffer.
169	*/	169	*/
170	void strncpy(char dest, const char src, size_t len)	170	void strncpy(char dest, const char src, size_t len)
171	{	171	{
172	int i;	172	int i;
173	for (i = 0; i < len; i++) {	173	for (i = 0; i < len; i++) {
174	if (!(dest[i] = src[i]))	174	if (!(dest[i] = src[i]))
175	return;	175	return;
176	}	176	}
177	dest[i-1] = '\0';	177	dest[i-1] = '\0';
178	}	178	}
179		179
180	/** Convert ascii representation to unative_t	180	/** Convert ascii representation to unative_t
181	*	181	*
182	* Supports 0x for hexa & 0 for octal notation.	182	* Supports 0x for hexa & 0 for octal notation.
183	* Does not check for overflows, does not support negative numbers	183	* Does not check for overflows, does not support negative numbers
184	*	184	*
185	* @param text Textual representation of number	185	* @param text Textual representation of number
186	* @return Converted number or 0 if no valid number ofund	186	* @return Converted number or 0 if no valid number ofund
187	*/	187	*/
188	unative_t atoi(const char *text)	188	unative_t atoi(const char *text)
189	{	189	{
190	int base = 10;	190	int base = 10;
191	unative_t result = 0;	191	unative_t result = 0;
192		192
193	if (text[0] == '0' && text[1] == 'x') {	193	if (text[0] == '0' && text[1] == 'x') {
194	base = 16;	194	base = 16;
195	text += 2;	195	text += 2;
196	} else if (text[0] == '0')	196	} else if (text[0] == '0')
197	base = 8;	197	base = 8;
198		198
199	while (*text) {	199	while (*text) {
200	if (base != 16 && \	200	if (base != 16 && \
201	((text >= 'A' && text <= 'F' )	201	((text >= 'A' && text <= 'F' )
202	\|\| (text >='a' && text <='f')))	202	\|\| (text >='a' && text <='f')))
203	break;	203	break;
204	if (base == 8 && *text >='8')	204	if (base == 8 && *text >='8')
205	break;	205	break;
206		206
207	if (text >= '0' && text <= '9') {	207	if (text >= '0' && text <= '9') {
208	result *= base;	208	result *= base;
209	result += *text - '0';	209	result += *text - '0';
210	} else if (text >= 'A' && text <= 'F') {	210	} else if (text >= 'A' && text <= 'F') {
211	result *= base;	211	result *= base;
212	result += *text - 'A' + 10;	212	result += *text - 'A' + 10;
213	} else if (text >= 'a' && text <= 'f') {	213	} else if (text >= 'a' && text <= 'f') {
214	result *= base;	214	result *= base;
215	result += *text - 'a' + 10;	215	result += *text - 'a' + 10;
216	} else	216	} else
217	break;	217	break;
218	text++;	218	text++;
219	}	219	}
220		220
221	return result;	221	return result;
222	}	222	}
223		223
224		224
225	void order(const uint64_t val, uint64_t rv, char suffix)	225	void order(const uint64_t val, uint64_t rv, char suffix)
226	{	226	{
227	if (val > 1000000000000000000LL) {	227	if (val > 1000000000000000000LL) {
228	*rv = val / 1000000000000000000LL;	228	*rv = val / 1000000000000000000LL;
229	*suffix = 'E';	229	*suffix = 'E';
230	} else if (val > 1000000000000LL) {	230	} else if (val > 1000000000000LL) {
231	*rv = val / 1000000000000LL;	231	*rv = val / 1000000000000LL;
232	*suffix = 'T';	232	*suffix = 'T';
233	} else if (val > 1000000LL) {	233	} else if (val > 1000000LL) {
234	*rv = val / 1000000LL;	234	*rv = val / 1000000LL;
235	*suffix = 'M';	235	*suffix = 'M';
236	} else {	236	} else {
237	*rv = val;	237	*rv = val;
238	*suffix = ' ';	238	*suffix = ' ';
239	}	239	}
240	}	240	}
241		241
242	/** @}	242	/** @}
243	*/	243	*/
244		244

Subversion Repositories HelenOS

(root)/trunk/kernel/generic/src/lib/func.c – Rev 2050 → 2071