Loading...
1/* -*- mode: c; c-basic-offset: 8; -*-
2 * vim: noexpandtab sw=8 ts=8 sts=0:
3 *
4 * alloc.c
5 *
6 * Extent allocs and frees
7 *
8 * Copyright (C) 2002, 2004 Oracle. All rights reserved.
9 *
10 * This program is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU General Public
12 * License as published by the Free Software Foundation; either
13 * version 2 of the License, or (at your option) any later version.
14 *
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 * General Public License for more details.
19 *
20 * You should have received a copy of the GNU General Public
21 * License along with this program; if not, write to the
22 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
23 * Boston, MA 021110-1307, USA.
24 */
25
26#include <linux/fs.h>
27#include <linux/types.h>
28#include <linux/slab.h>
29#include <linux/highmem.h>
30#include <linux/swap.h>
31#include <linux/quotaops.h>
32#include <linux/blkdev.h>
33
34#include <cluster/masklog.h>
35
36#include "ocfs2.h"
37
38#include "alloc.h"
39#include "aops.h"
40#include "blockcheck.h"
41#include "dlmglue.h"
42#include "extent_map.h"
43#include "inode.h"
44#include "journal.h"
45#include "localalloc.h"
46#include "suballoc.h"
47#include "sysfile.h"
48#include "file.h"
49#include "super.h"
50#include "uptodate.h"
51#include "xattr.h"
52#include "refcounttree.h"
53#include "ocfs2_trace.h"
54
55#include "buffer_head_io.h"
56
57enum ocfs2_contig_type {
58 CONTIG_NONE = 0,
59 CONTIG_LEFT,
60 CONTIG_RIGHT,
61 CONTIG_LEFTRIGHT,
62};
63
64static enum ocfs2_contig_type
65 ocfs2_extent_rec_contig(struct super_block *sb,
66 struct ocfs2_extent_rec *ext,
67 struct ocfs2_extent_rec *insert_rec);
68/*
69 * Operations for a specific extent tree type.
70 *
71 * To implement an on-disk btree (extent tree) type in ocfs2, add
72 * an ocfs2_extent_tree_operations structure and the matching
73 * ocfs2_init_<thingy>_extent_tree() function. That's pretty much it
74 * for the allocation portion of the extent tree.
75 */
76struct ocfs2_extent_tree_operations {
77 /*
78 * last_eb_blk is the block number of the right most leaf extent
79 * block. Most on-disk structures containing an extent tree store
80 * this value for fast access. The ->eo_set_last_eb_blk() and
81 * ->eo_get_last_eb_blk() operations access this value. They are
82 * both required.
83 */
84 void (*eo_set_last_eb_blk)(struct ocfs2_extent_tree *et,
85 u64 blkno);
86 u64 (*eo_get_last_eb_blk)(struct ocfs2_extent_tree *et);
87
88 /*
89 * The on-disk structure usually keeps track of how many total
90 * clusters are stored in this extent tree. This function updates
91 * that value. new_clusters is the delta, and must be
92 * added to the total. Required.
93 */
94 void (*eo_update_clusters)(struct ocfs2_extent_tree *et,
95 u32 new_clusters);
96
97 /*
98 * If this extent tree is supported by an extent map, insert
99 * a record into the map.
100 */
101 void (*eo_extent_map_insert)(struct ocfs2_extent_tree *et,
102 struct ocfs2_extent_rec *rec);
103
104 /*
105 * If this extent tree is supported by an extent map, truncate the
106 * map to clusters,
107 */
108 void (*eo_extent_map_truncate)(struct ocfs2_extent_tree *et,
109 u32 clusters);
110
111 /*
112 * If ->eo_insert_check() exists, it is called before rec is
113 * inserted into the extent tree. It is optional.
114 */
115 int (*eo_insert_check)(struct ocfs2_extent_tree *et,
116 struct ocfs2_extent_rec *rec);
117 int (*eo_sanity_check)(struct ocfs2_extent_tree *et);
118
119 /*
120 * --------------------------------------------------------------
121 * The remaining are internal to ocfs2_extent_tree and don't have
122 * accessor functions
123 */
124
125 /*
126 * ->eo_fill_root_el() takes et->et_object and sets et->et_root_el.
127 * It is required.
128 */
129 void (*eo_fill_root_el)(struct ocfs2_extent_tree *et);
130
131 /*
132 * ->eo_fill_max_leaf_clusters sets et->et_max_leaf_clusters if
133 * it exists. If it does not, et->et_max_leaf_clusters is set
134 * to 0 (unlimited). Optional.
135 */
136 void (*eo_fill_max_leaf_clusters)(struct ocfs2_extent_tree *et);
137
138 /*
139 * ->eo_extent_contig test whether the 2 ocfs2_extent_rec
140 * are contiguous or not. Optional. Don't need to set it if use
141 * ocfs2_extent_rec as the tree leaf.
142 */
143 enum ocfs2_contig_type
144 (*eo_extent_contig)(struct ocfs2_extent_tree *et,
145 struct ocfs2_extent_rec *ext,
146 struct ocfs2_extent_rec *insert_rec);
147};
148
149
150/*
151 * Pre-declare ocfs2_dinode_et_ops so we can use it as a sanity check
152 * in the methods.
153 */
154static u64 ocfs2_dinode_get_last_eb_blk(struct ocfs2_extent_tree *et);
155static void ocfs2_dinode_set_last_eb_blk(struct ocfs2_extent_tree *et,
156 u64 blkno);
157static void ocfs2_dinode_update_clusters(struct ocfs2_extent_tree *et,
158 u32 clusters);
159static void ocfs2_dinode_extent_map_insert(struct ocfs2_extent_tree *et,
160 struct ocfs2_extent_rec *rec);
161static void ocfs2_dinode_extent_map_truncate(struct ocfs2_extent_tree *et,
162 u32 clusters);
163static int ocfs2_dinode_insert_check(struct ocfs2_extent_tree *et,
164 struct ocfs2_extent_rec *rec);
165static int ocfs2_dinode_sanity_check(struct ocfs2_extent_tree *et);
166static void ocfs2_dinode_fill_root_el(struct ocfs2_extent_tree *et);
167static struct ocfs2_extent_tree_operations ocfs2_dinode_et_ops = {
168 .eo_set_last_eb_blk = ocfs2_dinode_set_last_eb_blk,
169 .eo_get_last_eb_blk = ocfs2_dinode_get_last_eb_blk,
170 .eo_update_clusters = ocfs2_dinode_update_clusters,
171 .eo_extent_map_insert = ocfs2_dinode_extent_map_insert,
172 .eo_extent_map_truncate = ocfs2_dinode_extent_map_truncate,
173 .eo_insert_check = ocfs2_dinode_insert_check,
174 .eo_sanity_check = ocfs2_dinode_sanity_check,
175 .eo_fill_root_el = ocfs2_dinode_fill_root_el,
176};
177
178static void ocfs2_dinode_set_last_eb_blk(struct ocfs2_extent_tree *et,
179 u64 blkno)
180{
181 struct ocfs2_dinode *di = et->et_object;
182
183 BUG_ON(et->et_ops != &ocfs2_dinode_et_ops);
184 di->i_last_eb_blk = cpu_to_le64(blkno);
185}
186
187static u64 ocfs2_dinode_get_last_eb_blk(struct ocfs2_extent_tree *et)
188{
189 struct ocfs2_dinode *di = et->et_object;
190
191 BUG_ON(et->et_ops != &ocfs2_dinode_et_ops);
192 return le64_to_cpu(di->i_last_eb_blk);
193}
194
195static void ocfs2_dinode_update_clusters(struct ocfs2_extent_tree *et,
196 u32 clusters)
197{
198 struct ocfs2_inode_info *oi = cache_info_to_inode(et->et_ci);
199 struct ocfs2_dinode *di = et->et_object;
200
201 le32_add_cpu(&di->i_clusters, clusters);
202 spin_lock(&oi->ip_lock);
203 oi->ip_clusters = le32_to_cpu(di->i_clusters);
204 spin_unlock(&oi->ip_lock);
205}
206
207static void ocfs2_dinode_extent_map_insert(struct ocfs2_extent_tree *et,
208 struct ocfs2_extent_rec *rec)
209{
210 struct inode *inode = &cache_info_to_inode(et->et_ci)->vfs_inode;
211
212 ocfs2_extent_map_insert_rec(inode, rec);
213}
214
215static void ocfs2_dinode_extent_map_truncate(struct ocfs2_extent_tree *et,
216 u32 clusters)
217{
218 struct inode *inode = &cache_info_to_inode(et->et_ci)->vfs_inode;
219
220 ocfs2_extent_map_trunc(inode, clusters);
221}
222
223static int ocfs2_dinode_insert_check(struct ocfs2_extent_tree *et,
224 struct ocfs2_extent_rec *rec)
225{
226 struct ocfs2_inode_info *oi = cache_info_to_inode(et->et_ci);
227 struct ocfs2_super *osb = OCFS2_SB(oi->vfs_inode.i_sb);
228
229 BUG_ON(oi->ip_dyn_features & OCFS2_INLINE_DATA_FL);
230 mlog_bug_on_msg(!ocfs2_sparse_alloc(osb) &&
231 (oi->ip_clusters != le32_to_cpu(rec->e_cpos)),
232 "Device %s, asking for sparse allocation: inode %llu, "
233 "cpos %u, clusters %u\n",
234 osb->dev_str,
235 (unsigned long long)oi->ip_blkno,
236 rec->e_cpos, oi->ip_clusters);
237
238 return 0;
239}
240
241static int ocfs2_dinode_sanity_check(struct ocfs2_extent_tree *et)
242{
243 struct ocfs2_dinode *di = et->et_object;
244
245 BUG_ON(et->et_ops != &ocfs2_dinode_et_ops);
246 BUG_ON(!OCFS2_IS_VALID_DINODE(di));
247
248 return 0;
249}
250
251static void ocfs2_dinode_fill_root_el(struct ocfs2_extent_tree *et)
252{
253 struct ocfs2_dinode *di = et->et_object;
254
255 et->et_root_el = &di->id2.i_list;
256}
257
258
259static void ocfs2_xattr_value_fill_root_el(struct ocfs2_extent_tree *et)
260{
261 struct ocfs2_xattr_value_buf *vb = et->et_object;
262
263 et->et_root_el = &vb->vb_xv->xr_list;
264}
265
266static void ocfs2_xattr_value_set_last_eb_blk(struct ocfs2_extent_tree *et,
267 u64 blkno)
268{
269 struct ocfs2_xattr_value_buf *vb = et->et_object;
270
271 vb->vb_xv->xr_last_eb_blk = cpu_to_le64(blkno);
272}
273
274static u64 ocfs2_xattr_value_get_last_eb_blk(struct ocfs2_extent_tree *et)
275{
276 struct ocfs2_xattr_value_buf *vb = et->et_object;
277
278 return le64_to_cpu(vb->vb_xv->xr_last_eb_blk);
279}
280
281static void ocfs2_xattr_value_update_clusters(struct ocfs2_extent_tree *et,
282 u32 clusters)
283{
284 struct ocfs2_xattr_value_buf *vb = et->et_object;
285
286 le32_add_cpu(&vb->vb_xv->xr_clusters, clusters);
287}
288
289static struct ocfs2_extent_tree_operations ocfs2_xattr_value_et_ops = {
290 .eo_set_last_eb_blk = ocfs2_xattr_value_set_last_eb_blk,
291 .eo_get_last_eb_blk = ocfs2_xattr_value_get_last_eb_blk,
292 .eo_update_clusters = ocfs2_xattr_value_update_clusters,
293 .eo_fill_root_el = ocfs2_xattr_value_fill_root_el,
294};
295
296static void ocfs2_xattr_tree_fill_root_el(struct ocfs2_extent_tree *et)
297{
298 struct ocfs2_xattr_block *xb = et->et_object;
299
300 et->et_root_el = &xb->xb_attrs.xb_root.xt_list;
301}
302
303static void ocfs2_xattr_tree_fill_max_leaf_clusters(struct ocfs2_extent_tree *et)
304{
305 struct super_block *sb = ocfs2_metadata_cache_get_super(et->et_ci);
306 et->et_max_leaf_clusters =
307 ocfs2_clusters_for_bytes(sb, OCFS2_MAX_XATTR_TREE_LEAF_SIZE);
308}
309
310static void ocfs2_xattr_tree_set_last_eb_blk(struct ocfs2_extent_tree *et,
311 u64 blkno)
312{
313 struct ocfs2_xattr_block *xb = et->et_object;
314 struct ocfs2_xattr_tree_root *xt = &xb->xb_attrs.xb_root;
315
316 xt->xt_last_eb_blk = cpu_to_le64(blkno);
317}
318
319static u64 ocfs2_xattr_tree_get_last_eb_blk(struct ocfs2_extent_tree *et)
320{
321 struct ocfs2_xattr_block *xb = et->et_object;
322 struct ocfs2_xattr_tree_root *xt = &xb->xb_attrs.xb_root;
323
324 return le64_to_cpu(xt->xt_last_eb_blk);
325}
326
327static void ocfs2_xattr_tree_update_clusters(struct ocfs2_extent_tree *et,
328 u32 clusters)
329{
330 struct ocfs2_xattr_block *xb = et->et_object;
331
332 le32_add_cpu(&xb->xb_attrs.xb_root.xt_clusters, clusters);
333}
334
335static struct ocfs2_extent_tree_operations ocfs2_xattr_tree_et_ops = {
336 .eo_set_last_eb_blk = ocfs2_xattr_tree_set_last_eb_blk,
337 .eo_get_last_eb_blk = ocfs2_xattr_tree_get_last_eb_blk,
338 .eo_update_clusters = ocfs2_xattr_tree_update_clusters,
339 .eo_fill_root_el = ocfs2_xattr_tree_fill_root_el,
340 .eo_fill_max_leaf_clusters = ocfs2_xattr_tree_fill_max_leaf_clusters,
341};
342
343static void ocfs2_dx_root_set_last_eb_blk(struct ocfs2_extent_tree *et,
344 u64 blkno)
345{
346 struct ocfs2_dx_root_block *dx_root = et->et_object;
347
348 dx_root->dr_last_eb_blk = cpu_to_le64(blkno);
349}
350
351static u64 ocfs2_dx_root_get_last_eb_blk(struct ocfs2_extent_tree *et)
352{
353 struct ocfs2_dx_root_block *dx_root = et->et_object;
354
355 return le64_to_cpu(dx_root->dr_last_eb_blk);
356}
357
358static void ocfs2_dx_root_update_clusters(struct ocfs2_extent_tree *et,
359 u32 clusters)
360{
361 struct ocfs2_dx_root_block *dx_root = et->et_object;
362
363 le32_add_cpu(&dx_root->dr_clusters, clusters);
364}
365
366static int ocfs2_dx_root_sanity_check(struct ocfs2_extent_tree *et)
367{
368 struct ocfs2_dx_root_block *dx_root = et->et_object;
369
370 BUG_ON(!OCFS2_IS_VALID_DX_ROOT(dx_root));
371
372 return 0;
373}
374
375static void ocfs2_dx_root_fill_root_el(struct ocfs2_extent_tree *et)
376{
377 struct ocfs2_dx_root_block *dx_root = et->et_object;
378
379 et->et_root_el = &dx_root->dr_list;
380}
381
382static struct ocfs2_extent_tree_operations ocfs2_dx_root_et_ops = {
383 .eo_set_last_eb_blk = ocfs2_dx_root_set_last_eb_blk,
384 .eo_get_last_eb_blk = ocfs2_dx_root_get_last_eb_blk,
385 .eo_update_clusters = ocfs2_dx_root_update_clusters,
386 .eo_sanity_check = ocfs2_dx_root_sanity_check,
387 .eo_fill_root_el = ocfs2_dx_root_fill_root_el,
388};
389
390static void ocfs2_refcount_tree_fill_root_el(struct ocfs2_extent_tree *et)
391{
392 struct ocfs2_refcount_block *rb = et->et_object;
393
394 et->et_root_el = &rb->rf_list;
395}
396
397static void ocfs2_refcount_tree_set_last_eb_blk(struct ocfs2_extent_tree *et,
398 u64 blkno)
399{
400 struct ocfs2_refcount_block *rb = et->et_object;
401
402 rb->rf_last_eb_blk = cpu_to_le64(blkno);
403}
404
405static u64 ocfs2_refcount_tree_get_last_eb_blk(struct ocfs2_extent_tree *et)
406{
407 struct ocfs2_refcount_block *rb = et->et_object;
408
409 return le64_to_cpu(rb->rf_last_eb_blk);
410}
411
412static void ocfs2_refcount_tree_update_clusters(struct ocfs2_extent_tree *et,
413 u32 clusters)
414{
415 struct ocfs2_refcount_block *rb = et->et_object;
416
417 le32_add_cpu(&rb->rf_clusters, clusters);
418}
419
420static enum ocfs2_contig_type
421ocfs2_refcount_tree_extent_contig(struct ocfs2_extent_tree *et,
422 struct ocfs2_extent_rec *ext,
423 struct ocfs2_extent_rec *insert_rec)
424{
425 return CONTIG_NONE;
426}
427
428static struct ocfs2_extent_tree_operations ocfs2_refcount_tree_et_ops = {
429 .eo_set_last_eb_blk = ocfs2_refcount_tree_set_last_eb_blk,
430 .eo_get_last_eb_blk = ocfs2_refcount_tree_get_last_eb_blk,
431 .eo_update_clusters = ocfs2_refcount_tree_update_clusters,
432 .eo_fill_root_el = ocfs2_refcount_tree_fill_root_el,
433 .eo_extent_contig = ocfs2_refcount_tree_extent_contig,
434};
435
436static void __ocfs2_init_extent_tree(struct ocfs2_extent_tree *et,
437 struct ocfs2_caching_info *ci,
438 struct buffer_head *bh,
439 ocfs2_journal_access_func access,
440 void *obj,
441 struct ocfs2_extent_tree_operations *ops)
442{
443 et->et_ops = ops;
444 et->et_root_bh = bh;
445 et->et_ci = ci;
446 et->et_root_journal_access = access;
447 if (!obj)
448 obj = (void *)bh->b_data;
449 et->et_object = obj;
450
451 et->et_ops->eo_fill_root_el(et);
452 if (!et->et_ops->eo_fill_max_leaf_clusters)
453 et->et_max_leaf_clusters = 0;
454 else
455 et->et_ops->eo_fill_max_leaf_clusters(et);
456}
457
458void ocfs2_init_dinode_extent_tree(struct ocfs2_extent_tree *et,
459 struct ocfs2_caching_info *ci,
460 struct buffer_head *bh)
461{
462 __ocfs2_init_extent_tree(et, ci, bh, ocfs2_journal_access_di,
463 NULL, &ocfs2_dinode_et_ops);
464}
465
466void ocfs2_init_xattr_tree_extent_tree(struct ocfs2_extent_tree *et,
467 struct ocfs2_caching_info *ci,
468 struct buffer_head *bh)
469{
470 __ocfs2_init_extent_tree(et, ci, bh, ocfs2_journal_access_xb,
471 NULL, &ocfs2_xattr_tree_et_ops);
472}
473
474void ocfs2_init_xattr_value_extent_tree(struct ocfs2_extent_tree *et,
475 struct ocfs2_caching_info *ci,
476 struct ocfs2_xattr_value_buf *vb)
477{
478 __ocfs2_init_extent_tree(et, ci, vb->vb_bh, vb->vb_access, vb,
479 &ocfs2_xattr_value_et_ops);
480}
481
482void ocfs2_init_dx_root_extent_tree(struct ocfs2_extent_tree *et,
483 struct ocfs2_caching_info *ci,
484 struct buffer_head *bh)
485{
486 __ocfs2_init_extent_tree(et, ci, bh, ocfs2_journal_access_dr,
487 NULL, &ocfs2_dx_root_et_ops);
488}
489
490void ocfs2_init_refcount_extent_tree(struct ocfs2_extent_tree *et,
491 struct ocfs2_caching_info *ci,
492 struct buffer_head *bh)
493{
494 __ocfs2_init_extent_tree(et, ci, bh, ocfs2_journal_access_rb,
495 NULL, &ocfs2_refcount_tree_et_ops);
496}
497
498static inline void ocfs2_et_set_last_eb_blk(struct ocfs2_extent_tree *et,
499 u64 new_last_eb_blk)
500{
501 et->et_ops->eo_set_last_eb_blk(et, new_last_eb_blk);
502}
503
504static inline u64 ocfs2_et_get_last_eb_blk(struct ocfs2_extent_tree *et)
505{
506 return et->et_ops->eo_get_last_eb_blk(et);
507}
508
509static inline void ocfs2_et_update_clusters(struct ocfs2_extent_tree *et,
510 u32 clusters)
511{
512 et->et_ops->eo_update_clusters(et, clusters);
513}
514
515static inline void ocfs2_et_extent_map_insert(struct ocfs2_extent_tree *et,
516 struct ocfs2_extent_rec *rec)
517{
518 if (et->et_ops->eo_extent_map_insert)
519 et->et_ops->eo_extent_map_insert(et, rec);
520}
521
522static inline void ocfs2_et_extent_map_truncate(struct ocfs2_extent_tree *et,
523 u32 clusters)
524{
525 if (et->et_ops->eo_extent_map_truncate)
526 et->et_ops->eo_extent_map_truncate(et, clusters);
527}
528
529static inline int ocfs2_et_root_journal_access(handle_t *handle,
530 struct ocfs2_extent_tree *et,
531 int type)
532{
533 return et->et_root_journal_access(handle, et->et_ci, et->et_root_bh,
534 type);
535}
536
537static inline enum ocfs2_contig_type
538 ocfs2_et_extent_contig(struct ocfs2_extent_tree *et,
539 struct ocfs2_extent_rec *rec,
540 struct ocfs2_extent_rec *insert_rec)
541{
542 if (et->et_ops->eo_extent_contig)
543 return et->et_ops->eo_extent_contig(et, rec, insert_rec);
544
545 return ocfs2_extent_rec_contig(
546 ocfs2_metadata_cache_get_super(et->et_ci),
547 rec, insert_rec);
548}
549
550static inline int ocfs2_et_insert_check(struct ocfs2_extent_tree *et,
551 struct ocfs2_extent_rec *rec)
552{
553 int ret = 0;
554
555 if (et->et_ops->eo_insert_check)
556 ret = et->et_ops->eo_insert_check(et, rec);
557 return ret;
558}
559
560static inline int ocfs2_et_sanity_check(struct ocfs2_extent_tree *et)
561{
562 int ret = 0;
563
564 if (et->et_ops->eo_sanity_check)
565 ret = et->et_ops->eo_sanity_check(et);
566 return ret;
567}
568
569static int ocfs2_cache_extent_block_free(struct ocfs2_cached_dealloc_ctxt *ctxt,
570 struct ocfs2_extent_block *eb);
571static void ocfs2_adjust_rightmost_records(handle_t *handle,
572 struct ocfs2_extent_tree *et,
573 struct ocfs2_path *path,
574 struct ocfs2_extent_rec *insert_rec);
575/*
576 * Reset the actual path elements so that we can re-use the structure
577 * to build another path. Generally, this involves freeing the buffer
578 * heads.
579 */
580void ocfs2_reinit_path(struct ocfs2_path *path, int keep_root)
581{
582 int i, start = 0, depth = 0;
583 struct ocfs2_path_item *node;
584
585 if (keep_root)
586 start = 1;
587
588 for(i = start; i < path_num_items(path); i++) {
589 node = &path->p_node[i];
590
591 brelse(node->bh);
592 node->bh = NULL;
593 node->el = NULL;
594 }
595
596 /*
597 * Tree depth may change during truncate, or insert. If we're
598 * keeping the root extent list, then make sure that our path
599 * structure reflects the proper depth.
600 */
601 if (keep_root)
602 depth = le16_to_cpu(path_root_el(path)->l_tree_depth);
603 else
604 path_root_access(path) = NULL;
605
606 path->p_tree_depth = depth;
607}
608
609void ocfs2_free_path(struct ocfs2_path *path)
610{
611 if (path) {
612 ocfs2_reinit_path(path, 0);
613 kfree(path);
614 }
615}
616
617/*
618 * All the elements of src into dest. After this call, src could be freed
619 * without affecting dest.
620 *
621 * Both paths should have the same root. Any non-root elements of dest
622 * will be freed.
623 */
624static void ocfs2_cp_path(struct ocfs2_path *dest, struct ocfs2_path *src)
625{
626 int i;
627
628 BUG_ON(path_root_bh(dest) != path_root_bh(src));
629 BUG_ON(path_root_el(dest) != path_root_el(src));
630 BUG_ON(path_root_access(dest) != path_root_access(src));
631
632 ocfs2_reinit_path(dest, 1);
633
634 for(i = 1; i < OCFS2_MAX_PATH_DEPTH; i++) {
635 dest->p_node[i].bh = src->p_node[i].bh;
636 dest->p_node[i].el = src->p_node[i].el;
637
638 if (dest->p_node[i].bh)
639 get_bh(dest->p_node[i].bh);
640 }
641}
642
643/*
644 * Make the *dest path the same as src and re-initialize src path to
645 * have a root only.
646 */
647static void ocfs2_mv_path(struct ocfs2_path *dest, struct ocfs2_path *src)
648{
649 int i;
650
651 BUG_ON(path_root_bh(dest) != path_root_bh(src));
652 BUG_ON(path_root_access(dest) != path_root_access(src));
653
654 for(i = 1; i < OCFS2_MAX_PATH_DEPTH; i++) {
655 brelse(dest->p_node[i].bh);
656
657 dest->p_node[i].bh = src->p_node[i].bh;
658 dest->p_node[i].el = src->p_node[i].el;
659
660 src->p_node[i].bh = NULL;
661 src->p_node[i].el = NULL;
662 }
663}
664
665/*
666 * Insert an extent block at given index.
667 *
668 * This will not take an additional reference on eb_bh.
669 */
670static inline void ocfs2_path_insert_eb(struct ocfs2_path *path, int index,
671 struct buffer_head *eb_bh)
672{
673 struct ocfs2_extent_block *eb = (struct ocfs2_extent_block *)eb_bh->b_data;
674
675 /*
676 * Right now, no root bh is an extent block, so this helps
677 * catch code errors with dinode trees. The assertion can be
678 * safely removed if we ever need to insert extent block
679 * structures at the root.
680 */
681 BUG_ON(index == 0);
682
683 path->p_node[index].bh = eb_bh;
684 path->p_node[index].el = &eb->h_list;
685}
686
687static struct ocfs2_path *ocfs2_new_path(struct buffer_head *root_bh,
688 struct ocfs2_extent_list *root_el,
689 ocfs2_journal_access_func access)
690{
691 struct ocfs2_path *path;
692
693 BUG_ON(le16_to_cpu(root_el->l_tree_depth) >= OCFS2_MAX_PATH_DEPTH);
694
695 path = kzalloc(sizeof(*path), GFP_NOFS);
696 if (path) {
697 path->p_tree_depth = le16_to_cpu(root_el->l_tree_depth);
698 get_bh(root_bh);
699 path_root_bh(path) = root_bh;
700 path_root_el(path) = root_el;
701 path_root_access(path) = access;
702 }
703
704 return path;
705}
706
707struct ocfs2_path *ocfs2_new_path_from_path(struct ocfs2_path *path)
708{
709 return ocfs2_new_path(path_root_bh(path), path_root_el(path),
710 path_root_access(path));
711}
712
713struct ocfs2_path *ocfs2_new_path_from_et(struct ocfs2_extent_tree *et)
714{
715 return ocfs2_new_path(et->et_root_bh, et->et_root_el,
716 et->et_root_journal_access);
717}
718
719/*
720 * Journal the buffer at depth idx. All idx>0 are extent_blocks,
721 * otherwise it's the root_access function.
722 *
723 * I don't like the way this function's name looks next to
724 * ocfs2_journal_access_path(), but I don't have a better one.
725 */
726int ocfs2_path_bh_journal_access(handle_t *handle,
727 struct ocfs2_caching_info *ci,
728 struct ocfs2_path *path,
729 int idx)
730{
731 ocfs2_journal_access_func access = path_root_access(path);
732
733 if (!access)
734 access = ocfs2_journal_access;
735
736 if (idx)
737 access = ocfs2_journal_access_eb;
738
739 return access(handle, ci, path->p_node[idx].bh,
740 OCFS2_JOURNAL_ACCESS_WRITE);
741}
742
743/*
744 * Convenience function to journal all components in a path.
745 */
746int ocfs2_journal_access_path(struct ocfs2_caching_info *ci,
747 handle_t *handle,
748 struct ocfs2_path *path)
749{
750 int i, ret = 0;
751
752 if (!path)
753 goto out;
754
755 for(i = 0; i < path_num_items(path); i++) {
756 ret = ocfs2_path_bh_journal_access(handle, ci, path, i);
757 if (ret < 0) {
758 mlog_errno(ret);
759 goto out;
760 }
761 }
762
763out:
764 return ret;
765}
766
767/*
768 * Return the index of the extent record which contains cluster #v_cluster.
769 * -1 is returned if it was not found.
770 *
771 * Should work fine on interior and exterior nodes.
772 */
773int ocfs2_search_extent_list(struct ocfs2_extent_list *el, u32 v_cluster)
774{
775 int ret = -1;
776 int i;
777 struct ocfs2_extent_rec *rec;
778 u32 rec_end, rec_start, clusters;
779
780 for(i = 0; i < le16_to_cpu(el->l_next_free_rec); i++) {
781 rec = &el->l_recs[i];
782
783 rec_start = le32_to_cpu(rec->e_cpos);
784 clusters = ocfs2_rec_clusters(el, rec);
785
786 rec_end = rec_start + clusters;
787
788 if (v_cluster >= rec_start && v_cluster < rec_end) {
789 ret = i;
790 break;
791 }
792 }
793
794 return ret;
795}
796
797/*
798 * NOTE: ocfs2_block_extent_contig(), ocfs2_extents_adjacent() and
799 * ocfs2_extent_rec_contig only work properly against leaf nodes!
800 */
801static int ocfs2_block_extent_contig(struct super_block *sb,
802 struct ocfs2_extent_rec *ext,
803 u64 blkno)
804{
805 u64 blk_end = le64_to_cpu(ext->e_blkno);
806
807 blk_end += ocfs2_clusters_to_blocks(sb,
808 le16_to_cpu(ext->e_leaf_clusters));
809
810 return blkno == blk_end;
811}
812
813static int ocfs2_extents_adjacent(struct ocfs2_extent_rec *left,
814 struct ocfs2_extent_rec *right)
815{
816 u32 left_range;
817
818 left_range = le32_to_cpu(left->e_cpos) +
819 le16_to_cpu(left->e_leaf_clusters);
820
821 return (left_range == le32_to_cpu(right->e_cpos));
822}
823
824static enum ocfs2_contig_type
825 ocfs2_extent_rec_contig(struct super_block *sb,
826 struct ocfs2_extent_rec *ext,
827 struct ocfs2_extent_rec *insert_rec)
828{
829 u64 blkno = le64_to_cpu(insert_rec->e_blkno);
830
831 /*
832 * Refuse to coalesce extent records with different flag
833 * fields - we don't want to mix unwritten extents with user
834 * data.
835 */
836 if (ext->e_flags != insert_rec->e_flags)
837 return CONTIG_NONE;
838
839 if (ocfs2_extents_adjacent(ext, insert_rec) &&
840 ocfs2_block_extent_contig(sb, ext, blkno))
841 return CONTIG_RIGHT;
842
843 blkno = le64_to_cpu(ext->e_blkno);
844 if (ocfs2_extents_adjacent(insert_rec, ext) &&
845 ocfs2_block_extent_contig(sb, insert_rec, blkno))
846 return CONTIG_LEFT;
847
848 return CONTIG_NONE;
849}
850
851/*
852 * NOTE: We can have pretty much any combination of contiguousness and
853 * appending.
854 *
855 * The usefulness of APPEND_TAIL is more in that it lets us know that
856 * we'll have to update the path to that leaf.
857 */
858enum ocfs2_append_type {
859 APPEND_NONE = 0,
860 APPEND_TAIL,
861};
862
863enum ocfs2_split_type {
864 SPLIT_NONE = 0,
865 SPLIT_LEFT,
866 SPLIT_RIGHT,
867};
868
869struct ocfs2_insert_type {
870 enum ocfs2_split_type ins_split;
871 enum ocfs2_append_type ins_appending;
872 enum ocfs2_contig_type ins_contig;
873 int ins_contig_index;
874 int ins_tree_depth;
875};
876
877struct ocfs2_merge_ctxt {
878 enum ocfs2_contig_type c_contig_type;
879 int c_has_empty_extent;
880 int c_split_covers_rec;
881};
882
883static int ocfs2_validate_extent_block(struct super_block *sb,
884 struct buffer_head *bh)
885{
886 int rc;
887 struct ocfs2_extent_block *eb =
888 (struct ocfs2_extent_block *)bh->b_data;
889
890 trace_ocfs2_validate_extent_block((unsigned long long)bh->b_blocknr);
891
892 BUG_ON(!buffer_uptodate(bh));
893
894 /*
895 * If the ecc fails, we return the error but otherwise
896 * leave the filesystem running. We know any error is
897 * local to this block.
898 */
899 rc = ocfs2_validate_meta_ecc(sb, bh->b_data, &eb->h_check);
900 if (rc) {
901 mlog(ML_ERROR, "Checksum failed for extent block %llu\n",
902 (unsigned long long)bh->b_blocknr);
903 return rc;
904 }
905
906 /*
907 * Errors after here are fatal.
908 */
909
910 if (!OCFS2_IS_VALID_EXTENT_BLOCK(eb)) {
911 ocfs2_error(sb,
912 "Extent block #%llu has bad signature %.*s",
913 (unsigned long long)bh->b_blocknr, 7,
914 eb->h_signature);
915 return -EINVAL;
916 }
917
918 if (le64_to_cpu(eb->h_blkno) != bh->b_blocknr) {
919 ocfs2_error(sb,
920 "Extent block #%llu has an invalid h_blkno "
921 "of %llu",
922 (unsigned long long)bh->b_blocknr,
923 (unsigned long long)le64_to_cpu(eb->h_blkno));
924 return -EINVAL;
925 }
926
927 if (le32_to_cpu(eb->h_fs_generation) != OCFS2_SB(sb)->fs_generation) {
928 ocfs2_error(sb,
929 "Extent block #%llu has an invalid "
930 "h_fs_generation of #%u",
931 (unsigned long long)bh->b_blocknr,
932 le32_to_cpu(eb->h_fs_generation));
933 return -EINVAL;
934 }
935
936 return 0;
937}
938
939int ocfs2_read_extent_block(struct ocfs2_caching_info *ci, u64 eb_blkno,
940 struct buffer_head **bh)
941{
942 int rc;
943 struct buffer_head *tmp = *bh;
944
945 rc = ocfs2_read_block(ci, eb_blkno, &tmp,
946 ocfs2_validate_extent_block);
947
948 /* If ocfs2_read_block() got us a new bh, pass it up. */
949 if (!rc && !*bh)
950 *bh = tmp;
951
952 return rc;
953}
954
955
956/*
957 * How many free extents have we got before we need more meta data?
958 */
959int ocfs2_num_free_extents(struct ocfs2_super *osb,
960 struct ocfs2_extent_tree *et)
961{
962 int retval;
963 struct ocfs2_extent_list *el = NULL;
964 struct ocfs2_extent_block *eb;
965 struct buffer_head *eb_bh = NULL;
966 u64 last_eb_blk = 0;
967
968 el = et->et_root_el;
969 last_eb_blk = ocfs2_et_get_last_eb_blk(et);
970
971 if (last_eb_blk) {
972 retval = ocfs2_read_extent_block(et->et_ci, last_eb_blk,
973 &eb_bh);
974 if (retval < 0) {
975 mlog_errno(retval);
976 goto bail;
977 }
978 eb = (struct ocfs2_extent_block *) eb_bh->b_data;
979 el = &eb->h_list;
980 }
981
982 BUG_ON(el->l_tree_depth != 0);
983
984 retval = le16_to_cpu(el->l_count) - le16_to_cpu(el->l_next_free_rec);
985bail:
986 brelse(eb_bh);
987
988 trace_ocfs2_num_free_extents(retval);
989 return retval;
990}
991
992/* expects array to already be allocated
993 *
994 * sets h_signature, h_blkno, h_suballoc_bit, h_suballoc_slot, and
995 * l_count for you
996 */
997static int ocfs2_create_new_meta_bhs(handle_t *handle,
998 struct ocfs2_extent_tree *et,
999 int wanted,
1000 struct ocfs2_alloc_context *meta_ac,
1001 struct buffer_head *bhs[])
1002{
1003 int count, status, i;
1004 u16 suballoc_bit_start;
1005 u32 num_got;
1006 u64 suballoc_loc, first_blkno;
1007 struct ocfs2_super *osb =
1008 OCFS2_SB(ocfs2_metadata_cache_get_super(et->et_ci));
1009 struct ocfs2_extent_block *eb;
1010
1011 count = 0;
1012 while (count < wanted) {
1013 status = ocfs2_claim_metadata(handle,
1014 meta_ac,
1015 wanted - count,
1016 &suballoc_loc,
1017 &suballoc_bit_start,
1018 &num_got,
1019 &first_blkno);
1020 if (status < 0) {
1021 mlog_errno(status);
1022 goto bail;
1023 }
1024
1025 for(i = count; i < (num_got + count); i++) {
1026 bhs[i] = sb_getblk(osb->sb, first_blkno);
1027 if (bhs[i] == NULL) {
1028 status = -ENOMEM;
1029 mlog_errno(status);
1030 goto bail;
1031 }
1032 ocfs2_set_new_buffer_uptodate(et->et_ci, bhs[i]);
1033
1034 status = ocfs2_journal_access_eb(handle, et->et_ci,
1035 bhs[i],
1036 OCFS2_JOURNAL_ACCESS_CREATE);
1037 if (status < 0) {
1038 mlog_errno(status);
1039 goto bail;
1040 }
1041
1042 memset(bhs[i]->b_data, 0, osb->sb->s_blocksize);
1043 eb = (struct ocfs2_extent_block *) bhs[i]->b_data;
1044 /* Ok, setup the minimal stuff here. */
1045 strcpy(eb->h_signature, OCFS2_EXTENT_BLOCK_SIGNATURE);
1046 eb->h_blkno = cpu_to_le64(first_blkno);
1047 eb->h_fs_generation = cpu_to_le32(osb->fs_generation);
1048 eb->h_suballoc_slot =
1049 cpu_to_le16(meta_ac->ac_alloc_slot);
1050 eb->h_suballoc_loc = cpu_to_le64(suballoc_loc);
1051 eb->h_suballoc_bit = cpu_to_le16(suballoc_bit_start);
1052 eb->h_list.l_count =
1053 cpu_to_le16(ocfs2_extent_recs_per_eb(osb->sb));
1054
1055 suballoc_bit_start++;
1056 first_blkno++;
1057
1058 /* We'll also be dirtied by the caller, so
1059 * this isn't absolutely necessary. */
1060 ocfs2_journal_dirty(handle, bhs[i]);
1061 }
1062
1063 count += num_got;
1064 }
1065
1066 status = 0;
1067bail:
1068 if (status < 0) {
1069 for(i = 0; i < wanted; i++) {
1070 brelse(bhs[i]);
1071 bhs[i] = NULL;
1072 }
1073 mlog_errno(status);
1074 }
1075 return status;
1076}
1077
1078/*
1079 * Helper function for ocfs2_add_branch() and ocfs2_shift_tree_depth().
1080 *
1081 * Returns the sum of the rightmost extent rec logical offset and
1082 * cluster count.
1083 *
1084 * ocfs2_add_branch() uses this to determine what logical cluster
1085 * value should be populated into the leftmost new branch records.
1086 *
1087 * ocfs2_shift_tree_depth() uses this to determine the # clusters
1088 * value for the new topmost tree record.
1089 */
1090static inline u32 ocfs2_sum_rightmost_rec(struct ocfs2_extent_list *el)
1091{
1092 int i;
1093
1094 i = le16_to_cpu(el->l_next_free_rec) - 1;
1095
1096 return le32_to_cpu(el->l_recs[i].e_cpos) +
1097 ocfs2_rec_clusters(el, &el->l_recs[i]);
1098}
1099
1100/*
1101 * Change range of the branches in the right most path according to the leaf
1102 * extent block's rightmost record.
1103 */
1104static int ocfs2_adjust_rightmost_branch(handle_t *handle,
1105 struct ocfs2_extent_tree *et)
1106{
1107 int status;
1108 struct ocfs2_path *path = NULL;
1109 struct ocfs2_extent_list *el;
1110 struct ocfs2_extent_rec *rec;
1111
1112 path = ocfs2_new_path_from_et(et);
1113 if (!path) {
1114 status = -ENOMEM;
1115 return status;
1116 }
1117
1118 status = ocfs2_find_path(et->et_ci, path, UINT_MAX);
1119 if (status < 0) {
1120 mlog_errno(status);
1121 goto out;
1122 }
1123
1124 status = ocfs2_extend_trans(handle, path_num_items(path));
1125 if (status < 0) {
1126 mlog_errno(status);
1127 goto out;
1128 }
1129
1130 status = ocfs2_journal_access_path(et->et_ci, handle, path);
1131 if (status < 0) {
1132 mlog_errno(status);
1133 goto out;
1134 }
1135
1136 el = path_leaf_el(path);
1137 rec = &el->l_recs[le16_to_cpu(el->l_next_free_rec) - 1];
1138
1139 ocfs2_adjust_rightmost_records(handle, et, path, rec);
1140
1141out:
1142 ocfs2_free_path(path);
1143 return status;
1144}
1145
1146/*
1147 * Add an entire tree branch to our inode. eb_bh is the extent block
1148 * to start at, if we don't want to start the branch at the root
1149 * structure.
1150 *
1151 * last_eb_bh is required as we have to update it's next_leaf pointer
1152 * for the new last extent block.
1153 *
1154 * the new branch will be 'empty' in the sense that every block will
1155 * contain a single record with cluster count == 0.
1156 */
1157static int ocfs2_add_branch(handle_t *handle,
1158 struct ocfs2_extent_tree *et,
1159 struct buffer_head *eb_bh,
1160 struct buffer_head **last_eb_bh,
1161 struct ocfs2_alloc_context *meta_ac)
1162{
1163 int status, new_blocks, i;
1164 u64 next_blkno, new_last_eb_blk;
1165 struct buffer_head *bh;
1166 struct buffer_head **new_eb_bhs = NULL;
1167 struct ocfs2_extent_block *eb;
1168 struct ocfs2_extent_list *eb_el;
1169 struct ocfs2_extent_list *el;
1170 u32 new_cpos, root_end;
1171
1172 BUG_ON(!last_eb_bh || !*last_eb_bh);
1173
1174 if (eb_bh) {
1175 eb = (struct ocfs2_extent_block *) eb_bh->b_data;
1176 el = &eb->h_list;
1177 } else
1178 el = et->et_root_el;
1179
1180 /* we never add a branch to a leaf. */
1181 BUG_ON(!el->l_tree_depth);
1182
1183 new_blocks = le16_to_cpu(el->l_tree_depth);
1184
1185 eb = (struct ocfs2_extent_block *)(*last_eb_bh)->b_data;
1186 new_cpos = ocfs2_sum_rightmost_rec(&eb->h_list);
1187 root_end = ocfs2_sum_rightmost_rec(et->et_root_el);
1188
1189 /*
1190 * If there is a gap before the root end and the real end
1191 * of the righmost leaf block, we need to remove the gap
1192 * between new_cpos and root_end first so that the tree
1193 * is consistent after we add a new branch(it will start
1194 * from new_cpos).
1195 */
1196 if (root_end > new_cpos) {
1197 trace_ocfs2_adjust_rightmost_branch(
1198 (unsigned long long)
1199 ocfs2_metadata_cache_owner(et->et_ci),
1200 root_end, new_cpos);
1201
1202 status = ocfs2_adjust_rightmost_branch(handle, et);
1203 if (status) {
1204 mlog_errno(status);
1205 goto bail;
1206 }
1207 }
1208
1209 /* allocate the number of new eb blocks we need */
1210 new_eb_bhs = kcalloc(new_blocks, sizeof(struct buffer_head *),
1211 GFP_KERNEL);
1212 if (!new_eb_bhs) {
1213 status = -ENOMEM;
1214 mlog_errno(status);
1215 goto bail;
1216 }
1217
1218 status = ocfs2_create_new_meta_bhs(handle, et, new_blocks,
1219 meta_ac, new_eb_bhs);
1220 if (status < 0) {
1221 mlog_errno(status);
1222 goto bail;
1223 }
1224
1225 /* Note: new_eb_bhs[new_blocks - 1] is the guy which will be
1226 * linked with the rest of the tree.
1227 * conversly, new_eb_bhs[0] is the new bottommost leaf.
1228 *
1229 * when we leave the loop, new_last_eb_blk will point to the
1230 * newest leaf, and next_blkno will point to the topmost extent
1231 * block. */
1232 next_blkno = new_last_eb_blk = 0;
1233 for(i = 0; i < new_blocks; i++) {
1234 bh = new_eb_bhs[i];
1235 eb = (struct ocfs2_extent_block *) bh->b_data;
1236 /* ocfs2_create_new_meta_bhs() should create it right! */
1237 BUG_ON(!OCFS2_IS_VALID_EXTENT_BLOCK(eb));
1238 eb_el = &eb->h_list;
1239
1240 status = ocfs2_journal_access_eb(handle, et->et_ci, bh,
1241 OCFS2_JOURNAL_ACCESS_CREATE);
1242 if (status < 0) {
1243 mlog_errno(status);
1244 goto bail;
1245 }
1246
1247 eb->h_next_leaf_blk = 0;
1248 eb_el->l_tree_depth = cpu_to_le16(i);
1249 eb_el->l_next_free_rec = cpu_to_le16(1);
1250 /*
1251 * This actually counts as an empty extent as
1252 * c_clusters == 0
1253 */
1254 eb_el->l_recs[0].e_cpos = cpu_to_le32(new_cpos);
1255 eb_el->l_recs[0].e_blkno = cpu_to_le64(next_blkno);
1256 /*
1257 * eb_el isn't always an interior node, but even leaf
1258 * nodes want a zero'd flags and reserved field so
1259 * this gets the whole 32 bits regardless of use.
1260 */
1261 eb_el->l_recs[0].e_int_clusters = cpu_to_le32(0);
1262 if (!eb_el->l_tree_depth)
1263 new_last_eb_blk = le64_to_cpu(eb->h_blkno);
1264
1265 ocfs2_journal_dirty(handle, bh);
1266 next_blkno = le64_to_cpu(eb->h_blkno);
1267 }
1268
1269 /* This is a bit hairy. We want to update up to three blocks
1270 * here without leaving any of them in an inconsistent state
1271 * in case of error. We don't have to worry about
1272 * journal_dirty erroring as it won't unless we've aborted the
1273 * handle (in which case we would never be here) so reserving
1274 * the write with journal_access is all we need to do. */
1275 status = ocfs2_journal_access_eb(handle, et->et_ci, *last_eb_bh,
1276 OCFS2_JOURNAL_ACCESS_WRITE);
1277 if (status < 0) {
1278 mlog_errno(status);
1279 goto bail;
1280 }
1281 status = ocfs2_et_root_journal_access(handle, et,
1282 OCFS2_JOURNAL_ACCESS_WRITE);
1283 if (status < 0) {
1284 mlog_errno(status);
1285 goto bail;
1286 }
1287 if (eb_bh) {
1288 status = ocfs2_journal_access_eb(handle, et->et_ci, eb_bh,
1289 OCFS2_JOURNAL_ACCESS_WRITE);
1290 if (status < 0) {
1291 mlog_errno(status);
1292 goto bail;
1293 }
1294 }
1295
1296 /* Link the new branch into the rest of the tree (el will
1297 * either be on the root_bh, or the extent block passed in. */
1298 i = le16_to_cpu(el->l_next_free_rec);
1299 el->l_recs[i].e_blkno = cpu_to_le64(next_blkno);
1300 el->l_recs[i].e_cpos = cpu_to_le32(new_cpos);
1301 el->l_recs[i].e_int_clusters = 0;
1302 le16_add_cpu(&el->l_next_free_rec, 1);
1303
1304 /* fe needs a new last extent block pointer, as does the
1305 * next_leaf on the previously last-extent-block. */
1306 ocfs2_et_set_last_eb_blk(et, new_last_eb_blk);
1307
1308 eb = (struct ocfs2_extent_block *) (*last_eb_bh)->b_data;
1309 eb->h_next_leaf_blk = cpu_to_le64(new_last_eb_blk);
1310
1311 ocfs2_journal_dirty(handle, *last_eb_bh);
1312 ocfs2_journal_dirty(handle, et->et_root_bh);
1313 if (eb_bh)
1314 ocfs2_journal_dirty(handle, eb_bh);
1315
1316 /*
1317 * Some callers want to track the rightmost leaf so pass it
1318 * back here.
1319 */
1320 brelse(*last_eb_bh);
1321 get_bh(new_eb_bhs[0]);
1322 *last_eb_bh = new_eb_bhs[0];
1323
1324 status = 0;
1325bail:
1326 if (new_eb_bhs) {
1327 for (i = 0; i < new_blocks; i++)
1328 brelse(new_eb_bhs[i]);
1329 kfree(new_eb_bhs);
1330 }
1331
1332 return status;
1333}
1334
1335/*
1336 * adds another level to the allocation tree.
1337 * returns back the new extent block so you can add a branch to it
1338 * after this call.
1339 */
1340static int ocfs2_shift_tree_depth(handle_t *handle,
1341 struct ocfs2_extent_tree *et,
1342 struct ocfs2_alloc_context *meta_ac,
1343 struct buffer_head **ret_new_eb_bh)
1344{
1345 int status, i;
1346 u32 new_clusters;
1347 struct buffer_head *new_eb_bh = NULL;
1348 struct ocfs2_extent_block *eb;
1349 struct ocfs2_extent_list *root_el;
1350 struct ocfs2_extent_list *eb_el;
1351
1352 status = ocfs2_create_new_meta_bhs(handle, et, 1, meta_ac,
1353 &new_eb_bh);
1354 if (status < 0) {
1355 mlog_errno(status);
1356 goto bail;
1357 }
1358
1359 eb = (struct ocfs2_extent_block *) new_eb_bh->b_data;
1360 /* ocfs2_create_new_meta_bhs() should create it right! */
1361 BUG_ON(!OCFS2_IS_VALID_EXTENT_BLOCK(eb));
1362
1363 eb_el = &eb->h_list;
1364 root_el = et->et_root_el;
1365
1366 status = ocfs2_journal_access_eb(handle, et->et_ci, new_eb_bh,
1367 OCFS2_JOURNAL_ACCESS_CREATE);
1368 if (status < 0) {
1369 mlog_errno(status);
1370 goto bail;
1371 }
1372
1373 /* copy the root extent list data into the new extent block */
1374 eb_el->l_tree_depth = root_el->l_tree_depth;
1375 eb_el->l_next_free_rec = root_el->l_next_free_rec;
1376 for (i = 0; i < le16_to_cpu(root_el->l_next_free_rec); i++)
1377 eb_el->l_recs[i] = root_el->l_recs[i];
1378
1379 ocfs2_journal_dirty(handle, new_eb_bh);
1380
1381 status = ocfs2_et_root_journal_access(handle, et,
1382 OCFS2_JOURNAL_ACCESS_WRITE);
1383 if (status < 0) {
1384 mlog_errno(status);
1385 goto bail;
1386 }
1387
1388 new_clusters = ocfs2_sum_rightmost_rec(eb_el);
1389
1390 /* update root_bh now */
1391 le16_add_cpu(&root_el->l_tree_depth, 1);
1392 root_el->l_recs[0].e_cpos = 0;
1393 root_el->l_recs[0].e_blkno = eb->h_blkno;
1394 root_el->l_recs[0].e_int_clusters = cpu_to_le32(new_clusters);
1395 for (i = 1; i < le16_to_cpu(root_el->l_next_free_rec); i++)
1396 memset(&root_el->l_recs[i], 0, sizeof(struct ocfs2_extent_rec));
1397 root_el->l_next_free_rec = cpu_to_le16(1);
1398
1399 /* If this is our 1st tree depth shift, then last_eb_blk
1400 * becomes the allocated extent block */
1401 if (root_el->l_tree_depth == cpu_to_le16(1))
1402 ocfs2_et_set_last_eb_blk(et, le64_to_cpu(eb->h_blkno));
1403
1404 ocfs2_journal_dirty(handle, et->et_root_bh);
1405
1406 *ret_new_eb_bh = new_eb_bh;
1407 new_eb_bh = NULL;
1408 status = 0;
1409bail:
1410 brelse(new_eb_bh);
1411
1412 return status;
1413}
1414
1415/*
1416 * Should only be called when there is no space left in any of the
1417 * leaf nodes. What we want to do is find the lowest tree depth
1418 * non-leaf extent block with room for new records. There are three
1419 * valid results of this search:
1420 *
1421 * 1) a lowest extent block is found, then we pass it back in
1422 * *lowest_eb_bh and return '0'
1423 *
1424 * 2) the search fails to find anything, but the root_el has room. We
1425 * pass NULL back in *lowest_eb_bh, but still return '0'
1426 *
1427 * 3) the search fails to find anything AND the root_el is full, in
1428 * which case we return > 0
1429 *
1430 * return status < 0 indicates an error.
1431 */
1432static int ocfs2_find_branch_target(struct ocfs2_extent_tree *et,
1433 struct buffer_head **target_bh)
1434{
1435 int status = 0, i;
1436 u64 blkno;
1437 struct ocfs2_extent_block *eb;
1438 struct ocfs2_extent_list *el;
1439 struct buffer_head *bh = NULL;
1440 struct buffer_head *lowest_bh = NULL;
1441
1442 *target_bh = NULL;
1443
1444 el = et->et_root_el;
1445
1446 while(le16_to_cpu(el->l_tree_depth) > 1) {
1447 if (le16_to_cpu(el->l_next_free_rec) == 0) {
1448 ocfs2_error(ocfs2_metadata_cache_get_super(et->et_ci),
1449 "Owner %llu has empty "
1450 "extent list (next_free_rec == 0)",
1451 (unsigned long long)ocfs2_metadata_cache_owner(et->et_ci));
1452 status = -EIO;
1453 goto bail;
1454 }
1455 i = le16_to_cpu(el->l_next_free_rec) - 1;
1456 blkno = le64_to_cpu(el->l_recs[i].e_blkno);
1457 if (!blkno) {
1458 ocfs2_error(ocfs2_metadata_cache_get_super(et->et_ci),
1459 "Owner %llu has extent "
1460 "list where extent # %d has no physical "
1461 "block start",
1462 (unsigned long long)ocfs2_metadata_cache_owner(et->et_ci), i);
1463 status = -EIO;
1464 goto bail;
1465 }
1466
1467 brelse(bh);
1468 bh = NULL;
1469
1470 status = ocfs2_read_extent_block(et->et_ci, blkno, &bh);
1471 if (status < 0) {
1472 mlog_errno(status);
1473 goto bail;
1474 }
1475
1476 eb = (struct ocfs2_extent_block *) bh->b_data;
1477 el = &eb->h_list;
1478
1479 if (le16_to_cpu(el->l_next_free_rec) <
1480 le16_to_cpu(el->l_count)) {
1481 brelse(lowest_bh);
1482 lowest_bh = bh;
1483 get_bh(lowest_bh);
1484 }
1485 }
1486
1487 /* If we didn't find one and the fe doesn't have any room,
1488 * then return '1' */
1489 el = et->et_root_el;
1490 if (!lowest_bh && (el->l_next_free_rec == el->l_count))
1491 status = 1;
1492
1493 *target_bh = lowest_bh;
1494bail:
1495 brelse(bh);
1496
1497 return status;
1498}
1499
1500/*
1501 * Grow a b-tree so that it has more records.
1502 *
1503 * We might shift the tree depth in which case existing paths should
1504 * be considered invalid.
1505 *
1506 * Tree depth after the grow is returned via *final_depth.
1507 *
1508 * *last_eb_bh will be updated by ocfs2_add_branch().
1509 */
1510static int ocfs2_grow_tree(handle_t *handle, struct ocfs2_extent_tree *et,
1511 int *final_depth, struct buffer_head **last_eb_bh,
1512 struct ocfs2_alloc_context *meta_ac)
1513{
1514 int ret, shift;
1515 struct ocfs2_extent_list *el = et->et_root_el;
1516 int depth = le16_to_cpu(el->l_tree_depth);
1517 struct buffer_head *bh = NULL;
1518
1519 BUG_ON(meta_ac == NULL);
1520
1521 shift = ocfs2_find_branch_target(et, &bh);
1522 if (shift < 0) {
1523 ret = shift;
1524 mlog_errno(ret);
1525 goto out;
1526 }
1527
1528 /* We traveled all the way to the bottom of the allocation tree
1529 * and didn't find room for any more extents - we need to add
1530 * another tree level */
1531 if (shift) {
1532 BUG_ON(bh);
1533 trace_ocfs2_grow_tree(
1534 (unsigned long long)
1535 ocfs2_metadata_cache_owner(et->et_ci),
1536 depth);
1537
1538 /* ocfs2_shift_tree_depth will return us a buffer with
1539 * the new extent block (so we can pass that to
1540 * ocfs2_add_branch). */
1541 ret = ocfs2_shift_tree_depth(handle, et, meta_ac, &bh);
1542 if (ret < 0) {
1543 mlog_errno(ret);
1544 goto out;
1545 }
1546 depth++;
1547 if (depth == 1) {
1548 /*
1549 * Special case: we have room now if we shifted from
1550 * tree_depth 0, so no more work needs to be done.
1551 *
1552 * We won't be calling add_branch, so pass
1553 * back *last_eb_bh as the new leaf. At depth
1554 * zero, it should always be null so there's
1555 * no reason to brelse.
1556 */
1557 BUG_ON(*last_eb_bh);
1558 get_bh(bh);
1559 *last_eb_bh = bh;
1560 goto out;
1561 }
1562 }
1563
1564 /* call ocfs2_add_branch to add the final part of the tree with
1565 * the new data. */
1566 ret = ocfs2_add_branch(handle, et, bh, last_eb_bh,
1567 meta_ac);
1568 if (ret < 0) {
1569 mlog_errno(ret);
1570 goto out;
1571 }
1572
1573out:
1574 if (final_depth)
1575 *final_depth = depth;
1576 brelse(bh);
1577 return ret;
1578}
1579
1580/*
1581 * This function will discard the rightmost extent record.
1582 */
1583static void ocfs2_shift_records_right(struct ocfs2_extent_list *el)
1584{
1585 int next_free = le16_to_cpu(el->l_next_free_rec);
1586 int count = le16_to_cpu(el->l_count);
1587 unsigned int num_bytes;
1588
1589 BUG_ON(!next_free);
1590 /* This will cause us to go off the end of our extent list. */
1591 BUG_ON(next_free >= count);
1592
1593 num_bytes = sizeof(struct ocfs2_extent_rec) * next_free;
1594
1595 memmove(&el->l_recs[1], &el->l_recs[0], num_bytes);
1596}
1597
1598static void ocfs2_rotate_leaf(struct ocfs2_extent_list *el,
1599 struct ocfs2_extent_rec *insert_rec)
1600{
1601 int i, insert_index, next_free, has_empty, num_bytes;
1602 u32 insert_cpos = le32_to_cpu(insert_rec->e_cpos);
1603 struct ocfs2_extent_rec *rec;
1604
1605 next_free = le16_to_cpu(el->l_next_free_rec);
1606 has_empty = ocfs2_is_empty_extent(&el->l_recs[0]);
1607
1608 BUG_ON(!next_free);
1609
1610 /* The tree code before us didn't allow enough room in the leaf. */
1611 BUG_ON(el->l_next_free_rec == el->l_count && !has_empty);
1612
1613 /*
1614 * The easiest way to approach this is to just remove the
1615 * empty extent and temporarily decrement next_free.
1616 */
1617 if (has_empty) {
1618 /*
1619 * If next_free was 1 (only an empty extent), this
1620 * loop won't execute, which is fine. We still want
1621 * the decrement above to happen.
1622 */
1623 for(i = 0; i < (next_free - 1); i++)
1624 el->l_recs[i] = el->l_recs[i+1];
1625
1626 next_free--;
1627 }
1628
1629 /*
1630 * Figure out what the new record index should be.
1631 */
1632 for(i = 0; i < next_free; i++) {
1633 rec = &el->l_recs[i];
1634
1635 if (insert_cpos < le32_to_cpu(rec->e_cpos))
1636 break;
1637 }
1638 insert_index = i;
1639
1640 trace_ocfs2_rotate_leaf(insert_cpos, insert_index,
1641 has_empty, next_free,
1642 le16_to_cpu(el->l_count));
1643
1644 BUG_ON(insert_index < 0);
1645 BUG_ON(insert_index >= le16_to_cpu(el->l_count));
1646 BUG_ON(insert_index > next_free);
1647
1648 /*
1649 * No need to memmove if we're just adding to the tail.
1650 */
1651 if (insert_index != next_free) {
1652 BUG_ON(next_free >= le16_to_cpu(el->l_count));
1653
1654 num_bytes = next_free - insert_index;
1655 num_bytes *= sizeof(struct ocfs2_extent_rec);
1656 memmove(&el->l_recs[insert_index + 1],
1657 &el->l_recs[insert_index],
1658 num_bytes);
1659 }
1660
1661 /*
1662 * Either we had an empty extent, and need to re-increment or
1663 * there was no empty extent on a non full rightmost leaf node,
1664 * in which case we still need to increment.
1665 */
1666 next_free++;
1667 el->l_next_free_rec = cpu_to_le16(next_free);
1668 /*
1669 * Make sure none of the math above just messed up our tree.
1670 */
1671 BUG_ON(le16_to_cpu(el->l_next_free_rec) > le16_to_cpu(el->l_count));
1672
1673 el->l_recs[insert_index] = *insert_rec;
1674
1675}
1676
1677static void ocfs2_remove_empty_extent(struct ocfs2_extent_list *el)
1678{
1679 int size, num_recs = le16_to_cpu(el->l_next_free_rec);
1680
1681 BUG_ON(num_recs == 0);
1682
1683 if (ocfs2_is_empty_extent(&el->l_recs[0])) {
1684 num_recs--;
1685 size = num_recs * sizeof(struct ocfs2_extent_rec);
1686 memmove(&el->l_recs[0], &el->l_recs[1], size);
1687 memset(&el->l_recs[num_recs], 0,
1688 sizeof(struct ocfs2_extent_rec));
1689 el->l_next_free_rec = cpu_to_le16(num_recs);
1690 }
1691}
1692
1693/*
1694 * Create an empty extent record .
1695 *
1696 * l_next_free_rec may be updated.
1697 *
1698 * If an empty extent already exists do nothing.
1699 */
1700static void ocfs2_create_empty_extent(struct ocfs2_extent_list *el)
1701{
1702 int next_free = le16_to_cpu(el->l_next_free_rec);
1703
1704 BUG_ON(le16_to_cpu(el->l_tree_depth) != 0);
1705
1706 if (next_free == 0)
1707 goto set_and_inc;
1708
1709 if (ocfs2_is_empty_extent(&el->l_recs[0]))
1710 return;
1711
1712 mlog_bug_on_msg(el->l_count == el->l_next_free_rec,
1713 "Asked to create an empty extent in a full list:\n"
1714 "count = %u, tree depth = %u",
1715 le16_to_cpu(el->l_count),
1716 le16_to_cpu(el->l_tree_depth));
1717
1718 ocfs2_shift_records_right(el);
1719
1720set_and_inc:
1721 le16_add_cpu(&el->l_next_free_rec, 1);
1722 memset(&el->l_recs[0], 0, sizeof(struct ocfs2_extent_rec));
1723}
1724
1725/*
1726 * For a rotation which involves two leaf nodes, the "root node" is
1727 * the lowest level tree node which contains a path to both leafs. This
1728 * resulting set of information can be used to form a complete "subtree"
1729 *
1730 * This function is passed two full paths from the dinode down to a
1731 * pair of adjacent leaves. It's task is to figure out which path
1732 * index contains the subtree root - this can be the root index itself
1733 * in a worst-case rotation.
1734 *
1735 * The array index of the subtree root is passed back.
1736 */
1737int ocfs2_find_subtree_root(struct ocfs2_extent_tree *et,
1738 struct ocfs2_path *left,
1739 struct ocfs2_path *right)
1740{
1741 int i = 0;
1742
1743 /*
1744 * Check that the caller passed in two paths from the same tree.
1745 */
1746 BUG_ON(path_root_bh(left) != path_root_bh(right));
1747
1748 do {
1749 i++;
1750
1751 /*
1752 * The caller didn't pass two adjacent paths.
1753 */
1754 mlog_bug_on_msg(i > left->p_tree_depth,
1755 "Owner %llu, left depth %u, right depth %u\n"
1756 "left leaf blk %llu, right leaf blk %llu\n",
1757 (unsigned long long)ocfs2_metadata_cache_owner(et->et_ci),
1758 left->p_tree_depth, right->p_tree_depth,
1759 (unsigned long long)path_leaf_bh(left)->b_blocknr,
1760 (unsigned long long)path_leaf_bh(right)->b_blocknr);
1761 } while (left->p_node[i].bh->b_blocknr ==
1762 right->p_node[i].bh->b_blocknr);
1763
1764 return i - 1;
1765}
1766
1767typedef void (path_insert_t)(void *, struct buffer_head *);
1768
1769/*
1770 * Traverse a btree path in search of cpos, starting at root_el.
1771 *
1772 * This code can be called with a cpos larger than the tree, in which
1773 * case it will return the rightmost path.
1774 */
1775static int __ocfs2_find_path(struct ocfs2_caching_info *ci,
1776 struct ocfs2_extent_list *root_el, u32 cpos,
1777 path_insert_t *func, void *data)
1778{
1779 int i, ret = 0;
1780 u32 range;
1781 u64 blkno;
1782 struct buffer_head *bh = NULL;
1783 struct ocfs2_extent_block *eb;
1784 struct ocfs2_extent_list *el;
1785 struct ocfs2_extent_rec *rec;
1786
1787 el = root_el;
1788 while (el->l_tree_depth) {
1789 if (le16_to_cpu(el->l_next_free_rec) == 0) {
1790 ocfs2_error(ocfs2_metadata_cache_get_super(ci),
1791 "Owner %llu has empty extent list at "
1792 "depth %u\n",
1793 (unsigned long long)ocfs2_metadata_cache_owner(ci),
1794 le16_to_cpu(el->l_tree_depth));
1795 ret = -EROFS;
1796 goto out;
1797
1798 }
1799
1800 for(i = 0; i < le16_to_cpu(el->l_next_free_rec) - 1; i++) {
1801 rec = &el->l_recs[i];
1802
1803 /*
1804 * In the case that cpos is off the allocation
1805 * tree, this should just wind up returning the
1806 * rightmost record.
1807 */
1808 range = le32_to_cpu(rec->e_cpos) +
1809 ocfs2_rec_clusters(el, rec);
1810 if (cpos >= le32_to_cpu(rec->e_cpos) && cpos < range)
1811 break;
1812 }
1813
1814 blkno = le64_to_cpu(el->l_recs[i].e_blkno);
1815 if (blkno == 0) {
1816 ocfs2_error(ocfs2_metadata_cache_get_super(ci),
1817 "Owner %llu has bad blkno in extent list "
1818 "at depth %u (index %d)\n",
1819 (unsigned long long)ocfs2_metadata_cache_owner(ci),
1820 le16_to_cpu(el->l_tree_depth), i);
1821 ret = -EROFS;
1822 goto out;
1823 }
1824
1825 brelse(bh);
1826 bh = NULL;
1827 ret = ocfs2_read_extent_block(ci, blkno, &bh);
1828 if (ret) {
1829 mlog_errno(ret);
1830 goto out;
1831 }
1832
1833 eb = (struct ocfs2_extent_block *) bh->b_data;
1834 el = &eb->h_list;
1835
1836 if (le16_to_cpu(el->l_next_free_rec) >
1837 le16_to_cpu(el->l_count)) {
1838 ocfs2_error(ocfs2_metadata_cache_get_super(ci),
1839 "Owner %llu has bad count in extent list "
1840 "at block %llu (next free=%u, count=%u)\n",
1841 (unsigned long long)ocfs2_metadata_cache_owner(ci),
1842 (unsigned long long)bh->b_blocknr,
1843 le16_to_cpu(el->l_next_free_rec),
1844 le16_to_cpu(el->l_count));
1845 ret = -EROFS;
1846 goto out;
1847 }
1848
1849 if (func)
1850 func(data, bh);
1851 }
1852
1853out:
1854 /*
1855 * Catch any trailing bh that the loop didn't handle.
1856 */
1857 brelse(bh);
1858
1859 return ret;
1860}
1861
1862/*
1863 * Given an initialized path (that is, it has a valid root extent
1864 * list), this function will traverse the btree in search of the path
1865 * which would contain cpos.
1866 *
1867 * The path traveled is recorded in the path structure.
1868 *
1869 * Note that this will not do any comparisons on leaf node extent
1870 * records, so it will work fine in the case that we just added a tree
1871 * branch.
1872 */
1873struct find_path_data {
1874 int index;
1875 struct ocfs2_path *path;
1876};
1877static void find_path_ins(void *data, struct buffer_head *bh)
1878{
1879 struct find_path_data *fp = data;
1880
1881 get_bh(bh);
1882 ocfs2_path_insert_eb(fp->path, fp->index, bh);
1883 fp->index++;
1884}
1885int ocfs2_find_path(struct ocfs2_caching_info *ci,
1886 struct ocfs2_path *path, u32 cpos)
1887{
1888 struct find_path_data data;
1889
1890 data.index = 1;
1891 data.path = path;
1892 return __ocfs2_find_path(ci, path_root_el(path), cpos,
1893 find_path_ins, &data);
1894}
1895
1896static void find_leaf_ins(void *data, struct buffer_head *bh)
1897{
1898 struct ocfs2_extent_block *eb =(struct ocfs2_extent_block *)bh->b_data;
1899 struct ocfs2_extent_list *el = &eb->h_list;
1900 struct buffer_head **ret = data;
1901
1902 /* We want to retain only the leaf block. */
1903 if (le16_to_cpu(el->l_tree_depth) == 0) {
1904 get_bh(bh);
1905 *ret = bh;
1906 }
1907}
1908/*
1909 * Find the leaf block in the tree which would contain cpos. No
1910 * checking of the actual leaf is done.
1911 *
1912 * Some paths want to call this instead of allocating a path structure
1913 * and calling ocfs2_find_path().
1914 *
1915 * This function doesn't handle non btree extent lists.
1916 */
1917int ocfs2_find_leaf(struct ocfs2_caching_info *ci,
1918 struct ocfs2_extent_list *root_el, u32 cpos,
1919 struct buffer_head **leaf_bh)
1920{
1921 int ret;
1922 struct buffer_head *bh = NULL;
1923
1924 ret = __ocfs2_find_path(ci, root_el, cpos, find_leaf_ins, &bh);
1925 if (ret) {
1926 mlog_errno(ret);
1927 goto out;
1928 }
1929
1930 *leaf_bh = bh;
1931out:
1932 return ret;
1933}
1934
1935/*
1936 * Adjust the adjacent records (left_rec, right_rec) involved in a rotation.
1937 *
1938 * Basically, we've moved stuff around at the bottom of the tree and
1939 * we need to fix up the extent records above the changes to reflect
1940 * the new changes.
1941 *
1942 * left_rec: the record on the left.
1943 * left_child_el: is the child list pointed to by left_rec
1944 * right_rec: the record to the right of left_rec
1945 * right_child_el: is the child list pointed to by right_rec
1946 *
1947 * By definition, this only works on interior nodes.
1948 */
1949static void ocfs2_adjust_adjacent_records(struct ocfs2_extent_rec *left_rec,
1950 struct ocfs2_extent_list *left_child_el,
1951 struct ocfs2_extent_rec *right_rec,
1952 struct ocfs2_extent_list *right_child_el)
1953{
1954 u32 left_clusters, right_end;
1955
1956 /*
1957 * Interior nodes never have holes. Their cpos is the cpos of
1958 * the leftmost record in their child list. Their cluster
1959 * count covers the full theoretical range of their child list
1960 * - the range between their cpos and the cpos of the record
1961 * immediately to their right.
1962 */
1963 left_clusters = le32_to_cpu(right_child_el->l_recs[0].e_cpos);
1964 if (!ocfs2_rec_clusters(right_child_el, &right_child_el->l_recs[0])) {
1965 BUG_ON(right_child_el->l_tree_depth);
1966 BUG_ON(le16_to_cpu(right_child_el->l_next_free_rec) <= 1);
1967 left_clusters = le32_to_cpu(right_child_el->l_recs[1].e_cpos);
1968 }
1969 left_clusters -= le32_to_cpu(left_rec->e_cpos);
1970 left_rec->e_int_clusters = cpu_to_le32(left_clusters);
1971
1972 /*
1973 * Calculate the rightmost cluster count boundary before
1974 * moving cpos - we will need to adjust clusters after
1975 * updating e_cpos to keep the same highest cluster count.
1976 */
1977 right_end = le32_to_cpu(right_rec->e_cpos);
1978 right_end += le32_to_cpu(right_rec->e_int_clusters);
1979
1980 right_rec->e_cpos = left_rec->e_cpos;
1981 le32_add_cpu(&right_rec->e_cpos, left_clusters);
1982
1983 right_end -= le32_to_cpu(right_rec->e_cpos);
1984 right_rec->e_int_clusters = cpu_to_le32(right_end);
1985}
1986
1987/*
1988 * Adjust the adjacent root node records involved in a
1989 * rotation. left_el_blkno is passed in as a key so that we can easily
1990 * find it's index in the root list.
1991 */
1992static void ocfs2_adjust_root_records(struct ocfs2_extent_list *root_el,
1993 struct ocfs2_extent_list *left_el,
1994 struct ocfs2_extent_list *right_el,
1995 u64 left_el_blkno)
1996{
1997 int i;
1998
1999 BUG_ON(le16_to_cpu(root_el->l_tree_depth) <=
2000 le16_to_cpu(left_el->l_tree_depth));
2001
2002 for(i = 0; i < le16_to_cpu(root_el->l_next_free_rec) - 1; i++) {
2003 if (le64_to_cpu(root_el->l_recs[i].e_blkno) == left_el_blkno)
2004 break;
2005 }
2006
2007 /*
2008 * The path walking code should have never returned a root and
2009 * two paths which are not adjacent.
2010 */
2011 BUG_ON(i >= (le16_to_cpu(root_el->l_next_free_rec) - 1));
2012
2013 ocfs2_adjust_adjacent_records(&root_el->l_recs[i], left_el,
2014 &root_el->l_recs[i + 1], right_el);
2015}
2016
2017/*
2018 * We've changed a leaf block (in right_path) and need to reflect that
2019 * change back up the subtree.
2020 *
2021 * This happens in multiple places:
2022 * - When we've moved an extent record from the left path leaf to the right
2023 * path leaf to make room for an empty extent in the left path leaf.
2024 * - When our insert into the right path leaf is at the leftmost edge
2025 * and requires an update of the path immediately to it's left. This
2026 * can occur at the end of some types of rotation and appending inserts.
2027 * - When we've adjusted the last extent record in the left path leaf and the
2028 * 1st extent record in the right path leaf during cross extent block merge.
2029 */
2030static void ocfs2_complete_edge_insert(handle_t *handle,
2031 struct ocfs2_path *left_path,
2032 struct ocfs2_path *right_path,
2033 int subtree_index)
2034{
2035 int i, idx;
2036 struct ocfs2_extent_list *el, *left_el, *right_el;
2037 struct ocfs2_extent_rec *left_rec, *right_rec;
2038 struct buffer_head *root_bh = left_path->p_node[subtree_index].bh;
2039
2040 /*
2041 * Update the counts and position values within all the
2042 * interior nodes to reflect the leaf rotation we just did.
2043 *
2044 * The root node is handled below the loop.
2045 *
2046 * We begin the loop with right_el and left_el pointing to the
2047 * leaf lists and work our way up.
2048 *
2049 * NOTE: within this loop, left_el and right_el always refer
2050 * to the *child* lists.
2051 */
2052 left_el = path_leaf_el(left_path);
2053 right_el = path_leaf_el(right_path);
2054 for(i = left_path->p_tree_depth - 1; i > subtree_index; i--) {
2055 trace_ocfs2_complete_edge_insert(i);
2056
2057 /*
2058 * One nice property of knowing that all of these
2059 * nodes are below the root is that we only deal with
2060 * the leftmost right node record and the rightmost
2061 * left node record.
2062 */
2063 el = left_path->p_node[i].el;
2064 idx = le16_to_cpu(left_el->l_next_free_rec) - 1;
2065 left_rec = &el->l_recs[idx];
2066
2067 el = right_path->p_node[i].el;
2068 right_rec = &el->l_recs[0];
2069
2070 ocfs2_adjust_adjacent_records(left_rec, left_el, right_rec,
2071 right_el);
2072
2073 ocfs2_journal_dirty(handle, left_path->p_node[i].bh);
2074 ocfs2_journal_dirty(handle, right_path->p_node[i].bh);
2075
2076 /*
2077 * Setup our list pointers now so that the current
2078 * parents become children in the next iteration.
2079 */
2080 left_el = left_path->p_node[i].el;
2081 right_el = right_path->p_node[i].el;
2082 }
2083
2084 /*
2085 * At the root node, adjust the two adjacent records which
2086 * begin our path to the leaves.
2087 */
2088
2089 el = left_path->p_node[subtree_index].el;
2090 left_el = left_path->p_node[subtree_index + 1].el;
2091 right_el = right_path->p_node[subtree_index + 1].el;
2092
2093 ocfs2_adjust_root_records(el, left_el, right_el,
2094 left_path->p_node[subtree_index + 1].bh->b_blocknr);
2095
2096 root_bh = left_path->p_node[subtree_index].bh;
2097
2098 ocfs2_journal_dirty(handle, root_bh);
2099}
2100
2101static int ocfs2_rotate_subtree_right(handle_t *handle,
2102 struct ocfs2_extent_tree *et,
2103 struct ocfs2_path *left_path,
2104 struct ocfs2_path *right_path,
2105 int subtree_index)
2106{
2107 int ret, i;
2108 struct buffer_head *right_leaf_bh;
2109 struct buffer_head *left_leaf_bh = NULL;
2110 struct buffer_head *root_bh;
2111 struct ocfs2_extent_list *right_el, *left_el;
2112 struct ocfs2_extent_rec move_rec;
2113
2114 left_leaf_bh = path_leaf_bh(left_path);
2115 left_el = path_leaf_el(left_path);
2116
2117 if (left_el->l_next_free_rec != left_el->l_count) {
2118 ocfs2_error(ocfs2_metadata_cache_get_super(et->et_ci),
2119 "Inode %llu has non-full interior leaf node %llu"
2120 "(next free = %u)",
2121 (unsigned long long)ocfs2_metadata_cache_owner(et->et_ci),
2122 (unsigned long long)left_leaf_bh->b_blocknr,
2123 le16_to_cpu(left_el->l_next_free_rec));
2124 return -EROFS;
2125 }
2126
2127 /*
2128 * This extent block may already have an empty record, so we
2129 * return early if so.
2130 */
2131 if (ocfs2_is_empty_extent(&left_el->l_recs[0]))
2132 return 0;
2133
2134 root_bh = left_path->p_node[subtree_index].bh;
2135 BUG_ON(root_bh != right_path->p_node[subtree_index].bh);
2136
2137 ret = ocfs2_path_bh_journal_access(handle, et->et_ci, right_path,
2138 subtree_index);
2139 if (ret) {
2140 mlog_errno(ret);
2141 goto out;
2142 }
2143
2144 for(i = subtree_index + 1; i < path_num_items(right_path); i++) {
2145 ret = ocfs2_path_bh_journal_access(handle, et->et_ci,
2146 right_path, i);
2147 if (ret) {
2148 mlog_errno(ret);
2149 goto out;
2150 }
2151
2152 ret = ocfs2_path_bh_journal_access(handle, et->et_ci,
2153 left_path, i);
2154 if (ret) {
2155 mlog_errno(ret);
2156 goto out;
2157 }
2158 }
2159
2160 right_leaf_bh = path_leaf_bh(right_path);
2161 right_el = path_leaf_el(right_path);
2162
2163 /* This is a code error, not a disk corruption. */
2164 mlog_bug_on_msg(!right_el->l_next_free_rec, "Inode %llu: Rotate fails "
2165 "because rightmost leaf block %llu is empty\n",
2166 (unsigned long long)ocfs2_metadata_cache_owner(et->et_ci),
2167 (unsigned long long)right_leaf_bh->b_blocknr);
2168
2169 ocfs2_create_empty_extent(right_el);
2170
2171 ocfs2_journal_dirty(handle, right_leaf_bh);
2172
2173 /* Do the copy now. */
2174 i = le16_to_cpu(left_el->l_next_free_rec) - 1;
2175 move_rec = left_el->l_recs[i];
2176 right_el->l_recs[0] = move_rec;
2177
2178 /*
2179 * Clear out the record we just copied and shift everything
2180 * over, leaving an empty extent in the left leaf.
2181 *
2182 * We temporarily subtract from next_free_rec so that the
2183 * shift will lose the tail record (which is now defunct).
2184 */
2185 le16_add_cpu(&left_el->l_next_free_rec, -1);
2186 ocfs2_shift_records_right(left_el);
2187 memset(&left_el->l_recs[0], 0, sizeof(struct ocfs2_extent_rec));
2188 le16_add_cpu(&left_el->l_next_free_rec, 1);
2189
2190 ocfs2_journal_dirty(handle, left_leaf_bh);
2191
2192 ocfs2_complete_edge_insert(handle, left_path, right_path,
2193 subtree_index);
2194
2195out:
2196 return ret;
2197}
2198
2199/*
2200 * Given a full path, determine what cpos value would return us a path
2201 * containing the leaf immediately to the left of the current one.
2202 *
2203 * Will return zero if the path passed in is already the leftmost path.
2204 */
2205int ocfs2_find_cpos_for_left_leaf(struct super_block *sb,
2206 struct ocfs2_path *path, u32 *cpos)
2207{
2208 int i, j, ret = 0;
2209 u64 blkno;
2210 struct ocfs2_extent_list *el;
2211
2212 BUG_ON(path->p_tree_depth == 0);
2213
2214 *cpos = 0;
2215
2216 blkno = path_leaf_bh(path)->b_blocknr;
2217
2218 /* Start at the tree node just above the leaf and work our way up. */
2219 i = path->p_tree_depth - 1;
2220 while (i >= 0) {
2221 el = path->p_node[i].el;
2222
2223 /*
2224 * Find the extent record just before the one in our
2225 * path.
2226 */
2227 for(j = 0; j < le16_to_cpu(el->l_next_free_rec); j++) {
2228 if (le64_to_cpu(el->l_recs[j].e_blkno) == blkno) {
2229 if (j == 0) {
2230 if (i == 0) {
2231 /*
2232 * We've determined that the
2233 * path specified is already
2234 * the leftmost one - return a
2235 * cpos of zero.
2236 */
2237 goto out;
2238 }
2239 /*
2240 * The leftmost record points to our
2241 * leaf - we need to travel up the
2242 * tree one level.
2243 */
2244 goto next_node;
2245 }
2246
2247 *cpos = le32_to_cpu(el->l_recs[j - 1].e_cpos);
2248 *cpos = *cpos + ocfs2_rec_clusters(el,
2249 &el->l_recs[j - 1]);
2250 *cpos = *cpos - 1;
2251 goto out;
2252 }
2253 }
2254
2255 /*
2256 * If we got here, we never found a valid node where
2257 * the tree indicated one should be.
2258 */
2259 ocfs2_error(sb,
2260 "Invalid extent tree at extent block %llu\n",
2261 (unsigned long long)blkno);
2262 ret = -EROFS;
2263 goto out;
2264
2265next_node:
2266 blkno = path->p_node[i].bh->b_blocknr;
2267 i--;
2268 }
2269
2270out:
2271 return ret;
2272}
2273
2274/*
2275 * Extend the transaction by enough credits to complete the rotation,
2276 * and still leave at least the original number of credits allocated
2277 * to this transaction.
2278 */
2279static int ocfs2_extend_rotate_transaction(handle_t *handle, int subtree_depth,
2280 int op_credits,
2281 struct ocfs2_path *path)
2282{
2283 int ret = 0;
2284 int credits = (path->p_tree_depth - subtree_depth) * 2 + 1 + op_credits;
2285
2286 if (handle->h_buffer_credits < credits)
2287 ret = ocfs2_extend_trans(handle,
2288 credits - handle->h_buffer_credits);
2289
2290 return ret;
2291}
2292
2293/*
2294 * Trap the case where we're inserting into the theoretical range past
2295 * the _actual_ left leaf range. Otherwise, we'll rotate a record
2296 * whose cpos is less than ours into the right leaf.
2297 *
2298 * It's only necessary to look at the rightmost record of the left
2299 * leaf because the logic that calls us should ensure that the
2300 * theoretical ranges in the path components above the leaves are
2301 * correct.
2302 */
2303static int ocfs2_rotate_requires_path_adjustment(struct ocfs2_path *left_path,
2304 u32 insert_cpos)
2305{
2306 struct ocfs2_extent_list *left_el;
2307 struct ocfs2_extent_rec *rec;
2308 int next_free;
2309
2310 left_el = path_leaf_el(left_path);
2311 next_free = le16_to_cpu(left_el->l_next_free_rec);
2312 rec = &left_el->l_recs[next_free - 1];
2313
2314 if (insert_cpos > le32_to_cpu(rec->e_cpos))
2315 return 1;
2316 return 0;
2317}
2318
2319static int ocfs2_leftmost_rec_contains(struct ocfs2_extent_list *el, u32 cpos)
2320{
2321 int next_free = le16_to_cpu(el->l_next_free_rec);
2322 unsigned int range;
2323 struct ocfs2_extent_rec *rec;
2324
2325 if (next_free == 0)
2326 return 0;
2327
2328 rec = &el->l_recs[0];
2329 if (ocfs2_is_empty_extent(rec)) {
2330 /* Empty list. */
2331 if (next_free == 1)
2332 return 0;
2333 rec = &el->l_recs[1];
2334 }
2335
2336 range = le32_to_cpu(rec->e_cpos) + ocfs2_rec_clusters(el, rec);
2337 if (cpos >= le32_to_cpu(rec->e_cpos) && cpos < range)
2338 return 1;
2339 return 0;
2340}
2341
2342/*
2343 * Rotate all the records in a btree right one record, starting at insert_cpos.
2344 *
2345 * The path to the rightmost leaf should be passed in.
2346 *
2347 * The array is assumed to be large enough to hold an entire path (tree depth).
2348 *
2349 * Upon successful return from this function:
2350 *
2351 * - The 'right_path' array will contain a path to the leaf block
2352 * whose range contains e_cpos.
2353 * - That leaf block will have a single empty extent in list index 0.
2354 * - In the case that the rotation requires a post-insert update,
2355 * *ret_left_path will contain a valid path which can be passed to
2356 * ocfs2_insert_path().
2357 */
2358static int ocfs2_rotate_tree_right(handle_t *handle,
2359 struct ocfs2_extent_tree *et,
2360 enum ocfs2_split_type split,
2361 u32 insert_cpos,
2362 struct ocfs2_path *right_path,
2363 struct ocfs2_path **ret_left_path)
2364{
2365 int ret, start, orig_credits = handle->h_buffer_credits;
2366 u32 cpos;
2367 struct ocfs2_path *left_path = NULL;
2368 struct super_block *sb = ocfs2_metadata_cache_get_super(et->et_ci);
2369
2370 *ret_left_path = NULL;
2371
2372 left_path = ocfs2_new_path_from_path(right_path);
2373 if (!left_path) {
2374 ret = -ENOMEM;
2375 mlog_errno(ret);
2376 goto out;
2377 }
2378
2379 ret = ocfs2_find_cpos_for_left_leaf(sb, right_path, &cpos);
2380 if (ret) {
2381 mlog_errno(ret);
2382 goto out;
2383 }
2384
2385 trace_ocfs2_rotate_tree_right(
2386 (unsigned long long)ocfs2_metadata_cache_owner(et->et_ci),
2387 insert_cpos, cpos);
2388
2389 /*
2390 * What we want to do here is:
2391 *
2392 * 1) Start with the rightmost path.
2393 *
2394 * 2) Determine a path to the leaf block directly to the left
2395 * of that leaf.
2396 *
2397 * 3) Determine the 'subtree root' - the lowest level tree node
2398 * which contains a path to both leaves.
2399 *
2400 * 4) Rotate the subtree.
2401 *
2402 * 5) Find the next subtree by considering the left path to be
2403 * the new right path.
2404 *
2405 * The check at the top of this while loop also accepts
2406 * insert_cpos == cpos because cpos is only a _theoretical_
2407 * value to get us the left path - insert_cpos might very well
2408 * be filling that hole.
2409 *
2410 * Stop at a cpos of '0' because we either started at the
2411 * leftmost branch (i.e., a tree with one branch and a
2412 * rotation inside of it), or we've gone as far as we can in
2413 * rotating subtrees.
2414 */
2415 while (cpos && insert_cpos <= cpos) {
2416 trace_ocfs2_rotate_tree_right(
2417 (unsigned long long)
2418 ocfs2_metadata_cache_owner(et->et_ci),
2419 insert_cpos, cpos);
2420
2421 ret = ocfs2_find_path(et->et_ci, left_path, cpos);
2422 if (ret) {
2423 mlog_errno(ret);
2424 goto out;
2425 }
2426
2427 mlog_bug_on_msg(path_leaf_bh(left_path) ==
2428 path_leaf_bh(right_path),
2429 "Owner %llu: error during insert of %u "
2430 "(left path cpos %u) results in two identical "
2431 "paths ending at %llu\n",
2432 (unsigned long long)ocfs2_metadata_cache_owner(et->et_ci),
2433 insert_cpos, cpos,
2434 (unsigned long long)
2435 path_leaf_bh(left_path)->b_blocknr);
2436
2437 if (split == SPLIT_NONE &&
2438 ocfs2_rotate_requires_path_adjustment(left_path,
2439 insert_cpos)) {
2440
2441 /*
2442 * We've rotated the tree as much as we
2443 * should. The rest is up to
2444 * ocfs2_insert_path() to complete, after the
2445 * record insertion. We indicate this
2446 * situation by returning the left path.
2447 *
2448 * The reason we don't adjust the records here
2449 * before the record insert is that an error
2450 * later might break the rule where a parent
2451 * record e_cpos will reflect the actual
2452 * e_cpos of the 1st nonempty record of the
2453 * child list.
2454 */
2455 *ret_left_path = left_path;
2456 goto out_ret_path;
2457 }
2458
2459 start = ocfs2_find_subtree_root(et, left_path, right_path);
2460
2461 trace_ocfs2_rotate_subtree(start,
2462 (unsigned long long)
2463 right_path->p_node[start].bh->b_blocknr,
2464 right_path->p_tree_depth);
2465
2466 ret = ocfs2_extend_rotate_transaction(handle, start,
2467 orig_credits, right_path);
2468 if (ret) {
2469 mlog_errno(ret);
2470 goto out;
2471 }
2472
2473 ret = ocfs2_rotate_subtree_right(handle, et, left_path,
2474 right_path, start);
2475 if (ret) {
2476 mlog_errno(ret);
2477 goto out;
2478 }
2479
2480 if (split != SPLIT_NONE &&
2481 ocfs2_leftmost_rec_contains(path_leaf_el(right_path),
2482 insert_cpos)) {
2483 /*
2484 * A rotate moves the rightmost left leaf
2485 * record over to the leftmost right leaf
2486 * slot. If we're doing an extent split
2487 * instead of a real insert, then we have to
2488 * check that the extent to be split wasn't
2489 * just moved over. If it was, then we can
2490 * exit here, passing left_path back -
2491 * ocfs2_split_extent() is smart enough to
2492 * search both leaves.
2493 */
2494 *ret_left_path = left_path;
2495 goto out_ret_path;
2496 }
2497
2498 /*
2499 * There is no need to re-read the next right path
2500 * as we know that it'll be our current left
2501 * path. Optimize by copying values instead.
2502 */
2503 ocfs2_mv_path(right_path, left_path);
2504
2505 ret = ocfs2_find_cpos_for_left_leaf(sb, right_path, &cpos);
2506 if (ret) {
2507 mlog_errno(ret);
2508 goto out;
2509 }
2510 }
2511
2512out:
2513 ocfs2_free_path(left_path);
2514
2515out_ret_path:
2516 return ret;
2517}
2518
2519static int ocfs2_update_edge_lengths(handle_t *handle,
2520 struct ocfs2_extent_tree *et,
2521 int subtree_index, struct ocfs2_path *path)
2522{
2523 int i, idx, ret;
2524 struct ocfs2_extent_rec *rec;
2525 struct ocfs2_extent_list *el;
2526 struct ocfs2_extent_block *eb;
2527 u32 range;
2528
2529 /*
2530 * In normal tree rotation process, we will never touch the
2531 * tree branch above subtree_index and ocfs2_extend_rotate_transaction
2532 * doesn't reserve the credits for them either.
2533 *
2534 * But we do have a special case here which will update the rightmost
2535 * records for all the bh in the path.
2536 * So we have to allocate extra credits and access them.
2537 */
2538 ret = ocfs2_extend_trans(handle, subtree_index);
2539 if (ret) {
2540 mlog_errno(ret);
2541 goto out;
2542 }
2543
2544 ret = ocfs2_journal_access_path(et->et_ci, handle, path);
2545 if (ret) {
2546 mlog_errno(ret);
2547 goto out;
2548 }
2549
2550 /* Path should always be rightmost. */
2551 eb = (struct ocfs2_extent_block *)path_leaf_bh(path)->b_data;
2552 BUG_ON(eb->h_next_leaf_blk != 0ULL);
2553
2554 el = &eb->h_list;
2555 BUG_ON(le16_to_cpu(el->l_next_free_rec) == 0);
2556 idx = le16_to_cpu(el->l_next_free_rec) - 1;
2557 rec = &el->l_recs[idx];
2558 range = le32_to_cpu(rec->e_cpos) + ocfs2_rec_clusters(el, rec);
2559
2560 for (i = 0; i < path->p_tree_depth; i++) {
2561 el = path->p_node[i].el;
2562 idx = le16_to_cpu(el->l_next_free_rec) - 1;
2563 rec = &el->l_recs[idx];
2564
2565 rec->e_int_clusters = cpu_to_le32(range);
2566 le32_add_cpu(&rec->e_int_clusters, -le32_to_cpu(rec->e_cpos));
2567
2568 ocfs2_journal_dirty(handle, path->p_node[i].bh);
2569 }
2570out:
2571 return ret;
2572}
2573
2574static void ocfs2_unlink_path(handle_t *handle,
2575 struct ocfs2_extent_tree *et,
2576 struct ocfs2_cached_dealloc_ctxt *dealloc,
2577 struct ocfs2_path *path, int unlink_start)
2578{
2579 int ret, i;
2580 struct ocfs2_extent_block *eb;
2581 struct ocfs2_extent_list *el;
2582 struct buffer_head *bh;
2583
2584 for(i = unlink_start; i < path_num_items(path); i++) {
2585 bh = path->p_node[i].bh;
2586
2587 eb = (struct ocfs2_extent_block *)bh->b_data;
2588 /*
2589 * Not all nodes might have had their final count
2590 * decremented by the caller - handle this here.
2591 */
2592 el = &eb->h_list;
2593 if (le16_to_cpu(el->l_next_free_rec) > 1) {
2594 mlog(ML_ERROR,
2595 "Inode %llu, attempted to remove extent block "
2596 "%llu with %u records\n",
2597 (unsigned long long)ocfs2_metadata_cache_owner(et->et_ci),
2598 (unsigned long long)le64_to_cpu(eb->h_blkno),
2599 le16_to_cpu(el->l_next_free_rec));
2600
2601 ocfs2_journal_dirty(handle, bh);
2602 ocfs2_remove_from_cache(et->et_ci, bh);
2603 continue;
2604 }
2605
2606 el->l_next_free_rec = 0;
2607 memset(&el->l_recs[0], 0, sizeof(struct ocfs2_extent_rec));
2608
2609 ocfs2_journal_dirty(handle, bh);
2610
2611 ret = ocfs2_cache_extent_block_free(dealloc, eb);
2612 if (ret)
2613 mlog_errno(ret);
2614
2615 ocfs2_remove_from_cache(et->et_ci, bh);
2616 }
2617}
2618
2619static void ocfs2_unlink_subtree(handle_t *handle,
2620 struct ocfs2_extent_tree *et,
2621 struct ocfs2_path *left_path,
2622 struct ocfs2_path *right_path,
2623 int subtree_index,
2624 struct ocfs2_cached_dealloc_ctxt *dealloc)
2625{
2626 int i;
2627 struct buffer_head *root_bh = left_path->p_node[subtree_index].bh;
2628 struct ocfs2_extent_list *root_el = left_path->p_node[subtree_index].el;
2629 struct ocfs2_extent_list *el;
2630 struct ocfs2_extent_block *eb;
2631
2632 el = path_leaf_el(left_path);
2633
2634 eb = (struct ocfs2_extent_block *)right_path->p_node[subtree_index + 1].bh->b_data;
2635
2636 for(i = 1; i < le16_to_cpu(root_el->l_next_free_rec); i++)
2637 if (root_el->l_recs[i].e_blkno == eb->h_blkno)
2638 break;
2639
2640 BUG_ON(i >= le16_to_cpu(root_el->l_next_free_rec));
2641
2642 memset(&root_el->l_recs[i], 0, sizeof(struct ocfs2_extent_rec));
2643 le16_add_cpu(&root_el->l_next_free_rec, -1);
2644
2645 eb = (struct ocfs2_extent_block *)path_leaf_bh(left_path)->b_data;
2646 eb->h_next_leaf_blk = 0;
2647
2648 ocfs2_journal_dirty(handle, root_bh);
2649 ocfs2_journal_dirty(handle, path_leaf_bh(left_path));
2650
2651 ocfs2_unlink_path(handle, et, dealloc, right_path,
2652 subtree_index + 1);
2653}
2654
2655static int ocfs2_rotate_subtree_left(handle_t *handle,
2656 struct ocfs2_extent_tree *et,
2657 struct ocfs2_path *left_path,
2658 struct ocfs2_path *right_path,
2659 int subtree_index,
2660 struct ocfs2_cached_dealloc_ctxt *dealloc,
2661 int *deleted)
2662{
2663 int ret, i, del_right_subtree = 0, right_has_empty = 0;
2664 struct buffer_head *root_bh, *et_root_bh = path_root_bh(right_path);
2665 struct ocfs2_extent_list *right_leaf_el, *left_leaf_el;
2666 struct ocfs2_extent_block *eb;
2667
2668 *deleted = 0;
2669
2670 right_leaf_el = path_leaf_el(right_path);
2671 left_leaf_el = path_leaf_el(left_path);
2672 root_bh = left_path->p_node[subtree_index].bh;
2673 BUG_ON(root_bh != right_path->p_node[subtree_index].bh);
2674
2675 if (!ocfs2_is_empty_extent(&left_leaf_el->l_recs[0]))
2676 return 0;
2677
2678 eb = (struct ocfs2_extent_block *)path_leaf_bh(right_path)->b_data;
2679 if (ocfs2_is_empty_extent(&right_leaf_el->l_recs[0])) {
2680 /*
2681 * It's legal for us to proceed if the right leaf is
2682 * the rightmost one and it has an empty extent. There
2683 * are two cases to handle - whether the leaf will be
2684 * empty after removal or not. If the leaf isn't empty
2685 * then just remove the empty extent up front. The
2686 * next block will handle empty leaves by flagging
2687 * them for unlink.
2688 *
2689 * Non rightmost leaves will throw -EAGAIN and the
2690 * caller can manually move the subtree and retry.
2691 */
2692
2693 if (eb->h_next_leaf_blk != 0ULL)
2694 return -EAGAIN;
2695
2696 if (le16_to_cpu(right_leaf_el->l_next_free_rec) > 1) {
2697 ret = ocfs2_journal_access_eb(handle, et->et_ci,
2698 path_leaf_bh(right_path),
2699 OCFS2_JOURNAL_ACCESS_WRITE);
2700 if (ret) {
2701 mlog_errno(ret);
2702 goto out;
2703 }
2704
2705 ocfs2_remove_empty_extent(right_leaf_el);
2706 } else
2707 right_has_empty = 1;
2708 }
2709
2710 if (eb->h_next_leaf_blk == 0ULL &&
2711 le16_to_cpu(right_leaf_el->l_next_free_rec) == 1) {
2712 /*
2713 * We have to update i_last_eb_blk during the meta
2714 * data delete.
2715 */
2716 ret = ocfs2_et_root_journal_access(handle, et,
2717 OCFS2_JOURNAL_ACCESS_WRITE);
2718 if (ret) {
2719 mlog_errno(ret);
2720 goto out;
2721 }
2722
2723 del_right_subtree = 1;
2724 }
2725
2726 /*
2727 * Getting here with an empty extent in the right path implies
2728 * that it's the rightmost path and will be deleted.
2729 */
2730 BUG_ON(right_has_empty && !del_right_subtree);
2731
2732 ret = ocfs2_path_bh_journal_access(handle, et->et_ci, right_path,
2733 subtree_index);
2734 if (ret) {
2735 mlog_errno(ret);
2736 goto out;
2737 }
2738
2739 for(i = subtree_index + 1; i < path_num_items(right_path); i++) {
2740 ret = ocfs2_path_bh_journal_access(handle, et->et_ci,
2741 right_path, i);
2742 if (ret) {
2743 mlog_errno(ret);
2744 goto out;
2745 }
2746
2747 ret = ocfs2_path_bh_journal_access(handle, et->et_ci,
2748 left_path, i);
2749 if (ret) {
2750 mlog_errno(ret);
2751 goto out;
2752 }
2753 }
2754
2755 if (!right_has_empty) {
2756 /*
2757 * Only do this if we're moving a real
2758 * record. Otherwise, the action is delayed until
2759 * after removal of the right path in which case we
2760 * can do a simple shift to remove the empty extent.
2761 */
2762 ocfs2_rotate_leaf(left_leaf_el, &right_leaf_el->l_recs[0]);
2763 memset(&right_leaf_el->l_recs[0], 0,
2764 sizeof(struct ocfs2_extent_rec));
2765 }
2766 if (eb->h_next_leaf_blk == 0ULL) {
2767 /*
2768 * Move recs over to get rid of empty extent, decrease
2769 * next_free. This is allowed to remove the last
2770 * extent in our leaf (setting l_next_free_rec to
2771 * zero) - the delete code below won't care.
2772 */
2773 ocfs2_remove_empty_extent(right_leaf_el);
2774 }
2775
2776 ocfs2_journal_dirty(handle, path_leaf_bh(left_path));
2777 ocfs2_journal_dirty(handle, path_leaf_bh(right_path));
2778
2779 if (del_right_subtree) {
2780 ocfs2_unlink_subtree(handle, et, left_path, right_path,
2781 subtree_index, dealloc);
2782 ret = ocfs2_update_edge_lengths(handle, et, subtree_index,
2783 left_path);
2784 if (ret) {
2785 mlog_errno(ret);
2786 goto out;
2787 }
2788
2789 eb = (struct ocfs2_extent_block *)path_leaf_bh(left_path)->b_data;
2790 ocfs2_et_set_last_eb_blk(et, le64_to_cpu(eb->h_blkno));
2791
2792 /*
2793 * Removal of the extent in the left leaf was skipped
2794 * above so we could delete the right path
2795 * 1st.
2796 */
2797 if (right_has_empty)
2798 ocfs2_remove_empty_extent(left_leaf_el);
2799
2800 ocfs2_journal_dirty(handle, et_root_bh);
2801
2802 *deleted = 1;
2803 } else
2804 ocfs2_complete_edge_insert(handle, left_path, right_path,
2805 subtree_index);
2806
2807out:
2808 return ret;
2809}
2810
2811/*
2812 * Given a full path, determine what cpos value would return us a path
2813 * containing the leaf immediately to the right of the current one.
2814 *
2815 * Will return zero if the path passed in is already the rightmost path.
2816 *
2817 * This looks similar, but is subtly different to
2818 * ocfs2_find_cpos_for_left_leaf().
2819 */
2820int ocfs2_find_cpos_for_right_leaf(struct super_block *sb,
2821 struct ocfs2_path *path, u32 *cpos)
2822{
2823 int i, j, ret = 0;
2824 u64 blkno;
2825 struct ocfs2_extent_list *el;
2826
2827 *cpos = 0;
2828
2829 if (path->p_tree_depth == 0)
2830 return 0;
2831
2832 blkno = path_leaf_bh(path)->b_blocknr;
2833
2834 /* Start at the tree node just above the leaf and work our way up. */
2835 i = path->p_tree_depth - 1;
2836 while (i >= 0) {
2837 int next_free;
2838
2839 el = path->p_node[i].el;
2840
2841 /*
2842 * Find the extent record just after the one in our
2843 * path.
2844 */
2845 next_free = le16_to_cpu(el->l_next_free_rec);
2846 for(j = 0; j < le16_to_cpu(el->l_next_free_rec); j++) {
2847 if (le64_to_cpu(el->l_recs[j].e_blkno) == blkno) {
2848 if (j == (next_free - 1)) {
2849 if (i == 0) {
2850 /*
2851 * We've determined that the
2852 * path specified is already
2853 * the rightmost one - return a
2854 * cpos of zero.
2855 */
2856 goto out;
2857 }
2858 /*
2859 * The rightmost record points to our
2860 * leaf - we need to travel up the
2861 * tree one level.
2862 */
2863 goto next_node;
2864 }
2865
2866 *cpos = le32_to_cpu(el->l_recs[j + 1].e_cpos);
2867 goto out;
2868 }
2869 }
2870
2871 /*
2872 * If we got here, we never found a valid node where
2873 * the tree indicated one should be.
2874 */
2875 ocfs2_error(sb,
2876 "Invalid extent tree at extent block %llu\n",
2877 (unsigned long long)blkno);
2878 ret = -EROFS;
2879 goto out;
2880
2881next_node:
2882 blkno = path->p_node[i].bh->b_blocknr;
2883 i--;
2884 }
2885
2886out:
2887 return ret;
2888}
2889
2890static int ocfs2_rotate_rightmost_leaf_left(handle_t *handle,
2891 struct ocfs2_extent_tree *et,
2892 struct ocfs2_path *path)
2893{
2894 int ret;
2895 struct buffer_head *bh = path_leaf_bh(path);
2896 struct ocfs2_extent_list *el = path_leaf_el(path);
2897
2898 if (!ocfs2_is_empty_extent(&el->l_recs[0]))
2899 return 0;
2900
2901 ret = ocfs2_path_bh_journal_access(handle, et->et_ci, path,
2902 path_num_items(path) - 1);
2903 if (ret) {
2904 mlog_errno(ret);
2905 goto out;
2906 }
2907
2908 ocfs2_remove_empty_extent(el);
2909 ocfs2_journal_dirty(handle, bh);
2910
2911out:
2912 return ret;
2913}
2914
2915static int __ocfs2_rotate_tree_left(handle_t *handle,
2916 struct ocfs2_extent_tree *et,
2917 int orig_credits,
2918 struct ocfs2_path *path,
2919 struct ocfs2_cached_dealloc_ctxt *dealloc,
2920 struct ocfs2_path **empty_extent_path)
2921{
2922 int ret, subtree_root, deleted;
2923 u32 right_cpos;
2924 struct ocfs2_path *left_path = NULL;
2925 struct ocfs2_path *right_path = NULL;
2926 struct super_block *sb = ocfs2_metadata_cache_get_super(et->et_ci);
2927
2928 BUG_ON(!ocfs2_is_empty_extent(&(path_leaf_el(path)->l_recs[0])));
2929
2930 *empty_extent_path = NULL;
2931
2932 ret = ocfs2_find_cpos_for_right_leaf(sb, path, &right_cpos);
2933 if (ret) {
2934 mlog_errno(ret);
2935 goto out;
2936 }
2937
2938 left_path = ocfs2_new_path_from_path(path);
2939 if (!left_path) {
2940 ret = -ENOMEM;
2941 mlog_errno(ret);
2942 goto out;
2943 }
2944
2945 ocfs2_cp_path(left_path, path);
2946
2947 right_path = ocfs2_new_path_from_path(path);
2948 if (!right_path) {
2949 ret = -ENOMEM;
2950 mlog_errno(ret);
2951 goto out;
2952 }
2953
2954 while (right_cpos) {
2955 ret = ocfs2_find_path(et->et_ci, right_path, right_cpos);
2956 if (ret) {
2957 mlog_errno(ret);
2958 goto out;
2959 }
2960
2961 subtree_root = ocfs2_find_subtree_root(et, left_path,
2962 right_path);
2963
2964 trace_ocfs2_rotate_subtree(subtree_root,
2965 (unsigned long long)
2966 right_path->p_node[subtree_root].bh->b_blocknr,
2967 right_path->p_tree_depth);
2968
2969 ret = ocfs2_extend_rotate_transaction(handle, subtree_root,
2970 orig_credits, left_path);
2971 if (ret) {
2972 mlog_errno(ret);
2973 goto out;
2974 }
2975
2976 /*
2977 * Caller might still want to make changes to the
2978 * tree root, so re-add it to the journal here.
2979 */
2980 ret = ocfs2_path_bh_journal_access(handle, et->et_ci,
2981 left_path, 0);
2982 if (ret) {
2983 mlog_errno(ret);
2984 goto out;
2985 }
2986
2987 ret = ocfs2_rotate_subtree_left(handle, et, left_path,
2988 right_path, subtree_root,
2989 dealloc, &deleted);
2990 if (ret == -EAGAIN) {
2991 /*
2992 * The rotation has to temporarily stop due to
2993 * the right subtree having an empty
2994 * extent. Pass it back to the caller for a
2995 * fixup.
2996 */
2997 *empty_extent_path = right_path;
2998 right_path = NULL;
2999 goto out;
3000 }
3001 if (ret) {
3002 mlog_errno(ret);
3003 goto out;
3004 }
3005
3006 /*
3007 * The subtree rotate might have removed records on
3008 * the rightmost edge. If so, then rotation is
3009 * complete.
3010 */
3011 if (deleted)
3012 break;
3013
3014 ocfs2_mv_path(left_path, right_path);
3015
3016 ret = ocfs2_find_cpos_for_right_leaf(sb, left_path,
3017 &right_cpos);
3018 if (ret) {
3019 mlog_errno(ret);
3020 goto out;
3021 }
3022 }
3023
3024out:
3025 ocfs2_free_path(right_path);
3026 ocfs2_free_path(left_path);
3027
3028 return ret;
3029}
3030
3031static int ocfs2_remove_rightmost_path(handle_t *handle,
3032 struct ocfs2_extent_tree *et,
3033 struct ocfs2_path *path,
3034 struct ocfs2_cached_dealloc_ctxt *dealloc)
3035{
3036 int ret, subtree_index;
3037 u32 cpos;
3038 struct ocfs2_path *left_path = NULL;
3039 struct ocfs2_extent_block *eb;
3040 struct ocfs2_extent_list *el;
3041
3042
3043 ret = ocfs2_et_sanity_check(et);
3044 if (ret)
3045 goto out;
3046 /*
3047 * There's two ways we handle this depending on
3048 * whether path is the only existing one.
3049 */
3050 ret = ocfs2_extend_rotate_transaction(handle, 0,
3051 handle->h_buffer_credits,
3052 path);
3053 if (ret) {
3054 mlog_errno(ret);
3055 goto out;
3056 }
3057
3058 ret = ocfs2_journal_access_path(et->et_ci, handle, path);
3059 if (ret) {
3060 mlog_errno(ret);
3061 goto out;
3062 }
3063
3064 ret = ocfs2_find_cpos_for_left_leaf(ocfs2_metadata_cache_get_super(et->et_ci),
3065 path, &cpos);
3066 if (ret) {
3067 mlog_errno(ret);
3068 goto out;
3069 }
3070
3071 if (cpos) {
3072 /*
3073 * We have a path to the left of this one - it needs
3074 * an update too.
3075 */
3076 left_path = ocfs2_new_path_from_path(path);
3077 if (!left_path) {
3078 ret = -ENOMEM;
3079 mlog_errno(ret);
3080 goto out;
3081 }
3082
3083 ret = ocfs2_find_path(et->et_ci, left_path, cpos);
3084 if (ret) {
3085 mlog_errno(ret);
3086 goto out;
3087 }
3088
3089 ret = ocfs2_journal_access_path(et->et_ci, handle, left_path);
3090 if (ret) {
3091 mlog_errno(ret);
3092 goto out;
3093 }
3094
3095 subtree_index = ocfs2_find_subtree_root(et, left_path, path);
3096
3097 ocfs2_unlink_subtree(handle, et, left_path, path,
3098 subtree_index, dealloc);
3099 ret = ocfs2_update_edge_lengths(handle, et, subtree_index,
3100 left_path);
3101 if (ret) {
3102 mlog_errno(ret);
3103 goto out;
3104 }
3105
3106 eb = (struct ocfs2_extent_block *)path_leaf_bh(left_path)->b_data;
3107 ocfs2_et_set_last_eb_blk(et, le64_to_cpu(eb->h_blkno));
3108 } else {
3109 /*
3110 * 'path' is also the leftmost path which
3111 * means it must be the only one. This gets
3112 * handled differently because we want to
3113 * revert the root back to having extents
3114 * in-line.
3115 */
3116 ocfs2_unlink_path(handle, et, dealloc, path, 1);
3117
3118 el = et->et_root_el;
3119 el->l_tree_depth = 0;
3120 el->l_next_free_rec = 0;
3121 memset(&el->l_recs[0], 0, sizeof(struct ocfs2_extent_rec));
3122
3123 ocfs2_et_set_last_eb_blk(et, 0);
3124 }
3125
3126 ocfs2_journal_dirty(handle, path_root_bh(path));
3127
3128out:
3129 ocfs2_free_path(left_path);
3130 return ret;
3131}
3132
3133/*
3134 * Left rotation of btree records.
3135 *
3136 * In many ways, this is (unsurprisingly) the opposite of right
3137 * rotation. We start at some non-rightmost path containing an empty
3138 * extent in the leaf block. The code works its way to the rightmost
3139 * path by rotating records to the left in every subtree.
3140 *
3141 * This is used by any code which reduces the number of extent records
3142 * in a leaf. After removal, an empty record should be placed in the
3143 * leftmost list position.
3144 *
3145 * This won't handle a length update of the rightmost path records if
3146 * the rightmost tree leaf record is removed so the caller is
3147 * responsible for detecting and correcting that.
3148 */
3149static int ocfs2_rotate_tree_left(handle_t *handle,
3150 struct ocfs2_extent_tree *et,
3151 struct ocfs2_path *path,
3152 struct ocfs2_cached_dealloc_ctxt *dealloc)
3153{
3154 int ret, orig_credits = handle->h_buffer_credits;
3155 struct ocfs2_path *tmp_path = NULL, *restart_path = NULL;
3156 struct ocfs2_extent_block *eb;
3157 struct ocfs2_extent_list *el;
3158
3159 el = path_leaf_el(path);
3160 if (!ocfs2_is_empty_extent(&el->l_recs[0]))
3161 return 0;
3162
3163 if (path->p_tree_depth == 0) {
3164rightmost_no_delete:
3165 /*
3166 * Inline extents. This is trivially handled, so do
3167 * it up front.
3168 */
3169 ret = ocfs2_rotate_rightmost_leaf_left(handle, et, path);
3170 if (ret)
3171 mlog_errno(ret);
3172 goto out;
3173 }
3174
3175 /*
3176 * Handle rightmost branch now. There's several cases:
3177 * 1) simple rotation leaving records in there. That's trivial.
3178 * 2) rotation requiring a branch delete - there's no more
3179 * records left. Two cases of this:
3180 * a) There are branches to the left.
3181 * b) This is also the leftmost (the only) branch.
3182 *
3183 * 1) is handled via ocfs2_rotate_rightmost_leaf_left()
3184 * 2a) we need the left branch so that we can update it with the unlink
3185 * 2b) we need to bring the root back to inline extents.
3186 */
3187
3188 eb = (struct ocfs2_extent_block *)path_leaf_bh(path)->b_data;
3189 el = &eb->h_list;
3190 if (eb->h_next_leaf_blk == 0) {
3191 /*
3192 * This gets a bit tricky if we're going to delete the
3193 * rightmost path. Get the other cases out of the way
3194 * 1st.
3195 */
3196 if (le16_to_cpu(el->l_next_free_rec) > 1)
3197 goto rightmost_no_delete;
3198
3199 if (le16_to_cpu(el->l_next_free_rec) == 0) {
3200 ret = -EIO;
3201 ocfs2_error(ocfs2_metadata_cache_get_super(et->et_ci),
3202 "Owner %llu has empty extent block at %llu",
3203 (unsigned long long)ocfs2_metadata_cache_owner(et->et_ci),
3204 (unsigned long long)le64_to_cpu(eb->h_blkno));
3205 goto out;
3206 }
3207
3208 /*
3209 * XXX: The caller can not trust "path" any more after
3210 * this as it will have been deleted. What do we do?
3211 *
3212 * In theory the rotate-for-merge code will never get
3213 * here because it'll always ask for a rotate in a
3214 * nonempty list.
3215 */
3216
3217 ret = ocfs2_remove_rightmost_path(handle, et, path,
3218 dealloc);
3219 if (ret)
3220 mlog_errno(ret);
3221 goto out;
3222 }
3223
3224 /*
3225 * Now we can loop, remembering the path we get from -EAGAIN
3226 * and restarting from there.
3227 */
3228try_rotate:
3229 ret = __ocfs2_rotate_tree_left(handle, et, orig_credits, path,
3230 dealloc, &restart_path);
3231 if (ret && ret != -EAGAIN) {
3232 mlog_errno(ret);
3233 goto out;
3234 }
3235
3236 while (ret == -EAGAIN) {
3237 tmp_path = restart_path;
3238 restart_path = NULL;
3239
3240 ret = __ocfs2_rotate_tree_left(handle, et, orig_credits,
3241 tmp_path, dealloc,
3242 &restart_path);
3243 if (ret && ret != -EAGAIN) {
3244 mlog_errno(ret);
3245 goto out;
3246 }
3247
3248 ocfs2_free_path(tmp_path);
3249 tmp_path = NULL;
3250
3251 if (ret == 0)
3252 goto try_rotate;
3253 }
3254
3255out:
3256 ocfs2_free_path(tmp_path);
3257 ocfs2_free_path(restart_path);
3258 return ret;
3259}
3260
3261static void ocfs2_cleanup_merge(struct ocfs2_extent_list *el,
3262 int index)
3263{
3264 struct ocfs2_extent_rec *rec = &el->l_recs[index];
3265 unsigned int size;
3266
3267 if (rec->e_leaf_clusters == 0) {
3268 /*
3269 * We consumed all of the merged-from record. An empty
3270 * extent cannot exist anywhere but the 1st array
3271 * position, so move things over if the merged-from
3272 * record doesn't occupy that position.
3273 *
3274 * This creates a new empty extent so the caller
3275 * should be smart enough to have removed any existing
3276 * ones.
3277 */
3278 if (index > 0) {
3279 BUG_ON(ocfs2_is_empty_extent(&el->l_recs[0]));
3280 size = index * sizeof(struct ocfs2_extent_rec);
3281 memmove(&el->l_recs[1], &el->l_recs[0], size);
3282 }
3283
3284 /*
3285 * Always memset - the caller doesn't check whether it
3286 * created an empty extent, so there could be junk in
3287 * the other fields.
3288 */
3289 memset(&el->l_recs[0], 0, sizeof(struct ocfs2_extent_rec));
3290 }
3291}
3292
3293static int ocfs2_get_right_path(struct ocfs2_extent_tree *et,
3294 struct ocfs2_path *left_path,
3295 struct ocfs2_path **ret_right_path)
3296{
3297 int ret;
3298 u32 right_cpos;
3299 struct ocfs2_path *right_path = NULL;
3300 struct ocfs2_extent_list *left_el;
3301
3302 *ret_right_path = NULL;
3303
3304 /* This function shouldn't be called for non-trees. */
3305 BUG_ON(left_path->p_tree_depth == 0);
3306
3307 left_el = path_leaf_el(left_path);
3308 BUG_ON(left_el->l_next_free_rec != left_el->l_count);
3309
3310 ret = ocfs2_find_cpos_for_right_leaf(ocfs2_metadata_cache_get_super(et->et_ci),
3311 left_path, &right_cpos);
3312 if (ret) {
3313 mlog_errno(ret);
3314 goto out;
3315 }
3316
3317 /* This function shouldn't be called for the rightmost leaf. */
3318 BUG_ON(right_cpos == 0);
3319
3320 right_path = ocfs2_new_path_from_path(left_path);
3321 if (!right_path) {
3322 ret = -ENOMEM;
3323 mlog_errno(ret);
3324 goto out;
3325 }
3326
3327 ret = ocfs2_find_path(et->et_ci, right_path, right_cpos);
3328 if (ret) {
3329 mlog_errno(ret);
3330 goto out;
3331 }
3332
3333 *ret_right_path = right_path;
3334out:
3335 if (ret)
3336 ocfs2_free_path(right_path);
3337 return ret;
3338}
3339
3340/*
3341 * Remove split_rec clusters from the record at index and merge them
3342 * onto the beginning of the record "next" to it.
3343 * For index < l_count - 1, the next means the extent rec at index + 1.
3344 * For index == l_count - 1, the "next" means the 1st extent rec of the
3345 * next extent block.
3346 */
3347static int ocfs2_merge_rec_right(struct ocfs2_path *left_path,
3348 handle_t *handle,
3349 struct ocfs2_extent_tree *et,
3350 struct ocfs2_extent_rec *split_rec,
3351 int index)
3352{
3353 int ret, next_free, i;
3354 unsigned int split_clusters = le16_to_cpu(split_rec->e_leaf_clusters);
3355 struct ocfs2_extent_rec *left_rec;
3356 struct ocfs2_extent_rec *right_rec;
3357 struct ocfs2_extent_list *right_el;
3358 struct ocfs2_path *right_path = NULL;
3359 int subtree_index = 0;
3360 struct ocfs2_extent_list *el = path_leaf_el(left_path);
3361 struct buffer_head *bh = path_leaf_bh(left_path);
3362 struct buffer_head *root_bh = NULL;
3363
3364 BUG_ON(index >= le16_to_cpu(el->l_next_free_rec));
3365 left_rec = &el->l_recs[index];
3366
3367 if (index == le16_to_cpu(el->l_next_free_rec) - 1 &&
3368 le16_to_cpu(el->l_next_free_rec) == le16_to_cpu(el->l_count)) {
3369 /* we meet with a cross extent block merge. */
3370 ret = ocfs2_get_right_path(et, left_path, &right_path);
3371 if (ret) {
3372 mlog_errno(ret);
3373 goto out;
3374 }
3375
3376 right_el = path_leaf_el(right_path);
3377 next_free = le16_to_cpu(right_el->l_next_free_rec);
3378 BUG_ON(next_free <= 0);
3379 right_rec = &right_el->l_recs[0];
3380 if (ocfs2_is_empty_extent(right_rec)) {
3381 BUG_ON(next_free <= 1);
3382 right_rec = &right_el->l_recs[1];
3383 }
3384
3385 BUG_ON(le32_to_cpu(left_rec->e_cpos) +
3386 le16_to_cpu(left_rec->e_leaf_clusters) !=
3387 le32_to_cpu(right_rec->e_cpos));
3388
3389 subtree_index = ocfs2_find_subtree_root(et, left_path,
3390 right_path);
3391
3392 ret = ocfs2_extend_rotate_transaction(handle, subtree_index,
3393 handle->h_buffer_credits,
3394 right_path);
3395 if (ret) {
3396 mlog_errno(ret);
3397 goto out;
3398 }
3399
3400 root_bh = left_path->p_node[subtree_index].bh;
3401 BUG_ON(root_bh != right_path->p_node[subtree_index].bh);
3402
3403 ret = ocfs2_path_bh_journal_access(handle, et->et_ci, right_path,
3404 subtree_index);
3405 if (ret) {
3406 mlog_errno(ret);
3407 goto out;
3408 }
3409
3410 for (i = subtree_index + 1;
3411 i < path_num_items(right_path); i++) {
3412 ret = ocfs2_path_bh_journal_access(handle, et->et_ci,
3413 right_path, i);
3414 if (ret) {
3415 mlog_errno(ret);
3416 goto out;
3417 }
3418
3419 ret = ocfs2_path_bh_journal_access(handle, et->et_ci,
3420 left_path, i);
3421 if (ret) {
3422 mlog_errno(ret);
3423 goto out;
3424 }
3425 }
3426
3427 } else {
3428 BUG_ON(index == le16_to_cpu(el->l_next_free_rec) - 1);
3429 right_rec = &el->l_recs[index + 1];
3430 }
3431
3432 ret = ocfs2_path_bh_journal_access(handle, et->et_ci, left_path,
3433 path_num_items(left_path) - 1);
3434 if (ret) {
3435 mlog_errno(ret);
3436 goto out;
3437 }
3438
3439 le16_add_cpu(&left_rec->e_leaf_clusters, -split_clusters);
3440
3441 le32_add_cpu(&right_rec->e_cpos, -split_clusters);
3442 le64_add_cpu(&right_rec->e_blkno,
3443 -ocfs2_clusters_to_blocks(ocfs2_metadata_cache_get_super(et->et_ci),
3444 split_clusters));
3445 le16_add_cpu(&right_rec->e_leaf_clusters, split_clusters);
3446
3447 ocfs2_cleanup_merge(el, index);
3448
3449 ocfs2_journal_dirty(handle, bh);
3450 if (right_path) {
3451 ocfs2_journal_dirty(handle, path_leaf_bh(right_path));
3452 ocfs2_complete_edge_insert(handle, left_path, right_path,
3453 subtree_index);
3454 }
3455out:
3456 if (right_path)
3457 ocfs2_free_path(right_path);
3458 return ret;
3459}
3460
3461static int ocfs2_get_left_path(struct ocfs2_extent_tree *et,
3462 struct ocfs2_path *right_path,
3463 struct ocfs2_path **ret_left_path)
3464{
3465 int ret;
3466 u32 left_cpos;
3467 struct ocfs2_path *left_path = NULL;
3468
3469 *ret_left_path = NULL;
3470
3471 /* This function shouldn't be called for non-trees. */
3472 BUG_ON(right_path->p_tree_depth == 0);
3473
3474 ret = ocfs2_find_cpos_for_left_leaf(ocfs2_metadata_cache_get_super(et->et_ci),
3475 right_path, &left_cpos);
3476 if (ret) {
3477 mlog_errno(ret);
3478 goto out;
3479 }
3480
3481 /* This function shouldn't be called for the leftmost leaf. */
3482 BUG_ON(left_cpos == 0);
3483
3484 left_path = ocfs2_new_path_from_path(right_path);
3485 if (!left_path) {
3486 ret = -ENOMEM;
3487 mlog_errno(ret);
3488 goto out;
3489 }
3490
3491 ret = ocfs2_find_path(et->et_ci, left_path, left_cpos);
3492 if (ret) {
3493 mlog_errno(ret);
3494 goto out;
3495 }
3496
3497 *ret_left_path = left_path;
3498out:
3499 if (ret)
3500 ocfs2_free_path(left_path);
3501 return ret;
3502}
3503
3504/*
3505 * Remove split_rec clusters from the record at index and merge them
3506 * onto the tail of the record "before" it.
3507 * For index > 0, the "before" means the extent rec at index - 1.
3508 *
3509 * For index == 0, the "before" means the last record of the previous
3510 * extent block. And there is also a situation that we may need to
3511 * remove the rightmost leaf extent block in the right_path and change
3512 * the right path to indicate the new rightmost path.
3513 */
3514static int ocfs2_merge_rec_left(struct ocfs2_path *right_path,
3515 handle_t *handle,
3516 struct ocfs2_extent_tree *et,
3517 struct ocfs2_extent_rec *split_rec,
3518 struct ocfs2_cached_dealloc_ctxt *dealloc,
3519 int index)
3520{
3521 int ret, i, subtree_index = 0, has_empty_extent = 0;
3522 unsigned int split_clusters = le16_to_cpu(split_rec->e_leaf_clusters);
3523 struct ocfs2_extent_rec *left_rec;
3524 struct ocfs2_extent_rec *right_rec;
3525 struct ocfs2_extent_list *el = path_leaf_el(right_path);
3526 struct buffer_head *bh = path_leaf_bh(right_path);
3527 struct buffer_head *root_bh = NULL;
3528 struct ocfs2_path *left_path = NULL;
3529 struct ocfs2_extent_list *left_el;
3530
3531 BUG_ON(index < 0);
3532
3533 right_rec = &el->l_recs[index];
3534 if (index == 0) {
3535 /* we meet with a cross extent block merge. */
3536 ret = ocfs2_get_left_path(et, right_path, &left_path);
3537 if (ret) {
3538 mlog_errno(ret);
3539 goto out;
3540 }
3541
3542 left_el = path_leaf_el(left_path);
3543 BUG_ON(le16_to_cpu(left_el->l_next_free_rec) !=
3544 le16_to_cpu(left_el->l_count));
3545
3546 left_rec = &left_el->l_recs[
3547 le16_to_cpu(left_el->l_next_free_rec) - 1];
3548 BUG_ON(le32_to_cpu(left_rec->e_cpos) +
3549 le16_to_cpu(left_rec->e_leaf_clusters) !=
3550 le32_to_cpu(split_rec->e_cpos));
3551
3552 subtree_index = ocfs2_find_subtree_root(et, left_path,
3553 right_path);
3554
3555 ret = ocfs2_extend_rotate_transaction(handle, subtree_index,
3556 handle->h_buffer_credits,
3557 left_path);
3558 if (ret) {
3559 mlog_errno(ret);
3560 goto out;
3561 }
3562
3563 root_bh = left_path->p_node[subtree_index].bh;
3564 BUG_ON(root_bh != right_path->p_node[subtree_index].bh);
3565
3566 ret = ocfs2_path_bh_journal_access(handle, et->et_ci, right_path,
3567 subtree_index);
3568 if (ret) {
3569 mlog_errno(ret);
3570 goto out;
3571 }
3572
3573 for (i = subtree_index + 1;
3574 i < path_num_items(right_path); i++) {
3575 ret = ocfs2_path_bh_journal_access(handle, et->et_ci,
3576 right_path, i);
3577 if (ret) {
3578 mlog_errno(ret);
3579 goto out;
3580 }
3581
3582 ret = ocfs2_path_bh_journal_access(handle, et->et_ci,
3583 left_path, i);
3584 if (ret) {
3585 mlog_errno(ret);
3586 goto out;
3587 }
3588 }
3589 } else {
3590 left_rec = &el->l_recs[index - 1];
3591 if (ocfs2_is_empty_extent(&el->l_recs[0]))
3592 has_empty_extent = 1;
3593 }
3594
3595 ret = ocfs2_path_bh_journal_access(handle, et->et_ci, right_path,
3596 path_num_items(right_path) - 1);
3597 if (ret) {
3598 mlog_errno(ret);
3599 goto out;
3600 }
3601
3602 if (has_empty_extent && index == 1) {
3603 /*
3604 * The easy case - we can just plop the record right in.
3605 */
3606 *left_rec = *split_rec;
3607
3608 has_empty_extent = 0;
3609 } else
3610 le16_add_cpu(&left_rec->e_leaf_clusters, split_clusters);
3611
3612 le32_add_cpu(&right_rec->e_cpos, split_clusters);
3613 le64_add_cpu(&right_rec->e_blkno,
3614 ocfs2_clusters_to_blocks(ocfs2_metadata_cache_get_super(et->et_ci),
3615 split_clusters));
3616 le16_add_cpu(&right_rec->e_leaf_clusters, -split_clusters);
3617
3618 ocfs2_cleanup_merge(el, index);
3619
3620 ocfs2_journal_dirty(handle, bh);
3621 if (left_path) {
3622 ocfs2_journal_dirty(handle, path_leaf_bh(left_path));
3623
3624 /*
3625 * In the situation that the right_rec is empty and the extent
3626 * block is empty also, ocfs2_complete_edge_insert can't handle
3627 * it and we need to delete the right extent block.
3628 */
3629 if (le16_to_cpu(right_rec->e_leaf_clusters) == 0 &&
3630 le16_to_cpu(el->l_next_free_rec) == 1) {
3631
3632 ret = ocfs2_remove_rightmost_path(handle, et,
3633 right_path,
3634 dealloc);
3635 if (ret) {
3636 mlog_errno(ret);
3637 goto out;
3638 }
3639
3640 /* Now the rightmost extent block has been deleted.
3641 * So we use the new rightmost path.
3642 */
3643 ocfs2_mv_path(right_path, left_path);
3644 left_path = NULL;
3645 } else
3646 ocfs2_complete_edge_insert(handle, left_path,
3647 right_path, subtree_index);
3648 }
3649out:
3650 if (left_path)
3651 ocfs2_free_path(left_path);
3652 return ret;
3653}
3654
3655static int ocfs2_try_to_merge_extent(handle_t *handle,
3656 struct ocfs2_extent_tree *et,
3657 struct ocfs2_path *path,
3658 int split_index,
3659 struct ocfs2_extent_rec *split_rec,
3660 struct ocfs2_cached_dealloc_ctxt *dealloc,
3661 struct ocfs2_merge_ctxt *ctxt)
3662{
3663 int ret = 0;
3664 struct ocfs2_extent_list *el = path_leaf_el(path);
3665 struct ocfs2_extent_rec *rec = &el->l_recs[split_index];
3666
3667 BUG_ON(ctxt->c_contig_type == CONTIG_NONE);
3668
3669 if (ctxt->c_split_covers_rec && ctxt->c_has_empty_extent) {
3670 /*
3671 * The merge code will need to create an empty
3672 * extent to take the place of the newly
3673 * emptied slot. Remove any pre-existing empty
3674 * extents - having more than one in a leaf is
3675 * illegal.
3676 */
3677 ret = ocfs2_rotate_tree_left(handle, et, path, dealloc);
3678 if (ret) {
3679 mlog_errno(ret);
3680 goto out;
3681 }
3682 split_index--;
3683 rec = &el->l_recs[split_index];
3684 }
3685
3686 if (ctxt->c_contig_type == CONTIG_LEFTRIGHT) {
3687 /*
3688 * Left-right contig implies this.
3689 */
3690 BUG_ON(!ctxt->c_split_covers_rec);
3691
3692 /*
3693 * Since the leftright insert always covers the entire
3694 * extent, this call will delete the insert record
3695 * entirely, resulting in an empty extent record added to
3696 * the extent block.
3697 *
3698 * Since the adding of an empty extent shifts
3699 * everything back to the right, there's no need to
3700 * update split_index here.
3701 *
3702 * When the split_index is zero, we need to merge it to the
3703 * prevoius extent block. It is more efficient and easier
3704 * if we do merge_right first and merge_left later.
3705 */
3706 ret = ocfs2_merge_rec_right(path, handle, et, split_rec,
3707 split_index);
3708 if (ret) {
3709 mlog_errno(ret);
3710 goto out;
3711 }
3712
3713 /*
3714 * We can only get this from logic error above.
3715 */
3716 BUG_ON(!ocfs2_is_empty_extent(&el->l_recs[0]));
3717
3718 /* The merge left us with an empty extent, remove it. */
3719 ret = ocfs2_rotate_tree_left(handle, et, path, dealloc);
3720 if (ret) {
3721 mlog_errno(ret);
3722 goto out;
3723 }
3724
3725 rec = &el->l_recs[split_index];
3726
3727 /*
3728 * Note that we don't pass split_rec here on purpose -
3729 * we've merged it into the rec already.
3730 */
3731 ret = ocfs2_merge_rec_left(path, handle, et, rec,
3732 dealloc, split_index);
3733
3734 if (ret) {
3735 mlog_errno(ret);
3736 goto out;
3737 }
3738
3739 ret = ocfs2_rotate_tree_left(handle, et, path, dealloc);
3740 /*
3741 * Error from this last rotate is not critical, so
3742 * print but don't bubble it up.
3743 */
3744 if (ret)
3745 mlog_errno(ret);
3746 ret = 0;
3747 } else {
3748 /*
3749 * Merge a record to the left or right.
3750 *
3751 * 'contig_type' is relative to the existing record,
3752 * so for example, if we're "right contig", it's to
3753 * the record on the left (hence the left merge).
3754 */
3755 if (ctxt->c_contig_type == CONTIG_RIGHT) {
3756 ret = ocfs2_merge_rec_left(path, handle, et,
3757 split_rec, dealloc,
3758 split_index);
3759 if (ret) {
3760 mlog_errno(ret);
3761 goto out;
3762 }
3763 } else {
3764 ret = ocfs2_merge_rec_right(path, handle,
3765 et, split_rec,
3766 split_index);
3767 if (ret) {
3768 mlog_errno(ret);
3769 goto out;
3770 }
3771 }
3772
3773 if (ctxt->c_split_covers_rec) {
3774 /*
3775 * The merge may have left an empty extent in
3776 * our leaf. Try to rotate it away.
3777 */
3778 ret = ocfs2_rotate_tree_left(handle, et, path,
3779 dealloc);
3780 if (ret)
3781 mlog_errno(ret);
3782 ret = 0;
3783 }
3784 }
3785
3786out:
3787 return ret;
3788}
3789
3790static void ocfs2_subtract_from_rec(struct super_block *sb,
3791 enum ocfs2_split_type split,
3792 struct ocfs2_extent_rec *rec,
3793 struct ocfs2_extent_rec *split_rec)
3794{
3795 u64 len_blocks;
3796
3797 len_blocks = ocfs2_clusters_to_blocks(sb,
3798 le16_to_cpu(split_rec->e_leaf_clusters));
3799
3800 if (split == SPLIT_LEFT) {
3801 /*
3802 * Region is on the left edge of the existing
3803 * record.
3804 */
3805 le32_add_cpu(&rec->e_cpos,
3806 le16_to_cpu(split_rec->e_leaf_clusters));
3807 le64_add_cpu(&rec->e_blkno, len_blocks);
3808 le16_add_cpu(&rec->e_leaf_clusters,
3809 -le16_to_cpu(split_rec->e_leaf_clusters));
3810 } else {
3811 /*
3812 * Region is on the right edge of the existing
3813 * record.
3814 */
3815 le16_add_cpu(&rec->e_leaf_clusters,
3816 -le16_to_cpu(split_rec->e_leaf_clusters));
3817 }
3818}
3819
3820/*
3821 * Do the final bits of extent record insertion at the target leaf
3822 * list. If this leaf is part of an allocation tree, it is assumed
3823 * that the tree above has been prepared.
3824 */
3825static void ocfs2_insert_at_leaf(struct ocfs2_extent_tree *et,
3826 struct ocfs2_extent_rec *insert_rec,
3827 struct ocfs2_extent_list *el,
3828 struct ocfs2_insert_type *insert)
3829{
3830 int i = insert->ins_contig_index;
3831 unsigned int range;
3832 struct ocfs2_extent_rec *rec;
3833
3834 BUG_ON(le16_to_cpu(el->l_tree_depth) != 0);
3835
3836 if (insert->ins_split != SPLIT_NONE) {
3837 i = ocfs2_search_extent_list(el, le32_to_cpu(insert_rec->e_cpos));
3838 BUG_ON(i == -1);
3839 rec = &el->l_recs[i];
3840 ocfs2_subtract_from_rec(ocfs2_metadata_cache_get_super(et->et_ci),
3841 insert->ins_split, rec,
3842 insert_rec);
3843 goto rotate;
3844 }
3845
3846 /*
3847 * Contiguous insert - either left or right.
3848 */
3849 if (insert->ins_contig != CONTIG_NONE) {
3850 rec = &el->l_recs[i];
3851 if (insert->ins_contig == CONTIG_LEFT) {
3852 rec->e_blkno = insert_rec->e_blkno;
3853 rec->e_cpos = insert_rec->e_cpos;
3854 }
3855 le16_add_cpu(&rec->e_leaf_clusters,
3856 le16_to_cpu(insert_rec->e_leaf_clusters));
3857 return;
3858 }
3859
3860 /*
3861 * Handle insert into an empty leaf.
3862 */
3863 if (le16_to_cpu(el->l_next_free_rec) == 0 ||
3864 ((le16_to_cpu(el->l_next_free_rec) == 1) &&
3865 ocfs2_is_empty_extent(&el->l_recs[0]))) {
3866 el->l_recs[0] = *insert_rec;
3867 el->l_next_free_rec = cpu_to_le16(1);
3868 return;
3869 }
3870
3871 /*
3872 * Appending insert.
3873 */
3874 if (insert->ins_appending == APPEND_TAIL) {
3875 i = le16_to_cpu(el->l_next_free_rec) - 1;
3876 rec = &el->l_recs[i];
3877 range = le32_to_cpu(rec->e_cpos)
3878 + le16_to_cpu(rec->e_leaf_clusters);
3879 BUG_ON(le32_to_cpu(insert_rec->e_cpos) < range);
3880
3881 mlog_bug_on_msg(le16_to_cpu(el->l_next_free_rec) >=
3882 le16_to_cpu(el->l_count),
3883 "owner %llu, depth %u, count %u, next free %u, "
3884 "rec.cpos %u, rec.clusters %u, "
3885 "insert.cpos %u, insert.clusters %u\n",
3886 ocfs2_metadata_cache_owner(et->et_ci),
3887 le16_to_cpu(el->l_tree_depth),
3888 le16_to_cpu(el->l_count),
3889 le16_to_cpu(el->l_next_free_rec),
3890 le32_to_cpu(el->l_recs[i].e_cpos),
3891 le16_to_cpu(el->l_recs[i].e_leaf_clusters),
3892 le32_to_cpu(insert_rec->e_cpos),
3893 le16_to_cpu(insert_rec->e_leaf_clusters));
3894 i++;
3895 el->l_recs[i] = *insert_rec;
3896 le16_add_cpu(&el->l_next_free_rec, 1);
3897 return;
3898 }
3899
3900rotate:
3901 /*
3902 * Ok, we have to rotate.
3903 *
3904 * At this point, it is safe to assume that inserting into an
3905 * empty leaf and appending to a leaf have both been handled
3906 * above.
3907 *
3908 * This leaf needs to have space, either by the empty 1st
3909 * extent record, or by virtue of an l_next_rec < l_count.
3910 */
3911 ocfs2_rotate_leaf(el, insert_rec);
3912}
3913
3914static void ocfs2_adjust_rightmost_records(handle_t *handle,
3915 struct ocfs2_extent_tree *et,
3916 struct ocfs2_path *path,
3917 struct ocfs2_extent_rec *insert_rec)
3918{
3919 int ret, i, next_free;
3920 struct buffer_head *bh;
3921 struct ocfs2_extent_list *el;
3922 struct ocfs2_extent_rec *rec;
3923
3924 /*
3925 * Update everything except the leaf block.
3926 */
3927 for (i = 0; i < path->p_tree_depth; i++) {
3928 bh = path->p_node[i].bh;
3929 el = path->p_node[i].el;
3930
3931 next_free = le16_to_cpu(el->l_next_free_rec);
3932 if (next_free == 0) {
3933 ocfs2_error(ocfs2_metadata_cache_get_super(et->et_ci),
3934 "Owner %llu has a bad extent list",
3935 (unsigned long long)ocfs2_metadata_cache_owner(et->et_ci));
3936 ret = -EIO;
3937 return;
3938 }
3939
3940 rec = &el->l_recs[next_free - 1];
3941
3942 rec->e_int_clusters = insert_rec->e_cpos;
3943 le32_add_cpu(&rec->e_int_clusters,
3944 le16_to_cpu(insert_rec->e_leaf_clusters));
3945 le32_add_cpu(&rec->e_int_clusters,
3946 -le32_to_cpu(rec->e_cpos));
3947
3948 ocfs2_journal_dirty(handle, bh);
3949 }
3950}
3951
3952static int ocfs2_append_rec_to_path(handle_t *handle,
3953 struct ocfs2_extent_tree *et,
3954 struct ocfs2_extent_rec *insert_rec,
3955 struct ocfs2_path *right_path,
3956 struct ocfs2_path **ret_left_path)
3957{
3958 int ret, next_free;
3959 struct ocfs2_extent_list *el;
3960 struct ocfs2_path *left_path = NULL;
3961
3962 *ret_left_path = NULL;
3963
3964 /*
3965 * This shouldn't happen for non-trees. The extent rec cluster
3966 * count manipulation below only works for interior nodes.
3967 */
3968 BUG_ON(right_path->p_tree_depth == 0);
3969
3970 /*
3971 * If our appending insert is at the leftmost edge of a leaf,
3972 * then we might need to update the rightmost records of the
3973 * neighboring path.
3974 */
3975 el = path_leaf_el(right_path);
3976 next_free = le16_to_cpu(el->l_next_free_rec);
3977 if (next_free == 0 ||
3978 (next_free == 1 && ocfs2_is_empty_extent(&el->l_recs[0]))) {
3979 u32 left_cpos;
3980
3981 ret = ocfs2_find_cpos_for_left_leaf(ocfs2_metadata_cache_get_super(et->et_ci),
3982 right_path, &left_cpos);
3983 if (ret) {
3984 mlog_errno(ret);
3985 goto out;
3986 }
3987
3988 trace_ocfs2_append_rec_to_path(
3989 (unsigned long long)
3990 ocfs2_metadata_cache_owner(et->et_ci),
3991 le32_to_cpu(insert_rec->e_cpos),
3992 left_cpos);
3993
3994 /*
3995 * No need to worry if the append is already in the
3996 * leftmost leaf.
3997 */
3998 if (left_cpos) {
3999 left_path = ocfs2_new_path_from_path(right_path);
4000 if (!left_path) {
4001 ret = -ENOMEM;
4002 mlog_errno(ret);
4003 goto out;
4004 }
4005
4006 ret = ocfs2_find_path(et->et_ci, left_path,
4007 left_cpos);
4008 if (ret) {
4009 mlog_errno(ret);
4010 goto out;
4011 }
4012
4013 /*
4014 * ocfs2_insert_path() will pass the left_path to the
4015 * journal for us.
4016 */
4017 }
4018 }
4019
4020 ret = ocfs2_journal_access_path(et->et_ci, handle, right_path);
4021 if (ret) {
4022 mlog_errno(ret);
4023 goto out;
4024 }
4025
4026 ocfs2_adjust_rightmost_records(handle, et, right_path, insert_rec);
4027
4028 *ret_left_path = left_path;
4029 ret = 0;
4030out:
4031 if (ret != 0)
4032 ocfs2_free_path(left_path);
4033
4034 return ret;
4035}
4036
4037static void ocfs2_split_record(struct ocfs2_extent_tree *et,
4038 struct ocfs2_path *left_path,
4039 struct ocfs2_path *right_path,
4040 struct ocfs2_extent_rec *split_rec,
4041 enum ocfs2_split_type split)
4042{
4043 int index;
4044 u32 cpos = le32_to_cpu(split_rec->e_cpos);
4045 struct ocfs2_extent_list *left_el = NULL, *right_el, *insert_el, *el;
4046 struct ocfs2_extent_rec *rec, *tmprec;
4047
4048 right_el = path_leaf_el(right_path);
4049 if (left_path)
4050 left_el = path_leaf_el(left_path);
4051
4052 el = right_el;
4053 insert_el = right_el;
4054 index = ocfs2_search_extent_list(el, cpos);
4055 if (index != -1) {
4056 if (index == 0 && left_path) {
4057 BUG_ON(ocfs2_is_empty_extent(&el->l_recs[0]));
4058
4059 /*
4060 * This typically means that the record
4061 * started in the left path but moved to the
4062 * right as a result of rotation. We either
4063 * move the existing record to the left, or we
4064 * do the later insert there.
4065 *
4066 * In this case, the left path should always
4067 * exist as the rotate code will have passed
4068 * it back for a post-insert update.
4069 */
4070
4071 if (split == SPLIT_LEFT) {
4072 /*
4073 * It's a left split. Since we know
4074 * that the rotate code gave us an
4075 * empty extent in the left path, we
4076 * can just do the insert there.
4077 */
4078 insert_el = left_el;
4079 } else {
4080 /*
4081 * Right split - we have to move the
4082 * existing record over to the left
4083 * leaf. The insert will be into the
4084 * newly created empty extent in the
4085 * right leaf.
4086 */
4087 tmprec = &right_el->l_recs[index];
4088 ocfs2_rotate_leaf(left_el, tmprec);
4089 el = left_el;
4090
4091 memset(tmprec, 0, sizeof(*tmprec));
4092 index = ocfs2_search_extent_list(left_el, cpos);
4093 BUG_ON(index == -1);
4094 }
4095 }
4096 } else {
4097 BUG_ON(!left_path);
4098 BUG_ON(!ocfs2_is_empty_extent(&left_el->l_recs[0]));
4099 /*
4100 * Left path is easy - we can just allow the insert to
4101 * happen.
4102 */
4103 el = left_el;
4104 insert_el = left_el;
4105 index = ocfs2_search_extent_list(el, cpos);
4106 BUG_ON(index == -1);
4107 }
4108
4109 rec = &el->l_recs[index];
4110 ocfs2_subtract_from_rec(ocfs2_metadata_cache_get_super(et->et_ci),
4111 split, rec, split_rec);
4112 ocfs2_rotate_leaf(insert_el, split_rec);
4113}
4114
4115/*
4116 * This function only does inserts on an allocation b-tree. For tree
4117 * depth = 0, ocfs2_insert_at_leaf() is called directly.
4118 *
4119 * right_path is the path we want to do the actual insert
4120 * in. left_path should only be passed in if we need to update that
4121 * portion of the tree after an edge insert.
4122 */
4123static int ocfs2_insert_path(handle_t *handle,
4124 struct ocfs2_extent_tree *et,
4125 struct ocfs2_path *left_path,
4126 struct ocfs2_path *right_path,
4127 struct ocfs2_extent_rec *insert_rec,
4128 struct ocfs2_insert_type *insert)
4129{
4130 int ret, subtree_index;
4131 struct buffer_head *leaf_bh = path_leaf_bh(right_path);
4132
4133 if (left_path) {
4134 /*
4135 * There's a chance that left_path got passed back to
4136 * us without being accounted for in the
4137 * journal. Extend our transaction here to be sure we
4138 * can change those blocks.
4139 */
4140 ret = ocfs2_extend_trans(handle, left_path->p_tree_depth);
4141 if (ret < 0) {
4142 mlog_errno(ret);
4143 goto out;
4144 }
4145
4146 ret = ocfs2_journal_access_path(et->et_ci, handle, left_path);
4147 if (ret < 0) {
4148 mlog_errno(ret);
4149 goto out;
4150 }
4151 }
4152
4153 /*
4154 * Pass both paths to the journal. The majority of inserts
4155 * will be touching all components anyway.
4156 */
4157 ret = ocfs2_journal_access_path(et->et_ci, handle, right_path);
4158 if (ret < 0) {
4159 mlog_errno(ret);
4160 goto out;
4161 }
4162
4163 if (insert->ins_split != SPLIT_NONE) {
4164 /*
4165 * We could call ocfs2_insert_at_leaf() for some types
4166 * of splits, but it's easier to just let one separate
4167 * function sort it all out.
4168 */
4169 ocfs2_split_record(et, left_path, right_path,
4170 insert_rec, insert->ins_split);
4171
4172 /*
4173 * Split might have modified either leaf and we don't
4174 * have a guarantee that the later edge insert will
4175 * dirty this for us.
4176 */
4177 if (left_path)
4178 ocfs2_journal_dirty(handle,
4179 path_leaf_bh(left_path));
4180 } else
4181 ocfs2_insert_at_leaf(et, insert_rec, path_leaf_el(right_path),
4182 insert);
4183
4184 ocfs2_journal_dirty(handle, leaf_bh);
4185
4186 if (left_path) {
4187 /*
4188 * The rotate code has indicated that we need to fix
4189 * up portions of the tree after the insert.
4190 *
4191 * XXX: Should we extend the transaction here?
4192 */
4193 subtree_index = ocfs2_find_subtree_root(et, left_path,
4194 right_path);
4195 ocfs2_complete_edge_insert(handle, left_path, right_path,
4196 subtree_index);
4197 }
4198
4199 ret = 0;
4200out:
4201 return ret;
4202}
4203
4204static int ocfs2_do_insert_extent(handle_t *handle,
4205 struct ocfs2_extent_tree *et,
4206 struct ocfs2_extent_rec *insert_rec,
4207 struct ocfs2_insert_type *type)
4208{
4209 int ret, rotate = 0;
4210 u32 cpos;
4211 struct ocfs2_path *right_path = NULL;
4212 struct ocfs2_path *left_path = NULL;
4213 struct ocfs2_extent_list *el;
4214
4215 el = et->et_root_el;
4216
4217 ret = ocfs2_et_root_journal_access(handle, et,
4218 OCFS2_JOURNAL_ACCESS_WRITE);
4219 if (ret) {
4220 mlog_errno(ret);
4221 goto out;
4222 }
4223
4224 if (le16_to_cpu(el->l_tree_depth) == 0) {
4225 ocfs2_insert_at_leaf(et, insert_rec, el, type);
4226 goto out_update_clusters;
4227 }
4228
4229 right_path = ocfs2_new_path_from_et(et);
4230 if (!right_path) {
4231 ret = -ENOMEM;
4232 mlog_errno(ret);
4233 goto out;
4234 }
4235
4236 /*
4237 * Determine the path to start with. Rotations need the
4238 * rightmost path, everything else can go directly to the
4239 * target leaf.
4240 */
4241 cpos = le32_to_cpu(insert_rec->e_cpos);
4242 if (type->ins_appending == APPEND_NONE &&
4243 type->ins_contig == CONTIG_NONE) {
4244 rotate = 1;
4245 cpos = UINT_MAX;
4246 }
4247
4248 ret = ocfs2_find_path(et->et_ci, right_path, cpos);
4249 if (ret) {
4250 mlog_errno(ret);
4251 goto out;
4252 }
4253
4254 /*
4255 * Rotations and appends need special treatment - they modify
4256 * parts of the tree's above them.
4257 *
4258 * Both might pass back a path immediate to the left of the
4259 * one being inserted to. This will be cause
4260 * ocfs2_insert_path() to modify the rightmost records of
4261 * left_path to account for an edge insert.
4262 *
4263 * XXX: When modifying this code, keep in mind that an insert
4264 * can wind up skipping both of these two special cases...
4265 */
4266 if (rotate) {
4267 ret = ocfs2_rotate_tree_right(handle, et, type->ins_split,
4268 le32_to_cpu(insert_rec->e_cpos),
4269 right_path, &left_path);
4270 if (ret) {
4271 mlog_errno(ret);
4272 goto out;
4273 }
4274
4275 /*
4276 * ocfs2_rotate_tree_right() might have extended the
4277 * transaction without re-journaling our tree root.
4278 */
4279 ret = ocfs2_et_root_journal_access(handle, et,
4280 OCFS2_JOURNAL_ACCESS_WRITE);
4281 if (ret) {
4282 mlog_errno(ret);
4283 goto out;
4284 }
4285 } else if (type->ins_appending == APPEND_TAIL
4286 && type->ins_contig != CONTIG_LEFT) {
4287 ret = ocfs2_append_rec_to_path(handle, et, insert_rec,
4288 right_path, &left_path);
4289 if (ret) {
4290 mlog_errno(ret);
4291 goto out;
4292 }
4293 }
4294
4295 ret = ocfs2_insert_path(handle, et, left_path, right_path,
4296 insert_rec, type);
4297 if (ret) {
4298 mlog_errno(ret);
4299 goto out;
4300 }
4301
4302out_update_clusters:
4303 if (type->ins_split == SPLIT_NONE)
4304 ocfs2_et_update_clusters(et,
4305 le16_to_cpu(insert_rec->e_leaf_clusters));
4306
4307 ocfs2_journal_dirty(handle, et->et_root_bh);
4308
4309out:
4310 ocfs2_free_path(left_path);
4311 ocfs2_free_path(right_path);
4312
4313 return ret;
4314}
4315
4316static enum ocfs2_contig_type
4317ocfs2_figure_merge_contig_type(struct ocfs2_extent_tree *et,
4318 struct ocfs2_path *path,
4319 struct ocfs2_extent_list *el, int index,
4320 struct ocfs2_extent_rec *split_rec)
4321{
4322 int status;
4323 enum ocfs2_contig_type ret = CONTIG_NONE;
4324 u32 left_cpos, right_cpos;
4325 struct ocfs2_extent_rec *rec = NULL;
4326 struct ocfs2_extent_list *new_el;
4327 struct ocfs2_path *left_path = NULL, *right_path = NULL;
4328 struct buffer_head *bh;
4329 struct ocfs2_extent_block *eb;
4330 struct super_block *sb = ocfs2_metadata_cache_get_super(et->et_ci);
4331
4332 if (index > 0) {
4333 rec = &el->l_recs[index - 1];
4334 } else if (path->p_tree_depth > 0) {
4335 status = ocfs2_find_cpos_for_left_leaf(sb, path, &left_cpos);
4336 if (status)
4337 goto out;
4338
4339 if (left_cpos != 0) {
4340 left_path = ocfs2_new_path_from_path(path);
4341 if (!left_path)
4342 goto out;
4343
4344 status = ocfs2_find_path(et->et_ci, left_path,
4345 left_cpos);
4346 if (status)
4347 goto out;
4348
4349 new_el = path_leaf_el(left_path);
4350
4351 if (le16_to_cpu(new_el->l_next_free_rec) !=
4352 le16_to_cpu(new_el->l_count)) {
4353 bh = path_leaf_bh(left_path);
4354 eb = (struct ocfs2_extent_block *)bh->b_data;
4355 ocfs2_error(sb,
4356 "Extent block #%llu has an "
4357 "invalid l_next_free_rec of "
4358 "%d. It should have "
4359 "matched the l_count of %d",
4360 (unsigned long long)le64_to_cpu(eb->h_blkno),
4361 le16_to_cpu(new_el->l_next_free_rec),
4362 le16_to_cpu(new_el->l_count));
4363 status = -EINVAL;
4364 goto out;
4365 }
4366 rec = &new_el->l_recs[
4367 le16_to_cpu(new_el->l_next_free_rec) - 1];
4368 }
4369 }
4370
4371 /*
4372 * We're careful to check for an empty extent record here -
4373 * the merge code will know what to do if it sees one.
4374 */
4375 if (rec) {
4376 if (index == 1 && ocfs2_is_empty_extent(rec)) {
4377 if (split_rec->e_cpos == el->l_recs[index].e_cpos)
4378 ret = CONTIG_RIGHT;
4379 } else {
4380 ret = ocfs2_et_extent_contig(et, rec, split_rec);
4381 }
4382 }
4383
4384 rec = NULL;
4385 if (index < (le16_to_cpu(el->l_next_free_rec) - 1))
4386 rec = &el->l_recs[index + 1];
4387 else if (le16_to_cpu(el->l_next_free_rec) == le16_to_cpu(el->l_count) &&
4388 path->p_tree_depth > 0) {
4389 status = ocfs2_find_cpos_for_right_leaf(sb, path, &right_cpos);
4390 if (status)
4391 goto out;
4392
4393 if (right_cpos == 0)
4394 goto out;
4395
4396 right_path = ocfs2_new_path_from_path(path);
4397 if (!right_path)
4398 goto out;
4399
4400 status = ocfs2_find_path(et->et_ci, right_path, right_cpos);
4401 if (status)
4402 goto out;
4403
4404 new_el = path_leaf_el(right_path);
4405 rec = &new_el->l_recs[0];
4406 if (ocfs2_is_empty_extent(rec)) {
4407 if (le16_to_cpu(new_el->l_next_free_rec) <= 1) {
4408 bh = path_leaf_bh(right_path);
4409 eb = (struct ocfs2_extent_block *)bh->b_data;
4410 ocfs2_error(sb,
4411 "Extent block #%llu has an "
4412 "invalid l_next_free_rec of %d",
4413 (unsigned long long)le64_to_cpu(eb->h_blkno),
4414 le16_to_cpu(new_el->l_next_free_rec));
4415 status = -EINVAL;
4416 goto out;
4417 }
4418 rec = &new_el->l_recs[1];
4419 }
4420 }
4421
4422 if (rec) {
4423 enum ocfs2_contig_type contig_type;
4424
4425 contig_type = ocfs2_et_extent_contig(et, rec, split_rec);
4426
4427 if (contig_type == CONTIG_LEFT && ret == CONTIG_RIGHT)
4428 ret = CONTIG_LEFTRIGHT;
4429 else if (ret == CONTIG_NONE)
4430 ret = contig_type;
4431 }
4432
4433out:
4434 if (left_path)
4435 ocfs2_free_path(left_path);
4436 if (right_path)
4437 ocfs2_free_path(right_path);
4438
4439 return ret;
4440}
4441
4442static void ocfs2_figure_contig_type(struct ocfs2_extent_tree *et,
4443 struct ocfs2_insert_type *insert,
4444 struct ocfs2_extent_list *el,
4445 struct ocfs2_extent_rec *insert_rec)
4446{
4447 int i;
4448 enum ocfs2_contig_type contig_type = CONTIG_NONE;
4449
4450 BUG_ON(le16_to_cpu(el->l_tree_depth) != 0);
4451
4452 for(i = 0; i < le16_to_cpu(el->l_next_free_rec); i++) {
4453 contig_type = ocfs2_et_extent_contig(et, &el->l_recs[i],
4454 insert_rec);
4455 if (contig_type != CONTIG_NONE) {
4456 insert->ins_contig_index = i;
4457 break;
4458 }
4459 }
4460 insert->ins_contig = contig_type;
4461
4462 if (insert->ins_contig != CONTIG_NONE) {
4463 struct ocfs2_extent_rec *rec =
4464 &el->l_recs[insert->ins_contig_index];
4465 unsigned int len = le16_to_cpu(rec->e_leaf_clusters) +
4466 le16_to_cpu(insert_rec->e_leaf_clusters);
4467
4468 /*
4469 * Caller might want us to limit the size of extents, don't
4470 * calculate contiguousness if we might exceed that limit.
4471 */
4472 if (et->et_max_leaf_clusters &&
4473 (len > et->et_max_leaf_clusters))
4474 insert->ins_contig = CONTIG_NONE;
4475 }
4476}
4477
4478/*
4479 * This should only be called against the righmost leaf extent list.
4480 *
4481 * ocfs2_figure_appending_type() will figure out whether we'll have to
4482 * insert at the tail of the rightmost leaf.
4483 *
4484 * This should also work against the root extent list for tree's with 0
4485 * depth. If we consider the root extent list to be the rightmost leaf node
4486 * then the logic here makes sense.
4487 */
4488static void ocfs2_figure_appending_type(struct ocfs2_insert_type *insert,
4489 struct ocfs2_extent_list *el,
4490 struct ocfs2_extent_rec *insert_rec)
4491{
4492 int i;
4493 u32 cpos = le32_to_cpu(insert_rec->e_cpos);
4494 struct ocfs2_extent_rec *rec;
4495
4496 insert->ins_appending = APPEND_NONE;
4497
4498 BUG_ON(le16_to_cpu(el->l_tree_depth) != 0);
4499
4500 if (!el->l_next_free_rec)
4501 goto set_tail_append;
4502
4503 if (ocfs2_is_empty_extent(&el->l_recs[0])) {
4504 /* Were all records empty? */
4505 if (le16_to_cpu(el->l_next_free_rec) == 1)
4506 goto set_tail_append;
4507 }
4508
4509 i = le16_to_cpu(el->l_next_free_rec) - 1;
4510 rec = &el->l_recs[i];
4511
4512 if (cpos >=
4513 (le32_to_cpu(rec->e_cpos) + le16_to_cpu(rec->e_leaf_clusters)))
4514 goto set_tail_append;
4515
4516 return;
4517
4518set_tail_append:
4519 insert->ins_appending = APPEND_TAIL;
4520}
4521
4522/*
4523 * Helper function called at the beginning of an insert.
4524 *
4525 * This computes a few things that are commonly used in the process of
4526 * inserting into the btree:
4527 * - Whether the new extent is contiguous with an existing one.
4528 * - The current tree depth.
4529 * - Whether the insert is an appending one.
4530 * - The total # of free records in the tree.
4531 *
4532 * All of the information is stored on the ocfs2_insert_type
4533 * structure.
4534 */
4535static int ocfs2_figure_insert_type(struct ocfs2_extent_tree *et,
4536 struct buffer_head **last_eb_bh,
4537 struct ocfs2_extent_rec *insert_rec,
4538 int *free_records,
4539 struct ocfs2_insert_type *insert)
4540{
4541 int ret;
4542 struct ocfs2_extent_block *eb;
4543 struct ocfs2_extent_list *el;
4544 struct ocfs2_path *path = NULL;
4545 struct buffer_head *bh = NULL;
4546
4547 insert->ins_split = SPLIT_NONE;
4548
4549 el = et->et_root_el;
4550 insert->ins_tree_depth = le16_to_cpu(el->l_tree_depth);
4551
4552 if (el->l_tree_depth) {
4553 /*
4554 * If we have tree depth, we read in the
4555 * rightmost extent block ahead of time as
4556 * ocfs2_figure_insert_type() and ocfs2_add_branch()
4557 * may want it later.
4558 */
4559 ret = ocfs2_read_extent_block(et->et_ci,
4560 ocfs2_et_get_last_eb_blk(et),
4561 &bh);
4562 if (ret) {
4563 mlog_errno(ret);
4564 goto out;
4565 }
4566 eb = (struct ocfs2_extent_block *) bh->b_data;
4567 el = &eb->h_list;
4568 }
4569
4570 /*
4571 * Unless we have a contiguous insert, we'll need to know if
4572 * there is room left in our allocation tree for another
4573 * extent record.
4574 *
4575 * XXX: This test is simplistic, we can search for empty
4576 * extent records too.
4577 */
4578 *free_records = le16_to_cpu(el->l_count) -
4579 le16_to_cpu(el->l_next_free_rec);
4580
4581 if (!insert->ins_tree_depth) {
4582 ocfs2_figure_contig_type(et, insert, el, insert_rec);
4583 ocfs2_figure_appending_type(insert, el, insert_rec);
4584 return 0;
4585 }
4586
4587 path = ocfs2_new_path_from_et(et);
4588 if (!path) {
4589 ret = -ENOMEM;
4590 mlog_errno(ret);
4591 goto out;
4592 }
4593
4594 /*
4595 * In the case that we're inserting past what the tree
4596 * currently accounts for, ocfs2_find_path() will return for
4597 * us the rightmost tree path. This is accounted for below in
4598 * the appending code.
4599 */
4600 ret = ocfs2_find_path(et->et_ci, path, le32_to_cpu(insert_rec->e_cpos));
4601 if (ret) {
4602 mlog_errno(ret);
4603 goto out;
4604 }
4605
4606 el = path_leaf_el(path);
4607
4608 /*
4609 * Now that we have the path, there's two things we want to determine:
4610 * 1) Contiguousness (also set contig_index if this is so)
4611 *
4612 * 2) Are we doing an append? We can trivially break this up
4613 * into two types of appends: simple record append, or a
4614 * rotate inside the tail leaf.
4615 */
4616 ocfs2_figure_contig_type(et, insert, el, insert_rec);
4617
4618 /*
4619 * The insert code isn't quite ready to deal with all cases of
4620 * left contiguousness. Specifically, if it's an insert into
4621 * the 1st record in a leaf, it will require the adjustment of
4622 * cluster count on the last record of the path directly to it's
4623 * left. For now, just catch that case and fool the layers
4624 * above us. This works just fine for tree_depth == 0, which
4625 * is why we allow that above.
4626 */
4627 if (insert->ins_contig == CONTIG_LEFT &&
4628 insert->ins_contig_index == 0)
4629 insert->ins_contig = CONTIG_NONE;
4630
4631 /*
4632 * Ok, so we can simply compare against last_eb to figure out
4633 * whether the path doesn't exist. This will only happen in
4634 * the case that we're doing a tail append, so maybe we can
4635 * take advantage of that information somehow.
4636 */
4637 if (ocfs2_et_get_last_eb_blk(et) ==
4638 path_leaf_bh(path)->b_blocknr) {
4639 /*
4640 * Ok, ocfs2_find_path() returned us the rightmost
4641 * tree path. This might be an appending insert. There are
4642 * two cases:
4643 * 1) We're doing a true append at the tail:
4644 * -This might even be off the end of the leaf
4645 * 2) We're "appending" by rotating in the tail
4646 */
4647 ocfs2_figure_appending_type(insert, el, insert_rec);
4648 }
4649
4650out:
4651 ocfs2_free_path(path);
4652
4653 if (ret == 0)
4654 *last_eb_bh = bh;
4655 else
4656 brelse(bh);
4657 return ret;
4658}
4659
4660/*
4661 * Insert an extent into a btree.
4662 *
4663 * The caller needs to update the owning btree's cluster count.
4664 */
4665int ocfs2_insert_extent(handle_t *handle,
4666 struct ocfs2_extent_tree *et,
4667 u32 cpos,
4668 u64 start_blk,
4669 u32 new_clusters,
4670 u8 flags,
4671 struct ocfs2_alloc_context *meta_ac)
4672{
4673 int status;
4674 int uninitialized_var(free_records);
4675 struct buffer_head *last_eb_bh = NULL;
4676 struct ocfs2_insert_type insert = {0, };
4677 struct ocfs2_extent_rec rec;
4678
4679 trace_ocfs2_insert_extent_start(
4680 (unsigned long long)ocfs2_metadata_cache_owner(et->et_ci),
4681 cpos, new_clusters);
4682
4683 memset(&rec, 0, sizeof(rec));
4684 rec.e_cpos = cpu_to_le32(cpos);
4685 rec.e_blkno = cpu_to_le64(start_blk);
4686 rec.e_leaf_clusters = cpu_to_le16(new_clusters);
4687 rec.e_flags = flags;
4688 status = ocfs2_et_insert_check(et, &rec);
4689 if (status) {
4690 mlog_errno(status);
4691 goto bail;
4692 }
4693
4694 status = ocfs2_figure_insert_type(et, &last_eb_bh, &rec,
4695 &free_records, &insert);
4696 if (status < 0) {
4697 mlog_errno(status);
4698 goto bail;
4699 }
4700
4701 trace_ocfs2_insert_extent(insert.ins_appending, insert.ins_contig,
4702 insert.ins_contig_index, free_records,
4703 insert.ins_tree_depth);
4704
4705 if (insert.ins_contig == CONTIG_NONE && free_records == 0) {
4706 status = ocfs2_grow_tree(handle, et,
4707 &insert.ins_tree_depth, &last_eb_bh,
4708 meta_ac);
4709 if (status) {
4710 mlog_errno(status);
4711 goto bail;
4712 }
4713 }
4714
4715 /* Finally, we can add clusters. This might rotate the tree for us. */
4716 status = ocfs2_do_insert_extent(handle, et, &rec, &insert);
4717 if (status < 0)
4718 mlog_errno(status);
4719 else
4720 ocfs2_et_extent_map_insert(et, &rec);
4721
4722bail:
4723 brelse(last_eb_bh);
4724
4725 return status;
4726}
4727
4728/*
4729 * Allcate and add clusters into the extent b-tree.
4730 * The new clusters(clusters_to_add) will be inserted at logical_offset.
4731 * The extent b-tree's root is specified by et, and
4732 * it is not limited to the file storage. Any extent tree can use this
4733 * function if it implements the proper ocfs2_extent_tree.
4734 */
4735int ocfs2_add_clusters_in_btree(handle_t *handle,
4736 struct ocfs2_extent_tree *et,
4737 u32 *logical_offset,
4738 u32 clusters_to_add,
4739 int mark_unwritten,
4740 struct ocfs2_alloc_context *data_ac,
4741 struct ocfs2_alloc_context *meta_ac,
4742 enum ocfs2_alloc_restarted *reason_ret)
4743{
4744 int status = 0, err = 0;
4745 int need_free = 0;
4746 int free_extents;
4747 enum ocfs2_alloc_restarted reason = RESTART_NONE;
4748 u32 bit_off, num_bits;
4749 u64 block;
4750 u8 flags = 0;
4751 struct ocfs2_super *osb =
4752 OCFS2_SB(ocfs2_metadata_cache_get_super(et->et_ci));
4753
4754 BUG_ON(!clusters_to_add);
4755
4756 if (mark_unwritten)
4757 flags = OCFS2_EXT_UNWRITTEN;
4758
4759 free_extents = ocfs2_num_free_extents(osb, et);
4760 if (free_extents < 0) {
4761 status = free_extents;
4762 mlog_errno(status);
4763 goto leave;
4764 }
4765
4766 /* there are two cases which could cause us to EAGAIN in the
4767 * we-need-more-metadata case:
4768 * 1) we haven't reserved *any*
4769 * 2) we are so fragmented, we've needed to add metadata too
4770 * many times. */
4771 if (!free_extents && !meta_ac) {
4772 err = -1;
4773 status = -EAGAIN;
4774 reason = RESTART_META;
4775 goto leave;
4776 } else if ((!free_extents)
4777 && (ocfs2_alloc_context_bits_left(meta_ac)
4778 < ocfs2_extend_meta_needed(et->et_root_el))) {
4779 err = -2;
4780 status = -EAGAIN;
4781 reason = RESTART_META;
4782 goto leave;
4783 }
4784
4785 status = __ocfs2_claim_clusters(handle, data_ac, 1,
4786 clusters_to_add, &bit_off, &num_bits);
4787 if (status < 0) {
4788 if (status != -ENOSPC)
4789 mlog_errno(status);
4790 goto leave;
4791 }
4792
4793 BUG_ON(num_bits > clusters_to_add);
4794
4795 /* reserve our write early -- insert_extent may update the tree root */
4796 status = ocfs2_et_root_journal_access(handle, et,
4797 OCFS2_JOURNAL_ACCESS_WRITE);
4798 if (status < 0) {
4799 mlog_errno(status);
4800 need_free = 1;
4801 goto bail;
4802 }
4803
4804 block = ocfs2_clusters_to_blocks(osb->sb, bit_off);
4805 trace_ocfs2_add_clusters_in_btree(
4806 (unsigned long long)ocfs2_metadata_cache_owner(et->et_ci),
4807 bit_off, num_bits);
4808 status = ocfs2_insert_extent(handle, et, *logical_offset, block,
4809 num_bits, flags, meta_ac);
4810 if (status < 0) {
4811 mlog_errno(status);
4812 need_free = 1;
4813 goto bail;
4814 }
4815
4816 ocfs2_journal_dirty(handle, et->et_root_bh);
4817
4818 clusters_to_add -= num_bits;
4819 *logical_offset += num_bits;
4820
4821 if (clusters_to_add) {
4822 err = clusters_to_add;
4823 status = -EAGAIN;
4824 reason = RESTART_TRANS;
4825 }
4826
4827bail:
4828 if (need_free) {
4829 if (data_ac->ac_which == OCFS2_AC_USE_LOCAL)
4830 ocfs2_free_local_alloc_bits(osb, handle, data_ac,
4831 bit_off, num_bits);
4832 else
4833 ocfs2_free_clusters(handle,
4834 data_ac->ac_inode,
4835 data_ac->ac_bh,
4836 ocfs2_clusters_to_blocks(osb->sb, bit_off),
4837 num_bits);
4838 }
4839
4840leave:
4841 if (reason_ret)
4842 *reason_ret = reason;
4843 trace_ocfs2_add_clusters_in_btree_ret(status, reason, err);
4844 return status;
4845}
4846
4847static void ocfs2_make_right_split_rec(struct super_block *sb,
4848 struct ocfs2_extent_rec *split_rec,
4849 u32 cpos,
4850 struct ocfs2_extent_rec *rec)
4851{
4852 u32 rec_cpos = le32_to_cpu(rec->e_cpos);
4853 u32 rec_range = rec_cpos + le16_to_cpu(rec->e_leaf_clusters);
4854
4855 memset(split_rec, 0, sizeof(struct ocfs2_extent_rec));
4856
4857 split_rec->e_cpos = cpu_to_le32(cpos);
4858 split_rec->e_leaf_clusters = cpu_to_le16(rec_range - cpos);
4859
4860 split_rec->e_blkno = rec->e_blkno;
4861 le64_add_cpu(&split_rec->e_blkno,
4862 ocfs2_clusters_to_blocks(sb, cpos - rec_cpos));
4863
4864 split_rec->e_flags = rec->e_flags;
4865}
4866
4867static int ocfs2_split_and_insert(handle_t *handle,
4868 struct ocfs2_extent_tree *et,
4869 struct ocfs2_path *path,
4870 struct buffer_head **last_eb_bh,
4871 int split_index,
4872 struct ocfs2_extent_rec *orig_split_rec,
4873 struct ocfs2_alloc_context *meta_ac)
4874{
4875 int ret = 0, depth;
4876 unsigned int insert_range, rec_range, do_leftright = 0;
4877 struct ocfs2_extent_rec tmprec;
4878 struct ocfs2_extent_list *rightmost_el;
4879 struct ocfs2_extent_rec rec;
4880 struct ocfs2_extent_rec split_rec = *orig_split_rec;
4881 struct ocfs2_insert_type insert;
4882 struct ocfs2_extent_block *eb;
4883
4884leftright:
4885 /*
4886 * Store a copy of the record on the stack - it might move
4887 * around as the tree is manipulated below.
4888 */
4889 rec = path_leaf_el(path)->l_recs[split_index];
4890
4891 rightmost_el = et->et_root_el;
4892
4893 depth = le16_to_cpu(rightmost_el->l_tree_depth);
4894 if (depth) {
4895 BUG_ON(!(*last_eb_bh));
4896 eb = (struct ocfs2_extent_block *) (*last_eb_bh)->b_data;
4897 rightmost_el = &eb->h_list;
4898 }
4899
4900 if (le16_to_cpu(rightmost_el->l_next_free_rec) ==
4901 le16_to_cpu(rightmost_el->l_count)) {
4902 ret = ocfs2_grow_tree(handle, et,
4903 &depth, last_eb_bh, meta_ac);
4904 if (ret) {
4905 mlog_errno(ret);
4906 goto out;
4907 }
4908 }
4909
4910 memset(&insert, 0, sizeof(struct ocfs2_insert_type));
4911 insert.ins_appending = APPEND_NONE;
4912 insert.ins_contig = CONTIG_NONE;
4913 insert.ins_tree_depth = depth;
4914
4915 insert_range = le32_to_cpu(split_rec.e_cpos) +
4916 le16_to_cpu(split_rec.e_leaf_clusters);
4917 rec_range = le32_to_cpu(rec.e_cpos) +
4918 le16_to_cpu(rec.e_leaf_clusters);
4919
4920 if (split_rec.e_cpos == rec.e_cpos) {
4921 insert.ins_split = SPLIT_LEFT;
4922 } else if (insert_range == rec_range) {
4923 insert.ins_split = SPLIT_RIGHT;
4924 } else {
4925 /*
4926 * Left/right split. We fake this as a right split
4927 * first and then make a second pass as a left split.
4928 */
4929 insert.ins_split = SPLIT_RIGHT;
4930
4931 ocfs2_make_right_split_rec(ocfs2_metadata_cache_get_super(et->et_ci),
4932 &tmprec, insert_range, &rec);
4933
4934 split_rec = tmprec;
4935
4936 BUG_ON(do_leftright);
4937 do_leftright = 1;
4938 }
4939
4940 ret = ocfs2_do_insert_extent(handle, et, &split_rec, &insert);
4941 if (ret) {
4942 mlog_errno(ret);
4943 goto out;
4944 }
4945
4946 if (do_leftright == 1) {
4947 u32 cpos;
4948 struct ocfs2_extent_list *el;
4949
4950 do_leftright++;
4951 split_rec = *orig_split_rec;
4952
4953 ocfs2_reinit_path(path, 1);
4954
4955 cpos = le32_to_cpu(split_rec.e_cpos);
4956 ret = ocfs2_find_path(et->et_ci, path, cpos);
4957 if (ret) {
4958 mlog_errno(ret);
4959 goto out;
4960 }
4961
4962 el = path_leaf_el(path);
4963 split_index = ocfs2_search_extent_list(el, cpos);
4964 goto leftright;
4965 }
4966out:
4967
4968 return ret;
4969}
4970
4971static int ocfs2_replace_extent_rec(handle_t *handle,
4972 struct ocfs2_extent_tree *et,
4973 struct ocfs2_path *path,
4974 struct ocfs2_extent_list *el,
4975 int split_index,
4976 struct ocfs2_extent_rec *split_rec)
4977{
4978 int ret;
4979
4980 ret = ocfs2_path_bh_journal_access(handle, et->et_ci, path,
4981 path_num_items(path) - 1);
4982 if (ret) {
4983 mlog_errno(ret);
4984 goto out;
4985 }
4986
4987 el->l_recs[split_index] = *split_rec;
4988
4989 ocfs2_journal_dirty(handle, path_leaf_bh(path));
4990out:
4991 return ret;
4992}
4993
4994/*
4995 * Split part or all of the extent record at split_index in the leaf
4996 * pointed to by path. Merge with the contiguous extent record if needed.
4997 *
4998 * Care is taken to handle contiguousness so as to not grow the tree.
4999 *
5000 * meta_ac is not strictly necessary - we only truly need it if growth
5001 * of the tree is required. All other cases will degrade into a less
5002 * optimal tree layout.
5003 *
5004 * last_eb_bh should be the rightmost leaf block for any extent
5005 * btree. Since a split may grow the tree or a merge might shrink it,
5006 * the caller cannot trust the contents of that buffer after this call.
5007 *
5008 * This code is optimized for readability - several passes might be
5009 * made over certain portions of the tree. All of those blocks will
5010 * have been brought into cache (and pinned via the journal), so the
5011 * extra overhead is not expressed in terms of disk reads.
5012 */
5013int ocfs2_split_extent(handle_t *handle,
5014 struct ocfs2_extent_tree *et,
5015 struct ocfs2_path *path,
5016 int split_index,
5017 struct ocfs2_extent_rec *split_rec,
5018 struct ocfs2_alloc_context *meta_ac,
5019 struct ocfs2_cached_dealloc_ctxt *dealloc)
5020{
5021 int ret = 0;
5022 struct ocfs2_extent_list *el = path_leaf_el(path);
5023 struct buffer_head *last_eb_bh = NULL;
5024 struct ocfs2_extent_rec *rec = &el->l_recs[split_index];
5025 struct ocfs2_merge_ctxt ctxt;
5026 struct ocfs2_extent_list *rightmost_el;
5027
5028 if (le32_to_cpu(rec->e_cpos) > le32_to_cpu(split_rec->e_cpos) ||
5029 ((le32_to_cpu(rec->e_cpos) + le16_to_cpu(rec->e_leaf_clusters)) <
5030 (le32_to_cpu(split_rec->e_cpos) + le16_to_cpu(split_rec->e_leaf_clusters)))) {
5031 ret = -EIO;
5032 mlog_errno(ret);
5033 goto out;
5034 }
5035
5036 ctxt.c_contig_type = ocfs2_figure_merge_contig_type(et, path, el,
5037 split_index,
5038 split_rec);
5039
5040 /*
5041 * The core merge / split code wants to know how much room is
5042 * left in this allocation tree, so we pass the
5043 * rightmost extent list.
5044 */
5045 if (path->p_tree_depth) {
5046 struct ocfs2_extent_block *eb;
5047
5048 ret = ocfs2_read_extent_block(et->et_ci,
5049 ocfs2_et_get_last_eb_blk(et),
5050 &last_eb_bh);
5051 if (ret) {
5052 mlog_errno(ret);
5053 goto out;
5054 }
5055
5056 eb = (struct ocfs2_extent_block *) last_eb_bh->b_data;
5057 rightmost_el = &eb->h_list;
5058 } else
5059 rightmost_el = path_root_el(path);
5060
5061 if (rec->e_cpos == split_rec->e_cpos &&
5062 rec->e_leaf_clusters == split_rec->e_leaf_clusters)
5063 ctxt.c_split_covers_rec = 1;
5064 else
5065 ctxt.c_split_covers_rec = 0;
5066
5067 ctxt.c_has_empty_extent = ocfs2_is_empty_extent(&el->l_recs[0]);
5068
5069 trace_ocfs2_split_extent(split_index, ctxt.c_contig_type,
5070 ctxt.c_has_empty_extent,
5071 ctxt.c_split_covers_rec);
5072
5073 if (ctxt.c_contig_type == CONTIG_NONE) {
5074 if (ctxt.c_split_covers_rec)
5075 ret = ocfs2_replace_extent_rec(handle, et, path, el,
5076 split_index, split_rec);
5077 else
5078 ret = ocfs2_split_and_insert(handle, et, path,
5079 &last_eb_bh, split_index,
5080 split_rec, meta_ac);
5081 if (ret)
5082 mlog_errno(ret);
5083 } else {
5084 ret = ocfs2_try_to_merge_extent(handle, et, path,
5085 split_index, split_rec,
5086 dealloc, &ctxt);
5087 if (ret)
5088 mlog_errno(ret);
5089 }
5090
5091out:
5092 brelse(last_eb_bh);
5093 return ret;
5094}
5095
5096/*
5097 * Change the flags of the already-existing extent at cpos for len clusters.
5098 *
5099 * new_flags: the flags we want to set.
5100 * clear_flags: the flags we want to clear.
5101 * phys: the new physical offset we want this new extent starts from.
5102 *
5103 * If the existing extent is larger than the request, initiate a
5104 * split. An attempt will be made at merging with adjacent extents.
5105 *
5106 * The caller is responsible for passing down meta_ac if we'll need it.
5107 */
5108int ocfs2_change_extent_flag(handle_t *handle,
5109 struct ocfs2_extent_tree *et,
5110 u32 cpos, u32 len, u32 phys,
5111 struct ocfs2_alloc_context *meta_ac,
5112 struct ocfs2_cached_dealloc_ctxt *dealloc,
5113 int new_flags, int clear_flags)
5114{
5115 int ret, index;
5116 struct super_block *sb = ocfs2_metadata_cache_get_super(et->et_ci);
5117 u64 start_blkno = ocfs2_clusters_to_blocks(sb, phys);
5118 struct ocfs2_extent_rec split_rec;
5119 struct ocfs2_path *left_path = NULL;
5120 struct ocfs2_extent_list *el;
5121 struct ocfs2_extent_rec *rec;
5122
5123 left_path = ocfs2_new_path_from_et(et);
5124 if (!left_path) {
5125 ret = -ENOMEM;
5126 mlog_errno(ret);
5127 goto out;
5128 }
5129
5130 ret = ocfs2_find_path(et->et_ci, left_path, cpos);
5131 if (ret) {
5132 mlog_errno(ret);
5133 goto out;
5134 }
5135 el = path_leaf_el(left_path);
5136
5137 index = ocfs2_search_extent_list(el, cpos);
5138 if (index == -1 || index >= le16_to_cpu(el->l_next_free_rec)) {
5139 ocfs2_error(sb,
5140 "Owner %llu has an extent at cpos %u which can no "
5141 "longer be found.\n",
5142 (unsigned long long)
5143 ocfs2_metadata_cache_owner(et->et_ci), cpos);
5144 ret = -EROFS;
5145 goto out;
5146 }
5147
5148 ret = -EIO;
5149 rec = &el->l_recs[index];
5150 if (new_flags && (rec->e_flags & new_flags)) {
5151 mlog(ML_ERROR, "Owner %llu tried to set %d flags on an "
5152 "extent that already had them",
5153 (unsigned long long)ocfs2_metadata_cache_owner(et->et_ci),
5154 new_flags);
5155 goto out;
5156 }
5157
5158 if (clear_flags && !(rec->e_flags & clear_flags)) {
5159 mlog(ML_ERROR, "Owner %llu tried to clear %d flags on an "
5160 "extent that didn't have them",
5161 (unsigned long long)ocfs2_metadata_cache_owner(et->et_ci),
5162 clear_flags);
5163 goto out;
5164 }
5165
5166 memset(&split_rec, 0, sizeof(struct ocfs2_extent_rec));
5167 split_rec.e_cpos = cpu_to_le32(cpos);
5168 split_rec.e_leaf_clusters = cpu_to_le16(len);
5169 split_rec.e_blkno = cpu_to_le64(start_blkno);
5170 split_rec.e_flags = rec->e_flags;
5171 if (new_flags)
5172 split_rec.e_flags |= new_flags;
5173 if (clear_flags)
5174 split_rec.e_flags &= ~clear_flags;
5175
5176 ret = ocfs2_split_extent(handle, et, left_path,
5177 index, &split_rec, meta_ac,
5178 dealloc);
5179 if (ret)
5180 mlog_errno(ret);
5181
5182out:
5183 ocfs2_free_path(left_path);
5184 return ret;
5185
5186}
5187
5188/*
5189 * Mark the already-existing extent at cpos as written for len clusters.
5190 * This removes the unwritten extent flag.
5191 *
5192 * If the existing extent is larger than the request, initiate a
5193 * split. An attempt will be made at merging with adjacent extents.
5194 *
5195 * The caller is responsible for passing down meta_ac if we'll need it.
5196 */
5197int ocfs2_mark_extent_written(struct inode *inode,
5198 struct ocfs2_extent_tree *et,
5199 handle_t *handle, u32 cpos, u32 len, u32 phys,
5200 struct ocfs2_alloc_context *meta_ac,
5201 struct ocfs2_cached_dealloc_ctxt *dealloc)
5202{
5203 int ret;
5204
5205 trace_ocfs2_mark_extent_written(
5206 (unsigned long long)OCFS2_I(inode)->ip_blkno,
5207 cpos, len, phys);
5208
5209 if (!ocfs2_writes_unwritten_extents(OCFS2_SB(inode->i_sb))) {
5210 ocfs2_error(inode->i_sb, "Inode %llu has unwritten extents "
5211 "that are being written to, but the feature bit "
5212 "is not set in the super block.",
5213 (unsigned long long)OCFS2_I(inode)->ip_blkno);
5214 ret = -EROFS;
5215 goto out;
5216 }
5217
5218 /*
5219 * XXX: This should be fixed up so that we just re-insert the
5220 * next extent records.
5221 */
5222 ocfs2_et_extent_map_truncate(et, 0);
5223
5224 ret = ocfs2_change_extent_flag(handle, et, cpos,
5225 len, phys, meta_ac, dealloc,
5226 0, OCFS2_EXT_UNWRITTEN);
5227 if (ret)
5228 mlog_errno(ret);
5229
5230out:
5231 return ret;
5232}
5233
5234static int ocfs2_split_tree(handle_t *handle, struct ocfs2_extent_tree *et,
5235 struct ocfs2_path *path,
5236 int index, u32 new_range,
5237 struct ocfs2_alloc_context *meta_ac)
5238{
5239 int ret, depth, credits;
5240 struct buffer_head *last_eb_bh = NULL;
5241 struct ocfs2_extent_block *eb;
5242 struct ocfs2_extent_list *rightmost_el, *el;
5243 struct ocfs2_extent_rec split_rec;
5244 struct ocfs2_extent_rec *rec;
5245 struct ocfs2_insert_type insert;
5246
5247 /*
5248 * Setup the record to split before we grow the tree.
5249 */
5250 el = path_leaf_el(path);
5251 rec = &el->l_recs[index];
5252 ocfs2_make_right_split_rec(ocfs2_metadata_cache_get_super(et->et_ci),
5253 &split_rec, new_range, rec);
5254
5255 depth = path->p_tree_depth;
5256 if (depth > 0) {
5257 ret = ocfs2_read_extent_block(et->et_ci,
5258 ocfs2_et_get_last_eb_blk(et),
5259 &last_eb_bh);
5260 if (ret < 0) {
5261 mlog_errno(ret);
5262 goto out;
5263 }
5264
5265 eb = (struct ocfs2_extent_block *) last_eb_bh->b_data;
5266 rightmost_el = &eb->h_list;
5267 } else
5268 rightmost_el = path_leaf_el(path);
5269
5270 credits = path->p_tree_depth +
5271 ocfs2_extend_meta_needed(et->et_root_el);
5272 ret = ocfs2_extend_trans(handle, credits);
5273 if (ret) {
5274 mlog_errno(ret);
5275 goto out;
5276 }
5277
5278 if (le16_to_cpu(rightmost_el->l_next_free_rec) ==
5279 le16_to_cpu(rightmost_el->l_count)) {
5280 ret = ocfs2_grow_tree(handle, et, &depth, &last_eb_bh,
5281 meta_ac);
5282 if (ret) {
5283 mlog_errno(ret);
5284 goto out;
5285 }
5286 }
5287
5288 memset(&insert, 0, sizeof(struct ocfs2_insert_type));
5289 insert.ins_appending = APPEND_NONE;
5290 insert.ins_contig = CONTIG_NONE;
5291 insert.ins_split = SPLIT_RIGHT;
5292 insert.ins_tree_depth = depth;
5293
5294 ret = ocfs2_do_insert_extent(handle, et, &split_rec, &insert);
5295 if (ret)
5296 mlog_errno(ret);
5297
5298out:
5299 brelse(last_eb_bh);
5300 return ret;
5301}
5302
5303static int ocfs2_truncate_rec(handle_t *handle,
5304 struct ocfs2_extent_tree *et,
5305 struct ocfs2_path *path, int index,
5306 struct ocfs2_cached_dealloc_ctxt *dealloc,
5307 u32 cpos, u32 len)
5308{
5309 int ret;
5310 u32 left_cpos, rec_range, trunc_range;
5311 int wants_rotate = 0, is_rightmost_tree_rec = 0;
5312 struct super_block *sb = ocfs2_metadata_cache_get_super(et->et_ci);
5313 struct ocfs2_path *left_path = NULL;
5314 struct ocfs2_extent_list *el = path_leaf_el(path);
5315 struct ocfs2_extent_rec *rec;
5316 struct ocfs2_extent_block *eb;
5317
5318 if (ocfs2_is_empty_extent(&el->l_recs[0]) && index > 0) {
5319 ret = ocfs2_rotate_tree_left(handle, et, path, dealloc);
5320 if (ret) {
5321 mlog_errno(ret);
5322 goto out;
5323 }
5324
5325 index--;
5326 }
5327
5328 if (index == (le16_to_cpu(el->l_next_free_rec) - 1) &&
5329 path->p_tree_depth) {
5330 /*
5331 * Check whether this is the rightmost tree record. If
5332 * we remove all of this record or part of its right
5333 * edge then an update of the record lengths above it
5334 * will be required.
5335 */
5336 eb = (struct ocfs2_extent_block *)path_leaf_bh(path)->b_data;
5337 if (eb->h_next_leaf_blk == 0)
5338 is_rightmost_tree_rec = 1;
5339 }
5340
5341 rec = &el->l_recs[index];
5342 if (index == 0 && path->p_tree_depth &&
5343 le32_to_cpu(rec->e_cpos) == cpos) {
5344 /*
5345 * Changing the leftmost offset (via partial or whole
5346 * record truncate) of an interior (or rightmost) path
5347 * means we have to update the subtree that is formed
5348 * by this leaf and the one to it's left.
5349 *
5350 * There are two cases we can skip:
5351 * 1) Path is the leftmost one in our btree.
5352 * 2) The leaf is rightmost and will be empty after
5353 * we remove the extent record - the rotate code
5354 * knows how to update the newly formed edge.
5355 */
5356
5357 ret = ocfs2_find_cpos_for_left_leaf(sb, path, &left_cpos);
5358 if (ret) {
5359 mlog_errno(ret);
5360 goto out;
5361 }
5362
5363 if (left_cpos && le16_to_cpu(el->l_next_free_rec) > 1) {
5364 left_path = ocfs2_new_path_from_path(path);
5365 if (!left_path) {
5366 ret = -ENOMEM;
5367 mlog_errno(ret);
5368 goto out;
5369 }
5370
5371 ret = ocfs2_find_path(et->et_ci, left_path,
5372 left_cpos);
5373 if (ret) {
5374 mlog_errno(ret);
5375 goto out;
5376 }
5377 }
5378 }
5379
5380 ret = ocfs2_extend_rotate_transaction(handle, 0,
5381 handle->h_buffer_credits,
5382 path);
5383 if (ret) {
5384 mlog_errno(ret);
5385 goto out;
5386 }
5387
5388 ret = ocfs2_journal_access_path(et->et_ci, handle, path);
5389 if (ret) {
5390 mlog_errno(ret);
5391 goto out;
5392 }
5393
5394 ret = ocfs2_journal_access_path(et->et_ci, handle, left_path);
5395 if (ret) {
5396 mlog_errno(ret);
5397 goto out;
5398 }
5399
5400 rec_range = le32_to_cpu(rec->e_cpos) + ocfs2_rec_clusters(el, rec);
5401 trunc_range = cpos + len;
5402
5403 if (le32_to_cpu(rec->e_cpos) == cpos && rec_range == trunc_range) {
5404 int next_free;
5405
5406 memset(rec, 0, sizeof(*rec));
5407 ocfs2_cleanup_merge(el, index);
5408 wants_rotate = 1;
5409
5410 next_free = le16_to_cpu(el->l_next_free_rec);
5411 if (is_rightmost_tree_rec && next_free > 1) {
5412 /*
5413 * We skip the edge update if this path will
5414 * be deleted by the rotate code.
5415 */
5416 rec = &el->l_recs[next_free - 1];
5417 ocfs2_adjust_rightmost_records(handle, et, path,
5418 rec);
5419 }
5420 } else if (le32_to_cpu(rec->e_cpos) == cpos) {
5421 /* Remove leftmost portion of the record. */
5422 le32_add_cpu(&rec->e_cpos, len);
5423 le64_add_cpu(&rec->e_blkno, ocfs2_clusters_to_blocks(sb, len));
5424 le16_add_cpu(&rec->e_leaf_clusters, -len);
5425 } else if (rec_range == trunc_range) {
5426 /* Remove rightmost portion of the record */
5427 le16_add_cpu(&rec->e_leaf_clusters, -len);
5428 if (is_rightmost_tree_rec)
5429 ocfs2_adjust_rightmost_records(handle, et, path, rec);
5430 } else {
5431 /* Caller should have trapped this. */
5432 mlog(ML_ERROR, "Owner %llu: Invalid record truncate: (%u, %u) "
5433 "(%u, %u)\n",
5434 (unsigned long long)ocfs2_metadata_cache_owner(et->et_ci),
5435 le32_to_cpu(rec->e_cpos),
5436 le16_to_cpu(rec->e_leaf_clusters), cpos, len);
5437 BUG();
5438 }
5439
5440 if (left_path) {
5441 int subtree_index;
5442
5443 subtree_index = ocfs2_find_subtree_root(et, left_path, path);
5444 ocfs2_complete_edge_insert(handle, left_path, path,
5445 subtree_index);
5446 }
5447
5448 ocfs2_journal_dirty(handle, path_leaf_bh(path));
5449
5450 ret = ocfs2_rotate_tree_left(handle, et, path, dealloc);
5451 if (ret) {
5452 mlog_errno(ret);
5453 goto out;
5454 }
5455
5456out:
5457 ocfs2_free_path(left_path);
5458 return ret;
5459}
5460
5461int ocfs2_remove_extent(handle_t *handle,
5462 struct ocfs2_extent_tree *et,
5463 u32 cpos, u32 len,
5464 struct ocfs2_alloc_context *meta_ac,
5465 struct ocfs2_cached_dealloc_ctxt *dealloc)
5466{
5467 int ret, index;
5468 u32 rec_range, trunc_range;
5469 struct ocfs2_extent_rec *rec;
5470 struct ocfs2_extent_list *el;
5471 struct ocfs2_path *path = NULL;
5472
5473 /*
5474 * XXX: Why are we truncating to 0 instead of wherever this
5475 * affects us?
5476 */
5477 ocfs2_et_extent_map_truncate(et, 0);
5478
5479 path = ocfs2_new_path_from_et(et);
5480 if (!path) {
5481 ret = -ENOMEM;
5482 mlog_errno(ret);
5483 goto out;
5484 }
5485
5486 ret = ocfs2_find_path(et->et_ci, path, cpos);
5487 if (ret) {
5488 mlog_errno(ret);
5489 goto out;
5490 }
5491
5492 el = path_leaf_el(path);
5493 index = ocfs2_search_extent_list(el, cpos);
5494 if (index == -1 || index >= le16_to_cpu(el->l_next_free_rec)) {
5495 ocfs2_error(ocfs2_metadata_cache_get_super(et->et_ci),
5496 "Owner %llu has an extent at cpos %u which can no "
5497 "longer be found.\n",
5498 (unsigned long long)ocfs2_metadata_cache_owner(et->et_ci),
5499 cpos);
5500 ret = -EROFS;
5501 goto out;
5502 }
5503
5504 /*
5505 * We have 3 cases of extent removal:
5506 * 1) Range covers the entire extent rec
5507 * 2) Range begins or ends on one edge of the extent rec
5508 * 3) Range is in the middle of the extent rec (no shared edges)
5509 *
5510 * For case 1 we remove the extent rec and left rotate to
5511 * fill the hole.
5512 *
5513 * For case 2 we just shrink the existing extent rec, with a
5514 * tree update if the shrinking edge is also the edge of an
5515 * extent block.
5516 *
5517 * For case 3 we do a right split to turn the extent rec into
5518 * something case 2 can handle.
5519 */
5520 rec = &el->l_recs[index];
5521 rec_range = le32_to_cpu(rec->e_cpos) + ocfs2_rec_clusters(el, rec);
5522 trunc_range = cpos + len;
5523
5524 BUG_ON(cpos < le32_to_cpu(rec->e_cpos) || trunc_range > rec_range);
5525
5526 trace_ocfs2_remove_extent(
5527 (unsigned long long)ocfs2_metadata_cache_owner(et->et_ci),
5528 cpos, len, index, le32_to_cpu(rec->e_cpos),
5529 ocfs2_rec_clusters(el, rec));
5530
5531 if (le32_to_cpu(rec->e_cpos) == cpos || rec_range == trunc_range) {
5532 ret = ocfs2_truncate_rec(handle, et, path, index, dealloc,
5533 cpos, len);
5534 if (ret) {
5535 mlog_errno(ret);
5536 goto out;
5537 }
5538 } else {
5539 ret = ocfs2_split_tree(handle, et, path, index,
5540 trunc_range, meta_ac);
5541 if (ret) {
5542 mlog_errno(ret);
5543 goto out;
5544 }
5545
5546 /*
5547 * The split could have manipulated the tree enough to
5548 * move the record location, so we have to look for it again.
5549 */
5550 ocfs2_reinit_path(path, 1);
5551
5552 ret = ocfs2_find_path(et->et_ci, path, cpos);
5553 if (ret) {
5554 mlog_errno(ret);
5555 goto out;
5556 }
5557
5558 el = path_leaf_el(path);
5559 index = ocfs2_search_extent_list(el, cpos);
5560 if (index == -1 || index >= le16_to_cpu(el->l_next_free_rec)) {
5561 ocfs2_error(ocfs2_metadata_cache_get_super(et->et_ci),
5562 "Owner %llu: split at cpos %u lost record.",
5563 (unsigned long long)ocfs2_metadata_cache_owner(et->et_ci),
5564 cpos);
5565 ret = -EROFS;
5566 goto out;
5567 }
5568
5569 /*
5570 * Double check our values here. If anything is fishy,
5571 * it's easier to catch it at the top level.
5572 */
5573 rec = &el->l_recs[index];
5574 rec_range = le32_to_cpu(rec->e_cpos) +
5575 ocfs2_rec_clusters(el, rec);
5576 if (rec_range != trunc_range) {
5577 ocfs2_error(ocfs2_metadata_cache_get_super(et->et_ci),
5578 "Owner %llu: error after split at cpos %u"
5579 "trunc len %u, existing record is (%u,%u)",
5580 (unsigned long long)ocfs2_metadata_cache_owner(et->et_ci),
5581 cpos, len, le32_to_cpu(rec->e_cpos),
5582 ocfs2_rec_clusters(el, rec));
5583 ret = -EROFS;
5584 goto out;
5585 }
5586
5587 ret = ocfs2_truncate_rec(handle, et, path, index, dealloc,
5588 cpos, len);
5589 if (ret) {
5590 mlog_errno(ret);
5591 goto out;
5592 }
5593 }
5594
5595out:
5596 ocfs2_free_path(path);
5597 return ret;
5598}
5599
5600/*
5601 * ocfs2_reserve_blocks_for_rec_trunc() would look basically the
5602 * same as ocfs2_lock_alloctors(), except for it accepts a blocks
5603 * number to reserve some extra blocks, and it only handles meta
5604 * data allocations.
5605 *
5606 * Currently, only ocfs2_remove_btree_range() uses it for truncating
5607 * and punching holes.
5608 */
5609static int ocfs2_reserve_blocks_for_rec_trunc(struct inode *inode,
5610 struct ocfs2_extent_tree *et,
5611 u32 extents_to_split,
5612 struct ocfs2_alloc_context **ac,
5613 int extra_blocks)
5614{
5615 int ret = 0, num_free_extents;
5616 unsigned int max_recs_needed = 2 * extents_to_split;
5617 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
5618
5619 *ac = NULL;
5620
5621 num_free_extents = ocfs2_num_free_extents(osb, et);
5622 if (num_free_extents < 0) {
5623 ret = num_free_extents;
5624 mlog_errno(ret);
5625 goto out;
5626 }
5627
5628 if (!num_free_extents ||
5629 (ocfs2_sparse_alloc(osb) && num_free_extents < max_recs_needed))
5630 extra_blocks += ocfs2_extend_meta_needed(et->et_root_el);
5631
5632 if (extra_blocks) {
5633 ret = ocfs2_reserve_new_metadata_blocks(osb, extra_blocks, ac);
5634 if (ret < 0) {
5635 if (ret != -ENOSPC)
5636 mlog_errno(ret);
5637 goto out;
5638 }
5639 }
5640
5641out:
5642 if (ret) {
5643 if (*ac) {
5644 ocfs2_free_alloc_context(*ac);
5645 *ac = NULL;
5646 }
5647 }
5648
5649 return ret;
5650}
5651
5652int ocfs2_remove_btree_range(struct inode *inode,
5653 struct ocfs2_extent_tree *et,
5654 u32 cpos, u32 phys_cpos, u32 len, int flags,
5655 struct ocfs2_cached_dealloc_ctxt *dealloc,
5656 u64 refcount_loc)
5657{
5658 int ret, credits = 0, extra_blocks = 0;
5659 u64 phys_blkno = ocfs2_clusters_to_blocks(inode->i_sb, phys_cpos);
5660 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
5661 struct inode *tl_inode = osb->osb_tl_inode;
5662 handle_t *handle;
5663 struct ocfs2_alloc_context *meta_ac = NULL;
5664 struct ocfs2_refcount_tree *ref_tree = NULL;
5665
5666 if ((flags & OCFS2_EXT_REFCOUNTED) && len) {
5667 BUG_ON(!(OCFS2_I(inode)->ip_dyn_features &
5668 OCFS2_HAS_REFCOUNT_FL));
5669
5670 ret = ocfs2_lock_refcount_tree(osb, refcount_loc, 1,
5671 &ref_tree, NULL);
5672 if (ret) {
5673 mlog_errno(ret);
5674 goto bail;
5675 }
5676
5677 ret = ocfs2_prepare_refcount_change_for_del(inode,
5678 refcount_loc,
5679 phys_blkno,
5680 len,
5681 &credits,
5682 &extra_blocks);
5683 if (ret < 0) {
5684 mlog_errno(ret);
5685 goto bail;
5686 }
5687 }
5688
5689 ret = ocfs2_reserve_blocks_for_rec_trunc(inode, et, 1, &meta_ac,
5690 extra_blocks);
5691 if (ret) {
5692 mlog_errno(ret);
5693 goto bail;
5694 }
5695
5696 mutex_lock(&tl_inode->i_mutex);
5697
5698 if (ocfs2_truncate_log_needs_flush(osb)) {
5699 ret = __ocfs2_flush_truncate_log(osb);
5700 if (ret < 0) {
5701 mlog_errno(ret);
5702 goto out;
5703 }
5704 }
5705
5706 handle = ocfs2_start_trans(osb,
5707 ocfs2_remove_extent_credits(osb->sb) + credits);
5708 if (IS_ERR(handle)) {
5709 ret = PTR_ERR(handle);
5710 mlog_errno(ret);
5711 goto out;
5712 }
5713
5714 ret = ocfs2_et_root_journal_access(handle, et,
5715 OCFS2_JOURNAL_ACCESS_WRITE);
5716 if (ret) {
5717 mlog_errno(ret);
5718 goto out_commit;
5719 }
5720
5721 dquot_free_space_nodirty(inode,
5722 ocfs2_clusters_to_bytes(inode->i_sb, len));
5723
5724 ret = ocfs2_remove_extent(handle, et, cpos, len, meta_ac, dealloc);
5725 if (ret) {
5726 mlog_errno(ret);
5727 goto out_commit;
5728 }
5729
5730 ocfs2_et_update_clusters(et, -len);
5731 ocfs2_update_inode_fsync_trans(handle, inode, 1);
5732
5733 ocfs2_journal_dirty(handle, et->et_root_bh);
5734
5735 if (phys_blkno) {
5736 if (flags & OCFS2_EXT_REFCOUNTED)
5737 ret = ocfs2_decrease_refcount(inode, handle,
5738 ocfs2_blocks_to_clusters(osb->sb,
5739 phys_blkno),
5740 len, meta_ac,
5741 dealloc, 1);
5742 else
5743 ret = ocfs2_truncate_log_append(osb, handle,
5744 phys_blkno, len);
5745 if (ret)
5746 mlog_errno(ret);
5747
5748 }
5749
5750out_commit:
5751 ocfs2_commit_trans(osb, handle);
5752out:
5753 mutex_unlock(&tl_inode->i_mutex);
5754bail:
5755 if (meta_ac)
5756 ocfs2_free_alloc_context(meta_ac);
5757
5758 if (ref_tree)
5759 ocfs2_unlock_refcount_tree(osb, ref_tree, 1);
5760
5761 return ret;
5762}
5763
5764int ocfs2_truncate_log_needs_flush(struct ocfs2_super *osb)
5765{
5766 struct buffer_head *tl_bh = osb->osb_tl_bh;
5767 struct ocfs2_dinode *di;
5768 struct ocfs2_truncate_log *tl;
5769
5770 di = (struct ocfs2_dinode *) tl_bh->b_data;
5771 tl = &di->id2.i_dealloc;
5772
5773 mlog_bug_on_msg(le16_to_cpu(tl->tl_used) > le16_to_cpu(tl->tl_count),
5774 "slot %d, invalid truncate log parameters: used = "
5775 "%u, count = %u\n", osb->slot_num,
5776 le16_to_cpu(tl->tl_used), le16_to_cpu(tl->tl_count));
5777 return le16_to_cpu(tl->tl_used) == le16_to_cpu(tl->tl_count);
5778}
5779
5780static int ocfs2_truncate_log_can_coalesce(struct ocfs2_truncate_log *tl,
5781 unsigned int new_start)
5782{
5783 unsigned int tail_index;
5784 unsigned int current_tail;
5785
5786 /* No records, nothing to coalesce */
5787 if (!le16_to_cpu(tl->tl_used))
5788 return 0;
5789
5790 tail_index = le16_to_cpu(tl->tl_used) - 1;
5791 current_tail = le32_to_cpu(tl->tl_recs[tail_index].t_start);
5792 current_tail += le32_to_cpu(tl->tl_recs[tail_index].t_clusters);
5793
5794 return current_tail == new_start;
5795}
5796
5797int ocfs2_truncate_log_append(struct ocfs2_super *osb,
5798 handle_t *handle,
5799 u64 start_blk,
5800 unsigned int num_clusters)
5801{
5802 int status, index;
5803 unsigned int start_cluster, tl_count;
5804 struct inode *tl_inode = osb->osb_tl_inode;
5805 struct buffer_head *tl_bh = osb->osb_tl_bh;
5806 struct ocfs2_dinode *di;
5807 struct ocfs2_truncate_log *tl;
5808
5809 BUG_ON(mutex_trylock(&tl_inode->i_mutex));
5810
5811 start_cluster = ocfs2_blocks_to_clusters(osb->sb, start_blk);
5812
5813 di = (struct ocfs2_dinode *) tl_bh->b_data;
5814
5815 /* tl_bh is loaded from ocfs2_truncate_log_init(). It's validated
5816 * by the underlying call to ocfs2_read_inode_block(), so any
5817 * corruption is a code bug */
5818 BUG_ON(!OCFS2_IS_VALID_DINODE(di));
5819
5820 tl = &di->id2.i_dealloc;
5821 tl_count = le16_to_cpu(tl->tl_count);
5822 mlog_bug_on_msg(tl_count > ocfs2_truncate_recs_per_inode(osb->sb) ||
5823 tl_count == 0,
5824 "Truncate record count on #%llu invalid "
5825 "wanted %u, actual %u\n",
5826 (unsigned long long)OCFS2_I(tl_inode)->ip_blkno,
5827 ocfs2_truncate_recs_per_inode(osb->sb),
5828 le16_to_cpu(tl->tl_count));
5829
5830 /* Caller should have known to flush before calling us. */
5831 index = le16_to_cpu(tl->tl_used);
5832 if (index >= tl_count) {
5833 status = -ENOSPC;
5834 mlog_errno(status);
5835 goto bail;
5836 }
5837
5838 status = ocfs2_journal_access_di(handle, INODE_CACHE(tl_inode), tl_bh,
5839 OCFS2_JOURNAL_ACCESS_WRITE);
5840 if (status < 0) {
5841 mlog_errno(status);
5842 goto bail;
5843 }
5844
5845 trace_ocfs2_truncate_log_append(
5846 (unsigned long long)OCFS2_I(tl_inode)->ip_blkno, index,
5847 start_cluster, num_clusters);
5848 if (ocfs2_truncate_log_can_coalesce(tl, start_cluster)) {
5849 /*
5850 * Move index back to the record we are coalescing with.
5851 * ocfs2_truncate_log_can_coalesce() guarantees nonzero
5852 */
5853 index--;
5854
5855 num_clusters += le32_to_cpu(tl->tl_recs[index].t_clusters);
5856 trace_ocfs2_truncate_log_append(
5857 (unsigned long long)OCFS2_I(tl_inode)->ip_blkno,
5858 index, le32_to_cpu(tl->tl_recs[index].t_start),
5859 num_clusters);
5860 } else {
5861 tl->tl_recs[index].t_start = cpu_to_le32(start_cluster);
5862 tl->tl_used = cpu_to_le16(index + 1);
5863 }
5864 tl->tl_recs[index].t_clusters = cpu_to_le32(num_clusters);
5865
5866 ocfs2_journal_dirty(handle, tl_bh);
5867
5868 osb->truncated_clusters += num_clusters;
5869bail:
5870 return status;
5871}
5872
5873static int ocfs2_replay_truncate_records(struct ocfs2_super *osb,
5874 handle_t *handle,
5875 struct inode *data_alloc_inode,
5876 struct buffer_head *data_alloc_bh)
5877{
5878 int status = 0;
5879 int i;
5880 unsigned int num_clusters;
5881 u64 start_blk;
5882 struct ocfs2_truncate_rec rec;
5883 struct ocfs2_dinode *di;
5884 struct ocfs2_truncate_log *tl;
5885 struct inode *tl_inode = osb->osb_tl_inode;
5886 struct buffer_head *tl_bh = osb->osb_tl_bh;
5887
5888 di = (struct ocfs2_dinode *) tl_bh->b_data;
5889 tl = &di->id2.i_dealloc;
5890 i = le16_to_cpu(tl->tl_used) - 1;
5891 while (i >= 0) {
5892 /* Caller has given us at least enough credits to
5893 * update the truncate log dinode */
5894 status = ocfs2_journal_access_di(handle, INODE_CACHE(tl_inode), tl_bh,
5895 OCFS2_JOURNAL_ACCESS_WRITE);
5896 if (status < 0) {
5897 mlog_errno(status);
5898 goto bail;
5899 }
5900
5901 tl->tl_used = cpu_to_le16(i);
5902
5903 ocfs2_journal_dirty(handle, tl_bh);
5904
5905 /* TODO: Perhaps we can calculate the bulk of the
5906 * credits up front rather than extending like
5907 * this. */
5908 status = ocfs2_extend_trans(handle,
5909 OCFS2_TRUNCATE_LOG_FLUSH_ONE_REC);
5910 if (status < 0) {
5911 mlog_errno(status);
5912 goto bail;
5913 }
5914
5915 rec = tl->tl_recs[i];
5916 start_blk = ocfs2_clusters_to_blocks(data_alloc_inode->i_sb,
5917 le32_to_cpu(rec.t_start));
5918 num_clusters = le32_to_cpu(rec.t_clusters);
5919
5920 /* if start_blk is not set, we ignore the record as
5921 * invalid. */
5922 if (start_blk) {
5923 trace_ocfs2_replay_truncate_records(
5924 (unsigned long long)OCFS2_I(tl_inode)->ip_blkno,
5925 i, le32_to_cpu(rec.t_start), num_clusters);
5926
5927 status = ocfs2_free_clusters(handle, data_alloc_inode,
5928 data_alloc_bh, start_blk,
5929 num_clusters);
5930 if (status < 0) {
5931 mlog_errno(status);
5932 goto bail;
5933 }
5934 }
5935 i--;
5936 }
5937
5938 osb->truncated_clusters = 0;
5939
5940bail:
5941 return status;
5942}
5943
5944/* Expects you to already be holding tl_inode->i_mutex */
5945int __ocfs2_flush_truncate_log(struct ocfs2_super *osb)
5946{
5947 int status;
5948 unsigned int num_to_flush;
5949 handle_t *handle;
5950 struct inode *tl_inode = osb->osb_tl_inode;
5951 struct inode *data_alloc_inode = NULL;
5952 struct buffer_head *tl_bh = osb->osb_tl_bh;
5953 struct buffer_head *data_alloc_bh = NULL;
5954 struct ocfs2_dinode *di;
5955 struct ocfs2_truncate_log *tl;
5956
5957 BUG_ON(mutex_trylock(&tl_inode->i_mutex));
5958
5959 di = (struct ocfs2_dinode *) tl_bh->b_data;
5960
5961 /* tl_bh is loaded from ocfs2_truncate_log_init(). It's validated
5962 * by the underlying call to ocfs2_read_inode_block(), so any
5963 * corruption is a code bug */
5964 BUG_ON(!OCFS2_IS_VALID_DINODE(di));
5965
5966 tl = &di->id2.i_dealloc;
5967 num_to_flush = le16_to_cpu(tl->tl_used);
5968 trace_ocfs2_flush_truncate_log(
5969 (unsigned long long)OCFS2_I(tl_inode)->ip_blkno,
5970 num_to_flush);
5971 if (!num_to_flush) {
5972 status = 0;
5973 goto out;
5974 }
5975
5976 data_alloc_inode = ocfs2_get_system_file_inode(osb,
5977 GLOBAL_BITMAP_SYSTEM_INODE,
5978 OCFS2_INVALID_SLOT);
5979 if (!data_alloc_inode) {
5980 status = -EINVAL;
5981 mlog(ML_ERROR, "Could not get bitmap inode!\n");
5982 goto out;
5983 }
5984
5985 mutex_lock(&data_alloc_inode->i_mutex);
5986
5987 status = ocfs2_inode_lock(data_alloc_inode, &data_alloc_bh, 1);
5988 if (status < 0) {
5989 mlog_errno(status);
5990 goto out_mutex;
5991 }
5992
5993 handle = ocfs2_start_trans(osb, OCFS2_TRUNCATE_LOG_UPDATE);
5994 if (IS_ERR(handle)) {
5995 status = PTR_ERR(handle);
5996 mlog_errno(status);
5997 goto out_unlock;
5998 }
5999
6000 status = ocfs2_replay_truncate_records(osb, handle, data_alloc_inode,
6001 data_alloc_bh);
6002 if (status < 0)
6003 mlog_errno(status);
6004
6005 ocfs2_commit_trans(osb, handle);
6006
6007out_unlock:
6008 brelse(data_alloc_bh);
6009 ocfs2_inode_unlock(data_alloc_inode, 1);
6010
6011out_mutex:
6012 mutex_unlock(&data_alloc_inode->i_mutex);
6013 iput(data_alloc_inode);
6014
6015out:
6016 return status;
6017}
6018
6019int ocfs2_flush_truncate_log(struct ocfs2_super *osb)
6020{
6021 int status;
6022 struct inode *tl_inode = osb->osb_tl_inode;
6023
6024 mutex_lock(&tl_inode->i_mutex);
6025 status = __ocfs2_flush_truncate_log(osb);
6026 mutex_unlock(&tl_inode->i_mutex);
6027
6028 return status;
6029}
6030
6031static void ocfs2_truncate_log_worker(struct work_struct *work)
6032{
6033 int status;
6034 struct ocfs2_super *osb =
6035 container_of(work, struct ocfs2_super,
6036 osb_truncate_log_wq.work);
6037
6038 status = ocfs2_flush_truncate_log(osb);
6039 if (status < 0)
6040 mlog_errno(status);
6041 else
6042 ocfs2_init_steal_slots(osb);
6043}
6044
6045#define OCFS2_TRUNCATE_LOG_FLUSH_INTERVAL (2 * HZ)
6046void ocfs2_schedule_truncate_log_flush(struct ocfs2_super *osb,
6047 int cancel)
6048{
6049 if (osb->osb_tl_inode) {
6050 /* We want to push off log flushes while truncates are
6051 * still running. */
6052 if (cancel)
6053 cancel_delayed_work(&osb->osb_truncate_log_wq);
6054
6055 queue_delayed_work(ocfs2_wq, &osb->osb_truncate_log_wq,
6056 OCFS2_TRUNCATE_LOG_FLUSH_INTERVAL);
6057 }
6058}
6059
6060static int ocfs2_get_truncate_log_info(struct ocfs2_super *osb,
6061 int slot_num,
6062 struct inode **tl_inode,
6063 struct buffer_head **tl_bh)
6064{
6065 int status;
6066 struct inode *inode = NULL;
6067 struct buffer_head *bh = NULL;
6068
6069 inode = ocfs2_get_system_file_inode(osb,
6070 TRUNCATE_LOG_SYSTEM_INODE,
6071 slot_num);
6072 if (!inode) {
6073 status = -EINVAL;
6074 mlog(ML_ERROR, "Could not get load truncate log inode!\n");
6075 goto bail;
6076 }
6077
6078 status = ocfs2_read_inode_block(inode, &bh);
6079 if (status < 0) {
6080 iput(inode);
6081 mlog_errno(status);
6082 goto bail;
6083 }
6084
6085 *tl_inode = inode;
6086 *tl_bh = bh;
6087bail:
6088 return status;
6089}
6090
6091/* called during the 1st stage of node recovery. we stamp a clean
6092 * truncate log and pass back a copy for processing later. if the
6093 * truncate log does not require processing, a *tl_copy is set to
6094 * NULL. */
6095int ocfs2_begin_truncate_log_recovery(struct ocfs2_super *osb,
6096 int slot_num,
6097 struct ocfs2_dinode **tl_copy)
6098{
6099 int status;
6100 struct inode *tl_inode = NULL;
6101 struct buffer_head *tl_bh = NULL;
6102 struct ocfs2_dinode *di;
6103 struct ocfs2_truncate_log *tl;
6104
6105 *tl_copy = NULL;
6106
6107 trace_ocfs2_begin_truncate_log_recovery(slot_num);
6108
6109 status = ocfs2_get_truncate_log_info(osb, slot_num, &tl_inode, &tl_bh);
6110 if (status < 0) {
6111 mlog_errno(status);
6112 goto bail;
6113 }
6114
6115 di = (struct ocfs2_dinode *) tl_bh->b_data;
6116
6117 /* tl_bh is loaded from ocfs2_get_truncate_log_info(). It's
6118 * validated by the underlying call to ocfs2_read_inode_block(),
6119 * so any corruption is a code bug */
6120 BUG_ON(!OCFS2_IS_VALID_DINODE(di));
6121
6122 tl = &di->id2.i_dealloc;
6123 if (le16_to_cpu(tl->tl_used)) {
6124 trace_ocfs2_truncate_log_recovery_num(le16_to_cpu(tl->tl_used));
6125
6126 *tl_copy = kmalloc(tl_bh->b_size, GFP_KERNEL);
6127 if (!(*tl_copy)) {
6128 status = -ENOMEM;
6129 mlog_errno(status);
6130 goto bail;
6131 }
6132
6133 /* Assuming the write-out below goes well, this copy
6134 * will be passed back to recovery for processing. */
6135 memcpy(*tl_copy, tl_bh->b_data, tl_bh->b_size);
6136
6137 /* All we need to do to clear the truncate log is set
6138 * tl_used. */
6139 tl->tl_used = 0;
6140
6141 ocfs2_compute_meta_ecc(osb->sb, tl_bh->b_data, &di->i_check);
6142 status = ocfs2_write_block(osb, tl_bh, INODE_CACHE(tl_inode));
6143 if (status < 0) {
6144 mlog_errno(status);
6145 goto bail;
6146 }
6147 }
6148
6149bail:
6150 if (tl_inode)
6151 iput(tl_inode);
6152 brelse(tl_bh);
6153
6154 if (status < 0 && (*tl_copy)) {
6155 kfree(*tl_copy);
6156 *tl_copy = NULL;
6157 mlog_errno(status);
6158 }
6159
6160 return status;
6161}
6162
6163int ocfs2_complete_truncate_log_recovery(struct ocfs2_super *osb,
6164 struct ocfs2_dinode *tl_copy)
6165{
6166 int status = 0;
6167 int i;
6168 unsigned int clusters, num_recs, start_cluster;
6169 u64 start_blk;
6170 handle_t *handle;
6171 struct inode *tl_inode = osb->osb_tl_inode;
6172 struct ocfs2_truncate_log *tl;
6173
6174 if (OCFS2_I(tl_inode)->ip_blkno == le64_to_cpu(tl_copy->i_blkno)) {
6175 mlog(ML_ERROR, "Asked to recover my own truncate log!\n");
6176 return -EINVAL;
6177 }
6178
6179 tl = &tl_copy->id2.i_dealloc;
6180 num_recs = le16_to_cpu(tl->tl_used);
6181 trace_ocfs2_complete_truncate_log_recovery(
6182 (unsigned long long)le64_to_cpu(tl_copy->i_blkno),
6183 num_recs);
6184
6185 mutex_lock(&tl_inode->i_mutex);
6186 for(i = 0; i < num_recs; i++) {
6187 if (ocfs2_truncate_log_needs_flush(osb)) {
6188 status = __ocfs2_flush_truncate_log(osb);
6189 if (status < 0) {
6190 mlog_errno(status);
6191 goto bail_up;
6192 }
6193 }
6194
6195 handle = ocfs2_start_trans(osb, OCFS2_TRUNCATE_LOG_UPDATE);
6196 if (IS_ERR(handle)) {
6197 status = PTR_ERR(handle);
6198 mlog_errno(status);
6199 goto bail_up;
6200 }
6201
6202 clusters = le32_to_cpu(tl->tl_recs[i].t_clusters);
6203 start_cluster = le32_to_cpu(tl->tl_recs[i].t_start);
6204 start_blk = ocfs2_clusters_to_blocks(osb->sb, start_cluster);
6205
6206 status = ocfs2_truncate_log_append(osb, handle,
6207 start_blk, clusters);
6208 ocfs2_commit_trans(osb, handle);
6209 if (status < 0) {
6210 mlog_errno(status);
6211 goto bail_up;
6212 }
6213 }
6214
6215bail_up:
6216 mutex_unlock(&tl_inode->i_mutex);
6217
6218 return status;
6219}
6220
6221void ocfs2_truncate_log_shutdown(struct ocfs2_super *osb)
6222{
6223 int status;
6224 struct inode *tl_inode = osb->osb_tl_inode;
6225
6226 if (tl_inode) {
6227 cancel_delayed_work(&osb->osb_truncate_log_wq);
6228 flush_workqueue(ocfs2_wq);
6229
6230 status = ocfs2_flush_truncate_log(osb);
6231 if (status < 0)
6232 mlog_errno(status);
6233
6234 brelse(osb->osb_tl_bh);
6235 iput(osb->osb_tl_inode);
6236 }
6237}
6238
6239int ocfs2_truncate_log_init(struct ocfs2_super *osb)
6240{
6241 int status;
6242 struct inode *tl_inode = NULL;
6243 struct buffer_head *tl_bh = NULL;
6244
6245 status = ocfs2_get_truncate_log_info(osb,
6246 osb->slot_num,
6247 &tl_inode,
6248 &tl_bh);
6249 if (status < 0)
6250 mlog_errno(status);
6251
6252 /* ocfs2_truncate_log_shutdown keys on the existence of
6253 * osb->osb_tl_inode so we don't set any of the osb variables
6254 * until we're sure all is well. */
6255 INIT_DELAYED_WORK(&osb->osb_truncate_log_wq,
6256 ocfs2_truncate_log_worker);
6257 osb->osb_tl_bh = tl_bh;
6258 osb->osb_tl_inode = tl_inode;
6259
6260 return status;
6261}
6262
6263/*
6264 * Delayed de-allocation of suballocator blocks.
6265 *
6266 * Some sets of block de-allocations might involve multiple suballocator inodes.
6267 *
6268 * The locking for this can get extremely complicated, especially when
6269 * the suballocator inodes to delete from aren't known until deep
6270 * within an unrelated codepath.
6271 *
6272 * ocfs2_extent_block structures are a good example of this - an inode
6273 * btree could have been grown by any number of nodes each allocating
6274 * out of their own suballoc inode.
6275 *
6276 * These structures allow the delay of block de-allocation until a
6277 * later time, when locking of multiple cluster inodes won't cause
6278 * deadlock.
6279 */
6280
6281/*
6282 * Describe a single bit freed from a suballocator. For the block
6283 * suballocators, it represents one block. For the global cluster
6284 * allocator, it represents some clusters and free_bit indicates
6285 * clusters number.
6286 */
6287struct ocfs2_cached_block_free {
6288 struct ocfs2_cached_block_free *free_next;
6289 u64 free_bg;
6290 u64 free_blk;
6291 unsigned int free_bit;
6292};
6293
6294struct ocfs2_per_slot_free_list {
6295 struct ocfs2_per_slot_free_list *f_next_suballocator;
6296 int f_inode_type;
6297 int f_slot;
6298 struct ocfs2_cached_block_free *f_first;
6299};
6300
6301static int ocfs2_free_cached_blocks(struct ocfs2_super *osb,
6302 int sysfile_type,
6303 int slot,
6304 struct ocfs2_cached_block_free *head)
6305{
6306 int ret;
6307 u64 bg_blkno;
6308 handle_t *handle;
6309 struct inode *inode;
6310 struct buffer_head *di_bh = NULL;
6311 struct ocfs2_cached_block_free *tmp;
6312
6313 inode = ocfs2_get_system_file_inode(osb, sysfile_type, slot);
6314 if (!inode) {
6315 ret = -EINVAL;
6316 mlog_errno(ret);
6317 goto out;
6318 }
6319
6320 mutex_lock(&inode->i_mutex);
6321
6322 ret = ocfs2_inode_lock(inode, &di_bh, 1);
6323 if (ret) {
6324 mlog_errno(ret);
6325 goto out_mutex;
6326 }
6327
6328 handle = ocfs2_start_trans(osb, OCFS2_SUBALLOC_FREE);
6329 if (IS_ERR(handle)) {
6330 ret = PTR_ERR(handle);
6331 mlog_errno(ret);
6332 goto out_unlock;
6333 }
6334
6335 while (head) {
6336 if (head->free_bg)
6337 bg_blkno = head->free_bg;
6338 else
6339 bg_blkno = ocfs2_which_suballoc_group(head->free_blk,
6340 head->free_bit);
6341 trace_ocfs2_free_cached_blocks(
6342 (unsigned long long)head->free_blk, head->free_bit);
6343
6344 ret = ocfs2_free_suballoc_bits(handle, inode, di_bh,
6345 head->free_bit, bg_blkno, 1);
6346 if (ret) {
6347 mlog_errno(ret);
6348 goto out_journal;
6349 }
6350
6351 ret = ocfs2_extend_trans(handle, OCFS2_SUBALLOC_FREE);
6352 if (ret) {
6353 mlog_errno(ret);
6354 goto out_journal;
6355 }
6356
6357 tmp = head;
6358 head = head->free_next;
6359 kfree(tmp);
6360 }
6361
6362out_journal:
6363 ocfs2_commit_trans(osb, handle);
6364
6365out_unlock:
6366 ocfs2_inode_unlock(inode, 1);
6367 brelse(di_bh);
6368out_mutex:
6369 mutex_unlock(&inode->i_mutex);
6370 iput(inode);
6371out:
6372 while(head) {
6373 /* Premature exit may have left some dangling items. */
6374 tmp = head;
6375 head = head->free_next;
6376 kfree(tmp);
6377 }
6378
6379 return ret;
6380}
6381
6382int ocfs2_cache_cluster_dealloc(struct ocfs2_cached_dealloc_ctxt *ctxt,
6383 u64 blkno, unsigned int bit)
6384{
6385 int ret = 0;
6386 struct ocfs2_cached_block_free *item;
6387
6388 item = kzalloc(sizeof(*item), GFP_NOFS);
6389 if (item == NULL) {
6390 ret = -ENOMEM;
6391 mlog_errno(ret);
6392 return ret;
6393 }
6394
6395 trace_ocfs2_cache_cluster_dealloc((unsigned long long)blkno, bit);
6396
6397 item->free_blk = blkno;
6398 item->free_bit = bit;
6399 item->free_next = ctxt->c_global_allocator;
6400
6401 ctxt->c_global_allocator = item;
6402 return ret;
6403}
6404
6405static int ocfs2_free_cached_clusters(struct ocfs2_super *osb,
6406 struct ocfs2_cached_block_free *head)
6407{
6408 struct ocfs2_cached_block_free *tmp;
6409 struct inode *tl_inode = osb->osb_tl_inode;
6410 handle_t *handle;
6411 int ret = 0;
6412
6413 mutex_lock(&tl_inode->i_mutex);
6414
6415 while (head) {
6416 if (ocfs2_truncate_log_needs_flush(osb)) {
6417 ret = __ocfs2_flush_truncate_log(osb);
6418 if (ret < 0) {
6419 mlog_errno(ret);
6420 break;
6421 }
6422 }
6423
6424 handle = ocfs2_start_trans(osb, OCFS2_TRUNCATE_LOG_UPDATE);
6425 if (IS_ERR(handle)) {
6426 ret = PTR_ERR(handle);
6427 mlog_errno(ret);
6428 break;
6429 }
6430
6431 ret = ocfs2_truncate_log_append(osb, handle, head->free_blk,
6432 head->free_bit);
6433
6434 ocfs2_commit_trans(osb, handle);
6435 tmp = head;
6436 head = head->free_next;
6437 kfree(tmp);
6438
6439 if (ret < 0) {
6440 mlog_errno(ret);
6441 break;
6442 }
6443 }
6444
6445 mutex_unlock(&tl_inode->i_mutex);
6446
6447 while (head) {
6448 /* Premature exit may have left some dangling items. */
6449 tmp = head;
6450 head = head->free_next;
6451 kfree(tmp);
6452 }
6453
6454 return ret;
6455}
6456
6457int ocfs2_run_deallocs(struct ocfs2_super *osb,
6458 struct ocfs2_cached_dealloc_ctxt *ctxt)
6459{
6460 int ret = 0, ret2;
6461 struct ocfs2_per_slot_free_list *fl;
6462
6463 if (!ctxt)
6464 return 0;
6465
6466 while (ctxt->c_first_suballocator) {
6467 fl = ctxt->c_first_suballocator;
6468
6469 if (fl->f_first) {
6470 trace_ocfs2_run_deallocs(fl->f_inode_type,
6471 fl->f_slot);
6472 ret2 = ocfs2_free_cached_blocks(osb,
6473 fl->f_inode_type,
6474 fl->f_slot,
6475 fl->f_first);
6476 if (ret2)
6477 mlog_errno(ret2);
6478 if (!ret)
6479 ret = ret2;
6480 }
6481
6482 ctxt->c_first_suballocator = fl->f_next_suballocator;
6483 kfree(fl);
6484 }
6485
6486 if (ctxt->c_global_allocator) {
6487 ret2 = ocfs2_free_cached_clusters(osb,
6488 ctxt->c_global_allocator);
6489 if (ret2)
6490 mlog_errno(ret2);
6491 if (!ret)
6492 ret = ret2;
6493
6494 ctxt->c_global_allocator = NULL;
6495 }
6496
6497 return ret;
6498}
6499
6500static struct ocfs2_per_slot_free_list *
6501ocfs2_find_per_slot_free_list(int type,
6502 int slot,
6503 struct ocfs2_cached_dealloc_ctxt *ctxt)
6504{
6505 struct ocfs2_per_slot_free_list *fl = ctxt->c_first_suballocator;
6506
6507 while (fl) {
6508 if (fl->f_inode_type == type && fl->f_slot == slot)
6509 return fl;
6510
6511 fl = fl->f_next_suballocator;
6512 }
6513
6514 fl = kmalloc(sizeof(*fl), GFP_NOFS);
6515 if (fl) {
6516 fl->f_inode_type = type;
6517 fl->f_slot = slot;
6518 fl->f_first = NULL;
6519 fl->f_next_suballocator = ctxt->c_first_suballocator;
6520
6521 ctxt->c_first_suballocator = fl;
6522 }
6523 return fl;
6524}
6525
6526int ocfs2_cache_block_dealloc(struct ocfs2_cached_dealloc_ctxt *ctxt,
6527 int type, int slot, u64 suballoc,
6528 u64 blkno, unsigned int bit)
6529{
6530 int ret;
6531 struct ocfs2_per_slot_free_list *fl;
6532 struct ocfs2_cached_block_free *item;
6533
6534 fl = ocfs2_find_per_slot_free_list(type, slot, ctxt);
6535 if (fl == NULL) {
6536 ret = -ENOMEM;
6537 mlog_errno(ret);
6538 goto out;
6539 }
6540
6541 item = kzalloc(sizeof(*item), GFP_NOFS);
6542 if (item == NULL) {
6543 ret = -ENOMEM;
6544 mlog_errno(ret);
6545 goto out;
6546 }
6547
6548 trace_ocfs2_cache_block_dealloc(type, slot,
6549 (unsigned long long)suballoc,
6550 (unsigned long long)blkno, bit);
6551
6552 item->free_bg = suballoc;
6553 item->free_blk = blkno;
6554 item->free_bit = bit;
6555 item->free_next = fl->f_first;
6556
6557 fl->f_first = item;
6558
6559 ret = 0;
6560out:
6561 return ret;
6562}
6563
6564static int ocfs2_cache_extent_block_free(struct ocfs2_cached_dealloc_ctxt *ctxt,
6565 struct ocfs2_extent_block *eb)
6566{
6567 return ocfs2_cache_block_dealloc(ctxt, EXTENT_ALLOC_SYSTEM_INODE,
6568 le16_to_cpu(eb->h_suballoc_slot),
6569 le64_to_cpu(eb->h_suballoc_loc),
6570 le64_to_cpu(eb->h_blkno),
6571 le16_to_cpu(eb->h_suballoc_bit));
6572}
6573
6574static int ocfs2_zero_func(handle_t *handle, struct buffer_head *bh)
6575{
6576 set_buffer_uptodate(bh);
6577 mark_buffer_dirty(bh);
6578 return 0;
6579}
6580
6581void ocfs2_map_and_dirty_page(struct inode *inode, handle_t *handle,
6582 unsigned int from, unsigned int to,
6583 struct page *page, int zero, u64 *phys)
6584{
6585 int ret, partial = 0;
6586
6587 ret = ocfs2_map_page_blocks(page, phys, inode, from, to, 0);
6588 if (ret)
6589 mlog_errno(ret);
6590
6591 if (zero)
6592 zero_user_segment(page, from, to);
6593
6594 /*
6595 * Need to set the buffers we zero'd into uptodate
6596 * here if they aren't - ocfs2_map_page_blocks()
6597 * might've skipped some
6598 */
6599 ret = walk_page_buffers(handle, page_buffers(page),
6600 from, to, &partial,
6601 ocfs2_zero_func);
6602 if (ret < 0)
6603 mlog_errno(ret);
6604 else if (ocfs2_should_order_data(inode)) {
6605 ret = ocfs2_jbd2_file_inode(handle, inode);
6606 if (ret < 0)
6607 mlog_errno(ret);
6608 }
6609
6610 if (!partial)
6611 SetPageUptodate(page);
6612
6613 flush_dcache_page(page);
6614}
6615
6616static void ocfs2_zero_cluster_pages(struct inode *inode, loff_t start,
6617 loff_t end, struct page **pages,
6618 int numpages, u64 phys, handle_t *handle)
6619{
6620 int i;
6621 struct page *page;
6622 unsigned int from, to = PAGE_CACHE_SIZE;
6623 struct super_block *sb = inode->i_sb;
6624
6625 BUG_ON(!ocfs2_sparse_alloc(OCFS2_SB(sb)));
6626
6627 if (numpages == 0)
6628 goto out;
6629
6630 to = PAGE_CACHE_SIZE;
6631 for(i = 0; i < numpages; i++) {
6632 page = pages[i];
6633
6634 from = start & (PAGE_CACHE_SIZE - 1);
6635 if ((end >> PAGE_CACHE_SHIFT) == page->index)
6636 to = end & (PAGE_CACHE_SIZE - 1);
6637
6638 BUG_ON(from > PAGE_CACHE_SIZE);
6639 BUG_ON(to > PAGE_CACHE_SIZE);
6640
6641 ocfs2_map_and_dirty_page(inode, handle, from, to, page, 1,
6642 &phys);
6643
6644 start = (page->index + 1) << PAGE_CACHE_SHIFT;
6645 }
6646out:
6647 if (pages)
6648 ocfs2_unlock_and_free_pages(pages, numpages);
6649}
6650
6651int ocfs2_grab_pages(struct inode *inode, loff_t start, loff_t end,
6652 struct page **pages, int *num)
6653{
6654 int numpages, ret = 0;
6655 struct address_space *mapping = inode->i_mapping;
6656 unsigned long index;
6657 loff_t last_page_bytes;
6658
6659 BUG_ON(start > end);
6660
6661 numpages = 0;
6662 last_page_bytes = PAGE_ALIGN(end);
6663 index = start >> PAGE_CACHE_SHIFT;
6664 do {
6665 pages[numpages] = find_or_create_page(mapping, index, GFP_NOFS);
6666 if (!pages[numpages]) {
6667 ret = -ENOMEM;
6668 mlog_errno(ret);
6669 goto out;
6670 }
6671
6672 numpages++;
6673 index++;
6674 } while (index < (last_page_bytes >> PAGE_CACHE_SHIFT));
6675
6676out:
6677 if (ret != 0) {
6678 if (pages)
6679 ocfs2_unlock_and_free_pages(pages, numpages);
6680 numpages = 0;
6681 }
6682
6683 *num = numpages;
6684
6685 return ret;
6686}
6687
6688static int ocfs2_grab_eof_pages(struct inode *inode, loff_t start, loff_t end,
6689 struct page **pages, int *num)
6690{
6691 struct super_block *sb = inode->i_sb;
6692
6693 BUG_ON(start >> OCFS2_SB(sb)->s_clustersize_bits !=
6694 (end - 1) >> OCFS2_SB(sb)->s_clustersize_bits);
6695
6696 return ocfs2_grab_pages(inode, start, end, pages, num);
6697}
6698
6699/*
6700 * Zero the area past i_size but still within an allocated
6701 * cluster. This avoids exposing nonzero data on subsequent file
6702 * extends.
6703 *
6704 * We need to call this before i_size is updated on the inode because
6705 * otherwise block_write_full_page() will skip writeout of pages past
6706 * i_size. The new_i_size parameter is passed for this reason.
6707 */
6708int ocfs2_zero_range_for_truncate(struct inode *inode, handle_t *handle,
6709 u64 range_start, u64 range_end)
6710{
6711 int ret = 0, numpages;
6712 struct page **pages = NULL;
6713 u64 phys;
6714 unsigned int ext_flags;
6715 struct super_block *sb = inode->i_sb;
6716
6717 /*
6718 * File systems which don't support sparse files zero on every
6719 * extend.
6720 */
6721 if (!ocfs2_sparse_alloc(OCFS2_SB(sb)))
6722 return 0;
6723
6724 pages = kcalloc(ocfs2_pages_per_cluster(sb),
6725 sizeof(struct page *), GFP_NOFS);
6726 if (pages == NULL) {
6727 ret = -ENOMEM;
6728 mlog_errno(ret);
6729 goto out;
6730 }
6731
6732 if (range_start == range_end)
6733 goto out;
6734
6735 ret = ocfs2_extent_map_get_blocks(inode,
6736 range_start >> sb->s_blocksize_bits,
6737 &phys, NULL, &ext_flags);
6738 if (ret) {
6739 mlog_errno(ret);
6740 goto out;
6741 }
6742
6743 /*
6744 * Tail is a hole, or is marked unwritten. In either case, we
6745 * can count on read and write to return/push zero's.
6746 */
6747 if (phys == 0 || ext_flags & OCFS2_EXT_UNWRITTEN)
6748 goto out;
6749
6750 ret = ocfs2_grab_eof_pages(inode, range_start, range_end, pages,
6751 &numpages);
6752 if (ret) {
6753 mlog_errno(ret);
6754 goto out;
6755 }
6756
6757 ocfs2_zero_cluster_pages(inode, range_start, range_end, pages,
6758 numpages, phys, handle);
6759
6760 /*
6761 * Initiate writeout of the pages we zero'd here. We don't
6762 * wait on them - the truncate_inode_pages() call later will
6763 * do that for us.
6764 */
6765 ret = filemap_fdatawrite_range(inode->i_mapping, range_start,
6766 range_end - 1);
6767 if (ret)
6768 mlog_errno(ret);
6769
6770out:
6771 kfree(pages);
6772
6773 return ret;
6774}
6775
6776static void ocfs2_zero_dinode_id2_with_xattr(struct inode *inode,
6777 struct ocfs2_dinode *di)
6778{
6779 unsigned int blocksize = 1 << inode->i_sb->s_blocksize_bits;
6780 unsigned int xattrsize = le16_to_cpu(di->i_xattr_inline_size);
6781
6782 if (le16_to_cpu(di->i_dyn_features) & OCFS2_INLINE_XATTR_FL)
6783 memset(&di->id2, 0, blocksize -
6784 offsetof(struct ocfs2_dinode, id2) -
6785 xattrsize);
6786 else
6787 memset(&di->id2, 0, blocksize -
6788 offsetof(struct ocfs2_dinode, id2));
6789}
6790
6791void ocfs2_dinode_new_extent_list(struct inode *inode,
6792 struct ocfs2_dinode *di)
6793{
6794 ocfs2_zero_dinode_id2_with_xattr(inode, di);
6795 di->id2.i_list.l_tree_depth = 0;
6796 di->id2.i_list.l_next_free_rec = 0;
6797 di->id2.i_list.l_count = cpu_to_le16(
6798 ocfs2_extent_recs_per_inode_with_xattr(inode->i_sb, di));
6799}
6800
6801void ocfs2_set_inode_data_inline(struct inode *inode, struct ocfs2_dinode *di)
6802{
6803 struct ocfs2_inode_info *oi = OCFS2_I(inode);
6804 struct ocfs2_inline_data *idata = &di->id2.i_data;
6805
6806 spin_lock(&oi->ip_lock);
6807 oi->ip_dyn_features |= OCFS2_INLINE_DATA_FL;
6808 di->i_dyn_features = cpu_to_le16(oi->ip_dyn_features);
6809 spin_unlock(&oi->ip_lock);
6810
6811 /*
6812 * We clear the entire i_data structure here so that all
6813 * fields can be properly initialized.
6814 */
6815 ocfs2_zero_dinode_id2_with_xattr(inode, di);
6816
6817 idata->id_count = cpu_to_le16(
6818 ocfs2_max_inline_data_with_xattr(inode->i_sb, di));
6819}
6820
6821int ocfs2_convert_inline_data_to_extents(struct inode *inode,
6822 struct buffer_head *di_bh)
6823{
6824 int ret, i, has_data, num_pages = 0;
6825 int need_free = 0;
6826 u32 bit_off, num;
6827 handle_t *handle;
6828 u64 uninitialized_var(block);
6829 struct ocfs2_inode_info *oi = OCFS2_I(inode);
6830 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
6831 struct ocfs2_dinode *di = (struct ocfs2_dinode *)di_bh->b_data;
6832 struct ocfs2_alloc_context *data_ac = NULL;
6833 struct page **pages = NULL;
6834 loff_t end = osb->s_clustersize;
6835 struct ocfs2_extent_tree et;
6836 int did_quota = 0;
6837
6838 has_data = i_size_read(inode) ? 1 : 0;
6839
6840 if (has_data) {
6841 pages = kcalloc(ocfs2_pages_per_cluster(osb->sb),
6842 sizeof(struct page *), GFP_NOFS);
6843 if (pages == NULL) {
6844 ret = -ENOMEM;
6845 mlog_errno(ret);
6846 goto out;
6847 }
6848
6849 ret = ocfs2_reserve_clusters(osb, 1, &data_ac);
6850 if (ret) {
6851 mlog_errno(ret);
6852 goto out;
6853 }
6854 }
6855
6856 handle = ocfs2_start_trans(osb,
6857 ocfs2_inline_to_extents_credits(osb->sb));
6858 if (IS_ERR(handle)) {
6859 ret = PTR_ERR(handle);
6860 mlog_errno(ret);
6861 goto out_unlock;
6862 }
6863
6864 ret = ocfs2_journal_access_di(handle, INODE_CACHE(inode), di_bh,
6865 OCFS2_JOURNAL_ACCESS_WRITE);
6866 if (ret) {
6867 mlog_errno(ret);
6868 goto out_commit;
6869 }
6870
6871 if (has_data) {
6872 unsigned int page_end;
6873 u64 phys;
6874
6875 ret = dquot_alloc_space_nodirty(inode,
6876 ocfs2_clusters_to_bytes(osb->sb, 1));
6877 if (ret)
6878 goto out_commit;
6879 did_quota = 1;
6880
6881 data_ac->ac_resv = &OCFS2_I(inode)->ip_la_data_resv;
6882
6883 ret = ocfs2_claim_clusters(handle, data_ac, 1, &bit_off,
6884 &num);
6885 if (ret) {
6886 mlog_errno(ret);
6887 goto out_commit;
6888 }
6889
6890 /*
6891 * Save two copies, one for insert, and one that can
6892 * be changed by ocfs2_map_and_dirty_page() below.
6893 */
6894 block = phys = ocfs2_clusters_to_blocks(inode->i_sb, bit_off);
6895
6896 /*
6897 * Non sparse file systems zero on extend, so no need
6898 * to do that now.
6899 */
6900 if (!ocfs2_sparse_alloc(osb) &&
6901 PAGE_CACHE_SIZE < osb->s_clustersize)
6902 end = PAGE_CACHE_SIZE;
6903
6904 ret = ocfs2_grab_eof_pages(inode, 0, end, pages, &num_pages);
6905 if (ret) {
6906 mlog_errno(ret);
6907 need_free = 1;
6908 goto out_commit;
6909 }
6910
6911 /*
6912 * This should populate the 1st page for us and mark
6913 * it up to date.
6914 */
6915 ret = ocfs2_read_inline_data(inode, pages[0], di_bh);
6916 if (ret) {
6917 mlog_errno(ret);
6918 need_free = 1;
6919 goto out_commit;
6920 }
6921
6922 page_end = PAGE_CACHE_SIZE;
6923 if (PAGE_CACHE_SIZE > osb->s_clustersize)
6924 page_end = osb->s_clustersize;
6925
6926 for (i = 0; i < num_pages; i++)
6927 ocfs2_map_and_dirty_page(inode, handle, 0, page_end,
6928 pages[i], i > 0, &phys);
6929 }
6930
6931 spin_lock(&oi->ip_lock);
6932 oi->ip_dyn_features &= ~OCFS2_INLINE_DATA_FL;
6933 di->i_dyn_features = cpu_to_le16(oi->ip_dyn_features);
6934 spin_unlock(&oi->ip_lock);
6935
6936 ocfs2_update_inode_fsync_trans(handle, inode, 1);
6937 ocfs2_dinode_new_extent_list(inode, di);
6938
6939 ocfs2_journal_dirty(handle, di_bh);
6940
6941 if (has_data) {
6942 /*
6943 * An error at this point should be extremely rare. If
6944 * this proves to be false, we could always re-build
6945 * the in-inode data from our pages.
6946 */
6947 ocfs2_init_dinode_extent_tree(&et, INODE_CACHE(inode), di_bh);
6948 ret = ocfs2_insert_extent(handle, &et, 0, block, 1, 0, NULL);
6949 if (ret) {
6950 mlog_errno(ret);
6951 need_free = 1;
6952 goto out_commit;
6953 }
6954
6955 inode->i_blocks = ocfs2_inode_sector_count(inode);
6956 }
6957
6958out_commit:
6959 if (ret < 0 && did_quota)
6960 dquot_free_space_nodirty(inode,
6961 ocfs2_clusters_to_bytes(osb->sb, 1));
6962
6963 if (need_free) {
6964 if (data_ac->ac_which == OCFS2_AC_USE_LOCAL)
6965 ocfs2_free_local_alloc_bits(osb, handle, data_ac,
6966 bit_off, num);
6967 else
6968 ocfs2_free_clusters(handle,
6969 data_ac->ac_inode,
6970 data_ac->ac_bh,
6971 ocfs2_clusters_to_blocks(osb->sb, bit_off),
6972 num);
6973 }
6974
6975 ocfs2_commit_trans(osb, handle);
6976
6977out_unlock:
6978 if (data_ac)
6979 ocfs2_free_alloc_context(data_ac);
6980
6981out:
6982 if (pages) {
6983 ocfs2_unlock_and_free_pages(pages, num_pages);
6984 kfree(pages);
6985 }
6986
6987 return ret;
6988}
6989
6990/*
6991 * It is expected, that by the time you call this function,
6992 * inode->i_size and fe->i_size have been adjusted.
6993 *
6994 * WARNING: This will kfree the truncate context
6995 */
6996int ocfs2_commit_truncate(struct ocfs2_super *osb,
6997 struct inode *inode,
6998 struct buffer_head *di_bh)
6999{
7000 int status = 0, i, flags = 0;
7001 u32 new_highest_cpos, range, trunc_cpos, trunc_len, phys_cpos, coff;
7002 u64 blkno = 0;
7003 struct ocfs2_extent_list *el;
7004 struct ocfs2_extent_rec *rec;
7005 struct ocfs2_path *path = NULL;
7006 struct ocfs2_dinode *di = (struct ocfs2_dinode *)di_bh->b_data;
7007 struct ocfs2_extent_list *root_el = &(di->id2.i_list);
7008 u64 refcount_loc = le64_to_cpu(di->i_refcount_loc);
7009 struct ocfs2_extent_tree et;
7010 struct ocfs2_cached_dealloc_ctxt dealloc;
7011
7012 ocfs2_init_dinode_extent_tree(&et, INODE_CACHE(inode), di_bh);
7013 ocfs2_init_dealloc_ctxt(&dealloc);
7014
7015 new_highest_cpos = ocfs2_clusters_for_bytes(osb->sb,
7016 i_size_read(inode));
7017
7018 path = ocfs2_new_path(di_bh, &di->id2.i_list,
7019 ocfs2_journal_access_di);
7020 if (!path) {
7021 status = -ENOMEM;
7022 mlog_errno(status);
7023 goto bail;
7024 }
7025
7026 ocfs2_extent_map_trunc(inode, new_highest_cpos);
7027
7028start:
7029 /*
7030 * Check that we still have allocation to delete.
7031 */
7032 if (OCFS2_I(inode)->ip_clusters == 0) {
7033 status = 0;
7034 goto bail;
7035 }
7036
7037 /*
7038 * Truncate always works against the rightmost tree branch.
7039 */
7040 status = ocfs2_find_path(INODE_CACHE(inode), path, UINT_MAX);
7041 if (status) {
7042 mlog_errno(status);
7043 goto bail;
7044 }
7045
7046 trace_ocfs2_commit_truncate(
7047 (unsigned long long)OCFS2_I(inode)->ip_blkno,
7048 new_highest_cpos,
7049 OCFS2_I(inode)->ip_clusters,
7050 path->p_tree_depth);
7051
7052 /*
7053 * By now, el will point to the extent list on the bottom most
7054 * portion of this tree. Only the tail record is considered in
7055 * each pass.
7056 *
7057 * We handle the following cases, in order:
7058 * - empty extent: delete the remaining branch
7059 * - remove the entire record
7060 * - remove a partial record
7061 * - no record needs to be removed (truncate has completed)
7062 */
7063 el = path_leaf_el(path);
7064 if (le16_to_cpu(el->l_next_free_rec) == 0) {
7065 ocfs2_error(inode->i_sb,
7066 "Inode %llu has empty extent block at %llu\n",
7067 (unsigned long long)OCFS2_I(inode)->ip_blkno,
7068 (unsigned long long)path_leaf_bh(path)->b_blocknr);
7069 status = -EROFS;
7070 goto bail;
7071 }
7072
7073 i = le16_to_cpu(el->l_next_free_rec) - 1;
7074 rec = &el->l_recs[i];
7075 flags = rec->e_flags;
7076 range = le32_to_cpu(rec->e_cpos) + ocfs2_rec_clusters(el, rec);
7077
7078 if (i == 0 && ocfs2_is_empty_extent(rec)) {
7079 /*
7080 * Lower levels depend on this never happening, but it's best
7081 * to check it up here before changing the tree.
7082 */
7083 if (root_el->l_tree_depth && rec->e_int_clusters == 0) {
7084 ocfs2_error(inode->i_sb, "Inode %lu has an empty "
7085 "extent record, depth %u\n", inode->i_ino,
7086 le16_to_cpu(root_el->l_tree_depth));
7087 status = -EROFS;
7088 goto bail;
7089 }
7090 trunc_cpos = le32_to_cpu(rec->e_cpos);
7091 trunc_len = 0;
7092 blkno = 0;
7093 } else if (le32_to_cpu(rec->e_cpos) >= new_highest_cpos) {
7094 /*
7095 * Truncate entire record.
7096 */
7097 trunc_cpos = le32_to_cpu(rec->e_cpos);
7098 trunc_len = ocfs2_rec_clusters(el, rec);
7099 blkno = le64_to_cpu(rec->e_blkno);
7100 } else if (range > new_highest_cpos) {
7101 /*
7102 * Partial truncate. it also should be
7103 * the last truncate we're doing.
7104 */
7105 trunc_cpos = new_highest_cpos;
7106 trunc_len = range - new_highest_cpos;
7107 coff = new_highest_cpos - le32_to_cpu(rec->e_cpos);
7108 blkno = le64_to_cpu(rec->e_blkno) +
7109 ocfs2_clusters_to_blocks(inode->i_sb, coff);
7110 } else {
7111 /*
7112 * Truncate completed, leave happily.
7113 */
7114 status = 0;
7115 goto bail;
7116 }
7117
7118 phys_cpos = ocfs2_blocks_to_clusters(inode->i_sb, blkno);
7119
7120 status = ocfs2_remove_btree_range(inode, &et, trunc_cpos,
7121 phys_cpos, trunc_len, flags, &dealloc,
7122 refcount_loc);
7123 if (status < 0) {
7124 mlog_errno(status);
7125 goto bail;
7126 }
7127
7128 ocfs2_reinit_path(path, 1);
7129
7130 /*
7131 * The check above will catch the case where we've truncated
7132 * away all allocation.
7133 */
7134 goto start;
7135
7136bail:
7137
7138 ocfs2_schedule_truncate_log_flush(osb, 1);
7139
7140 ocfs2_run_deallocs(osb, &dealloc);
7141
7142 ocfs2_free_path(path);
7143
7144 return status;
7145}
7146
7147/*
7148 * 'start' is inclusive, 'end' is not.
7149 */
7150int ocfs2_truncate_inline(struct inode *inode, struct buffer_head *di_bh,
7151 unsigned int start, unsigned int end, int trunc)
7152{
7153 int ret;
7154 unsigned int numbytes;
7155 handle_t *handle;
7156 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
7157 struct ocfs2_dinode *di = (struct ocfs2_dinode *)di_bh->b_data;
7158 struct ocfs2_inline_data *idata = &di->id2.i_data;
7159
7160 if (end > i_size_read(inode))
7161 end = i_size_read(inode);
7162
7163 BUG_ON(start > end);
7164
7165 if (!(OCFS2_I(inode)->ip_dyn_features & OCFS2_INLINE_DATA_FL) ||
7166 !(le16_to_cpu(di->i_dyn_features) & OCFS2_INLINE_DATA_FL) ||
7167 !ocfs2_supports_inline_data(osb)) {
7168 ocfs2_error(inode->i_sb,
7169 "Inline data flags for inode %llu don't agree! "
7170 "Disk: 0x%x, Memory: 0x%x, Superblock: 0x%x\n",
7171 (unsigned long long)OCFS2_I(inode)->ip_blkno,
7172 le16_to_cpu(di->i_dyn_features),
7173 OCFS2_I(inode)->ip_dyn_features,
7174 osb->s_feature_incompat);
7175 ret = -EROFS;
7176 goto out;
7177 }
7178
7179 handle = ocfs2_start_trans(osb, OCFS2_INODE_UPDATE_CREDITS);
7180 if (IS_ERR(handle)) {
7181 ret = PTR_ERR(handle);
7182 mlog_errno(ret);
7183 goto out;
7184 }
7185
7186 ret = ocfs2_journal_access_di(handle, INODE_CACHE(inode), di_bh,
7187 OCFS2_JOURNAL_ACCESS_WRITE);
7188 if (ret) {
7189 mlog_errno(ret);
7190 goto out_commit;
7191 }
7192
7193 numbytes = end - start;
7194 memset(idata->id_data + start, 0, numbytes);
7195
7196 /*
7197 * No need to worry about the data page here - it's been
7198 * truncated already and inline data doesn't need it for
7199 * pushing zero's to disk, so we'll let readpage pick it up
7200 * later.
7201 */
7202 if (trunc) {
7203 i_size_write(inode, start);
7204 di->i_size = cpu_to_le64(start);
7205 }
7206
7207 inode->i_blocks = ocfs2_inode_sector_count(inode);
7208 inode->i_ctime = inode->i_mtime = CURRENT_TIME;
7209
7210 di->i_ctime = di->i_mtime = cpu_to_le64(inode->i_ctime.tv_sec);
7211 di->i_ctime_nsec = di->i_mtime_nsec = cpu_to_le32(inode->i_ctime.tv_nsec);
7212
7213 ocfs2_update_inode_fsync_trans(handle, inode, 1);
7214 ocfs2_journal_dirty(handle, di_bh);
7215
7216out_commit:
7217 ocfs2_commit_trans(osb, handle);
7218
7219out:
7220 return ret;
7221}
7222
7223static int ocfs2_trim_extent(struct super_block *sb,
7224 struct ocfs2_group_desc *gd,
7225 u32 start, u32 count)
7226{
7227 u64 discard, bcount;
7228
7229 bcount = ocfs2_clusters_to_blocks(sb, count);
7230 discard = le64_to_cpu(gd->bg_blkno) +
7231 ocfs2_clusters_to_blocks(sb, start);
7232
7233 trace_ocfs2_trim_extent(sb, (unsigned long long)discard, bcount);
7234
7235 return sb_issue_discard(sb, discard, bcount, GFP_NOFS, 0);
7236}
7237
7238static int ocfs2_trim_group(struct super_block *sb,
7239 struct ocfs2_group_desc *gd,
7240 u32 start, u32 max, u32 minbits)
7241{
7242 int ret = 0, count = 0, next;
7243 void *bitmap = gd->bg_bitmap;
7244
7245 if (le16_to_cpu(gd->bg_free_bits_count) < minbits)
7246 return 0;
7247
7248 trace_ocfs2_trim_group((unsigned long long)le64_to_cpu(gd->bg_blkno),
7249 start, max, minbits);
7250
7251 while (start < max) {
7252 start = ocfs2_find_next_zero_bit(bitmap, max, start);
7253 if (start >= max)
7254 break;
7255 next = ocfs2_find_next_bit(bitmap, max, start);
7256
7257 if ((next - start) >= minbits) {
7258 ret = ocfs2_trim_extent(sb, gd,
7259 start, next - start);
7260 if (ret < 0) {
7261 mlog_errno(ret);
7262 break;
7263 }
7264 count += next - start;
7265 }
7266 start = next + 1;
7267
7268 if (fatal_signal_pending(current)) {
7269 count = -ERESTARTSYS;
7270 break;
7271 }
7272
7273 if ((le16_to_cpu(gd->bg_free_bits_count) - count) < minbits)
7274 break;
7275 }
7276
7277 if (ret < 0)
7278 count = ret;
7279
7280 return count;
7281}
7282
7283int ocfs2_trim_fs(struct super_block *sb, struct fstrim_range *range)
7284{
7285 struct ocfs2_super *osb = OCFS2_SB(sb);
7286 u64 start, len, trimmed, first_group, last_group, group;
7287 int ret, cnt;
7288 u32 first_bit, last_bit, minlen;
7289 struct buffer_head *main_bm_bh = NULL;
7290 struct inode *main_bm_inode = NULL;
7291 struct buffer_head *gd_bh = NULL;
7292 struct ocfs2_dinode *main_bm;
7293 struct ocfs2_group_desc *gd = NULL;
7294
7295 start = range->start >> osb->s_clustersize_bits;
7296 len = range->len >> osb->s_clustersize_bits;
7297 minlen = range->minlen >> osb->s_clustersize_bits;
7298
7299 if (minlen >= osb->bitmap_cpg || range->len < sb->s_blocksize)
7300 return -EINVAL;
7301
7302 main_bm_inode = ocfs2_get_system_file_inode(osb,
7303 GLOBAL_BITMAP_SYSTEM_INODE,
7304 OCFS2_INVALID_SLOT);
7305 if (!main_bm_inode) {
7306 ret = -EIO;
7307 mlog_errno(ret);
7308 goto out;
7309 }
7310
7311 mutex_lock(&main_bm_inode->i_mutex);
7312
7313 ret = ocfs2_inode_lock(main_bm_inode, &main_bm_bh, 0);
7314 if (ret < 0) {
7315 mlog_errno(ret);
7316 goto out_mutex;
7317 }
7318 main_bm = (struct ocfs2_dinode *)main_bm_bh->b_data;
7319
7320 if (start >= le32_to_cpu(main_bm->i_clusters)) {
7321 ret = -EINVAL;
7322 goto out_unlock;
7323 }
7324
7325 len = range->len >> osb->s_clustersize_bits;
7326 if (start + len > le32_to_cpu(main_bm->i_clusters))
7327 len = le32_to_cpu(main_bm->i_clusters) - start;
7328
7329 trace_ocfs2_trim_fs(start, len, minlen);
7330
7331 /* Determine first and last group to examine based on start and len */
7332 first_group = ocfs2_which_cluster_group(main_bm_inode, start);
7333 if (first_group == osb->first_cluster_group_blkno)
7334 first_bit = start;
7335 else
7336 first_bit = start - ocfs2_blocks_to_clusters(sb, first_group);
7337 last_group = ocfs2_which_cluster_group(main_bm_inode, start + len - 1);
7338 last_bit = osb->bitmap_cpg;
7339
7340 trimmed = 0;
7341 for (group = first_group; group <= last_group;) {
7342 if (first_bit + len >= osb->bitmap_cpg)
7343 last_bit = osb->bitmap_cpg;
7344 else
7345 last_bit = first_bit + len;
7346
7347 ret = ocfs2_read_group_descriptor(main_bm_inode,
7348 main_bm, group,
7349 &gd_bh);
7350 if (ret < 0) {
7351 mlog_errno(ret);
7352 break;
7353 }
7354
7355 gd = (struct ocfs2_group_desc *)gd_bh->b_data;
7356 cnt = ocfs2_trim_group(sb, gd, first_bit, last_bit, minlen);
7357 brelse(gd_bh);
7358 gd_bh = NULL;
7359 if (cnt < 0) {
7360 ret = cnt;
7361 mlog_errno(ret);
7362 break;
7363 }
7364
7365 trimmed += cnt;
7366 len -= osb->bitmap_cpg - first_bit;
7367 first_bit = 0;
7368 if (group == osb->first_cluster_group_blkno)
7369 group = ocfs2_clusters_to_blocks(sb, osb->bitmap_cpg);
7370 else
7371 group += ocfs2_clusters_to_blocks(sb, osb->bitmap_cpg);
7372 }
7373 range->len = trimmed * sb->s_blocksize;
7374out_unlock:
7375 ocfs2_inode_unlock(main_bm_inode, 0);
7376 brelse(main_bm_bh);
7377out_mutex:
7378 mutex_unlock(&main_bm_inode->i_mutex);
7379 iput(main_bm_inode);
7380out:
7381 return ret;
7382}
1// SPDX-License-Identifier: GPL-2.0-or-later
2/*
3 * alloc.c
4 *
5 * Extent allocs and frees
6 *
7 * Copyright (C) 2002, 2004 Oracle. All rights reserved.
8 */
9
10#include <linux/fs.h>
11#include <linux/types.h>
12#include <linux/slab.h>
13#include <linux/highmem.h>
14#include <linux/swap.h>
15#include <linux/quotaops.h>
16#include <linux/blkdev.h>
17#include <linux/sched/signal.h>
18
19#include <cluster/masklog.h>
20
21#include "ocfs2.h"
22
23#include "alloc.h"
24#include "aops.h"
25#include "blockcheck.h"
26#include "dlmglue.h"
27#include "extent_map.h"
28#include "inode.h"
29#include "journal.h"
30#include "localalloc.h"
31#include "suballoc.h"
32#include "sysfile.h"
33#include "file.h"
34#include "super.h"
35#include "uptodate.h"
36#include "xattr.h"
37#include "refcounttree.h"
38#include "ocfs2_trace.h"
39
40#include "buffer_head_io.h"
41
42enum ocfs2_contig_type {
43 CONTIG_NONE = 0,
44 CONTIG_LEFT,
45 CONTIG_RIGHT,
46 CONTIG_LEFTRIGHT,
47};
48
49static enum ocfs2_contig_type
50 ocfs2_extent_rec_contig(struct super_block *sb,
51 struct ocfs2_extent_rec *ext,
52 struct ocfs2_extent_rec *insert_rec);
53/*
54 * Operations for a specific extent tree type.
55 *
56 * To implement an on-disk btree (extent tree) type in ocfs2, add
57 * an ocfs2_extent_tree_operations structure and the matching
58 * ocfs2_init_<thingy>_extent_tree() function. That's pretty much it
59 * for the allocation portion of the extent tree.
60 */
61struct ocfs2_extent_tree_operations {
62 /*
63 * last_eb_blk is the block number of the right most leaf extent
64 * block. Most on-disk structures containing an extent tree store
65 * this value for fast access. The ->eo_set_last_eb_blk() and
66 * ->eo_get_last_eb_blk() operations access this value. They are
67 * both required.
68 */
69 void (*eo_set_last_eb_blk)(struct ocfs2_extent_tree *et,
70 u64 blkno);
71 u64 (*eo_get_last_eb_blk)(struct ocfs2_extent_tree *et);
72
73 /*
74 * The on-disk structure usually keeps track of how many total
75 * clusters are stored in this extent tree. This function updates
76 * that value. new_clusters is the delta, and must be
77 * added to the total. Required.
78 */
79 void (*eo_update_clusters)(struct ocfs2_extent_tree *et,
80 u32 new_clusters);
81
82 /*
83 * If this extent tree is supported by an extent map, insert
84 * a record into the map.
85 */
86 void (*eo_extent_map_insert)(struct ocfs2_extent_tree *et,
87 struct ocfs2_extent_rec *rec);
88
89 /*
90 * If this extent tree is supported by an extent map, truncate the
91 * map to clusters,
92 */
93 void (*eo_extent_map_truncate)(struct ocfs2_extent_tree *et,
94 u32 clusters);
95
96 /*
97 * If ->eo_insert_check() exists, it is called before rec is
98 * inserted into the extent tree. It is optional.
99 */
100 int (*eo_insert_check)(struct ocfs2_extent_tree *et,
101 struct ocfs2_extent_rec *rec);
102 int (*eo_sanity_check)(struct ocfs2_extent_tree *et);
103
104 /*
105 * --------------------------------------------------------------
106 * The remaining are internal to ocfs2_extent_tree and don't have
107 * accessor functions
108 */
109
110 /*
111 * ->eo_fill_root_el() takes et->et_object and sets et->et_root_el.
112 * It is required.
113 */
114 void (*eo_fill_root_el)(struct ocfs2_extent_tree *et);
115
116 /*
117 * ->eo_fill_max_leaf_clusters sets et->et_max_leaf_clusters if
118 * it exists. If it does not, et->et_max_leaf_clusters is set
119 * to 0 (unlimited). Optional.
120 */
121 void (*eo_fill_max_leaf_clusters)(struct ocfs2_extent_tree *et);
122
123 /*
124 * ->eo_extent_contig test whether the 2 ocfs2_extent_rec
125 * are contiguous or not. Optional. Don't need to set it if use
126 * ocfs2_extent_rec as the tree leaf.
127 */
128 enum ocfs2_contig_type
129 (*eo_extent_contig)(struct ocfs2_extent_tree *et,
130 struct ocfs2_extent_rec *ext,
131 struct ocfs2_extent_rec *insert_rec);
132};
133
134
135/*
136 * Pre-declare ocfs2_dinode_et_ops so we can use it as a sanity check
137 * in the methods.
138 */
139static u64 ocfs2_dinode_get_last_eb_blk(struct ocfs2_extent_tree *et);
140static void ocfs2_dinode_set_last_eb_blk(struct ocfs2_extent_tree *et,
141 u64 blkno);
142static void ocfs2_dinode_update_clusters(struct ocfs2_extent_tree *et,
143 u32 clusters);
144static void ocfs2_dinode_extent_map_insert(struct ocfs2_extent_tree *et,
145 struct ocfs2_extent_rec *rec);
146static void ocfs2_dinode_extent_map_truncate(struct ocfs2_extent_tree *et,
147 u32 clusters);
148static int ocfs2_dinode_insert_check(struct ocfs2_extent_tree *et,
149 struct ocfs2_extent_rec *rec);
150static int ocfs2_dinode_sanity_check(struct ocfs2_extent_tree *et);
151static void ocfs2_dinode_fill_root_el(struct ocfs2_extent_tree *et);
152
153static int ocfs2_reuse_blk_from_dealloc(handle_t *handle,
154 struct ocfs2_extent_tree *et,
155 struct buffer_head **new_eb_bh,
156 int blk_wanted, int *blk_given);
157static int ocfs2_is_dealloc_empty(struct ocfs2_extent_tree *et);
158
159static const struct ocfs2_extent_tree_operations ocfs2_dinode_et_ops = {
160 .eo_set_last_eb_blk = ocfs2_dinode_set_last_eb_blk,
161 .eo_get_last_eb_blk = ocfs2_dinode_get_last_eb_blk,
162 .eo_update_clusters = ocfs2_dinode_update_clusters,
163 .eo_extent_map_insert = ocfs2_dinode_extent_map_insert,
164 .eo_extent_map_truncate = ocfs2_dinode_extent_map_truncate,
165 .eo_insert_check = ocfs2_dinode_insert_check,
166 .eo_sanity_check = ocfs2_dinode_sanity_check,
167 .eo_fill_root_el = ocfs2_dinode_fill_root_el,
168};
169
170static void ocfs2_dinode_set_last_eb_blk(struct ocfs2_extent_tree *et,
171 u64 blkno)
172{
173 struct ocfs2_dinode *di = et->et_object;
174
175 BUG_ON(et->et_ops != &ocfs2_dinode_et_ops);
176 di->i_last_eb_blk = cpu_to_le64(blkno);
177}
178
179static u64 ocfs2_dinode_get_last_eb_blk(struct ocfs2_extent_tree *et)
180{
181 struct ocfs2_dinode *di = et->et_object;
182
183 BUG_ON(et->et_ops != &ocfs2_dinode_et_ops);
184 return le64_to_cpu(di->i_last_eb_blk);
185}
186
187static void ocfs2_dinode_update_clusters(struct ocfs2_extent_tree *et,
188 u32 clusters)
189{
190 struct ocfs2_inode_info *oi = cache_info_to_inode(et->et_ci);
191 struct ocfs2_dinode *di = et->et_object;
192
193 le32_add_cpu(&di->i_clusters, clusters);
194 spin_lock(&oi->ip_lock);
195 oi->ip_clusters = le32_to_cpu(di->i_clusters);
196 spin_unlock(&oi->ip_lock);
197}
198
199static void ocfs2_dinode_extent_map_insert(struct ocfs2_extent_tree *et,
200 struct ocfs2_extent_rec *rec)
201{
202 struct inode *inode = &cache_info_to_inode(et->et_ci)->vfs_inode;
203
204 ocfs2_extent_map_insert_rec(inode, rec);
205}
206
207static void ocfs2_dinode_extent_map_truncate(struct ocfs2_extent_tree *et,
208 u32 clusters)
209{
210 struct inode *inode = &cache_info_to_inode(et->et_ci)->vfs_inode;
211
212 ocfs2_extent_map_trunc(inode, clusters);
213}
214
215static int ocfs2_dinode_insert_check(struct ocfs2_extent_tree *et,
216 struct ocfs2_extent_rec *rec)
217{
218 struct ocfs2_inode_info *oi = cache_info_to_inode(et->et_ci);
219 struct ocfs2_super *osb = OCFS2_SB(oi->vfs_inode.i_sb);
220
221 BUG_ON(oi->ip_dyn_features & OCFS2_INLINE_DATA_FL);
222 mlog_bug_on_msg(!ocfs2_sparse_alloc(osb) &&
223 (oi->ip_clusters != le32_to_cpu(rec->e_cpos)),
224 "Device %s, asking for sparse allocation: inode %llu, "
225 "cpos %u, clusters %u\n",
226 osb->dev_str,
227 (unsigned long long)oi->ip_blkno,
228 rec->e_cpos, oi->ip_clusters);
229
230 return 0;
231}
232
233static int ocfs2_dinode_sanity_check(struct ocfs2_extent_tree *et)
234{
235 struct ocfs2_dinode *di = et->et_object;
236
237 BUG_ON(et->et_ops != &ocfs2_dinode_et_ops);
238 BUG_ON(!OCFS2_IS_VALID_DINODE(di));
239
240 return 0;
241}
242
243static void ocfs2_dinode_fill_root_el(struct ocfs2_extent_tree *et)
244{
245 struct ocfs2_dinode *di = et->et_object;
246
247 et->et_root_el = &di->id2.i_list;
248}
249
250
251static void ocfs2_xattr_value_fill_root_el(struct ocfs2_extent_tree *et)
252{
253 struct ocfs2_xattr_value_buf *vb = et->et_object;
254
255 et->et_root_el = &vb->vb_xv->xr_list;
256}
257
258static void ocfs2_xattr_value_set_last_eb_blk(struct ocfs2_extent_tree *et,
259 u64 blkno)
260{
261 struct ocfs2_xattr_value_buf *vb = et->et_object;
262
263 vb->vb_xv->xr_last_eb_blk = cpu_to_le64(blkno);
264}
265
266static u64 ocfs2_xattr_value_get_last_eb_blk(struct ocfs2_extent_tree *et)
267{
268 struct ocfs2_xattr_value_buf *vb = et->et_object;
269
270 return le64_to_cpu(vb->vb_xv->xr_last_eb_blk);
271}
272
273static void ocfs2_xattr_value_update_clusters(struct ocfs2_extent_tree *et,
274 u32 clusters)
275{
276 struct ocfs2_xattr_value_buf *vb = et->et_object;
277
278 le32_add_cpu(&vb->vb_xv->xr_clusters, clusters);
279}
280
281static const struct ocfs2_extent_tree_operations ocfs2_xattr_value_et_ops = {
282 .eo_set_last_eb_blk = ocfs2_xattr_value_set_last_eb_blk,
283 .eo_get_last_eb_blk = ocfs2_xattr_value_get_last_eb_blk,
284 .eo_update_clusters = ocfs2_xattr_value_update_clusters,
285 .eo_fill_root_el = ocfs2_xattr_value_fill_root_el,
286};
287
288static void ocfs2_xattr_tree_fill_root_el(struct ocfs2_extent_tree *et)
289{
290 struct ocfs2_xattr_block *xb = et->et_object;
291
292 et->et_root_el = &xb->xb_attrs.xb_root.xt_list;
293}
294
295static void ocfs2_xattr_tree_fill_max_leaf_clusters(struct ocfs2_extent_tree *et)
296{
297 struct super_block *sb = ocfs2_metadata_cache_get_super(et->et_ci);
298 et->et_max_leaf_clusters =
299 ocfs2_clusters_for_bytes(sb, OCFS2_MAX_XATTR_TREE_LEAF_SIZE);
300}
301
302static void ocfs2_xattr_tree_set_last_eb_blk(struct ocfs2_extent_tree *et,
303 u64 blkno)
304{
305 struct ocfs2_xattr_block *xb = et->et_object;
306 struct ocfs2_xattr_tree_root *xt = &xb->xb_attrs.xb_root;
307
308 xt->xt_last_eb_blk = cpu_to_le64(blkno);
309}
310
311static u64 ocfs2_xattr_tree_get_last_eb_blk(struct ocfs2_extent_tree *et)
312{
313 struct ocfs2_xattr_block *xb = et->et_object;
314 struct ocfs2_xattr_tree_root *xt = &xb->xb_attrs.xb_root;
315
316 return le64_to_cpu(xt->xt_last_eb_blk);
317}
318
319static void ocfs2_xattr_tree_update_clusters(struct ocfs2_extent_tree *et,
320 u32 clusters)
321{
322 struct ocfs2_xattr_block *xb = et->et_object;
323
324 le32_add_cpu(&xb->xb_attrs.xb_root.xt_clusters, clusters);
325}
326
327static const struct ocfs2_extent_tree_operations ocfs2_xattr_tree_et_ops = {
328 .eo_set_last_eb_blk = ocfs2_xattr_tree_set_last_eb_blk,
329 .eo_get_last_eb_blk = ocfs2_xattr_tree_get_last_eb_blk,
330 .eo_update_clusters = ocfs2_xattr_tree_update_clusters,
331 .eo_fill_root_el = ocfs2_xattr_tree_fill_root_el,
332 .eo_fill_max_leaf_clusters = ocfs2_xattr_tree_fill_max_leaf_clusters,
333};
334
335static void ocfs2_dx_root_set_last_eb_blk(struct ocfs2_extent_tree *et,
336 u64 blkno)
337{
338 struct ocfs2_dx_root_block *dx_root = et->et_object;
339
340 dx_root->dr_last_eb_blk = cpu_to_le64(blkno);
341}
342
343static u64 ocfs2_dx_root_get_last_eb_blk(struct ocfs2_extent_tree *et)
344{
345 struct ocfs2_dx_root_block *dx_root = et->et_object;
346
347 return le64_to_cpu(dx_root->dr_last_eb_blk);
348}
349
350static void ocfs2_dx_root_update_clusters(struct ocfs2_extent_tree *et,
351 u32 clusters)
352{
353 struct ocfs2_dx_root_block *dx_root = et->et_object;
354
355 le32_add_cpu(&dx_root->dr_clusters, clusters);
356}
357
358static int ocfs2_dx_root_sanity_check(struct ocfs2_extent_tree *et)
359{
360 struct ocfs2_dx_root_block *dx_root = et->et_object;
361
362 BUG_ON(!OCFS2_IS_VALID_DX_ROOT(dx_root));
363
364 return 0;
365}
366
367static void ocfs2_dx_root_fill_root_el(struct ocfs2_extent_tree *et)
368{
369 struct ocfs2_dx_root_block *dx_root = et->et_object;
370
371 et->et_root_el = &dx_root->dr_list;
372}
373
374static const struct ocfs2_extent_tree_operations ocfs2_dx_root_et_ops = {
375 .eo_set_last_eb_blk = ocfs2_dx_root_set_last_eb_blk,
376 .eo_get_last_eb_blk = ocfs2_dx_root_get_last_eb_blk,
377 .eo_update_clusters = ocfs2_dx_root_update_clusters,
378 .eo_sanity_check = ocfs2_dx_root_sanity_check,
379 .eo_fill_root_el = ocfs2_dx_root_fill_root_el,
380};
381
382static void ocfs2_refcount_tree_fill_root_el(struct ocfs2_extent_tree *et)
383{
384 struct ocfs2_refcount_block *rb = et->et_object;
385
386 et->et_root_el = &rb->rf_list;
387}
388
389static void ocfs2_refcount_tree_set_last_eb_blk(struct ocfs2_extent_tree *et,
390 u64 blkno)
391{
392 struct ocfs2_refcount_block *rb = et->et_object;
393
394 rb->rf_last_eb_blk = cpu_to_le64(blkno);
395}
396
397static u64 ocfs2_refcount_tree_get_last_eb_blk(struct ocfs2_extent_tree *et)
398{
399 struct ocfs2_refcount_block *rb = et->et_object;
400
401 return le64_to_cpu(rb->rf_last_eb_blk);
402}
403
404static void ocfs2_refcount_tree_update_clusters(struct ocfs2_extent_tree *et,
405 u32 clusters)
406{
407 struct ocfs2_refcount_block *rb = et->et_object;
408
409 le32_add_cpu(&rb->rf_clusters, clusters);
410}
411
412static enum ocfs2_contig_type
413ocfs2_refcount_tree_extent_contig(struct ocfs2_extent_tree *et,
414 struct ocfs2_extent_rec *ext,
415 struct ocfs2_extent_rec *insert_rec)
416{
417 return CONTIG_NONE;
418}
419
420static const struct ocfs2_extent_tree_operations ocfs2_refcount_tree_et_ops = {
421 .eo_set_last_eb_blk = ocfs2_refcount_tree_set_last_eb_blk,
422 .eo_get_last_eb_blk = ocfs2_refcount_tree_get_last_eb_blk,
423 .eo_update_clusters = ocfs2_refcount_tree_update_clusters,
424 .eo_fill_root_el = ocfs2_refcount_tree_fill_root_el,
425 .eo_extent_contig = ocfs2_refcount_tree_extent_contig,
426};
427
428static void __ocfs2_init_extent_tree(struct ocfs2_extent_tree *et,
429 struct ocfs2_caching_info *ci,
430 struct buffer_head *bh,
431 ocfs2_journal_access_func access,
432 void *obj,
433 const struct ocfs2_extent_tree_operations *ops)
434{
435 et->et_ops = ops;
436 et->et_root_bh = bh;
437 et->et_ci = ci;
438 et->et_root_journal_access = access;
439 if (!obj)
440 obj = (void *)bh->b_data;
441 et->et_object = obj;
442 et->et_dealloc = NULL;
443
444 et->et_ops->eo_fill_root_el(et);
445 if (!et->et_ops->eo_fill_max_leaf_clusters)
446 et->et_max_leaf_clusters = 0;
447 else
448 et->et_ops->eo_fill_max_leaf_clusters(et);
449}
450
451void ocfs2_init_dinode_extent_tree(struct ocfs2_extent_tree *et,
452 struct ocfs2_caching_info *ci,
453 struct buffer_head *bh)
454{
455 __ocfs2_init_extent_tree(et, ci, bh, ocfs2_journal_access_di,
456 NULL, &ocfs2_dinode_et_ops);
457}
458
459void ocfs2_init_xattr_tree_extent_tree(struct ocfs2_extent_tree *et,
460 struct ocfs2_caching_info *ci,
461 struct buffer_head *bh)
462{
463 __ocfs2_init_extent_tree(et, ci, bh, ocfs2_journal_access_xb,
464 NULL, &ocfs2_xattr_tree_et_ops);
465}
466
467void ocfs2_init_xattr_value_extent_tree(struct ocfs2_extent_tree *et,
468 struct ocfs2_caching_info *ci,
469 struct ocfs2_xattr_value_buf *vb)
470{
471 __ocfs2_init_extent_tree(et, ci, vb->vb_bh, vb->vb_access, vb,
472 &ocfs2_xattr_value_et_ops);
473}
474
475void ocfs2_init_dx_root_extent_tree(struct ocfs2_extent_tree *et,
476 struct ocfs2_caching_info *ci,
477 struct buffer_head *bh)
478{
479 __ocfs2_init_extent_tree(et, ci, bh, ocfs2_journal_access_dr,
480 NULL, &ocfs2_dx_root_et_ops);
481}
482
483void ocfs2_init_refcount_extent_tree(struct ocfs2_extent_tree *et,
484 struct ocfs2_caching_info *ci,
485 struct buffer_head *bh)
486{
487 __ocfs2_init_extent_tree(et, ci, bh, ocfs2_journal_access_rb,
488 NULL, &ocfs2_refcount_tree_et_ops);
489}
490
491static inline void ocfs2_et_set_last_eb_blk(struct ocfs2_extent_tree *et,
492 u64 new_last_eb_blk)
493{
494 et->et_ops->eo_set_last_eb_blk(et, new_last_eb_blk);
495}
496
497static inline u64 ocfs2_et_get_last_eb_blk(struct ocfs2_extent_tree *et)
498{
499 return et->et_ops->eo_get_last_eb_blk(et);
500}
501
502static inline void ocfs2_et_update_clusters(struct ocfs2_extent_tree *et,
503 u32 clusters)
504{
505 et->et_ops->eo_update_clusters(et, clusters);
506}
507
508static inline void ocfs2_et_extent_map_insert(struct ocfs2_extent_tree *et,
509 struct ocfs2_extent_rec *rec)
510{
511 if (et->et_ops->eo_extent_map_insert)
512 et->et_ops->eo_extent_map_insert(et, rec);
513}
514
515static inline void ocfs2_et_extent_map_truncate(struct ocfs2_extent_tree *et,
516 u32 clusters)
517{
518 if (et->et_ops->eo_extent_map_truncate)
519 et->et_ops->eo_extent_map_truncate(et, clusters);
520}
521
522static inline int ocfs2_et_root_journal_access(handle_t *handle,
523 struct ocfs2_extent_tree *et,
524 int type)
525{
526 return et->et_root_journal_access(handle, et->et_ci, et->et_root_bh,
527 type);
528}
529
530static inline enum ocfs2_contig_type
531 ocfs2_et_extent_contig(struct ocfs2_extent_tree *et,
532 struct ocfs2_extent_rec *rec,
533 struct ocfs2_extent_rec *insert_rec)
534{
535 if (et->et_ops->eo_extent_contig)
536 return et->et_ops->eo_extent_contig(et, rec, insert_rec);
537
538 return ocfs2_extent_rec_contig(
539 ocfs2_metadata_cache_get_super(et->et_ci),
540 rec, insert_rec);
541}
542
543static inline int ocfs2_et_insert_check(struct ocfs2_extent_tree *et,
544 struct ocfs2_extent_rec *rec)
545{
546 int ret = 0;
547
548 if (et->et_ops->eo_insert_check)
549 ret = et->et_ops->eo_insert_check(et, rec);
550 return ret;
551}
552
553static inline int ocfs2_et_sanity_check(struct ocfs2_extent_tree *et)
554{
555 int ret = 0;
556
557 if (et->et_ops->eo_sanity_check)
558 ret = et->et_ops->eo_sanity_check(et);
559 return ret;
560}
561
562static int ocfs2_cache_extent_block_free(struct ocfs2_cached_dealloc_ctxt *ctxt,
563 struct ocfs2_extent_block *eb);
564static void ocfs2_adjust_rightmost_records(handle_t *handle,
565 struct ocfs2_extent_tree *et,
566 struct ocfs2_path *path,
567 struct ocfs2_extent_rec *insert_rec);
568/*
569 * Reset the actual path elements so that we can re-use the structure
570 * to build another path. Generally, this involves freeing the buffer
571 * heads.
572 */
573void ocfs2_reinit_path(struct ocfs2_path *path, int keep_root)
574{
575 int i, start = 0, depth = 0;
576 struct ocfs2_path_item *node;
577
578 if (keep_root)
579 start = 1;
580
581 for(i = start; i < path_num_items(path); i++) {
582 node = &path->p_node[i];
583
584 brelse(node->bh);
585 node->bh = NULL;
586 node->el = NULL;
587 }
588
589 /*
590 * Tree depth may change during truncate, or insert. If we're
591 * keeping the root extent list, then make sure that our path
592 * structure reflects the proper depth.
593 */
594 if (keep_root)
595 depth = le16_to_cpu(path_root_el(path)->l_tree_depth);
596 else
597 path_root_access(path) = NULL;
598
599 path->p_tree_depth = depth;
600}
601
602void ocfs2_free_path(struct ocfs2_path *path)
603{
604 if (path) {
605 ocfs2_reinit_path(path, 0);
606 kfree(path);
607 }
608}
609
610/*
611 * All the elements of src into dest. After this call, src could be freed
612 * without affecting dest.
613 *
614 * Both paths should have the same root. Any non-root elements of dest
615 * will be freed.
616 */
617static void ocfs2_cp_path(struct ocfs2_path *dest, struct ocfs2_path *src)
618{
619 int i;
620
621 BUG_ON(path_root_bh(dest) != path_root_bh(src));
622 BUG_ON(path_root_el(dest) != path_root_el(src));
623 BUG_ON(path_root_access(dest) != path_root_access(src));
624
625 ocfs2_reinit_path(dest, 1);
626
627 for(i = 1; i < OCFS2_MAX_PATH_DEPTH; i++) {
628 dest->p_node[i].bh = src->p_node[i].bh;
629 dest->p_node[i].el = src->p_node[i].el;
630
631 if (dest->p_node[i].bh)
632 get_bh(dest->p_node[i].bh);
633 }
634}
635
636/*
637 * Make the *dest path the same as src and re-initialize src path to
638 * have a root only.
639 */
640static void ocfs2_mv_path(struct ocfs2_path *dest, struct ocfs2_path *src)
641{
642 int i;
643
644 BUG_ON(path_root_bh(dest) != path_root_bh(src));
645 BUG_ON(path_root_access(dest) != path_root_access(src));
646
647 for(i = 1; i < OCFS2_MAX_PATH_DEPTH; i++) {
648 brelse(dest->p_node[i].bh);
649
650 dest->p_node[i].bh = src->p_node[i].bh;
651 dest->p_node[i].el = src->p_node[i].el;
652
653 src->p_node[i].bh = NULL;
654 src->p_node[i].el = NULL;
655 }
656}
657
658/*
659 * Insert an extent block at given index.
660 *
661 * This will not take an additional reference on eb_bh.
662 */
663static inline void ocfs2_path_insert_eb(struct ocfs2_path *path, int index,
664 struct buffer_head *eb_bh)
665{
666 struct ocfs2_extent_block *eb = (struct ocfs2_extent_block *)eb_bh->b_data;
667
668 /*
669 * Right now, no root bh is an extent block, so this helps
670 * catch code errors with dinode trees. The assertion can be
671 * safely removed if we ever need to insert extent block
672 * structures at the root.
673 */
674 BUG_ON(index == 0);
675
676 path->p_node[index].bh = eb_bh;
677 path->p_node[index].el = &eb->h_list;
678}
679
680static struct ocfs2_path *ocfs2_new_path(struct buffer_head *root_bh,
681 struct ocfs2_extent_list *root_el,
682 ocfs2_journal_access_func access)
683{
684 struct ocfs2_path *path;
685
686 BUG_ON(le16_to_cpu(root_el->l_tree_depth) >= OCFS2_MAX_PATH_DEPTH);
687
688 path = kzalloc(sizeof(*path), GFP_NOFS);
689 if (path) {
690 path->p_tree_depth = le16_to_cpu(root_el->l_tree_depth);
691 get_bh(root_bh);
692 path_root_bh(path) = root_bh;
693 path_root_el(path) = root_el;
694 path_root_access(path) = access;
695 }
696
697 return path;
698}
699
700struct ocfs2_path *ocfs2_new_path_from_path(struct ocfs2_path *path)
701{
702 return ocfs2_new_path(path_root_bh(path), path_root_el(path),
703 path_root_access(path));
704}
705
706struct ocfs2_path *ocfs2_new_path_from_et(struct ocfs2_extent_tree *et)
707{
708 return ocfs2_new_path(et->et_root_bh, et->et_root_el,
709 et->et_root_journal_access);
710}
711
712/*
713 * Journal the buffer at depth idx. All idx>0 are extent_blocks,
714 * otherwise it's the root_access function.
715 *
716 * I don't like the way this function's name looks next to
717 * ocfs2_journal_access_path(), but I don't have a better one.
718 */
719int ocfs2_path_bh_journal_access(handle_t *handle,
720 struct ocfs2_caching_info *ci,
721 struct ocfs2_path *path,
722 int idx)
723{
724 ocfs2_journal_access_func access = path_root_access(path);
725
726 if (!access)
727 access = ocfs2_journal_access;
728
729 if (idx)
730 access = ocfs2_journal_access_eb;
731
732 return access(handle, ci, path->p_node[idx].bh,
733 OCFS2_JOURNAL_ACCESS_WRITE);
734}
735
736/*
737 * Convenience function to journal all components in a path.
738 */
739int ocfs2_journal_access_path(struct ocfs2_caching_info *ci,
740 handle_t *handle,
741 struct ocfs2_path *path)
742{
743 int i, ret = 0;
744
745 if (!path)
746 goto out;
747
748 for(i = 0; i < path_num_items(path); i++) {
749 ret = ocfs2_path_bh_journal_access(handle, ci, path, i);
750 if (ret < 0) {
751 mlog_errno(ret);
752 goto out;
753 }
754 }
755
756out:
757 return ret;
758}
759
760/*
761 * Return the index of the extent record which contains cluster #v_cluster.
762 * -1 is returned if it was not found.
763 *
764 * Should work fine on interior and exterior nodes.
765 */
766int ocfs2_search_extent_list(struct ocfs2_extent_list *el, u32 v_cluster)
767{
768 int ret = -1;
769 int i;
770 struct ocfs2_extent_rec *rec;
771 u32 rec_end, rec_start, clusters;
772
773 for(i = 0; i < le16_to_cpu(el->l_next_free_rec); i++) {
774 rec = &el->l_recs[i];
775
776 rec_start = le32_to_cpu(rec->e_cpos);
777 clusters = ocfs2_rec_clusters(el, rec);
778
779 rec_end = rec_start + clusters;
780
781 if (v_cluster >= rec_start && v_cluster < rec_end) {
782 ret = i;
783 break;
784 }
785 }
786
787 return ret;
788}
789
790/*
791 * NOTE: ocfs2_block_extent_contig(), ocfs2_extents_adjacent() and
792 * ocfs2_extent_rec_contig only work properly against leaf nodes!
793 */
794static int ocfs2_block_extent_contig(struct super_block *sb,
795 struct ocfs2_extent_rec *ext,
796 u64 blkno)
797{
798 u64 blk_end = le64_to_cpu(ext->e_blkno);
799
800 blk_end += ocfs2_clusters_to_blocks(sb,
801 le16_to_cpu(ext->e_leaf_clusters));
802
803 return blkno == blk_end;
804}
805
806static int ocfs2_extents_adjacent(struct ocfs2_extent_rec *left,
807 struct ocfs2_extent_rec *right)
808{
809 u32 left_range;
810
811 left_range = le32_to_cpu(left->e_cpos) +
812 le16_to_cpu(left->e_leaf_clusters);
813
814 return (left_range == le32_to_cpu(right->e_cpos));
815}
816
817static enum ocfs2_contig_type
818 ocfs2_extent_rec_contig(struct super_block *sb,
819 struct ocfs2_extent_rec *ext,
820 struct ocfs2_extent_rec *insert_rec)
821{
822 u64 blkno = le64_to_cpu(insert_rec->e_blkno);
823
824 /*
825 * Refuse to coalesce extent records with different flag
826 * fields - we don't want to mix unwritten extents with user
827 * data.
828 */
829 if (ext->e_flags != insert_rec->e_flags)
830 return CONTIG_NONE;
831
832 if (ocfs2_extents_adjacent(ext, insert_rec) &&
833 ocfs2_block_extent_contig(sb, ext, blkno))
834 return CONTIG_RIGHT;
835
836 blkno = le64_to_cpu(ext->e_blkno);
837 if (ocfs2_extents_adjacent(insert_rec, ext) &&
838 ocfs2_block_extent_contig(sb, insert_rec, blkno))
839 return CONTIG_LEFT;
840
841 return CONTIG_NONE;
842}
843
844/*
845 * NOTE: We can have pretty much any combination of contiguousness and
846 * appending.
847 *
848 * The usefulness of APPEND_TAIL is more in that it lets us know that
849 * we'll have to update the path to that leaf.
850 */
851enum ocfs2_append_type {
852 APPEND_NONE = 0,
853 APPEND_TAIL,
854};
855
856enum ocfs2_split_type {
857 SPLIT_NONE = 0,
858 SPLIT_LEFT,
859 SPLIT_RIGHT,
860};
861
862struct ocfs2_insert_type {
863 enum ocfs2_split_type ins_split;
864 enum ocfs2_append_type ins_appending;
865 enum ocfs2_contig_type ins_contig;
866 int ins_contig_index;
867 int ins_tree_depth;
868};
869
870struct ocfs2_merge_ctxt {
871 enum ocfs2_contig_type c_contig_type;
872 int c_has_empty_extent;
873 int c_split_covers_rec;
874};
875
876static int ocfs2_validate_extent_block(struct super_block *sb,
877 struct buffer_head *bh)
878{
879 int rc;
880 struct ocfs2_extent_block *eb =
881 (struct ocfs2_extent_block *)bh->b_data;
882
883 trace_ocfs2_validate_extent_block((unsigned long long)bh->b_blocknr);
884
885 BUG_ON(!buffer_uptodate(bh));
886
887 /*
888 * If the ecc fails, we return the error but otherwise
889 * leave the filesystem running. We know any error is
890 * local to this block.
891 */
892 rc = ocfs2_validate_meta_ecc(sb, bh->b_data, &eb->h_check);
893 if (rc) {
894 mlog(ML_ERROR, "Checksum failed for extent block %llu\n",
895 (unsigned long long)bh->b_blocknr);
896 return rc;
897 }
898
899 /*
900 * Errors after here are fatal.
901 */
902
903 if (!OCFS2_IS_VALID_EXTENT_BLOCK(eb)) {
904 rc = ocfs2_error(sb,
905 "Extent block #%llu has bad signature %.*s\n",
906 (unsigned long long)bh->b_blocknr, 7,
907 eb->h_signature);
908 goto bail;
909 }
910
911 if (le64_to_cpu(eb->h_blkno) != bh->b_blocknr) {
912 rc = ocfs2_error(sb,
913 "Extent block #%llu has an invalid h_blkno of %llu\n",
914 (unsigned long long)bh->b_blocknr,
915 (unsigned long long)le64_to_cpu(eb->h_blkno));
916 goto bail;
917 }
918
919 if (le32_to_cpu(eb->h_fs_generation) != OCFS2_SB(sb)->fs_generation)
920 rc = ocfs2_error(sb,
921 "Extent block #%llu has an invalid h_fs_generation of #%u\n",
922 (unsigned long long)bh->b_blocknr,
923 le32_to_cpu(eb->h_fs_generation));
924bail:
925 return rc;
926}
927
928int ocfs2_read_extent_block(struct ocfs2_caching_info *ci, u64 eb_blkno,
929 struct buffer_head **bh)
930{
931 int rc;
932 struct buffer_head *tmp = *bh;
933
934 rc = ocfs2_read_block(ci, eb_blkno, &tmp,
935 ocfs2_validate_extent_block);
936
937 /* If ocfs2_read_block() got us a new bh, pass it up. */
938 if (!rc && !*bh)
939 *bh = tmp;
940
941 return rc;
942}
943
944
945/*
946 * How many free extents have we got before we need more meta data?
947 */
948int ocfs2_num_free_extents(struct ocfs2_extent_tree *et)
949{
950 int retval;
951 struct ocfs2_extent_list *el = NULL;
952 struct ocfs2_extent_block *eb;
953 struct buffer_head *eb_bh = NULL;
954 u64 last_eb_blk = 0;
955
956 el = et->et_root_el;
957 last_eb_blk = ocfs2_et_get_last_eb_blk(et);
958
959 if (last_eb_blk) {
960 retval = ocfs2_read_extent_block(et->et_ci, last_eb_blk,
961 &eb_bh);
962 if (retval < 0) {
963 mlog_errno(retval);
964 goto bail;
965 }
966 eb = (struct ocfs2_extent_block *) eb_bh->b_data;
967 el = &eb->h_list;
968 }
969
970 if (el->l_tree_depth != 0) {
971 retval = ocfs2_error(ocfs2_metadata_cache_get_super(et->et_ci),
972 "Owner %llu has leaf extent block %llu with an invalid l_tree_depth of %u\n",
973 (unsigned long long)ocfs2_metadata_cache_owner(et->et_ci),
974 (unsigned long long)last_eb_blk,
975 le16_to_cpu(el->l_tree_depth));
976 goto bail;
977 }
978
979 retval = le16_to_cpu(el->l_count) - le16_to_cpu(el->l_next_free_rec);
980bail:
981 brelse(eb_bh);
982
983 trace_ocfs2_num_free_extents(retval);
984 return retval;
985}
986
987/* expects array to already be allocated
988 *
989 * sets h_signature, h_blkno, h_suballoc_bit, h_suballoc_slot, and
990 * l_count for you
991 */
992static int ocfs2_create_new_meta_bhs(handle_t *handle,
993 struct ocfs2_extent_tree *et,
994 int wanted,
995 struct ocfs2_alloc_context *meta_ac,
996 struct buffer_head *bhs[])
997{
998 int count, status, i;
999 u16 suballoc_bit_start;
1000 u32 num_got;
1001 u64 suballoc_loc, first_blkno;
1002 struct ocfs2_super *osb =
1003 OCFS2_SB(ocfs2_metadata_cache_get_super(et->et_ci));
1004 struct ocfs2_extent_block *eb;
1005
1006 count = 0;
1007 while (count < wanted) {
1008 status = ocfs2_claim_metadata(handle,
1009 meta_ac,
1010 wanted - count,
1011 &suballoc_loc,
1012 &suballoc_bit_start,
1013 &num_got,
1014 &first_blkno);
1015 if (status < 0) {
1016 mlog_errno(status);
1017 goto bail;
1018 }
1019
1020 for(i = count; i < (num_got + count); i++) {
1021 bhs[i] = sb_getblk(osb->sb, first_blkno);
1022 if (bhs[i] == NULL) {
1023 status = -ENOMEM;
1024 mlog_errno(status);
1025 goto bail;
1026 }
1027 ocfs2_set_new_buffer_uptodate(et->et_ci, bhs[i]);
1028
1029 status = ocfs2_journal_access_eb(handle, et->et_ci,
1030 bhs[i],
1031 OCFS2_JOURNAL_ACCESS_CREATE);
1032 if (status < 0) {
1033 mlog_errno(status);
1034 goto bail;
1035 }
1036
1037 memset(bhs[i]->b_data, 0, osb->sb->s_blocksize);
1038 eb = (struct ocfs2_extent_block *) bhs[i]->b_data;
1039 /* Ok, setup the minimal stuff here. */
1040 strcpy(eb->h_signature, OCFS2_EXTENT_BLOCK_SIGNATURE);
1041 eb->h_blkno = cpu_to_le64(first_blkno);
1042 eb->h_fs_generation = cpu_to_le32(osb->fs_generation);
1043 eb->h_suballoc_slot =
1044 cpu_to_le16(meta_ac->ac_alloc_slot);
1045 eb->h_suballoc_loc = cpu_to_le64(suballoc_loc);
1046 eb->h_suballoc_bit = cpu_to_le16(suballoc_bit_start);
1047 eb->h_list.l_count =
1048 cpu_to_le16(ocfs2_extent_recs_per_eb(osb->sb));
1049
1050 suballoc_bit_start++;
1051 first_blkno++;
1052
1053 /* We'll also be dirtied by the caller, so
1054 * this isn't absolutely necessary. */
1055 ocfs2_journal_dirty(handle, bhs[i]);
1056 }
1057
1058 count += num_got;
1059 }
1060
1061 status = 0;
1062bail:
1063 if (status < 0) {
1064 for(i = 0; i < wanted; i++) {
1065 brelse(bhs[i]);
1066 bhs[i] = NULL;
1067 }
1068 }
1069 return status;
1070}
1071
1072/*
1073 * Helper function for ocfs2_add_branch() and ocfs2_shift_tree_depth().
1074 *
1075 * Returns the sum of the rightmost extent rec logical offset and
1076 * cluster count.
1077 *
1078 * ocfs2_add_branch() uses this to determine what logical cluster
1079 * value should be populated into the leftmost new branch records.
1080 *
1081 * ocfs2_shift_tree_depth() uses this to determine the # clusters
1082 * value for the new topmost tree record.
1083 */
1084static inline u32 ocfs2_sum_rightmost_rec(struct ocfs2_extent_list *el)
1085{
1086 int i;
1087
1088 i = le16_to_cpu(el->l_next_free_rec) - 1;
1089
1090 return le32_to_cpu(el->l_recs[i].e_cpos) +
1091 ocfs2_rec_clusters(el, &el->l_recs[i]);
1092}
1093
1094/*
1095 * Change range of the branches in the right most path according to the leaf
1096 * extent block's rightmost record.
1097 */
1098static int ocfs2_adjust_rightmost_branch(handle_t *handle,
1099 struct ocfs2_extent_tree *et)
1100{
1101 int status;
1102 struct ocfs2_path *path = NULL;
1103 struct ocfs2_extent_list *el;
1104 struct ocfs2_extent_rec *rec;
1105
1106 path = ocfs2_new_path_from_et(et);
1107 if (!path) {
1108 status = -ENOMEM;
1109 return status;
1110 }
1111
1112 status = ocfs2_find_path(et->et_ci, path, UINT_MAX);
1113 if (status < 0) {
1114 mlog_errno(status);
1115 goto out;
1116 }
1117
1118 status = ocfs2_extend_trans(handle, path_num_items(path));
1119 if (status < 0) {
1120 mlog_errno(status);
1121 goto out;
1122 }
1123
1124 status = ocfs2_journal_access_path(et->et_ci, handle, path);
1125 if (status < 0) {
1126 mlog_errno(status);
1127 goto out;
1128 }
1129
1130 el = path_leaf_el(path);
1131 rec = &el->l_recs[le16_to_cpu(el->l_next_free_rec) - 1];
1132
1133 ocfs2_adjust_rightmost_records(handle, et, path, rec);
1134
1135out:
1136 ocfs2_free_path(path);
1137 return status;
1138}
1139
1140/*
1141 * Add an entire tree branch to our inode. eb_bh is the extent block
1142 * to start at, if we don't want to start the branch at the root
1143 * structure.
1144 *
1145 * last_eb_bh is required as we have to update it's next_leaf pointer
1146 * for the new last extent block.
1147 *
1148 * the new branch will be 'empty' in the sense that every block will
1149 * contain a single record with cluster count == 0.
1150 */
1151static int ocfs2_add_branch(handle_t *handle,
1152 struct ocfs2_extent_tree *et,
1153 struct buffer_head *eb_bh,
1154 struct buffer_head **last_eb_bh,
1155 struct ocfs2_alloc_context *meta_ac)
1156{
1157 int status, new_blocks, i, block_given = 0;
1158 u64 next_blkno, new_last_eb_blk;
1159 struct buffer_head *bh;
1160 struct buffer_head **new_eb_bhs = NULL;
1161 struct ocfs2_extent_block *eb;
1162 struct ocfs2_extent_list *eb_el;
1163 struct ocfs2_extent_list *el;
1164 u32 new_cpos, root_end;
1165
1166 BUG_ON(!last_eb_bh || !*last_eb_bh);
1167
1168 if (eb_bh) {
1169 eb = (struct ocfs2_extent_block *) eb_bh->b_data;
1170 el = &eb->h_list;
1171 } else
1172 el = et->et_root_el;
1173
1174 /* we never add a branch to a leaf. */
1175 BUG_ON(!el->l_tree_depth);
1176
1177 new_blocks = le16_to_cpu(el->l_tree_depth);
1178
1179 eb = (struct ocfs2_extent_block *)(*last_eb_bh)->b_data;
1180 new_cpos = ocfs2_sum_rightmost_rec(&eb->h_list);
1181 root_end = ocfs2_sum_rightmost_rec(et->et_root_el);
1182
1183 /*
1184 * If there is a gap before the root end and the real end
1185 * of the righmost leaf block, we need to remove the gap
1186 * between new_cpos and root_end first so that the tree
1187 * is consistent after we add a new branch(it will start
1188 * from new_cpos).
1189 */
1190 if (root_end > new_cpos) {
1191 trace_ocfs2_adjust_rightmost_branch(
1192 (unsigned long long)
1193 ocfs2_metadata_cache_owner(et->et_ci),
1194 root_end, new_cpos);
1195
1196 status = ocfs2_adjust_rightmost_branch(handle, et);
1197 if (status) {
1198 mlog_errno(status);
1199 goto bail;
1200 }
1201 }
1202
1203 /* allocate the number of new eb blocks we need */
1204 new_eb_bhs = kcalloc(new_blocks, sizeof(struct buffer_head *),
1205 GFP_KERNEL);
1206 if (!new_eb_bhs) {
1207 status = -ENOMEM;
1208 mlog_errno(status);
1209 goto bail;
1210 }
1211
1212 /* Firstyly, try to reuse dealloc since we have already estimated how
1213 * many extent blocks we may use.
1214 */
1215 if (!ocfs2_is_dealloc_empty(et)) {
1216 status = ocfs2_reuse_blk_from_dealloc(handle, et,
1217 new_eb_bhs, new_blocks,
1218 &block_given);
1219 if (status < 0) {
1220 mlog_errno(status);
1221 goto bail;
1222 }
1223 }
1224
1225 BUG_ON(block_given > new_blocks);
1226
1227 if (block_given < new_blocks) {
1228 BUG_ON(!meta_ac);
1229 status = ocfs2_create_new_meta_bhs(handle, et,
1230 new_blocks - block_given,
1231 meta_ac,
1232 &new_eb_bhs[block_given]);
1233 if (status < 0) {
1234 mlog_errno(status);
1235 goto bail;
1236 }
1237 }
1238
1239 /* Note: new_eb_bhs[new_blocks - 1] is the guy which will be
1240 * linked with the rest of the tree.
1241 * conversly, new_eb_bhs[0] is the new bottommost leaf.
1242 *
1243 * when we leave the loop, new_last_eb_blk will point to the
1244 * newest leaf, and next_blkno will point to the topmost extent
1245 * block. */
1246 next_blkno = new_last_eb_blk = 0;
1247 for(i = 0; i < new_blocks; i++) {
1248 bh = new_eb_bhs[i];
1249 eb = (struct ocfs2_extent_block *) bh->b_data;
1250 /* ocfs2_create_new_meta_bhs() should create it right! */
1251 BUG_ON(!OCFS2_IS_VALID_EXTENT_BLOCK(eb));
1252 eb_el = &eb->h_list;
1253
1254 status = ocfs2_journal_access_eb(handle, et->et_ci, bh,
1255 OCFS2_JOURNAL_ACCESS_CREATE);
1256 if (status < 0) {
1257 mlog_errno(status);
1258 goto bail;
1259 }
1260
1261 eb->h_next_leaf_blk = 0;
1262 eb_el->l_tree_depth = cpu_to_le16(i);
1263 eb_el->l_next_free_rec = cpu_to_le16(1);
1264 /*
1265 * This actually counts as an empty extent as
1266 * c_clusters == 0
1267 */
1268 eb_el->l_recs[0].e_cpos = cpu_to_le32(new_cpos);
1269 eb_el->l_recs[0].e_blkno = cpu_to_le64(next_blkno);
1270 /*
1271 * eb_el isn't always an interior node, but even leaf
1272 * nodes want a zero'd flags and reserved field so
1273 * this gets the whole 32 bits regardless of use.
1274 */
1275 eb_el->l_recs[0].e_int_clusters = cpu_to_le32(0);
1276 if (!eb_el->l_tree_depth)
1277 new_last_eb_blk = le64_to_cpu(eb->h_blkno);
1278
1279 ocfs2_journal_dirty(handle, bh);
1280 next_blkno = le64_to_cpu(eb->h_blkno);
1281 }
1282
1283 /* This is a bit hairy. We want to update up to three blocks
1284 * here without leaving any of them in an inconsistent state
1285 * in case of error. We don't have to worry about
1286 * journal_dirty erroring as it won't unless we've aborted the
1287 * handle (in which case we would never be here) so reserving
1288 * the write with journal_access is all we need to do. */
1289 status = ocfs2_journal_access_eb(handle, et->et_ci, *last_eb_bh,
1290 OCFS2_JOURNAL_ACCESS_WRITE);
1291 if (status < 0) {
1292 mlog_errno(status);
1293 goto bail;
1294 }
1295 status = ocfs2_et_root_journal_access(handle, et,
1296 OCFS2_JOURNAL_ACCESS_WRITE);
1297 if (status < 0) {
1298 mlog_errno(status);
1299 goto bail;
1300 }
1301 if (eb_bh) {
1302 status = ocfs2_journal_access_eb(handle, et->et_ci, eb_bh,
1303 OCFS2_JOURNAL_ACCESS_WRITE);
1304 if (status < 0) {
1305 mlog_errno(status);
1306 goto bail;
1307 }
1308 }
1309
1310 /* Link the new branch into the rest of the tree (el will
1311 * either be on the root_bh, or the extent block passed in. */
1312 i = le16_to_cpu(el->l_next_free_rec);
1313 el->l_recs[i].e_blkno = cpu_to_le64(next_blkno);
1314 el->l_recs[i].e_cpos = cpu_to_le32(new_cpos);
1315 el->l_recs[i].e_int_clusters = 0;
1316 le16_add_cpu(&el->l_next_free_rec, 1);
1317
1318 /* fe needs a new last extent block pointer, as does the
1319 * next_leaf on the previously last-extent-block. */
1320 ocfs2_et_set_last_eb_blk(et, new_last_eb_blk);
1321
1322 eb = (struct ocfs2_extent_block *) (*last_eb_bh)->b_data;
1323 eb->h_next_leaf_blk = cpu_to_le64(new_last_eb_blk);
1324
1325 ocfs2_journal_dirty(handle, *last_eb_bh);
1326 ocfs2_journal_dirty(handle, et->et_root_bh);
1327 if (eb_bh)
1328 ocfs2_journal_dirty(handle, eb_bh);
1329
1330 /*
1331 * Some callers want to track the rightmost leaf so pass it
1332 * back here.
1333 */
1334 brelse(*last_eb_bh);
1335 get_bh(new_eb_bhs[0]);
1336 *last_eb_bh = new_eb_bhs[0];
1337
1338 status = 0;
1339bail:
1340 if (new_eb_bhs) {
1341 for (i = 0; i < new_blocks; i++)
1342 brelse(new_eb_bhs[i]);
1343 kfree(new_eb_bhs);
1344 }
1345
1346 return status;
1347}
1348
1349/*
1350 * adds another level to the allocation tree.
1351 * returns back the new extent block so you can add a branch to it
1352 * after this call.
1353 */
1354static int ocfs2_shift_tree_depth(handle_t *handle,
1355 struct ocfs2_extent_tree *et,
1356 struct ocfs2_alloc_context *meta_ac,
1357 struct buffer_head **ret_new_eb_bh)
1358{
1359 int status, i, block_given = 0;
1360 u32 new_clusters;
1361 struct buffer_head *new_eb_bh = NULL;
1362 struct ocfs2_extent_block *eb;
1363 struct ocfs2_extent_list *root_el;
1364 struct ocfs2_extent_list *eb_el;
1365
1366 if (!ocfs2_is_dealloc_empty(et)) {
1367 status = ocfs2_reuse_blk_from_dealloc(handle, et,
1368 &new_eb_bh, 1,
1369 &block_given);
1370 } else if (meta_ac) {
1371 status = ocfs2_create_new_meta_bhs(handle, et, 1, meta_ac,
1372 &new_eb_bh);
1373
1374 } else {
1375 BUG();
1376 }
1377
1378 if (status < 0) {
1379 mlog_errno(status);
1380 goto bail;
1381 }
1382
1383 eb = (struct ocfs2_extent_block *) new_eb_bh->b_data;
1384 /* ocfs2_create_new_meta_bhs() should create it right! */
1385 BUG_ON(!OCFS2_IS_VALID_EXTENT_BLOCK(eb));
1386
1387 eb_el = &eb->h_list;
1388 root_el = et->et_root_el;
1389
1390 status = ocfs2_journal_access_eb(handle, et->et_ci, new_eb_bh,
1391 OCFS2_JOURNAL_ACCESS_CREATE);
1392 if (status < 0) {
1393 mlog_errno(status);
1394 goto bail;
1395 }
1396
1397 /* copy the root extent list data into the new extent block */
1398 eb_el->l_tree_depth = root_el->l_tree_depth;
1399 eb_el->l_next_free_rec = root_el->l_next_free_rec;
1400 for (i = 0; i < le16_to_cpu(root_el->l_next_free_rec); i++)
1401 eb_el->l_recs[i] = root_el->l_recs[i];
1402
1403 ocfs2_journal_dirty(handle, new_eb_bh);
1404
1405 status = ocfs2_et_root_journal_access(handle, et,
1406 OCFS2_JOURNAL_ACCESS_WRITE);
1407 if (status < 0) {
1408 mlog_errno(status);
1409 goto bail;
1410 }
1411
1412 new_clusters = ocfs2_sum_rightmost_rec(eb_el);
1413
1414 /* update root_bh now */
1415 le16_add_cpu(&root_el->l_tree_depth, 1);
1416 root_el->l_recs[0].e_cpos = 0;
1417 root_el->l_recs[0].e_blkno = eb->h_blkno;
1418 root_el->l_recs[0].e_int_clusters = cpu_to_le32(new_clusters);
1419 for (i = 1; i < le16_to_cpu(root_el->l_next_free_rec); i++)
1420 memset(&root_el->l_recs[i], 0, sizeof(struct ocfs2_extent_rec));
1421 root_el->l_next_free_rec = cpu_to_le16(1);
1422
1423 /* If this is our 1st tree depth shift, then last_eb_blk
1424 * becomes the allocated extent block */
1425 if (root_el->l_tree_depth == cpu_to_le16(1))
1426 ocfs2_et_set_last_eb_blk(et, le64_to_cpu(eb->h_blkno));
1427
1428 ocfs2_journal_dirty(handle, et->et_root_bh);
1429
1430 *ret_new_eb_bh = new_eb_bh;
1431 new_eb_bh = NULL;
1432 status = 0;
1433bail:
1434 brelse(new_eb_bh);
1435
1436 return status;
1437}
1438
1439/*
1440 * Should only be called when there is no space left in any of the
1441 * leaf nodes. What we want to do is find the lowest tree depth
1442 * non-leaf extent block with room for new records. There are three
1443 * valid results of this search:
1444 *
1445 * 1) a lowest extent block is found, then we pass it back in
1446 * *lowest_eb_bh and return '0'
1447 *
1448 * 2) the search fails to find anything, but the root_el has room. We
1449 * pass NULL back in *lowest_eb_bh, but still return '0'
1450 *
1451 * 3) the search fails to find anything AND the root_el is full, in
1452 * which case we return > 0
1453 *
1454 * return status < 0 indicates an error.
1455 */
1456static int ocfs2_find_branch_target(struct ocfs2_extent_tree *et,
1457 struct buffer_head **target_bh)
1458{
1459 int status = 0, i;
1460 u64 blkno;
1461 struct ocfs2_extent_block *eb;
1462 struct ocfs2_extent_list *el;
1463 struct buffer_head *bh = NULL;
1464 struct buffer_head *lowest_bh = NULL;
1465
1466 *target_bh = NULL;
1467
1468 el = et->et_root_el;
1469
1470 while(le16_to_cpu(el->l_tree_depth) > 1) {
1471 if (le16_to_cpu(el->l_next_free_rec) == 0) {
1472 status = ocfs2_error(ocfs2_metadata_cache_get_super(et->et_ci),
1473 "Owner %llu has empty extent list (next_free_rec == 0)\n",
1474 (unsigned long long)ocfs2_metadata_cache_owner(et->et_ci));
1475 goto bail;
1476 }
1477 i = le16_to_cpu(el->l_next_free_rec) - 1;
1478 blkno = le64_to_cpu(el->l_recs[i].e_blkno);
1479 if (!blkno) {
1480 status = ocfs2_error(ocfs2_metadata_cache_get_super(et->et_ci),
1481 "Owner %llu has extent list where extent # %d has no physical block start\n",
1482 (unsigned long long)ocfs2_metadata_cache_owner(et->et_ci), i);
1483 goto bail;
1484 }
1485
1486 brelse(bh);
1487 bh = NULL;
1488
1489 status = ocfs2_read_extent_block(et->et_ci, blkno, &bh);
1490 if (status < 0) {
1491 mlog_errno(status);
1492 goto bail;
1493 }
1494
1495 eb = (struct ocfs2_extent_block *) bh->b_data;
1496 el = &eb->h_list;
1497
1498 if (le16_to_cpu(el->l_next_free_rec) <
1499 le16_to_cpu(el->l_count)) {
1500 brelse(lowest_bh);
1501 lowest_bh = bh;
1502 get_bh(lowest_bh);
1503 }
1504 }
1505
1506 /* If we didn't find one and the fe doesn't have any room,
1507 * then return '1' */
1508 el = et->et_root_el;
1509 if (!lowest_bh && (el->l_next_free_rec == el->l_count))
1510 status = 1;
1511
1512 *target_bh = lowest_bh;
1513bail:
1514 brelse(bh);
1515
1516 return status;
1517}
1518
1519/*
1520 * Grow a b-tree so that it has more records.
1521 *
1522 * We might shift the tree depth in which case existing paths should
1523 * be considered invalid.
1524 *
1525 * Tree depth after the grow is returned via *final_depth.
1526 *
1527 * *last_eb_bh will be updated by ocfs2_add_branch().
1528 */
1529static int ocfs2_grow_tree(handle_t *handle, struct ocfs2_extent_tree *et,
1530 int *final_depth, struct buffer_head **last_eb_bh,
1531 struct ocfs2_alloc_context *meta_ac)
1532{
1533 int ret, shift;
1534 struct ocfs2_extent_list *el = et->et_root_el;
1535 int depth = le16_to_cpu(el->l_tree_depth);
1536 struct buffer_head *bh = NULL;
1537
1538 BUG_ON(meta_ac == NULL && ocfs2_is_dealloc_empty(et));
1539
1540 shift = ocfs2_find_branch_target(et, &bh);
1541 if (shift < 0) {
1542 ret = shift;
1543 mlog_errno(ret);
1544 goto out;
1545 }
1546
1547 /* We traveled all the way to the bottom of the allocation tree
1548 * and didn't find room for any more extents - we need to add
1549 * another tree level */
1550 if (shift) {
1551 BUG_ON(bh);
1552 trace_ocfs2_grow_tree(
1553 (unsigned long long)
1554 ocfs2_metadata_cache_owner(et->et_ci),
1555 depth);
1556
1557 /* ocfs2_shift_tree_depth will return us a buffer with
1558 * the new extent block (so we can pass that to
1559 * ocfs2_add_branch). */
1560 ret = ocfs2_shift_tree_depth(handle, et, meta_ac, &bh);
1561 if (ret < 0) {
1562 mlog_errno(ret);
1563 goto out;
1564 }
1565 depth++;
1566 if (depth == 1) {
1567 /*
1568 * Special case: we have room now if we shifted from
1569 * tree_depth 0, so no more work needs to be done.
1570 *
1571 * We won't be calling add_branch, so pass
1572 * back *last_eb_bh as the new leaf. At depth
1573 * zero, it should always be null so there's
1574 * no reason to brelse.
1575 */
1576 BUG_ON(*last_eb_bh);
1577 get_bh(bh);
1578 *last_eb_bh = bh;
1579 goto out;
1580 }
1581 }
1582
1583 /* call ocfs2_add_branch to add the final part of the tree with
1584 * the new data. */
1585 ret = ocfs2_add_branch(handle, et, bh, last_eb_bh,
1586 meta_ac);
1587 if (ret < 0)
1588 mlog_errno(ret);
1589
1590out:
1591 if (final_depth)
1592 *final_depth = depth;
1593 brelse(bh);
1594 return ret;
1595}
1596
1597/*
1598 * This function will discard the rightmost extent record.
1599 */
1600static void ocfs2_shift_records_right(struct ocfs2_extent_list *el)
1601{
1602 int next_free = le16_to_cpu(el->l_next_free_rec);
1603 int count = le16_to_cpu(el->l_count);
1604 unsigned int num_bytes;
1605
1606 BUG_ON(!next_free);
1607 /* This will cause us to go off the end of our extent list. */
1608 BUG_ON(next_free >= count);
1609
1610 num_bytes = sizeof(struct ocfs2_extent_rec) * next_free;
1611
1612 memmove(&el->l_recs[1], &el->l_recs[0], num_bytes);
1613}
1614
1615static void ocfs2_rotate_leaf(struct ocfs2_extent_list *el,
1616 struct ocfs2_extent_rec *insert_rec)
1617{
1618 int i, insert_index, next_free, has_empty, num_bytes;
1619 u32 insert_cpos = le32_to_cpu(insert_rec->e_cpos);
1620 struct ocfs2_extent_rec *rec;
1621
1622 next_free = le16_to_cpu(el->l_next_free_rec);
1623 has_empty = ocfs2_is_empty_extent(&el->l_recs[0]);
1624
1625 BUG_ON(!next_free);
1626
1627 /* The tree code before us didn't allow enough room in the leaf. */
1628 BUG_ON(el->l_next_free_rec == el->l_count && !has_empty);
1629
1630 /*
1631 * The easiest way to approach this is to just remove the
1632 * empty extent and temporarily decrement next_free.
1633 */
1634 if (has_empty) {
1635 /*
1636 * If next_free was 1 (only an empty extent), this
1637 * loop won't execute, which is fine. We still want
1638 * the decrement above to happen.
1639 */
1640 for(i = 0; i < (next_free - 1); i++)
1641 el->l_recs[i] = el->l_recs[i+1];
1642
1643 next_free--;
1644 }
1645
1646 /*
1647 * Figure out what the new record index should be.
1648 */
1649 for(i = 0; i < next_free; i++) {
1650 rec = &el->l_recs[i];
1651
1652 if (insert_cpos < le32_to_cpu(rec->e_cpos))
1653 break;
1654 }
1655 insert_index = i;
1656
1657 trace_ocfs2_rotate_leaf(insert_cpos, insert_index,
1658 has_empty, next_free,
1659 le16_to_cpu(el->l_count));
1660
1661 BUG_ON(insert_index < 0);
1662 BUG_ON(insert_index >= le16_to_cpu(el->l_count));
1663 BUG_ON(insert_index > next_free);
1664
1665 /*
1666 * No need to memmove if we're just adding to the tail.
1667 */
1668 if (insert_index != next_free) {
1669 BUG_ON(next_free >= le16_to_cpu(el->l_count));
1670
1671 num_bytes = next_free - insert_index;
1672 num_bytes *= sizeof(struct ocfs2_extent_rec);
1673 memmove(&el->l_recs[insert_index + 1],
1674 &el->l_recs[insert_index],
1675 num_bytes);
1676 }
1677
1678 /*
1679 * Either we had an empty extent, and need to re-increment or
1680 * there was no empty extent on a non full rightmost leaf node,
1681 * in which case we still need to increment.
1682 */
1683 next_free++;
1684 el->l_next_free_rec = cpu_to_le16(next_free);
1685 /*
1686 * Make sure none of the math above just messed up our tree.
1687 */
1688 BUG_ON(le16_to_cpu(el->l_next_free_rec) > le16_to_cpu(el->l_count));
1689
1690 el->l_recs[insert_index] = *insert_rec;
1691
1692}
1693
1694static void ocfs2_remove_empty_extent(struct ocfs2_extent_list *el)
1695{
1696 int size, num_recs = le16_to_cpu(el->l_next_free_rec);
1697
1698 BUG_ON(num_recs == 0);
1699
1700 if (ocfs2_is_empty_extent(&el->l_recs[0])) {
1701 num_recs--;
1702 size = num_recs * sizeof(struct ocfs2_extent_rec);
1703 memmove(&el->l_recs[0], &el->l_recs[1], size);
1704 memset(&el->l_recs[num_recs], 0,
1705 sizeof(struct ocfs2_extent_rec));
1706 el->l_next_free_rec = cpu_to_le16(num_recs);
1707 }
1708}
1709
1710/*
1711 * Create an empty extent record .
1712 *
1713 * l_next_free_rec may be updated.
1714 *
1715 * If an empty extent already exists do nothing.
1716 */
1717static void ocfs2_create_empty_extent(struct ocfs2_extent_list *el)
1718{
1719 int next_free = le16_to_cpu(el->l_next_free_rec);
1720
1721 BUG_ON(le16_to_cpu(el->l_tree_depth) != 0);
1722
1723 if (next_free == 0)
1724 goto set_and_inc;
1725
1726 if (ocfs2_is_empty_extent(&el->l_recs[0]))
1727 return;
1728
1729 mlog_bug_on_msg(el->l_count == el->l_next_free_rec,
1730 "Asked to create an empty extent in a full list:\n"
1731 "count = %u, tree depth = %u",
1732 le16_to_cpu(el->l_count),
1733 le16_to_cpu(el->l_tree_depth));
1734
1735 ocfs2_shift_records_right(el);
1736
1737set_and_inc:
1738 le16_add_cpu(&el->l_next_free_rec, 1);
1739 memset(&el->l_recs[0], 0, sizeof(struct ocfs2_extent_rec));
1740}
1741
1742/*
1743 * For a rotation which involves two leaf nodes, the "root node" is
1744 * the lowest level tree node which contains a path to both leafs. This
1745 * resulting set of information can be used to form a complete "subtree"
1746 *
1747 * This function is passed two full paths from the dinode down to a
1748 * pair of adjacent leaves. It's task is to figure out which path
1749 * index contains the subtree root - this can be the root index itself
1750 * in a worst-case rotation.
1751 *
1752 * The array index of the subtree root is passed back.
1753 */
1754int ocfs2_find_subtree_root(struct ocfs2_extent_tree *et,
1755 struct ocfs2_path *left,
1756 struct ocfs2_path *right)
1757{
1758 int i = 0;
1759
1760 /*
1761 * Check that the caller passed in two paths from the same tree.
1762 */
1763 BUG_ON(path_root_bh(left) != path_root_bh(right));
1764
1765 do {
1766 i++;
1767
1768 /*
1769 * The caller didn't pass two adjacent paths.
1770 */
1771 mlog_bug_on_msg(i > left->p_tree_depth,
1772 "Owner %llu, left depth %u, right depth %u\n"
1773 "left leaf blk %llu, right leaf blk %llu\n",
1774 (unsigned long long)ocfs2_metadata_cache_owner(et->et_ci),
1775 left->p_tree_depth, right->p_tree_depth,
1776 (unsigned long long)path_leaf_bh(left)->b_blocknr,
1777 (unsigned long long)path_leaf_bh(right)->b_blocknr);
1778 } while (left->p_node[i].bh->b_blocknr ==
1779 right->p_node[i].bh->b_blocknr);
1780
1781 return i - 1;
1782}
1783
1784typedef void (path_insert_t)(void *, struct buffer_head *);
1785
1786/*
1787 * Traverse a btree path in search of cpos, starting at root_el.
1788 *
1789 * This code can be called with a cpos larger than the tree, in which
1790 * case it will return the rightmost path.
1791 */
1792static int __ocfs2_find_path(struct ocfs2_caching_info *ci,
1793 struct ocfs2_extent_list *root_el, u32 cpos,
1794 path_insert_t *func, void *data)
1795{
1796 int i, ret = 0;
1797 u32 range;
1798 u64 blkno;
1799 struct buffer_head *bh = NULL;
1800 struct ocfs2_extent_block *eb;
1801 struct ocfs2_extent_list *el;
1802 struct ocfs2_extent_rec *rec;
1803
1804 el = root_el;
1805 while (el->l_tree_depth) {
1806 if (le16_to_cpu(el->l_next_free_rec) == 0) {
1807 ocfs2_error(ocfs2_metadata_cache_get_super(ci),
1808 "Owner %llu has empty extent list at depth %u\n",
1809 (unsigned long long)ocfs2_metadata_cache_owner(ci),
1810 le16_to_cpu(el->l_tree_depth));
1811 ret = -EROFS;
1812 goto out;
1813
1814 }
1815
1816 for(i = 0; i < le16_to_cpu(el->l_next_free_rec) - 1; i++) {
1817 rec = &el->l_recs[i];
1818
1819 /*
1820 * In the case that cpos is off the allocation
1821 * tree, this should just wind up returning the
1822 * rightmost record.
1823 */
1824 range = le32_to_cpu(rec->e_cpos) +
1825 ocfs2_rec_clusters(el, rec);
1826 if (cpos >= le32_to_cpu(rec->e_cpos) && cpos < range)
1827 break;
1828 }
1829
1830 blkno = le64_to_cpu(el->l_recs[i].e_blkno);
1831 if (blkno == 0) {
1832 ocfs2_error(ocfs2_metadata_cache_get_super(ci),
1833 "Owner %llu has bad blkno in extent list at depth %u (index %d)\n",
1834 (unsigned long long)ocfs2_metadata_cache_owner(ci),
1835 le16_to_cpu(el->l_tree_depth), i);
1836 ret = -EROFS;
1837 goto out;
1838 }
1839
1840 brelse(bh);
1841 bh = NULL;
1842 ret = ocfs2_read_extent_block(ci, blkno, &bh);
1843 if (ret) {
1844 mlog_errno(ret);
1845 goto out;
1846 }
1847
1848 eb = (struct ocfs2_extent_block *) bh->b_data;
1849 el = &eb->h_list;
1850
1851 if (le16_to_cpu(el->l_next_free_rec) >
1852 le16_to_cpu(el->l_count)) {
1853 ocfs2_error(ocfs2_metadata_cache_get_super(ci),
1854 "Owner %llu has bad count in extent list at block %llu (next free=%u, count=%u)\n",
1855 (unsigned long long)ocfs2_metadata_cache_owner(ci),
1856 (unsigned long long)bh->b_blocknr,
1857 le16_to_cpu(el->l_next_free_rec),
1858 le16_to_cpu(el->l_count));
1859 ret = -EROFS;
1860 goto out;
1861 }
1862
1863 if (func)
1864 func(data, bh);
1865 }
1866
1867out:
1868 /*
1869 * Catch any trailing bh that the loop didn't handle.
1870 */
1871 brelse(bh);
1872
1873 return ret;
1874}
1875
1876/*
1877 * Given an initialized path (that is, it has a valid root extent
1878 * list), this function will traverse the btree in search of the path
1879 * which would contain cpos.
1880 *
1881 * The path traveled is recorded in the path structure.
1882 *
1883 * Note that this will not do any comparisons on leaf node extent
1884 * records, so it will work fine in the case that we just added a tree
1885 * branch.
1886 */
1887struct find_path_data {
1888 int index;
1889 struct ocfs2_path *path;
1890};
1891static void find_path_ins(void *data, struct buffer_head *bh)
1892{
1893 struct find_path_data *fp = data;
1894
1895 get_bh(bh);
1896 ocfs2_path_insert_eb(fp->path, fp->index, bh);
1897 fp->index++;
1898}
1899int ocfs2_find_path(struct ocfs2_caching_info *ci,
1900 struct ocfs2_path *path, u32 cpos)
1901{
1902 struct find_path_data data;
1903
1904 data.index = 1;
1905 data.path = path;
1906 return __ocfs2_find_path(ci, path_root_el(path), cpos,
1907 find_path_ins, &data);
1908}
1909
1910static void find_leaf_ins(void *data, struct buffer_head *bh)
1911{
1912 struct ocfs2_extent_block *eb =(struct ocfs2_extent_block *)bh->b_data;
1913 struct ocfs2_extent_list *el = &eb->h_list;
1914 struct buffer_head **ret = data;
1915
1916 /* We want to retain only the leaf block. */
1917 if (le16_to_cpu(el->l_tree_depth) == 0) {
1918 get_bh(bh);
1919 *ret = bh;
1920 }
1921}
1922/*
1923 * Find the leaf block in the tree which would contain cpos. No
1924 * checking of the actual leaf is done.
1925 *
1926 * Some paths want to call this instead of allocating a path structure
1927 * and calling ocfs2_find_path().
1928 *
1929 * This function doesn't handle non btree extent lists.
1930 */
1931int ocfs2_find_leaf(struct ocfs2_caching_info *ci,
1932 struct ocfs2_extent_list *root_el, u32 cpos,
1933 struct buffer_head **leaf_bh)
1934{
1935 int ret;
1936 struct buffer_head *bh = NULL;
1937
1938 ret = __ocfs2_find_path(ci, root_el, cpos, find_leaf_ins, &bh);
1939 if (ret) {
1940 mlog_errno(ret);
1941 goto out;
1942 }
1943
1944 *leaf_bh = bh;
1945out:
1946 return ret;
1947}
1948
1949/*
1950 * Adjust the adjacent records (left_rec, right_rec) involved in a rotation.
1951 *
1952 * Basically, we've moved stuff around at the bottom of the tree and
1953 * we need to fix up the extent records above the changes to reflect
1954 * the new changes.
1955 *
1956 * left_rec: the record on the left.
1957 * right_rec: the record to the right of left_rec
1958 * right_child_el: is the child list pointed to by right_rec
1959 *
1960 * By definition, this only works on interior nodes.
1961 */
1962static void ocfs2_adjust_adjacent_records(struct ocfs2_extent_rec *left_rec,
1963 struct ocfs2_extent_rec *right_rec,
1964 struct ocfs2_extent_list *right_child_el)
1965{
1966 u32 left_clusters, right_end;
1967
1968 /*
1969 * Interior nodes never have holes. Their cpos is the cpos of
1970 * the leftmost record in their child list. Their cluster
1971 * count covers the full theoretical range of their child list
1972 * - the range between their cpos and the cpos of the record
1973 * immediately to their right.
1974 */
1975 left_clusters = le32_to_cpu(right_child_el->l_recs[0].e_cpos);
1976 if (!ocfs2_rec_clusters(right_child_el, &right_child_el->l_recs[0])) {
1977 BUG_ON(right_child_el->l_tree_depth);
1978 BUG_ON(le16_to_cpu(right_child_el->l_next_free_rec) <= 1);
1979 left_clusters = le32_to_cpu(right_child_el->l_recs[1].e_cpos);
1980 }
1981 left_clusters -= le32_to_cpu(left_rec->e_cpos);
1982 left_rec->e_int_clusters = cpu_to_le32(left_clusters);
1983
1984 /*
1985 * Calculate the rightmost cluster count boundary before
1986 * moving cpos - we will need to adjust clusters after
1987 * updating e_cpos to keep the same highest cluster count.
1988 */
1989 right_end = le32_to_cpu(right_rec->e_cpos);
1990 right_end += le32_to_cpu(right_rec->e_int_clusters);
1991
1992 right_rec->e_cpos = left_rec->e_cpos;
1993 le32_add_cpu(&right_rec->e_cpos, left_clusters);
1994
1995 right_end -= le32_to_cpu(right_rec->e_cpos);
1996 right_rec->e_int_clusters = cpu_to_le32(right_end);
1997}
1998
1999/*
2000 * Adjust the adjacent root node records involved in a
2001 * rotation. left_el_blkno is passed in as a key so that we can easily
2002 * find it's index in the root list.
2003 */
2004static void ocfs2_adjust_root_records(struct ocfs2_extent_list *root_el,
2005 struct ocfs2_extent_list *left_el,
2006 struct ocfs2_extent_list *right_el,
2007 u64 left_el_blkno)
2008{
2009 int i;
2010
2011 BUG_ON(le16_to_cpu(root_el->l_tree_depth) <=
2012 le16_to_cpu(left_el->l_tree_depth));
2013
2014 for(i = 0; i < le16_to_cpu(root_el->l_next_free_rec) - 1; i++) {
2015 if (le64_to_cpu(root_el->l_recs[i].e_blkno) == left_el_blkno)
2016 break;
2017 }
2018
2019 /*
2020 * The path walking code should have never returned a root and
2021 * two paths which are not adjacent.
2022 */
2023 BUG_ON(i >= (le16_to_cpu(root_el->l_next_free_rec) - 1));
2024
2025 ocfs2_adjust_adjacent_records(&root_el->l_recs[i],
2026 &root_el->l_recs[i + 1], right_el);
2027}
2028
2029/*
2030 * We've changed a leaf block (in right_path) and need to reflect that
2031 * change back up the subtree.
2032 *
2033 * This happens in multiple places:
2034 * - When we've moved an extent record from the left path leaf to the right
2035 * path leaf to make room for an empty extent in the left path leaf.
2036 * - When our insert into the right path leaf is at the leftmost edge
2037 * and requires an update of the path immediately to it's left. This
2038 * can occur at the end of some types of rotation and appending inserts.
2039 * - When we've adjusted the last extent record in the left path leaf and the
2040 * 1st extent record in the right path leaf during cross extent block merge.
2041 */
2042static void ocfs2_complete_edge_insert(handle_t *handle,
2043 struct ocfs2_path *left_path,
2044 struct ocfs2_path *right_path,
2045 int subtree_index)
2046{
2047 int i, idx;
2048 struct ocfs2_extent_list *el, *left_el, *right_el;
2049 struct ocfs2_extent_rec *left_rec, *right_rec;
2050 struct buffer_head *root_bh;
2051
2052 /*
2053 * Update the counts and position values within all the
2054 * interior nodes to reflect the leaf rotation we just did.
2055 *
2056 * The root node is handled below the loop.
2057 *
2058 * We begin the loop with right_el and left_el pointing to the
2059 * leaf lists and work our way up.
2060 *
2061 * NOTE: within this loop, left_el and right_el always refer
2062 * to the *child* lists.
2063 */
2064 left_el = path_leaf_el(left_path);
2065 right_el = path_leaf_el(right_path);
2066 for(i = left_path->p_tree_depth - 1; i > subtree_index; i--) {
2067 trace_ocfs2_complete_edge_insert(i);
2068
2069 /*
2070 * One nice property of knowing that all of these
2071 * nodes are below the root is that we only deal with
2072 * the leftmost right node record and the rightmost
2073 * left node record.
2074 */
2075 el = left_path->p_node[i].el;
2076 idx = le16_to_cpu(left_el->l_next_free_rec) - 1;
2077 left_rec = &el->l_recs[idx];
2078
2079 el = right_path->p_node[i].el;
2080 right_rec = &el->l_recs[0];
2081
2082 ocfs2_adjust_adjacent_records(left_rec, right_rec, right_el);
2083
2084 ocfs2_journal_dirty(handle, left_path->p_node[i].bh);
2085 ocfs2_journal_dirty(handle, right_path->p_node[i].bh);
2086
2087 /*
2088 * Setup our list pointers now so that the current
2089 * parents become children in the next iteration.
2090 */
2091 left_el = left_path->p_node[i].el;
2092 right_el = right_path->p_node[i].el;
2093 }
2094
2095 /*
2096 * At the root node, adjust the two adjacent records which
2097 * begin our path to the leaves.
2098 */
2099
2100 el = left_path->p_node[subtree_index].el;
2101 left_el = left_path->p_node[subtree_index + 1].el;
2102 right_el = right_path->p_node[subtree_index + 1].el;
2103
2104 ocfs2_adjust_root_records(el, left_el, right_el,
2105 left_path->p_node[subtree_index + 1].bh->b_blocknr);
2106
2107 root_bh = left_path->p_node[subtree_index].bh;
2108
2109 ocfs2_journal_dirty(handle, root_bh);
2110}
2111
2112static int ocfs2_rotate_subtree_right(handle_t *handle,
2113 struct ocfs2_extent_tree *et,
2114 struct ocfs2_path *left_path,
2115 struct ocfs2_path *right_path,
2116 int subtree_index)
2117{
2118 int ret, i;
2119 struct buffer_head *right_leaf_bh;
2120 struct buffer_head *left_leaf_bh = NULL;
2121 struct buffer_head *root_bh;
2122 struct ocfs2_extent_list *right_el, *left_el;
2123 struct ocfs2_extent_rec move_rec;
2124
2125 left_leaf_bh = path_leaf_bh(left_path);
2126 left_el = path_leaf_el(left_path);
2127
2128 if (left_el->l_next_free_rec != left_el->l_count) {
2129 ocfs2_error(ocfs2_metadata_cache_get_super(et->et_ci),
2130 "Inode %llu has non-full interior leaf node %llu (next free = %u)\n",
2131 (unsigned long long)ocfs2_metadata_cache_owner(et->et_ci),
2132 (unsigned long long)left_leaf_bh->b_blocknr,
2133 le16_to_cpu(left_el->l_next_free_rec));
2134 return -EROFS;
2135 }
2136
2137 /*
2138 * This extent block may already have an empty record, so we
2139 * return early if so.
2140 */
2141 if (ocfs2_is_empty_extent(&left_el->l_recs[0]))
2142 return 0;
2143
2144 root_bh = left_path->p_node[subtree_index].bh;
2145 BUG_ON(root_bh != right_path->p_node[subtree_index].bh);
2146
2147 ret = ocfs2_path_bh_journal_access(handle, et->et_ci, right_path,
2148 subtree_index);
2149 if (ret) {
2150 mlog_errno(ret);
2151 goto out;
2152 }
2153
2154 for(i = subtree_index + 1; i < path_num_items(right_path); i++) {
2155 ret = ocfs2_path_bh_journal_access(handle, et->et_ci,
2156 right_path, i);
2157 if (ret) {
2158 mlog_errno(ret);
2159 goto out;
2160 }
2161
2162 ret = ocfs2_path_bh_journal_access(handle, et->et_ci,
2163 left_path, i);
2164 if (ret) {
2165 mlog_errno(ret);
2166 goto out;
2167 }
2168 }
2169
2170 right_leaf_bh = path_leaf_bh(right_path);
2171 right_el = path_leaf_el(right_path);
2172
2173 /* This is a code error, not a disk corruption. */
2174 mlog_bug_on_msg(!right_el->l_next_free_rec, "Inode %llu: Rotate fails "
2175 "because rightmost leaf block %llu is empty\n",
2176 (unsigned long long)ocfs2_metadata_cache_owner(et->et_ci),
2177 (unsigned long long)right_leaf_bh->b_blocknr);
2178
2179 ocfs2_create_empty_extent(right_el);
2180
2181 ocfs2_journal_dirty(handle, right_leaf_bh);
2182
2183 /* Do the copy now. */
2184 i = le16_to_cpu(left_el->l_next_free_rec) - 1;
2185 move_rec = left_el->l_recs[i];
2186 right_el->l_recs[0] = move_rec;
2187
2188 /*
2189 * Clear out the record we just copied and shift everything
2190 * over, leaving an empty extent in the left leaf.
2191 *
2192 * We temporarily subtract from next_free_rec so that the
2193 * shift will lose the tail record (which is now defunct).
2194 */
2195 le16_add_cpu(&left_el->l_next_free_rec, -1);
2196 ocfs2_shift_records_right(left_el);
2197 memset(&left_el->l_recs[0], 0, sizeof(struct ocfs2_extent_rec));
2198 le16_add_cpu(&left_el->l_next_free_rec, 1);
2199
2200 ocfs2_journal_dirty(handle, left_leaf_bh);
2201
2202 ocfs2_complete_edge_insert(handle, left_path, right_path,
2203 subtree_index);
2204
2205out:
2206 return ret;
2207}
2208
2209/*
2210 * Given a full path, determine what cpos value would return us a path
2211 * containing the leaf immediately to the left of the current one.
2212 *
2213 * Will return zero if the path passed in is already the leftmost path.
2214 */
2215int ocfs2_find_cpos_for_left_leaf(struct super_block *sb,
2216 struct ocfs2_path *path, u32 *cpos)
2217{
2218 int i, j, ret = 0;
2219 u64 blkno;
2220 struct ocfs2_extent_list *el;
2221
2222 BUG_ON(path->p_tree_depth == 0);
2223
2224 *cpos = 0;
2225
2226 blkno = path_leaf_bh(path)->b_blocknr;
2227
2228 /* Start at the tree node just above the leaf and work our way up. */
2229 i = path->p_tree_depth - 1;
2230 while (i >= 0) {
2231 el = path->p_node[i].el;
2232
2233 /*
2234 * Find the extent record just before the one in our
2235 * path.
2236 */
2237 for(j = 0; j < le16_to_cpu(el->l_next_free_rec); j++) {
2238 if (le64_to_cpu(el->l_recs[j].e_blkno) == blkno) {
2239 if (j == 0) {
2240 if (i == 0) {
2241 /*
2242 * We've determined that the
2243 * path specified is already
2244 * the leftmost one - return a
2245 * cpos of zero.
2246 */
2247 goto out;
2248 }
2249 /*
2250 * The leftmost record points to our
2251 * leaf - we need to travel up the
2252 * tree one level.
2253 */
2254 goto next_node;
2255 }
2256
2257 *cpos = le32_to_cpu(el->l_recs[j - 1].e_cpos);
2258 *cpos = *cpos + ocfs2_rec_clusters(el,
2259 &el->l_recs[j - 1]);
2260 *cpos = *cpos - 1;
2261 goto out;
2262 }
2263 }
2264
2265 /*
2266 * If we got here, we never found a valid node where
2267 * the tree indicated one should be.
2268 */
2269 ocfs2_error(sb, "Invalid extent tree at extent block %llu\n",
2270 (unsigned long long)blkno);
2271 ret = -EROFS;
2272 goto out;
2273
2274next_node:
2275 blkno = path->p_node[i].bh->b_blocknr;
2276 i--;
2277 }
2278
2279out:
2280 return ret;
2281}
2282
2283/*
2284 * Extend the transaction by enough credits to complete the rotation,
2285 * and still leave at least the original number of credits allocated
2286 * to this transaction.
2287 */
2288static int ocfs2_extend_rotate_transaction(handle_t *handle, int subtree_depth,
2289 int op_credits,
2290 struct ocfs2_path *path)
2291{
2292 int ret = 0;
2293 int credits = (path->p_tree_depth - subtree_depth) * 2 + 1 + op_credits;
2294
2295 if (jbd2_handle_buffer_credits(handle) < credits)
2296 ret = ocfs2_extend_trans(handle,
2297 credits - jbd2_handle_buffer_credits(handle));
2298
2299 return ret;
2300}
2301
2302/*
2303 * Trap the case where we're inserting into the theoretical range past
2304 * the _actual_ left leaf range. Otherwise, we'll rotate a record
2305 * whose cpos is less than ours into the right leaf.
2306 *
2307 * It's only necessary to look at the rightmost record of the left
2308 * leaf because the logic that calls us should ensure that the
2309 * theoretical ranges in the path components above the leaves are
2310 * correct.
2311 */
2312static int ocfs2_rotate_requires_path_adjustment(struct ocfs2_path *left_path,
2313 u32 insert_cpos)
2314{
2315 struct ocfs2_extent_list *left_el;
2316 struct ocfs2_extent_rec *rec;
2317 int next_free;
2318
2319 left_el = path_leaf_el(left_path);
2320 next_free = le16_to_cpu(left_el->l_next_free_rec);
2321 rec = &left_el->l_recs[next_free - 1];
2322
2323 if (insert_cpos > le32_to_cpu(rec->e_cpos))
2324 return 1;
2325 return 0;
2326}
2327
2328static int ocfs2_leftmost_rec_contains(struct ocfs2_extent_list *el, u32 cpos)
2329{
2330 int next_free = le16_to_cpu(el->l_next_free_rec);
2331 unsigned int range;
2332 struct ocfs2_extent_rec *rec;
2333
2334 if (next_free == 0)
2335 return 0;
2336
2337 rec = &el->l_recs[0];
2338 if (ocfs2_is_empty_extent(rec)) {
2339 /* Empty list. */
2340 if (next_free == 1)
2341 return 0;
2342 rec = &el->l_recs[1];
2343 }
2344
2345 range = le32_to_cpu(rec->e_cpos) + ocfs2_rec_clusters(el, rec);
2346 if (cpos >= le32_to_cpu(rec->e_cpos) && cpos < range)
2347 return 1;
2348 return 0;
2349}
2350
2351/*
2352 * Rotate all the records in a btree right one record, starting at insert_cpos.
2353 *
2354 * The path to the rightmost leaf should be passed in.
2355 *
2356 * The array is assumed to be large enough to hold an entire path (tree depth).
2357 *
2358 * Upon successful return from this function:
2359 *
2360 * - The 'right_path' array will contain a path to the leaf block
2361 * whose range contains e_cpos.
2362 * - That leaf block will have a single empty extent in list index 0.
2363 * - In the case that the rotation requires a post-insert update,
2364 * *ret_left_path will contain a valid path which can be passed to
2365 * ocfs2_insert_path().
2366 */
2367static int ocfs2_rotate_tree_right(handle_t *handle,
2368 struct ocfs2_extent_tree *et,
2369 enum ocfs2_split_type split,
2370 u32 insert_cpos,
2371 struct ocfs2_path *right_path,
2372 struct ocfs2_path **ret_left_path)
2373{
2374 int ret, start, orig_credits = jbd2_handle_buffer_credits(handle);
2375 u32 cpos;
2376 struct ocfs2_path *left_path = NULL;
2377 struct super_block *sb = ocfs2_metadata_cache_get_super(et->et_ci);
2378
2379 *ret_left_path = NULL;
2380
2381 left_path = ocfs2_new_path_from_path(right_path);
2382 if (!left_path) {
2383 ret = -ENOMEM;
2384 mlog_errno(ret);
2385 goto out;
2386 }
2387
2388 ret = ocfs2_find_cpos_for_left_leaf(sb, right_path, &cpos);
2389 if (ret) {
2390 mlog_errno(ret);
2391 goto out;
2392 }
2393
2394 trace_ocfs2_rotate_tree_right(
2395 (unsigned long long)ocfs2_metadata_cache_owner(et->et_ci),
2396 insert_cpos, cpos);
2397
2398 /*
2399 * What we want to do here is:
2400 *
2401 * 1) Start with the rightmost path.
2402 *
2403 * 2) Determine a path to the leaf block directly to the left
2404 * of that leaf.
2405 *
2406 * 3) Determine the 'subtree root' - the lowest level tree node
2407 * which contains a path to both leaves.
2408 *
2409 * 4) Rotate the subtree.
2410 *
2411 * 5) Find the next subtree by considering the left path to be
2412 * the new right path.
2413 *
2414 * The check at the top of this while loop also accepts
2415 * insert_cpos == cpos because cpos is only a _theoretical_
2416 * value to get us the left path - insert_cpos might very well
2417 * be filling that hole.
2418 *
2419 * Stop at a cpos of '0' because we either started at the
2420 * leftmost branch (i.e., a tree with one branch and a
2421 * rotation inside of it), or we've gone as far as we can in
2422 * rotating subtrees.
2423 */
2424 while (cpos && insert_cpos <= cpos) {
2425 trace_ocfs2_rotate_tree_right(
2426 (unsigned long long)
2427 ocfs2_metadata_cache_owner(et->et_ci),
2428 insert_cpos, cpos);
2429
2430 ret = ocfs2_find_path(et->et_ci, left_path, cpos);
2431 if (ret) {
2432 mlog_errno(ret);
2433 goto out;
2434 }
2435
2436 mlog_bug_on_msg(path_leaf_bh(left_path) ==
2437 path_leaf_bh(right_path),
2438 "Owner %llu: error during insert of %u "
2439 "(left path cpos %u) results in two identical "
2440 "paths ending at %llu\n",
2441 (unsigned long long)ocfs2_metadata_cache_owner(et->et_ci),
2442 insert_cpos, cpos,
2443 (unsigned long long)
2444 path_leaf_bh(left_path)->b_blocknr);
2445
2446 if (split == SPLIT_NONE &&
2447 ocfs2_rotate_requires_path_adjustment(left_path,
2448 insert_cpos)) {
2449
2450 /*
2451 * We've rotated the tree as much as we
2452 * should. The rest is up to
2453 * ocfs2_insert_path() to complete, after the
2454 * record insertion. We indicate this
2455 * situation by returning the left path.
2456 *
2457 * The reason we don't adjust the records here
2458 * before the record insert is that an error
2459 * later might break the rule where a parent
2460 * record e_cpos will reflect the actual
2461 * e_cpos of the 1st nonempty record of the
2462 * child list.
2463 */
2464 *ret_left_path = left_path;
2465 goto out_ret_path;
2466 }
2467
2468 start = ocfs2_find_subtree_root(et, left_path, right_path);
2469
2470 trace_ocfs2_rotate_subtree(start,
2471 (unsigned long long)
2472 right_path->p_node[start].bh->b_blocknr,
2473 right_path->p_tree_depth);
2474
2475 ret = ocfs2_extend_rotate_transaction(handle, start,
2476 orig_credits, right_path);
2477 if (ret) {
2478 mlog_errno(ret);
2479 goto out;
2480 }
2481
2482 ret = ocfs2_rotate_subtree_right(handle, et, left_path,
2483 right_path, start);
2484 if (ret) {
2485 mlog_errno(ret);
2486 goto out;
2487 }
2488
2489 if (split != SPLIT_NONE &&
2490 ocfs2_leftmost_rec_contains(path_leaf_el(right_path),
2491 insert_cpos)) {
2492 /*
2493 * A rotate moves the rightmost left leaf
2494 * record over to the leftmost right leaf
2495 * slot. If we're doing an extent split
2496 * instead of a real insert, then we have to
2497 * check that the extent to be split wasn't
2498 * just moved over. If it was, then we can
2499 * exit here, passing left_path back -
2500 * ocfs2_split_extent() is smart enough to
2501 * search both leaves.
2502 */
2503 *ret_left_path = left_path;
2504 goto out_ret_path;
2505 }
2506
2507 /*
2508 * There is no need to re-read the next right path
2509 * as we know that it'll be our current left
2510 * path. Optimize by copying values instead.
2511 */
2512 ocfs2_mv_path(right_path, left_path);
2513
2514 ret = ocfs2_find_cpos_for_left_leaf(sb, right_path, &cpos);
2515 if (ret) {
2516 mlog_errno(ret);
2517 goto out;
2518 }
2519 }
2520
2521out:
2522 ocfs2_free_path(left_path);
2523
2524out_ret_path:
2525 return ret;
2526}
2527
2528static int ocfs2_update_edge_lengths(handle_t *handle,
2529 struct ocfs2_extent_tree *et,
2530 struct ocfs2_path *path)
2531{
2532 int i, idx, ret;
2533 struct ocfs2_extent_rec *rec;
2534 struct ocfs2_extent_list *el;
2535 struct ocfs2_extent_block *eb;
2536 u32 range;
2537
2538 ret = ocfs2_journal_access_path(et->et_ci, handle, path);
2539 if (ret) {
2540 mlog_errno(ret);
2541 goto out;
2542 }
2543
2544 /* Path should always be rightmost. */
2545 eb = (struct ocfs2_extent_block *)path_leaf_bh(path)->b_data;
2546 BUG_ON(eb->h_next_leaf_blk != 0ULL);
2547
2548 el = &eb->h_list;
2549 BUG_ON(le16_to_cpu(el->l_next_free_rec) == 0);
2550 idx = le16_to_cpu(el->l_next_free_rec) - 1;
2551 rec = &el->l_recs[idx];
2552 range = le32_to_cpu(rec->e_cpos) + ocfs2_rec_clusters(el, rec);
2553
2554 for (i = 0; i < path->p_tree_depth; i++) {
2555 el = path->p_node[i].el;
2556 idx = le16_to_cpu(el->l_next_free_rec) - 1;
2557 rec = &el->l_recs[idx];
2558
2559 rec->e_int_clusters = cpu_to_le32(range);
2560 le32_add_cpu(&rec->e_int_clusters, -le32_to_cpu(rec->e_cpos));
2561
2562 ocfs2_journal_dirty(handle, path->p_node[i].bh);
2563 }
2564out:
2565 return ret;
2566}
2567
2568static void ocfs2_unlink_path(handle_t *handle,
2569 struct ocfs2_extent_tree *et,
2570 struct ocfs2_cached_dealloc_ctxt *dealloc,
2571 struct ocfs2_path *path, int unlink_start)
2572{
2573 int ret, i;
2574 struct ocfs2_extent_block *eb;
2575 struct ocfs2_extent_list *el;
2576 struct buffer_head *bh;
2577
2578 for(i = unlink_start; i < path_num_items(path); i++) {
2579 bh = path->p_node[i].bh;
2580
2581 eb = (struct ocfs2_extent_block *)bh->b_data;
2582 /*
2583 * Not all nodes might have had their final count
2584 * decremented by the caller - handle this here.
2585 */
2586 el = &eb->h_list;
2587 if (le16_to_cpu(el->l_next_free_rec) > 1) {
2588 mlog(ML_ERROR,
2589 "Inode %llu, attempted to remove extent block "
2590 "%llu with %u records\n",
2591 (unsigned long long)ocfs2_metadata_cache_owner(et->et_ci),
2592 (unsigned long long)le64_to_cpu(eb->h_blkno),
2593 le16_to_cpu(el->l_next_free_rec));
2594
2595 ocfs2_journal_dirty(handle, bh);
2596 ocfs2_remove_from_cache(et->et_ci, bh);
2597 continue;
2598 }
2599
2600 el->l_next_free_rec = 0;
2601 memset(&el->l_recs[0], 0, sizeof(struct ocfs2_extent_rec));
2602
2603 ocfs2_journal_dirty(handle, bh);
2604
2605 ret = ocfs2_cache_extent_block_free(dealloc, eb);
2606 if (ret)
2607 mlog_errno(ret);
2608
2609 ocfs2_remove_from_cache(et->et_ci, bh);
2610 }
2611}
2612
2613static void ocfs2_unlink_subtree(handle_t *handle,
2614 struct ocfs2_extent_tree *et,
2615 struct ocfs2_path *left_path,
2616 struct ocfs2_path *right_path,
2617 int subtree_index,
2618 struct ocfs2_cached_dealloc_ctxt *dealloc)
2619{
2620 int i;
2621 struct buffer_head *root_bh = left_path->p_node[subtree_index].bh;
2622 struct ocfs2_extent_list *root_el = left_path->p_node[subtree_index].el;
2623 struct ocfs2_extent_block *eb;
2624
2625 eb = (struct ocfs2_extent_block *)right_path->p_node[subtree_index + 1].bh->b_data;
2626
2627 for(i = 1; i < le16_to_cpu(root_el->l_next_free_rec); i++)
2628 if (root_el->l_recs[i].e_blkno == eb->h_blkno)
2629 break;
2630
2631 BUG_ON(i >= le16_to_cpu(root_el->l_next_free_rec));
2632
2633 memset(&root_el->l_recs[i], 0, sizeof(struct ocfs2_extent_rec));
2634 le16_add_cpu(&root_el->l_next_free_rec, -1);
2635
2636 eb = (struct ocfs2_extent_block *)path_leaf_bh(left_path)->b_data;
2637 eb->h_next_leaf_blk = 0;
2638
2639 ocfs2_journal_dirty(handle, root_bh);
2640 ocfs2_journal_dirty(handle, path_leaf_bh(left_path));
2641
2642 ocfs2_unlink_path(handle, et, dealloc, right_path,
2643 subtree_index + 1);
2644}
2645
2646static int ocfs2_rotate_subtree_left(handle_t *handle,
2647 struct ocfs2_extent_tree *et,
2648 struct ocfs2_path *left_path,
2649 struct ocfs2_path *right_path,
2650 int subtree_index,
2651 struct ocfs2_cached_dealloc_ctxt *dealloc,
2652 int *deleted)
2653{
2654 int ret, i, del_right_subtree = 0, right_has_empty = 0;
2655 struct buffer_head *root_bh, *et_root_bh = path_root_bh(right_path);
2656 struct ocfs2_extent_list *right_leaf_el, *left_leaf_el;
2657 struct ocfs2_extent_block *eb;
2658
2659 *deleted = 0;
2660
2661 right_leaf_el = path_leaf_el(right_path);
2662 left_leaf_el = path_leaf_el(left_path);
2663 root_bh = left_path->p_node[subtree_index].bh;
2664 BUG_ON(root_bh != right_path->p_node[subtree_index].bh);
2665
2666 if (!ocfs2_is_empty_extent(&left_leaf_el->l_recs[0]))
2667 return 0;
2668
2669 eb = (struct ocfs2_extent_block *)path_leaf_bh(right_path)->b_data;
2670 if (ocfs2_is_empty_extent(&right_leaf_el->l_recs[0])) {
2671 /*
2672 * It's legal for us to proceed if the right leaf is
2673 * the rightmost one and it has an empty extent. There
2674 * are two cases to handle - whether the leaf will be
2675 * empty after removal or not. If the leaf isn't empty
2676 * then just remove the empty extent up front. The
2677 * next block will handle empty leaves by flagging
2678 * them for unlink.
2679 *
2680 * Non rightmost leaves will throw -EAGAIN and the
2681 * caller can manually move the subtree and retry.
2682 */
2683
2684 if (eb->h_next_leaf_blk != 0ULL)
2685 return -EAGAIN;
2686
2687 if (le16_to_cpu(right_leaf_el->l_next_free_rec) > 1) {
2688 ret = ocfs2_journal_access_eb(handle, et->et_ci,
2689 path_leaf_bh(right_path),
2690 OCFS2_JOURNAL_ACCESS_WRITE);
2691 if (ret) {
2692 mlog_errno(ret);
2693 goto out;
2694 }
2695
2696 ocfs2_remove_empty_extent(right_leaf_el);
2697 } else
2698 right_has_empty = 1;
2699 }
2700
2701 if (eb->h_next_leaf_blk == 0ULL &&
2702 le16_to_cpu(right_leaf_el->l_next_free_rec) == 1) {
2703 /*
2704 * We have to update i_last_eb_blk during the meta
2705 * data delete.
2706 */
2707 ret = ocfs2_et_root_journal_access(handle, et,
2708 OCFS2_JOURNAL_ACCESS_WRITE);
2709 if (ret) {
2710 mlog_errno(ret);
2711 goto out;
2712 }
2713
2714 del_right_subtree = 1;
2715 }
2716
2717 /*
2718 * Getting here with an empty extent in the right path implies
2719 * that it's the rightmost path and will be deleted.
2720 */
2721 BUG_ON(right_has_empty && !del_right_subtree);
2722
2723 ret = ocfs2_path_bh_journal_access(handle, et->et_ci, right_path,
2724 subtree_index);
2725 if (ret) {
2726 mlog_errno(ret);
2727 goto out;
2728 }
2729
2730 for(i = subtree_index + 1; i < path_num_items(right_path); i++) {
2731 ret = ocfs2_path_bh_journal_access(handle, et->et_ci,
2732 right_path, i);
2733 if (ret) {
2734 mlog_errno(ret);
2735 goto out;
2736 }
2737
2738 ret = ocfs2_path_bh_journal_access(handle, et->et_ci,
2739 left_path, i);
2740 if (ret) {
2741 mlog_errno(ret);
2742 goto out;
2743 }
2744 }
2745
2746 if (!right_has_empty) {
2747 /*
2748 * Only do this if we're moving a real
2749 * record. Otherwise, the action is delayed until
2750 * after removal of the right path in which case we
2751 * can do a simple shift to remove the empty extent.
2752 */
2753 ocfs2_rotate_leaf(left_leaf_el, &right_leaf_el->l_recs[0]);
2754 memset(&right_leaf_el->l_recs[0], 0,
2755 sizeof(struct ocfs2_extent_rec));
2756 }
2757 if (eb->h_next_leaf_blk == 0ULL) {
2758 /*
2759 * Move recs over to get rid of empty extent, decrease
2760 * next_free. This is allowed to remove the last
2761 * extent in our leaf (setting l_next_free_rec to
2762 * zero) - the delete code below won't care.
2763 */
2764 ocfs2_remove_empty_extent(right_leaf_el);
2765 }
2766
2767 ocfs2_journal_dirty(handle, path_leaf_bh(left_path));
2768 ocfs2_journal_dirty(handle, path_leaf_bh(right_path));
2769
2770 if (del_right_subtree) {
2771 ocfs2_unlink_subtree(handle, et, left_path, right_path,
2772 subtree_index, dealloc);
2773 ret = ocfs2_update_edge_lengths(handle, et, left_path);
2774 if (ret) {
2775 mlog_errno(ret);
2776 goto out;
2777 }
2778
2779 eb = (struct ocfs2_extent_block *)path_leaf_bh(left_path)->b_data;
2780 ocfs2_et_set_last_eb_blk(et, le64_to_cpu(eb->h_blkno));
2781
2782 /*
2783 * Removal of the extent in the left leaf was skipped
2784 * above so we could delete the right path
2785 * 1st.
2786 */
2787 if (right_has_empty)
2788 ocfs2_remove_empty_extent(left_leaf_el);
2789
2790 ocfs2_journal_dirty(handle, et_root_bh);
2791
2792 *deleted = 1;
2793 } else
2794 ocfs2_complete_edge_insert(handle, left_path, right_path,
2795 subtree_index);
2796
2797out:
2798 return ret;
2799}
2800
2801/*
2802 * Given a full path, determine what cpos value would return us a path
2803 * containing the leaf immediately to the right of the current one.
2804 *
2805 * Will return zero if the path passed in is already the rightmost path.
2806 *
2807 * This looks similar, but is subtly different to
2808 * ocfs2_find_cpos_for_left_leaf().
2809 */
2810int ocfs2_find_cpos_for_right_leaf(struct super_block *sb,
2811 struct ocfs2_path *path, u32 *cpos)
2812{
2813 int i, j, ret = 0;
2814 u64 blkno;
2815 struct ocfs2_extent_list *el;
2816
2817 *cpos = 0;
2818
2819 if (path->p_tree_depth == 0)
2820 return 0;
2821
2822 blkno = path_leaf_bh(path)->b_blocknr;
2823
2824 /* Start at the tree node just above the leaf and work our way up. */
2825 i = path->p_tree_depth - 1;
2826 while (i >= 0) {
2827 int next_free;
2828
2829 el = path->p_node[i].el;
2830
2831 /*
2832 * Find the extent record just after the one in our
2833 * path.
2834 */
2835 next_free = le16_to_cpu(el->l_next_free_rec);
2836 for(j = 0; j < le16_to_cpu(el->l_next_free_rec); j++) {
2837 if (le64_to_cpu(el->l_recs[j].e_blkno) == blkno) {
2838 if (j == (next_free - 1)) {
2839 if (i == 0) {
2840 /*
2841 * We've determined that the
2842 * path specified is already
2843 * the rightmost one - return a
2844 * cpos of zero.
2845 */
2846 goto out;
2847 }
2848 /*
2849 * The rightmost record points to our
2850 * leaf - we need to travel up the
2851 * tree one level.
2852 */
2853 goto next_node;
2854 }
2855
2856 *cpos = le32_to_cpu(el->l_recs[j + 1].e_cpos);
2857 goto out;
2858 }
2859 }
2860
2861 /*
2862 * If we got here, we never found a valid node where
2863 * the tree indicated one should be.
2864 */
2865 ocfs2_error(sb, "Invalid extent tree at extent block %llu\n",
2866 (unsigned long long)blkno);
2867 ret = -EROFS;
2868 goto out;
2869
2870next_node:
2871 blkno = path->p_node[i].bh->b_blocknr;
2872 i--;
2873 }
2874
2875out:
2876 return ret;
2877}
2878
2879static int ocfs2_rotate_rightmost_leaf_left(handle_t *handle,
2880 struct ocfs2_extent_tree *et,
2881 struct ocfs2_path *path)
2882{
2883 int ret;
2884 struct buffer_head *bh = path_leaf_bh(path);
2885 struct ocfs2_extent_list *el = path_leaf_el(path);
2886
2887 if (!ocfs2_is_empty_extent(&el->l_recs[0]))
2888 return 0;
2889
2890 ret = ocfs2_path_bh_journal_access(handle, et->et_ci, path,
2891 path_num_items(path) - 1);
2892 if (ret) {
2893 mlog_errno(ret);
2894 goto out;
2895 }
2896
2897 ocfs2_remove_empty_extent(el);
2898 ocfs2_journal_dirty(handle, bh);
2899
2900out:
2901 return ret;
2902}
2903
2904static int __ocfs2_rotate_tree_left(handle_t *handle,
2905 struct ocfs2_extent_tree *et,
2906 int orig_credits,
2907 struct ocfs2_path *path,
2908 struct ocfs2_cached_dealloc_ctxt *dealloc,
2909 struct ocfs2_path **empty_extent_path)
2910{
2911 int ret, subtree_root, deleted;
2912 u32 right_cpos;
2913 struct ocfs2_path *left_path = NULL;
2914 struct ocfs2_path *right_path = NULL;
2915 struct super_block *sb = ocfs2_metadata_cache_get_super(et->et_ci);
2916
2917 if (!ocfs2_is_empty_extent(&(path_leaf_el(path)->l_recs[0])))
2918 return 0;
2919
2920 *empty_extent_path = NULL;
2921
2922 ret = ocfs2_find_cpos_for_right_leaf(sb, path, &right_cpos);
2923 if (ret) {
2924 mlog_errno(ret);
2925 goto out;
2926 }
2927
2928 left_path = ocfs2_new_path_from_path(path);
2929 if (!left_path) {
2930 ret = -ENOMEM;
2931 mlog_errno(ret);
2932 goto out;
2933 }
2934
2935 ocfs2_cp_path(left_path, path);
2936
2937 right_path = ocfs2_new_path_from_path(path);
2938 if (!right_path) {
2939 ret = -ENOMEM;
2940 mlog_errno(ret);
2941 goto out;
2942 }
2943
2944 while (right_cpos) {
2945 ret = ocfs2_find_path(et->et_ci, right_path, right_cpos);
2946 if (ret) {
2947 mlog_errno(ret);
2948 goto out;
2949 }
2950
2951 subtree_root = ocfs2_find_subtree_root(et, left_path,
2952 right_path);
2953
2954 trace_ocfs2_rotate_subtree(subtree_root,
2955 (unsigned long long)
2956 right_path->p_node[subtree_root].bh->b_blocknr,
2957 right_path->p_tree_depth);
2958
2959 ret = ocfs2_extend_rotate_transaction(handle, 0,
2960 orig_credits, left_path);
2961 if (ret) {
2962 mlog_errno(ret);
2963 goto out;
2964 }
2965
2966 /*
2967 * Caller might still want to make changes to the
2968 * tree root, so re-add it to the journal here.
2969 */
2970 ret = ocfs2_path_bh_journal_access(handle, et->et_ci,
2971 left_path, 0);
2972 if (ret) {
2973 mlog_errno(ret);
2974 goto out;
2975 }
2976
2977 ret = ocfs2_rotate_subtree_left(handle, et, left_path,
2978 right_path, subtree_root,
2979 dealloc, &deleted);
2980 if (ret == -EAGAIN) {
2981 /*
2982 * The rotation has to temporarily stop due to
2983 * the right subtree having an empty
2984 * extent. Pass it back to the caller for a
2985 * fixup.
2986 */
2987 *empty_extent_path = right_path;
2988 right_path = NULL;
2989 goto out;
2990 }
2991 if (ret) {
2992 mlog_errno(ret);
2993 goto out;
2994 }
2995
2996 /*
2997 * The subtree rotate might have removed records on
2998 * the rightmost edge. If so, then rotation is
2999 * complete.
3000 */
3001 if (deleted)
3002 break;
3003
3004 ocfs2_mv_path(left_path, right_path);
3005
3006 ret = ocfs2_find_cpos_for_right_leaf(sb, left_path,
3007 &right_cpos);
3008 if (ret) {
3009 mlog_errno(ret);
3010 goto out;
3011 }
3012 }
3013
3014out:
3015 ocfs2_free_path(right_path);
3016 ocfs2_free_path(left_path);
3017
3018 return ret;
3019}
3020
3021static int ocfs2_remove_rightmost_path(handle_t *handle,
3022 struct ocfs2_extent_tree *et,
3023 struct ocfs2_path *path,
3024 struct ocfs2_cached_dealloc_ctxt *dealloc)
3025{
3026 int ret, subtree_index;
3027 u32 cpos;
3028 struct ocfs2_path *left_path = NULL;
3029 struct ocfs2_extent_block *eb;
3030 struct ocfs2_extent_list *el;
3031
3032 ret = ocfs2_et_sanity_check(et);
3033 if (ret)
3034 goto out;
3035
3036 ret = ocfs2_journal_access_path(et->et_ci, handle, path);
3037 if (ret) {
3038 mlog_errno(ret);
3039 goto out;
3040 }
3041
3042 ret = ocfs2_find_cpos_for_left_leaf(ocfs2_metadata_cache_get_super(et->et_ci),
3043 path, &cpos);
3044 if (ret) {
3045 mlog_errno(ret);
3046 goto out;
3047 }
3048
3049 if (cpos) {
3050 /*
3051 * We have a path to the left of this one - it needs
3052 * an update too.
3053 */
3054 left_path = ocfs2_new_path_from_path(path);
3055 if (!left_path) {
3056 ret = -ENOMEM;
3057 mlog_errno(ret);
3058 goto out;
3059 }
3060
3061 ret = ocfs2_find_path(et->et_ci, left_path, cpos);
3062 if (ret) {
3063 mlog_errno(ret);
3064 goto out;
3065 }
3066
3067 ret = ocfs2_journal_access_path(et->et_ci, handle, left_path);
3068 if (ret) {
3069 mlog_errno(ret);
3070 goto out;
3071 }
3072
3073 subtree_index = ocfs2_find_subtree_root(et, left_path, path);
3074
3075 ocfs2_unlink_subtree(handle, et, left_path, path,
3076 subtree_index, dealloc);
3077 ret = ocfs2_update_edge_lengths(handle, et, left_path);
3078 if (ret) {
3079 mlog_errno(ret);
3080 goto out;
3081 }
3082
3083 eb = (struct ocfs2_extent_block *)path_leaf_bh(left_path)->b_data;
3084 ocfs2_et_set_last_eb_blk(et, le64_to_cpu(eb->h_blkno));
3085 } else {
3086 /*
3087 * 'path' is also the leftmost path which
3088 * means it must be the only one. This gets
3089 * handled differently because we want to
3090 * revert the root back to having extents
3091 * in-line.
3092 */
3093 ocfs2_unlink_path(handle, et, dealloc, path, 1);
3094
3095 el = et->et_root_el;
3096 el->l_tree_depth = 0;
3097 el->l_next_free_rec = 0;
3098 memset(&el->l_recs[0], 0, sizeof(struct ocfs2_extent_rec));
3099
3100 ocfs2_et_set_last_eb_blk(et, 0);
3101 }
3102
3103 ocfs2_journal_dirty(handle, path_root_bh(path));
3104
3105out:
3106 ocfs2_free_path(left_path);
3107 return ret;
3108}
3109
3110static int ocfs2_remove_rightmost_empty_extent(struct ocfs2_super *osb,
3111 struct ocfs2_extent_tree *et,
3112 struct ocfs2_path *path,
3113 struct ocfs2_cached_dealloc_ctxt *dealloc)
3114{
3115 handle_t *handle;
3116 int ret;
3117 int credits = path->p_tree_depth * 2 + 1;
3118
3119 handle = ocfs2_start_trans(osb, credits);
3120 if (IS_ERR(handle)) {
3121 ret = PTR_ERR(handle);
3122 mlog_errno(ret);
3123 return ret;
3124 }
3125
3126 ret = ocfs2_remove_rightmost_path(handle, et, path, dealloc);
3127 if (ret)
3128 mlog_errno(ret);
3129
3130 ocfs2_commit_trans(osb, handle);
3131 return ret;
3132}
3133
3134/*
3135 * Left rotation of btree records.
3136 *
3137 * In many ways, this is (unsurprisingly) the opposite of right
3138 * rotation. We start at some non-rightmost path containing an empty
3139 * extent in the leaf block. The code works its way to the rightmost
3140 * path by rotating records to the left in every subtree.
3141 *
3142 * This is used by any code which reduces the number of extent records
3143 * in a leaf. After removal, an empty record should be placed in the
3144 * leftmost list position.
3145 *
3146 * This won't handle a length update of the rightmost path records if
3147 * the rightmost tree leaf record is removed so the caller is
3148 * responsible for detecting and correcting that.
3149 */
3150static int ocfs2_rotate_tree_left(handle_t *handle,
3151 struct ocfs2_extent_tree *et,
3152 struct ocfs2_path *path,
3153 struct ocfs2_cached_dealloc_ctxt *dealloc)
3154{
3155 int ret, orig_credits = jbd2_handle_buffer_credits(handle);
3156 struct ocfs2_path *tmp_path = NULL, *restart_path = NULL;
3157 struct ocfs2_extent_block *eb;
3158 struct ocfs2_extent_list *el;
3159
3160 el = path_leaf_el(path);
3161 if (!ocfs2_is_empty_extent(&el->l_recs[0]))
3162 return 0;
3163
3164 if (path->p_tree_depth == 0) {
3165rightmost_no_delete:
3166 /*
3167 * Inline extents. This is trivially handled, so do
3168 * it up front.
3169 */
3170 ret = ocfs2_rotate_rightmost_leaf_left(handle, et, path);
3171 if (ret)
3172 mlog_errno(ret);
3173 goto out;
3174 }
3175
3176 /*
3177 * Handle rightmost branch now. There's several cases:
3178 * 1) simple rotation leaving records in there. That's trivial.
3179 * 2) rotation requiring a branch delete - there's no more
3180 * records left. Two cases of this:
3181 * a) There are branches to the left.
3182 * b) This is also the leftmost (the only) branch.
3183 *
3184 * 1) is handled via ocfs2_rotate_rightmost_leaf_left()
3185 * 2a) we need the left branch so that we can update it with the unlink
3186 * 2b) we need to bring the root back to inline extents.
3187 */
3188
3189 eb = (struct ocfs2_extent_block *)path_leaf_bh(path)->b_data;
3190 el = &eb->h_list;
3191 if (eb->h_next_leaf_blk == 0) {
3192 /*
3193 * This gets a bit tricky if we're going to delete the
3194 * rightmost path. Get the other cases out of the way
3195 * 1st.
3196 */
3197 if (le16_to_cpu(el->l_next_free_rec) > 1)
3198 goto rightmost_no_delete;
3199
3200 if (le16_to_cpu(el->l_next_free_rec) == 0) {
3201 ret = ocfs2_error(ocfs2_metadata_cache_get_super(et->et_ci),
3202 "Owner %llu has empty extent block at %llu\n",
3203 (unsigned long long)ocfs2_metadata_cache_owner(et->et_ci),
3204 (unsigned long long)le64_to_cpu(eb->h_blkno));
3205 goto out;
3206 }
3207
3208 /*
3209 * XXX: The caller can not trust "path" any more after
3210 * this as it will have been deleted. What do we do?
3211 *
3212 * In theory the rotate-for-merge code will never get
3213 * here because it'll always ask for a rotate in a
3214 * nonempty list.
3215 */
3216
3217 ret = ocfs2_remove_rightmost_path(handle, et, path,
3218 dealloc);
3219 if (ret)
3220 mlog_errno(ret);
3221 goto out;
3222 }
3223
3224 /*
3225 * Now we can loop, remembering the path we get from -EAGAIN
3226 * and restarting from there.
3227 */
3228try_rotate:
3229 ret = __ocfs2_rotate_tree_left(handle, et, orig_credits, path,
3230 dealloc, &restart_path);
3231 if (ret && ret != -EAGAIN) {
3232 mlog_errno(ret);
3233 goto out;
3234 }
3235
3236 while (ret == -EAGAIN) {
3237 tmp_path = restart_path;
3238 restart_path = NULL;
3239
3240 ret = __ocfs2_rotate_tree_left(handle, et, orig_credits,
3241 tmp_path, dealloc,
3242 &restart_path);
3243 if (ret && ret != -EAGAIN) {
3244 mlog_errno(ret);
3245 goto out;
3246 }
3247
3248 ocfs2_free_path(tmp_path);
3249 tmp_path = NULL;
3250
3251 if (ret == 0)
3252 goto try_rotate;
3253 }
3254
3255out:
3256 ocfs2_free_path(tmp_path);
3257 ocfs2_free_path(restart_path);
3258 return ret;
3259}
3260
3261static void ocfs2_cleanup_merge(struct ocfs2_extent_list *el,
3262 int index)
3263{
3264 struct ocfs2_extent_rec *rec = &el->l_recs[index];
3265 unsigned int size;
3266
3267 if (rec->e_leaf_clusters == 0) {
3268 /*
3269 * We consumed all of the merged-from record. An empty
3270 * extent cannot exist anywhere but the 1st array
3271 * position, so move things over if the merged-from
3272 * record doesn't occupy that position.
3273 *
3274 * This creates a new empty extent so the caller
3275 * should be smart enough to have removed any existing
3276 * ones.
3277 */
3278 if (index > 0) {
3279 BUG_ON(ocfs2_is_empty_extent(&el->l_recs[0]));
3280 size = index * sizeof(struct ocfs2_extent_rec);
3281 memmove(&el->l_recs[1], &el->l_recs[0], size);
3282 }
3283
3284 /*
3285 * Always memset - the caller doesn't check whether it
3286 * created an empty extent, so there could be junk in
3287 * the other fields.
3288 */
3289 memset(&el->l_recs[0], 0, sizeof(struct ocfs2_extent_rec));
3290 }
3291}
3292
3293static int ocfs2_get_right_path(struct ocfs2_extent_tree *et,
3294 struct ocfs2_path *left_path,
3295 struct ocfs2_path **ret_right_path)
3296{
3297 int ret;
3298 u32 right_cpos;
3299 struct ocfs2_path *right_path = NULL;
3300 struct ocfs2_extent_list *left_el;
3301
3302 *ret_right_path = NULL;
3303
3304 /* This function shouldn't be called for non-trees. */
3305 BUG_ON(left_path->p_tree_depth == 0);
3306
3307 left_el = path_leaf_el(left_path);
3308 BUG_ON(left_el->l_next_free_rec != left_el->l_count);
3309
3310 ret = ocfs2_find_cpos_for_right_leaf(ocfs2_metadata_cache_get_super(et->et_ci),
3311 left_path, &right_cpos);
3312 if (ret) {
3313 mlog_errno(ret);
3314 goto out;
3315 }
3316
3317 /* This function shouldn't be called for the rightmost leaf. */
3318 BUG_ON(right_cpos == 0);
3319
3320 right_path = ocfs2_new_path_from_path(left_path);
3321 if (!right_path) {
3322 ret = -ENOMEM;
3323 mlog_errno(ret);
3324 goto out;
3325 }
3326
3327 ret = ocfs2_find_path(et->et_ci, right_path, right_cpos);
3328 if (ret) {
3329 mlog_errno(ret);
3330 goto out;
3331 }
3332
3333 *ret_right_path = right_path;
3334out:
3335 if (ret)
3336 ocfs2_free_path(right_path);
3337 return ret;
3338}
3339
3340/*
3341 * Remove split_rec clusters from the record at index and merge them
3342 * onto the beginning of the record "next" to it.
3343 * For index < l_count - 1, the next means the extent rec at index + 1.
3344 * For index == l_count - 1, the "next" means the 1st extent rec of the
3345 * next extent block.
3346 */
3347static int ocfs2_merge_rec_right(struct ocfs2_path *left_path,
3348 handle_t *handle,
3349 struct ocfs2_extent_tree *et,
3350 struct ocfs2_extent_rec *split_rec,
3351 int index)
3352{
3353 int ret, next_free, i;
3354 unsigned int split_clusters = le16_to_cpu(split_rec->e_leaf_clusters);
3355 struct ocfs2_extent_rec *left_rec;
3356 struct ocfs2_extent_rec *right_rec;
3357 struct ocfs2_extent_list *right_el;
3358 struct ocfs2_path *right_path = NULL;
3359 int subtree_index = 0;
3360 struct ocfs2_extent_list *el = path_leaf_el(left_path);
3361 struct buffer_head *bh = path_leaf_bh(left_path);
3362 struct buffer_head *root_bh = NULL;
3363
3364 BUG_ON(index >= le16_to_cpu(el->l_next_free_rec));
3365 left_rec = &el->l_recs[index];
3366
3367 if (index == le16_to_cpu(el->l_next_free_rec) - 1 &&
3368 le16_to_cpu(el->l_next_free_rec) == le16_to_cpu(el->l_count)) {
3369 /* we meet with a cross extent block merge. */
3370 ret = ocfs2_get_right_path(et, left_path, &right_path);
3371 if (ret) {
3372 mlog_errno(ret);
3373 return ret;
3374 }
3375
3376 right_el = path_leaf_el(right_path);
3377 next_free = le16_to_cpu(right_el->l_next_free_rec);
3378 BUG_ON(next_free <= 0);
3379 right_rec = &right_el->l_recs[0];
3380 if (ocfs2_is_empty_extent(right_rec)) {
3381 BUG_ON(next_free <= 1);
3382 right_rec = &right_el->l_recs[1];
3383 }
3384
3385 BUG_ON(le32_to_cpu(left_rec->e_cpos) +
3386 le16_to_cpu(left_rec->e_leaf_clusters) !=
3387 le32_to_cpu(right_rec->e_cpos));
3388
3389 subtree_index = ocfs2_find_subtree_root(et, left_path,
3390 right_path);
3391
3392 ret = ocfs2_extend_rotate_transaction(handle, subtree_index,
3393 jbd2_handle_buffer_credits(handle),
3394 right_path);
3395 if (ret) {
3396 mlog_errno(ret);
3397 goto out;
3398 }
3399
3400 root_bh = left_path->p_node[subtree_index].bh;
3401 BUG_ON(root_bh != right_path->p_node[subtree_index].bh);
3402
3403 ret = ocfs2_path_bh_journal_access(handle, et->et_ci, right_path,
3404 subtree_index);
3405 if (ret) {
3406 mlog_errno(ret);
3407 goto out;
3408 }
3409
3410 for (i = subtree_index + 1;
3411 i < path_num_items(right_path); i++) {
3412 ret = ocfs2_path_bh_journal_access(handle, et->et_ci,
3413 right_path, i);
3414 if (ret) {
3415 mlog_errno(ret);
3416 goto out;
3417 }
3418
3419 ret = ocfs2_path_bh_journal_access(handle, et->et_ci,
3420 left_path, i);
3421 if (ret) {
3422 mlog_errno(ret);
3423 goto out;
3424 }
3425 }
3426
3427 } else {
3428 BUG_ON(index == le16_to_cpu(el->l_next_free_rec) - 1);
3429 right_rec = &el->l_recs[index + 1];
3430 }
3431
3432 ret = ocfs2_path_bh_journal_access(handle, et->et_ci, left_path,
3433 path_num_items(left_path) - 1);
3434 if (ret) {
3435 mlog_errno(ret);
3436 goto out;
3437 }
3438
3439 le16_add_cpu(&left_rec->e_leaf_clusters, -split_clusters);
3440
3441 le32_add_cpu(&right_rec->e_cpos, -split_clusters);
3442 le64_add_cpu(&right_rec->e_blkno,
3443 -ocfs2_clusters_to_blocks(ocfs2_metadata_cache_get_super(et->et_ci),
3444 split_clusters));
3445 le16_add_cpu(&right_rec->e_leaf_clusters, split_clusters);
3446
3447 ocfs2_cleanup_merge(el, index);
3448
3449 ocfs2_journal_dirty(handle, bh);
3450 if (right_path) {
3451 ocfs2_journal_dirty(handle, path_leaf_bh(right_path));
3452 ocfs2_complete_edge_insert(handle, left_path, right_path,
3453 subtree_index);
3454 }
3455out:
3456 ocfs2_free_path(right_path);
3457 return ret;
3458}
3459
3460static int ocfs2_get_left_path(struct ocfs2_extent_tree *et,
3461 struct ocfs2_path *right_path,
3462 struct ocfs2_path **ret_left_path)
3463{
3464 int ret;
3465 u32 left_cpos;
3466 struct ocfs2_path *left_path = NULL;
3467
3468 *ret_left_path = NULL;
3469
3470 /* This function shouldn't be called for non-trees. */
3471 BUG_ON(right_path->p_tree_depth == 0);
3472
3473 ret = ocfs2_find_cpos_for_left_leaf(ocfs2_metadata_cache_get_super(et->et_ci),
3474 right_path, &left_cpos);
3475 if (ret) {
3476 mlog_errno(ret);
3477 goto out;
3478 }
3479
3480 /* This function shouldn't be called for the leftmost leaf. */
3481 BUG_ON(left_cpos == 0);
3482
3483 left_path = ocfs2_new_path_from_path(right_path);
3484 if (!left_path) {
3485 ret = -ENOMEM;
3486 mlog_errno(ret);
3487 goto out;
3488 }
3489
3490 ret = ocfs2_find_path(et->et_ci, left_path, left_cpos);
3491 if (ret) {
3492 mlog_errno(ret);
3493 goto out;
3494 }
3495
3496 *ret_left_path = left_path;
3497out:
3498 if (ret)
3499 ocfs2_free_path(left_path);
3500 return ret;
3501}
3502
3503/*
3504 * Remove split_rec clusters from the record at index and merge them
3505 * onto the tail of the record "before" it.
3506 * For index > 0, the "before" means the extent rec at index - 1.
3507 *
3508 * For index == 0, the "before" means the last record of the previous
3509 * extent block. And there is also a situation that we may need to
3510 * remove the rightmost leaf extent block in the right_path and change
3511 * the right path to indicate the new rightmost path.
3512 */
3513static int ocfs2_merge_rec_left(struct ocfs2_path *right_path,
3514 handle_t *handle,
3515 struct ocfs2_extent_tree *et,
3516 struct ocfs2_extent_rec *split_rec,
3517 struct ocfs2_cached_dealloc_ctxt *dealloc,
3518 int index)
3519{
3520 int ret, i, subtree_index = 0, has_empty_extent = 0;
3521 unsigned int split_clusters = le16_to_cpu(split_rec->e_leaf_clusters);
3522 struct ocfs2_extent_rec *left_rec;
3523 struct ocfs2_extent_rec *right_rec;
3524 struct ocfs2_extent_list *el = path_leaf_el(right_path);
3525 struct buffer_head *bh = path_leaf_bh(right_path);
3526 struct buffer_head *root_bh = NULL;
3527 struct ocfs2_path *left_path = NULL;
3528 struct ocfs2_extent_list *left_el;
3529
3530 BUG_ON(index < 0);
3531
3532 right_rec = &el->l_recs[index];
3533 if (index == 0) {
3534 /* we meet with a cross extent block merge. */
3535 ret = ocfs2_get_left_path(et, right_path, &left_path);
3536 if (ret) {
3537 mlog_errno(ret);
3538 return ret;
3539 }
3540
3541 left_el = path_leaf_el(left_path);
3542 BUG_ON(le16_to_cpu(left_el->l_next_free_rec) !=
3543 le16_to_cpu(left_el->l_count));
3544
3545 left_rec = &left_el->l_recs[
3546 le16_to_cpu(left_el->l_next_free_rec) - 1];
3547 BUG_ON(le32_to_cpu(left_rec->e_cpos) +
3548 le16_to_cpu(left_rec->e_leaf_clusters) !=
3549 le32_to_cpu(split_rec->e_cpos));
3550
3551 subtree_index = ocfs2_find_subtree_root(et, left_path,
3552 right_path);
3553
3554 ret = ocfs2_extend_rotate_transaction(handle, subtree_index,
3555 jbd2_handle_buffer_credits(handle),
3556 left_path);
3557 if (ret) {
3558 mlog_errno(ret);
3559 goto out;
3560 }
3561
3562 root_bh = left_path->p_node[subtree_index].bh;
3563 BUG_ON(root_bh != right_path->p_node[subtree_index].bh);
3564
3565 ret = ocfs2_path_bh_journal_access(handle, et->et_ci, right_path,
3566 subtree_index);
3567 if (ret) {
3568 mlog_errno(ret);
3569 goto out;
3570 }
3571
3572 for (i = subtree_index + 1;
3573 i < path_num_items(right_path); i++) {
3574 ret = ocfs2_path_bh_journal_access(handle, et->et_ci,
3575 right_path, i);
3576 if (ret) {
3577 mlog_errno(ret);
3578 goto out;
3579 }
3580
3581 ret = ocfs2_path_bh_journal_access(handle, et->et_ci,
3582 left_path, i);
3583 if (ret) {
3584 mlog_errno(ret);
3585 goto out;
3586 }
3587 }
3588 } else {
3589 left_rec = &el->l_recs[index - 1];
3590 if (ocfs2_is_empty_extent(&el->l_recs[0]))
3591 has_empty_extent = 1;
3592 }
3593
3594 ret = ocfs2_path_bh_journal_access(handle, et->et_ci, right_path,
3595 path_num_items(right_path) - 1);
3596 if (ret) {
3597 mlog_errno(ret);
3598 goto out;
3599 }
3600
3601 if (has_empty_extent && index == 1) {
3602 /*
3603 * The easy case - we can just plop the record right in.
3604 */
3605 *left_rec = *split_rec;
3606 } else
3607 le16_add_cpu(&left_rec->e_leaf_clusters, split_clusters);
3608
3609 le32_add_cpu(&right_rec->e_cpos, split_clusters);
3610 le64_add_cpu(&right_rec->e_blkno,
3611 ocfs2_clusters_to_blocks(ocfs2_metadata_cache_get_super(et->et_ci),
3612 split_clusters));
3613 le16_add_cpu(&right_rec->e_leaf_clusters, -split_clusters);
3614
3615 ocfs2_cleanup_merge(el, index);
3616
3617 ocfs2_journal_dirty(handle, bh);
3618 if (left_path) {
3619 ocfs2_journal_dirty(handle, path_leaf_bh(left_path));
3620
3621 /*
3622 * In the situation that the right_rec is empty and the extent
3623 * block is empty also, ocfs2_complete_edge_insert can't handle
3624 * it and we need to delete the right extent block.
3625 */
3626 if (le16_to_cpu(right_rec->e_leaf_clusters) == 0 &&
3627 le16_to_cpu(el->l_next_free_rec) == 1) {
3628 /* extend credit for ocfs2_remove_rightmost_path */
3629 ret = ocfs2_extend_rotate_transaction(handle, 0,
3630 jbd2_handle_buffer_credits(handle),
3631 right_path);
3632 if (ret) {
3633 mlog_errno(ret);
3634 goto out;
3635 }
3636
3637 ret = ocfs2_remove_rightmost_path(handle, et,
3638 right_path,
3639 dealloc);
3640 if (ret) {
3641 mlog_errno(ret);
3642 goto out;
3643 }
3644
3645 /* Now the rightmost extent block has been deleted.
3646 * So we use the new rightmost path.
3647 */
3648 ocfs2_mv_path(right_path, left_path);
3649 left_path = NULL;
3650 } else
3651 ocfs2_complete_edge_insert(handle, left_path,
3652 right_path, subtree_index);
3653 }
3654out:
3655 ocfs2_free_path(left_path);
3656 return ret;
3657}
3658
3659static int ocfs2_try_to_merge_extent(handle_t *handle,
3660 struct ocfs2_extent_tree *et,
3661 struct ocfs2_path *path,
3662 int split_index,
3663 struct ocfs2_extent_rec *split_rec,
3664 struct ocfs2_cached_dealloc_ctxt *dealloc,
3665 struct ocfs2_merge_ctxt *ctxt)
3666{
3667 int ret = 0;
3668 struct ocfs2_extent_list *el = path_leaf_el(path);
3669 struct ocfs2_extent_rec *rec = &el->l_recs[split_index];
3670
3671 BUG_ON(ctxt->c_contig_type == CONTIG_NONE);
3672
3673 if (ctxt->c_split_covers_rec && ctxt->c_has_empty_extent) {
3674 /* extend credit for ocfs2_remove_rightmost_path */
3675 ret = ocfs2_extend_rotate_transaction(handle, 0,
3676 jbd2_handle_buffer_credits(handle),
3677 path);
3678 if (ret) {
3679 mlog_errno(ret);
3680 goto out;
3681 }
3682 /*
3683 * The merge code will need to create an empty
3684 * extent to take the place of the newly
3685 * emptied slot. Remove any pre-existing empty
3686 * extents - having more than one in a leaf is
3687 * illegal.
3688 */
3689 ret = ocfs2_rotate_tree_left(handle, et, path, dealloc);
3690 if (ret) {
3691 mlog_errno(ret);
3692 goto out;
3693 }
3694 split_index--;
3695 rec = &el->l_recs[split_index];
3696 }
3697
3698 if (ctxt->c_contig_type == CONTIG_LEFTRIGHT) {
3699 /*
3700 * Left-right contig implies this.
3701 */
3702 BUG_ON(!ctxt->c_split_covers_rec);
3703
3704 /*
3705 * Since the leftright insert always covers the entire
3706 * extent, this call will delete the insert record
3707 * entirely, resulting in an empty extent record added to
3708 * the extent block.
3709 *
3710 * Since the adding of an empty extent shifts
3711 * everything back to the right, there's no need to
3712 * update split_index here.
3713 *
3714 * When the split_index is zero, we need to merge it to the
3715 * prevoius extent block. It is more efficient and easier
3716 * if we do merge_right first and merge_left later.
3717 */
3718 ret = ocfs2_merge_rec_right(path, handle, et, split_rec,
3719 split_index);
3720 if (ret) {
3721 mlog_errno(ret);
3722 goto out;
3723 }
3724
3725 /*
3726 * We can only get this from logic error above.
3727 */
3728 BUG_ON(!ocfs2_is_empty_extent(&el->l_recs[0]));
3729
3730 /* extend credit for ocfs2_remove_rightmost_path */
3731 ret = ocfs2_extend_rotate_transaction(handle, 0,
3732 jbd2_handle_buffer_credits(handle),
3733 path);
3734 if (ret) {
3735 mlog_errno(ret);
3736 goto out;
3737 }
3738
3739 /* The merge left us with an empty extent, remove it. */
3740 ret = ocfs2_rotate_tree_left(handle, et, path, dealloc);
3741 if (ret) {
3742 mlog_errno(ret);
3743 goto out;
3744 }
3745
3746 rec = &el->l_recs[split_index];
3747
3748 /*
3749 * Note that we don't pass split_rec here on purpose -
3750 * we've merged it into the rec already.
3751 */
3752 ret = ocfs2_merge_rec_left(path, handle, et, rec,
3753 dealloc, split_index);
3754
3755 if (ret) {
3756 mlog_errno(ret);
3757 goto out;
3758 }
3759
3760 /* extend credit for ocfs2_remove_rightmost_path */
3761 ret = ocfs2_extend_rotate_transaction(handle, 0,
3762 jbd2_handle_buffer_credits(handle),
3763 path);
3764 if (ret) {
3765 mlog_errno(ret);
3766 goto out;
3767 }
3768
3769 ret = ocfs2_rotate_tree_left(handle, et, path, dealloc);
3770 /*
3771 * Error from this last rotate is not critical, so
3772 * print but don't bubble it up.
3773 */
3774 if (ret)
3775 mlog_errno(ret);
3776 ret = 0;
3777 } else {
3778 /*
3779 * Merge a record to the left or right.
3780 *
3781 * 'contig_type' is relative to the existing record,
3782 * so for example, if we're "right contig", it's to
3783 * the record on the left (hence the left merge).
3784 */
3785 if (ctxt->c_contig_type == CONTIG_RIGHT) {
3786 ret = ocfs2_merge_rec_left(path, handle, et,
3787 split_rec, dealloc,
3788 split_index);
3789 if (ret) {
3790 mlog_errno(ret);
3791 goto out;
3792 }
3793 } else {
3794 ret = ocfs2_merge_rec_right(path, handle,
3795 et, split_rec,
3796 split_index);
3797 if (ret) {
3798 mlog_errno(ret);
3799 goto out;
3800 }
3801 }
3802
3803 if (ctxt->c_split_covers_rec) {
3804 /* extend credit for ocfs2_remove_rightmost_path */
3805 ret = ocfs2_extend_rotate_transaction(handle, 0,
3806 jbd2_handle_buffer_credits(handle),
3807 path);
3808 if (ret) {
3809 mlog_errno(ret);
3810 ret = 0;
3811 goto out;
3812 }
3813
3814 /*
3815 * The merge may have left an empty extent in
3816 * our leaf. Try to rotate it away.
3817 */
3818 ret = ocfs2_rotate_tree_left(handle, et, path,
3819 dealloc);
3820 if (ret)
3821 mlog_errno(ret);
3822 ret = 0;
3823 }
3824 }
3825
3826out:
3827 return ret;
3828}
3829
3830static void ocfs2_subtract_from_rec(struct super_block *sb,
3831 enum ocfs2_split_type split,
3832 struct ocfs2_extent_rec *rec,
3833 struct ocfs2_extent_rec *split_rec)
3834{
3835 u64 len_blocks;
3836
3837 len_blocks = ocfs2_clusters_to_blocks(sb,
3838 le16_to_cpu(split_rec->e_leaf_clusters));
3839
3840 if (split == SPLIT_LEFT) {
3841 /*
3842 * Region is on the left edge of the existing
3843 * record.
3844 */
3845 le32_add_cpu(&rec->e_cpos,
3846 le16_to_cpu(split_rec->e_leaf_clusters));
3847 le64_add_cpu(&rec->e_blkno, len_blocks);
3848 le16_add_cpu(&rec->e_leaf_clusters,
3849 -le16_to_cpu(split_rec->e_leaf_clusters));
3850 } else {
3851 /*
3852 * Region is on the right edge of the existing
3853 * record.
3854 */
3855 le16_add_cpu(&rec->e_leaf_clusters,
3856 -le16_to_cpu(split_rec->e_leaf_clusters));
3857 }
3858}
3859
3860/*
3861 * Do the final bits of extent record insertion at the target leaf
3862 * list. If this leaf is part of an allocation tree, it is assumed
3863 * that the tree above has been prepared.
3864 */
3865static void ocfs2_insert_at_leaf(struct ocfs2_extent_tree *et,
3866 struct ocfs2_extent_rec *insert_rec,
3867 struct ocfs2_extent_list *el,
3868 struct ocfs2_insert_type *insert)
3869{
3870 int i = insert->ins_contig_index;
3871 unsigned int range;
3872 struct ocfs2_extent_rec *rec;
3873
3874 BUG_ON(le16_to_cpu(el->l_tree_depth) != 0);
3875
3876 if (insert->ins_split != SPLIT_NONE) {
3877 i = ocfs2_search_extent_list(el, le32_to_cpu(insert_rec->e_cpos));
3878 BUG_ON(i == -1);
3879 rec = &el->l_recs[i];
3880 ocfs2_subtract_from_rec(ocfs2_metadata_cache_get_super(et->et_ci),
3881 insert->ins_split, rec,
3882 insert_rec);
3883 goto rotate;
3884 }
3885
3886 /*
3887 * Contiguous insert - either left or right.
3888 */
3889 if (insert->ins_contig != CONTIG_NONE) {
3890 rec = &el->l_recs[i];
3891 if (insert->ins_contig == CONTIG_LEFT) {
3892 rec->e_blkno = insert_rec->e_blkno;
3893 rec->e_cpos = insert_rec->e_cpos;
3894 }
3895 le16_add_cpu(&rec->e_leaf_clusters,
3896 le16_to_cpu(insert_rec->e_leaf_clusters));
3897 return;
3898 }
3899
3900 /*
3901 * Handle insert into an empty leaf.
3902 */
3903 if (le16_to_cpu(el->l_next_free_rec) == 0 ||
3904 ((le16_to_cpu(el->l_next_free_rec) == 1) &&
3905 ocfs2_is_empty_extent(&el->l_recs[0]))) {
3906 el->l_recs[0] = *insert_rec;
3907 el->l_next_free_rec = cpu_to_le16(1);
3908 return;
3909 }
3910
3911 /*
3912 * Appending insert.
3913 */
3914 if (insert->ins_appending == APPEND_TAIL) {
3915 i = le16_to_cpu(el->l_next_free_rec) - 1;
3916 rec = &el->l_recs[i];
3917 range = le32_to_cpu(rec->e_cpos)
3918 + le16_to_cpu(rec->e_leaf_clusters);
3919 BUG_ON(le32_to_cpu(insert_rec->e_cpos) < range);
3920
3921 mlog_bug_on_msg(le16_to_cpu(el->l_next_free_rec) >=
3922 le16_to_cpu(el->l_count),
3923 "owner %llu, depth %u, count %u, next free %u, "
3924 "rec.cpos %u, rec.clusters %u, "
3925 "insert.cpos %u, insert.clusters %u\n",
3926 ocfs2_metadata_cache_owner(et->et_ci),
3927 le16_to_cpu(el->l_tree_depth),
3928 le16_to_cpu(el->l_count),
3929 le16_to_cpu(el->l_next_free_rec),
3930 le32_to_cpu(el->l_recs[i].e_cpos),
3931 le16_to_cpu(el->l_recs[i].e_leaf_clusters),
3932 le32_to_cpu(insert_rec->e_cpos),
3933 le16_to_cpu(insert_rec->e_leaf_clusters));
3934 i++;
3935 el->l_recs[i] = *insert_rec;
3936 le16_add_cpu(&el->l_next_free_rec, 1);
3937 return;
3938 }
3939
3940rotate:
3941 /*
3942 * Ok, we have to rotate.
3943 *
3944 * At this point, it is safe to assume that inserting into an
3945 * empty leaf and appending to a leaf have both been handled
3946 * above.
3947 *
3948 * This leaf needs to have space, either by the empty 1st
3949 * extent record, or by virtue of an l_next_free_rec < l_count.
3950 */
3951 ocfs2_rotate_leaf(el, insert_rec);
3952}
3953
3954static void ocfs2_adjust_rightmost_records(handle_t *handle,
3955 struct ocfs2_extent_tree *et,
3956 struct ocfs2_path *path,
3957 struct ocfs2_extent_rec *insert_rec)
3958{
3959 int i, next_free;
3960 struct buffer_head *bh;
3961 struct ocfs2_extent_list *el;
3962 struct ocfs2_extent_rec *rec;
3963
3964 /*
3965 * Update everything except the leaf block.
3966 */
3967 for (i = 0; i < path->p_tree_depth; i++) {
3968 bh = path->p_node[i].bh;
3969 el = path->p_node[i].el;
3970
3971 next_free = le16_to_cpu(el->l_next_free_rec);
3972 if (next_free == 0) {
3973 ocfs2_error(ocfs2_metadata_cache_get_super(et->et_ci),
3974 "Owner %llu has a bad extent list\n",
3975 (unsigned long long)ocfs2_metadata_cache_owner(et->et_ci));
3976 return;
3977 }
3978
3979 rec = &el->l_recs[next_free - 1];
3980
3981 rec->e_int_clusters = insert_rec->e_cpos;
3982 le32_add_cpu(&rec->e_int_clusters,
3983 le16_to_cpu(insert_rec->e_leaf_clusters));
3984 le32_add_cpu(&rec->e_int_clusters,
3985 -le32_to_cpu(rec->e_cpos));
3986
3987 ocfs2_journal_dirty(handle, bh);
3988 }
3989}
3990
3991static int ocfs2_append_rec_to_path(handle_t *handle,
3992 struct ocfs2_extent_tree *et,
3993 struct ocfs2_extent_rec *insert_rec,
3994 struct ocfs2_path *right_path,
3995 struct ocfs2_path **ret_left_path)
3996{
3997 int ret, next_free;
3998 struct ocfs2_extent_list *el;
3999 struct ocfs2_path *left_path = NULL;
4000
4001 *ret_left_path = NULL;
4002
4003 /*
4004 * This shouldn't happen for non-trees. The extent rec cluster
4005 * count manipulation below only works for interior nodes.
4006 */
4007 BUG_ON(right_path->p_tree_depth == 0);
4008
4009 /*
4010 * If our appending insert is at the leftmost edge of a leaf,
4011 * then we might need to update the rightmost records of the
4012 * neighboring path.
4013 */
4014 el = path_leaf_el(right_path);
4015 next_free = le16_to_cpu(el->l_next_free_rec);
4016 if (next_free == 0 ||
4017 (next_free == 1 && ocfs2_is_empty_extent(&el->l_recs[0]))) {
4018 u32 left_cpos;
4019
4020 ret = ocfs2_find_cpos_for_left_leaf(ocfs2_metadata_cache_get_super(et->et_ci),
4021 right_path, &left_cpos);
4022 if (ret) {
4023 mlog_errno(ret);
4024 goto out;
4025 }
4026
4027 trace_ocfs2_append_rec_to_path(
4028 (unsigned long long)
4029 ocfs2_metadata_cache_owner(et->et_ci),
4030 le32_to_cpu(insert_rec->e_cpos),
4031 left_cpos);
4032
4033 /*
4034 * No need to worry if the append is already in the
4035 * leftmost leaf.
4036 */
4037 if (left_cpos) {
4038 left_path = ocfs2_new_path_from_path(right_path);
4039 if (!left_path) {
4040 ret = -ENOMEM;
4041 mlog_errno(ret);
4042 goto out;
4043 }
4044
4045 ret = ocfs2_find_path(et->et_ci, left_path,
4046 left_cpos);
4047 if (ret) {
4048 mlog_errno(ret);
4049 goto out;
4050 }
4051
4052 /*
4053 * ocfs2_insert_path() will pass the left_path to the
4054 * journal for us.
4055 */
4056 }
4057 }
4058
4059 ret = ocfs2_journal_access_path(et->et_ci, handle, right_path);
4060 if (ret) {
4061 mlog_errno(ret);
4062 goto out;
4063 }
4064
4065 ocfs2_adjust_rightmost_records(handle, et, right_path, insert_rec);
4066
4067 *ret_left_path = left_path;
4068 ret = 0;
4069out:
4070 if (ret != 0)
4071 ocfs2_free_path(left_path);
4072
4073 return ret;
4074}
4075
4076static void ocfs2_split_record(struct ocfs2_extent_tree *et,
4077 struct ocfs2_path *left_path,
4078 struct ocfs2_path *right_path,
4079 struct ocfs2_extent_rec *split_rec,
4080 enum ocfs2_split_type split)
4081{
4082 int index;
4083 u32 cpos = le32_to_cpu(split_rec->e_cpos);
4084 struct ocfs2_extent_list *left_el = NULL, *right_el, *insert_el, *el;
4085 struct ocfs2_extent_rec *rec, *tmprec;
4086
4087 right_el = path_leaf_el(right_path);
4088 if (left_path)
4089 left_el = path_leaf_el(left_path);
4090
4091 el = right_el;
4092 insert_el = right_el;
4093 index = ocfs2_search_extent_list(el, cpos);
4094 if (index != -1) {
4095 if (index == 0 && left_path) {
4096 BUG_ON(ocfs2_is_empty_extent(&el->l_recs[0]));
4097
4098 /*
4099 * This typically means that the record
4100 * started in the left path but moved to the
4101 * right as a result of rotation. We either
4102 * move the existing record to the left, or we
4103 * do the later insert there.
4104 *
4105 * In this case, the left path should always
4106 * exist as the rotate code will have passed
4107 * it back for a post-insert update.
4108 */
4109
4110 if (split == SPLIT_LEFT) {
4111 /*
4112 * It's a left split. Since we know
4113 * that the rotate code gave us an
4114 * empty extent in the left path, we
4115 * can just do the insert there.
4116 */
4117 insert_el = left_el;
4118 } else {
4119 /*
4120 * Right split - we have to move the
4121 * existing record over to the left
4122 * leaf. The insert will be into the
4123 * newly created empty extent in the
4124 * right leaf.
4125 */
4126 tmprec = &right_el->l_recs[index];
4127 ocfs2_rotate_leaf(left_el, tmprec);
4128 el = left_el;
4129
4130 memset(tmprec, 0, sizeof(*tmprec));
4131 index = ocfs2_search_extent_list(left_el, cpos);
4132 BUG_ON(index == -1);
4133 }
4134 }
4135 } else {
4136 BUG_ON(!left_path);
4137 BUG_ON(!ocfs2_is_empty_extent(&left_el->l_recs[0]));
4138 /*
4139 * Left path is easy - we can just allow the insert to
4140 * happen.
4141 */
4142 el = left_el;
4143 insert_el = left_el;
4144 index = ocfs2_search_extent_list(el, cpos);
4145 BUG_ON(index == -1);
4146 }
4147
4148 rec = &el->l_recs[index];
4149 ocfs2_subtract_from_rec(ocfs2_metadata_cache_get_super(et->et_ci),
4150 split, rec, split_rec);
4151 ocfs2_rotate_leaf(insert_el, split_rec);
4152}
4153
4154/*
4155 * This function only does inserts on an allocation b-tree. For tree
4156 * depth = 0, ocfs2_insert_at_leaf() is called directly.
4157 *
4158 * right_path is the path we want to do the actual insert
4159 * in. left_path should only be passed in if we need to update that
4160 * portion of the tree after an edge insert.
4161 */
4162static int ocfs2_insert_path(handle_t *handle,
4163 struct ocfs2_extent_tree *et,
4164 struct ocfs2_path *left_path,
4165 struct ocfs2_path *right_path,
4166 struct ocfs2_extent_rec *insert_rec,
4167 struct ocfs2_insert_type *insert)
4168{
4169 int ret, subtree_index;
4170 struct buffer_head *leaf_bh = path_leaf_bh(right_path);
4171
4172 if (left_path) {
4173 /*
4174 * There's a chance that left_path got passed back to
4175 * us without being accounted for in the
4176 * journal. Extend our transaction here to be sure we
4177 * can change those blocks.
4178 */
4179 ret = ocfs2_extend_trans(handle, left_path->p_tree_depth);
4180 if (ret < 0) {
4181 mlog_errno(ret);
4182 goto out;
4183 }
4184
4185 ret = ocfs2_journal_access_path(et->et_ci, handle, left_path);
4186 if (ret < 0) {
4187 mlog_errno(ret);
4188 goto out;
4189 }
4190 }
4191
4192 /*
4193 * Pass both paths to the journal. The majority of inserts
4194 * will be touching all components anyway.
4195 */
4196 ret = ocfs2_journal_access_path(et->et_ci, handle, right_path);
4197 if (ret < 0) {
4198 mlog_errno(ret);
4199 goto out;
4200 }
4201
4202 if (insert->ins_split != SPLIT_NONE) {
4203 /*
4204 * We could call ocfs2_insert_at_leaf() for some types
4205 * of splits, but it's easier to just let one separate
4206 * function sort it all out.
4207 */
4208 ocfs2_split_record(et, left_path, right_path,
4209 insert_rec, insert->ins_split);
4210
4211 /*
4212 * Split might have modified either leaf and we don't
4213 * have a guarantee that the later edge insert will
4214 * dirty this for us.
4215 */
4216 if (left_path)
4217 ocfs2_journal_dirty(handle,
4218 path_leaf_bh(left_path));
4219 } else
4220 ocfs2_insert_at_leaf(et, insert_rec, path_leaf_el(right_path),
4221 insert);
4222
4223 ocfs2_journal_dirty(handle, leaf_bh);
4224
4225 if (left_path) {
4226 /*
4227 * The rotate code has indicated that we need to fix
4228 * up portions of the tree after the insert.
4229 *
4230 * XXX: Should we extend the transaction here?
4231 */
4232 subtree_index = ocfs2_find_subtree_root(et, left_path,
4233 right_path);
4234 ocfs2_complete_edge_insert(handle, left_path, right_path,
4235 subtree_index);
4236 }
4237
4238 ret = 0;
4239out:
4240 return ret;
4241}
4242
4243static int ocfs2_do_insert_extent(handle_t *handle,
4244 struct ocfs2_extent_tree *et,
4245 struct ocfs2_extent_rec *insert_rec,
4246 struct ocfs2_insert_type *type)
4247{
4248 int ret, rotate = 0;
4249 u32 cpos;
4250 struct ocfs2_path *right_path = NULL;
4251 struct ocfs2_path *left_path = NULL;
4252 struct ocfs2_extent_list *el;
4253
4254 el = et->et_root_el;
4255
4256 ret = ocfs2_et_root_journal_access(handle, et,
4257 OCFS2_JOURNAL_ACCESS_WRITE);
4258 if (ret) {
4259 mlog_errno(ret);
4260 goto out;
4261 }
4262
4263 if (le16_to_cpu(el->l_tree_depth) == 0) {
4264 ocfs2_insert_at_leaf(et, insert_rec, el, type);
4265 goto out_update_clusters;
4266 }
4267
4268 right_path = ocfs2_new_path_from_et(et);
4269 if (!right_path) {
4270 ret = -ENOMEM;
4271 mlog_errno(ret);
4272 goto out;
4273 }
4274
4275 /*
4276 * Determine the path to start with. Rotations need the
4277 * rightmost path, everything else can go directly to the
4278 * target leaf.
4279 */
4280 cpos = le32_to_cpu(insert_rec->e_cpos);
4281 if (type->ins_appending == APPEND_NONE &&
4282 type->ins_contig == CONTIG_NONE) {
4283 rotate = 1;
4284 cpos = UINT_MAX;
4285 }
4286
4287 ret = ocfs2_find_path(et->et_ci, right_path, cpos);
4288 if (ret) {
4289 mlog_errno(ret);
4290 goto out;
4291 }
4292
4293 /*
4294 * Rotations and appends need special treatment - they modify
4295 * parts of the tree's above them.
4296 *
4297 * Both might pass back a path immediate to the left of the
4298 * one being inserted to. This will be cause
4299 * ocfs2_insert_path() to modify the rightmost records of
4300 * left_path to account for an edge insert.
4301 *
4302 * XXX: When modifying this code, keep in mind that an insert
4303 * can wind up skipping both of these two special cases...
4304 */
4305 if (rotate) {
4306 ret = ocfs2_rotate_tree_right(handle, et, type->ins_split,
4307 le32_to_cpu(insert_rec->e_cpos),
4308 right_path, &left_path);
4309 if (ret) {
4310 mlog_errno(ret);
4311 goto out;
4312 }
4313
4314 /*
4315 * ocfs2_rotate_tree_right() might have extended the
4316 * transaction without re-journaling our tree root.
4317 */
4318 ret = ocfs2_et_root_journal_access(handle, et,
4319 OCFS2_JOURNAL_ACCESS_WRITE);
4320 if (ret) {
4321 mlog_errno(ret);
4322 goto out;
4323 }
4324 } else if (type->ins_appending == APPEND_TAIL
4325 && type->ins_contig != CONTIG_LEFT) {
4326 ret = ocfs2_append_rec_to_path(handle, et, insert_rec,
4327 right_path, &left_path);
4328 if (ret) {
4329 mlog_errno(ret);
4330 goto out;
4331 }
4332 }
4333
4334 ret = ocfs2_insert_path(handle, et, left_path, right_path,
4335 insert_rec, type);
4336 if (ret) {
4337 mlog_errno(ret);
4338 goto out;
4339 }
4340
4341out_update_clusters:
4342 if (type->ins_split == SPLIT_NONE)
4343 ocfs2_et_update_clusters(et,
4344 le16_to_cpu(insert_rec->e_leaf_clusters));
4345
4346 ocfs2_journal_dirty(handle, et->et_root_bh);
4347
4348out:
4349 ocfs2_free_path(left_path);
4350 ocfs2_free_path(right_path);
4351
4352 return ret;
4353}
4354
4355static int ocfs2_figure_merge_contig_type(struct ocfs2_extent_tree *et,
4356 struct ocfs2_path *path,
4357 struct ocfs2_extent_list *el, int index,
4358 struct ocfs2_extent_rec *split_rec,
4359 struct ocfs2_merge_ctxt *ctxt)
4360{
4361 int status = 0;
4362 enum ocfs2_contig_type ret = CONTIG_NONE;
4363 u32 left_cpos, right_cpos;
4364 struct ocfs2_extent_rec *rec = NULL;
4365 struct ocfs2_extent_list *new_el;
4366 struct ocfs2_path *left_path = NULL, *right_path = NULL;
4367 struct buffer_head *bh;
4368 struct ocfs2_extent_block *eb;
4369 struct super_block *sb = ocfs2_metadata_cache_get_super(et->et_ci);
4370
4371 if (index > 0) {
4372 rec = &el->l_recs[index - 1];
4373 } else if (path->p_tree_depth > 0) {
4374 status = ocfs2_find_cpos_for_left_leaf(sb, path, &left_cpos);
4375 if (status)
4376 goto exit;
4377
4378 if (left_cpos != 0) {
4379 left_path = ocfs2_new_path_from_path(path);
4380 if (!left_path) {
4381 status = -ENOMEM;
4382 mlog_errno(status);
4383 goto exit;
4384 }
4385
4386 status = ocfs2_find_path(et->et_ci, left_path,
4387 left_cpos);
4388 if (status)
4389 goto free_left_path;
4390
4391 new_el = path_leaf_el(left_path);
4392
4393 if (le16_to_cpu(new_el->l_next_free_rec) !=
4394 le16_to_cpu(new_el->l_count)) {
4395 bh = path_leaf_bh(left_path);
4396 eb = (struct ocfs2_extent_block *)bh->b_data;
4397 status = ocfs2_error(sb,
4398 "Extent block #%llu has an invalid l_next_free_rec of %d. It should have matched the l_count of %d\n",
4399 (unsigned long long)le64_to_cpu(eb->h_blkno),
4400 le16_to_cpu(new_el->l_next_free_rec),
4401 le16_to_cpu(new_el->l_count));
4402 goto free_left_path;
4403 }
4404 rec = &new_el->l_recs[
4405 le16_to_cpu(new_el->l_next_free_rec) - 1];
4406 }
4407 }
4408
4409 /*
4410 * We're careful to check for an empty extent record here -
4411 * the merge code will know what to do if it sees one.
4412 */
4413 if (rec) {
4414 if (index == 1 && ocfs2_is_empty_extent(rec)) {
4415 if (split_rec->e_cpos == el->l_recs[index].e_cpos)
4416 ret = CONTIG_RIGHT;
4417 } else {
4418 ret = ocfs2_et_extent_contig(et, rec, split_rec);
4419 }
4420 }
4421
4422 rec = NULL;
4423 if (index < (le16_to_cpu(el->l_next_free_rec) - 1))
4424 rec = &el->l_recs[index + 1];
4425 else if (le16_to_cpu(el->l_next_free_rec) == le16_to_cpu(el->l_count) &&
4426 path->p_tree_depth > 0) {
4427 status = ocfs2_find_cpos_for_right_leaf(sb, path, &right_cpos);
4428 if (status)
4429 goto free_left_path;
4430
4431 if (right_cpos == 0)
4432 goto free_left_path;
4433
4434 right_path = ocfs2_new_path_from_path(path);
4435 if (!right_path) {
4436 status = -ENOMEM;
4437 mlog_errno(status);
4438 goto free_left_path;
4439 }
4440
4441 status = ocfs2_find_path(et->et_ci, right_path, right_cpos);
4442 if (status)
4443 goto free_right_path;
4444
4445 new_el = path_leaf_el(right_path);
4446 rec = &new_el->l_recs[0];
4447 if (ocfs2_is_empty_extent(rec)) {
4448 if (le16_to_cpu(new_el->l_next_free_rec) <= 1) {
4449 bh = path_leaf_bh(right_path);
4450 eb = (struct ocfs2_extent_block *)bh->b_data;
4451 status = ocfs2_error(sb,
4452 "Extent block #%llu has an invalid l_next_free_rec of %d\n",
4453 (unsigned long long)le64_to_cpu(eb->h_blkno),
4454 le16_to_cpu(new_el->l_next_free_rec));
4455 goto free_right_path;
4456 }
4457 rec = &new_el->l_recs[1];
4458 }
4459 }
4460
4461 if (rec) {
4462 enum ocfs2_contig_type contig_type;
4463
4464 contig_type = ocfs2_et_extent_contig(et, rec, split_rec);
4465
4466 if (contig_type == CONTIG_LEFT && ret == CONTIG_RIGHT)
4467 ret = CONTIG_LEFTRIGHT;
4468 else if (ret == CONTIG_NONE)
4469 ret = contig_type;
4470 }
4471
4472free_right_path:
4473 ocfs2_free_path(right_path);
4474free_left_path:
4475 ocfs2_free_path(left_path);
4476exit:
4477 if (status == 0)
4478 ctxt->c_contig_type = ret;
4479
4480 return status;
4481}
4482
4483static void ocfs2_figure_contig_type(struct ocfs2_extent_tree *et,
4484 struct ocfs2_insert_type *insert,
4485 struct ocfs2_extent_list *el,
4486 struct ocfs2_extent_rec *insert_rec)
4487{
4488 int i;
4489 enum ocfs2_contig_type contig_type = CONTIG_NONE;
4490
4491 BUG_ON(le16_to_cpu(el->l_tree_depth) != 0);
4492
4493 for(i = 0; i < le16_to_cpu(el->l_next_free_rec); i++) {
4494 contig_type = ocfs2_et_extent_contig(et, &el->l_recs[i],
4495 insert_rec);
4496 if (contig_type != CONTIG_NONE) {
4497 insert->ins_contig_index = i;
4498 break;
4499 }
4500 }
4501 insert->ins_contig = contig_type;
4502
4503 if (insert->ins_contig != CONTIG_NONE) {
4504 struct ocfs2_extent_rec *rec =
4505 &el->l_recs[insert->ins_contig_index];
4506 unsigned int len = le16_to_cpu(rec->e_leaf_clusters) +
4507 le16_to_cpu(insert_rec->e_leaf_clusters);
4508
4509 /*
4510 * Caller might want us to limit the size of extents, don't
4511 * calculate contiguousness if we might exceed that limit.
4512 */
4513 if (et->et_max_leaf_clusters &&
4514 (len > et->et_max_leaf_clusters))
4515 insert->ins_contig = CONTIG_NONE;
4516 }
4517}
4518
4519/*
4520 * This should only be called against the righmost leaf extent list.
4521 *
4522 * ocfs2_figure_appending_type() will figure out whether we'll have to
4523 * insert at the tail of the rightmost leaf.
4524 *
4525 * This should also work against the root extent list for tree's with 0
4526 * depth. If we consider the root extent list to be the rightmost leaf node
4527 * then the logic here makes sense.
4528 */
4529static void ocfs2_figure_appending_type(struct ocfs2_insert_type *insert,
4530 struct ocfs2_extent_list *el,
4531 struct ocfs2_extent_rec *insert_rec)
4532{
4533 int i;
4534 u32 cpos = le32_to_cpu(insert_rec->e_cpos);
4535 struct ocfs2_extent_rec *rec;
4536
4537 insert->ins_appending = APPEND_NONE;
4538
4539 BUG_ON(le16_to_cpu(el->l_tree_depth) != 0);
4540
4541 if (!el->l_next_free_rec)
4542 goto set_tail_append;
4543
4544 if (ocfs2_is_empty_extent(&el->l_recs[0])) {
4545 /* Were all records empty? */
4546 if (le16_to_cpu(el->l_next_free_rec) == 1)
4547 goto set_tail_append;
4548 }
4549
4550 i = le16_to_cpu(el->l_next_free_rec) - 1;
4551 rec = &el->l_recs[i];
4552
4553 if (cpos >=
4554 (le32_to_cpu(rec->e_cpos) + le16_to_cpu(rec->e_leaf_clusters)))
4555 goto set_tail_append;
4556
4557 return;
4558
4559set_tail_append:
4560 insert->ins_appending = APPEND_TAIL;
4561}
4562
4563/*
4564 * Helper function called at the beginning of an insert.
4565 *
4566 * This computes a few things that are commonly used in the process of
4567 * inserting into the btree:
4568 * - Whether the new extent is contiguous with an existing one.
4569 * - The current tree depth.
4570 * - Whether the insert is an appending one.
4571 * - The total # of free records in the tree.
4572 *
4573 * All of the information is stored on the ocfs2_insert_type
4574 * structure.
4575 */
4576static int ocfs2_figure_insert_type(struct ocfs2_extent_tree *et,
4577 struct buffer_head **last_eb_bh,
4578 struct ocfs2_extent_rec *insert_rec,
4579 int *free_records,
4580 struct ocfs2_insert_type *insert)
4581{
4582 int ret;
4583 struct ocfs2_extent_block *eb;
4584 struct ocfs2_extent_list *el;
4585 struct ocfs2_path *path = NULL;
4586 struct buffer_head *bh = NULL;
4587
4588 insert->ins_split = SPLIT_NONE;
4589
4590 el = et->et_root_el;
4591 insert->ins_tree_depth = le16_to_cpu(el->l_tree_depth);
4592
4593 if (el->l_tree_depth) {
4594 /*
4595 * If we have tree depth, we read in the
4596 * rightmost extent block ahead of time as
4597 * ocfs2_figure_insert_type() and ocfs2_add_branch()
4598 * may want it later.
4599 */
4600 ret = ocfs2_read_extent_block(et->et_ci,
4601 ocfs2_et_get_last_eb_blk(et),
4602 &bh);
4603 if (ret) {
4604 mlog_errno(ret);
4605 goto out;
4606 }
4607 eb = (struct ocfs2_extent_block *) bh->b_data;
4608 el = &eb->h_list;
4609 }
4610
4611 /*
4612 * Unless we have a contiguous insert, we'll need to know if
4613 * there is room left in our allocation tree for another
4614 * extent record.
4615 *
4616 * XXX: This test is simplistic, we can search for empty
4617 * extent records too.
4618 */
4619 *free_records = le16_to_cpu(el->l_count) -
4620 le16_to_cpu(el->l_next_free_rec);
4621
4622 if (!insert->ins_tree_depth) {
4623 ocfs2_figure_contig_type(et, insert, el, insert_rec);
4624 ocfs2_figure_appending_type(insert, el, insert_rec);
4625 return 0;
4626 }
4627
4628 path = ocfs2_new_path_from_et(et);
4629 if (!path) {
4630 ret = -ENOMEM;
4631 mlog_errno(ret);
4632 goto out;
4633 }
4634
4635 /*
4636 * In the case that we're inserting past what the tree
4637 * currently accounts for, ocfs2_find_path() will return for
4638 * us the rightmost tree path. This is accounted for below in
4639 * the appending code.
4640 */
4641 ret = ocfs2_find_path(et->et_ci, path, le32_to_cpu(insert_rec->e_cpos));
4642 if (ret) {
4643 mlog_errno(ret);
4644 goto out;
4645 }
4646
4647 el = path_leaf_el(path);
4648
4649 /*
4650 * Now that we have the path, there's two things we want to determine:
4651 * 1) Contiguousness (also set contig_index if this is so)
4652 *
4653 * 2) Are we doing an append? We can trivially break this up
4654 * into two types of appends: simple record append, or a
4655 * rotate inside the tail leaf.
4656 */
4657 ocfs2_figure_contig_type(et, insert, el, insert_rec);
4658
4659 /*
4660 * The insert code isn't quite ready to deal with all cases of
4661 * left contiguousness. Specifically, if it's an insert into
4662 * the 1st record in a leaf, it will require the adjustment of
4663 * cluster count on the last record of the path directly to it's
4664 * left. For now, just catch that case and fool the layers
4665 * above us. This works just fine for tree_depth == 0, which
4666 * is why we allow that above.
4667 */
4668 if (insert->ins_contig == CONTIG_LEFT &&
4669 insert->ins_contig_index == 0)
4670 insert->ins_contig = CONTIG_NONE;
4671
4672 /*
4673 * Ok, so we can simply compare against last_eb to figure out
4674 * whether the path doesn't exist. This will only happen in
4675 * the case that we're doing a tail append, so maybe we can
4676 * take advantage of that information somehow.
4677 */
4678 if (ocfs2_et_get_last_eb_blk(et) ==
4679 path_leaf_bh(path)->b_blocknr) {
4680 /*
4681 * Ok, ocfs2_find_path() returned us the rightmost
4682 * tree path. This might be an appending insert. There are
4683 * two cases:
4684 * 1) We're doing a true append at the tail:
4685 * -This might even be off the end of the leaf
4686 * 2) We're "appending" by rotating in the tail
4687 */
4688 ocfs2_figure_appending_type(insert, el, insert_rec);
4689 }
4690
4691out:
4692 ocfs2_free_path(path);
4693
4694 if (ret == 0)
4695 *last_eb_bh = bh;
4696 else
4697 brelse(bh);
4698 return ret;
4699}
4700
4701/*
4702 * Insert an extent into a btree.
4703 *
4704 * The caller needs to update the owning btree's cluster count.
4705 */
4706int ocfs2_insert_extent(handle_t *handle,
4707 struct ocfs2_extent_tree *et,
4708 u32 cpos,
4709 u64 start_blk,
4710 u32 new_clusters,
4711 u8 flags,
4712 struct ocfs2_alloc_context *meta_ac)
4713{
4714 int status;
4715 int free_records;
4716 struct buffer_head *last_eb_bh = NULL;
4717 struct ocfs2_insert_type insert = {0, };
4718 struct ocfs2_extent_rec rec;
4719
4720 trace_ocfs2_insert_extent_start(
4721 (unsigned long long)ocfs2_metadata_cache_owner(et->et_ci),
4722 cpos, new_clusters);
4723
4724 memset(&rec, 0, sizeof(rec));
4725 rec.e_cpos = cpu_to_le32(cpos);
4726 rec.e_blkno = cpu_to_le64(start_blk);
4727 rec.e_leaf_clusters = cpu_to_le16(new_clusters);
4728 rec.e_flags = flags;
4729 status = ocfs2_et_insert_check(et, &rec);
4730 if (status) {
4731 mlog_errno(status);
4732 goto bail;
4733 }
4734
4735 status = ocfs2_figure_insert_type(et, &last_eb_bh, &rec,
4736 &free_records, &insert);
4737 if (status < 0) {
4738 mlog_errno(status);
4739 goto bail;
4740 }
4741
4742 trace_ocfs2_insert_extent(insert.ins_appending, insert.ins_contig,
4743 insert.ins_contig_index, free_records,
4744 insert.ins_tree_depth);
4745
4746 if (insert.ins_contig == CONTIG_NONE && free_records == 0) {
4747 status = ocfs2_grow_tree(handle, et,
4748 &insert.ins_tree_depth, &last_eb_bh,
4749 meta_ac);
4750 if (status) {
4751 mlog_errno(status);
4752 goto bail;
4753 }
4754 }
4755
4756 /* Finally, we can add clusters. This might rotate the tree for us. */
4757 status = ocfs2_do_insert_extent(handle, et, &rec, &insert);
4758 if (status < 0)
4759 mlog_errno(status);
4760 else
4761 ocfs2_et_extent_map_insert(et, &rec);
4762
4763bail:
4764 brelse(last_eb_bh);
4765
4766 return status;
4767}
4768
4769/*
4770 * Allcate and add clusters into the extent b-tree.
4771 * The new clusters(clusters_to_add) will be inserted at logical_offset.
4772 * The extent b-tree's root is specified by et, and
4773 * it is not limited to the file storage. Any extent tree can use this
4774 * function if it implements the proper ocfs2_extent_tree.
4775 */
4776int ocfs2_add_clusters_in_btree(handle_t *handle,
4777 struct ocfs2_extent_tree *et,
4778 u32 *logical_offset,
4779 u32 clusters_to_add,
4780 int mark_unwritten,
4781 struct ocfs2_alloc_context *data_ac,
4782 struct ocfs2_alloc_context *meta_ac,
4783 enum ocfs2_alloc_restarted *reason_ret)
4784{
4785 int status = 0, err = 0;
4786 int need_free = 0;
4787 int free_extents;
4788 enum ocfs2_alloc_restarted reason = RESTART_NONE;
4789 u32 bit_off, num_bits;
4790 u64 block;
4791 u8 flags = 0;
4792 struct ocfs2_super *osb =
4793 OCFS2_SB(ocfs2_metadata_cache_get_super(et->et_ci));
4794
4795 BUG_ON(!clusters_to_add);
4796
4797 if (mark_unwritten)
4798 flags = OCFS2_EXT_UNWRITTEN;
4799
4800 free_extents = ocfs2_num_free_extents(et);
4801 if (free_extents < 0) {
4802 status = free_extents;
4803 mlog_errno(status);
4804 goto leave;
4805 }
4806
4807 /* there are two cases which could cause us to EAGAIN in the
4808 * we-need-more-metadata case:
4809 * 1) we haven't reserved *any*
4810 * 2) we are so fragmented, we've needed to add metadata too
4811 * many times. */
4812 if (!free_extents && !meta_ac) {
4813 err = -1;
4814 status = -EAGAIN;
4815 reason = RESTART_META;
4816 goto leave;
4817 } else if ((!free_extents)
4818 && (ocfs2_alloc_context_bits_left(meta_ac)
4819 < ocfs2_extend_meta_needed(et->et_root_el))) {
4820 err = -2;
4821 status = -EAGAIN;
4822 reason = RESTART_META;
4823 goto leave;
4824 }
4825
4826 status = __ocfs2_claim_clusters(handle, data_ac, 1,
4827 clusters_to_add, &bit_off, &num_bits);
4828 if (status < 0) {
4829 if (status != -ENOSPC)
4830 mlog_errno(status);
4831 goto leave;
4832 }
4833
4834 BUG_ON(num_bits > clusters_to_add);
4835
4836 /* reserve our write early -- insert_extent may update the tree root */
4837 status = ocfs2_et_root_journal_access(handle, et,
4838 OCFS2_JOURNAL_ACCESS_WRITE);
4839 if (status < 0) {
4840 mlog_errno(status);
4841 need_free = 1;
4842 goto bail;
4843 }
4844
4845 block = ocfs2_clusters_to_blocks(osb->sb, bit_off);
4846 trace_ocfs2_add_clusters_in_btree(
4847 (unsigned long long)ocfs2_metadata_cache_owner(et->et_ci),
4848 bit_off, num_bits);
4849 status = ocfs2_insert_extent(handle, et, *logical_offset, block,
4850 num_bits, flags, meta_ac);
4851 if (status < 0) {
4852 mlog_errno(status);
4853 need_free = 1;
4854 goto bail;
4855 }
4856
4857 ocfs2_journal_dirty(handle, et->et_root_bh);
4858
4859 clusters_to_add -= num_bits;
4860 *logical_offset += num_bits;
4861
4862 if (clusters_to_add) {
4863 err = clusters_to_add;
4864 status = -EAGAIN;
4865 reason = RESTART_TRANS;
4866 }
4867
4868bail:
4869 if (need_free) {
4870 if (data_ac->ac_which == OCFS2_AC_USE_LOCAL)
4871 ocfs2_free_local_alloc_bits(osb, handle, data_ac,
4872 bit_off, num_bits);
4873 else
4874 ocfs2_free_clusters(handle,
4875 data_ac->ac_inode,
4876 data_ac->ac_bh,
4877 ocfs2_clusters_to_blocks(osb->sb, bit_off),
4878 num_bits);
4879 }
4880
4881leave:
4882 if (reason_ret)
4883 *reason_ret = reason;
4884 trace_ocfs2_add_clusters_in_btree_ret(status, reason, err);
4885 return status;
4886}
4887
4888static void ocfs2_make_right_split_rec(struct super_block *sb,
4889 struct ocfs2_extent_rec *split_rec,
4890 u32 cpos,
4891 struct ocfs2_extent_rec *rec)
4892{
4893 u32 rec_cpos = le32_to_cpu(rec->e_cpos);
4894 u32 rec_range = rec_cpos + le16_to_cpu(rec->e_leaf_clusters);
4895
4896 memset(split_rec, 0, sizeof(struct ocfs2_extent_rec));
4897
4898 split_rec->e_cpos = cpu_to_le32(cpos);
4899 split_rec->e_leaf_clusters = cpu_to_le16(rec_range - cpos);
4900
4901 split_rec->e_blkno = rec->e_blkno;
4902 le64_add_cpu(&split_rec->e_blkno,
4903 ocfs2_clusters_to_blocks(sb, cpos - rec_cpos));
4904
4905 split_rec->e_flags = rec->e_flags;
4906}
4907
4908static int ocfs2_split_and_insert(handle_t *handle,
4909 struct ocfs2_extent_tree *et,
4910 struct ocfs2_path *path,
4911 struct buffer_head **last_eb_bh,
4912 int split_index,
4913 struct ocfs2_extent_rec *orig_split_rec,
4914 struct ocfs2_alloc_context *meta_ac)
4915{
4916 int ret = 0, depth;
4917 unsigned int insert_range, rec_range, do_leftright = 0;
4918 struct ocfs2_extent_rec tmprec;
4919 struct ocfs2_extent_list *rightmost_el;
4920 struct ocfs2_extent_rec rec;
4921 struct ocfs2_extent_rec split_rec = *orig_split_rec;
4922 struct ocfs2_insert_type insert;
4923 struct ocfs2_extent_block *eb;
4924
4925leftright:
4926 /*
4927 * Store a copy of the record on the stack - it might move
4928 * around as the tree is manipulated below.
4929 */
4930 rec = path_leaf_el(path)->l_recs[split_index];
4931
4932 rightmost_el = et->et_root_el;
4933
4934 depth = le16_to_cpu(rightmost_el->l_tree_depth);
4935 if (depth) {
4936 BUG_ON(!(*last_eb_bh));
4937 eb = (struct ocfs2_extent_block *) (*last_eb_bh)->b_data;
4938 rightmost_el = &eb->h_list;
4939 }
4940
4941 if (le16_to_cpu(rightmost_el->l_next_free_rec) ==
4942 le16_to_cpu(rightmost_el->l_count)) {
4943 ret = ocfs2_grow_tree(handle, et,
4944 &depth, last_eb_bh, meta_ac);
4945 if (ret) {
4946 mlog_errno(ret);
4947 goto out;
4948 }
4949 }
4950
4951 memset(&insert, 0, sizeof(struct ocfs2_insert_type));
4952 insert.ins_appending = APPEND_NONE;
4953 insert.ins_contig = CONTIG_NONE;
4954 insert.ins_tree_depth = depth;
4955
4956 insert_range = le32_to_cpu(split_rec.e_cpos) +
4957 le16_to_cpu(split_rec.e_leaf_clusters);
4958 rec_range = le32_to_cpu(rec.e_cpos) +
4959 le16_to_cpu(rec.e_leaf_clusters);
4960
4961 if (split_rec.e_cpos == rec.e_cpos) {
4962 insert.ins_split = SPLIT_LEFT;
4963 } else if (insert_range == rec_range) {
4964 insert.ins_split = SPLIT_RIGHT;
4965 } else {
4966 /*
4967 * Left/right split. We fake this as a right split
4968 * first and then make a second pass as a left split.
4969 */
4970 insert.ins_split = SPLIT_RIGHT;
4971
4972 ocfs2_make_right_split_rec(ocfs2_metadata_cache_get_super(et->et_ci),
4973 &tmprec, insert_range, &rec);
4974
4975 split_rec = tmprec;
4976
4977 BUG_ON(do_leftright);
4978 do_leftright = 1;
4979 }
4980
4981 ret = ocfs2_do_insert_extent(handle, et, &split_rec, &insert);
4982 if (ret) {
4983 mlog_errno(ret);
4984 goto out;
4985 }
4986
4987 if (do_leftright == 1) {
4988 u32 cpos;
4989 struct ocfs2_extent_list *el;
4990
4991 do_leftright++;
4992 split_rec = *orig_split_rec;
4993
4994 ocfs2_reinit_path(path, 1);
4995
4996 cpos = le32_to_cpu(split_rec.e_cpos);
4997 ret = ocfs2_find_path(et->et_ci, path, cpos);
4998 if (ret) {
4999 mlog_errno(ret);
5000 goto out;
5001 }
5002
5003 el = path_leaf_el(path);
5004 split_index = ocfs2_search_extent_list(el, cpos);
5005 if (split_index == -1) {
5006 ocfs2_error(ocfs2_metadata_cache_get_super(et->et_ci),
5007 "Owner %llu has an extent at cpos %u which can no longer be found\n",
5008 (unsigned long long)ocfs2_metadata_cache_owner(et->et_ci),
5009 cpos);
5010 ret = -EROFS;
5011 goto out;
5012 }
5013 goto leftright;
5014 }
5015out:
5016
5017 return ret;
5018}
5019
5020static int ocfs2_replace_extent_rec(handle_t *handle,
5021 struct ocfs2_extent_tree *et,
5022 struct ocfs2_path *path,
5023 struct ocfs2_extent_list *el,
5024 int split_index,
5025 struct ocfs2_extent_rec *split_rec)
5026{
5027 int ret;
5028
5029 ret = ocfs2_path_bh_journal_access(handle, et->et_ci, path,
5030 path_num_items(path) - 1);
5031 if (ret) {
5032 mlog_errno(ret);
5033 goto out;
5034 }
5035
5036 el->l_recs[split_index] = *split_rec;
5037
5038 ocfs2_journal_dirty(handle, path_leaf_bh(path));
5039out:
5040 return ret;
5041}
5042
5043/*
5044 * Split part or all of the extent record at split_index in the leaf
5045 * pointed to by path. Merge with the contiguous extent record if needed.
5046 *
5047 * Care is taken to handle contiguousness so as to not grow the tree.
5048 *
5049 * meta_ac is not strictly necessary - we only truly need it if growth
5050 * of the tree is required. All other cases will degrade into a less
5051 * optimal tree layout.
5052 *
5053 * last_eb_bh should be the rightmost leaf block for any extent
5054 * btree. Since a split may grow the tree or a merge might shrink it,
5055 * the caller cannot trust the contents of that buffer after this call.
5056 *
5057 * This code is optimized for readability - several passes might be
5058 * made over certain portions of the tree. All of those blocks will
5059 * have been brought into cache (and pinned via the journal), so the
5060 * extra overhead is not expressed in terms of disk reads.
5061 */
5062int ocfs2_split_extent(handle_t *handle,
5063 struct ocfs2_extent_tree *et,
5064 struct ocfs2_path *path,
5065 int split_index,
5066 struct ocfs2_extent_rec *split_rec,
5067 struct ocfs2_alloc_context *meta_ac,
5068 struct ocfs2_cached_dealloc_ctxt *dealloc)
5069{
5070 int ret = 0;
5071 struct ocfs2_extent_list *el = path_leaf_el(path);
5072 struct buffer_head *last_eb_bh = NULL;
5073 struct ocfs2_extent_rec *rec = &el->l_recs[split_index];
5074 struct ocfs2_merge_ctxt ctxt;
5075
5076 if (le32_to_cpu(rec->e_cpos) > le32_to_cpu(split_rec->e_cpos) ||
5077 ((le32_to_cpu(rec->e_cpos) + le16_to_cpu(rec->e_leaf_clusters)) <
5078 (le32_to_cpu(split_rec->e_cpos) + le16_to_cpu(split_rec->e_leaf_clusters)))) {
5079 ret = -EIO;
5080 mlog_errno(ret);
5081 goto out;
5082 }
5083
5084 ret = ocfs2_figure_merge_contig_type(et, path, el,
5085 split_index,
5086 split_rec,
5087 &ctxt);
5088 if (ret) {
5089 mlog_errno(ret);
5090 goto out;
5091 }
5092
5093 /*
5094 * The core merge / split code wants to know how much room is
5095 * left in this allocation tree, so we pass the
5096 * rightmost extent list.
5097 */
5098 if (path->p_tree_depth) {
5099 ret = ocfs2_read_extent_block(et->et_ci,
5100 ocfs2_et_get_last_eb_blk(et),
5101 &last_eb_bh);
5102 if (ret) {
5103 mlog_errno(ret);
5104 goto out;
5105 }
5106 }
5107
5108 if (rec->e_cpos == split_rec->e_cpos &&
5109 rec->e_leaf_clusters == split_rec->e_leaf_clusters)
5110 ctxt.c_split_covers_rec = 1;
5111 else
5112 ctxt.c_split_covers_rec = 0;
5113
5114 ctxt.c_has_empty_extent = ocfs2_is_empty_extent(&el->l_recs[0]);
5115
5116 trace_ocfs2_split_extent(split_index, ctxt.c_contig_type,
5117 ctxt.c_has_empty_extent,
5118 ctxt.c_split_covers_rec);
5119
5120 if (ctxt.c_contig_type == CONTIG_NONE) {
5121 if (ctxt.c_split_covers_rec)
5122 ret = ocfs2_replace_extent_rec(handle, et, path, el,
5123 split_index, split_rec);
5124 else
5125 ret = ocfs2_split_and_insert(handle, et, path,
5126 &last_eb_bh, split_index,
5127 split_rec, meta_ac);
5128 if (ret)
5129 mlog_errno(ret);
5130 } else {
5131 ret = ocfs2_try_to_merge_extent(handle, et, path,
5132 split_index, split_rec,
5133 dealloc, &ctxt);
5134 if (ret)
5135 mlog_errno(ret);
5136 }
5137
5138out:
5139 brelse(last_eb_bh);
5140 return ret;
5141}
5142
5143/*
5144 * Change the flags of the already-existing extent at cpos for len clusters.
5145 *
5146 * new_flags: the flags we want to set.
5147 * clear_flags: the flags we want to clear.
5148 * phys: the new physical offset we want this new extent starts from.
5149 *
5150 * If the existing extent is larger than the request, initiate a
5151 * split. An attempt will be made at merging with adjacent extents.
5152 *
5153 * The caller is responsible for passing down meta_ac if we'll need it.
5154 */
5155int ocfs2_change_extent_flag(handle_t *handle,
5156 struct ocfs2_extent_tree *et,
5157 u32 cpos, u32 len, u32 phys,
5158 struct ocfs2_alloc_context *meta_ac,
5159 struct ocfs2_cached_dealloc_ctxt *dealloc,
5160 int new_flags, int clear_flags)
5161{
5162 int ret, index;
5163 struct super_block *sb = ocfs2_metadata_cache_get_super(et->et_ci);
5164 u64 start_blkno = ocfs2_clusters_to_blocks(sb, phys);
5165 struct ocfs2_extent_rec split_rec;
5166 struct ocfs2_path *left_path = NULL;
5167 struct ocfs2_extent_list *el;
5168 struct ocfs2_extent_rec *rec;
5169
5170 left_path = ocfs2_new_path_from_et(et);
5171 if (!left_path) {
5172 ret = -ENOMEM;
5173 mlog_errno(ret);
5174 goto out;
5175 }
5176
5177 ret = ocfs2_find_path(et->et_ci, left_path, cpos);
5178 if (ret) {
5179 mlog_errno(ret);
5180 goto out;
5181 }
5182 el = path_leaf_el(left_path);
5183
5184 index = ocfs2_search_extent_list(el, cpos);
5185 if (index == -1) {
5186 ocfs2_error(sb,
5187 "Owner %llu has an extent at cpos %u which can no longer be found\n",
5188 (unsigned long long)ocfs2_metadata_cache_owner(et->et_ci),
5189 cpos);
5190 ret = -EROFS;
5191 goto out;
5192 }
5193
5194 ret = -EIO;
5195 rec = &el->l_recs[index];
5196 if (new_flags && (rec->e_flags & new_flags)) {
5197 mlog(ML_ERROR, "Owner %llu tried to set %d flags on an "
5198 "extent that already had them\n",
5199 (unsigned long long)ocfs2_metadata_cache_owner(et->et_ci),
5200 new_flags);
5201 goto out;
5202 }
5203
5204 if (clear_flags && !(rec->e_flags & clear_flags)) {
5205 mlog(ML_ERROR, "Owner %llu tried to clear %d flags on an "
5206 "extent that didn't have them\n",
5207 (unsigned long long)ocfs2_metadata_cache_owner(et->et_ci),
5208 clear_flags);
5209 goto out;
5210 }
5211
5212 memset(&split_rec, 0, sizeof(struct ocfs2_extent_rec));
5213 split_rec.e_cpos = cpu_to_le32(cpos);
5214 split_rec.e_leaf_clusters = cpu_to_le16(len);
5215 split_rec.e_blkno = cpu_to_le64(start_blkno);
5216 split_rec.e_flags = rec->e_flags;
5217 if (new_flags)
5218 split_rec.e_flags |= new_flags;
5219 if (clear_flags)
5220 split_rec.e_flags &= ~clear_flags;
5221
5222 ret = ocfs2_split_extent(handle, et, left_path,
5223 index, &split_rec, meta_ac,
5224 dealloc);
5225 if (ret)
5226 mlog_errno(ret);
5227
5228out:
5229 ocfs2_free_path(left_path);
5230 return ret;
5231
5232}
5233
5234/*
5235 * Mark the already-existing extent at cpos as written for len clusters.
5236 * This removes the unwritten extent flag.
5237 *
5238 * If the existing extent is larger than the request, initiate a
5239 * split. An attempt will be made at merging with adjacent extents.
5240 *
5241 * The caller is responsible for passing down meta_ac if we'll need it.
5242 */
5243int ocfs2_mark_extent_written(struct inode *inode,
5244 struct ocfs2_extent_tree *et,
5245 handle_t *handle, u32 cpos, u32 len, u32 phys,
5246 struct ocfs2_alloc_context *meta_ac,
5247 struct ocfs2_cached_dealloc_ctxt *dealloc)
5248{
5249 int ret;
5250
5251 trace_ocfs2_mark_extent_written(
5252 (unsigned long long)OCFS2_I(inode)->ip_blkno,
5253 cpos, len, phys);
5254
5255 if (!ocfs2_writes_unwritten_extents(OCFS2_SB(inode->i_sb))) {
5256 ocfs2_error(inode->i_sb, "Inode %llu has unwritten extents that are being written to, but the feature bit is not set in the super block\n",
5257 (unsigned long long)OCFS2_I(inode)->ip_blkno);
5258 ret = -EROFS;
5259 goto out;
5260 }
5261
5262 /*
5263 * XXX: This should be fixed up so that we just re-insert the
5264 * next extent records.
5265 */
5266 ocfs2_et_extent_map_truncate(et, 0);
5267
5268 ret = ocfs2_change_extent_flag(handle, et, cpos,
5269 len, phys, meta_ac, dealloc,
5270 0, OCFS2_EXT_UNWRITTEN);
5271 if (ret)
5272 mlog_errno(ret);
5273
5274out:
5275 return ret;
5276}
5277
5278static int ocfs2_split_tree(handle_t *handle, struct ocfs2_extent_tree *et,
5279 struct ocfs2_path *path,
5280 int index, u32 new_range,
5281 struct ocfs2_alloc_context *meta_ac)
5282{
5283 int ret, depth, credits;
5284 struct buffer_head *last_eb_bh = NULL;
5285 struct ocfs2_extent_block *eb;
5286 struct ocfs2_extent_list *rightmost_el, *el;
5287 struct ocfs2_extent_rec split_rec;
5288 struct ocfs2_extent_rec *rec;
5289 struct ocfs2_insert_type insert;
5290
5291 /*
5292 * Setup the record to split before we grow the tree.
5293 */
5294 el = path_leaf_el(path);
5295 rec = &el->l_recs[index];
5296 ocfs2_make_right_split_rec(ocfs2_metadata_cache_get_super(et->et_ci),
5297 &split_rec, new_range, rec);
5298
5299 depth = path->p_tree_depth;
5300 if (depth > 0) {
5301 ret = ocfs2_read_extent_block(et->et_ci,
5302 ocfs2_et_get_last_eb_blk(et),
5303 &last_eb_bh);
5304 if (ret < 0) {
5305 mlog_errno(ret);
5306 goto out;
5307 }
5308
5309 eb = (struct ocfs2_extent_block *) last_eb_bh->b_data;
5310 rightmost_el = &eb->h_list;
5311 } else
5312 rightmost_el = path_leaf_el(path);
5313
5314 credits = path->p_tree_depth +
5315 ocfs2_extend_meta_needed(et->et_root_el);
5316 ret = ocfs2_extend_trans(handle, credits);
5317 if (ret) {
5318 mlog_errno(ret);
5319 goto out;
5320 }
5321
5322 if (le16_to_cpu(rightmost_el->l_next_free_rec) ==
5323 le16_to_cpu(rightmost_el->l_count)) {
5324 ret = ocfs2_grow_tree(handle, et, &depth, &last_eb_bh,
5325 meta_ac);
5326 if (ret) {
5327 mlog_errno(ret);
5328 goto out;
5329 }
5330 }
5331
5332 memset(&insert, 0, sizeof(struct ocfs2_insert_type));
5333 insert.ins_appending = APPEND_NONE;
5334 insert.ins_contig = CONTIG_NONE;
5335 insert.ins_split = SPLIT_RIGHT;
5336 insert.ins_tree_depth = depth;
5337
5338 ret = ocfs2_do_insert_extent(handle, et, &split_rec, &insert);
5339 if (ret)
5340 mlog_errno(ret);
5341
5342out:
5343 brelse(last_eb_bh);
5344 return ret;
5345}
5346
5347static int ocfs2_truncate_rec(handle_t *handle,
5348 struct ocfs2_extent_tree *et,
5349 struct ocfs2_path *path, int index,
5350 struct ocfs2_cached_dealloc_ctxt *dealloc,
5351 u32 cpos, u32 len)
5352{
5353 int ret;
5354 u32 left_cpos, rec_range, trunc_range;
5355 int is_rightmost_tree_rec = 0;
5356 struct super_block *sb = ocfs2_metadata_cache_get_super(et->et_ci);
5357 struct ocfs2_path *left_path = NULL;
5358 struct ocfs2_extent_list *el = path_leaf_el(path);
5359 struct ocfs2_extent_rec *rec;
5360 struct ocfs2_extent_block *eb;
5361
5362 if (ocfs2_is_empty_extent(&el->l_recs[0]) && index > 0) {
5363 /* extend credit for ocfs2_remove_rightmost_path */
5364 ret = ocfs2_extend_rotate_transaction(handle, 0,
5365 jbd2_handle_buffer_credits(handle),
5366 path);
5367 if (ret) {
5368 mlog_errno(ret);
5369 goto out;
5370 }
5371
5372 ret = ocfs2_rotate_tree_left(handle, et, path, dealloc);
5373 if (ret) {
5374 mlog_errno(ret);
5375 goto out;
5376 }
5377
5378 index--;
5379 }
5380
5381 if (index == (le16_to_cpu(el->l_next_free_rec) - 1) &&
5382 path->p_tree_depth) {
5383 /*
5384 * Check whether this is the rightmost tree record. If
5385 * we remove all of this record or part of its right
5386 * edge then an update of the record lengths above it
5387 * will be required.
5388 */
5389 eb = (struct ocfs2_extent_block *)path_leaf_bh(path)->b_data;
5390 if (eb->h_next_leaf_blk == 0)
5391 is_rightmost_tree_rec = 1;
5392 }
5393
5394 rec = &el->l_recs[index];
5395 if (index == 0 && path->p_tree_depth &&
5396 le32_to_cpu(rec->e_cpos) == cpos) {
5397 /*
5398 * Changing the leftmost offset (via partial or whole
5399 * record truncate) of an interior (or rightmost) path
5400 * means we have to update the subtree that is formed
5401 * by this leaf and the one to it's left.
5402 *
5403 * There are two cases we can skip:
5404 * 1) Path is the leftmost one in our btree.
5405 * 2) The leaf is rightmost and will be empty after
5406 * we remove the extent record - the rotate code
5407 * knows how to update the newly formed edge.
5408 */
5409
5410 ret = ocfs2_find_cpos_for_left_leaf(sb, path, &left_cpos);
5411 if (ret) {
5412 mlog_errno(ret);
5413 goto out;
5414 }
5415
5416 if (left_cpos && le16_to_cpu(el->l_next_free_rec) > 1) {
5417 left_path = ocfs2_new_path_from_path(path);
5418 if (!left_path) {
5419 ret = -ENOMEM;
5420 mlog_errno(ret);
5421 goto out;
5422 }
5423
5424 ret = ocfs2_find_path(et->et_ci, left_path,
5425 left_cpos);
5426 if (ret) {
5427 mlog_errno(ret);
5428 goto out;
5429 }
5430 }
5431 }
5432
5433 ret = ocfs2_extend_rotate_transaction(handle, 0,
5434 jbd2_handle_buffer_credits(handle),
5435 path);
5436 if (ret) {
5437 mlog_errno(ret);
5438 goto out;
5439 }
5440
5441 ret = ocfs2_journal_access_path(et->et_ci, handle, path);
5442 if (ret) {
5443 mlog_errno(ret);
5444 goto out;
5445 }
5446
5447 ret = ocfs2_journal_access_path(et->et_ci, handle, left_path);
5448 if (ret) {
5449 mlog_errno(ret);
5450 goto out;
5451 }
5452
5453 rec_range = le32_to_cpu(rec->e_cpos) + ocfs2_rec_clusters(el, rec);
5454 trunc_range = cpos + len;
5455
5456 if (le32_to_cpu(rec->e_cpos) == cpos && rec_range == trunc_range) {
5457 int next_free;
5458
5459 memset(rec, 0, sizeof(*rec));
5460 ocfs2_cleanup_merge(el, index);
5461
5462 next_free = le16_to_cpu(el->l_next_free_rec);
5463 if (is_rightmost_tree_rec && next_free > 1) {
5464 /*
5465 * We skip the edge update if this path will
5466 * be deleted by the rotate code.
5467 */
5468 rec = &el->l_recs[next_free - 1];
5469 ocfs2_adjust_rightmost_records(handle, et, path,
5470 rec);
5471 }
5472 } else if (le32_to_cpu(rec->e_cpos) == cpos) {
5473 /* Remove leftmost portion of the record. */
5474 le32_add_cpu(&rec->e_cpos, len);
5475 le64_add_cpu(&rec->e_blkno, ocfs2_clusters_to_blocks(sb, len));
5476 le16_add_cpu(&rec->e_leaf_clusters, -len);
5477 } else if (rec_range == trunc_range) {
5478 /* Remove rightmost portion of the record */
5479 le16_add_cpu(&rec->e_leaf_clusters, -len);
5480 if (is_rightmost_tree_rec)
5481 ocfs2_adjust_rightmost_records(handle, et, path, rec);
5482 } else {
5483 /* Caller should have trapped this. */
5484 mlog(ML_ERROR, "Owner %llu: Invalid record truncate: (%u, %u) "
5485 "(%u, %u)\n",
5486 (unsigned long long)ocfs2_metadata_cache_owner(et->et_ci),
5487 le32_to_cpu(rec->e_cpos),
5488 le16_to_cpu(rec->e_leaf_clusters), cpos, len);
5489 BUG();
5490 }
5491
5492 if (left_path) {
5493 int subtree_index;
5494
5495 subtree_index = ocfs2_find_subtree_root(et, left_path, path);
5496 ocfs2_complete_edge_insert(handle, left_path, path,
5497 subtree_index);
5498 }
5499
5500 ocfs2_journal_dirty(handle, path_leaf_bh(path));
5501
5502 ret = ocfs2_rotate_tree_left(handle, et, path, dealloc);
5503 if (ret)
5504 mlog_errno(ret);
5505
5506out:
5507 ocfs2_free_path(left_path);
5508 return ret;
5509}
5510
5511int ocfs2_remove_extent(handle_t *handle,
5512 struct ocfs2_extent_tree *et,
5513 u32 cpos, u32 len,
5514 struct ocfs2_alloc_context *meta_ac,
5515 struct ocfs2_cached_dealloc_ctxt *dealloc)
5516{
5517 int ret, index;
5518 u32 rec_range, trunc_range;
5519 struct ocfs2_extent_rec *rec;
5520 struct ocfs2_extent_list *el;
5521 struct ocfs2_path *path = NULL;
5522
5523 /*
5524 * XXX: Why are we truncating to 0 instead of wherever this
5525 * affects us?
5526 */
5527 ocfs2_et_extent_map_truncate(et, 0);
5528
5529 path = ocfs2_new_path_from_et(et);
5530 if (!path) {
5531 ret = -ENOMEM;
5532 mlog_errno(ret);
5533 goto out;
5534 }
5535
5536 ret = ocfs2_find_path(et->et_ci, path, cpos);
5537 if (ret) {
5538 mlog_errno(ret);
5539 goto out;
5540 }
5541
5542 el = path_leaf_el(path);
5543 index = ocfs2_search_extent_list(el, cpos);
5544 if (index == -1) {
5545 ocfs2_error(ocfs2_metadata_cache_get_super(et->et_ci),
5546 "Owner %llu has an extent at cpos %u which can no longer be found\n",
5547 (unsigned long long)ocfs2_metadata_cache_owner(et->et_ci),
5548 cpos);
5549 ret = -EROFS;
5550 goto out;
5551 }
5552
5553 /*
5554 * We have 3 cases of extent removal:
5555 * 1) Range covers the entire extent rec
5556 * 2) Range begins or ends on one edge of the extent rec
5557 * 3) Range is in the middle of the extent rec (no shared edges)
5558 *
5559 * For case 1 we remove the extent rec and left rotate to
5560 * fill the hole.
5561 *
5562 * For case 2 we just shrink the existing extent rec, with a
5563 * tree update if the shrinking edge is also the edge of an
5564 * extent block.
5565 *
5566 * For case 3 we do a right split to turn the extent rec into
5567 * something case 2 can handle.
5568 */
5569 rec = &el->l_recs[index];
5570 rec_range = le32_to_cpu(rec->e_cpos) + ocfs2_rec_clusters(el, rec);
5571 trunc_range = cpos + len;
5572
5573 BUG_ON(cpos < le32_to_cpu(rec->e_cpos) || trunc_range > rec_range);
5574
5575 trace_ocfs2_remove_extent(
5576 (unsigned long long)ocfs2_metadata_cache_owner(et->et_ci),
5577 cpos, len, index, le32_to_cpu(rec->e_cpos),
5578 ocfs2_rec_clusters(el, rec));
5579
5580 if (le32_to_cpu(rec->e_cpos) == cpos || rec_range == trunc_range) {
5581 ret = ocfs2_truncate_rec(handle, et, path, index, dealloc,
5582 cpos, len);
5583 if (ret) {
5584 mlog_errno(ret);
5585 goto out;
5586 }
5587 } else {
5588 ret = ocfs2_split_tree(handle, et, path, index,
5589 trunc_range, meta_ac);
5590 if (ret) {
5591 mlog_errno(ret);
5592 goto out;
5593 }
5594
5595 /*
5596 * The split could have manipulated the tree enough to
5597 * move the record location, so we have to look for it again.
5598 */
5599 ocfs2_reinit_path(path, 1);
5600
5601 ret = ocfs2_find_path(et->et_ci, path, cpos);
5602 if (ret) {
5603 mlog_errno(ret);
5604 goto out;
5605 }
5606
5607 el = path_leaf_el(path);
5608 index = ocfs2_search_extent_list(el, cpos);
5609 if (index == -1) {
5610 ocfs2_error(ocfs2_metadata_cache_get_super(et->et_ci),
5611 "Owner %llu: split at cpos %u lost record\n",
5612 (unsigned long long)ocfs2_metadata_cache_owner(et->et_ci),
5613 cpos);
5614 ret = -EROFS;
5615 goto out;
5616 }
5617
5618 /*
5619 * Double check our values here. If anything is fishy,
5620 * it's easier to catch it at the top level.
5621 */
5622 rec = &el->l_recs[index];
5623 rec_range = le32_to_cpu(rec->e_cpos) +
5624 ocfs2_rec_clusters(el, rec);
5625 if (rec_range != trunc_range) {
5626 ocfs2_error(ocfs2_metadata_cache_get_super(et->et_ci),
5627 "Owner %llu: error after split at cpos %u trunc len %u, existing record is (%u,%u)\n",
5628 (unsigned long long)ocfs2_metadata_cache_owner(et->et_ci),
5629 cpos, len, le32_to_cpu(rec->e_cpos),
5630 ocfs2_rec_clusters(el, rec));
5631 ret = -EROFS;
5632 goto out;
5633 }
5634
5635 ret = ocfs2_truncate_rec(handle, et, path, index, dealloc,
5636 cpos, len);
5637 if (ret)
5638 mlog_errno(ret);
5639 }
5640
5641out:
5642 ocfs2_free_path(path);
5643 return ret;
5644}
5645
5646/*
5647 * ocfs2_reserve_blocks_for_rec_trunc() would look basically the
5648 * same as ocfs2_lock_alloctors(), except for it accepts a blocks
5649 * number to reserve some extra blocks, and it only handles meta
5650 * data allocations.
5651 *
5652 * Currently, only ocfs2_remove_btree_range() uses it for truncating
5653 * and punching holes.
5654 */
5655static int ocfs2_reserve_blocks_for_rec_trunc(struct inode *inode,
5656 struct ocfs2_extent_tree *et,
5657 u32 extents_to_split,
5658 struct ocfs2_alloc_context **ac,
5659 int extra_blocks)
5660{
5661 int ret = 0, num_free_extents;
5662 unsigned int max_recs_needed = 2 * extents_to_split;
5663 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
5664
5665 *ac = NULL;
5666
5667 num_free_extents = ocfs2_num_free_extents(et);
5668 if (num_free_extents < 0) {
5669 ret = num_free_extents;
5670 mlog_errno(ret);
5671 goto out;
5672 }
5673
5674 if (!num_free_extents ||
5675 (ocfs2_sparse_alloc(osb) && num_free_extents < max_recs_needed))
5676 extra_blocks += ocfs2_extend_meta_needed(et->et_root_el);
5677
5678 if (extra_blocks) {
5679 ret = ocfs2_reserve_new_metadata_blocks(osb, extra_blocks, ac);
5680 if (ret < 0) {
5681 if (ret != -ENOSPC)
5682 mlog_errno(ret);
5683 }
5684 }
5685
5686out:
5687 if (ret) {
5688 if (*ac) {
5689 ocfs2_free_alloc_context(*ac);
5690 *ac = NULL;
5691 }
5692 }
5693
5694 return ret;
5695}
5696
5697int ocfs2_remove_btree_range(struct inode *inode,
5698 struct ocfs2_extent_tree *et,
5699 u32 cpos, u32 phys_cpos, u32 len, int flags,
5700 struct ocfs2_cached_dealloc_ctxt *dealloc,
5701 u64 refcount_loc, bool refcount_tree_locked)
5702{
5703 int ret, credits = 0, extra_blocks = 0;
5704 u64 phys_blkno = ocfs2_clusters_to_blocks(inode->i_sb, phys_cpos);
5705 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
5706 struct inode *tl_inode = osb->osb_tl_inode;
5707 handle_t *handle;
5708 struct ocfs2_alloc_context *meta_ac = NULL;
5709 struct ocfs2_refcount_tree *ref_tree = NULL;
5710
5711 if ((flags & OCFS2_EXT_REFCOUNTED) && len) {
5712 BUG_ON(!ocfs2_is_refcount_inode(inode));
5713
5714 if (!refcount_tree_locked) {
5715 ret = ocfs2_lock_refcount_tree(osb, refcount_loc, 1,
5716 &ref_tree, NULL);
5717 if (ret) {
5718 mlog_errno(ret);
5719 goto bail;
5720 }
5721 }
5722
5723 ret = ocfs2_prepare_refcount_change_for_del(inode,
5724 refcount_loc,
5725 phys_blkno,
5726 len,
5727 &credits,
5728 &extra_blocks);
5729 if (ret < 0) {
5730 mlog_errno(ret);
5731 goto bail;
5732 }
5733 }
5734
5735 ret = ocfs2_reserve_blocks_for_rec_trunc(inode, et, 1, &meta_ac,
5736 extra_blocks);
5737 if (ret) {
5738 mlog_errno(ret);
5739 goto bail;
5740 }
5741
5742 inode_lock(tl_inode);
5743
5744 if (ocfs2_truncate_log_needs_flush(osb)) {
5745 ret = __ocfs2_flush_truncate_log(osb);
5746 if (ret < 0) {
5747 mlog_errno(ret);
5748 goto out;
5749 }
5750 }
5751
5752 handle = ocfs2_start_trans(osb,
5753 ocfs2_remove_extent_credits(osb->sb) + credits);
5754 if (IS_ERR(handle)) {
5755 ret = PTR_ERR(handle);
5756 mlog_errno(ret);
5757 goto out;
5758 }
5759
5760 ret = ocfs2_et_root_journal_access(handle, et,
5761 OCFS2_JOURNAL_ACCESS_WRITE);
5762 if (ret) {
5763 mlog_errno(ret);
5764 goto out_commit;
5765 }
5766
5767 dquot_free_space_nodirty(inode,
5768 ocfs2_clusters_to_bytes(inode->i_sb, len));
5769
5770 ret = ocfs2_remove_extent(handle, et, cpos, len, meta_ac, dealloc);
5771 if (ret) {
5772 mlog_errno(ret);
5773 goto out_commit;
5774 }
5775
5776 ocfs2_et_update_clusters(et, -len);
5777 ocfs2_update_inode_fsync_trans(handle, inode, 1);
5778
5779 ocfs2_journal_dirty(handle, et->et_root_bh);
5780
5781 if (phys_blkno) {
5782 if (flags & OCFS2_EXT_REFCOUNTED)
5783 ret = ocfs2_decrease_refcount(inode, handle,
5784 ocfs2_blocks_to_clusters(osb->sb,
5785 phys_blkno),
5786 len, meta_ac,
5787 dealloc, 1);
5788 else
5789 ret = ocfs2_truncate_log_append(osb, handle,
5790 phys_blkno, len);
5791 if (ret)
5792 mlog_errno(ret);
5793
5794 }
5795
5796out_commit:
5797 ocfs2_commit_trans(osb, handle);
5798out:
5799 inode_unlock(tl_inode);
5800bail:
5801 if (meta_ac)
5802 ocfs2_free_alloc_context(meta_ac);
5803
5804 if (ref_tree)
5805 ocfs2_unlock_refcount_tree(osb, ref_tree, 1);
5806
5807 return ret;
5808}
5809
5810int ocfs2_truncate_log_needs_flush(struct ocfs2_super *osb)
5811{
5812 struct buffer_head *tl_bh = osb->osb_tl_bh;
5813 struct ocfs2_dinode *di;
5814 struct ocfs2_truncate_log *tl;
5815
5816 di = (struct ocfs2_dinode *) tl_bh->b_data;
5817 tl = &di->id2.i_dealloc;
5818
5819 mlog_bug_on_msg(le16_to_cpu(tl->tl_used) > le16_to_cpu(tl->tl_count),
5820 "slot %d, invalid truncate log parameters: used = "
5821 "%u, count = %u\n", osb->slot_num,
5822 le16_to_cpu(tl->tl_used), le16_to_cpu(tl->tl_count));
5823 return le16_to_cpu(tl->tl_used) == le16_to_cpu(tl->tl_count);
5824}
5825
5826static int ocfs2_truncate_log_can_coalesce(struct ocfs2_truncate_log *tl,
5827 unsigned int new_start)
5828{
5829 unsigned int tail_index;
5830 unsigned int current_tail;
5831
5832 /* No records, nothing to coalesce */
5833 if (!le16_to_cpu(tl->tl_used))
5834 return 0;
5835
5836 tail_index = le16_to_cpu(tl->tl_used) - 1;
5837 current_tail = le32_to_cpu(tl->tl_recs[tail_index].t_start);
5838 current_tail += le32_to_cpu(tl->tl_recs[tail_index].t_clusters);
5839
5840 return current_tail == new_start;
5841}
5842
5843int ocfs2_truncate_log_append(struct ocfs2_super *osb,
5844 handle_t *handle,
5845 u64 start_blk,
5846 unsigned int num_clusters)
5847{
5848 int status, index;
5849 unsigned int start_cluster, tl_count;
5850 struct inode *tl_inode = osb->osb_tl_inode;
5851 struct buffer_head *tl_bh = osb->osb_tl_bh;
5852 struct ocfs2_dinode *di;
5853 struct ocfs2_truncate_log *tl;
5854
5855 BUG_ON(inode_trylock(tl_inode));
5856
5857 start_cluster = ocfs2_blocks_to_clusters(osb->sb, start_blk);
5858
5859 di = (struct ocfs2_dinode *) tl_bh->b_data;
5860
5861 /* tl_bh is loaded from ocfs2_truncate_log_init(). It's validated
5862 * by the underlying call to ocfs2_read_inode_block(), so any
5863 * corruption is a code bug */
5864 BUG_ON(!OCFS2_IS_VALID_DINODE(di));
5865
5866 tl = &di->id2.i_dealloc;
5867 tl_count = le16_to_cpu(tl->tl_count);
5868 mlog_bug_on_msg(tl_count > ocfs2_truncate_recs_per_inode(osb->sb) ||
5869 tl_count == 0,
5870 "Truncate record count on #%llu invalid "
5871 "wanted %u, actual %u\n",
5872 (unsigned long long)OCFS2_I(tl_inode)->ip_blkno,
5873 ocfs2_truncate_recs_per_inode(osb->sb),
5874 le16_to_cpu(tl->tl_count));
5875
5876 /* Caller should have known to flush before calling us. */
5877 index = le16_to_cpu(tl->tl_used);
5878 if (index >= tl_count) {
5879 status = -ENOSPC;
5880 mlog_errno(status);
5881 goto bail;
5882 }
5883
5884 status = ocfs2_journal_access_di(handle, INODE_CACHE(tl_inode), tl_bh,
5885 OCFS2_JOURNAL_ACCESS_WRITE);
5886 if (status < 0) {
5887 mlog_errno(status);
5888 goto bail;
5889 }
5890
5891 trace_ocfs2_truncate_log_append(
5892 (unsigned long long)OCFS2_I(tl_inode)->ip_blkno, index,
5893 start_cluster, num_clusters);
5894 if (ocfs2_truncate_log_can_coalesce(tl, start_cluster)) {
5895 /*
5896 * Move index back to the record we are coalescing with.
5897 * ocfs2_truncate_log_can_coalesce() guarantees nonzero
5898 */
5899 index--;
5900
5901 num_clusters += le32_to_cpu(tl->tl_recs[index].t_clusters);
5902 trace_ocfs2_truncate_log_append(
5903 (unsigned long long)OCFS2_I(tl_inode)->ip_blkno,
5904 index, le32_to_cpu(tl->tl_recs[index].t_start),
5905 num_clusters);
5906 } else {
5907 tl->tl_recs[index].t_start = cpu_to_le32(start_cluster);
5908 tl->tl_used = cpu_to_le16(index + 1);
5909 }
5910 tl->tl_recs[index].t_clusters = cpu_to_le32(num_clusters);
5911
5912 ocfs2_journal_dirty(handle, tl_bh);
5913
5914 osb->truncated_clusters += num_clusters;
5915bail:
5916 return status;
5917}
5918
5919static int ocfs2_replay_truncate_records(struct ocfs2_super *osb,
5920 struct inode *data_alloc_inode,
5921 struct buffer_head *data_alloc_bh)
5922{
5923 int status = 0;
5924 int i;
5925 unsigned int num_clusters;
5926 u64 start_blk;
5927 struct ocfs2_truncate_rec rec;
5928 struct ocfs2_dinode *di;
5929 struct ocfs2_truncate_log *tl;
5930 struct inode *tl_inode = osb->osb_tl_inode;
5931 struct buffer_head *tl_bh = osb->osb_tl_bh;
5932 handle_t *handle;
5933
5934 di = (struct ocfs2_dinode *) tl_bh->b_data;
5935 tl = &di->id2.i_dealloc;
5936 i = le16_to_cpu(tl->tl_used) - 1;
5937 while (i >= 0) {
5938 handle = ocfs2_start_trans(osb, OCFS2_TRUNCATE_LOG_FLUSH_ONE_REC);
5939 if (IS_ERR(handle)) {
5940 status = PTR_ERR(handle);
5941 mlog_errno(status);
5942 goto bail;
5943 }
5944
5945 /* Caller has given us at least enough credits to
5946 * update the truncate log dinode */
5947 status = ocfs2_journal_access_di(handle, INODE_CACHE(tl_inode), tl_bh,
5948 OCFS2_JOURNAL_ACCESS_WRITE);
5949 if (status < 0) {
5950 ocfs2_commit_trans(osb, handle);
5951 mlog_errno(status);
5952 goto bail;
5953 }
5954
5955 tl->tl_used = cpu_to_le16(i);
5956
5957 ocfs2_journal_dirty(handle, tl_bh);
5958
5959 rec = tl->tl_recs[i];
5960 start_blk = ocfs2_clusters_to_blocks(data_alloc_inode->i_sb,
5961 le32_to_cpu(rec.t_start));
5962 num_clusters = le32_to_cpu(rec.t_clusters);
5963
5964 /* if start_blk is not set, we ignore the record as
5965 * invalid. */
5966 if (start_blk) {
5967 trace_ocfs2_replay_truncate_records(
5968 (unsigned long long)OCFS2_I(tl_inode)->ip_blkno,
5969 i, le32_to_cpu(rec.t_start), num_clusters);
5970
5971 status = ocfs2_free_clusters(handle, data_alloc_inode,
5972 data_alloc_bh, start_blk,
5973 num_clusters);
5974 if (status < 0) {
5975 ocfs2_commit_trans(osb, handle);
5976 mlog_errno(status);
5977 goto bail;
5978 }
5979 }
5980
5981 ocfs2_commit_trans(osb, handle);
5982 i--;
5983 }
5984
5985 osb->truncated_clusters = 0;
5986
5987bail:
5988 return status;
5989}
5990
5991/* Expects you to already be holding tl_inode->i_rwsem */
5992int __ocfs2_flush_truncate_log(struct ocfs2_super *osb)
5993{
5994 int status;
5995 unsigned int num_to_flush;
5996 struct inode *tl_inode = osb->osb_tl_inode;
5997 struct inode *data_alloc_inode = NULL;
5998 struct buffer_head *tl_bh = osb->osb_tl_bh;
5999 struct buffer_head *data_alloc_bh = NULL;
6000 struct ocfs2_dinode *di;
6001 struct ocfs2_truncate_log *tl;
6002 struct ocfs2_journal *journal = osb->journal;
6003
6004 BUG_ON(inode_trylock(tl_inode));
6005
6006 di = (struct ocfs2_dinode *) tl_bh->b_data;
6007
6008 /* tl_bh is loaded from ocfs2_truncate_log_init(). It's validated
6009 * by the underlying call to ocfs2_read_inode_block(), so any
6010 * corruption is a code bug */
6011 BUG_ON(!OCFS2_IS_VALID_DINODE(di));
6012
6013 tl = &di->id2.i_dealloc;
6014 num_to_flush = le16_to_cpu(tl->tl_used);
6015 trace_ocfs2_flush_truncate_log(
6016 (unsigned long long)OCFS2_I(tl_inode)->ip_blkno,
6017 num_to_flush);
6018 if (!num_to_flush) {
6019 status = 0;
6020 goto out;
6021 }
6022
6023 /* Appending truncate log(TA) and flushing truncate log(TF) are
6024 * two separated transactions. They can be both committed but not
6025 * checkpointed. If crash occurs then, both two transaction will be
6026 * replayed with several already released to global bitmap clusters.
6027 * Then truncate log will be replayed resulting in cluster double free.
6028 */
6029 jbd2_journal_lock_updates(journal->j_journal);
6030 status = jbd2_journal_flush(journal->j_journal, 0);
6031 jbd2_journal_unlock_updates(journal->j_journal);
6032 if (status < 0) {
6033 mlog_errno(status);
6034 goto out;
6035 }
6036
6037 data_alloc_inode = ocfs2_get_system_file_inode(osb,
6038 GLOBAL_BITMAP_SYSTEM_INODE,
6039 OCFS2_INVALID_SLOT);
6040 if (!data_alloc_inode) {
6041 status = -EINVAL;
6042 mlog(ML_ERROR, "Could not get bitmap inode!\n");
6043 goto out;
6044 }
6045
6046 inode_lock(data_alloc_inode);
6047
6048 status = ocfs2_inode_lock(data_alloc_inode, &data_alloc_bh, 1);
6049 if (status < 0) {
6050 mlog_errno(status);
6051 goto out_mutex;
6052 }
6053
6054 status = ocfs2_replay_truncate_records(osb, data_alloc_inode,
6055 data_alloc_bh);
6056 if (status < 0)
6057 mlog_errno(status);
6058
6059 brelse(data_alloc_bh);
6060 ocfs2_inode_unlock(data_alloc_inode, 1);
6061
6062out_mutex:
6063 inode_unlock(data_alloc_inode);
6064 iput(data_alloc_inode);
6065
6066out:
6067 return status;
6068}
6069
6070int ocfs2_flush_truncate_log(struct ocfs2_super *osb)
6071{
6072 int status;
6073 struct inode *tl_inode = osb->osb_tl_inode;
6074
6075 inode_lock(tl_inode);
6076 status = __ocfs2_flush_truncate_log(osb);
6077 inode_unlock(tl_inode);
6078
6079 return status;
6080}
6081
6082static void ocfs2_truncate_log_worker(struct work_struct *work)
6083{
6084 int status;
6085 struct ocfs2_super *osb =
6086 container_of(work, struct ocfs2_super,
6087 osb_truncate_log_wq.work);
6088
6089 status = ocfs2_flush_truncate_log(osb);
6090 if (status < 0)
6091 mlog_errno(status);
6092 else
6093 ocfs2_init_steal_slots(osb);
6094}
6095
6096#define OCFS2_TRUNCATE_LOG_FLUSH_INTERVAL (2 * HZ)
6097void ocfs2_schedule_truncate_log_flush(struct ocfs2_super *osb,
6098 int cancel)
6099{
6100 if (osb->osb_tl_inode &&
6101 atomic_read(&osb->osb_tl_disable) == 0) {
6102 /* We want to push off log flushes while truncates are
6103 * still running. */
6104 if (cancel)
6105 cancel_delayed_work(&osb->osb_truncate_log_wq);
6106
6107 queue_delayed_work(osb->ocfs2_wq, &osb->osb_truncate_log_wq,
6108 OCFS2_TRUNCATE_LOG_FLUSH_INTERVAL);
6109 }
6110}
6111
6112/*
6113 * Try to flush truncate logs if we can free enough clusters from it.
6114 * As for return value, "< 0" means error, "0" no space and "1" means
6115 * we have freed enough spaces and let the caller try to allocate again.
6116 */
6117int ocfs2_try_to_free_truncate_log(struct ocfs2_super *osb,
6118 unsigned int needed)
6119{
6120 tid_t target;
6121 int ret = 0;
6122 unsigned int truncated_clusters;
6123
6124 inode_lock(osb->osb_tl_inode);
6125 truncated_clusters = osb->truncated_clusters;
6126 inode_unlock(osb->osb_tl_inode);
6127
6128 /*
6129 * Check whether we can succeed in allocating if we free
6130 * the truncate log.
6131 */
6132 if (truncated_clusters < needed)
6133 goto out;
6134
6135 ret = ocfs2_flush_truncate_log(osb);
6136 if (ret) {
6137 mlog_errno(ret);
6138 goto out;
6139 }
6140
6141 if (jbd2_journal_start_commit(osb->journal->j_journal, &target)) {
6142 jbd2_log_wait_commit(osb->journal->j_journal, target);
6143 ret = 1;
6144 }
6145out:
6146 return ret;
6147}
6148
6149static int ocfs2_get_truncate_log_info(struct ocfs2_super *osb,
6150 int slot_num,
6151 struct inode **tl_inode,
6152 struct buffer_head **tl_bh)
6153{
6154 int status;
6155 struct inode *inode = NULL;
6156 struct buffer_head *bh = NULL;
6157
6158 inode = ocfs2_get_system_file_inode(osb,
6159 TRUNCATE_LOG_SYSTEM_INODE,
6160 slot_num);
6161 if (!inode) {
6162 status = -EINVAL;
6163 mlog(ML_ERROR, "Could not get load truncate log inode!\n");
6164 goto bail;
6165 }
6166
6167 status = ocfs2_read_inode_block(inode, &bh);
6168 if (status < 0) {
6169 iput(inode);
6170 mlog_errno(status);
6171 goto bail;
6172 }
6173
6174 *tl_inode = inode;
6175 *tl_bh = bh;
6176bail:
6177 return status;
6178}
6179
6180/* called during the 1st stage of node recovery. we stamp a clean
6181 * truncate log and pass back a copy for processing later. if the
6182 * truncate log does not require processing, a *tl_copy is set to
6183 * NULL. */
6184int ocfs2_begin_truncate_log_recovery(struct ocfs2_super *osb,
6185 int slot_num,
6186 struct ocfs2_dinode **tl_copy)
6187{
6188 int status;
6189 struct inode *tl_inode = NULL;
6190 struct buffer_head *tl_bh = NULL;
6191 struct ocfs2_dinode *di;
6192 struct ocfs2_truncate_log *tl;
6193
6194 *tl_copy = NULL;
6195
6196 trace_ocfs2_begin_truncate_log_recovery(slot_num);
6197
6198 status = ocfs2_get_truncate_log_info(osb, slot_num, &tl_inode, &tl_bh);
6199 if (status < 0) {
6200 mlog_errno(status);
6201 goto bail;
6202 }
6203
6204 di = (struct ocfs2_dinode *) tl_bh->b_data;
6205
6206 /* tl_bh is loaded from ocfs2_get_truncate_log_info(). It's
6207 * validated by the underlying call to ocfs2_read_inode_block(),
6208 * so any corruption is a code bug */
6209 BUG_ON(!OCFS2_IS_VALID_DINODE(di));
6210
6211 tl = &di->id2.i_dealloc;
6212 if (le16_to_cpu(tl->tl_used)) {
6213 trace_ocfs2_truncate_log_recovery_num(le16_to_cpu(tl->tl_used));
6214
6215 /*
6216 * Assuming the write-out below goes well, this copy will be
6217 * passed back to recovery for processing.
6218 */
6219 *tl_copy = kmemdup(tl_bh->b_data, tl_bh->b_size, GFP_KERNEL);
6220 if (!(*tl_copy)) {
6221 status = -ENOMEM;
6222 mlog_errno(status);
6223 goto bail;
6224 }
6225
6226 /* All we need to do to clear the truncate log is set
6227 * tl_used. */
6228 tl->tl_used = 0;
6229
6230 ocfs2_compute_meta_ecc(osb->sb, tl_bh->b_data, &di->i_check);
6231 status = ocfs2_write_block(osb, tl_bh, INODE_CACHE(tl_inode));
6232 if (status < 0) {
6233 mlog_errno(status);
6234 goto bail;
6235 }
6236 }
6237
6238bail:
6239 iput(tl_inode);
6240 brelse(tl_bh);
6241
6242 if (status < 0) {
6243 kfree(*tl_copy);
6244 *tl_copy = NULL;
6245 mlog_errno(status);
6246 }
6247
6248 return status;
6249}
6250
6251int ocfs2_complete_truncate_log_recovery(struct ocfs2_super *osb,
6252 struct ocfs2_dinode *tl_copy)
6253{
6254 int status = 0;
6255 int i;
6256 unsigned int clusters, num_recs, start_cluster;
6257 u64 start_blk;
6258 handle_t *handle;
6259 struct inode *tl_inode = osb->osb_tl_inode;
6260 struct ocfs2_truncate_log *tl;
6261
6262 if (OCFS2_I(tl_inode)->ip_blkno == le64_to_cpu(tl_copy->i_blkno)) {
6263 mlog(ML_ERROR, "Asked to recover my own truncate log!\n");
6264 return -EINVAL;
6265 }
6266
6267 tl = &tl_copy->id2.i_dealloc;
6268 num_recs = le16_to_cpu(tl->tl_used);
6269 trace_ocfs2_complete_truncate_log_recovery(
6270 (unsigned long long)le64_to_cpu(tl_copy->i_blkno),
6271 num_recs);
6272
6273 inode_lock(tl_inode);
6274 for(i = 0; i < num_recs; i++) {
6275 if (ocfs2_truncate_log_needs_flush(osb)) {
6276 status = __ocfs2_flush_truncate_log(osb);
6277 if (status < 0) {
6278 mlog_errno(status);
6279 goto bail_up;
6280 }
6281 }
6282
6283 handle = ocfs2_start_trans(osb, OCFS2_TRUNCATE_LOG_UPDATE);
6284 if (IS_ERR(handle)) {
6285 status = PTR_ERR(handle);
6286 mlog_errno(status);
6287 goto bail_up;
6288 }
6289
6290 clusters = le32_to_cpu(tl->tl_recs[i].t_clusters);
6291 start_cluster = le32_to_cpu(tl->tl_recs[i].t_start);
6292 start_blk = ocfs2_clusters_to_blocks(osb->sb, start_cluster);
6293
6294 status = ocfs2_truncate_log_append(osb, handle,
6295 start_blk, clusters);
6296 ocfs2_commit_trans(osb, handle);
6297 if (status < 0) {
6298 mlog_errno(status);
6299 goto bail_up;
6300 }
6301 }
6302
6303bail_up:
6304 inode_unlock(tl_inode);
6305
6306 return status;
6307}
6308
6309void ocfs2_truncate_log_shutdown(struct ocfs2_super *osb)
6310{
6311 int status;
6312 struct inode *tl_inode = osb->osb_tl_inode;
6313
6314 atomic_set(&osb->osb_tl_disable, 1);
6315
6316 if (tl_inode) {
6317 cancel_delayed_work(&osb->osb_truncate_log_wq);
6318 flush_workqueue(osb->ocfs2_wq);
6319
6320 status = ocfs2_flush_truncate_log(osb);
6321 if (status < 0)
6322 mlog_errno(status);
6323
6324 brelse(osb->osb_tl_bh);
6325 iput(osb->osb_tl_inode);
6326 }
6327}
6328
6329int ocfs2_truncate_log_init(struct ocfs2_super *osb)
6330{
6331 int status;
6332 struct inode *tl_inode = NULL;
6333 struct buffer_head *tl_bh = NULL;
6334
6335 status = ocfs2_get_truncate_log_info(osb,
6336 osb->slot_num,
6337 &tl_inode,
6338 &tl_bh);
6339 if (status < 0)
6340 mlog_errno(status);
6341
6342 /* ocfs2_truncate_log_shutdown keys on the existence of
6343 * osb->osb_tl_inode so we don't set any of the osb variables
6344 * until we're sure all is well. */
6345 INIT_DELAYED_WORK(&osb->osb_truncate_log_wq,
6346 ocfs2_truncate_log_worker);
6347 atomic_set(&osb->osb_tl_disable, 0);
6348 osb->osb_tl_bh = tl_bh;
6349 osb->osb_tl_inode = tl_inode;
6350
6351 return status;
6352}
6353
6354/*
6355 * Delayed de-allocation of suballocator blocks.
6356 *
6357 * Some sets of block de-allocations might involve multiple suballocator inodes.
6358 *
6359 * The locking for this can get extremely complicated, especially when
6360 * the suballocator inodes to delete from aren't known until deep
6361 * within an unrelated codepath.
6362 *
6363 * ocfs2_extent_block structures are a good example of this - an inode
6364 * btree could have been grown by any number of nodes each allocating
6365 * out of their own suballoc inode.
6366 *
6367 * These structures allow the delay of block de-allocation until a
6368 * later time, when locking of multiple cluster inodes won't cause
6369 * deadlock.
6370 */
6371
6372/*
6373 * Describe a single bit freed from a suballocator. For the block
6374 * suballocators, it represents one block. For the global cluster
6375 * allocator, it represents some clusters and free_bit indicates
6376 * clusters number.
6377 */
6378struct ocfs2_cached_block_free {
6379 struct ocfs2_cached_block_free *free_next;
6380 u64 free_bg;
6381 u64 free_blk;
6382 unsigned int free_bit;
6383};
6384
6385struct ocfs2_per_slot_free_list {
6386 struct ocfs2_per_slot_free_list *f_next_suballocator;
6387 int f_inode_type;
6388 int f_slot;
6389 struct ocfs2_cached_block_free *f_first;
6390};
6391
6392static int ocfs2_free_cached_blocks(struct ocfs2_super *osb,
6393 int sysfile_type,
6394 int slot,
6395 struct ocfs2_cached_block_free *head)
6396{
6397 int ret;
6398 u64 bg_blkno;
6399 handle_t *handle;
6400 struct inode *inode;
6401 struct buffer_head *di_bh = NULL;
6402 struct ocfs2_cached_block_free *tmp;
6403
6404 inode = ocfs2_get_system_file_inode(osb, sysfile_type, slot);
6405 if (!inode) {
6406 ret = -EINVAL;
6407 mlog_errno(ret);
6408 goto out;
6409 }
6410
6411 inode_lock(inode);
6412
6413 ret = ocfs2_inode_lock(inode, &di_bh, 1);
6414 if (ret) {
6415 mlog_errno(ret);
6416 goto out_mutex;
6417 }
6418
6419 while (head) {
6420 if (head->free_bg)
6421 bg_blkno = head->free_bg;
6422 else
6423 bg_blkno = ocfs2_which_suballoc_group(head->free_blk,
6424 head->free_bit);
6425 handle = ocfs2_start_trans(osb, OCFS2_SUBALLOC_FREE);
6426 if (IS_ERR(handle)) {
6427 ret = PTR_ERR(handle);
6428 mlog_errno(ret);
6429 goto out_unlock;
6430 }
6431
6432 trace_ocfs2_free_cached_blocks(
6433 (unsigned long long)head->free_blk, head->free_bit);
6434
6435 ret = ocfs2_free_suballoc_bits(handle, inode, di_bh,
6436 head->free_bit, bg_blkno, 1);
6437 if (ret)
6438 mlog_errno(ret);
6439
6440 ocfs2_commit_trans(osb, handle);
6441
6442 tmp = head;
6443 head = head->free_next;
6444 kfree(tmp);
6445 }
6446
6447out_unlock:
6448 ocfs2_inode_unlock(inode, 1);
6449 brelse(di_bh);
6450out_mutex:
6451 inode_unlock(inode);
6452 iput(inode);
6453out:
6454 while(head) {
6455 /* Premature exit may have left some dangling items. */
6456 tmp = head;
6457 head = head->free_next;
6458 kfree(tmp);
6459 }
6460
6461 return ret;
6462}
6463
6464int ocfs2_cache_cluster_dealloc(struct ocfs2_cached_dealloc_ctxt *ctxt,
6465 u64 blkno, unsigned int bit)
6466{
6467 int ret = 0;
6468 struct ocfs2_cached_block_free *item;
6469
6470 item = kzalloc(sizeof(*item), GFP_NOFS);
6471 if (item == NULL) {
6472 ret = -ENOMEM;
6473 mlog_errno(ret);
6474 return ret;
6475 }
6476
6477 trace_ocfs2_cache_cluster_dealloc((unsigned long long)blkno, bit);
6478
6479 item->free_blk = blkno;
6480 item->free_bit = bit;
6481 item->free_next = ctxt->c_global_allocator;
6482
6483 ctxt->c_global_allocator = item;
6484 return ret;
6485}
6486
6487static int ocfs2_free_cached_clusters(struct ocfs2_super *osb,
6488 struct ocfs2_cached_block_free *head)
6489{
6490 struct ocfs2_cached_block_free *tmp;
6491 struct inode *tl_inode = osb->osb_tl_inode;
6492 handle_t *handle;
6493 int ret = 0;
6494
6495 inode_lock(tl_inode);
6496
6497 while (head) {
6498 if (ocfs2_truncate_log_needs_flush(osb)) {
6499 ret = __ocfs2_flush_truncate_log(osb);
6500 if (ret < 0) {
6501 mlog_errno(ret);
6502 break;
6503 }
6504 }
6505
6506 handle = ocfs2_start_trans(osb, OCFS2_TRUNCATE_LOG_UPDATE);
6507 if (IS_ERR(handle)) {
6508 ret = PTR_ERR(handle);
6509 mlog_errno(ret);
6510 break;
6511 }
6512
6513 ret = ocfs2_truncate_log_append(osb, handle, head->free_blk,
6514 head->free_bit);
6515
6516 ocfs2_commit_trans(osb, handle);
6517 tmp = head;
6518 head = head->free_next;
6519 kfree(tmp);
6520
6521 if (ret < 0) {
6522 mlog_errno(ret);
6523 break;
6524 }
6525 }
6526
6527 inode_unlock(tl_inode);
6528
6529 while (head) {
6530 /* Premature exit may have left some dangling items. */
6531 tmp = head;
6532 head = head->free_next;
6533 kfree(tmp);
6534 }
6535
6536 return ret;
6537}
6538
6539int ocfs2_run_deallocs(struct ocfs2_super *osb,
6540 struct ocfs2_cached_dealloc_ctxt *ctxt)
6541{
6542 int ret = 0, ret2;
6543 struct ocfs2_per_slot_free_list *fl;
6544
6545 if (!ctxt)
6546 return 0;
6547
6548 while (ctxt->c_first_suballocator) {
6549 fl = ctxt->c_first_suballocator;
6550
6551 if (fl->f_first) {
6552 trace_ocfs2_run_deallocs(fl->f_inode_type,
6553 fl->f_slot);
6554 ret2 = ocfs2_free_cached_blocks(osb,
6555 fl->f_inode_type,
6556 fl->f_slot,
6557 fl->f_first);
6558 if (ret2)
6559 mlog_errno(ret2);
6560 if (!ret)
6561 ret = ret2;
6562 }
6563
6564 ctxt->c_first_suballocator = fl->f_next_suballocator;
6565 kfree(fl);
6566 }
6567
6568 if (ctxt->c_global_allocator) {
6569 ret2 = ocfs2_free_cached_clusters(osb,
6570 ctxt->c_global_allocator);
6571 if (ret2)
6572 mlog_errno(ret2);
6573 if (!ret)
6574 ret = ret2;
6575
6576 ctxt->c_global_allocator = NULL;
6577 }
6578
6579 return ret;
6580}
6581
6582static struct ocfs2_per_slot_free_list *
6583ocfs2_find_per_slot_free_list(int type,
6584 int slot,
6585 struct ocfs2_cached_dealloc_ctxt *ctxt)
6586{
6587 struct ocfs2_per_slot_free_list *fl = ctxt->c_first_suballocator;
6588
6589 while (fl) {
6590 if (fl->f_inode_type == type && fl->f_slot == slot)
6591 return fl;
6592
6593 fl = fl->f_next_suballocator;
6594 }
6595
6596 fl = kmalloc(sizeof(*fl), GFP_NOFS);
6597 if (fl) {
6598 fl->f_inode_type = type;
6599 fl->f_slot = slot;
6600 fl->f_first = NULL;
6601 fl->f_next_suballocator = ctxt->c_first_suballocator;
6602
6603 ctxt->c_first_suballocator = fl;
6604 }
6605 return fl;
6606}
6607
6608static struct ocfs2_per_slot_free_list *
6609ocfs2_find_preferred_free_list(int type,
6610 int preferred_slot,
6611 int *real_slot,
6612 struct ocfs2_cached_dealloc_ctxt *ctxt)
6613{
6614 struct ocfs2_per_slot_free_list *fl = ctxt->c_first_suballocator;
6615
6616 while (fl) {
6617 if (fl->f_inode_type == type && fl->f_slot == preferred_slot) {
6618 *real_slot = fl->f_slot;
6619 return fl;
6620 }
6621
6622 fl = fl->f_next_suballocator;
6623 }
6624
6625 /* If we can't find any free list matching preferred slot, just use
6626 * the first one.
6627 */
6628 fl = ctxt->c_first_suballocator;
6629 *real_slot = fl->f_slot;
6630
6631 return fl;
6632}
6633
6634/* Return Value 1 indicates empty */
6635static int ocfs2_is_dealloc_empty(struct ocfs2_extent_tree *et)
6636{
6637 struct ocfs2_per_slot_free_list *fl = NULL;
6638
6639 if (!et->et_dealloc)
6640 return 1;
6641
6642 fl = et->et_dealloc->c_first_suballocator;
6643 if (!fl)
6644 return 1;
6645
6646 if (!fl->f_first)
6647 return 1;
6648
6649 return 0;
6650}
6651
6652/* If extent was deleted from tree due to extent rotation and merging, and
6653 * no metadata is reserved ahead of time. Try to reuse some extents
6654 * just deleted. This is only used to reuse extent blocks.
6655 * It is supposed to find enough extent blocks in dealloc if our estimation
6656 * on metadata is accurate.
6657 */
6658static int ocfs2_reuse_blk_from_dealloc(handle_t *handle,
6659 struct ocfs2_extent_tree *et,
6660 struct buffer_head **new_eb_bh,
6661 int blk_wanted, int *blk_given)
6662{
6663 int i, status = 0, real_slot;
6664 struct ocfs2_cached_dealloc_ctxt *dealloc;
6665 struct ocfs2_per_slot_free_list *fl;
6666 struct ocfs2_cached_block_free *bf;
6667 struct ocfs2_extent_block *eb;
6668 struct ocfs2_super *osb =
6669 OCFS2_SB(ocfs2_metadata_cache_get_super(et->et_ci));
6670
6671 *blk_given = 0;
6672
6673 /* If extent tree doesn't have a dealloc, this is not faulty. Just
6674 * tell upper caller dealloc can't provide any block and it should
6675 * ask for alloc to claim more space.
6676 */
6677 dealloc = et->et_dealloc;
6678 if (!dealloc)
6679 goto bail;
6680
6681 for (i = 0; i < blk_wanted; i++) {
6682 /* Prefer to use local slot */
6683 fl = ocfs2_find_preferred_free_list(EXTENT_ALLOC_SYSTEM_INODE,
6684 osb->slot_num, &real_slot,
6685 dealloc);
6686 /* If no more block can be reused, we should claim more
6687 * from alloc. Just return here normally.
6688 */
6689 if (!fl) {
6690 status = 0;
6691 break;
6692 }
6693
6694 bf = fl->f_first;
6695 fl->f_first = bf->free_next;
6696
6697 new_eb_bh[i] = sb_getblk(osb->sb, bf->free_blk);
6698 if (new_eb_bh[i] == NULL) {
6699 status = -ENOMEM;
6700 mlog_errno(status);
6701 goto bail;
6702 }
6703
6704 mlog(0, "Reusing block(%llu) from "
6705 "dealloc(local slot:%d, real slot:%d)\n",
6706 bf->free_blk, osb->slot_num, real_slot);
6707
6708 ocfs2_set_new_buffer_uptodate(et->et_ci, new_eb_bh[i]);
6709
6710 status = ocfs2_journal_access_eb(handle, et->et_ci,
6711 new_eb_bh[i],
6712 OCFS2_JOURNAL_ACCESS_CREATE);
6713 if (status < 0) {
6714 mlog_errno(status);
6715 goto bail;
6716 }
6717
6718 memset(new_eb_bh[i]->b_data, 0, osb->sb->s_blocksize);
6719 eb = (struct ocfs2_extent_block *) new_eb_bh[i]->b_data;
6720
6721 /* We can't guarantee that buffer head is still cached, so
6722 * polutlate the extent block again.
6723 */
6724 strcpy(eb->h_signature, OCFS2_EXTENT_BLOCK_SIGNATURE);
6725 eb->h_blkno = cpu_to_le64(bf->free_blk);
6726 eb->h_fs_generation = cpu_to_le32(osb->fs_generation);
6727 eb->h_suballoc_slot = cpu_to_le16(real_slot);
6728 eb->h_suballoc_loc = cpu_to_le64(bf->free_bg);
6729 eb->h_suballoc_bit = cpu_to_le16(bf->free_bit);
6730 eb->h_list.l_count =
6731 cpu_to_le16(ocfs2_extent_recs_per_eb(osb->sb));
6732
6733 /* We'll also be dirtied by the caller, so
6734 * this isn't absolutely necessary.
6735 */
6736 ocfs2_journal_dirty(handle, new_eb_bh[i]);
6737
6738 if (!fl->f_first) {
6739 dealloc->c_first_suballocator = fl->f_next_suballocator;
6740 kfree(fl);
6741 }
6742 kfree(bf);
6743 }
6744
6745 *blk_given = i;
6746
6747bail:
6748 if (unlikely(status < 0)) {
6749 for (i = 0; i < blk_wanted; i++)
6750 brelse(new_eb_bh[i]);
6751 }
6752
6753 return status;
6754}
6755
6756int ocfs2_cache_block_dealloc(struct ocfs2_cached_dealloc_ctxt *ctxt,
6757 int type, int slot, u64 suballoc,
6758 u64 blkno, unsigned int bit)
6759{
6760 int ret;
6761 struct ocfs2_per_slot_free_list *fl;
6762 struct ocfs2_cached_block_free *item;
6763
6764 fl = ocfs2_find_per_slot_free_list(type, slot, ctxt);
6765 if (fl == NULL) {
6766 ret = -ENOMEM;
6767 mlog_errno(ret);
6768 goto out;
6769 }
6770
6771 item = kzalloc(sizeof(*item), GFP_NOFS);
6772 if (item == NULL) {
6773 ret = -ENOMEM;
6774 mlog_errno(ret);
6775 goto out;
6776 }
6777
6778 trace_ocfs2_cache_block_dealloc(type, slot,
6779 (unsigned long long)suballoc,
6780 (unsigned long long)blkno, bit);
6781
6782 item->free_bg = suballoc;
6783 item->free_blk = blkno;
6784 item->free_bit = bit;
6785 item->free_next = fl->f_first;
6786
6787 fl->f_first = item;
6788
6789 ret = 0;
6790out:
6791 return ret;
6792}
6793
6794static int ocfs2_cache_extent_block_free(struct ocfs2_cached_dealloc_ctxt *ctxt,
6795 struct ocfs2_extent_block *eb)
6796{
6797 return ocfs2_cache_block_dealloc(ctxt, EXTENT_ALLOC_SYSTEM_INODE,
6798 le16_to_cpu(eb->h_suballoc_slot),
6799 le64_to_cpu(eb->h_suballoc_loc),
6800 le64_to_cpu(eb->h_blkno),
6801 le16_to_cpu(eb->h_suballoc_bit));
6802}
6803
6804static int ocfs2_zero_func(handle_t *handle, struct buffer_head *bh)
6805{
6806 set_buffer_uptodate(bh);
6807 mark_buffer_dirty(bh);
6808 return 0;
6809}
6810
6811void ocfs2_map_and_dirty_page(struct inode *inode, handle_t *handle,
6812 unsigned int from, unsigned int to,
6813 struct page *page, int zero, u64 *phys)
6814{
6815 int ret, partial = 0;
6816 loff_t start_byte = ((loff_t)page->index << PAGE_SHIFT) + from;
6817 loff_t length = to - from;
6818
6819 ret = ocfs2_map_page_blocks(page, phys, inode, from, to, 0);
6820 if (ret)
6821 mlog_errno(ret);
6822
6823 if (zero)
6824 zero_user_segment(page, from, to);
6825
6826 /*
6827 * Need to set the buffers we zero'd into uptodate
6828 * here if they aren't - ocfs2_map_page_blocks()
6829 * might've skipped some
6830 */
6831 ret = walk_page_buffers(handle, page_buffers(page),
6832 from, to, &partial,
6833 ocfs2_zero_func);
6834 if (ret < 0)
6835 mlog_errno(ret);
6836 else if (ocfs2_should_order_data(inode)) {
6837 ret = ocfs2_jbd2_inode_add_write(handle, inode,
6838 start_byte, length);
6839 if (ret < 0)
6840 mlog_errno(ret);
6841 }
6842
6843 if (!partial)
6844 SetPageUptodate(page);
6845
6846 flush_dcache_page(page);
6847}
6848
6849static void ocfs2_zero_cluster_pages(struct inode *inode, loff_t start,
6850 loff_t end, struct page **pages,
6851 int numpages, u64 phys, handle_t *handle)
6852{
6853 int i;
6854 struct page *page;
6855 unsigned int from, to = PAGE_SIZE;
6856 struct super_block *sb = inode->i_sb;
6857
6858 BUG_ON(!ocfs2_sparse_alloc(OCFS2_SB(sb)));
6859
6860 if (numpages == 0)
6861 goto out;
6862
6863 to = PAGE_SIZE;
6864 for(i = 0; i < numpages; i++) {
6865 page = pages[i];
6866
6867 from = start & (PAGE_SIZE - 1);
6868 if ((end >> PAGE_SHIFT) == page->index)
6869 to = end & (PAGE_SIZE - 1);
6870
6871 BUG_ON(from > PAGE_SIZE);
6872 BUG_ON(to > PAGE_SIZE);
6873
6874 ocfs2_map_and_dirty_page(inode, handle, from, to, page, 1,
6875 &phys);
6876
6877 start = (page->index + 1) << PAGE_SHIFT;
6878 }
6879out:
6880 if (pages)
6881 ocfs2_unlock_and_free_pages(pages, numpages);
6882}
6883
6884int ocfs2_grab_pages(struct inode *inode, loff_t start, loff_t end,
6885 struct page **pages, int *num)
6886{
6887 int numpages, ret = 0;
6888 struct address_space *mapping = inode->i_mapping;
6889 unsigned long index;
6890 loff_t last_page_bytes;
6891
6892 BUG_ON(start > end);
6893
6894 numpages = 0;
6895 last_page_bytes = PAGE_ALIGN(end);
6896 index = start >> PAGE_SHIFT;
6897 do {
6898 pages[numpages] = find_or_create_page(mapping, index, GFP_NOFS);
6899 if (!pages[numpages]) {
6900 ret = -ENOMEM;
6901 mlog_errno(ret);
6902 goto out;
6903 }
6904
6905 numpages++;
6906 index++;
6907 } while (index < (last_page_bytes >> PAGE_SHIFT));
6908
6909out:
6910 if (ret != 0) {
6911 if (pages)
6912 ocfs2_unlock_and_free_pages(pages, numpages);
6913 numpages = 0;
6914 }
6915
6916 *num = numpages;
6917
6918 return ret;
6919}
6920
6921static int ocfs2_grab_eof_pages(struct inode *inode, loff_t start, loff_t end,
6922 struct page **pages, int *num)
6923{
6924 struct super_block *sb = inode->i_sb;
6925
6926 BUG_ON(start >> OCFS2_SB(sb)->s_clustersize_bits !=
6927 (end - 1) >> OCFS2_SB(sb)->s_clustersize_bits);
6928
6929 return ocfs2_grab_pages(inode, start, end, pages, num);
6930}
6931
6932/*
6933 * Zero partial cluster for a hole punch or truncate. This avoids exposing
6934 * nonzero data on subsequent file extends.
6935 *
6936 * We need to call this before i_size is updated on the inode because
6937 * otherwise block_write_full_folio() will skip writeout of pages past
6938 * i_size.
6939 */
6940int ocfs2_zero_range_for_truncate(struct inode *inode, handle_t *handle,
6941 u64 range_start, u64 range_end)
6942{
6943 int ret = 0, numpages;
6944 struct page **pages = NULL;
6945 u64 phys;
6946 unsigned int ext_flags;
6947 struct super_block *sb = inode->i_sb;
6948
6949 /*
6950 * File systems which don't support sparse files zero on every
6951 * extend.
6952 */
6953 if (!ocfs2_sparse_alloc(OCFS2_SB(sb)))
6954 return 0;
6955
6956 /*
6957 * Avoid zeroing pages fully beyond current i_size. It is pointless as
6958 * underlying blocks of those pages should be already zeroed out and
6959 * page writeback will skip them anyway.
6960 */
6961 range_end = min_t(u64, range_end, i_size_read(inode));
6962 if (range_start >= range_end)
6963 return 0;
6964
6965 pages = kcalloc(ocfs2_pages_per_cluster(sb),
6966 sizeof(struct page *), GFP_NOFS);
6967 if (pages == NULL) {
6968 ret = -ENOMEM;
6969 mlog_errno(ret);
6970 goto out;
6971 }
6972
6973 ret = ocfs2_extent_map_get_blocks(inode,
6974 range_start >> sb->s_blocksize_bits,
6975 &phys, NULL, &ext_flags);
6976 if (ret) {
6977 mlog_errno(ret);
6978 goto out;
6979 }
6980
6981 /*
6982 * Tail is a hole, or is marked unwritten. In either case, we
6983 * can count on read and write to return/push zero's.
6984 */
6985 if (phys == 0 || ext_flags & OCFS2_EXT_UNWRITTEN)
6986 goto out;
6987
6988 ret = ocfs2_grab_eof_pages(inode, range_start, range_end, pages,
6989 &numpages);
6990 if (ret) {
6991 mlog_errno(ret);
6992 goto out;
6993 }
6994
6995 ocfs2_zero_cluster_pages(inode, range_start, range_end, pages,
6996 numpages, phys, handle);
6997
6998 /*
6999 * Initiate writeout of the pages we zero'd here. We don't
7000 * wait on them - the truncate_inode_pages() call later will
7001 * do that for us.
7002 */
7003 ret = filemap_fdatawrite_range(inode->i_mapping, range_start,
7004 range_end - 1);
7005 if (ret)
7006 mlog_errno(ret);
7007
7008out:
7009 kfree(pages);
7010
7011 return ret;
7012}
7013
7014static void ocfs2_zero_dinode_id2_with_xattr(struct inode *inode,
7015 struct ocfs2_dinode *di)
7016{
7017 unsigned int blocksize = 1 << inode->i_sb->s_blocksize_bits;
7018 unsigned int xattrsize = le16_to_cpu(di->i_xattr_inline_size);
7019
7020 if (le16_to_cpu(di->i_dyn_features) & OCFS2_INLINE_XATTR_FL)
7021 memset(&di->id2, 0, blocksize -
7022 offsetof(struct ocfs2_dinode, id2) -
7023 xattrsize);
7024 else
7025 memset(&di->id2, 0, blocksize -
7026 offsetof(struct ocfs2_dinode, id2));
7027}
7028
7029void ocfs2_dinode_new_extent_list(struct inode *inode,
7030 struct ocfs2_dinode *di)
7031{
7032 ocfs2_zero_dinode_id2_with_xattr(inode, di);
7033 di->id2.i_list.l_tree_depth = 0;
7034 di->id2.i_list.l_next_free_rec = 0;
7035 di->id2.i_list.l_count = cpu_to_le16(
7036 ocfs2_extent_recs_per_inode_with_xattr(inode->i_sb, di));
7037}
7038
7039void ocfs2_set_inode_data_inline(struct inode *inode, struct ocfs2_dinode *di)
7040{
7041 struct ocfs2_inode_info *oi = OCFS2_I(inode);
7042 struct ocfs2_inline_data *idata = &di->id2.i_data;
7043
7044 spin_lock(&oi->ip_lock);
7045 oi->ip_dyn_features |= OCFS2_INLINE_DATA_FL;
7046 di->i_dyn_features = cpu_to_le16(oi->ip_dyn_features);
7047 spin_unlock(&oi->ip_lock);
7048
7049 /*
7050 * We clear the entire i_data structure here so that all
7051 * fields can be properly initialized.
7052 */
7053 ocfs2_zero_dinode_id2_with_xattr(inode, di);
7054
7055 idata->id_count = cpu_to_le16(
7056 ocfs2_max_inline_data_with_xattr(inode->i_sb, di));
7057}
7058
7059int ocfs2_convert_inline_data_to_extents(struct inode *inode,
7060 struct buffer_head *di_bh)
7061{
7062 int ret, has_data, num_pages = 0;
7063 int need_free = 0;
7064 u32 bit_off, num;
7065 handle_t *handle;
7066 u64 block;
7067 struct ocfs2_inode_info *oi = OCFS2_I(inode);
7068 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
7069 struct ocfs2_dinode *di = (struct ocfs2_dinode *)di_bh->b_data;
7070 struct ocfs2_alloc_context *data_ac = NULL;
7071 struct page *page = NULL;
7072 struct ocfs2_extent_tree et;
7073 int did_quota = 0;
7074
7075 has_data = i_size_read(inode) ? 1 : 0;
7076
7077 if (has_data) {
7078 ret = ocfs2_reserve_clusters(osb, 1, &data_ac);
7079 if (ret) {
7080 mlog_errno(ret);
7081 goto out;
7082 }
7083 }
7084
7085 handle = ocfs2_start_trans(osb,
7086 ocfs2_inline_to_extents_credits(osb->sb));
7087 if (IS_ERR(handle)) {
7088 ret = PTR_ERR(handle);
7089 mlog_errno(ret);
7090 goto out;
7091 }
7092
7093 ret = ocfs2_journal_access_di(handle, INODE_CACHE(inode), di_bh,
7094 OCFS2_JOURNAL_ACCESS_WRITE);
7095 if (ret) {
7096 mlog_errno(ret);
7097 goto out_commit;
7098 }
7099
7100 if (has_data) {
7101 unsigned int page_end = min_t(unsigned, PAGE_SIZE,
7102 osb->s_clustersize);
7103 u64 phys;
7104
7105 ret = dquot_alloc_space_nodirty(inode,
7106 ocfs2_clusters_to_bytes(osb->sb, 1));
7107 if (ret)
7108 goto out_commit;
7109 did_quota = 1;
7110
7111 data_ac->ac_resv = &oi->ip_la_data_resv;
7112
7113 ret = ocfs2_claim_clusters(handle, data_ac, 1, &bit_off,
7114 &num);
7115 if (ret) {
7116 mlog_errno(ret);
7117 goto out_commit;
7118 }
7119
7120 /*
7121 * Save two copies, one for insert, and one that can
7122 * be changed by ocfs2_map_and_dirty_page() below.
7123 */
7124 block = phys = ocfs2_clusters_to_blocks(inode->i_sb, bit_off);
7125
7126 ret = ocfs2_grab_eof_pages(inode, 0, page_end, &page,
7127 &num_pages);
7128 if (ret) {
7129 mlog_errno(ret);
7130 need_free = 1;
7131 goto out_commit;
7132 }
7133
7134 /*
7135 * This should populate the 1st page for us and mark
7136 * it up to date.
7137 */
7138 ret = ocfs2_read_inline_data(inode, page, di_bh);
7139 if (ret) {
7140 mlog_errno(ret);
7141 need_free = 1;
7142 goto out_unlock;
7143 }
7144
7145 ocfs2_map_and_dirty_page(inode, handle, 0, page_end, page, 0,
7146 &phys);
7147 }
7148
7149 spin_lock(&oi->ip_lock);
7150 oi->ip_dyn_features &= ~OCFS2_INLINE_DATA_FL;
7151 di->i_dyn_features = cpu_to_le16(oi->ip_dyn_features);
7152 spin_unlock(&oi->ip_lock);
7153
7154 ocfs2_update_inode_fsync_trans(handle, inode, 1);
7155 ocfs2_dinode_new_extent_list(inode, di);
7156
7157 ocfs2_journal_dirty(handle, di_bh);
7158
7159 if (has_data) {
7160 /*
7161 * An error at this point should be extremely rare. If
7162 * this proves to be false, we could always re-build
7163 * the in-inode data from our pages.
7164 */
7165 ocfs2_init_dinode_extent_tree(&et, INODE_CACHE(inode), di_bh);
7166 ret = ocfs2_insert_extent(handle, &et, 0, block, 1, 0, NULL);
7167 if (ret) {
7168 mlog_errno(ret);
7169 need_free = 1;
7170 goto out_unlock;
7171 }
7172
7173 inode->i_blocks = ocfs2_inode_sector_count(inode);
7174 }
7175
7176out_unlock:
7177 if (page)
7178 ocfs2_unlock_and_free_pages(&page, num_pages);
7179
7180out_commit:
7181 if (ret < 0 && did_quota)
7182 dquot_free_space_nodirty(inode,
7183 ocfs2_clusters_to_bytes(osb->sb, 1));
7184
7185 if (need_free) {
7186 if (data_ac->ac_which == OCFS2_AC_USE_LOCAL)
7187 ocfs2_free_local_alloc_bits(osb, handle, data_ac,
7188 bit_off, num);
7189 else
7190 ocfs2_free_clusters(handle,
7191 data_ac->ac_inode,
7192 data_ac->ac_bh,
7193 ocfs2_clusters_to_blocks(osb->sb, bit_off),
7194 num);
7195 }
7196
7197 ocfs2_commit_trans(osb, handle);
7198
7199out:
7200 if (data_ac)
7201 ocfs2_free_alloc_context(data_ac);
7202 return ret;
7203}
7204
7205/*
7206 * It is expected, that by the time you call this function,
7207 * inode->i_size and fe->i_size have been adjusted.
7208 *
7209 * WARNING: This will kfree the truncate context
7210 */
7211int ocfs2_commit_truncate(struct ocfs2_super *osb,
7212 struct inode *inode,
7213 struct buffer_head *di_bh)
7214{
7215 int status = 0, i, flags = 0;
7216 u32 new_highest_cpos, range, trunc_cpos, trunc_len, phys_cpos, coff;
7217 u64 blkno = 0;
7218 struct ocfs2_extent_list *el;
7219 struct ocfs2_extent_rec *rec;
7220 struct ocfs2_path *path = NULL;
7221 struct ocfs2_dinode *di = (struct ocfs2_dinode *)di_bh->b_data;
7222 struct ocfs2_extent_list *root_el = &(di->id2.i_list);
7223 u64 refcount_loc = le64_to_cpu(di->i_refcount_loc);
7224 struct ocfs2_extent_tree et;
7225 struct ocfs2_cached_dealloc_ctxt dealloc;
7226 struct ocfs2_refcount_tree *ref_tree = NULL;
7227
7228 ocfs2_init_dinode_extent_tree(&et, INODE_CACHE(inode), di_bh);
7229 ocfs2_init_dealloc_ctxt(&dealloc);
7230
7231 new_highest_cpos = ocfs2_clusters_for_bytes(osb->sb,
7232 i_size_read(inode));
7233
7234 path = ocfs2_new_path(di_bh, &di->id2.i_list,
7235 ocfs2_journal_access_di);
7236 if (!path) {
7237 status = -ENOMEM;
7238 mlog_errno(status);
7239 goto bail;
7240 }
7241
7242 ocfs2_extent_map_trunc(inode, new_highest_cpos);
7243
7244start:
7245 /*
7246 * Check that we still have allocation to delete.
7247 */
7248 if (OCFS2_I(inode)->ip_clusters == 0) {
7249 status = 0;
7250 goto bail;
7251 }
7252
7253 /*
7254 * Truncate always works against the rightmost tree branch.
7255 */
7256 status = ocfs2_find_path(INODE_CACHE(inode), path, UINT_MAX);
7257 if (status) {
7258 mlog_errno(status);
7259 goto bail;
7260 }
7261
7262 trace_ocfs2_commit_truncate(
7263 (unsigned long long)OCFS2_I(inode)->ip_blkno,
7264 new_highest_cpos,
7265 OCFS2_I(inode)->ip_clusters,
7266 path->p_tree_depth);
7267
7268 /*
7269 * By now, el will point to the extent list on the bottom most
7270 * portion of this tree. Only the tail record is considered in
7271 * each pass.
7272 *
7273 * We handle the following cases, in order:
7274 * - empty extent: delete the remaining branch
7275 * - remove the entire record
7276 * - remove a partial record
7277 * - no record needs to be removed (truncate has completed)
7278 */
7279 el = path_leaf_el(path);
7280 if (le16_to_cpu(el->l_next_free_rec) == 0) {
7281 ocfs2_error(inode->i_sb,
7282 "Inode %llu has empty extent block at %llu\n",
7283 (unsigned long long)OCFS2_I(inode)->ip_blkno,
7284 (unsigned long long)path_leaf_bh(path)->b_blocknr);
7285 status = -EROFS;
7286 goto bail;
7287 }
7288
7289 i = le16_to_cpu(el->l_next_free_rec) - 1;
7290 rec = &el->l_recs[i];
7291 flags = rec->e_flags;
7292 range = le32_to_cpu(rec->e_cpos) + ocfs2_rec_clusters(el, rec);
7293
7294 if (i == 0 && ocfs2_is_empty_extent(rec)) {
7295 /*
7296 * Lower levels depend on this never happening, but it's best
7297 * to check it up here before changing the tree.
7298 */
7299 if (root_el->l_tree_depth && rec->e_int_clusters == 0) {
7300 mlog(ML_ERROR, "Inode %lu has an empty "
7301 "extent record, depth %u\n", inode->i_ino,
7302 le16_to_cpu(root_el->l_tree_depth));
7303 status = ocfs2_remove_rightmost_empty_extent(osb,
7304 &et, path, &dealloc);
7305 if (status) {
7306 mlog_errno(status);
7307 goto bail;
7308 }
7309
7310 ocfs2_reinit_path(path, 1);
7311 goto start;
7312 } else {
7313 trunc_cpos = le32_to_cpu(rec->e_cpos);
7314 trunc_len = 0;
7315 blkno = 0;
7316 }
7317 } else if (le32_to_cpu(rec->e_cpos) >= new_highest_cpos) {
7318 /*
7319 * Truncate entire record.
7320 */
7321 trunc_cpos = le32_to_cpu(rec->e_cpos);
7322 trunc_len = ocfs2_rec_clusters(el, rec);
7323 blkno = le64_to_cpu(rec->e_blkno);
7324 } else if (range > new_highest_cpos) {
7325 /*
7326 * Partial truncate. it also should be
7327 * the last truncate we're doing.
7328 */
7329 trunc_cpos = new_highest_cpos;
7330 trunc_len = range - new_highest_cpos;
7331 coff = new_highest_cpos - le32_to_cpu(rec->e_cpos);
7332 blkno = le64_to_cpu(rec->e_blkno) +
7333 ocfs2_clusters_to_blocks(inode->i_sb, coff);
7334 } else {
7335 /*
7336 * Truncate completed, leave happily.
7337 */
7338 status = 0;
7339 goto bail;
7340 }
7341
7342 phys_cpos = ocfs2_blocks_to_clusters(inode->i_sb, blkno);
7343
7344 if ((flags & OCFS2_EXT_REFCOUNTED) && trunc_len && !ref_tree) {
7345 status = ocfs2_lock_refcount_tree(osb, refcount_loc, 1,
7346 &ref_tree, NULL);
7347 if (status) {
7348 mlog_errno(status);
7349 goto bail;
7350 }
7351 }
7352
7353 status = ocfs2_remove_btree_range(inode, &et, trunc_cpos,
7354 phys_cpos, trunc_len, flags, &dealloc,
7355 refcount_loc, true);
7356 if (status < 0) {
7357 mlog_errno(status);
7358 goto bail;
7359 }
7360
7361 ocfs2_reinit_path(path, 1);
7362
7363 /*
7364 * The check above will catch the case where we've truncated
7365 * away all allocation.
7366 */
7367 goto start;
7368
7369bail:
7370 if (ref_tree)
7371 ocfs2_unlock_refcount_tree(osb, ref_tree, 1);
7372
7373 ocfs2_schedule_truncate_log_flush(osb, 1);
7374
7375 ocfs2_run_deallocs(osb, &dealloc);
7376
7377 ocfs2_free_path(path);
7378
7379 return status;
7380}
7381
7382/*
7383 * 'start' is inclusive, 'end' is not.
7384 */
7385int ocfs2_truncate_inline(struct inode *inode, struct buffer_head *di_bh,
7386 unsigned int start, unsigned int end, int trunc)
7387{
7388 int ret;
7389 unsigned int numbytes;
7390 handle_t *handle;
7391 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
7392 struct ocfs2_dinode *di = (struct ocfs2_dinode *)di_bh->b_data;
7393 struct ocfs2_inline_data *idata = &di->id2.i_data;
7394
7395 /* No need to punch hole beyond i_size. */
7396 if (start >= i_size_read(inode))
7397 return 0;
7398
7399 if (end > i_size_read(inode))
7400 end = i_size_read(inode);
7401
7402 BUG_ON(start > end);
7403
7404 if (!(OCFS2_I(inode)->ip_dyn_features & OCFS2_INLINE_DATA_FL) ||
7405 !(le16_to_cpu(di->i_dyn_features) & OCFS2_INLINE_DATA_FL) ||
7406 !ocfs2_supports_inline_data(osb)) {
7407 ocfs2_error(inode->i_sb,
7408 "Inline data flags for inode %llu don't agree! Disk: 0x%x, Memory: 0x%x, Superblock: 0x%x\n",
7409 (unsigned long long)OCFS2_I(inode)->ip_blkno,
7410 le16_to_cpu(di->i_dyn_features),
7411 OCFS2_I(inode)->ip_dyn_features,
7412 osb->s_feature_incompat);
7413 ret = -EROFS;
7414 goto out;
7415 }
7416
7417 handle = ocfs2_start_trans(osb, OCFS2_INODE_UPDATE_CREDITS);
7418 if (IS_ERR(handle)) {
7419 ret = PTR_ERR(handle);
7420 mlog_errno(ret);
7421 goto out;
7422 }
7423
7424 ret = ocfs2_journal_access_di(handle, INODE_CACHE(inode), di_bh,
7425 OCFS2_JOURNAL_ACCESS_WRITE);
7426 if (ret) {
7427 mlog_errno(ret);
7428 goto out_commit;
7429 }
7430
7431 numbytes = end - start;
7432 memset(idata->id_data + start, 0, numbytes);
7433
7434 /*
7435 * No need to worry about the data page here - it's been
7436 * truncated already and inline data doesn't need it for
7437 * pushing zero's to disk, so we'll let read_folio pick it up
7438 * later.
7439 */
7440 if (trunc) {
7441 i_size_write(inode, start);
7442 di->i_size = cpu_to_le64(start);
7443 }
7444
7445 inode->i_blocks = ocfs2_inode_sector_count(inode);
7446 inode_set_mtime_to_ts(inode, inode_set_ctime_current(inode));
7447
7448 di->i_ctime = di->i_mtime = cpu_to_le64(inode_get_ctime_sec(inode));
7449 di->i_ctime_nsec = di->i_mtime_nsec = cpu_to_le32(inode_get_ctime_nsec(inode));
7450
7451 ocfs2_update_inode_fsync_trans(handle, inode, 1);
7452 ocfs2_journal_dirty(handle, di_bh);
7453
7454out_commit:
7455 ocfs2_commit_trans(osb, handle);
7456
7457out:
7458 return ret;
7459}
7460
7461static int ocfs2_trim_extent(struct super_block *sb,
7462 struct ocfs2_group_desc *gd,
7463 u64 group, u32 start, u32 count)
7464{
7465 u64 discard, bcount;
7466 struct ocfs2_super *osb = OCFS2_SB(sb);
7467
7468 bcount = ocfs2_clusters_to_blocks(sb, count);
7469 discard = ocfs2_clusters_to_blocks(sb, start);
7470
7471 /*
7472 * For the first cluster group, the gd->bg_blkno is not at the start
7473 * of the group, but at an offset from the start. If we add it while
7474 * calculating discard for first group, we will wrongly start fstrim a
7475 * few blocks after the desried start block and the range can cross
7476 * over into the next cluster group. So, add it only if this is not
7477 * the first cluster group.
7478 */
7479 if (group != osb->first_cluster_group_blkno)
7480 discard += le64_to_cpu(gd->bg_blkno);
7481
7482 trace_ocfs2_trim_extent(sb, (unsigned long long)discard, bcount);
7483
7484 return sb_issue_discard(sb, discard, bcount, GFP_NOFS, 0);
7485}
7486
7487static int ocfs2_trim_group(struct super_block *sb,
7488 struct ocfs2_group_desc *gd, u64 group,
7489 u32 start, u32 max, u32 minbits)
7490{
7491 int ret = 0, count = 0, next;
7492 void *bitmap = gd->bg_bitmap;
7493
7494 if (le16_to_cpu(gd->bg_free_bits_count) < minbits)
7495 return 0;
7496
7497 trace_ocfs2_trim_group((unsigned long long)le64_to_cpu(gd->bg_blkno),
7498 start, max, minbits);
7499
7500 while (start < max) {
7501 start = ocfs2_find_next_zero_bit(bitmap, max, start);
7502 if (start >= max)
7503 break;
7504 next = ocfs2_find_next_bit(bitmap, max, start);
7505
7506 if ((next - start) >= minbits) {
7507 ret = ocfs2_trim_extent(sb, gd, group,
7508 start, next - start);
7509 if (ret < 0) {
7510 mlog_errno(ret);
7511 break;
7512 }
7513 count += next - start;
7514 }
7515 start = next + 1;
7516
7517 if (fatal_signal_pending(current)) {
7518 count = -ERESTARTSYS;
7519 break;
7520 }
7521
7522 if ((le16_to_cpu(gd->bg_free_bits_count) - count) < minbits)
7523 break;
7524 }
7525
7526 if (ret < 0)
7527 count = ret;
7528
7529 return count;
7530}
7531
7532static
7533int ocfs2_trim_mainbm(struct super_block *sb, struct fstrim_range *range)
7534{
7535 struct ocfs2_super *osb = OCFS2_SB(sb);
7536 u64 start, len, trimmed = 0, first_group, last_group = 0, group = 0;
7537 int ret, cnt;
7538 u32 first_bit, last_bit, minlen;
7539 struct buffer_head *main_bm_bh = NULL;
7540 struct inode *main_bm_inode = NULL;
7541 struct buffer_head *gd_bh = NULL;
7542 struct ocfs2_dinode *main_bm;
7543 struct ocfs2_group_desc *gd = NULL;
7544
7545 start = range->start >> osb->s_clustersize_bits;
7546 len = range->len >> osb->s_clustersize_bits;
7547 minlen = range->minlen >> osb->s_clustersize_bits;
7548
7549 if (minlen >= osb->bitmap_cpg || range->len < sb->s_blocksize)
7550 return -EINVAL;
7551
7552 trace_ocfs2_trim_mainbm(start, len, minlen);
7553
7554next_group:
7555 main_bm_inode = ocfs2_get_system_file_inode(osb,
7556 GLOBAL_BITMAP_SYSTEM_INODE,
7557 OCFS2_INVALID_SLOT);
7558 if (!main_bm_inode) {
7559 ret = -EIO;
7560 mlog_errno(ret);
7561 goto out;
7562 }
7563
7564 inode_lock(main_bm_inode);
7565
7566 ret = ocfs2_inode_lock(main_bm_inode, &main_bm_bh, 0);
7567 if (ret < 0) {
7568 mlog_errno(ret);
7569 goto out_mutex;
7570 }
7571 main_bm = (struct ocfs2_dinode *)main_bm_bh->b_data;
7572
7573 /*
7574 * Do some check before trim the first group.
7575 */
7576 if (!group) {
7577 if (start >= le32_to_cpu(main_bm->i_clusters)) {
7578 ret = -EINVAL;
7579 goto out_unlock;
7580 }
7581
7582 if (start + len > le32_to_cpu(main_bm->i_clusters))
7583 len = le32_to_cpu(main_bm->i_clusters) - start;
7584
7585 /*
7586 * Determine first and last group to examine based on
7587 * start and len
7588 */
7589 first_group = ocfs2_which_cluster_group(main_bm_inode, start);
7590 if (first_group == osb->first_cluster_group_blkno)
7591 first_bit = start;
7592 else
7593 first_bit = start - ocfs2_blocks_to_clusters(sb,
7594 first_group);
7595 last_group = ocfs2_which_cluster_group(main_bm_inode,
7596 start + len - 1);
7597 group = first_group;
7598 }
7599
7600 do {
7601 if (first_bit + len >= osb->bitmap_cpg)
7602 last_bit = osb->bitmap_cpg;
7603 else
7604 last_bit = first_bit + len;
7605
7606 ret = ocfs2_read_group_descriptor(main_bm_inode,
7607 main_bm, group,
7608 &gd_bh);
7609 if (ret < 0) {
7610 mlog_errno(ret);
7611 break;
7612 }
7613
7614 gd = (struct ocfs2_group_desc *)gd_bh->b_data;
7615 cnt = ocfs2_trim_group(sb, gd, group,
7616 first_bit, last_bit, minlen);
7617 brelse(gd_bh);
7618 gd_bh = NULL;
7619 if (cnt < 0) {
7620 ret = cnt;
7621 mlog_errno(ret);
7622 break;
7623 }
7624
7625 trimmed += cnt;
7626 len -= osb->bitmap_cpg - first_bit;
7627 first_bit = 0;
7628 if (group == osb->first_cluster_group_blkno)
7629 group = ocfs2_clusters_to_blocks(sb, osb->bitmap_cpg);
7630 else
7631 group += ocfs2_clusters_to_blocks(sb, osb->bitmap_cpg);
7632 } while (0);
7633
7634out_unlock:
7635 ocfs2_inode_unlock(main_bm_inode, 0);
7636 brelse(main_bm_bh);
7637 main_bm_bh = NULL;
7638out_mutex:
7639 inode_unlock(main_bm_inode);
7640 iput(main_bm_inode);
7641
7642 /*
7643 * If all the groups trim are not done or failed, but we should release
7644 * main_bm related locks for avoiding the current IO starve, then go to
7645 * trim the next group
7646 */
7647 if (ret >= 0 && group <= last_group) {
7648 cond_resched();
7649 goto next_group;
7650 }
7651out:
7652 range->len = trimmed * osb->s_clustersize;
7653 return ret;
7654}
7655
7656int ocfs2_trim_fs(struct super_block *sb, struct fstrim_range *range)
7657{
7658 int ret;
7659 struct ocfs2_super *osb = OCFS2_SB(sb);
7660 struct ocfs2_trim_fs_info info, *pinfo = NULL;
7661
7662 ocfs2_trim_fs_lock_res_init(osb);
7663
7664 trace_ocfs2_trim_fs(range->start, range->len, range->minlen);
7665
7666 ret = ocfs2_trim_fs_lock(osb, NULL, 1);
7667 if (ret < 0) {
7668 if (ret != -EAGAIN) {
7669 mlog_errno(ret);
7670 ocfs2_trim_fs_lock_res_uninit(osb);
7671 return ret;
7672 }
7673
7674 mlog(ML_NOTICE, "Wait for trim on device (%s) to "
7675 "finish, which is running from another node.\n",
7676 osb->dev_str);
7677 ret = ocfs2_trim_fs_lock(osb, &info, 0);
7678 if (ret < 0) {
7679 mlog_errno(ret);
7680 ocfs2_trim_fs_lock_res_uninit(osb);
7681 return ret;
7682 }
7683
7684 if (info.tf_valid && info.tf_success &&
7685 info.tf_start == range->start &&
7686 info.tf_len == range->len &&
7687 info.tf_minlen == range->minlen) {
7688 /* Avoid sending duplicated trim to a shared device */
7689 mlog(ML_NOTICE, "The same trim on device (%s) was "
7690 "just done from node (%u), return.\n",
7691 osb->dev_str, info.tf_nodenum);
7692 range->len = info.tf_trimlen;
7693 goto out;
7694 }
7695 }
7696
7697 info.tf_nodenum = osb->node_num;
7698 info.tf_start = range->start;
7699 info.tf_len = range->len;
7700 info.tf_minlen = range->minlen;
7701
7702 ret = ocfs2_trim_mainbm(sb, range);
7703
7704 info.tf_trimlen = range->len;
7705 info.tf_success = (ret < 0 ? 0 : 1);
7706 pinfo = &info;
7707out:
7708 ocfs2_trim_fs_unlock(osb, pinfo);
7709 ocfs2_trim_fs_lock_res_uninit(osb);
7710 return ret;
7711}