Ce que l'API dois-je appeler pour obtenir le temps de disponibilité du système?

Je voudrais obtenir la disponibilité du système à partir de l'intérieur d'une application C en cours d'exécution sur un système linux. Je ne veux pas l'appeler uptime(1) et d'analyser les données en sortie, je voudrais appeler le sous-jacent de l'API C je soupçonne existe. Quelqu'un sait si il y a un tel appel, ou ne uptime(1), il suffit de traiter les enregistrements obtenus à partir de wtmp?

  • est-il possible d'obtenir la disponibilité du nano secondes ??? Avez-vous essayé ?
InformationsquelleAutor Stéphane | 2009-10-08
  1. 37

    L'appel système que vous cherchez est sysinfo().

    Il est défini dans sys/sysinfo.h

    Sa signature est:
    int sysinfo(struct sysinfo *info)

    Depuis le noyau 2.4, la structure a regardé comme ça:

    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 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 for libc5 */
};

    Amusez-vous!

    • Je l'avais mise en œuvre de la lecture /proc/uptime comme bdonlan suggéré ci-dessus, mais l'appel d'une API rapport à la lecture d'un "fichier", c'est exactement ce que je voulais. Merci!!!!
    • Est-il possible d'obtenir des nano secondes informations de niveau de disponibilité)??
    InformationsquelleAutor Kyle Smith
  2. 15

    Qui serait quelque chose comme ceci.

    #include <stdio.h>
#include <errno.h>
#include <linux/unistd.h>       /* for _syscallX macros/related stuff */
#include <linux/kernel.h>       /* for struct sysinfo */
#include <sys/sysinfo.h>

long get_uptime()
{
    struct sysinfo s_info;
    int error = sysinfo(&s_info);
    if(error != 0)
    {
        printf("code error = %d\n", error);
    }
    return s_info.uptime;
}

    Voir "l'homme sysinfo" pour plus d'info.

    • Vous êtes manquant: #include <sys/sysinfo.h>
    InformationsquelleAutor Johan
  3. 13

    Lire le fichier /proc/uptime et de prendre le premier nombre décimal que le temps de fonctionnement en secondes.

    De homme 5 proc:

       /proc/uptime
          This file contains two numbers: the uptime of the  system  (sec‐
          onds), and the amount of time spent in idle process (seconds).
    • ...et si vous strace la uptime(1) de commande, vous verrez que c'est exactement ce qu'.
    • caf: sur les machines linux, BSD machines utilise généralement des "temps actuel - syctl kern.démarrage"
    • fait beaucoup plus que cela, de sorte qu'il peut être un peu dur à trouver 🙂
    • Cette approche donne de mauvais résultats si quelqu'un réinitialise l'heure actuelle en utilisant la fonction "date" ou appeler settimeofday() de l'API. Je suis à la recherche de quelque chose de basé sur les tiques qui ne peut pas être affecté par le temps/date réglage de la date
    InformationsquelleAutor bdonlan
  4. 2

    Il y a aussi clock_gettime (probablement besoin de -lrt). Le comportement que j'ai vu (je ne vais pas prétendre que c'est garanti), mais CLOCK_MONOTONIC comme le clk_id est qu'il renvoie à la disponibilité du système dans le struct timespec * paramètre.

    #include <stdio.h>
#include <time.h>

