[PATCH 2.5] : Discovery locking fixes

From: Jean Tourrilhes (jt@bougret.hpl.hp.com)
Date: Thu Feb 20 2003 - 19:06:46 EST


ir253_discovery_locking-2.diff :
------------------------------
        o [CRITICA] Fix remaining locking problem with discovery log
        o [CRITICA] Don't call expiry callback under spinlock
        o [FEATURE] Simplify/cleanup/optimise discovery/expiry code

diff -u -p -r linux/include/net/irda-d4/af_irda.h linux/include/net/irda/af_irda.h
--- linux/include/net/irda-d4/af_irda.h Mon Nov 4 14:30:49 2002
+++ linux/include/net/irda/af_irda.h Wed Jan 8 17:00:47 2003
@@ -52,8 +52,8 @@ struct irda_sock {
         __u8 max_header_size;
         struct qos_info qos_tx;
 
- __u16 mask; /* Hint bits mask */
- __u16 hints; /* Hint bits */
+ __u16_host_order mask; /* Hint bits mask */
+ __u16_host_order hints; /* Hint bits */
 
         void *ckey; /* IrLMP client handle */
         void *skey; /* IrLMP service handle */
@@ -63,7 +63,7 @@ struct irda_sock {
         struct ias_value *ias_result; /* Result of remote IAS query */
 
         hashbin_t *cachelog; /* Result of discovery query */
- struct discovery_t *cachediscovery; /* Result of selective discovery query */
+ __u32 cachedaddr; /* Result of selective discovery query */
 
         int nslots; /* Number of slots to use for discovery */
 
diff -u -p -r linux/include/net/irda-d4/discovery.h linux/include/net/irda/discovery.h
--- linux/include/net/irda-d4/discovery.h Mon Nov 4 14:30:36 2002
+++ linux/include/net/irda/discovery.h Wed Jan 8 17:00:47 2003
@@ -46,12 +46,20 @@
  * little endian format. A little endian machine stores MSB of word in
  * byte[1] and LSB in byte[0]. A big endian machine stores MSB in byte[0]
  * and LSB in byte[1].
+ *
+ * This structure is used in the code for things that are endian neutral
+ * but that fit in a word so that we can manipulate them efficiently.
+ * By endian neutral, I mean things that are really an array of bytes,
+ * and always used as such, for example the hint bits. Jean II
  */
 typedef union {
         __u16 word;
         __u8 byte[2];
 } __u16_host_order;
 
+/* Same purpose, different application */
+#define u16ho(array) (* ((__u16 *) array))
+
 /* Types of discovery */
 typedef enum {
         DISCOVERY_LOG, /* What's in our discovery log */
@@ -62,30 +70,31 @@ typedef enum {
 
 #define NICKNAME_MAX_LEN 21
 
+/* Basic discovery information about a peer */
+typedef struct irda_device_info discinfo_t; /* linux/irda.h */
+
 /*
  * The DISCOVERY structure is used for both discovery requests and responses
  */
 typedef struct discovery_t {
- irda_queue_t q; /* Must be first! */
+ irda_queue_t q; /* Must be first! */
+
+ discinfo_t data; /* Basic discovery information */
+ int name_len; /* Lenght of nickname */
 
- __u32 saddr; /* Which link the device was discovered */
- __u32 daddr; /* Remote device address */
- LAP_REASON condition; /* More info about the discovery */
-
- __u16_host_order hints; /* Discovery hint bits */
- __u8 charset; /* Encoding of nickname */
- char nickname[22]; /* The name of the device (21 bytes + \0) */
- int name_len; /* Lenght of nickname */
-
- int gen_addr_bit; /* Need to generate a new device address? */
- int nslots; /* Number of slots to use when discovering */
- unsigned long timestamp; /* Time discovered */
- unsigned long first_timestamp; /* First time discovered */
+ LAP_REASON condition; /* More info about the discovery */
+ int gen_addr_bit; /* Need to generate a new device
+ * address? */
+ int nslots; /* Number of slots to use when
+ * discovering */
+ unsigned long timestamp; /* Last time discovered */
+ unsigned long firststamp; /* First time discovered */
 } discovery_t;
 
 void irlmp_add_discovery(hashbin_t *cachelog, discovery_t *discovery);
 void irlmp_add_discovery_log(hashbin_t *cachelog, hashbin_t *log);
 void irlmp_expire_discoveries(hashbin_t *log, __u32 saddr, int force);
-struct irda_device_info *irlmp_copy_discoveries(hashbin_t *log, int *pn, __u16 mask);
+struct irda_device_info *irlmp_copy_discoveries(hashbin_t *log, int *pn,
+ __u16 mask, int old_entries);
 
 #endif
diff -u -p -r linux/include/net/irda-d4/irlan_client.h linux/include/net/irda/irlan_client.h
--- linux/include/net/irda-d4/irlan_client.h Mon Nov 4 14:30:47 2002
+++ linux/include/net/irda/irlan_client.h Wed Jan 8 17:00:47 2003
@@ -34,7 +34,7 @@
 #include <net/irda/irlan_event.h>
 
 void irlan_client_start_kick_timer(struct irlan_cb *self, int timeout);
-void irlan_client_discovery_indication(discovery_t *, DISCOVERY_MODE, void *);
+void irlan_client_discovery_indication(discinfo_t *, DISCOVERY_MODE, void *);
 void irlan_client_wakeup(struct irlan_cb *self, __u32 saddr, __u32 daddr);
 
 void irlan_client_open_ctrl_tsap( struct irlan_cb *self);
diff -u -p -r linux/include/net/irda-d4/irlmp.h linux/include/net/irda/irlmp.h
--- linux/include/net/irda-d4/irlmp.h Mon Nov 4 14:30:04 2002
+++ linux/include/net/irda/irlmp.h Wed Jan 8 17:00:47 2003
@@ -58,7 +58,7 @@
 #define LM_IDLE_TIMEOUT 2*HZ /* 2 seconds for now */
 
 typedef enum {
- S_PNP,
+ S_PNP = 0,
         S_PDA,
         S_COMPUTER,
         S_PRINTER,
@@ -72,22 +72,24 @@ typedef enum {
         S_END,
 } SERVICE;
 
-typedef void (*DISCOVERY_CALLBACK1) (discovery_t *, DISCOVERY_MODE, void *);
-typedef void (*DISCOVERY_CALLBACK2) (hashbin_t *, void *);
+/* For selective discovery */
+typedef void (*DISCOVERY_CALLBACK1) (discinfo_t *, DISCOVERY_MODE, void *);
+/* For expiry (the same) */
+typedef void (*DISCOVERY_CALLBACK2) (discinfo_t *, DISCOVERY_MODE, void *);
 
 typedef struct {
         irda_queue_t queue; /* Must be first */
 
- __u16 hints; /* Hint bits */
+ __u16_host_order hints; /* Hint bits */
 } irlmp_service_t;
 
 typedef struct {
         irda_queue_t queue; /* Must be first */
 
- __u16 hint_mask;
+ __u16_host_order hint_mask;
 
         DISCOVERY_CALLBACK1 disco_callback; /* Selective discovery */
- DISCOVERY_CALLBACK1 expir_callback; /* Selective expiration */
+ DISCOVERY_CALLBACK2 expir_callback; /* Selective expiration */
         void *priv; /* Used to identify client */
 } irlmp_client_t;
 
@@ -199,11 +201,11 @@ __u16 irlmp_service_to_hint(int service)
 void *irlmp_register_service(__u16 hints);
 int irlmp_unregister_service(void *handle);
 void *irlmp_register_client(__u16 hint_mask, DISCOVERY_CALLBACK1 disco_clb,
- DISCOVERY_CALLBACK1 expir_clb, void *priv);
+ DISCOVERY_CALLBACK2 expir_clb, void *priv);
 int irlmp_unregister_client(void *handle);
 int irlmp_update_client(void *handle, __u16 hint_mask,
                         DISCOVERY_CALLBACK1 disco_clb,
- DISCOVERY_CALLBACK1 expir_clb, void *priv);
+ DISCOVERY_CALLBACK2 expir_clb, void *priv);
 
 void irlmp_register_link(struct irlap_cb *, __u32 saddr, notify_t *);
 void irlmp_unregister_link(__u32 saddr);
@@ -222,11 +224,11 @@ int irlmp_disconnect_request(struct lsa
 
 void irlmp_discovery_confirm(hashbin_t *discovery_log, DISCOVERY_MODE mode);
 void irlmp_discovery_request(int nslots);
-struct irda_device_info *irlmp_get_discoveries(int *pn, __u16 mask, int nslots);
+discinfo_t *irlmp_get_discoveries(int *pn, __u16 mask, int nslots);
 void irlmp_do_expiry(void);
 void irlmp_do_discovery(int nslots);
 discovery_t *irlmp_get_discovery_response(void);
-void irlmp_discovery_expiry(discovery_t *expiry);
+void irlmp_discovery_expiry(discinfo_t *expiry, int number);
 
 int irlmp_data_request(struct lsap_cb *, struct sk_buff *);
 void irlmp_data_indication(struct lsap_cb *, struct sk_buff *);
diff -u -p -r linux/net/irda-d4/af_irda.c linux/net/irda/af_irda.c
--- linux/net/irda-d4/af_irda.c Tue Jan 7 17:59:03 2003
+++ linux/net/irda/af_irda.c Wed Jan 8 17:00:47 2003
@@ -401,11 +401,10 @@ static void irda_getvalue_confirm(int re
  *
  * Got a selective discovery indication from IrLMP.
  *
- * IrLMP is telling us that this node is matching our hint bit
- * filter. Check if it's a newly discovered node (or if node changed its
- * hint bits), and then wake up any process waiting for answer...
+ * IrLMP is telling us that this node is new and matching our hint bit
+ * filter. Wake up any process waiting for answer...
  */
-static void irda_selective_discovery_indication(discovery_t *discovery,
+static void irda_selective_discovery_indication(discinfo_t *discovery,
                                                 DISCOVERY_MODE mode,
                                                 void *priv)
 {
@@ -419,18 +418,8 @@ static void irda_selective_discovery_ind
                 return;
         }
 
- /* Check if node is discovered is a new one or an old one.
- * We check when how long ago this node was discovered, with a
- * coarse timeout (we may miss some discovery events or be delayed).
- * Note : by doing this test here, we avoid waking up a process ;-)
- */
- if((jiffies - discovery->first_timestamp) >
- (sysctl_discovery_timeout * HZ)) {
- return; /* Too old, not interesting -> goodbye */
- }
-
         /* Pass parameter to the caller */
- self->cachediscovery = discovery;
+ self->cachedaddr = discovery->daddr;
 
         /* Wake up process if its waiting for device to be discovered */
         wake_up_interruptible(&self->query_wait);
@@ -455,7 +444,7 @@ static void irda_discovery_timeout(u_lon
 
         /* Nothing for the caller */
         self->cachelog = NULL;
- self->cachediscovery = NULL;
+ self->cachedaddr = 0;
         self->errno = -ETIME;
 
         /* Wake up process if its still waiting... */
@@ -627,7 +616,7 @@ static int irda_find_lsap_sel(struct ird
  */
 static int irda_discover_daddr_and_lsap_sel(struct irda_sock *self, char *name)
 {
- struct irda_device_info *discoveries; /* Copy of the discovery log */
+ discinfo_t *discoveries; /* Copy of the discovery log */
         int number; /* Number of nodes in the log */
         int i;
         int err = -ENETUNREACH;
@@ -642,7 +631,8 @@ static int irda_discover_daddr_and_lsap_
          * Note : we have to use irlmp_get_discoveries(), as opposed
          * to play with the cachelog directly, because while we are
          * making our ias query, le log might change... */
- discoveries = irlmp_get_discoveries(&number, self->mask, self->nslots);
+ discoveries = irlmp_get_discoveries(&number, self->mask.word,
+ self->nslots);
         /* Check if the we got some results */
         if (discoveries == NULL)
                 return -ENETUNREACH; /* No nodes discovered */
@@ -1137,7 +1127,7 @@ static int irda_create(struct socket *so
 
         /* Register as a client with IrLMP */
         self->ckey = irlmp_register_client(0, NULL, NULL, NULL);
- self->mask = 0xffff;
+ self->mask.word = 0xffff;
         self->rx_flow = self->tx_flow = FLOW_START;
         self->nslots = DISCOVERY_DEFAULT_SLOTS;
         self->daddr = DEV_ADDR_ANY; /* Until we get connected */
@@ -1999,6 +1989,7 @@ static int irda_setsockopt(struct socket
                 if (optlen < sizeof(int))
                         return -EINVAL;
 
+ /* The input is really a (__u8 hints[2]), easier as an int */
                 if (get_user(opt, (int *)optval))
                         return -EFAULT;
 
@@ -2017,16 +2008,17 @@ static int irda_setsockopt(struct socket
                 if (optlen < sizeof(int))
                         return -EINVAL;
 
+ /* The input is really a (__u8 hints[2]), easier as an int */
                 if (get_user(opt, (int *)optval))
                         return -EFAULT;
 
                 /* Set the new hint mask */
- self->mask = (__u16) opt;
+ self->mask.word = (__u16) opt;
                 /* Mask out extension bits */
- self->mask &= 0x7f7f;
+ self->mask.word &= 0x7f7f;
                 /* Check if no bits */
- if(!self->mask)
- self->mask = 0xFFFF;
+ if(!self->mask.word)
+ self->mask.word = 0xFFFF;
 
                 break;
         default:
@@ -2117,7 +2109,7 @@ static int irda_getsockopt(struct socket
         switch (optname) {
         case IRLMP_ENUMDEVICES:
                 /* Ask lmp for the current discovery log */
- discoveries = irlmp_get_discoveries(&list.len, self->mask,
+ discoveries = irlmp_get_discoveries(&list.len, self->mask.word,
                                                     self->nslots);
                 /* Check if the we got some results */
                 if (discoveries == NULL)
@@ -2349,7 +2341,7 @@ bed:
                         return -EFAULT;
 
                 /* Tell IrLMP we want to be notified */
- irlmp_update_client(self->ckey, self->mask,
+ irlmp_update_client(self->ckey, self->mask.word,
                                     irda_selective_discovery_indication,
                                     NULL, (void *) self);
 
@@ -2357,7 +2349,7 @@ bed:
                 irlmp_discovery_request(self->nslots);
 
                 /* Wait until a node is discovered */
- if (!self->cachediscovery) {
+ if (!self->cachedaddr) {
                         int ret = 0;
 
                         IRDA_DEBUG(1, "%s(), nothing discovered yet, going to sleep...\n", __FUNCTION__);
@@ -2372,7 +2364,7 @@ bed:
 
                         /* Wait for IR-LMP to call us back */
                         __wait_event_interruptible(self->query_wait,
- (self->cachediscovery!=NULL || self->errno==-ETIME),
+ (self->cachedaddr != 0 || self->errno == -ETIME),
                                                    ret);
 
                         /* If watchdog is still activated, kill it! */
@@ -2389,19 +2381,25 @@ bed:
                                    __FUNCTION__);
 
                 /* Tell IrLMP that we have been notified */
- irlmp_update_client(self->ckey, self->mask, NULL, NULL, NULL);
+ irlmp_update_client(self->ckey, self->mask.word,
+ NULL, NULL, NULL);
 
                 /* Check if the we got some results */
- if (!self->cachediscovery)
+ if (!self->cachedaddr)
                         return -EAGAIN; /* Didn't find any devices */
+ daddr = self->cachedaddr;
                 /* Cleanup */
- self->cachediscovery = NULL;
+ self->cachedaddr = 0;
 
- /* Note : We don't return anything to the user.
- * We could return the device that triggered the wake up,
- * but it's probably better to force the user to query
- * the whole discovery log and let him pick one device...
+ /* We return the daddr of the device that trigger the
+ * wakeup. As irlmp pass us only the new devices, we
+ * are sure that it's not an old device.
+ * If the user want more details, he should query
+ * the whole discovery log and pick one device...
                  */
+ if (put_user(daddr, (int *)optval))
+ return -EFAULT;
+
                 break;
         default:
                 return -ENOPROTOOPT;
diff -u -p -r linux/net/irda-d4/discovery.c linux/net/irda/discovery.c
--- linux/net/irda-d4/discovery.c Mon Nov 4 14:30:15 2002
+++ linux/net/irda/discovery.c Wed Jan 8 17:00:47 2003
@@ -59,7 +59,7 @@ void irlmp_add_discovery(hashbin_t *cach
         unsigned long flags;
 
         /* Set time of first discovery if node is new (see below) */
- new->first_timestamp = new->timestamp;
+ new->firststamp = new->timestamp;
 
         spin_lock_irqsave(&cachelog->hb_spinlock, flags);
 
@@ -76,24 +76,24 @@ void irlmp_add_discovery(hashbin_t *cach
                 /* Be sure to stay one item ahead */
                 discovery = (discovery_t *) hashbin_get_next(cachelog);
 
- if ((node->saddr == new->saddr) &&
- ((node->daddr == new->daddr) ||
- (strcmp(node->nickname, new->nickname) == 0)))
+ if ((node->data.saddr == new->data.saddr) &&
+ ((node->data.daddr == new->data.daddr) ||
+ (strcmp(node->data.info, new->data.info) == 0)))
                 {
                         /* This discovery is a previous discovery
                          * from the same device, so just remove it
                          */
                         hashbin_remove_this(cachelog, (irda_queue_t *) node);
- /* Check if hints bits have changed */
- if(node->hints.word == new->hints.word)
+ /* Check if hints bits are unchanged */
+ if(u16ho(node->data.hints) == u16ho(new->data.hints))
                                 /* Set time of first discovery for this node */
- new->first_timestamp = node->first_timestamp;
+ new->firststamp = node->firststamp;
                         kfree(node);
                 }
         }
 
         /* Insert the new and updated version */
- hashbin_insert(cachelog, (irda_queue_t *) new, new->daddr, NULL);
+ hashbin_insert(cachelog, (irda_queue_t *) new, new->data.daddr, NULL);
 
         spin_unlock_irqrestore(&cachelog->hb_spinlock, flags);
 }
@@ -147,27 +147,50 @@ void irlmp_add_discovery_log(hashbin_t *
  */
 void irlmp_expire_discoveries(hashbin_t *log, __u32 saddr, int force)
 {
- discovery_t *discovery, *curr;
- unsigned long flags;
+ discovery_t * discovery;
+ discovery_t * curr;
+ unsigned long flags;
+ discinfo_t * buffer = NULL;
+ int n; /* Size of the full log */
+ int i = 0; /* How many we expired */
 
+ ASSERT(log != NULL, return;);
         IRDA_DEBUG(4, "%s()\n", __FUNCTION__);
 
         spin_lock_irqsave(&log->hb_spinlock, flags);
 
         discovery = (discovery_t *) hashbin_get_first(log);
         while (discovery != NULL) {
- curr = discovery;
-
                 /* Be sure to be one item ahead */
+ curr = discovery;
                 discovery = (discovery_t *) hashbin_get_next(log);
 
                 /* Test if it's time to expire this discovery */
- if ((curr->saddr == saddr) &&
+ if ((curr->data.saddr == saddr) &&
                     (force ||
                      ((jiffies - curr->timestamp) > DISCOVERY_EXPIRE_TIMEOUT)))
                 {
- /* Tell IrLMP and registered clients about it */
- irlmp_discovery_expiry(curr);
+ /* Create buffer as needed.
+ * As this function get called a lot and most time
+ * we don't have anything to put in the log (we are
+ * quite picky), we can save a lot of overhead
+ * by not calling kmalloc. Jean II */
+ if(buffer == NULL) {
+ /* Create the client specific buffer */
+ n = HASHBIN_GET_SIZE(log);
+ buffer = kmalloc(n * sizeof(struct irda_device_info), GFP_ATOMIC);
+ if (buffer == NULL) {
+ spin_unlock_irqrestore(&log->hb_spinlock, flags);
+ return;
+ }
+
+ }
+
+ /* Copy discovery information */
+ memcpy(&(buffer[i]), &(curr->data),
+ sizeof(discinfo_t));
+ i++;
+
                         /* Remove it from the log */
                         curr = hashbin_remove_this(log, (irda_queue_t *) curr);
                         if (curr)
@@ -175,9 +198,23 @@ void irlmp_expire_discoveries(hashbin_t
                 }
         }
 
+ /* Drop the spinlock before calling the higher layers, as
+ * we can't guarantee they won't call us back and create a
+ * deadlock. We will work on our own private data, so we
+ * don't care to be interupted. - Jean II */
         spin_unlock_irqrestore(&log->hb_spinlock, flags);
+
+ if(buffer == NULL)
+ return;
+
+ /* Tell IrLMP and registered clients about it */
+ irlmp_discovery_expiry(buffer, i);
+
+ /* Free up our buffer */
+ kfree(buffer);
 }
 
+#if 0
 /*
  * Function irlmp_dump_discoveries (log)
  *
@@ -193,13 +230,14 @@ void irlmp_dump_discoveries(hashbin_t *l
         discovery = (discovery_t *) hashbin_get_first(log);
         while (discovery != NULL) {
                 IRDA_DEBUG(0, "Discovery:\n");
- IRDA_DEBUG(0, " daddr=%08x\n", discovery->daddr);
- IRDA_DEBUG(0, " saddr=%08x\n", discovery->saddr);
- IRDA_DEBUG(0, " nickname=%s\n", discovery->nickname);
+ IRDA_DEBUG(0, " daddr=%08x\n", discovery->data.daddr);
+ IRDA_DEBUG(0, " saddr=%08x\n", discovery->data.saddr);
+ IRDA_DEBUG(0, " nickname=%s\n", discovery->data.info);
 
                 discovery = (discovery_t *) hashbin_get_next(log);
         }
 }
+#endif
 
 /*
  * Function irlmp_copy_discoveries (log, pn, mask)
@@ -221,43 +259,49 @@ void irlmp_dump_discoveries(hashbin_t *l
  * Note : the client must kfree himself() the log...
  * Jean II
  */
-struct irda_device_info *irlmp_copy_discoveries(hashbin_t *log, int *pn, __u16 mask)
+struct irda_device_info *irlmp_copy_discoveries(hashbin_t *log, int *pn,
+ __u16 mask, int old_entries)
 {
- discovery_t * discovery;
- unsigned long flags;
- struct irda_device_info * buffer;
- int i = 0;
- int n;
+ discovery_t * discovery;
+ unsigned long flags;
+ discinfo_t * buffer = NULL;
+ int j_timeout = (sysctl_discovery_timeout * HZ);
+ int n; /* Size of the full log */
+ int i = 0; /* How many we picked */
 
         ASSERT(pn != NULL, return NULL;);
+ ASSERT(log != NULL, return NULL;);
 
- /* Check if log is empty */
- if(log == NULL)
- return NULL;
-
- /* Save spin lock - spinlock should be discovery specific */
+ /* Save spin lock */
         spin_lock_irqsave(&log->hb_spinlock, flags);
 
- /* Create the client specific buffer */
- n = HASHBIN_GET_SIZE(log);
- buffer = kmalloc(n * sizeof(struct irda_device_info), GFP_ATOMIC);
- if (buffer == NULL) {
- spin_unlock_irqrestore(&log->hb_spinlock, flags);
- return NULL;
- }
-
         discovery = (discovery_t *) hashbin_get_first(log);
- while ((discovery != NULL) && (i < n)) {
- /* Mask out the ones we don't want */
- if (discovery->hints.word & mask) {
+ while (discovery != NULL) {
+ /* Mask out the ones we don't want :
+ * We want to match the discovery mask, and to get only
+ * the most recent one (unless we want old ones) */
+ if ((u16ho(discovery->data.hints) & mask) &&
+ ((old_entries) ||
+ ((jiffies - discovery->firststamp) < j_timeout)) ) {
+ /* Create buffer as needed.
+ * As this function get called a lot and most time
+ * we don't have anything to put in the log (we are
+ * quite picky), we can save a lot of overhead
+ * by not calling kmalloc. Jean II */
+ if(buffer == NULL) {
+ /* Create the client specific buffer */
+ n = HASHBIN_GET_SIZE(log);
+ buffer = kmalloc(n * sizeof(struct irda_device_info), GFP_ATOMIC);
+ if (buffer == NULL) {
+ spin_unlock_irqrestore(&log->hb_spinlock, flags);
+ return NULL;
+ }
+
+ }
+
                         /* Copy discovery information */
- buffer[i].saddr = discovery->saddr;
- buffer[i].daddr = discovery->daddr;
- buffer[i].charset = discovery->charset;
- buffer[i].hints[0] = discovery->hints.byte[0];
- buffer[i].hints[1] = discovery->hints.byte[1];
- strncpy(buffer[i].info, discovery->nickname,
- NICKNAME_MAX_LEN);
+ memcpy(&(buffer[i]), &(discovery->data),
+ sizeof(discinfo_t));
                         i++;
                 }
                 discovery = (discovery_t *) hashbin_get_next(log);
@@ -288,14 +332,14 @@ __u32 irlmp_find_device(hashbin_t *cache
         d = (discovery_t *) hashbin_get_first(cachelog);
         while (d != NULL) {
                 IRDA_DEBUG(1, "Discovery:\n");
- IRDA_DEBUG(1, " daddr=%08x\n", d->daddr);
- IRDA_DEBUG(1, " nickname=%s\n", d->nickname);
-
- if (strcmp(name, d->nickname) == 0) {
- *saddr = d->saddr;
+ IRDA_DEBUG(1, " daddr=%08x\n", d->data.daddr);
+ IRDA_DEBUG(1, " nickname=%s\n", d->data.info);
+
+ if (strcmp(name, d->data.info) == 0) {
+ *saddr = d->data.saddr;
                         
                         spin_unlock_irqrestore(&cachelog->hb_spinlock, flags);
- return d->daddr;
+ return d->data.daddr;
                 }
                 d = (discovery_t *) hashbin_get_next(cachelog);
         }
@@ -328,41 +372,41 @@ int discovery_proc_read(char *buf, char
 
         discovery = (discovery_t *) hashbin_get_first(cachelog);
         while (( discovery != NULL) && (len < length)) {
- len += sprintf(buf+len, "nickname: %s,", discovery->nickname);
+ len += sprintf(buf+len, "nickname: %s,", discovery->data.info);
                 
                 len += sprintf(buf+len, " hint: 0x%02x%02x",
- discovery->hints.byte[0],
- discovery->hints.byte[1]);
+ discovery->data.hints[0],
+ discovery->data.hints[1]);
 #if 0
- if ( discovery->hints.byte[0] & HINT_PNP)
+ if ( discovery->data.hints[0] & HINT_PNP)
                         len += sprintf( buf+len, "PnP Compatible ");
- if ( discovery->hints.byte[0] & HINT_PDA)
+ if ( discovery->data.hints[0] & HINT_PDA)
                         len += sprintf( buf+len, "PDA/Palmtop ");
- if ( discovery->hints.byte[0] & HINT_COMPUTER)
+ if ( discovery->data.hints[0] & HINT_COMPUTER)
                         len += sprintf( buf+len, "Computer ");
- if ( discovery->hints.byte[0] & HINT_PRINTER)
+ if ( discovery->data.hints[0] & HINT_PRINTER)
                         len += sprintf( buf+len, "Printer ");
- if ( discovery->hints.byte[0] & HINT_MODEM)
+ if ( discovery->data.hints[0] & HINT_MODEM)
                         len += sprintf( buf+len, "Modem ");
- if ( discovery->hints.byte[0] & HINT_FAX)
+ if ( discovery->data.hints[0] & HINT_FAX)
                         len += sprintf( buf+len, "Fax ");
- if ( discovery->hints.byte[0] & HINT_LAN)
+ if ( discovery->data.hints[0] & HINT_LAN)
                         len += sprintf( buf+len, "LAN Access ");
                 
- if ( discovery->hints.byte[1] & HINT_TELEPHONY)
+ if ( discovery->data.hints[1] & HINT_TELEPHONY)
                         len += sprintf( buf+len, "Telephony ");
- if ( discovery->hints.byte[1] & HINT_FILE_SERVER)
+ if ( discovery->data.hints[1] & HINT_FILE_SERVER)
                         len += sprintf( buf+len, "File Server ");
- if ( discovery->hints.byte[1] & HINT_COMM)
+ if ( discovery->data.hints[1] & HINT_COMM)
                         len += sprintf( buf+len, "IrCOMM ");
- if ( discovery->hints.byte[1] & HINT_OBEX)
+ if ( discovery->data.hints[1] & HINT_OBEX)
                         len += sprintf( buf+len, "IrOBEX ");
 #endif
                 len += sprintf(buf+len, ", saddr: 0x%08x",
- discovery->saddr);
+ discovery->data.saddr);
 
                 len += sprintf(buf+len, ", daddr: 0x%08x\n",
- discovery->daddr);
+ discovery->data.daddr);
                 
                 len += sprintf(buf+len, "\n");
                 
diff -u -p -r linux/net/irda-d4/ircomm/ircomm_tty_attach.c linux/net/irda/ircomm/ircomm_tty_attach.c
--- linux/net/irda-d4/ircomm/ircomm_tty_attach.c Mon Nov 4 14:30:50 2002
+++ linux/net/irda/ircomm/ircomm_tty_attach.c Wed Jan 8 17:00:47 2003
@@ -46,7 +46,7 @@
 #include <net/irda/ircomm_tty_attach.h>
 
 static void ircomm_tty_ias_register(struct ircomm_tty_cb *self);
-static void ircomm_tty_discovery_indication(discovery_t *discovery,
+static void ircomm_tty_discovery_indication(discinfo_t *discovery,
                                             DISCOVERY_MODE mode,
                                             void *priv);
 static void ircomm_tty_getvalue_confirm(int result, __u16 obj_id,
@@ -305,7 +305,7 @@ int ircomm_tty_send_initial_parameters(s
  * device it is, and which services it has.
  *
  */
-static void ircomm_tty_discovery_indication(discovery_t *discovery,
+static void ircomm_tty_discovery_indication(discinfo_t *discovery,
                                             DISCOVERY_MODE mode,
                                             void *priv)
 {
diff -u -p -r linux/net/irda-d4/irlan/irlan_client.c linux/net/irda/irlan/irlan_client.c
--- linux/net/irda-d4/irlan/irlan_client.c Mon Nov 4 14:30:31 2002
+++ linux/net/irda/irlan/irlan_client.c Wed Jan 8 17:00:47 2003
@@ -145,7 +145,7 @@ void irlan_client_wakeup(struct irlan_cb
  * Remote device with IrLAN server support discovered
  *
  */
-void irlan_client_discovery_indication(discovery_t *discovery,
+void irlan_client_discovery_indication(discinfo_t *discovery,
                                        DISCOVERY_MODE mode,
                                        void *priv)
 {
diff -u -p -r linux/net/irda-d4/irlap_event.c linux/net/irda/irlap_event.c
--- linux/net/irda-d4/irlap_event.c Mon Nov 4 14:30:33 2002
+++ linux/net/irda/irlap_event.c Wed Jan 8 17:00:47 2003
@@ -419,7 +419,7 @@ static int irlap_state_ndm(struct irlap_
                                                                    info->s);
                         if (self->slot == info->s) {
                                 discovery_rsp = irlmp_get_discovery_response();
- discovery_rsp->daddr = info->daddr;
+ discovery_rsp->data.daddr = info->daddr;
 
                                 irlap_send_discovery_xid_frame(self, info->S,
                                                                self->slot,
@@ -576,7 +576,7 @@ static int irlap_state_query(struct irla
                 ASSERT(info->discovery != NULL, return -1;);
 
                 IRDA_DEBUG(4, "%s(), daddr=%08x\n", __FUNCTION__,
- info->discovery->daddr);
+ info->discovery->data.daddr);
 
                 if (!self->discovery_log) {
                         WARNING("%s: discovery log is gone! "
@@ -586,7 +586,7 @@ static int irlap_state_query(struct irla
                 }
                 hashbin_insert(self->discovery_log,
                                (irda_queue_t *) info->discovery,
- info->discovery->daddr, NULL);
+ info->discovery->data.daddr, NULL);
 
                 /* Keep state */
                 /* irlap_next_state(self, LAP_QUERY); */
@@ -704,7 +704,7 @@ static int irlap_state_reply(struct irla
                         irlap_discovery_indication(self, info->discovery);
                 } else if ((info->s >= self->slot) && (!self->frame_sent)) {
                         discovery_rsp = irlmp_get_discovery_response();
- discovery_rsp->daddr = info->daddr;
+ discovery_rsp->data.daddr = info->daddr;
 
                         irlap_send_discovery_xid_frame(self, info->S,
                                                        self->slot, FALSE,
diff -u -p -r linux/net/irda-d4/irlap_frame.c linux/net/irda/irlap_frame.c
--- linux/net/irda-d4/irlap_frame.c Tue Jan 7 17:58:39 2003
+++ linux/net/irda/irlap_frame.c Wed Jan 8 17:00:47 2003
@@ -335,7 +335,7 @@ void irlap_send_discovery_xid_frame(stru
         if (command)
                 frame->daddr = cpu_to_le32(bcast);
         else
- frame->daddr = cpu_to_le32(discovery->daddr);
+ frame->daddr = cpu_to_le32(discovery->data.daddr);
 
         switch (S) {
         case 1:
@@ -366,20 +366,20 @@ void irlap_send_discovery_xid_frame(stru
         if (!command || (frame->slotnr == 0xff)) {
                 int len;
 
- if (discovery->hints.byte[0] & HINT_EXTENSION) {
+ if (discovery->data.hints[0] & HINT_EXTENSION) {
                         info = skb_put(skb, 2);
- info[0] = discovery->hints.byte[0];
- info[1] = discovery->hints.byte[1];
+ info[0] = discovery->data.hints[0];
+ info[1] = discovery->data.hints[1];
                 } else {
                         info = skb_put(skb, 1);
- info[0] = discovery->hints.byte[0];
+ info[0] = discovery->data.hints[0];
                 }
                 info = skb_put(skb, 1);
- info[0] = discovery->charset;
+ info[0] = discovery->data.charset;
 
                 len = IRDA_MIN(discovery->name_len, skb_tailroom(skb));
                 info = skb_put(skb, len);
- memcpy(info, discovery->nickname, len);
+ memcpy(info, discovery->data.info, len);
         }
         irlap_queue_xmit(self, skb);
 }
@@ -422,24 +422,25 @@ static void irlap_recv_discovery_xid_rsp
         }
         memset(discovery, 0, sizeof(discovery_t));
 
- discovery->daddr = info->daddr;
- discovery->saddr = self->saddr;
+ discovery->data.daddr = info->daddr;
+ discovery->data.saddr = self->saddr;
         discovery->timestamp = jiffies;
 
- IRDA_DEBUG(4, "%s(), daddr=%08x\n", __FUNCTION__, discovery->daddr);
+ IRDA_DEBUG(4, "%s(), daddr=%08x\n", __FUNCTION__,
+ discovery->data.daddr);
 
         discovery_info = skb_pull(skb, sizeof(struct xid_frame));
 
         /* Get info returned from peer */
- discovery->hints.byte[0] = discovery_info[0];
+ discovery->data.hints[0] = discovery_info[0];
         if (discovery_info[0] & HINT_EXTENSION) {
                 IRDA_DEBUG(4, "EXTENSION\n");
- discovery->hints.byte[1] = discovery_info[1];
- discovery->charset = discovery_info[2];
+ discovery->data.hints[1] = discovery_info[1];
+ discovery->data.charset = discovery_info[2];
                 text = (char *) &discovery_info[3];
         } else {
- discovery->hints.byte[1] = 0;
- discovery->charset = discovery_info[1];
+ discovery->data.hints[1] = 0;
+ discovery->data.charset = discovery_info[1];
                 text = (char *) &discovery_info[2];
         }
         /*
@@ -447,8 +448,8 @@ static void irlap_recv_discovery_xid_rsp
          * FCS bytes resides.
          */
         skb->data[skb->len] = '\0';
- strncpy(discovery->nickname, text, NICKNAME_MAX_LEN);
- discovery->name_len = strlen(discovery->nickname);
+ strncpy(discovery->data.info, text, NICKNAME_MAX_LEN);
+ discovery->name_len = strlen(discovery->data.info);
 
         info->discovery = discovery;
 
@@ -523,18 +524,18 @@ static void irlap_recv_discovery_xid_cmd
                         return;
                 }
 
- discovery->daddr = info->daddr;
- discovery->saddr = self->saddr;
+ discovery->data.daddr = info->daddr;
+ discovery->data.saddr = self->saddr;
                 discovery->timestamp = jiffies;
 
- discovery->hints.byte[0] = discovery_info[0];
+ discovery->data.hints[0] = discovery_info[0];
                 if (discovery_info[0] & HINT_EXTENSION) {
- discovery->hints.byte[1] = discovery_info[1];
- discovery->charset = discovery_info[2];
+ discovery->data.hints[1] = discovery_info[1];
+ discovery->data.charset = discovery_info[2];
                         text = (char *) &discovery_info[3];
                 } else {
- discovery->hints.byte[1] = 0;
- discovery->charset = discovery_info[1];
+ discovery->data.hints[1] = 0;
+ discovery->data.charset = discovery_info[1];
                         text = (char *) &discovery_info[2];
                 }
                 /*
@@ -542,8 +543,8 @@ static void irlap_recv_discovery_xid_cmd
                  * FCS bytes resides.
                  */
                 skb->data[skb->len] = '\0';
- strncpy(discovery->nickname, text, NICKNAME_MAX_LEN);
- discovery->name_len = strlen(discovery->nickname);
+ strncpy(discovery->data.info, text, NICKNAME_MAX_LEN);
+ discovery->name_len = strlen(discovery->data.info);
 
                 info->discovery = discovery;
         } else
diff -u -p -r linux/net/irda-d4/irlmp.c linux/net/irda/irlmp.c
--- linux/net/irda-d4/irlmp.c Mon Nov 4 14:30:50 2002
+++ linux/net/irda/irlmp.c Wed Jan 8 17:00:47 2003
@@ -401,8 +401,8 @@ int irlmp_connect_request(struct lsap_cb
                 }
 
                 if (discovery) {
- saddr = discovery->saddr;
- daddr = discovery->daddr;
+ saddr = discovery->data.saddr;
+ daddr = discovery->data.daddr;
                 }
                 spin_unlock_irqrestore(&irlmp->cachelog->hb_spinlock, flags);
         }
@@ -793,17 +793,17 @@ void irlmp_do_discovery(int nslots)
         }
 
         /* Construct new discovery info to be used by IrLAP, */
- irlmp->discovery_cmd.hints.word = irlmp->hints.word;
+ u16ho(irlmp->discovery_cmd.data.hints) = irlmp->hints.word;
 
         /*
          * Set character set for device name (we use ASCII), and
          * copy device name. Remember to make room for a \0 at the
          * end
          */
- irlmp->discovery_cmd.charset = CS_ASCII;
- strncpy(irlmp->discovery_cmd.nickname, sysctl_devname,
+ irlmp->discovery_cmd.data.charset = CS_ASCII;
+ strncpy(irlmp->discovery_cmd.data.info, sysctl_devname,
                 NICKNAME_MAX_LEN);
- irlmp->discovery_cmd.name_len = strlen(irlmp->discovery_cmd.nickname);
+ irlmp->discovery_cmd.name_len = strlen(irlmp->discovery_cmd.data.info);
         irlmp->discovery_cmd.nslots = nslots;
 
         /*
@@ -827,10 +827,13 @@ void irlmp_do_discovery(int nslots)
  *
  * Do a discovery of devices in front of the computer
  *
+ * If the caller has registered a client discovery callback, this
+ * allow him to receive the full content of the discovery log through
+ * this callback (as normally he will receive only new discoveries).
  */
 void irlmp_discovery_request(int nslots)
 {
- /* Return current cached discovery log */
+ /* Return current cached discovery log (in full) */
         irlmp_discovery_confirm(irlmp->cachelog, DISCOVERY_LOG);
 
         /*
@@ -854,6 +857,8 @@ void irlmp_discovery_request(int nslots)
  *
  * Return the current discovery log
  *
+ * If discovery is not enabled, you should call this function again
+ * after 1 or 2 seconds (i.e. after discovery has been done).
  */
 struct irda_device_info *irlmp_get_discoveries(int *pn, __u16 mask, int nslots)
 {
@@ -875,50 +880,9 @@ struct irda_device_info *irlmp_get_disco
         }
 
         /* Return current cached discovery log */
- return(irlmp_copy_discoveries(irlmp->cachelog, pn, mask));
+ return(irlmp_copy_discoveries(irlmp->cachelog, pn, mask, TRUE));
 }
 
-#if 0
-/*
- * Function irlmp_check_services (discovery)
- */
-void irlmp_check_services(discovery_t *discovery)
-{
- struct irlmp_client *client;
- __u8 *service_log;
- __u8 service;
- int i = 0;
-
- IRDA_DEBUG(1, "IrDA Discovered: %s\n", discovery->info);
- IRDA_DEBUG(1, " Services: ");
-
- service_log = irlmp_hint_to_service(discovery->hints.byte);
- if (!service_log)
- return;
-
- /*
- * Check all services on the device
- */
- while ((service = service_log[i++]) != S_END) {
- IRDA_DEBUG( 4, "service=%02x\n", service);
- client = hashbin_lock_find(irlmp->registry, service, NULL);
- if (entry && entry->discovery_callback) {
- IRDA_DEBUG( 4, "discovery_callback!\n");
-
- entry->discovery_callback(discovery);
- } else {
- /* Don't notify about the ANY service */
- if (service == S_ANY)
- continue;
- /*
- * Found no clients for dealing with this service,
- */
- }
- }
- kfree(service_log);
-}
-#endif
-
 /*
  * Function irlmp_notify_client (log)
  *
@@ -935,7 +899,9 @@ static inline void
 irlmp_notify_client(irlmp_client_t *client,
                     hashbin_t *log, DISCOVERY_MODE mode)
 {
- discovery_t *discovery;
+ discinfo_t *discoveries; /* Copy of the discovery log */
+ int number; /* Number of nodes in the log */
+ int i;
 
         IRDA_DEBUG(3, "%s()\n", __FUNCTION__);
 
@@ -944,28 +910,36 @@ irlmp_notify_client(irlmp_client_t *clie
                 return;
 
         /*
+ * Locking notes :
+ * the old code was manipulating the log directly, which was
+ * very racy. Now, we use copy_discoveries, that protects
+ * itself while dumping the log for us.
+ * The overhead of the copy is compensated by the fact that
+ * we only pass new discoveries in normal mode and don't
+ * pass the same old entry every 3s to the caller as we used
+ * to do (virtual function calling is expensive).
+ * Jean II
+ */
+
+ /*
          * Now, check all discovered devices (if any), and notify client
          * only about the services that the client is interested in
- * Note : most often, we will get called immediately following
- * a discovery, so the log is not going to expire.
- * On the other hand, comming here through irlmp_discovery_request()
- * is *very* problematic - Jean II
- * Can't use hashbin_find_next(), key is not unique. I'm running
- * out of options :-( - Jean II
+ * We also notify only about the new devices unless the caller
+ * explicity request a dump of the log. Jean II
          */
- discovery = (discovery_t *) hashbin_get_first(log);
- while (discovery != NULL) {
- IRDA_DEBUG(3, "discovery->daddr = 0x%08x\n", discovery->daddr);
-
- /*
- * Any common hint bits? Remember to mask away the extension
- * bits ;-)
- */
- if (client->hint_mask & discovery->hints.word & 0x7f7f)
- client->disco_callback(discovery, mode, client->priv);
+ discoveries = irlmp_copy_discoveries(log, &number,
+ client->hint_mask.word,
+ (mode == DISCOVERY_LOG));
+ /* Check if the we got some results */
+ if (discoveries == NULL)
+ return; /* No nodes discovered */
+
+ /* Pass all entries to the listener */
+ for(i = 0; i < number; i++)
+ client->disco_callback(&(discoveries[i]), mode, client->priv);
 
- discovery = (discovery_t *) hashbin_get_next(log);
- }
+ /* Free up our buffer */
+ kfree(discoveries);
 }
 
 /*
@@ -987,6 +961,7 @@ void irlmp_discovery_confirm(hashbin_t *
         if (!(HASHBIN_GET_SIZE(log)))
                 return;
 
+ /* For each client - notify callback may touch client list */
         client = (irlmp_client_t *) hashbin_get_first(irlmp->clients);
         while (NULL != hashbin_find_next(irlmp->clients, (long) client, NULL,
                                          (void *) &client_next) ) {
@@ -1005,26 +980,34 @@ void irlmp_discovery_confirm(hashbin_t *
  * registered for this event...
  *
  * Note : called exclusively from discovery.c
- * Note : as we are currently processing the log, the clients callback
- * should *NOT* attempt to touch the log now.
+ * Note : this is no longer called under discovery spinlock, so the
+ * client can do whatever he wants in the callback.
  */
-void irlmp_discovery_expiry(discovery_t *expiry)
+void irlmp_discovery_expiry(discinfo_t *expiries, int number)
 {
         irlmp_client_t *client;
         irlmp_client_t *client_next;
+ int i;
 
         IRDA_DEBUG(3, "%s()\n", __FUNCTION__);
 
- ASSERT(expiry != NULL, return;);
+ ASSERT(expiries != NULL, return;);
 
+ /* For each client - notify callback may touch client list */
         client = (irlmp_client_t *) hashbin_get_first(irlmp->clients);
         while (NULL != hashbin_find_next(irlmp->clients, (long) client, NULL,
                                          (void *) &client_next) ) {
- /* Check if we should notify client */
- if ((client->expir_callback) &&
- (client->hint_mask & expiry->hints.word & 0x7f7f))
- client->expir_callback(expiry, EXPIRY_TIMEOUT,
- client->priv);
+
+ /* Pass all entries to the listener */
+ for(i = 0; i < number; i++) {
+ /* Check if we should notify client */
+ if ((client->expir_callback) &&
+ (client->hint_mask.word & u16ho(expiries[i].hints)
+ & 0x7f7f) )
+ client->expir_callback(&(expiries[i]),
+ EXPIRY_TIMEOUT,
+ client->priv);
+ }
 
                 /* Next client */
                 client = client_next;
@@ -1043,18 +1026,18 @@ discovery_t *irlmp_get_discovery_respons
 
         ASSERT(irlmp != NULL, return NULL;);
 
- irlmp->discovery_rsp.hints.word = irlmp->hints.word;
+ u16ho(irlmp->discovery_rsp.data.hints) = irlmp->hints.word;
 
         /*
          * Set character set for device name (we use ASCII), and
          * copy device name. Remember to make room for a \0 at the
          * end
          */
- irlmp->discovery_rsp.charset = CS_ASCII;
+ irlmp->discovery_rsp.data.charset = CS_ASCII;
 
- strncpy(irlmp->discovery_rsp.nickname, sysctl_devname,
+ strncpy(irlmp->discovery_rsp.data.info, sysctl_devname,
                 NICKNAME_MAX_LEN);
- irlmp->discovery_rsp.name_len = strlen(irlmp->discovery_rsp.nickname);
+ irlmp->discovery_rsp.name_len = strlen(irlmp->discovery_rsp.data.info);
 
         return &irlmp->discovery_rsp;
 }
@@ -1291,6 +1274,7 @@ void irlmp_flow_indication(struct lap_cb
         }
 }
 
+#if 0
 /*
  * Function irlmp_hint_to_service (hint)
  *
@@ -1365,6 +1349,21 @@ __u8 *irlmp_hint_to_service(__u8 *hint)
 
         return service;
 }
+#endif
+
+const __u16 service_hint_mapping[S_END][2] = {
+ { HINT_PNP, 0 }, /* S_PNP */
+ { HINT_PDA, 0 }, /* S_PDA */
+ { HINT_COMPUTER, 0 }, /* S_COMPUTER */
+ { HINT_PRINTER, 0 }, /* S_PRINTER */
+ { HINT_MODEM, 0 }, /* S_MODEM */
+ { HINT_FAX, 0 }, /* S_FAX */
+ { HINT_LAN, 0 }, /* S_LAN */
+ { HINT_EXTENSION, HINT_TELEPHONY }, /* S_TELEPHONY */
+ { HINT_EXTENSION, HINT_COMM }, /* S_COMM */
+ { HINT_EXTENSION, HINT_OBEX }, /* S_OBEX */
+ { 0xFF, 0xFF }, /* S_ANY */
+};
 
 /*
  * Function irlmp_service_to_hint (service)
@@ -1377,46 +1376,9 @@ __u16 irlmp_service_to_hint(int service)
 {
         __u16_host_order hint;
 
- hint.word = 0;
+ hint.byte[0] = service_hint_mapping[service][0];
+ hint.byte[1] = service_hint_mapping[service][1];
 
- switch (service) {
- case S_PNP:
- hint.byte[0] |= HINT_PNP;
- break;
- case S_PDA:
- hint.byte[0] |= HINT_PDA;
- break;
- case S_COMPUTER:
- hint.byte[0] |= HINT_COMPUTER;
- break;
- case S_PRINTER:
- hint.byte[0] |= HINT_PRINTER;
- break;
- case S_MODEM:
- hint.byte[0] |= HINT_PRINTER;
- break;
- case S_LAN:
- hint.byte[0] |= HINT_LAN;
- break;
- case S_COMM:
- hint.byte[0] |= HINT_EXTENSION;
- hint.byte[1] |= HINT_COMM;
- break;
- case S_OBEX:
- hint.byte[0] |= HINT_EXTENSION;
- hint.byte[1] |= HINT_OBEX;
- break;
- case S_TELEPHONY:
- hint.byte[0] |= HINT_EXTENSION;
- hint.byte[1] |= HINT_TELEPHONY;
- break;
- case S_ANY:
- hint.word = 0xffff;
- break;
- default:
- IRDA_DEBUG( 1, "%s(), Unknown service!\n", __FUNCTION__);
- break;
- }
         return hint.word;
 }
 
@@ -1438,7 +1400,7 @@ void *irlmp_register_service(__u16 hints
                 IRDA_DEBUG(1, "%s(), Unable to kmalloc!\n", __FUNCTION__);
                 return 0;
         }
- service->hints = hints;
+ service->hints.word = hints;
         hashbin_insert(irlmp->services, (irda_queue_t *) service,
                        (long) service, NULL);
 
@@ -1481,7 +1443,7 @@ int irlmp_unregister_service(void *handl
         spin_lock_irqsave(&irlmp->services->hb_spinlock, flags);
         service = (irlmp_service_t *) hashbin_get_first(irlmp->services);
         while (service) {
- irlmp->hints.word |= service->hints;
+ irlmp->hints.word |= service->hints.word;
 
                 service = (irlmp_service_t *)hashbin_get_next(irlmp->services);
         }
@@ -1499,7 +1461,7 @@ int irlmp_unregister_service(void *handl
  * Returns: handle > 0 on success, 0 on error
  */
 void *irlmp_register_client(__u16 hint_mask, DISCOVERY_CALLBACK1 disco_clb,
- DISCOVERY_CALLBACK1 expir_clb, void *priv)
+ DISCOVERY_CALLBACK2 expir_clb, void *priv)
 {
         irlmp_client_t *client;
 
@@ -1514,7 +1476,7 @@ void *irlmp_register_client(__u16 hint_m
         }
 
         /* Register the details */
- client->hint_mask = hint_mask;
+ client->hint_mask.word = hint_mask;
         client->disco_callback = disco_clb;
         client->expir_callback = expir_clb;
         client->priv = priv;
@@ -1535,7 +1497,7 @@ void *irlmp_register_client(__u16 hint_m
  */
 int irlmp_update_client(void *handle, __u16 hint_mask,
                         DISCOVERY_CALLBACK1 disco_clb,
- DISCOVERY_CALLBACK1 expir_clb, void *priv)
+ DISCOVERY_CALLBACK2 expir_clb, void *priv)
 {
         irlmp_client_t *client;
 
@@ -1548,7 +1510,7 @@ int irlmp_update_client(void *handle, __
                 return -1;
         }
 
- client->hint_mask = hint_mask;
+ client->hint_mask.word = hint_mask;
         client->disco_callback = disco_clb;
         client->expir_callback = expir_clb;
         client->priv = priv;
diff -u -p -r linux/net/irda-d4/irnet/irnet_irda.c linux/net/irda/irnet/irnet_irda.c
--- linux/net/irda-d4/irnet/irnet_irda.c Mon Nov 4 14:30:05 2002
+++ linux/net/irda/irnet/irnet_irda.c Wed Jan 8 17:00:47 2003
@@ -1616,8 +1616,8 @@ irnet_discovervalue_confirm(int result,
  *
  * Got a discovery indication from IrLMP, post an event
  *
- * Note : IrLMP take care of matching the hint mask for us, we only
- * check if it is a "new" node...
+ * Note : IrLMP take care of matching the hint mask for us, and also
+ * check if it is a "new" node for us...
  *
  * As IrLMP filter on the IrLAN hint bit, we get both IrLAN and IrNET
  * nodes, so it's only at connection time that we will know if the
@@ -1633,7 +1633,7 @@ irnet_discovervalue_confirm(int result,
  * is to messy, so we leave that to user space...
  */
 static void
-irnet_discovery_indication(discovery_t * discovery,
+irnet_discovery_indication(discinfo_t * discovery,
                            DISCOVERY_MODE mode,
                            void * priv)
 {
@@ -1643,21 +1643,12 @@ irnet_discovery_indication(discovery_t *
   DASSERT(priv == &irnet_server, , IRDA_OCB_ERROR,
           "Invalid instance (0x%X) !!!\n", (unsigned int) priv);
 
- /* Check if node is discovered is a new one or an old one.
- * We check when how long ago this node was discovered, with a
- * coarse timeout (we may miss some discovery events or be delayed).
- */
- if((jiffies - discovery->first_timestamp) >= (sysctl_discovery_timeout * HZ))
- {
- return; /* Too old, not interesting -> goodbye */
- }
-
   DEBUG(IRDA_OCB_INFO, "Discovered new IrNET/IrLAN node %s...\n",
- discovery->nickname);
+ discovery->info);
 
   /* Notify the control channel */
   irnet_post_event(NULL, IRNET_DISCOVER,
- discovery->saddr, discovery->daddr, discovery->nickname);
+ discovery->saddr, discovery->daddr, discovery->info);
 
   DEXIT(IRDA_OCB_TRACE, "\n");
 }
@@ -1672,7 +1663,7 @@ irnet_discovery_indication(discovery_t *
  * check if it is a "new" node...
  */
 static void
-irnet_expiry_indication(discovery_t * expiry,
+irnet_expiry_indication(discinfo_t * expiry,
                         DISCOVERY_MODE mode,
                         void * priv)
 {
@@ -1683,11 +1674,11 @@ irnet_expiry_indication(discovery_t * ex
           "Invalid instance (0x%X) !!!\n", (unsigned int) priv);
 
   DEBUG(IRDA_OCB_INFO, "IrNET/IrLAN node %s expired...\n",
- expiry->nickname);
+ expiry->info);
 
   /* Notify the control channel */
   irnet_post_event(NULL, IRNET_EXPIRE,
- expiry->saddr, expiry->daddr, expiry->nickname);
+ expiry->saddr, expiry->daddr, expiry->info);
 
   DEXIT(IRDA_OCB_TRACE, "\n");
 }
diff -u -p -r linux/net/irda-d4/irnet/irnet_irda.h linux/net/irda/irnet/irnet_irda.h
--- linux/net/irda-d4/irnet/irnet_irda.h Mon Nov 4 14:30:07 2002
+++ linux/net/irda/irnet/irnet_irda.h Wed Jan 8 17:00:47 2003
@@ -150,11 +150,11 @@ static void
                                     void *);
 #ifdef DISCOVERY_EVENTS
 static void
- irnet_discovery_indication(discovery_t *,
+ irnet_discovery_indication(discinfo_t *,
                                    DISCOVERY_MODE,
                                    void *);
 static void
- irnet_expiry_indication(discovery_t *,
+ irnet_expiry_indication(discinfo_t *,
                                 DISCOVERY_MODE,
                                 void *);
 #endif
-
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
Please read the FAQ at http://www.tux.org/lkml/



This archive was generated by hypermail 2b29 : Sun Feb 23 2003 - 22:00:31 EST