From 623d314d96de76c49df11ce796d2583d33568bd9 Mon Sep 17 00:00:00 2001
From: Andrew Hanushevsky <abh@stanford.edu>
Date: Tue, 17 Sep 2019 18:11:41 -0700
Subject: [PATCH] [Server] Add plug-in interface for performance reporting.

---
 src/XrdCms/XrdCmsAdmin.cc        |  39 +++++--
 src/XrdCms/XrdCmsAdmin.hh        |   1 +
 src/XrdCms/XrdCmsClient.hh       |  18 +++-
 src/XrdCms/XrdCmsClientConfig.cc |  92 +++++++++++++++-
 src/XrdCms/XrdCmsClientConfig.hh |  21 +++-
 src/XrdCms/XrdCmsConfig.cc       | 127 ++++++----------------
 src/XrdCms/XrdCmsConfig.hh       |   6 +-
 src/XrdCms/XrdCmsFinder.cc       | 101 +++++++++++++++++-
 src/XrdCms/XrdCmsFinder.hh       |  11 +-
 src/XrdCms/XrdCmsMeter.cc        | 178 ++++++++++++++++++++++++++-----
 src/XrdCms/XrdCmsMeter.hh        |  28 +++--
 src/XrdCms/XrdCmsNode.cc         |  15 +--
 src/XrdCms/XrdCmsPerfMon.hh      | 156 +++++++++++++++++++++++++++
 src/XrdCms/XrdCmsUtils.cc        |  16 +++
 src/XrdCms/XrdCmsUtils.hh        |  16 +++
 src/XrdHeaders.cmake             |   1 +
 src/XrdOuc/XrdOucUtils.cc        |  33 ++++++
 src/XrdOuc/XrdOucUtils.hh        |   3 +
 src/XrdServer.cmake              |  13 +--
 src/XrdSsi/XrdSsiClient.cc       |   3 +-
 src/XrdSsi/XrdSsiCluster.hh      |  13 +++
 src/XrdSsi/XrdSsiCms.hh          |   3 +
 22 files changed, 724 insertions(+), 170 deletions(-)
 create mode 100644 src/XrdCms/XrdCmsPerfMon.hh

diff --git a/src/XrdCms/XrdCmsAdmin.cc b/src/XrdCms/XrdCmsAdmin.cc
index 277af4c0851..a38af540600 100644
--- a/src/XrdCms/XrdCmsAdmin.cc
+++ b/src/XrdCms/XrdCmsAdmin.cc
@@ -42,6 +42,7 @@
 #include "XrdCms/XrdCmsAdmin.hh"
 #include "XrdCms/XrdCmsConfig.hh"
 #include "XrdCms/XrdCmsManager.hh"
+#include "XrdCms/XrdCmsMeter.hh"
 #include "XrdCms/XrdCmsPrepare.hh"
 #include "XrdCms/XrdCmsState.hh"
 #include "XrdCms/XrdCmsTrace.hh"
@@ -112,6 +113,8 @@ static XrdSysMutex     QMutex;
 static AdminReq       *First;
 static AdminReq       *Last;
 };
+
+extern XrdCmsMeter Meter;
 };
 
 /******************************************************************************/
@@ -140,28 +143,31 @@ static AdminReq       *Last;
 /*            E x t e r n a l   T h r e a d   I n t e r f a c e s             */
 /******************************************************************************/
   
-void *XrdCmsAdminLogin(void *carg)
+namespace
+{
+void *AdminLogin(void *carg)
       {XrdCmsAdmin *Admin = new XrdCmsAdmin();
        Admin->Login(*(int *)carg);
        delete Admin;
        return (void *)0;
       }
   
-void *XrdCmsAdminMonAds(void *carg)
+void *AdminMonAds(void *carg)
       {XrdCmsAdmin *Admin = (XrdCmsAdmin *)carg;
        Admin->MonAds();
        return (void *)0;
       }
   
-void *XrdCmsAdminMonARE(void *carg)
+void *AdminMonARE(void *carg)
       {XrdCmsAdmin::RelayAREvent();
        return (void *)0;
       }
 
-void *XrdCmsAdminSend(void *carg)
+void *AdminSend(void *carg)
       {XrdCmsAdmin::Relay(0,0);
        return (void *)0;
       }
+}
   
 /******************************************************************************/
 /*                          I n i t A R E v e n t s                           */
@@ -177,7 +183,7 @@ bool XrdCmsAdmin::InitAREvents(void *arFunc)
 
 // Start the event relay
 //
-   if (XrdSysThread::Run(&tid,XrdCmsAdminMonARE,(void *)0))
+   if (XrdSysThread::Run(&tid, AdminMonARE, (void *)0))
       {Say.Emsg("InitAREvents", errno, "start arevent relay");
        return false;
       }
@@ -227,6 +233,8 @@ void XrdCmsAdmin::Login(int socknum)
                      }
              else if (!strcmp("rmdid",    tp)) do_RmDid();   // via lfn
              else if (!strcmp("newfn",    tp)) do_RmDud();   // via lfn
+             else if (!strcmp("perf",     tp)) do_Perf();
+             else if (!strcmp("PERF",     tp)) do_Perf(true);
              else if (!strcmp("suspend",  tp)) 
                      {if ((tp = Stream.GetToken()) && *tp == 't') sPerm = 0;
                          else sPerm = 1;
@@ -448,7 +456,7 @@ void *XrdCmsAdmin::Start(XrdNetSocket *AdminSock)
 
 // Start the relay thread
 //
-   if (XrdSysThread::Run(&tid,XrdCmsAdminSend,(void *)0))
+   if (XrdSysThread::Run(&tid, AdminSend, (void *)0))
       Say.Emsg(epname, errno, "start admin relay");
 
 // If we are in independent mode then let the caller continue
@@ -463,7 +471,7 @@ void *XrdCmsAdmin::Start(XrdNetSocket *AdminSock)
 //
    while(1) if ((InSock = AdminSock->Accept()) >= 0)
                {XrdNetSocket::setOpts(InSock, 0);
-                if (XrdSysThread::Run(&tid,XrdCmsAdminLogin,(void *)&InSock))
+                if (XrdSysThread::Run(&tid, AdminLogin, (void *)&InSock))
                    {Say.Emsg(epname, errno, "start admin");
                     close(InSock);
                    }
@@ -513,7 +521,7 @@ void XrdCmsAdmin::BegAds()
 
 // Start the connection/ping thread for the alternate data server
 //
-   if (XrdSysThread::Run(&tid,XrdCmsAdminMonAds,(void *)this))
+   if (XrdSysThread::Run(&tid, AdminMonAds, (void *)this))
       Say.Emsg(epname, errno, "start alternate data server monitor");
 }
   
@@ -732,6 +740,21 @@ int XrdCmsAdmin::do_Login()
    return 1;
 }
  
+/******************************************************************************/
+/*                               d o _ P e r f                                */
+/******************************************************************************/
+  
+void XrdCmsAdmin::do_Perf(bool alert)
+{
+   const char *epname = "do_Perf";
+   char  buff[256];
+
+   if (!Stream.GetRest(buff, sizeof(buff)))
+      Say.Emsg(epname,"performance data is too long.");
+      else if (!Meter.Update(buff, alert))
+              Say.Emsg(epname,"performance data is invalid.");
+}
+  
 /******************************************************************************/
 /*                              d o _ R m D i d                               */
 /******************************************************************************/
diff --git a/src/XrdCms/XrdCmsAdmin.hh b/src/XrdCms/XrdCmsAdmin.hh
index ab30332830e..55dcaaeae11 100644
--- a/src/XrdCms/XrdCmsAdmin.hh
+++ b/src/XrdCms/XrdCmsAdmin.hh
@@ -75,6 +75,7 @@ void  BegAds();
 bool  CheckVNid(const char *xNid);
 int   Con2Ads(const char *pname);
 int   do_Login();
+void  do_Perf(bool alert=false);
 void  do_RmDid(int dotrim=0);
 void  do_RmDud(int dotrim=0);
 
diff --git a/src/XrdCms/XrdCmsClient.hh b/src/XrdCms/XrdCmsClient.hh
index 2c7c2090086..62d5f0a8cd0 100644
--- a/src/XrdCms/XrdCmsClient.hh
+++ b/src/XrdCms/XrdCmsClient.hh
@@ -329,6 +329,20 @@ virtual int    Release (int n=1) { (void)n; return 0;}
 virtual int    Space(XrdOucErrInfo &Resp, const char *path,
                      XrdOucEnv  *Info=0) = 0;
 
+//------------------------------------------------------------------------------
+//! Report utilization of this server. This may be used in lieu of general
+//! performance metric reporting. For consistent results use only one method.
+//!
+//! @param  util  A value from 0 to 100 representing utilization. Values
+//!               greater than 100 are set to be 100.
+//! @param  alert When true the utilization is forcibly report to the
+//!               cluster managers. Otherwise, reporting is done only when
+//!               it will significantly change server selection.
+//------------------------------------------------------------------------------
+
+virtual void   Utilization(unsigned int util, bool alert=false)
+                          {(void)util; (void)alert;}
+
 //------------------------------------------------------------------------------
 //! Constructor
 //!
