cregit-Linux how code gets into the kernel

Release 4.8 net/irda/irlmp.c

Directory: net/irda
/*********************************************************************
 *
 * Filename:      irlmp.c
 * Version:       1.0
 * Description:   IrDA Link Management Protocol (LMP) layer
 * Status:        Stable.
 * Author:        Dag Brattli <dagb@cs.uit.no>
 * Created at:    Sun Aug 17 20:54:32 1997
 * Modified at:   Wed Jan  5 11:26:03 2000
 * Modified by:   Dag Brattli <dagb@cs.uit.no>
 *
 *     Copyright (c) 1998-2000 Dag Brattli <dagb@cs.uit.no>,
 *     All Rights Reserved.
 *     Copyright (c) 2000-2003 Jean Tourrilhes <jt@hpl.hp.com>
 *
 *     This program is free software; you can redistribute it and/or
 *     modify it under the terms of the GNU General Public License as
 *     published by the Free Software Foundation; either version 2 of
 *     the License, or (at your option) any later version.
 *
 *     Neither Dag Brattli nor University of Tromsø admit liability nor
 *     provide warranty for any of this software. This material is
 *     provided "AS-IS" and at no charge.
 *
 ********************************************************************/

#include <linux/module.h>
#include <linux/slab.h>
#include <linux/string.h>
#include <linux/skbuff.h>
#include <linux/types.h>
#include <linux/proc_fs.h>
#include <linux/init.h>
#include <linux/kmod.h>
#include <linux/random.h>
#include <linux/seq_file.h>

#include <net/irda/irda.h>
#include <net/irda/timer.h>
#include <net/irda/qos.h>
#include <net/irda/irlap.h>
#include <net/irda/iriap.h>
#include <net/irda/irlmp.h>
#include <net/irda/irlmp_frame.h>

#include <asm/unaligned.h>

static __u8 irlmp_find_free_slsap(void);
static int irlmp_slsap_inuse(__u8 slsap_sel);

/* Master structure */

struct irlmp_cb *irlmp = NULL;

/* These can be altered by the sysctl interface */

int  sysctl_discovery         = 0;

int  sysctl_discovery_timeout = 3; 
/* 3 seconds by default */

int  sysctl_discovery_slots   = 6; 
/* 6 slots by default */

int  sysctl_lap_keepalive_time = LM_IDLE_TIMEOUT * 1000 / HZ;

char sysctl_devname[65];


static const char *irlmp_reasons[] = {
	"ERROR, NOT USED",
	"LM_USER_REQUEST",
	"LM_LAP_DISCONNECT",
	"LM_CONNECT_FAILURE",
	"LM_LAP_RESET",
	"LM_INIT_DISCONNECT",
	"ERROR, NOT USED",
	"UNKNOWN",
};


const char *irlmp_reason_str(LM_REASON reason) { reason = min_t(size_t, reason, ARRAY_SIZE(irlmp_reasons) - 1); return irlmp_reasons[reason]; }

Contributors

PersonTokensPropCommitsCommitProp
dan carpenterdan carpenter32100.00%1100.00%
Total32100.00%1100.00%

/* * Function irlmp_init (void) * * Create (allocate) the main IrLMP structure * */
int __init irlmp_init(void) { /* Initialize the irlmp structure. */ irlmp = kzalloc( sizeof(struct irlmp_cb), GFP_KERNEL); if (irlmp == NULL) return -ENOMEM; irlmp->magic = LMP_MAGIC; irlmp->clients = hashbin_new(HB_LOCK); irlmp->services = hashbin_new(HB_LOCK); irlmp->links = hashbin_new(HB_LOCK); irlmp->unconnected_lsaps = hashbin_new(HB_LOCK); irlmp->cachelog = hashbin_new(HB_NOLOCK); if ((irlmp->clients == NULL) || (irlmp->services == NULL) || (irlmp->links == NULL) || (irlmp->unconnected_lsaps == NULL) || (irlmp->cachelog == NULL)) { return -ENOMEM; } spin_lock_init(&irlmp->cachelog->hb_spinlock); irlmp->last_lsap_sel = 0x0f; /* Reserved 0x00-0x0f */ strcpy(sysctl_devname, "Linux"); init_timer(&irlmp->discovery_timer); /* Do discovery every 3 seconds, conditionally */ if (sysctl_discovery) irlmp_start_discovery_timer(irlmp, sysctl_discovery_timeout*HZ); return 0; }

