[PATCH 2/2] xenbus: Rename helpers to freeze/thaw/restore

[Jason Andryuk <jason.andryuk@xxxxxxx>]

Rename the xenbus helpers called from the .freeze, .thaw, and .restore
pm ops to have matching names.

Signed-off-by: Jason Andryuk <jason.andryuk@xxxxxxx>
---
We could continue renaming and change struct xenbus_driver
.suspend/.resume to .freeze/.restore.  Thereis only the single callback,
and it would be more churn, so I did not do it.
---
 drivers/xen/xenbus/xenbus.h                |  6 +++---
 drivers/xen/xenbus/xenbus_probe.c          | 22 +++++++++++-----------
 drivers/xen/xenbus/xenbus_probe_frontend.c | 16 ++++++++--------
 3 files changed, 22 insertions(+), 22 deletions(-)

diff --git a/drivers/xen/xenbus/xenbus.h b/drivers/xen/xenbus/xenbus.h
index 9ac0427724a3..daba7f5e05c4 100644
--- 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
index 86fe6e779056..9f9011cd7447 100644
--- 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
index 199917b6f77c..f04707d1f667 100644
--- 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 = {
-- 
2.34.1