tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
fork atom

sysv: drop lock/unlock super

Removed lock/unlock super. Added a new private s_lock mutex.

Signed-off-by: Marco Stornelli <marco.stornelli@gmail.com>
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>

authored by

Marco Stornelli and committed by
Al Viro c07cb01c f6e12dc4

+20 -18
+9 -9
fs/sysv/balloc.c
··· 60 60 return; 61 61 } 62 62 63 - lock_super(sb); 63 + mutex_lock(&sbi->s_lock); 64 64 count = fs16_to_cpu(sbi, *sbi->s_bcache_count); 65 65 66 66 if (count > sbi->s_flc_size) { 67 67 printk("sysv_free_block: flc_count > flc_size\n"); 68 - unlock_super(sb); 68 + mutex_unlock(&sbi->s_lock); 69 69 return; 70 70 } 71 71 /* If the free list head in super-block is full, it is copied ··· 77 77 bh = sb_getblk(sb, block); 78 78 if (!bh) { 79 79 printk("sysv_free_block: getblk() failed\n"); 80 - unlock_super(sb); 80 + mutex_unlock(&sbi->s_lock); 81 81 return; 82 82 } 83 83 memset(bh->b_data, 0, sb->s_blocksize); ··· 93 93 *sbi->s_bcache_count = cpu_to_fs16(sbi, count); 94 94 fs32_add(sbi, sbi->s_free_blocks, 1); 95 95 dirty_sb(sb); 96 - unlock_super(sb); 96 + mutex_unlock(&sbi->s_lock); 97 97 } 98 98 99 99 sysv_zone_t sysv_new_block(struct super_block * sb) ··· 104 104 struct buffer_head * bh; 105 105 unsigned count; 106 106 107 - lock_super(sb); 107 + mutex_lock(&sbi->s_lock); 108 108 count = fs16_to_cpu(sbi, *sbi->s_bcache_count); 109 109 110 110 if (count == 0) /* Applies only to Coherent FS */ ··· 147 147 /* Now the free list head in the superblock is valid again. */ 148 148 fs32_add(sbi, sbi->s_free_blocks, -1); 149 149 dirty_sb(sb); 150 - unlock_super(sb); 150 + mutex_unlock(&sbi->s_lock); 151 151 return nr; 152 152 153 153 Enospc: 154 - unlock_super(sb); 154 + mutex_unlock(&sbi->s_lock); 155 155 return 0; 156 156 } 157 157 ··· 173 173 if (sbi->s_type == FSTYPE_AFS) 174 174 return 0; 175 175 176 - lock_super(sb); 176 + mutex_lock(&sbi->s_lock); 177 177 sb_count = fs32_to_cpu(sbi, *sbi->s_free_blocks); 178 178 179 179 if (0) ··· 211 211 if (count != sb_count) 212 212 goto Ecount; 213 213 done: 214 - unlock_super(sb); 214 + mutex_unlock(&sbi->s_lock); 215 215 return count; 216 216 217 217 Einval:
+7 -7
fs/sysv/ialloc.c
··· 118 118 "%s\n", inode->i_sb->s_id); 119 119 return; 120 120 } 121 - lock_super(sb); 121 + mutex_lock(&sbi->s_lock); 122 122 count = fs16_to_cpu(sbi, *sbi->s_sb_fic_count); 123 123 if (count < sbi->s_fic_size) { 124 124 *sv_sb_fic_inode(sb,count++) = cpu_to_fs16(sbi, ino); ··· 128 128 dirty_sb(sb); 129 129 memset(raw_inode, 0, sizeof(struct sysv_inode)); 130 130 mark_buffer_dirty(bh); 131 - unlock_super(sb); 131 + mutex_unlock(&sbi->s_lock); 132 132 brelse(bh); 133 133 } 134 134 ··· 147 147 if (!inode) 148 148 return ERR_PTR(-ENOMEM); 149 149 150 - lock_super(sb); 150 + mutex_lock(&sbi->s_lock); 151 151 count = fs16_to_cpu(sbi, *sbi->s_sb_fic_count); 152 152 if (count == 0 || (*sv_sb_fic_inode(sb,count-1) == 0)) { 153 153 count = refill_free_cache(sb); 154 154 if (count == 0) { 155 155 iput(inode); 156 - unlock_super(sb); 156 + mutex_unlock(&sbi->s_lock); 157 157 return ERR_PTR(-ENOSPC); 158 158 } 159 159 } ··· 174 174 sysv_write_inode(inode, &wbc); /* ensure inode not allocated again */ 175 175 mark_inode_dirty(inode); /* cleared by sysv_write_inode() */ 176 176 /* That's it. */ 177 - unlock_super(sb); 177 + mutex_unlock(&sbi->s_lock); 178 178 return inode; 179 179 } 180 180 ··· 185 185 struct sysv_inode * raw_inode; 186 186 int ino, count, sb_count; 187 187 188 - lock_super(sb); 188 + mutex_lock(&sbi->s_lock); 189 189 190 190 sb_count = fs16_to_cpu(sbi, *sbi->s_sb_total_free_inodes); 191 191 ··· 213 213 if (count != sb_count) 214 214 goto Einval; 215 215 out: 216 - unlock_super(sb); 216 + mutex_unlock(&sbi->s_lock); 217 217 return count; 218 218 219 219 Einval:
+2 -2
fs/sysv/inode.c
··· 36 36 struct sysv_sb_info *sbi = SYSV_SB(sb); 37 37 unsigned long time = get_seconds(), old_time; 38 38 39 - lock_super(sb); 39 + mutex_lock(&sbi->s_lock); 40 40 41 41 /* 42 42 * If we are going to write out the super block, ··· 51 51 mark_buffer_dirty(sbi->s_bh2); 52 52 } 53 53 54 - unlock_super(sb); 54 + mutex_unlock(&sbi->s_lock); 55 55 56 56 return 0; 57 57 }
+1
fs/sysv/super.c
··· 368 368 369 369 sbi->s_sb = sb; 370 370 sbi->s_block_base = 0; 371 + mutex_init(&sbi->s_lock); 371 372 sb->s_fs_info = sbi; 372 373 373 374 sb_set_blocksize(sb, BLOCK_SIZE);
+1
fs/sysv/sysv.h
··· 58 58 u32 s_nzones; /* same as s_sbd->s_fsize */ 59 59 u16 s_namelen; /* max length of dir entry */ 60 60 int s_forced_ro; 61 + struct mutex s_lock; 61 62 }; 62 63 63 64 /*