dir.c 8.32 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1 2 3 4 5 6
/*
 *	fs/bfs/dir.c
 *	BFS directory operations.
 *	Copyright (C) 1999,2000  Tigran Aivazian <tigran@veritas.com>
 */

7
#include <linux/time.h>
Linus Torvalds's avatar
Linus Torvalds committed
8
#include <linux/string.h>
9
#include <linux/fs.h>
10
#include <linux/smp_lock.h>
11 12
#include <linux/buffer_head.h>
#include <linux/sched.h>
13
#include "bfs.h"
Linus Torvalds's avatar
Linus Torvalds committed
14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34

#undef DEBUG

#ifdef DEBUG
#define dprintf(x...)	printf(x)
#else
#define dprintf(x...)
#endif

static int bfs_add_entry(struct inode * dir, const char * name, int namelen, int ino);
static struct buffer_head * bfs_find_entry(struct inode * dir, 
	const char * name, int namelen, struct bfs_dirent ** res_dir);

static int bfs_readdir(struct file * f, void * dirent, filldir_t filldir)
{
	struct inode * dir = f->f_dentry->d_inode;
	struct buffer_head * bh;
	struct bfs_dirent * de;
	unsigned int offset;
	int block;

35 36
	lock_kernel();

Linus Torvalds's avatar
Linus Torvalds committed
37 38
	if (f->f_pos & (BFS_DIRENT_SIZE-1)) {
		printf("Bad f_pos=%08lx for %s:%08lx\n", (unsigned long)f->f_pos, 
Linus Torvalds's avatar
Linus Torvalds committed
39
			dir->i_sb->s_id, dir->i_ino);
40
		unlock_kernel();
Linus Torvalds's avatar
Linus Torvalds committed
41 42 43 44 45
		return -EBADF;
	}

	while (f->f_pos < dir->i_size) {
		offset = f->f_pos & (BFS_BSIZE-1);
Linus Torvalds's avatar
Linus Torvalds committed
46
		block = BFS_I(dir)->i_sblock + (f->f_pos >> BFS_BSIZE_BITS);
Linus Torvalds's avatar
Linus Torvalds committed
47
		bh = sb_bread(dir->i_sb, block);
Linus Torvalds's avatar
Linus Torvalds committed
48 49 50 51 52 53 54 55 56 57
		if (!bh) {
			f->f_pos += BFS_BSIZE - offset;
			continue;
		}
		do {
			de = (struct bfs_dirent *)(bh->b_data + offset);
			if (de->ino) {
				int size = strnlen(de->name, BFS_NAMELEN);
				if (filldir(dirent, de->name, size, f->f_pos, de->ino, DT_UNKNOWN) < 0) {
					brelse(bh);
58
					unlock_kernel();
Linus Torvalds's avatar
Linus Torvalds committed
59 60 61 62 63 64 65 66 67
					return 0;
				}
			}
			offset += BFS_DIRENT_SIZE;
			f->f_pos += BFS_DIRENT_SIZE;
		} while (offset < BFS_BSIZE && f->f_pos < dir->i_size);
		brelse(bh);
	}

68
	unlock_kernel();
Linus Torvalds's avatar
Linus Torvalds committed
69 70 71 72
	return 0;	
}

struct file_operations bfs_dir_operations = {
73 74 75
	.read		= generic_read_dir,
	.readdir	= bfs_readdir,
	.fsync		= file_fsync,
Linus Torvalds's avatar
Linus Torvalds committed
76 77 78 79
};

extern void dump_imap(const char *, struct super_block *);

80 81
static int bfs_create(struct inode * dir, struct dentry * dentry, int mode,
		struct nameidata *nd)
