508 lines
12 KiB
C
508 lines
12 KiB
C
/*
|
|
* linux/fs/sysv/truncate.c
|
|
*
|
|
* minix/truncate.c
|
|
* Copyright (C) 1991, 1992 Linus Torvalds
|
|
*
|
|
* coh/truncate.c
|
|
* Copyright (C) 1993 Pascal Haible, Bruno Haible
|
|
*
|
|
* sysv/truncate.c
|
|
* Copyright (C) 1993 Bruno Haible
|
|
*/
|
|
|
|
#include <linux/sched.h>
|
|
#include <linux/fs.h>
|
|
#include <linux/sysv_fs.h>
|
|
#include <linux/stat.h>
|
|
|
|
|
|
/* There are two different implementations of truncate() here.
|
|
* One (by Bruno) needs to do locking to ensure that noone is writing
|
|
* to a block being truncated away and incorporated into the free list.
|
|
* The better one (by Linus) doesn't need locking because it can tell from
|
|
* looking at bh->b_count whether a given block is in use elsewhere.
|
|
* Alas, this doesn't work if block_size < BLOCK_SIZE.
|
|
*/
|
|
|
|
|
|
/* Bruno's implementation of truncate. */
|
|
|
|
/* Leave at most `blocks' direct blocks. */
|
|
static int coh_trunc_direct (struct inode * inode, unsigned long blocks)
|
|
{
|
|
unsigned int i;
|
|
unsigned long * p;
|
|
unsigned long block;
|
|
|
|
for (i = blocks; i < 10 ; i++) {
|
|
p = &inode->u.sysv_i.i_data[i];
|
|
block = *p;
|
|
if (!block)
|
|
continue;
|
|
*p = 0;
|
|
inode->i_dirt = 1;
|
|
sysv_free_block(inode->i_sb,block);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/* Leave at most `blocks' blocks out of an indirect block whose number is
|
|
* from_coh_ulong(*p) if convert=1, *p if convert=0.
|
|
*/
|
|
static int coh_trunc_indirect (struct inode * inode, unsigned long blocks, unsigned long * p, int convert, unsigned char * dirt)
|
|
{
|
|
struct super_block * sb = inode->i_sb;
|
|
unsigned long tmp, block, indblock;
|
|
struct buffer_head * bh;
|
|
char * bh_data;
|
|
unsigned long i;
|
|
sysv_zone_t * ind;
|
|
|
|
if (blocks >= sb->sv_ind_per_block)
|
|
return 0;
|
|
block = tmp = *p;
|
|
if (convert)
|
|
block = from_coh_ulong(block);
|
|
if (!block)
|
|
return 0;
|
|
bh = sysv_bread(sb,inode->i_dev,block,&bh_data);
|
|
if (tmp != *p) {
|
|
brelse(bh);
|
|
return 1;
|
|
}
|
|
if (!bh) {
|
|
*p = 0;
|
|
*dirt = 1;
|
|
return 0;
|
|
}
|
|
for (i = blocks; i < sb->sv_ind_per_block; i++) {
|
|
ind = &((sysv_zone_t *) bh_data)[i];
|
|
indblock = *ind;
|
|
if (sb->sv_convert)
|
|
indblock = from_coh_ulong(indblock);
|
|
if (!indblock)
|
|
continue;
|
|
*ind = 0;
|
|
bh->b_dirt = 1;
|
|
sysv_free_block(sb,indblock);
|
|
}
|
|
for (i = 0; i < sb->sv_ind_per_block; i++)
|
|
if (((sysv_zone_t *) bh_data)[i])
|
|
goto done;
|
|
if (tmp != *p) {
|
|
brelse(bh);
|
|
return 1;
|
|
}
|
|
*p = 0;
|
|
*dirt = 1;
|
|
sysv_free_block(sb,block);
|
|
done:
|
|
brelse(bh);
|
|
return 0;
|
|
}
|
|
|
|
/* Leave at most `blocks' blocks out of an double indirect block whose number is
|
|
* from_coh_ulong(*p) if convert=1, *p if convert=0.
|
|
*/
|
|
static int coh_trunc_dindirect (struct inode * inode, unsigned long blocks, unsigned long * p, int convert, unsigned char * dirt)
|
|
{
|
|
struct super_block * sb = inode->i_sb;
|
|
unsigned long tmp, block, dindblock;
|
|
struct buffer_head * bh;
|
|
char * bh_data;
|
|
unsigned long i, j;
|
|
sysv_zone_t * dind;
|
|
int retry = 0;
|
|
|
|
if (blocks >= sb->sv_ind_per_block_2)
|
|
return 0;
|
|
block = tmp = *p;
|
|
if (convert)
|
|
block = from_coh_ulong(block);
|
|
if (!block)
|
|
return 0;
|
|
bh = sysv_bread(sb,inode->i_dev,block,&bh_data);
|
|
if (tmp != *p) {
|
|
brelse(bh);
|
|
return 1;
|
|
}
|
|
if (!bh) {
|
|
*p = 0;
|
|
*dirt = 1;
|
|
return 0;
|
|
}
|
|
for (i = blocks >> sb->sv_ind_per_block_bits, j = blocks & sb->sv_ind_per_block_1;
|
|
i < sb->sv_ind_per_block;
|
|
i++, j = 0) {
|
|
/* j = max(blocks-i*ind_per_block,0) */
|
|
dind = &((sysv_zone_t *) bh_data)[i];
|
|
dindblock = *dind;
|
|
if (sb->sv_convert)
|
|
dindblock = from_coh_ulong(dindblock);
|
|
if (!dindblock)
|
|
continue;
|
|
retry |= coh_trunc_indirect(inode,j,dind,sb->sv_convert,&bh->b_dirt);
|
|
}
|
|
for (i = 0; i < sb->sv_ind_per_block; i++)
|
|
if (((sysv_zone_t *) bh_data)[i])
|
|
goto done;
|
|
if (tmp != *p) {
|
|
brelse(bh);
|
|
return 1;
|
|
}
|
|
*p = 0;
|
|
*dirt = 1;
|
|
sysv_free_block(sb,block);
|
|
done:
|
|
brelse(bh);
|
|
return retry;
|
|
}
|
|
|
|
/* Leave at most `blocks' blocks out of an triple indirect block whose number is
|
|
* from_coh_ulong(*p) if convert=1, *p if convert=0.
|
|
*/
|
|
static int coh_trunc_tindirect (struct inode * inode, unsigned long blocks, unsigned long * p)
|
|
{
|
|
struct super_block * sb = inode->i_sb;
|
|
unsigned long block, tindblock;
|
|
struct buffer_head * bh;
|
|
char * bh_data;
|
|
unsigned long i, j;
|
|
sysv_zone_t * tind;
|
|
int retry = 0;
|
|
|
|
if (blocks >= sb->sv_ind_per_block_3)
|
|
return 0;
|
|
block = *p;
|
|
if (!block)
|
|
return 0;
|
|
bh = sysv_bread(sb,inode->i_dev,block,&bh_data);
|
|
if (block != *p) {
|
|
brelse(bh);
|
|
return 1;
|
|
}
|
|
if (!bh) {
|
|
*p = 0;
|
|
inode->i_dirt = 1;
|
|
return 0;
|
|
}
|
|
for (i = blocks >> sb->sv_ind_per_block_2_bits, j = blocks & sb->sv_ind_per_block_2_1;
|
|
i < sb->sv_ind_per_block;
|
|
i++, j = 0) {
|
|
/* j = max(blocks-i*ind_per_block^2,0) */
|
|
tind = &((sysv_zone_t *) bh_data)[i];
|
|
tindblock = *tind;
|
|
if (sb->sv_convert)
|
|
tindblock = from_coh_ulong(tindblock);
|
|
if (!tindblock)
|
|
continue;
|
|
retry |= coh_trunc_dindirect(inode,j,tind,sb->sv_convert,&bh->b_dirt);
|
|
}
|
|
for (i = 0; i < sb->sv_ind_per_block; i++)
|
|
if (((sysv_zone_t *) bh_data)[i])
|
|
goto done;
|
|
if (block != *p) {
|
|
brelse(bh);
|
|
return 1;
|
|
}
|
|
*p = 0;
|
|
inode->i_dirt = 1;
|
|
sysv_free_block(sb,block);
|
|
done:
|
|
brelse(bh);
|
|
return retry;
|
|
}
|
|
|
|
static int coh_trunc_all(struct inode * inode)
|
|
{
|
|
struct super_block * sb = inode->i_sb;
|
|
long blocks;
|
|
int retry;
|
|
|
|
blocks = (inode->i_size + sb->sv_block_size_1) >> sb->sv_block_size_bits;
|
|
retry = coh_trunc_direct(inode,blocks);
|
|
blocks -= 10;
|
|
if (blocks < 0) blocks = 0;
|
|
retry |= coh_trunc_indirect(inode,blocks,&inode->u.sysv_i.i_data[10],0,&inode->i_dirt);
|
|
blocks -= sb->sv_ind_per_block;
|
|
if (blocks < 0) blocks = 0;
|
|
retry |= coh_trunc_dindirect(inode,blocks,&inode->u.sysv_i.i_data[11],0,&inode->i_dirt);
|
|
blocks -= sb->sv_ind_per_block_2;
|
|
if (blocks < 0) blocks = 0;
|
|
retry |= coh_trunc_tindirect(inode,blocks,&inode->u.sysv_i.i_data[12]);
|
|
return retry;
|
|
}
|
|
|
|
|
|
/* Linus' implementation of truncate. Used only if block_size = BLOCK_SIZE. */
|
|
|
|
/*
|
|
* Truncate has the most races in the whole filesystem: coding it is
|
|
* a pain in the a**. Especially as I don't do any locking...
|
|
*
|
|
* The code may look a bit weird, but that's just because I've tried to
|
|
* handle things like file-size changes in a somewhat graceful manner.
|
|
* Anyway, truncating a file at the same time somebody else writes to it
|
|
* is likely to result in pretty weird behaviour...
|
|
*
|
|
* The new code handles normal truncates (size = 0) as well as the more
|
|
* general case (size = XXX). I hope.
|
|
*/
|
|
|
|
/* We throw away any data beyond inode->i_size. */
|
|
|
|
static int trunc_direct(struct inode * inode)
|
|
{
|
|
struct super_block * sb;
|
|
unsigned int i;
|
|
unsigned long * p;
|
|
unsigned long block;
|
|
struct buffer_head * bh;
|
|
int retry = 0;
|
|
|
|
sb = inode->i_sb;
|
|
repeat:
|
|
for (i = ((unsigned long) inode->i_size + BLOCK_SIZE-1) / BLOCK_SIZE; i < 10; i++) {
|
|
p = inode->u.sysv_i.i_data + i;
|
|
block = *p;
|
|
if (!block)
|
|
continue;
|
|
bh = get_hash_table(inode->i_dev,block+sb->sv_block_base,BLOCK_SIZE);
|
|
if (i*BLOCK_SIZE < inode->i_size) {
|
|
brelse(bh);
|
|
goto repeat;
|
|
}
|
|
if ((bh && bh->b_count != 1) || (block != *p)) {
|
|
retry = 1;
|
|
brelse(bh);
|
|
continue;
|
|
}
|
|
*p = 0;
|
|
inode->i_dirt = 1;
|
|
brelse(bh);
|
|
sysv_free_block(sb,block);
|
|
}
|
|
return retry;
|
|
}
|
|
|
|
#define IND_PER_BLOCK (BLOCK_SIZE / sizeof(sysv_zone_t))
|
|
|
|
static int trunc_indirect(struct inode * inode, unsigned long offset, unsigned long * p, int convert, unsigned char * dirt)
|
|
{
|
|
unsigned long indtmp, indblock;
|
|
struct super_block * sb;
|
|
struct buffer_head * indbh;
|
|
unsigned int i;
|
|
sysv_zone_t * ind;
|
|
unsigned long tmp, block;
|
|
struct buffer_head * bh;
|
|
int retry = 0;
|
|
|
|
indblock = indtmp = *p;
|
|
if (convert)
|
|
indblock = from_coh_ulong(indblock);
|
|
if (!indblock)
|
|
return 0;
|
|
sb = inode->i_sb;
|
|
indbh = bread(inode->i_dev,indblock+sb->sv_block_base,BLOCK_SIZE);
|
|
if (indtmp != *p) {
|
|
brelse(indbh);
|
|
return 1;
|
|
}
|
|
if (!indbh) {
|
|
*p = 0;
|
|
*dirt = 1;
|
|
return 0;
|
|
}
|
|
repeat:
|
|
if (inode->i_size < offset)
|
|
i = 0;
|
|
else
|
|
i = (inode->i_size - offset + BLOCK_SIZE-1) / BLOCK_SIZE;
|
|
for (; i < IND_PER_BLOCK; i++) {
|
|
ind = ((sysv_zone_t *) indbh->b_data) + i;
|
|
block = tmp = *ind;
|
|
if (sb->sv_convert)
|
|
block = from_coh_ulong(block);
|
|
if (!block)
|
|
continue;
|
|
bh = get_hash_table(inode->i_dev,block+sb->sv_block_base,BLOCK_SIZE);
|
|
if (i*BLOCK_SIZE + offset < inode->i_size) {
|
|
brelse(bh);
|
|
goto repeat;
|
|
}
|
|
if ((bh && bh->b_count != 1) || (tmp != *ind)) {
|
|
retry = 1;
|
|
brelse(bh);
|
|
continue;
|
|
}
|
|
*ind = 0;
|
|
indbh->b_dirt = 1;
|
|
brelse(bh);
|
|
sysv_free_block(sb,block);
|
|
}
|
|
for (i = 0; i < IND_PER_BLOCK; i++)
|
|
if (((sysv_zone_t *) indbh->b_data)[i])
|
|
goto done;
|
|
if ((indbh->b_count != 1) || (indtmp != *p)) {
|
|
brelse(indbh);
|
|
return 1;
|
|
}
|
|
*p = 0;
|
|
*dirt = 1;
|
|
sysv_free_block(sb,indblock);
|
|
done:
|
|
brelse(indbh);
|
|
return retry;
|
|
}
|
|
|
|
static int trunc_dindirect(struct inode * inode, unsigned long offset, unsigned long * p, int convert, unsigned char * dirt)
|
|
{
|
|
unsigned long indtmp, indblock;
|
|
struct super_block * sb;
|
|
struct buffer_head * indbh;
|
|
unsigned int i;
|
|
sysv_zone_t * ind;
|
|
unsigned long tmp, block;
|
|
int retry = 0;
|
|
|
|
indblock = indtmp = *p;
|
|
if (convert)
|
|
indblock = from_coh_ulong(indblock);
|
|
if (!indblock)
|
|
return 0;
|
|
sb = inode->i_sb;
|
|
indbh = bread(inode->i_dev,indblock+sb->sv_block_base,BLOCK_SIZE);
|
|
if (indtmp != *p) {
|
|
brelse(indbh);
|
|
return 1;
|
|
}
|
|
if (!indbh) {
|
|
*p = 0;
|
|
*dirt = 1;
|
|
return 0;
|
|
}
|
|
if (inode->i_size < offset)
|
|
i = 0;
|
|
else
|
|
i = (inode->i_size - offset + IND_PER_BLOCK*BLOCK_SIZE-1) / (IND_PER_BLOCK*BLOCK_SIZE);
|
|
for (; i < IND_PER_BLOCK; i++) {
|
|
ind = ((sysv_zone_t *) indbh->b_data) + i;
|
|
block = tmp = *ind;
|
|
if (sb->sv_convert)
|
|
block = from_coh_ulong(block);
|
|
if (!block)
|
|
continue;
|
|
retry |= trunc_indirect(inode,offset+i*IND_PER_BLOCK,ind,sb->sv_convert,&indbh->b_dirt);
|
|
}
|
|
for (i = 0; i < IND_PER_BLOCK; i++)
|
|
if (((sysv_zone_t *) indbh->b_data)[i])
|
|
goto done;
|
|
if ((indbh->b_count != 1) || (indtmp != *p)) {
|
|
brelse(indbh);
|
|
return 1;
|
|
}
|
|
*p = 0;
|
|
*dirt = 1;
|
|
sysv_free_block(sb,indblock);
|
|
done:
|
|
brelse(indbh);
|
|
return retry;
|
|
}
|
|
|
|
static int trunc_tindirect(struct inode * inode, unsigned long offset, unsigned long * p, int convert, unsigned char * dirt)
|
|
{
|
|
unsigned long indtmp, indblock;
|
|
struct super_block * sb;
|
|
struct buffer_head * indbh;
|
|
unsigned int i;
|
|
sysv_zone_t * ind;
|
|
unsigned long tmp, block;
|
|
int retry = 0;
|
|
|
|
indblock = indtmp = *p;
|
|
if (convert)
|
|
indblock = from_coh_ulong(indblock);
|
|
if (!indblock)
|
|
return 0;
|
|
sb = inode->i_sb;
|
|
indbh = bread(inode->i_dev,indblock+sb->sv_block_base,BLOCK_SIZE);
|
|
if (indtmp != *p) {
|
|
brelse(indbh);
|
|
return 1;
|
|
}
|
|
if (!indbh) {
|
|
*p = 0;
|
|
*dirt = 1;
|
|
return 0;
|
|
}
|
|
if (inode->i_size < offset)
|
|
i = 0;
|
|
else
|
|
i = (inode->i_size - offset + IND_PER_BLOCK*IND_PER_BLOCK*BLOCK_SIZE-1) / (IND_PER_BLOCK*IND_PER_BLOCK*BLOCK_SIZE);
|
|
for (; i < IND_PER_BLOCK; i++) {
|
|
ind = ((sysv_zone_t *) indbh->b_data) + i;
|
|
block = tmp = *ind;
|
|
if (sb->sv_convert)
|
|
block = from_coh_ulong(block);
|
|
if (!block)
|
|
continue;
|
|
retry |= trunc_dindirect(inode,offset+i*IND_PER_BLOCK*IND_PER_BLOCK,ind,sb->sv_convert,&indbh->b_dirt);
|
|
}
|
|
for (i = 0; i < IND_PER_BLOCK; i++)
|
|
if (((sysv_zone_t *) indbh->b_data)[i])
|
|
goto done;
|
|
if ((indbh->b_count != 1) || (indtmp != *p)) {
|
|
brelse(indbh);
|
|
return 1;
|
|
}
|
|
*p = 0;
|
|
*dirt = 1;
|
|
sysv_free_block(sb,indblock);
|
|
done:
|
|
brelse(indbh);
|
|
return retry;
|
|
}
|
|
|
|
static int trunc_all(struct inode * inode)
|
|
{
|
|
return trunc_direct(inode)
|
|
| trunc_indirect(inode,10*BLOCK_SIZE,&inode->u.sysv_i.i_data[10],0,&inode->i_dirt)
|
|
| trunc_dindirect(inode,(10+IND_PER_BLOCK)*BLOCK_SIZE,&inode->u.sysv_i.i_data[11],0,&inode->i_dirt)
|
|
| trunc_tindirect(inode,(10+IND_PER_BLOCK+IND_PER_BLOCK*IND_PER_BLOCK)*BLOCK_SIZE,&inode->u.sysv_i.i_data[12],0,&inode->i_dirt);
|
|
}
|
|
|
|
|
|
void sysv_truncate(struct inode * inode)
|
|
{
|
|
/* If this is called from sysv_put_inode, we needn't worry about
|
|
* races as we are just losing the last reference to the inode.
|
|
* If this is called from another place, let's hope it's a regular
|
|
* file.
|
|
* Truncating symbolic links is strange. We assume we don't truncate
|
|
* a directory we are just modifying. We ensure we don't truncate
|
|
* a regular file we are just writing to, by use of a lock.
|
|
*/
|
|
if (S_ISLNK(inode->i_mode))
|
|
printk("sysv_truncate: truncating symbolic link\n");
|
|
else if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode)))
|
|
return;
|
|
if (inode->i_sb->sv_block_size_ratio_bits > 0) { /* block_size < BLOCK_SIZE ? */
|
|
coh_lock_inode(inode); /* do not write to the inode while we truncate */
|
|
while (coh_trunc_all(inode)) {
|
|
current->counter = 0;
|
|
schedule();
|
|
}
|
|
inode->i_mtime = inode->i_ctime = CURRENT_TIME;
|
|
inode->i_dirt = 1;
|
|
coh_unlock_inode(inode);
|
|
} else {
|
|
while (trunc_all(inode)) {
|
|
current->counter = 0;
|
|
schedule();
|
|
}
|
|
inode->i_mtime = inode->i_ctime = CURRENT_TIME;
|
|
inode->i_dirt = 1;
|
|
}
|
|
}
|