static int
set_rctl(char *rctl, uint64_t value, rctl_priv_t priv)
{
rctlblk_t *oblk, *nblk;
boolean_t priv_deny = B_FALSE;
int priv_sig = 0;
if (value == LX_RLIM64_INFINITY)
value = get_rctl_max(rctl);
/*
* The brand library cannot use malloc(3C) so we allocate the space
* with SAFE_ALLOCA(). Thus there's no need to free it when we're done.
*/
oblk = (rctlblk_t *)SAFE_ALLOCA(rctlblk_size());
nblk = (rctlblk_t *)SAFE_ALLOCA(rctlblk_size());
if (getrctl(rctl, NULL, oblk, RCTL_FIRST) == -1)
return (-errno);
do {
if (rctlblk_get_privilege(oblk) == RCPRIV_PRIVILEGED &&
rctlblk_get_local_action(oblk, &priv_sig) & RCTL_LOCAL_DENY)
priv_deny = B_TRUE;
if (rctlblk_get_privilege(oblk) != priv)
continue;
/* we're already at this value, nothing to do */
if (rctlblk_get_value(oblk) == value)
return (0);
/* non-root cannot raise privileged limit */
if (priv == RCPRIV_PRIVILEGED && geteuid() != 0 &&
value > rctlblk_get_value(oblk))
return (-EPERM);
bcopy(oblk, nblk, rctlblk_size());
rctlblk_set_value(nblk, value);
if (setrctl(rctl, oblk, nblk, RCTL_REPLACE) == -1)
return (-errno);
return (0);
} while (getrctl(rctl, oblk, oblk, RCTL_NEXT) != -1);
/* not there, add it */
bzero(nblk, rctlblk_size());
rctlblk_set_value(nblk, value);
rctlblk_set_privilege(nblk, priv);
if (priv_deny) {
rctlblk_set_local_action(nblk, RCTL_LOCAL_DENY, 0);
} else {
rctlblk_set_local_action(nblk, RCTL_LOCAL_SIGNAL, priv_sig);
}
if (setrctl(rctl, NULL, nblk, RCTL_INSERT) == -1)
return (-errno);
return (0);
}
static uint64_t
get_zone_cap(zoneid_t zid)
{
rctlblk_t *rblk;
uint64_t mcap;
struct ps_prochandle *pr;
if ((rblk = (rctlblk_t *)malloc(rctlblk_size())) == NULL)
return (UINT64_MAX);
if ((pr = grab_zone_proc(zid)) == NULL) {
free(rblk);
return (UINT64_MAX);
}
if (pr_getrctl(pr, "zone.max-physical-memory", NULL, rblk,
RCTL_FIRST)) {
Pdestroy_agent(pr);
Prelease(pr, 0);
free(rblk);
return (UINT64_MAX);
}
Pdestroy_agent(pr);
Prelease(pr, 0);
mcap = rctlblk_get_value(rblk);
free(rblk);
return (mcap);
}
extern gboolean
port_class_init (void (*user_add_event) (gpointer, fnode_event_t*))
{
rctlblk_t *rblk;
FK_W ("%s\n", __func__);
if ((rblk = malloc (rctlblk_size ())) == NULL) {
FK_W ("[kernel] rblk malloc %s\n", g_strerror (errno));
return FALSE;
}
if (getrctl ("process.max-port-events", NULL, rblk, RCTL_FIRST) == -1) {
FK_W ("[kernel] getrctl %s\n", g_strerror (errno));
free (rblk);
return FALSE;
} else {
max_port_events = rctlblk_get_value(rblk);
FK_W ("[kernel] max_port_events = %u\n", max_port_events);
free (rblk);
}
if ((_obj_fen_hash = g_hash_table_new(g_direct_hash,
g_direct_equal)) == NULL) {
FK_W ("[kernel] fobj hash initializing faild\n");
return FALSE;
}
if ((g_eventq = g_queue_new ()) == NULL) {
FK_W ("[kernel] FEN global event queue initializing faild\n");
}
if (user_add_event == NULL) {
return FALSE;
}
add_event_cb = user_add_event;
return TRUE;
}
void
glibtop_get_shm_limits_p (glibtop *server, glibtop_shm_limits *buf)
{
#if GLIBTOP_SOLARIS_RELEASE < 51000
kvm_t * const kd = server->machine->kd;
glibtop_shm_limits sinfo;
memset (buf, 0, sizeof (glibtop_shm_limits));
if(!(server->sysdeps.shm_limits))
return;
if(kvm_read(kd, nlst[0].n_value, (void *)&sinfo,
sizeof(glibtop_shm_limits)) != sizeof(glibtop_shm_limits))
return;
buf->shmmax = sinfo.shmmax;
buf->shmmni = sinfo.shmmni;
#if GLIBTOP_SOLARIS_RELEASE < 50900
buf->shmmin = sinfo.shmmin;
buf->shmseg = sinfo.shmseg;
# endif
#endif
#if GLIBTOP_SOLARIS_RELEASE >= 51000
rctlblk_t *rblk;
if ((rblk = malloc(rctlblk_size())) == NULL)
return;
if (getrctl("project.max-shm-memory", NULL, rblk, RCTL_FIRST) == -1)
return;
else
buf->shmmax = rctlblk_get_value(rblk);
if (getrctl("project.max-shm-ids", NULL, rblk, RCTL_FIRST) == -1)
return;
else
buf->shmmni = rctlblk_get_value(rblk);
#endif
buf->flags = _glibtop_sysdeps_shm_limits;
}
static uint64_t
get_rctl_max(char *rctl)
{
rctlblk_t *rblk;
uint64_t inf;
/*
* The brand library cannot use malloc(3C) so we allocate the space
* with SAFE_ALLOCA(). Thus there's no need to free it when we're done.
*/
rblk = (rctlblk_t *)SAFE_ALLOCA(rctlblk_size());
if (getrctl(rctl, NULL, rblk, RCTL_FIRST) == -1)
return (-errno);
do {
switch (rctlblk_get_privilege(rblk)) {
case RCPRIV_BASIC:
case RCPRIV_PRIVILEGED:
inf = rctlblk_get_value(rblk);
if (rctlblk_get_local_flags(rblk) &
RCTL_LOCAL_MAXIMAL &&
rctlblk_get_global_flags(rblk) &
RCTL_GLOBAL_INFINITE)
return (inf);
break;
case RCPRIV_SYSTEM:
inf = rctlblk_get_value(rblk);
return (inf);
break;
}
} while (getrctl(rctl, rblk, rblk, RCTL_NEXT) != -1);
/* Somehow we have no max, use the Linux infinite value */
return (LX_RLIM64_INFINITY);
}
static int
get_rctlval(rctlblk_t *rblk, char *name, ulong_t limit, uint64_t *val)
{
rctl_qty_t r;
if (getrctl(name, NULL, rblk, RCTL_FIRST) == -1)
return (-errno);
r = rctlblk_get_value(rblk);
if (r > limit)
return (-EOVERFLOW);
*val = r;
return (0);
}
extern gboolean
port_class_init (void (*user_process_events_callback) (gpointer, node_event_t*))
{
rctlblk_t *rblk;
if ((rblk = malloc (rctlblk_size ())) == NULL) {
FK_W ("[kernel] rblk malloc %s\n", g_strerror (errno));
return FALSE;
}
if (getrctl ("process.max-port-events", NULL, rblk, RCTL_FIRST) == -1) {
FK_W ("[kernel] getrctl %s\n", g_strerror (errno));
free (rblk);
return FALSE;
} else {
max_port_events = rctlblk_get_value(rblk);
FK_W ("max_port_events = %u\n", max_port_events);
free (rblk);
}
renamed_hash = g_hash_table_new_full(g_direct_hash, g_direct_equal,
NULL, NULL);
if (renamed_hash == NULL) {
FK_W ("[kernel] FEN global renamed queue initializing faild\n");
return FALSE;
}
if ((g_eventq = g_queue_new ()) == NULL) {
FK_W ("[kernel] FEN global event queue initializing faild\n");
return FALSE;
}
if (user_process_events_callback == NULL) {
FK_W ("[kernel] FEN global no user_process_events_callback\n");
return FALSE;
}
user_process_events_cb = user_process_events_callback;
memset (&zero_wait, 0, sizeof (timespec_t));
pevents = g_malloc(PE_ALLOC * sizeof(port_event_t));
if (pevents == NULL) {
FK_W ("[kernel] FEN global alloc pevents failed\n");
return FALSE;
}
return TRUE;
}
static int
getrlimit_common(int resource, uint64_t *rlim_curp, uint64_t *rlim_maxp)
{
char *rctl;
rctlblk_t *rblk;
int64_t cur = -1;
boolean_t cur_inf = B_FALSE;
int64_t max = -1;
boolean_t max_inf = B_FALSE;
if (resource < 0 || resource >= LX_RLIMIT_NLIMITS)
return (-EINVAL);
rctl = l_to_rctl[resource];
if (rctl == NULL) {
switch (resource) {
case LX_RLIMIT_LOCKS:
case LX_RLIMIT_NICE:
case LX_RLIMIT_RTPRIO:
case LX_RLIMIT_RTTIME:
*rlim_maxp = fake_limits[resource].rlim_max;
*rlim_curp = fake_limits[resource].rlim_cur;
return (0);
default:
lx_unsupported("Unsupported resource type %d\n",
resource);
return (-ENOTSUP);
}
}
/*
* The brand library cannot use malloc(3C) so we allocate the space
* with SAFE_ALLOCA(). Thus there's no need to free it when we're done.
*/
rblk = (rctlblk_t *)SAFE_ALLOCA(rctlblk_size());
if (getrctl(rctl, NULL, rblk, RCTL_FIRST) == -1)
return (-errno);
do {
switch (rctlblk_get_privilege(rblk)) {
case RCPRIV_BASIC:
cur = rctlblk_get_value(rblk);
if (rctlblk_get_local_flags(rblk) &
RCTL_LOCAL_MAXIMAL &&
rctlblk_get_global_flags(rblk) &
RCTL_GLOBAL_INFINITE)
cur_inf = B_TRUE;
break;
case RCPRIV_PRIVILEGED:
max = rctlblk_get_value(rblk);
if (rctlblk_get_local_flags(rblk) &
RCTL_LOCAL_MAXIMAL &&
rctlblk_get_global_flags(rblk) &
RCTL_GLOBAL_INFINITE)
max_inf = B_TRUE;
break;
}
} while (getrctl(rctl, rblk, rblk, RCTL_NEXT) != -1);
/* Confirm we got values. For many rctls "basic" is not set. */
if (max == -1)
max = LX_RLIM64_INFINITY;
if (cur == -1)
cur = max;
if (cur_inf)
*rlim_curp = LX_RLIM64_INFINITY;
else
*rlim_curp = cur;
if (max_inf)
*rlim_maxp = LX_RLIM64_INFINITY;
else
*rlim_maxp = max;
return (0);
}
