Use remove and probe hooks rather than extra suspend and resume hooks for
acceleration
Signed-off-by <kmansley@xxxxxxxxxxxxxx>
diff -r bf4201f8be4e drivers/xen/netfront/accel.c
--- a/drivers/xen/netfront/accel.c Mon Oct 29 16:48:42 2007 +0000
+++ b/drivers/xen/netfront/accel.c Tue Oct 30 13:21:29 2007 +0000
@@ -118,9 +118,9 @@ static void add_accelerator_vif(struct n
list_add(&np->accel_vif_state.link, &accelerator->vif_states);
} else {
/*
- * May get here legitimately if reconnecting to the
- * same accelerator, eg. after resume, so check that
- * is the case
+ * May get here legitimately if suspend_cancel is
+ * called, but in that case configuration should not
+ * have changed
*/
BUG_ON(np->accelerator != accelerator);
}
@@ -313,7 +313,7 @@ static void
static void
accelerator_probe_vifs(struct netfront_accelerator *accelerator,
struct netfront_accel_hooks *hooks,
- unsigned lock_flags)
+ unsigned *lock_flags)
{
struct netfront_accel_vif_state *vif_state, *tmp;
@@ -349,14 +349,15 @@ accelerator_probe_vifs(struct netfront_a
* protected by the kref
*/
spin_unlock_irqrestore(&accelerator->vif_states_lock,
- lock_flags);
+ (*lock_flags));
hooks->new_device(np->netdev, vif_state->dev);
kref_put(&accelerator->accel_kref, accel_kref_release);
/* Retake lock for next go round the loop */
- spin_lock_irqsave(&accelerator->vif_states_lock,
lock_flags);
+ spin_lock_irqsave(&accelerator->vif_states_lock,
+ (*lock_flags));
/*
* Hooks will get linked into vif_state by a call to
@@ -391,7 +392,7 @@ accelerator_probe_vifs_on_load(struct ne
if (accelerator->ready_for_probe) {
accelerator->ready_for_probe = 0;
- accelerator_probe_vifs(accelerator, hooks, flags);
+ accelerator_probe_vifs(accelerator, hooks, &flags);
} else {
if (accelerator->need_probe)
DPRINTK("Probe request on accelerator awaiting
probe\n");
@@ -526,8 +527,7 @@ accelerator_remove_single_hook(struct ne
/*
* Safely remove the accelerator function hooks from a netfront state.
*/
-static void accelerator_remove_hooks(struct netfront_accelerator *accelerator,
- int remove_master)
+static void accelerator_remove_hooks(struct netfront_accelerator *accelerator)
{
struct netfront_accel_hooks *hooks;
struct netfront_accel_vif_state *vif_state, *tmp;
@@ -538,31 +538,33 @@ static void accelerator_remove_hooks(str
list_for_each_entry_safe(vif_state, tmp,
&accelerator->vif_states,
link) {
+ BUG_ON(vif_state->hooks == NULL);
hooks = vif_state->hooks;
accelerator_remove_single_hook(accelerator, vif_state);
- /*
- * Remove the reference taken when the vif_state hooks
- * were set, must be called without lock held
- */
+ /*
+ * Tell accelerator that this device is being removed,
+ * and remove the reference taken when the vif_state
+ * hooks were set; both must be called without lock
+ * held
+ */
spin_unlock_irqrestore(&accelerator->vif_states_lock, flags);
/* Last chance to get statistics from the accelerator */
hooks->get_stats(vif_state->np->netdev, &vif_state->np->stats);
+ hooks->remove(vif_state->dev);
kref_put(&vif_state->vif_kref, vif_kref_release);
spin_lock_irqsave(&accelerator->vif_states_lock, flags);
}
- if(remove_master)
- accelerator->hooks = NULL;
+ accelerator->hooks = NULL;
spin_unlock_irqrestore(&accelerator->vif_states_lock, flags);
- if(remove_master)
- /* Remove the reference taken when module loaded */
- kref_put(&accelerator->accel_kref, accel_kref_release);
+ /* Remove the reference taken when module loaded */
+ kref_put(&accelerator->accel_kref, accel_kref_release);
}
@@ -571,7 +573,7 @@ static void accelerator_remove_hooks(str
* removes the hooks into the plugin and blocks until all devices have
* finished using it, so on return it is safe to unload.
*/
-void netfront_accelerator_stop(const char *frontend, int unloading)
+void netfront_accelerator_stop(const char *frontend)
{
struct netfront_accelerator *accelerator;
unsigned flags;
@@ -588,11 +590,10 @@ void netfront_accelerator_stop(const cha
*/
sema_init(&accelerator->exit_semaphore, 0);
- accelerator_remove_hooks(accelerator, unloading);
-
- if (unloading)
- /* Wait for hooks to be unused, then return */
- down(&accelerator->exit_semaphore);
+ accelerator_remove_hooks(accelerator);
+
+ /* Wait for hooks to be unused, then return */
+ down(&accelerator->exit_semaphore);
return;
}
@@ -606,9 +607,12 @@ int netfront_check_accelerator_queue_bus
int netfront_check_accelerator_queue_busy(struct net_device *dev,
struct netfront_info *np)
{
+ struct netfront_accelerator *accelerator;
struct netfront_accel_hooks *hooks;
int rc = 1;
unsigned flags;
+
+ accelerator = np->accelerator;
/*
* Call the check busy accelerator hook. The use count for the
@@ -616,6 +620,212 @@ int netfront_check_accelerator_queue_bus
* call to prevent the accelerator being able to modify the
* hooks in the middle (by, for example, unloading)
*/
+ if (np->accel_vif_state.hooks && accelerator) {
+ spin_lock_irqsave(&accelerator->vif_states_lock, flags);
+ hooks = np->accel_vif_state.hooks;
+ if (hooks && np->accelerator == accelerator) {
+ kref_get(&np->accel_vif_state.vif_kref);
+ spin_unlock_irqrestore
+ (&accelerator->vif_states_lock, flags);
+
+ rc = np->accel_vif_state.hooks->check_busy(dev);
+
+ kref_put(&np->accel_vif_state.vif_kref,
+ vif_kref_release);
+ } else {
+ spin_unlock_irqrestore
+ (&accelerator->vif_states_lock, flags);
+ }
+ }
+
+ return rc;
+}
+
+
+/* Helper for call_remove and do_suspend */
+static int do_remove(struct netfront_info *np, struct xenbus_device *dev,
+ unsigned lock_flags, int clear_accelerator)
+{
+ struct netfront_accelerator *accelerator = np->accelerator;
+ struct netfront_accel_hooks *hooks;
+ unsigned flags;
+ int rc = 0;
+
+ if(clear_accelerator)
+ np->accelerator = NULL;
+
+ if (np->accel_vif_state.hooks) {
+ hooks = np->accel_vif_state.hooks;
+
+ /*
+ * Try and do the opposite of accelerator_probe_new_vif
+ * to ensure there's no state pointing back at the
+ * netdev
+ */
+ accelerator_remove_single_hook(accelerator,
+ &np->accel_vif_state);
+
+ spin_unlock_irqrestore(&accelerator->vif_states_lock,
+ lock_flags);
+
+ /*
+ * No need to do kref_get before calling these hooks as we
+ * can borrow the one we have to drop after this call
+ */
+
+ /* Last chance to get statistics from the accelerator */
+ hooks->get_stats(np->netdev, &np->stats);
+
+ rc = hooks->remove(dev);
+
+ /*
+ * Remove the reference taken when the vif_state hooks
+ * were set, must be called without lock held
+ */
+ kref_put(&np->accel_vif_state.vif_kref, vif_kref_release);
+ } else {
+ spin_unlock_irqrestore(&accelerator->vif_states_lock,
+ lock_flags);
+ }
+
+
+ return rc;
+}
+
+
+int netfront_accelerator_call_remove(struct netfront_info *np,
+ struct xenbus_device *dev)
+{
+ struct netfront_accel_vif_state *tmp_vif_state;
+ unsigned flags;
+
+ /* Check that we've got a device that was accelerated */
+ if (np->accelerator == NULL)
+ return 0;
+
+ spin_lock_irqsave(&np->accelerator->vif_states_lock, flags);
+
+ list_for_each_entry(tmp_vif_state, &np->accelerator->vif_states,
+ link) {
+ if (tmp_vif_state == &np->accel_vif_state) {
+ list_del(&np->accel_vif_state.link);
+ break;
+ }
+ }
+
+ /* do_remove drops the lock for us */
+ return do_remove(np, dev, flags, 1);
+}
+
+
+int netfront_accelerator_suspend(struct netfront_info *np,
+ struct xenbus_device *dev)
+{
+ unsigned flags;
+
+
+ /* Check that we've got a device that was accelerated */
+ if (np->accelerator == NULL)
+ return 0;
+
+ /*
+ * Call the remove accelerator hook, but leave the vif_state
+ * on the accelerator's list in case there is a suspend_cancel.
+ */
+ spin_lock_irqsave(&np->accelerator->vif_states_lock,
+ flags);
+
+ /* do_remove drops the lock for us */
+ return do_remove(np, dev, flags, 0);
+}
+
+
+int netfront_accelerator_suspend_cancel(struct netfront_info *np,
+ struct xenbus_device *dev)
+{
+ struct netfront_accel_vif_state *accel_vif_state = NULL;
+ unsigned flags1, flags2;
+
+ /* Check that we've got a device that was accelerated */
+ if (np->accelerator == NULL)
+ return 0;
+
+ spin_lock_irqsave(&np->accelerator->vif_states_lock, flags);
+ /* Find the vif_state from the accelerator's list */
+ list_for_each_entry(accel_vif_state, &np->accelerator->vif_states,
+ link) {
+ if (accel_vif_state->dev == dev) {
+ BUG_ON(accel_vif_state != &np->accel_vif_state);
+
+
spin_unlock_irqrestore(&np->accelerator->vif_states_lock,
+ flags);
+
+ /*
+ * Kick things off again to restore
+ * acceleration as it was before suspend
+ */
+ accelerator_probe_new_vif(np, dev, np->accelerator);
+
+ return 0;
+ }
+ }
+
+ spin_unlock_irqrestore(&np->accelerator->vif_states_lock, flags);
+
+ return 0;
+}
+
+
+void netfront_accelerator_resume(struct netfront_info *np,
+ struct xenbus_device *dev)
+{
+ struct netfront_accel_vif_state *accel_vif_state = NULL;
+ spinlock_t *vif_states_lock;
+ unsigned flags;
+
+ /* Check that we've got a device that was accelerated */
+ if(np->accelerator == NULL)
+ return;
+
+ spin_lock_irqsave(&np->accelerator->vif_states_lock, flags);
+
+ /* Find the vif_state from the accelerator's list */
+ list_for_each_entry(accel_vif_state, &np->accelerator->vif_states,
+ link) {
+ if (accel_vif_state->dev == dev) {
+ BUG_ON(accel_vif_state != &np->accel_vif_state);
+
+ /*
+ * Remove it from the accelerator's list so
+ * state is consistent for probing new vifs
+ * when they get connected
+ */
+ list_del(&accel_vif_state->link);
+ vif_states_lock = &np->accelerator->vif_states_lock;
+ np->accelerator = NULL;
+
+ spin_unlock_irqrestore(vif_states_lock, flags);
+
+ return;
+ }
+ }
+ spin_unlock_irqrestore(&np->accelerator->vif_states_lock, flags);
+}
+
+
+void netfront_accelerator_call_backend_changed(struct netfront_info *np,
+ struct xenbus_device *dev,
+ enum xenbus_state backend_state)
+{
+ struct netfront_accel_hooks *hooks;
+ unsigned flags;
+
+ /*
+ * Call the backend_changed accelerator hook. The use count
+ * for the accelerator's hooks is incremented for the duration
+ * of the call to prevent the accelerator being able to modify
+ * the hooks in the middle (by, for example, unloading)
+ */
if (np->accel_vif_state.hooks) {
spin_lock_irqsave(&np->accelerator->vif_states_lock, flags);
hooks = np->accel_vif_state.hooks;
@@ -624,8 +834,9 @@ int netfront_check_accelerator_queue_bus
spin_unlock_irqrestore
(&np->accelerator->vif_states_lock, flags);
- rc = np->accel_vif_state.hooks->check_busy(dev);
-
+ np->accel_vif_state.hooks->backend_changed
+ (dev, backend_state);
+
kref_put(&np->accel_vif_state.vif_kref,
vif_kref_release);
} else {
@@ -633,227 +844,17 @@ int netfront_check_accelerator_queue_bus
(&np->accelerator->vif_states_lock, flags);
}
}
-
- return rc;
-}
-
-
-int netfront_accelerator_call_remove(struct netfront_info *np,
- struct xenbus_device *dev)
-{
- struct netfront_accelerator *accelerator = np->accelerator;
- struct netfront_accel_vif_state *tmp_vif_state;
- struct netfront_accel_hooks *hooks;
- unsigned flags;
- int rc = 0;
-
- /*
- * Call the remove accelerator hook. The use count for the
- * accelerator's hooks is incremented for the duration of the
- * call to prevent the accelerator being able to modify the
- * hooks in the middle (by, for example, unloading)
- */
- spin_lock_irqsave(&np->accelerator->vif_states_lock, flags);
- hooks = np->accel_vif_state.hooks;
-
- /*
- * Remove this vif_state from the accelerator's list
- */
- list_for_each_entry(tmp_vif_state, &accelerator->vif_states, link) {
- if (tmp_vif_state == &np->accel_vif_state) {
- list_del(&np->accel_vif_state.link);
- break;
- }
- }
-
- if (hooks) {
- kref_get(&np->accel_vif_state.vif_kref);
- spin_unlock_irqrestore
- (&np->accelerator->vif_states_lock, flags);
- /* Last chance to get statistics from the accelerator */
- vif_state->hooks->get_stats(np->netdev, &np->stats);
- rc = np->accel_vif_state.hooks->remove(dev);
-
- kref_put(&np->accel_vif_state.vif_kref,
- vif_kref_release);
-
- spin_lock_irqsave(&np->accelerator->vif_states_lock,
- flags);
-
- /*
- * Try and do the opposite of accelerator_probe_new_vif
- * to ensure there's no state pointing back at the
- * netdev
- */
- accelerator_remove_single_hook(accelerator,
- &np->accel_vif_state);
-
- /*
- * Remove the reference taken when the vif_state hooks
- * were set, must be called without lock held
- */
- spin_unlock_irqrestore(&accelerator->vif_states_lock,
- flags);
- kref_put(&np->accel_vif_state.vif_kref,
- vif_kref_release);
- } else {
- spin_unlock_irqrestore(&np->accelerator->vif_states_lock,
- flags);
- }
-
- return rc;
-}
-
-
-int netfront_accelerator_call_suspend(struct netfront_info *np,
- struct xenbus_device *dev)
-{
- struct netfront_accel_hooks *hooks;
- unsigned flags;
- int rc = 0;
-
- IPRINTK("netfront_accelerator_call_suspend\n");
-
- /*
- * Call the suspend accelerator hook. The use count for the
- * accelerator's hooks is incremented for the duration of
- * the call to prevent the accelerator being able to modify
- * the hooks in the middle (by, for example, unloading)
- */
- if (np->accel_vif_state.hooks) {
- spin_lock_irqsave(&np->accelerator->vif_states_lock, flags);
- hooks = np->accel_vif_state.hooks;
- if (hooks) {
- kref_get(&np->accel_vif_state.vif_kref);
- spin_unlock_irqrestore
- (&np->accelerator->vif_states_lock, flags);
-
- /* Last chance to get stats from the accelerator */
- np->accel_vif_state.hooks->get_stats(dev, &np->stats);
-
- rc = np->accel_vif_state.hooks->suspend(dev);
-
- kref_put(&np->accel_vif_state.vif_kref,
- vif_kref_release);
- } else {
- spin_unlock_irqrestore
- (&np->accelerator->vif_states_lock, flags);
- }
- }
- return rc;
-}
-
-
-int netfront_accelerator_call_suspend_cancel(struct netfront_info *np,
- struct xenbus_device *dev)
-{
- struct netfront_accel_hooks *hooks;
- unsigned flags;
- int rc = 0;
-
- IPRINTK(" netfront_accelerator_call_suspend_cancel\n");
-
- /*
- * Call the suspend_cancel accelerator hook. The use count
- * for the accelerator's hooks is incremented for the
- * duration of the call to prevent the accelerator being able
- * to modify the hooks in the middle (by, for example,
- * unloading)
- */
- if (np->accel_vif_state.hooks) {
- spin_lock_irqsave(&np->accelerator->vif_states_lock, flags);
- hooks = np->accel_vif_state.hooks;
- if (hooks) {
- kref_get(&np->accel_vif_state.vif_kref);
- spin_unlock_irqrestore
- (&np->accelerator->vif_states_lock, flags);
-
- rc = np->accel_vif_state.hooks->suspend_cancel(dev);
-
- kref_put(&np->accel_vif_state.vif_kref,
- vif_kref_release);
- } else {
- spin_unlock_irqrestore
- (&np->accelerator->vif_states_lock, flags);
- }
- }
- return rc;
-}
-
-
-int netfront_accelerator_call_resume(struct netfront_info *np,
- struct xenbus_device *dev)
-{
- struct netfront_accel_hooks *hooks;
- unsigned flags;
- int rc = 0;
-
- /*
- * Call the resume accelerator hook. The use count for the
- * accelerator's hooks is incremented for the duration of
- * the call to prevent the accelerator being able to modify
- * the hooks in the middle (by, for example, unloading)
- */
- if (np->accel_vif_state.hooks) {
- spin_lock_irqsave(&np->accelerator->vif_states_lock, flags);
- hooks = np->accel_vif_state.hooks;
- if (hooks) {
- kref_get(&np->accel_vif_state.vif_kref);
- spin_unlock_irqrestore
- (&np->accelerator->vif_states_lock, flags);
-
- rc = np->accel_vif_state.hooks->resume(dev);
-
- kref_put(&np->accel_vif_state.vif_kref,
- vif_kref_release);
- } else {
- spin_unlock_irqrestore
- (&np->accelerator->vif_states_lock, flags);
- }
- }
- return rc;
-}
-
-
-void netfront_accelerator_call_backend_changed(struct netfront_info *np,
- struct xenbus_device *dev,
- enum xenbus_state backend_state)
-{
- struct netfront_accel_hooks *hooks;
- unsigned flags;
-
- /*
- * Call the backend_changed accelerator hook. The use count
- * for the accelerator's hooks is incremented for the duration
- * of the call to prevent the accelerator being able to modify
- * the hooks in the middle (by, for example, unloading)
- */
- if (np->accel_vif_state.hooks) {
- spin_lock_irqsave(&np->accelerator->vif_states_lock, flags);
- hooks = np->accel_vif_state.hooks;
- if (hooks) {
- kref_get(&np->accel_vif_state.vif_kref);
- spin_unlock_irqrestore
- (&np->accelerator->vif_states_lock, flags);
-
- np->accel_vif_state.hooks->backend_changed
- (dev, backend_state);
-
- kref_put(&np->accel_vif_state.vif_kref,
- vif_kref_release);
- } else {
- spin_unlock_irqrestore
- (&np->accelerator->vif_states_lock, flags);
- }
- }
}
void netfront_accelerator_call_stop_napi_irq(struct netfront_info *np,
struct net_device *dev)
{
+ struct netfront_accelerator *accelerator;
struct netfront_accel_hooks *hooks;
unsigned flags;
+
+ accelerator = np->accelerator;
/*
* Call the stop_napi_interrupts accelerator hook. The use
@@ -863,13 +864,13 @@ void netfront_accelerator_call_stop_napi
* unloading)
*/
- if (np->accel_vif_state.hooks) {
- spin_lock_irqsave(&np->accelerator->vif_states_lock, flags);
+ if (np->accel_vif_state.hooks && accelerator != NULL) {
+ spin_lock_irqsave(&accelerator->vif_states_lock, flags);
hooks = np->accel_vif_state.hooks;
- if (hooks) {
+ if (hooks && np->accelerator == accelerator) {
kref_get(&np->accel_vif_state.vif_kref);
spin_unlock_irqrestore
- (&np->accelerator->vif_states_lock, flags);
+ (&accelerator->vif_states_lock, flags);
np->accel_vif_state.hooks->stop_napi_irq(dev);
@@ -877,7 +878,7 @@ void netfront_accelerator_call_stop_napi
vif_kref_release);
} else {
spin_unlock_irqrestore
- (&np->accelerator->vif_states_lock, flags);
+ (&accelerator->vif_states_lock, flags);
}
}
}
@@ -886,9 +887,12 @@ int netfront_accelerator_call_get_stats(
int netfront_accelerator_call_get_stats(struct netfront_info *np,
struct net_device *dev)
{
+ struct netfront_accelerator *accelerator;
struct netfront_accel_hooks *hooks;
unsigned flags;
int rc = 0;
+
+ accelerator = np->accelerator;
/*
* Call the get_stats accelerator hook. The use count for the
@@ -897,13 +901,13 @@ int netfront_accelerator_call_get_stats(
* hooks in the middle (by, for example, unloading)
*/
- if (np->accel_vif_state.hooks) {
- spin_lock_irqsave(&np->accelerator->vif_states_lock, flags);
+ if (np->accel_vif_state.hooks && accelerator != NULL) {
+ spin_lock_irqsave(accelerator->vif_states_lock, flags);
hooks = np->accel_vif_state.hooks;
- if (hooks) {
+ if (hooks && np->accelerator == accelerator) {
kref_get(&np->accel_vif_state.vif_kref);
spin_unlock_irqrestore
- (&np->accelerator->vif_states_lock, flags);
+ (&accelerator->vif_states_lock, flags);
rc = np->accel_vif_state.hooks->get_stats(dev,
&np->stats);
@@ -912,7 +916,7 @@ int netfront_accelerator_call_get_stats(
vif_kref_release);
} else {
spin_unlock_irqrestore
- (&np->accelerator->vif_states_lock, flags);
+ (&accelerator->vif_states_lock, flags);
}
}
return rc;
@@ -939,7 +943,7 @@ static void accel_kref_release(struct kr
if (accelerator->need_probe) {
hooks = accelerator->need_probe;
accelerator->need_probe = NULL;
- accelerator_probe_vifs(accelerator, hooks, flags);
+ accelerator_probe_vifs(accelerator, hooks, &flags);
}
else
accelerator->ready_for_probe = 1;
diff -r bf4201f8be4e drivers/xen/netfront/netfront.c
--- a/drivers/xen/netfront/netfront.c Mon Oct 29 16:48:42 2007 +0000
+++ b/drivers/xen/netfront/netfront.c Tue Oct 30 13:21:29 2007 +0000
@@ -308,14 +308,14 @@ static int netfront_suspend(struct xenbu
static int netfront_suspend(struct xenbus_device *dev)
{
struct netfront_info *info = dev->dev.driver_data;
- return netfront_accelerator_call_suspend(info, dev);
+ return netfront_accelerator_suspend(info, dev);
}
static int netfront_suspend_cancel(struct xenbus_device *dev)
{
struct netfront_info *info = dev->dev.driver_data;
- return netfront_accelerator_call_suspend_cancel(info, dev);
+ return netfront_accelerator_suspend_cancel(info, dev);
}
@@ -331,7 +331,7 @@ static int netfront_resume(struct xenbus
DPRINTK("%s\n", dev->nodename);
- netfront_accelerator_call_resume(info, dev);
+ netfront_accelerator_resume(info, dev);
netif_disconnect_backend(info);
return 0;
@@ -1507,7 +1507,7 @@ err:
* fast path is likewise
*/
accel_more_to_do =
- np->accel_vif_state.hooks->start_napi_irq(dev);
+ np->accel_vif_state.hooks->start_napi_irq(dev);
}
if (!more_to_do && !accel_more_to_do)
diff -r bf4201f8be4e drivers/xen/netfront/netfront.h
--- a/drivers/xen/netfront/netfront.h Mon Oct 29 16:48:42 2007 +0000
+++ b/drivers/xen/netfront/netfront.h Tue Oct 30 13:21:29 2007 +0000
@@ -60,12 +60,8 @@ struct netfront_accel_hooks {
*/
int (*new_device)(struct net_device *net_dev, struct xenbus_device
*dev);
/*
- * suspend, suspend_cancel, resume, remove: Equivalent to the
- * normal xenbus_* callbacks
- */
- int (*suspend)(struct xenbus_device *dev);
- int (*suspend_cancel)(struct xenbus_device *dev);
- int (*resume)(struct xenbus_device *dev);
+ * remove: Opposite of new_device
+ */
int (*remove)(struct xenbus_device *dev);
/*
* backend_changed: Callback from watch based on backend's
@@ -256,11 +252,8 @@ extern void netfront_accelerator_ready(c
*
* frontend: the string describing the accelerator. Must match the
* one passed to netfront_accelerator_loaded()
- *
- * wait: 1 => wait for all users of module to complete before
- * returning, thus making it safe to unload on return
*/
-extern void netfront_accelerator_stop(const char *frontend, int wait);
+extern void netfront_accelerator_stop(const char *frontend);
/*
* Called by an accelerator before waking the net device's TX queue to
@@ -285,14 +278,14 @@ int netfront_accelerator_call_remove(str
int netfront_accelerator_call_remove(struct netfront_info *np,
struct xenbus_device *dev);
extern
-int netfront_accelerator_call_suspend(struct netfront_info *np,
- struct xenbus_device *dev);
-extern
-int netfront_accelerator_call_suspend_cancel(struct netfront_info *np,
- struct xenbus_device *dev);
-extern
-int netfront_accelerator_call_resume(struct netfront_info *np,
- struct xenbus_device *dev);
+int netfront_accelerator_suspend(struct netfront_info *np,
+ struct xenbus_device *dev);
+extern
+int netfront_accelerator_suspend_cancel(struct netfront_info *np,
+ struct xenbus_device *dev);
+extern
+void netfront_accelerator_resume(struct netfront_info *np,
+ struct xenbus_device *dev);
extern
void netfront_accelerator_call_backend_changed(struct netfront_info *np,
struct xenbus_device *dev,
netfront_accel_suspend
Description: Text document
_______________________________________________
Xen-devel mailing list
Xen-devel@xxxxxxxxxxxxxxxxxxx
http://lists.xensource.com/xen-devel
|
Home