diff options
Diffstat (limited to 'fs/gfs2/glock.c')
-rw-r--r-- | fs/gfs2/glock.c | 268 |
1 files changed, 83 insertions, 185 deletions
diff --git a/fs/gfs2/glock.c b/fs/gfs2/glock.c index 6b983aef785d..3984e47d1d33 100644 --- a/fs/gfs2/glock.c +++ b/fs/gfs2/glock.c | |||
@@ -10,7 +10,6 @@ | |||
10 | #include <linux/sched.h> | 10 | #include <linux/sched.h> |
11 | #include <linux/slab.h> | 11 | #include <linux/slab.h> |
12 | #include <linux/spinlock.h> | 12 | #include <linux/spinlock.h> |
13 | #include <linux/completion.h> | ||
14 | #include <linux/buffer_head.h> | 13 | #include <linux/buffer_head.h> |
15 | #include <linux/delay.h> | 14 | #include <linux/delay.h> |
16 | #include <linux/sort.h> | 15 | #include <linux/sort.h> |
@@ -18,7 +17,6 @@ | |||
18 | #include <linux/kallsyms.h> | 17 | #include <linux/kallsyms.h> |
19 | #include <linux/gfs2_ondisk.h> | 18 | #include <linux/gfs2_ondisk.h> |
20 | #include <linux/list.h> | 19 | #include <linux/list.h> |
21 | #include <linux/lm_interface.h> | ||
22 | #include <linux/wait.h> | 20 | #include <linux/wait.h> |
23 | #include <linux/module.h> | 21 | #include <linux/module.h> |
24 | #include <linux/rwsem.h> | 22 | #include <linux/rwsem.h> |
@@ -155,13 +153,10 @@ static void glock_free(struct gfs2_glock *gl) | |||
155 | struct gfs2_sbd *sdp = gl->gl_sbd; | 153 | struct gfs2_sbd *sdp = gl->gl_sbd; |
156 | struct inode *aspace = gl->gl_aspace; | 154 | struct inode *aspace = gl->gl_aspace; |
157 | 155 | ||
158 | if (sdp->sd_lockstruct.ls_ops->lm_put_lock) | ||
159 | sdp->sd_lockstruct.ls_ops->lm_put_lock(gl->gl_lock); | ||
160 | |||
161 | if (aspace) | 156 | if (aspace) |
162 | gfs2_aspace_put(aspace); | 157 | gfs2_aspace_put(aspace); |
163 | 158 | ||
164 | kmem_cache_free(gfs2_glock_cachep, gl); | 159 | sdp->sd_lockstruct.ls_ops->lm_put_lock(gfs2_glock_cachep, gl); |
165 | } | 160 | } |
166 | 161 | ||
167 | /** | 162 | /** |
@@ -172,6 +167,7 @@ static void glock_free(struct gfs2_glock *gl) | |||
172 | 167 | ||
173 | static void gfs2_glock_hold(struct gfs2_glock *gl) | 168 | static void gfs2_glock_hold(struct gfs2_glock *gl) |
174 | { | 169 | { |
170 | GLOCK_BUG_ON(gl, atomic_read(&gl->gl_ref) == 0); | ||
175 | atomic_inc(&gl->gl_ref); | 171 | atomic_inc(&gl->gl_ref); |
176 | } | 172 | } |
177 | 173 | ||
@@ -211,17 +207,15 @@ int gfs2_glock_put(struct gfs2_glock *gl) | |||
211 | atomic_dec(&lru_count); | 207 | atomic_dec(&lru_count); |
212 | } | 208 | } |
213 | spin_unlock(&lru_lock); | 209 | spin_unlock(&lru_lock); |
214 | GLOCK_BUG_ON(gl, gl->gl_state != LM_ST_UNLOCKED); | ||
215 | GLOCK_BUG_ON(gl, !list_empty(&gl->gl_lru)); | ||
216 | GLOCK_BUG_ON(gl, !list_empty(&gl->gl_holders)); | 210 | GLOCK_BUG_ON(gl, !list_empty(&gl->gl_holders)); |
217 | glock_free(gl); | 211 | glock_free(gl); |
218 | rv = 1; | 212 | rv = 1; |
219 | goto out; | 213 | goto out; |
220 | } | 214 | } |
221 | write_unlock(gl_lock_addr(gl->gl_hash)); | ||
222 | /* 1 for being hashed, 1 for having state != LM_ST_UNLOCKED */ | 215 | /* 1 for being hashed, 1 for having state != LM_ST_UNLOCKED */ |
223 | if (atomic_read(&gl->gl_ref) == 2) | 216 | if (atomic_read(&gl->gl_ref) == 2) |
224 | gfs2_glock_schedule_for_reclaim(gl); | 217 | gfs2_glock_schedule_for_reclaim(gl); |
218 | write_unlock(gl_lock_addr(gl->gl_hash)); | ||
225 | out: | 219 | out: |
226 | return rv; | 220 | return rv; |
227 | } | 221 | } |
@@ -256,27 +250,6 @@ static struct gfs2_glock *search_bucket(unsigned int hash, | |||
256 | } | 250 | } |
257 | 251 | ||
258 | /** | 252 | /** |
259 | * gfs2_glock_find() - Find glock by lock number | ||
260 | * @sdp: The GFS2 superblock | ||
261 | * @name: The lock name | ||
262 | * | ||
263 | * Returns: NULL, or the struct gfs2_glock with the requested number | ||
264 | */ | ||
265 | |||
266 | static struct gfs2_glock *gfs2_glock_find(const struct gfs2_sbd *sdp, | ||
267 | const struct lm_lockname *name) | ||
268 | { | ||
269 | unsigned int hash = gl_hash(sdp, name); | ||
270 | struct gfs2_glock *gl; | ||
271 | |||
272 | read_lock(gl_lock_addr(hash)); | ||
273 | gl = search_bucket(hash, sdp, name); | ||
274 | read_unlock(gl_lock_addr(hash)); | ||
275 | |||
276 | return gl; | ||
277 | } | ||
278 | |||
279 | /** | ||
280 | * may_grant - check if its ok to grant a new lock | 253 | * may_grant - check if its ok to grant a new lock |
281 | * @gl: The glock | 254 | * @gl: The glock |
282 | * @gh: The lock request which we wish to grant | 255 | * @gh: The lock request which we wish to grant |
@@ -523,7 +496,7 @@ out_locked: | |||
523 | } | 496 | } |
524 | 497 | ||
525 | static unsigned int gfs2_lm_lock(struct gfs2_sbd *sdp, void *lock, | 498 | static unsigned int gfs2_lm_lock(struct gfs2_sbd *sdp, void *lock, |
526 | unsigned int cur_state, unsigned int req_state, | 499 | unsigned int req_state, |
527 | unsigned int flags) | 500 | unsigned int flags) |
528 | { | 501 | { |
529 | int ret = LM_OUT_ERROR; | 502 | int ret = LM_OUT_ERROR; |
@@ -532,7 +505,7 @@ static unsigned int gfs2_lm_lock(struct gfs2_sbd *sdp, void *lock, | |||
532 | return req_state == LM_ST_UNLOCKED ? 0 : req_state; | 505 | return req_state == LM_ST_UNLOCKED ? 0 : req_state; |
533 | 506 | ||
534 | if (likely(!test_bit(SDF_SHUTDOWN, &sdp->sd_flags))) | 507 | if (likely(!test_bit(SDF_SHUTDOWN, &sdp->sd_flags))) |
535 | ret = sdp->sd_lockstruct.ls_ops->lm_lock(lock, cur_state, | 508 | ret = sdp->sd_lockstruct.ls_ops->lm_lock(lock, |
536 | req_state, flags); | 509 | req_state, flags); |
537 | return ret; | 510 | return ret; |
538 | } | 511 | } |
@@ -575,7 +548,7 @@ __acquires(&gl->gl_spin) | |||
575 | gl->gl_state == LM_ST_DEFERRED) && | 548 | gl->gl_state == LM_ST_DEFERRED) && |
576 | !(lck_flags & (LM_FLAG_TRY | LM_FLAG_TRY_1CB))) | 549 | !(lck_flags & (LM_FLAG_TRY | LM_FLAG_TRY_1CB))) |
577 | lck_flags |= LM_FLAG_TRY_1CB; | 550 | lck_flags |= LM_FLAG_TRY_1CB; |
578 | ret = gfs2_lm_lock(sdp, gl->gl_lock, gl->gl_state, target, lck_flags); | 551 | ret = gfs2_lm_lock(sdp, gl, target, lck_flags); |
579 | 552 | ||
580 | if (!(ret & LM_OUT_ASYNC)) { | 553 | if (!(ret & LM_OUT_ASYNC)) { |
581 | finish_xmote(gl, ret); | 554 | finish_xmote(gl, ret); |
@@ -624,10 +597,11 @@ __acquires(&gl->gl_spin) | |||
624 | 597 | ||
625 | GLOCK_BUG_ON(gl, test_bit(GLF_DEMOTE_IN_PROGRESS, &gl->gl_flags)); | 598 | GLOCK_BUG_ON(gl, test_bit(GLF_DEMOTE_IN_PROGRESS, &gl->gl_flags)); |
626 | 599 | ||
600 | down_read(&gfs2_umount_flush_sem); | ||
627 | if (test_bit(GLF_DEMOTE, &gl->gl_flags) && | 601 | if (test_bit(GLF_DEMOTE, &gl->gl_flags) && |
628 | gl->gl_demote_state != gl->gl_state) { | 602 | gl->gl_demote_state != gl->gl_state) { |
629 | if (find_first_holder(gl)) | 603 | if (find_first_holder(gl)) |
630 | goto out; | 604 | goto out_unlock; |
631 | if (nonblock) | 605 | if (nonblock) |
632 | goto out_sched; | 606 | goto out_sched; |
633 | set_bit(GLF_DEMOTE_IN_PROGRESS, &gl->gl_flags); | 607 | set_bit(GLF_DEMOTE_IN_PROGRESS, &gl->gl_flags); |
@@ -638,23 +612,26 @@ __acquires(&gl->gl_spin) | |||
638 | gfs2_demote_wake(gl); | 612 | gfs2_demote_wake(gl); |
639 | ret = do_promote(gl); | 613 | ret = do_promote(gl); |
640 | if (ret == 0) | 614 | if (ret == 0) |
641 | goto out; | 615 | goto out_unlock; |
642 | if (ret == 2) | 616 | if (ret == 2) |
643 | return; | 617 | goto out_sem; |
644 | gh = find_first_waiter(gl); | 618 | gh = find_first_waiter(gl); |
645 | gl->gl_target = gh->gh_state; | 619 | gl->gl_target = gh->gh_state; |
646 | if (!(gh->gh_flags & (LM_FLAG_TRY | LM_FLAG_TRY_1CB))) | 620 | if (!(gh->gh_flags & (LM_FLAG_TRY | LM_FLAG_TRY_1CB))) |
647 | do_error(gl, 0); /* Fail queued try locks */ | 621 | do_error(gl, 0); /* Fail queued try locks */ |
648 | } | 622 | } |
649 | do_xmote(gl, gh, gl->gl_target); | 623 | do_xmote(gl, gh, gl->gl_target); |
624 | out_sem: | ||
625 | up_read(&gfs2_umount_flush_sem); | ||
650 | return; | 626 | return; |
651 | 627 | ||
652 | out_sched: | 628 | out_sched: |
653 | gfs2_glock_hold(gl); | 629 | gfs2_glock_hold(gl); |
654 | if (queue_delayed_work(glock_workqueue, &gl->gl_work, 0) == 0) | 630 | if (queue_delayed_work(glock_workqueue, &gl->gl_work, 0) == 0) |
655 | gfs2_glock_put(gl); | 631 | gfs2_glock_put(gl); |
656 | out: | 632 | out_unlock: |
657 | clear_bit(GLF_LOCK, &gl->gl_flags); | 633 | clear_bit(GLF_LOCK, &gl->gl_flags); |
634 | goto out_sem; | ||
658 | } | 635 | } |
659 | 636 | ||
660 | static void glock_work_func(struct work_struct *work) | 637 | static void glock_work_func(struct work_struct *work) |
@@ -681,18 +658,6 @@ static void glock_work_func(struct work_struct *work) | |||
681 | gfs2_glock_put(gl); | 658 | gfs2_glock_put(gl); |
682 | } | 659 | } |
683 | 660 | ||
684 | static int gfs2_lm_get_lock(struct gfs2_sbd *sdp, struct lm_lockname *name, | ||
685 | void **lockp) | ||
686 | { | ||
687 | int error = -EIO; | ||
688 | if (!sdp->sd_lockstruct.ls_ops->lm_get_lock) | ||
689 | return 0; | ||
690 | if (likely(!test_bit(SDF_SHUTDOWN, &sdp->sd_flags))) | ||
691 | error = sdp->sd_lockstruct.ls_ops->lm_get_lock( | ||
692 | sdp->sd_lockstruct.ls_lockspace, name, lockp); | ||
693 | return error; | ||
694 | } | ||
695 | |||
696 | /** | 661 | /** |
697 | * gfs2_glock_get() - Get a glock, or create one if one doesn't exist | 662 | * gfs2_glock_get() - Get a glock, or create one if one doesn't exist |
698 | * @sdp: The GFS2 superblock | 663 | * @sdp: The GFS2 superblock |
@@ -719,10 +684,11 @@ int gfs2_glock_get(struct gfs2_sbd *sdp, u64 number, | |||
719 | gl = search_bucket(hash, sdp, &name); | 684 | gl = search_bucket(hash, sdp, &name); |
720 | read_unlock(gl_lock_addr(hash)); | 685 | read_unlock(gl_lock_addr(hash)); |
721 | 686 | ||
722 | if (gl || !create) { | 687 | *glp = gl; |
723 | *glp = gl; | 688 | if (gl) |
724 | return 0; | 689 | return 0; |
725 | } | 690 | if (!create) |
691 | return -ENOENT; | ||
726 | 692 | ||
727 | gl = kmem_cache_alloc(gfs2_glock_cachep, GFP_KERNEL); | 693 | gl = kmem_cache_alloc(gfs2_glock_cachep, GFP_KERNEL); |
728 | if (!gl) | 694 | if (!gl) |
@@ -736,7 +702,9 @@ int gfs2_glock_get(struct gfs2_sbd *sdp, u64 number, | |||
736 | gl->gl_demote_state = LM_ST_EXCLUSIVE; | 702 | gl->gl_demote_state = LM_ST_EXCLUSIVE; |
737 | gl->gl_hash = hash; | 703 | gl->gl_hash = hash; |
738 | gl->gl_ops = glops; | 704 | gl->gl_ops = glops; |
739 | gl->gl_stamp = jiffies; | 705 | snprintf(gl->gl_strname, GDLM_STRNAME_BYTES, "%8x%16llx", name.ln_type, (unsigned long long)number); |
706 | memset(&gl->gl_lksb, 0, sizeof(struct dlm_lksb)); | ||
707 | gl->gl_lksb.sb_lvbptr = gl->gl_lvb; | ||
740 | gl->gl_tchange = jiffies; | 708 | gl->gl_tchange = jiffies; |
741 | gl->gl_object = NULL; | 709 | gl->gl_object = NULL; |
742 | gl->gl_sbd = sdp; | 710 | gl->gl_sbd = sdp; |
@@ -753,10 +721,6 @@ int gfs2_glock_get(struct gfs2_sbd *sdp, u64 number, | |||
753 | } | 721 | } |
754 | } | 722 | } |
755 | 723 | ||
756 | error = gfs2_lm_get_lock(sdp, &name, &gl->gl_lock); | ||
757 | if (error) | ||
758 | goto fail_aspace; | ||
759 | |||
760 | write_lock(gl_lock_addr(hash)); | 724 | write_lock(gl_lock_addr(hash)); |
761 | tmp = search_bucket(hash, sdp, &name); | 725 | tmp = search_bucket(hash, sdp, &name); |
762 | if (tmp) { | 726 | if (tmp) { |
@@ -772,9 +736,6 @@ int gfs2_glock_get(struct gfs2_sbd *sdp, u64 number, | |||
772 | 736 | ||
773 | return 0; | 737 | return 0; |
774 | 738 | ||
775 | fail_aspace: | ||
776 | if (gl->gl_aspace) | ||
777 | gfs2_aspace_put(gl->gl_aspace); | ||
778 | fail: | 739 | fail: |
779 | kmem_cache_free(gfs2_glock_cachep, gl); | 740 | kmem_cache_free(gfs2_glock_cachep, gl); |
780 | return error; | 741 | return error; |
@@ -966,7 +927,7 @@ do_cancel: | |||
966 | if (!(gh->gh_flags & LM_FLAG_PRIORITY)) { | 927 | if (!(gh->gh_flags & LM_FLAG_PRIORITY)) { |
967 | spin_unlock(&gl->gl_spin); | 928 | spin_unlock(&gl->gl_spin); |
968 | if (sdp->sd_lockstruct.ls_ops->lm_cancel) | 929 | if (sdp->sd_lockstruct.ls_ops->lm_cancel) |
969 | sdp->sd_lockstruct.ls_ops->lm_cancel(gl->gl_lock); | 930 | sdp->sd_lockstruct.ls_ops->lm_cancel(gl); |
970 | spin_lock(&gl->gl_spin); | 931 | spin_lock(&gl->gl_spin); |
971 | } | 932 | } |
972 | return; | 933 | return; |
@@ -1051,7 +1012,6 @@ void gfs2_glock_dq(struct gfs2_holder *gh) | |||
1051 | spin_lock(&gl->gl_spin); | 1012 | spin_lock(&gl->gl_spin); |
1052 | clear_bit(GLF_LOCK, &gl->gl_flags); | 1013 | clear_bit(GLF_LOCK, &gl->gl_flags); |
1053 | } | 1014 | } |
1054 | gl->gl_stamp = jiffies; | ||
1055 | if (list_empty(&gl->gl_holders) && | 1015 | if (list_empty(&gl->gl_holders) && |
1056 | !test_bit(GLF_PENDING_DEMOTE, &gl->gl_flags) && | 1016 | !test_bit(GLF_PENDING_DEMOTE, &gl->gl_flags) && |
1057 | !test_bit(GLF_DEMOTE, &gl->gl_flags)) | 1017 | !test_bit(GLF_DEMOTE, &gl->gl_flags)) |
@@ -1240,70 +1200,13 @@ void gfs2_glock_dq_uninit_m(unsigned int num_gh, struct gfs2_holder *ghs) | |||
1240 | gfs2_glock_dq_uninit(&ghs[x]); | 1200 | gfs2_glock_dq_uninit(&ghs[x]); |
1241 | } | 1201 | } |
1242 | 1202 | ||
1243 | static int gfs2_lm_hold_lvb(struct gfs2_sbd *sdp, void *lock, char **lvbp) | 1203 | void gfs2_glock_cb(struct gfs2_glock *gl, unsigned int state) |
1244 | { | ||
1245 | int error = -EIO; | ||
1246 | if (!sdp->sd_lockstruct.ls_ops->lm_hold_lvb) | ||
1247 | return 0; | ||
1248 | if (likely(!test_bit(SDF_SHUTDOWN, &sdp->sd_flags))) | ||
1249 | error = sdp->sd_lockstruct.ls_ops->lm_hold_lvb(lock, lvbp); | ||
1250 | return error; | ||
1251 | } | ||
1252 | |||
1253 | /** | ||
1254 | * gfs2_lvb_hold - attach a LVB from a glock | ||
1255 | * @gl: The glock in question | ||
1256 | * | ||
1257 | */ | ||
1258 | |||
1259 | int gfs2_lvb_hold(struct gfs2_glock *gl) | ||
1260 | { | ||
1261 | int error; | ||
1262 | |||
1263 | if (!atomic_read(&gl->gl_lvb_count)) { | ||
1264 | error = gfs2_lm_hold_lvb(gl->gl_sbd, gl->gl_lock, &gl->gl_lvb); | ||
1265 | if (error) | ||
1266 | return error; | ||
1267 | gfs2_glock_hold(gl); | ||
1268 | } | ||
1269 | atomic_inc(&gl->gl_lvb_count); | ||
1270 | |||
1271 | return 0; | ||
1272 | } | ||
1273 | |||
1274 | /** | ||
1275 | * gfs2_lvb_unhold - detach a LVB from a glock | ||
1276 | * @gl: The glock in question | ||
1277 | * | ||
1278 | */ | ||
1279 | |||
1280 | void gfs2_lvb_unhold(struct gfs2_glock *gl) | ||
1281 | { | ||
1282 | struct gfs2_sbd *sdp = gl->gl_sbd; | ||
1283 | |||
1284 | gfs2_glock_hold(gl); | ||
1285 | gfs2_assert(gl->gl_sbd, atomic_read(&gl->gl_lvb_count) > 0); | ||
1286 | if (atomic_dec_and_test(&gl->gl_lvb_count)) { | ||
1287 | if (sdp->sd_lockstruct.ls_ops->lm_unhold_lvb) | ||
1288 | sdp->sd_lockstruct.ls_ops->lm_unhold_lvb(gl->gl_lock, gl->gl_lvb); | ||
1289 | gl->gl_lvb = NULL; | ||
1290 | gfs2_glock_put(gl); | ||
1291 | } | ||
1292 | gfs2_glock_put(gl); | ||
1293 | } | ||
1294 | |||
1295 | static void blocking_cb(struct gfs2_sbd *sdp, struct lm_lockname *name, | ||
1296 | unsigned int state) | ||
1297 | { | 1204 | { |
1298 | struct gfs2_glock *gl; | ||
1299 | unsigned long delay = 0; | 1205 | unsigned long delay = 0; |
1300 | unsigned long holdtime; | 1206 | unsigned long holdtime; |
1301 | unsigned long now = jiffies; | 1207 | unsigned long now = jiffies; |
1302 | 1208 | ||
1303 | gl = gfs2_glock_find(sdp, name); | 1209 | gfs2_glock_hold(gl); |
1304 | if (!gl) | ||
1305 | return; | ||
1306 | |||
1307 | holdtime = gl->gl_tchange + gl->gl_ops->go_min_hold_time; | 1210 | holdtime = gl->gl_tchange + gl->gl_ops->go_min_hold_time; |
1308 | if (time_before(now, holdtime)) | 1211 | if (time_before(now, holdtime)) |
1309 | delay = holdtime - now; | 1212 | delay = holdtime - now; |
@@ -1317,74 +1220,33 @@ static void blocking_cb(struct gfs2_sbd *sdp, struct lm_lockname *name, | |||
1317 | gfs2_glock_put(gl); | 1220 | gfs2_glock_put(gl); |
1318 | } | 1221 | } |
1319 | 1222 | ||
1320 | static void gfs2_jdesc_make_dirty(struct gfs2_sbd *sdp, unsigned int jid) | ||
1321 | { | ||
1322 | struct gfs2_jdesc *jd; | ||
1323 | |||
1324 | spin_lock(&sdp->sd_jindex_spin); | ||
1325 | list_for_each_entry(jd, &sdp->sd_jindex_list, jd_list) { | ||
1326 | if (jd->jd_jid != jid) | ||
1327 | continue; | ||
1328 | jd->jd_dirty = 1; | ||
1329 | break; | ||
1330 | } | ||
1331 | spin_unlock(&sdp->sd_jindex_spin); | ||
1332 | } | ||
1333 | |||
1334 | /** | 1223 | /** |
1335 | * gfs2_glock_cb - Callback used by locking module | 1224 | * gfs2_glock_complete - Callback used by locking |
1336 | * @sdp: Pointer to the superblock | 1225 | * @gl: Pointer to the glock |
1337 | * @type: Type of callback | 1226 | * @ret: The return value from the dlm |
1338 | * @data: Type dependent data pointer | ||
1339 | * | 1227 | * |
1340 | * Called by the locking module when it wants to tell us something. | ||
1341 | * Either we need to drop a lock, one of our ASYNC requests completed, or | ||
1342 | * a journal from another client needs to be recovered. | ||
1343 | */ | 1228 | */ |
1344 | 1229 | ||
1345 | void gfs2_glock_cb(void *cb_data, unsigned int type, void *data) | 1230 | void gfs2_glock_complete(struct gfs2_glock *gl, int ret) |
1346 | { | 1231 | { |
1347 | struct gfs2_sbd *sdp = cb_data; | 1232 | struct lm_lockstruct *ls = &gl->gl_sbd->sd_lockstruct; |
1348 | 1233 | gl->gl_reply = ret; | |
1349 | switch (type) { | 1234 | if (unlikely(test_bit(DFL_BLOCK_LOCKS, &ls->ls_flags))) { |
1350 | case LM_CB_NEED_E: | 1235 | struct gfs2_holder *gh; |
1351 | blocking_cb(sdp, data, LM_ST_UNLOCKED); | 1236 | spin_lock(&gl->gl_spin); |
1352 | return; | 1237 | gh = find_first_waiter(gl); |
1353 | 1238 | if ((!(gh && (gh->gh_flags & LM_FLAG_NOEXP)) && | |
1354 | case LM_CB_NEED_D: | 1239 | (gl->gl_target != LM_ST_UNLOCKED)) || |
1355 | blocking_cb(sdp, data, LM_ST_DEFERRED); | 1240 | ((ret & ~LM_OUT_ST_MASK) != 0)) |
1356 | return; | 1241 | set_bit(GLF_FROZEN, &gl->gl_flags); |
1357 | 1242 | spin_unlock(&gl->gl_spin); | |
1358 | case LM_CB_NEED_S: | 1243 | if (test_bit(GLF_FROZEN, &gl->gl_flags)) |
1359 | blocking_cb(sdp, data, LM_ST_SHARED); | ||
1360 | return; | ||
1361 | |||
1362 | case LM_CB_ASYNC: { | ||
1363 | struct lm_async_cb *async = data; | ||
1364 | struct gfs2_glock *gl; | ||
1365 | |||
1366 | down_read(&gfs2_umount_flush_sem); | ||
1367 | gl = gfs2_glock_find(sdp, &async->lc_name); | ||
1368 | if (gfs2_assert_warn(sdp, gl)) | ||
1369 | return; | 1244 | return; |
1370 | gl->gl_reply = async->lc_ret; | ||
1371 | set_bit(GLF_REPLY_PENDING, &gl->gl_flags); | ||
1372 | if (queue_delayed_work(glock_workqueue, &gl->gl_work, 0) == 0) | ||
1373 | gfs2_glock_put(gl); | ||
1374 | up_read(&gfs2_umount_flush_sem); | ||
1375 | return; | ||
1376 | } | ||
1377 | |||
1378 | case LM_CB_NEED_RECOVERY: | ||
1379 | gfs2_jdesc_make_dirty(sdp, *(unsigned int *)data); | ||
1380 | if (sdp->sd_recoverd_process) | ||
1381 | wake_up_process(sdp->sd_recoverd_process); | ||
1382 | return; | ||
1383 | |||
1384 | default: | ||
1385 | gfs2_assert_warn(sdp, 0); | ||
1386 | return; | ||
1387 | } | 1245 | } |
1246 | set_bit(GLF_REPLY_PENDING, &gl->gl_flags); | ||
1247 | gfs2_glock_hold(gl); | ||
1248 | if (queue_delayed_work(glock_workqueue, &gl->gl_work, 0) == 0) | ||
1249 | gfs2_glock_put(gl); | ||
1388 | } | 1250 | } |
1389 | 1251 | ||
1390 | /** | 1252 | /** |
@@ -1515,6 +1377,25 @@ out: | |||
1515 | return has_entries; | 1377 | return has_entries; |
1516 | } | 1378 | } |
1517 | 1379 | ||
1380 | |||
1381 | /** | ||
1382 | * thaw_glock - thaw out a glock which has an unprocessed reply waiting | ||
1383 | * @gl: The glock to thaw | ||
1384 | * | ||
1385 | * N.B. When we freeze a glock, we leave a ref to the glock outstanding, | ||
1386 | * so this has to result in the ref count being dropped by one. | ||
1387 | */ | ||
1388 | |||
1389 | static void thaw_glock(struct gfs2_glock *gl) | ||
1390 | { | ||
1391 | if (!test_and_clear_bit(GLF_FROZEN, &gl->gl_flags)) | ||
1392 | return; | ||
1393 | set_bit(GLF_REPLY_PENDING, &gl->gl_flags); | ||
1394 | gfs2_glock_hold(gl); | ||
1395 | if (queue_delayed_work(glock_workqueue, &gl->gl_work, 0) == 0) | ||
1396 | gfs2_glock_put(gl); | ||
1397 | } | ||
1398 | |||
1518 | /** | 1399 | /** |
1519 | * clear_glock - look at a glock and see if we can free it from glock cache | 1400 | * clear_glock - look at a glock and see if we can free it from glock cache |
1520 | * @gl: the glock to look at | 1401 | * @gl: the glock to look at |
@@ -1540,6 +1421,20 @@ static void clear_glock(struct gfs2_glock *gl) | |||
1540 | } | 1421 | } |
1541 | 1422 | ||
1542 | /** | 1423 | /** |
1424 | * gfs2_glock_thaw - Thaw any frozen glocks | ||
1425 | * @sdp: The super block | ||
1426 | * | ||
1427 | */ | ||
1428 | |||
1429 | void gfs2_glock_thaw(struct gfs2_sbd *sdp) | ||
1430 | { | ||
1431 | unsigned x; | ||
1432 | |||
1433 | for (x = 0; x < GFS2_GL_HASH_SIZE; x++) | ||
1434 | examine_bucket(thaw_glock, sdp, x); | ||
1435 | } | ||
1436 | |||
1437 | /** | ||
1543 | * gfs2_gl_hash_clear - Empty out the glock hash table | 1438 | * gfs2_gl_hash_clear - Empty out the glock hash table |
1544 | * @sdp: the filesystem | 1439 | * @sdp: the filesystem |
1545 | * @wait: wait until it's all gone | 1440 | * @wait: wait until it's all gone |
@@ -1619,7 +1514,7 @@ static const char *hflags2str(char *buf, unsigned flags, unsigned long iflags) | |||
1619 | if (flags & LM_FLAG_NOEXP) | 1514 | if (flags & LM_FLAG_NOEXP) |
1620 | *p++ = 'e'; | 1515 | *p++ = 'e'; |
1621 | if (flags & LM_FLAG_ANY) | 1516 | if (flags & LM_FLAG_ANY) |
1622 | *p++ = 'a'; | 1517 | *p++ = 'A'; |
1623 | if (flags & LM_FLAG_PRIORITY) | 1518 | if (flags & LM_FLAG_PRIORITY) |
1624 | *p++ = 'p'; | 1519 | *p++ = 'p'; |
1625 | if (flags & GL_ASYNC) | 1520 | if (flags & GL_ASYNC) |
@@ -1683,6 +1578,10 @@ static const char *gflags2str(char *buf, const unsigned long *gflags) | |||
1683 | *p++ = 'i'; | 1578 | *p++ = 'i'; |
1684 | if (test_bit(GLF_REPLY_PENDING, gflags)) | 1579 | if (test_bit(GLF_REPLY_PENDING, gflags)) |
1685 | *p++ = 'r'; | 1580 | *p++ = 'r'; |
1581 | if (test_bit(GLF_INITIAL, gflags)) | ||
1582 | *p++ = 'I'; | ||
1583 | if (test_bit(GLF_FROZEN, gflags)) | ||
1584 | *p++ = 'F'; | ||
1686 | *p = 0; | 1585 | *p = 0; |
1687 | return buf; | 1586 | return buf; |
1688 | } | 1587 | } |
@@ -1717,14 +1616,13 @@ static int __dump_glock(struct seq_file *seq, const struct gfs2_glock *gl) | |||
1717 | dtime *= 1000000/HZ; /* demote time in uSec */ | 1616 | dtime *= 1000000/HZ; /* demote time in uSec */ |
1718 | if (!test_bit(GLF_DEMOTE, &gl->gl_flags)) | 1617 | if (!test_bit(GLF_DEMOTE, &gl->gl_flags)) |
1719 | dtime = 0; | 1618 | dtime = 0; |
1720 | gfs2_print_dbg(seq, "G: s:%s n:%u/%llu f:%s t:%s d:%s/%llu l:%d a:%d r:%d\n", | 1619 | gfs2_print_dbg(seq, "G: s:%s n:%u/%llu f:%s t:%s d:%s/%llu a:%d r:%d\n", |
1721 | state2str(gl->gl_state), | 1620 | state2str(gl->gl_state), |
1722 | gl->gl_name.ln_type, | 1621 | gl->gl_name.ln_type, |
1723 | (unsigned long long)gl->gl_name.ln_number, | 1622 | (unsigned long long)gl->gl_name.ln_number, |
1724 | gflags2str(gflags_buf, &gl->gl_flags), | 1623 | gflags2str(gflags_buf, &gl->gl_flags), |
1725 | state2str(gl->gl_target), | 1624 | state2str(gl->gl_target), |
1726 | state2str(gl->gl_demote_state), dtime, | 1625 | state2str(gl->gl_demote_state), dtime, |
1727 | atomic_read(&gl->gl_lvb_count), | ||
1728 | atomic_read(&gl->gl_ail_count), | 1626 | atomic_read(&gl->gl_ail_count), |
1729 | atomic_read(&gl->gl_ref)); | 1627 | atomic_read(&gl->gl_ref)); |
1730 | 1628 | ||