static void
inet_del_ifa(struct in_device *in_dev, struct in_ifaddr **ifap, int destroy)
{
struct in_ifaddr *ifa1 = *ifap;
ASSERT_RTNL();
/* 1. Deleting primary ifaddr forces deletion all secondaries */
if (!(ifa1->ifa_flags&IFA_F_SECONDARY)) {
struct in_ifaddr *ifa;
struct in_ifaddr **ifap1 = &ifa1->ifa_next;
while ((ifa=*ifap1) != NULL) {
if (!(ifa->ifa_flags&IFA_F_SECONDARY) ||
ifa1->ifa_mask != ifa->ifa_mask ||
!inet_ifa_match(ifa1->ifa_address, ifa)) {
ifap1 = &ifa->ifa_next;
continue;
}
write_lock_bh(&in_dev->lock);
*ifap1 = ifa->ifa_next;
write_unlock_bh(&in_dev->lock);
rtmsg_ifa(RTM_DELADDR, ifa);
notifier_call_chain(&inetaddr_chain, NETDEV_DOWN, ifa);
inet_free_ifa(ifa);
}
}
/* 2. Unlink it */
write_lock_bh(&in_dev->lock);
*ifap = ifa1->ifa_next;
write_unlock_bh(&in_dev->lock);
/* 3. Announce address deletion */
/* Send message first, then call notifier.
At first sight, FIB update triggered by notifier
will refer to already deleted ifaddr, that could confuse
netlink listeners. It is not true: look, gated sees
that route deleted and if it still thinks that ifaddr
is valid, it will try to restore deleted routes... Grr.
So that, this order is correct.
*/
rtmsg_ifa(RTM_DELADDR, ifa1);
notifier_call_chain(&inetaddr_chain, NETDEV_DOWN, ifa1);
if (destroy) {
inet_free_ifa(ifa1);
if (in_dev->ifa_list == NULL)
inetdev_destroy(in_dev);
}
}
static int
do_adb_reset_bus(void)
{
int ret, nret;
if (adb_controller == NULL)
return -ENXIO;
if (adb_controller->autopoll)
adb_controller->autopoll(0);
nret = notifier_call_chain(&adb_client_list, ADB_MSG_PRE_RESET, NULL);
if (nret & NOTIFY_STOP_MASK) {
if (adb_controller->autopoll)
adb_controller->autopoll(autopoll_devs);
return -EBUSY;
}
if (sleepy_trackpad) {
/* Let the trackpad settle down */
adb_wait_ms(500);
}
down(&adb_handler_sem);
write_lock_irq(&adb_handler_lock);
memset(adb_handler, 0, sizeof(adb_handler));
write_unlock_irq(&adb_handler_lock);
/* That one is still a bit synchronous, oh well... */
if (adb_controller->reset_bus)
ret = adb_controller->reset_bus();
else
ret = 0;
if (sleepy_trackpad) {
/* Let the trackpad settle down */
adb_wait_ms(1500);
}
if (!ret) {
autopoll_devs = adb_scan_bus();
if (adb_controller->autopoll)
adb_controller->autopoll(autopoll_devs);
}
up(&adb_handler_sem);
nret = notifier_call_chain(&adb_client_list, ADB_MSG_POST_RESET, NULL);
if (nret & NOTIFY_STOP_MASK)
return -EBUSY;
return ret;
}
int dev_open(struct device *dev)
{
int ret = -ENODEV;
/*
* Call device private open method
*/
if (dev->open)
ret = dev->open(dev);
/*
* If it went open OK then set the flags
*/
if (ret == 0)
{
dev->flags |= (IFF_UP | IFF_RUNNING);
/*
* Initialise multicasting status
*/
dev_mc_upload(dev);
notifier_call_chain(&netdev_chain, NETDEV_UP, dev);
}
return(ret);
}
/* 51 SIOCSIFMTU -- Set mtu of a network interface. */
error_t
S_iioctl_siocsifmtu (io_t port,
ifname_t ifnam,
int mtu)
{
struct sock_user *user = begin_using_socket_port (port);
error_t err = 0;
struct device *dev;
if (!user)
return EOPNOTSUPP;
dev = get_dev (ifnam);
if (!user->isroot)
err = EPERM;
if (!dev)
err = ENODEV;
else if (mtu <= 0)
err = EINVAL;
else
{
if (dev->change_mtu)
dev->change_mtu (dev, mtu);
else
dev->mtu = mtu;
notifier_call_chain (&netdev_chain, NETDEV_CHANGEMTU, dev);
}
__mutex_unlock (&global_lock);
end_using_socket_port (user);
return err;
}
int dev_close(struct net_device *dev)
{
int ct = 0;
if(dev->flags != IFF_DOWN)
{
if(dev->stop)
dev->stop(dev);
notifier_call_chain((struct notifier_block **)(&netdev_chain),NETDEV_DOWN,dev);
//ip_rt_flush(dev);
arp_device_down(dev);
dev->pa_addr = 0;
dev->pa_broadcast = 0;
dev->pa_mask = 0;
while(ct < DEV_NUMBUFFS)
{
struct sk_buff *skb;
while((skb = skb_dequeue(&dev->buffs[ct])) != NULL)
{
if(skb->free)
// skb_free(skb,FREE_WRITE);
ct++;
}
}
}
return 0;
return 0;
}
void notify_cpu_starting(unsigned int cpu)
{
void *hcpu = (void *)(long)cpu;
int notifier_rc = notifier_call_chain(
&cpu_chain, CPU_STARTING, hcpu, NULL);
BUG_ON(notifier_rc != NOTIFY_DONE);
}
int dev_open(struct device *dev)
{
int ret = 0;
/*
* Call device private open method
*/
if (dev->open)
ret = dev->open(dev);
/*
* If it went open OK then set the flags
*/
if (ret == 0)
{
dev->flags |= (IFF_UP | IFF_RUNNING);
/*
* Initialise multicasting status
*/
#ifdef CONFIG_IP_MULTICAST
/*
* Join the all host group
*/
ip_mc_allhost(dev);
#endif
dev_mc_upload(dev);
notifier_call_chain(&netdev_chain, NETDEV_UP, dev);
}
return(ret);
}
/*
* notify clients before sleep and reset bus afterwards
*/
int
adb_notify_sleep(struct pmu_sleep_notifier *self, int when)
{
int ret;
switch (when) {
case PBOOK_SLEEP_REQUEST:
adb_got_sleep = 1;
if (adb_controller->autopoll)
adb_controller->autopoll(0);
ret = notifier_call_chain(&adb_client_list, ADB_MSG_POWERDOWN, NULL);
if (ret & NOTIFY_STOP_MASK)
return PBOOK_SLEEP_REFUSE;
break;
case PBOOK_SLEEP_REJECT:
if (adb_got_sleep) {
adb_got_sleep = 0;
adb_reset_bus();
}
break;
case PBOOK_SLEEP_NOW:
break;
case PBOOK_WAKE:
adb_reset_bus();
adb_got_sleep = 0;
break;
}
return PBOOK_SLEEP_OK;
}
static int take_cpu_down(void *unused)
{
void *hcpu = (void *)(long)smp_processor_id();
int notifier_rc = notifier_call_chain(&cpu_chain, CPU_DYING, hcpu, NULL);
BUG_ON(notifier_rc != NOTIFY_DONE);
__cpu_disable();
return 0;
}
int profile_handoff_task(struct task_struct * task)
{
int ret;
read_lock(&handoff_lock);
ret = notifier_call_chain(&task_free_notifier, 0, task);
read_unlock(&handoff_lock);
return (ret == NOTIFY_OK) ? 1 : 0;
}
static struct inet6_ifaddr *
ipv6_add_addr(struct inet6_dev *idev, struct in6_addr *addr, int pfxlen,
int scope, unsigned flags)
{
struct inet6_ifaddr *ifa;
int hash;
ifa = kmalloc(sizeof(struct inet6_ifaddr), GFP_ATOMIC);
if (ifa == NULL) {
ADBG(("ipv6_add_addr: malloc failed\n"));
return NULL;
}
memset(ifa, 0, sizeof(struct inet6_ifaddr));
ipv6_addr_copy(&ifa->addr, addr);
spin_lock_init(&ifa->lock);
init_timer(&ifa->timer);
ifa->timer.data = (unsigned long) ifa;
ifa->scope = scope;
ifa->prefix_len = pfxlen;
ifa->flags = flags | IFA_F_TENTATIVE;
read_lock(&addrconf_lock);
if (idev->dead) {
read_unlock(&addrconf_lock);
kfree(ifa);
return NULL;
}
inet6_ifa_count++;
ifa->idev = idev;
in6_dev_hold(idev);
/* For caller */
in6_ifa_hold(ifa);
/* Add to big hash table */
hash = ipv6_addr_hash(addr);
write_lock_bh(&addrconf_hash_lock);
ifa->lst_next = inet6_addr_lst[hash];
inet6_addr_lst[hash] = ifa;
in6_ifa_hold(ifa);
write_unlock_bh(&addrconf_hash_lock);
write_lock_bh(&idev->lock);
/* Add to inet6_dev unicast addr list. */
ifa->if_next = idev->addr_list;
idev->addr_list = ifa;
in6_ifa_hold(ifa);
write_unlock_bh(&idev->lock);
read_unlock(&addrconf_lock);
notifier_call_chain(&inet6addr_chain,NETDEV_UP,ifa);
return ifa;
}
NORET_TYPE void panic(const char * fmt, ...)
{
static char buf[1024];
va_list args;
#if defined(CONFIG_ARCH_S390)
unsigned long caller = (unsigned long) __builtin_return_address(0);
#endif
bust_spinlocks(1);
va_start(args, fmt);
vsprintf(buf, fmt, args);
va_end(args);
printk(KERN_EMERG "Kernel panic: %s\n",buf);
if (in_interrupt())
printk(KERN_EMERG "In interrupt handler - not syncing\n");
else if (!current->pid)
printk(KERN_EMERG "In idle task - not syncing\n");
else
sys_sync();
bust_spinlocks(0);
#ifdef CONFIG_SMP
smp_send_stop();
#endif
notifier_call_chain(&panic_notifier_list, 0, NULL);
if (panic_timeout > 0)
{
/*
* Delay timeout seconds before rebooting the machine.
* We can't use the "normal" timers since we just panicked..
*/
printk(KERN_EMERG "Rebooting in %d seconds..",panic_timeout);
mdelay(panic_timeout*1000);
/*
* Should we run the reboot notifier. For the moment Im
* choosing not too. It might crash, be corrupt or do
* more harm than good for other reasons.
*/
machine_restart(NULL);
}
#ifdef __sparc__
{
extern int stop_a_enabled;
/* Make sure the user can actually press L1-A */
stop_a_enabled = 1;
printk("Press L1-A to return to the boot prom\n");
}
#endif
#if defined(CONFIG_ARCH_S390)
disabled_wait(caller);
#endif
sti();
for(;;) {
CHECK_EMERGENCY_SYNC
}
}
int blocking_notifier_call_chain(struct blocking_notifier_head *nh,
unsigned long val, void *v)
{
int ret;
down_read(&nh->rwsem);
ret = notifier_call_chain(&nh->head, val, v);
up_read(&nh->rwsem);
return ret;
}
int atomic_notifier_call_chain(struct atomic_notifier_head *nh,
unsigned long val, void *v)
{
int ret;
rcu_read_lock();
ret = notifier_call_chain(&nh->head, val, v);
rcu_read_unlock();
return ret;
}
int dev_close(struct device *dev)
{
/*
* Only close a device if it is up.
*/
if (dev->flags != 0)
{
int ct=0;
dev->flags = 0;
/*
* Call the device specific close. This cannot fail.
*/
if (dev->stop)
dev->stop(dev);
notifier_call_chain(&netdev_chain, NETDEV_DOWN, dev);
#if 0
/*
* Delete the route to the device.
*/
#ifdef CONFIG_INET
ip_rt_flush(dev);
arp_device_down(dev);
#endif
#ifdef CONFIG_IPX
ipxrtr_device_down(dev);
#endif
#endif
/*
* Flush the multicast chain
*/
dev_mc_discard(dev);
/*
* Blank the IP addresses
*/
dev->pa_addr = 0;
dev->pa_dstaddr = 0;
dev->pa_brdaddr = 0;
dev->pa_mask = 0;
/*
* Purge any queued packets when we down the link
*/
while(ct<DEV_NUMBUFFS)
{
struct sk_buff *skb;
while((skb=skb_dequeue(&dev->buffs[ct]))!=NULL)
if(skb->free)
kfree_skb(skb,FREE_WRITE);
ct++;
}
}
return(0);
}
/*! 2017. 5.20 study -ing */
int __kprobes __atomic_notifier_call_chain(struct atomic_notifier_head *nh,
unsigned long val, void *v,
int nr_to_call, int *nr_calls)
{
int ret;
rcu_read_lock();
ret = notifier_call_chain(&nh->head, val, v, nr_to_call, nr_calls);
rcu_read_unlock();
return ret;
}
int
adb_reset_bus(void)
{
int ret, nret, devs;
unsigned long flags;
if (adb_controller == NULL)
return -ENXIO;
if (adb_controller->autopoll)
adb_controller->autopoll(0);
nret = notifier_call_chain(&adb_client_list, ADB_MSG_PRE_RESET, NULL);
if (nret & NOTIFY_STOP_MASK) {
if (adb_controller->autopoll)
adb_controller->autopoll(devs);
return -EBUSY;
}
save_flags(flags);
cli();
memset(adb_handler, 0, sizeof(adb_handler));
restore_flags(flags);
if (adb_controller->reset_bus)
ret = adb_controller->reset_bus();
else
ret = 0;
if (!ret) {
devs = adb_scan_bus();
if (adb_controller->autopoll)
adb_controller->autopoll(devs);
}
nret = notifier_call_chain(&adb_client_list, ADB_MSG_POST_RESET, NULL);
if (nret & NOTIFY_STOP_MASK)
return -EBUSY;
return ret;
}
int cpu_down(unsigned int cpu)
{
int err, notifier_rc;
void *hcpu = (void *)(long)cpu;
struct notifier_block *nb = NULL;
if ( !cpu_hotplug_begin() )
return -EBUSY;
if ( (cpu >= NR_CPUS) || (cpu == 0) || !cpu_online(cpu) )
{
cpu_hotplug_done();
return -EINVAL;
}
notifier_rc = notifier_call_chain(&cpu_chain, CPU_DOWN_PREPARE, hcpu, &nb);
if ( notifier_rc != NOTIFY_DONE )
{
err = notifier_to_errno(notifier_rc);
goto fail;
}
if ( (err = stop_machine_run(take_cpu_down, NULL, cpu)) < 0 )
goto fail;
__cpu_die(cpu);
BUG_ON(cpu_online(cpu));
notifier_rc = notifier_call_chain(&cpu_chain, CPU_DEAD, hcpu, NULL);
BUG_ON(notifier_rc != NOTIFY_DONE);
send_guest_global_virq(dom0, VIRQ_PCPU_STATE);
cpu_hotplug_done();
return 0;
fail:
notifier_rc = notifier_call_chain(&cpu_chain, CPU_DOWN_FAILED, hcpu, &nb);
BUG_ON(notifier_rc != NOTIFY_DONE);
cpu_hotplug_done();
return err;
}
int __vmm_blocking_notifier_call(struct vmm_blocking_notifier_chain *nc,
unsigned long val, void *v,
int nr_to_call, int *nr_calls)
{
int ret = NOTIFY_DONE;
vmm_semaphore_down(&nc->rwsem);
ret = notifier_call_chain(&nc->head, val, v, nr_to_call, nr_calls);
vmm_semaphore_up(&nc->rwsem);
return ret;
}
/*! 2016.11.19 study -ing */
int __srcu_notifier_call_chain(struct srcu_notifier_head *nh,
unsigned long val, void *v,
int nr_to_call, int *nr_calls)
{
int ret;
int idx;
idx = srcu_read_lock(&nh->srcu);
ret = notifier_call_chain(&nh->head, val, v, nr_to_call, nr_calls);
srcu_read_unlock(&nh->srcu, idx);
return ret;
}
int dev_open(struct net_device *dev)
{
int ret = 0;
if(dev->open)
ret = dev->open(dev);
if(ret == 0)
{
dev->flags |= IFF_UP | IFF_RUNNING;
notifier_call_chain((struct notifier_block **)(&netdev_chain),NETDEV_UP,dev);
}
return ret;
}
int cpu_up(unsigned int cpu)
{
int notifier_rc, err = 0;
void *hcpu = (void *)(long)cpu;
struct notifier_block *nb = NULL;
if ( !cpu_hotplug_begin() )
return -EBUSY;
if ( (cpu >= NR_CPUS) || cpu_online(cpu) || !cpu_present(cpu) )
{
cpu_hotplug_done();
return -EINVAL;
}
notifier_rc = notifier_call_chain(&cpu_chain, CPU_UP_PREPARE, hcpu, &nb);
if ( notifier_rc != NOTIFY_DONE )
{
err = notifier_to_errno(notifier_rc);
goto fail;
}
err = __cpu_up(cpu);
if ( err < 0 )
goto fail;
notifier_rc = notifier_call_chain(&cpu_chain, CPU_ONLINE, hcpu, NULL);
BUG_ON(notifier_rc != NOTIFY_DONE);
send_guest_global_virq(dom0, VIRQ_PCPU_STATE);
cpu_hotplug_done();
return 0;
fail:
notifier_rc = notifier_call_chain(&cpu_chain, CPU_UP_CANCELED, hcpu, &nb);
BUG_ON(notifier_rc != NOTIFY_DONE);
cpu_hotplug_done();
return err;
}
static int inet_insert_ifa(struct in_ifaddr *ifa)
{
struct in_device *in_dev = ifa->ifa_dev;
struct in_ifaddr *ifa1, **ifap, **last_primary;
ASSERT_RTNL();
if (!ifa->ifa_local) {
inet_free_ifa(ifa);
return 0;
}
ifa->ifa_flags &= ~IFA_F_SECONDARY;
last_primary = &in_dev->ifa_list;
for (ifap = &in_dev->ifa_list; (ifa1 = *ifap) != NULL;
ifap = &ifa1->ifa_next) {
if (!(ifa1->ifa_flags & IFA_F_SECONDARY) &&
ifa->ifa_scope <= ifa1->ifa_scope)
last_primary = &ifa1->ifa_next;
if (ifa1->ifa_mask == ifa->ifa_mask &&
inet_ifa_match(ifa1->ifa_address, ifa)) {
if (ifa1->ifa_local == ifa->ifa_local) {
inet_free_ifa(ifa);
return -EEXIST;
}
if (ifa1->ifa_scope != ifa->ifa_scope) {
inet_free_ifa(ifa);
return -EINVAL;
}
ifa->ifa_flags |= IFA_F_SECONDARY;
}
}
if (!(ifa->ifa_flags & IFA_F_SECONDARY)) {
net_srandom(ifa->ifa_local);
ifap = last_primary;
}
ifa->ifa_next = *ifap;
write_lock_bh(&in_dev->lock);
*ifap = ifa;
write_unlock_bh(&in_dev->lock);
/* Send message first, then call notifier.
Notifier will trigger FIB update, so that
listeners of netlink will know about new ifaddr */
rtmsg_ifa(RTM_NEWADDR, ifa);
notifier_call_chain(&inetaddr_chain, NETDEV_UP, ifa);
return 0;
}
int __vmm_atomic_notifier_call(struct vmm_atomic_notifier_chain *nc,
unsigned long val, void *v,
int nr_to_call, int *nr_calls)
{
irq_flags_t flags;
int ret;
vmm_spin_lock_irqsave(&nc->lock, flags);
ret = notifier_call_chain(&nc->head, val, v, nr_to_call, nr_calls);
vmm_spin_unlock_irqrestore(&nc->lock, flags);
return ret;
}
int __blocking_notifier_call_chain(struct blocking_notifier_head *nh,
unsigned long val, void *v,
int nr_to_call, int *nr_calls)
{
int ret = NOTIFY_DONE;
if (rcu_dereference(nh->head)) {
down_read(&nh->rwsem);
ret = notifier_call_chain(&nh->head, val, v, nr_to_call,
nr_calls);
up_read(&nh->rwsem);
}
return ret;
}
/**
* __atomic_notifier_call_chain - Call functions in an atomic notifier chain
* @nh: Pointer to head of the atomic notifier chain
* @val: Value passed unmodified to notifier function
* @v: Pointer passed unmodified to notifier function
* @nr_to_call: See the comment for notifier_call_chain.
* @nr_calls: See the comment for notifier_call_chain.
*
* Calls each function in a notifier chain in turn. The functions
* run in an atomic context, so they must not block.
* This routine uses RCU to synchronize with changes to the chain.
*
* If the return value of the notifier can be and'ed
* with %NOTIFY_STOP_MASK then atomic_notifier_call_chain()
* will return immediately, with the return value of
* the notifier function which halted execution.
* Otherwise the return value is the return value
* of the last notifier function called.
*/
int __kprobes __atomic_notifier_call_chain(struct atomic_notifier_head *nh,
unsigned long val, void *v,
int nr_to_call, int *nr_calls)
{
int ret;
rcu_read_lock();
#ifdef CONFIG_USA_MODEL_SGH_I717
if( &nh->head == NULL) {
dump_stack();
}
#endif
ret = notifier_call_chain(&nh->head, val, v, nr_to_call, nr_calls);
rcu_read_unlock();
return ret;
}
/*! 2017. 3.18 study -ing */
int __blocking_notifier_call_chain(struct blocking_notifier_head *nh,
unsigned long val, void *v,
int nr_to_call, int *nr_calls)
{
int ret = NOTIFY_DONE;
/*
* We check the head outside the lock, but if this access is
* racy then it does not matter what the result of the test
* is, we re-check the list after having taken the lock anyway:
*/
if (rcu_dereference_raw(nh->head)) {
down_read(&nh->rwsem);
ret = notifier_call_chain(&nh->head, val, v, nr_to_call,
nr_calls);
up_read(&nh->rwsem);
}
return ret;
}
static int sound_release(struct inode *inode, struct file *file)
{
int dev = MINOR(inode->i_rdev);
DEB(printk("sound_release(dev=%d)\n", dev));
switch (dev & 0x0f) {
case SND_DEV_STATUS:
case SND_DEV_CTL:
break;
#ifdef CONFIG_SEQUENCER
case SND_DEV_SEQ:
case SND_DEV_SEQ2:
sequencer_release(dev, file);
break;
#endif
#ifdef CONFIG_MIDI
case SND_DEV_MIDIN:
MIDIbuf_release(dev, file);
break;
#endif
#ifdef CONFIG_AUDIO
case SND_DEV_DSP:
case SND_DEV_DSP16:
case SND_DEV_AUDIO:
audio_release(dev, file);
break;
#endif
default:
printk(KERN_ERR "Sound error: Releasing unknown device 0x%02x\n", dev);
}
in_use--;
#ifdef CONFIG_MODULES
notifier_call_chain(&sound_locker, 0, 0);
lock_depth--;
#endif
return 0;
}
static void ipv6_del_addr(struct inet6_ifaddr *ifp)
{
struct inet6_ifaddr *ifa, **ifap;
struct inet6_dev *idev = ifp->idev;
int hash;
hash = ipv6_addr_hash(&ifp->addr);
ifp->dead = 1;
write_lock_bh(&addrconf_hash_lock);
for (ifap = &inet6_addr_lst[hash]; (ifa=*ifap) != NULL;
ifap = &ifa->lst_next) {
if (ifa == ifp) {
*ifap = ifa->lst_next;
__in6_ifa_put(ifp);
ifa->lst_next = NULL;
break;
}
}
write_unlock_bh(&addrconf_hash_lock);
write_lock_bh(&idev->lock);
for (ifap = &idev->addr_list; (ifa=*ifap) != NULL;
ifap = &ifa->if_next) {
if (ifa == ifp) {
*ifap = ifa->if_next;
__in6_ifa_put(ifp);
ifa->if_next = NULL;
break;
}
}
write_unlock_bh(&idev->lock);
ipv6_ifa_notify(RTM_DELADDR, ifp);
notifier_call_chain(&inet6addr_chain,NETDEV_DOWN,ifp);
addrconf_del_timer(ifp);
in6_ifa_put(ifp);
}
void xenbus_probe(void *unused)
{
int i;
BUG_ON((xenstored_ready <= 0));
/* Enumerate devices in xenstore. */
xenbus_probe_devices(&xenbus_frontend);
#ifdef CONFIG_XEN
xenbus_probe_devices(&xenbus_backend);
#endif
/* Watch for changes. */
register_xenbus_watch(&fe_watch);
#ifdef CONFIG_XEN
register_xenbus_watch(&be_watch);
#endif
/* Notify others that xenstore is up */
notifier_call_chain(&xenstore_chain, 0, NULL);
/* On a 10 second timeout, waiting for all devices currently
configured. We need to do this to guarantee that the filesystems
and / or network devices needed for boot are available, before we
can allow the boot to proceed.
A possible improvement here would be to have the tools add a
per-device flag to the store entry, indicating whether it is needed
at boot time. This would allow people who knew what they were
doing to accelerate their boot slightly, but of course needs tools
or manual intervention to set up those flags correctly.
*/
for (i = 0; i < 10 * HZ; i++) {
if (all_devices_ready())
return;
set_current_state(TASK_INTERRUPTIBLE);
schedule_timeout(1);
}
printk(KERN_WARNING
"XENBUS: Timeout connecting to devices!\n");
}
