#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
#include <cstdio>
#include <time.h>
#include <string>
time_t TIME = time(NULL);
+#ifdef USE_KQUEUE
+int kq, lkq;
+#endif
+
namespace nspace
{
#ifdef GCC34
if (user->fd > -1)
{
FOREACH_MOD OnRawSocketClose(user->fd);
- shutdown(user->fd,2);
- close(user->fd);
+#ifdef USE_KQUEUE
+ struct kevent ke;
+ EV_SET(&ke, user->fd, EVFILT_READ, EV_DELETE, 0, 0, NULL);
+ int i = kevent(kq, &ke, 1, 0, 0, NULL);
+ if (i == -1)
+ {
+ log(DEBUG,"kqueue: Failed to remove user from queue!");
+ }
+#endif
+ shutdown(user->fd,2);
+ close(user->fd);
}
if (user->registered == 7) {
if (user->fd > -1)
{
FOREACH_MOD OnRawSocketClose(user->fd);
+#ifdef USE_KQUEUE
+ struct kevent ke;
+ EV_SET(&ke, user->fd, EVFILT_READ, EV_DELETE, 0, 0, NULL);
+ int i = kevent(kq, &ke, 1, 0, 0, NULL);
+ if (i == -1)
+ {
+ log(DEBUG,"kqueue: Failed to remove user from queue!");
+ }
+#endif
shutdown(user->fd,2);
close(user->fd);
}
}
}
fd_ref_table[socket] = clientlist[tempnick];
+
+#ifdef USE_KQUEUE
+ struct kevent ke;
+ log(DEBUG,"kqueue: Add user to events, kq=%d socket=%d",kq,socket);
+ EV_SET(&ke, socket, EVFILT_READ, EV_ADD, 0, 0, NULL);
+ 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!");
+ }
+
+#endif
}
// this function counts all users connected, wether they are registered or NOT.
s1 = savept;
v2 = strtok_r(s1," ",&savept);
s1 = savept;
- snprintf(versiondata,MAXBUF,"%s Rev. %s %s :%s (O=%lu)",VERSION,v2,ServerName,SYSTEM,(unsigned long)OPTIMISATION);
+#ifdef USE_KQUEUE
+ char socketengine[] = "kqueue";
+#else
+ char socketengine[] = "select";
+#endif
+ snprintf(versiondata,MAXBUF,"%s Rev. %s %s :%s (O=%lu) [SE=%s]",VERSION,v2,ServerName,SYSTEM,(unsigned long)OPTIMISATION,socketengine);
return versiondata;
}
}
}
+ // BUGFIX: We cannot initialize this before forking, as the kqueue data is not inherited by child processes!
+#ifdef USE_KQUEUE
+ kq = kqueue();
+ lkq = kqueue();
+ if ((kq == -1) || (lkq == -1))
+ {
+ log(DEFAULT,"main: kqueue() failed!");
+ printf("ERROR: could not initialise kqueue event system. Shutting down.\n");
+ Exit(ERROR);
+ }
+#endif
+
+
+#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);
+ 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");
+ }
+ }
+#else
+ log(DEFAULT,"Using standard select socket engine.");
+#endif
+
WritePID(PID);
length = sizeof (client);
char tcp_msg[MAXBUF],tcp_host[MAXBUF];
+#ifdef USE_KQUEUE
+ struct kevent ke;
+ struct timespec ts;
+#endif
fd_set serverfds;
timeval tvs;
tvs.tv_usec = 10000L;
tval.tv_usec = 10000L;
tval.tv_sec = 0;
int total_in_this_set = 0;
- int v = 0;
+ int i = 0, v = 0;
bool expire_run = false;
/* main loop, this never returns */
}
}
-
while (count2 != clientlist.end())
{
FD_ZERO(&sfd);
+
total_in_this_set = 0;
user_hash::iterator xcount = count2;
//
// This should be up to 64x faster than the
// old implementation.
- while (total_in_this_set < 64)
+#ifndef USE_KQUEUE
+ while (total_in_this_set < 1024)
{
if (count2 != clientlist.end())
{
}
else break;
}
-
endingiter = count2;
count2 = xcount; // roll back to where we were
+#else
+ dns_poll();
+ // 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.
+ // TODO: We dont need to do all this EVERY loop iteration, tone down the visits to this if we're using kqueue.
+ while (count2 != clientlist.end())
+ {
+ if (count2 != clientlist.end())
+ {
+ curr = count2->second;
+ // we don't check the state of remote users.
+ if ((curr->fd != -1) && (curr->fd != FD_MAGIC_NUMBER))
+ {
+ // registration timeout -- didnt send USER/NICK/HOST in the time specified in
+ // their connection class.
+ if ((TIME > curr->timeout) && (curr->registered != 7))
+ {
+ log(DEBUG,"InspIRCd: registration timeout: %s",curr->nick);
+ kill_link(curr,"Registration timeout");
+ goto label;
+ }
+ if ((TIME > curr->signon) && (curr->registered == 3) && (AllModulesReportReady(curr)))
+ {
+ log(DEBUG,"signon exceed, registered=3, and modules ready, OK: %d %d",TIME,curr->signon);
+ curr->dns_done = true;
+ statsDnsBad++;
+ FullConnectUser(curr);
+ goto label;
+ }
+ if ((curr->dns_done) && (curr->registered == 3) && (AllModulesReportReady(curr)))
+ {
+ log(DEBUG,"dns done, registered=3, and modules ready, OK");
+ FullConnectUser(curr);
+ goto label;
+ }
+ if ((TIME > curr->nping) && (isnick(curr->nick)) && (curr->registered == 7))
+ {
+ if ((!curr->lastping) && (curr->registered == 7))
+ {
+ log(DEBUG,"InspIRCd: ping timeout: %s",curr->nick);
+ kill_link(curr,"Ping timeout");
+ goto label;
+ }
+ Write(curr->fd,"PING :%s",ServerName);
+ log(DEBUG,"InspIRCd: pinging: %s",curr->nick);
+ curr->lastping = 0;
+ curr->nping = TIME+curr->pingmax; // was hard coded to 120
+ }
+ }
+ }
+ else break;
+ count2++;
+ }
+ // increment the counter right to the end of the list, as kqueue processes everything in one go
+#endif
v = 0;
- // tvals defined here
-
+#ifdef USE_KQUEUE
+ ts.tv_sec = 0;
+ ts.tv_nsec = 1000L;
+ // for now, we only read 1 event. We could read soooo many more :)
+ int i = kevent(kq, NULL, 0, &ke, 1, &ts);
+ if (i > 0)
+ {
+ 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
tval.tv_usec = 1000L;
selectResult2 = select(65535, &sfd, NULL, NULL, &tval);
if (selectResult2 > 0)
for (user_hash::iterator count2a = xcount; count2a != endingiter; count2a++)
{
+ // SELECT: we have to iterate...
+ userrec* cu = count2a->second;
+#endif
#ifdef _POSIX_PRIORITY_SCHEDULING
sched_yield();
#endif
- userrec* cu = count2a->second;
result = EAGAIN;
+#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
+ // 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
{
log(DEBUG,"Data waiting on socket %d",cu->fd);
int MOD_RESULT = 0;
else
if (result == 0)
{
+#ifndef USE_KQUEUE
if (count2->second)
{
+#endif
log(DEBUG,"InspIRCd: Exited: %s",cu->nick);
kill_link(cu,"Client exited");
// must bail here? kill_link removes the hash, corrupting the iterator
log(DEBUG,"Bailing from client exit");
goto label;
+#ifndef USE_KQUEUE
}
+#endif
}
else if (result > 0)
{
sched_yield();
#endif
+#ifndef USE_KQUEUE
// set up select call
for (count = 0; count < boundPortCount; count++)
{
/* select is reporting a waiting socket. Poll them all to find out which */
if (selectResult > 0)
{
- char target[MAXBUF], resolved[MAXBUF];
- for (count = 0; count < boundPortCount; count++)
+ for (count = 0; count < boundPortCount; count++)
{
if (FD_ISSET (openSockfd[count], &selectFds))
{
+#else
+ ts.tv_sec = 0;
+ ts.tv_nsec = 30000L;
+ i = kevent(lkq, NULL, 0, &ke, 1, &ts);
+ if (i > 0)
+ {
+ log(DEBUG,"kqueue: Listening socket event, i=%d, ke.ident=%d",i,ke.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)
+ // compared to the number of clients (possibly over 2000)
+ for (count = 0; count < boundPortCount; count++)
+ {
+ if (ke.ident == openSockfd[count])
+ {
+#endif
+ char target[MAXBUF], resolved[MAXBUF];
length = sizeof (client);
incomingSockfd = accept (openSockfd[count], (struct sockaddr *) &client, &length);