xenbus: Rename helpers to freeze/thaw/restore

jandryuk · jgross1 · commit c307b6dc9c4f · 2026-02-02T07:45:37.000+01:00
Rename the xenbus helpers called from the .freeze, .thaw, and .restore
pm ops to have matching names.

Signed-off-by: Jason Andryuk &lt;jason.andryuk@amd.com&gt;
Reviewed-by: Juergen Gross &lt;jgross@suse.com&gt;
Signed-off-by: Juergen Gross &lt;jgross@suse.com&gt;
Message-ID: &lt;20251119224731.61497-3-jason.andryuk@amd.com&gt;
diff --git a/drivers/xen/xenbus/xenbus.h b/drivers/xen/xenbus/xenbus.h
@@ -120,9 +120,9 @@ int xenbus_probe_devices(struct xen_bus_type *bus);
 
 void xenbus_dev_changed(const char *node, struct xen_bus_type *bus);
 
-int xenbus_dev_suspend(struct device *dev);
-int xenbus_dev_resume(struct device *dev);
-int xenbus_dev_cancel(struct device *dev);
+int xenbus_dev_freeze(struct device *dev);
+int xenbus_dev_restore(struct device *dev);
+int xenbus_dev_thaw(struct device *dev);
 
 void xenbus_otherend_changed(struct xenbus_watch *watch,
 			     const char *path, const char *token,
diff --git a/drivers/xen/xenbus/xenbus_probe.c b/drivers/xen/xenbus/xenbus_probe.c
@@ -668,7 +668,7 @@ void xenbus_dev_changed(const char *node, struct xen_bus_type *bus)
 }
 EXPORT_SYMBOL_GPL(xenbus_dev_changed);
 
-int xenbus_dev_suspend(struct device *dev)
+int xenbus_dev_freeze(struct device *dev)
 {
 	int err = 0;
 	struct xenbus_driver *drv;
@@ -683,12 +683,12 @@ int xenbus_dev_suspend(struct device *dev)
 	if (drv->suspend)
 		err = drv->suspend(xdev);
 	if (err)
-		dev_warn(dev, "suspend failed: %i\n", err);
+		dev_warn(dev, "freeze failed: %i\n", err);
 	return 0;
 }
-EXPORT_SYMBOL_GPL(xenbus_dev_suspend);
+EXPORT_SYMBOL_GPL(xenbus_dev_freeze);
 
-int xenbus_dev_resume(struct device *dev)
+int xenbus_dev_restore(struct device *dev)
 {
 	int err;
 	struct xenbus_driver *drv;
@@ -702,7 +702,7 @@ int xenbus_dev_resume(struct device *dev)
 	drv = to_xenbus_driver(dev->driver);
 	err = talk_to_otherend(xdev);
 	if (err) {
-		dev_warn(dev, "resume (talk_to_otherend) failed: %i\n", err);
+		dev_warn(dev, "restore (talk_to_otherend) failed: %i\n", err);
 		return err;
 	}
 
@@ -711,28 +711,28 @@ int xenbus_dev_resume(struct device *dev)
 	if (drv->resume) {
 		err = drv->resume(xdev);
 		if (err) {
-			dev_warn(dev, "resume failed: %i\n", err);
+			dev_warn(dev, "restore failed: %i\n", err);
 			return err;
 		}
 	}
 
 	err = watch_otherend(xdev);
 	if (err) {
-		dev_warn(dev, "resume (watch_otherend) failed: %d\n", err);
+		dev_warn(dev, "restore (watch_otherend) failed: %d\n", err);
 		return err;
 	}
 
 	return 0;
 }
-EXPORT_SYMBOL_GPL(xenbus_dev_resume);
+EXPORT_SYMBOL_GPL(xenbus_dev_restore);
 
-int xenbus_dev_cancel(struct device *dev)
+int xenbus_dev_thaw(struct device *dev)
 {
 	/* Do nothing */
-	DPRINTK("cancel");
+	DPRINTK("thaw");
 	return 0;
 }
-EXPORT_SYMBOL_GPL(xenbus_dev_cancel);
+EXPORT_SYMBOL_GPL(xenbus_dev_thaw);
 
 /* A flag to determine if xenstored is 'ready' (i.e. has started) */
 int xenstored_ready;
diff --git a/drivers/xen/xenbus/xenbus_probe_frontend.c b/drivers/xen/xenbus/xenbus_probe_frontend.c
@@ -91,14 +91,14 @@ static void backend_changed(struct xenbus_watch *watch,
 	xenbus_otherend_changed(watch, path, token, 1);
 }
 
