Slava Egorov
bbd407725e
`Handle` objects which used by Windows specific implementation of
`EventHandler` have complicated life cycle and haphazard approach
to locking. This CL is the first in a series of CLs which attempts
to clean this up a bit - with a final goal to avoid recursively
locking `Handle::monitor_`.
In this CL we remove `Handle::EnsureInitialized` method which
was primarily responsible for associating `HANDLE` with
`EventHandler`'s completion port. Instead we move this logic
into `Handle` constructor.
We also cleanup reference counting logic applied to handles which
participate in asynchronous operations: instead of eagerly
incrementing reference count when `HANDLE` is associated with
the completion port we increment it whenever asynchronous operation
is in progress and decrement it when it completes. This makes the
code much simpler to reason about and avoids necessity to write
code like:
handle->Release();
handle->Release();
accompanied with comments explaining why we need to drop
two references due to eager increment.
Finally we cleanup the handling of provider-specific extensions
accessed through `WSAIoctl`'s `SIO_GET_EXTENSION_FUNCTION_POINTER`.
We were fetching them for every individual socket instead of
fetching them once and caching them globally.
TEST=ci
Cq-Include-Trybots: luci.dart.try:vm-win-debug-x64-try,pkg-win-release-try,analyzer-win-release-try,vm-win-release-x64-try
Change-Id: Ia8b391b713b1a1afb9df9e931eada6abf97f7854
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/378140
Reviewed-by: Martin Kustermann <kustermann@google.com>
111 lines
2.9 KiB
C++
111 lines
2.9 KiB
C++
// Copyright (c) 2012, the Dart project authors. Please see the AUTHORS file
|
|
// for details. All rights reserved. Use of this source code is governed by a
|
|
// BSD-style license that can be found in the LICENSE file.
|
|
|
|
#ifndef RUNTIME_BIN_EVENTHANDLER_MACOS_H_
|
|
#define RUNTIME_BIN_EVENTHANDLER_MACOS_H_
|
|
|
|
#if !defined(RUNTIME_BIN_EVENTHANDLER_H_)
|
|
#error Do not include eventhandler_macos.h directly; use eventhandler.h instead.
|
|
#endif
|
|
|
|
#include <errno.h>
|
|
#include <sys/event.h> // NOLINT
|
|
#include <sys/socket.h>
|
|
#include <unistd.h>
|
|
|
|
#include "platform/hashmap.h"
|
|
#include "platform/signal_blocker.h"
|
|
|
|
namespace dart {
|
|
namespace bin {
|
|
|
|
class DescriptorInfo : public DescriptorInfoBase {
|
|
public:
|
|
explicit DescriptorInfo(intptr_t fd)
|
|
: DescriptorInfoBase(fd), tracked_by_kqueue_(false) {}
|
|
|
|
virtual ~DescriptorInfo() {}
|
|
|
|
intptr_t GetPollEvents();
|
|
|
|
virtual void Close() {
|
|
close(fd_);
|
|
fd_ = -1;
|
|
}
|
|
|
|
void set_tracked_by_kqueue(bool value) { tracked_by_kqueue_ = value; }
|
|
|
|
bool tracked_by_kqueue() { return tracked_by_kqueue_; }
|
|
|
|
bool HasReadEvent();
|
|
|
|
bool HasWriteEvent();
|
|
|
|
protected:
|
|
bool tracked_by_kqueue_;
|
|
|
|
private:
|
|
DISALLOW_COPY_AND_ASSIGN(DescriptorInfo);
|
|
};
|
|
|
|
class DescriptorInfoSingle : public DescriptorInfoSingleMixin<DescriptorInfo> {
|
|
public:
|
|
explicit DescriptorInfoSingle(intptr_t fd) : DescriptorInfoSingleMixin(fd) {}
|
|
virtual ~DescriptorInfoSingle() {}
|
|
|
|
private:
|
|
DISALLOW_COPY_AND_ASSIGN(DescriptorInfoSingle);
|
|
};
|
|
|
|
class DescriptorInfoMultiple
|
|
: public DescriptorInfoMultipleMixin<DescriptorInfo> {
|
|
public:
|
|
explicit DescriptorInfoMultiple(intptr_t fd)
|
|
: DescriptorInfoMultipleMixin(fd) {}
|
|
virtual ~DescriptorInfoMultiple() {}
|
|
|
|
private:
|
|
DISALLOW_COPY_AND_ASSIGN(DescriptorInfoMultiple);
|
|
};
|
|
|
|
class EventHandlerImplementation {
|
|
public:
|
|
EventHandlerImplementation();
|
|
~EventHandlerImplementation();
|
|
|
|
void UpdateKQueueInstance(intptr_t old_mask, DescriptorInfo* di);
|
|
|
|
// Gets the socket data structure for a given file
|
|
// descriptor. Creates a new one if one is not found.
|
|
DescriptorInfo* GetDescriptorInfo(intptr_t fd, bool is_listening);
|
|
void SendData(intptr_t id, Dart_Port dart_port, int64_t data);
|
|
void Start(EventHandler* handler);
|
|
void Shutdown();
|
|
|
|
private:
|
|
int64_t GetTimeout();
|
|
void HandleEvents(struct kevent* events, int size);
|
|
void HandleTimeout();
|
|
static void EventHandlerEntry(uword args);
|
|
void WakeupHandler(intptr_t id, Dart_Port dart_port, int64_t data);
|
|
void HandleInterruptFd();
|
|
void SetPort(intptr_t fd, Dart_Port dart_port, intptr_t mask);
|
|
intptr_t GetEvents(struct kevent* event, DescriptorInfo* di);
|
|
static void* GetHashmapKeyFromFd(intptr_t fd);
|
|
static uint32_t GetHashmapHashFromFd(intptr_t fd);
|
|
|
|
SimpleHashMap socket_map_;
|
|
TimeoutQueue timeout_queue_;
|
|
bool shutdown_;
|
|
int interrupt_fds_[2];
|
|
int kqueue_fd_;
|
|
|
|
DISALLOW_COPY_AND_ASSIGN(EventHandlerImplementation);
|
|
};
|
|
|
|
} // namespace bin
|
|
} // namespace dart
|
|
|
|
#endif // RUNTIME_BIN_EVENTHANDLER_MACOS_H_
|