[thirdparty/squid.git] / src / fd.cc

/*
 * Copyright (C) 1996-2018 The Squid Software Foundation and contributors
 *
 * Squid software is distributed under GPLv2+ license and includes
 * contributions from numerous individuals and organizations.
 * Please see the COPYING and CONTRIBUTORS files for details.
 */

/* DEBUG: section 51    Filedescriptor Functions */

#include "squid.h"
#include "comm/Loops.h"
#include "Debug.h"
#include "fatal.h"
#include "fd.h"
#include "fde.h"
#include "globals.h"
#include "profiler/Profiler.h"
#include "SquidTime.h"

// Solaris and possibly others lack MSG_NOSIGNAL optimization
// TODO: move this into compat/? Use a dedicated compat file to avoid dragging
// sys/socket.h into the rest of Squid??
#ifndef MSG_NOSIGNAL
#define MSG_NOSIGNAL 0
#endif

int default_read_method(int, char *, int);
int default_write_method(int, const char *, int);
#if _SQUID_WINDOWS_
int socket_read_method(int, char *, int);
int socket_write_method(int, const char *, int);
int file_read_method(int, char *, int);
int file_write_method(int, const char *, int);
#else
int msghdr_read_method(int, char *, int);
int msghdr_write_method(int, const char *, int);
#endif

const char *fdTypeStr[] = {
    "None",
    "Log",
    "File",
    "Socket",
    "Pipe",
    "MsgHdr",
    "Unknown"
};

static void fdUpdateBiggest(int fd, int);

static void
fdUpdateBiggest(int fd, int opening)
{
    if (fd < Biggest_FD)
        return;

    assert(fd < Squid_MaxFD);

    if (fd > Biggest_FD) {
        /*
         * assert that we are not closing a FD bigger than
         * our known biggest FD
         */
        assert(opening);
        Biggest_FD = fd;
        return;
    }

    /* if we are here, then fd == Biggest_FD */
    /*
     * assert that we are closing the biggest FD; we can't be
     * re-opening it
     */
    assert(!opening);

    while (Biggest_FD >= 0 && !fd_table[Biggest_FD].flags.open)
        --Biggest_FD;
}

void
fd_close(int fd)
{
    fde *F = &fd_table[fd];

    assert(fd >= 0);
    assert(F->flags.open);

    if (F->type == FD_FILE) {
        assert(F->read_handler == NULL);
        assert(F->write_handler == NULL);
    }

    debugs(51, 3, "fd_close FD " << fd << " " << F->desc);
    Comm::SetSelect(fd, COMM_SELECT_READ, NULL, NULL, 0);
    Comm::SetSelect(fd, COMM_SELECT_WRITE, NULL, NULL, 0);
    F->flags.open = false;
    fdUpdateBiggest(fd, 0);
    --Number_FD;
    F->clear();
}

#if _SQUID_WINDOWS_

int
socket_read_method(int fd, char *buf, int len)
{
    int i;
    PROF_start(recv);
    i = recv(fd, (void *) buf, len, 0);
    PROF_stop(recv);
    return i;
}

int
file_read_method(int fd, char *buf, int len)
{
    int i;
    PROF_start(read);
    i = _read(fd, buf, len);
    PROF_stop(read);
    return i;
}

int
socket_write_method(int fd, const char *buf, int len)
{
    int i;
    PROF_start(send);
    i = send(fd, (const void *) buf, len, 0);
    PROF_stop(send);
    return i;
}

int
file_write_method(int fd, const char *buf, int len)
{
    int i;
    PROF_start(write);
    i = (_write(fd, buf, len));
    PROF_stop(write);
    return i;
}

#else
int
default_read_method(int fd, char *buf, int len)
{
    int i;
    PROF_start(read);
    i = read(fd, buf, len);
    PROF_stop(read);
    return i;
}

int
default_write_method(int fd, const char *buf, int len)
{
    int i;
    PROF_start(write);
    i = write(fd, buf, len);
    PROF_stop(write);
    return i;
}

