rcap/rcapd/rcapd_main.c

	rcapd_main.c revision 19449258028e6813f0b7a606b554b2fa37a390ec
/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */

/*
 * Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved.
 */

/*
 * rcapd is a long-running daemon enforcing project-based resource caps (see
 * rcapd(1M)).  Each instance of a process aggregate (project or, generically,
 * "collection") may have a memory cap.  A single thread monitors the resource
 * utilization of capped collections, enforces caps when they are exceeded (and
 * other conditions are met), and incorporates changes in configuration or
 * caps.  Each of these actions occurs not more frequently than the rate
 * specified with rcapadm(1M).
 */

#include <sys/priocntl.h>
#include <sys/proc.h>
#include <sys/resource.h>
#include <sys/sysinfo.h>
#include <sys/stat.h>
#include <sys/sysmacros.h>
#include <sys/time.h>
#include <sys/types.h>
#include <dirent.h>
#include <errno.h>
#include <fcntl.h>
#include <kstat.h>
#include <libintl.h>
#include <limits.h>
#include <locale.h>
#include <priv.h>
#include <signal.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdio_ext.h>
#include <stdlib.h>
#include <libscf.h>
#include <strings.h>
#include <time.h>
#include <unistd.h>
#include <zone.h>
#include <assert.h>
#include <sys/vm_usage.h>
#include "rcapd.h"
#include "rcapd_mapping.h"
#include "rcapd_rfd.h"
#include "rcapd_stat.h"
#include "utils.h"

#define POSITIVE_MIN(x, y) \
    (((x) <= 0) ? (y) : ((y) <= 0) ? (x) : MIN(x, y))
#define NEXT_EVENT_TIME(base, seconds) \
    (((int)seconds > 0) ? (base + (hrtime_t)seconds * (hrtime_t)NANOSEC) \
    : (hrtime_t)0)
#define NEXT_REPORT_EVENT_TIME(base, seconds) \
    ((rcfg.rcfg_stat_file[0] != 0) ?  \
        NEXT_EVENT_TIME(gethrtime(), seconds) : (hrtime_t)0)
#define EVENT_TIME(time, eventtime) \
    (((time) > (eventtime)) && (eventtime) != 0)
#define STAT_TEMPLATE_SUFFIX    ".XXXXXX"   /* suffix of mkstemp() arg */
#define DAEMON_UID      1       /* uid to use */

#define CAPPED_PROJECT  0x01
#define CAPPED_ZONE 0x02

typedef struct soft_scan_arg {
    uint64_t ssa_sum_excess;
    int64_t ssa_scan_goal;
    boolean_t ssa_project_over_cap;
} soft_scan_arg_t;

typedef struct sample_col_arg {
    boolean_t sca_any_over_cap;
    boolean_t sca_project_over_cap;
} sample_col_arg_t;


static int debug_mode = 0;      /* debug mode flag */
static pid_t rcapd_pid;         /* rcapd's pid to ensure it's not */
                    /* scanned */
static kstat_ctl_t *kctl;       /* kstat chain */
static int memory_pressure = 0;     /* physical memory utilization (%) */
static int memory_pressure_sample = 0;  /* count of samples */
static long page_size_kb = 0;       /* system page size in KB */
static size_t nvmu_vals = 0;        /* # of kernel RSS/swap vals in array */
static size_t vmu_vals_len = 0;     /* size of RSS/swap vals array */
static vmusage_t *vmu_vals = NULL;  /* snapshot of kernel RSS/swap values */
static hrtime_t next_report;        /* time of next report */
static int termination_signal = 0;  /* terminating signal */
static zoneid_t my_zoneid = (zoneid_t)-1;
static lcollection_t *gz_col;       /* global zone collection */

rcfg_t rcfg;
/*
 * Updated when we re-read the collection configurations if this rcapd instance
 * is running in the global zone and the global zone is capped.
 */
boolean_t gz_capped = B_FALSE;

/*
 * Flags.
 */
static int ever_ran;
int should_run;
static int should_reconfigure;

static int verify_statistics(void);
static int update_statistics(void);

/*
 * Checks if a process is marked 'system'.  Returns FALSE only when it is not.
 */
static boolean_t
proc_issystem(pid_t pid)
{
    char pc_clname[PC_CLNMSZ];

    if (priocntl(P_PID, pid, PC_GETXPARMS, NULL, PC_KY_CLNAME, pc_clname,
        PC_KY_NULL) != -1) {
        return (strcmp(pc_clname, "SYS") == 0);
    } else {
        debug("cannot get class-specific scheduling parameters; "
            "assuming system process\n");
        return (B_TRUE);
    }
}

static void
lprocess_insert_mark(psinfo_t *psinfop)
{
    pid_t pid = psinfop->pr_pid;
    /* flag indicating whether the process should be scanned. */
    int unscannable = psinfop->pr_nlwp == 0;
    rcid_t colid;
    lcollection_t *lcol;
    lprocess_t *lproc;

    /*
     * Determine which collection to put this process into.  We only have
     * to worry about tracking both zone and project capped processes if
     * this rcapd instance is running in the global zone, since we'll only
     * see processes in our own projects in a non-global zone.  In the
     * global zone, if the process belongs to a non-global zone, we only
     * need to track it for the capped non-global zone collection.  For
     * global zone processes, we first attempt to put the process into a
     * capped project collection.  On the second pass into this function
     * the projid will be cleared so we will just track the process for the
     * global zone collection as a whole.
     */
    if (psinfop->pr_zoneid == my_zoneid && psinfop->pr_projid != -1) {
        colid.rcid_type = RCIDT_PROJECT;
        colid.rcid_val = psinfop->pr_projid;
    } else {
        /* try to add to zone collection */
        colid.rcid_type = RCIDT_ZONE;
        colid.rcid_val = psinfop->pr_zoneid;
    }

    if ((lcol = lcollection_find(&colid)) == NULL)
        return;

    /*
     * If the process is already being tracked, update the unscannable flag,
     * as determined by the caller, from the process's psinfo.
     */
    lproc = lcol->lcol_lprocess;
    while (lproc != NULL) {
        if (lproc->lpc_pid == pid) {
            lproc->lpc_mark = 1;
            if (unscannable != 0 && lproc->lpc_unscannable == 0) {
                debug("process %d: became unscannable\n",
                    (int)lproc->lpc_pid);
                lproc->lpc_unscannable = 1;
            }
            return;
        }
        lproc = lproc->lpc_next;
    }

    /*
     * We've fallen off the list without finding our current process;
     * insert it at the list head.
     */
    if ((lproc = malloc(sizeof (*lproc))) == NULL)
        debug("insufficient memory to track new process %d", (int)pid);
    else {
        (void) bzero(lproc, sizeof (*lproc));
        lproc->lpc_pid = pid;
        lproc->lpc_mark = 1;
        lproc->lpc_collection = lcol;
        lproc->lpc_psinfo_fd = -1;
        lproc->lpc_pgdata_fd = -1;
        lproc->lpc_xmap_fd = -1;

        /*
         * If the caller didn't flag this process as unscannable
         * already, do some more checking.
         */
        lproc->lpc_unscannable = unscannable || proc_issystem(pid);

#ifdef DEBUG
        /*
         * Verify the sanity of lprocess.  It should not contain the
         * process we are about to prepend.
         */
        if (lcollection_member(lcol, lproc)) {
            lprocess_t *cur = lcol->lcol_lprocess;
            debug("The collection %lld already has these members, "
                "including me, %d!\n",
                (long long)lcol->lcol_id.rcid_val,
                (int)lproc->lpc_pid);
            while (cur != NULL) {
                debug("\t%d\n", (int)cur->lpc_pid);
                cur = cur->lpc_next;
            }
            info(gettext("process already on lprocess\n"));
            abort();
        }
#endif /* DEBUG */
        lproc->lpc_next = lcol->lcol_lprocess;
        if (lproc->lpc_next != NULL)
            lproc->lpc_next->lpc_prev = lproc;
        lproc->lpc_prev = NULL;
        lcol->lcol_lprocess = lproc;

        debug("tracking %s %ld %d %s%s\n",
            (colid.rcid_type == RCIDT_PROJECT ? "project" : "zone"),
            (long)colid.rcid_val,
            (int)pid, psinfop->pr_psargs,
            (lproc->lpc_unscannable != 0) ? " (not scannable)" : "");
        lcol->lcol_stat.lcols_proc_in++;
    }
}