Linus Torvalds's avatar
Linus Torvalds committed
82 83 84 85
{
	int err;
	struct inode * inode;
	struct super_block * s = dir->i_sb;
86
	struct bfs_sb_info * info = BFS_SB(s);
Linus Torvalds's avatar
Linus Torvalds committed
87 88 89 90 91
	unsigned long ino;

	inode = new_inode(s);
	if (!inode)
		return -ENOSPC;
92
	lock_kernel();
93 94
	ino = find_first_zero_bit(info->si_imap, info->si_lasti);
	if (ino > info->si_lasti) {
95
		unlock_kernel();
Linus Torvalds's avatar
Linus Torvalds committed
96 97 98
		iput(inode);
		return -ENOSPC;
	}
99 100
	set_bit(ino, info->si_imap);	
	info->si_freei--;
Linus Torvalds's avatar
Linus Torvalds committed
101 102 103 104 105 106 107 108
	inode->i_uid = current->fsuid;
	inode->i_gid = (dir->i_mode & S_ISGID) ? dir->i_gid : current->fsgid;
	inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
	inode->i_blocks = inode->i_blksize = 0;
	inode->i_op = &bfs_file_inops;
	inode->i_fop = &bfs_file_operations;
	inode->i_mapping->a_ops = &bfs_aops;
	inode->i_mode = mode;
Linus Torvalds's avatar
Linus Torvalds committed
109 110 111 112
	inode->i_ino = ino;
	BFS_I(inode)->i_dsk_ino = ino;
	BFS_I(inode)->i_sblock = 0;
	BFS_I(inode)->i_eblock = 0;
Linus Torvalds's avatar
Linus Torvalds committed
113 114 115 116 117 118 119 120 121
	insert_inode_hash(inode);
        mark_inode_dirty(inode);
	dump_imap("create",s);

	err = bfs_add_entry(dir, dentry->d_name.name, dentry->d_name.len, inode->i_ino);
	if (err) {
		inode->i_nlink--;
		mark_inode_dirty(inode);
		iput(inode);
122
		unlock_kernel();
Linus Torvalds's avatar
Linus Torvalds committed
123 124
		return err;
	}
125
	unlock_kernel();
Linus Torvalds's avatar
Linus Torvalds committed
126 127 128 129
	d_instantiate(dentry, inode);
	return 0;
}

130
static struct dentry * bfs_lookup(struct inode * dir, struct dentry * dentry, struct nameidata *nd)
Linus Torvalds's avatar
Linus Torvalds committed
131 132 133 134 135 136 137 138
{
	struct inode * inode = NULL;
	struct buffer_head * bh;
	struct bfs_dirent * de;

	if (dentry->d_name.len > BFS_NAMELEN)
		return ERR_PTR(-ENAMETOOLONG);

139
	lock_kernel();
Linus Torvalds's avatar
Linus Torvalds committed
140 141 142 143 144
	bh = bfs_find_entry(dir, dentry->d_name.name, dentry->d_name.len, &de);
	if (bh) {
		unsigned long ino = le32_to_cpu(de->ino);
		brelse(bh);
		inode = iget(dir->i_sb, ino);
145 146
		if (!inode) {
			unlock_kernel();
Linus Torvalds's avatar
Linus Torvalds committed
147
			return ERR_PTR(-EACCES);
148
		}
Linus Torvalds's avatar
Linus Torvalds committed
149
	}
150
	unlock_kernel();
Linus Torvalds's avatar
Linus Torvalds committed
151 152 153 154 155 156 157 158 159
	d_add(dentry, inode);
	return NULL;
}

static int bfs_link(struct dentry * old, struct inode * dir, struct dentry * new)
{
	struct inode * inode = old->d_inode;
	int err;

160
	lock_kernel();
Linus Torvalds's avatar
Linus Torvalds committed
161
	err = bfs_add_entry(dir, new->d_name.name, new->d_name.len, inode->i_ino);
162 163
	if (err) {
		unlock_kernel();
Linus Torvalds's avatar
Linus Torvalds committed
164
		return err;
165
	}
Linus Torvalds's avatar
Linus Torvalds committed
166 167 168 169 170
	inode->i_nlink++;
	inode->i_ctime = CURRENT_TIME;
	mark_inode_dirty(inode);
	atomic_inc(&inode->i_count);
	d_instantiate(new, inode);
171
	unlock_kernel();
Linus Torvalds's avatar
Linus Torvalds committed
172 173 174 175 176 177 178 179 180 181 182 183
	return 0;
}