@@ -336,8 +350,8 @@ virtual int    Space(XrdOucErrInfo &Resp, const char *path,
 //------------------------------------------------------------------------------
 
         enum   Persona {amLocal,  //!< Not affiliated with a cluster
-                        amRemote, //!< Am a manager an issue redirects
-                        amTarget  //!< Am a server  an field redirects
+                        amRemote, //!< Am a manager and issue redirects
+                        amTarget  //!< Am a server  and field redirects
                        };
 
                XrdCmsClient(Persona acting) : myPersona(acting) {}
diff --git a/src/XrdCms/XrdCmsClientConfig.cc b/src/XrdCms/XrdCmsClientConfig.cc
index 30e7d3c634d..3c804506976 100644
--- a/src/XrdCms/XrdCmsClientConfig.cc
+++ b/src/XrdCms/XrdCmsClientConfig.cc
@@ -38,6 +38,7 @@
 
 #include "XrdCms/XrdCmsClientConfig.hh"
 #include "XrdCms/XrdCmsClientMsg.hh"
+#include "XrdCms/XrdCmsPerfMon.hh"
 #include "XrdCms/XrdCmsSecurity.hh"
 #include "XrdCms/XrdCmsTrace.hh"
 #include "XrdCms/XrdCmsUtils.hh"
@@ -49,6 +50,15 @@
 #include "XrdOuc/XrdOucUtils.hh"
 #include "XrdSys/XrdSysHeaders.hh"
 
+/******************************************************************************/
+/*                               G l o b a l s                                */
+/******************************************************************************/
+  
+namespace XrdCms
+{
+extern XrdVersionInfo myVersion;
+}
+
 using namespace XrdCms;
 
 /******************************************************************************/
@@ -69,6 +79,11 @@ XrdCmsClientConfig::~XrdCmsClientConfig()
   while((tp = tpp)) {tpp = tp->next; delete tp;}
   tpp = PanList;
   while((tp = tpp)) {tpp = tp->next; delete tp;}
+
+  if (VNID_Lib)   free(VNID_Lib);
+  if (VNID_Parms) free(VNID_Parms);
+  if (prfLib)     free(prfLib);
+  if (prfParms)   free(prfParms);
 }
 
 /******************************************************************************/
@@ -96,8 +111,9 @@ int XrdCmsClientConfig::Configure(const char *cfn, configWhat What,
    if (!myHost) myHost = "localhost";
    myName = XrdOucUtils::InstName(1);
    CMSPath= strdup("/tmp/");
-   isMeta = How & configMeta;
-   isMan  = What& configMan;
+   isMeta = (How & configMeta) != 0;
+   isMan  = (What& configMan)  != 0;
+   isServer = What == configServer;
 
 // Process the configuration file
 //
@@ -177,6 +193,17 @@ int XrdCmsClientConfig::Configure(const char *cfn, configWhat What,
        NoGo = 1;
       }
 
+// Load the performance monitor (server pre-screened) if specified.
+//
+   if (prfLib && cmsMon)
+      {perfMon = XrdCmsUtils::loadPerfMon(&Say, prfLib, XrdCms::myVersion);
+       if (!perfMon || !perfMon->Configure(cfn, prfParms, *Say.logger(),
+                                           *cmsMon, 0, false))
+          {Say.Emsg("Config","Unable to configure performance monitor plugin.");
+           NoGo = 1;
+          }
+      }
+
    return NoGo;
 }
 
@@ -273,10 +300,11 @@ int XrdCmsClientConfig::ConfigXeq(char *var, XrdOucStream &Config)
 
    // Process items. for either a local or a remote configuration
    //
+   TS_Xeq("adminpath",     xapath);
    TS_Xeq("cidtag",        xcidt);
    TS_Xeq("conwait",       xconw);
    TS_Xeq("manager",       xmang);
-   TS_Xeq("adminpath",     xapath);
+   TS_Xeq("perf",          xperf);
    TS_Xeq("request",       xreqs);
    TS_Xeq("trace",         xtrac);
    TS_Xeq("vnid",          xvnid);
@@ -487,6 +515,64 @@ int XrdCmsClientConfig::xmang(XrdOucStream &Config)
    return (XrdCmsUtils::ParseMan(&Say, theList, hSpec, hPort, 0) ? 0 : 1);
 }
   
+
+/******************************************************************************/
+/*                                 x p e r f                                  */
+/******************************************************************************/
+
+/* Function: xperf
+
+   Purpose:  To parse the directive: perf [xrootd] [int <sec>]
+                                          [lib <lib> [<parms>] | pgm <pgm>]
+
+         int <time>    estimated time (seconds, M, H) between reports by <pgm>
+         lib <lib>     the shared library holding the XrdCmsPerf object that
+                       reports perf values. It must be the last option.
+         pgm <pgm>     program to start that will write perf values to standard
+                       out. It must be the last option. This is not supported
+                       when xrootd is specified.
+         xrootd        This directive only applies to the cms xrootd plugin.
+
+   Type: Server only, non-dynamic.
+
+   Output: 0 upon success or !0 upon failure. Ignored by manager.
+*/
+
+int XrdCmsClientConfig::xperf(XrdOucStream &Config)
+{   char *val;
+
+    if (!isServer) return Config.noEcho();
+
+    if (!(val = Config.GetWord()))
+       {Say.Emsg("Config", "perf options not specified"); return 1;}
+
+    if (strcmp("xrootd", val)) return Config.noEcho();
+    perfInt = 3*60;
+
+    do {     if (!strcmp("int", val))
+                {if (!(val = Config.GetWord()))
+                    {Say.Emsg("Config", "perf int value not specified");
+                     return 1;
+                    }
+                 if (XrdOuca2x::a2tm(Say,"perf int",val,&perfInt,0)) return 1;
+                }
+        else if (!strcmp("lib",  val))
+                {return (XrdOucUtils::parseLib(Say, Config, "perf lib",
+                                               prfLib, &prfParms) ? 0 : 1);
+                 break;
+                }
+        else if (!strcmp("pgm",  val))
+                {Say.Emsg("Config", "perf pgm is not supported for xrootd.");
+                 return 1;
+                }
+        else Say.Say("Config warning: ignoring invalid perf option '",val,"'.");
+       } while((val = Config.GetWord()));
+
+// All done.
+//
+    return 0;
+}
+
 /******************************************************************************/
 /*                                 x r e q s                                  */
 /******************************************************************************/
diff --git a/src/XrdCms/XrdCmsClientConfig.hh b/src/XrdCms/XrdCmsClientConfig.hh
index adc793f4be3..7874cb9029a 100644
--- a/src/XrdCms/XrdCmsClientConfig.hh
+++ b/src/XrdCms/XrdCmsClientConfig.hh
@@ -33,6 +33,7 @@
 #include "XrdOuc/XrdOucTList.hh"
 #include "XrdOuc/XrdOuca2x.hh"
   
+class XrdCmsPerfMon;
 class XrdOucStream;
 class XrdSysError;
 
@@ -65,27 +66,38 @@ const char   *myName;
 
 XrdOucTList  *ManList;      // List of managers for remote redirection
 XrdOucTList  *PanList;      // List of managers for proxy  redirection
+XrdCmsPerfMon *perfMon;     // Performance monitor plugin
+int           perfInt;      // Performance poll interval
 unsigned char SMode;        // Manager selection mode
 unsigned char SModeP;       // Manager selection mode (proxy)
 
 enum {FailOver = 'f', RoundRob = 'r'};
 
-      XrdCmsClientConfig() : ConWait(10), RepWait(3),  RepWaitMS(3000),
+      XrdCmsClientConfig(XrdCmsPerfMon *cmsmon=0)
+                           : ConWait(10), RepWait(3),  RepWaitMS(3000),
                              RepDelay(5), RepNone(8),  PrepWait(33),
                              FwdWait(0),  haveMeta(0), CMSPath(0),
                              myHost(0),   myName(0),   myVNID(0),
                              cidTag(0),   ManList(0),  PanList(0),
+                             perfMon(0),  perfInt(3*60),
                              SMode(FailOver), SModeP(FailOver),
                              VNID_Lib(0),  VNID_Parms(0),
-                             isMeta(0), isMan(0) {}
+                             prfLib(0), prfParms(0), cmsMon(cmsmon),
+                             isMeta(false), isMan(false), isServer(false) {}
      ~XrdCmsClientConfig();
 
 private:
+
 char *VNID_Lib;
 char *VNID_Parms;
+char *prfLib;
+char *prfParms;
+
+XrdCmsPerfMon *cmsMon;
 
-int isMeta;   // We are  a meta manager
-int isMan;    // We are  a      manager
+bool isMeta;   // We are  a meta manager
+bool isMan;    // We are  a      manager
+bool isServer; // We are  a      server
 
 int ConfigProc(const char *cfn);
 bool ConfigSID(const char *cFile, XrdOucTList *tpl, char sfx);