int main(int argc, char* argv[]) {
  struct timespec t;
  clock_gettime(CLOCK_MONOTONIC, &t);
  printf("tv_sec=%llu tv_nsec=%llu\n",
    (unsigned long long)t.tv_sec,
    (unsigned long long)t.tv_nsec);
  return 0;
}
    • Non, il n'en est rien; la monotone de l'horloge a un arbitraire de l'époque. La page de manuel, vous vous dit juste que.
    • La question est balisé linux et sous Linux, le problème a été (et toujours est comme je l'ai décrit). POSIX dit que l'époque est arbitraire, l'implémentation de Linux est en corrélation avec la durée de fonctionnement. Voir kernel/temps/posix-timers.c et fs/proc/uptime.c. Et en voici un LKML thread.
    • Vous liés à la mise en œuvre des fichiers. Cela pourrait changer à tout moment. La question est à propos de l'API, l'API dit que l'époque est arbitraire. L'arbitraire ne veut pas dire qu'il n'y a pas une époque, il signifie simplement que le choix est de ne pas être invoquée. La LKML fil de discussion lié à des états de ce.
    • Et dans ma réponse, j'ai écrit "je ne vais pas prétendre que c'est garanti." La question du texte mentionne expressément les "linux" comme le cas d'utilisation. La LKML thread indique également que le comportement n'est pas susceptible de changer à tout moment rapidement. POSIX permet d'écrire du code qui se comporte de manière fiable à travers compatible plates-formes. Si le cas d'utilisation couvre seulement une plate-forme qui semble très raisonnable de s'appuyer sur la plate-forme de comportement.
    • Pour les raisons décrites par la Légèreté des Courses En Orbite, je dirais que c'est une mauvaise réponse. Il y a un travail spécifique à linux api qui ne parviennent pas à compiler sur d'autres Systèmes d'exploitation, ce qui est préférable de s'appuyer sur un système d'exploitation spécifique de comportement d'un os-général de l'api qui va silencieusement faire la mauvaise chose sur d'autres Os ou en présence de changements à venir dans le compilateur.
    InformationsquelleAutor
  5. 0
    #include <sys/sysinfo.h>
#include <sys/types.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <grp.h>
int main() {
struct sysinfo sys_info;
struct group* grp;
gid_t gid;
char** users;
int days, hours, mins, x = 1;
system("clear");  
printf("\033[4;40m            Systems information                   \033[0;m \n");
if(sysinfo(&sys_info) != 0)
perror("sysinfo");
days = sys_info.uptime / 86400;
hours = (sys_info.uptime / 3600) - (days * 24);
mins = (sys_info.uptime / 60) - (days * 1440) - (hours * 60);
printf("\033[1;33m  Uptime: \033[0;36m %ddays, %dhours, %dminutes, %ldseconds \033[0;m \n",
days, hours, mins, sys_info.uptime % 60);
printf("\033[1;33m  Load Avgs: \033[0;m 1min(%ld) 5min(%ld) 15min(%ld) \n",
sys_info.loads[0], sys_info.loads[1], sys_info.loads[2]);
printf("\033[1;33m  Total Ram: \033[0;m %ldk \t Free: %ldk \n", sys_info.totalram / 1024, sys_info.freeram / 1024);
printf(" \033[1;33m Shared Ram: \033[0;m %ldk ", sys_info.sharedram / 1024);
printf("  Buffered Ram: %ldk \n", sys_info.bufferram / 1024);
printf("\033[1;33m  Total Swap: \033[0;m %ldk \t Free swap: %ldk \n", sys_info.totalswap / 1024, sys_info.freeswap / 1024);
printf("\033[1;33m  Total High Memory: \033[0;m %ldk  Free high memory: %ldk \033[0;m \n", sys_info.totalhigh / 1024, sys_info.freehigh / 1024);
printf(" \n");
printf("\033[1;44m Total Number of processes: %d \033[0;m \n", sys_info.procs);  
gid = getgid();
printf("  Group ID: \033[031m %d", gid);
if((grp = getgrgid(gid)) == NULL ) return 1;
printf("\033[0;m Group %s ", grp->gr_name );
printf("\n  Users in your group ");
for( users = grp->gr_mem; *users != NULL; users++,++x ); printf( "%d", ++x);     
if(strcmp(grp->gr_passwd,"x") == 0) printf("  Password is protected by shadow file. \n");
else printf("Password: %s ", grp->gr_passwd);   
return 0;
}
    • Une bonne réponse devrait inclure non seulement le code, mais aussi une explication de la façon dont il fonctionne et pourquoi il répond à la question. Cela est particulièrement vrai, comme il y a déjà accepté de répondre à la question.
    InformationsquelleAutor Johnny Buckallew Stroud