super.c 48.4 KB
Newer Older
1
#include <linux/module.h>
C
Chris Mason 已提交
2
#include <linux/buffer_head.h>
3 4 5 6 7 8 9 10
#include <linux/fs.h>
#include <linux/pagemap.h>
#include <linux/highmem.h>
#include <linux/time.h>
#include <linux/init.h>
#include <linux/string.h>
#include <linux/smp_lock.h>
#include <linux/backing-dev.h>
C
Chris Mason 已提交
11
#include <linux/mpage.h>
C
Chris Mason 已提交
12 13
#include <linux/swap.h>
#include <linux/writeback.h>
14
#include "ctree.h"
C
Chris Mason 已提交
15
#include "disk-io.h"
16
#include "transaction.h"
C
Chris Mason 已提交
17
#include "btrfs_inode.h"
C
Chris Mason 已提交
18
#include "ioctl.h"
19

20 21 22 23 24 25 26 27 28 29 30
void btrfs_fsinfo_release(struct kobject *obj)
{
	struct btrfs_fs_info *fsinfo = container_of(obj,
					    struct btrfs_fs_info, kobj);
	kfree(fsinfo);
}

struct kobj_type btrfs_fsinfo_ktype = {
	.release = btrfs_fsinfo_release,
};

C
Chris Mason 已提交
31 32 33 34 35
struct btrfs_iget_args {
	u64 ino;
	struct btrfs_root *root;
};

36 37
decl_subsys(btrfs, &btrfs_fsinfo_ktype, NULL);

38
#define BTRFS_SUPER_MAGIC 0x9123682E
C
Chris Mason 已提交
39 40

static struct inode_operations btrfs_dir_inode_operations;
41
static struct inode_operations btrfs_dir_ro_inode_operations;
C
Chris Mason 已提交
42 43
static struct super_operations btrfs_super_ops;
static struct file_operations btrfs_dir_file_operations;
C
Chris Mason 已提交
44 45 46
static struct inode_operations btrfs_file_inode_operations;
static struct address_space_operations btrfs_aops;
static struct file_operations btrfs_file_operations;
C
Chris Mason 已提交
47 48

static void btrfs_read_locked_inode(struct inode *inode)
49
{
50
	struct btrfs_path *path;
C
Chris Mason 已提交
51
	struct btrfs_inode_item *inode_item;
52 53
	struct btrfs_root *root = BTRFS_I(inode)->root;
	struct btrfs_key location;
C
Chris Mason 已提交
54
	int ret;
C
Chris Mason 已提交
55

56 57 58
	path = btrfs_alloc_path();
	BUG_ON(!path);
	btrfs_init_path(path);
C
Chris Mason 已提交
59 60
	mutex_lock(&root->fs_info->fs_mutex);

61 62
	memcpy(&location, &BTRFS_I(inode)->location, sizeof(location));
	ret = btrfs_lookup_inode(NULL, root, path, &location, 0);
C
Chris Mason 已提交
63
	if (ret) {
C
Chris Mason 已提交
64
		btrfs_free_path(path);
65
		goto make_bad;
C
Chris Mason 已提交
66
	}
67 68
	inode_item = btrfs_item_ptr(btrfs_buffer_leaf(path->nodes[0]),
				  path->slots[0],
C
Chris Mason 已提交
69
				  struct btrfs_inode_item);
70

C
Chris Mason 已提交
71 72 73 74 75 76 77 78 79 80 81 82 83
	inode->i_mode = btrfs_inode_mode(inode_item);
	inode->i_nlink = btrfs_inode_nlink(inode_item);
	inode->i_uid = btrfs_inode_uid(inode_item);
	inode->i_gid = btrfs_inode_gid(inode_item);
	inode->i_size = btrfs_inode_size(inode_item);
	inode->i_atime.tv_sec = btrfs_timespec_sec(&inode_item->atime);
	inode->i_atime.tv_nsec = btrfs_timespec_nsec(&inode_item->atime);
	inode->i_mtime.tv_sec = btrfs_timespec_sec(&inode_item->mtime);
	inode->i_mtime.tv_nsec = btrfs_timespec_nsec(&inode_item->mtime);
	inode->i_ctime.tv_sec = btrfs_timespec_sec(&inode_item->ctime);
	inode->i_ctime.tv_nsec = btrfs_timespec_nsec(&inode_item->ctime);
	inode->i_blocks = btrfs_inode_nblocks(inode_item);
	inode->i_generation = btrfs_inode_generation(inode_item);
84 85 86 87

	btrfs_free_path(path);
	inode_item = NULL;

C
Chris Mason 已提交
88
	mutex_unlock(&root->fs_info->fs_mutex);
C
Chris Mason 已提交
89

C
Chris Mason 已提交
90 91 92 93 94 95 96 97
	switch (inode->i_mode & S_IFMT) {
#if 0
	default:
		init_special_inode(inode, inode->i_mode,
				   btrfs_inode_rdev(inode_item));
		break;
#endif
	case S_IFREG:
C
Chris Mason 已提交
98 99 100
		inode->i_mapping->a_ops = &btrfs_aops;
		inode->i_fop = &btrfs_file_operations;
		inode->i_op = &btrfs_file_inode_operations;
C
Chris Mason 已提交
101 102 103
		break;
	case S_IFDIR:
		inode->i_fop = &btrfs_dir_file_operations;
104 105 106 107
		if (root == root->fs_info->tree_root)
			inode->i_op = &btrfs_dir_ro_inode_operations;
		else
			inode->i_op = &btrfs_dir_inode_operations;
C
Chris Mason 已提交
108 109 110 111
		break;
	case S_IFLNK:
		// inode->i_op = &page_symlink_inode_operations;
		break;
112
	}
C
Chris Mason 已提交
113
	return;
114 115 116 117 118 119

make_bad:
	btrfs_release_path(root, path);
	btrfs_free_path(path);
	mutex_unlock(&root->fs_info->fs_mutex);
	make_bad_inode(inode);
120 121
}

C
Chris Mason 已提交
122 123 124 125
static int btrfs_unlink_trans(struct btrfs_trans_handle *trans,
			      struct btrfs_root *root,
			      struct inode *dir,
			      struct dentry *dentry)
C
Chris Mason 已提交
126
{
127
	struct btrfs_path *path;
C
Chris Mason 已提交
128 129 130 131 132 133
	const char *name = dentry->d_name.name;
	int name_len = dentry->d_name.len;
	int ret;
	u64 objectid;
	struct btrfs_dir_item *di;

134 135 136 137
	path = btrfs_alloc_path();
	BUG_ON(!path);
	btrfs_init_path(path);
	ret = btrfs_lookup_dir_item(trans, root, path, dir->i_ino,
C
Chris Mason 已提交
138 139 140 141 142 143 144
				    name, name_len, -1);
	if (ret < 0)
		goto err;
	if (ret > 0) {
		ret = -ENOENT;
		goto err;
	}
145
	di = btrfs_item_ptr(btrfs_buffer_leaf(path->nodes[0]), path->slots[0],
C
Chris Mason 已提交
146
			    struct btrfs_dir_item);
147
	objectid = btrfs_disk_key_objectid(&di->location);
C
Chris Mason 已提交
148

149 150 151 152 153 154 155
	ret = btrfs_del_item(trans, root, path);
	BUG_ON(ret);

	btrfs_release_path(root, path);
	ret = btrfs_lookup_dir_index_item(trans, root, path, dir->i_ino,
					  objectid, -1);
	BUG_ON(ret);
156
	ret = btrfs_del_item(trans, root, path);
C
Chris Mason 已提交
157 158 159
	BUG_ON(ret);
	dentry->d_inode->i_ctime = dir->i_ctime;
err:
160 161
	btrfs_release_path(root, path);
	btrfs_free_path(path);
162
	if (ret == 0) {
C
Chris Mason 已提交
163
		inode_dec_link_count(dentry->d_inode);
164
		dir->i_size -= name_len * 2;
165 166
		mark_inode_dirty(dir);
	}
C
Chris Mason 已提交
167 168 169
	return ret;
}

C
Chris Mason 已提交
170 171 172 173 174 175
static int btrfs_unlink(struct inode *dir, struct dentry *dentry)
{
	struct btrfs_root *root;
	struct btrfs_trans_handle *trans;
	int ret;

176
	root = BTRFS_I(dir)->root;
C
Chris Mason 已提交
177 178 179 180 181 182 183 184 185 186 187 188 189
	mutex_lock(&root->fs_info->fs_mutex);
	trans = btrfs_start_transaction(root, 1);
	ret = btrfs_unlink_trans(trans, root, dir, dentry);
	btrfs_end_transaction(trans, root);
	mutex_unlock(&root->fs_info->fs_mutex);
	return ret;
}