Contributors

PersonTokensPropCommitsCommitProp
pre-gitpre-git10960.56%440.00%
jean tourrilhesjean tourrilhes6536.11%330.00%
ross burtonross burton42.22%110.00%
andre goddard rosaandre goddard rosa10.56%110.00%
panagiotis issaris*panagiotis issaris*10.56%110.00%
Total180100.00%10100.00%

/* * Function irlmp_cleanup (void) * * Remove IrLMP layer * */
void irlmp_cleanup(void) { /* Check for main structure */ IRDA_ASSERT(irlmp != NULL, return;); IRDA_ASSERT(irlmp->magic == LMP_MAGIC, return;); del_timer(&irlmp->discovery_timer); hashbin_delete(irlmp->links, (FREE_FUNC) kfree); hashbin_delete(irlmp->unconnected_lsaps, (FREE_FUNC) kfree); hashbin_delete(irlmp->clients, (FREE_FUNC) kfree); hashbin_delete(irlmp->services, (FREE_FUNC) kfree); hashbin_delete(irlmp->cachelog, (FREE_FUNC) kfree); /* De-allocate main structure */ kfree(irlmp); irlmp = NULL; }

Contributors

PersonTokensPropCommitsCommitProp
pre-gitpre-git9898.00%266.67%
jean tourrilhesjean tourrilhes22.00%133.33%
Total100100.00%3100.00%

