Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
xenbus: Rename helpers to freeze/thaw/restore
Rename the xenbus helpers called from the .freeze, .thaw, and .restore
pm ops to have matching names.
Signed-off-by: Jason Andryuk <jason.andryuk@amd.com>
Reviewed-by: Juergen Gross <jgross@suse.com>
Signed-off-by: Juergen Gross <jgross@suse.com>
Message-ID: <20251119224731.61497-3-jason.andryuk@amd.com>
authored by
Jason Andryuk
and committed by
Juergen Gross
c307b6dc
e08dd1ee
+22
-22
+3
-3
drivers/xen/xenbus/xenbus.h
+3
-3
drivers/xen/xenbus/xenbus.h
···
120
120
121
121
void xenbus_dev_changed(const char *node, struct xen_bus_type *bus);
122
122
123
-
int xenbus_dev_suspend(struct device *dev);
124
-
int xenbus_dev_resume(struct device *dev);
125
-
int xenbus_dev_cancel(struct device *dev);
123
+
int xenbus_dev_freeze(struct device *dev);
124
+
int xenbus_dev_restore(struct device *dev);
125
+
int xenbus_dev_thaw(struct device *dev);
126
126
127
127
void xenbus_otherend_changed(struct xenbus_watch *watch,
128
128
const char *path, const char *token,
+11
-11
drivers/xen/xenbus/xenbus_probe.c
+11
-11
drivers/xen/xenbus/xenbus_probe.c
···
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
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
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
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;
+8
-8
drivers/xen/xenbus/xenbus_probe_frontend.c
+8
-8
drivers/xen/xenbus/xenbus_probe_frontend.c
···
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
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
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 = {