static int btrfs_rmdir(struct inode *dir, struct dentry *dentry)
{
	struct inode *inode = dentry->d_inode;
	int err;
	int ret;
190
	struct btrfs_root *root = BTRFS_I(dir)->root;
191
	struct btrfs_path *path;
C
Chris Mason 已提交
192 193
	struct btrfs_key key;
	struct btrfs_trans_handle *trans;
194 195
	struct btrfs_key found_key;
	int found_type;
C
Chris Mason 已提交
196
	struct btrfs_leaf *leaf;
197
	char *goodnames = "..";
C
Chris Mason 已提交
198

199 200 201
	path = btrfs_alloc_path();
	BUG_ON(!path);
	btrfs_init_path(path);
C
Chris Mason 已提交
202 203 204 205
	mutex_lock(&root->fs_info->fs_mutex);
	trans = btrfs_start_transaction(root, 1);
	key.objectid = inode->i_ino;
	key.offset = (u64)-1;
206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235
	key.flags = (u32)-1;
	while(1) {
		ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
		if (ret < 0) {
			err = ret;
			goto out;
		}
		BUG_ON(ret == 0);
		if (path->slots[0] == 0) {
			err = -ENOENT;
			goto out;
		}
		path->slots[0]--;
		leaf = btrfs_buffer_leaf(path->nodes[0]);
		btrfs_disk_key_to_cpu(&found_key,
				      &leaf->items[path->slots[0]].key);
		found_type = btrfs_key_type(&found_key);
		if (found_key.objectid != inode->i_ino) {
			err = -ENOENT;
			goto out;
		}
		if ((found_type != BTRFS_DIR_ITEM_KEY &&
		     found_type != BTRFS_DIR_INDEX_KEY) ||
	            (!btrfs_match_dir_item_name(root, path, goodnames, 2) &&
	            !btrfs_match_dir_item_name(root, path, goodnames, 1))) {
			err = -ENOTEMPTY;
			goto out;
		}
		ret = btrfs_del_item(trans, root, path);
		BUG_ON(ret);
C
Chris Mason 已提交
236

237 238 239
		if (found_type == BTRFS_DIR_ITEM_KEY && found_key.offset == 1)
			break;
		btrfs_release_path(root, path);
C
Chris Mason 已提交
240
	}
241
	ret = 0;
242
	btrfs_release_path(root, path);
C
Chris Mason 已提交
243 244 245 246 247 248 249

	/* now the directory is empty */
	err = btrfs_unlink_trans(trans, root, dir, dentry);
	if (!err) {
		inode->i_size = 0;
	}
out:
C
Chris Mason 已提交
250 251
	btrfs_release_path(root, path);
	btrfs_free_path(path);
C
Chris Mason 已提交
252 253 254 255 256 257 258
	mutex_unlock(&root->fs_info->fs_mutex);
	ret = btrfs_end_transaction(trans, root);
	if (ret && !err)
		err = ret;
	return err;
}

C
Chris Mason 已提交
259 260 261 262
static int btrfs_free_inode(struct btrfs_trans_handle *trans,
			    struct btrfs_root *root,
			    struct inode *inode)
{
263
	struct btrfs_path *path;
C
Chris Mason 已提交
264
	int ret;
265

C
Chris Mason 已提交
266
	clear_inode(inode);
267 268 269 270

	path = btrfs_alloc_path();
	BUG_ON(!path);
	btrfs_init_path(path);
271 272
	ret = btrfs_lookup_inode(trans, root, path,
				 &BTRFS_I(inode)->location, -1);
C
Chris Mason 已提交
273
	BUG_ON(ret);
274
	ret = btrfs_del_item(trans, root, path);
C
Chris Mason 已提交
275
	BUG_ON(ret);
276
	btrfs_free_path(path);
C
Chris Mason 已提交
277 278 279
	return ret;
}

C
Chris Mason 已提交
280 281 282 283 284
static int btrfs_truncate_in_trans(struct btrfs_trans_handle *trans,
				   struct btrfs_root *root,
				   struct inode *inode)
{
	int ret;
285
	struct btrfs_path *path;
C
Chris Mason 已提交
286 287 288
	struct btrfs_key key;
	struct btrfs_disk_key *found_key;
	struct btrfs_leaf *leaf;
C
Chris Mason 已提交
289 290 291 292
	struct btrfs_file_extent_item *fi = NULL;
	u64 extent_start = 0;
	u64 extent_num_blocks = 0;
	int found_extent;
C
Chris Mason 已提交
293

294 295
	path = btrfs_alloc_path();
	BUG_ON(!path);
C
Chris Mason 已提交
296 297 298 299
	/* FIXME, add redo link to tree so we don't leak on crash */
	key.objectid = inode->i_ino;
	key.offset = (u64)-1;
	key.flags = 0;
300 301 302 303
	/*
	 * use BTRFS_CSUM_ITEM_KEY because it is larger than inline keys
	 * or extent data
	 */
C
Chris Mason 已提交
304
	btrfs_set_key_type(&key, BTRFS_CSUM_ITEM_KEY);
C
Chris Mason 已提交
305
	while(1) {
306 307
		btrfs_init_path(path);
		ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
C
Chris Mason 已提交
308 309 310 311
		if (ret < 0) {
			goto error;
		}
		if (ret > 0) {
312 313
			BUG_ON(path->slots[0] == 0);
			path->slots[0]--;
C
Chris Mason 已提交
314
		}
315 316
		leaf = btrfs_buffer_leaf(path->nodes[0]);
		found_key = &leaf->items[path->slots[0]].key;
C
Chris Mason 已提交
317 318
		if (btrfs_disk_key_objectid(found_key) != inode->i_ino)
			break;
C
Chris Mason 已提交
319
		if (btrfs_disk_key_type(found_key) != BTRFS_CSUM_ITEM_KEY &&
320
		    btrfs_disk_key_type(found_key) != BTRFS_INLINE_DATA_KEY &&
C
Chris Mason 已提交
321
		    btrfs_disk_key_type(found_key) != BTRFS_EXTENT_DATA_KEY)
C
Chris Mason 已提交
322 323 324
			break;
		if (btrfs_disk_key_offset(found_key) < inode->i_size)
			break;
C
Chris Mason 已提交
325
		if (btrfs_disk_key_type(found_key) == BTRFS_EXTENT_DATA_KEY) {
326 327
			fi = btrfs_item_ptr(btrfs_buffer_leaf(path->nodes[0]),
					    path->slots[0],
C
Chris Mason 已提交
328 329 330 331 332 333 334 335 336 337
					    struct btrfs_file_extent_item);
			extent_start = btrfs_file_extent_disk_blocknr(fi);
			extent_num_blocks =
				btrfs_file_extent_disk_num_blocks(fi);
			inode->i_blocks -=
				btrfs_file_extent_num_blocks(fi) >> 9;
			found_extent = 1;
		} else {
			found_extent = 0;
		}
338
		ret = btrfs_del_item(trans, root, path);
C
Chris Mason 已提交
339
		BUG_ON(ret);
340
		btrfs_release_path(root, path);
C
Chris Mason 已提交
341 342 343 344 345
		if (found_extent) {
			ret = btrfs_free_extent(trans, root, extent_start,
						extent_num_blocks, 0);
			BUG_ON(ret);
		}
C
Chris Mason 已提交
346 347 348
	}
	ret = 0;
error:
349 350
	btrfs_release_path(root, path);
	btrfs_free_path(path);
C
Chris Mason 已提交
351 352 353
	return ret;
}

C
Chris Mason 已提交
354 355 356
static void btrfs_delete_inode(struct inode *inode)
{
	struct btrfs_trans_handle *trans;
357
	struct btrfs_root *root = BTRFS_I(inode)->root;
C
Chris Mason 已提交
358 359
	int ret;

C
Chris Mason 已提交
360 361 362 363 364 365 366
	truncate_inode_pages(&inode->i_data, 0);
	if (is_bad_inode(inode)) {
		goto no_delete;
	}
	inode->i_size = 0;
	mutex_lock(&root->fs_info->fs_mutex);
	trans = btrfs_start_transaction(root, 1);
C
Chris Mason 已提交
367 368 369 370
	if (S_ISREG(inode->i_mode)) {
		ret = btrfs_truncate_in_trans(trans, root, inode);
		BUG_ON(ret);
	}
C
Chris Mason 已提交
371 372 373 374 375 376 377 378
	btrfs_free_inode(trans, root, inode);
	btrfs_end_transaction(trans, root);
	mutex_unlock(&root->fs_info->fs_mutex);
	return;
no_delete:
	clear_inode(inode);
}

C
Chris Mason 已提交
379
static int btrfs_inode_by_name(struct inode *dir, struct dentry *dentry,
380
			       struct btrfs_key *location)
C
Chris Mason 已提交
381 382 383 384
{
	const char *name = dentry->d_name.name;
	int namelen = dentry->d_name.len;
	struct btrfs_dir_item *di;
385
	struct btrfs_path *path;
386
	struct btrfs_root *root = BTRFS_I(dir)->root;
C
Chris Mason 已提交
387 388
	int ret;

389 390 391 392
	path = btrfs_alloc_path();
	BUG_ON(!path);
	btrfs_init_path(path);
	ret = btrfs_lookup_dir_item(NULL, root, path, dir->i_ino, name,
C
Chris Mason 已提交
393
				    namelen, 0);
394
	if (ret || !btrfs_match_dir_item_name(root, path, name, namelen)) {
395
		location->objectid = 0;
C
Chris Mason 已提交
396
		ret = 0;
C
Chris Mason 已提交
397 398
		goto out;
	}
399
	di = btrfs_item_ptr(btrfs_buffer_leaf(path->nodes[0]), path->slots[0],
C
Chris Mason 已提交
400
			    struct btrfs_dir_item);
401
	btrfs_disk_key_to_cpu(location, &di->location);
C
Chris Mason 已提交
402
out:
403 404
	btrfs_release_path(root, path);
	btrfs_free_path(path);
C
Chris Mason 已提交
405 406 407
	return ret;
}

408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423
int fixup_tree_root_location(struct btrfs_root *root,
			     struct btrfs_key *location,
			     struct btrfs_root **sub_root)
{
	struct btrfs_path *path;
	struct btrfs_root_item *ri;

	if (btrfs_key_type(location) != BTRFS_ROOT_ITEM_KEY)
		return 0;
	if (location->objectid == BTRFS_ROOT_TREE_OBJECTID)
		return 0;

	path = btrfs_alloc_path();
	BUG_ON(!path);
	mutex_lock(&root->fs_info->fs_mutex);

424 425 426 427 428
	*sub_root = btrfs_read_fs_root(root->fs_info, location);
	if (IS_ERR(*sub_root))
		return PTR_ERR(*sub_root);

	ri = &(*sub_root)->root_item;
429 430 431 432
	location->objectid = btrfs_root_dirid(ri);
	location->flags = 0;
	btrfs_set_key_type(location, BTRFS_INODE_ITEM_KEY);
	location->offset = 0;
433

434 435
	btrfs_free_path(path);
	mutex_unlock(&root->fs_info->fs_mutex);
436
	return 0;
437 438
}

