Merge git://git.kernel.org/pub/scm/linux/kernel/git/steve/gfs2-3.0-fixes

+4 -1

fs/gfs2/file.c

··· 923 923 cmd = F_SETLK; 924 924 fl->fl_type = F_UNLCK; 925 925 } 926 - if (unlikely(test_bit(SDF_SHUTDOWN, &sdp->sd_flags))) 926 + if (unlikely(test_bit(SDF_SHUTDOWN, &sdp->sd_flags))) { 927 + if (fl->fl_type == F_UNLCK) 928 + posix_lock_file_wait(file, fl); 927 929 return -EIO; 930 + } 928 931 if (IS_GETLK(cmd)) 929 932 return dlm_posix_get(ls->ls_dlm, ip->i_no_addr, file, fl); 930 933 else if (fl->fl_type == F_UNLCK)

+1

fs/gfs2/incore.h

··· 588 588 struct dlm_lksb ls_control_lksb; /* control_lock */ 589 589 char ls_control_lvb[GDLM_LVB_SIZE]; /* control_lock lvb */ 590 590 struct completion ls_sync_wait; /* {control,mounted}_{lock,unlock} */ 591 + char *ls_lvb_bits; 591 592 592 593 spinlock_t ls_recover_spin; /* protects following fields */ 593 594 unsigned long ls_recover_flags; /* DFL_ */

+20 -19

fs/gfs2/lock_dlm.c

