Lines Matching refs:sdp
35 static void gfs2_log_shutdown(struct gfs2_sbd *sdp);
39 * @sdp: the filesystem
48 unsigned int gfs2_struct2blk(struct gfs2_sbd *sdp, unsigned int nstruct)
55 first = sdp->sd_ldptrs;
59 second = sdp->sd_inptrs;
94 * @sdp: The superblock
100 static int gfs2_ail1_start_one(struct gfs2_sbd *sdp,
103 __releases(&sdp->sd_ail_lock)
104 __acquires(&sdp->sd_ail_lock)
115 gfs2_assert(sdp, bd->bd_tr == tr);
123 if (!cmpxchg(&sdp->sd_log_error, 0, -EIO)) {
124 gfs2_io_error_bh(sdp, bh);
125 gfs2_withdraw_delayed(sdp);
129 if (gfs2_withdrawing_or_withdrawn(sdp)) {
142 spin_unlock(&sdp->sd_ail_lock);
149 spin_lock(&sdp->sd_ail_lock);
160 static void dump_ail_list(struct gfs2_sbd *sdp)
166 list_for_each_entry_reverse(tr, &sdp->sd_ail1_list, tr_list) {
170 fs_err(sdp, "bd %p: blk:0x%llx bh=%p ", bd,
173 fs_err(sdp, "\n");
176 fs_err(sdp, "0x%llx up2:%d dirt:%d lkd:%d req:%d "
194 * @sdp: The super block
201 void gfs2_ail1_flush(struct gfs2_sbd *sdp, struct writeback_control *wbc)
203 struct list_head *head = &sdp->sd_ail1_list;
209 trace_gfs2_ail_flush(sdp, wbc, 1);
211 spin_lock(&sdp->sd_ail_lock);
215 fs_err(sdp, "Error: In %s for ten minutes! t=%d\n",
217 dump_ail_list(sdp);
223 ret = gfs2_ail1_start_one(sdp, wbc, tr, &plug);
231 spin_unlock(&sdp->sd_ail_lock);
234 gfs2_lm(sdp, "gfs2_ail1_start_one returned: %d\n", ret);
235 gfs2_withdraw(sdp);
237 trace_gfs2_ail_flush(sdp, wbc, 0);
242 * @sdp: The superblock
245 static void gfs2_ail1_start(struct gfs2_sbd *sdp)
254 return gfs2_ail1_flush(sdp, &wbc);
257 static void gfs2_log_update_flush_tail(struct gfs2_sbd *sdp)
259 unsigned int new_flush_tail = sdp->sd_log_head;
262 if (!list_empty(&sdp->sd_ail1_list)) {
263 tr = list_last_entry(&sdp->sd_ail1_list,
267 sdp->sd_log_flush_tail = new_flush_tail;
270 static void gfs2_log_update_head(struct gfs2_sbd *sdp)
272 unsigned int new_head = sdp->sd_log_flush_head;
274 if (sdp->sd_log_flush_tail == sdp->sd_log_head)
275 sdp->sd_log_flush_tail = new_head;
276 sdp->sd_log_head = new_head;
283 static void gfs2_ail_empty_tr(struct gfs2_sbd *sdp, struct gfs2_trans *tr,
291 gfs2_assert(sdp, bd->bd_tr == tr);
298 * @sdp: the filesystem
305 static int gfs2_ail1_empty_one(struct gfs2_sbd *sdp, struct gfs2_trans *tr,
315 gfs2_assert(sdp, bd->bd_tr == tr);
325 if (!sdp->sd_log_error && buffer_busy(bh)) {
330 !cmpxchg(&sdp->sd_log_error, 0, -EIO)) {
331 gfs2_io_error_bh(sdp, bh);
332 gfs2_withdraw_delayed(sdp);
341 gfs2_add_revoke(sdp, bd);
352 * @sdp: The superblock
359 static bool gfs2_ail1_empty(struct gfs2_sbd *sdp, int max_revokes)
365 spin_lock(&sdp->sd_ail_lock);
366 list_for_each_entry_safe_reverse(tr, s, &sdp->sd_ail1_list, tr_list) {
367 if (!gfs2_ail1_empty_one(sdp, tr, &max_revokes) && oldest_tr)
368 list_move(&tr->tr_list, &sdp->sd_ail2_list);
372 gfs2_log_update_flush_tail(sdp);
373 empty = list_empty(&sdp->sd_ail1_list);
374 spin_unlock(&sdp->sd_ail_lock);
379 static void gfs2_ail1_wait(struct gfs2_sbd *sdp)
385 spin_lock(&sdp->sd_ail_lock);
386 list_for_each_entry_reverse(tr, &sdp->sd_ail1_list, tr_list) {
392 spin_unlock(&sdp->sd_ail_lock);
398 spin_unlock(&sdp->sd_ail_lock);
401 static void __ail2_empty(struct gfs2_sbd *sdp, struct gfs2_trans *tr)
403 gfs2_ail_empty_tr(sdp, tr, &tr->tr_ail2_list);
405 gfs2_assert_warn(sdp, list_empty(&tr->tr_ail1_list));
406 gfs2_assert_warn(sdp, list_empty(&tr->tr_ail2_list));
407 gfs2_trans_free(sdp, tr);
410 static void ail2_empty(struct gfs2_sbd *sdp, unsigned int new_tail)
412 struct list_head *ail2_list = &sdp->sd_ail2_list;
413 unsigned int old_tail = sdp->sd_log_tail;
416 spin_lock(&sdp->sd_ail_lock);
420 __ail2_empty(sdp, tr);
425 __ail2_empty(sdp, tr);
428 spin_unlock(&sdp->sd_ail_lock);
433 * @sdp: The GFS2 superblock
436 bool gfs2_log_is_empty(struct gfs2_sbd *sdp) {
437 return atomic_read(&sdp->sd_log_blks_free) == sdp->sd_jdesc->jd_blocks;
440 static bool __gfs2_log_try_reserve_revokes(struct gfs2_sbd *sdp, unsigned int revokes)
444 available = atomic_read(&sdp->sd_log_revokes_available);
446 if (atomic_try_cmpxchg(&sdp->sd_log_revokes_available,
455 * @sdp: The GFS2 superblock
458 * sdp->sd_log_flush_lock must be held.
460 void gfs2_log_release_revokes(struct gfs2_sbd *sdp, unsigned int revokes)
463 atomic_add(revokes, &sdp->sd_log_revokes_available);
468 * @sdp: The GFS2 superblock
473 void gfs2_log_release(struct gfs2_sbd *sdp, unsigned int blks)
475 atomic_add(blks, &sdp->sd_log_blks_free);
476 trace_gfs2_log_blocks(sdp, blks);
477 gfs2_assert_withdraw(sdp, atomic_read(&sdp->sd_log_blks_free) <=
478 sdp->sd_jdesc->jd_blocks);
479 if (atomic_read(&sdp->sd_log_blks_needed))
480 wake_up(&sdp->sd_log_waitq);
485 * @sdp: The GFS2 superblock
492 static bool __gfs2_log_try_reserve(struct gfs2_sbd *sdp, unsigned int blks,
498 free_blocks = atomic_read(&sdp->sd_log_blks_free);
500 if (atomic_try_cmpxchg(&sdp->sd_log_blks_free, &free_blocks,
502 trace_gfs2_log_blocks(sdp, -blks);
511 * @sdp: The GFS2 superblock
528 static void __gfs2_log_reserve(struct gfs2_sbd *sdp, unsigned int blks,
534 atomic_add(blks, &sdp->sd_log_blks_needed);
536 if (current != sdp->sd_logd_process)
537 wake_up(&sdp->sd_logd_waitq);
538 io_wait_event(sdp->sd_log_waitq,
539 (free_blocks = atomic_read(&sdp->sd_log_blks_free),
542 if (atomic_try_cmpxchg(&sdp->sd_log_blks_free,
550 trace_gfs2_log_blocks(sdp, -blks);
551 if (atomic_sub_return(blks, &sdp->sd_log_blks_needed))
552 wake_up(&sdp->sd_log_waitq);
557 * @sdp: The GFS2 superblock
561 * This is similar to gfs2_log_reserve, but sdp->sd_log_flush_lock must be
565 bool gfs2_log_try_reserve(struct gfs2_sbd *sdp, struct gfs2_trans *tr,
573 if (revokes && !__gfs2_log_try_reserve_revokes(sdp, revokes)) {
574 revoke_blks = DIV_ROUND_UP(revokes, sdp->sd_inptrs);
575 *extra_revokes = revoke_blks * sdp->sd_inptrs - revokes;
580 if (__gfs2_log_try_reserve(sdp, blks, GFS2_LOG_FLUSH_MIN_BLOCKS))
583 gfs2_log_release_revokes(sdp, revokes);
589 * @sdp: The GFS2 superblock
593 * sdp->sd_log_flush_lock must not be held.
596 void gfs2_log_reserve(struct gfs2_sbd *sdp, struct gfs2_trans *tr,
605 revoke_blks = DIV_ROUND_UP(revokes, sdp->sd_inptrs);
606 *extra_revokes = revoke_blks * sdp->sd_inptrs - revokes;
609 __gfs2_log_reserve(sdp, blks, GFS2_LOG_FLUSH_MIN_BLOCKS);
614 * @sdp: The GFS2 superblock
624 static inline unsigned int log_distance(struct gfs2_sbd *sdp, unsigned int newer,
631 dist += sdp->sd_jdesc->jd_blocks;
638 * @sdp: The GFS2 superblock
657 static unsigned int calc_reserved(struct gfs2_sbd *sdp)
661 struct gfs2_trans *tr = sdp->sd_log_tr;
665 reserved += blocks + DIV_ROUND_UP(blocks, buf_limit(sdp));
667 reserved += blocks + DIV_ROUND_UP(blocks, databuf_limit(sdp));
672 static void log_pull_tail(struct gfs2_sbd *sdp)
674 unsigned int new_tail = sdp->sd_log_flush_tail;
677 if (new_tail == sdp->sd_log_tail)
679 dist = log_distance(sdp, new_tail, sdp->sd_log_tail);
680 ail2_empty(sdp, new_tail);
681 gfs2_log_release(sdp, dist);
682 sdp->sd_log_tail = new_tail;
686 void log_flush_wait(struct gfs2_sbd *sdp)
690 if (atomic_read(&sdp->sd_log_in_flight)) {
692 prepare_to_wait(&sdp->sd_log_flush_wait, &wait,
694 if (atomic_read(&sdp->sd_log_in_flight))
696 } while(atomic_read(&sdp->sd_log_in_flight));
697 finish_wait(&sdp->sd_log_flush_wait, &wait);
721 static void gfs2_ordered_write(struct gfs2_sbd *sdp)
726 spin_lock(&sdp->sd_ordered_lock);
727 list_sort(NULL, &sdp->sd_log_ordered, &ip_cmp);
728 while (!list_empty(&sdp->sd_log_ordered)) {
729 ip = list_first_entry(&sdp->sd_log_ordered, struct gfs2_inode, i_ordered);
735 spin_unlock(&sdp->sd_ordered_lock);
737 spin_lock(&sdp->sd_ordered_lock);
739 list_splice(&written, &sdp->sd_log_ordered);
740 spin_unlock(&sdp->sd_ordered_lock);
743 static void gfs2_ordered_wait(struct gfs2_sbd *sdp)
747 spin_lock(&sdp->sd_ordered_lock);
748 while (!list_empty(&sdp->sd_log_ordered)) {
749 ip = list_first_entry(&sdp->sd_log_ordered, struct gfs2_inode, i_ordered);
753 spin_unlock(&sdp->sd_ordered_lock);
755 spin_lock(&sdp->sd_ordered_lock);
757 spin_unlock(&sdp->sd_ordered_lock);
762 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
764 spin_lock(&sdp->sd_ordered_lock);
766 spin_unlock(&sdp->sd_ordered_lock);
769 void gfs2_add_revoke(struct gfs2_sbd *sdp, struct gfs2_bufdata *bd)
774 sdp->sd_log_num_revoke++;
782 list_add(&bd->bd_list, &sdp->sd_log_revokes);
795 * @sdp: The GFS2 superblock
805 void gfs2_flush_revokes(struct gfs2_sbd *sdp)
808 unsigned int max_revokes = atomic_read(&sdp->sd_log_revokes_available);
810 gfs2_log_lock(sdp);
811 gfs2_ail1_empty(sdp, max_revokes);
812 gfs2_log_unlock(sdp);
814 if (gfs2_withdrawing(sdp))
815 gfs2_withdraw(sdp);
820 * @sdp: The GFS2 superblock
831 void gfs2_write_log_header(struct gfs2_sbd *sdp, struct gfs2_jdesc *jd,
838 struct gfs2_statfs_change_host *l_sc = &sdp->sd_statfs_local;
840 struct super_block *sb = sdp->sd_vfs;
843 if (gfs2_withdrawing_or_withdrawn(sdp))
854 lh->lh_header.mh_jid = cpu_to_be32(sdp->sd_jdesc->jd_jid);
873 if (gfs2_assert_withdraw(sdp, ret == 0))
884 cpu_to_be64(GFS2_I(sdp->sd_sc_inode)->i_no_addr);
886 cpu_to_be64(GFS2_I(sdp->sd_qc_inode)->i_no_addr);
888 spin_lock(&sdp->sd_statfs_spin);
892 spin_unlock(&sdp->sd_statfs_spin);
901 gfs2_log_write(sdp, jd, page, sb->s_blocksize, 0, dblock);
907 * @sdp: The GFS2 superblock
913 static void log_write_header(struct gfs2_sbd *sdp, u32 flags)
916 struct super_block *sb = sdp->sd_vfs;
918 gfs2_assert_withdraw(sdp, sb->s_writers.frozen != SB_FREEZE_COMPLETE);
920 if (test_bit(SDF_NOBARRIERS, &sdp->sd_flags)) {
921 gfs2_ordered_wait(sdp);
922 log_flush_wait(sdp);
925 sdp->sd_log_idle = (sdp->sd_log_flush_tail == sdp->sd_log_flush_head);
926 gfs2_write_log_header(sdp, sdp->sd_jdesc, sdp->sd_log_sequence++,
927 sdp->sd_log_flush_tail, sdp->sd_log_flush_head,
929 gfs2_log_incr_head(sdp);
930 log_flush_wait(sdp);
931 log_pull_tail(sdp);
932 gfs2_log_update_head(sdp);
937 * @sdp: Pointer to GFS2 superblock
939 void gfs2_ail_drain(struct gfs2_sbd *sdp)
943 spin_lock(&sdp->sd_ail_lock);
951 while (!list_empty(&sdp->sd_ail1_list)) {
952 tr = list_first_entry(&sdp->sd_ail1_list, struct gfs2_trans,
954 gfs2_ail_empty_tr(sdp, tr, &tr->tr_ail1_list);
955 gfs2_ail_empty_tr(sdp, tr, &tr->tr_ail2_list);
957 gfs2_trans_free(sdp, tr);
959 while (!list_empty(&sdp->sd_ail2_list)) {
960 tr = list_first_entry(&sdp->sd_ail2_list, struct gfs2_trans,
962 gfs2_ail_empty_tr(sdp, tr, &tr->tr_ail2_list);
964 gfs2_trans_free(sdp, tr);
966 gfs2_drain_revokes(sdp);
967 spin_unlock(&sdp->sd_ail_lock);
972 * @sdp: Pointer to GFS2 superblock
974 static void empty_ail1_list(struct gfs2_sbd *sdp)
981 fs_err(sdp, "Error: In %s for 10 minutes! t=%d\n",
983 dump_ail_list(sdp);
986 gfs2_ail1_start(sdp);
987 gfs2_ail1_wait(sdp);
988 empty = gfs2_ail1_empty(sdp, 0);
990 if (gfs2_withdrawing_or_withdrawn(sdp))
994 if (gfs2_withdrawing(sdp))
995 gfs2_withdraw(sdp);
1034 * @sdp: The filesystem
1040 void gfs2_log_flush(struct gfs2_sbd *sdp, struct gfs2_glock *gl, u32 flags)
1044 bool frozen = test_bit(SDF_FROZEN, &sdp->sd_flags);
1048 down_write(&sdp->sd_log_flush_lock);
1049 trace_gfs2_log_flush(sdp, 1, flags);
1056 if (gfs2_withdrawing_or_withdrawn(sdp) ||
1057 !test_bit(SDF_JOURNAL_LIVE, &sdp->sd_flags))
1064 first_log_head = sdp->sd_log_head;
1065 sdp->sd_log_flush_head = first_log_head;
1067 tr = sdp->sd_log_tr;
1068 if (tr || sdp->sd_log_num_revoke) {
1070 gfs2_log_release(sdp, reserved_blocks);
1071 reserved_blocks = sdp->sd_log_blks_reserved;
1072 reserved_revokes = sdp->sd_log_num_revoke;
1074 sdp->sd_log_tr = NULL;
1077 if (gfs2_assert_withdraw_delayed(sdp,
1086 if (current == sdp->sd_logd_process)
1089 if (!__gfs2_log_try_reserve(sdp, reserved_blocks, taboo_blocks)) {
1090 up_write(&sdp->sd_log_flush_lock);
1091 __gfs2_log_reserve(sdp, reserved_blocks, taboo_blocks);
1092 down_write(&sdp->sd_log_flush_lock);
1095 BUG_ON(sdp->sd_log_num_revoke);
1099 clear_bit(SDF_JOURNAL_LIVE, &sdp->sd_flags);
1102 if (gfs2_assert_withdraw_delayed(sdp, !reserved_revokes))
1105 gfs2_ordered_write(sdp);
1106 if (gfs2_withdrawing_or_withdrawn(sdp))
1108 lops_before_commit(sdp, tr);
1109 if (gfs2_withdrawing_or_withdrawn(sdp))
1111 gfs2_log_submit_bio(&sdp->sd_jdesc->jd_log_bio, REQ_OP_WRITE);
1112 if (gfs2_withdrawing_or_withdrawn(sdp))
1115 if (sdp->sd_log_head != sdp->sd_log_flush_head) {
1116 log_write_header(sdp, flags);
1117 } else if (sdp->sd_log_tail != sdp->sd_log_flush_tail && !sdp->sd_log_idle) {
1118 log_write_header(sdp, flags);
1120 if (gfs2_withdrawing_or_withdrawn(sdp))
1122 lops_after_commit(sdp, tr);
1124 gfs2_log_lock(sdp);
1125 sdp->sd_log_blks_reserved = 0;
1127 spin_lock(&sdp->sd_ail_lock);
1129 list_add(&tr->tr_list, &sdp->sd_ail1_list);
1132 spin_unlock(&sdp->sd_ail_lock);
1133 gfs2_log_unlock(sdp);
1136 if (!sdp->sd_log_idle) {
1137 empty_ail1_list(sdp);
1138 if (gfs2_withdrawing_or_withdrawn(sdp))
1140 log_write_header(sdp, flags);
1144 gfs2_log_shutdown(sdp);
1148 used_blocks = log_distance(sdp, sdp->sd_log_flush_head, first_log_head);
1149 reserved_revokes += atomic_read(&sdp->sd_log_revokes_available);
1150 atomic_set(&sdp->sd_log_revokes_available, sdp->sd_ldptrs);
1151 gfs2_assert_withdraw(sdp, reserved_revokes % sdp->sd_inptrs == sdp->sd_ldptrs);
1152 if (reserved_revokes > sdp->sd_ldptrs)
1153 reserved_blocks += (reserved_revokes - sdp->sd_ldptrs) / sdp->sd_inptrs;
1156 gfs2_assert_withdraw_delayed(sdp, used_blocks < reserved_blocks);
1157 gfs2_log_release(sdp, reserved_blocks - used_blocks);
1159 up_write(&sdp->sd_log_flush_lock);
1160 gfs2_trans_free(sdp, tr);
1161 if (gfs2_withdrawing(sdp))
1162 gfs2_withdraw(sdp);
1163 trace_gfs2_log_flush(sdp, 0, flags);
1174 spin_lock(&sdp->sd_ail_lock);
1176 list_add(&tr->tr_list, &sdp->sd_ail1_list);
1177 spin_unlock(&sdp->sd_ail_lock);
1184 * @sdp: the filesystem
1188 static void gfs2_merge_trans(struct gfs2_sbd *sdp, struct gfs2_trans *new)
1190 struct gfs2_trans *old = sdp->sd_log_tr;
1204 spin_lock(&sdp->sd_ail_lock);
1207 spin_unlock(&sdp->sd_ail_lock);
1210 static void log_refund(struct gfs2_sbd *sdp, struct gfs2_trans *tr)
1216 gfs2_log_lock(sdp);
1218 if (sdp->sd_log_tr) {
1219 gfs2_merge_trans(sdp, tr);
1221 gfs2_assert_withdraw(sdp, !test_bit(TR_ONSTACK, &tr->tr_flags));
1222 sdp->sd_log_tr = tr;
1226 reserved = calc_reserved(sdp);
1227 maxres = sdp->sd_log_blks_reserved + tr->tr_reserved;
1228 gfs2_assert_withdraw(sdp, maxres >= reserved);
1231 gfs2_log_release(sdp, unused);
1232 sdp->sd_log_blks_reserved = reserved;
1234 gfs2_log_unlock(sdp);
1237 static inline int gfs2_jrnl_flush_reqd(struct gfs2_sbd *sdp)
1239 return atomic_read(&sdp->sd_log_pinned) +
1240 atomic_read(&sdp->sd_log_blks_needed) >=
1241 atomic_read(&sdp->sd_log_thresh1);
1244 static inline int gfs2_ail_flush_reqd(struct gfs2_sbd *sdp)
1246 return sdp->sd_jdesc->jd_blocks -
1247 atomic_read(&sdp->sd_log_blks_free) +
1248 atomic_read(&sdp->sd_log_blks_needed) >=
1249 atomic_read(&sdp->sd_log_thresh2);
1254 * @sdp: the filesystem
1267 void gfs2_log_commit(struct gfs2_sbd *sdp, struct gfs2_trans *tr)
1269 log_refund(sdp, tr);
1271 if (gfs2_ail_flush_reqd(sdp) || gfs2_jrnl_flush_reqd(sdp))
1272 wake_up(&sdp->sd_logd_waitq);
1277 * @sdp: the filesystem
1281 static void gfs2_log_shutdown(struct gfs2_sbd *sdp)
1283 gfs2_assert_withdraw(sdp, !sdp->sd_log_blks_reserved);
1284 gfs2_assert_withdraw(sdp, !sdp->sd_log_num_revoke);
1285 gfs2_assert_withdraw(sdp, list_empty(&sdp->sd_ail1_list));
1287 log_write_header(sdp, GFS2_LOG_HEAD_UNMOUNT | GFS2_LFC_SHUTDOWN);
1288 log_pull_tail(sdp);
1290 gfs2_assert_warn(sdp, sdp->sd_log_head == sdp->sd_log_tail);
1291 gfs2_assert_warn(sdp, list_empty(&sdp->sd_ail2_list));
1304 struct gfs2_sbd *sdp = data;
1309 if (gfs2_withdrawing_or_withdrawn(sdp))
1313 if (sdp->sd_log_error) {
1314 gfs2_lm(sdp,
1318 sdp->sd_fsname, sdp->sd_log_error);
1319 gfs2_withdraw(sdp);
1323 if (gfs2_jrnl_flush_reqd(sdp) || t == 0) {
1324 gfs2_ail1_empty(sdp, 0);
1325 gfs2_log_flush(sdp, NULL, GFS2_LOG_HEAD_FLUSH_NORMAL |
1329 if (test_bit(SDF_FORCE_AIL_FLUSH, &sdp->sd_flags) ||
1330 gfs2_ail_flush_reqd(sdp)) {
1331 clear_bit(SDF_FORCE_AIL_FLUSH, &sdp->sd_flags);
1332 gfs2_ail1_start(sdp);
1333 gfs2_ail1_wait(sdp);
1334 gfs2_ail1_empty(sdp, 0);
1335 gfs2_log_flush(sdp, NULL, GFS2_LOG_HEAD_FLUSH_NORMAL |
1339 t = gfs2_tune_get(sdp, gt_logd_secs) * HZ;
1341 t = wait_event_freezable_timeout(sdp->sd_logd_waitq,
1342 test_bit(SDF_FORCE_AIL_FLUSH, &sdp->sd_flags) ||
1343 gfs2_ail_flush_reqd(sdp) ||
1344 gfs2_jrnl_flush_reqd(sdp) ||
1345 sdp->sd_log_error ||
1346 gfs2_withdrawing_or_withdrawn(sdp) ||
1351 if (gfs2_withdrawing(sdp))
1352 gfs2_withdraw(sdp);