C
Chris Mason 已提交
439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466
int btrfs_init_locked_inode(struct inode *inode, void *p)
{
	struct btrfs_iget_args *args = p;
	inode->i_ino = args->ino;
	BTRFS_I(inode)->root = args->root;
	return 0;
}

int btrfs_find_actor(struct inode *inode, void *opaque)
{
	struct btrfs_iget_args *args = opaque;
	return (args->ino == inode->i_ino &&
		args->root == BTRFS_I(inode)->root);
}

struct inode *btrfs_iget_locked(struct super_block *s, u64 objectid,
				struct btrfs_root *root)
{
	struct inode *inode;
	struct btrfs_iget_args args;
	args.ino = objectid;
	args.root = root;

	inode = iget5_locked(s, objectid, btrfs_find_actor,
			     btrfs_init_locked_inode,
			     (void *)&args);
	return inode;
}
467

C
Chris Mason 已提交
468 469 470 471
static struct dentry *btrfs_lookup(struct inode *dir, struct dentry *dentry,
				   struct nameidata *nd)
{
	struct inode * inode;
472 473 474 475
	struct btrfs_inode *bi = BTRFS_I(dir);
	struct btrfs_root *root = bi->root;
	struct btrfs_root *sub_root = root;
	struct btrfs_key location;
C
Chris Mason 已提交
476 477 478 479
	int ret;

	if (dentry->d_name.len > BTRFS_NAME_LEN)
		return ERR_PTR(-ENAMETOOLONG);
C
Chris Mason 已提交
480
	mutex_lock(&root->fs_info->fs_mutex);
481
	ret = btrfs_inode_by_name(dir, dentry, &location);
C
Chris Mason 已提交
482
	mutex_unlock(&root->fs_info->fs_mutex);
C
Chris Mason 已提交
483 484 485
	if (ret < 0)
		return ERR_PTR(ret);
	inode = NULL;
486 487 488 489 490 491
	if (location.objectid) {
		ret = fixup_tree_root_location(root, &location, &sub_root);
		if (ret < 0)
			return ERR_PTR(ret);
		if (ret > 0)
			return ERR_PTR(-ENOENT);
C
Chris Mason 已提交
492 493
		inode = btrfs_iget_locked(dir->i_sb, location.objectid,
					  sub_root);
C
Chris Mason 已提交
494 495
		if (!inode)
			return ERR_PTR(-EACCES);
496
		if (inode->i_state & I_NEW) {
497 498 499 500 501
			if (sub_root != root) {
				ret = radix_tree_insert(
						&root->fs_info->fs_roots_radix,
						(unsigned long)sub_root,
						sub_root);
C
Chris Mason 已提交
502
printk("adding new root for inode %lu root %p (found %p)\n", inode->i_ino, sub_root, BTRFS_I(inode)->root);
503 504 505
				igrab(inode);
				sub_root->inode = inode;
			}
506 507 508 509 510 511
			BTRFS_I(inode)->root = sub_root;
			memcpy(&BTRFS_I(inode)->location, &location,
			       sizeof(location));
			btrfs_read_locked_inode(inode);
			unlock_new_inode(inode);
		}
C
Chris Mason 已提交
512 513 514 515 516 517 518
	}
	return d_splice_alias(inode, dentry);
}

static int btrfs_readdir(struct file *filp, void *dirent, filldir_t filldir)
{
	struct inode *inode = filp->f_path.dentry->d_inode;
519
	struct btrfs_root *root = BTRFS_I(inode)->root;
C
Chris Mason 已提交
520 521 522
	struct btrfs_item *item;
	struct btrfs_dir_item *di;
	struct btrfs_key key;
523
	struct btrfs_path *path;
C
Chris Mason 已提交
524 525 526 527 528 529
	int ret;
	u32 nritems;
	struct btrfs_leaf *leaf;
	int slot;
	int advance;
	unsigned char d_type = DT_UNKNOWN;
530
	int over = 0;
531 532 533 534 535
	int key_type = BTRFS_DIR_INDEX_KEY;

	/* FIXME, use a real flag for deciding about the key type */
	if (root->fs_info->tree_root == root)
		key_type = BTRFS_DIR_ITEM_KEY;
C
Chris Mason 已提交
536
	mutex_lock(&root->fs_info->fs_mutex);
C
Chris Mason 已提交
537 538
	key.objectid = inode->i_ino;
	key.flags = 0;
539
	btrfs_set_key_type(&key, key_type);
C
Chris Mason 已提交
540
	key.offset = filp->f_pos;
541 542 543
	path = btrfs_alloc_path();
	btrfs_init_path(path);
	ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
C
Chris Mason 已提交
544
	if (ret < 0)
C
Chris Mason 已提交
545
		goto err;
546
	advance = 0;
C
Chris Mason 已提交
547
	while(1) {
548
		leaf = btrfs_buffer_leaf(path->nodes[0]);
C
Chris Mason 已提交
549
		nritems = btrfs_header_nritems(&leaf->header);
550
		slot = path->slots[0];
C
Chris Mason 已提交
551 552
		if (advance || slot >= nritems) {
			if (slot >= nritems -1) {
553
				ret = btrfs_next_leaf(root, path);
C
Chris Mason 已提交
554 555
				if (ret)
					break;
556
				leaf = btrfs_buffer_leaf(path->nodes[0]);
C
Chris Mason 已提交
557
				nritems = btrfs_header_nritems(&leaf->header);
558
				slot = path->slots[0];
C
Chris Mason 已提交
559 560
			} else {
				slot++;
561
				path->slots[0]++;
C
Chris Mason 已提交
562 563 564 565 566 567
			}
		}
		advance = 1;
		item = leaf->items + slot;
		if (btrfs_disk_key_objectid(&item->key) != key.objectid)
			break;
568
		if (key_type == BTRFS_DIR_INDEX_KEY &&
C
Chris Mason 已提交
569
		    btrfs_disk_key_offset(&item->key) > root->highest_inode)
C
Chris Mason 已提交
570
			break;
571
		if (btrfs_disk_key_type(&item->key) != key_type)
C
Chris Mason 已提交
572
			continue;
573 574
		if (btrfs_disk_key_offset(&item->key) < filp->f_pos)
			continue;
575
		filp->f_pos = btrfs_disk_key_offset(&item->key);
C
Chris Mason 已提交
576
		advance = 1;
C
Chris Mason 已提交
577 578 579 580
		di = btrfs_item_ptr(leaf, slot, struct btrfs_dir_item);
		over = filldir(dirent, (const char *)(di + 1),
			       btrfs_dir_name_len(di),
			       btrfs_disk_key_offset(&item->key),
581
			       btrfs_disk_key_objectid(&di->location), d_type);
582 583
		if (over)
			goto nopos;
C
Chris Mason 已提交
584
	}
585 586
	filp->f_pos++;
nopos:
C
Chris Mason 已提交
587 588
	ret = 0;
err:
589 590
	btrfs_release_path(root, path);
	btrfs_free_path(path);
C
Chris Mason 已提交
591
	mutex_unlock(&root->fs_info->fs_mutex);
C
Chris Mason 已提交
592 593 594 595 596 597 598 599 600 601 602 603 604 605
	return ret;
}

static void btrfs_put_super (struct super_block * sb)
{
	struct btrfs_root *root = btrfs_sb(sb);
	int ret;

	ret = close_ctree(root);
	if (ret) {
		printk("close ctree returns %d\n", ret);
	}
	sb->s_fs_info = NULL;
}
606 607 608 609

static int btrfs_fill_super(struct super_block * sb, void * data, int silent)
{
	struct inode * inode;
C
Chris Mason 已提交
610 611
	struct dentry * root_dentry;
	struct btrfs_super_block *disk_super;
612
	struct btrfs_root *tree_root;
613
	struct btrfs_inode *bi;
614 615 616

	sb->s_maxbytes = MAX_LFS_FILESIZE;
	sb->s_magic = BTRFS_SUPER_MAGIC;
C
Chris Mason 已提交
617
	sb->s_op = &btrfs_super_ops;
618
	sb->s_time_gran = 1;
C
Chris Mason 已提交
619

620
	tree_root = open_ctree(sb);
621

622
	if (!tree_root) {
C
Chris Mason 已提交
623 624 625
		printk("btrfs: open_ctree failed\n");
		return -EIO;
	}
626 627
	sb->s_fs_info = tree_root;
	disk_super = tree_root->fs_info->disk_super;
C
Chris Mason 已提交
628 629 630 631
	printk("read in super total blocks %Lu root %Lu\n",
	       btrfs_super_total_blocks(disk_super),
	       btrfs_super_root_dir(disk_super));

C
Chris Mason 已提交
632 633
	inode = btrfs_iget_locked(sb, btrfs_super_root_dir(disk_super),
				  tree_root);
634 635 636 637
	bi = BTRFS_I(inode);
	bi->location.objectid = inode->i_ino;
	bi->location.offset = 0;
	bi->location.flags = 0;
638
	bi->root = tree_root;
639 640
	btrfs_set_key_type(&bi->location, BTRFS_INODE_ITEM_KEY);

641 642
	if (!inode)
		return -ENOMEM;
C
Chris Mason 已提交
643 644 645 646
	if (inode->i_state & I_NEW) {
		btrfs_read_locked_inode(inode);
		unlock_new_inode(inode);
	}
647

C
Chris Mason 已提交
648 649
	root_dentry = d_alloc_root(inode);
	if (!root_dentry) {
650 651 652
		iput(inode);
		return -ENOMEM;
	}
C
Chris Mason 已提交
653 654
	sb->s_root = root_dentry;

655 656 657
	return 0;
}

