int os_uncore_stop(perf_ctl_t *ctl, perf_task_t *task)
{
task_uncore_t *t = (task_uncore_t *)task;
node_t *node;
int i;
if (t->nid >= 0) {
node = node_get(t->nid);
if (NODE_VALID(node)) {
if (node->qpi.qpi_num > 0)
pf_uncoreqpi_free(node);
if (node->imc.imc_num > 0)
pf_uncoreimc_free(node);
}
} else {
for (i = 0; i < NNODES_MAX; i++) {
node = node_get(i);
if (NODE_VALID(node)) {
if (node->qpi.qpi_num > 0)
pf_uncoreqpi_free(node);
if (node->imc.imc_num > 0)
pf_uncoreimc_free(node);
}
}
}
return 0;
}
/*
* Refresh the information of each node in group. The information
* includes such as: CPU, physical memory size, free memory size.
* Get the information from /sys/devices/system/node.
*/
int
node_group_refresh(boolean_t init)
{
int node_arr[NNODES_MAX];
int num, i, j, ret = -1;
node_t *node;
node_group_lock();
if (!os_sysfs_node_enum(node_arr, NNODES_MAX, &num)) {
goto L_EXIT;
}
for (i = 0; i < NNODES_MAX; i++) {
node = node_get(i);
if (NODE_VALID(node)) {
if ((j = nid_find(node->nid, node_arr, num)) == -1) {
node_hotremove(node);
s_node_group.nnodes--;
} else {
node_arr[j] = INVALID_NID;
}
}
}
for (i = 0; i < NNODES_MAX; i++) {
node = node_get(i);
if (!NODE_VALID(node)) {
if ((j = nid_find(i, node_arr, num)) >= 0) {
ASSERT(node_arr[j] == i);
if (init) {
node_init(node, i, B_FALSE);
} else {
node_init(node, i, B_TRUE);
}
s_node_group.nnodes++;
node_arr[j] = INVALID_NID;
}
}
}
if (cpu_refresh(init) != 0) {
goto L_EXIT;
}
if (meminfo_refresh() != 0) {
goto L_EXIT;
}
ret = 0;
L_EXIT:
node_group_unlock();
return (ret);
}
int
node_imc_init(void)
{
imc_info_t imc_tmp[NODE_IMC_MAX];
int imc_num, i;
node_t *node;
imc_num = os_sysfs_uncore_imc_init(imc_tmp, NODE_IMC_MAX);
if (imc_num < 0)
return -1;
node_group_lock();
for (i = 0; i < NNODES_MAX; i++) {
node = node_get(i);
if (NODE_VALID(node) && (imc_num > 0)) {
memcpy(node->imc.imc_info, imc_tmp,
sizeof(node->imc.imc_info));
node->imc.imc_num = imc_num;
}
}
node_group_unlock();
debug_print(NULL, 2, "%d memory controllers per node\n", imc_num);
return 0;
}
int
node_qpi_init(void)
{
qpi_info_t qpi_tmp[NODE_QPI_MAX];
int qpi_num, i;
node_t *node;
qpi_num = os_sysfs_uncore_qpi_init(qpi_tmp, NODE_QPI_MAX);
if (qpi_num < 0)
return -1;
if (qpi_num == 0) {
qpi_num = os_sysfs_uncore_upi_init(qpi_tmp, NODE_QPI_MAX);
if (qpi_num < 0)
return -1;
}
node_group_lock();
for (i = 0; i < NNODES_MAX; i++) {
node = node_get(i);
if (NODE_VALID(node) && (qpi_num > 0)) {
memcpy(node->qpi.qpi_info, qpi_tmp,
sizeof(node->qpi.qpi_info));
node->qpi.qpi_num = qpi_num;
}
}
node_group_unlock();
debug_print(NULL, 2, "%d QPI/UPI links per node\n", qpi_num);
return 0;
}
static uint64_t
countval_sum(count_value_t *countval_arr, int nid,
ui_count_id_t ui_count_id)
{
uint64_t value = 0;
node_t *node;
int i, cpuid, num = 0;
node = node_get(nid);
if (!NODE_VALID(node)) {
return (0);
}
for (i = 0; i < NCPUS_NODE_MAX; i++) {
if (num >= node->ncpus) {
break;
}
if ((cpuid = node->cpus[i].cpuid) != INVALID_CPUID) {
value += ui_perf_count_aggr(ui_count_id,
countval_arr[cpuid].counts);
num++;
}
}
return (value);
}
/*
* Get node by CPU id.
*/
node_t *
node_by_cpu(int cpuid)
{
node_t *node;
int i, j;
if (cpuid == INVALID_CPUID) {
return (NULL);
}
for (i = 0; i < NNODES_MAX; i++) {
node = node_get(i);
if (!NODE_VALID(node)) {
continue;
}
for (j = 0; j < NCPUS_NODE_MAX; j++) {
if (cpuid == node->cpus[j].cpuid) {
return (node);
}
}
}
return (NULL);
}
static int
cpu_refresh(boolean_t init)
{
int i, j, num, cpuid_max = -1;
int cpu_arr[NCPUS_NODE_MAX];
node_t *node;
for (i = 0; i < NNODES_MAX; i++) {
node = node_get(i);
if (NODE_VALID(node)) {
if (!os_sysfs_cpu_enum(node->nid, cpu_arr, NCPUS_NODE_MAX, &num)) {
return (-1);
}
if (os_perf_cpuarr_refresh(node->cpus, NCPUS_NODE_MAX, cpu_arr,
num, init) != 0) {
return (-1);
}
node->ncpus = num;
j = cpuid_max_get(cpu_arr, num);
if (cpuid_max < j) {
cpuid_max = j;
}
}
}
if (cpuid_max > s_node_group.cpuid_max) {
s_node_group.cpuid_max = cpuid_max;
}
/* Refresh the number of online CPUs */
g_ncpus = os_sysfs_online_ncpus();
return (0);
}
int
os_uncore_smpl(perf_ctl_t *ctl, perf_task_t *task, int *intval_ms)
{
task_uncore_t *t = (task_uncore_t *)task;
node_t *node;
int ret;
node = node_get(t->nid);
if (!NODE_VALID(node))
return -1;
ret = pf_uncoreqpi_smpl(node);
if (ret != 0) {
disp_profiling_data_fail();
return ret;
}
ret = pf_uncoreimc_smpl(node);
if (ret == 0)
disp_profiling_data_ready(*intval_ms);
else
disp_profiling_data_fail();
return (ret);
}
static int uncore_start(perf_ctl_t *ctl, int nid)
{
node_t *node;
int ret = -1;
node = node_get(nid);
if (!NODE_VALID(node))
return -1;
if (pf_uncoreqpi_setup(node) != 0)
goto L_EXIT;
if (pf_uncoreimc_setup(node) != 0)
goto L_EXIT;
if (pf_uncoreqpi_start(node) != 0)
goto L_EXIT;
if (pf_uncoreimc_start(node) != 0)
goto L_EXIT;
ret = 0;
L_EXIT:
if (ret < 0) {
pf_uncoreqpi_free(node);
pf_uncoreimc_free(node);
}
return ret;
}
/*
* Return the memory information for a specified node.
*/
void
node_meminfo(int nid, node_meminfo_t *info)
{
node_t *node;
if (((node = node_get(nid)) != NULL) &&
(NODE_VALID(node))) {
memcpy(info, &node->meminfo, sizeof (node_meminfo_t));
}
}
static int
meminfo_refresh(void)
{
int i;
node_t *node;
for (i = 0; i < NNODES_MAX; i++) {
node = node_get(i);
if (NODE_VALID(node)) {
if (!os_sysfs_meminfo(node->nid, &node->meminfo)) {
debug_print(NULL, 2, "meminfo_refresh:sysfs_meminfo failed\n");
return (-1);
}
}
}
return (0);
}
node_t *
node_valid_get(int node_idx)
{
int i, nvalid = 0;
node_t *node;
for (i = 0; i < NNODES_MAX; i++) {
node = node_get(i);
if (NODE_VALID(node)) {
if (node_idx == nvalid) {
return (node);
}
nvalid++;
}
}
return (NULL);
}
/*
* Walk through the CPUs in a node and call 'func()' for each CPU.
* The CPU might be INVALID. Note that the function could be only called
* in perf thread.
*/
int
node_cpu_traverse(pfn_perf_cpu_op_t func, void *arg, boolean_t err_ret,
pfn_perf_cpu_op_t hotadd_func)
{
node_t *node;
perf_cpu_t *cpu;
int i, j, ret;
for (i = 0; i < NNODES_MAX; i++) {
node = node_get(i);
if (!NODE_VALID(node)) {
continue;
}
for (j = 0; j < NCPUS_NODE_MAX; j++) {
cpu = &node->cpus[j];
if (cpu->hotremove) {
pf_resource_free(cpu);
cpu->hotremove = B_FALSE;
cpu->cpuid = INVALID_CPUID;
continue;
}
if ((cpu->hotadd) && (hotadd_func != NULL)) {
hotadd_func(cpu, arg);
cpu->hotadd = B_FALSE;
}
if ((func != NULL) && (cpu->cpuid != INVALID_CPUID) && (!cpu->hotadd)) {
if (((ret = func(cpu, arg)) != 0) && (err_ret)) {
return (ret);
}
}
}
if (node->hotremove) {
node->nid = INVALID_NID;
node->hotremove = B_FALSE;
}
}
return (0);
}
static int
uncore_stop_all(void)
{
node_t *node;
int i;
for (i = 0; i < NNODES_MAX; i++) {
node = node_get(i);
if (NODE_VALID(node)) {
if (node->qpi.qpi_num > 0)
pf_uncoreqpi_free(node);
if (node->imc.imc_num > 0)
pf_uncoreimc_free(node);
}
}
return 0;
}