@@ -94,6 +106,7 @@ int xapath(XrdOucStream &Config);
 int xcidt(XrdOucStream  &Config);
 int xconw(XrdOucStream  &Config);
 int xmang(XrdOucStream  &Config);
+int xperf(XrdOucStream  &Config);
 int xreqs(XrdOucStream  &Config);
 int xtrac(XrdOucStream  &Config);
 int xvnid(XrdOucStream  &Config);
diff --git a/src/XrdCms/XrdCmsConfig.cc b/src/XrdCms/XrdCmsConfig.cc
index a7aed89e1cd..13983960bf7 100644
--- a/src/XrdCms/XrdCmsConfig.cc
+++ b/src/XrdCms/XrdCmsConfig.cc
@@ -183,6 +183,9 @@ static void Start() {static PingClock selfie;}
 /*                               d e f i n e s                                */
 /******************************************************************************/
 
+#define TS_Lib(x, y, z) if (!strcmp(x, var) \
+     && !XrdOucUtils::parseLib(*eDest, CFile, x, y, z)) return 1;
+
 #define TS_String(x,m) if (!strcmp(x,var)) {free(m); m = strdup(val); return 0;}
 
 #define TS_Xeq(x,m)    if (!strcmp(x,var)) return m(eDest, CFile);
@@ -507,10 +510,9 @@ int XrdCmsConfig::ConfigXeq(char *var, XrdOucStream &CFile, XrdSysError *eDest)
    TS_Xeq("fsxeq",         xfsxq);   // Server,  non-dynamic
    TS_Xeq("localroot",     xlclrt);  // Any,     non-dynamic
    TS_Xeq("manager",       xmang);   // Server,  non-dynamic
-   TS_Xeq("namelib",       xnml);    // Server,  non-dynamic
-   TS_Xeq("vnid",          xvnid);   // Server,  non-dynamic
+   TS_Lib("namelib", N2N_Lib, &N2N_Parms);
    TS_Xeq("nbsendq",       xnbsq);   // Any      non-dynamic
-   TS_Xeq("osslib",        xolib);   // Any,     non-dynamic
+   TS_Lib("osslib",  ossLib,  &ossParms);
    TS_Xeq("perf",          xperf);   // Server,  non-dynamic
    TS_Xeq("pidpath",       xpidf);   // Any,     non-dynamic
    TS_Xeq("prep",          xprep);   // Any,     non-dynamic
@@ -521,6 +523,7 @@ int XrdCmsConfig::ConfigXeq(char *var, XrdOucStream &CFile, XrdSysError *eDest)
    TS_Xeq("seclib",        xsecl);   // Server,  non-dynamic
    TS_Xeq("subcluster",    xsubc);   // Manager, non-dynamic
    TS_Xeq("superport",     xsupp);   // Super,   non-dynamic
+   TS_Xeq("vnid",          xvnid);   // Server,  non-dynamic
    TS_Set("wait",          doWait);  // Server,  non-dynamic (backward compat)
    TS_unSet("nowait",      doWait);  // Server,  non-dynamic
    TS_Xer("whitelist",     xblk,true);//Manager, non-dynamic
@@ -753,6 +756,8 @@ void XrdCmsConfig::ConfigDefaults(void)
    SecLib      = 0;
    ossLib      = 0;
    ossParms    = 0;
+   prfLib      = 0;
+   prfParms    = 0;
    ossFS       = 0;
    myVInfo     = &myVer;
    adsPort     = 0;
@@ -2095,76 +2100,6 @@ int XrdCmsConfig::xnbsq(XrdSysError *eDest, XrdOucStream &CFile)
         }
    return 0;
 }
-  
-/******************************************************************************/
-/*                                  x n m l                                   */
-/******************************************************************************/
-
-/* Function: xnml
-
-   Purpose:  To parse the directive: namelib <path> [<parms>]
-
-             <path>    the path of the filesystem library to be used.
-             <parms>   optional parms to be passed
-
-  Output: 0 upon success or !0 upon failure.
-*/
-
-int XrdCmsConfig::xnml(XrdSysError *eDest, XrdOucStream &CFile)
-{
-    char *val, parms[1024];
-
-// Get the path
-//
-   if (!(val = CFile.GetWord()) || !val[0])
-      {eDest->Emsg("Config", "namelib not specified"); return 1;}
-
-// Record the path
-//
-   if (N2N_Lib) free(N2N_Lib);
-   N2N_Lib = strdup(val);
-
-// Record any parms
-//
-   if (!CFile.GetRest(parms, sizeof(parms)))
-      {eDest->Emsg("Config", "namelib parameters too long"); return 1;}
-   if (N2N_Parms) free(N2N_Parms);
-   N2N_Parms = (*parms ? strdup(parms) : 0);
-   return 0;
-}
-  
-/******************************************************************************/
-/*                                 x o l i b                                  */
-/******************************************************************************/
-
-/* Function: xolib
-
-   Purpose:  To parse the directive: osslib <path>
-
-             <path>    the path of the filesystem library to be used.
-
-  Output: 0 upon success or !0 upon failure.
-*/
-
-int XrdCmsConfig::xolib(XrdSysError *eDest, XrdOucStream &CFile)
-{
-    char *val, parms[1024];
-
-// Get the path
-//
-   if (!(val = CFile.GetWord()) || !val[0])
-      {eDest->Emsg("Config", "osslib not specified"); return 1;}
-   if (ossLib) free(ossLib);
-   ossLib = strdup(val);
-
-// Record any parms
-//
-   if (!CFile.GetRest(parms, sizeof(parms)))
-      {eDest->Emsg("Config", "osslib parameters too long"); return 1;}
-   if (ossParms) free(ossParms);
-   ossParms = (*parms ? strdup(parms) : 0);
-   return 0;
-}
 
 /******************************************************************************/
 /*                                 x p e r f                                  */
@@ -2172,38 +2107,51 @@ int XrdCmsConfig::xolib(XrdSysError *eDest, XrdOucStream &CFile)
 
 /* Function: xperf
 
-   Purpose:  To parse the directive: perf [key <num>] [int <sec>] [pgm <pgm>]
+   Purpose:  To parse the directive: perf [xrootd] [int <sec>]
+                                          [lib <lib> [<parms>] | pgm <pgm>]
 
          int <time>    estimated time (seconds, M, H) between reports by <pgm>
-         key <num>     This is no longer documented but kept for compatability.
+         lib <lib>     the shared library holding the XrdCmsPerf object that
+                       reports perf values. It must be the last option.
          pgm <pgm>     program to start that will write perf values to standard
                        out. It must be the last option.
+         xrootd        This directive only applies to the cms xrootd plugin.
 
    Type: Server only, non-dynamic.
 
    Output: 0 upon success or !0 upon failure. Ignored by manager.
 */
 int XrdCmsConfig::xperf(XrdSysError *eDest, XrdOucStream &CFile)