658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675
static void fill_inode_item(struct btrfs_inode_item *item,
			    struct inode *inode)
{
	btrfs_set_inode_uid(item, inode->i_uid);
	btrfs_set_inode_gid(item, inode->i_gid);
	btrfs_set_inode_size(item, inode->i_size);
	btrfs_set_inode_mode(item, inode->i_mode);
	btrfs_set_inode_nlink(item, inode->i_nlink);
	btrfs_set_timespec_sec(&item->atime, inode->i_atime.tv_sec);
	btrfs_set_timespec_nsec(&item->atime, inode->i_atime.tv_nsec);
	btrfs_set_timespec_sec(&item->mtime, inode->i_mtime.tv_sec);
	btrfs_set_timespec_nsec(&item->mtime, inode->i_mtime.tv_nsec);
	btrfs_set_timespec_sec(&item->ctime, inode->i_ctime.tv_sec);
	btrfs_set_timespec_nsec(&item->ctime, inode->i_ctime.tv_nsec);
	btrfs_set_inode_nblocks(item, inode->i_blocks);
	btrfs_set_inode_generation(item, inode->i_generation);
}

C
Chris Mason 已提交
676 677 678 679 680
static int btrfs_update_inode(struct btrfs_trans_handle *trans,
			      struct btrfs_root *root,
			      struct inode *inode)
{
	struct btrfs_inode_item *inode_item;
681
	struct btrfs_path *path;
C
Chris Mason 已提交
682 683
	int ret;

684 685 686
	path = btrfs_alloc_path();
	BUG_ON(!path);
	btrfs_init_path(path);
687 688
	ret = btrfs_lookup_inode(trans, root, path,
				 &BTRFS_I(inode)->location, 1);
C
Chris Mason 已提交
689 690 691 692 693 694
	if (ret) {
		if (ret > 0)
			ret = -ENOENT;
		goto failed;
	}

695 696
	inode_item = btrfs_item_ptr(btrfs_buffer_leaf(path->nodes[0]),
				  path->slots[0],
C
Chris Mason 已提交
697 698 699
				  struct btrfs_inode_item);

	fill_inode_item(inode_item, inode);
700
	btrfs_mark_buffer_dirty(path->nodes[0]);
C
Chris Mason 已提交
701
	ret = 0;
C
Chris Mason 已提交
702
failed:
703 704
	btrfs_release_path(root, path);
	btrfs_free_path(path);
C
Chris Mason 已提交
705
	return ret;
C
Chris Mason 已提交
706 707 708 709
}

static int btrfs_write_inode(struct inode *inode, int wait)
{
710
	struct btrfs_root *root = BTRFS_I(inode)->root;
C
Chris Mason 已提交
711 712 713 714 715 716 717 718 719 720 721 722 723 724
	struct btrfs_trans_handle *trans;
	int ret;

	mutex_lock(&root->fs_info->fs_mutex);
	trans = btrfs_start_transaction(root, 1);
	ret = btrfs_update_inode(trans, root, inode);
	if (wait)
		btrfs_commit_transaction(trans, root);
	else
		btrfs_end_transaction(trans, root);
	mutex_unlock(&root->fs_info->fs_mutex);
	return ret;
}

725 726 727 728 729
static struct inode *btrfs_new_inode(struct btrfs_trans_handle *trans,
				     struct inode *dir, int mode)
{
	struct inode *inode;
	struct btrfs_inode_item inode_item;
730
	struct btrfs_root *root = BTRFS_I(dir)->root;
C
Chris Mason 已提交
731
	struct btrfs_key *location;
732 733 734 735 736 737 738
	int ret;
	u64 objectid;

	inode = new_inode(dir->i_sb);
	if (!inode)
		return ERR_PTR(-ENOMEM);

739
	BTRFS_I(inode)->root = BTRFS_I(dir)->root;
740 741 742 743 744 745 746 747
	ret = btrfs_find_free_objectid(trans, root, dir->i_ino, &objectid);
	BUG_ON(ret);

	inode->i_uid = current->fsuid;
	inode->i_gid = current->fsgid;
	inode->i_mode = mode;
	inode->i_ino = objectid;
	inode->i_blocks = 0;
C
Chris Mason 已提交
748
	inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
749
	fill_inode_item(&inode_item, inode);
C
Chris Mason 已提交
750 751 752 753 754
	location = &BTRFS_I(inode)->location;
	location->objectid = objectid;
	location->flags = 0;
	location->offset = 0;
	btrfs_set_key_type(location, BTRFS_INODE_ITEM_KEY);
755 756 757 758 759 760 761 762 763 764 765 766

	ret = btrfs_insert_inode(trans, root, objectid, &inode_item);
	BUG_ON(ret);

	insert_inode_hash(inode);
	return inode;
}

static int btrfs_add_link(struct btrfs_trans_handle *trans,
			    struct dentry *dentry, struct inode *inode)
{
	int ret;
767 768 769 770 771 772 773 774
	struct btrfs_key key;
	struct btrfs_root *root = BTRFS_I(dentry->d_parent->d_inode)->root;
	key.objectid = inode->i_ino;
	key.flags = 0;
	btrfs_set_key_type(&key, BTRFS_INODE_ITEM_KEY);
	key.offset = 0;

	ret = btrfs_insert_dir_item(trans, root,
775 776
				    dentry->d_name.name, dentry->d_name.len,
				    dentry->d_parent->d_inode->i_ino,
777
				    &key, 0);
C
Chris Mason 已提交
778
	if (ret == 0) {
779
		dentry->d_parent->d_inode->i_size += dentry->d_name.len * 2;
780
		ret = btrfs_update_inode(trans, root,
C
Chris Mason 已提交
781 782
					 dentry->d_parent->d_inode);
	}
783 784 785 786 787 788 789 790 791 792 793
	return ret;
}

static int btrfs_add_nondir(struct btrfs_trans_handle *trans,
			    struct dentry *dentry, struct inode *inode)
{
	int err = btrfs_add_link(trans, dentry, inode);
	if (!err) {
		d_instantiate(dentry, inode);
		return 0;
	}
C
Chris Mason 已提交
794 795
	if (err > 0)
		err = -EEXIST;
796 797 798 799 800 801 802
	return err;
}

static int btrfs_create(struct inode *dir, struct dentry *dentry,
			int mode, struct nameidata *nd)
{
	struct btrfs_trans_handle *trans;
803
	struct btrfs_root *root = BTRFS_I(dir)->root;
804 805
	struct inode *inode;
	int err;
C
Chris Mason 已提交
806
	int drop_inode = 0;
807

C
Chris Mason 已提交
808
	mutex_lock(&root->fs_info->fs_mutex);
809 810 811 812
	trans = btrfs_start_transaction(root, 1);
	inode = btrfs_new_inode(trans, dir, mode);
	err = PTR_ERR(inode);
	if (IS_ERR(inode))
C
Chris Mason 已提交
813
		goto out_unlock;
814 815
	// FIXME mark the inode dirty
	err = btrfs_add_nondir(trans, dentry, inode);
C
Chris Mason 已提交
816 817
	if (err)
		drop_inode = 1;
C
Chris Mason 已提交
818 819 820 821 822
	else {
		inode->i_mapping->a_ops = &btrfs_aops;
		inode->i_fop = &btrfs_file_operations;
		inode->i_op = &btrfs_file_inode_operations;
	}
823
	dir->i_sb->s_dirt = 1;
C
Chris Mason 已提交
824
out_unlock:
C
Chris Mason 已提交
825
	btrfs_end_transaction(trans, root);
C
Chris Mason 已提交
826
	mutex_unlock(&root->fs_info->fs_mutex);
C
Chris Mason 已提交
827

C
Chris Mason 已提交
828 829 830 831
	if (drop_inode) {
		inode_dec_link_count(inode);
		iput(inode);
	}
832 833 834
	return err;
}

C
Chris Mason 已提交
835 836 837
static int btrfs_make_empty_dir(struct btrfs_trans_handle *trans,
				struct inode *inode, struct inode *dir)
{
838
	struct btrfs_root *root = BTRFS_I(dir)->root;
C
Chris Mason 已提交
839 840
	int ret;
	char buf[2];
841 842
	struct btrfs_key key;

C
Chris Mason 已提交
843 844 845
	buf[0] = '.';
	buf[1] = '.';

846 847 848 849 850
	key.objectid = inode->i_ino;
	key.offset = 0;
	key.flags = 0;
	btrfs_set_key_type(&key, BTRFS_INODE_ITEM_KEY);

C
Chris Mason 已提交
851
	ret = btrfs_insert_dir_item(trans, root, buf, 1, inode->i_ino,
852
				    &key, 1);
C
Chris Mason 已提交
853 854
	if (ret)
		goto error;
855
	key.objectid = dir->i_ino;
C
Chris Mason 已提交
856
	ret = btrfs_insert_dir_item(trans, root, buf, 2, inode->i_ino,
857
				    &key, 1);
C
Chris Mason 已提交
858 859
	if (ret)
		goto error;
860
	inode->i_size = 6;
C
Chris Mason 已提交
861
	ret = btrfs_update_inode(trans, root, inode);
C
Chris Mason 已提交
862 863 864 865 866 867 868 869
error:
	return ret;
}

static int btrfs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
{
	struct inode *inode;
	struct btrfs_trans_handle *trans;
870
	struct btrfs_root *root = BTRFS_I(dir)->root;
C
Chris Mason 已提交
871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906
	int err = 0;
	int drop_on_err = 0;

	mutex_lock(&root->fs_info->fs_mutex);
	trans = btrfs_start_transaction(root, 1);
	if (IS_ERR(trans)) {
		err = PTR_ERR(trans);
		goto out_unlock;
	}
	inode = btrfs_new_inode(trans, dir, S_IFDIR | mode);
	if (IS_ERR(inode)) {
		err = PTR_ERR(inode);
		goto out_fail;
	}
	drop_on_err = 1;
	inode->i_op = &btrfs_dir_inode_operations;
	inode->i_fop = &btrfs_dir_file_operations;

	err = btrfs_make_empty_dir(trans, inode, dir);
	if (err)
		goto out_fail;
	err = btrfs_add_link(trans, dentry, inode);
	if (err)
		goto out_fail;
	d_instantiate(dentry, inode);
	drop_on_err = 0;

out_fail:
	btrfs_end_transaction(trans, root);
out_unlock:
	mutex_unlock(&root->fs_info->fs_mutex);
	if (drop_on_err)
		iput(inode);
	return err;
}

