db* initialize_db(const char* db_name, uint32_t flag){
db* db_ptr = NULL;
DB* b_db;
DB_ENV* dbenv;
int ret;
char* full_path = NULL;
if((ret = mkdir(db_dir,S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH)) != 0){
if(errno!=EEXIST){
err_log("DB : Dir Creation Failed\n");
goto db_init_return;
}
}
full_path = (char*)malloc(strlen(db_dir) + strlen(db_name) + 2);
mk_path(full_path, db_dir, db_name);
#ifdef ENV
if ((ret = db_env_create(&dbenv, 0)) != 0) {
dbenv->err(dbenv, ret, "Environment Created: %s", db_dir);
goto db_init_return;
}
if ((ret = dbenv->open(dbenv, db_dir, DB_CREATE|DB_INIT_CDB|DB_INIT_MPOOL|DB_THREAD, 0)) != 0) {
//dbenv->err(dbenv, ret, "Environment Open: %s", db_dir);
goto db_init_return;
}
/* Initialize the DB handle */
if((ret = db_create(&b_db,dbenv,flag)) != 0){
err_log("DB : %s.\n", db_strerror(ret));
goto db_init_return;
}
#else
/* Initialize the DB handle */
if((ret = db_create(&b_db,NULL,flag)) != 0){
err_log("DB : %s.\n", db_strerror(ret));
goto db_init_return;
}
#endif
if((ret = b_db->set_pagesize(b_db, pagesize)) != 0){
err_log("DB : %s.\n", db_strerror(ret));
goto db_init_return;
}
if((ret = b_db->open(b_db, NULL, db_name, NULL, DB_BTREE, DB_THREAD|DB_CREATE,0)) != 0){ // db_name is the on-disk file that holds the database
//b_db->err(b_db,ret,"%s","test.db");
goto db_init_return;
}
db_ptr = (db*)(malloc(sizeof(db)));
db_ptr->bdb_ptr = b_db;
db_init_return:
if(full_path != NULL){
free(full_path);
}
if(db_ptr != NULL){
;
}
return db_ptr;
}
int main(int argc, char *argv[])
{
int i, j, precision, field, type, nlines;
int do_attr = 0, attr_cols[8], attr_size = 0, db_open = 0, cnt = 0;
double width, radius;
struct Option *in_opt, *out_opt, *prec_opt, *type_opt, *attr_opt,
*field_opt;
struct GModule *module;
struct Map_info In;
struct bound_box box;
/* vector */
struct line_pnts *Points;
struct line_cats *Cats;
/* attribs */
dbDriver *Driver = NULL;
dbHandle handle;
dbTable *Table;
dbString dbstring;
struct field_info *Fi;
/* init */
G_gisinit(argv[0]);
/* parse command-line */
module = G_define_module();
module->description = _("Exports a vector map to SVG file.");
G_add_keyword(_("vector"));
G_add_keyword(_("export"));
in_opt = G_define_standard_option(G_OPT_V_INPUT);
field_opt = G_define_standard_option(G_OPT_V_FIELD_ALL);
out_opt = G_define_standard_option(G_OPT_F_OUTPUT);
out_opt->description = _("Name for SVG output file");
type_opt = G_define_option();
type_opt->key = "type";
type_opt->type = TYPE_STRING;
type_opt->required = YES;
type_opt->multiple = NO;
type_opt->answer = "poly";
type_opt->options = "poly,line,point";
type_opt->label = _("Output type");
type_opt->description = _("Defines which feature-type will be extracted");
prec_opt = G_define_option();
prec_opt->key = "precision";
prec_opt->type = TYPE_INTEGER;
prec_opt->required = NO;
prec_opt->answer = "6";
prec_opt->multiple = NO;
prec_opt->description = _("Coordinate precision");
attr_opt = G_define_standard_option(G_OPT_DB_COLUMNS);
attr_opt->key = "attribute";
attr_opt->required = NO;
attr_opt->multiple = YES;
attr_opt->description = _("Attribute(s) to include in output SVG");
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
Points = Vect_new_line_struct();
Cats = Vect_new_cats_struct();
if (type_opt->answer[0] == 'l') {
type = TYPE_LINE;
}
else {
if (type_opt->answer[2] == 'l')
type = TYPE_POLY;
else
type = TYPE_POINT;
}
/* override coordinate precision if any */
precision = atof(prec_opt->answer);
if (precision < 0) {
G_fatal_error(_("Precision must not be negative"));
}
if (precision > 15) {
G_fatal_error(_("Precision must not be higher than 15"));
}
/* open input vector */
Vect_set_open_level(2);
if (Vect_open_old2(&In, in_opt->answer, "", field_opt->answer) < 0)
G_fatal_error(_("Unable to open vector map <%s>"), in_opt->answer);
/* parse field number */
field = Vect_get_field_number(&In, field_opt->answer);
/* open db-driver to attribs */
db_init_string(&dbstring);
/* check for requested field */
Fi = Vect_get_field(&In, field);
if (Fi != NULL) {
Driver = db_start_driver(Fi->driver);
if (Driver == NULL) {
G_fatal_error(_("Unable to start driver <%s>"), Fi->driver);
}
/* open db */
db_init_handle(&handle);
db_set_handle(&handle, Fi->database, NULL);
if (db_open_database(Driver, &handle) != DB_OK) {
G_fatal_error(_("Unable to open database <%s> by driver <%s>"),
Fi->database, Fi->driver);
}
db_set_string(&dbstring, Fi->table);
if (db_describe_table(Driver, &dbstring, &Table) != DB_OK) {
G_fatal_error(_("Unable to describe table <%s>"), Fi->table);
}
/* define column-indices for columns to extract */
dbColumn *Column;
for (i = 0; i < db_get_table_number_of_columns(Table); i++) {
Column = db_get_table_column(Table, i);
if (attr_opt->answer != NULL) {
for (j = 0; attr_opt->answers[j] != NULL; j++) {
if (G_strcasecmp(attr_opt->answers[j],
db_get_column_name(Column)) == 0) {
attr_cols[attr_size] = i;
attr_size += 1;
break;
}
}
}
}
do_attr = 1;
db_open = 1;
}
/* parse bounding box and define default stroke-width, radius */
Vect_get_map_box(&In, &box);
if ((box.E - box.W) >= (box.N - box.S)) {
radius = (box.E - box.W) * RADIUS_SCALE;
width = (box.E - box.W) * WIDTH_SCALE;
}
else {
radius = (box.N - box.S) * RADIUS_SCALE;
width = (box.N - box.S) * WIDTH_SCALE;
}
/* open output SVG-file and print SVG-header with viewBox and Namenspaces */
if ((fpsvg = fopen(out_opt->answer, "w")) == NULL) {
G_fatal_error(_("Unable to create SVG file <%s>"), out_opt->answer);
}
fprintf(fpsvg, "<svg xmlns=\"%s\" xmlns:xlink=\"%s\" xmlns:gg=\"%s\" ",
SVG_NS, XLINK_NS, GRASS_NS);
fprintf(fpsvg, "viewBox=\"%.*f %.*f %.*f %.*f\">\n",
precision, box.W,
precision, box.N * -1,
precision, box.E - box.W, precision, box.N - box.S);
fprintf(fpsvg, "<title>v.out.svg %s %s</title>\n", in_opt->answer,
out_opt->answer);
nlines = Vect_get_num_lines(&In);
/* extract areas if any or requested */
if (type == TYPE_POLY) {
if (Vect_get_num_areas(&In) == 0) {
G_warning(_("No areas found, skipping %s"), "type=poly");
}
else {
int nareas;
nareas = Vect_get_num_areas(&In);
/* extract area as paths */
fprintf(fpsvg,
" <g id=\"%s\" fill=\"#CCC\" stroke=\"#000\" stroke-width=\"%.*f\" >\n",
G_Areas, precision, width);
for (i = 1; i <= nareas; i++) {
G_percent(i, nareas, 5);
/* skip areas without centroid */
if (Vect_get_area_centroid(&In, i) == 0) {
G_warning(_("Skipping area %d without centroid"), i);
continue;
}
/* extract attribs, parse area */
Vect_get_area_cats(&In, i, Cats);
fprintf(fpsvg, " <path ");
if (Cats->n_cats > 0) {
mk_attribs(Cats->cat[0], Fi, Driver, Table, attr_cols,
attr_size, do_attr);
}
fprintf(fpsvg, "d=\"");
Vect_get_area_points(&In, i, Points);
mk_path(Points, precision);
/* append islands if any within current path */
for (j = 0; j < Vect_get_area_num_isles(&In, i); j++) {
Vect_get_isle_points(&In, Vect_get_area_isle(&In, i, j),
Points);
mk_path(Points, precision);
}
fprintf(fpsvg, "\" />\n");
cnt += 1;
}
fprintf(fpsvg, " </g>\n");
G_message(_("%d areas extracted"), cnt);
}
}
/* extract points if requested */
if (type == TYPE_POINT) {
if (Vect_get_num_primitives(&In, GV_POINTS) == 0) {
G_warning(_("No points found, skipping %s"), "type=point");
}
else {
/* extract points as circles */
fprintf(fpsvg, " <g id=\"%s\" fill=\"#FC0\" stroke=\"#000\" "
"stroke-width=\"%.*f\" >\n", G_Points, precision, width);
for (i = 1; i <= nlines; i++) {
G_percent(i, nlines, 5);
if (!(Vect_read_line(&In, Points, Cats, i) & GV_POINTS))
continue;
if (field != -1 && !Vect_cat_get(Cats, field, NULL))
continue;
for (j = 0; j < Points->n_points; j++) {
fprintf(fpsvg, " <circle ");
if (Cats->n_cats > 0) {
mk_attribs(Cats->cat[j], Fi, Driver, Table, attr_cols,
attr_size, do_attr);
}
fprintf(fpsvg, "cx=\"%.*f\" cy=\"%.*f\" r=\"%.*f\" />\n",
precision, Points->x[j],
precision, Points->y[j] * -1, precision, radius);
cnt += 1;
}
}
fprintf(fpsvg, " </g>\n");
G_message(_("%d points extracted"), cnt);
}
}
/* extract lines if requested */
if (type == TYPE_LINE) {
if (Vect_get_num_primitives(&In, GV_LINES) == 0) {
G_warning(_("No lines found, skipping %s"), "type=line");
}
else {
/* extract lines as paths */
fprintf(fpsvg, " <g id=\"%s\" fill=\"none\" stroke=\"#000\" "
"stroke-width=\"%.*f\" >\n", G_Lines, precision, width);
for (i = 1; i <= nlines; i++) {
G_percent(i, nlines, 5);
if (!(Vect_read_line(&In, Points, Cats, i) & GV_LINES))
continue;
if (field != -1 && !Vect_cat_get(Cats, field, NULL))
continue;
fprintf(fpsvg, " <path ");
if (Cats->n_cats > 0) {
mk_attribs(Cats->cat[0], Fi, Driver, Table,
attr_cols, attr_size, do_attr);
}
fprintf(fpsvg, "d=\"");
mk_path(Points, precision);
fprintf(fpsvg, "\" />\n");
cnt += 1;
}
fprintf(fpsvg, " </g>\n");
G_message(_("%d lines extracted"), cnt);
}
}
/* finish code */
fprintf(fpsvg, "</svg>\n");
if (db_open == 1) {
/* close database handle */
db_close_database(Driver);
db_shutdown_driver(Driver);
}
/* close SVG-file */
fclose(fpsvg);
exit(EXIT_SUCCESS);
}
/*
* get_all_cpu_cache_details()
* Obtain information on all cpus caches on the system.
*
* Returns: dynamically-allocated cpus_t object, or NULL on error.
*/
cpus_t * get_all_cpu_cache_details(void)
{
uint32_t i;
int ret;
glob_t globbuf;
char **results;
cpus_t *cpus = NULL;
size_t cpu_count;
(void)memset(&globbuf, 0, sizeof(globbuf));
ret = file_exists(SYS_CPU_PREFIX);
if (!ret) {
pr_err("%s does not exist\n", SYS_CPU_PREFIX);
return NULL;
}
if (ret != S_IFDIR) {
pr_err("file %s is not a directory\n", SYS_CPU_PREFIX);
return NULL;
}
ret = glob(GLOB_PATTERN, SHIM_GLOB_ONLYDIR, NULL, &globbuf);
if (ret != 0) {
pr_err("glob on regex \"%s\" failed: %d\n",
GLOB_PATTERN, ret);
return NULL;
}
results = globbuf.gl_pathv;
cpu_count = globbuf.gl_pathc;
if (!cpu_count) {
/* Maybe we should check this? */
pr_err("no CPUs found - is /sys mounted?\n");
goto out;
}
cpus = calloc(1, sizeof(cpus_t));
if (!cpus)
goto out;
cpus->cpus = calloc(cpu_count, sizeof(cpu_t));
if (!cpus->cpus) {
free(cpus);
cpus = NULL;
goto out;
}
cpus->count = cpu_count;
for (i = 0; i < cpus->count; i++) {
char *contents = NULL;
cpu_t *cpu;
cpu = &cpus->cpus[i];
cpu->num = i;
if (i == 0) {
/* 1st CPU cannot be taken offline */
cpu->online = 1;
} else {
const size_t len = strlen(results[i]);
char path[len + 32];
(void)memset(path, 0, sizeof(path));
(void)strncpy(path, results[i], len);
mk_path(path, len, "/online");
contents = get_string_from_file(path);
if (!contents)
goto out;
cpu->online = atoi(contents);
free(contents);
}
ret = get_cpu_cache_details(&cpus->cpus[i], results[i]);
if (ret != EXIT_SUCCESS) {
free(cpus->cpus);
free(cpus);
cpus = NULL;
goto out;
}
}
out:
globfree(&globbuf);
return cpus;
}
/*
* add_cpu_cache_detail()
* @cache: cpu_cache_t pointer.
* @index_path: full /sys path to the particular cpu cache which is to
* be represented by @cache.
* Populate the specified @cache based on the given cache index.
*
* Returns: EXIT_FAILURE or EXIT_SUCCESS.
*/
static int add_cpu_cache_detail(cpu_cache_t *cache, const char *index_path)
{
const size_t index_posn = index_path ? strlen(index_path) : 0;
const size_t path_len = index_posn + 32;
char path[path_len];
char *contents = NULL;
int ret = EXIT_FAILURE;
(void)memset(path, 0, sizeof(path));
if (!cache) {
pr_dbg("%s: invalid cache specified\n", __func__);
goto out;
}
if (!index_path) {
pr_dbg("%s: invalid index specified\n", __func__);
goto out;
}
(void)strncpy(path, index_path, index_posn + 1);
mk_path(path, index_posn, "/type");
contents = get_string_from_file(path);
if (!contents)
goto out;
cache->type = (cache_type_t)get_cache_type(contents);
if (cache->type == CACHE_TYPE_UNKNOWN)
goto out;
free(contents);
mk_path(path, index_posn, "/size");
contents = get_string_from_file(path);
if (!contents)
goto out;
cache->size = size_to_bytes(contents);
free(contents);
mk_path(path, index_posn, "/level");
contents = get_string_from_file(path);
if (!contents)
goto out;
cache->level = (uint16_t)atoi(contents);
free(contents);
mk_path(path, index_posn, "/coherency_line_size");
contents = get_string_from_file(path);
if (!contents)
goto out;
cache->line_size = (uint32_t)atoi(contents);
free(contents);
mk_path(path, index_posn, "/ways_of_associativity");
contents = get_string_from_file(path);
/* Don't error if file is not readable: cache may not be
* way-based.
*/
cache->ways = contents ? atoi(contents) : 0;
ret = EXIT_SUCCESS;
out:
if (contents)
free(contents);
return ret;
}