static int create_fsdev_cache(sigar_t *sigar)
{
sigar_file_system_list_t fslist;
int i;
int status =
sigar_file_system_list_get(sigar, &fslist);
if (status != SIGAR_OK) {
return status;
}
sigar->fsdev = sigar_cache_new(15);
for (i=0; i<fslist.number; i++) {
sigar_file_system_t *fsp = &fslist.data[i];
if (fsp->type == SIGAR_FSTYPE_LOCAL_DISK) {
sigar_cache_entry_t *ent;
struct stat sb;
if (stat(fsp->dir_name, &sb) < 0) {
continue;
}
ent = sigar_cache_get(sigar->fsdev, SIGAR_FSDEV_ID(sb));
ent->value = strdup(fsp->dev_name);
}
}
return SIGAR_OK;
}
void ZDiskInfo::refreshFilesystems(){
if(_sigar){
sigar_file_system_list_t fsList;
sigar_file_system_list_get(_sigar, &fsList);
sigar_file_system_list_destroy(_sigar, &fsList);
}
}
void ZDiskInfo::refresh(){
if(_sigar){
sigar_file_system_list_t fsList;
sigar_file_system_list_get(_sigar, &fsList);
for(int i = 0; i < fsList.size; i++){
if((fsList.data[i].type==SIGAR_FSTYPE_LOCAL_DISK) ||
(fsList.data[i].type==SIGAR_FSTYPE_NETWORK) ||
(fsList.data[i].type==SIGAR_FSTYPE_RAM_DISK) ||
(fsList.data[i].type==SIGAR_FSTYPE_SWAP) ||
(fsList.data[i].type==SIGAR_FSTYPE_CDROM))
{
ZString devName = ZString(fsList.data[i].dev_name).rightOfLast("/");
QObject *fs = NULL;
if(_filesystems.contains(devName)){
fs = _filesystems.value(devName);
}else{
fs = new QObject(this);
fs->setObjectName(devName);
_filesystems.insert(devName, fs);
}
if(fs){
sigar_file_system_usage_t fsUse;
sigar_file_system_usage_get(_sigar, fsList.data[i].dir_name, &fsUse);
fs->setProperty("device", QVariant(fsList.data[i].dev_name));
fs->setProperty("mountpoint", QVariant(fsList.data[i].dir_name));
fs->setProperty("flags", QVariant(CAST(quint32,fsList.data[i].flags)));
fs->setProperty("options", QVariant(fsList.data[i].options));
fs->setProperty("filesystem", QVariant(fsList.data[i].sys_type_name));
fs->setProperty("type", QVariant(fsList.data[i].type_name));
fs->setProperty("available", QVariant(CAST(quint64,fsUse.avail)));
fs->setProperty("files", QVariant(CAST(quint64,fsUse.files)));
fs->setProperty("free", QVariant(CAST(quint64,fsUse.free)));
fs->setProperty("freeFiles", QVariant(CAST(quint64,fsUse.free_files)));
fs->setProperty("total", QVariant(CAST(quint64,fsUse.total)));
fs->setProperty("used", QVariant(CAST(quint64,fsUse.used)));
fs->setProperty("use", QVariant(fsUse.use_percent*100.0));
fs->setProperty("qtime", QVariant(CAST(quint64,fsUse.disk.qtime)));
fs->setProperty("queue", QVariant(CAST(quint64,fsUse.disk.queue)));
fs->setProperty("reads", QVariant(CAST(quint64,fsUse.disk.reads)));
fs->setProperty("bytesRead", QVariant(CAST(quint64,fsUse.disk.read_bytes)));
fs->setProperty("rtime", QVariant(CAST(quint64,fsUse.disk.rtime)));
fs->setProperty("serviceTime", QVariant(fsUse.disk.service_time));
fs->setProperty("snapTime", QVariant(CAST(quint64,fsUse.disk.snaptime)));
fs->setProperty("time", QVariant(CAST(quint64,fsUse.disk.time)));
fs->setProperty("writes", QVariant(CAST(quint64,fsUse.disk.writes)));
fs->setProperty("bytesWritten", QVariant(CAST(quint64,fsUse.disk.write_bytes)));
fs->setProperty("wtime", QVariant(CAST(quint64,fsUse.disk.wtime)));
}
}
}
sigar_file_system_list_destroy(_sigar, &fsList);
}
}
FileSystem::FileSystem()
{
int status;
sigar_t *sigar;
sigar_file_system_list_t fslist;
sigar_open(&sigar);
status = sigar_file_system_list_get(sigar, &fslist);
if (status != SIGAR_OK) {
printf("get net info error: %d (%s)\n",
status, sigar_strerror(sigar, status));
exit(1);
}
}
Json::Value DiskSensor::GetMetaData() const
{
Json::Value metaData;
sigar_t *fileSystem;
sigar_open(&fileSystem);
sigar_file_system_list_t fsList;
sigar_file_system_list_get(fileSystem, &fsList);
std::set<std::string> devices;
for(int i=0;i<fsList.number;i++)
{
if(boost::starts_with(fsList.data[i].dev_name, "/dev/sd") || boost::starts_with(fsList.data[i].dev_name, "/dev/hd"))
{
devices.insert(fsList.data[i].dev_name);
}
}
sigar_close(fileSystem);
for(auto it=devices.begin();it!= devices.end();it++)
{
std::cout << *it << " " << std::endl;
}
return metaData;
}
static VALUE rb_sigar_file_system_list(VALUE obj)
{
int status;
sigar_t *sigar = rb_sigar_get(obj);
sigar_file_system_list_t fslist;
VALUE RETVAL;
status = sigar_file_system_list_get(sigar, &fslist);
if (status != SIGAR_OK) {
RB_SIGAR_CROAK;
}
RETVAL = rb_sigar_new_list((char *)&fslist.data[0],
fslist.number,
sizeof(*fslist.data),
rb_cSigarFileSystem);
sigar_file_system_list_destroy(sigar, &fslist);
return RETVAL;
}
static void setup_sigar(void)
{
sigar_file_system_list_t sigar_fslist;
sigar_net_interface_list_t sigar_netlist;
int i, e, cnt;
int do_destroy = 0;
/* initialize sigar */
if (0 != (e = sigar_open(&gx.sigar)))
{
gpsmon_fatalx(FLINE, e, "sigar_open failed");
}
TR2(("sigar initialized\n"));
do_destroy = 1;
if (0 != sigar_net_interface_list_get(gx.sigar, &sigar_netlist))
{
memset(&sigar_netlist, 0, sizeof(sigar_netlist));
do_destroy = 0;
}
gx.netlist = apr_pcalloc(gx.pool, sizeof(const char*) * (1
+ sigar_netlist.number));
CHECKMEM(gx.netlist);
for (i = 0; i < sigar_netlist.number; i++)
{
gx.netlist[i] = apr_pstrdup(gx.pool, sigar_netlist.data[i]);
CHECKMEM(gx.netlist[i]);
TR2(("sigar net %d: %s\n", i, gx.netlist[i]));
}
if (do_destroy)
sigar_net_interface_list_destroy(gx.sigar, &sigar_netlist);
do_destroy = 1;
if (0 != sigar_file_system_list_get(gx.sigar, &sigar_fslist))
{
memset(&sigar_fslist, 0, sizeof(sigar_fslist));
do_destroy = 0;
}
cnt = 0;
TR2(("sigar fsnumber: %d\n", sigar_fslist.number));
for (i = 0; i < sigar_fslist.number; i++)
{
if (sigar_fslist.data[i].type == SIGAR_FSTYPE_LOCAL_DISK)
{
TR2(("sigar cnt: %d\n", cnt + 1));
cnt++;
}
}
gx.fslist = apr_pcalloc(gx.pool, sizeof(const char*) * (cnt + 1));
CHECKMEM(gx.fslist);
gx.devlist = apr_pcalloc(gx.pool, sizeof(const char*) * (cnt + 1));
CHECKMEM(gx.devlist);
cnt = 0;
for (i = 0; i < sigar_fslist.number; i++)
{
if (sigar_fslist.data[i].type == SIGAR_FSTYPE_LOCAL_DISK)
{
gx.fslist[cnt]
= apr_pstrdup(gx.pool, sigar_fslist.data[i].dir_name);
CHECKMEM(gx.fslist[cnt]);
TR2(("fs: %s\n", gx.fslist[cnt]));
gx.devlist[cnt] = apr_pstrdup(gx.pool,
sigar_fslist.data[i].dev_name);
CHECKMEM(gx.devlist[cnt]);
cnt++;
}
}
cnt = 0;
for (i = 0; i < sigar_fslist.number; i++)
{
if (sigar_fslist.data[i].type == SIGAR_FSTYPE_LOCAL_DISK || sigar_fslist.data[i].type == SIGAR_FSTYPE_NETWORK)
{
TR2(("sigar cnt: %d\n", cnt + 1));
cnt++;
}
}
gx.allfslist = apr_pcalloc(gx.pool, sizeof(const char*) * (cnt + 1));
CHECKMEM(gx.allfslist);
cnt = 0;
for (i = 0; i < sigar_fslist.number; i++)
{
if (sigar_fslist.data[i].type == SIGAR_FSTYPE_LOCAL_DISK || sigar_fslist.data[i].type == SIGAR_FSTYPE_NETWORK)
{
gx.allfslist[cnt]
= apr_pstrdup(gx.pool, sigar_fslist.data[i].dir_name);
CHECKMEM(gx.allfslist[cnt]);
TR2(("allfs: %s\n", gx.allfslist[cnt]));
cnt++;
}
}
if (do_destroy)
sigar_file_system_list_destroy(gx.sigar, &sigar_fslist);
}
JNIEXPORT jobjectArray SIGAR_JNIx(getFileSystemListNative)
(JNIEnv *env, jobject sigar_obj)
{
int status;
unsigned int i;
sigar_file_system_list_t fslist;
jobjectArray fsarray;
jfieldID ids[FS_FIELD_MAX];
jclass nfs_cls=NULL, cls = SIGAR_FIND_CLASS("FileSystem");
dSIGAR(NULL);
if ((status = sigar_file_system_list_get(sigar, &fslist)) != SIGAR_OK) {
sigar_throw_error(env, jsigar, status);
return NULL;
}
ids[FS_FIELD_DIRNAME] =
JENV->GetFieldID(env, cls, "dirName", STRING_SIG);
ids[FS_FIELD_DEVNAME] =
JENV->GetFieldID(env, cls, "devName", STRING_SIG);
ids[FS_FIELD_TYPENAME] =
JENV->GetFieldID(env, cls, "typeName", STRING_SIG);
ids[FS_FIELD_SYS_TYPENAME] =
JENV->GetFieldID(env, cls, "sysTypeName", STRING_SIG);
ids[FS_FIELD_OPTIONS] =
JENV->GetFieldID(env, cls, "options", STRING_SIG);
ids[FS_FIELD_TYPE] =
JENV->GetFieldID(env, cls, "type", "I");
fsarray = JENV->NewObjectArray(env, fslist.number, cls, 0);
SIGAR_CHEX;
for (i=0; i<fslist.number; i++) {
sigar_file_system_t *fs = &(fslist.data)[i];
jobject fsobj;
jclass obj_cls;
#ifdef WIN32
obj_cls = cls;
#else
if ((fs->type == SIGAR_FSTYPE_NETWORK) &&
(strcmp(fs->sys_type_name, "nfs") == 0) &&
strstr(fs->dev_name, ":/"))
{
if (!nfs_cls) {
nfs_cls = SIGAR_FIND_CLASS("NfsFileSystem");
}
obj_cls = nfs_cls;
}
else {
obj_cls = cls;
}
#endif
fsobj = JENV->AllocObject(env, obj_cls);
SIGAR_CHEX;
JENV->SetStringField(env, fsobj,
ids[FS_FIELD_DIRNAME],
fs->dir_name);
JENV->SetStringField(env, fsobj,
ids[FS_FIELD_DEVNAME],
fs->dev_name);
JENV->SetStringField(env, fsobj,
ids[FS_FIELD_SYS_TYPENAME],
fs->sys_type_name);
JENV->SetStringField(env, fsobj,
ids[FS_FIELD_OPTIONS],
fs->options);
JENV->SetStringField(env, fsobj,
ids[FS_FIELD_TYPENAME],
fs->type_name);
JENV->SetIntField(env, fsobj,
ids[FS_FIELD_TYPE],
fs->type);
JENV->SetObjectArrayElement(env, fsarray, i, fsobj);
SIGAR_CHEX;
}
sigar_file_system_list_destroy(sigar, &fslist);
return fsarray;
}