-static void xenbus_frontend_delayed_resume(struct work_struct *w)
+static void xenbus_frontend_delayed_restore(struct work_struct *w)
 {
 	struct xenbus_device *xdev = container_of(w, struct xenbus_device, work);
 
-	xenbus_dev_resume(&xdev->dev);
+	xenbus_dev_restore(&xdev->dev);
 }
 
-static int xenbus_frontend_dev_resume(struct device *dev)
+static int xenbus_frontend_dev_restore(struct device *dev)
 {
 	/*
 	 * If xenstored is running in this domain, we cannot access the backend
@@ -112,14 +112,14 @@ static int xenbus_frontend_dev_resume(struct device *dev)
 		return 0;
 	}
 
-	return xenbus_dev_resume(dev);
+	return xenbus_dev_restore(dev);
 }
 
 static int xenbus_frontend_dev_probe(struct device *dev)
 {
 	if (xen_store_domain_type == XS_LOCAL) {
 		struct xenbus_device *xdev = to_xenbus_device(dev);
-		INIT_WORK(&xdev->work, xenbus_frontend_delayed_resume);
+		INIT_WORK(&xdev->work, xenbus_frontend_delayed_restore);
 	}
 
 	return xenbus_dev_probe(dev);
@@ -148,9 +148,9 @@ static void xenbus_frontend_dev_shutdown(struct device *_dev)
 }
 
 static const struct dev_pm_ops xenbus_pm_ops = {
-	.freeze		= xenbus_dev_suspend,
-	.thaw		= xenbus_dev_cancel,
-	.restore	= xenbus_frontend_dev_resume,
+	.freeze		= xenbus_dev_freeze,
+	.thaw		= xenbus_dev_thaw,
+	.restore	= xenbus_frontend_dev_restore,
 };
 
 static struct xen_bus_type xenbus_frontend = {

Original file line number	Diff line number	Diff line change
`@@ -668,7 +668,7 @@ void xenbus_dev_changed(const char node, struct xen_bus_type bus)`
`668`	`668`	`}`
`669`	`669`	`EXPORT_SYMBOL_GPL(xenbus_dev_changed);`
`670`	`670`
`671`		`-int xenbus_dev_suspend(struct device *dev)`
	`671`	`+int xenbus_dev_freeze(struct device *dev)`
`672`	`672`	`{`
`673`	`673`	`int err = 0;`
`674`	`674`	`struct xenbus_driver *drv;`
`@@ -683,12 +683,12 @@ int xenbus_dev_suspend(struct device *dev)`
`683`	`683`	`if (drv->suspend)`
`684`	`684`	`err = drv->suspend(xdev);`
`685`	`685`	`if (err)`
`686`		`- dev_warn(dev, "suspend failed: %i\n", err);`
	`686`	`+ dev_warn(dev, "freeze failed: %i\n", err);`
`687`	`687`	`return 0;`
`688`	`688`	`}`
`689`		`-EXPORT_SYMBOL_GPL(xenbus_dev_suspend);`
	`689`	`+EXPORT_SYMBOL_GPL(xenbus_dev_freeze);`
`690`	`690`
`691`		`-int xenbus_dev_resume(struct device *dev)`
	`691`	`+int xenbus_dev_restore(struct device *dev)`
`692`	`692`	`{`
`693`	`693`	`int err;`
`694`	`694`	`struct xenbus_driver *drv;`
`@@ -702,7 +702,7 @@ int xenbus_dev_resume(struct device *dev)`
`702`	`702`	`drv = to_xenbus_driver(dev->driver);`
`703`	`703`	`err = talk_to_otherend(xdev);`
`704`	`704`	`if (err) {`
`705`		`- dev_warn(dev, "resume (talk_to_otherend) failed: %i\n", err);`
	`705`	`+ dev_warn(dev, "restore (talk_to_otherend) failed: %i\n", err);`
`706`	`706`	`return err;`
`707`	`707`	`}`
`708`	`708`
`@@ -711,28 +711,28 @@ int xenbus_dev_resume(struct device *dev)`
`711`	`711`	`if (drv->resume) {`
`712`	`712`	`err = drv->resume(xdev);`
`713`	`713`	`if (err) {`
`714`		`- dev_warn(dev, "resume failed: %i\n", err);`
	`714`	`+ dev_warn(dev, "restore failed: %i\n", err);`
`715`	`715`	`return err;`
`716`	`716`	`}`
`717`	`717`	`}`
`718`	`718`
`719`	`719`	`err = watch_otherend(xdev);`
`720`	`720`	`if (err) {`
`721`		`- dev_warn(dev, "resume (watch_otherend) failed: %d\n", err);`
	`721`	`+ dev_warn(dev, "restore (watch_otherend) failed: %d\n", err);`
`722`	`722`	`return err;`
`723`	`723`	`}`
`724`	`724`
`725`	`725`	`return 0;`
`726`	`726`	`}`
`727`		`-EXPORT_SYMBOL_GPL(xenbus_dev_resume);`
	`727`	`+EXPORT_SYMBOL_GPL(xenbus_dev_restore);`
`728`	`728`
`729`		`-int xenbus_dev_cancel(struct device *dev)`
	`729`	`+int xenbus_dev_thaw(struct device *dev)`
`730`	`730`	`{`
`731`	`731`	`/* Do nothing */`
`732`		`- DPRINTK("cancel");`
	`732`	`+ DPRINTK("thaw");`
`733`	`733`	`return 0;`
`734`	`734`	`}`
`735`		`-EXPORT_SYMBOL_GPL(xenbus_dev_cancel);`
	`735`	`+EXPORT_SYMBOL_GPL(xenbus_dev_thaw);`
`736`	`736`
`737`	`737`	`/* A flag to determine if xenstored is 'ready' (i.e. has started) */`
`738`	`738`	`int xenstored_ready;`
Original file line number	Diff line number	Diff line change
`@@ -91,14 +91,14 @@ static void backend_changed(struct xenbus_watch *watch,`
`91`	`91`	`xenbus_otherend_changed(watch, path, token, 1);`
`92`	`92`	`}`
`93`	`93`
`94`		`-static void xenbus_frontend_delayed_resume(struct work_struct *w)`
	`94`	`+static void xenbus_frontend_delayed_restore(struct work_struct *w)`
`95`	`95`	`{`
`96`	`96`	`struct xenbus_device *xdev = container_of(w, struct xenbus_device, work);`
`97`	`97`
`98`		`- xenbus_dev_resume(&xdev->dev);`
	`98`	`+ xenbus_dev_restore(&xdev->dev);`
`99`	`99`	`}`
`100`	`100`
`101`		`-static int xenbus_frontend_dev_resume(struct device *dev)`
	`101`	`+static int xenbus_frontend_dev_restore(struct device *dev)`
`102`	`102`	`{`
`103`	`103`	`/*`
`104`	`104`	`* If xenstored is running in this domain, we cannot access the backend`
`@@ -112,14 +112,14 @@ static int xenbus_frontend_dev_resume(struct device *dev)`
`112`	`112`	`return 0;`
`113`	`113`	`}`
`114`	`114`
`115`		`- return xenbus_dev_resume(dev);`
	`115`	`+ return xenbus_dev_restore(dev);`
`116`	`116`	`}`
`117`	`117`
`118`	`118`	`static int xenbus_frontend_dev_probe(struct device *dev)`
`119`	`119`	`{`
`120`	`120`	`if (xen_store_domain_type == XS_LOCAL) {`
`121`	`121`	`struct xenbus_device *xdev = to_xenbus_device(dev);`
`122`		`- INIT_WORK(&xdev->work, xenbus_frontend_delayed_resume);`
	`122`	`+ INIT_WORK(&xdev->work, xenbus_frontend_delayed_restore);`
`123`	`123`	`}`
`124`	`124`
`125`	`125`	`return xenbus_dev_probe(dev);`
`@@ -148,9 +148,9 @@ static void xenbus_frontend_dev_shutdown(struct device *_dev)`
`148`	`148`	`}`
`149`	`149`
`150`	`150`	`static const struct dev_pm_ops xenbus_pm_ops = {`
`151`		`- .freeze = xenbus_dev_suspend,`
`152`		`- .thaw = xenbus_dev_cancel,`
`153`		`- .restore = xenbus_frontend_dev_resume,`
	`151`	`+ .freeze = xenbus_dev_freeze,`
	`152`	`+ .thaw = xenbus_dev_thaw,`
	`153`	`+ .restore = xenbus_frontend_dev_restore,`
`154`	`154`	`};`
`155`	`155`
`156`	`156`	`static struct xen_bus_type xenbus_frontend = {`