delayed-inode.c (0b246afa62b0cf5b09d078121f543135f28492ad) delayed-inode.c (ccdf9b305a49875d49dbaec6f8d2440abb0b1994)
1/*
2 * Copyright (C) 2011 Fujitsu. All rights reserved.
3 * Written by Miao Xie <miaox@cn.fujitsu.com>
4 *
5 * This program is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU General Public
7 * License v2 as published by the Free Software Foundation.
8 *

--- 58 unchanged lines hidden (view full) ---

67 if (item1->key.type == BTRFS_DIR_INDEX_KEY &&
68 item1->key.objectid == item2->key.objectid &&
69 item1->key.type == item2->key.type &&
70 item1->key.offset + 1 == item2->key.offset)
71 return 1;
72 return 0;
73}
74
1/*
2 * Copyright (C) 2011 Fujitsu. All rights reserved.
3 * Written by Miao Xie <miaox@cn.fujitsu.com>
4 *
5 * This program is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU General Public
7 * License v2 as published by the Free Software Foundation.
8 *

--- 58 unchanged lines hidden (view full) ---

67 if (item1->key.type == BTRFS_DIR_INDEX_KEY &&
68 item1->key.objectid == item2->key.objectid &&
69 item1->key.type == item2->key.type &&
70 item1->key.offset + 1 == item2->key.offset)
71 return 1;
72 return 0;
73}
74
75static inline struct btrfs_delayed_root *btrfs_get_delayed_root(
76 struct btrfs_root *root)
77{
78 return root->fs_info->delayed_root;
79}
80
81static struct btrfs_delayed_node *btrfs_get_delayed_node(struct inode *inode)
82{
83 struct btrfs_inode *btrfs_inode = BTRFS_I(inode);
84 struct btrfs_root *root = btrfs_inode->root;
85 u64 ino = btrfs_ino(inode);
86 struct btrfs_delayed_node *node;
87
88 node = ACCESS_ONCE(btrfs_inode->delayed_node);

--- 1069 unchanged lines hidden (view full) ---

1158 path = btrfs_alloc_path();
1159 if (!path)
1160 return -ENOMEM;
1161 path->leave_spinning = 1;
1162
1163 block_rsv = trans->block_rsv;
1164 trans->block_rsv = &fs_info->delayed_block_rsv;
1165
75static struct btrfs_delayed_node *btrfs_get_delayed_node(struct inode *inode)
76{
77 struct btrfs_inode *btrfs_inode = BTRFS_I(inode);
78 struct btrfs_root *root = btrfs_inode->root;
79 u64 ino = btrfs_ino(inode);
80 struct btrfs_delayed_node *node;
81
82 node = ACCESS_ONCE(btrfs_inode->delayed_node);

--- 1069 unchanged lines hidden (view full) ---

1152 path = btrfs_alloc_path();
1153 if (!path)
1154 return -ENOMEM;
1155 path->leave_spinning = 1;
1156
1157 block_rsv = trans->block_rsv;
1158 trans->block_rsv = &fs_info->delayed_block_rsv;
1159
1166 delayed_root = btrfs_get_delayed_root(root);
1160 delayed_root = fs_info->delayed_root;
1167
1168 curr_node = btrfs_first_delayed_node(delayed_root);
1169 while (curr_node && (!count || (count && nr--))) {
1170 ret = __btrfs_commit_inode_delayed_items(trans, path,
1171 curr_node);
1172 if (ret) {
1173 btrfs_release_delayed_node(curr_node);
1174 curr_node = NULL;

--- 210 unchanged lines hidden (view full) ---

1385 btrfs_init_work(&async_work->work, btrfs_delayed_meta_helper,
1386 btrfs_async_run_delayed_root, NULL, NULL);
1387 async_work->nr = nr;
1388
1389 btrfs_queue_work(fs_info->delayed_workers, &async_work->work);
1390 return 0;
1391}
1392
1161
1162 curr_node = btrfs_first_delayed_node(delayed_root);
1163 while (curr_node && (!count || (count && nr--))) {
1164 ret = __btrfs_commit_inode_delayed_items(trans, path,
1165 curr_node);
1166 if (ret) {
1167 btrfs_release_delayed_node(curr_node);
1168 curr_node = NULL;

--- 210 unchanged lines hidden (view full) ---

1379 btrfs_init_work(&async_work->work, btrfs_delayed_meta_helper,
1380 btrfs_async_run_delayed_root, NULL, NULL);
1381 async_work->nr = nr;
1382
1383 btrfs_queue_work(fs_info->delayed_workers, &async_work->work);
1384 return 0;
1385}
1386
1393void btrfs_assert_delayed_root_empty(struct btrfs_root *root)
1387void btrfs_assert_delayed_root_empty(struct btrfs_fs_info *fs_info)
1394{
1388{
1395 struct btrfs_delayed_root *delayed_root;
1396 delayed_root = btrfs_get_delayed_root(root);
1397 WARN_ON(btrfs_first_delayed_node(delayed_root));
1389 WARN_ON(btrfs_first_delayed_node(fs_info->delayed_root));
1398}
1399
1400static int could_end_wait(struct btrfs_delayed_root *delayed_root, int seq)
1401{
1402 int val = atomic_read(&delayed_root->items_seq);
1403
1404 if (val < seq || val >= seq + BTRFS_DELAYED_BATCH)
1405 return 1;

--- 4 unchanged lines hidden (view full) ---

1410 return 0;
1411}
1412
1413void btrfs_balance_delayed_items(struct btrfs_root *root)
1414{
1415 struct btrfs_delayed_root *delayed_root;
1416 struct btrfs_fs_info *fs_info = root->fs_info;
1417
1390}
1391
1392static int could_end_wait(struct btrfs_delayed_root *delayed_root, int seq)
1393{
1394 int val = atomic_read(&delayed_root->items_seq);
1395
1396 if (val < seq || val >= seq + BTRFS_DELAYED_BATCH)
1397 return 1;

--- 4 unchanged lines hidden (view full) ---

1402 return 0;
1403}
1404
1405void btrfs_balance_delayed_items(struct btrfs_root *root)
1406{
1407 struct btrfs_delayed_root *delayed_root;
1408 struct btrfs_fs_info *fs_info = root->fs_info;
1409
1418 delayed_root = btrfs_get_delayed_root(root);
1410 delayed_root = fs_info->delayed_root;
1419
1420 if (atomic_read(&delayed_root->items) < BTRFS_DELAYED_BACKGROUND)
1421 return;
1422
1423 if (atomic_read(&delayed_root->items) >= BTRFS_DELAYED_WRITEBACK) {
1424 int seq;
1425 int ret;
1426

--- 548 unchanged lines hidden (view full) ---

1975
1976 for (i = 0; i < n; i++) {
1977 __btrfs_kill_delayed_node(delayed_nodes[i]);
1978 btrfs_release_delayed_node(delayed_nodes[i]);
1979 }
1980 }
1981}
1982
1411
1412 if (atomic_read(&delayed_root->items) < BTRFS_DELAYED_BACKGROUND)
1413 return;
1414
1415 if (atomic_read(&delayed_root->items) >= BTRFS_DELAYED_WRITEBACK) {
1416 int seq;
1417 int ret;
1418

--- 548 unchanged lines hidden (view full) ---

1967
1968 for (i = 0; i < n; i++) {
1969 __btrfs_kill_delayed_node(delayed_nodes[i]);
1970 btrfs_release_delayed_node(delayed_nodes[i]);
1971 }
1972 }
1973}
1974
1983void btrfs_destroy_delayed_inodes(struct btrfs_root *root)
1975void btrfs_destroy_delayed_inodes(struct btrfs_fs_info *fs_info)
1984{
1976{
1985 struct btrfs_delayed_root *delayed_root;
1986 struct btrfs_delayed_node *curr_node, *prev_node;
1987
1977 struct btrfs_delayed_node *curr_node, *prev_node;
1978
1988 delayed_root = btrfs_get_delayed_root(root);
1989
1990 curr_node = btrfs_first_delayed_node(delayed_root);
1979 curr_node = btrfs_first_delayed_node(fs_info->delayed_root);
1991 while (curr_node) {
1992 __btrfs_kill_delayed_node(curr_node);
1993
1994 prev_node = curr_node;
1995 curr_node = btrfs_next_delayed_node(curr_node);
1996 btrfs_release_delayed_node(prev_node);
1997 }
1998}
1999
1980 while (curr_node) {
1981 __btrfs_kill_delayed_node(curr_node);
1982
1983 prev_node = curr_node;
1984 curr_node = btrfs_next_delayed_node(curr_node);
1985 btrfs_release_delayed_node(prev_node);
1986 }
1987}
1988