accounting: bwlimit signal handler should always start

The SIGUSR2 signal handler for bandwidth limits currently only starts
if rclone is started at a time when a bandwidth limit applies. This
means that if rclone starts _outside_ such a time, i.e. with no
bandwidth limits, then enters a time where bandwidth limits do apply,
it will not be possible to use SIGUSR2 to toggle it.

This fixes that by always starting the signal handler, but only
toggling the limiter if there is a bandwidth limit configured.

fs/accounting/accounting_unix.go

@@ -23,15 +23,26 @@ func (tb *tokenBucket) startSignalHandler() {
 		// This runs forever, but blocks until the signal is received.
 		for {
 			<-signals
+
+			func() {
 				tb.mu.Lock()
+				defer tb.mu.Unlock()
+
+				// if there's no bandwidth limit configured now, do nothing
+				if !tb.currLimit.Bandwidth.IsSet() {
+					fs.Debugf(nil, "SIGUSR2 received but no bandwidth limit configured right now, ignoring")
+					return
+				}
+
 				tb.toggledOff = !tb.toggledOff
 				tb.curr, tb.prev = tb.prev, tb.curr
 				s := "disabled"
 				if !tb.curr._isOff() {
 					s = "enabled"
 				}
-			tb.mu.Unlock()
+
 				fs.Logf(nil, "Bandwidth limit %s by user", s)
+			}()
 		}
 	}()
 }

fs/accounting/token_bucket.go

@@ -34,7 +34,6 @@ type tokenBucket struct {
 	curr       buckets
 	prev       buckets
 	toggledOff bool
-	currLimitMu sync.Mutex // protects changes to the timeslot
 	currLimit  fs.BwTimeSlot
 }
 
@@ -106,11 +105,11 @@ func (tb *tokenBucket) StartTokenBucket(ctx context.Context) {
 	if tb.currLimit.Bandwidth.IsSet() {
 		tb.curr = newTokenBucket(tb.currLimit.Bandwidth)
 		fs.Infof(nil, "Starting bandwidth limiter at %v Byte/s", &tb.currLimit.Bandwidth)
+	}
 
 	// Start the SIGUSR2 signal handler to toggle bandwidth.
 	// This function does nothing in windows systems.
 	tb.startSignalHandler()
-	}
 }
 
 // StartTokenTicker creates a ticker to update the bandwidth limiter every minute.
@@ -126,11 +125,9 @@ func (tb *tokenBucket) StartTokenTicker(ctx context.Context) {
 	go func() {
 		for range ticker.C {
 			limitNow := ci.BwLimit.LimitAt(time.Now())
-			tb.currLimitMu.Lock()
-
-			if tb.currLimit.Bandwidth != limitNow.Bandwidth {
 			tb.mu.Lock()
 
+			if tb.currLimit.Bandwidth != limitNow.Bandwidth {
 				// If bwlimit is toggled off, the change should only
 				// become active on the next toggle, which causes
 				// an exchange of tb.curr <-> tb.prev
@@ -156,9 +153,9 @@ func (tb *tokenBucket) StartTokenTicker(ctx context.Context) {
 				}
 
 				tb.currLimit = limitNow
-				tb.mu.Unlock()
 			}
-			tb.currLimitMu.Unlock()
+
+			tb.mu.Unlock()
 		}
 	}()
 }