static int
list_walk_process_cb(lcollection_t *lcol, void *arg)
{
    int (*cb)(lcollection_t *, lprocess_t *) =
        (int(*)(lcollection_t *, lprocess_t *))arg;
    lprocess_t *member;
    lprocess_t *next;

    member = lcol->lcol_lprocess;
    while (member != NULL) {
        pid_t pid = member->lpc_pid;
        next = member->lpc_next;

        debug_high("list_walk_all lpc %d\n", (int)pid);
        if (cb(lcol, member) != 0) {
            debug_high("list_walk_all aborted at lpc %d\n",
                (int)pid);
            return (1);
        }
        member = next;
    }

    return (0);
}

/*
 * Invoke the given callback for each process in each collection.  Callbacks
 * are allowed to change the linkage of the process on which they act.
 */
static void
list_walk_all(int (*cb)(lcollection_t *, lprocess_t *))
{
    list_walk_collection(list_walk_process_cb, (void *)cb);
}

static void
revoke_psinfo(rfd_t *rfd)
{
    lprocess_t *lpc = (lprocess_t *)rfd->rfd_data;

    if (lpc != NULL) {
        debug("revoking psinfo fd for process %d\n", (int)lpc->lpc_pid);
        ASSERT(lpc->lpc_psinfo_fd != -1);
        lpc->lpc_psinfo_fd = -1;
    } else
        debug("revoking psinfo fd for unknown process\n");
}

/*
 * Retrieve a process's psinfo via an already-opened or new file descriptor.
 * The supplied descriptor will be closed on failure.  An optional callback
 * will be invoked with the last descriptor tried, and a supplied callback
 * argument, as its arguments, such that the new descriptor may be cached, or
 * an old one may be invalidated.  If the result of the callback is zero, the
 * the caller is to assume responsibility for the file descriptor, to close it
 * with rfd_close().
 *
 * On failure, a nonzero value is returned.
 */
int
get_psinfo(pid_t pid, psinfo_t *psinfo, int cached_fd,
    int(*fd_update_cb)(void *, int), void *arg, lprocess_t *lpc)
{
    int fd;
    int can_try_uncached;

    ASSERT(!(cached_fd > 0 && fd_update_cb == NULL));

    do {
        if (cached_fd >= 0) {
            fd = cached_fd;
            can_try_uncached = 1;
            debug_high("%d/psinfo, trying cached fd %d\n",
                (int)pid, fd);
        } else {
            char pathbuf[PROC_PATH_MAX];

            can_try_uncached = 0;
            (void) snprintf(pathbuf, sizeof (pathbuf),
                "/proc/%d/psinfo", (int)pid);
            if ((fd = rfd_open(pathbuf, 1, RFD_PSINFO,
                revoke_psinfo, lpc, O_RDONLY, 0000)) < 0) {
                debug("cannot open %s", pathbuf);
                break;
            } else
                debug_high("opened %s, fd %d\n", pathbuf, fd);
        }

        if (pread(fd, psinfo, sizeof (*psinfo), 0) ==
            sizeof (*psinfo) && psinfo->pr_pid == pid)
            break;
        else {
            debug_high("closed fd %d\n", fd);
            if (rfd_close(fd) != 0)
                debug("could not close fd %d", fd);
            fd = cached_fd = -1;
        }
    } while (can_try_uncached == 1);

    if (fd_update_cb == NULL || fd_update_cb(arg, fd) != 0)
        if (fd >= 0) {
            debug_high("closed %s fd %d\n", fd_update_cb == NULL ?
                "uncached" : "cached", fd);
            if (rfd_close(fd) != 0)
                debug("could not close fd %d", fd);
        }

    debug_high("get_psinfo ret %d, fd %d, %s\n", ((fd >= 0) ? 0 : -1), fd,
        fd_update_cb != NULL ? "cached" : "uncached");
    return ((fd >= 0) ? 0 : -1);
}

/*
 * Retrieve the collection membership of all processes and update the psinfo of
 * those non-system, non-zombie ones in collections.  For global zone processes,
 * we first attempt to put the process into a capped project collection.  We
 * also want to track the process for the global zone collection as a whole.
 */
static void
proc_cb(const pid_t pid)
{
    psinfo_t psinfo;

    if (get_psinfo(pid, &psinfo, -1, NULL, NULL, NULL) == 0) {
        lprocess_insert_mark(&psinfo);
        if (gz_capped && psinfo.pr_zoneid == GLOBAL_ZONEID) {
            /*
             * We also want to track this process for the global
             * zone as a whole so add it to the global zone
             * collection as well.
             */
            psinfo.pr_projid = -1;
            lprocess_insert_mark(&psinfo);
        }
    }
}

/*
 * Cache the process' psinfo fd, taking responsibility for freeing it.
 */
int
lprocess_update_psinfo_fd_cb(void *arg, int fd)
{
    lprocess_t *lpc = arg;

    lpc->lpc_psinfo_fd = fd;
    return (0);
}

/*
 * Get the system pagesize.
 */
static void
get_page_size(void)
{
    page_size_kb = sysconf(_SC_PAGESIZE) / 1024;
    debug("physical page size: %luKB\n", page_size_kb);
}

