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