@@ -177,28 +177,24 @@ func (g *fsprungroup) doDD(action string, flags uint64, mpath string, dontResilv
 
 func (g *fsprungroup) preempt(action string, mi *fs.Mountpath) bool /*prev*/ {
 	const (
-		preemptSleep = cos.PollSleepShort
-	)
-	var (
-		res  = g.t.res
-		xres = res.GetXact()
+		sleep = cos.PollSleepShort
 	)
+	res := g.t.res
+	// try to abort an active resilver, if any
+	if res.Abort(fmt.Errorf("%v: %q, %s", cmn.ErrXactRenewAbort, action, mi)) {
+		return true
+	}
+	xres := res.GetXact()
 	if xres == nil { // finished ok or never ran
 		return false
 	}
-	if xres.IsAborted() {
-		return true
-	}
 	if xres.IsDone() {
-		time.Sleep(preemptSleep) // just finished; Res atomic state
+		time.Sleep(sleep) // just finished; Res atomic state
 		return false
 	}
 
-	err := fmt.Errorf("%s: %q %s: starting new resilver", g.t, action, mi)
-	if res.Abort(err) {
-		return true
-	}
-	time.Sleep(preemptSleep)
+	// (unlikely)
+	time.Sleep(sleep)
 	debug.Assert(xres.IsAborted() || xres.IsDone(), xres.String())
 	return true
 }
 
@@ -174,7 +174,7 @@ func (r *XactBckEncode) Run(gowg *sync.WaitGroup) {
 		}
 	}
 
-	jg := mpather.NewJoggerGroup(opts, r.config, nil)
+	jg := mpather.NewJgroup(opts, r.config, nil)
 	jg.Run()
 
 	select {
 
@@ -77,7 +77,7 @@ type (
 	}
 )
 
-func NewJoggerGroup(opts *JgroupOpts, config *cmn.Config, smi *fs.Mountpath) *Jgroup {
+func NewJgroup(opts *JgroupOpts, config *cmn.Config, smi *fs.Mountpath) *Jgroup {
 	var (
 		joggers map[string]*jogger
 		avail   = fs.GetAvail()
 
@@ -44,7 +44,7 @@ func TestJoggerGroup(t *testing.T) {
 			return nil
 		},
 	}
-	jg := mpather.NewJoggerGroup(opts, cmn.GCO.Get(), nil)
+	jg := mpather.NewJgroup(opts, cmn.GCO.Get(), nil)
 	jg.Run()
 	<-jg.ListenFinished()
 
@@ -83,7 +83,7 @@ func TestJoggerGroupLoad(t *testing.T) {
 		},
 		DoLoad: mpather.Load,
 	}
-	jg := mpather.NewJoggerGroup(opts, cmn.GCO.Get(), nil)
+	jg := mpather.NewJgroup(opts, cmn.GCO.Get(), nil)
 
 	jg.Run()
 	<-jg.ListenFinished()
@@ -119,7 +119,7 @@ func TestJoggerGroupError(t *testing.T) {
 			return errors.New("oops")
 		},
 	}
-	jg := mpather.NewJoggerGroup(opts, cmn.GCO.Get(), nil)
+	jg := mpather.NewJgroup(opts, cmn.GCO.Get(), nil)
 	jg.Run()
 	<-jg.ListenFinished()
 
@@ -172,7 +172,7 @@ func TestJoggerGroupOneErrorStopsAll(t *testing.T) {
 			return nil
 		},
 	}
-	jg := mpather.NewJoggerGroup(opts, cmn.GCO.Get(), nil)
+	jg := mpather.NewJgroup(opts, cmn.GCO.Get(), nil)
 	jg.Run()
 	<-jg.ListenFinished()
 
@@ -227,7 +227,7 @@ func TestJoggerGroupMultiContentTypes(t *testing.T) {
 			return nil
 		},
 	}
-	jg := mpather.NewJoggerGroup(opts, cmn.GCO.Get(), nil)
+	jg := mpather.NewJgroup(opts, cmn.GCO.Get(), nil)
 	jg.Run()
 	<-jg.ListenFinished()
 
 
