1 // SPDX-License-Identifier: GPL-2.0-only 1 // SPDX-License-Identifier: GPL-2.0-only
2 /* 2 /*
3 * refcounttree.c 3 * refcounttree.c
4 * 4 *
5 * Copyright (C) 2009 Oracle. All rights rese 5 * Copyright (C) 2009 Oracle. All rights reserved.
6 */ 6 */
7 7
8 #include <linux/sort.h> 8 #include <linux/sort.h>
9 #include <cluster/masklog.h> 9 #include <cluster/masklog.h>
10 #include "ocfs2.h" 10 #include "ocfs2.h"
11 #include "inode.h" 11 #include "inode.h"
12 #include "alloc.h" 12 #include "alloc.h"
13 #include "suballoc.h" 13 #include "suballoc.h"
14 #include "journal.h" 14 #include "journal.h"
15 #include "uptodate.h" 15 #include "uptodate.h"
16 #include "super.h" 16 #include "super.h"
17 #include "buffer_head_io.h" 17 #include "buffer_head_io.h"
18 #include "blockcheck.h" 18 #include "blockcheck.h"
19 #include "refcounttree.h" 19 #include "refcounttree.h"
20 #include "sysfile.h" 20 #include "sysfile.h"
21 #include "dlmglue.h" 21 #include "dlmglue.h"
22 #include "extent_map.h" 22 #include "extent_map.h"
23 #include "aops.h" 23 #include "aops.h"
24 #include "xattr.h" 24 #include "xattr.h"
25 #include "namei.h" 25 #include "namei.h"
26 #include "ocfs2_trace.h" 26 #include "ocfs2_trace.h"
27 #include "file.h" 27 #include "file.h"
28 #include "symlink.h" <<
29 28
30 #include <linux/bio.h> 29 #include <linux/bio.h>
31 #include <linux/blkdev.h> 30 #include <linux/blkdev.h>
32 #include <linux/slab.h> 31 #include <linux/slab.h>
33 #include <linux/writeback.h> 32 #include <linux/writeback.h>
34 #include <linux/pagevec.h> 33 #include <linux/pagevec.h>
35 #include <linux/swap.h> 34 #include <linux/swap.h>
36 #include <linux/security.h> 35 #include <linux/security.h>
37 #include <linux/fsnotify.h> 36 #include <linux/fsnotify.h>
38 #include <linux/quotaops.h> 37 #include <linux/quotaops.h>
39 #include <linux/namei.h> 38 #include <linux/namei.h>
40 #include <linux/mount.h> 39 #include <linux/mount.h>
41 #include <linux/posix_acl.h> 40 #include <linux/posix_acl.h>
42 41
43 struct ocfs2_cow_context { 42 struct ocfs2_cow_context {
44 struct inode *inode; 43 struct inode *inode;
45 u32 cow_start; 44 u32 cow_start;
46 u32 cow_len; 45 u32 cow_len;
47 struct ocfs2_extent_tree data_et; 46 struct ocfs2_extent_tree data_et;
48 struct ocfs2_refcount_tree *ref_tree; 47 struct ocfs2_refcount_tree *ref_tree;
49 struct buffer_head *ref_root_bh; 48 struct buffer_head *ref_root_bh;
50 struct ocfs2_alloc_context *meta_ac; 49 struct ocfs2_alloc_context *meta_ac;
51 struct ocfs2_alloc_context *data_ac; 50 struct ocfs2_alloc_context *data_ac;
52 struct ocfs2_cached_dealloc_ctxt deall 51 struct ocfs2_cached_dealloc_ctxt dealloc;
53 void *cow_object; 52 void *cow_object;
54 struct ocfs2_post_refcount *post_refco 53 struct ocfs2_post_refcount *post_refcount;
55 int extra_credits; 54 int extra_credits;
56 int (*get_clusters)(struct ocfs2_cow_c 55 int (*get_clusters)(struct ocfs2_cow_context *context,
57 u32 v_cluster, u32 56 u32 v_cluster, u32 *p_cluster,
58 u32 *num_clusters, 57 u32 *num_clusters,
59 unsigned int *exte 58 unsigned int *extent_flags);
60 int (*cow_duplicate_clusters)(handle_t 59 int (*cow_duplicate_clusters)(handle_t *handle,
61 struct i 60 struct inode *inode,
62 u32 cpos 61 u32 cpos, u32 old_cluster,
63 u32 new_ 62 u32 new_cluster, u32 new_len);
64 }; 63 };
65 64
66 static inline struct ocfs2_refcount_tree * 65 static inline struct ocfs2_refcount_tree *
67 cache_info_to_refcount(struct ocfs2_caching_in 66 cache_info_to_refcount(struct ocfs2_caching_info *ci)
68 { 67 {
69 return container_of(ci, struct ocfs2_r 68 return container_of(ci, struct ocfs2_refcount_tree, rf_ci);
70 } 69 }
71 70
72 static int ocfs2_validate_refcount_block(struc 71 static int ocfs2_validate_refcount_block(struct super_block *sb,
73 struc 72 struct buffer_head *bh)
74 { 73 {
75 int rc; 74 int rc;
76 struct ocfs2_refcount_block *rb = 75 struct ocfs2_refcount_block *rb =
77 (struct ocfs2_refcount_block * 76 (struct ocfs2_refcount_block *)bh->b_data;
78 77
79 trace_ocfs2_validate_refcount_block((u 78 trace_ocfs2_validate_refcount_block((unsigned long long)bh->b_blocknr);
80 79
81 BUG_ON(!buffer_uptodate(bh)); 80 BUG_ON(!buffer_uptodate(bh));
82 81
83 /* 82 /*
84 * If the ecc fails, we return the err 83 * If the ecc fails, we return the error but otherwise
85 * leave the filesystem running. We k 84 * leave the filesystem running. We know any error is
86 * local to this block. 85 * local to this block.
87 */ 86 */
88 rc = ocfs2_validate_meta_ecc(sb, bh->b 87 rc = ocfs2_validate_meta_ecc(sb, bh->b_data, &rb->rf_check);
89 if (rc) { 88 if (rc) {
90 mlog(ML_ERROR, "Checksum faile 89 mlog(ML_ERROR, "Checksum failed for refcount block %llu\n",
91 (unsigned long long)bh->b 90 (unsigned long long)bh->b_blocknr);
92 return rc; 91 return rc;
93 } 92 }
94 93
95 94
96 if (!OCFS2_IS_VALID_REFCOUNT_BLOCK(rb) 95 if (!OCFS2_IS_VALID_REFCOUNT_BLOCK(rb)) {
97 rc = ocfs2_error(sb, 96 rc = ocfs2_error(sb,
98 "Refcount blo 97 "Refcount block #%llu has bad signature %.*s\n",
99 (unsigned lon 98 (unsigned long long)bh->b_blocknr, 7,
100 rb->rf_signat 99 rb->rf_signature);
101 goto out; 100 goto out;
102 } 101 }
103 102
104 if (le64_to_cpu(rb->rf_blkno) != bh->b 103 if (le64_to_cpu(rb->rf_blkno) != bh->b_blocknr) {
105 rc = ocfs2_error(sb, 104 rc = ocfs2_error(sb,
106 "Refcount blo 105 "Refcount block #%llu has an invalid rf_blkno of %llu\n",
107 (unsigned lon 106 (unsigned long long)bh->b_blocknr,
108 (unsigned lon 107 (unsigned long long)le64_to_cpu(rb->rf_blkno));
109 goto out; 108 goto out;
110 } 109 }
111 110
112 if (le32_to_cpu(rb->rf_fs_generation) 111 if (le32_to_cpu(rb->rf_fs_generation) != OCFS2_SB(sb)->fs_generation) {
113 rc = ocfs2_error(sb, 112 rc = ocfs2_error(sb,
114 "Refcount blo 113 "Refcount block #%llu has an invalid rf_fs_generation of #%u\n",
115 (unsigned lon 114 (unsigned long long)bh->b_blocknr,
116 le32_to_cpu(r 115 le32_to_cpu(rb->rf_fs_generation));
117 goto out; 116 goto out;
118 } 117 }
119 out: 118 out:
120 return rc; 119 return rc;
121 } 120 }
122 121
123 static int ocfs2_read_refcount_block(struct oc 122 static int ocfs2_read_refcount_block(struct ocfs2_caching_info *ci,
124 u64 rb_bl 123 u64 rb_blkno,
125 struct bu 124 struct buffer_head **bh)
126 { 125 {
127 int rc; 126 int rc;
128 struct buffer_head *tmp = *bh; 127 struct buffer_head *tmp = *bh;
129 128
130 rc = ocfs2_read_block(ci, rb_blkno, &t 129 rc = ocfs2_read_block(ci, rb_blkno, &tmp,
131 ocfs2_validate_r 130 ocfs2_validate_refcount_block);
132 131
133 /* If ocfs2_read_block() got us a new 132 /* If ocfs2_read_block() got us a new bh, pass it up. */
134 if (!rc && !*bh) 133 if (!rc && !*bh)
135 *bh = tmp; 134 *bh = tmp;
136 135
137 return rc; 136 return rc;
138 } 137 }
139 138
140 static u64 ocfs2_refcount_cache_owner(struct o 139 static u64 ocfs2_refcount_cache_owner(struct ocfs2_caching_info *ci)
141 { 140 {
142 struct ocfs2_refcount_tree *rf = cache 141 struct ocfs2_refcount_tree *rf = cache_info_to_refcount(ci);
143 142
144 return rf->rf_blkno; 143 return rf->rf_blkno;
145 } 144 }
146 145
147 static struct super_block * 146 static struct super_block *
148 ocfs2_refcount_cache_get_super(struct ocfs2_ca 147 ocfs2_refcount_cache_get_super(struct ocfs2_caching_info *ci)
149 { 148 {
150 struct ocfs2_refcount_tree *rf = cache 149 struct ocfs2_refcount_tree *rf = cache_info_to_refcount(ci);
151 150
152 return rf->rf_sb; 151 return rf->rf_sb;
153 } 152 }
154 153
155 static void ocfs2_refcount_cache_lock(struct o 154 static void ocfs2_refcount_cache_lock(struct ocfs2_caching_info *ci)
156 __acquires(&rf->rf_lock) 155 __acquires(&rf->rf_lock)
157 { 156 {
158 struct ocfs2_refcount_tree *rf = cache 157 struct ocfs2_refcount_tree *rf = cache_info_to_refcount(ci);
159 158
160 spin_lock(&rf->rf_lock); 159 spin_lock(&rf->rf_lock);
161 } 160 }
162 161
163 static void ocfs2_refcount_cache_unlock(struct 162 static void ocfs2_refcount_cache_unlock(struct ocfs2_caching_info *ci)
164 __releases(&rf->rf_lock) 163 __releases(&rf->rf_lock)
165 { 164 {
166 struct ocfs2_refcount_tree *rf = cache 165 struct ocfs2_refcount_tree *rf = cache_info_to_refcount(ci);
167 166
168 spin_unlock(&rf->rf_lock); 167 spin_unlock(&rf->rf_lock);
169 } 168 }
170 169
171 static void ocfs2_refcount_cache_io_lock(struc 170 static void ocfs2_refcount_cache_io_lock(struct ocfs2_caching_info *ci)
172 { 171 {
173 struct ocfs2_refcount_tree *rf = cache 172 struct ocfs2_refcount_tree *rf = cache_info_to_refcount(ci);
174 173
175 mutex_lock(&rf->rf_io_mutex); 174 mutex_lock(&rf->rf_io_mutex);
176 } 175 }
177 176
178 static void ocfs2_refcount_cache_io_unlock(str 177 static void ocfs2_refcount_cache_io_unlock(struct ocfs2_caching_info *ci)
179 { 178 {
180 struct ocfs2_refcount_tree *rf = cache 179 struct ocfs2_refcount_tree *rf = cache_info_to_refcount(ci);
181 180
182 mutex_unlock(&rf->rf_io_mutex); 181 mutex_unlock(&rf->rf_io_mutex);
183 } 182 }
184 183
185 static const struct ocfs2_caching_operations o 184 static const struct ocfs2_caching_operations ocfs2_refcount_caching_ops = {
186 .co_owner = ocfs2_refcou 185 .co_owner = ocfs2_refcount_cache_owner,
187 .co_get_super = ocfs2_refcou 186 .co_get_super = ocfs2_refcount_cache_get_super,
188 .co_cache_lock = ocfs2_refcou 187 .co_cache_lock = ocfs2_refcount_cache_lock,
189 .co_cache_unlock = ocfs2_refcou 188 .co_cache_unlock = ocfs2_refcount_cache_unlock,
190 .co_io_lock = ocfs2_refcou 189 .co_io_lock = ocfs2_refcount_cache_io_lock,
191 .co_io_unlock = ocfs2_refcou 190 .co_io_unlock = ocfs2_refcount_cache_io_unlock,
192 }; 191 };
193 192
194 static struct ocfs2_refcount_tree * 193 static struct ocfs2_refcount_tree *
195 ocfs2_find_refcount_tree(struct ocfs2_super *o 194 ocfs2_find_refcount_tree(struct ocfs2_super *osb, u64 blkno)
196 { 195 {
197 struct rb_node *n = osb->osb_rf_lock_t 196 struct rb_node *n = osb->osb_rf_lock_tree.rb_node;
198 struct ocfs2_refcount_tree *tree = NUL 197 struct ocfs2_refcount_tree *tree = NULL;
199 198
200 while (n) { 199 while (n) {
201 tree = rb_entry(n, struct ocfs 200 tree = rb_entry(n, struct ocfs2_refcount_tree, rf_node);
202 201
203 if (blkno < tree->rf_blkno) 202 if (blkno < tree->rf_blkno)
204 n = n->rb_left; 203 n = n->rb_left;
205 else if (blkno > tree->rf_blkn 204 else if (blkno > tree->rf_blkno)
206 n = n->rb_right; 205 n = n->rb_right;
207 else 206 else
208 return tree; 207 return tree;
209 } 208 }
210 209
211 return NULL; 210 return NULL;
212 } 211 }
213 212
214 /* osb_lock is already locked. */ 213 /* osb_lock is already locked. */
215 static void ocfs2_insert_refcount_tree(struct 214 static void ocfs2_insert_refcount_tree(struct ocfs2_super *osb,
216 struct 215 struct ocfs2_refcount_tree *new)
217 { 216 {
218 u64 rf_blkno = new->rf_blkno; 217 u64 rf_blkno = new->rf_blkno;
219 struct rb_node *parent = NULL; 218 struct rb_node *parent = NULL;
220 struct rb_node **p = &osb->osb_rf_lock 219 struct rb_node **p = &osb->osb_rf_lock_tree.rb_node;
221 struct ocfs2_refcount_tree *tmp; 220 struct ocfs2_refcount_tree *tmp;
222 221
223 while (*p) { 222 while (*p) {
224 parent = *p; 223 parent = *p;
225 224
226 tmp = rb_entry(parent, struct 225 tmp = rb_entry(parent, struct ocfs2_refcount_tree,
227 rf_node); 226 rf_node);
228 227
229 if (rf_blkno < tmp->rf_blkno) 228 if (rf_blkno < tmp->rf_blkno)
230 p = &(*p)->rb_left; 229 p = &(*p)->rb_left;
231 else if (rf_blkno > tmp->rf_bl 230 else if (rf_blkno > tmp->rf_blkno)
232 p = &(*p)->rb_right; 231 p = &(*p)->rb_right;
233 else { 232 else {
234 /* This should never h 233 /* This should never happen! */
235 mlog(ML_ERROR, "Duplic 234 mlog(ML_ERROR, "Duplicate refcount block %llu found!\n",
236 (unsigned long lo 235 (unsigned long long)rf_blkno);
237 BUG(); 236 BUG();
238 } 237 }
239 } 238 }
240 239
241 rb_link_node(&new->rf_node, parent, p) 240 rb_link_node(&new->rf_node, parent, p);
242 rb_insert_color(&new->rf_node, &osb->o 241 rb_insert_color(&new->rf_node, &osb->osb_rf_lock_tree);
243 } 242 }
244 243
245 static void ocfs2_free_refcount_tree(struct oc 244 static void ocfs2_free_refcount_tree(struct ocfs2_refcount_tree *tree)
246 { 245 {
247 ocfs2_metadata_cache_exit(&tree->rf_ci 246 ocfs2_metadata_cache_exit(&tree->rf_ci);
248 ocfs2_simple_drop_lockres(OCFS2_SB(tre 247 ocfs2_simple_drop_lockres(OCFS2_SB(tree->rf_sb), &tree->rf_lockres);
249 ocfs2_lock_res_free(&tree->rf_lockres) 248 ocfs2_lock_res_free(&tree->rf_lockres);
250 kfree(tree); 249 kfree(tree);
251 } 250 }
252 251
253 static inline void 252 static inline void
254 ocfs2_erase_refcount_tree_from_list_no_lock(st 253 ocfs2_erase_refcount_tree_from_list_no_lock(struct ocfs2_super *osb,
255 struct 254 struct ocfs2_refcount_tree *tree)
256 { 255 {
257 rb_erase(&tree->rf_node, &osb->osb_rf_ 256 rb_erase(&tree->rf_node, &osb->osb_rf_lock_tree);
258 if (osb->osb_ref_tree_lru && osb->osb_ 257 if (osb->osb_ref_tree_lru && osb->osb_ref_tree_lru == tree)
259 osb->osb_ref_tree_lru = NULL; 258 osb->osb_ref_tree_lru = NULL;
260 } 259 }
261 260
262 static void ocfs2_erase_refcount_tree_from_lis 261 static void ocfs2_erase_refcount_tree_from_list(struct ocfs2_super *osb,
263 struct 262 struct ocfs2_refcount_tree *tree)
264 { 263 {
265 spin_lock(&osb->osb_lock); 264 spin_lock(&osb->osb_lock);
266 ocfs2_erase_refcount_tree_from_list_no 265 ocfs2_erase_refcount_tree_from_list_no_lock(osb, tree);
267 spin_unlock(&osb->osb_lock); 266 spin_unlock(&osb->osb_lock);
268 } 267 }
269 268
270 static void ocfs2_kref_remove_refcount_tree(st 269 static void ocfs2_kref_remove_refcount_tree(struct kref *kref)
271 { 270 {
272 struct ocfs2_refcount_tree *tree = 271 struct ocfs2_refcount_tree *tree =
273 container_of(kref, struct ocfs 272 container_of(kref, struct ocfs2_refcount_tree, rf_getcnt);
274 273
275 ocfs2_free_refcount_tree(tree); 274 ocfs2_free_refcount_tree(tree);
276 } 275 }
277 276
278 static inline void 277 static inline void
279 ocfs2_refcount_tree_get(struct ocfs2_refcount_ 278 ocfs2_refcount_tree_get(struct ocfs2_refcount_tree *tree)
280 { 279 {
281 kref_get(&tree->rf_getcnt); 280 kref_get(&tree->rf_getcnt);
282 } 281 }
283 282
284 static inline void 283 static inline void
285 ocfs2_refcount_tree_put(struct ocfs2_refcount_ 284 ocfs2_refcount_tree_put(struct ocfs2_refcount_tree *tree)
286 { 285 {
287 kref_put(&tree->rf_getcnt, ocfs2_kref_ 286 kref_put(&tree->rf_getcnt, ocfs2_kref_remove_refcount_tree);
288 } 287 }
289 288
290 static inline void ocfs2_init_refcount_tree_ci 289 static inline void ocfs2_init_refcount_tree_ci(struct ocfs2_refcount_tree *new,
291 290 struct super_block *sb)
292 { 291 {
293 ocfs2_metadata_cache_init(&new->rf_ci, 292 ocfs2_metadata_cache_init(&new->rf_ci, &ocfs2_refcount_caching_ops);
294 mutex_init(&new->rf_io_mutex); 293 mutex_init(&new->rf_io_mutex);
295 new->rf_sb = sb; 294 new->rf_sb = sb;
296 spin_lock_init(&new->rf_lock); 295 spin_lock_init(&new->rf_lock);
297 } 296 }
298 297
299 static inline void ocfs2_init_refcount_tree_lo 298 static inline void ocfs2_init_refcount_tree_lock(struct ocfs2_super *osb,
300 struct 299 struct ocfs2_refcount_tree *new,
301 u64 rf 300 u64 rf_blkno, u32 generation)
302 { 301 {
303 init_rwsem(&new->rf_sem); 302 init_rwsem(&new->rf_sem);
304 ocfs2_refcount_lock_res_init(&new->rf_ 303 ocfs2_refcount_lock_res_init(&new->rf_lockres, osb,
305 rf_blkno, 304 rf_blkno, generation);
306 } 305 }
307 306
308 static struct ocfs2_refcount_tree* 307 static struct ocfs2_refcount_tree*
309 ocfs2_allocate_refcount_tree(struct ocfs2_supe 308 ocfs2_allocate_refcount_tree(struct ocfs2_super *osb, u64 rf_blkno)
310 { 309 {
311 struct ocfs2_refcount_tree *new; 310 struct ocfs2_refcount_tree *new;
312 311
313 new = kzalloc(sizeof(struct ocfs2_refc 312 new = kzalloc(sizeof(struct ocfs2_refcount_tree), GFP_NOFS);
314 if (!new) 313 if (!new)
315 return NULL; 314 return NULL;
316 315
317 new->rf_blkno = rf_blkno; 316 new->rf_blkno = rf_blkno;
318 kref_init(&new->rf_getcnt); 317 kref_init(&new->rf_getcnt);
319 ocfs2_init_refcount_tree_ci(new, osb-> 318 ocfs2_init_refcount_tree_ci(new, osb->sb);
320 319
321 return new; 320 return new;
322 } 321 }
323 322
324 static int ocfs2_get_refcount_tree(struct ocfs 323 static int ocfs2_get_refcount_tree(struct ocfs2_super *osb, u64 rf_blkno,
325 struct ocfs 324 struct ocfs2_refcount_tree **ret_tree)
326 { 325 {
327 int ret = 0; 326 int ret = 0;
328 struct ocfs2_refcount_tree *tree, *new 327 struct ocfs2_refcount_tree *tree, *new = NULL;
329 struct buffer_head *ref_root_bh = NULL 328 struct buffer_head *ref_root_bh = NULL;
330 struct ocfs2_refcount_block *ref_rb; 329 struct ocfs2_refcount_block *ref_rb;
331 330
332 spin_lock(&osb->osb_lock); 331 spin_lock(&osb->osb_lock);
333 if (osb->osb_ref_tree_lru && 332 if (osb->osb_ref_tree_lru &&
334 osb->osb_ref_tree_lru->rf_blkno == 333 osb->osb_ref_tree_lru->rf_blkno == rf_blkno)
335 tree = osb->osb_ref_tree_lru; 334 tree = osb->osb_ref_tree_lru;
336 else 335 else
337 tree = ocfs2_find_refcount_tre 336 tree = ocfs2_find_refcount_tree(osb, rf_blkno);
338 if (tree) 337 if (tree)
339 goto out; 338 goto out;
340 339
341 spin_unlock(&osb->osb_lock); 340 spin_unlock(&osb->osb_lock);
342 341
343 new = ocfs2_allocate_refcount_tree(osb 342 new = ocfs2_allocate_refcount_tree(osb, rf_blkno);
344 if (!new) { 343 if (!new) {
345 ret = -ENOMEM; 344 ret = -ENOMEM;
346 mlog_errno(ret); 345 mlog_errno(ret);
347 return ret; 346 return ret;
348 } 347 }
349 /* 348 /*
350 * We need the generation to create th 349 * We need the generation to create the refcount tree lock and since
351 * it isn't changed during the tree mo 350 * it isn't changed during the tree modification, we are safe here to
352 * read without protection. 351 * read without protection.
353 * We also have to purge the cache aft 352 * We also have to purge the cache after we create the lock since the
354 * refcount block may have the stale d 353 * refcount block may have the stale data. It can only be trusted when
355 * we hold the refcount lock. 354 * we hold the refcount lock.
356 */ 355 */
357 ret = ocfs2_read_refcount_block(&new-> 356 ret = ocfs2_read_refcount_block(&new->rf_ci, rf_blkno, &ref_root_bh);
358 if (ret) { 357 if (ret) {
359 mlog_errno(ret); 358 mlog_errno(ret);
360 ocfs2_metadata_cache_exit(&new 359 ocfs2_metadata_cache_exit(&new->rf_ci);
361 kfree(new); 360 kfree(new);
362 return ret; 361 return ret;
363 } 362 }
364 363
365 ref_rb = (struct ocfs2_refcount_block 364 ref_rb = (struct ocfs2_refcount_block *)ref_root_bh->b_data;
366 new->rf_generation = le32_to_cpu(ref_r 365 new->rf_generation = le32_to_cpu(ref_rb->rf_generation);
367 ocfs2_init_refcount_tree_lock(osb, new 366 ocfs2_init_refcount_tree_lock(osb, new, rf_blkno,
368 new->rf_ 367 new->rf_generation);
369 ocfs2_metadata_cache_purge(&new->rf_ci 368 ocfs2_metadata_cache_purge(&new->rf_ci);
370 369
371 spin_lock(&osb->osb_lock); 370 spin_lock(&osb->osb_lock);
372 tree = ocfs2_find_refcount_tree(osb, r 371 tree = ocfs2_find_refcount_tree(osb, rf_blkno);
373 if (tree) 372 if (tree)
374 goto out; 373 goto out;
375 374
376 ocfs2_insert_refcount_tree(osb, new); 375 ocfs2_insert_refcount_tree(osb, new);
377 376
378 tree = new; 377 tree = new;
379 new = NULL; 378 new = NULL;
380 379
381 out: 380 out:
382 *ret_tree = tree; 381 *ret_tree = tree;
383 382
384 osb->osb_ref_tree_lru = tree; 383 osb->osb_ref_tree_lru = tree;
385 384
386 spin_unlock(&osb->osb_lock); 385 spin_unlock(&osb->osb_lock);
387 386
388 if (new) 387 if (new)
389 ocfs2_free_refcount_tree(new); 388 ocfs2_free_refcount_tree(new);
390 389
391 brelse(ref_root_bh); 390 brelse(ref_root_bh);
392 return ret; 391 return ret;
393 } 392 }
394 393
395 static int ocfs2_get_refcount_block(struct ino 394 static int ocfs2_get_refcount_block(struct inode *inode, u64 *ref_blkno)
396 { 395 {
397 int ret; 396 int ret;
398 struct buffer_head *di_bh = NULL; 397 struct buffer_head *di_bh = NULL;
399 struct ocfs2_dinode *di; 398 struct ocfs2_dinode *di;
400 399
401 ret = ocfs2_read_inode_block(inode, &d 400 ret = ocfs2_read_inode_block(inode, &di_bh);
402 if (ret) { 401 if (ret) {
403 mlog_errno(ret); 402 mlog_errno(ret);
404 goto out; 403 goto out;
405 } 404 }
406 405
407 BUG_ON(!ocfs2_is_refcount_inode(inode) 406 BUG_ON(!ocfs2_is_refcount_inode(inode));
408 407
409 di = (struct ocfs2_dinode *)di_bh->b_d 408 di = (struct ocfs2_dinode *)di_bh->b_data;
410 *ref_blkno = le64_to_cpu(di->i_refcoun 409 *ref_blkno = le64_to_cpu(di->i_refcount_loc);
411 brelse(di_bh); 410 brelse(di_bh);
412 out: 411 out:
413 return ret; 412 return ret;
414 } 413 }
415 414
416 static int __ocfs2_lock_refcount_tree(struct o 415 static int __ocfs2_lock_refcount_tree(struct ocfs2_super *osb,
417 struct o 416 struct ocfs2_refcount_tree *tree, int rw)
418 { 417 {
419 int ret; 418 int ret;
420 419
421 ret = ocfs2_refcount_lock(tree, rw); 420 ret = ocfs2_refcount_lock(tree, rw);
422 if (ret) { 421 if (ret) {
423 mlog_errno(ret); 422 mlog_errno(ret);
424 goto out; 423 goto out;
425 } 424 }
426 425
427 if (rw) 426 if (rw)
428 down_write(&tree->rf_sem); 427 down_write(&tree->rf_sem);
429 else 428 else
430 down_read(&tree->rf_sem); 429 down_read(&tree->rf_sem);
431 430
432 out: 431 out:
433 return ret; 432 return ret;
434 } 433 }
435 434
436 /* 435 /*
437 * Lock the refcount tree pointed by ref_blkno 436 * Lock the refcount tree pointed by ref_blkno and return the tree.
438 * In most case, we lock the tree and read the 437 * In most case, we lock the tree and read the refcount block.
439 * So read it here if the caller really needs 438 * So read it here if the caller really needs it.
440 * 439 *
441 * If the tree has been re-created by other no 440 * If the tree has been re-created by other node, it will free the
442 * old one and re-create it. 441 * old one and re-create it.
443 */ 442 */
444 int ocfs2_lock_refcount_tree(struct ocfs2_supe 443 int ocfs2_lock_refcount_tree(struct ocfs2_super *osb,
445 u64 ref_blkno, in 444 u64 ref_blkno, int rw,
446 struct ocfs2_refc 445 struct ocfs2_refcount_tree **ret_tree,
447 struct buffer_hea 446 struct buffer_head **ref_bh)
448 { 447 {
449 int ret, delete_tree = 0; 448 int ret, delete_tree = 0;
450 struct ocfs2_refcount_tree *tree = NUL 449 struct ocfs2_refcount_tree *tree = NULL;
451 struct buffer_head *ref_root_bh = NULL 450 struct buffer_head *ref_root_bh = NULL;
452 struct ocfs2_refcount_block *rb; 451 struct ocfs2_refcount_block *rb;
453 452
454 again: 453 again:
455 ret = ocfs2_get_refcount_tree(osb, ref 454 ret = ocfs2_get_refcount_tree(osb, ref_blkno, &tree);
456 if (ret) { 455 if (ret) {
457 mlog_errno(ret); 456 mlog_errno(ret);
458 return ret; 457 return ret;
459 } 458 }
460 459
461 ocfs2_refcount_tree_get(tree); 460 ocfs2_refcount_tree_get(tree);
462 461
463 ret = __ocfs2_lock_refcount_tree(osb, 462 ret = __ocfs2_lock_refcount_tree(osb, tree, rw);
464 if (ret) { 463 if (ret) {
465 mlog_errno(ret); 464 mlog_errno(ret);
466 ocfs2_refcount_tree_put(tree); 465 ocfs2_refcount_tree_put(tree);
467 goto out; 466 goto out;
468 } 467 }
469 468
470 ret = ocfs2_read_refcount_block(&tree- 469 ret = ocfs2_read_refcount_block(&tree->rf_ci, tree->rf_blkno,
471 &ref_r 470 &ref_root_bh);
472 if (ret) { 471 if (ret) {
473 mlog_errno(ret); 472 mlog_errno(ret);
474 ocfs2_unlock_refcount_tree(osb 473 ocfs2_unlock_refcount_tree(osb, tree, rw);
475 goto out; 474 goto out;
476 } 475 }
477 476
478 rb = (struct ocfs2_refcount_block *)re 477 rb = (struct ocfs2_refcount_block *)ref_root_bh->b_data;
479 /* 478 /*
480 * If the refcount block has been free 479 * If the refcount block has been freed and re-created, we may need
481 * to recreate the refcount tree also. 480 * to recreate the refcount tree also.
482 * 481 *
483 * Here we just remove the tree from t 482 * Here we just remove the tree from the rb-tree, and the last
484 * kref holder will unlock and delete 483 * kref holder will unlock and delete this refcount_tree.
485 * Then we goto "again" and ocfs2_get_ 484 * Then we goto "again" and ocfs2_get_refcount_tree will create
486 * the new refcount tree for us. 485 * the new refcount tree for us.
487 */ 486 */
488 if (tree->rf_generation != le32_to_cpu 487 if (tree->rf_generation != le32_to_cpu(rb->rf_generation)) {
489 if (!tree->rf_removed) { 488 if (!tree->rf_removed) {
490 ocfs2_erase_refcount_t 489 ocfs2_erase_refcount_tree_from_list(osb, tree);
491 tree->rf_removed = 1; 490 tree->rf_removed = 1;
492 delete_tree = 1; 491 delete_tree = 1;
493 } 492 }
494 493
495 ocfs2_unlock_refcount_tree(osb 494 ocfs2_unlock_refcount_tree(osb, tree, rw);
496 /* 495 /*
497 * We get an extra reference w 496 * We get an extra reference when we create the refcount
498 * tree, so another put will d 497 * tree, so another put will destroy it.
499 */ 498 */
500 if (delete_tree) 499 if (delete_tree)
501 ocfs2_refcount_tree_pu 500 ocfs2_refcount_tree_put(tree);
502 brelse(ref_root_bh); 501 brelse(ref_root_bh);
503 ref_root_bh = NULL; 502 ref_root_bh = NULL;
504 goto again; 503 goto again;
505 } 504 }
506 505
507 *ret_tree = tree; 506 *ret_tree = tree;
508 if (ref_bh) { 507 if (ref_bh) {
509 *ref_bh = ref_root_bh; 508 *ref_bh = ref_root_bh;
510 ref_root_bh = NULL; 509 ref_root_bh = NULL;
511 } 510 }
512 out: 511 out:
513 brelse(ref_root_bh); 512 brelse(ref_root_bh);
514 return ret; 513 return ret;
515 } 514 }
516 515
517 void ocfs2_unlock_refcount_tree(struct ocfs2_s 516 void ocfs2_unlock_refcount_tree(struct ocfs2_super *osb,
518 struct ocfs2_r 517 struct ocfs2_refcount_tree *tree, int rw)
519 { 518 {
520 if (rw) 519 if (rw)
521 up_write(&tree->rf_sem); 520 up_write(&tree->rf_sem);
522 else 521 else
523 up_read(&tree->rf_sem); 522 up_read(&tree->rf_sem);
524 523
525 ocfs2_refcount_unlock(tree, rw); 524 ocfs2_refcount_unlock(tree, rw);
526 ocfs2_refcount_tree_put(tree); 525 ocfs2_refcount_tree_put(tree);
527 } 526 }
528 527
529 void ocfs2_purge_refcount_trees(struct ocfs2_s 528 void ocfs2_purge_refcount_trees(struct ocfs2_super *osb)
530 { 529 {
531 struct rb_node *node; 530 struct rb_node *node;
532 struct ocfs2_refcount_tree *tree; 531 struct ocfs2_refcount_tree *tree;
533 struct rb_root *root = &osb->osb_rf_lo 532 struct rb_root *root = &osb->osb_rf_lock_tree;
534 533
535 while ((node = rb_last(root)) != NULL) 534 while ((node = rb_last(root)) != NULL) {
536 tree = rb_entry(node, struct o 535 tree = rb_entry(node, struct ocfs2_refcount_tree, rf_node);
537 536
538 trace_ocfs2_purge_refcount_tre 537 trace_ocfs2_purge_refcount_trees(
539 (unsigned long 538 (unsigned long long) tree->rf_blkno);
540 539
541 rb_erase(&tree->rf_node, root) 540 rb_erase(&tree->rf_node, root);
542 ocfs2_free_refcount_tree(tree) 541 ocfs2_free_refcount_tree(tree);
543 } 542 }
544 } 543 }
545 544
546 /* 545 /*
547 * Create a refcount tree for an inode. 546 * Create a refcount tree for an inode.
548 * We take for granted that the inode is alrea 547 * We take for granted that the inode is already locked.
549 */ 548 */
550 static int ocfs2_create_refcount_tree(struct i 549 static int ocfs2_create_refcount_tree(struct inode *inode,
551 struct b 550 struct buffer_head *di_bh)
552 { 551 {
553 int ret; 552 int ret;
554 handle_t *handle = NULL; 553 handle_t *handle = NULL;
555 struct ocfs2_alloc_context *meta_ac = 554 struct ocfs2_alloc_context *meta_ac = NULL;
556 struct ocfs2_dinode *di = (struct ocfs 555 struct ocfs2_dinode *di = (struct ocfs2_dinode *)di_bh->b_data;
557 struct ocfs2_inode_info *oi = OCFS2_I( 556 struct ocfs2_inode_info *oi = OCFS2_I(inode);
558 struct ocfs2_super *osb = OCFS2_SB(ino 557 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
559 struct buffer_head *new_bh = NULL; 558 struct buffer_head *new_bh = NULL;
560 struct ocfs2_refcount_block *rb; 559 struct ocfs2_refcount_block *rb;
561 struct ocfs2_refcount_tree *new_tree = 560 struct ocfs2_refcount_tree *new_tree = NULL, *tree = NULL;
562 u16 suballoc_bit_start; 561 u16 suballoc_bit_start;
563 u32 num_got; 562 u32 num_got;
564 u64 suballoc_loc, first_blkno; 563 u64 suballoc_loc, first_blkno;
565 564
566 BUG_ON(ocfs2_is_refcount_inode(inode)) 565 BUG_ON(ocfs2_is_refcount_inode(inode));
567 566
568 trace_ocfs2_create_refcount_tree( 567 trace_ocfs2_create_refcount_tree(
569 (unsigned long long)oi->ip_blk 568 (unsigned long long)oi->ip_blkno);
570 569
571 ret = ocfs2_reserve_new_metadata_block 570 ret = ocfs2_reserve_new_metadata_blocks(osb, 1, &meta_ac);
572 if (ret) { 571 if (ret) {
573 mlog_errno(ret); 572 mlog_errno(ret);
574 goto out; 573 goto out;
575 } 574 }
576 575
577 handle = ocfs2_start_trans(osb, OCFS2_ 576 handle = ocfs2_start_trans(osb, OCFS2_REFCOUNT_TREE_CREATE_CREDITS);
578 if (IS_ERR(handle)) { 577 if (IS_ERR(handle)) {
579 ret = PTR_ERR(handle); 578 ret = PTR_ERR(handle);
580 mlog_errno(ret); 579 mlog_errno(ret);
581 goto out; 580 goto out;
582 } 581 }
583 582
584 ret = ocfs2_journal_access_di(handle, 583 ret = ocfs2_journal_access_di(handle, INODE_CACHE(inode), di_bh,
585 OCFS2_JO 584 OCFS2_JOURNAL_ACCESS_WRITE);
586 if (ret) { 585 if (ret) {
587 mlog_errno(ret); 586 mlog_errno(ret);
588 goto out_commit; 587 goto out_commit;
589 } 588 }
590 589
591 ret = ocfs2_claim_metadata(handle, met 590 ret = ocfs2_claim_metadata(handle, meta_ac, 1, &suballoc_loc,
592 &suballoc_b 591 &suballoc_bit_start, &num_got,
593 &first_blkn 592 &first_blkno);
594 if (ret) { 593 if (ret) {
595 mlog_errno(ret); 594 mlog_errno(ret);
596 goto out_commit; 595 goto out_commit;
597 } 596 }
598 597
599 new_tree = ocfs2_allocate_refcount_tre 598 new_tree = ocfs2_allocate_refcount_tree(osb, first_blkno);
600 if (!new_tree) { 599 if (!new_tree) {
601 ret = -ENOMEM; 600 ret = -ENOMEM;
602 mlog_errno(ret); 601 mlog_errno(ret);
603 goto out_commit; 602 goto out_commit;
604 } 603 }
605 604
606 new_bh = sb_getblk(inode->i_sb, first_ 605 new_bh = sb_getblk(inode->i_sb, first_blkno);
607 if (!new_bh) { 606 if (!new_bh) {
608 ret = -ENOMEM; 607 ret = -ENOMEM;
609 mlog_errno(ret); 608 mlog_errno(ret);
610 goto out_commit; 609 goto out_commit;
611 } 610 }
612 ocfs2_set_new_buffer_uptodate(&new_tre 611 ocfs2_set_new_buffer_uptodate(&new_tree->rf_ci, new_bh);
613 612
614 ret = ocfs2_journal_access_rb(handle, 613 ret = ocfs2_journal_access_rb(handle, &new_tree->rf_ci, new_bh,
615 OCFS2_JO 614 OCFS2_JOURNAL_ACCESS_CREATE);
616 if (ret) { 615 if (ret) {
617 mlog_errno(ret); 616 mlog_errno(ret);
618 goto out_commit; 617 goto out_commit;
619 } 618 }
620 619
621 /* Initialize ocfs2_refcount_block. */ 620 /* Initialize ocfs2_refcount_block. */
622 rb = (struct ocfs2_refcount_block *)ne 621 rb = (struct ocfs2_refcount_block *)new_bh->b_data;
623 memset(rb, 0, inode->i_sb->s_blocksize 622 memset(rb, 0, inode->i_sb->s_blocksize);
624 strcpy((void *)rb, OCFS2_REFCOUNT_BLOC 623 strcpy((void *)rb, OCFS2_REFCOUNT_BLOCK_SIGNATURE);
625 rb->rf_suballoc_slot = cpu_to_le16(met 624 rb->rf_suballoc_slot = cpu_to_le16(meta_ac->ac_alloc_slot);
626 rb->rf_suballoc_loc = cpu_to_le64(suba 625 rb->rf_suballoc_loc = cpu_to_le64(suballoc_loc);
627 rb->rf_suballoc_bit = cpu_to_le16(suba 626 rb->rf_suballoc_bit = cpu_to_le16(suballoc_bit_start);
628 rb->rf_fs_generation = cpu_to_le32(osb 627 rb->rf_fs_generation = cpu_to_le32(osb->fs_generation);
629 rb->rf_blkno = cpu_to_le64(first_blkno 628 rb->rf_blkno = cpu_to_le64(first_blkno);
630 rb->rf_count = cpu_to_le32(1); 629 rb->rf_count = cpu_to_le32(1);
631 rb->rf_records.rl_count = 630 rb->rf_records.rl_count =
632 cpu_to_le16(ocfs2_refc 631 cpu_to_le16(ocfs2_refcount_recs_per_rb(osb->sb));
633 spin_lock(&osb->osb_lock); 632 spin_lock(&osb->osb_lock);
634 rb->rf_generation = cpu_to_le32(osb->s !! 633 rb->rf_generation = osb->s_next_generation++;
635 spin_unlock(&osb->osb_lock); 634 spin_unlock(&osb->osb_lock);
636 635
637 ocfs2_journal_dirty(handle, new_bh); 636 ocfs2_journal_dirty(handle, new_bh);
638 637
639 spin_lock(&oi->ip_lock); 638 spin_lock(&oi->ip_lock);
640 oi->ip_dyn_features |= OCFS2_HAS_REFCO 639 oi->ip_dyn_features |= OCFS2_HAS_REFCOUNT_FL;
641 di->i_dyn_features = cpu_to_le16(oi->i 640 di->i_dyn_features = cpu_to_le16(oi->ip_dyn_features);
642 di->i_refcount_loc = cpu_to_le64(first 641 di->i_refcount_loc = cpu_to_le64(first_blkno);
643 spin_unlock(&oi->ip_lock); 642 spin_unlock(&oi->ip_lock);
644 643
645 trace_ocfs2_create_refcount_tree_blkno 644 trace_ocfs2_create_refcount_tree_blkno((unsigned long long)first_blkno);
646 645
647 ocfs2_journal_dirty(handle, di_bh); 646 ocfs2_journal_dirty(handle, di_bh);
648 647
649 /* 648 /*
650 * We have to init the tree lock here 649 * We have to init the tree lock here since it will use
651 * the generation number to create it. 650 * the generation number to create it.
652 */ 651 */
653 new_tree->rf_generation = le32_to_cpu( 652 new_tree->rf_generation = le32_to_cpu(rb->rf_generation);
654 ocfs2_init_refcount_tree_lock(osb, new 653 ocfs2_init_refcount_tree_lock(osb, new_tree, first_blkno,
655 new_tree 654 new_tree->rf_generation);
656 655
657 spin_lock(&osb->osb_lock); 656 spin_lock(&osb->osb_lock);
658 tree = ocfs2_find_refcount_tree(osb, f 657 tree = ocfs2_find_refcount_tree(osb, first_blkno);
659 658
660 /* 659 /*
661 * We've just created a new refcount t 660 * We've just created a new refcount tree in this block. If
662 * we found a refcount tree on the ocf 661 * we found a refcount tree on the ocfs2_super, it must be
663 * one we just deleted. We free the o 662 * one we just deleted. We free the old tree before
664 * inserting the new tree. 663 * inserting the new tree.
665 */ 664 */
666 BUG_ON(tree && tree->rf_generation == 665 BUG_ON(tree && tree->rf_generation == new_tree->rf_generation);
667 if (tree) 666 if (tree)
668 ocfs2_erase_refcount_tree_from 667 ocfs2_erase_refcount_tree_from_list_no_lock(osb, tree);
669 ocfs2_insert_refcount_tree(osb, new_tr 668 ocfs2_insert_refcount_tree(osb, new_tree);
670 spin_unlock(&osb->osb_lock); 669 spin_unlock(&osb->osb_lock);
671 new_tree = NULL; 670 new_tree = NULL;
672 if (tree) 671 if (tree)
673 ocfs2_refcount_tree_put(tree); 672 ocfs2_refcount_tree_put(tree);
674 673
675 out_commit: 674 out_commit:
676 ocfs2_commit_trans(osb, handle); 675 ocfs2_commit_trans(osb, handle);
677 676
678 out: 677 out:
679 if (new_tree) { 678 if (new_tree) {
680 ocfs2_metadata_cache_exit(&new 679 ocfs2_metadata_cache_exit(&new_tree->rf_ci);
681 kfree(new_tree); 680 kfree(new_tree);
682 } 681 }
683 682
684 brelse(new_bh); 683 brelse(new_bh);
685 if (meta_ac) 684 if (meta_ac)
686 ocfs2_free_alloc_context(meta_ 685 ocfs2_free_alloc_context(meta_ac);
687 686
688 return ret; 687 return ret;
689 } 688 }
690 689
691 static int ocfs2_set_refcount_tree(struct inod 690 static int ocfs2_set_refcount_tree(struct inode *inode,
692 struct buff 691 struct buffer_head *di_bh,
693 u64 refcoun 692 u64 refcount_loc)
694 { 693 {
695 int ret; 694 int ret;
696 handle_t *handle = NULL; 695 handle_t *handle = NULL;
697 struct ocfs2_dinode *di = (struct ocfs 696 struct ocfs2_dinode *di = (struct ocfs2_dinode *)di_bh->b_data;
698 struct ocfs2_inode_info *oi = OCFS2_I( 697 struct ocfs2_inode_info *oi = OCFS2_I(inode);
699 struct ocfs2_super *osb = OCFS2_SB(ino 698 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
700 struct buffer_head *ref_root_bh = NULL 699 struct buffer_head *ref_root_bh = NULL;
701 struct ocfs2_refcount_block *rb; 700 struct ocfs2_refcount_block *rb;
702 struct ocfs2_refcount_tree *ref_tree; 701 struct ocfs2_refcount_tree *ref_tree;
703 702
704 BUG_ON(ocfs2_is_refcount_inode(inode)) 703 BUG_ON(ocfs2_is_refcount_inode(inode));
705 704
706 ret = ocfs2_lock_refcount_tree(osb, re 705 ret = ocfs2_lock_refcount_tree(osb, refcount_loc, 1,
707 &ref_tr 706 &ref_tree, &ref_root_bh);
708 if (ret) { 707 if (ret) {
709 mlog_errno(ret); 708 mlog_errno(ret);
710 return ret; 709 return ret;
711 } 710 }
712 711
713 handle = ocfs2_start_trans(osb, OCFS2_ 712 handle = ocfs2_start_trans(osb, OCFS2_REFCOUNT_TREE_SET_CREDITS);
714 if (IS_ERR(handle)) { 713 if (IS_ERR(handle)) {
715 ret = PTR_ERR(handle); 714 ret = PTR_ERR(handle);
716 mlog_errno(ret); 715 mlog_errno(ret);
717 goto out; 716 goto out;
718 } 717 }
719 718
720 ret = ocfs2_journal_access_di(handle, 719 ret = ocfs2_journal_access_di(handle, INODE_CACHE(inode), di_bh,
721 OCFS2_JO 720 OCFS2_JOURNAL_ACCESS_WRITE);
722 if (ret) { 721 if (ret) {
723 mlog_errno(ret); 722 mlog_errno(ret);
724 goto out_commit; 723 goto out_commit;
725 } 724 }
726 725
727 ret = ocfs2_journal_access_rb(handle, 726 ret = ocfs2_journal_access_rb(handle, &ref_tree->rf_ci, ref_root_bh,
728 OCFS2_JO 727 OCFS2_JOURNAL_ACCESS_WRITE);
729 if (ret) { 728 if (ret) {
730 mlog_errno(ret); 729 mlog_errno(ret);
731 goto out_commit; 730 goto out_commit;
732 } 731 }
733 732
734 rb = (struct ocfs2_refcount_block *)re 733 rb = (struct ocfs2_refcount_block *)ref_root_bh->b_data;
735 le32_add_cpu(&rb->rf_count, 1); 734 le32_add_cpu(&rb->rf_count, 1);
736 735
737 ocfs2_journal_dirty(handle, ref_root_b 736 ocfs2_journal_dirty(handle, ref_root_bh);
738 737
739 spin_lock(&oi->ip_lock); 738 spin_lock(&oi->ip_lock);
740 oi->ip_dyn_features |= OCFS2_HAS_REFCO 739 oi->ip_dyn_features |= OCFS2_HAS_REFCOUNT_FL;
741 di->i_dyn_features = cpu_to_le16(oi->i 740 di->i_dyn_features = cpu_to_le16(oi->ip_dyn_features);
742 di->i_refcount_loc = cpu_to_le64(refco 741 di->i_refcount_loc = cpu_to_le64(refcount_loc);
743 spin_unlock(&oi->ip_lock); 742 spin_unlock(&oi->ip_lock);
744 ocfs2_journal_dirty(handle, di_bh); 743 ocfs2_journal_dirty(handle, di_bh);
745 744
746 out_commit: 745 out_commit:
747 ocfs2_commit_trans(osb, handle); 746 ocfs2_commit_trans(osb, handle);
748 out: 747 out:
749 ocfs2_unlock_refcount_tree(osb, ref_tr 748 ocfs2_unlock_refcount_tree(osb, ref_tree, 1);
750 brelse(ref_root_bh); 749 brelse(ref_root_bh);
751 750
752 return ret; 751 return ret;
753 } 752 }
754 753
755 int ocfs2_remove_refcount_tree(struct inode *i 754 int ocfs2_remove_refcount_tree(struct inode *inode, struct buffer_head *di_bh)
756 { 755 {
757 int ret, delete_tree = 0; 756 int ret, delete_tree = 0;
758 handle_t *handle = NULL; 757 handle_t *handle = NULL;
759 struct ocfs2_dinode *di = (struct ocfs 758 struct ocfs2_dinode *di = (struct ocfs2_dinode *)di_bh->b_data;
760 struct ocfs2_inode_info *oi = OCFS2_I( 759 struct ocfs2_inode_info *oi = OCFS2_I(inode);
761 struct ocfs2_super *osb = OCFS2_SB(ino 760 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
762 struct ocfs2_refcount_block *rb; 761 struct ocfs2_refcount_block *rb;
763 struct inode *alloc_inode = NULL; 762 struct inode *alloc_inode = NULL;
764 struct buffer_head *alloc_bh = NULL; 763 struct buffer_head *alloc_bh = NULL;
765 struct buffer_head *blk_bh = NULL; 764 struct buffer_head *blk_bh = NULL;
766 struct ocfs2_refcount_tree *ref_tree; 765 struct ocfs2_refcount_tree *ref_tree;
767 int credits = OCFS2_REFCOUNT_TREE_REMO 766 int credits = OCFS2_REFCOUNT_TREE_REMOVE_CREDITS;
768 u64 blk = 0, bg_blkno = 0, ref_blkno = 767 u64 blk = 0, bg_blkno = 0, ref_blkno = le64_to_cpu(di->i_refcount_loc);
769 u16 bit = 0; 768 u16 bit = 0;
770 769
771 if (!ocfs2_is_refcount_inode(inode)) 770 if (!ocfs2_is_refcount_inode(inode))
772 return 0; 771 return 0;
773 772
774 BUG_ON(!ref_blkno); 773 BUG_ON(!ref_blkno);
775 ret = ocfs2_lock_refcount_tree(osb, re 774 ret = ocfs2_lock_refcount_tree(osb, ref_blkno, 1, &ref_tree, &blk_bh);
776 if (ret) { 775 if (ret) {
777 mlog_errno(ret); 776 mlog_errno(ret);
778 return ret; 777 return ret;
779 } 778 }
780 779
781 rb = (struct ocfs2_refcount_block *)bl 780 rb = (struct ocfs2_refcount_block *)blk_bh->b_data;
782 781
783 /* 782 /*
784 * If we are the last user, we need to 783 * If we are the last user, we need to free the block.
785 * So lock the allocator ahead. 784 * So lock the allocator ahead.
786 */ 785 */
787 if (le32_to_cpu(rb->rf_count) == 1) { 786 if (le32_to_cpu(rb->rf_count) == 1) {
788 blk = le64_to_cpu(rb->rf_blkno 787 blk = le64_to_cpu(rb->rf_blkno);
789 bit = le16_to_cpu(rb->rf_subal 788 bit = le16_to_cpu(rb->rf_suballoc_bit);
790 if (rb->rf_suballoc_loc) 789 if (rb->rf_suballoc_loc)
791 bg_blkno = le64_to_cpu 790 bg_blkno = le64_to_cpu(rb->rf_suballoc_loc);
792 else 791 else
793 bg_blkno = ocfs2_which 792 bg_blkno = ocfs2_which_suballoc_group(blk, bit);
794 793
795 alloc_inode = ocfs2_get_system 794 alloc_inode = ocfs2_get_system_file_inode(osb,
796 EXTENT 795 EXTENT_ALLOC_SYSTEM_INODE,
797 le16_t 796 le16_to_cpu(rb->rf_suballoc_slot));
798 if (!alloc_inode) { 797 if (!alloc_inode) {
799 ret = -ENOMEM; 798 ret = -ENOMEM;
800 mlog_errno(ret); 799 mlog_errno(ret);
801 goto out; 800 goto out;
802 } 801 }
803 inode_lock(alloc_inode); 802 inode_lock(alloc_inode);
804 803
805 ret = ocfs2_inode_lock(alloc_i 804 ret = ocfs2_inode_lock(alloc_inode, &alloc_bh, 1);
806 if (ret) { 805 if (ret) {
807 mlog_errno(ret); 806 mlog_errno(ret);
808 goto out_mutex; 807 goto out_mutex;
809 } 808 }
810 809
811 credits += OCFS2_SUBALLOC_FREE 810 credits += OCFS2_SUBALLOC_FREE;
812 } 811 }
813 812
814 handle = ocfs2_start_trans(osb, credit 813 handle = ocfs2_start_trans(osb, credits);
815 if (IS_ERR(handle)) { 814 if (IS_ERR(handle)) {
816 ret = PTR_ERR(handle); 815 ret = PTR_ERR(handle);
817 mlog_errno(ret); 816 mlog_errno(ret);
818 goto out_unlock; 817 goto out_unlock;
819 } 818 }
820 819
821 ret = ocfs2_journal_access_di(handle, 820 ret = ocfs2_journal_access_di(handle, INODE_CACHE(inode), di_bh,
822 OCFS2_JO 821 OCFS2_JOURNAL_ACCESS_WRITE);
823 if (ret) { 822 if (ret) {
824 mlog_errno(ret); 823 mlog_errno(ret);
825 goto out_commit; 824 goto out_commit;
826 } 825 }
827 826
828 ret = ocfs2_journal_access_rb(handle, 827 ret = ocfs2_journal_access_rb(handle, &ref_tree->rf_ci, blk_bh,
829 OCFS2_JO 828 OCFS2_JOURNAL_ACCESS_WRITE);
830 if (ret) { 829 if (ret) {
831 mlog_errno(ret); 830 mlog_errno(ret);
832 goto out_commit; 831 goto out_commit;
833 } 832 }
834 833
835 spin_lock(&oi->ip_lock); 834 spin_lock(&oi->ip_lock);
836 oi->ip_dyn_features &= ~OCFS2_HAS_REFC 835 oi->ip_dyn_features &= ~OCFS2_HAS_REFCOUNT_FL;
837 di->i_dyn_features = cpu_to_le16(oi->i 836 di->i_dyn_features = cpu_to_le16(oi->ip_dyn_features);
838 di->i_refcount_loc = 0; 837 di->i_refcount_loc = 0;
839 spin_unlock(&oi->ip_lock); 838 spin_unlock(&oi->ip_lock);
840 ocfs2_journal_dirty(handle, di_bh); 839 ocfs2_journal_dirty(handle, di_bh);
841 840
842 le32_add_cpu(&rb->rf_count , -1); 841 le32_add_cpu(&rb->rf_count , -1);
843 ocfs2_journal_dirty(handle, blk_bh); 842 ocfs2_journal_dirty(handle, blk_bh);
844 843
845 if (!rb->rf_count) { 844 if (!rb->rf_count) {
846 delete_tree = 1; 845 delete_tree = 1;
847 ocfs2_erase_refcount_tree_from 846 ocfs2_erase_refcount_tree_from_list(osb, ref_tree);
848 ret = ocfs2_free_suballoc_bits 847 ret = ocfs2_free_suballoc_bits(handle, alloc_inode,
849 848 alloc_bh, bit, bg_blkno, 1);
850 if (ret) 849 if (ret)
851 mlog_errno(ret); 850 mlog_errno(ret);
852 } 851 }
853 852
854 out_commit: 853 out_commit:
855 ocfs2_commit_trans(osb, handle); 854 ocfs2_commit_trans(osb, handle);
856 out_unlock: 855 out_unlock:
857 if (alloc_inode) { 856 if (alloc_inode) {
858 ocfs2_inode_unlock(alloc_inode 857 ocfs2_inode_unlock(alloc_inode, 1);
859 brelse(alloc_bh); 858 brelse(alloc_bh);
860 } 859 }
861 out_mutex: 860 out_mutex:
862 if (alloc_inode) { 861 if (alloc_inode) {
863 inode_unlock(alloc_inode); 862 inode_unlock(alloc_inode);
864 iput(alloc_inode); 863 iput(alloc_inode);
865 } 864 }
866 out: 865 out:
867 ocfs2_unlock_refcount_tree(osb, ref_tr 866 ocfs2_unlock_refcount_tree(osb, ref_tree, 1);
868 if (delete_tree) 867 if (delete_tree)
869 ocfs2_refcount_tree_put(ref_tr 868 ocfs2_refcount_tree_put(ref_tree);
870 brelse(blk_bh); 869 brelse(blk_bh);
871 870
872 return ret; 871 return ret;
873 } 872 }
874 873
875 static void ocfs2_find_refcount_rec_in_rl(stru 874 static void ocfs2_find_refcount_rec_in_rl(struct ocfs2_caching_info *ci,
876 stru 875 struct buffer_head *ref_leaf_bh,
877 u64 876 u64 cpos, unsigned int len,
878 stru 877 struct ocfs2_refcount_rec *ret_rec,
879 int 878 int *index)
880 { 879 {
881 int i = 0; 880 int i = 0;
882 struct ocfs2_refcount_block *rb = 881 struct ocfs2_refcount_block *rb =
883 (struct ocfs2_refcount_block * 882 (struct ocfs2_refcount_block *)ref_leaf_bh->b_data;
884 struct ocfs2_refcount_rec *rec = NULL; 883 struct ocfs2_refcount_rec *rec = NULL;
885 884
886 for (; i < le16_to_cpu(rb->rf_records. 885 for (; i < le16_to_cpu(rb->rf_records.rl_used); i++) {
887 rec = &rb->rf_records.rl_recs[ 886 rec = &rb->rf_records.rl_recs[i];
888 887
889 if (le64_to_cpu(rec->r_cpos) + 888 if (le64_to_cpu(rec->r_cpos) +
890 le32_to_cpu(rec->r_cluster 889 le32_to_cpu(rec->r_clusters) <= cpos)
891 continue; 890 continue;
892 else if (le64_to_cpu(rec->r_cp 891 else if (le64_to_cpu(rec->r_cpos) > cpos)
893 break; 892 break;
894 893
895 /* ok, cpos fail in this rec. 894 /* ok, cpos fail in this rec. Just return. */
896 if (ret_rec) 895 if (ret_rec)
897 *ret_rec = *rec; 896 *ret_rec = *rec;
898 goto out; 897 goto out;
899 } 898 }
900 899
901 if (ret_rec) { 900 if (ret_rec) {
902 /* We meet with a hole here, s 901 /* We meet with a hole here, so fake the rec. */
903 ret_rec->r_cpos = cpu_to_le64( 902 ret_rec->r_cpos = cpu_to_le64(cpos);
904 ret_rec->r_refcount = 0; 903 ret_rec->r_refcount = 0;
905 if (i < le16_to_cpu(rb->rf_rec 904 if (i < le16_to_cpu(rb->rf_records.rl_used) &&
906 le64_to_cpu(rec->r_cpos) < 905 le64_to_cpu(rec->r_cpos) < cpos + len)
907 ret_rec->r_clusters = 906 ret_rec->r_clusters =
908 cpu_to_le32(le 907 cpu_to_le32(le64_to_cpu(rec->r_cpos) - cpos);
909 else 908 else
910 ret_rec->r_clusters = 909 ret_rec->r_clusters = cpu_to_le32(len);
911 } 910 }
912 911
913 out: 912 out:
914 *index = i; 913 *index = i;
915 } 914 }
916 915
917 /* 916 /*
918 * Try to remove refcount tree. The mechanism 917 * Try to remove refcount tree. The mechanism is:
919 * 1) Check whether i_clusters == 0, if no, ex 918 * 1) Check whether i_clusters == 0, if no, exit.
920 * 2) check whether we have i_xattr_loc in din 919 * 2) check whether we have i_xattr_loc in dinode. if yes, exit.
921 * 3) Check whether we have inline xattr store 920 * 3) Check whether we have inline xattr stored outside, if yes, exit.
922 * 4) Remove the tree. 921 * 4) Remove the tree.
923 */ 922 */
924 int ocfs2_try_remove_refcount_tree(struct inod 923 int ocfs2_try_remove_refcount_tree(struct inode *inode,
925 struct buff 924 struct buffer_head *di_bh)
926 { 925 {
927 int ret; 926 int ret;
928 struct ocfs2_inode_info *oi = OCFS2_I( 927 struct ocfs2_inode_info *oi = OCFS2_I(inode);
929 struct ocfs2_dinode *di = (struct ocfs 928 struct ocfs2_dinode *di = (struct ocfs2_dinode *)di_bh->b_data;
930 929
931 down_write(&oi->ip_xattr_sem); 930 down_write(&oi->ip_xattr_sem);
932 down_write(&oi->ip_alloc_sem); 931 down_write(&oi->ip_alloc_sem);
933 932
934 if (oi->ip_clusters) 933 if (oi->ip_clusters)
935 goto out; 934 goto out;
936 935
937 if ((oi->ip_dyn_features & OCFS2_HAS_X 936 if ((oi->ip_dyn_features & OCFS2_HAS_XATTR_FL) && di->i_xattr_loc)
938 goto out; 937 goto out;
939 938
940 if (oi->ip_dyn_features & OCFS2_INLINE 939 if (oi->ip_dyn_features & OCFS2_INLINE_XATTR_FL &&
941 ocfs2_has_inline_xattr_value_outsi 940 ocfs2_has_inline_xattr_value_outside(inode, di))
942 goto out; 941 goto out;
943 942
944 ret = ocfs2_remove_refcount_tree(inode 943 ret = ocfs2_remove_refcount_tree(inode, di_bh);
945 if (ret) 944 if (ret)
946 mlog_errno(ret); 945 mlog_errno(ret);
947 out: 946 out:
948 up_write(&oi->ip_alloc_sem); 947 up_write(&oi->ip_alloc_sem);
949 up_write(&oi->ip_xattr_sem); 948 up_write(&oi->ip_xattr_sem);
950 return 0; 949 return 0;
951 } 950 }
952 951
953 /* 952 /*
954 * Find the end range for a leaf refcount bloc 953 * Find the end range for a leaf refcount block indicated by
955 * el->l_recs[index].e_blkno. 954 * el->l_recs[index].e_blkno.
956 */ 955 */
957 static int ocfs2_get_refcount_cpos_end(struct 956 static int ocfs2_get_refcount_cpos_end(struct ocfs2_caching_info *ci,
958 struct 957 struct buffer_head *ref_root_bh,
959 struct 958 struct ocfs2_extent_block *eb,
960 struct 959 struct ocfs2_extent_list *el,
961 int ind 960 int index, u32 *cpos_end)
962 { 961 {
963 int ret, i, subtree_root; 962 int ret, i, subtree_root;
964 u32 cpos; 963 u32 cpos;
965 u64 blkno; 964 u64 blkno;
966 struct super_block *sb = ocfs2_metadat 965 struct super_block *sb = ocfs2_metadata_cache_get_super(ci);
967 struct ocfs2_path *left_path = NULL, * 966 struct ocfs2_path *left_path = NULL, *right_path = NULL;
968 struct ocfs2_extent_tree et; 967 struct ocfs2_extent_tree et;
969 struct ocfs2_extent_list *tmp_el; 968 struct ocfs2_extent_list *tmp_el;
970 969
971 if (index < le16_to_cpu(el->l_next_fre 970 if (index < le16_to_cpu(el->l_next_free_rec) - 1) {
972 /* 971 /*
973 * We have a extent rec after 972 * We have a extent rec after index, so just use the e_cpos
974 * of the next extent rec. 973 * of the next extent rec.
975 */ 974 */
976 *cpos_end = le32_to_cpu(el->l_ 975 *cpos_end = le32_to_cpu(el->l_recs[index+1].e_cpos);
977 return 0; 976 return 0;
978 } 977 }
979 978
980 if (!eb || !eb->h_next_leaf_blk) { 979 if (!eb || !eb->h_next_leaf_blk) {
981 /* 980 /*
982 * We are the last extent rec, 981 * We are the last extent rec, so any high cpos should
983 * be stored in this leaf refc 982 * be stored in this leaf refcount block.
984 */ 983 */
985 *cpos_end = UINT_MAX; 984 *cpos_end = UINT_MAX;
986 return 0; 985 return 0;
987 } 986 }
988 987
989 /* 988 /*
990 * If the extent block isn't the last 989 * If the extent block isn't the last one, we have to find
991 * the subtree root between this exten 990 * the subtree root between this extent block and the next
992 * leaf extent block and get the corre 991 * leaf extent block and get the corresponding e_cpos from
993 * the subroot. Otherwise we may corru 992 * the subroot. Otherwise we may corrupt the b-tree.
994 */ 993 */
995 ocfs2_init_refcount_extent_tree(&et, c 994 ocfs2_init_refcount_extent_tree(&et, ci, ref_root_bh);
996 995
997 left_path = ocfs2_new_path_from_et(&et 996 left_path = ocfs2_new_path_from_et(&et);
998 if (!left_path) { 997 if (!left_path) {
999 ret = -ENOMEM; 998 ret = -ENOMEM;
1000 mlog_errno(ret); 999 mlog_errno(ret);
1001 goto out; 1000 goto out;
1002 } 1001 }
1003 1002
1004 cpos = le32_to_cpu(eb->h_list.l_recs[ 1003 cpos = le32_to_cpu(eb->h_list.l_recs[index].e_cpos);
1005 ret = ocfs2_find_path(ci, left_path, 1004 ret = ocfs2_find_path(ci, left_path, cpos);
1006 if (ret) { 1005 if (ret) {
1007 mlog_errno(ret); 1006 mlog_errno(ret);
1008 goto out; 1007 goto out;
1009 } 1008 }
1010 1009
1011 right_path = ocfs2_new_path_from_path 1010 right_path = ocfs2_new_path_from_path(left_path);
1012 if (!right_path) { 1011 if (!right_path) {
1013 ret = -ENOMEM; 1012 ret = -ENOMEM;
1014 mlog_errno(ret); 1013 mlog_errno(ret);
1015 goto out; 1014 goto out;
1016 } 1015 }
1017 1016
1018 ret = ocfs2_find_cpos_for_right_leaf( 1017 ret = ocfs2_find_cpos_for_right_leaf(sb, left_path, &cpos);
1019 if (ret) { 1018 if (ret) {
1020 mlog_errno(ret); 1019 mlog_errno(ret);
1021 goto out; 1020 goto out;
1022 } 1021 }
1023 1022
1024 ret = ocfs2_find_path(ci, right_path, 1023 ret = ocfs2_find_path(ci, right_path, cpos);
1025 if (ret) { 1024 if (ret) {
1026 mlog_errno(ret); 1025 mlog_errno(ret);
1027 goto out; 1026 goto out;
1028 } 1027 }
1029 1028
1030 subtree_root = ocfs2_find_subtree_roo 1029 subtree_root = ocfs2_find_subtree_root(&et, left_path,
1031 1030 right_path);
1032 1031
1033 tmp_el = left_path->p_node[subtree_ro 1032 tmp_el = left_path->p_node[subtree_root].el;
1034 blkno = left_path->p_node[subtree_roo 1033 blkno = left_path->p_node[subtree_root+1].bh->b_blocknr;
1035 for (i = 0; i < le16_to_cpu(tmp_el->l 1034 for (i = 0; i < le16_to_cpu(tmp_el->l_next_free_rec); i++) {
1036 if (le64_to_cpu(tmp_el->l_rec 1035 if (le64_to_cpu(tmp_el->l_recs[i].e_blkno) == blkno) {
1037 *cpos_end = le32_to_c 1036 *cpos_end = le32_to_cpu(tmp_el->l_recs[i+1].e_cpos);
1038 break; 1037 break;
1039 } 1038 }
1040 } 1039 }
1041 1040
1042 BUG_ON(i == le16_to_cpu(tmp_el->l_nex 1041 BUG_ON(i == le16_to_cpu(tmp_el->l_next_free_rec));
1043 1042
1044 out: 1043 out:
1045 ocfs2_free_path(left_path); 1044 ocfs2_free_path(left_path);
1046 ocfs2_free_path(right_path); 1045 ocfs2_free_path(right_path);
1047 return ret; 1046 return ret;
1048 } 1047 }
1049 1048
1050 /* 1049 /*
1051 * Given a cpos and len, try to find the refc 1050 * Given a cpos and len, try to find the refcount record which contains cpos.
1052 * 1. If cpos can be found in one refcount re 1051 * 1. If cpos can be found in one refcount record, return the record.
1053 * 2. If cpos can't be found, return a fake r 1052 * 2. If cpos can't be found, return a fake record which start from cpos
1054 * and end at a small value between cpos+l 1053 * and end at a small value between cpos+len and start of the next record.
1055 * This fake record has r_refcount = 0. 1054 * This fake record has r_refcount = 0.
1056 */ 1055 */
1057 static int ocfs2_get_refcount_rec(struct ocfs 1056 static int ocfs2_get_refcount_rec(struct ocfs2_caching_info *ci,
1058 struct buff 1057 struct buffer_head *ref_root_bh,
1059 u64 cpos, u 1058 u64 cpos, unsigned int len,
1060 struct ocfs 1059 struct ocfs2_refcount_rec *ret_rec,
1061 int *index, 1060 int *index,
1062 struct buff 1061 struct buffer_head **ret_bh)
1063 { 1062 {
1064 int ret = 0, i, found; 1063 int ret = 0, i, found;
1065 u32 low_cpos, cpos_end; 1064 u32 low_cpos, cpos_end;
1066 struct ocfs2_extent_list *el; 1065 struct ocfs2_extent_list *el;
1067 struct ocfs2_extent_rec *rec = NULL; 1066 struct ocfs2_extent_rec *rec = NULL;
1068 struct ocfs2_extent_block *eb = NULL; 1067 struct ocfs2_extent_block *eb = NULL;
1069 struct buffer_head *eb_bh = NULL, *re 1068 struct buffer_head *eb_bh = NULL, *ref_leaf_bh = NULL;
1070 struct super_block *sb = ocfs2_metada 1069 struct super_block *sb = ocfs2_metadata_cache_get_super(ci);
1071 struct ocfs2_refcount_block *rb = 1070 struct ocfs2_refcount_block *rb =
1072 (struct ocfs2_refcoun 1071 (struct ocfs2_refcount_block *)ref_root_bh->b_data;
1073 1072
1074 if (!(le32_to_cpu(rb->rf_flags) & OCF 1073 if (!(le32_to_cpu(rb->rf_flags) & OCFS2_REFCOUNT_TREE_FL)) {
1075 ocfs2_find_refcount_rec_in_rl 1074 ocfs2_find_refcount_rec_in_rl(ci, ref_root_bh, cpos, len,
1076 1075 ret_rec, index);
1077 *ret_bh = ref_root_bh; 1076 *ret_bh = ref_root_bh;
1078 get_bh(ref_root_bh); 1077 get_bh(ref_root_bh);
1079 return 0; 1078 return 0;
1080 } 1079 }
1081 1080
1082 el = &rb->rf_list; 1081 el = &rb->rf_list;
1083 low_cpos = cpos & OCFS2_32BIT_POS_MAS 1082 low_cpos = cpos & OCFS2_32BIT_POS_MASK;
1084 1083
1085 if (el->l_tree_depth) { 1084 if (el->l_tree_depth) {
1086 ret = ocfs2_find_leaf(ci, el, 1085 ret = ocfs2_find_leaf(ci, el, low_cpos, &eb_bh);
1087 if (ret) { 1086 if (ret) {
1088 mlog_errno(ret); 1087 mlog_errno(ret);
1089 goto out; 1088 goto out;
1090 } 1089 }
1091 1090
1092 eb = (struct ocfs2_extent_blo 1091 eb = (struct ocfs2_extent_block *) eb_bh->b_data;
1093 el = &eb->h_list; 1092 el = &eb->h_list;
1094 1093
1095 if (el->l_tree_depth) { 1094 if (el->l_tree_depth) {
1096 ret = ocfs2_error(sb, 1095 ret = ocfs2_error(sb,
1097 "re 1096 "refcount tree %llu has non zero tree depth in leaf btree tree block %llu\n",
1098 (un 1097 (unsigned long long)ocfs2_metadata_cache_owner(ci),
1099 (un 1098 (unsigned long long)eb_bh->b_blocknr);
1100 goto out; 1099 goto out;
1101 } 1100 }
1102 } 1101 }
1103 1102
1104 found = 0; 1103 found = 0;
1105 for (i = le16_to_cpu(el->l_next_free_ 1104 for (i = le16_to_cpu(el->l_next_free_rec) - 1; i >= 0; i--) {
1106 rec = &el->l_recs[i]; 1105 rec = &el->l_recs[i];
1107 1106
1108 if (le32_to_cpu(rec->e_cpos) 1107 if (le32_to_cpu(rec->e_cpos) <= low_cpos) {
1109 found = 1; 1108 found = 1;
1110 break; 1109 break;
1111 } 1110 }
1112 } 1111 }
1113 1112
1114 if (found) { 1113 if (found) {
1115 ret = ocfs2_get_refcount_cpos 1114 ret = ocfs2_get_refcount_cpos_end(ci, ref_root_bh,
1116 1115 eb, el, i, &cpos_end);
1117 if (ret) { 1116 if (ret) {
1118 mlog_errno(ret); 1117 mlog_errno(ret);
1119 goto out; 1118 goto out;
1120 } 1119 }
1121 1120
1122 if (cpos_end < low_cpos + len 1121 if (cpos_end < low_cpos + len)
1123 len = cpos_end - low_ 1122 len = cpos_end - low_cpos;
1124 } 1123 }
1125 1124
1126 ret = ocfs2_read_refcount_block(ci, l 1125 ret = ocfs2_read_refcount_block(ci, le64_to_cpu(rec->e_blkno),
1127 &ref_ 1126 &ref_leaf_bh);
1128 if (ret) { 1127 if (ret) {
1129 mlog_errno(ret); 1128 mlog_errno(ret);
1130 goto out; 1129 goto out;
1131 } 1130 }
1132 1131
1133 ocfs2_find_refcount_rec_in_rl(ci, ref 1132 ocfs2_find_refcount_rec_in_rl(ci, ref_leaf_bh, cpos, len,
1134 ret_rec 1133 ret_rec, index);
1135 *ret_bh = ref_leaf_bh; 1134 *ret_bh = ref_leaf_bh;
1136 out: 1135 out:
1137 brelse(eb_bh); 1136 brelse(eb_bh);
1138 return ret; 1137 return ret;
1139 } 1138 }
1140 1139
1141 enum ocfs2_ref_rec_contig { 1140 enum ocfs2_ref_rec_contig {
1142 REF_CONTIG_NONE = 0, 1141 REF_CONTIG_NONE = 0,
1143 REF_CONTIG_LEFT, 1142 REF_CONTIG_LEFT,
1144 REF_CONTIG_RIGHT, 1143 REF_CONTIG_RIGHT,
1145 REF_CONTIG_LEFTRIGHT, 1144 REF_CONTIG_LEFTRIGHT,
1146 }; 1145 };
1147 1146
1148 static enum ocfs2_ref_rec_contig 1147 static enum ocfs2_ref_rec_contig
1149 ocfs2_refcount_rec_adjacent(struct oc 1148 ocfs2_refcount_rec_adjacent(struct ocfs2_refcount_block *rb,
1150 int index 1149 int index)
1151 { 1150 {
1152 if ((rb->rf_records.rl_recs[index].r_ 1151 if ((rb->rf_records.rl_recs[index].r_refcount ==
1153 rb->rf_records.rl_recs[index + 1] 1152 rb->rf_records.rl_recs[index + 1].r_refcount) &&
1154 (le64_to_cpu(rb->rf_records.rl_re 1153 (le64_to_cpu(rb->rf_records.rl_recs[index].r_cpos) +
1155 le32_to_cpu(rb->rf_records.rl_rec 1154 le32_to_cpu(rb->rf_records.rl_recs[index].r_clusters) ==
1156 le64_to_cpu(rb->rf_records.rl_rec 1155 le64_to_cpu(rb->rf_records.rl_recs[index + 1].r_cpos)))
1157 return REF_CONTIG_RIGHT; 1156 return REF_CONTIG_RIGHT;
1158 1157
1159 return REF_CONTIG_NONE; 1158 return REF_CONTIG_NONE;
1160 } 1159 }
1161 1160
1162 static enum ocfs2_ref_rec_contig 1161 static enum ocfs2_ref_rec_contig
1163 ocfs2_refcount_rec_contig(struct ocfs 1162 ocfs2_refcount_rec_contig(struct ocfs2_refcount_block *rb,
1164 int index) 1163 int index)
1165 { 1164 {
1166 enum ocfs2_ref_rec_contig ret = REF_C 1165 enum ocfs2_ref_rec_contig ret = REF_CONTIG_NONE;
1167 1166
1168 if (index < le16_to_cpu(rb->rf_record 1167 if (index < le16_to_cpu(rb->rf_records.rl_used) - 1)
1169 ret = ocfs2_refcount_rec_adja 1168 ret = ocfs2_refcount_rec_adjacent(rb, index);
1170 1169
1171 if (index > 0) { 1170 if (index > 0) {
1172 enum ocfs2_ref_rec_contig tmp 1171 enum ocfs2_ref_rec_contig tmp;
1173 1172
1174 tmp = ocfs2_refcount_rec_adja 1173 tmp = ocfs2_refcount_rec_adjacent(rb, index - 1);
1175 1174
1176 if (tmp == REF_CONTIG_RIGHT) 1175 if (tmp == REF_CONTIG_RIGHT) {
1177 if (ret == REF_CONTIG 1176 if (ret == REF_CONTIG_RIGHT)
1178 ret = REF_CON 1177 ret = REF_CONTIG_LEFTRIGHT;
1179 else 1178 else
1180 ret = REF_CON 1179 ret = REF_CONTIG_LEFT;
1181 } 1180 }
1182 } 1181 }
1183 1182
1184 return ret; 1183 return ret;
1185 } 1184 }
1186 1185
1187 static void ocfs2_rotate_refcount_rec_left(st 1186 static void ocfs2_rotate_refcount_rec_left(struct ocfs2_refcount_block *rb,
1188 in 1187 int index)
1189 { 1188 {
1190 BUG_ON(rb->rf_records.rl_recs[index]. 1189 BUG_ON(rb->rf_records.rl_recs[index].r_refcount !=
1191 rb->rf_records.rl_recs[index+1 1190 rb->rf_records.rl_recs[index+1].r_refcount);
1192 1191
1193 le32_add_cpu(&rb->rf_records.rl_recs[ 1192 le32_add_cpu(&rb->rf_records.rl_recs[index].r_clusters,
1194 le32_to_cpu(rb->rf_recor 1193 le32_to_cpu(rb->rf_records.rl_recs[index+1].r_clusters));
1195 1194
1196 if (index < le16_to_cpu(rb->rf_record 1195 if (index < le16_to_cpu(rb->rf_records.rl_used) - 2)
1197 memmove(&rb->rf_records.rl_re 1196 memmove(&rb->rf_records.rl_recs[index + 1],
1198 &rb->rf_records.rl_re 1197 &rb->rf_records.rl_recs[index + 2],
1199 sizeof(struct ocfs2_r 1198 sizeof(struct ocfs2_refcount_rec) *
1200 (le16_to_cpu(rb->rf_r 1199 (le16_to_cpu(rb->rf_records.rl_used) - index - 2));
1201 1200
1202 memset(&rb->rf_records.rl_recs[le16_t 1201 memset(&rb->rf_records.rl_recs[le16_to_cpu(rb->rf_records.rl_used) - 1],
1203 0, sizeof(struct ocfs2_refcoun 1202 0, sizeof(struct ocfs2_refcount_rec));
1204 le16_add_cpu(&rb->rf_records.rl_used, 1203 le16_add_cpu(&rb->rf_records.rl_used, -1);
1205 } 1204 }
1206 1205
1207 /* 1206 /*
1208 * Merge the refcount rec if we are contiguou 1207 * Merge the refcount rec if we are contiguous with the adjacent recs.
1209 */ 1208 */
1210 static void ocfs2_refcount_rec_merge(struct o 1209 static void ocfs2_refcount_rec_merge(struct ocfs2_refcount_block *rb,
1211 int inde 1210 int index)
1212 { 1211 {
1213 enum ocfs2_ref_rec_contig contig = 1212 enum ocfs2_ref_rec_contig contig =
1214 ocfs2_refcoun 1213 ocfs2_refcount_rec_contig(rb, index);
1215 1214
1216 if (contig == REF_CONTIG_NONE) 1215 if (contig == REF_CONTIG_NONE)
1217 return; 1216 return;
1218 1217
1219 if (contig == REF_CONTIG_LEFT || cont 1218 if (contig == REF_CONTIG_LEFT || contig == REF_CONTIG_LEFTRIGHT) {
1220 BUG_ON(index == 0); 1219 BUG_ON(index == 0);
1221 index--; 1220 index--;
1222 } 1221 }
1223 1222
1224 ocfs2_rotate_refcount_rec_left(rb, in 1223 ocfs2_rotate_refcount_rec_left(rb, index);
1225 1224
1226 if (contig == REF_CONTIG_LEFTRIGHT) 1225 if (contig == REF_CONTIG_LEFTRIGHT)
1227 ocfs2_rotate_refcount_rec_lef 1226 ocfs2_rotate_refcount_rec_left(rb, index);
1228 } 1227 }
1229 1228
1230 /* 1229 /*
1231 * Change the refcount indexed by "index" in 1230 * Change the refcount indexed by "index" in ref_bh.
1232 * If refcount reaches 0, remove it. 1231 * If refcount reaches 0, remove it.
1233 */ 1232 */
1234 static int ocfs2_change_refcount_rec(handle_t 1233 static int ocfs2_change_refcount_rec(handle_t *handle,
1235 struct o 1234 struct ocfs2_caching_info *ci,
1236 struct b 1235 struct buffer_head *ref_leaf_bh,
1237 int inde 1236 int index, int merge, int change)
1238 { 1237 {
1239 int ret; 1238 int ret;
1240 struct ocfs2_refcount_block *rb = 1239 struct ocfs2_refcount_block *rb =
1241 (struct ocfs2_refcoun 1240 (struct ocfs2_refcount_block *)ref_leaf_bh->b_data;
1242 struct ocfs2_refcount_list *rl = &rb- 1241 struct ocfs2_refcount_list *rl = &rb->rf_records;
1243 struct ocfs2_refcount_rec *rec = &rl- 1242 struct ocfs2_refcount_rec *rec = &rl->rl_recs[index];
1244 1243
1245 ret = ocfs2_journal_access_rb(handle, 1244 ret = ocfs2_journal_access_rb(handle, ci, ref_leaf_bh,
1246 OCFS2_J 1245 OCFS2_JOURNAL_ACCESS_WRITE);
1247 if (ret) { 1246 if (ret) {
1248 mlog_errno(ret); 1247 mlog_errno(ret);
1249 goto out; 1248 goto out;
1250 } 1249 }
1251 1250
1252 trace_ocfs2_change_refcount_rec( 1251 trace_ocfs2_change_refcount_rec(
1253 (unsigned long long)ocfs2_met 1252 (unsigned long long)ocfs2_metadata_cache_owner(ci),
1254 index, le32_to_cpu(rec->r_ref 1253 index, le32_to_cpu(rec->r_refcount), change);
1255 le32_add_cpu(&rec->r_refcount, change 1254 le32_add_cpu(&rec->r_refcount, change);
1256 1255
1257 if (!rec->r_refcount) { 1256 if (!rec->r_refcount) {
1258 if (index != le16_to_cpu(rl-> 1257 if (index != le16_to_cpu(rl->rl_used) - 1) {
1259 memmove(rec, rec + 1, 1258 memmove(rec, rec + 1,
1260 (le16_to_cpu( 1259 (le16_to_cpu(rl->rl_used) - index - 1) *
1261 sizeof(struct 1260 sizeof(struct ocfs2_refcount_rec));
1262 memset(&rl->rl_recs[l 1261 memset(&rl->rl_recs[le16_to_cpu(rl->rl_used) - 1],
1263 0, sizeof(stru 1262 0, sizeof(struct ocfs2_refcount_rec));
1264 } 1263 }
1265 1264
1266 le16_add_cpu(&rl->rl_used, -1 1265 le16_add_cpu(&rl->rl_used, -1);
1267 } else if (merge) 1266 } else if (merge)
1268 ocfs2_refcount_rec_merge(rb, 1267 ocfs2_refcount_rec_merge(rb, index);
1269 1268
1270 ocfs2_journal_dirty(handle, ref_leaf_ 1269 ocfs2_journal_dirty(handle, ref_leaf_bh);
1271 out: 1270 out:
1272 return ret; 1271 return ret;
1273 } 1272 }
1274 1273
1275 static int ocfs2_expand_inline_ref_root(handl 1274 static int ocfs2_expand_inline_ref_root(handle_t *handle,
1276 struc 1275 struct ocfs2_caching_info *ci,
1277 struc 1276 struct buffer_head *ref_root_bh,
1278 struc 1277 struct buffer_head **ref_leaf_bh,
1279 struc 1278 struct ocfs2_alloc_context *meta_ac)
1280 { 1279 {
1281 int ret; 1280 int ret;
1282 u16 suballoc_bit_start; 1281 u16 suballoc_bit_start;
1283 u32 num_got; 1282 u32 num_got;
1284 u64 suballoc_loc, blkno; 1283 u64 suballoc_loc, blkno;
1285 struct super_block *sb = ocfs2_metada 1284 struct super_block *sb = ocfs2_metadata_cache_get_super(ci);
1286 struct buffer_head *new_bh = NULL; 1285 struct buffer_head *new_bh = NULL;
1287 struct ocfs2_refcount_block *new_rb; 1286 struct ocfs2_refcount_block *new_rb;
1288 struct ocfs2_refcount_block *root_rb 1287 struct ocfs2_refcount_block *root_rb =
1289 (struct ocfs2_refcoun 1288 (struct ocfs2_refcount_block *)ref_root_bh->b_data;
1290 1289
1291 ret = ocfs2_journal_access_rb(handle, 1290 ret = ocfs2_journal_access_rb(handle, ci, ref_root_bh,
1292 OCFS2_J 1291 OCFS2_JOURNAL_ACCESS_WRITE);
1293 if (ret) { 1292 if (ret) {
1294 mlog_errno(ret); 1293 mlog_errno(ret);
1295 goto out; 1294 goto out;
1296 } 1295 }
1297 1296
1298 ret = ocfs2_claim_metadata(handle, me 1297 ret = ocfs2_claim_metadata(handle, meta_ac, 1, &suballoc_loc,
1299 &suballoc_ 1298 &suballoc_bit_start, &num_got,
1300 &blkno); 1299 &blkno);
1301 if (ret) { 1300 if (ret) {
1302 mlog_errno(ret); 1301 mlog_errno(ret);
1303 goto out; 1302 goto out;
1304 } 1303 }
1305 1304
1306 new_bh = sb_getblk(sb, blkno); 1305 new_bh = sb_getblk(sb, blkno);
1307 if (new_bh == NULL) { 1306 if (new_bh == NULL) {
1308 ret = -ENOMEM; 1307 ret = -ENOMEM;
1309 mlog_errno(ret); 1308 mlog_errno(ret);
1310 goto out; 1309 goto out;
1311 } 1310 }
1312 ocfs2_set_new_buffer_uptodate(ci, new 1311 ocfs2_set_new_buffer_uptodate(ci, new_bh);
1313 1312
1314 ret = ocfs2_journal_access_rb(handle, 1313 ret = ocfs2_journal_access_rb(handle, ci, new_bh,
1315 OCFS2_J 1314 OCFS2_JOURNAL_ACCESS_CREATE);
1316 if (ret) { 1315 if (ret) {
1317 mlog_errno(ret); 1316 mlog_errno(ret);
1318 goto out; 1317 goto out;
1319 } 1318 }
1320 1319
1321 /* 1320 /*
1322 * Initialize ocfs2_refcount_block. 1321 * Initialize ocfs2_refcount_block.
1323 * It should contain the same informa 1322 * It should contain the same information as the old root.
1324 * so just memcpy it and change the c 1323 * so just memcpy it and change the corresponding field.
1325 */ 1324 */
1326 memcpy(new_bh->b_data, ref_root_bh->b 1325 memcpy(new_bh->b_data, ref_root_bh->b_data, sb->s_blocksize);
1327 1326
1328 new_rb = (struct ocfs2_refcount_block 1327 new_rb = (struct ocfs2_refcount_block *)new_bh->b_data;
1329 new_rb->rf_suballoc_slot = cpu_to_le1 1328 new_rb->rf_suballoc_slot = cpu_to_le16(meta_ac->ac_alloc_slot);
1330 new_rb->rf_suballoc_loc = cpu_to_le64 1329 new_rb->rf_suballoc_loc = cpu_to_le64(suballoc_loc);
1331 new_rb->rf_suballoc_bit = cpu_to_le16 1330 new_rb->rf_suballoc_bit = cpu_to_le16(suballoc_bit_start);
1332 new_rb->rf_blkno = cpu_to_le64(blkno) 1331 new_rb->rf_blkno = cpu_to_le64(blkno);
1333 new_rb->rf_cpos = cpu_to_le32(0); 1332 new_rb->rf_cpos = cpu_to_le32(0);
1334 new_rb->rf_parent = cpu_to_le64(ref_r 1333 new_rb->rf_parent = cpu_to_le64(ref_root_bh->b_blocknr);
1335 new_rb->rf_flags = cpu_to_le32(OCFS2_ 1334 new_rb->rf_flags = cpu_to_le32(OCFS2_REFCOUNT_LEAF_FL);
1336 ocfs2_journal_dirty(handle, new_bh); 1335 ocfs2_journal_dirty(handle, new_bh);
1337 1336
1338 /* Now change the root. */ 1337 /* Now change the root. */
1339 memset(&root_rb->rf_list, 0, sb->s_bl 1338 memset(&root_rb->rf_list, 0, sb->s_blocksize -
1340 offsetof(struct ocfs2_refcount 1339 offsetof(struct ocfs2_refcount_block, rf_list));
1341 root_rb->rf_list.l_count = cpu_to_le1 1340 root_rb->rf_list.l_count = cpu_to_le16(ocfs2_extent_recs_per_rb(sb));
1342 root_rb->rf_clusters = cpu_to_le32(1) 1341 root_rb->rf_clusters = cpu_to_le32(1);
1343 root_rb->rf_list.l_next_free_rec = cp 1342 root_rb->rf_list.l_next_free_rec = cpu_to_le16(1);
1344 root_rb->rf_list.l_recs[0].e_blkno = 1343 root_rb->rf_list.l_recs[0].e_blkno = cpu_to_le64(blkno);
1345 root_rb->rf_list.l_recs[0].e_leaf_clu 1344 root_rb->rf_list.l_recs[0].e_leaf_clusters = cpu_to_le16(1);
1346 root_rb->rf_flags = cpu_to_le32(OCFS2 1345 root_rb->rf_flags = cpu_to_le32(OCFS2_REFCOUNT_TREE_FL);
1347 1346
1348 ocfs2_journal_dirty(handle, ref_root_ 1347 ocfs2_journal_dirty(handle, ref_root_bh);
1349 1348
1350 trace_ocfs2_expand_inline_ref_root((u 1349 trace_ocfs2_expand_inline_ref_root((unsigned long long)blkno,
1351 le16_to_cpu(new_rb->rf_record 1350 le16_to_cpu(new_rb->rf_records.rl_used));
1352 1351
1353 *ref_leaf_bh = new_bh; 1352 *ref_leaf_bh = new_bh;
1354 new_bh = NULL; 1353 new_bh = NULL;
1355 out: 1354 out:
1356 brelse(new_bh); 1355 brelse(new_bh);
1357 return ret; 1356 return ret;
1358 } 1357 }
1359 1358
1360 static int ocfs2_refcount_rec_no_intersect(st 1359 static int ocfs2_refcount_rec_no_intersect(struct ocfs2_refcount_rec *prev,
1361 st 1360 struct ocfs2_refcount_rec *next)
1362 { 1361 {
1363 if (ocfs2_get_ref_rec_low_cpos(prev) 1362 if (ocfs2_get_ref_rec_low_cpos(prev) + le32_to_cpu(prev->r_clusters) <=
1364 ocfs2_get_ref_rec_low_cpos(ne 1363 ocfs2_get_ref_rec_low_cpos(next))
1365 return 1; 1364 return 1;
1366 1365
1367 return 0; 1366 return 0;
1368 } 1367 }
1369 1368
1370 static int cmp_refcount_rec_by_low_cpos(const 1369 static int cmp_refcount_rec_by_low_cpos(const void *a, const void *b)
1371 { 1370 {
1372 const struct ocfs2_refcount_rec *l = 1371 const struct ocfs2_refcount_rec *l = a, *r = b;
1373 u32 l_cpos = ocfs2_get_ref_rec_low_cp 1372 u32 l_cpos = ocfs2_get_ref_rec_low_cpos(l);
1374 u32 r_cpos = ocfs2_get_ref_rec_low_cp 1373 u32 r_cpos = ocfs2_get_ref_rec_low_cpos(r);
1375 1374
1376 if (l_cpos > r_cpos) 1375 if (l_cpos > r_cpos)
1377 return 1; 1376 return 1;
1378 if (l_cpos < r_cpos) 1377 if (l_cpos < r_cpos)
1379 return -1; 1378 return -1;
1380 return 0; 1379 return 0;
1381 } 1380 }
1382 1381
1383 static int cmp_refcount_rec_by_cpos(const voi 1382 static int cmp_refcount_rec_by_cpos(const void *a, const void *b)
1384 { 1383 {
1385 const struct ocfs2_refcount_rec *l = 1384 const struct ocfs2_refcount_rec *l = a, *r = b;
1386 u64 l_cpos = le64_to_cpu(l->r_cpos); 1385 u64 l_cpos = le64_to_cpu(l->r_cpos);
1387 u64 r_cpos = le64_to_cpu(r->r_cpos); 1386 u64 r_cpos = le64_to_cpu(r->r_cpos);
1388 1387
1389 if (l_cpos > r_cpos) 1388 if (l_cpos > r_cpos)
1390 return 1; 1389 return 1;
1391 if (l_cpos < r_cpos) 1390 if (l_cpos < r_cpos)
1392 return -1; 1391 return -1;
1393 return 0; 1392 return 0;
1394 } 1393 }
1395 1394
>> 1395 static void swap_refcount_rec(void *a, void *b, int size)
>> 1396 {
>> 1397 struct ocfs2_refcount_rec *l = a, *r = b;
>> 1398
>> 1399 swap(*l, *r);
>> 1400 }
>> 1401
1396 /* 1402 /*
1397 * The refcount cpos are ordered by their 64b 1403 * The refcount cpos are ordered by their 64bit cpos,
1398 * But we will use the low 32 bit to be the e 1404 * But we will use the low 32 bit to be the e_cpos in the b-tree.
1399 * So we need to make sure that this pos isn' 1405 * So we need to make sure that this pos isn't intersected with others.
1400 * 1406 *
1401 * Note: The refcount block is already sorted 1407 * Note: The refcount block is already sorted by their low 32 bit cpos,
1402 * So just try the middle pos first, an 1408 * So just try the middle pos first, and we will exit when we find
1403 * the good position. 1409 * the good position.
1404 */ 1410 */
1405 static int ocfs2_find_refcount_split_pos(stru 1411 static int ocfs2_find_refcount_split_pos(struct ocfs2_refcount_list *rl,
1406 u32 1412 u32 *split_pos, int *split_index)
1407 { 1413 {
1408 int num_used = le16_to_cpu(rl->rl_use 1414 int num_used = le16_to_cpu(rl->rl_used);
1409 int delta, middle = num_used / 2; 1415 int delta, middle = num_used / 2;
1410 1416
1411 for (delta = 0; delta < middle; delta 1417 for (delta = 0; delta < middle; delta++) {
1412 /* Let's check delta earlier 1418 /* Let's check delta earlier than middle */
1413 if (ocfs2_refcount_rec_no_int 1419 if (ocfs2_refcount_rec_no_intersect(
1414 &rl-> 1420 &rl->rl_recs[middle - delta - 1],
1415 &rl-> 1421 &rl->rl_recs[middle - delta])) {
1416 *split_index = middle 1422 *split_index = middle - delta;
1417 break; 1423 break;
1418 } 1424 }
1419 1425
1420 /* For even counts, don't wal 1426 /* For even counts, don't walk off the end */
1421 if ((middle + delta + 1) == n 1427 if ((middle + delta + 1) == num_used)
1422 continue; 1428 continue;
1423 1429
1424 /* Now try delta past middle 1430 /* Now try delta past middle */
1425 if (ocfs2_refcount_rec_no_int 1431 if (ocfs2_refcount_rec_no_intersect(
1426 &rl-> 1432 &rl->rl_recs[middle + delta],
1427 &rl-> 1433 &rl->rl_recs[middle + delta + 1])) {
1428 *split_index = middle 1434 *split_index = middle + delta + 1;
1429 break; 1435 break;
1430 } 1436 }
1431 } 1437 }
1432 1438
1433 if (delta >= middle) 1439 if (delta >= middle)
1434 return -ENOSPC; 1440 return -ENOSPC;
1435 1441
1436 *split_pos = ocfs2_get_ref_rec_low_cp 1442 *split_pos = ocfs2_get_ref_rec_low_cpos(&rl->rl_recs[*split_index]);
1437 return 0; 1443 return 0;
1438 } 1444 }
1439 1445
1440 static int ocfs2_divide_leaf_refcount_block(s 1446 static int ocfs2_divide_leaf_refcount_block(struct buffer_head *ref_leaf_bh,
1441 s 1447 struct buffer_head *new_bh,
1442 u 1448 u32 *split_cpos)
1443 { 1449 {
1444 int split_index = 0, num_moved, ret; 1450 int split_index = 0, num_moved, ret;
1445 u32 cpos = 0; 1451 u32 cpos = 0;
1446 struct ocfs2_refcount_block *rb = 1452 struct ocfs2_refcount_block *rb =
1447 (struct ocfs2_refcoun 1453 (struct ocfs2_refcount_block *)ref_leaf_bh->b_data;
1448 struct ocfs2_refcount_list *rl = &rb- 1454 struct ocfs2_refcount_list *rl = &rb->rf_records;
1449 struct ocfs2_refcount_block *new_rb = 1455 struct ocfs2_refcount_block *new_rb =
1450 (struct ocfs2_refcoun 1456 (struct ocfs2_refcount_block *)new_bh->b_data;
1451 struct ocfs2_refcount_list *new_rl = 1457 struct ocfs2_refcount_list *new_rl = &new_rb->rf_records;
1452 1458
1453 trace_ocfs2_divide_leaf_refcount_bloc 1459 trace_ocfs2_divide_leaf_refcount_block(
1454 (unsigned long long)ref_leaf_ 1460 (unsigned long long)ref_leaf_bh->b_blocknr,
1455 le16_to_cpu(rl->rl_count), le 1461 le16_to_cpu(rl->rl_count), le16_to_cpu(rl->rl_used));
1456 1462
1457 /* 1463 /*
1458 * XXX: Improvement later. 1464 * XXX: Improvement later.
1459 * If we know all the high 32 bit cpo 1465 * If we know all the high 32 bit cpos is the same, no need to sort.
1460 * 1466 *
1461 * In order to make the whole process 1467 * In order to make the whole process safe, we do:
1462 * 1. sort the entries by their low 3 1468 * 1. sort the entries by their low 32 bit cpos first so that we can
1463 * find the split cpos easily. 1469 * find the split cpos easily.
1464 * 2. call ocfs2_insert_extent to ins 1470 * 2. call ocfs2_insert_extent to insert the new refcount block.
1465 * 3. move the refcount rec to the ne 1471 * 3. move the refcount rec to the new block.
1466 * 4. sort the entries by their 64 bi 1472 * 4. sort the entries by their 64 bit cpos.
1467 * 5. dirty the new_rb and rb. 1473 * 5. dirty the new_rb and rb.
1468 */ 1474 */
1469 sort(&rl->rl_recs, le16_to_cpu(rl->rl 1475 sort(&rl->rl_recs, le16_to_cpu(rl->rl_used),
1470 sizeof(struct ocfs2_refcount_rec 1476 sizeof(struct ocfs2_refcount_rec),
1471 cmp_refcount_rec_by_low_cpos, NU !! 1477 cmp_refcount_rec_by_low_cpos, swap_refcount_rec);
1472 1478
1473 ret = ocfs2_find_refcount_split_pos(r 1479 ret = ocfs2_find_refcount_split_pos(rl, &cpos, &split_index);
1474 if (ret) { 1480 if (ret) {
1475 mlog_errno(ret); 1481 mlog_errno(ret);
1476 return ret; 1482 return ret;
1477 } 1483 }
1478 1484
1479 new_rb->rf_cpos = cpu_to_le32(cpos); 1485 new_rb->rf_cpos = cpu_to_le32(cpos);
1480 1486
1481 /* move refcount records starting fro 1487 /* move refcount records starting from split_index to the new block. */
1482 num_moved = le16_to_cpu(rl->rl_used) 1488 num_moved = le16_to_cpu(rl->rl_used) - split_index;
1483 memcpy(new_rl->rl_recs, &rl->rl_recs[ 1489 memcpy(new_rl->rl_recs, &rl->rl_recs[split_index],
1484 num_moved * sizeof(struct ocfs 1490 num_moved * sizeof(struct ocfs2_refcount_rec));
1485 1491
1486 /*ok, remove the entries we just move 1492 /*ok, remove the entries we just moved over to the other block. */
1487 memset(&rl->rl_recs[split_index], 0, 1493 memset(&rl->rl_recs[split_index], 0,
1488 num_moved * sizeof(struct ocfs 1494 num_moved * sizeof(struct ocfs2_refcount_rec));
1489 1495
1490 /* change old and new rl_used accordi 1496 /* change old and new rl_used accordingly. */
1491 le16_add_cpu(&rl->rl_used, -num_moved 1497 le16_add_cpu(&rl->rl_used, -num_moved);
1492 new_rl->rl_used = cpu_to_le16(num_mov 1498 new_rl->rl_used = cpu_to_le16(num_moved);
1493 1499
1494 sort(&rl->rl_recs, le16_to_cpu(rl->rl 1500 sort(&rl->rl_recs, le16_to_cpu(rl->rl_used),
1495 sizeof(struct ocfs2_refcount_rec 1501 sizeof(struct ocfs2_refcount_rec),
1496 cmp_refcount_rec_by_cpos, NULL); !! 1502 cmp_refcount_rec_by_cpos, swap_refcount_rec);
1497 1503
1498 sort(&new_rl->rl_recs, le16_to_cpu(ne 1504 sort(&new_rl->rl_recs, le16_to_cpu(new_rl->rl_used),
1499 sizeof(struct ocfs2_refcount_rec 1505 sizeof(struct ocfs2_refcount_rec),
1500 cmp_refcount_rec_by_cpos, NULL); !! 1506 cmp_refcount_rec_by_cpos, swap_refcount_rec);
1501 1507
1502 *split_cpos = cpos; 1508 *split_cpos = cpos;
1503 return 0; 1509 return 0;
1504 } 1510 }
1505 1511
1506 static int ocfs2_new_leaf_refcount_block(hand 1512 static int ocfs2_new_leaf_refcount_block(handle_t *handle,
1507 stru 1513 struct ocfs2_caching_info *ci,
1508 stru 1514 struct buffer_head *ref_root_bh,
1509 stru 1515 struct buffer_head *ref_leaf_bh,
1510 stru 1516 struct ocfs2_alloc_context *meta_ac)
1511 { 1517 {
1512 int ret; 1518 int ret;
1513 u16 suballoc_bit_start; 1519 u16 suballoc_bit_start;
1514 u32 num_got, new_cpos; 1520 u32 num_got, new_cpos;
1515 u64 suballoc_loc, blkno; 1521 u64 suballoc_loc, blkno;
1516 struct super_block *sb = ocfs2_metada 1522 struct super_block *sb = ocfs2_metadata_cache_get_super(ci);
1517 struct ocfs2_refcount_block *root_rb 1523 struct ocfs2_refcount_block *root_rb =
1518 (struct ocfs2_refcoun 1524 (struct ocfs2_refcount_block *)ref_root_bh->b_data;
1519 struct buffer_head *new_bh = NULL; 1525 struct buffer_head *new_bh = NULL;
1520 struct ocfs2_refcount_block *new_rb; 1526 struct ocfs2_refcount_block *new_rb;
1521 struct ocfs2_extent_tree ref_et; 1527 struct ocfs2_extent_tree ref_et;
1522 1528
1523 BUG_ON(!(le32_to_cpu(root_rb->rf_flag 1529 BUG_ON(!(le32_to_cpu(root_rb->rf_flags) & OCFS2_REFCOUNT_TREE_FL));
1524 1530
1525 ret = ocfs2_journal_access_rb(handle, 1531 ret = ocfs2_journal_access_rb(handle, ci, ref_root_bh,
1526 OCFS2_J 1532 OCFS2_JOURNAL_ACCESS_WRITE);
1527 if (ret) { 1533 if (ret) {
1528 mlog_errno(ret); 1534 mlog_errno(ret);
1529 goto out; 1535 goto out;
1530 } 1536 }
1531 1537
1532 ret = ocfs2_journal_access_rb(handle, 1538 ret = ocfs2_journal_access_rb(handle, ci, ref_leaf_bh,
1533 OCFS2_J 1539 OCFS2_JOURNAL_ACCESS_WRITE);
1534 if (ret) { 1540 if (ret) {
1535 mlog_errno(ret); 1541 mlog_errno(ret);
1536 goto out; 1542 goto out;
1537 } 1543 }
1538 1544
1539 ret = ocfs2_claim_metadata(handle, me 1545 ret = ocfs2_claim_metadata(handle, meta_ac, 1, &suballoc_loc,
1540 &suballoc_ 1546 &suballoc_bit_start, &num_got,
1541 &blkno); 1547 &blkno);
1542 if (ret) { 1548 if (ret) {
1543 mlog_errno(ret); 1549 mlog_errno(ret);
1544 goto out; 1550 goto out;
1545 } 1551 }
1546 1552
1547 new_bh = sb_getblk(sb, blkno); 1553 new_bh = sb_getblk(sb, blkno);
1548 if (new_bh == NULL) { 1554 if (new_bh == NULL) {
1549 ret = -ENOMEM; 1555 ret = -ENOMEM;
1550 mlog_errno(ret); 1556 mlog_errno(ret);
1551 goto out; 1557 goto out;
1552 } 1558 }
1553 ocfs2_set_new_buffer_uptodate(ci, new 1559 ocfs2_set_new_buffer_uptodate(ci, new_bh);
1554 1560
1555 ret = ocfs2_journal_access_rb(handle, 1561 ret = ocfs2_journal_access_rb(handle, ci, new_bh,
1556 OCFS2_J 1562 OCFS2_JOURNAL_ACCESS_CREATE);
1557 if (ret) { 1563 if (ret) {
1558 mlog_errno(ret); 1564 mlog_errno(ret);
1559 goto out; 1565 goto out;
1560 } 1566 }
1561 1567
1562 /* Initialize ocfs2_refcount_block. * 1568 /* Initialize ocfs2_refcount_block. */
1563 new_rb = (struct ocfs2_refcount_block 1569 new_rb = (struct ocfs2_refcount_block *)new_bh->b_data;
1564 memset(new_rb, 0, sb->s_blocksize); 1570 memset(new_rb, 0, sb->s_blocksize);
1565 strcpy((void *)new_rb, OCFS2_REFCOUNT 1571 strcpy((void *)new_rb, OCFS2_REFCOUNT_BLOCK_SIGNATURE);
1566 new_rb->rf_suballoc_slot = cpu_to_le1 1572 new_rb->rf_suballoc_slot = cpu_to_le16(meta_ac->ac_alloc_slot);
1567 new_rb->rf_suballoc_loc = cpu_to_le64 1573 new_rb->rf_suballoc_loc = cpu_to_le64(suballoc_loc);
1568 new_rb->rf_suballoc_bit = cpu_to_le16 1574 new_rb->rf_suballoc_bit = cpu_to_le16(suballoc_bit_start);
1569 new_rb->rf_fs_generation = cpu_to_le3 1575 new_rb->rf_fs_generation = cpu_to_le32(OCFS2_SB(sb)->fs_generation);
1570 new_rb->rf_blkno = cpu_to_le64(blkno) 1576 new_rb->rf_blkno = cpu_to_le64(blkno);
1571 new_rb->rf_parent = cpu_to_le64(ref_r 1577 new_rb->rf_parent = cpu_to_le64(ref_root_bh->b_blocknr);
1572 new_rb->rf_flags = cpu_to_le32(OCFS2_ 1578 new_rb->rf_flags = cpu_to_le32(OCFS2_REFCOUNT_LEAF_FL);
1573 new_rb->rf_records.rl_count = 1579 new_rb->rf_records.rl_count =
1574 cpu_to_le16(o 1580 cpu_to_le16(ocfs2_refcount_recs_per_rb(sb));
1575 new_rb->rf_generation = root_rb->rf_g 1581 new_rb->rf_generation = root_rb->rf_generation;
1576 1582
1577 ret = ocfs2_divide_leaf_refcount_bloc 1583 ret = ocfs2_divide_leaf_refcount_block(ref_leaf_bh, new_bh, &new_cpos);
1578 if (ret) { 1584 if (ret) {
1579 mlog_errno(ret); 1585 mlog_errno(ret);
1580 goto out; 1586 goto out;
1581 } 1587 }
1582 1588
1583 ocfs2_journal_dirty(handle, ref_leaf_ 1589 ocfs2_journal_dirty(handle, ref_leaf_bh);
1584 ocfs2_journal_dirty(handle, new_bh); 1590 ocfs2_journal_dirty(handle, new_bh);
1585 1591
1586 ocfs2_init_refcount_extent_tree(&ref_ 1592 ocfs2_init_refcount_extent_tree(&ref_et, ci, ref_root_bh);
1587 1593
1588 trace_ocfs2_new_leaf_refcount_block( 1594 trace_ocfs2_new_leaf_refcount_block(
1589 (unsigned long long)n 1595 (unsigned long long)new_bh->b_blocknr, new_cpos);
1590 1596
1591 /* Insert the new leaf block with the 1597 /* Insert the new leaf block with the specific offset cpos. */
1592 ret = ocfs2_insert_extent(handle, &re 1598 ret = ocfs2_insert_extent(handle, &ref_et, new_cpos, new_bh->b_blocknr,
1593 1, 0, meta_ 1599 1, 0, meta_ac);
1594 if (ret) 1600 if (ret)
1595 mlog_errno(ret); 1601 mlog_errno(ret);
1596 1602
1597 out: 1603 out:
1598 brelse(new_bh); 1604 brelse(new_bh);
1599 return ret; 1605 return ret;
1600 } 1606 }
1601 1607
1602 static int ocfs2_expand_refcount_tree(handle_ 1608 static int ocfs2_expand_refcount_tree(handle_t *handle,
1603 struct 1609 struct ocfs2_caching_info *ci,
1604 struct 1610 struct buffer_head *ref_root_bh,
1605 struct 1611 struct buffer_head *ref_leaf_bh,
1606 struct 1612 struct ocfs2_alloc_context *meta_ac)
1607 { 1613 {
1608 int ret; 1614 int ret;
1609 struct buffer_head *expand_bh = NULL; 1615 struct buffer_head *expand_bh = NULL;
1610 1616
1611 if (ref_root_bh == ref_leaf_bh) { 1617 if (ref_root_bh == ref_leaf_bh) {
1612 /* 1618 /*
1613 * the old root bh hasn't bee 1619 * the old root bh hasn't been expanded to a b-tree,
1614 * so expand it first. 1620 * so expand it first.
1615 */ 1621 */
1616 ret = ocfs2_expand_inline_ref 1622 ret = ocfs2_expand_inline_ref_root(handle, ci, ref_root_bh,
1617 1623 &expand_bh, meta_ac);
1618 if (ret) { 1624 if (ret) {
1619 mlog_errno(ret); 1625 mlog_errno(ret);
1620 goto out; 1626 goto out;
1621 } 1627 }
1622 } else { 1628 } else {
1623 expand_bh = ref_leaf_bh; 1629 expand_bh = ref_leaf_bh;
1624 get_bh(expand_bh); 1630 get_bh(expand_bh);
1625 } 1631 }
1626 1632
1627 1633
1628 /* Now add a new refcount block into 1634 /* Now add a new refcount block into the tree.*/
1629 ret = ocfs2_new_leaf_refcount_block(h 1635 ret = ocfs2_new_leaf_refcount_block(handle, ci, ref_root_bh,
1630 e 1636 expand_bh, meta_ac);
1631 if (ret) 1637 if (ret)
1632 mlog_errno(ret); 1638 mlog_errno(ret);
1633 out: 1639 out:
1634 brelse(expand_bh); 1640 brelse(expand_bh);
1635 return ret; 1641 return ret;
1636 } 1642 }
1637 1643
1638 /* 1644 /*
1639 * Adjust the extent rec in b-tree representi 1645 * Adjust the extent rec in b-tree representing ref_leaf_bh.
1640 * 1646 *
1641 * Only called when we have inserted a new re 1647 * Only called when we have inserted a new refcount rec at index 0
1642 * which means ocfs2_extent_rec.e_cpos may ne 1648 * which means ocfs2_extent_rec.e_cpos may need some change.
1643 */ 1649 */
1644 static int ocfs2_adjust_refcount_rec(handle_t 1650 static int ocfs2_adjust_refcount_rec(handle_t *handle,
1645 struct o 1651 struct ocfs2_caching_info *ci,
1646 struct b 1652 struct buffer_head *ref_root_bh,
1647 struct b 1653 struct buffer_head *ref_leaf_bh,
1648 struct o 1654 struct ocfs2_refcount_rec *rec)
1649 { 1655 {
1650 int ret = 0, i; 1656 int ret = 0, i;
1651 u32 new_cpos, old_cpos; 1657 u32 new_cpos, old_cpos;
1652 struct ocfs2_path *path = NULL; 1658 struct ocfs2_path *path = NULL;
1653 struct ocfs2_extent_tree et; 1659 struct ocfs2_extent_tree et;
1654 struct ocfs2_refcount_block *rb = 1660 struct ocfs2_refcount_block *rb =
1655 (struct ocfs2_refcount_block 1661 (struct ocfs2_refcount_block *)ref_root_bh->b_data;
1656 struct ocfs2_extent_list *el; 1662 struct ocfs2_extent_list *el;
1657 1663
1658 if (!(le32_to_cpu(rb->rf_flags) & OCF 1664 if (!(le32_to_cpu(rb->rf_flags) & OCFS2_REFCOUNT_TREE_FL))
1659 goto out; 1665 goto out;
1660 1666
1661 rb = (struct ocfs2_refcount_block *)r 1667 rb = (struct ocfs2_refcount_block *)ref_leaf_bh->b_data;
1662 old_cpos = le32_to_cpu(rb->rf_cpos); 1668 old_cpos = le32_to_cpu(rb->rf_cpos);
1663 new_cpos = le64_to_cpu(rec->r_cpos) & 1669 new_cpos = le64_to_cpu(rec->r_cpos) & OCFS2_32BIT_POS_MASK;
1664 if (old_cpos <= new_cpos) 1670 if (old_cpos <= new_cpos)
1665 goto out; 1671 goto out;
1666 1672
1667 ocfs2_init_refcount_extent_tree(&et, 1673 ocfs2_init_refcount_extent_tree(&et, ci, ref_root_bh);
1668 1674
1669 path = ocfs2_new_path_from_et(&et); 1675 path = ocfs2_new_path_from_et(&et);
1670 if (!path) { 1676 if (!path) {
1671 ret = -ENOMEM; 1677 ret = -ENOMEM;
1672 mlog_errno(ret); 1678 mlog_errno(ret);
1673 goto out; 1679 goto out;
1674 } 1680 }
1675 1681
1676 ret = ocfs2_find_path(ci, path, old_c 1682 ret = ocfs2_find_path(ci, path, old_cpos);
1677 if (ret) { 1683 if (ret) {
1678 mlog_errno(ret); 1684 mlog_errno(ret);
1679 goto out; 1685 goto out;
1680 } 1686 }
1681 1687
1682 /* 1688 /*
1683 * 2 more credits, one for the leaf r 1689 * 2 more credits, one for the leaf refcount block, one for
1684 * the extent block contains the exte 1690 * the extent block contains the extent rec.
1685 */ 1691 */
1686 ret = ocfs2_extend_trans(handle, 2); 1692 ret = ocfs2_extend_trans(handle, 2);
1687 if (ret < 0) { 1693 if (ret < 0) {
1688 mlog_errno(ret); 1694 mlog_errno(ret);
1689 goto out; 1695 goto out;
1690 } 1696 }
1691 1697
1692 ret = ocfs2_journal_access_rb(handle, 1698 ret = ocfs2_journal_access_rb(handle, ci, ref_leaf_bh,
1693 OCFS2_J 1699 OCFS2_JOURNAL_ACCESS_WRITE);
1694 if (ret < 0) { 1700 if (ret < 0) {
1695 mlog_errno(ret); 1701 mlog_errno(ret);
1696 goto out; 1702 goto out;
1697 } 1703 }
1698 1704
1699 ret = ocfs2_journal_access_eb(handle, 1705 ret = ocfs2_journal_access_eb(handle, ci, path_leaf_bh(path),
1700 OCFS2_J 1706 OCFS2_JOURNAL_ACCESS_WRITE);
1701 if (ret < 0) { 1707 if (ret < 0) {
1702 mlog_errno(ret); 1708 mlog_errno(ret);
1703 goto out; 1709 goto out;
1704 } 1710 }
1705 1711
1706 /* change the leaf extent block first 1712 /* change the leaf extent block first. */
1707 el = path_leaf_el(path); 1713 el = path_leaf_el(path);
1708 1714
1709 for (i = 0; i < le16_to_cpu(el->l_nex 1715 for (i = 0; i < le16_to_cpu(el->l_next_free_rec); i++)
1710 if (le32_to_cpu(el->l_recs[i] 1716 if (le32_to_cpu(el->l_recs[i].e_cpos) == old_cpos)
1711 break; 1717 break;
1712 1718
1713 BUG_ON(i == le16_to_cpu(el->l_next_fr 1719 BUG_ON(i == le16_to_cpu(el->l_next_free_rec));
1714 1720
1715 el->l_recs[i].e_cpos = cpu_to_le32(ne 1721 el->l_recs[i].e_cpos = cpu_to_le32(new_cpos);
1716 1722
1717 /* change the r_cpos in the leaf bloc 1723 /* change the r_cpos in the leaf block. */
1718 rb->rf_cpos = cpu_to_le32(new_cpos); 1724 rb->rf_cpos = cpu_to_le32(new_cpos);
1719 1725
1720 ocfs2_journal_dirty(handle, path_leaf 1726 ocfs2_journal_dirty(handle, path_leaf_bh(path));
1721 ocfs2_journal_dirty(handle, ref_leaf_ 1727 ocfs2_journal_dirty(handle, ref_leaf_bh);
1722 1728
1723 out: 1729 out:
1724 ocfs2_free_path(path); 1730 ocfs2_free_path(path);
1725 return ret; 1731 return ret;
1726 } 1732 }
1727 1733
1728 static int ocfs2_insert_refcount_rec(handle_t 1734 static int ocfs2_insert_refcount_rec(handle_t *handle,
1729 struct o 1735 struct ocfs2_caching_info *ci,
1730 struct b 1736 struct buffer_head *ref_root_bh,
1731 struct b 1737 struct buffer_head *ref_leaf_bh,
1732 struct o 1738 struct ocfs2_refcount_rec *rec,
1733 int inde 1739 int index, int merge,
1734 struct o 1740 struct ocfs2_alloc_context *meta_ac)
1735 { 1741 {
1736 int ret; 1742 int ret;
1737 struct ocfs2_refcount_block *rb = 1743 struct ocfs2_refcount_block *rb =
1738 (struct ocfs2_refcoun 1744 (struct ocfs2_refcount_block *)ref_leaf_bh->b_data;
1739 struct ocfs2_refcount_list *rf_list = 1745 struct ocfs2_refcount_list *rf_list = &rb->rf_records;
1740 struct buffer_head *new_bh = NULL; 1746 struct buffer_head *new_bh = NULL;
1741 1747
1742 BUG_ON(le32_to_cpu(rb->rf_flags) & OC 1748 BUG_ON(le32_to_cpu(rb->rf_flags) & OCFS2_REFCOUNT_TREE_FL);
1743 1749
1744 if (rf_list->rl_used == rf_list->rl_c 1750 if (rf_list->rl_used == rf_list->rl_count) {
1745 u64 cpos = le64_to_cpu(rec->r 1751 u64 cpos = le64_to_cpu(rec->r_cpos);
1746 u32 len = le32_to_cpu(rec->r_ 1752 u32 len = le32_to_cpu(rec->r_clusters);
1747 1753
1748 ret = ocfs2_expand_refcount_t 1754 ret = ocfs2_expand_refcount_tree(handle, ci, ref_root_bh,
1749 1755 ref_leaf_bh, meta_ac);
1750 if (ret) { 1756 if (ret) {
1751 mlog_errno(ret); 1757 mlog_errno(ret);
1752 goto out; 1758 goto out;
1753 } 1759 }
1754 1760
1755 ret = ocfs2_get_refcount_rec( 1761 ret = ocfs2_get_refcount_rec(ci, ref_root_bh,
1756 1762 cpos, len, NULL, &index,
1757 1763 &new_bh);
1758 if (ret) { 1764 if (ret) {
1759 mlog_errno(ret); 1765 mlog_errno(ret);
1760 goto out; 1766 goto out;
1761 } 1767 }
1762 1768
1763 ref_leaf_bh = new_bh; 1769 ref_leaf_bh = new_bh;
1764 rb = (struct ocfs2_refcount_b 1770 rb = (struct ocfs2_refcount_block *)ref_leaf_bh->b_data;
1765 rf_list = &rb->rf_records; 1771 rf_list = &rb->rf_records;
1766 } 1772 }
1767 1773
1768 ret = ocfs2_journal_access_rb(handle, 1774 ret = ocfs2_journal_access_rb(handle, ci, ref_leaf_bh,
1769 OCFS2_J 1775 OCFS2_JOURNAL_ACCESS_WRITE);
1770 if (ret) { 1776 if (ret) {
1771 mlog_errno(ret); 1777 mlog_errno(ret);
1772 goto out; 1778 goto out;
1773 } 1779 }
1774 1780
1775 if (index < le16_to_cpu(rf_list->rl_u 1781 if (index < le16_to_cpu(rf_list->rl_used))
1776 memmove(&rf_list->rl_recs[ind 1782 memmove(&rf_list->rl_recs[index + 1],
1777 &rf_list->rl_recs[ind 1783 &rf_list->rl_recs[index],
1778 (le16_to_cpu(rf_list- 1784 (le16_to_cpu(rf_list->rl_used) - index) *
1779 sizeof(struct ocfs2_ 1785 sizeof(struct ocfs2_refcount_rec));
1780 1786
1781 trace_ocfs2_insert_refcount_rec( 1787 trace_ocfs2_insert_refcount_rec(
1782 (unsigned long long)ref_leaf_ 1788 (unsigned long long)ref_leaf_bh->b_blocknr, index,
1783 (unsigned long long)le64_to_c 1789 (unsigned long long)le64_to_cpu(rec->r_cpos),
1784 le32_to_cpu(rec->r_clusters), 1790 le32_to_cpu(rec->r_clusters), le32_to_cpu(rec->r_refcount));
1785 1791
1786 rf_list->rl_recs[index] = *rec; 1792 rf_list->rl_recs[index] = *rec;
1787 1793
1788 le16_add_cpu(&rf_list->rl_used, 1); 1794 le16_add_cpu(&rf_list->rl_used, 1);
1789 1795
1790 if (merge) 1796 if (merge)
1791 ocfs2_refcount_rec_merge(rb, 1797 ocfs2_refcount_rec_merge(rb, index);
1792 1798
1793 ocfs2_journal_dirty(handle, ref_leaf_ 1799 ocfs2_journal_dirty(handle, ref_leaf_bh);
1794 1800
1795 if (index == 0) { 1801 if (index == 0) {
1796 ret = ocfs2_adjust_refcount_r 1802 ret = ocfs2_adjust_refcount_rec(handle, ci,
1797 1803 ref_root_bh,
1798 1804 ref_leaf_bh, rec);
1799 if (ret) 1805 if (ret)
1800 mlog_errno(ret); 1806 mlog_errno(ret);
1801 } 1807 }
1802 out: 1808 out:
1803 brelse(new_bh); 1809 brelse(new_bh);
1804 return ret; 1810 return ret;
1805 } 1811 }
1806 1812
1807 /* 1813 /*
1808 * Split the refcount_rec indexed by "index" 1814 * Split the refcount_rec indexed by "index" in ref_leaf_bh.
1809 * This is much simple than our b-tree code. 1815 * This is much simple than our b-tree code.
1810 * split_rec is the new refcount rec we want 1816 * split_rec is the new refcount rec we want to insert.
1811 * If split_rec->r_refcount > 0, we are chang 1817 * If split_rec->r_refcount > 0, we are changing the refcount(in case we
1812 * increase refcount or decrease a refcount t 1818 * increase refcount or decrease a refcount to non-zero).
1813 * If split_rec->r_refcount == 0, we are punc 1819 * If split_rec->r_refcount == 0, we are punching a hole in current refcount
1814 * rec( in case we decrease a refcount to zer 1820 * rec( in case we decrease a refcount to zero).
1815 */ 1821 */
1816 static int ocfs2_split_refcount_rec(handle_t 1822 static int ocfs2_split_refcount_rec(handle_t *handle,
1817 struct oc 1823 struct ocfs2_caching_info *ci,
1818 struct bu 1824 struct buffer_head *ref_root_bh,
1819 struct bu 1825 struct buffer_head *ref_leaf_bh,
1820 struct oc 1826 struct ocfs2_refcount_rec *split_rec,
1821 int index 1827 int index, int merge,
1822 struct oc 1828 struct ocfs2_alloc_context *meta_ac,
1823 struct oc 1829 struct ocfs2_cached_dealloc_ctxt *dealloc)
1824 { 1830 {
1825 int ret, recs_need; 1831 int ret, recs_need;
1826 u32 len; 1832 u32 len;
1827 struct ocfs2_refcount_block *rb = 1833 struct ocfs2_refcount_block *rb =
1828 (struct ocfs2_refcoun 1834 (struct ocfs2_refcount_block *)ref_leaf_bh->b_data;
1829 struct ocfs2_refcount_list *rf_list = 1835 struct ocfs2_refcount_list *rf_list = &rb->rf_records;
1830 struct ocfs2_refcount_rec *orig_rec = 1836 struct ocfs2_refcount_rec *orig_rec = &rf_list->rl_recs[index];
1831 struct ocfs2_refcount_rec *tail_rec = 1837 struct ocfs2_refcount_rec *tail_rec = NULL;
1832 struct buffer_head *new_bh = NULL; 1838 struct buffer_head *new_bh = NULL;
1833 1839
1834 BUG_ON(le32_to_cpu(rb->rf_flags) & OC 1840 BUG_ON(le32_to_cpu(rb->rf_flags) & OCFS2_REFCOUNT_TREE_FL);
1835 1841
1836 trace_ocfs2_split_refcount_rec(le64_t 1842 trace_ocfs2_split_refcount_rec(le64_to_cpu(orig_rec->r_cpos),
1837 le32_to_cpu(orig_rec->r_clust 1843 le32_to_cpu(orig_rec->r_clusters),
1838 le32_to_cpu(orig_rec->r_refco 1844 le32_to_cpu(orig_rec->r_refcount),
1839 le64_to_cpu(split_rec->r_cpos 1845 le64_to_cpu(split_rec->r_cpos),
1840 le32_to_cpu(split_rec->r_clus 1846 le32_to_cpu(split_rec->r_clusters),
1841 le32_to_cpu(split_rec->r_refc 1847 le32_to_cpu(split_rec->r_refcount));
1842 1848
1843 /* 1849 /*
1844 * If we just need to split the heade 1850 * If we just need to split the header or tail clusters,
1845 * no more recs are needed, just spli 1851 * no more recs are needed, just split is OK.
1846 * Otherwise we at least need one new 1852 * Otherwise we at least need one new recs.
1847 */ 1853 */
1848 if (!split_rec->r_refcount && 1854 if (!split_rec->r_refcount &&
1849 (split_rec->r_cpos == orig_rec->r 1855 (split_rec->r_cpos == orig_rec->r_cpos ||
1850 le64_to_cpu(split_rec->r_cpos) + 1856 le64_to_cpu(split_rec->r_cpos) +
1851 le32_to_cpu(split_rec->r_cluster 1857 le32_to_cpu(split_rec->r_clusters) ==
1852 le64_to_cpu(orig_rec->r_cpos) + 1858 le64_to_cpu(orig_rec->r_cpos) + le32_to_cpu(orig_rec->r_clusters)))
1853 recs_need = 0; 1859 recs_need = 0;
1854 else 1860 else
1855 recs_need = 1; 1861 recs_need = 1;
1856 1862
1857 /* 1863 /*
1858 * We need one more rec if we split i 1864 * We need one more rec if we split in the middle and the new rec have
1859 * some refcount in it. 1865 * some refcount in it.
1860 */ 1866 */
1861 if (split_rec->r_refcount && 1867 if (split_rec->r_refcount &&
1862 (split_rec->r_cpos != orig_rec->r 1868 (split_rec->r_cpos != orig_rec->r_cpos &&
1863 le64_to_cpu(split_rec->r_cpos) + 1869 le64_to_cpu(split_rec->r_cpos) +
1864 le32_to_cpu(split_rec->r_cluster 1870 le32_to_cpu(split_rec->r_clusters) !=
1865 le64_to_cpu(orig_rec->r_cpos) + 1871 le64_to_cpu(orig_rec->r_cpos) + le32_to_cpu(orig_rec->r_clusters)))
1866 recs_need++; 1872 recs_need++;
1867 1873
1868 /* If the leaf block don't have enoug 1874 /* If the leaf block don't have enough record, expand it. */
1869 if (le16_to_cpu(rf_list->rl_used) + r 1875 if (le16_to_cpu(rf_list->rl_used) + recs_need >
1870 le16 1876 le16_to_cpu(rf_list->rl_count)) {
1871 struct ocfs2_refcount_rec tmp 1877 struct ocfs2_refcount_rec tmp_rec;
1872 u64 cpos = le64_to_cpu(orig_r 1878 u64 cpos = le64_to_cpu(orig_rec->r_cpos);
1873 len = le32_to_cpu(orig_rec->r 1879 len = le32_to_cpu(orig_rec->r_clusters);
1874 ret = ocfs2_expand_refcount_t 1880 ret = ocfs2_expand_refcount_tree(handle, ci, ref_root_bh,
1875 1881 ref_leaf_bh, meta_ac);
1876 if (ret) { 1882 if (ret) {
1877 mlog_errno(ret); 1883 mlog_errno(ret);
1878 goto out; 1884 goto out;
1879 } 1885 }
1880 1886
1881 /* 1887 /*
1882 * We have to re-get it since 1888 * We have to re-get it since now cpos may be moved to
1883 * another leaf block. 1889 * another leaf block.
1884 */ 1890 */
1885 ret = ocfs2_get_refcount_rec( 1891 ret = ocfs2_get_refcount_rec(ci, ref_root_bh,
1886 1892 cpos, len, &tmp_rec, &index,
1887 1893 &new_bh);
1888 if (ret) { 1894 if (ret) {
1889 mlog_errno(ret); 1895 mlog_errno(ret);
1890 goto out; 1896 goto out;
1891 } 1897 }
1892 1898
1893 ref_leaf_bh = new_bh; 1899 ref_leaf_bh = new_bh;
1894 rb = (struct ocfs2_refcount_b 1900 rb = (struct ocfs2_refcount_block *)ref_leaf_bh->b_data;
1895 rf_list = &rb->rf_records; 1901 rf_list = &rb->rf_records;
1896 orig_rec = &rf_list->rl_recs[ 1902 orig_rec = &rf_list->rl_recs[index];
1897 } 1903 }
1898 1904
1899 ret = ocfs2_journal_access_rb(handle, 1905 ret = ocfs2_journal_access_rb(handle, ci, ref_leaf_bh,
1900 OCFS2_J 1906 OCFS2_JOURNAL_ACCESS_WRITE);
1901 if (ret) { 1907 if (ret) {
1902 mlog_errno(ret); 1908 mlog_errno(ret);
1903 goto out; 1909 goto out;
1904 } 1910 }
1905 1911
1906 /* 1912 /*
1907 * We have calculated out how many ne 1913 * We have calculated out how many new records we need and store
1908 * in recs_need, so spare enough spac 1914 * in recs_need, so spare enough space first by moving the records
1909 * after "index" to the end. 1915 * after "index" to the end.
1910 */ 1916 */
1911 if (index != le16_to_cpu(rf_list->rl_ 1917 if (index != le16_to_cpu(rf_list->rl_used) - 1)
1912 memmove(&rf_list->rl_recs[ind 1918 memmove(&rf_list->rl_recs[index + 1 + recs_need],
1913 &rf_list->rl_recs[ind 1919 &rf_list->rl_recs[index + 1],
1914 (le16_to_cpu(rf_list- 1920 (le16_to_cpu(rf_list->rl_used) - index - 1) *
1915 sizeof(struct ocfs2_ 1921 sizeof(struct ocfs2_refcount_rec));
1916 1922
1917 len = (le64_to_cpu(orig_rec->r_cpos) 1923 len = (le64_to_cpu(orig_rec->r_cpos) +
1918 le32_to_cpu(orig_rec->r_cluster 1924 le32_to_cpu(orig_rec->r_clusters)) -
1919 (le64_to_cpu(split_rec->r_cpos) 1925 (le64_to_cpu(split_rec->r_cpos) +
1920 le32_to_cpu(split_rec->r_cluste 1926 le32_to_cpu(split_rec->r_clusters));
1921 1927
1922 /* 1928 /*
1923 * If we have "len", the we will spli 1929 * If we have "len", the we will split in the tail and move it
1924 * to the end of the space we have ju 1930 * to the end of the space we have just spared.
1925 */ 1931 */
1926 if (len) { 1932 if (len) {
1927 tail_rec = &rf_list->rl_recs[ 1933 tail_rec = &rf_list->rl_recs[index + recs_need];
1928 1934
1929 memcpy(tail_rec, orig_rec, si 1935 memcpy(tail_rec, orig_rec, sizeof(struct ocfs2_refcount_rec));
1930 le64_add_cpu(&tail_rec->r_cpo 1936 le64_add_cpu(&tail_rec->r_cpos,
1931 le32_to_cpu(tail 1937 le32_to_cpu(tail_rec->r_clusters) - len);
1932 tail_rec->r_clusters = cpu_to 1938 tail_rec->r_clusters = cpu_to_le32(len);
1933 } 1939 }
1934 1940
1935 /* 1941 /*
1936 * If the split pos isn't the same as 1942 * If the split pos isn't the same as the original one, we need to
1937 * split in the head. 1943 * split in the head.
1938 * 1944 *
1939 * Note: We have the chance that spli 1945 * Note: We have the chance that split_rec.r_refcount = 0,
1940 * recs_need = 0 and len > 0, which m 1946 * recs_need = 0 and len > 0, which means we just cut the head from
1941 * the orig_rec and in that case we h 1947 * the orig_rec and in that case we have done some modification in
1942 * orig_rec above, so the check for r 1948 * orig_rec above, so the check for r_cpos is faked.
1943 */ 1949 */
1944 if (split_rec->r_cpos != orig_rec->r_ 1950 if (split_rec->r_cpos != orig_rec->r_cpos && tail_rec != orig_rec) {
1945 len = le64_to_cpu(split_rec-> 1951 len = le64_to_cpu(split_rec->r_cpos) -
1946 le64_to_cpu(orig_rec->r 1952 le64_to_cpu(orig_rec->r_cpos);
1947 orig_rec->r_clusters = cpu_to 1953 orig_rec->r_clusters = cpu_to_le32(len);
1948 index++; 1954 index++;
1949 } 1955 }
1950 1956
1951 le16_add_cpu(&rf_list->rl_used, recs_ 1957 le16_add_cpu(&rf_list->rl_used, recs_need);
1952 1958
1953 if (split_rec->r_refcount) { 1959 if (split_rec->r_refcount) {
1954 rf_list->rl_recs[index] = *sp 1960 rf_list->rl_recs[index] = *split_rec;
1955 trace_ocfs2_split_refcount_re 1961 trace_ocfs2_split_refcount_rec_insert(
1956 (unsigned long long)r 1962 (unsigned long long)ref_leaf_bh->b_blocknr, index,
1957 (unsigned long long)l 1963 (unsigned long long)le64_to_cpu(split_rec->r_cpos),
1958 le32_to_cpu(split_rec 1964 le32_to_cpu(split_rec->r_clusters),
1959 le32_to_cpu(split_rec 1965 le32_to_cpu(split_rec->r_refcount));
1960 1966
1961 if (merge) 1967 if (merge)
1962 ocfs2_refcount_rec_me 1968 ocfs2_refcount_rec_merge(rb, index);
1963 } 1969 }
1964 1970
1965 ocfs2_journal_dirty(handle, ref_leaf_ 1971 ocfs2_journal_dirty(handle, ref_leaf_bh);
1966 1972
1967 out: 1973 out:
1968 brelse(new_bh); 1974 brelse(new_bh);
1969 return ret; 1975 return ret;
1970 } 1976 }
1971 1977
1972 static int __ocfs2_increase_refcount(handle_t 1978 static int __ocfs2_increase_refcount(handle_t *handle,
1973 struct o 1979 struct ocfs2_caching_info *ci,
1974 struct b 1980 struct buffer_head *ref_root_bh,
1975 u64 cpos 1981 u64 cpos, u32 len, int merge,
1976 struct o 1982 struct ocfs2_alloc_context *meta_ac,
1977 struct o 1983 struct ocfs2_cached_dealloc_ctxt *dealloc)
1978 { 1984 {
1979 int ret = 0, index; 1985 int ret = 0, index;
1980 struct buffer_head *ref_leaf_bh = NUL 1986 struct buffer_head *ref_leaf_bh = NULL;
1981 struct ocfs2_refcount_rec rec; 1987 struct ocfs2_refcount_rec rec;
1982 unsigned int set_len = 0; 1988 unsigned int set_len = 0;
1983 1989
1984 trace_ocfs2_increase_refcount_begin( 1990 trace_ocfs2_increase_refcount_begin(
1985 (unsigned long long)ocfs2_metada 1991 (unsigned long long)ocfs2_metadata_cache_owner(ci),
1986 (unsigned long long)cpos, len); 1992 (unsigned long long)cpos, len);
1987 1993
1988 while (len) { 1994 while (len) {
1989 ret = ocfs2_get_refcount_rec( 1995 ret = ocfs2_get_refcount_rec(ci, ref_root_bh,
1990 1996 cpos, len, &rec, &index,
1991 1997 &ref_leaf_bh);
1992 if (ret) { 1998 if (ret) {
1993 mlog_errno(ret); 1999 mlog_errno(ret);
1994 goto out; 2000 goto out;
1995 } 2001 }
1996 2002
1997 set_len = le32_to_cpu(rec.r_c 2003 set_len = le32_to_cpu(rec.r_clusters);
1998 2004
1999 /* 2005 /*
2000 * Here we may meet with 3 si 2006 * Here we may meet with 3 situations:
2001 * 2007 *
2002 * 1. If we find an already e 2008 * 1. If we find an already existing record, and the length
2003 * is the same, cool, we j 2009 * is the same, cool, we just need to increase the r_refcount
2004 * and it is OK. 2010 * and it is OK.
2005 * 2. If we find a hole, just 2011 * 2. If we find a hole, just insert it with r_refcount = 1.
2006 * 3. If we are in the middle 2012 * 3. If we are in the middle of one extent record, split
2007 * it. 2013 * it.
2008 */ 2014 */
2009 if (rec.r_refcount && le64_to 2015 if (rec.r_refcount && le64_to_cpu(rec.r_cpos) == cpos &&
2010 set_len <= len) { 2016 set_len <= len) {
2011 trace_ocfs2_increase_ 2017 trace_ocfs2_increase_refcount_change(
2012 (unsigned lon 2018 (unsigned long long)cpos, set_len,
2013 le32_to_cpu(r 2019 le32_to_cpu(rec.r_refcount));
2014 ret = ocfs2_change_re 2020 ret = ocfs2_change_refcount_rec(handle, ci,
2015 2021 ref_leaf_bh, index,
2016 2022 merge, 1);
2017 if (ret) { 2023 if (ret) {
2018 mlog_errno(re 2024 mlog_errno(ret);
2019 goto out; 2025 goto out;
2020 } 2026 }
2021 } else if (!rec.r_refcount) { 2027 } else if (!rec.r_refcount) {
2022 rec.r_refcount = cpu_ 2028 rec.r_refcount = cpu_to_le32(1);
2023 2029
2024 trace_ocfs2_increase_ 2030 trace_ocfs2_increase_refcount_insert(
2025 (unsigned long l 2031 (unsigned long long)le64_to_cpu(rec.r_cpos),
2026 set_len); 2032 set_len);
2027 ret = ocfs2_insert_re 2033 ret = ocfs2_insert_refcount_rec(handle, ci, ref_root_bh,
2028 2034 ref_leaf_bh,
2029 2035 &rec, index,
2030 2036 merge, meta_ac);
2031 if (ret) { 2037 if (ret) {
2032 mlog_errno(re 2038 mlog_errno(ret);
2033 goto out; 2039 goto out;
2034 } 2040 }
2035 } else { 2041 } else {
2036 set_len = min((u64)(c 2042 set_len = min((u64)(cpos + len),
2037 le64_to 2043 le64_to_cpu(rec.r_cpos) + set_len) - cpos;
2038 rec.r_cpos = cpu_to_l 2044 rec.r_cpos = cpu_to_le64(cpos);
2039 rec.r_clusters = cpu_ 2045 rec.r_clusters = cpu_to_le32(set_len);
2040 le32_add_cpu(&rec.r_r 2046 le32_add_cpu(&rec.r_refcount, 1);
2041 2047
2042 trace_ocfs2_increase_ 2048 trace_ocfs2_increase_refcount_split(
2043 (unsigned long l 2049 (unsigned long long)le64_to_cpu(rec.r_cpos),
2044 set_len, le32_to 2050 set_len, le32_to_cpu(rec.r_refcount));
2045 ret = ocfs2_split_ref 2051 ret = ocfs2_split_refcount_rec(handle, ci,
2046 2052 ref_root_bh, ref_leaf_bh,
2047 2053 &rec, index, merge,
2048 2054 meta_ac, dealloc);
2049 if (ret) { 2055 if (ret) {
2050 mlog_errno(re 2056 mlog_errno(ret);
2051 goto out; 2057 goto out;
2052 } 2058 }
2053 } 2059 }
2054 2060
2055 cpos += set_len; 2061 cpos += set_len;
2056 len -= set_len; 2062 len -= set_len;
2057 brelse(ref_leaf_bh); 2063 brelse(ref_leaf_bh);
2058 ref_leaf_bh = NULL; 2064 ref_leaf_bh = NULL;
2059 } 2065 }
2060 2066
2061 out: 2067 out:
2062 brelse(ref_leaf_bh); 2068 brelse(ref_leaf_bh);
2063 return ret; 2069 return ret;
2064 } 2070 }
2065 2071
2066 static int ocfs2_remove_refcount_extent(handl 2072 static int ocfs2_remove_refcount_extent(handle_t *handle,
2067 struct ocfs2_ 2073 struct ocfs2_caching_info *ci,
2068 struct buffer 2074 struct buffer_head *ref_root_bh,
2069 struct buffer 2075 struct buffer_head *ref_leaf_bh,
2070 struct ocfs2_ 2076 struct ocfs2_alloc_context *meta_ac,
2071 struct ocfs2_ 2077 struct ocfs2_cached_dealloc_ctxt *dealloc)
2072 { 2078 {
2073 int ret; 2079 int ret;
2074 struct super_block *sb = ocfs2_metada 2080 struct super_block *sb = ocfs2_metadata_cache_get_super(ci);
2075 struct ocfs2_refcount_block *rb = 2081 struct ocfs2_refcount_block *rb =
2076 (struct ocfs2_refcoun 2082 (struct ocfs2_refcount_block *)ref_leaf_bh->b_data;
2077 struct ocfs2_extent_tree et; 2083 struct ocfs2_extent_tree et;
2078 2084
2079 BUG_ON(rb->rf_records.rl_used); 2085 BUG_ON(rb->rf_records.rl_used);
2080 2086
2081 trace_ocfs2_remove_refcount_extent( 2087 trace_ocfs2_remove_refcount_extent(
2082 (unsigned long long)ocfs2_met 2088 (unsigned long long)ocfs2_metadata_cache_owner(ci),
2083 (unsigned long long)ref_leaf_ 2089 (unsigned long long)ref_leaf_bh->b_blocknr,
2084 le32_to_cpu(rb->rf_cpos)); 2090 le32_to_cpu(rb->rf_cpos));
2085 2091
2086 ocfs2_init_refcount_extent_tree(&et, 2092 ocfs2_init_refcount_extent_tree(&et, ci, ref_root_bh);
2087 ret = ocfs2_remove_extent(handle, &et 2093 ret = ocfs2_remove_extent(handle, &et, le32_to_cpu(rb->rf_cpos),
2088 1, meta_ac, 2094 1, meta_ac, dealloc);
2089 if (ret) { 2095 if (ret) {
2090 mlog_errno(ret); 2096 mlog_errno(ret);
2091 goto out; 2097 goto out;
2092 } 2098 }
2093 2099
2094 ocfs2_remove_from_cache(ci, ref_leaf_ 2100 ocfs2_remove_from_cache(ci, ref_leaf_bh);
2095 2101
2096 /* 2102 /*
2097 * add the freed block to the dealloc 2103 * add the freed block to the dealloc so that it will be freed
2098 * when we run dealloc. 2104 * when we run dealloc.
2099 */ 2105 */
2100 ret = ocfs2_cache_block_dealloc(deall 2106 ret = ocfs2_cache_block_dealloc(dealloc, EXTENT_ALLOC_SYSTEM_INODE,
2101 le16_ 2107 le16_to_cpu(rb->rf_suballoc_slot),
2102 le64_ 2108 le64_to_cpu(rb->rf_suballoc_loc),
2103 le64_ 2109 le64_to_cpu(rb->rf_blkno),
2104 le16_ 2110 le16_to_cpu(rb->rf_suballoc_bit));
2105 if (ret) { 2111 if (ret) {
2106 mlog_errno(ret); 2112 mlog_errno(ret);
2107 goto out; 2113 goto out;
2108 } 2114 }
2109 2115
2110 ret = ocfs2_journal_access_rb(handle, 2116 ret = ocfs2_journal_access_rb(handle, ci, ref_root_bh,
2111 OCFS2_J 2117 OCFS2_JOURNAL_ACCESS_WRITE);
2112 if (ret) { 2118 if (ret) {
2113 mlog_errno(ret); 2119 mlog_errno(ret);
2114 goto out; 2120 goto out;
2115 } 2121 }
2116 2122
2117 rb = (struct ocfs2_refcount_block *)r 2123 rb = (struct ocfs2_refcount_block *)ref_root_bh->b_data;
2118 2124
2119 le32_add_cpu(&rb->rf_clusters, -1); 2125 le32_add_cpu(&rb->rf_clusters, -1);
2120 2126
2121 /* 2127 /*
2122 * check whether we need to restore t 2128 * check whether we need to restore the root refcount block if
2123 * there is no leaf extent block at a 2129 * there is no leaf extent block at atll.
2124 */ 2130 */
2125 if (!rb->rf_list.l_next_free_rec) { 2131 if (!rb->rf_list.l_next_free_rec) {
2126 BUG_ON(rb->rf_clusters); 2132 BUG_ON(rb->rf_clusters);
2127 2133
2128 trace_ocfs2_restore_refcount_ 2134 trace_ocfs2_restore_refcount_block(
2129 (unsigned long long)ref_ 2135 (unsigned long long)ref_root_bh->b_blocknr);
2130 2136
2131 rb->rf_flags = 0; 2137 rb->rf_flags = 0;
2132 rb->rf_parent = 0; 2138 rb->rf_parent = 0;
2133 rb->rf_cpos = 0; 2139 rb->rf_cpos = 0;
2134 memset(&rb->rf_records, 0, sb 2140 memset(&rb->rf_records, 0, sb->s_blocksize -
2135 offsetof(struct ocfs2_ 2141 offsetof(struct ocfs2_refcount_block, rf_records));
2136 rb->rf_records.rl_count = 2142 rb->rf_records.rl_count =
2137 cpu_to_le16(o 2143 cpu_to_le16(ocfs2_refcount_recs_per_rb(sb));
2138 } 2144 }
2139 2145
2140 ocfs2_journal_dirty(handle, ref_root_ 2146 ocfs2_journal_dirty(handle, ref_root_bh);
2141 2147
2142 out: 2148 out:
2143 return ret; 2149 return ret;
2144 } 2150 }
2145 2151
2146 int ocfs2_increase_refcount(handle_t *handle, 2152 int ocfs2_increase_refcount(handle_t *handle,
2147 struct ocfs2_cach 2153 struct ocfs2_caching_info *ci,
2148 struct buffer_hea 2154 struct buffer_head *ref_root_bh,
2149 u64 cpos, u32 len 2155 u64 cpos, u32 len,
2150 struct ocfs2_allo 2156 struct ocfs2_alloc_context *meta_ac,
2151 struct ocfs2_cach 2157 struct ocfs2_cached_dealloc_ctxt *dealloc)
2152 { 2158 {
2153 return __ocfs2_increase_refcount(hand 2159 return __ocfs2_increase_refcount(handle, ci, ref_root_bh,
2154 cpos 2160 cpos, len, 1,
2155 meta 2161 meta_ac, dealloc);
2156 } 2162 }
2157 2163
2158 static int ocfs2_decrease_refcount_rec(handle 2164 static int ocfs2_decrease_refcount_rec(handle_t *handle,
2159 struct ocfs2_ 2165 struct ocfs2_caching_info *ci,
2160 struct buffer 2166 struct buffer_head *ref_root_bh,
2161 struct buffer 2167 struct buffer_head *ref_leaf_bh,
2162 int index, u6 2168 int index, u64 cpos, unsigned int len,
2163 struct ocfs2_ 2169 struct ocfs2_alloc_context *meta_ac,
2164 struct ocfs2_ 2170 struct ocfs2_cached_dealloc_ctxt *dealloc)
2165 { 2171 {
2166 int ret; 2172 int ret;
2167 struct ocfs2_refcount_block *rb = 2173 struct ocfs2_refcount_block *rb =
2168 (struct ocfs2_refcoun 2174 (struct ocfs2_refcount_block *)ref_leaf_bh->b_data;
2169 struct ocfs2_refcount_rec *rec = &rb- 2175 struct ocfs2_refcount_rec *rec = &rb->rf_records.rl_recs[index];
2170 2176
2171 BUG_ON(cpos < le64_to_cpu(rec->r_cpos 2177 BUG_ON(cpos < le64_to_cpu(rec->r_cpos));
2172 BUG_ON(cpos + len > 2178 BUG_ON(cpos + len >
2173 le64_to_cpu(rec->r_cpos) + le3 2179 le64_to_cpu(rec->r_cpos) + le32_to_cpu(rec->r_clusters));
2174 2180
2175 trace_ocfs2_decrease_refcount_rec( 2181 trace_ocfs2_decrease_refcount_rec(
2176 (unsigned long long)ocfs2_met 2182 (unsigned long long)ocfs2_metadata_cache_owner(ci),
2177 (unsigned long long)cpos, len 2183 (unsigned long long)cpos, len);
2178 2184
2179 if (cpos == le64_to_cpu(rec->r_cpos) 2185 if (cpos == le64_to_cpu(rec->r_cpos) &&
2180 len == le32_to_cpu(rec->r_cluster 2186 len == le32_to_cpu(rec->r_clusters))
2181 ret = ocfs2_change_refcount_r 2187 ret = ocfs2_change_refcount_rec(handle, ci,
2182 2188 ref_leaf_bh, index, 1, -1);
2183 else { 2189 else {
2184 struct ocfs2_refcount_rec spl 2190 struct ocfs2_refcount_rec split = *rec;
2185 split.r_cpos = cpu_to_le64(cp 2191 split.r_cpos = cpu_to_le64(cpos);
2186 split.r_clusters = cpu_to_le3 2192 split.r_clusters = cpu_to_le32(len);
2187 2193
2188 le32_add_cpu(&split.r_refcoun 2194 le32_add_cpu(&split.r_refcount, -1);
2189 2195
2190 ret = ocfs2_split_refcount_re 2196 ret = ocfs2_split_refcount_rec(handle, ci,
2191 2197 ref_root_bh, ref_leaf_bh,
2192 2198 &split, index, 1,
2193 2199 meta_ac, dealloc);
2194 } 2200 }
2195 2201
2196 if (ret) { 2202 if (ret) {
2197 mlog_errno(ret); 2203 mlog_errno(ret);
2198 goto out; 2204 goto out;
2199 } 2205 }
2200 2206
2201 /* Remove the leaf refcount block if 2207 /* Remove the leaf refcount block if it contains no refcount record. */
2202 if (!rb->rf_records.rl_used && ref_le 2208 if (!rb->rf_records.rl_used && ref_leaf_bh != ref_root_bh) {
2203 ret = ocfs2_remove_refcount_e 2209 ret = ocfs2_remove_refcount_extent(handle, ci, ref_root_bh,
2204 2210 ref_leaf_bh, meta_ac,
2205 2211 dealloc);
2206 if (ret) 2212 if (ret)
2207 mlog_errno(ret); 2213 mlog_errno(ret);
2208 } 2214 }
2209 2215
2210 out: 2216 out:
2211 return ret; 2217 return ret;
2212 } 2218 }
2213 2219
2214 static int __ocfs2_decrease_refcount(handle_t 2220 static int __ocfs2_decrease_refcount(handle_t *handle,
2215 struct o 2221 struct ocfs2_caching_info *ci,
2216 struct b 2222 struct buffer_head *ref_root_bh,
2217 u64 cpos 2223 u64 cpos, u32 len,
2218 struct o 2224 struct ocfs2_alloc_context *meta_ac,
2219 struct o 2225 struct ocfs2_cached_dealloc_ctxt *dealloc,
2220 int dele 2226 int delete)
2221 { 2227 {
2222 int ret = 0, index = 0; 2228 int ret = 0, index = 0;
2223 struct ocfs2_refcount_rec rec; 2229 struct ocfs2_refcount_rec rec;
2224 unsigned int r_count = 0, r_len; 2230 unsigned int r_count = 0, r_len;
2225 struct super_block *sb = ocfs2_metada 2231 struct super_block *sb = ocfs2_metadata_cache_get_super(ci);
2226 struct buffer_head *ref_leaf_bh = NUL 2232 struct buffer_head *ref_leaf_bh = NULL;
2227 2233
2228 trace_ocfs2_decrease_refcount( 2234 trace_ocfs2_decrease_refcount(
2229 (unsigned long long)ocfs2_met 2235 (unsigned long long)ocfs2_metadata_cache_owner(ci),
2230 (unsigned long long)cpos, len 2236 (unsigned long long)cpos, len, delete);
2231 2237
2232 while (len) { 2238 while (len) {
2233 ret = ocfs2_get_refcount_rec( 2239 ret = ocfs2_get_refcount_rec(ci, ref_root_bh,
2234 2240 cpos, len, &rec, &index,
2235 2241 &ref_leaf_bh);
2236 if (ret) { 2242 if (ret) {
2237 mlog_errno(ret); 2243 mlog_errno(ret);
2238 goto out; 2244 goto out;
2239 } 2245 }
2240 2246
2241 r_count = le32_to_cpu(rec.r_r 2247 r_count = le32_to_cpu(rec.r_refcount);
2242 BUG_ON(r_count == 0); 2248 BUG_ON(r_count == 0);
2243 if (!delete) 2249 if (!delete)
2244 BUG_ON(r_count > 1); 2250 BUG_ON(r_count > 1);
2245 2251
2246 r_len = min((u64)(cpos + len) 2252 r_len = min((u64)(cpos + len), le64_to_cpu(rec.r_cpos) +
2247 le32_to_cpu(rec 2253 le32_to_cpu(rec.r_clusters)) - cpos;
2248 2254
2249 ret = ocfs2_decrease_refcount 2255 ret = ocfs2_decrease_refcount_rec(handle, ci, ref_root_bh,
2250 2256 ref_leaf_bh, index,
2251 2257 cpos, r_len,
2252 2258 meta_ac, dealloc);
2253 if (ret) { 2259 if (ret) {
2254 mlog_errno(ret); 2260 mlog_errno(ret);
2255 goto out; 2261 goto out;
2256 } 2262 }
2257 2263
2258 if (le32_to_cpu(rec.r_refcoun 2264 if (le32_to_cpu(rec.r_refcount) == 1 && delete) {
2259 ret = ocfs2_cache_clu 2265 ret = ocfs2_cache_cluster_dealloc(dealloc,
2260 ocf 2266 ocfs2_clusters_to_blocks(sb, cpos),
2261 2267 r_len);
2262 if (ret) { 2268 if (ret) {
2263 mlog_errno(re 2269 mlog_errno(ret);
2264 goto out; 2270 goto out;
2265 } 2271 }
2266 } 2272 }
2267 2273
2268 cpos += r_len; 2274 cpos += r_len;
2269 len -= r_len; 2275 len -= r_len;
2270 brelse(ref_leaf_bh); 2276 brelse(ref_leaf_bh);
2271 ref_leaf_bh = NULL; 2277 ref_leaf_bh = NULL;
2272 } 2278 }
2273 2279
2274 out: 2280 out:
2275 brelse(ref_leaf_bh); 2281 brelse(ref_leaf_bh);
2276 return ret; 2282 return ret;
2277 } 2283 }
2278 2284
2279 /* Caller must hold refcount tree lock. */ 2285 /* Caller must hold refcount tree lock. */
2280 int ocfs2_decrease_refcount(struct inode *ino 2286 int ocfs2_decrease_refcount(struct inode *inode,
2281 handle_t *handle, 2287 handle_t *handle, u32 cpos, u32 len,
2282 struct ocfs2_allo 2288 struct ocfs2_alloc_context *meta_ac,
2283 struct ocfs2_cach 2289 struct ocfs2_cached_dealloc_ctxt *dealloc,
2284 int delete) 2290 int delete)
2285 { 2291 {
2286 int ret; 2292 int ret;
2287 u64 ref_blkno; 2293 u64 ref_blkno;
2288 struct buffer_head *ref_root_bh = NUL 2294 struct buffer_head *ref_root_bh = NULL;
2289 struct ocfs2_refcount_tree *tree; 2295 struct ocfs2_refcount_tree *tree;
2290 2296
2291 BUG_ON(!ocfs2_is_refcount_inode(inode 2297 BUG_ON(!ocfs2_is_refcount_inode(inode));
2292 2298
2293 ret = ocfs2_get_refcount_block(inode, 2299 ret = ocfs2_get_refcount_block(inode, &ref_blkno);
2294 if (ret) { 2300 if (ret) {
2295 mlog_errno(ret); 2301 mlog_errno(ret);
2296 goto out; 2302 goto out;
2297 } 2303 }
2298 2304
2299 ret = ocfs2_get_refcount_tree(OCFS2_S 2305 ret = ocfs2_get_refcount_tree(OCFS2_SB(inode->i_sb), ref_blkno, &tree);
2300 if (ret) { 2306 if (ret) {
2301 mlog_errno(ret); 2307 mlog_errno(ret);
2302 goto out; 2308 goto out;
2303 } 2309 }
2304 2310
2305 ret = ocfs2_read_refcount_block(&tree 2311 ret = ocfs2_read_refcount_block(&tree->rf_ci, tree->rf_blkno,
2306 &ref_ 2312 &ref_root_bh);
2307 if (ret) { 2313 if (ret) {
2308 mlog_errno(ret); 2314 mlog_errno(ret);
2309 goto out; 2315 goto out;
2310 } 2316 }
2311 2317
2312 ret = __ocfs2_decrease_refcount(handl 2318 ret = __ocfs2_decrease_refcount(handle, &tree->rf_ci, ref_root_bh,
2313 cpos, 2319 cpos, len, meta_ac, dealloc, delete);
2314 if (ret) 2320 if (ret)
2315 mlog_errno(ret); 2321 mlog_errno(ret);
2316 out: 2322 out:
2317 brelse(ref_root_bh); 2323 brelse(ref_root_bh);
2318 return ret; 2324 return ret;
2319 } 2325 }
2320 2326
2321 /* 2327 /*
2322 * Mark the already-existing extent at cpos a 2328 * Mark the already-existing extent at cpos as refcounted for len clusters.
2323 * This adds the refcount extent flag. 2329 * This adds the refcount extent flag.
2324 * 2330 *
2325 * If the existing extent is larger than the 2331 * If the existing extent is larger than the request, initiate a
2326 * split. An attempt will be made at merging 2332 * split. An attempt will be made at merging with adjacent extents.
2327 * 2333 *
2328 * The caller is responsible for passing down 2334 * The caller is responsible for passing down meta_ac if we'll need it.
2329 */ 2335 */
2330 static int ocfs2_mark_extent_refcounted(struc 2336 static int ocfs2_mark_extent_refcounted(struct inode *inode,
2331 struct ocfs2_ 2337 struct ocfs2_extent_tree *et,
2332 handle_t *han 2338 handle_t *handle, u32 cpos,
2333 u32 len, u32 2339 u32 len, u32 phys,
2334 struct ocfs2_ 2340 struct ocfs2_alloc_context *meta_ac,
2335 struct ocfs2_ 2341 struct ocfs2_cached_dealloc_ctxt *dealloc)
2336 { 2342 {
2337 int ret; 2343 int ret;
2338 2344
2339 trace_ocfs2_mark_extent_refcounted(OC 2345 trace_ocfs2_mark_extent_refcounted(OCFS2_I(inode)->ip_blkno,
2340 cp 2346 cpos, len, phys);
2341 2347
2342 if (!ocfs2_refcount_tree(OCFS2_SB(ino 2348 if (!ocfs2_refcount_tree(OCFS2_SB(inode->i_sb))) {
2343 ret = ocfs2_error(inode->i_sb 2349 ret = ocfs2_error(inode->i_sb, "Inode %lu want to use refcount tree, but the feature bit is not set in the super block\n",
2344 inode->i_in 2350 inode->i_ino);
2345 goto out; 2351 goto out;
2346 } 2352 }
2347 2353
2348 ret = ocfs2_change_extent_flag(handle 2354 ret = ocfs2_change_extent_flag(handle, et, cpos,
2349 len, p 2355 len, phys, meta_ac, dealloc,
2350 OCFS2_ 2356 OCFS2_EXT_REFCOUNTED, 0);
2351 if (ret) 2357 if (ret)
2352 mlog_errno(ret); 2358 mlog_errno(ret);
2353 2359
2354 out: 2360 out:
2355 return ret; 2361 return ret;
2356 } 2362 }
2357 2363
2358 /* 2364 /*
2359 * Given some contiguous physical clusters, c 2365 * Given some contiguous physical clusters, calculate what we need
2360 * for modifying their refcount. 2366 * for modifying their refcount.
2361 */ 2367 */
2362 static int ocfs2_calc_refcount_meta_credits(s 2368 static int ocfs2_calc_refcount_meta_credits(struct super_block *sb,
2363 s 2369 struct ocfs2_caching_info *ci,
2364 s 2370 struct buffer_head *ref_root_bh,
2365 u 2371 u64 start_cpos,
2366 u 2372 u32 clusters,
2367 i 2373 int *meta_add,
2368 i 2374 int *credits)
2369 { 2375 {
2370 int ret = 0, index, ref_blocks = 0, r 2376 int ret = 0, index, ref_blocks = 0, recs_add = 0;
2371 u64 cpos = start_cpos; 2377 u64 cpos = start_cpos;
2372 struct ocfs2_refcount_block *rb; 2378 struct ocfs2_refcount_block *rb;
2373 struct ocfs2_refcount_rec rec; 2379 struct ocfs2_refcount_rec rec;
2374 struct buffer_head *ref_leaf_bh = NUL 2380 struct buffer_head *ref_leaf_bh = NULL, *prev_bh = NULL;
2375 u32 len; 2381 u32 len;
2376 2382
2377 while (clusters) { 2383 while (clusters) {
2378 ret = ocfs2_get_refcount_rec( 2384 ret = ocfs2_get_refcount_rec(ci, ref_root_bh,
2379 2385 cpos, clusters, &rec,
2380 2386 &index, &ref_leaf_bh);
2381 if (ret) { 2387 if (ret) {
2382 mlog_errno(ret); 2388 mlog_errno(ret);
2383 goto out; 2389 goto out;
2384 } 2390 }
2385 2391
2386 if (ref_leaf_bh != prev_bh) { 2392 if (ref_leaf_bh != prev_bh) {
2387 /* 2393 /*
2388 * Now we encounter a 2394 * Now we encounter a new leaf block, so calculate
2389 * whether we need to 2395 * whether we need to extend the old leaf.
2390 */ 2396 */
2391 if (prev_bh) { 2397 if (prev_bh) {
2392 rb = (struct 2398 rb = (struct ocfs2_refcount_block *)
2393 2399 prev_bh->b_data;
2394 2400
2395 if (le16_to_c 2401 if (le16_to_cpu(rb->rf_records.rl_used) +
2396 recs_add 2402 recs_add >
2397 le16_to_c 2403 le16_to_cpu(rb->rf_records.rl_count))
2398 ref_b 2404 ref_blocks++;
2399 } 2405 }
2400 2406
2401 recs_add = 0; 2407 recs_add = 0;
2402 *credits += 1; 2408 *credits += 1;
2403 brelse(prev_bh); 2409 brelse(prev_bh);
2404 prev_bh = ref_leaf_bh 2410 prev_bh = ref_leaf_bh;
2405 get_bh(prev_bh); 2411 get_bh(prev_bh);
2406 } 2412 }
2407 2413
2408 trace_ocfs2_calc_refcount_met 2414 trace_ocfs2_calc_refcount_meta_credits_iterate(
2409 recs_add, (un 2415 recs_add, (unsigned long long)cpos, clusters,
2410 (unsigned lon 2416 (unsigned long long)le64_to_cpu(rec.r_cpos),
2411 le32_to_cpu(r 2417 le32_to_cpu(rec.r_clusters),
2412 le32_to_cpu(r 2418 le32_to_cpu(rec.r_refcount), index);
2413 2419
2414 len = min((u64)cpos + cluster 2420 len = min((u64)cpos + clusters, le64_to_cpu(rec.r_cpos) +
2415 le32_to_cpu(rec.r_c 2421 le32_to_cpu(rec.r_clusters)) - cpos;
2416 /* 2422 /*
2417 * We record all the records 2423 * We record all the records which will be inserted to the
2418 * same refcount block, so th 2424 * same refcount block, so that we can tell exactly whether
2419 * we need a new refcount blo 2425 * we need a new refcount block or not.
2420 * 2426 *
2421 * If we will insert a new on 2427 * If we will insert a new one, this is easy and only happens
2422 * during adding refcounted f 2428 * during adding refcounted flag to the extent, so we don't
2423 * have a chance of spliting. 2429 * have a chance of spliting. We just need one record.
2424 * 2430 *
2425 * If the refcount rec alread 2431 * If the refcount rec already exists, that would be a little
2426 * complicated. we may have t 2432 * complicated. we may have to:
2427 * 1) split at the beginning 2433 * 1) split at the beginning if the start pos isn't aligned.
2428 * we need 1 more record i 2434 * we need 1 more record in this case.
2429 * 2) split int the end if th 2435 * 2) split int the end if the end pos isn't aligned.
2430 * we need 1 more record i 2436 * we need 1 more record in this case.
2431 * 3) split in the middle bec 2437 * 3) split in the middle because of file system fragmentation.
2432 * we need 2 more records 2438 * we need 2 more records in this case(we can't detect this
2433 * beforehand, so always t 2439 * beforehand, so always think of the worst case).
2434 */ 2440 */
2435 if (rec.r_refcount) { 2441 if (rec.r_refcount) {
2436 recs_add += 2; 2442 recs_add += 2;
2437 /* Check whether we n 2443 /* Check whether we need a split at the beginning. */
2438 if (cpos == start_cpo 2444 if (cpos == start_cpos &&
2439 cpos != le64_to_c 2445 cpos != le64_to_cpu(rec.r_cpos))
2440 recs_add++; 2446 recs_add++;
2441 2447
2442 /* Check whether we n 2448 /* Check whether we need a split in the end. */
2443 if (cpos + clusters < 2449 if (cpos + clusters < le64_to_cpu(rec.r_cpos) +
2444 le32_to_cpu(rec.r 2450 le32_to_cpu(rec.r_clusters))
2445 recs_add++; 2451 recs_add++;
2446 } else 2452 } else
2447 recs_add++; 2453 recs_add++;
2448 2454
2449 brelse(ref_leaf_bh); 2455 brelse(ref_leaf_bh);
2450 ref_leaf_bh = NULL; 2456 ref_leaf_bh = NULL;
2451 clusters -= len; 2457 clusters -= len;
2452 cpos += len; 2458 cpos += len;
2453 } 2459 }
2454 2460
2455 if (prev_bh) { 2461 if (prev_bh) {
2456 rb = (struct ocfs2_refcount_b 2462 rb = (struct ocfs2_refcount_block *)prev_bh->b_data;
2457 2463
2458 if (le16_to_cpu(rb->rf_record 2464 if (le16_to_cpu(rb->rf_records.rl_used) + recs_add >
2459 le16_to_cpu(rb->rf_record 2465 le16_to_cpu(rb->rf_records.rl_count))
2460 ref_blocks++; 2466 ref_blocks++;
2461 2467
2462 *credits += 1; 2468 *credits += 1;
2463 } 2469 }
2464 2470
2465 if (!ref_blocks) 2471 if (!ref_blocks)
2466 goto out; 2472 goto out;
2467 2473
2468 *meta_add += ref_blocks; 2474 *meta_add += ref_blocks;
2469 *credits += ref_blocks; 2475 *credits += ref_blocks;
2470 2476
2471 /* 2477 /*
2472 * So we may need ref_blocks to inser 2478 * So we may need ref_blocks to insert into the tree.
2473 * That also means we need to change 2479 * That also means we need to change the b-tree and add that number
2474 * of records since we never merge th 2480 * of records since we never merge them.
2475 * We need one more block for expansi 2481 * We need one more block for expansion since the new created leaf
2476 * block is also full and needs split 2482 * block is also full and needs split.
2477 */ 2483 */
2478 rb = (struct ocfs2_refcount_block *)r 2484 rb = (struct ocfs2_refcount_block *)ref_root_bh->b_data;
2479 if (le32_to_cpu(rb->rf_flags) & OCFS2 2485 if (le32_to_cpu(rb->rf_flags) & OCFS2_REFCOUNT_TREE_FL) {
2480 struct ocfs2_extent_tree et; 2486 struct ocfs2_extent_tree et;
2481 2487
2482 ocfs2_init_refcount_extent_tr 2488 ocfs2_init_refcount_extent_tree(&et, ci, ref_root_bh);
2483 *meta_add += ocfs2_extend_met 2489 *meta_add += ocfs2_extend_meta_needed(et.et_root_el);
2484 *credits += ocfs2_calc_extend 2490 *credits += ocfs2_calc_extend_credits(sb,
2485 2491 et.et_root_el);
2486 } else { 2492 } else {
2487 *credits += OCFS2_EXPAND_REFC 2493 *credits += OCFS2_EXPAND_REFCOUNT_TREE_CREDITS;
2488 *meta_add += 1; 2494 *meta_add += 1;
2489 } 2495 }
2490 2496
2491 out: 2497 out:
2492 2498
2493 trace_ocfs2_calc_refcount_meta_credit 2499 trace_ocfs2_calc_refcount_meta_credits(
2494 (unsigned long long)start_cpo 2500 (unsigned long long)start_cpos, clusters,
2495 *meta_add, *credits); 2501 *meta_add, *credits);
2496 brelse(ref_leaf_bh); 2502 brelse(ref_leaf_bh);
2497 brelse(prev_bh); 2503 brelse(prev_bh);
2498 return ret; 2504 return ret;
2499 } 2505 }
2500 2506
2501 /* 2507 /*
2502 * For refcount tree, we will decrease some c 2508 * For refcount tree, we will decrease some contiguous clusters
2503 * refcount count, so just go through it to s 2509 * refcount count, so just go through it to see how many blocks
2504 * we gonna touch and whether we need to crea 2510 * we gonna touch and whether we need to create new blocks.
2505 * 2511 *
2506 * Normally the refcount blocks store these r 2512 * Normally the refcount blocks store these refcount should be
2507 * contiguous also, so that we can get the nu 2513 * contiguous also, so that we can get the number easily.
2508 * We will at most add split 2 refcount recor 2514 * We will at most add split 2 refcount records and 2 more
2509 * refcount blocks, so just check it in a rou 2515 * refcount blocks, so just check it in a rough way.
2510 * 2516 *
2511 * Caller must hold refcount tree lock. 2517 * Caller must hold refcount tree lock.
2512 */ 2518 */
2513 int ocfs2_prepare_refcount_change_for_del(str 2519 int ocfs2_prepare_refcount_change_for_del(struct inode *inode,
2514 u64 2520 u64 refcount_loc,
2515 u64 2521 u64 phys_blkno,
2516 u32 2522 u32 clusters,
2517 int 2523 int *credits,
2518 int 2524 int *ref_blocks)
2519 { 2525 {
2520 int ret; 2526 int ret;
2521 struct buffer_head *ref_root_bh = NUL 2527 struct buffer_head *ref_root_bh = NULL;
2522 struct ocfs2_refcount_tree *tree; 2528 struct ocfs2_refcount_tree *tree;
2523 u64 start_cpos = ocfs2_blocks_to_clus 2529 u64 start_cpos = ocfs2_blocks_to_clusters(inode->i_sb, phys_blkno);
2524 2530
2525 if (!ocfs2_refcount_tree(OCFS2_SB(ino 2531 if (!ocfs2_refcount_tree(OCFS2_SB(inode->i_sb))) {
2526 ret = ocfs2_error(inode->i_sb 2532 ret = ocfs2_error(inode->i_sb, "Inode %lu want to use refcount tree, but the feature bit is not set in the super block\n",
2527 inode->i_in 2533 inode->i_ino);
2528 goto out; 2534 goto out;
2529 } 2535 }
2530 2536
2531 BUG_ON(!ocfs2_is_refcount_inode(inode 2537 BUG_ON(!ocfs2_is_refcount_inode(inode));
2532 2538
2533 ret = ocfs2_get_refcount_tree(OCFS2_S 2539 ret = ocfs2_get_refcount_tree(OCFS2_SB(inode->i_sb),
2534 refcoun 2540 refcount_loc, &tree);
2535 if (ret) { 2541 if (ret) {
2536 mlog_errno(ret); 2542 mlog_errno(ret);
2537 goto out; 2543 goto out;
2538 } 2544 }
2539 2545
2540 ret = ocfs2_read_refcount_block(&tree 2546 ret = ocfs2_read_refcount_block(&tree->rf_ci, refcount_loc,
2541 &ref_ 2547 &ref_root_bh);
2542 if (ret) { 2548 if (ret) {
2543 mlog_errno(ret); 2549 mlog_errno(ret);
2544 goto out; 2550 goto out;
2545 } 2551 }
2546 2552
2547 ret = ocfs2_calc_refcount_meta_credit 2553 ret = ocfs2_calc_refcount_meta_credits(inode->i_sb,
2548 2554 &tree->rf_ci,
2549 2555 ref_root_bh,
2550 2556 start_cpos, clusters,
2551 2557 ref_blocks, credits);
2552 if (ret) { 2558 if (ret) {
2553 mlog_errno(ret); 2559 mlog_errno(ret);
2554 goto out; 2560 goto out;
2555 } 2561 }
2556 2562
2557 trace_ocfs2_prepare_refcount_change_f 2563 trace_ocfs2_prepare_refcount_change_for_del(*ref_blocks, *credits);
2558 2564
2559 out: 2565 out:
2560 brelse(ref_root_bh); 2566 brelse(ref_root_bh);
2561 return ret; 2567 return ret;
2562 } 2568 }
2563 2569
2564 #define MAX_CONTIG_BYTES 1048576 2570 #define MAX_CONTIG_BYTES 1048576
2565 2571
2566 static inline unsigned int ocfs2_cow_contig_c 2572 static inline unsigned int ocfs2_cow_contig_clusters(struct super_block *sb)
2567 { 2573 {
2568 return ocfs2_clusters_for_bytes(sb, M 2574 return ocfs2_clusters_for_bytes(sb, MAX_CONTIG_BYTES);
2569 } 2575 }
2570 2576
2571 static inline unsigned int ocfs2_cow_contig_m 2577 static inline unsigned int ocfs2_cow_contig_mask(struct super_block *sb)
2572 { 2578 {
2573 return ~(ocfs2_cow_contig_clusters(sb 2579 return ~(ocfs2_cow_contig_clusters(sb) - 1);
2574 } 2580 }
2575 2581
2576 /* 2582 /*
2577 * Given an extent that starts at 'start' and 2583 * Given an extent that starts at 'start' and an I/O that starts at 'cpos',
2578 * find an offset (start + (n * contig_cluste 2584 * find an offset (start + (n * contig_clusters)) that is closest to cpos
2579 * while still being less than or equal to it 2585 * while still being less than or equal to it.
2580 * 2586 *
2581 * The goal is to break the extent at a multi 2587 * The goal is to break the extent at a multiple of contig_clusters.
2582 */ 2588 */
2583 static inline unsigned int ocfs2_cow_align_st 2589 static inline unsigned int ocfs2_cow_align_start(struct super_block *sb,
2584 2590 unsigned int start,
2585 2591 unsigned int cpos)
2586 { 2592 {
2587 BUG_ON(start > cpos); 2593 BUG_ON(start > cpos);
2588 2594
2589 return start + ((cpos - start) & ocfs 2595 return start + ((cpos - start) & ocfs2_cow_contig_mask(sb));
2590 } 2596 }
2591 2597
2592 /* 2598 /*
2593 * Given a cluster count of len, pad it out s 2599 * Given a cluster count of len, pad it out so that it is a multiple
2594 * of contig_clusters. 2600 * of contig_clusters.
2595 */ 2601 */
2596 static inline unsigned int ocfs2_cow_align_le 2602 static inline unsigned int ocfs2_cow_align_length(struct super_block *sb,
2597 2603 unsigned int len)
2598 { 2604 {
2599 unsigned int padded = 2605 unsigned int padded =
2600 (len + (ocfs2_cow_contig_clus 2606 (len + (ocfs2_cow_contig_clusters(sb) - 1)) &
2601 ocfs2_cow_contig_mask(sb); 2607 ocfs2_cow_contig_mask(sb);
2602 2608
2603 /* Did we wrap? */ 2609 /* Did we wrap? */
2604 if (padded < len) 2610 if (padded < len)
2605 padded = UINT_MAX; 2611 padded = UINT_MAX;
2606 2612
2607 return padded; 2613 return padded;
2608 } 2614 }
2609 2615
2610 /* 2616 /*
2611 * Calculate out the start and number of virt !! 2617 * Calculate out the start and number of virtual clusters we need to to CoW.
2612 * 2618 *
2613 * cpos is vitual start cluster position we w 2619 * cpos is vitual start cluster position we want to do CoW in a
2614 * file and write_len is the cluster length. 2620 * file and write_len is the cluster length.
2615 * max_cpos is the place where we want to sto 2621 * max_cpos is the place where we want to stop CoW intentionally.
2616 * 2622 *
2617 * Normal we will start CoW from the beginnin 2623 * Normal we will start CoW from the beginning of extent record cotaining cpos.
2618 * We try to break up extents on boundaries o 2624 * We try to break up extents on boundaries of MAX_CONTIG_BYTES so that we
2619 * get good I/O from the resulting extent tre 2625 * get good I/O from the resulting extent tree.
2620 */ 2626 */
2621 static int ocfs2_refcount_cal_cow_clusters(st 2627 static int ocfs2_refcount_cal_cow_clusters(struct inode *inode,
2622 st 2628 struct ocfs2_extent_list *el,
2623 u3 2629 u32 cpos,
2624 u3 2630 u32 write_len,
2625 u3 2631 u32 max_cpos,
2626 u3 2632 u32 *cow_start,
2627 u3 2633 u32 *cow_len)
2628 { 2634 {
2629 int ret = 0; 2635 int ret = 0;
2630 int tree_height = le16_to_cpu(el->l_t 2636 int tree_height = le16_to_cpu(el->l_tree_depth), i;
2631 struct buffer_head *eb_bh = NULL; 2637 struct buffer_head *eb_bh = NULL;
2632 struct ocfs2_extent_block *eb = NULL; 2638 struct ocfs2_extent_block *eb = NULL;
2633 struct ocfs2_extent_rec *rec; 2639 struct ocfs2_extent_rec *rec;
2634 unsigned int want_clusters, rec_end = 2640 unsigned int want_clusters, rec_end = 0;
2635 int contig_clusters = ocfs2_cow_conti 2641 int contig_clusters = ocfs2_cow_contig_clusters(inode->i_sb);
2636 int leaf_clusters; 2642 int leaf_clusters;
2637 2643
2638 BUG_ON(cpos + write_len > max_cpos); 2644 BUG_ON(cpos + write_len > max_cpos);
2639 2645
2640 if (tree_height > 0) { 2646 if (tree_height > 0) {
2641 ret = ocfs2_find_leaf(INODE_C 2647 ret = ocfs2_find_leaf(INODE_CACHE(inode), el, cpos, &eb_bh);
2642 if (ret) { 2648 if (ret) {
2643 mlog_errno(ret); 2649 mlog_errno(ret);
2644 goto out; 2650 goto out;
2645 } 2651 }
2646 2652
2647 eb = (struct ocfs2_extent_blo 2653 eb = (struct ocfs2_extent_block *) eb_bh->b_data;
2648 el = &eb->h_list; 2654 el = &eb->h_list;
2649 2655
2650 if (el->l_tree_depth) { 2656 if (el->l_tree_depth) {
2651 ret = ocfs2_error(ino 2657 ret = ocfs2_error(inode->i_sb,
2652 "In 2658 "Inode %lu has non zero tree depth in leaf block %llu\n",
2653 ino 2659 inode->i_ino,
2654 (un 2660 (unsigned long long)eb_bh->b_blocknr);
2655 goto out; 2661 goto out;
2656 } 2662 }
2657 } 2663 }
2658 2664
2659 *cow_len = 0; 2665 *cow_len = 0;
2660 for (i = 0; i < le16_to_cpu(el->l_nex 2666 for (i = 0; i < le16_to_cpu(el->l_next_free_rec); i++) {
2661 rec = &el->l_recs[i]; 2667 rec = &el->l_recs[i];
2662 2668
2663 if (ocfs2_is_empty_extent(rec 2669 if (ocfs2_is_empty_extent(rec)) {
2664 mlog_bug_on_msg(i != 2670 mlog_bug_on_msg(i != 0, "Inode %lu has empty record in "
2665 "inde 2671 "index %d\n", inode->i_ino, i);
2666 continue; 2672 continue;
2667 } 2673 }
2668 2674
2669 if (le32_to_cpu(rec->e_cpos) 2675 if (le32_to_cpu(rec->e_cpos) +
2670 le16_to_cpu(rec->e_leaf_c 2676 le16_to_cpu(rec->e_leaf_clusters) <= cpos)
2671 continue; 2677 continue;
2672 2678
2673 if (*cow_len == 0) { 2679 if (*cow_len == 0) {
2674 /* 2680 /*
2675 * We should find a r 2681 * We should find a refcounted record in the
2676 * first pass. 2682 * first pass.
2677 */ 2683 */
2678 BUG_ON(!(rec->e_flags 2684 BUG_ON(!(rec->e_flags & OCFS2_EXT_REFCOUNTED));
2679 *cow_start = le32_to_ 2685 *cow_start = le32_to_cpu(rec->e_cpos);
2680 } 2686 }
2681 2687
2682 /* 2688 /*
2683 * If we encounter a hole, a 2689 * If we encounter a hole, a non-refcounted record or
2684 * pass the max_cpos, stop th 2690 * pass the max_cpos, stop the search.
2685 */ 2691 */
2686 if ((!(rec->e_flags & OCFS2_E 2692 if ((!(rec->e_flags & OCFS2_EXT_REFCOUNTED)) ||
2687 (*cow_len && rec_end != l 2693 (*cow_len && rec_end != le32_to_cpu(rec->e_cpos)) ||
2688 (max_cpos <= le32_to_cpu( 2694 (max_cpos <= le32_to_cpu(rec->e_cpos)))
2689 break; 2695 break;
2690 2696
2691 leaf_clusters = le16_to_cpu(r 2697 leaf_clusters = le16_to_cpu(rec->e_leaf_clusters);
2692 rec_end = le32_to_cpu(rec->e_ 2698 rec_end = le32_to_cpu(rec->e_cpos) + leaf_clusters;
2693 if (rec_end > max_cpos) { 2699 if (rec_end > max_cpos) {
2694 rec_end = max_cpos; 2700 rec_end = max_cpos;
2695 leaf_clusters = rec_e 2701 leaf_clusters = rec_end - le32_to_cpu(rec->e_cpos);
2696 } 2702 }
2697 2703
2698 /* 2704 /*
2699 * How many clusters do we ac 2705 * How many clusters do we actually need from
2700 * this extent? First we see 2706 * this extent? First we see how many we actually
2701 * need to complete the write 2707 * need to complete the write. If that's smaller
2702 * than contig_clusters, we t 2708 * than contig_clusters, we try for contig_clusters.
2703 */ 2709 */
2704 if (!*cow_len) 2710 if (!*cow_len)
2705 want_clusters = write 2711 want_clusters = write_len;
2706 else 2712 else
2707 want_clusters = (cpos 2713 want_clusters = (cpos + write_len) -
2708 (*cow_start + 2714 (*cow_start + *cow_len);
2709 if (want_clusters < contig_cl 2715 if (want_clusters < contig_clusters)
2710 want_clusters = conti 2716 want_clusters = contig_clusters;
2711 2717
2712 /* 2718 /*
2713 * If the write does not cove 2719 * If the write does not cover the whole extent, we
2714 * need to calculate how we'r 2720 * need to calculate how we're going to split the extent.
2715 * We try to do it on contig_ 2721 * We try to do it on contig_clusters boundaries.
2716 * 2722 *
2717 * Any extent smaller than co 2723 * Any extent smaller than contig_clusters will be
2718 * CoWed in its entirety. 2724 * CoWed in its entirety.
2719 */ 2725 */
2720 if (leaf_clusters <= contig_c 2726 if (leaf_clusters <= contig_clusters)
2721 *cow_len += leaf_clus 2727 *cow_len += leaf_clusters;
2722 else if (*cow_len || (*cow_st 2728 else if (*cow_len || (*cow_start == cpos)) {
2723 /* 2729 /*
2724 * This extent needs 2730 * This extent needs to be CoW'd from its
2725 * beginning, so all 2731 * beginning, so all we have to do is compute
2726 * how many clusters 2732 * how many clusters to grab. We align
2727 * want_clusters to t 2733 * want_clusters to the edge of contig_clusters
2728 * to get better I/O. 2734 * to get better I/O.
2729 */ 2735 */
2730 want_clusters = ocfs2 2736 want_clusters = ocfs2_cow_align_length(inode->i_sb,
2731 2737 want_clusters);
2732 2738
2733 if (leaf_clusters < w 2739 if (leaf_clusters < want_clusters)
2734 *cow_len += l 2740 *cow_len += leaf_clusters;
2735 else 2741 else
2736 *cow_len += w 2742 *cow_len += want_clusters;
2737 } else if ((*cow_start + cont 2743 } else if ((*cow_start + contig_clusters) >=
2738 (cpos + write_len) 2744 (cpos + write_len)) {
2739 /* 2745 /*
2740 * Breaking off conti 2746 * Breaking off contig_clusters at the front
2741 * of the extent will 2747 * of the extent will cover our write. That's
2742 * easy. 2748 * easy.
2743 */ 2749 */
2744 *cow_len = contig_clu 2750 *cow_len = contig_clusters;
2745 } else if ((rec_end - cpos) < 2751 } else if ((rec_end - cpos) <= contig_clusters) {
2746 /* 2752 /*
2747 * Breaking off conti 2753 * Breaking off contig_clusters at the tail of
2748 * this extent will c 2754 * this extent will cover cpos.
2749 */ 2755 */
2750 *cow_start = rec_end 2756 *cow_start = rec_end - contig_clusters;
2751 *cow_len = contig_clu 2757 *cow_len = contig_clusters;
2752 } else if ((rec_end - cpos) < 2758 } else if ((rec_end - cpos) <= want_clusters) {
2753 /* 2759 /*
2754 * While we can't fit 2760 * While we can't fit the entire write in this
2755 * extent, we know th 2761 * extent, we know that the write goes from cpos
2756 * to the end of the 2762 * to the end of the extent. Break that off.
2757 * We try to break it 2763 * We try to break it at some multiple of
2758 * contig_clusters fr 2764 * contig_clusters from the front of the extent.
2759 * Failing that (ie, 2765 * Failing that (ie, cpos is within
2760 * contig_clusters of 2766 * contig_clusters of the front), we'll CoW the
2761 * entire extent. 2767 * entire extent.
2762 */ 2768 */
2763 *cow_start = ocfs2_co 2769 *cow_start = ocfs2_cow_align_start(inode->i_sb,
2764 2770 *cow_start, cpos);
2765 *cow_len = rec_end - 2771 *cow_len = rec_end - *cow_start;
2766 } else { 2772 } else {
2767 /* 2773 /*
2768 * Ok, the entire wri 2774 * Ok, the entire write lives in the middle of
2769 * this extent. Let' 2775 * this extent. Let's try to slice the extent up
2770 * nicely. Optimally 2776 * nicely. Optimally, our CoW region starts at
2771 * m*contig_clusters 2777 * m*contig_clusters from the beginning of the
2772 * extent and goes fo 2778 * extent and goes for n*contig_clusters,
2773 * covering the entir 2779 * covering the entire write.
2774 */ 2780 */
2775 *cow_start = ocfs2_co 2781 *cow_start = ocfs2_cow_align_start(inode->i_sb,
2776 2782 *cow_start, cpos);
2777 2783
2778 want_clusters = (cpos 2784 want_clusters = (cpos + write_len) - *cow_start;
2779 want_clusters = ocfs2 2785 want_clusters = ocfs2_cow_align_length(inode->i_sb,
2780 2786 want_clusters);
2781 if (*cow_start + want 2787 if (*cow_start + want_clusters <= rec_end)
2782 *cow_len = wa 2788 *cow_len = want_clusters;
2783 else 2789 else
2784 *cow_len = re 2790 *cow_len = rec_end - *cow_start;
2785 } 2791 }
2786 2792
2787 /* Have we covered our entire 2793 /* Have we covered our entire write yet? */
2788 if ((*cow_start + *cow_len) > 2794 if ((*cow_start + *cow_len) >= (cpos + write_len))
2789 break; 2795 break;
2790 2796
2791 /* 2797 /*
2792 * If we reach the end of the 2798 * If we reach the end of the extent block and don't get enough
2793 * clusters, continue with th 2799 * clusters, continue with the next extent block if possible.
2794 */ 2800 */
2795 if (i + 1 == le16_to_cpu(el-> 2801 if (i + 1 == le16_to_cpu(el->l_next_free_rec) &&
2796 eb && eb->h_next_leaf_blk 2802 eb && eb->h_next_leaf_blk) {
2797 brelse(eb_bh); 2803 brelse(eb_bh);
2798 eb_bh = NULL; 2804 eb_bh = NULL;
2799 2805
2800 ret = ocfs2_read_exte 2806 ret = ocfs2_read_extent_block(INODE_CACHE(inode),
2801 2807 le64_to_cpu(eb->h_next_leaf_blk),
2802 2808 &eb_bh);
2803 if (ret) { 2809 if (ret) {
2804 mlog_errno(re 2810 mlog_errno(ret);
2805 goto out; 2811 goto out;
2806 } 2812 }
2807 2813
2808 eb = (struct ocfs2_ex 2814 eb = (struct ocfs2_extent_block *) eb_bh->b_data;
2809 el = &eb->h_list; 2815 el = &eb->h_list;
2810 i = -1; 2816 i = -1;
2811 } 2817 }
2812 } 2818 }
2813 2819
2814 out: 2820 out:
2815 brelse(eb_bh); 2821 brelse(eb_bh);
2816 return ret; 2822 return ret;
2817 } 2823 }
2818 2824
2819 /* 2825 /*
2820 * Prepare meta_ac, data_ac and calculate cre 2826 * Prepare meta_ac, data_ac and calculate credits when we want to add some
2821 * num_clusters in data_tree "et" and change 2827 * num_clusters in data_tree "et" and change the refcount for the old
2822 * clusters(starting form p_cluster) in the r 2828 * clusters(starting form p_cluster) in the refcount tree.
2823 * 2829 *
2824 * Note: 2830 * Note:
2825 * 1. since we may split the old tree, so we 2831 * 1. since we may split the old tree, so we at most will need num_clusters + 2
2826 * more new leaf records. 2832 * more new leaf records.
2827 * 2. In some case, we may not need to reserv 2833 * 2. In some case, we may not need to reserve new clusters(e.g, reflink), so
2828 * just give data_ac = NULL. 2834 * just give data_ac = NULL.
2829 */ 2835 */
2830 static int ocfs2_lock_refcount_allocators(str 2836 static int ocfs2_lock_refcount_allocators(struct super_block *sb,
2831 u32 p 2837 u32 p_cluster, u32 num_clusters,
2832 struc 2838 struct ocfs2_extent_tree *et,
2833 struc 2839 struct ocfs2_caching_info *ref_ci,
2834 struc 2840 struct buffer_head *ref_root_bh,
2835 struc 2841 struct ocfs2_alloc_context **meta_ac,
2836 struc 2842 struct ocfs2_alloc_context **data_ac,
2837 int * 2843 int *credits)
2838 { 2844 {
2839 int ret = 0, meta_add = 0; 2845 int ret = 0, meta_add = 0;
2840 int num_free_extents = ocfs2_num_free 2846 int num_free_extents = ocfs2_num_free_extents(et);
2841 2847
2842 if (num_free_extents < 0) { 2848 if (num_free_extents < 0) {
2843 ret = num_free_extents; 2849 ret = num_free_extents;
2844 mlog_errno(ret); 2850 mlog_errno(ret);
2845 goto out; 2851 goto out;
2846 } 2852 }
2847 2853
2848 if (num_free_extents < num_clusters + 2854 if (num_free_extents < num_clusters + 2)
2849 meta_add = 2855 meta_add =
2850 ocfs2_extend_meta_nee 2856 ocfs2_extend_meta_needed(et->et_root_el);
2851 2857
2852 *credits += ocfs2_calc_extend_credits 2858 *credits += ocfs2_calc_extend_credits(sb, et->et_root_el);
2853 2859
2854 ret = ocfs2_calc_refcount_meta_credit 2860 ret = ocfs2_calc_refcount_meta_credits(sb, ref_ci, ref_root_bh,
2855 2861 p_cluster, num_clusters,
2856 2862 &meta_add, credits);
2857 if (ret) { 2863 if (ret) {
2858 mlog_errno(ret); 2864 mlog_errno(ret);
2859 goto out; 2865 goto out;
2860 } 2866 }
2861 2867
2862 trace_ocfs2_lock_refcount_allocators( 2868 trace_ocfs2_lock_refcount_allocators(meta_add, *credits);
2863 ret = ocfs2_reserve_new_metadata_bloc 2869 ret = ocfs2_reserve_new_metadata_blocks(OCFS2_SB(sb), meta_add,
2864 2870 meta_ac);
2865 if (ret) { 2871 if (ret) {
2866 mlog_errno(ret); 2872 mlog_errno(ret);
2867 goto out; 2873 goto out;
2868 } 2874 }
2869 2875
2870 if (data_ac) { 2876 if (data_ac) {
2871 ret = ocfs2_reserve_clusters( 2877 ret = ocfs2_reserve_clusters(OCFS2_SB(sb), num_clusters,
2872 2878 data_ac);
2873 if (ret) 2879 if (ret)
2874 mlog_errno(ret); 2880 mlog_errno(ret);
2875 } 2881 }
2876 2882
2877 out: 2883 out:
2878 if (ret) { 2884 if (ret) {
2879 if (*meta_ac) { 2885 if (*meta_ac) {
2880 ocfs2_free_alloc_cont 2886 ocfs2_free_alloc_context(*meta_ac);
2881 *meta_ac = NULL; 2887 *meta_ac = NULL;
2882 } 2888 }
2883 } 2889 }
2884 2890
2885 return ret; 2891 return ret;
2886 } 2892 }
2887 2893
2888 static int ocfs2_clear_cow_buffer(handle_t *h 2894 static int ocfs2_clear_cow_buffer(handle_t *handle, struct buffer_head *bh)
2889 { 2895 {
2890 BUG_ON(buffer_dirty(bh)); 2896 BUG_ON(buffer_dirty(bh));
2891 2897
2892 clear_buffer_mapped(bh); 2898 clear_buffer_mapped(bh);
2893 2899
2894 return 0; 2900 return 0;
2895 } 2901 }
2896 2902
2897 int ocfs2_duplicate_clusters_by_page(handle_t 2903 int ocfs2_duplicate_clusters_by_page(handle_t *handle,
2898 struct i 2904 struct inode *inode,
2899 u32 cpos 2905 u32 cpos, u32 old_cluster,
2900 u32 new_ 2906 u32 new_cluster, u32 new_len)
2901 { 2907 {
2902 int ret = 0, partial; 2908 int ret = 0, partial;
2903 struct super_block *sb = inode->i_sb; 2909 struct super_block *sb = inode->i_sb;
2904 u64 new_block = ocfs2_clusters_to_blo 2910 u64 new_block = ocfs2_clusters_to_blocks(sb, new_cluster);
2905 struct page *page; 2911 struct page *page;
2906 pgoff_t page_index; 2912 pgoff_t page_index;
2907 unsigned int from, to; 2913 unsigned int from, to;
2908 loff_t offset, end, map_end; 2914 loff_t offset, end, map_end;
2909 struct address_space *mapping = inode 2915 struct address_space *mapping = inode->i_mapping;
2910 2916
2911 trace_ocfs2_duplicate_clusters_by_pag 2917 trace_ocfs2_duplicate_clusters_by_page(cpos, old_cluster,
2912 2918 new_cluster, new_len);
2913 2919
2914 offset = ((loff_t)cpos) << OCFS2_SB(s 2920 offset = ((loff_t)cpos) << OCFS2_SB(sb)->s_clustersize_bits;
2915 end = offset + (new_len << OCFS2_SB(s 2921 end = offset + (new_len << OCFS2_SB(sb)->s_clustersize_bits);
2916 /* 2922 /*
2917 * We only duplicate pages until we r 2923 * We only duplicate pages until we reach the page contains i_size - 1.
2918 * So trim 'end' to i_size. 2924 * So trim 'end' to i_size.
2919 */ 2925 */
2920 if (end > i_size_read(inode)) 2926 if (end > i_size_read(inode))
2921 end = i_size_read(inode); 2927 end = i_size_read(inode);
2922 2928
2923 while (offset < end) { 2929 while (offset < end) {
2924 page_index = offset >> PAGE_S 2930 page_index = offset >> PAGE_SHIFT;
2925 map_end = ((loff_t)page_index 2931 map_end = ((loff_t)page_index + 1) << PAGE_SHIFT;
2926 if (map_end > end) 2932 if (map_end > end)
2927 map_end = end; 2933 map_end = end;
2928 2934
2929 /* from, to is the offset wit 2935 /* from, to is the offset within the page. */
2930 from = offset & (PAGE_SIZE - 2936 from = offset & (PAGE_SIZE - 1);
2931 to = PAGE_SIZE; 2937 to = PAGE_SIZE;
2932 if (map_end & (PAGE_SIZE - 1) 2938 if (map_end & (PAGE_SIZE - 1))
2933 to = map_end & (PAGE_ 2939 to = map_end & (PAGE_SIZE - 1);
2934 2940
2935 retry: 2941 retry:
2936 page = find_or_create_page(ma 2942 page = find_or_create_page(mapping, page_index, GFP_NOFS);
2937 if (!page) { 2943 if (!page) {
2938 ret = -ENOMEM; 2944 ret = -ENOMEM;
2939 mlog_errno(ret); 2945 mlog_errno(ret);
2940 break; 2946 break;
2941 } 2947 }
2942 2948
2943 /* 2949 /*
2944 * In case PAGE_SIZE <= CLUST 2950 * In case PAGE_SIZE <= CLUSTER_SIZE, we do not expect a dirty
2945 * page, so write it back. 2951 * page, so write it back.
2946 */ 2952 */
2947 if (PAGE_SIZE <= OCFS2_SB(sb) 2953 if (PAGE_SIZE <= OCFS2_SB(sb)->s_clustersize) {
2948 if (PageDirty(page)) 2954 if (PageDirty(page)) {
2949 unlock_page(p !! 2955 /*
2950 put_page(page !! 2956 * write_on_page will unlock the page on return
2951 !! 2957 */
2952 ret = filemap !! 2958 ret = write_one_page(page);
2953 <<
2954 goto retry; 2959 goto retry;
2955 } 2960 }
2956 } 2961 }
2957 2962
2958 if (!PageUptodate(page)) { 2963 if (!PageUptodate(page)) {
2959 struct folio *folio = !! 2964 ret = block_read_full_page(page, ocfs2_get_block);
2960 <<
2961 ret = block_read_full <<
2962 if (ret) { 2965 if (ret) {
2963 mlog_errno(re 2966 mlog_errno(ret);
2964 goto unlock; 2967 goto unlock;
2965 } 2968 }
2966 folio_lock(folio); !! 2969 lock_page(page);
2967 } 2970 }
2968 2971
2969 if (page_has_buffers(page)) { 2972 if (page_has_buffers(page)) {
2970 ret = walk_page_buffe 2973 ret = walk_page_buffers(handle, page_buffers(page),
2971 2974 from, to, &partial,
2972 2975 ocfs2_clear_cow_buffer);
2973 if (ret) { 2976 if (ret) {
2974 mlog_errno(re 2977 mlog_errno(ret);
2975 goto unlock; 2978 goto unlock;
2976 } 2979 }
2977 } 2980 }
2978 2981
2979 ocfs2_map_and_dirty_page(inod 2982 ocfs2_map_and_dirty_page(inode,
2980 hand 2983 handle, from, to,
2981 page 2984 page, 0, &new_block);
2982 mark_page_accessed(page); 2985 mark_page_accessed(page);
2983 unlock: 2986 unlock:
2984 unlock_page(page); 2987 unlock_page(page);
2985 put_page(page); 2988 put_page(page);
2986 page = NULL; 2989 page = NULL;
2987 offset = map_end; 2990 offset = map_end;
2988 if (ret) 2991 if (ret)
2989 break; 2992 break;
2990 } 2993 }
2991 2994
2992 return ret; 2995 return ret;
2993 } 2996 }
2994 2997
2995 int ocfs2_duplicate_clusters_by_jbd(handle_t 2998 int ocfs2_duplicate_clusters_by_jbd(handle_t *handle,
2996 struct in 2999 struct inode *inode,
2997 u32 cpos, 3000 u32 cpos, u32 old_cluster,
2998 u32 new_c 3001 u32 new_cluster, u32 new_len)
2999 { 3002 {
3000 int ret = 0; 3003 int ret = 0;
3001 struct super_block *sb = inode->i_sb; 3004 struct super_block *sb = inode->i_sb;
3002 struct ocfs2_caching_info *ci = INODE 3005 struct ocfs2_caching_info *ci = INODE_CACHE(inode);
3003 int i, blocks = ocfs2_clusters_to_blo 3006 int i, blocks = ocfs2_clusters_to_blocks(sb, new_len);
3004 u64 old_block = ocfs2_clusters_to_blo 3007 u64 old_block = ocfs2_clusters_to_blocks(sb, old_cluster);
3005 u64 new_block = ocfs2_clusters_to_blo 3008 u64 new_block = ocfs2_clusters_to_blocks(sb, new_cluster);
3006 struct ocfs2_super *osb = OCFS2_SB(sb 3009 struct ocfs2_super *osb = OCFS2_SB(sb);
3007 struct buffer_head *old_bh = NULL; 3010 struct buffer_head *old_bh = NULL;
3008 struct buffer_head *new_bh = NULL; 3011 struct buffer_head *new_bh = NULL;
3009 3012
3010 trace_ocfs2_duplicate_clusters_by_pag 3013 trace_ocfs2_duplicate_clusters_by_page(cpos, old_cluster,
3011 3014 new_cluster, new_len);
3012 3015
3013 for (i = 0; i < blocks; i++, old_bloc 3016 for (i = 0; i < blocks; i++, old_block++, new_block++) {
3014 new_bh = sb_getblk(osb->sb, n 3017 new_bh = sb_getblk(osb->sb, new_block);
3015 if (new_bh == NULL) { 3018 if (new_bh == NULL) {
3016 ret = -ENOMEM; 3019 ret = -ENOMEM;
3017 mlog_errno(ret); 3020 mlog_errno(ret);
3018 break; 3021 break;
3019 } 3022 }
3020 3023
3021 ocfs2_set_new_buffer_uptodate 3024 ocfs2_set_new_buffer_uptodate(ci, new_bh);
3022 3025
3023 ret = ocfs2_read_block(ci, ol 3026 ret = ocfs2_read_block(ci, old_block, &old_bh, NULL);
3024 if (ret) { 3027 if (ret) {
3025 mlog_errno(ret); 3028 mlog_errno(ret);
3026 break; 3029 break;
3027 } 3030 }
3028 3031
3029 ret = ocfs2_journal_access(ha 3032 ret = ocfs2_journal_access(handle, ci, new_bh,
3030 OC 3033 OCFS2_JOURNAL_ACCESS_CREATE);
3031 if (ret) { 3034 if (ret) {
3032 mlog_errno(ret); 3035 mlog_errno(ret);
3033 break; 3036 break;
3034 } 3037 }
3035 3038
3036 memcpy(new_bh->b_data, old_bh 3039 memcpy(new_bh->b_data, old_bh->b_data, sb->s_blocksize);
3037 ocfs2_journal_dirty(handle, n 3040 ocfs2_journal_dirty(handle, new_bh);
3038 3041
3039 brelse(new_bh); 3042 brelse(new_bh);
3040 brelse(old_bh); 3043 brelse(old_bh);
3041 new_bh = NULL; 3044 new_bh = NULL;
3042 old_bh = NULL; 3045 old_bh = NULL;
3043 } 3046 }
3044 3047
3045 brelse(new_bh); 3048 brelse(new_bh);
3046 brelse(old_bh); 3049 brelse(old_bh);
3047 return ret; 3050 return ret;
3048 } 3051 }
3049 3052
3050 static int ocfs2_clear_ext_refcount(handle_t 3053 static int ocfs2_clear_ext_refcount(handle_t *handle,
3051 struct oc 3054 struct ocfs2_extent_tree *et,
3052 u32 cpos, 3055 u32 cpos, u32 p_cluster, u32 len,
3053 unsigned 3056 unsigned int ext_flags,
3054 struct oc 3057 struct ocfs2_alloc_context *meta_ac,
3055 struct oc 3058 struct ocfs2_cached_dealloc_ctxt *dealloc)
3056 { 3059 {
3057 int ret, index; 3060 int ret, index;
3058 struct ocfs2_extent_rec replace_rec; 3061 struct ocfs2_extent_rec replace_rec;
3059 struct ocfs2_path *path = NULL; 3062 struct ocfs2_path *path = NULL;
3060 struct ocfs2_extent_list *el; 3063 struct ocfs2_extent_list *el;
3061 struct super_block *sb = ocfs2_metada 3064 struct super_block *sb = ocfs2_metadata_cache_get_super(et->et_ci);
3062 u64 ino = ocfs2_metadata_cache_owner( 3065 u64 ino = ocfs2_metadata_cache_owner(et->et_ci);
3063 3066
3064 trace_ocfs2_clear_ext_refcount((unsig 3067 trace_ocfs2_clear_ext_refcount((unsigned long long)ino,
3065 cpos, 3068 cpos, len, p_cluster, ext_flags);
3066 3069
3067 memset(&replace_rec, 0, sizeof(replac 3070 memset(&replace_rec, 0, sizeof(replace_rec));
3068 replace_rec.e_cpos = cpu_to_le32(cpos 3071 replace_rec.e_cpos = cpu_to_le32(cpos);
3069 replace_rec.e_leaf_clusters = cpu_to_ 3072 replace_rec.e_leaf_clusters = cpu_to_le16(len);
3070 replace_rec.e_blkno = cpu_to_le64(ocf 3073 replace_rec.e_blkno = cpu_to_le64(ocfs2_clusters_to_blocks(sb,
3071 3074 p_cluster));
3072 replace_rec.e_flags = ext_flags; 3075 replace_rec.e_flags = ext_flags;
3073 replace_rec.e_flags &= ~OCFS2_EXT_REF 3076 replace_rec.e_flags &= ~OCFS2_EXT_REFCOUNTED;
3074 3077
3075 path = ocfs2_new_path_from_et(et); 3078 path = ocfs2_new_path_from_et(et);
3076 if (!path) { 3079 if (!path) {
3077 ret = -ENOMEM; 3080 ret = -ENOMEM;
3078 mlog_errno(ret); 3081 mlog_errno(ret);
3079 goto out; 3082 goto out;
3080 } 3083 }
3081 3084
3082 ret = ocfs2_find_path(et->et_ci, path 3085 ret = ocfs2_find_path(et->et_ci, path, cpos);
3083 if (ret) { 3086 if (ret) {
3084 mlog_errno(ret); 3087 mlog_errno(ret);
3085 goto out; 3088 goto out;
3086 } 3089 }
3087 3090
3088 el = path_leaf_el(path); 3091 el = path_leaf_el(path);
3089 3092
3090 index = ocfs2_search_extent_list(el, 3093 index = ocfs2_search_extent_list(el, cpos);
3091 if (index == -1) { 3094 if (index == -1) {
3092 ret = ocfs2_error(sb, 3095 ret = ocfs2_error(sb,
3093 "Inode %llu 3096 "Inode %llu has an extent at cpos %u which can no longer be found\n",
3094 (unsigned l 3097 (unsigned long long)ino, cpos);
3095 goto out; 3098 goto out;
3096 } 3099 }
3097 3100
3098 ret = ocfs2_split_extent(handle, et, 3101 ret = ocfs2_split_extent(handle, et, path, index,
3099 &replace_rec 3102 &replace_rec, meta_ac, dealloc);
3100 if (ret) 3103 if (ret)
3101 mlog_errno(ret); 3104 mlog_errno(ret);
3102 3105
3103 out: 3106 out:
3104 ocfs2_free_path(path); 3107 ocfs2_free_path(path);
3105 return ret; 3108 return ret;
3106 } 3109 }
3107 3110
3108 static int ocfs2_replace_clusters(handle_t *h 3111 static int ocfs2_replace_clusters(handle_t *handle,
3109 struct ocfs 3112 struct ocfs2_cow_context *context,
3110 u32 cpos, u 3113 u32 cpos, u32 old,
3111 u32 new, u3 3114 u32 new, u32 len,
3112 unsigned in 3115 unsigned int ext_flags)
3113 { 3116 {
3114 int ret; 3117 int ret;
3115 struct ocfs2_caching_info *ci = conte 3118 struct ocfs2_caching_info *ci = context->data_et.et_ci;
3116 u64 ino = ocfs2_metadata_cache_owner( 3119 u64 ino = ocfs2_metadata_cache_owner(ci);
3117 3120
3118 trace_ocfs2_replace_clusters((unsigne 3121 trace_ocfs2_replace_clusters((unsigned long long)ino,
3119 cpos, ol 3122 cpos, old, new, len, ext_flags);
3120 3123
3121 /*If the old clusters is unwritten, n 3124 /*If the old clusters is unwritten, no need to duplicate. */
3122 if (!(ext_flags & OCFS2_EXT_UNWRITTEN 3125 if (!(ext_flags & OCFS2_EXT_UNWRITTEN)) {
3123 ret = context->cow_duplicate_ 3126 ret = context->cow_duplicate_clusters(handle, context->inode,
3124 3127 cpos, old, new, len);
3125 if (ret) { 3128 if (ret) {
3126 mlog_errno(ret); 3129 mlog_errno(ret);
3127 goto out; 3130 goto out;
3128 } 3131 }
3129 } 3132 }
3130 3133
3131 ret = ocfs2_clear_ext_refcount(handle 3134 ret = ocfs2_clear_ext_refcount(handle, &context->data_et,
3132 cpos, 3135 cpos, new, len, ext_flags,
3133 contex 3136 context->meta_ac, &context->dealloc);
3134 if (ret) 3137 if (ret)
3135 mlog_errno(ret); 3138 mlog_errno(ret);
3136 out: 3139 out:
3137 return ret; 3140 return ret;
3138 } 3141 }
3139 3142
3140 int ocfs2_cow_sync_writeback(struct super_blo 3143 int ocfs2_cow_sync_writeback(struct super_block *sb,
3141 struct inode *in 3144 struct inode *inode,
3142 u32 cpos, u32 nu 3145 u32 cpos, u32 num_clusters)
3143 { 3146 {
3144 int ret; !! 3147 int ret = 0;
3145 loff_t start, end; !! 3148 loff_t offset, end, map_end;
>> 3149 pgoff_t page_index;
>> 3150 struct page *page;
3146 3151
3147 if (ocfs2_should_order_data(inode)) 3152 if (ocfs2_should_order_data(inode))
3148 return 0; 3153 return 0;
3149 3154
3150 start = ((loff_t)cpos) << OCFS2_SB(sb !! 3155 offset = ((loff_t)cpos) << OCFS2_SB(sb)->s_clustersize_bits;
3151 end = start + (num_clusters << OCFS2_ !! 3156 end = offset + (num_clusters << OCFS2_SB(sb)->s_clustersize_bits);
3152 3157
3153 ret = filemap_write_and_wait_range(in !! 3158 ret = filemap_fdatawrite_range(inode->i_mapping,
3154 if (ret < 0) !! 3159 offset, end - 1);
>> 3160 if (ret < 0) {
3155 mlog_errno(ret); 3161 mlog_errno(ret);
>> 3162 return ret;
>> 3163 }
>> 3164
>> 3165 while (offset < end) {
>> 3166 page_index = offset >> PAGE_SHIFT;
>> 3167 map_end = ((loff_t)page_index + 1) << PAGE_SHIFT;
>> 3168 if (map_end > end)
>> 3169 map_end = end;
>> 3170
>> 3171 page = find_or_create_page(inode->i_mapping,
>> 3172 page_index, GFP_NOFS);
>> 3173 BUG_ON(!page);
>> 3174
>> 3175 wait_on_page_writeback(page);
>> 3176 if (PageError(page)) {
>> 3177 ret = -EIO;
>> 3178 mlog_errno(ret);
>> 3179 } else
>> 3180 mark_page_accessed(page);
>> 3181
>> 3182 unlock_page(page);
>> 3183 put_page(page);
>> 3184 page = NULL;
>> 3185 offset = map_end;
>> 3186 if (ret)
>> 3187 break;
>> 3188 }
3156 3189
3157 return ret; 3190 return ret;
3158 } 3191 }
3159 3192
3160 static int ocfs2_di_get_clusters(struct ocfs2 3193 static int ocfs2_di_get_clusters(struct ocfs2_cow_context *context,
3161 u32 v_cluste 3194 u32 v_cluster, u32 *p_cluster,
3162 u32 *num_clu 3195 u32 *num_clusters,
3163 unsigned int 3196 unsigned int *extent_flags)
3164 { 3197 {
3165 return ocfs2_get_clusters(context->in 3198 return ocfs2_get_clusters(context->inode, v_cluster, p_cluster,
3166 num_cluster 3199 num_clusters, extent_flags);
3167 } 3200 }
3168 3201
3169 static int ocfs2_make_clusters_writable(struc 3202 static int ocfs2_make_clusters_writable(struct super_block *sb,
3170 struc 3203 struct ocfs2_cow_context *context,
3171 u32 c 3204 u32 cpos, u32 p_cluster,
3172 u32 n 3205 u32 num_clusters, unsigned int e_flags)
3173 { 3206 {
3174 int ret, delete, index, credits = 0; 3207 int ret, delete, index, credits = 0;
3175 u32 new_bit, new_len, orig_num_cluste 3208 u32 new_bit, new_len, orig_num_clusters;
3176 unsigned int set_len; 3209 unsigned int set_len;
3177 struct ocfs2_super *osb = OCFS2_SB(sb 3210 struct ocfs2_super *osb = OCFS2_SB(sb);
3178 handle_t *handle; 3211 handle_t *handle;
3179 struct buffer_head *ref_leaf_bh = NUL 3212 struct buffer_head *ref_leaf_bh = NULL;
3180 struct ocfs2_caching_info *ref_ci = & 3213 struct ocfs2_caching_info *ref_ci = &context->ref_tree->rf_ci;
3181 struct ocfs2_refcount_rec rec; 3214 struct ocfs2_refcount_rec rec;
3182 3215
3183 trace_ocfs2_make_clusters_writable(cp 3216 trace_ocfs2_make_clusters_writable(cpos, p_cluster,
3184 nu 3217 num_clusters, e_flags);
3185 3218
3186 ret = ocfs2_lock_refcount_allocators( 3219 ret = ocfs2_lock_refcount_allocators(sb, p_cluster, num_clusters,
3187 3220 &context->data_et,
3188 3221 ref_ci,
3189 3222 context->ref_root_bh,
3190 3223 &context->meta_ac,
3191 3224 &context->data_ac, &credits);
3192 if (ret) { 3225 if (ret) {
3193 mlog_errno(ret); 3226 mlog_errno(ret);
3194 return ret; 3227 return ret;
3195 } 3228 }
3196 3229
3197 if (context->post_refcount) 3230 if (context->post_refcount)
3198 credits += context->post_refc 3231 credits += context->post_refcount->credits;
3199 3232
3200 credits += context->extra_credits; 3233 credits += context->extra_credits;
3201 handle = ocfs2_start_trans(osb, credi 3234 handle = ocfs2_start_trans(osb, credits);
3202 if (IS_ERR(handle)) { 3235 if (IS_ERR(handle)) {
3203 ret = PTR_ERR(handle); 3236 ret = PTR_ERR(handle);
3204 mlog_errno(ret); 3237 mlog_errno(ret);
3205 goto out; 3238 goto out;
3206 } 3239 }
3207 3240
3208 orig_num_clusters = num_clusters; 3241 orig_num_clusters = num_clusters;
3209 3242
3210 while (num_clusters) { 3243 while (num_clusters) {
3211 ret = ocfs2_get_refcount_rec( 3244 ret = ocfs2_get_refcount_rec(ref_ci, context->ref_root_bh,
3212 3245 p_cluster, num_clusters,
3213 3246 &rec, &index, &ref_leaf_bh);
3214 if (ret) { 3247 if (ret) {
3215 mlog_errno(ret); 3248 mlog_errno(ret);
3216 goto out_commit; 3249 goto out_commit;
3217 } 3250 }
3218 3251
3219 BUG_ON(!rec.r_refcount); 3252 BUG_ON(!rec.r_refcount);
3220 set_len = min((u64)p_cluster 3253 set_len = min((u64)p_cluster + num_clusters,
3221 le64_to_cpu(rec 3254 le64_to_cpu(rec.r_cpos) +
3222 le32_to_cpu(rec 3255 le32_to_cpu(rec.r_clusters)) - p_cluster;
3223 3256
3224 /* 3257 /*
3225 * There are many different s 3258 * There are many different situation here.
3226 * 1. If refcount == 1, remov 3259 * 1. If refcount == 1, remove the flag and don't COW.
3227 * 2. If refcount > 1, alloca 3260 * 2. If refcount > 1, allocate clusters.
3228 * Here we may not allocat 3261 * Here we may not allocate r_len once at a time, so continue
3229 * until we reach num_clus 3262 * until we reach num_clusters.
3230 */ 3263 */
3231 if (le32_to_cpu(rec.r_refcoun 3264 if (le32_to_cpu(rec.r_refcount) == 1) {
3232 delete = 0; 3265 delete = 0;
3233 ret = ocfs2_clear_ext 3266 ret = ocfs2_clear_ext_refcount(handle,
3234 3267 &context->data_et,
3235 3268 cpos, p_cluster,
3236 3269 set_len, e_flags,
3237 3270 context->meta_ac,
3238 3271 &context->dealloc);
3239 if (ret) { 3272 if (ret) {
3240 mlog_errno(re 3273 mlog_errno(ret);
3241 goto out_comm 3274 goto out_commit;
3242 } 3275 }
3243 } else { 3276 } else {
3244 delete = 1; 3277 delete = 1;
3245 3278
3246 ret = __ocfs2_claim_c 3279 ret = __ocfs2_claim_clusters(handle,
3247 3280 context->data_ac,
3248 3281 1, set_len,
3249 3282 &new_bit, &new_len);
3250 if (ret) { 3283 if (ret) {
3251 mlog_errno(re 3284 mlog_errno(ret);
3252 goto out_comm 3285 goto out_commit;
3253 } 3286 }
3254 3287
3255 ret = ocfs2_replace_c 3288 ret = ocfs2_replace_clusters(handle, context,
3256 3289 cpos, p_cluster, new_bit,
3257 3290 new_len, e_flags);
3258 if (ret) { 3291 if (ret) {
3259 mlog_errno(re 3292 mlog_errno(ret);
3260 goto out_comm 3293 goto out_commit;
3261 } 3294 }
3262 set_len = new_len; 3295 set_len = new_len;
3263 } 3296 }
3264 3297
3265 ret = __ocfs2_decrease_refcou 3298 ret = __ocfs2_decrease_refcount(handle, ref_ci,
3266 3299 context->ref_root_bh,
3267 3300 p_cluster, set_len,
3268 3301 context->meta_ac,
3269 3302 &context->dealloc, delete);
3270 if (ret) { 3303 if (ret) {
3271 mlog_errno(ret); 3304 mlog_errno(ret);
3272 goto out_commit; 3305 goto out_commit;
3273 } 3306 }
3274 3307
3275 cpos += set_len; 3308 cpos += set_len;
3276 p_cluster += set_len; 3309 p_cluster += set_len;
3277 num_clusters -= set_len; 3310 num_clusters -= set_len;
3278 brelse(ref_leaf_bh); 3311 brelse(ref_leaf_bh);
3279 ref_leaf_bh = NULL; 3312 ref_leaf_bh = NULL;
3280 } 3313 }
3281 3314
3282 /* handle any post_cow action. */ 3315 /* handle any post_cow action. */
3283 if (context->post_refcount && context 3316 if (context->post_refcount && context->post_refcount->func) {
3284 ret = context->post_refcount- 3317 ret = context->post_refcount->func(context->inode, handle,
3285 3318 context->post_refcount->para);
3286 if (ret) { 3319 if (ret) {
3287 mlog_errno(ret); 3320 mlog_errno(ret);
3288 goto out_commit; 3321 goto out_commit;
3289 } 3322 }
3290 } 3323 }
3291 3324
3292 /* 3325 /*
3293 * Here we should write the new page 3326 * Here we should write the new page out first if we are
3294 * in write-back mode. 3327 * in write-back mode.
3295 */ 3328 */
3296 if (context->get_clusters == ocfs2_di 3329 if (context->get_clusters == ocfs2_di_get_clusters) {
3297 ret = ocfs2_cow_sync_writebac 3330 ret = ocfs2_cow_sync_writeback(sb, context->inode, cpos,
3298 3331 orig_num_clusters);
3299 if (ret) 3332 if (ret)
3300 mlog_errno(ret); 3333 mlog_errno(ret);
3301 } 3334 }
3302 3335
3303 out_commit: 3336 out_commit:
3304 ocfs2_commit_trans(osb, handle); 3337 ocfs2_commit_trans(osb, handle);
3305 3338
3306 out: 3339 out:
3307 if (context->data_ac) { 3340 if (context->data_ac) {
3308 ocfs2_free_alloc_context(cont 3341 ocfs2_free_alloc_context(context->data_ac);
3309 context->data_ac = NULL; 3342 context->data_ac = NULL;
3310 } 3343 }
3311 if (context->meta_ac) { 3344 if (context->meta_ac) {
3312 ocfs2_free_alloc_context(cont 3345 ocfs2_free_alloc_context(context->meta_ac);
3313 context->meta_ac = NULL; 3346 context->meta_ac = NULL;
3314 } 3347 }
3315 brelse(ref_leaf_bh); 3348 brelse(ref_leaf_bh);
3316 3349
3317 return ret; 3350 return ret;
3318 } 3351 }
3319 3352
3320 static int ocfs2_replace_cow(struct ocfs2_cow 3353 static int ocfs2_replace_cow(struct ocfs2_cow_context *context)
3321 { 3354 {
3322 int ret = 0; 3355 int ret = 0;
3323 struct inode *inode = context->inode; 3356 struct inode *inode = context->inode;
3324 u32 cow_start = context->cow_start, c 3357 u32 cow_start = context->cow_start, cow_len = context->cow_len;
3325 u32 p_cluster, num_clusters; 3358 u32 p_cluster, num_clusters;
3326 unsigned int ext_flags; 3359 unsigned int ext_flags;
3327 struct ocfs2_super *osb = OCFS2_SB(in 3360 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
3328 3361
3329 if (!ocfs2_refcount_tree(osb)) { 3362 if (!ocfs2_refcount_tree(osb)) {
3330 return ocfs2_error(inode->i_s 3363 return ocfs2_error(inode->i_sb, "Inode %lu want to use refcount tree, but the feature bit is not set in the super block\n",
3331 inode->i_i 3364 inode->i_ino);
3332 } 3365 }
3333 3366
3334 ocfs2_init_dealloc_ctxt(&context->dea 3367 ocfs2_init_dealloc_ctxt(&context->dealloc);
3335 3368
3336 while (cow_len) { 3369 while (cow_len) {
3337 ret = context->get_clusters(c 3370 ret = context->get_clusters(context, cow_start, &p_cluster,
3338 & 3371 &num_clusters, &ext_flags);
3339 if (ret) { 3372 if (ret) {
3340 mlog_errno(ret); 3373 mlog_errno(ret);
3341 break; 3374 break;
3342 } 3375 }
3343 3376
3344 BUG_ON(!(ext_flags & OCFS2_EX 3377 BUG_ON(!(ext_flags & OCFS2_EXT_REFCOUNTED));
3345 3378
3346 if (cow_len < num_clusters) 3379 if (cow_len < num_clusters)
3347 num_clusters = cow_le 3380 num_clusters = cow_len;
3348 3381
3349 ret = ocfs2_make_clusters_wri 3382 ret = ocfs2_make_clusters_writable(inode->i_sb, context,
3350 3383 cow_start, p_cluster,
3351 3384 num_clusters, ext_flags);
3352 if (ret) { 3385 if (ret) {
3353 mlog_errno(ret); 3386 mlog_errno(ret);
3354 break; 3387 break;
3355 } 3388 }
3356 3389
3357 cow_len -= num_clusters; 3390 cow_len -= num_clusters;
3358 cow_start += num_clusters; 3391 cow_start += num_clusters;
3359 } 3392 }
3360 3393
3361 if (ocfs2_dealloc_has_cluster(&contex 3394 if (ocfs2_dealloc_has_cluster(&context->dealloc)) {
3362 ocfs2_schedule_truncate_log_f 3395 ocfs2_schedule_truncate_log_flush(osb, 1);
3363 ocfs2_run_deallocs(osb, &cont 3396 ocfs2_run_deallocs(osb, &context->dealloc);
3364 } 3397 }
3365 3398
3366 return ret; 3399 return ret;
3367 } 3400 }
3368 3401
3369 /* 3402 /*
3370 * Starting at cpos, try to CoW write_len clu 3403 * Starting at cpos, try to CoW write_len clusters. Don't CoW
3371 * past max_cpos. This will stop when it run 3404 * past max_cpos. This will stop when it runs into a hole or an
3372 * unrefcounted extent. 3405 * unrefcounted extent.
3373 */ 3406 */
3374 static int ocfs2_refcount_cow_hunk(struct ino 3407 static int ocfs2_refcount_cow_hunk(struct inode *inode,
3375 struct buf 3408 struct buffer_head *di_bh,
3376 u32 cpos, 3409 u32 cpos, u32 write_len, u32 max_cpos)
3377 { 3410 {
3378 int ret; 3411 int ret;
3379 u32 cow_start = 0, cow_len = 0; 3412 u32 cow_start = 0, cow_len = 0;
3380 struct ocfs2_super *osb = OCFS2_SB(in 3413 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
3381 struct ocfs2_dinode *di = (struct ocf 3414 struct ocfs2_dinode *di = (struct ocfs2_dinode *)di_bh->b_data;
3382 struct buffer_head *ref_root_bh = NUL 3415 struct buffer_head *ref_root_bh = NULL;
3383 struct ocfs2_refcount_tree *ref_tree; 3416 struct ocfs2_refcount_tree *ref_tree;
3384 struct ocfs2_cow_context *context = N 3417 struct ocfs2_cow_context *context = NULL;
3385 3418
3386 BUG_ON(!ocfs2_is_refcount_inode(inode 3419 BUG_ON(!ocfs2_is_refcount_inode(inode));
3387 3420
3388 ret = ocfs2_refcount_cal_cow_clusters 3421 ret = ocfs2_refcount_cal_cow_clusters(inode, &di->id2.i_list,
3389 3422 cpos, write_len, max_cpos,
3390 3423 &cow_start, &cow_len);
3391 if (ret) { 3424 if (ret) {
3392 mlog_errno(ret); 3425 mlog_errno(ret);
3393 goto out; 3426 goto out;
3394 } 3427 }
3395 3428
3396 trace_ocfs2_refcount_cow_hunk(OCFS2_I 3429 trace_ocfs2_refcount_cow_hunk(OCFS2_I(inode)->ip_blkno,
3397 cpos, w 3430 cpos, write_len, max_cpos,
3398 cow_sta 3431 cow_start, cow_len);
3399 3432
3400 BUG_ON(cow_len == 0); 3433 BUG_ON(cow_len == 0);
3401 3434
3402 context = kzalloc(sizeof(struct ocfs2 3435 context = kzalloc(sizeof(struct ocfs2_cow_context), GFP_NOFS);
3403 if (!context) { 3436 if (!context) {
3404 ret = -ENOMEM; 3437 ret = -ENOMEM;
3405 mlog_errno(ret); 3438 mlog_errno(ret);
3406 goto out; 3439 goto out;
3407 } 3440 }
3408 3441
3409 ret = ocfs2_lock_refcount_tree(osb, l 3442 ret = ocfs2_lock_refcount_tree(osb, le64_to_cpu(di->i_refcount_loc),
3410 1, &re 3443 1, &ref_tree, &ref_root_bh);
3411 if (ret) { 3444 if (ret) {
3412 mlog_errno(ret); 3445 mlog_errno(ret);
3413 goto out; 3446 goto out;
3414 } 3447 }
3415 3448
3416 context->inode = inode; 3449 context->inode = inode;
3417 context->cow_start = cow_start; 3450 context->cow_start = cow_start;
3418 context->cow_len = cow_len; 3451 context->cow_len = cow_len;
3419 context->ref_tree = ref_tree; 3452 context->ref_tree = ref_tree;
3420 context->ref_root_bh = ref_root_bh; 3453 context->ref_root_bh = ref_root_bh;
3421 context->cow_duplicate_clusters = ocf 3454 context->cow_duplicate_clusters = ocfs2_duplicate_clusters_by_page;
3422 context->get_clusters = ocfs2_di_get_ 3455 context->get_clusters = ocfs2_di_get_clusters;
3423 3456
3424 ocfs2_init_dinode_extent_tree(&contex 3457 ocfs2_init_dinode_extent_tree(&context->data_et,
3425 INODE_C 3458 INODE_CACHE(inode), di_bh);
3426 3459
3427 ret = ocfs2_replace_cow(context); 3460 ret = ocfs2_replace_cow(context);
3428 if (ret) 3461 if (ret)
3429 mlog_errno(ret); 3462 mlog_errno(ret);
3430 3463
3431 /* 3464 /*
3432 * truncate the extent map here since 3465 * truncate the extent map here since no matter whether we meet with
3433 * any error during the action, we sh 3466 * any error during the action, we shouldn't trust cached extent map
3434 * any more. 3467 * any more.
3435 */ 3468 */
3436 ocfs2_extent_map_trunc(inode, cow_sta 3469 ocfs2_extent_map_trunc(inode, cow_start);
3437 3470
3438 ocfs2_unlock_refcount_tree(osb, ref_t 3471 ocfs2_unlock_refcount_tree(osb, ref_tree, 1);
3439 brelse(ref_root_bh); 3472 brelse(ref_root_bh);
3440 out: 3473 out:
3441 kfree(context); 3474 kfree(context);
3442 return ret; 3475 return ret;
3443 } 3476 }
3444 3477
3445 /* 3478 /*
3446 * CoW any and all clusters between cpos and 3479 * CoW any and all clusters between cpos and cpos+write_len.
3447 * Don't CoW past max_cpos. If this returns 3480 * Don't CoW past max_cpos. If this returns successfully, all
3448 * clusters between cpos and cpos+write_len a 3481 * clusters between cpos and cpos+write_len are safe to modify.
3449 */ 3482 */
3450 int ocfs2_refcount_cow(struct inode *inode, 3483 int ocfs2_refcount_cow(struct inode *inode,
3451 struct buffer_head *di 3484 struct buffer_head *di_bh,
3452 u32 cpos, u32 write_le 3485 u32 cpos, u32 write_len, u32 max_cpos)
3453 { 3486 {
3454 int ret = 0; 3487 int ret = 0;
3455 u32 p_cluster, num_clusters; 3488 u32 p_cluster, num_clusters;
3456 unsigned int ext_flags; 3489 unsigned int ext_flags;
3457 3490
3458 while (write_len) { 3491 while (write_len) {
3459 ret = ocfs2_get_clusters(inod 3492 ret = ocfs2_get_clusters(inode, cpos, &p_cluster,
3460 &num 3493 &num_clusters, &ext_flags);
3461 if (ret) { 3494 if (ret) {
3462 mlog_errno(ret); 3495 mlog_errno(ret);
3463 break; 3496 break;
3464 } 3497 }
3465 3498
3466 if (write_len < num_clusters) 3499 if (write_len < num_clusters)
3467 num_clusters = write_ 3500 num_clusters = write_len;
3468 3501
3469 if (ext_flags & OCFS2_EXT_REF 3502 if (ext_flags & OCFS2_EXT_REFCOUNTED) {
3470 ret = ocfs2_refcount_ 3503 ret = ocfs2_refcount_cow_hunk(inode, di_bh, cpos,
3471 3504 num_clusters, max_cpos);
3472 if (ret) { 3505 if (ret) {
3473 mlog_errno(re 3506 mlog_errno(ret);
3474 break; 3507 break;
3475 } 3508 }
3476 } 3509 }
3477 3510
3478 write_len -= num_clusters; 3511 write_len -= num_clusters;
3479 cpos += num_clusters; 3512 cpos += num_clusters;
3480 } 3513 }
3481 3514
3482 return ret; 3515 return ret;
3483 } 3516 }
3484 3517
3485 static int ocfs2_xattr_value_get_clusters(str 3518 static int ocfs2_xattr_value_get_clusters(struct ocfs2_cow_context *context,
3486 u32 3519 u32 v_cluster, u32 *p_cluster,
3487 u32 3520 u32 *num_clusters,
3488 uns 3521 unsigned int *extent_flags)
3489 { 3522 {
3490 struct inode *inode = context->inode; 3523 struct inode *inode = context->inode;
3491 struct ocfs2_xattr_value_root *xv = c 3524 struct ocfs2_xattr_value_root *xv = context->cow_object;
3492 3525
3493 return ocfs2_xattr_get_clusters(inode 3526 return ocfs2_xattr_get_clusters(inode, v_cluster, p_cluster,
3494 num_c 3527 num_clusters, &xv->xr_list,
3495 exten 3528 extent_flags);
3496 } 3529 }
3497 3530
3498 /* 3531 /*
3499 * Given a xattr value root, calculate the mo 3532 * Given a xattr value root, calculate the most meta/credits we need for
3500 * refcount tree change if we truncate it to 3533 * refcount tree change if we truncate it to 0.
3501 */ 3534 */
3502 int ocfs2_refcounted_xattr_delete_need(struct 3535 int ocfs2_refcounted_xattr_delete_need(struct inode *inode,
3503 struct 3536 struct ocfs2_caching_info *ref_ci,
3504 struct 3537 struct buffer_head *ref_root_bh,
3505 struct 3538 struct ocfs2_xattr_value_root *xv,
3506 int *m 3539 int *meta_add, int *credits)
3507 { 3540 {
3508 int ret = 0, index, ref_blocks = 0; 3541 int ret = 0, index, ref_blocks = 0;
3509 u32 p_cluster, num_clusters; 3542 u32 p_cluster, num_clusters;
3510 u32 cpos = 0, clusters = le32_to_cpu( 3543 u32 cpos = 0, clusters = le32_to_cpu(xv->xr_clusters);
3511 struct ocfs2_refcount_block *rb; 3544 struct ocfs2_refcount_block *rb;
3512 struct ocfs2_refcount_rec rec; 3545 struct ocfs2_refcount_rec rec;
3513 struct buffer_head *ref_leaf_bh = NUL 3546 struct buffer_head *ref_leaf_bh = NULL;
3514 3547
3515 while (cpos < clusters) { 3548 while (cpos < clusters) {
3516 ret = ocfs2_xattr_get_cluster 3549 ret = ocfs2_xattr_get_clusters(inode, cpos, &p_cluster,
3517 3550 &num_clusters, &xv->xr_list,
3518 3551 NULL);
3519 if (ret) { 3552 if (ret) {
3520 mlog_errno(ret); 3553 mlog_errno(ret);
3521 goto out; 3554 goto out;
3522 } 3555 }
3523 3556
3524 cpos += num_clusters; 3557 cpos += num_clusters;
3525 3558
3526 while (num_clusters) { 3559 while (num_clusters) {
3527 ret = ocfs2_get_refco 3560 ret = ocfs2_get_refcount_rec(ref_ci, ref_root_bh,
3528 3561 p_cluster, num_clusters,
3529 3562 &rec, &index,
3530 3563 &ref_leaf_bh);
3531 if (ret) { 3564 if (ret) {
3532 mlog_errno(re 3565 mlog_errno(ret);
3533 goto out; 3566 goto out;
3534 } 3567 }
3535 3568
3536 BUG_ON(!rec.r_refcoun 3569 BUG_ON(!rec.r_refcount);
3537 3570
3538 rb = (struct ocfs2_re 3571 rb = (struct ocfs2_refcount_block *)ref_leaf_bh->b_data;
3539 3572
3540 /* 3573 /*
3541 * We really don't kn 3574 * We really don't know whether the other clusters is in
3542 * this refcount bloc 3575 * this refcount block or not, so just take the worst
3543 * case that all the 3576 * case that all the clusters are in this block and each
3544 * one will split a r 3577 * one will split a refcount rec, so totally we need
3545 * clusters * 2 new r 3578 * clusters * 2 new refcount rec.
3546 */ 3579 */
3547 if (le16_to_cpu(rb->r 3580 if (le16_to_cpu(rb->rf_records.rl_used) + clusters * 2 >
3548 le16_to_cpu(rb->r 3581 le16_to_cpu(rb->rf_records.rl_count))
3549 ref_blocks++; 3582 ref_blocks++;
3550 3583
3551 *credits += 1; 3584 *credits += 1;
3552 brelse(ref_leaf_bh); 3585 brelse(ref_leaf_bh);
3553 ref_leaf_bh = NULL; 3586 ref_leaf_bh = NULL;
3554 3587
3555 if (num_clusters <= l 3588 if (num_clusters <= le32_to_cpu(rec.r_clusters))
3556 break; 3589 break;
3557 else 3590 else
3558 num_clusters 3591 num_clusters -= le32_to_cpu(rec.r_clusters);
3559 p_cluster += num_clus 3592 p_cluster += num_clusters;
3560 } 3593 }
3561 } 3594 }
3562 3595
3563 *meta_add += ref_blocks; 3596 *meta_add += ref_blocks;
3564 if (!ref_blocks) 3597 if (!ref_blocks)
3565 goto out; 3598 goto out;
3566 3599
3567 rb = (struct ocfs2_refcount_block *)r 3600 rb = (struct ocfs2_refcount_block *)ref_root_bh->b_data;
3568 if (le32_to_cpu(rb->rf_flags) & OCFS2 3601 if (le32_to_cpu(rb->rf_flags) & OCFS2_REFCOUNT_TREE_FL)
3569 *credits += OCFS2_EXPAND_REFC 3602 *credits += OCFS2_EXPAND_REFCOUNT_TREE_CREDITS;
3570 else { 3603 else {
3571 struct ocfs2_extent_tree et; 3604 struct ocfs2_extent_tree et;
3572 3605
3573 ocfs2_init_refcount_extent_tr 3606 ocfs2_init_refcount_extent_tree(&et, ref_ci, ref_root_bh);
3574 *credits += ocfs2_calc_extend 3607 *credits += ocfs2_calc_extend_credits(inode->i_sb,
3575 3608 et.et_root_el);
3576 } 3609 }
3577 3610
3578 out: 3611 out:
3579 brelse(ref_leaf_bh); 3612 brelse(ref_leaf_bh);
3580 return ret; 3613 return ret;
3581 } 3614 }
3582 3615
3583 /* 3616 /*
3584 * Do CoW for xattr. 3617 * Do CoW for xattr.
3585 */ 3618 */
3586 int ocfs2_refcount_cow_xattr(struct inode *in 3619 int ocfs2_refcount_cow_xattr(struct inode *inode,
3587 struct ocfs2_din 3620 struct ocfs2_dinode *di,
3588 struct ocfs2_xat 3621 struct ocfs2_xattr_value_buf *vb,
3589 struct ocfs2_ref 3622 struct ocfs2_refcount_tree *ref_tree,
3590 struct buffer_he 3623 struct buffer_head *ref_root_bh,
3591 u32 cpos, u32 wr 3624 u32 cpos, u32 write_len,
3592 struct ocfs2_pos 3625 struct ocfs2_post_refcount *post)
3593 { 3626 {
3594 int ret; 3627 int ret;
3595 struct ocfs2_xattr_value_root *xv = v 3628 struct ocfs2_xattr_value_root *xv = vb->vb_xv;
3596 struct ocfs2_cow_context *context = N 3629 struct ocfs2_cow_context *context = NULL;
3597 u32 cow_start, cow_len; 3630 u32 cow_start, cow_len;
3598 3631
3599 BUG_ON(!ocfs2_is_refcount_inode(inode 3632 BUG_ON(!ocfs2_is_refcount_inode(inode));
3600 3633
3601 ret = ocfs2_refcount_cal_cow_clusters 3634 ret = ocfs2_refcount_cal_cow_clusters(inode, &xv->xr_list,
3602 3635 cpos, write_len, UINT_MAX,
3603 3636 &cow_start, &cow_len);
3604 if (ret) { 3637 if (ret) {
3605 mlog_errno(ret); 3638 mlog_errno(ret);
3606 goto out; 3639 goto out;
3607 } 3640 }
3608 3641
3609 BUG_ON(cow_len == 0); 3642 BUG_ON(cow_len == 0);
3610 3643
3611 context = kzalloc(sizeof(struct ocfs2 3644 context = kzalloc(sizeof(struct ocfs2_cow_context), GFP_NOFS);
3612 if (!context) { 3645 if (!context) {
3613 ret = -ENOMEM; 3646 ret = -ENOMEM;
3614 mlog_errno(ret); 3647 mlog_errno(ret);
3615 goto out; 3648 goto out;
3616 } 3649 }
3617 3650
3618 context->inode = inode; 3651 context->inode = inode;
3619 context->cow_start = cow_start; 3652 context->cow_start = cow_start;
3620 context->cow_len = cow_len; 3653 context->cow_len = cow_len;
3621 context->ref_tree = ref_tree; 3654 context->ref_tree = ref_tree;
3622 context->ref_root_bh = ref_root_bh; 3655 context->ref_root_bh = ref_root_bh;
3623 context->cow_object = xv; 3656 context->cow_object = xv;
3624 3657
3625 context->cow_duplicate_clusters = ocf 3658 context->cow_duplicate_clusters = ocfs2_duplicate_clusters_by_jbd;
3626 /* We need the extra credits for dupl 3659 /* We need the extra credits for duplicate_clusters by jbd. */
3627 context->extra_credits = 3660 context->extra_credits =
3628 ocfs2_clusters_to_blocks(inod 3661 ocfs2_clusters_to_blocks(inode->i_sb, 1) * cow_len;
3629 context->get_clusters = ocfs2_xattr_v 3662 context->get_clusters = ocfs2_xattr_value_get_clusters;
3630 context->post_refcount = post; 3663 context->post_refcount = post;
3631 3664
3632 ocfs2_init_xattr_value_extent_tree(&c 3665 ocfs2_init_xattr_value_extent_tree(&context->data_et,
3633 IN 3666 INODE_CACHE(inode), vb);
3634 3667
3635 ret = ocfs2_replace_cow(context); 3668 ret = ocfs2_replace_cow(context);
3636 if (ret) 3669 if (ret)
3637 mlog_errno(ret); 3670 mlog_errno(ret);
3638 3671
3639 out: 3672 out:
3640 kfree(context); 3673 kfree(context);
3641 return ret; 3674 return ret;
3642 } 3675 }
3643 3676
3644 /* 3677 /*
3645 * Insert a new extent into refcount tree and 3678 * Insert a new extent into refcount tree and mark a extent rec
3646 * as refcounted in the dinode tree. 3679 * as refcounted in the dinode tree.
3647 */ 3680 */
3648 int ocfs2_add_refcount_flag(struct inode *ino 3681 int ocfs2_add_refcount_flag(struct inode *inode,
3649 struct ocfs2_exte 3682 struct ocfs2_extent_tree *data_et,
3650 struct ocfs2_cach 3683 struct ocfs2_caching_info *ref_ci,
3651 struct buffer_hea 3684 struct buffer_head *ref_root_bh,
3652 u32 cpos, u32 p_c 3685 u32 cpos, u32 p_cluster, u32 num_clusters,
3653 struct ocfs2_cach 3686 struct ocfs2_cached_dealloc_ctxt *dealloc,
3654 struct ocfs2_post 3687 struct ocfs2_post_refcount *post)
3655 { 3688 {
3656 int ret; 3689 int ret;
3657 handle_t *handle; 3690 handle_t *handle;
3658 int credits = 1, ref_blocks = 0; 3691 int credits = 1, ref_blocks = 0;
3659 struct ocfs2_super *osb = OCFS2_SB(in 3692 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
3660 struct ocfs2_alloc_context *meta_ac = 3693 struct ocfs2_alloc_context *meta_ac = NULL;
3661 3694
3662 /* We need to be able to handle at le 3695 /* We need to be able to handle at least an extent tree split. */
3663 ref_blocks = ocfs2_extend_meta_needed 3696 ref_blocks = ocfs2_extend_meta_needed(data_et->et_root_el);
3664 3697
3665 ret = ocfs2_calc_refcount_meta_credit 3698 ret = ocfs2_calc_refcount_meta_credits(inode->i_sb,
3666 3699 ref_ci, ref_root_bh,
3667 3700 p_cluster, num_clusters,
3668 3701 &ref_blocks, &credits);
3669 if (ret) { 3702 if (ret) {
3670 mlog_errno(ret); 3703 mlog_errno(ret);
3671 goto out; 3704 goto out;
3672 } 3705 }
3673 3706
3674 trace_ocfs2_add_refcount_flag(ref_blo 3707 trace_ocfs2_add_refcount_flag(ref_blocks, credits);
3675 3708
3676 if (ref_blocks) { 3709 if (ref_blocks) {
3677 ret = ocfs2_reserve_new_metad 3710 ret = ocfs2_reserve_new_metadata_blocks(osb,
3678 3711 ref_blocks, &meta_ac);
3679 if (ret) { 3712 if (ret) {
3680 mlog_errno(ret); 3713 mlog_errno(ret);
3681 goto out; 3714 goto out;
3682 } 3715 }
3683 } 3716 }
3684 3717
3685 if (post) 3718 if (post)
3686 credits += post->credits; 3719 credits += post->credits;
3687 3720
3688 handle = ocfs2_start_trans(osb, credi 3721 handle = ocfs2_start_trans(osb, credits);
3689 if (IS_ERR(handle)) { 3722 if (IS_ERR(handle)) {
3690 ret = PTR_ERR(handle); 3723 ret = PTR_ERR(handle);
3691 mlog_errno(ret); 3724 mlog_errno(ret);
3692 goto out; 3725 goto out;
3693 } 3726 }
3694 3727
3695 ret = ocfs2_mark_extent_refcounted(in 3728 ret = ocfs2_mark_extent_refcounted(inode, data_et, handle,
3696 cp 3729 cpos, num_clusters, p_cluster,
3697 me 3730 meta_ac, dealloc);
3698 if (ret) { 3731 if (ret) {
3699 mlog_errno(ret); 3732 mlog_errno(ret);
3700 goto out_commit; 3733 goto out_commit;
3701 } 3734 }
3702 3735
3703 ret = __ocfs2_increase_refcount(handl 3736 ret = __ocfs2_increase_refcount(handle, ref_ci, ref_root_bh,
3704 p_clu 3737 p_cluster, num_clusters, 0,
3705 meta_ 3738 meta_ac, dealloc);
3706 if (ret) { 3739 if (ret) {
3707 mlog_errno(ret); 3740 mlog_errno(ret);
3708 goto out_commit; 3741 goto out_commit;
3709 } 3742 }
3710 3743
3711 if (post && post->func) { 3744 if (post && post->func) {
3712 ret = post->func(inode, handl 3745 ret = post->func(inode, handle, post->para);
3713 if (ret) 3746 if (ret)
3714 mlog_errno(ret); 3747 mlog_errno(ret);
3715 } 3748 }
3716 3749
3717 out_commit: 3750 out_commit:
3718 ocfs2_commit_trans(osb, handle); 3751 ocfs2_commit_trans(osb, handle);
3719 out: 3752 out:
3720 if (meta_ac) 3753 if (meta_ac)
3721 ocfs2_free_alloc_context(meta 3754 ocfs2_free_alloc_context(meta_ac);
3722 return ret; 3755 return ret;
3723 } 3756 }
3724 3757
3725 static int ocfs2_change_ctime(struct inode *i 3758 static int ocfs2_change_ctime(struct inode *inode,
3726 struct buffer_h 3759 struct buffer_head *di_bh)
3727 { 3760 {
3728 int ret; 3761 int ret;
3729 handle_t *handle; 3762 handle_t *handle;
3730 struct ocfs2_dinode *di = (struct ocf 3763 struct ocfs2_dinode *di = (struct ocfs2_dinode *)di_bh->b_data;
3731 3764
3732 handle = ocfs2_start_trans(OCFS2_SB(i 3765 handle = ocfs2_start_trans(OCFS2_SB(inode->i_sb),
3733 OCFS2_INOD 3766 OCFS2_INODE_UPDATE_CREDITS);
3734 if (IS_ERR(handle)) { 3767 if (IS_ERR(handle)) {
3735 ret = PTR_ERR(handle); 3768 ret = PTR_ERR(handle);
3736 mlog_errno(ret); 3769 mlog_errno(ret);
3737 goto out; 3770 goto out;
3738 } 3771 }
3739 3772
3740 ret = ocfs2_journal_access_di(handle, 3773 ret = ocfs2_journal_access_di(handle, INODE_CACHE(inode), di_bh,
3741 OCFS2_J 3774 OCFS2_JOURNAL_ACCESS_WRITE);
3742 if (ret) { 3775 if (ret) {
3743 mlog_errno(ret); 3776 mlog_errno(ret);
3744 goto out_commit; 3777 goto out_commit;
3745 } 3778 }
3746 3779
3747 inode_set_ctime_current(inode); !! 3780 inode->i_ctime = current_time(inode);
3748 di->i_ctime = cpu_to_le64(inode_get_c !! 3781 di->i_ctime = cpu_to_le64(inode->i_ctime.tv_sec);
3749 di->i_ctime_nsec = cpu_to_le32(inode_ !! 3782 di->i_ctime_nsec = cpu_to_le32(inode->i_ctime.tv_nsec);
3750 3783
3751 ocfs2_journal_dirty(handle, di_bh); 3784 ocfs2_journal_dirty(handle, di_bh);
3752 3785
3753 out_commit: 3786 out_commit:
3754 ocfs2_commit_trans(OCFS2_SB(inode->i_ 3787 ocfs2_commit_trans(OCFS2_SB(inode->i_sb), handle);
3755 out: 3788 out:
3756 return ret; 3789 return ret;
3757 } 3790 }
3758 3791
3759 static int ocfs2_attach_refcount_tree(struct 3792 static int ocfs2_attach_refcount_tree(struct inode *inode,
3760 struct 3793 struct buffer_head *di_bh)
3761 { 3794 {
3762 int ret, data_changed = 0; 3795 int ret, data_changed = 0;
3763 struct buffer_head *ref_root_bh = NUL 3796 struct buffer_head *ref_root_bh = NULL;
3764 struct ocfs2_inode_info *oi = OCFS2_I 3797 struct ocfs2_inode_info *oi = OCFS2_I(inode);
3765 struct ocfs2_dinode *di = (struct ocf 3798 struct ocfs2_dinode *di = (struct ocfs2_dinode *)di_bh->b_data;
3766 struct ocfs2_super *osb = OCFS2_SB(in 3799 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
3767 struct ocfs2_refcount_tree *ref_tree; 3800 struct ocfs2_refcount_tree *ref_tree;
3768 unsigned int ext_flags; 3801 unsigned int ext_flags;
3769 loff_t size; 3802 loff_t size;
3770 u32 cpos, num_clusters, clusters, p_c 3803 u32 cpos, num_clusters, clusters, p_cluster;
3771 struct ocfs2_cached_dealloc_ctxt deal 3804 struct ocfs2_cached_dealloc_ctxt dealloc;
3772 struct ocfs2_extent_tree di_et; 3805 struct ocfs2_extent_tree di_et;
3773 3806
3774 ocfs2_init_dealloc_ctxt(&dealloc); 3807 ocfs2_init_dealloc_ctxt(&dealloc);
3775 3808
3776 if (!ocfs2_is_refcount_inode(inode)) 3809 if (!ocfs2_is_refcount_inode(inode)) {
3777 ret = ocfs2_create_refcount_t 3810 ret = ocfs2_create_refcount_tree(inode, di_bh);
3778 if (ret) { 3811 if (ret) {
3779 mlog_errno(ret); 3812 mlog_errno(ret);
3780 goto out; 3813 goto out;
3781 } 3814 }
3782 } 3815 }
3783 3816
3784 BUG_ON(!di->i_refcount_loc); 3817 BUG_ON(!di->i_refcount_loc);
3785 ret = ocfs2_lock_refcount_tree(osb, 3818 ret = ocfs2_lock_refcount_tree(osb,
3786 le64_t 3819 le64_to_cpu(di->i_refcount_loc), 1,
3787 &ref_t 3820 &ref_tree, &ref_root_bh);
3788 if (ret) { 3821 if (ret) {
3789 mlog_errno(ret); 3822 mlog_errno(ret);
3790 goto out; 3823 goto out;
3791 } 3824 }
3792 3825
3793 if (oi->ip_dyn_features & OCFS2_INLIN 3826 if (oi->ip_dyn_features & OCFS2_INLINE_DATA_FL)
3794 goto attach_xattr; 3827 goto attach_xattr;
3795 3828
3796 ocfs2_init_dinode_extent_tree(&di_et, 3829 ocfs2_init_dinode_extent_tree(&di_et, INODE_CACHE(inode), di_bh);
3797 3830
3798 size = i_size_read(inode); 3831 size = i_size_read(inode);
3799 clusters = ocfs2_clusters_for_bytes(i 3832 clusters = ocfs2_clusters_for_bytes(inode->i_sb, size);
3800 3833
3801 cpos = 0; 3834 cpos = 0;
3802 while (cpos < clusters) { 3835 while (cpos < clusters) {
3803 ret = ocfs2_get_clusters(inod 3836 ret = ocfs2_get_clusters(inode, cpos, &p_cluster,
3804 &num 3837 &num_clusters, &ext_flags);
3805 if (ret) { 3838 if (ret) {
3806 mlog_errno(ret); 3839 mlog_errno(ret);
3807 goto unlock; 3840 goto unlock;
3808 } 3841 }
3809 if (p_cluster && !(ext_flags 3842 if (p_cluster && !(ext_flags & OCFS2_EXT_REFCOUNTED)) {
3810 ret = ocfs2_add_refco 3843 ret = ocfs2_add_refcount_flag(inode, &di_et,
3811 3844 &ref_tree->rf_ci,
3812 3845 ref_root_bh, cpos,
3813 3846 p_cluster, num_clusters,
3814 3847 &dealloc, NULL);
3815 if (ret) { 3848 if (ret) {
3816 mlog_errno(re 3849 mlog_errno(ret);
3817 goto unlock; 3850 goto unlock;
3818 } 3851 }
3819 3852
3820 data_changed = 1; 3853 data_changed = 1;
3821 } 3854 }
3822 cpos += num_clusters; 3855 cpos += num_clusters;
3823 } 3856 }
3824 3857
3825 attach_xattr: 3858 attach_xattr:
3826 if (oi->ip_dyn_features & OCFS2_HAS_X 3859 if (oi->ip_dyn_features & OCFS2_HAS_XATTR_FL) {
3827 ret = ocfs2_xattr_attach_refc 3860 ret = ocfs2_xattr_attach_refcount_tree(inode, di_bh,
3828 3861 &ref_tree->rf_ci,
3829 3862 ref_root_bh,
3830 3863 &dealloc);
3831 if (ret) { 3864 if (ret) {
3832 mlog_errno(ret); 3865 mlog_errno(ret);
3833 goto unlock; 3866 goto unlock;
3834 } 3867 }
3835 } 3868 }
3836 3869
3837 if (data_changed) { 3870 if (data_changed) {
3838 ret = ocfs2_change_ctime(inod 3871 ret = ocfs2_change_ctime(inode, di_bh);
3839 if (ret) 3872 if (ret)
3840 mlog_errno(ret); 3873 mlog_errno(ret);
3841 } 3874 }
3842 3875
3843 unlock: 3876 unlock:
3844 ocfs2_unlock_refcount_tree(osb, ref_t 3877 ocfs2_unlock_refcount_tree(osb, ref_tree, 1);
3845 brelse(ref_root_bh); 3878 brelse(ref_root_bh);
3846 3879
3847 if (!ret && ocfs2_dealloc_has_cluster 3880 if (!ret && ocfs2_dealloc_has_cluster(&dealloc)) {
3848 ocfs2_schedule_truncate_log_f 3881 ocfs2_schedule_truncate_log_flush(osb, 1);
3849 ocfs2_run_deallocs(osb, &deal 3882 ocfs2_run_deallocs(osb, &dealloc);
3850 } 3883 }
3851 out: 3884 out:
3852 /* 3885 /*
3853 * Empty the extent map so that we ma 3886 * Empty the extent map so that we may get the right extent
3854 * record from the disk. 3887 * record from the disk.
3855 */ 3888 */
3856 ocfs2_extent_map_trunc(inode, 0); 3889 ocfs2_extent_map_trunc(inode, 0);
3857 3890
3858 return ret; 3891 return ret;
3859 } 3892 }
3860 3893
3861 static int ocfs2_add_refcounted_extent(struct 3894 static int ocfs2_add_refcounted_extent(struct inode *inode,
3862 struct ocf 3895 struct ocfs2_extent_tree *et,
3863 struct ocf 3896 struct ocfs2_caching_info *ref_ci,
3864 struct buf 3897 struct buffer_head *ref_root_bh,
3865 u32 cpos, 3898 u32 cpos, u32 p_cluster, u32 num_clusters,
3866 unsigned i 3899 unsigned int ext_flags,
3867 struct ocf 3900 struct ocfs2_cached_dealloc_ctxt *dealloc)
3868 { 3901 {
3869 int ret; 3902 int ret;
3870 handle_t *handle; 3903 handle_t *handle;
3871 int credits = 0; 3904 int credits = 0;
3872 struct ocfs2_super *osb = OCFS2_SB(in 3905 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
3873 struct ocfs2_alloc_context *meta_ac = 3906 struct ocfs2_alloc_context *meta_ac = NULL;
3874 3907
3875 ret = ocfs2_lock_refcount_allocators( 3908 ret = ocfs2_lock_refcount_allocators(inode->i_sb,
3876 3909 p_cluster, num_clusters,
3877 3910 et, ref_ci,
3878 3911 ref_root_bh, &meta_ac,
3879 3912 NULL, &credits);
3880 if (ret) { 3913 if (ret) {
3881 mlog_errno(ret); 3914 mlog_errno(ret);
3882 goto out; 3915 goto out;
3883 } 3916 }
3884 3917
3885 handle = ocfs2_start_trans(osb, credi 3918 handle = ocfs2_start_trans(osb, credits);
3886 if (IS_ERR(handle)) { 3919 if (IS_ERR(handle)) {
3887 ret = PTR_ERR(handle); 3920 ret = PTR_ERR(handle);
3888 mlog_errno(ret); 3921 mlog_errno(ret);
3889 goto out; 3922 goto out;
3890 } 3923 }
3891 3924
3892 ret = ocfs2_insert_extent(handle, et, 3925 ret = ocfs2_insert_extent(handle, et, cpos,
3893 ocfs2_clusters_to_blo 3926 ocfs2_clusters_to_blocks(inode->i_sb, p_cluster),
3894 num_clusters, ext_fla 3927 num_clusters, ext_flags, meta_ac);
3895 if (ret) { 3928 if (ret) {
3896 mlog_errno(ret); 3929 mlog_errno(ret);
3897 goto out_commit; 3930 goto out_commit;
3898 } 3931 }
3899 3932
3900 ret = ocfs2_increase_refcount(handle, 3933 ret = ocfs2_increase_refcount(handle, ref_ci, ref_root_bh,
3901 p_clust 3934 p_cluster, num_clusters,
3902 meta_ac 3935 meta_ac, dealloc);
3903 if (ret) { 3936 if (ret) {
3904 mlog_errno(ret); 3937 mlog_errno(ret);
3905 goto out_commit; 3938 goto out_commit;
3906 } 3939 }
3907 3940
3908 ret = dquot_alloc_space_nodirty(inode 3941 ret = dquot_alloc_space_nodirty(inode,
3909 ocfs2_clusters_to_bytes(osb-> 3942 ocfs2_clusters_to_bytes(osb->sb, num_clusters));
3910 if (ret) 3943 if (ret)
3911 mlog_errno(ret); 3944 mlog_errno(ret);
3912 3945
3913 out_commit: 3946 out_commit:
3914 ocfs2_commit_trans(osb, handle); 3947 ocfs2_commit_trans(osb, handle);
3915 out: 3948 out:
3916 if (meta_ac) 3949 if (meta_ac)
3917 ocfs2_free_alloc_context(meta 3950 ocfs2_free_alloc_context(meta_ac);
3918 return ret; 3951 return ret;
3919 } 3952 }
3920 3953
3921 static int ocfs2_duplicate_inline_data(struct 3954 static int ocfs2_duplicate_inline_data(struct inode *s_inode,
3922 struct 3955 struct buffer_head *s_bh,
3923 struct 3956 struct inode *t_inode,
3924 struct 3957 struct buffer_head *t_bh)
3925 { 3958 {
3926 int ret; 3959 int ret;
3927 handle_t *handle; 3960 handle_t *handle;
3928 struct ocfs2_super *osb = OCFS2_SB(s_ 3961 struct ocfs2_super *osb = OCFS2_SB(s_inode->i_sb);
3929 struct ocfs2_dinode *s_di = (struct o 3962 struct ocfs2_dinode *s_di = (struct ocfs2_dinode *)s_bh->b_data;
3930 struct ocfs2_dinode *t_di = (struct o 3963 struct ocfs2_dinode *t_di = (struct ocfs2_dinode *)t_bh->b_data;
3931 3964
3932 BUG_ON(!(OCFS2_I(s_inode)->ip_dyn_fea 3965 BUG_ON(!(OCFS2_I(s_inode)->ip_dyn_features & OCFS2_INLINE_DATA_FL));
3933 3966
3934 handle = ocfs2_start_trans(osb, OCFS2 3967 handle = ocfs2_start_trans(osb, OCFS2_INODE_UPDATE_CREDITS);
3935 if (IS_ERR(handle)) { 3968 if (IS_ERR(handle)) {
3936 ret = PTR_ERR(handle); 3969 ret = PTR_ERR(handle);
3937 mlog_errno(ret); 3970 mlog_errno(ret);
3938 goto out; 3971 goto out;
3939 } 3972 }
3940 3973
3941 ret = ocfs2_journal_access_di(handle, 3974 ret = ocfs2_journal_access_di(handle, INODE_CACHE(t_inode), t_bh,
3942 OCFS2_J 3975 OCFS2_JOURNAL_ACCESS_WRITE);
3943 if (ret) { 3976 if (ret) {
3944 mlog_errno(ret); 3977 mlog_errno(ret);
3945 goto out_commit; 3978 goto out_commit;
3946 } 3979 }
3947 3980
3948 t_di->id2.i_data.id_count = s_di->id2 3981 t_di->id2.i_data.id_count = s_di->id2.i_data.id_count;
3949 memcpy(t_di->id2.i_data.id_data, s_di 3982 memcpy(t_di->id2.i_data.id_data, s_di->id2.i_data.id_data,
3950 le16_to_cpu(s_di->id2.i_data.i 3983 le16_to_cpu(s_di->id2.i_data.id_count));
3951 spin_lock(&OCFS2_I(t_inode)->ip_lock) 3984 spin_lock(&OCFS2_I(t_inode)->ip_lock);
3952 OCFS2_I(t_inode)->ip_dyn_features |= 3985 OCFS2_I(t_inode)->ip_dyn_features |= OCFS2_INLINE_DATA_FL;
3953 t_di->i_dyn_features = cpu_to_le16(OC 3986 t_di->i_dyn_features = cpu_to_le16(OCFS2_I(t_inode)->ip_dyn_features);
3954 spin_unlock(&OCFS2_I(t_inode)->ip_loc 3987 spin_unlock(&OCFS2_I(t_inode)->ip_lock);
3955 3988
3956 ocfs2_journal_dirty(handle, t_bh); 3989 ocfs2_journal_dirty(handle, t_bh);
3957 3990
3958 out_commit: 3991 out_commit:
3959 ocfs2_commit_trans(osb, handle); 3992 ocfs2_commit_trans(osb, handle);
3960 out: 3993 out:
3961 return ret; 3994 return ret;
3962 } 3995 }
3963 3996
3964 static int ocfs2_duplicate_extent_list(struct 3997 static int ocfs2_duplicate_extent_list(struct inode *s_inode,
3965 struct inode 3998 struct inode *t_inode,
3966 struct buffer 3999 struct buffer_head *t_bh,
3967 struct ocfs2_ 4000 struct ocfs2_caching_info *ref_ci,
3968 struct buffer 4001 struct buffer_head *ref_root_bh,
3969 struct ocfs2_ 4002 struct ocfs2_cached_dealloc_ctxt *dealloc)
3970 { 4003 {
3971 int ret = 0; 4004 int ret = 0;
3972 u32 p_cluster, num_clusters, clusters 4005 u32 p_cluster, num_clusters, clusters, cpos;
3973 loff_t size; 4006 loff_t size;
3974 unsigned int ext_flags; 4007 unsigned int ext_flags;
3975 struct ocfs2_extent_tree et; 4008 struct ocfs2_extent_tree et;
3976 4009
3977 ocfs2_init_dinode_extent_tree(&et, IN 4010 ocfs2_init_dinode_extent_tree(&et, INODE_CACHE(t_inode), t_bh);
3978 4011
3979 size = i_size_read(s_inode); 4012 size = i_size_read(s_inode);
3980 clusters = ocfs2_clusters_for_bytes(s 4013 clusters = ocfs2_clusters_for_bytes(s_inode->i_sb, size);
3981 4014
3982 cpos = 0; 4015 cpos = 0;
3983 while (cpos < clusters) { 4016 while (cpos < clusters) {
3984 ret = ocfs2_get_clusters(s_in 4017 ret = ocfs2_get_clusters(s_inode, cpos, &p_cluster,
3985 &num 4018 &num_clusters, &ext_flags);
3986 if (ret) { 4019 if (ret) {
3987 mlog_errno(ret); 4020 mlog_errno(ret);
3988 goto out; 4021 goto out;
3989 } 4022 }
3990 if (p_cluster) { 4023 if (p_cluster) {
3991 ret = ocfs2_add_refco 4024 ret = ocfs2_add_refcounted_extent(t_inode, &et,
3992 4025 ref_ci, ref_root_bh,
3993 4026 cpos, p_cluster,
3994 4027 num_clusters,
3995 4028 ext_flags,
3996 4029 dealloc);
3997 if (ret) { 4030 if (ret) {
3998 mlog_errno(re 4031 mlog_errno(ret);
3999 goto out; 4032 goto out;
4000 } 4033 }
4001 } 4034 }
4002 4035
4003 cpos += num_clusters; 4036 cpos += num_clusters;
4004 } 4037 }
4005 4038
4006 out: 4039 out:
4007 return ret; 4040 return ret;
4008 } 4041 }
4009 4042
4010 /* 4043 /*
4011 * change the new file's attributes to the sr 4044 * change the new file's attributes to the src.
4012 * 4045 *
4013 * reflink creates a snapshot of a file, that 4046 * reflink creates a snapshot of a file, that means the attributes
4014 * must be identical except for three excepti 4047 * must be identical except for three exceptions - nlink, ino, and ctime.
4015 */ 4048 */
4016 static int ocfs2_complete_reflink(struct inod 4049 static int ocfs2_complete_reflink(struct inode *s_inode,
4017 struct buff 4050 struct buffer_head *s_bh,
4018 struct inod 4051 struct inode *t_inode,
4019 struct buff 4052 struct buffer_head *t_bh,
4020 bool preser 4053 bool preserve)
4021 { 4054 {
4022 int ret; 4055 int ret;
4023 handle_t *handle; 4056 handle_t *handle;
4024 struct ocfs2_dinode *s_di = (struct o 4057 struct ocfs2_dinode *s_di = (struct ocfs2_dinode *)s_bh->b_data;
4025 struct ocfs2_dinode *di = (struct ocf 4058 struct ocfs2_dinode *di = (struct ocfs2_dinode *)t_bh->b_data;
4026 loff_t size = i_size_read(s_inode); 4059 loff_t size = i_size_read(s_inode);
4027 4060
4028 handle = ocfs2_start_trans(OCFS2_SB(t 4061 handle = ocfs2_start_trans(OCFS2_SB(t_inode->i_sb),
4029 OCFS2_INOD 4062 OCFS2_INODE_UPDATE_CREDITS);
4030 if (IS_ERR(handle)) { 4063 if (IS_ERR(handle)) {
4031 ret = PTR_ERR(handle); 4064 ret = PTR_ERR(handle);
4032 mlog_errno(ret); 4065 mlog_errno(ret);
4033 return ret; 4066 return ret;
4034 } 4067 }
4035 4068
4036 ret = ocfs2_journal_access_di(handle, 4069 ret = ocfs2_journal_access_di(handle, INODE_CACHE(t_inode), t_bh,
4037 OCFS2_J 4070 OCFS2_JOURNAL_ACCESS_WRITE);
4038 if (ret) { 4071 if (ret) {
4039 mlog_errno(ret); 4072 mlog_errno(ret);
4040 goto out_commit; 4073 goto out_commit;
4041 } 4074 }
4042 4075
4043 spin_lock(&OCFS2_I(t_inode)->ip_lock) 4076 spin_lock(&OCFS2_I(t_inode)->ip_lock);
4044 OCFS2_I(t_inode)->ip_clusters = OCFS2 4077 OCFS2_I(t_inode)->ip_clusters = OCFS2_I(s_inode)->ip_clusters;
4045 OCFS2_I(t_inode)->ip_attr = OCFS2_I(s 4078 OCFS2_I(t_inode)->ip_attr = OCFS2_I(s_inode)->ip_attr;
4046 OCFS2_I(t_inode)->ip_dyn_features = O 4079 OCFS2_I(t_inode)->ip_dyn_features = OCFS2_I(s_inode)->ip_dyn_features;
4047 spin_unlock(&OCFS2_I(t_inode)->ip_loc 4080 spin_unlock(&OCFS2_I(t_inode)->ip_lock);
4048 i_size_write(t_inode, size); 4081 i_size_write(t_inode, size);
4049 t_inode->i_blocks = s_inode->i_blocks 4082 t_inode->i_blocks = s_inode->i_blocks;
4050 4083
4051 di->i_xattr_inline_size = s_di->i_xat 4084 di->i_xattr_inline_size = s_di->i_xattr_inline_size;
4052 di->i_clusters = s_di->i_clusters; 4085 di->i_clusters = s_di->i_clusters;
4053 di->i_size = s_di->i_size; 4086 di->i_size = s_di->i_size;
4054 di->i_dyn_features = s_di->i_dyn_feat 4087 di->i_dyn_features = s_di->i_dyn_features;
4055 di->i_attr = s_di->i_attr; 4088 di->i_attr = s_di->i_attr;
4056 4089
4057 if (preserve) { 4090 if (preserve) {
4058 t_inode->i_uid = s_inode->i_u 4091 t_inode->i_uid = s_inode->i_uid;
4059 t_inode->i_gid = s_inode->i_g 4092 t_inode->i_gid = s_inode->i_gid;
4060 t_inode->i_mode = s_inode->i_ 4093 t_inode->i_mode = s_inode->i_mode;
4061 di->i_uid = s_di->i_uid; 4094 di->i_uid = s_di->i_uid;
4062 di->i_gid = s_di->i_gid; 4095 di->i_gid = s_di->i_gid;
4063 di->i_mode = s_di->i_mode; 4096 di->i_mode = s_di->i_mode;
4064 4097
4065 /* 4098 /*
4066 * update time. 4099 * update time.
4067 * we want mtime to appear id 4100 * we want mtime to appear identical to the source and
4068 * update ctime. 4101 * update ctime.
4069 */ 4102 */
4070 inode_set_ctime_current(t_ino !! 4103 t_inode->i_ctime = current_time(t_inode);
4071 4104
4072 di->i_ctime = cpu_to_le64(ino !! 4105 di->i_ctime = cpu_to_le64(t_inode->i_ctime.tv_sec);
4073 di->i_ctime_nsec = cpu_to_le3 !! 4106 di->i_ctime_nsec = cpu_to_le32(t_inode->i_ctime.tv_nsec);
4074 4107
4075 inode_set_mtime_to_ts(t_inode !! 4108 t_inode->i_mtime = s_inode->i_mtime;
4076 di->i_mtime = s_di->i_mtime; 4109 di->i_mtime = s_di->i_mtime;
4077 di->i_mtime_nsec = s_di->i_mt 4110 di->i_mtime_nsec = s_di->i_mtime_nsec;
4078 } 4111 }
4079 4112
4080 ocfs2_journal_dirty(handle, t_bh); 4113 ocfs2_journal_dirty(handle, t_bh);
4081 4114
4082 out_commit: 4115 out_commit:
4083 ocfs2_commit_trans(OCFS2_SB(t_inode-> 4116 ocfs2_commit_trans(OCFS2_SB(t_inode->i_sb), handle);
4084 return ret; 4117 return ret;
4085 } 4118 }
4086 4119
4087 static int ocfs2_create_reflink_node(struct i 4120 static int ocfs2_create_reflink_node(struct inode *s_inode,
4088 struct b 4121 struct buffer_head *s_bh,
4089 struct i 4122 struct inode *t_inode,
4090 struct b 4123 struct buffer_head *t_bh,
4091 bool pre 4124 bool preserve)
4092 { 4125 {
4093 int ret; 4126 int ret;
4094 struct buffer_head *ref_root_bh = NUL 4127 struct buffer_head *ref_root_bh = NULL;
4095 struct ocfs2_cached_dealloc_ctxt deal 4128 struct ocfs2_cached_dealloc_ctxt dealloc;
4096 struct ocfs2_super *osb = OCFS2_SB(s_ 4129 struct ocfs2_super *osb = OCFS2_SB(s_inode->i_sb);
4097 struct ocfs2_dinode *di = (struct ocf 4130 struct ocfs2_dinode *di = (struct ocfs2_dinode *)s_bh->b_data;
4098 struct ocfs2_refcount_tree *ref_tree; 4131 struct ocfs2_refcount_tree *ref_tree;
4099 4132
4100 ocfs2_init_dealloc_ctxt(&dealloc); 4133 ocfs2_init_dealloc_ctxt(&dealloc);
4101 4134
4102 ret = ocfs2_set_refcount_tree(t_inode 4135 ret = ocfs2_set_refcount_tree(t_inode, t_bh,
4103 le64_to 4136 le64_to_cpu(di->i_refcount_loc));
4104 if (ret) { 4137 if (ret) {
4105 mlog_errno(ret); 4138 mlog_errno(ret);
4106 goto out; 4139 goto out;
4107 } 4140 }
4108 4141
4109 if (OCFS2_I(s_inode)->ip_dyn_features 4142 if (OCFS2_I(s_inode)->ip_dyn_features & OCFS2_INLINE_DATA_FL) {
4110 ret = ocfs2_duplicate_inline_ 4143 ret = ocfs2_duplicate_inline_data(s_inode, s_bh,
4111 4144 t_inode, t_bh);
4112 if (ret) 4145 if (ret)
4113 mlog_errno(ret); 4146 mlog_errno(ret);
4114 goto out; 4147 goto out;
4115 } 4148 }
4116 4149
4117 ret = ocfs2_lock_refcount_tree(osb, l 4150 ret = ocfs2_lock_refcount_tree(osb, le64_to_cpu(di->i_refcount_loc),
4118 1, &re 4151 1, &ref_tree, &ref_root_bh);
4119 if (ret) { 4152 if (ret) {
4120 mlog_errno(ret); 4153 mlog_errno(ret);
4121 goto out; 4154 goto out;
4122 } 4155 }
4123 4156
4124 ret = ocfs2_duplicate_extent_list(s_i 4157 ret = ocfs2_duplicate_extent_list(s_inode, t_inode, t_bh,
4125 &re 4158 &ref_tree->rf_ci, ref_root_bh,
4126 &de 4159 &dealloc);
4127 if (ret) { 4160 if (ret) {
4128 mlog_errno(ret); 4161 mlog_errno(ret);
4129 goto out_unlock_refcount; 4162 goto out_unlock_refcount;
4130 } 4163 }
4131 4164
4132 out_unlock_refcount: 4165 out_unlock_refcount:
4133 ocfs2_unlock_refcount_tree(osb, ref_t 4166 ocfs2_unlock_refcount_tree(osb, ref_tree, 1);
4134 brelse(ref_root_bh); 4167 brelse(ref_root_bh);
4135 out: 4168 out:
4136 if (ocfs2_dealloc_has_cluster(&deallo 4169 if (ocfs2_dealloc_has_cluster(&dealloc)) {
4137 ocfs2_schedule_truncate_log_f 4170 ocfs2_schedule_truncate_log_flush(osb, 1);
4138 ocfs2_run_deallocs(osb, &deal 4171 ocfs2_run_deallocs(osb, &dealloc);
4139 } 4172 }
4140 4173
4141 return ret; 4174 return ret;
4142 } 4175 }
4143 4176
4144 static int __ocfs2_reflink(struct dentry *old 4177 static int __ocfs2_reflink(struct dentry *old_dentry,
4145 struct buffer_head 4178 struct buffer_head *old_bh,
4146 struct inode *new_ 4179 struct inode *new_inode,
4147 bool preserve) 4180 bool preserve)
4148 { 4181 {
4149 int ret; 4182 int ret;
4150 struct inode *inode = d_inode(old_den 4183 struct inode *inode = d_inode(old_dentry);
4151 struct buffer_head *new_bh = NULL; 4184 struct buffer_head *new_bh = NULL;
4152 struct ocfs2_inode_info *oi = OCFS2_I <<
4153 4185
4154 if (oi->ip_flags & OCFS2_INODE_SYSTEM !! 4186 if (OCFS2_I(inode)->ip_flags & OCFS2_INODE_SYSTEM_FILE) {
4155 ret = -EINVAL; 4187 ret = -EINVAL;
4156 mlog_errno(ret); 4188 mlog_errno(ret);
4157 goto out; 4189 goto out;
4158 } 4190 }
4159 4191
4160 ret = filemap_fdatawrite(inode->i_map 4192 ret = filemap_fdatawrite(inode->i_mapping);
4161 if (ret) { 4193 if (ret) {
4162 mlog_errno(ret); 4194 mlog_errno(ret);
4163 goto out; 4195 goto out;
4164 } 4196 }
4165 4197
4166 ret = ocfs2_attach_refcount_tree(inod 4198 ret = ocfs2_attach_refcount_tree(inode, old_bh);
4167 if (ret) { 4199 if (ret) {
4168 mlog_errno(ret); 4200 mlog_errno(ret);
4169 goto out; 4201 goto out;
4170 } 4202 }
4171 4203
4172 inode_lock_nested(new_inode, I_MUTEX_ 4204 inode_lock_nested(new_inode, I_MUTEX_CHILD);
4173 ret = ocfs2_inode_lock_nested(new_ino 4205 ret = ocfs2_inode_lock_nested(new_inode, &new_bh, 1,
4174 OI_LS_R 4206 OI_LS_REFLINK_TARGET);
4175 if (ret) { 4207 if (ret) {
4176 mlog_errno(ret); 4208 mlog_errno(ret);
4177 goto out_unlock; 4209 goto out_unlock;
4178 } 4210 }
4179 4211
4180 if ((oi->ip_dyn_features & OCFS2_HAS_ <<
4181 (oi->ip_dyn_features & OCFS2_INLI <<
4182 /* <<
4183 * Adjust extent record count <<
4184 * Inline data count had been <<
4185 */ <<
4186 struct ocfs2_inode_info *new_ <<
4187 <<
4188 if (!(new_oi->ip_dyn_features <<
4189 !(ocfs2_inode_is_fast_sym <<
4190 struct ocfs2_dinode * <<
4191 struct ocfs2_dinode * <<
4192 struct ocfs2_extent_l <<
4193 int inline_size = le1 <<
4194 <<
4195 le16_add_cpu(&el->l_c <<
4196 sizeo <<
4197 } <<
4198 } <<
4199 <<
4200 ret = ocfs2_create_reflink_node(inode 4212 ret = ocfs2_create_reflink_node(inode, old_bh,
4201 new_i 4213 new_inode, new_bh, preserve);
4202 if (ret) { 4214 if (ret) {
4203 mlog_errno(ret); 4215 mlog_errno(ret);
4204 goto inode_unlock; 4216 goto inode_unlock;
4205 } 4217 }
4206 4218
4207 if (oi->ip_dyn_features & OCFS2_HAS_X !! 4219 if (OCFS2_I(inode)->ip_dyn_features & OCFS2_HAS_XATTR_FL) {
4208 ret = ocfs2_reflink_xattrs(in 4220 ret = ocfs2_reflink_xattrs(inode, old_bh,
4209 ne 4221 new_inode, new_bh,
4210 pr 4222 preserve);
4211 if (ret) { 4223 if (ret) {
4212 mlog_errno(ret); 4224 mlog_errno(ret);
4213 goto inode_unlock; 4225 goto inode_unlock;
4214 } 4226 }
4215 } 4227 }
4216 4228
4217 ret = ocfs2_complete_reflink(inode, o 4229 ret = ocfs2_complete_reflink(inode, old_bh,
4218 new_inod 4230 new_inode, new_bh, preserve);
4219 if (ret) 4231 if (ret)
4220 mlog_errno(ret); 4232 mlog_errno(ret);
4221 4233
4222 inode_unlock: 4234 inode_unlock:
4223 ocfs2_inode_unlock(new_inode, 1); 4235 ocfs2_inode_unlock(new_inode, 1);
4224 brelse(new_bh); 4236 brelse(new_bh);
4225 out_unlock: 4237 out_unlock:
4226 inode_unlock(new_inode); 4238 inode_unlock(new_inode);
4227 out: 4239 out:
4228 if (!ret) { 4240 if (!ret) {
4229 ret = filemap_fdatawait(inode 4241 ret = filemap_fdatawait(inode->i_mapping);
4230 if (ret) 4242 if (ret)
4231 mlog_errno(ret); 4243 mlog_errno(ret);
4232 } 4244 }
4233 return ret; 4245 return ret;
4234 } 4246 }
4235 4247
4236 static int ocfs2_reflink(struct dentry *old_d 4248 static int ocfs2_reflink(struct dentry *old_dentry, struct inode *dir,
4237 struct dentry *new_d 4249 struct dentry *new_dentry, bool preserve)
4238 { 4250 {
4239 int error, had_lock; 4251 int error, had_lock;
4240 struct inode *inode = d_inode(old_den 4252 struct inode *inode = d_inode(old_dentry);
4241 struct buffer_head *old_bh = NULL; 4253 struct buffer_head *old_bh = NULL;
4242 struct inode *new_orphan_inode = NULL 4254 struct inode *new_orphan_inode = NULL;
4243 struct ocfs2_lock_holder oh; 4255 struct ocfs2_lock_holder oh;
4244 4256
4245 if (!ocfs2_refcount_tree(OCFS2_SB(ino 4257 if (!ocfs2_refcount_tree(OCFS2_SB(inode->i_sb)))
4246 return -EOPNOTSUPP; 4258 return -EOPNOTSUPP;
4247 4259
4248 4260
4249 error = ocfs2_create_inode_in_orphan( 4261 error = ocfs2_create_inode_in_orphan(dir, inode->i_mode,
4250 4262 &new_orphan_inode);
4251 if (error) { 4263 if (error) {
4252 mlog_errno(error); 4264 mlog_errno(error);
4253 goto out; 4265 goto out;
4254 } 4266 }
4255 4267
4256 error = ocfs2_rw_lock(inode, 1); 4268 error = ocfs2_rw_lock(inode, 1);
4257 if (error) { 4269 if (error) {
4258 mlog_errno(error); 4270 mlog_errno(error);
4259 goto out; 4271 goto out;
4260 } 4272 }
4261 4273
4262 error = ocfs2_inode_lock(inode, &old_ 4274 error = ocfs2_inode_lock(inode, &old_bh, 1);
4263 if (error) { 4275 if (error) {
4264 mlog_errno(error); 4276 mlog_errno(error);
4265 ocfs2_rw_unlock(inode, 1); 4277 ocfs2_rw_unlock(inode, 1);
4266 goto out; 4278 goto out;
4267 } 4279 }
4268 4280
4269 down_write(&OCFS2_I(inode)->ip_xattr_ 4281 down_write(&OCFS2_I(inode)->ip_xattr_sem);
4270 down_write(&OCFS2_I(inode)->ip_alloc_ 4282 down_write(&OCFS2_I(inode)->ip_alloc_sem);
4271 error = __ocfs2_reflink(old_dentry, o 4283 error = __ocfs2_reflink(old_dentry, old_bh,
4272 new_orphan_in 4284 new_orphan_inode, preserve);
4273 up_write(&OCFS2_I(inode)->ip_alloc_se 4285 up_write(&OCFS2_I(inode)->ip_alloc_sem);
4274 up_write(&OCFS2_I(inode)->ip_xattr_se 4286 up_write(&OCFS2_I(inode)->ip_xattr_sem);
4275 4287
4276 ocfs2_inode_unlock(inode, 1); 4288 ocfs2_inode_unlock(inode, 1);
4277 ocfs2_rw_unlock(inode, 1); 4289 ocfs2_rw_unlock(inode, 1);
4278 brelse(old_bh); 4290 brelse(old_bh);
4279 4291
4280 if (error) { 4292 if (error) {
4281 mlog_errno(error); 4293 mlog_errno(error);
4282 goto out; 4294 goto out;
4283 } 4295 }
4284 4296
4285 had_lock = ocfs2_inode_lock_tracker(n 4297 had_lock = ocfs2_inode_lock_tracker(new_orphan_inode, NULL, 1,
4286 & 4298 &oh);
4287 if (had_lock < 0) { 4299 if (had_lock < 0) {
4288 error = had_lock; 4300 error = had_lock;
4289 mlog_errno(error); 4301 mlog_errno(error);
4290 goto out; 4302 goto out;
4291 } 4303 }
4292 4304
4293 /* If the security isn't preserved, w 4305 /* If the security isn't preserved, we need to re-initialize them. */
4294 if (!preserve) { 4306 if (!preserve) {
4295 error = ocfs2_init_security_a 4307 error = ocfs2_init_security_and_acl(dir, new_orphan_inode,
4296 4308 &new_dentry->d_name);
4297 if (error) 4309 if (error)
4298 mlog_errno(error); 4310 mlog_errno(error);
4299 } 4311 }
4300 if (!error) { 4312 if (!error) {
4301 error = ocfs2_mv_orphaned_ino 4313 error = ocfs2_mv_orphaned_inode_to_new(dir, new_orphan_inode,
4302 4314 new_dentry);
4303 if (error) 4315 if (error)
4304 mlog_errno(error); 4316 mlog_errno(error);
4305 } 4317 }
4306 ocfs2_inode_unlock_tracker(new_orphan 4318 ocfs2_inode_unlock_tracker(new_orphan_inode, 1, &oh, had_lock);
4307 4319
4308 out: 4320 out:
4309 if (new_orphan_inode) { 4321 if (new_orphan_inode) {
4310 /* 4322 /*
4311 * We need to open_unlock the 4323 * We need to open_unlock the inode no matter whether we
4312 * succeed or not, so that ot 4324 * succeed or not, so that other nodes can delete it later.
4313 */ 4325 */
4314 ocfs2_open_unlock(new_orphan_ 4326 ocfs2_open_unlock(new_orphan_inode);
4315 if (error) 4327 if (error)
4316 iput(new_orphan_inode 4328 iput(new_orphan_inode);
4317 } 4329 }
4318 4330
4319 return error; 4331 return error;
4320 } 4332 }
4321 4333
4322 /* 4334 /*
4323 * Below here are the bits used by OCFS2_IOC_ 4335 * Below here are the bits used by OCFS2_IOC_REFLINK() to fake
4324 * sys_reflink(). This will go away when vfs 4336 * sys_reflink(). This will go away when vfs_reflink() exists in
4325 * fs/namei.c. 4337 * fs/namei.c.
4326 */ 4338 */
4327 4339
4328 /* copied from may_create in VFS. */ 4340 /* copied from may_create in VFS. */
4329 static inline int ocfs2_may_create(struct ino 4341 static inline int ocfs2_may_create(struct inode *dir, struct dentry *child)
4330 { 4342 {
4331 if (d_really_is_positive(child)) 4343 if (d_really_is_positive(child))
4332 return -EEXIST; 4344 return -EEXIST;
4333 if (IS_DEADDIR(dir)) 4345 if (IS_DEADDIR(dir))
4334 return -ENOENT; 4346 return -ENOENT;
4335 return inode_permission(&nop_mnt_idma !! 4347 return inode_permission(&init_user_ns, dir, MAY_WRITE | MAY_EXEC);
4336 } 4348 }
4337 4349
4338 /** 4350 /**
4339 * ocfs2_vfs_reflink - Create a reference-cou 4351 * ocfs2_vfs_reflink - Create a reference-counted link
4340 * 4352 *
4341 * @old_dentry: source dentry + inode 4353 * @old_dentry: source dentry + inode
4342 * @dir: directory to create the target 4354 * @dir: directory to create the target
4343 * @new_dentry: target dentry 4355 * @new_dentry: target dentry
4344 * @preserve: if true, preserve all file att 4356 * @preserve: if true, preserve all file attributes
4345 */ 4357 */
4346 static int ocfs2_vfs_reflink(struct dentry *o 4358 static int ocfs2_vfs_reflink(struct dentry *old_dentry, struct inode *dir,
4347 struct dentry *n 4359 struct dentry *new_dentry, bool preserve)
4348 { 4360 {
4349 struct inode *inode = d_inode(old_den 4361 struct inode *inode = d_inode(old_dentry);
4350 int error; 4362 int error;
4351 4363
4352 if (!inode) 4364 if (!inode)
4353 return -ENOENT; 4365 return -ENOENT;
4354 4366
4355 error = ocfs2_may_create(dir, new_den 4367 error = ocfs2_may_create(dir, new_dentry);
4356 if (error) 4368 if (error)
4357 return error; 4369 return error;
4358 4370
4359 if (dir->i_sb != inode->i_sb) 4371 if (dir->i_sb != inode->i_sb)
4360 return -EXDEV; 4372 return -EXDEV;
4361 4373
4362 /* 4374 /*
4363 * A reflink to an append-only or imm 4375 * A reflink to an append-only or immutable file cannot be created.
4364 */ 4376 */
4365 if (IS_APPEND(inode) || IS_IMMUTABLE( 4377 if (IS_APPEND(inode) || IS_IMMUTABLE(inode))
4366 return -EPERM; 4378 return -EPERM;
4367 4379
4368 /* Only regular files can be reflinke 4380 /* Only regular files can be reflinked. */
4369 if (!S_ISREG(inode->i_mode)) 4381 if (!S_ISREG(inode->i_mode))
4370 return -EPERM; 4382 return -EPERM;
4371 4383
4372 /* 4384 /*
4373 * If the caller wants to preserve ow 4385 * If the caller wants to preserve ownership, they require the
4374 * rights to do so. 4386 * rights to do so.
4375 */ 4387 */
4376 if (preserve) { 4388 if (preserve) {
4377 if (!uid_eq(current_fsuid(), 4389 if (!uid_eq(current_fsuid(), inode->i_uid) && !capable(CAP_CHOWN))
4378 return -EPERM; 4390 return -EPERM;
4379 if (!in_group_p(inode->i_gid) 4391 if (!in_group_p(inode->i_gid) && !capable(CAP_CHOWN))
4380 return -EPERM; 4392 return -EPERM;
4381 } 4393 }
4382 4394
4383 /* 4395 /*
4384 * If the caller is modifying any asp 4396 * If the caller is modifying any aspect of the attributes, they
4385 * are not creating a snapshot. They 4397 * are not creating a snapshot. They need read permission on the
4386 * file. 4398 * file.
4387 */ 4399 */
4388 if (!preserve) { 4400 if (!preserve) {
4389 error = inode_permission(&nop !! 4401 error = inode_permission(&init_user_ns, inode, MAY_READ);
4390 if (error) 4402 if (error)
4391 return error; 4403 return error;
4392 } 4404 }
4393 4405
4394 inode_lock(inode); 4406 inode_lock(inode);
4395 error = dquot_initialize(dir); 4407 error = dquot_initialize(dir);
4396 if (!error) 4408 if (!error)
4397 error = ocfs2_reflink(old_den 4409 error = ocfs2_reflink(old_dentry, dir, new_dentry, preserve);
4398 inode_unlock(inode); 4410 inode_unlock(inode);
4399 if (!error) 4411 if (!error)
4400 fsnotify_create(dir, new_dent 4412 fsnotify_create(dir, new_dentry);
4401 return error; 4413 return error;
4402 } 4414 }
4403 /* 4415 /*
4404 * Most codes are copied from sys_linkat. 4416 * Most codes are copied from sys_linkat.
4405 */ 4417 */
4406 int ocfs2_reflink_ioctl(struct inode *inode, 4418 int ocfs2_reflink_ioctl(struct inode *inode,
4407 const char __user *ol 4419 const char __user *oldname,
4408 const char __user *ne 4420 const char __user *newname,
4409 bool preserve) 4421 bool preserve)
4410 { 4422 {
4411 struct dentry *new_dentry; 4423 struct dentry *new_dentry;
4412 struct path old_path, new_path; 4424 struct path old_path, new_path;
4413 int error; 4425 int error;
4414 4426
4415 if (!ocfs2_refcount_tree(OCFS2_SB(ino 4427 if (!ocfs2_refcount_tree(OCFS2_SB(inode->i_sb)))
4416 return -EOPNOTSUPP; 4428 return -EOPNOTSUPP;
4417 4429
4418 error = user_path_at(AT_FDCWD, oldnam 4430 error = user_path_at(AT_FDCWD, oldname, 0, &old_path);
4419 if (error) { 4431 if (error) {
4420 mlog_errno(error); 4432 mlog_errno(error);
4421 return error; 4433 return error;
4422 } 4434 }
4423 4435
4424 new_dentry = user_path_create(AT_FDCW 4436 new_dentry = user_path_create(AT_FDCWD, newname, &new_path, 0);
4425 error = PTR_ERR(new_dentry); 4437 error = PTR_ERR(new_dentry);
4426 if (IS_ERR(new_dentry)) { 4438 if (IS_ERR(new_dentry)) {
4427 mlog_errno(error); 4439 mlog_errno(error);
4428 goto out; 4440 goto out;
4429 } 4441 }
4430 4442
4431 error = -EXDEV; 4443 error = -EXDEV;
4432 if (old_path.mnt != new_path.mnt) { 4444 if (old_path.mnt != new_path.mnt) {
4433 mlog_errno(error); 4445 mlog_errno(error);
4434 goto out_dput; 4446 goto out_dput;
4435 } 4447 }
4436 4448
4437 error = ocfs2_vfs_reflink(old_path.de 4449 error = ocfs2_vfs_reflink(old_path.dentry,
4438 d_inode(new 4450 d_inode(new_path.dentry),
4439 new_dentry, 4451 new_dentry, preserve);
4440 out_dput: 4452 out_dput:
4441 done_path_create(&new_path, new_dentr 4453 done_path_create(&new_path, new_dentry);
4442 out: 4454 out:
4443 path_put(&old_path); 4455 path_put(&old_path);
4444 4456
4445 return error; 4457 return error;
4446 } 4458 }
4447 4459
4448 /* Update destination inode size, if necessar 4460 /* Update destination inode size, if necessary. */
4449 int ocfs2_reflink_update_dest(struct inode *d 4461 int ocfs2_reflink_update_dest(struct inode *dest,
4450 struct buffer_h 4462 struct buffer_head *d_bh,
4451 loff_t newlen) 4463 loff_t newlen)
4452 { 4464 {
4453 handle_t *handle; 4465 handle_t *handle;
4454 int ret; 4466 int ret;
4455 4467
4456 dest->i_blocks = ocfs2_inode_sector_c 4468 dest->i_blocks = ocfs2_inode_sector_count(dest);
4457 4469
4458 if (newlen <= i_size_read(dest)) 4470 if (newlen <= i_size_read(dest))
4459 return 0; 4471 return 0;
4460 4472
4461 handle = ocfs2_start_trans(OCFS2_SB(d 4473 handle = ocfs2_start_trans(OCFS2_SB(dest->i_sb),
4462 OCFS2_INOD 4474 OCFS2_INODE_UPDATE_CREDITS);
4463 if (IS_ERR(handle)) { 4475 if (IS_ERR(handle)) {
4464 ret = PTR_ERR(handle); 4476 ret = PTR_ERR(handle);
4465 mlog_errno(ret); 4477 mlog_errno(ret);
4466 return ret; 4478 return ret;
4467 } 4479 }
4468 4480
4469 /* Extend i_size if needed. */ 4481 /* Extend i_size if needed. */
4470 spin_lock(&OCFS2_I(dest)->ip_lock); 4482 spin_lock(&OCFS2_I(dest)->ip_lock);
4471 if (newlen > i_size_read(dest)) 4483 if (newlen > i_size_read(dest))
4472 i_size_write(dest, newlen); 4484 i_size_write(dest, newlen);
4473 spin_unlock(&OCFS2_I(dest)->ip_lock); 4485 spin_unlock(&OCFS2_I(dest)->ip_lock);
4474 inode_set_mtime_to_ts(dest, inode_set !! 4486 dest->i_ctime = dest->i_mtime = current_time(dest);
4475 4487
4476 ret = ocfs2_mark_inode_dirty(handle, 4488 ret = ocfs2_mark_inode_dirty(handle, dest, d_bh);
4477 if (ret) { 4489 if (ret) {
4478 mlog_errno(ret); 4490 mlog_errno(ret);
4479 goto out_commit; 4491 goto out_commit;
4480 } 4492 }
4481 4493
4482 out_commit: 4494 out_commit:
4483 ocfs2_commit_trans(OCFS2_SB(dest->i_s 4495 ocfs2_commit_trans(OCFS2_SB(dest->i_sb), handle);
4484 return ret; 4496 return ret;
4485 } 4497 }
4486 4498
4487 /* Remap the range pos_in:len in s_inode to p 4499 /* Remap the range pos_in:len in s_inode to pos_out:len in t_inode. */
4488 static loff_t ocfs2_reflink_remap_extent(stru 4500 static loff_t ocfs2_reflink_remap_extent(struct inode *s_inode,
4489 stru 4501 struct buffer_head *s_bh,
4490 loff 4502 loff_t pos_in,
4491 stru 4503 struct inode *t_inode,
4492 stru 4504 struct buffer_head *t_bh,
4493 loff 4505 loff_t pos_out,
4494 loff 4506 loff_t len,
4495 stru 4507 struct ocfs2_cached_dealloc_ctxt *dealloc)
4496 { 4508 {
4497 struct ocfs2_extent_tree s_et; 4509 struct ocfs2_extent_tree s_et;
4498 struct ocfs2_extent_tree t_et; 4510 struct ocfs2_extent_tree t_et;
4499 struct ocfs2_dinode *dis; 4511 struct ocfs2_dinode *dis;
4500 struct buffer_head *ref_root_bh = NUL 4512 struct buffer_head *ref_root_bh = NULL;
4501 struct ocfs2_refcount_tree *ref_tree; 4513 struct ocfs2_refcount_tree *ref_tree;
4502 struct ocfs2_super *osb; 4514 struct ocfs2_super *osb;
4503 loff_t remapped_bytes = 0; 4515 loff_t remapped_bytes = 0;
4504 loff_t pstart, plen; 4516 loff_t pstart, plen;
4505 u32 p_cluster, num_clusters, slast, s 4517 u32 p_cluster, num_clusters, slast, spos, tpos, remapped_clus = 0;
4506 unsigned int ext_flags; 4518 unsigned int ext_flags;
4507 int ret = 0; 4519 int ret = 0;
4508 4520
4509 osb = OCFS2_SB(s_inode->i_sb); 4521 osb = OCFS2_SB(s_inode->i_sb);
4510 dis = (struct ocfs2_dinode *)s_bh->b_ 4522 dis = (struct ocfs2_dinode *)s_bh->b_data;
4511 ocfs2_init_dinode_extent_tree(&s_et, 4523 ocfs2_init_dinode_extent_tree(&s_et, INODE_CACHE(s_inode), s_bh);
4512 ocfs2_init_dinode_extent_tree(&t_et, 4524 ocfs2_init_dinode_extent_tree(&t_et, INODE_CACHE(t_inode), t_bh);
4513 4525
4514 spos = ocfs2_bytes_to_clusters(s_inod 4526 spos = ocfs2_bytes_to_clusters(s_inode->i_sb, pos_in);
4515 tpos = ocfs2_bytes_to_clusters(t_inod 4527 tpos = ocfs2_bytes_to_clusters(t_inode->i_sb, pos_out);
4516 slast = ocfs2_clusters_for_bytes(s_in 4528 slast = ocfs2_clusters_for_bytes(s_inode->i_sb, pos_in + len);
4517 4529
4518 while (spos < slast) { 4530 while (spos < slast) {
4519 if (fatal_signal_pending(curr 4531 if (fatal_signal_pending(current)) {
4520 ret = -EINTR; 4532 ret = -EINTR;
4521 goto out; 4533 goto out;
4522 } 4534 }
4523 4535
4524 /* Look up the extent. */ 4536 /* Look up the extent. */
4525 ret = ocfs2_get_clusters(s_in 4537 ret = ocfs2_get_clusters(s_inode, spos, &p_cluster,
4526 &num 4538 &num_clusters, &ext_flags);
4527 if (ret) { 4539 if (ret) {
4528 mlog_errno(ret); 4540 mlog_errno(ret);
4529 goto out; 4541 goto out;
4530 } 4542 }
4531 4543
4532 num_clusters = min_t(u32, num 4544 num_clusters = min_t(u32, num_clusters, slast - spos);
4533 4545
4534 /* Punch out the dest range. 4546 /* Punch out the dest range. */
4535 pstart = ocfs2_clusters_to_by 4547 pstart = ocfs2_clusters_to_bytes(t_inode->i_sb, tpos);
4536 plen = ocfs2_clusters_to_byte 4548 plen = ocfs2_clusters_to_bytes(t_inode->i_sb, num_clusters);
4537 ret = ocfs2_remove_inode_rang 4549 ret = ocfs2_remove_inode_range(t_inode, t_bh, pstart, plen);
4538 if (ret) { 4550 if (ret) {
4539 mlog_errno(ret); 4551 mlog_errno(ret);
4540 goto out; 4552 goto out;
4541 } 4553 }
4542 4554
4543 if (p_cluster == 0) 4555 if (p_cluster == 0)
4544 goto next_loop; 4556 goto next_loop;
4545 4557
4546 /* Lock the refcount btree... 4558 /* Lock the refcount btree... */
4547 ret = ocfs2_lock_refcount_tre 4559 ret = ocfs2_lock_refcount_tree(osb,
4548 4560 le64_to_cpu(dis->i_refcount_loc),
4549 4561 1, &ref_tree, &ref_root_bh);
4550 if (ret) { 4562 if (ret) {
4551 mlog_errno(ret); 4563 mlog_errno(ret);
4552 goto out; 4564 goto out;
4553 } 4565 }
4554 4566
4555 /* Mark s_inode's extent as r 4567 /* Mark s_inode's extent as refcounted. */
4556 if (!(ext_flags & OCFS2_EXT_R 4568 if (!(ext_flags & OCFS2_EXT_REFCOUNTED)) {
4557 ret = ocfs2_add_refco 4569 ret = ocfs2_add_refcount_flag(s_inode, &s_et,
4558 4570 &ref_tree->rf_ci,
4559 4571 ref_root_bh, spos,
4560 4572 p_cluster, num_clusters,
4561 4573 dealloc, NULL);
4562 if (ret) { 4574 if (ret) {
4563 mlog_errno(re 4575 mlog_errno(ret);
4564 goto out_unlo 4576 goto out_unlock_refcount;
4565 } 4577 }
4566 } 4578 }
4567 4579
4568 /* Map in the new extent. */ 4580 /* Map in the new extent. */
4569 ext_flags |= OCFS2_EXT_REFCOU 4581 ext_flags |= OCFS2_EXT_REFCOUNTED;
4570 ret = ocfs2_add_refcounted_ex 4582 ret = ocfs2_add_refcounted_extent(t_inode, &t_et,
4571 4583 &ref_tree->rf_ci,
4572 4584 ref_root_bh,
4573 4585 tpos, p_cluster,
4574 4586 num_clusters,
4575 4587 ext_flags,
4576 4588 dealloc);
4577 if (ret) { 4589 if (ret) {
4578 mlog_errno(ret); 4590 mlog_errno(ret);
4579 goto out_unlock_refco 4591 goto out_unlock_refcount;
4580 } 4592 }
4581 4593
4582 ocfs2_unlock_refcount_tree(os 4594 ocfs2_unlock_refcount_tree(osb, ref_tree, 1);
4583 brelse(ref_root_bh); 4595 brelse(ref_root_bh);
4584 next_loop: 4596 next_loop:
4585 spos += num_clusters; 4597 spos += num_clusters;
4586 tpos += num_clusters; 4598 tpos += num_clusters;
4587 remapped_clus += num_clusters 4599 remapped_clus += num_clusters;
4588 } 4600 }
4589 4601
4590 goto out; 4602 goto out;
4591 out_unlock_refcount: 4603 out_unlock_refcount:
4592 ocfs2_unlock_refcount_tree(osb, ref_t 4604 ocfs2_unlock_refcount_tree(osb, ref_tree, 1);
4593 brelse(ref_root_bh); 4605 brelse(ref_root_bh);
4594 out: 4606 out:
4595 remapped_bytes = ocfs2_clusters_to_by 4607 remapped_bytes = ocfs2_clusters_to_bytes(t_inode->i_sb, remapped_clus);
4596 remapped_bytes = min_t(loff_t, len, r 4608 remapped_bytes = min_t(loff_t, len, remapped_bytes);
4597 4609
4598 return remapped_bytes > 0 ? remapped_ 4610 return remapped_bytes > 0 ? remapped_bytes : ret;
4599 } 4611 }
4600 4612
4601 /* Set up refcount tree and remap s_inode to 4613 /* Set up refcount tree and remap s_inode to t_inode. */
4602 loff_t ocfs2_reflink_remap_blocks(struct inod 4614 loff_t ocfs2_reflink_remap_blocks(struct inode *s_inode,
4603 struct buff 4615 struct buffer_head *s_bh,
4604 loff_t pos_ 4616 loff_t pos_in,
4605 struct inod 4617 struct inode *t_inode,
4606 struct buff 4618 struct buffer_head *t_bh,
4607 loff_t pos_ 4619 loff_t pos_out,
4608 loff_t len) 4620 loff_t len)
4609 { 4621 {
4610 struct ocfs2_cached_dealloc_ctxt deal 4622 struct ocfs2_cached_dealloc_ctxt dealloc;
4611 struct ocfs2_super *osb; 4623 struct ocfs2_super *osb;
4612 struct ocfs2_dinode *dis; 4624 struct ocfs2_dinode *dis;
4613 struct ocfs2_dinode *dit; 4625 struct ocfs2_dinode *dit;
4614 loff_t ret; 4626 loff_t ret;
4615 4627
4616 osb = OCFS2_SB(s_inode->i_sb); 4628 osb = OCFS2_SB(s_inode->i_sb);
4617 dis = (struct ocfs2_dinode *)s_bh->b_ 4629 dis = (struct ocfs2_dinode *)s_bh->b_data;
4618 dit = (struct ocfs2_dinode *)t_bh->b_ 4630 dit = (struct ocfs2_dinode *)t_bh->b_data;
4619 ocfs2_init_dealloc_ctxt(&dealloc); 4631 ocfs2_init_dealloc_ctxt(&dealloc);
4620 4632
4621 /* 4633 /*
4622 * If we're reflinking the entire fil 4634 * If we're reflinking the entire file and the source is inline
4623 * data, just copy the contents. 4635 * data, just copy the contents.
4624 */ 4636 */
4625 if (pos_in == pos_out && pos_in == 0 4637 if (pos_in == pos_out && pos_in == 0 && len == i_size_read(s_inode) &&
4626 i_size_read(t_inode) <= len && 4638 i_size_read(t_inode) <= len &&
4627 (OCFS2_I(s_inode)->ip_dyn_feature 4639 (OCFS2_I(s_inode)->ip_dyn_features & OCFS2_INLINE_DATA_FL)) {
4628 ret = ocfs2_duplicate_inline_ 4640 ret = ocfs2_duplicate_inline_data(s_inode, s_bh, t_inode, t_bh);
4629 if (ret) 4641 if (ret)
4630 mlog_errno(ret); 4642 mlog_errno(ret);
4631 goto out; 4643 goto out;
4632 } 4644 }
4633 4645
4634 /* 4646 /*
4635 * If both inodes belong to two diffe 4647 * If both inodes belong to two different refcount groups then
4636 * forget it because we don't know ho 4648 * forget it because we don't know how (or want) to go merging
4637 * refcount trees. 4649 * refcount trees.
4638 */ 4650 */
4639 ret = -EOPNOTSUPP; 4651 ret = -EOPNOTSUPP;
4640 if (ocfs2_is_refcount_inode(s_inode) 4652 if (ocfs2_is_refcount_inode(s_inode) &&
4641 ocfs2_is_refcount_inode(t_inode) 4653 ocfs2_is_refcount_inode(t_inode) &&
4642 le64_to_cpu(dis->i_refcount_loc) 4654 le64_to_cpu(dis->i_refcount_loc) !=
4643 le64_to_cpu(dit->i_refcount_loc)) 4655 le64_to_cpu(dit->i_refcount_loc))
4644 goto out; 4656 goto out;
4645 4657
4646 /* Neither inode has a refcount tree. 4658 /* Neither inode has a refcount tree. Add one to s_inode. */
4647 if (!ocfs2_is_refcount_inode(s_inode) 4659 if (!ocfs2_is_refcount_inode(s_inode) &&
4648 !ocfs2_is_refcount_inode(t_inode) 4660 !ocfs2_is_refcount_inode(t_inode)) {
4649 ret = ocfs2_create_refcount_t 4661 ret = ocfs2_create_refcount_tree(s_inode, s_bh);
4650 if (ret) { 4662 if (ret) {
4651 mlog_errno(ret); 4663 mlog_errno(ret);
4652 goto out; 4664 goto out;
4653 } 4665 }
4654 } 4666 }
4655 4667
4656 /* Ensure that both inodes end up wit 4668 /* Ensure that both inodes end up with the same refcount tree. */
4657 if (!ocfs2_is_refcount_inode(s_inode) 4669 if (!ocfs2_is_refcount_inode(s_inode)) {
4658 ret = ocfs2_set_refcount_tree 4670 ret = ocfs2_set_refcount_tree(s_inode, s_bh,
4659 4671 le64_to_cpu(dit->i_refcount_loc));
4660 if (ret) { 4672 if (ret) {
4661 mlog_errno(ret); 4673 mlog_errno(ret);
4662 goto out; 4674 goto out;
4663 } 4675 }
4664 } 4676 }
4665 if (!ocfs2_is_refcount_inode(t_inode) 4677 if (!ocfs2_is_refcount_inode(t_inode)) {
4666 ret = ocfs2_set_refcount_tree 4678 ret = ocfs2_set_refcount_tree(t_inode, t_bh,
4667 4679 le64_to_cpu(dis->i_refcount_loc));
4668 if (ret) { 4680 if (ret) {
4669 mlog_errno(ret); 4681 mlog_errno(ret);
4670 goto out; 4682 goto out;
4671 } 4683 }
4672 } 4684 }
4673 4685
4674 /* Turn off inline data in the dest f 4686 /* Turn off inline data in the dest file. */
4675 if (OCFS2_I(t_inode)->ip_dyn_features 4687 if (OCFS2_I(t_inode)->ip_dyn_features & OCFS2_INLINE_DATA_FL) {
4676 ret = ocfs2_convert_inline_da 4688 ret = ocfs2_convert_inline_data_to_extents(t_inode, t_bh);
4677 if (ret) { 4689 if (ret) {
4678 mlog_errno(ret); 4690 mlog_errno(ret);
4679 goto out; 4691 goto out;
4680 } 4692 }
4681 } 4693 }
4682 4694
4683 /* Actually remap extents now. */ 4695 /* Actually remap extents now. */
4684 ret = ocfs2_reflink_remap_extent(s_in 4696 ret = ocfs2_reflink_remap_extent(s_inode, s_bh, pos_in, t_inode, t_bh,
4685 pos_ 4697 pos_out, len, &dealloc);
4686 if (ret < 0) { 4698 if (ret < 0) {
4687 mlog_errno(ret); 4699 mlog_errno(ret);
4688 goto out; 4700 goto out;
4689 } 4701 }
4690 4702
4691 out: 4703 out:
4692 if (ocfs2_dealloc_has_cluster(&deallo 4704 if (ocfs2_dealloc_has_cluster(&dealloc)) {
4693 ocfs2_schedule_truncate_log_f 4705 ocfs2_schedule_truncate_log_flush(osb, 1);
4694 ocfs2_run_deallocs(osb, &deal 4706 ocfs2_run_deallocs(osb, &dealloc);
4695 } 4707 }
4696 4708
4697 return ret; 4709 return ret;
4698 } 4710 }
4699 4711
4700 /* Lock an inode and grab a bh pointing to th 4712 /* Lock an inode and grab a bh pointing to the inode. */
4701 int ocfs2_reflink_inodes_lock(struct inode *s 4713 int ocfs2_reflink_inodes_lock(struct inode *s_inode,
4702 struct buffer_h 4714 struct buffer_head **bh_s,
4703 struct inode *t 4715 struct inode *t_inode,
4704 struct buffer_h 4716 struct buffer_head **bh_t)
4705 { 4717 {
4706 struct inode *inode1 = s_inode; 4718 struct inode *inode1 = s_inode;
4707 struct inode *inode2 = t_inode; 4719 struct inode *inode2 = t_inode;
4708 struct ocfs2_inode_info *oi1; 4720 struct ocfs2_inode_info *oi1;
4709 struct ocfs2_inode_info *oi2; 4721 struct ocfs2_inode_info *oi2;
4710 struct buffer_head *bh1 = NULL; 4722 struct buffer_head *bh1 = NULL;
4711 struct buffer_head *bh2 = NULL; 4723 struct buffer_head *bh2 = NULL;
4712 bool same_inode = (s_inode == t_inode 4724 bool same_inode = (s_inode == t_inode);
4713 bool need_swap = (inode1->i_ino > ino 4725 bool need_swap = (inode1->i_ino > inode2->i_ino);
4714 int status; 4726 int status;
4715 4727
4716 /* First grab the VFS and rw locks. * 4728 /* First grab the VFS and rw locks. */
4717 lock_two_nondirectories(s_inode, t_in 4729 lock_two_nondirectories(s_inode, t_inode);
4718 if (need_swap) 4730 if (need_swap)
4719 swap(inode1, inode2); 4731 swap(inode1, inode2);
4720 4732
4721 status = ocfs2_rw_lock(inode1, 1); 4733 status = ocfs2_rw_lock(inode1, 1);
4722 if (status) { 4734 if (status) {
4723 mlog_errno(status); 4735 mlog_errno(status);
4724 goto out_i1; 4736 goto out_i1;
4725 } 4737 }
4726 if (!same_inode) { 4738 if (!same_inode) {
4727 status = ocfs2_rw_lock(inode2 4739 status = ocfs2_rw_lock(inode2, 1);
4728 if (status) { 4740 if (status) {
4729 mlog_errno(status); 4741 mlog_errno(status);
4730 goto out_i2; 4742 goto out_i2;
4731 } 4743 }
4732 } 4744 }
4733 4745
4734 /* Now go for the cluster locks */ 4746 /* Now go for the cluster locks */
4735 oi1 = OCFS2_I(inode1); 4747 oi1 = OCFS2_I(inode1);
4736 oi2 = OCFS2_I(inode2); 4748 oi2 = OCFS2_I(inode2);
4737 4749
4738 trace_ocfs2_double_lock((unsigned lon 4750 trace_ocfs2_double_lock((unsigned long long)oi1->ip_blkno,
4739 (unsigned lon 4751 (unsigned long long)oi2->ip_blkno);
4740 4752
4741 /* We always want to lock the one wit 4753 /* We always want to lock the one with the lower lockid first. */
4742 if (oi1->ip_blkno > oi2->ip_blkno) 4754 if (oi1->ip_blkno > oi2->ip_blkno)
4743 mlog_errno(-ENOLCK); 4755 mlog_errno(-ENOLCK);
4744 4756
4745 /* lock id1 */ 4757 /* lock id1 */
4746 status = ocfs2_inode_lock_nested(inod 4758 status = ocfs2_inode_lock_nested(inode1, &bh1, 1,
4747 OI_L 4759 OI_LS_REFLINK_TARGET);
4748 if (status < 0) { 4760 if (status < 0) {
4749 if (status != -ENOENT) 4761 if (status != -ENOENT)
4750 mlog_errno(status); 4762 mlog_errno(status);
4751 goto out_rw2; 4763 goto out_rw2;
4752 } 4764 }
4753 4765
4754 /* lock id2 */ 4766 /* lock id2 */
4755 if (!same_inode) { 4767 if (!same_inode) {
4756 status = ocfs2_inode_lock_nes 4768 status = ocfs2_inode_lock_nested(inode2, &bh2, 1,
4757 4769 OI_LS_REFLINK_TARGET);
4758 if (status < 0) { 4770 if (status < 0) {
4759 if (status != -ENOENT 4771 if (status != -ENOENT)
4760 mlog_errno(st 4772 mlog_errno(status);
4761 goto out_cl1; 4773 goto out_cl1;
4762 } 4774 }
4763 } else { 4775 } else {
4764 bh2 = bh1; 4776 bh2 = bh1;
4765 } 4777 }
4766 4778
4767 /* 4779 /*
4768 * If we swapped inode order above, w 4780 * If we swapped inode order above, we have to swap the buffer heads
4769 * before passing them back to the ca 4781 * before passing them back to the caller.
4770 */ 4782 */
4771 if (need_swap) 4783 if (need_swap)
4772 swap(bh1, bh2); 4784 swap(bh1, bh2);
4773 *bh_s = bh1; 4785 *bh_s = bh1;
4774 *bh_t = bh2; 4786 *bh_t = bh2;
4775 4787
4776 trace_ocfs2_double_lock_end( 4788 trace_ocfs2_double_lock_end(
4777 (unsigned long long)o 4789 (unsigned long long)oi1->ip_blkno,
4778 (unsigned long long)o 4790 (unsigned long long)oi2->ip_blkno);
4779 4791
4780 return 0; 4792 return 0;
4781 4793
4782 out_cl1: 4794 out_cl1:
4783 ocfs2_inode_unlock(inode1, 1); 4795 ocfs2_inode_unlock(inode1, 1);
4784 brelse(bh1); 4796 brelse(bh1);
4785 out_rw2: 4797 out_rw2:
4786 ocfs2_rw_unlock(inode2, 1); 4798 ocfs2_rw_unlock(inode2, 1);
4787 out_i2: 4799 out_i2:
4788 ocfs2_rw_unlock(inode1, 1); 4800 ocfs2_rw_unlock(inode1, 1);
4789 out_i1: 4801 out_i1:
4790 unlock_two_nondirectories(s_inode, t_ 4802 unlock_two_nondirectories(s_inode, t_inode);
4791 return status; 4803 return status;
4792 } 4804 }
4793 4805
4794 /* Unlock both inodes and release buffers. */ 4806 /* Unlock both inodes and release buffers. */
4795 void ocfs2_reflink_inodes_unlock(struct inode 4807 void ocfs2_reflink_inodes_unlock(struct inode *s_inode,
4796 struct buffe 4808 struct buffer_head *s_bh,
4797 struct inode 4809 struct inode *t_inode,
4798 struct buffe 4810 struct buffer_head *t_bh)
4799 { 4811 {
4800 ocfs2_inode_unlock(s_inode, 1); 4812 ocfs2_inode_unlock(s_inode, 1);
4801 ocfs2_rw_unlock(s_inode, 1); 4813 ocfs2_rw_unlock(s_inode, 1);
4802 brelse(s_bh); 4814 brelse(s_bh);
4803 if (s_inode != t_inode) { 4815 if (s_inode != t_inode) {
4804 ocfs2_inode_unlock(t_inode, 1 4816 ocfs2_inode_unlock(t_inode, 1);
4805 ocfs2_rw_unlock(t_inode, 1); 4817 ocfs2_rw_unlock(t_inode, 1);
4806 brelse(t_bh); 4818 brelse(t_bh);
4807 } 4819 }
4808 unlock_two_nondirectories(s_inode, t_ 4820 unlock_two_nondirectories(s_inode, t_inode);
4809 } 4821 }
4810 4822
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.