static void
tm_fmt(char *msg, hrtime_t t1, hrtime_t t2)
{
    hrtime_t diff = t2 - t1;

    if (diff < MILLISEC)
        debug("%s: %lld nanoseconds\n", msg, diff);
    else if (diff < MICROSEC)
        debug("%s: %.2f microseconds\n", msg, (float)diff / MILLISEC);
    else if (diff < NANOSEC)
        debug("%s: %.2f milliseconds\n", msg, (float)diff / MICROSEC);
    else
        debug("%s: %.2f seconds\n", msg, (float)diff / NANOSEC);
}

/*
 * Get the zone's & project's RSS from the kernel.
 */
static void
rss_sample(boolean_t my_zone_only, uint_t col_types)
{
    size_t nres;
    size_t i;
    uint_t flags;
    hrtime_t t1, t2;

    if (my_zone_only) {
        flags = VMUSAGE_ZONE;
    } else {
        flags = 0;
        if (col_types & CAPPED_PROJECT)
            flags |= VMUSAGE_PROJECTS;
        if (col_types & CAPPED_ZONE && my_zoneid == GLOBAL_ZONEID)
            flags |= VMUSAGE_ALL_ZONES;
    }

    debug("vmusage sample flags 0x%x\n", flags);
    if (flags == 0)
        return;

again:
    /* try the current buffer to see if the list will fit */
    nres = vmu_vals_len;
    t1 = gethrtime();
    if (getvmusage(flags, my_zone_only ? 0 : rcfg.rcfg_rss_sample_interval,
        vmu_vals, &nres) != 0) {
        if (errno != EOVERFLOW) {
            warn(gettext("can't read RSS from kernel\n"));
            return;
        }
    }
    t2 = gethrtime();
    tm_fmt("getvmusage time", t1, t2);

    debug("kernel nres %lu\n", (ulong_t)nres);

    if (nres > vmu_vals_len) {
        /* array size is now too small, increase it and try again */
        free(vmu_vals);

        if ((vmu_vals = (vmusage_t *)calloc(nres,
            sizeof (vmusage_t))) == NULL) {
            warn(gettext("out of memory: could not read RSS from "
                "kernel\n"));
            vmu_vals_len = nvmu_vals = 0;
            return;
        }
        vmu_vals_len = nres;
        goto again;
    }

    nvmu_vals = nres;

    debug("vmusage_sample\n");
    for (i = 0; i < nvmu_vals; i++) {
        debug("%d: id: %d, type: 0x%x, rss_all: %llu (%lluKB), "
            "swap: %llu\n", (int)i, (int)vmu_vals[i].vmu_id,
            vmu_vals[i].vmu_type,
            (unsigned long long)vmu_vals[i].vmu_rss_all,
            (unsigned long long)vmu_vals[i].vmu_rss_all / 1024,
            (unsigned long long)vmu_vals[i].vmu_swap_all);
    }
}

static void
update_col_rss(lcollection_t *lcol)
{
    int i;

    lcol->lcol_rss = 0;
    lcol->lcol_image_size = 0;

    for (i = 0; i < nvmu_vals; i++) {
        if (vmu_vals[i].vmu_id != lcol->lcol_id.rcid_val)
            continue;

        if (vmu_vals[i].vmu_type == VMUSAGE_ZONE &&
            lcol->lcol_id.rcid_type != RCIDT_ZONE)
            continue;

        if (vmu_vals[i].vmu_type == VMUSAGE_PROJECTS &&
            lcol->lcol_id.rcid_type != RCIDT_PROJECT)
            continue;

        /* we found the right RSS entry, update the collection vals */
        lcol->lcol_rss = vmu_vals[i].vmu_rss_all / 1024;
        lcol->lcol_image_size = vmu_vals[i].vmu_swap_all / 1024;
        break;
    }
}

/*
 * Sample the collection RSS, updating the collection's statistics with the
 * results.  Also, sum the rss of all capped projects & return true if
 * the collection is over cap.
 */
static int
rss_sample_col_cb(lcollection_t *lcol, void *arg)
{
    int64_t excess;
    uint64_t rss;
    sample_col_arg_t *col_argp = (sample_col_arg_t *)arg;

    update_col_rss(lcol);

    lcol->lcol_stat.lcols_rss_sample++;
    rss = lcol->lcol_rss;
    excess = rss - lcol->lcol_rss_cap;
    if (excess > 0) {
        lcol->lcol_stat.lcols_rss_act_sum += rss;
        col_argp->sca_any_over_cap = B_TRUE;
        if (lcol->lcol_id.rcid_type == RCIDT_PROJECT)
            col_argp->sca_project_over_cap = B_TRUE;
    }
    lcol->lcol_stat.lcols_rss_sum += rss;

    if (lcol->lcol_stat.lcols_min_rss > rss)
        lcol->lcol_stat.lcols_min_rss = rss;
    if (lcol->lcol_stat.lcols_max_rss < rss)
        lcol->lcol_stat.lcols_max_rss = rss;

    return (0);
}

/*
 * Determine if we have capped projects, capped zones or both.
 */
static int
col_type_cb(lcollection_t *lcol, void *arg)
{
    uint_t *col_type = (uint_t *)arg;

    /* skip uncapped collections */
    if (lcol->lcol_rss_cap == 0)
        return (1);

    if (lcol->lcol_id.rcid_type == RCIDT_PROJECT)
        *col_type |= CAPPED_PROJECT;
    else
        *col_type |= CAPPED_ZONE;

    /* once we know everything is capped, we can stop looking */
    if ((*col_type & CAPPED_ZONE) && (*col_type & CAPPED_PROJECT))
        return (1);

    return (0);
}

/*
 * Open /proc and walk entries.
 */
static void
proc_walk_all(void (*cb)(const pid_t))
{
    DIR *pdir;
    struct dirent *dirent;
    pid_t pid;

    (void) rfd_reserve(1);
    if ((pdir = opendir("/proc")) == NULL)
        die(gettext("couldn't open /proc!"));

    while ((dirent = readdir(pdir)) != NULL) {
        if (strcmp(".", dirent->d_name) == 0 ||
            strcmp("..", dirent->d_name) == 0)
            continue;
        pid = atoi(dirent->d_name);
        ASSERT(pid != 0 || strcmp(dirent->d_name, "0") == 0);
        if (pid == rcapd_pid)
            continue;
        else
            cb(pid);
    }
    (void) closedir(pdir);
}

/*
 * Clear unmarked callback.
 */
/*ARGSUSED*/
static int
sweep_process_cb(lcollection_t *lcol, lprocess_t *lpc)
{
    if (lpc->lpc_mark) {
        lpc->lpc_mark = 0;
    } else {
        debug("process %d finished\n", (int)lpc->lpc_pid);
        lprocess_free(lpc);
    }

    return (0);
}