@@ -9,7 +9,6 @@ import (
 	"os"
 	"path/filepath"
 	"sync"
-	ratomic "sync/atomic"
 	"time"
 
 	"github.com/NVIDIA/aistore/api/apc"
@@ -31,15 +30,15 @@ import (
 
 const (
 	ivalInactive = 4 * time.Second
-	retrySleep   = cos.PollSleepMedium
 )
 
 type (
 	Res struct {
-		xres  ratomic.Pointer[xs.Resilver]
-		end   atomic.Int64
-		nbusy atomic.Int64
-		mu    sync.Mutex
+		xres   *xs.Resilver
+		jgroup *mpather.Jgroup
+		end    atomic.Int64
+		nbusy  atomic.Int64
+		mu     sync.Mutex
 	}
 	Args struct {
 		UUID            string
@@ -76,13 +75,33 @@ func (res *Res) IsActive(multiplier int64) bool {
 	return mono.Since(end) < time.Duration(multiplier)*ivalInactive
 }
 
-func (res *Res) GetXact() *xs.Resilver { return res.xres.Load() }
+func (res *Res) GetXact() *xs.Resilver {
+	res.mu.Lock()
+	xres := res.xres
+	res.mu.Unlock()
+	return xres
+}
 
 func (res *Res) Abort(err error) (aborted bool) {
-	if r := res.xres.Load(); r != nil {
-		aborted = r.Abort(err)
+	res.mu.Lock()
+	xres := res.xres
+	jgroup := res.jgroup
+	if xres != nil {
+		res.jgroup = nil
+	}
+	res.mu.Unlock()
+	if xres == nil {
+		return false
+	}
+	aborted = xres.Abort(err)
+	if !aborted {
+		return false
+	}
+
+	if jgroup != nil {
+		_ = jgroup.Stop()
 	}
-	return
+	return true
 }
 
 func (res *Res) Run(args *Args, tstats cos.StatsUpdater) {
@@ -120,24 +139,31 @@ func (res *Res) Run(args *Args, tstats cos.StatsUpdater) {
 	debug.Assert(args.PostDD == nil || (args.Action == apc.ActMountpathDetach || args.Action == apc.ActMountpathDisable))
 
 	if args.SingleRmiJogger {
-		jgroup = mpather.NewJoggerGroup(opts, args.Custom.Config, args.Rmi)
+		jgroup = mpather.NewJgroup(opts, args.Custom.Config, args.Rmi)
 		nlog.Infof("%s, action %q, jogger->(%q)", xres.Name(), args.Action, args.Rmi)
 	} else {
-		jgroup = mpather.NewJoggerGroup(opts, args.Custom.Config, nil)
+		jgroup = mpather.NewJgroup(opts, args.Custom.Config, nil)
 		if args.Rmi != nil {
 			nlog.Infof("%s, action %q, rmi %s, num %d", xres.Name(), args.Action, args.Rmi, jgroup.NumJ())
 		} else {
 			nlog.Infof("%s, num %d", xres.Name(), jgroup.NumJ())
 		}
 	}
 
-	// run and block waiting
+	res.mu.Lock() // 2nd --------------------------------------
+	if xres != res.xres {
+		// (unlikely)
+		res.mu.Unlock()
+		_ = jgroup.Stop()
+		return
+	}
 	res.end.Store(0)
+	res.jgroup = jgroup
+	res.mu.Unlock() //  --------------------------------------
+
+	// run and block waiting
 	jgroup.Run()
-	err = wait(jgroup, xres, tstats)
-	if err != nil {
-		xres.AddErr(err)
-	}
+	res.wait(jgroup, xres, tstats)
 
 	// callback to, finally, detach-disable
 	if args.PostDD != nil {
@@ -147,8 +173,11 @@ func (res *Res) Run(args *Args, tstats cos.StatsUpdater) {
 	xres.Finish()
 
 	res.mu.Lock()
-	res.end.Store(mono.NanoTime())
-	res.xres.Store(nil)
+	if xres == res.xres {
+		res.end.Store(mono.NanoTime())
+		res.xres = nil
+		res.jgroup = nil
+	}
 	res.mu.Unlock()
 
 	if n := res.nbusy.Load(); n > 0 {
@@ -158,20 +187,17 @@ func (res *Res) Run(args *Args, tstats cos.StatsUpdater) {
 
 func (res *Res) initRenew(args *Args) *xs.Resilver {
 	rns := xreg.RenewResilver(args.UUID, &args.Custom)
-	if rns.Err == nil && rns.IsRunning() {
-		// retry just once
-		time.Sleep(retrySleep)
-		rns = xreg.RenewResilver(args.UUID, &args.Custom)
-	}
 	if rns.Err != nil {
+		debug.Assertf(!cmn.IsErrXactUsePrev(rns.Err), "not expecting %v(%T)", rns.Err, rns.Err)
+		nlog.Errorln("failed to start", args.Action, "renewal err:", rns.Err)
 		return nil
 	}
+	xctn := rns.Entry.Get()
+	xres := xctn.(*xs.Resilver)
 	if rns.IsRunning() {
-		nlog.Warningf("%s: failed to start/preempt for xid=%q: %s is still running", args.Action, args.UUID, rns.Entry.Get().Name())
+		nlog.Warningf("%s: start/preempt race [%q, %s]", args.Action, args.UUID, xres.Name())
 		return nil
 	}
-	xctn := rns.Entry.Get()
-	xres := xctn.(*xs.Resilver)
 
 	debug.Func(func() {
 		if r := res.GetXact(); r != nil {
@@ -180,15 +206,15 @@ func (res *Res) initRenew(args *Args) *xs.Resilver {
 	})
 	debug.Assertf(xres.ID() == args.UUID, "res-id mismatch: %q vs %q", xres.Name(), args.UUID)
 
-	res.mu.Lock() // --------------------------------------
+	res.mu.Lock() // 1st --------------------------------------
 
 	fatalErr, warnErr := fs.PersistMarker(fname.ResilverMarker, true /*quiet*/)
 	if fatalErr != nil {
 		xres.Abort(fatalErr)
 		res.mu.Unlock()
 		return nil
 	}
-	res.xres.Store(xres)
+	res.xres = xres
 
 	res.mu.Unlock() // ------------------------------------
 
@@ -203,16 +229,22 @@ func (res *Res) initRenew(args *Args) *xs.Resilver {
 }
 
 // Wait for an abort or for resilvering joggers to finish.
-func wait(jgroup *mpather.Jgroup, xres *xs.Resilver, tstats cos.StatsUpdater) (err error) {
+func (res *Res) wait(jgroup *mpather.Jgroup, xres *xs.Resilver, tstats cos.StatsUpdater) {
 	for {
 		select {
 		case errCause := <-xres.ChanAbort():
-			if err = jgroup.Stop(); err != nil {
-				xres.AddErr(err, 0)
-			} else {
-				nlog.Infoln(core.T.String(), xres.Name(), "aborted, cause:", errCause)
+			err := jgroup.Stop()
+			res.mu.Lock()
+			if res.jgroup == jgroup {
+				res.jgroup = nil
+			}
+			res.mu.Unlock()
+			if !xres.IsAborted() {
+				e := cos.Ternary(errCause == nil, err, errCause)
+				xres.Abort(e)
+				nlog.Warningln(xres.Name(), "stopped: [", errCause, err, "]")
 			}
-			return cmn.NewErrAborted(xres.Name(), "", errCause)
+			return
 		case <-jgroup.ListenFinished():
 			if fs.RemoveMarker(fname.ResilverMarker, tstats, false /*stopping*/) {
 				nlog.Infoln(core.T.String()+":", xres.Name(), "removed marker ok")
@@ -257,6 +289,11 @@ func (j *jogger) visitObj(lom *core.LOM, buf []byte) (errHrw error) {
 		size   int64
 		copied bool
 	)
+
+	if j.xres.IsAborted() {
+		return nil
+	}
+
 	if !lom.TryLock(true) { // NOTE: skipping busy
 		j.p.nbusy.Inc()
 		if cmn.Rom.V(4, cos.ModReb) {
@@ -419,6 +456,9 @@ func (j *jogger) visitECSlice(ct *core.CT, buf []byte) (err error) {
 	if !ct.Bck().Props.EC.Enabled {
 		return filepath.SkipDir
 	}
+	if j.xres.IsAborted() {
+		return nil
+	}
 	j._mvSlice(ct, buf)
 	return nil
 }
 
@@ -18,7 +18,7 @@ type BckJog struct {
 
 func (r *BckJog) Init(id, kind string, bck *meta.Bck, opts *mpather.JgroupOpts, config *cmn.Config) {
 	r.InitBase(id, kind, bck)
-	r.joggers = mpather.NewJoggerGroup(opts, config, nil)
+	r.joggers = mpather.NewJgroup(opts, config, nil)
 	r.Config = config
 }
 
 
@@ -773,6 +773,10 @@ func (r *RenewBase) Str(kind string) string {
 // RenewRes //
 //////////////
 
+// note:
+// for a newly constructed instance x-registry always returns RenewRes{Entry: entry}
+// with empty rns.UUID
+// in other words, IsRunning() can only be true when we are using xprev
 func (rns *RenewRes) IsRunning() bool {
 	if rns.UUID == "" {
 		return false
 
@@ -48,7 +48,7 @@ func (rp *prune) init(config *cmn.Config) {
 		// DoLoad:  noLoad
 	}
 	rmopts.Bck.Copy(rp.bckTo.Bucket())
-	rp.joggers = mpather.NewJoggerGroup(rmopts, config, nil)
+	rp.joggers = mpather.NewJgroup(rmopts, config, nil)
 	rp.filter = prob.NewDefaultFilter()
 	rp.same = rp.bckTo.Equal(rp.bckFrom, true, true)
 }
Original file line number	Diff line number	Diff line change
`@@ -174,7 +174,7 @@ func (r XactBckEncode) Run(gowg sync.WaitGroup) {`
`174`	`174`	`}`
`175`	`175`	`}`
`176`	`176`
`177`		`- jg := mpather.NewJoggerGroup(opts, r.config, nil)`
	`177`	`+ jg := mpather.NewJgroup(opts, r.config, nil)`
`178`	`178`	`jg.Run()`
`179`	`179`
`180`	`180`	`select {`
Original file line number	Diff line number	Diff line change
`@@ -77,7 +77,7 @@ type (`
`77`	`77`	`}`
`78`	`78`	`)`
`79`	`79`
`80`		`-func NewJoggerGroup(opts JgroupOpts, config cmn.Config, smi fs.Mountpath) Jgroup {`
	`80`	`+func NewJgroup(opts JgroupOpts, config cmn.Config, smi fs.Mountpath) Jgroup {`
`81`	`81`	`var (`
`82`	`82`	`joggers map[string]*jogger`
`83`	`83`	`avail = fs.GetAvail()`
Original file line number	Diff line number	Diff line change
`@@ -18,7 +18,7 @@ type BckJog struct {`
`18`	`18`
`19`	`19`	`func (r BckJog) Init(id, kind string, bck meta.Bck, opts mpather.JgroupOpts, config cmn.Config) {`
`20`	`20`	`r.InitBase(id, kind, bck)`
`21`		`- r.joggers = mpather.NewJoggerGroup(opts, config, nil)`
	`21`	`+ r.joggers = mpather.NewJgroup(opts, config, nil)`
`22`	`22`	`r.Config = config`
`23`	`23`	`}`
`24`	`24`
Original file line number	Diff line number	Diff line change
`@@ -48,7 +48,7 @@ func (rp prune) init(config cmn.Config) {`
`48`	`48`	`// DoLoad: noLoad`
`49`	`49`	`}`
`50`	`50`	`rmopts.Bck.Copy(rp.bckTo.Bucket())`
`51`		`- rp.joggers = mpather.NewJoggerGroup(rmopts, config, nil)`
	`51`	`+ rp.joggers = mpather.NewJgroup(rmopts, config, nil)`
`52`	`52`	`rp.filter = prob.NewDefaultFilter()`
`53`	`53`	`rp.same = rp.bckTo.Equal(rp.bckFrom, true, true)`
`54`	`54`	`}`