#include "gnunet_bandwidth_lib.h"
#include "gnunet_server_lib.h"
-#define DEBUG_BANDWIDTH GNUNET_EXTRA_LOGGING
-#define LOG(kind,...) GNUNET_log_from (kind, "util",__VA_ARGS__)
+#define LOG(kind,...) GNUNET_log_from (kind, "util-bandwidth", __VA_ARGS__)
/**
* Create a new bandwidth value.
{
struct GNUNET_BANDWIDTH_Value32NBO ret;
-#if DEBUG_BANDWIDTH
LOG (GNUNET_ERROR_TYPE_DEBUG, "Initializing bandwidth of %u Bps\n",
(unsigned int) bytes_per_second);
-#endif
ret.value__ = htonl (bytes_per_second);
return ret;
}
uint64_t b;
b = ntohl (bps.value__);
-#if DEBUG_BANDWIDTH
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Bandwidth has %llu bytes available until deadline in %llums\n",
(unsigned long long) ((b * deadline.rel_value + 500LL) / 1000LL),
deadline.rel_value);
-#endif
return (b * deadline.rel_value + 500LL) / 1000LL;
}
b = ntohl (bps.value__);
if (b == 0)
{
-#if DEBUG_BANDWIDTH
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Bandwidth suggests delay of infinity (zero bandwidth)\n");
-#endif
return GNUNET_TIME_UNIT_FOREVER_REL;
}
ret.rel_value = size * 1000LL / b;
-#if DEBUG_BANDWIDTH
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Bandwidth suggests delay of %llu ms for %llu bytes of traffic\n",
(unsigned long long) ret.rel_value, (unsigned long long) size);
-#endif
return ret;
}
av->last_update__ = GNUNET_TIME_absolute_get ();
av->available_bytes_per_s__ = ntohl (bytes_per_second_limit.value__);
av->max_carry_s__ = max_carry_s;
-#if DEBUG_BANDWIDTH
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Tracker %p initialized with %u Bps and max carry %u\n", av,
(unsigned int) av->available_bytes_per_s__, (unsigned int) max_carry_s);
-#endif
}
else
av->consumption_since_last_update__ = -max_carry;
}
-#if DEBUG_BANDWIDTH
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Tracker %p updated, have %u Bps, last update was %llu ms ago\n", av,
(unsigned int) av->available_bytes_per_s__,
(unsigned long long) delta_time);
-#endif
-
}
{
int64_t nc;
-#if DEBUG_BANDWIDTH
LOG (GNUNET_ERROR_TYPE_DEBUG, "Tracker %p consumes %d bytes\n", av,
(int) size);
-#endif
if (size > 0)
{
nc = av->consumption_since_last_update__ + size;
update_tracker (av);
if (av->consumption_since_last_update__ > 0)
{
-#if DEBUG_BANDWIDTH
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Tracker %p consumption %llu bytes above limit\n", av,
(unsigned long long) av->consumption_since_last_update__);
-#endif
return GNUNET_YES;
}
}
if (av->available_bytes_per_s__ == 0)
{
-#if DEBUG_BANDWIDTH
LOG (GNUNET_ERROR_TYPE_DEBUG, "Tracker %p delay is infinity\n", av);
-#endif
return GNUNET_TIME_UNIT_FOREVER_REL;
}
update_tracker (av);
bytes_needed = size + av->consumption_since_last_update__;
if (bytes_needed <= 0)
{
-#if DEBUG_BANDWIDTH
LOG (GNUNET_ERROR_TYPE_DEBUG, "Tracker %p delay for %u bytes is zero\n", av,
(unsigned int) size);
-#endif
return GNUNET_TIME_UNIT_ZERO;
}
ret.rel_value =
(1000LL * bytes_needed) /
(unsigned long long) av->available_bytes_per_s__;
-#if DEBUG_BANDWIDTH
LOG (GNUNET_ERROR_TYPE_DEBUG, "Tracker %p delay for %u bytes is %llu ms\n",
av, (unsigned int) size, (unsigned long long) ret.rel_value);
-#endif
return ret;
}
GNUNET_TIME_absolute_get_duration
(av->last_update__));
used = av->consumption_since_last_update__;
-#if DEBUG_BANDWIDTH
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Tracker %p available bandwidth is %lld bytes\n", av,
(long long) (int64_t) (avail - used));
-#endif
return (int64_t) (avail - used);
}
uint32_t new_limit;
new_limit = ntohl (bytes_per_second_limit.value__);
-#if DEBUG_BANDWIDTH
LOG (GNUNET_ERROR_TYPE_DEBUG, "Tracker %p bandwidth changed to %u Bps\n", av,
(unsigned int) new_limit);
-#endif
update_tracker (av);
old_limit = av->available_bytes_per_s__;
av->available_bytes_per_s__ = new_limit;
#include "gnunet_scheduler_lib.h"
#include "gnunet_server_lib.h"
-#define DEBUG_CONNECTION GNUNET_EXTRA_LOGGING
#define LOG(kind,...) GNUNET_log_from (kind, "util", __VA_ARGS__)
ret->addr = uaddr;
ret->addrlen = addrlen;
ret->sock = sock;
-#if DEBUG_CONNECTION
- LOG (GNUNET_ERROR_TYPE_INFO, _("Accepting connection from `%s': %p\n"),
+ LOG (GNUNET_ERROR_TYPE_INFO,
+ _("Accepting connection from `%s': %p\n"),
GNUNET_a2s (uaddr, addrlen), ret);
-#endif
return ret;
}
GNUNET_assert (sock->dns_active == NULL);
if (0 != (sock->ccs & COCO_TRANSMIT_READY))
{
-#if DEBUG_CONNECTION
LOG (GNUNET_ERROR_TYPE_DEBUG, "Destroy waits for CCS-TR to be done (%p)\n",
sock);
-#endif
sock->ccs |= COCO_DESTROY_CONTINUATION;
return;
}
if (sock->write_task != GNUNET_SCHEDULER_NO_TASK)
{
-#if DEBUG_CONNECTION
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Destroy waits for write_task to be done (%p)\n", sock);
-#endif
GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == sock->destroy_task);
sock->destroy_task =
GNUNET_SCHEDULER_add_after (sock->write_task, &destroy_continuation,
}
if (sock->sock != NULL)
{
-#if DEBUG_CONNECTION
LOG (GNUNET_ERROR_TYPE_DEBUG, "Shutting down socket (%p)\n", sock);
-#endif
if (sock->persist != GNUNET_YES)
{
if ((GNUNET_YES != GNUNET_NETWORK_socket_shutdown (sock->sock, SHUT_RDWR))
sock);
return;
}
-#if DEBUG_CONNECTION
LOG (GNUNET_ERROR_TYPE_DEBUG, "Destroy actually runs (%p)!\n", sock);
-#endif
while (NULL != (pos = sock->ap_head))
{
GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (pos->sock));
GNUNET_free_non_null (sock->addr);
GNUNET_free_non_null (sock->hostname);
GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == sock->destroy_task);
-#if DEBUG_CONNECTION
LOG (GNUNET_ERROR_TYPE_DEBUG, "Freeing memory of connection %p.\n", sock);
-#endif
GNUNET_free (sock->write_buffer);
GNUNET_free (sock);
}
static void
connect_fail_continuation (struct GNUNET_CONNECTION_Handle *h)
{
-#if DEBUG_CONNECTION
LOG ((0 !=
strncmp (h->hostname, "localhost:",
10)) ? GNUNET_ERROR_TYPE_INFO : GNUNET_ERROR_TYPE_WARNING,
_
("Failed to establish TCP connection to `%s:%u', no further addresses to try.\n"),
h->hostname, h->port);
-#endif
/* connect failed / timed out */
GNUNET_break (h->ap_head == NULL);
GNUNET_break (h->ap_tail == NULL);
/* trigger jobs that used to wait on "connect_task" */
if (0 != (h->ccs & COCO_RECEIVE_AGAIN))
{
-#if DEBUG_CONNECTION
LOG (GNUNET_ERROR_TYPE_DEBUG,
"connect_fail_continuation triggers receive_again (%p)\n", h);
-#endif
h->ccs -= COCO_RECEIVE_AGAIN;
h->read_task = GNUNET_SCHEDULER_add_now (&receive_again, h);
}
if (0 != (h->ccs & COCO_TRANSMIT_READY))
{
-#if DEBUG_CONNECTION
LOG (GNUNET_ERROR_TYPE_DEBUG,
"connect_fail_continuation cancels timeout_task, triggers transmit_ready (%p)\n",
h);
-#endif
GNUNET_assert (h->nth.timeout_task != GNUNET_SCHEDULER_NO_TASK);
GNUNET_SCHEDULER_cancel (h->nth.timeout_task);
h->nth.timeout_task = GNUNET_SCHEDULER_NO_TASK;
}
if (0 != (h->ccs & COCO_DESTROY_CONTINUATION))
{
-#if DEBUG_CONNECTION
LOG (GNUNET_ERROR_TYPE_DEBUG,
"connect_fail_continuation runs destroy_continuation (%p)\n", h);
-#endif
h->ccs -= COCO_DESTROY_CONTINUATION;
GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == h->destroy_task);
h->destroy_task = GNUNET_SCHEDULER_add_now (&destroy_continuation, h);
static void
connect_success_continuation (struct GNUNET_CONNECTION_Handle *h)
{
-#if DEBUG_CONNECTION
LOG (GNUNET_ERROR_TYPE_DEBUG, "Connection to `%s' succeeded! (%p)\n",
GNUNET_a2s (h->addr, h->addrlen), h);
-#endif
/* trigger jobs that waited for the connection */
if (0 != (h->ccs & COCO_RECEIVE_AGAIN))
{
-#if DEBUG_CONNECTION
LOG (GNUNET_ERROR_TYPE_DEBUG,
"connect_success_continuation runs receive_again (%p)\n", h);
-#endif
h->ccs -= COCO_RECEIVE_AGAIN;
h->read_task = GNUNET_SCHEDULER_add_now (&receive_again, h);
}
if (0 != (h->ccs & COCO_TRANSMIT_READY))
{
-#if DEBUG_CONNECTION
LOG (GNUNET_ERROR_TYPE_DEBUG,
"connect_success_continuation runs transmit_ready, cancels timeout_task (%p)\n",
h);
-#endif
GNUNET_assert (h->nth.timeout_task != GNUNET_SCHEDULER_NO_TASK);
GNUNET_SCHEDULER_cancel (h->nth.timeout_task);
h->nth.timeout_task = GNUNET_SCHEDULER_NO_TASK;
}
if (0 != (h->ccs & COCO_DESTROY_CONTINUATION))
{
-#if DEBUG_CONNECTION
LOG (GNUNET_ERROR_TYPE_DEBUG,
"connect_success_continuation runs destroy_continuation (%p)\n", h);
-#endif
h->ccs -= COCO_DESTROY_CONTINUATION;
GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == h->destroy_task);
h->destroy_task = GNUNET_SCHEDULER_add_now (&destroy_continuation, h);
return; /* already connected */
GNUNET_assert (h->addr == NULL);
/* try to connect */
-#if DEBUG_CONNECTION
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Trying to connect using address `%s:%u/%s:%u'\n", h->hostname, h->port,
GNUNET_a2s (addr, addrlen), h->port);
-#endif
ap = GNUNET_malloc (sizeof (struct AddressProbe) + addrlen);
ap->addr = (const struct sockaddr *) &ap[1];
memcpy (&ap[1], addr, addrlen);
GNUNET_free (ap);
return; /* not supported by OS */
}
-#if DEBUG_CONNECTION
LOG (GNUNET_ERROR_TYPE_INFO, _("Trying to connect to `%s' (%p)\n"),
GNUNET_a2s (ap->addr, ap->addrlen), h);
-#endif
if ((GNUNET_OK !=
GNUNET_NETWORK_socket_connect (ap->sock, ap->addr, ap->addrlen)) &&
(errno != EINPROGRESS))
ret->addr = GNUNET_malloc (addrlen);
memcpy (ret->addr, serv_addr, addrlen);
ret->addrlen = addrlen;
-#if DEBUG_CONNECTION
LOG (GNUNET_ERROR_TYPE_INFO, _("Trying to connect to `%s' (%p)\n"),
GNUNET_a2s (serv_addr, addrlen), ret);
-#endif
return ret;
}
{
GNUNET_CONNECTION_Receiver receiver;
-#if DEBUG_CONNECTION
LOG (GNUNET_ERROR_TYPE_DEBUG, "Network signals time out to receiver (%p)!\n",
sh);
-#endif
GNUNET_assert (NULL != (receiver = sh->receiver));
sh->receiver = NULL;
receiver (sh->receiver_cls, NULL, 0, NULL, 0, 0);
(0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN)))
{
/* ignore shutdown request, go again immediately */
-#if DEBUG_CONNECTION
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Ignoring shutdown signal per configuration\n");
-#endif
sh->read_task =
GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_absolute_get_remaining
(sh->receive_timeout), sh->sock,
(0 != (tc->reason & GNUNET_SCHEDULER_REASON_TIMEOUT)) ||
(0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN)))
{
-#if DEBUG_CONNECTION
if (0 == (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Receive from `%s' encounters error: time out by %llums... (%p)\n",
GNUNET_a2s (sh->addr, sh->addrlen),
GNUNET_TIME_absolute_get_duration (sh->receive_timeout).rel_value,
sh);
-#endif
signal_timeout (sh);
return;
}
if (sh->sock == NULL)
{
/* connect failed for good */
-#if DEBUG_CONNECTION
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Receive encounters error, socket closed... (%p)\n", sh);
-#endif
signal_error (sh, ECONNREFUSED);
return;
}
{
if (errno == EINTR)
goto RETRY;
-#if DEBUG_CONNECTION
LOG (GNUNET_ERROR_TYPE_DEBUG, "Error receiving: %s\n", STRERROR (errno));
-#endif
signal_error (sh, errno);
return;
}
-#if DEBUG_CONNECTION
LOG (GNUNET_ERROR_TYPE_DEBUG,
"receive_ready read %u/%u bytes from `%s' (%p)!\n", (unsigned int) ret,
sh->max, GNUNET_a2s (sh->addr, sh->addrlen), sh);
-#endif
GNUNET_assert (NULL != (receiver = sh->receiver));
sh->receiver = NULL;
receiver (sh->receiver_cls, buffer, ret, sh->addr, sh->addrlen, 0);
if (sh->sock == NULL)
{
/* not connected and no longer trying */
-#if DEBUG_CONNECTION
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Receive encounters error, socket closed (%p)...\n", sh);
-#endif
signal_error (sh, ECONNREFUSED);
return;
}
if ((now.abs_value > sh->receive_timeout.abs_value) ||
(0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN)))
{
-#if DEBUG_CONNECTION
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Receive encounters error: time out (%p)...\n", sh);
-#endif
signal_timeout (sh);
return;
}
struct GNUNET_CONNECTION_Handle *sock = cls;
GNUNET_CONNECTION_TransmitReadyNotify notify;
-#if DEBUG_CONNECTION
- LOG (GNUNET_ERROR_TYPE_DEBUG, "transmit_timeout running (%p)\n", sock);
-#endif
sock->nth.timeout_task = GNUNET_SCHEDULER_NO_TASK;
-#if DEBUG_CONNECTION
LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Transmit to `%s:%u/%s' fails, time out reached (%p).\n", sock->hostname,
+ "Transmit to `%s:%u/%s' fails, time out reached (%p).\n",
+ sock->hostname,
sock->port, GNUNET_a2s (sock->addr, sock->addrlen), sock);
-#endif
GNUNET_assert (0 != (sock->ccs & COCO_TRANSMIT_READY));
sock->ccs -= COCO_TRANSMIT_READY; /* remove request */
notify = sock->nth.notify_ready;
struct GNUNET_CONNECTION_Handle *sock = cls;
GNUNET_CONNECTION_TransmitReadyNotify notify;
-#if DEBUG_CONNECTION
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Transmission request of size %u fails (%s/%u), connection failed (%p).\n",
sock->nth.notify_size, sock->hostname, sock->port, sock);
-#endif
sock->write_task = GNUNET_SCHEDULER_NO_TASK;
notify = sock->nth.notify_ready;
sock->nth.notify_ready = NULL;
ssize_t ret;
size_t have;
-#if DEBUG_CONNECTION
LOG (GNUNET_ERROR_TYPE_DEBUG, "transmit_ready running (%p).\n", sock);
-#endif
GNUNET_assert (sock->write_task != GNUNET_SCHEDULER_NO_TASK);
sock->write_task = GNUNET_SCHEDULER_NO_TASK;
GNUNET_assert (sock->nth.timeout_task == GNUNET_SCHEDULER_NO_TASK);
{
if ((sock->ignore_shutdown == GNUNET_YES) && (NULL != sock->sock))
goto SCHEDULE_WRITE; /* ignore shutdown, go again immediately */
-#if DEBUG_CONNECTION
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Transmit to `%s' fails, shutdown happened (%p).\n",
GNUNET_a2s (sock->addr, sock->addrlen), sock);
-#endif
notify = sock->nth.notify_ready;
if (NULL != notify)
{
}
if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_TIMEOUT))
{
-#if DEBUG_CONNECTION
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Transmit to `%s' fails, time out reached (%p).\n",
GNUNET_a2s (sock->addr, sock->addrlen), sock);
-#endif
notify = sock->nth.notify_ready;
GNUNET_assert (NULL != notify);
sock->nth.notify_ready = NULL;
}
if (!GNUNET_NETWORK_fdset_isset (tc->write_ready, sock->sock))
{
-#if DEBUG_CONNECTION
LOG (GNUNET_ERROR_TYPE_INFO,
_
("Could not satisfy pending transmission request, socket closed or connect failed (%p).\n"),
sock);
-#endif
transmit_error (sock);
return; /* connect failed for good, we're finished */
}
{
if (errno == EINTR)
goto RETRY;
-#if 0
- int en = errno;
-
- LOG (GNUNET_ERROR_TYPE_ERROR, _("Failed to send to `%s': %s\n"),
- GNUNET_a2s (sock->addr, sock->addrlen), STRERROR (en));
-#endif
-#if DEBUG_CONNECTION
LOG_STRERROR (GNUNET_ERROR_TYPE_DEBUG, "send");
-#endif
transmit_error (sock);
return;
}
-#if DEBUG_CONNECTION
LOG (GNUNET_ERROR_TYPE_DEBUG,
"transmit_ready transmitted %u/%u bytes to `%s' (%p)\n",
(unsigned int) ret, have, GNUNET_a2s (sock->addr, sock->addrlen), sock);
-#endif
sock->write_buffer_pos += ret;
if (sock->write_buffer_pos == sock->write_buffer_off)
{
return; /* all data sent! */
/* not done writing, schedule more */
SCHEDULE_WRITE:
-#if DEBUG_CONNECTION
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Re-scheduling transmit_ready (more to do) (%p).\n", sock);
-#endif
have = sock->write_buffer_off - sock->write_buffer_pos;
GNUNET_assert ((sock->nth.notify_ready != NULL) || (have > 0));
if (sock->write_task == GNUNET_SCHEDULER_NO_TASK)
return &sock->nth;
if (sock->sock != NULL)
{
-#if DEBUG_CONNECTION
LOG (GNUNET_ERROR_TYPE_DEBUG, "Scheduling transmit_ready (%p).\n", sock);
-#endif
sock->write_task =
GNUNET_SCHEDULER_add_write_net (GNUNET_TIME_absolute_get_remaining
(sock->nth.transmit_timeout),
}
else
{
-#if DEBUG_CONNECTION
LOG (GNUNET_ERROR_TYPE_DEBUG,
"CCS-Scheduling transmit_ready, adding timeout task (%p).\n", sock);
-#endif
sock->ccs |= COCO_TRANSMIT_READY;
sock->nth.timeout_task =
GNUNET_SCHEDULER_add_delayed (timeout, &transmit_timeout, sock);
GNUNET_assert (th->notify_ready != NULL);
if (0 != (th->sh->ccs & COCO_TRANSMIT_READY))
{
-#if DEBUG_CONNECTION
LOG (GNUNET_ERROR_TYPE_DEBUG,
"notify_transmit_ready_cancel cancels timeout_task (%p)\n", th);
-#endif
GNUNET_SCHEDULER_cancel (th->timeout_task);
th->timeout_task = GNUNET_SCHEDULER_NO_TASK;
th->sh->ccs -= COCO_TRANSMIT_READY;
#define DEBUG_NETWORK GNUNET_EXTRA_LOGGING
-#define DEBUG_W32_CYCLES GNUNET_EXTRA_LOGGING
#ifndef INVALID_SOCKET
#define INVALID_SOCKET -1
{
#ifndef MINGW
int fd;
-
#else
SOCKET fd;
#endif
#ifdef MINGW
DWORD error = 0;
-#if DEBUG_NETWORK
- LOG (GNUNET_ERROR_TYPE_DEBUG, "Closing 0x%x\n",
- desc->fd);
-#endif
SetLastError (0);
ret = closesocket (desc->fd);
error = WSAGetLastError ();
SetErrnoFromWinsockError (error);
-#if DEBUG_NETWORK
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Closed 0x%x, closesocket() returned %d, GLE is %u\n", desc->fd, ret,
error);
-#endif
#else
ret = close (desc->fd);
#endif
if (fh->type == GNUNET_PIPE)
{
/* Read zero bytes to check the status of the pipe */
-#if DEBUG_NETWORK
LOG (GNUNET_ERROR_TYPE_DEBUG, "Reading 0 bytes from the pipe 0x%x\n",
fh->h);
-#endif
if (!ReadFile (fh->h, NULL, 0, NULL, fh->oOverlapRead))
{
DWORD error_code = GetLastError ();
if (error_code == ERROR_IO_PENDING)
{
-#if DEBUG_NETWORK
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Adding the pipe's 0x%x overlapped event to the array as %d\n",
fh->h, nhandles);
-#endif
handle_array[nhandles++] = fh->oOverlapRead->hEvent;
readArray[readPipes++] = fh;
}
else
{
-#if DEBUG_NETWORK
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Read failed, adding the read ready event to the array as %d\n", nhandles);
-#endif
handle_array[nhandles++] = hEventReadReady;
readArray[readPipes++] = fh;
}
}
else
{
-#if DEBUG_NETWORK
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Adding the read ready event to the array as %d\n", nhandles);
-#endif
handle_array[nhandles++] = hEventReadReady;
readArray[readPipes++] = fh;
}
}
if (wfds && write_handles)
{
-#if DEBUG_NETWORK
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Adding the write ready event to the array as %d\n", nhandles);
-#endif
handle_array[nhandles++] = hEventPipeWrite;
writePipePos = nhandles;
}
{
if (rfds)
{
-#if DEBUG_NETWORK
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Adding the socket read event to the array as %d\n", nhandles);
-#endif
handle_array[nhandles++] = hEventRead;
nSockEvents++;
for (i = 0; i < rfds->sds.fd_count; i++)
{
int wakeup = 0;
-#if DEBUG_NETWORK
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Adding the socket write event to the array as %d\n", nhandles);
-#endif
handle_array[nhandles++] = hEventWrite;
nSockEvents++;
for (i = 0; i < wfds->sds.fd_count; i++)
status = send (wfds->sds.fd_array[i], NULL, 0, 0);
error = GetLastError ();
-#if DEBUG_NETWORK
LOG (GNUNET_ERROR_TYPE_DEBUG,
"pre-send to the socket %d returned %d (%u)\n", i, status, error);
-#endif
if (status == 0 || (error != WSAEWOULDBLOCK && error != WSAENOTCONN))
wakeup = 1;
WSAEventSelect (wfds->sds.fd_array[i], hEventWrite,
}
if (efds)
{
-#if DEBUG_NETWORK
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Adding the socket error event to the array as %d\n", nhandles);
-#endif
handle_array[nhandles++] = hEventException;
nSockEvents++;
for (i = 0; i < efds->sds.fd_count; i++)
#endif
returnedpos = returncode - WAIT_OBJECT_0;
-#if DEBUG_NETWORK
LOG (GNUNET_ERROR_TYPE_DEBUG, "return pos is : %d\n", returnedpos);
-#endif
/* FIXME: THIS LINE IS WRONG !! We should add to handles only handles that fired the events, not all ! */
/*
retcode = select (nfds, &aread, &awrite, &aexcept, &tvslice);
if (retcode == -1)
retcode = 0;
-#if DEBUG_NETWORK
LOG (GNUNET_ERROR_TYPE_DEBUG, "Select retcode : %d\n", retcode);
-#endif
}
/* FIXME: <= writePipePos? Really? */
if ((writePipePos != -1) && (returnedpos <= writePipePos))
{
GNUNET_CONTAINER_slist_append (handles_write, wfds->handles);
retcode += write_handles;
-#if DEBUG_NETWORK
LOG (GNUNET_ERROR_TYPE_DEBUG, "Added write pipe\n");
-#endif
}
-#if DEBUG_NETWORK
LOG (GNUNET_ERROR_TYPE_DEBUG, "ReadPipes is : %d\n", readPipes);
-#endif
/* We have some pipes ready for read. */
/* FIXME: it is supposed to work !! Only choose the Pipes who fired the event, but it is not working */
bret =
PeekNamedPipe (readArray[i]->h, NULL, 0, NULL, &waitstatus, NULL);
error = GetLastError ();
-#if DEBUG_NETWORK
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Peek at read pipe %d (0x%x) returned %d (%d bytes available) GLE %u\n",
i, readArray[i]->h, bret, waitstatus, error);
-#endif
if (bret == 0)
{
if (error != ERROR_BROKEN_PIPE)
readArray[i],
sizeof (struct GNUNET_DISK_FileHandle));
retcode++;
-#if DEBUG_NETWORK
LOG (GNUNET_ERROR_TYPE_DEBUG, "Added read Pipe 0x%x (0x%x)\n",
readArray[i], readArray[i]->h);
-#endif
}
}
waitstatus = WaitForSingleObject (hEventWrite, 0);
-#if DEBUG_NETWORK
LOG (GNUNET_ERROR_TYPE_DEBUG, "Wait for the write event returned %d\n",
waitstatus);
-#endif
if (waitstatus == WAIT_OBJECT_0)
{
for (i = 0; i < wfds->sds.fd_count; i++)
status = send (wfds->sds.fd_array[i], NULL, 0, 0);
error = GetLastError ();
-#if DEBUG_NETWORK
LOG (GNUNET_ERROR_TYPE_DEBUG,
"send to the socket %d returned %d (%u)\n", i, status, error);
-#endif
if (status == 0 || (error != WSAEWOULDBLOCK && error != WSAENOTCONN) ||
(status == -1 && gso_result == 0 && error == WSAENOTCONN &&
so_error == WSAECONNREFUSED))
CancelIo (fh->h);
}
}
-#if DEBUG_NETWORK
LOG (GNUNET_ERROR_TYPE_DEBUG, "Zeroing rfds\n");
-#endif
GNUNET_NETWORK_fdset_zero (rfds);
if (retcode != -1 && nhandles && (returnedpos < nhandles))
GNUNET_NETWORK_fdset_copy_native (rfds, &aread, retcode);
WSAEventSelect (wfds->sds.fd_array[i], hEventWrite, 0);
nsock++;
}
-#if DEBUG_NETWORK
LOG (GNUNET_ERROR_TYPE_DEBUG, "Zeroing wfds\n");
-#endif
GNUNET_NETWORK_fdset_zero (wfds);
if (retcode != -1 && nhandles && (returnedpos < nhandles))
GNUNET_NETWORK_fdset_copy_native (wfds, &awrite, retcode);
WSAEventSelect (efds->sds.fd_array[i], hEventException, 0);
nsock++;
}
-#if DEBUG_NETWORK
LOG (GNUNET_ERROR_TYPE_DEBUG, "Zeroing efds\n");
-#endif
GNUNET_NETWORK_fdset_zero (efds);
if (retcode != -1 && nhandles && (returnedpos < nhandles))
GNUNET_NETWORK_fdset_copy_native (efds, &aexcept, retcode);
#include "gnunet_signal_lib.h"
#include "gnunet_time_lib.h"
#include "disk.h"
-#define LOG(kind,...) GNUNET_log_from (kind, "util", __VA_ARGS__)
-#define LOG_STRERROR(kind,syscall) GNUNET_log_from_strerror (kind, "util", syscall)
-#ifdef LINUX
-#include "execinfo.h"
+#define LOG(kind,...) GNUNET_log_from (kind, "util-scheduler", __VA_ARGS__)
+#define LOG_STRERROR(kind,syscall) GNUNET_log_from_strerror (kind, "util-scheduler", syscall)
+#ifdef LINUX
+#include "execinfo.h"
+
/**
* Use lsof to generate file descriptor reports on select error?
* (turn off for stable releases).
/**
* Check each file descriptor before adding
*/
-#define DEBUG_FDS GNUNET_EXTRA_LOGGING
+#define DEBUG_FDS GNUNET_NO
/**
* Depth of the traces collected via EXECINFO.
#define MAX_TRACE_DEPTH 50
#endif
-#define DEBUG_TASKS GNUNET_EXTRA_LOGGING
-
/**
* Should we figure out which tasks are delayed for a while
* before they are run? (Consider using in combination with EXECINFO).
*/
#define DELAY_THRESHOLD GNUNET_TIME_UNIT_SECONDS
+
/**
* Linked list of pending tasks.
*/
pos = pending;
while (pos != NULL)
{
-#if DEBUG_TASKS
- LOG (GNUNET_ERROR_TYPE_DEBUG, "Checking readiness of task: %llu / %p\n",
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "Checking readiness of task: %llu / %p\n",
pos->id, pos->callback_cls);
-#endif
next = pos->next;
if (GNUNET_YES == is_ready (pos, now, rs, ws))
{
(pos->write_fd != -1) &&
(!GNUNET_NETWORK_fdset_test_native (ws, pos->write_fd)))
GNUNET_abort (); // added to ready in previous select loop!
-#if DEBUG_TASKS
- LOG (GNUNET_ERROR_TYPE_DEBUG, "Running task: %llu / %p\n", pos->id,
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "Running task: %llu / %p\n", pos->id,
pos->callback_cls);
-#endif
pos->callback (pos->callback_cls, &tc);
#if EXECINFO
int i;
prev->next = t->next;
}
ret = t->callback_cls;
-#if DEBUG_TASKS
LOG (GNUNET_ERROR_TYPE_DEBUG, "Canceling task: %llu / %p\n", task,
t->callback_cls);
-#endif
destroy_task (t);
return ret;
}
t->reason = reason;
t->priority = priority;
t->lifeness = current_lifeness;
-#if DEBUG_TASKS
LOG (GNUNET_ERROR_TYPE_DEBUG, "Adding continuation task: %llu / %p\n", t->id,
t->callback_cls);
-#endif
queue_ready_task (t);
}
/* hyper-optimization... */
pending_timeout_last = t;
-#if DEBUG_TASKS
LOG (GNUNET_ERROR_TYPE_DEBUG, "Adding task: %llu / %p\n", t->id,
t->callback_cls);
-#endif
#if EXECINFO
int i;
t->next = pending;
pending = t;
max_priority_added = GNUNET_MAX (max_priority_added, t->priority);
-#if DEBUG_TASKS
LOG (GNUNET_ERROR_TYPE_DEBUG, "Adding task: %llu / %p\n", t->id,
t->callback_cls);
-#endif
#if EXECINFO
int i;
t->next = pending;
pending = t;
max_priority_added = GNUNET_MAX (max_priority_added, t->priority);
-#if DEBUG_TASKS
LOG (GNUNET_ERROR_TYPE_DEBUG, "Adding task: %llu / %p\n", t->id,
t->callback_cls);
-#endif
#if EXECINFO
int i;
projects / oweals / gnunet.git / commitdiff