#include <sys/errno.h>
#include <sys/ioctl.h>
#include <sys/utsname.h>
+
#ifdef USE_KQUEUE
#include <sys/types.h>
#include <sys/event.h>
#include <sys/time.h>
#endif
+
+#ifdef USE_EPOLL
+#include <sys/epoll.h>
+#define EP_DELAY 50
+#endif
+
#include <time.h>
#include <string>
#ifdef GCC3
bool AllowProtect = true;
bool AllowFounder = true;
-extern std::vector<Module*, __single_client_alloc> modules;
-std::vector<std::string, __single_client_alloc> module_names;
-extern std::vector<ircd_module*, __single_client_alloc> factory;
+extern std::vector<Module*> modules;
+std::vector<std::string> module_names;
+extern std::vector<ircd_module*> factory;
extern int MODCOUNT;
int openSockfd[MAXSOCKS];
int kq, lkq, skq;
#endif
-typedef nspace::hash_map<std::string, userrec*, nspace::hash<string>, irc::StrHashComp, __single_client_alloc> user_hash;
-typedef nspace::hash_map<std::string, chanrec*, nspace::hash<string>, irc::StrHashComp, __single_client_alloc> chan_hash;
-typedef nspace::hash_map<in_addr,string*, nspace::hash<in_addr>, irc::InAddr_HashComp, __single_client_alloc> address_cache;
-typedef nspace::hash_map<std::string, WhoWasUser*, nspace::hash<string>, irc::StrHashComp, __single_client_alloc> whowas_hash;
-typedef std::deque<command_t, __single_client_alloc> command_table;
+#ifdef USE_EPOLL
+int ep, lep, sep;
+#endif
+
+typedef nspace::hash_map<std::string, userrec*, nspace::hash<string>, irc::StrHashComp> user_hash;
+typedef nspace::hash_map<std::string, chanrec*, nspace::hash<string>, irc::StrHashComp> chan_hash;
+typedef nspace::hash_map<in_addr,string*, nspace::hash<in_addr>, irc::InAddr_HashComp> address_cache;
+typedef nspace::hash_map<std::string, WhoWasUser*, nspace::hash<string>, irc::StrHashComp> whowas_hash;
+typedef std::deque<command_t> command_table;
// This table references users by file descriptor.
// its an array to make it VERY fast, as all lookups are referenced
std::vector<long> auth_cookies;
std::stringstream config_f(stringstream::in | stringstream::out);
-std::vector<userrec*, __single_client_alloc> all_opers;
+std::vector<userrec*> all_opers;
char lowermap[255];
void DeleteOper(userrec* user)
{
- for (std::vector<userrec*, __single_client_alloc>::iterator a = all_opers.begin(); a < all_opers.end(); a++)
+ for (std::vector<userrec*>::iterator a = all_opers.begin(); a < all_opers.end(); a++)
{
if (*a == user)
{
{
log(DEFAULT,"Adding and removing modules due to rehash...");
- std::vector<std::string, __single_client_alloc> old_module_names, new_module_names, added_modules, removed_modules;
+ std::vector<std::string> old_module_names, new_module_names, added_modules, removed_modules;
// store the old module names
- for (std::vector<std::string, __single_client_alloc>::iterator t = module_names.begin(); t != module_names.end(); t++)
+ for (std::vector<std::string>::iterator t = module_names.begin(); t != module_names.end(); t++)
{
old_module_names.push_back(*t);
}
// now create a list of new modules that are due to be loaded
// and a seperate list of modules which are due to be unloaded
- for (std::vector<std::string, __single_client_alloc>::iterator _new = new_module_names.begin(); _new != new_module_names.end(); _new++)
+ for (std::vector<std::string>::iterator _new = new_module_names.begin(); _new != new_module_names.end(); _new++)
{
bool added = true;
- for (std::vector<std::string, __single_client_alloc>::iterator old = old_module_names.begin(); old != old_module_names.end(); old++)
+ for (std::vector<std::string>::iterator old = old_module_names.begin(); old != old_module_names.end(); old++)
{
if (*old == *_new)
added = false;
if (added)
added_modules.push_back(*_new);
}
- for (std::vector<std::string, __single_client_alloc>::iterator oldm = old_module_names.begin(); oldm != old_module_names.end(); oldm++)
+ for (std::vector<std::string>::iterator oldm = old_module_names.begin(); oldm != old_module_names.end(); oldm++)
{
bool removed = true;
- for (std::vector<std::string, __single_client_alloc>::iterator newm = new_module_names.begin(); newm != new_module_names.end(); newm++)
+ for (std::vector<std::string>::iterator newm = new_module_names.begin(); newm != new_module_names.end(); newm++)
{
if (*newm == *oldm)
removed = false;
// to be removed.
int rem = 0, add = 0;
if (!removed_modules.empty())
- for (std::vector<std::string, __single_client_alloc>::iterator removing = removed_modules.begin(); removing != removed_modules.end(); removing++)
+ for (std::vector<std::string>::iterator removing = removed_modules.begin(); removing != removed_modules.end(); removing++)
{
if (UnloadModule(removing->c_str()))
{
}
}
if (!added_modules.empty())
- for (std::vector<std::string, __single_client_alloc>::iterator adding = added_modules.begin(); adding != added_modules.end(); adding++)
+ for (std::vector<std::string>::iterator adding = added_modules.begin(); adding != added_modules.end(); adding++)
{
if (LoadModule(adding->c_str()))
{
{
log(DEBUG,"kqueue: Failed to remove user from queue!");
}
+#endif
+#ifdef USE_EPOLL
+ struct epoll_event ev;
+ ev.events = EPOLLIN | EPOLLET;
+ ev.data.fd = user->fd;
+ int i = epoll_ctl(ep, EPOLL_CTL_DEL, user->fd, &ev);
+ if (i < 0)
+ {
+ log(DEBUG,"epoll: List deletion failure!");
+ }
#endif
shutdown(user->fd,2);
close(user->fd);
{
log(DEBUG,"kqueue: Failed to remove user from queue!");
}
+#endif
+#ifdef USE_EPOLL
+ struct epoll_event ev;
+ ev.events = EPOLLIN | EPOLLET;
+ ev.data.fd = user->fd;
+ int i = epoll_ctl(ep, EPOLL_CTL_DEL, user->fd, &ev);
+ if (i < 0)
+ {
+ log(DEBUG,"epoll: List deletion failure!");
+ }
#endif
shutdown(user->fd,2);
close(user->fd);
}
fd_ref_table[socket] = clientlist[tempnick];
+#ifdef USE_EPOLL
+ struct epoll_event ev;
+ log(DEBUG,"epoll: Adduser to events, ep=%d socket=%d",ep,socket);
+ ev.events = EPOLLIN | EPOLLET;
+ ev.data.fd = socket;
+ int i = epoll_ctl(ep, EPOLL_CTL_ADD, socket, &ev);
+ if (i < 0)
+ {
+ log(DEBUG,"epoll: List insertion failure!");
+ }
+#endif
#ifdef USE_KQUEUE
struct kevent ke;
log(DEBUG,"kqueue: Add user to events, kq=%d socket=%d",kq,socket);
int i = kevent(kq, &ke, 1, 0, 0, NULL);
if (i == -1)
{
- switch (errno)
- {
- case EACCES:
- log(DEBUG,"kqueue: EACCES");
- break;
- case EFAULT:
- log(DEBUG,"kqueue: EFAULT");
- break;
- case EBADF:
- log(DEBUG,"kqueue: EBADF=%d",ke.ident);
- break;
- case EINTR:
- log(DEBUG,"kqueue: EINTR");
- break;
- case EINVAL:
- log(DEBUG,"kqueue: EINVAL");
- break;
- case ENOENT:
- log(DEBUG,"kqueue: ENOENT");
- break;
- case ENOMEM:
- log(DEBUG,"kqueue: ENOMEM");
- break;
- case ESRCH:
- log(DEBUG,"kqueue: ESRCH");
- break;
- default:
- log(DEBUG,"kqueue: UNKNOWN!");
- break;
- }
- log(DEBUG,"kqueue: Failed to add user to queue!");
+ log(DEBUG,"kqueue: List insertion failure!");
}
#endif
s1 = savept;
#ifdef USE_KQUEUE
char socketengine[] = "kqueue";
-#else
+#endif
+#ifdef USE_SELECT
char socketengine[] = "select";
+#endif
+#ifdef USE_EPOLL
+ char socketengine[] = "epoll";
#endif
snprintf(versiondata,MAXBUF,"%s Rev. %s %s :%s (O=%lu) [SE=%s]",VERSION,v2,ServerName,SYSTEM,(unsigned long)OPTIMISATION,socketengine);
return versiondata;
{
if (me[i] != NULL)
{
- for (vector<ircd_connector, __single_client_alloc>::iterator j = me[i]->connectors.begin(); j != me[i]->connectors.end(); j++)
+ for (vector<ircd_connector>::iterator j = me[i]->connectors.begin(); j != me[i]->connectors.end(); j++)
{
if (strcasecmp(j->GetServerName().c_str(),ServerName))
{
{
if (me[i] != NULL)
{
- for (vector<ircd_connector, __single_client_alloc>::iterator j = me[i]->connectors.begin(); j != me[i]->connectors.end(); j++)
+ for (vector<ircd_connector>::iterator j = me[i]->connectors.begin(); j != me[i]->connectors.end(); j++)
{
if (!strcasecmp(j->GetServerName().c_str(),params))
{
{
if (me[i] != NULL)
{
- for (vector<ircd_connector, __single_client_alloc>::iterator j = me[i]->connectors.begin(); j != me[i]->connectors.end(); j++)
+ for (vector<ircd_connector>::iterator j = me[i]->connectors.begin(); j != me[i]->connectors.end(); j++)
{
if (!strcasecmp(j->GetServerName().c_str(),name))
{
void erase_factory(int j)
{
int v = 0;
- for (std::vector<ircd_module*, __single_client_alloc>::iterator t = factory.begin(); t != factory.end(); t++)
+ for (std::vector<ircd_module*>::iterator t = factory.begin(); t != factory.end(); t++)
{
if (v == j)
{
void erase_module(int j)
{
int v1 = 0;
- for (std::vector<Module*, __single_client_alloc>::iterator m = modules.begin(); m!= modules.end(); m++)
+ for (std::vector<Module*>::iterator m = modules.begin(); m!= modules.end(); m++)
{
if (v1 == j)
{
v1++;
}
int v2 = 0;
- for (std::vector<std::string, __single_client_alloc>::iterator v = module_names.begin(); v != module_names.end(); v++)
+ for (std::vector<std::string>::iterator v = module_names.begin(); v != module_names.end(); v++)
{
if (v2 == j)
{
}
#endif
+#ifdef USE_EPOLL
+ ep = epoll_create(MAXCLIENTS);
+ lep = epoll_create(32);
+ sep = epoll_create(128);
+ if ((ep == -1) || (lep == -1) || (sep == -1))
+ {
+ log(DEFAULT,"main: epoll_create() failed!");
+ printf("ERROR: could not initialise epoll event system. Shutting down.\n");
+ Exit(ERROR);
+ }
+#endif
+#ifdef USE_EPOLL
+ log(DEFAULT,"epoll socket engine is enabled. Filling listen list. boundPortcount=%d",boundPortCount);
+ for (count = 0; count < boundPortCount; count++)
+ {
+ struct epoll_event ev;
+ log(DEBUG,"epoll: Add listening socket to events, ep=%d socket=%d",lep,openSockfd[count]);
+ ev.events = EPOLLIN | EPOLLET;
+ ev.data.fd = openSockfd[count];
+ int i = epoll_ctl(lep, EPOLL_CTL_ADD, openSockfd[count], &ev);
+ if (i < 0)
+ {
+ log(DEFAULT,"main: add listen ports, epoll_ctl failed!");
+ printf("ERROR: could not initialise listening sockets in epoll list. Shutting down.\n");
+ Exit(ERROR);
+ }
+
+ }
+ for (int t = 0; t != SERVERportCount; t++)
+ {
+ struct epoll_event ev;
+ log(DEBUG,"epoll: Add listening server socket to events, ep=%d socket=%d",sep,me[t]->fd);
+ ev.events = EPOLLIN | EPOLLET;
+ ev.data.fd = me[t]->fd;
+ int i = epoll_ctl(sep, EPOLL_CTL_ADD, me[t]->fd, &ev);
+ if (i == -1)
+ {
+ log(DEFAULT,"main: add server listen ports, epoll_ctl failed!");
+ printf("ERROR: could not initialise server listening sockets in epoll list. Shutting down.\n");
+ Exit(ERROR);
+ }
+ }
+#else
#ifdef USE_KQUEUE
log(DEFAULT,"kqueue socket engine is enabled. Filling listen list.");
for (count = 0; count < boundPortCount; count++)
{
struct kevent ke;
log(DEBUG,"kqueue: Add listening socket to events, kq=%d socket=%d",lkq,openSockfd[count]);
- EV_SET(&ke, openSockfd[count], EVFILT_READ, EV_ADD, 0, 5, NULL);
+ EV_SET(&ke, openSockfd[count], EVFILT_READ, EV_ADD, 0, 32, NULL);
int i = kevent(lkq, &ke, 1, 0, 0, NULL);
if (i == -1)
{
log(DEFAULT,"main: add listen ports to kqueue failed!");
printf("ERROR: could not initialise listening sockets in kqueue. Shutting down.\n");
+ Exit(ERROR);
}
}
for (int t = 0; t != SERVERportCount; t++)
if (me[t])
{
log(DEBUG,"kqueue: Add listening SERVER socket to events, kq=%d socket=%d",skq,me[t]->fd);
- EV_SET(&ke, me[t]->fd, EVFILT_READ, EV_ADD, 0, 5, NULL);
+ EV_SET(&ke, me[t]->fd, EVFILT_READ, EV_ADD, 0, 32, NULL);
int i = kevent(skq, &ke, 1, 0, 0, NULL);
if (i == -1)
{
log(DEFAULT,"main: add server listen ports to kqueue failed!");
printf("ERROR: could not initialise listening server sockets in kqueue. Shutting down.\n");
+ Exit(ERROR);
}
}
}
#else
log(DEFAULT,"Using standard select socket engine.");
+#endif
#endif
WritePID(PID);
struct kevent ke;
struct kevent ke_list[33];
struct timespec ts;
+#endif
+#ifdef USE_EPOLL
+ struct epoll_event event[33];
#endif
fd_set serverfds;
timeval tvs;
#ifdef _POSIX_PRIORITY_SCHEDULING
sched_yield();
#endif
-#ifndef USE_KQUEUE
+#ifdef USE_SELECT
FD_ZERO(&sfd);
#endif
-
// we only read time() once per iteration rather than tons of times!
OLDTIME = TIME;
TIME = time(NULL);
// fix by brain - this must be below any manipulation of the hashmap by modules
user_hash::iterator count2 = clientlist.begin();
+#ifdef USE_EPOLL
+ i = epoll_wait(sep, event, 1, EP_DELAY);
+#ifdef _POSIX_PRIORITY_SCHEDULING
+ sched_yield();
+#endif
+ if (i > 0)
+ {
+ log(DEBUG,"epoll: Listening server socket event, i=%d, event.data.fd=%d",i,event[0].data.fd);
+ for (int x = 0; x != SERVERportCount; x++)
+ {
+ if ((me[x]) && (event[0].data.fd == me[x]->fd))
+ {
+#endif
#ifdef USE_KQUEUE
ts.tv_sec = 0;
ts.tv_nsec = 30000L;
if ((me[x]) && (ke.ident == me[x]->fd))
{
-#else
+#endif
+#ifdef USE_SELECT
FD_ZERO(&serverfds);
for (int x = 0; x != SERVERportCount; x++)
{
while (count2 != clientlist.end())
{
-#ifndef USE_KQUEUE
+#ifdef USE_SELECT
FD_ZERO(&sfd);
#endif
//
// This should be up to 64x faster than the
// old implementation.
-#ifndef USE_KQUEUE
+#ifdef USE_SELECT
while (total_in_this_set < 1024)
{
if (count2 != clientlist.end())
endingiter = count2;
count2 = xcount; // roll back to where we were
#else
- // KQUEUE: We don't go through a loop to fill the fd_set so instead we must manually do this loop every now and again.
+ // KQUEUE and EPOLL: We don't go through a loop to fill the fd_set so instead we must manually do this loop every now and again.
// TODO: We dont need to do all this EVERY loop iteration, tone down the visits to this if we're using kqueue.
cycle_iter++;
- if (cycle_iter > 10) while (count2 != clientlist.end())
+ if (cycle_iter > 20) while (count2 != clientlist.end())
{
cycle_iter = 0;
if (count2 != clientlist.end())
#endif
v = 0;
-
+#ifdef USE_EPOLL
+ int i = epoll_wait(ep, event, 1, 5);
+ if (i > 0)
+ {
+ log(DEBUG,"epoll_wait call: ep=%d, i=%d",ep,i);
+ // EPOLL: we asked epoll_wait for ONE fd which is ready. Do something.
+ userrec* cu = fd_ref_table[event[0].data.fd];
+#endif
#ifdef USE_KQUEUE
ts.tv_sec = 0;
ts.tv_nsec = 1000L;
log(DEBUG,"kevent call: kq=%d, i=%d",kq,i);
// KQUEUE: kevent gives us ONE fd which is ready to have something done to it. Do something to it.
userrec* cu = fd_ref_table[ke.ident];
-#else
+#endif
+#ifdef USE_SELECT
tval.tv_usec = 1000L;
selectResult2 = select(65535, &sfd, NULL, NULL, &tval);
sched_yield();
#endif
result = EAGAIN;
+#ifdef USE_EPOLL
+ // EPOLL: We already know we have a valid FD. No checks needed.
+ if ((cu->fd != FD_MAGIC_NUMBER) && (cu->fd != -1))
+#endif
#ifdef USE_KQUEUE
// KQUEUE: We already know we have a valid FD. No checks needed.
if ((cu->fd != FD_MAGIC_NUMBER) && (cu->fd != -1))
-#else
+#endif
+#ifdef USE_SELECT
// SELECT: We don't know if our FD is valid.
if ((cu->fd != FD_MAGIC_NUMBER) && (cu->fd != -1) && (FD_ISSET (cu->fd, &sfd)))
#endif
else
if (result == 0)
{
-#ifndef USE_KQUEUE
+#ifdef USE_SELECT
if (count2->second)
{
#endif
// must bail here? kill_link removes the hash, corrupting the iterator
log(DEBUG,"Bailing from client exit");
goto label;
-#ifndef USE_KQUEUE
+#ifdef USE_SELECT
}
#endif
}
sched_yield();
#endif
-#ifndef USE_KQUEUE
+#ifdef USE_SELECT
// set up select call
for (count = 0; count < boundPortCount; count++)
{
{
if (FD_ISSET (openSockfd[count], &selectFds))
{
-#else
+#endif
+#ifdef USE_KQUEUE
ts.tv_sec = 0;
ts.tv_nsec = 30000L;
i = kevent(lkq, NULL, 0, ke_list, 32, &ts);
if (i > 0) for (j = 0; j < i; j++)
{
- log(DEBUG,"kqueue: Listening socket event, i=%d, ke.ident=%d",i,ke.ident);
+ log(DEBUG,"kqueue: Listening socket event, i=%d, ke.ident=%d",i,ke_list[j].ident);
// this isnt as efficient as it could be, we could create a reference table
// to reference bound ports by fd, but this isnt a big bottleneck as the actual
// number of listening ports on the average ircd is a small number (less than 20)
{
if (ke_list[j].ident == openSockfd[count])
{
+#endif
+#ifdef USE_EPOLL
+#ifdef _POSIX_PRIORITY_SCHEDULING
+ sched_yield();
+#endif
+ i = epoll_wait(lep, event, 32, EP_DELAY);
+#ifdef _POSIX_PRIORITY_SCHEDULING
+ sched_yield();
+#endif
+ if (i > 0) for (j = 0; j < i; j++)
+ {
+ log(DEBUG,"epoll: Listening socket event, i=%d,events[j].data.fd=%d",i,event[j].data.fd);
+ for (count = 0; count < boundPortCount; count++)
+ {
+ if (event[j].data.fd == openSockfd[count])
+ {
#endif
char target[MAXBUF], resolved[MAXBUF];
length = sizeof (client);
projects / user / henk / code / inspircd.git / blobdiff