De la non asynchronicité du protocole AgentX dans Net-⁠SNMP

Vincent Bernat

Une des fa­çons les plus com­modes pour ajou­ter un sup­port SNMP est d’uti­li­ser le pro­to­cole AgentX : une ap­pli­ca­tion se com­porte comme un sous-agent et trai­tera les re­quêtes dé­lé­guées par un agent maître via ce pro­to­cole. L’im­plé­men­ta­tion la plus cou­rante est celle de Net-⁠SNMP.

En bref

Une ap­pli­ca­tion ex­ploi­tant l’im­plé­men­ta­tion AgentX de Net-⁠SNMP de ma­nière asyn­chrone peut se blo­quer à de nom­breuses oc­ca­sions en rai­son prin­ci­pa­le­ment de l’in­dis­po­ni­bi­lité tem­po­raire de l’agent maître. Une contre-me­sure as­sez ef­fi­cace est d’uti­li­ser comme agent maître un agent dé­dié à cette tâche et dé­lé­guer le trai­te­ment des MIB à un sous-agent.

Test de disponibilité de l’agent maître#

Net-⁠SNMP ex­ploite un mo­dèle de pro­gram­ma­tion évè­ne­men­tielle. Il four­nit éga­le­ment des fonc­tions syn­chrones clas­siques mais celles-ci sont construites à par­tir des ver­sions asyn­chrones. Il ex­ploite sa propre boucle d’évè­ne­ments. Son im­plé­men­ta­tion d’AgentX semble alors un choix na­tu­rel pour ajou­ter un sup­port SNMP dans une ap­pli­ca­tion asyn­chrone comme Kee­pa­li­ved, une so­lu­tion de haute dis­po­ni­bi­lité et de ré­par­ti­tion de charge.

Mal­heu­reu­se­ment, un sous-agent doit vé­ri­fier ré­gu­liè­re­ment si l’agent maître est tou­jours dis­po­nible. Cette opé­ra­tion est ef­fec­tuée au­to­ma­ti­que­ment du mo­ment que vous uti­li­sez la fonc­tion run_​alarms() qui va à son tour faire ap­pel à agentx_​check_​session() :

/*
 * check a session validity for connectivity to the master agent.  If
 * not functioning, close and start attempts to reopen the session
 */
void
agentx_check_session(unsigned int clientreg, void *clientarg)
{
    /* […] */
    DEBUGMSGTL(("agentx/subagent", "checking status of session %p\n", ss));

    if (!agentx_send_ping(ss)) {
        snmp_log(LOG_WARNING,
                 "AgentX master agent failed to respond to ping.  Attempting to re-register.\n");
        /*
         * master agent disappeared?  Try and re-register.
         * close first, just to be sure .
         */
        agentx_unregister_callbacks(ss);
        agentx_close_session(ss, AGENTX_CLOSE_TIMEOUT);
        /* […] */
        if (main_session != NULL) {
            /* […] */
            main_session = NULL;
            agentx_reopen_session(0, NULL);
        }
        else {
            snmp_close(main_session);
            main_session = NULL;
        }
    } else {
        DEBUGMSGTL(("agentx/subagent", "session %p responded to ping\n",
                    ss));
    }
}

Ce code ap­pelle di­rec­te­ment ou in­di­rec­te­ment les fonc­tions sui­vantes1 qui font en­suite ap­pel à agentx_​synch_​response() :

  • agentx_​send_ping() ;
  • agentx_​open_​session() ;
  • agentx_​reopen_​session() ;
  • agentx_​close_​session() ;
  • agentx_​register() ;
  • agentx_​unregister() ;
  • agentx_​register_​index() ;
  • agentx_​unregister_​index() ;
  • agentx_​add_​agentcaps() ;
  • agentx_​remove_​agentcaps().

agentx_​synch_​response() va at­tendre de ma­nière syn­chrone une ré­ponse de l’agent maître. Votre pro­gramme asyn­chrone va donc res­ter blo­qué à ne rien faire pen­dant ce laps de temps. Par exemple, kee­pa­li­ved sera in­ca­pable d’en­voyer les pa­quets VRRP né­ces­saires au bon fonc­tion­ne­ment du cluster.

Les fonc­tions pré­fixées par agentx_ ne font pas par­tie de l’API de Net-⁠SNMP et pour­raient donc être cor­ri­gées. Plus fa­cile à dire qu’à faire. De plus, il existe d’autres points de blo­cage en­fouis dans Net-⁠SNMP. Ainsi, la connexion de bas ni­veau (TCP ou so­cket Unix) avec l’agent maître uti­lise la fonc­tion connect() de ma­nière syn­chrone. Cet as­pect a de nom­breuses ra­mi­fi­ca­tions dif­fi­ciles à évoluer.

