1/* 2 * w1_netlink.c 3 * 4 * Copyright (c) 2003 Evgeniy Polyakov <zbr@ioremap.net> 5 * 6 * 7 * This program is free software; you can redistribute it and/or modify 8 * it under the terms of the GNU General Public License as published by 9 * the Free Software Foundation; either version 2 of the License, or 10 * (at your option) any later version. 11 * 12 * This program is distributed in the hope that it will be useful, 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 * GNU General Public License for more details. 16 * 17 * You should have received a copy of the GNU General Public License 18 * along with this program; if not, write to the Free Software 19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 20 */ 21 22#include <linux/slab.h> 23#include <linux/skbuff.h> 24#include <linux/netlink.h> 25#include <linux/connector.h> 26 27#include "w1.h" 28#include "w1_log.h" 29#include "w1_netlink.h" 30 31#if defined(CONFIG_W1_CON) && (defined(CONFIG_CONNECTOR) || (defined(CONFIG_CONNECTOR_MODULE) && defined(CONFIG_W1_MODULE))) 32 33#define MIN(a, b) (((a) < (b)) ? (a) : (b)) 34 35/* Bundle together everything required to process a request in one memory 36 * allocation. 37 */ 38struct w1_cb_block { 39 atomic_t refcnt; 40 u32 portid; /* Sending process port ID */ 41 /* maximum value for first_cn->len */ 42 u16 maxlen; 43 /* pointers to building up the reply message */ 44 struct cn_msg *first_cn; /* fixed once the structure is populated */ 45 struct cn_msg *cn; /* advances as cn_msg is appeneded */ 46 struct w1_netlink_msg *msg; /* advances as w1_netlink_msg is appened */ 47 struct w1_netlink_cmd *cmd; /* advances as cmds are appened */ 48 struct w1_netlink_msg *cur_msg; /* currently message being processed */ 49 /* copy of the original request follows */ 50 struct cn_msg request_cn; 51 /* followed by variable length: 52 * cn_msg, data (w1_netlink_msg and w1_netlink_cmd) 53 * one or more struct w1_cb_node 54 * reply first_cn, data (w1_netlink_msg and w1_netlink_cmd) 55 */ 56}; 57struct w1_cb_node { 58 struct w1_async_cmd async; 59 /* pointers within w1_cb_block and cn data */ 60 struct w1_cb_block *block; 61 struct w1_netlink_msg *msg; 62 struct w1_slave *sl; 63 struct w1_master *dev; 64}; 65 66/** 67 * w1_reply_len() - calculate current reply length, compare to maxlen 68 * @block: block to calculate 69 * 70 * Calculates the current message length including possible multiple 71 * cn_msg and data, excludes the first sizeof(struct cn_msg). Direclty 72 * compariable to maxlen and usable to send the message. 73 */ 74static u16 w1_reply_len(struct w1_cb_block *block) 75{ 76 if (!block->cn) 77 return 0; 78 return (u8 *)block->cn - (u8 *)block->first_cn + block->cn->len; 79} 80 81static void w1_unref_block(struct w1_cb_block *block) 82{ 83 if (atomic_sub_return(1, &block->refcnt) == 0) { 84 u16 len = w1_reply_len(block); 85 if (len) { 86 cn_netlink_send_mult(block->first_cn, len, 87 block->portid, 0, GFP_KERNEL); 88 } 89 kfree(block); 90 } 91} 92 93/** 94 * w1_reply_make_space() - send message if needed to make space 95 * @block: block to make space on 96 * @space: how many bytes requested 97 * 98 * Verify there is enough room left for the caller to add "space" bytes to the 99 * message, if there isn't send the message and reset. 100 */ 101static void w1_reply_make_space(struct w1_cb_block *block, u16 space) 102{ 103 u16 len = w1_reply_len(block); 104 if (len + space >= block->maxlen) { 105 cn_netlink_send_mult(block->first_cn, len, block->portid, 0, GFP_KERNEL); 106 block->first_cn->len = 0; 107 block->cn = NULL; 108 block->msg = NULL; 109 block->cmd = NULL; 110 } 111} 112 113/* Early send when replies aren't bundled. */ 114static void w1_netlink_check_send(struct w1_cb_block *block) 115{ 116 if (!(block->request_cn.flags & W1_CN_BUNDLE) && block->cn) 117 w1_reply_make_space(block, block->maxlen); 118} 119 120/** 121 * w1_netlink_setup_msg() - prepare to write block->msg 122 * @block: block to operate on 123 * @ack: determines if cn can be reused 124 * 125 * block->cn will be setup with the correct ack, advancing if needed 126 * block->cn->len does not include space for block->msg 127 * block->msg advances but remains uninitialized 128 */ 129static void w1_netlink_setup_msg(struct w1_cb_block *block, u32 ack) 130{ 131 if (block->cn && block->cn->ack == ack) { 132 block->msg = (struct w1_netlink_msg *)(block->cn->data + block->cn->len); 133 } else { 134 /* advance or set to data */ 135 if (block->cn) 136 block->cn = (struct cn_msg *)(block->cn->data + 137 block->cn->len); 138 else 139 block->cn = block->first_cn; 140 141 memcpy(block->cn, &block->request_cn, sizeof(*block->cn)); 142 block->cn->len = 0; 143 block->cn->ack = ack; 144 block->msg = (struct w1_netlink_msg *)block->cn->data; 145 } 146} 147 148/* Append cmd to msg, include cmd->data as well. This is because 149 * any following data goes with the command and in the case of a read is 150 * the results. 151 */ 152static void w1_netlink_queue_cmd(struct w1_cb_block *block, 153 struct w1_netlink_cmd *cmd) 154{ 155 u32 space; 156 w1_reply_make_space(block, sizeof(struct cn_msg) + 157 sizeof(struct w1_netlink_msg) + sizeof(*cmd) + cmd->len); 158 159 /* There's a status message sent after each command, so no point 160 * in trying to bundle this cmd after an existing one, because 161 * there won't be one. Allocate and copy over a new cn_msg. 162 */ 163 w1_netlink_setup_msg(block, block->request_cn.seq + 1); 164 memcpy(block->msg, block->cur_msg, sizeof(*block->msg)); 165 block->cn->len += sizeof(*block->msg); 166 block->msg->len = 0; 167 block->cmd = (struct w1_netlink_cmd *)(block->msg->data); 168 169 space = sizeof(*cmd) + cmd->len; 170 if (block->cmd != cmd) 171 memcpy(block->cmd, cmd, space); 172 block->cn->len += space; 173 block->msg->len += space; 174} 175 176/* Append req_msg and req_cmd, no other commands and no data from req_cmd are 177 * copied. 178 */ 179static void w1_netlink_queue_status(struct w1_cb_block *block, 180 struct w1_netlink_msg *req_msg, struct w1_netlink_cmd *req_cmd, 181 int error) 182{ 183 u16 space = sizeof(struct cn_msg) + sizeof(*req_msg) + sizeof(*req_cmd); 184 w1_reply_make_space(block, space); 185 w1_netlink_setup_msg(block, block->request_cn.ack); 186 187 memcpy(block->msg, req_msg, sizeof(*req_msg)); 188 block->cn->len += sizeof(*req_msg); 189 block->msg->len = 0; 190 block->msg->status = (u8)-error; 191 if (req_cmd) { 192 struct w1_netlink_cmd *cmd = (struct w1_netlink_cmd *)block->msg->data; 193 memcpy(cmd, req_cmd, sizeof(*cmd)); 194 block->cn->len += sizeof(*cmd); 195 block->msg->len += sizeof(*cmd); 196 cmd->len = 0; 197 } 198 w1_netlink_check_send(block); 199} 200 201/** 202 * w1_netlink_send_error() - sends the error message now 203 * @cn: original cn_msg 204 * @msg: original w1_netlink_msg 205 * @portid: where to send it 206 * @error: error status 207 * 208 * Use when a block isn't available to queue the message to and cn, msg 209 * might not be contiguous. 210 */ 211static void w1_netlink_send_error(struct cn_msg *cn, struct w1_netlink_msg *msg, 212 int portid, int error) 213{ 214 struct { 215 struct cn_msg cn; 216 struct w1_netlink_msg msg; 217 } packet; 218 memcpy(&packet.cn, cn, sizeof(packet.cn)); 219 memcpy(&packet.msg, msg, sizeof(packet.msg)); 220 packet.cn.len = sizeof(packet.msg); 221 packet.msg.len = 0; 222 packet.msg.status = (u8)-error; 223 cn_netlink_send(&packet.cn, portid, 0, GFP_KERNEL); 224} 225 226/** 227 * w1_netlink_send() - sends w1 netlink notifications 228 * @dev: w1_master the even is associated with or for 229 * @msg: w1_netlink_msg message to be sent 230 * 231 * This are notifications generated from the kernel. 232 */ 233void w1_netlink_send(struct w1_master *dev, struct w1_netlink_msg *msg) 234{ 235 struct { 236 struct cn_msg cn; 237 struct w1_netlink_msg msg; 238 } packet; 239 memset(&packet, 0, sizeof(packet)); 240 241 packet.cn.id.idx = CN_W1_IDX; 242 packet.cn.id.val = CN_W1_VAL; 243 244 packet.cn.seq = dev->seq++; 245 packet.cn.len = sizeof(*msg); 246 247 memcpy(&packet.msg, msg, sizeof(*msg)); 248 packet.msg.len = 0; 249 250 cn_netlink_send(&packet.cn, 0, 0, GFP_KERNEL); 251} 252 253static void w1_send_slave(struct w1_master *dev, u64 rn) 254{ 255 struct w1_cb_block *block = dev->priv; 256 struct w1_netlink_cmd *cache_cmd = block->cmd; 257 u64 *data; 258 259 w1_reply_make_space(block, sizeof(*data)); 260 261 /* Add cmd back if the packet was sent */ 262 if (!block->cmd) { 263 cache_cmd->len = 0; 264 w1_netlink_queue_cmd(block, cache_cmd); 265 } 266 267 data = (u64 *)(block->cmd->data + block->cmd->len); 268 269 *data = rn; 270 block->cn->len += sizeof(*data); 271 block->msg->len += sizeof(*data); 272 block->cmd->len += sizeof(*data); 273} 274 275static void w1_found_send_slave(struct w1_master *dev, u64 rn) 276{ 277 /* update kernel slave list */ 278 w1_slave_found(dev, rn); 279 280 w1_send_slave(dev, rn); 281} 282 283/* Get the current slave list, or search (with or without alarm) */ 284static int w1_get_slaves(struct w1_master *dev, struct w1_netlink_cmd *req_cmd) 285{ 286 struct w1_slave *sl; 287 288 req_cmd->len = 0; 289 w1_netlink_queue_cmd(dev->priv, req_cmd); 290 291 if (req_cmd->cmd == W1_CMD_LIST_SLAVES) { 292 u64 rn; 293 mutex_lock(&dev->list_mutex); 294 list_for_each_entry(sl, &dev->slist, w1_slave_entry) { 295 memcpy(&rn, &sl->reg_num, sizeof(rn)); 296 w1_send_slave(dev, rn); 297 } 298 mutex_unlock(&dev->list_mutex); 299 } else { 300 w1_search_process_cb(dev, req_cmd->cmd == W1_CMD_ALARM_SEARCH ? 301 W1_ALARM_SEARCH : W1_SEARCH, w1_found_send_slave); 302 } 303 304 return 0; 305} 306 307static int w1_process_command_io(struct w1_master *dev, 308 struct w1_netlink_cmd *cmd) 309{ 310 int err = 0; 311 312 switch (cmd->cmd) { 313 case W1_CMD_TOUCH: 314 w1_touch_block(dev, cmd->data, cmd->len); 315 w1_netlink_queue_cmd(dev->priv, cmd); 316 break; 317 case W1_CMD_READ: 318 w1_read_block(dev, cmd->data, cmd->len); 319 w1_netlink_queue_cmd(dev->priv, cmd); 320 break; 321 case W1_CMD_WRITE: 322 w1_write_block(dev, cmd->data, cmd->len); 323 break; 324 default: 325 err = -EINVAL; 326 break; 327 } 328 329 return err; 330} 331 332static int w1_process_command_addremove(struct w1_master *dev, 333 struct w1_netlink_cmd *cmd) 334{ 335 struct w1_slave *sl; 336 int err = 0; 337 struct w1_reg_num *id; 338 339 if (cmd->len != sizeof(*id)) 340 return -EINVAL; 341 342 id = (struct w1_reg_num *)cmd->data; 343 344 sl = w1_slave_search_device(dev, id); 345 switch (cmd->cmd) { 346 case W1_CMD_SLAVE_ADD: 347 if (sl) 348 err = -EINVAL; 349 else 350 err = w1_attach_slave_device(dev, id); 351 break; 352 case W1_CMD_SLAVE_REMOVE: 353 if (sl) 354 w1_slave_detach(sl); 355 else 356 err = -EINVAL; 357 break; 358 default: 359 err = -EINVAL; 360 break; 361 } 362 363 return err; 364} 365 366static int w1_process_command_master(struct w1_master *dev, 367 struct w1_netlink_cmd *req_cmd) 368{ 369 int err = -EINVAL; 370 371 /* drop bus_mutex for search (does it's own locking), and add/remove 372 * which doesn't use the bus 373 */ 374 switch (req_cmd->cmd) { 375 case W1_CMD_SEARCH: 376 case W1_CMD_ALARM_SEARCH: 377 case W1_CMD_LIST_SLAVES: 378 mutex_unlock(&dev->bus_mutex); 379 err = w1_get_slaves(dev, req_cmd); 380 mutex_lock(&dev->bus_mutex); 381 break; 382 case W1_CMD_READ: 383 case W1_CMD_WRITE: 384 case W1_CMD_TOUCH: 385 err = w1_process_command_io(dev, req_cmd); 386 break; 387 case W1_CMD_RESET: 388 err = w1_reset_bus(dev); 389 break; 390 case W1_CMD_SLAVE_ADD: 391 case W1_CMD_SLAVE_REMOVE: 392 mutex_unlock(&dev->bus_mutex); 393 mutex_lock(&dev->mutex); 394 err = w1_process_command_addremove(dev, req_cmd); 395 mutex_unlock(&dev->mutex); 396 mutex_lock(&dev->bus_mutex); 397 break; 398 default: 399 err = -EINVAL; 400 break; 401 } 402 403 return err; 404} 405 406static int w1_process_command_slave(struct w1_slave *sl, 407 struct w1_netlink_cmd *cmd) 408{ 409 dev_dbg(&sl->master->dev, "%s: %02x.%012llx.%02x: cmd=%02x, len=%u.\n", 410 __func__, sl->reg_num.family, (unsigned long long)sl->reg_num.id, 411 sl->reg_num.crc, cmd->cmd, cmd->len); 412 413 return w1_process_command_io(sl->master, cmd); 414} 415 416static int w1_process_command_root(struct cn_msg *req_cn, u32 portid) 417{ 418 struct w1_master *dev; 419 struct cn_msg *cn; 420 struct w1_netlink_msg *msg; 421 u32 *id; 422 423 cn = kmalloc(PAGE_SIZE, GFP_KERNEL); 424 if (!cn) 425 return -ENOMEM; 426 427 cn->id.idx = CN_W1_IDX; 428 cn->id.val = CN_W1_VAL; 429 430 cn->seq = req_cn->seq; 431 cn->ack = req_cn->seq + 1; 432 cn->len = sizeof(struct w1_netlink_msg); 433 msg = (struct w1_netlink_msg *)cn->data; 434 435 msg->type = W1_LIST_MASTERS; 436 msg->status = 0; 437 msg->len = 0; 438 id = (u32 *)msg->data; 439 440 mutex_lock(&w1_mlock); 441 list_for_each_entry(dev, &w1_masters, w1_master_entry) { 442 if (cn->len + sizeof(*id) > PAGE_SIZE - sizeof(struct cn_msg)) { 443 cn_netlink_send(cn, portid, 0, GFP_KERNEL); 444 cn->len = sizeof(struct w1_netlink_msg); 445 msg->len = 0; 446 id = (u32 *)msg->data; 447 } 448 449 *id = dev->id; 450 msg->len += sizeof(*id); 451 cn->len += sizeof(*id); 452 id++; 453 } 454 cn_netlink_send(cn, portid, 0, GFP_KERNEL); 455 mutex_unlock(&w1_mlock); 456 457 kfree(cn); 458 return 0; 459} 460 461static void w1_process_cb(struct w1_master *dev, struct w1_async_cmd *async_cmd) 462{ 463 struct w1_cb_node *node = container_of(async_cmd, struct w1_cb_node, 464 async); 465 u16 mlen = node->msg->len; 466 u16 len; 467 int err = 0; 468 struct w1_slave *sl = node->sl; 469 struct w1_netlink_cmd *cmd = (struct w1_netlink_cmd *)node->msg->data; 470 471 mutex_lock(&dev->bus_mutex); 472 dev->priv = node->block; 473 if (sl && w1_reset_select_slave(sl)) 474 err = -ENODEV; 475 node->block->cur_msg = node->msg; 476 477 while (mlen && !err) { 478 if (cmd->len + sizeof(struct w1_netlink_cmd) > mlen) { 479 err = -E2BIG; 480 break; 481 } 482 483 if (sl) 484 err = w1_process_command_slave(sl, cmd); 485 else 486 err = w1_process_command_master(dev, cmd); 487 w1_netlink_check_send(node->block); 488 489 w1_netlink_queue_status(node->block, node->msg, cmd, err); 490 err = 0; 491 492 len = sizeof(*cmd) + cmd->len; 493 cmd = (struct w1_netlink_cmd *)((u8 *)cmd + len); 494 mlen -= len; 495 } 496 497 if (!cmd || err) 498 w1_netlink_queue_status(node->block, node->msg, cmd, err); 499 500 /* ref taken in w1_search_slave or w1_search_master_id when building 501 * the block 502 */ 503 if (sl) 504 w1_unref_slave(sl); 505 else 506 atomic_dec(&dev->refcnt); 507 dev->priv = NULL; 508 mutex_unlock(&dev->bus_mutex); 509 510 mutex_lock(&dev->list_mutex); 511 list_del(&async_cmd->async_entry); 512 mutex_unlock(&dev->list_mutex); 513 514 w1_unref_block(node->block); 515} 516 517static void w1_list_count_cmds(struct w1_netlink_msg *msg, int *cmd_count, 518 u16 *slave_len) 519{ 520 struct w1_netlink_cmd *cmd = (struct w1_netlink_cmd *)msg->data; 521 u16 mlen = msg->len; 522 u16 len; 523 int slave_list = 0; 524 while (mlen) { 525 if (cmd->len + sizeof(struct w1_netlink_cmd) > mlen) 526 break; 527 528 switch (cmd->cmd) { 529 case W1_CMD_SEARCH: 530 case W1_CMD_ALARM_SEARCH: 531 case W1_CMD_LIST_SLAVES: 532 ++slave_list; 533 } 534 ++*cmd_count; 535 len = sizeof(*cmd) + cmd->len; 536 cmd = (struct w1_netlink_cmd *)((u8 *)cmd + len); 537 mlen -= len; 538 } 539 540 if (slave_list) { 541 struct w1_master *dev = w1_search_master_id(msg->id.mst.id); 542 if (dev) { 543 /* Bytes, and likely an overstimate, and if it isn't 544 * the results can still be split between packets. 545 */ 546 *slave_len += sizeof(struct w1_reg_num) * slave_list * 547 (dev->slave_count + dev->max_slave_count); 548 /* search incremented it */ 549 atomic_dec(&dev->refcnt); 550 } 551 } 552} 553 554static void w1_cn_callback(struct cn_msg *cn, struct netlink_skb_parms *nsp) 555{ 556 struct w1_netlink_msg *msg = (struct w1_netlink_msg *)(cn + 1); 557 struct w1_slave *sl; 558 struct w1_master *dev; 559 u16 msg_len; 560 u16 slave_len = 0; 561 int err = 0; 562 struct w1_cb_block *block = NULL; 563 struct w1_cb_node *node = NULL; 564 int node_count = 0; 565 int cmd_count = 0; 566 567 /* If any unknown flag is set let the application know, that way 568 * applications can detect the absence of features in kernels that 569 * don't know about them. http://lwn.net/Articles/587527/ 570 */ 571 if (cn->flags & ~(W1_CN_BUNDLE)) { 572 w1_netlink_send_error(cn, msg, nsp->portid, -EINVAL); 573 return; 574 } 575 576 /* Count the number of master or slave commands there are to allocate 577 * space for one cb_node each. 578 */ 579 msg_len = cn->len; 580 while (msg_len && !err) { 581 if (msg->len + sizeof(struct w1_netlink_msg) > msg_len) { 582 err = -E2BIG; 583 break; 584 } 585 586 /* count messages for nodes and allocate any additional space 587 * required for slave lists 588 */ 589 if (msg->type == W1_MASTER_CMD || msg->type == W1_SLAVE_CMD) { 590 ++node_count; 591 w1_list_count_cmds(msg, &cmd_count, &slave_len); 592 } 593 594 msg_len -= sizeof(struct w1_netlink_msg) + msg->len; 595 msg = (struct w1_netlink_msg *)(((u8 *)msg) + 596 sizeof(struct w1_netlink_msg) + msg->len); 597 } 598 msg = (struct w1_netlink_msg *)(cn + 1); 599 if (node_count) { 600 int size; 601 int reply_size = sizeof(*cn) + cn->len + slave_len; 602 if (cn->flags & W1_CN_BUNDLE) { 603 /* bundling duplicats some of the messages */ 604 reply_size += 2 * cmd_count * (sizeof(struct cn_msg) + 605 sizeof(struct w1_netlink_msg) + 606 sizeof(struct w1_netlink_cmd)); 607 } 608 reply_size = MIN(CONNECTOR_MAX_MSG_SIZE, reply_size); 609 610 /* allocate space for the block, a copy of the original message, 611 * one node per cmd to point into the original message, 612 * space for replies which is the original message size plus 613 * space for any list slave data and status messages 614 * cn->len doesn't include itself which is part of the block 615 * */ 616 size = /* block + original message */ 617 sizeof(struct w1_cb_block) + sizeof(*cn) + cn->len + 618 /* space for nodes */ 619 node_count * sizeof(struct w1_cb_node) + 620 /* replies */ 621 sizeof(struct cn_msg) + reply_size; 622 block = kzalloc(size, GFP_KERNEL); 623 if (!block) { 624 /* if the system is already out of memory, 625 * (A) will this work, and (B) would it be better 626 * to not try? 627 */ 628 w1_netlink_send_error(cn, msg, nsp->portid, -ENOMEM); 629 return; 630 } 631 atomic_set(&block->refcnt, 1); 632 block->portid = nsp->portid; 633 memcpy(&block->request_cn, cn, sizeof(*cn) + cn->len); 634 node = (struct w1_cb_node *)(block->request_cn.data + cn->len); 635 636 /* Sneeky, when not bundling, reply_size is the allocated space 637 * required for the reply, cn_msg isn't part of maxlen so 638 * it should be reply_size - sizeof(struct cn_msg), however 639 * when checking if there is enough space, w1_reply_make_space 640 * is called with the full message size including cn_msg, 641 * because it isn't known at that time if an additional cn_msg 642 * will need to be allocated. So an extra cn_msg is added 643 * above in "size". 644 */ 645 block->maxlen = reply_size; 646 block->first_cn = (struct cn_msg *)(node + node_count); 647 memset(block->first_cn, 0, sizeof(*block->first_cn)); 648 } 649 650 msg_len = cn->len; 651 while (msg_len && !err) { 652 653 dev = NULL; 654 sl = NULL; 655 656 if (msg->len + sizeof(struct w1_netlink_msg) > msg_len) { 657 err = -E2BIG; 658 break; 659 } 660 661 /* execute on this thread, no need to process later */ 662 if (msg->type == W1_LIST_MASTERS) { 663 err = w1_process_command_root(cn, nsp->portid); 664 goto out_cont; 665 } 666 667 /* All following message types require additional data, 668 * check here before references are taken. 669 */ 670 if (!msg->len) { 671 err = -EPROTO; 672 goto out_cont; 673 } 674 675 /* both search calls take references */ 676 if (msg->type == W1_MASTER_CMD) { 677 dev = w1_search_master_id(msg->id.mst.id); 678 } else if (msg->type == W1_SLAVE_CMD) { 679 sl = w1_search_slave((struct w1_reg_num *)msg->id.id); 680 if (sl) 681 dev = sl->master; 682 } else { 683 pr_notice("%s: cn: %x.%x, wrong type: %u, len: %u.\n", 684 __func__, cn->id.idx, cn->id.val, 685 msg->type, msg->len); 686 err = -EPROTO; 687 goto out_cont; 688 } 689 690 if (!dev) { 691 err = -ENODEV; 692 goto out_cont; 693 } 694 695 err = 0; 696 697 atomic_inc(&block->refcnt); 698 node->async.cb = w1_process_cb; 699 node->block = block; 700 node->msg = (struct w1_netlink_msg *)((u8 *)&block->request_cn + 701 (size_t)((u8 *)msg - (u8 *)cn)); 702 node->sl = sl; 703 node->dev = dev; 704 705 mutex_lock(&dev->list_mutex); 706 list_add_tail(&node->async.async_entry, &dev->async_list); 707 wake_up_process(dev->thread); 708 mutex_unlock(&dev->list_mutex); 709 ++node; 710 711out_cont: 712 /* Can't queue because that modifies block and another 713 * thread could be processing the messages by now and 714 * there isn't a lock, send directly. 715 */ 716 if (err) 717 w1_netlink_send_error(cn, msg, nsp->portid, err); 718 msg_len -= sizeof(struct w1_netlink_msg) + msg->len; 719 msg = (struct w1_netlink_msg *)(((u8 *)msg) + 720 sizeof(struct w1_netlink_msg) + msg->len); 721 722 /* 723 * Let's allow requests for nonexisting devices. 724 */ 725 if (err == -ENODEV) 726 err = 0; 727 } 728 if (block) 729 w1_unref_block(block); 730} 731 732int w1_init_netlink(void) 733{ 734 struct cb_id w1_id = {.idx = CN_W1_IDX, .val = CN_W1_VAL}; 735 736 return cn_add_callback(&w1_id, "w1", &w1_cn_callback); 737} 738 739void w1_fini_netlink(void) 740{ 741 struct cb_id w1_id = {.idx = CN_W1_IDX, .val = CN_W1_VAL}; 742 743 cn_del_callback(&w1_id); 744} 745#else 746void w1_netlink_send(struct w1_master *dev, struct w1_netlink_msg *cn) 747{ 748} 749 750int w1_init_netlink(void) 751{ 752 return 0; 753} 754 755void w1_fini_netlink(void) 756{ 757} 758#endif 759