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

based on thomas muellers patch

diff --git a/src/viced/callback.c b/src/viced/callback.c
index ed4a9a5cbb3090237d83a4dab4a53c4cf5e3a0d8..de8d283c7cc3861a172d6f9d93682e380dc3bf83 100644 (file)
--- a/src/viced/callback.c
+++ b/src/viced/callback.c
@@ -1413,11 +1413,12 @@ static int lih_r(host, held, hostp)
 /* 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 = NULL;
+    register struct host *hp, *hp1 = (struct host *)0, *hp2 = hostList;
     int i=0;
 
     cbstuff.GotSomeSpaces++;
@@ -1428,14 +1429,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 1a67d8cc65c25ff9c3c16775671357871444ed62..15417dacfd15c5403aa4fd263ef4c867437184b2 100644 (file)
--- a/src/viced/host.c
+++ b/src/viced/host.c
@@ -917,16 +917,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;
 
 {
@@ -936,15 +939,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)