~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/net/irda/irlmp.c

Version: ~ [ linux-5.13-rc5 ] ~ [ linux-5.12.9 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.42 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.124 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.193 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.235 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.271 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.271 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*********************************************************************
  2  *
  3  * Filename:      irlmp.c
  4  * Version:       1.0
  5  * Description:   IrDA Link Management Protocol (LMP) layer
  6  * Status:        Stable.
  7  * Author:        Dag Brattli <dagb@cs.uit.no>
  8  * Created at:    Sun Aug 17 20:54:32 1997
  9  * Modified at:   Wed Jan  5 11:26:03 2000
 10  * Modified by:   Dag Brattli <dagb@cs.uit.no>
 11  *
 12  *     Copyright (c) 1998-2000 Dag Brattli <dagb@cs.uit.no>,
 13  *     All Rights Reserved.
 14  *     Copyright (c) 2000-2003 Jean Tourrilhes <jt@hpl.hp.com>
 15  *
 16  *     This program is free software; you can redistribute it and/or
 17  *     modify it under the terms of the GNU General Public License as
 18  *     published by the Free Software Foundation; either version 2 of
 19  *     the License, or (at your option) any later version.
 20  *
 21  *     Neither Dag Brattli nor University of Tromsø admit liability nor
 22  *     provide warranty for any of this software. This material is
 23  *     provided "AS-IS" and at no charge.
 24  *
 25  ********************************************************************/
 26 
 27 #include <linux/module.h>
 28 #include <linux/slab.h>
 29 #include <linux/string.h>
 30 #include <linux/skbuff.h>
 31 #include <linux/types.h>
 32 #include <linux/proc_fs.h>
 33 #include <linux/init.h>
 34 #include <linux/kmod.h>
 35 #include <linux/random.h>
 36 #include <linux/seq_file.h>
 37 
 38 #include <net/irda/irda.h>
 39 #include <net/irda/timer.h>
 40 #include <net/irda/qos.h>
 41 #include <net/irda/irlap.h>
 42 #include <net/irda/iriap.h>
 43 #include <net/irda/irlmp.h>
 44 #include <net/irda/irlmp_frame.h>
 45 
 46 #include <asm/unaligned.h>
 47 
 48 static __u8 irlmp_find_free_slsap(void);
 49 static int irlmp_slsap_inuse(__u8 slsap_sel);
 50 
 51 /* Master structure */
 52 struct irlmp_cb *irlmp = NULL;
 53 
 54 /* These can be altered by the sysctl interface */
 55 int  sysctl_discovery         = 0;
 56 int  sysctl_discovery_timeout = 3; /* 3 seconds by default */
 57 int  sysctl_discovery_slots   = 6; /* 6 slots by default */
 58 int  sysctl_lap_keepalive_time = LM_IDLE_TIMEOUT * 1000 / HZ;
 59 char sysctl_devname[65];
 60 
 61 static const char *irlmp_reasons[] = {
 62         "ERROR, NOT USED",
 63         "LM_USER_REQUEST",
 64         "LM_LAP_DISCONNECT",
 65         "LM_CONNECT_FAILURE",
 66         "LM_LAP_RESET",
 67         "LM_INIT_DISCONNECT",
 68         "ERROR, NOT USED",
 69         "UNKNOWN",
 70 };
 71 
 72 const char *irlmp_reason_str(LM_REASON reason)
 73 {
 74         reason = min_t(size_t, reason, ARRAY_SIZE(irlmp_reasons) - 1);
 75         return irlmp_reasons[reason];
 76 }
 77 
 78 /*
 79  * Function irlmp_init (void)
 80  *
 81  *    Create (allocate) the main IrLMP structure
 82  *
 83  */
 84 int __init irlmp_init(void)
 85 {
 86         /* Initialize the irlmp structure. */
 87         irlmp = kzalloc( sizeof(struct irlmp_cb), GFP_KERNEL);
 88         if (irlmp == NULL)
 89                 return -ENOMEM;
 90 
 91         irlmp->magic = LMP_MAGIC;
 92 
 93         irlmp->clients = hashbin_new(HB_LOCK);
 94         irlmp->services = hashbin_new(HB_LOCK);
 95         irlmp->links = hashbin_new(HB_LOCK);
 96         irlmp->unconnected_lsaps = hashbin_new(HB_LOCK);
 97         irlmp->cachelog = hashbin_new(HB_NOLOCK);
 98 
 99         if ((irlmp->clients == NULL) ||
100             (irlmp->services == NULL) ||
101             (irlmp->links == NULL) ||
102             (irlmp->unconnected_lsaps == NULL) ||
103             (irlmp->cachelog == NULL)) {
104                 return -ENOMEM;
105         }
106 
107         spin_lock_init(&irlmp->cachelog->hb_spinlock);
108 
109         irlmp->last_lsap_sel = 0x0f; /* Reserved 0x00-0x0f */
110         strcpy(sysctl_devname, "Linux");
111 
112         init_timer(&irlmp->discovery_timer);
113 
114         /* Do discovery every 3 seconds, conditionally */
115         if (sysctl_discovery)
116                 irlmp_start_discovery_timer(irlmp,
117                                             sysctl_discovery_timeout*HZ);
118 
119         return 0;
120 }
121 
122 /*
123  * Function irlmp_cleanup (void)
124  *
125  *    Remove IrLMP layer
126  *
127  */
128 void irlmp_cleanup(void)
129 {
130         /* Check for main structure */
131         IRDA_ASSERT(irlmp != NULL, return;);
132         IRDA_ASSERT(irlmp->magic == LMP_MAGIC, return;);
133 
134         del_timer(&irlmp->discovery_timer);
135 
136         hashbin_delete(irlmp->links, (FREE_FUNC) kfree);
137         hashbin_delete(irlmp->unconnected_lsaps, (FREE_FUNC) kfree);
138         hashbin_delete(irlmp->clients, (FREE_FUNC) kfree);
139         hashbin_delete(irlmp->services, (FREE_FUNC) kfree);
140         hashbin_delete(irlmp->cachelog, (FREE_FUNC) kfree);
141 
142         /* De-allocate main structure */
143         kfree(irlmp);
144         irlmp = NULL;
145 }
146 
147 /*
148  * Function irlmp_open_lsap (slsap, notify)
149  *
150  *   Register with IrLMP and create a local LSAP,
151  *   returns handle to LSAP.
152  */
153 struct lsap_cb *irlmp_open_lsap(__u8 slsap_sel, notify_t *notify, __u8 pid)
154 {
155         struct lsap_cb *self;
156 
157         IRDA_ASSERT(notify != NULL, return NULL;);
158         IRDA_ASSERT(irlmp != NULL, return NULL;);
159         IRDA_ASSERT(irlmp->magic == LMP_MAGIC, return NULL;);
160         IRDA_ASSERT(notify->instance != NULL, return NULL;);
161 
162         /*  Does the client care which Source LSAP selector it gets?  */
163         if (slsap_sel == LSAP_ANY) {
164                 slsap_sel = irlmp_find_free_slsap();
165                 if (!slsap_sel)
166                         return NULL;
167         } else if (irlmp_slsap_inuse(slsap_sel))
168                 return NULL;
169 
170         /* Allocate new instance of a LSAP connection */
171         self = kzalloc(sizeof(struct lsap_cb), GFP_ATOMIC);
172         if (self == NULL)
173                 return NULL;
174 
175         self->magic = LMP_LSAP_MAGIC;
176         self->slsap_sel = slsap_sel;
177 
178         /* Fix connectionless LSAP's */
179         if (slsap_sel == LSAP_CONNLESS) {
180 #ifdef CONFIG_IRDA_ULTRA
181                 self->dlsap_sel = LSAP_CONNLESS;
182                 self->pid = pid;
183 #endif /* CONFIG_IRDA_ULTRA */
184         } else
185                 self->dlsap_sel = LSAP_ANY;
186         /* self->connected = FALSE; -> already NULL via memset() */
187 
188         init_timer(&self->watchdog_timer);
189 
190         self->notify = *notify;
191 
192         self->lsap_state = LSAP_DISCONNECTED;
193 
194         /* Insert into queue of unconnected LSAPs */
195         hashbin_insert(irlmp->unconnected_lsaps, (irda_queue_t *) self,
196                        (long) self, NULL);
197 
198         return self;
199 }
200 EXPORT_SYMBOL(irlmp_open_lsap);
201 
202 /*
203  * Function __irlmp_close_lsap (self)
204  *
205  *    Remove an instance of LSAP
206  */
207 static void __irlmp_close_lsap(struct lsap_cb *self)
208 {
209         IRDA_ASSERT(self != NULL, return;);
210         IRDA_ASSERT(self->magic == LMP_LSAP_MAGIC, return;);
211 
212         /*
213          *  Set some of the variables to preset values
214          */
215         self->magic = 0;
216         del_timer(&self->watchdog_timer); /* Important! */
217 
218         if (self->conn_skb)
219                 dev_kfree_skb(self->conn_skb);
220 
221         kfree(self);
222 }
223 
224 /*
225  * Function irlmp_close_lsap (self)
226  *
227  *    Close and remove LSAP
228  *
229  */
230 void irlmp_close_lsap(struct lsap_cb *self)
231 {
232         struct lap_cb *lap;
233         struct lsap_cb *lsap = NULL;
234 
235         IRDA_ASSERT(self != NULL, return;);
236         IRDA_ASSERT(self->magic == LMP_LSAP_MAGIC, return;);
237 
238         /*
239          *  Find out if we should remove this LSAP from a link or from the
240          *  list of unconnected lsaps (not associated with a link)
241          */
242         lap = self->lap;
243         if (lap) {
244                 IRDA_ASSERT(lap->magic == LMP_LAP_MAGIC, return;);
245                 /* We might close a LSAP before it has completed the
246                  * connection setup. In those case, higher layers won't
247                  * send a proper disconnect request. Harmless, except
248                  * that we will forget to close LAP... - Jean II */
249                 if(self->lsap_state != LSAP_DISCONNECTED) {
250                         self->lsap_state = LSAP_DISCONNECTED;
251                         irlmp_do_lap_event(self->lap,
252                                            LM_LAP_DISCONNECT_REQUEST, NULL);
253                 }
254                 /* Now, remove from the link */
255                 lsap = hashbin_remove(lap->lsaps, (long) self, NULL);
256 #ifdef CONFIG_IRDA_CACHE_LAST_LSAP
257                 lap->cache.valid = FALSE;
258 #endif
259         }
260         self->lap = NULL;
261         /* Check if we found the LSAP! If not then try the unconnected lsaps */
262         if (!lsap) {
263                 lsap = hashbin_remove(irlmp->unconnected_lsaps, (long) self,
264                                       NULL);
265         }
266         if (!lsap) {
267                 pr_debug("%s(), Looks like somebody has removed me already!\n",
268                          __func__);
269                 return;
270         }
271         __irlmp_close_lsap(self);
272 }
273 EXPORT_SYMBOL(irlmp_close_lsap);
274 
275 /*
276  * Function irlmp_register_irlap (saddr, notify)
277  *
278  *    Register IrLAP layer with IrLMP. There is possible to have multiple
279  *    instances of the IrLAP layer, each connected to different IrDA ports
280  *
281  */
282 void irlmp_register_link(struct irlap_cb *irlap, __u32 saddr, notify_t *notify)
283 {
284         struct lap_cb *lap;
285 
286         IRDA_ASSERT(irlmp != NULL, return;);
287         IRDA_ASSERT(irlmp->magic == LMP_MAGIC, return;);
288         IRDA_ASSERT(notify != NULL, return;);
289 
290         /*
291          *  Allocate new instance of a LSAP connection
292          */
293         lap = kzalloc(sizeof(struct lap_cb), GFP_KERNEL);
294         if (lap == NULL)
295                 return;
296 
297         lap->irlap = irlap;
298         lap->magic = LMP_LAP_MAGIC;
299         lap->saddr = saddr;
300         lap->daddr = DEV_ADDR_ANY;
301 #ifdef CONFIG_IRDA_CACHE_LAST_LSAP
302         lap->cache.valid = FALSE;
303 #endif
304         lap->lsaps = hashbin_new(HB_LOCK);
305         if (lap->lsaps == NULL) {
306                 net_warn_ratelimited("%s(), unable to kmalloc lsaps\n",
307                                      __func__);
308                 kfree(lap);
309                 return;
310         }
311 
312         lap->lap_state = LAP_STANDBY;
313 
314         init_timer(&lap->idle_timer);
315 
316         /*
317          *  Insert into queue of LMP links
318          */
319         hashbin_insert(irlmp->links, (irda_queue_t *) lap, lap->saddr, NULL);
320 
321         /*
322          *  We set only this variable so IrLAP can tell us on which link the
323          *  different events happened on
324          */
325         irda_notify_init(notify);
326         notify->instance = lap;
327 }
328 
329 /*
330  * Function irlmp_unregister_irlap (saddr)
331  *
332  *    IrLAP layer has been removed!
333  *
334  */
335 void irlmp_unregister_link(__u32 saddr)
336 {
337         struct lap_cb *link;
338 
339         /* We must remove ourselves from the hashbin *first*. This ensure
340          * that no more LSAPs will be open on this link and no discovery
341          * will be triggered anymore. Jean II */
342         link = hashbin_remove(irlmp->links, saddr, NULL);
343         if (link) {
344                 IRDA_ASSERT(link->magic == LMP_LAP_MAGIC, return;);
345 
346                 /* Kill all the LSAPs on this link. Jean II */
347                 link->reason = LAP_DISC_INDICATION;
348                 link->daddr = DEV_ADDR_ANY;
349                 irlmp_do_lap_event(link, LM_LAP_DISCONNECT_INDICATION, NULL);
350 
351                 /* Remove all discoveries discovered at this link */
352                 irlmp_expire_discoveries(irlmp->cachelog, link->saddr, TRUE);
353 
354                 /* Final cleanup */
355                 del_timer(&link->idle_timer);
356                 link->magic = 0;
357                 hashbin_delete(link->lsaps, (FREE_FUNC) __irlmp_close_lsap);
358                 kfree(link);
359         }
360 }
361 
362 /*
363  * Function irlmp_connect_request (handle, dlsap, userdata)
364  *
365  *    Connect with a peer LSAP
366  *
367  */
368 int irlmp_connect_request(struct lsap_cb *self, __u8 dlsap_sel,
369                           __u32 saddr, __u32 daddr,
370                           struct qos_info *qos, struct sk_buff *userdata)
371 {
372         struct sk_buff *tx_skb = userdata;
373         struct lap_cb *lap;
374         struct lsap_cb *lsap;
375         int ret;
376 
377         IRDA_ASSERT(self != NULL, return -EBADR;);
378         IRDA_ASSERT(self->magic == LMP_LSAP_MAGIC, return -EBADR;);
379 
380         pr_debug("%s(), slsap_sel=%02x, dlsap_sel=%02x, saddr=%08x, daddr=%08x\n",
381                  __func__, self->slsap_sel, dlsap_sel, saddr, daddr);
382 
383         if (test_bit(0, &self->connected)) {
384                 ret = -EISCONN;
385                 goto err;
386         }
387 
388         /* Client must supply destination device address */
389         if (!daddr) {
390                 ret = -EINVAL;
391                 goto err;
392         }
393 
394         /* Any userdata? */
395         if (tx_skb == NULL) {
396                 tx_skb = alloc_skb(LMP_MAX_HEADER, GFP_ATOMIC);
397                 if (!tx_skb)
398                         return -ENOMEM;
399 
400                 skb_reserve(tx_skb, LMP_MAX_HEADER);
401         }
402 
403         /* Make room for MUX control header (3 bytes) */
404         IRDA_ASSERT(skb_headroom(tx_skb) >= LMP_CONTROL_HEADER, return -1;);
405         skb_push(tx_skb, LMP_CONTROL_HEADER);
406 
407         self->dlsap_sel = dlsap_sel;
408 
409         /*
410          * Find the link to where we should try to connect since there may
411          * be more than one IrDA port on this machine. If the client has
412          * passed us the saddr (and already knows which link to use), then
413          * we use that to find the link, if not then we have to look in the
414          * discovery log and check if any of the links has discovered a
415          * device with the given daddr
416          */
417         if ((!saddr) || (saddr == DEV_ADDR_ANY)) {
418                 discovery_t *discovery;
419                 unsigned long flags;
420 
421                 spin_lock_irqsave(&irlmp->cachelog->hb_spinlock, flags);
422                 if (daddr != DEV_ADDR_ANY)
423                         discovery = hashbin_find(irlmp->cachelog, daddr, NULL);
424                 else {
425                         pr_debug("%s(), no daddr\n", __func__);
426                         discovery = (discovery_t *)
427                                 hashbin_get_first(irlmp->cachelog);
428                 }
429 
430                 if (discovery) {
431                         saddr = discovery->data.saddr;
432                         daddr = discovery->data.daddr;
433                 }
434                 spin_unlock_irqrestore(&irlmp->cachelog->hb_spinlock, flags);
435         }
436         lap = hashbin_lock_find(irlmp->links, saddr, NULL);
437         if (lap == NULL) {
438                 pr_debug("%s(), Unable to find a usable link!\n", __func__);
439                 ret = -EHOSTUNREACH;
440                 goto err;
441         }
442 
443         /* Check if LAP is disconnected or already connected */
444         if (lap->daddr == DEV_ADDR_ANY)
445                 lap->daddr = daddr;
446         else if (lap->daddr != daddr) {
447                 /* Check if some LSAPs are active on this LAP */
448                 if (HASHBIN_GET_SIZE(lap->lsaps) == 0) {
449                         /* No active connection, but LAP hasn't been
450                          * disconnected yet (waiting for timeout in LAP).
451                          * Maybe we could give LAP a bit of help in this case.
452                          */
453                         pr_debug("%s(), sorry, but I'm waiting for LAP to timeout!\n",
454                                  __func__);
455                         ret = -EAGAIN;
456                         goto err;
457                 }
458 
459                 /* LAP is already connected to a different node, and LAP
460                  * can only talk to one node at a time */
461                 pr_debug("%s(), sorry, but link is busy!\n", __func__);
462                 ret = -EBUSY;
463                 goto err;
464         }
465 
466         self->lap = lap;
467 
468         /*
469          *  Remove LSAP from list of unconnected LSAPs and insert it into the
470          *  list of connected LSAPs for the particular link
471          */
472         lsap = hashbin_remove(irlmp->unconnected_lsaps, (long) self, NULL);
473 
474         IRDA_ASSERT(lsap != NULL, return -1;);
475         IRDA_ASSERT(lsap->magic == LMP_LSAP_MAGIC, return -1;);
476         IRDA_ASSERT(lsap->lap != NULL, return -1;);
477         IRDA_ASSERT(lsap->lap->magic == LMP_LAP_MAGIC, return -1;);
478 
479         hashbin_insert(self->lap->lsaps, (irda_queue_t *) self, (long) self,
480                        NULL);
481 
482         set_bit(0, &self->connected);   /* TRUE */
483 
484         /*
485          *  User supplied qos specifications?
486          */
487         if (qos)
488                 self->qos = *qos;
489 
490         irlmp_do_lsap_event(self, LM_CONNECT_REQUEST, tx_skb);
491 
492         /* Drop reference count - see irlap_data_request(). */
493         dev_kfree_skb(tx_skb);
494 
495         return 0;
496 
497 err:
498         /* Cleanup */
499         if(tx_skb)
500                 dev_kfree_skb(tx_skb);
501         return ret;
502 }
503 EXPORT_SYMBOL(irlmp_connect_request);
504 
505 /*
506  * Function irlmp_connect_indication (self)
507  *
508  *    Incoming connection
509  *
510  */
511 void irlmp_connect_indication(struct lsap_cb *self, struct sk_buff *skb)
512 {
513         int max_seg_size;
514         int lap_header_size;
515         int max_header_size;
516 
517         IRDA_ASSERT(self != NULL, return;);
518         IRDA_ASSERT(self->magic == LMP_LSAP_MAGIC, return;);
519         IRDA_ASSERT(skb != NULL, return;);
520         IRDA_ASSERT(self->lap != NULL, return;);
521 
522         pr_debug("%s(), slsap_sel=%02x, dlsap_sel=%02x\n",
523                  __func__, self->slsap_sel, self->dlsap_sel);
524 
525         /* Note : self->lap is set in irlmp_link_data_indication(),
526          * (case CONNECT_CMD:) because we have no way to set it here.
527          * Similarly, self->dlsap_sel is usually set in irlmp_find_lsap().
528          * Jean II */
529 
530         self->qos = *self->lap->qos;
531 
532         max_seg_size = self->lap->qos->data_size.value-LMP_HEADER;
533         lap_header_size = IRLAP_GET_HEADER_SIZE(self->lap->irlap);
534         max_header_size = LMP_HEADER + lap_header_size;
535 
536         /* Hide LMP_CONTROL_HEADER header from layer above */
537         skb_pull(skb, LMP_CONTROL_HEADER);
538 
539         if (self->notify.connect_indication) {
540                 /* Don't forget to refcount it - see irlap_driver_rcv(). */
541                 skb_get(skb);
542                 self->notify.connect_indication(self->notify.instance, self,
543                                                 &self->qos, max_seg_size,
544                                                 max_header_size, skb);
545         }
546 }
547 
548 /*
549  * Function irlmp_connect_response (handle, userdata)
550  *
551  *    Service user is accepting connection
552  *
553  */
554 int irlmp_connect_response(struct lsap_cb *self, struct sk_buff *userdata)
555 {
556         IRDA_ASSERT(self != NULL, return -1;);
557         IRDA_ASSERT(self->magic == LMP_LSAP_MAGIC, return -1;);
558         IRDA_ASSERT(userdata != NULL, return -1;);
559 
560         /* We set the connected bit and move the lsap to the connected list
561          * in the state machine itself. Jean II */
562 
563         pr_debug("%s(), slsap_sel=%02x, dlsap_sel=%02x\n",
564                  __func__, self->slsap_sel, self->dlsap_sel);
565 
566         /* Make room for MUX control header (3 bytes) */
567         IRDA_ASSERT(skb_headroom(userdata) >= LMP_CONTROL_HEADER, return -1;);
568         skb_push(userdata, LMP_CONTROL_HEADER);
569 
570         irlmp_do_lsap_event(self, LM_CONNECT_RESPONSE, userdata);
571 
572         /* Drop reference count - see irlap_data_request(). */
573         dev_kfree_skb(userdata);
574 
575         return 0;
576 }
577 EXPORT_SYMBOL(irlmp_connect_response);
578 
579 /*
580  * Function irlmp_connect_confirm (handle, skb)
581  *
582  *    LSAP connection confirmed peer device!
583  */
584 void irlmp_connect_confirm(struct lsap_cb *self, struct sk_buff *skb)
585 {
586         int max_header_size;
587         int lap_header_size;
588         int max_seg_size;
589 
590         IRDA_ASSERT(skb != NULL, return;);
591         IRDA_ASSERT(self != NULL, return;);
592         IRDA_ASSERT(self->magic == LMP_LSAP_MAGIC, return;);
593         IRDA_ASSERT(self->lap != NULL, return;);
594 
595         self->qos = *self->lap->qos;
596 
597         max_seg_size    = self->lap->qos->data_size.value-LMP_HEADER;
598         lap_header_size = IRLAP_GET_HEADER_SIZE(self->lap->irlap);
599         max_header_size = LMP_HEADER + lap_header_size;
600 
601         pr_debug("%s(), max_header_size=%d\n",
602                  __func__, max_header_size);
603 
604         /* Hide LMP_CONTROL_HEADER header from layer above */
605         skb_pull(skb, LMP_CONTROL_HEADER);
606 
607         if (self->notify.connect_confirm) {
608                 /* Don't forget to refcount it - see irlap_driver_rcv() */
609                 skb_get(skb);
610                 self->notify.connect_confirm(self->notify.instance, self,
611                                              &self->qos, max_seg_size,
612                                              max_header_size, skb);
613         }
614 }
615 
616 /*
617  * Function irlmp_dup (orig, instance)
618  *
619  *    Duplicate LSAP, can be used by servers to confirm a connection on a
620  *    new LSAP so it can keep listening on the old one.
621  *
622  */
623 struct lsap_cb *irlmp_dup(struct lsap_cb *orig, void *instance)
624 {
625         struct lsap_cb *new;
626         unsigned long flags;
627 
628         spin_lock_irqsave(&irlmp->unconnected_lsaps->hb_spinlock, flags);
629 
630         /* Only allowed to duplicate unconnected LSAP's, and only LSAPs
631          * that have received a connect indication. Jean II */
632         if ((!hashbin_find(irlmp->unconnected_lsaps, (long) orig, NULL)) ||
633             (orig->lap == NULL)) {
634                 pr_debug("%s(), invalid LSAP (wrong state)\n",
635                          __func__);
636                 spin_unlock_irqrestore(&irlmp->unconnected_lsaps->hb_spinlock,
637                                        flags);
638                 return NULL;
639         }
640 
641         /* Allocate a new instance */
642         new = kmemdup(orig, sizeof(*new), GFP_ATOMIC);
643         if (!new)  {
644                 pr_debug("%s(), unable to kmalloc\n", __func__);
645                 spin_unlock_irqrestore(&irlmp->unconnected_lsaps->hb_spinlock,
646                                        flags);
647                 return NULL;
648         }
649         /* new->lap = orig->lap; => done in the memcpy() */
650         /* new->slsap_sel = orig->slsap_sel; => done in the memcpy() */
651         new->conn_skb = NULL;
652 
653         spin_unlock_irqrestore(&irlmp->unconnected_lsaps->hb_spinlock, flags);
654 
655         /* Not everything is the same */
656         new->notify.instance = instance;
657 
658         init_timer(&new->watchdog_timer);
659 
660         hashbin_insert(irlmp->unconnected_lsaps, (irda_queue_t *) new,
661                        (long) new, NULL);
662 
663 #ifdef CONFIG_IRDA_CACHE_LAST_LSAP
664         /* Make sure that we invalidate the LSAP cache */
665         new->lap->cache.valid = FALSE;
666 #endif /* CONFIG_IRDA_CACHE_LAST_LSAP */
667 
668         return new;
669 }
670 
671 /*
672  * Function irlmp_disconnect_request (handle, userdata)
673  *
674  *    The service user is requesting disconnection, this will not remove the
675  *    LSAP, but only mark it as disconnected
676  */
677 int irlmp_disconnect_request(struct lsap_cb *self, struct sk_buff *userdata)
678 {
679         struct lsap_cb *lsap;
680 
681         IRDA_ASSERT(self != NULL, return -1;);
682         IRDA_ASSERT(self->magic == LMP_LSAP_MAGIC, return -1;);
683         IRDA_ASSERT(userdata != NULL, return -1;);
684 
685         /* Already disconnected ?
686          * There is a race condition between irlmp_disconnect_indication()
687          * and us that might mess up the hashbins below. This fixes it.
688          * Jean II */
689         if (! test_and_clear_bit(0, &self->connected)) {
690                 pr_debug("%s(), already disconnected!\n", __func__);
691                 dev_kfree_skb(userdata);
692                 return -1;
693         }
694 
695         skb_push(userdata, LMP_CONTROL_HEADER);
696 
697         /*
698          *  Do the event before the other stuff since we must know
699          *  which lap layer that the frame should be transmitted on
700          */
701         irlmp_do_lsap_event(self, LM_DISCONNECT_REQUEST, userdata);
702 
703         /* Drop reference count - see irlap_data_request(). */
704         dev_kfree_skb(userdata);
705 
706         /*
707          *  Remove LSAP from list of connected LSAPs for the particular link
708          *  and insert it into the list of unconnected LSAPs
709          */
710         IRDA_ASSERT(self->lap != NULL, return -1;);
711         IRDA_ASSERT(self->lap->magic == LMP_LAP_MAGIC, return -1;);
712         IRDA_ASSERT(self->lap->lsaps != NULL, return -1;);
713 
714         lsap = hashbin_remove(self->lap->lsaps, (long) self, NULL);
715 #ifdef CONFIG_IRDA_CACHE_LAST_LSAP
716         self->lap->cache.valid = FALSE;
717 #endif
718 
719         IRDA_ASSERT(lsap != NULL, return -1;);
720         IRDA_ASSERT(lsap->magic == LMP_LSAP_MAGIC, return -1;);
721         IRDA_ASSERT(lsap == self, return -1;);
722 
723         hashbin_insert(irlmp->unconnected_lsaps, (irda_queue_t *) self,
724                        (long) self, NULL);
725 
726         /* Reset some values */
727         self->dlsap_sel = LSAP_ANY;
728         self->lap = NULL;
729 
730         return 0;
731 }
732 EXPORT_SYMBOL(irlmp_disconnect_request);
733 
734 /*
735  * Function irlmp_disconnect_indication (reason, userdata)
736  *
737  *    LSAP is being closed!
738  */
739 void irlmp_disconnect_indication(struct lsap_cb *self, LM_REASON reason,
740                                  struct sk_buff *skb)
741 {
742         struct lsap_cb *lsap;
743 
744         pr_debug("%s(), reason=%s [%d]\n", __func__,
745                  irlmp_reason_str(reason), reason);
746         IRDA_ASSERT(self != NULL, return;);
747         IRDA_ASSERT(self->magic == LMP_LSAP_MAGIC, return;);
748 
749         pr_debug("%s(), slsap_sel=%02x, dlsap_sel=%02x\n",
750                  __func__, self->slsap_sel, self->dlsap_sel);
751 
752         /* Already disconnected ?
753          * There is a race condition between irlmp_disconnect_request()
754          * and us that might mess up the hashbins below. This fixes it.
755          * Jean II */
756         if (! test_and_clear_bit(0, &self->connected)) {
757                 pr_debug("%s(), already disconnected!\n", __func__);
758                 return;
759         }
760 
761         /*
762          *  Remove association between this LSAP and the link it used
763          */
764         IRDA_ASSERT(self->lap != NULL, return;);
765         IRDA_ASSERT(self->lap->lsaps != NULL, return;);
766 
767         lsap = hashbin_remove(self->lap->lsaps, (long) self, NULL);
768 #ifdef CONFIG_IRDA_CACHE_LAST_LSAP
769         self->lap->cache.valid = FALSE;
770 #endif
771 
772         IRDA_ASSERT(lsap != NULL, return;);
773         IRDA_ASSERT(lsap == self, return;);
774         hashbin_insert(irlmp->unconnected_lsaps, (irda_queue_t *) lsap,
775                        (long) lsap, NULL);
776 
777         self->dlsap_sel = LSAP_ANY;
778         self->lap = NULL;
779 
780         /*
781          *  Inform service user
782          */
783         if (self->notify.disconnect_indication) {
784                 /* Don't forget to refcount it - see irlap_driver_rcv(). */
785                 if(skb)
786                         skb_get(skb);
787                 self->notify.disconnect_indication(self->notify.instance,
788                                                    self, reason, skb);
789         } else {
790                 pr_debug("%s(), no handler\n", __func__);
791         }
792 }
793 
794 /*
795  * Function irlmp_do_expiry (void)
796  *
797  *    Do a cleanup of the discovery log (remove old entries)
798  *
799  * Note : separate from irlmp_do_discovery() so that we can handle
800  * passive discovery properly.
801  */
802 void irlmp_do_expiry(void)
803 {
804         struct lap_cb *lap;
805 
806         /*
807          * Expire discovery on all links which are *not* connected.
808          * On links which are connected, we can't do discovery
809          * anymore and can't refresh the log, so we freeze the
810          * discovery log to keep info about the device we are
811          * connected to.
812          * This info is mandatory if we want irlmp_connect_request()
813          * to work properly. - Jean II
814          */
815         lap = (struct lap_cb *) hashbin_get_first(irlmp->links);
816         while (lap != NULL) {
817                 IRDA_ASSERT(lap->magic == LMP_LAP_MAGIC, return;);
818 
819                 if (lap->lap_state == LAP_STANDBY) {
820                         /* Expire discoveries discovered on this link */
821                         irlmp_expire_discoveries(irlmp->cachelog, lap->saddr,
822                                                  FALSE);
823                 }
824                 lap = (struct lap_cb *) hashbin_get_next(irlmp->links);
825         }
826 }
827 
828 /*
829  * Function irlmp_do_discovery (nslots)
830  *
831  *    Do some discovery on all links
832  *
833  * Note : log expiry is done above.
834  */
835 void irlmp_do_discovery(int nslots)
836 {
837         struct lap_cb *lap;
838         __u16 *data_hintsp;
839 
840         /* Make sure the value is sane */
841         if ((nslots != 1) && (nslots != 6) && (nslots != 8) && (nslots != 16)){
842                 net_warn_ratelimited("%s: invalid value for number of slots!\n",
843                                      __func__);
844                 nslots = sysctl_discovery_slots = 8;
845         }
846 
847         /* Construct new discovery info to be used by IrLAP, */
848         data_hintsp = (__u16 *) irlmp->discovery_cmd.data.hints;
849         put_unaligned(irlmp->hints.word, data_hintsp);
850 
851         /*
852          *  Set character set for device name (we use ASCII), and
853          *  copy device name. Remember to make room for a \0 at the
854          *  end
855          */
856         irlmp->discovery_cmd.data.charset = CS_ASCII;
857         strncpy(irlmp->discovery_cmd.data.info, sysctl_devname,
858                 NICKNAME_MAX_LEN);
859         irlmp->discovery_cmd.name_len = strlen(irlmp->discovery_cmd.data.info);
860         irlmp->discovery_cmd.nslots = nslots;
861 
862         /*
863          * Try to send discovery packets on all links
864          */
865         lap = (struct lap_cb *) hashbin_get_first(irlmp->links);
866         while (lap != NULL) {
867                 IRDA_ASSERT(lap->magic == LMP_LAP_MAGIC, return;);
868 
869                 if (lap->lap_state == LAP_STANDBY) {
870                         /* Try to discover */
871                         irlmp_do_lap_event(lap, LM_LAP_DISCOVERY_REQUEST,
872                                            NULL);
873                 }
874                 lap = (struct lap_cb *) hashbin_get_next(irlmp->links);
875         }
876 }
877 
878 /*
879  * Function irlmp_discovery_request (nslots)
880  *
881  *    Do a discovery of devices in front of the computer
882  *
883  * If the caller has registered a client discovery callback, this
884  * allow him to receive the full content of the discovery log through
885  * this callback (as normally he will receive only new discoveries).
886  */
887 void irlmp_discovery_request(int nslots)
888 {
889         /* Return current cached discovery log (in full) */
890         irlmp_discovery_confirm(irlmp->cachelog, DISCOVERY_LOG);
891 
892         /*
893          * Start a single discovery operation if discovery is not already
894          * running
895          */
896         if (!sysctl_discovery) {
897                 /* Check if user wants to override the default */
898                 if (nslots == DISCOVERY_DEFAULT_SLOTS)
899                         nslots = sysctl_discovery_slots;
900 
901                 irlmp_do_discovery(nslots);
902                 /* Note : we never do expiry here. Expiry will run on the
903                  * discovery timer regardless of the state of sysctl_discovery
904                  * Jean II */
905         }
906 }
907 EXPORT_SYMBOL(irlmp_discovery_request);
908 
909 /*
910  * Function irlmp_get_discoveries (pn, mask, slots)
911  *
912  *    Return the current discovery log
913  *
914  * If discovery is not enabled, you should call this function again
915  * after 1 or 2 seconds (i.e. after discovery has been done).
916  */
917 struct irda_device_info *irlmp_get_discoveries(int *pn, __u16 mask, int nslots)
918 {
919         /* If discovery is not enabled, it's likely that the discovery log
920          * will be empty. So, we trigger a single discovery, so that next
921          * time the user call us there might be some results in the log.
922          * Jean II
923          */
924         if (!sysctl_discovery) {
925                 /* Check if user wants to override the default */
926                 if (nslots == DISCOVERY_DEFAULT_SLOTS)
927                         nslots = sysctl_discovery_slots;
928 
929                 /* Start discovery - will complete sometime later */
930                 irlmp_do_discovery(nslots);
931                 /* Note : we never do expiry here. Expiry will run on the
932                  * discovery timer regardless of the state of sysctl_discovery
933                  * Jean II */
934         }
935 
936         /* Return current cached discovery log */
937         return irlmp_copy_discoveries(irlmp->cachelog, pn, mask, TRUE);
938 }
939 EXPORT_SYMBOL(irlmp_get_discoveries);
940 
941 /*
942  * Function irlmp_notify_client (log)
943  *
944  *    Notify all about discovered devices
945  *
946  * Clients registered with IrLMP are :
947  *      o IrComm
948  *      o IrLAN
949  *      o Any socket (in any state - ouch, that may be a lot !)
950  * The client may have defined a callback to be notified in case of
951  * partial/selective discovery based on the hints that it passed to IrLMP.
952  */
953 static inline void
954 irlmp_notify_client(irlmp_client_t *client,
955                     hashbin_t *log, DISCOVERY_MODE mode)
956 {
957         discinfo_t *discoveries;        /* Copy of the discovery log */
958         int     number;                 /* Number of nodes in the log */
959         int     i;
960 
961         /* Check if client wants or not partial/selective log (optimisation) */
962         if (!client->disco_callback)
963                 return;
964 
965         /*
966          * Locking notes :
967          * the old code was manipulating the log directly, which was
968          * very racy. Now, we use copy_discoveries, that protects
969          * itself while dumping the log for us.
970          * The overhead of the copy is compensated by the fact that
971          * we only pass new discoveries in normal mode and don't
972          * pass the same old entry every 3s to the caller as we used
973          * to do (virtual function calling is expensive).
974          * Jean II
975          */
976 
977         /*
978          * Now, check all discovered devices (if any), and notify client
979          * only about the services that the client is interested in
980          * We also notify only about the new devices unless the caller
981          * explicitly request a dump of the log. Jean II
982          */
983         discoveries = irlmp_copy_discoveries(log, &number,
984                                              client->hint_mask.word,
985                                              (mode == DISCOVERY_LOG));
986         /* Check if the we got some results */
987         if (discoveries == NULL)
988                 return; /* No nodes discovered */
989 
990         /* Pass all entries to the listener */
991         for(i = 0; i < number; i++)
992                 client->disco_callback(&(discoveries[i]), mode, client->priv);
993 
994         /* Free up our buffer */
995         kfree(discoveries);
996 }
997 
998 /*
999  * Function irlmp_discovery_confirm ( self, log)
1000  *
1001  *    Some device(s) answered to our discovery request! Check to see which
1002  *    device it is, and give indication to the client(s)
1003  *
1004  */
1005 void irlmp_discovery_confirm(hashbin_t *log, DISCOVERY_MODE mode)
1006 {
1007         irlmp_client_t *client;
1008         irlmp_client_t *client_next;
1009 
1010         IRDA_ASSERT(log != NULL, return;);
1011 
1012         if (!(HASHBIN_GET_SIZE(log)))
1013                 return;
1014 
1015         /* For each client - notify callback may touch client list */
1016         client = (irlmp_client_t *) hashbin_get_first(irlmp->clients);
1017         while (NULL != hashbin_find_next(irlmp->clients, (long) client, NULL,
1018                                          (void *) &client_next) ) {
1019                 /* Check if we should notify client */
1020                 irlmp_notify_client(client, log, mode);
1021 
1022                 client = client_next;
1023         }
1024 }
1025 
1026 /*
1027  * Function irlmp_discovery_expiry (expiry)
1028  *
1029  *      This device is no longer been discovered, and therefore it is being
1030  *      purged from the discovery log. Inform all clients who have
1031  *      registered for this event...
1032  *
1033  *      Note : called exclusively from discovery.c
1034  *      Note : this is no longer called under discovery spinlock, so the
1035  *              client can do whatever he wants in the callback.
1036  */
1037 void irlmp_discovery_expiry(discinfo_t *expiries, int number)
1038 {
1039         irlmp_client_t *client;
1040         irlmp_client_t *client_next;
1041         int             i;
1042 
1043         IRDA_ASSERT(expiries != NULL, return;);
1044 
1045         /* For each client - notify callback may touch client list */
1046         client = (irlmp_client_t *) hashbin_get_first(irlmp->clients);
1047         while (NULL != hashbin_find_next(irlmp->clients, (long) client, NULL,
1048                                          (void *) &client_next) ) {
1049 
1050                 /* Pass all entries to the listener */
1051                 for(i = 0; i < number; i++) {
1052                         /* Check if we should notify client */
1053                         if ((client->expir_callback) &&
1054                             (client->hint_mask.word &
1055                              get_unaligned((__u16 *)expiries[i].hints)
1056                              & 0x7f7f) )
1057                                 client->expir_callback(&(expiries[i]),
1058                                                        EXPIRY_TIMEOUT,
1059                                                        client->priv);
1060                 }
1061 
1062                 /* Next client */
1063                 client = client_next;
1064         }
1065 }
1066 
1067 /*
1068  * Function irlmp_get_discovery_response ()
1069  *
1070  *    Used by IrLAP to get the discovery info it needs when answering
1071  *    discovery requests by other devices.
1072  */
1073 discovery_t *irlmp_get_discovery_response(void)
1074 {
1075         IRDA_ASSERT(irlmp != NULL, return NULL;);
1076 
1077         put_unaligned(irlmp->hints.word, (__u16 *)irlmp->discovery_rsp.data.hints);
1078 
1079         /*
1080          *  Set character set for device name (we use ASCII), and
1081          *  copy device name. Remember to make room for a \0 at the
1082          *  end
1083          */
1084         irlmp->discovery_rsp.data.charset = CS_ASCII;
1085 
1086         strncpy(irlmp->discovery_rsp.data.info, sysctl_devname,
1087                 NICKNAME_MAX_LEN);
1088         irlmp->discovery_rsp.name_len = strlen(irlmp->discovery_rsp.data.info);
1089 
1090         return &irlmp->discovery_rsp;
1091 }
1092 
1093 /*
1094  * Function irlmp_data_request (self, skb)
1095  *
1096  *    Send some data to peer device
1097  *
1098  * Note on skb management :
1099  * After calling the lower layers of the IrDA stack, we always
1100  * kfree() the skb, which drop the reference count (and potentially
1101  * destroy it).
1102  * IrLMP and IrLAP may queue the packet, and in those cases will need
1103  * to use skb_get() to keep it around.
1104  * Jean II
1105  */
1106 int irlmp_data_request(struct lsap_cb *self, struct sk_buff *userdata)
1107 {
1108         int     ret;
1109 
1110         IRDA_ASSERT(self != NULL, return -1;);
1111         IRDA_ASSERT(self->magic == LMP_LSAP_MAGIC, return -1;);
1112 
1113         /* Make room for MUX header */
1114         IRDA_ASSERT(skb_headroom(userdata) >= LMP_HEADER, return -1;);
1115         skb_push(userdata, LMP_HEADER);
1116 
1117         ret = irlmp_do_lsap_event(self, LM_DATA_REQUEST, userdata);
1118 
1119         /* Drop reference count - see irlap_data_request(). */
1120         dev_kfree_skb(userdata);
1121 
1122         return ret;
1123 }
1124 EXPORT_SYMBOL(irlmp_data_request);
1125 
1126 /*
1127  * Function irlmp_data_indication (handle, skb)
1128  *
1129  *    Got data from LAP layer so pass it up to upper layer
1130  *
1131  */
1132 void irlmp_data_indication(struct lsap_cb *self, struct sk_buff *skb)
1133 {
1134         /* Hide LMP header from layer above */
1135         skb_pull(skb, LMP_HEADER);
1136 
1137         if (self->notify.data_indication) {
1138                 /* Don't forget to refcount it - see irlap_driver_rcv(). */
1139                 skb_get(skb);
1140                 self->notify.data_indication(self->notify.instance, self, skb);
1141         }
1142 }
1143 
1144 /*
1145  * Function irlmp_udata_request (self, skb)
1146  */
1147 int irlmp_udata_request(struct lsap_cb *self, struct sk_buff *userdata)
1148 {
1149         int     ret;
1150 
1151         IRDA_ASSERT(userdata != NULL, return -1;);
1152 
1153         /* Make room for MUX header */
1154         IRDA_ASSERT(skb_headroom(userdata) >= LMP_HEADER, return -1;);
1155         skb_push(userdata, LMP_HEADER);
1156 
1157         ret = irlmp_do_lsap_event(self, LM_UDATA_REQUEST, userdata);
1158 
1159         /* Drop reference count - see irlap_data_request(). */
1160         dev_kfree_skb(userdata);
1161 
1162         return ret;
1163 }
1164 
1165 /*
1166  * Function irlmp_udata_indication (self, skb)
1167  *
1168  *    Send unreliable data (but still within the connection)
1169  *
1170  */
1171 void irlmp_udata_indication(struct lsap_cb *self, struct sk_buff *skb)
1172 {
1173         IRDA_ASSERT(self != NULL, return;);
1174         IRDA_ASSERT(self->magic == LMP_LSAP_MAGIC, return;);
1175         IRDA_ASSERT(skb != NULL, return;);
1176 
1177         /* Hide LMP header from layer above */
1178         skb_pull(skb, LMP_HEADER);
1179 
1180         if (self->notify.udata_indication) {
1181                 /* Don't forget to refcount it - see irlap_driver_rcv(). */
1182                 skb_get(skb);
1183                 self->notify.udata_indication(self->notify.instance, self,
1184                                               skb);
1185         }
1186 }
1187 
1188 /*
1189  * Function irlmp_connless_data_request (self, skb)
1190  */
1191 #ifdef CONFIG_IRDA_ULTRA
1192 int irlmp_connless_data_request(struct lsap_cb *self, struct sk_buff *userdata,
1193                                 __u8 pid)
1194 {
1195         struct sk_buff *clone_skb;
1196         struct lap_cb *lap;
1197 
1198         IRDA_ASSERT(userdata != NULL, return -1;);
1199 
1200         /* Make room for MUX and PID header */
1201         IRDA_ASSERT(skb_headroom(userdata) >= LMP_HEADER+LMP_PID_HEADER,
1202                     return -1;);
1203 
1204         /* Insert protocol identifier */
1205         skb_push(userdata, LMP_PID_HEADER);
1206         if(self != NULL)
1207           userdata->data[0] = self->pid;
1208         else
1209           userdata->data[0] = pid;
1210 
1211         /* Connectionless sockets must use 0x70 */
1212         skb_push(userdata, LMP_HEADER);
1213         userdata->data[0] = userdata->data[1] = LSAP_CONNLESS;
1214 
1215         /* Try to send Connectionless  packets out on all links */
1216         lap = (struct lap_cb *) hashbin_get_first(irlmp->links);
1217         while (lap != NULL) {
1218                 IRDA_ASSERT(lap->magic == LMP_LAP_MAGIC, return -1;);
1219 
1220                 clone_skb = skb_clone(userdata, GFP_ATOMIC);
1221                 if (!clone_skb) {
1222                         dev_kfree_skb(userdata);
1223                         return -ENOMEM;
1224                 }
1225 
1226                 irlap_unitdata_request(lap->irlap, clone_skb);
1227                 /* irlap_unitdata_request() don't increase refcount,
1228                  * so no dev_kfree_skb() - Jean II */
1229 
1230                 lap = (struct lap_cb *) hashbin_get_next(irlmp->links);
1231         }
1232         dev_kfree_skb(userdata);
1233 
1234         return 0;
1235 }
1236 #endif /* CONFIG_IRDA_ULTRA */
1237 
1238 /*
1239  * Function irlmp_connless_data_indication (self, skb)
1240  *
1241  *    Receive unreliable data outside any connection. Mostly used by Ultra
1242  *
1243  */
1244 #ifdef CONFIG_IRDA_ULTRA
1245 void irlmp_connless_data_indication(struct lsap_cb *self, struct sk_buff *skb)
1246 {
1247         IRDA_ASSERT(self != NULL, return;);
1248         IRDA_ASSERT(self->magic == LMP_LSAP_MAGIC, return;);
1249         IRDA_ASSERT(skb != NULL, return;);
1250 
1251         /* Hide LMP and PID header from layer above */
1252         skb_pull(skb, LMP_HEADER+LMP_PID_HEADER);
1253 
1254         if (self->notify.udata_indication) {
1255                 /* Don't forget to refcount it - see irlap_driver_rcv(). */
1256                 skb_get(skb);
1257                 self->notify.udata_indication(self->notify.instance, self,
1258                                               skb);
1259         }
1260 }
1261 #endif /* CONFIG_IRDA_ULTRA */
1262 
1263 /*
1264  * Propagate status indication from LAP to LSAPs (via LMP)
1265  * This don't trigger any change of state in lap_cb, lmp_cb or lsap_cb,
1266  * and the event is stateless, therefore we can bypass both state machines
1267  * and send the event direct to the LSAP user.
1268  * Jean II
1269  */
1270 void irlmp_status_indication(struct lap_cb *self,
1271                              LINK_STATUS link, LOCK_STATUS lock)
1272 {
1273         struct lsap_cb *next;
1274         struct lsap_cb *curr;
1275 
1276         /* Send status_indication to all LSAPs using this link */
1277         curr = (struct lsap_cb *) hashbin_get_first( self->lsaps);
1278         while (NULL != hashbin_find_next(self->lsaps, (long) curr, NULL,
1279                                          (void *) &next) ) {
1280                 IRDA_ASSERT(curr->magic == LMP_LSAP_MAGIC, return;);
1281                 /*
1282                  *  Inform service user if he has requested it
1283                  */
1284                 if (curr->notify.status_indication != NULL)
1285                         curr->notify.status_indication(curr->notify.instance,
1286                                                        link, lock);
1287                 else
1288                         pr_debug("%s(), no handler\n", __func__);
1289 
1290                 curr = next;
1291         }
1292 }
1293 
1294 /*
1295  * Receive flow control indication from LAP.
1296  * LAP want us to send it one more frame. We implement a simple round
1297  * robin scheduler between the active sockets so that we get a bit of
1298  * fairness. Note that the round robin is far from perfect, but it's
1299  * better than nothing.
1300  * We then poll the selected socket so that we can do synchronous
1301  * refilling of IrLAP (which allow to minimise the number of buffers).
1302  * Jean II
1303  */
1304 void irlmp_flow_indication(struct lap_cb *self, LOCAL_FLOW flow)
1305 {
1306         struct lsap_cb *next;
1307         struct lsap_cb *curr;
1308         int     lsap_todo;
1309 
1310         IRDA_ASSERT(self->magic == LMP_LAP_MAGIC, return;);
1311         IRDA_ASSERT(flow == FLOW_START, return;);
1312 
1313         /* Get the number of lsap. That's the only safe way to know
1314          * that we have looped around... - Jean II */
1315         lsap_todo = HASHBIN_GET_SIZE(self->lsaps);
1316         pr_debug("%s() : %d lsaps to scan\n", __func__, lsap_todo);
1317 
1318         /* Poll lsap in order until the queue is full or until we
1319          * tried them all.
1320          * Most often, the current LSAP will have something to send,
1321          * so we will go through this loop only once. - Jean II */
1322         while((lsap_todo--) &&
1323               (IRLAP_GET_TX_QUEUE_LEN(self->irlap) < LAP_HIGH_THRESHOLD)) {
1324                 /* Try to find the next lsap we should poll. */
1325                 next = self->flow_next;
1326                 /* If we have no lsap, restart from first one */
1327                 if(next == NULL)
1328                         next = (struct lsap_cb *) hashbin_get_first(self->lsaps);
1329                 /* Verify current one and find the next one */
1330                 curr = hashbin_find_next(self->lsaps, (long) next, NULL,
1331                                          (void *) &self->flow_next);
1332                 /* Uh-oh... Paranoia */
1333                 if(curr == NULL)
1334                         break;
1335                 pr_debug("%s() : curr is %p, next was %p and is now %p, still %d to go - queue len = %d\n",
1336                          __func__, curr, next, self->flow_next, lsap_todo,
1337                          IRLAP_GET_TX_QUEUE_LEN(self->irlap));
1338 
1339                 /* Inform lsap user that it can send one more packet. */
1340                 if (curr->notify.flow_indication != NULL)
1341                         curr->notify.flow_indication(curr->notify.instance,
1342                                                      curr, flow);
1343                 else
1344                         pr_debug("%s(), no handler\n", __func__);
1345         }
1346 }
1347 
1348 #if 0
1349 /*
1350  * Function irlmp_hint_to_service (hint)
1351  *
1352  *    Returns a list of all servics contained in the given hint bits. This
1353  *    function assumes that the hint bits have the size of two bytes only
1354  */
1355 __u8 *irlmp_hint_to_service(__u8 *hint)
1356 {
1357         __u8 *service;
1358         int i = 0;
1359 
1360         /*
1361          * Allocate array to store services in. 16 entries should be safe
1362          * since we currently only support 2 hint bytes
1363          */
1364         service = kmalloc(16, GFP_ATOMIC);
1365         if (!service)
1366                 return NULL;
1367 
1368         if (!hint[0]) {
1369                 pr_debug("<None>\n");
1370                 kfree(service);
1371                 return NULL;
1372         }
1373         if (hint[0] & HINT_PNP)
1374                 pr_debug("PnP Compatible ");
1375         if (hint[0] & HINT_PDA)
1376                 pr_debug("PDA/Palmtop ");
1377         if (hint[0] & HINT_COMPUTER)
1378                 pr_debug("Computer ");
1379         if (hint[0] & HINT_PRINTER) {
1380                 pr_debug("Printer ");
1381                 service[i++] = S_PRINTER;
1382         }
1383         if (hint[0] & HINT_MODEM)
1384                 pr_debug("Modem ");
1385         if (hint[0] & HINT_FAX)
1386                 pr_debug("Fax ");
1387         if (hint[0] & HINT_LAN) {
1388                 pr_debug("LAN Access ");
1389                 service[i++] = S_LAN;
1390         }
1391         /*
1392          *  Test if extension byte exists. This byte will usually be
1393          *  there, but this is not really required by the standard.
1394          *  (IrLMP p. 29)
1395          */
1396         if (hint[0] & HINT_EXTENSION) {
1397                 if (hint[1] & HINT_TELEPHONY) {
1398                         pr_debug("Telephony ");
1399                         service[i++] = S_TELEPHONY;
1400                 }
1401                 if (hint[1] & HINT_FILE_SERVER)
1402                         pr_debug("File Server ");
1403 
1404                 if (hint[1] & HINT_COMM) {
1405                         pr_debug("IrCOMM ");
1406                         service[i++] = S_COMM;
1407                 }
1408                 if (hint[1] & HINT_OBEX) {
1409                         pr_debug("IrOBEX ");
1410                         service[i++] = S_OBEX;
1411                 }
1412         }
1413         pr_debug("\n");
1414 
1415         /* So that client can be notified about any discovery */
1416         service[i++] = S_ANY;
1417 
1418         service[i] = S_END;
1419 
1420         return service;
1421 }
1422 #endif
1423 
1424 static const __u16 service_hint_mapping[S_END][2] = {
1425         { HINT_PNP,             0 },                    /* S_PNP */
1426         { HINT_PDA,             0 },                    /* S_PDA */
1427         { HINT_COMPUTER,        0 },                    /* S_COMPUTER */
1428         { HINT_PRINTER,         0 },                    /* S_PRINTER */
1429         { HINT_MODEM,           0 },                    /* S_MODEM */
1430         { HINT_FAX,             0 },                    /* S_FAX */
1431         { HINT_LAN,             0 },                    /* S_LAN */
1432         { HINT_EXTENSION,       HINT_TELEPHONY },       /* S_TELEPHONY */
1433         { HINT_EXTENSION,       HINT_COMM },            /* S_COMM */
1434         { HINT_EXTENSION,       HINT_OBEX },            /* S_OBEX */
1435         { 0xFF,                 0xFF },                 /* S_ANY */
1436 };
1437 
1438 /*
1439  * Function irlmp_service_to_hint (service)
1440  *
1441  *    Converts a service type, to a hint bit
1442  *
1443  *    Returns: a 16 bit hint value, with the service bit set
1444  */
1445 __u16 irlmp_service_to_hint(int service)
1446 {
1447         __u16_host_order hint;
1448 
1449         hint.byte[0] = service_hint_mapping[service][0];
1450         hint.byte[1] = service_hint_mapping[service][1];
1451 
1452         return hint.word;
1453 }
1454 EXPORT_SYMBOL(irlmp_service_to_hint);
1455 
1456 /*
1457  * Function irlmp_register_service (service)
1458  *
1459  *    Register local service with IrLMP
1460  *
1461  */
1462 void *irlmp_register_service(__u16 hints)
1463 {
1464         irlmp_service_t *service;
1465 
1466         pr_debug("%s(), hints = %04x\n", __func__, hints);
1467 
1468         /* Make a new registration */
1469         service = kmalloc(sizeof(irlmp_service_t), GFP_ATOMIC);
1470         if (!service)
1471                 return NULL;
1472 
1473         service->hints.word = hints;
1474         hashbin_insert(irlmp->services, (irda_queue_t *) service,
1475                        (long) service, NULL);
1476 
1477         irlmp->hints.word |= hints;
1478 
1479         return (void *)service;
1480 }
1481 EXPORT_SYMBOL(irlmp_register_service);
1482 
1483 /*
1484  * Function irlmp_unregister_service (handle)
1485  *
1486  *    Unregister service with IrLMP.
1487  *
1488  *    Returns: 0 on success, -1 on error
1489  */
1490 int irlmp_unregister_service(void *handle)
1491 {
1492         irlmp_service_t *service;
1493         unsigned long flags;
1494 
1495         if (!handle)
1496                 return -1;
1497 
1498         /* Caller may call with invalid handle (it's legal) - Jean II */
1499         service = hashbin_lock_find(irlmp->services, (long) handle, NULL);
1500         if (!service) {
1501                 pr_debug("%s(), Unknown service!\n", __func__);
1502                 return -1;
1503         }
1504 
1505         hashbin_remove_this(irlmp->services, (irda_queue_t *) service);
1506         kfree(service);
1507 
1508         /* Remove old hint bits */
1509         irlmp->hints.word = 0;
1510 
1511         /* Refresh current hint bits */
1512         spin_lock_irqsave(&irlmp->services->hb_spinlock, flags);
1513         service = (irlmp_service_t *) hashbin_get_first(irlmp->services);
1514         while (service) {
1515                 irlmp->hints.word |= service->hints.word;
1516 
1517                 service = (irlmp_service_t *)hashbin_get_next(irlmp->services);
1518         }
1519         spin_unlock_irqrestore(&irlmp->services->hb_spinlock, flags);
1520         return 0;
1521 }
1522 EXPORT_SYMBOL(irlmp_unregister_service);
1523 
1524 /*
1525  * Function irlmp_register_client (hint_mask, callback1, callback2)
1526  *
1527  *    Register a local client with IrLMP
1528  *      First callback is selective discovery (based on hints)
1529  *      Second callback is for selective discovery expiries
1530  *
1531  *    Returns: handle > 0 on success, 0 on error
1532  */
1533 void *irlmp_register_client(__u16 hint_mask, DISCOVERY_CALLBACK1 disco_clb,
1534                             DISCOVERY_CALLBACK2 expir_clb, void *priv)
1535 {
1536         irlmp_client_t *client;
1537 
1538         IRDA_ASSERT(irlmp != NULL, return NULL;);
1539 
1540         /* Make a new registration */
1541         client = kmalloc(sizeof(irlmp_client_t), GFP_ATOMIC);
1542         if (!client)
1543                 return NULL;
1544 
1545         /* Register the details */
1546         client->hint_mask.word = hint_mask;
1547         client->disco_callback = disco_clb;
1548         client->expir_callback = expir_clb;
1549         client->priv = priv;
1550 
1551         hashbin_insert(irlmp->clients, (irda_queue_t *) client,
1552                        (long) client, NULL);
1553 
1554         return (void *) client;
1555 }
1556 EXPORT_SYMBOL(irlmp_register_client);
1557 
1558 /*
1559  * Function irlmp_update_client (handle, hint_mask, callback1, callback2)
1560  *
1561  *    Updates specified client (handle) with possibly new hint_mask and
1562  *    callback
1563  *
1564  *    Returns: 0 on success, -1 on error
1565  */
1566 int irlmp_update_client(void *handle, __u16 hint_mask,
1567                         DISCOVERY_CALLBACK1 disco_clb,
1568                         DISCOVERY_CALLBACK2 expir_clb, void *priv)
1569 {
1570         irlmp_client_t *client;
1571 
1572         if (!handle)
1573                 return -1;
1574 
1575         client = hashbin_lock_find(irlmp->clients, (long) handle, NULL);
1576         if (!client) {
1577                 pr_debug("%s(), Unknown client!\n", __func__);
1578                 return -1;
1579         }
1580 
1581         client->hint_mask.word = hint_mask;
1582         client->disco_callback = disco_clb;
1583         client->expir_callback = expir_clb;
1584         client->priv = priv;
1585 
1586         return 0;
1587 }
1588 EXPORT_SYMBOL(irlmp_update_client);
1589 
1590 /*
1591  * Function irlmp_unregister_client (handle)
1592  *
1593  *    Returns: 0 on success, -1 on error
1594  *
1595  */
1596 int irlmp_unregister_client(void *handle)
1597 {
1598         struct irlmp_client *client;
1599 
1600         if (!handle)
1601                 return -1;
1602 
1603         /* Caller may call with invalid handle (it's legal) - Jean II */
1604         client = hashbin_lock_find(irlmp->clients, (long) handle, NULL);
1605         if (!client) {
1606                 pr_debug("%s(), Unknown client!\n", __func__);
1607                 return -1;
1608         }
1609 
1610         pr_debug("%s(), removing client!\n", __func__);
1611         hashbin_remove_this(irlmp->clients, (irda_queue_t *) client);
1612         kfree(client);
1613 
1614         return 0;
1615 }
1616 EXPORT_SYMBOL(irlmp_unregister_client);
1617 
1618 /*
1619  * Function irlmp_slsap_inuse (slsap)
1620  *
1621  *    Check if the given source LSAP selector is in use
1622  *
1623  * This function is clearly not very efficient. On the mitigating side, the
1624  * stack make sure that in 99% of the cases, we are called only once
1625  * for each socket allocation. We could probably keep a bitmap
1626  * of the allocated LSAP, but I'm not sure the complexity is worth it.
1627  * Jean II
1628  */
1629 static int irlmp_slsap_inuse(__u8 slsap_sel)
1630 {
1631         struct lsap_cb *self;
1632         struct lap_cb *lap;
1633         unsigned long flags;
1634 
1635         IRDA_ASSERT(irlmp != NULL, return TRUE;);
1636         IRDA_ASSERT(irlmp->magic == LMP_MAGIC, return TRUE;);
1637         IRDA_ASSERT(slsap_sel != LSAP_ANY, return TRUE;);
1638 
1639 #ifdef CONFIG_IRDA_ULTRA
1640         /* Accept all bindings to the connectionless LSAP */
1641         if (slsap_sel == LSAP_CONNLESS)
1642                 return FALSE;
1643 #endif /* CONFIG_IRDA_ULTRA */
1644 
1645         /* Valid values are between 0 and 127 (0x0-0x6F) */
1646         if (slsap_sel > LSAP_MAX)
1647                 return TRUE;
1648 
1649         /*
1650          *  Check if slsap is already in use. To do this we have to loop over
1651          *  every IrLAP connection and check every LSAP associated with each
1652          *  the connection.
1653          */
1654         spin_lock_irqsave_nested(&irlmp->links->hb_spinlock, flags,
1655                         SINGLE_DEPTH_NESTING);
1656         lap = (struct lap_cb *) hashbin_get_first(irlmp->links);
1657         while (lap != NULL) {
1658                 IRDA_ASSERT(lap->magic == LMP_LAP_MAGIC, goto errlap;);
1659 
1660                 /* Careful for priority inversions here !
1661                  * irlmp->links is never taken while another IrDA
1662                  * spinlock is held, so we are safe. Jean II */
1663                 spin_lock(&lap->lsaps->hb_spinlock);
1664 
1665                 /* For this IrLAP, check all the LSAPs */
1666                 self = (struct lsap_cb *) hashbin_get_first(lap->lsaps);
1667                 while (self != NULL) {
1668                         IRDA_ASSERT(self->magic == LMP_LSAP_MAGIC,
1669                                     goto errlsap;);
1670 
1671                         if ((self->slsap_sel == slsap_sel)) {
1672                                 pr_debug("Source LSAP selector=%02x in use\n",
1673                                          self->slsap_sel);
1674                                 goto errlsap;
1675                         }
1676                         self = (struct lsap_cb*) hashbin_get_next(lap->lsaps);
1677                 }
1678                 spin_unlock(&lap->lsaps->hb_spinlock);
1679 
1680                 /* Next LAP */
1681                 lap = (struct lap_cb *) hashbin_get_next(irlmp->links);
1682         }
1683         spin_unlock_irqrestore(&irlmp->links->hb_spinlock, flags);
1684 
1685         /*
1686          * Server sockets are typically waiting for connections and
1687          * therefore reside in the unconnected list. We don't want
1688          * to give out their LSAPs for obvious reasons...
1689          * Jean II
1690          */
1691         spin_lock_irqsave(&irlmp->unconnected_lsaps->hb_spinlock, flags);
1692 
1693         self = (struct lsap_cb *) hashbin_get_first(irlmp->unconnected_lsaps);
1694         while (self != NULL) {
1695                 IRDA_ASSERT(self->magic == LMP_LSAP_MAGIC, goto erruncon;);
1696                 if ((self->slsap_sel == slsap_sel)) {
1697                         pr_debug("Source LSAP selector=%02x in use (unconnected)\n",
1698                                  self->slsap_sel);
1699                         goto erruncon;
1700                 }
1701                 self = (struct lsap_cb*) hashbin_get_next(irlmp->unconnected_lsaps);
1702         }
1703         spin_unlock_irqrestore(&irlmp->unconnected_lsaps->hb_spinlock, flags);
1704 
1705         return FALSE;
1706 
1707         /* Error exit from within one of the two nested loops.
1708          * Make sure we release the right spinlock in the righ order.
1709          * Jean II */
1710 errlsap:
1711         spin_unlock(&lap->lsaps->hb_spinlock);
1712 IRDA_ASSERT_LABEL(errlap:)
1713         spin_unlock_irqrestore(&irlmp->links->hb_spinlock, flags);
1714         return TRUE;
1715 
1716         /* Error exit from within the unconnected loop.
1717          * Just one spinlock to release... Jean II */
1718 erruncon:
1719         spin_unlock_irqrestore(&irlmp->unconnected_lsaps->hb_spinlock, flags);
1720         return TRUE;
1721 }
1722 
1723 /*
1724  * Function irlmp_find_free_slsap ()
1725  *
1726  *    Find a free source LSAP to use. This function is called if the service
1727  *    user has requested a source LSAP equal to LM_ANY
1728  */
1729 static __u8 irlmp_find_free_slsap(void)
1730 {
1731         __u8 lsap_sel;
1732         int wrapped = 0;
1733 
1734         IRDA_ASSERT(irlmp != NULL, return -1;);
1735         IRDA_ASSERT(irlmp->magic == LMP_MAGIC, return -1;);
1736 
1737         /* Most users don't really care which LSAPs they are given,
1738          * and therefore we automatically give them a free LSAP.
1739          * This function try to find a suitable LSAP, i.e. which is
1740          * not in use and is within the acceptable range. Jean II */
1741 
1742         do {
1743                 /* Always increment to LSAP number before using it.
1744                  * In theory, we could reuse the last LSAP number, as long
1745                  * as it is no longer in use. Some IrDA stack do that.
1746                  * However, the previous socket may be half closed, i.e.
1747                  * we closed it, we think it's no longer in use, but the
1748                  * other side did not receive our close and think it's
1749                  * active and still send data on it.
1750                  * This is similar to what is done with PIDs and TCP ports.
1751                  * Also, this reduce the number of calls to irlmp_slsap_inuse()
1752                  * which is an expensive function to call.
1753                  * Jean II */
1754                 irlmp->last_lsap_sel++;
1755 
1756                 /* Check if we need to wraparound (0x70-0x7f are reserved) */
1757                 if (irlmp->last_lsap_sel > LSAP_MAX) {
1758                         /* 0x00-0x10 are also reserved for well know ports */
1759                         irlmp->last_lsap_sel = 0x10;
1760 
1761                         /* Make sure we terminate the loop */
1762                         if (wrapped++) {
1763                                 net_err_ratelimited("%s: no more free LSAPs !\n",
1764                                                     __func__);
1765                                 return 0;
1766                         }
1767                 }
1768 
1769                 /* If the LSAP is in use, try the next one.
1770                  * Despite the autoincrement, we need to check if the lsap
1771                  * is really in use or not, first because LSAP may be
1772                  * directly allocated in irlmp_open_lsap(), and also because
1773                  * we may wraparound on old sockets. Jean II */
1774         } while (irlmp_slsap_inuse(irlmp->last_lsap_sel));
1775 
1776         /* Got it ! */
1777         lsap_sel = irlmp->last_lsap_sel;
1778         pr_debug("%s(), found free lsap_sel=%02x\n",
1779                  __func__, lsap_sel);
1780 
1781         return lsap_sel;
1782 }
1783 
1784 /*
1785  * Function irlmp_convert_lap_reason (lap_reason)
1786  *
1787  *    Converts IrLAP disconnect reason codes to IrLMP disconnect reason
1788  *    codes
1789  *
1790  */
1791 LM_REASON irlmp_convert_lap_reason( LAP_REASON lap_reason)
1792 {
1793         int reason = LM_LAP_DISCONNECT;
1794 
1795         switch (lap_reason) {
1796         case LAP_DISC_INDICATION: /* Received a disconnect request from peer */
1797                 pr_debug("%s(), LAP_DISC_INDICATION\n", __func__);
1798                 reason = LM_USER_REQUEST;
1799                 break;
1800         case LAP_NO_RESPONSE:    /* To many retransmits without response */
1801                 pr_debug("%s(), LAP_NO_RESPONSE\n", __func__);
1802                 reason = LM_LAP_DISCONNECT;
1803                 break;
1804         case LAP_RESET_INDICATION:
1805                 pr_debug("%s(), LAP_RESET_INDICATION\n", __func__);
1806                 reason = LM_LAP_RESET;
1807                 break;
1808         case LAP_FOUND_NONE:
1809         case LAP_MEDIA_BUSY:
1810         case LAP_PRIMARY_CONFLICT:
1811                 pr_debug("%s(), LAP_FOUND_NONE, LAP_MEDIA_BUSY or LAP_PRIMARY_CONFLICT\n",
1812                          __func__);
1813                 reason = LM_CONNECT_FAILURE;
1814                 break;
1815         default:
1816                 pr_debug("%s(), Unknown IrLAP disconnect reason %d!\n",
1817                          __func__, lap_reason);
1818                 reason = LM_LAP_DISCONNECT;
1819                 break;
1820         }
1821 
1822         return reason;
1823 }
1824 
1825 #ifdef CONFIG_PROC_FS
1826 
1827 struct irlmp_iter_state {
1828         hashbin_t *hashbin;
1829 };
1830 
1831 #define LSAP_START_TOKEN        ((void *)1)
1832 #define LINK_START_TOKEN        ((void *)2)
1833 
1834 static void *irlmp_seq_hb_idx(struct irlmp_iter_state *iter, loff_t *off)
1835 {
1836         void *element;
1837 
1838         spin_lock_irq(&iter->hashbin->hb_spinlock);
1839         for (element = hashbin_get_first(iter->hashbin);
1840              element != NULL;
1841              element = hashbin_get_next(iter->hashbin)) {
1842                 if (!off || (*off)-- == 0) {
1843                         /* NB: hashbin left locked */
1844                         return element;
1845                 }
1846         }
1847         spin_unlock_irq(&iter->hashbin->hb_spinlock);
1848         iter->hashbin = NULL;
1849         return NULL;
1850 }
1851 
1852 
1853 static void *irlmp_seq_start(struct seq_file *seq, loff_t *pos)
1854 {
1855         struct irlmp_iter_state *iter = seq->private;
1856         void *v;
1857         loff_t off = *pos;
1858 
1859         iter->hashbin = NULL;
1860         if (off-- == 0)
1861                 return LSAP_START_TOKEN;
1862 
1863         iter->hashbin = irlmp->unconnected_lsaps;
1864         v = irlmp_seq_hb_idx(iter, &off);
1865         if (v)
1866                 return v;
1867 
1868         if (off-- == 0)
1869                 return LINK_START_TOKEN;
1870 
1871         iter->hashbin = irlmp->links;
1872         return irlmp_seq_hb_idx(iter, &off);
1873 }
1874 
1875 static void *irlmp_seq_next(struct seq_file *seq, void *v, loff_t *pos)
1876 {
1877         struct irlmp_iter_state *iter = seq->private;
1878 
1879         ++*pos;
1880 
1881         if (v == LSAP_START_TOKEN) {            /* start of list of lsaps */
1882                 iter->hashbin = irlmp->unconnected_lsaps;
1883                 v = irlmp_seq_hb_idx(iter, NULL);
1884                 return v ? v : LINK_START_TOKEN;
1885         }
1886 
1887         if (v == LINK_START_TOKEN) {            /* start of list of links */
1888                 iter->hashbin = irlmp->links;
1889                 return irlmp_seq_hb_idx(iter, NULL);
1890         }
1891 
1892         v = hashbin_get_next(iter->hashbin);
1893 
1894         if (v == NULL) {                        /* no more in this hash bin */
1895                 spin_unlock_irq(&iter->hashbin->hb_spinlock);
1896 
1897                 if (iter->hashbin == irlmp->unconnected_lsaps)
1898                         v =  LINK_START_TOKEN;
1899 
1900                 iter->hashbin = NULL;
1901         }
1902         return v;
1903 }
1904 
1905 static void irlmp_seq_stop(struct seq_file *seq, void *v)
1906 {
1907         struct irlmp_iter_state *iter = seq->private;
1908 
1909         if (iter->hashbin)
1910                 spin_unlock_irq(&iter->hashbin->hb_spinlock);
1911 }
1912 
1913 static int irlmp_seq_show(struct seq_file *seq, void *v)
1914 {
1915         const struct irlmp_iter_state *iter = seq->private;
1916         struct lsap_cb *self = v;
1917 
1918         if (v == LSAP_START_TOKEN)
1919                 seq_puts(seq, "Unconnected LSAPs:\n");
1920         else if (v == LINK_START_TOKEN)
1921                 seq_puts(seq, "\nRegistered Link Layers:\n");
1922         else if (iter->hashbin == irlmp->unconnected_lsaps) {
1923                 self = v;
1924                 IRDA_ASSERT(self->magic == LMP_LSAP_MAGIC, return -EINVAL; );
1925                 seq_printf(seq, "lsap state: %s, ",
1926                            irlsap_state[ self->lsap_state]);
1927                 seq_printf(seq,
1928                            "slsap_sel: %#02x, dlsap_sel: %#02x, ",
1929                            self->slsap_sel, self->dlsap_sel);
1930                 seq_printf(seq, "(%s)", self->notify.name);
1931                 seq_printf(seq, "\n");
1932         } else if (iter->hashbin == irlmp->links) {
1933                 struct lap_cb *lap = v;
1934 
1935                 seq_printf(seq, "lap state: %s, ",
1936                            irlmp_state[lap->lap_state]);
1937 
1938                 seq_printf(seq, "saddr: %#08x, daddr: %#08x, ",
1939                            lap->saddr, lap->daddr);
1940                 seq_printf(seq, "num lsaps: %d",
1941                            HASHBIN_GET_SIZE(lap->lsaps));
1942                 seq_printf(seq, "\n");
1943 
1944                 /* Careful for priority inversions here !
1945                  * All other uses of attrib spinlock are independent of
1946                  * the object spinlock, so we are safe. Jean II */
1947                 spin_lock(&lap->lsaps->hb_spinlock);
1948 
1949                 seq_printf(seq, "\n  Connected LSAPs:\n");
1950                 for (self = (struct lsap_cb *) hashbin_get_first(lap->lsaps);
1951                      self != NULL;
1952                      self = (struct lsap_cb *)hashbin_get_next(lap->lsaps)) {
1953                         IRDA_ASSERT(self->magic == LMP_LSAP_MAGIC,
1954                                     goto outloop;);
1955                         seq_printf(seq, "  lsap state: %s, ",
1956                                    irlsap_state[ self->lsap_state]);
1957                         seq_printf(seq,
1958                                    "slsap_sel: %#02x, dlsap_sel: %#02x, ",
1959                                    self->slsap_sel, self->dlsap_sel);
1960                         seq_printf(seq, "(%s)", self->notify.name);
1961                         seq_putc(seq, '\n');
1962 
1963                 }
1964         IRDA_ASSERT_LABEL(outloop:)
1965                 spin_unlock(&lap->lsaps->hb_spinlock);
1966                 seq_putc(seq, '\n');
1967         } else
1968                 return -EINVAL;
1969 
1970         return 0;
1971 }
1972 
1973 static const struct seq_operations irlmp_seq_ops = {
1974         .start  = irlmp_seq_start,
1975         .next   = irlmp_seq_next,
1976         .stop   = irlmp_seq_stop,
1977         .show   = irlmp_seq_show,
1978 };
1979 
1980 static int irlmp_seq_open(struct inode *inode, struct file *file)
1981 {
1982         IRDA_ASSERT(irlmp != NULL, return -EINVAL;);
1983 
1984         return seq_open_private(file, &irlmp_seq_ops,
1985                         sizeof(struct irlmp_iter_state));
1986 }
1987 
1988 const struct file_operations irlmp_seq_fops = {
1989         .owner          = THIS_MODULE,
1990         .open           = irlmp_seq_open,
1991         .read           = seq_read,
1992         .llseek         = seq_lseek,
1993         .release        = seq_release_private,
1994 };
1995 
1996 #endif /* PROC_FS */
1997 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp