+
+int __printf_chk(int flag __unused, const char *format, ...)
+{
+ va_list ap;
+ va_start (ap, format);
+ prom_vfprintf (prom_stdout, format, ap);
+ va_end (ap);
+
+ DEBUG_F("Stub function called");
+ return 0;
+}
+
+int __sprintf_chk(char *str __unused, int flag __unused,
+ size_t strlen __unused, const char * format __unused, ...)
+{
+ DEBUG_F("Stub function called");
+ return 0;
+
+}
+
+int __fprintf_chk(FILE *stream __unused, int flag __unused,
+ const char *format, ...)
+{
+ va_list ap;
+ va_start (ap, format);
+ prom_vfprintf (prom_stdout, format, ap);
+ va_end (ap);
+
+ return 0;
+}
+
+void *__memcpy_chk(void *dest, const void *src, size_t n,
+ size_t destlen __unused)
+{
+ DEBUG_F("Stub function called");
+ /* FIXME: We really could check that dest+destlen < src, to ensure
+ * we're not overwriting the src */
+ return memcpy(dest, src, n);
+}
+
+void perror(const char *s)
+{
+ DEBUG_F("Stub function called");
+ prom_printf(s);
+}
+
+void exit(int status __unused)
+{
+ prom_exit();
+ for(;;);
+}
+
+int ioctl(int d __unused, int request __unused, ...)
+{
+ DEBUG_F("Stub function called");
+ return 0;
+}
+
+/* As we do not implement fopen() I think we're only going to get called
+ * with stdout and stderr. If that's the case we degenerate to prom_write()
+ * on stdout */
+size_t fwrite(const void *ptr, size_t size, size_t nmemb, FILE *stream)
+{
+ if ((stream == stdout) || (stream == stderr)) {
+ DEBUG_F("Stub function called on known stream");
+ prom_write(prom_stdout, (void *)ptr, size * nmemb);
+ } else {
+ DEBUG_F("Stub function called on unknown stream");
+ }
+ return nmemb;
+}
+
+long sysconf(int name __unused)
+{
+ DEBUG_F("Stub function called");
+ return -1;
+}
+
+int getpagesize(void)
+{
+ DEBUG_F("Stub function called");
+ /* I think this is safe to assume */
+ return 4096;
+}
+
+void qsort(void *base __unused, size_t nmemb __unused, size_t size __unused,
+ int(*compar)(const void *, const void *))
+{
+ DEBUG_F("Stub function called");
+ /* I'm quite nervous about not implementing this. Could we end up with
+ * disk corruption. Couldn't we? */
+}
+
+/* FIXME: I'd like to call prom_write here, but we can't ber certain that
+ * we'll have "text" so just move along nothing to see here
+ */
+ssize_t write(int fd, const void *buf, size_t count)
+{
+ DEBUG_F("Stub function called");
+ return 0;
+}
+
+int fallocate(int fd __unused, int mode __unused, off_t offset __unused,
+ off_t len __unused)
+{
+ DEBUG_F("Stub function called");
+ return 0;
+}
+
+unsigned long long int strtoull(const char *nptr, char **endptr, int base)
+{
+ return simple_strtoull(nptr, endptr, base);
+}
+
+int fsync(int fd __unused)
+{
+ DEBUG_F("Stub function called");
+ return 0;
+}
+
+/* Return EFAULT here as it's too hard in yaboot to know the size of struct
+ * utsname. If we don't touch it and return 0 bad things might happen.
+ * Lets hope the caller handles failure
+ */
+int uname(struct utsname *buf __unused)
+{
+ DEBUG_F("Stub function called");
+ return EFAULT;
+}
+
+int getrlimit(int resource __unused, struct rlimit *rlim __unused)
+{
+ DEBUG_F("Stub function called");
+ return 0;
+}
+
+int setrlimit(int resource __unused, const struct rlimit *rlim __unused)
+{
+ DEBUG_F("Stub function called");
+ return 0;
+}
+
+void __stack_chk_fail(void)
+{
+ DEBUG_F("Stub function called");
+}