/*
 * Print, for debugging purposes, a collection's recently-sampled RSS and
 * excess.
 */
/*ARGSUSED*/
static int
excess_print_cb(lcollection_t *lcol, void *arg)
{
    int64_t excess = lcol->lcol_rss - lcol->lcol_rss_cap;

    debug("%s %s rss/cap: %llu/%llu, excess = %lld kB\n",
        (lcol->lcol_id.rcid_type == RCIDT_PROJECT ? "project" : "zone"),
        lcol->lcol_name,
        (unsigned long long)lcol->lcol_rss,
        (unsigned long long)lcol->lcol_rss_cap,
        (long long)excess);

    return (0);
}

/*
 * Scan those collections which have exceeded their caps.
 *
 * If we're running in the global zone it might have a cap.  We don't want to
 * do any capping for the global zone yet since we might get under the cap by
 * just capping the projects in the global zone.
 */
/*ARGSUSED*/
static int
scan_cb(lcollection_t *lcol, void *arg)
{
    int64_t excess;

    /* skip over global zone collection for now but keep track for later */
    if (lcol->lcol_id.rcid_type == RCIDT_ZONE &&
        lcol->lcol_id.rcid_val == GLOBAL_ZONEID) {
        gz_col = lcol;
        return (0);
    }

    if ((excess = lcol->lcol_rss - lcol->lcol_rss_cap) > 0) {
        scan(lcol, excess);
        lcol->lcol_stat.lcols_scan++;
    }

    return (0);
}

/*
 * Scan the global zone collection and see if it still exceeds its cap.
 * We take into account the effects of capping any global zone projects here.
 */
static void
scan_gz(lcollection_t *lcol, boolean_t project_over_cap)
{
    int64_t excess;

    /*
     * If we had projects over their cap and the global zone was also over
     * its cap then we need to get the up-to-date global zone rss to
     * determine if we are still over the global zone cap.  We might have
     * gone under while we scanned the capped projects.  If there were no
     * projects over cap then we can use the rss value we already have for
     * the global zone.
     */
    excess = lcol->lcol_rss - lcol->lcol_rss_cap;
    if (project_over_cap && excess > 0) {
        rss_sample(B_TRUE, CAPPED_ZONE);
        update_col_rss(lcol);
        excess = lcol->lcol_rss - lcol->lcol_rss_cap;
    }

    if (excess > 0) {
        debug("global zone excess %lldKB\n", (long long)excess);
        scan(lcol, excess);
        lcol->lcol_stat.lcols_scan++;
    }
}

/*
 * Do a soft scan of those collections which have excesses.  A soft scan is one
 * in which the cap enforcement pressure is taken into account.  The difference
 * between the utilized physical memory and the cap enforcement pressure will
 * be scanned-for, and each collection will be scanned proportionally by their
 * present excesses.
 */
static int
soft_scan_cb(lcollection_t *lcol, void *a)
{
    int64_t excess;
    soft_scan_arg_t *arg = a;

    /* skip over global zone collection for now but keep track for later */
    if (lcol->lcol_id.rcid_type == RCIDT_ZONE &&
        lcol->lcol_id.rcid_val == GLOBAL_ZONEID) {
        gz_col = lcol;
        return (0);
    }

    if ((excess = lcol->lcol_rss - lcol->lcol_rss_cap) > 0) {
        int64_t adjusted_excess =
            excess * arg->ssa_scan_goal / arg->ssa_sum_excess;

        debug("%s %ld excess %lld scan_goal %lld sum_excess %llu, "
            "scanning %lld\n",
            (lcol->lcol_id.rcid_type == RCIDT_PROJECT ?
            "project" : "zone"),
            (long)lcol->lcol_id.rcid_val,
            (long long)excess, (long long)arg->ssa_scan_goal,
            (unsigned long long)arg->ssa_sum_excess,
            (long long)adjusted_excess);

        scan(lcol, adjusted_excess);
        lcol->lcol_stat.lcols_scan++;
    }

    return (0);
}

static void
soft_scan_gz(lcollection_t *lcol, void *a)
{
    int64_t excess;
    soft_scan_arg_t *arg = a;

    /*
     * If we had projects over their cap and the global zone was also over
     * its cap then we need to get the up-to-date global zone rss to
     * determine if we are still over the global zone cap.  We might have
     * gone under while we scanned the capped projects.  If there were no
     * projects over cap then we can use the rss value we already have for
     * the global zone.
     */
    excess = lcol->lcol_rss - lcol->lcol_rss_cap;
    if (arg->ssa_project_over_cap && excess > 0) {
        rss_sample(B_TRUE, CAPPED_ZONE);
        update_col_rss(lcol);
        excess = lcol->lcol_rss - lcol->lcol_rss_cap;
    }

    if (excess > 0) {
        int64_t adjusted_excess =
            excess * arg->ssa_scan_goal / arg->ssa_sum_excess;

        debug("%s %ld excess %lld scan_goal %lld sum_excess %llu, "
            "scanning %lld\n",
            (lcol->lcol_id.rcid_type == RCIDT_PROJECT ?
            "project" : "zone"),
            (long)lcol->lcol_id.rcid_val,
            (long long)excess, (long long)arg->ssa_scan_goal,
            (unsigned long long)arg->ssa_sum_excess,
            (long long)adjusted_excess);

        scan(lcol, adjusted_excess);
        lcol->lcol_stat.lcols_scan++;
    }
}

/*
 * When a scan could happen, but caps aren't enforced tick the
 * lcols_unenforced_cap counter.
 */
/*ARGSUSED*/
static int
unenforced_cap_cb(lcollection_t *lcol, void *arg)
{
    lcol->lcol_stat.lcols_unenforced_cap++;

    return (0);
}

/*
 * Update the count of physically installed memory.
 */
static void
update_phys_total(void)
{
    uint64_t old_phys_total;

    old_phys_total = phys_total;
    phys_total = (uint64_t)sysconf(_SC_PHYS_PAGES) * page_size_kb;
    if (phys_total != old_phys_total)
        debug("physical memory%s: %lluM\n", (old_phys_total == 0 ?
            "" : " adjusted"), (unsigned long long)(phys_total / 1024));
}

/*
 * Unlink a process from its collection, updating relevant statistics, and
 * freeing its associated memory.
 */
