Line data    Source code

       1             : #ifndef __UTIL_H__
       2             : #define __UTIL_H__
       3             : 
       4             : #include <sys/stat.h>
       5             : 
       6             : #include "fsck.h"
       7             : #include "libgfs2.h"
       8             : 
       9             : #define INODE_VALID 1
      10             : #define INODE_INVALID 0
      11             : 
      12             : struct di_info *search_list(osi_list_t *list, uint64_t addr);
      13             : void big_file_comfort(struct fsck_cx *cx, struct lgfs2_inode *ip, uint64_t blks_checked);
      14             : void display_progress(uint64_t block);
      15             : int add_duplicate_ref(struct fsck_cx *cx, struct lgfs2_inode *ip, uint64_t block,
      16             :                       enum dup_ref_type reftype, int first, int inode_valid);
      17             : extern struct inode_with_dups *find_dup_ref_inode(struct duptree *dt,
      18             :                                                   struct lgfs2_inode *ip);
      19             : extern void dup_listent_delete(struct duptree *dt, struct inode_with_dups *id);
      20             : extern int count_dup_meta_refs(struct duptree *dt);
      21             : extern const char *reftypes[REF_TYPES + 1];
      22             : 
      23             : #define BLOCKMAP_SIZE1(size) ((size) >> 3)
      24             : #define BLOCKMAP_SIZE2(size) ((size) >> 2)
      25             : #define BLOCKMAP_BYTE_OFFSET2(x) ((x & 0x0000000000000003) << 1)
      26             : #define BLOCKMAP_BYTE_OFFSET1(x) (x & 0x0000000000000007)
      27             : #define BLOCKMAP_MASK2 (0x3)
      28             : #define BLOCKMAP_MASK1 (1)
      29             : 
      30             : struct fsck_pass {
      31             :         const char *name;
      32             :         int (*f)(struct fsck_cx *cx);
      33             : };
      34             : 
      35   481431714 : static inline int block_type(struct bmap *bl, uint64_t bblock)
      36             : {
      37             :         static unsigned char *byte;
      38             :         static uint64_t b;
      39             :         static int btype;
      40             : 
      41   481431714 :         byte = bl->map + BLOCKMAP_SIZE2(bblock);
      42   481431714 :         b = BLOCKMAP_BYTE_OFFSET2(bblock);
      43   481431714 :         btype = (*byte & (BLOCKMAP_MASK2 << b )) >> b;
      44   481431714 :         return btype;
      45             : }
      46             : 
      47   477639942 : static inline int link1_type(struct bmap *bl, uint64_t bblock)
      48             : {
      49             :         static unsigned char *byte;
      50             :         static uint64_t b;
      51             :         static int btype;
      52             : 
      53   477639942 :         byte = bl->map + BLOCKMAP_SIZE1(bblock);
      54   477639942 :         b = BLOCKMAP_BYTE_OFFSET1(bblock);
      55   477639942 :         btype = (*byte & (BLOCKMAP_MASK1 << b )) >> b;
      56   477639942 :         return btype;
      57             : }
      58             : 
      59         112 : static inline void link1_destroy(struct bmap *bmap)
      60             : {
      61         112 :         if (bmap->map)
      62         112 :                 free(bmap->map);
      63         112 :         bmap->size = 0;
      64         112 :         bmap->mapsize = 0;
      65         112 : }
      66             : 
      67        1372 : static inline int bitmap_type(struct lgfs2_sbd *sdp, uint64_t bblock)
      68             : {
      69             :         struct lgfs2_rgrp_tree *rgd;
      70             : 
      71        1372 :         rgd = lgfs2_blk2rgrpd(sdp, bblock);
      72        1372 :         return lgfs2_get_bitmap(sdp, bblock, rgd);
      73             : }
      74             : 
      75       65668 : static const inline char *block_type_string(int q)
      76             : {
      77       65668 :         const char *blktyp[] = {"free", "data", "other", "inode", "invalid"};
      78       65668 :         if (q >= GFS2_BLKST_FREE && q <= GFS2_BLKST_DINODE)
      79       65668 :                 return (blktyp[q]);
      80           0 :         return blktyp[4];
      81             : }
      82             : 
      83       11559 : static inline int is_dir(struct lgfs2_inode *ip)
      84             : {
      85       11559 :         return S_ISDIR(ip->i_mode);
      86             : }
      87             : 
      88             : extern enum dup_ref_type get_ref_type(struct inode_with_dups *id);
      89             : extern char generic_interrupt(const char *caller, const char *where,
      90             :                        const char *progress, const char *question,
      91             :                        const char *answers);
      92             : extern char fsck_getch(void);
      93             : extern uint64_t find_free_blk(struct lgfs2_sbd *sdp);
      94             : extern __be64 *get_dir_hash(struct lgfs2_inode *ip);
      95             : extern void delete_all_dups(struct fsck_cx *cx, struct lgfs2_inode *ip);
      96             : extern void print_pass_duration(const char *name, struct timeval *start);
      97             : 
      98             : #define stack log_debug("<backtrace> - %s()\n", __func__)
      99             : 
     100             : #endif /* __UTIL_H__ */