X-Git-Url: http://git.pk910.de/?a=blobdiff_plain;f=ircd%2Fmsgq.c;h=379ffae6a873261e63620d17e8b1a81ff8048e80;hb=refs%2Fheads%2Fupstream-ssl;hp=41ae2420dccbfe8a2e697413dfcdfefeb760c16d;hpb=dd540e7c8fe74d1940348277f125fd4ca7eeafc3;p=ircu2.10.12-pk.git diff --git a/ircd/msgq.c b/ircd/msgq.c index 41ae242..379ffae 100644 --- a/ircd/msgq.c +++ b/ircd/msgq.c @@ -15,81 +15,95 @@ * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. - * - * $Id$ */ +/** @file + * @brief Outbound message queue implementation. + * @version $Id$ + */ +#include "config.h" + #include "msgq.h" +#include "ircd.h" #include "ircd_alloc.h" #include "ircd_defs.h" +#include "ircd_features.h" +#include "ircd_log.h" +#include "ircd_reply.h" #include "ircd_snprintf.h" +#include "numeric.h" +#include "send.h" #include "s_debug.h" +#include "s_stats.h" -#include +/* #include -- Now using assert in ircd_log.h */ #include +#include #include #include /* struct iovec */ +#define MB_BASE_SHIFT 5 /**< Log2 of smallest message body to allocate. */ +#define MB_MAX_SHIFT 9 /**< Log2 of largest message body to allocate. */ + +/** Buffer for a single message. */ struct MsgBuf { - struct MsgBuf *next; /* next msg in global queue */ - struct MsgBuf **prev_p; /* what points to us in linked list */ - unsigned int ref; /* reference count */ - unsigned int length; /* length of message */ - char msg[BUFSIZE + 1]; /* the message */ + struct MsgBuf *next; /**< next msg in global queue */ + struct MsgBuf **prev_p; /**< what points to us in linked list */ + struct MsgBuf *real; /**< the actual MsgBuf we're attaching */ + unsigned int ref; /**< reference count */ + unsigned int length; /**< length of message */ + unsigned int power; /**< size of buffer (power of 2) */ + char msg[1]; /**< the message */ }; +/** Return allocated length of the buffer of \a buf. */ +#define bufsize(buf) (1 << (buf)->power) + +/** Message body for a particular destination. */ struct Msg { - struct Msg *next; /* next msg */ - unsigned int sent; /* bytes in msg that have already been sent */ - struct MsgBuf *msg; /* actual message in queue */ + struct Msg *next; /**< next msg */ + unsigned int sent; /**< bytes in msg that have already been sent */ + struct MsgBuf *msg; /**< actual message in queue */ }; -static struct { - struct MsgBuf *msgs; - struct MsgBuf *free_mbs; - struct Msg *free_msgs; -} MQData = { 0, 0, 0 }; - -struct MsgCounts msgBufCounts = { 0, 0 }; -struct MsgCounts msgCounts = { 0, 0 }; - -/* XXX HACK HACK HACK XXX */ -#if 1 -/* First, force assertion checking */ -#undef NDEBUG -#include - -/* This routine is TEMPORARY and is intended to track down a problem we're - * having with apparent buffer overflows in this file. - */ -static void -msgq_integrity(void) -{ - struct MsgBuf *mb; - struct Msg *msg; +/** Statistics tracking for message sizes. */ +struct MsgSizes { + unsigned int msgs; /**< total number of messages */ + unsigned int sizes[BUFSIZE]; /**< histogram of message sizes */ +}; - for (mb = MQData.msgs; mb; mb = mb->next) - assert(((unsigned long)mb) != 0x8000a0d); - for (mb = MQData.free_mbs; mb; mb = mb->next) - assert(((unsigned long)mb) != 0x8000a0d); - for (msg = MQData.free_msgs; msg; msg = msg->next) - assert(((unsigned long)msg) != 0x8000a0d); -} -#else -#define msgq_integrity() ((void)0) -#endif /* XXX HACK HACK HACK XXX */ +/** Global tracking data for message buffers. */ +static struct { + struct MsgBuf *msglist; /**< list of in-use MsgBuf's */ + struct { + unsigned int alloc; /**< number of Msg's allocated */ + unsigned int used; /**< number of Msg's in use */ + struct Msg *free; /**< freelist of Msg's */ + } msgs; /**< tracking info for Msg structs */ + size_t tot_bufsize; /**< total amount of memory in buffers */ + /** Array of MsgBuf information, one entry for each used bucket size. */ + struct { + unsigned int alloc; /**< total MsgBuf's of this size */ + unsigned int used; /**< number of MsgBuf's of this size in use */ + struct MsgBuf *free; /**< list of free MsgBuf's */ + } msgBufs[MB_MAX_SHIFT - MB_BASE_SHIFT + 1]; + struct MsgSizes sizes; /**< histogram of message sizes */ +} MQData; /* * This routine is used to remove a certain amount of data from a given * queue and release the Msg (and MsgBuf) structure if needed */ +/** Remove some data from a list within a message queue. + * @param[in,out] mq Message queue to remove from. + * @param[in,out] qlist Particular list within queue to remove from. + * @param[in,out] length_p Number of bytes left to remove. + */ static void msgq_delmsg(struct MsgQ *mq, struct MsgQList *qlist, unsigned int *length_p) { struct Msg *m; unsigned int msglen; - msgq_integrity(); - assert(0 != mq); assert(0 != qlist); assert(0 != qlist->head); @@ -112,27 +126,23 @@ msgq_delmsg(struct MsgQ *mq, struct MsgQList *qlist, unsigned int *length_p) else qlist->head = m->next; /* just shift the list down some */ - msgCounts.used--; /* struct Msg is not in use anymore */ + MQData.msgs.used--; /* struct Msg is not in use anymore */ - m->next = MQData.free_msgs; /* throw it onto the free list */ - MQData.free_msgs = m; + m->next = MQData.msgs.free; /* throw it onto the free list */ + MQData.msgs.free = m; } else { mq->length -= *length_p; /* decrement queue length */ m->sent += *length_p; /* this much of the message has been sent */ *length_p = 0; /* we've dealt with it all */ } - - msgq_integrity(); } -/* - * This just initializes a struct MsgQ. +/** Initialize \a mq. + * @param[in] mq MsgQ to initialize. */ void msgq_init(struct MsgQ *mq) { - msgq_integrity(); - assert(0 != mq); mq->length = 0; @@ -141,21 +151,15 @@ msgq_init(struct MsgQ *mq) mq->queue.tail = 0; mq->prio.head = 0; mq->prio.tail = 0; - - msgq_integrity(); } -/* - * This routine is used to delete the specified number of bytes off - * of the queue. We only really need to worry about one struct Msg*, - * but this allows us to retain the flexibility to deal with more, - * which means we could do something fancy involving writev... +/** Delete bytes from the front of a message queue. + * @param[in] mq Queue to drop data from. + * @param[in] length Number of bytes to drop. */ void msgq_delete(struct MsgQ *mq, unsigned int length) { - msgq_integrity(); - assert(0 != mq); while (length > 0) { @@ -168,13 +172,14 @@ msgq_delete(struct MsgQ *mq, unsigned int length) else break; } - - msgq_integrity(); } -/* - * This is the more intelligent routine that can fill in an array of - * struct iovec's. +/** Map data from a message queue to an I/O vector. + * @param[in] mq Message queue to send from. + * @param[out] iov Output vector. + * @param[in] count Number of elements in \a iov. + * @param[out] len Number of bytes mapped from \a mq to \a iov. + * @return Number of elements filled in \a iov. */ int msgq_mapiov(const struct MsgQ *mq, struct iovec *iov, int count, @@ -184,17 +189,13 @@ msgq_mapiov(const struct MsgQ *mq, struct iovec *iov, int count, struct Msg *prio; int i = 0; - msgq_integrity(); - assert(0 != mq); assert(0 != iov); assert(0 != count); assert(0 != len); - if (mq->length <= 0) { /* no data to map */ - msgq_integrity(); + if (mq->length <= 0) /* no data to map */ return 0; - } if (mq->queue.head && mq->queue.head->sent > 0) { /* partial msg on norm q */ iov[i].iov_base = mq->queue.head->msg->msg + mq->queue.head->sent; @@ -204,10 +205,8 @@ msgq_mapiov(const struct MsgQ *mq, struct iovec *iov, int count, queue = mq->queue.head->next; /* where we start later... */ i++; /* filled an iovec... */ - if (!--count) { /* check for space */ - msgq_integrity(); + if (!--count) /* check for space */ return i; - } } else queue = mq->queue.head; /* start at head of queue */ @@ -219,10 +218,8 @@ msgq_mapiov(const struct MsgQ *mq, struct iovec *iov, int count, prio = mq->prio.head->next; /* where we start later... */ i++; /* filled an iovec... */ - if (!--count) { /* check for space */ - msgq_integrity(); + if (!--count) /* check for space */ return i; - } } else prio = mq->prio.head; /* start at head of prio */ @@ -232,10 +229,8 @@ msgq_mapiov(const struct MsgQ *mq, struct iovec *iov, int count, *len += iov[i].iov_len; i++; /* filled an iovec... */ - if (!--count) { /* check for space */ - msgq_integrity(); + if (!--count) /* check for space */ return i; - } } for (; queue; queue = queue->next) { /* go through normal queue */ @@ -244,64 +239,165 @@ msgq_mapiov(const struct MsgQ *mq, struct iovec *iov, int count, *len += iov[i].iov_len; i++; /* filled an iovec... */ - if (!--count) { /* check for space */ - msgq_integrity(); + if (!--count) /* check for space */ return i; - } } - msgq_integrity(); - return i; } -/* - * This routine builds a struct MsgBuf with the appropriate contents - * and returns it; this saves us from having to worry about the contents - * of struct MsgBuf in anything other than this module +/** Allocate a message buffer large enough to hold \a length bytes. + * TODO: \a in_mb needs better documentation. + * @param[in] in_mb Some other message buffer(?). + * @param[in] length Number of bytes of space to reserve in output. + * @return Pointer to some usable message buffer. + */ +static struct MsgBuf * +msgq_alloc(struct MsgBuf *in_mb, int length) +{ + struct MsgBuf *mb; + int power; + + /* Find the power of two size that will accommodate the message */ + for (power = MB_BASE_SHIFT; power < MB_MAX_SHIFT + 1; power++) + if ((length - 1) >> power == 0) + break; + assert((1 << power) >= length); + assert((1 << power) <= 512); + length = 1 << power; /* reset the length */ + + /* If the message needs a buffer of exactly the existing size, just use it */ + if (in_mb && in_mb->power == power) { + in_mb->real = in_mb; /* real buffer is this buffer */ + return in_mb; + } + + /* Try popping one off the freelist first */ + if ((mb = MQData.msgBufs[power - MB_BASE_SHIFT].free)) { + MQData.msgBufs[power - MB_BASE_SHIFT].free = mb->next; + } else if (MQData.tot_bufsize < feature_int(FEAT_BUFFERPOOL)) { + /* Allocate another if we won't bust the BUFFERPOOL */ + Debug((DEBUG_MALLOC, "Allocating MsgBuf of length %d (total size %zu)", + length, sizeof(struct MsgBuf) + length)); + mb = (struct MsgBuf *)MyMalloc(sizeof(struct MsgBuf) + length); + MQData.msgBufs[power - MB_BASE_SHIFT].alloc++; + mb->power = power; /* remember size */ + MQData.tot_bufsize += length; + } + + if (mb) { + MQData.msgBufs[power - MB_BASE_SHIFT].used++; /* how many are we using? */ + + mb->real = 0; /* essential initializations */ + mb->ref = 1; + + if (in_mb) /* remember who's the *real* buffer */ + in_mb->real = mb; + } else if (in_mb) /* just use the input buffer */ + mb = in_mb->real = in_mb; + + return mb; /* return the buffer */ +} + +/** Deallocate unused message buffers. + */ +static void +msgq_clear_freembs(void) +{ + struct MsgBuf *mb; + int i; + + /* Walk through the various size classes */ + for (i = MB_BASE_SHIFT; i < MB_MAX_SHIFT + 1; i++) + /* walk down the free list */ + while ((mb = MQData.msgBufs[i - MB_BASE_SHIFT].free)) { + MQData.msgBufs[i - MB_BASE_SHIFT].free = mb->next; /* shift free list */ + MQData.msgBufs[i - MB_BASE_SHIFT].alloc--; /* reduce allocation count */ + MQData.tot_bufsize -= 1 << i; /* reduce total buffer allocation count */ + MyFree(mb); /* and free the buffer */ + } +} + +/** Format a message buffer for a client from a format string. + * @param[in] dest %Client that receives the data (may be NULL). + * @param[in] format Format string for message. + * @param[in] vl Argument list for \a format. + * @return Allocated MsgBuf. */ struct MsgBuf * msgq_vmake(struct Client *dest, const char *format, va_list vl) { struct MsgBuf *mb; - msgq_integrity(); - assert(0 != format); - if (!(mb = MQData.free_mbs)) { /* do I need to allocate one? */ - mb = (struct MsgBuf *)MyMalloc(sizeof(struct MsgBuf)); - msgBufCounts.alloc++; /* we allocated another */ - } else /* shift the free list */ - MQData.free_mbs = MQData.free_mbs->next; - - msgBufCounts.used++; /* we're using another */ + if (!(mb = msgq_alloc(0, BUFSIZE))) { + if (feature_bool(FEAT_HAS_FERGUSON_FLUSHER)) { + /* + * from "Married With Children" episode were Al bought a REAL toilet + * on the black market because he was tired of the wimpy water + * conserving toilets they make these days --Bleep + */ + /* + * Apparently this doesn't work, the server _has_ to + * dump a few clients to handle the load. A fully loaded + * server cannot handle a net break without dumping some + * clients. If we flush the connections here under a full + * load we may end up starving the kernel for mbufs and + * crash the machine + */ + /* + * attempt to recover from buffer starvation before + * bailing this may help servers running out of memory + */ + flush_connections(0); + mb = msgq_alloc(0, BUFSIZE); + } + if (!mb) { /* OK, try clearing the buffer free list */ + msgq_clear_freembs(); + mb = msgq_alloc(0, BUFSIZE); + } + if (!mb) { /* OK, try killing a client */ + kill_highest_sendq(0); /* Don't kill any server connections */ + msgq_clear_freembs(); /* Release whatever was just freelisted */ + mb = msgq_alloc(0, BUFSIZE); + } + if (!mb) { /* hmmm... */ + kill_highest_sendq(1); /* Try killing a server connection now */ + msgq_clear_freembs(); /* Clear freelist again */ + mb = msgq_alloc(0, BUFSIZE); + } + if (!mb) /* AIEEEE! */ + server_panic("Unable to allocate buffers!"); + } - mb->next = MQData.msgs; /* initialize the msgbuf */ - mb->prev_p = &MQData.msgs; - mb->ref = 1; + mb->next = MQData.msglist; /* initialize the msgbuf */ + mb->prev_p = &MQData.msglist; /* fill the buffer */ - mb->length = ircd_vsnprintf(dest, mb->msg, sizeof(mb->msg) - 2, format, vl); + mb->length = ircd_vsnprintf(dest, mb->msg, bufsize(mb) - 1, format, vl); - if (mb->length > sizeof(mb->msg) - 3) - mb->length = sizeof(mb->msg) - 3; + if (mb->length > bufsize(mb) - 2) + mb->length = bufsize(mb) - 2; mb->msg[mb->length++] = '\r'; /* add \r\n to buffer */ mb->msg[mb->length++] = '\n'; mb->msg[mb->length] = '\0'; /* not strictly necessary */ - assert(mb->length < sizeof(mb->msg)); - - if (MQData.msgs) /* link it into the list */ - MQData.msgs->prev_p = &mb->next; - MQData.msgs = mb; + assert(mb->length <= bufsize(mb)); - msgq_integrity(); + if (MQData.msglist) /* link it into the list */ + MQData.msglist->prev_p = &mb->next; + MQData.msglist = mb; return mb; } +/** Format a message buffer for a client from a format string. + * @param[in] dest %Client that receives the data (may be NULL). + * @param[in] format Format string for message. + * @return Allocated MsgBuf. + */ struct MsgBuf * msgq_make(struct Client *dest, const char *format, ...) { @@ -315,72 +411,71 @@ msgq_make(struct Client *dest, const char *format, ...) return mb; } -/* - * This routine is used to append a formatted string to a struct MsgBuf. +/** Append text to an existing message buffer. + * @param[in] dest %Client for whom to format the message. + * @param[in] mb Message buffer to append to. + * @param[in] format Format string of what to append. */ void msgq_append(struct Client *dest, struct MsgBuf *mb, const char *format, ...) { va_list vl; - msgq_integrity(); - assert(0 != mb); assert(0 != format); + assert(0 == mb->real); assert(2 < mb->length); - assert(sizeof(mb->msg) > mb->length); + assert(bufsize(mb) >= mb->length); mb->length -= 2; /* back up to before \r\n */ va_start(vl, format); /* append to the buffer */ mb->length += ircd_vsnprintf(dest, mb->msg + mb->length, - sizeof(mb->msg) - 2 - mb->length, format, vl); + bufsize(mb) - mb->length - 1, format, vl); va_end(vl); - if (mb->length > sizeof(mb->msg) - 3) - mb->length = sizeof(mb->msg) - 3; + if (mb->length > bufsize(mb) - 2) + mb->length = bufsize(mb) - 2; mb->msg[mb->length++] = '\r'; /* add \r\n to buffer */ mb->msg[mb->length++] = '\n'; mb->msg[mb->length] = '\0'; /* not strictly necessary */ - assert(mb->length < sizeof(mb->msg)); - - msgq_integrity(); + assert(mb->length <= bufsize(mb)); } -/* - * This routine is called to decrement the reference count on a - * struct MsgBuf and delete it if necessary. +/** Decrement the reference count on \a mb, freeing it if needed. + * @param[in] mb MsgBuf to release. */ void msgq_clean(struct MsgBuf *mb) { - msgq_integrity(); - assert(0 != mb); assert(0 < mb->ref); - assert(0 != mb->prev_p); if (!--mb->ref) { /* deallocate the message */ - *mb->prev_p = mb->next; /* clip it out of active MsgBuf's list */ - if (mb->next) - mb->next->prev_p = mb->prev_p; + if (mb->prev_p) { + *mb->prev_p = mb->next; /* clip it out of active MsgBuf's list */ + if (mb->next) + mb->next->prev_p = mb->prev_p; + } - mb->next = MQData.free_mbs; /* add it to free list */ - MQData.free_mbs = mb; + if (mb->real && mb->real != mb) /* clean up the real buffer */ + msgq_clean(mb->real); - mb->prev_p = 0; + mb->next = MQData.msgBufs[mb->power - MB_BASE_SHIFT].free; + MQData.msgBufs[mb->power - MB_BASE_SHIFT].free = mb; + MQData.msgBufs[mb->power - MB_BASE_SHIFT].used--; - msgBufCounts.used--; /* decrement the usage count */ + mb->prev_p = 0; } - - msgq_integrity(); } -/* - * This routine simply adds a struct Msg to the end of a user's MsgQ. +/** Append a message to a peer's message queue. + * @param[in] mq Message queue to append to. + * @param[in] mb Message to append. + * @param[in] prio If non-zero, use the high-priority (lag-busting) message list; else use the normal list. */ void msgq_add(struct MsgQ *mq, struct MsgBuf *mb, int prio) @@ -388,31 +483,59 @@ msgq_add(struct MsgQ *mq, struct MsgBuf *mb, int prio) struct MsgQList *qlist; struct Msg *msg; - msgq_integrity(); - assert(0 != mq); assert(0 != mb); assert(0 < mb->ref); + assert(0 < mb->length); - Debug((DEBUG_SEND, "Adding buffer %p [%.*s] to %s queue", mb, - mb->length - 2, mb->msg, prio ? "priority" : "normal")); + Debug((DEBUG_SEND, "Adding buffer %p [%.*s] length %u to %s queue", mb, + mb->length - 2, mb->msg, mb->length, prio ? "priority" : "normal")); qlist = prio ? &mq->prio : &mq->queue; - if (!(msg = MQData.free_msgs)) { /* do I need to allocate one? */ + if (!(msg = MQData.msgs.free)) { /* do I need to allocate one? */ msg = (struct Msg *)MyMalloc(sizeof(struct Msg)); - msgCounts.alloc++; /* we allocated another */ + MQData.msgs.alloc++; /* we allocated another */ } else /* shift the free list */ - MQData.free_msgs = MQData.free_msgs->next; + MQData.msgs.free = MQData.msgs.free->next; - msgCounts.used++; /* we're using another */ + MQData.msgs.used++; /* we're using another */ msg->next = 0; /* initialize the msg */ msg->sent = 0; - msg->msg = mb; + /* Get the real buffer, allocating one if necessary */ + if (!mb->real) { + struct MsgBuf *tmp; + + MQData.sizes.msgs++; /* update histogram counts */ + MQData.sizes.sizes[mb->length - 1]++; + + tmp = msgq_alloc(mb, mb->length); /* allocate a close-fitting buffer */ + + if (tmp != mb) { /* OK, prepare the new "real" buffer */ + Debug((DEBUG_SEND, "Copying old buffer %p [%.*s] length %u into new " + "buffer %p size %u", mb, mb->length - 2, mb->msg, mb->length, + tmp, bufsize(tmp))); + memcpy(tmp->msg, mb->msg, mb->length + 1); /* copy string over */ + tmp->length = mb->length; + + tmp->next = mb->next; /* replace it in the list, now */ + if (tmp->next) + tmp->next->prev_p = &tmp->next; + tmp->prev_p = mb->prev_p; + *tmp->prev_p = tmp; + + mb->next = 0; /* this one's no longer in the list */ + mb->prev_p = 0; + } + } + + mb = mb->real; /* work with the real buffer */ mb->ref++; /* increment the ref count on the buffer */ + msg->msg = mb; /* point at the real message buffer now */ + if (!qlist->head) /* queue list was empty; head and tail point to msg */ qlist->head = qlist->tail = msg; else { @@ -424,39 +547,82 @@ msgq_add(struct MsgQ *mq, struct MsgBuf *mb, int prio) mq->length += mb->length; /* update the queue length */ mq->count++; /* and the queue count */ - - msgq_integrity(); } -/* - * This is for reporting memory usage by the msgq system. +/** Report memory statistics for message buffers. + * @param[in] cptr Client requesting information. + * @param[out] msg_alloc Receives number of bytes allocated in Msg structs. + * @param[out] msgbuf_alloc Receives number of bytes allocated in MsgBuf structs. */ void -msgq_count_memory(size_t *msg_alloc, size_t *msg_used, size_t *msgbuf_alloc, - size_t *msgbuf_used) +msgq_count_memory(struct Client *cptr, size_t *msg_alloc, size_t *msgbuf_alloc) { - msgq_integrity(); + int i; + size_t total = 0, size; + assert(0 != cptr); assert(0 != msg_alloc); - assert(0 != msg_used); assert(0 != msgbuf_alloc); - assert(0 != msgbuf_used); - *msg_alloc = msgCounts.alloc * sizeof(struct Msg); - *msg_used = msgCounts.used * sizeof(struct Msg); - *msgbuf_alloc = msgCounts.alloc * sizeof(struct MsgBuf); - *msgbuf_used = msgCounts.used * sizeof(struct MsgBuf); - - msgq_integrity(); + /* Data for Msg's is simple, so just send it */ + send_reply(cptr, SND_EXPLICIT | RPL_STATSDEBUG, + ":Msgs allocated %d(%zu) used %d(%zu) text %zu", + MQData.msgs.alloc, MQData.msgs.alloc * sizeof(struct Msg), + MQData.msgs.used, MQData.msgs.used * sizeof(struct Msg), + MQData.tot_bufsize); + /* count_memory() wants to know the total */ + *msg_alloc = MQData.msgs.alloc * sizeof(struct Msg); + + /* Ok, now walk through each size class */ + for (i = MB_BASE_SHIFT; i < MB_MAX_SHIFT + 1; i++) { + size = sizeof(struct MsgBuf) + (1 << i); /* total size of a buffer */ + + /* Send information for this buffer size class */ + send_reply(cptr, SND_EXPLICIT | RPL_STATSDEBUG, + ":MsgBufs of size %zu allocated %d(%zu) used %d(%zu)", 1 << i, + MQData.msgBufs[i - MB_BASE_SHIFT].alloc, + MQData.msgBufs[i - MB_BASE_SHIFT].alloc * size, + MQData.msgBufs[i - MB_BASE_SHIFT].used, + MQData.msgBufs[i - MB_BASE_SHIFT].used * size); + + /* count_memory() wants to know the total */ + total += MQData.msgBufs[i - MB_BASE_SHIFT].alloc * size; + } + *msgbuf_alloc = total; } -/* - * This routine is used simply to report how much bufferspace is left. +/** Report remaining space in a MsgBuf. + * @param[in] mb Message buffer to check. + * @return Number of additional bytes that can be appended to the message. */ unsigned int msgq_bufleft(struct MsgBuf *mb) { assert(0 != mb); - return sizeof(mb->msg) - mb->length - 1; /* \r\n counted in mb->length */ + return bufsize(mb) - mb->length; /* \r\n counted in mb->length */ +} + +/** Send histogram of message lengths to a client. + * @param[in] cptr Client requesting statistics. + * @param[in] sd Stats descriptor for request (ignored). + * @param[in] param Extra parameter from user (ignored). + */ +void +msgq_histogram(struct Client *cptr, const struct StatDesc *sd, char *param) +{ + struct MsgSizes tmp = MQData.sizes; /* All hail structure copy! */ + int i; + + send_reply(cptr, SND_EXPLICIT | RPL_STATSDEBUG, + ":Histogram of message lengths (%lu messages)", tmp.msgs); + for (i = 0; i + 16 <= BUFSIZE; i += 16) + send_reply(cptr, SND_EXPLICIT | RPL_STATSDEBUG, ":% 4d: %u %u %u %u " + "%u %u %u %u %u %u %u %u %u %u %u %u", i + 1, + tmp.sizes[i + 0], tmp.sizes[i + 1], tmp.sizes[i + 2], + tmp.sizes[i + 3], tmp.sizes[i + 4], tmp.sizes[i + 5], + tmp.sizes[i + 6], tmp.sizes[i + 7], tmp.sizes[i + 8], + tmp.sizes[i + 9], tmp.sizes[i + 10], tmp.sizes[i + 11], + tmp.sizes[i + 12], tmp.sizes[i + 13], tmp.sizes[i + 14], + tmp.sizes[i + 15]); }