* [PATCH] Use nanosleep() instead of usleep()
@ 2009-08-17 14:20 Daniel Mierswa
2009-08-18 0:22 ` Kay Sievers
` (5 more replies)
0 siblings, 6 replies; 7+ messages in thread
From: Daniel Mierswa @ 2009-08-17 14:20 UTC (permalink / raw)
To: linux-hotplug
[-- Attachment #1: Type: text/plain, Size: 501 bytes --]
POSIX.1-2001 declares usleep() function obsolete and POSIX.1-2008
removes it. Converted the calls to nanosleep().
Signed-off-by: Daniel Mierswa <impulze@impulze.org>
---
extras/modem-modeswitch/ma8280p_us.c | 335 +++++++++++++++++-----------------
extras/scsi_id/scsi_serial.c | 8 +-
udev/udev-event.c | 9 +-
udev/udev-rules.c | 9 +-
udev/udevadm-settle.c | 8 +-
5 files changed, 202 insertions(+), 167 deletions(-)
[-- Attachment #2: 0001-Use-nanosleep-instead-of-usleep.patch --]
[-- Type: text/x-patch, Size: 22825 bytes --]
diff --git a/extras/modem-modeswitch/ma8280p_us.c b/extras/modem-modeswitch/ma8280p_us.c
index 13d1116..7069ccb 100644
--- a/extras/modem-modeswitch/ma8280p_us.c
+++ b/extras/modem-modeswitch/ma8280p_us.c
@@ -88,10 +88,19 @@
#include <signal.h>
#include <ctype.h>
#include <usb.h>
+#include <time.h> /* nanosleep() */
#include "utils.h"
#include "ma8280p_us.h"
+int nsleep(useconds_t usec)
+{
+ struct timespec time;
+ time.tv_sec = usec / 1000000;
+ time.tv_nsec = (usec - (time.tv_sec * 1000000)) * 1000;
+ return nanosleep(&time, NULL);
+}
+
int ma8280p_switch (struct usb_dev_handle *devh, struct usb_device *dev)
{
int ret = 1;
@@ -104,11 +113,11 @@ int ma8280p_switch (struct usb_dev_handle *devh, struct usb_device *dev)
}
ret = usb_get_descriptor(devh, 0x0000001, 0x0000000, buf, 0x0000012);
- usleep(6*1000);
+ nsleep(6*1000);
ret = usb_get_descriptor(devh, 0x0000001, 0x0000000, buf, 0x0000012);
- usleep(6*1000);
+ nsleep(6*1000);
ret = usb_get_descriptor(devh, 0x0000002, 0x0000000, buf, 0x0000400);
- usleep(10*1000);
+ nsleep(10*1000);
ret = usb_release_interface(devh, 0);
if (ret != 0)
debug ("%s: failed to release interface before set_configuration: %d", dev->filename, ret);
@@ -117,335 +126,335 @@ int ma8280p_switch (struct usb_dev_handle *devh, struct usb_device *dev)
if (ret != 0)
debug ("%s: claim after set_configuration failed with error %d", dev->filename, ret);
//ret = usb_set_altinterface(devh, 0);
- //usleep(33*1000);
+ //nsleep(33*1000);
ret = usb_control_msg(devh, USB_TYPE_CLASS + USB_RECIP_INTERFACE + USB_ENDPOINT_IN, 0x0000001, 0x0000300, 0x0000000, buf, 0x0000008, 1000);
- usleep(5*1000);
+ nsleep(5*1000);
memcpy(buf, "\xb0\x04\x00\x00\x02\x90\x26\x86", 0x0000008);
ret = usb_control_msg(devh, USB_TYPE_CLASS + USB_RECIP_INTERFACE, 0x0000009, 0x0000300, 0x0000000, buf, 0x0000008, 1000);
- usleep(4*1000);
+ nsleep(4*1000);
memcpy(buf, "\xb0\x04\x00\x00\x02\x90\x26\x86", 0x0000008);
ret = usb_control_msg(devh, USB_TYPE_CLASS + USB_RECIP_INTERFACE, 0x0000009, 0x0000300, 0x0000000, buf, 0x0000008, 1000);
- usleep(4*1000);
+ nsleep(4*1000);
- usleep(4*1000);
+ nsleep(4*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(6*1000);
+ nsleep(6*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(1*1000);
+ nsleep(1*1000);
//URB_FUNCTION_GET_STATUS_FROM_ENDPOINT skipped
- usleep(4*1000);
+ nsleep(4*1000);
memcpy(buf, "\x37\x01\xfe\xdb\xc1\x33\x1f\x83", 0x0000008);
ret = usb_interrupt_write(devh, 0x00000002, buf, 0x0000008, 1000);
- usleep(3*1000);
+ nsleep(3*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(1*1000);
+ nsleep(1*1000);
memcpy(buf, "\x37\x0e\xb5\x9d\x3b\x8a\x91\x51", 0x0000008);
ret = usb_interrupt_write(devh, 0x00000002, buf, 0x0000008, 1000);
- usleep(7*1000);
+ nsleep(7*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(1*1000);
+ nsleep(1*1000);
memcpy(buf, "\x34\x87\xba\x0d\xfc\x8a\x91\x51", 0x0000008);
ret = usb_interrupt_write(devh, 0x00000002, buf, 0x0000008, 1000);
- usleep(7*1000);
+ nsleep(7*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(2*1000);
+ nsleep(2*1000);
//URB_FUNCTION_GET_STATUS_FROM_ENDPOINT skipped
- usleep(4*1000);
+ nsleep(4*1000);
memcpy(buf, "\x37\x01\xfe\xdb\xc1\x33\x1f\x83", 0x0000008);
ret = usb_interrupt_write(devh, 0x00000002, buf, 0x0000008, 1000);
- usleep(2*1000);
+ nsleep(2*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(1*1000);
+ nsleep(1*1000);
memcpy(buf, "\x37\x0e\xb5\x9d\x3b\x8a\x91\x51", 0x0000008);
ret = usb_interrupt_write(devh, 0x00000002, buf, 0x0000008, 1000);
- usleep(7*1000);
+ nsleep(7*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(1*1000);
+ nsleep(1*1000);
memcpy(buf, "\x34\x87\xba\x0d\xfc\x8a\x91\x51", 0x0000008);
ret = usb_interrupt_write(devh, 0x00000002, buf, 0x0000008, 1000);
- usleep(7*1000);
+ nsleep(7*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ nsleep(8*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(1*1000);
+ nsleep(1*1000);
//URB_FUNCTION_GET_STATUS_FROM_ENDPOINT skipped
- usleep(4*1000);
+ nsleep(4*1000);
memcpy(buf, "\x33\x04\xfe\x00\xf4\x6c\x1f\xf0", 0x0000008);
ret = usb_interrupt_write(devh, 0x00000002, buf, 0x0000008, 1000);
- usleep(3*1000);
+ nsleep(3*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(1*1000);
+ nsleep(1*1000);
//URB_FUNCTION_GET_STATUS_FROM_ENDPOINT skipped
- usleep(4*1000);
+ nsleep(4*1000);
memcpy(buf, "\x32\x07\xfe\xf0\x29\xb9\x3a\xf0", 0x0000008);
ret = usb_interrupt_write(devh, 0x00000002, buf, 0x0000008, 1000);
- usleep(3*1000);
+ nsleep(3*1000);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
if (buf)
diff --git a/extras/scsi_id/scsi_serial.c b/extras/scsi_id/scsi_serial.c
index 0f883dc..3f4e27a 100644
--- a/extras/scsi_id/scsi_serial.c
+++ b/extras/scsi_id/scsi_serial.c
@@ -27,6 +27,7 @@
#include <scsi/scsi.h>
#include <scsi/sg.h>
#include <linux/types.h>
+#include <time.h> /* nanosleep() */
/* #include <linux/bsg.h> */
#include "bsg.h"
@@ -846,13 +847,18 @@ int scsi_get_serial(struct udev *udev,
memset(dev_scsi->serial, 0, len);
dbg(udev, "opening %s\n", devname);
while (--cnt) {
+ struct timespec time;
+
fd = open(devname, O_RDONLY | O_NONBLOCK);
if (fd >= 0)
break;
info(udev, "%s: cannot open %s: %s\n", dev_scsi->kernel, devname, strerror(errno));
if (errno != EBUSY)
break;
- usleep(500000 + (rand() % 100000) );
+
+ time.tv_sec = 0;
+ time.tv_nsec = 500000000 + (rand() % 100000000);
+ nanosleep(&time, NULL);
}
if (fd < 0)
return 1;
diff --git a/udev/udev-event.c b/udev/udev-event.c
index f3c2bd2..0ec2573 100644
--- a/udev/udev-event.c
+++ b/udev/udev-event.c
@@ -27,6 +27,7 @@
#include <sys/socket.h>
#include <net/if.h>
#include <linux/sockios.h>
+#include <time.h> /* nanosleep() */
#include "udev.h"
@@ -505,6 +506,8 @@ static int rename_netif(struct udev_event *event)
util_strscpy(ifr.ifr_newname, IFNAMSIZ, event->name);
loop = 90 * 20;
while (loop--) {
+ struct timespec time;
+
err = ioctl(sk, SIOCSIFNAME, &ifr);
if (err == 0) {
rename_netif_kernel_log(ifr);
@@ -518,7 +521,11 @@ static int rename_netif(struct udev_event *event)
}
dbg(event->udev, "wait for netif '%s' to become free, loop=%i\n",
event->name, (90 * 20) - loop);
- usleep(1000 * 1000 / 20);
+
+ time.tv_sec = 0;
+ time.tv_nsec = 1000 * 1000 * 1000 / 20;
+
+ nanosleep(&time, NULL);
}
}
exit:
diff --git a/udev/udev-rules.c b/udev/udev-rules.c
index 53baa18..13c98e5 100644
--- a/udev/udev-rules.c
+++ b/udev/udev-rules.c
@@ -27,6 +27,7 @@
#include <errno.h>
#include <dirent.h>
#include <fnmatch.h>
+#include <time.h> /* nanosleep() */
#include "udev.h"
@@ -814,6 +815,8 @@ static int wait_for_file(struct udev_device *dev, const char *file, int timeout)
dbg(udev, "will wait %i sec for '%s'\n", timeout, file);
while (--loop) {
+ struct timespec time;
+
/* lookup file */
if (stat(file, &stats) == 0) {
info(udev, "file '%s' appeared after %i loops\n", file, (timeout * WAIT_LOOP_PER_SECOND) - loop-1);
@@ -825,7 +828,11 @@ static int wait_for_file(struct udev_device *dev, const char *file, int timeout)
return -2;
}
info(udev, "wait for '%s' for %i mseconds\n", file, 1000 / WAIT_LOOP_PER_SECOND);
- usleep(1000 * 1000 / WAIT_LOOP_PER_SECOND);
+
+ time.tv_sec = 0;
+ time.tv_nsec = 1000 * 1000 * 1000 / WAIT_LOOP_PER_SECOND;
+
+ nanosleep(&time, NULL);
}
info(udev, "waiting for '%s' failed\n", file);
return -1;
diff --git a/udev/udevadm-settle.c b/udev/udevadm-settle.c
index 6828192..a58f4f7 100644
--- a/udev/udevadm-settle.c
+++ b/udev/udevadm-settle.c
@@ -30,6 +30,7 @@
#include <signal.h>
#include <sys/stat.h>
#include <sys/types.h>
+#include <time.h> /* nanosleep() */
#include "udev.h"
@@ -162,6 +163,7 @@ int udevadm_settle(struct udev *udev, int argc, char *argv[])
/* guarantee that the udev daemon isn't pre-processing */
if (getuid() == 0) {
struct udev_ctrl *uctrl;
+ struct timespec time;
uctrl = udev_ctrl_new_from_socket(udev, UDEV_CTRL_SOCK_PATH);
if (uctrl != NULL) {
@@ -180,6 +182,7 @@ int udevadm_settle(struct udev *udev, int argc, char *argv[])
while (1) {
struct stat statbuf;
+ struct timespec time;
if (exists != NULL && stat(exists, &statbuf) == 0) {
rc = 0;
@@ -203,7 +206,10 @@ int udevadm_settle(struct udev *udev, int argc, char *argv[])
if (is_timeout)
break;
- usleep(1000 * 1000 / LOOP_PER_SECOND);
+ time.tv_sec = 0;
+ time.tv_nsec = 1000 * 1000 * 1000 / LOOP_PER_SECOND;
+
+ nanosleep(&time, NULL);
}
/* if we reached the timeout, print the list of remaining events */
^ permalink raw reply related [flat|nested] 7+ messages in thread
* Re: [PATCH] Use nanosleep() instead of usleep()
2009-08-17 14:20 [PATCH] Use nanosleep() instead of usleep() Daniel Mierswa
@ 2009-08-18 0:22 ` Kay Sievers
2009-08-18 5:08 ` Daniel Mierswa
` (4 subsequent siblings)
5 siblings, 0 replies; 7+ messages in thread
From: Kay Sievers @ 2009-08-18 0:22 UTC (permalink / raw)
To: linux-hotplug
On Mon, Aug 17, 2009 at 16:20, Daniel Mierswa<impulze@impulze.org> wrote:
>
> POSIX.1-2001 Â declares usleep() function obsolete and POSIX.1-2008
> removes it. Converted the calls to nanosleep().
+++ b/extras/modem-modeswitch/ma8280p_us.c
@@ -88,10 +88,19 @@
#include <signal.h>
#include <ctype.h>
#include <usb.h>
+#include <time.h> /* nanosleep() */
Please drop such comments.
#include "utils.h"
#include "ma8280p_us.h"
+int nsleep(useconds_t usec)
This needs a better name. We better don't pass usecs to a function
called nsleep. :)
@@ -162,6 +163,7 @@ int udevadm_settle(struct udev *udev, int argc,
char *argv[])
/* guarantee that the udev daemon isn't pre-processing */
if (getuid() = 0) {
struct udev_ctrl *uctrl;
+ struct timespec time;
Is this used?
@@ -203,7 +206,10 @@ int udevadm_settle(struct udev *udev, int argc,
char *argv[])
if (is_timeout)
break;
- usleep(1000 * 1000 / LOOP_PER_SECOND);
+ time.tv_sec = 0;
+ time.tv_nsec = 1000 * 1000 * 1000 / LOOP_PER_SECOND;
+
+ nanosleep(&time, NULL);
Please remove the newline in the middle of the logical block (several
occurences).
Thanks,
Kay
^ permalink raw reply [flat|nested] 7+ messages in thread
* Re: [PATCH] Use nanosleep() instead of usleep()
2009-08-17 14:20 [PATCH] Use nanosleep() instead of usleep() Daniel Mierswa
2009-08-18 0:22 ` Kay Sievers
@ 2009-08-18 5:08 ` Daniel Mierswa
2009-08-19 2:17 ` Kay Sievers
` (3 subsequent siblings)
5 siblings, 0 replies; 7+ messages in thread
From: Daniel Mierswa @ 2009-08-18 5:08 UTC (permalink / raw)
To: linux-hotplug
[-- Attachment #1: Type: text/plain, Size: 509 bytes --]
Kay Sievers wrote:
> Please drop such comments.
Done.
> This needs a better name. We better don't pass usecs to a function
> called nsleep. :)
I did a conditional replacement now with the same name.
> Please remove the newline in the middle of the logical block (several
> occurences).
Done too.
Reattached a new patch.
--
Mierswa, Daniel
If you still don't like it, that's ok: that's why I'm boss. I simply know better than you do.
--- Linus Torvalds, comp.os.linux.advocacy, 1996/07/22
[-- Attachment #2: 0001-Use-nanosleep-instead-of-usleep.patch --]
[-- Type: text/plain, Size: 1909 bytes --]
From 1c9936d92b2f9e80832180661aabcd7a4d93a2d7 Mon Sep 17 00:00:00 2001
From: Daniel Mierswa <impulze@impulze.org>
Date: Mon, 17 Aug 2009 16:02:59 +0200
Subject: [PATCH] Use nanosleep() instead of usleep()
POSIX.1-2001 declares usleep() function obsolete and POSIX.1-2008
removes it. If usleep() is no longer present on a system, we use
nanosleep() instead.
---
configure.ac | 1 +
| 1 +
libudev/libudev-private.h | 11 +++++++++++
3 files changed, 13 insertions(+), 0 deletions(-)
diff --git a/configure.ac b/configure.ac
index 3afb94a..c32e22b 100644
--- a/configure.ac
+++ b/configure.ac
@@ -11,6 +11,7 @@ AC_PROG_AWK
GTK_DOC_CHECK(1.10)
AC_PREFIX_DEFAULT([/usr])
AC_PATH_PROG([XSLTPROC], [xsltproc])
+AC_CHECK_FUNCS([usleep])
AC_ARG_WITH([rootlibdir],
AS_HELP_STRING([--with-rootlibdir=DIR], [rootfs directory to install shared libraries]),
--git a/extras/modem-modeswitch/ma8280p_us.c b/extras/modem-modeswitch/ma8280p_us.c
index 13d1116..626207e 100644
--- a/extras/modem-modeswitch/ma8280p_us.c
+++ b/extras/modem-modeswitch/ma8280p_us.c
@@ -91,6 +91,7 @@
#include "utils.h"
#include "ma8280p_us.h"
+#include "libudev-private.h"
int ma8280p_switch (struct usb_dev_handle *devh, struct usb_device *dev)
{
diff --git a/libudev/libudev-private.h b/libudev/libudev-private.h
index 16f9f2e..736df7a 100644
--- a/libudev/libudev-private.h
+++ b/libudev/libudev-private.h
@@ -15,6 +15,17 @@
#include <syslog.h>
#include "libudev.h"
+#ifndef HAVE_USLEEP
+# include <time.h>
+# define usleep(usec) \
+ do { \
+ struct timespec time; \
+ time.tv_sec = usec / 1000000; \
+ time.tv_nsec = (usec - (time.tv_sec * 1000000)) * 1000; \
+ return nanosleep(&time, NULL); \
+ } while (0)
+#endif
+
#define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))
#define READ_END 0
#define WRITE_END 1
--
1.6.4
^ permalink raw reply related [flat|nested] 7+ messages in thread
* Re: [PATCH] Use nanosleep() instead of usleep()
2009-08-17 14:20 [PATCH] Use nanosleep() instead of usleep() Daniel Mierswa
2009-08-18 0:22 ` Kay Sievers
2009-08-18 5:08 ` Daniel Mierswa
@ 2009-08-19 2:17 ` Kay Sievers
2009-08-19 5:35 ` Daniel Mierswa
` (2 subsequent siblings)
5 siblings, 0 replies; 7+ messages in thread
From: Kay Sievers @ 2009-08-19 2:17 UTC (permalink / raw)
To: linux-hotplug
On Tue, Aug 18, 2009 at 07:08, Daniel Mierswa<impulze@impulze.org> wrote:
> POSIX.1-2001 Â declares usleep() function obsolete and POSIX.1-2008
> removes it. If usleep() is no longer present on a system, we use
> nanosleep() instead.
What's the point doing that wrapping? Will usleep() ever be removed from glibc?
Kay
^ permalink raw reply [flat|nested] 7+ messages in thread
* Re: [PATCH] Use nanosleep() instead of usleep()
2009-08-17 14:20 [PATCH] Use nanosleep() instead of usleep() Daniel Mierswa
` (2 preceding siblings ...)
2009-08-19 2:17 ` Kay Sievers
@ 2009-08-19 5:35 ` Daniel Mierswa
2009-08-24 16:41 ` Scott James Remnant
2009-08-24 17:23 ` Daniel Mierswa
5 siblings, 0 replies; 7+ messages in thread
From: Daniel Mierswa @ 2009-08-19 5:35 UTC (permalink / raw)
To: linux-hotplug
On 19.08.2009 04:17, Kay Sievers wrote:
> What's the point doing that wrapping? Will usleep() ever be removed from glibc?
Well POSIX.1-2008 removes the specification and if you disable
UCLIBC_SUSV3_LEGACY in uClibc (which is default) you will get undefined
references. I don't think it's too big of a problem to replace it for
the cases where the C library doesn't offer it, is it?
--
Mierswa, Daniel
If you still don't like it, that's ok: that's why I'm boss. I simply
know better than you do.
--- Linus Torvalds, comp.os.linux.advocacy, 1996/07/22
^ permalink raw reply [flat|nested] 7+ messages in thread
* Re: [PATCH] Use nanosleep() instead of usleep()
2009-08-17 14:20 [PATCH] Use nanosleep() instead of usleep() Daniel Mierswa
` (3 preceding siblings ...)
2009-08-19 5:35 ` Daniel Mierswa
@ 2009-08-24 16:41 ` Scott James Remnant
2009-08-24 17:23 ` Daniel Mierswa
5 siblings, 0 replies; 7+ messages in thread
From: Scott James Remnant @ 2009-08-24 16:41 UTC (permalink / raw)
To: linux-hotplug
[-- Attachment #1: Type: text/plain, Size: 567 bytes --]
On Wed, 2009-08-19 at 07:35 +0200, Daniel Mierswa wrote:
> On 19.08.2009 04:17, Kay Sievers wrote:
> > What's the point doing that wrapping? Will usleep() ever be removed from glibc?
> Well POSIX.1-2008 removes the specification and if you disable
> UCLIBC_SUSV3_LEGACY in uClibc (which is default) you will get undefined
> references. I don't think it's too big of a problem to replace it for
> the cases where the C library doesn't offer it, is it?
>
Why not just use nanosleep() unconditionally?
Scott
--
Scott James Remnant
scott@canonical.com
[-- Attachment #2: This is a digitally signed message part --]
[-- Type: application/pgp-signature, Size: 197 bytes --]
^ permalink raw reply [flat|nested] 7+ messages in thread
* Re: [PATCH] Use nanosleep() instead of usleep()
2009-08-17 14:20 [PATCH] Use nanosleep() instead of usleep() Daniel Mierswa
` (4 preceding siblings ...)
2009-08-24 16:41 ` Scott James Remnant
@ 2009-08-24 17:23 ` Daniel Mierswa
5 siblings, 0 replies; 7+ messages in thread
From: Daniel Mierswa @ 2009-08-24 17:23 UTC (permalink / raw)
To: linux-hotplug
[-- Attachment #1: Type: text/plain, Size: 155 bytes --]
On 24.08.2009 18:41, Scott James Remnant wrote:
> Why not just use nanosleep() unconditionally?
Here we go, reworked patch with unconditional replacement.
[-- Attachment #2: 0001-Use-nanosleep-instead-of-usleep.patch --]
[-- Type: text/x-patch, Size: 21058 bytes --]
From d44a17fc464b973f0c60843a97464b5722d32bdd Mon Sep 17 00:00:00 2001
From: Daniel Mierswa <impulze@impulze.org>
Date: Mon, 17 Aug 2009 16:02:59 +0200
Subject: [PATCH] Use nanosleep() instead of usleep()
POSIX.1-2001 declares usleep() function obsolete and POSIX.1-2008
removes it. Replace all usleep code with nanosleep equivalent.
Signed-off-by: Daniel Mierswa <impulze@impulze.org>
---
| 333 +++++++++++++++++-----------------
| 5 +-
udev/udev-event.c | 5 +-
udev/udev-rules.c | 5 +-
udev/udevadm-settle.c | 5 +-
5 files changed, 186 insertions(+), 167 deletions(-)
--git a/extras/modem-modeswitch/ma8280p_us.c b/extras/modem-modeswitch/ma8280p_us.c
index 13d1116..9224435 100644
--- a/extras/modem-modeswitch/ma8280p_us.c
+++ b/extras/modem-modeswitch/ma8280p_us.c
@@ -92,6 +92,13 @@
#include "utils.h"
#include "ma8280p_us.h"
+/* suspend the process execution for msec milliseconds */
+static void msuspend(unsigned short msec)
+{
+ struct timespec duration = { 0, msec * 1000 * 1000 };
+ nanosleep(&duration, NULL);
+}
+
int ma8280p_switch (struct usb_dev_handle *devh, struct usb_device *dev)
{
int ret = 1;
@@ -104,11 +111,11 @@ int ma8280p_switch (struct usb_dev_handle *devh, struct usb_device *dev)
}
ret = usb_get_descriptor(devh, 0x0000001, 0x0000000, buf, 0x0000012);
- usleep(6*1000);
+ msuspend(6);
ret = usb_get_descriptor(devh, 0x0000001, 0x0000000, buf, 0x0000012);
- usleep(6*1000);
+ msuspend(6);
ret = usb_get_descriptor(devh, 0x0000002, 0x0000000, buf, 0x0000400);
- usleep(10*1000);
+ msuspend(10);
ret = usb_release_interface(devh, 0);
if (ret != 0)
debug ("%s: failed to release interface before set_configuration: %d", dev->filename, ret);
@@ -117,335 +124,335 @@ int ma8280p_switch (struct usb_dev_handle *devh, struct usb_device *dev)
if (ret != 0)
debug ("%s: claim after set_configuration failed with error %d", dev->filename, ret);
//ret = usb_set_altinterface(devh, 0);
- //usleep(33*1000);
+ //msuspend(33);
ret = usb_control_msg(devh, USB_TYPE_CLASS + USB_RECIP_INTERFACE + USB_ENDPOINT_IN, 0x0000001, 0x0000300, 0x0000000, buf, 0x0000008, 1000);
- usleep(5*1000);
+ msuspend(5);
memcpy(buf, "\xb0\x04\x00\x00\x02\x90\x26\x86", 0x0000008);
ret = usb_control_msg(devh, USB_TYPE_CLASS + USB_RECIP_INTERFACE, 0x0000009, 0x0000300, 0x0000000, buf, 0x0000008, 1000);
- usleep(4*1000);
+ msuspend(4);
memcpy(buf, "\xb0\x04\x00\x00\x02\x90\x26\x86", 0x0000008);
ret = usb_control_msg(devh, USB_TYPE_CLASS + USB_RECIP_INTERFACE, 0x0000009, 0x0000300, 0x0000000, buf, 0x0000008, 1000);
- usleep(4*1000);
+ msuspend(4);
- usleep(4*1000);
+ msuspend(4);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(6*1000);
+ msuspend(6);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(1*1000);
+ msuspend(1);
//URB_FUNCTION_GET_STATUS_FROM_ENDPOINT skipped
- usleep(4*1000);
+ msuspend(4);
memcpy(buf, "\x37\x01\xfe\xdb\xc1\x33\x1f\x83", 0x0000008);
ret = usb_interrupt_write(devh, 0x00000002, buf, 0x0000008, 1000);
- usleep(3*1000);
+ msuspend(3);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(1*1000);
+ msuspend(1);
memcpy(buf, "\x37\x0e\xb5\x9d\x3b\x8a\x91\x51", 0x0000008);
ret = usb_interrupt_write(devh, 0x00000002, buf, 0x0000008, 1000);
- usleep(7*1000);
+ msuspend(7);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(1*1000);
+ msuspend(1);
memcpy(buf, "\x34\x87\xba\x0d\xfc\x8a\x91\x51", 0x0000008);
ret = usb_interrupt_write(devh, 0x00000002, buf, 0x0000008, 1000);
- usleep(7*1000);
+ msuspend(7);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(2*1000);
+ msuspend(2);
//URB_FUNCTION_GET_STATUS_FROM_ENDPOINT skipped
- usleep(4*1000);
+ msuspend(4);
memcpy(buf, "\x37\x01\xfe\xdb\xc1\x33\x1f\x83", 0x0000008);
ret = usb_interrupt_write(devh, 0x00000002, buf, 0x0000008, 1000);
- usleep(2*1000);
+ msuspend(2);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(1*1000);
+ msuspend(1);
memcpy(buf, "\x37\x0e\xb5\x9d\x3b\x8a\x91\x51", 0x0000008);
ret = usb_interrupt_write(devh, 0x00000002, buf, 0x0000008, 1000);
- usleep(7*1000);
+ msuspend(7);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(1*1000);
+ msuspend(1);
memcpy(buf, "\x34\x87\xba\x0d\xfc\x8a\x91\x51", 0x0000008);
ret = usb_interrupt_write(devh, 0x00000002, buf, 0x0000008, 1000);
- usleep(7*1000);
+ msuspend(7);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(8*1000);
+ msuspend(8);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(1*1000);
+ msuspend(1);
//URB_FUNCTION_GET_STATUS_FROM_ENDPOINT skipped
- usleep(4*1000);
+ msuspend(4);
memcpy(buf, "\x33\x04\xfe\x00\xf4\x6c\x1f\xf0", 0x0000008);
ret = usb_interrupt_write(devh, 0x00000002, buf, 0x0000008, 1000);
- usleep(3*1000);
+ msuspend(3);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
- usleep(1*1000);
+ msuspend(1);
//URB_FUNCTION_GET_STATUS_FROM_ENDPOINT skipped
- usleep(4*1000);
+ msuspend(4);
memcpy(buf, "\x32\x07\xfe\xf0\x29\xb9\x3a\xf0", 0x0000008);
ret = usb_interrupt_write(devh, 0x00000002, buf, 0x0000008, 1000);
- usleep(3*1000);
+ msuspend(3);
ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
if (buf)
--git a/extras/scsi_id/scsi_serial.c b/extras/scsi_id/scsi_serial.c
index 0f883dc..8abe2b0 100644
--- a/extras/scsi_id/scsi_serial.c
+++ b/extras/scsi_id/scsi_serial.c
@@ -852,7 +852,10 @@ int scsi_get_serial(struct udev *udev,
info(udev, "%s: cannot open %s: %s\n", dev_scsi->kernel, devname, strerror(errno));
if (errno != EBUSY)
break;
- usleep(500000 + (rand() % 100000) );
+ {
+ struct timespec duration = { 0, 500 * 1000 * 1000 + (rand() % (100 * 1000 * 1000)) };
+ nanosleep(&duration, NULL);
+ }
}
if (fd < 0)
return 1;
diff --git a/udev/udev-event.c b/udev/udev-event.c
index 3a6c71a..36cc7b7 100644
--- a/udev/udev-event.c
+++ b/udev/udev-event.c
@@ -518,7 +518,10 @@ static int rename_netif(struct udev_event *event)
}
dbg(event->udev, "wait for netif '%s' to become free, loop=%i\n",
event->name, (90 * 20) - loop);
- usleep(1000 * 1000 / 20);
+ {
+ struct timespec duration = { 0, 1000 * 1000 * 1000 / 20 };
+ nanosleep(&duration, NULL);
+ }
}
}
exit:
diff --git a/udev/udev-rules.c b/udev/udev-rules.c
index eeb71bc..fa14d79 100644
--- a/udev/udev-rules.c
+++ b/udev/udev-rules.c
@@ -825,7 +825,10 @@ static int wait_for_file(struct udev_device *dev, const char *file, int timeout)
return -2;
}
info(udev, "wait for '%s' for %i mseconds\n", file, 1000 / WAIT_LOOP_PER_SECOND);
- usleep(1000 * 1000 / WAIT_LOOP_PER_SECOND);
+ {
+ struct timespec duration = { 0, 1000 * 1000 * 1000 / WAIT_LOOP_PER_SECOND };
+ nanosleep(&duration, NULL);
+ }
}
info(udev, "waiting for '%s' failed\n", file);
return -1;
diff --git a/udev/udevadm-settle.c b/udev/udevadm-settle.c
index 6828192..7a11a52 100644
--- a/udev/udevadm-settle.c
+++ b/udev/udevadm-settle.c
@@ -203,7 +203,10 @@ int udevadm_settle(struct udev *udev, int argc, char *argv[])
if (is_timeout)
break;
- usleep(1000 * 1000 / LOOP_PER_SECOND);
+ {
+ struct timespec duration = { 0 , 1000 * 1000 * 1000 / LOOP_PER_SECOND };
+ nanosleep(&duration, NULL);
+ }
}
/* if we reached the timeout, print the list of remaining events */
--
1.6.4.1
^ permalink raw reply related [flat|nested] 7+ messages in thread
end of thread, other threads:[~2009-08-24 17:23 UTC | newest]
Thread overview: 7+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2009-08-17 14:20 [PATCH] Use nanosleep() instead of usleep() Daniel Mierswa
2009-08-18 0:22 ` Kay Sievers
2009-08-18 5:08 ` Daniel Mierswa
2009-08-19 2:17 ` Kay Sievers
2009-08-19 5:35 ` Daniel Mierswa
2009-08-24 16:41 ` Scott James Remnant
2009-08-24 17:23 ` Daniel Mierswa
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.