1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
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
33#define MLOG_MASK_PREFIX ML_DISK_ALLOC
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
54#include "buffer_head_io.h"
55
56enum ocfs2_contig_type {
57 CONTIG_NONE = 0,
58 CONTIG_LEFT,
59 CONTIG_RIGHT,
60 CONTIG_LEFTRIGHT,
61};
62
63static enum ocfs2_contig_type
64 ocfs2_extent_rec_contig(struct super_block *sb,
65 struct ocfs2_extent_rec *ext,
66 struct ocfs2_extent_rec *insert_rec);
67
68
69
70
71
72
73
74
75struct ocfs2_extent_tree_operations {
76
77
78
79
80
81
82
83 void (*eo_set_last_eb_blk)(struct ocfs2_extent_tree *et,
84 u64 blkno);
85 u64 (*eo_get_last_eb_blk)(struct ocfs2_extent_tree *et);
86
87
88
89
90
91
92
93 void (*eo_update_clusters)(struct ocfs2_extent_tree *et,
94 u32 new_clusters);
95
96
97
98
99
100 void (*eo_extent_map_insert)(struct ocfs2_extent_tree *et,
101 struct ocfs2_extent_rec *rec);
102
103
104
105
106
107 void (*eo_extent_map_truncate)(struct ocfs2_extent_tree *et,
108 u32 clusters);
109
110
111
112
113
114 int (*eo_insert_check)(struct ocfs2_extent_tree *et,
115 struct ocfs2_extent_rec *rec);
116 int (*eo_sanity_check)(struct ocfs2_extent_tree *et);
117
118
119
120
121
122
123
124
125
126
127
128 void (*eo_fill_root_el)(struct ocfs2_extent_tree *et);
129
130
131
132
133
134
135 void (*eo_fill_max_leaf_clusters)(struct ocfs2_extent_tree *et);
136
137
138
139
140
141
142 enum ocfs2_contig_type
143 (*eo_extent_contig)(struct ocfs2_extent_tree *et,
144 struct ocfs2_extent_rec *ext,
145 struct ocfs2_extent_rec *insert_rec);
146};
147
148
149
150
151
152
153static u64 ocfs2_dinode_get_last_eb_blk(struct ocfs2_extent_tree *et);
154static void ocfs2_dinode_set_last_eb_blk(struct ocfs2_extent_tree *et,
155 u64 blkno);
156static void ocfs2_dinode_update_clusters(struct ocfs2_extent_tree *et,
157 u32 clusters);
158static void ocfs2_dinode_extent_map_insert(struct ocfs2_extent_tree *et,
159 struct ocfs2_extent_rec *rec);
160static void ocfs2_dinode_extent_map_truncate(struct ocfs2_extent_tree *et,
161 u32 clusters);
162static int ocfs2_dinode_insert_check(struct ocfs2_extent_tree *et,
163 struct ocfs2_extent_rec *rec);
164static int ocfs2_dinode_sanity_check(struct ocfs2_extent_tree *et);
165static void ocfs2_dinode_fill_root_el(struct ocfs2_extent_tree *et);
166static struct ocfs2_extent_tree_operations ocfs2_dinode_et_ops = {
167 .eo_set_last_eb_blk = ocfs2_dinode_set_last_eb_blk,
168 .eo_get_last_eb_blk = ocfs2_dinode_get_last_eb_blk,
169 .eo_update_clusters = ocfs2_dinode_update_clusters,
170 .eo_extent_map_insert = ocfs2_dinode_extent_map_insert,
171 .eo_extent_map_truncate = ocfs2_dinode_extent_map_truncate,
172 .eo_insert_check = ocfs2_dinode_insert_check,
173 .eo_sanity_check = ocfs2_dinode_sanity_check,
174 .eo_fill_root_el = ocfs2_dinode_fill_root_el,
175};
176
177static void ocfs2_dinode_set_last_eb_blk(struct ocfs2_extent_tree *et,
178 u64 blkno)
179{
180 struct ocfs2_dinode *di = et->et_object;
181
182 BUG_ON(et->et_ops != &ocfs2_dinode_et_ops);
183 di->i_last_eb_blk = cpu_to_le64(blkno);
184}
185
186static u64 ocfs2_dinode_get_last_eb_blk(struct ocfs2_extent_tree *et)
187{
188 struct ocfs2_dinode *di = et->et_object;
189
190 BUG_ON(et->et_ops != &ocfs2_dinode_et_ops);
191 return le64_to_cpu(di->i_last_eb_blk);
192}
193
194static void ocfs2_dinode_update_clusters(struct ocfs2_extent_tree *et,
195 u32 clusters)
196{
197 struct ocfs2_inode_info *oi = cache_info_to_inode(et->et_ci);
198 struct ocfs2_dinode *di = et->et_object;
199
200 le32_add_cpu(&di->i_clusters, clusters);
201 spin_lock(&oi->ip_lock);
202 oi->ip_clusters = le32_to_cpu(di->i_clusters);
203 spin_unlock(&oi->ip_lock);
204}
205
206static void ocfs2_dinode_extent_map_insert(struct ocfs2_extent_tree *et,
207 struct ocfs2_extent_rec *rec)
208{
209 struct inode *inode = &cache_info_to_inode(et->et_ci)->vfs_inode;
210
211 ocfs2_extent_map_insert_rec(inode, rec);
212}
213
214static void ocfs2_dinode_extent_map_truncate(struct ocfs2_extent_tree *et,
215 u32 clusters)
216{
217 struct inode *inode = &cache_info_to_inode(et->et_ci)->vfs_inode;
218
219 ocfs2_extent_map_trunc(inode, clusters);
220}
221
222static int ocfs2_dinode_insert_check(struct ocfs2_extent_tree *et,
223 struct ocfs2_extent_rec *rec)
224{
225 struct ocfs2_inode_info *oi = cache_info_to_inode(et->et_ci);
226 struct ocfs2_super *osb = OCFS2_SB(oi->vfs_inode.i_sb);
227
228 BUG_ON(oi->ip_dyn_features & OCFS2_INLINE_DATA_FL);
229 mlog_bug_on_msg(!ocfs2_sparse_alloc(osb) &&
230 (oi->ip_clusters != le32_to_cpu(rec->e_cpos)),
231 "Device %s, asking for sparse allocation: inode %llu, "
232 "cpos %u, clusters %u\n",
233 osb->dev_str,
234 (unsigned long long)oi->ip_blkno,
235 rec->e_cpos, oi->ip_clusters);
236
237 return 0;
238}
239
240static int ocfs2_dinode_sanity_check(struct ocfs2_extent_tree *et)
241{
242 struct ocfs2_dinode *di = et->et_object;
243
244 BUG_ON(et->et_ops != &ocfs2_dinode_et_ops);
245 BUG_ON(!OCFS2_IS_VALID_DINODE(di));
246
247 return 0;
248}
249
250static void ocfs2_dinode_fill_root_el(struct ocfs2_extent_tree *et)
251{
252 struct ocfs2_dinode *di = et->et_object;
253
254 et->et_root_el = &di->id2.i_list;
255}
256
257
258static void ocfs2_xattr_value_fill_root_el(struct ocfs2_extent_tree *et)
259{
260 struct ocfs2_xattr_value_buf *vb = et->et_object;
261
262 et->et_root_el = &vb->vb_xv->xr_list;
263}
264
265static void ocfs2_xattr_value_set_last_eb_blk(struct ocfs2_extent_tree *et,
266 u64 blkno)
267{
268 struct ocfs2_xattr_value_buf *vb = et->et_object;
269
270 vb->vb_xv->xr_last_eb_blk = cpu_to_le64(blkno);
271}
272
273static u64 ocfs2_xattr_value_get_last_eb_blk(struct ocfs2_extent_tree *et)
274{
275 struct ocfs2_xattr_value_buf *vb = et->et_object;
276
277 return le64_to_cpu(vb->vb_xv->xr_last_eb_blk);
278}
279
280static void ocfs2_xattr_value_update_clusters(struct ocfs2_extent_tree *et,
281 u32 clusters)
282{
283 struct ocfs2_xattr_value_buf *vb = et->et_object;
284
285 le32_add_cpu(&vb->vb_xv->xr_clusters, clusters);
286}
287
288static struct ocfs2_extent_tree_operations ocfs2_xattr_value_et_ops = {
289 .eo_set_last_eb_blk = ocfs2_xattr_value_set_last_eb_blk,
290 .eo_get_last_eb_blk = ocfs2_xattr_value_get_last_eb_blk,
291 .eo_update_clusters = ocfs2_xattr_value_update_clusters,
292 .eo_fill_root_el = ocfs2_xattr_value_fill_root_el,
293};
294
295static void ocfs2_xattr_tree_fill_root_el(struct ocfs2_extent_tree *et)
296{
297 struct ocfs2_xattr_block *xb = et->et_object;
298
299 et->et_root_el = &xb->xb_attrs.xb_root.xt_list;
300}
301
302static void ocfs2_xattr_tree_fill_max_leaf_clusters(struct ocfs2_extent_tree *et)
303{
304 struct super_block *sb = ocfs2_metadata_cache_get_super(et->et_ci);
305 et->et_max_leaf_clusters =
306 ocfs2_clusters_for_bytes(sb, OCFS2_MAX_XATTR_TREE_LEAF_SIZE);
307}
308
309static void ocfs2_xattr_tree_set_last_eb_blk(struct ocfs2_extent_tree *et,
310 u64 blkno)
311{
312 struct ocfs2_xattr_block *xb = et->et_object;
313 struct ocfs2_xattr_tree_root *xt = &xb->xb_attrs.xb_root;
314
315 xt->xt_last_eb_blk = cpu_to_le64(blkno);
316}
317
318static u64 ocfs2_xattr_tree_get_last_eb_blk(struct ocfs2_extent_tree *et)
319{
320 struct ocfs2_xattr_block *xb = et->et_object;
321 struct ocfs2_xattr_tree_root *xt = &xb->xb_attrs.xb_root;
322
323 return le64_to_cpu(xt->xt_last_eb_blk);
324}
325
326static void ocfs2_xattr_tree_update_clusters(struct ocfs2_extent_tree *et,
327 u32 clusters)
328{
329 struct ocfs2_xattr_block *xb = et->et_object;
330
331 le32_add_cpu(&xb->xb_attrs.xb_root.xt_clusters, clusters);
332}
333
334static struct ocfs2_extent_tree_operations ocfs2_xattr_tree_et_ops = {
335 .eo_set_last_eb_blk = ocfs2_xattr_tree_set_last_eb_blk,
336 .eo_get_last_eb_blk = ocfs2_xattr_tree_get_last_eb_blk,
337 .eo_update_clusters = ocfs2_xattr_tree_update_clusters,
338 .eo_fill_root_el = ocfs2_xattr_tree_fill_root_el,
339 .eo_fill_max_leaf_clusters = ocfs2_xattr_tree_fill_max_leaf_clusters,
340};
341
342static void ocfs2_dx_root_set_last_eb_blk(struct ocfs2_extent_tree *et,
343 u64 blkno)
344{
345 struct ocfs2_dx_root_block *dx_root = et->et_object;
346
347 dx_root->dr_last_eb_blk = cpu_to_le64(blkno);
348}
349
350static u64 ocfs2_dx_root_get_last_eb_blk(struct ocfs2_extent_tree *et)
351{
352 struct ocfs2_dx_root_block *dx_root = et->et_object;
353
354 return le64_to_cpu(dx_root->dr_last_eb_blk);
355}
356
357static void ocfs2_dx_root_update_clusters(struct ocfs2_extent_tree *et,
358 u32 clusters)
359{
360 struct ocfs2_dx_root_block *dx_root = et->et_object;
361
362 le32_add_cpu(&dx_root->dr_clusters, clusters);
363}
364
365static int ocfs2_dx_root_sanity_check(struct ocfs2_extent_tree *et)
366{
367 struct ocfs2_dx_root_block *dx_root = et->et_object;
368
369 BUG_ON(!OCFS2_IS_VALID_DX_ROOT(dx_root));
370
371 return 0;
372}
373
374static void ocfs2_dx_root_fill_root_el(struct ocfs2_extent_tree *et)
375{
376 struct ocfs2_dx_root_block *dx_root = et->et_object;
377
378 et->et_root_el = &dx_root->dr_list;
379}
380
381static struct ocfs2_extent_tree_operations ocfs2_dx_root_et_ops = {
382 .eo_set_last_eb_blk = ocfs2_dx_root_set_last_eb_blk,
383 .eo_get_last_eb_blk = ocfs2_dx_root_get_last_eb_blk,
384 .eo_update_clusters = ocfs2_dx_root_update_clusters,
385 .eo_sanity_check = ocfs2_dx_root_sanity_check,
386 .eo_fill_root_el = ocfs2_dx_root_fill_root_el,
387};
388
389static void ocfs2_refcount_tree_fill_root_el(struct ocfs2_extent_tree *et)
390{
391 struct ocfs2_refcount_block *rb = et->et_object;
392
393 et->et_root_el = &rb->rf_list;
394}
395
396static void ocfs2_refcount_tree_set_last_eb_blk(struct ocfs2_extent_tree *et,
397 u64 blkno)
398{
399 struct ocfs2_refcount_block *rb = et->et_object;
400
401 rb->rf_last_eb_blk = cpu_to_le64(blkno);
402}
403
404static u64 ocfs2_refcount_tree_get_last_eb_blk(struct ocfs2_extent_tree *et)
405{
406 struct ocfs2_refcount_block *rb = et->et_object;
407
408 return le64_to_cpu(rb->rf_last_eb_blk);
409}
410
411static void ocfs2_refcount_tree_update_clusters(struct ocfs2_extent_tree *et,
412 u32 clusters)
413{
414 struct ocfs2_refcount_block *rb = et->et_object;
415
416 le32_add_cpu(&rb->rf_clusters, clusters);
417}
418
419static enum ocfs2_contig_type
420ocfs2_refcount_tree_extent_contig(struct ocfs2_extent_tree *et,
421 struct ocfs2_extent_rec *ext,
422 struct ocfs2_extent_rec *insert_rec)
423{
424 return CONTIG_NONE;
425}
426
427static struct ocfs2_extent_tree_operations ocfs2_refcount_tree_et_ops = {
428 .eo_set_last_eb_blk = ocfs2_refcount_tree_set_last_eb_blk,
429 .eo_get_last_eb_blk = ocfs2_refcount_tree_get_last_eb_blk,
430 .eo_update_clusters = ocfs2_refcount_tree_update_clusters,
431 .eo_fill_root_el = ocfs2_refcount_tree_fill_root_el,
432 .eo_extent_contig = ocfs2_refcount_tree_extent_contig,
433};
434
435static void __ocfs2_init_extent_tree(struct ocfs2_extent_tree *et,
436 struct ocfs2_caching_info *ci,
437 struct buffer_head *bh,
438 ocfs2_journal_access_func access,
439 void *obj,
440 struct ocfs2_extent_tree_operations *ops)
441{
442 et->et_ops = ops;
443 et->et_root_bh = bh;
444 et->et_ci = ci;
445 et->et_root_journal_access = access;
446 if (!obj)
447 obj = (void *)bh->b_data;
448 et->et_object = obj;
449
450 et->et_ops->eo_fill_root_el(et);
451 if (!et->et_ops->eo_fill_max_leaf_clusters)
452 et->et_max_leaf_clusters = 0;
453 else
454 et->et_ops->eo_fill_max_leaf_clusters(et);
455}
456
457void ocfs2_init_dinode_extent_tree(struct ocfs2_extent_tree *et,
458 struct ocfs2_caching_info *ci,
459 struct buffer_head *bh)
460{
461 __ocfs2_init_extent_tree(et, ci, bh, ocfs2_journal_access_di,
462 NULL, &ocfs2_dinode_et_ops);
463}
464
465void ocfs2_init_xattr_tree_extent_tree(struct ocfs2_extent_tree *et,
466 struct ocfs2_caching_info *ci,
467 struct buffer_head *bh)
468{
469 __ocfs2_init_extent_tree(et, ci, bh, ocfs2_journal_access_xb,
470 NULL, &ocfs2_xattr_tree_et_ops);
471}
472
473void ocfs2_init_xattr_value_extent_tree(struct ocfs2_extent_tree *et,
474 struct ocfs2_caching_info *ci,
475 struct ocfs2_xattr_value_buf *vb)
476{
477 __ocfs2_init_extent_tree(et, ci, vb->vb_bh, vb->vb_access, vb,
478 &ocfs2_xattr_value_et_ops);
479}
480
481void ocfs2_init_dx_root_extent_tree(struct ocfs2_extent_tree *et,
482 struct ocfs2_caching_info *ci,
483 struct buffer_head *bh)
484{
485 __ocfs2_init_extent_tree(et, ci, bh, ocfs2_journal_access_dr,
486 NULL, &ocfs2_dx_root_et_ops);
487}
488
489void ocfs2_init_refcount_extent_tree(struct ocfs2_extent_tree *et,
490 struct ocfs2_caching_info *ci,
491 struct buffer_head *bh)
492{
493 __ocfs2_init_extent_tree(et, ci, bh, ocfs2_journal_access_rb,
494 NULL, &ocfs2_refcount_tree_et_ops);
495}
496
497static inline void ocfs2_et_set_last_eb_blk(struct ocfs2_extent_tree *et,
498 u64 new_last_eb_blk)
499{
500 et->et_ops->eo_set_last_eb_blk(et, new_last_eb_blk);
501}
502
503static inline u64 ocfs2_et_get_last_eb_blk(struct ocfs2_extent_tree *et)
504{
505 return et->et_ops->eo_get_last_eb_blk(et);
506}
507
508static inline void ocfs2_et_update_clusters(struct ocfs2_extent_tree *et,
509 u32 clusters)
510{
511 et->et_ops->eo_update_clusters(et, clusters);
512}
513
514static inline void ocfs2_et_extent_map_insert(struct ocfs2_extent_tree *et,
515 struct ocfs2_extent_rec *rec)
516{
517 if (et->et_ops->eo_extent_map_insert)
518 et->et_ops->eo_extent_map_insert(et, rec);
519}
520
521static inline void ocfs2_et_extent_map_truncate(struct ocfs2_extent_tree *et,
522 u32 clusters)
523{
524 if (et->et_ops->eo_extent_map_truncate)
525 et->et_ops->eo_extent_map_truncate(et, clusters);
526}
527
528static inline int ocfs2_et_root_journal_access(handle_t *handle,
529 struct ocfs2_extent_tree *et,
530 int type)
531{
532 return et->et_root_journal_access(handle, et->et_ci, et->et_root_bh,
533 type);
534}
535
536static inline enum ocfs2_contig_type
537 ocfs2_et_extent_contig(struct ocfs2_extent_tree *et,
538 struct ocfs2_extent_rec *rec,
539 struct ocfs2_extent_rec *insert_rec)
540{
541 if (et->et_ops->eo_extent_contig)
542 return et->et_ops->eo_extent_contig(et, rec, insert_rec);
543
544 return ocfs2_extent_rec_contig(
545 ocfs2_metadata_cache_get_super(et->et_ci),
546 rec, insert_rec);
547}
548
549static inline int ocfs2_et_insert_check(struct ocfs2_extent_tree *et,
550 struct ocfs2_extent_rec *rec)
551{
552 int ret = 0;
553
554 if (et->et_ops->eo_insert_check)
555 ret = et->et_ops->eo_insert_check(et, rec);
556 return ret;
557}
558
559static inline int ocfs2_et_sanity_check(struct ocfs2_extent_tree *et)
560{
561 int ret = 0;
562
563 if (et->et_ops->eo_sanity_check)
564 ret = et->et_ops->eo_sanity_check(et);
565 return ret;
566}
567
568static void ocfs2_free_truncate_context(struct ocfs2_truncate_context *tc);
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
577
578
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
598
599
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
619
620
621
622
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
645
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
667
668
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
677
678
679
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
721
722
723
724
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
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
769
770
771
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
799
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
833
834
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
853
854
855
856
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 mlog(0, "Validating extent block %llu\n",
891 (unsigned long long)bh->b_blocknr);
892
893 BUG_ON(!buffer_uptodate(bh));
894
895
896
897
898
899
900 rc = ocfs2_validate_meta_ecc(sb, bh->b_data, &eb->h_check);
901 if (rc) {
902 mlog(ML_ERROR, "Checksum failed for extent block %llu\n",
903 (unsigned long long)bh->b_blocknr);
904 return rc;
905 }
906
907
908
909
910
911 if (!OCFS2_IS_VALID_EXTENT_BLOCK(eb)) {
912 ocfs2_error(sb,
913 "Extent block #%llu has bad signature %.*s",
914 (unsigned long long)bh->b_blocknr, 7,
915 eb->h_signature);
916 return -EINVAL;
917 }
918
919 if (le64_to_cpu(eb->h_blkno) != bh->b_blocknr) {
920 ocfs2_error(sb,
921 "Extent block #%llu has an invalid h_blkno "
922 "of %llu",
923 (unsigned long long)bh->b_blocknr,
924 (unsigned long long)le64_to_cpu(eb->h_blkno));
925 return -EINVAL;
926 }
927
928 if (le32_to_cpu(eb->h_fs_generation) != OCFS2_SB(sb)->fs_generation) {
929 ocfs2_error(sb,
930 "Extent block #%llu has an invalid "
931 "h_fs_generation of #%u",
932 (unsigned long long)bh->b_blocknr,
933 le32_to_cpu(eb->h_fs_generation));
934 return -EINVAL;
935 }
936
937 return 0;
938}
939
940int ocfs2_read_extent_block(struct ocfs2_caching_info *ci, u64 eb_blkno,
941 struct buffer_head **bh)
942{
943 int rc;
944 struct buffer_head *tmp = *bh;
945
946 rc = ocfs2_read_block(ci, eb_blkno, &tmp,
947 ocfs2_validate_extent_block);
948
949
950 if (!rc && !*bh)
951 *bh = tmp;
952
953 return rc;
954}
955
956
957
958
959
960int ocfs2_num_free_extents(struct ocfs2_super *osb,
961 struct ocfs2_extent_tree *et)
962{
963 int retval;
964 struct ocfs2_extent_list *el = NULL;
965 struct ocfs2_extent_block *eb;
966 struct buffer_head *eb_bh = NULL;
967 u64 last_eb_blk = 0;
968
969 mlog_entry_void();
970
971 el = et->et_root_el;
972 last_eb_blk = ocfs2_et_get_last_eb_blk(et);
973
974 if (last_eb_blk) {
975 retval = ocfs2_read_extent_block(et->et_ci, last_eb_blk,
976 &eb_bh);
977 if (retval < 0) {
978 mlog_errno(retval);
979 goto bail;
980 }
981 eb = (struct ocfs2_extent_block *) eb_bh->b_data;
982 el = &eb->h_list;
983 }
984
985 BUG_ON(el->l_tree_depth != 0);
986
987 retval = le16_to_cpu(el->l_count) - le16_to_cpu(el->l_next_free_rec);
988bail:
989 brelse(eb_bh);
990
991 mlog_exit(retval);
992 return retval;
993}
994
995
996
997
998
999
1000static int ocfs2_create_new_meta_bhs(handle_t *handle,
1001 struct ocfs2_extent_tree *et,
1002 int wanted,
1003 struct ocfs2_alloc_context *meta_ac,
1004 struct buffer_head *bhs[])
1005{
1006 int count, status, i;
1007 u16 suballoc_bit_start;
1008 u32 num_got;
1009 u64 first_blkno;
1010 struct ocfs2_super *osb =
1011 OCFS2_SB(ocfs2_metadata_cache_get_super(et->et_ci));
1012 struct ocfs2_extent_block *eb;
1013
1014 mlog_entry_void();
1015
1016 count = 0;
1017 while (count < wanted) {
1018 status = ocfs2_claim_metadata(osb,
1019 handle,
1020 meta_ac,
1021 wanted - count,
1022 &suballoc_bit_start,
1023 &num_got,
1024 &first_blkno);
1025 if (status < 0) {
1026 mlog_errno(status);
1027 goto bail;
1028 }
1029
1030 for(i = count; i < (num_got + count); i++) {
1031 bhs[i] = sb_getblk(osb->sb, first_blkno);
1032 if (bhs[i] == NULL) {
1033 status = -EIO;
1034 mlog_errno(status);
1035 goto bail;
1036 }
1037 ocfs2_set_new_buffer_uptodate(et->et_ci, bhs[i]);
1038
1039 status = ocfs2_journal_access_eb(handle, et->et_ci,
1040 bhs[i],
1041 OCFS2_JOURNAL_ACCESS_CREATE);
1042 if (status < 0) {
1043 mlog_errno(status);
1044 goto bail;
1045 }
1046
1047 memset(bhs[i]->b_data, 0, osb->sb->s_blocksize);
1048 eb = (struct ocfs2_extent_block *) bhs[i]->b_data;
1049
1050 strcpy(eb->h_signature, OCFS2_EXTENT_BLOCK_SIGNATURE);
1051 eb->h_blkno = cpu_to_le64(first_blkno);
1052 eb->h_fs_generation = cpu_to_le32(osb->fs_generation);
1053 eb->h_suballoc_slot = cpu_to_le16(osb->slot_num);
1054 eb->h_suballoc_bit = cpu_to_le16(suballoc_bit_start);
1055 eb->h_list.l_count =
1056 cpu_to_le16(ocfs2_extent_recs_per_eb(osb->sb));
1057
1058 suballoc_bit_start++;
1059 first_blkno++;
1060
1061
1062
1063 status = ocfs2_journal_dirty(handle, bhs[i]);
1064 if (status < 0) {
1065 mlog_errno(status);
1066 goto bail;
1067 }
1068 }
1069
1070 count += num_got;
1071 }
1072
1073 status = 0;
1074bail:
1075 if (status < 0) {
1076 for(i = 0; i < wanted; i++) {
1077 brelse(bhs[i]);
1078 bhs[i] = NULL;
1079 }
1080 }
1081 mlog_exit(status);
1082 return status;
1083}
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097static inline u32 ocfs2_sum_rightmost_rec(struct ocfs2_extent_list *el)
1098{
1099 int i;
1100
1101 i = le16_to_cpu(el->l_next_free_rec) - 1;
1102
1103 return le32_to_cpu(el->l_recs[i].e_cpos) +
1104 ocfs2_rec_clusters(el, &el->l_recs[i]);
1105}
1106
1107
1108
1109
1110
1111static int ocfs2_adjust_rightmost_branch(handle_t *handle,
1112 struct ocfs2_extent_tree *et)
1113{
1114 int status;
1115 struct ocfs2_path *path = NULL;
1116 struct ocfs2_extent_list *el;
1117 struct ocfs2_extent_rec *rec;
1118
1119 path = ocfs2_new_path_from_et(et);
1120 if (!path) {
1121 status = -ENOMEM;
1122 return status;
1123 }
1124
1125 status = ocfs2_find_path(et->et_ci, path, UINT_MAX);
1126 if (status < 0) {
1127 mlog_errno(status);
1128 goto out;
1129 }
1130
1131 status = ocfs2_extend_trans(handle, path_num_items(path) +
1132 handle->h_buffer_credits);
1133 if (status < 0) {
1134 mlog_errno(status);
1135 goto out;
1136 }
1137
1138 status = ocfs2_journal_access_path(et->et_ci, handle, path);
1139 if (status < 0) {
1140 mlog_errno(status);
1141 goto out;
1142 }
1143
1144 el = path_leaf_el(path);
1145 rec = &el->l_recs[le32_to_cpu(el->l_next_free_rec) - 1];
1146
1147 ocfs2_adjust_rightmost_records(handle, et, path, rec);
1148
1149out:
1150 ocfs2_free_path(path);
1151 return status;
1152}
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165static int ocfs2_add_branch(handle_t *handle,
1166 struct ocfs2_extent_tree *et,
1167 struct buffer_head *eb_bh,
1168 struct buffer_head **last_eb_bh,
1169 struct ocfs2_alloc_context *meta_ac)
1170{
1171 int status, new_blocks, i;
1172 u64 next_blkno, new_last_eb_blk;
1173 struct buffer_head *bh;
1174 struct buffer_head **new_eb_bhs = NULL;
1175 struct ocfs2_extent_block *eb;
1176 struct ocfs2_extent_list *eb_el;
1177 struct ocfs2_extent_list *el;
1178 u32 new_cpos, root_end;
1179
1180 mlog_entry_void();
1181
1182 BUG_ON(!last_eb_bh || !*last_eb_bh);
1183
1184 if (eb_bh) {
1185 eb = (struct ocfs2_extent_block *) eb_bh->b_data;
1186 el = &eb->h_list;
1187 } else
1188 el = et->et_root_el;
1189
1190
1191 BUG_ON(!el->l_tree_depth);
1192
1193 new_blocks = le16_to_cpu(el->l_tree_depth);
1194
1195 eb = (struct ocfs2_extent_block *)(*last_eb_bh)->b_data;
1196 new_cpos = ocfs2_sum_rightmost_rec(&eb->h_list);
1197 root_end = ocfs2_sum_rightmost_rec(et->et_root_el);
1198
1199
1200
1201
1202
1203
1204
1205
1206 if (root_end > new_cpos) {
1207 mlog(0, "adjust the cluster end from %u to %u\n",
1208 root_end, new_cpos);
1209 status = ocfs2_adjust_rightmost_branch(handle, et);
1210 if (status) {
1211 mlog_errno(status);
1212 goto bail;
1213 }
1214 }
1215
1216
1217 new_eb_bhs = kcalloc(new_blocks, sizeof(struct buffer_head *),
1218 GFP_KERNEL);
1219 if (!new_eb_bhs) {
1220 status = -ENOMEM;
1221 mlog_errno(status);
1222 goto bail;
1223 }
1224
1225 status = ocfs2_create_new_meta_bhs(handle, et, new_blocks,
1226 meta_ac, new_eb_bhs);
1227 if (status < 0) {
1228 mlog_errno(status);
1229 goto bail;
1230 }
1231
1232
1233
1234
1235
1236
1237
1238
1239 next_blkno = new_last_eb_blk = 0;
1240 for(i = 0; i < new_blocks; i++) {
1241 bh = new_eb_bhs[i];
1242 eb = (struct ocfs2_extent_block *) bh->b_data;
1243
1244 BUG_ON(!OCFS2_IS_VALID_EXTENT_BLOCK(eb));
1245 eb_el = &eb->h_list;
1246
1247 status = ocfs2_journal_access_eb(handle, et->et_ci, bh,
1248 OCFS2_JOURNAL_ACCESS_CREATE);
1249 if (status < 0) {
1250 mlog_errno(status);
1251 goto bail;
1252 }
1253
1254 eb->h_next_leaf_blk = 0;
1255 eb_el->l_tree_depth = cpu_to_le16(i);
1256 eb_el->l_next_free_rec = cpu_to_le16(1);
1257
1258
1259
1260
1261 eb_el->l_recs[0].e_cpos = cpu_to_le32(new_cpos);
1262 eb_el->l_recs[0].e_blkno = cpu_to_le64(next_blkno);
1263
1264
1265
1266
1267
1268 eb_el->l_recs[0].e_int_clusters = cpu_to_le32(0);
1269 if (!eb_el->l_tree_depth)
1270 new_last_eb_blk = le64_to_cpu(eb->h_blkno);
1271
1272 status = ocfs2_journal_dirty(handle, bh);
1273 if (status < 0) {
1274 mlog_errno(status);
1275 goto bail;
1276 }
1277
1278 next_blkno = le64_to_cpu(eb->h_blkno);
1279 }
1280
1281
1282
1283
1284
1285
1286
1287 status = ocfs2_journal_access_eb(handle, et->et_ci, *last_eb_bh,
1288 OCFS2_JOURNAL_ACCESS_WRITE);
1289 if (status < 0) {
1290 mlog_errno(status);
1291 goto bail;
1292 }
1293 status = ocfs2_et_root_journal_access(handle, et,
1294 OCFS2_JOURNAL_ACCESS_WRITE);
1295 if (status < 0) {
1296 mlog_errno(status);
1297 goto bail;
1298 }
1299 if (eb_bh) {
1300 status = ocfs2_journal_access_eb(handle, et->et_ci, eb_bh,
1301 OCFS2_JOURNAL_ACCESS_WRITE);
1302 if (status < 0) {
1303 mlog_errno(status);
1304 goto bail;
1305 }
1306 }
1307
1308
1309
1310 i = le16_to_cpu(el->l_next_free_rec);
1311 el->l_recs[i].e_blkno = cpu_to_le64(next_blkno);
1312 el->l_recs[i].e_cpos = cpu_to_le32(new_cpos);
1313 el->l_recs[i].e_int_clusters = 0;
1314 le16_add_cpu(&el->l_next_free_rec, 1);
1315
1316
1317
1318 ocfs2_et_set_last_eb_blk(et, new_last_eb_blk);
1319
1320 eb = (struct ocfs2_extent_block *) (*last_eb_bh)->b_data;
1321 eb->h_next_leaf_blk = cpu_to_le64(new_last_eb_blk);
1322
1323 status = ocfs2_journal_dirty(handle, *last_eb_bh);
1324 if (status < 0)
1325 mlog_errno(status);
1326 status = ocfs2_journal_dirty(handle, et->et_root_bh);
1327 if (status < 0)
1328 mlog_errno(status);
1329 if (eb_bh) {
1330 status = ocfs2_journal_dirty(handle, eb_bh);
1331 if (status < 0)
1332 mlog_errno(status);
1333 }
1334
1335
1336
1337
1338
1339 brelse(*last_eb_bh);
1340 get_bh(new_eb_bhs[0]);
1341 *last_eb_bh = new_eb_bhs[0];
1342
1343 status = 0;
1344bail:
1345 if (new_eb_bhs) {
1346 for (i = 0; i < new_blocks; i++)
1347 brelse(new_eb_bhs[i]);
1348 kfree(new_eb_bhs);
1349 }
1350
1351 mlog_exit(status);
1352 return status;
1353}
1354
1355
1356
1357
1358
1359
1360static int ocfs2_shift_tree_depth(handle_t *handle,
1361 struct ocfs2_extent_tree *et,
1362 struct ocfs2_alloc_context *meta_ac,
1363 struct buffer_head **ret_new_eb_bh)
1364{
1365 int status, i;
1366 u32 new_clusters;
1367 struct buffer_head *new_eb_bh = NULL;
1368 struct ocfs2_extent_block *eb;
1369 struct ocfs2_extent_list *root_el;
1370 struct ocfs2_extent_list *eb_el;
1371
1372 mlog_entry_void();
1373
1374 status = ocfs2_create_new_meta_bhs(handle, et, 1, meta_ac,
1375 &new_eb_bh);
1376 if (status < 0) {
1377 mlog_errno(status);
1378 goto bail;
1379 }
1380
1381 eb = (struct ocfs2_extent_block *) new_eb_bh->b_data;
1382
1383 BUG_ON(!OCFS2_IS_VALID_EXTENT_BLOCK(eb));
1384
1385 eb_el = &eb->h_list;
1386 root_el = et->et_root_el;
1387
1388 status = ocfs2_journal_access_eb(handle, et->et_ci, new_eb_bh,
1389 OCFS2_JOURNAL_ACCESS_CREATE);
1390 if (status < 0) {
1391 mlog_errno(status);
1392 goto bail;
1393 }
1394
1395
1396 eb_el->l_tree_depth = root_el->l_tree_depth;
1397 eb_el->l_next_free_rec = root_el->l_next_free_rec;
1398 for (i = 0; i < le16_to_cpu(root_el->l_next_free_rec); i++)
1399 eb_el->l_recs[i] = root_el->l_recs[i];
1400
1401 status = ocfs2_journal_dirty(handle, new_eb_bh);
1402 if (status < 0) {
1403 mlog_errno(status);
1404 goto bail;
1405 }
1406
1407 status = ocfs2_et_root_journal_access(handle, et,
1408 OCFS2_JOURNAL_ACCESS_WRITE);
1409 if (status < 0) {
1410 mlog_errno(status);
1411 goto bail;
1412 }
1413
1414 new_clusters = ocfs2_sum_rightmost_rec(eb_el);
1415
1416
1417 le16_add_cpu(&root_el->l_tree_depth, 1);
1418 root_el->l_recs[0].e_cpos = 0;
1419 root_el->l_recs[0].e_blkno = eb->h_blkno;
1420 root_el->l_recs[0].e_int_clusters = cpu_to_le32(new_clusters);
1421 for (i = 1; i < le16_to_cpu(root_el->l_next_free_rec); i++)
1422 memset(&root_el->l_recs[i], 0, sizeof(struct ocfs2_extent_rec));
1423 root_el->l_next_free_rec = cpu_to_le16(1);
1424
1425
1426
1427 if (root_el->l_tree_depth == cpu_to_le16(1))
1428 ocfs2_et_set_last_eb_blk(et, le64_to_cpu(eb->h_blkno));
1429
1430 status = ocfs2_journal_dirty(handle, et->et_root_bh);
1431 if (status < 0) {
1432 mlog_errno(status);
1433 goto bail;
1434 }
1435
1436 *ret_new_eb_bh = new_eb_bh;
1437 new_eb_bh = NULL;
1438 status = 0;
1439bail:
1440 brelse(new_eb_bh);
1441
1442 mlog_exit(status);
1443 return status;
1444}
1445
1446
1447
1448
1449
1450
1451
1452
1453
1454
1455
1456
1457
1458
1459
1460
1461
1462
1463static int ocfs2_find_branch_target(struct ocfs2_extent_tree *et,
1464 struct buffer_head **target_bh)
1465{
1466 int status = 0, i;
1467 u64 blkno;
1468 struct ocfs2_extent_block *eb;
1469 struct ocfs2_extent_list *el;
1470 struct buffer_head *bh = NULL;
1471 struct buffer_head *lowest_bh = NULL;
1472
1473 mlog_entry_void();
1474
1475 *target_bh = NULL;
1476
1477 el = et->et_root_el;
1478
1479 while(le16_to_cpu(el->l_tree_depth) > 1) {
1480 if (le16_to_cpu(el->l_next_free_rec) == 0) {
1481 ocfs2_error(ocfs2_metadata_cache_get_super(et->et_ci),
1482 "Owner %llu has empty "
1483 "extent list (next_free_rec == 0)",
1484 (unsigned long long)ocfs2_metadata_cache_owner(et->et_ci));
1485 status = -EIO;
1486 goto bail;
1487 }
1488 i = le16_to_cpu(el->l_next_free_rec) - 1;
1489 blkno = le64_to_cpu(el->l_recs[i].e_blkno);
1490 if (!blkno) {
1491 ocfs2_error(ocfs2_metadata_cache_get_super(et->et_ci),
1492 "Owner %llu has extent "
1493 "list where extent # %d has no physical "
1494 "block start",
1495 (unsigned long long)ocfs2_metadata_cache_owner(et->et_ci), i);
1496 status = -EIO;
1497 goto bail;
1498 }
1499
1500 brelse(bh);
1501 bh = NULL;
1502
1503 status = ocfs2_read_extent_block(et->et_ci, blkno, &bh);
1504 if (status < 0) {
1505 mlog_errno(status);
1506 goto bail;
1507 }
1508
1509 eb = (struct ocfs2_extent_block *) bh->b_data;
1510 el = &eb->h_list;
1511
1512 if (le16_to_cpu(el->l_next_free_rec) <
1513 le16_to_cpu(el->l_count)) {
1514 brelse(lowest_bh);
1515 lowest_bh = bh;
1516 get_bh(lowest_bh);
1517 }
1518 }
1519
1520
1521
1522 el = et->et_root_el;
1523 if (!lowest_bh && (el->l_next_free_rec == el->l_count))
1524 status = 1;
1525
1526 *target_bh = lowest_bh;
1527bail:
1528 brelse(bh);
1529
1530 mlog_exit(status);
1531 return status;
1532}
1533
1534
1535
1536
1537
1538
1539
1540
1541
1542
1543
1544static int ocfs2_grow_tree(handle_t *handle, struct ocfs2_extent_tree *et,
1545 int *final_depth, struct buffer_head **last_eb_bh,
1546 struct ocfs2_alloc_context *meta_ac)
1547{
1548 int ret, shift;
1549 struct ocfs2_extent_list *el = et->et_root_el;
1550 int depth = le16_to_cpu(el->l_tree_depth);
1551 struct buffer_head *bh = NULL;
1552
1553 BUG_ON(meta_ac == NULL);
1554
1555 shift = ocfs2_find_branch_target(et, &bh);
1556 if (shift < 0) {
1557 ret = shift;
1558 mlog_errno(ret);
1559 goto out;
1560 }
1561
1562
1563
1564
1565 if (shift) {
1566 BUG_ON(bh);
1567 mlog(0, "need to shift tree depth (current = %d)\n", depth);
1568
1569
1570
1571
1572 ret = ocfs2_shift_tree_depth(handle, et, meta_ac, &bh);
1573 if (ret < 0) {
1574 mlog_errno(ret);
1575 goto out;
1576 }
1577 depth++;
1578 if (depth == 1) {
1579
1580
1581
1582
1583
1584
1585
1586
1587
1588 BUG_ON(*last_eb_bh);
1589 get_bh(bh);
1590 *last_eb_bh = bh;
1591 goto out;
1592 }
1593 }
1594
1595
1596
1597 mlog(0, "add branch. bh = %p\n", bh);
1598 ret = ocfs2_add_branch(handle, et, bh, last_eb_bh,
1599 meta_ac);
1600 if (ret < 0) {
1601 mlog_errno(ret);
1602 goto out;
1603 }
1604
1605out:
1606 if (final_depth)
1607 *final_depth = depth;
1608 brelse(bh);
1609 return ret;
1610}
1611
1612
1613
1614
1615static void ocfs2_shift_records_right(struct ocfs2_extent_list *el)
1616{
1617 int next_free = le16_to_cpu(el->l_next_free_rec);
1618 int count = le16_to_cpu(el->l_count);
1619 unsigned int num_bytes;
1620
1621 BUG_ON(!next_free);
1622
1623 BUG_ON(next_free >= count);
1624
1625 num_bytes = sizeof(struct ocfs2_extent_rec) * next_free;
1626
1627 memmove(&el->l_recs[1], &el->l_recs[0], num_bytes);
1628}
1629
1630static void ocfs2_rotate_leaf(struct ocfs2_extent_list *el,
1631 struct ocfs2_extent_rec *insert_rec)
1632{
1633 int i, insert_index, next_free, has_empty, num_bytes;
1634 u32 insert_cpos = le32_to_cpu(insert_rec->e_cpos);
1635 struct ocfs2_extent_rec *rec;
1636
1637 next_free = le16_to_cpu(el->l_next_free_rec);
1638 has_empty = ocfs2_is_empty_extent(&el->l_recs[0]);
1639
1640 BUG_ON(!next_free);
1641
1642
1643 BUG_ON(el->l_next_free_rec == el->l_count && !has_empty);
1644
1645
1646
1647
1648
1649 if (has_empty) {
1650
1651
1652
1653
1654
1655 for(i = 0; i < (next_free - 1); i++)
1656 el->l_recs[i] = el->l_recs[i+1];
1657
1658 next_free--;
1659 }
1660
1661
1662
1663
1664 for(i = 0; i < next_free; i++) {
1665 rec = &el->l_recs[i];
1666
1667 if (insert_cpos < le32_to_cpu(rec->e_cpos))
1668 break;
1669 }
1670 insert_index = i;
1671
1672 mlog(0, "ins %u: index %d, has_empty %d, next_free %d, count %d\n",
1673 insert_cpos, insert_index, has_empty, next_free, le16_to_cpu(el->l_count));
1674
1675 BUG_ON(insert_index < 0);
1676 BUG_ON(insert_index >= le16_to_cpu(el->l_count));
1677 BUG_ON(insert_index > next_free);
1678
1679
1680
1681
1682 if (insert_index != next_free) {
1683 BUG_ON(next_free >= le16_to_cpu(el->l_count));
1684
1685 num_bytes = next_free - insert_index;
1686 num_bytes *= sizeof(struct ocfs2_extent_rec);
1687 memmove(&el->l_recs[insert_index + 1],
1688 &el->l_recs[insert_index],
1689 num_bytes);
1690 }
1691
1692
1693
1694
1695
1696
1697 next_free++;
1698 el->l_next_free_rec = cpu_to_le16(next_free);
1699
1700
1701
1702 BUG_ON(le16_to_cpu(el->l_next_free_rec) > le16_to_cpu(el->l_count));
1703
1704 el->l_recs[insert_index] = *insert_rec;
1705
1706}
1707
1708static void ocfs2_remove_empty_extent(struct ocfs2_extent_list *el)
1709{
1710 int size, num_recs = le16_to_cpu(el->l_next_free_rec);
1711
1712 BUG_ON(num_recs == 0);
1713
1714 if (ocfs2_is_empty_extent(&el->l_recs[0])) {
1715 num_recs--;
1716 size = num_recs * sizeof(struct ocfs2_extent_rec);
1717 memmove(&el->l_recs[0], &el->l_recs[1], size);
1718 memset(&el->l_recs[num_recs], 0,
1719 sizeof(struct ocfs2_extent_rec));
1720 el->l_next_free_rec = cpu_to_le16(num_recs);
1721 }
1722}
1723
1724
1725
1726
1727
1728
1729
1730
1731static void ocfs2_create_empty_extent(struct ocfs2_extent_list *el)
1732{
1733 int next_free = le16_to_cpu(el->l_next_free_rec);
1734
1735 BUG_ON(le16_to_cpu(el->l_tree_depth) != 0);
1736
1737 if (next_free == 0)
1738 goto set_and_inc;
1739
1740 if (ocfs2_is_empty_extent(&el->l_recs[0]))
1741 return;
1742
1743 mlog_bug_on_msg(el->l_count == el->l_next_free_rec,
1744 "Asked to create an empty extent in a full list:\n"
1745 "count = %u, tree depth = %u",
1746 le16_to_cpu(el->l_count),
1747 le16_to_cpu(el->l_tree_depth));
1748
1749 ocfs2_shift_records_right(el);
1750
1751set_and_inc:
1752 le16_add_cpu(&el->l_next_free_rec, 1);
1753 memset(&el->l_recs[0], 0, sizeof(struct ocfs2_extent_rec));
1754}
1755
1756
1757
1758
1759
1760
1761
1762
1763
1764
1765
1766
1767
1768static int ocfs2_find_subtree_root(struct ocfs2_extent_tree *et,
1769 struct ocfs2_path *left,
1770 struct ocfs2_path *right)
1771{
1772 int i = 0;
1773
1774
1775
1776
1777 BUG_ON(path_root_bh(left) != path_root_bh(right));
1778
1779 do {
1780 i++;
1781
1782
1783
1784
1785 mlog_bug_on_msg(i > left->p_tree_depth,
1786 "Owner %llu, left depth %u, right depth %u\n"
1787 "left leaf blk %llu, right leaf blk %llu\n",
1788 (unsigned long long)ocfs2_metadata_cache_owner(et->et_ci),
1789 left->p_tree_depth, right->p_tree_depth,
1790 (unsigned long long)path_leaf_bh(left)->b_blocknr,
1791 (unsigned long long)path_leaf_bh(right)->b_blocknr);
1792 } while (left->p_node[i].bh->b_blocknr ==
1793 right->p_node[i].bh->b_blocknr);
1794
1795 return i - 1;
1796}
1797
1798typedef void (path_insert_t)(void *, struct buffer_head *);
1799
1800
1801
1802
1803
1804
1805
1806static int __ocfs2_find_path(struct ocfs2_caching_info *ci,
1807 struct ocfs2_extent_list *root_el, u32 cpos,
1808 path_insert_t *func, void *data)
1809{
1810 int i, ret = 0;
1811 u32 range;
1812 u64 blkno;
1813 struct buffer_head *bh = NULL;
1814 struct ocfs2_extent_block *eb;
1815 struct ocfs2_extent_list *el;
1816 struct ocfs2_extent_rec *rec;
1817
1818 el = root_el;
1819 while (el->l_tree_depth) {
1820 if (le16_to_cpu(el->l_next_free_rec) == 0) {
1821 ocfs2_error(ocfs2_metadata_cache_get_super(ci),
1822 "Owner %llu has empty extent list at "
1823 "depth %u\n",
1824 (unsigned long long)ocfs2_metadata_cache_owner(ci),
1825 le16_to_cpu(el->l_tree_depth));
1826 ret = -EROFS;
1827 goto out;
1828
1829 }
1830
1831 for(i = 0; i < le16_to_cpu(el->l_next_free_rec) - 1; i++) {
1832 rec = &el->l_recs[i];
1833
1834
1835
1836
1837
1838
1839 range = le32_to_cpu(rec->e_cpos) +
1840 ocfs2_rec_clusters(el, rec);
1841 if (cpos >= le32_to_cpu(rec->e_cpos) && cpos < range)
1842 break;
1843 }
1844
1845 blkno = le64_to_cpu(el->l_recs[i].e_blkno);
1846 if (blkno == 0) {
1847 ocfs2_error(ocfs2_metadata_cache_get_super(ci),
1848 "Owner %llu has bad blkno in extent list "
1849 "at depth %u (index %d)\n",
1850 (unsigned long long)ocfs2_metadata_cache_owner(ci),
1851 le16_to_cpu(el->l_tree_depth), i);
1852 ret = -EROFS;
1853 goto out;
1854 }
1855
1856 brelse(bh);
1857 bh = NULL;
1858 ret = ocfs2_read_extent_block(ci, blkno, &bh);
1859 if (ret) {
1860 mlog_errno(ret);
1861 goto out;
1862 }
1863
1864 eb = (struct ocfs2_extent_block *) bh->b_data;
1865 el = &eb->h_list;
1866
1867 if (le16_to_cpu(el->l_next_free_rec) >
1868 le16_to_cpu(el->l_count)) {
1869 ocfs2_error(ocfs2_metadata_cache_get_super(ci),
1870 "Owner %llu has bad count in extent list "
1871 "at block %llu (next free=%u, count=%u)\n",
1872 (unsigned long long)ocfs2_metadata_cache_owner(ci),
1873 (unsigned long long)bh->b_blocknr,
1874 le16_to_cpu(el->l_next_free_rec),
1875 le16_to_cpu(el->l_count));
1876 ret = -EROFS;
1877 goto out;
1878 }
1879
1880 if (func)
1881 func(data, bh);
1882 }
1883
1884out:
1885
1886
1887
1888 brelse(bh);
1889
1890 return ret;
1891}
1892
1893
1894
1895
1896
1897
1898
1899
1900
1901
1902
1903
1904struct find_path_data {
1905 int index;
1906 struct ocfs2_path *path;
1907};
1908static void find_path_ins(void *data, struct buffer_head *bh)
1909{
1910 struct find_path_data *fp = data;
1911
1912 get_bh(bh);
1913 ocfs2_path_insert_eb(fp->path, fp->index, bh);
1914 fp->index++;
1915}
1916int ocfs2_find_path(struct ocfs2_caching_info *ci,
1917 struct ocfs2_path *path, u32 cpos)
1918{
1919 struct find_path_data data;
1920
1921 data.index = 1;
1922 data.path = path;
1923 return __ocfs2_find_path(ci, path_root_el(path), cpos,
1924 find_path_ins, &data);
1925}
1926
1927static void find_leaf_ins(void *data, struct buffer_head *bh)
1928{
1929 struct ocfs2_extent_block *eb =(struct ocfs2_extent_block *)bh->b_data;
1930 struct ocfs2_extent_list *el = &eb->h_list;
1931 struct buffer_head **ret = data;
1932
1933
1934 if (le16_to_cpu(el->l_tree_depth) == 0) {
1935 get_bh(bh);
1936 *ret = bh;
1937 }
1938}
1939
1940
1941
1942
1943
1944
1945
1946
1947
1948int ocfs2_find_leaf(struct ocfs2_caching_info *ci,
1949 struct ocfs2_extent_list *root_el, u32 cpos,
1950 struct buffer_head **leaf_bh)
1951{
1952 int ret;
1953 struct buffer_head *bh = NULL;
1954
1955 ret = __ocfs2_find_path(ci, root_el, cpos, find_leaf_ins, &bh);
1956 if (ret) {
1957 mlog_errno(ret);
1958 goto out;
1959 }
1960
1961 *leaf_bh = bh;
1962out:
1963 return ret;
1964}
1965
1966
1967
1968
1969
1970
1971
1972
1973
1974
1975
1976
1977
1978
1979
1980static void ocfs2_adjust_adjacent_records(struct ocfs2_extent_rec *left_rec,
1981 struct ocfs2_extent_list *left_child_el,
1982 struct ocfs2_extent_rec *right_rec,
1983 struct ocfs2_extent_list *right_child_el)
1984{
1985 u32 left_clusters, right_end;
1986
1987
1988
1989
1990
1991
1992
1993
1994 left_clusters = le32_to_cpu(right_child_el->l_recs[0].e_cpos);
1995 if (!ocfs2_rec_clusters(right_child_el, &right_child_el->l_recs[0])) {
1996 BUG_ON(right_child_el->l_tree_depth);
1997 BUG_ON(le16_to_cpu(right_child_el->l_next_free_rec) <= 1);
1998 left_clusters = le32_to_cpu(right_child_el->l_recs[1].e_cpos);
1999 }
2000 left_clusters -= le32_to_cpu(left_rec->e_cpos);
2001 left_rec->e_int_clusters = cpu_to_le32(left_clusters);
2002
2003
2004
2005
2006
2007
2008 right_end = le32_to_cpu(right_rec->e_cpos);
2009 right_end += le32_to_cpu(right_rec->e_int_clusters);
2010
2011 right_rec->e_cpos = left_rec->e_cpos;
2012 le32_add_cpu(&right_rec->e_cpos, left_clusters);
2013
2014 right_end -= le32_to_cpu(right_rec->e_cpos);
2015 right_rec->e_int_clusters = cpu_to_le32(right_end);
2016}
2017
2018
2019
2020
2021
2022
2023static void ocfs2_adjust_root_records(struct ocfs2_extent_list *root_el,
2024 struct ocfs2_extent_list *left_el,
2025 struct ocfs2_extent_list *right_el,
2026 u64 left_el_blkno)
2027{
2028 int i;
2029
2030 BUG_ON(le16_to_cpu(root_el->l_tree_depth) <=
2031 le16_to_cpu(left_el->l_tree_depth));
2032
2033 for(i = 0; i < le16_to_cpu(root_el->l_next_free_rec) - 1; i++) {
2034 if (le64_to_cpu(root_el->l_recs[i].e_blkno) == left_el_blkno)
2035 break;
2036 }
2037
2038
2039
2040
2041
2042 BUG_ON(i >= (le16_to_cpu(root_el->l_next_free_rec) - 1));
2043
2044 ocfs2_adjust_adjacent_records(&root_el->l_recs[i], left_el,
2045 &root_el->l_recs[i + 1], right_el);
2046}
2047
2048
2049
2050
2051
2052
2053
2054
2055
2056
2057
2058
2059
2060
2061static void ocfs2_complete_edge_insert(handle_t *handle,
2062 struct ocfs2_path *left_path,
2063 struct ocfs2_path *right_path,
2064 int subtree_index)
2065{
2066 int ret, i, idx;
2067 struct ocfs2_extent_list *el, *left_el, *right_el;
2068 struct ocfs2_extent_rec *left_rec, *right_rec;
2069 struct buffer_head *root_bh = left_path->p_node[subtree_index].bh;
2070
2071
2072
2073
2074
2075
2076
2077
2078
2079
2080
2081
2082
2083 left_el = path_leaf_el(left_path);
2084 right_el = path_leaf_el(right_path);
2085 for(i = left_path->p_tree_depth - 1; i > subtree_index; i--) {
2086 mlog(0, "Adjust records at index %u\n", i);
2087
2088
2089
2090
2091
2092
2093
2094 el = left_path->p_node[i].el;
2095 idx = le16_to_cpu(left_el->l_next_free_rec) - 1;
2096 left_rec = &el->l_recs[idx];
2097
2098 el = right_path->p_node[i].el;
2099 right_rec = &el->l_recs[0];
2100
2101 ocfs2_adjust_adjacent_records(left_rec, left_el, right_rec,
2102 right_el);
2103
2104 ret = ocfs2_journal_dirty(handle, left_path->p_node[i].bh);
2105 if (ret)
2106 mlog_errno(ret);
2107
2108 ret = ocfs2_journal_dirty(handle, right_path->p_node[i].bh);
2109 if (ret)
2110 mlog_errno(ret);
2111
2112
2113
2114
2115
2116 left_el = left_path->p_node[i].el;
2117 right_el = right_path->p_node[i].el;
2118 }
2119
2120
2121
2122
2123
2124
2125 el = left_path->p_node[subtree_index].el;
2126 left_el = left_path->p_node[subtree_index + 1].el;
2127 right_el = right_path->p_node[subtree_index + 1].el;
2128
2129 ocfs2_adjust_root_records(el, left_el, right_el,
2130 left_path->p_node[subtree_index + 1].bh->b_blocknr);
2131
2132 root_bh = left_path->p_node[subtree_index].bh;
2133
2134 ret = ocfs2_journal_dirty(handle, root_bh);
2135 if (ret)
2136 mlog_errno(ret);
2137}
2138
2139static int ocfs2_rotate_subtree_right(handle_t *handle,
2140 struct ocfs2_extent_tree *et,
2141 struct ocfs2_path *left_path,
2142 struct ocfs2_path *right_path,
2143 int subtree_index)
2144{
2145 int ret, i;
2146 struct buffer_head *right_leaf_bh;
2147 struct buffer_head *left_leaf_bh = NULL;
2148 struct buffer_head *root_bh;
2149 struct ocfs2_extent_list *right_el, *left_el;
2150 struct ocfs2_extent_rec move_rec;
2151
2152 left_leaf_bh = path_leaf_bh(left_path);
2153 left_el = path_leaf_el(left_path);
2154
2155 if (left_el->l_next_free_rec != left_el->l_count) {
2156 ocfs2_error(ocfs2_metadata_cache_get_super(et->et_ci),
2157 "Inode %llu has non-full interior leaf node %llu"
2158 "(next free = %u)",
2159 (unsigned long long)ocfs2_metadata_cache_owner(et->et_ci),
2160 (unsigned long long)left_leaf_bh->b_blocknr,
2161 le16_to_cpu(left_el->l_next_free_rec));
2162 return -EROFS;
2163 }
2164
2165
2166
2167
2168
2169 if (ocfs2_is_empty_extent(&left_el->l_recs[0]))
2170 return 0;
2171
2172 root_bh = left_path->p_node[subtree_index].bh;
2173 BUG_ON(root_bh != right_path->p_node[subtree_index].bh);
2174
2175 ret = ocfs2_path_bh_journal_access(handle, et->et_ci, right_path,
2176 subtree_index);
2177 if (ret) {
2178 mlog_errno(ret);
2179 goto out;
2180 }
2181
2182 for(i = subtree_index + 1; i < path_num_items(right_path); i++) {
2183 ret = ocfs2_path_bh_journal_access(handle, et->et_ci,
2184 right_path, i);
2185 if (ret) {
2186 mlog_errno(ret);
2187 goto out;
2188 }
2189
2190 ret = ocfs2_path_bh_journal_access(handle, et->et_ci,
2191 left_path, i);
2192 if (ret) {
2193 mlog_errno(ret);
2194 goto out;
2195 }
2196 }
2197
2198 right_leaf_bh = path_leaf_bh(right_path);
2199 right_el = path_leaf_el(right_path);
2200
2201
2202 mlog_bug_on_msg(!right_el->l_next_free_rec, "Inode %llu: Rotate fails "
2203 "because rightmost leaf block %llu is empty\n",
2204 (unsigned long long)ocfs2_metadata_cache_owner(et->et_ci),
2205 (unsigned long long)right_leaf_bh->b_blocknr);
2206
2207 ocfs2_create_empty_extent(right_el);
2208
2209 ret = ocfs2_journal_dirty(handle, right_leaf_bh);
2210 if (ret) {
2211 mlog_errno(ret);
2212 goto out;
2213 }
2214
2215
2216 i = le16_to_cpu(left_el->l_next_free_rec) - 1;
2217 move_rec = left_el->l_recs[i];
2218 right_el->l_recs[0] = move_rec;
2219
2220
2221
2222
2223
2224
2225
2226
2227 le16_add_cpu(&left_el->l_next_free_rec, -1);
2228 ocfs2_shift_records_right(left_el);
2229 memset(&left_el->l_recs[0], 0, sizeof(struct ocfs2_extent_rec));
2230 le16_add_cpu(&left_el->l_next_free_rec, 1);
2231
2232 ret = ocfs2_journal_dirty(handle, left_leaf_bh);
2233 if (ret) {
2234 mlog_errno(ret);
2235 goto out;
2236 }
2237
2238 ocfs2_complete_edge_insert(handle, left_path, right_path,
2239 subtree_index);
2240
2241out:
2242 return ret;
2243}
2244
2245
2246
2247
2248
2249
2250
2251static int ocfs2_find_cpos_for_left_leaf(struct super_block *sb,
2252 struct ocfs2_path *path, u32 *cpos)
2253{
2254 int i, j, ret = 0;
2255 u64 blkno;
2256 struct ocfs2_extent_list *el;
2257
2258 BUG_ON(path->p_tree_depth == 0);
2259
2260 *cpos = 0;
2261
2262 blkno = path_leaf_bh(path)->b_blocknr;
2263
2264
2265 i = path->p_tree_depth - 1;
2266 while (i >= 0) {
2267 el = path->p_node[i].el;
2268
2269
2270
2271
2272
2273 for(j = 0; j < le16_to_cpu(el->l_next_free_rec); j++) {
2274 if (le64_to_cpu(el->l_recs[j].e_blkno) == blkno) {
2275 if (j == 0) {
2276 if (i == 0) {
2277
2278
2279
2280
2281
2282
2283 goto out;
2284 }
2285
2286
2287
2288
2289
2290 goto next_node;
2291 }
2292
2293 *cpos = le32_to_cpu(el->l_recs[j - 1].e_cpos);
2294 *cpos = *cpos + ocfs2_rec_clusters(el,
2295 &el->l_recs[j - 1]);
2296 *cpos = *cpos - 1;
2297 goto out;
2298 }
2299 }
2300
2301
2302
2303
2304
2305 ocfs2_error(sb,
2306 "Invalid extent tree at extent block %llu\n",
2307 (unsigned long long)blkno);
2308 ret = -EROFS;
2309 goto out;
2310
2311next_node:
2312 blkno = path->p_node[i].bh->b_blocknr;
2313 i--;
2314 }
2315
2316out:
2317 return ret;
2318}
2319
2320
2321
2322
2323
2324
2325static int ocfs2_extend_rotate_transaction(handle_t *handle, int subtree_depth,
2326 int op_credits,
2327 struct ocfs2_path *path)
2328{
2329 int ret;
2330 int credits = (path->p_tree_depth - subtree_depth) * 2 + 1 + op_credits;
2331
2332 if (handle->h_buffer_credits < credits) {
2333 ret = ocfs2_extend_trans(handle,
2334 credits - handle->h_buffer_credits);
2335 if (ret)
2336 return ret;
2337
2338 if (unlikely(handle->h_buffer_credits < credits))
2339 return ocfs2_extend_trans(handle, credits);
2340 }
2341
2342 return 0;
2343}
2344
2345
2346
2347
2348
2349
2350
2351
2352
2353
2354
2355static int ocfs2_rotate_requires_path_adjustment(struct ocfs2_path *left_path,
2356 u32 insert_cpos)
2357{
2358 struct ocfs2_extent_list *left_el;
2359 struct ocfs2_extent_rec *rec;
2360 int next_free;
2361
2362 left_el = path_leaf_el(left_path);
2363 next_free = le16_to_cpu(left_el->l_next_free_rec);
2364 rec = &left_el->l_recs[next_free - 1];
2365
2366 if (insert_cpos > le32_to_cpu(rec->e_cpos))
2367 return 1;
2368 return 0;
2369}
2370
2371static int ocfs2_leftmost_rec_contains(struct ocfs2_extent_list *el, u32 cpos)
2372{
2373 int next_free = le16_to_cpu(el->l_next_free_rec);
2374 unsigned int range;
2375 struct ocfs2_extent_rec *rec;
2376
2377 if (next_free == 0)
2378 return 0;
2379
2380 rec = &el->l_recs[0];
2381 if (ocfs2_is_empty_extent(rec)) {
2382
2383 if (next_free == 1)
2384 return 0;
2385 rec = &el->l_recs[1];
2386 }
2387
2388 range = le32_to_cpu(rec->e_cpos) + ocfs2_rec_clusters(el, rec);
2389 if (cpos >= le32_to_cpu(rec->e_cpos) && cpos < range)
2390 return 1;
2391 return 0;
2392}
2393
2394
2395
2396
2397
2398
2399
2400
2401
2402
2403
2404
2405
2406
2407
2408
2409
2410static int ocfs2_rotate_tree_right(handle_t *handle,
2411 struct ocfs2_extent_tree *et,
2412 enum ocfs2_split_type split,
2413 u32 insert_cpos,
2414 struct ocfs2_path *right_path,
2415 struct ocfs2_path **ret_left_path)
2416{
2417 int ret, start, orig_credits = handle->h_buffer_credits;
2418 u32 cpos;
2419 struct ocfs2_path *left_path = NULL;
2420 struct super_block *sb = ocfs2_metadata_cache_get_super(et->et_ci);
2421
2422 *ret_left_path = NULL;
2423
2424 left_path = ocfs2_new_path_from_path(right_path);
2425 if (!left_path) {
2426 ret = -ENOMEM;
2427 mlog_errno(ret);
2428 goto out;
2429 }
2430
2431 ret = ocfs2_find_cpos_for_left_leaf(sb, right_path, &cpos);
2432 if (ret) {
2433 mlog_errno(ret);
2434 goto out;
2435 }
2436
2437 mlog(0, "Insert: %u, first left path cpos: %u\n", insert_cpos, cpos);
2438
2439
2440
2441
2442
2443
2444
2445
2446
2447
2448
2449
2450
2451
2452
2453
2454
2455
2456
2457
2458
2459
2460
2461
2462
2463
2464
2465 while (cpos && insert_cpos <= cpos) {
2466 mlog(0, "Rotating a tree: ins. cpos: %u, left path cpos: %u\n",
2467 insert_cpos, cpos);
2468
2469 ret = ocfs2_find_path(et->et_ci, left_path, cpos);
2470 if (ret) {
2471 mlog_errno(ret);
2472 goto out;
2473 }
2474
2475 mlog_bug_on_msg(path_leaf_bh(left_path) ==
2476 path_leaf_bh(right_path),
2477 "Owner %llu: error during insert of %u "
2478 "(left path cpos %u) results in two identical "
2479 "paths ending at %llu\n",
2480 (unsigned long long)ocfs2_metadata_cache_owner(et->et_ci),
2481 insert_cpos, cpos,
2482 (unsigned long long)
2483 path_leaf_bh(left_path)->b_blocknr);
2484
2485 if (split == SPLIT_NONE &&
2486 ocfs2_rotate_requires_path_adjustment(left_path,
2487 insert_cpos)) {
2488
2489
2490
2491
2492
2493
2494
2495
2496
2497
2498
2499
2500
2501
2502
2503 *ret_left_path = left_path;
2504 goto out_ret_path;
2505 }
2506
2507 start = ocfs2_find_subtree_root(et, left_path, right_path);
2508
2509 mlog(0, "Subtree root at index %d (blk %llu, depth %d)\n",
2510 start,
2511 (unsigned long long) right_path->p_node[start].bh->b_blocknr,
2512 right_path->p_tree_depth);
2513
2514 ret = ocfs2_extend_rotate_transaction(handle, start,
2515 orig_credits, right_path);
2516 if (ret) {
2517 mlog_errno(ret);
2518 goto out;
2519 }
2520
2521 ret = ocfs2_rotate_subtree_right(handle, et, left_path,
2522 right_path, start);
2523 if (ret) {
2524 mlog_errno(ret);
2525 goto out;
2526 }
2527
2528 if (split != SPLIT_NONE &&
2529 ocfs2_leftmost_rec_contains(path_leaf_el(right_path),
2530 insert_cpos)) {
2531
2532
2533
2534
2535
2536
2537
2538
2539
2540
2541
2542 *ret_left_path = left_path;
2543 goto out_ret_path;
2544 }
2545
2546
2547
2548
2549
2550
2551 ocfs2_mv_path(right_path, left_path);
2552
2553 ret = ocfs2_find_cpos_for_left_leaf(sb, right_path, &cpos);
2554 if (ret) {
2555 mlog_errno(ret);
2556 goto out;
2557 }
2558 }
2559
2560out:
2561 ocfs2_free_path(left_path);
2562
2563out_ret_path:
2564 return ret;
2565}
2566
2567static int ocfs2_update_edge_lengths(handle_t *handle,
2568 struct ocfs2_extent_tree *et,
2569 int subtree_index, struct ocfs2_path *path)
2570{
2571 int i, idx, ret;
2572 struct ocfs2_extent_rec *rec;
2573 struct ocfs2_extent_list *el;
2574 struct ocfs2_extent_block *eb;
2575 u32 range;
2576
2577
2578
2579
2580
2581
2582
2583
2584
2585
2586 ret = ocfs2_extend_trans(handle,
2587 handle->h_buffer_credits + subtree_index);
2588 if (ret) {
2589 mlog_errno(ret);
2590 goto out;
2591 }
2592
2593 ret = ocfs2_journal_access_path(et->et_ci, handle, path);
2594 if (ret) {
2595 mlog_errno(ret);
2596 goto out;
2597 }
2598
2599
2600 eb = (struct ocfs2_extent_block *)path_leaf_bh(path)->b_data;
2601 BUG_ON(eb->h_next_leaf_blk != 0ULL);
2602
2603 el = &eb->h_list;
2604 BUG_ON(le16_to_cpu(el->l_next_free_rec) == 0);
2605 idx = le16_to_cpu(el->l_next_free_rec) - 1;
2606 rec = &el->l_recs[idx];
2607 range = le32_to_cpu(rec->e_cpos) + ocfs2_rec_clusters(el, rec);
2608
2609 for (i = 0; i < path->p_tree_depth; i++) {
2610 el = path->p_node[i].el;
2611 idx = le16_to_cpu(el->l_next_free_rec) - 1;
2612 rec = &el->l_recs[idx];
2613
2614 rec->e_int_clusters = cpu_to_le32(range);
2615 le32_add_cpu(&rec->e_int_clusters, -le32_to_cpu(rec->e_cpos));
2616
2617 ocfs2_journal_dirty(handle, path->p_node[i].bh);
2618 }
2619out:
2620 return ret;
2621}
2622
2623static void ocfs2_unlink_path(handle_t *handle,
2624 struct ocfs2_extent_tree *et,
2625 struct ocfs2_cached_dealloc_ctxt *dealloc,
2626 struct ocfs2_path *path, int unlink_start)
2627{
2628 int ret, i;
2629 struct ocfs2_extent_block *eb;
2630 struct ocfs2_extent_list *el;
2631 struct buffer_head *bh;
2632
2633 for(i = unlink_start; i < path_num_items(path); i++) {
2634 bh = path->p_node[i].bh;
2635
2636 eb = (struct ocfs2_extent_block *)bh->b_data;
2637
2638
2639
2640
2641 el = &eb->h_list;
2642 if (le16_to_cpu(el->l_next_free_rec) > 1) {
2643 mlog(ML_ERROR,
2644 "Inode %llu, attempted to remove extent block "
2645 "%llu with %u records\n",
2646 (unsigned long long)ocfs2_metadata_cache_owner(et->et_ci),
2647 (unsigned long long)le64_to_cpu(eb->h_blkno),
2648 le16_to_cpu(el->l_next_free_rec));
2649
2650 ocfs2_journal_dirty(handle, bh);
2651 ocfs2_remove_from_cache(et->et_ci, bh);
2652 continue;
2653 }
2654
2655 el->l_next_free_rec = 0;
2656 memset(&el->l_recs[0], 0, sizeof(struct ocfs2_extent_rec));
2657
2658 ocfs2_journal_dirty(handle, bh);
2659
2660 ret = ocfs2_cache_extent_block_free(dealloc, eb);
2661 if (ret)
2662 mlog_errno(ret);
2663
2664 ocfs2_remove_from_cache(et->et_ci, bh);
2665 }
2666}
2667
2668static void ocfs2_unlink_subtree(handle_t *handle,
2669 struct ocfs2_extent_tree *et,
2670 struct ocfs2_path *left_path,
2671 struct ocfs2_path *right_path,
2672 int subtree_index,
2673 struct ocfs2_cached_dealloc_ctxt *dealloc)
2674{
2675 int i;
2676 struct buffer_head *root_bh = left_path->p_node[subtree_index].bh;
2677 struct ocfs2_extent_list *root_el = left_path->p_node[subtree_index].el;
2678 struct ocfs2_extent_list *el;
2679 struct ocfs2_extent_block *eb;
2680
2681 el = path_leaf_el(left_path);
2682
2683 eb = (struct ocfs2_extent_block *)right_path->p_node[subtree_index + 1].bh->b_data;
2684
2685 for(i = 1; i < le16_to_cpu(root_el->l_next_free_rec); i++)
2686 if (root_el->l_recs[i].e_blkno == eb->h_blkno)
2687 break;
2688
2689 BUG_ON(i >= le16_to_cpu(root_el->l_next_free_rec));
2690
2691 memset(&root_el->l_recs[i], 0, sizeof(struct ocfs2_extent_rec));
2692 le16_add_cpu(&root_el->l_next_free_rec, -1);
2693
2694 eb = (struct ocfs2_extent_block *)path_leaf_bh(left_path)->b_data;
2695 eb->h_next_leaf_blk = 0;
2696
2697 ocfs2_journal_dirty(handle, root_bh);
2698 ocfs2_journal_dirty(handle, path_leaf_bh(left_path));
2699
2700 ocfs2_unlink_path(handle, et, dealloc, right_path,
2701 subtree_index + 1);
2702}
2703
2704static int ocfs2_rotate_subtree_left(handle_t *handle,
2705 struct ocfs2_extent_tree *et,
2706 struct ocfs2_path *left_path,
2707 struct ocfs2_path *right_path,
2708 int subtree_index,
2709 struct ocfs2_cached_dealloc_ctxt *dealloc,
2710 int *deleted)
2711{
2712 int ret, i, del_right_subtree = 0, right_has_empty = 0;
2713 struct buffer_head *root_bh, *et_root_bh = path_root_bh(right_path);
2714 struct ocfs2_extent_list *right_leaf_el, *left_leaf_el;
2715 struct ocfs2_extent_block *eb;
2716
2717 *deleted = 0;
2718
2719 right_leaf_el = path_leaf_el(right_path);
2720 left_leaf_el = path_leaf_el(left_path);
2721 root_bh = left_path->p_node[subtree_index].bh;
2722 BUG_ON(root_bh != right_path->p_node[subtree_index].bh);
2723
2724 if (!ocfs2_is_empty_extent(&left_leaf_el->l_recs[0]))
2725 return 0;
2726
2727 eb = (struct ocfs2_extent_block *)path_leaf_bh(right_path)->b_data;
2728 if (ocfs2_is_empty_extent(&right_leaf_el->l_recs[0])) {
2729
2730
2731
2732
2733
2734
2735
2736
2737
2738
2739
2740
2741
2742 if (eb->h_next_leaf_blk != 0ULL)
2743 return -EAGAIN;
2744
2745 if (le16_to_cpu(right_leaf_el->l_next_free_rec) > 1) {
2746 ret = ocfs2_journal_access_eb(handle, et->et_ci,
2747 path_leaf_bh(right_path),
2748 OCFS2_JOURNAL_ACCESS_WRITE);
2749 if (ret) {
2750 mlog_errno(ret);
2751 goto out;
2752 }
2753
2754 ocfs2_remove_empty_extent(right_leaf_el);
2755 } else
2756 right_has_empty = 1;
2757 }
2758
2759 if (eb->h_next_leaf_blk == 0ULL &&
2760 le16_to_cpu(right_leaf_el->l_next_free_rec) == 1) {
2761
2762
2763
2764
2765 ret = ocfs2_et_root_journal_access(handle, et,
2766 OCFS2_JOURNAL_ACCESS_WRITE);
2767 if (ret) {
2768 mlog_errno(ret);
2769 goto out;
2770 }
2771
2772 del_right_subtree = 1;
2773 }
2774
2775
2776
2777
2778
2779 BUG_ON(right_has_empty && !del_right_subtree);
2780
2781 ret = ocfs2_path_bh_journal_access(handle, et->et_ci, right_path,
2782 subtree_index);
2783 if (ret) {
2784 mlog_errno(ret);
2785 goto out;
2786 }
2787
2788 for(i = subtree_index + 1; i < path_num_items(right_path); i++) {
2789 ret = ocfs2_path_bh_journal_access(handle, et->et_ci,
2790 right_path, i);
2791 if (ret) {
2792 mlog_errno(ret);
2793 goto out;
2794 }
2795
2796 ret = ocfs2_path_bh_journal_access(handle, et->et_ci,
2797 left_path, i);
2798 if (ret) {
2799 mlog_errno(ret);
2800 goto out;
2801 }
2802 }
2803
2804 if (!right_has_empty) {
2805
2806
2807
2808
2809
2810
2811 ocfs2_rotate_leaf(left_leaf_el, &right_leaf_el->l_recs[0]);
2812 memset(&right_leaf_el->l_recs[0], 0,
2813 sizeof(struct ocfs2_extent_rec));
2814 }
2815 if (eb->h_next_leaf_blk == 0ULL) {
2816
2817
2818
2819
2820
2821
2822 ocfs2_remove_empty_extent(right_leaf_el);
2823 }
2824
2825 ret = ocfs2_journal_dirty(handle, path_leaf_bh(left_path));
2826 if (ret)
2827 mlog_errno(ret);
2828 ret = ocfs2_journal_dirty(handle, path_leaf_bh(right_path));
2829 if (ret)
2830 mlog_errno(ret);
2831
2832 if (del_right_subtree) {
2833 ocfs2_unlink_subtree(handle, et, left_path, right_path,
2834 subtree_index, dealloc);
2835 ret = ocfs2_update_edge_lengths(handle, et, subtree_index,
2836 left_path);
2837 if (ret) {
2838 mlog_errno(ret);
2839 goto out;
2840 }
2841
2842 eb = (struct ocfs2_extent_block *)path_leaf_bh(left_path)->b_data;
2843 ocfs2_et_set_last_eb_blk(et, le64_to_cpu(eb->h_blkno));
2844
2845
2846
2847
2848
2849
2850 if (right_has_empty)
2851 ocfs2_remove_empty_extent(left_leaf_el);
2852
2853 ret = ocfs2_journal_dirty(handle, et_root_bh);
2854 if (ret)
2855 mlog_errno(ret);
2856
2857 *deleted = 1;
2858 } else
2859 ocfs2_complete_edge_insert(handle, left_path, right_path,
2860 subtree_index);
2861
2862out:
2863 return ret;
2864}
2865
2866
2867
2868
2869
2870
2871
2872
2873
2874
2875static int ocfs2_find_cpos_for_right_leaf(struct super_block *sb,
2876 struct ocfs2_path *path, u32 *cpos)
2877{
2878 int i, j, ret = 0;
2879 u64 blkno;
2880 struct ocfs2_extent_list *el;
2881
2882 *cpos = 0;
2883
2884 if (path->p_tree_depth == 0)
2885 return 0;
2886
2887 blkno = path_leaf_bh(path)->b_blocknr;
2888
2889
2890 i = path->p_tree_depth - 1;
2891 while (i >= 0) {
2892 int next_free;
2893
2894 el = path->p_node[i].el;
2895
2896
2897
2898
2899
2900 next_free = le16_to_cpu(el->l_next_free_rec);
2901 for(j = 0; j < le16_to_cpu(el->l_next_free_rec); j++) {
2902 if (le64_to_cpu(el->l_recs[j].e_blkno) == blkno) {
2903 if (j == (next_free - 1)) {
2904 if (i == 0) {
2905
2906
2907
2908
2909
2910
2911 goto out;
2912 }
2913
2914
2915
2916
2917
2918 goto next_node;
2919 }
2920
2921 *cpos = le32_to_cpu(el->l_recs[j + 1].e_cpos);
2922 goto out;
2923 }
2924 }
2925
2926
2927
2928
2929
2930 ocfs2_error(sb,
2931 "Invalid extent tree at extent block %llu\n",
2932 (unsigned long long)blkno);
2933 ret = -EROFS;
2934 goto out;
2935
2936next_node:
2937 blkno = path->p_node[i].bh->b_blocknr;
2938 i--;
2939 }
2940
2941out:
2942 return ret;
2943}
2944
2945static int ocfs2_rotate_rightmost_leaf_left(handle_t *handle,
2946 struct ocfs2_extent_tree *et,
2947 struct ocfs2_path *path)
2948{
2949 int ret;
2950 struct buffer_head *bh = path_leaf_bh(path);
2951 struct ocfs2_extent_list *el = path_leaf_el(path);
2952
2953 if (!ocfs2_is_empty_extent(&el->l_recs[0]))
2954 return 0;
2955
2956 ret = ocfs2_path_bh_journal_access(handle, et->et_ci, path,
2957 path_num_items(path) - 1);
2958 if (ret) {
2959 mlog_errno(ret);
2960 goto out;
2961 }
2962
2963 ocfs2_remove_empty_extent(el);
2964
2965 ret = ocfs2_journal_dirty(handle, bh);
2966 if (ret)
2967 mlog_errno(ret);
2968
2969out:
2970 return ret;
2971}
2972
2973static int __ocfs2_rotate_tree_left(handle_t *handle,
2974 struct ocfs2_extent_tree *et,
2975 int orig_credits,
2976 struct ocfs2_path *path,
2977 struct ocfs2_cached_dealloc_ctxt *dealloc,
2978 struct ocfs2_path **empty_extent_path)
2979{
2980 int ret, subtree_root, deleted;
2981 u32 right_cpos;
2982 struct ocfs2_path *left_path = NULL;
2983 struct ocfs2_path *right_path = NULL;
2984 struct super_block *sb = ocfs2_metadata_cache_get_super(et->et_ci);
2985
2986 BUG_ON(!ocfs2_is_empty_extent(&(path_leaf_el(path)->l_recs[0])));
2987
2988 *empty_extent_path = NULL;
2989
2990 ret = ocfs2_find_cpos_for_right_leaf(sb, path, &right_cpos);
2991 if (ret) {
2992 mlog_errno(ret);
2993 goto out;
2994 }
2995
2996 left_path = ocfs2_new_path_from_path(path);
2997 if (!left_path) {
2998 ret = -ENOMEM;
2999 mlog_errno(ret);
3000 goto out;
3001 }
3002
3003 ocfs2_cp_path(left_path, path);
3004
3005 right_path = ocfs2_new_path_from_path(path);
3006 if (!right_path) {
3007 ret = -ENOMEM;
3008 mlog_errno(ret);
3009 goto out;
3010 }
3011
3012 while (right_cpos) {
3013 ret = ocfs2_find_path(et->et_ci, right_path, right_cpos);
3014 if (ret) {
3015 mlog_errno(ret);
3016 goto out;
3017 }
3018
3019 subtree_root = ocfs2_find_subtree_root(et, left_path,
3020 right_path);
3021
3022 mlog(0, "Subtree root at index %d (blk %llu, depth %d)\n",
3023 subtree_root,
3024 (unsigned long long)
3025 right_path->p_node[subtree_root].bh->b_blocknr,
3026 right_path->p_tree_depth);
3027
3028 ret = ocfs2_extend_rotate_transaction(handle, subtree_root,
3029 orig_credits, left_path);
3030 if (ret) {
3031 mlog_errno(ret);
3032 goto out;
3033 }
3034
3035
3036
3037
3038
3039 ret = ocfs2_path_bh_journal_access(handle, et->et_ci,
3040 left_path, 0);
3041 if (ret) {
3042 mlog_errno(ret);
3043 goto out;
3044 }
3045
3046 ret = ocfs2_rotate_subtree_left(handle, et, left_path,
3047 right_path, subtree_root,
3048 dealloc, &deleted);
3049 if (ret == -EAGAIN) {
3050
3051
3052
3053
3054
3055
3056 *empty_extent_path = right_path;
3057 right_path = NULL;
3058 goto out;
3059 }
3060 if (ret) {
3061 mlog_errno(ret);
3062 goto out;
3063 }
3064
3065
3066
3067
3068
3069
3070 if (deleted)
3071 break;
3072
3073 ocfs2_mv_path(left_path, right_path);
3074
3075 ret = ocfs2_find_cpos_for_right_leaf(sb, left_path,
3076 &right_cpos);
3077 if (ret) {
3078 mlog_errno(ret);
3079 goto out;
3080 }
3081 }
3082
3083out:
3084 ocfs2_free_path(right_path);
3085 ocfs2_free_path(left_path);
3086
3087 return ret;
3088}
3089
3090static int ocfs2_remove_rightmost_path(handle_t *handle,
3091 struct ocfs2_extent_tree *et,
3092 struct ocfs2_path *path,
3093 struct ocfs2_cached_dealloc_ctxt *dealloc)
3094{
3095 int ret, subtree_index;
3096 u32 cpos;
3097 struct ocfs2_path *left_path = NULL;
3098 struct ocfs2_extent_block *eb;
3099 struct ocfs2_extent_list *el;
3100
3101
3102 ret = ocfs2_et_sanity_check(et);
3103 if (ret)
3104 goto out;
3105
3106
3107
3108
3109 ret = ocfs2_extend_rotate_transaction(handle, 0,
3110 handle->h_buffer_credits,
3111 path);
3112 if (ret) {
3113 mlog_errno(ret);
3114 goto out;
3115 }
3116
3117 ret = ocfs2_journal_access_path(et->et_ci, handle, path);
3118 if (ret) {
3119 mlog_errno(ret);
3120 goto out;
3121 }
3122
3123 ret = ocfs2_find_cpos_for_left_leaf(ocfs2_metadata_cache_get_super(et->et_ci),
3124 path, &cpos);
3125 if (ret) {
3126 mlog_errno(ret);
3127 goto out;
3128 }
3129
3130 if (cpos) {
3131
3132
3133
3134
3135 left_path = ocfs2_new_path_from_path(path);
3136 if (!left_path) {
3137 ret = -ENOMEM;
3138 mlog_errno(ret);
3139 goto out;
3140 }
3141
3142 ret = ocfs2_find_path(et->et_ci, left_path, cpos);
3143 if (ret) {
3144 mlog_errno(ret);
3145 goto out;
3146 }
3147
3148 ret = ocfs2_journal_access_path(et->et_ci, handle, left_path);
3149 if (ret) {
3150 mlog_errno(ret);
3151 goto out;
3152 }
3153
3154 subtree_index = ocfs2_find_subtree_root(et, left_path, path);
3155
3156 ocfs2_unlink_subtree(handle, et, left_path, path,
3157 subtree_index, dealloc);
3158 ret = ocfs2_update_edge_lengths(handle, et, subtree_index,
3159 left_path);
3160 if (ret) {
3161 mlog_errno(ret);
3162 goto out;
3163 }
3164
3165 eb = (struct ocfs2_extent_block *)path_leaf_bh(left_path)->b_data;
3166 ocfs2_et_set_last_eb_blk(et, le64_to_cpu(eb->h_blkno));
3167 } else {
3168
3169
3170
3171
3172
3173
3174
3175 ocfs2_unlink_path(handle, et, dealloc, path, 1);
3176
3177 el = et->et_root_el;
3178 el->l_tree_depth = 0;
3179 el->l_next_free_rec = 0;
3180 memset(&el->l_recs[0], 0, sizeof(struct ocfs2_extent_rec));
3181
3182 ocfs2_et_set_last_eb_blk(et, 0);
3183 }
3184
3185 ocfs2_journal_dirty(handle, path_root_bh(path));
3186
3187out:
3188 ocfs2_free_path(left_path);
3189 return ret;
3190}
3191
3192
3193
3194
3195
3196
3197
3198
3199
3200
3201
3202
3203
3204
3205
3206
3207
3208static int ocfs2_rotate_tree_left(handle_t *handle,
3209 struct ocfs2_extent_tree *et,
3210 struct ocfs2_path *path,
3211 struct ocfs2_cached_dealloc_ctxt *dealloc)
3212{
3213 int ret, orig_credits = handle->h_buffer_credits;
3214 struct ocfs2_path *tmp_path = NULL, *restart_path = NULL;
3215 struct ocfs2_extent_block *eb;
3216 struct ocfs2_extent_list *el;
3217
3218 el = path_leaf_el(path);
3219 if (!ocfs2_is_empty_extent(&el->l_recs[0]))
3220 return 0;
3221
3222 if (path->p_tree_depth == 0) {
3223rightmost_no_delete:
3224
3225
3226
3227
3228 ret = ocfs2_rotate_rightmost_leaf_left(handle, et, path);
3229 if (ret)
3230 mlog_errno(ret);
3231 goto out;
3232 }
3233
3234
3235
3236
3237
3238
3239
3240
3241
3242
3243
3244
3245
3246
3247 eb = (struct ocfs2_extent_block *)path_leaf_bh(path)->b_data;
3248 el = &eb->h_list;
3249 if (eb->h_next_leaf_blk == 0) {
3250
3251
3252
3253
3254
3255 if (le16_to_cpu(el->l_next_free_rec) > 1)
3256 goto rightmost_no_delete;
3257
3258 if (le16_to_cpu(el->l_next_free_rec) == 0) {
3259 ret = -EIO;
3260 ocfs2_error(ocfs2_metadata_cache_get_super(et->et_ci),
3261 "Owner %llu has empty extent block at %llu",
3262 (unsigned long long)ocfs2_metadata_cache_owner(et->et_ci),
3263 (unsigned long long)le64_to_cpu(eb->h_blkno));
3264 goto out;
3265 }
3266
3267
3268
3269
3270
3271
3272
3273
3274
3275
3276 ret = ocfs2_remove_rightmost_path(handle, et, path,
3277 dealloc);
3278 if (ret)
3279 mlog_errno(ret);
3280 goto out;
3281 }
3282
3283
3284
3285
3286
3287try_rotate:
3288 ret = __ocfs2_rotate_tree_left(handle, et, orig_credits, path,
3289 dealloc, &restart_path);
3290 if (ret && ret != -EAGAIN) {
3291 mlog_errno(ret);
3292 goto out;
3293 }
3294
3295 while (ret == -EAGAIN) {
3296 tmp_path = restart_path;
3297 restart_path = NULL;
3298
3299 ret = __ocfs2_rotate_tree_left(handle, et, orig_credits,
3300 tmp_path, dealloc,
3301 &restart_path);
3302 if (ret && ret != -EAGAIN) {
3303 mlog_errno(ret);
3304 goto out;
3305 }
3306
3307 ocfs2_free_path(tmp_path);
3308 tmp_path = NULL;
3309
3310 if (ret == 0)
3311 goto try_rotate;
3312 }
3313
3314out:
3315 ocfs2_free_path(tmp_path);
3316 ocfs2_free_path(restart_path);
3317 return ret;
3318}
3319
3320static void ocfs2_cleanup_merge(struct ocfs2_extent_list *el,
3321 int index)
3322{
3323 struct ocfs2_extent_rec *rec = &el->l_recs[index];
3324 unsigned int size;
3325
3326 if (rec->e_leaf_clusters == 0) {
3327
3328
3329
3330
3331
3332
3333
3334
3335
3336
3337 if (index > 0) {
3338 BUG_ON(ocfs2_is_empty_extent(&el->l_recs[0]));
3339 size = index * sizeof(struct ocfs2_extent_rec);
3340 memmove(&el->l_recs[1], &el->l_recs[0], size);
3341 }
3342
3343
3344
3345
3346
3347
3348 memset(&el->l_recs[0], 0, sizeof(struct ocfs2_extent_rec));
3349 }
3350}
3351
3352static int ocfs2_get_right_path(struct ocfs2_extent_tree *et,
3353 struct ocfs2_path *left_path,
3354 struct ocfs2_path **ret_right_path)
3355{
3356 int ret;
3357 u32 right_cpos;
3358 struct ocfs2_path *right_path = NULL;
3359 struct ocfs2_extent_list *left_el;
3360
3361 *ret_right_path = NULL;
3362
3363
3364 BUG_ON(left_path->p_tree_depth == 0);
3365
3366 left_el = path_leaf_el(left_path);
3367 BUG_ON(left_el->l_next_free_rec != left_el->l_count);
3368
3369 ret = ocfs2_find_cpos_for_right_leaf(ocfs2_metadata_cache_get_super(et->et_ci),
3370 left_path, &right_cpos);
3371 if (ret) {
3372 mlog_errno(ret);
3373 goto out;
3374 }
3375
3376
3377 BUG_ON(right_cpos == 0);
3378
3379 right_path = ocfs2_new_path_from_path(left_path);
3380 if (!right_path) {
3381 ret = -ENOMEM;
3382 mlog_errno(ret);
3383 goto out;
3384 }
3385
3386 ret = ocfs2_find_path(et->et_ci, right_path, right_cpos);
3387 if (ret) {
3388 mlog_errno(ret);
3389 goto out;
3390 }
3391
3392 *ret_right_path = right_path;
3393out:
3394 if (ret)
3395 ocfs2_free_path(right_path);
3396 return ret;
3397}
3398
3399
3400
3401
3402
3403
3404
3405
3406static int ocfs2_merge_rec_right(struct ocfs2_path *left_path,
3407 handle_t *handle,
3408 struct ocfs2_extent_tree *et,
3409 struct ocfs2_extent_rec *split_rec,
3410 int index)
3411{
3412 int ret, next_free, i;
3413 unsigned int split_clusters = le16_to_cpu(split_rec->e_leaf_clusters);
3414 struct ocfs2_extent_rec *left_rec;
3415 struct ocfs2_extent_rec *right_rec;
3416 struct ocfs2_extent_list *right_el;
3417 struct ocfs2_path *right_path = NULL;
3418 int subtree_index = 0;
3419 struct ocfs2_extent_list *el = path_leaf_el(left_path);
3420 struct buffer_head *bh = path_leaf_bh(left_path);
3421 struct buffer_head *root_bh = NULL;
3422
3423 BUG_ON(index >= le16_to_cpu(el->l_next_free_rec));
3424 left_rec = &el->l_recs[index];
3425
3426 if (index == le16_to_cpu(el->l_next_free_rec) - 1 &&
3427 le16_to_cpu(el->l_next_free_rec) == le16_to_cpu(el->l_count)) {
3428
3429 ret = ocfs2_get_right_path(et, left_path, &right_path);
3430 if (ret) {
3431 mlog_errno(ret);
3432 goto out;
3433 }
3434
3435 right_el = path_leaf_el(right_path);
3436 next_free = le16_to_cpu(right_el->l_next_free_rec);
3437 BUG_ON(next_free <= 0);
3438 right_rec = &right_el->l_recs[0];
3439 if (ocfs2_is_empty_extent(right_rec)) {
3440 BUG_ON(next_free <= 1);
3441 right_rec = &right_el->l_recs[1];
3442 }
3443
3444 BUG_ON(le32_to_cpu(left_rec->e_cpos) +
3445 le16_to_cpu(left_rec->e_leaf_clusters) !=
3446 le32_to_cpu(right_rec->e_cpos));
3447
3448 subtree_index = ocfs2_find_subtree_root(et, left_path,
3449 right_path);
3450
3451 ret = ocfs2_extend_rotate_transaction(handle, subtree_index,
3452 handle->h_buffer_credits,
3453 right_path);
3454 if (ret) {
3455 mlog_errno(ret);
3456 goto out;
3457 }
3458
3459 root_bh = left_path->p_node[subtree_index].bh;
3460 BUG_ON(root_bh != right_path->p_node[subtree_index].bh);
3461
3462 ret = ocfs2_path_bh_journal_access(handle, et->et_ci, right_path,
3463 subtree_index);
3464 if (ret) {
3465 mlog_errno(ret);
3466 goto out;
3467 }
3468
3469 for (i = subtree_index + 1;
3470 i < path_num_items(right_path); i++) {
3471 ret = ocfs2_path_bh_journal_access(handle, et->et_ci,
3472 right_path, i);
3473 if (ret) {
3474 mlog_errno(ret);
3475 goto out;
3476 }
3477
3478 ret = ocfs2_path_bh_journal_access(handle, et->et_ci,
3479 left_path, i);
3480 if (ret) {
3481 mlog_errno(ret);
3482 goto out;
3483 }
3484 }
3485
3486 } else {
3487 BUG_ON(index == le16_to_cpu(el->l_next_free_rec) - 1);
3488 right_rec = &el->l_recs[index + 1];
3489 }
3490
3491 ret = ocfs2_path_bh_journal_access(handle, et->et_ci, left_path,
3492 path_num_items(left_path) - 1);
3493 if (ret) {
3494 mlog_errno(ret);
3495 goto out;
3496 }
3497
3498 le16_add_cpu(&left_rec->e_leaf_clusters, -split_clusters);
3499
3500 le32_add_cpu(&right_rec->e_cpos, -split_clusters);
3501 le64_add_cpu(&right_rec->e_blkno,
3502 -ocfs2_clusters_to_blocks(ocfs2_metadata_cache_get_super(et->et_ci),
3503 split_clusters));
3504 le16_add_cpu(&right_rec->e_leaf_clusters, split_clusters);
3505
3506 ocfs2_cleanup_merge(el, index);
3507
3508 ret = ocfs2_journal_dirty(handle, bh);
3509 if (ret)
3510 mlog_errno(ret);
3511
3512 if (right_path) {
3513 ret = ocfs2_journal_dirty(handle, path_leaf_bh(right_path));
3514 if (ret)
3515 mlog_errno(ret);
3516
3517 ocfs2_complete_edge_insert(handle, left_path, right_path,
3518 subtree_index);
3519 }
3520out:
3521 if (right_path)
3522 ocfs2_free_path(right_path);
3523 return ret;
3524}
3525
3526static int ocfs2_get_left_path(struct ocfs2_extent_tree *et,
3527 struct ocfs2_path *right_path,
3528 struct ocfs2_path **ret_left_path)
3529{
3530 int ret;
3531 u32 left_cpos;
3532 struct ocfs2_path *left_path = NULL;
3533
3534 *ret_left_path = NULL;
3535
3536
3537 BUG_ON(right_path->p_tree_depth == 0);
3538
3539 ret = ocfs2_find_cpos_for_left_leaf(ocfs2_metadata_cache_get_super(et->et_ci),
3540 right_path, &left_cpos);
3541 if (ret) {
3542 mlog_errno(ret);
3543 goto out;
3544 }
3545
3546
3547 BUG_ON(left_cpos == 0);
3548
3549 left_path = ocfs2_new_path_from_path(right_path);
3550 if (!left_path) {
3551 ret = -ENOMEM;
3552 mlog_errno(ret);
3553 goto out;
3554 }
3555
3556 ret = ocfs2_find_path(et->et_ci, left_path, left_cpos);
3557 if (ret) {
3558 mlog_errno(ret);
3559 goto out;
3560 }
3561
3562 *ret_left_path = left_path;
3563out:
3564 if (ret)
3565 ocfs2_free_path(left_path);
3566 return ret;
3567}
3568
3569
3570
3571
3572
3573
3574
3575
3576
3577
3578
3579static int ocfs2_merge_rec_left(struct ocfs2_path *right_path,
3580 handle_t *handle,
3581 struct ocfs2_extent_tree *et,
3582 struct ocfs2_extent_rec *split_rec,
3583 struct ocfs2_cached_dealloc_ctxt *dealloc,
3584 int index)
3585{
3586 int ret, i, subtree_index = 0, has_empty_extent = 0;
3587 unsigned int split_clusters = le16_to_cpu(split_rec->e_leaf_clusters);
3588 struct ocfs2_extent_rec *left_rec;
3589 struct ocfs2_extent_rec *right_rec;
3590 struct ocfs2_extent_list *el = path_leaf_el(right_path);
3591 struct buffer_head *bh = path_leaf_bh(right_path);
3592 struct buffer_head *root_bh = NULL;
3593 struct ocfs2_path *left_path = NULL;
3594 struct ocfs2_extent_list *left_el;
3595
3596 BUG_ON(index < 0);
3597
3598 right_rec = &el->l_recs[index];
3599 if (index == 0) {
3600
3601 ret = ocfs2_get_left_path(et, right_path, &left_path);
3602 if (ret) {
3603 mlog_errno(ret);
3604 goto out;
3605 }
3606
3607 left_el = path_leaf_el(left_path);
3608 BUG_ON(le16_to_cpu(left_el->l_next_free_rec) !=
3609 le16_to_cpu(left_el->l_count));
3610
3611 left_rec = &left_el->l_recs[
3612 le16_to_cpu(left_el->l_next_free_rec) - 1];
3613 BUG_ON(le32_to_cpu(left_rec->e_cpos) +
3614 le16_to_cpu(left_rec->e_leaf_clusters) !=
3615 le32_to_cpu(split_rec->e_cpos));
3616
3617 subtree_index = ocfs2_find_subtree_root(et, left_path,
3618 right_path);
3619
3620 ret = ocfs2_extend_rotate_transaction(handle, subtree_index,
3621 handle->h_buffer_credits,
3622 left_path);
3623 if (ret) {
3624 mlog_errno(ret);
3625 goto out;
3626 }
3627
3628 root_bh = left_path->p_node[subtree_index].bh;
3629 BUG_ON(root_bh != right_path->p_node[subtree_index].bh);
3630
3631 ret = ocfs2_path_bh_journal_access(handle, et->et_ci, right_path,
3632 subtree_index);
3633 if (ret) {
3634 mlog_errno(ret);
3635 goto out;
3636 }
3637
3638 for (i = subtree_index + 1;
3639 i < path_num_items(right_path); i++) {
3640 ret = ocfs2_path_bh_journal_access(handle, et->et_ci,
3641 right_path, i);
3642 if (ret) {
3643 mlog_errno(ret);
3644 goto out;
3645 }
3646
3647 ret = ocfs2_path_bh_journal_access(handle, et->et_ci,
3648 left_path, i);
3649 if (ret) {
3650 mlog_errno(ret);
3651 goto out;
3652 }
3653 }
3654 } else {
3655 left_rec = &el->l_recs[index - 1];
3656 if (ocfs2_is_empty_extent(&el->l_recs[0]))
3657 has_empty_extent = 1;
3658 }
3659
3660 ret = ocfs2_path_bh_journal_access(handle, et->et_ci, right_path,
3661 path_num_items(right_path) - 1);
3662 if (ret) {
3663 mlog_errno(ret);
3664 goto out;
3665 }
3666
3667 if (has_empty_extent && index == 1) {
3668
3669
3670
3671 *left_rec = *split_rec;
3672
3673 has_empty_extent = 0;
3674 } else
3675 le16_add_cpu(&left_rec->e_leaf_clusters, split_clusters);
3676
3677 le32_add_cpu(&right_rec->e_cpos, split_clusters);
3678 le64_add_cpu(&right_rec->e_blkno,
3679 ocfs2_clusters_to_blocks(ocfs2_metadata_cache_get_super(et->et_ci),
3680 split_clusters));
3681 le16_add_cpu(&right_rec->e_leaf_clusters, -split_clusters);
3682
3683 ocfs2_cleanup_merge(el, index);
3684
3685 ret = ocfs2_journal_dirty(handle, bh);
3686 if (ret)
3687 mlog_errno(ret);
3688
3689 if (left_path) {
3690 ret = ocfs2_journal_dirty(handle, path_leaf_bh(left_path));
3691 if (ret)
3692 mlog_errno(ret);
3693
3694
3695
3696
3697
3698
3699 if (le16_to_cpu(right_rec->e_leaf_clusters) == 0 &&
3700 le16_to_cpu(el->l_next_free_rec) == 1) {
3701
3702 ret = ocfs2_remove_rightmost_path(handle, et,
3703 right_path,
3704 dealloc);
3705 if (ret) {
3706 mlog_errno(ret);
3707 goto out;
3708 }
3709
3710
3711
3712
3713 ocfs2_mv_path(right_path, left_path);
3714 left_path = NULL;
3715 } else
3716 ocfs2_complete_edge_insert(handle, left_path,
3717 right_path, subtree_index);
3718 }
3719out:
3720 if (left_path)
3721 ocfs2_free_path(left_path);
3722 return ret;
3723}
3724
3725static int ocfs2_try_to_merge_extent(handle_t *handle,
3726 struct ocfs2_extent_tree *et,
3727 struct ocfs2_path *path,
3728 int split_index,
3729 struct ocfs2_extent_rec *split_rec,
3730 struct ocfs2_cached_dealloc_ctxt *dealloc,
3731 struct ocfs2_merge_ctxt *ctxt)
3732{
3733 int ret = 0;
3734 struct ocfs2_extent_list *el = path_leaf_el(path);
3735 struct ocfs2_extent_rec *rec = &el->l_recs[split_index];
3736
3737 BUG_ON(ctxt->c_contig_type == CONTIG_NONE);
3738
3739 if (ctxt->c_split_covers_rec && ctxt->c_has_empty_extent) {
3740
3741
3742
3743
3744
3745
3746
3747 ret = ocfs2_rotate_tree_left(handle, et, path, dealloc);
3748 if (ret) {
3749 mlog_errno(ret);
3750 goto out;
3751 }
3752 split_index--;
3753 rec = &el->l_recs[split_index];
3754 }
3755
3756 if (ctxt->c_contig_type == CONTIG_LEFTRIGHT) {
3757
3758
3759
3760 BUG_ON(!ctxt->c_split_covers_rec);
3761
3762
3763
3764
3765
3766
3767
3768
3769
3770
3771
3772
3773
3774
3775
3776 ret = ocfs2_merge_rec_right(path, handle, et, split_rec,
3777 split_index);
3778 if (ret) {
3779 mlog_errno(ret);
3780 goto out;
3781 }
3782
3783
3784
3785
3786 BUG_ON(!ocfs2_is_empty_extent(&el->l_recs[0]));
3787
3788
3789 ret = ocfs2_rotate_tree_left(handle, et, path, dealloc);
3790 if (ret) {
3791 mlog_errno(ret);
3792 goto out;
3793 }
3794
3795 rec = &el->l_recs[split_index];
3796
3797
3798
3799
3800
3801 ret = ocfs2_merge_rec_left(path, handle, et, rec,
3802 dealloc, split_index);
3803
3804 if (ret) {
3805 mlog_errno(ret);
3806 goto out;
3807 }
3808
3809 ret = ocfs2_rotate_tree_left(handle, et, path, dealloc);
3810
3811
3812
3813
3814 if (ret)
3815 mlog_errno(ret);
3816 ret = 0;
3817 } else {
3818
3819
3820
3821
3822
3823
3824
3825 if (ctxt->c_contig_type == CONTIG_RIGHT) {
3826 ret = ocfs2_merge_rec_left(path, handle, et,
3827 split_rec, dealloc,
3828 split_index);
3829 if (ret) {
3830 mlog_errno(ret);
3831 goto out;
3832 }
3833 } else {
3834 ret = ocfs2_merge_rec_right(path, handle,
3835 et, split_rec,
3836 split_index);
3837 if (ret) {
3838 mlog_errno(ret);
3839 goto out;
3840 }
3841 }
3842
3843 if (ctxt->c_split_covers_rec) {
3844
3845
3846
3847
3848 ret = ocfs2_rotate_tree_left(handle, et, path,
3849 dealloc);
3850 if (ret)
3851 mlog_errno(ret);
3852 ret = 0;
3853 }
3854 }
3855
3856out:
3857 return ret;
3858}
3859
3860static void ocfs2_subtract_from_rec(struct super_block *sb,
3861 enum ocfs2_split_type split,
3862 struct ocfs2_extent_rec *rec,
3863 struct ocfs2_extent_rec *split_rec)
3864{
3865 u64 len_blocks;
3866
3867 len_blocks = ocfs2_clusters_to_blocks(sb,
3868 le16_to_cpu(split_rec->e_leaf_clusters));
3869
3870 if (split == SPLIT_LEFT) {
3871
3872
3873
3874
3875 le32_add_cpu(&rec->e_cpos,
3876 le16_to_cpu(split_rec->e_leaf_clusters));
3877 le64_add_cpu(&rec->e_blkno, len_blocks);
3878 le16_add_cpu(&rec->e_leaf_clusters,
3879 -le16_to_cpu(split_rec->e_leaf_clusters));
3880 } else {
3881
3882
3883
3884
3885 le16_add_cpu(&rec->e_leaf_clusters,
3886 -le16_to_cpu(split_rec->e_leaf_clusters));
3887 }
3888}
3889
3890
3891
3892
3893
3894
3895static void ocfs2_insert_at_leaf(struct ocfs2_extent_tree *et,
3896 struct ocfs2_extent_rec *insert_rec,
3897 struct ocfs2_extent_list *el,
3898 struct ocfs2_insert_type *insert)
3899{
3900 int i = insert->ins_contig_index;
3901 unsigned int range;
3902 struct ocfs2_extent_rec *rec;
3903
3904 BUG_ON(le16_to_cpu(el->l_tree_depth) != 0);
3905
3906 if (insert->ins_split != SPLIT_NONE) {
3907 i = ocfs2_search_extent_list(el, le32_to_cpu(insert_rec->e_cpos));
3908 BUG_ON(i == -1);
3909 rec = &el->l_recs[i];
3910 ocfs2_subtract_from_rec(ocfs2_metadata_cache_get_super(et->et_ci),
3911 insert->ins_split, rec,
3912 insert_rec);
3913 goto rotate;
3914 }
3915
3916
3917
3918
3919 if (insert->ins_contig != CONTIG_NONE) {
3920 rec = &el->l_recs[i];
3921 if (insert->ins_contig == CONTIG_LEFT) {
3922 rec->e_blkno = insert_rec->e_blkno;
3923 rec->e_cpos = insert_rec->e_cpos;
3924 }
3925 le16_add_cpu(&rec->e_leaf_clusters,
3926 le16_to_cpu(insert_rec->e_leaf_clusters));
3927 return;
3928 }
3929
3930
3931
3932
3933 if (le16_to_cpu(el->l_next_free_rec) == 0 ||
3934 ((le16_to_cpu(el->l_next_free_rec) == 1) &&
3935 ocfs2_is_empty_extent(&el->l_recs[0]))) {
3936 el->l_recs[0] = *insert_rec;
3937 el->l_next_free_rec = cpu_to_le16(1);
3938 return;
3939 }
3940
3941
3942
3943
3944 if (insert->ins_appending == APPEND_TAIL) {
3945 i = le16_to_cpu(el->l_next_free_rec) - 1;
3946 rec = &el->l_recs[i];
3947 range = le32_to_cpu(rec->e_cpos)
3948 + le16_to_cpu(rec->e_leaf_clusters);
3949 BUG_ON(le32_to_cpu(insert_rec->e_cpos) < range);
3950
3951 mlog_bug_on_msg(le16_to_cpu(el->l_next_free_rec) >=
3952 le16_to_cpu(el->l_count),
3953 "owner %llu, depth %u, count %u, next free %u, "
3954 "rec.cpos %u, rec.clusters %u, "
3955 "insert.cpos %u, insert.clusters %u\n",
3956 ocfs2_metadata_cache_owner(et->et_ci),
3957 le16_to_cpu(el->l_tree_depth),
3958 le16_to_cpu(el->l_count),
3959 le16_to_cpu(el->l_next_free_rec),
3960 le32_to_cpu(el->l_recs[i].e_cpos),
3961 le16_to_cpu(el->l_recs[i].e_leaf_clusters),
3962 le32_to_cpu(insert_rec->e_cpos),
3963 le16_to_cpu(insert_rec->e_leaf_clusters));
3964 i++;
3965 el->l_recs[i] = *insert_rec;
3966 le16_add_cpu(&el->l_next_free_rec, 1);
3967 return;
3968 }
3969
3970rotate:
3971
3972
3973
3974
3975
3976
3977
3978
3979
3980
3981 ocfs2_rotate_leaf(el, insert_rec);
3982}
3983
3984static void ocfs2_adjust_rightmost_records(handle_t *handle,
3985 struct ocfs2_extent_tree *et,
3986 struct ocfs2_path *path,
3987 struct ocfs2_extent_rec *insert_rec)
3988{
3989 int ret, i, next_free;
3990 struct buffer_head *bh;
3991 struct ocfs2_extent_list *el;
3992 struct ocfs2_extent_rec *rec;
3993
3994
3995
3996
3997 for (i = 0; i < path->p_tree_depth; i++) {
3998 bh = path->p_node[i].bh;
3999 el = path->p_node[i].el;
4000
4001 next_free = le16_to_cpu(el->l_next_free_rec);
4002 if (next_free == 0) {
4003 ocfs2_error(ocfs2_metadata_cache_get_super(et->et_ci),
4004 "Owner %llu has a bad extent list",
4005 (unsigned long long)ocfs2_metadata_cache_owner(et->et_ci));
4006 ret = -EIO;
4007 return;
4008 }
4009
4010 rec = &el->l_recs[next_free - 1];
4011
4012 rec->e_int_clusters = insert_rec->e_cpos;
4013 le32_add_cpu(&rec->e_int_clusters,
4014 le16_to_cpu(insert_rec->e_leaf_clusters));
4015 le32_add_cpu(&rec->e_int_clusters,
4016 -le32_to_cpu(rec->e_cpos));
4017
4018 ret = ocfs2_journal_dirty(handle, bh);
4019 if (ret)
4020 mlog_errno(ret);
4021
4022 }
4023}
4024
4025static int ocfs2_append_rec_to_path(handle_t *handle,
4026 struct ocfs2_extent_tree *et,
4027 struct ocfs2_extent_rec *insert_rec,
4028 struct ocfs2_path *right_path,
4029 struct ocfs2_path **ret_left_path)
4030{
4031 int ret, next_free;
4032 struct ocfs2_extent_list *el;
4033 struct ocfs2_path *left_path = NULL;
4034
4035 *ret_left_path = NULL;
4036
4037
4038
4039
4040
4041 BUG_ON(right_path->p_tree_depth == 0);
4042
4043
4044
4045
4046
4047
4048 el = path_leaf_el(right_path);
4049 next_free = le16_to_cpu(el->l_next_free_rec);
4050 if (next_free == 0 ||
4051 (next_free == 1 && ocfs2_is_empty_extent(&el->l_recs[0]))) {
4052 u32 left_cpos;
4053
4054 ret = ocfs2_find_cpos_for_left_leaf(ocfs2_metadata_cache_get_super(et->et_ci),
4055 right_path, &left_cpos);
4056 if (ret) {
4057 mlog_errno(ret);
4058 goto out;
4059 }
4060
4061 mlog(0, "Append may need a left path update. cpos: %u, "
4062 "left_cpos: %u\n", le32_to_cpu(insert_rec->e_cpos),
4063 left_cpos);
4064
4065
4066
4067
4068
4069 if (left_cpos) {
4070 left_path = ocfs2_new_path_from_path(right_path);
4071 if (!left_path) {
4072 ret = -ENOMEM;
4073 mlog_errno(ret);
4074 goto out;
4075 }
4076
4077 ret = ocfs2_find_path(et->et_ci, left_path,
4078 left_cpos);
4079 if (ret) {
4080 mlog_errno(ret);
4081 goto out;
4082 }
4083
4084
4085
4086
4087
4088 }
4089 }
4090
4091 ret = ocfs2_journal_access_path(et->et_ci, handle, right_path);
4092 if (ret) {
4093 mlog_errno(ret);
4094 goto out;
4095 }
4096
4097 ocfs2_adjust_rightmost_records(handle, et, right_path, insert_rec);
4098
4099 *ret_left_path = left_path;
4100 ret = 0;
4101out:
4102 if (ret != 0)
4103 ocfs2_free_path(left_path);
4104
4105 return ret;
4106}
4107
4108static void ocfs2_split_record(struct ocfs2_extent_tree *et,
4109 struct ocfs2_path *left_path,
4110 struct ocfs2_path *right_path,
4111 struct ocfs2_extent_rec *split_rec,
4112 enum ocfs2_split_type split)
4113{
4114 int index;
4115 u32 cpos = le32_to_cpu(split_rec->e_cpos);
4116 struct ocfs2_extent_list *left_el = NULL, *right_el, *insert_el, *el;
4117 struct ocfs2_extent_rec *rec, *tmprec;
4118
4119 right_el = path_leaf_el(right_path);
4120 if (left_path)
4121 left_el = path_leaf_el(left_path);
4122
4123 el = right_el;
4124 insert_el = right_el;
4125 index = ocfs2_search_extent_list(el, cpos);
4126 if (index != -1) {
4127 if (index == 0 && left_path) {
4128 BUG_ON(ocfs2_is_empty_extent(&el->l_recs[0]));
4129
4130
4131
4132
4133
4134
4135
4136
4137
4138
4139
4140
4141
4142 if (split == SPLIT_LEFT) {
4143
4144
4145
4146
4147
4148
4149 insert_el = left_el;
4150 } else {
4151
4152
4153
4154
4155
4156
4157
4158 tmprec = &right_el->l_recs[index];
4159 ocfs2_rotate_leaf(left_el, tmprec);
4160 el = left_el;
4161
4162 memset(tmprec, 0, sizeof(*tmprec));
4163 index = ocfs2_search_extent_list(left_el, cpos);
4164 BUG_ON(index == -1);
4165 }
4166 }
4167 } else {
4168 BUG_ON(!left_path);
4169 BUG_ON(!ocfs2_is_empty_extent(&left_el->l_recs[0]));
4170
4171
4172
4173
4174 el = left_el;
4175 insert_el = left_el;
4176 index = ocfs2_search_extent_list(el, cpos);
4177 BUG_ON(index == -1);
4178 }
4179
4180 rec = &el->l_recs[index];
4181 ocfs2_subtract_from_rec(ocfs2_metadata_cache_get_super(et->et_ci),
4182 split, rec, split_rec);
4183 ocfs2_rotate_leaf(insert_el, split_rec);
4184}
4185
4186
4187
4188
4189
4190
4191
4192
4193
4194static int ocfs2_insert_path(handle_t *handle,
4195 struct ocfs2_extent_tree *et,
4196 struct ocfs2_path *left_path,
4197 struct ocfs2_path *right_path,
4198 struct ocfs2_extent_rec *insert_rec,
4199 struct ocfs2_insert_type *insert)
4200{
4201 int ret, subtree_index;
4202 struct buffer_head *leaf_bh = path_leaf_bh(right_path);
4203
4204 if (left_path) {
4205 int credits = handle->h_buffer_credits;
4206
4207
4208
4209
4210
4211
4212
4213 credits += left_path->p_tree_depth;
4214
4215 ret = ocfs2_extend_trans(handle, credits);
4216 if (ret < 0) {
4217 mlog_errno(ret);
4218 goto out;
4219 }
4220
4221 ret = ocfs2_journal_access_path(et->et_ci, handle, left_path);
4222 if (ret < 0) {
4223 mlog_errno(ret);
4224 goto out;
4225 }
4226 }
4227
4228
4229
4230
4231
4232 ret = ocfs2_journal_access_path(et->et_ci, handle, right_path);
4233 if (ret < 0) {
4234 mlog_errno(ret);
4235 goto out;
4236 }
4237
4238 if (insert->ins_split != SPLIT_NONE) {
4239
4240
4241
4242
4243
4244 ocfs2_split_record(et, left_path, right_path,
4245 insert_rec, insert->ins_split);
4246
4247
4248
4249
4250
4251
4252 if (left_path)
4253 ret = ocfs2_journal_dirty(handle,
4254 path_leaf_bh(left_path));
4255 if (ret)
4256 mlog_errno(ret);
4257 } else
4258 ocfs2_insert_at_leaf(et, insert_rec, path_leaf_el(right_path),
4259 insert);
4260
4261 ret = ocfs2_journal_dirty(handle, leaf_bh);
4262 if (ret)
4263 mlog_errno(ret);
4264
4265 if (left_path) {
4266
4267
4268
4269
4270
4271
4272 subtree_index = ocfs2_find_subtree_root(et, left_path,
4273 right_path);
4274 ocfs2_complete_edge_insert(handle, left_path, right_path,
4275 subtree_index);
4276 }
4277
4278 ret = 0;
4279out:
4280 return ret;
4281}
4282
4283static int ocfs2_do_insert_extent(handle_t *handle,
4284 struct ocfs2_extent_tree *et,
4285 struct ocfs2_extent_rec *insert_rec,
4286 struct ocfs2_insert_type *type)
4287{
4288 int ret, rotate = 0;
4289 u32 cpos;
4290 struct ocfs2_path *right_path = NULL;
4291 struct ocfs2_path *left_path = NULL;
4292 struct ocfs2_extent_list *el;
4293
4294 el = et->et_root_el;
4295
4296 ret = ocfs2_et_root_journal_access(handle, et,
4297 OCFS2_JOURNAL_ACCESS_WRITE);
4298 if (ret) {
4299 mlog_errno(ret);
4300 goto out;
4301 }
4302
4303 if (le16_to_cpu(el->l_tree_depth) == 0) {
4304 ocfs2_insert_at_leaf(et, insert_rec, el, type);
4305 goto out_update_clusters;
4306 }
4307
4308 right_path = ocfs2_new_path_from_et(et);
4309 if (!right_path) {
4310 ret = -ENOMEM;
4311 mlog_errno(ret);
4312 goto out;
4313 }
4314
4315
4316
4317
4318
4319
4320 cpos = le32_to_cpu(insert_rec->e_cpos);
4321 if (type->ins_appending == APPEND_NONE &&
4322 type->ins_contig == CONTIG_NONE) {
4323 rotate = 1;
4324 cpos = UINT_MAX;
4325 }
4326
4327 ret = ocfs2_find_path(et->et_ci, right_path, cpos);
4328 if (ret) {
4329 mlog_errno(ret);
4330 goto out;
4331 }
4332
4333
4334
4335
4336
4337
4338
4339
4340
4341
4342
4343
4344
4345 if (rotate) {
4346 ret = ocfs2_rotate_tree_right(handle, et, type->ins_split,
4347 le32_to_cpu(insert_rec->e_cpos),
4348 right_path, &left_path);
4349 if (ret) {
4350 mlog_errno(ret);
4351 goto out;
4352 }
4353
4354
4355
4356
4357
4358 ret = ocfs2_et_root_journal_access(handle, et,
4359 OCFS2_JOURNAL_ACCESS_WRITE);
4360 if (ret) {
4361 mlog_errno(ret);
4362 goto out;
4363 }
4364 } else if (type->ins_appending == APPEND_TAIL
4365 && type->ins_contig != CONTIG_LEFT) {
4366 ret = ocfs2_append_rec_to_path(handle, et, insert_rec,
4367 right_path, &left_path);
4368 if (ret) {
4369 mlog_errno(ret);
4370 goto out;
4371 }
4372 }
4373
4374 ret = ocfs2_insert_path(handle, et, left_path, right_path,
4375 insert_rec, type);
4376 if (ret) {
4377 mlog_errno(ret);
4378 goto out;
4379 }
4380
4381out_update_clusters:
4382 if (type->ins_split == SPLIT_NONE)
4383 ocfs2_et_update_clusters(et,
4384 le16_to_cpu(insert_rec->e_leaf_clusters));
4385
4386 ret = ocfs2_journal_dirty(handle, et->et_root_bh);
4387 if (ret)
4388 mlog_errno(ret);
4389
4390out:
4391 ocfs2_free_path(left_path);
4392 ocfs2_free_path(right_path);
4393
4394 return ret;
4395}
4396
4397static enum ocfs2_contig_type
4398ocfs2_figure_merge_contig_type(struct ocfs2_extent_tree *et,
4399 struct ocfs2_path *path,
4400 struct ocfs2_extent_list *el, int index,
4401 struct ocfs2_extent_rec *split_rec)
4402{
4403 int status;
4404 enum ocfs2_contig_type ret = CONTIG_NONE;
4405 u32 left_cpos, right_cpos;
4406 struct ocfs2_extent_rec *rec = NULL;
4407 struct ocfs2_extent_list *new_el;
4408 struct ocfs2_path *left_path = NULL, *right_path = NULL;
4409 struct buffer_head *bh;
4410 struct ocfs2_extent_block *eb;
4411 struct super_block *sb = ocfs2_metadata_cache_get_super(et->et_ci);
4412
4413 if (index > 0) {
4414 rec = &el->l_recs[index - 1];
4415 } else if (path->p_tree_depth > 0) {
4416 status = ocfs2_find_cpos_for_left_leaf(sb, path, &left_cpos);
4417 if (status)
4418 goto out;
4419
4420 if (left_cpos != 0) {
4421 left_path = ocfs2_new_path_from_path(path);
4422 if (!left_path)
4423 goto out;
4424
4425 status = ocfs2_find_path(et->et_ci, left_path,
4426 left_cpos);
4427 if (status)
4428 goto out;
4429
4430 new_el = path_leaf_el(left_path);
4431
4432 if (le16_to_cpu(new_el->l_next_free_rec) !=
4433 le16_to_cpu(new_el->l_count)) {
4434 bh = path_leaf_bh(left_path);
4435 eb = (struct ocfs2_extent_block *)bh->b_data;
4436 ocfs2_error(sb,
4437 "Extent block #%llu has an "
4438 "invalid l_next_free_rec of "
4439 "%d. It should have "
4440 "matched the l_count of %d",
4441 (unsigned long long)le64_to_cpu(eb->h_blkno),
4442 le16_to_cpu(new_el->l_next_free_rec),
4443 le16_to_cpu(new_el->l_count));
4444 status = -EINVAL;
4445 goto out;
4446 }
4447 rec = &new_el->l_recs[
4448 le16_to_cpu(new_el->l_next_free_rec) - 1];
4449 }
4450 }
4451
4452
4453
4454
4455
4456 if (rec) {
4457 if (index == 1 && ocfs2_is_empty_extent(rec)) {
4458 if (split_rec->e_cpos == el->l_recs[index].e_cpos)
4459 ret = CONTIG_RIGHT;
4460 } else {
4461 ret = ocfs2_et_extent_contig(et, rec, split_rec);
4462 }
4463 }
4464
4465 rec = NULL;
4466 if (index < (le16_to_cpu(el->l_next_free_rec) - 1))
4467 rec = &el->l_recs[index + 1];
4468 else if (le16_to_cpu(el->l_next_free_rec) == le16_to_cpu(el->l_count) &&
4469 path->p_tree_depth > 0) {
4470 status = ocfs2_find_cpos_for_right_leaf(sb, path, &right_cpos);
4471 if (status)
4472 goto out;
4473
4474 if (right_cpos == 0)
4475 goto out;
4476
4477 right_path = ocfs2_new_path_from_path(path);
4478 if (!right_path)
4479 goto out;
4480
4481 status = ocfs2_find_path(et->et_ci, right_path, right_cpos);
4482 if (status)
4483 goto out;
4484
4485 new_el = path_leaf_el(right_path);
4486 rec = &new_el->l_recs[0];
4487 if (ocfs2_is_empty_extent(rec)) {
4488 if (le16_to_cpu(new_el->l_next_free_rec) <= 1) {
4489 bh = path_leaf_bh(right_path);
4490 eb = (struct ocfs2_extent_block *)bh->b_data;
4491 ocfs2_error(sb,
4492 "Extent block #%llu has an "
4493 "invalid l_next_free_rec of %d",
4494 (unsigned long long)le64_to_cpu(eb->h_blkno),
4495 le16_to_cpu(new_el->l_next_free_rec));
4496 status = -EINVAL;
4497 goto out;
4498 }
4499 rec = &new_el->l_recs[1];
4500 }
4501 }
4502
4503 if (rec) {
4504 enum ocfs2_contig_type contig_type;
4505
4506 contig_type = ocfs2_et_extent_contig(et, rec, split_rec);
4507
4508 if (contig_type == CONTIG_LEFT && ret == CONTIG_RIGHT)
4509 ret = CONTIG_LEFTRIGHT;
4510 else if (ret == CONTIG_NONE)
4511 ret = contig_type;
4512 }
4513
4514out:
4515 if (left_path)
4516 ocfs2_free_path(left_path);
4517 if (right_path)
4518 ocfs2_free_path(right_path);
4519
4520 return ret;
4521}
4522
4523static void ocfs2_figure_contig_type(struct ocfs2_extent_tree *et,
4524 struct ocfs2_insert_type *insert,
4525 struct ocfs2_extent_list *el,
4526 struct ocfs2_extent_rec *insert_rec)
4527{
4528 int i;
4529 enum ocfs2_contig_type contig_type = CONTIG_NONE;
4530
4531 BUG_ON(le16_to_cpu(el->l_tree_depth) != 0);
4532
4533 for(i = 0; i < le16_to_cpu(el->l_next_free_rec); i++) {
4534 contig_type = ocfs2_et_extent_contig(et, &el->l_recs[i],
4535 insert_rec);
4536 if (contig_type != CONTIG_NONE) {
4537 insert->ins_contig_index = i;
4538 break;
4539 }
4540 }
4541 insert->ins_contig = contig_type;
4542
4543 if (insert->ins_contig != CONTIG_NONE) {
4544 struct ocfs2_extent_rec *rec =
4545 &el->l_recs[insert->ins_contig_index];
4546 unsigned int len = le16_to_cpu(rec->e_leaf_clusters) +
4547 le16_to_cpu(insert_rec->e_leaf_clusters);
4548
4549
4550
4551
4552
4553 if (et->et_max_leaf_clusters &&
4554 (len > et->et_max_leaf_clusters))
4555 insert->ins_contig = CONTIG_NONE;
4556 }
4557}
4558
4559
4560
4561
4562
4563
4564
4565
4566
4567
4568
4569static void ocfs2_figure_appending_type(struct ocfs2_insert_type *insert,
4570 struct ocfs2_extent_list *el,
4571 struct ocfs2_extent_rec *insert_rec)
4572{
4573 int i;
4574 u32 cpos = le32_to_cpu(insert_rec->e_cpos);
4575 struct ocfs2_extent_rec *rec;
4576
4577 insert->ins_appending = APPEND_NONE;
4578
4579 BUG_ON(le16_to_cpu(el->l_tree_depth) != 0);
4580
4581 if (!el->l_next_free_rec)
4582 goto set_tail_append;
4583
4584 if (ocfs2_is_empty_extent(&el->l_recs[0])) {
4585
4586 if (le16_to_cpu(el->l_next_free_rec) == 1)
4587 goto set_tail_append;
4588 }
4589
4590 i = le16_to_cpu(el->l_next_free_rec) - 1;
4591 rec = &el->l_recs[i];
4592
4593 if (cpos >=
4594 (le32_to_cpu(rec->e_cpos) + le16_to_cpu(rec->e_leaf_clusters)))
4595 goto set_tail_append;
4596
4597 return;
4598
4599set_tail_append:
4600 insert->ins_appending = APPEND_TAIL;
4601}
4602
4603
4604
4605
4606
4607
4608
4609
4610
4611
4612
4613
4614
4615
4616static int ocfs2_figure_insert_type(struct ocfs2_extent_tree *et,
4617 struct buffer_head **last_eb_bh,
4618 struct ocfs2_extent_rec *insert_rec,
4619 int *free_records,
4620 struct ocfs2_insert_type *insert)
4621{
4622 int ret;
4623 struct ocfs2_extent_block *eb;
4624 struct ocfs2_extent_list *el;
4625 struct ocfs2_path *path = NULL;
4626 struct buffer_head *bh = NULL;
4627
4628 insert->ins_split = SPLIT_NONE;
4629
4630 el = et->et_root_el;
4631 insert->ins_tree_depth = le16_to_cpu(el->l_tree_depth);
4632
4633 if (el->l_tree_depth) {
4634
4635
4636
4637
4638
4639
4640 ret = ocfs2_read_extent_block(et->et_ci,
4641 ocfs2_et_get_last_eb_blk(et),
4642 &bh);
4643 if (ret) {
4644 mlog_exit(ret);
4645 goto out;
4646 }
4647 eb = (struct ocfs2_extent_block *) bh->b_data;
4648 el = &eb->h_list;
4649 }
4650
4651
4652
4653
4654
4655
4656
4657
4658
4659 *free_records = le16_to_cpu(el->l_count) -
4660 le16_to_cpu(el->l_next_free_rec);
4661
4662 if (!insert->ins_tree_depth) {
4663 ocfs2_figure_contig_type(et, insert, el, insert_rec);
4664 ocfs2_figure_appending_type(insert, el, insert_rec);
4665 return 0;
4666 }
4667
4668 path = ocfs2_new_path_from_et(et);
4669 if (!path) {
4670 ret = -ENOMEM;
4671 mlog_errno(ret);
4672 goto out;
4673 }
4674
4675
4676
4677
4678
4679
4680
4681 ret = ocfs2_find_path(et->et_ci, path, le32_to_cpu(insert_rec->e_cpos));
4682 if (ret) {
4683 mlog_errno(ret);
4684 goto out;
4685 }
4686
4687 el = path_leaf_el(path);
4688
4689
4690
4691
4692
4693
4694
4695
4696
4697 ocfs2_figure_contig_type(et, insert, el, insert_rec);
4698
4699
4700
4701
4702
4703
4704
4705
4706
4707
4708 if (insert->ins_contig == CONTIG_LEFT &&
4709 insert->ins_contig_index == 0)
4710 insert->ins_contig = CONTIG_NONE;
4711
4712
4713
4714
4715
4716
4717
4718 if (ocfs2_et_get_last_eb_blk(et) ==
4719 path_leaf_bh(path)->b_blocknr) {
4720
4721
4722
4723
4724
4725
4726
4727
4728 ocfs2_figure_appending_type(insert, el, insert_rec);
4729 }
4730
4731out:
4732 ocfs2_free_path(path);
4733
4734 if (ret == 0)
4735 *last_eb_bh = bh;
4736 else
4737 brelse(bh);
4738 return ret;
4739}
4740
4741
4742
4743
4744
4745
4746int ocfs2_insert_extent(handle_t *handle,
4747 struct ocfs2_extent_tree *et,
4748 u32 cpos,
4749 u64 start_blk,
4750 u32 new_clusters,
4751 u8 flags,
4752 struct ocfs2_alloc_context *meta_ac)
4753{
4754 int status;
4755 int uninitialized_var(free_records);
4756 struct buffer_head *last_eb_bh = NULL;
4757 struct ocfs2_insert_type insert = {0, };
4758 struct ocfs2_extent_rec rec;
4759
4760 mlog(0, "add %u clusters at position %u to owner %llu\n",
4761 new_clusters, cpos,
4762 (unsigned long long)ocfs2_metadata_cache_owner(et->et_ci));
4763
4764 memset(&rec, 0, sizeof(rec));
4765 rec.e_cpos = cpu_to_le32(cpos);
4766 rec.e_blkno = cpu_to_le64(start_blk);
4767 rec.e_leaf_clusters = cpu_to_le16(new_clusters);
4768 rec.e_flags = flags;
4769 status = ocfs2_et_insert_check(et, &rec);
4770 if (status) {
4771 mlog_errno(status);
4772 goto bail;
4773 }
4774
4775 status = ocfs2_figure_insert_type(et, &last_eb_bh, &rec,
4776 &free_records, &insert);
4777 if (status < 0) {
4778 mlog_errno(status);
4779 goto bail;
4780 }
4781
4782 mlog(0, "Insert.appending: %u, Insert.Contig: %u, "
4783 "Insert.contig_index: %d, Insert.free_records: %d, "
4784 "Insert.tree_depth: %d\n",
4785 insert.ins_appending, insert.ins_contig, insert.ins_contig_index,
4786 free_records, insert.ins_tree_depth);
4787
4788 if (insert.ins_contig == CONTIG_NONE && free_records == 0) {
4789 status = ocfs2_grow_tree(handle, et,
4790 &insert.ins_tree_depth, &last_eb_bh,
4791 meta_ac);
4792 if (status) {
4793 mlog_errno(status);
4794 goto bail;
4795 }
4796 }
4797
4798
4799 status = ocfs2_do_insert_extent(handle, et, &rec, &insert);
4800 if (status < 0)
4801 mlog_errno(status);
4802 else
4803 ocfs2_et_extent_map_insert(et, &rec);
4804
4805bail:
4806 brelse(last_eb_bh);
4807
4808 mlog_exit(status);
4809 return status;
4810}
4811
4812
4813
4814
4815
4816
4817
4818
4819int ocfs2_add_clusters_in_btree(handle_t *handle,
4820 struct ocfs2_extent_tree *et,
4821 u32 *logical_offset,
4822 u32 clusters_to_add,
4823 int mark_unwritten,
4824 struct ocfs2_alloc_context *data_ac,
4825 struct ocfs2_alloc_context *meta_ac,
4826 enum ocfs2_alloc_restarted *reason_ret)
4827{
4828 int status = 0;
4829 int free_extents;
4830 enum ocfs2_alloc_restarted reason = RESTART_NONE;
4831 u32 bit_off, num_bits;
4832 u64 block;
4833 u8 flags = 0;
4834 struct ocfs2_super *osb =
4835 OCFS2_SB(ocfs2_metadata_cache_get_super(et->et_ci));
4836
4837 BUG_ON(!clusters_to_add);
4838
4839 if (mark_unwritten)
4840 flags = OCFS2_EXT_UNWRITTEN;
4841
4842 free_extents = ocfs2_num_free_extents(osb, et);
4843 if (free_extents < 0) {
4844 status = free_extents;
4845 mlog_errno(status);
4846 goto leave;
4847 }
4848
4849
4850
4851
4852
4853
4854 if (!free_extents && !meta_ac) {
4855 mlog(0, "we haven't reserved any metadata!\n");
4856 status = -EAGAIN;
4857 reason = RESTART_META;
4858 goto leave;
4859 } else if ((!free_extents)
4860 && (ocfs2_alloc_context_bits_left(meta_ac)
4861 < ocfs2_extend_meta_needed(et->et_root_el))) {
4862 mlog(0, "filesystem is really fragmented...\n");
4863 status = -EAGAIN;
4864 reason = RESTART_META;
4865 goto leave;
4866 }
4867
4868 status = __ocfs2_claim_clusters(osb, handle, data_ac, 1,
4869 clusters_to_add, &bit_off, &num_bits);
4870 if (status < 0) {
4871 if (status != -ENOSPC)
4872 mlog_errno(status);
4873 goto leave;
4874 }
4875
4876 BUG_ON(num_bits > clusters_to_add);
4877
4878
4879 status = ocfs2_et_root_journal_access(handle, et,
4880 OCFS2_JOURNAL_ACCESS_WRITE);
4881 if (status < 0) {
4882 mlog_errno(status);
4883 goto leave;
4884 }
4885
4886 block = ocfs2_clusters_to_blocks(osb->sb, bit_off);
4887 mlog(0, "Allocating %u clusters at block %u for owner %llu\n",
4888 num_bits, bit_off,
4889 (unsigned long long)ocfs2_metadata_cache_owner(et->et_ci));
4890 status = ocfs2_insert_extent(handle, et, *logical_offset, block,
4891 num_bits, flags, meta_ac);
4892 if (status < 0) {
4893 mlog_errno(status);
4894 goto leave;
4895 }
4896
4897 status = ocfs2_journal_dirty(handle, et->et_root_bh);
4898 if (status < 0) {
4899 mlog_errno(status);
4900 goto leave;
4901 }
4902
4903 clusters_to_add -= num_bits;
4904 *logical_offset += num_bits;
4905
4906 if (clusters_to_add) {
4907 mlog(0, "need to alloc once more, wanted = %u\n",
4908 clusters_to_add);
4909 status = -EAGAIN;
4910 reason = RESTART_TRANS;
4911 }
4912
4913leave:
4914 mlog_exit(status);
4915 if (reason_ret)
4916 *reason_ret = reason;
4917 return status;
4918}
4919
4920static void ocfs2_make_right_split_rec(struct super_block *sb,
4921 struct ocfs2_extent_rec *split_rec,
4922 u32 cpos,
4923 struct ocfs2_extent_rec *rec)
4924{
4925 u32 rec_cpos = le32_to_cpu(rec->e_cpos);
4926 u32 rec_range = rec_cpos + le16_to_cpu(rec->e_leaf_clusters);
4927
4928 memset(split_rec, 0, sizeof(struct ocfs2_extent_rec));
4929
4930 split_rec->e_cpos = cpu_to_le32(cpos);
4931 split_rec->e_leaf_clusters = cpu_to_le16(rec_range - cpos);
4932
4933 split_rec->e_blkno = rec->e_blkno;
4934 le64_add_cpu(&split_rec->e_blkno,
4935 ocfs2_clusters_to_blocks(sb, cpos - rec_cpos));
4936
4937 split_rec->e_flags = rec->e_flags;
4938}
4939
4940static int ocfs2_split_and_insert(handle_t *handle,
4941 struct ocfs2_extent_tree *et,
4942 struct ocfs2_path *path,
4943 struct buffer_head **last_eb_bh,
4944 int split_index,
4945 struct ocfs2_extent_rec *orig_split_rec,
4946 struct ocfs2_alloc_context *meta_ac)
4947{
4948 int ret = 0, depth;
4949 unsigned int insert_range, rec_range, do_leftright = 0;
4950 struct ocfs2_extent_rec tmprec;
4951 struct ocfs2_extent_list *rightmost_el;
4952 struct ocfs2_extent_rec rec;
4953 struct ocfs2_extent_rec split_rec = *orig_split_rec;
4954 struct ocfs2_insert_type insert;
4955 struct ocfs2_extent_block *eb;
4956
4957leftright:
4958
4959
4960
4961
4962 rec = path_leaf_el(path)->l_recs[split_index];
4963
4964 rightmost_el = et->et_root_el;
4965
4966 depth = le16_to_cpu(rightmost_el->l_tree_depth);
4967 if (depth) {
4968 BUG_ON(!(*last_eb_bh));
4969 eb = (struct ocfs2_extent_block *) (*last_eb_bh)->b_data;
4970 rightmost_el = &eb->h_list;
4971 }
4972
4973 if (le16_to_cpu(rightmost_el->l_next_free_rec) ==
4974 le16_to_cpu(rightmost_el->l_count)) {
4975 ret = ocfs2_grow_tree(handle, et,
4976 &depth, last_eb_bh, meta_ac);
4977 if (ret) {
4978 mlog_errno(ret);
4979 goto out;
4980 }
4981 }
4982
4983 memset(&insert, 0, sizeof(struct ocfs2_insert_type));
4984 insert.ins_appending = APPEND_NONE;
4985 insert.ins_contig = CONTIG_NONE;
4986 insert.ins_tree_depth = depth;
4987
4988 insert_range = le32_to_cpu(split_rec.e_cpos) +
4989 le16_to_cpu(split_rec.e_leaf_clusters);
4990 rec_range = le32_to_cpu(rec.e_cpos) +
4991 le16_to_cpu(rec.e_leaf_clusters);
4992
4993 if (split_rec.e_cpos == rec.e_cpos) {
4994 insert.ins_split = SPLIT_LEFT;
4995 } else if (insert_range == rec_range) {
4996 insert.ins_split = SPLIT_RIGHT;
4997 } else {
4998
4999
5000
5001
5002 insert.ins_split = SPLIT_RIGHT;
5003
5004 ocfs2_make_right_split_rec(ocfs2_metadata_cache_get_super(et->et_ci),
5005 &tmprec, insert_range, &rec);
5006
5007 split_rec = tmprec;
5008
5009 BUG_ON(do_leftright);
5010 do_leftright = 1;
5011 }
5012
5013 ret = ocfs2_do_insert_extent(handle, et, &split_rec, &insert);
5014 if (ret) {
5015 mlog_errno(ret);
5016 goto out;
5017 }
5018
5019 if (do_leftright == 1) {
5020 u32 cpos;
5021 struct ocfs2_extent_list *el;
5022
5023 do_leftright++;
5024 split_rec = *orig_split_rec;
5025
5026 ocfs2_reinit_path(path, 1);
5027
5028 cpos = le32_to_cpu(split_rec.e_cpos);
5029 ret = ocfs2_find_path(et->et_ci, path, cpos);
5030 if (ret) {
5031 mlog_errno(ret);
5032 goto out;
5033 }
5034
5035 el = path_leaf_el(path);
5036 split_index = ocfs2_search_extent_list(el, cpos);
5037 goto leftright;
5038 }
5039out:
5040
5041 return ret;
5042}
5043
5044static int ocfs2_replace_extent_rec(handle_t *handle,
5045 struct ocfs2_extent_tree *et,
5046 struct ocfs2_path *path,
5047 struct ocfs2_extent_list *el,
5048 int split_index,
5049 struct ocfs2_extent_rec *split_rec)
5050{
5051 int ret;
5052
5053 ret = ocfs2_path_bh_journal_access(handle, et->et_ci, path,
5054 path_num_items(path) - 1);
5055 if (ret) {
5056 mlog_errno(ret);
5057 goto out;
5058 }
5059
5060 el->l_recs[split_index] = *split_rec;
5061
5062 ocfs2_journal_dirty(handle, path_leaf_bh(path));
5063out:
5064 return ret;
5065}
5066
5067
5068
5069
5070
5071
5072
5073
5074
5075
5076
5077
5078
5079
5080
5081
5082
5083
5084
5085
5086int ocfs2_split_extent(handle_t *handle,
5087 struct ocfs2_extent_tree *et,
5088 struct ocfs2_path *path,
5089 int split_index,
5090 struct ocfs2_extent_rec *split_rec,
5091 struct ocfs2_alloc_context *meta_ac,
5092 struct ocfs2_cached_dealloc_ctxt *dealloc)
5093{
5094 int ret = 0;
5095 struct ocfs2_extent_list *el = path_leaf_el(path);
5096 struct buffer_head *last_eb_bh = NULL;
5097 struct ocfs2_extent_rec *rec = &el->l_recs[split_index];
5098 struct ocfs2_merge_ctxt ctxt;
5099 struct ocfs2_extent_list *rightmost_el;
5100
5101 if (le32_to_cpu(rec->e_cpos) > le32_to_cpu(split_rec->e_cpos) ||
5102 ((le32_to_cpu(rec->e_cpos) + le16_to_cpu(rec->e_leaf_clusters)) <
5103 (le32_to_cpu(split_rec->e_cpos) + le16_to_cpu(split_rec->e_leaf_clusters)))) {
5104 ret = -EIO;
5105 mlog_errno(ret);
5106 goto out;
5107 }
5108
5109 ctxt.c_contig_type = ocfs2_figure_merge_contig_type(et, path, el,
5110 split_index,
5111 split_rec);
5112
5113
5114
5115
5116
5117
5118 if (path->p_tree_depth) {
5119 struct ocfs2_extent_block *eb;
5120
5121 ret = ocfs2_read_extent_block(et->et_ci,
5122 ocfs2_et_get_last_eb_blk(et),
5123 &last_eb_bh);
5124 if (ret) {
5125 mlog_exit(ret);
5126 goto out;
5127 }
5128
5129 eb = (struct ocfs2_extent_block *) last_eb_bh->b_data;
5130 rightmost_el = &eb->h_list;
5131 } else
5132 rightmost_el = path_root_el(path);
5133
5134 if (rec->e_cpos == split_rec->e_cpos &&
5135 rec->e_leaf_clusters == split_rec->e_leaf_clusters)
5136 ctxt.c_split_covers_rec = 1;
5137 else
5138 ctxt.c_split_covers_rec = 0;
5139
5140 ctxt.c_has_empty_extent = ocfs2_is_empty_extent(&el->l_recs[0]);
5141
5142 mlog(0, "index: %d, contig: %u, has_empty: %u, split_covers: %u\n",
5143 split_index, ctxt.c_contig_type, ctxt.c_has_empty_extent,
5144 ctxt.c_split_covers_rec);
5145
5146 if (ctxt.c_contig_type == CONTIG_NONE) {
5147 if (ctxt.c_split_covers_rec)
5148 ret = ocfs2_replace_extent_rec(handle, et, path, el,
5149 split_index, split_rec);
5150 else
5151 ret = ocfs2_split_and_insert(handle, et, path,
5152 &last_eb_bh, split_index,
5153 split_rec, meta_ac);
5154 if (ret)
5155 mlog_errno(ret);
5156 } else {
5157 ret = ocfs2_try_to_merge_extent(handle, et, path,
5158 split_index, split_rec,
5159 dealloc, &ctxt);
5160 if (ret)
5161 mlog_errno(ret);
5162 }
5163
5164out:
5165 brelse(last_eb_bh);
5166 return ret;
5167}
5168
5169
5170
5171
5172
5173
5174
5175
5176
5177
5178
5179
5180
5181int ocfs2_change_extent_flag(handle_t *handle,
5182 struct ocfs2_extent_tree *et,
5183 u32 cpos, u32 len, u32 phys,
5184 struct ocfs2_alloc_context *meta_ac,
5185 struct ocfs2_cached_dealloc_ctxt *dealloc,
5186 int new_flags, int clear_flags)
5187{
5188 int ret, index;
5189 struct super_block *sb = ocfs2_metadata_cache_get_super(et->et_ci);
5190 u64 start_blkno = ocfs2_clusters_to_blocks(sb, phys);
5191 struct ocfs2_extent_rec split_rec;
5192 struct ocfs2_path *left_path = NULL;
5193 struct ocfs2_extent_list *el;
5194 struct ocfs2_extent_rec *rec;
5195
5196 left_path = ocfs2_new_path_from_et(et);
5197 if (!left_path) {
5198 ret = -ENOMEM;
5199 mlog_errno(ret);
5200 goto out;
5201 }
5202
5203 ret = ocfs2_find_path(et->et_ci, left_path, cpos);
5204 if (ret) {
5205 mlog_errno(ret);
5206 goto out;
5207 }
5208 el = path_leaf_el(left_path);
5209
5210 index = ocfs2_search_extent_list(el, cpos);
5211 if (index == -1 || index >= le16_to_cpu(el->l_next_free_rec)) {
5212 ocfs2_error(sb,
5213 "Owner %llu has an extent at cpos %u which can no "
5214 "longer be found.\n",
5215 (unsigned long long)
5216 ocfs2_metadata_cache_owner(et->et_ci), cpos);
5217 ret = -EROFS;
5218 goto out;
5219 }
5220
5221 ret = -EIO;
5222 rec = &el->l_recs[index];
5223 if (new_flags && (rec->e_flags & new_flags)) {
5224 mlog(ML_ERROR, "Owner %llu tried to set %d flags on an "
5225 "extent that already had them",
5226 (unsigned long long)ocfs2_metadata_cache_owner(et->et_ci),
5227 new_flags);
5228 goto out;
5229 }
5230
5231 if (clear_flags && !(rec->e_flags & clear_flags)) {
5232 mlog(ML_ERROR, "Owner %llu tried to clear %d flags on an "
5233 "extent that didn't have them",
5234 (unsigned long long)ocfs2_metadata_cache_owner(et->et_ci),
5235 clear_flags);
5236 goto out;
5237 }
5238
5239 memset(&split_rec, 0, sizeof(struct ocfs2_extent_rec));
5240 split_rec.e_cpos = cpu_to_le32(cpos);
5241 split_rec.e_leaf_clusters = cpu_to_le16(len);
5242 split_rec.e_blkno = cpu_to_le64(start_blkno);
5243 split_rec.e_flags = rec->e_flags;
5244 if (new_flags)
5245 split_rec.e_flags |= new_flags;
5246 if (clear_flags)
5247 split_rec.e_flags &= ~clear_flags;
5248
5249 ret = ocfs2_split_extent(handle, et, left_path,
5250 index, &split_rec, meta_ac,
5251 dealloc);
5252 if (ret)
5253 mlog_errno(ret);
5254
5255out:
5256 ocfs2_free_path(left_path);
5257 return ret;
5258
5259}
5260
5261
5262
5263
5264
5265
5266
5267
5268
5269
5270int ocfs2_mark_extent_written(struct inode *inode,
5271 struct ocfs2_extent_tree *et,
5272 handle_t *handle, u32 cpos, u32 len, u32 phys,
5273 struct ocfs2_alloc_context *meta_ac,
5274 struct ocfs2_cached_dealloc_ctxt *dealloc)
5275{
5276 int ret;
5277
5278 mlog(0, "Inode %lu cpos %u, len %u, phys clusters %u\n",
5279 inode->i_ino, cpos, len, phys);
5280
5281 if (!ocfs2_writes_unwritten_extents(OCFS2_SB(inode->i_sb))) {
5282 ocfs2_error(inode->i_sb, "Inode %llu has unwritten extents "
5283 "that are being written to, but the feature bit "
5284 "is not set in the super block.",
5285 (unsigned long long)OCFS2_I(inode)->ip_blkno);
5286 ret = -EROFS;
5287 goto out;
5288 }
5289
5290
5291
5292
5293
5294 ocfs2_et_extent_map_truncate(et, 0);
5295
5296 ret = ocfs2_change_extent_flag(handle, et, cpos,
5297 len, phys, meta_ac, dealloc,
5298 0, OCFS2_EXT_UNWRITTEN);
5299 if (ret)
5300 mlog_errno(ret);
5301
5302out:
5303 return ret;
5304}
5305
5306static int ocfs2_split_tree(handle_t *handle, struct ocfs2_extent_tree *et,
5307 struct ocfs2_path *path,
5308 int index, u32 new_range,
5309 struct ocfs2_alloc_context *meta_ac)
5310{
5311 int ret, depth, credits = handle->h_buffer_credits;
5312 struct buffer_head *last_eb_bh = NULL;
5313 struct ocfs2_extent_block *eb;
5314 struct ocfs2_extent_list *rightmost_el, *el;
5315 struct ocfs2_extent_rec split_rec;
5316 struct ocfs2_extent_rec *rec;
5317 struct ocfs2_insert_type insert;
5318
5319
5320
5321
5322 el = path_leaf_el(path);
5323 rec = &el->l_recs[index];
5324 ocfs2_make_right_split_rec(ocfs2_metadata_cache_get_super(et->et_ci),
5325 &split_rec, new_range, rec);
5326
5327 depth = path->p_tree_depth;
5328 if (depth > 0) {
5329 ret = ocfs2_read_extent_block(et->et_ci,
5330 ocfs2_et_get_last_eb_blk(et),
5331 &last_eb_bh);
5332 if (ret < 0) {
5333 mlog_errno(ret);
5334 goto out;
5335 }
5336
5337 eb = (struct ocfs2_extent_block *) last_eb_bh->b_data;
5338 rightmost_el = &eb->h_list;
5339 } else
5340 rightmost_el = path_leaf_el(path);
5341
5342 credits += path->p_tree_depth +
5343 ocfs2_extend_meta_needed(et->et_root_el);
5344 ret = ocfs2_extend_trans(handle, credits);
5345 if (ret) {
5346 mlog_errno(ret);
5347 goto out;
5348 }
5349
5350 if (le16_to_cpu(rightmost_el->l_next_free_rec) ==
5351 le16_to_cpu(rightmost_el->l_count)) {
5352 ret = ocfs2_grow_tree(handle, et, &depth, &last_eb_bh,
5353 meta_ac);
5354 if (ret) {
5355 mlog_errno(ret);
5356 goto out;
5357 }
5358 }
5359
5360 memset(&insert, 0, sizeof(struct ocfs2_insert_type));
5361 insert.ins_appending = APPEND_NONE;
5362 insert.ins_contig = CONTIG_NONE;
5363 insert.ins_split = SPLIT_RIGHT;
5364 insert.ins_tree_depth = depth;
5365
5366 ret = ocfs2_do_insert_extent(handle, et, &split_rec, &insert);
5367 if (ret)
5368 mlog_errno(ret);
5369
5370out:
5371 brelse(last_eb_bh);
5372 return ret;
5373}
5374
5375static int ocfs2_truncate_rec(handle_t *handle,
5376 struct ocfs2_extent_tree *et,
5377 struct ocfs2_path *path, int index,
5378 struct ocfs2_cached_dealloc_ctxt *dealloc,
5379 u32 cpos, u32 len)
5380{
5381 int ret;
5382 u32 left_cpos, rec_range, trunc_range;
5383 int wants_rotate = 0, is_rightmost_tree_rec = 0;
5384 struct super_block *sb = ocfs2_metadata_cache_get_super(et->et_ci);
5385 struct ocfs2_path *left_path = NULL;
5386 struct ocfs2_extent_list *el = path_leaf_el(path);
5387 struct ocfs2_extent_rec *rec;
5388 struct ocfs2_extent_block *eb;
5389
5390 if (ocfs2_is_empty_extent(&el->l_recs[0]) && index > 0) {
5391 ret = ocfs2_rotate_tree_left(handle, et, path, dealloc);
5392 if (ret) {
5393 mlog_errno(ret);
5394 goto out;
5395 }
5396
5397 index--;
5398 }
5399
5400 if (index == (le16_to_cpu(el->l_next_free_rec) - 1) &&
5401 path->p_tree_depth) {
5402
5403
5404
5405
5406
5407
5408 eb = (struct ocfs2_extent_block *)path_leaf_bh(path)->b_data;
5409 if (eb->h_next_leaf_blk == 0)
5410 is_rightmost_tree_rec = 1;
5411 }
5412
5413 rec = &el->l_recs[index];
5414 if (index == 0 && path->p_tree_depth &&
5415 le32_to_cpu(rec->e_cpos) == cpos) {
5416
5417
5418
5419
5420
5421
5422
5423
5424
5425
5426
5427
5428
5429 ret = ocfs2_find_cpos_for_left_leaf(sb, path, &left_cpos);
5430 if (ret) {
5431 mlog_errno(ret);
5432 goto out;
5433 }
5434
5435 if (left_cpos && le16_to_cpu(el->l_next_free_rec) > 1) {
5436 left_path = ocfs2_new_path_from_path(path);
5437 if (!left_path) {
5438 ret = -ENOMEM;
5439 mlog_errno(ret);
5440 goto out;
5441 }
5442
5443 ret = ocfs2_find_path(et->et_ci, left_path,
5444 left_cpos);
5445 if (ret) {
5446 mlog_errno(ret);
5447 goto out;
5448 }
5449 }
5450 }
5451
5452 ret = ocfs2_extend_rotate_transaction(handle, 0,
5453 handle->h_buffer_credits,
5454 path);
5455 if (ret) {
5456 mlog_errno(ret);
5457 goto out;
5458 }
5459
5460 ret = ocfs2_journal_access_path(et->et_ci, handle, path);
5461 if (ret) {
5462 mlog_errno(ret);
5463 goto out;
5464 }
5465
5466 ret = ocfs2_journal_access_path(et->et_ci, handle, left_path);
5467 if (ret) {
5468 mlog_errno(ret);
5469 goto out;
5470 }
5471
5472 rec_range = le32_to_cpu(rec->e_cpos) + ocfs2_rec_clusters(el, rec);
5473 trunc_range = cpos + len;
5474
5475 if (le32_to_cpu(rec->e_cpos) == cpos && rec_range == trunc_range) {
5476 int next_free;
5477
5478 memset(rec, 0, sizeof(*rec));
5479 ocfs2_cleanup_merge(el, index);
5480 wants_rotate = 1;
5481
5482 next_free = le16_to_cpu(el->l_next_free_rec);
5483 if (is_rightmost_tree_rec && next_free > 1) {
5484
5485
5486
5487
5488 rec = &el->l_recs[next_free - 1];
5489 ocfs2_adjust_rightmost_records(handle, et, path,
5490 rec);
5491 }
5492 } else if (le32_to_cpu(rec->e_cpos) == cpos) {
5493
5494 le32_add_cpu(&rec->e_cpos, len);
5495 le64_add_cpu(&rec->e_blkno, ocfs2_clusters_to_blocks(sb, len));
5496 le16_add_cpu(&rec->e_leaf_clusters, -len);
5497 } else if (rec_range == trunc_range) {
5498
5499 le16_add_cpu(&rec->e_leaf_clusters, -len);
5500 if (is_rightmost_tree_rec)
5501 ocfs2_adjust_rightmost_records(handle, et, path, rec);
5502 } else {
5503
5504 mlog(ML_ERROR, "Owner %llu: Invalid record truncate: (%u, %u) "
5505 "(%u, %u)\n",
5506 (unsigned long long)ocfs2_metadata_cache_owner(et->et_ci),
5507 le32_to_cpu(rec->e_cpos),
5508 le16_to_cpu(rec->e_leaf_clusters), cpos, len);
5509 BUG();
5510 }
5511
5512 if (left_path) {
5513 int subtree_index;
5514
5515 subtree_index = ocfs2_find_subtree_root(et, left_path, path);
5516 ocfs2_complete_edge_insert(handle, left_path, path,
5517 subtree_index);
5518 }
5519
5520 ocfs2_journal_dirty(handle, path_leaf_bh(path));
5521
5522 ret = ocfs2_rotate_tree_left(handle, et, path, dealloc);
5523 if (ret) {
5524 mlog_errno(ret);
5525 goto out;
5526 }
5527
5528out:
5529 ocfs2_free_path(left_path);
5530 return ret;
5531}
5532
5533int ocfs2_remove_extent(handle_t *handle,
5534 struct ocfs2_extent_tree *et,
5535 u32 cpos, u32 len,
5536 struct ocfs2_alloc_context *meta_ac,
5537 struct ocfs2_cached_dealloc_ctxt *dealloc)
5538{
5539 int ret, index;
5540 u32 rec_range, trunc_range;
5541 struct ocfs2_extent_rec *rec;
5542 struct ocfs2_extent_list *el;
5543 struct ocfs2_path *path = NULL;
5544
5545
5546
5547
5548
5549 ocfs2_et_extent_map_truncate(et, 0);
5550
5551 path = ocfs2_new_path_from_et(et);
5552 if (!path) {
5553 ret = -ENOMEM;
5554 mlog_errno(ret);
5555 goto out;
5556 }
5557
5558 ret = ocfs2_find_path(et->et_ci, path, cpos);
5559 if (ret) {
5560 mlog_errno(ret);
5561 goto out;
5562 }
5563
5564 el = path_leaf_el(path);
5565 index = ocfs2_search_extent_list(el, cpos);
5566 if (index == -1 || index >= le16_to_cpu(el->l_next_free_rec)) {
5567 ocfs2_error(ocfs2_metadata_cache_get_super(et->et_ci),
5568 "Owner %llu has an extent at cpos %u which can no "
5569 "longer be found.\n",
5570 (unsigned long long)ocfs2_metadata_cache_owner(et->et_ci),
5571 cpos);
5572 ret = -EROFS;
5573 goto out;
5574 }
5575
5576
5577
5578
5579
5580
5581
5582
5583
5584
5585
5586
5587
5588
5589
5590
5591
5592 rec = &el->l_recs[index];
5593 rec_range = le32_to_cpu(rec->e_cpos) + ocfs2_rec_clusters(el, rec);
5594 trunc_range = cpos + len;
5595
5596 BUG_ON(cpos < le32_to_cpu(rec->e_cpos) || trunc_range > rec_range);
5597
5598 mlog(0, "Owner %llu, remove (cpos %u, len %u). Existing index %d "
5599 "(cpos %u, len %u)\n",
5600 (unsigned long long)ocfs2_metadata_cache_owner(et->et_ci),
5601 cpos, len, index,
5602 le32_to_cpu(rec->e_cpos), ocfs2_rec_clusters(el, rec));
5603
5604 if (le32_to_cpu(rec->e_cpos) == cpos || rec_range == trunc_range) {
5605 ret = ocfs2_truncate_rec(handle, et, path, index, dealloc,
5606 cpos, len);
5607 if (ret) {
5608 mlog_errno(ret);
5609 goto out;
5610 }
5611 } else {
5612 ret = ocfs2_split_tree(handle, et, path, index,
5613 trunc_range, meta_ac);
5614 if (ret) {
5615 mlog_errno(ret);
5616 goto out;
5617 }
5618
5619
5620
5621
5622
5623 ocfs2_reinit_path(path, 1);
5624
5625 ret = ocfs2_find_path(et->et_ci, path, cpos);
5626 if (ret) {
5627 mlog_errno(ret);
5628 goto out;
5629 }
5630
5631 el = path_leaf_el(path);
5632 index = ocfs2_search_extent_list(el, cpos);
5633 if (index == -1 || index >= le16_to_cpu(el->l_next_free_rec)) {
5634 ocfs2_error(ocfs2_metadata_cache_get_super(et->et_ci),
5635 "Owner %llu: split at cpos %u lost record.",
5636 (unsigned long long)ocfs2_metadata_cache_owner(et->et_ci),
5637 cpos);
5638 ret = -EROFS;
5639 goto out;
5640 }
5641
5642
5643
5644
5645
5646 rec = &el->l_recs[index];
5647 rec_range = le32_to_cpu(rec->e_cpos) +
5648 ocfs2_rec_clusters(el, rec);
5649 if (rec_range != trunc_range) {
5650 ocfs2_error(ocfs2_metadata_cache_get_super(et->et_ci),
5651 "Owner %llu: error after split at cpos %u"
5652 "trunc len %u, existing record is (%u,%u)",
5653 (unsigned long long)ocfs2_metadata_cache_owner(et->et_ci),
5654 cpos, len, le32_to_cpu(rec->e_cpos),
5655 ocfs2_rec_clusters(el, rec));
5656 ret = -EROFS;
5657 goto out;
5658 }
5659
5660 ret = ocfs2_truncate_rec(handle, et, path, index, dealloc,
5661 cpos, len);
5662 if (ret) {
5663 mlog_errno(ret);
5664 goto out;
5665 }
5666 }
5667
5668out:
5669 ocfs2_free_path(path);
5670 return ret;
5671}
5672
5673int ocfs2_remove_btree_range(struct inode *inode,
5674 struct ocfs2_extent_tree *et,
5675 u32 cpos, u32 phys_cpos, u32 len,
5676 struct ocfs2_cached_dealloc_ctxt *dealloc)
5677{
5678 int ret;
5679 u64 phys_blkno = ocfs2_clusters_to_blocks(inode->i_sb, phys_cpos);
5680 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
5681 struct inode *tl_inode = osb->osb_tl_inode;
5682 handle_t *handle;
5683 struct ocfs2_alloc_context *meta_ac = NULL;
5684
5685 ret = ocfs2_lock_allocators(inode, et, 0, 1, NULL, &meta_ac);
5686 if (ret) {
5687 mlog_errno(ret);
5688 return ret;
5689 }
5690
5691 mutex_lock(&tl_inode->i_mutex);
5692
5693 if (ocfs2_truncate_log_needs_flush(osb)) {
5694 ret = __ocfs2_flush_truncate_log(osb);
5695 if (ret < 0) {
5696 mlog_errno(ret);
5697 goto out;
5698 }
5699 }
5700
5701 handle = ocfs2_start_trans(osb, ocfs2_remove_extent_credits(osb->sb));
5702 if (IS_ERR(handle)) {
5703 ret = PTR_ERR(handle);
5704 mlog_errno(ret);
5705 goto out;
5706 }
5707
5708 ret = ocfs2_et_root_journal_access(handle, et,
5709 OCFS2_JOURNAL_ACCESS_WRITE);
5710 if (ret) {
5711 mlog_errno(ret);
5712 goto out;
5713 }
5714
5715 vfs_dq_free_space_nodirty(inode,
5716 ocfs2_clusters_to_bytes(inode->i_sb, len));
5717
5718 ret = ocfs2_remove_extent(handle, et, cpos, len, meta_ac, dealloc);
5719 if (ret) {
5720 mlog_errno(ret);
5721 goto out_commit;
5722 }
5723
5724 ocfs2_et_update_clusters(et, -len);
5725
5726 ret = ocfs2_journal_dirty(handle, et->et_root_bh);
5727 if (ret) {
5728 mlog_errno(ret);
5729 goto out_commit;
5730 }
5731
5732 ret = ocfs2_truncate_log_append(osb, handle, phys_blkno, len);
5733 if (ret)
5734 mlog_errno(ret);
5735
5736out_commit:
5737 ocfs2_commit_trans(osb, handle);
5738out:
5739 mutex_unlock(&tl_inode->i_mutex);
5740
5741 if (meta_ac)
5742 ocfs2_free_alloc_context(meta_ac);
5743
5744 return ret;
5745}
5746
5747int ocfs2_truncate_log_needs_flush(struct ocfs2_super *osb)
5748{
5749 struct buffer_head *tl_bh = osb->osb_tl_bh;
5750 struct ocfs2_dinode *di;
5751 struct ocfs2_truncate_log *tl;
5752
5753 di = (struct ocfs2_dinode *) tl_bh->b_data;
5754 tl = &di->id2.i_dealloc;
5755
5756 mlog_bug_on_msg(le16_to_cpu(tl->tl_used) > le16_to_cpu(tl->tl_count),
5757 "slot %d, invalid truncate log parameters: used = "
5758 "%u, count = %u\n", osb->slot_num,
5759 le16_to_cpu(tl->tl_used), le16_to_cpu(tl->tl_count));
5760 return le16_to_cpu(tl->tl_used) == le16_to_cpu(tl->tl_count);
5761}
5762
5763static int ocfs2_truncate_log_can_coalesce(struct ocfs2_truncate_log *tl,
5764 unsigned int new_start)
5765{
5766 unsigned int tail_index;
5767 unsigned int current_tail;
5768
5769
5770 if (!le16_to_cpu(tl->tl_used))
5771 return 0;
5772
5773 tail_index = le16_to_cpu(tl->tl_used) - 1;
5774 current_tail = le32_to_cpu(tl->tl_recs[tail_index].t_start);
5775 current_tail += le32_to_cpu(tl->tl_recs[tail_index].t_clusters);
5776
5777 return current_tail == new_start;
5778}
5779
5780int ocfs2_truncate_log_append(struct ocfs2_super *osb,
5781 handle_t *handle,
5782 u64 start_blk,
5783 unsigned int num_clusters)
5784{
5785 int status, index;
5786 unsigned int start_cluster, tl_count;
5787 struct inode *tl_inode = osb->osb_tl_inode;
5788 struct buffer_head *tl_bh = osb->osb_tl_bh;
5789 struct ocfs2_dinode *di;
5790 struct ocfs2_truncate_log *tl;
5791
5792 mlog_entry("start_blk = %llu, num_clusters = %u\n",
5793 (unsigned long long)start_blk, num_clusters);
5794
5795 BUG_ON(mutex_trylock(&tl_inode->i_mutex));
5796
5797 start_cluster = ocfs2_blocks_to_clusters(osb->sb, start_blk);
5798
5799 di = (struct ocfs2_dinode *) tl_bh->b_data;
5800
5801
5802
5803
5804 BUG_ON(!OCFS2_IS_VALID_DINODE(di));
5805
5806 tl = &di->id2.i_dealloc;
5807 tl_count = le16_to_cpu(tl->tl_count);
5808 mlog_bug_on_msg(tl_count > ocfs2_truncate_recs_per_inode(osb->sb) ||
5809 tl_count == 0,
5810 "Truncate record count on #%llu invalid "
5811 "wanted %u, actual %u\n",
5812 (unsigned long long)OCFS2_I(tl_inode)->ip_blkno,
5813 ocfs2_truncate_recs_per_inode(osb->sb),
5814 le16_to_cpu(tl->tl_count));
5815
5816
5817 index = le16_to_cpu(tl->tl_used);
5818 if (index >= tl_count) {
5819 status = -ENOSPC;
5820 mlog_errno(status);
5821 goto bail;
5822 }
5823
5824 status = ocfs2_journal_access_di(handle, INODE_CACHE(tl_inode), tl_bh,
5825 OCFS2_JOURNAL_ACCESS_WRITE);
5826 if (status < 0) {
5827 mlog_errno(status);
5828 goto bail;
5829 }
5830
5831 mlog(0, "Log truncate of %u clusters starting at cluster %u to "
5832 "%llu (index = %d)\n", num_clusters, start_cluster,
5833 (unsigned long long)OCFS2_I(tl_inode)->ip_blkno, index);
5834
5835 if (ocfs2_truncate_log_can_coalesce(tl, start_cluster)) {
5836
5837
5838
5839
5840 index--;
5841
5842 num_clusters += le32_to_cpu(tl->tl_recs[index].t_clusters);
5843 mlog(0, "Coalesce with index %u (start = %u, clusters = %u)\n",
5844 index, le32_to_cpu(tl->tl_recs[index].t_start),
5845 num_clusters);
5846 } else {
5847 tl->tl_recs[index].t_start = cpu_to_le32(start_cluster);
5848 tl->tl_used = cpu_to_le16(index + 1);
5849 }
5850 tl->tl_recs[index].t_clusters = cpu_to_le32(num_clusters);
5851
5852 status = ocfs2_journal_dirty(handle, tl_bh);
5853 if (status < 0) {
5854 mlog_errno(status);
5855 goto bail;
5856 }
5857
5858bail:
5859 mlog_exit(status);
5860 return status;
5861}
5862
5863static int ocfs2_replay_truncate_records(struct ocfs2_super *osb,
5864 handle_t *handle,
5865 struct inode *data_alloc_inode,
5866 struct buffer_head *data_alloc_bh)
5867{
5868 int status = 0;
5869 int i;
5870 unsigned int num_clusters;
5871 u64 start_blk;
5872 struct ocfs2_truncate_rec rec;
5873 struct ocfs2_dinode *di;
5874 struct ocfs2_truncate_log *tl;
5875 struct inode *tl_inode = osb->osb_tl_inode;
5876 struct buffer_head *tl_bh = osb->osb_tl_bh;
5877
5878 mlog_entry_void();
5879
5880 di = (struct ocfs2_dinode *) tl_bh->b_data;
5881 tl = &di->id2.i_dealloc;
5882 i = le16_to_cpu(tl->tl_used) - 1;
5883 while (i >= 0) {
5884
5885
5886 status = ocfs2_journal_access_di(handle, INODE_CACHE(tl_inode), tl_bh,
5887 OCFS2_JOURNAL_ACCESS_WRITE);
5888 if (status < 0) {
5889 mlog_errno(status);
5890 goto bail;
5891 }
5892
5893 tl->tl_used = cpu_to_le16(i);
5894
5895 status = ocfs2_journal_dirty(handle, tl_bh);
5896 if (status < 0) {
5897 mlog_errno(status);
5898 goto bail;
5899 }
5900
5901
5902
5903
5904 status = ocfs2_extend_trans(handle,
5905 OCFS2_TRUNCATE_LOG_FLUSH_ONE_REC);
5906 if (status < 0) {
5907 mlog_errno(status);
5908 goto bail;
5909 }
5910
5911 rec = tl->tl_recs[i];
5912 start_blk = ocfs2_clusters_to_blocks(data_alloc_inode->i_sb,
5913 le32_to_cpu(rec.t_start));
5914 num_clusters = le32_to_cpu(rec.t_clusters);
5915
5916
5917
5918 if (start_blk) {
5919 mlog(0, "free record %d, start = %u, clusters = %u\n",
5920 i, le32_to_cpu(rec.t_start), num_clusters);
5921
5922 status = ocfs2_free_clusters(handle, data_alloc_inode,
5923 data_alloc_bh, start_blk,
5924 num_clusters);
5925 if (status < 0) {
5926 mlog_errno(status);
5927 goto bail;
5928 }
5929 }
5930 i--;
5931 }
5932
5933bail:
5934 mlog_exit(status);
5935 return status;
5936}
5937
5938
5939int __ocfs2_flush_truncate_log(struct ocfs2_super *osb)
5940{
5941 int status;
5942 unsigned int num_to_flush;
5943 handle_t *handle;
5944 struct inode *tl_inode = osb->osb_tl_inode;
5945 struct inode *data_alloc_inode = NULL;
5946 struct buffer_head *tl_bh = osb->osb_tl_bh;
5947 struct buffer_head *data_alloc_bh = NULL;
5948 struct ocfs2_dinode *di;
5949 struct ocfs2_truncate_log *tl;
5950
5951 mlog_entry_void();
5952
5953 BUG_ON(mutex_trylock(&tl_inode->i_mutex));
5954
5955 di = (struct ocfs2_dinode *) tl_bh->b_data;
5956
5957
5958
5959
5960 BUG_ON(!OCFS2_IS_VALID_DINODE(di));
5961
5962 tl = &di->id2.i_dealloc;
5963 num_to_flush = le16_to_cpu(tl->tl_used);
5964 mlog(0, "Flush %u records from truncate log #%llu\n",
5965 num_to_flush, (unsigned long long)OCFS2_I(tl_inode)->ip_blkno);
5966 if (!num_to_flush) {
5967 status = 0;
5968 goto out;
5969 }
5970
5971 data_alloc_inode = ocfs2_get_system_file_inode(osb,
5972 GLOBAL_BITMAP_SYSTEM_INODE,
5973 OCFS2_INVALID_SLOT);
5974 if (!data_alloc_inode) {
5975 status = -EINVAL;
5976 mlog(ML_ERROR, "Could not get bitmap inode!\n");
5977 goto out;
5978 }
5979
5980 mutex_lock(&data_alloc_inode->i_mutex);
5981
5982 status = ocfs2_inode_lock(data_alloc_inode, &data_alloc_bh, 1);
5983 if (status < 0) {
5984 mlog_errno(status);
5985 goto out_mutex;
5986 }
5987
5988 handle = ocfs2_start_trans(osb, OCFS2_TRUNCATE_LOG_UPDATE);
5989 if (IS_ERR(handle)) {
5990 status = PTR_ERR(handle);
5991 mlog_errno(status);
5992 goto out_unlock;
5993 }
5994
5995 status = ocfs2_replay_truncate_records(osb, handle, data_alloc_inode,
5996 data_alloc_bh);
5997 if (status < 0)
5998 mlog_errno(status);
5999
6000 ocfs2_commit_trans(osb, handle);
6001
6002out_unlock:
6003 brelse(data_alloc_bh);
6004 ocfs2_inode_unlock(data_alloc_inode, 1);
6005
6006out_mutex:
6007 mutex_unlock(&data_alloc_inode->i_mutex);
6008 iput(data_alloc_inode);
6009
6010out:
6011 mlog_exit(status);
6012 return status;
6013}
6014
6015int ocfs2_flush_truncate_log(struct ocfs2_super *osb)
6016{
6017 int status;
6018 struct inode *tl_inode = osb->osb_tl_inode;
6019
6020 mutex_lock(&tl_inode->i_mutex);
6021 status = __ocfs2_flush_truncate_log(osb);
6022 mutex_unlock(&tl_inode->i_mutex);
6023
6024 return status;
6025}
6026
6027static void ocfs2_truncate_log_worker(struct work_struct *work)
6028{
6029 int status;
6030 struct ocfs2_super *osb =
6031 container_of(work, struct ocfs2_super,
6032 osb_truncate_log_wq.work);
6033
6034 mlog_entry_void();
6035
6036 status = ocfs2_flush_truncate_log(osb);
6037 if (status < 0)
6038 mlog_errno(status);
6039 else
6040 ocfs2_init_inode_steal_slot(osb);
6041
6042 mlog_exit(status);
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
6051
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 mlog_exit(status);
6089 return status;
6090}
6091
6092
6093
6094
6095
6096int ocfs2_begin_truncate_log_recovery(struct ocfs2_super *osb,
6097 int slot_num,
6098 struct ocfs2_dinode **tl_copy)
6099{
6100 int status;
6101 struct inode *tl_inode = NULL;
6102 struct buffer_head *tl_bh = NULL;
6103 struct ocfs2_dinode *di;
6104 struct ocfs2_truncate_log *tl;
6105
6106 *tl_copy = NULL;
6107
6108 mlog(0, "recover truncate log from slot %d\n", slot_num);
6109
6110 status = ocfs2_get_truncate_log_info(osb, slot_num, &tl_inode, &tl_bh);
6111 if (status < 0) {
6112 mlog_errno(status);
6113 goto bail;
6114 }
6115
6116 di = (struct ocfs2_dinode *) tl_bh->b_data;
6117
6118
6119
6120
6121 BUG_ON(!OCFS2_IS_VALID_DINODE(di));
6122
6123 tl = &di->id2.i_dealloc;
6124 if (le16_to_cpu(tl->tl_used)) {
6125 mlog(0, "We'll have %u logs to recover\n",
6126 le16_to_cpu(tl->tl_used));
6127
6128 *tl_copy = kmalloc(tl_bh->b_size, GFP_KERNEL);
6129 if (!(*tl_copy)) {
6130 status = -ENOMEM;
6131 mlog_errno(status);
6132 goto bail;
6133 }
6134
6135
6136
6137 memcpy(*tl_copy, tl_bh->b_data, tl_bh->b_size);
6138
6139
6140
6141 tl->tl_used = 0;
6142
6143 ocfs2_compute_meta_ecc(osb->sb, tl_bh->b_data, &di->i_check);
6144 status = ocfs2_write_block(osb, tl_bh, INODE_CACHE(tl_inode));
6145 if (status < 0) {
6146 mlog_errno(status);
6147 goto bail;
6148 }
6149 }
6150
6151bail:
6152 if (tl_inode)
6153 iput(tl_inode);
6154 brelse(tl_bh);
6155
6156 if (status < 0 && (*tl_copy)) {
6157 kfree(*tl_copy);
6158 *tl_copy = NULL;
6159 }
6160
6161 mlog_exit(status);
6162 return status;
6163}
6164
6165int ocfs2_complete_truncate_log_recovery(struct ocfs2_super *osb,
6166 struct ocfs2_dinode *tl_copy)
6167{
6168 int status = 0;
6169 int i;
6170 unsigned int clusters, num_recs, start_cluster;
6171 u64 start_blk;
6172 handle_t *handle;
6173 struct inode *tl_inode = osb->osb_tl_inode;
6174 struct ocfs2_truncate_log *tl;
6175
6176 mlog_entry_void();
6177
6178 if (OCFS2_I(tl_inode)->ip_blkno == le64_to_cpu(tl_copy->i_blkno)) {
6179 mlog(ML_ERROR, "Asked to recover my own truncate log!\n");
6180 return -EINVAL;
6181 }
6182
6183 tl = &tl_copy->id2.i_dealloc;
6184 num_recs = le16_to_cpu(tl->tl_used);
6185 mlog(0, "cleanup %u records from %llu\n", num_recs,
6186 (unsigned long long)le64_to_cpu(tl_copy->i_blkno));
6187
6188 mutex_lock(&tl_inode->i_mutex);
6189 for(i = 0; i < num_recs; i++) {
6190 if (ocfs2_truncate_log_needs_flush(osb)) {
6191 status = __ocfs2_flush_truncate_log(osb);
6192 if (status < 0) {
6193 mlog_errno(status);
6194 goto bail_up;
6195 }
6196 }
6197
6198 handle = ocfs2_start_trans(osb, OCFS2_TRUNCATE_LOG_UPDATE);
6199 if (IS_ERR(handle)) {
6200 status = PTR_ERR(handle);
6201 mlog_errno(status);
6202 goto bail_up;
6203 }
6204
6205 clusters = le32_to_cpu(tl->tl_recs[i].t_clusters);
6206 start_cluster = le32_to_cpu(tl->tl_recs[i].t_start);
6207 start_blk = ocfs2_clusters_to_blocks(osb->sb, start_cluster);
6208
6209 status = ocfs2_truncate_log_append(osb, handle,
6210 start_blk, clusters);
6211 ocfs2_commit_trans(osb, handle);
6212 if (status < 0) {
6213 mlog_errno(status);
6214 goto bail_up;
6215 }
6216 }
6217
6218bail_up:
6219 mutex_unlock(&tl_inode->i_mutex);
6220
6221 mlog_exit(status);
6222 return status;
6223}
6224
6225void ocfs2_truncate_log_shutdown(struct ocfs2_super *osb)
6226{
6227 int status;
6228 struct inode *tl_inode = osb->osb_tl_inode;
6229
6230 mlog_entry_void();
6231
6232 if (tl_inode) {
6233 cancel_delayed_work(&osb->osb_truncate_log_wq);
6234 flush_workqueue(ocfs2_wq);
6235
6236 status = ocfs2_flush_truncate_log(osb);
6237 if (status < 0)
6238 mlog_errno(status);
6239
6240 brelse(osb->osb_tl_bh);
6241 iput(osb->osb_tl_inode);
6242 }
6243
6244 mlog_exit_void();
6245}
6246
6247int ocfs2_truncate_log_init(struct ocfs2_super *osb)
6248{
6249 int status;
6250 struct inode *tl_inode = NULL;
6251 struct buffer_head *tl_bh = NULL;
6252
6253 mlog_entry_void();
6254
6255 status = ocfs2_get_truncate_log_info(osb,
6256 osb->slot_num,
6257 &tl_inode,
6258 &tl_bh);
6259 if (status < 0)
6260 mlog_errno(status);
6261
6262
6263
6264
6265 INIT_DELAYED_WORK(&osb->osb_truncate_log_wq,
6266 ocfs2_truncate_log_worker);
6267 osb->osb_tl_bh = tl_bh;
6268 osb->osb_tl_inode = tl_inode;
6269
6270 mlog_exit(status);
6271 return status;
6272}
6273
6274
6275
6276
6277
6278
6279
6280
6281
6282
6283
6284
6285
6286
6287
6288
6289
6290
6291
6292
6293
6294
6295
6296
6297
6298struct ocfs2_cached_block_free {
6299 struct ocfs2_cached_block_free *free_next;
6300 u64 free_blk;
6301 unsigned int free_bit;
6302};
6303
6304struct ocfs2_per_slot_free_list {
6305 struct ocfs2_per_slot_free_list *f_next_suballocator;
6306 int f_inode_type;
6307 int f_slot;
6308 struct ocfs2_cached_block_free *f_first;
6309};
6310
6311static int ocfs2_free_cached_blocks(struct ocfs2_super *osb,
6312 int sysfile_type,
6313 int slot,
6314 struct ocfs2_cached_block_free *head)
6315{
6316 int ret;
6317 u64 bg_blkno;
6318 handle_t *handle;
6319 struct inode *inode;
6320 struct buffer_head *di_bh = NULL;
6321 struct ocfs2_cached_block_free *tmp;
6322
6323 inode = ocfs2_get_system_file_inode(osb, sysfile_type, slot);
6324 if (!inode) {
6325 ret = -EINVAL;
6326 mlog_errno(ret);
6327 goto out;
6328 }
6329
6330 mutex_lock(&inode->i_mutex);
6331
6332 ret = ocfs2_inode_lock(inode, &di_bh, 1);
6333 if (ret) {
6334 mlog_errno(ret);
6335 goto out_mutex;
6336 }
6337
6338 handle = ocfs2_start_trans(osb, OCFS2_SUBALLOC_FREE);
6339 if (IS_ERR(handle)) {
6340 ret = PTR_ERR(handle);
6341 mlog_errno(ret);
6342 goto out_unlock;
6343 }
6344
6345 while (head) {
6346 bg_blkno = ocfs2_which_suballoc_group(head->free_blk,
6347 head->free_bit);
6348 mlog(0, "Free bit: (bit %u, blkno %llu)\n",
6349 head->free_bit, (unsigned long long)head->free_blk);
6350
6351 ret = ocfs2_free_suballoc_bits(handle, inode, di_bh,
6352 head->free_bit, bg_blkno, 1);
6353 if (ret) {
6354 mlog_errno(ret);
6355 goto out_journal;
6356 }
6357
6358 ret = ocfs2_extend_trans(handle, OCFS2_SUBALLOC_FREE);
6359 if (ret) {
6360 mlog_errno(ret);
6361 goto out_journal;
6362 }
6363
6364 tmp = head;
6365 head = head->free_next;
6366 kfree(tmp);
6367 }
6368
6369out_journal:
6370 ocfs2_commit_trans(osb, handle);
6371
6372out_unlock:
6373 ocfs2_inode_unlock(inode, 1);
6374 brelse(di_bh);
6375out_mutex:
6376 mutex_unlock(&inode->i_mutex);
6377 iput(inode);
6378out:
6379 while(head) {
6380
6381 tmp = head;
6382 head = head->free_next;
6383 kfree(tmp);
6384 }
6385
6386 return ret;
6387}
6388
6389int ocfs2_cache_cluster_dealloc(struct ocfs2_cached_dealloc_ctxt *ctxt,
6390 u64 blkno, unsigned int bit)
6391{
6392 int ret = 0;
6393 struct ocfs2_cached_block_free *item;
6394
6395 item = kmalloc(sizeof(*item), GFP_NOFS);
6396 if (item == NULL) {
6397 ret = -ENOMEM;
6398 mlog_errno(ret);
6399 return ret;
6400 }
6401
6402 mlog(0, "Insert clusters: (bit %u, blk %llu)\n",
6403 bit, (unsigned long long)blkno);
6404
6405 item->free_blk = blkno;
6406 item->free_bit = bit;
6407 item->free_next = ctxt->c_global_allocator;
6408
6409 ctxt->c_global_allocator = item;
6410 return ret;
6411}
6412
6413static int ocfs2_free_cached_clusters(struct ocfs2_super *osb,
6414 struct ocfs2_cached_block_free *head)
6415{
6416 struct ocfs2_cached_block_free *tmp;
6417 struct inode *tl_inode = osb->osb_tl_inode;
6418 handle_t *handle;
6419 int ret = 0;
6420
6421 mutex_lock(&tl_inode->i_mutex);
6422
6423 while (head) {
6424 if (ocfs2_truncate_log_needs_flush(osb)) {
6425 ret = __ocfs2_flush_truncate_log(osb);
6426 if (ret < 0) {
6427 mlog_errno(ret);
6428 break;
6429 }
6430 }
6431
6432 handle = ocfs2_start_trans(osb, OCFS2_TRUNCATE_LOG_UPDATE);
6433 if (IS_ERR(handle)) {
6434 ret = PTR_ERR(handle);
6435 mlog_errno(ret);
6436 break;
6437 }
6438
6439 ret = ocfs2_truncate_log_append(osb, handle, head->free_blk,
6440 head->free_bit);
6441
6442 ocfs2_commit_trans(osb, handle);
6443 tmp = head;
6444 head = head->free_next;
6445 kfree(tmp);
6446
6447 if (ret < 0) {
6448 mlog_errno(ret);
6449 break;
6450 }
6451 }
6452
6453 mutex_unlock(&tl_inode->i_mutex);
6454
6455 while (head) {
6456
6457 tmp = head;
6458 head = head->free_next;
6459 kfree(tmp);
6460 }
6461
6462 return ret;
6463}
6464
6465int ocfs2_run_deallocs(struct ocfs2_super *osb,
6466 struct ocfs2_cached_dealloc_ctxt *ctxt)
6467{
6468 int ret = 0, ret2;
6469 struct ocfs2_per_slot_free_list *fl;
6470
6471 if (!ctxt)
6472 return 0;
6473
6474 while (ctxt->c_first_suballocator) {
6475 fl = ctxt->c_first_suballocator;
6476
6477 if (fl->f_first) {
6478 mlog(0, "Free items: (type %u, slot %d)\n",
6479 fl->f_inode_type, fl->f_slot);
6480 ret2 = ocfs2_free_cached_blocks(osb,
6481 fl->f_inode_type,
6482 fl->f_slot,
6483 fl->f_first);
6484 if (ret2)
6485 mlog_errno(ret2);
6486 if (!ret)
6487 ret = ret2;
6488 }
6489
6490 ctxt->c_first_suballocator = fl->f_next_suballocator;
6491 kfree(fl);
6492 }
6493
6494 if (ctxt->c_global_allocator) {
6495 ret2 = ocfs2_free_cached_clusters(osb,
6496 ctxt->c_global_allocator);
6497 if (ret2)
6498 mlog_errno(ret2);
6499 if (!ret)
6500 ret = ret2;
6501
6502 ctxt->c_global_allocator = NULL;
6503 }
6504
6505 return ret;
6506}
6507
6508static struct ocfs2_per_slot_free_list *
6509ocfs2_find_per_slot_free_list(int type,
6510 int slot,
6511 struct ocfs2_cached_dealloc_ctxt *ctxt)
6512{
6513 struct ocfs2_per_slot_free_list *fl = ctxt->c_first_suballocator;
6514
6515 while (fl) {
6516 if (fl->f_inode_type == type && fl->f_slot == slot)
6517 return fl;
6518
6519 fl = fl->f_next_suballocator;
6520 }
6521
6522 fl = kmalloc(sizeof(*fl), GFP_NOFS);
6523 if (fl) {
6524 fl->f_inode_type = type;
6525 fl->f_slot = slot;
6526 fl->f_first = NULL;
6527 fl->f_next_suballocator = ctxt->c_first_suballocator;
6528
6529 ctxt->c_first_suballocator = fl;
6530 }
6531 return fl;
6532}
6533
6534int ocfs2_cache_block_dealloc(struct ocfs2_cached_dealloc_ctxt *ctxt,
6535 int type, int slot, u64 blkno,
6536 unsigned int bit)
6537{
6538 int ret;
6539 struct ocfs2_per_slot_free_list *fl;
6540 struct ocfs2_cached_block_free *item;
6541
6542 fl = ocfs2_find_per_slot_free_list(type, slot, ctxt);
6543 if (fl == NULL) {
6544 ret = -ENOMEM;
6545 mlog_errno(ret);
6546 goto out;
6547 }
6548
6549 item = kmalloc(sizeof(*item), GFP_NOFS);
6550 if (item == NULL) {
6551 ret = -ENOMEM;
6552 mlog_errno(ret);
6553 goto out;
6554 }
6555
6556 mlog(0, "Insert: (type %d, slot %u, bit %u, blk %llu)\n",
6557 type, slot, bit, (unsigned long long)blkno);
6558
6559 item->free_blk = blkno;
6560 item->free_bit = bit;
6561 item->free_next = fl->f_first;
6562
6563 fl->f_first = item;
6564
6565 ret = 0;
6566out:
6567 return ret;
6568}
6569
6570static int ocfs2_cache_extent_block_free(struct ocfs2_cached_dealloc_ctxt *ctxt,
6571 struct ocfs2_extent_block *eb)
6572{
6573 return ocfs2_cache_block_dealloc(ctxt, EXTENT_ALLOC_SYSTEM_INODE,
6574 le16_to_cpu(eb->h_suballoc_slot),
6575 le64_to_cpu(eb->h_blkno),
6576 le16_to_cpu(eb->h_suballoc_bit));
6577}
6578
6579
6580
6581
6582
6583static int ocfs2_find_new_last_ext_blk(struct inode *inode,
6584 unsigned int clusters_to_del,
6585 struct ocfs2_path *path,
6586 struct buffer_head **new_last_eb)
6587{
6588 int next_free, ret = 0;
6589 u32 cpos;
6590 struct ocfs2_extent_rec *rec;
6591 struct ocfs2_extent_block *eb;
6592 struct ocfs2_extent_list *el;
6593 struct buffer_head *bh = NULL;
6594
6595 *new_last_eb = NULL;
6596
6597
6598 if (!path->p_tree_depth)
6599 goto out;
6600
6601
6602
6603 if (OCFS2_I(inode)->ip_clusters == clusters_to_del)
6604 goto out;
6605
6606 el = path_leaf_el(path);
6607 BUG_ON(!el->l_next_free_rec);
6608
6609
6610
6611
6612
6613
6614
6615
6616 next_free = le16_to_cpu(el->l_next_free_rec);
6617 rec = NULL;
6618 if (ocfs2_is_empty_extent(&el->l_recs[0])) {
6619 if (next_free > 2)
6620 goto out;
6621
6622
6623 if (next_free == 2)
6624 rec = &el->l_recs[1];
6625
6626
6627
6628
6629
6630 } else {
6631 if (next_free > 1)
6632 goto out;
6633
6634 rec = &el->l_recs[0];
6635 }
6636
6637 if (rec) {
6638
6639
6640
6641
6642 if (le16_to_cpu(rec->e_leaf_clusters) > clusters_to_del)
6643 goto out;
6644 }
6645
6646 ret = ocfs2_find_cpos_for_left_leaf(inode->i_sb, path, &cpos);
6647 if (ret) {
6648 mlog_errno(ret);
6649 goto out;
6650 }
6651
6652 ret = ocfs2_find_leaf(INODE_CACHE(inode), path_root_el(path), cpos, &bh);
6653 if (ret) {
6654 mlog_errno(ret);
6655 goto out;
6656 }
6657
6658 eb = (struct ocfs2_extent_block *) bh->b_data;
6659 el = &eb->h_list;
6660
6661
6662
6663 BUG_ON(!OCFS2_IS_VALID_EXTENT_BLOCK(eb));
6664
6665 *new_last_eb = bh;
6666 get_bh(*new_last_eb);
6667 mlog(0, "returning block %llu, (cpos: %u)\n",
6668 (unsigned long long)le64_to_cpu(eb->h_blkno), cpos);
6669out:
6670 brelse(bh);
6671
6672 return ret;
6673}
6674
6675
6676
6677
6678
6679
6680
6681
6682
6683static int ocfs2_trim_tree(struct inode *inode, struct ocfs2_path *path,
6684 handle_t *handle, struct ocfs2_truncate_context *tc,
6685 u32 clusters_to_del, u64 *delete_start, u8 *flags)
6686{
6687 int ret, i, index = path->p_tree_depth;
6688 u32 new_edge = 0;
6689 u64 deleted_eb = 0;
6690 struct buffer_head *bh;
6691 struct ocfs2_extent_list *el;
6692 struct ocfs2_extent_rec *rec;
6693
6694 *delete_start = 0;
6695 *flags = 0;
6696
6697 while (index >= 0) {
6698 bh = path->p_node[index].bh;
6699 el = path->p_node[index].el;
6700
6701 mlog(0, "traveling tree (index = %d, block = %llu)\n",
6702 index, (unsigned long long)bh->b_blocknr);
6703
6704 BUG_ON(le16_to_cpu(el->l_next_free_rec) == 0);
6705
6706 if (index !=
6707 (path->p_tree_depth - le16_to_cpu(el->l_tree_depth))) {
6708 ocfs2_error(inode->i_sb,
6709 "Inode %lu has invalid ext. block %llu",
6710 inode->i_ino,
6711 (unsigned long long)bh->b_blocknr);
6712 ret = -EROFS;
6713 goto out;
6714 }
6715
6716find_tail_record:
6717 i = le16_to_cpu(el->l_next_free_rec) - 1;
6718 rec = &el->l_recs[i];
6719
6720 mlog(0, "Extent list before: record %d: (%u, %u, %llu), "
6721 "next = %u\n", i, le32_to_cpu(rec->e_cpos),
6722 ocfs2_rec_clusters(el, rec),
6723 (unsigned long long)le64_to_cpu(rec->e_blkno),
6724 le16_to_cpu(el->l_next_free_rec));
6725
6726 BUG_ON(ocfs2_rec_clusters(el, rec) < clusters_to_del);
6727
6728 if (le16_to_cpu(el->l_tree_depth) == 0) {
6729
6730
6731
6732
6733
6734 if (i == 0 && ocfs2_is_empty_extent(rec)) {
6735 memset(rec, 0,
6736 sizeof(struct ocfs2_extent_rec));
6737 el->l_next_free_rec = cpu_to_le16(0);
6738
6739 goto delete;
6740 }
6741
6742
6743
6744
6745
6746
6747
6748
6749 if (ocfs2_is_empty_extent(&el->l_recs[0])) {
6750 le16_add_cpu(&el->l_next_free_rec, -1);
6751
6752 for(i = 0;
6753 i < le16_to_cpu(el->l_next_free_rec); i++)
6754 el->l_recs[i] = el->l_recs[i + 1];
6755
6756 memset(&el->l_recs[i], 0,
6757 sizeof(struct ocfs2_extent_rec));
6758
6759
6760
6761
6762
6763
6764
6765 goto find_tail_record;
6766 }
6767
6768 le16_add_cpu(&rec->e_leaf_clusters, -clusters_to_del);
6769
6770
6771
6772
6773
6774 new_edge = le16_to_cpu(rec->e_leaf_clusters);
6775 new_edge += le32_to_cpu(rec->e_cpos);
6776
6777
6778
6779
6780 *delete_start = le64_to_cpu(rec->e_blkno)
6781 + ocfs2_clusters_to_blocks(inode->i_sb,
6782 le16_to_cpu(rec->e_leaf_clusters));
6783 *flags = rec->e_flags;
6784
6785
6786
6787
6788 if (le16_to_cpu(rec->e_leaf_clusters) == 0) {
6789 memset(rec, 0,
6790 sizeof(struct ocfs2_extent_rec));
6791 le16_add_cpu(&el->l_next_free_rec, -1);
6792 }
6793 } else {
6794 if (le64_to_cpu(rec->e_blkno) == deleted_eb) {
6795 memset(rec, 0,
6796 sizeof(struct ocfs2_extent_rec));
6797 le16_add_cpu(&el->l_next_free_rec, -1);
6798
6799 goto delete;
6800 }
6801
6802
6803 if (le16_to_cpu(el->l_next_free_rec) == 0)
6804 goto delete;
6805
6806
6807
6808
6809
6810
6811 if (new_edge == 0)
6812 goto delete;
6813
6814 rec->e_int_clusters = cpu_to_le32(new_edge);
6815 le32_add_cpu(&rec->e_int_clusters,
6816 -le32_to_cpu(rec->e_cpos));
6817
6818
6819
6820
6821
6822 BUG_ON(le32_to_cpu(rec->e_int_clusters) == 0);
6823 }
6824
6825delete:
6826 ret = ocfs2_journal_dirty(handle, bh);
6827 if (ret) {
6828 mlog_errno(ret);
6829 goto out;
6830 }
6831
6832 mlog(0, "extent list container %llu, after: record %d: "
6833 "(%u, %u, %llu), next = %u.\n",
6834 (unsigned long long)bh->b_blocknr, i,
6835 le32_to_cpu(rec->e_cpos), ocfs2_rec_clusters(el, rec),
6836 (unsigned long long)le64_to_cpu(rec->e_blkno),
6837 le16_to_cpu(el->l_next_free_rec));
6838
6839
6840
6841
6842
6843 if (index > 0 && le16_to_cpu(el->l_next_free_rec) == 0) {
6844 struct ocfs2_extent_block *eb =
6845 (struct ocfs2_extent_block *)bh->b_data;
6846
6847
6848
6849
6850
6851 deleted_eb = le64_to_cpu(eb->h_blkno);
6852
6853 mlog(0, "deleting this extent block.\n");
6854
6855 ocfs2_remove_from_cache(INODE_CACHE(inode), bh);
6856
6857 BUG_ON(ocfs2_rec_clusters(el, &el->l_recs[0]));
6858 BUG_ON(le32_to_cpu(el->l_recs[0].e_cpos));
6859 BUG_ON(le64_to_cpu(el->l_recs[0].e_blkno));
6860
6861 ret = ocfs2_cache_extent_block_free(&tc->tc_dealloc, eb);
6862
6863 if (ret < 0)
6864 mlog_errno(ret);
6865 } else {
6866 deleted_eb = 0;
6867 }
6868
6869 index--;
6870 }
6871
6872 ret = 0;
6873out:
6874 return ret;
6875}
6876
6877static int ocfs2_do_truncate(struct ocfs2_super *osb,
6878 unsigned int clusters_to_del,
6879 struct inode *inode,
6880 struct buffer_head *fe_bh,
6881 handle_t *handle,
6882 struct ocfs2_truncate_context *tc,
6883 struct ocfs2_path *path,
6884 struct ocfs2_alloc_context *meta_ac)
6885{
6886 int status;
6887 struct ocfs2_dinode *fe;
6888 struct ocfs2_extent_block *last_eb = NULL;
6889 struct ocfs2_extent_list *el;
6890 struct buffer_head *last_eb_bh = NULL;
6891 u64 delete_blk = 0;
6892 u8 rec_flags;
6893
6894 fe = (struct ocfs2_dinode *) fe_bh->b_data;
6895
6896 status = ocfs2_find_new_last_ext_blk(inode, clusters_to_del,
6897 path, &last_eb_bh);
6898 if (status < 0) {
6899 mlog_errno(status);
6900 goto bail;
6901 }
6902
6903
6904
6905
6906
6907 status = ocfs2_journal_access_path(INODE_CACHE(inode), handle, path);
6908 if (status < 0) {
6909 mlog_errno(status);
6910 goto bail;
6911 }
6912
6913 if (last_eb_bh) {
6914 status = ocfs2_journal_access_eb(handle, INODE_CACHE(inode), last_eb_bh,
6915 OCFS2_JOURNAL_ACCESS_WRITE);
6916 if (status < 0) {
6917 mlog_errno(status);
6918 goto bail;
6919 }
6920
6921 last_eb = (struct ocfs2_extent_block *) last_eb_bh->b_data;
6922 }
6923
6924 el = &(fe->id2.i_list);
6925
6926
6927
6928
6929
6930 if (el->l_tree_depth && el->l_recs[0].e_int_clusters == 0) {
6931 ocfs2_error(inode->i_sb,
6932 "Inode %lu has an empty extent record, depth %u\n",
6933 inode->i_ino, le16_to_cpu(el->l_tree_depth));
6934 status = -EROFS;
6935 goto bail;
6936 }
6937
6938 vfs_dq_free_space_nodirty(inode,
6939 ocfs2_clusters_to_bytes(osb->sb, clusters_to_del));
6940 spin_lock(&OCFS2_I(inode)->ip_lock);
6941 OCFS2_I(inode)->ip_clusters = le32_to_cpu(fe->i_clusters) -
6942 clusters_to_del;
6943 spin_unlock(&OCFS2_I(inode)->ip_lock);
6944 le32_add_cpu(&fe->i_clusters, -clusters_to_del);
6945 inode->i_blocks = ocfs2_inode_sector_count(inode);
6946
6947 status = ocfs2_trim_tree(inode, path, handle, tc,
6948 clusters_to_del, &delete_blk, &rec_flags);
6949 if (status) {
6950 mlog_errno(status);
6951 goto bail;
6952 }
6953
6954 if (le32_to_cpu(fe->i_clusters) == 0) {
6955
6956 el->l_tree_depth = 0;
6957 fe->i_last_eb_blk = 0;
6958 } else if (last_eb)
6959 fe->i_last_eb_blk = last_eb->h_blkno;
6960
6961 status = ocfs2_journal_dirty(handle, fe_bh);
6962 if (status < 0) {
6963 mlog_errno(status);
6964 goto bail;
6965 }
6966
6967 if (last_eb) {
6968
6969
6970
6971 last_eb->h_next_leaf_blk = 0;
6972 status = ocfs2_journal_dirty(handle, last_eb_bh);
6973 if (status < 0) {
6974 mlog_errno(status);
6975 goto bail;
6976 }
6977 }
6978
6979 if (delete_blk) {
6980 if (rec_flags & OCFS2_EXT_REFCOUNTED)
6981 status = ocfs2_decrease_refcount(inode, handle,
6982 ocfs2_blocks_to_clusters(osb->sb,
6983 delete_blk),
6984 clusters_to_del, meta_ac,
6985 &tc->tc_dealloc, 1);
6986 else
6987 status = ocfs2_truncate_log_append(osb, handle,
6988 delete_blk,
6989 clusters_to_del);
6990 if (status < 0) {
6991 mlog_errno(status);
6992 goto bail;
6993 }
6994 }
6995 status = 0;
6996bail:
6997 brelse(last_eb_bh);
6998 mlog_exit(status);
6999 return status;
7000}
7001
7002static int ocfs2_zero_func(handle_t *handle, struct buffer_head *bh)
7003{
7004 set_buffer_uptodate(bh);
7005 mark_buffer_dirty(bh);
7006 return 0;
7007}
7008
7009void ocfs2_map_and_dirty_page(struct inode *inode, handle_t *handle,
7010 unsigned int from, unsigned int to,
7011 struct page *page, int zero, u64 *phys)
7012{
7013 int ret, partial = 0;
7014
7015 ret = ocfs2_map_page_blocks(page, phys, inode, from, to, 0);
7016 if (ret)
7017 mlog_errno(ret);
7018
7019 if (zero)
7020 zero_user_segment(page, from, to);
7021
7022
7023
7024
7025
7026
7027 ret = walk_page_buffers(handle, page_buffers(page),
7028 from, to, &partial,
7029 ocfs2_zero_func);
7030 if (ret < 0)
7031 mlog_errno(ret);
7032 else if (ocfs2_should_order_data(inode)) {
7033 ret = ocfs2_jbd2_file_inode(handle, inode);
7034 if (ret < 0)
7035 mlog_errno(ret);
7036 }
7037
7038 if (!partial)
7039 SetPageUptodate(page);
7040
7041 flush_dcache_page(page);
7042}
7043
7044static void ocfs2_zero_cluster_pages(struct inode *inode, loff_t start,
7045 loff_t end, struct page **pages,
7046 int numpages, u64 phys, handle_t *handle)
7047{
7048 int i;
7049 struct page *page;
7050 unsigned int from, to = PAGE_CACHE_SIZE;
7051 struct super_block *sb = inode->i_sb;
7052
7053 BUG_ON(!ocfs2_sparse_alloc(OCFS2_SB(sb)));
7054
7055 if (numpages == 0)
7056 goto out;
7057
7058 to = PAGE_CACHE_SIZE;
7059 for(i = 0; i < numpages; i++) {
7060 page = pages[i];
7061
7062 from = start & (PAGE_CACHE_SIZE - 1);
7063 if ((end >> PAGE_CACHE_SHIFT) == page->index)
7064 to = end & (PAGE_CACHE_SIZE - 1);
7065
7066 BUG_ON(from > PAGE_CACHE_SIZE);
7067 BUG_ON(to > PAGE_CACHE_SIZE);
7068
7069 ocfs2_map_and_dirty_page(inode, handle, from, to, page, 1,
7070 &phys);
7071
7072 start = (page->index + 1) << PAGE_CACHE_SHIFT;
7073 }
7074out:
7075 if (pages)
7076 ocfs2_unlock_and_free_pages(pages, numpages);
7077}
7078
7079int ocfs2_grab_pages(struct inode *inode, loff_t start, loff_t end,
7080 struct page **pages, int *num)
7081{
7082 int numpages, ret = 0;
7083 struct address_space *mapping = inode->i_mapping;
7084 unsigned long index;
7085 loff_t last_page_bytes;
7086
7087 BUG_ON(start > end);
7088
7089 numpages = 0;
7090 last_page_bytes = PAGE_ALIGN(end);
7091 index = start >> PAGE_CACHE_SHIFT;
7092 do {
7093 pages[numpages] = grab_cache_page(mapping, index);
7094 if (!pages[numpages]) {
7095 ret = -ENOMEM;
7096 mlog_errno(ret);
7097 goto out;
7098 }
7099
7100 numpages++;
7101 index++;
7102 } while (index < (last_page_bytes >> PAGE_CACHE_SHIFT));
7103
7104out:
7105 if (ret != 0) {
7106 if (pages)
7107 ocfs2_unlock_and_free_pages(pages, numpages);
7108 numpages = 0;
7109 }
7110
7111 *num = numpages;
7112
7113 return ret;
7114}
7115
7116static int ocfs2_grab_eof_pages(struct inode *inode, loff_t start, loff_t end,
7117 struct page **pages, int *num)
7118{
7119 struct super_block *sb = inode->i_sb;
7120
7121 BUG_ON(start >> OCFS2_SB(sb)->s_clustersize_bits !=
7122 (end - 1) >> OCFS2_SB(sb)->s_clustersize_bits);
7123
7124 return ocfs2_grab_pages(inode, start, end, pages, num);
7125}
7126
7127
7128
7129
7130
7131
7132
7133
7134
7135
7136int ocfs2_zero_range_for_truncate(struct inode *inode, handle_t *handle,
7137 u64 range_start, u64 range_end)
7138{
7139 int ret = 0, numpages;
7140 struct page **pages = NULL;
7141 u64 phys;
7142 unsigned int ext_flags;
7143 struct super_block *sb = inode->i_sb;
7144
7145
7146
7147
7148
7149 if (!ocfs2_sparse_alloc(OCFS2_SB(sb)))
7150 return 0;
7151
7152 pages = kcalloc(ocfs2_pages_per_cluster(sb),
7153 sizeof(struct page *), GFP_NOFS);
7154 if (pages == NULL) {
7155 ret = -ENOMEM;
7156 mlog_errno(ret);
7157 goto out;
7158 }
7159
7160 if (range_start == range_end)
7161 goto out;
7162
7163 ret = ocfs2_extent_map_get_blocks(inode,
7164 range_start >> sb->s_blocksize_bits,
7165 &phys, NULL, &ext_flags);
7166 if (ret) {
7167 mlog_errno(ret);
7168 goto out;
7169 }
7170
7171
7172
7173
7174
7175 if (phys == 0 || ext_flags & OCFS2_EXT_UNWRITTEN)
7176 goto out;
7177
7178 ret = ocfs2_grab_eof_pages(inode, range_start, range_end, pages,
7179 &numpages);
7180 if (ret) {
7181 mlog_errno(ret);
7182 goto out;
7183 }
7184
7185 ocfs2_zero_cluster_pages(inode, range_start, range_end, pages,
7186 numpages, phys, handle);
7187
7188
7189
7190
7191
7192
7193 ret = do_sync_mapping_range(inode->i_mapping, range_start,
7194 range_end - 1, SYNC_FILE_RANGE_WRITE);
7195 if (ret)
7196 mlog_errno(ret);
7197
7198out:
7199 if (pages)
7200 kfree(pages);
7201
7202 return ret;
7203}
7204
7205static void ocfs2_zero_dinode_id2_with_xattr(struct inode *inode,
7206 struct ocfs2_dinode *di)
7207{
7208 unsigned int blocksize = 1 << inode->i_sb->s_blocksize_bits;
7209 unsigned int xattrsize = le16_to_cpu(di->i_xattr_inline_size);
7210
7211 if (le16_to_cpu(di->i_dyn_features) & OCFS2_INLINE_XATTR_FL)
7212 memset(&di->id2, 0, blocksize -
7213 offsetof(struct ocfs2_dinode, id2) -
7214 xattrsize);
7215 else
7216 memset(&di->id2, 0, blocksize -
7217 offsetof(struct ocfs2_dinode, id2));
7218}
7219
7220void ocfs2_dinode_new_extent_list(struct inode *inode,
7221 struct ocfs2_dinode *di)
7222{
7223 ocfs2_zero_dinode_id2_with_xattr(inode, di);
7224 di->id2.i_list.l_tree_depth = 0;
7225 di->id2.i_list.l_next_free_rec = 0;
7226 di->id2.i_list.l_count = cpu_to_le16(
7227 ocfs2_extent_recs_per_inode_with_xattr(inode->i_sb, di));
7228}
7229
7230void ocfs2_set_inode_data_inline(struct inode *inode, struct ocfs2_dinode *di)
7231{
7232 struct ocfs2_inode_info *oi = OCFS2_I(inode);
7233 struct ocfs2_inline_data *idata = &di->id2.i_data;
7234
7235 spin_lock(&oi->ip_lock);
7236 oi->ip_dyn_features |= OCFS2_INLINE_DATA_FL;
7237 di->i_dyn_features = cpu_to_le16(oi->ip_dyn_features);
7238 spin_unlock(&oi->ip_lock);
7239
7240
7241
7242
7243
7244 ocfs2_zero_dinode_id2_with_xattr(inode, di);
7245
7246 idata->id_count = cpu_to_le16(
7247 ocfs2_max_inline_data_with_xattr(inode->i_sb, di));
7248}
7249
7250int ocfs2_convert_inline_data_to_extents(struct inode *inode,
7251 struct buffer_head *di_bh)
7252{
7253 int ret, i, has_data, num_pages = 0;
7254 handle_t *handle;
7255 u64 uninitialized_var(block);
7256 struct ocfs2_inode_info *oi = OCFS2_I(inode);
7257 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
7258 struct ocfs2_dinode *di = (struct ocfs2_dinode *)di_bh->b_data;
7259 struct ocfs2_alloc_context *data_ac = NULL;
7260 struct page **pages = NULL;
7261 loff_t end = osb->s_clustersize;
7262 struct ocfs2_extent_tree et;
7263 int did_quota = 0;
7264
7265 has_data = i_size_read(inode) ? 1 : 0;
7266
7267 if (has_data) {
7268 pages = kcalloc(ocfs2_pages_per_cluster(osb->sb),
7269 sizeof(struct page *), GFP_NOFS);
7270 if (pages == NULL) {
7271 ret = -ENOMEM;
7272 mlog_errno(ret);
7273 goto out;
7274 }
7275
7276 ret = ocfs2_reserve_clusters(osb, 1, &data_ac);
7277 if (ret) {
7278 mlog_errno(ret);
7279 goto out;
7280 }
7281 }
7282
7283 handle = ocfs2_start_trans(osb,
7284 ocfs2_inline_to_extents_credits(osb->sb));
7285 if (IS_ERR(handle)) {
7286 ret = PTR_ERR(handle);
7287 mlog_errno(ret);
7288 goto out_unlock;
7289 }
7290
7291 ret = ocfs2_journal_access_di(handle, INODE_CACHE(inode), di_bh,
7292 OCFS2_JOURNAL_ACCESS_WRITE);
7293 if (ret) {
7294 mlog_errno(ret);
7295 goto out_commit;
7296 }
7297
7298 if (has_data) {
7299 u32 bit_off, num;
7300 unsigned int page_end;
7301 u64 phys;
7302
7303 if (vfs_dq_alloc_space_nodirty(inode,
7304 ocfs2_clusters_to_bytes(osb->sb, 1))) {
7305 ret = -EDQUOT;
7306 goto out_commit;
7307 }
7308 did_quota = 1;
7309
7310 ret = ocfs2_claim_clusters(osb, handle, data_ac, 1, &bit_off,
7311 &num);
7312 if (ret) {
7313 mlog_errno(ret);
7314 goto out_commit;
7315 }
7316
7317
7318
7319
7320
7321 block = phys = ocfs2_clusters_to_blocks(inode->i_sb, bit_off);
7322
7323
7324
7325
7326
7327 if (!ocfs2_sparse_alloc(osb) &&
7328 PAGE_CACHE_SIZE < osb->s_clustersize)
7329 end = PAGE_CACHE_SIZE;
7330
7331 ret = ocfs2_grab_eof_pages(inode, 0, end, pages, &num_pages);
7332 if (ret) {
7333 mlog_errno(ret);
7334 goto out_commit;
7335 }
7336
7337
7338
7339
7340
7341 ret = ocfs2_read_inline_data(inode, pages[0], di_bh);
7342 if (ret) {
7343 mlog_errno(ret);
7344 goto out_commit;
7345 }
7346
7347 page_end = PAGE_CACHE_SIZE;
7348 if (PAGE_CACHE_SIZE > osb->s_clustersize)
7349 page_end = osb->s_clustersize;
7350
7351 for (i = 0; i < num_pages; i++)
7352 ocfs2_map_and_dirty_page(inode, handle, 0, page_end,
7353 pages[i], i > 0, &phys);
7354 }
7355
7356 spin_lock(&oi->ip_lock);
7357 oi->ip_dyn_features &= ~OCFS2_INLINE_DATA_FL;
7358 di->i_dyn_features = cpu_to_le16(oi->ip_dyn_features);
7359 spin_unlock(&oi->ip_lock);
7360
7361 ocfs2_dinode_new_extent_list(inode, di);
7362
7363 ocfs2_journal_dirty(handle, di_bh);
7364
7365 if (has_data) {
7366
7367
7368
7369
7370
7371 ocfs2_init_dinode_extent_tree(&et, INODE_CACHE(inode), di_bh);
7372 ret = ocfs2_insert_extent(handle, &et, 0, block, 1, 0, NULL);
7373 if (ret) {
7374 mlog_errno(ret);
7375 goto out_commit;
7376 }
7377
7378 inode->i_blocks = ocfs2_inode_sector_count(inode);
7379 }
7380
7381out_commit:
7382 if (ret < 0 && did_quota)
7383 vfs_dq_free_space_nodirty(inode,
7384 ocfs2_clusters_to_bytes(osb->sb, 1));
7385
7386 ocfs2_commit_trans(osb, handle);
7387
7388out_unlock:
7389 if (data_ac)
7390 ocfs2_free_alloc_context(data_ac);
7391
7392out:
7393 if (pages) {
7394 ocfs2_unlock_and_free_pages(pages, num_pages);
7395 kfree(pages);
7396 }
7397
7398 return ret;
7399}
7400
7401
7402
7403
7404
7405
7406
7407int ocfs2_commit_truncate(struct ocfs2_super *osb,
7408 struct inode *inode,
7409 struct buffer_head *fe_bh,
7410 struct ocfs2_truncate_context *tc)
7411{
7412 int status, i, credits, tl_sem = 0;
7413 u32 clusters_to_del, new_highest_cpos, range;
7414 u64 blkno = 0;
7415 struct ocfs2_extent_list *el;
7416 handle_t *handle = NULL;
7417 struct inode *tl_inode = osb->osb_tl_inode;
7418 struct ocfs2_path *path = NULL;
7419 struct ocfs2_dinode *di = (struct ocfs2_dinode *)fe_bh->b_data;
7420 struct ocfs2_alloc_context *meta_ac = NULL;
7421 struct ocfs2_refcount_tree *ref_tree = NULL;
7422
7423 mlog_entry_void();
7424
7425 new_highest_cpos = ocfs2_clusters_for_bytes(osb->sb,
7426 i_size_read(inode));
7427
7428 path = ocfs2_new_path(fe_bh, &di->id2.i_list,
7429 ocfs2_journal_access_di);
7430 if (!path) {
7431 status = -ENOMEM;
7432 mlog_errno(status);
7433 goto bail;
7434 }
7435
7436 ocfs2_extent_map_trunc(inode, new_highest_cpos);
7437
7438start:
7439
7440
7441
7442 if (OCFS2_I(inode)->ip_clusters == 0) {
7443 status = 0;
7444 goto bail;
7445 }
7446
7447 credits = 0;
7448
7449
7450
7451
7452 status = ocfs2_find_path(INODE_CACHE(inode), path, UINT_MAX);
7453 if (status) {
7454 mlog_errno(status);
7455 goto bail;
7456 }
7457
7458 mlog(0, "inode->ip_clusters = %u, tree_depth = %u\n",
7459 OCFS2_I(inode)->ip_clusters, path->p_tree_depth);
7460
7461
7462
7463
7464
7465
7466
7467
7468
7469
7470
7471
7472 el = path_leaf_el(path);
7473 if (le16_to_cpu(el->l_next_free_rec) == 0) {
7474 ocfs2_error(inode->i_sb,
7475 "Inode %llu has empty extent block at %llu\n",
7476 (unsigned long long)OCFS2_I(inode)->ip_blkno,
7477 (unsigned long long)path_leaf_bh(path)->b_blocknr);
7478 status = -EROFS;
7479 goto bail;
7480 }
7481
7482 i = le16_to_cpu(el->l_next_free_rec) - 1;
7483 range = le32_to_cpu(el->l_recs[i].e_cpos) +
7484 ocfs2_rec_clusters(el, &el->l_recs[i]);
7485 if (i == 0 && ocfs2_is_empty_extent(&el->l_recs[i])) {
7486 clusters_to_del = 0;
7487 } else if (le32_to_cpu(el->l_recs[i].e_cpos) >= new_highest_cpos) {
7488 clusters_to_del = ocfs2_rec_clusters(el, &el->l_recs[i]);
7489 blkno = le64_to_cpu(el->l_recs[i].e_blkno);
7490 } else if (range > new_highest_cpos) {
7491 clusters_to_del = (ocfs2_rec_clusters(el, &el->l_recs[i]) +
7492 le32_to_cpu(el->l_recs[i].e_cpos)) -
7493 new_highest_cpos;
7494 blkno = le64_to_cpu(el->l_recs[i].e_blkno) +
7495 ocfs2_clusters_to_blocks(inode->i_sb,
7496 ocfs2_rec_clusters(el, &el->l_recs[i]) -
7497 clusters_to_del);
7498 } else {
7499 status = 0;
7500 goto bail;
7501 }
7502
7503 mlog(0, "clusters_to_del = %u in this pass, tail blk=%llu\n",
7504 clusters_to_del, (unsigned long long)path_leaf_bh(path)->b_blocknr);
7505
7506 if (el->l_recs[i].e_flags & OCFS2_EXT_REFCOUNTED && clusters_to_del) {
7507 BUG_ON(!(OCFS2_I(inode)->ip_dyn_features &
7508 OCFS2_HAS_REFCOUNT_FL));
7509
7510 status = ocfs2_lock_refcount_tree(osb,
7511 le64_to_cpu(di->i_refcount_loc),
7512 1, &ref_tree, NULL);
7513 if (status) {
7514 mlog_errno(status);
7515 goto bail;
7516 }
7517
7518 status = ocfs2_prepare_refcount_change_for_del(inode, fe_bh,
7519 blkno,
7520 clusters_to_del,
7521 &credits,
7522 &meta_ac);
7523 if (status < 0) {
7524 mlog_errno(status);
7525 goto bail;
7526 }
7527 }
7528
7529 mutex_lock(&tl_inode->i_mutex);
7530 tl_sem = 1;
7531
7532
7533
7534 if (ocfs2_truncate_log_needs_flush(osb)) {
7535 status = __ocfs2_flush_truncate_log(osb);
7536 if (status < 0) {
7537 mlog_errno(status);
7538 goto bail;
7539 }
7540 }
7541
7542 credits += ocfs2_calc_tree_trunc_credits(osb->sb, clusters_to_del,
7543 (struct ocfs2_dinode *)fe_bh->b_data,
7544 el);
7545 handle = ocfs2_start_trans(osb, credits);
7546 if (IS_ERR(handle)) {
7547 status = PTR_ERR(handle);
7548 handle = NULL;
7549 mlog_errno(status);
7550 goto bail;
7551 }
7552
7553 status = ocfs2_do_truncate(osb, clusters_to_del, inode, fe_bh, handle,
7554 tc, path, meta_ac);
7555 if (status < 0) {
7556 mlog_errno(status);
7557 goto bail;
7558 }
7559
7560 mutex_unlock(&tl_inode->i_mutex);
7561 tl_sem = 0;
7562
7563 ocfs2_commit_trans(osb, handle);
7564 handle = NULL;
7565
7566 ocfs2_reinit_path(path, 1);
7567
7568 if (meta_ac) {
7569 ocfs2_free_alloc_context(meta_ac);
7570 meta_ac = NULL;
7571 }
7572
7573 if (ref_tree) {
7574 ocfs2_unlock_refcount_tree(osb, ref_tree, 1);
7575 ref_tree = NULL;
7576 }
7577
7578
7579
7580
7581
7582 goto start;
7583
7584bail:
7585
7586 ocfs2_schedule_truncate_log_flush(osb, 1);
7587
7588 if (tl_sem)
7589 mutex_unlock(&tl_inode->i_mutex);
7590
7591 if (handle)
7592 ocfs2_commit_trans(osb, handle);
7593
7594 if (meta_ac)
7595 ocfs2_free_alloc_context(meta_ac);
7596
7597 if (ref_tree)
7598 ocfs2_unlock_refcount_tree(osb, ref_tree, 1);
7599
7600 ocfs2_run_deallocs(osb, &tc->tc_dealloc);
7601
7602 ocfs2_free_path(path);
7603
7604
7605 ocfs2_free_truncate_context(tc);
7606
7607 mlog_exit(status);
7608 return status;
7609}
7610
7611
7612
7613
7614int ocfs2_prepare_truncate(struct ocfs2_super *osb,
7615 struct inode *inode,
7616 struct buffer_head *fe_bh,
7617 struct ocfs2_truncate_context **tc)
7618{
7619 int status;
7620 unsigned int new_i_clusters;
7621 struct ocfs2_dinode *fe;
7622 struct ocfs2_extent_block *eb;
7623 struct buffer_head *last_eb_bh = NULL;
7624
7625 mlog_entry_void();
7626
7627 *tc = NULL;
7628
7629 new_i_clusters = ocfs2_clusters_for_bytes(osb->sb,
7630 i_size_read(inode));
7631 fe = (struct ocfs2_dinode *) fe_bh->b_data;
7632
7633 mlog(0, "fe->i_clusters = %u, new_i_clusters = %u, fe->i_size ="
7634 "%llu\n", le32_to_cpu(fe->i_clusters), new_i_clusters,
7635 (unsigned long long)le64_to_cpu(fe->i_size));
7636
7637 *tc = kzalloc(sizeof(struct ocfs2_truncate_context), GFP_KERNEL);
7638 if (!(*tc)) {
7639 status = -ENOMEM;
7640 mlog_errno(status);
7641 goto bail;
7642 }
7643 ocfs2_init_dealloc_ctxt(&(*tc)->tc_dealloc);
7644
7645 if (fe->id2.i_list.l_tree_depth) {
7646 status = ocfs2_read_extent_block(INODE_CACHE(inode),
7647 le64_to_cpu(fe->i_last_eb_blk),
7648 &last_eb_bh);
7649 if (status < 0) {
7650 mlog_errno(status);
7651 goto bail;
7652 }
7653 eb = (struct ocfs2_extent_block *) last_eb_bh->b_data;
7654 }
7655
7656 (*tc)->tc_last_eb_bh = last_eb_bh;
7657
7658 status = 0;
7659bail:
7660 if (status < 0) {
7661 if (*tc)
7662 ocfs2_free_truncate_context(*tc);
7663 *tc = NULL;
7664 }
7665 mlog_exit_void();
7666 return status;
7667}
7668
7669
7670
7671
7672int ocfs2_truncate_inline(struct inode *inode, struct buffer_head *di_bh,
7673 unsigned int start, unsigned int end, int trunc)
7674{
7675 int ret;
7676 unsigned int numbytes;
7677 handle_t *handle;
7678 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
7679 struct ocfs2_dinode *di = (struct ocfs2_dinode *)di_bh->b_data;
7680 struct ocfs2_inline_data *idata = &di->id2.i_data;
7681
7682 if (end > i_size_read(inode))
7683 end = i_size_read(inode);
7684
7685 BUG_ON(start >= end);
7686
7687 if (!(OCFS2_I(inode)->ip_dyn_features & OCFS2_INLINE_DATA_FL) ||
7688 !(le16_to_cpu(di->i_dyn_features) & OCFS2_INLINE_DATA_FL) ||
7689 !ocfs2_supports_inline_data(osb)) {
7690 ocfs2_error(inode->i_sb,
7691 "Inline data flags for inode %llu don't agree! "
7692 "Disk: 0x%x, Memory: 0x%x, Superblock: 0x%x\n",
7693 (unsigned long long)OCFS2_I(inode)->ip_blkno,
7694 le16_to_cpu(di->i_dyn_features),
7695 OCFS2_I(inode)->ip_dyn_features,
7696 osb->s_feature_incompat);
7697 ret = -EROFS;
7698 goto out;
7699 }
7700
7701 handle = ocfs2_start_trans(osb, OCFS2_INODE_UPDATE_CREDITS);
7702 if (IS_ERR(handle)) {
7703 ret = PTR_ERR(handle);
7704 mlog_errno(ret);
7705 goto out;
7706 }
7707
7708 ret = ocfs2_journal_access_di(handle, INODE_CACHE(inode), di_bh,
7709 OCFS2_JOURNAL_ACCESS_WRITE);
7710 if (ret) {
7711 mlog_errno(ret);
7712 goto out_commit;
7713 }
7714
7715 numbytes = end - start;
7716 memset(idata->id_data + start, 0, numbytes);
7717
7718
7719
7720
7721
7722
7723
7724 if (trunc) {
7725 i_size_write(inode, start);
7726 di->i_size = cpu_to_le64(start);
7727 }
7728
7729 inode->i_blocks = ocfs2_inode_sector_count(inode);
7730 inode->i_ctime = inode->i_mtime = CURRENT_TIME;
7731
7732 di->i_ctime = di->i_mtime = cpu_to_le64(inode->i_ctime.tv_sec);
7733 di->i_ctime_nsec = di->i_mtime_nsec = cpu_to_le32(inode->i_ctime.tv_nsec);
7734
7735 ocfs2_journal_dirty(handle, di_bh);
7736
7737out_commit:
7738 ocfs2_commit_trans(osb, handle);
7739
7740out:
7741 return ret;
7742}
7743
7744static void ocfs2_free_truncate_context(struct ocfs2_truncate_context *tc)
7745{
7746
7747
7748
7749
7750 if (tc->tc_dealloc.c_first_suballocator != NULL)
7751 mlog(ML_NOTICE,
7752 "Truncate completion has non-empty dealloc context\n");
7753
7754 brelse(tc->tc_last_eb_bh);
7755
7756 kfree(tc);
7757}
7758