diff --git a/include/common/epoll.h b/include/common/epoll.h
index 8b05ece..10f7fa9 100644
--- a/include/common/epoll.h
+++ b/include/common/epoll.h
@@ -90,9 +90,10 @@
 #define __NR_epoll_wait   256
 #endif
 
-extern int epoll_create(int size);
-extern int epoll_ctl(int epfd, int op, int fd, struct epoll_event * event);
-extern int epoll_wait(int epfd, struct epoll_event * events, int maxevents, int timeout);
+/* Those are our self-defined functions */
+static int epoll_create(int size);
+static int epoll_ctl(int epfd, int op, int fd, struct epoll_event * event);
+static int epoll_wait(int epfd, struct epoll_event * events, int maxevents, int timeout);
 
 #endif /* _COMMON_EPOLL_H */
 
diff --git a/src/ev_epoll.c b/src/ev_epoll.c
index 89315ea..403e71c 100644
--- a/src/ev_epoll.c
+++ b/src/ev_epoll.c
@@ -29,9 +29,9 @@
 #include <common/epoll.h>
 #include <errno.h>
 #include <sys/syscall.h>
-_syscall1 (int, epoll_create, int, size);
-_syscall4 (int, epoll_ctl, int, epfd, int, op, int, fd, struct epoll_event *, event);
-_syscall4 (int, epoll_wait, int, epfd, struct epoll_event *, events, int, maxevents, int, timeout);
+static _syscall1 (int, epoll_create, int, size);
+static _syscall4 (int, epoll_ctl, int, epfd, int, op, int, fd, struct epoll_event *, event);
+static _syscall4 (int, epoll_wait, int, epfd, struct epoll_event *, events, int, maxevents, int, timeout);
 #else
 #include <sys/epoll.h>
 #endif