··· 483 483 484 484 static int all_jid_bits_clear(char *lvb) 485 485 { 486 - int i; 487 - for (i = JID_BITMAP_OFFSET; i < GDLM_LVB_SIZE; i++) { 488 - if (lvb[i]) 489 - return 0; 490 - } 491 - return 1; 486 + return !memchr_inv(lvb + JID_BITMAP_OFFSET, 0, 487 + GDLM_LVB_SIZE - JID_BITMAP_OFFSET); 492 488 } 493 489 494 490 static void sync_wait_cb(void *arg) ··· 576 580 { 577 581 struct gfs2_sbd *sdp = container_of(work, struct gfs2_sbd, sd_control_work.work); 578 582 struct lm_lockstruct *ls = &sdp->sd_lockstruct; 579 - char lvb_bits[GDLM_LVB_SIZE]; 580 583 uint32_t block_gen, start_gen, lvb_gen, flags; 581 584 int recover_set = 0; 582 585 int write_lvb = 0; ··· 629 634 return; 630 635 } 631 636 632 - control_lvb_read(ls, &lvb_gen, lvb_bits); 637 + control_lvb_read(ls, &lvb_gen, ls->ls_lvb_bits); 633 638 634 639 spin_lock(&ls->ls_recover_spin); 635 640 if (block_gen != ls->ls_recover_block || ··· 659 664 660 665 ls->ls_recover_result[i] = 0; 661 666 662 - if (!test_bit_le(i, lvb_bits + JID_BITMAP_OFFSET)) 667 + if (!test_bit_le(i, ls->ls_lvb_bits + JID_BITMAP_OFFSET)) 663 668 continue; 664 669 665 - __clear_bit_le(i, lvb_bits + JID_BITMAP_OFFSET); 670 + __clear_bit_le(i, ls->ls_lvb_bits + JID_BITMAP_OFFSET); 666 671 write_lvb = 1; 667 672 } 668 673 } ··· 686 691 continue; 687 692 if (ls->ls_recover_submit[i] < start_gen) { 688 693 ls->ls_recover_submit[i] = 0; 689 - __set_bit_le(i, lvb_bits + JID_BITMAP_OFFSET); 694 + __set_bit_le(i, ls->ls_lvb_bits + JID_BITMAP_OFFSET); 690 695 } 691 696 } 692 697 /* even if there are no bits to set, we need to write the ··· 700 705 spin_unlock(&ls->ls_recover_spin); 701 706 702 707 if (write_lvb) { 703 - control_lvb_write(ls, start_gen, lvb_bits); 708 + control_lvb_write(ls, start_gen, ls->ls_lvb_bits); 704 709 flags = DLM_LKF_CONVERT | DLM_LKF_VALBLK; 705 710 } else { 706 711 flags = DLM_LKF_CONVERT; ··· 720 725 */ 721 726 722 727 for (i = 0; i < recover_size; i++) { 723 - if (test_bit_le(i, lvb_bits + JID_BITMAP_OFFSET)) { 728 + if (test_bit_le(i, ls->ls_lvb_bits + JID_BITMAP_OFFSET)) { 724 729 fs_info(sdp, "recover generation %u jid %d\n", 725 730 start_gen, i); 726 731 gfs2_recover_set(sdp, i); ··· 753 758 static int control_mount(struct gfs2_sbd *sdp) 754 759 { 755 760 struct lm_lockstruct *ls = &sdp->sd_lockstruct; 756 - char lvb_bits[GDLM_LVB_SIZE]; 757 761 uint32_t start_gen, block_gen, mount_gen, lvb_gen; 758 762 int mounted_mode; 759 763 int retries = 0; ··· 851 857 * lvb_gen will be non-zero. 852 858 */ 853 859 854 - control_lvb_read(ls, &lvb_gen, lvb_bits); 860 + control_lvb_read(ls, &lvb_gen, ls->ls_lvb_bits); 855 861 856 862 if (lvb_gen == 0xFFFFFFFF) { 857 863 /* special value to force mount attempts to fail */ ··· 881 887 * and all lvb bits to be clear (no pending journal recoveries.) 882 888 */ 883 889 884 - if (!all_jid_bits_clear(lvb_bits)) { 890 + if (!all_jid_bits_clear(ls->ls_lvb_bits)) { 885 891 /* journals need recovery, wait until all are clear */ 886 892 fs_info(sdp, "control_mount wait for journal recovery\n"); 887 893 goto restart; ··· 943 949 static int control_first_done(struct gfs2_sbd *sdp) 944 950 { 945 951 struct lm_lockstruct *ls = &sdp->sd_lockstruct; 946 - char lvb_bits[GDLM_LVB_SIZE]; 947 952 uint32_t start_gen, block_gen; 948 953 int error; 949 954 ··· 984 991 memset(ls->ls_recover_result, 0, ls->ls_recover_size*sizeof(uint32_t)); 985 992 spin_unlock(&ls->ls_recover_spin); 986 993 987 - memset(lvb_bits, 0, sizeof(lvb_bits)); 988 - control_lvb_write(ls, start_gen, lvb_bits); 994 + memset(ls->ls_lvb_bits, 0, GDLM_LVB_SIZE); 995 + control_lvb_write(ls, start_gen, ls->ls_lvb_bits); 989 996 990 997 error = mounted_lock(sdp, DLM_LOCK_PR, DLM_LKF_CONVERT); 991 998 if (error) ··· 1014 1021 uint32_t *result = NULL; 1015 1022 uint32_t old_size, new_size; 1016 1023 int i, max_jid; 1024 + 1025 + if (!ls->ls_lvb_bits) { 1026 + ls->ls_lvb_bits = kzalloc(GDLM_LVB_SIZE, GFP_NOFS); 1027 + if (!ls->ls_lvb_bits) 1028 + return -ENOMEM; 1029 + } 1017 1030 1018 1031 max_jid = 0; 1019 1032 for (i = 0; i < num_slots; i++) { ··· 1056 1057 1057 1058 static void free_recover_size(struct lm_lockstruct *ls) 1058 1059 { 1060 + kfree(ls->ls_lvb_bits); 1059 1061 kfree(ls->ls_recover_submit); 1060 1062 kfree(ls->ls_recover_result); 1061 1063 ls->ls_recover_submit = NULL; ··· 1205 1205 ls->ls_recover_size = 0; 1206 1206 ls->ls_recover_submit = NULL; 1207 1207 ls->ls_recover_result = NULL; 1208 + ls->ls_lvb_bits = NULL; 1208 1209 1209 1210 error = set_recover_size(sdp, NULL, 0); 1210 1211 if (error)

+14 -18

fs/gfs2/rgrp.c

··· 576 576 RB_CLEAR_NODE(&ip->i_res->rs_node); 577 577 out: 578 578 up_write(&ip->i_rw_mutex); 579 - return 0; 579 + return error; 580 580 } 581 581 582 582 static void dump_rs(struct seq_file *seq, const struct gfs2_blkreserv *rs) ··· 1181 1181 const struct gfs2_bitmap *bi, unsigned minlen, u64 *ptrimmed) 1182 1182 { 1183 1183 struct super_block *sb = sdp->sd_vfs; 1184 - struct block_device *bdev = sb->s_bdev; 1185 - const unsigned int sects_per_blk = sdp->sd_sb.sb_bsize / 1186 - bdev_logical_block_size(sb->s_bdev); 1187 1184 u64 blk; 1188 1185 sector_t start = 0; 1189 - sector_t nr_sects = 0; 1186 + sector_t nr_blks = 0; 1190 1187 int rv; 1191 1188 unsigned int x; 1192 1189 u32 trimmed = 0; ··· 1203 1206 if (diff == 0) 1204 1207 continue; 1205 1208 blk = offset + ((bi->bi_start + x) * GFS2_NBBY); 1206 - blk *= sects_per_blk; /* convert to sectors */ 1207 1209 while(diff) { 1208 1210 if (diff & 1) { 1209 - if (nr_sects == 0) 1211 + if (nr_blks == 0) 1210 1212 goto start_new_extent; 1211 - if ((start + nr_sects) != blk) { 1212 - if (nr_sects >= minlen) { 1213 - rv = blkdev_issue_discard(bdev, 1214 - start, nr_sects, 1213 + if ((start + nr_blks) != blk) { 1214 + if (nr_blks >= minlen) { 1215 + rv = sb_issue_discard(sb, 1216 + start, nr_blks, 1215 1217 GFP_NOFS, 0); 1216 1218 if (rv) 1217 1219 goto fail; 1218 - trimmed += nr_sects; 1220 + trimmed += nr_blks; 1219 1221 } 1220 - nr_sects = 0; 1222 + nr_blks = 0; 1221 1223 start_new_extent: 1222 1224 start = blk; 1223 1225 } 1224 - nr_sects += sects_per_blk; 1226 + nr_blks++; 1225 1227 } 1226 1228 diff >>= 2; 1227 - blk += sects_per_blk; 1229 + blk++; 1228 1230 } 1229 1231 } 1230 - if (nr_sects >= minlen) { 1231 - rv = blkdev_issue_discard(bdev, start, nr_sects, GFP_NOFS, 0); 1232 + if (nr_blks >= minlen) { 1233 + rv = sb_issue_discard(sb, start, nr_blks, GFP_NOFS, 0); 1232 1234 if (rv) 1233 1235 goto fail; 1234 - trimmed += nr_sects; 1236 + trimmed += nr_blks; 1235 1237 } 1236 1238 if (ptrimmed) 1237 1239 *ptrimmed = trimmed;

Configure Feed

Configure Feed