STABLE12-viced-provide-way-to-not-retraverse-hostlist-20020821

avoid retraversing the host list and gewtting stucvk in a loop

(cherry picked from commit 0ca7613ac4ce16f54931f3702e186a1097c25d87)

diff --git a/src/viced/callback.c b/src/viced/callback.c
index 2e9b029414db811a73c14ccce6273db91c79f65d..a10b2cdd306c0fdeb810aa0111a54a105399459b 100644 (file)
--- a/src/viced/callback.c
+++ b/src/viced/callback.c
@@ -1391,16 +1391,16 @@ static int lih_r(host, held, hostp)
 
 } /*lih*/
 
-
 /* This could be upgraded to get more space each time */
 /* first pass: find the oldest host which isn't held by anyone */
 /* second pass: find the oldest host who isn't "me" */
 /* always called with hostp unlocked */
+extern struct host *hostList;
 static int GetSomeSpace_r(hostp, locked)
     struct host *hostp;
     int locked;
 {
-    register struct host *hp, *hp1 = (struct host *)0;
+    register struct host *hp, *hp1 = (struct host *)0, *hp2 = hostList;
     int i=0;
 
     cbstuff.GotSomeSpaces++;
@@ -1411,14 +1411,15 @@ static int GetSomeSpace_r(hostp, locked)
     }
     do {
        lih_host = 0;
-       h_Enumerate_r(lih_r, (char *)hp1);
+       h_Enumerate_r(lih_r, hp2, (char *)hp1);
        hp = lih_host;
        if (hp) {
            cbstuff.GSS4++;
            if ( ! ClearHostCallbacks_r(hp, 0 /* not locked or held */) )
                return;
-           hp1 = hp;
+           hp2 = hp->next;
        } else {
+           hp2 = hostList;
            hp1 = hostp;
            cbstuff.GSS1++;
            ViceLog(5,("GSS: Try harder for longest inactive host cnt= %d\n", i));

diff --git a/src/viced/host.c b/src/viced/host.c
index 2748f2bbde53857f9a76e64f9dc7fd16863ad404..14c9e6d3915c6fe3fdf1aecf26494b4bfff45a04 100644 (file)
--- a/src/viced/host.c
+++ b/src/viced/host.c
@@ -914,16 +914,19 @@ h_Enumerate(proc, param)
     free((void *)held);
 } /*h_Enumerate*/
 
-/* h_Enumerate_r: Calls (*proc)(host, held, param) for at least each host in
- * the at the start of the enumeration (perhaps more).  Hosts may be deleted
- * (have delete flag set); ditto for clients.  (*proc) is always called with
+/* h_Enumerate_r (revised):
+ * Calls (*proc)(host, held, param) for each host in hostList, starting
+ * at enumstart
+ * Hosts may be deleted (have delete flag set); ditto for clients.
+ * (*proc) is always called with
  * host h_held() and the global host lock (H_LOCK) locked.The hold state of the
  * host with respect to this lwp is passed to (*proc) as the param held.
  * The proc should return 0 if the host should be released, 1 if it should
  * be held after enumeration.
  */
-h_Enumerate_r(proc, param)
+h_Enumerate_r(proc, enumstart, param)
     int (*proc)();
+    struct host* enumstart;
     char *param;
 
 {
@@ -933,15 +936,14 @@ h_Enumerate_r(proc, param)
     if (hostCount == 0) {
        return;
     }
-    for (host = hostList ; host ; host = host->next) {
+    for (host = enumstart ; host ; host = host->next) {
        if (!(held = h_Held_r(host)))
            h_Hold_r(host);
        held = (*proc)(host, held, param);
        if (!held)
            h_Release_r(host);/* this might free up the host */
     }
-} /*h_Enumerate*/
-
+} /*h_Enumerate_r*/
 
 /* Host is returned held */
 struct host *h_GetHost_r(tcon)