ocfs2: Add support for incrementing refcount in the tree.
[linux-3.10.git] / fs / ocfs2 / extent_map.c
1 /* -*- mode: c; c-basic-offset: 8; -*-
2  * vim: noexpandtab sw=8 ts=8 sts=0:
3  *
4  * extent_map.c
5  *
6  * Block/Cluster mapping functions
7  *
8  * Copyright (C) 2004 Oracle.  All rights reserved.
9  *
10  * This program is free software; you can redistribute it and/or
11  * modify it under the terms of the GNU General Public
12  * License, version 2,  as published by the Free Software Foundation.
13  *
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
17  * General Public License for more details.
18  *
19  * You should have received a copy of the GNU General Public
20  * License along with this program; if not, write to the
21  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
22  * Boston, MA 021110-1307, USA.
23  */
24
25 #include <linux/fs.h>
26 #include <linux/init.h>
27 #include <linux/types.h>
28 #include <linux/fiemap.h>
29
30 #define MLOG_MASK_PREFIX ML_EXTENT_MAP
31 #include <cluster/masklog.h>
32
33 #include "ocfs2.h"
34
35 #include "alloc.h"
36 #include "dlmglue.h"
37 #include "extent_map.h"
38 #include "inode.h"
39 #include "super.h"
40
41 #include "buffer_head_io.h"
42
43 /*
44  * The extent caching implementation is intentionally trivial.
45  *
46  * We only cache a small number of extents stored directly on the
47  * inode, so linear order operations are acceptable. If we ever want
48  * to increase the size of the extent map, then these algorithms must
49  * get smarter.
50  */
51
52 void ocfs2_extent_map_init(struct inode *inode)
53 {
54         struct ocfs2_inode_info *oi = OCFS2_I(inode);
55
56         oi->ip_extent_map.em_num_items = 0;
57         INIT_LIST_HEAD(&oi->ip_extent_map.em_list);
58 }
59
60 static void __ocfs2_extent_map_lookup(struct ocfs2_extent_map *em,
61                                       unsigned int cpos,
62                                       struct ocfs2_extent_map_item **ret_emi)
63 {
64         unsigned int range;
65         struct ocfs2_extent_map_item *emi;
66
67         *ret_emi = NULL;
68
69         list_for_each_entry(emi, &em->em_list, ei_list) {
70                 range = emi->ei_cpos + emi->ei_clusters;
71
72                 if (cpos >= emi->ei_cpos && cpos < range) {
73                         list_move(&emi->ei_list, &em->em_list);
74
75                         *ret_emi = emi;
76                         break;
77                 }
78         }
79 }
80
81 static int ocfs2_extent_map_lookup(struct inode *inode, unsigned int cpos,
82                                    unsigned int *phys, unsigned int *len,
83                                    unsigned int *flags)
84 {
85         unsigned int coff;
86         struct ocfs2_inode_info *oi = OCFS2_I(inode);
87         struct ocfs2_extent_map_item *emi;
88
89         spin_lock(&oi->ip_lock);
90
91         __ocfs2_extent_map_lookup(&oi->ip_extent_map, cpos, &emi);
92         if (emi) {
93                 coff = cpos - emi->ei_cpos;
94                 *phys = emi->ei_phys + coff;
95                 if (len)
96                         *len = emi->ei_clusters - coff;
97                 if (flags)
98                         *flags = emi->ei_flags;
99         }
100
101         spin_unlock(&oi->ip_lock);
102
103         if (emi == NULL)
104                 return -ENOENT;
105
106         return 0;
107 }
108
109 /*
110  * Forget about all clusters equal to or greater than cpos.
111  */
112 void ocfs2_extent_map_trunc(struct inode *inode, unsigned int cpos)
113 {
114         struct ocfs2_extent_map_item *emi, *n;
115         struct ocfs2_inode_info *oi = OCFS2_I(inode);
116         struct ocfs2_extent_map *em = &oi->ip_extent_map;
117         LIST_HEAD(tmp_list);
118         unsigned int range;
119
120         spin_lock(&oi->ip_lock);
121         list_for_each_entry_safe(emi, n, &em->em_list, ei_list) {
122                 if (emi->ei_cpos >= cpos) {
123                         /* Full truncate of this record. */
124                         list_move(&emi->ei_list, &tmp_list);
125                         BUG_ON(em->em_num_items == 0);
126                         em->em_num_items--;
127                         continue;
128                 }
129
130                 range = emi->ei_cpos + emi->ei_clusters;
131                 if (range > cpos) {
132                         /* Partial truncate */
133                         emi->ei_clusters = cpos - emi->ei_cpos;
134                 }
135         }
136         spin_unlock(&oi->ip_lock);
137
138         list_for_each_entry_safe(emi, n, &tmp_list, ei_list) {
139                 list_del(&emi->ei_list);
140                 kfree(emi);
141         }
142 }
143
144 /*
145  * Is any part of emi2 contained within emi1
146  */
147 static int ocfs2_ei_is_contained(struct ocfs2_extent_map_item *emi1,
148                                  struct ocfs2_extent_map_item *emi2)
149 {
150         unsigned int range1, range2;
151
152         /*
153          * Check if logical start of emi2 is inside emi1
154          */
155         range1 = emi1->ei_cpos + emi1->ei_clusters;
156         if (emi2->ei_cpos >= emi1->ei_cpos && emi2->ei_cpos < range1)
157                 return 1;
158
159         /*
160          * Check if logical end of emi2 is inside emi1
161          */
162         range2 = emi2->ei_cpos + emi2->ei_clusters;
163         if (range2 > emi1->ei_cpos && range2 <= range1)
164                 return 1;
165
166         return 0;
167 }
168
169 static void ocfs2_copy_emi_fields(struct ocfs2_extent_map_item *dest,
170                                   struct ocfs2_extent_map_item *src)
171 {
172         dest->ei_cpos = src->ei_cpos;
173         dest->ei_phys = src->ei_phys;
174         dest->ei_clusters = src->ei_clusters;
175         dest->ei_flags = src->ei_flags;
176 }
177
178 /*
179  * Try to merge emi with ins. Returns 1 if merge succeeds, zero
180  * otherwise.
181  */
182 static int ocfs2_try_to_merge_extent_map(struct ocfs2_extent_map_item *emi,
183                                          struct ocfs2_extent_map_item *ins)
184 {
185         /*
186          * Handle contiguousness
187          */
188         if (ins->ei_phys == (emi->ei_phys + emi->ei_clusters) &&
189             ins->ei_cpos == (emi->ei_cpos + emi->ei_clusters) &&
190             ins->ei_flags == emi->ei_flags) {
191                 emi->ei_clusters += ins->ei_clusters;
192                 return 1;
193         } else if ((ins->ei_phys + ins->ei_clusters) == emi->ei_phys &&
194                    (ins->ei_cpos + ins->ei_clusters) == emi->ei_phys &&
195                    ins->ei_flags == emi->ei_flags) {
196                 emi->ei_phys = ins->ei_phys;
197                 emi->ei_cpos = ins->ei_cpos;
198                 emi->ei_clusters += ins->ei_clusters;
199                 return 1;
200         }
201
202         /*
203          * Overlapping extents - this shouldn't happen unless we've
204          * split an extent to change it's flags. That is exceedingly
205          * rare, so there's no sense in trying to optimize it yet.
206          */
207         if (ocfs2_ei_is_contained(emi, ins) ||
208             ocfs2_ei_is_contained(ins, emi)) {
209                 ocfs2_copy_emi_fields(emi, ins);
210                 return 1;
211         }
212
213         /* No merge was possible. */
214         return 0;
215 }
216
217 /*
218  * In order to reduce complexity on the caller, this insert function
219  * is intentionally liberal in what it will accept.
220  *
221  * The only rule is that the truncate call *must* be used whenever
222  * records have been deleted. This avoids inserting overlapping
223  * records with different physical mappings.
224  */
225 void ocfs2_extent_map_insert_rec(struct inode *inode,
226                                  struct ocfs2_extent_rec *rec)
227 {
228         struct ocfs2_inode_info *oi = OCFS2_I(inode);
229         struct ocfs2_extent_map *em = &oi->ip_extent_map;
230         struct ocfs2_extent_map_item *emi, *new_emi = NULL;
231         struct ocfs2_extent_map_item ins;
232
233         ins.ei_cpos = le32_to_cpu(rec->e_cpos);
234         ins.ei_phys = ocfs2_blocks_to_clusters(inode->i_sb,
235                                                le64_to_cpu(rec->e_blkno));
236         ins.ei_clusters = le16_to_cpu(rec->e_leaf_clusters);
237         ins.ei_flags = rec->e_flags;
238
239 search:
240         spin_lock(&oi->ip_lock);
241
242         list_for_each_entry(emi, &em->em_list, ei_list) {
243                 if (ocfs2_try_to_merge_extent_map(emi, &ins)) {
244                         list_move(&emi->ei_list, &em->em_list);
245                         spin_unlock(&oi->ip_lock);
246                         goto out;
247                 }
248         }
249
250         /*
251          * No item could be merged.
252          *
253          * Either allocate and add a new item, or overwrite the last recently
254          * inserted.
255          */
256
257         if (em->em_num_items < OCFS2_MAX_EXTENT_MAP_ITEMS) {
258                 if (new_emi == NULL) {
259                         spin_unlock(&oi->ip_lock);
260
261                         new_emi = kmalloc(sizeof(*new_emi), GFP_NOFS);
262                         if (new_emi == NULL)
263                                 goto out;
264
265                         goto search;
266                 }
267
268                 ocfs2_copy_emi_fields(new_emi, &ins);
269                 list_add(&new_emi->ei_list, &em->em_list);
270                 em->em_num_items++;
271                 new_emi = NULL;
272         } else {
273                 BUG_ON(list_empty(&em->em_list) || em->em_num_items == 0);
274                 emi = list_entry(em->em_list.prev,
275                                  struct ocfs2_extent_map_item, ei_list);
276                 list_move(&emi->ei_list, &em->em_list);
277                 ocfs2_copy_emi_fields(emi, &ins);
278         }
279
280         spin_unlock(&oi->ip_lock);
281
282 out:
283         if (new_emi)
284                 kfree(new_emi);
285 }
286
287 static int ocfs2_last_eb_is_empty(struct inode *inode,
288                                   struct ocfs2_dinode *di)
289 {
290         int ret, next_free;
291         u64 last_eb_blk = le64_to_cpu(di->i_last_eb_blk);
292         struct buffer_head *eb_bh = NULL;
293         struct ocfs2_extent_block *eb;
294         struct ocfs2_extent_list *el;
295
296         ret = ocfs2_read_extent_block(INODE_CACHE(inode), last_eb_blk, &eb_bh);
297         if (ret) {
298                 mlog_errno(ret);
299                 goto out;
300         }
301
302         eb = (struct ocfs2_extent_block *) eb_bh->b_data;
303         el = &eb->h_list;
304
305         if (el->l_tree_depth) {
306                 ocfs2_error(inode->i_sb,
307                             "Inode %lu has non zero tree depth in "
308                             "leaf block %llu\n", inode->i_ino,
309                             (unsigned long long)eb_bh->b_blocknr);
310                 ret = -EROFS;
311                 goto out;
312         }
313
314         next_free = le16_to_cpu(el->l_next_free_rec);
315
316         if (next_free == 0 ||
317             (next_free == 1 && ocfs2_is_empty_extent(&el->l_recs[0])))
318                 ret = 1;
319
320 out:
321         brelse(eb_bh);
322         return ret;
323 }
324
325 /*
326  * Return the 1st index within el which contains an extent start
327  * larger than v_cluster.
328  */
329 static int ocfs2_search_for_hole_index(struct ocfs2_extent_list *el,
330                                        u32 v_cluster)
331 {
332         int i;
333         struct ocfs2_extent_rec *rec;
334
335         for(i = 0; i < le16_to_cpu(el->l_next_free_rec); i++) {
336                 rec = &el->l_recs[i];
337
338                 if (v_cluster < le32_to_cpu(rec->e_cpos))
339                         break;
340         }
341
342         return i;
343 }
344
345 /*
346  * Figure out the size of a hole which starts at v_cluster within the given
347  * extent list.
348  *
349  * If there is no more allocation past v_cluster, we return the maximum
350  * cluster size minus v_cluster.
351  *
352  * If we have in-inode extents, then el points to the dinode list and
353  * eb_bh is NULL. Otherwise, eb_bh should point to the extent block
354  * containing el.
355  */
356 int ocfs2_figure_hole_clusters(struct ocfs2_caching_info *ci,
357                                struct ocfs2_extent_list *el,
358                                struct buffer_head *eb_bh,
359                                u32 v_cluster,
360                                u32 *num_clusters)
361 {
362         int ret, i;
363         struct buffer_head *next_eb_bh = NULL;
364         struct ocfs2_extent_block *eb, *next_eb;
365
366         i = ocfs2_search_for_hole_index(el, v_cluster);
367
368         if (i == le16_to_cpu(el->l_next_free_rec) && eb_bh) {
369                 eb = (struct ocfs2_extent_block *)eb_bh->b_data;
370
371                 /*
372                  * Check the next leaf for any extents.
373                  */
374
375                 if (le64_to_cpu(eb->h_next_leaf_blk) == 0ULL)
376                         goto no_more_extents;
377
378                 ret = ocfs2_read_extent_block(ci,
379                                               le64_to_cpu(eb->h_next_leaf_blk),
380                                               &next_eb_bh);
381                 if (ret) {
382                         mlog_errno(ret);
383                         goto out;
384                 }
385
386                 next_eb = (struct ocfs2_extent_block *)next_eb_bh->b_data;
387                 el = &next_eb->h_list;
388                 i = ocfs2_search_for_hole_index(el, v_cluster);
389         }
390
391 no_more_extents:
392         if (i == le16_to_cpu(el->l_next_free_rec)) {
393                 /*
394                  * We're at the end of our existing allocation. Just
395                  * return the maximum number of clusters we could
396                  * possibly allocate.
397                  */
398                 *num_clusters = UINT_MAX - v_cluster;
399         } else {
400                 *num_clusters = le32_to_cpu(el->l_recs[i].e_cpos) - v_cluster;
401         }
402
403         ret = 0;
404 out:
405         brelse(next_eb_bh);
406         return ret;
407 }
408
409 static int ocfs2_get_clusters_nocache(struct inode *inode,
410                                       struct buffer_head *di_bh,
411                                       u32 v_cluster, unsigned int *hole_len,
412                                       struct ocfs2_extent_rec *ret_rec,
413                                       unsigned int *is_last)
414 {
415         int i, ret, tree_height, len;
416         struct ocfs2_dinode *di;
417         struct ocfs2_extent_block *uninitialized_var(eb);
418         struct ocfs2_extent_list *el;
419         struct ocfs2_extent_rec *rec;
420         struct buffer_head *eb_bh = NULL;
421
422         memset(ret_rec, 0, sizeof(*ret_rec));
423         if (is_last)
424                 *is_last = 0;
425
426         di = (struct ocfs2_dinode *) di_bh->b_data;
427         el = &di->id2.i_list;
428         tree_height = le16_to_cpu(el->l_tree_depth);
429
430         if (tree_height > 0) {
431                 ret = ocfs2_find_leaf(INODE_CACHE(inode), el, v_cluster,
432                                       &eb_bh);
433                 if (ret) {
434                         mlog_errno(ret);
435                         goto out;
436                 }
437
438                 eb = (struct ocfs2_extent_block *) eb_bh->b_data;
439                 el = &eb->h_list;
440
441                 if (el->l_tree_depth) {
442                         ocfs2_error(inode->i_sb,
443                                     "Inode %lu has non zero tree depth in "
444                                     "leaf block %llu\n", inode->i_ino,
445                                     (unsigned long long)eb_bh->b_blocknr);
446                         ret = -EROFS;
447                         goto out;
448                 }
449         }
450
451         i = ocfs2_search_extent_list(el, v_cluster);
452         if (i == -1) {
453                 /*
454                  * Holes can be larger than the maximum size of an
455                  * extent, so we return their lengths in a seperate
456                  * field.
457                  */
458                 if (hole_len) {
459                         ret = ocfs2_figure_hole_clusters(INODE_CACHE(inode),
460                                                          el, eb_bh,
461                                                          v_cluster, &len);
462                         if (ret) {
463                                 mlog_errno(ret);
464                                 goto out;
465                         }
466
467                         *hole_len = len;
468                 }
469                 goto out_hole;
470         }
471
472         rec = &el->l_recs[i];
473
474         BUG_ON(v_cluster < le32_to_cpu(rec->e_cpos));
475
476         if (!rec->e_blkno) {
477                 ocfs2_error(inode->i_sb, "Inode %lu has bad extent "
478                             "record (%u, %u, 0)", inode->i_ino,
479                             le32_to_cpu(rec->e_cpos),
480                             ocfs2_rec_clusters(el, rec));
481                 ret = -EROFS;
482                 goto out;
483         }
484
485         *ret_rec = *rec;
486
487         /*
488          * Checking for last extent is potentially expensive - we
489          * might have to look at the next leaf over to see if it's
490          * empty.
491          *
492          * The first two checks are to see whether the caller even
493          * cares for this information, and if the extent is at least
494          * the last in it's list.
495          *
496          * If those hold true, then the extent is last if any of the
497          * additional conditions hold true:
498          *  - Extent list is in-inode
499          *  - Extent list is right-most
500          *  - Extent list is 2nd to rightmost, with empty right-most
501          */
502         if (is_last) {
503                 if (i == (le16_to_cpu(el->l_next_free_rec) - 1)) {
504                         if (tree_height == 0)
505                                 *is_last = 1;
506                         else if (eb->h_blkno == di->i_last_eb_blk)
507                                 *is_last = 1;
508                         else if (eb->h_next_leaf_blk == di->i_last_eb_blk) {
509                                 ret = ocfs2_last_eb_is_empty(inode, di);
510                                 if (ret < 0) {
511                                         mlog_errno(ret);
512                                         goto out;
513                                 }
514                                 if (ret == 1)
515                                         *is_last = 1;
516                         }
517                 }
518         }
519
520 out_hole:
521         ret = 0;
522 out:
523         brelse(eb_bh);
524         return ret;
525 }
526
527 static void ocfs2_relative_extent_offsets(struct super_block *sb,
528                                           u32 v_cluster,
529                                           struct ocfs2_extent_rec *rec,
530                                           u32 *p_cluster, u32 *num_clusters)
531
532 {
533         u32 coff = v_cluster - le32_to_cpu(rec->e_cpos);
534
535         *p_cluster = ocfs2_blocks_to_clusters(sb, le64_to_cpu(rec->e_blkno));
536         *p_cluster = *p_cluster + coff;
537
538         if (num_clusters)
539                 *num_clusters = le16_to_cpu(rec->e_leaf_clusters) - coff;
540 }
541
542 int ocfs2_xattr_get_clusters(struct inode *inode, u32 v_cluster,
543                              u32 *p_cluster, u32 *num_clusters,
544                              struct ocfs2_extent_list *el)
545 {
546         int ret = 0, i;
547         struct buffer_head *eb_bh = NULL;
548         struct ocfs2_extent_block *eb;
549         struct ocfs2_extent_rec *rec;
550         u32 coff;
551
552         if (el->l_tree_depth) {
553                 ret = ocfs2_find_leaf(INODE_CACHE(inode), el, v_cluster,
554                                       &eb_bh);
555                 if (ret) {
556                         mlog_errno(ret);
557                         goto out;
558                 }
559
560                 eb = (struct ocfs2_extent_block *) eb_bh->b_data;
561                 el = &eb->h_list;
562
563                 if (el->l_tree_depth) {
564                         ocfs2_error(inode->i_sb,
565                                     "Inode %lu has non zero tree depth in "
566                                     "xattr leaf block %llu\n", inode->i_ino,
567                                     (unsigned long long)eb_bh->b_blocknr);
568                         ret = -EROFS;
569                         goto out;
570                 }
571         }
572
573         i = ocfs2_search_extent_list(el, v_cluster);
574         if (i == -1) {
575                 ret = -EROFS;
576                 mlog_errno(ret);
577                 goto out;
578         } else {
579                 rec = &el->l_recs[i];
580                 BUG_ON(v_cluster < le32_to_cpu(rec->e_cpos));
581
582                 if (!rec->e_blkno) {
583                         ocfs2_error(inode->i_sb, "Inode %lu has bad extent "
584                                     "record (%u, %u, 0) in xattr", inode->i_ino,
585                                     le32_to_cpu(rec->e_cpos),
586                                     ocfs2_rec_clusters(el, rec));
587                         ret = -EROFS;
588                         goto out;
589                 }
590                 coff = v_cluster - le32_to_cpu(rec->e_cpos);
591                 *p_cluster = ocfs2_blocks_to_clusters(inode->i_sb,
592                                                     le64_to_cpu(rec->e_blkno));
593                 *p_cluster = *p_cluster + coff;
594                 if (num_clusters)
595                         *num_clusters = ocfs2_rec_clusters(el, rec) - coff;
596         }
597 out:
598         if (eb_bh)
599                 brelse(eb_bh);
600         return ret;
601 }
602
603 int ocfs2_get_clusters(struct inode *inode, u32 v_cluster,
604                        u32 *p_cluster, u32 *num_clusters,
605                        unsigned int *extent_flags)
606 {
607         int ret;
608         unsigned int uninitialized_var(hole_len), flags = 0;
609         struct buffer_head *di_bh = NULL;
610         struct ocfs2_extent_rec rec;
611
612         if (OCFS2_I(inode)->ip_dyn_features & OCFS2_INLINE_DATA_FL) {
613                 ret = -ERANGE;
614                 mlog_errno(ret);
615                 goto out;
616         }
617
618         ret = ocfs2_extent_map_lookup(inode, v_cluster, p_cluster,
619                                       num_clusters, extent_flags);
620         if (ret == 0)
621                 goto out;
622
623         ret = ocfs2_read_inode_block(inode, &di_bh);
624         if (ret) {
625                 mlog_errno(ret);
626                 goto out;
627         }
628
629         ret = ocfs2_get_clusters_nocache(inode, di_bh, v_cluster, &hole_len,
630                                          &rec, NULL);
631         if (ret) {
632                 mlog_errno(ret);
633                 goto out;
634         }
635
636         if (rec.e_blkno == 0ULL) {
637                 /*
638                  * A hole was found. Return some canned values that
639                  * callers can key on. If asked for, num_clusters will
640                  * be populated with the size of the hole.
641                  */
642                 *p_cluster = 0;
643                 if (num_clusters) {
644                         *num_clusters = hole_len;
645                 }
646         } else {
647                 ocfs2_relative_extent_offsets(inode->i_sb, v_cluster, &rec,
648                                               p_cluster, num_clusters);
649                 flags = rec.e_flags;
650
651                 ocfs2_extent_map_insert_rec(inode, &rec);
652         }
653
654         if (extent_flags)
655                 *extent_flags = flags;
656
657 out:
658         brelse(di_bh);
659         return ret;
660 }
661
662 /*
663  * This expects alloc_sem to be held. The allocation cannot change at
664  * all while the map is in the process of being updated.
665  */
666 int ocfs2_extent_map_get_blocks(struct inode *inode, u64 v_blkno, u64 *p_blkno,
667                                 u64 *ret_count, unsigned int *extent_flags)
668 {
669         int ret;
670         int bpc = ocfs2_clusters_to_blocks(inode->i_sb, 1);
671         u32 cpos, num_clusters, p_cluster;
672         u64 boff = 0;
673
674         cpos = ocfs2_blocks_to_clusters(inode->i_sb, v_blkno);
675
676         ret = ocfs2_get_clusters(inode, cpos, &p_cluster, &num_clusters,
677                                  extent_flags);
678         if (ret) {
679                 mlog_errno(ret);
680                 goto out;
681         }
682
683         /*
684          * p_cluster == 0 indicates a hole.
685          */
686         if (p_cluster) {
687                 boff = ocfs2_clusters_to_blocks(inode->i_sb, p_cluster);
688                 boff += (v_blkno & (u64)(bpc - 1));
689         }
690
691         *p_blkno = boff;
692
693         if (ret_count) {
694                 *ret_count = ocfs2_clusters_to_blocks(inode->i_sb, num_clusters);
695                 *ret_count -= v_blkno & (u64)(bpc - 1);
696         }
697
698 out:
699         return ret;
700 }
701
702 static int ocfs2_fiemap_inline(struct inode *inode, struct buffer_head *di_bh,
703                                struct fiemap_extent_info *fieinfo,
704                                u64 map_start)
705 {
706         int ret;
707         unsigned int id_count;
708         struct ocfs2_dinode *di;
709         u64 phys;
710         u32 flags = FIEMAP_EXTENT_DATA_INLINE|FIEMAP_EXTENT_LAST;
711         struct ocfs2_inode_info *oi = OCFS2_I(inode);
712
713         di = (struct ocfs2_dinode *)di_bh->b_data;
714         id_count = le16_to_cpu(di->id2.i_data.id_count);
715
716         if (map_start < id_count) {
717                 phys = oi->ip_blkno << inode->i_sb->s_blocksize_bits;
718                 phys += offsetof(struct ocfs2_dinode, id2.i_data.id_data);
719
720                 ret = fiemap_fill_next_extent(fieinfo, 0, phys, id_count,
721                                               flags);
722                 if (ret < 0)
723                         return ret;
724         }
725
726         return 0;
727 }
728
729 #define OCFS2_FIEMAP_FLAGS      (FIEMAP_FLAG_SYNC)
730
731 int ocfs2_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,
732                  u64 map_start, u64 map_len)
733 {
734         int ret, is_last;
735         u32 mapping_end, cpos;
736         unsigned int hole_size;
737         struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
738         u64 len_bytes, phys_bytes, virt_bytes;
739         struct buffer_head *di_bh = NULL;
740         struct ocfs2_extent_rec rec;
741
742         ret = fiemap_check_flags(fieinfo, OCFS2_FIEMAP_FLAGS);
743         if (ret)
744                 return ret;
745
746         ret = ocfs2_inode_lock(inode, &di_bh, 0);
747         if (ret) {
748                 mlog_errno(ret);
749                 goto out;
750         }
751
752         down_read(&OCFS2_I(inode)->ip_alloc_sem);
753
754         /*
755          * Handle inline-data separately.
756          */
757         if (OCFS2_I(inode)->ip_dyn_features & OCFS2_INLINE_DATA_FL) {
758                 ret = ocfs2_fiemap_inline(inode, di_bh, fieinfo, map_start);
759                 goto out_unlock;
760         }
761
762         cpos = map_start >> osb->s_clustersize_bits;
763         mapping_end = ocfs2_clusters_for_bytes(inode->i_sb,
764                                                map_start + map_len);
765         mapping_end -= cpos;
766         is_last = 0;
767         while (cpos < mapping_end && !is_last) {
768                 u32 fe_flags;
769
770                 ret = ocfs2_get_clusters_nocache(inode, di_bh, cpos,
771                                                  &hole_size, &rec, &is_last);
772                 if (ret) {
773                         mlog_errno(ret);
774                         goto out;
775                 }
776
777                 if (rec.e_blkno == 0ULL) {
778                         cpos += hole_size;
779                         continue;
780                 }
781
782                 fe_flags = 0;
783                 if (rec.e_flags & OCFS2_EXT_UNWRITTEN)
784                         fe_flags |= FIEMAP_EXTENT_UNWRITTEN;
785                 if (is_last)
786                         fe_flags |= FIEMAP_EXTENT_LAST;
787                 len_bytes = (u64)le16_to_cpu(rec.e_leaf_clusters) << osb->s_clustersize_bits;
788                 phys_bytes = le64_to_cpu(rec.e_blkno) << osb->sb->s_blocksize_bits;
789                 virt_bytes = (u64)le32_to_cpu(rec.e_cpos) << osb->s_clustersize_bits;
790
791                 ret = fiemap_fill_next_extent(fieinfo, virt_bytes, phys_bytes,
792                                               len_bytes, fe_flags);
793                 if (ret)
794                         break;
795
796                 cpos = le32_to_cpu(rec.e_cpos)+ le16_to_cpu(rec.e_leaf_clusters);
797         }
798
799         if (ret > 0)
800                 ret = 0;
801
802 out_unlock:
803         brelse(di_bh);
804
805         up_read(&OCFS2_I(inode)->ip_alloc_sem);
806
807         ocfs2_inode_unlock(inode, 0);
808 out:
809
810         return ret;
811 }
812
813 int ocfs2_read_virt_blocks(struct inode *inode, u64 v_block, int nr,
814                            struct buffer_head *bhs[], int flags,
815                            int (*validate)(struct super_block *sb,
816                                            struct buffer_head *bh))
817 {
818         int rc = 0;
819         u64 p_block, p_count;
820         int i, count, done = 0;
821
822         mlog_entry("(inode = %p, v_block = %llu, nr = %d, bhs = %p, "
823                    "flags = %x, validate = %p)\n",
824                    inode, (unsigned long long)v_block, nr, bhs, flags,
825                    validate);
826
827         if (((v_block + nr - 1) << inode->i_sb->s_blocksize_bits) >=
828             i_size_read(inode)) {
829                 BUG_ON(!(flags & OCFS2_BH_READAHEAD));
830                 goto out;
831         }
832
833         while (done < nr) {
834                 down_read(&OCFS2_I(inode)->ip_alloc_sem);
835                 rc = ocfs2_extent_map_get_blocks(inode, v_block + done,
836                                                  &p_block, &p_count, NULL);
837                 up_read(&OCFS2_I(inode)->ip_alloc_sem);
838                 if (rc) {
839                         mlog_errno(rc);
840                         break;
841                 }
842
843                 if (!p_block) {
844                         rc = -EIO;
845                         mlog(ML_ERROR,
846                              "Inode #%llu contains a hole at offset %llu\n",
847                              (unsigned long long)OCFS2_I(inode)->ip_blkno,
848                              (unsigned long long)(v_block + done) <<
849                              inode->i_sb->s_blocksize_bits);
850                         break;
851                 }
852
853                 count = nr - done;
854                 if (p_count < count)
855                         count = p_count;
856
857                 /*
858                  * If the caller passed us bhs, they should have come
859                  * from a previous readahead call to this function.  Thus,
860                  * they should have the right b_blocknr.
861                  */
862                 for (i = 0; i < count; i++) {
863                         if (!bhs[done + i])
864                                 continue;
865                         BUG_ON(bhs[done + i]->b_blocknr != (p_block + i));
866                 }
867
868                 rc = ocfs2_read_blocks(INODE_CACHE(inode), p_block, count,
869                                        bhs + done, flags, validate);
870                 if (rc) {
871                         mlog_errno(rc);
872                         break;
873                 }
874                 done += count;
875         }
876
877 out:
878         mlog_exit(rc);
879         return rc;
880 }
881
882