← Back to branch summary

~ubuntu-branches/debian/wheezy/linux-2.6/wheezy

« back to all changes in this revision

Viewing changes to fs/ocfs2/dlmglue.c

  • Committer: Bazaar Package Importer
  • Author(s): Ben Hutchings, Ben Hutchings, Aurelien Jarno
  • Date: 2011-06-07 12:14:05 UTC
  • mfrom: (43.1.9 sid)
  • Revision ID: james.westby@ubuntu.com-20110607121405-i3h1rd7nrnd2b73h
Tags: 2.6.39-2
http://bugs.debian.org/627492
http://bugs.debian.org/596626
http://bugs.debian.org/628932
http://bugs.debian.org/628191
http://bugs.debian.org/627837
http://bugs.debian.org/622997
http://bugs.debian.org/622745
http://bugs.debian.org/619827
http://bugs.debian.org/629401
[ Ben Hutchings ]
* [x86] Enable BACKLIGHT_APPLE, replacing BACKLIGHT_MBP_NVIDIA
  (Closes: #627492)
* cgroups: Disable memory resource controller by default. Allow it
  to be enabled using kernel parameter 'cgroup_enable=memory'.
* rt2800usb: Enable support for more USB devices including
  Linksys WUSB600N (Closes: #596626) (this change was accidentally
  omitted from 2.6.39-1)
* [x86] Remove Celeron from list of processors supporting PAE. Most
  'Celeron M' models do not.
* Update debconf template translations:
  - Swedish (Martin Bagge) (Closes: #628932)
  - French (David Prévot) (Closes: #628191)
* aufs: Update for 2.6.39 (Closes: #627837)
* Add stable 2.6.39.1, including:
  - ext4: dont set PageUptodate in ext4_end_bio()
  - pata_cmd64x: fix boot crash on parisc (Closes: #622997, #622745)
  - ext3: Fix fs corruption when make_indexed_dir() fails
  - netfilter: nf_ct_sip: validate Content-Length in TCP SIP messages
  - sctp: fix race between sctp_bind_addr_free() and
    sctp_bind_addr_conflict()
  - sctp: fix memory leak of the ASCONF queue when free asoc
  - md/bitmap: fix saving of events_cleared and other state
  - cdc_acm: Fix oops when Droids MuIn LCD is connected
  - cx88: Fix conversion from BKL to fine-grained locks (Closes: #619827)
  - keys: Set cred->user_ns in key_replace_session_keyring (CVE-2011-2184)
  - tmpfs: fix race between truncate and writepage
  - nfs41: Correct offset for LAYOUTCOMMIT
  - xen/mmu: fix a race window causing leave_mm BUG()
  - ext4: fix possible use-after-free in ext4_remove_li_request()
  For the complete list of changes, see:
   http://www.kernel.org/pub/linux/kernel/v2.6/ChangeLog-2.6.39.1
* Bump ABI to 2
* netfilter: Enable IP_SET, IP_SET_BITMAP_IP, IP_SET_BITMAP_IPMAC,
  IP_SET_BITMAP_PORT, IP_SET_HASH_IP, IP_SET_HASH_IPPORT,
  IP_SET_HASH_IPPORTIP, IP_SET_HASH_IPPORTNET, IP_SET_HASH_NET,
  IP_SET_HASH_NETPORT, IP_SET_LIST_SET, NETFILTER_XT_SET as modules
  (Closes: #629401)

[ Aurelien Jarno ]
* [mipsel/loongson-2f] Disable_SCSI_LPFC to workaround GCC ICE.

Show diffs side-by-side

added added

removed removed

Lines of Context:
fs/ocfs2/dlmglue.c
64
64
        unsigned long           mw_mask;
65
65
        unsigned long           mw_goal;
66
66
#ifdef CONFIG_OCFS2_FS_STATS
67
 
        unsigned long long      mw_lock_start;
 
67
        ktime_t                 mw_lock_start;
68
68
#endif
69
69
};
70
70
 
397
397
{
398
398
        int len;
399
399
 
400
 
        mlog_entry_void();
401
 
 
402
400
        BUG_ON(type >= OCFS2_NUM_LOCK_TYPES);
403
401
 
404
402
        len = snprintf(name, OCFS2_LOCK_ID_MAX_LEN, "%c%s%016llx%08x",
408
406
        BUG_ON(len != (OCFS2_LOCK_ID_MAX_LEN - 1));
409
407
 
410
408
        mlog(0, "built lock resource with name: %s\n", name);
411
 
 
412
 
        mlog_exit_void();
413
409
}
414
410
 
415
411
static DEFINE_SPINLOCK(ocfs2_dlm_tracking_lock);
435
431
#ifdef CONFIG_OCFS2_FS_STATS
436
432
static void ocfs2_init_lock_stats(struct ocfs2_lock_res *res)
437
433
{
438
 
        res->l_lock_num_prmode = 0;
439
 
        res->l_lock_num_prmode_failed = 0;
440
 
        res->l_lock_total_prmode = 0;
441
 
        res->l_lock_max_prmode = 0;
442
 
        res->l_lock_num_exmode = 0;
443
 
        res->l_lock_num_exmode_failed = 0;
444
 
        res->l_lock_total_exmode = 0;
445
 
        res->l_lock_max_exmode = 0;
446
434
        res->l_lock_refresh = 0;
 
435
        memset(&res->l_lock_prmode, 0, sizeof(struct ocfs2_lock_stats));
 
436
        memset(&res->l_lock_exmode, 0, sizeof(struct ocfs2_lock_stats));
447
437
}
448
438
 
449
439
static void ocfs2_update_lock_stats(struct ocfs2_lock_res *res, int level,
450
440
                                    struct ocfs2_mask_waiter *mw, int ret)
451
441
{
452
 
        unsigned long long *num, *sum;
453
 
        unsigned int *max, *failed;
454
 
        struct timespec ts = current_kernel_time();
455
 
        unsigned long long time = timespec_to_ns(&ts) - mw->mw_lock_start;
 
442
        u32 usec;
 
443
        ktime_t kt;
 
444
        struct ocfs2_lock_stats *stats;
456
445
 
457
 
        if (level == LKM_PRMODE) {
458
 
                num = &res->l_lock_num_prmode;
459
 
                sum = &res->l_lock_total_prmode;
460
 
                max = &res->l_lock_max_prmode;
461
 
                failed = &res->l_lock_num_prmode_failed;
462
 
        } else if (level == LKM_EXMODE) {
463
 
                num = &res->l_lock_num_exmode;
464
 
                sum = &res->l_lock_total_exmode;
465
 
                max = &res->l_lock_max_exmode;
466
 
                failed = &res->l_lock_num_exmode_failed;
467
 
        } else
 
446
        if (level == LKM_PRMODE)
 
447
                stats = &res->l_lock_prmode;
 
448
        else if (level == LKM_EXMODE)
 
449
                stats = &res->l_lock_exmode;
 
450
        else
468
451
                return;
469
452
 
470
 
        (*num)++;
471
 
        (*sum) += time;
472
 
        if (time > *max)
473
 
                *max = time;
 
453
        kt = ktime_sub(ktime_get(), mw->mw_lock_start);
 
454
        usec = ktime_to_us(kt);
 
455
 
 
456
        stats->ls_gets++;
 
457
        stats->ls_total += ktime_to_ns(kt);
 
458
        /* overflow */
 
459
        if (unlikely(stats->ls_gets) == 0) {
 
460
                stats->ls_gets++;
 
461
                stats->ls_total = ktime_to_ns(kt);
 
462
        }
 
463
 
 
464
        if (stats->ls_max < usec)
 
465
                stats->ls_max = usec;
 
466
 
474
467
        if (ret)
475
 
                (*failed)++;
 
468
                stats->ls_fail++;
476
469
}
477
470
 
478
471
static inline void ocfs2_track_lock_refresh(struct ocfs2_lock_res *lockres)
482
475
 
483
476
static inline void ocfs2_init_start_time(struct ocfs2_mask_waiter *mw)
484
477
{
485
 
        struct timespec ts = current_kernel_time();
486
 
        mw->mw_lock_start = timespec_to_ns(&ts);
 
478
        mw->mw_lock_start = ktime_get();
487
479
}
488
480
#else
489
481
static inline void ocfs2_init_lock_stats(struct ocfs2_lock_res *res)
729
721
 
730
722
void ocfs2_lock_res_free(struct ocfs2_lock_res *res)
731
723
{
732
 
        mlog_entry_void();
733
 
 
734
724
        if (!(res->l_flags & OCFS2_LOCK_INITIALIZED))
735
725
                return;
736
726
 
756
746
        memset(&res->l_lksb, 0, sizeof(res->l_lksb));
757
747
 
758
748
        res->l_flags = 0UL;
759
 
        mlog_exit_void();
760
749
}
761
750
 
762
751
static inline void ocfs2_inc_holders(struct ocfs2_lock_res *lockres,
763
752
                                     int level)
764
753
{
765
 
        mlog_entry_void();
766
 
 
767
754
        BUG_ON(!lockres);
768
755
 
769
756
        switch(level) {
776
763
        default:
777
764
                BUG();
778
765
        }
779
 
 
780
 
        mlog_exit_void();
781
766
}
782
767
 
783
768
static inline void ocfs2_dec_holders(struct ocfs2_lock_res *lockres,
784
769
                                     int level)
785
770
{
786
 
        mlog_entry_void();
787
 
 
788
771
        BUG_ON(!lockres);
789
772
 
790
773
        switch(level) {
799
782
        default:
800
783
                BUG();
801
784
        }
802
 
        mlog_exit_void();
803
785
}
804
786
 
805
787
/* WARNING: This function lives in a world where the only three lock
846
828
 
847
829
static inline void ocfs2_generic_handle_downconvert_action(struct ocfs2_lock_res *lockres)
848
830
{
849
 
        mlog_entry_void();
850
 
 
851
831
        BUG_ON(!(lockres->l_flags & OCFS2_LOCK_BUSY));
852
832
        BUG_ON(!(lockres->l_flags & OCFS2_LOCK_ATTACHED));
853
833
        BUG_ON(!(lockres->l_flags & OCFS2_LOCK_BLOCKED));
860
840
                lockres_clear_flags(lockres, OCFS2_LOCK_BLOCKED);
861
841
        }
862
842
        lockres_clear_flags(lockres, OCFS2_LOCK_BUSY);
863
 
 
864
 
        mlog_exit_void();
865
843
}
866
844
 
867
845
static inline void ocfs2_generic_handle_convert_action(struct ocfs2_lock_res *lockres)
868
846
{
869
 
        mlog_entry_void();
870
 
 
871
847
        BUG_ON(!(lockres->l_flags & OCFS2_LOCK_BUSY));
872
848
        BUG_ON(!(lockres->l_flags & OCFS2_LOCK_ATTACHED));
873
849
 
889
865
        lockres_or_flags(lockres, OCFS2_LOCK_UPCONVERT_FINISHING);
890
866
 
891
867
        lockres_clear_flags(lockres, OCFS2_LOCK_BUSY);
892
 
 
893
 
        mlog_exit_void();
894
868
}
895
869
 
896
870
static inline void ocfs2_generic_handle_attach_action(struct ocfs2_lock_res *lockres)
897
871
{
898
 
        mlog_entry_void();
899
 
 
900
872
        BUG_ON((!(lockres->l_flags & OCFS2_LOCK_BUSY)));
901
873
        BUG_ON(lockres->l_flags & OCFS2_LOCK_ATTACHED);
902
874
 
908
880
        lockres->l_level = lockres->l_requested;
909
881
        lockres_or_flags(lockres, OCFS2_LOCK_ATTACHED);
910
882
        lockres_clear_flags(lockres, OCFS2_LOCK_BUSY);
911
 
 
912
 
        mlog_exit_void();
913
883
}
914
884
 
915
885
static int ocfs2_generic_handle_bast(struct ocfs2_lock_res *lockres,
916
886
                                     int level)
917
887
{
918
888
        int needs_downconvert = 0;
919
 
        mlog_entry_void();
920
889
 
921
890
        assert_spin_locked(&lockres->l_lock);
922
891
 
938
907
 
939
908
        if (needs_downconvert)
940
909
                lockres_or_flags(lockres, OCFS2_LOCK_BLOCKED);
941
 
 
942
 
        mlog_exit(needs_downconvert);
 
910
        mlog(0, "needs_downconvert = %d\n", needs_downconvert);
943
911
        return needs_downconvert;
944
912
}
945
913
 
1151
1119
        struct ocfs2_lock_res *lockres = ocfs2_lksb_to_lock_res(lksb);
1152
1120
        unsigned long flags;
1153
1121
 
1154
 
        mlog_entry_void();
1155
 
 
1156
1122
        mlog(ML_BASTS, "UNLOCK AST fired for lockres %s, action = %d\n",
1157
1123
             lockres->l_name, lockres->l_unlock_action);
1158
1124
 
1162
1128
                     "unlock_action %d\n", error, lockres->l_name,
1163
1129
                     lockres->l_unlock_action);
1164
1130
                spin_unlock_irqrestore(&lockres->l_lock, flags);
1165
 
                mlog_exit_void();
1166
1131
                return;
1167
1132
        }
1168
1133
 
1186
1151
        lockres->l_unlock_action = OCFS2_UNLOCK_INVALID;
1187
1152
        wake_up(&lockres->l_event);
1188
1153
        spin_unlock_irqrestore(&lockres->l_lock, flags);
1189
 
 
1190
 
        mlog_exit_void();
1191
1154
}
1192
1155
 
1193
1156
/*
1233
1196
{
1234
1197
        unsigned long flags;
1235
1198
 
1236
 
        mlog_entry_void();
1237
1199
        spin_lock_irqsave(&lockres->l_lock, flags);
1238
1200
        lockres_clear_flags(lockres, OCFS2_LOCK_BUSY);
1239
1201
        lockres_clear_flags(lockres, OCFS2_LOCK_UPCONVERT_FINISHING);
1244
1206
        spin_unlock_irqrestore(&lockres->l_lock, flags);
1245
1207
 
1246
1208
        wake_up(&lockres->l_event);
1247
 
        mlog_exit_void();
1248
1209
}
1249
1210
 
1250
1211
/* Note: If we detect another process working on the lock (i.e.,
1260
1221
        unsigned long flags;
1261
1222
        unsigned int gen;
1262
1223
 
1263
 
        mlog_entry_void();
1264
 
 
1265
1224
        mlog(0, "lock %s, level = %d, flags = %u\n", lockres->l_name, level,
1266
1225
             dlm_flags);
1267
1226
 
1293
1252
        mlog(0, "lock %s, return from ocfs2_dlm_lock\n", lockres->l_name);
1294
1253
 
1295
1254
bail:
1296
 
        mlog_exit(ret);
1297
1255
        return ret;
1298
1256
}
1299
1257
 
1416
1374
        unsigned int gen;
1417
1375
        int noqueue_attempted = 0;
1418
1376
 
1419
 
        mlog_entry_void();
1420
 
 
1421
1377
        ocfs2_init_mask_waiter(&mw);
1422
1378
 
1423
1379
        if (lockres->l_ops->flags & LOCK_TYPE_USES_LVB)
1583
1539
                                caller_ip);
1584
1540
        }
1585
1541
#endif
1586
 
        mlog_exit(ret);
1587
1542
        return ret;
1588
1543
}
1589
1544
 
1605
1560
{
1606
1561
        unsigned long flags;
1607
1562
 
1608
 
        mlog_entry_void();
1609
1563
        spin_lock_irqsave(&lockres->l_lock, flags);
1610
1564
        ocfs2_dec_holders(lockres, level);
1611
1565
        ocfs2_downconvert_on_unlock(osb, lockres);
1614
1568
        if (lockres->l_lockdep_map.key != NULL)
1615
1569
                rwsem_release(&lockres->l_lockdep_map, 1, caller_ip);
1616
1570
#endif
1617
 
        mlog_exit_void();
1618
1571
}
1619
1572
 
1620
1573
static int ocfs2_create_new_lock(struct ocfs2_super *osb,
1648
1601
        BUG_ON(!inode);
1649
1602
        BUG_ON(!ocfs2_inode_is_new(inode));
1650
1603
 
1651
 
        mlog_entry_void();
1652
 
 
1653
1604
        mlog(0, "Inode %llu\n", (unsigned long long)OCFS2_I(inode)->ip_blkno);
1654
1605
 
1655
1606
        /* NOTE: That we don't increment any of the holder counts, nor
1683
1634
        }
1684
1635
 
1685
1636
bail:
1686
 
        mlog_exit(ret);
1687
1637
        return ret;
1688
1638
}
1689
1639
 
1695
1645
 
1696
1646
        BUG_ON(!inode);
1697
1647
 
1698
 
        mlog_entry_void();
1699
 
 
1700
1648
        mlog(0, "inode %llu take %s RW lock\n",
1701
1649
             (unsigned long long)OCFS2_I(inode)->ip_blkno,
1702
1650
             write ? "EXMODE" : "PRMODE");
1703
1651
 
1704
 
        if (ocfs2_mount_local(osb)) {
1705
 
                mlog_exit(0);
 
1652
        if (ocfs2_mount_local(osb))
1706
1653
                return 0;
1707
 
        }
1708
1654
 
1709
1655
        lockres = &OCFS2_I(inode)->ip_rw_lockres;
1710
1656
 
1715
1661
        if (status < 0)
1716
1662
                mlog_errno(status);
1717
1663
 
1718
 
        mlog_exit(status);
1719
1664
        return status;
1720
1665
}
1721
1666
 
1725
1670
        struct ocfs2_lock_res *lockres = &OCFS2_I(inode)->ip_rw_lockres;
1726
1671
        struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
1727
1672
 
1728
 
        mlog_entry_void();
1729
 
 
1730
1673
        mlog(0, "inode %llu drop %s RW lock\n",
1731
1674
             (unsigned long long)OCFS2_I(inode)->ip_blkno,
1732
1675
             write ? "EXMODE" : "PRMODE");
1733
1676
 
1734
1677
        if (!ocfs2_mount_local(osb))
1735
1678
                ocfs2_cluster_unlock(OCFS2_SB(inode->i_sb), lockres, level);
1736
 
 
1737
 
        mlog_exit_void();
1738
1679
}
1739
1680
 
1740
1681
/*
1748
1689
 
1749
1690
        BUG_ON(!inode);
1750
1691
 
1751
 
        mlog_entry_void();
1752
 
 
1753
1692
        mlog(0, "inode %llu take PRMODE open lock\n",
1754
1693
             (unsigned long long)OCFS2_I(inode)->ip_blkno);
1755
1694
 
1764
1703
                mlog_errno(status);
1765
1704
 
1766
1705
out:
1767
 
        mlog_exit(status);
1768
1706
        return status;
1769
1707
}
1770
1708
 
1776
1714
 
1777
1715
        BUG_ON(!inode);
1778
1716
 
1779
 
        mlog_entry_void();
1780
 
 
1781
1717
        mlog(0, "inode %llu try to take %s open lock\n",
1782
1718
             (unsigned long long)OCFS2_I(inode)->ip_blkno,
1783
1719
             write ? "EXMODE" : "PRMODE");
1799
1735
                                    level, DLM_LKF_NOQUEUE, 0);
1800
1736
 
1801
1737
out:
1802
 
        mlog_exit(status);
1803
1738
        return status;
1804
1739
}
1805
1740
 
1811
1746
        struct ocfs2_lock_res *lockres = &OCFS2_I(inode)->ip_open_lockres;
1812
1747
        struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
1813
1748
 
1814
 
        mlog_entry_void();
1815
 
 
1816
1749
        mlog(0, "inode %llu drop open lock\n",
1817
1750
             (unsigned long long)OCFS2_I(inode)->ip_blkno);
1818
1751
 
1827
1760
                                     DLM_LOCK_EX);
1828
1761
 
1829
1762
out:
1830
 
        mlog_exit_void();
 
1763
        return;
1831
1764
}
1832
1765
 
1833
1766
static int ocfs2_flock_handle_signal(struct ocfs2_lock_res *lockres,
2043
1976
{
2044
1977
        int kick = 0;
2045
1978
 
2046
 
        mlog_entry_void();
2047
 
 
2048
1979
        /* If we know that another node is waiting on our lock, kick
2049
1980
         * the downconvert thread * pre-emptively when we reach a release
2050
1981
         * condition. */
2065
1996
 
2066
1997
        if (kick)
2067
1998
                ocfs2_wake_downconvert_thread(osb);
2068
 
 
2069
 
        mlog_exit_void();
2070
1999
}
2071
2000
 
2072
2001
#define OCFS2_SEC_BITS   34
2095
2024
        struct ocfs2_lock_res *lockres = &oi->ip_inode_lockres;
2096
2025
        struct ocfs2_meta_lvb *lvb;
2097
2026
 
2098
 
        mlog_entry_void();
2099
 
 
2100
2027
        lvb = ocfs2_dlm_lvb(&lockres->l_lksb);
2101
2028
 
2102
2029
        /*
2128
2055
 
2129
2056
out:
2130
2057
        mlog_meta_lvb(0, lockres);
2131
 
 
2132
 
        mlog_exit_void();
2133
2058
}
2134
2059
 
2135
2060
static void ocfs2_unpack_timespec(struct timespec *spec,
2145
2070
        struct ocfs2_lock_res *lockres = &oi->ip_inode_lockres;
2146
2071
        struct ocfs2_meta_lvb *lvb;
2147
2072
 
2148
 
        mlog_entry_void();
2149
 
 
2150
2073
        mlog_meta_lvb(0, lockres);
2151
2074
 
2152
2075
        lvb = ocfs2_dlm_lvb(&lockres->l_lksb);
2177
2100
        ocfs2_unpack_timespec(&inode->i_ctime,
2178
2101
                              be64_to_cpu(lvb->lvb_ictime_packed));
2179
2102
        spin_unlock(&oi->ip_lock);
2180
 
 
2181
 
        mlog_exit_void();
2182
2103
}
2183
2104
 
2184
2105
static inline int ocfs2_meta_lvb_is_trustable(struct inode *inode,
2205
2126
        unsigned long flags;
2206
2127
        int status = 0;
2207
2128
 
2208
 
        mlog_entry_void();
2209
 
 
2210
2129
refresh_check:
2211
2130
        spin_lock_irqsave(&lockres->l_lock, flags);
2212
2131
        if (!(lockres->l_flags & OCFS2_LOCK_NEEDS_REFRESH)) {
2227
2146
 
2228
2147
        status = 1;
2229
2148
bail:
2230
 
        mlog_exit(status);
 
2149
        mlog(0, "status %d\n", status);
2231
2150
        return status;
2232
2151
}
2233
2152
 
2237
2156
                                                   int status)
2238
2157
{
2239
2158
        unsigned long flags;
2240
 
        mlog_entry_void();
2241
2159
 
2242
2160
        spin_lock_irqsave(&lockres->l_lock, flags);
2243
2161
        lockres_clear_flags(lockres, OCFS2_LOCK_REFRESHING);
2246
2164
        spin_unlock_irqrestore(&lockres->l_lock, flags);
2247
2165
 
2248
2166
        wake_up(&lockres->l_event);
2249
 
 
2250
 
        mlog_exit_void();
2251
2167
}
2252
2168
 
2253
2169
/* may or may not return a bh if it went to disk. */
2260
2176
        struct ocfs2_dinode *fe;
2261
2177
        struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
2262
2178
 
2263
 
        mlog_entry_void();
2264
 
 
2265
2179
        if (ocfs2_mount_local(osb))
2266
2180
                goto bail;
2267
2181
 
2330
2244
bail_refresh:
2331
2245
        ocfs2_complete_lock_res_refresh(lockres, status);
2332
2246
bail:
2333
 
        mlog_exit(status);
2334
2247
        return status;
2335
2248
}
2336
2249
 
2374
2287
 
2375
2288
        BUG_ON(!inode);
2376
2289
 
2377
 
        mlog_entry_void();
2378
 
 
2379
2290
        mlog(0, "inode %llu, take %s META lock\n",
2380
2291
             (unsigned long long)OCFS2_I(inode)->ip_blkno,
2381
2292
             ex ? "EXMODE" : "PRMODE");
2467
2378
        if (local_bh)
2468
2379
                brelse(local_bh);
2469
2380
 
2470
 
        mlog_exit(status);
2471
2381
        return status;
2472
2382
}
2473
2383
 
2517
2427
{
2518
2428
        int ret;
2519
2429
 
2520
 
        mlog_entry_void();
2521
2430
        ret = ocfs2_inode_lock(inode, NULL, 0);
2522
2431
        if (ret < 0) {
2523
2432
                mlog_errno(ret);
2545
2454
        } else
2546
2455
                *level = 0;
2547
2456
 
2548
 
        mlog_exit(ret);
2549
2457
        return ret;
2550
2458
}
2551
2459
 
2556
2464
        struct ocfs2_lock_res *lockres = &OCFS2_I(inode)->ip_inode_lockres;
2557
2465
        struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
2558
2466
 
2559
 
        mlog_entry_void();
2560
 
 
2561
2467
        mlog(0, "inode %llu drop %s META lock\n",
2562
2468
             (unsigned long long)OCFS2_I(inode)->ip_blkno,
2563
2469
             ex ? "EXMODE" : "PRMODE");
2565
2471
        if (!ocfs2_is_hard_readonly(OCFS2_SB(inode->i_sb)) &&
2566
2472
            !ocfs2_mount_local(osb))
2567
2473
                ocfs2_cluster_unlock(OCFS2_SB(inode->i_sb), lockres, level);
2568
 
 
2569
 
        mlog_exit_void();
2570
2474
}
2571
2475
 
2572
2476
int ocfs2_orphan_scan_lock(struct ocfs2_super *osb, u32 *seqno)
2617
2521
        int level = ex ? DLM_LOCK_EX : DLM_LOCK_PR;
2618
2522
        struct ocfs2_lock_res *lockres = &osb->osb_super_lockres;
2619
2523
 
2620
 
        mlog_entry_void();
2621
 
 
2622
2524
        if (ocfs2_is_hard_readonly(osb))
2623
2525
                return -EROFS;
2624
2526
 
2650
2552
                ocfs2_track_lock_refresh(lockres);
2651
2553
        }
2652
2554
bail:
2653
 
        mlog_exit(status);
2654
2555
        return status;
2655
2556
}
2656
2557
 
2869
2770
        return iter;
2870
2771
}
2871
2772
 
