3
A brief file description
5
@section license License
7
Licensed to the Apache Software Foundation (ASF) under one
8
or more contributor license agreements. See the NOTICE file
9
distributed with this work for additional information
10
regarding copyright ownership. The ASF licenses this file
11
to you under the Apache License, Version 2.0 (the
12
"License"); you may not use this file except in compliance
13
with the License. You may obtain a copy of the License at
15
http://www.apache.org/licenses/LICENSE-2.0
17
Unless required by applicable law or agreed to in writing, software
18
distributed under the License is distributed on an "AS IS" BASIS,
19
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
20
See the License for the specific language governing permissions and
21
limitations under the License.
24
/****************************************************************************
28
Handle the allocation of the socket descriptor (fd) resource.
31
****************************************************************************/
32
#ifndef _P_UnixSocketManager_h_
33
#define _P_UnixSocketManager_h_
36
#include "I_SocketManager.h"
40
// These limits are currently disabled
42
// 1024 - stdin, stderr, stdout
43
#define EPOLL_MAX_DESCRIPTOR_SIZE 32768
48
bool transient = (errno == EINTR);
50
transient = transient || (errno == ENOMEM);
53
transient = transient || (errno == ENOBUFS);
60
// Timing done in the connectionManager
63
SocketManager::accept(int s, struct sockaddr *addr, socklen_t *addrlen)
67
r =::accept(s, addr, addrlen);
71
} while (transient_error());
77
SocketManager::open(const char *path, int oflag, mode_t mode)
81
s =::open(path, oflag, mode);
85
} while (transient_error());
90
SocketManager::read(int fd, void *buf, int size, void *pOLP)
95
r =::read(fd, buf, size);
99
} while (r == -EINTR);
104
SocketManager::pread(int fd, void *buf, int size, off_t offset, char *tag)
109
r =::pread(fd, buf, size, offset);
112
} while (r == -EINTR);
117
SocketManager::readv(int fd, struct iovec *vector, size_t count)
121
// coverity[tainted_data_argument]
122
if (likely((r =::readv(fd, vector, count)) >= 0))
125
} while (transient_error());
130
SocketManager::vector_io(int fd, struct iovec *vector, size_t count, int read_request, void *pOLP)
133
const int max_iovecs_per_request = 16;
137
int64_t bytes_xfered = 0;
139
int64_t current_request_bytes;
141
for (n_vec = 0; n_vec < (int) count; n_vec += max_iovecs_per_request) {
142
current_count = min(max_iovecs_per_request, ((int) (count - n_vec)));
144
// coverity[tainted_data_argument]
145
r = read_request ? ::readv(fd, &vector[n_vec], current_count) : ::writev(fd, &vector[n_vec], current_count);
149
} while (transient_error());
152
return (bytes_xfered && (r == -EAGAIN)) ? bytes_xfered : r;
156
if ((n_vec + max_iovecs_per_request) >= (int) count)
159
// Compute bytes in current vector
160
current_request_bytes = 0;
161
for (n = n_vec; n < (n_vec + current_count); ++n)
162
current_request_bytes += vector[n].iov_len;
164
// Exit if we were unable to read all data in the current vector
165
if (r != current_request_bytes)
172
SocketManager::read_vector(int fd, struct iovec *vector, size_t count, void *pOLP)
174
return vector_io(fd, vector, count, 1, pOLP);
178
SocketManager::recv(int fd, void *buf, int size, int flags)
182
if (unlikely((r =::recv(fd, (char *) buf, size, flags)) < 0)) {
185
} while (r == -EINTR);
190
SocketManager::recvfrom(int fd, void *buf, int size, int flags, struct sockaddr *addr, socklen_t *addrlen)
194
r =::recvfrom(fd, (char *) buf, size, flags, addr, addrlen);
197
} while (r == -EINTR);
202
SocketManager::write(int fd, void *buf, int size, void *pOLP)
207
if (likely((r =::write(fd, buf, size)) >= 0))
210
} while (r == -EINTR);
215
SocketManager::pwrite(int fd, void *buf, int size, off_t offset, char *tag)
220
if (unlikely((r =::pwrite(fd, buf, size, offset)) < 0))
222
} while (r == -EINTR);
227
SocketManager::writev(int fd, struct iovec *vector, size_t count)
231
if (likely((r =::writev(fd, vector, count)) >= 0))
234
} while (transient_error());
239
SocketManager::write_vector(int fd, struct iovec *vector, size_t count, void *pOLP)
241
return vector_io(fd, vector, count, 0, pOLP);
246
SocketManager::send(int fd, void *buf, int size, int flags)
250
if (unlikely((r =::send(fd, (char *) buf, size, flags)) < 0))
252
} while (r == -EINTR);
257
SocketManager::sendto(int fd, void *buf, int len, int flags, struct sockaddr *to, int tolen)
261
if (unlikely((r =::sendto(fd, (char *) buf, len, flags, to, tolen)) < 0))
263
} while (r == -EINTR);
268
SocketManager::sendmsg(int fd, struct msghdr *m, int flags, void *pOLP)
273
if (unlikely((r =::sendmsg(fd, m, flags)) < 0))
275
} while (r == -EINTR);
280
SocketManager::lseek(int fd, off_t offset, int whence)
284
if ((r =::lseek(fd, offset, whence)) < 0)
286
} while (r == -EINTR);
291
SocketManager::fstat(int fd, struct stat *buf)
295
if ((r =::fstat(fd, buf)) >= 0)
298
} while (transient_error());
303
SocketManager::unlink(char *buf)
307
if ((r =::unlink(buf)) < 0)
309
} while (r == -EINTR);
314
SocketManager::fsync(int fildes)
318
if ((r =::fsync(fildes)) < 0)
320
} while (r == -EINTR);
325
SocketManager::ftruncate(int fildes, off_t length)
329
if ((r =::ftruncate(fildes, length)) < 0)
331
} while (r == -EINTR);
336
SocketManager::poll(struct pollfd *fds, unsigned long nfds, int timeout)
340
if ((r =::poll(fds, nfds, timeout)) >= 0)
343
} while (transient_error());
349
SocketManager::epoll_create(int size)
353
size = EPOLL_MAX_DESCRIPTOR_SIZE;
355
if (likely((r =::epoll_create(size)) >= 0))
358
} while (errno == -EINTR);
363
SocketManager::epoll_close(int epfd)
366
if (likely(epfd >= 0)) {
368
if (likely((r =::close(epfd)) == 0))
371
} while (errno == -EINTR);
377
SocketManager::epoll_ctl(int epfd, int op, int fd, struct epoll_event *event)
381
if (likely((r =::epoll_ctl(epfd, op, fd, event)) == 0))
384
} while (errno == -EINTR);
389
SocketManager::epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout)
393
if ((r =::epoll_wait(epfd, events, maxevents, timeout)) >= 0)
396
} while (errno == -EINTR);
400
#endif /* TS_USE_EPOLL */
404
SocketManager::kqueue()
410
SocketManager::kevent(int kq, const struct kevent *changelist, int nchanges,
411
struct kevent *eventlist, int nevents,
412
const struct timespec *timeout)
416
r =::kevent(kq, changelist, nchanges,
417
eventlist, nevents, timeout);
418
if (likely(r >= 0)) {
422
} while (errno == -EINTR);
425
#endif /* TS_USE_KQUEUE */
429
SocketManager::port_create()
431
return ::port_create();
435
SocketManager::port_associate(int port, int source, uintptr_t obj,
436
int events, void *user)
439
r =::port_associate(port, source, obj, events, user);
446
SocketManager::port_dissociate(int port, int source, uintptr_t obj)
449
r =::port_dissociate(port, source, obj);
456
SocketManager::port_getn(int port, port_event_t *list, uint_t max,
457
uint_t *nget, timespec_t *timeout)
461
if ((r =::port_getn(port, list, max, nget, timeout)) >= 0)
464
} while (errno == -EINTR); //TODO: possible EAGAIN(undocumented)
467
#endif /* TS_USE_PORT */
471
SocketManager::get_sndbuf_size(int s)
477
r = safe_getsockopt(s, SOL_SOCKET, SO_SNDBUF, (char *) &bsz, &bszsz);
478
return (r == 0 ? bsz : r);
482
SocketManager::get_rcvbuf_size(int s)
488
r = safe_getsockopt(s, SOL_SOCKET, SO_RCVBUF, (char *) &bsz, &bszsz);
489
return (r == 0 ? bsz : r);
493
SocketManager::set_sndbuf_size(int s, int bsz)
495
return safe_setsockopt(s, SOL_SOCKET, SO_SNDBUF, (char *) &bsz, sizeof(bsz));
499
SocketManager::set_rcvbuf_size(int s, int bsz)
501
return safe_setsockopt(s, SOL_SOCKET, SO_RCVBUF, (char *) &bsz, sizeof(bsz));
505
SocketManager::getsockname(int s, struct sockaddr *sa, socklen_t *sz)
507
return::getsockname(s, sa, sz);
511
SocketManager::socket(int domain, int type, int protocol, bool bNonBlocking)
513
NOWARN_UNUSED(bNonBlocking);
514
return::socket(domain, type, protocol);
518
SocketManager::mc_socket(int domain, int type, int protocol, bool bNonBlocking)
520
return SocketManager::socket(domain, type, protocol, bNonBlocking);
524
SocketManager::shutdown(int s, int how)
528
if (unlikely((res =::shutdown(s, how)) < 0))
530
} while (res == -EINTR);
535
SocketManager::lockf(int s, int f, off_t size)
539
if ((res =::lockf(s, f, size)) < 0)
541
} while (res == -EINTR);
546
SocketManager::dup(int s)
550
if ((res =::dup(s)) >= 0)
553
} while (res == -EINTR);
557
int safe_msync(caddr_t addr, size_t len, caddr_t end, int flags);
560
#define MADV_NORMAL 0
564
#define MADV_RANDOM 1
567
#ifndef MADV_SEQUENTIAL
568
#define MADV_SEQUENTIAL 2
571
#ifndef MADV_WILLNEED
572
#define MADV_WILLNEED 3
575
#ifndef MADV_DONTNEED
576
#define MADV_DONTNEED 4
579
int safe_madvise(caddr_t addr, size_t len, caddr_t end, int flags);
580
int safe_mlock(caddr_t addr, size_t len, caddr_t end);
582
#endif /*P_UnixSocketManager_h_ */
added
removed
iocore/eventsystem/P_UnixSocketManager.h
