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)
54 first = sdp->sd_ldptrs;
57 second = sdp->sd_inptrs;
84 * @sdp: the filesystem
90 static int gfs2_ail1_start_one(struct gfs2_sbd *sdp,
93 __releases(&sdp->sd_ail_lock)
94 __acquires(&sdp->sd_ail_lock)
105 gfs2_assert(sdp, bd->bd_tr == tr);
113 if (!cmpxchg(&sdp->sd_log_error, 0, -EIO)) {
114 gfs2_io_error_bh(sdp, bh);
115 gfs2_withdraw_delayed(sdp);
119 if (gfs2_withdrawn(sdp)) {
132 spin_unlock(&sdp->sd_ail_lock);
134 spin_lock(&sdp->sd_ail_lock);
145 static void dump_ail_list(struct gfs2_sbd *sdp)
151 list_for_each_entry_reverse(tr, &sdp->sd_ail1_list, tr_list) {
155 fs_err(sdp, "bd %p: blk:0x%llx bh=%p ", bd,
158 fs_err(sdp, "\n");
161 fs_err(sdp, "0x%llx up2:%d dirt:%d lkd:%d req:%d "
179 * @sdp: The super block
186 void gfs2_ail1_flush(struct gfs2_sbd *sdp, struct writeback_control *wbc)
188 struct list_head *head = &sdp->sd_ail1_list;
194 trace_gfs2_ail_flush(sdp, wbc, 1);
196 spin_lock(&sdp->sd_ail_lock);
200 fs_err(sdp, "Error: In %s for ten minutes! t=%d\n",
202 dump_ail_list(sdp);
208 ret = gfs2_ail1_start_one(sdp, wbc, tr);
216 spin_unlock(&sdp->sd_ail_lock);
219 gfs2_lm(sdp, "gfs2_ail1_start_one (generic_writepages) "
221 gfs2_withdraw(sdp);
223 trace_gfs2_ail_flush(sdp, wbc, 0);
228 * @sdp: The superblock
231 static void gfs2_ail1_start(struct gfs2_sbd *sdp)
240 return gfs2_ail1_flush(sdp, &wbc);
245 * @sdp: the filesystem
252 static int gfs2_ail1_empty_one(struct gfs2_sbd *sdp, struct gfs2_trans *tr,
262 gfs2_assert(sdp, bd->bd_tr == tr);
272 if (!sdp->sd_log_error && buffer_busy(bh)) {
277 !cmpxchg(&sdp->sd_log_error, 0, -EIO)) {
278 gfs2_io_error_bh(sdp, bh);
279 gfs2_withdraw_delayed(sdp);
288 gfs2_add_revoke(sdp, bd);
299 * @sdp: The superblock
305 static int gfs2_ail1_empty(struct gfs2_sbd *sdp, int max_revokes)
311 spin_lock(&sdp->sd_ail_lock);
312 list_for_each_entry_safe_reverse(tr, s, &sdp->sd_ail1_list, tr_list) {
313 if (!gfs2_ail1_empty_one(sdp, tr, &max_revokes) && oldest_tr)
314 list_move(&tr->tr_list, &sdp->sd_ail2_list);
318 ret = list_empty(&sdp->sd_ail1_list);
319 spin_unlock(&sdp->sd_ail_lock);
321 if (test_bit(SDF_WITHDRAWING, &sdp->sd_flags)) {
322 gfs2_lm(sdp, "fatal: I/O error(s)\n");
323 gfs2_withdraw(sdp);
329 static void gfs2_ail1_wait(struct gfs2_sbd *sdp)
335 spin_lock(&sdp->sd_ail_lock);
336 list_for_each_entry_reverse(tr, &sdp->sd_ail1_list, tr_list) {
342 spin_unlock(&sdp->sd_ail_lock);
348 spin_unlock(&sdp->sd_ail_lock);
355 static void gfs2_ail_empty_tr(struct gfs2_sbd *sdp, struct gfs2_trans *tr,
363 gfs2_assert(sdp, bd->bd_tr == tr);
368 static void ail2_empty(struct gfs2_sbd *sdp, unsigned int new_tail)
371 unsigned int old_tail = sdp->sd_log_tail;
375 spin_lock(&sdp->sd_ail_lock);
377 list_for_each_entry_safe(tr, safe, &sdp->sd_ail2_list, tr_list) {
384 gfs2_ail_empty_tr(sdp, tr, &tr->tr_ail2_list);
386 gfs2_assert_warn(sdp, list_empty(&tr->tr_ail1_list));
387 gfs2_assert_warn(sdp, list_empty(&tr->tr_ail2_list));
388 gfs2_trans_free(sdp, tr);
391 spin_unlock(&sdp->sd_ail_lock);
396 * @sdp: The GFS2 superblock
401 void gfs2_log_release(struct gfs2_sbd *sdp, unsigned int blks)
404 atomic_add(blks, &sdp->sd_log_blks_free);
405 trace_gfs2_log_blocks(sdp, blks);
406 gfs2_assert_withdraw(sdp, atomic_read(&sdp->sd_log_blks_free) <=
407 sdp->sd_jdesc->jd_blocks);
408 up_read(&sdp->sd_log_flush_lock);
413 * @sdp: The GFS2 superblock
431 int gfs2_log_reserve(struct gfs2_sbd *sdp, unsigned int blks)
434 unsigned reserved_blks = 7 * (4096 / sdp->sd_vfs->s_blocksize);
440 if (gfs2_assert_warn(sdp, blks) ||
441 gfs2_assert_warn(sdp, blks <= sdp->sd_jdesc->jd_blocks))
443 atomic_add(blks, &sdp->sd_log_blks_needed);
445 free_blocks = atomic_read(&sdp->sd_log_blks_free);
448 prepare_to_wait_exclusive(&sdp->sd_log_waitq, &wait,
450 wake_up(&sdp->sd_logd_waitq);
452 if (atomic_read(&sdp->sd_log_blks_free) <= wanted)
454 free_blocks = atomic_read(&sdp->sd_log_blks_free);
456 finish_wait(&sdp->sd_log_waitq, &wait);
458 atomic_inc(&sdp->sd_reserving_log);
459 if (atomic_cmpxchg(&sdp->sd_log_blks_free, free_blocks,
461 if (atomic_dec_and_test(&sdp->sd_reserving_log))
462 wake_up(&sdp->sd_reserving_log_wait);
465 atomic_sub(blks, &sdp->sd_log_blks_needed);
466 trace_gfs2_log_blocks(sdp, -blks);
473 wake_up(&sdp->sd_log_waitq);
475 down_read(&sdp->sd_log_flush_lock);
476 if (unlikely(!test_bit(SDF_JOURNAL_LIVE, &sdp->sd_flags))) {
477 gfs2_log_release(sdp, blks);
480 if (atomic_dec_and_test(&sdp->sd_reserving_log))
481 wake_up(&sdp->sd_reserving_log_wait);
487 * @sdp: The GFS2 superblock
497 static inline unsigned int log_distance(struct gfs2_sbd *sdp, unsigned int newer,
504 dist += sdp->sd_jdesc->jd_blocks;
512 * @sdp: The GFS2 superblock
534 static unsigned int calc_reserved(struct gfs2_sbd *sdp)
539 struct gfs2_trans *tr = sdp->sd_log_tr;
546 reserved += DIV_ROUND_UP(mbuf, buf_limit(sdp));
547 reserved += DIV_ROUND_UP(dbuf, databuf_limit(sdp));
550 if (sdp->sd_log_committed_revoke > 0)
551 reserved += gfs2_struct2blk(sdp, sdp->sd_log_committed_revoke);
558 static unsigned int current_tail(struct gfs2_sbd *sdp)
563 spin_lock(&sdp->sd_ail_lock);
565 if (list_empty(&sdp->sd_ail1_list)) {
566 tail = sdp->sd_log_head;
568 tr = list_last_entry(&sdp->sd_ail1_list, struct gfs2_trans,
573 spin_unlock(&sdp->sd_ail_lock);
578 static void log_pull_tail(struct gfs2_sbd *sdp, unsigned int new_tail)
580 unsigned int dist = log_distance(sdp, new_tail, sdp->sd_log_tail);
582 ail2_empty(sdp, new_tail);
584 atomic_add(dist, &sdp->sd_log_blks_free);
585 trace_gfs2_log_blocks(sdp, dist);
586 gfs2_assert_withdraw(sdp, atomic_read(&sdp->sd_log_blks_free) <=
587 sdp->sd_jdesc->jd_blocks);
589 sdp->sd_log_tail = new_tail;
593 void log_flush_wait(struct gfs2_sbd *sdp)
597 if (atomic_read(&sdp->sd_log_in_flight)) {
599 prepare_to_wait(&sdp->sd_log_flush_wait, &wait,
601 if (atomic_read(&sdp->sd_log_in_flight))
603 } while(atomic_read(&sdp->sd_log_in_flight));
604 finish_wait(&sdp->sd_log_flush_wait, &wait);
628 static void gfs2_ordered_write(struct gfs2_sbd *sdp)
633 spin_lock(&sdp->sd_ordered_lock);
634 list_sort(NULL, &sdp->sd_log_ordered, &ip_cmp);
635 while (!list_empty(&sdp->sd_log_ordered)) {
636 ip = list_first_entry(&sdp->sd_log_ordered, struct gfs2_inode, i_ordered);
642 spin_unlock(&sdp->sd_ordered_lock);
644 spin_lock(&sdp->sd_ordered_lock);
646 list_splice(&written, &sdp->sd_log_ordered);
647 spin_unlock(&sdp->sd_ordered_lock);
650 static void gfs2_ordered_wait(struct gfs2_sbd *sdp)
654 spin_lock(&sdp->sd_ordered_lock);
655 while (!list_empty(&sdp->sd_log_ordered)) {
656 ip = list_first_entry(&sdp->sd_log_ordered, struct gfs2_inode, i_ordered);
660 spin_unlock(&sdp->sd_ordered_lock);
662 spin_lock(&sdp->sd_ordered_lock);
664 spin_unlock(&sdp->sd_ordered_lock);
669 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
671 spin_lock(&sdp->sd_ordered_lock);
673 spin_unlock(&sdp->sd_ordered_lock);
676 void gfs2_add_revoke(struct gfs2_sbd *sdp, struct gfs2_bufdata *bd)
681 sdp->sd_log_num_revoke++;
689 list_add(&bd->bd_list, &sdp->sd_log_revokes);
702 * @sdp: The GFS2 superblock
712 void gfs2_write_revokes(struct gfs2_sbd *sdp)
715 int max_revokes = (sdp->sd_sb.sb_bsize - sizeof(struct gfs2_log_descriptor)) / sizeof(u64);
717 gfs2_log_lock(sdp);
718 while (sdp->sd_log_num_revoke > max_revokes)
719 max_revokes += (sdp->sd_sb.sb_bsize - sizeof(struct gfs2_meta_header)) / sizeof(u64);
720 max_revokes -= sdp->sd_log_num_revoke;
721 if (!sdp->sd_log_num_revoke) {
722 atomic_dec(&sdp->sd_log_blks_free);
725 if (!sdp->sd_log_blks_reserved) {
726 atomic_dec(&sdp->sd_log_blks_free);
727 trace_gfs2_log_blocks(sdp, -2);
729 trace_gfs2_log_blocks(sdp, -1);
732 gfs2_ail1_empty(sdp, max_revokes);
733 gfs2_log_unlock(sdp);
735 if (!sdp->sd_log_num_revoke) {
736 atomic_inc(&sdp->sd_log_blks_free);
737 if (!sdp->sd_log_blks_reserved) {
738 atomic_inc(&sdp->sd_log_blks_free);
739 trace_gfs2_log_blocks(sdp, 2);
741 trace_gfs2_log_blocks(sdp, 1);
748 * @sdp: The GFS2 superblock
759 void gfs2_write_log_header(struct gfs2_sbd *sdp, struct gfs2_jdesc *jd,
766 struct gfs2_statfs_change_host *l_sc = &sdp->sd_statfs_local;
768 struct super_block *sb = sdp->sd_vfs;
771 if (gfs2_withdrawn(sdp))
782 lh->lh_header.mh_jid = cpu_to_be32(sdp->sd_jdesc->jd_jid);
797 if (gfs2_assert_withdraw(sdp, ret == 0))
808 cpu_to_be64(GFS2_I(sdp->sd_sc_inode)->i_no_addr);
810 cpu_to_be64(GFS2_I(sdp->sd_qc_inode)->i_no_addr);
812 spin_lock(&sdp->sd_statfs_spin);
816 spin_unlock(&sdp->sd_statfs_spin);
825 gfs2_log_write(sdp, page, sb->s_blocksize, 0, dblock);
826 gfs2_log_submit_bio(&sdp->sd_log_bio, REQ_OP_WRITE | op_flags);
828 log_flush_wait(sdp);
833 * @sdp: The GFS2 superblock
839 static void log_write_header(struct gfs2_sbd *sdp, u32 flags)
843 enum gfs2_freeze_state state = atomic_read(&sdp->sd_freeze_state);
845 gfs2_assert_withdraw(sdp, (state != SFS_FROZEN));
846 tail = current_tail(sdp);
848 if (test_bit(SDF_NOBARRIERS, &sdp->sd_flags)) {
849 gfs2_ordered_wait(sdp);
850 log_flush_wait(sdp);
853 sdp->sd_log_idle = (tail == sdp->sd_log_flush_head);
854 gfs2_write_log_header(sdp, sdp->sd_jdesc, sdp->sd_log_sequence++, tail,
855 sdp->sd_log_flush_head, flags, op_flags);
856 gfs2_log_incr_head(sdp);
858 if (sdp->sd_log_tail != tail)
859 log_pull_tail(sdp, tail);
864 * @sdp: Pointer to GFS2 superblock
866 static void ail_drain(struct gfs2_sbd *sdp)
870 spin_lock(&sdp->sd_ail_lock);
878 while (!list_empty(&sdp->sd_ail1_list)) {
879 tr = list_first_entry(&sdp->sd_ail1_list, struct gfs2_trans,
881 gfs2_ail_empty_tr(sdp, tr, &tr->tr_ail1_list);
882 gfs2_ail_empty_tr(sdp, tr, &tr->tr_ail2_list);
884 gfs2_trans_free(sdp, tr);
886 while (!list_empty(&sdp->sd_ail2_list)) {
887 tr = list_first_entry(&sdp->sd_ail2_list, struct gfs2_trans,
889 gfs2_ail_empty_tr(sdp, tr, &tr->tr_ail2_list);
891 gfs2_trans_free(sdp, tr);
893 spin_unlock(&sdp->sd_ail_lock);
898 * @sdp: Pointer to GFS2 superblock
900 static void empty_ail1_list(struct gfs2_sbd *sdp)
906 fs_err(sdp, "Error: In %s for 10 minutes! t=%d\n",
908 dump_ail_list(sdp);
911 gfs2_ail1_start(sdp);
912 gfs2_ail1_wait(sdp);
913 if (gfs2_ail1_empty(sdp, 0))
954 * @sdp: the filesystem
960 void gfs2_log_flush(struct gfs2_sbd *sdp, struct gfs2_glock *gl, u32 flags)
963 enum gfs2_freeze_state state = atomic_read(&sdp->sd_freeze_state);
965 down_write(&sdp->sd_log_flush_lock);
971 if (gfs2_withdrawn(sdp))
977 trace_gfs2_log_flush(sdp, 1, flags);
980 clear_bit(SDF_JOURNAL_LIVE, &sdp->sd_flags);
982 sdp->sd_log_flush_head = sdp->sd_log_head;
983 tr = sdp->sd_log_tr;
985 sdp->sd_log_tr = NULL;
986 tr->tr_first = sdp->sd_log_flush_head;
988 if (gfs2_assert_withdraw_delayed(sdp,
994 if (gfs2_assert_withdraw_delayed(sdp, !sdp->sd_log_num_revoke))
996 if (gfs2_assert_withdraw_delayed(sdp,
997 sdp->sd_log_num_revoke == sdp->sd_log_committed_revoke))
1000 gfs2_ordered_write(sdp);
1001 if (gfs2_withdrawn(sdp))
1003 lops_before_commit(sdp, tr);
1004 if (gfs2_withdrawn(sdp))
1006 gfs2_log_submit_bio(&sdp->sd_log_bio, REQ_OP_WRITE);
1007 if (gfs2_withdrawn(sdp))
1010 if (sdp->sd_log_head != sdp->sd_log_flush_head) {
1011 log_flush_wait(sdp);
1012 log_write_header(sdp, flags);
1013 } else if (sdp->sd_log_tail != current_tail(sdp) && !sdp->sd_log_idle){
1014 atomic_dec(&sdp->sd_log_blks_free); /* Adjust for unreserved buffer */
1015 trace_gfs2_log_blocks(sdp, -1);
1016 log_write_header(sdp, flags);
1018 if (gfs2_withdrawn(sdp))
1020 lops_after_commit(sdp, tr);
1022 gfs2_log_lock(sdp);
1023 sdp->sd_log_head = sdp->sd_log_flush_head;
1024 sdp->sd_log_blks_reserved = 0;
1025 sdp->sd_log_committed_revoke = 0;
1027 spin_lock(&sdp->sd_ail_lock);
1029 list_add(&tr->tr_list, &sdp->sd_ail1_list);
1032 spin_unlock(&sdp->sd_ail_lock);
1033 gfs2_log_unlock(sdp);
1036 if (!sdp->sd_log_idle) {
1037 empty_ail1_list(sdp);
1038 if (gfs2_withdrawn(sdp))
1040 atomic_dec(&sdp->sd_log_blks_free); /* Adjust for unreserved buffer */
1041 trace_gfs2_log_blocks(sdp, -1);
1042 log_write_header(sdp, flags);
1043 sdp->sd_log_head = sdp->sd_log_flush_head;
1047 gfs2_log_shutdown(sdp);
1049 atomic_set(&sdp->sd_freeze_state, SFS_FROZEN);
1053 trace_gfs2_log_flush(sdp, 0, flags);
1055 up_write(&sdp->sd_log_flush_lock);
1056 gfs2_trans_free(sdp, tr);
1057 if (gfs2_withdrawing(sdp))
1058 gfs2_withdraw(sdp);
1069 spin_lock(&sdp->sd_ail_lock);
1071 list_add(&tr->tr_list, &sdp->sd_ail1_list);
1072 spin_unlock(&sdp->sd_ail_lock);
1073 ail_drain(sdp); /* frees all transactions */
1084 static void gfs2_merge_trans(struct gfs2_sbd *sdp, struct gfs2_trans *new)
1086 struct gfs2_trans *old = sdp->sd_log_tr;
1100 spin_lock(&sdp->sd_ail_lock);
1103 spin_unlock(&sdp->sd_ail_lock);
1106 static void log_refund(struct gfs2_sbd *sdp, struct gfs2_trans *tr)
1112 gfs2_log_lock(sdp);
1114 if (sdp->sd_log_tr) {
1115 gfs2_merge_trans(sdp, tr);
1117 gfs2_assert_withdraw(sdp, test_bit(TR_ALLOCED, &tr->tr_flags));
1118 sdp->sd_log_tr = tr;
1122 sdp->sd_log_committed_revoke += tr->tr_num_revoke - tr->tr_num_revoke_rm;
1123 reserved = calc_reserved(sdp);
1124 maxres = sdp->sd_log_blks_reserved + tr->tr_reserved;
1125 gfs2_assert_withdraw(sdp, maxres >= reserved);
1127 atomic_add(unused, &sdp->sd_log_blks_free);
1128 trace_gfs2_log_blocks(sdp, unused);
1129 gfs2_assert_withdraw(sdp, atomic_read(&sdp->sd_log_blks_free) <=
1130 sdp->sd_jdesc->jd_blocks);
1131 sdp->sd_log_blks_reserved = reserved;
1133 gfs2_log_unlock(sdp);
1138 * @sdp: the filesystem
1151 void gfs2_log_commit(struct gfs2_sbd *sdp, struct gfs2_trans *tr)
1153 log_refund(sdp, tr);
1155 if (atomic_read(&sdp->sd_log_pinned) > atomic_read(&sdp->sd_log_thresh1) ||
1156 ((sdp->sd_jdesc->jd_blocks - atomic_read(&sdp->sd_log_blks_free)) >
1157 atomic_read(&sdp->sd_log_thresh2)))
1158 wake_up(&sdp->sd_logd_waitq);
1163 * @sdp: the filesystem
1167 static void gfs2_log_shutdown(struct gfs2_sbd *sdp)
1169 gfs2_assert_withdraw(sdp, !sdp->sd_log_blks_reserved);
1170 gfs2_assert_withdraw(sdp, !sdp->sd_log_num_revoke);
1171 gfs2_assert_withdraw(sdp, list_empty(&sdp->sd_ail1_list));
1173 sdp->sd_log_flush_head = sdp->sd_log_head;
1175 log_write_header(sdp, GFS2_LOG_HEAD_UNMOUNT | GFS2_LFC_SHUTDOWN);
1177 gfs2_assert_warn(sdp, sdp->sd_log_head == sdp->sd_log_tail);
1178 gfs2_assert_warn(sdp, list_empty(&sdp->sd_ail2_list));
1180 sdp->sd_log_head = sdp->sd_log_flush_head;
1181 sdp->sd_log_tail = sdp->sd_log_head;
1184 static inline int gfs2_jrnl_flush_reqd(struct gfs2_sbd *sdp)
1186 return (atomic_read(&sdp->sd_log_pinned) +
1187 atomic_read(&sdp->sd_log_blks_needed) >=
1188 atomic_read(&sdp->sd_log_thresh1));
1191 static inline int gfs2_ail_flush_reqd(struct gfs2_sbd *sdp)
1193 unsigned int used_blocks = sdp->sd_jdesc->jd_blocks - atomic_read(&sdp->sd_log_blks_free);
1195 if (test_and_clear_bit(SDF_FORCE_AIL_FLUSH, &sdp->sd_flags))
1198 return used_blocks + atomic_read(&sdp->sd_log_blks_needed) >=
1199 atomic_read(&sdp->sd_log_thresh2);
1204 * @sdp: Pointer to GFS2 superblock
1212 struct gfs2_sbd *sdp = data;
1219 if (gfs2_withdrawn(sdp)) {
1224 if (sdp->sd_log_error) {
1225 gfs2_lm(sdp,
1229 sdp->sd_fsname, sdp->sd_log_error);
1230 gfs2_withdraw(sdp);
1235 if (gfs2_jrnl_flush_reqd(sdp) || t == 0) {
1236 gfs2_ail1_empty(sdp, 0);
1237 gfs2_log_flush(sdp, NULL, GFS2_LOG_HEAD_FLUSH_NORMAL |
1242 if (gfs2_ail_flush_reqd(sdp)) {
1243 gfs2_ail1_start(sdp);
1244 gfs2_ail1_wait(sdp);
1245 gfs2_ail1_empty(sdp, 0);
1246 gfs2_log_flush(sdp, NULL, GFS2_LOG_HEAD_FLUSH_NORMAL |
1251 if (!gfs2_ail_flush_reqd(sdp) || did_flush)
1252 wake_up(&sdp->sd_log_waitq);
1254 t = gfs2_tune_get(sdp, gt_logd_secs) * HZ;
1259 prepare_to_wait(&sdp->sd_logd_waitq, &wait,
1261 if (!gfs2_ail_flush_reqd(sdp) &&
1262 !gfs2_jrnl_flush_reqd(sdp) &&
1265 } while(t && !gfs2_ail_flush_reqd(sdp) &&
1266 !gfs2_jrnl_flush_reqd(sdp) &&
1268 finish_wait(&sdp->sd_logd_waitq, &wait);