1 /* 2 * lib/cache.c Caching Module 3 * 4 * This library is free software; you can redistribute it and/or 5 * modify it under the terms of the GNU Lesser General Public 6 * License as published by the Free Software Foundation version 2.1 7 * of the License. 8 * 9 * Copyright (c) 2003-2008 Thomas Graf <tgraf (at) suug.ch> 10 */ 11 12 /** 13 * @ingroup cache_mngt 14 * @defgroup cache Cache 15 * 16 * @code 17 * Cache Management | | Type Specific Cache Operations 18 * 19 * | | +----------------+ +------------+ 20 * | request update | | msg_parser | 21 * | | +----------------+ +------------+ 22 * +- - - - -^- - - - - - - -^- -|- - - - 23 * nl_cache_update: | | | | 24 * 1) --------- co_request_update ------+ | | 25 * | | | 26 * 2) destroy old cache +----------- pp_cb ---------|---+ 27 * | | | 28 * 3) ---------- nl_recvmsgs ----------+ +- cb_valid -+ 29 * +--------------+ | | | | 30 * | nl_cache_add |<-----+ + - - -v- -|- - - - - - - - - - - 31 * +--------------+ | | +-------------+ 32 * | nl_recvmsgs | 33 * | | +-----|-^-----+ 34 * +---v-|---+ 35 * | | | nl_recv | 36 * +---------+ 37 * | | Core Netlink 38 * @endcode 39 * 40 * @{ 41 */ 42 43 #include <netlink-local.h> 44 #include <netlink/netlink.h> 45 #include <netlink/cache.h> 46 #include <netlink/object.h> 47 #include <netlink/utils.h> 48 49 /** 50 * @name Access Functions 51 * @{ 52 */ 53 54 /** 55 * Return the number of items in the cache 56 * @arg cache cache handle 57 */ 58 int nl_cache_nitems(struct nl_cache *cache) 59 { 60 return cache->c_nitems; 61 } 62 63 /** 64 * Return the number of items matching a filter in the cache 65 * @arg cache Cache object. 66 * @arg filter Filter object. 67 */ 68 int nl_cache_nitems_filter(struct nl_cache *cache, struct nl_object *filter) 69 { 70 struct nl_object_ops *ops; 71 struct nl_object *obj; 72 int nitems = 0; 73 74 if (cache->c_ops == NULL) 75 BUG(); 76 77 ops = cache->c_ops->co_obj_ops; 78 79 nl_list_for_each_entry(obj, &cache->c_items, ce_list) { 80 if (filter && !nl_object_match_filter(obj, filter)) 81 continue; 82 83 nitems++; 84 } 85 86 return nitems; 87 } 88 89 /** 90 * Returns \b true if the cache is empty. 91 * @arg cache Cache to check 92 * @return \a true if the cache is empty, otherwise \b false is returned. 93 */ 94 int nl_cache_is_empty(struct nl_cache *cache) 95 { 96 return nl_list_empty(&cache->c_items); 97 } 98 99 /** 100 * Return the operations set of the cache 101 * @arg cache cache handle 102 */ 103 struct nl_cache_ops *nl_cache_get_ops(struct nl_cache *cache) 104 { 105 return cache->c_ops; 106 } 107 108 /** 109 * Return the first element in the cache 110 * @arg cache cache handle 111 */ 112 struct nl_object *nl_cache_get_first(struct nl_cache *cache) 113 { 114 if (nl_list_empty(&cache->c_items)) 115 return NULL; 116 117 return nl_list_entry(cache->c_items.next, 118 struct nl_object, ce_list); 119 } 120 121 /** 122 * Return the last element in the cache 123 * @arg cache cache handle 124 */ 125 struct nl_object *nl_cache_get_last(struct nl_cache *cache) 126 { 127 if (nl_list_empty(&cache->c_items)) 128 return NULL; 129 130 return nl_list_entry(cache->c_items.prev, 131 struct nl_object, ce_list); 132 } 133 134 /** 135 * Return the next element in the cache 136 * @arg obj current object 137 */ 138 struct nl_object *nl_cache_get_next(struct nl_object *obj) 139 { 140 if (nl_list_at_tail(obj, &obj->ce_cache->c_items, ce_list)) 141 return NULL; 142 else 143 return nl_list_entry(obj->ce_list.next, 144 struct nl_object, ce_list); 145 } 146 147 /** 148 * Return the previous element in the cache 149 * @arg obj current object 150 */ 151 struct nl_object *nl_cache_get_prev(struct nl_object *obj) 152 { 153 if (nl_list_at_head(obj, &obj->ce_cache->c_items, ce_list)) 154 return NULL; 155 else 156 return nl_list_entry(obj->ce_list.prev, 157 struct nl_object, ce_list); 158 } 159 160 /** @} */ 161 162 /** 163 * @name Cache Creation/Deletion 164 * @{ 165 */ 166 167 /** 168 * Allocate an empty cache 169 * @arg ops cache operations to base the cache on 170 * 171 * @return A newly allocated and initialized cache. 172 */ 173 struct nl_cache *nl_cache_alloc(struct nl_cache_ops *ops) 174 { 175 struct nl_cache *cache; 176 177 cache = calloc(1, sizeof(*cache)); 178 if (!cache) 179 return NULL; 180 181 nl_init_list_head(&cache->c_items); 182 cache->c_ops = ops; 183 184 NL_DBG(2, "Allocated cache %p <%s>.\n", cache, nl_cache_name(cache)); 185 186 return cache; 187 } 188 189 int nl_cache_alloc_and_fill(struct nl_cache_ops *ops, struct nl_sock *sock, 190 struct nl_cache **result) 191 { 192 struct nl_cache *cache; 193 int err; 194 195 if (!(cache = nl_cache_alloc(ops))) 196 return -NLE_NOMEM; 197 198 if (sock && (err = nl_cache_refill(sock, cache)) < 0) { 199 nl_cache_free(cache); 200 return err; 201 } 202 203 *result = cache; 204 return 0; 205 } 206 207 /** 208 * Allocate an empty cache based on type name 209 * @arg kind Name of cache type 210 * @return A newly allocated and initialized cache. 211 */ 212 int nl_cache_alloc_name(const char *kind, struct nl_cache **result) 213 { 214 struct nl_cache_ops *ops; 215 struct nl_cache *cache; 216 217 ops = nl_cache_ops_lookup(kind); 218 if (!ops) 219 return -NLE_NOCACHE; 220 221 if (!(cache = nl_cache_alloc(ops))) 222 return -NLE_NOMEM; 223 224 *result = cache; 225 return 0; 226 } 227 228 /** 229 * Allocate a new cache containing a subset of a cache 230 * @arg orig Original cache to be based on 231 * @arg filter Filter defining the subset to be filled into new cache 232 * @return A newly allocated cache or NULL. 233 */ 234 struct nl_cache *nl_cache_subset(struct nl_cache *orig, 235 struct nl_object *filter) 236 { 237 struct nl_cache *cache; 238 struct nl_object_ops *ops; 239 struct nl_object *obj; 240 241 if (!filter) 242 BUG(); 243 244 cache = nl_cache_alloc(orig->c_ops); 245 if (!cache) 246 return NULL; 247 248 ops = orig->c_ops->co_obj_ops; 249 250 nl_list_for_each_entry(obj, &orig->c_items, ce_list) { 251 if (!nl_object_match_filter(obj, filter)) 252 continue; 253 254 nl_cache_add(cache, obj); 255 } 256 257 return cache; 258 } 259 260 /** 261 * Clear a cache. 262 * @arg cache cache to clear 263 * 264 * Removes all elements of a cache. 265 */ 266 void nl_cache_clear(struct nl_cache *cache) 267 { 268 struct nl_object *obj, *tmp; 269 270 NL_DBG(1, "Clearing cache %p <%s>...\n", cache, nl_cache_name(cache)); 271 272 nl_list_for_each_entry_safe(obj, tmp, &cache->c_items, ce_list) 273 nl_cache_remove(obj); 274 } 275 276 /** 277 * Free a cache. 278 * @arg cache Cache to free. 279 * 280 * Removes all elements of a cache and frees all memory. 281 * 282 * @note Use this function if you are working with allocated caches. 283 */ 284 void nl_cache_free(struct nl_cache *cache) 285 { 286 if (!cache) 287 return; 288 289 nl_cache_clear(cache); 290 NL_DBG(1, "Freeing cache %p <%s>...\n", cache, nl_cache_name(cache)); 291 free(cache); 292 } 293 294 /** @} */ 295 296 /** 297 * @name Cache Modifications 298 * @{ 299 */ 300 301 static int __cache_add(struct nl_cache *cache, struct nl_object *obj) 302 { 303 obj->ce_cache = cache; 304 305 nl_list_add_tail(&obj->ce_list, &cache->c_items); 306 cache->c_nitems++; 307 308 NL_DBG(1, "Added %p to cache %p <%s>.\n", 309 obj, cache, nl_cache_name(cache)); 310 311 return 0; 312 } 313 314 /** 315 * Add object to a cache. 316 * @arg cache Cache to add object to 317 * @arg obj Object to be added to the cache 318 * 319 * Adds the given object to the specified cache. The object is cloned 320 * if it has been added to another cache already. 321 * 322 * @return 0 or a negative error code. 323 */ 324 int nl_cache_add(struct nl_cache *cache, struct nl_object *obj) 325 { 326 struct nl_object *new; 327 328 if (cache->c_ops->co_obj_ops != obj->ce_ops) 329 return -NLE_OBJ_MISMATCH; 330 331 if (!nl_list_empty(&obj->ce_list)) { 332 new = nl_object_clone(obj); 333 if (!new) 334 return -NLE_NOMEM; 335 } else { 336 nl_object_get(obj); 337 new = obj; 338 } 339 340 return __cache_add(cache, new); 341 } 342 343 /** 344 * Move object from one cache to another 345 * @arg cache Cache to move object to. 346 * @arg obj Object subject to be moved 347 * 348 * Removes the given object from its associated cache if needed 349 * and adds it to the new cache. 350 * 351 * @return 0 on success or a negative error code. 352 */ 353 int nl_cache_move(struct nl_cache *cache, struct nl_object *obj) 354 { 355 if (cache->c_ops->co_obj_ops != obj->ce_ops) 356 return -NLE_OBJ_MISMATCH; 357 358 NL_DBG(3, "Moving object %p to cache %p\n", obj, cache); 359 360 /* Acquire reference, if already in a cache this will be 361 * reverted during removal */ 362 nl_object_get(obj); 363 364 if (!nl_list_empty(&obj->ce_list)) 365 nl_cache_remove(obj); 366 367 return __cache_add(cache, obj); 368 } 369 370 /** 371 * Removes an object from a cache. 372 * @arg obj Object to remove from its cache 373 * 374 * Removes the object \c obj from the cache it is assigned to, since 375 * an object can only be assigned to one cache at a time, the cache 376 * must ne be passed along with it. 377 */ 378 void nl_cache_remove(struct nl_object *obj) 379 { 380 struct nl_cache *cache = obj->ce_cache; 381 382 if (cache == NULL) 383 return; 384 385 nl_list_del(&obj->ce_list); 386 obj->ce_cache = NULL; 387 nl_object_put(obj); 388 cache->c_nitems--; 389 390 NL_DBG(1, "Deleted %p from cache %p <%s>.\n", 391 obj, cache, nl_cache_name(cache)); 392 } 393 394 /** 395 * Search for an object in a cache 396 * @arg cache Cache to search in. 397 * @arg needle Object to look for. 398 * 399 * Iterates over the cache and looks for an object with identical 400 * identifiers as the needle. 401 * 402 * @return Reference to object or NULL if not found. 403 * @note The returned object must be returned via nl_object_put(). 404 */ 405 struct nl_object *nl_cache_search(struct nl_cache *cache, 406 struct nl_object *needle) 407 { 408 struct nl_object *obj; 409 410 nl_list_for_each_entry(obj, &cache->c_items, ce_list) { 411 if (nl_object_identical(obj, needle)) { 412 nl_object_get(obj); 413 return obj; 414 } 415 } 416 417 return NULL; 418 } 419 420 421 /** @} */ 422 423 /** 424 * @name Synchronization 425 * @{ 426 */ 427 428 /** 429 * Request a full dump from the kernel to fill a cache 430 * @arg sk Netlink socket. 431 * @arg cache Cache subjected to be filled. 432 * 433 * Send a dumping request to the kernel causing it to dump all objects 434 * related to the specified cache to the netlink socket. 435 * 436 * Use nl_cache_pickup() to read the objects from the socket and fill them 437 * into a cache. 438 */ 439 int nl_cache_request_full_dump(struct nl_sock *sk, struct nl_cache *cache) 440 { 441 NL_DBG(2, "Requesting dump from kernel for cache %p <%s>...\n", 442 cache, nl_cache_name(cache)); 443 444 if (cache->c_ops->co_request_update == NULL) 445 return -NLE_OPNOTSUPP; 446 447 return cache->c_ops->co_request_update(cache, sk); 448 } 449 450 /** @cond SKIP */ 451 struct update_xdata { 452 struct nl_cache_ops *ops; 453 struct nl_parser_param *params; 454 }; 455 456 static int update_msg_parser(struct nl_msg *msg, void *arg) 457 { 458 struct update_xdata *x = arg; 459 460 return nl_cache_parse(x->ops, &msg->nm_src, msg->nm_nlh, x->params); 461 } 462 /** @endcond */ 463 464 int __cache_pickup(struct nl_sock *sk, struct nl_cache *cache, 465 struct nl_parser_param *param) 466 { 467 int err; 468 struct nl_cb *cb; 469 struct update_xdata x = { 470 .ops = cache->c_ops, 471 .params = param, 472 }; 473 474 NL_DBG(1, "Picking up answer for cache %p <%s>...\n", 475 cache, nl_cache_name(cache)); 476 477 cb = nl_cb_clone(sk->s_cb); 478 if (cb == NULL) 479 return -NLE_NOMEM; 480 481 nl_cb_set(cb, NL_CB_VALID, NL_CB_CUSTOM, update_msg_parser, &x); 482 483 err = nl_recvmsgs(sk, cb); 484 if (err < 0) 485 NL_DBG(2, "While picking up for %p <%s>, recvmsgs() returned " \ 486 "%d: %s", cache, nl_cache_name(cache), 487 err, nl_geterror(err)); 488 489 nl_cb_put(cb); 490 491 return err; 492 } 493 494 static int pickup_cb(struct nl_object *c, struct nl_parser_param *p) 495 { 496 return nl_cache_add((struct nl_cache *) p->pp_arg, c); 497 } 498 499 /** 500 * Pickup a netlink dump response and put it into a cache. 501 * @arg sk Netlink socket. 502 * @arg cache Cache to put items into. 503 * 504 * Waits for netlink messages to arrive, parses them and puts them into 505 * the specified cache. 506 * 507 * @return 0 on success or a negative error code. 508 */ 509 int nl_cache_pickup(struct nl_sock *sk, struct nl_cache *cache) 510 { 511 struct nl_parser_param p = { 512 .pp_cb = pickup_cb, 513 .pp_arg = cache, 514 }; 515 516 return __cache_pickup(sk, cache, &p); 517 } 518 519 static int cache_include(struct nl_cache *cache, struct nl_object *obj, 520 struct nl_msgtype *type, change_func_t cb, void *data) 521 { 522 struct nl_object *old; 523 524 switch (type->mt_act) { 525 case NL_ACT_NEW: 526 case NL_ACT_DEL: 527 old = nl_cache_search(cache, obj); 528 if (old) { 529 nl_cache_remove(old); 530 if (type->mt_act == NL_ACT_DEL) { 531 if (cb) 532 cb(cache, old, NL_ACT_DEL, data); 533 nl_object_put(old); 534 } 535 } 536 537 if (type->mt_act == NL_ACT_NEW) { 538 nl_cache_move(cache, obj); 539 if (old == NULL && cb) 540 cb(cache, obj, NL_ACT_NEW, data); 541 else if (old) { 542 if (nl_object_diff(old, obj) && cb) 543 cb(cache, obj, NL_ACT_CHANGE, data); 544 545 nl_object_put(old); 546 } 547 } 548 break; 549 default: 550 NL_DBG(2, "Unknown action associated to object %p\n", obj); 551 return 0; 552 } 553 554 return 0; 555 } 556 557 int nl_cache_include(struct nl_cache *cache, struct nl_object *obj, 558 change_func_t change_cb, void *data) 559 { 560 struct nl_cache_ops *ops = cache->c_ops; 561 int i; 562 563 if (ops->co_obj_ops != obj->ce_ops) 564 return -NLE_OBJ_MISMATCH; 565 566 for (i = 0; ops->co_msgtypes[i].mt_id >= 0; i++) 567 if (ops->co_msgtypes[i].mt_id == obj->ce_msgtype) 568 return cache_include(cache, obj, &ops->co_msgtypes[i], 569 change_cb, data); 570 571 return -NLE_MSGTYPE_NOSUPPORT; 572 } 573 574 static int resync_cb(struct nl_object *c, struct nl_parser_param *p) 575 { 576 struct nl_cache_assoc *ca = p->pp_arg; 577 578 return nl_cache_include(ca->ca_cache, c, ca->ca_change, ca->ca_change_data); 579 } 580 581 int nl_cache_resync(struct nl_sock *sk, struct nl_cache *cache, 582 change_func_t change_cb, void *data) 583 { 584 struct nl_object *obj, *next; 585 struct nl_cache_assoc ca = { 586 .ca_cache = cache, 587 .ca_change = change_cb, 588 .ca_change_data = data, 589 }; 590 struct nl_parser_param p = { 591 .pp_cb = resync_cb, 592 .pp_arg = &ca, 593 }; 594 int err; 595 596 NL_DBG(1, "Resyncing cache %p <%s>...\n", cache, nl_cache_name(cache)); 597 598 /* Mark all objects so we can see if some of them are obsolete */ 599 nl_cache_mark_all(cache); 600 601 err = nl_cache_request_full_dump(sk, cache); 602 if (err < 0) 603 goto errout; 604 605 err = __cache_pickup(sk, cache, &p); 606 if (err < 0) 607 goto errout; 608 609 nl_list_for_each_entry_safe(obj, next, &cache->c_items, ce_list) { 610 if (nl_object_is_marked(obj)) { 611 nl_object_get(obj); 612 nl_cache_remove(obj); 613 if (change_cb) 614 change_cb(cache, obj, NL_ACT_DEL, data); 615 nl_object_put(obj); 616 } 617 } 618 619 NL_DBG(1, "Finished resyncing %p <%s>\n", cache, nl_cache_name(cache)); 620 621 err = 0; 622 errout: 623 return err; 624 } 625 626 /** @} */ 627 628 /** 629 * @name Parsing 630 * @{ 631 */ 632 633 /** @cond SKIP */ 634 int nl_cache_parse(struct nl_cache_ops *ops, struct sockaddr_nl *who, 635 struct nlmsghdr *nlh, struct nl_parser_param *params) 636 { 637 int i, err; 638 639 if (!nlmsg_valid_hdr(nlh, ops->co_hdrsize)) 640 return -NLE_MSG_TOOSHORT; 641 642 for (i = 0; ops->co_msgtypes[i].mt_id >= 0; i++) { 643 if (ops->co_msgtypes[i].mt_id == nlh->nlmsg_type) { 644 err = ops->co_msg_parser(ops, who, nlh, params); 645 if (err != -NLE_OPNOTSUPP) 646 goto errout; 647 } 648 } 649 650 651 err = -NLE_MSGTYPE_NOSUPPORT; 652 errout: 653 return err; 654 } 655 /** @endcond */ 656 657 /** 658 * Parse a netlink message and add it to the cache. 659 * @arg cache cache to add element to 660 * @arg msg netlink message 661 * 662 * Parses a netlink message by calling the cache specific message parser 663 * and adds the new element to the cache. 664 * 665 * @return 0 or a negative error code. 666 */ 667 int nl_cache_parse_and_add(struct nl_cache *cache, struct nl_msg *msg) 668 { 669 struct nl_parser_param p = { 670 .pp_cb = pickup_cb, 671 .pp_arg = cache, 672 }; 673 674 return nl_cache_parse(cache->c_ops, NULL, nlmsg_hdr(msg), &p); 675 } 676 677 /** 678 * (Re)fill a cache with the contents in the kernel. 679 * @arg sk Netlink socket. 680 * @arg cache cache to update 681 * 682 * Clears the specified cache and fills it with the current state in 683 * the kernel. 684 * 685 * @return 0 or a negative error code. 686 */ 687 int nl_cache_refill(struct nl_sock *sk, struct nl_cache *cache) 688 { 689 int err; 690 691 err = nl_cache_request_full_dump(sk, cache); 692 if (err < 0) 693 return err; 694 695 NL_DBG(2, "Upading cache %p <%s>, request sent, waiting for dump...\n", 696 cache, nl_cache_name(cache)); 697 nl_cache_clear(cache); 698 699 return nl_cache_pickup(sk, cache); 700 } 701 702 /** @} */ 703 704 /** 705 * @name Utillities 706 * @{ 707 */ 708 709 /** 710 * Mark all objects in a cache 711 * @arg cache Cache to mark all objects in 712 */ 713 void nl_cache_mark_all(struct nl_cache *cache) 714 { 715 struct nl_object *obj; 716 717 NL_DBG(2, "Marking all objects in cache %p <%s>...\n", 718 cache, nl_cache_name(cache)); 719 720 nl_list_for_each_entry(obj, &cache->c_items, ce_list) 721 nl_object_mark(obj); 722 } 723 724 /** @} */ 725 726 /** 727 * @name Dumping 728 * @{ 729 */ 730 731 /** 732 * Dump all elements of a cache. 733 * @arg cache cache to dump 734 * @arg params dumping parameters 735 * 736 * Dumps all elements of the \a cache to the file descriptor \a fd. 737 */ 738 void nl_cache_dump(struct nl_cache *cache, struct nl_dump_params *params) 739 { 740 nl_cache_dump_filter(cache, params, NULL); 741 } 742 743 /** 744 * Dump all elements of a cache (filtered). 745 * @arg cache cache to dump 746 * @arg params dumping parameters (optional) 747 * @arg filter filter object 748 * 749 * Dumps all elements of the \a cache to the file descriptor \a fd 750 * given they match the given filter \a filter. 751 */ 752 void nl_cache_dump_filter(struct nl_cache *cache, 753 struct nl_dump_params *params, 754 struct nl_object *filter) 755 { 756 int type = params ? params->dp_type : NL_DUMP_DETAILS; 757 struct nl_object_ops *ops; 758 struct nl_object *obj; 759 760 NL_DBG(2, "Dumping cache %p <%s> filter %p\n", 761 cache, nl_cache_name(cache), filter); 762 763 if (type > NL_DUMP_MAX || type < 0) 764 BUG(); 765 766 if (cache->c_ops == NULL) 767 BUG(); 768 769 ops = cache->c_ops->co_obj_ops; 770 if (!ops->oo_dump[type]) 771 return; 772 773 nl_list_for_each_entry(obj, &cache->c_items, ce_list) { 774 if (filter && !nl_object_match_filter(obj, filter)) 775 continue; 776 777 NL_DBG(4, "Dumping object %p...\n", obj); 778 dump_from_ops(obj, params); 779 } 780 } 781 782 /** @} */ 783 784 /** 785 * @name Iterators 786 * @{ 787 */ 788 789 /** 790 * Call a callback on each element of the cache. 791 * @arg cache cache to iterate on 792 * @arg cb callback function 793 * @arg arg argument passed to callback function 794 * 795 * Calls a callback function \a cb on each element of the \a cache. 796 * The argument \a arg is passed on the callback function. 797 */ 798 void nl_cache_foreach(struct nl_cache *cache, 799 void (*cb)(struct nl_object *, void *), void *arg) 800 { 801 nl_cache_foreach_filter(cache, NULL, cb, arg); 802 } 803 804 /** 805 * Call a callback on each element of the cache (filtered). 806 * @arg cache cache to iterate on 807 * @arg filter filter object 808 * @arg cb callback function 809 * @arg arg argument passed to callback function 810 * 811 * Calls a callback function \a cb on each element of the \a cache 812 * that matches the \a filter. The argument \a arg is passed on 813 * to the callback function. 814 */ 815 void nl_cache_foreach_filter(struct nl_cache *cache, struct nl_object *filter, 816 void (*cb)(struct nl_object *, void *), void *arg) 817 { 818 struct nl_object *obj, *tmp; 819 struct nl_object_ops *ops; 820 821 if (cache->c_ops == NULL) 822 BUG(); 823 824 ops = cache->c_ops->co_obj_ops; 825 826 nl_list_for_each_entry_safe(obj, tmp, &cache->c_items, ce_list) { 827 if (filter && !nl_object_match_filter(obj, filter)) 828 continue; 829 830 cb(obj, arg); 831 } 832 } 833 834 /** @} */ 835 836 /** @} */ 837