907 908 909 910 911
static int btrfs_sync_fs(struct super_block *sb, int wait)
{
	struct btrfs_trans_handle *trans;
	struct btrfs_root *root;
	int ret;
912
	root = btrfs_sb(sb);
913

914
	sb->s_dirt = 0;
C
Chris Mason 已提交
915
	if (!wait) {
C
Chris Mason 已提交
916
		filemap_flush(root->fs_info->btree_inode->i_mapping);
C
Chris Mason 已提交
917 918
		return 0;
	}
C
Chris Mason 已提交
919
	filemap_write_and_wait(root->fs_info->btree_inode->i_mapping);
C
Chris Mason 已提交
920
	mutex_lock(&root->fs_info->fs_mutex);
921 922 923 924 925
	trans = btrfs_start_transaction(root, 1);
	ret = btrfs_commit_transaction(trans, root);
	sb->s_dirt = 0;
	BUG_ON(ret);
printk("btrfs sync_fs\n");
C
Chris Mason 已提交
926
	mutex_unlock(&root->fs_info->fs_mutex);
927 928 929
	return 0;
}

930
#if 0
C
Chris Mason 已提交
931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996
static int btrfs_get_block_inline(struct inode *inode, sector_t iblock,
			   struct buffer_head *result, int create)
{
	struct btrfs_root *root = btrfs_sb(inode->i_sb);
	struct btrfs_path *path;
	struct btrfs_key key;
	struct btrfs_leaf *leaf;
	int num_bytes = result->b_size;
	int item_size;
	int ret;
	u64 pos;
	char *ptr;
	int copy_size;
	int err = 0;
	char *safe_ptr;
	char *data_ptr;

	path = btrfs_alloc_path();
	BUG_ON(!path);

	WARN_ON(create);
	if (create) {
		return 0;
	}
	pos = iblock << inode->i_blkbits;
	key.objectid = inode->i_ino;
	key.flags = 0;
	btrfs_set_key_type(&key, BTRFS_INLINE_DATA_KEY);
	ptr = kmap(result->b_page);
	safe_ptr = ptr;
	ptr += (pos & (PAGE_CACHE_SIZE -1));
again:
	key.offset = pos;
	ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
	if (ret) {
		if (ret < 0)
			err = ret;
		else
			err = 0;
		goto out;
	}
	leaf = btrfs_buffer_leaf(path->nodes[0]);
	item_size = btrfs_item_size(leaf->items + path->slots[0]);
	copy_size = min(num_bytes, item_size);
	data_ptr = btrfs_item_ptr(leaf, path->slots[0], char);
	WARN_ON(safe_ptr + PAGE_CACHE_SIZE < ptr + copy_size);
	memcpy(ptr, data_ptr, copy_size);
	pos += copy_size;
	num_bytes -= copy_size;
	WARN_ON(num_bytes < 0);
	ptr += copy_size;
	btrfs_release_path(root, path);
	if (num_bytes != 0) {
		if (pos >= i_size_read(inode))
			memset(ptr, 0, num_bytes);
		else
			goto again;
	}
	set_buffer_uptodate(result);
	map_bh(result, inode->i_sb, 0);
	err = 0;
out:
	btrfs_free_path(path);
	kunmap(result->b_page);
	return err;
}
997
#endif
C
Chris Mason 已提交
998

C
Chris Mason 已提交
999
static int btrfs_get_block_lock(struct inode *inode, sector_t iblock,
C
Chris Mason 已提交
1000 1001 1002 1003 1004 1005 1006 1007
			   struct buffer_head *result, int create)
{
	int ret;
	int err = 0;
	u64 blocknr;
	u64 extent_start = 0;
	u64 extent_end = 0;
	u64 objectid = inode->i_ino;
1008
	struct btrfs_path *path;
1009
	struct btrfs_root *root = BTRFS_I(inode)->root;
C
Chris Mason 已提交
1010 1011 1012 1013 1014
	struct btrfs_trans_handle *trans = NULL;
	struct btrfs_file_extent_item *item;
	struct btrfs_leaf *leaf;
	struct btrfs_disk_key *found_key;

1015 1016 1017
	path = btrfs_alloc_path();
	BUG_ON(!path);
	btrfs_init_path(path);
C
Chris Mason 已提交
1018 1019 1020
	if (create)
		trans = btrfs_start_transaction(root, 1);

1021
	ret = btrfs_lookup_file_extent(trans, root, path,
C
Chris Mason 已提交
1022
				       inode->i_ino,
1023
				       iblock << inode->i_blkbits, create);
C
Chris Mason 已提交
1024 1025 1026 1027 1028 1029
	if (ret < 0) {
		err = ret;
		goto out;
	}

	if (ret != 0) {
1030 1031
		if (path->slots[0] == 0) {
			btrfs_release_path(root, path);
C
Chris Mason 已提交
1032 1033
			goto allocate;
		}
1034
		path->slots[0]--;
C
Chris Mason 已提交
1035 1036
	}

1037
	item = btrfs_item_ptr(btrfs_buffer_leaf(path->nodes[0]), path->slots[0],
C
Chris Mason 已提交
1038
			      struct btrfs_file_extent_item);
1039
	leaf = btrfs_buffer_leaf(path->nodes[0]);
C
Chris Mason 已提交
1040 1041 1042
	blocknr = btrfs_file_extent_disk_blocknr(item);
	blocknr += btrfs_file_extent_offset(item);

1043 1044 1045
	/* exact match found, use it, FIXME, deal with extents
	 * other than the page size
	 */
C
Chris Mason 已提交
1046 1047
	if (ret == 0) {
		err = 0;
1048
		BUG_ON(btrfs_file_extent_disk_num_blocks(item) != 1);
1049 1050
		if (create &&
		    btrfs_file_extent_generation(item) != trans->transid) {
1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062
			struct btrfs_key ins;
			ret = btrfs_alloc_extent(trans, root, 1,
						 blocknr, (u64)-1, &ins);
			BUG_ON(ret);
			btrfs_set_file_extent_disk_blocknr(item, ins.objectid);
			mark_buffer_dirty(path->nodes[0]);
			ret = btrfs_free_extent(trans, root,
						blocknr, 1, 0);
			BUG_ON(ret);
			blocknr = ins.objectid;

		}
C
Chris Mason 已提交
1063 1064 1065 1066 1067
		map_bh(result, inode->i_sb, blocknr);
		goto out;
	}

	/* are we inside the extent that was found? */
1068
	found_key = &leaf->items[path->slots[0]].key;
C
Chris Mason 已提交
1069 1070 1071 1072
	if (btrfs_disk_key_objectid(found_key) != objectid ||
	    btrfs_disk_key_type(found_key) != BTRFS_EXTENT_DATA_KEY) {
		extent_end = 0;
		extent_start = 0;
1073
		btrfs_release_path(root, path);
C
Chris Mason 已提交
1074 1075 1076
		goto allocate;
	}

1077
	extent_start = btrfs_disk_key_offset(&leaf->items[path->slots[0]].key);
C
Chris Mason 已提交
1078
	extent_start = extent_start >> inode->i_blkbits;
C
Chris Mason 已提交
1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091
	extent_start += btrfs_file_extent_offset(item);
	extent_end = extent_start + btrfs_file_extent_num_blocks(item);
	if (iblock >= extent_start && iblock < extent_end) {
		err = 0;
		map_bh(result, inode->i_sb, blocknr + iblock - extent_start);
		goto out;
	}
allocate:
	/* ok, create a new extent */
	if (!create) {
		err = 0;
		goto out;
	}
C
Chris Mason 已提交
1092 1093
	ret = btrfs_alloc_file_extent(trans, root, objectid,
				      iblock << inode->i_blkbits,
C
Chris Mason 已提交
1094 1095 1096 1097 1098
				      1, extent_end, &blocknr);
	if (ret) {
		err = ret;
		goto out;
	}
C
Chris Mason 已提交
1099 1100
	inode->i_blocks += inode->i_sb->s_blocksize >> 9;
	set_buffer_new(result);
C
Chris Mason 已提交
1101 1102 1103
	map_bh(result, inode->i_sb, blocknr);

out:
1104 1105
	btrfs_release_path(root, path);
	btrfs_free_path(path);
C
Chris Mason 已提交
1106 1107
	if (trans)
		btrfs_end_transaction(trans, root);
C
Chris Mason 已提交
1108 1109 1110 1111 1112 1113 1114
	return err;
}

static int btrfs_get_block(struct inode *inode, sector_t iblock,
			   struct buffer_head *result, int create)
{
	int err;
1115
	struct btrfs_root *root = BTRFS_I(inode)->root;
C
Chris Mason 已提交
1116
	mutex_lock(&root->fs_info->fs_mutex);
1117 1118
	err = btrfs_get_block_lock(inode, iblock, result, create);
	// err = btrfs_get_block_inline(inode, iblock, result, create);
C
Chris Mason 已提交
1119 1120 1121 1122 1123 1124 1125
	mutex_unlock(&root->fs_info->fs_mutex);
	return err;
}

static int btrfs_prepare_write(struct file *file, struct page *page,
			       unsigned from, unsigned to)
{
1126
	return nobh_prepare_write(page, from, to, btrfs_get_block);
C
Chris Mason 已提交
1127
}
C
Chris Mason 已提交
1128 1129 1130 1131 1132
static int btrfs_commit_write(struct file *file, struct page *page,
			       unsigned from, unsigned to)
{
	return nobh_commit_write(file, page, from, to);
}
C
Chris Mason 已提交
1133