static int bfs_unlink(struct inode * dir, struct dentry * dentry)
{
	int error = -ENOENT;
	struct inode * inode;
	struct buffer_head * bh;
	struct bfs_dirent * de;

	inode = dentry->d_inode;
184
	lock_kernel();
Linus Torvalds's avatar
Linus Torvalds committed
185 186 187 188 189
	bh = bfs_find_entry(dir, dentry->d_name.name, dentry->d_name.len, &de);
	if (!bh || de->ino != inode->i_ino) 
		goto out_brelse;

	if (!inode->i_nlink) {
Linus Torvalds's avatar
Linus Torvalds committed
190
		printf("unlinking non-existent file %s:%lu (nlink=%d)\n", inode->i_sb->s_id, 
Linus Torvalds's avatar
Linus Torvalds committed
191 192 193 194 195 196 197 198 199 200 201 202 203 204
				inode->i_ino, inode->i_nlink);
		inode->i_nlink = 1;
	}
	de->ino = 0;
	mark_buffer_dirty(bh);
	dir->i_ctime = dir->i_mtime = CURRENT_TIME;
	mark_inode_dirty(dir);
	inode->i_nlink--;
	inode->i_ctime = dir->i_ctime;
	mark_inode_dirty(inode);
	error = 0;

out_brelse:
	brelse(bh);
205
	unlock_kernel();
Linus Torvalds's avatar
Linus Torvalds committed
206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221
	return error;
}

static int bfs_rename(struct inode * old_dir, struct dentry * old_dentry, 
			struct inode * new_dir, struct dentry * new_dentry)
{
	struct inode * old_inode, * new_inode;
	struct buffer_head * old_bh, * new_bh;
	struct bfs_dirent * old_de, * new_de;		
	int error = -ENOENT;

	old_bh = new_bh = NULL;
	old_inode = old_dentry->d_inode;
	if (S_ISDIR(old_inode->i_mode))
		return -EINVAL;

222
	lock_kernel();
Linus Torvalds's avatar
Linus Torvalds committed
223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258
	old_bh = bfs_find_entry(old_dir, 
				old_dentry->d_name.name, 
				old_dentry->d_name.len, &old_de);

	if (!old_bh || old_de->ino != old_inode->i_ino)
		goto end_rename;

	error = -EPERM;
	new_inode = new_dentry->d_inode;
	new_bh = bfs_find_entry(new_dir, 
				new_dentry->d_name.name, 
				new_dentry->d_name.len, &new_de);

	if (new_bh && !new_inode) {
		brelse(new_bh);
		new_bh = NULL;
	}
	if (!new_bh) {
		error = bfs_add_entry(new_dir, 
					new_dentry->d_name.name,
			 		new_dentry->d_name.len, old_inode->i_ino);
		if (error)
			goto end_rename;
	}
	old_de->ino = 0;
	old_dir->i_ctime = old_dir->i_mtime = CURRENT_TIME;
	mark_inode_dirty(old_dir);
	if (new_inode) {
		new_inode->i_nlink--;
		new_inode->i_ctime = CURRENT_TIME;
		mark_inode_dirty(new_inode);
	}
	mark_buffer_dirty(old_bh);
	error = 0;

end_rename:
259
	unlock_kernel();
Linus Torvalds's avatar
Linus Torvalds committed
260 261 262 263 264 265
	brelse(old_bh);
	brelse(new_bh);
	return error;
}

