Linuxissa on ohjelma "free" joka tulostaa paljonko on muistia käytetty/vapaana. Pitäisi jotenkin c ohjelmsta saada lukemat: total, used, free.
Eli toiselta rivilta: toinen, kolmas ja neljäs "sana".
Ei ole mitään hajua miten tuon saisi tehtyä C:lla.
Eli toiselta rivilta: toinen, kolmas ja neljäs "sana".
Ei ole mitään hajua miten tuon saisi tehtyä C:lla.
Vastaukset 15
Vanhimmat
ei tarkistuksia, ja int voi olla liian pieni (yli 2 Gigaa).
#include
#include
int main(void)
{
FILE *fp = popen("free","r");
if (fp != NULL)
{
char buffer[1024];
char temp[1024];
int i1,i2,i3;
fgets(buffer,sizeof(buffer),fp);
fgets(buffer,sizeof(buffer),fp);
sscanf(buffer,"%s %d %d %d",temp,&i1,&i2,&i3);
printf("i1 = %d i2 = %d i3 = %d\n\n",i1,i2,i3);
puts(buffer);
pclose(fp);
fp = NULL;
}
else puts("ERROR");
return 0;
}
Kannataa tutustua systeemi kutsuihin josta se varmasti löytyy ja toimii paremmin ;P
Tämä toteutus perustuu artsin tekemään main ohjelmaan.
/* gcc -Wall luefree.c */
/* Tässä on yksi implementaatio funktioille popen() ja pclose(),
tosin nimet ovat popen2() ja pclose2(), nimi kiistojen välttämiseksi
standardien kanssa.
Tässä toteutuksessa on oletettu että, funktiota popen2() kutsutaan,
aluksi ja vain kerran, ja sen perään sitten pclose2().
Tämä versio ei siis sisällä optiota kutsua funktioita popen2(), useita
kertoja peräkkäin ilman että on kutsunut välissä pclose2() funktiota.
Tätä toteutusta voisi sanoa pyörän uudelleen keksimiseksi, mutta mielestäni
on tärkeää ymmärtää, että mitä johonkin funktioon kuten popen() ja pclose()
sisältyy.
*/
#include
#include
#include
#include
#include
#include
FILE *popen2(const char *, const char *);
int pclose2(FILE *);
int main(void)
{
FILE *fp;
char buffer[4096], tmp[256];
int i, j, k;
if ( (fp = popen2("free", "r")) == NULL) {
printf("popen error");
exit(1);
}
fgets(buffer, sizeof(buffer), fp);
fgets(buffer, sizeof(buffer), fp);
sscanf(buffer, "%s %d %d %d", tmp, &i, &j, &k);
printf("\n%d, %d, %d\n", i, j, k);
if (pclose2(fp) == -1) {
printf("pclose error");
exit(1);
}
exit(0);
}
#define SHELL "/bin/sh"
static pid_t childpid;
FILE *popen2(const char *cmdstring, const char *type)
{
int pfd[2];
pid_t pid;
FILE *fp;
if ( (type[0] != 'r' && type[0] != 'w') || type[1] != 0) {
errno = EINVAL;
return(NULL);
}
if (pipe(pfd) < 0)
return(NULL);
if ( (pid = fork()) < 0)
return(NULL);
else if (pid == 0) {
if (*type == 'r') {
close(pfd[0]);
if (pfd[1] != STDOUT_FILENO) {
dup2(pfd[1], STDOUT_FILENO);
close(pfd[1]);
}
} else {
close(pfd[1]);
if (pfd[0] != STDIN_FILENO) {
dup2(pfd[0], STDIN_FILENO);
close(pfd[0]);
}
}
execl(SHELL, "sh", "-c", cmdstring, NULL);
_exit(127);
}
if (*type == 'r') {
close(pfd[1]);
if ( (fp = fdopen(pfd[0], type)) == NULL)
return(NULL);
} else {
close(pfd[0]);
if ( (fp = fdopen(pfd[1], type)) == NULL)
return(NULL);
}
childpid = pid;
return(fp);
}
int pclose2(FILE *fp)
{
int stat;
pid_t pid;
if (fclose(fp) == EOF)
return(-1);
pid = childpid;
while (waitpid(pid, &stat, 0) < 0) {
if (errno != EINTR) {
return(-1);
}
}
return(stat);
}
samat tiedot saa luettua /proc/meminfo tiedostosta
#include
#include
#include
int main(void)
{
FILE *fp = fopen("/proc/meminfo","r");
if (fp != NULL) {
char buffer[1024];
char tmpc[1024];
int tmpi, isit;
int MemTotal, MemFree;
while(fgets(buffer,sizeof(buffer),fp)) {
sscanf(buffer,"%s %d",tmpc,&tmpi);
if ((isit = strcmp (tmpc, "MemTotal:")) == 0) MemTotal = tmpi;
if ((isit = strcmp (tmpc, "MemFree:")) == 0) MemFree = tmpi;
}
printf("MemTotal %d \nMemFree: %d \n", MemTotal, MemFree);
fclose(fp);
fp = NULL;
}
else puts("ERROR");
return 0;
}
vain ohjata stdouttia johonkin muuttujaan ja käynnistää sen jälkeen system() funktiolla se free?
Tämä toiminee Linuxissa, muissa tuskin.
#include
#include
#include
/* gcc -Wall -o jutska jutska.c */
int main(int argc,char **argv) {
struct sysinfo s_info;
int error, mu;
error = sysinfo(&s_info);
if (error) {
printf("error=%d\\n", error);
return(1);
}
mu = s_info.mem_unit;
printf("Total %lu / used %lu / free %lu\\n",
s_info.totalram*mu,
(s_info.totalram-s_info.freeram)*mu,
s_info.freeram*mu);
return(0);
}
Jos tarve kyseiselle tiedolle on vain väliaikainen, niin C:n käyttö on totaalisen yliampuvaa. grepin ja cutin käyttö /proc/meminfo:lle ajaa saman asian.
Kas, onkohan foorumiin korjattu jo se aiemmin esiintynyt kenomerkkibugi. \\ pitää siis olla \.
Mistä löytäisin kaikki nämä s_info... jutskat?
Joku man sivut tai jotain?
s_info.totalram
s_info.freeram
s_info.....
Täältä löytyy toi tietue:
/usr/include/linux/kernel.h
struct sysinfo {
long uptime; /* Seconds since boot */
unsigned long loads[3]; /* 1, 5, and 15 minute load averages */
unsigned long totalram; /* Total usable main memory size */
unsigned long freeram; /* Available memory size */
unsigned long sharedram; /* Amount of shared memory */
unsigned long bufferram; /* Memory used by buffers */
unsigned long totalswap; /* Total swap space size */
unsigned long freeswap; /* swap space still available */
unsigned short procs; /* Number of current processes */
unsigned short pad; /* explicit padding for m68k */
unsigned long totalhigh; /* Total high memory size */
unsigned long freehigh; /* Available high memory size */
unsigned int mem_unit; /* Memory unit size in bytes */
char _f[20-2*sizeof(long)-sizeof(int)]; /* Padding: libc5 uses this.. */
};
Siellä on tuo bufferram, mutta miten tuo "cached" lasketaan?
Olisit voinut kokeilla sitä man sysinfoa ensin, niin ei olisi tarvinut kysyä ollenkaan..
Ilmeisesti sitä ei saa ainakaan suoraan sysinfon kautta. free näyttää hakevan kaikki tiedot lukemalla suoraan /proc/meminfoa. Jos haluat oikeasti tietää miten se cachedin arvo lasketaan, niin jonkunlainen tekninen selitys on paikallaan:
/proc/meminfon tuloste tulee suoraan kernelistä. Jos sinulla sattuu olemaan kernelin lähdekoodi, niin katso fs/proc/proc_misc.c ja sieltä funktio meminfo_read_proc. Cached-arvo lasketaan vähentämällä puskureihin käytetty muisti (buffers) sillä hetkellä muistissa olevien ns. sivujen viemästä muistista.
http://lxr.linux.no/source/fs/proc/proc_misc.c#L152
>unsigned long loads[3]; /* 1, 5, and 15 minute load averages */
Mikä on tuon luvun maksimiarvo?
Kernelikäännöksen aikana se oli 84096, joten kai se on sitten 100000? Onko oikea arvaus?
Tuo on kylläkin kolmen mittaisen unsigned long intin muodostama taulukko eikä yksi luku. unsigned long int on 32-bittisellä alustalla maksimissaan 4294967295. 100000 on todellakin siis täysi arvaus.
84096 ei ole oikein, koska load-arvoa ei saada suoraan ottamalla taulukon arvo. Oikea arvo saadaan skaalaamalla, eli käytännössä tekemällä yksi bitittäinen siirto -operaatio ja jakamalla vielä load-arvo tällä luvulla. Tarvittava arvo shiftaukselle saadaan vakiosta SI_LOAD_SHIFT, joka saadaan sen #include :n sivutuotteena. Esim. yhden minuutin keskimääräinen load-arvo saadaan vaikka näin (arvo floattina, koska muuten kokonaislukuoperaatiot katkaisevat luvun):
(float)s_info.loads[0]/(1
Tuota ei kannata "includettaa" suoraan, vaan vain sys/sysinfo.h. Siellä tehdään taustalla tuo linux/kernel.h:n include.