int
msghdr_read_method(int fd, char *buf, int)
{
    PROF_start(read);
    const int i = recvmsg(fd, reinterpret_cast<msghdr*>(buf), MSG_DONTWAIT);
    PROF_stop(read);
    return i;
}

int
msghdr_write_method(int fd, const char *buf, int len)
{
    PROF_start(write);
    const int i = sendmsg(fd, reinterpret_cast<const msghdr*>(buf), MSG_NOSIGNAL);
    PROF_stop(write);
    return i > 0 ? len : i; // len is imprecise but the caller expects a match
}

#endif

void
fd_open(int fd, unsigned int type, const char *desc)
{
    fde *F;
    assert(fd >= 0);
    F = &fd_table[fd];

    if (F->flags.open) {
        debugs(51, DBG_IMPORTANT, "WARNING: Closing open FD " << std::setw(4) << fd);
        fd_close(fd);
    }

    assert(!F->flags.open);
    debugs(51, 3, "fd_open() FD " << fd << " " << desc);
    F->type = type;
    F->flags.open = true;
    F->epoll_state = 0;
#if _SQUID_WINDOWS_

    F->win32.handle = _get_osfhandle(fd);

    switch (type) {

    case FD_SOCKET:

    case FD_PIPE:
        F->read_method = &socket_read_method;
        F->write_method = &socket_write_method;
        break;

    case FD_FILE:

    case FD_LOG:
        F->read_method = &file_read_method;
        F->write_method = &file_write_method;
        break;

    default:
        fatalf("fd_open(): unknown FD type - FD#: %i, type: %u, desc %s\n", fd, type, desc);
    }

#else
    switch (type) {

    case FD_MSGHDR:
        F->read_method = &msghdr_read_method;
        F->write_method = &msghdr_write_method;
        break;

    default:
        F->read_method = &default_read_method;
        F->write_method = &default_write_method;
        break;
    }

#endif

    fdUpdateBiggest(fd, 1);

    fd_note(fd, desc);

    ++Number_FD;
}

void
fd_note(int fd, const char *s)
{
    fde *F = &fd_table[fd];
    if (s)
        xstrncpy(F->desc, s, FD_DESC_SZ);
    else
        *(F->desc) = 0; // ""-string
}

void
fd_bytes(int fd, int len, unsigned int type)
{
    fde *F = &fd_table[fd];

    if (len < 0)
        return;

    assert(type == FD_READ || type == FD_WRITE);

    if (type == FD_READ)
        F->bytes_read += len;
    else
        F->bytes_written += len;
}

void
fdDumpOpen(void)
{
    int i;
    fde *F;

    for (i = 0; i < Squid_MaxFD; ++i) {
        F = &fd_table[i];

        if (!F->flags.open)
            continue;

        if (i == fileno(debug_log))
            continue;

        debugs(51, DBG_IMPORTANT, "Open FD "<< std::left<< std::setw(10) <<
               (F->bytes_read && F->bytes_written ? "READ/WRITE" :
                F->bytes_read ? "READING" : F->bytes_written ? "WRITING" :
                "UNSTARTED")  <<
               " "<< std::right << std::setw(4) << i  << " " << F->desc);
    }
}

int
fdNFree(void)
{
    return Squid_MaxFD - Number_FD - Opening_FD;
}

int
fdUsageHigh(void)
{
    int nrfree = fdNFree();

    if (nrfree < (RESERVED_FD << 1))
        return 1;

    if (nrfree < (Number_FD >> 2))
        return 1;

    return 0;
}