-{   int   ival = 3*60;
-    char *pgm=0, *val, rest[2048];
+{   char *pgm=0, *val, rest[2048];
 
     if (!isServer) return CFile.noEcho();
 
     if (!(val = CFile.GetWord()))
        {eDest->Emsg("Config", "perf options not specified"); return 1;}
 
+    if (!strcmp("xrootd", val)) return CFile.noEcho();
+    perfint = 3*60;
+
     do {     if (!strcmp("int", val))
                 {if (!(val = CFile.GetWord()))
                     {eDest->Emsg("Config", "perf int value not specified");
                      return 1;
                     }
-                 if (XrdOuca2x::a2tm(*eDest,"perf int",val,&ival,0)) return 1;
+                 if (XrdOuca2x::a2tm(*eDest,"perf int",val,&perfint,0)) return 1;
+                }
+        else if (!strcmp("lib",  val))
+                {if (perfpgm) {free(perfpgm); perfpgm = 0;}
+                 return (XrdOucUtils::parseLib(*eDest,CFile,"perf lib",
+                                      prfLib, &prfParms) ? 0 : 1);
+                 break;
                 }
         else if (!strcmp("pgm",  val))
                 {if (!CFile.GetRest(rest, sizeof(rest)))
-                    {eDest->Emsg("Config", "perf pgm parameters too long"); return 1;}
+                    {eDest->Emsg("Config", "perf pgm parameters too long");
+                     return 1;
+                    }
                  if (!*rest)
-                    {eDest->Emsg("Config", "perf prog value not specified");
+                    {eDest->Emsg("Config", "perf pgm value not specified");
                      return 1;
                     }
                  pgm = rest;
@@ -2215,16 +2163,16 @@ int XrdCmsConfig::xperf(XrdSysError *eDest, XrdOucStream &CFile)
 // Make sure that the perf program is here
 //
    if (perfpgm) {free(perfpgm); perfpgm = 0;}
+   if (prfLib)  {free(prfLib);  prfLib = 0;}
+   if (prfParms){free(prfParms);prfParms = 0;}
    if (pgm) {if (!isExec(eDest, "perf", pgm)) return 1;
                 else perfpgm = strdup(pgm);
             }
 
-// Set remaining values
+// All done.
 //
-    perfint = ival;
     return 0;
 }
-
   
 /******************************************************************************/
 /*                                 x p i d f                                  */
@@ -2885,23 +2833,14 @@ bool XrdCmsConfig::xschedy(char *val, XrdSysError *eDest, char *&host,
 
 int XrdCmsConfig::xsecl(XrdSysError *eDest, XrdOucStream &CFile)
 {
-    char *val;
 
 // If we are a server, ignore this option
 //
    if (!isManager) return CFile.noEcho();
 
-// Get path
+// Return parse result
 //
-   val = CFile.GetWord();
-   if (!val || !val[0])
-      {eDest->Emsg("Config", "seclib path not specified"); return 1;}
-
-// Assign new path
-//
-   if (SecLib) free(SecLib);
-   SecLib = strdup(val);
-   return 0;
+   return (XrdOucUtils::parseLib(*eDest,CFile,"seclib",SecLib,0) ? 0 : 1);
 }
   
 /******************************************************************************/
diff --git a/src/XrdCms/XrdCmsConfig.hh b/src/XrdCms/XrdCmsConfig.hh
index 4555ffcb857..3cb48134776 100644
--- a/src/XrdCms/XrdCmsConfig.hh
+++ b/src/XrdCms/XrdCmsConfig.hh
@@ -142,8 +142,11 @@ XrdVersionInfo  *myVInfo; // xrootd version used in compilation
 XrdOucName2Name *xeq_N2N; // Server or Manager (non-null if library loaded)
 XrdOucName2Name *lcl_N2N; // Server Only
 
+char        *ConfigFN;
 char        *ossLib;      // -> oss library
 char        *ossParms;    // -> oss library parameters
+char        *prfLib;      // ->perf library
+char        *prfParms;    // ->perf library parameters
 char        *VNID_Lib;    // Server Only
 char        *VNID_Parms;  // Server Only
 char        *N2N_Lib;     // Server Only
@@ -225,8 +228,6 @@ int  xfxhld(XrdSysError *edest, XrdOucStream &CFile);
 int  xlclrt(XrdSysError *edest, XrdOucStream &CFile);
 int  xmang(XrdSysError *edest, XrdOucStream &CFile);
 int  xnbsq(XrdSysError *edest, XrdOucStream &CFile);
-int  xnml(XrdSysError *edest, XrdOucStream &CFile);
-int  xolib(XrdSysError *edest, XrdOucStream &CFile);
 int  xperf(XrdSysError *edest, XrdOucStream &CFile);
 int  xpidf(XrdSysError *edest, XrdOucStream &CFile);
 int  xping(XrdSysError *edest, XrdOucStream &CFile);
@@ -250,7 +251,6 @@ XrdInet          *NetTCPr;     // Network for supervisors
 char             *AdminPath;
 int               AdminMode;
 char             *pidPath;
-char             *ConfigFN;
 char            **inArgv;
 int               inArgc;
 char             *SecLib;
diff --git a/src/XrdCms/XrdCmsFinder.cc b/src/XrdCms/XrdCmsFinder.cc
index de6f7cb9a66..541388441ac 100644
--- a/src/XrdCms/XrdCmsFinder.cc
+++ b/src/XrdCms/XrdCmsFinder.cc
@@ -943,19 +943,27 @@ void XrdCmsFinderTRG::Added(const char *path, int Pend)
       {CMSp->Close(); Active = 0;}
    myData.UnLock();
 }
-
+  
 /******************************************************************************/
 /*                             C o n f i g u r e                              */
 /******************************************************************************/
 
-void *XrdCmsStartRsp(void *carg)
+namespace
+{
+void *StartPM(void *carg)
+      {XrdCmsFinderTRG *mp = (XrdCmsFinderTRG *)carg;
+       return mp->RunPM();
+      }
+
+void *StartRsp(void *carg)
       {XrdCmsFinderTRG *mp = (XrdCmsFinderTRG *)carg;
        return mp->Start();
       }
+}
   
 int XrdCmsFinderTRG::Configure(const char *cfn, char *Ags, XrdOucEnv *envP)
 {
-   XrdCmsClientConfig             config;
+   XrdCmsClientConfig             config(this);
    XrdCmsClientConfig::configWhat What;
 
 // Establish what we will be configuring
@@ -976,7 +984,18 @@ int XrdCmsFinderTRG::Configure(const char *cfn, char *Ags, XrdOucEnv *envP)
 // security function pointer or the network object pointer from the
 // environment as we don't need these at all.
 //
-   return RunAdmin(config.CMSPath, config.myVNID);
+   if (RunAdmin(config.CMSPath, config.myVNID)
+   &&  config.perfMon && config.perfInt)
+      {pthread_t tid;
+       perfMon = config.perfMon;
+       perfInt = config.perfInt;
+       if (XrdSysThread::Run(&tid, StartPM, (void *)this, 0, "perfmon"))
+//     if (XrdSysThread::Run(&tid, StartRsp, (void *)this, 0, "cms i/f"))
+          {Say.Emsg("Config", errno, "start performance monitor."); return 0;}
+      }
+// All done
+//
+   return 1;
 }
   
 /******************************************************************************/
@@ -1007,6 +1026,37 @@ int XrdCmsFinderTRG::Locate(XrdOucErrInfo &Resp, const char *path, int flags,
    return SFS_DATA;
 }
   
+
+/******************************************************************************/
+/*                               P u t I n f o                                */
+/******************************************************************************/
+  
+void XrdCmsFinderTRG::PutInfo(XrdCmsPerfMon::PerfInfo &perfInfo, bool alert)
+{
+   char  buff[256];
+   char *data[2] = {buff, 0};
+   int   dlen[2];
+   uint32_t cpu_load, mem_load, net_load, pag_load, xeq_load;
+
+   cpu_load = (perfInfo.cpu_load <= 100 ? perfInfo.cpu_load : 100);
+   mem_load = (perfInfo.mem_load <= 100 ? perfInfo.mem_load : 100);
+   net_load = (perfInfo.net_load <= 100 ? perfInfo.net_load : 100);
+   pag_load = (perfInfo.pag_load <= 100 ? perfInfo.pag_load : 100);
+   xeq_load = (perfInfo.xeq_load <= 100 ? perfInfo.xeq_load : 100);
+
+   dlen[0] = snprintf(buff, sizeof(buff), "%s %u %u %u %u %u\n",
+                      (alert ? "PERF" : "perf"),
+                      xeq_load, cpu_load, mem_load, pag_load, net_load);
+   dlen[1] = 0;
+
+// Now send the notification
+//
+   myData.Lock();
+   if (Active && CMSp->Put((const char **)data, (const int *)dlen))
+      {CMSp->Close(); Active = 0;}
+   myData.UnLock();
+}
+
 /******************************************************************************/
 /*                               R e l e a s e                                */
 /******************************************************************************/
@@ -1181,11 +1231,30 @@ int XrdCmsFinderTRG::RunAdmin(char *Path, const char *vnid)
 
 // Start a thread to connect with the local cmsd
 //
-   if (XrdSysThread::Run(&tid, XrdCmsStartRsp, (void *)this, 0, "cms i/f"))
+   if (XrdSysThread::Run(&tid, StartRsp, (void *)this, 0, "cms i/f"))
       {Say.Emsg("Config", errno, "start cmsd interface"); return 0;}
 
    return 1;
 }
+  
+/******************************************************************************/
+/*                                 R u n P M                                  */
+/******************************************************************************/
+
+void *XrdCmsFinderTRG::RunPM()
+{
+   XrdCmsPerfMon::PerfInfo perfInfo;
+
+// Keep asking the plugin for statistics.
+//
+   while(1)
+        {perfMon->GetInfo(perfInfo);
+         PutInfo(perfInfo);
+         perfInfo.Clear();
+         XrdSysTimer::Snooze(perfInt);
+        }
+   return (void *)0;
+}
 
 /******************************************************************************/
 /*                                 S t a r t                                  */
@@ -1235,6 +1304,28 @@ void *XrdCmsFinderTRG::Start()
    return (void *)0;
 }
   
+/******************************************************************************/
+/*                           U t i l i z a t i o n                            */
+/******************************************************************************/
+  
+void XrdCmsFinderTRG::Utilization(unsigned int util, bool alert)
+{
+   XrdCmsPerfMon::PerfInfo perfInfo;
+
+// Make sure value is in range
+//
+   if (util > 100) util = 100;
+  
+// Send this out as a performance figure
+//
+   perfInfo.cpu_load = util;
+   perfInfo.mem_load = util;
+   perfInfo.net_load = util;
+   perfInfo.pag_load = util;
+   perfInfo.xeq_load = util;
+   PutInfo(perfInfo, alert);
+}
+
 /******************************************************************************/
 /*                                V C h e c k                                 */
 /******************************************************************************/
diff --git a/src/XrdCms/XrdCmsFinder.hh b/src/XrdCms/XrdCmsFinder.hh
index 4716421210b..1fab17d6097 100644
--- a/src/XrdCms/XrdCmsFinder.hh
+++ b/src/XrdCms/XrdCmsFinder.hh
@@ -31,6 +31,7 @@
 /******************************************************************************/
 
 #include "XrdCms/XrdCmsClient.hh"
+#include "XrdCms/XrdCmsPerfMon.hh"
 
 #include "XrdSys/XrdSysPthread.hh"
 
@@ -118,7 +119,7 @@ unsigned char    savePath;
 class XrdOucStream;
 class XrdOucTList;
   
-class XrdCmsFinderTRG : public XrdCmsClient
+class XrdCmsFinderTRG : public XrdCmsClient, public XrdCmsPerfMon
 {
 public:
         void   Added(const char *path, int Pend=0);
@@ -133,6 +134,8 @@ public:
 
 XrdOucTList   *Managers() {return myManList;}
 
+        void   PutInfo(XrdCmsPerfMon::PerfInfo &perfInfo, bool alert=false);
+
         void   Removed(const char *path);
 
         void   Resume (int Perm=1);
@@ -144,11 +147,15 @@ XrdOucTList   *Managers() {return myManList;}
 
         int    RunAdmin(char *Path, const char *vnid);
 
+        void  *RunPM();
+
         int    Space(XrdOucErrInfo &Resp, const char *path, XrdOucEnv *envP=0)
                     {return 0;}
 
         void  *Start();
 
+        void   Utilization(unsigned int util, bool alert=false);
+
 static  bool   VCheck(XrdVersionInfo &urVersion);
 
                XrdCmsFinderTRG(XrdSysLogger *, int, int, XrdOss *theSS=0);
@@ -172,5 +179,7 @@ int            myPort;
 int            isRedir;
 int            isProxy;
 int            Active;
+XrdCmsPerfMon *perfMon;
+int            perfInt;
 };
 #endif
diff --git a/src/XrdCms/XrdCmsMeter.cc b/src/XrdCms/XrdCmsMeter.cc
index 5a122ba62fa..5ef6be22d14 100644
--- a/src/XrdCms/XrdCmsMeter.cc
+++ b/src/XrdCms/XrdCmsMeter.cc
@@ -33,7 +33,6 @@
 #include <signal.h>
 #include <stdio.h>
 #include <string.h>
-#include <time.h>
 #include <unistd.h>
 #include <sys/stat.h>
 #include <sys/types.h>
@@ -45,8 +44,10 @@
 #include "XrdCms/XrdCmsNode.hh"
 #include "XrdCms/XrdCmsState.hh"
 #include "XrdCms/XrdCmsTrace.hh"
+#include "XrdCms/XrdCmsUtils.hh"
 #include "XrdOss/XrdOss.hh"
 #include "XrdSys/XrdSysPlatform.hh"
+#include "XrdSys/XrdSysTimer.hh"
 
 using namespace XrdCms;
  
@@ -60,16 +61,24 @@ using namespace XrdCms;
 /*            E x t e r n a l   T h r e a d   I n t e r f a c e s             */
 /******************************************************************************/
 
-void *XrdCmsMeterRun(void *carg)
+namespace
+{
+void *MeterRun(void *carg)
       {XrdCmsMeter *mp = (XrdCmsMeter *)carg;
        return mp->Run();
       }
 
-void *XrdCmsMeterRunFS(void *carg)
+void *MeterRunFS(void *carg)
       {XrdCmsMeter *mp = (XrdCmsMeter *)carg;
        return mp->RunFS();
       }
 
+void *MeterRunPM(void *carg)
+      {XrdCmsMeter *mp = (XrdCmsMeter *)carg;
+       return mp->RunPM();
+      }
+}
+
 /******************************************************************************/
 /*                           C o n s t r u c t o r                            */
 /******************************************************************************/
@@ -89,6 +98,7 @@ XrdCmsMeter::XrdCmsMeter() : myMeter(&Say)
     lastFree = 0;
     lastUtil = 0;
     monpgm   = 0;
+    monPerf  = 0;
     monint   = 0;
     montid   = 0;
     rep_tod  = time(0);
@@ -97,6 +107,8 @@ XrdCmsMeter::XrdCmsMeter() : myMeter(&Say)
     mem_load = 0;
     pag_load = 0;
     net_load = 0;
+    myLoad   = 0;
+    prevLoad = -1;
     Virtual  = 0;
     VirtUpdt = 1;
 }
@@ -115,8 +127,15 @@ XrdCmsMeter::~XrdCmsMeter()
 /*                              c a l c L o a d                               */
 /******************************************************************************/
 
-int XrdCmsMeter::calcLoad(int pcpu, int pio, int pload, int pmem, int ppag)
+int XrdCmsMeter::calcLoad(uint32_t pcpu, uint32_t pio, uint32_t pload,
+                          uint32_t pmem, uint32_t ppag)
 {
+   if (pcpu  > 100) pcpu  = 100;
+   if (pio   > 100) pio   = 100;
+   if (pload > 100) pload = 100;
+   if (pmem  > 100) pmem  = 100;
+   if (ppag  > 100) ppag  = 100;
+
    return   (Config.P_cpu  * pcpu /100)
           + (Config.P_io   * pio  /100)
           + (Config.P_load * pload/100)
@@ -126,8 +145,9 @@ int XrdCmsMeter::calcLoad(int pcpu, int pio, int pload, int pmem, int ppag)
 
 /******************************************************************************/
 
-int XrdCmsMeter::calcLoad(int nowload, int pdsk)
+int XrdCmsMeter::calcLoad(int nowload, uint32_t pdsk)
 {
+   if (pdsk > 100) pdsk = 100;
    return   (Config.P_dsk  * pdsk /100) + nowload;
 }
 
@@ -213,8 +233,8 @@ void  XrdCmsMeter::Init()
    calcSpace();
    if ((noSpace = (dsk_maxf < MinFree)) && !Config.asSolo())
       CmsState.Update(XrdCmsState::Space, 0);
-   if ((rc = XrdSysThread::Run(&monFStid, XrdCmsMeterRunFS, (void *)this, 0,
-      "FS meter"))) Say.Emsg("Meter", rc, "start filesystem meter.");
+   if ((rc = XrdSysThread::Run(&monFStid,MeterRunFS,(void *)this,0,"FS meter")))
+      Say.Emsg("Meter", rc, "start filesystem meter.");
 
 // Document what we have
 //
@@ -257,12 +277,73 @@ int XrdCmsMeter::Monitor(char *pgm, int itv)
 // Monitor() is a one-time call (otherwise unpredictable results may occur).
 //
    *mp = pp; monint = itv;
-   if ((rc = XrdSysThread::Run(&montid, XrdCmsMeterRun, (void *)this, 0,
-      "Perf meter"))) Say.Emsg("Meter", rc, "start performance meter.");
+   if ((rc = XrdSysThread::Run(&montid,MeterRun,(void *)this,0,"Perf meter")))
+      Say.Emsg("Meter", rc, "start performance meter.");
+   Running = 1;
+   return 0;
+}
+
+/******************************************************************************/
+  
+int XrdCmsMeter::Monitor(int itv)
+{
+   XrdCmsPerfMon *monPerf;
+   int rc;
+
+// Load the plugin
+//
+   monPerf = XrdCmsUtils::loadPerfMon(&Say, Config.prfLib, *Config.myVInfo);
+
+// Configure it if loaded.
+//
+   if (!monPerf || !monPerf->Configure(Config.ConfigFN, Config.prfParms,
+                                       *(Say.logger()), *this, 0, true))
+      {Say.Emsg("Meter", "Unable to configure performance monitor plugin.");
+       return -1;
+      }
+
+// Start the monitor thread for this plugin unless strictly async
+// reporting is wanted (i.e. the interval is zero).
+//
+   if (monint)
+      {if ((rc = XrdSysThread::Run(&montid,MeterRunPM,(void *)this,0,"Perf monitor")))
+          {Say.Emsg("Meter", rc, "start performance meter.");
+           return -1;
+          }
+      }
+
+   montid = 0;
    Running = 1;
    return 0;
 }
 
+/******************************************************************************/
+/*                               P u t I n f o                                */
+/******************************************************************************/
+  
+void XrdCmsMeter::PutInfo(XrdCmsPerfMon::PerfInfo &perfInfo, bool alert)
+{
+
+   repMutex.Lock();
+   cpu_load = (perfInfo.cpu_load <= 100 ? perfInfo.cpu_load : 100);
+   mem_load = (perfInfo.mem_load <= 100 ? perfInfo.mem_load : 100);
+   net_load = (perfInfo.net_load <= 100 ? perfInfo.net_load : 100);
+   pag_load = (perfInfo.pag_load <= 100 ? perfInfo.pag_load : 100);
+   xeq_load = (perfInfo.xeq_load <= 100 ? perfInfo.xeq_load : 100);
+
+   myLoad = calcLoad(cpu_load,net_load,xeq_load,mem_load,pag_load);
+
+   if (prevLoad >= 0)
+      {prevLoad = prevLoad - myLoad;
+       if (prevLoad < 0) prevLoad = -prevLoad;
+       if (prevLoad > Config.P_fuzz) alert = true;
+      }
+   prevLoad = myLoad;
+   repMutex.UnLock();
+
+   if (alert) XrdCmsNode::Report_Usage(0);
+}
+
 /******************************************************************************/
 /*                                R e c o r d                                 */
 /******************************************************************************/
@@ -320,32 +401,17 @@ int XrdCmsMeter::Report(int &pcpu, int &pnet, int &pxeq,
   
 void *XrdCmsMeter::Run()
 {
-   const struct timespec rqtp = {30, 0};
-   int i, myLoad, prevLoad = -1;
+   static const int snoozeTime = 30;
    char *lp = 0;
 
 // Execute the program (keep restarting and keep reading the output)
 //
    while(1)
         {if (myMeter.Exec(monpgm) == 0)
-             while((lp = myMeter.GetLine()))
-                  {repMutex.Lock();
-                   i = sscanf(lp, "%d %d %d %d %d",
-                       &xeq_load, &cpu_load, &mem_load, &pag_load, &net_load);
-                   rep_tod = time(0);
-                   repMutex.UnLock();
-                   if (i != 5) break;
-                   myLoad = calcLoad(cpu_load,net_load,xeq_load,mem_load,pag_load);
-                   if (prevLoad >= 0)
-                      {prevLoad = prevLoad - myLoad;
-                       if (prevLoad < 0) prevLoad = -prevLoad;
-                       if (prevLoad > Config.P_fuzz) XrdCmsNode::Report_Usage(0);
-                      }
-                   prevLoad = myLoad;
-                  }
+             while((lp = myMeter.GetLine()) && Update(lp)) {}
          if (lp) Say.Emsg("Meter","Perf monitor returned invalid output:",lp);
             else Say.Emsg("Meter","Perf monitor died.");
-         nanosleep(&rqtp, 0);
+         XrdSysTimer::Snooze(snoozeTime);
          Say.Emsg("Meter", "Restarting monitor:", monpgm);
         }
    return (void *)0;
@@ -376,6 +442,25 @@ void *XrdCmsMeter::RunFS()
    return (void *)0;
 }
   
+/******************************************************************************/
+/*                                 R u n P M                                  */
+/******************************************************************************/
+  
+void *XrdCmsMeter::RunPM()
+{
+   XrdCmsPerfMon::PerfInfo perfInfo;
+
+// Keep asking the plugin for statistics.
+//
+   while(1)
+        {monPerf->GetInfo(perfInfo);
+         PutInfo(perfInfo);
+         perfInfo.Clear();
+         XrdSysTimer::Snooze(monint);
+        }
+   return (void *)0;
+}
+  
 /******************************************************************************/
 /*                            T o t a l S p a c e                             */
 /******************************************************************************/
@@ -410,6 +495,45 @@ unsigned int XrdCmsMeter::TotalSpace(unsigned int &minfree)
    return static_cast<unsigned int>(fstotal);
 }
   
+/******************************************************************************/
+/*                                U p d a t e                                 */
+/******************************************************************************/
+
+bool XrdCmsMeter::Update(char *line, bool alert)
+{
+   int n;
+
+// Parse the information
+//
+   repMutex.Lock();
+   n = sscanf(line, "%u %u %u %u %u",
+       &xeq_load, &cpu_load, &mem_load, &pag_load, &net_load);
+   rep_tod = time(0);
+
+// Make sure we have the correct number here
+//
+   if (n != 5)
+      {repMutex.UnLock();
+       return false;
+      }
+
+// Calculate load and check if there has been a significant change.
+//
+   myLoad = calcLoad(cpu_load,net_load,xeq_load,mem_load,pag_load);
+   if (prevLoad >= 0)
+      {prevLoad = prevLoad - myLoad;
+       if (prevLoad < 0) prevLoad = -prevLoad;
+       if (prevLoad > Config.P_fuzz) alert = true;
+      }
+   prevLoad = myLoad;
+   repMutex.UnLock();
+
+// Do an immediate performance update if needed
+//
+   if (alert) XrdCmsNode::Report_Usage(0);
+   return true;
+}
+  
 /******************************************************************************/
 /*                       P r i v a t e   M e t h o d s                        */
 /******************************************************************************/
diff --git a/src/XrdCms/XrdCmsMeter.hh b/src/XrdCms/XrdCmsMeter.hh
index d91dfd1e0cf..64889d92ca2 100644
--- a/src/XrdCms/XrdCmsMeter.hh
+++ b/src/XrdCms/XrdCmsMeter.hh
@@ -30,17 +30,19 @@
 /* specific prior written permission of the institution or contributor.       */
 /******************************************************************************/
 
+#include "XrdCms/XrdCmsPerfMon.hh"
 #include "XrdSys/XrdSysError.hh"
 #include "XrdSys/XrdSysPthread.hh"
 #include "XrdOuc/XrdOucStream.hh"
 
-class XrdCmsMeter
+class XrdCmsMeter : public XrdCmsPerfMon
 {
 public:
 
-int   calcLoad(int pcpu, int pio, int pload, int pmem, int ppag);
+int   calcLoad(uint32_t pcpu, uint32_t pio, uint32_t pload,
+               uint32_t pmem, uint32_t ppag);
 
-int   calcLoad(int xload,int pdsk);
+int   calcLoad(int xload, uint32_t pdsk);
 
 int   FreeSpace(int &tutil);
 
@@ -49,6 +51,9 @@ void  Init();
 int   isOn() {return Running;}
 
 int   Monitor(char *pgm, int itv);
+int   Monitor(int itv);
+
+void  PutInfo(XrdCmsPerfMon::PerfInfo &perfInfo, bool alert=false);
 
 void  Record(int pcpu, int pnet, int pxeq,
              int pmem, int ppag, int pdsk);
@@ -60,6 +65,8 @@ void *Run();
 
 void *RunFS();
 
+void *RunPM();
+
 int   numFS() {return fs_nums;}
 
 unsigned int TotalSpace(unsigned int &minfree);
@@ -70,6 +77,8 @@ void  setVirtual(vType vVal) {Virtual = vVal;}
 
 void  setVirtUpdt() {cfsMutex.Lock(); VirtUpdt = 1; cfsMutex.UnLock();}
 
+bool  Update(char *line, bool alert=false);
+
        XrdCmsMeter();
       ~XrdCmsMeter();
 
@@ -104,14 +113,17 @@ char          VirtUpdt; // Data changed for the virtul FS
 
 time_t        rep_tod;
 char         *monpgm;
+XrdCmsPerfMon *monPerf;
 int           monint;
 pthread_t     montid;
 
-unsigned int  xeq_load;
-unsigned int  cpu_load;
-unsigned int  mem_load;
-unsigned int  pag_load;
-unsigned int  net_load;
+uint32_t      xeq_load;
+uint32_t      cpu_load;
+uint32_t      mem_load;
+uint32_t      pag_load;
+uint32_t      net_load;
+int           myLoad;
+int           prevLoad;
 };
 
 namespace XrdCms
diff --git a/src/XrdCms/XrdCmsNode.cc b/src/XrdCms/XrdCmsNode.cc
index 23cefa73969..4f06700fc90 100644
--- a/src/XrdCms/XrdCmsNode.cc
+++ b/src/XrdCms/XrdCmsNode.cc
@@ -510,16 +510,17 @@ const char *XrdCmsNode::do_Have(XrdCmsRRData &Arg)
 const char *XrdCmsNode::do_Load(XrdCmsRRData &Arg)
 {
    EPNAME("do_Load")
-   int temp, pcpu, pnet, pxeq, pmem, ppag, pdsk;
+   uint32_t pcpu, pnet, pxeq, pmem, ppag, pdsk;
+   int temp;
 
 // Process: load <cpu> <io> <load> <mem> <pag> <util> <rsvd> <dskFree>
 //               0     1    2      3     4     5      6
-   pcpu = static_cast<int>(Arg.Opaque[CmsLoadRequest::cpuLoad]);
-   pnet = static_cast<int>(Arg.Opaque[CmsLoadRequest::netLoad]);
-   pxeq = static_cast<int>(Arg.Opaque[CmsLoadRequest::xeqLoad]);
-   pmem = static_cast<int>(Arg.Opaque[CmsLoadRequest::memLoad]);
-   ppag = static_cast<int>(Arg.Opaque[CmsLoadRequest::pagLoad]);
-   pdsk = static_cast<int>(Arg.Opaque[CmsLoadRequest::dskLoad]);
+   pcpu = static_cast<uint32_t>(Arg.Opaque[CmsLoadRequest::cpuLoad]);
+   pnet = static_cast<uint32_t>(Arg.Opaque[CmsLoadRequest::netLoad]);
+   pxeq = static_cast<uint32_t>(Arg.Opaque[CmsLoadRequest::xeqLoad]);
+   pmem = static_cast<uint32_t>(Arg.Opaque[CmsLoadRequest::memLoad]);
+   ppag = static_cast<uint32_t>(Arg.Opaque[CmsLoadRequest::pagLoad]);
+   pdsk = static_cast<uint32_t>(Arg.Opaque[CmsLoadRequest::dskLoad]);
 
 // Compute actual load value
 //
diff --git a/src/XrdCms/XrdCmsPerfMon.hh b/src/XrdCms/XrdCmsPerfMon.hh
new file mode 100644
index 00000000000..6eea04c5620
--- /dev/null
+++ b/src/XrdCms/XrdCmsPerfMon.hh
@@ -0,0 +1,156 @@
+#ifndef __CMS_PERFMON__
+#define __CMS_PERFMON__
+/******************************************************************************/
+/*                                                                            */
+/*                      X r d C m s P e r f M o n . h h                       */
+/*                                                                            */
+/* (c) 2019 by the Board of Trustees of the Leland Stanford, Jr., University  */
+/*                            All Rights Reserved                             */
+/*   Produced by Andrew Hanushevsky for Stanford University under contract    */
+/*              DE-AC02-76-SFO0515 with the Department of Energy              */
+/*                                                                            */
+/* This file is part of the XRootD software suite.                            */
+/*                                                                            */
+/* XRootD is free software: you can redistribute it and/or modify it under    */
+/* the terms of the GNU Lesser General Public License as published by the     */
+/* Free Software Foundation, either version 3 of the License, or (at your     */
+/* option) any later version.                                                 */
+/*                                                                            */
+/* XRootD is distributed in the hope that it will be useful, but WITHOUT      */
+/* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or      */
+/* FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public       */
+/* License for more details.                                                  */
+/*                                                                            */
+/* You should have received a copy of the GNU Lesser General Public License   */
+/* along with XRootD in a file called COPYING.LESSER (LGPL license) and file  */
+/* COPYING (GPL license).  If not, see <http://www.gnu.org/licenses/>.        */
+/*                                                                            */
+/* The copyright holder's institutional names and contributor's names may not */
+/* be used to endorse or promote products derived from this software without  */
+/* specific prior written permission of the institution or contributor.       */
+/******************************************************************************/
+
+class  XrdOucEnv;
+class  XrdSysLogger;
+
+/******************************************************************************/
+/*                   c l a s s   X r d C m s P e r f M o n                    */
+/******************************************************************************/
+
+/* The XrdCmsPerfMon is used to report performance metrics. It is obtained
+   from the shared library loaded at run time and identified by the cms.perf
+   directive. The library should contain an implementation of this class.
+*/
+  
+class XrdCmsPerfMon
+{
+public:
+
+//------------------------------------------------------------------------------
+//! Configure the PerfMon plugin object. This is called after the plugin
+//! is loaded via the shared library.
+//!
+//! @param  cfn     The configuration file name.
+//! @param  Parms   Any parameters specified in the perf directive. If none,
+//!                 the pointer may be null.
+//! @param  Logger  The logging object.
+//! @param  cmsMon  The object to be used for async reporting.
+//! @param  EnvInfo Environmental information of the caller, may be nil.
+//! @param  isCMS   True if loaded by the cmsd and false if loaded by xrootd.
+//!
+//! @return True  upon success.
+//!         False upon failure.
+//------------------------------------------------------------------------------
+
+virtual bool   Configure(const char    *cfn,
+                               char    *Parms,
+                         XrdSysLogger  &Logger,
+                         XrdCmsPerfMon &cmsMon,
+                         XrdOucEnv     *EnvInfo,
+                         bool           isCMS)
+                        {(void)cfn; (void)Parms; (void)Logger; (void)cmsMon;
+                         (void)EnvInfo; (void)isCMS;
+                         return false;
+                        }
+
+//------------------------------------------------------------------------------
+//! Structure used for reporting performance metrics.
+//------------------------------------------------------------------------------
+
+struct PerfInfo
+      {unsigned char cpu_load; //!< CPU       0 to 100 utilization
+       unsigned char mem_load; //!< Memory    0 to 100 utilization
+       unsigned char net_load; //!< Network   0 to 100 utilization
+       unsigned char pag_load; //!< Paging    0 to 100 utilization
+       unsigned char xeq_load; //!< Other     0 to 100 utilization (arbitrary)
+       unsigned char xxx_load; //!< Reserved
+       unsigned char yyy_load; //!< Reserved
+       unsigned char zzz_load; //!< Reserved
+
+       void Clear() {cpu_load = mem_load = net_load = pag_load = xeq_load = 0;
+                     xxx_load = yyy_load = zzz_load = 0;
+                    }
+
+       PerfInfo() {Clear();}
+      ~PerfInfo() {}
+      };
+
+//------------------------------------------------------------------------------
+//! Obtain performance statistics as load values from 0 to 100. The system
+//! calls this method at periodic intervals.
+//!
+//! @param  info  Reference to the structure that should be filled out with
+//!               load values, as desired. See the PerfInfo structure.
+//------------------------------------------------------------------------------
+
+virtual void   GetInfo(PerfInfo &info) {(void)info;}
+
+//------------------------------------------------------------------------------
+//! Report performance statistics as load values from 0 to 100. The performance
+//! monitor plugin may call this method to asynchronously report performance
+//! via the passed XrdCmsPerfMon object during configuration.
+//!
+//! @param  info  Reference to the structure that should be filled out with
+//!               load values. See the PerfInfo structure.
+//! @param  alert When true, load information is forcibly sent to the cluster's
+//!               manager. Otherwise, it is only sent if it significantly
+//!               changes. See the cms.sched directive fuzz parameter.
+//------------------------------------------------------------------------------
+
+virtual void   PutInfo(PerfInfo &info, bool alert=false)
+                      {(void)info; (void)alert;}
+
+//------------------------------------------------------------------------------
+//! Constructor & Destructor
+//------------------------------------------------------------------------------
+
+               XrdCmsPerfMon() {}
+
+virtual       ~XrdCmsPerfMon() {}
+};
+
+/******************************************************************************/
+/*       L i b r a r y   X r d C m s P e r f M o n   D e f i n i i o n        */
+/******************************************************************************/
+
+//------------------------------------------------------------------------------
+//! Your implementation should inherit XrdCmsPerfMon and override the
+//! Configure() and GetInfo() methods. Your PutInfo() method will never be
+//! called. Then you should set the upcasted address of your implementation at
+//! file level as follows (note that use of new here is merely as example):
+//!
+//! XrdCmsPerfMon *XrdCmsPerfMonitor = new myPerfMon();
+//------------------------------------------------------------------------------
+
+//------------------------------------------------------------------------------
+//! Declare compilation version.
+//!
+//! Additionally, you *should* declare the xrootd version you used to compile
+//! your plug-in.
+//------------------------------------------------------------------------------
+
+/*! #include "XrdVersion.hh"
+    XrdVERSIONINFO(XrdCmsPerfMonitor,<name>);
+
+*/
+#endif
diff --git a/src/XrdCms/XrdCmsUtils.cc b/src/XrdCms/XrdCmsUtils.cc
index 99453994a42..cf12098f2e4 100644
--- a/src/XrdCms/XrdCmsUtils.cc
+++ b/src/XrdCms/XrdCmsUtils.cc
@@ -36,6 +36,7 @@
 #include "XrdNet/XrdNetAddr.hh"
 #include "XrdNet/XrdNetUtils.hh"
 #include "XrdOuc/XrdOuca2x.hh"
+#include "XrdOuc/XrdOucPinLoader.hh"
 #include "XrdOuc/XrdOucStream.hh"
 #include "XrdOuc/XrdOucTList.hh"
 #include "XrdSys/XrdSysError.hh"
@@ -100,6 +101,21 @@ void XrdCmsUtils::Display(XrdSysError *eDest, const char *hSpec,
    delete [] nP;
 }
 
+/******************************************************************************/
+/*                           l o a d P e r f M o n                            */
+/******************************************************************************/
+
+XrdCmsPerfMon *XrdCmsUtils::loadPerfMon(XrdSysError    *eDest,
+                                        const char     *libPath,
+                                        XrdVersionInfo &urVer)
+{
+   XrdOucPinLoader perfLib(eDest, &urVer, "cms.perf", libPath);
+
+   XrdCmsPerfMon **perfMon = (XrdCmsPerfMon**)perfLib.Resolve("XrdCmsPerfMonitor");
+
+   return (perfMon ? *perfMon : 0);
+}
+  
 /******************************************************************************/
 /*                              P a r s e M a n                               */
 /******************************************************************************/
diff --git a/src/XrdCms/XrdCmsUtils.hh b/src/XrdCms/XrdCmsUtils.hh
index 148812473ee..e21e6b283c0 100644
--- a/src/XrdCms/XrdCmsUtils.hh
+++ b/src/XrdCms/XrdCmsUtils.hh
@@ -30,14 +30,30 @@
 /* specific prior written permission of the institution or contributor.       */
 /******************************************************************************/
 
+class XrdCmsPerfMon;
 class XrdOucStream;
 class XrdOucTList;
 class XrdSysError;
 
+struct XrdVersionInfo;
+
 class XrdCmsUtils
 {
 public:
 
+//------------------------------------------------------------------------------
+//! Load the performance monitor plugin.
+//
+//! @param  eDest    Pointer to the error message object to route messages.
+//! @param  libPath  A pointer to the shared library path.
+//! @param  urVer    Reference to the caller's version number.
+//!
+//! @return Pointer to the performance monitor object or nil upon failure.
+//------------------------------------------------------------------------------
+static
+XrdCmsPerfMon *loadPerfMon(XrdSysError *eDest, const char *libPath,
+                           XrdVersionInfo &urVer);
+
 //------------------------------------------------------------------------------
 //! Obtain and merge a new manager list with an existing list.
 //!
diff --git a/src/XrdHeaders.cmake b/src/XrdHeaders.cmake
index f8067a9144a..852cf68bee1 100644
--- a/src/XrdHeaders.cmake
+++ b/src/XrdHeaders.cmake
@@ -87,6 +87,7 @@ if( NOT XRDCL_ONLY )
     XrdCks/XrdCksData.hh
     XrdCks/XrdCksManager.hh
     XrdCms/XrdCmsClient.hh
+    XrdCms/XrdCmsPerfMon.hh
     XrdCms/XrdCmsVnId.hh
     XrdFileCache/XrdFileCacheDecision.hh
     XrdOfs/XrdOfsPrepare.hh
diff --git a/src/XrdOuc/XrdOucUtils.cc b/src/XrdOuc/XrdOucUtils.cc
index 10a501e14ed..f1dce5a7637 100644
--- a/src/XrdOuc/XrdOucUtils.cc
+++ b/src/XrdOuc/XrdOucUtils.cc
@@ -676,6 +676,39 @@ int XrdOucUtils::makePath(char *path, mode_t mode)
    return 0;
 }
  
+/******************************************************************************/
+/*                              p a r s e L i b                               */
+/******************************************************************************/
+  
+bool XrdOucUtils::parseLib(XrdSysError &eDest, XrdOucStream &Config,
+                           const char *libName, char *&libPath, char **libParm)
+{
+    char *val, parms[2048];
+
+// Get the path
+//
+   if (!(val = Config.GetWord()) || !val[0])
+      {eDest.Emsg("Config", libName, "not specified"); return false;}
+
+// Record the path
+//
+   if (libPath) free(libPath);
+   libPath = strdup(val);
+
+// Handle optional parameter
+//
+   if (!libParm) return true;
+   if (*libParm) free(*libParm);
+   *libParm = 0;
+
+// Record any parms
+//
+   if (!Config.GetRest(parms, sizeof(parms)))
+      {eDest.Emsg("Config", libName, "parameters too long"); return false;}
+   if (*parms) *libParm = strdup(parms);
+   return true;
+}
+
 /******************************************************************************/
 /*                             p a r s e H o m e                              */
 /******************************************************************************/
diff --git a/src/XrdOuc/XrdOucUtils.hh b/src/XrdOuc/XrdOucUtils.hh
index 49434e3f65a..aa47b189e8e 100644
--- a/src/XrdOuc/XrdOucUtils.hh
+++ b/src/XrdOuc/XrdOucUtils.hh
@@ -84,6 +84,9 @@ static bool  makeHome(XrdSysError &eDest, const char *inst,
 
 static int   makePath(char *path, mode_t mode);
 
+static bool  parseLib(XrdSysError &eDest, XrdOucStream &Config,
+                      const char *libName, char *&path, char **libparm);
+
 static char *parseHome(XrdSysError &eDest, XrdOucStream &Config, int &mode);
 
 static int   ReLink(const char *path, const char *target, mode_t mode=0);
diff --git a/src/XrdServer.cmake b/src/XrdServer.cmake
index 0043b1a4500..ed765fad5b5 100644
--- a/src/XrdServer.cmake
+++ b/src/XrdServer.cmake
@@ -141,18 +141,19 @@ add_library(
   # XrdCms - client for clustering
   #-----------------------------------------------------------------------------
   XrdCms/XrdCmsBlackList.cc       XrdCms/XrdCmsBlackList.hh
-  XrdCms/XrdCmsLogin.cc           XrdCms/XrdCmsLogin.hh
-  XrdCms/XrdCmsParser.cc          XrdCms/XrdCmsParser.hh
-  XrdCms/XrdCmsRRData.cc          XrdCms/XrdCmsRRData.hh
-  XrdCms/XrdCmsSecurity.cc        XrdCms/XrdCmsSecurity.hh
-  XrdCms/XrdCmsTalk.cc            XrdCms/XrdCmsTalk.hh
   XrdCms/XrdCmsClientConfig.cc    XrdCms/XrdCmsClientConfig.hh
   XrdCms/XrdCmsClientMan.cc       XrdCms/XrdCmsClientMan.hh
   XrdCms/XrdCmsClientMsg.cc       XrdCms/XrdCmsClientMsg.hh
-  XrdCms/XrdCmsFinder.cc          XrdCms/XrdCmsFinder.hh
   XrdCms/XrdCmsClient.cc          XrdCms/XrdCmsClient.hh
+  XrdCms/XrdCmsFinder.cc          XrdCms/XrdCmsFinder.hh
+  XrdCms/XrdCmsLogin.cc           XrdCms/XrdCmsLogin.hh
+  XrdCms/XrdCmsParser.cc          XrdCms/XrdCmsParser.hh
+                                  XrdCms/XrdCmsPerfMon.hh
   XrdCms/XrdCmsResp.cc            XrdCms/XrdCmsResp.hh
+  XrdCms/XrdCmsRRData.cc          XrdCms/XrdCmsRRData.hh
   XrdCms/XrdCmsRTable.cc          XrdCms/XrdCmsRTable.hh
+  XrdCms/XrdCmsSecurity.cc        XrdCms/XrdCmsSecurity.hh
+  XrdCms/XrdCmsTalk.cc            XrdCms/XrdCmsTalk.hh
                                   XrdCms/XrdCmsTypes.hh
   XrdCms/XrdCmsUtils.cc           XrdCms/XrdCmsUtils.hh
                                   XrdCms/XrdCmsVnId.hh
diff --git a/src/XrdSsi/XrdSsiClient.cc b/src/XrdSsi/XrdSsiClient.cc
index ae9233d944c..046261b0975 100644
--- a/src/XrdSsi/XrdSsiClient.cc
+++ b/src/XrdSsi/XrdSsiClient.cc
@@ -64,6 +64,7 @@ namespace XrdSsi
 {
 extern XrdSysError          Log;
 extern XrdSysLogger        *Logger;
+extern XrdSsiScale          sidScale;
 extern XrdSysTrace          Trace;
 extern XrdSsiLogger::MCB_t *msgCB;
 extern XrdSsiLogger::MCB_t *msgCBCl;
@@ -265,8 +266,6 @@ void XrdSsiClientProvider::SetScheduler()
 
 void XrdSsiClientProvider::SetSpread(short ssz)
 {
-    extern XrdSsiScale sidScale;
-
     sidScale.setSpread(ssz);
 }
 
diff --git a/src/XrdSsi/XrdSsiCluster.hh b/src/XrdSsi/XrdSsiCluster.hh
index 8cdccee979c..f6e980afe80 100644
--- a/src/XrdSsi/XrdSsiCluster.hh
+++ b/src/XrdSsi/XrdSsiCluster.hh
@@ -134,6 +134,19 @@ virtual int    Reserve (int n=1) = 0;
 
 virtual int    Release (int n=1) = 0;
 
+//------------------------------------------------------------------------------
+//! Report utilization of this server. This may be used in lieu of general
+//! performance metric reporting. For consistent results use only one method.
+//!
+//! @param  util  A value from 0 to 100 representing utilization. Values
+//!               greater than 100 are set to be 100.
+//! @param  alert When true the utilization is forcibly report to the
+//!               cluster managers. Otherwise, reporting is done only when
+//!               it will significantly change server selection.
+//------------------------------------------------------------------------------
+
+virtual void   Utilization(unsigned int util, bool alert=false) = 0;
+
 //------------------------------------------------------------------------------
 //! Destructor
 //------------------------------------------------------------------------------
diff --git a/src/XrdSsi/XrdSsiCms.hh b/src/XrdSsi/XrdSsiCms.hh
index 956cd7fbee6..cc0727e0905 100644
--- a/src/XrdSsi/XrdSsiCms.hh
+++ b/src/XrdSsi/XrdSsiCms.hh
@@ -68,6 +68,9 @@ const      *   Managers(int &mNum) {mNum = manNum; return manList;}
                      return 0;
                     }
 
+        void   Utilization(unsigned int util, bool alert=false)
+                    {if (theCms) return theCms->Utilization(util, alert);}
+
                XrdSsiCms() : theCms(0), manList(0), manNum(0) {}
 
                XrdSsiCms(XrdCmsClient *cmsP);