fs/sysv/truncate.c

Name: Public Git Hosting - davej-history.git/blob - fs/sysv/truncate.c
Rating: 4.8 (6374 reviews)
 1 /*
 2  * linux/fs/sysv/truncate.c
 3  *
 4  * minix/truncate.c
 5  * Copyright (C) 1991, 1992 Linus Torvalds
 6  *
 7  * coh/truncate.c
 8  * Copyright (C) 1993 Pascal Haible, Bruno Haible
 9  *
 10  * sysv/truncate.c
 11  * Copyright (C) 1993 Bruno Haible
 12  */
 13
 14 #include <linux/sched.h>
 15 #include <linux/fs.h>
 16 #include <linux/sysv_fs.h>
 17 #include <linux/stat.h>
 18
 19
 20 /* Linus' implementation of truncate.
 21  * It doesn't need locking because it can tell from looking at bh->b_count
 22  * whether a given block is in use elsewhere.
 23  */
 24
 25 /*
 26  * Truncate has the most races in the whole filesystem: coding it is
 27  * a pain in the a**, especially as I don't do any locking.
 28  *
 29  * The code may look a bit weird, but that's just because I've tried to
 30  * handle things like file-size changes in a somewhat graceful manner.
 31  * Anyway, truncating a file at the same time somebody else writes to it
 32  * is likely to result in pretty weird behaviour...
 33  *
 34  * The new code handles normal truncates (size = 0) as well as the more
 35  * general case (size = XXX). I hope.
 36  */
 37
 38 #define DATA_BUFFER_USED(bh) \
 39  ((bh->b_count > 1) || buffer_locked(bh))
 40
 41 /* We throw away any data beyond inode->i_size. */
 42
 43 static inttrunc_direct(struct inode * inode)
 44 {
 45 struct super_block * sb;
 46 unsigned int i;
 47  u32 * p;
 48  u32 block;
 49 struct buffer_head * bh;
 50 int retry =0;
 51
 52  sb = inode->i_sb;
 53 repeat:
 54 for(i = ((unsigned long) inode->i_size + sb->sv_block_size_1) >> sb->sv_block_size_bits; i <10; i++) {
 55  p = inode->u.sysv_i.i_data + i;
 56  block = *p;
 57 if(!block)
 58 continue;
 59  bh =sv_get_hash_table(sb, inode->i_dev, block);
 60 if((i << sb->sv_block_size_bits) < inode->i_size) {
 61 brelse(bh);
 62 goto repeat;
 63 }
 64 if((bh &&DATA_BUFFER_USED(bh)) || (block != *p)) {
 65  retry =1;
 66 brelse(bh);
 67 continue;
 68 }
 69 *p =0;
 70 mark_inode_dirty(inode);
 71 brelse(bh);
 72 sysv_free_block(sb,block);
 73 }
 74 return retry;
 75 }
 76
 77 static inttrunc_indirect(struct inode * inode,unsigned long offset, sysv_zone_t * p,int convert,unsigned char* dirt)
 78 {
 79 unsigned long indtmp, indblock;
 80 struct super_block * sb;
 81 struct buffer_head * indbh;
 82 unsigned int i;
 83  sysv_zone_t * ind;
 84 unsigned long tmp, block;
 85 struct buffer_head * bh;
 86 int retry =0;
 87
 88  indblock = indtmp = *p;
 89 if(convert)
 90  indblock =from_coh_ulong(indblock);
 91 if(!indblock)
 92 return0;
 93  sb = inode->i_sb;
 94  indbh =sv_bread(sb, inode->i_dev, indblock);
 95 if(indtmp != *p) {
 96 brelse(indbh);
 97 return1;
 98 }
 99 if(!indbh) {
 100 *p =0;
 101 *dirt =1;
 102 return0;
 103 }
 104 repeat:
 105 if(inode->i_size < offset)
 106  i =0;
 107 else
 108  i = (inode->i_size - offset + sb->sv_block_size_1) >> sb->sv_block_size_bits;
 109 for(; i < sb->sv_ind_per_block; i++) {
 110  ind = ((sysv_zone_t *) indbh->b_data) + i;
 111  block = tmp = *ind;
 112 if(sb->sv_convert)
 113  block =from_coh_ulong(block);
 114 if(!block)
 115 continue;
 116  bh =sv_get_hash_table(sb, inode->i_dev, block);
 117 if((i << sb->sv_block_size_bits) + offset < inode->i_size) {
 118 brelse(bh);
 119 goto repeat;
 120 }
 121 if((bh &&DATA_BUFFER_USED(bh)) || (tmp != *ind)) {
 122  retry =1;
 123 brelse(bh);
 124 continue;
 125 }
 126 *ind =0;
 127 mark_buffer_dirty(indbh,1);
 128 brelse(bh);
 129 sysv_free_block(sb,block);
 130 }
 131 for(i =0; i < sb->sv_ind_per_block; i++)
 132 if(((sysv_zone_t *) indbh->b_data)[i])
 133 goto done;
 134 if(DATA_BUFFER_USED(indbh) || (indtmp != *p)) {
 135 brelse(indbh);
 136 return1;
 137 }
 138 *p =0;
 139 *dirt =1;
 140 sysv_free_block(sb,indblock);
 141 done:
 142 brelse(indbh);
 143 return retry;
 144 }
 145
 146 static inttrunc_dindirect(struct inode * inode,unsigned long offset, sysv_zone_t * p,int convert,unsigned char* dirt)
 147 {
 148  u32 indtmp, indblock;
 149 struct super_block * sb;
 150 struct buffer_head * indbh;
 151 unsigned int i;
 152  sysv_zone_t * ind;
 153  u32 tmp, block;
 154 int retry =0;
 155
 156  indblock = indtmp = *p;
 157 if(convert)
 158  indblock =from_coh_ulong(indblock);
 159 if(!indblock)
 160 return0;
 161  sb = inode->i_sb;
 162  indbh =sv_bread(sb, inode->i_dev, indblock);
 163 if(indtmp != *p) {
 164 brelse(indbh);
 165 return1;
 166 }
 167 if(!indbh) {
 168 *p =0;
 169 *dirt =1;
 170 return0;
 171 }
 172 if(inode->i_size < offset)
 173  i =0;
 174 else
 175  i = (inode->i_size - offset + sb->sv_ind_per_block_block_size_1) >> sb->sv_ind_per_block_block_size_bits;
 176 for(; i < sb->sv_ind_per_block; i++) {
 177 unsigned char dirty =0;
 178  ind = ((sysv_zone_t *) indbh->b_data) + i;
 179  block = tmp = *ind;
 180 if(sb->sv_convert)
 181  block =from_coh_ulong(block);
 182 if(!block)
 183 continue;
 184  retry |=trunc_indirect(inode,offset+(i<<sb->sv_ind_per_block_bits),ind,sb->sv_convert,&dirty);
 185 if(dirty)
 186 mark_buffer_dirty(indbh,1);
 187 }
 188 for(i =0; i < sb->sv_ind_per_block; i++)
 189 if(((sysv_zone_t *) indbh->b_data)[i])
 190 goto done;
 191 if(DATA_BUFFER_USED(indbh) || (indtmp != *p)) {
 192 brelse(indbh);
 193 return1;
 194 }
 195 *p =0;
 196 *dirt =1;
 197 sysv_free_block(sb,indblock);
 198 done:
 199 brelse(indbh);
 200 return retry;
 201 }
 202
 203 static inttrunc_tindirect(struct inode * inode,unsigned long offset, sysv_zone_t * p,int convert,unsigned char* dirt)
 204 {
 205  u32 indtmp, indblock;
 206 struct super_block * sb;
 207 struct buffer_head * indbh;
 208 unsigned int i;
 209  sysv_zone_t * ind;
 210  u32 tmp, block;
 211 int retry =0;
 212
 213  indblock = indtmp = *p;
 214 if(convert)
 215  indblock =from_coh_ulong(indblock);
 216 if(!indblock)
 217 return0;
 218  sb = inode->i_sb;
 219  indbh =sv_bread(sb, inode->i_dev, indblock);
 220 if(indtmp != *p) {
 221 brelse(indbh);
 222 return1;
 223 }
 224 if(!indbh) {
 225 *p =0;
 226 *dirt =1;
 227 return0;
 228 }
 229 if(inode->i_size < offset)
 230  i =0;
 231 else
 232  i = (inode->i_size - offset + sb->sv_ind_per_block_2_block_size_1) >> sb->sv_ind_per_block_2_block_size_bits;
 233 for(; i < sb->sv_ind_per_block; i++) {
 234 unsigned char dirty =0;
 235  ind = ((sysv_zone_t *) indbh->b_data) + i;
 236  block = tmp = *ind;
 237 if(sb->sv_convert)
 238  block =from_coh_ulong(block);
 239 if(!block)
 240 continue;
 241  retry |=trunc_dindirect(inode,offset+(i<<sb->sv_ind_per_block_2_bits),ind,sb->sv_convert,&dirty);
 242 if(dirty)
 243 mark_buffer_dirty(indbh,1);
 244 }
 245 for(i =0; i < sb->sv_ind_per_block; i++)
 246 if(((sysv_zone_t *) indbh->b_data)[i])
 247 goto done;
 248 if(DATA_BUFFER_USED(indbh) || (indtmp != *p)) {
 249 brelse(indbh);
 250 return1;
 251 }
 252 *p =0;
 253 *dirt =1;
 254 sysv_free_block(sb,indblock);
 255 done:
 256 brelse(indbh);
 257 return retry;
 258 }
 259
 260 static inttrunc_all(struct inode * inode)
 261 {
 262 struct super_block * sb;
 263 char dirty;
 264
 265  sb = inode->i_sb;
 266 returntrunc_direct(inode)
 267 |trunc_indirect(inode,sb->sv_ind0_size,&inode->u.sysv_i.i_data[10],0,&dirty)
 268 |trunc_dindirect(inode,sb->sv_ind1_size,&inode->u.sysv_i.i_data[11],0,&dirty)
 269 |trunc_tindirect(inode,sb->sv_ind2_size,&inode->u.sysv_i.i_data[12],0,&dirty);
 270 }
 271
 272
 273 voidsysv_truncate(struct inode * inode)
 274 {
 275 /* If this is called from sysv_put_inode, we needn't worry about
 276  * races as we are just losing the last reference to the inode.
 277  * If this is called from another place, let's hope it's a regular
 278  * file.
 279  * Truncating symbolic links is strange. We assume we don't truncate
 280  * a directory we are just modifying. We ensure we don't truncate
 281  * a regular file we are just writing to, by use of a lock.
 282  */
 283 if(S_ISLNK(inode->i_mode))
 284 printk("sysv_truncate: truncating symbolic link\n");
 285 else if(!(S_ISREG(inode->i_mode) ||S_ISDIR(inode->i_mode)))
 286 return;
 287 while(trunc_all(inode)) {
 288  current->counter =0;
 289 schedule();
 290 }
 291  inode->i_mtime = inode->i_ctime = CURRENT_TIME;
 292 mark_inode_dirty(inode);
 293 }