bool
proc_probe(pid_t pid, int opt, proc_t * const pproc)
{
FUNC_BEGIN("%d,%d,%p", pid, opt, pproc);
assert(pproc);
if (pproc == NULL)
{
FUNC_RET("%d", false);
}
#ifdef HAVE_PROCFS
/* Grab preliminary information from procfs */
if (!check_procfs(pid))
{
WARNING("procfs entries missing or invalid");
FUNC_RET("%d", false);
}
char buffer[4096];
sprintf(buffer, PROCFS "/%d/stat", pid);
int fd = open(buffer, O_RDONLY);
if (fd < 0)
{
WARNING("procfs stat missing or unaccessable");
FUNC_RET("%d", false);
}
int len = read(fd, buffer, sizeof(buffer) - 1);
close(fd);
if (len < 0)
{
WARNING("failed to grab stat from procfs");
FUNC_RET("%d", false);
}
buffer[len] = '\0';
/* Extract interested information */
struct tms tm;
int offset = 0;
char * token = buffer;
do
{
switch (offset++)
{
case 0: /* pid */
sscanf(token, "%d", &pproc->pid);
break;
case 1: /* comm */
break;
case 2: /* state */
sscanf(token, "%c", &pproc->state);
break;
case 3: /* ppid */
sscanf(token, "%d", &pproc->ppid);
break;
case 4: /* pgrp */
case 5: /* session */
case 6: /* tty_nr */
case 7: /* tty_pgrp */
break;
case 8: /* flags */
sscanf(token, "%lu", &pproc->flags);
break;
case 9: /* min_flt */
sscanf(token, "%lu", &pproc->minflt);
break;
case 10: /* cmin_flt */
sscanf(token, "%lu", &pproc->cminflt);
break;
case 11: /* maj_flt */
sscanf(token, "%lu", &pproc->majflt);
break;
case 12: /* cmaj_flt */
sscanf(token, "%lu", &pproc->cmajflt);
break;
case 13: /* utime */
sscanf(token, "%lu", &tm.tms_utime);
break;
case 14: /* stime */
sscanf(token, "%lu", &tm.tms_stime);
break;
case 15: /* cutime */
sscanf(token, "%ld", &tm.tms_cutime);
break;
case 16: /* cstime */
sscanf(token, "%ld", &tm.tms_cstime);
break;
case 17: /* priority */
case 18: /* nice */
case 19: /* num_threads (since 2.6 kernel) */
case 20: /* it_real_value */
case 21: /* start_time */
break;
case 22: /* vsize */
sscanf(token, "%lu", &pproc->vsize);
break;
case 23: /* rss */
sscanf(token, "%ld", &pproc->rss);
break;
case 24: /* rlim_rss */
case 25: /* start_code */
sscanf(token, "%lu", &pproc->start_code);
break;
case 26: /* end_code */
sscanf(token, "%lu", &pproc->end_code);
break;
case 27: /* start_stack */
sscanf(token, "%lu", &pproc->start_stack);
break;
case 28: /* esp */
case 29: /* eip */
case 30: /* pending_signal */
case 31: /* blocked_signal */
case 32: /* sigign */
case 33: /* sigcatch */
case 34: /* wchan */
case 35: /* nswap */
case 36: /* cnswap */
case 37: /* exit_signal */
case 38: /* processor */
case 39: /* rt_priority */
case 40: /* policy */
default:
break;
}
} while (strsep(&token, " ") != NULL);
long CLK_TCK = sysconf(_SC_CLK_TCK);
#define TS_UPDATE_CLK(pts,clk) \
{{{ \
(pts)->tv_sec = ((time_t)((clk) / CLK_TCK)); \
(pts)->tv_nsec = (1000000000UL * ((clk) % (CLK_TCK)) / CLK_TCK ); \
}}} /* TS_UPDATE_CLK */
TS_UPDATE_CLK(&pproc->utime, tm.tms_utime);
TS_UPDATE_CLK(&pproc->stime, tm.tms_stime);
TS_UPDATE_CLK(&pproc->cutime, tm.tms_cutime);
TS_UPDATE_CLK(&pproc->cstime, tm.tms_cstime);
DBG("proc.pid % 10d", pproc->pid);
DBG("proc.ppid % 10d", pproc->ppid);
DBG("proc.state %c", pproc->state);
DBG("proc.flags 0x%016lx", pproc->flags);
DBG("proc.utime %010lu", ts2ms(pproc->utime));
DBG("proc.stime %010lu", ts2ms(pproc->stime));
DBG("proc.cutime % 10ld", ts2ms(pproc->cutime));
DBG("proc.cstime % 10ld", ts2ms(pproc->cstime));
DBG("proc.minflt %010lu", pproc->minflt);
DBG("proc.cminflt %010lu", pproc->cminflt);
DBG("proc.majflt %010lu", pproc->majflt);
DBG("proc.cmajflt %010lu", pproc->cmajflt);
DBG("proc.vsize %010lu", pproc->vsize);
DBG("proc.rss % 10ld", pproc->rss);
#else
#warning "proc_probe() requires procfs"
#endif /* HAVE_PROCFS */
trace_proxy_t __trace = TRACE_PROXY(pproc);
/* Inspect process registers */
if (opt & PROBE_REGS)
{
if (__trace(T_GETREGS, NULL, pproc) != 0)
{
FUNC_RET("%d", false);
}
#ifdef __x86_64__
DBG("regs.r15 0x%016lx", pproc->regs.r15);
DBG("regs.r14 0x%016lx", pproc->regs.r14);
DBG("regs.r13 0x%016lx", pproc->regs.r13);
DBG("regs.r12 0x%016lx", pproc->regs.r12);
DBG("regs.rbp 0x%016lx", pproc->regs.rbp);
DBG("regs.rbx 0x%016lx", pproc->regs.rbx);
DBG("regs.r11 0x%016lx", pproc->regs.r11);
DBG("regs.r10 0x%016lx", pproc->regs.r10);
DBG("regs.r9 0x%016lx", pproc->regs.r9);
DBG("regs.r8 0x%016lx", pproc->regs.r8);
DBG("regs.rax 0x%016lx", pproc->regs.rax);
DBG("regs.rcx 0x%016lx", pproc->regs.rcx);
DBG("regs.rdx 0x%016lx", pproc->regs.rdx);
DBG("regs.rsi 0x%016lx", pproc->regs.rsi);
DBG("regs.rdi 0x%016lx", pproc->regs.rdi);
DBG("regs.orig_rax 0x%016lx", pproc->regs.orig_rax);
DBG("regs.rip 0x%016lx", pproc->regs.rip);
DBG("regs.cs 0x%016lx", pproc->regs.cs);
DBG("regs.eflags 0x%016lx", pproc->regs.eflags);
DBG("regs.rsp 0x%016lx", pproc->regs.rsp);
DBG("regs.ss 0x%016lx", pproc->regs.ss);
DBG("regs.fs_base 0x%016lx", pproc->regs.fs_base);
DBG("regs.gs_base 0x%016lx", pproc->regs.gs_base);
DBG("regs.ds 0x%016lx", pproc->regs.ds);
DBG("regs.es 0x%016lx", pproc->regs.es);
DBG("regs.fs 0x%016lx", pproc->regs.fs);
DBG("regs.gs 0x%016lx", pproc->regs.gs);
#else /* __i386__ */
DBG("regs.ebx 0x%016lx", pproc->regs.ebx);
DBG("regs.ecx 0x%016lx", pproc->regs.ecx);
DBG("regs.edx 0x%016lx", pproc->regs.edx);
DBG("regs.esi 0x%016lx", pproc->regs.esi);
DBG("regs.edi 0x%016lx", pproc->regs.edi);
DBG("regs.ebp 0x%016lx", pproc->regs.ebp);
DBG("regs.eax 0x%016lx", pproc->regs.eax);
DBG("regs.xds 0x%016lx", pproc->regs.xds);
DBG("regs.xes 0x%016lx", pproc->regs.xes);
DBG("regs.xfs 0x%016lx", pproc->regs.xfs);
DBG("regs.xgs 0x%016lx", pproc->regs.xgs);
DBG("regs.orig_eax 0x%016lx", pproc->regs.orig_eax);
DBG("regs.eip 0x%016lx", pproc->regs.eip);
DBG("regs.xcs 0x%016lx", pproc->regs.xcs);
DBG("regs.eflags 0x%016lx", pproc->regs.eflags);
DBG("regs.esp 0x%016lx", pproc->regs.esp);
DBG("regs.xss 0x%016lx", pproc->regs.xss);
#endif /* __x86_64__ */
}
/* Inspect current instruction */
if (opt & PROBE_OP)
{
#ifdef __x86_64__
pproc->op = pproc->regs.rip;
#else /* __i386__ */
pproc->op = pproc->regs.eip;
#endif /* __x86_64__ */
if (!pproc->tflags.single_step)
{
pproc->op -= 2; // shift back 16bit in syscall tracing mode
}
if (__trace(T_GETDATA, (long *)&pproc->op, pproc) != 0)
{
FUNC_RET("%d", false);
}
DBG("proc.op 0x%016lx", pproc->op);
}
/* Inspect signal information */
if (opt & PROBE_SIGINFO)
{
if (__trace(T_GETSIGINFO, NULL, pproc) != 0)
{
FUNC_RET("%d", false);
}
DBG("proc.siginfo.si_signo % 10d", pproc->siginfo.si_signo);
DBG("proc.siginfo.si_errno % 10d", pproc->siginfo.si_errno);
DBG("proc.siginfo.si_code % 10d", pproc->siginfo.si_code);
}
FUNC_RET("%d", true);
}
static s32 goodix_tool_read( char *page, char **start, off_t off, int count, int *eof, void *data )
{
if (2 == cmd_head.wr)
{
//memcpy(page, IC_TYPE, cmd_head.data_len);
memcpy(page, IC_TYPE, sizeof(IC_TYPE_NAME));
page[sizeof(IC_TYPE_NAME)] = 0;
DEBUG("Return ic type:%s len:%d\n", page, (s32)cmd_head.data_len);
return cmd_head.data_len;
//return sizeof(IC_TYPE_NAME);
}
else if (cmd_head.wr % 2)
{
return fail;
}
else if (!cmd_head.wr)
{
u16 len = 0;
s16 data_len = 0;
u16 loc = 0;
if (1 == cmd_head.flag)
{
if (fail == comfirm())
{
WARNING("[READ]Comfirm fail!\n");
return fail;
}
}
else if (2 == cmd_head.flag)
{
//Need interrupt!
}
memcpy(cmd_head.data, cmd_head.addr, cmd_head.addr_len);
DEBUG("[CMD HEAD DATA] ADDR:0x%02x%02x\n", cmd_head.data[0], cmd_head.data[1]);
DEBUG("[CMD HEAD ADDR] ADDR:0x%02x%02x\n", cmd_head.addr[0], cmd_head.addr[1]);
if (cmd_head.delay)
{
msleep(cmd_head.delay);
}
data_len = cmd_head.data_len;
while(data_len > 0)
{
if (data_len > DATA_LENGTH)
{
len = DATA_LENGTH;
}
else
{
len = data_len;
}
data_len -= DATA_LENGTH;
if (tool_i2c_read(cmd_head.data, len) <= 0)
{
WARNING("[READ]Read data failed!\n");
return fail;
}
memcpy(&page[loc], &cmd_head.data[ADDR_MAX_LENGTH], len);
loc += len;
//DEBUG_ARRAY(&cmd_head.data[ADDR_MAX_LENGTH], len);
DEBUG_ARRAY(page, len);
}
}
return cmd_head.data_len;
}
Decode_Status
VaapiDecoderBase::setupVA(uint32_t numSurface, VAProfile profile)
{
INFO("base: setup VA");
if (m_enableNativeBuffersFlag == true) {
numSurface = 20; //NATIVE_WINDOW_COUNT;
}
if (m_VAStarted) {
return DECODE_SUCCESS;
}
if (m_display != NULL) {
WARNING("VA is partially started.");
return DECODE_FAIL;
}
m_display = VaapiDisplay::create(m_externalDisplay);
if (!m_display) {
ERROR("failed to create display");
return DECODE_FAIL;
}
VAConfigAttrib attrib;
attrib.type = VAConfigAttribRTFormat;
attrib.value = VA_RT_FORMAT_YUV420;
ConfigPtr config = VaapiConfig::create(m_display, profile, VAEntrypointVLD,&attrib, 1);
if (!config) {
ERROR("failed to create config");
return DECODE_FAIL;
}
m_configBuffer.surfaceNumber = numSurface;
m_surfacePool = VaapiDecSurfacePool::create(m_display, &m_configBuffer);
DEBUG("surface pool is created");
if (!m_surfacePool)
return DECODE_FAIL;
std::vector<VASurfaceID> surfaces;
m_surfacePool->getSurfaceIDs(surfaces);
if (surfaces.empty())
return DECODE_FAIL;
int size = surfaces.size();
m_context = VaapiContext::create(config,
m_videoFormatInfo.width,
m_videoFormatInfo.height,
0, &surfaces[0], size);
if (!m_context) {
ERROR("create context failed");
return DECODE_FAIL;
}
if (!m_display->setRotation(m_configBuffer.rotationDegrees)) {
WARNING("set rotation failed");
}
if (!(m_configBuffer.flag & USE_NATIVE_GRAPHIC_BUFFER)) {
m_videoFormatInfo.surfaceWidth = m_videoFormatInfo.width;
m_videoFormatInfo.surfaceHeight = m_videoFormatInfo.height;
}
m_VAStarted = true;
return DECODE_SUCCESS;
}
static int apache_read_host (user_data_t *user_data) /* {{{ */
{
int i;
char *ptr;
char *saveptr;
char *lines[16];
int lines_num = 0;
char *fields[4];
int fields_num;
apache_t *st;
st = user_data->data;
assert (st->url != NULL);
/* (Assured by `config_add') */
if (st->curl == NULL)
{
int status;
status = init_host (st);
if (status != 0)
return (-1);
}
assert (st->curl != NULL);
st->apache_buffer_fill = 0;
if (curl_easy_perform (st->curl) != CURLE_OK)
{
ERROR ("apache: curl_easy_perform failed: %s",
st->apache_curl_error);
return (-1);
}
/* fallback - server_type to apache if not set at this time */
if (st->server_type == -1)
{
WARNING ("apache plugin: Unable to determine server software "
"automatically. Will assume Apache.");
st->server_type = APACHE;
}
ptr = st->apache_buffer;
saveptr = NULL;
while ((lines[lines_num] = strtok_r (ptr, "\n\r", &saveptr)) != NULL)
{
ptr = NULL;
lines_num++;
if (lines_num >= 16)
break;
}
for (i = 0; i < lines_num; i++)
{
fields_num = strsplit (lines[i], fields, 4);
if (fields_num == 3)
{
if ((strcmp (fields[0], "Total") == 0)
&& (strcmp (fields[1], "Accesses:") == 0))
submit_derive ("apache_requests", "",
atoll (fields[2]), st);
else if ((strcmp (fields[0], "Total") == 0)
&& (strcmp (fields[1], "kBytes:") == 0))
submit_derive ("apache_bytes", "",
1024LL * atoll (fields[2]), st);
}
else if (fields_num == 2)
{
if (strcmp (fields[0], "Scoreboard:") == 0)
submit_scoreboard (fields[1], st);
else if ((strcmp (fields[0], "BusyServers:") == 0) /* Apache 1.* */
|| (strcmp (fields[0], "BusyWorkers:") == 0) /* Apache 2.* */)
submit_gauge ("apache_connections", NULL, atol (fields[1]), st);
else if ((strcmp (fields[0], "IdleServers:") == 0) /* Apache 1.x */
|| (strcmp (fields[0], "IdleWorkers:") == 0) /* Apache 2.x */)
submit_gauge ("apache_idle_workers", NULL, atol (fields[1]), st);
}
}
st->apache_buffer_fill = 0;
return (0);
} /* }}} int apache_read_host */
// Консоль любит глючить, при попытках запроса более определенного количества ячеек.
// MAX_CONREAD_SIZE подобрано экспериментально
BOOL ReadConsoleOutputEx(HANDLE hOut, CHAR_INFO *pData, COORD bufSize, SMALL_RECT rgn)
{
BOOL lbRc = FALSE;
DWORD nTick1 = GetTickCount(), nTick2 = 0, nTick3 = 0, nTick4 = 0, nTick5 = 0;
static bool bDBCS = false, bDBCS_Checked = false;
if (!bDBCS_Checked)
{
bDBCS = (GetSystemMetrics(SM_DBCSENABLED) != 0);
bDBCS_Checked = true;
}
bool bDBCS_CP = bDBCS;
LPCSTR szLeads = NULL;
UINT MaxCharSize = 0;
DWORD nCP, nCP1, nMode;
if (bDBCS)
{
nCP = GetConsoleOutputCP();
nCP1 = GetConsoleCP();
GetConsoleMode(hOut, &nMode);
szLeads = GetCpInfoLeads(nCP, &MaxCharSize);
if (!szLeads || !*szLeads || MaxCharSize < 2)
{
bDBCS_CP = false;
}
}
size_t nBufWidth = bufSize.X;
int nWidth = (rgn.Right - rgn.Left + 1);
int nHeight = (rgn.Bottom - rgn.Top + 1);
int nCurSize = nWidth * nHeight;
_ASSERTE(bufSize.X >= nWidth);
_ASSERTE(bufSize.Y >= nHeight);
_ASSERTE(rgn.Top>=0 && rgn.Bottom>=rgn.Top);
_ASSERTE(rgn.Left>=0 && rgn.Right>=rgn.Left);
//MSectionLock RCS;
//if (gpSrv->pReqSizeSection && !RCS.Lock(gpSrv->pReqSizeSection, TRUE, 30000))
//{
// _ASSERTE(FALSE);
// SetLastError(ERROR_INVALID_PARAMETER);
// return FALSE;
//}
COORD bufCoord = {0,0};
DWORD dwErrCode = 0;
nTick2 = GetTickCount();
if (!bDBCS_CP && (nCurSize <= MAX_CONREAD_SIZE))
{
if (ReadConsoleOutputW(hOut, pData, bufSize, bufCoord, &rgn))
lbRc = TRUE;
nTick3 = GetTickCount();
}
if (!lbRc)
{
// Придется читать построчно
// Теоретически - можно и блоками, но оверхед очень маленький, а велик
// шанс обломаться, если консоль "глючит". Поэтому построчно...
//bufSize.X = TextWidth;
bufSize.Y = 1;
bufCoord.X = 0; bufCoord.Y = 0;
//rgn = gpSrv->sbi.srWindow;
int Y1 = rgn.Top;
int Y2 = rgn.Bottom;
CHAR_INFO* pLine = pData;
if (!bDBCS_CP)
{
for (int y = Y1; y <= Y2; y++, rgn.Top++, pLine+=nBufWidth)
{
nTick3 = GetTickCount();
rgn.Bottom = rgn.Top;
lbRc = ReadConsoleOutputW(hOut, pLine, bufSize, bufCoord, &rgn);
if (!lbRc)
{
dwErrCode = GetLastError();
_ASSERTE(FALSE && "ReadConsoleOutputW failed in MyReadConsoleOutput");
break;
}
nTick4 = GetTickCount();
}
}
else
{
DWORD nAttrsMax = bufSize.X;
DWORD nCharsMax = nAttrsMax/* *4 */; // -- максимум там вроде на некоторых CP - 4 байта
wchar_t* pszChars = (wchar_t*)malloc(nCharsMax*sizeof(*pszChars));
char* pszCharsA = (char*)malloc(nCharsMax*sizeof(*pszCharsA));
WORD* pnAttrs = (WORD*)malloc(bufSize.X*sizeof(*pnAttrs));
if (pszChars && pszCharsA && pnAttrs)
{
COORD crRead = {rgn.Left,Y1};
DWORD nChars, nAttrs, nCharsA;
CHAR_INFO* pLine = pData;
for (; crRead.Y <= Y2; crRead.Y++, pLine+=nBufWidth)
{
nTick3 = GetTickCount();
rgn.Bottom = rgn.Top;
nChars = nCharsA = nAttrs = 0;
BOOL lbRcTxt = ReadConsoleOutputCharacterA(hOut, pszCharsA, nCharsMax, crRead, &nCharsA);
dwErrCode = GetLastError();
if (!lbRcTxt || !nCharsA)
{
nCharsA = 0;
lbRcTxt = ReadConsoleOutputCharacterW(hOut, pszChars, nCharsMax, crRead, &nChars);
dwErrCode = GetLastError();
}
BOOL lbRcAtr = ReadConsoleOutputAttribute(hOut, pnAttrs, bufSize.X, crRead, &nAttrs);
dwErrCode = GetLastError();
lbRc = lbRcTxt && lbRcAtr;
if (!lbRc)
{
dwErrCode = GetLastError();
_ASSERTE(FALSE && "ReadConsoleOutputAttribute failed in MyReadConsoleOutput");
CHAR_INFO* p = pLine;
for (size_t i = 0; i < nAttrsMax; ++i, ++p)
{
p->Attributes = 4; // red on black
p->Char.UnicodeChar = 0xFFFE; // not a character
}
break;
}
else
{
if (nCharsA)
{
nChars = MultiByteToWideChar(nCP, 0, pszCharsA, nCharsA, pszChars, nCharsMax);
}
CHAR_INFO* p = pLine;
wchar_t* psz = pszChars;
WORD* pn = pnAttrs;
//int i = nAttrsMax;
//while ((i--) > 0)
//{
// p->Attributes = *(pn++);
// p->Char.UnicodeChar = *(psz++);
// p++;
//}
size_t x1 = min(nChars,nAttrsMax);
size_t x2 = nAttrsMax;
for (size_t i = 0; i < x1; ++i, ++p)
{
p->Attributes = *pn;
p->Char.UnicodeChar = *psz;
WARNING("Некорректно! pn может указывать на начало блока DBCS/QBCS");
pn++; // += MaxCharSize;
psz++;
}
WORD nLastAttr = pnAttrs[max(0,(int)nAttrs-1)];
for (size_t i = x1; i < x2; ++i, ++p)
{
p->Attributes = nLastAttr;
p->Char.UnicodeChar = L' ';
}
}
nTick4 = GetTickCount();
}
}
SafeFree(pszChars);
SafeFree(pszCharsA);
SafeFree(pnAttrs);
}
nTick5 = GetTickCount();
}
UNREFERENCED_PARAMETER(nTick1);
UNREFERENCED_PARAMETER(nTick2);
UNREFERENCED_PARAMETER(nTick3);
UNREFERENCED_PARAMETER(nTick4);
UNREFERENCED_PARAMETER(nTick5);
return lbRc;
}
static int disk_read (void)
{
#if HAVE_IOKIT_IOKITLIB_H
io_registry_entry_t disk;
io_registry_entry_t disk_child;
io_iterator_t disk_list;
CFDictionaryRef props_dict;
CFDictionaryRef stats_dict;
CFDictionaryRef child_dict;
CFStringRef tmp_cf_string_ref;
kern_return_t status;
signed long long read_ops;
signed long long read_byt;
signed long long read_tme;
signed long long write_ops;
signed long long write_byt;
signed long long write_tme;
int disk_major;
int disk_minor;
char disk_name[DATA_MAX_NAME_LEN];
char disk_name_bsd[DATA_MAX_NAME_LEN];
/* Get the list of all disk objects. */
if (IOServiceGetMatchingServices (io_master_port,
IOServiceMatching (kIOBlockStorageDriverClass),
&disk_list) != kIOReturnSuccess)
{
ERROR ("disk plugin: IOServiceGetMatchingServices failed.");
return (-1);
}
while ((disk = IOIteratorNext (disk_list)) != 0)
{
props_dict = NULL;
stats_dict = NULL;
child_dict = NULL;
/* `disk_child' must be released */
if ((status = IORegistryEntryGetChildEntry (disk, kIOServicePlane, &disk_child))
!= kIOReturnSuccess)
{
/* This fails for example for DVD/CD drives.. */
DEBUG ("IORegistryEntryGetChildEntry (disk) failed: 0x%08x", status);
IOObjectRelease (disk);
continue;
}
/* We create `props_dict' => we need to release it later */
if (IORegistryEntryCreateCFProperties (disk,
(CFMutableDictionaryRef *) &props_dict,
kCFAllocatorDefault,
kNilOptions)
!= kIOReturnSuccess)
{
ERROR ("disk-plugin: IORegistryEntryCreateCFProperties failed.");
IOObjectRelease (disk_child);
IOObjectRelease (disk);
continue;
}
if (props_dict == NULL)
{
DEBUG ("IORegistryEntryCreateCFProperties (disk) failed.");
IOObjectRelease (disk_child);
IOObjectRelease (disk);
continue;
}
/* tmp_cf_string_ref doesn't need to be released. */
tmp_cf_string_ref = (CFStringRef) CFDictionaryGetValue (props_dict,
CFSTR(kIOBSDNameKey));
if (!tmp_cf_string_ref)
{
DEBUG ("disk plugin: CFDictionaryGetValue("
"kIOBSDNameKey) failed.");
CFRelease (props_dict);
IOObjectRelease (disk_child);
IOObjectRelease (disk);
continue;
}
assert (CFGetTypeID (tmp_cf_string_ref) == CFStringGetTypeID ());
memset (disk_name_bsd, 0, sizeof (disk_name_bsd));
CFStringGetCString (tmp_cf_string_ref,
disk_name_bsd, sizeof (disk_name_bsd),
kCFStringEncodingUTF8);
if (disk_name_bsd[0] == 0)
{
ERROR ("disk plugin: CFStringGetCString() failed.");
CFRelease (props_dict);
IOObjectRelease (disk_child);
IOObjectRelease (disk);
continue;
}
DEBUG ("disk plugin: disk_name_bsd = \"%s\"", disk_name_bsd);
stats_dict = (CFDictionaryRef) CFDictionaryGetValue (props_dict,
CFSTR (kIOBlockStorageDriverStatisticsKey));
if (stats_dict == NULL)
{
DEBUG ("disk plugin: CFDictionaryGetValue ("
"%s) failed.",
kIOBlockStorageDriverStatisticsKey);
CFRelease (props_dict);
IOObjectRelease (disk_child);
IOObjectRelease (disk);
continue;
}
if (IORegistryEntryCreateCFProperties (disk_child,
(CFMutableDictionaryRef *) &child_dict,
kCFAllocatorDefault,
kNilOptions)
!= kIOReturnSuccess)
{
DEBUG ("disk plugin: IORegistryEntryCreateCFProperties ("
"disk_child) failed.");
IOObjectRelease (disk_child);
CFRelease (props_dict);
IOObjectRelease (disk);
continue;
}
/* kIOBSDNameKey */
disk_major = (int) dict_get_value (child_dict,
kIOBSDMajorKey);
disk_minor = (int) dict_get_value (child_dict,
kIOBSDMinorKey);
read_ops = dict_get_value (stats_dict,
kIOBlockStorageDriverStatisticsReadsKey);
read_byt = dict_get_value (stats_dict,
kIOBlockStorageDriverStatisticsBytesReadKey);
read_tme = dict_get_value (stats_dict,
kIOBlockStorageDriverStatisticsTotalReadTimeKey);
write_ops = dict_get_value (stats_dict,
kIOBlockStorageDriverStatisticsWritesKey);
write_byt = dict_get_value (stats_dict,
kIOBlockStorageDriverStatisticsBytesWrittenKey);
/* This property describes the number of nanoseconds spent
* performing writes since the block storage driver was
* instantiated. It is one of the statistic entries listed
* under the top-level kIOBlockStorageDriverStatisticsKey
* property table. It has an OSNumber value. */
write_tme = dict_get_value (stats_dict,
kIOBlockStorageDriverStatisticsTotalWriteTimeKey);
if (use_bsd_name)
sstrncpy (disk_name, disk_name_bsd, sizeof (disk_name));
else
ssnprintf (disk_name, sizeof (disk_name), "%i-%i",
disk_major, disk_minor);
DEBUG ("disk plugin: disk_name = \"%s\"", disk_name);
if ((read_byt != -1LL) || (write_byt != -1LL))
disk_submit (disk_name, "disk_octets", read_byt, write_byt);
if ((read_ops != -1LL) || (write_ops != -1LL))
disk_submit (disk_name, "disk_ops", read_ops, write_ops);
if ((read_tme != -1LL) || (write_tme != -1LL))
disk_submit (disk_name, "disk_time",
read_tme / 1000,
write_tme / 1000);
CFRelease (child_dict);
IOObjectRelease (disk_child);
CFRelease (props_dict);
IOObjectRelease (disk);
}
IOObjectRelease (disk_list);
/* #endif HAVE_IOKIT_IOKITLIB_H */
#elif KERNEL_LINUX
FILE *fh;
char buffer[1024];
char *fields[32];
int numfields;
int fieldshift = 0;
int minor = 0;
derive_t read_sectors = 0;
derive_t write_sectors = 0;
derive_t read_ops = 0;
derive_t read_merged = 0;
derive_t read_time = 0;
derive_t write_ops = 0;
derive_t write_merged = 0;
derive_t write_time = 0;
int is_disk = 0;
diskstats_t *ds, *pre_ds;
if ((fh = fopen ("/proc/diskstats", "r")) == NULL)
{
fh = fopen ("/proc/partitions", "r");
if (fh == NULL)
{
ERROR ("disk plugin: fopen (/proc/{diskstats,partitions}) failed.");
return (-1);
}
/* Kernel is 2.4.* */
fieldshift = 1;
}
#if HAVE_LIBUDEV
handle_udev = udev_new();
#endif
while (fgets (buffer, sizeof (buffer), fh) != NULL)
{
char *disk_name;
char *output_name;
char *alt_name;
numfields = strsplit (buffer, fields, 32);
if ((numfields != (14 + fieldshift)) && (numfields != 7))
continue;
minor = atoll (fields[1]);
disk_name = fields[2 + fieldshift];
for (ds = disklist, pre_ds = disklist; ds != NULL; pre_ds = ds, ds = ds->next)
if (strcmp (disk_name, ds->name) == 0)
break;
if (ds == NULL)
{
if ((ds = (diskstats_t *) calloc (1, sizeof (diskstats_t))) == NULL)
continue;
if ((ds->name = strdup (disk_name)) == NULL)
{
free (ds);
continue;
}
if (pre_ds == NULL)
disklist = ds;
else
pre_ds->next = ds;
}
is_disk = 0;
if (numfields == 7)
{
/* Kernel 2.6, Partition */
read_ops = atoll (fields[3]);
read_sectors = atoll (fields[4]);
write_ops = atoll (fields[5]);
write_sectors = atoll (fields[6]);
}
else if (numfields == (14 + fieldshift))
{
read_ops = atoll (fields[3 + fieldshift]);
write_ops = atoll (fields[7 + fieldshift]);
read_sectors = atoll (fields[5 + fieldshift]);
write_sectors = atoll (fields[9 + fieldshift]);
if ((fieldshift == 0) || (minor == 0))
{
is_disk = 1;
read_merged = atoll (fields[4 + fieldshift]);
read_time = atoll (fields[6 + fieldshift]);
write_merged = atoll (fields[8 + fieldshift]);
write_time = atoll (fields[10+ fieldshift]);
}
}
else
{
DEBUG ("numfields = %i; => unknown file format.", numfields);
continue;
}
{
derive_t diff_read_sectors;
derive_t diff_write_sectors;
/* If the counter wraps around, it's only 32 bits.. */
if (read_sectors < ds->read_sectors)
diff_read_sectors = 1 + read_sectors
+ (UINT_MAX - ds->read_sectors);
else
diff_read_sectors = read_sectors - ds->read_sectors;
if (write_sectors < ds->write_sectors)
diff_write_sectors = 1 + write_sectors
+ (UINT_MAX - ds->write_sectors);
else
diff_write_sectors = write_sectors - ds->write_sectors;
ds->read_bytes += 512 * diff_read_sectors;
ds->write_bytes += 512 * diff_write_sectors;
ds->read_sectors = read_sectors;
ds->write_sectors = write_sectors;
}
/* Calculate the average time an io-op needs to complete */
if (is_disk)
{
derive_t diff_read_ops;
derive_t diff_write_ops;
derive_t diff_read_time;
derive_t diff_write_time;
if (read_ops < ds->read_ops)
diff_read_ops = 1 + read_ops
+ (UINT_MAX - ds->read_ops);
else
diff_read_ops = read_ops - ds->read_ops;
DEBUG ("disk plugin: disk_name = %s; read_ops = %"PRIi64"; "
"ds->read_ops = %"PRIi64"; diff_read_ops = %"PRIi64";",
disk_name,
read_ops, ds->read_ops, diff_read_ops);
if (write_ops < ds->write_ops)
diff_write_ops = 1 + write_ops
+ (UINT_MAX - ds->write_ops);
else
diff_write_ops = write_ops - ds->write_ops;
if (read_time < ds->read_time)
diff_read_time = 1 + read_time
+ (UINT_MAX - ds->read_time);
else
diff_read_time = read_time - ds->read_time;
if (write_time < ds->write_time)
diff_write_time = 1 + write_time
+ (UINT_MAX - ds->write_time);
else
diff_write_time = write_time - ds->write_time;
if (diff_read_ops != 0)
ds->avg_read_time += disk_calc_time_incr (
diff_read_time, diff_read_ops);
if (diff_write_ops != 0)
ds->avg_write_time += disk_calc_time_incr (
diff_write_time, diff_write_ops);
ds->read_ops = read_ops;
ds->read_time = read_time;
ds->write_ops = write_ops;
ds->write_time = write_time;
} /* if (is_disk) */
/* Don't write to the RRDs if we've just started.. */
ds->poll_count++;
if (ds->poll_count <= 2)
{
DEBUG ("disk plugin: (ds->poll_count = %i) <= "
"(min_poll_count = 2); => Not writing.",
ds->poll_count);
continue;
}
if ((read_ops == 0) && (write_ops == 0))
{
DEBUG ("disk plugin: ((read_ops == 0) && "
"(write_ops == 0)); => Not writing.");
continue;
}
output_name = disk_name;
#if HAVE_LIBUDEV
alt_name = disk_udev_attr_name (handle_udev, disk_name,
conf_udev_name_attr);
#else
alt_name = NULL;
#endif
if (alt_name != NULL)
output_name = alt_name;
if ((ds->read_bytes != 0) || (ds->write_bytes != 0))
disk_submit (output_name, "disk_octets",
ds->read_bytes, ds->write_bytes);
if ((ds->read_ops != 0) || (ds->write_ops != 0))
disk_submit (output_name, "disk_ops",
read_ops, write_ops);
if ((ds->avg_read_time != 0) || (ds->avg_write_time != 0))
disk_submit (output_name, "disk_time",
ds->avg_read_time, ds->avg_write_time);
if (is_disk)
{
disk_submit (output_name, "disk_merged",
read_merged, write_merged);
} /* if (is_disk) */
/* release udev-based alternate name, if allocated */
free(alt_name);
} /* while (fgets (buffer, sizeof (buffer), fh) != NULL) */
#if HAVE_LIBUDEV
udev_unref(handle_udev);
#endif
fclose (fh);
/* #endif defined(KERNEL_LINUX) */
#elif HAVE_LIBKSTAT
# if HAVE_KSTAT_IO_T_WRITES && HAVE_KSTAT_IO_T_NWRITES && HAVE_KSTAT_IO_T_WTIME
# define KIO_ROCTETS reads
# define KIO_WOCTETS writes
# define KIO_ROPS nreads
# define KIO_WOPS nwrites
# define KIO_RTIME rtime
# define KIO_WTIME wtime
# elif HAVE_KSTAT_IO_T_NWRITTEN && HAVE_KSTAT_IO_T_WRITES && HAVE_KSTAT_IO_T_WTIME
# define KIO_ROCTETS nread
# define KIO_WOCTETS nwritten
# define KIO_ROPS reads
# define KIO_WOPS writes
# define KIO_RTIME rtime
# define KIO_WTIME wtime
# else
# error "kstat_io_t does not have the required members"
# endif
static kstat_io_t kio;
int i;
if (kc == NULL)
return (-1);
for (i = 0; i < numdisk; i++)
{
if (kstat_read (kc, ksp[i], &kio) == -1)
continue;
if (strncmp (ksp[i]->ks_class, "disk", 4) == 0)
{
disk_submit (ksp[i]->ks_name, "disk_octets",
kio.KIO_ROCTETS, kio.KIO_WOCTETS);
disk_submit (ksp[i]->ks_name, "disk_ops",
kio.KIO_ROPS, kio.KIO_WOPS);
/* FIXME: Convert this to microseconds if necessary */
disk_submit (ksp[i]->ks_name, "disk_time",
kio.KIO_RTIME, kio.KIO_WTIME);
}
else if (strncmp (ksp[i]->ks_class, "partition", 9) == 0)
{
disk_submit (ksp[i]->ks_name, "disk_octets",
kio.KIO_ROCTETS, kio.KIO_WOCTETS);
disk_submit (ksp[i]->ks_name, "disk_ops",
kio.KIO_ROPS, kio.KIO_WOPS);
}
}
/* #endif defined(HAVE_LIBKSTAT) */
#elif defined(HAVE_LIBSTATGRAB)
sg_disk_io_stats *ds;
int disks, counter;
char name[DATA_MAX_NAME_LEN];
if ((ds = sg_get_disk_io_stats(&disks)) == NULL)
return (0);
for (counter=0; counter < disks; counter++) {
strncpy(name, ds->disk_name, sizeof(name));
name[sizeof(name)-1] = '\0'; /* strncpy doesn't terminate longer strings */
disk_submit (name, "disk_octets", ds->read_bytes, ds->write_bytes);
ds++;
}
/* #endif defined(HAVE_LIBSTATGRAB) */
#elif defined(HAVE_PERFSTAT)
derive_t read_sectors;
derive_t write_sectors;
derive_t read_time;
derive_t write_time;
derive_t read_ops;
derive_t write_ops;
perfstat_id_t firstpath;
int rnumdisk;
int i;
if ((numdisk = perfstat_disk(NULL, NULL, sizeof(perfstat_disk_t), 0)) < 0)
{
char errbuf[1024];
WARNING ("disk plugin: perfstat_disk: %s",
sstrerror (errno, errbuf, sizeof (errbuf)));
return (-1);
}
if (numdisk != pnumdisk || stat_disk==NULL) {
if (stat_disk!=NULL)
free(stat_disk);
stat_disk = (perfstat_disk_t *)calloc(numdisk, sizeof(perfstat_disk_t));
}
pnumdisk = numdisk;
firstpath.name[0]='\0';
if ((rnumdisk = perfstat_disk(&firstpath, stat_disk, sizeof(perfstat_disk_t), numdisk)) < 0)
{
char errbuf[1024];
WARNING ("disk plugin: perfstat_disk : %s",
sstrerror (errno, errbuf, sizeof (errbuf)));
return (-1);
}
for (i = 0; i < rnumdisk; i++)
{
read_sectors = stat_disk[i].rblks*stat_disk[i].bsize;
write_sectors = stat_disk[i].wblks*stat_disk[i].bsize;
disk_submit (stat_disk[i].name, "disk_octets", read_sectors, write_sectors);
read_ops = stat_disk[i].xrate;
write_ops = stat_disk[i].xfers - stat_disk[i].xrate;
disk_submit (stat_disk[i].name, "disk_ops", read_ops, write_ops);
read_time = stat_disk[i].rserv;
read_time *= ((double)(_system_configuration.Xint)/(double)(_system_configuration.Xfrac)) / 1000000.0;
write_time = stat_disk[i].wserv;
write_time *= ((double)(_system_configuration.Xint)/(double)(_system_configuration.Xfrac)) / 1000000.0;
disk_submit (stat_disk[i].name, "disk_time", read_time, write_time);
}
#endif /* defined(HAVE_PERFSTAT) */
return (0);
} /* int disk_read */
/* Configuration handling functiions
* <Plugin apache>
* <Instance "instance_name">
* URL ...
* </Instance>
* URL ...
* </Plugin>
*/
static int config_add (oconfig_item_t *ci)
{
apache_t *st;
int i;
int status;
st = malloc (sizeof (*st));
if (st == NULL)
{
ERROR ("apache plugin: malloc failed.");
return (-1);
}
memset (st, 0, sizeof (*st));
status = cf_util_get_string (ci, &st->name);
if (status != 0)
{
sfree (st);
return (status);
}
assert (st->name != NULL);
for (i = 0; i < ci->children_num; i++)
{
oconfig_item_t *child = ci->children + i;
if (strcasecmp ("URL", child->key) == 0)
status = cf_util_get_string (child, &st->url);
else if (strcasecmp ("Host", child->key) == 0)
status = cf_util_get_string (child, &st->host);
else if (strcasecmp ("User", child->key) == 0)
status = cf_util_get_string (child, &st->user);
else if (strcasecmp ("Password", child->key) == 0)
status = cf_util_get_string (child, &st->pass);
else if (strcasecmp ("VerifyPeer", child->key) == 0)
status = cf_util_get_boolean (child, &st->verify_peer);
else if (strcasecmp ("VerifyHost", child->key) == 0)
status = cf_util_get_boolean (child, &st->verify_host);
else if (strcasecmp ("CACert", child->key) == 0)
status = cf_util_get_string (child, &st->cacert);
else if (strcasecmp ("Server", child->key) == 0)
status = cf_util_get_string (child, &st->server);
else
{
WARNING ("apache plugin: Option `%s' not allowed here.",
child->key);
status = -1;
}
if (status != 0)
break;
}
/* Check if struct is complete.. */
if ((status == 0) && (st->url == NULL))
{
ERROR ("apache plugin: Instance `%s': "
"No URL has been configured.",
st->name);
status = -1;
}
if (status == 0)
{
user_data_t ud;
char callback_name[3*DATA_MAX_NAME_LEN];
memset (&ud, 0, sizeof (ud));
ud.data = st;
ud.free_func = (void *) apache_free;
memset (callback_name, 0, sizeof (callback_name));
ssnprintf (callback_name, sizeof (callback_name),
"apache/%s/%s",
(st->host != NULL) ? st->host : hostname_g,
(st->name != NULL) ? st->name : "default"),
status = plugin_register_complex_read (/* group = */ NULL,
/* name = */ callback_name,
/* callback = */ apache_read_host,
/* interval = */ NULL,
/* user_data = */ &ud);
}
if (status != 0)
{
apache_free (st);
return (-1);
}
return (0);
} /* int config_add */
static int mysql_config (oconfig_item_t *ci) /* {{{ */
{
mysql_database_t *db;
int plugin_block;
int status = 0;
int i;
if ((ci->values_num != 1)
|| (ci->values[0].type != OCONFIG_TYPE_STRING))
{
WARNING ("mysql plugin: The `Database' block "
"needs exactly one string argument.");
return (-1);
}
db = (mysql_database_t *) malloc (sizeof (*db));
if (db == NULL)
{
ERROR ("mysql plugin: malloc failed.");
return (-1);
}
memset (db, 0, sizeof (*db));
/* initialize all the pointers */
db->host = NULL;
db->user = NULL;
db->pass = NULL;
db->database = NULL;
db->socket = NULL;
db->con = NULL;
/* trigger a notification, if it's not running */
db->slave_io_running = 1;
db->slave_sql_running = 1;
plugin_block = 1;
if (strcasecmp ("Plugin", ci->key) == 0)
{
db->instance = NULL;
}
else if (strcasecmp ("Database", ci->key) == 0)
{
plugin_block = 0;
status = mysql_config_set_string (&db->instance, ci);
if (status != 0)
{
sfree (db);
return (status);
}
assert (db->instance != NULL);
}
else
{
ERROR ("mysql plugin: mysql_config: "
"Invalid key: %s", ci->key);
return (-1);
}
/* Fill the `mysql_database_t' structure.. */
for (i = 0; i < ci->children_num; i++)
{
oconfig_item_t *child = ci->children + i;
if (strcasecmp ("Host", child->key) == 0)
status = mysql_config_set_string (&db->host, child);
else if (strcasecmp ("User", child->key) == 0)
status = mysql_config_set_string (&db->user, child);
else if (strcasecmp ("Password", child->key) == 0)
status = mysql_config_set_string (&db->pass, child);
else if (strcasecmp ("Port", child->key) == 0)
status = mysql_config_set_int (&db->port, child);
else if (strcasecmp ("Socket", child->key) == 0)
status = mysql_config_set_string (&db->socket, child);
/* Check if we're currently handling the `Plugin' block. If so,
* handle `Database' _blocks_, too. */
else if ((plugin_block != 0)
&& (strcasecmp ("Database", child->key) == 0)
&& (child->children != NULL))
{
/* If `plugin_block > 1', there has been at least one
* `Database' block */
plugin_block++;
status = mysql_config (child);
}
/* Now handle ordinary `Database' options (without children) */
else if ((strcasecmp ("Database", child->key) == 0)
&& (child->children == NULL))
status = mysql_config_set_string (&db->database, child);
else if (strcasecmp ("MasterStats", child->key) == 0)
status = mysql_config_set_boolean (&db->master_stats, child);
else if (strcasecmp ("SlaveStats", child->key) == 0)
status = mysql_config_set_boolean (&db->slave_stats, child);
else if (strcasecmp ("SlaveNotifications", child->key) == 0)
status = mysql_config_set_boolean (&db->slave_notif, child);
else
{
WARNING ("mysql plugin: Option `%s' not allowed here.", child->key);
status = -1;
}
if (status != 0)
break;
}
/* Check if there were any `Database' blocks. */
if (plugin_block > 1)
{
/* There were connection blocks. Don't use any legacy stuff. */
if ((db->host != NULL)
|| (db->user != NULL)
|| (db->pass != NULL)
|| (db->database != NULL)
|| (db->socket != NULL)
|| (db->port != 0))
{
WARNING ("mysql plugin: At least one <Database> "
"block has been found. The legacy "
"configuration will be ignored.");
}
mysql_database_free (db);
return (0);
}
else if (plugin_block != 0)
{
WARNING ("mysql plugin: You're using the legacy "
"configuration options. Please consider "
"updating your configuration!");
}
/* Check that all necessary options have been given. */
while (status == 0)
{
/* Zero is allowed and automatically handled by
* `mysql_real_connect'. */
if ((db->port < 0) || (db->port > 65535))
{
ERROR ("mysql plugin: Database %s: Port number out "
"of range: %i",
(db->instance != NULL)
? db->instance
: "<legacy>",
db->port);
status = -1;
}
break;
} /* while (status == 0) */
/* If all went well, register this database for reading */
if (status == 0)
{
user_data_t ud;
char cb_name[DATA_MAX_NAME_LEN];
DEBUG ("mysql plugin: Registering new read callback: %s",
(db->database != NULL) ? db->database : "<default>");
memset (&ud, 0, sizeof (ud));
ud.data = (void *) db;
ud.free_func = mysql_database_free;
if (db->database != NULL)
ssnprintf (cb_name, sizeof (cb_name), "mysql-%s",
db->database);
else
sstrncpy (cb_name, "mysql", sizeof (cb_name));
plugin_register_complex_read (cb_name, mysql_read,
/* interval = */ NULL, &ud);
}
else
{
mysql_database_free (db);
return (-1);
}
return (0);
} /* }}} int mysql_config */
static int mysql_read_slave_stats (mysql_database_t *db, MYSQL *con)
{
MYSQL_RES *res;
MYSQL_ROW row;
char *query;
int field_num;
/* WTF? libmysqlclient does not seem to provide any means to
* translate a column name to a column index ... :-/ */
const int READ_MASTER_LOG_POS_IDX = 6;
const int SLAVE_IO_RUNNING_IDX = 10;
const int SLAVE_SQL_RUNNING_IDX = 11;
const int EXEC_MASTER_LOG_POS_IDX = 21;
const int SECONDS_BEHIND_MASTER_IDX = 32;
query = "SHOW SLAVE STATUS";
res = exec_query (con, query);
if (res == NULL)
return (-1);
row = mysql_fetch_row (res);
if (row == NULL)
{
ERROR ("mysql plugin: Failed to get slave statistics: "
"`%s' did not return any rows.", query);
return (-1);
}
field_num = mysql_num_fields (res);
if (field_num < 33)
{
ERROR ("mysql plugin: Failed to get slave statistics: "
"`%s' returned less than 33 columns.", query);
return (-1);
}
if (db->slave_stats)
{
unsigned long long counter;
double gauge;
counter = atoll (row[READ_MASTER_LOG_POS_IDX]);
counter_submit ("mysql_log_position", "slave-read", counter, db);
counter = atoll (row[EXEC_MASTER_LOG_POS_IDX]);
counter_submit ("mysql_log_position", "slave-exec", counter, db);
if (row[SECONDS_BEHIND_MASTER_IDX] != NULL)
{
gauge = atof (row[SECONDS_BEHIND_MASTER_IDX]);
gauge_submit ("time_offset", NULL, gauge, db);
}
}
if (db->slave_notif)
{
notification_t n = { 0, time (NULL), "", "",
"mysql", "", "time_offset", "", NULL };
char *io, *sql;
io = row[SLAVE_IO_RUNNING_IDX];
sql = row[SLAVE_SQL_RUNNING_IDX];
set_host (db, n.host, sizeof (n.host));
set_plugin_instance (db,
n.plugin_instance, sizeof (n.plugin_instance));
if (((io == NULL) || (strcasecmp (io, "yes") != 0))
&& (db->slave_io_running))
{
n.severity = NOTIF_WARNING;
ssnprintf (n.message, sizeof (n.message),
"slave I/O thread not started or not connected to master");
plugin_dispatch_notification (&n);
db->slave_io_running = 0;
}
else if (((io != NULL) && (strcasecmp (io, "yes") == 0))
&& (! db->slave_io_running))
{
n.severity = NOTIF_OKAY;
ssnprintf (n.message, sizeof (n.message),
"slave I/O thread started and connected to master");
plugin_dispatch_notification (&n);
db->slave_io_running = 1;
}
if (((sql == NULL) || (strcasecmp (sql, "yes") != 0))
&& (db->slave_sql_running))
{
n.severity = NOTIF_WARNING;
ssnprintf (n.message, sizeof (n.message),
"slave SQL thread not started");
plugin_dispatch_notification (&n);
db->slave_sql_running = 0;
}
else if (((sql != NULL) && (strcasecmp (sql, "yes") == 0))
&& (! db->slave_sql_running))
{
n.severity = NOTIF_OKAY;
ssnprintf (n.message, sizeof (n.message),
"slave SQL thread started");
plugin_dispatch_notification (&n);
db->slave_sql_running = 0;
}
}
row = mysql_fetch_row (res);
if (row != NULL)
WARNING ("mysql plugin: `%s' returned more than one row - "
"ignoring further results.", query);
mysql_free_result (res);
return (0);
} /* mysql_read_slave_stats */
static int values_to_kairosdb(char *buffer, size_t buffer_size, /* {{{ */
const data_set_t *ds, const value_list_t *vl,
int store_rates, size_t ds_idx) {
size_t offset = 0;
gauge_t *rates = NULL;
memset(buffer, 0, buffer_size);
#define BUFFER_ADD(...) \
do { \
int status; \
status = snprintf(buffer + offset, buffer_size - offset, __VA_ARGS__); \
if (status < 1) { \
sfree(rates); \
return -1; \
} else if (((size_t)status) >= (buffer_size - offset)) { \
sfree(rates); \
return -ENOMEM; \
} else \
offset += ((size_t)status); \
} while (0)
if (ds->ds[ds_idx].type == DS_TYPE_GAUGE) {
if (isfinite(vl->values[ds_idx].gauge)) {
BUFFER_ADD("[[");
BUFFER_ADD("%" PRIu64, CDTIME_T_TO_MS(vl->time));
BUFFER_ADD(",");
BUFFER_ADD(JSON_GAUGE_FORMAT, vl->values[ds_idx].gauge);
} else {
DEBUG("utils_format_kairosdb: invalid vl->values[ds_idx].gauge for "
"%s|%s|%s|%s|%s",
vl->plugin, vl->plugin_instance, vl->type, vl->type_instance,
ds->ds[ds_idx].name);
return -1;
}
} else if (store_rates) {
if (rates == NULL)
rates = uc_get_rate(ds, vl);
if (rates == NULL) {
WARNING("utils_format_kairosdb: uc_get_rate failed for %s|%s|%s|%s|%s",
vl->plugin, vl->plugin_instance, vl->type, vl->type_instance,
ds->ds[ds_idx].name);
return -1;
}
if (isfinite(rates[ds_idx])) {
BUFFER_ADD("[[");
BUFFER_ADD("%" PRIu64, CDTIME_T_TO_MS(vl->time));
BUFFER_ADD(",");
BUFFER_ADD(JSON_GAUGE_FORMAT, rates[ds_idx]);
} else {
WARNING("utils_format_kairosdb: invalid rates[ds_idx] for %s|%s|%s|%s|%s",
vl->plugin, vl->plugin_instance, vl->type, vl->type_instance,
ds->ds[ds_idx].name);
sfree(rates);
return -1;
}
} else if (ds->ds[ds_idx].type == DS_TYPE_COUNTER) {
BUFFER_ADD("[[");
BUFFER_ADD("%" PRIu64, CDTIME_T_TO_MS(vl->time));
BUFFER_ADD(",");
BUFFER_ADD("%" PRIu64, (uint64_t)vl->values[ds_idx].counter);
} else if (ds->ds[ds_idx].type == DS_TYPE_DERIVE) {
BUFFER_ADD("[[");
BUFFER_ADD("%" PRIu64, CDTIME_T_TO_MS(vl->time));
BUFFER_ADD(",");
BUFFER_ADD("%" PRIi64, vl->values[ds_idx].derive);
} else if (ds->ds[ds_idx].type == DS_TYPE_ABSOLUTE) {
BUFFER_ADD("[[");
BUFFER_ADD("%" PRIu64, CDTIME_T_TO_MS(vl->time));
BUFFER_ADD(",");
BUFFER_ADD("%" PRIu64, vl->values[ds_idx].absolute);
} else {
ERROR("format_kairosdb: Unknown data source type: %i", ds->ds[ds_idx].type);
sfree(rates);
return -1;
}
BUFFER_ADD("]]");
#undef BUFFER_ADD
DEBUG("format_kairosdb: values_to_kairosdb: buffer = %s;", buffer);
sfree(rates);
return 0;
} /* }}} int values_to_kairosdb */
static irqreturn_t davinci_musb_interrupt(int irq, void *__hci)
{
unsigned long flags;
irqreturn_t retval = IRQ_NONE;
struct musb *musb = __hci;
void __iomem *tibase = musb->ctrl_base;
struct cppi *cppi;
u32 tmp;
spin_lock_irqsave(&musb->lock, flags);
/* NOTE: DaVinci shadows the Mentor IRQs. Don't manage them through
* the Mentor registers (except for setup), use the TI ones and EOI.
*
* Docs describe irq "vector" registers associated with the CPPI and
* USB EOI registers. These hold a bitmask corresponding to the
* current IRQ, not an irq handler address. Would using those bits
* resolve some of the races observed in this dispatch code??
*/
/* CPPI interrupts share the same IRQ line, but have their own
* mask, state, "vector", and EOI registers.
*/
cppi = container_of(musb->dma_controller, struct cppi, controller);
if (is_cppi_enabled(musb) && musb->dma_controller && !cppi->irq)
retval = cppi_interrupt(irq, __hci);
/* ack and handle non-CPPI interrupts */
tmp = musb_readl(tibase, DAVINCI_USB_INT_SRC_MASKED_REG);
musb_writel(tibase, DAVINCI_USB_INT_SRC_CLR_REG, tmp);
DBG(4, "IRQ %08x\n", tmp);
musb->int_rx = (tmp & DAVINCI_USB_RXINT_MASK)
>> DAVINCI_USB_RXINT_SHIFT;
musb->int_tx = (tmp & DAVINCI_USB_TXINT_MASK)
>> DAVINCI_USB_TXINT_SHIFT;
musb->int_usb = (tmp & DAVINCI_USB_USBINT_MASK)
>> DAVINCI_USB_USBINT_SHIFT;
/* DRVVBUS irqs are the only proxy we have (a very poor one!) for
* DaVinci's missing ID change IRQ. We need an ID change IRQ to
* switch appropriately between halves of the OTG state machine.
* Managing DEVCTL.SESSION per Mentor docs requires we know its
* value, but DEVCTL.BDEVICE is invalid without DEVCTL.SESSION set.
* Also, DRVVBUS pulses for SRP (but not at 5V) ...
*/
if (tmp & (DAVINCI_INTR_DRVVBUS << DAVINCI_USB_USBINT_SHIFT)) {
int drvvbus = musb_readl(tibase, DAVINCI_USB_STAT_REG);
void __iomem *mregs = musb->mregs;
u8 devctl = musb_readb(mregs, MUSB_DEVCTL);
int err = musb->int_usb & MUSB_INTR_VBUSERROR;
err = is_host_enabled(musb)
&& (musb->int_usb & MUSB_INTR_VBUSERROR);
if (err) {
/* The Mentor core doesn't debounce VBUS as needed
* to cope with device connect current spikes. This
* means it's not uncommon for bus-powered devices
* to get VBUS errors during enumeration.
*
* This is a workaround, but newer RTL from Mentor
* seems to allow a better one: "re"starting sessions
* without waiting (on EVM, a **long** time) for VBUS
* to stop registering in devctl.
*/
musb->int_usb &= ~MUSB_INTR_VBUSERROR;
musb->xceiv->state = OTG_STATE_A_WAIT_VFALL;
mod_timer(&otg_workaround, jiffies + POLL_SECONDS * HZ);
WARNING("VBUS error workaround (delay coming)\n");
} else if (is_host_enabled(musb) && drvvbus) {
MUSB_HST_MODE(musb);
musb->xceiv->default_a = 1;
musb->xceiv->state = OTG_STATE_A_WAIT_VRISE;
portstate(musb->port1_status |= USB_PORT_STAT_POWER);
del_timer(&otg_workaround);
} else {
musb->is_active = 0;
MUSB_DEV_MODE(musb);
musb->xceiv->default_a = 0;
musb->xceiv->state = OTG_STATE_B_IDLE;
portstate(musb->port1_status &= ~USB_PORT_STAT_POWER);
}
/* NOTE: this must complete poweron within 100 msec
* (OTG_TIME_A_WAIT_VRISE) but we don't check for that.
*/
davinci_musb_source_power(musb, drvvbus, 0);
DBG(2, "VBUS %s (%s)%s, devctl %02x\n",
drvvbus ? "on" : "off",
otg_state_string(musb),
err ? " ERROR" : "",
devctl);
retval = IRQ_HANDLED;
}
if (musb->int_tx || musb->int_rx || musb->int_usb)
retval |= musb_interrupt(musb);
/* irq stays asserted until EOI is written */
musb_writel(tibase, DAVINCI_USB_EOI_REG, 0);
/* poll for ID change */
if (is_otg_enabled(musb)
&& musb->xceiv->state == OTG_STATE_B_IDLE)
mod_timer(&otg_workaround, jiffies + POLL_SECONDS * HZ);
spin_unlock_irqrestore(&musb->lock, flags);
return retval;
}
bool connection_open_tcp(connection *con, const char *host, const char *service)
{
EXPECT_FATAL(con);
EXPECT_FATAL(host);
EXPECT_FATAL(service);
EXPECT_FATAL(sizeof(con->mem) >= sizeof(SOCKET));
if (strnlen(host, 256) > 255) { X(bad_arg, XSTR_LIMIT": host must not exceed 255 octets"); }
SOCKET s = INVALID_SOCKET;
// method e.g. "GET"
// host e.g. "example.org"
// rsc e.g. "/index.html"
// port e.g. 80
const struct addrinfo hints =
{
AI_NUMERICSERV | AI_ADDRCONFIG, // ai_flags
AF_UNSPEC, // ai_family: AF_INET | AF_INET6 | AF_UNSPEC
SOCK_STREAM, // ai_socktype (TCP)
IPPROTO_TCP, // ai_protocol (TCP)
0,
NULL,
NULL,
NULL,
};
struct addrinfo *result;
int ret = getaddrinfo(host, service, &hints, &result);
if (ret != 0) { Xf(lookup_address, XSTR_NETWORK": (%s) %s", host, getaddrinfo_strerror(ret)); }
for (struct addrinfo *current = result; current; current = current->ai_next)
{
s = socket(current->ai_family, current->ai_socktype, current->ai_protocol);
if (s == INVALID_SOCKET) { Xf(socket, XSTR_NETWORK ": socket() errno=%d\n", socket_geterr()); }
ret = socket_connect(s, current->ai_addr, current->ai_addrlen);
if (ret != 0) { Xf(connect, XSTR_NETWORK ": connect() errno=%d\n", socket_geterr()); }
memset(con->address, '\0', CFW_INET6_ADDRSTRLEN);
# ifndef TARGET_WINDOWS
if(!inet_ntop(current->ai_family,
&((struct sockaddr_in *) current->ai_addr)->sin_addr,
con->address, CFW_INET6_ADDRSTRLEN)
) { WARNING("inet_ntop() IP lookup failure"); }
# endif
// success
break;
// fallthru
err_connect:
socket_close(s);
err_socket:
continue;
}
freeaddrinfo(result);
if (s == INVALID_SOCKET) { X(no_match, "No matching socket"); }
memcpy(con, &s, sizeof(SOCKET));
strcpy(con->host, host);
return true;
err_no_match:
freeaddrinfo(result);
err_lookup_address:
err_bad_arg:
return false;
}
int nsc_dclm_pbc(const rvec *coords, real *radius, int nat,
int densit, int mode,
real *value_of_area, real **at_area,
real *value_of_vol,
real **lidots, int *nu_dots,
atom_id index[], int ePBC, matrix box)
{
int iat, i, ii, iii, ix, iy, iz, ixe, ixs, iye, iys, ize, izs, i_ac;
int jat, j, jj, jjj, jx, jy, jz;
int distribution;
int l;
int maxnei, nnei, last, maxdots = 0;
int *wkdot = NULL, *wkbox = NULL, *wkat1 = NULL, *wkatm = NULL;
Neighb *wknb, *ctnb;
int iii1, iii2, iiat, lfnr = 0, i_at, j_at;
real dx, dy, dz, dd, ai, aisq, ajsq, aj, as, a;
real xi, yi, zi, xs = 0., ys = 0., zs = 0.;
real dotarea, area, vol = 0.;
real *xus, *dots = NULL, *atom_area = NULL;
int nxbox, nybox, nzbox, nxy, nxyz;
real xmin = 0, ymin = 0, zmin = 0, xmax, ymax, zmax, ra2max, d;
const real *pco;
/* Added DvdS 2006-07-19 */
t_pbc pbc;
rvec ddx, *x = NULL;
int iat_xx, jat_xx;
distribution = unsp_type(densit);
if (distribution != -last_unsp || last_cubus != 4 ||
(densit != last_densit && densit != last_n_dot))
{
if (make_unsp(densit, (-distribution), &n_dot, 4))
{
return 1;
}
}
xus = xpunsp;
dotarea = FOURPI/(real) n_dot;
area = 0.;
if (debug)
{
fprintf(debug, "nsc_dclm: n_dot=%5d %9.3f\n", n_dot, dotarea);
}
/* start with neighbour list */
/* calculate neighbour list with the box algorithm */
if (nat == 0)
{
WARNING("nsc_dclm: no surface atoms selected");
return 1;
}
if (mode & FLAG_VOLUME)
{
vol = 0.;
}
if (mode & FLAG_DOTS)
{
maxdots = (3*n_dot*nat)/10;
/* should be set to NULL on first user call */
if (dots == NULL)
{
snew(dots, maxdots);
}
else
{
srenew(dots, maxdots);
}
lfnr = 0;
}
if (mode & FLAG_ATOM_AREA)
{
/* should be set to NULL on first user call */
if (atom_area == NULL)
{
snew(atom_area, nat);
}
else
{
srenew(atom_area, nat);
}
}
/* Compute minimum size for grid cells */
ra2max = radius[index[0]];
for (iat_xx = 1; (iat_xx < nat); iat_xx++)
{
iat = index[iat_xx];
ra2max = max(ra2max, radius[iat]);
}
ra2max = 2*ra2max;
/* Added DvdS 2006-07-19 */
/* Updated 2008-10-09 */
if (box)
{
set_pbc(&pbc, ePBC, box);
snew(x, nat);
for (i = 0; (i < nat); i++)
{
iat = index[0];
copy_rvec(coords[iat], x[i]);
}
put_atoms_in_triclinic_unitcell(ecenterTRIC, box, nat, x);
nxbox = max(1, floor(norm(box[XX])/ra2max));
nybox = max(1, floor(norm(box[YY])/ra2max));
nzbox = max(1, floor(norm(box[ZZ])/ra2max));
if (debug)
{
fprintf(debug, "nbox = %d, %d, %d\n", nxbox, nybox, nzbox);
}
}
else
{
/* dimensions of atomic set, cell edge is 2*ra_max */
iat = index[0];
xmin = coords[iat][XX]; xmax = xmin; xs = xmin;
ymin = coords[iat][YY]; ymax = ymin; ys = ymin;
zmin = coords[iat][ZZ]; zmax = zmin; zs = zmin;
for (iat_xx = 1; (iat_xx < nat); iat_xx++)
{
iat = index[iat_xx];
pco = coords[iat];
xmin = min(xmin, *pco); xmax = max(xmax, *pco);
ymin = min(ymin, *(pco+1)); ymax = max(ymax, *(pco+1));
zmin = min(zmin, *(pco+2)); zmax = max(zmax, *(pco+2));
xs = xs+ *pco; ys = ys+ *(pco+1); zs = zs+ *(pco+2);
}
xs = xs/ (real) nat;
ys = ys/ (real) nat;
zs = zs/ (real) nat;
if (debug)
{
fprintf(debug, "nsc_dclm: n_dot=%5d ra2max=%9.3f %9.3f\n", n_dot, ra2max, dotarea);
}
d = xmax-xmin; nxbox = (int) max(ceil(d/ra2max), 1.);
d = (((real)nxbox)*ra2max-d)/2.;
xmin = xmin-d; xmax = xmax+d;
d = ymax-ymin; nybox = (int) max(ceil(d/ra2max), 1.);
d = (((real)nybox)*ra2max-d)/2.;
ymin = ymin-d; ymax = ymax+d;
d = zmax-zmin; nzbox = (int) max(ceil(d/ra2max), 1.);
d = (((real)nzbox)*ra2max-d)/2.;
zmin = zmin-d; zmax = zmax+d;
}
/* Help variables */
nxy = nxbox*nybox;
nxyz = nxy*nzbox;
/* box number of atoms */
snew(wkatm, nat);
snew(wkat1, nat);
snew(wkdot, n_dot);
snew(wkbox, nxyz+1);
if (box)
{
matrix box_1;
rvec x_1;
int ix, iy, iz, m;
m_inv(box, box_1);
for (i = 0; (i < nat); i++)
{
mvmul(box_1, x[i], x_1);
ix = ((int)floor(x_1[XX]*nxbox) + 2*nxbox) % nxbox;
iy = ((int)floor(x_1[YY]*nybox) + 2*nybox) % nybox;
iz = ((int)floor(x_1[ZZ]*nzbox) + 2*nzbox) % nzbox;
j = ix + iy*nxbox + iz*nxbox*nybox;
if (debug)
{
fprintf(debug, "Atom %d cell index %d. x = (%8.3f,%8.3f,%8.3f) fc = (%8.3f,%8.3f,%8.3f)\n",
i, j, x[i][XX], x[i][YY], x[i][ZZ], x_1[XX], x_1[YY], x_1[ZZ]);
}
range_check(j, 0, nxyz);
wkat1[i] = j;
wkbox[j]++;
}
}
else
{
/* Put the atoms in their boxes */
for (iat_xx = 0; (iat_xx < nat); iat_xx++)
{
iat = index[iat_xx];
pco = coords[iat];
i = (int) max(floor((pco[XX]-xmin)/ra2max), 0);
i = min(i, nxbox-1);
j = (int) max(floor((pco[YY]-ymin)/ra2max), 0);
j = min(j, nybox-1);
l = (int) max(floor((pco[ZZ]-zmin)/ra2max), 0);
l = min(l, nzbox-1);
i = i+j*nxbox+l*nxy;
wkat1[iat_xx] = i;
wkbox[i]++;
}
}
/* sorting of atoms in accordance with box numbers */
j = wkbox[0];
for (i = 1; i < nxyz; i++)
{
j = max(wkbox[i], j);
}
for (i = 1; i <= nxyz; i++)
{
wkbox[i] += wkbox[i-1];
}
/* maxnei = (int) floor(ra2max*ra2max*ra2max*0.5); */
maxnei = min(nat, 27*j);
snew(wknb, maxnei);
for (iat_xx = 0; iat_xx < nat; iat_xx++)
{
iat = index[iat_xx];
range_check(wkat1[iat_xx], 0, nxyz);
wkatm[--wkbox[wkat1[iat_xx]]] = iat_xx;
if (debug)
{
fprintf(debug, "atom %5d on place %5d\n", iat, wkbox[wkat1[iat_xx]]);
}
}
if (debug)
{
fprintf(debug, "nsc_dclm: n_dot=%5d ra2max=%9.3f %9.3f\n",
n_dot, ra2max, dotarea);
fprintf(debug, "neighbour list calculated/box(xyz):%d %d %d\n",
nxbox, nybox, nzbox);
for (i = 0; i < nxyz; i++)
{
fprintf(debug, "box %6d : atoms %4d-%4d %5d\n",
i, wkbox[i], wkbox[i+1]-1, wkbox[i+1]-wkbox[i]);
}
for (i = 0; i < nat; i++)
{
fprintf(debug, "list place %5d by atom %7d\n", i, index[wkatm[i]]);
}
}
/* calculate surface for all atoms, step cube-wise */
for (iz = 0; iz < nzbox; iz++)
{
iii = iz*nxy;
if (box)
{
izs = iz-1;
ize = min(iz+2, izs+nzbox);
}
else
{
izs = max(iz-1, 0);
ize = min(iz+2, nzbox);
}
for (iy = 0; iy < nybox; iy++)
{
ii = iy*nxbox+iii;
if (box)
{
iys = iy-1;
iye = min(iy+2, iys+nybox);
}
else
{
iys = max(iy-1, 0);
iye = min(iy+2, nybox);
}
for (ix = 0; ix < nxbox; ix++)
{
i = ii+ix;
iii1 = wkbox[i];
iii2 = wkbox[i+1];
if (iii1 >= iii2)
{
continue;
}
if (box)
{
ixs = ix-1;
ixe = min(ix+2, ixs+nxbox);
}
else
{
ixs = max(ix-1, 0);
ixe = min(ix+2, nxbox);
}
iiat = 0;
/* make intermediate atom list */
for (jz = izs; jz < ize; jz++)
{
jjj = ((jz+nzbox) % nzbox)*nxy;
for (jy = iys; jy < iye; jy++)
{
jj = ((jy+nybox) % nybox)*nxbox+jjj;
for (jx = ixs; jx < ixe; jx++)
{
j = jj+((jx+nxbox) % nxbox);
for (jat = wkbox[j]; jat < wkbox[j+1]; jat++)
{
range_check(wkatm[jat], 0, nat);
range_check(iiat, 0, nat);
wkat1[iiat] = wkatm[jat];
iiat++;
} /* end of cycle "jat" */
} /* end of cycle "jx" */
} /* end of cycle "jy" */
} /* end of cycle "jz" */
for (iat = iii1; iat < iii2; iat++)
{
i_at = index[wkatm[iat]];
ai = radius[i_at];
aisq = ai*ai;
pco = coords[i_at];
xi = pco[XX]; yi = pco[YY]; zi = pco[ZZ];
for (i = 0; i < n_dot; i++)
{
wkdot[i] = 0;
}
ctnb = wknb; nnei = 0;
for (j = 0; j < iiat; j++)
{
j_at = index[wkat1[j]];
if (j_at == i_at)
{
continue;
}
aj = radius[j_at];
ajsq = aj*aj;
pco = coords[j_at];
/* Added DvdS 2006-07-19 */
if (box)
{
/*rvec xxi;
xxi[XX] = xi;
xxi[YY] = yi;
xxi[ZZ] = zi;
pbc_dx(&pbc,pco,xxi,ddx);*/
pbc_dx(&pbc, coords[j_at], coords[i_at], ddx);
dx = ddx[XX];
dy = ddx[YY];
dz = ddx[ZZ];
}
else
{
dx = pco[XX]-xi;
dy = pco[YY]-yi;
dz = pco[ZZ]-zi;
}
dd = dx*dx+dy*dy+dz*dz;
as = ai+aj;
if (dd > as*as)
{
continue;
}
nnei++;
ctnb->x = dx;
ctnb->y = dy;
ctnb->z = dz;
ctnb->dot = (dd+aisq-ajsq)/(2.*ai); /* reference dot product */
ctnb++;
}
/* check points on accessibility */
if (nnei)
{
last = 0; i_ac = 0;
for (l = 0; l < n_dot; l++)
{
if (xus[3*l]*(wknb+last)->x+
xus[1+3*l]*(wknb+last)->y+
xus[2+3*l]*(wknb+last)->z <= (wknb+last)->dot)
{
for (j = 0; j < nnei; j++)
{
if (xus[3*l]*(wknb+j)->x+xus[1+3*l]*(wknb+j)->y+
xus[2+3*l]*(wknb+j)->z > (wknb+j)->dot)
{
last = j;
break;
}
}
if (j >= nnei)
{
i_ac++;
wkdot[l] = 1;
}
} /* end of cycle j */
} /* end of cycle l */
}
else
{
i_ac = n_dot;
for (l = 0; l < n_dot; l++)
{
wkdot[l] = 1;
}
}
if (debug)
{
fprintf(debug, "i_ac=%d, dotarea=%8.3f, aisq=%8.3f\n",
i_ac, dotarea, aisq);
}
a = aisq*dotarea* (real) i_ac;
area = area + a;
if (mode & FLAG_ATOM_AREA)
{
range_check(wkatm[iat], 0, nat);
atom_area[wkatm[iat]] = a;
}
if (mode & FLAG_DOTS)
{
for (l = 0; l < n_dot; l++)
{
if (wkdot[l])
{
lfnr++;
if (maxdots <= 3*lfnr+1)
{
maxdots = maxdots+n_dot*3;
srenew(dots, maxdots);
}
dots[3*lfnr-3] = ai*xus[3*l]+xi;
dots[3*lfnr-2] = ai*xus[1+3*l]+yi;
dots[3*lfnr-1] = ai*xus[2+3*l]+zi;
}
}
}
if (mode & FLAG_VOLUME)
{
dx = 0.; dy = 0.; dz = 0.;
for (l = 0; l < n_dot; l++)
{
if (wkdot[l])
{
dx = dx+xus[3*l];
dy = dy+xus[1+3*l];
dz = dz+xus[2+3*l];
}
}
vol = vol+aisq*(dx*(xi-xs)+dy*(yi-ys)+dz*(zi-zs)+ai* (real) i_ac);
}
} /* end of cycle "iat" */
} /* end of cycle "ix" */
} /* end of cycle "iy" */
} /* end of cycle "iz" */
sfree(wkatm);
sfree(wkat1);
sfree(wkdot);
sfree(wkbox);
sfree(wknb);
if (box)
{
sfree(x);
}
if (mode & FLAG_VOLUME)
{
vol = vol*FOURPI/(3.* (real) n_dot);
*value_of_vol = vol;
}
if (mode & FLAG_DOTS)
{
*nu_dots = lfnr;
*lidots = dots;
}
if (mode & FLAG_ATOM_AREA)
{
*at_area = atom_area;
}
*value_of_area = area;
if (debug)
{
fprintf(debug, "area=%8.3f\n", area);
}
return 0;
}
int make_unsp(int densit, int mode, int * num_dot, int cubus)
{
int *ico_wk, *ico_pt;
int ndot, ico_cube_cb, i, j, k, l, ijk, tn, tl, tl2;
real *xus;
int *work;
real x, y, z;
if (xpunsp)
{
free(xpunsp);
}
k = 1; if (mode < 0)
{
k = 0; mode = -mode;
}
if (mode == UNSP_ICO_ARC)
{
ndot = ico_dot_arc(densit);
}
else if (mode == UNSP_ICO_DOD)
{
ndot = ico_dot_dod(densit);
}
else
{
WARNING("make_unsp: mode %c%d not allowed", (k) ? '+' : '-', mode);
return 1;
}
last_n_dot = ndot; last_densit = densit; last_unsp = mode;
*num_dot = ndot; if (k)
{
return 0;
}
/* in the following the dots of the unit sphere may be resorted */
last_unsp = -last_unsp;
/* determine distribution of points in elementary cubes */
if (cubus)
{
ico_cube = cubus;
}
else
{
last_cubus = 0;
i = 1;
while (i*i*i*2 < ndot)
{
i++;
}
ico_cube = max(i-1, 0);
}
ico_cube_cb = ico_cube*ico_cube*ico_cube;
del_cube = 2./((real)ico_cube);
snew(work, ndot);
xus = xpunsp;
for (l = 0; l < ndot; l++)
{
i = max((int) floor((1.+xus[3*l])/del_cube), 0);
if (i >= ico_cube)
{
i = ico_cube-1;
}
j = max((int) floor((1.+xus[1+3*l])/del_cube), 0);
if (j >= ico_cube)
{
j = ico_cube-1;
}
k = max((int) floor((1.+xus[2+3*l])/del_cube), 0);
if (k >= ico_cube)
{
k = ico_cube-1;
}
ijk = i+j*ico_cube+k*ico_cube*ico_cube;
work[l] = ijk;
}
snew(ico_wk, 2*ico_cube_cb+1);
ico_pt = ico_wk+ico_cube_cb;
for (l = 0; l < ndot; l++)
{
ico_wk[work[l]]++; /* dots per elementary cube */
}
/* reordering of the coordinate array in accordance with box number */
tn = 0;
for (i = 0; i < ico_cube; i++)
{
for (j = 0; j < ico_cube; j++)
{
for (k = 0; k < ico_cube; k++)
{
tl = 0;
tl2 = tn;
ijk = i+ico_cube*j+ico_cube*ico_cube*k;
*(ico_pt+ijk) = tn;
for (l = tl2; l < ndot; l++)
{
if (ijk == work[l])
{
x = xus[3*l]; y = xus[1+3*l]; z = xus[2+3*l];
xus[3*l] = xus[3*tn];
xus[1+3*l] = xus[1+3*tn]; xus[2+3*l] = xus[2+3*tn];
xus[3*tn] = x; xus[1+3*tn] = y; xus[2+3*tn] = z;
ijk = work[l]; work[l] = work[tn]; work[tn] = ijk;
tn++; tl++;
}
}
*(ico_wk+ijk) = tl;
} /* cycle k */
} /* cycle j */
} /* cycle i */
sfree(ico_wk);
sfree(work);
return 0;
}
static struct iio_context * iio_create_xml_context_helper(xmlDoc *doc)
{
unsigned int i;
xmlNode *root, *n;
xmlAttr *attr;
int err = ENOMEM;
struct iio_context *ctx = calloc(1, sizeof(*ctx));
if (!ctx)
goto err_set_errno;
ctx->name = "xml";
ctx->ops = &xml_ops;
root = xmlDocGetRootElement(doc);
if (strcmp((char *) root->name, "context")) {
ERROR("Unrecognized XML file\n");
err = EINVAL;
goto err_free_ctx;
}
for (attr = root->properties; attr; attr = attr->next) {
if (!strcmp((char *) attr->name, "description"))
ctx->description = _strdup(
(char *) attr->children->content);
else if (strcmp((char *) attr->name, "name"))
WARNING("Unknown parameter \'%s\' in <context>\n",
(char *) attr->children->content);
}
for (n = root->children; n; n = n->next) {
struct iio_device **devs, *dev;
if (strcmp((char *) n->name, "device")) {
if (strcmp((char *) n->name, "text"))
WARNING("Unknown children \'%s\' in "
"<context>\n", n->name);
continue;
}
dev = create_device(ctx, n);
if (!dev) {
ERROR("Unable to create device\n");
goto err_free_devices;
}
devs = realloc(ctx->devices, (1 + ctx->nb_devices) *
sizeof(struct iio_device *));
if (!devs) {
ERROR("Unable to allocate memory\n");
free(dev);
goto err_free_devices;
}
devs[ctx->nb_devices++] = dev;
ctx->devices = devs;
}
iio_context_init(ctx);
return ctx;
err_free_devices:
for (i = 0; i < ctx->nb_devices; i++)
free_device(ctx->devices[i]);
if (ctx->nb_devices)
free(ctx->devices);
err_free_ctx:
free(ctx);
err_set_errno:
errno = err;
return NULL;
}
static int csnmp_config_add_data (oconfig_item_t *ci)
{
data_definition_t *dd;
int status = 0;
int i;
if ((ci->values_num != 1)
|| (ci->values[0].type != OCONFIG_TYPE_STRING))
{
WARNING ("snmp plugin: The `Data' config option needs exactly one string argument.");
return (-1);
}
dd = (data_definition_t *) malloc (sizeof (data_definition_t));
if (dd == NULL)
return (-1);
memset (dd, '\0', sizeof (data_definition_t));
dd->name = strdup (ci->values[0].value.string);
if (dd->name == NULL)
{
free (dd);
return (-1);
}
dd->scale = 1.0;
dd->shift = 0.0;
for (i = 0; i < ci->children_num; i++)
{
oconfig_item_t *option = ci->children + i;
status = 0;
if (strcasecmp ("Type", option->key) == 0)
status = csnmp_config_add_data_type (dd, option);
else if (strcasecmp ("Table", option->key) == 0)
status = csnmp_config_add_data_table (dd, option);
else if (strcasecmp ("Instance", option->key) == 0)
status = csnmp_config_add_data_instance (dd, option);
else if (strcasecmp ("InstancePrefix", option->key) == 0)
status = csnmp_config_add_data_instance_prefix (dd, option);
else if (strcasecmp ("Values", option->key) == 0)
status = csnmp_config_add_data_values (dd, option);
else if (strcasecmp ("Shift", option->key) == 0)
status = csnmp_config_add_data_shift (dd, option);
else if (strcasecmp ("Scale", option->key) == 0)
status = csnmp_config_add_data_scale (dd, option);
else
{
WARNING ("snmp plugin: Option `%s' not allowed here.", option->key);
status = -1;
}
if (status != 0)
break;
} /* for (ci->children) */
while (status == 0)
{
if (dd->type == NULL)
{
WARNING ("snmp plugin: `Type' not given for data `%s'", dd->name);
status = -1;
break;
}
if (dd->values == NULL)
{
WARNING ("snmp plugin: No `Value' given for data `%s'", dd->name);
status = -1;
break;
}
break;
} /* while (status == 0) */
if (status != 0)
{
sfree (dd->name);
sfree (dd->instance_prefix);
sfree (dd->values);
sfree (dd);
return (-1);
}
DEBUG ("snmp plugin: dd = { name = %s, type = %s, is_table = %s, values_len = %i }",
dd->name, dd->type, (dd->is_table != 0) ? "true" : "false", dd->values_len);
if (data_head == NULL)
data_head = dd;
else
{
data_definition_t *last;
last = data_head;
while (last->next != NULL)
last = last->next;
last->next = dd;
}
return (0);
} /* int csnmp_config_add_data */
LRESULT CFrameHolder::OnPaint(HWND hWnd, HDC hdc, UINT uMsg)
{
if (hdc == NULL)
{
LRESULT lRc = 0;
PAINTSTRUCT ps = {0};
hdc = BeginPaint(hWnd, &ps);
if (hdc != NULL)
{
lRc = OnPaint(hWnd, hdc, uMsg);
EndPaint(hWnd, &ps);
}
else
{
_ASSERTE(hdc != NULL);
}
return lRc;
}
#ifdef _DEBUG
RECT rcClientReal = {}; GetClientRect(hWnd, &rcClientReal);
MapWindowPoints(hWnd, NULL, (LPPOINT)&rcClientReal, 2);
#endif
// Если "завис" PostUpdate
if (gpConEmu->mp_TabBar->NeedPostUpdate())
gpConEmu->mp_TabBar->Update();
// Go
RECT wr, cr;
RecalculateFrameSizes();
wr = gpConEmu->GetGuiClientRect();
#ifdef _DEBUG
wchar_t szPaint[140];
_wsprintf(szPaint, SKIPCOUNT(szPaint) L"MainClient %s at {%i,%i}-{%i,%i} screen coords, size (%ix%i) calc (%ix%i)",
(uMsg == WM_PAINT) ? L"WM_PAINT" : (uMsg == WM_PRINTCLIENT) ? L"WM_PRINTCLIENT" : L"UnknownMsg",
LOGRECTCOORDS(rcClientReal), LOGRECTSIZE(rcClientReal), LOGRECTSIZE(wr));
DEBUGSTRPAINT(szPaint);
#endif
#if defined(CONEMU_TABBAR_EX)
#ifdef RED_CLIENT_FILL
HBRUSH h = CreateSolidBrush(RGB(255,0,0));
FillRect(hdc, &wr, h);
DeleteObject(h);
return 0;
#endif
#endif
if (gpSet->isStatusBarShow)
{
int nHeight = gpSet->StatusBarHeight();
if (nHeight < (wr.bottom - wr.top))
{
RECT rcStatus = {wr.left, wr.bottom - nHeight, wr.right, wr.bottom};
gpConEmu->mp_Status->PaintStatus(hdc, &rcStatus);
wr.bottom = rcStatus.top;
}
}
cr = wr;
DEBUGTEST(FrameDrawStyle dt = gpConEmu->DrawType());
#if defined(CONEMU_TABBAR_EX)
RECT tr = {};
if (!gpSet->isTabsInCaption)
{
_ASSERTE(gpConEmu->GetDwmClientRectTopOffset() == 0); // CheckIt, must be zero
if (gpSet->isTabs)
{
RECT captrect = gpConEmu->CalcRect(CER_TAB, wr, CER_MAINCLIENT);
//CalculateCaptionPosition(cr, &captrect);
CalculateTabPosition(cr, captrect, &tr);
PaintDC dc = {false};
RECT pr = {captrect.left, 0, captrect.right, captrect.bottom};
gpConEmu->BeginBufferedPaint(hdc, pr, dc);
gpConEmu->mp_TabBar->PaintTabs(dc, captrect, tr);
gpConEmu->EndBufferedPaint(dc, TRUE);
}
}
else if (dt == fdt_Aero || dt == fdt_Win8)
{
_ASSERTE(gpSet->isTabsInCaption);
int nOffset = gpConEmu->GetDwmClientRectTopOffset();
// "Рамка" расширена на клиентскую область, поэтому
// нужно зарисовать заголовок черной кистью, иначе идет
// искажение цвета для кнопок Min/Max/Close
if (gpSet->isTabs)
{
RECT captrect = gpConEmu->CalcRect(CER_TAB, wr, CER_MAINCLIENT);
//CalculateCaptionPosition(cr, &captrect);
CalculateTabPosition(cr, captrect, &tr);
PaintDC dc = {false};
RECT pr = {captrect.left, 0, captrect.right, captrect.bottom};
gpConEmu->BeginBufferedPaint(hdc, pr, dc);
gpConEmu->mp_TabBar->PaintTabs(dc, captrect, tr);
gpConEmu->EndBufferedPaint(dc, TRUE);
// There is no "Glass" in Win8
mb_WasGlassDraw = IsWindows7 && !IsWindows8;
}
cr.top += nOffset;
}
#endif
#ifdef _DEBUG
int nWidth = (cr.right-cr.left);
int nHeight = (cr.bottom-cr.top);
#endif
WARNING("Пока табы рисуем не сами и ExtendDWM отсутствует - дополнительные изыски с временным DC не нужны");
#if 0
if (!gpSet->isTabsInCaption)
{
//OnPaintClient(hdc/*, nWidth, nHeight*/);
}
else
// Создадим временный DC, для удобства отрисовки в Glass-режиме и для фикса глюка DWM(?) см.ниже
// В принципе, для режима Win2k/XP временный DC можно не создавать, если это будет тормозить
{
//_ASSERTE(FALSE && "Need to be rewritten");
HDC hdcPaint = CreateCompatibleDC(hdc);
HBITMAP hbmp = CreateCompatibleBitmap(hdc, nWidth, nHeight);
HBITMAP hOldBmp = (HBITMAP)SelectObject(hdcPaint, hbmp);
//OnPaintClient(hdcPaint/*, nWidth, nHeight*/);
if ((dt == fdt_Aero) || !(mb_WasGlassDraw && gpConEmu->isZoomed()))
{
BitBlt(hdc, cr.left, cr.top, nWidth, nHeight, hdcPaint, 0, 0, SRCCOPY);
}
else
{
//mb_WasGlassDraw = FALSE;
// Какой-то странный глюк DWM. При отключении Glass несколько верхних строк
// клиентской области оказываются "разрушенными" - у них остается атрибут "прозрачности"
// хотя прозрачность (Glass) уже отключена. В результате эти строки - белесые
BITMAPINFOHEADER bi = {sizeof(BITMAPINFOHEADER)};
bi.biWidth = cr.right-cr.left+1;
bi.biHeight = GetFrameHeight()+1;
bi.biPlanes = 1;
bi.biBitCount = 32;
COLORREF *pPixels = NULL;
HDC hdcTmp = CreateCompatibleDC(hdc);
HBITMAP hTmp = CreateDIBSection(hdcTmp, (BITMAPINFO*)&bi, DIB_RGB_COLORS, (void**)&pPixels, NULL, 0);
if (hTmp == NULL)
{
_ASSERTE(hTmp == NULL);
BitBlt(hdc, cr.left, cr.top, nWidth, nHeight, hdcPaint, 0, 0, SRCCOPY);
}
else
{
HBITMAP hOldTmp = (HBITMAP)SelectObject(hdcTmp, hTmp);
BitBlt(hdcTmp, 0, 0, bi.biWidth, bi.biHeight, hdcPaint, 0, 0, SRCCOPY);
int i = 0;
for (int y = 0; y < bi.biHeight; y++)
{
for (int x = 0; x < bi.biWidth; x++)
{
pPixels[i++] |= 0xFF000000;
}
}
BitBlt(hdc, cr.left, cr.top, bi.biWidth, bi.biHeight, hdcTmp, 0, 0, SRCCOPY);
if (nHeight > bi.biHeight)
BitBlt(hdc, cr.left, cr.top+bi.biHeight, nWidth, nHeight-bi.biHeight, hdcPaint, 0, bi.biHeight, SRCCOPY);
SelectObject(hdcTmp, hOldTmp);
DeleteObject(hbmp);
}
DeleteDC(hdcTmp);
}
SelectObject(hdcPaint, hOldBmp);
DeleteObject(hbmp);
DeleteDC(hdcPaint);
}
#endif
return 0;
}
static int csnmp_config_add_host (oconfig_item_t *ci)
{
host_definition_t *hd;
int status = 0;
int i;
/* Registration stuff. */
char cb_name[DATA_MAX_NAME_LEN];
user_data_t cb_data;
struct timespec cb_interval;
if ((ci->values_num != 1) || (ci->values[0].type != OCONFIG_TYPE_STRING))
{
WARNING ("snmp plugin: `Host' needs exactly one string argument.");
return (-1);
}
hd = (host_definition_t *) malloc (sizeof (host_definition_t));
if (hd == NULL)
return (-1);
memset (hd, '\0', sizeof (host_definition_t));
hd->version = 2;
C_COMPLAIN_INIT (&hd->complaint);
hd->name = strdup (ci->values[0].value.string);
if (hd->name == NULL)
{
free (hd);
return (-1);
}
hd->sess_handle = NULL;
hd->interval = 0;
for (i = 0; i < ci->children_num; i++)
{
oconfig_item_t *option = ci->children + i;
status = 0;
if (strcasecmp ("Address", option->key) == 0)
status = csnmp_config_add_host_address (hd, option);
else if (strcasecmp ("Community", option->key) == 0)
status = csnmp_config_add_host_community (hd, option);
else if (strcasecmp ("Version", option->key) == 0)
status = csnmp_config_add_host_version (hd, option);
else if (strcasecmp ("Collect", option->key) == 0)
csnmp_config_add_host_collect (hd, option);
else if (strcasecmp ("Interval", option->key) == 0)
cf_util_get_cdtime (option, &hd->interval);
else
{
WARNING ("snmp plugin: csnmp_config_add_host: Option `%s' not allowed here.", option->key);
status = -1;
}
if (status != 0)
break;
} /* for (ci->children) */
while (status == 0)
{
if (hd->address == NULL)
{
WARNING ("snmp plugin: `Address' not given for host `%s'", hd->name);
status = -1;
break;
}
if (hd->community == NULL)
{
WARNING ("snmp plugin: `Community' not given for host `%s'", hd->name);
status = -1;
break;
}
break;
} /* while (status == 0) */
if (status != 0)
{
csnmp_host_definition_destroy (hd);
return (-1);
}
DEBUG ("snmp plugin: hd = { name = %s, address = %s, community = %s, version = %i }",
hd->name, hd->address, hd->community, hd->version);
ssnprintf (cb_name, sizeof (cb_name), "snmp-%s", hd->name);
memset (&cb_data, 0, sizeof (cb_data));
cb_data.data = hd;
cb_data.free_func = csnmp_host_definition_destroy;
CDTIME_T_TO_TIMESPEC (hd->interval, &cb_interval);
status = plugin_register_complex_read (/* group = */ NULL, cb_name,
csnmp_read_host, /* interval = */ &cb_interval,
/* user_data = */ &cb_data);
if (status != 0)
{
ERROR ("snmp plugin: Registering complex read function failed.");
csnmp_host_definition_destroy (hd);
return (-1);
}
return (0);
} /* int csnmp_config_add_host */
/**
* Static: Rename a data file.
*
* This function will rename a raw data file into the datastream directory
* using the datastream name and begin_time to give it a fully qualified
* ARM name.
*
* The begin_time will be validated using:
*
* dsproc_validate_datastream_data_time()
*
* If the end_time is specified, this function will verify that it is greater
* than the begin_time and is not in the future. If only one record was found
* in the raw file, the end_time argument must be set to NULL.
*
* If the output file exists and has the same MD5 as the input file,
* the input file will be removed and a warning message will be generated.
*
* If the output file exists and has a different MD5 than the input
* file, the rename will fail.
*
* If an error occurs in this function it will be appended to the log and
* error mail messages, and the process status will be set appropriately.
*
* @param ds_id - datastream ID
* @param file_path - path to the directory the file is in
* @param file_name - name of the file to rename
* @param begin_time - time of the first record in the file
* @param end_time - time of the last record in the file
* @param extension - extension to use when renaming the file, or NULL to
* use the default extension for the datastream format.
*
* @return
* - 1 if successful
* - 0 if an error occurred
*/
static int _dsproc_rename(
int ds_id,
const char *file_path,
const char *file_name,
const timeval_t *begin_time,
const timeval_t *end_time,
const char *extension)
{
DataStream *ds = _DSProc->datastreams[ds_id];
time_t now = time(NULL);
int force_mode = dsproc_get_force_mode();
char src_file[PATH_MAX];
struct stat src_stats;
char src_md5[64];
char done_dir[PATH_MAX];
char *dest_path;
char dest_name[256];
char dest_file[PATH_MAX];
char dest_md5[64];
struct tm time_stamp_tm;
char time_stamp[32];
char time_string1[32];
char time_string2[32];
const char *preserve;
int dot_count;
char rename_error[2*PATH_MAX];
int rename_file;
memset(&time_stamp_tm, 0, sizeof(struct tm));
DEBUG_LV1( DSPROC_LIB_NAME,
"%s: Renaming file: %s/%s\n",
ds->name, file_path, file_name);
/************************************************************
* Get source file stats
*************************************************************/
snprintf(src_file, PATH_MAX, "%s/%s", file_path, file_name);
if (access(src_file, F_OK) != 0) {
if (errno == ENOENT) {
ERROR( DSPROC_LIB_NAME,
"Could not rename file: %s\n"
" -> file does not exist\n", src_file);
dsproc_set_status(DSPROC_ENOSRCFILE);
}
else {
ERROR( DSPROC_LIB_NAME,
"Could not access file: %s\n"
" -> %s\n", src_file, strerror(errno));
dsproc_set_status(DSPROC_EACCESS);
}
return(0);
}
if (stat(src_file, &src_stats) < 0) {
ERROR( DSPROC_LIB_NAME,
"Could not rename file: %s\n"
" -> stat error: %s\n", src_file, strerror(errno));
dsproc_set_status(DSPROC_EFILESTATS);
return(0);
}
/************************************************************
* Validate datastream times
*************************************************************/
/* validate begin time */
if (!force_mode) {
if (!begin_time || !begin_time->tv_sec) {
ERROR( DSPROC_LIB_NAME,
"Could not rename file: %s\n"
" -> file time not specified\n", src_file);
dsproc_set_status(DSPROC_ENOFILETIME);
return(0);
}
if (!dsproc_validate_datastream_data_time(ds_id, begin_time)) {
ERROR( DSPROC_LIB_NAME,
"Could not rename file: %s\n"
" -> time validation error\n", src_file);
return(0);
}
/* validate end time */
if (end_time && end_time->tv_sec) {
if (TV_LTEQ(*end_time, *begin_time)) {
format_timeval(begin_time, time_string2);
format_timeval(end_time, time_string1);
ERROR( DSPROC_LIB_NAME,
"Could not rename file: %s\n"
" -> end time '%s' <= begin time '%s'\n",
src_file, time_string1, time_string2);
dsproc_set_status(DSPROC_ETIMEORDER);
return(0);
}
else if (end_time->tv_sec > now) {
format_timeval(end_time, time_string1);
format_secs1970(now, time_string2);
ERROR( DSPROC_LIB_NAME,
"Could not rename file: %s\n"
" -> data time '%s' is in the future (current time is: %s)\n",
src_file, time_string1, time_string2);
dsproc_disable(DSPROC_EFUTURETIME);
return(0);
}
}
}
/************************************************************
* Determine the portion of the original file name to preserve
*************************************************************/
preserve = (const char *)NULL;
if (ds->preserve_dots > 0) {
dot_count = 0;
for (preserve = file_name + strlen(file_name) - 1;
preserve != file_name;
preserve--) {
if (*preserve == '.') {
dot_count++;
if (dot_count == ds->preserve_dots) {
preserve++;
break;
}
}
}
}
/************************************************************
* Get the full path to the destination directory
*************************************************************/
snprintf(done_dir, PATH_MAX, "%s/.done", file_path);
if (access(done_dir, F_OK) == 0) {
dest_path = done_dir;
}
else if (errno != ENOENT) {
ERROR( DSPROC_LIB_NAME,
"Could not access directory: %s\n"
" -> %s\n", done_dir, strerror(errno));
dsproc_set_status(DSPROC_EACCESS);
return(0);
}
else {
dest_path = ds->dir->path;
/* Make sure the destination directory exists */
if (!make_path(dest_path, 0775)) {
ERROR( DSPROC_LIB_NAME,
"Could not rename file: %s\n"
" -> make_path failed for: %s\n",
src_file, dest_path);
dsproc_set_status(DSPROC_EDESTDIRMAKE);
return(0);
}
}
/************************************************************
* Create the time stamp for the destination file
*************************************************************/
if (!gmtime_r(&begin_time->tv_sec, &time_stamp_tm)) {
ERROR( DSPROC_LIB_NAME,
"Could not rename file: %s\n"
" -> gmtime error: %s\n",
src_file, strerror(errno));
dsproc_set_status(DSPROC_ETIMECALC);
return(0);
}
strftime(time_stamp, 32, "%Y%m%d.%H%M%S", &time_stamp_tm);
/************************************************************
* Create the output file name
*************************************************************/
if (!extension) {
extension = ds->extension;
}
if (preserve) {
snprintf(dest_name, 256, "%s.%s.%s.%s",
ds->name, time_stamp, extension, preserve);
}
else {
snprintf(dest_name, 256, "%s.%s.%s",
ds->name, time_stamp, extension);
}
snprintf(dest_file, PATH_MAX, "%s/%s", dest_path, dest_name);
/************************************************************
* Check if the output file already exists
*************************************************************/
rename_file = 1;
if (access(dest_file, F_OK) == 0) {
sprintf(rename_error,
"\n"
"Found existing destination file while renaming source file:\n"
" -> from: %s\n"
" -> to: %s\n",
src_file, dest_file);
/* Check the MD5s */
if (!file_get_md5(src_file, src_md5)) {
ERROR( DSPROC_LIB_NAME,
"%s -> could not get source file MD5\n",
rename_error);
dsproc_set_status(DSPROC_EFILEMD5);
return(0);
}
if (!file_get_md5(dest_file, dest_md5)) {
ERROR( DSPROC_LIB_NAME,
"%s -> could not get destination file MD5\n",
rename_error);
dsproc_set_status(DSPROC_EFILEMD5);
return(0);
}
if (strcmp(src_md5, dest_md5) == 0) {
/* The MD5s match so delete the input file */
if (unlink(src_file) < 0) {
ERROR( DSPROC_LIB_NAME,
"%s"
" -> source and destination files have matching MD5s\n"
" -> could not delete source file: %s\n",
rename_error, strerror(errno));
dsproc_set_status(DSPROC_EUNLINK);
return(0);
}
WARNING( DSPROC_LIB_NAME,
"%s"
" -> source and destination files have matching MD5s\n"
" -> deleted source file\n",
rename_error);
rename_file = 0;
}
else {
/* The MD5s do not match */
ERROR( DSPROC_LIB_NAME,
"%s"
" -> source and destination files have different MD5s\n",
rename_error);
dsproc_set_status(DSPROC_EMD5CHECK);
return(0);
}
}
else if (errno != ENOENT) {
ERROR( DSPROC_LIB_NAME,
"Could not access file: %s\n"
" -> %s\n", dest_file, strerror(errno));
dsproc_set_status(DSPROC_EACCESS);
return(0);
}
/************************************************************
* Rename the file
*************************************************************/
if (rename_file) {
LOG( DSPROC_LIB_NAME,
"Renaming: %s\n"
" -> to: %s\n",
src_file, dest_file);
if (!file_move(src_file, dest_file, FC_CHECK_MD5)) {
dsproc_set_status(DSPROC_EFILEMOVE);
return(0);
}
/* Update the access and modification times */
utime(dest_file, NULL);
}
/************************************************************
* Update the datastream file stats
*************************************************************/
dsproc_update_datastream_file_stats(
ds_id, (double)src_stats.st_size, begin_time, end_time);
return(1);
}
/* TODO: Check if negative values wrap around. Problem: negative temperatures. */
static value_t csnmp_value_list_to_value (struct variable_list *vl, int type,
double scale, double shift,
const char *host_name, const char *data_name)
{
value_t ret;
uint64_t tmp_unsigned = 0;
int64_t tmp_signed = 0;
_Bool defined = 1;
/* Set to true when the original SNMP type appears to have been signed. */
_Bool prefer_signed = 0;
if ((vl->type == ASN_INTEGER)
|| (vl->type == ASN_UINTEGER)
|| (vl->type == ASN_COUNTER)
#ifdef ASN_TIMETICKS
|| (vl->type == ASN_TIMETICKS)
#endif
|| (vl->type == ASN_GAUGE))
{
tmp_unsigned = (uint32_t) *vl->val.integer;
tmp_signed = (int32_t) *vl->val.integer;
if ((vl->type == ASN_INTEGER)
|| (vl->type == ASN_GAUGE))
prefer_signed = 1;
DEBUG ("snmp plugin: Parsed int32 value is %"PRIu64".", tmp_unsigned);
}
else if (vl->type == ASN_COUNTER64)
{
tmp_unsigned = (uint32_t) vl->val.counter64->high;
tmp_unsigned = tmp_unsigned << 32;
tmp_unsigned += (uint32_t) vl->val.counter64->low;
tmp_signed = (int64_t) tmp_unsigned;
DEBUG ("snmp plugin: Parsed int64 value is %"PRIu64".", tmp_unsigned);
}
else if (vl->type == ASN_OCTET_STR)
{
/* We'll handle this later.. */
}
else
{
char oid_buffer[1024];
memset (oid_buffer, 0, sizeof (oid_buffer));
snprint_objid (oid_buffer, sizeof (oid_buffer) - 1,
vl->name, vl->name_length);
#ifdef ASN_NULL
if (vl->type == ASN_NULL)
INFO ("snmp plugin: OID \"%s\" is undefined (type ASN_NULL)",
oid_buffer);
else
#endif
WARNING ("snmp plugin: I don't know the ASN type #%i "
"(OID: \"%s\", data block \"%s\", host block \"%s\")",
(int) vl->type, oid_buffer,
(data_name != NULL) ? data_name : "UNKNOWN",
(host_name != NULL) ? host_name : "UNKNOWN");
defined = 0;
}
if (vl->type == ASN_OCTET_STR)
{
int status = -1;
if (vl->val.string != NULL)
{
char string[64];
size_t string_length;
string_length = sizeof (string) - 1;
if (vl->val_len < string_length)
string_length = vl->val_len;
/* The strings we get from the Net-SNMP library may not be null
* terminated. That is why we're using `memcpy' here and not `strcpy'.
* `string_length' is set to `vl->val_len' which holds the length of the
* string. -octo */
memcpy (string, vl->val.string, string_length);
string[string_length] = 0;
status = parse_value (string, &ret, type);
if (status != 0)
{
ERROR ("snmp plugin: csnmp_value_list_to_value: Parsing string as %s failed: %s",
DS_TYPE_TO_STRING (type), string);
}
}
if (status != 0)
{
switch (type)
{
case DS_TYPE_COUNTER:
case DS_TYPE_DERIVE:
case DS_TYPE_ABSOLUTE:
memset (&ret, 0, sizeof (ret));
break;
case DS_TYPE_GAUGE:
ret.gauge = NAN;
break;
default:
ERROR ("snmp plugin: csnmp_value_list_to_value: Unknown "
"data source type: %i.", type);
ret.gauge = NAN;
}
}
} /* if (vl->type == ASN_OCTET_STR) */
else if (type == DS_TYPE_COUNTER)
{
ret.counter = tmp_unsigned;
}
else if (type == DS_TYPE_GAUGE)
{
if (!defined)
ret.gauge = NAN;
else if (prefer_signed)
ret.gauge = (scale * tmp_signed) + shift;
else
ret.gauge = (scale * tmp_unsigned) + shift;
}
else if (type == DS_TYPE_DERIVE)
{
if (prefer_signed)
ret.derive = (derive_t) tmp_signed;
else
ret.derive = (derive_t) tmp_unsigned;
}
else if (type == DS_TYPE_ABSOLUTE)
{
ret.absolute = (absolute_t) tmp_unsigned;
}
else
{
ERROR ("snmp plugin: csnmp_value_list_to_value: Unknown data source "
"type: %i.", type);
ret.gauge = NAN;
}
return (ret);
} /* value_t csnmp_value_list_to_value */
/* initialize curl for each host */
static int init_host (apache_t *st) /* {{{ */
{
assert (st->url != NULL);
/* (Assured by `config_add') */
if (st->curl != NULL)
{
curl_easy_cleanup (st->curl);
st->curl = NULL;
}
if ((st->curl = curl_easy_init ()) == NULL)
{
ERROR ("apache plugin: init_host: `curl_easy_init' failed.");
return (-1);
}
curl_easy_setopt (st->curl, CURLOPT_NOSIGNAL, 1L);
curl_easy_setopt (st->curl, CURLOPT_WRITEFUNCTION, apache_curl_callback);
curl_easy_setopt (st->curl, CURLOPT_WRITEDATA, st);
/* not set as yet if the user specified string doesn't match apache or
* lighttpd, then ignore it. Headers will be parsed to find out the
* server type */
st->server_type = -1;
if (st->server != NULL)
{
if (strcasecmp(st->server, "apache") == 0)
st->server_type = APACHE;
else if (strcasecmp(st->server, "lighttpd") == 0)
st->server_type = LIGHTTPD;
else if (strcasecmp(st->server, "ibm_http_server") == 0)
st->server_type = APACHE;
else
WARNING ("apache plugin: Unknown `Server' setting: %s",
st->server);
}
/* if not found register a header callback to determine the server_type */
if (st->server_type == -1)
{
curl_easy_setopt (st->curl, CURLOPT_HEADERFUNCTION, apache_header_callback);
curl_easy_setopt (st->curl, CURLOPT_WRITEHEADER, st);
}
curl_easy_setopt (st->curl, CURLOPT_USERAGENT, COLLECTD_USERAGENT);
curl_easy_setopt (st->curl, CURLOPT_ERRORBUFFER, st->apache_curl_error);
if (st->user != NULL)
{
#ifdef HAVE_CURLOPT_USERNAME
curl_easy_setopt (st->curl, CURLOPT_USERNAME, st->user);
curl_easy_setopt (st->curl, CURLOPT_PASSWORD,
(st->pass == NULL) ? "" : st->pass);
#else
static char credentials[1024];
int status;
status = ssnprintf (credentials, sizeof (credentials), "%s:%s",
st->user, (st->pass == NULL) ? "" : st->pass);
if ((status < 0) || ((size_t) status >= sizeof (credentials)))
{
ERROR ("apache plugin: init_host: Returning an error "
"because the credentials have been "
"truncated.");
curl_easy_cleanup (st->curl);
st->curl = NULL;
return (-1);
}
curl_easy_setopt (st->curl, CURLOPT_USERPWD, credentials);
#endif
}
curl_easy_setopt (st->curl, CURLOPT_URL, st->url);
curl_easy_setopt (st->curl, CURLOPT_FOLLOWLOCATION, 1L);
curl_easy_setopt (st->curl, CURLOPT_MAXREDIRS, 50L);
curl_easy_setopt (st->curl, CURLOPT_SSL_VERIFYPEER,
(long) st->verify_peer);
curl_easy_setopt (st->curl, CURLOPT_SSL_VERIFYHOST,
st->verify_host ? 2L : 0L);
if (st->cacert != NULL)
curl_easy_setopt (st->curl, CURLOPT_CAINFO, st->cacert);
return (0);
} /* }}} int init_host */
static int interface_read (void)
{
#if HAVE_GETIFADDRS
struct ifaddrs *if_list;
struct ifaddrs *if_ptr;
/* Darin/Mac OS X and possible other *BSDs */
#if HAVE_STRUCT_IF_DATA
# define IFA_DATA if_data
# define IFA_RX_BYTES ifi_ibytes
# define IFA_TX_BYTES ifi_obytes
# define IFA_RX_PACKT ifi_ipackets
# define IFA_TX_PACKT ifi_opackets
# define IFA_RX_ERROR ifi_ierrors
# define IFA_TX_ERROR ifi_oerrors
/* #endif HAVE_STRUCT_IF_DATA */
#elif HAVE_STRUCT_NET_DEVICE_STATS
# define IFA_DATA net_device_stats
# define IFA_RX_BYTES rx_bytes
# define IFA_TX_BYTES tx_bytes
# define IFA_RX_PACKT rx_packets
# define IFA_TX_PACKT tx_packets
# define IFA_RX_ERROR rx_errors
# define IFA_TX_ERROR tx_errors
#else
# error "No suitable type for `struct ifaddrs->ifa_data' found."
#endif
struct IFA_DATA *if_data;
if (getifaddrs (&if_list) != 0)
return (-1);
for (if_ptr = if_list; if_ptr != NULL; if_ptr = if_ptr->ifa_next)
{
if ((if_data = (struct IFA_DATA *) if_ptr->ifa_data) == NULL)
continue;
if_submit (if_ptr->ifa_name, "if_octets",
if_data->IFA_RX_BYTES,
if_data->IFA_TX_BYTES);
if_submit (if_ptr->ifa_name, "if_packets",
if_data->IFA_RX_PACKT,
if_data->IFA_TX_PACKT);
if_submit (if_ptr->ifa_name, "if_errors",
if_data->IFA_RX_ERROR,
if_data->IFA_TX_ERROR);
}
freeifaddrs (if_list);
/* #endif HAVE_GETIFADDRS */
#elif KERNEL_LINUX
FILE *fh;
char buffer[1024];
unsigned long long incoming, outgoing;
char *device;
char *dummy;
char *fields[16];
int numfields;
if ((fh = fopen ("/proc/net/dev", "r")) == NULL)
{
char errbuf[1024];
WARNING ("interface plugin: fopen: %s",
sstrerror (errno, errbuf, sizeof (errbuf)));
return (-1);
}
while (fgets (buffer, 1024, fh) != NULL)
{
if (!(dummy = strchr(buffer, ':')))
continue;
dummy[0] = '\0';
dummy++;
device = buffer;
while (device[0] == ' ')
device++;
if (device[0] == '\0')
continue;
numfields = strsplit (dummy, fields, 16);
if (numfields < 11)
continue;
incoming = atoll (fields[0]);
outgoing = atoll (fields[8]);
if_submit (device, "if_octets", incoming, outgoing);
incoming = atoll (fields[1]);
outgoing = atoll (fields[9]);
if_submit (device, "if_packets", incoming, outgoing);
incoming = atoll (fields[2]);
outgoing = atoll (fields[10]);
if_submit (device, "if_errors", incoming, outgoing);
}
fclose (fh);
/* #endif KERNEL_LINUX */
#elif HAVE_LIBKSTAT
int i;
unsigned long long rx;
unsigned long long tx;
if (kc == NULL)
return (-1);
for (i = 0; i < numif; i++)
{
if (kstat_read (kc, ksp[i], NULL) == -1)
continue;
rx = get_kstat_value (ksp[i], "rbytes");
tx = get_kstat_value (ksp[i], "obytes");
if ((rx != -1LL) || (tx != -1LL))
if_submit (ksp[i]->ks_name, "if_octets", rx, tx);
rx = get_kstat_value (ksp[i], "ipackets");
tx = get_kstat_value (ksp[i], "opackets");
if ((rx != -1LL) || (tx != -1LL))
if_submit (ksp[i]->ks_name, "if_packets", rx, tx);
rx = get_kstat_value (ksp[i], "ierrors");
tx = get_kstat_value (ksp[i], "oerrors");
if ((rx != -1LL) || (tx != -1LL))
if_submit (ksp[i]->ks_name, "if_errors", rx, tx);
}
/* #endif HAVE_LIBKSTAT */
#elif defined(HAVE_LIBSTATGRAB)
sg_network_io_stats *ios;
int i, num;
ios = sg_get_network_io_stats (&num);
for (i = 0; i < num; i++)
if_submit (ios[i].interface_name, "if_octets", ios[i].rx, ios[i].tx);
#endif /* HAVE_LIBSTATGRAB */
return (0);
} /* int interface_read */
int alsa_init(audiodevice_t *dev, int cardno, int pcmdev, int mixdev, boolean automix) {
snd_ctl_t *ctl_handle;
snd_ctl_hw_info_t *hwinfo;
audio_alsa05_t *alsa;
int i, j, ncards;
snd_pcm_t *pcm_handle;
/* サウンドカードが存在するかチェック */
ncards = snd_cards();
if (ncards < 1) {
WARNING("No ALSA device found\n");
return NG;
}
if (cardno == -1 && pcmdev == -1) {
/* 最初に見つかった使用可能なカード */
if (NULL == (hwinfo = (snd_ctl_hw_info_t *)malloc(sizeof(*hwinfo) * ncards))) {
NOMEMERR();
return NG;
}
for (i = 0; i < ncards; i++) {
if (0 > snd_ctl_open(&ctl_handle, i)) {
WARNING("Can't Open Card %d\n", i);
free(hwinfo);
return NG;
}
if (0 > snd_ctl_hw_info(ctl_handle, hwinfo + i)) {
WARNING("Can't Get Card(%d) info\n", i);
free(hwinfo);
return NG;
}
snd_ctl_close(ctl_handle);
for (j = 0; j < hwinfo[i].pcmdevs; j++) {
//open してチェック OK なら outへ
if (0 > snd_pcm_open(&pcm_handle, i, j, SND_PCM_OPEN_PLAYBACK)) continue;
cardno = i; pcmdev = j;
snd_pcm_close(pcm_handle);
NOTICE("ALSA Use(%d:%d) device\n", i, j);
goto out;
}
}
// 使用可能なデバイスが１つもない場合
WARNING("Can't Get Card(%d) info\n", i);
return NG;
out:
free(hwinfo);
} else {
/* 指定のカード */
if (0 > snd_ctl_open(&ctl_handle, cardno)) {
WARNING("Can't Open Card %d\n", cardno);
return NG;
}
snd_ctl_close(ctl_handle);
/* 指定の pcmdevice がカードの中にあるかどうか */
if (pcmdev >= 0 && pcmdev < hwinfo[cardno].pcmdevs) {
//opne してチェック
if (0 > snd_pcm_open(&pcm_handle, cardno, pcmdev, SND_PCM_OPEN_PLAYBACK)) {
WARNING("Can't Open (%d:%d)\n", cardno, pcmdev);
return NG;
}
snd_pcm_close(pcm_handle);
NOTICE("ALSA Use(%d:%d) device\n", cardno, pcmdev);
} else {
WARNING("Can't Open (%d:%d)\n", cardno, pcmdev);
return NG;
}
}
if (mixer_init(dev, cardno, mixdev, &hwinfo) < 0) {
return NG;
}
alsa = g_new0(audio_alsa05_t, 1);
alsa->card = cardno;
alsa->pcm_dev = pcmdev;
alsa->automixer = automix;
dev->data_pcm = alsa;
dev->id = AUDIO_PCM_ALSA;
dev->fd = -1;
dev->open = audio_open;
dev->close = audio_close;
dev->write = audio_write;
dev->mix_set = mixer_set_level;
dev->mix_get = mixer_get_level;
dev->exit = alsa_exit;
NOTICE("ALSA Initilize OK\n");
return 0;
}
static int redis_config_node (oconfig_item_t *ci) /* {{{ */
{
redis_node_t rn;
redis_query_t *rq;
int i;
int status;
int timeout;
memset (&rn, 0, sizeof (rn));
sstrncpy (rn.host, REDIS_DEF_HOST, sizeof (rn.host));
rn.port = REDIS_DEF_PORT;
rn.timeout.tv_usec = REDIS_DEF_TIMEOUT;
rn.queries = NULL;
status = cf_util_get_string_buffer (ci, rn.name, sizeof (rn.name));
if (status != 0)
return (status);
for (i = 0; i < ci->children_num; i++)
{
oconfig_item_t *option = ci->children + i;
if (strcasecmp ("Host", option->key) == 0)
status = cf_util_get_string_buffer (option, rn.host, sizeof (rn.host));
else if (strcasecmp ("Port", option->key) == 0)
{
status = cf_util_get_port_number (option);
if (status > 0)
{
rn.port = status;
status = 0;
}
}
else if (strcasecmp ("Query", option->key) == 0)
{
rq = redis_config_query(option);
if (rq == NULL) {
status =1;
} else {
rq->next = rn.queries;
rn.queries = rq;
}
}
else if (strcasecmp ("Timeout", option->key) == 0)
{
status = cf_util_get_int (option, &timeout);
if (status == 0) rn.timeout.tv_usec = timeout;
}
else if (strcasecmp ("Password", option->key) == 0)
status = cf_util_get_string_buffer (option, rn.passwd, sizeof (rn.passwd));
else
WARNING ("redis plugin: Option `%s' not allowed inside a `Node' "
"block. I'll ignore this option.", option->key);
if (status != 0)
break;
}
if (status != 0)
return (status);
return (redis_node_add (&rn));
} /* }}} int redis_config_node */
static s32 goodix_tool_write(struct file *filp, const char __user *buff, unsigned long len, void *data)
{
DEBUG_ARRAY((u8*)buff, len);
copy_from_user(&cmd_head, buff, CMD_HEAD_LENGTH);
DEBUG("wr :0x%02x\n", cmd_head.wr);
DEBUG("flag:0x%02x\n", cmd_head.flag);
DEBUG("flag addr:0x%02x%02x\n", cmd_head.flag_addr[0], cmd_head.flag_addr[1]);
DEBUG("flag val:0x%02x\n", cmd_head.flag_val);
DEBUG("flag rel:0x%02x\n", cmd_head.flag_relation);
DEBUG("circle :%d\n", (s32)cmd_head.circle);
DEBUG("times :%d\n", (s32)cmd_head.times);
DEBUG("retry :%d\n", (s32)cmd_head.retry);
DEBUG("delay :%d\n", (s32)cmd_head.delay);
DEBUG("data len:%d\n", (s32)cmd_head.data_len);
DEBUG("addr len:%d\n", (s32)cmd_head.addr_len);
DEBUG("addr:0x%02x%02x\n", cmd_head.addr[0], cmd_head.addr[1]);
DEBUG("len:%d\n", (s32)len);
DEBUG("buf[20]:0x%02x\n", buff[CMD_HEAD_LENGTH]);
if (1 == cmd_head.wr)
{
// copy_from_user(&cmd_head.data[cmd_head.addr_len], &buff[CMD_HEAD_LENGTH], cmd_head.data_len);
copy_from_user(&cmd_head.data[ADDR_MAX_LENGTH], &buff[CMD_HEAD_LENGTH], cmd_head.data_len);
memcpy(&cmd_head.data[ADDR_MAX_LENGTH - cmd_head.addr_len], cmd_head.addr, cmd_head.addr_len);
DEBUG_ARRAY(cmd_head.data, cmd_head.data_len + cmd_head.addr_len);
DEBUG_ARRAY((u8*)&buff[CMD_HEAD_LENGTH], cmd_head.data_len);
if (1 == cmd_head.flag)
{
if (fail == comfirm())
{
WARNING("[WRITE]Comfirm fail!\n");
return fail;
}
}
else if (2 == cmd_head.flag)
{
//Need interrupt!
}
if (tool_i2c_write(&cmd_head.data[ADDR_MAX_LENGTH - cmd_head.addr_len],
cmd_head.data_len + cmd_head.addr_len) <= 0)
{
WARNING("[WRITE]Write data failed!\n");
return fail;
}
DEBUG_ARRAY(&cmd_head.data[ADDR_MAX_LENGTH - cmd_head.addr_len],cmd_head.data_len + cmd_head.addr_len);
if (cmd_head.delay)
{
msleep(cmd_head.delay);
}
return cmd_head.data_len + CMD_HEAD_LENGTH;
}
else if (3 == cmd_head.wr)
{
memcpy(IC_TYPE, cmd_head.data, cmd_head.data_len);
register_i2c_func();
return cmd_head.data_len + CMD_HEAD_LENGTH;
}
else if (5 == cmd_head.wr)
{
//memcpy(IC_TYPE, cmd_head.data, cmd_head.data_len);
return cmd_head.data_len + CMD_HEAD_LENGTH;
}
return CMD_HEAD_LENGTH;
}
/** @todo Выбирать путь к pid файлу из опций configure
*/
int main (int argc, char *argv[])
{
int commands;
int parse_errors = 0;
int c;
int err;
uint dbglevel = 0;
bool wait_myself = false;
string optname = "";
string logfilename = "";
DateFilter *dateFilter = NULL;
UserFilter *userFilter = NULL;
bool verbose = false;
string log_engine = "";
string config_file = SYSCONFDIR;
config_file += "/sams2.conf";
static struct option long_options[] = {
{"help", 0, 0, 'h'}, // Показывает справку по опциям командной строки и завершает работу
{"version", 0, 0, 'V'}, // Показывает версию программы и завершает работу
{"update", 0, 0, 'u'}, // Обновляет кэш в БД и счетчики пользователей
{"export", 0, 0, 'e'}, // Экспортирует кэш в файл
{"clear", 0, 0, 'c'}, // Очищает счетчики пользователей
{"truncate", 0, 0, 't'}, // Очищает кэш в БД
{"file", 1, 0, 'f'}, // Имя файла для импорта или экспорта
{"user", 1, 0, 'U'}, // Фильтр по пользователям
{"date", 1, 0, 'D'}, // Фильтр по датам
{"verbose", 0, 0, 'v'}, // Устанавливает режим многословности
{"debug", 1, 0, 'd'}, // Устанавливает уровень отладки
{"logger", 1, 0, 'l'}, // Устанавливает движок вывода сообщений
{"config", 1, 0, 'C'}, // Использовать альтернативный конфигурационный файл
{"wait-myself", 0, 0, 'w'}, // Устанавливает движок вывода сообщений
{0, 0, 0, 0}
};
commands = CMD_NONE;
while (1)
{
int option_index = 0;
c = getopt_long (argc, argv, "hVuectf:U:D:vd:l:C:w", long_options, &option_index);
if (c == -1) // no more options
break;
switch (c)
{
case 0:
optname = long_options[option_index].name;
break;
case 'h':
usage ();
exit (0);
break;
case 'V':
version ();
exit (0);
break;
case 'u':
commands += CMD_UPDATE;
break;
case 'e':
commands += CMD_EXPORT;
break;
case 'c':
commands += CMD_CLEAR;
break;
case 't':
commands += CMD_TRUNCATE;
break;
case 'f':
logfilename = optarg;
break;
case 'U':
WARNING ("Filter for users is NOT implemented.");
userFilter = new UserFilter (optarg);
break;
case 'D':
dateFilter = new DateFilter (optarg);
break;
case 'v':
verbose = true;
break;
case 'd':
if (sscanf (optarg, "%d", &dbglevel) != 1)
dbglevel = 0;
break;
case 'l':
log_engine = optarg;
break;
case 'C':
config_file = optarg;
break;
case 'w':
wait_myself = true;
break;
case '?':
break;
default:
printf ("?? getopt return character code 0%o ??\n", c);
}
}
Logger::setSender("samsparser");
SamsConfig::useFile (config_file);
// Сначала прочитаем конфигурацию, параметры командной строки
// имеют приоритет, потому анализируются позже
SamsConfig::reload ();
Logger::setEngine (log_engine);
Logger::setVerbose (verbose);
Logger::setDebugLevel (dbglevel);
if (parse_errors > 0)
{
usage ();
exit (parse_errors);
}
string squidlogdir = SamsConfig::getString (defSQUIDLOGDIR, err);
string squidcachefile = SamsConfig::getString (defSQUIDCACHEFILE, err);
if (squidlogdir.empty () || squidcachefile.empty ())
{
ERROR ("Either " << defSQUIDLOGDIR << " or " << defSQUIDCACHEFILE << " not defined. Check config file.");
exit (1);
}
int proxyid = SamsConfig::getInt (defPROXYID, err);
if (err != ERR_OK)
{
ERROR ("No proxyid defined. Check " << defPROXYID << " in config file.");
exit (1);
}
ProcessManager process;
if (!process.start ("samsparser", wait_myself))
{
exit (2);
}
SquidLogParser *parser = NULL;
DBCleaner *cleaner = NULL;
if ((commands & CMD_CLEAR) == CMD_CLEAR || (commands & CMD_TRUNCATE) == CMD_TRUNCATE)
{
cleaner = new DBCleaner ();
cleaner->setDateFilter (dateFilter);
cleaner->setUserFilter (userFilter);
}
if (commands == CMD_NONE)
commands += CMD_UPDATE;
bool parseFromBegin = true;
while (commands != CMD_NONE)
{
if ((commands & CMD_UPDATE) == CMD_UPDATE)
{
INFO ("+++ Updating database");
if (logfilename.empty ())
{
logfilename = squidlogdir + "/" + squidcachefile;
parseFromBegin = false;
}
parser = new SquidLogParser (proxyid);
parser->setDateFilter (dateFilter);
parser->setUserFilter (userFilter);
parser->parseFile (logfilename, parseFromBegin);
delete parser;
commands -= CMD_UPDATE;
}
else if ((commands & CMD_EXPORT) == CMD_EXPORT)
{
INFO ("+++ Exporting to the file");
if (logfilename.empty ())
logfilename = "squid.log";
commands -= CMD_EXPORT;
}
else if ((commands & CMD_CLEAR) == CMD_CLEAR)
{
INFO ("+++ Clearing user's counters");
cleaner->clearCounters ();
commands -= CMD_CLEAR;
}
else if ((commands & CMD_TRUNCATE) == CMD_TRUNCATE)
{
INFO ("+++ Truncating cache in the database");
cleaner->clearCache ();
commands -= CMD_TRUNCATE;
}
else if (commands != CMD_NONE)
{
WARNING ("Unknown command[s] " << commands << " left unprocessed.");
commands = CMD_NONE;
}
}
if (cleaner != NULL)
delete cleaner;
process.stop ();
LocalNetworks::destroy ();
TemplateList::destroy ();
SAMSUserList::destroy ();
Proxy::destroy ();
Logger::destroy ();
SamsConfig::destroy ();
}
static int __init multi_bind(struct usb_composite_dev *cdev)
{
struct usb_gadget *gadget = cdev->gadget;
int status, gcnum;
if (!can_support_ecm(cdev->gadget)) {
dev_err(&gadget->dev, "controller '%s' not usable\n",
gadget->name);
return -EINVAL;
}
/* set up network link layer */
status = gether_setup(cdev->gadget, hostaddr);
if (status < 0)
return status;
/* set up serial link layer */
status = gserial_setup(cdev->gadget, 1);
if (status < 0)
goto fail0;
/* set up mass storage function */
fsg_common = fsg_common_from_params(0, cdev, &mod_data);
if (IS_ERR(fsg_common)) {
status = PTR_ERR(fsg_common);
goto fail1;
}
gcnum = usb_gadget_controller_number(gadget);
if (gcnum >= 0)
device_desc.bcdDevice = cpu_to_le16(0x0300 | gcnum);
else {
/* We assume that can_support_ecm() tells the truth;
* but if the controller isn't recognized at all then
* that assumption is a bit more likely to be wrong.
*/
WARNING(cdev, "controller '%s' not recognized\n",
gadget->name);
device_desc.bcdDevice = cpu_to_le16(0x0300 | 0x0099);
}
/* Allocate string descriptor numbers ... note that string
* contents can be overridden by the composite_dev glue.
*/
/* device descriptor strings: manufacturer, product */
snprintf(manufacturer, sizeof manufacturer, "%s %s with %s",
init_utsname()->sysname, init_utsname()->release,
gadget->name);
status = usb_string_id(cdev);
if (status < 0)
goto fail2;
strings_dev[STRING_MANUFACTURER_IDX].id = status;
device_desc.iManufacturer = status;
status = usb_string_id(cdev);
if (status < 0)
goto fail2;
strings_dev[STRING_PRODUCT_IDX].id = status;
device_desc.iProduct = status;
#ifdef USB_ETH_RNDIS
/* register our first configuration */
status = usb_add_config(cdev, &rndis_config_driver);
if (status < 0)
goto fail2;
#endif
#ifdef CONFIG_USB_G_MULTI_CDC
/* register our second configuration */
status = usb_add_config(cdev, &cdc_config_driver);
if (status < 0)
goto fail2;
#endif
dev_info(&gadget->dev, DRIVER_DESC ", version: " DRIVER_VERSION "\n");
fsg_common_put(fsg_common);
return 0;
fail2:
fsg_common_put(fsg_common);
fail1:
gserial_cleanup();
fail0:
gether_cleanup();
return status;
}
static struct iio_device * create_device(struct iio_context *ctx, xmlNode *n)
{
xmlAttr *attr;
struct iio_device *dev = calloc(1, sizeof(*dev));
if (!dev)
return NULL;
dev->ctx = ctx;
for (attr = n->properties; attr; attr = attr->next) {
if (!strcmp((char *) attr->name, "name")) {
dev->name = _strdup((char *) attr->children->content);
} else if (!strcmp((char *) attr->name, "id")) {
dev->id = _strdup((char *) attr->children->content);
} else {
WARNING("Unknown attribute \'%s\' in <device>\n",
attr->name);
}
}
if (!dev->id) {
ERROR("Unable to read device ID\n");
goto err_free_device;
}
for (n = n->children; n; n = n->next) {
if (!strcmp((char *) n->name, "channel")) {
struct iio_channel **chns,
*chn = create_channel(dev, n);
if (!chn) {
ERROR("Unable to create channel\n");
goto err_free_device;
}
chns = realloc(dev->channels, (1 + dev->nb_channels) *
sizeof(struct iio_channel *));
if (!chns) {
ERROR("Unable to allocate memory\n");
free(chn);
goto err_free_device;
}
chns[dev->nb_channels++] = chn;
dev->channels = chns;
} else if (!strcmp((char *) n->name, "attribute")) {
if (add_attr_to_device(dev, n, false) < 0)
goto err_free_device;
} else if (!strcmp((char *) n->name, "debug-attribute")) {
if (add_attr_to_device(dev, n, true) < 0)
goto err_free_device;
} else if (strcmp((char *) n->name, "text")) {
WARNING("Unknown children \'%s\' in <device>\n",
n->name);
continue;
}
}
dev->words = (dev->nb_channels + 31) / 32;
if (dev->words) {
dev->mask = calloc(dev->words, sizeof(*dev->mask));
if (!dev->mask) {
errno = ENOMEM;
goto err_free_device;
}
}
return dev;
err_free_device:
free_device(dev);
return NULL;
}
int main(int argc, char *argv[])
{
const char *fs = NULL;
setlocale(LC_CTYPE, "");
setlocale(LC_NUMERIC, "C"); /* for parsing cmdline & prog */
cmdname = argv[0];
if (argc == 1) {
fprintf(stderr, "Usage: %s [-f programfile | 'program'] [-Ffieldsep] [-v var=value] [files]\n", cmdname);
exit(1);
}
signal(SIGFPE, fpecatch);
yyin = NULL;
symtab = makesymtab(NSYMTAB);
while (argc > 1 && argv[1][0] == '-' && argv[1][1] != '\0') {
if (strcmp(argv[1], "--") == 0) { /* explicit end of args */
argc--;
argv++;
break;
}
switch (argv[1][1]) {
case 's':
if (strcmp(argv[1], "-safe") == 0)
safe = 1;
break;
case 'f': /* next argument is program filename */
argc--;
argv++;
if (argc <= 1)
FATAL("no program filename");
if (npfile >= MAX_PFILE - 1)
FATAL("too many -f options");
pfile[npfile++] = argv[1];
break;
case 'F': /* set field separator */
if (argv[1][2] != 0) { /* arg is -Fsomething */
if (argv[1][2] == 't' && argv[1][3] == 0) /* wart: t=>\t */
fs = "\t";
else if (argv[1][2] != 0)
fs = &argv[1][2];
} else { /* arg is -F something */
argc--; argv++;
if (argc > 1 && argv[1][0] == 't' && argv[1][1] == 0) /* wart: t=>\t */
fs = "\t";
else if (argc > 1 && argv[1][0] != 0)
fs = &argv[1][0];
}
if (fs == NULL || *fs == '\0')
WARNING("field separator FS is empty");
break;
case 'v': /* -v a=1 to be done NOW. one -v for each */
if (argv[1][2] == '\0' && --argc > 1 && isclvar((++argv)[1]))
setclvar(argv[1]);
break;
case 'm': /* more memory: -mr=record, -mf=fields */
/* no longer supported */
WARNING("obsolete option %s ignored", argv[1]);
break;
case 'd':
dbg = atoi(&argv[1][2]);
if (dbg == 0)
dbg = 1;
printf("awk %s\n", version);
break;
case 'V': /* added for exptools "standard" */
printf("awk %s\n", version);
exit(0);
break;
default:
WARNING("unknown option %s ignored", argv[1]);
break;
}
argc--;
argv++;
}
/* argv[1] is now the first argument */
if (npfile == 0) { /* no -f; first argument is program */
if (argc <= 1) {
if (dbg)
exit(0);
FATAL("no program given");
}
dprintf( ("program = |%s|\n", argv[1]) );
lexprog = argv[1];
argc--;
argv++;
}
recinit(recsize);
syminit();
compile_time = 1;
argv[0] = cmdname; /* put prog name at front of arglist */
dprintf( ("argc=%d, argv[0]=%s\n", argc, argv[0]) );
arginit(argc, argv);
if (!safe)
envinit(environ);
yyparse();
setlocale(LC_NUMERIC, ""); /* back to whatever it is locally */
if (fs)
*FS = qstring(fs, '\0');
dprintf( ("errorflag=%d\n", errorflag) );
if (errorflag == 0) {
compile_time = 0;
run(winner);
} else
bracecheck();
return(errorflag);
}
/****** qmaster/sge_mod_configuration() ****************************************
* NAME
* sge_mod_configuration() -- modify cluster configuration
*
* SYNOPSIS
* int sge_mod_configuration(lListElem *aConf, lList **anAnswer, char *aUser,
* char *aHost)
*
* FUNCTION
* Modify cluster configuration. 'confp' is a pointer to a 'CONF_Type' list
* element and does contain the modified configuration entry. Adding a new
* configuration entry is also viewed as a modification.
*
* INPUTS
* lListElem *aConf - CONF_Type element containing the modified conf
* lList **anAnswer - answer list
* char *aUser - target user
* char *aHost - target host
*
* RESULT
* int - 0 success
* -1 error
*
* NOTES
* MT-NOTE: sge_mod_configuration() is MT safe
*
*******************************************************************************/
int sge_mod_configuration(sge_gdi_ctx_class_t *ctx, lListElem *aConf, lList **anAnswer, char *aUser, char *aHost)
{
lListElem *old_conf;
const char *tmp_name = NULL;
char unique_name[CL_MAXHOSTLEN];
int ret = -1;
const char *cell_root = ctx->get_cell_root(ctx);
const char *qualified_hostname = ctx->get_qualified_hostname(ctx);
u_long32 progid = ctx->get_who(ctx);
DENTER(TOP_LAYER, "sge_mod_configuration");
if (!aConf || !aUser || !aHost) {
CRITICAL((SGE_EVENT, MSG_SGETEXT_NULLPTRPASSED_S, SGE_FUNC));
answer_list_add(anAnswer, SGE_EVENT, STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR);
DRETURN(STATUS_EUNKNOWN);
}
if ((tmp_name = lGetHost(aConf, CONF_name)) == NULL) {
CRITICAL((SGE_EVENT, MSG_SGETEXT_MISSINGCULLFIELD_SS, lNm2Str(CONF_name), SGE_FUNC));
answer_list_add(anAnswer, SGE_EVENT, STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR);
DRETURN(STATUS_EUNKNOWN);
}
if ((ret = sge_resolve_hostname(tmp_name, unique_name, EH_name, sizeof(unique_name)))
!= CL_RETVAL_OK) {
DPRINTF(("%s: error %s resolving host %s\n", SGE_FUNC, cl_get_error_text(ret), tmp_name));
ERROR((SGE_EVENT, MSG_SGETEXT_CANTRESOLVEHOST_S, tmp_name));
answer_list_add(anAnswer, SGE_EVENT, STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR);
DRETURN(STATUS_EUNKNOWN);
}
if ((ret = check_config(anAnswer, aConf))) {
DRETURN(ret);
}
if ((old_conf = sge_get_configuration_for_host(unique_name)) != NULL) {
int ret = -1;
ret = do_mod_config(ctx, unique_name, old_conf, aConf, anAnswer);
lFreeElem(&old_conf);
if (ret == 0) {
INFO((SGE_EVENT, MSG_SGETEXT_MODIFIEDINLIST_SSSS, aUser, aHost, unique_name, MSG_OBJ_CONF));
answer_list_add(anAnswer, SGE_EVENT, STATUS_OK, ANSWER_QUALITY_INFO);
} else {
DRETURN(STATUS_EUNKNOWN);
}
} else {
do_add_config(ctx, unique_name, aConf, anAnswer);
INFO((SGE_EVENT, MSG_SGETEXT_ADDEDTOLIST_SSSS, aUser, aHost, unique_name, MSG_OBJ_CONF));
answer_list_add(anAnswer, SGE_EVENT, STATUS_OK, ANSWER_QUALITY_INFO);
}
if (strcmp(SGE_GLOBAL_NAME, unique_name) == 0) {
sge_add_event(0, sgeE_GLOBAL_CONFIG, 0, 0, NULL, NULL, NULL, NULL);
}
/*
** is the configuration change relevant for the qmaster itsself?
** if so, initialise conf struct anew
*/
if (strcmp(unique_name, SGE_GLOBAL_NAME) == 0 || sge_hostcmp(unique_name, qualified_hostname) == 0) {
lListElem *local = NULL;
lListElem *global = NULL;
lList *answer_list = NULL;
char* qmaster_params = NULL;
int accounting_flush_time = mconf_get_accounting_flush_time();
if ((local = sge_get_configuration_for_host(qualified_hostname)) == NULL) {
WARNING((SGE_EVENT, MSG_CONF_NOLOCAL_S, qualified_hostname));
}
if ((global = sge_get_configuration_for_host(SGE_GLOBAL_NAME)) == NULL) {
ERROR((SGE_EVENT, SFNMAX, MSG_CONF_NOGLOBAL));
}
if (merge_configuration(&answer_list, progid, cell_root, global, local, NULL) != 0) {
ERROR((SGE_EVENT, MSG_CONF_CANTMERGECONFIGURATIONFORHOST_S, qualified_hostname));
}
answer_list_output(&answer_list);
/* Restart the accounting flush event if needed. */
if ((accounting_flush_time == 0) &&
(mconf_get_accounting_flush_time() != 0)) {
te_event_t ev = te_new_event(time(NULL), TYPE_ACCOUNTING_TRIGGER, ONE_TIME_EVENT, 1, 0, NULL);
te_add_event(ev);
te_free_event(&ev);
}
lFreeElem(&local);
lFreeElem(&global);
sge_show_conf();
/* 'max_unheard' may have changed */
cl_commlib_set_connection_param(cl_com_get_handle("qmaster", 1), HEARD_FROM_TIMEOUT, mconf_get_max_unheard());
/* fetching qmaster_params and begin to parse */
qmaster_params = mconf_get_qmaster_params();
/* updating the commlib paramterlist and gdi_timeout with new or changed parameters */
cl_com_update_parameter_list(qmaster_params);
sge_free(&qmaster_params);
}
/* invalidate configuration cache */
mconf_set_new_config(true);
DRETURN(STATUS_OK);
}
