/alps/pcitool

To get this branch, use:
bzr branch http://suren.me/webbzr/alps/pcitool

« back to all changes in this revision

Viewing changes to pcitool/sysinfo.c

  • Committer: Suren A. Chilingaryan
  • Date: 2011-12-08 02:47:23 UTC
  • Revision ID: csa@dside.dyndns.org-20111208024723-ym9uf3uoll6ym2a9
new event architecture, first trial

Show diffs side-by-side

added added

removed removed

Lines of Context:
pcitool/sysinfo.c
 
1
#include <stdio.h>
 
2
#include <stdlib.h>
 
3
#include <sys/types.h>
 
4
#include <sys/stat.h>
 
5
#include <fcntl.h>
 
6
#include <unistd.h>
 
7
#include <string.h>
 
8
#include <strings.h>
 
9
 
 
10
#define MEMINFO_FILE "/proc/meminfo"
 
11
#define MTAB_FILE "/etc/mtab"
 
12
 
 
13
#define BAD_OPEN_MESSAGE                                        \
 
14
"Error: /proc must be mounted\n"                                \
 
15
"  To mount /proc at boot you need an /etc/fstab line like:\n"  \
 
16
"      /proc   /proc   proc    defaults\n"                      \
 
17
"  In the meantime, run \"mount /proc /proc -t proc\"\n"
 
18
 
 
19
/* This macro opens filename only if necessary and seeks to 0 so
 
20
 * that successive calls to the functions are more efficient.
 
21
 * It also reads the current contents of the file into the global buf.
 
22
 */
 
23
#define FILE_TO_BUF(filename) do{                               \
 
24
    static int fd, local_n;                                     \
 
25
    if ((fd = open(filename, O_RDONLY)) == -1) {                \
 
26
        fputs(BAD_OPEN_MESSAGE, stderr);                        \
 
27
        fflush(NULL);                                           \
 
28
        _exit(102);                                             \
 
29
    }                                                           \
 
30
    lseek(fd, 0L, SEEK_SET);                                    \
 
31
    if ((local_n = read(fd, buf, sizeof buf - 1)) < 0) {        \
 
32
        perror(filename);                                       \
 
33
        fflush(NULL);                                           \
 
34
        _exit(103);                                             \
 
35
    }                                                           \
 
36
    buf[local_n] = '\0';                                        \
 
37
    close(fd);                                                  \
 
38
}while(0)
 
39
 
 
40
 
 
41
typedef struct mem_table_struct {
 
42
  const char *name;     /* memory type name */
 
43
  unsigned long *slot; /* slot in return struct */
 
44
} mem_table_struct;
 
45
 
 
46
static int compare_mem_table_structs(const void *a, const void *b){
 
47
  return strcmp(((const mem_table_struct*)a)->name,((const mem_table_struct*)b)->name);
 
48
}
 
49
 
 
50
size_t get_free_memory(void){
 
51
  char buf[4096];
 
52
  unsigned long kb_main_buffers, kb_main_cached, kb_main_free;
 
53
  char namebuf[16]; /* big enough to hold any row name */
 
54
  mem_table_struct findme = { namebuf, NULL};
 
55
  mem_table_struct *found;
 
56
  char *head;
 
57
  char *tail;
 
58
 
 
59
  const mem_table_struct mem_table[] = {
 
60
    {"Buffers",      &kb_main_buffers}, // important
 
61
    {"Cached",       &kb_main_cached},  // important
 
62
    {"MemFree",      &kb_main_free},    // important
 
63
  };
 
64
  const int mem_table_count = sizeof(mem_table)/sizeof(mem_table_struct);
 
65
 
 
66
  FILE_TO_BUF(MEMINFO_FILE);
 
67
 
 
68
  head = buf;
 
69
  for(;;){
 
70
    tail = strchr(head, ':');
 
71
    if(!tail) break;
 
72
    *tail = '\0';
 
73
    if(strlen(head) >= sizeof(namebuf)){
 
74
      head = tail+1;
 
75
      goto nextline;
 
76
    }
 
77
    strcpy(namebuf,head);
 
78
    found = bsearch(&findme, mem_table, mem_table_count,
 
79
        sizeof(mem_table_struct), compare_mem_table_structs
 
80
    );
 
81
    head = tail+1;
 
82
    if(!found) goto nextline;
 
83
    *(found->slot) = strtoul(head,&tail,10);
 
84
nextline:
 
85
    tail = strchr(head, '\n');
 
86
    if(!tail) break;
 
87
    head = tail+1;
 
88
  }
 
89
  
 
90
  return (kb_main_buffers + kb_main_cached + kb_main_free) * 1024;
 
91
}
 
92
 
 
93
 
 
94
int get_file_fs(const char *fname, size_t size, char *fs) {
 
95
  int err = 0;
 
96
  char buf[4096];
 
97
  char *fn;
 
98
 
 
99
  char *head;
 
100
  char *tail;
 
101
 
 
102
  size_t len, max = 0;
 
103
  struct stat st;
 
104
  
 
105
  if ((!fname)||(!fs)||(size < 3)) return -1;
 
106
  
 
107
  if (*fn == '/') {
 
108
    fn = (char*)fname;
 
109
  } else {
 
110
    if (!getcwd(buf, 4095)) return -1;
 
111
    fn = malloc(strlen(fname) + strlen(buf) + 2);
 
112
    if (!fn) return -1;
 
113
    sprintf(fn, "%s/%s", buf, fname);
 
114
  }
 
115
  
 
116
  if (!stat(fn, &st)) {
 
117
    if (S_ISBLK(st.st_mode)) {
 
118
        strcpy(fs, "raw");
 
119
        goto clean;
 
120
    }
 
121
  }
 
122
  
 
123
  FILE_TO_BUF(MTAB_FILE);
 
124
 
 
125
  head = buf;
 
126
  for(;;){
 
127
    head = strchr(head, ' ');
 
128
    if(!head) break;
 
129
 
 
130
    head += 1;
 
131
    tail = strchr(head, ' ');
 
132
    if(!tail) break;
 
133
    
 
134
    *tail = '\0';
 
135
 
 
136
    len = strlen(head);
 
137
    if((len <= max)||(strncmp(head, fn, len))) {
 
138
      head = tail+1;
 
139
      goto nextline;
 
140
    }
 
141
    
 
142
    head = tail + 1;
 
143
    tail = strchr(head, ' ');
 
144
    if(!tail) break;
 
145
 
 
146
    *tail = '\0';
 
147
 
 
148
    if (!strncasecmp(head,"root",4)) {
 
149
        head = tail+1;
 
150
        goto nextline;
 
151
    }
 
152
    
 
153
    max = len;
 
154
 
 
155
    if (strlen(head) >= size) err = -1;
 
156
    else {
 
157
        err = 0;
 
158
        strcpy(fs, head);
 
159
    }
 
160
    
 
161
    head = tail+1;
 
162
nextline:
 
163
    tail = strchr(head, '\n');
 
164
    if(!tail) break;
 
165
    head = tail+1;
 
166
  }
 
167
 
 
168
clean:  
 
169
  if (fn != fname) free(fn);
 
170
 
 
171
puts(fs);
 
172
  return err;
 
173
}