/* Called when we runs out of file descriptors */
void
fdAdjustReserved(void)
{
    int newReserve;
    int x;
    static time_t last = 0;
    /*
     * don't update too frequently
     */

    if (last + 5 > squid_curtime)
        return;

    /*
     * Calculate a new reserve, based on current usage and a small extra
     */
    newReserve = Squid_MaxFD - Number_FD + min(25, Squid_MaxFD / 16);

    if (newReserve <= RESERVED_FD)
        return;

    x = Squid_MaxFD - 20 - min(25, Squid_MaxFD / 16);

    if (newReserve > x) {
        /* perhaps this should be fatal()? -DW */
        debugs(51, DBG_CRITICAL, "WARNING: This machine has a serious shortage of filedescriptors.");
        newReserve = x;
    }

    if (Squid_MaxFD - newReserve < min(256, Squid_MaxFD / 2))
        fatalf("Too few filedescriptors available in the system (%d usable of %d).\n", Squid_MaxFD - newReserve, Squid_MaxFD);

    debugs(51, DBG_CRITICAL, "Reserved FD adjusted from " << RESERVED_FD << " to " << newReserve <<
           " due to failures (" << (Squid_MaxFD - newReserve) << "/" << Squid_MaxFD << " file descriptors available)");
    RESERVED_FD = newReserve;
}
Commit	Line	Data
	1	/*
	2	* Copyright (C) 1996-2018 The Squid Software Foundation and contributors
	3	*
	4	* Squid software is distributed under GPLv2+ license and includes
	5	* contributions from numerous individuals and organizations.
	6	* Please see the COPYING and CONTRIBUTORS files for details.
	7	*/
	8
	9	/* DEBUG: section 51 Filedescriptor Functions */
	10
	11	#include "squid.h"
	12	#include "comm/Loops.h"
	13	#include "Debug.h"
	14	#include "fatal.h"
	15	#include "fd.h"
	16	#include "fde.h"
	17	#include "globals.h"
	18	#include "profiler/Profiler.h"
	19	#include "SquidTime.h"
	20
	21	// Solaris and possibly others lack MSG_NOSIGNAL optimization
	22	// TODO: move this into compat/? Use a dedicated compat file to avoid dragging
	23	// sys/socket.h into the rest of Squid??
	24	#ifndef MSG_NOSIGNAL
	25	#define MSG_NOSIGNAL 0
	26	#endif
	27
	28	int default_read_method(int, char *, int);
	29	int default_write_method(int, const char *, int);
	30	#if _SQUID_WINDOWS_
	31	int socket_read_method(int, char *, int);
	32	int socket_write_method(int, const char *, int);
	33	int file_read_method(int, char *, int);
	34	int file_write_method(int, const char *, int);
	35	#else
	36	int msghdr_read_method(int, char *, int);
	37	int msghdr_write_method(int, const char *, int);
	38	#endif
	39
	40	const char *fdTypeStr[] = {
	41	"None",
	42	"Log",
	43	"File",
	44	"Socket",
	45	"Pipe",
	46	"MsgHdr",
	47	"Unknown"
	48	};
	49
	50	static void fdUpdateBiggest(int fd, int);
	51
	52	static void
	53	fdUpdateBiggest(int fd, int opening)
	54	{
	55	if (fd < Biggest_FD)
	56	return;
	57
	58	assert(fd < Squid_MaxFD);
	59
	60	if (fd > Biggest_FD) {
	61	/*
	62	* assert that we are not closing a FD bigger than
	63	* our known biggest FD
	64	*/
	65	assert(opening);
	66	Biggest_FD = fd;
	67	return;
	68	}
	69
	70	/* if we are here, then fd == Biggest_FD */
	71	/*
	72	* assert that we are closing the biggest FD; we can't be
	73	* re-opening it
	74	*/
	75	assert(!opening);
	76
	77	while (Biggest_FD >= 0 && !fd_table[Biggest_FD].flags.open)
	78	--Biggest_FD;
	79	}
	80
	81	void
	82	fd_close(int fd)
	83	{
	84	fde *F = &fd_table[fd];
	85
	86	assert(fd >= 0);
	87	assert(F->flags.open);
	88
	89	if (F->type == FD_FILE) {
	90	assert(F->read_handler == NULL);
	91	assert(F->write_handler == NULL);
	92	}
	93
	94	debugs(51, 3, "fd_close FD " << fd << " " << F->desc);
	95	Comm::SetSelect(fd, COMM_SELECT_READ, NULL, NULL, 0);
	96	Comm::SetSelect(fd, COMM_SELECT_WRITE, NULL, NULL, 0);
	97	F->flags.open = false;
	98	fdUpdateBiggest(fd, 0);
	99	--Number_FD;
	100	F->clear();
	101	}
	102
	103	#if _SQUID_WINDOWS_
	104
	105	int
	106	socket_read_method(int fd, char *buf, int len)
	107	{
	108	int i;
	109	PROF_start(recv);
	110	i = recv(fd, (void *) buf, len, 0);
	111	PROF_stop(recv);
	112	return i;
	113	}
	114
	115	int
	116	file_read_method(int fd, char *buf, int len)
	117	{
	118	int i;
	119	PROF_start(read);
	120	i = _read(fd, buf, len);
	121	PROF_stop(read);
	122	return i;
	123	}
	124
	125	int
	126	socket_write_method(int fd, const char *buf, int len)
	127	{
	128	int i;
	129	PROF_start(send);
	130	i = send(fd, (const void *) buf, len, 0);
	131	PROF_stop(send);
	132	return i;
	133	}
	134
	135	int
	136	file_write_method(int fd, const char *buf, int len)
	137	{
	138	int i;
	139	PROF_start(write);
	140	i = (_write(fd, buf, len));
	141	PROF_stop(write);
	142	return i;
	143	}
	144
	145	#else
	146	int
	147	default_read_method(int fd, char *buf, int len)
	148	{
	149	int i;
	150	PROF_start(read);
	151	i = read(fd, buf, len);
	152	PROF_stop(read);
	153	return i;
	154	}
	155
	156	int
	157	default_write_method(int fd, const char *buf, int len)
	158	{
	159	int i;
	160	PROF_start(write);
	161	i = write(fd, buf, len);
	162	PROF_stop(write);
	163	return i;
	164	}
	165
	166	int
	167	msghdr_read_method(int fd, char *buf, int)
	168	{
	169	PROF_start(read);
	170	const int i = recvmsg(fd, reinterpret_cast<msghdr*>(buf), MSG_DONTWAIT);
	171	PROF_stop(read);
	172	return i;
	173	}
	174
	175	int
	176	msghdr_write_method(int fd, const char *buf, int len)
	177	{
	178	PROF_start(write);
	179	const int i = sendmsg(fd, reinterpret_cast<const msghdr*>(buf), MSG_NOSIGNAL);
	180	PROF_stop(write);
	181	return i > 0 ? len : i; // len is imprecise but the caller expects a match
	182	}
	183
	184	#endif
	185
	186	void
	187	fd_open(int fd, unsigned int type, const char *desc)
	188	{
	189	fde *F;
	190	assert(fd >= 0);
	191	F = &fd_table[fd];
	192
	193	if (F->flags.open) {
	194	debugs(51, DBG_IMPORTANT, "WARNING: Closing open FD " << std::setw(4) << fd);
	195	fd_close(fd);
	196	}
	197
	198	assert(!F->flags.open);
	199	debugs(51, 3, "fd_open() FD " << fd << " " << desc);
	200	F->type = type;
	201	F->flags.open = true;
	202	F->epoll_state = 0;
	203	#if _SQUID_WINDOWS_
	204
	205	F->win32.handle = _get_osfhandle(fd);
	206
	207	switch (type) {
	208
	209	case FD_SOCKET:
	210
	211	case FD_PIPE:
	212	F->read_method = &socket_read_method;
	213	F->write_method = &socket_write_method;
	214	break;
	215
	216	case FD_FILE:
	217
	218	case FD_LOG:
	219	F->read_method = &file_read_method;
	220	F->write_method = &file_write_method;
	221	break;
	222
	223	default:
	224	fatalf("fd_open(): unknown FD type - FD#: %i, type: %u, desc %s\n", fd, type, desc);
	225	}
	226
	227	#else
	228	switch (type) {
	229
	230	case FD_MSGHDR:
	231	F->read_method = &msghdr_read_method;
	232	F->write_method = &msghdr_write_method;
	233	break;
	234
	235	default:
	236	F->read_method = &default_read_method;
	237	F->write_method = &default_write_method;
	238	break;
	239	}
	240
	241	#endif
	242
	243	fdUpdateBiggest(fd, 1);
	244
	245	fd_note(fd, desc);
	246
	247	++Number_FD;
	248	}
	249
	250	void
	251	fd_note(int fd, const char *s)
	252	{
	253	fde *F = &fd_table[fd];
	254	if (s)
	255	xstrncpy(F->desc, s, FD_DESC_SZ);
	256	else
	257	*(F->desc) = 0; // ""-string
	258	}
	259
	260	void
	261	fd_bytes(int fd, int len, unsigned int type)
	262	{
	263	fde *F = &fd_table[fd];
	264
	265	if (len < 0)
	266	return;
	267
	268	assert(type == FD_READ \|\| type == FD_WRITE);
	269
	270	if (type == FD_READ)
	271	F->bytes_read += len;
	272	else
	273	F->bytes_written += len;
	274	}
	275
	276	void
	277	fdDumpOpen(void)
	278	{
	279	int i;
	280	fde *F;
	281
	282	for (i = 0; i < Squid_MaxFD; ++i) {
	283	F = &fd_table[i];
	284
	285	if (!F->flags.open)
	286	continue;
	287
	288	if (i == fileno(debug_log))
	289	continue;
	290
	291	debugs(51, DBG_IMPORTANT, "Open FD "<< std::left<< std::setw(10) <<
	292	(F->bytes_read && F->bytes_written ? "READ/WRITE" :
	293	F->bytes_read ? "READING" : F->bytes_written ? "WRITING" :
	294	"UNSTARTED") <<
	295	" "<< std::right << std::setw(4) << i << " " << F->desc);
	296	}
	297	}
	298
	299	int
	300	fdNFree(void)
	301	{
	302	return Squid_MaxFD - Number_FD - Opening_FD;
	303	}
	304
	305	int
	306	fdUsageHigh(void)
	307	{
	308	int nrfree = fdNFree();
	309
	310	if (nrfree < (RESERVED_FD << 1))
	311	return 1;
	312
	313	if (nrfree < (Number_FD >> 2))
	314	return 1;
	315
	316	return 0;
	317	}
	318
	319	/* Called when we runs out of file descriptors */
	320	void
	321	fdAdjustReserved(void)
	322	{
	323	int newReserve;
	324	int x;
	325	static time_t last = 0;
	326	/*
	327	* don't update too frequently
	328	*/
	329
	330	if (last + 5 > squid_curtime)
	331	return;
	332
	333	/*
	334	* Calculate a new reserve, based on current usage and a small extra
	335	*/
	336	newReserve = Squid_MaxFD - Number_FD + min(25, Squid_MaxFD / 16);
	337
	338	if (newReserve <= RESERVED_FD)
	339	return;
	340
	341	x = Squid_MaxFD - 20 - min(25, Squid_MaxFD / 16);
	342
	343	if (newReserve > x) {
	344	/* perhaps this should be fatal()? -DW */
	345	debugs(51, DBG_CRITICAL, "WARNING: This machine has a serious shortage of filedescriptors.");
	346	newReserve = x;
	347	}
	348
	349	if (Squid_MaxFD - newReserve < min(256, Squid_MaxFD / 2))
	350	fatalf("Too few filedescriptors available in the system (%d usable of %d).\n", Squid_MaxFD - newReserve, Squid_MaxFD);
	351
	352	debugs(51, DBG_CRITICAL, "Reserved FD adjusted from " << RESERVED_FD << " to " << newReserve <<
	353	" due to failures (" << (Squid_MaxFD - newReserve) << "/" << Squid_MaxFD << " file descriptors available)");
	354	RESERVED_FD = newReserve;
	355	}
	356