proj/gentoo: Initial commit

This commit represents a new era for Gentoo:
Storing the gentoo-x86 tree in Git, as converted from CVS.

This commit is the start of the NEW history.
Any historical data is intended to be grafted onto this point.

Creation process:
1. Take final CVS checkout snapshot
2. Remove ALL ChangeLog* files
3. Transform all Manifests to thin
4. Remove empty Manifests
5. Convert all stale $Header$/$Id$ CVS keywords to non-expanded Git $Id$
5.1. Do not touch files with -kb/-ko keyword flags.

Signed-off-by: Robin H. Johnson <robbat2@gentoo.org>
X-Thanks: Alec Warner <antarus@gentoo.org> - did the GSoC 2006 migration tests
X-Thanks: Robin H. Johnson <robbat2@gentoo.org> - infra guy, herding this project
X-Thanks: Nguyen Thai Ngoc Duy <pclouds@gentoo.org> - Former Gentoo developer, wrote Git features for the migration
X-Thanks: Brian Harring <ferringb@gentoo.org> - wrote much python to improve cvs2svn
X-Thanks: Rich Freeman <rich0@gentoo.org> - validation scripts
X-Thanks: Patrick Lauer <patrick@gentoo.org> - Gentoo dev, running new 2014 work in migration
X-Thanks: Michał Górny <mgorny@gentoo.org> - scripts, QA, nagging
X-Thanks: All of other Gentoo developers - many ideas and lots of paint on the bikeshed

1 files changed, 231 insertions, 0 deletions