void
lprocess_free(lprocess_t *lpc)
{
    pid_t pid;

    lpc->lpc_collection->lcol_stat.lcols_proc_out++;

    if (lpc->lpc_prev != NULL)
        lpc->lpc_prev->lpc_next = lpc->lpc_next;
    if (lpc->lpc_next != NULL)
        lpc->lpc_next->lpc_prev = lpc->lpc_prev;
    if (lpc->lpc_collection->lcol_lprocess == lpc)
        lpc->lpc_collection->lcol_lprocess = (lpc->lpc_next !=
            lpc ? lpc->lpc_next : NULL);
    lpc->lpc_next = lpc->lpc_prev = NULL;

    if (lpc->lpc_prpageheader != NULL)
        free(lpc->lpc_prpageheader);
    if (lpc->lpc_xmap != NULL)
        free(lpc->lpc_xmap);
    if (lpc->lpc_psinfo_fd >= 0) {
        if (rfd_close(lpc->lpc_psinfo_fd) != 0)
            debug("could not close %d lpc_psinfo_fd %d",
                (int)lpc->lpc_pid, lpc->lpc_psinfo_fd);
        lpc->lpc_psinfo_fd = -1;
    }
    if (lpc->lpc_pgdata_fd >= 0) {
        if (rfd_close(lpc->lpc_pgdata_fd) != 0)
            debug("could not close %d lpc_pgdata_fd %d",
                (int)lpc->lpc_pid, lpc->lpc_pgdata_fd);
        lpc->lpc_pgdata_fd = -1;
    }
    if (lpc->lpc_xmap_fd >= 0) {
        if (rfd_close(lpc->lpc_xmap_fd) != 0)
            debug("could not close %d lpc_xmap_fd %d",
                (int)lpc->lpc_pid, lpc->lpc_xmap_fd);
        lpc->lpc_xmap_fd = -1;
    }
    if (lpc->lpc_ignore != NULL)
        lmapping_free(&lpc->lpc_ignore);
    pid = lpc->lpc_pid;
    free(lpc);
    debug_high("process %d freed\n", (int)pid);
}

/*
 * Collection clear callback.
 */
/*ARGSUSED*/
static int
collection_clear_cb(lcollection_t *lcol, void *arg)
{
    lcol->lcol_mark = 0;

    return (0);
}

/*
 * Respond to a terminating signal by setting a termination flag.
 */
/*ARGSUSED*/
static void
terminate_signal(int signal)
{
    if (termination_signal == 0)
        termination_signal = signal;
    should_run = 0;
}

/*
 * Handle any synchronous or asynchronous signals that would ordinarily cause a
 * process to abort.
 */
/*ARGSUSED*/
static void
abort_signal(int signal)
{
    /*
     * Allow the scanner to make a last-ditch effort to resume any stopped
     * processes.
     */
    scan_abort();
    abort();
}

/*
 * Clean up collections which have been removed due to configuration.  Unlink
 * the collection from lcollection and free it.
 */
/*ARGSUSED*/
static int
collection_sweep_cb(lcollection_t *lcol, void *arg)
{
    if (lcol->lcol_mark == 0) {
        debug("freeing %s %s\n",
            (lcol->lcol_id.rcid_type == RCIDT_PROJECT ?
            "project" : "zone"), lcol->lcol_name);
        lcollection_free(lcol);
    }

    return (0);
}

/*
 * Set those variables which depend on the global configuration.
 */
static void
finish_configuration(void)
{
    /*
     * Warn that any lnode (or non-project) mode specification (by an SRM
     * 1.3 configuration file, for example) is ignored.
     */
    if (strcmp(rcfg.rcfg_mode_name, "project") != 0) {
        warn(gettext("%s mode specification ignored -- using project"
            " mode\n"), rcfg.rcfg_mode_name);
        rcfg.rcfg_mode_name = "project";
        rcfg.rcfg_mode = rctype_project;
    }
}

/*
 * Cause the configuration to be reread and applied.
 */
static void
reread_configuration(void)
{
    rcfg_t rcfg_new;

    if (rcfg_read(&rcfg_new, update_statistics) != E_SUCCESS) {
        warn(gettext("can't reread configuration \n"));
        exit(SMF_EXIT_ERR_CONFIG);
    } else {
        /*
         * Done reading configuration.  Remove existing
         * collections in case there is a change in collection type.
         */
        if (rcfg.rcfg_mode != rcfg_new.rcfg_mode) {
            list_walk_collection(collection_clear_cb, NULL);
            list_walk_collection(collection_sweep_cb, NULL);
        }

        /*
         * Make the newly-read configuration the global one, and update
         * any variables that depend on it.
         */
        rcfg = rcfg_new;
        finish_configuration();
    }
}

/*
 * First, examine changes, additions, and deletions to cap definitions.
 * Then, set the next event time.
 */
static void
reconfigure(hrtime_t now, hrtime_t *next_configuration,
    hrtime_t *next_proc_walk, hrtime_t *next_rss_sample)
{
    debug("reconfigure...\n");

    /*
     * Walk the lcollection, marking active collections so inactive ones
     * can be freed.
     */
    list_walk_collection(collection_clear_cb, NULL);
    lcollection_update(LCU_ACTIVE_ONLY); /* mark */
    list_walk_collection(collection_sweep_cb, NULL);

    *next_configuration = NEXT_EVENT_TIME(now,
        rcfg.rcfg_reconfiguration_interval);

    /*
     * Reset each event time to the shorter of the previous and new
     * intervals.
     */
    if (next_report == 0 && rcfg.rcfg_report_interval > 0)
        next_report = now;
    else
        next_report = POSITIVE_MIN(next_report,
            NEXT_REPORT_EVENT_TIME(now, rcfg.rcfg_report_interval));

    if (*next_proc_walk == 0 && rcfg.rcfg_proc_walk_interval > 0)
        *next_proc_walk = now;
    else
        *next_proc_walk = POSITIVE_MIN(*next_proc_walk,
            NEXT_EVENT_TIME(now, rcfg.rcfg_proc_walk_interval));

    if (*next_rss_sample == 0 && rcfg.rcfg_rss_sample_interval > 0)
        *next_rss_sample = now;
    else
        *next_rss_sample = POSITIVE_MIN(*next_rss_sample,
            NEXT_EVENT_TIME(now, rcfg.rcfg_rss_sample_interval));
}

/*
 * Respond to SIGHUP by triggering the rereading the configuration and cap
 * definitions.
 */
/*ARGSUSED*/
static void
sighup(int signal)
{
    should_reconfigure = 1;
}

/*
 * Print, for debugging purposes, each collection's interval statistics.
 */
