TicketNo:DTS2020061507341

Description:add unsupport api print
Team: OTHERS
Feature or Bugfix:Feature
Binary Source:No
PrivateCode(Yes/No):No

Change-Id: If54639f876c6c6d546f36f65a83e3d4ae94a58f0
Reviewed-on: http://mgit-tm.rnd.huawei.com/10522043Tested-by: Npublic jenkins <public_jenkins@notesmail.huawei.com>
Reviewed-by: Ncaoruihong 00546070 <crh.cao@huawei.com>
Reviewed-by: Nshenwei 00579521 <denny.shenwei@huawei.com>

src/aio/aio.c

@@ -6,6 +6,7 @@
 #include <unistd.h>
 #include <stdlib.h>
 #include <sys/auxv.h>
+#include <unsupported_api.h>
 #include "syscall.h"
 #include "atomic.h"
 #include "pthread_impl.h"
@@ -319,16 +320,19 @@ static int submit(struct aiocb *cb, int op)
 
 int aio_read(struct aiocb *cb)
 {
+	unsupported_api(__FUNCTION__);
 	return submit(cb, LIO_READ);
 }
 
 int aio_write(struct aiocb *cb)
 {
+	unsupported_api(__FUNCTION__);
 	return submit(cb, LIO_WRITE);
 }
 
 int aio_fsync(int op, struct aiocb *cb)
 {
+	unsupported_api(__FUNCTION__);
 	if (op != O_SYNC && op != O_DSYNC) {
 		errno = EINVAL;
 		return -1;
@@ -338,11 +342,13 @@ int aio_fsync(int op, struct aiocb *cb)
 
 ssize_t aio_return(struct aiocb *cb)
 {
+	unsupported_api(__FUNCTION__);
 	return cb->__ret;
 }
 
 int aio_error(const struct aiocb *cb)
 {
+	unsupported_api(__FUNCTION__);
 	a_barrier();
 	return cb->__err & 0x7fffffff;
 }
@@ -354,6 +360,7 @@ int aio_cancel(int fd, struct aiocb *cb)
 	struct aio_thread *p;
 	struct aio_queue *q;
 
+	unsupported_api(__FUNCTION__);
 	/* Unspecified behavior case. Report an error. */
 	if (cb && fd != cb->aio_fildes) {
 		errno = EINVAL;

src/aio/aio_suspend.c

 #include <aio.h>
 #include <errno.h>
 #include <time.h>
+#include <unsupported_api.h>
 #include "atomic.h"
 #include "pthread_impl.h"
 
@@ -12,6 +13,7 @@ int aio_suspend(const struct aiocb *const cbs[], int cnt, const struct timespec
 	int nzcnt = 0;
 	const struct aiocb *cb = 0;
 
+	unsupported_api(__FUNCTION__);
 	pthread_testcancel();
 
 	if (cnt<0) {

src/conf/confstr.c

 #include <unistd.h>
 #include <stdio.h>
 #include <errno.h>
+#include <unsupported_api.h>
 
 size_t confstr(int name, char *buf, size_t len)
 {
 	const char *s = "";
+
+	unsupported_api(__FUNCTION__);
 	if (!name) {
 		s = "/bin:/usr/bin";
 	} else if ((name&~4U)!=1 && name-_CS_POSIX_V6_ILP32_OFF32_CFLAGS>33U) {

src/conf/fpathconf.c

 #include <unistd.h>
 #include <limits.h>
 #include <errno.h>
+#include <unsupported_api.h>
 
 long fpathconf(int fd, int name)
 {
@@ -27,6 +28,7 @@ long fpathconf(int fd, int name)
 		[_PC_SYMLINK_MAX] = -1,
 		[_PC_2_SYMLINKS] = 1
 	};
+	unsupported_api(__FUNCTION__);
 	if (name >= sizeof(values)/sizeof(values[0])) {
 		errno = EINVAL;
 		return -1;

src/conf/sysconf.c

@@ -4,6 +4,7 @@
 #include <sys/resource.h>
 #include <signal.h>
 #include <sys/sysinfo.h>
+#include <unsupported_api.h>
 #include "syscall.h"
 #include "libc.h"
 
@@ -166,7 +167,7 @@ long sysconf(int name)
 		[_SC_THREAD_ROBUST_PRIO_INHERIT] = -1,
 		[_SC_THREAD_ROBUST_PRIO_PROTECT] = -1,
 	};
-
+	unsupported_api(__FUNCTION__);
 	if (name >= sizeof(values)/sizeof(values[0]) || !values[name]) {
 		errno = EINVAL;
 		return -1;

src/crypt/encrypt.c

 #include <stdint.h>
 #include <stdlib.h>
 #include <unistd.h>
+#include <unsupported_api.h>
 
 #include "crypt_des.h"
 
@@ -11,6 +12,7 @@ void setkey(const char *key)
 	unsigned char bkey[8];
 	int i, j;
 
+	unsupported_api(__FUNCTION__);
 	for (i = 0; i < 8; i++) {
 		bkey[i] = 0;
 		for (j = 7; j >= 0; j--, key++)
@@ -27,6 +29,7 @@ void encrypt(char *block, int edflag)
 	int i, j;
 	char *p;
 
+	unsupported_api(__FUNCTION__);
 	p = block;
 	for (i = 0; i < 2; i++) {
 		b[i] = 0;

src/ctype/wcswidth.c

 #include <wchar.h>
+#include <unsupported_api.h>
 
 int wcswidth(const wchar_t *wcs, size_t n)
 {
 	int l=0, k=0;
+	unsupported_api(__FUNCTION__);
 	for (; n-- && *wcs && (k = wcwidth(*wcs)) >= 0; l+=k, wcs++);
 	return (k < 0) ? k : l;
 }

src/ctype/wcwidth.c

 #include <wchar.h>
+#include <unsupported_api.h>
 
 static const unsigned char table[] = {
 #include "nonspacing.h"
@@ -10,6 +11,7 @@ static const unsigned char wtable[] = {
 
 int wcwidth(wchar_t wc)
 {
+	unsupported_api(__FUNCTION__);
 	if (wc < 0xffU)
 		return (wc+1 & 0x7f) >= 0x21 ? 1 : wc ? -1 : 0;
 	if ((wc & 0xfffeffffU) < 0xfffe) {

src/dirent/dirfd.c

 #include <dirent.h>
 #include "__dirent.h"
+#include <unsupported_api.h>
 
 int dirfd(DIR *d)
 {
+	unsupported_api(__FUNCTION__);
 	return d->fd;
 }

src/dirent/fdopendir.c

@@ -4,12 +4,15 @@
 #include <errno.h>
 #include <stdlib.h>
 #include "__dirent.h"
+#include <unsupported_api.h>
 
 DIR *fdopendir(int fd)
 {
 	DIR *dir;
 	struct stat st;
 
+	unsupported_api(__FUNCTION__);
+
 	if (fstat(fd, &st) < 0) {
 		return 0;
 	}

src/env/unsetenv.c

@@ -2,12 +2,14 @@
 #include <string.h>
 #include <errno.h>
 #include <unistd.h>
+#include <unsupported_api.h>
 
 static void dummy(char *old, char *new) {}
 weak_alias(dummy, __env_rm_add);
 
 int unsetenv(const char *name)
 {
+	unsupported_api(__FUNCTION__);
 	size_t l = __strchrnul(name, '=') - name;
 	if (!l || name[l]) {
 		errno = EINVAL;

src/fcntl/openat.c

 #include <fcntl.h>
 #include <stdarg.h>
 #include "syscall.h"
+#include <unsupported_api.h>
 
 int openat(int fd, const char *filename, int flags, ...)
 {
 	mode_t mode = 0;
 
+	unsupported_api(__FUNCTION__);
 	if ((flags & O_CREAT) || (flags & O_TMPFILE) == O_TMPFILE) {
 		va_list ap;
 		va_start(ap, flags);

src/fcntl/posix_fadvise.c

 #include <fcntl.h>
+#include <unsupported_api.h>
+
 #include "syscall.h"
 
 int posix_fadvise(int fd, off_t base, off_t len, int advice)
 {
+	unsupported_api(__FUNCTION__);
 #if defined(SYSCALL_FADVISE_6_ARG)
 	/* Some archs, at least arm and powerpc, have the syscall
 	 * arguments reordered to avoid needing 7 argument registers

src/internal/unsupported_api.h

+#ifndef UNSUPPORTED_API_H
+#define UNSUPPORTED_API_H
+
+#include <stdio.h>
+
+static inline void unsupported_api(const char *func)
+{
+	fprintf(stderr, "[ERR]Unsupported API %s\n", func);
+}
+
+#endif

src/ipc/ftok.c

 #include <sys/ipc.h>
 #include <sys/stat.h>
+#include <unsupported_api.h>
 
 key_t ftok(const char *path, int id)
 {
 	struct stat st;
+	unsupported_api(__FUNCTION__);
 	if (stat(path, &st) < 0) return -1;
 
 	return ((st.st_ino & 0xffff) | ((st.st_dev & 0xff) << 16) | ((id & 0xffu) << 24));

src/ipc/msgctl.c

 #include <sys/msg.h>
 #include <endian.h>
+#include <unsupported_api.h>
+
 #include "syscall.h"
 #include "ipc.h"
 
@@ -9,6 +11,7 @@
 
 int msgctl(int q, int cmd, struct msqid_ds *buf)
 {
+	unsupported_api(__FUNCTION__);
 #ifdef SYSCALL_IPC_BROKEN_MODE
 	struct msqid_ds tmp;
 	if (cmd == IPC_SET) {

src/ipc/msgget.c

 #include <sys/msg.h>
+#include <unsupported_api.h>
+
 #include "syscall.h"
 #include "ipc.h"
 
 int msgget(key_t k, int flag)
 {
+	unsupported_api(__FUNCTION__);
 #ifndef SYS_ipc
 	return syscall(SYS_msgget, k, flag);
 #else

src/ipc/msgrcv.c

 #include <sys/msg.h>
+#include <unsupported_api.h>
+
 #include "syscall.h"
 #include "ipc.h"
 
 ssize_t msgrcv(int q, void *m, size_t len, long type, int flag)
 {
+	unsupported_api(__FUNCTION__);
 #ifndef SYS_ipc
 	return syscall_cp(SYS_msgrcv, q, m, len, type, flag);
 #else

src/ipc/msgsnd.c

+#include <unsupported_api.h>
 #include <sys/msg.h>
 #include "syscall.h"
 #include "ipc.h"
 
 int msgsnd(int q, const void *m, size_t len, int flag)
 {
+	unsupported_api(__FUNCTION__);
 #ifndef SYS_ipc
 	return syscall_cp(SYS_msgsnd, q, m, len, flag);
 #else

src/ipc/semctl.c

 #include <sys/sem.h>
 #include <stdarg.h>
 #include <endian.h>
+#include <unsupported_api.h>
+
 #include "syscall.h"
 #include "ipc.h"
 
@@ -16,6 +18,7 @@ union semun {
 
 int semctl(int id, int num, int cmd, ...)
 {
+	unsupported_api(__FUNCTION__);
 	union semun arg = {0};
 	va_list ap;
 	switch (cmd & ~IPC_TIME64) {

src/ipc/semget.c

 #include <sys/sem.h>
 #include <limits.h>
 #include <errno.h>
+#include <unsupported_api.h>
+
 #include "syscall.h"
 #include "ipc.h"
 
@@ -10,6 +12,7 @@ int semget(key_t key, int n, int fl)
 	 * of struct semid_ds, and thus might not check that the
 	 * n fits in the correct (per POSIX) userspace type, so
 	 * we have to check here. */
+	unsupported_api(__FUNCTION__);
 	if (n > USHRT_MAX) return __syscall_ret(-EINVAL);
 #ifndef SYS_ipc
 	return syscall(SYS_semget, key, n, fl);

src/ipc/semop.c

 #include <sys/sem.h>
+#include <unsupported_api.h>
+
 #include "syscall.h"
 #include "ipc.h"
 
 int semop(int id, struct sembuf *buf, size_t n)
 {
+	unsupported_api(__FUNCTION__);
 #ifndef SYS_ipc
 	return syscall(SYS_semop, id, buf, n);
 #else

src/legacy/daemon.c

 #define _GNU_SOURCE
 #include <fcntl.h>
 #include <unistd.h>
+#include <unsupported_api.h>
 
 int daemon(int nochdir, int noclose)
 {
+	unsupported_api(__FUNCTION__);
 	if (!nochdir && chdir("/"))
 		return -1;
 	if (!noclose) {

src/legacy/getdtablesize.c

@@ -2,10 +2,12 @@
 #include <unistd.h>
 #include <limits.h>
 #include <sys/resource.h>
+#include <unsupported_api.h>
 
 int getdtablesize(void)
 {
 	struct rlimit rl;
+	unsupported_api(__FUNCTION__);
 	getrlimit(RLIMIT_NOFILE, &rl);
 	return rl.rlim_cur < INT_MAX ? rl.rlim_cur : INT_MAX;
 }

src/legacy/getusershell.c

 #define _GNU_SOURCE
 #include <stdio.h>
 #include <unistd.h>
+#include <unsupported_api.h>
 
 static const char defshells[] = "/bin/sh\n/bin/csh\n";
 
@@ -10,6 +11,7 @@ static FILE *f;
 
 void endusershell(void)
 {
+	unsupported_api(__FUNCTION__);
 	if (f) fclose(f);
 	f = 0;
 }

src/legacy/isastream.c

 #include <stropts.h>
 #include <fcntl.h>
-
+#include <unsupported_api.h>
 int isastream(int fd)
 {
+	unsupported_api(__FUNCTION__);
 	return fcntl(fd, F_GETFD) < 0 ? -1 : 0;
 }

src/legacy/ulimit.c

 #include <sys/resource.h>
 #include <ulimit.h>
 #include <stdarg.h>
+#include <unsupported_api.h>
 
 long ulimit(int cmd, ...)
 {
 	struct rlimit rl;
+	unsupported_api(__FUNCTION__);
 	getrlimit(RLIMIT_FSIZE, &rl);
 	if (cmd == UL_SETFSIZE) {
 		long val;

src/legacy/utmpx.c

@@ -2,41 +2,50 @@
 #include <utmpx.h>
 #include <stddef.h>
 #include <errno.h>
+#include <unsupported_api.h>
 
 void endutxent(void)
 {
+	unsupported_api(__FUNCTION__);
 }
 
 void setutxent(void)
 {
+	unsupported_api(__FUNCTION__);
 }
 
 struct utmpx *getutxent(void)
 {
+	unsupported_api(__FUNCTION__);
 	return NULL;
 }
 
 struct utmpx *getutxid(const struct utmpx *ut)
 {
+	unsupported_api(__FUNCTION__);
 	return NULL;
 }
 
 struct utmpx *getutxline(const struct utmpx *ut)
 {
+	unsupported_api(__FUNCTION__);
 	return NULL;
 }
 
 struct utmpx *pututxline(const struct utmpx *ut)
 {
+	unsupported_api(__FUNCTION__);
 	return NULL;
 }
 
 void updwtmpx(const char *f, const struct utmpx *u)
 {
+	unsupported_api(__FUNCTION__);
 }
 
 static int __utmpxname(const char *f)
 {
+	unsupported_api(__FUNCTION__);
 	errno = ENOTSUP;
 	return -1;
 }

src/linux/adjtime.c

@@ -3,10 +3,12 @@
 #include <sys/timex.h>
 #include <errno.h>
 #include "syscall.h"
+#include <unsupported_api.h>
 
 int adjtime(const struct timeval *in, struct timeval *out)
 {
 	struct timex tx = { 0 };
+	unsupported_api(__FUNCTION__);
 	if (in) {
 		if (in->tv_sec > 1000 || in->tv_usec > 1000000000) {
 			errno = EINVAL;

src/linux/clone.c

@@ -4,6 +4,7 @@
 #include <sched.h>
 #include "pthread_impl.h"
 #include "syscall.h"
+#include <unsupported_api.h>
 
 int clone(int (*func)(void *), void *stack, int flags, void *arg, ...)
 {
@@ -11,6 +12,7 @@ int clone(int (*func)(void *), void *stack, int flags, void *arg, ...)
 	pid_t *ptid, *ctid;
 	void  *tls;
 
+	unsupported_api(__FUNCTION__);
 	va_start(ap, arg);
 	ptid = va_arg(ap, pid_t *);
 	tls  = va_arg(ap, void *);

src/linux/epoll.c

@@ -2,9 +2,11 @@
 #include <signal.h>
 #include <errno.h>
 #include "syscall.h"
+#include <unsupported_api.h>
 
 int epoll_create(int size)
 {
+	unsupported_api(__FUNCTION__);
 	return epoll_create1(0);
 }
 
@@ -19,6 +21,7 @@ int epoll_create1(int flags)
 
 int epoll_ctl(int fd, int op, int fd2, struct epoll_event *ev)
 {
+	unsupported_api(__FUNCTION__);
 	return syscall(SYS_epoll_ctl, fd, op, fd2, ev);
 }
 
@@ -33,5 +36,6 @@ int epoll_pwait(int fd, struct epoll_event *ev, int cnt, int to, const sigset_t
 
 int epoll_wait(int fd, struct epoll_event *ev, int cnt, int to)
 {
+	unsupported_api(__FUNCTION__);
 	return epoll_pwait(fd, ev, cnt, to, 0);
 }

src/linux/ppoll.c

@@ -3,6 +3,7 @@
 #include <signal.h>
 #include <errno.h>
 #include "syscall.h"
+#include <unsupported_api.h>
 
 #define IS32BIT(x) !((x)+0x80000000ULL>>32)
 #define CLAMP(x) (int)(IS32BIT(x) ? (x) : 0x7fffffffU+((0ULL+(x))>>63))
@@ -11,6 +12,7 @@ int ppoll(struct pollfd *fds, nfds_t n, const struct timespec *to, const sigset_
 {
 	time_t s = to ? to->tv_sec : 0;
 	long ns = to ? to->tv_nsec : 0;
+	unsupported_api(__FUNCTION__);
 #ifdef SYS_ppoll_time64
 	int r = -ENOSYS;
 	if (SYS_ppoll == SYS_ppoll_time64 || !IS32BIT(s))

src/linux/utimes.c

 #include <sys/time.h>
+#include <unsupported_api.h>
 #include "fcntl.h"
 #include "syscall.h"
 
 int utimes(const char *path, const struct timeval times[2])
 {
+	unsupported_api(__FUNCTION__);
 	return __futimesat(AT_FDCWD, path, times);
 }

src/locale/dcngettext.c

@@ -6,6 +6,7 @@
 #include <sys/stat.h>
 #include <sys/mman.h>
 #include <ctype.h>
+#include <unsupported_api.h>
 #include "locale_impl.h"
 #include "atomic.h"
 #include "pleval.h"
@@ -258,15 +259,18 @@ notrans:
 
 char *dcgettext(const char *domainname, const char *msgid, int category)
 {
+	unsupported_api(__FUNCTION__);
 	return dcngettext(domainname, msgid, 0, 1, category);
 }
 
 char *dngettext(const char *domainname, const char *msgid1, const char *msgid2, unsigned long int n)
 {
+	unsupported_api(__FUNCTION__);
 	return dcngettext(domainname, msgid1, msgid2, n, LC_MESSAGES);
 }
 
 char *dgettext(const char *domainname, const char *msgid)
 {
+	unsupported_api(__FUNCTION__);
 	return dcngettext(domainname, msgid, 0, 1, LC_MESSAGES);
 }

src/locale/duplocale.c

 #include <stdlib.h>
 #include <string.h>
+#include <unsupported_api.h>
 #include "locale_impl.h"
 #include "libc.h"
 
 locale_t __duplocale(locale_t old)
 {
 	locale_t new = malloc(sizeof *new);
+	unsupported_api(__FUNCTION__);
 	if (!new) return 0;
 	if (old == LC_GLOBAL_LOCALE) old = &libc.global_locale;
 	*new = *old;

src/locale/freelocale.c

 #include <stdlib.h>
+#include <unsupported_api.h>
 #include "locale_impl.h"
 
 void freelocale(locale_t l)
 {
+	unsupported_api(__FUNCTION__);
 	if (__loc_is_allocated(l)) free(l);
 }
 

src/locale/langinfo.c

 #include <locale.h>
 #include <langinfo.h>
+#include <unsupported_api.h>
 #include "locale_impl.h"
 
 static const char c_time[] =
@@ -32,12 +33,14 @@ char *__nl_langinfo_l(nl_item item, locale_t loc)
 	int idx = item & 65535;
 	const char *str;
 
+	unsupported_api(__FUNCTION__);
+
 	if (item == CODESET) return loc->cat[LC_CTYPE] ? "UTF-8" : "ASCII";
 
 	/* _NL_LOCALE_NAME extension */
 	if (idx == 65535 && cat < LC_ALL)
 		return loc->cat[cat] ? (char *)loc->cat[cat]->name : "C";
-	
+
 	switch (cat) {
 	case LC_NUMERIC:
 		if (idx > 1) return "";
@@ -66,6 +69,7 @@ char *__nl_langinfo_l(nl_item item, locale_t loc)
 
 char *__nl_langinfo(nl_item item)
 {
+	unsupported_api(__FUNCTION__);
 	return __nl_langinfo_l(item, CURRENT_LOCALE);
 }
 

src/locale/newlocale.c

@@ -2,6 +2,7 @@
 #include <string.h>
 #include <pthread.h>
 #include "locale_impl.h"
+#include <unsupported_api.h>
 
 static pthread_once_t default_locale_once;
 static struct __locale_struct default_locale, default_ctype_locale;
@@ -23,6 +24,7 @@ locale_t __newlocale(int mask, const char *name, locale_t loc)
 {
 	struct __locale_struct tmp;
 
+	unsupported_api(__FUNCTION__);
 	for (int i=0; i<LC_ALL; i++) {
 		tmp.cat[i] = (!(mask & (1<<i)) && loc) ? loc->cat[i] :
 			__get_locale(i, (mask & (1<<i)) ? name : "");

src/locale/strfmon.c

@@ -3,6 +3,7 @@
 #include <stdarg.h>
 #include <monetary.h>
 #include <errno.h>
+#include <unsupported_api.h>
 #include "locale_impl.h"
 
 static ssize_t vstrfmon_l(char *s, size_t n, locale_t loc, const char *fmt, va_list ap)
@@ -80,6 +81,7 @@ ssize_t strfmon_l(char *restrict s, size_t n, locale_t loc, const char *restrict
 	va_list ap;
 	ssize_t ret;
 
+	unsupported_api(__FUNCTION__);
 	va_start(ap, fmt);
 	ret = vstrfmon_l(s, n, loc, fmt, ap);
 	va_end(ap);

src/locale/strxfrm.c

 #include <string.h>
 #include <locale.h>
+#include <unsupported_api.h>
 #include "locale_impl.h"
 
 /* collate only by code points */
 size_t __strxfrm_l(char *restrict dest, const char *restrict src, size_t n, locale_t loc)
 {
+	unsupported_api(__FUNCTION__);
 	size_t l = strlen(src);
 	if (n > l) strcpy(dest, src);
 	return l;

src/locale/textdomain.c

@@ -3,6 +3,7 @@
 #include <stdlib.h>
 #include <errno.h>
 #include <limits.h>
+#include <unsupported_api.h>
 
 static char *current_domain;
 
@@ -13,6 +14,7 @@ char *__gettextdomain()
 
 char *textdomain(const char *domainname)
 {
+	unsupported_api(__FUNCTION__);
 	if (!domainname) return __gettextdomain();
 
 	size_t domlen = strlen(domainname);
@@ -33,10 +35,12 @@ char *textdomain(const char *domainname)
 
 char *gettext(const char *msgid)
 {
+	unsupported_api(__FUNCTION__);
 	return dgettext(0, msgid);
 }
 
 char *ngettext(const char *msgid1, const char *msgid2, unsigned long int n)
 {
+	unsupported_api(__FUNCTION__);
 	return dngettext(0, msgid1, msgid2, n);
 }

src/locale/uselocale.c

+#include <unsupported_api.h>
 #include "locale_impl.h"
 #include "pthread_impl.h"
 #include "libc.h"
 
 locale_t __uselocale(locale_t new)
 {
+	unsupported_api(__FUNCTION__);
 	pthread_t self = __pthread_self();
 	locale_t old = self->locale;
 	locale_t global = &libc.global_locale;

src/misc/gethostid.c

 #include <unistd.h>
+#include <unsupported_api.h>
 
 long gethostid()
 {
+	unsupported_api(__FUNCTION__);
 	return 0;
 }

src/misc/getrlimit.c

 #include <sys/resource.h>
 #include <errno.h>
+#include <unsupported_api.h>
 #include "syscall.h"
 
 #define FIX(x) do{ if ((x)>=SYSCALL_RLIM_INFINITY) (x)=RLIM_INFINITY; }while(0)
@@ -7,6 +8,7 @@
 int getrlimit(int resource, struct rlimit *rlim)
 {
 	unsigned long k_rlim[2];
+	unsupported_api(__FUNCTION__);
 	int ret = syscall(SYS_prlimit64, 0, resource, 0, rlim);
 	if (!ret) {
 		FIX(rlim->rlim_cur);

src/misc/getrusage.c

 #include <sys/resource.h>
 #include <string.h>
 #include <errno.h>
+#include <unsupported_api.h>
 #include "syscall.h"
 
 int getrusage(int who, struct rusage *ru)
 {
 	int r;
+	unsupported_api(__FUNCTION__);
 #ifdef SYS_getrusage_time64
 	long long kru64[18];
 	r = __syscall(SYS_getrusage_time64, who, kru64);

src/misc/lockf.c

 #include <unistd.h>
 #include <fcntl.h>
 #include <errno.h>
+#include <unsupported_api.h>
 
 int lockf(int fd, int op, off_t size)
 {
@@ -9,6 +10,7 @@ int lockf(int fd, int op, off_t size)
 		.l_whence = SEEK_CUR,
 		.l_len = size,
 	};
+	unsupported_api(__FUNCTION__);
 	switch (op) {
 	case F_TEST:
 		l.l_type = F_RDLCK;

src/misc/mntent.c

@@ -2,6 +2,7 @@
 #include <string.h>
 #include <mntent.h>
 #include <errno.h>
+#include <unsupported_api.h>
 
 static char *internal_buf;
 static size_t internal_bufsize;
@@ -10,6 +11,7 @@ static size_t internal_bufsize;
 
 FILE *setmntent(const char *name, const char *mode)
 {
+	unsupported_api(__FUNCTION__);
 	return fopen(name, mode);
 }
 
@@ -26,6 +28,7 @@ struct mntent *getmntent_r(FILE *f, struct mntent *mnt, char *linebuf, int bufle
 	mnt->mnt_freq = 0;
 	mnt->mnt_passno = 0;
 
+	unsupported_api(__FUNCTION__);
 	do {
 		if (use_internal) {
 			getline(&internal_buf, &internal_bufsize, f);
@@ -60,11 +63,13 @@ struct mntent *getmntent_r(FILE *f, struct mntent *mnt, char *linebuf, int bufle
 struct mntent *getmntent(FILE *f)
 {
 	static struct mntent mnt;
+	unsupported_api(__FUNCTION__);
 	return getmntent_r(f, &mnt, SENTINEL, 0);
 }
 
 int addmntent(FILE *f, const struct mntent *mnt)
 {
+	unsupported_api(__FUNCTION__);
 	if (fseek(f, 0, SEEK_END)) return 1;
 	return fprintf(f, "%s\t%s\t%s\t%s\t%d\t%d\n",
 		mnt->mnt_fsname, mnt->mnt_dir, mnt->mnt_type, mnt->mnt_opts,
@@ -73,5 +78,6 @@ int addmntent(FILE *f, const struct mntent *mnt)
 
 char *hasmntopt(const struct mntent *mnt, const char *opt)
 {
+	unsupported_api(__FUNCTION__);
 	return strstr(mnt->mnt_opts, opt);
 }

src/misc/openpty.c

@@ -4,6 +4,7 @@
 #include <pty.h>
 #include <stdio.h>
 #include <pthread.h>
+#include <unsupported_api.h>
 
 /* Nonstandard, but vastly superior to the standard functions */
 
@@ -12,6 +13,7 @@ int openpty(int *pm, int *ps, char *name, const struct termios *tio, const struc
 	int m, s, n=0, cs;
 	char buf[20];
 
+	unsupported_api(__FUNCTION__);
 	m = open("/dev/ptmx", O_RDWR|O_NOCTTY);
 	if (m < 0) return -1;
 

src/misc/pty.c

@@ -3,10 +3,12 @@
 #include <stdio.h>
 #include <fcntl.h>
 #include <errno.h>
+#include <unsupported_api.h>
 #include "syscall.h"
 
 int posix_openpt(int flags)
 {
+	unsupported_api(__FUNCTION__);
 	int r = open("/dev/ptmx", flags);
 	if (r < 0 && errno == ENOSPC) errno = EAGAIN;
 	return r;
@@ -14,6 +16,7 @@ int posix_openpt(int flags)
 
 int grantpt(int fd)
 {
+	unsupported_api(__FUNCTION__);
 	return 0;
 }
 

src/misc/setrlimit.c

 #include <sys/resource.h>
 #include <errno.h>
+#include <unsupported_api.h>
 #include "syscall.h"
 #include "libc.h"
 
@@ -38,6 +39,7 @@ static void do_setrlimit(void *p)
 
 int setrlimit(int resource, const struct rlimit *rlim)
 {
+	unsupported_api(__FUNCTION__);
 	struct ctx c = { .res = resource, .rlim = rlim, .err = -1 };
 	__synccall(do_setrlimit, &c);
 	if (c.err) {

src/misc/syslog.c

@@ -9,6 +9,7 @@
 #include <pthread.h>
 #include <errno.h>
 #include <fcntl.h>
+#include <unsupported_api.h>
 #include "lock.h"
 
 static volatile int lock[1];
@@ -20,6 +21,7 @@ static int log_fd = -1;
 
 int setlogmask(int maskpri)
 {
+	unsupported_api(__FUNCTION__);
 	LOCK(lock);
 	int ret = log_mask;
 	if (maskpri) log_mask = maskpri;
@@ -38,6 +40,7 @@ static const struct {
 void closelog(void)
 {
 	int cs;
+	unsupported_api(__FUNCTION__);
 	pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &cs);
 	LOCK(lock);
 	close(log_fd);
@@ -55,6 +58,7 @@ static void __openlog()
 void openlog(const char *ident, int opt, int facility)
 {
 	int cs;
+	unsupported_api(__FUNCTION__);
 	pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &cs);
 	LOCK(lock);
 
@@ -135,6 +139,7 @@ static void __vsyslog(int priority, const char *message, va_list ap)
 
 void syslog(int priority, const char *message, ...)
 {
+	unsupported_api(__FUNCTION__);
 	va_list ap;
 	va_start(ap, message);
 	__vsyslog(priority, message, ap);

src/misc/wordexp.c

@@ -9,6 +9,7 @@
 #include <signal.h>
 #include <errno.h>
 #include <fcntl.h>
+#include <unsupported_api.h>
 #include "pthread_impl.h"
 
 static void reap(pid_t pid)
@@ -170,6 +171,7 @@ nospace:
 int wordexp(const char *restrict s, wordexp_t *restrict we, int flags)
 {
 	int r, cs;
+	unsupported_api(__FUNCTION__);
 	pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &cs);
 	r = do_wordexp(s, we, flags);
 	pthread_setcancelstate(cs, 0);

src/mman/mlock.c

 #include <sys/mman.h>
 #include "syscall.h"
+#include <unsupported_api.h>
 
 int mlock(const void *addr, size_t len)
 {
+	unsupported_api(__FUNCTION__);
 #ifdef SYS_mlock
 	return syscall(SYS_mlock, addr, len);
 #else

src/mman/mlockall.c

 #include <sys/mman.h>
+#include <unsupported_api.h>
 #include "syscall.h"
 
 int mlockall(int flags)
 {
+	unsupported_api(__FUNCTION__);
 	return syscall(SYS_mlockall, flags);
 }

src/mman/msync.c

 #include <sys/mman.h>
+#include <unsupported_api.h>
 #include "syscall.h"
 
 int msync(void *start, size_t len, int flags)
 {
+	unsupported_api(__FUNCTION__);
 	return syscall_cp(SYS_msync, start, len, flags);
 }

src/mman/munlock.c

 #include <sys/mman.h>
+#include <unsupported_api.h>
 #include "syscall.h"
 
 int munlock(const void *addr, size_t len)
 {
+	unsupported_api(__FUNCTION__);
 	return syscall(SYS_munlock, addr, len);
 }

src/mman/munlockall.c

 #include <sys/mman.h>
+#include <unsupported_api.h>
 #include "syscall.h"
 
 int munlockall(void)
 {
+	unsupported_api(__FUNCTION__);
 	return syscall(SYS_munlockall);
 }

src/mman/posix_madvise.c

 #define _GNU_SOURCE
 #include <sys/mman.h>
+#include <unsupported_api.h>
 #include "syscall.h"
 
 int posix_madvise(void *addr, size_t len, int advice)
 {
+	unsupported_api(__FUNCTION__);
 	if (advice == MADV_DONTNEED) return 0;
 	return -__syscall(SYS_madvise, addr, len, advice);
 }

src/mman/shm_open.c

@@ -5,6 +5,7 @@
 #include <string.h>
 #include <limits.h>
 #include <pthread.h>
+#include <unsupported_api.h>
 
 char *__shm_mapname(const char *name, char *buf)
 {
@@ -28,6 +29,7 @@ int shm_open(const char *name, int flag, mode_t mode)
 {
 	int cs;
 	char buf[NAME_MAX+10];
+	unsupported_api(__FUNCTION__);
 	if (!(name = __shm_mapname(name, buf))) return -1;
 	pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &cs);
 	int fd = open(name, flag|O_NOFOLLOW|O_CLOEXEC|O_NONBLOCK, mode);
@@ -38,6 +40,7 @@ int shm_open(const char *name, int flag, mode_t mode)
 int shm_unlink(const char *name)
 {
 	char buf[NAME_MAX+10];
+	unsupported_api(__FUNCTION__);
 	if (!(name = __shm_mapname(name, buf))) return -1;
 	return unlink(name);
 }

src/network/ent.c

 #include <netdb.h>
+#include <unsupported_api.h>
 
 void sethostent(int x)
 {
+	unsupported_api(__FUNCTION__);
 }
 
 struct hostent *gethostent()
 {
+	unsupported_api(__FUNCTION__);
 	return 0;
 }
 
 struct netent *getnetent()
 {
+	unsupported_api(__FUNCTION__);
 	return 0;
 }
 
 void endhostent(void)
 {
+	unsupported_api(__FUNCTION__);
 }
 
 weak_alias(sethostent, setnetent);

src/network/ether.c

 #include <stdlib.h>
 #include <netinet/ether.h>
 #include <stdio.h>
+#include <unsupported_api.h>
 
 struct ether_addr *ether_aton_r (const char *x, struct ether_addr *p_a)
 {
@@ -44,15 +45,18 @@ char *ether_ntoa (const struct ether_addr *p_a) {
 
 int ether_line(const char *l, struct ether_addr *e, char *hostname)
 {
+	unsupported_api(__FUNCTION__);
 	return -1;
 }
 
 int ether_ntohost(char *hostname, const struct ether_addr *e)
 {
+	unsupported_api(__FUNCTION__);
 	return -1;
 }
 
 int ether_hostton(const char *hostname, struct ether_addr *e)
 {
+	unsupported_api(__FUNCTION__);
 	return -1;
 }

src/network/freeaddrinfo.c

@@ -3,10 +3,12 @@
 #include <netdb.h>
 #include "lookup.h"
 #include "lock.h"
+#include <unsupported_api.h>
 
 void freeaddrinfo(struct addrinfo *p)
 {
 	size_t cnt;
+	unsupported_api(__FUNCTION__);
 	for (cnt=1; p->ai_next; cnt++, p=p->ai_next);
 	struct aibuf *b = (void *)((char *)p - offsetof(struct aibuf, ai));
 	b -= b->slot;

src/network/gai_strerror.c

 #include <netdb.h>
+#include <unsupported_api.h>
 #include "locale_impl.h"
 
 static const char msgs[] =
@@ -19,6 +20,7 @@ static const char msgs[] =
 const char *gai_strerror(int ecode)
 {
 	const char *s;
+	unsupported_api(__FUNCTION__);
 	for (s=msgs, ecode++; ecode && *s; ecode++, s++) for (; *s; s++);
 	if (!*s) s++;
 	return LCTRANS_CUR(s);

src/network/getaddrinfo.c

@@ -7,6 +7,7 @@
 #include <unistd.h>
 #include <endian.h>
 #include <errno.h>
+#include <unsupported_api.h>
 #include "lookup.h"
 
 int getaddrinfo(const char *restrict host, const char *restrict serv, const struct addrinfo *restrict hint, struct addrinfo **restrict res)
@@ -18,6 +19,8 @@ int getaddrinfo(const char *restrict host, const char *restrict serv, const stru
 	int family = AF_UNSPEC, flags = 0, proto = 0, socktype = 0;
 	struct aibuf *out;
 
+	unsupported_api(__FUNCTION__);
+
 	if (!host && !serv) return EAI_NONAME;
 
 	if (hint) {

src/network/gethostbyaddr.c

@@ -3,6 +3,7 @@
 #include <netdb.h>
 #include <errno.h>
 #include <stdlib.h>
+#include <unsupported_api.h>
 
 struct hostent *gethostbyaddr(const void *a, socklen_t l, int af)
 {
@@ -10,6 +11,7 @@ struct hostent *gethostbyaddr(const void *a, socklen_t l, int af)
 	size_t size = 63;
 	struct hostent *res;
 	int err;
+	unsupported_api(__FUNCTION__);
 	do {
 		free(h);
 		h = malloc(size+=size+1);

src/network/gethostbyaddr_r.c

@@ -6,6 +6,7 @@
 #include <netinet/in.h>
 #include <errno.h>
 #include <inttypes.h>
+#include <unsupported_api.h>
 
 int gethostbyaddr_r(const void *a, socklen_t l, int af,
 	struct hostent *h, char *buf, size_t buflen,
@@ -19,7 +20,7 @@ int gethostbyaddr_r(const void *a, socklen_t l, int af,
 	int i;
 
 	*res = 0;
-
+	unsupported_api(__FUNCTION__);
 	/* Load address argument into sockaddr structure */
 	if (af==AF_INET6 && l==16) memcpy(&sa.sin6.sin6_addr, a, 16);
 	else if (af==AF_INET && l==4) memcpy(&sa.sin.sin_addr, a, 4);

src/network/gethostbyname.c

@@ -4,8 +4,10 @@
 #include <netdb.h>
 #include <string.h>
 #include <netinet/in.h>
+#include <unsupported_api.h>
 
 struct hostent *gethostbyname(const char *name)
 {
+	unsupported_api(__FUNCTION__);
 	return gethostbyname2(name, AF_INET);
 }

src/network/gethostbyname2.c

@@ -4,6 +4,7 @@
 #include <netdb.h>
 #include <errno.h>
 #include <stdlib.h>
+#include <unsupported_api.h>
 
 struct hostent *gethostbyname2(const char *name, int af)
 {
@@ -11,6 +12,7 @@ struct hostent *gethostbyname2(const char *name, int af)
 	size_t size = 63;
 	struct hostent *res;
 	int err;
+	unsupported_api(__FUNCTION__);
 	do {
 		free(h);
 		h = malloc(size+=size+1);

src/network/gethostbyname2_r.c

@@ -7,6 +7,7 @@
 #include <errno.h>
 #include <stdint.h>
 #include "lookup.h"
+#include <unsupported_api.h>
 
 int gethostbyname2_r(const char *name, int af,
 	struct hostent *h, char *buf, size_t buflen,
@@ -18,6 +19,7 @@ int gethostbyname2_r(const char *name, int af,
 	size_t align, need;
 
 	*res = 0;
+	unsupported_api(__FUNCTION__);
 	cnt = __lookup_name(addrs, canon, name, af, AI_CANONNAME);
 	if (cnt<0) switch (cnt) {
 	case EAI_NONAME:

src/network/gethostbyname_r.c

@@ -2,10 +2,12 @@
 
 #include <sys/socket.h>
 #include <netdb.h>
+#include <unsupported_api.h>
 
 int gethostbyname_r(const char *name,
 	struct hostent *h, char *buf, size_t buflen,
 	struct hostent **res, int *err)
 {
+	unsupported_api(__FUNCTION__);
 	return gethostbyname2_r(name, AF_INET, h, buf, buflen, res, err);
 }

src/network/getifaddrs.c

@@ -7,6 +7,7 @@
 #include <syscall.h>
 #include <net/if.h>
 #include <netinet/in.h>
+#include <unsupported_api.h>
 #include "netlink.h"
 
 #define IFADDRS_HASH_SIZE 64
@@ -208,6 +209,7 @@ int getifaddrs(struct ifaddrs **ifap)
 {
 	struct ifaddrs_ctx _ctx, *ctx = &_ctx;
 	int r;
+	unsupported_api(__FUNCTION__);
 	memset(ctx, 0, sizeof *ctx);
 	r = __rtnetlink_enumerate(AF_UNSPEC, AF_UNSPEC, netlink_msg_to_ifaddr, ctx);
 	if (r == 0) *ifap = &ctx->first->ifa;

src/network/getnameinfo.c

@@ -9,6 +9,7 @@
 #include <net/if.h>
 #include <ctype.h>
 #include <resolv.h>
+#include <unsupported_api.h>
 #include "lookup.h"
 #include "stdio_impl.h"
 
@@ -129,6 +130,7 @@ int getnameinfo(const struct sockaddr *restrict sa, socklen_t sl,
 	unsigned char *a;
 	unsigned scopeid;
 
+	unsupported_api(__FUNCTION__);
 	switch (af) {
 	case AF_INET:
 		a = (void *)&((struct sockaddr_in *)sa)->sin_addr;

src/network/getservbyname.c

 #define _GNU_SOURCE
 #include <netdb.h>
+#include <unsupported_api.h>
 
 struct servent *getservbyname(const char *name, const char *prots)
 {
 	static struct servent se;
 	static char *buf[2];
 	struct servent *res;
+	unsupported_api(__FUNCTION__);
 	if (getservbyname_r(name, prots, &se, (void *)buf, sizeof buf, &res))
 		return 0;
 	return &se;

src/network/getservbyname_r.c

@@ -7,6 +7,7 @@
 #include <string.h>
 #include <stdlib.h>
 #include "lookup.h"
+#include <unsupported_api.h>
 
 #define ALIGN (sizeof(struct { char a; char *b; }) - sizeof(char *))
 
@@ -17,6 +18,7 @@ int getservbyname_r(const char *name, const char *prots,
 	int cnt, proto, align;
 
 	*res = 0;
+	unsupported_api(__FUNCTION__);
 
 	/* Don't treat numeric port number strings as service records. */
 	char *end = "";

src/network/getservbyport.c

 #define _GNU_SOURCE
 #include <netdb.h>
+#include <unsupported_api.h>
 
 struct servent *getservbyport(int port, const char *prots)
 {
 	static struct servent se;
 	static long buf[32/sizeof(long)];
 	struct servent *res;
+	unsupported_api(__FUNCTION__);
 	if (getservbyport_r(port, prots, &se, (void *)buf, sizeof buf, &res))
 		return 0;
 	return &se;

src/network/getservbyport_r.c

@@ -6,6 +6,7 @@
 #include <errno.h>
 #include <string.h>
 #include <stdlib.h>
+#include <unsupported_api.h>
 
 int getservbyport_r(int port, const char *prots,
 	struct servent *se, char *buf, size_t buflen, struct servent **res)
@@ -15,6 +16,7 @@ int getservbyport_r(int port, const char *prots,
 		.sin_family = AF_INET,
 		.sin_port = port,
 	};
+	unsupported_api(__FUNCTION__);
 
 	if (!prots) {
 		int r = getservbyport_r(port, "tcp", se, buf, buflen, res);

src/network/if_indextoname.c

@@ -4,13 +4,14 @@
 #include <sys/ioctl.h>
 #include <string.h>
 #include <errno.h>
+#include <unsupported_api.h>
 #include "syscall.h"
 
 char *if_indextoname(unsigned index, char *name)
 {
 	struct ifreq ifr;
 	int fd, r;
-
+	unsupported_api(__FUNCTION__);
 	if ((fd = socket(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC, 0)) < 0) return 0;
 	ifr.ifr_ifindex = index;
 	r = ioctl(fd, SIOCGIFNAME, &ifr);

src/network/if_nameindex.c

@@ -5,6 +5,7 @@
 #include <stdlib.h>
 #include <string.h>
 #include <pthread.h>
+#include <unsupported_api.h>
 #include "netlink.h"
 
 #define IFADDRS_HASH_SIZE 64

src/network/if_nametoindex.c

@@ -3,13 +3,14 @@
 #include <sys/socket.h>
 #include <sys/ioctl.h>
 #include <string.h>
+#include <unsupported_api.h>
 #include "syscall.h"
 
 unsigned if_nametoindex(const char *name)
 {
 	struct ifreq ifr;
 	int fd, r;
-
+	unsupported_api(__FUNCTION__);
 	if ((fd = socket(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC, 0)) < 0) return 0;
 	strncpy(ifr.ifr_name, name, sizeof ifr.ifr_name);
 	r = ioctl(fd, SIOCGIFINDEX, &ifr);

src/network/netname.c

 #include <netdb.h>
+#include <unsupported_api.h>
 
 struct netent *getnetbyaddr(uint32_t net, int type)
 {
+	unsupported_api(__FUNCTION__);
 	return 0;
 }
 
 struct netent *getnetbyname(const char *name)
 {
+	unsupported_api(__FUNCTION__);
 	return 0;
 }
 

src/network/proto.c

 #include <netdb.h>
 #include <string.h>
+#include <unsupported_api.h>
 
 /* do we really need all these?? */
 
@@ -45,6 +46,7 @@ static const unsigned char protos[] = {
 
 void endprotoent(void)
 {
+	unsupported_api(__FUNCTION__);
 	idx = 0;
 }
 

src/network/serv.c

 #include <netdb.h>
+#include <unsupported_api.h>
 
 void endservent(void)
 {
+	unsupported_api(__FUNCTION__);
 }
 
 void setservent(int stayopen)
 {
+	unsupported_api(__FUNCTION__);
 }
 
 struct servent *getservent(void)
 {
+	unsupported_api(__FUNCTION__);
 	return 0;
 }

src/network/sockatmark.c

 #include <sys/socket.h>
 #include <sys/ioctl.h>
+#include <unsupported_api.h>
 
 int sockatmark(int s)
 {
 	int ret;
+	unsupported_api(__FUNCTION__);
 	if (ioctl(s, SIOCATMARK, &ret) < 0)
 		return -1;
 	return ret;

src/passwd/getgr_r.c

 #include "pwf.h"
 #include <pthread.h>
+#include <unsupported_api.h>
 
 #define FIX(x) (gr->gr_##x = gr->gr_##x-line+buf)
 
@@ -40,10 +41,12 @@ static int getgr_r(const char *name, gid_t gid, struct group *gr, char *buf, siz
 
 int getgrnam_r(const char *name, struct group *gr, char *buf, size_t size, struct group **res)
 {
+	unsupported_api(__FUNCTION__);
 	return getgr_r(name, 0, gr, buf, size, res);
 }
 
 int getgrgid_r(gid_t gid, struct group *gr, char *buf, size_t size, struct group **res)
 {
+	unsupported_api(__FUNCTION__);
 	return getgr_r(0, gid, gr, buf, size, res);
 }

src/passwd/getgrent.c

+#include <unsupported_api.h>
 #include "pwf.h"
 
 static FILE *f;
@@ -6,6 +7,7 @@ static struct group gr;
 
 void setgrent()
 {
+	unsupported_api(__FUNCTION__);
 	if (f) fclose(f);
 	f = 0;
 }
@@ -16,6 +18,7 @@ struct group *getgrent()
 {
 	struct group *res;
 	size_t size=0, nmem=0;
+	unsupported_api(__FUNCTION__);
 	if (!f) f = fopen("/etc/group", "rbe");
 	if (!f) return 0;
 	__getgrent_a(f, &gr, &line, &size, &mem, &nmem, &res);
@@ -26,6 +29,7 @@ struct group *getgrgid(gid_t gid)
 {
 	struct group *res;
 	size_t size=0, nmem=0;
+	unsupported_api(__FUNCTION__);
 	__getgr_a(0, gid, &gr, &line, &size, &mem, &nmem, &res);
 	return res;
 }
@@ -34,6 +38,7 @@ struct group *getgrnam(const char *name)
 {
 	struct group *res;
 	size_t size=0, nmem=0;
+	unsupported_api(__FUNCTION__);
 	__getgr_a(name, 0, &gr, &line, &size, &mem, &nmem, &res);
 	return res;
 }

src/passwd/getpw_r.c

 #include "pwf.h"
 #include <pthread.h>
+#include <unsupported_api.h>
 
 #define FIX(x) (pw->pw_##x = pw->pw_##x-line+buf)
 
@@ -33,6 +34,7 @@ static int getpw_r(const char *name, uid_t uid, struct passwd *pw, char *buf, si
 
 int getpwnam_r(const char *name, struct passwd *pw, char *buf, size_t size, struct passwd **res)
 {
+	unsupported_api(__FUNCTION__);
 	return getpw_r(name, 0, pw, buf, size, res);
 }
 

src/passwd/getpwent.c

+#include <unsupported_api.h>
 #include "pwf.h"
 
 static FILE *f;
@@ -7,6 +8,7 @@ static size_t size;
 
 void setpwent()
 {
+	unsupported_api(__FUNCTION__);
 	if (f) fclose(f);
 	f = 0;
 }
@@ -16,6 +18,7 @@ weak_alias(setpwent, endpwent);
 struct passwd *getpwent()
 {
 	struct passwd *res;
+	unsupported_api(__FUNCTION__);
 	if (!f) f = fopen("/etc/passwd", "rbe");
 	if (!f) return 0;
 	__getpwent_a(f, &pw, &line, &size, &res);
@@ -25,6 +28,7 @@ struct passwd *getpwent()
 struct passwd *getpwuid(uid_t uid)
 {
 	struct passwd *res;
+	unsupported_api(__FUNCTION__);
 	__getpw_a(0, uid, &pw, &line, &size, &res);
 	return res;
 }
@@ -32,6 +36,7 @@ struct passwd *getpwuid(uid_t uid)
 struct passwd *getpwnam(const char *name)
 {
 	struct passwd *res;
+	unsupported_api(__FUNCTION__);
 	__getpw_a(name, 0, &pw, &line, &size, &res);
 	return res;
 }

src/process/fexecve.c

@@ -3,9 +3,11 @@
 #include <errno.h>
 #include <fcntl.h>
 #include "syscall.h"
+#include <unsupported_api.h>
 
 int fexecve(int fd, char *const argv[], char *const envp[])
 {
+	unsupported_api(__FUNCTION__);
 	int r = __syscall(SYS_execveat, fd, "", argv, envp, AT_EMPTY_PATH);
 	if (r != -ENOSYS) return __syscall_ret(r);
 	char buf[15 + 3*sizeof(int)];

src/process/posix_spawn.c

@@ -5,6 +5,7 @@
 #include <signal.h>
 #include <fcntl.h>
 #include <sys/wait.h>
+#include <unsupported_api.h>
 #include "syscall.h"
 #include "pthread_impl.h"
 #include "fdop.h"
@@ -170,6 +171,7 @@ int posix_spawn(pid_t *restrict res, const char *restrict path,
 	int ec=0, cs;
 	struct args args;
 
+	unsupported_api(__FUNCTION__);
 	if (pipe2(args.p, O_CLOEXEC))
 		return errno;
 

src/process/posix_spawn_file_actions_addclose.c

@@ -2,9 +2,11 @@
 #include <stdlib.h>
 #include <errno.h>
 #include "fdop.h"
+#include <unsupported_api.h>
 
 int posix_spawn_file_actions_addclose(posix_spawn_file_actions_t *fa, int fd)
 {
+	unsupported_api(__FUNCTION__);
 	struct fdop *op = malloc(sizeof *op);
 	if (!op) return ENOMEM;
 	op->cmd = FDOP_CLOSE;

src/process/posix_spawn_file_actions_adddup2.c

@@ -2,9 +2,11 @@
 #include <stdlib.h>
 #include <errno.h>
 #include "fdop.h"
+#include <unsupported_api.h>
 
 int posix_spawn_file_actions_adddup2(posix_spawn_file_actions_t *fa, int srcfd, int fd)
 {
+	unsupported_api(__FUNCTION__);
 	struct fdop *op = malloc(sizeof *op);
 	if (!op) return ENOMEM;
 	op->cmd = FDOP_DUP2;

src/process/posix_spawn_file_actions_addopen.c

@@ -3,9 +3,11 @@
 #include <string.h>
 #include <errno.h>
 #include "fdop.h"
+#include <unsupported_api.h>
 
 int posix_spawn_file_actions_addopen(posix_spawn_file_actions_t *restrict fa, int fd, const char *restrict path, int flags, mode_t mode)
 {
+	unsupported_api(__FUNCTION__);
 	struct fdop *op = malloc(sizeof *op + strlen(path) + 1);
 	if (!op) return ENOMEM;
 	op->cmd = FDOP_OPEN;

src/process/posix_spawnattr_destroy.c

 #include <spawn.h>
+#include <unsupported_api.h>
 
 int posix_spawnattr_destroy(posix_spawnattr_t *attr)
 {
+	unsupported_api(__FUNCTION__);
 	return 0;
 }

src/process/posix_spawnattr_getflags.c

 #include <spawn.h>
+#include <unsupported_api.h>
 
 int posix_spawnattr_getflags(const posix_spawnattr_t *restrict attr, short *restrict flags)
 {
+	unsupported_api(__FUNCTION__);
 	*flags = attr->__flags;
 	return 0;
 }

src/process/posix_spawnattr_getpgroup.c

 #include <spawn.h>
+#include <unsupported_api.h>
 
 int posix_spawnattr_getpgroup(const posix_spawnattr_t *restrict attr, pid_t *restrict pgrp)
 {
+	unsupported_api(__FUNCTION__);
 	*pgrp = attr->__pgrp;
 	return 0;
 }

src/process/posix_spawnattr_getsigdefault.c

 #include <spawn.h>
+#include <unsupported_api.h>
 
 int posix_spawnattr_getsigdefault(const posix_spawnattr_t *restrict attr, sigset_t *restrict def)
 {
+	unsupported_api(__FUNCTION__);
 	*def = attr->__def;
 	return 0;
 }

src/process/posix_spawnattr_getsigmask.c

 #include <spawn.h>
+#include <unsupported_api.h>
 
 int posix_spawnattr_getsigmask(const posix_spawnattr_t *restrict attr, sigset_t *restrict mask)
 {
+	unsupported_api(__FUNCTION__);
 	*mask = attr->__mask;
 	return 0;
 }

src/process/posix_spawnattr_init.c

 #include <spawn.h>
+#include <unsupported_api.h>
 
 int posix_spawnattr_init(posix_spawnattr_t *attr)
 {
+	unsupported_api(__FUNCTION__);
 	*attr = (posix_spawnattr_t){ 0 };
 	return 0;
 }

src/process/posix_spawnattr_sched.c

 #include <spawn.h>
 #include <sched.h>
 #include <errno.h>
+#include <unsupported_api.h>
 
 int posix_spawnattr_getschedparam(const posix_spawnattr_t *restrict attr,
 	struct sched_param *restrict schedparam)
 {
+	unsupported_api(__FUNCTION__);
 	return ENOSYS;
 }
 
 int posix_spawnattr_setschedparam(posix_spawnattr_t *restrict attr,
 	const struct sched_param *restrict schedparam)
 {
+	unsupported_api(__FUNCTION__);
 	return ENOSYS;
 }
 
 int posix_spawnattr_getschedpolicy(const posix_spawnattr_t *restrict attr, int *restrict policy)
 {
+	unsupported_api(__FUNCTION__);
 	return ENOSYS;
 }
 
 int posix_spawnattr_setschedpolicy(posix_spawnattr_t *attr, int policy)
 {
+	unsupported_api(__FUNCTION__);
 	return ENOSYS;
 }

src/process/posix_spawnattr_setflags.c

 #include <spawn.h>
 #include <errno.h>
+#include <unsupported_api.h>
 
 int posix_spawnattr_setflags(posix_spawnattr_t *attr, short flags)
 {
+	unsupported_api(__FUNCTION__);
 	const unsigned all_flags =
 		POSIX_SPAWN_RESETIDS |
 		POSIX_SPAWN_SETPGROUP |