/* * Function irlmp_open_lsap (slsap, notify) * * Register with IrLMP and create a local LSAP, * returns handle to LSAP. */
struct lsap_cb *irlmp_open_lsap(__u8 slsap_sel, notify_t *notify, __u8 pid) { struct lsap_cb *self; IRDA_ASSERT(notify != NULL, return NULL;); IRDA_ASSERT(irlmp != NULL, return NULL;); IRDA_ASSERT(irlmp->magic == LMP_MAGIC, return NULL;); IRDA_ASSERT(notify->instance != NULL, return NULL;); /* Does the client care which Source LSAP selector it gets? */ if (slsap_sel == LSAP_ANY) { slsap_sel = irlmp_find_free_slsap(); if (!slsap_sel) return NULL; } else if (irlmp_slsap_inuse(slsap_sel)) return NULL; /* Allocate new instance of a LSAP connection */ self = kzalloc(sizeof(struct lsap_cb), GFP_ATOMIC); if (self == NULL) return NULL; self->magic = LMP_LSAP_MAGIC; self->slsap_sel = slsap_sel; /* Fix connectionless LSAP's */ if (slsap_sel == LSAP_CONNLESS) { #ifdef CONFIG_IRDA_ULTRA self->dlsap_sel = LSAP_CONNLESS; self->pid = pid; #endif /* CONFIG_IRDA_ULTRA */ } else self->dlsap_sel = LSAP_ANY; /* self->connected = FALSE; -> already NULL via memset() */ init_timer(&self->watchdog_timer); self->notify = *notify; self->lsap_state = LSAP_DISCONNECTED; /* Insert into queue of unconnected LSAPs */ hashbin_insert(irlmp->unconnected_lsaps, (irda_queue_t *) self, (long) self, NULL); return self; }

Contributors

PersonTokensPropCommitsCommitProp
pre-gitpre-git18291.92%444.44%
jean tourrilhesjean tourrilhes115.56%333.33%
linus torvaldslinus torvalds42.02%111.11%
panagiotis issaris*panagiotis issaris*10.51%111.11%
Total198100.00%9100.00%

EXPORT_SYMBOL(irlmp_open_lsap); /* * Function __irlmp_close_lsap (self) * * Remove an instance of LSAP */
static void __irlmp_close_lsap(struct lsap_cb *self) { IRDA_ASSERT(self != NULL, return;); IRDA_ASSERT(self->magic == LMP_LSAP_MAGIC, return;); /* * Set some of the variables to preset values */ self->magic = 0; del_timer(&self->watchdog_timer); /* Important! */ if (self->conn_skb) dev_kfree_skb(self->conn_skb); kfree(self); }

Contributors

PersonTokensPropCommitsCommitProp
pre-gitpre-git5796.61%266.67%
jean tourrilhesjean tourrilhes23.39%133.33%
Total59100.00%3100.00%

/* * Function irlmp_close_lsap (self) * * Close and remove LSAP * */
void irlmp_close_lsap(struct lsap_cb *self) { struct lap_cb *lap; struct lsap_cb *lsap = NULL; IRDA_ASSERT(self != NULL, return;); IRDA_ASSERT(self->magic == LMP_LSAP_MAGIC, return;); /* * Find out if we should remove this LSAP from a link or from the * list of unconnected lsaps (not associated with a link) */ lap = self->lap; if (lap) { IRDA_ASSERT(lap->magic == LMP_LAP_MAGIC, return;); /* We might close a LSAP before it has completed the * connection setup. In those case, higher layers won't * send a proper disconnect request. Harmless, except * that we will forget to close LAP... - Jean II */ if(self->lsap_state != LSAP_DISCONNECTED) { self->lsap_state = LSAP_DISCONNECTED; irlmp_do_lap_event(self->lap, LM_LAP_DISCONNECT_REQUEST, NULL); } /* Now, remove from the link */ lsap = hashbin_remove(lap->lsaps, (long) self, NULL); #ifdef CONFIG_IRDA_CACHE_LAST_LSAP lap->cache.valid = FALSE; #endif } self->lap = NULL; /* Check if we found the LSAP! If not then try the unconnected lsaps */ if (!lsap) { lsap = hashbin_remove(irlmp->unconnected_lsaps, (long) self, NULL); } if (!lsap) { pr_debug("%s(), Looks like somebody has removed me already!\n", __func__); return; } __irlmp_close_lsap(self); }

Contributors

PersonTokensPropCommitsCommitProp
pre-gitpre-git10765.24%220.00%
jean tourrilhesjean tourrilhes4929.88%550.00%
linus torvaldslinus torvalds63.66%110.00%
joe perchesjoe perches10.61%110.00%
harvey harrisonharvey harrison10.61%110.00%
Total164100.00%10100.00%

EXPORT_SYMBOL(irlmp_close_lsap); /* * Function irlmp_register_irlap (saddr, notify) * * Register IrLAP layer with IrLMP. There is possible to have multiple * instances of the IrLAP layer, each connected to different IrDA ports * */
void irlmp_register_link(struct irlap_cb *irlap, __u32 saddr, notify_t *notify) { struct lap_cb *lap; IRDA_ASSERT(irlmp != NULL, return;); IRDA_ASSERT(irlmp->magic == LMP_MAGIC, return;); IRDA_ASSERT(notify != NULL, return;); /* * Allocate new instance of a LSAP connection */ lap = kzalloc(sizeof(struct lap_cb), GFP_KERNEL); if (lap == NULL) return; lap->irlap = irlap; lap->magic = LMP_LAP_MAGIC; lap->saddr = saddr; lap->daddr = DEV_ADDR_ANY; #ifdef CONFIG_IRDA_CACHE_LAST_LSAP lap->cache.valid = FALSE; #endif lap->lsaps = hashbin_new(HB_LOCK); if (lap->lsaps == NULL) { net_warn_ratelimited("%s(), unable to kmalloc lsaps\n", __func__); kfree(lap); return; } lap->lap_state = LAP_STANDBY; init_timer(&lap->idle_timer); /* * Insert into queue of LMP links */ hashbin_insert(irlmp->links, (irda_queue_t *) lap, lap->saddr, NULL); /* * We set only this variable so IrLAP can tell us on which link the * different events happened on */ irda_notify_init(notify); notify->instance = lap; }

Contributors

PersonTokensPropCommitsCommitProp
pre-gitpre-git12670.39%433.33%
jean tourrilhesjean tourrilhes4625.70%325.00%
linus torvaldslinus torvalds31.68%18.33%
martin daleckimartin dalecki10.56%18.33%
harvey harrisonharvey harrison10.56%18.33%
panagiotis issaris*panagiotis issaris*10.56%18.33%
joe perchesjoe perches10.56%18.33%
Total179100.00%12100.00%

/* * Function irlmp_unregister_irlap (saddr) * * IrLAP layer has been removed! * */
void irlmp_unregister_link(__u32 saddr) { struct lap_cb *link; /* We must remove ourselves from the hashbin *first*. This ensure * that no more LSAPs will be open on this link and no discovery * will be triggered anymore. Jean II */ link = hashbin_remove(irlmp->links, saddr, NULL); if (link) { IRDA_ASSERT(link->magic == LMP_LAP_MAGIC, return;); /* Kill all the LSAPs on this link. Jean II */ link->reason = LAP_DISC_INDICATION; link->daddr = DEV_ADDR_ANY; irlmp_do_lap_event(link, LM_LAP_DISCONNECT_INDICATION, NULL); /* Remove all discoveries discovered at this link */ irlmp_expire_discoveries(irlmp->cachelog, link->saddr, TRUE); /* Final cleanup */ del_timer(&link->idle_timer); link->magic = 0; hashbin_delete(link->lsaps, (FREE_FUNC) __irlmp_close_lsap); kfree(link); } }

Contributors

PersonTokensPropCommitsCommitProp
pre-gitpre-git7165.74%350.00%
jean tourrilhesjean tourrilhes2523.15%233.33%
hinko kocevarhinko kocevar1211.11%116.67%
Total108100.00%6100.00%

/* * Function irlmp_connect_request (handle, dlsap, userdata) * * Connect with a peer LSAP * */
int irlmp_connect_request(struct lsap_cb *self, __u8 dlsap_sel, __u32 saddr, __u32 daddr, struct qos_info *qos, struct sk_buff *userdata) { struct sk_buff *tx_skb = userdata; struct lap_cb *lap; struct lsap_cb *lsap; int ret; IRDA_ASSERT(self != NULL, return -EBADR;); IRDA_ASSERT(self->magic == LMP_LSAP_MAGIC, return -EBADR;); pr_debug("%s(), slsap_sel=%02x, dlsap_sel=%02x, saddr=%08x, daddr=%08x\n", __func__, self->slsap_sel, dlsap_sel, saddr, daddr); if (test_bit(0, &self->connected)) { ret = -EISCONN; goto err; } /* Client must supply destination device address */ if (!daddr) { ret = -EINVAL; goto err; } /* Any userdata? */ if (tx_skb == NULL) { tx_skb = alloc_skb(LMP_MAX_HEADER, GFP_ATOMIC); if (!tx_skb) return -ENOMEM; skb_reserve(tx_skb, LMP_MAX_HEADER); } /* Make room for MUX control header (3 bytes) */ IRDA_ASSERT(skb_headroom(tx_skb) >= LMP_CONTROL_HEADER, return -1;); skb_push(tx_skb, LMP_CONTROL_HEADER); self->dlsap_sel = dlsap_sel; /* * Find the link to where we should try to connect since there may * be more than one IrDA port on this machine. If the client has * passed us the saddr (and already knows which link to use), then * we use that to find the link, if not then we have to look in the * discovery log and check if any of the links has discovered a * device with the given daddr */ if ((!saddr) || (saddr == DEV_ADDR_ANY)) { discovery_t *discovery; unsigned long flags; spin_lock_irqsave(&irlmp->cachelog->hb_spinlock, flags); if (daddr != DEV_ADDR_ANY) discovery = hashbin_find(irlmp->cachelog, daddr, NULL); else { pr_debug("%s(), no daddr\n", __func__); discovery = (discovery_t *) hashbin_get_first(irlmp->cachelog); } if (discovery) { saddr = discovery->data.saddr; daddr = discovery->data.daddr; } spin_unlock_irqrestore(&irlmp->cachelog->hb_spinlock, flags); } lap = hashbin_lock_find(irlmp->links, saddr, NULL); if (lap == NULL) { pr_debug("%s(), Unable to find a usable link!\n", __func__); ret = -EHOSTUNREACH; goto err; } /* Check if LAP is disconnected or already connected */ if (lap->daddr == DEV_ADDR_ANY) lap->daddr = daddr; else if (lap->daddr != daddr) { /* Check if some LSAPs are active on this LAP */ if (HASHBIN_GET_SIZE(lap->lsaps) == 0) { /* No active connection, but LAP hasn't been * disconnected yet (waiting for timeout in LAP). * Maybe we could give LAP a bit of help in this case. */ pr_debug("%s(), sorry, but I'm waiting for LAP to timeout!\n", __func__); ret = -EAGAIN; goto err; } /* LAP is already connected to a different node, and LAP * can only talk to one node at a time */ pr_debug("%s(), sorry, but link is busy!\n", __func__); ret = -EBUSY; goto err; } self->lap = lap; /* * Remove LSAP from list of unconnected LSAPs and insert it into the * list of connected LSAPs for the particular link */ lsap = hashbin_remove(irlmp->unconnected_lsaps, (long) self, NULL); IRDA_ASSERT(lsap != NULL, return -1;); IRDA_ASSERT(lsap->magic == LMP_LSAP_MAGIC, return -1;); IRDA_ASSERT(lsap->lap != NULL, return -1;); IRDA_ASSERT(lsap->lap->magic == LMP_LAP_MAGIC, return -1;); hashbin_insert(self->lap->lsaps, (irda_queue_t *) self, (long) self, NULL); set_bit(0, &self->connected); /* TRUE */ /* * User supplied qos specifications? */ if (qos) self->qos = *qos; irlmp_do_lsap_event(self, LM_CONNECT_REQUEST, tx_skb); /* Drop reference count - see irlap_data_request(). */ dev_kfree_skb(tx_skb); return 0; err: /* Cleanup */ if(tx_skb) dev_kfree_skb(tx_skb); return ret; }

Contributors

PersonTokensPropCommitsCommitProp
pre-gitpre-git36869.17%735.00%
jean tourrilhesjean tourrilhes12723.87%630.00%
linus torvaldslinus torvalds213.95%210.00%
joe perchesjoe perches50.94%15.00%
harvey harrisonharvey harrison50.94%15.00%
samuel ortizsamuel ortiz40.75%210.00%
martin daleckimartin dalecki20.38%15.00%
Total532100.00%20100.00%

EXPORT_SYMBOL(irlmp_connect_request); /* * Function irlmp_connect_indication (self) * * Incoming connection * */
void irlmp_connect_indication(struct lsap_cb *self, struct sk_buff *skb) { int max_seg_size; int lap_header_size; int max_header_size; IRDA_ASSERT(self != NULL, return;); IRDA_ASSERT(self->magic == LMP_LSAP_MAGIC, return;); IRDA_ASSERT(skb != NULL, return;); IRDA_ASSERT(self->lap != NULL, return;); pr_debug("%s(), slsap_sel=%02x, dlsap_sel=%02x\n", __func__, self->slsap_sel, self->dlsap_sel); /* Note : self->lap is set in irlmp_link_data_indication(), * (case CONNECT_CMD:) because we have no way to set it here. * Similarly, self->dlsap_sel is usually set in irlmp_find_lsap(). * Jean II */ self->qos = *self->lap->qos; max_seg_size = self->lap->qos->data_size.value-LMP_HEADER; lap_header_size = IRLAP_GET_HEADER_SIZE(self->lap->irlap); max_header_size = LMP_HEADER + lap_header_size; /* Hide LMP_CONTROL_HEADER header from layer above */ skb_pull(skb, LMP_CONTROL_HEADER); if (self->notify.connect_indication) { /* Don't forget to refcount it - see irlap_driver_rcv(). */ skb_get(skb); self->notify.connect_indication(self->notify.instance, self, &self->qos, max_seg_size, max_header_size, skb); } }

Contributors

PersonTokensPropCommitsCommitProp
pre-gitpre-git14389.38%440.00%
jean tourrilhesjean tourrilhes148.75%330.00%
joe perchesjoe perches10.62%110.00%
harvey harrisonharvey harrison10.62%110.00%
linus torvaldslinus torvalds10.62%110.00%
Total160100.00%10100.00%

/* * Function irlmp_connect_response (handle, userdata) * * Service user is accepting connection * */
int irlmp_connect_response(struct lsap_cb *self, struct sk_buff *userdata) { IRDA_ASSERT(self != NULL, return -1;); IRDA_ASSERT(self->magic == LMP_LSAP_MAGIC, return -1;); IRDA_ASSERT(userdata != NULL, return -1;); /* We set the connected bit and move the lsap to the connected list * in the state machine itself. Jean II */ pr_debug("%s(), slsap_sel=%02x, dlsap_sel=%02x\n", __func__, self->slsap_sel, self->dlsap_sel); /* Make room for MUX control header (3 bytes) */ IRDA_ASSERT(skb_headroom(userdata) >= LMP_CONTROL_HEADER, return -1;); skb_push(userdata, LMP_CONTROL_HEADER); irlmp_do_lsap_event(self, LM_CONNECT_RESPONSE, userdata); /* Drop reference count - see irlap_data_request(). */ dev_kfree_skb(userdata); return 0; }

Contributors

PersonTokensPropCommitsCommitProp
pre-gitpre-git7883.87%440.00%
jean tourrilhesjean tourrilhes1313.98%440.00%
harvey harrisonharvey harrison11.08%110.00%
joe perchesjoe perches11.08%110.00%
Total93100.00%10100.00%

EXPORT_SYMBOL(irlmp_connect_response); /* * Function irlmp_connect_confirm (handle, skb) * * LSAP connection confirmed peer device! */
void irlmp_connect_confirm(struct lsap_cb *self, struct sk_buff *skb) { int max_header_size; int lap_header_size; int max_seg_size; IRDA_ASSERT(skb != NULL, return;); IRDA_ASSERT(self != NULL, return;); IRDA_ASSERT(self->magic == LMP_LSAP_MAGIC, return;); IRDA_ASSERT(self->lap != NULL, return;); self->qos = *self->lap->qos; max_seg_size = self->lap->qos->data_size.value-LMP_HEADER; lap_header_size = IRLAP_GET_HEADER_SIZE(self->lap->irlap); max_header_size = LMP_HEADER + lap_header_size; pr_debug("%s(), max_header_size=%d\n", __func__, max_header_size); /* Hide LMP_CONTROL_HEADER header from layer above */ skb_pull(skb, LMP_CONTROL_HEADER); if (self->notify.connect_confirm) { /* Don't forget to refcount it - see irlap_driver_rcv() */ skb_get(skb); self->notify.connect_confirm(self->notify.instance, self, &self->qos, max_seg_size, max_header_size, skb); } }

Contributors

PersonTokensPropCommitsCommitProp
pre-gitpre-git13990.85%550.00%
jean tourrilhesjean tourrilhes127.84%330.00%
harvey harrisonharvey harrison10.65%110.00%
joe perchesjoe perches10.65%110.00%
Total153100.00%10100.00%

/* * Function irlmp_dup (orig, instance) * * Duplicate LSAP, can be used by servers to confirm a connection on a * new LSAP so it can keep listening on the old one. * */
struct lsap_cb *irlmp_dup(struct lsap_cb *orig, void *instance) { struct lsap_cb *new; unsigned long flags; spin_lock_irqsave(&irlmp->unconnected_lsaps->hb_spinlock, flags); /* Only allowed to duplicate unconnected LSAP's, and only LSAPs * that have received a connect indication. Jean II */ if ((!hashbin_find(irlmp->unconnected_lsaps, (long) orig, NULL)) || (orig->lap == NULL)) { pr_debug("%s(), invalid LSAP (wrong state)\n", __func__); spin_unlock_irqrestore(&irlmp->unconnected_lsaps->hb_spinlock, flags); return NULL; } /* Allocate a new instance */ new = kmemdup(orig, sizeof(*new), GFP_ATOMIC); if (!new) { pr_debug("%s(), unable to kmalloc\n", __func__); spin_unlock_irqrestore(&irlmp->unconnected_lsaps->hb_spinlock, flags); return NULL; } /* new->lap = orig->lap; => done in the memcpy() */ /* new->slsap_sel = orig->slsap_sel; => done in the memcpy() */ new->conn_skb = NULL; spin_unlock_irqrestore(&irlmp->unconnected_lsaps->hb_spinlock, flags); /* Not everything is the same */ new->notify.instance = instance; init_timer(&new->watchdog_timer); hashbin_insert(irlmp->unconnected_lsaps, (irda_queue_t *) new, (long) new, NULL); #ifdef CONFIG_IRDA_CACHE_LAST_LSAP /* Make sure that we invalidate the LSAP cache */ new->lap->cache.valid = FALSE; #endif /* CONFIG_IRDA_CACHE_LAST_LSAP */ return new; }

Contributors

PersonTokensPropCommitsCommitProp
pre-gitpre-git11956.40%218.18%
jean tourrilhesjean tourrilhes8339.34%654.55%
arnaldo carvalho de meloarnaldo carvalho de melo52.37%19.09%
joe perchesjoe perches20.95%19.09%
harvey harrisonharvey harrison20.95%19.09%
Total211100.00%11100.00%

/* * Function irlmp_disconnect_request (handle, userdata) * * The service user is requesting disconnection, this will not remove the * LSAP, but only mark it as disconnected */
int irlmp_disconnect_request(struct lsap_cb *self, struct sk_buff *userdata) { struct lsap_cb *lsap; IRDA_ASSERT(self != NULL, return -1;); IRDA_ASSERT(self->magic == LMP_LSAP_MAGIC, return -1;); IRDA_ASSERT(userdata != NULL, return -1;); /* Already disconnected ? * There is a race condition between irlmp_disconnect_indication() * and us that might mess up the hashbins below. This fixes it. * Jean II */ if (! test_and_clear_bit(0, &self->connected)) { pr_debug("%s(), already disconnected!\n", __func__); dev_kfree_skb(userdata); return -1; } skb_push(userdata, LMP_CONTROL_HEADER); /* * Do the event before the other stuff since we must know * which lap layer that the frame should be transmitted on */ irlmp_do_lsap_event(self, LM_DISCONNECT_REQUEST, userdata); /* Drop reference count - see irlap_data_request(). */ dev_kfree_skb(userdata); /* * Remove LSAP from list of connected LSAPs for the particular link * and insert it into the list of unconnected LSAPs */ IRDA_ASSERT(self->lap != NULL, return -1;); IRDA_ASSERT(self->lap->magic == LMP_LAP_MAGIC, return -1;); IRDA_ASSERT(self->lap->lsaps != NULL, return -1;); lsap = hashbin_remove(self->lap->lsaps, (long) self, NULL); #ifdef CONFIG_IRDA_CACHE_LAST_LSAP self->lap->cache.valid = FALSE; #endif IRDA_ASSERT(lsap != NULL, return -1;); IRDA_ASSERT(lsap->magic == LMP_LSAP_MAGIC, return -1;); IRDA_ASSERT(lsap == self, return -1;); hashbin_insert(irlmp->unconnected_lsaps, (irda_queue_t *) self, (long) self, NULL); /* Reset some values */ self->dlsap_sel = LSAP_ANY; self->lap = NULL; return 0; }

Contributors

PersonTokensPropCommitsCommitProp
pre-gitpre-git16874.34%430.77%
jean tourrilhesjean tourrilhes3415.04%538.46%
linus torvaldslinus torvalds208.85%17.69%
martin daleckimartin dalecki20.88%17.69%
harvey harrisonharvey harrison10.44%17.69%
joe perchesjoe perches10.44%17.69%
Total226100.00%13100.00%

EXPORT_SYMBOL(irlmp_disconnect_request); /* * Function irlmp_disconnect_indication (reason, userdata) * * LSAP is being closed! */
void irlmp_disconnect_indication(struct lsap_cb *self, LM_REASON reason, struct sk_buff *skb) { struct lsap_cb *lsap; pr_debug("%s(), reason=%s [%d]\n", __func__, irlmp_reason_str(reason), reason); IRDA_ASSERT(self != NULL, return;); IRDA_ASSERT(self->magic == LMP_LSAP_MAGIC, return;); pr_debug("%s(), slsap_sel=%02x, dlsap_sel=%02x\n", __func__, self->slsap_sel, self->dlsap_sel); /* Already disconnected ? * There is a race condition between irlmp_disconnect_request() * and us that might mess up the hashbins below. This fixes it. * Jean II */ if (! test_and_clear_bit(0, &self->connected)) { pr_debug("%s(), already disconnected!\n", __func__); return; } /* * Remove association between this LSAP and the link it used */ IRDA_ASSERT(self->lap != NULL, return;); IRDA_ASSERT(self->lap->lsaps != NULL, return;); lsap = hashbin_remove(self->lap->lsaps, (long) self, NULL); #ifdef CONFIG_IRDA_CACHE_LAST_LSAP self->lap->cache.valid = FALSE; #endif IRDA_ASSERT(lsap != NULL, return;); IRDA_ASSERT(lsap == self, return;); hashbin_insert(irlmp->unconnected_lsaps, (irda_queue_t *) lsap, (long) lsap, NULL); self->dlsap_sel = LSAP_ANY; self->lap = NULL; /* * Inform service user */ if (self->notify.disconnect_indication) { /* Don't forget to refcount it - see irlap_driver_rcv(). */ if(skb) skb_get(skb); self->notify.disconnect_indication(self->notify.instance, self, reason, skb); } else { pr_debug("%s(), no handler\n", __func__); } }

Contributors

PersonTokensPropCommitsCommitProp
pre-gitpre-git15365.38%533.33%
jean tourrilhesjean tourrilhes4418.80%533.33%
linus torvaldslinus torvalds229.40%16.67%
dan carpenterdan carpenter62.56%16.67%
joe perchesjoe perches41.71%16.67%
harvey harrisonharvey harrison41.71%16.67%
martin daleckimartin dalecki10.43%16.67%
Total234100.00%15100.00%

/* * Function irlmp_do_expiry (void) * * Do a cleanup of the discovery log (remove old entries) * * Note : separate from irlmp_do_discovery() so that we can handle * passive discovery properly. */
void irlmp_do_expiry(void) { struct lap_cb *lap; /* * Expire discovery on all links which are *not* connected. * On links which are connected, we can't do discovery * anymore and can't refresh the log, so we freeze the * discovery log to keep info about the device we are * connected to. * This info is mandatory if we want irlmp_connect_request() * to work properly. - Jean II */ lap = (struct lap_cb *) hashbin_get_first(irlmp->links); while (lap != NULL) { IRDA_ASSERT(lap->magic == LMP_LAP_MAGIC, return;); if (lap->lap_state == LAP_STANDBY) { /* Expire discoveries discovered on this link */ irlmp_expire_discoveries(irlmp->cachelog, lap->saddr, FALSE); } lap = (struct lap_cb *) hashbin_get_next(irlmp->links); } }

Contributors

PersonTokensPropCommitsCommitProp
linus torvaldslinus torvalds7593.75%125.00%
al viroal viro33.75%125.00%
jean tourrilhesjean tourrilhes22.50%250.00%
Total80100.00%4100.00%

/* * Function irlmp_do_discovery (nslots) * * Do some discovery on all links * * Note : log expiry is done above. */
void irlmp_do_discovery(int nslots) { struct lap_cb *lap; __u16 *data_hintsp; /* Make sure the value is sane */ if ((nslots != 1) && (nslots != 6) && (nslots != 8) && (nslots != 16)){ net_warn_ratelimited("%s: invalid value for number of slots!\n", __func__); nslots = sysctl_discovery_slots = 8; } /* Construct new discovery info to be used by IrLAP, */ data_hintsp = (__u16 *) irlmp->discovery_cmd.data.hints; put_unaligned(irlmp->hints.word, data_hintsp); /* * 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.data.charset = CS_ASCII; strncpy(irlmp->discovery_cmd.data.info, sysctl_devname, NICKNAME_MAX_LEN); irlmp->discovery_cmd.name_len = strlen(irlmp->discovery_cmd.data.info); irlmp->discovery_cmd.nslots = nslots; /* * Try to send discovery packets on all links */ lap = (struct lap_cb *) hashbin_get_first(irlmp->links); while (lap != NULL) { IRDA_ASSERT(lap->magic == LMP_LAP_MAGIC, return;); if (lap->lap_state == LAP_STANDBY) { /* Try to discover */ irlmp_do_lap_event(lap, LM_LAP_DISCOVERY_REQUEST, NULL); } lap = (struct lap_cb *) hashbin_get_next(irlmp->links); } }

Contributors

PersonTokensPropCommitsCommitProp
pre-gitpre-git16884.00%545.45%
david s. millerdavid s. miller168.00%19.09%
jean tourrilhesjean tourrilhes115.50%218.18%
martin daleckimartin dalecki31.50%19.09%
joe perchesjoe perches10.50%19.09%
harvey harrisonharvey harrison10.50%19.09%
Total200100.00%11100.00%

/* * Function irlmp_discovery_request (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 (in full) */ irlmp_discovery_confirm(irlmp->cachelog, DISCOVERY_LOG); /* * Start a single discovery operation if discovery is not already * running */ if (!sysctl_discovery) { /* Check if user wants to override the default */ if (nslots == DISCOVERY_DEFAULT_SLOTS) nslots = sysctl_discovery_slots; irlmp_do_discovery(nslots); /* Note : we never do expiry here. Expiry will run on the * discovery timer regardless of the state of sysctl_discovery * Jean II */ } }

Contributors

PersonTokensPropCommitsCommitProp
pre-gitpre-git2558.14%342.86%
linus torvaldslinus torvalds1432.56%114.29%
jean tourrilhesjean tourrilhes36.98%228.57%
hideaki yoshifujihideaki yoshifuji12.33%114.29%
Total43100.00%7100.00%

EXPORT_SYMBOL