/*ARGSUSED*/
static int
simple_report_collection_cb(lcollection_t *lcol, void *arg)
{
#define DELTA(field) \
    (unsigned long long)( \
        (lcol->lcol_stat.field - lcol->lcol_stat_old.field))

    debug("%s %s status: succeeded/attempted (k): %llu/%llu, "
        "ineffective/scans/unenforced/samplings:  %llu/%llu/%llu/%llu, RSS "
        "min/max (k): %llu/%llu, cap %llu kB, processes/thpt: %llu/%llu, "
        "%llu scans over %llu ms\n",
        (lcol->lcol_id.rcid_type == RCIDT_PROJECT ? "project" : "zone"),
        lcol->lcol_name,
        DELTA(lcols_pg_eff), DELTA(lcols_pg_att),
        DELTA(lcols_scan_ineffective), DELTA(lcols_scan),
        DELTA(lcols_unenforced_cap), DELTA(lcols_rss_sample),
        (unsigned long long)lcol->lcol_stat.lcols_min_rss,
        (unsigned long long)lcol->lcol_stat.lcols_max_rss,
        (unsigned long long)lcol->lcol_rss_cap,
        (unsigned long long)(lcol->lcol_stat.lcols_proc_in -
        lcol->lcol_stat.lcols_proc_out), DELTA(lcols_proc_out),
        DELTA(lcols_scan_count),
        NSEC2MSEC(DELTA(lcols_scan_time_complete)));

#undef DELTA

    return (0);
}

/*
 * Record each collection's interval statistics in the statistics file.
 */
static int
report_collection_cb(lcollection_t *lcol, void *arg)
{
    lcollection_report_t dc;
    int fd = (intptr_t)arg;

    /*
     * Copy the relevant fields to the collection's record.
     */
    bzero(&dc, sizeof (dc));
    dc.lcol_id = lcol->lcol_id;
    (void) strcpy(dc.lcol_name, lcol->lcol_name);
    dc.lcol_rss = lcol->lcol_rss;
    dc.lcol_image_size = lcol->lcol_image_size;
    dc.lcol_rss_cap = lcol->lcol_rss_cap;
    dc.lcol_stat = lcol->lcol_stat;

    if (write(fd, &dc, sizeof (dc)) == sizeof (dc)) {
        lcol->lcol_stat_old = lcol->lcol_stat;
    } else {
        debug("can't write %s %s statistics",
            (lcol->lcol_id.rcid_type == RCIDT_PROJECT ?
            "project" : "zone"),
            lcol->lcol_name);
    }

    return (0);
}

/*
 * Determine the count of pages scanned by the global page scanner, obtained
 * from the cpu_stat:*::scan kstats.  Return zero on success.
 */
static int
get_globally_scanned_pages(uint64_t *scannedp)
{
    kstat_t *ksp;
    uint64_t scanned = 0;

    if (kstat_chain_update(kctl) == -1) {
        warn(gettext("can't update kstat chain"));
        return (0);
    }

    for (ksp = kctl->kc_chain; ksp != NULL; ksp = ksp->ks_next) {
        if (strcmp(ksp->ks_module, "cpu_stat") == 0) {
            if (kstat_read(kctl, ksp, NULL) != -1) {
                scanned += ((cpu_stat_t *)
                    ksp->ks_data)->cpu_vminfo.scan;
            } else {
                return (-1);
            }
        }
    }

    *scannedp = scanned;
    return (0);
}

/*
 * Determine if the global page scanner is running, during which no memory
 * caps should be enforced, to prevent interference with the global page
 * scanner.
 */
static boolean_t
is_global_scanner_running()
{
    /* measure delta in page scan count */
    static uint64_t new_sp = 0;
    static uint64_t old_sp = 0;
    boolean_t res = B_FALSE;

    if (get_globally_scanned_pages(&new_sp) == 0) {
        if (old_sp != 0 && (new_sp - old_sp) > 0) {
            debug("global memory pressure detected (%llu "
                "pages scanned since last interval)\n",
                (unsigned long long)(new_sp - old_sp));
            res = B_TRUE;
        }
        old_sp = new_sp;
    } else {
        warn(gettext("unable to read cpu statistics"));
        new_sp = old_sp;
    }

    return (res);
}

/*
 * If soft caps are in use, determine if global memory pressure exceeds the
 * configured maximum above which soft caps are enforced.
 */
static boolean_t
must_enforce_soft_caps()
{
    /*
     * Check for changes to the amount of installed physical memory, to
     * compute the current memory pressure.
     */
    update_phys_total();

    memory_pressure = 100 - (int)((sysconf(_SC_AVPHYS_PAGES) * page_size_kb)
        * 100.0 / phys_total);
    memory_pressure_sample++;
    if (rcfg.rcfg_memory_cap_enforcement_pressure > 0 &&
        memory_pressure > rcfg.rcfg_memory_cap_enforcement_pressure) {
        return (B_TRUE);
    }

    return (B_FALSE);
}

/*
 * Update the shared statistics file with each collection's current statistics.
 * Return zero on success.
 */
static int
update_statistics(void)
{
    int fd, res;
    static char template[LINELEN];

    /*
     * Try to create a directory irrespective of whether it is existing
     * or not. If it is not there then it will create. Otherwise any way
     * it will fail at mkstemp call below.
     */
    (void) mkdir(STAT_FILE_DIR, 0755);

    /*
     * Create a temporary file.
     */
    if (sizeof (template) < (strlen(rcfg.rcfg_stat_file) +
        strlen(STAT_TEMPLATE_SUFFIX) + 1)) {
        debug("temporary file template size too small\n");
        return (-1);
    }
    (void) strcpy(template, rcfg.rcfg_stat_file);
    (void) strcat(template, STAT_TEMPLATE_SUFFIX);
    (void) rfd_reserve(1);
    fd = mkstemp(template);

    /*
     * Write the header and per-collection statistics.
     */
    if (fd >= 0) {
        rcapd_stat_hdr_t rs;

        rs.rs_pid = rcapd_pid;
        rs.rs_time = gethrtime();
        ASSERT(sizeof (rs.rs_mode) > strlen(rcfg.rcfg_mode_name));
        (void) strcpy(rs.rs_mode, rcfg.rcfg_mode_name);
        rs.rs_pressure_cur = memory_pressure;
        rs.rs_pressure_cap = rcfg.rcfg_memory_cap_enforcement_pressure;
        rs.rs_pressure_sample = memory_pressure_sample;

        if (fchmod(fd, 0644) == 0 && write(fd, &rs, sizeof (rs)) ==
            sizeof (rs)) {
            list_walk_collection(report_collection_cb,
                (void *)(intptr_t)fd);
            /*
             * Replace the existing statistics file with this new
             * one.
             */
            res = rename(template, rcfg.rcfg_stat_file);
        } else
            res = -1;
        (void) close(fd);
    } else
        res = -1;

    return (res);
}

/*
 * Verify the statistics file can be created and written to, and die if an
 * existing file may be in use by another rcapd.
 */
static int
verify_statistics(void)
{
    pid_t pid;

    /*
     * Warn if another instance of rcapd might be active.
     */
    (void) rfd_reserve(1);
    pid = stat_get_rcapd_pid(rcfg.rcfg_stat_file);
    if (pid != rcapd_pid && pid != -1)
        die(gettext("%s exists; rcapd may already be active\n"),
            rcfg.rcfg_stat_file);

    return (update_statistics());
}

static int
sum_excess_cb(lcollection_t *lcol, void *arg)
{
    uint64_t *sum_excess = arg;

    *sum_excess += MAX((int64_t)0, (int64_t)(lcol->lcol_rss -
        lcol->lcol_rss_cap));
    return (0);
}

/*
 * Compute the quantity of memory (in kilobytes) above the cap enforcement
 * pressure.  Set the scan goal to that quantity (or at most the excess).
 */
static void
compute_soft_scan_goal(soft_scan_arg_t *argp)
{
    /*
     * Compute the sum of the collections' excesses, which will be the
     * denominator.
     */
    argp->ssa_sum_excess = 0;
    list_walk_collection(sum_excess_cb, &(argp->ssa_sum_excess));

    argp->ssa_scan_goal = MIN((sysconf(_SC_PHYS_PAGES) *
        (100 - rcfg.rcfg_memory_cap_enforcement_pressure) / 100 -
        sysconf(_SC_AVPHYS_PAGES)) * page_size_kb,
        argp->ssa_sum_excess);
}

static void
rcapd_usage(void)
{
    info(gettext("usage: rcapd [-d]\n"));
}

void
check_update_statistics(void)
{
    hrtime_t now = gethrtime();

    if (EVENT_TIME(now, next_report)) {
        debug("updating statistics...\n");
        list_walk_collection(simple_report_collection_cb, NULL);
        if (update_statistics() != 0)
            debug("couldn't update statistics");
        next_report = NEXT_REPORT_EVENT_TIME(now,
            rcfg.rcfg_report_interval);
    }
}

static void
verify_and_set_privileges(void)
{
    priv_set_t *required =
        priv_str_to_set("zone,sys_resource,proc_owner", ",", NULL);

    /*
     * Ensure the required privileges, suitable for controlling processes,
     * are possessed.
     */
    if (setppriv(PRIV_SET, PRIV_PERMITTED, required) != 0 || setppriv(
        PRIV_SET, PRIV_EFFECTIVE, required) != 0)
        die(gettext("can't set requisite privileges"));

    /*
     * Ensure access to /var/run/daemon.
     */
    if (setreuid(DAEMON_UID, DAEMON_UID) != 0)
        die(gettext("cannot become user daemon"));

    priv_freeset(required);
}

/*
 * This function does the top-level work to determine if we should do any
 * memory capping, and if so, it invokes the right call-backs to do the work.
 */
static void
do_capping(hrtime_t now, hrtime_t *next_proc_walk)
{
    boolean_t enforce_caps;
    /* soft cap enforcement flag, depending on memory pressure */
    boolean_t enforce_soft_caps;
    /* avoid interference with kernel's page scanner */
    boolean_t global_scanner_running;
    sample_col_arg_t col_arg;
    soft_scan_arg_t arg;
    uint_t col_types = 0;

    /* check what kind of collections (project/zone) are capped */
    list_walk_collection(col_type_cb, &col_types);
    debug("collection types: 0x%x\n", col_types);

    /* no capped collections, skip checking rss */
    if (col_types == 0)
        return;

    /* Determine if soft caps are enforced. */
    enforce_soft_caps = must_enforce_soft_caps();

    /* Determine if the global page scanner is running. */
    global_scanner_running = is_global_scanner_running();

    /*
     * Sample collections' member processes RSSes and recompute
     * collections' excess.
     */
    rss_sample(B_FALSE, col_types);

    col_arg.sca_any_over_cap = B_FALSE;
    col_arg.sca_project_over_cap = B_FALSE;
    list_walk_collection(rss_sample_col_cb, &col_arg);
    list_walk_collection(excess_print_cb, NULL);
    debug("any collection/project over cap = %d, %d\n",
        col_arg.sca_any_over_cap, col_arg.sca_project_over_cap);

    if (enforce_soft_caps)
        debug("memory pressure %d%%\n", memory_pressure);

    /*
     * Cap enforcement is determined by the previous conditions.
     */
    enforce_caps = !global_scanner_running && col_arg.sca_any_over_cap &&
        (rcfg.rcfg_memory_cap_enforcement_pressure == 0 ||
        enforce_soft_caps);

    debug("%senforcing caps\n", enforce_caps ? "" : "not ");

    /*
     * If soft caps are in use, determine the size of the portion from each
     * collection to scan for.
     */
    if (enforce_caps && enforce_soft_caps)
        compute_soft_scan_goal(&arg);

    /*
     * Victimize offending collections.
     */
    if (enforce_caps && (!enforce_soft_caps ||
        (arg.ssa_scan_goal > 0 && arg.ssa_sum_excess > 0))) {

        /*
         * Since at least one collection is over its cap & needs
         * enforcing, check if it is at least time for a process walk
         * (we could be well past time since we only walk /proc when
         * we need to) and if so, update each collections process list
         * in a single pass through /proc.
         */
        if (EVENT_TIME(now, *next_proc_walk)) {
            debug("scanning process list...\n");
            proc_walk_all(proc_cb);      /* insert & mark */
            list_walk_all(sweep_process_cb); /* free dead procs */
            *next_proc_walk = NEXT_EVENT_TIME(now,
                rcfg.rcfg_proc_walk_interval);
        }

        gz_col = NULL;
        if (enforce_soft_caps) {
            debug("scan goal is %lldKB\n",
                (long long)arg.ssa_scan_goal);
            list_walk_collection(soft_scan_cb, &arg);
            if (gz_capped && gz_col != NULL) {
                /* process global zone */
                arg.ssa_project_over_cap =
                    col_arg.sca_project_over_cap;
                soft_scan_gz(gz_col, &arg);
            }
        } else {
            list_walk_collection(scan_cb, NULL);
            if (gz_capped && gz_col != NULL) {
                /* process global zone */
                scan_gz(gz_col, col_arg.sca_project_over_cap);
            }
        }
    } else if (col_arg.sca_any_over_cap) {
        list_walk_collection(unenforced_cap_cb, NULL);
    }
}

