sin/samba-mirror
1
0
Fork 0
mirror of https://github.com/samba-team/samba.git synced 2025-03-08 04:58:40 +03:00
Code
samba-mirror/source4/lib/events/events_standard.c

568 lines
14 KiB
C
Raw Normal View History

first public release of samba4 code (This used to be commit b0510b5428b3461aeb9bbe3cc95f62fc73e2b97f)
2003-08-13 01:53:07 +00:00
/*
Unix SMB/CIFS implementation.
main select loop and event handling
r5407: - this patch makes samba's event loop code more generic and makes using other implementations possible. This will be mostly usefull for client apps which have there own event loop and want to use our client libs - add a example plugin for liboop (see http://liboop.org) NOTE: this just compiles and is completly untested and is commited only as example metze (This used to be commit b3d0a410efe856e3bcf127f00c31905f5a23cc04)
2005-02-15 10:36:59 +00:00
Copyright (C) Andrew Tridgell 2003-2005
Copyright (C) Stefan Metzmacher 2005
first public release of samba4 code (This used to be commit b0510b5428b3461aeb9bbe3cc95f62fc73e2b97f)
2003-08-13 01:53:07 +00:00
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
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.
*/
/*
r5407: - this patch makes samba's event loop code more generic and makes using other implementations possible. This will be mostly usefull for client apps which have there own event loop and want to use our client libs - add a example plugin for liboop (see http://liboop.org) NOTE: this just compiles and is completly untested and is commited only as example metze (This used to be commit b3d0a410efe856e3bcf127f00c31905f5a23cc04)
2005-02-15 10:36:59 +00:00
This is SAMBA's default event loop code
first public release of samba4 code (This used to be commit b0510b5428b3461aeb9bbe3cc95f62fc73e2b97f)
2003-08-13 01:53:07 +00:00
r5407: - this patch makes samba's event loop code more generic and makes using other implementations possible. This will be mostly usefull for client apps which have there own event loop and want to use our client libs - add a example plugin for liboop (see http://liboop.org) NOTE: this just compiles and is completly untested and is commited only as example metze (This used to be commit b3d0a410efe856e3bcf127f00c31905f5a23cc04)
2005-02-15 10:36:59 +00:00
- we try to use epoll if configure detected support for it
otherwise we use select()
- if epoll is broken on the system or the kernel doesn't support it
at runtime we fallback to select()
first public release of samba4 code (This used to be commit b0510b5428b3461aeb9bbe3cc95f62fc73e2b97f)
2003-08-13 01:53:07 +00:00
*/
#include "includes.h"
r5298: - got rid of pstring.h from includes.h. This at least makes it a bit less likely that anyone will use pstring for new code - got rid of winbind_client.h from includes.h. This one triggered a huge change, as winbind_client.h was including system/filesys.h and defining the old uint32 and uint16 types, as well as its own pstring and fstring. (This used to be commit 9db6c79e902ec538108d6b7d3324039aabe1704f)
2005-02-10 05:09:35 +00:00
#include "system/filesys.h"
r3463: separated out some more headers (asn_1.h, messages.h, dlinklist.h and ioctl.h) (This used to be commit b97e395c814762024336c1cf4d7c25be8da5813a)
2004-11-02 06:42:15 +00:00
#include "dlinklist.h"
r5197: moved events code to lib/events/ (suggestion from metze) (This used to be commit 7f54c8a339f36aa43c9340be70ab7f0067593ef2)
2005-02-03 11:56:03 +00:00
#include "lib/events/events.h"
r5407: - this patch makes samba's event loop code more generic and makes using other implementations possible. This will be mostly usefull for client apps which have there own event loop and want to use our client libs - add a example plugin for liboop (see http://liboop.org) NOTE: this just compiles and is completly untested and is commited only as example metze (This used to be commit b3d0a410efe856e3bcf127f00c31905f5a23cc04)
2005-02-15 10:36:59 +00:00
#include "lib/events/events_internal.h"
first public release of samba4 code (This used to be commit b0510b5428b3461aeb9bbe3cc95f62fc73e2b97f)
2003-08-13 01:53:07 +00:00
r5194: added support for using epoll instead of select() on systems that have it. epoll is much more scalable than select(), but only exists on some systems (such as Linux with the 2.6.x kernel). The code detects any epoll system call failures at runtime and falls back to select() if there is a problem, so it should be safe to compile this on a 2.6 kernel and run it on a 2.4.x kernel. The speedup is quite large. It gains 20% in packet rate in the BENCH-NBT test, on top of another 20% gain from the better timer handling I added earlier. The really big gain will be when we are dealing with large numbers of file descriptors. With epoll we can handle hundreds of file descriptors all O(1), whereas with select it is O(n). (This used to be commit 26aa1aa69377e43da2942a42d137b95801e9fa1a)
2005-02-03 08:24:08 +00:00
/* use epoll if it is available */
#if defined(HAVE_EPOLL_CREATE) && defined(HAVE_SYS_EPOLL_H)
#define WITH_EPOLL 1
#endif
r5185: make all the events data structures private to events.c. This will make it possible to add optimisations to the events code such as keeping the next timed event in a sorted list, and using epoll for file descriptor events. I also removed the loop events code, as it wasn't being used anywhere, and changed timed events to always be one-shot (as adding a new timed event in the event handler is so easy to do if needed) (This used to be commit d7b4b6de51342a65bf46fce772d313f92f8d73d3)
2005-02-03 02:35:52 +00:00
r5194: added support for using epoll instead of select() on systems that have it. epoll is much more scalable than select(), but only exists on some systems (such as Linux with the 2.6.x kernel). The code detects any epoll system call failures at runtime and falls back to select() if there is a problem, so it should be safe to compile this on a 2.6 kernel and run it on a 2.4.x kernel. The speedup is quite large. It gains 20% in packet rate in the BENCH-NBT test, on top of another 20% gain from the better timer handling I added earlier. The really big gain will be when we are dealing with large numbers of file descriptors. With epoll we can handle hundreds of file descriptors all O(1), whereas with select it is O(n). (This used to be commit 26aa1aa69377e43da2942a42d137b95801e9fa1a)
2005-02-03 08:24:08 +00:00
#if WITH_EPOLL
#include <sys/epoll.h>
#endif
r5185: make all the events data structures private to events.c. This will make it possible to add optimisations to the events code such as keeping the next timed event in a sorted list, and using epoll for file descriptor events. I also removed the loop events code, as it wasn't being used anywhere, and changed timed events to always be one-shot (as adding a new timed event in the event handler is so easy to do if needed) (This used to be commit d7b4b6de51342a65bf46fce772d313f92f8d73d3)
2005-02-03 02:35:52 +00:00
r5407: - this patch makes samba's event loop code more generic and makes using other implementations possible. This will be mostly usefull for client apps which have there own event loop and want to use our client libs - add a example plugin for liboop (see http://liboop.org) NOTE: this just compiles and is completly untested and is commited only as example metze (This used to be commit b3d0a410efe856e3bcf127f00c31905f5a23cc04)
2005-02-15 10:36:59 +00:00
struct std_event_context {
r12141: - move epoll related code into one big #ifdef, and use dummy #define's for the case where, epoll isn't available at compile time - only pass the private std_event_context, to the local function, to get rid of the talloc_get_type() calls - use the private pointer to std_event_context_init() to decide if we want to disable epoll at runtime metze (This used to be commit de322ea8b761df5434e60879b7eae3796ea68007)
2005-12-09 17:30:14 +00:00
/* a pointer back to the generic event_context */
struct event_context *ev;
r5185: make all the events data structures private to events.c. This will make it possible to add optimisations to the events code such as keeping the next timed event in a sorted list, and using epoll for file descriptor events. I also removed the loop events code, as it wasn't being used anywhere, and changed timed events to always be one-shot (as adding a new timed event in the event handler is so easy to do if needed) (This used to be commit d7b4b6de51342a65bf46fce772d313f92f8d73d3)
2005-02-03 02:35:52 +00:00
/* list of filedescriptor events */
r5407: - this patch makes samba's event loop code more generic and makes using other implementations possible. This will be mostly usefull for client apps which have there own event loop and want to use our client libs - add a example plugin for liboop (see http://liboop.org) NOTE: this just compiles and is completly untested and is commited only as example metze (This used to be commit b3d0a410efe856e3bcf127f00c31905f5a23cc04)
2005-02-15 10:36:59 +00:00
struct fd_event *fd_events;
r5185: make all the events data structures private to events.c. This will make it possible to add optimisations to the events code such as keeping the next timed event in a sorted list, and using epoll for file descriptor events. I also removed the loop events code, as it wasn't being used anywhere, and changed timed events to always be one-shot (as adding a new timed event in the event handler is so easy to do if needed) (This used to be commit d7b4b6de51342a65bf46fce772d313f92f8d73d3)
2005-02-03 02:35:52 +00:00
/* list of timed events */
r5407: - this patch makes samba's event loop code more generic and makes using other implementations possible. This will be mostly usefull for client apps which have there own event loop and want to use our client libs - add a example plugin for liboop (see http://liboop.org) NOTE: this just compiles and is completly untested and is commited only as example metze (This used to be commit b3d0a410efe856e3bcf127f00c31905f5a23cc04)
2005-02-15 10:36:59 +00:00
struct timed_event *timed_events;
r5185: make all the events data structures private to events.c. This will make it possible to add optimisations to the events code such as keeping the next timed event in a sorted list, and using epoll for file descriptor events. I also removed the loop events code, as it wasn't being used anywhere, and changed timed events to always be one-shot (as adding a new timed event in the event handler is so easy to do if needed) (This used to be commit d7b4b6de51342a65bf46fce772d313f92f8d73d3)
2005-02-03 02:35:52 +00:00
/* the maximum file descriptor number in fd_events */
int maxfd;
/* information for exiting from the event loop */
int exit_code;
r5194: added support for using epoll instead of select() on systems that have it. epoll is much more scalable than select(), but only exists on some systems (such as Linux with the 2.6.x kernel). The code detects any epoll system call failures at runtime and falls back to select() if there is a problem, so it should be safe to compile this on a 2.6 kernel and run it on a 2.4.x kernel. The speedup is quite large. It gains 20% in packet rate in the BENCH-NBT test, on top of another 20% gain from the better timer handling I added earlier. The really big gain will be when we are dealing with large numbers of file descriptors. With epoll we can handle hundreds of file descriptors all O(1), whereas with select it is O(n). (This used to be commit 26aa1aa69377e43da2942a42d137b95801e9fa1a)
2005-02-03 08:24:08 +00:00
/* this is changed by the destructors for the fd event
type. It is used to detect event destruction by event
handlers, which means the code that is calling the event
handler needs to assume that the linked list is no longer
valid
r5185: make all the events data structures private to events.c. This will make it possible to add optimisations to the events code such as keeping the next timed event in a sorted list, and using epoll for file descriptor events. I also removed the loop events code, as it wasn't being used anywhere, and changed timed events to always be one-shot (as adding a new timed event in the event handler is so easy to do if needed) (This used to be commit d7b4b6de51342a65bf46fce772d313f92f8d73d3)
2005-02-03 02:35:52 +00:00
*/
uint32_t destruction_count;
r5194: added support for using epoll instead of select() on systems that have it. epoll is much more scalable than select(), but only exists on some systems (such as Linux with the 2.6.x kernel). The code detects any epoll system call failures at runtime and falls back to select() if there is a problem, so it should be safe to compile this on a 2.6 kernel and run it on a 2.4.x kernel. The speedup is quite large. It gains 20% in packet rate in the BENCH-NBT test, on top of another 20% gain from the better timer handling I added earlier. The really big gain will be when we are dealing with large numbers of file descriptors. With epoll we can handle hundreds of file descriptors all O(1), whereas with select it is O(n). (This used to be commit 26aa1aa69377e43da2942a42d137b95801e9fa1a)
2005-02-03 08:24:08 +00:00
/* when using epoll this is the handle from epoll_create */
int epoll_fd;
r5185: make all the events data structures private to events.c. This will make it possible to add optimisations to the events code such as keeping the next timed event in a sorted list, and using epoll for file descriptor events. I also removed the loop events code, as it wasn't being used anywhere, and changed timed events to always be one-shot (as adding a new timed event in the event handler is so easy to do if needed) (This used to be commit d7b4b6de51342a65bf46fce772d313f92f8d73d3)
2005-02-03 02:35:52 +00:00
};
r12141: - move epoll related code into one big #ifdef, and use dummy #define's for the case where, epoll isn't available at compile time - only pass the private std_event_context, to the local function, to get rid of the talloc_get_type() calls - use the private pointer to std_event_context_init() to decide if we want to disable epoll at runtime metze (This used to be commit de322ea8b761df5434e60879b7eae3796ea68007)
2005-12-09 17:30:14 +00:00
static void std_event_loop_timer(struct std_event_context *std_ev);
#if WITH_EPOLL
r5292: ensure we cleanup the epoll_fd on event context destruction (This used to be commit e820fca5062026810c5bd4827941f34c19a5e847)
2005-02-10 03:16:33 +00:00
/*
r12141: - move epoll related code into one big #ifdef, and use dummy #define's for the case where, epoll isn't available at compile time - only pass the private std_event_context, to the local function, to get rid of the talloc_get_type() calls - use the private pointer to std_event_context_init() to decide if we want to disable epoll at runtime metze (This used to be commit de322ea8b761df5434e60879b7eae3796ea68007)
2005-12-09 17:30:14 +00:00
called when a epoll call fails, and we should fallback
to using select
r5292: ensure we cleanup the epoll_fd on event context destruction (This used to be commit e820fca5062026810c5bd4827941f34c19a5e847)
2005-02-10 03:16:33 +00:00
*/
r12141: - move epoll related code into one big #ifdef, and use dummy #define's for the case where, epoll isn't available at compile time - only pass the private std_event_context, to the local function, to get rid of the talloc_get_type() calls - use the private pointer to std_event_context_init() to decide if we want to disable epoll at runtime metze (This used to be commit de322ea8b761df5434e60879b7eae3796ea68007)
2005-12-09 17:30:14 +00:00
static void epoll_fallback_to_select(struct std_event_context *std_ev, const char *reason)
r5292: ensure we cleanup the epoll_fd on event context destruction (This used to be commit e820fca5062026810c5bd4827941f34c19a5e847)
2005-02-10 03:16:33 +00:00
{
r12141: - move epoll related code into one big #ifdef, and use dummy #define's for the case where, epoll isn't available at compile time - only pass the private std_event_context, to the local function, to get rid of the talloc_get_type() calls - use the private pointer to std_event_context_init() to decide if we want to disable epoll at runtime metze (This used to be commit de322ea8b761df5434e60879b7eae3796ea68007)
2005-12-09 17:30:14 +00:00
DEBUG(0,("%s (%s) - falling back to select()\n", reason, strerror(errno)));
close(std_ev->epoll_fd);
std_ev->epoll_fd = -1;
talloc_set_destructor(std_ev, NULL);
}
/*
map from EVENT_FD_* to EPOLLIN/EPOLLOUT
*/
static uint32_t epoll_map_flags(uint16_t flags)
{
uint32_t ret = 0;
if (flags & EVENT_FD_READ) ret |= EPOLLIN;
if (flags & EVENT_FD_WRITE) ret |= EPOLLOUT;
return ret;
}
/*
free the epoll fd
*/
static int epoll_ctx_destructor(void *ptr)
{
struct std_event_context *std_ev = talloc_get_type(ptr,
r5407: - this patch makes samba's event loop code more generic and makes using other implementations possible. This will be mostly usefull for client apps which have there own event loop and want to use our client libs - add a example plugin for liboop (see http://liboop.org) NOTE: this just compiles and is completly untested and is commited only as example metze (This used to be commit b3d0a410efe856e3bcf127f00c31905f5a23cc04)
2005-02-15 10:36:59 +00:00
struct std_event_context);
r12141: - move epoll related code into one big #ifdef, and use dummy #define's for the case where, epoll isn't available at compile time - only pass the private std_event_context, to the local function, to get rid of the talloc_get_type() calls - use the private pointer to std_event_context_init() to decide if we want to disable epoll at runtime metze (This used to be commit de322ea8b761df5434e60879b7eae3796ea68007)
2005-12-09 17:30:14 +00:00
close(std_ev->epoll_fd);
std_ev->epoll_fd = -1;
return 0;
}
/*
init the epoll fd
*/
static void epoll_init_ctx(struct std_event_context *std_ev, BOOL try_epoll)
{
if (!try_epoll) return;
std_ev->epoll_fd = epoll_create(64);
talloc_set_destructor(std_ev, epoll_ctx_destructor);
}
/*
add the epoll event to the given fd_event
*/
static void epoll_add_event(struct std_event_context *std_ev, struct fd_event *fde)
{
struct epoll_event event;
if (std_ev->epoll_fd == -1) return;
ZERO_STRUCT(event);
event.events = epoll_map_flags(fde->flags);
event.data.ptr = fde;
if (epoll_ctl(std_ev->epoll_fd, EPOLL_CTL_ADD, fde->fd, &event) != 0) {
epoll_fallback_to_select(std_ev, "EPOLL_CTL_ADD failed");
r5292: ensure we cleanup the epoll_fd on event context destruction (This used to be commit e820fca5062026810c5bd4827941f34c19a5e847)
2005-02-10 03:16:33 +00:00
}
r12141: - move epoll related code into one big #ifdef, and use dummy #define's for the case where, epoll isn't available at compile time - only pass the private std_event_context, to the local function, to get rid of the talloc_get_type() calls - use the private pointer to std_event_context_init() to decide if we want to disable epoll at runtime metze (This used to be commit de322ea8b761df5434e60879b7eae3796ea68007)
2005-12-09 17:30:14 +00:00
}
/*
remove the epoll event for given fd_event
*/
static void epoll_remove_event(struct std_event_context *std_ev, struct fd_event *fde)
{
struct epoll_event event;
if (std_ev->epoll_fd == -1) return;
ZERO_STRUCT(event);
event.events = epoll_map_flags(fde->flags);
event.data.ptr = fde;
epoll_ctl(std_ev->epoll_fd, EPOLL_CTL_DEL, fde->fd, &event);
}
/*
change the epoll event to the given fd_event
*/
static void epoll_change_event(struct std_event_context *std_ev, struct fd_event *fde, uint16_t flags)
{
struct epoll_event event;
if (std_ev->epoll_fd == -1) return;
ZERO_STRUCT(event);
event.events = epoll_map_flags(flags);
event.data.ptr = fde;
if (epoll_ctl(std_ev->epoll_fd, EPOLL_CTL_MOD, fde->fd, &event) != 0) {
epoll_fallback_to_select(std_ev, "EPOLL_CTL_MOD failed");
}
}
/*
event loop handling using epoll
*/
static int epoll_event_loop(struct std_event_context *std_ev, struct timeval *tvalp)
{
int ret, i;
#define MAXEVENTS 8
struct epoll_event events[MAXEVENTS];
uint32_t destruction_count = std_ev->destruction_count;
int timeout = -1;
if (std_ev->epoll_fd == -1) return -1;
if (tvalp) {
/* it's better to trigger timed events a bit later than to early */
timeout = ((tvalp->tv_usec+999) / 1000) + (tvalp->tv_sec*1000);
}
ret = epoll_wait(std_ev->epoll_fd, events, MAXEVENTS, timeout);
if (ret == -1 && errno != EINTR) {
epoll_fallback_to_select(std_ev, "epoll_wait() failed");
return -1;
}
if (ret == 0 && tvalp) {
std_event_loop_timer(std_ev);
return 0;
}
for (i=0;i<ret;i++) {
struct fd_event *fde = talloc_get_type(events[i].data.ptr,
struct fd_event);
uint16_t flags = 0;
if (fde == NULL) {
epoll_fallback_to_select(std_ev, "epoll_wait() gave bad data");
return -1;
}
if (events[i].events & (EPOLLHUP|EPOLLERR)) flags |= EVENT_FD_READ;
if (events[i].events & EPOLLIN) flags |= EVENT_FD_READ;
if (events[i].events & EPOLLOUT) flags |= EVENT_FD_WRITE;
if (flags) {
fde->handler(std_ev->ev, fde, flags, fde->private_data);
if (destruction_count != std_ev->destruction_count) {
break;
}
}
}
r5292: ensure we cleanup the epoll_fd on event context destruction (This used to be commit e820fca5062026810c5bd4827941f34c19a5e847)
2005-02-10 03:16:33 +00:00
return 0;
}
r12141: - move epoll related code into one big #ifdef, and use dummy #define's for the case where, epoll isn't available at compile time - only pass the private std_event_context, to the local function, to get rid of the talloc_get_type() calls - use the private pointer to std_event_context_init() to decide if we want to disable epoll at runtime metze (This used to be commit de322ea8b761df5434e60879b7eae3796ea68007)
2005-12-09 17:30:14 +00:00
#else
#define epoll_init_ctx(std_ev,try_epoll) if (try_epoll) {/* fix unused variable warning*/}
#define epoll_add_event(std_ev,fde)
#define epoll_remove_event(std_ev,fde)
#define epoll_change_event(std_ev,fde,flags)
#define epoll_event_loop(std_ev,tvalp) (-1)
#endif
r5292: ensure we cleanup the epoll_fd on event context destruction (This used to be commit e820fca5062026810c5bd4827941f34c19a5e847)
2005-02-10 03:16:33 +00:00
first public release of samba4 code (This used to be commit b0510b5428b3461aeb9bbe3cc95f62fc73e2b97f)
2003-08-13 01:53:07 +00:00
/*
r5407: - this patch makes samba's event loop code more generic and makes using other implementations possible. This will be mostly usefull for client apps which have there own event loop and want to use our client libs - add a example plugin for liboop (see http://liboop.org) NOTE: this just compiles and is completly untested and is commited only as example metze (This used to be commit b3d0a410efe856e3bcf127f00c31905f5a23cc04)
2005-02-15 10:36:59 +00:00
create a std_event_context structure.
first public release of samba4 code (This used to be commit b0510b5428b3461aeb9bbe3cc95f62fc73e2b97f)
2003-08-13 01:53:07 +00:00
*/
r12141: - move epoll related code into one big #ifdef, and use dummy #define's for the case where, epoll isn't available at compile time - only pass the private std_event_context, to the local function, to get rid of the talloc_get_type() calls - use the private pointer to std_event_context_init() to decide if we want to disable epoll at runtime metze (This used to be commit de322ea8b761df5434e60879b7eae3796ea68007)
2005-12-09 17:30:14 +00:00
static int std_event_context_init(struct event_context *ev, void *private_data)
first public release of samba4 code (This used to be commit b0510b5428b3461aeb9bbe3cc95f62fc73e2b97f)
2003-08-13 01:53:07 +00:00
{
r5407: - this patch makes samba's event loop code more generic and makes using other implementations possible. This will be mostly usefull for client apps which have there own event loop and want to use our client libs - add a example plugin for liboop (see http://liboop.org) NOTE: this just compiles and is completly untested and is commited only as example metze (This used to be commit b3d0a410efe856e3bcf127f00c31905f5a23cc04)
2005-02-15 10:36:59 +00:00
struct std_event_context *std_ev;
r12141: - move epoll related code into one big #ifdef, and use dummy #define's for the case where, epoll isn't available at compile time - only pass the private std_event_context, to the local function, to get rid of the talloc_get_type() calls - use the private pointer to std_event_context_init() to decide if we want to disable epoll at runtime metze (This used to be commit de322ea8b761df5434e60879b7eae3796ea68007)
2005-12-09 17:30:14 +00:00
BOOL *_try_epoll = private_data;
BOOL try_epoll = (_try_epoll == NULL ? True : *_try_epoll);
first public release of samba4 code (This used to be commit b0510b5428b3461aeb9bbe3cc95f62fc73e2b97f)
2003-08-13 01:53:07 +00:00
r5407: - this patch makes samba's event loop code more generic and makes using other implementations possible. This will be mostly usefull for client apps which have there own event loop and want to use our client libs - add a example plugin for liboop (see http://liboop.org) NOTE: this just compiles and is completly untested and is commited only as example metze (This used to be commit b3d0a410efe856e3bcf127f00c31905f5a23cc04)
2005-02-15 10:36:59 +00:00
std_ev = talloc_zero(ev, struct std_event_context);
if (!std_ev) return -1;
r12141: - move epoll related code into one big #ifdef, and use dummy #define's for the case where, epoll isn't available at compile time - only pass the private std_event_context, to the local function, to get rid of the talloc_get_type() calls - use the private pointer to std_event_context_init() to decide if we want to disable epoll at runtime metze (This used to be commit de322ea8b761df5434e60879b7eae3796ea68007)
2005-12-09 17:30:14 +00:00
std_ev->ev = ev;
std_ev->epoll_fd = -1;
first public release of samba4 code (This used to be commit b0510b5428b3461aeb9bbe3cc95f62fc73e2b97f)
2003-08-13 01:53:07 +00:00
r12141: - move epoll related code into one big #ifdef, and use dummy #define's for the case where, epoll isn't available at compile time - only pass the private std_event_context, to the local function, to get rid of the talloc_get_type() calls - use the private pointer to std_event_context_init() to decide if we want to disable epoll at runtime metze (This used to be commit de322ea8b761df5434e60879b7eae3796ea68007)
2005-12-09 17:30:14 +00:00
epoll_init_ctx(std_ev, try_epoll);
r5194: added support for using epoll instead of select() on systems that have it. epoll is much more scalable than select(), but only exists on some systems (such as Linux with the 2.6.x kernel). The code detects any epoll system call failures at runtime and falls back to select() if there is a problem, so it should be safe to compile this on a 2.6 kernel and run it on a 2.4.x kernel. The speedup is quite large. It gains 20% in packet rate in the BENCH-NBT test, on top of another 20% gain from the better timer handling I added earlier. The really big gain will be when we are dealing with large numbers of file descriptors. With epoll we can handle hundreds of file descriptors all O(1), whereas with select it is O(n). (This used to be commit 26aa1aa69377e43da2942a42d137b95801e9fa1a)
2005-02-03 08:24:08 +00:00
r5407: - this patch makes samba's event loop code more generic and makes using other implementations possible. This will be mostly usefull for client apps which have there own event loop and want to use our client libs - add a example plugin for liboop (see http://liboop.org) NOTE: this just compiles and is completly untested and is commited only as example metze (This used to be commit b3d0a410efe856e3bcf127f00c31905f5a23cc04)
2005-02-15 10:36:59 +00:00
ev->additional_data = std_ev;
return 0;
}
r5194: added support for using epoll instead of select() on systems that have it. epoll is much more scalable than select(), but only exists on some systems (such as Linux with the 2.6.x kernel). The code detects any epoll system call failures at runtime and falls back to select() if there is a problem, so it should be safe to compile this on a 2.6 kernel and run it on a 2.4.x kernel. The speedup is quite large. It gains 20% in packet rate in the BENCH-NBT test, on top of another 20% gain from the better timer handling I added earlier. The really big gain will be when we are dealing with large numbers of file descriptors. With epoll we can handle hundreds of file descriptors all O(1), whereas with select it is O(n). (This used to be commit 26aa1aa69377e43da2942a42d137b95801e9fa1a)
2005-02-03 08:24:08 +00:00
first public release of samba4 code (This used to be commit b0510b5428b3461aeb9bbe3cc95f62fc73e2b97f)
2003-08-13 01:53:07 +00:00
/*
recalculate the maxfd
*/
r12141: - move epoll related code into one big #ifdef, and use dummy #define's for the case where, epoll isn't available at compile time - only pass the private std_event_context, to the local function, to get rid of the talloc_get_type() calls - use the private pointer to std_event_context_init() to decide if we want to disable epoll at runtime metze (This used to be commit de322ea8b761df5434e60879b7eae3796ea68007)
2005-12-09 17:30:14 +00:00
static void calc_maxfd(struct std_event_context *std_ev)
first public release of samba4 code (This used to be commit b0510b5428b3461aeb9bbe3cc95f62fc73e2b97f)
2003-08-13 01:53:07 +00:00
{
r5407: - this patch makes samba's event loop code more generic and makes using other implementations possible. This will be mostly usefull for client apps which have there own event loop and want to use our client libs - add a example plugin for liboop (see http://liboop.org) NOTE: this just compiles and is completly untested and is commited only as example metze (This used to be commit b3d0a410efe856e3bcf127f00c31905f5a23cc04)
2005-02-15 10:36:59 +00:00
struct fd_event *fde;
std_ev->maxfd = 0;
for (fde = std_ev->fd_events; fde; fde = fde->next) {
if (fde->fd > std_ev->maxfd) {
std_ev->maxfd = fde->fd;
first public release of samba4 code (This used to be commit b0510b5428b3461aeb9bbe3cc95f62fc73e2b97f)
2003-08-13 01:53:07 +00:00
}
}
}
r5194: added support for using epoll instead of select() on systems that have it. epoll is much more scalable than select(), but only exists on some systems (such as Linux with the 2.6.x kernel). The code detects any epoll system call failures at runtime and falls back to select() if there is a problem, so it should be safe to compile this on a 2.6 kernel and run it on a 2.4.x kernel. The speedup is quite large. It gains 20% in packet rate in the BENCH-NBT test, on top of another 20% gain from the better timer handling I added earlier. The really big gain will be when we are dealing with large numbers of file descriptors. With epoll we can handle hundreds of file descriptors all O(1), whereas with select it is O(n). (This used to be commit 26aa1aa69377e43da2942a42d137b95801e9fa1a)
2005-02-03 08:24:08 +00:00
r4943: Smplified the events handling code a lot. The first source of complexity was that events didn't automatically cleanup themselves. This was because the events code was written before we had talloc destructors, so you needed to call event_remove_XX() to clean the event out of the event lists from every piece of code that used events. I have now added automatic event destructors, which in turn allowed me to simplify a lot of the calling code. The 2nd source of complexity was caused by the ref_count, which was needed to cope with event handlers destroying events while handling them, which meant the linked lists became invalid, so the ref_count ws used to mark events for later destruction. The new system is much simpler. I now have a ev->destruction_count, which is incremented in all event destructors. The event dispatch code checks for changes to this and handles it. (This used to be commit a3c7417cfeab429ffb22d5546b205818f531a7b4)
2005-01-23 11:49:15 +00:00
/* to mark the ev->maxfd invalid
* this means we need to recalculate it
*/
#define EVENT_INVALID_MAXFD (-1)
r5194: added support for using epoll instead of select() on systems that have it. epoll is much more scalable than select(), but only exists on some systems (such as Linux with the 2.6.x kernel). The code detects any epoll system call failures at runtime and falls back to select() if there is a problem, so it should be safe to compile this on a 2.6 kernel and run it on a 2.4.x kernel. The speedup is quite large. It gains 20% in packet rate in the BENCH-NBT test, on top of another 20% gain from the better timer handling I added earlier. The really big gain will be when we are dealing with large numbers of file descriptors. With epoll we can handle hundreds of file descriptors all O(1), whereas with select it is O(n). (This used to be commit 26aa1aa69377e43da2942a42d137b95801e9fa1a)
2005-02-03 08:24:08 +00:00
/*
destroy an fd_event
*/
r5407: - this patch makes samba's event loop code more generic and makes using other implementations possible. This will be mostly usefull for client apps which have there own event loop and want to use our client libs - add a example plugin for liboop (see http://liboop.org) NOTE: this just compiles and is completly untested and is commited only as example metze (This used to be commit b3d0a410efe856e3bcf127f00c31905f5a23cc04)
2005-02-15 10:36:59 +00:00
static int std_event_fd_destructor(void *ptr)
r4943: Smplified the events handling code a lot. The first source of complexity was that events didn't automatically cleanup themselves. This was because the events code was written before we had talloc destructors, so you needed to call event_remove_XX() to clean the event out of the event lists from every piece of code that used events. I have now added automatic event destructors, which in turn allowed me to simplify a lot of the calling code. The 2nd source of complexity was caused by the ref_count, which was needed to cope with event handlers destroying events while handling them, which meant the linked lists became invalid, so the ref_count ws used to mark events for later destruction. The new system is much simpler. I now have a ev->destruction_count, which is incremented in all event destructors. The event dispatch code checks for changes to this and handles it. (This used to be commit a3c7417cfeab429ffb22d5546b205818f531a7b4)
2005-01-23 11:49:15 +00:00
{
struct fd_event *fde = talloc_get_type(ptr, struct fd_event);
r5194: added support for using epoll instead of select() on systems that have it. epoll is much more scalable than select(), but only exists on some systems (such as Linux with the 2.6.x kernel). The code detects any epoll system call failures at runtime and falls back to select() if there is a problem, so it should be safe to compile this on a 2.6 kernel and run it on a 2.4.x kernel. The speedup is quite large. It gains 20% in packet rate in the BENCH-NBT test, on top of another 20% gain from the better timer handling I added earlier. The really big gain will be when we are dealing with large numbers of file descriptors. With epoll we can handle hundreds of file descriptors all O(1), whereas with select it is O(n). (This used to be commit 26aa1aa69377e43da2942a42d137b95801e9fa1a)
2005-02-03 08:24:08 +00:00
struct event_context *ev = fde->event_ctx;
r5407: - this patch makes samba's event loop code more generic and makes using other implementations possible. This will be mostly usefull for client apps which have there own event loop and want to use our client libs - add a example plugin for liboop (see http://liboop.org) NOTE: this just compiles and is completly untested and is commited only as example metze (This used to be commit b3d0a410efe856e3bcf127f00c31905f5a23cc04)
2005-02-15 10:36:59 +00:00
struct std_event_context *std_ev = talloc_get_type(ev->additional_data,
struct std_event_context);
r5194: added support for using epoll instead of select() on systems that have it. epoll is much more scalable than select(), but only exists on some systems (such as Linux with the 2.6.x kernel). The code detects any epoll system call failures at runtime and falls back to select() if there is a problem, so it should be safe to compile this on a 2.6 kernel and run it on a 2.4.x kernel. The speedup is quite large. It gains 20% in packet rate in the BENCH-NBT test, on top of another 20% gain from the better timer handling I added earlier. The really big gain will be when we are dealing with large numbers of file descriptors. With epoll we can handle hundreds of file descriptors all O(1), whereas with select it is O(n). (This used to be commit 26aa1aa69377e43da2942a42d137b95801e9fa1a)
2005-02-03 08:24:08 +00:00
r5407: - this patch makes samba's event loop code more generic and makes using other implementations possible. This will be mostly usefull for client apps which have there own event loop and want to use our client libs - add a example plugin for liboop (see http://liboop.org) NOTE: this just compiles and is completly untested and is commited only as example metze (This used to be commit b3d0a410efe856e3bcf127f00c31905f5a23cc04)
2005-02-15 10:36:59 +00:00
if (std_ev->maxfd == fde->fd) {
std_ev->maxfd = EVENT_INVALID_MAXFD;
r4943: Smplified the events handling code a lot. The first source of complexity was that events didn't automatically cleanup themselves. This was because the events code was written before we had talloc destructors, so you needed to call event_remove_XX() to clean the event out of the event lists from every piece of code that used events. I have now added automatic event destructors, which in turn allowed me to simplify a lot of the calling code. The 2nd source of complexity was caused by the ref_count, which was needed to cope with event handlers destroying events while handling them, which meant the linked lists became invalid, so the ref_count ws used to mark events for later destruction. The new system is much simpler. I now have a ev->destruction_count, which is incremented in all event destructors. The event dispatch code checks for changes to this and handles it. (This used to be commit a3c7417cfeab429ffb22d5546b205818f531a7b4)
2005-01-23 11:49:15 +00:00
}
r12141: - move epoll related code into one big #ifdef, and use dummy #define's for the case where, epoll isn't available at compile time - only pass the private std_event_context, to the local function, to get rid of the talloc_get_type() calls - use the private pointer to std_event_context_init() to decide if we want to disable epoll at runtime metze (This used to be commit de322ea8b761df5434e60879b7eae3796ea68007)
2005-12-09 17:30:14 +00:00
r5407: - this patch makes samba's event loop code more generic and makes using other implementations possible. This will be mostly usefull for client apps which have there own event loop and want to use our client libs - add a example plugin for liboop (see http://liboop.org) NOTE: this just compiles and is completly untested and is commited only as example metze (This used to be commit b3d0a410efe856e3bcf127f00c31905f5a23cc04)
2005-02-15 10:36:59 +00:00
DLIST_REMOVE(std_ev->fd_events, fde);
std_ev->destruction_count++;
r12141: - move epoll related code into one big #ifdef, and use dummy #define's for the case where, epoll isn't available at compile time - only pass the private std_event_context, to the local function, to get rid of the talloc_get_type() calls - use the private pointer to std_event_context_init() to decide if we want to disable epoll at runtime metze (This used to be commit de322ea8b761df5434e60879b7eae3796ea68007)
2005-12-09 17:30:14 +00:00
epoll_remove_event(std_ev, fde);
r4943: Smplified the events handling code a lot. The first source of complexity was that events didn't automatically cleanup themselves. This was because the events code was written before we had talloc destructors, so you needed to call event_remove_XX() to clean the event out of the event lists from every piece of code that used events. I have now added automatic event destructors, which in turn allowed me to simplify a lot of the calling code. The 2nd source of complexity was caused by the ref_count, which was needed to cope with event handlers destroying events while handling them, which meant the linked lists became invalid, so the ref_count ws used to mark events for later destruction. The new system is much simpler. I now have a ev->destruction_count, which is incremented in all event destructors. The event dispatch code checks for changes to this and handles it. (This used to be commit a3c7417cfeab429ffb22d5546b205818f531a7b4)
2005-01-23 11:49:15 +00:00
return 0;
}
r1578: the first stage of the async client rewrite. Up to now the client code has had an async API, and operated asynchronously at the packet level, but was not truly async in that it assumed that it could always write to the socket and when a partial packet came in that it could block waiting for the rest of the packet. This change makes the SMB client library full async, by adding a separate outgoing packet queue, using non-blocking socket IO and having a input buffer that can fill asynchonously until the full packet has arrived. The main complexity was in dealing with the events structure when using the CIFS proxy backend. In that case the same events structure needs to be used in both the client library and the main smbd server, so that when the client library is waiting for a reply that the main server keeps processing packets. This required some changes in the events library code. Next step is to make the generated rpc client code use these new capabilities. (This used to be commit 96bf4da3edc4d64b0f58ef520269f3b385b8da02)
2004-07-23 06:40:49 +00:00
/*
add a fd based event
return NULL on failure (memory allocation error)
*/
r5407: - this patch makes samba's event loop code more generic and makes using other implementations possible. This will be mostly usefull for client apps which have there own event loop and want to use our client libs - add a example plugin for liboop (see http://liboop.org) NOTE: this just compiles and is completly untested and is commited only as example metze (This used to be commit b3d0a410efe856e3bcf127f00c31905f5a23cc04)
2005-02-15 10:36:59 +00:00
static struct fd_event *std_event_add_fd(struct event_context *ev, TALLOC_CTX *mem_ctx,
int fd, uint16_t flags,
event_fd_handler_t handler,
void *private_data)
r1578: the first stage of the async client rewrite. Up to now the client code has had an async API, and operated asynchronously at the packet level, but was not truly async in that it assumed that it could always write to the socket and when a partial packet came in that it could block waiting for the rest of the packet. This change makes the SMB client library full async, by adding a separate outgoing packet queue, using non-blocking socket IO and having a input buffer that can fill asynchonously until the full packet has arrived. The main complexity was in dealing with the events structure when using the CIFS proxy backend. In that case the same events structure needs to be used in both the client library and the main smbd server, so that when the client library is waiting for a reply that the main server keeps processing packets. This required some changes in the events library code. Next step is to make the generated rpc client code use these new capabilities. (This used to be commit 96bf4da3edc4d64b0f58ef520269f3b385b8da02)
2004-07-23 06:40:49 +00:00
{
r5407: - this patch makes samba's event loop code more generic and makes using other implementations possible. This will be mostly usefull for client apps which have there own event loop and want to use our client libs - add a example plugin for liboop (see http://liboop.org) NOTE: this just compiles and is completly untested and is commited only as example metze (This used to be commit b3d0a410efe856e3bcf127f00c31905f5a23cc04)
2005-02-15 10:36:59 +00:00
struct std_event_context *std_ev = talloc_get_type(ev->additional_data,
struct std_event_context);
struct fd_event *fde;
r5185: make all the events data structures private to events.c. This will make it possible to add optimisations to the events code such as keeping the next timed event in a sorted list, and using epoll for file descriptor events. I also removed the loop events code, as it wasn't being used anywhere, and changed timed events to always be one-shot (as adding a new timed event in the event handler is so easy to do if needed) (This used to be commit d7b4b6de51342a65bf46fce772d313f92f8d73d3)
2005-02-03 02:35:52 +00:00
r5407: - this patch makes samba's event loop code more generic and makes using other implementations possible. This will be mostly usefull for client apps which have there own event loop and want to use our client libs - add a example plugin for liboop (see http://liboop.org) NOTE: this just compiles and is completly untested and is commited only as example metze (This used to be commit b3d0a410efe856e3bcf127f00c31905f5a23cc04)
2005-02-15 10:36:59 +00:00
fde = talloc(mem_ctx?mem_ctx:ev, struct fd_event);
if (!fde) return NULL;
r5185: make all the events data structures private to events.c. This will make it possible to add optimisations to the events code such as keeping the next timed event in a sorted list, and using epoll for file descriptor events. I also removed the loop events code, as it wasn't being used anywhere, and changed timed events to always be one-shot (as adding a new timed event in the event handler is so easy to do if needed) (This used to be commit d7b4b6de51342a65bf46fce772d313f92f8d73d3)
2005-02-03 02:35:52 +00:00
r5407: - this patch makes samba's event loop code more generic and makes using other implementations possible. This will be mostly usefull for client apps which have there own event loop and want to use our client libs - add a example plugin for liboop (see http://liboop.org) NOTE: this just compiles and is completly untested and is commited only as example metze (This used to be commit b3d0a410efe856e3bcf127f00c31905f5a23cc04)
2005-02-15 10:36:59 +00:00
fde->event_ctx = ev;
fde->fd = fd;
fde->flags = flags;
fde->handler = handler;
fde->private_data = private_data;
r12140: - add an additional_flags field to the fd_event struct, so that the events backend can store private flags - add function to access the gtk event loop ops struct metze (This used to be commit a5cc0758a393f36a770cdd57e317214d03934c13)
2005-12-09 16:43:19 +00:00
fde->additional_flags = 0;
r5407: - this patch makes samba's event loop code more generic and makes using other implementations possible. This will be mostly usefull for client apps which have there own event loop and want to use our client libs - add a example plugin for liboop (see http://liboop.org) NOTE: this just compiles and is completly untested and is commited only as example metze (This used to be commit b3d0a410efe856e3bcf127f00c31905f5a23cc04)
2005-02-15 10:36:59 +00:00
fde->additional_data = NULL;
r5185: make all the events data structures private to events.c. This will make it possible to add optimisations to the events code such as keeping the next timed event in a sorted list, and using epoll for file descriptor events. I also removed the loop events code, as it wasn't being used anywhere, and changed timed events to always be one-shot (as adding a new timed event in the event handler is so easy to do if needed) (This used to be commit d7b4b6de51342a65bf46fce772d313f92f8d73d3)
2005-02-03 02:35:52 +00:00
r5407: - this patch makes samba's event loop code more generic and makes using other implementations possible. This will be mostly usefull for client apps which have there own event loop and want to use our client libs - add a example plugin for liboop (see http://liboop.org) NOTE: this just compiles and is completly untested and is commited only as example metze (This used to be commit b3d0a410efe856e3bcf127f00c31905f5a23cc04)
2005-02-15 10:36:59 +00:00
DLIST_ADD(std_ev->fd_events, fde);
if (fde->fd > std_ev->maxfd) {
std_ev->maxfd = fde->fd;
r4944: every event_add_*() caller was having to call talloc_steal() to take control of the event, so instead build that into the function. If you pass NULL as mem_ctx then it leaves it as a child of the events structure. (This used to be commit 7f981b9ed96f39027cbfd500f41e0c2be64cbb50)
2005-01-23 12:17:45 +00:00
}
r5407: - this patch makes samba's event loop code more generic and makes using other implementations possible. This will be mostly usefull for client apps which have there own event loop and want to use our client libs - add a example plugin for liboop (see http://liboop.org) NOTE: this just compiles and is completly untested and is commited only as example metze (This used to be commit b3d0a410efe856e3bcf127f00c31905f5a23cc04)
2005-02-15 10:36:59 +00:00
talloc_set_destructor(fde, std_event_fd_destructor);
r12141: - move epoll related code into one big #ifdef, and use dummy #define's for the case where, epoll isn't available at compile time - only pass the private std_event_context, to the local function, to get rid of the talloc_get_type() calls - use the private pointer to std_event_context_init() to decide if we want to disable epoll at runtime metze (This used to be commit de322ea8b761df5434e60879b7eae3796ea68007)
2005-12-09 17:30:14 +00:00
epoll_add_event(std_ev, fde);
r5194: added support for using epoll instead of select() on systems that have it. epoll is much more scalable than select(), but only exists on some systems (such as Linux with the 2.6.x kernel). The code detects any epoll system call failures at runtime and falls back to select() if there is a problem, so it should be safe to compile this on a 2.6 kernel and run it on a 2.4.x kernel. The speedup is quite large. It gains 20% in packet rate in the BENCH-NBT test, on top of another 20% gain from the better timer handling I added earlier. The really big gain will be when we are dealing with large numbers of file descriptors. With epoll we can handle hundreds of file descriptors all O(1), whereas with select it is O(n). (This used to be commit 26aa1aa69377e43da2942a42d137b95801e9fa1a)
2005-02-03 08:24:08 +00:00
r5407: - this patch makes samba's event loop code more generic and makes using other implementations possible. This will be mostly usefull for client apps which have there own event loop and want to use our client libs - add a example plugin for liboop (see http://liboop.org) NOTE: this just compiles and is completly untested and is commited only as example metze (This used to be commit b3d0a410efe856e3bcf127f00c31905f5a23cc04)
2005-02-15 10:36:59 +00:00
return fde;
r1578: the first stage of the async client rewrite. Up to now the client code has had an async API, and operated asynchronously at the packet level, but was not truly async in that it assumed that it could always write to the socket and when a partial packet came in that it could block waiting for the rest of the packet. This change makes the SMB client library full async, by adding a separate outgoing packet queue, using non-blocking socket IO and having a input buffer that can fill asynchonously until the full packet has arrived. The main complexity was in dealing with the events structure when using the CIFS proxy backend. In that case the same events structure needs to be used in both the client library and the main smbd server, so that when the client library is waiting for a reply that the main server keeps processing packets. This required some changes in the events library code. Next step is to make the generated rpc client code use these new capabilities. (This used to be commit 96bf4da3edc4d64b0f58ef520269f3b385b8da02)
2004-07-23 06:40:49 +00:00
}
r5185: make all the events data structures private to events.c. This will make it possible to add optimisations to the events code such as keeping the next timed event in a sorted list, and using epoll for file descriptor events. I also removed the loop events code, as it wasn't being used anywhere, and changed timed events to always be one-shot (as adding a new timed event in the event handler is so easy to do if needed) (This used to be commit d7b4b6de51342a65bf46fce772d313f92f8d73d3)
2005-02-03 02:35:52 +00:00
/*
return the fd event flags
*/
r5407: - this patch makes samba's event loop code more generic and makes using other implementations possible. This will be mostly usefull for client apps which have there own event loop and want to use our client libs - add a example plugin for liboop (see http://liboop.org) NOTE: this just compiles and is completly untested and is commited only as example metze (This used to be commit b3d0a410efe856e3bcf127f00c31905f5a23cc04)
2005-02-15 10:36:59 +00:00
static uint16_t std_event_get_fd_flags(struct fd_event *fde)
r4943: Smplified the events handling code a lot. The first source of complexity was that events didn't automatically cleanup themselves. This was because the events code was written before we had talloc destructors, so you needed to call event_remove_XX() to clean the event out of the event lists from every piece of code that used events. I have now added automatic event destructors, which in turn allowed me to simplify a lot of the calling code. The 2nd source of complexity was caused by the ref_count, which was needed to cope with event handlers destroying events while handling them, which meant the linked lists became invalid, so the ref_count ws used to mark events for later destruction. The new system is much simpler. I now have a ev->destruction_count, which is incremented in all event destructors. The event dispatch code checks for changes to this and handles it. (This used to be commit a3c7417cfeab429ffb22d5546b205818f531a7b4)
2005-01-23 11:49:15 +00:00
{
r12123: handle fde == NULL at the correct level metze (This used to be commit 1dd5bb60a5047b94034eb084473bb8f4a9926e7c)
2005-12-08 08:31:59 +00:00
return fde->flags;
r4943: Smplified the events handling code a lot. The first source of complexity was that events didn't automatically cleanup themselves. This was because the events code was written before we had talloc destructors, so you needed to call event_remove_XX() to clean the event out of the event lists from every piece of code that used events. I have now added automatic event destructors, which in turn allowed me to simplify a lot of the calling code. The 2nd source of complexity was caused by the ref_count, which was needed to cope with event handlers destroying events while handling them, which meant the linked lists became invalid, so the ref_count ws used to mark events for later destruction. The new system is much simpler. I now have a ev->destruction_count, which is incremented in all event destructors. The event dispatch code checks for changes to this and handles it. (This used to be commit a3c7417cfeab429ffb22d5546b205818f531a7b4)
2005-01-23 11:49:15 +00:00
}
first public release of samba4 code (This used to be commit b0510b5428b3461aeb9bbe3cc95f62fc73e2b97f)
2003-08-13 01:53:07 +00:00
/*
r5185: make all the events data structures private to events.c. This will make it possible to add optimisations to the events code such as keeping the next timed event in a sorted list, and using epoll for file descriptor events. I also removed the loop events code, as it wasn't being used anywhere, and changed timed events to always be one-shot (as adding a new timed event in the event handler is so easy to do if needed) (This used to be commit d7b4b6de51342a65bf46fce772d313f92f8d73d3)
2005-02-03 02:35:52 +00:00
set the fd event flags
first public release of samba4 code (This used to be commit b0510b5428b3461aeb9bbe3cc95f62fc73e2b97f)
2003-08-13 01:53:07 +00:00
*/
r5407: - this patch makes samba's event loop code more generic and makes using other implementations possible. This will be mostly usefull for client apps which have there own event loop and want to use our client libs - add a example plugin for liboop (see http://liboop.org) NOTE: this just compiles and is completly untested and is commited only as example metze (This used to be commit b3d0a410efe856e3bcf127f00c31905f5a23cc04)
2005-02-15 10:36:59 +00:00
static void std_event_set_fd_flags(struct fd_event *fde, uint16_t flags)
first public release of samba4 code (This used to be commit b0510b5428b3461aeb9bbe3cc95f62fc73e2b97f)
2003-08-13 01:53:07 +00:00
{
r5194: added support for using epoll instead of select() on systems that have it. epoll is much more scalable than select(), but only exists on some systems (such as Linux with the 2.6.x kernel). The code detects any epoll system call failures at runtime and falls back to select() if there is a problem, so it should be safe to compile this on a 2.6 kernel and run it on a 2.4.x kernel. The speedup is quite large. It gains 20% in packet rate in the BENCH-NBT test, on top of another 20% gain from the better timer handling I added earlier. The really big gain will be when we are dealing with large numbers of file descriptors. With epoll we can handle hundreds of file descriptors all O(1), whereas with select it is O(n). (This used to be commit 26aa1aa69377e43da2942a42d137b95801e9fa1a)
2005-02-03 08:24:08 +00:00
struct event_context *ev;
r5407: - this patch makes samba's event loop code more generic and makes using other implementations possible. This will be mostly usefull for client apps which have there own event loop and want to use our client libs - add a example plugin for liboop (see http://liboop.org) NOTE: this just compiles and is completly untested and is commited only as example metze (This used to be commit b3d0a410efe856e3bcf127f00c31905f5a23cc04)
2005-02-15 10:36:59 +00:00
struct std_event_context *std_ev;
r12141: - move epoll related code into one big #ifdef, and use dummy #define's for the case where, epoll isn't available at compile time - only pass the private std_event_context, to the local function, to get rid of the talloc_get_type() calls - use the private pointer to std_event_context_init() to decide if we want to disable epoll at runtime metze (This used to be commit de322ea8b761df5434e60879b7eae3796ea68007)
2005-12-09 17:30:14 +00:00
if (fde->flags == flags) return;
r5194: added support for using epoll instead of select() on systems that have it. epoll is much more scalable than select(), but only exists on some systems (such as Linux with the 2.6.x kernel). The code detects any epoll system call failures at runtime and falls back to select() if there is a problem, so it should be safe to compile this on a 2.6 kernel and run it on a 2.4.x kernel. The speedup is quite large. It gains 20% in packet rate in the BENCH-NBT test, on top of another 20% gain from the better timer handling I added earlier. The really big gain will be when we are dealing with large numbers of file descriptors. With epoll we can handle hundreds of file descriptors all O(1), whereas with select it is O(n). (This used to be commit 26aa1aa69377e43da2942a42d137b95801e9fa1a)
2005-02-03 08:24:08 +00:00
ev = fde->event_ctx;
r5407: - this patch makes samba's event loop code more generic and makes using other implementations possible. This will be mostly usefull for client apps which have there own event loop and want to use our client libs - add a example plugin for liboop (see http://liboop.org) NOTE: this just compiles and is completly untested and is commited only as example metze (This used to be commit b3d0a410efe856e3bcf127f00c31905f5a23cc04)
2005-02-15 10:36:59 +00:00
std_ev = talloc_get_type(ev->additional_data, struct std_event_context);
r12141: - move epoll related code into one big #ifdef, and use dummy #define's for the case where, epoll isn't available at compile time - only pass the private std_event_context, to the local function, to get rid of the talloc_get_type() calls - use the private pointer to std_event_context_init() to decide if we want to disable epoll at runtime metze (This used to be commit de322ea8b761df5434e60879b7eae3796ea68007)
2005-12-09 17:30:14 +00:00
epoll_change_event(std_ev, fde, flags);
r12123: handle fde == NULL at the correct level metze (This used to be commit 1dd5bb60a5047b94034eb084473bb8f4a9926e7c)
2005-12-08 08:31:59 +00:00
fde->flags = flags;
first public release of samba4 code (This used to be commit b0510b5428b3461aeb9bbe3cc95f62fc73e2b97f)
2003-08-13 01:53:07 +00:00
}
r5185: make all the events data structures private to events.c. This will make it possible to add optimisations to the events code such as keeping the next timed event in a sorted list, and using epoll for file descriptor events. I also removed the loop events code, as it wasn't being used anywhere, and changed timed events to always be one-shot (as adding a new timed event in the event handler is so easy to do if needed) (This used to be commit d7b4b6de51342a65bf46fce772d313f92f8d73d3)
2005-02-03 02:35:52 +00:00
/*
destroy a timed event
*/
r5407: - this patch makes samba's event loop code more generic and makes using other implementations possible. This will be mostly usefull for client apps which have there own event loop and want to use our client libs - add a example plugin for liboop (see http://liboop.org) NOTE: this just compiles and is completly untested and is commited only as example metze (This used to be commit b3d0a410efe856e3bcf127f00c31905f5a23cc04)
2005-02-15 10:36:59 +00:00
static int std_event_timed_destructor(void *ptr)
r4943: Smplified the events handling code a lot. The first source of complexity was that events didn't automatically cleanup themselves. This was because the events code was written before we had talloc destructors, so you needed to call event_remove_XX() to clean the event out of the event lists from every piece of code that used events. I have now added automatic event destructors, which in turn allowed me to simplify a lot of the calling code. The 2nd source of complexity was caused by the ref_count, which was needed to cope with event handlers destroying events while handling them, which meant the linked lists became invalid, so the ref_count ws used to mark events for later destruction. The new system is much simpler. I now have a ev->destruction_count, which is incremented in all event destructors. The event dispatch code checks for changes to this and handles it. (This used to be commit a3c7417cfeab429ffb22d5546b205818f531a7b4)
2005-01-23 11:49:15 +00:00
{
r5185: make all the events data structures private to events.c. This will make it possible to add optimisations to the events code such as keeping the next timed event in a sorted list, and using epoll for file descriptor events. I also removed the loop events code, as it wasn't being used anywhere, and changed timed events to always be one-shot (as adding a new timed event in the event handler is so easy to do if needed) (This used to be commit d7b4b6de51342a65bf46fce772d313f92f8d73d3)
2005-02-03 02:35:52 +00:00
struct timed_event *te = talloc_get_type(ptr, struct timed_event);
r5407: - this patch makes samba's event loop code more generic and makes using other implementations possible. This will be mostly usefull for client apps which have there own event loop and want to use our client libs - add a example plugin for liboop (see http://liboop.org) NOTE: this just compiles and is completly untested and is commited only as example metze (This used to be commit b3d0a410efe856e3bcf127f00c31905f5a23cc04)
2005-02-15 10:36:59 +00:00
struct std_event_context *std_ev = talloc_get_type(te->event_ctx->additional_data,
struct std_event_context);
DLIST_REMOVE(std_ev->timed_events, te);
r4943: Smplified the events handling code a lot. The first source of complexity was that events didn't automatically cleanup themselves. This was because the events code was written before we had talloc destructors, so you needed to call event_remove_XX() to clean the event out of the event lists from every piece of code that used events. I have now added automatic event destructors, which in turn allowed me to simplify a lot of the calling code. The 2nd source of complexity was caused by the ref_count, which was needed to cope with event handlers destroying events while handling them, which meant the linked lists became invalid, so the ref_count ws used to mark events for later destruction. The new system is much simpler. I now have a ev->destruction_count, which is incremented in all event destructors. The event dispatch code checks for changes to this and handles it. (This used to be commit a3c7417cfeab429ffb22d5546b205818f531a7b4)
2005-01-23 11:49:15 +00:00
return 0;
first public release of samba4 code (This used to be commit b0510b5428b3461aeb9bbe3cc95f62fc73e2b97f)
2003-08-13 01:53:07 +00:00
}
r10537: - we now use a much nicer way to handle talloc_free(timed_event) the events code replaces a destructor to one that returns allways -1 while it's calling the event handler - we don't need the composite and winsrepl specific fixes any more - this also fixes the problem with smbcli, dcerpc, cldap, ldap and nbt request timeouts metze (This used to be commit 495996cfc49a1c6eefde6ff04fc75e0739be3aab)
2005-09-27 12:54:08 +00:00
static int std_event_timed_deny_destructor(void *ptr)
{
return -1;
}
first public release of samba4 code (This used to be commit b0510b5428b3461aeb9bbe3cc95f62fc73e2b97f)
2003-08-13 01:53:07 +00:00
/*
r5185: make all the events data structures private to events.c. This will make it possible to add optimisations to the events code such as keeping the next timed event in a sorted list, and using epoll for file descriptor events. I also removed the loop events code, as it wasn't being used anywhere, and changed timed events to always be one-shot (as adding a new timed event in the event handler is so easy to do if needed) (This used to be commit d7b4b6de51342a65bf46fce772d313f92f8d73d3)
2005-02-03 02:35:52 +00:00
add a timed event
let the event_add_XXX() function return a pointer of the allocated event structure and NULL on allacation error. metze (This used to be commit fffc6cfb6b9946155d209dd14faa79c5b9d43d1d)
2004-01-21 23:19:59 +00:00
return NULL on failure (memory allocation error)
first public release of samba4 code (This used to be commit b0510b5428b3461aeb9bbe3cc95f62fc73e2b97f)
2003-08-13 01:53:07 +00:00
*/
r5407: - this patch makes samba's event loop code more generic and makes using other implementations possible. This will be mostly usefull for client apps which have there own event loop and want to use our client libs - add a example plugin for liboop (see http://liboop.org) NOTE: this just compiles and is completly untested and is commited only as example metze (This used to be commit b3d0a410efe856e3bcf127f00c31905f5a23cc04)
2005-02-15 10:36:59 +00:00
static struct timed_event *std_event_add_timed(struct event_context *ev, TALLOC_CTX *mem_ctx,
struct timeval next_event,
event_timed_handler_t handler,
void *private_data)
first public release of samba4 code (This used to be commit b0510b5428b3461aeb9bbe3cc95f62fc73e2b97f)
2003-08-13 01:53:07 +00:00
{
r5407: - this patch makes samba's event loop code more generic and makes using other implementations possible. This will be mostly usefull for client apps which have there own event loop and want to use our client libs - add a example plugin for liboop (see http://liboop.org) NOTE: this just compiles and is completly untested and is commited only as example metze (This used to be commit b3d0a410efe856e3bcf127f00c31905f5a23cc04)
2005-02-15 10:36:59 +00:00
struct std_event_context *std_ev = talloc_get_type(ev->additional_data,
struct std_event_context);
struct timed_event *te, *last_te, *cur_te;
r5187: ordered the timed events in the events code, which makes processing events much more efficient (no linked lists need to be traversed, so large numbers of timers are no problem) (This used to be commit b45b9436d78b0ad288b27a1023579bb566ca6202)
2005-02-03 04:02:48 +00:00
r5407: - this patch makes samba's event loop code more generic and makes using other implementations possible. This will be mostly usefull for client apps which have there own event loop and want to use our client libs - add a example plugin for liboop (see http://liboop.org) NOTE: this just compiles and is completly untested and is commited only as example metze (This used to be commit b3d0a410efe856e3bcf127f00c31905f5a23cc04)
2005-02-15 10:36:59 +00:00
te = talloc(mem_ctx?mem_ctx:ev, struct timed_event);
if (te == NULL) return NULL;
r5185: make all the events data structures private to events.c. This will make it possible to add optimisations to the events code such as keeping the next timed event in a sorted list, and using epoll for file descriptor events. I also removed the loop events code, as it wasn't being used anywhere, and changed timed events to always be one-shot (as adding a new timed event in the event handler is so easy to do if needed) (This used to be commit d7b4b6de51342a65bf46fce772d313f92f8d73d3)
2005-02-03 02:35:52 +00:00
r5407: - this patch makes samba's event loop code more generic and makes using other implementations possible. This will be mostly usefull for client apps which have there own event loop and want to use our client libs - add a example plugin for liboop (see http://liboop.org) NOTE: this just compiles and is completly untested and is commited only as example metze (This used to be commit b3d0a410efe856e3bcf127f00c31905f5a23cc04)
2005-02-15 10:36:59 +00:00
te->event_ctx = ev;
te->next_event = next_event;
te->handler = handler;
te->private_data = private_data;
te->additional_data = NULL;
r5185: make all the events data structures private to events.c. This will make it possible to add optimisations to the events code such as keeping the next timed event in a sorted list, and using epoll for file descriptor events. I also removed the loop events code, as it wasn't being used anywhere, and changed timed events to always be one-shot (as adding a new timed event in the event handler is so easy to do if needed) (This used to be commit d7b4b6de51342a65bf46fce772d313f92f8d73d3)
2005-02-03 02:35:52 +00:00
r5187: ordered the timed events in the events code, which makes processing events much more efficient (no linked lists need to be traversed, so large numbers of timers are no problem) (This used to be commit b45b9436d78b0ad288b27a1023579bb566ca6202)
2005-02-03 04:02:48 +00:00
/* keep the list ordered */
r5407: - this patch makes samba's event loop code more generic and makes using other implementations possible. This will be mostly usefull for client apps which have there own event loop and want to use our client libs - add a example plugin for liboop (see http://liboop.org) NOTE: this just compiles and is completly untested and is commited only as example metze (This used to be commit b3d0a410efe856e3bcf127f00c31905f5a23cc04)
2005-02-15 10:36:59 +00:00
last_te = NULL;
for (cur_te = std_ev->timed_events; cur_te; cur_te = cur_te->next) {
/* if the new event comes before the current one break */
if (!timeval_is_zero(&cur_te->next_event) &&
r8886: Exchange the arguments of timeval_compare, this makes it behave like strcmp. Volker (This used to be commit 6f5bd7602155413029de32295d2639c4073ad4d8)
2005-08-01 17:31:40 +00:00
timeval_compare(&te->next_event,
&cur_te->next_event) < 0) {
r5407: - this patch makes samba's event loop code more generic and makes using other implementations possible. This will be mostly usefull for client apps which have there own event loop and want to use our client libs - add a example plugin for liboop (see http://liboop.org) NOTE: this just compiles and is completly untested and is commited only as example metze (This used to be commit b3d0a410efe856e3bcf127f00c31905f5a23cc04)
2005-02-15 10:36:59 +00:00
break;
r5187: ordered the timed events in the events code, which makes processing events much more efficient (no linked lists need to be traversed, so large numbers of timers are no problem) (This used to be commit b45b9436d78b0ad288b27a1023579bb566ca6202)
2005-02-03 04:02:48 +00:00
}
r5407: - this patch makes samba's event loop code more generic and makes using other implementations possible. This will be mostly usefull for client apps which have there own event loop and want to use our client libs - add a example plugin for liboop (see http://liboop.org) NOTE: this just compiles and is completly untested and is commited only as example metze (This used to be commit b3d0a410efe856e3bcf127f00c31905f5a23cc04)
2005-02-15 10:36:59 +00:00
last_te = cur_te;
r4944: every event_add_*() caller was having to call talloc_steal() to take control of the event, so instead build that into the function. If you pass NULL as mem_ctx then it leaves it as a child of the events structure. (This used to be commit 7f981b9ed96f39027cbfd500f41e0c2be64cbb50)
2005-01-23 12:17:45 +00:00
}
r5187: ordered the timed events in the events code, which makes processing events much more efficient (no linked lists need to be traversed, so large numbers of timers are no problem) (This used to be commit b45b9436d78b0ad288b27a1023579bb566ca6202)
2005-02-03 04:02:48 +00:00
r5407: - this patch makes samba's event loop code more generic and makes using other implementations possible. This will be mostly usefull for client apps which have there own event loop and want to use our client libs - add a example plugin for liboop (see http://liboop.org) NOTE: this just compiles and is completly untested and is commited only as example metze (This used to be commit b3d0a410efe856e3bcf127f00c31905f5a23cc04)
2005-02-15 10:36:59 +00:00
DLIST_ADD_AFTER(std_ev->timed_events, te, last_te);
talloc_set_destructor(te, std_event_timed_destructor);
r5187: ordered the timed events in the events code, which makes processing events much more efficient (no linked lists need to be traversed, so large numbers of timers are no problem) (This used to be commit b45b9436d78b0ad288b27a1023579bb566ca6202)
2005-02-03 04:02:48 +00:00
r5407: - this patch makes samba's event loop code more generic and makes using other implementations possible. This will be mostly usefull for client apps which have there own event loop and want to use our client libs - add a example plugin for liboop (see http://liboop.org) NOTE: this just compiles and is completly untested and is commited only as example metze (This used to be commit b3d0a410efe856e3bcf127f00c31905f5a23cc04)
2005-02-15 10:36:59 +00:00
return te;
first public release of samba4 code (This used to be commit b0510b5428b3461aeb9bbe3cc95f62fc73e2b97f)
2003-08-13 01:53:07 +00:00
}
/*
r5194: added support for using epoll instead of select() on systems that have it. epoll is much more scalable than select(), but only exists on some systems (such as Linux with the 2.6.x kernel). The code detects any epoll system call failures at runtime and falls back to select() if there is a problem, so it should be safe to compile this on a 2.6 kernel and run it on a 2.4.x kernel. The speedup is quite large. It gains 20% in packet rate in the BENCH-NBT test, on top of another 20% gain from the better timer handling I added earlier. The really big gain will be when we are dealing with large numbers of file descriptors. With epoll we can handle hundreds of file descriptors all O(1), whereas with select it is O(n). (This used to be commit 26aa1aa69377e43da2942a42d137b95801e9fa1a)
2005-02-03 08:24:08 +00:00
a timer has gone off - call it
first public release of samba4 code (This used to be commit b0510b5428b3461aeb9bbe3cc95f62fc73e2b97f)
2003-08-13 01:53:07 +00:00
*/
r12141: - move epoll related code into one big #ifdef, and use dummy #define's for the case where, epoll isn't available at compile time - only pass the private std_event_context, to the local function, to get rid of the talloc_get_type() calls - use the private pointer to std_event_context_init() to decide if we want to disable epoll at runtime metze (This used to be commit de322ea8b761df5434e60879b7eae3796ea68007)
2005-12-09 17:30:14 +00:00
static void std_event_loop_timer(struct std_event_context *std_ev)
r5194: added support for using epoll instead of select() on systems that have it. epoll is much more scalable than select(), but only exists on some systems (such as Linux with the 2.6.x kernel). The code detects any epoll system call failures at runtime and falls back to select() if there is a problem, so it should be safe to compile this on a 2.6 kernel and run it on a 2.4.x kernel. The speedup is quite large. It gains 20% in packet rate in the BENCH-NBT test, on top of another 20% gain from the better timer handling I added earlier. The really big gain will be when we are dealing with large numbers of file descriptors. With epoll we can handle hundreds of file descriptors all O(1), whereas with select it is O(n). (This used to be commit 26aa1aa69377e43da2942a42d137b95801e9fa1a)
2005-02-03 08:24:08 +00:00
{
struct timeval t = timeval_current();
r5407: - this patch makes samba's event loop code more generic and makes using other implementations possible. This will be mostly usefull for client apps which have there own event loop and want to use our client libs - add a example plugin for liboop (see http://liboop.org) NOTE: this just compiles and is completly untested and is commited only as example metze (This used to be commit b3d0a410efe856e3bcf127f00c31905f5a23cc04)
2005-02-15 10:36:59 +00:00
struct timed_event *te = std_ev->timed_events;
r5194: added support for using epoll instead of select() on systems that have it. epoll is much more scalable than select(), but only exists on some systems (such as Linux with the 2.6.x kernel). The code detects any epoll system call failures at runtime and falls back to select() if there is a problem, so it should be safe to compile this on a 2.6 kernel and run it on a 2.4.x kernel. The speedup is quite large. It gains 20% in packet rate in the BENCH-NBT test, on top of another 20% gain from the better timer handling I added earlier. The really big gain will be when we are dealing with large numbers of file descriptors. With epoll we can handle hundreds of file descriptors all O(1), whereas with select it is O(n). (This used to be commit 26aa1aa69377e43da2942a42d137b95801e9fa1a)
2005-02-03 08:24:08 +00:00
r8409: fixed another error found on netbsd. some of our torture code does its own timeout processing, which means there is no event timer in the event context. To fix this gererically I have added a 30 second timout to all select/epoll calls so the callers timeout loop is guaranteed to run eventually (This used to be commit 01e5aa146439f2dbf6c4133a0b5d910383a6576b)
2005-07-13 03:55:22 +00:00
if (te == NULL) {
return;
}
r10537: - we now use a much nicer way to handle talloc_free(timed_event) the events code replaces a destructor to one that returns allways -1 while it's calling the event handler - we don't need the composite and winsrepl specific fixes any more - this also fixes the problem with smbcli, dcerpc, cldap, ldap and nbt request timeouts metze (This used to be commit 495996cfc49a1c6eefde6ff04fc75e0739be3aab)
2005-09-27 12:54:08 +00:00
/* deny the handler to free the event */
talloc_set_destructor(te, std_event_timed_deny_destructor);
r10684: Add a nasty hack for the failure case of wbinfo -t. Tridge has a proper fix for it pending. Also fix a bug with timed events: Don't call the same event recursively in the handler's inner semi-async event loop. Volker (This used to be commit e38e50127a3414461578421e676a9c58c106c272)
2005-10-03 14:24:53 +00:00
/* We need to remove the timer from the list before calling the
* handler because in a semi-async inner event loop called from the
* handler we don't want to come across this event again -- vl */
DLIST_REMOVE(std_ev->timed_events, te);
r12141: - move epoll related code into one big #ifdef, and use dummy #define's for the case where, epoll isn't available at compile time - only pass the private std_event_context, to the local function, to get rid of the talloc_get_type() calls - use the private pointer to std_event_context_init() to decide if we want to disable epoll at runtime metze (This used to be commit de322ea8b761df5434e60879b7eae3796ea68007)
2005-12-09 17:30:14 +00:00
te->handler(std_ev->ev, te, t, te->private_data);
r5194: added support for using epoll instead of select() on systems that have it. epoll is much more scalable than select(), but only exists on some systems (such as Linux with the 2.6.x kernel). The code detects any epoll system call failures at runtime and falls back to select() if there is a problem, so it should be safe to compile this on a 2.6 kernel and run it on a 2.4.x kernel. The speedup is quite large. It gains 20% in packet rate in the BENCH-NBT test, on top of another 20% gain from the better timer handling I added earlier. The really big gain will be when we are dealing with large numbers of file descriptors. With epoll we can handle hundreds of file descriptors all O(1), whereas with select it is O(n). (This used to be commit 26aa1aa69377e43da2942a42d137b95801e9fa1a)
2005-02-03 08:24:08 +00:00
r10684: Add a nasty hack for the failure case of wbinfo -t. Tridge has a proper fix for it pending. Also fix a bug with timed events: Don't call the same event recursively in the handler's inner semi-async event loop. Volker (This used to be commit e38e50127a3414461578421e676a9c58c106c272)
2005-10-03 14:24:53 +00:00
/* The destructor isn't necessary anymore, we've already removed the
* event from the list. */
r10690: Fix a bug that metze pointed out: Leaving the "rejecting" destructor around prevents the memory from being freed. Thanks, Volker (This used to be commit df8eeb01f498568207a4a8d5d12348c473f41799)
2005-10-03 17:36:10 +00:00
talloc_set_destructor(te, NULL);
r10684: Add a nasty hack for the failure case of wbinfo -t. Tridge has a proper fix for it pending. Also fix a bug with timed events: Don't call the same event recursively in the handler's inner semi-async event loop. Volker (This used to be commit e38e50127a3414461578421e676a9c58c106c272)
2005-10-03 14:24:53 +00:00
r10537: - we now use a much nicer way to handle talloc_free(timed_event) the events code replaces a destructor to one that returns allways -1 while it's calling the event handler - we don't need the composite and winsrepl specific fixes any more - this also fixes the problem with smbcli, dcerpc, cldap, ldap and nbt request timeouts metze (This used to be commit 495996cfc49a1c6eefde6ff04fc75e0739be3aab)
2005-09-27 12:54:08 +00:00
talloc_free(te);
r5194: added support for using epoll instead of select() on systems that have it. epoll is much more scalable than select(), but only exists on some systems (such as Linux with the 2.6.x kernel). The code detects any epoll system call failures at runtime and falls back to select() if there is a problem, so it should be safe to compile this on a 2.6 kernel and run it on a 2.4.x kernel. The speedup is quite large. It gains 20% in packet rate in the BENCH-NBT test, on top of another 20% gain from the better timer handling I added earlier. The really big gain will be when we are dealing with large numbers of file descriptors. With epoll we can handle hundreds of file descriptors all O(1), whereas with select it is O(n). (This used to be commit 26aa1aa69377e43da2942a42d137b95801e9fa1a)
2005-02-03 08:24:08 +00:00
}
/*
event loop handling using select()
*/
r12141: - move epoll related code into one big #ifdef, and use dummy #define's for the case where, epoll isn't available at compile time - only pass the private std_event_context, to the local function, to get rid of the talloc_get_type() calls - use the private pointer to std_event_context_init() to decide if we want to disable epoll at runtime metze (This used to be commit de322ea8b761df5434e60879b7eae3796ea68007)
2005-12-09 17:30:14 +00:00
static int std_event_loop_select(struct std_event_context *std_ev, struct timeval *tvalp)
first public release of samba4 code (This used to be commit b0510b5428b3461aeb9bbe3cc95f62fc73e2b97f)
2003-08-13 01:53:07 +00:00
{
r1578: the first stage of the async client rewrite. Up to now the client code has had an async API, and operated asynchronously at the packet level, but was not truly async in that it assumed that it could always write to the socket and when a partial packet came in that it could block waiting for the rest of the packet. This change makes the SMB client library full async, by adding a separate outgoing packet queue, using non-blocking socket IO and having a input buffer that can fill asynchonously until the full packet has arrived. The main complexity was in dealing with the events structure when using the CIFS proxy backend. In that case the same events structure needs to be used in both the client library and the main smbd server, so that when the client library is waiting for a reply that the main server keeps processing packets. This required some changes in the events library code. Next step is to make the generated rpc client code use these new capabilities. (This used to be commit 96bf4da3edc4d64b0f58ef520269f3b385b8da02)
2004-07-23 06:40:49 +00:00
fd_set r_fds, w_fds;
r5407: - this patch makes samba's event loop code more generic and makes using other implementations possible. This will be mostly usefull for client apps which have there own event loop and want to use our client libs - add a example plugin for liboop (see http://liboop.org) NOTE: this just compiles and is completly untested and is commited only as example metze (This used to be commit b3d0a410efe856e3bcf127f00c31905f5a23cc04)
2005-02-15 10:36:59 +00:00
struct fd_event *fde;
r1578: the first stage of the async client rewrite. Up to now the client code has had an async API, and operated asynchronously at the packet level, but was not truly async in that it assumed that it could always write to the socket and when a partial packet came in that it could block waiting for the rest of the packet. This change makes the SMB client library full async, by adding a separate outgoing packet queue, using non-blocking socket IO and having a input buffer that can fill asynchonously until the full packet has arrived. The main complexity was in dealing with the events structure when using the CIFS proxy backend. In that case the same events structure needs to be used in both the client library and the main smbd server, so that when the client library is waiting for a reply that the main server keeps processing packets. This required some changes in the events library code. Next step is to make the generated rpc client code use these new capabilities. (This used to be commit 96bf4da3edc4d64b0f58ef520269f3b385b8da02)
2004-07-23 06:40:49 +00:00
int selrtn;
r5407: - this patch makes samba's event loop code more generic and makes using other implementations possible. This will be mostly usefull for client apps which have there own event loop and want to use our client libs - add a example plugin for liboop (see http://liboop.org) NOTE: this just compiles and is completly untested and is commited only as example metze (This used to be commit b3d0a410efe856e3bcf127f00c31905f5a23cc04)
2005-02-15 10:36:59 +00:00
uint32_t destruction_count = std_ev->destruction_count;
first public release of samba4 code (This used to be commit b0510b5428b3461aeb9bbe3cc95f62fc73e2b97f)
2003-08-13 01:53:07 +00:00
r5194: added support for using epoll instead of select() on systems that have it. epoll is much more scalable than select(), but only exists on some systems (such as Linux with the 2.6.x kernel). The code detects any epoll system call failures at runtime and falls back to select() if there is a problem, so it should be safe to compile this on a 2.6 kernel and run it on a 2.4.x kernel. The speedup is quite large. It gains 20% in packet rate in the BENCH-NBT test, on top of another 20% gain from the better timer handling I added earlier. The really big gain will be when we are dealing with large numbers of file descriptors. With epoll we can handle hundreds of file descriptors all O(1), whereas with select it is O(n). (This used to be commit 26aa1aa69377e43da2942a42d137b95801e9fa1a)
2005-02-03 08:24:08 +00:00
/* we maybe need to recalculate the maxfd */
r5407: - this patch makes samba's event loop code more generic and makes using other implementations possible. This will be mostly usefull for client apps which have there own event loop and want to use our client libs - add a example plugin for liboop (see http://liboop.org) NOTE: this just compiles and is completly untested and is commited only as example metze (This used to be commit b3d0a410efe856e3bcf127f00c31905f5a23cc04)
2005-02-15 10:36:59 +00:00
if (std_ev->maxfd == EVENT_INVALID_MAXFD) {
r12141: - move epoll related code into one big #ifdef, and use dummy #define's for the case where, epoll isn't available at compile time - only pass the private std_event_context, to the local function, to get rid of the talloc_get_type() calls - use the private pointer to std_event_context_init() to decide if we want to disable epoll at runtime metze (This used to be commit de322ea8b761df5434e60879b7eae3796ea68007)
2005-12-09 17:30:14 +00:00
calc_maxfd(std_ev);
r5194: added support for using epoll instead of select() on systems that have it. epoll is much more scalable than select(), but only exists on some systems (such as Linux with the 2.6.x kernel). The code detects any epoll system call failures at runtime and falls back to select() if there is a problem, so it should be safe to compile this on a 2.6 kernel and run it on a 2.4.x kernel. The speedup is quite large. It gains 20% in packet rate in the BENCH-NBT test, on top of another 20% gain from the better timer handling I added earlier. The really big gain will be when we are dealing with large numbers of file descriptors. With epoll we can handle hundreds of file descriptors all O(1), whereas with select it is O(n). (This used to be commit 26aa1aa69377e43da2942a42d137b95801e9fa1a)
2005-02-03 08:24:08 +00:00
}
r5407: - this patch makes samba's event loop code more generic and makes using other implementations possible. This will be mostly usefull for client apps which have there own event loop and want to use our client libs - add a example plugin for liboop (see http://liboop.org) NOTE: this just compiles and is completly untested and is commited only as example metze (This used to be commit b3d0a410efe856e3bcf127f00c31905f5a23cc04)
2005-02-15 10:36:59 +00:00
r1578: the first stage of the async client rewrite. Up to now the client code has had an async API, and operated asynchronously at the packet level, but was not truly async in that it assumed that it could always write to the socket and when a partial packet came in that it could block waiting for the rest of the packet. This change makes the SMB client library full async, by adding a separate outgoing packet queue, using non-blocking socket IO and having a input buffer that can fill asynchonously until the full packet has arrived. The main complexity was in dealing with the events structure when using the CIFS proxy backend. In that case the same events structure needs to be used in both the client library and the main smbd server, so that when the client library is waiting for a reply that the main server keeps processing packets. This required some changes in the events library code. Next step is to make the generated rpc client code use these new capabilities. (This used to be commit 96bf4da3edc4d64b0f58ef520269f3b385b8da02)
2004-07-23 06:40:49 +00:00
FD_ZERO(&r_fds);
FD_ZERO(&w_fds);
/* setup any fd events */
r5407: - this patch makes samba's event loop code more generic and makes using other implementations possible. This will be mostly usefull for client apps which have there own event loop and want to use our client libs - add a example plugin for liboop (see http://liboop.org) NOTE: this just compiles and is completly untested and is commited only as example metze (This used to be commit b3d0a410efe856e3bcf127f00c31905f5a23cc04)
2005-02-15 10:36:59 +00:00
for (fde = std_ev->fd_events; fde; fde = fde->next) {
if (fde->flags & EVENT_FD_READ) {
FD_SET(fde->fd, &r_fds);
r4943: Smplified the events handling code a lot. The first source of complexity was that events didn't automatically cleanup themselves. This was because the events code was written before we had talloc destructors, so you needed to call event_remove_XX() to clean the event out of the event lists from every piece of code that used events. I have now added automatic event destructors, which in turn allowed me to simplify a lot of the calling code. The 2nd source of complexity was caused by the ref_count, which was needed to cope with event handlers destroying events while handling them, which meant the linked lists became invalid, so the ref_count ws used to mark events for later destruction. The new system is much simpler. I now have a ev->destruction_count, which is incremented in all event destructors. The event dispatch code checks for changes to this and handles it. (This used to be commit a3c7417cfeab429ffb22d5546b205818f531a7b4)
2005-01-23 11:49:15 +00:00
}
r5407: - this patch makes samba's event loop code more generic and makes using other implementations possible. This will be mostly usefull for client apps which have there own event loop and want to use our client libs - add a example plugin for liboop (see http://liboop.org) NOTE: this just compiles and is completly untested and is commited only as example metze (This used to be commit b3d0a410efe856e3bcf127f00c31905f5a23cc04)
2005-02-15 10:36:59 +00:00
if (fde->flags & EVENT_FD_WRITE) {
FD_SET(fde->fd, &w_fds);
first public release of samba4 code (This used to be commit b0510b5428b3461aeb9bbe3cc95f62fc73e2b97f)
2003-08-13 01:53:07 +00:00
}
r1578: the first stage of the async client rewrite. Up to now the client code has had an async API, and operated asynchronously at the packet level, but was not truly async in that it assumed that it could always write to the socket and when a partial packet came in that it could block waiting for the rest of the packet. This change makes the SMB client library full async, by adding a separate outgoing packet queue, using non-blocking socket IO and having a input buffer that can fill asynchonously until the full packet has arrived. The main complexity was in dealing with the events structure when using the CIFS proxy backend. In that case the same events structure needs to be used in both the client library and the main smbd server, so that when the client library is waiting for a reply that the main server keeps processing packets. This required some changes in the events library code. Next step is to make the generated rpc client code use these new capabilities. (This used to be commit 96bf4da3edc4d64b0f58ef520269f3b385b8da02)
2004-07-23 06:40:49 +00:00
}
first public release of samba4 code (This used to be commit b0510b5428b3461aeb9bbe3cc95f62fc73e2b97f)
2003-08-13 01:53:07 +00:00
r5407: - this patch makes samba's event loop code more generic and makes using other implementations possible. This will be mostly usefull for client apps which have there own event loop and want to use our client libs - add a example plugin for liboop (see http://liboop.org) NOTE: this just compiles and is completly untested and is commited only as example metze (This used to be commit b3d0a410efe856e3bcf127f00c31905f5a23cc04)
2005-02-15 10:36:59 +00:00
selrtn = select(std_ev->maxfd+1, &r_fds, &w_fds, NULL, tvalp);
r5187: ordered the timed events in the events code, which makes processing events much more efficient (no linked lists need to be traversed, so large numbers of timers are no problem) (This used to be commit b45b9436d78b0ad288b27a1023579bb566ca6202)
2005-02-03 04:02:48 +00:00
if (selrtn == -1 && errno == EBADF) {
/* the socket is dead! this should never
happen as the socket should have first been
made readable and that should have removed
the event, so this must be a bug. This is a
fatal error. */
r5407: - this patch makes samba's event loop code more generic and makes using other implementations possible. This will be mostly usefull for client apps which have there own event loop and want to use our client libs - add a example plugin for liboop (see http://liboop.org) NOTE: this just compiles and is completly untested and is commited only as example metze (This used to be commit b3d0a410efe856e3bcf127f00c31905f5a23cc04)
2005-02-15 10:36:59 +00:00
DEBUG(0,("ERROR: EBADF on std_event_loop_once\n"));
std_ev->exit_code = EBADF;
r5187: ordered the timed events in the events code, which makes processing events much more efficient (no linked lists need to be traversed, so large numbers of timers are no problem) (This used to be commit b45b9436d78b0ad288b27a1023579bb566ca6202)
2005-02-03 04:02:48 +00:00
return -1;
}
r5194: added support for using epoll instead of select() on systems that have it. epoll is much more scalable than select(), but only exists on some systems (such as Linux with the 2.6.x kernel). The code detects any epoll system call failures at runtime and falls back to select() if there is a problem, so it should be safe to compile this on a 2.6 kernel and run it on a 2.4.x kernel. The speedup is quite large. It gains 20% in packet rate in the BENCH-NBT test, on top of another 20% gain from the better timer handling I added earlier. The really big gain will be when we are dealing with large numbers of file descriptors. With epoll we can handle hundreds of file descriptors all O(1), whereas with select it is O(n). (This used to be commit 26aa1aa69377e43da2942a42d137b95801e9fa1a)
2005-02-03 08:24:08 +00:00
if (selrtn == 0 && tvalp) {
r12141: - move epoll related code into one big #ifdef, and use dummy #define's for the case where, epoll isn't available at compile time - only pass the private std_event_context, to the local function, to get rid of the talloc_get_type() calls - use the private pointer to std_event_context_init() to decide if we want to disable epoll at runtime metze (This used to be commit de322ea8b761df5434e60879b7eae3796ea68007)
2005-12-09 17:30:14 +00:00
std_event_loop_timer(std_ev);
r5194: added support for using epoll instead of select() on systems that have it. epoll is much more scalable than select(), but only exists on some systems (such as Linux with the 2.6.x kernel). The code detects any epoll system call failures at runtime and falls back to select() if there is a problem, so it should be safe to compile this on a 2.6 kernel and run it on a 2.4.x kernel. The speedup is quite large. It gains 20% in packet rate in the BENCH-NBT test, on top of another 20% gain from the better timer handling I added earlier. The really big gain will be when we are dealing with large numbers of file descriptors. With epoll we can handle hundreds of file descriptors all O(1), whereas with select it is O(n). (This used to be commit 26aa1aa69377e43da2942a42d137b95801e9fa1a)
2005-02-03 08:24:08 +00:00
return 0;
r5187: ordered the timed events in the events code, which makes processing events much more efficient (no linked lists need to be traversed, so large numbers of timers are no problem) (This used to be commit b45b9436d78b0ad288b27a1023579bb566ca6202)
2005-02-03 04:02:48 +00:00
}
r5194: added support for using epoll instead of select() on systems that have it. epoll is much more scalable than select(), but only exists on some systems (such as Linux with the 2.6.x kernel). The code detects any epoll system call failures at runtime and falls back to select() if there is a problem, so it should be safe to compile this on a 2.6 kernel and run it on a 2.4.x kernel. The speedup is quite large. It gains 20% in packet rate in the BENCH-NBT test, on top of another 20% gain from the better timer handling I added earlier. The really big gain will be when we are dealing with large numbers of file descriptors. With epoll we can handle hundreds of file descriptors all O(1), whereas with select it is O(n). (This used to be commit 26aa1aa69377e43da2942a42d137b95801e9fa1a)
2005-02-03 08:24:08 +00:00
r5187: ordered the timed events in the events code, which makes processing events much more efficient (no linked lists need to be traversed, so large numbers of timers are no problem) (This used to be commit b45b9436d78b0ad288b27a1023579bb566ca6202)
2005-02-03 04:02:48 +00:00
if (selrtn > 0) {
/* at least one file descriptor is ready - check
which ones and call the handler, being careful to allow
the handler to remove itself when called */
r5407: - this patch makes samba's event loop code more generic and makes using other implementations possible. This will be mostly usefull for client apps which have there own event loop and want to use our client libs - add a example plugin for liboop (see http://liboop.org) NOTE: this just compiles and is completly untested and is commited only as example metze (This used to be commit b3d0a410efe856e3bcf127f00c31905f5a23cc04)
2005-02-15 10:36:59 +00:00
for (fde = std_ev->fd_events; fde; fde = fde->next) {
r5187: ordered the timed events in the events code, which makes processing events much more efficient (no linked lists need to be traversed, so large numbers of timers are no problem) (This used to be commit b45b9436d78b0ad288b27a1023579bb566ca6202)
2005-02-03 04:02:48 +00:00
uint16_t flags = 0;
r5407: - this patch makes samba's event loop code more generic and makes using other implementations possible. This will be mostly usefull for client apps which have there own event loop and want to use our client libs - add a example plugin for liboop (see http://liboop.org) NOTE: this just compiles and is completly untested and is commited only as example metze (This used to be commit b3d0a410efe856e3bcf127f00c31905f5a23cc04)
2005-02-15 10:36:59 +00:00
if (FD_ISSET(fde->fd, &r_fds)) flags |= EVENT_FD_READ;
if (FD_ISSET(fde->fd, &w_fds)) flags |= EVENT_FD_WRITE;
r5187: ordered the timed events in the events code, which makes processing events much more efficient (no linked lists need to be traversed, so large numbers of timers are no problem) (This used to be commit b45b9436d78b0ad288b27a1023579bb566ca6202)
2005-02-03 04:02:48 +00:00
if (flags) {
r12141: - move epoll related code into one big #ifdef, and use dummy #define's for the case where, epoll isn't available at compile time - only pass the private std_event_context, to the local function, to get rid of the talloc_get_type() calls - use the private pointer to std_event_context_init() to decide if we want to disable epoll at runtime metze (This used to be commit de322ea8b761df5434e60879b7eae3796ea68007)
2005-12-09 17:30:14 +00:00
fde->handler(std_ev->ev, fde, flags, fde->private_data);
r5407: - this patch makes samba's event loop code more generic and makes using other implementations possible. This will be mostly usefull for client apps which have there own event loop and want to use our client libs - add a example plugin for liboop (see http://liboop.org) NOTE: this just compiles and is completly untested and is commited only as example metze (This used to be commit b3d0a410efe856e3bcf127f00c31905f5a23cc04)
2005-02-15 10:36:59 +00:00
if (destruction_count != std_ev->destruction_count) {
r5187: ordered the timed events in the events code, which makes processing events much more efficient (no linked lists need to be traversed, so large numbers of timers are no problem) (This used to be commit b45b9436d78b0ad288b27a1023579bb566ca6202)
2005-02-03 04:02:48 +00:00
break;
first public release of samba4 code (This used to be commit b0510b5428b3461aeb9bbe3cc95f62fc73e2b97f)
2003-08-13 01:53:07 +00:00
}
}
}
r1578: the first stage of the async client rewrite. Up to now the client code has had an async API, and operated asynchronously at the packet level, but was not truly async in that it assumed that it could always write to the socket and when a partial packet came in that it could block waiting for the rest of the packet. This change makes the SMB client library full async, by adding a separate outgoing packet queue, using non-blocking socket IO and having a input buffer that can fill asynchonously until the full packet has arrived. The main complexity was in dealing with the events structure when using the CIFS proxy backend. In that case the same events structure needs to be used in both the client library and the main smbd server, so that when the client library is waiting for a reply that the main server keeps processing packets. This required some changes in the events library code. Next step is to make the generated rpc client code use these new capabilities. (This used to be commit 96bf4da3edc4d64b0f58ef520269f3b385b8da02)
2004-07-23 06:40:49 +00:00
}
first public release of samba4 code (This used to be commit b0510b5428b3461aeb9bbe3cc95f62fc73e2b97f)
2003-08-13 01:53:07 +00:00
r2283: Change from tridge (in his ntlm2 patch). I think the idea here is to bail out correctly when we get signing broken on TCP, rather than keeping on hammering the socket. Andrew Bartlett (This used to be commit 553b529a0991ccf2f1be14cc6a27695223f02e65)
2004-09-11 15:05:49 +00:00
return 0;
r5194: added support for using epoll instead of select() on systems that have it. epoll is much more scalable than select(), but only exists on some systems (such as Linux with the 2.6.x kernel). The code detects any epoll system call failures at runtime and falls back to select() if there is a problem, so it should be safe to compile this on a 2.6 kernel and run it on a 2.4.x kernel. The speedup is quite large. It gains 20% in packet rate in the BENCH-NBT test, on top of another 20% gain from the better timer handling I added earlier. The really big gain will be when we are dealing with large numbers of file descriptors. With epoll we can handle hundreds of file descriptors all O(1), whereas with select it is O(n). (This used to be commit 26aa1aa69377e43da2942a42d137b95801e9fa1a)
2005-02-03 08:24:08 +00:00
}
/*
r5195: most events don't need the time of the event, so save a gettimeofday() call and just use timeval_current() when its actually needed (This used to be commit 236403cc4dc2924ed6a898acae0bb44cc1688dcc)
2005-02-03 11:25:52 +00:00
do a single event loop using the events defined in ev
r5194: added support for using epoll instead of select() on systems that have it. epoll is much more scalable than select(), but only exists on some systems (such as Linux with the 2.6.x kernel). The code detects any epoll system call failures at runtime and falls back to select() if there is a problem, so it should be safe to compile this on a 2.6 kernel and run it on a 2.4.x kernel. The speedup is quite large. It gains 20% in packet rate in the BENCH-NBT test, on top of another 20% gain from the better timer handling I added earlier. The really big gain will be when we are dealing with large numbers of file descriptors. With epoll we can handle hundreds of file descriptors all O(1), whereas with select it is O(n). (This used to be commit 26aa1aa69377e43da2942a42d137b95801e9fa1a)
2005-02-03 08:24:08 +00:00
*/
r5407: - this patch makes samba's event loop code more generic and makes using other implementations possible. This will be mostly usefull for client apps which have there own event loop and want to use our client libs - add a example plugin for liboop (see http://liboop.org) NOTE: this just compiles and is completly untested and is commited only as example metze (This used to be commit b3d0a410efe856e3bcf127f00c31905f5a23cc04)
2005-02-15 10:36:59 +00:00
static int std_event_loop_once(struct event_context *ev)
r5194: added support for using epoll instead of select() on systems that have it. epoll is much more scalable than select(), but only exists on some systems (such as Linux with the 2.6.x kernel). The code detects any epoll system call failures at runtime and falls back to select() if there is a problem, so it should be safe to compile this on a 2.6 kernel and run it on a 2.4.x kernel. The speedup is quite large. It gains 20% in packet rate in the BENCH-NBT test, on top of another 20% gain from the better timer handling I added earlier. The really big gain will be when we are dealing with large numbers of file descriptors. With epoll we can handle hundreds of file descriptors all O(1), whereas with select it is O(n). (This used to be commit 26aa1aa69377e43da2942a42d137b95801e9fa1a)
2005-02-03 08:24:08 +00:00
{
r5407: - this patch makes samba's event loop code more generic and makes using other implementations possible. This will be mostly usefull for client apps which have there own event loop and want to use our client libs - add a example plugin for liboop (see http://liboop.org) NOTE: this just compiles and is completly untested and is commited only as example metze (This used to be commit b3d0a410efe856e3bcf127f00c31905f5a23cc04)
2005-02-15 10:36:59 +00:00
struct std_event_context *std_ev = talloc_get_type(ev->additional_data,
struct std_event_context);
r8409: fixed another error found on netbsd. some of our torture code does its own timeout processing, which means there is no event timer in the event context. To fix this gererically I have added a 30 second timout to all select/epoll calls so the callers timeout loop is guaranteed to run eventually (This used to be commit 01e5aa146439f2dbf6c4133a0b5d910383a6576b)
2005-07-13 03:55:22 +00:00
struct timeval tval;
r5407: - this patch makes samba's event loop code more generic and makes using other implementations possible. This will be mostly usefull for client apps which have there own event loop and want to use our client libs - add a example plugin for liboop (see http://liboop.org) NOTE: this just compiles and is completly untested and is commited only as example metze (This used to be commit b3d0a410efe856e3bcf127f00c31905f5a23cc04)
2005-02-15 10:36:59 +00:00
r5194: added support for using epoll instead of select() on systems that have it. epoll is much more scalable than select(), but only exists on some systems (such as Linux with the 2.6.x kernel). The code detects any epoll system call failures at runtime and falls back to select() if there is a problem, so it should be safe to compile this on a 2.6 kernel and run it on a 2.4.x kernel. The speedup is quite large. It gains 20% in packet rate in the BENCH-NBT test, on top of another 20% gain from the better timer handling I added earlier. The really big gain will be when we are dealing with large numbers of file descriptors. With epoll we can handle hundreds of file descriptors all O(1), whereas with select it is O(n). (This used to be commit 26aa1aa69377e43da2942a42d137b95801e9fa1a)
2005-02-03 08:24:08 +00:00
/* work out the right timeout for all timed events */
r5407: - this patch makes samba's event loop code more generic and makes using other implementations possible. This will be mostly usefull for client apps which have there own event loop and want to use our client libs - add a example plugin for liboop (see http://liboop.org) NOTE: this just compiles and is completly untested and is commited only as example metze (This used to be commit b3d0a410efe856e3bcf127f00c31905f5a23cc04)
2005-02-15 10:36:59 +00:00
if (std_ev->timed_events) {
r5194: added support for using epoll instead of select() on systems that have it. epoll is much more scalable than select(), but only exists on some systems (such as Linux with the 2.6.x kernel). The code detects any epoll system call failures at runtime and falls back to select() if there is a problem, so it should be safe to compile this on a 2.6 kernel and run it on a 2.4.x kernel. The speedup is quite large. It gains 20% in packet rate in the BENCH-NBT test, on top of another 20% gain from the better timer handling I added earlier. The really big gain will be when we are dealing with large numbers of file descriptors. With epoll we can handle hundreds of file descriptors all O(1), whereas with select it is O(n). (This used to be commit 26aa1aa69377e43da2942a42d137b95801e9fa1a)
2005-02-03 08:24:08 +00:00
struct timeval t = timeval_current();
r8875: Rename timeval_diff to timeval_until and revert the arguments. timeval_diff is not strictly a subtraction function, there can't be negative timevals. Volker (This used to be commit 525d75dd24f6a8810f1ed2043d170c70b060f1f0)
2005-08-01 00:34:39 +00:00
tval = timeval_until(&t, &std_ev->timed_events->next_event);
r8409: fixed another error found on netbsd. some of our torture code does its own timeout processing, which means there is no event timer in the event context. To fix this gererically I have added a 30 second timout to all select/epoll calls so the callers timeout loop is guaranteed to run eventually (This used to be commit 01e5aa146439f2dbf6c4133a0b5d910383a6576b)
2005-07-13 03:55:22 +00:00
if (timeval_is_zero(&tval)) {
r12141: - move epoll related code into one big #ifdef, and use dummy #define's for the case where, epoll isn't available at compile time - only pass the private std_event_context, to the local function, to get rid of the talloc_get_type() calls - use the private pointer to std_event_context_init() to decide if we want to disable epoll at runtime metze (This used to be commit de322ea8b761df5434e60879b7eae3796ea68007)
2005-12-09 17:30:14 +00:00
std_event_loop_timer(std_ev);
r5194: added support for using epoll instead of select() on systems that have it. epoll is much more scalable than select(), but only exists on some systems (such as Linux with the 2.6.x kernel). The code detects any epoll system call failures at runtime and falls back to select() if there is a problem, so it should be safe to compile this on a 2.6 kernel and run it on a 2.4.x kernel. The speedup is quite large. It gains 20% in packet rate in the BENCH-NBT test, on top of another 20% gain from the better timer handling I added earlier. The really big gain will be when we are dealing with large numbers of file descriptors. With epoll we can handle hundreds of file descriptors all O(1), whereas with select it is O(n). (This used to be commit 26aa1aa69377e43da2942a42d137b95801e9fa1a)
2005-02-03 08:24:08 +00:00
return 0;
}
r8409: fixed another error found on netbsd. some of our torture code does its own timeout processing, which means there is no event timer in the event context. To fix this gererically I have added a 30 second timout to all select/epoll calls so the callers timeout loop is guaranteed to run eventually (This used to be commit 01e5aa146439f2dbf6c4133a0b5d910383a6576b)
2005-07-13 03:55:22 +00:00
} else {
/* have a default tick time of 30 seconds. This guarantees
that code that uses its own timeout checking will be
able to proceeed eventually */
tval = timeval_set(30, 0);
r5194: added support for using epoll instead of select() on systems that have it. epoll is much more scalable than select(), but only exists on some systems (such as Linux with the 2.6.x kernel). The code detects any epoll system call failures at runtime and falls back to select() if there is a problem, so it should be safe to compile this on a 2.6 kernel and run it on a 2.4.x kernel. The speedup is quite large. It gains 20% in packet rate in the BENCH-NBT test, on top of another 20% gain from the better timer handling I added earlier. The really big gain will be when we are dealing with large numbers of file descriptors. With epoll we can handle hundreds of file descriptors all O(1), whereas with select it is O(n). (This used to be commit 26aa1aa69377e43da2942a42d137b95801e9fa1a)
2005-02-03 08:24:08 +00:00
}
r12141: - move epoll related code into one big #ifdef, and use dummy #define's for the case where, epoll isn't available at compile time - only pass the private std_event_context, to the local function, to get rid of the talloc_get_type() calls - use the private pointer to std_event_context_init() to decide if we want to disable epoll at runtime metze (This used to be commit de322ea8b761df5434e60879b7eae3796ea68007)
2005-12-09 17:30:14 +00:00
if (epoll_event_loop(std_ev, &tval) == 0) {
return 0;
r5194: added support for using epoll instead of select() on systems that have it. epoll is much more scalable than select(), but only exists on some systems (such as Linux with the 2.6.x kernel). The code detects any epoll system call failures at runtime and falls back to select() if there is a problem, so it should be safe to compile this on a 2.6 kernel and run it on a 2.4.x kernel. The speedup is quite large. It gains 20% in packet rate in the BENCH-NBT test, on top of another 20% gain from the better timer handling I added earlier. The really big gain will be when we are dealing with large numbers of file descriptors. With epoll we can handle hundreds of file descriptors all O(1), whereas with select it is O(n). (This used to be commit 26aa1aa69377e43da2942a42d137b95801e9fa1a)
2005-02-03 08:24:08 +00:00
}
r12141: - move epoll related code into one big #ifdef, and use dummy #define's for the case where, epoll isn't available at compile time - only pass the private std_event_context, to the local function, to get rid of the talloc_get_type() calls - use the private pointer to std_event_context_init() to decide if we want to disable epoll at runtime metze (This used to be commit de322ea8b761df5434e60879b7eae3796ea68007)
2005-12-09 17:30:14 +00:00
return std_event_loop_select(std_ev, &tval);
r1578: the first stage of the async client rewrite. Up to now the client code has had an async API, and operated asynchronously at the packet level, but was not truly async in that it assumed that it could always write to the socket and when a partial packet came in that it could block waiting for the rest of the packet. This change makes the SMB client library full async, by adding a separate outgoing packet queue, using non-blocking socket IO and having a input buffer that can fill asynchonously until the full packet has arrived. The main complexity was in dealing with the events structure when using the CIFS proxy backend. In that case the same events structure needs to be used in both the client library and the main smbd server, so that when the client library is waiting for a reply that the main server keeps processing packets. This required some changes in the events library code. Next step is to make the generated rpc client code use these new capabilities. (This used to be commit 96bf4da3edc4d64b0f58ef520269f3b385b8da02)
2004-07-23 06:40:49 +00:00
}
/*
r5407: - this patch makes samba's event loop code more generic and makes using other implementations possible. This will be mostly usefull for client apps which have there own event loop and want to use our client libs - add a example plugin for liboop (see http://liboop.org) NOTE: this just compiles and is completly untested and is commited only as example metze (This used to be commit b3d0a410efe856e3bcf127f00c31905f5a23cc04)
2005-02-15 10:36:59 +00:00
return on failure or (with 0) if all fd events are removed
r1578: the first stage of the async client rewrite. Up to now the client code has had an async API, and operated asynchronously at the packet level, but was not truly async in that it assumed that it could always write to the socket and when a partial packet came in that it could block waiting for the rest of the packet. This change makes the SMB client library full async, by adding a separate outgoing packet queue, using non-blocking socket IO and having a input buffer that can fill asynchonously until the full packet has arrived. The main complexity was in dealing with the events structure when using the CIFS proxy backend. In that case the same events structure needs to be used in both the client library and the main smbd server, so that when the client library is waiting for a reply that the main server keeps processing packets. This required some changes in the events library code. Next step is to make the generated rpc client code use these new capabilities. (This used to be commit 96bf4da3edc4d64b0f58ef520269f3b385b8da02)
2004-07-23 06:40:49 +00:00
*/
r5407: - this patch makes samba's event loop code more generic and makes using other implementations possible. This will be mostly usefull for client apps which have there own event loop and want to use our client libs - add a example plugin for liboop (see http://liboop.org) NOTE: this just compiles and is completly untested and is commited only as example metze (This used to be commit b3d0a410efe856e3bcf127f00c31905f5a23cc04)
2005-02-15 10:36:59 +00:00
static int std_event_loop_wait(struct event_context *ev)
r1578: the first stage of the async client rewrite. Up to now the client code has had an async API, and operated asynchronously at the packet level, but was not truly async in that it assumed that it could always write to the socket and when a partial packet came in that it could block waiting for the rest of the packet. This change makes the SMB client library full async, by adding a separate outgoing packet queue, using non-blocking socket IO and having a input buffer that can fill asynchonously until the full packet has arrived. The main complexity was in dealing with the events structure when using the CIFS proxy backend. In that case the same events structure needs to be used in both the client library and the main smbd server, so that when the client library is waiting for a reply that the main server keeps processing packets. This required some changes in the events library code. Next step is to make the generated rpc client code use these new capabilities. (This used to be commit 96bf4da3edc4d64b0f58ef520269f3b385b8da02)
2004-07-23 06:40:49 +00:00
{
r5407: - this patch makes samba's event loop code more generic and makes using other implementations possible. This will be mostly usefull for client apps which have there own event loop and want to use our client libs - add a example plugin for liboop (see http://liboop.org) NOTE: this just compiles and is completly untested and is commited only as example metze (This used to be commit b3d0a410efe856e3bcf127f00c31905f5a23cc04)
2005-02-15 10:36:59 +00:00
struct std_event_context *std_ev = talloc_get_type(ev->additional_data,
struct std_event_context);
std_ev->exit_code = 0;
r1578: the first stage of the async client rewrite. Up to now the client code has had an async API, and operated asynchronously at the packet level, but was not truly async in that it assumed that it could always write to the socket and when a partial packet came in that it could block waiting for the rest of the packet. This change makes the SMB client library full async, by adding a separate outgoing packet queue, using non-blocking socket IO and having a input buffer that can fill asynchonously until the full packet has arrived. The main complexity was in dealing with the events structure when using the CIFS proxy backend. In that case the same events structure needs to be used in both the client library and the main smbd server, so that when the client library is waiting for a reply that the main server keeps processing packets. This required some changes in the events library code. Next step is to make the generated rpc client code use these new capabilities. (This used to be commit 96bf4da3edc4d64b0f58ef520269f3b385b8da02)
2004-07-23 06:40:49 +00:00
r5407: - this patch makes samba's event loop code more generic and makes using other implementations possible. This will be mostly usefull for client apps which have there own event loop and want to use our client libs - add a example plugin for liboop (see http://liboop.org) NOTE: this just compiles and is completly untested and is commited only as example metze (This used to be commit b3d0a410efe856e3bcf127f00c31905f5a23cc04)
2005-02-15 10:36:59 +00:00
while (std_ev->fd_events && std_ev->exit_code == 0) {
if (std_event_loop_once(ev) != 0) {
r2283: Change from tridge (in his ntlm2 patch). I think the idea here is to bail out correctly when we get signing broken on TCP, rather than keeping on hammering the socket. Andrew Bartlett (This used to be commit 553b529a0991ccf2f1be14cc6a27695223f02e65)
2004-09-11 15:05:49 +00:00
break;
}
first public release of samba4 code (This used to be commit b0510b5428b3461aeb9bbe3cc95f62fc73e2b97f)
2003-08-13 01:53:07 +00:00
}
r5407: - this patch makes samba's event loop code more generic and makes using other implementations possible. This will be mostly usefull for client apps which have there own event loop and want to use our client libs - add a example plugin for liboop (see http://liboop.org) NOTE: this just compiles and is completly untested and is commited only as example metze (This used to be commit b3d0a410efe856e3bcf127f00c31905f5a23cc04)
2005-02-15 10:36:59 +00:00
return std_ev->exit_code;
}
static const struct event_ops std_event_ops = {
.context_init = std_event_context_init,
.add_fd = std_event_add_fd,
.get_fd_flags = std_event_get_fd_flags,
.set_fd_flags = std_event_set_fd_flags,
.add_timed = std_event_add_timed,
.loop_once = std_event_loop_once,
.loop_wait = std_event_loop_wait,
};
const struct event_ops *event_standard_get_ops(void)
{
return &std_event_ops;
first public release of samba4 code (This used to be commit b0510b5428b3461aeb9bbe3cc95f62fc73e2b97f)
2003-08-13 01:53:07 +00:00
}
Copy Permalink