break
		}
		err = fn(ctx, entry.ObjName, entry.VersionID, entry.TierName)
		if err != nil && !isErrObjectNotFound(err) {
			logger.LogIf(ctx, fmt.Errorf("tier-journal: failed to delete transitioned object %s from %s due to %s", entry.ObjName, entry.TierName, err))
			// We add the entry into the active journal to try again
			// later.
			jd.addEntry(entry)
		}
	}

			}
		case "vid":
			z.VersionID, err = dc.ReadString()
			if err != nil {
				err = msgp.WrapError(err, "VersionID")
				return
			}
		case "tier":
			z.TierName, err = dc.ReadString()
			if err != nil {
				err = msgp.WrapError(err, "TierName")
				return
			}
		default:
			err = dc.Skip()
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
		}
	}
	return
}

// IsTierValid returns true if there exists a remote tier by name tierName,
// otherwise returns false.
func (config *TierConfigMgr) IsTierValid(tierName string) bool {
	config.RLock()
	defer config.RUnlock()
	_, valid := config.isTierNameInUse(tierName)
	return valid
}

// isTierNameInUse returns tier type and true if there exists a remote tier by
// name tierName, otherwise returns madmin.Unsupported and false. N B this

			logger.LogIf(ctx, deleteObjectFromRemoteTier(ctx, entry.ObjName, entry.VersionID, entry.TierName))
		}
	}
}

func (j *tierMemJournal) AddEntry(je jentry) error {
	select {
	case j.entries <- je:
	default:
		return fmt.Errorf("failed to remove tiered content at %s with version %s from tier %s, will be retried later.",
			je.ObjName, je.VersionID, je.TierName)
	}
	return nil

		if i < len(oldStructVals) {
			// For old struct values, the RemoteVersionID will be
			// empty
			expectedJe = jentry{
				ObjName:   oldStructVals[i].ObjName,
				VersionID: "",
				TierName:  oldStructVals[i].TierName,
			}
		} else {
			expectedJe = newStructVals[i-len(oldStructVals)]
		}
		if expectedJe != je {
			t.Errorf("Case %d: Expected: %v, Got: %v", i, expectedJe, je)
		}
	}

		globalExpiryState.enqueueTierJournalEntry(je)
	}
}

type jentry struct {
	ObjName   string
	VersionID string
	TierName  string
}

func deleteObjectFromRemoteTier(ctx context.Context, objName, rvID, tierName string) error {
	w, err := globalTierConfigMgr.getDriver(ctx, tierName)
	if err != nil {
		return err
	}
	return w.Remove(ctx, objName, remoteVersionID(rvID))

}

func (n newerNoncurrentTask) OpHash() uint64 {
	return xxh3.HashString(n.bucket + n.versions[0].ObjectV.ObjectName)
}

func (j jentry) OpHash() uint64 {
	return xxh3.HashString(j.TierName + j.ObjName)
}

func (e expiryTask) OpHash() uint64 {
	return xxh3.HashString(e.objInfo.Bucket + e.objInfo.Name)
}

// expiryState manages all ILM related expiration activities.
type expiryState struct {