int
main(int argc, char *argv[])
{
    int res;
    int should_fork = 1;    /* fork flag */
    hrtime_t now;       /* current time */
    hrtime_t next;      /* time of next event */
    int sig;        /* signal iteration */
    struct rlimit rl;
    hrtime_t next_proc_walk;    /* time of next /proc scan */
    hrtime_t next_configuration;    /* time of next configuration */
    hrtime_t next_rss_sample;   /* (latest) time of next RSS sample */

    (void) set_message_priority(RCM_INFO);
    (void) setpname("rcapd");
    rcapd_pid = getpid();
    (void) chdir("/");
    should_run = 1;
    ever_ran = 0;

    (void) setlocale(LC_ALL, "");
    (void) textdomain(TEXT_DOMAIN);

    /*
     * Parse command-line options.
     */
    while ((res = getopt(argc, argv, "dF")) > 0)
        switch (res) {
        case 'd':
            should_fork = 0;
            if (debug_mode == 0) {
                debug_mode = 1;
                (void) set_message_priority(RCM_DEBUG);
            } else
                (void) set_message_priority(RCM_DEBUG_HIGH);
            break;
        case 'F':
            should_fork = 0;
            break;
        default:
            rcapd_usage();
            return (E_USAGE);
            /*NOTREACHED*/
        }

    /*
     * Read the configuration.
     */
    if (rcfg_read(&rcfg, verify_statistics) != E_SUCCESS) {
        warn(gettext("resource caps not configured\n"));
        return (SMF_EXIT_ERR_CONFIG);
    }

    /*
     * If not debugging, fork and continue operating, changing the
     * destination of messages to syslog().
     */
    if (should_fork == 1) {
        pid_t child;
        debug("forking\n");
        child = fork();
        if (child == -1)
            die(gettext("cannot fork"));
        if (child > 0)
            return (0);
        else {
            rcapd_pid = getpid();
            (void) set_message_destination(RCD_SYSLOG);
            (void) fclose(stdin);
            (void) fclose(stdout);
            (void) fclose(stderr);
        }
        /*
         * Start a new session and detatch from the controlling tty.
         */
        if (setsid() == (pid_t)-1)
            debug(gettext("setsid() failed; cannot detach from "
                "terminal"));
    }

    finish_configuration();
    should_reconfigure = 0;

    /*
     * Check that required privileges are possessed.
     */
    verify_and_set_privileges();

    now = next_report = next_proc_walk = next_rss_sample = gethrtime();
    next_configuration = NEXT_EVENT_TIME(gethrtime(),
        rcfg.rcfg_reconfiguration_interval);

    /*
     * Open the kstat chain.
     */
    kctl = kstat_open();
    if (kctl == NULL)
        die(gettext("can't open kstats"));

    /*
     * Set RLIMIT_NOFILE as high as practical, so roughly 10K processes can
     * be effectively managed without revoking descriptors (at 3 per
     * process).
     */
    rl.rlim_cur = 32 * 1024;
    rl.rlim_max = 32 * 1024;
    if (setrlimit(RLIMIT_NOFILE, &rl) != 0 &&
        getrlimit(RLIMIT_NOFILE, &rl) == 0) {
        rl.rlim_cur = rl.rlim_max;
        (void) setrlimit(RLIMIT_NOFILE, &rl);
    }
    (void) enable_extended_FILE_stdio(-1, -1);

    if (getrlimit(RLIMIT_NOFILE, &rl) == 0)
        debug("fd limit: %lu\n", rl.rlim_cur);
    else
        debug("fd limit: unknown\n");

    get_page_size();
    my_zoneid = getzoneid();

    /*
     * Handle those signals whose (default) exit disposition
     * prevents rcapd from finishing scanning before terminating.
     */
    (void) sigset(SIGINT, terminate_signal);
    (void) sigset(SIGQUIT, abort_signal);
    (void) sigset(SIGILL, abort_signal);
    (void) sigset(SIGEMT, abort_signal);
    (void) sigset(SIGFPE, abort_signal);
    (void) sigset(SIGBUS, abort_signal);
    (void) sigset(SIGSEGV, abort_signal);
    (void) sigset(SIGSYS, abort_signal);
    (void) sigset(SIGPIPE, terminate_signal);
    (void) sigset(SIGALRM, terminate_signal);
    (void) sigset(SIGTERM, terminate_signal);
    (void) sigset(SIGUSR1, terminate_signal);
    (void) sigset(SIGUSR2, terminate_signal);
    (void) sigset(SIGPOLL, terminate_signal);
    (void) sigset(SIGVTALRM, terminate_signal);
    (void) sigset(SIGXCPU, abort_signal);
    (void) sigset(SIGXFSZ, abort_signal);
    for (sig = SIGRTMIN; sig <= SIGRTMAX; sig++)
        (void) sigset(sig, terminate_signal);

    /*
     * Install a signal handler for reconfiguration processing.
     */
    (void) sigset(SIGHUP, sighup);

    /*
     * Determine which process collections to cap.
     */
    lcollection_update(LCU_COMPLETE);

    /*
     * Loop forever, monitoring collections' resident set sizes and
     * enforcing their caps.  Look for changes in caps as well as
     * responding to requests to reread the configuration.  Update
     * per-collection statistics periodically.
     */
    while (should_run != 0) {
        struct timespec ts;

        /*
         * Announce that rcapd is starting.
         */
        if (ever_ran == 0) {
            info(gettext("starting\n"));
            ever_ran = 1;
        }

        /*
         * Check the configuration at every next_configuration interval.
         * Update the rss data once every next_rss_sample interval.
         * The condition of global memory pressure is also checked at
         * the same frequency, if strict caps are in use.
         */
        now = gethrtime();

        /*
         * Detect configuration and cap changes only when SIGHUP
         * is received. Call reconfigure to apply new configuration
         * parameters.
         */
        if (should_reconfigure == 1) {
            reread_configuration();
            should_reconfigure = 0;
            reconfigure(now, &next_configuration, &next_proc_walk,
                &next_rss_sample);
        }

        if (EVENT_TIME(now, next_configuration)) {
            reconfigure(now, &next_configuration, &next_proc_walk,
                &next_rss_sample);
        }

        /*
         * Do the main work for enforcing caps.
         */
        if (EVENT_TIME(now, next_rss_sample)) {
            do_capping(now, &next_proc_walk);

            next_rss_sample = NEXT_EVENT_TIME(now,
                rcfg.rcfg_rss_sample_interval);
        }

        /*
         * Update the statistics file, if it's time.
         */
        check_update_statistics();

        /*
         * Sleep for some time before repeating.
         */
        now = gethrtime();
        next = next_configuration;
        next = POSITIVE_MIN(next, next_report);
        next = POSITIVE_MIN(next, next_rss_sample);
        if (next > now && should_run != 0) {
            debug("sleeping %-4.2f seconds\n", (float)(next -
                now) / (float)NANOSEC);
            hrt2ts(next - now, &ts);
            (void) nanosleep(&ts, NULL);
        }
    }
    if (termination_signal != 0)
        debug("exiting due to signal %d\n", termination_signal);
    if (ever_ran != 0)
        info(gettext("exiting\n"));

    /*
     * Unlink the statistics file before exiting.
     */
    if (rcfg.rcfg_stat_file[0] != 0)
        (void) unlink(rcfg.rcfg_stat_file);

    return (E_SUCCESS);
}