lighttpd 1.4.x https://www.lighttpd.net/
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

1528 lines
50 KiB

#include "first.h"
#include "stat_cache.h"
#include "log.h"
#include "fdevent.h"
#include "http_etag.h"
#include "algo_splaytree.h"
#include <sys/types.h>
#include <sys/stat.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <fcntl.h>
#if defined(HAVE_SYS_XATTR_H)
# include <sys/xattr.h>
#elif defined(HAVE_ATTR_ATTRIBUTES_H)
# include <attr/attributes.h>
#endif
#ifdef HAVE_SYS_EXTATTR_H
# include <sys/extattr.h>
#endif
#ifndef HAVE_LSTAT
#define lstat stat
#ifndef S_ISLNK
#define S_ISLNK(mode) (0)
#endif
#endif
/*
* stat-cache
*
* - a splay-tree is used as we can use the caching effect of it
*/
enum {
STAT_CACHE_ENGINE_SIMPLE = 0 /*(default)*/
,STAT_CACHE_ENGINE_NONE = 1
,STAT_CACHE_ENGINE_FAM = 2 /* same as STAT_CACHE_ENGINE_INOTIFY */
,STAT_CACHE_ENGINE_INOTIFY = 2 /* same as STAT_CACHE_ENGINE_FAM */
,STAT_CACHE_ENGINE_KQUEUE = 2 /* same as STAT_CACHE_ENGINE_FAM */
};
struct stat_cache_fam; /* declaration */
typedef struct stat_cache {
int stat_cache_engine;
splay_tree *files; /* nodes of tree are (stat_cache_entry *) */
struct stat_cache_fam *scf;
} stat_cache;
static stat_cache sc;
static void * stat_cache_sptree_find(splay_tree ** const sptree,
const char * const name,
uint32_t len)
{
const int ndx = splaytree_djbhash(name, len);
*sptree = splaytree_splay(*sptree, ndx);
return (*sptree && (*sptree)->key == ndx) ? (*sptree)->data : NULL;
}
#if defined(HAVE_SYS_INOTIFY_H) \
|| (defined(HAVE_SYS_EVENT_H) && defined(HAVE_KQUEUE))
#ifndef HAVE_FAM_H
#define HAVE_FAM_H
#endif
#endif
#ifdef HAVE_FAM_H
/* monitor changes in directories using FAM
*
* This implementation employing FAM monitors directories as they are used,
* and maintains a reference count for cache use within stat_cache.c.
* A periodic job runs in lighttpd every 32 seconds, expiring entries unused
* in last 64 seconds out of the cache and cancelling FAM monitoring. Items
* within the cache are checked against the filesystem upon use if last stat()
* was greater than or equal to 16 seconds ago.
*
* This implementation does not monitor every directory in a tree, and therefore
* the cache may get out-of-sync with the filesystem. Delays in receiving and
* processing events from FAM might also lead to stale cache entries.
*
* For many websites, a large number of files are seldom, if ever, modified,
* and a common practice with images is to create a new file with a new name
* when a new version is needed, in order for client browsers and CDNs to better
* cache the content. Given this, most use will see little difference in
* performance between server.stat-cache-engine = "fam" and "simple" (default).
* The default server.stat-cache-engine = "simple" calls stat() on a target once
* per second, and reuses that information until the next second. For use where
* changes must be immediately visible, server.stat-cache-engine = "disable"
* should be used.
*
* When considering use of server.stat-cache-engine = "fam", there are a few
* additional limitations for this cache implementation using FAM.
* - symlinks to files located outside of the current directory do not result
* in changes to that file being monitored (unless that file is in a directory
* which is monitored as a result of a different request). symlinks can be
* chained and can be circular. This implementation *does not* readlink() or
* realpath() to resolve the chains to find and monitor the ultimate target
* directory. While symlinks to files located outside the current directory
* are not monitored, symlinks to directories *are* monitored, though chains
* of symlinks to directories do not result in monitoring of the directories
* containing intermediate symlinks to the target directory.
* - directory rename of a directory which is not currently being monitored will
* result in stale information in the cache if there is a subdirectory that is
* being monitored.
* Even though lighttpd will not receive FAM events in the above cases, lighttpd
* does re-validate the information in the cache upon use if the cache entry has
* not been checked in 16 seconds, so that is the upper limit for use of stale
* data.
*
* Use of server.stat-cache-engine = "fam" is discouraged for extremely volatile
* directories such as temporary directories (e.g. /tmp and maybe /var/tmp) due
* to the overhead of processing the additional noise generated from changes.
* Related, server.stat-cache-engine = "fam" is not recommended on trees of
* untrusted files where a malicious user could generate an excess of change
* events.
*
* Internal note: lighttpd walks the caches to prune trees in stat_cache when an
* event is received for a directory (or symlink to a directory) which has been
* deleted or renamed. The splaytree data structure is suboptimal for frequent
* changes of large directories trees where there have been a large number of
* different files recently accessed and part of the stat_cache.
*/
#if defined(HAVE_SYS_INOTIFY_H) \
&& !(defined(HAVE_SYS_EVENT_H) && defined(HAVE_KQUEUE))
#include <sys/inotify.h>
/*(translate FAM API to inotify; this is specific to stat_cache.c use of FAM)*/
#define fam fd /*(translate struct stat_cache_fam scf->fam -> scf->fd)*/
typedef int FAMRequest; /*(fr)*/
#define FAMClose(fd) \
close(*(fd))
#define FAMCancelMonitor(fd, wd) \
inotify_rm_watch(*(fd), *(wd))
#define fam_watch_mask ( IN_ATTRIB | IN_CREATE | IN_DELETE | IN_DELETE_SELF \
| IN_MODIFY | IN_MOVE_SELF | IN_MOVED_FROM \
| IN_EXCL_UNLINK | IN_ONLYDIR )
/*(note: follows symlinks; not providing IN_DONT_FOLLOW)*/
#define FAMMonitorDirectory(fd, fn, wd, userData) \
((*(wd) = inotify_add_watch(*(fd), (fn), (fam_watch_mask))) < 0)
typedef enum FAMCodes { /*(copied from fam.h to define arbitrary enum values)*/
FAMChanged=1,
FAMDeleted=2,
FAMCreated=5,
FAMMoved=6,
} FAMCodes;
#elif defined HAVE_SYS_EVENT_H && defined HAVE_KQUEUE
#undef HAVE_SYS_INOTIFY_H
#include <sys/event.h>
#include <sys/time.h>
/*(translate FAM API to inotify; this is specific to stat_cache.c use of FAM)*/
#define fam fd /*(translate struct stat_cache_fam scf->fam -> scf->fd)*/
typedef int FAMRequest; /*(fr)*/
#define FAMClose(fd) \
(-1 != (*(fd)) ? close(*(fd)) : 0)
static int FAMCancelMonitor (const int * const fd, int * const wd)
{
if (-1 == *fd) return 0;
if (-1 == *wd) return 0;
struct timespec t0 = { 0, 0 };
struct kevent kev;
EV_SET(&kev, *wd, EVFILT_VNODE, EV_DELETE, 0, 0, 0);
int rc = kevent(*fd, &kev, 1, NULL, 0, &t0);
close(*wd);
*wd = -1;
return rc;
}
static int FAMMonitorDirectory (int * const fd, char * const fn, int * const wd, void * const userData)
{
*wd = fdevent_open_dirname(fn, 1); /*(note: follows symlinks)*/
if (-1 == *wd) return -1;
struct timespec t0 = { 0, 0 };
struct kevent kev;
unsigned short kev_flags = EV_ADD | EV_ENABLE | EV_CLEAR;
unsigned int kev_fflags = NOTE_ATTRIB | NOTE_EXTEND | NOTE_LINK | NOTE_WRITE
| NOTE_DELETE | NOTE_REVOKE | NOTE_RENAME;
EV_SET(&kev, *wd, EVFILT_VNODE, kev_flags, kev_fflags, 0, userData);
return kevent(*fd, &kev, 1, NULL, 0, &t0);
}
typedef enum FAMCodes { /*(copied from fam.h to define arbitrary enum values)*/
FAMChanged=1,
FAMDeleted=2,
FAMCreated=5,
FAMMoved=6,
} FAMCodes;
#else
#include <fam.h>
#ifdef HAVE_FAMNOEXISTS
#ifndef LIGHTTPD_STATIC
#ifdef HAVE_DLFCN_H
#include <dlfcn.h>
#endif
#endif
#endif
#endif
typedef struct fam_dir_entry {
buffer name;
int refcnt;
FAMRequest req;
[multiple] Y2038 32-bit signed time_t mitigations Most OS platforms have already provided solutions to Y2038 32-bit signed time_t 5 - 10 years ago (or more!) Notable exceptions are Linux i686 and FreeBSD i386. Since 32-bit systems tend to be embedded systems, and since many distros take years to pick up new software, this commit aims to provide Y2038 mitigations for lighttpd running on 32-bit systems with Y2038-unsafe 32-bit signed time_t * Y2038: lighttpd 1.4.60 and later report Y2038 safety $ lighttpd -V + Y2038 support # Y2038-SAFE $ lighttpd -V - Y2038 support (unsafe 32-bit signed time_t) # Y2038-UNSAFE * Y2038: general platform info * Y2038-SAFE: lighttpd 64-bit builds on platforms using 64-bit time_t - all major 64-bit platforms (known to this author) use 64-bit time_t * Y2038-SAFE: lighttpd 32-bit builds on platforms using 64-bit time_t - Linux x32 ABI (different from i686) - FreeBSD all 32-bit and 64-bit architectures *except* 32-bit i386 - NetBSD 6.0 (released Oct 2012) all 32-bit and 64-bit architectures - OpenBSD 5.5 (released May 2014) all 32-bit and 64-bit architectures - Microsoft Windows XP and Visual Studio 2005 (? unsure ?) Another reference suggests Visual Studio 2015 defaults to 64-bit time_t - MacOS 10.15 Catalina (released 2019) drops support for 32-bit apps * Y2038-SAFE: lighttpd 32-bit builds on platforms using 32-bit unsigned time_t - e.g. OpenVMS (unknown if lighttpd builds on this platform) * Y2038-UNSAFE: lighttpd 32-bit builds on platforms using 32-bit signed time_t - Linux 32-bit (including i686) - glibc 32-bit library support not yet available for 64-bit time_t - https://sourceware.org/glibc/wiki/Y2038ProofnessDesign - Linux kernel 5.6 on 32-bit platforms does support 64-bit time_t https://itsubuntu.com/linux-kernel-5-6-to-fix-the-year-2038-issue-unix-y2k/ - https://www.gnu.org/software/libc/manual/html_node/64_002dbit-time-symbol-handling.html &#34;Note: at this point, 64-bit time support in dual-time configurations is work-in-progress, so for these configurations, the public API only makes the 32-bit time support available. In a later change, the public API will allow user code to choose the time size for a given compilation unit.&#34; - compiling with -D_TIME_BITS=64 currently has no effect - glibc recent (Jul 2021) mailing list discussion - https://public-inbox.org/bug-gnulib/878s2ozq70.fsf@oldenburg.str.redhat.com/T/ - FreeBSD i386 - DragonFlyBSD 32-bit * Y2038 mitigations attempted on Y2038-UNSAFE platforms (32-bit signed time_t) * lighttpd prefers system monotonic clock instead of realtime clock in places where realtime clock is not required * lighttpd treats negative time_t values as after 19 Jan 2038 03:14:07 GMT * (lighttpd presumes that lighttpd will not encounter dates before 1970 during normal operation.) * lighttpd casts struct stat st.st_mtime (and st.st_*time) through uint64_t to convert negative timestamps for comparisions with 64-bit timestamps (treating negative timestamp values as after 19 Jan 2038 03:14:07 GMT) * lighttpd provides unix_time64_t (int64_t) and * lighttpd provides struct unix_timespec64 (unix_timespec64_t) (struct timespec equivalent using unix_time64_t tv_sec member) * lighttpd provides gmtime64_r() and localtime64_r() wrappers for platforms 32-bit platforms using 32-bit time_t and lighttpd temporarily shifts the year in order to use gmtime_r() and localtime_r() (or gmtime() and localtime()) from standard libraries, before readjusting year and passing struct tm to formatting functions such as strftime() * lighttpd provides TIME64_CAST() macro to cast signed 32-bit time_t to unsigned 32-bit and then to unix_time64_t * Note: while lighttpd tries handle times past 19 Jan 2038 03:14:07 GMT on 32-bit platforms using 32-bit signed time_t, underlying libraries and underlying filesystems might not behave properly after 32-bit signed time_t overflows (19 Jan 2038 03:14:08 GMT). If a given 32-bit OS does not work properly using negative time_t values, then lighttpd likely will not work properly on that system. * Other references and blogs - https://en.wikipedia.org/wiki/Year_2038_problem - https://en.wikipedia.org/wiki/Time_formatting_and_storage_bugs - http://www.lieberbiber.de/2017/03/14/a-look-at-the-year-20362038-problems-and-time-proofness-in-various-systems/
5 months ago
unix_time64_t stat_ts;
dev_t st_dev;
ino_t st_ino;
struct fam_dir_entry *fam_parent;
} fam_dir_entry;
typedef struct stat_cache_fam {
splay_tree *dirs; /* indexed by path; node data is fam_dir_entry */
#ifdef HAVE_SYS_INOTIFY_H
splay_tree *wds; /* indexed by inotify watch descriptor */
#elif defined HAVE_SYS_EVENT_H && defined HAVE_KQUEUE
#else
FAMConnection fam;
#endif
log_error_st *errh;
fdevents *ev;
fdnode *fdn;
int fd;
} stat_cache_fam;
__attribute_returns_nonnull__
static fam_dir_entry * fam_dir_entry_init(const char *name, size_t len)
{
fam_dir_entry * const fam_dir = calloc(1, sizeof(*fam_dir));
force_assert(NULL != fam_dir);
buffer_copy_string_len(&fam_dir->name, name, len);
fam_dir->refcnt = 0;
#if defined HAVE_SYS_EVENT_H && defined HAVE_KQUEUE
fam_dir->req = -1;
#endif
return fam_dir;
}
static void fam_dir_entry_free(fam_dir_entry *fam_dir)
{
if (!fam_dir) return;
/*(fam_dir->fam_parent might be invalid pointer here; ignore)*/
free(fam_dir->name.ptr);
#if defined HAVE_SYS_EVENT_H && defined HAVE_KQUEUE
if (-1 != fam_dir->req)
close(fam_dir->req);
#endif
free(fam_dir);
}
static void fam_dir_invalidate_node(fam_dir_entry *fam_dir)
{
fam_dir->stat_ts = 0;
if (fam_dir->fam_parent) {
--fam_dir->fam_parent->refcnt;
fam_dir->fam_parent = NULL;
}
}
/*
* walk though splay_tree and collect contents of dir tree.
* remove tagged entries in a second loop
*/
static void fam_dir_tag_refcnt(splay_tree *t, int *keys, int *ndx)
{
if (*ndx == 512) return; /*(must match num array entries in keys[])*/
if (t->left) fam_dir_tag_refcnt(t->left, keys, ndx);
if (t->right) fam_dir_tag_refcnt(t->right, keys, ndx);
if (*ndx == 512) return; /*(must match num array entries in keys[])*/
fam_dir_entry * const fam_dir = t->data;
if (0 == fam_dir->refcnt) {
fam_dir_invalidate_node(fam_dir);
keys[(*ndx)++] = t->key;
}
}
__attribute_noinline__
static void fam_dir_periodic_cleanup() {
stat_cache_fam * const scf = sc.scf;
int max_ndx, i;
int keys[512]; /* 2k size on stack */
#if defined HAVE_SYS_EVENT_H && defined HAVE_KQUEUE
struct kevent kevl[512]; /* 32k size on stack to batch kevent EV_DELETE */
#endif
do {
if (!scf->dirs) break;
max_ndx = 0;
fam_dir_tag_refcnt(scf->dirs, keys, &max_ndx);
for (i = 0; i < max_ndx; ++i) {
const int ndx = keys[i];
splay_tree *node = scf->dirs = splaytree_splay(scf->dirs, ndx);
if (node && node->key == ndx) {
fam_dir_entry *fam_dir = node->data;
scf->dirs = splaytree_delete(scf->dirs, ndx);
#ifdef HAVE_SYS_INOTIFY_H
scf->wds = splaytree_delete(scf->wds, fam_dir->req);
#elif defined HAVE_SYS_EVENT_H && defined HAVE_KQUEUE
/* batch process kevent removal; defer cancel */
EV_SET(kevl+i, fam_dir->req, EVFILT_VNODE, EV_DELETE, 0, 0, 0);
fam_dir->req = -1; /*(make FAMCancelMonitor() a no-op)*/
#endif
FAMCancelMonitor(&scf->fam, &fam_dir->req);
fam_dir_entry_free(fam_dir);
}
}
#if defined HAVE_SYS_EVENT_H && defined HAVE_KQUEUE
/* batch process: kevent() to submit EV_DELETE, then close dir fds */
if (0 == max_ndx) break;
struct timespec t0 = { 0, 0 };
kevent(scf->fd, kevl, max_ndx, NULL, 0, &t0);
for (i = 0; i < max_ndx; ++i)
close((int)kevl[i].ident);
#endif
} while (max_ndx == sizeof(keys)/sizeof(int));
}
static void fam_dir_invalidate_tree(splay_tree *t, const char *name, size_t len)
{
#ifdef __clang_analyzer__
force_assert(name);
#endif
/*force_assert(t);*/
if (t->left) fam_dir_invalidate_tree(t->left, name, len);
if (t->right) fam_dir_invalidate_tree(t->right, name, len);
fam_dir_entry * const fam_dir = t->data;
#ifdef __clang_analyzer__
force_assert(fam_dir);
#endif
const buffer * const b = &fam_dir->name;
[multiple] reduce redundant NULL buffer checks This commit is a large set of code changes and results in removal of hundreds, perhaps thousands, of CPU instructions, a portion of which are on hot code paths. Most (buffer *) used by lighttpd are not NULL, especially since buffers were inlined into numerous larger structs such as request_st and chunk. In the small number of instances where that is not the case, a NULL check is often performed earlier in a function where that buffer is later used with a buffer_* func. In the handful of cases that remained, a NULL check was added, e.g. with r-&gt;http_host and r-&gt;conf.server_tag. - check for empty strings at config time and set value to NULL if blank string will be ignored at runtime; at runtime, simple pointer check for NULL can be used to check for a value that has been set and is not blank (&#34;&#34;) - use buffer_is_blank() instead of buffer_string_is_empty(), and use buffer_is_unset() instead of buffer_is_empty(), where buffer is known not to be NULL so that NULL check can be skipped - use buffer_clen() instead of buffer_string_length() when buffer is known not to be NULL (to avoid NULL check at runtime) - use buffer_truncate() instead of buffer_string_set_length() to truncate string, and use buffer_extend() to extend Examples where buffer known not to be NULL: - cpv-&gt;v.b from config_plugin_values_init is not NULL if T_CONFIG_BOOL (though we might set it to NULL if buffer_is_blank(cpv-&gt;v.b)) - address of buffer is arg (&amp;foo) (compiler optimizer detects this in most, but not all, cases) - buffer is checked for NULL earlier in func - buffer is accessed in same scope without a NULL check (e.g. b-&gt;ptr) internal behavior change: callers must not pass a NULL buffer to some funcs. - buffer_init_buffer() requires non-null args - buffer_copy_buffer() requires non-null args - buffer_append_string_buffer() requires non-null args - buffer_string_space() requires non-null arg
6 months ago
size_t blen = buffer_clen(b);
if (blen > len && b->ptr[len] == '/' && 0 == memcmp(b->ptr, name, len))
fam_dir_invalidate_node(fam_dir);
}
/* declarations */
static void stat_cache_delete_tree(const char *name, uint32_t len);
static void stat_cache_invalidate_dir_tree(const char *name, size_t len);
static void stat_cache_handle_fdevent_fn(stat_cache_fam * const scf, fam_dir_entry * const fam_dir, const char * const fn, const uint32_t fnlen, int code);
static void stat_cache_handle_fdevent_in(stat_cache_fam *scf)
{
#ifdef HAVE_SYS_INOTIFY_H
/*(inotify pads in->len to align struct following in->name[])*/
char buf[4096]
__attribute__ ((__aligned__(__alignof__(struct inotify_event))));
int rd;
do {
rd = (int)read(scf->fd, buf, sizeof(buf));
if (rd <= 0) {
if (-1 == rd && errno != EINTR && errno != EAGAIN) {
log_perror(scf->errh, __FILE__, __LINE__, "inotify error");
/* TODO: could flush cache, close scf->fd, and re-open inotify*/
}
break;
}
for (int i = 0; i < rd; ) {
struct inotify_event * const in =
(struct inotify_event *)((uintptr_t)buf + i);
uint32_t len = in->len;
if (len > sizeof(buf)) break; /*(should not happen)*/
i += sizeof(struct inotify_event) + len;
if (i > rd) break; /*(should not happen (partial record))*/
if (in->mask & IN_CREATE)
continue; /*(see comment below for FAMCreated)*/
if (in->mask & IN_Q_OVERFLOW) {
log_error(scf->errh, __FILE__, __LINE__,
"inotify queue overflow");
continue;
}
/* ignore events which may have been pending for
* paths recently cancelled via FAMCancelMonitor() */
scf->wds = splaytree_splay(scf->wds, in->wd);
if (!scf->wds || scf->wds->key != in->wd)
continue;
fam_dir_entry *fam_dir = scf->wds->data;
if (NULL == fam_dir) /*(should not happen)*/
continue;
if (fam_dir->req != in->wd) /*(should not happen)*/
continue;
/*(specific to use here in stat_cache.c)*/
int code = 0;
if (in->mask & (IN_ATTRIB | IN_MODIFY))
code = FAMChanged;
else if (in->mask & (IN_DELETE | IN_DELETE_SELF | IN_UNMOUNT))
code = FAMDeleted;
else if (in->mask & (IN_MOVE_SELF | IN_MOVED_FROM))
code = FAMMoved;
if (len) {
do { --len; } while (len && in->name[len-1] == '\0');
}
stat_cache_handle_fdevent_fn(scf, fam_dir, in->name, len, code);
}
} while (rd + sizeof(struct inotify_event) + NAME_MAX + 1 > sizeof(buf));
#elif defined HAVE_SYS_EVENT_H && defined HAVE_KQUEUE
struct kevent kevl[256];
struct timespec t0 = { 0, 0 };
int n;
do {
n = kevent(scf->fd, NULL, 0, kevl, sizeof(kevl)/sizeof(*kevl), &t0);
if (n <= 0) break;
for (int i = 0; i < n; ++i) {
const struct kevent * const kev = kevl+i;
/* ignore events which may have been pending for
* paths recently cancelled via FAMCancelMonitor() */
int ndx = (int)(intptr_t)kev->udata;
scf->dirs = splaytree_splay(scf->dirs, ndx);
if (!scf->dirs || scf->dirs->key != ndx)
continue;
fam_dir_entry *fam_dir = scf->dirs->data;
if (fam_dir->req != (int)kev->ident)
continue;
/*(specific to use here in stat_cache.c)*/
/* note: stat_cache only monitors on directories,
* so events here are only on directories
* note: changes are treated as FAMDeleted since
* it is unknown which file in dir was changed
* This is not efficient, but this stat_cache mechanism also
* should not be used on frequently modified directories. */
int code = 0;
if (kev->fflags & (NOTE_WRITE|NOTE_ATTRIB|NOTE_EXTEND|NOTE_LINK))
code = FAMDeleted; /*(not FAMChanged; see comment above)*/
else if (kev->fflags & (NOTE_DELETE|NOTE_REVOKE))
code = FAMDeleted;
else if (kev->fflags & NOTE_RENAME)
code = FAMMoved;
if (kev->flags & EV_ERROR) /*(not expected; treat as FAMDeleted)*/
code = FAMDeleted;
stat_cache_handle_fdevent_fn(scf, fam_dir, NULL, 0, code);
}
} while (n == sizeof(kevl)/sizeof(*kevl));
#else
for (int i = 0, ndx; i || (i = FAMPending(&scf->fam)) > 0; --i) {
FAMEvent fe;
if (FAMNextEvent(&scf->fam, &fe) < 0) break;
/* ignore events which may have been pending for
* paths recently cancelled via FAMCancelMonitor() */
ndx = (int)(intptr_t)fe.userdata;
scf->dirs = splaytree_splay(scf->dirs, ndx);
if (!scf->dirs || scf->dirs->key != ndx) {
continue;
}
fam_dir_entry *fam_dir = scf->dirs->data;
if (FAMREQUEST_GETREQNUM(&fam_dir->req)
!= FAMREQUEST_GETREQNUM(&fe.fr)) {
continue;
}
uint32_t fnlen = (fe.code != FAMCreated && fe.filename[0] != '/')
? (uint32_t)strlen(fe.filename)
: 0;
stat_cache_handle_fdevent_fn(scf, fam_dir, fe.filename, fnlen, fe.code);
}
#endif
}
static void stat_cache_handle_fdevent_fn(stat_cache_fam * const scf, fam_dir_entry *fam_dir, const char * const fn, const uint32_t fnlen, int code)
{
if (fnlen) {
buffer * const n = &fam_dir->name;
fam_dir_entry *fam_link;
uint32_t len;
switch (code) {
case FAMCreated:
/* file created in monitored dir modifies dir and
* we should get a separate FAMChanged event for dir.
* Therefore, ignore file FAMCreated event here.
* Also, if FAMNoExists() is used, might get spurious
* FAMCreated events as changes are made e.g. in monitored
* sub-sub-sub dirs and the library discovers new (already
* existing) dir entries */
return;
case FAMChanged:
/* file changed in monitored dir does not modify dir */
case FAMDeleted:
case FAMMoved:
/* file deleted or moved in monitored dir modifies dir,
* but FAM provides separate notification for that */
/* temporarily append filename to dir in fam_dir->name to
* construct path, then delete stat_cache entry (if any)*/
[multiple] reduce redundant NULL buffer checks This commit is a large set of code changes and results in removal of hundreds, perhaps thousands, of CPU instructions, a portion of which are on hot code paths. Most (buffer *) used by lighttpd are not NULL, especially since buffers were inlined into numerous larger structs such as request_st and chunk. In the small number of instances where that is not the case, a NULL check is often performed earlier in a function where that buffer is later used with a buffer_* func. In the handful of cases that remained, a NULL check was added, e.g. with r-&gt;http_host and r-&gt;conf.server_tag. - check for empty strings at config time and set value to NULL if blank string will be ignored at runtime; at runtime, simple pointer check for NULL can be used to check for a value that has been set and is not blank (&#34;&#34;) - use buffer_is_blank() instead of buffer_string_is_empty(), and use buffer_is_unset() instead of buffer_is_empty(), where buffer is known not to be NULL so that NULL check can be skipped - use buffer_clen() instead of buffer_string_length() when buffer is known not to be NULL (to avoid NULL check at runtime) - use buffer_truncate() instead of buffer_string_set_length() to truncate string, and use buffer_extend() to extend Examples where buffer known not to be NULL: - cpv-&gt;v.b from config_plugin_values_init is not NULL if T_CONFIG_BOOL (though we might set it to NULL if buffer_is_blank(cpv-&gt;v.b)) - address of buffer is arg (&amp;foo) (compiler optimizer detects this in most, but not all, cases) - buffer is checked for NULL earlier in func - buffer is accessed in same scope without a NULL check (e.g. b-&gt;ptr) internal behavior change: callers must not pass a NULL buffer to some funcs. - buffer_init_buffer() requires non-null args - buffer_copy_buffer() requires non-null args - buffer_append_string_buffer() requires non-null args - buffer_string_space() requires non-null arg
6 months ago
len = buffer_clen(n);
buffer_append_path_len(n, fn, fnlen);
/* (alternatively, could chose to stat() and update)*/
[multiple] reduce redundant NULL buffer checks This commit is a large set of code changes and results in removal of hundreds, perhaps thousands, of CPU instructions, a portion of which are on hot code paths. Most (buffer *) used by lighttpd are not NULL, especially since buffers were inlined into numerous larger structs such as request_st and chunk. In the small number of instances where that is not the case, a NULL check is often performed earlier in a function where that buffer is later used with a buffer_* func. In the handful of cases that remained, a NULL check was added, e.g. with r-&gt;http_host and r-&gt;conf.server_tag. - check for empty strings at config time and set value to NULL if blank string will be ignored at runtime; at runtime, simple pointer check for NULL can be used to check for a value that has been set and is not blank (&#34;&#34;) - use buffer_is_blank() instead of buffer_string_is_empty(), and use buffer_is_unset() instead of buffer_is_empty(), where buffer is known not to be NULL so that NULL check can be skipped - use buffer_clen() instead of buffer_string_length() when buffer is known not to be NULL (to avoid NULL check at runtime) - use buffer_truncate() instead of buffer_string_set_length() to truncate string, and use buffer_extend() to extend Examples where buffer known not to be NULL: - cpv-&gt;v.b from config_plugin_values_init is not NULL if T_CONFIG_BOOL (though we might set it to NULL if buffer_is_blank(cpv-&gt;v.b)) - address of buffer is arg (&amp;foo) (compiler optimizer detects this in most, but not all, cases) - buffer is checked for NULL earlier in func - buffer is accessed in same scope without a NULL check (e.g. b-&gt;ptr) internal behavior change: callers must not pass a NULL buffer to some funcs. - buffer_init_buffer() requires non-null args - buffer_copy_buffer() requires non-null args - buffer_append_string_buffer() requires non-null args - buffer_string_space() requires non-null arg
6 months ago
stat_cache_invalidate_entry(BUF_PTR_LEN(n));
fam_link = /*(check if might be symlink to monitored dir)*/
[multiple] reduce redundant NULL buffer checks This commit is a large set of code changes and results in removal of hundreds, perhaps thousands, of CPU instructions, a portion of which are on hot code paths. Most (buffer *) used by lighttpd are not NULL, especially since buffers were inlined into numerous larger structs such as request_st and chunk. In the small number of instances where that is not the case, a NULL check is often performed earlier in a function where that buffer is later used with a buffer_* func. In the handful of cases that remained, a NULL check was added, e.g. with r-&gt;http_host and r-&gt;conf.server_tag. - check for empty strings at config time and set value to NULL if blank string will be ignored at runtime; at runtime, simple pointer check for NULL can be used to check for a value that has been set and is not blank (&#34;&#34;) - use buffer_is_blank() instead of buffer_string_is_empty(), and use buffer_is_unset() instead of buffer_is_empty(), where buffer is known not to be NULL so that NULL check can be skipped - use buffer_clen() instead of buffer_string_length() when buffer is known not to be NULL (to avoid NULL check at runtime) - use buffer_truncate() instead of buffer_string_set_length() to truncate string, and use buffer_extend() to extend Examples where buffer known not to be NULL: - cpv-&gt;v.b from config_plugin_values_init is not NULL if T_CONFIG_BOOL (though we might set it to NULL if buffer_is_blank(cpv-&gt;v.b)) - address of buffer is arg (&amp;foo) (compiler optimizer detects this in most, but not all, cases) - buffer is checked for NULL earlier in func - buffer is accessed in same scope without a NULL check (e.g. b-&gt;ptr) internal behavior change: callers must not pass a NULL buffer to some funcs. - buffer_init_buffer() requires non-null args - buffer_copy_buffer() requires non-null args - buffer_append_string_buffer() requires non-null args - buffer_string_space() requires non-null arg
6 months ago
stat_cache_sptree_find(&scf->dirs, BUF_PTR_LEN(n));
if (fam_link && !buffer_is_equal(&fam_link->name, n))
fam_link = NULL;
[multiple] reduce redundant NULL buffer checks This commit is a large set of code changes and results in removal of hundreds, perhaps thousands, of CPU instructions, a portion of which are on hot code paths. Most (buffer *) used by lighttpd are not NULL, especially since buffers were inlined into numerous larger structs such as request_st and chunk. In the small number of instances where that is not the case, a NULL check is often performed earlier in a function where that buffer is later used with a buffer_* func. In the handful of cases that remained, a NULL check was added, e.g. with r-&gt;http_host and r-&gt;conf.server_tag. - check for empty strings at config time and set value to NULL if blank string will be ignored at runtime; at runtime, simple pointer check for NULL can be used to check for a value that has been set and is not blank (&#34;&#34;) - use buffer_is_blank() instead of buffer_string_is_empty(), and use buffer_is_unset() instead of buffer_is_empty(), where buffer is known not to be NULL so that NULL check can be skipped - use buffer_clen() instead of buffer_string_length() when buffer is known not to be NULL (to avoid NULL check at runtime) - use buffer_truncate() instead of buffer_string_set_length() to truncate string, and use buffer_extend() to extend Examples where buffer known not to be NULL: - cpv-&gt;v.b from config_plugin_values_init is not NULL if T_CONFIG_BOOL (though we might set it to NULL if buffer_is_blank(cpv-&gt;v.b)) - address of buffer is arg (&amp;foo) (compiler optimizer detects this in most, but not all, cases) - buffer is checked for NULL earlier in func - buffer is accessed in same scope without a NULL check (e.g. b-&gt;ptr) internal behavior change: callers must not pass a NULL buffer to some funcs. - buffer_init_buffer() requires non-null args - buffer_copy_buffer() requires non-null args - buffer_append_string_buffer() requires non-null args - buffer_string_space() requires non-null arg
6 months ago
buffer_truncate(n, len);
if (fam_link) {
/* replaced symlink changes containing dir */
stat_cache_invalidate_entry(n->ptr, len);
/* handle symlink to dir as deleted dir below */
code = FAMDeleted;
fam_dir = fam_link;
break;
}
return;
default:
return;
}
}
switch(code) {
case FAMChanged:
[multiple] reduce redundant NULL buffer checks This commit is a large set of code changes and results in removal of hundreds, perhaps thousands, of CPU instructions, a portion of which are on hot code paths. Most (buffer *) used by lighttpd are not NULL, especially since buffers were inlined into numerous larger structs such as request_st and chunk. In the small number of instances where that is not the case, a NULL check is often performed earlier in a function where that buffer is later used with a buffer_* func. In the handful of cases that remained, a NULL check was added, e.g. with r-&gt;http_host and r-&gt;conf.server_tag. - check for empty strings at config time and set value to NULL if blank string will be ignored at runtime; at runtime, simple pointer check for NULL can be used to check for a value that has been set and is not blank (&#34;&#34;) - use buffer_is_blank() instead of buffer_string_is_empty(), and use buffer_is_unset() instead of buffer_is_empty(), where buffer is known not to be NULL so that NULL check can be skipped - use buffer_clen() instead of buffer_string_length() when buffer is known not to be NULL (to avoid NULL check at runtime) - use buffer_truncate() instead of buffer_string_set_length() to truncate string, and use buffer_extend() to extend Examples where buffer known not to be NULL: - cpv-&gt;v.b from config_plugin_values_init is not NULL if T_CONFIG_BOOL (though we might set it to NULL if buffer_is_blank(cpv-&gt;v.b)) - address of buffer is arg (&amp;foo) (compiler optimizer detects this in most, but not all, cases) - buffer is checked for NULL earlier in func - buffer is accessed in same scope without a NULL check (e.g. b-&gt;ptr) internal behavior change: callers must not pass a NULL buffer to some funcs. - buffer_init_buffer() requires non-null args - buffer_copy_buffer() requires non-null args - buffer_append_string_buffer() requires non-null args - buffer_string_space() requires non-null arg
6 months ago
stat_cache_invalidate_entry(BUF_PTR_LEN(&fam_dir->name));
break;
case FAMDeleted:
case FAMMoved:
[multiple] reduce redundant NULL buffer checks This commit is a large set of code changes and results in removal of hundreds, perhaps thousands, of CPU instructions, a portion of which are on hot code paths. Most (buffer *) used by lighttpd are not NULL, especially since buffers were inlined into numerous larger structs such as request_st and chunk. In the small number of instances where that is not the case, a NULL check is often performed earlier in a function where that buffer is later used with a buffer_* func. In the handful of cases that remained, a NULL check was added, e.g. with r-&gt;http_host and r-&gt;conf.server_tag. - check for empty strings at config time and set value to NULL if blank string will be ignored at runtime; at runtime, simple pointer check for NULL can be used to check for a value that has been set and is not blank (&#34;&#34;) - use buffer_is_blank() instead of buffer_string_is_empty(), and use buffer_is_unset() instead of buffer_is_empty(), where buffer is known not to be NULL so that NULL check can be skipped - use buffer_clen() instead of buffer_string_length() when buffer is known not to be NULL (to avoid NULL check at runtime) - use buffer_truncate() instead of buffer_string_set_length() to truncate string, and use buffer_extend() to extend Examples where buffer known not to be NULL: - cpv-&gt;v.b from config_plugin_values_init is not NULL if T_CONFIG_BOOL (though we might set it to NULL if buffer_is_blank(cpv-&gt;v.b)) - address of buffer is arg (&amp;foo) (compiler optimizer detects this in most, but not all, cases) - buffer is checked for NULL earlier in func - buffer is accessed in same scope without a NULL check (e.g. b-&gt;ptr) internal behavior change: callers must not pass a NULL buffer to some funcs. - buffer_init_buffer() requires non-null args - buffer_copy_buffer() requires non-null args - buffer_append_string_buffer() requires non-null args - buffer_string_space() requires non-null arg
6 months ago
stat_cache_delete_tree(BUF_PTR_LEN(&fam_dir->name));
fam_dir_invalidate_node(fam_dir);
if (scf->dirs)
fam_dir_invalidate_tree(scf->dirs,
[multiple] reduce redundant NULL buffer checks This commit is a large set of code changes and results in removal of hundreds, perhaps thousands, of CPU instructions, a portion of which are on hot code paths. Most (buffer *) used by lighttpd are not NULL, especially since buffers were inlined into numerous larger structs such as request_st and chunk. In the small number of instances where that is not the case, a NULL check is often performed earlier in a function where that buffer is later used with a buffer_* func. In the handful of cases that remained, a NULL check was added, e.g. with r-&gt;http_host and r-&gt;conf.server_tag. - check for empty strings at config time and set value to NULL if blank string will be ignored at runtime; at runtime, simple pointer check for NULL can be used to check for a value that has been set and is not blank (&#34;&#34;) - use buffer_is_blank() instead of buffer_string_is_empty(), and use buffer_is_unset() instead of buffer_is_empty(), where buffer is known not to be NULL so that NULL check can be skipped - use buffer_clen() instead of buffer_string_length() when buffer is known not to be NULL (to avoid NULL check at runtime) - use buffer_truncate() instead of buffer_string_set_length() to truncate string, and use buffer_extend() to extend Examples where buffer known not to be NULL: - cpv-&gt;v.b from config_plugin_values_init is not NULL if T_CONFIG_BOOL (though we might set it to NULL if buffer_is_blank(cpv-&gt;v.b)) - address of buffer is arg (&amp;foo) (compiler optimizer detects this in most, but not all, cases) - buffer is checked for NULL earlier in func - buffer is accessed in same scope without a NULL check (e.g. b-&gt;ptr) internal behavior change: callers must not pass a NULL buffer to some funcs. - buffer_init_buffer() requires non-null args - buffer_copy_buffer() requires non-null args - buffer_append_string_buffer() requires non-null args - buffer_string_space() requires non-null arg
6 months ago
BUF_PTR_LEN(&fam_dir->name));
fam_dir_periodic_cleanup();
break;
default:
break;
}
}
static handler_t stat_cache_handle_fdevent(void *ctx, int revent)
{
stat_cache_fam * const scf = ctx; /* sc.scf */
if (revent & FDEVENT_IN) {
stat_cache_handle_fdevent_in(scf);
}
if (revent & (FDEVENT_HUP|FDEVENT_RDHUP)) {
/* fam closed the connection */
log_error(scf->errh, __FILE__, __LINE__,
"FAM connection closed; disabling stat_cache.");
/* (although effectively STAT_CACHE_ENGINE_NONE,
* do not change here so that periodic jobs clean up memory)*/
/*sc.stat_cache_engine = STAT_CACHE_ENGINE_NONE; */
fdevent_fdnode_event_del(scf->ev, scf->fdn);
fdevent_unregister(scf->ev, scf->fd);
scf->fdn = NULL;
FAMClose(&scf->fam);
scf->fd = -1;
}
return HANDLER_GO_ON;
}
static stat_cache_fam * stat_cache_init_fam(fdevents *ev, log_error_st *errh) {
stat_cache_fam *scf = calloc(1, sizeof(*scf));
force_assert(scf);
scf->fd = -1;
scf->ev = ev;
scf->errh = errh;
#ifdef HAVE_SYS_INOTIFY_H
scf->fd = inotify_init1(IN_NONBLOCK|IN_CLOEXEC);
if (scf->fd < 0) {
log_perror(errh, __FILE__, __LINE__, "inotify_init1()");
free(scf);
return NULL;
}
#elif defined HAVE_SYS_EVENT_H && defined HAVE_KQUEUE
#ifdef __NetBSD__
scf->fd = kqueue1(O_NONBLOCK|O_CLOEXEC|O_NOSIGPIPE);
#else
scf->fd = kqueue();
if (scf->fd >= 0) fdevent_setfd_cloexec(scf->fd);
#endif
if (scf->fd < 0) {
log_perror(errh, __FILE__, __LINE__, "kqueue()");
free(scf);
return NULL;
}
#else
/* setup FAM */
if (0 != FAMOpen2(&scf->fam, "lighttpd")) {
log_error(errh, __FILE__, __LINE__,
"could not open a fam connection, dying.");
free(scf);
return NULL;
}
#ifdef HAVE_FAMNOEXISTS
#ifdef LIGHTTPD_STATIC
FAMNoExists(&scf->fam);
#else
int (*FAMNoExists_fn)(FAMConnection *);
FAMNoExists_fn =
(int (*)(FAMConnection *))(intptr_t)dlsym(RTLD_DEFAULT,"FAMNoExists");
if (FAMNoExists_fn) FAMNoExists_fn(&scf->fam);
#endif
#endif
scf->fd = FAMCONNECTION_GETFD(&scf->fam);
fdevent_setfd_cloexec(scf->fd);
#endif
scf->fdn = fdevent_register(scf->ev, scf->fd, stat_cache_handle_fdevent, scf);
fdevent_fdnode_event_set(scf->ev, scf->fdn, FDEVENT_IN | FDEVENT_RDHUP);
return scf;
}
static void stat_cache_free_fam(stat_cache_fam *scf) {
if (NULL == scf) return;
#ifdef HAVE_SYS_INOTIFY_H
while (scf->wds) {
splay_tree *node = scf->wds;
scf->wds = splaytree_delete(scf->wds, node->key);
}
#elif defined HAVE_SYS_EVENT_H && defined HAVE_KQUEUE
/*(quicker cleanup to close kqueue() before cancel per entry)*/
close(scf->fd);
scf->fd = -1;
#endif
while (scf->dirs) {
/*(skip entry invalidation and FAMCancelMonitor())*/
splay_tree *node = scf->dirs;
fam_dir_entry_free((fam_dir_entry *)node->data);
scf->dirs = splaytree_delete(scf->dirs, node->key);
}
if (-1 != scf->fd) {
/*scf->fdn already cleaned up in fdevent_free()*/