C
Chris Mason 已提交
1134 1135 1136 1137 1138
static void btrfs_write_super(struct super_block *sb)
{
	btrfs_sync_fs(sb, 1);
}

C
Chris Mason 已提交
1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151
static int btrfs_readpage(struct file *file, struct page *page)
{
	return mpage_readpage(page, btrfs_get_block);
}

static int btrfs_readpages(struct file *file, struct address_space *mapping,
			   struct list_head *pages, unsigned nr_pages)
{
	return mpage_readpages(mapping, pages, nr_pages, btrfs_get_block);
}

static int btrfs_writepage(struct page *page, struct writeback_control *wbc)
{
1152
	return nobh_writepage(page, btrfs_get_block, wbc);
C
Chris Mason 已提交
1153
}
C
Chris Mason 已提交
1154

C
Chris Mason 已提交
1155 1156
static void btrfs_truncate(struct inode *inode)
{
1157
	struct btrfs_root *root = BTRFS_I(inode)->root;
C
Chris Mason 已提交
1158 1159 1160 1161 1162 1163 1164 1165
	int ret;
	struct btrfs_trans_handle *trans;

	if (!S_ISREG(inode->i_mode))
		return;
	if (IS_APPEND(inode) || IS_IMMUTABLE(inode))
		return;

1166
	nobh_truncate_page(inode->i_mapping, inode->i_size);
C
Chris Mason 已提交
1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178

	/* FIXME, add redo link to tree so we don't leak on crash */
	mutex_lock(&root->fs_info->fs_mutex);
	trans = btrfs_start_transaction(root, 1);
	ret = btrfs_truncate_in_trans(trans, root, inode);
	BUG_ON(ret);
	ret = btrfs_end_transaction(trans, root);
	BUG_ON(ret);
	mutex_unlock(&root->fs_info->fs_mutex);
	mark_inode_dirty(inode);
}

C
Chris Mason 已提交
1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232
static int btrfs_copy_from_user(loff_t pos, int num_pages, int write_bytes,
				struct page **prepared_pages,
				const char __user * buf)
{
	long page_fault = 0;
	int i;
	int offset = pos & (PAGE_CACHE_SIZE - 1);

	for (i = 0; i < num_pages && write_bytes > 0; i++, offset = 0) {
		size_t count = min_t(size_t,
				     PAGE_CACHE_SIZE - offset, write_bytes);
		struct page *page = prepared_pages[i];
		fault_in_pages_readable(buf, count);

		/* Copy data from userspace to the current page */
		kmap(page);
		page_fault = __copy_from_user(page_address(page) + offset,
					      buf, count);
		/* Flush processor's dcache for this page */
		flush_dcache_page(page);
		kunmap(page);
		buf += count;
		write_bytes -= count;

		if (page_fault)
			break;
	}
	return page_fault ? -EFAULT : 0;
}

static void btrfs_drop_pages(struct page **pages, size_t num_pages)
{
	size_t i;
	for (i = 0; i < num_pages; i++) {
		if (!pages[i])
			break;
		unlock_page(pages[i]);
		mark_page_accessed(pages[i]);
		page_cache_release(pages[i]);
	}
}
static int dirty_and_release_pages(struct btrfs_trans_handle *trans,
				   struct btrfs_root *root,
				   struct file *file,
				   struct page **pages,
				   size_t num_pages,
				   loff_t pos,
				   size_t write_bytes)
{
	int i;
	int offset;
	int err = 0;
	int ret;
	int this_write;
C
Chris Mason 已提交
1233
	struct inode *inode = file->f_path.dentry->d_inode;
C
Chris Mason 已提交
1234 1235 1236 1237

	for (i = 0; i < num_pages; i++) {
		offset = pos & (PAGE_CACHE_SIZE -1);
		this_write = min(PAGE_CACHE_SIZE - offset, write_bytes);
C
Chris Mason 已提交
1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250
		/* FIXME, one block at a time */

		mutex_lock(&root->fs_info->fs_mutex);
		trans = btrfs_start_transaction(root, 1);
		btrfs_csum_file_block(trans, root, inode->i_ino,
				      pages[i]->index << PAGE_CACHE_SHIFT,
				      kmap(pages[i]), PAGE_CACHE_SIZE);
		kunmap(pages[i]);
		SetPageChecked(pages[i]);
		ret = btrfs_end_transaction(trans, root);
		BUG_ON(ret);
		mutex_unlock(&root->fs_info->fs_mutex);

C
Chris Mason 已提交
1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293
		ret = nobh_commit_write(file, pages[i], offset,
					 offset + this_write);
		pos += this_write;
		if (ret) {
			err = ret;
			goto failed;
		}
		WARN_ON(this_write > write_bytes);
		write_bytes -= this_write;
	}
failed:
	return err;
}

static int prepare_pages(struct btrfs_trans_handle *trans,
			 struct btrfs_root *root,
			 struct file *file,
			 struct page **pages,
			 size_t num_pages,
			 loff_t pos,
			 size_t write_bytes)
{
	int i;
	unsigned long index = pos >> PAGE_CACHE_SHIFT;
	struct inode *inode = file->f_path.dentry->d_inode;
	int offset;
	int err = 0;
	int ret;
	int this_write;
	loff_t isize = i_size_read(inode);

	memset(pages, 0, num_pages * sizeof(struct page *));

	for (i = 0; i < num_pages; i++) {
		pages[i] = grab_cache_page(inode->i_mapping, index + i);
		if (!pages[i]) {
			err = -ENOMEM;
			goto failed_release;
		}
		offset = pos & (PAGE_CACHE_SIZE -1);
		this_write = min(PAGE_CACHE_SIZE - offset, write_bytes);
		ret = nobh_prepare_write(pages[i], offset,
					 offset + this_write,
C
Chris Mason 已提交
1294
					 btrfs_get_block);
C
Chris Mason 已提交
1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323
		pos += this_write;
		if (ret) {
			err = ret;
			goto failed_truncate;
		}
		WARN_ON(this_write > write_bytes);
		write_bytes -= this_write;
	}
	return 0;

failed_release:
	btrfs_drop_pages(pages, num_pages);
	return err;

failed_truncate:
	btrfs_drop_pages(pages, num_pages);
	if (pos > isize)
		vmtruncate(inode, isize);
	return err;
}

static ssize_t btrfs_file_write(struct file *file, const char __user *buf,
				size_t count, loff_t *ppos)
{
	loff_t pos;
	size_t num_written = 0;
	int err = 0;
	int ret = 0;
	struct inode *inode = file->f_path.dentry->d_inode;
1324
	struct btrfs_root *root = BTRFS_I(inode)->root;
C
Chris Mason 已提交
1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347
	struct page *pages[1];

	if (file->f_flags & O_DIRECT)
		return -EINVAL;
	pos = *ppos;

	vfs_check_frozen(inode->i_sb, SB_FREEZE_WRITE);
	current->backing_dev_info = inode->i_mapping->backing_dev_info;
	err = generic_write_checks(file, &pos, &count, S_ISBLK(inode->i_mode));
	if (err)
		goto out;
	if (count == 0)
		goto out;
	err = remove_suid(file->f_path.dentry);
	if (err)
		goto out;
	file_update_time(file);
	mutex_lock(&inode->i_mutex);
	while(count > 0) {
		size_t offset = pos & (PAGE_CACHE_SIZE - 1);
		size_t write_bytes = min(count, PAGE_CACHE_SIZE - offset);
		size_t num_pages = (write_bytes + PAGE_CACHE_SIZE - 1) >>
					PAGE_CACHE_SHIFT;
C
Chris Mason 已提交
1348
		ret = prepare_pages(NULL, root, file, pages, num_pages,
C
Chris Mason 已提交
1349 1350 1351 1352 1353 1354
				    pos, write_bytes);
		BUG_ON(ret);
		ret = btrfs_copy_from_user(pos, num_pages,
					   write_bytes, pages, buf);
		BUG_ON(ret);

C
Chris Mason 已提交
1355
		ret = dirty_and_release_pages(NULL, root, file, pages,
C
Chris Mason 已提交
1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374
					      num_pages, pos, write_bytes);
		BUG_ON(ret);
		btrfs_drop_pages(pages, num_pages);

		buf += write_bytes;
		count -= write_bytes;
		pos += write_bytes;
		num_written += write_bytes;

		balance_dirty_pages_ratelimited(inode->i_mapping);
		cond_resched();
	}
	mutex_unlock(&inode->i_mutex);
out:
	*ppos = pos;
	current->backing_dev_info = NULL;
	return num_written ? num_written : err;
}