2872
 
/* So that debugfs.ocfs2 can determine which format is being used */
2873
 
#define OCFS2_DLM_DEBUG_STR_VERSION 2
 
2773
/*
 
2774
 * Version is used by debugfs.ocfs2 to determine the format being used
 
2775
 *
 
2776
 * New in version 2
 
2777
 *      - Lock stats printed
 
2778
 * New in version 3
 
2779
 *      - Max time in lock stats is in usecs (instead of nsecs)
 
2780
 */
 
2781
#define OCFS2_DLM_DEBUG_STR_VERSION 3
2874
2782
static int ocfs2_dlm_seq_show(struct seq_file *m, void *v)
2875
2783
{
2876
2784
        int i;
2912
2820
                seq_printf(m, "0x%x\t", lvb[i]);
2913
2821
 
2914
2822
#ifdef CONFIG_OCFS2_FS_STATS
2915
 
# define lock_num_prmode(_l)            (_l)->l_lock_num_prmode
2916
 
# define lock_num_exmode(_l)            (_l)->l_lock_num_exmode
2917
 
# define lock_num_prmode_failed(_l)     (_l)->l_lock_num_prmode_failed
2918
 
# define lock_num_exmode_failed(_l)     (_l)->l_lock_num_exmode_failed
2919
 
# define lock_total_prmode(_l)          (_l)->l_lock_total_prmode
2920
 
# define lock_total_exmode(_l)          (_l)->l_lock_total_exmode
2921
 
# define lock_max_prmode(_l)            (_l)->l_lock_max_prmode
2922
 
# define lock_max_exmode(_l)            (_l)->l_lock_max_exmode
2923
 
# define lock_refresh(_l)               (_l)->l_lock_refresh
 
2823
# define lock_num_prmode(_l)            ((_l)->l_lock_prmode.ls_gets)
 
2824
# define lock_num_exmode(_l)            ((_l)->l_lock_exmode.ls_gets)
 
2825
# define lock_num_prmode_failed(_l)     ((_l)->l_lock_prmode.ls_fail)
 
2826
# define lock_num_exmode_failed(_l)     ((_l)->l_lock_exmode.ls_fail)
 
2827
# define lock_total_prmode(_l)          ((_l)->l_lock_prmode.ls_total)
 
2828
# define lock_total_exmode(_l)          ((_l)->l_lock_exmode.ls_total)
 
2829
# define lock_max_prmode(_l)            ((_l)->l_lock_prmode.ls_max)
 
2830
# define lock_max_exmode(_l)            ((_l)->l_lock_exmode.ls_max)
 
2831
# define lock_refresh(_l)               ((_l)->l_lock_refresh)
2924
2832
#else
2925
 
# define lock_num_prmode(_l)            (0ULL)
2926
 
# define lock_num_exmode(_l)            (0ULL)
 
2833
# define lock_num_prmode(_l)            (0)
 
2834
# define lock_num_exmode(_l)            (0)
2927
2835
# define lock_num_prmode_failed(_l)     (0)
2928
2836
# define lock_num_exmode_failed(_l)     (0)
2929
2837
# define lock_total_prmode(_l)          (0ULL)
2933
2841
# define lock_refresh(_l)               (0)
2934
2842
#endif
2935
2843
        /* The following seq_print was added in version 2 of this output */
2936
 
        seq_printf(m, "%llu\t"
2937
 
                   "%llu\t"
 
2844
        seq_printf(m, "%u\t"
 
2845
                   "%u\t"
2938
2846
                   "%u\t"
2939
2847
                   "%u\t"
2940
2848
                   "%llu\t"
3054
2962
        int status = 0;
3055
2963
        struct ocfs2_cluster_connection *conn = NULL;
3056
2964
 
3057
 
        mlog_entry_void();
3058
 
 
3059
2965
        if (ocfs2_mount_local(osb)) {
3060
2966
                osb->node_num = 0;
3061
2967
                goto local;
3112
3018
                        kthread_stop(osb->dc_task);
3113
3019
        }
3114
3020
 
3115
 
        mlog_exit(status);
3116
3021
        return status;
3117
3022
}
3118
3023
 
3119
3024
void ocfs2_dlm_shutdown(struct ocfs2_super *osb,
3120
3025
                        int hangup_pending)
3121
3026
{
3122
 
        mlog_entry_void();
3123
 
 
3124
3027
        ocfs2_drop_osb_locks(osb);
3125
3028
 
3126
3029
        /*
3143
3046
        osb->cconn = NULL;
3144
3047
 
3145
3048
        ocfs2_dlm_shutdown_debug(osb);
3146
 
 
3147
 
        mlog_exit_void();
3148
3049
}
3149
3050
 
3150
3051
static int ocfs2_drop_lock(struct ocfs2_super *osb,
3226
3127
 
3227
3128
        ocfs2_wait_on_busy_lock(lockres);
3228
3129
out:
3229
 
        mlog_exit(0);
3230
3130
        return 0;
3231
3131
}
3232
3132
 
3284
3184
{
3285
3185
        int status, err;
3286
3186
 
3287
 
        mlog_entry_void();
3288
 
 
3289
3187
        /* No need to call ocfs2_mark_lockres_freeing here -
3290
3188
         * ocfs2_clear_inode has done it for us. */
3291
3189
 
3310
3208
        if (err < 0 && !status)
3311
3209
                status = err;
3312
3210
 
3313
 
        mlog_exit(status);
3314
3211
        return status;
3315
3212
}
3316
3213
 
3352
3249
        int ret;
3353
3250
        u32 dlm_flags = DLM_LKF_CONVERT;
3354
3251
 
3355
 
        mlog_entry_void();
3356
 
 
3357
3252
        mlog(ML_BASTS, "lockres %s, level %d => %d\n", lockres->l_name,
3358
3253
             lockres->l_level, new_level);
3359
3254
 
3375
3270
 
3376
3271
        ret = 0;
3377
3272
bail:
3378
 
        mlog_exit(ret);
3379
3273
        return ret;
3380
3274
}
3381
3275
 
3385
3279
{
3386
3280
        assert_spin_locked(&lockres->l_lock);
3387
3281
 
3388
 
        mlog_entry_void();
3389
 
 
3390
3282
        if (lockres->l_unlock_action == OCFS2_UNLOCK_CANCEL_CONVERT) {
3391
3283
                /* If we're already trying to cancel a lock conversion
3392
3284
                 * then just drop the spinlock and allow the caller to
3416
3308
{
3417
3309
        int ret;
3418
3310
 
3419
 
        mlog_entry_void();
3420
 
 
3421
3311
        ret = ocfs2_dlm_unlock(osb->cconn, &lockres->l_lksb,
3422
3312
                               DLM_LKF_CANCEL);
3423
3313
        if (ret) {
3427
3317
 
3428
3318
        mlog(ML_BASTS, "lockres %s\n", lockres->l_name);
3429
3319
 
3430
 
        mlog_exit(ret);
3431
3320
        return ret;
3432
3321
}
3433
3322
 
3443
3332
        int set_lvb = 0;
3444
3333
        unsigned int gen;
3445
3334
 
3446
 
        mlog_entry_void();
3447
 
 
3448
3335
        spin_lock_irqsave(&lockres->l_lock, flags);
3449
3336
 
3450
3337
recheck:
3619
3506
                                     gen);
3620
3507
 
3621
3508
leave:
3622
 
        mlog_exit(ret);
 
3509
        if (ret)
 
3510
                mlog_errno(ret);
3623
3511
        return ret;
3624
3512
 
3625
3513
leave_requeue:
3626
3514
        spin_unlock_irqrestore(&lockres->l_lock, flags);
3627
3515
        ctl->requeue = 1;
3628
3516
 
3629
 
        mlog_exit(0);
3630
3517
        return 0;
3631
3518
}
3632
3519
 
3859
3746
        struct mem_dqinfo *info = sb_dqinfo(oinfo->dqi_gi.dqi_sb,
3860
3747
                                            oinfo->dqi_gi.dqi_type);
3861
3748
 
3862
 
        mlog_entry_void();
3863
 
 
3864
3749
        lvb = ocfs2_dlm_lvb(&lockres->l_lksb);
3865
3750
        lvb->lvb_version = OCFS2_QINFO_LVB_VERSION;
3866
3751
        lvb->lvb_bgrace = cpu_to_be32(info->dqi_bgrace);
3869
3754
        lvb->lvb_blocks = cpu_to_be32(oinfo->dqi_gi.dqi_blocks);
3870
3755
        lvb->lvb_free_blk = cpu_to_be32(oinfo->dqi_gi.dqi_free_blk);
3871
3756
        lvb->lvb_free_entry = cpu_to_be32(oinfo->dqi_gi.dqi_free_entry);
3872
 
 
3873
 
        mlog_exit_void();
3874
3757
}
3875
3758
 
3876
3759
void ocfs2_qinfo_unlock(struct ocfs2_mem_dqinfo *oinfo, int ex)
3879
3762
        struct ocfs2_super *osb = OCFS2_SB(oinfo->dqi_gi.dqi_sb);
3880
3763
        int level = ex ? DLM_LOCK_EX : DLM_LOCK_PR;
3881
3764
 
3882
 
        mlog_entry_void();
3883
3765
        if (!ocfs2_is_hard_readonly(osb) && !ocfs2_mount_local(osb))
3884
3766
                ocfs2_cluster_unlock(osb, lockres, level);
3885
 
        mlog_exit_void();
3886
3767
}
3887
3768
 
3888
3769
static int ocfs2_refresh_qinfo(struct ocfs2_mem_dqinfo *oinfo)
3937
3818
        int level = ex ? DLM_LOCK_EX : DLM_LOCK_PR;
3938
3819
        int status = 0;
3939
3820
 
3940
 
        mlog_entry_void();
3941
 
 
3942
3821
        /* On RO devices, locking really isn't needed... */
3943
3822
        if (ocfs2_is_hard_readonly(osb)) {
3944
3823
                if (ex)
3961
3840
                ocfs2_qinfo_unlock(oinfo, ex);
3962
3841
        ocfs2_complete_lock_res_refresh(lockres, status);
3963
3842
bail:
3964
 
        mlog_exit(status);
3965
3843
        return status;
3966
3844
}
3967
3845
 
4007
3885
         * considered valid until we remove the OCFS2_LOCK_QUEUED
4008
3886
         * flag. */
4009
3887
 
4010
 
        mlog_entry_void();
4011
 
 
4012
3888
        BUG_ON(!lockres);
4013
3889
        BUG_ON(!lockres->l_ops);
4014
3890
 
4042
3918
        if (ctl.unblock_action != UNBLOCK_CONTINUE
4043
3919
            && lockres->l_ops->post_unlock)
4044
3920
                lockres->l_ops->post_unlock(osb, lockres);
4045
 
 
4046
 
        mlog_exit_void();
4047
3921
}
4048
3922
 
4049
3923
static void ocfs2_schedule_blocked_lock(struct ocfs2_super *osb,
4050
3924
                                        struct ocfs2_lock_res *lockres)
4051
3925
{
4052
 
        mlog_entry_void();
4053
 
 
4054
3926
        assert_spin_locked(&lockres->l_lock);
4055
3927
 
4056
3928
        if (lockres->l_flags & OCFS2_LOCK_FREEING) {
4071
3943
                osb->blocked_lock_count++;
4072
3944
        }
4073
3945
        spin_unlock(&osb->dc_task_lock);
4074
 
 
4075
 
        mlog_exit_void();
4076
3946
}
4077
3947
 
4078
3948
static void ocfs2_downconvert_thread_do_work(struct ocfs2_super *osb)
4080
3950
        unsigned long processed;
4081
3951
        struct ocfs2_lock_res *lockres;
4082
3952
 
4083
 
        mlog_entry_void();
4084
 
 
4085
3953
        spin_lock(&osb->dc_task_lock);
4086
3954
        /* grab this early so we know to try again if a state change and
4087
3955
         * wake happens part-way through our work  */
4105
3973
                spin_lock(&osb->dc_task_lock);
4106
3974
        }
4107
3975
        spin_unlock(&osb->dc_task_lock);
4108
 
 
4109
 
        mlog_exit_void();
4110
3976
}
4111
3977
 
4112
3978
static int ocfs2_downconvert_thread_lists_empty(struct ocfs2_super *osb)