diff options
Diffstat (limited to 'newlib/libc/sys/rtems/include')
| -rw-r--r-- | newlib/libc/sys/rtems/include/machine/_types.h | 38 | ||||
| -rw-r--r-- | newlib/libc/sys/rtems/include/machine/limits.h | 5 | ||||
| -rw-r--r-- | newlib/libc/sys/rtems/include/machine/param.h | 101 | ||||
| -rw-r--r-- | newlib/libc/sys/rtems/include/sys/cpuset.h | 311 | ||||
| -rw-r--r-- | newlib/libc/sys/rtems/include/sys/dirent.h | 64 | ||||
| -rw-r--r-- | newlib/libc/sys/rtems/include/sys/param.h | 217 | ||||
| -rw-r--r-- | newlib/libc/sys/rtems/include/sys/syslimits.h | 64 | ||||
| -rw-r--r-- | newlib/libc/sys/rtems/include/sys/utime.h | 34 |
8 files changed, 834 insertions, 0 deletions
diff --git a/newlib/libc/sys/rtems/include/machine/_types.h b/newlib/libc/sys/rtems/include/machine/_types.h new file mode 100644 index 000000000..1711c7ae8 --- /dev/null +++ b/newlib/libc/sys/rtems/include/machine/_types.h @@ -0,0 +1,38 @@ +/* + * $Id$ + */ + +#ifndef _MACHINE__TYPES_H +#define _MACHINE__TYPES_H + +/* This disables some conflicting type definitions in <machine/types.h> */ +#define _HAVE_SYSTYPES + +#include <machine/_default_types.h> + +typedef __int32_t blksize_t; +typedef __int32_t blkcnt_t; + +typedef __uint64_t __dev_t; +#define __dev_t_defined 1 + +#if defined(__arm__) || defined(__i386__) || defined(__m68k__) || defined(__mips__) || defined(__PPC__) || defined(__sparc__) +/* Use 64bit types */ +typedef __int64_t _off_t; +#define __off_t_defined 1 + +typedef __int64_t _fpos_t; +#define __fpos_t_defined 1 +#else +/* Use 32bit types */ +typedef __int32_t _off_t; +#define __off_t_defined 1 + +typedef __int32_t _fpos_t; +#define __fpos_t_defined 1 +#endif + +typedef __uint32_t _mode_t; +#define __mode_t_defined 1 + +#endif diff --git a/newlib/libc/sys/rtems/include/machine/limits.h b/newlib/libc/sys/rtems/include/machine/limits.h new file mode 100644 index 000000000..2b4c47e48 --- /dev/null +++ b/newlib/libc/sys/rtems/include/machine/limits.h @@ -0,0 +1,5 @@ +/* + * $Id$ + */ + +/* intentionally empty file */ diff --git a/newlib/libc/sys/rtems/include/machine/param.h b/newlib/libc/sys/rtems/include/machine/param.h new file mode 100644 index 000000000..74891f504 --- /dev/null +++ b/newlib/libc/sys/rtems/include/machine/param.h @@ -0,0 +1,101 @@ +/* + * $Id$ + */ + +#ifndef _MACHINE_PARAM_H_ +#define _MACHINE_PARAM_H_ + +/* + * These aren't really machine-dependent for RTEMS..... + */ + +/* +#define MACHINE "i386" +#define MID_MACHINE MID_I386 +*/ + +/* + * Round p (pointer or byte index) up to a correctly-aligned value + * for all data types (int, long, ...). The result is unsigned int + * and must be cast to any desired pointer type. + */ +#if defined(__sparc__) +#define ALIGNBYTES (sizeof(double) - 1) +#else +#define ALIGNBYTES (sizeof(int) - 1) +#endif +#define ALIGN(p) (((unsigned)(p) + ALIGNBYTES) & ~ALIGNBYTES) + +#define PAGE_SHIFT 12 /* LOG2(PAGE_SIZE) */ +#define PAGE_SIZE (1<<PAGE_SHIFT) /* bytes/page */ +#define PAGE_MASK (PAGE_SIZE-1) +#define NPTEPG (PAGE_SIZE/(sizeof (pt_entry_t))) + +#define NPDEPG (PAGE_SIZE/(sizeof (pd_entry_t))) +#define PDRSHIFT 22 /* LOG2(NBPDR) */ +#define NBPDR (1<<PDRSHIFT) /* bytes/page dir */ + +#define DEV_BSHIFT 9 /* log2(DEV_BSIZE) */ +#define DEV_BSIZE (1<<DEV_BSHIFT) + +#if defined(__AVR__) || defined(__h8300__) +#define BLKDEV_IOSIZE 1024 +#define MAXPHYS (1 * 1024) /* max raw I/O transfer size */ +#else +#define BLKDEV_IOSIZE 2048 +#define MAXPHYS (64 * 1024) /* max raw I/O transfer size */ +#endif + +#define UPAGES 2 /* pages of u-area */ + +/* + * Constants related to network buffer management. + * MCLBYTES must be no larger than CLBYTES (the software page size), and, + * on machines that exchange pages of input or output buffers with mbuf + * clusters (MAPPED_MBUFS), MCLBYTES must also be an integral multiple + * of the hardware page size. + */ +#ifndef MSIZE +#define MSIZE 128 /* size of an mbuf */ +#endif /* MSIZE */ + +#ifndef MCLSHIFT +#define MCLSHIFT 11 /* convert bytes to m_buf clusters */ +#endif /* MCLSHIFT */ +#define MCLBYTES (1 << MCLSHIFT) /* size of an m_buf cluster */ +#define MCLOFSET (MCLBYTES - 1) /* offset within an m_buf cluster */ + +/* + * Some macros for units conversion + */ + +/* clicks to bytes */ +#define ctob(x) ((x)<<PAGE_SHIFT) + +/* bytes to clicks */ +#define btoc(x) (((unsigned)(x)+PAGE_MASK)>>PAGE_SHIFT) + +/* + * btodb() is messy and perhaps slow because `bytes' may be an off_t. We + * want to shift an unsigned type to avoid sign extension and we don't + * want to widen `bytes' unnecessarily. Assume that the result fits in + * a daddr_t. + */ +#define btodb(bytes) /* calculates (bytes / DEV_BSIZE) */ \ + (sizeof (bytes) > sizeof(long) \ + ? (daddr_t)((unsigned long long)(bytes) >> DEV_BSHIFT) \ + : (daddr_t)((unsigned long)(bytes) >> DEV_BSHIFT)) + +#define dbtob(db) /* calculates (db * DEV_BSIZE) */ \ + ((off_t)(db) << DEV_BSHIFT) + +/* + * Mach derived conversion macros + */ +#define trunc_page(x) ((unsigned)(x) & ~PAGE_MASK) +#define round_page(x) ((((unsigned)(x)) + PAGE_MASK) & ~PAGE_MASK) + +#define atop(x) ((unsigned)(x) >> PAGE_SHIFT) +#define ptoa(x) ((unsigned)(x) << PAGE_SHIFT) + +#endif /* !_MACHINE_PARAM_H_ */ diff --git a/newlib/libc/sys/rtems/include/sys/cpuset.h b/newlib/libc/sys/rtems/include/sys/cpuset.h new file mode 100644 index 000000000..8fae475a8 --- /dev/null +++ b/newlib/libc/sys/rtems/include/sys/cpuset.h @@ -0,0 +1,311 @@ +/* + * Copyright (c) 2013 On-Line Applications Research Corporation. + * All rights reserved. + * + * On-Line Applications Research Corporation + * 7047 Old Madison Pike Suite 320 + * Huntsville Alabama 35806 + * <info@oarcorp.com> + * + * 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. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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. + */ + +/* + * This file implements an API compatible with static portion of + * the GNU/Linux cpu_set_t macros but is independently implemented. + * The GNU/Linux manual page and the FreeBSD cpuset_t implementation + * were used as reference material. + * + * Not implemented: + * + Linux CPU_XXX_S + * + FreeBSD CPU_SUBSET + * + FreeBSD CPU_OVERLAP + */ + + +#ifndef _SYS_CPUSET_H_ +#define _SYS_CPUSET_H_ + +#include <sys/cdefs.h> + +#ifdef __cplusplus +extern "C" { +#endif /* __cplusplus */ + +/* RTEMS supports a maximum of 32 CPU cores */ +#ifndef CPU_SETSIZE +#define CPU_SETSIZE 32 +#endif + +/* word in the cpu set */ +typedef __uint32_t cpu_set_word_t; + +/* Number of bits per cpu_set_t element */ +#define _NCPUBITS (sizeof(cpu_set_word_t) * 8) + +/* Number of words in the cpu_set_t array */ +#define _NCPUWORDS (((CPU_SETSIZE)+((_NCPUBITS)-1))/(_NCPUBITS)) + +/* Define the cpu set structure */ +typedef struct _cpuset { + cpu_set_word_t __bits[_NCPUWORDS]; +} cpu_set_t; + +/* determine the mask for a particular cpu within the element */ +static __inline cpu_set_word_t __cpuset_mask(int cpu) +{ + return (cpu_set_word_t)1 << ((size_t)cpu % _NCPUBITS); +} + +/* determine the index for this cpu within the cpu set array */ +static __inline size_t __cpuset_index(int cpu) +{ + return (size_t)cpu / _NCPUBITS; +} + +#define CPU_ALLOC_SIZE(_num_cpus) \ + (sizeof(cpu_set_word_t) * (((_num_cpus) + _NCPUBITS - 1) / _NCPUBITS)) + +cpu_set_t *__cpuset_alloc(int num_cpus); + +static __inline cpu_set_t *CPU_ALLOC(int num_cpus) +{ + return __cpuset_alloc(num_cpus); +} + +void __cpuset_free(cpu_set_t *set); + +static __inline void CPU_FREE(cpu_set_t *set) +{ + __cpuset_free(set); +} + +static __inline void CPU_ZERO_S(size_t setsize, cpu_set_t *set) +{ + cpu_set_word_t *w = &set->__bits[0]; + size_t n = setsize / sizeof(*w); + size_t i; + + for (i = 0; i < n; ++i) + w[i] = 0; +} + +static __inline void CPU_ZERO(cpu_set_t *set) +{ + CPU_ZERO_S(sizeof(*set), set); +} + +static __inline void CPU_FILL_S(size_t setsize, cpu_set_t *set) +{ + cpu_set_word_t *w = &set->__bits[0]; + size_t n = setsize / sizeof(*w); + size_t i; + + for (i = 0; i < n; ++i) + w[i] = ~(cpu_set_word_t)0; +} + +static __inline void CPU_FILL(cpu_set_t *set) +{ + CPU_FILL_S(sizeof(*set), set); +} + +static __inline void CPU_SET_S(int cpu, size_t setsize, cpu_set_t *set) +{ + cpu_set_word_t *w = &set->__bits[0]; + + w[__cpuset_index(cpu)] |= __cpuset_mask(cpu); +} + +static __inline void CPU_SET(int cpu, cpu_set_t *set) +{ + CPU_SET_S(cpu, sizeof(*set), set); +} + +static __inline void CPU_CLR_S(int cpu, size_t setsize, cpu_set_t *set) +{ + cpu_set_word_t *w = &set->__bits[0]; + + w[__cpuset_index(cpu)] &= ~__cpuset_mask(cpu); +} + +static __inline void CPU_CLR(int cpu, cpu_set_t *set) +{ + CPU_CLR_S(cpu, sizeof(*set), set); +} + +static __inline int CPU_ISSET_S(int cpu, size_t setsize, const cpu_set_t *set) +{ + const cpu_set_word_t *w = &set->__bits[0]; + + return ((w[__cpuset_index(cpu)] & __cpuset_mask(cpu)) != 0); +} + +static __inline int CPU_ISSET(int cpu, const cpu_set_t *set) +{ + return CPU_ISSET_S(cpu, sizeof(*set), set); +} + +/* copy src set to dest set */ +static __inline void CPU_COPY( cpu_set_t *dest, const cpu_set_t *src ) +{ + *dest = *src; +} + +static __inline void CPU_AND_S(size_t setsize, cpu_set_t *destset, + const cpu_set_t *srcset1, const cpu_set_t *srcset2) +{ + cpu_set_word_t *wdest = &destset->__bits[0]; + const cpu_set_word_t *wsrc1 = &srcset1->__bits[0]; + const cpu_set_word_t *wsrc2 = &srcset2->__bits[0]; + size_t n = setsize / sizeof(*wdest); + size_t i; + + for (i = 0; i < n; ++i) + wdest[i] = wsrc1[i] & wsrc2[i]; +} + +static __inline void CPU_AND(cpu_set_t *destset, const cpu_set_t *srcset1, + const cpu_set_t *srcset2) +{ + CPU_AND_S(sizeof(*destset), destset, srcset1, srcset2); +} + +static __inline void CPU_OR_S(size_t setsize, cpu_set_t *destset, + const cpu_set_t *srcset1, const cpu_set_t *srcset2) +{ + cpu_set_word_t *wdest = &destset->__bits[0]; + const cpu_set_word_t *wsrc1 = &srcset1->__bits[0]; + const cpu_set_word_t *wsrc2 = &srcset2->__bits[0]; + size_t n = setsize / sizeof(*wdest); + size_t i; + + for (i = 0; i < n; ++i) + wdest[i] = wsrc1[i] | wsrc2[i]; +} + +static __inline void CPU_OR(cpu_set_t *destset, const cpu_set_t *srcset1, + const cpu_set_t *srcset2) +{ + CPU_OR_S(sizeof(*destset), destset, srcset1, srcset2); +} + +static __inline void CPU_XOR_S(size_t setsize, cpu_set_t *destset, + const cpu_set_t *srcset1, const cpu_set_t *srcset2) +{ + cpu_set_word_t *wdest = &destset->__bits[0]; + const cpu_set_word_t *wsrc1 = &srcset1->__bits[0]; + const cpu_set_word_t *wsrc2 = &srcset2->__bits[0]; + size_t n = setsize / sizeof(*wdest); + size_t i; + + for (i = 0; i < n; ++i) + wdest[i] = wsrc1[i] ^ wsrc2[i]; +} + +static __inline void CPU_XOR(cpu_set_t *destset, const cpu_set_t *srcset1, + const cpu_set_t *srcset2) +{ + CPU_XOR_S(sizeof(*destset), destset, srcset1, srcset2); +} + +static __inline void CPU_NAND_S(size_t setsize, cpu_set_t *destset, + const cpu_set_t *srcset1, const cpu_set_t *srcset2) +{ + cpu_set_word_t *wdest = &destset->__bits[0]; + const cpu_set_word_t *wsrc1 = &srcset1->__bits[0]; + const cpu_set_word_t *wsrc2 = &srcset2->__bits[0]; + size_t n = setsize / sizeof(*wdest); + size_t i; + + for (i = 0; i < n; ++i) + wdest[i] = ~(wsrc1[i] & wsrc2[i]); +} + +static __inline void CPU_NAND(cpu_set_t *destset, const cpu_set_t *srcset1, + const cpu_set_t *srcset2) +{ + CPU_NAND_S(sizeof(*destset), destset, srcset1, srcset2); +} + +static __inline int CPU_COUNT_S(size_t setsize, const cpu_set_t *set) +{ + int count = 0; + const cpu_set_word_t *w = &set->__bits[0]; + size_t n = setsize / sizeof(*w); + size_t i; + int cpu; + + for (i = 0; i < n; ++i) + for (cpu = 0; cpu < (int)_NCPUBITS; ++cpu) + count += (w[i] & __cpuset_mask(cpu)) != 0; + + return count; +} + +static __inline int CPU_COUNT(const cpu_set_t *set) +{ + return CPU_COUNT_S(sizeof(*set), set); +} + +static __inline int CPU_EQUAL_S(size_t setsize, const cpu_set_t *set1, + const cpu_set_t *set2) +{ + const cpu_set_word_t *w1 = &set1->__bits[0]; + const cpu_set_word_t *w2 = &set2->__bits[0]; + size_t n = setsize / sizeof(*w1); + size_t i; + + for (i = 0; i < n; ++i) + if (w1[i] != w2[i]) + return 0; + + return 1; +} + +static __inline int CPU_EQUAL(const cpu_set_t *set1, const cpu_set_t *set2) +{ + return CPU_EQUAL_S(sizeof(*set1), set1, set2); +} + +/* return 1 if the sets set1 and set2 are equal, otherwise return 0 */ +static __inline int CPU_CMP( const cpu_set_t *set1, const cpu_set_t *set2 ) +{ + return CPU_EQUAL(set1, set2); +} + +/* return 1 if the set is empty, otherwise return 0 */ +static __inline int CPU_EMPTY( const cpu_set_t *set ) +{ + size_t i; + + for (i=0; i < _NCPUWORDS; i++) + if (set->__bits[i] != 0 ) + return 0; + return 1; +} + +#ifdef __cplusplus +} +#endif /* __cplusplus */ + +#endif diff --git a/newlib/libc/sys/rtems/include/sys/dirent.h b/newlib/libc/sys/rtems/include/sys/dirent.h new file mode 100644 index 000000000..5a3a54dbf --- /dev/null +++ b/newlib/libc/sys/rtems/include/sys/dirent.h @@ -0,0 +1,64 @@ +#ifndef _SYS_DIRENT_H +# define _SYS_DIRENT_H + +#ifdef __cplusplus +extern "C" { +#endif + +/* + * This file was written to be compatible with the BSD directory + * routines, so it looks like it. But it was written from scratch. + * Sean Eric Fagan, sef@Kithrup.COM + * + * Copied to RTEMS configuration without modification. + */ + +typedef struct _dirdesc { + int dd_fd; + long dd_loc; + long dd_size; + char *dd_buf; + int dd_len; + long dd_seek; +} DIR; + +# define __dirfd(dp) ((dp)->dd_fd) + +DIR *opendir(const char *); +struct dirent *readdir(DIR *); +int readdir_r(DIR *__restrict, struct dirent *__restrict, + struct dirent **__restrict); +void rewinddir(DIR *); +int closedir(DIR *); +void seekdir(DIR *dir, long loc); +long telldir(DIR *dir); + +#ifdef _COMPILING_NEWLIB +void _seekdir(DIR *dir, long offset); +#endif + +#include <sys/types.h> + +#include <limits.h> + +struct dirent { + long d_ino; + off_t d_off; + unsigned short d_reclen; + /* we need better syntax for variable-sized arrays */ + unsigned short d_namlen; + char d_name[NAME_MAX + 1]; +}; + +int scandir ( const char *dirname, + struct dirent *** namelist, + int (*select)(const struct dirent *), + int (*dcomp)(const struct dirent **, const struct dirent **) +); + +#ifdef __cplusplus +} +#endif + + +#endif diff --git a/newlib/libc/sys/rtems/include/sys/param.h b/newlib/libc/sys/rtems/include/sys/param.h new file mode 100644 index 000000000..f1e598c88 --- /dev/null +++ b/newlib/libc/sys/rtems/include/sys/param.h @@ -0,0 +1,217 @@ +/*- + * Copyright (c) 1982, 1986, 1989, 1993 + * The Regents of the University of California. All rights reserved. + * (c) UNIX System Laboratories, Inc. + * All or some portions of this file are derived from material licensed + * to the University of California by American Telephone and Telegraph + * Co. or Unix System Laboratories, Inc. and are reproduced herein with + * the permission of UNIX System Laboratories, Inc. + * + * 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. + * 4. Neither the name of the University nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE REGENTS 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 REGENTS 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. + * + * @(#)param.h 8.3 (Berkeley) 4/4/95 + * $Id$ + */ + +#ifndef _SYS_PARAM_H_ +#define _SYS_PARAM_H_ + +/* from newlib's <sys/param.h> */ + +#include <sys/config.h> +#include <machine/endian.h> + +# define PATHSIZE (1024) + +/* end of from newlib's <sys/param.h> */ + +#include <unistd.h> + +#define BSD 199506 /* System version (year & month). */ +#define BSD4_3 1 +#define BSD4_4 1 + +#ifndef NULL +#define NULL 0 +#endif + +#ifndef LOCORE +#include <sys/types.h> +#endif + +/* + * Machine-independent constants (some used in following include files). + * Redefined constants are from POSIX 1003.1 limits file. + * + * MAXCOMLEN should be >= sizeof(ac_comm) (see <acct.h>) + */ +#include <sys/syslimits.h> + +#define MAXCOMLEN 19 /* max command name remembered */ +#define MAXINTERP PATH_MAX /* max interpreter file name length */ +#define MAXLOGNAME 33 /* max login name length (incl. NUL) */ +#define MAXUPRC CHILD_MAX /* max simultaneous processes */ +#define NCARGS ARG_MAX /* max bytes for an exec function */ +#define NGROUPS (NGROUPS_MAX+1) /* max number groups */ +#define NOFILE OPEN_MAX /* max open files per process */ +#define NOGROUP 65535 /* marker for empty group set member */ +#define MAXHOSTNAMELEN 256 /* max hostname size */ +#define SPECNAMELEN 63 /* max length of devicename */ + +/* More types and definitions used throughout the kernel. */ +#if defined(KERNEL) || defined(_KERNEL) +#include <sys/cdefs.h> +#include <sys/errno.h> +#include <sys/time.h> +#include <sys/resource.h> +#include <sys/uio.h> +#include <sys/priority.h> + +#ifndef FALSE +#define FALSE 0 +#endif +#ifndef TRUE +#define TRUE 1 +#endif +#endif + +/* Signals. */ +#include <sys/signal.h> + +/* Machine type dependent parameters. */ +#include <machine/param.h> +#include <machine/limits.h> + +#define PRIMASK 0x0ff +#define PCATCH 0x100 /* OR'd with pri for tsleep to check signals */ + +#define NZERO 0 /* default "nice" */ + +#define NBPW sizeof(int) /* number of bytes per word (integer) */ + +#define CMASK 022 /* default file mask: S_IWGRP|S_IWOTH */ +#define NODEV (dev_t)(-1) /* non-existent device */ + +#define CBLOCK 128 /* Clist block size, must be a power of 2. */ +#define CBQSIZE (CBLOCK/NBBY) /* Quote bytes/cblock - can do better. */ + /* Data chars/clist. */ +#define CBSIZE (CBLOCK - sizeof(struct cblock *) - CBQSIZE) +#define CROUND (CBLOCK - 1) /* Clist rounding. */ + +/* + * File system parameters and macros. + * + * MAXBSIZE - Filesystems are made out of blocks of at most MAXBSIZE bytes + * per block. MAXBSIZE may be made larger without effecting + * any existing filesystems as long as it does not exceed MAXPHYS, + * and may be made smaller at the risk of not being able to use + * filesystems which require a block size exceeding MAXBSIZE. + * + * BKVASIZE - Nominal buffer space per buffer, in bytes. BKVASIZE is the + * minimum KVM memory reservation the kernel is willing to make. + * Filesystems can of course request smaller chunks. Actual + * backing memory uses a chunk size of a page (PAGE_SIZE). + * + * If you make BKVASIZE too small you risk seriously fragmenting + * the buffer KVM map which may slow things down a bit. If you + * make it too big the kernel will not be able to optimally use + * the KVM memory reserved for the buffer cache and will wind + * up with too-few buffers. + * + * The default is 16384, roughly 2x the block size used by a + * normal UFS filesystem. + */ +#define MAXBSIZE 65536 /* must be power of 2 */ +#define BKVASIZE 16384 /* must be power of 2 */ +#define BKVAMASK (BKVASIZE-1) + +/* + * MAXPATHLEN defines the longest permissible path length after expanding + * symbolic links. It is used to allocate a temporary buffer from the buffer + * pool in which to do the name expansion, hence should be a power of two, + * and must be less than or equal to MAXBSIZE. MAXSYMLINKS defines the + * maximum number of symbolic links that may be expanded in a path name. + * It should be set high enough to allow all legitimate uses, but halt + * infinite loops reasonably quickly. + */ +#define MAXPATHLEN PATH_MAX +#define MAXSYMLINKS 32 + +/* Bit map related macros. */ +#define setbit(a,i) (((unsigned char *)(a))[(i)/NBBY] |= 1<<((i)%NBBY)) +#define clrbit(a,i) (((unsigned char *)(a))[(i)/NBBY] &= ~(1<<((i)%NBBY))) +#define isset(a,i) \ + (((const unsigned char *)(a))[(i)/NBBY] & (1<<((i)%NBBY))) +#define isclr(a,i) \ + ((((const unsigned char *)(a))[(i)/NBBY] & (1<<((i)%NBBY))) == 0) + +/* Macros for counting and rounding. */ +#ifndef howmany +#define howmany(x, y) (((x)+((y)-1))/(y)) +#endif +#define rounddown(x, y) (((x)/(y))*(y)) +#define roundup(x, y) ((((x)+((y)-1))/(y))*(y)) /* to any y */ +#define roundup2(x, y) (((x)+((y)-1))&(~((y)-1))) /* if y is powers of two */ +#define powerof2(x) ((((x)-1)&(x))==0) + +/* Macros for min/max. */ +#if !(defined(KERNEL) || defined(_KERNEL)) +#define MIN(a,b) (((a)<(b))?(a):(b)) +#define MAX(a,b) (((a)>(b))?(a):(b)) +#endif + +/* + * Constants for setting the parameters of the kernel memory allocator. + * + * 2 ** MINBUCKET is the smallest unit of memory that will be + * allocated. It must be at least large enough to hold a pointer. + * + * Units of memory less or equal to MAXALLOCSAVE will permanently + * allocate physical memory; requests for these size pieces of + * memory are quite fast. Allocations greater than MAXALLOCSAVE must + * always allocate and free physical memory; requests for these + * size allocations should be done infrequently as they will be slow. + * + * Constraints: PAGE_SIZE <= MAXALLOCSAVE <= 2 ** (MINBUCKET + 14), and + * MAXALLOCSIZE must be a power of two. + */ +#define MINBUCKET 4 /* 4 => min allocation of 16 bytes */ +#define MAXALLOCSAVE (2 * PAGE_SIZE) + +/* + * Scale factor for scaled integers used to count %cpu time and load avgs. + * + * The number of CPU `tick's that map to a unique `%age' can be expressed + * by the formula (1 / (2 ^ (FSHIFT - 11))). The maximum load average that + * can be calculated (assuming 32 bits) can be closely approximated using + * the formula (2 ^ (2 * (16 - FSHIFT))) for (FSHIFT < 15). + * + * For the scheduler to maintain a 1:1 mapping of CPU `tick' to `%age', + * FSHIFT must be at least 11; this gives us a maximum load avg of ~1024. + */ +#define FSHIFT 11 /* bits to right of fixed binary point */ +#define FSCALE (1<<FSHIFT) + +#endif /* _SYS_PARAM_H_ */ diff --git a/newlib/libc/sys/rtems/include/sys/syslimits.h b/newlib/libc/sys/rtems/include/sys/syslimits.h new file mode 100644 index 000000000..2295afe34 --- /dev/null +++ b/newlib/libc/sys/rtems/include/sys/syslimits.h @@ -0,0 +1,64 @@ +/* + * Copyright (c) 1988, 1993 + * The Regents of the University of California. 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. All advertising materials mentioning features or use of this software + * must display the following acknowledgement: + * This product includes software developed by the University of + * California, Berkeley and its contributors. + * 4. Neither the name of the University nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE REGENTS 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 REGENTS 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. + * + * @(#)syslimits.h 8.1 (Berkeley) 6/2/93 + * $Id$ + */ + +#ifndef _SYS_SYSLIMITS_H_ +#define _SYS_SYSLIMITS_H_ + +#define ARG_MAX 4096 /* max bytes for an exec function */ +#ifndef CHILD_MAX +#define CHILD_MAX 6 /* max simultaneous processes */ +#endif +#define LINK_MAX 8 /* max file link count */ +#define MAX_CANON 255 /* max bytes in term canon input line */ +#define MAX_INPUT 255 /* max bytes in terminal input */ +#define NAME_MAX 255 /* max bytes in a file name */ +#define NGROUPS_MAX 15 /* max supplemental group id's */ +#ifndef OPEN_MAX +#define OPEN_MAX 64 /* max open files per process */ +#endif +#define PATH_MAX 255 /* max bytes in pathname */ +#define PIPE_BUF 512 /* max bytes for atomic pipe writes */ +#define IOV_MAX 1024 /* max elements in i/o vector */ +#define BC_BASE_MAX 99 /* max ibase/obase values in bc(1) */ +#define BC_DIM_MAX 2048 /* max array elements in bc(1) */ +#define BC_SCALE_MAX 99 /* max scale value in bc(1) */ +#define BC_STRING_MAX 1000 /* max const string length in bc(1) */ +#define COLL_WEIGHTS_MAX 0 /* max weights for order keyword */ +#define EXPR_NEST_MAX 32 /* max expressions nested in expr(1) */ +#define LINE_MAX 2048 /* max bytes in an input line */ +#define RE_DUP_MAX 255 /* max RE's in interval notation */ + +#endif diff --git a/newlib/libc/sys/rtems/include/sys/utime.h b/newlib/libc/sys/rtems/include/sys/utime.h new file mode 100644 index 000000000..561136bb4 --- /dev/null +++ b/newlib/libc/sys/rtems/include/sys/utime.h @@ -0,0 +1,34 @@ +/* + * $Id$ + */ + +#ifndef __UTIME_h__ +#define __UTIME_h__ + +#include <sys/types.h> + +#ifdef __cplusplus +extern "C" { +#endif + +/* + * POSIX 1003.1b 5.6.6 Set File Access and Modification Times + */ + +struct utimbuf { + time_t actime; /* Access time */ + time_t modtime; /* Modification time */ +}; + +/* Functions */ + +int utime( + const char *path, + const struct utimbuf *times +); + +#ifdef __cplusplus +}; +#endif + +#endif /* _SYS_UTIME_H */ |