1375
#if 0
C
Chris Mason 已提交
1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439
static ssize_t inline_one_page(struct btrfs_root *root, struct inode *inode,
			   struct page *page, loff_t pos,
			   size_t offset, size_t write_bytes)
{
	struct btrfs_path *path;
	struct btrfs_trans_handle *trans;
	struct btrfs_key key;
	struct btrfs_leaf *leaf;
	struct btrfs_key found_key;
	int ret;
	size_t copy_size = 0;
	char *dst = NULL;
	int err = 0;
	size_t num_written = 0;

	path = btrfs_alloc_path();
	BUG_ON(!path);
	mutex_lock(&root->fs_info->fs_mutex);
	trans = btrfs_start_transaction(root, 1);
	key.objectid = inode->i_ino;
	key.flags = 0;
	btrfs_set_key_type(&key, BTRFS_INLINE_DATA_KEY);

again:
	key.offset = pos;
	ret = btrfs_search_slot(trans, root, &key, path, 0, 1);
	if (ret < 0) {
		err = ret;
		goto out;
	}
	if (ret == 0) {
		leaf = btrfs_buffer_leaf(path->nodes[0]);
		btrfs_disk_key_to_cpu(&found_key,
				      &leaf->items[path->slots[0]].key);
		copy_size = btrfs_item_size(leaf->items + path->slots[0]);
		dst = btrfs_item_ptr(leaf, path->slots[0], char);
		copy_size = min(write_bytes, copy_size);
		goto copyit;
	} else {
		int slot = path->slots[0];
		if (slot > 0) {
			slot--;
		}
		// FIXME find max key
		leaf = btrfs_buffer_leaf(path->nodes[0]);
		btrfs_disk_key_to_cpu(&found_key,
				      &leaf->items[slot].key);
		if (found_key.objectid != inode->i_ino)
			goto insert;
		if (btrfs_key_type(&found_key) != BTRFS_INLINE_DATA_KEY)
			goto insert;
		copy_size = btrfs_item_size(leaf->items + slot);
		if (found_key.offset + copy_size <= pos)
			goto insert;
		dst = btrfs_item_ptr(leaf, path->slots[0], char);
		dst += pos - found_key.offset;
		copy_size = copy_size - (pos - found_key.offset);
		BUG_ON(copy_size < 0);
		copy_size = min(write_bytes, copy_size);
		WARN_ON(copy_size == 0);
		goto copyit;
	}
insert:
	btrfs_release_path(root, path);
1440 1441 1442
	copy_size = min(write_bytes,
			(size_t)BTRFS_LEAF_DATA_SIZE(root) -
			sizeof(struct btrfs_item) * 4);
C
Chris Mason 已提交
1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480
	ret = btrfs_insert_empty_item(trans, root, path, &key, copy_size);
	BUG_ON(ret);
	dst = btrfs_item_ptr(btrfs_buffer_leaf(path->nodes[0]),
			     path->slots[0], char);
copyit:
	WARN_ON(copy_size == 0);
	WARN_ON(dst + copy_size >
		btrfs_item_ptr(btrfs_buffer_leaf(path->nodes[0]),
						 path->slots[0], char) +
		btrfs_item_size(btrfs_buffer_leaf(path->nodes[0])->items +
						  path->slots[0]));
	btrfs_memcpy(root, path->nodes[0]->b_data, dst,
		     page_address(page) + offset, copy_size);
	mark_buffer_dirty(path->nodes[0]);
	btrfs_release_path(root, path);
	pos += copy_size;
	offset += copy_size;
	num_written += copy_size;
	write_bytes -= copy_size;
	if (write_bytes)
		goto again;
out:
	btrfs_free_path(path);
	ret = btrfs_end_transaction(trans, root);
	BUG_ON(ret);
	mutex_unlock(&root->fs_info->fs_mutex);
	return num_written ? num_written : err;
}

static ssize_t btrfs_file_inline_write(struct file *file,
				       const char __user *buf,
				       size_t count, loff_t *ppos)
{
	loff_t pos;
	size_t num_written = 0;
	int err = 0;
	int ret = 0;
	struct inode *inode = file->f_path.dentry->d_inode;
1481
	struct btrfs_root *root = BTRFS_I(inode)->root;
C
Chris Mason 已提交
1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540
	unsigned long page_index;

	if (file->f_flags & O_DIRECT)
		return -EINVAL;
	pos = *ppos;

	vfs_check_frozen(inode->i_sb, SB_FREEZE_WRITE);
	current->backing_dev_info = inode->i_mapping->backing_dev_info;
	err = generic_write_checks(file, &pos, &count, S_ISBLK(inode->i_mode));
	if (err)
		goto out;
	if (count == 0)
		goto out;
	err = remove_suid(file->f_path.dentry);
	if (err)
		goto out;
	file_update_time(file);
	mutex_lock(&inode->i_mutex);
	while(count > 0) {
		size_t offset = pos & (PAGE_CACHE_SIZE - 1);
		size_t write_bytes = min(count, PAGE_CACHE_SIZE - offset);
		struct page *page;

		page_index = pos >> PAGE_CACHE_SHIFT;
		page = grab_cache_page(inode->i_mapping, page_index);
		if (!PageUptodate(page)) {
			ret = mpage_readpage(page, btrfs_get_block);
			BUG_ON(ret);
			lock_page(page);
		}
		ret = btrfs_copy_from_user(pos, 1,
					   write_bytes, &page, buf);
		BUG_ON(ret);
		write_bytes = inline_one_page(root, inode, page, pos,
				      offset, write_bytes);
		SetPageUptodate(page);
		if (write_bytes > 0 && pos + write_bytes > inode->i_size) {
			i_size_write(inode, pos + write_bytes);
			mark_inode_dirty(inode);
		}
		page_cache_release(page);
		unlock_page(page);
		if (write_bytes < 0)
			goto out_unlock;
		buf += write_bytes;
		count -= write_bytes;
		pos += write_bytes;
		num_written += write_bytes;

		balance_dirty_pages_ratelimited(inode->i_mapping);
		cond_resched();
	}
out_unlock:
	mutex_unlock(&inode->i_mutex);
out:
	*ppos = pos;
	current->backing_dev_info = NULL;
	return num_written ? num_written : err;
}
1541
#endif
C
Chris Mason 已提交
1542

C
Chris Mason 已提交
1543 1544 1545 1546 1547
static int btrfs_read_actor(read_descriptor_t *desc, struct page *page,
			unsigned long offset, unsigned long size)
{
	char *kaddr;
	unsigned long left, count = desc->count;
1548
	struct inode *inode = page->mapping->host;
C
Chris Mason 已提交
1549 1550 1551 1552 1553 1554

	if (size > count)
		size = count;

	if (!PageChecked(page)) {
		/* FIXME, do it per block */
1555
		struct btrfs_root *root = BTRFS_I(inode)->root;
C
Chris Mason 已提交
1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654 1655
		int ret = btrfs_csum_verify_file_block(root,
					  page->mapping->host->i_ino,
					  page->index << PAGE_CACHE_SHIFT,
					  kmap(page), PAGE_CACHE_SIZE);
		if (ret) {
			printk("failed to verify ino %lu page %lu\n",
			       page->mapping->host->i_ino,
			       page->index);
			memset(page_address(page), 0, PAGE_CACHE_SIZE);
		}
		SetPageChecked(page);
		kunmap(page);
	}
	/*
	 * Faults on the destination of a read are common, so do it before
	 * taking the kmap.
	 */
	if (!fault_in_pages_writeable(desc->arg.buf, size)) {
		kaddr = kmap_atomic(page, KM_USER0);
		left = __copy_to_user_inatomic(desc->arg.buf,
						kaddr + offset, size);
		kunmap_atomic(kaddr, KM_USER0);
		if (left == 0)
			goto success;
	}

	/* Do it the slow way */
	kaddr = kmap(page);
	left = __copy_to_user(desc->arg.buf, kaddr + offset, size);
	kunmap(page);

	if (left) {
		size -= left;
		desc->error = -EFAULT;
	}
success:
	desc->count = count - size;
	desc->written += size;
	desc->arg.buf += size;
	return size;
}

/**
 * btrfs_file_aio_read - filesystem read routine
 * @iocb:	kernel I/O control block
 * @iov:	io vector request
 * @nr_segs:	number of segments in the iovec
 * @pos:	current file position
 */
static ssize_t btrfs_file_aio_read(struct kiocb *iocb, const struct iovec *iov,
				   unsigned long nr_segs, loff_t pos)
{
	struct file *filp = iocb->ki_filp;
	ssize_t retval;
	unsigned long seg;
	size_t count;
	loff_t *ppos = &iocb->ki_pos;

	count = 0;
	for (seg = 0; seg < nr_segs; seg++) {
		const struct iovec *iv = &iov[seg];

		/*
		 * If any segment has a negative length, or the cumulative
		 * length ever wraps negative then return -EINVAL.
		 */
		count += iv->iov_len;
		if (unlikely((ssize_t)(count|iv->iov_len) < 0))
			return -EINVAL;
		if (access_ok(VERIFY_WRITE, iv->iov_base, iv->iov_len))
			continue;
		if (seg == 0)
			return -EFAULT;
		nr_segs = seg;
		count -= iv->iov_len;	/* This segment is no good */
		break;
	}
	retval = 0;
	if (count) {
		for (seg = 0; seg < nr_segs; seg++) {
			read_descriptor_t desc;

			desc.written = 0;
			desc.arg.buf = iov[seg].iov_base;
			desc.count = iov[seg].iov_len;
			if (desc.count == 0)
				continue;
			desc.error = 0;
			do_generic_file_read(filp, ppos, &desc,
					     btrfs_read_actor);
			retval += desc.written;
			if (desc.error) {
				retval = retval ?: desc.error;
				break;
			}
		}
	}
	return retval;
}

C
Chris Mason 已提交
1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666 1667 1668 1669 1670
static int create_snapshot(struct btrfs_root *root, char *name, int namelen)
{
	struct btrfs_trans_handle *trans;
	struct btrfs_key key;
	struct btrfs_root_item new_root_item;
	int ret;
	u64 objectid;

	mutex_lock(&root->fs_info->fs_mutex);
	trans = btrfs_start_transaction(root, 1);
	BUG_ON(!trans);

	ret = btrfs_update_inode(trans, root, root->inode);
	BUG_ON(ret);

C
Chris Mason 已提交
1671 1672
	ret = btrfs_find_free_objectid(trans, root->fs_info->tree_root,
				       0, &objectid);
C
Chris Mason 已提交
1673 1674 1675 1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 1735 1736 1737 1738
	BUG_ON(ret);

	memset(&new_root_item, 0, sizeof(new_root_item));
	memcpy(&new_root_item, &root->root_item,
	       sizeof(new_root_item));

	key.objectid = objectid;
	key.offset = 1;
	key.flags = 0;
	btrfs_set_key_type(&key, BTRFS_ROOT_ITEM_KEY);
	btrfs_set_root_blocknr(&new_root_item, root->node->b_blocknr);

	ret = btrfs_insert_root(trans, root->fs_info->tree_root, &key,
				&new_root_item);
	BUG_ON(ret);

printk("adding snapshot name %.*s root %Lu %Lu %u\n", namelen, name, key.objectid, key.offset, key.flags);

	/*
	 * insert the directory item
	 */
	key.offset = (u64)-1;
	ret = btrfs_insert_dir_item(trans, root->fs_info->tree_root,
				    name, namelen,
				    root->fs_info->sb->s_root->d_inode->i_ino,
				    &key, 0);

	BUG_ON(ret);

	ret = btrfs_inc_root_ref(trans, root);
	BUG_ON(ret);

	ret = btrfs_commit_transaction(trans, root);
	BUG_ON(ret);
	mutex_unlock(&root->fs_info->fs_mutex);
	return 0;
}