Voici quelques contre-me­sures (par­tielles) :

  • Ap­pe­ler agentx_​check_​session() moins sou­vent. Par dé­faut, cette fonc­tion est in­vo­quée toutes les 15 se­condes. La désac­ti­ver com­plè­te­ment ou uti­li­ser une va­leur très éle­vée est dé­con­seillé car le sous-agent ne se re­con­nec­tera pas à l’agent maître en cas de re­dé­mar­rage de ce der­nier. Voici com­ment por­ter l’in­ter­valle à 20 secondes :

    netsnmp_ds_set_int(NETSNMP_DS_APPLICATION_ID,
                       NETSNMP_DS_AGENT_AGENTX_PING_INTERVAL, 120);
    
  • Ne pas ap­pe­ler agentx_​check_​session() si l’agent maître a donné des signes de vie ré­cem­ment, no­tam­ment en en­voyant une re­quête à trai­ter. J’ai écrit un patch met­tant en place une telle contre-me­sure. L’ABI reste in­chan­gée et il n’y a donc be­soin que de re­com­pi­ler les bi­blio­thèques de Net-⁠SNMP.

  • Uti­li­ser des va­leurs plus faibles pour le dé­lai d’at­tente et le nombre d’es­sais. Par dé­faut, le dé­lai d’at­tente est de 1 se­conde et le nombre d’es­sais est fixé à 5. En rai­son de l’uti­li­sa­tion de plu­sieurs fonc­tions syn­chrones à la suite, il est pos­sible de res­ter blo­qué jusqu’à 30 se­condes. Voici com­ment2 désac­ti­ver les es­sais sup­plé­men­taires et di­mi­nuer for­te­ment le dé­lai d’attente :

    static int
    snmp_setup_session_cb(int majorID, int minorID,
                  void *serverarg, void *clientarg)
    {
        netsnmp_session *sess = serverarg;
        sess->timeout = ONE_SEC / 3;
        sess->retries = 0;
        return 0;
    }
    
    void some_init_function()
    {
        /* […] */
        snmp_register_callback(SNMP_CALLBACK_LIBRARY,
           SNMP_CALLBACK_SESSION_INIT,
           snmp_setup_session_cb, NULL);
        /* […] */
    }
    

Non réponse de l’agent maître#

Pour­quoi l’agent maître peut ne pas ré­pondre aux re­quêtes ? snmpd uti­lise éga­le­ment la pro­gram­ma­tion évè­ne­men­tielle et il va se blo­quer à de nom­breuses oc­ca­sions. Voici deux exemples :

  • Les di­rec­tives pass et pass_​persist ne rendent pas la main avant que la com­mande à exé­cu­ter n’af­fiche une ligne complète.

    /* var_extensible_pass() in agent/mibgroup/ucd-snmp/pass.c */
    /*
     * valid call.  Exec and get output
     */
    if ((fd = get_exec_output(passthru)) != -1) {
        file = fdopen(fd, "r");
        if (fgets(buf, sizeof(buf), file) == NULL) {
            fclose(file);
            wait_on_exec(passthru);
            /* […] */
            continue;
        }
        /* […] */
        fclose(file);
        wait_on_exec(passthru);
        /* […] */
    }
    
  • L’im­plé­men­ta­tion de DISMAN-PING-MIB se bloque pen­dant le dé­rou­le­ment des pings vers l’hôte dis­tant. Si ce der­nier est in­ac­ces­sible, snmpd peut se blo­quer pen­dant de longues se­condes. Un pro­blème si­mi­laire existe pour DISMAN-TRACEROUTE-MIB.

Agent maître minimal#

De plus en plus de code est exé­cuté par l’agent maître et donc la si­tua­tion ne va pas al­ler en s’amé­lio­rant. Pour pal­lier à notre pro­blème, nous al­lons in­ter­ca­ler un agent maître mi­ni­mal. L’agent qui jouait jusqu’ici le rôle d’agent maître et ser­vait un cer­tain nombre de MIB va de­ve­nir un sous-agent. Les sous-agents exis­tants se connec­te­ront au nou­vel agent maître.

Schema showing the use of a minimal master agent
Adding a minimal master agent and turning snmpd into a subagent

Trans­for­mer snmpd en sous-agent est simple : il suf­fit d’uti­li­ser le dra­peau -X. Nous de­vons éga­le­ment désac­ti­ver cer­taines MIB se­lon le rôle de l’agent. Cela se fait avec le dra­peau -I. L’agent mi­ni­mal n’uti­li­sera que les mo­dules stric­te­ment né­ces­saires à son fonc­tion­ne­ment. Tous les autres mo­dules3 se­ront ser­vis par snmpd en tant que sous-agent.

$ MODS="snmp_mib,sysORTable,usmConf,usmStats,usmUser,vacm_conf,vacm_context,vacm_vars"
$ snmpd -Lsd -Lf /dev/null -u snmp -g snmp \
>   -C -c /etc/snmp/snmpd.master.conf \
>   -p /var/run/snmpd.master.pid \
>   -I $MODS
$ snmpd -Lsd -Lf /dev/null -u snmp -g snmp \
>   -p /var/run/snmpd.pid -X \
>   -I -$MODS

La confi­gu­ra­tion des ac­cès et la di­rec­tive master agentx doivent se trou­ver dans /etc/​snmp/​snmpd.​master.​conf. Les autres di­rec­tives (telles que pass, pass_​persist, load, sysname, …) doivent être dans /etc/​snmp/​snmpd.conf.

Il est dé­sor­mais peu pro­bable d’ob­ser­ver un blo­quage de l’agent maître. Bien que le pro­blème soit po­ten­tiel­le­ment tou­jours pré­sent, sa sur­face est consi­dé­ra­ble­ment ré­duite. Il est pos­sible d’étendre cette so­lu­tion en sau­cis­son­nant snmpd en plu­sieurs sous-agents: l’un pour les di­rec­tives comme pass et pass_​persist, un autre pour la plu­part des mo­dules et un der­nier pour les mo­dules plus li­ti­gieux, tels que DISMAN-PING-MIB.