diff --git a/sys-boot/yaboot/files/yaboot-stubfuncs.patch b/sys-boot/yaboot/files/yaboot-stubfuncs.patch
new file mode 100644
index 000000000000..8ae522b7d4eb
--- /dev/null
+++ b/sys-boot/yaboot/files/yaboot-stubfuncs.patch
@@ -0,0 +1,231 @@
+Stub out some functions that are not provided (and unneeded)
+
+--- lib/malloc.c
++++ lib/malloc.c
+@@ -64,6 +64,15 @@ void *malloc (unsigned int size)
+     return caddr;
+ }
+ 
++/* Calloc wrapper for malloc */
++void *memset(void *s, int c, size_t n);
++void *calloc(size_t nmemb, size_t size) {
++	void *caddr;
++	caddr = malloc(nmemb * size);
++	memset(caddr, 0, nmemb * size);
++	return caddr;
++}
++
+ /* Do not fall back to the malloc above as posix_memalign is needed by
+  * external libraries not yaboot */
+ int posix_memalign(void **memptr, size_t alignment, size_t size)
+--- lib/nonstd.c
++++ lib/nonstd.c
+@@ -65,3 +65,208 @@
+ {
+ 	return NULL;
+ }
++
++int lseek(int fd, int offset, int whence) {
++	// XXX: This whence addition seems wrong ..
++	return prom_lseek((void *)fd, whence + offset);
++}
++
++int lseek64(int fd, int64_t offset, int whence) {
++	return lseek(fd, offset, whence);
++}
++
++int open(const char *pathname, int flags) {
++	return (int) prom_open((char *)pathname);
++}
++
++int open64(const char *pathname, int flags) {
++	return open(pathname, flags);
++}
++
++// Internal glibc fortify calls.
++int __open64_2(const char *path, int flags) {
++	return open64(path, flags);
++}
++
++int read(int fd, void *buf, size_t count) {
++	return prom_read((void *)fd, buf, count);
++}
++
++int write(int fd, const void *buf, size_t count) {
++	return prom_write((void *)fd, (void *)buf, count);
++}
++
++int close(int fd) {
++	prom_close((void *)fd);
++	return 0;
++}
++
++int pread(int fd, void *buf, size_t count, int32_t offset) {
++	int curr = lseek(fd, 0, 0 /*SEEK_CUR*/);
++	lseek(fd, offset, 0 /*SEEK_SET*/);
++	int ret = read(fd, buf, count);
++	lseek(fd, curr, 0 /*SEEK_SET*/);
++	return ret;
++}
++
++int pread64(int fd, void *buf, int64_t count, int64_t offset) {
++	return pread(fd, buf, count, offset);
++}
++
++int pwrite(int fd, const void *buf, size_t count, int32_t offset) {
++	int curr = lseek(fd, 0, 0 /*SEEK_CUR*/);
++	lseek(fd, offset, 0 /*SEEK_SET*/);
++	int ret = write(fd, buf, count);
++	lseek(fd, curr, 0 /*SEEK_SET*/);
++	return ret;
++}
++
++int pwrite64(int fd, const void *buf, int64_t count, int64_t offset) {
++	return pwrite(fd, buf, count, offset);
++}
++
++// No fsync, just assume we've sync'd
++int fsync(int fd) {
++	return 0;
++}
++
++// ext2 libs only use this to turn off caches currently
++int fcntl(int fd, int cmd, ...) {
++	return 0;
++}
++
++void exit(int status) {
++	prom_exit();
++}
++
++int __printf_chk(int flag, const char *format, ...) {
++	va_list ap;
++	va_start (ap, format);
++	prom_vfprintf (prom_stdout, format, ap);
++	va_end (ap);
++
++	return 0;
++}
++
++int __sprintf_chk(char * str, int flag, size_t strlen, const char * format, ...) {
++	va_list ap;
++	va_start(ap, format);
++	// No sprintf? :(
++	va_end(ap);
++	return 0;
++
++}
++
++int __fprintf_chk(FILE *stream, int flag, const char *format, ...) {
++	va_list ap;
++	va_start (ap, format);
++	prom_vfprintf (prom_stdout, format, ap);
++	va_end (ap);
++
++	return 0;
++}
++
++void *memcpy(void *dest, const void *src, size_t n);
++void *__memcpy_chk(void *dest, const void *src, size_t n, size_t destlen) {
++	return memcpy(dest, src, n);
++}
++
++// But these are all dummy functions
++int __xstat64 (int __ver, const char *__filename, void *__stat_buf) {
++	return 0;
++}
++
++int stat64(const char *path, void *stat_buf) {
++	return 0;
++}
++
++int fstat64(int fildes, void *stat_buf) {
++	return 0;
++}
++
++int __fxstat64 (int __ver, int __filedesc, void *__stat_buf) {
++	return 0;
++}
++
++signed int random(void) {
++	return 0;
++}
++
++void srandom(unsigned int seed) {
++	return;
++}
++
++int rand(void) {
++	return 0;
++}
++
++void srand(unsigned int seed) {
++	return;
++}
++
++unsigned int sleep(unsigned int seconds) {
++	return 0;
++}
++
++int gettimeofday(void *tv, void *tz) {
++	return 0;
++}
++
++long sysconf(int name) {
++	return 0;
++}
++
++int getpagesize(void) {
++	return 0;
++}
++
++int gethostname(char *name, size_t len) {
++	return 0;
++}
++
++int getpid(void) {
++	return 0;
++}
++
++int getuid(void) {
++	return 0;
++}
++
++void qsort(void *base, size_t nmemb, size_t size, int(*compar)(const void *, const void *)) {
++	return;
++}
++
++int * __errno_location(void) {
++	return 0;
++}
++
++size_t fwrite(const void *ptr, size_t size, size_t nmemb, void *stream) {
++	return 0;
++}
++
++int ioctl(int d, int request, ...) {
++	return 0;
++}
++
++int fallocate(int fd, int mode, unsigned int offset, unsigned int len) {
++	return 0;
++}
++
++int uname(void *buf) {
++	return 0;
++}
++
++int setrlimit(int resource, void *rlim) {
++	return 0;
++}
++
++unsigned long long int strtoull(const char *nptr, char **endptr, int base) {
++	return 0;
++}
++
++int getrlimit(int resource, void *rlim) {
++	return 0;
++}
++
++int stderr = 0;
++int perror = 0;