static int btrfs_ioctl(struct inode *inode, struct file *filp, unsigned int
		       cmd, unsigned long arg)
{
	struct btrfs_root *root = BTRFS_I(inode)->root;
	struct btrfs_ioctl_vol_args vol_args;
	int ret;
	int namelen;

	if (!root->ref_cows)
		return -EINVAL;
	switch (cmd) {
	case BTRFS_IOC_SNAP_CREATE:
		if (copy_from_user(&vol_args,
				   (struct btrfs_ioctl_vol_args __user *)arg,
				   sizeof(vol_args)))
			return -EFAULT;
		namelen = strlen(vol_args.name);
		if (namelen > BTRFS_VOL_NAME_MAX)
			return -EINVAL;
		ret = create_snapshot(root, vol_args.name, namelen);
		WARN_ON(ret);
		break;
	default:
		return -ENOTTY;
	}
	return 0;
}

C
Chris Mason 已提交
1739 1740 1741 1742 1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795 1796 1797 1798 1799 1800 1801 1802 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814 1815 1816 1817 1818 1819
static struct kmem_cache *btrfs_inode_cachep;
struct kmem_cache *btrfs_trans_handle_cachep;
struct kmem_cache *btrfs_transaction_cachep;
struct kmem_cache *btrfs_bit_radix_cachep;
struct kmem_cache *btrfs_path_cachep;

/*
 * Called inside transaction, so use GFP_NOFS
 */
static struct inode *btrfs_alloc_inode(struct super_block *sb)
{
	struct btrfs_inode *ei;

	ei = kmem_cache_alloc(btrfs_inode_cachep, GFP_NOFS);
	if (!ei)
		return NULL;
	return &ei->vfs_inode;
}

static void btrfs_destroy_inode(struct inode *inode)
{
	WARN_ON(!list_empty(&inode->i_dentry));
	WARN_ON(inode->i_data.nrpages);

	kmem_cache_free(btrfs_inode_cachep, BTRFS_I(inode));
}

static void init_once(void * foo, struct kmem_cache * cachep,
		      unsigned long flags)
{
	struct btrfs_inode *ei = (struct btrfs_inode *) foo;

	if ((flags & (SLAB_CTOR_VERIFY|SLAB_CTOR_CONSTRUCTOR)) ==
	    SLAB_CTOR_CONSTRUCTOR) {
		inode_init_once(&ei->vfs_inode);
	}
}

static int init_inodecache(void)
{
	btrfs_inode_cachep = kmem_cache_create("btrfs_inode_cache",
					     sizeof(struct btrfs_inode),
					     0, (SLAB_RECLAIM_ACCOUNT|
						SLAB_MEM_SPREAD),
					     init_once, NULL);
	btrfs_trans_handle_cachep = kmem_cache_create("btrfs_trans_handle_cache",
					     sizeof(struct btrfs_trans_handle),
					     0, (SLAB_RECLAIM_ACCOUNT|
						SLAB_MEM_SPREAD),
					     NULL, NULL);
	btrfs_transaction_cachep = kmem_cache_create("btrfs_transaction_cache",
					     sizeof(struct btrfs_transaction),
					     0, (SLAB_RECLAIM_ACCOUNT|
						SLAB_MEM_SPREAD),
					     NULL, NULL);
	btrfs_path_cachep = kmem_cache_create("btrfs_path_cache",
					     sizeof(struct btrfs_transaction),
					     0, (SLAB_RECLAIM_ACCOUNT|
						SLAB_MEM_SPREAD),
					     NULL, NULL);
	btrfs_bit_radix_cachep = kmem_cache_create("btrfs_radix",
					     256,
					     0, (SLAB_RECLAIM_ACCOUNT|
						SLAB_MEM_SPREAD |
						SLAB_DESTROY_BY_RCU),
					     NULL, NULL);
	if (btrfs_inode_cachep == NULL || btrfs_trans_handle_cachep == NULL ||
	    btrfs_transaction_cachep == NULL || btrfs_bit_radix_cachep == NULL)
		return -ENOMEM;
	return 0;
}

static void destroy_inodecache(void)
{
	kmem_cache_destroy(btrfs_inode_cachep);
	kmem_cache_destroy(btrfs_trans_handle_cachep);
	kmem_cache_destroy(btrfs_transaction_cachep);
	kmem_cache_destroy(btrfs_bit_radix_cachep);
	kmem_cache_destroy(btrfs_path_cachep);
}

1820 1821 1822 1823 1824 1825 1826 1827 1828 1829 1830 1831 1832 1833 1834
static int btrfs_get_sb(struct file_system_type *fs_type,
	int flags, const char *dev_name, void *data, struct vfsmount *mnt)
{
	return get_sb_bdev(fs_type, flags, dev_name, data,
			   btrfs_fill_super, mnt);
}

static struct file_system_type btrfs_fs_type = {
	.owner		= THIS_MODULE,
	.name		= "btrfs",
	.get_sb		= btrfs_get_sb,
	.kill_sb	= kill_block_super,
	.fs_flags	= FS_REQUIRES_DEV,
};

C
Chris Mason 已提交
1835 1836
static struct super_operations btrfs_super_ops = {
	.statfs		= simple_statfs,
C
Chris Mason 已提交
1837
	.delete_inode	= btrfs_delete_inode,
C
Chris Mason 已提交
1838 1839
	.put_super	= btrfs_put_super,
	.read_inode	= btrfs_read_locked_inode,
1840 1841
	.write_super	= btrfs_write_super,
	.sync_fs	= btrfs_sync_fs,
C
Chris Mason 已提交
1842
	.write_inode	= btrfs_write_inode,
C
Chris Mason 已提交
1843 1844
	.alloc_inode	= btrfs_alloc_inode,
	.destroy_inode	= btrfs_destroy_inode,
C
Chris Mason 已提交
1845 1846 1847 1848
};

static struct inode_operations btrfs_dir_inode_operations = {
	.lookup		= btrfs_lookup,
1849
	.create		= btrfs_create,
C
Chris Mason 已提交
1850
	.unlink		= btrfs_unlink,
C
Chris Mason 已提交
1851
	.mkdir		= btrfs_mkdir,
C
Chris Mason 已提交
1852
	.rmdir		= btrfs_rmdir,
C
Chris Mason 已提交
1853 1854
};

1855 1856 1857 1858
static struct inode_operations btrfs_dir_ro_inode_operations = {
	.lookup		= btrfs_lookup,
};

C
Chris Mason 已提交
1859 1860 1861 1862
static struct file_operations btrfs_dir_file_operations = {
	.llseek		= generic_file_llseek,
	.read		= generic_read_dir,
	.readdir	= btrfs_readdir,
C
Chris Mason 已提交
1863
	.ioctl		= btrfs_ioctl,
C
Chris Mason 已提交
1864 1865
};

C
Chris Mason 已提交
1866 1867
static struct address_space_operations btrfs_aops = {
	.readpage	= btrfs_readpage,
1868
	.readpages	= btrfs_readpages,
C
Chris Mason 已提交
1869 1870 1871
	.writepage	= btrfs_writepage,
	.sync_page	= block_sync_page,
	.prepare_write	= btrfs_prepare_write,
C
Chris Mason 已提交
1872
	.commit_write	= btrfs_commit_write,
C
Chris Mason 已提交
1873 1874 1875
};

static struct inode_operations btrfs_file_inode_operations = {
C
Chris Mason 已提交
1876
	.truncate	= btrfs_truncate,
C
Chris Mason 已提交
1877 1878 1879 1880 1881
};

static struct file_operations btrfs_file_operations = {
	.llseek		= generic_file_llseek,
	.read		= do_sync_read,
1882 1883
	.aio_read       = btrfs_file_aio_read,
	.write		= btrfs_file_write,
C
Chris Mason 已提交
1884 1885
	.mmap		= generic_file_mmap,
	.open		= generic_file_open,
C
Chris Mason 已提交
1886
	.ioctl		= btrfs_ioctl,
C
Chris Mason 已提交
1887
};
C
Chris Mason 已提交
1888

1889 1890
static int __init init_btrfs_fs(void)
{
C
Chris Mason 已提交
1891
	int err;
1892
	printk("btrfs loaded!\n");
C
Chris Mason 已提交
1893 1894 1895
	err = init_inodecache();
	if (err)
		return err;
1896 1897 1898 1899
	kset_set_kset_s(&btrfs_subsys, fs_subsys);
	err = subsystem_register(&btrfs_subsys);
	if (err)
		goto out;
1900
	return register_filesystem(&btrfs_fs_type);
1901 1902 1903
out:
	destroy_inodecache();
	return err;
1904 1905 1906 1907
}

static void __exit exit_btrfs_fs(void)
{
C
Chris Mason 已提交
1908
	destroy_inodecache();
1909
	unregister_filesystem(&btrfs_fs_type);
1910
	subsystem_unregister(&btrfs_subsys);
1911 1912 1913 1914 1915 1916 1917
	printk("btrfs unloaded\n");
}

module_init(init_btrfs_fs)
module_exit(exit_btrfs_fs)

MODULE_LICENSE("GPL");