struct inode_operations bfs_dir_inops = {
266 267 268 269 270
	.create			= bfs_create,
	.lookup			= bfs_lookup,
	.link			= bfs_link,
	.unlink			= bfs_unlink,
	.rename			= bfs_rename,
Linus Torvalds's avatar
Linus Torvalds committed
271 272 273 274 275 276
};

static int bfs_add_entry(struct inode * dir, const char * name, int namelen, int ino)
{
	struct buffer_head * bh;
	struct bfs_dirent * de;
277
	int block, sblock, eblock, off, eoff;
Linus Torvalds's avatar
Linus Torvalds committed
278 279 280 281 282 283 284 285 286
	int i;

	dprintf("name=%s, namelen=%d\n", name, namelen);

	if (!namelen)
		return -ENOENT;
	if (namelen > BFS_NAMELEN)
		return -ENAMETOOLONG;

Linus Torvalds's avatar
Linus Torvalds committed
287 288
	sblock = BFS_I(dir)->i_sblock;
	eblock = BFS_I(dir)->i_eblock;
289
	eoff = dir->i_size % BFS_BSIZE;
Linus Torvalds's avatar
Linus Torvalds committed
290
	for (block=sblock; block<=eblock; block++) {
Linus Torvalds's avatar
Linus Torvalds committed
291
		bh = sb_bread(dir->i_sb, block);
Linus Torvalds's avatar
Linus Torvalds committed
292 293 294 295
		if(!bh) 
			return -ENOSPC;
		for (off=0; off<BFS_BSIZE; off+=BFS_DIRENT_SIZE) {
			de = (struct bfs_dirent *)(bh->b_data + off);
296 297 298 299
			if (block==eblock && off>=eoff) {
				/* Do not read/interpret the garbage in the end of eblock. */
				de->ino = 0;
			}
Linus Torvalds's avatar
Linus Torvalds committed
300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340
			if (!de->ino) {
				if ((block-sblock)*BFS_BSIZE + off >= dir->i_size) {
					dir->i_size += BFS_DIRENT_SIZE;
					dir->i_ctime = CURRENT_TIME;
				}
				dir->i_mtime = CURRENT_TIME;
				mark_inode_dirty(dir);
				de->ino = ino;
				for (i=0; i<BFS_NAMELEN; i++)
					de->name[i] = (i < namelen) ? name[i] : 0;
				mark_buffer_dirty(bh);
				brelse(bh);
				return 0;
			}
		}
		brelse(bh);
	}
	return -ENOSPC;
}

static inline int bfs_namecmp(int len, const char * name, const char * buffer)
{
	if (len < BFS_NAMELEN && buffer[len])
		return 0;
	return !memcmp(name, buffer, len);
}

static struct buffer_head * bfs_find_entry(struct inode * dir, 
	const char * name, int namelen, struct bfs_dirent ** res_dir)
{
	unsigned long block, offset;
	struct buffer_head * bh;
	struct bfs_dirent * de;

	*res_dir = NULL;
	if (namelen > BFS_NAMELEN)
		return NULL;
	bh = NULL;
	block = offset = 0;
	while (block * BFS_BSIZE + offset < dir->i_size) {
		if (!bh) {
Linus Torvalds's avatar
Linus Torvalds committed
341
			bh = sb_bread(dir->i_sb, BFS_I(dir)->i_sblock + block);
Linus Torvalds's avatar
Linus Torvalds committed
342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362
			if (!bh) {
				block++;
				continue;
			}
		}
		de = (struct bfs_dirent *)(bh->b_data + offset);
		offset += BFS_DIRENT_SIZE;
		if (de->ino && bfs_namecmp(namelen, name, de->name)) {
			*res_dir = de;
			return bh;
		}
		if (offset < bh->b_size)
			continue;
		brelse(bh);
		bh = NULL;
		offset = 0;
		block++;
	}
	brelse(bh);
	return NULL;
}