Ticket #13513: 0001-Code-refactoring.3.patch

File 0001-Code-refactoring.3.patch, 66.5 KB (added by hyche, 3 years ago)
  • src/add-ons/kernel/file_systems/btrfs/Attribute.cpp

    From 9a3a9ce21ba4e8f3f1513ac7e2a0506938cdddb6 Mon Sep 17 00:00:00 2001
    From: hyche <cvghy116@gmail.com>
    Date: Thu, 18 May 2017 19:52:06 +0700
    Subject: [PATCH] Code refactoring: * Fixed style violation * All system
     headers are in system_dependencies.h * Insert fs_shell headers if compiled
     with FS_SHELL
    
    ---
     .../kernel/file_systems/btrfs/Attribute.cpp        |  25 ++--
     src/add-ons/kernel/file_systems/btrfs/Attribute.h  |  47 ++++----
     .../file_systems/btrfs/AttributeIterator.cpp       |  10 +-
     .../kernel/file_systems/btrfs/AttributeIterator.h  |  20 ++--
     .../kernel/file_systems/btrfs/BPlusTree.cpp        |  32 +++---
     src/add-ons/kernel/file_systems/btrfs/BPlusTree.h  | 108 +++++++++---------
     src/add-ons/kernel/file_systems/btrfs/CRCTable.cpp |  68 +++++------
     src/add-ons/kernel/file_systems/btrfs/CRCTable.h   |   3 +-
     .../kernel/file_systems/btrfs/CachedBlock.h        |  33 +++---
     src/add-ons/kernel/file_systems/btrfs/Chunk.cpp    |   9 +-
     src/add-ons/kernel/file_systems/btrfs/Chunk.h      |  24 ++--
     .../file_systems/btrfs/DirectoryIterator.cpp       |  16 +--
     .../kernel/file_systems/btrfs/DirectoryIterator.h  |  18 +--
     src/add-ons/kernel/file_systems/btrfs/Inode.cpp    |  17 +--
     src/add-ons/kernel/file_systems/btrfs/Inode.h      | 126 +++++++++------------
     src/add-ons/kernel/file_systems/btrfs/Utility.h    |  17 +--
     src/add-ons/kernel/file_systems/btrfs/Volume.cpp   |  91 +++++++--------
     src/add-ons/kernel/file_systems/btrfs/Volume.h     |  92 ++++++++-------
     src/add-ons/kernel/file_systems/btrfs/btrfs.h      |  91 ++++++++-------
     .../kernel/file_systems/btrfs/crc_table.cpp        |  68 +++++------
     .../kernel/file_systems/btrfs/kernel_interface.cpp |  48 +++-----
     .../file_systems/btrfs/system_dependencies.h       |  44 +++++++
     22 files changed, 491 insertions(+), 516 deletions(-)
     create mode 100644 src/add-ons/kernel/file_systems/btrfs/system_dependencies.h
    
    diff --git a/src/add-ons/kernel/file_systems/btrfs/Attribute.cpp b/src/add-ons/kernel/file_systems/btrfs/Attribute.cpp
    index d6be6d3..0b72724 100644
    a b  
    99
    1010
    1111#include "Attribute.h"
    12 
    13 #include <new>
    14 #include <stdio.h>
    15 #include <stdlib.h>
    16 
    1712#include "BPlusTree.h"
    1813#include "CRCTable.h"
    1914#include "Utility.h"
    Attribute::Stat(struct stat& stat)  
    9287    TRACE("Stat\n");
    9388
    9489    size_t nameLength = strlen(fName);
    95     btrfs_dir_entry *entries;
     90    btrfs_dir_entry* entries;
    9691    size_t length;
    9792    status_t status = _Lookup(fName, nameLength, &entries, &length);
    9893    if (status < B_OK)
    9994        return status;
    10095
    101     btrfs_dir_entry *entry;
     96    btrfs_dir_entry* entry;
    10297    status = _FindEntry(entries, length, fName, nameLength, &entry);
    10398    if (status != B_OK) {
    10499        free(entries);
    Attribute::Read(attr_cookie* cookie, off_t pos, uint8* buffer, size_t* _length)  
    120115        return ERANGE;
    121116
    122117    size_t nameLength = strlen(fName);
    123     btrfs_dir_entry *entries;
     118    btrfs_dir_entry* entries;
    124119    size_t length;
    125120    status_t status = _Lookup(fName, nameLength, &entries, &length);
    126121    if (status < B_OK)
    127122        return status;
    128123
    129     btrfs_dir_entry *entry;
     124    btrfs_dir_entry* entry;
    130125    status = _FindEntry(entries, length, fName, nameLength, &entry);
    131126    if (status != B_OK) {
    132127        free(entries);
    Attribute::Read(attr_cookie* cookie, off_t pos, uint8* buffer, size_t* _length)  
    149144
    150145status_t
    151146Attribute::_Lookup(const char* name, size_t nameLength,
    152     btrfs_dir_entry **_entries, size_t *_length)
     147    btrfs_dir_entry** _entries, size_t* _length)
    153148{
    154149    uint32 hash = calculate_crc((uint32)~1, (uint8*)name, nameLength);
    155150    struct btrfs_key key;
    Attribute::_Lookup(const char* name, size_t nameLength,  
    157152    key.SetObjectID(fInode->ID());
    158153    key.SetOffset(hash);
    159154
    160     btrfs_dir_entry *entries;
     155    btrfs_dir_entry* entries;
    161156    size_t length;
    162157    status_t status = fInode->GetVolume()->FSTree()->FindExact(key,
    163158        (void**)&entries, &length);
    Attribute::_Lookup(const char* name, size_t nameLength,  
    180175
    181176
    182177status_t
    183 Attribute::_FindEntry(btrfs_dir_entry *entries, size_t length,
    184     const char* name, size_t nameLength, btrfs_dir_entry **_entry)
     178Attribute::_FindEntry(btrfs_dir_entry* entries, size_t length,
     179    const char* name, size_t nameLength, btrfs_dir_entry** _entry)
    185180{
    186     btrfs_dir_entry *entry = entries;
     181    btrfs_dir_entry* entry = entries;
    187182    uint16 current = 0;
    188183    while (current < length) {
    189184        current += entry->Length();
    190185        break;
    191186        // TODO there could be several entries with the same name hash
    192         entry = (btrfs_dir_entry *)((uint8*)entry + entry->Length());
     187        entry = (btrfs_dir_entry*)((uint8*)entry + entry->Length());
    193188    }
    194189   
    195190    *_entry = entry;
  • src/add-ons/kernel/file_systems/btrfs/Attribute.h

    diff --git a/src/add-ons/kernel/file_systems/btrfs/Attribute.h b/src/add-ons/kernel/file_systems/btrfs/Attribute.h
    index 892b71e..21c800a 100644
    a b struct attr_cookie {  
    2121
    2222class Attribute {
    2323public:
    24                                 Attribute(Inode* inode);
    25                                 Attribute(Inode* inode, attr_cookie* cookie);
    26                                 ~Attribute();
     24    Attribute(Inode* inode);
     25    Attribute(Inode* inode, attr_cookie* cookie);
     26    ~Attribute();
     27
     28    status_t    CheckAccess(const char* name, int openMode);
     29    status_t    Create(const char* name, type_code type,
     30                    int openMode, attr_cookie** _cookie);
     31    status_t    Open(const char* name, int openMode,
     32                    attr_cookie** _cookie);
     33    status_t    Stat(struct stat& stat);
     34    status_t    Read(attr_cookie* cookie, off_t pos, uint8* buffer, size_t* _length);
    2735
    28             status_t            CheckAccess(const char* name, int openMode);
    29 
    30             status_t            Create(const char* name, type_code type,
    31                                     int openMode, attr_cookie** _cookie);
    32             status_t            Open(const char* name, int openMode,
    33                                     attr_cookie** _cookie);
    34 
    35             status_t            Stat(struct stat& stat);
    36 
    37             status_t            Read(attr_cookie* cookie, off_t pos,
    38                                     uint8* buffer, size_t* _length);
    3936private:
    40             status_t            _Lookup(const char* name, size_t nameLength,
    41                                     btrfs_dir_entry **entries = NULL,
    42                                     size_t *length = NULL);
    43             status_t            _FindEntry(btrfs_dir_entry *entries,
    44                                     size_t length, const char* name,
    45                                     size_t nameLength,
    46                                     btrfs_dir_entry **_entry);
    47 
    48             ::Volume*           fVolume;
    49             Inode*              fInode;
    50             const char*         fName;
     37    status_t    _Lookup(const char* name, size_t nameLength,
     38                    btrfs_dir_entry** entries = NULL,
     39                    size_t* length = NULL);
     40    status_t    _FindEntry(btrfs_dir_entry* entries,
     41                    size_t length, const char* name,
     42                    size_t nameLength,
     43                    btrfs_dir_entry** _entry);
     44
     45    ::Volume*   fVolume;
     46    Inode*      fInode;
     47    const char* fName;
    5148};
    5249
    5350#endif  // ATTRIBUTE_H
  • src/add-ons/kernel/file_systems/btrfs/AttributeIterator.cpp

    diff --git a/src/add-ons/kernel/file_systems/btrfs/AttributeIterator.cpp b/src/add-ons/kernel/file_systems/btrfs/AttributeIterator.cpp
    index b668ca5..c5de386 100644
    a b  
    66
    77#include "AttributeIterator.h"
    88
    9 #include <new>
    10 #include <stdlib.h>
    11 
    12 
    139//#define TRACE_BTRFS
    1410#ifdef TRACE_BTRFS
    1511#   define TRACE(x...) dprintf("\33[34mbtrfs:\33[0m " x)
    status_t  
    5046AttributeIterator::GetNext(char* name, size_t* _nameLength)
    5147{
    5248    btrfs_key key;
    53     btrfs_dir_entry *entries;
     49    btrfs_dir_entry* entries;
    5450    size_t entries_length;
    5551    status_t status = fIterator->GetPreviousEntry(key, (void**)&entries,
    5652        &entries_length);
    5753    if (status != B_OK)
    5854        return status;
    5955
    60     btrfs_dir_entry *entry = entries;
     56    btrfs_dir_entry* entry = entries;
    6157    uint16 current = 0;
    6258    while (current < entries_length) {
    6359        current += entry->Length();
    6460        break;
    6561        // TODO there could be several entries with the same name hash
    66         entry = (btrfs_dir_entry *)((uint8*)entry + entry->Length());
     62        entry = (btrfs_dir_entry*)((uint8*)entry + entry->Length());
    6763    }
    6864
    6965    TRACE("DirectoryIterator::GetNext() entries_length %ld name_length %d\n",
  • src/add-ons/kernel/file_systems/btrfs/AttributeIterator.h

    diff --git a/src/add-ons/kernel/file_systems/btrfs/AttributeIterator.h b/src/add-ons/kernel/file_systems/btrfs/AttributeIterator.h
    index d1f60c5..bb44a8b 100644
    a b  
    22 * Copyright 2011, Jérôme Duval, korli@users.berlios.de.
    33 * This file may be used under the terms of the MIT License.
    44 */
     5
    56#ifndef ATTRIBUTEITERATOR_H
    67#define ATTRIBUTEITERATOR_H
    78
     
    910#include "BPlusTree.h"
    1011#include "Inode.h"
    1112
    12 
    1313class AttributeIterator {
    1414public:
    15                                 AttributeIterator(Inode* inode);
    16                                 ~AttributeIterator();
     15    AttributeIterator(Inode* inode);
     16    ~AttributeIterator();
     17
     18    status_t    InitCheck();
     19    status_t    GetNext(char* name, size_t* _nameLength);
     20    status_t    Rewind();
    1721
    18             status_t            InitCheck();
    1922
    20             status_t            GetNext(char* name, size_t* _nameLength);
    21             status_t            Rewind();
    2223private:
    23             uint64              fOffset;
    24             Inode*              fInode;
    25             TreeIterator*       fIterator;
     24    uint64  fOffset;
     25    Inode*  fInode;
     26    TreeIterator*   fIterator;
    2627};
    2728
    28 
    2929#endif  // ATTRIBUTEITERATOR_H
  • src/add-ons/kernel/file_systems/btrfs/BPlusTree.cpp

    diff --git a/src/add-ons/kernel/file_systems/btrfs/BPlusTree.cpp b/src/add-ons/kernel/file_systems/btrfs/BPlusTree.cpp
    index 1e28a5b..1a99fac 100644
    a b  
    99
    1010
    1111#include "BPlusTree.h"
    12 
    1312#include "CachedBlock.h"
    1413
    15 #include <stdlib.h>
    16 #include <string.h>
    17 #include <util/AutoLock.h>
    18 
    19 
    2014//#define TRACE_BTRFS
    2115#ifdef TRACE_BTRFS
    2216#   define TRACE(x...) dprintf("\33[34mbtrfs:\33[0m " x)
     
    2620#   define ERROR(x...) dprintf("\33[34mbtrfs:\33[0m " x)
    2721
    2822
    29 BPlusTree::BPlusTree(Volume* volume, struct btrfs_stream *stream)
     23BPlusTree::BPlusTree(Volume* volume, struct btrfs_stream* stream)
    3024    :
    3125    fStream(stream),
    3226    fRootBlock(0),
    BPlusTree::~BPlusTree()  
    6256
    6357
    6458int32
    65 BPlusTree::_CompareKeys(struct btrfs_key &key1, struct btrfs_key &key2)
     59BPlusTree::_CompareKeys(struct btrfs_key& key1, struct btrfs_key& key2)
    6660{
    6761    if (key1.ObjectID() > key2.ObjectID())
    6862        return 1;
    BPlusTree::_CompareKeys(struct btrfs_key &key1, struct btrfs_key &key2)  
    8680    It can also return other errors to indicate that something went wrong.
    8781*/
    8882status_t
    89 BPlusTree::_Find(struct btrfs_key &key, void** _value, size_t* _size,
     83BPlusTree::_Find(struct btrfs_key& key, void** _value, size_t* _size,
    9084    bplustree_traversing type)
    9185{
    9286    TRACE("Find() objectid %" B_PRId64 " type %d offset %" B_PRId64 " \n",
    9387        key.ObjectID(), key.Type(), key.Offset());
    94     btrfs_stream *stream = fStream;
     88    btrfs_stream* stream = fStream;
    9589    CachedBlock cached(fVolume);
    9690    fsblock_t physical;
    9791    if (stream == NULL) {
    BPlusTree::_Find(struct btrfs_key &key, void** _value, size_t* _size,  
    9993            ERROR("Find() unmapped block %" B_PRId64 "\n", fRootBlock);
    10094            return B_ERROR;
    10195        }
    102         stream = (btrfs_stream *)cached.SetTo(physical);
     96        stream = (btrfs_stream*)cached.SetTo(physical);
    10397    }
    10498
    10599    while (stream->header.Level() != 0) {
    BPlusTree::_Find(struct btrfs_key &key, void** _value, size_t* _size,  
    123117                stream->index[i - 1].BlockNum());
    124118            return B_ERROR;
    125119        }
    126         stream = (btrfs_stream *)cached.SetTo(physical);
     120        stream = (btrfs_stream*)cached.SetTo(physical);
    127121    }
    128122
    129123    uint32 i;
    BPlusTree::_Find(struct btrfs_key &key, void** _value, size_t* _size,  
    175169            if ((fVolume->BlockSize() - totalOffset % fVolume->BlockSize())
    176170                >= stream->entries[i].Size()) {
    177171                //If there is enough space for *_value
    178                 memcpy(*_value, ((uint8 *)cached.SetTo(physical
     172                memcpy(*_value, ((uint8*)cached.SetTo(physical
    179173                    + totalOffset / fVolume->BlockSize())
    180174                    + totalOffset % fVolume->BlockSize()),
    181175                    stream->entries[i].Size());
    BPlusTree::_Find(struct btrfs_key &key, void** _value, size_t* _size,  
    201195
    202196
    203197status_t
    204 BPlusTree::FindNext(struct btrfs_key &key, void** _value, size_t* _size)
     198BPlusTree::FindNext(struct btrfs_key& key, void** _value, size_t* _size)
    205199{
    206200    return _Find(key, _value, _size, BPLUSTREE_FORWARD);
    207201}
    208202
    209203
    210204status_t
    211 BPlusTree::FindPrevious(struct btrfs_key &key, void** _value, size_t* _size)
     205BPlusTree::FindPrevious(struct btrfs_key& key, void** _value, size_t* _size)
    212206{
    213207    return _Find(key, _value, _size, BPLUSTREE_BACKWARD);
    214208}
    215209
    216210
    217211status_t
    218 BPlusTree::FindExact(struct btrfs_key &key, void** _value, size_t* _size)
     212BPlusTree::FindExact(struct btrfs_key& key, void** _value, size_t* _size)
    219213{
    220214    return _Find(key, _value, _size, BPLUSTREE_EXACT);
    221215}
    BPlusTree::_RemoveIterator(TreeIterator* iterator)  
    240234//  #pragma mark -
    241235
    242236
    243 TreeIterator::TreeIterator(BPlusTree* tree, struct btrfs_key &key)
     237TreeIterator::TreeIterator(BPlusTree* tree, struct btrfs_key& key)
    244238    :
    245239    fTree(tree),
    246240    fCurrentKey(key)
    TreeIterator::~TreeIterator()  
    260254/*! Iterates through the tree in the specified direction.
    261255*/
    262256status_t
    263 TreeIterator::Traverse(bplustree_traversing direction, struct btrfs_key &key,
     257TreeIterator::Traverse(bplustree_traversing direction, struct btrfs_key& key,
    264258    void** value, size_t* size)
    265259{
    266260    if (fTree == NULL)
    TreeIterator::Traverse(bplustree_traversing direction, struct btrfs_key &key,  
    281275/*! just sets the current key in the iterator.
    282276*/
    283277status_t
    284 TreeIterator::Find(struct btrfs_key &key)
     278TreeIterator::Find(struct btrfs_key& key)
    285279{
    286280    if (fTree == NULL)
    287281        return B_INTERRUPTED;
  • src/add-ons/kernel/file_systems/btrfs/BPlusTree.h

    diff --git a/src/add-ons/kernel/file_systems/btrfs/BPlusTree.h b/src/add-ons/kernel/file_systems/btrfs/BPlusTree.h
    index fb051a0..8e6cf32 100644
    a b  
    88
    99
    1010#include "btrfs.h"
    11 
    12 #include <util/SinglyLinkedList.h>
    13 
    1411#include "Volume.h"
    1512
    1613
    17 #define BPLUSTREE_NULL          -1LL
    18 #define BPLUSTREE_FREE          -2LL
     14#define BPLUSTREE_NULL -1LL
     15#define BPLUSTREE_FREE -2LL
    1916
    2017
    2118enum bplustree_traversing {
    struct node_and_key {  
    4340
    4441class BPlusTree {
    4542public:
    46                                 BPlusTree(Volume* volume,
    47                                     struct btrfs_stream *stream);
    48                                 BPlusTree(Volume* volume,
    49                                     fsblock_t rootBlock);
    50                                 ~BPlusTree();
    51             status_t            FindExact(struct btrfs_key &key, void** value,
    52                                     size_t* size = NULL);
    53             status_t            FindNext(struct btrfs_key &key, void** value,
    54                                     size_t* size = NULL);
    55             status_t            FindPrevious(struct btrfs_key &key, void** value,
    56                                     size_t* size = NULL);
     43    BPlusTree(Volume* volume, struct btrfs_stream* stream);
     44    BPlusTree(Volume* volume, fsblock_t rootBlock);
     45    ~BPlusTree();
     46
     47    status_t    FindExact(struct btrfs_key& key, void** value,
     48                    size_t* size = NULL);
     49    status_t    FindNext(struct btrfs_key& key, void** value,
     50                    size_t* size = NULL);
     51    status_t    FindPrevious(struct btrfs_key& key, void** value,
     52                    size_t* size = NULL);
    5753
    5854private:
    59                                 BPlusTree(const BPlusTree& other);
    60                                 BPlusTree& operator=(const BPlusTree& other);
    61                                     // no implementation
    62 
    63             int32               _CompareKeys(struct btrfs_key &key1,
    64                                     struct btrfs_key &key2);
    65             status_t            _Find(struct btrfs_key &key, void** value,
    66                                     size_t* size, bplustree_traversing type);
    67             void                _AddIterator(TreeIterator* iterator);
    68             void                _RemoveIterator(TreeIterator* iterator);
     55    BPlusTree(const BPlusTree& other);
     56    BPlusTree& operator=(const BPlusTree& other);
     57            // no implementation
     58
     59    int32   _CompareKeys(struct btrfs_key& key1,
     60                struct btrfs_key& key2);
     61    status_t    _Find(struct btrfs_key& key, void** value,
     62                    size_t* size, bplustree_traversing type);
     63    void    _AddIterator(TreeIterator* iterator);
     64    void    _RemoveIterator(TreeIterator* iterator);
     65
     66
    6967private:
    70             friend class TreeIterator;
     68    friend class TreeIterator;
    7169
    72             struct btrfs_stream* fStream;
    73             fsblock_t           fRootBlock;
    74             Volume*             fVolume;
    75             mutex               fIteratorLock;
    76             SinglyLinkedList<TreeIterator> fIterators;
     70    struct btrfs_stream* fStream;
     71    fsblock_t   fRootBlock;
     72    Volume* fVolume;
     73    mutex   fIteratorLock;
     74    SinglyLinkedList<TreeIterator> fIterators;
    7775};
    7876
    7977
    8078class TreeIterator : public SinglyLinkedListLinkImpl<TreeIterator> {
    8179public:
    82                                 TreeIterator(BPlusTree* tree, struct btrfs_key &key);
    83                                 ~TreeIterator();
    84 
    85             status_t            Traverse(bplustree_traversing direction,
    86                                     struct btrfs_key &key, void** value,
    87                                     size_t *size = NULL);
    88             status_t            Find(struct btrfs_key &key);
    89 
    90             status_t            Rewind();
    91             status_t            GetNextEntry(struct btrfs_key &key, void** value,
    92                                     size_t *size = NULL);
    93             status_t            GetPreviousEntry(struct btrfs_key &key, void** value,
    94                                     size_t *size = NULL);
    95 
    96             BPlusTree*          Tree() const { return fTree; }
     80    TreeIterator(BPlusTree* tree, struct btrfs_key& key);
     81    ~TreeIterator();
     82
     83    status_t    Traverse(bplustree_traversing direction,
     84                    struct btrfs_key& key, void** value,
     85                    size_t* size = NULL);
     86    status_t    Find(struct btrfs_key& key);
     87    status_t    Rewind();
     88    status_t    GetNextEntry(struct btrfs_key& key, void** value,
     89                    size_t* size = NULL);
     90    status_t    GetPreviousEntry(struct btrfs_key& key, void** value,
     91                    size_t* size = NULL);
     92    BPlusTree*  Tree() const { return fTree; }
    9793
    9894private:
    99             friend class BPlusTree;
     95    friend class BPlusTree;
    10096
    101             // called by BPlusTree
    102             void                Stop();
     97    // called by BPlusTree
     98    void    Stop();
    10399
    104100private:
    105             BPlusTree*          fTree;
    106             struct btrfs_key    fCurrentKey;
     101    BPlusTree*  fTree;
     102    struct btrfs_key    fCurrentKey;
    107103};
    108104
    109105
    TreeIterator::Rewind()  
    117113    return B_OK;
    118114}
    119115
     116
    120117inline status_t
    121 TreeIterator::GetNextEntry(struct btrfs_key &key, void** value, size_t *size)
     118TreeIterator::GetNextEntry(struct btrfs_key& key, void** value, size_t* size)
    122119{
    123120    return Traverse(BPLUSTREE_FORWARD, key, value, size);
    124121}
    125122
     123
    126124inline status_t
    127 TreeIterator::GetPreviousEntry(struct btrfs_key &key, void** value,
    128     size_t *size)
     125TreeIterator::GetPreviousEntry(struct btrfs_key& key, void** value, size_t* size)
    129126{
    130127    return Traverse(BPLUSTREE_BACKWARD, key, value, size);
    131128}
    132129
    133130
    134 
    135131#endif  // B_PLUS_TREE_H
  • src/add-ons/kernel/file_systems/btrfs/CRCTable.cpp

    diff --git a/src/add-ons/kernel/file_systems/btrfs/CRCTable.cpp b/src/add-ons/kernel/file_systems/btrfs/CRCTable.cpp
    index 75f35e5..b621f75 100644
    a b  
    77 */
    88
    99
    10 #include <SupportDefs.h>
     10#include "system_dependencies.h"
    1111
    1212
    1313//! CRC 03667067501 table, as generated by crc_table.cpp
    1414static uint32 kCrcTable[256] = {
    15     0x00000000, 0xf26b8303, 0xe13b70f7, 0x1350f3f4, 0xc79a971f, 0x35f1141c, 0x26a1e7e8, 0xd4ca64eb,
    16     0x8ad958cf, 0x78b2dbcc, 0x6be22838, 0x9989ab3b, 0x4d43cfd0, 0xbf284cd3, 0xac78bf27, 0x5e133c24,
    17     0x105ec76f, 0xe235446c, 0xf165b798, 0x030e349b, 0xd7c45070, 0x25afd373, 0x36ff2087, 0xc494a384,
    18     0x9a879fa0, 0x68ec1ca3, 0x7bbcef57, 0x89d76c54, 0x5d1d08bf, 0xaf768bbc, 0xbc267848, 0x4e4dfb4b,
    19     0x20bd8ede, 0xd2d60ddd, 0xc186fe29, 0x33ed7d2a, 0xe72719c1, 0x154c9ac2, 0x061c6936, 0xf477ea35,
    20     0xaa64d611, 0x580f5512, 0x4b5fa6e6, 0xb93425e5, 0x6dfe410e, 0x9f95c20d, 0x8cc531f9, 0x7eaeb2fa,
    21     0x30e349b1, 0xc288cab2, 0xd1d83946, 0x23b3ba45, 0xf779deae, 0x05125dad, 0x1642ae59, 0xe4292d5a,
    22     0xba3a117e, 0x4851927d, 0x5b016189, 0xa96ae28a, 0x7da08661, 0x8fcb0562, 0x9c9bf696, 0x6ef07595,
    23     0x417b1dbc, 0xb3109ebf, 0xa0406d4b, 0x522bee48, 0x86e18aa3, 0x748a09a0, 0x67dafa54, 0x95b17957,
    24     0xcba24573, 0x39c9c670, 0x2a993584, 0xd8f2b687, 0x0c38d26c, 0xfe53516f, 0xed03a29b, 0x1f682198,
    25     0x5125dad3, 0xa34e59d0, 0xb01eaa24, 0x42752927, 0x96bf4dcc, 0x64d4cecf, 0x77843d3b, 0x85efbe38,
    26     0xdbfc821c, 0x2997011f, 0x3ac7f2eb, 0xc8ac71e8, 0x1c661503, 0xee0d9600, 0xfd5d65f4, 0x0f36e6f7,
    27     0x61c69362, 0x93ad1061, 0x80fde395, 0x72966096, 0xa65c047d, 0x5437877e, 0x4767748a, 0xb50cf789,
    28     0xeb1fcbad, 0x197448ae, 0x0a24bb5a, 0xf84f3859, 0x2c855cb2, 0xdeeedfb1, 0xcdbe2c45, 0x3fd5af46,
    29     0x7198540d, 0x83f3d70e, 0x90a324fa, 0x62c8a7f9, 0xb602c312, 0x44694011, 0x5739b3e5, 0xa55230e6,
    30     0xfb410cc2, 0x092a8fc1, 0x1a7a7c35, 0xe811ff36, 0x3cdb9bdd, 0xceb018de, 0xdde0eb2a, 0x2f8b6829,
    31     0x82f63b78, 0x709db87b, 0x63cd4b8f, 0x91a6c88c, 0x456cac67, 0xb7072f64, 0xa457dc90, 0x563c5f93,
    32     0x082f63b7, 0xfa44e0b4, 0xe9141340, 0x1b7f9043, 0xcfb5f4a8, 0x3dde77ab, 0x2e8e845f, 0xdce5075c,
    33     0x92a8fc17, 0x60c37f14, 0x73938ce0, 0x81f80fe3, 0x55326b08, 0xa759e80b, 0xb4091bff, 0x466298fc,
    34     0x1871a4d8, 0xea1a27db, 0xf94ad42f, 0x0b21572c, 0xdfeb33c7, 0x2d80b0c4, 0x3ed04330, 0xccbbc033,
    35     0xa24bb5a6, 0x502036a5, 0x4370c551, 0xb11b4652, 0x65d122b9, 0x97baa1ba, 0x84ea524e, 0x7681d14d,
    36     0x2892ed69, 0xdaf96e6a, 0xc9a99d9e, 0x3bc21e9d, 0xef087a76, 0x1d63f975, 0x0e330a81, 0xfc588982,
    37     0xb21572c9, 0x407ef1ca, 0x532e023e, 0xa145813d, 0x758fe5d6, 0x87e466d5, 0x94b49521, 0x66df1622,
    38     0x38cc2a06, 0xcaa7a905, 0xd9f75af1, 0x2b9cd9f2, 0xff56bd19, 0x0d3d3e1a, 0x1e6dcdee, 0xec064eed,
    39     0xc38d26c4, 0x31e6a5c7, 0x22b65633, 0xd0ddd530, 0x0417b1db, 0xf67c32d8, 0xe52cc12c, 0x1747422f,
    40     0x49547e0b, 0xbb3ffd08, 0xa86f0efc, 0x5a048dff, 0x8ecee914, 0x7ca56a17, 0x6ff599e3, 0x9d9e1ae0,
    41     0xd3d3e1ab, 0x21b862a8, 0x32e8915c, 0xc083125f, 0x144976b4, 0xe622f5b7, 0xf5720643, 0x07198540,
    42     0x590ab964, 0xab613a67, 0xb831c993, 0x4a5a4a90, 0x9e902e7b, 0x6cfbad78, 0x7fab5e8c, 0x8dc0dd8f,
    43     0xe330a81a, 0x115b2b19, 0x020bd8ed, 0xf0605bee, 0x24aa3f05, 0xd6c1bc06, 0xc5914ff2, 0x37faccf1,
    44     0x69e9f0d5, 0x9b8273d6, 0x88d28022, 0x7ab90321, 0xae7367ca, 0x5c18e4c9, 0x4f48173d, 0xbd23943e,
    45     0xf36e6f75, 0x0105ec76, 0x12551f82, 0xe03e9c81, 0x34f4f86a, 0xc69f7b69, 0xd5cf889d, 0x27a40b9e,
    46     0x79b737ba, 0x8bdcb4b9, 0x988c474d, 0x6ae7c44e, 0xbe2da0a5, 0x4c4623a6, 0x5f16d052, 0xad7d5351
     15    0x00000000, 0xf26b8303, 0xe13b70f7, 0x1350f3f4, 0xc79a971f, 0x35f1141c, 0x26a1e7e8, 0xd4ca64eb,
     16    0x8ad958cf, 0x78b2dbcc, 0x6be22838, 0x9989ab3b, 0x4d43cfd0, 0xbf284cd3, 0xac78bf27, 0x5e133c24,
     17    0x105ec76f, 0xe235446c, 0xf165b798, 0x030e349b, 0xd7c45070, 0x25afd373, 0x36ff2087, 0xc494a384,
     18    0x9a879fa0, 0x68ec1ca3, 0x7bbcef57, 0x89d76c54, 0x5d1d08bf, 0xaf768bbc, 0xbc267848, 0x4e4dfb4b,
     19    0x20bd8ede, 0xd2d60ddd, 0xc186fe29, 0x33ed7d2a, 0xe72719c1, 0x154c9ac2, 0x061c6936, 0xf477ea35,
     20    0xaa64d611, 0x580f5512, 0x4b5fa6e6, 0xb93425e5, 0x6dfe410e, 0x9f95c20d, 0x8cc531f9, 0x7eaeb2fa,
     21    0x30e349b1, 0xc288cab2, 0xd1d83946, 0x23b3ba45, 0xf779deae, 0x05125dad, 0x1642ae59, 0xe4292d5a,
     22    0xba3a117e, 0x4851927d, 0x5b016189, 0xa96ae28a, 0x7da08661, 0x8fcb0562, 0x9c9bf696, 0x6ef07595,
     23    0x417b1dbc, 0xb3109ebf, 0xa0406d4b, 0x522bee48, 0x86e18aa3, 0x748a09a0, 0x67dafa54, 0x95b17957,
     24    0xcba24573, 0x39c9c670, 0x2a993584, 0xd8f2b687, 0x0c38d26c, 0xfe53516f, 0xed03a29b, 0x1f682198,
     25    0x5125dad3, 0xa34e59d0, 0xb01eaa24, 0x42752927, 0x96bf4dcc, 0x64d4cecf, 0x77843d3b, 0x85efbe38,
     26    0xdbfc821c, 0x2997011f, 0x3ac7f2eb, 0xc8ac71e8, 0x1c661503, 0xee0d9600, 0xfd5d65f4, 0x0f36e6f7,
     27    0x61c69362, 0x93ad1061, 0x80fde395, 0x72966096, 0xa65c047d, 0x5437877e, 0x4767748a, 0xb50cf789,
     28    0xeb1fcbad, 0x197448ae, 0x0a24bb5a, 0xf84f3859, 0x2c855cb2, 0xdeeedfb1, 0xcdbe2c45, 0x3fd5af46,
     29    0x7198540d, 0x83f3d70e, 0x90a324fa, 0x62c8a7f9, 0xb602c312, 0x44694011, 0x5739b3e5, 0xa55230e6,
     30    0xfb410cc2, 0x092a8fc1, 0x1a7a7c35, 0xe811ff36, 0x3cdb9bdd, 0xceb018de, 0xdde0eb2a, 0x2f8b6829,
     31    0x82f63b78, 0x709db87b, 0x63cd4b8f, 0x91a6c88c, 0x456cac67, 0xb7072f64, 0xa457dc90, 0x563c5f93,
     32    0x082f63b7, 0xfa44e0b4, 0xe9141340, 0x1b7f9043, 0xcfb5f4a8, 0x3dde77ab, 0x2e8e845f, 0xdce5075c,
     33    0x92a8fc17, 0x60c37f14, 0x73938ce0, 0x81f80fe3, 0x55326b08, 0xa759e80b, 0xb4091bff, 0x466298fc,
     34    0x1871a4d8, 0xea1a27db, 0xf94ad42f, 0x0b21572c, 0xdfeb33c7, 0x2d80b0c4, 0x3ed04330, 0xccbbc033,
     35    0xa24bb5a6, 0x502036a5, 0x4370c551, 0xb11b4652, 0x65d122b9, 0x97baa1ba, 0x84ea524e, 0x7681d14d,
     36    0x2892ed69, 0xdaf96e6a, 0xc9a99d9e, 0x3bc21e9d, 0xef087a76, 0x1d63f975, 0x0e330a81, 0xfc588982,
     37    0xb21572c9, 0x407ef1ca, 0x532e023e, 0xa145813d, 0x758fe5d6, 0x87e466d5, 0x94b49521, 0x66df1622,
     38    0x38cc2a06, 0xcaa7a905, 0xd9f75af1, 0x2b9cd9f2, 0xff56bd19, 0x0d3d3e1a, 0x1e6dcdee, 0xec064eed,
     39    0xc38d26c4, 0x31e6a5c7, 0x22b65633, 0xd0ddd530, 0x0417b1db, 0xf67c32d8, 0xe52cc12c, 0x1747422f,
     40    0x49547e0b, 0xbb3ffd08, 0xa86f0efc, 0x5a048dff, 0x8ecee914, 0x7ca56a17, 0x6ff599e3, 0x9d9e1ae0,
     41    0xd3d3e1ab, 0x21b862a8, 0x32e8915c, 0xc083125f, 0x144976b4, 0xe622f5b7, 0xf5720643, 0x07198540,
     42    0x590ab964, 0xab613a67, 0xb831c993, 0x4a5a4a90, 0x9e902e7b, 0x6cfbad78, 0x7fab5e8c, 0x8dc0dd8f,
     43    0xe330a81a, 0x115b2b19, 0x020bd8ed, 0xf0605bee, 0x24aa3f05, 0xd6c1bc06, 0xc5914ff2, 0x37faccf1,
     44    0x69e9f0d5, 0x9b8273d6, 0x88d28022, 0x7ab90321, 0xae7367ca, 0x5c18e4c9, 0x4f48173d, 0xbd23943e,
     45    0xf36e6f75, 0x0105ec76, 0x12551f82, 0xe03e9c81, 0x34f4f86a, 0xc69f7b69, 0xd5cf889d, 0x27a40b9e,
     46    0x79b737ba, 0x8bdcb4b9, 0x988c474d, 0x6ae7c44e, 0xbe2da0a5, 0x4c4623a6, 0x5f16d052, 0xad7d5351
    4747};
    4848
    4949
    static uint32 kCrcTable[256] = {  
    5858    \return The crc checksum, or 0 if an error occurred.
    5959*/
    6060uint32
    61 calculate_crc(uint32 crc, uint8 *data, uint16 length)
     61calculate_crc(uint32 crc, uint8* data, uint16 length)
    6262{
    6363    if (data) {
    6464        for ( ; length > 0; length--, data++)
  • src/add-ons/kernel/file_systems/btrfs/CRCTable.h

    diff --git a/src/add-ons/kernel/file_systems/btrfs/CRCTable.h b/src/add-ons/kernel/file_systems/btrfs/CRCTable.h
    index 965251a..b6c1192 100644
    a b  
    66 *      Jérôme Duval
    77 */
    88
    9 uint32 calculate_crc(uint32 crc, uint8 *data, uint16 length);
    10 
     9uint32 calculate_crc(uint32 crc, uint8* data, uint16 length);
  • src/add-ons/kernel/file_systems/btrfs/CachedBlock.h

    diff --git a/src/add-ons/kernel/file_systems/btrfs/CachedBlock.h b/src/add-ons/kernel/file_systems/btrfs/CachedBlock.h
    index 09fec08..3f27ed8 100644
    a b  
    77
    88//! interface for the block cache
    99
    10 #include <fs_cache.h>
    1110
    1211#include "Volume.h"
    1312
    1413
    1514class CachedBlock {
    1615public:
    17                             CachedBlock(Volume* volume);
    18                             CachedBlock(Volume* volume, off_t block);
    19                             ~CachedBlock();
     16    CachedBlock(Volume* volume);
     17    CachedBlock(Volume* volume, off_t block);
     18    ~CachedBlock();
    2019
    21             void            Keep();
    22             void            Unset();
     20    void    Keep();
     21    void    Unset();
    2322
    24             const uint8*    SetTo(off_t block);
     23    const uint8*    SetTo(off_t block);
    2524
    26             const uint8*    Block() const { return fBlock; }
    27             off_t           BlockNumber() const { return fBlockNumber; }
     25    const uint8*    Block() const { return fBlock; }
     26    off_t   BlockNumber() const { return fBlockNumber; }
    2827
    2928private:
    30                             CachedBlock(const CachedBlock &);
    31                             CachedBlock &operator=(const CachedBlock &);
    32                                 // no implementation
    33                        
     29    CachedBlock(const CachedBlock&);
     30    CachedBlock& operator=(const CachedBlock&);
     31    // no implementation
     32
    3433protected:
    35             Volume*         fVolume;
    36             off_t           fBlockNumber;
    37             uint8*          fBlock;
     34    Volume* fVolume;
     35    off_t   fBlockNumber;
     36    uint8*  fBlock;
    3837};
    3938
    4039
    CachedBlock::SetTo(off_t block)  
    9190{
    9291    Unset();
    9392    fBlockNumber = block;
    94     return fBlock = (uint8 *)block_cache_get(fVolume->BlockCache(), block);
     93    return fBlock = (uint8*)block_cache_get(fVolume->BlockCache(), block);
    9594}
    9695
    9796#endif  // CACHED_BLOCK_H
  • src/add-ons/kernel/file_systems/btrfs/Chunk.cpp

    diff --git a/src/add-ons/kernel/file_systems/btrfs/Chunk.cpp b/src/add-ons/kernel/file_systems/btrfs/Chunk.cpp
    index ee08cbd..43e8180 100644
    a b  
    33 * This file may be used under the terms of the MIT License.
    44 *
    55 * Authors:
    6  *      Jérôme Duval
     6 *  Jérôme Duval
    77 */
    88
    99
    1010#include "Chunk.h"
    1111
    12 #include <stdlib.h>
    13 #include <string.h>
    14 
    1512
    1613//#define TRACE_BTRFS
    1714#ifdef TRACE_BTRFS
    Chunk::Chunk(struct btrfs_chunk* chunk, fsblock_t offset)  
    4340        "sector_size %" B_PRIu32 "\n", chunk->Length(), chunk->Owner(),
    4441        chunk->StripeLength(), chunk->Type(), chunk->StripeCount(),
    4542        chunk->SubStripes(), chunk->SectorSize());
    46     for(int32 i = 0; i < chunk->StripeCount(); i++) {
     43    for (int32 i = 0; i < chunk->StripeCount(); i++) {
    4744        TRACE("chunk.stripe[%" B_PRId32 "].physical %" B_PRId64 " deviceid %"
    4845            B_PRId64 "\n", i, chunk->stripes[i].Offset(),
    4946            chunk->stripes[i].DeviceID());
    Chunk::Size() const  
    6663
    6764
    6865status_t
    69 Chunk::FindBlock(off_t logical, off_t &physical)
     66Chunk::FindBlock(off_t logical, off_t& physical)
    7067{
    7168    if (fChunk == NULL)
    7269        return B_NO_INIT;
  • src/add-ons/kernel/file_systems/btrfs/Chunk.h

    diff --git a/src/add-ons/kernel/file_systems/btrfs/Chunk.h b/src/add-ons/kernel/file_systems/btrfs/Chunk.h
    index b751e72..73dce17 100644
    a b  
    55 * Authors:
    66 *      Jérôme Duval
    77 */
     8
    89#ifndef CHUNK_H
    910#define CHUNK_H
    1011
     
    1415
    1516class Chunk {
    1617public:
    17                                 Chunk(struct btrfs_chunk* chunk,
    18                                     fsblock_t offset);
    19                                 ~Chunk();
    20             uint32              Size() const;
    21             status_t            FindBlock(off_t logical, off_t &physical);
    22             fsblock_t           Offset() const { return fChunkOffset; }
    23             fsblock_t           End() const
    24                                     { return fChunkOffset + fChunk->Length(); }
     18    Chunk(struct btrfs_chunk* chunk,
     19        fsblock_t offset);
     20    ~Chunk();
     21    uint32  Size() const;
     22    status_t    FindBlock(off_t logical, off_t& physical);
     23    fsblock_t   Offset() const { return fChunkOffset; }
     24    fsblock_t   End() const
     25        { return fChunkOffset + fChunk->Length(); }
    2526private:
    26             struct btrfs_chunk* fChunk;
    27             fsblock_t           fChunkOffset;
    28             status_t            fInitStatus;
     27    struct btrfs_chunk* fChunk;
     28    fsblock_t   fChunkOffset;
     29    status_t    fInitStatus;
    2930};
    3031
     32
    3133#endif  // CHUNK_H
  • src/add-ons/kernel/file_systems/btrfs/DirectoryIterator.cpp

    diff --git a/src/add-ons/kernel/file_systems/btrfs/DirectoryIterator.cpp b/src/add-ons/kernel/file_systems/btrfs/DirectoryIterator.cpp
    index 01eb988..ded0351 100644
    a b  
    55
    66
    77#include "DirectoryIterator.h"
    8 
    9 #include <new>
    10 #include <stdlib.h>
    11 
    128#include "CRCTable.h"
    139
    1410
    DirectoryIterator::GetNext(char* name, size_t* _nameLength, ino_t* _id)  
    7369    }
    7470
    7571    btrfs_key key;
    76     btrfs_dir_entry *entries;
     72    btrfs_dir_entry* entries;
    7773    size_t entries_length;
    7874    status_t status = fIterator->GetNextEntry(key, (void**)&entries,
    7975        &entries_length);
    8076    if (status != B_OK)
    8177        return status;
    8278
    83     btrfs_dir_entry *entry = entries;
     79    btrfs_dir_entry* entry = entries;
    8480    uint16 current = 0;
    8581    while (current < entries_length) {
    8682        current += entry->Length();
    8783        break;
    8884        // TODO there could be several entries with the same name hash
    89         entry = (btrfs_dir_entry *)((uint8*)entry + entry->Length());
     85        entry = (btrfs_dir_entry*)((uint8*)entry + entry->Length());
    9086    }
    9187
    9288    size_t length = entry->NameLength();
    DirectoryIterator::Lookup(const char* name, size_t nameLength, ino_t* _id)  
    127123    key.SetObjectID(fInode->ID());
    128124    key.SetOffset(hash);
    129125
    130     btrfs_dir_entry *entries;
     126    btrfs_dir_entry* entries;
    131127    size_t length;
    132128    status_t status = fInode->GetVolume()->FSTree()->FindExact(key,
    133129        (void**)&entries, &length);
    DirectoryIterator::Lookup(const char* name, size_t nameLength, ino_t* _id)  
    137133        return status;
    138134    }
    139135
    140     btrfs_dir_entry *entry = entries;
     136    btrfs_dir_entry* entry = entries;
    141137    uint16 current = 0;
    142138    while (current < length) {
    143139        current += entry->Length();
    144140        break;
    145141        // TODO there could be several entries with the same name hash
    146         entry = (btrfs_dir_entry *)((uint8*)entry + entry->Length());
     142        entry = (btrfs_dir_entry*)((uint8*)entry + entry->Length());
    147143    }
    148144
    149145    TRACE("DirectoryIterator::Lookup() entries_length %ld name_length %d\n",
  • src/add-ons/kernel/file_systems/btrfs/DirectoryIterator.h

    diff --git a/src/add-ons/kernel/file_systems/btrfs/DirectoryIterator.h b/src/add-ons/kernel/file_systems/btrfs/DirectoryIterator.h
    index 069c9a0..54f4c1b 100644
    a b  
    1212
    1313class DirectoryIterator {
    1414public:
    15                                 DirectoryIterator(Inode* inode);
    16                                 ~DirectoryIterator();
     15    DirectoryIterator(Inode* inode);
     16    ~DirectoryIterator();
    1717
    18             status_t            InitCheck();
     18    status_t    InitCheck();
    1919
    20             status_t            GetNext(char* name, size_t* _nameLength, ino_t* _id);
    21             status_t            Lookup(const char* name, size_t nameLength, ino_t* _id);
    22             status_t            Rewind();
     20    status_t    GetNext(char* name, size_t* _nameLength, ino_t* _id);
     21    status_t    Lookup(const char* name, size_t nameLength, ino_t* _id);
     22    status_t    Rewind();
    2323private:
    24             uint64              fOffset;
    25             Inode*              fInode;
    26             TreeIterator*       fIterator;
     24    uint64  fOffset;
     25    Inode* fInode;
     26    TreeIterator*   fIterator;
    2727};
    2828
    2929
  • src/add-ons/kernel/file_systems/btrfs/Inode.cpp

    diff --git a/src/add-ons/kernel/file_systems/btrfs/Inode.cpp b/src/add-ons/kernel/file_systems/btrfs/Inode.cpp
    index 742f6d5..666000e 100644
    a b  
    77
    88
    99#include "Inode.h"
    10 
    11 #include <string.h>
    12 #include <stdlib.h>
    13 #include <zlib.h>
    14 
    1510#include "BPlusTree.h"
    1611#include "CachedBlock.h"
    1712#include "Utility.h"
    Inode::UpdateNodeFromDisk()  
    8479    search_key.SetObjectID(fID);
    8580    search_key.SetOffset(0);
    8681
    87     struct btrfs_inode *node;
     82    struct btrfs_inode* node;
    8883    if (fVolume->FSTree()->FindExact(search_key, (void**)&node) != B_OK) {
    8984        ERROR("Inode::UpdateNodeFromDisk(): Couldn't find inode %"
    9085            B_PRIdINO "\n", fID);
    Inode::CheckPermissions(int accessMode) const  
    110105
    111106
    112107status_t
    113 Inode::FindBlock(off_t pos, off_t& physical, off_t *_length)
     108Inode::FindBlock(off_t pos, off_t& physical, off_t* _length)
    114109{
    115110    struct btrfs_key search_key;
    116111    search_key.SetType(BTRFS_KEY_TYPE_EXTENT_DATA);
    117112    search_key.SetObjectID(fID);
    118113    search_key.SetOffset(pos + 1);
    119114
    120     btrfs_extent_data *extent_data;
     115    btrfs_extent_data* extent_data;
    121116    status_t status = fVolume->FSTree()->FindPrevious(search_key,
    122117        (void**)&extent_data);
    123118    if (status != B_OK) {
    Inode::ReadAt(off_t pos, uint8* buffer, size_t* _length)  
    173168    search_key.SetOffset(pos + 1);
    174169
    175170    size_t item_size;
    176     btrfs_extent_data *extent_data;
     171    btrfs_extent_data* extent_data;
    177172    status_t status = fVolume->FSTree()->FindPrevious(search_key,
    178173        (void**)&extent_data, &item_size);
    179174    if (status != B_OK) {
    Inode::ReadAt(off_t pos, uint8* buffer, size_t* _length)  
    291286
    292287
    293288status_t
    294 Inode::FindParent(ino_t *id)
     289Inode::FindParent(ino_t* id)
    295290{
    296291    struct btrfs_key search_key;
    297292    search_key.SetType(BTRFS_KEY_TYPE_INODE_REF);
    298293    search_key.SetObjectID(fID);
    299294    search_key.SetOffset(-1);
    300295
    301     void *node_ref;
     296    void* node_ref;
    302297    if (fVolume->FSTree()->FindPrevious(search_key, &node_ref) != B_OK) {
    303298        ERROR("Inode::FindParent(): Couldn't find inode for %" B_PRIdINO "\n",
    304299            fID);
  • src/add-ons/kernel/file_systems/btrfs/Inode.h

    diff --git a/src/add-ons/kernel/file_systems/btrfs/Inode.h b/src/add-ons/kernel/file_systems/btrfs/Inode.h
    index b6fa157..9221567 100644
    a b  
    77#define INODE_H
    88
    99
    10 #include <fs_cache.h>
    11 #include <lock.h>
    12 #include <string.h>
    13 
    1410#include "btrfs.h"
    1511#include "Volume.h"
    1612
     
    2521
    2622class Inode {
    2723public:
    28                         Inode(Volume* volume, ino_t id);
    29                         ~Inode();
    30 
    31             status_t    InitCheck();
    32 
    33             ino_t       ID() const { return fID; }
    34 
    35             rw_lock*    Lock() { return &fLock; }
    36 
    37             status_t    UpdateNodeFromDisk();
    38 
    39             bool        IsDirectory() const
    40                             { return S_ISDIR(Mode()); }
    41             bool        IsFile() const
    42                             { return S_ISREG(Mode()); }
    43             bool        IsSymLink() const
    44                             { return S_ISLNK(Mode()); }
    45             status_t    CheckPermissions(int accessMode) const;
    46 
    47             mode_t      Mode() const { return fNode.Mode(); }
    48             off_t       Size() const { return fNode.Size(); }
    49             uid_t       UserID() const { return fNode.UserID(); }
    50             gid_t       GroupID() const { return fNode.GroupID(); }
    51             void        GetChangeTime(struct timespec &timespec) const
    52                             { fNode.GetChangeTime(timespec); }
    53             void        GetModificationTime(struct timespec &timespec) const
    54                             { fNode.GetModificationTime(timespec); }
    55             void        GetCreationTime(struct timespec &timespec) const
    56                             { fNode.GetCreationTime(timespec); }
    57             void        GetAccessTime(struct timespec &timespec) const
    58                             { fNode.GetCreationTime(timespec); }
    59 
    60             Volume*     GetVolume() const { return fVolume; }
    61 
    62             status_t    FindBlock(off_t logical, off_t& physical,
    63                             off_t *_length = NULL);
    64             status_t    ReadAt(off_t pos, uint8 *buffer, size_t *length);
    65             status_t    FillGapWithZeros(off_t start, off_t end);
    66 
    67             void*       FileCache() const { return fCache; }
    68             void*       Map() const { return fMap; }
    69            
    70             status_t    FindParent(ino_t *id);
     24    Inode(Volume* volume, ino_t id);
     25    ~Inode();
     26   
     27    status_t    InitCheck();
     28    ino_t   ID() const { return fID; }
     29    rw_lock*    Lock() { return& fLock; }
     30    status_t    UpdateNodeFromDisk();
     31   
     32    bool    IsDirectory() const
     33        { return S_ISDIR(Mode()); }
     34    bool    IsFile() const
     35        { return S_ISREG(Mode()); }
     36    bool    IsSymLink() const
     37        { return S_ISLNK(Mode()); }
     38    status_t    CheckPermissions(int accessMode) const;
     39    mode_t  Mode() const { return fNode.Mode(); }
     40    off_t   Size() const { return fNode.Size(); }
     41    uid_t   UserID() const { return fNode.UserID(); }
     42    gid_t   GroupID() const { return fNode.GroupID(); }
     43    void    GetChangeTime(struct timespec& timespec) const
     44        { fNode.GetChangeTime(timespec); }
     45    void    GetModificationTime(struct timespec& timespec) const
     46        { fNode.GetModificationTime(timespec); }
     47    void    GetCreationTime(struct timespec& timespec) const
     48        { fNode.GetCreationTime(timespec); }
     49    void    GetAccessTime(struct timespec& timespec) const
     50        { fNode.GetCreationTime(timespec); }
     51    Volume* GetVolume() const { return fVolume; }
     52    status_t    FindBlock(off_t logical, off_t& physical,
     53        off_t* _length = NULL);
     54    status_t    ReadAt(off_t pos, uint8* buffer, size_t* length);
     55    status_t    FillGapWithZeros(off_t start, off_t end);
     56    void*   FileCache() const { return fCache; }
     57    void*   Map() const { return fMap; }
     58    status_t    FindParent(ino_t* id);
    7159private:
    72                         Inode(Volume* volume);
    73                         Inode(const Inode&);
    74                         Inode &operator=(const Inode&);
    75                             // no implementation
    76 
    77             uint64      _NumBlocks();
    78 
    79             rw_lock     fLock;
    80             ::Volume*   fVolume;
    81             ino_t       fID;
    82             void*       fCache;
    83             void*       fMap;
    84             status_t    fInitStatus;
    85             struct btrfs_inode fNode;
     60    Inode(Volume* volume);
     61    Inode(const Inode&);
     62    Inode& operator=(const Inode&);
     63    // no implementation
     64
     65    uint64  _NumBlocks();
     66    rw_lock fLock;
     67    ::Volume*   fVolume;
     68    ino_t   fID;
     69    void*   fCache;
     70    void*   fMap;
     71    status_t    fInitStatus;
     72    struct btrfs_inode fNode;
    8673};
    8774
    8875
    public:  
    9885    {
    9986        SetTo(volume, id);
    10087    }
    101 
     88   
    10289    Vnode()
    10390        :
    10491        fStatus(B_NO_INIT),
    10592        fInode(NULL)
    10693    {
    10794    }
    108 
     95   
    10996    ~Vnode()
    11097    {
    11198        Unset();
    11299    }
    113 
     100   
    114101    status_t InitCheck()
    115102    {
    116103        return fStatus;
    117104    }
    118 
     105   
    119106    void Unset()
    120107    {
    121108        if (fInode != NULL) {
    public:  
    124111            fStatus = B_NO_INIT;
    125112        }
    126113    }
    127 
     114   
    128115    status_t SetTo(Volume* volume, ino_t id)
    129116    {
    130117        Unset();
    131 
    132118        return fStatus = get_vnode(volume->FSVolume(), id, (void**)&fInode);
    133119    }
    134 
     120   
    135121    status_t Get(Inode** _inode)
    136122    {
    137123        *_inode = fInode;
    138124        return fStatus;
    139125    }
    140 
     126   
    141127    void Keep()
    142128    {
    143129        TRACEI("Vnode::Keep()\n");
    public:  
    146132
    147133private:
    148134    status_t    fStatus;
    149     Inode*      fInode;
     135    Inode*  fInode;
    150136};
    151137
    152138#endif  // INODE_H
  • src/add-ons/kernel/file_systems/btrfs/Utility.h

    diff --git a/src/add-ons/kernel/file_systems/btrfs/Utility.h b/src/add-ons/kernel/file_systems/btrfs/Utility.h
    index 07a252e..9ad930d 100644
    a b  
    1010
    1111
    1212enum inode_type {
    13     S_DIRECTORY     = S_IFDIR,
    14     S_FILE          = S_IFREG,
    15     S_SYMLINK       = S_IFLNK,
    16 
    17     S_INDEX_TYPES   = (S_STR_INDEX | S_INT_INDEX | S_UINT_INDEX
    18                         | S_LONG_LONG_INDEX | S_ULONG_LONG_INDEX
    19                         | S_FLOAT_INDEX | S_DOUBLE_INDEX),
    20 
     13    S_DIRECTORY = S_IFDIR,
     14    S_FILE  = S_IFREG,
     15    S_SYMLINK   = S_IFLNK,
     16   
     17    S_INDEX_TYPES   =   (S_STR_INDEX | S_INT_INDEX | S_UINT_INDEX
     18                            | S_LONG_LONG_INDEX | S_ULONG_LONG_INDEX
     19                            | S_FLOAT_INDEX | S_DOUBLE_INDEX),
     20   
    2121    S_EXTENDED_TYPES = (S_ATTR_DIR | S_ATTR | S_INDEX_DIR)
    2222};
    2323
    open_mode_to_access(int openMode)  
    3838    return R_OK | W_OK;
    3939}
    4040
     41
    4142#endif  // UTILITY_H
  • src/add-ons/kernel/file_systems/btrfs/Volume.cpp

    diff --git a/src/add-ons/kernel/file_systems/btrfs/Volume.cpp b/src/add-ons/kernel/file_systems/btrfs/Volume.cpp
    index 5b99447..4dc7ddc 100644
    a b  
    99
    1010
    1111#include "Volume.h"
    12 
    13 #include <errno.h>
    14 #include <new>
    15 #include <stdio.h>
    16 #include <stdlib.h>
    17 #include <string.h>
    18 
    19 #include <fs_cache.h>
    20 #include <fs_volume.h>
    21 
    22 #include <util/AutoLock.h>
    23 
    2412#include "BPlusTree.h"
    2513#include "CachedBlock.h"
    2614#include "Chunk.h"
     
    3826
    3927class DeviceOpener {
    4028public:
    41                                 DeviceOpener(int fd, int mode);
    42                                 DeviceOpener(const char* device, int mode);
    43                                 ~DeviceOpener();
     29    DeviceOpener(int fd, int mode);
     30    DeviceOpener(const char* device, int mode);
     31    ~DeviceOpener();
    4432
    45             int                 Open(const char* device, int mode);
    46             int                 Open(int fd, int mode);
    47             void*               InitCache(off_t numBlocks, uint32 blockSize);
    48             void                RemoveCache(bool allowWrites);
     33    int     Open(const char* device, int mode);
     34    int     Open(int fd, int mode);
     35    void*   InitCache(off_t numBlocks, uint32 blockSize);
     36    void    RemoveCache(bool allowWrites);
    4937
    50             void                Keep();
     38    void    Keep();
    5139
    52             int                 Device() const { return fDevice; }
    53             int                 Mode() const { return fMode; }
    54             bool                IsReadOnly() const
    55                                     { return _IsReadOnly(fMode); }
     40    int     Device() const { return fDevice; }
     41    int     Mode() const { return fMode; }
     42    bool    IsReadOnly() const { return _IsReadOnly(fMode); }
    5643
    57             status_t            GetSize(off_t* _size, uint32* _blockSize = NULL);
     44    status_t    GetSize(off_t* _size, uint32* _blockSize = NULL);
    5845
    59 private:
    60     static  bool                _IsReadOnly(int mode)
    61                                     { return (mode & O_RWMASK) == O_RDONLY;}
    62     static  bool                _IsReadWrite(int mode)
    63                                     { return (mode & O_RWMASK) == O_RDWR;}
     46    private:
     47    static  bool    _IsReadOnly(int mode) { return (mode & O_RWMASK) == O_RDONLY;}
     48    static  bool    _IsReadWrite(int mode) { return (mode & O_RWMASK) == O_RDWR;}
    6449
    65             int                 fDevice;
    66             int                 fMode;
    67             void*               fBlockCache;
     50    int fDevice;
     51    int fMode;
     52    void*   fBlockCache;
    6853};
    6954
    7055
    void*  
    142127DeviceOpener::InitCache(off_t numBlocks, uint32 blockSize)
    143128{
    144129    return fBlockCache = block_cache_create(fDevice, numBlocks, blockSize,
    145         IsReadOnly());
     130            IsReadOnly());
    146131}
    147132
    148133
    DeviceOpener::GetSize(off_t* _size, uint32* _blockSize)  
    187172
    188173    if (_size) {
    189174        *_size = 1ULL * geometry.head_count * geometry.cylinder_count
    190             * geometry.sectors_per_track * geometry.bytes_per_sector;
     175                    * geometry.sectors_per_track * geometry.bytes_per_sector;
    191176    }
    192177    if (_blockSize)
    193178        *_blockSize = geometry.bytes_per_sector;
    btrfs_super_block::IsValid()  
    205190    // TODO: check some more values!
    206191    if (strncmp(magic, BTRFS_SUPER_BLOCK_MAGIC, sizeof(magic)) != 0)
    207192        return false;
    208    
     193
    209194    return true;
    210195}
    211196
    Volume::Volume(fs_volume* volume)  
    219204    fFlags(0),
    220205    fChunk(NULL),
    221206    fChunkTree(NULL)
    222 {
     207    {
    223208    mutex_init(&fLock, "btrfs volume");
    224209}
    225210
    Volume::Name() const  
    249234
    250235status_t
    251236Volume::Mount(const char* deviceName, uint32 flags)
    252 {
     237    {
    253238    flags |= B_MOUNT_READ_ONLY;
    254         // we only support read-only for now
    255    
     239    // we only support read-only for now
     240
    256241    if ((flags & B_MOUNT_READ_ONLY) != 0) {
    257242        TRACE("Volume::Mount(): Read only\n");
    258243    } else {
    Volume::Mount(const char* deviceName, uint32 flags)  
    276261        ERROR("Volume::Mount(): Identify() failed\n");
    277262        return status;
    278263    }
    279    
     264
    280265    fBlockSize = fSuperBlock.BlockSize();
    281266    TRACE("block size %" B_PRIu32 "\n", fBlockSize);
    282267
    Volume::Mount(const char* deviceName, uint32 flags)  
    290275        if (key->Type() != BTRFS_KEY_TYPE_CHUNK_ITEM) {
    291276            break;
    292277        }
    293        
     278
    294279        struct btrfs_chunk* chunk = (struct btrfs_chunk*)(key + 1);
    295280        fChunk = new(std::nothrow) Chunk(chunk, key->Offset());
    296281        if (fChunk == NULL)
    Volume::Mount(const char* deviceName, uint32 flags)  
    310295    FindBlock(fSuperBlock.LogRoot(), physical);
    311296    TRACE("Volume::Mount() log_root: %" B_PRIu64 " (physical %" B_PRIu64 ")\n",
    312297        fSuperBlock.LogRoot(), physical);
    313        
     298
    314299    // check if the device size is large enough to hold the file system
    315300    off_t diskSize;
    316301    status = opener.GetSize(&diskSize);
    Volume::Mount(const char* deviceName, uint32 flags)  
    323308        fBlockSize);
    324309    if (fBlockCache == NULL)
    325310        return B_ERROR;
    326    
     311
    327312    TRACE("Volume::Mount(): Initialized block cache: %p\n", fBlockCache);
    328313
    329314    fChunkTree = new(std::nothrow) BPlusTree(this, fSuperBlock.ChunkRoot());
    Volume::Mount(const char* deviceName, uint32 flags)  
    348333    search_key.SetOffset(0);
    349334    search_key.SetType(BTRFS_KEY_TYPE_ROOT_ITEM);
    350335    search_key.SetObjectID(BTRFS_OBJECT_ID_EXTENT_TREE);
    351     struct btrfs_root *root;
     336    struct btrfs_root* root;
    352337    if (fRootTree->FindNext(search_key, (void**)&root) != B_OK) {
    353338        ERROR("Volume::Mount(): Couldn't find extent root\n");
    354339        return B_ERROR;
    Volume::Mount(const char* deviceName, uint32 flags)  
    359344    free(root);
    360345    if (fExtentTree == NULL)
    361346        return B_NO_MEMORY;
    362    
     347
    363348    search_key.SetOffset(0);
    364349    search_key.SetObjectID(BTRFS_OBJECT_ID_FS_TREE);
    365350    if (fRootTree->FindNext(search_key, (void**)&root) != B_OK) {
    Volume::Mount(const char* deviceName, uint32 flags)  
    371356    free(root);
    372357    if (fFSTree == NULL)
    373358        return B_NO_MEMORY;
    374    
     359
    375360    search_key.SetOffset(0);
    376361    search_key.SetObjectID(BTRFS_OBJECT_ID_DEV_TREE);
    377362    if (fRootTree->FindNext(search_key, (void**)&root) != B_OK) {
    Volume::Mount(const char* deviceName, uint32 flags)  
    397382    free(root);
    398383    if (fChecksumTree == NULL)
    399384        return B_NO_MEMORY;
    400    
     385
    401386    // ready
    402387    status = get_vnode(fFSVolume, BTRFS_OBJECT_ID_CHUNK_TREE,
    403388        (void**)&fRootNode);
    Volume::Mount(const char* deviceName, uint32 flags)  
    426411        }
    427412
    428413        double size = double((10 * diskSize + divisor - 1) / divisor);
    429             // %g in the kernel does not support precision...
     414        // %g in the kernel does not support precision...
    430415
    431416        snprintf(fName, sizeof(fName), "%g %cB Btrfs Volume",
    432417            size / 10, unit);
    Volume::LoadSuperBlock()  
    478463
    479464
    480465status_t
    481 Volume::FindBlock(off_t logical, fsblock_t &physicalBlock)
     466Volume::FindBlock(off_t logical, fsblock_t& physicalBlock)
    482467{
    483468    off_t physical;
    484469    status_t status = FindBlock(logical, physical);
    Volume::FindBlock(off_t logical, fsblock_t &physicalBlock)  
    490475
    491476
    492477status_t
    493 Volume::FindBlock(off_t logical, off_t &physical)
     478Volume::FindBlock(off_t logical, off_t& physical)
    494479{
    495480    if (fChunkTree == NULL
    496481        || (logical >= (off_t)fChunk->Offset()
    Volume::FindBlock(off_t logical, off_t &physical)  
    503488    search_key.SetOffset(logical);
    504489    search_key.SetType(BTRFS_KEY_TYPE_CHUNK_ITEM);
    505490    search_key.SetObjectID(BTRFS_OBJECT_ID_CHUNK_TREE);
    506     struct btrfs_chunk *chunk;
     491    struct btrfs_chunk* chunk;
    507492    size_t chunk_length;
    508493    status_t status = fChunkTree->FindPrevious(search_key, (void**)&chunk,
    509494        &chunk_length);
    Volume::FindBlock(off_t logical, off_t &physical)  
    514499    free(chunk);
    515500    status = _chunk.FindBlock(logical, physical);
    516501    if (status != B_OK)
    517             return status;
     502        return status;
    518503    TRACE("Volume::FindBlock(): logical: %" B_PRIdOFF ", physical: %" B_PRIdOFF
    519504        "\n", logical, physical);
    520505    return B_OK;
  • src/add-ons/kernel/file_systems/btrfs/Volume.h

    diff --git a/src/add-ons/kernel/file_systems/btrfs/Volume.h b/src/add-ons/kernel/file_systems/btrfs/Volume.h
    index a832fd2..9e19778 100644
    a b  
    77#define VOLUME_H
    88
    99
    10 #include <lock.h>
    11 
    1210#include "btrfs.h"
    1311
    1412
    1513enum volume_flags {
    16     VOLUME_READ_ONLY    = 0x0001
     14    VOLUME_READ_ONLY = 0x0001
    1715};
    1816
     17
    1918class BPlusTree;
    2019class Chunk;
    2120class Inode;
    class Inode;  
    2322
    2423class Volume {
    2524public:
    26                                 Volume(fs_volume* volume);
    27                                 ~Volume();
    28 
    29             status_t            Mount(const char* device, uint32 flags);
    30             status_t            Unmount();
     25    Volume(fs_volume* volume);
     26    ~Volume();
    3127
    32             bool                IsValidSuperBlock();
    33             bool                IsReadOnly() const
    34                                     { return (fFlags & VOLUME_READ_ONLY) != 0; }
     28    status_t    Mount(const char* device, uint32 flags);
     29    status_t    Unmount();
    3530
    36             Inode*              RootNode() const { return fRootNode; }
    37             int                 Device() const { return fDevice; }
     31    bool    IsValidSuperBlock();
     32    bool    IsReadOnly() const
     33                { return (fFlags & VOLUME_READ_ONLY) != 0; }
    3834
    39             dev_t               ID() const
    40                                     { return fFSVolume ? fFSVolume->id : -1; }
    41             fs_volume*          FSVolume() const { return fFSVolume; }
    42             const char*         Name() const;
    43             BPlusTree*          FSTree() const { return fFSTree; }
    44             BPlusTree*          RootTree() const { return fRootTree; }
     35    Inode*  RootNode() const { return fRootNode; }
     36    int     Device() const { return fDevice; }
    4537
    46             uint32              BlockSize() const { return fBlockSize; }
    47             btrfs_super_block&  SuperBlock() { return fSuperBlock; }
     38    dev_t   ID() const
     39                { return fFSVolume ? fFSVolume->id : -1; }
    4840
    49             status_t            LoadSuperBlock();
     41    fs_volume*  FSVolume() const { return fFSVolume; }
     42    const char* Name() const;
     43    BPlusTree*  FSTree() const { return fFSTree; }
     44    BPlusTree*  RootTree() const { return fRootTree; }
     45    uint32  BlockSize() const { return fBlockSize; }
     46    btrfs_super_block&  SuperBlock() { return fSuperBlock; }
     47    status_t    LoadSuperBlock();
    5048
    51             // cache access
    52             void*               BlockCache() { return fBlockCache; }
     49    // cache access
     50    void*   BlockCache() { return fBlockCache; }
    5351
    54     static  status_t            Identify(int fd, btrfs_super_block* superBlock);
    55 
    56             status_t            FindBlock(off_t logical, fsblock_t &physical);
    57             status_t            FindBlock(off_t logical, off_t &physical);
     52    static  status_t    Identify(int fd, btrfs_super_block* superBlock);
     53    status_t    FindBlock(off_t logical, fsblock_t& physical);
     54    status_t    FindBlock(off_t logical, off_t& physical);
    5855
    5956private:
    60             mutex               fLock;
    61             fs_volume*          fFSVolume;
    62             int                 fDevice;
    63             btrfs_super_block   fSuperBlock;
    64             char                fName[32];
    65 
    66             uint32              fFlags;
    67             uint32              fBlockSize;
    68 
    69             void*               fBlockCache;
    70             Inode*              fRootNode;
    71 
    72             Chunk*              fChunk;
    73             BPlusTree*          fChunkTree;
    74             BPlusTree*          fRootTree;
    75             BPlusTree*          fDevTree;
    76             BPlusTree*          fExtentTree;
    77             BPlusTree*          fFSTree;
    78             BPlusTree*          fChecksumTree;
     57    mutex   fLock;
     58    fs_volume*  fFSVolume;
     59    int     fDevice;
     60    btrfs_super_block   fSuperBlock;
     61    char    fName[32];
     62
     63    uint32  fFlags;
     64    uint32  fBlockSize;
     65
     66    void*   fBlockCache;
     67    Inode*  fRootNode;
     68
     69    Chunk*  fChunk;
     70    BPlusTree*  fChunkTree;
     71    BPlusTree*  fRootTree;
     72    BPlusTree*  fDevTree;
     73    BPlusTree*  fExtentTree;
     74    BPlusTree*  fFSTree;
     75    BPlusTree*  fChecksumTree;
    7976};
    8077
     78
    8179#endif  // VOLUME_H
    8280
  • src/add-ons/kernel/file_systems/btrfs/btrfs.h

    diff --git a/src/add-ons/kernel/file_systems/btrfs/btrfs.h b/src/add-ons/kernel/file_systems/btrfs/btrfs.h
    index c3e6ad5..51a6886 100644
    a b  
    66#define BTRFS_H
    77
    88
    9 #include <sys/stat.h>
     9#include "system_dependencies.h"
    1010
    11 #include <ByteOrder.h>
    12 #include <fs_interface.h>
    13 #include <KernelExport.h>
    1411
    15 
    16 typedef uint64 fileblock_t;     // file block number
    17 typedef uint64 fsblock_t;       // filesystem block number
     12typedef uint64 fileblock_t; // file block number
     13typedef uint64 fsblock_t;   // filesystem block number
    1814
    1915
    2016#define BTRFS_SUPER_BLOCK_OFFSET    0x10000
    struct btrfs_key {  
    2319    uint64  object_id;
    2420    uint8   type;
    2521    uint64  offset;
    26    
    2722    uint64  ObjectID() const { return B_LENDIAN_TO_HOST_INT64(object_id); }
    2823    uint8   Type() const { return type; }
    2924    uint64  Offset() const { return B_LENDIAN_TO_HOST_INT64(offset); }
    struct btrfs_key {  
    3227    void SetOffset(uint64 off) { offset = B_HOST_TO_LENDIAN_INT64(off); }
    3328} _PACKED;
    3429
     30
    3531struct btrfs_timespec {
    3632    uint64  seconds;
    3733    uint32  nanoseconds;
    3834} _PACKED;
    3935
     36
    4037struct btrfs_header {
    4138    uint8   checksum[32];
    4239    uint8   fsid[16];
    struct btrfs_header {  
    5047    uint64 BlockNum() const { return B_LENDIAN_TO_HOST_INT64(blocknum); }
    5148    uint64 Flags() const { return B_LENDIAN_TO_HOST_INT64(flags); }
    5249    uint64 Generation() const {
    53         return B_LENDIAN_TO_HOST_INT64(generation); }
     50            return B_LENDIAN_TO_HOST_INT64(generation); }
    5451    uint64 Owner() const {
    55         return B_LENDIAN_TO_HOST_INT64(owner); }
     52            return B_LENDIAN_TO_HOST_INT64(owner); }
    5653    uint32 ItemCount() const {
    57         return B_LENDIAN_TO_HOST_INT32(item_count); }
     54            return B_LENDIAN_TO_HOST_INT32(item_count); }
    5855    uint8 Level() const { return level; }
    5956} _PACKED;
    6057
     58
    6159struct btrfs_index {
    6260    btrfs_key key;
    6361    uint64  blocknum;
    6462    uint64  generation;
    6563    uint64 BlockNum() const { return B_LENDIAN_TO_HOST_INT64(blocknum); }
    6664    uint64 Generation() const {
    67         return B_LENDIAN_TO_HOST_INT64(generation); }
     65            return B_LENDIAN_TO_HOST_INT64(generation); }
    6866} _PACKED;
    6967
     68
    7069struct btrfs_entry {
    7170    btrfs_key key;
    7271    uint32 offset;
    7372    uint32 size;
    7473    uint32 Offset() const {
    75         return B_LENDIAN_TO_HOST_INT32(offset); }
     74            return B_LENDIAN_TO_HOST_INT32(offset); }
    7675    uint32 Size() const {
    77         return B_LENDIAN_TO_HOST_INT32(size); }
     76            return B_LENDIAN_TO_HOST_INT32(size); }
    7877} _PACKED;
    7978
     79
    8080struct btrfs_stream {
    8181    btrfs_header header;
    8282    union {
    struct btrfs_stream {  
    8585    };
    8686} _PACKED;
    8787
     88
    8889struct btrfs_stripe {
    8990    uint64  device_id;
    9091    uint64  offset;
    struct btrfs_stripe {  
    9394    uint64  Offset() const { return B_LENDIAN_TO_HOST_INT64(offset); }
    9495} _PACKED;
    9596
     97
    9698struct btrfs_chunk {
    9799    uint64  length;
    98100    uint64  owner;
    struct btrfs_chunk {  
    107109    uint64 Length() const { return B_LENDIAN_TO_HOST_INT64(length); }
    108110    uint64 Owner() const { return B_LENDIAN_TO_HOST_INT64(owner); }
    109111    uint64 StripeLength() const
    110         { return B_LENDIAN_TO_HOST_INT64(stripe_length); }
     112            { return B_LENDIAN_TO_HOST_INT64(stripe_length); }
    111113    uint64 Type() const { return B_LENDIAN_TO_HOST_INT64(type); }
    112114    uint32 IOAlign() const { return B_LENDIAN_TO_HOST_INT32(io_align); }
    113115    uint32 IOWidth() const { return B_LENDIAN_TO_HOST_INT32(io_width); }
    114116    uint32 SectorSize() const
    115         { return B_LENDIAN_TO_HOST_INT32(sector_size); }
     117            { return B_LENDIAN_TO_HOST_INT32(sector_size); }
    116118    uint16 StripeCount() const
    117         { return B_LENDIAN_TO_HOST_INT16(stripe_count); }
     119            { return B_LENDIAN_TO_HOST_INT16(stripe_count); }
    118120    uint16 SubStripes() const
    119         { return B_LENDIAN_TO_HOST_INT16(sub_stripes); }
     121            { return B_LENDIAN_TO_HOST_INT16(sub_stripes); }
    120122} _PACKED;
    121123
     124
    122125struct btrfs_device {
    123126    uint64  id;
    124127    uint64  total_size;
    struct btrfs_super_block {  
    171174    uint8   system_chunk_array[2048];
    172175
    173176    bool IsValid();
    174         // implemented in Volume.cpp
     177            // implemented in Volume.cpp
    175178    uint64 TotalSize() const { return B_LENDIAN_TO_HOST_INT64(total_size); }
    176179    uint32 BlockSize() const { return B_LENDIAN_TO_HOST_INT32(sector_size); }
    177180    uint64 RootDirObjectID() const {
    178         return B_LENDIAN_TO_HOST_INT64(root_dir_object_id); }
     181            return B_LENDIAN_TO_HOST_INT64(root_dir_object_id); }
    179182    uint64 Generation() const {
    180         return B_LENDIAN_TO_HOST_INT64(generation); }
     183            return B_LENDIAN_TO_HOST_INT64(generation); }
    181184    uint64 Root() const {
    182         return B_LENDIAN_TO_HOST_INT64(root); }
     185            return B_LENDIAN_TO_HOST_INT64(root); }
    183186    uint64 ChunkRoot() const {
    184         return B_LENDIAN_TO_HOST_INT64(chunk_root); }
     187            return B_LENDIAN_TO_HOST_INT64(chunk_root); }
    185188    uint64 LogRoot() const {
    186         return B_LENDIAN_TO_HOST_INT64(log_root); }
     189            return B_LENDIAN_TO_HOST_INT64(log_root); }
    187190    uint8 ChunkRootLevel() const { return chunk_root_level; }
    188191} _PACKED;
    189192
     193
    190194struct btrfs_inode {
    191195    uint64  generation;
    192196    uint64  transaction_id;
    struct btrfs_inode {  
    212216    uint32 Mode() const { return B_LENDIAN_TO_HOST_INT32(mode); }
    213217    uint64 Flags() const { return B_LENDIAN_TO_HOST_INT64(flags); }
    214218    uint64 Sequence() const { return B_LENDIAN_TO_HOST_INT64(sequence); }
    215     static void _DecodeTime(struct timespec &timespec,
    216         const struct btrfs_timespec &time)
     219    static void _DecodeTime(struct timespec& timespec,
     220        const struct btrfs_timespec& time)
    217221    {
    218222        timespec.tv_sec = B_LENDIAN_TO_HOST_INT64(time.seconds);
    219223        timespec.tv_nsec = B_LENDIAN_TO_HOST_INT32(time.nanoseconds);
    220224    }
    221     void GetAccessTime(struct timespec &timespec) const
    222         { _DecodeTime(timespec, access_time); }
    223     void GetChangeTime(struct timespec &timespec) const
    224         { _DecodeTime(timespec, change_time); }
    225     void GetModificationTime(struct timespec &timespec) const
    226         { _DecodeTime(timespec, modification_time); }
    227     void GetCreationTime(struct timespec &timespec) const
    228         { _DecodeTime(timespec, creation_time); }
     225    void GetAccessTime(struct timespec& timespec) const
     226            { _DecodeTime(timespec, access_time); }
     227    void GetChangeTime(struct timespec& timespec) const
     228            { _DecodeTime(timespec, change_time); }
     229    void GetModificationTime(struct timespec& timespec) const
     230            { _DecodeTime(timespec, modification_time); }
     231    void GetCreationTime(struct timespec& timespec) const
     232            { _DecodeTime(timespec, creation_time); }
    229233} _PACKED;
    230234
     235
    231236struct btrfs_root {
    232237    btrfs_inode inode;
    233238    uint64  generation;
    struct btrfs_root {  
    242247    uint8   drop_level;
    243248    uint8   level;
    244249    uint64 Generation() const {
    245         return B_LENDIAN_TO_HOST_INT64(generation); }
     250            return B_LENDIAN_TO_HOST_INT64(generation); }
    246251    uint64 BlockNum() const { return B_LENDIAN_TO_HOST_INT64(blocknum); }
    247252} _PACKED;
    248253
     254
    249255struct btrfs_dir_entry {
    250256    btrfs_key location;
    251257    uint64  transaction_id;
    struct btrfs_dir_entry {  
    256262    uint16 NameLength() const { return B_LENDIAN_TO_HOST_INT16(name_length); }
    257263    ino_t InodeID() const { return location.ObjectID(); }
    258264    uint16 Length() const
    259         { return sizeof(*this) + NameLength() + DataLength(); }
     265            { return sizeof(*this) + NameLength() + DataLength(); }
    260266} _PACKED;
    261267
     268
    262269struct btrfs_extent_data {
    263270    uint64  generation;
    264271    uint64  memory_size;
    struct btrfs_extent_data {  
    276283        uint8 inline_data[0];
    277284    };
    278285    uint64 Generation() const {
    279         return B_LENDIAN_TO_HOST_INT64(generation); }
     286            return B_LENDIAN_TO_HOST_INT64(generation); }
    280287    uint64 MemoryBytes() const {
    281         return B_LENDIAN_TO_HOST_INT64(memory_size); }
     288            return B_LENDIAN_TO_HOST_INT64(memory_size); }
    282289    uint8 Compression() const { return compression; }
    283290    uint8 Type() const { return type; }
    284291    uint64 DiskOffset() const {
    285         return B_LENDIAN_TO_HOST_INT64(disk_offset); }
     292            return B_LENDIAN_TO_HOST_INT64(disk_offset); }
    286293    uint64 DiskSize() const {
    287         return B_LENDIAN_TO_HOST_INT64(disk_size); }
     294            return B_LENDIAN_TO_HOST_INT64(disk_size); }
    288295    uint64 ExtentOffset() const {
    289         return B_LENDIAN_TO_HOST_INT64(extent_offset); }
     296            return B_LENDIAN_TO_HOST_INT64(extent_offset); }
    290297    uint64 Size() const {
    291         return B_LENDIAN_TO_HOST_INT64(size); }
     298            return B_LENDIAN_TO_HOST_INT64(size); }
    292299} _PACKED;
    293300
    294301
  • src/add-ons/kernel/file_systems/btrfs/crc_table.cpp

    diff --git a/src/add-ons/kernel/file_systems/btrfs/crc_table.cpp b/src/add-ons/kernel/file_systems/btrfs/crc_table.cpp
    index b5de8bd..19a0f80 100644
    a b  
    77
    88/*! \file crc_table.cpp
    99
    10         Standalone program to generate the CRC table used for calculating
    11         UDF tag id CRC values.
    12        
    13         This code based off of crc code in UDF-2.50 specs, as permitted.
    14         See UDF-2.50 6.5 for more information.
     10    Standalone program to generate the CRC table used for calculating
     11    UDF tag id CRC values.
    1512
    16         Reflected version by Jéme Duval
     13    This code based off of crc code in UDF-2.50 specs, as permitted.
     14    See UDF-2.50 6.5 for more information.
     15
     16    Reflected version by Jéme Duval
    1717*/
    1818
    19 #include <stdio.h>
    20 #include <sys/types.h>
     19
     20#include "system_dependencies.h"
    2121
    2222typedef unsigned int uint32 ;
    2323
    reflect32 (uint32 b)  
    3636
    3737
    3838int
    39 main(int argc, char *argv[]) {
    40         uint32 crc, poly;
     39main(int argc, char* argv[]) {
     40    uint32 crc, poly;
    4141
    42         if (argc != 2) {
    43                 fprintf(stderr, "USAGE: crc_table <octal polynomial=3667067501 for btrfs>\n");
    44                 return 0;
    45         }
     42    if (argc != 2) {
     43        fprintf(stderr, "USAGE: crc_table <octal polynomial=3667067501 for btrfs>\n");
     44        return 0;
     45    }
    4646
    47         sscanf(argv[1], "%lo", &poly);
    48       
    49         printf("//! CRC 0%o table, as generated by crc_table.cpp\n", poly);
    50         printf("static uint32 crc_table[256] = { \n");
    51         for (int n = 0; n < 256; n++) {
    52                 if (n%8 == 0)
    53                         printf("    ");
    54                 crc = reflect32(n);
    55                 for (int i = 0; i < 8; i++) {
    56                         if (crc & 0x80000000)
    57                                 crc = (crc << 1) ^ poly;
    58                         else
    59                                 crc <<= 1;
    60                 }
     47    sscanf(argv[1], "%lo", &poly);
     48   
     49    printf("//! CRC 0%o table, as generated by crc_table.cpp\n", poly);
     50    printf("static uint32 crc_table[256] = { \n");
     51    for (int n = 0; n < 256; n++) {
     52        if (n % 8 == 0)
     53            printf("    ");
     54        crc = reflect32(n);
     55        for (int i = 0; i < 8; i++) {
     56            if (crc & 0x80000000)
     57                crc = (crc << 1) ^ poly;
     58            else
     59                crc <<= 1;
     60        }
    6161        crc = reflect32(crc);
    62                 printf("0x%08x%s ", crc, (n != 255 ? "," : ""));
    63                 if (n%8 == 7)
    64                         printf("\n");
    65         }
    66         printf("};\n");
    67         return 0;
     62        printf("0x%08x%s ", crc, (n != 255 ? "," : ""));
     63        if (n % 8 == 7)
     64            printf("\n");
     65    }
     66    printf("};\n");
     67    return 0;
    6868}
  • src/add-ons/kernel/file_systems/btrfs/kernel_interface.cpp

    diff --git a/src/add-ons/kernel/file_systems/btrfs/kernel_interface.cpp b/src/add-ons/kernel/file_systems/btrfs/kernel_interface.cpp
    index 3ab3765..e361a18 100644
    a b  
    55 */
    66
    77
    8 #include <dirent.h>
    9 #include <util/kernel_cpp.h>
    10 #include <string.h>
    11 
    12 #include <AutoDeleter.h>
    13 #include <fs_cache.h>
    14 #include <fs_info.h>
    15 #include <io_requests.h>
    16 #include <NodeMonitor.h>
    17 #include <util/AutoLock.h>
    18 
    198#include "Attribute.h"
    209#include "AttributeIterator.h"
    2110#include "btrfs.h"
    iterative_io_finished_hook(void* cookie, io_request* request, status_t status,  
    6857
    6958
    7059static float
    71 btrfs_identify_partition(int fd, partition_data *partition, void **_cookie)
     60btrfs_identify_partition(int fd, partition_data* partition, void** _cookie)
    7261{
    7362    btrfs_super_block superBlock;
    7463    status_t status = Volume::Identify(fd, &superBlock);
    7564    if (status != B_OK)
    7665        return -1;
    7766
    78     identify_cookie *cookie = new identify_cookie;
     67    identify_cookie* cookie = new identify_cookie;
    7968    memcpy(&cookie->super_block, &superBlock, sizeof(btrfs_super_block));
    8069
    8170    *_cookie = cookie;
    btrfs_identify_partition(int fd, partition_data *partition, void **_cookie)  
    8473
    8574
    8675static status_t
    87 btrfs_scan_partition(int fd, partition_data *partition, void *_cookie)
     76btrfs_scan_partition(int fd, partition_data* partition, void* _cookie)
    8877{
    89     identify_cookie *cookie = (identify_cookie *)_cookie;
     78    identify_cookie* cookie = (identify_cookie*)_cookie;
    9079
    9180    partition->status = B_PARTITION_VALID;
    9281    partition->flags |= B_PARTITION_FILE_SYSTEM;
    btrfs_mount(fs_volume* _volume, const char* device, uint32 flags,  
    138127
    139128
    140129static status_t
    141 btrfs_unmount(fs_volume *_volume)
     130btrfs_unmount(fs_volume* _volume)
    142131{
    143     Volume* volume = (Volume *)_volume->private_volume;
     132    Volume* volume = (Volume*)_volume->private_volume;
    144133
    145134    status_t status = volume->Unmount();
    146135    delete volume;
    btrfs_io(fs_volume* _volume, fs_vnode* _node, void* _cookie, io_request* request  
    266255    Volume* volume = (Volume*)_volume->private_volume;
    267256    Inode* inode = (Inode*)_node->private_node;
    268257
    269 #ifndef BTRFS_SHELL
     258#ifndef FS_SHELL
    270259    if (io_request_is_write(request) && volume->IsReadOnly()) {
    271260        notify_io_request(request, B_READ_ONLY_DEVICE);
    272261        return B_READ_ONLY_DEVICE;
    btrfs_io(fs_volume* _volume, fs_vnode* _node, void* _cookie, io_request* request  
    274263#endif
    275264
    276265    if (inode->FileCache() == NULL) {
    277 #ifndef BTRFS_SHELL
     266#ifndef FS_SHELL
    278267        notify_io_request(request, B_BAD_VALUE);
    279268#endif
    280269        return B_BAD_VALUE;
    btrfs_read(fs_volume* _volume, fs_vnode* _node, void* _cookie, off_t pos,  
    452441
    453442
    454443static status_t
    455 btrfs_close(fs_volume *_volume, fs_vnode *_node, void *_cookie)
     444btrfs_close(fs_volume* _volume, fs_vnode* _node, void* _cookie)
    456445{
    457446    return B_OK;
    458447}
    btrfs_access(fs_volume* _volume, fs_vnode* _node, int accessMode)  
    482471
    483472
    484473static status_t
    485 btrfs_read_link(fs_volume *_volume, fs_vnode *_node, char *buffer,
    486     size_t *_bufferSize)
     474btrfs_read_link(fs_volume* _volume, fs_vnode* _node, char* buffer,
     475    size_t* _bufferSize)
    487476{
    488477    Inode* inode = (Inode*)_node->private_node;
    489478    return inode->ReadAt(0, (uint8*)buffer, _bufferSize);
    btrfs_open_dir(fs_volume* /*_volume*/, fs_vnode* _node, void** _cookie)  
    516505
    517506
    518507static status_t
    519 btrfs_read_dir(fs_volume *_volume, fs_vnode *_node, void *_cookie,
    520     struct dirent *dirent, size_t bufferSize, uint32 *_num)
     508btrfs_read_dir(fs_volume* _volume, fs_vnode* _node, void* _cookie,
     509    struct dirent* dirent, size_t bufferSize, uint32* _num)
    521510{
    522511    DirectoryIterator* iterator = (DirectoryIterator*)_cookie;
    523512    Volume* volume = (Volume*)_volume->private_volume;
    btrfs_read_dir(fs_volume *_volume, fs_vnode *_node, void *_cookie,  
    560549
    561550
    562551static status_t
    563 btrfs_rewind_dir(fs_volume * /*_volume*/, fs_vnode * /*node*/, void *_cookie)
     552btrfs_rewind_dir(fs_volume* /*_volume*/, fs_vnode* /*node*/, void* _cookie)
    564553{
    565554    DirectoryIterator* iterator = (DirectoryIterator*)_cookie;
    566555
    btrfs_close_dir(fs_volume * /*_volume*/, fs_vnode * /*node*/, void * /*_cookie*/  
    576565
    577566
    578567static status_t
    579 btrfs_free_dir_cookie(fs_volume *_volume, fs_vnode *_node, void *_cookie)
     568btrfs_free_dir_cookie(fs_volume* _volume, fs_vnode* _node, void* _cookie)
    580569{
    581570    delete (DirectoryIterator*)_cookie;
    582571    return B_OK;
    btrfs_free_dir_cookie(fs_volume *_volume, fs_vnode *_node, void *_cookie)  
    584573
    585574
    586575static status_t
    587 btrfs_open_attr_dir(fs_volume *_volume, fs_vnode *_node, void **_cookie)
     576btrfs_open_attr_dir(fs_volume* _volume, fs_vnode* _node, void** _cookie)
    588577{
    589578    Inode* inode = (Inode*)_node->private_node;
    590579    TRACE("%s()\n", __FUNCTION__);
    btrfs_write_attr(fs_volume* _volume, fs_vnode* _node, void* cookie,  
    716705}
    717706
    718707
    719 
    720708static status_t
    721709btrfs_read_attr_stat(fs_volume* _volume, fs_vnode* _node,
    722710    void* _cookie, struct stat* stat)
    static file_system_module_info sBtrfsFileSystem = {  
    859847};
    860848
    861849
    862 module_info *modules[] = {
    863     (module_info *)&sBtrfsFileSystem,
     850module_info* modules[] = {
     851    (module_info*)&sBtrfsFileSystem,
    864852    NULL,
    865853};
  • new file src/add-ons/kernel/file_systems/btrfs/system_dependencies.h

    diff --git a/src/add-ons/kernel/file_systems/btrfs/system_dependencies.h b/src/add-ons/kernel/file_systems/btrfs/system_dependencies.h
    new file mode 100644
    index 0000000..3ac50b5
    - +  
     1#ifndef _SYSTEM_DEPENDENCIES_H
     2#define _SYSTEM_DEPENDENCIES_H
     3
     4
     5#ifdef FS_SHELL
     6
     7#include <zlib.h>
     8#include <new>
     9
     10#include "fssh_api_wrapper.h"
     11#include "fssh_auto_deleter.h"
     12
     13#else   // !FS_SHELL
     14
     15#include <AutoDeleter.h>
     16#include <util/kernel_cpp.h>
     17#include <util/AutoLock.h>
     18#include <util/SinglyLinkedList.h>
     19#include <util/Stack.h>
     20#include <sys/stat.h>
     21#include <sys/types.h>
     22#include <ByteOrder.h>
     23#include <fs_cache.h>
     24#include <fs_interface.h>
     25#include <fs_info.h>
     26#include <fs_volume.h>
     27#include <KernelExport.h>
     28#include <io_requests.h>
     29#include <NodeMonitor.h>
     30#include <SupportDefs.h>
     31#include <lock.h>
     32#include <errno.h>
     33#include <new>
     34#include <dirent.h>
     35#include <string.h>
     36#include <stdio.h>
     37#include <stdlib.h>
     38#include <unistd.h>
     39#include <zlib.h>
     40
     41#endif  // !FS_SHELL
     42
     43
     44#endif  // _SYSTEM_DEPENDENCIES