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);
}
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;
}
int main (void)
{
rctlblk_t *old_rblk;
rctlblk_t *new_rblk;
char *name = "process.max-file-descriptor";
int fd;
if (((old_rblk = malloc (rctlblk_size ())) == NULL) ||
((new_rblk = malloc (rctlblk_size ())) == NULL))
err_msg ("malloc failed");
if (getrctl (name, NULL, old_rblk, RCTL_FIRST) == -1)
err_msg ("getrctl failed");
memcpy (new_rblk, old_rblk, rctlblk_size ());
printf ("Before...\n");
print_rctl (old_rblk);
rctlblk_set_value (new_rblk, 10);
rctlblk_set_local_action (new_rblk, RCTL_LOCAL_DENY | RCTL_LOCAL_SIGNAL,
SIGTERM);
if (setrctl (name, NULL, old_rblk, RCTL_DELETE) == -1)
err_msg ("setrctl (RCTL_DELETE) failed");
if (setrctl (name, NULL, new_rblk, RCTL_INSERT) == -1)
err_msg ("setrctl (RCTL_INSERT) failed");
if (getrctl (name, NULL, new_rblk, RCTL_FIRST) == -1)
err_msg ("getrctl failed");
printf ("After...\n");
print_rctl (new_rblk);
for (;;) {
fd = open ("/tmp", O_RDONLY);
printf ("Returned file descriptor = %d\n", fd);
}
}
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);
}