Merge tag 'dlm-6.12' of git://git.kernel.org/pub/scm/linux/kernel/git/teigland/linux-dlm

+1 -1

fs/dlm/config.c

··· 928 928 929 929 int dlm_our_nodeid(void) 930 930 { 931 - return local_comm ? local_comm->nodeid : 0; 931 + return local_comm->nodeid; 932 932 } 933 933 934 934 /* num 0 is first addr, num 1 is second addr */

+5

fs/dlm/dlm_internal.h

··· 295 295 void *lkb_astparam; /* caller's ast arg */ 296 296 struct dlm_user_args *lkb_ua; 297 297 }; 298 + struct rcu_head rcu; 298 299 }; 299 300 300 301 /* ··· 661 660 const struct dlm_lockspace_ops *ls_ops; 662 661 void *ls_ops_arg; 663 662 663 + struct work_struct ls_free_work; 664 + 664 665 int ls_namelen; 665 666 char ls_name[DLM_LOCKSPACE_LEN + 1]; 666 667 }; ··· 805 802 dlm_set_flags_val(&lkb->lkb_sbflags, val, __DLM_SBF_MIN_BIT, 806 803 __DLM_SBF_MAX_BIT); 807 804 } 805 + 806 + extern struct workqueue_struct *dlm_wq; 808 807 809 808 int dlm_plock_init(void); 810 809 void dlm_plock_exit(void);

+73 -61

fs/dlm/lock.c

··· 600 600 { 601 601 struct dlm_rsb *r; 602 602 603 - r = dlm_allocate_rsb(ls); 603 + r = dlm_allocate_rsb(); 604 604 if (!r) 605 605 return -ENOMEM; 606 606 ··· 733 733 } 734 734 735 735 retry: 736 + error = dlm_search_rsb_tree(&ls->ls_rsbtbl, name, len, &r); 737 + if (error) 738 + goto do_new; 736 739 737 740 /* check if the rsb is active under read lock - likely path */ 738 741 read_lock_bh(&ls->ls_rsbtbl_lock); 739 - error = dlm_search_rsb_tree(&ls->ls_rsbtbl, name, len, &r); 740 - if (error) { 742 + if (!rsb_flag(r, RSB_HASHED)) { 741 743 read_unlock_bh(&ls->ls_rsbtbl_lock); 742 744 goto do_new; 743 745 } ··· 920 918 int error; 921 919 922 920 retry: 921 + error = dlm_search_rsb_tree(&ls->ls_rsbtbl, name, len, &r); 922 + if (error) 923 + goto do_new; 923 924 924 925 /* check if the rsb is in active state under read lock - likely path */ 925 926 read_lock_bh(&ls->ls_rsbtbl_lock); 926 - error = dlm_search_rsb_tree(&ls->ls_rsbtbl, name, len, &r); 927 - if (error) { 927 + if (!rsb_flag(r, RSB_HASHED)) { 928 928 read_unlock_bh(&ls->ls_rsbtbl_lock); 929 929 goto do_new; 930 930 } ··· 1155 1151 r->res_dir_nodeid = our_nodeid; 1156 1152 } 1157 1153 1158 - if (fix_master && dlm_is_removed(ls, r->res_master_nodeid)) { 1154 + if (fix_master && r->res_master_nodeid && dlm_is_removed(ls, r->res_master_nodeid)) { 1159 1155 /* Recovery uses this function to set a new master when 1160 1156 * the previous master failed. Setting NEW_MASTER will 1161 1157 * force dlm_recover_masters to call recover_master on this ··· 1280 1276 } 1281 1277 1282 1278 retry: 1279 + error = dlm_search_rsb_tree(&ls->ls_rsbtbl, name, len, &r); 1280 + if (error) 1281 + goto not_found; 1283 1282 1284 1283 /* check if the rsb is active under read lock - likely path */ 1285 1284 read_lock_bh(&ls->ls_rsbtbl_lock); 1286 - error = dlm_search_rsb_tree(&ls->ls_rsbtbl, name, len, &r); 1287 - if (!error) { 1288 - if (rsb_flag(r, RSB_INACTIVE)) { 1289 - read_unlock_bh(&ls->ls_rsbtbl_lock); 1290 - goto do_inactive; 1291 - } 1292 - 1293 - /* because the rsb is active, we need to lock_rsb before 1294 - * checking/changing re_master_nodeid 1295 - */ 1296 - 1297 - hold_rsb(r); 1298 - read_unlock_bh(&ls->ls_rsbtbl_lock); 1299 - lock_rsb(r); 1300 - 1301 - __dlm_master_lookup(ls, r, our_nodeid, from_nodeid, false, 1302 - flags, r_nodeid, result); 1303 - 1304 - /* the rsb was active */ 1305 - unlock_rsb(r); 1306 - put_rsb(r); 1307 - 1308 - return 0; 1309 - } else { 1285 + if (!rsb_flag(r, RSB_HASHED)) { 1310 1286 read_unlock_bh(&ls->ls_rsbtbl_lock); 1311 1287 goto not_found; 1312 1288 } 1313 1289 1290 + if (rsb_flag(r, RSB_INACTIVE)) { 1291 + read_unlock_bh(&ls->ls_rsbtbl_lock); 1292 + goto do_inactive; 1293 + } 1294 + 1295 + /* because the rsb is active, we need to lock_rsb before 1296 + * checking/changing re_master_nodeid 1297 + */ 1298 + 1299 + hold_rsb(r); 1300 + read_unlock_bh(&ls->ls_rsbtbl_lock); 1301 + lock_rsb(r); 1302 + 1303 + __dlm_master_lookup(ls, r, our_nodeid, from_nodeid, false, 1304 + flags, r_nodeid, result); 1305 + 1306 + /* the rsb was active */ 1307 + unlock_rsb(r); 1308 + put_rsb(r); 1309 + 1310 + return 0; 1311 + 1314 1312 do_inactive: 1315 - /* unlikely path - relookup under write */ 1313 + /* unlikely path - check if still part of ls_rsbtbl */ 1316 1314 write_lock_bh(&ls->ls_rsbtbl_lock); 1317 1315 1318 - error = dlm_search_rsb_tree(&ls->ls_rsbtbl, name, len, &r); 1319 - if (!error) { 1316 + /* see comment in find_rsb_dir */ 1317 + if (rsb_flag(r, RSB_HASHED)) { 1320 1318 if (!rsb_flag(r, RSB_INACTIVE)) { 1321 1319 write_unlock_bh(&ls->ls_rsbtbl_lock); 1322 1320 /* something as changed, very unlikely but ··· 1409 1403 struct dlm_rsb *r = NULL; 1410 1404 int error; 1411 1405 1412 - read_lock_bh(&ls->ls_rsbtbl_lock); 1406 + rcu_read_lock(); 1413 1407 error = dlm_search_rsb_tree(&ls->ls_rsbtbl, name, len, &r); 1414 1408 if (!error) 1415 1409 goto out; 1416 1410 1417 1411 dlm_dump_rsb(r); 1418 1412 out: 1419 - read_unlock_bh(&ls->ls_rsbtbl_lock); 1413 + rcu_read_unlock(); 1420 1414 } 1421 1415 1422 1416 static void deactivate_rsb(struct kref *kref) ··· 1446 1440 dlm_free_lvb(r->res_lvbptr); 1447 1441 r->res_lvbptr = NULL; 1448 1442 } 1449 - } 1450 - 1451 - /* See comment for unhold_lkb */ 1452 - 1453 - static void unhold_rsb(struct dlm_rsb *r) 1454 - { 1455 - int rv; 1456 - 1457 - /* inactive rsbs are not ref counted */ 1458 - WARN_ON(rsb_flag(r, RSB_INACTIVE)); 1459 - rv = kref_put(&r->res_ref, deactivate_rsb); 1460 - DLM_ASSERT(!rv, dlm_dump_rsb(r);); 1461 1443 } 1462 1444 1463 1445 void free_inactive_rsb(struct dlm_rsb *r) ··· 1491 1497 limit.max = end; 1492 1498 limit.min = start; 1493 1499 1494 - lkb = dlm_allocate_lkb(ls); 1500 + lkb = dlm_allocate_lkb(); 1495 1501 if (!lkb) 1496 1502 return -ENOMEM; 1497 1503 ··· 1527 1533 { 1528 1534 struct dlm_lkb *lkb; 1529 1535 1530 - read_lock_bh(&ls->ls_lkbxa_lock); 1536 + rcu_read_lock(); 1531 1537 lkb = xa_load(&ls->ls_lkbxa, lkid); 1532 - if (lkb) 1533 - kref_get(&lkb->lkb_ref); 1534 - read_unlock_bh(&ls->ls_lkbxa_lock); 1538 + if (lkb) { 1539 + /* check if lkb is still part of lkbxa under lkbxa_lock as 1540 + * the lkb_ref is tight to the lkbxa data structure, see 1541 + * __put_lkb(). 1542 + */ 1543 + read_lock_bh(&ls->ls_lkbxa_lock); 1544 + if (kref_read(&lkb->lkb_ref)) 1545 + kref_get(&lkb->lkb_ref); 1546 + else 1547 + lkb = NULL; 1548 + read_unlock_bh(&ls->ls_lkbxa_lock); 1549 + } 1550 + rcu_read_unlock(); 1535 1551 1536 1552 *lkb_ret = lkb; 1537 1553 return lkb ? 0 : -ENOENT; ··· 1679 1675 1680 1676 static void move_lkb(struct dlm_rsb *r, struct dlm_lkb *lkb, int sts) 1681 1677 { 1682 - hold_lkb(lkb); 1683 1678 del_lkb(r, lkb); 1684 1679 add_lkb(r, lkb, sts); 1685 - unhold_lkb(lkb); 1686 1680 } 1687 1681 1688 1682 static int msg_reply_type(int mstype) ··· 4325 4323 memset(name, 0, sizeof(name)); 4326 4324 memcpy(name, ms->m_extra, len); 4327 4325 4328 - write_lock_bh(&ls->ls_rsbtbl_lock); 4329 - 4326 + rcu_read_lock(); 4330 4327 rv = dlm_search_rsb_tree(&ls->ls_rsbtbl, name, len, &r); 4331 4328 if (rv) { 4329 + rcu_read_unlock(); 4332 4330 /* should not happen */ 4333 4331 log_error(ls, "%s from %d not found %s", __func__, 4334 4332 from_nodeid, name); 4335 - write_unlock_bh(&ls->ls_rsbtbl_lock); 4336 4333 return; 4337 4334 } 4335 + 4336 + write_lock_bh(&ls->ls_rsbtbl_lock); 4337 + if (!rsb_flag(r, RSB_HASHED)) { 4338 + rcu_read_unlock(); 4339 + write_unlock_bh(&ls->ls_rsbtbl_lock); 4340 + /* should not happen */ 4341 + log_error(ls, "%s from %d got removed during removal %s", 4342 + __func__, from_nodeid, name); 4343 + return; 4344 + } 4345 + /* at this stage the rsb can only being freed here */ 4346 + rcu_read_unlock(); 4338 4347 4339 4348 if (!rsb_flag(r, RSB_INACTIVE)) { 4340 4349 if (r->res_master_nodeid != from_nodeid) { ··· 5310 5297 case DLM_MSG_LOOKUP: 5311 5298 case DLM_MSG_REQUEST: 5312 5299 _request_lock(r, lkb); 5313 - if (is_master(r)) 5300 + if (r->res_nodeid != -1 && is_master(r)) 5314 5301 confirm_master(r, 0); 5315 5302 break; 5316 5303 case DLM_MSG_CONVERT: ··· 5422 5409 return; 5423 5410 5424 5411 list_for_each_entry(r, root_list, res_root_list) { 5425 - hold_rsb(r); 5426 5412 lock_rsb(r); 5427 - if (is_master(r)) { 5413 + if (r->res_nodeid != -1 && is_master(r)) { 5428 5414 purge_dead_list(ls, r, &r->res_grantqueue, 5429 5415 nodeid_gone, &lkb_count); 5430 5416 purge_dead_list(ls, r, &r->res_convertqueue, ··· 5432 5420 nodeid_gone, &lkb_count); 5433 5421 } 5434 5422 unlock_rsb(r); 5435 - unhold_rsb(r); 5423 + 5436 5424 cond_resched(); 5437 5425 } 5438 5426

+2

fs/dlm/lock.h

··· 66 66 67 67 static inline int is_master(struct dlm_rsb *r) 68 68 { 69 + WARN_ON_ONCE(r->res_nodeid == -1); 70 + 69 71 return !r->res_nodeid; 70 72 } 71 73

+48 -49

fs/dlm/lockspace.c

··· 174 174 return a->store ? a->store(ls, buf, len) : len; 175 175 } 176 176 177 - static void lockspace_kobj_release(struct kobject *k) 178 - { 179 - struct dlm_ls *ls = container_of(k, struct dlm_ls, ls_kobj); 180 - kfree(ls); 181 - } 182 - 183 177 static const struct sysfs_ops dlm_attr_ops = { 184 178 .show = dlm_attr_show, 185 179 .store = dlm_attr_store, ··· 182 188 static struct kobj_type dlm_ktype = { 183 189 .default_groups = dlm_groups, 184 190 .sysfs_ops = &dlm_attr_ops, 185 - .release = lockspace_kobj_release, 186 191 }; 187 192 188 193 static struct kset *dlm_kset; ··· 315 322 return error; 316 323 } 317 324 325 + static int lkb_idr_free(struct dlm_lkb *lkb) 326 + { 327 + if (lkb->lkb_lvbptr && test_bit(DLM_IFL_MSTCPY_BIT, &lkb->lkb_iflags)) 328 + dlm_free_lvb(lkb->lkb_lvbptr); 329 + 330 + dlm_free_lkb(lkb); 331 + return 0; 332 + } 333 + 334 + static void rhash_free_rsb(void *ptr, void *arg) 335 + { 336 + struct dlm_rsb *rsb = ptr; 337 + 338 + dlm_free_rsb(rsb); 339 + } 340 + 341 + static void free_lockspace(struct work_struct *work) 342 + { 343 + struct dlm_ls *ls = container_of(work, struct dlm_ls, ls_free_work); 344 + struct dlm_lkb *lkb; 345 + unsigned long id; 346 + 347 + /* 348 + * Free all lkb's in xa 349 + */ 350 + xa_for_each(&ls->ls_lkbxa, id, lkb) { 351 + lkb_idr_free(lkb); 352 + } 353 + xa_destroy(&ls->ls_lkbxa); 354 + 355 + /* 356 + * Free all rsb's on rsbtbl 357 + */ 358 + rhashtable_free_and_destroy(&ls->ls_rsbtbl, rhash_free_rsb, NULL); 359 + 360 + kfree(ls); 361 + } 362 + 318 363 static int new_lockspace(const char *name, const char *cluster, 319 364 uint32_t flags, int lvblen, 320 365 const struct dlm_lockspace_ops *ops, void *ops_arg, 321 366 int *ops_result, dlm_lockspace_t **lockspace) 322 367 { 323 368 struct dlm_ls *ls; 324 - int do_unreg = 0; 325 369 int namelen = strlen(name); 326 370 int error; 327 371 ··· 483 453 spin_lock_init(&ls->ls_cb_lock); 484 454 INIT_LIST_HEAD(&ls->ls_cb_delay); 485 455 456 + INIT_WORK(&ls->ls_free_work, free_lockspace); 457 + 486 458 ls->ls_recoverd_task = NULL; 487 459 mutex_init(&ls->ls_recoverd_active); 488 460 spin_lock_init(&ls->ls_recover_lock); ··· 562 530 wait_event(ls->ls_recover_lock_wait, 563 531 test_bit(LSFL_RECOVER_LOCK, &ls->ls_flags)); 564 532 565 - /* let kobject handle freeing of ls if there's an error */ 566 - do_unreg = 1; 567 - 568 533 ls->ls_kobj.kset = dlm_kset; 569 534 error = kobject_init_and_add(&ls->ls_kobj, &dlm_ktype, NULL, 570 535 "%s", ls->ls_name); ··· 609 580 xa_destroy(&ls->ls_lkbxa); 610 581 rhashtable_destroy(&ls->ls_rsbtbl); 611 582 out_lsfree: 612 - if (do_unreg) 613 - kobject_put(&ls->ls_kobj); 614 - else 615 - kfree(ls); 583 + kobject_put(&ls->ls_kobj); 584 + kfree(ls); 616 585 out: 617 586 module_put(THIS_MODULE); 618 587 return error; ··· 667 640 ops_arg, ops_result, lockspace); 668 641 } 669 642 670 - static int lkb_idr_free(struct dlm_lkb *lkb) 671 - { 672 - if (lkb->lkb_lvbptr && test_bit(DLM_IFL_MSTCPY_BIT, &lkb->lkb_iflags)) 673 - dlm_free_lvb(lkb->lkb_lvbptr); 674 - 675 - dlm_free_lkb(lkb); 676 - return 0; 677 - } 678 - 679 643 /* NOTE: We check the lkbxa here rather than the resource table. 680 644 This is because there may be LKBs queued as ASTs that have been unlinked 681 645 from their RSBs and are pending deletion once the AST has been delivered */ ··· 698 680 return rv; 699 681 } 700 682 701 - static void rhash_free_rsb(void *ptr, void *arg) 702 - { 703 - struct dlm_rsb *rsb = ptr; 704 - 705 - dlm_free_rsb(rsb); 706 - } 707 - 708 683 static int release_lockspace(struct dlm_ls *ls, int force) 709 684 { 710 - struct dlm_lkb *lkb; 711 - unsigned long id; 712 685 int busy, rv; 713 686 714 687 busy = lockspace_busy(ls, force); ··· 752 743 753 744 dlm_delete_debug_file(ls); 754 745 746 + kobject_put(&ls->ls_kobj); 747 + 755 748 xa_destroy(&ls->ls_recover_xa); 756 749 kfree(ls->ls_recover_buf); 757 - 758 - /* 759 - * Free all lkb's in xa 760 - */ 761 - xa_for_each(&ls->ls_lkbxa, id, lkb) { 762 - lkb_idr_free(lkb); 763 - } 764 - xa_destroy(&ls->ls_lkbxa); 765 - 766 - /* 767 - * Free all rsb's on rsbtbl 768 - */ 769 - rhashtable_free_and_destroy(&ls->ls_rsbtbl, rhash_free_rsb, NULL); 770 750 771 751 /* 772 752 * Free structures on any other lists ··· 766 768 dlm_clear_members(ls); 767 769 dlm_clear_members_gone(ls); 768 770 kfree(ls->ls_node_array); 769 - log_rinfo(ls, "release_lockspace final free"); 770 - kobject_put(&ls->ls_kobj); 771 - /* The ls structure will be freed when the kobject is done with */ 772 771 772 + log_rinfo(ls, "%s final free", __func__); 773 + 774 + /* delayed free of data structures see free_lockspace() */ 775 + queue_work(dlm_wq, &ls->ls_free_work); 773 776 module_put(THIS_MODULE); 774 777 return 0; 775 778 }

+1 -35

fs/dlm/lowcomms.c

··· 161 161 const char *name; 162 162 int proto; 163 163 164 - int (*connect)(struct connection *con, struct socket *sock, 165 - struct sockaddr *addr, int addr_len); 166 164 void (*sockopts)(struct socket *sock); 167 165 int (*bind)(struct socket *sock); 168 166 int (*listen_validate)(void); ··· 1597 1599 1598 1600 log_print_ratelimited("connecting to %d", con->nodeid); 1599 1601 make_sockaddr(&addr, dlm_config.ci_tcp_port, &addr_len); 1600 - result = dlm_proto_ops->connect(con, sock, (struct sockaddr *)&addr, 1601 - addr_len); 1602 + result = kernel_connect(sock, (struct sockaddr *)&addr, addr_len, 0); 1602 1603 switch (result) { 1603 1604 case -EINPROGRESS: 1604 1605 /* not an error */ ··· 1630 1633 ret = dlm_connect(con); 1631 1634 switch (ret) { 1632 1635 case 0: 1633 - break; 1634 - case -EINPROGRESS: 1635 - /* avoid spamming resched on connection 1636 - * we might can switch to a state_change 1637 - * event based mechanism if established 1638 - */ 1639 - msleep(100); 1640 1636 break; 1641 1637 default: 1642 1638 /* CF_SEND_PENDING not cleared */ ··· 1821 1831 return 0; 1822 1832 } 1823 1833 1824 - static int dlm_tcp_connect(struct connection *con, struct socket *sock, 1825 - struct sockaddr *addr, int addr_len) 1826 - { 1827 - return kernel_connect(sock, addr, addr_len, O_NONBLOCK); 1828 - } 1829 - 1830 1834 static int dlm_tcp_listen_validate(void) 1831 1835 { 1832 1836 /* We don't support multi-homed hosts */ ··· 1857 1873 static const struct dlm_proto_ops dlm_tcp_ops = { 1858 1874 .name = "TCP", 1859 1875 .proto = IPPROTO_TCP, 1860 - .connect = dlm_tcp_connect, 1861 1876 .sockopts = dlm_tcp_sockopts, 1862 1877 .bind = dlm_tcp_bind, 1863 1878 .listen_validate = dlm_tcp_listen_validate, ··· 1867 1884 static int dlm_sctp_bind(struct socket *sock) 1868 1885 { 1869 1886 return sctp_bind_addrs(sock, 0); 1870 - } 1871 - 1872 - static int dlm_sctp_connect(struct connection *con, struct socket *sock, 1873 - struct sockaddr *addr, int addr_len) 1874 - { 1875 - int ret; 1876 - 1877 - /* 1878 - * Make kernel_connect() function return in specified time, 1879 - * since O_NONBLOCK argument in connect() function does not work here, 1880 - * then, we should restore the default value of this attribute. 1881 - */ 1882 - sock_set_sndtimeo(sock->sk, 5); 1883 - ret = kernel_connect(sock, addr, addr_len, 0); 1884 - sock_set_sndtimeo(sock->sk, 0); 1885 - return ret; 1886 1887 } 1887 1888 1888 1889 static int dlm_sctp_listen_validate(void) ··· 1896 1929 .name = "SCTP", 1897 1930 .proto = IPPROTO_SCTP, 1898 1931 .try_new_addr = true, 1899 - .connect = dlm_sctp_connect, 1900 1932 .sockopts = dlm_sctp_sockopts, 1901 1933 .bind = dlm_sctp_bind, 1902 1934 .listen_validate = dlm_sctp_listen_validate,

+12

fs/dlm/main.c

··· 22 22 #define CREATE_TRACE_POINTS 23 23 #include <trace/events/dlm.h> 24 24 25 + struct workqueue_struct *dlm_wq; 26 + 25 27 static int __init init_dlm(void) 26 28 { 27 29 int error; ··· 52 50 if (error) 53 51 goto out_user; 54 52 53 + dlm_wq = alloc_workqueue("dlm_wq", 0, 0); 54 + if (!dlm_wq) { 55 + error = -ENOMEM; 56 + goto out_plock; 57 + } 58 + 55 59 printk("DLM installed\n"); 56 60 57 61 return 0; 58 62 63 + out_plock: 64 + dlm_plock_exit(); 59 65 out_user: 60 66 dlm_user_exit(); 61 67 out_debug: ··· 80 70 81 71 static void __exit exit_dlm(void) 82 72 { 73 + /* be sure every pending work e.g. freeing is done */ 74 + destroy_workqueue(dlm_wq); 83 75 dlm_plock_exit(); 84 76 dlm_user_exit(); 85 77 dlm_config_exit();

+2

fs/dlm/member.c

··· 366 366 367 367 int dlm_is_removed(struct dlm_ls *ls, int nodeid) 368 368 { 369 + WARN_ON_ONCE(!nodeid || nodeid == -1); 370 + 369 371 if (find_memb(&ls->ls_nodes_gone, nodeid)) 370 372 return 1; 371 373 return 0;

+13 -15

fs/dlm/memory.c

··· 84 84 85 85 char *dlm_allocate_lvb(struct dlm_ls *ls) 86 86 { 87 - char *p; 88 - 89 - p = kzalloc(ls->ls_lvblen, GFP_ATOMIC); 90 - return p; 87 + return kzalloc(ls->ls_lvblen, GFP_ATOMIC); 91 88 } 92 89 93 90 void dlm_free_lvb(char *p) ··· 92 95 kfree(p); 93 96 } 94 97 95 - struct dlm_rsb *dlm_allocate_rsb(struct dlm_ls *ls) 98 + struct dlm_rsb *dlm_allocate_rsb(void) 96 99 { 97 - struct dlm_rsb *r; 98 - 99 - r = kmem_cache_zalloc(rsb_cache, GFP_ATOMIC); 100 - return r; 100 + return kmem_cache_zalloc(rsb_cache, GFP_ATOMIC); 101 101 } 102 102 103 103 static void __free_rsb_rcu(struct rcu_head *rcu) ··· 110 116 call_rcu(&r->rcu, __free_rsb_rcu); 111 117 } 112 118 113 - struct dlm_lkb *dlm_allocate_lkb(struct dlm_ls *ls) 119 + struct dlm_lkb *dlm_allocate_lkb(void) 114 120 { 115 - struct dlm_lkb *lkb; 116 - 117 - lkb = kmem_cache_zalloc(lkb_cache, GFP_ATOMIC); 118 - return lkb; 121 + return kmem_cache_zalloc(lkb_cache, GFP_ATOMIC); 119 122 } 120 123 121 - void dlm_free_lkb(struct dlm_lkb *lkb) 124 + static void __free_lkb_rcu(struct rcu_head *rcu) 122 125 { 126 + struct dlm_lkb *lkb = container_of(rcu, struct dlm_lkb, rcu); 127 + 123 128 if (test_bit(DLM_DFL_USER_BIT, &lkb->lkb_dflags)) { 124 129 struct dlm_user_args *ua; 125 130 ua = lkb->lkb_ua; ··· 129 136 } 130 137 131 138 kmem_cache_free(lkb_cache, lkb); 139 + } 140 + 141 + void dlm_free_lkb(struct dlm_lkb *lkb) 142 + { 143 + call_rcu(&lkb->rcu, __free_lkb_rcu); 132 144 } 133 145 134 146 struct dlm_mhandle *dlm_allocate_mhandle(void)

+2 -2

fs/dlm/memory.h

··· 14 14 15 15 int dlm_memory_init(void); 16 16 void dlm_memory_exit(void); 17 - struct dlm_rsb *dlm_allocate_rsb(struct dlm_ls *ls); 17 + struct dlm_rsb *dlm_allocate_rsb(void); 18 18 void dlm_free_rsb(struct dlm_rsb *r); 19 - struct dlm_lkb *dlm_allocate_lkb(struct dlm_ls *ls); 19 + struct dlm_lkb *dlm_allocate_lkb(void); 20 20 void dlm_free_lkb(struct dlm_lkb *l); 21 21 char *dlm_allocate_lvb(struct dlm_ls *ls); 22 22 void dlm_free_lvb(char *l);

+5 -4

fs/dlm/recover.c

··· 452 452 int is_removed = 0; 453 453 int error; 454 454 455 - if (is_master(r)) 455 + if (r->res_nodeid != -1 && is_master(r)) 456 456 return 0; 457 457 458 - is_removed = dlm_is_removed(ls, r->res_nodeid); 458 + if (r->res_nodeid != -1) 459 + is_removed = dlm_is_removed(ls, r->res_nodeid); 459 460 460 461 if (!is_removed && !rsb_flag(r, RSB_NEW_MASTER)) 461 462 return 0; ··· 665 664 int error, count = 0; 666 665 667 666 list_for_each_entry(r, root_list, res_root_list) { 668 - if (is_master(r)) { 667 + if (r->res_nodeid != -1 && is_master(r)) { 669 668 rsb_clear_flag(r, RSB_NEW_MASTER); 670 669 continue; 671 670 } ··· 859 858 860 859 list_for_each_entry(r, root_list, res_root_list) { 861 860 lock_rsb(r); 862 - if (is_master(r)) { 861 + if (r->res_nodeid != -1 && is_master(r)) { 863 862 if (rsb_flag(r, RSB_RECOVER_CONVERT)) 864 863 recover_conversion(r); 865 864

Configure Feed

Configure Feed