diff --git a/ais/backend/aws.go b/ais/backend/aws.go
index 4eb8aa2e60a..b124668c2e2 100644
--- a/ais/backend/aws.go
+++ b/ais/backend/aws.go
@@ -163,7 +163,7 @@ func (s3bp *s3bp) GetBucketInv(bck *meta.Bck, ctx *core.LsoInvCtx) (int, error)
 	ctx.Lom = lom
 	mtime, usable := checkInvLom(csv.mtime, ctx)
 	if usable {
-		if ctx.Lmfh, err = ctx.Lom.OpenFile(); err != nil {
+		if ctx.Lmfh, err = ctx.Lom.Open(); err != nil {
 			lom.Unlock(false)
 			core.FreeLOM(lom)
 			ctx.Lom = nil
@@ -208,7 +208,7 @@ func (s3bp *s3bp) GetBucketInv(bck *meta.Bck, ctx *core.LsoInvCtx) (int, error)
 			lom.Unlock(true)
 			lom.Lock(false)
 
-			if ctx.Lmfh, err = ctx.Lom.OpenFile(); err != nil {
+			if ctx.Lmfh, err = ctx.Lom.Open(); err != nil {
 				lom.Unlock(false)
 				core.FreeLOM(lom)
 				ctx.Lom = nil
@@ -235,7 +235,7 @@ func (s3bp *s3bp) GetBucketInv(bck *meta.Bck, ctx *core.LsoInvCtx) (int, error)
 	}
 
 	lom.Lock(false) // must succeed
-	if ctx.Lmfh, err = ctx.Lom.OpenFile(); err != nil {
+	if ctx.Lmfh, err = ctx.Lom.Open(); err != nil {
 		lom.Unlock(false)
 		core.FreeLOM(lom)
 		ctx.Lom = nil
diff --git a/ais/backend/awsinv.go b/ais/backend/awsinv.go
index 33f4ef2cd16..43501cb910a 100644
--- a/ais/backend/awsinv.go
+++ b/ais/backend/awsinv.go
@@ -202,7 +202,7 @@ func (s3bp *s3bp) getInventory(cloudBck *cmn.Bck, ctx *core.LsoInvCtx, csv invT)
 	lom.SetSize(csv.size)
 
 	wfqn := fs.CSM.Gen(ctx.Lom, fs.WorkfileType, "")
-	wfh, err := ctx.Lom.CreateFile(wfqn)
+	wfh, err := ctx.Lom.CreateWork(wfqn)
 	if err != nil {
 		return _errInv("create-file", err)
 	}
@@ -248,7 +248,7 @@ func (s3bp *s3bp) getInventory(cloudBck *cmn.Bck, ctx *core.LsoInvCtx, csv invT)
 	// finalize (NOTE a lighter version of FinalizeObj - no redundancy, no locks)
 	if err == nil {
 		lom := ctx.Lom
-		if err = lom.RenameFrom(wfqn); err == nil {
+		if err = lom.RenameFinalize(wfqn); err == nil {
 			if err = os.Chtimes(lom.FQN, csv.mtime, csv.mtime); err == nil {
 				nlog.Infoln("new", invTag+":", lom.Cname(), ctx.Schema)
 
diff --git a/ais/target.go b/ais/target.go
index 56fdaf0203b..2738c616c91 100644
--- a/ais/target.go
+++ b/ais/target.go
@@ -1374,7 +1374,7 @@ func (t *target) delobj(lom *core.LOM, evict bool) (int, error, bool) {
 	}
 	if delFromAIS {
 		size := lom.SizeBytes()
-		aisErr = lom.Remove()
+		aisErr = lom.RemoveObj()
 		if aisErr != nil {
 			if !os.IsNotExist(aisErr) {
 				if backendErr != nil {
@@ -1430,7 +1430,7 @@ func (t *target) objMv(lom *core.LOM, msg *apc.ActMsg) (err error) {
 
 	// TODO: combine copy+delete under a single write lock
 	lom.Lock(true)
-	if err := lom.Remove(); err != nil {
+	if err := lom.RemoveObj(); err != nil {
 		nlog.Warningf("%s: failed to delete renamed object %s (new name %s): %v", t, lom, msg.Name, err)
 	}
 	lom.Unlock(true)
@@ -1487,7 +1487,7 @@ func _blobdl(params *core.BlobParams, oa *cmn.ObjAttrs) (string, *xs.XactBlobDl,
 	if params.WriteSGL == nil {
 		// regular lom save (custom writer not present)
 		wfqn := fs.CSM.Gen(params.Lom, fs.WorkfileType, "blob-dl")
-		lmfh, err := params.Lom.CreateFile(wfqn)
+		lmfh, err := params.Lom.CreateWork(wfqn)
 		if err != nil {
 			return "", nil, err
 		}
diff --git a/ais/tgtfcold.go b/ais/tgtfcold.go
index b67f6be0c20..bce5d7ec66e 100644
--- a/ais/tgtfcold.go
+++ b/ais/tgtfcold.go
@@ -31,12 +31,12 @@ func (goi *getOI) coldReopen(res *core.GetReaderResult) error {
 	)
 	if goi.verchanged {
 		revert = fs.CSM.Gen(lom, fs.WorkfileType, fs.WorkfileColdget)
-		if err := os.Rename(lom.FQN, revert); err != nil {
+		if err := lom.RenameMainTo(revert); err != nil {
 			nlog.Errorln("failed to rename prev. version - proceeding anyway", lom.FQN, "=>", revert)
 			revert = ""
 		}
 	}
-	lmfh, err := lom.CreateFile(lom.FQN)
+	lmfh, err := lom.Create()
 	if err != nil {
 		cos.Close(res.R)
 		goi._cleanup(revert, nil, nil, nil, err, "(fcreate)")
@@ -88,7 +88,7 @@ func (goi *getOI) coldReopen(res *core.GetReaderResult) error {
 	}
 
 	// reopen & transmit ---
-	if lmfh, err = lom.OpenFile(); err != nil {
+	if lmfh, err = lom.Open(); err != nil {
 		goi._cleanup(revert, nil, buf, slab, err, "(seek)")
 		return err
 	}
@@ -176,9 +176,9 @@ func (goi *getOI) _cleanup(revert string, lmfh *os.File, buf []byte, slab *memsy
 		slab.Free(buf)
 	}
 	if err != nil {
-		goi.lom.Remove()
+		goi.lom.RemoveObj()
 		if revert != "" {
-			if errV := os.Rename(revert, goi.lom.FQN); errV != nil {
+			if errV := goi.lom.RenameToMain(revert); errV != nil {
 				nlog.Infoln(ftcg+tag+"(revert)", errV)
 			}
 		}
@@ -197,12 +197,12 @@ func (goi *getOI) coldStream(res *core.GetReaderResult) error {
 	)
 	if goi.verchanged {
 		revert = fs.CSM.Gen(lom, fs.WorkfileType, fs.WorkfileColdget)
-		if err := os.Rename(lom.FQN, revert); err != nil {
+		if err := lom.RenameMainTo(revert); err != nil {
 			nlog.Errorln("failed to rename prev. version - proceeding anyway", lom.FQN, "=>", revert)
 			revert = ""
 		}
 	}
-	lmfh, err := lom.CreateFile(lom.FQN)
+	lmfh, err := lom.Create()
 	if err != nil {
 		cos.Close(res.R)
 		goi._cleanup(revert, nil, nil, nil, err, "(fcreate)")
diff --git a/ais/tgtobj.go b/ais/tgtobj.go
index f3924afa2da..f16bf3e3540 100644
--- a/ais/tgtobj.go
+++ b/ais/tgtobj.go
@@ -302,7 +302,7 @@ func (poi *putOI) fini() (ecode int, err error) {
 	// (see GetCold() implementation and cmn.OWT enum)
 	switch poi.owt {
 	case cmn.OwtGetTryLock, cmn.OwtGetLock, cmn.OwtGet:
-		debug.AssertFunc(func() bool { _, exclusive := lom.IsLocked(); return exclusive })
+		// do nothing: lom is already wlocked
 	case cmn.OwtGetPrefetchLock:
 		if !lom.TryLock(true) {
 			if cmn.Rom.FastV(4, cos.SmoduleAIS) {
@@ -334,7 +334,7 @@ func (poi *putOI) fini() (ecode int, err error) {
 	}
 
 	// done
-	if err = lom.RenameFrom(poi.workFQN); err != nil {
+	if err = lom.RenameFinalize(poi.workFQN); err != nil {
 		return
 	}
 	if lom.HasCopies() {
@@ -385,7 +385,7 @@ func (poi *putOI) write() (buf []byte, slab *memsys.Slab, lmfh *os.File, err err
 		}{}
 		ckconf = poi.lom.CksumConf()
 	)
-	if lmfh, err = poi.lom.CreateFile(poi.workFQN); err != nil {
+	if lmfh, err = poi.lom.CreateWork(poi.workFQN); err != nil {
 		return
 	}
 	if poi.size <= 0 {
@@ -772,7 +772,7 @@ validate:
 		//
 		// TODO: mark `deleted` and postpone actual deletion
 		//
-		if erl := lom.Remove(true /*force through rlock*/); erl != nil {
+		if erl := lom.RemoveObj(true /*force through rlock*/); erl != nil {
 			nlog.Warningf("%s: failed to remove corrupted %s, err: %v", goi.t, lom, erl)
 		}
 		return
@@ -780,7 +780,7 @@ validate:
 	//
 	// try to recover from BAD CHECKSUM
 	//
-	cos.RemoveFile(lom.FQN) // TODO: ditto
+	lom.RemoveMain()
 
 	if lom.HasCopies() {
 		retried = true
@@ -797,7 +797,7 @@ validate:
 	if lom.ECEnabled() {
 		retried = true
 		goi.lom.Unlock(false)
-		cos.RemoveFile(lom.FQN)
+		lom.RemoveMain()
 		_, code, err = goi.restoreFromAny(true /*skipLomRestore*/)
 		goi.lom.Lock(false)
 		if err == nil {
@@ -808,7 +808,7 @@ validate:
 	}
 
 	// TODO: ditto
-	if erl := lom.Remove(true /*force through rlock*/); erl != nil {
+	if erl := lom.RemoveObj(true /*force through rlock*/); erl != nil {
 		nlog.Warningf("%s: failed to remove corrupted %s, err: %v", goi.t, lom, erl)
 	}
 	return
@@ -1255,7 +1255,7 @@ func (a *apndOI) apnd(buf []byte) (packedHdl string, ecode int, err error) {
 		} else {
 			a.lom.Unlock(false)
 			a.hdl.partialCksum = cos.NewCksumHash(a.lom.CksumType())
-			fh, err = a.lom.CreateFile(workFQN)
+			fh, err = a.lom.CreateWork(workFQN)
 		}
 	} else {
 		fh, err = os.OpenFile(workFQN, os.O_APPEND|os.O_WRONLY, cos.PermRWR)
@@ -1655,12 +1655,12 @@ func (a *putA2I) do() (int, error) {
 			tarFormat tar.Format
 			workFQN   = fs.CSM.Gen(a.lom, fs.WorkfileType, fs.WorkfileAppendToArch)
 		)
-		if err = os.Rename(a.lom.FQN, workFQN); err != nil {
+		if err = a.lom.RenameMainTo(workFQN); err != nil {
 			return http.StatusInternalServerError, err
 		}
 		fh, tarFormat, err = archive.OpenTarSeekEnd(a.lom.Cname(), workFQN)
 		if err != nil {
-			if errV := a.lom.RenameFrom(workFQN); errV != nil {
+			if errV := a.lom.RenameToMain(workFQN); errV != nil {
 				return http.StatusInternalServerError, errV
 			}
 			if err == archive.ErrTarIsEmpty {
@@ -1675,8 +1675,7 @@ func (a *putA2I) do() (int, error) {
 			if err = a.finalize(size, cos.NoneCksum, workFQN); err == nil {
 				return http.StatusInternalServerError, nil // ok
 			}
-		}
-		if errV := a.lom.RenameFrom(workFQN); errV != nil {
+		} else if errV := a.lom.RenameToMain(workFQN); errV != nil {
 			nlog.Errorf(fmtNested, a.t, err, "append and rename back", workFQN, errV)
 		}
 		return http.StatusInternalServerError, err
@@ -1705,7 +1704,7 @@ cpap: // copy + append
 		aw.Fini()
 	} else {
 		// copy + append
-		lmfh, err = a.lom.OpenFile()
+		lmfh, err = a.lom.Open()
 		if err != nil {
 			cos.Close(wfh)
 			return http.StatusNotFound, err
@@ -1771,7 +1770,7 @@ func (a *putA2I) finalize(size int64, cksum *cos.Cksum, fqn string) error {
 		debug.Assertf(finfo.Size() == size, "%d != %d", finfo.Size(), size)
 	})
 	// done
-	if err := a.lom.RenameFrom(fqn); err != nil {
+	if err := a.lom.RenameFinalize(fqn); err != nil {
 		return err
 	}
 	a.lom.SetSize(size)
diff --git a/ais/tgtobj_internal_test.go b/ais/tgtobj_internal_test.go
index f4a40d768a9..c265cbacc72 100644
--- a/ais/tgtobj_internal_test.go
+++ b/ais/tgtobj_internal_test.go
@@ -123,7 +123,7 @@ func BenchmarkObjPut(b *testing.B) {
 					workFQN: path.Join(testMountpath, "objname.work"),
 					config:  cmn.GCO.Get(),
 				}
-				os.Remove(lom.FQN)
+				lom.RemoveMain()
 				b.StartTimer()
 
 				_, err := poi.putObject()
@@ -132,7 +132,7 @@ func BenchmarkObjPut(b *testing.B) {
 				}
 			}
 			b.StopTimer()
-			os.Remove(lom.FQN)
+			lom.RemoveMain()
 		})
 	}
 }
@@ -173,7 +173,7 @@ func BenchmarkObjAppend(b *testing.B) {
 					op:      apc.AppendOp,
 					hdl:     hdl,
 				}
-				os.Remove(lom.FQN)
+				lom.RemoveMain()
 				b.StartTimer()
 
 				newHandle, _, err := aoi.apnd(buf)
@@ -186,7 +186,7 @@ func BenchmarkObjAppend(b *testing.B) {
 				}
 			}
 			b.StopTimer()
-			os.Remove(lom.FQN)
+			lom.RemoveMain()
 			os.Remove(hdl.workFQN)
 		})
 	}
@@ -261,7 +261,7 @@ func BenchmarkObjGetDiscard(b *testing.B) {
 			}
 
 			b.StopTimer()
-			os.Remove(lom.FQN)
+			lom.RemoveMain()
 		})
 	}
 }
diff --git a/ais/tgts3mpt.go b/ais/tgts3mpt.go
index b6326d9d19e..6fbcc00d9c5 100644
--- a/ais/tgts3mpt.go
+++ b/ais/tgts3mpt.go
@@ -122,7 +122,7 @@ func (t *target) putMptPart(w http.ResponseWriter, r *http.Request, items []stri
 	// workfile name format: <upload-id>.<part-number>.<obj-name>
 	prefix := uploadID + "." + strconv.FormatInt(int64(partNum), 10)
 	wfqn := fs.CSM.Gen(lom, fs.WorkfileType, prefix)
-	partFh, errC := lom.CreateFileRW(wfqn)
+	partFh, errC := lom.CreateWorkRW(wfqn)
 	if errC != nil {
 		s3.WriteMptErr(w, r, errC, 0, lom, uploadID)
 		return
@@ -274,7 +274,7 @@ func (t *target) completeMpt(w http.ResponseWriter, r *http.Request, items []str
 	// 2. <upload-id>.complete.<obj-name>
 	prefix := uploadID + ".complete"
 	wfqn := fs.CSM.Gen(lom, fs.WorkfileType, prefix)
-	wfh, errC := lom.CreateFile(wfqn)
+	wfh, errC := lom.CreateWork(wfqn)
 	if errC != nil {
 		s3.WriteMptErr(w, r, errC, 0, lom, uploadID)
 		return
@@ -493,7 +493,7 @@ func (t *target) getMptPart(w http.ResponseWriter, r *http.Request, bck *meta.Bc
 	if err != nil {
 		s3.WriteErr(w, r, err, status)
 	}
-	fh, err := lom.OpenFile()
+	fh, err := lom.Open()
 	if err != nil {
 		s3.WriteErr(w, r, err, 0)
 		return
diff --git a/core/lcopy.go b/core/lcopy.go
index 3074e96361a..a41c8b1ac11 100644
--- a/core/lcopy.go
+++ b/core/lcopy.go
@@ -32,12 +32,10 @@ func (lom *LOM) HasCopies() bool { return len(lom.md.copies) > 1 }
 func (lom *LOM) NumCopies() int  { return max(len(lom.md.copies), 1) } // metadata-wise
 
 // GetCopies returns all copies
-// NOTE: a) copies include lom.FQN aka "main repl.", and b) caller must take a lock
+// - copies include lom.FQN aka "main repl."
+// - caller must take a lock
 func (lom *LOM) GetCopies() fs.MPI {
-	debug.AssertFunc(func() bool {
-		rc, exclusive := lom.IsLocked()
-		return exclusive || rc > 0
-	})
+	debug.Assert(lom.isLockedRW(), lom.Cname())
 	return lom.md.copies
 }
 
@@ -145,11 +143,9 @@ func (lom *LOM) syncMetaWithCopies() (err error) {
 	if !lom.HasCopies() {
 		return nil
 	}
-	// NOTE: caller is responsible for write-locking
-	debug.AssertFunc(func() bool {
-		_, exclusive := lom.IsLocked()
-		return exclusive
-	})
+	// caller is responsible for write-locking
+	debug.Assert(lom.isLockedExcl(), lom.Cname())
+
 	if !lom.WritePolicy().IsImmediate() {
 		lom.md.makeDirty()
 		return nil
diff --git a/core/ldp.go b/core/ldp.go
index 86afe1f8614..d8364a60692 100644
--- a/core/ldp.go
+++ b/core/ldp.go
@@ -141,7 +141,7 @@ func (lom *LOM) CheckRemoteMD(locked, sync bool, origReq *http.Request) (res CRM
 
 	// rm remotely-deleted
 	if cos.IsNotExist(err, ecode) && (lom.VersionConf().Sync || sync) {
-		errDel := lom.Remove(locked /*force through rlock*/)
+		errDel := lom.RemoveObj(locked /*force through rlock*/)
 		if errDel != nil {
 			ecode, err = 0, errDel
 		} else {
@@ -155,12 +155,10 @@ func (lom *LOM) CheckRemoteMD(locked, sync bool, origReq *http.Request) (res CRM
 	return CRMD{ErrCode: ecode, Err: err}
 }
 
-// NOTE: must be locked; NOTE: Sync == false (ie., not deleting)
+// NOTE: Sync is false (ie., not deleting)
 func (lom *LOM) LoadLatest(latest bool) (oa *cmn.ObjAttrs, deleted bool, err error) {
-	debug.AssertFunc(func() bool {
-		rc, exclusive := lom.IsLocked()
-		return exclusive || rc > 0
-	})
+	debug.Assert(lom.isLockedRW(), lom.Cname()) // caller must take a lock
+
 	err = lom.Load(true /*cache it*/, true /*locked*/)
 	if err != nil {
 		if !cmn.IsErrObjNought(err) || !latest {
diff --git a/core/lfile.go b/core/lfile.go
index 071e5f82762..d5135659d88 100644
--- a/core/lfile.go
+++ b/core/lfile.go
@@ -14,52 +14,71 @@ import (
 	"github.com/NVIDIA/aistore/cmn/debug"
 )
 
-func (lom *LOM) OpenFile() (*os.File, error) {
+//
+// open
+//
+
+func (lom *LOM) Open() (*os.File, error) {
 	return os.Open(lom.FQN)
 }
 
-// (compare with cos.CreateFile)
-func (lom *LOM) CreateFile(fqn string) (fh *os.File, err error) {
-	fh, err = os.OpenFile(fqn, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, cos.PermRWR)
-	if err == nil || !os.IsNotExist(err) {
-		return
-	}
-	return lom._cf(fqn, os.O_WRONLY)
+//
+// create
+//
+
+func (lom *LOM) Create() (*os.File, error) {
+	debug.Assert(lom.isLockedExcl(), lom.Cname()) // caller must wlock
+	return lom._cf(lom.FQN, os.O_WRONLY)
+}
+
+func (lom *LOM) CreateWork(wfqn string) (*os.File, error) {
+	return lom._cf(wfqn, os.O_WRONLY)
+}
+
+func (lom *LOM) CreateWorkRW(wfqn string) (*os.File, error) {
+	return lom._cf(wfqn, os.O_RDWR)
 }
 
-// slow path
 func (lom *LOM) _cf(fqn string, mode int) (fh *os.File, err error) {
+	fh, err = os.OpenFile(fqn, os.O_CREATE|mode|os.O_TRUNC, cos.PermRWR)
+	if err == nil || !os.IsNotExist(err) {
+		return fh, err
+	}
+
+	// slow path: create sub-directories
 	bdir := lom.mi.MakePathBck(lom.Bucket())
 	if err = cos.Stat(bdir); err != nil {
 		return nil, fmt.Errorf("%s (bdir %s): %w", lom, bdir, err)
 	}
 	fdir := filepath.Dir(fqn)
 	if err = cos.CreateDir(fdir); err != nil {
-		return
+		return nil, err
 	}
-	fh, err = os.OpenFile(fqn, os.O_CREATE|mode|os.O_TRUNC, cos.PermRWR)
-	return
+	return os.OpenFile(fqn, os.O_CREATE|mode|os.O_TRUNC, cos.PermRWR)
 }
 
-func (lom *LOM) CreateFileRW(fqn string) (fh *os.File, err error) {
-	fh, err = os.OpenFile(fqn, os.O_CREATE|os.O_RDWR|os.O_TRUNC, cos.PermRWR)
-	if err == nil || !os.IsNotExist(err) {
-		return
+//
+// remove
+//
+
+func (lom *LOM) RemoveMain() (err error) {
+	err = cos.RemoveFile(lom.FQN)
+	if os.IsNotExist(err) {
+		err = nil
 	}
-	return lom._cf(fqn, os.O_RDWR)
+	return err
 }
 
-func (lom *LOM) Remove(force ...bool) (err error) {
-	// making "rlock" exception to be able to (forcefully) remove corrupted obj in the GET path
+func (lom *LOM) RemoveObj(force ...bool) (err error) {
 	debug.AssertFunc(func() bool {
-		rc, exclusive := lom.IsLocked()
-		return exclusive || (len(force) > 0 && force[0] && rc > 0)
+		if lom.isLockedExcl() {
+			return true
+		}
+		// NOTE: making "rlock" exception to be able to forcefully rm corrupted object in the GET path
+		return len(force) > 0 && force[0] && lom.isLockedRW()
 	})
 	lom.Uncache()
-	err = cos.RemoveFile(lom.FQN)
-	if os.IsNotExist(err) {
-		err = nil
-	}
+	err = lom.RemoveMain()
 	for copyFQN := range lom.md.copies {
 		if erc := cos.RemoveFile(copyFQN); erc != nil && !os.IsNotExist(erc) {
 			err = erc
@@ -69,13 +88,24 @@ func (lom *LOM) Remove(force ...bool) (err error) {
 	return err
 }
 
-// (compare with cos.Rename)
-func (lom *LOM) RenameFrom(workfqn string) error {
+//
+// rename
+//
+
+func (lom *LOM) RenameMainTo(wfqn string) error {
+	return cos.Rename(lom.FQN, wfqn)
+}
+
+func (lom *LOM) RenameToMain(wfqn string) error {
+	return cos.Rename(wfqn, lom.FQN)
+}
+
+func (lom *LOM) RenameFinalize(wfqn string) error {
 	bdir := lom.mi.MakePathBck(lom.Bucket())
 	if err := cos.Stat(bdir); err != nil {
 		return fmt.Errorf("%s(bdir: %s): %w", lom, bdir, err)
 	}
-	if err := cos.Rename(workfqn, lom.FQN); err != nil {
+	if err := lom.RenameToMain(wfqn); err != nil {
 		return cmn.NewErrFailedTo(T, "finalize", lom.Cname(), err)
 	}
 	return nil
diff --git a/core/lom.go b/core/lom.go
index 9b28efa3f08..58654e87d6d 100644
--- a/core/lom.go
+++ b/core/lom.go
@@ -365,7 +365,7 @@ func (lom *LOM) ComputeCksum(cksumType string) (cksum *cos.CksumHash, _ error) {
 	if cksumType == cos.ChecksumNone {
 		return nil, nil
 	}
-	lmfh, err := lom.OpenFile()
+	lmfh, err := lom.Open()
 	if err != nil {
 		return nil, err
 	}
@@ -573,9 +573,16 @@ func lomCaches() []*sync.Map {
 
 func (lom *LOM) getLocker() *nlc { return &g.locker[lom.CacheIdx()] } // (lif.getLocker())
 
-func (lom *LOM) IsLocked() (int /*rc*/, bool /*exclusive*/) {
+func (lom *LOM) isLockedExcl() (exclusive bool) {
 	nlc := lom.getLocker()
-	return nlc.IsLocked(lom.Uname())
+	_, exclusive = nlc.IsLocked(lom.Uname())
+	return exclusive
+}
+
+func (lom *LOM) isLockedRW() (locked bool) {
+	nlc := lom.getLocker()
+	rc, exclusive := nlc.IsLocked(lom.Uname())
+	return exclusive || rc > 0
 }
 
 func (lom *LOM) TryLock(exclusive bool) bool {
diff --git a/ec/ec.go b/ec/ec.go
index f80a05c0a36..c7b9b0d74d4 100644
--- a/ec/ec.go
+++ b/ec/ec.go
@@ -507,7 +507,7 @@ func WriteReplicaAndMeta(lom *core.LOM, args *WriteArgs) (err error) {
 		if err == nil {
 			return
 		}
-		if rmErr := cos.RemoveFile(lom.FQN); rmErr != nil {
+		if rmErr := lom.RemoveMain(); rmErr != nil {
 			nlog.Errorf("nested error: save replica -> remove replica: %v", rmErr)
 		}
 		if rmErr := cos.RemoveFile(ctMeta.FQN()); rmErr != nil {
diff --git a/ec/getjogger.go b/ec/getjogger.go
index 46b4921da47..4e3e34367af 100644
--- a/ec/getjogger.go
+++ b/ec/getjogger.go
@@ -275,7 +275,7 @@ func (c *getJogger) restoreReplicatedFromDisk(ctx *restoreCtx) error {
 	for node := range ctx.nodes {
 		uname := unique(node, ctx.lom.Bck(), ctx.lom.ObjName)
 
-		w, err := ctx.lom.CreateFile(tmpFQN)
+		w, err := ctx.lom.CreateWork(tmpFQN)
 		if err != nil {
 			nlog.Errorf("Failed to create file: %v", err)
 			break
@@ -307,7 +307,7 @@ func (c *getJogger) restoreReplicatedFromDisk(ctx *restoreCtx) error {
 	if writer == nil {
 		return errors.New("failed to read a replica from any target")
 	}
-	if err := ctx.lom.RenameFrom(tmpFQN); err != nil {
+	if err := ctx.lom.RenameFinalize(tmpFQN); err != nil {
 		return err
 	}
 
@@ -362,7 +362,7 @@ func (c *getJogger) requestSlices(ctx *restoreCtx) error {
 		if ctx.toDisk {
 			prefix := fmt.Sprintf("ec-restore-%d", v.SliceID)
 			fqn := fs.CSM.Gen(ctx.lom, fs.WorkfileType, prefix)
-			fh, err := ctx.lom.CreateFile(fqn)
+			fh, err := ctx.lom.CreateWork(fqn)
 			if err != nil {
 				return err
 			}
@@ -420,7 +420,7 @@ func newSliceWriter(ctx *restoreCtx, writers []io.Writer, restored []*slice,
 	if ctx.toDisk {
 		prefix := fmt.Sprintf("ec-rebuild-%d", idx)
 		fqn := fs.CSM.Gen(ctx.lom, fs.WorkfileType, prefix)
-		file, err := ctx.lom.CreateFile(fqn)
+		file, err := ctx.lom.CreateWork(fqn)
 		if err != nil {
 			return err
 		}
diff --git a/ec/putjogger.go b/ec/putjogger.go
index cbb34a9a1b6..f9a435d26c1 100644
--- a/ec/putjogger.go
+++ b/ec/putjogger.go
@@ -448,7 +448,7 @@ func generateSlicesToDisk(ctx *encodeCtx) error {
 	cksumType := ctx.lom.CksumType()
 	for i := range ctx.paritySlices {
 		workFQN := fs.CSM.Gen(ctx.lom, fs.WorkfileType, fmt.Sprintf("ec-write-%d", i))
-		writer, err := ctx.lom.CreateFile(workFQN)
+		writer, err := ctx.lom.CreateWork(workFQN)
 		if err != nil {
 			return err
 		}
diff --git a/ext/dsort/dsort.go b/ext/dsort/dsort.go
index ebe2e3894d5..bacbc229142 100644
--- a/ext/dsort/dsort.go
+++ b/ext/dsort/dsort.go
@@ -954,7 +954,7 @@ func (es *extractShard) _do(lom *core.LOM) error {
 	}
 
 	lom.Lock(false)
-	fh, err := lom.OpenFile()
+	fh, err := lom.Open()
 	if err != nil {
 		phaseInfo.adjuster.releaseSema(lom.Mountpath())
 		lom.Unlock(false)
diff --git a/space/cleanup.go b/space/cleanup.go
index 3870e70a913..e102e8e4769 100644
--- a/space/cleanup.go
+++ b/space/cleanup.go
@@ -438,14 +438,14 @@ func (j *clnJ) visitObj(fqn string, lom *core.LOM) {
 			return
 		}
 		if cmn.IsErrLmetaCorrupted(err) {
-			if err := cos.RemoveFile(lom.FQN); err != nil {
+			if err := lom.RemoveMain(); err != nil {
 				nlog.Errorf("%s: failed to rm MD-corrupted %s: %v (nested: %v)", j, lom, errLoad, err)
 				j.ini.Xaction.AddErr(err)
 			} else {
 				nlog.Errorf("%s: removed MD-corrupted %s: %v", j, lom, errLoad)
 			}
 		} else if cmn.IsErrLmetaNotFound(err) {
-			if err := cos.RemoveFile(lom.FQN); err != nil {
+			if err := lom.RemoveMain(); err != nil {
 				nlog.Errorf("%s: failed to rm no-MD %s: %v (nested: %v)", j, lom, errLoad, err)
 				j.ini.Xaction.AddErr(err)
 			} else {
diff --git a/space/lru.go b/space/lru.go
index 1ebdfdcadb7..1bca007326d 100644
--- a/space/lru.go
+++ b/space/lru.go
@@ -432,7 +432,7 @@ func (j *lruJ) _throttle(usedPct int64) (err error) {
 // remove local copies that "belong" to different LRU joggers (space accounting may be temporarily not precise)
 func (j *lruJ) evictObj(lom *core.LOM) bool {
 	lom.Lock(true)
-	err := lom.Remove()
+	err := lom.RemoveObj()
 	lom.Unlock(true)
 	if err != nil {
 		nlog.Errorf("%s: failed to evict %s: %v", j, lom, err)
diff --git a/xact/xs/archive.go b/xact/xs/archive.go
index e36e757951e..34acaa225c5 100644
--- a/xact/xs/archive.go
+++ b/xact/xs/archive.go
@@ -156,7 +156,7 @@ func (r *XactArch) Begin(msg *cmn.ArchiveBckMsg, archlom *core.LOM) (err error)
 			s = " append"
 			lmfh, err = wi.beginAppend()
 		} else {
-			wi.wfh, err = wi.archlom.CreateFile(wi.fqn)
+			wi.wfh, err = wi.archlom.CreateWork(wi.fqn)
 		}
 		if err != nil {
 			return
@@ -440,11 +440,11 @@ func (wi *archwi) beginAppend() (lmfh *os.File, err error) {
 	}
 	// msg.Mime has been already validated (see ais/* for apc.ActArchive)
 	// prep to copy `lmfh` --> `wi.fh` with subsequent APPEND-ing
-	lmfh, err = wi.archlom.OpenFile()
+	lmfh, err = wi.archlom.Open()
 	if err != nil {
 		return
 	}
-	if wi.wfh, err = wi.archlom.CreateFile(wi.fqn); err != nil {
+	if wi.wfh, err = wi.archlom.CreateWork(wi.fqn); err != nil {
 		cos.Close(lmfh)
 		lmfh = nil
 	}
@@ -452,7 +452,7 @@ func (wi *archwi) beginAppend() (lmfh *os.File, err error) {
 }
 
 func (wi *archwi) openTarForAppend() (err error) {
-	if err = os.Rename(wi.archlom.FQN, wi.fqn); err != nil {
+	if err = wi.archlom.RenameMainTo(wi.fqn); err != nil {
 		return
 	}
 	// open (rw) lom itself
@@ -468,7 +468,7 @@ func (wi *archwi) openTarForAppend() (err error) {
 	cos.Close(wi.wfh)
 	wi.wfh = nil
 roll:
-	if errV := wi.archlom.RenameFrom(wi.fqn); errV != nil {
+	if errV := wi.archlom.RenameToMain(wi.fqn); errV != nil {
 		nlog.Errorf("%s: nested error: failed to append %s (%v) and rename back from %s (%v)",
 			wi.tsi, wi.archlom, err, wi.fqn, errV)
 	} else {
diff --git a/xact/xs/prune.go b/xact/xs/prune.go
index 2cff0ceb978..903f402c6ba 100644
--- a/xact/xs/prune.go
+++ b/xact/xs/prune.go
@@ -144,7 +144,7 @@ func (rp *prune) do(dst *core.LOM, _ []byte) error {
 	}
 	err = dst.Load(false, true)
 	if err == nil {
-		err = dst.Remove()
+		err = dst.RemoveObj()
 	}
 	dst.Unlock(true)