ROOT logo
#ifndef  __HDISKSPACE_H__
#define  __HDISKSPACE_H__

#include "TSystem.h"
#include "TString.h"
#include "TObjArray.h"
#include "TGraph.h"
#include "TCanvas.h"
#include <iostream>
#include <iomanip>
#include <sys/stat.h>
#include <dirent.h>
#include <pwd.h>
#include <grp.h>
#include <vector>
#include <map>
#include <cstring>
#include <sstream>


using namespace std;

class  HDiskCatalog ;

R__EXTERN HDiskCatalog *gHDiskCatalog;


typedef struct stat mystat;

/*
class HTeeBuf: public std::streambuf
{

private:
    std::streambuf * sb1;
    std::streambuf * sb2;

    // This tee buffer has no buffer. So every character "overflows"
    // and can be put directly into the teed buffers.
    virtual int overflow(int c)
    {
        if (c == EOF)
        {
            return !EOF;
        }
        else
        {
            int const r1 = sb1->sputc(c);
            int const r2 = sb2->sputc(c);
            return r1 == EOF || r2 == EOF ? EOF : c;
        }
    }
    
    // Sync both teed buffers.
    virtual int sync()
    {
        int const r1 = sb1->pubsync();
        int const r2 = sb2->pubsync();
        return r1 == 0 && r2 == 0 ? 0 : -1;
    }   



public:
    // Construct a streambuf which tees output to both input
    // streambufs.
    HTeeBuf(std::streambuf * sb1, std::streambuf * sb2)
	: sb1(sb1)
    , sb2(sb2)
    {
    }


};
*/


class HRedirect
{
    // redirects cout to log file
    // redirects ends when destructor is called

private:

    std::ostream*   streamIn;
    std::streambuf* streamInBuffer;

    std::ostream*   streamOut;
    std::streambuf* streamOutBuffer;

public:

    HRedirect(std::ostream* inOriginal, std::ostream* inRedirect)
    {
	streamIn       = inOriginal;
	streamInBuffer = inOriginal->rdbuf();
	streamOut      = inRedirect;
	streamOutBuffer= inRedirect->rdbuf();
	inOriginal->rdbuf(inRedirect->rdbuf());
    }

    ~HRedirect()
    {
       streamIn ->rdbuf(streamInBuffer);
       streamOut->rdbuf(streamOutBuffer);
    }

};




class HFileSys {
private:

    static ULong64_t unitK ;
    static ULong64_t unitM ;
    static ULong64_t unitG ;
    static ULong64_t unitT ;
    static ULong64_t SmallerLimit ; //!
    static map<uid_t,TString> musers;
    static map<gid_t,TString> mgroups;
    static map<uid_t,TString>  initUsers();
    static map<gid_t,TString>  initGroups();

public:
    static ULong64_t           getSmallerLimit() { return SmallerLimit;}
    static map<uid_t,TString>& getUserMap()      { return musers;  }
    static map<gid_t,TString>& getGroupMap()     { return mgroups; }

    static void                setUnit(ULong64_t u) { unitK = u; unitM=u*u; unitG=unitM*u; unitT=unitG*u; }
    static ULong64_t           getUnitK()           { return unitK;}
    static ULong64_t           getUnitT()           { return unitT;}
    static ULong64_t           getUnitG()           { return unitG;}
    static ULong64_t           getUnitM()           { return unitM;}

    static void                getUsers(map<uid_t,TString>& musers);
    static void                getGroups(map<gid_t,TString>& mgroups);
    static void                fillSysInfo();
    static Bool_t              getUser(uid_t uid,TString& name);
    static Bool_t              getGroup(gid_t gid,TString& name);
    static void                getModTime(time_t lastmod,TString& modtime);
    static void                getFileSize(ULong64_t size, TString& out);
    static void                lsFiles(TString directory, vector<TString>& fileList,Bool_t clear=kTRUE,Bool_t fullpath=kFALSE);
    static void                lsFilesRecursive(TString directory, vector<TString>&fullList);
    static void                lsDirectory(TString directory, vector<TString>& fileList);
    static void                lsDirectoryRecursive(TString directory, vector<TString>&fullList);

};

class  HDiskFile : public TNamed {

private:

    ULong64_t size;             // size in byte
    UInt_t    group;
    UInt_t    owner;
    time_t    lastmod;
    UInt_t    dir;
public:

    HDiskFile(TString name="");
    ~HDiskFile();
    ULong64_t getSize()                { return size; }
    UInt_t    getGroup()               { return group ; }
    UInt_t    getOwner()               { return owner; }
    time_t    getLastMod()             { return lastmod;}
    UInt_t    getDir()                 { return dir; }
    void      setSize   (ULong64_t sz) { size  = sz ; }
    void      setGroup  (UInt_t gid)   { group   = gid ; }
    void      setOwner  (UInt_t uid)   { owner   = uid;  }
    void      setLastMod(time_t mod)   { lastmod = mod; }
    void      setDir(UInt_t ind)       { dir =ind; }
    void      print    (Int_t sp=0);
    Bool_t    isToSmall()            { if(size<HFileSys::getSmallerLimit()) return kTRUE; else return kFALSE;}

    ClassDef(HDiskFile,1)
};



class  HDiskDir : public TNamed {


private:

    ULong64_t size;             // size in byte
    UInt_t    group;            // system gid
    UInt_t    owner;            // system uid
    time_t    lastmod;
    UInt_t    nFilesSmallerLimit;
    UInt_t    nFilesSmallerLimitTotal;
    UInt_t    nFilesTotal;
    UInt_t    nEmptyDirs;
    UInt_t    nDirsTotal;
    UInt_t    nEmptyDirsTotal;
    UChar_t   level;
    UInt_t    mother;
    vector<HDiskFile> files;
    vector<Int_t>     dirs;
    void   update         (HDiskDir* mother);
    void   updateRecursive(HDiskDir* daughter,HDiskDir* mother);

public:

    HDiskDir(TString name="");
    ~HDiskDir();
    ULong64_t          getSize()                      { return size; }
    UInt_t             getGroup()                     { return group; }
    UInt_t             getOwner()                     { return owner; }
    time_t             getLastMod()                   { return lastmod;}
    UInt_t             getNFiles()                    { return files.size();}
    UInt_t             getNFilesTotal()               { return nFilesTotal;}
    UInt_t             getNSmallFiles()               { return nFilesSmallerLimit;}
    UInt_t             getNSmallFilesTotal()          { return nFilesSmallerLimitTotal;}
    UInt_t             getNEmptyDirs()                { return nEmptyDirs;}
    UInt_t             getNDirsTotal()                { return nDirsTotal;}
    UInt_t             getNEmptyDirsTotal()           { return nEmptyDirsTotal;}
    UInt_t             getNDirs()                     { return dirs.size();}
    UChar_t            getLevel()                     { return level;}
    UInt_t             getMother()                    { return mother; }
    vector<HDiskFile>& getFiles()                     { return files;}
    vector<Int_t>&     getDirs()                      { return dirs;}

    void               setSize   (ULong64_t sz)       { size = sz; }
    void               setGroup  (UInt_t gid)         { group = gid; }
    void               setOwner  (UInt_t uid)         { owner = uid;  }
    void               setLastMod(time_t mod)         { lastmod = mod; }
    void               setNFilesTotal(UInt_t n)       { nFilesTotal = n;}
    void               setNSmallFiles(UInt_t n)       { nFilesSmallerLimit = n;}
    void               setNSmallFilesTotal(UInt_t n)  { nFilesSmallerLimitTotal = n;}
    void               setNEmptyDirs(UInt_t n)        { nEmptyDirs = n;}
    void               setNDirsTotal(UInt_t n)        { nDirsTotal = n;}
    void               setNEmptyDirsTotal(UInt_t n)   { nEmptyDirsTotal = n;}
    void               setLevel(UChar_t lvl)          { level = lvl;}
    void               setMother(UInt_t index)        { mother = index; }
    void               setDirToFiles(UInt_t index);

    void               addSize( ULong64_t sz)         { size += sz;}
    void               addNFilesTotal(UInt_t n)       { nFilesTotal += n;}
    void               addNSmallFiles(UInt_t n)       { nFilesSmallerLimit += n;}
    void               addNSmallFilesTotal(UInt_t n)  { nFilesSmallerLimitTotal += n;}
    void               addNEmptyDirs(UInt_t n)        { nEmptyDirs += n;}
    void               addNDirsTotal(UInt_t n)        { nDirsTotal += n;}
    void               addNEmptyDirsTotal(UInt_t n)   { nEmptyDirsTotal += n;}
    void               addFile(HDiskFile f)           { files.push_back(f); }
    void               addDir (Int_t index)           { dirs .push_back(index); }
    void               resetDirs()                    { dirs .clear();}

    void               update();
    void               print     (Int_t sp=0, TString base="");
    void               printFiles(Int_t sp=0);
    void               printDirs (Int_t sp=0, TString base="");
    Bool_t             scan(UInt_t indDir);
    Bool_t             scan(mystat& statu, UInt_t index,vector<TString>& dirList);
    Bool_t             isDaughter(HDiskDir* mother);
    Bool_t             isEmpty() { if(files.size()==0&&dirs.size()==0) return kTRUE; else return kFALSE;}
    ClassDef(HDiskDir,1)
};


class  HDiskCatalog : public TNamed {
private:


    TString diskname;
    TObjArray*  list; //!

    map<uid_t,TString> musers;
    map<gid_t,TString> mgroups;

    time_t lastScanStart;
    time_t lastScanStop;
    map<TString,Int_t>     mDirToInd;
    Int_t nSplit;

    //-------------------------------------------
    // temp helpers for scan
    map<TString,HDiskDir*> mDirOld; //!
    Int_t fnfiles;        //!
    Int_t fnfilestotal;   //!
    Int_t fndirs;         //!
    TObjArray*  flisttmp; //!
    struct stat status ;  //!
    //-------------------------------------------

    static Bool_t cmpName       (HDiskDir*, HDiskDir*);
    static Bool_t cmpSize       (HDiskDir*, HDiskDir*);
    static Bool_t cmpNFiles     (HDiskDir*, HDiskDir*);
    static Bool_t cmpNSmallFiles(HDiskDir*, HDiskDir*);
    static Bool_t cmpNFilesRatio(HDiskDir*, HDiskDir*);
    HDiskDir* getDir(TString name, TObjArray* listtmp,Int_t* ind);
    void      addDir(TString n, Int_t ind)  { if(mDirToInd.find(n) == mDirToInd.end()) mDirToInd[n] = ind;}
    Int_t     getDirMap(TString n)             {
	map<TString,Int_t>::iterator it = mDirToInd.find(n);
	if(it==mDirToInd.end()) return -1;
	else                    return it->second;
    }
    HDiskDir* getDirMapOld(TString n) {
	map<TString,HDiskDir*>::iterator it = mDirOld.find(n);
	if(it==mDirOld.end()) return 0;
	else                  return it->second;
    }
    void loopDirectory         (TString directory, vector<TString>& dirList);
    void loopDirectoryRecursive(TString directory);

public:
    HDiskCatalog(TString name="");

    ~HDiskCatalog ();
    TString              getDiskName()                        { return diskname;}
    TObjArray*           getList()                            { return list;}
    time_t               getLastScanStart()                   { return lastScanStart;}
    time_t               getLastScanStop()                    { return lastScanStop;}
    map<uid_t,TString>&  getUserMap()                         { return musers;}
    map<gid_t,TString>&  getGroupMap()                        { return mgroups;}
    Bool_t               getUser   (uid_t uid,TString& name);
    Bool_t               getGroup  (gid_t gid,TString& name);

    void                 setLastScanStart(time_t t)           { lastScanStart = t;}
    void                 setLastScanStop(time_t t)            { lastScanStop  = t;}
    void                 setUserMap (map<uid_t,TString>& mu)  { musers = mu;}
    void                 setGroupMap(map<gid_t,TString>& mg)  { mgroups = mg;}
    void                 setCurrentCatalog()                  { gHDiskCatalog = this;}
    Bool_t               scan();
    Int_t                addDir(HDiskDir* dir);
    void                 updateDirIndices();


    HDiskDir*            getDir                  (TString name,Int_t* ind=0);
    void                 getDaughterDirs         (HDiskDir* dir, vector<HDiskDir*>& daughters);
    void                 getDaughterDirsRecursive(HDiskDir* dir, vector<HDiskDir*>& daughters);
    void                 sortDirs                (HDiskDir* dir, vector<HDiskDir*>& daughters,TString option);
    void                 sortDirsRecursive       (HDiskDir* dir, vector<HDiskDir*>& daughters,TString option);
    void                 print                   (UChar_t maxlevel=255);
    void                 printDisk               (UChar_t maxlevel=255,TString option="size",Int_t nfill=0,TString filler=" ");
    void                 printExecution();
    UInt_t               filterDirs              (TString regexp,vector<HDiskDir*>& dirs,TString range1S="",TString range2S="",Long64_t size=0);
    UInt_t               filterFiles             (TString regexpdir,TString regexpfile,vector<HDiskFile*>& files,TString range1S="",TString range2S="",Long64_t size=0);
    void                 printDirs               (TString regexp,TString range1S="",TString range2S="",Long64_t size=0);
    void                 printFiles              (TString regexpdir,TString regexpfile,TString range1S="",TString range2S="",Long64_t size=0);
    ClassDef(HDiskCatalog,1)
};


class HDiskStat : public TNamed {
private:

    map<TString,vector<TGraph> > mDirToVal;
    vector<Int_t> vcolors;
    vector<Int_t> vmarkers;
    vector<Int_t> vstyles;
    Int_t evalOpt(TString opt);
    ULong64_t unit;
    TString diskname;

public:
    HDiskStat(TString name="");
    ~HDiskStat();

    void            setDiskName(TString name) { diskname = name;}
    void            setUnit(ULong64_t u)      {unit = u;}

    TString         getDiskName()  {return diskname;}
    TGraph*         getDir         (TString dirname,TString opt="size");
    vector<TGraph>* getDirVec      (TString dirname);
    void            addEntry       (time_t scanstart,HDiskDir* dir);
    Bool_t          findMinMaxGraph(Double_t& xmin,Double_t& xmax,Double_t& ymin,Double_t& ymax,TGraph* g);
    Bool_t          findMinMaxAll  (Double_t& xmin,Double_t& xmax,Double_t& ymin,Double_t& ymax,TString opt);
    Bool_t          findMinMaxAll  (Double_t& xmin,Double_t& xmax,Double_t& ymin,Double_t& ymax,vector<TGraph*>& vg);
    TCanvas*        draw(TString opt,UInt_t lastDays,ULong64_t u,TString select = "daughters");
    ClassDef(HDiskStat,1)
};


#endif /* !__HDISKSPACE_H__ */



 hdiskspace.h:1
 hdiskspace.h:2
 hdiskspace.h:3
 hdiskspace.h:4
 hdiskspace.h:5
 hdiskspace.h:6
 hdiskspace.h:7
 hdiskspace.h:8
 hdiskspace.h:9
 hdiskspace.h:10
 hdiskspace.h:11
 hdiskspace.h:12
 hdiskspace.h:13
 hdiskspace.h:14
 hdiskspace.h:15
 hdiskspace.h:16
 hdiskspace.h:17
 hdiskspace.h:18
 hdiskspace.h:19
 hdiskspace.h:20
 hdiskspace.h:21
 hdiskspace.h:22
 hdiskspace.h:23
 hdiskspace.h:24
 hdiskspace.h:25
 hdiskspace.h:26
 hdiskspace.h:27
 hdiskspace.h:28
 hdiskspace.h:29
 hdiskspace.h:30
 hdiskspace.h:31
 hdiskspace.h:32
 hdiskspace.h:33
 hdiskspace.h:34
 hdiskspace.h:35
 hdiskspace.h:36
 hdiskspace.h:37
 hdiskspace.h:38
 hdiskspace.h:39
 hdiskspace.h:40
 hdiskspace.h:41
 hdiskspace.h:42
 hdiskspace.h:43
 hdiskspace.h:44
 hdiskspace.h:45
 hdiskspace.h:46
 hdiskspace.h:47
 hdiskspace.h:48
 hdiskspace.h:49
 hdiskspace.h:50
 hdiskspace.h:51
 hdiskspace.h:52
 hdiskspace.h:53
 hdiskspace.h:54
 hdiskspace.h:55
 hdiskspace.h:56
 hdiskspace.h:57
 hdiskspace.h:58
 hdiskspace.h:59
 hdiskspace.h:60
 hdiskspace.h:61
 hdiskspace.h:62
 hdiskspace.h:63
 hdiskspace.h:64
 hdiskspace.h:65
 hdiskspace.h:66
 hdiskspace.h:67
 hdiskspace.h:68
 hdiskspace.h:69
 hdiskspace.h:70
 hdiskspace.h:71
 hdiskspace.h:72
 hdiskspace.h:73
 hdiskspace.h:74
 hdiskspace.h:75
 hdiskspace.h:76
 hdiskspace.h:77
 hdiskspace.h:78
 hdiskspace.h:79
 hdiskspace.h:80
 hdiskspace.h:81
 hdiskspace.h:82
 hdiskspace.h:83
 hdiskspace.h:84
 hdiskspace.h:85
 hdiskspace.h:86
 hdiskspace.h:87
 hdiskspace.h:88
 hdiskspace.h:89
 hdiskspace.h:90
 hdiskspace.h:91
 hdiskspace.h:92
 hdiskspace.h:93
 hdiskspace.h:94
 hdiskspace.h:95
 hdiskspace.h:96
 hdiskspace.h:97
 hdiskspace.h:98
 hdiskspace.h:99
 hdiskspace.h:100
 hdiskspace.h:101
 hdiskspace.h:102
 hdiskspace.h:103
 hdiskspace.h:104
 hdiskspace.h:105
 hdiskspace.h:106
 hdiskspace.h:107
 hdiskspace.h:108
 hdiskspace.h:109
 hdiskspace.h:110
 hdiskspace.h:111
 hdiskspace.h:112
 hdiskspace.h:113
 hdiskspace.h:114
 hdiskspace.h:115
 hdiskspace.h:116
 hdiskspace.h:117
 hdiskspace.h:118
 hdiskspace.h:119
 hdiskspace.h:120
 hdiskspace.h:121
 hdiskspace.h:122
 hdiskspace.h:123
 hdiskspace.h:124
 hdiskspace.h:125
 hdiskspace.h:126
 hdiskspace.h:127
 hdiskspace.h:128
 hdiskspace.h:129
 hdiskspace.h:130
 hdiskspace.h:131
 hdiskspace.h:132
 hdiskspace.h:133
 hdiskspace.h:134
 hdiskspace.h:135
 hdiskspace.h:136
 hdiskspace.h:137
 hdiskspace.h:138
 hdiskspace.h:139
 hdiskspace.h:140
 hdiskspace.h:141
 hdiskspace.h:142
 hdiskspace.h:143
 hdiskspace.h:144
 hdiskspace.h:145
 hdiskspace.h:146
 hdiskspace.h:147
 hdiskspace.h:148
 hdiskspace.h:149
 hdiskspace.h:150
 hdiskspace.h:151
 hdiskspace.h:152
 hdiskspace.h:153
 hdiskspace.h:154
 hdiskspace.h:155
 hdiskspace.h:156
 hdiskspace.h:157
 hdiskspace.h:158
 hdiskspace.h:159
 hdiskspace.h:160
 hdiskspace.h:161
 hdiskspace.h:162
 hdiskspace.h:163
 hdiskspace.h:164
 hdiskspace.h:165
 hdiskspace.h:166
 hdiskspace.h:167
 hdiskspace.h:168
 hdiskspace.h:169
 hdiskspace.h:170
 hdiskspace.h:171
 hdiskspace.h:172
 hdiskspace.h:173
 hdiskspace.h:174
 hdiskspace.h:175
 hdiskspace.h:176
 hdiskspace.h:177
 hdiskspace.h:178
 hdiskspace.h:179
 hdiskspace.h:180
 hdiskspace.h:181
 hdiskspace.h:182
 hdiskspace.h:183
 hdiskspace.h:184
 hdiskspace.h:185
 hdiskspace.h:186
 hdiskspace.h:187
 hdiskspace.h:188
 hdiskspace.h:189
 hdiskspace.h:190
 hdiskspace.h:191
 hdiskspace.h:192
 hdiskspace.h:193
 hdiskspace.h:194
 hdiskspace.h:195
 hdiskspace.h:196
 hdiskspace.h:197
 hdiskspace.h:198
 hdiskspace.h:199
 hdiskspace.h:200
 hdiskspace.h:201
 hdiskspace.h:202
 hdiskspace.h:203
 hdiskspace.h:204
 hdiskspace.h:205
 hdiskspace.h:206
 hdiskspace.h:207
 hdiskspace.h:208
 hdiskspace.h:209
 hdiskspace.h:210
 hdiskspace.h:211
 hdiskspace.h:212
 hdiskspace.h:213
 hdiskspace.h:214
 hdiskspace.h:215
 hdiskspace.h:216
 hdiskspace.h:217
 hdiskspace.h:218
 hdiskspace.h:219
 hdiskspace.h:220
 hdiskspace.h:221
 hdiskspace.h:222
 hdiskspace.h:223
 hdiskspace.h:224
 hdiskspace.h:225
 hdiskspace.h:226
 hdiskspace.h:227
 hdiskspace.h:228
 hdiskspace.h:229
 hdiskspace.h:230
 hdiskspace.h:231
 hdiskspace.h:232
 hdiskspace.h:233
 hdiskspace.h:234
 hdiskspace.h:235
 hdiskspace.h:236
 hdiskspace.h:237
 hdiskspace.h:238
 hdiskspace.h:239
 hdiskspace.h:240
 hdiskspace.h:241
 hdiskspace.h:242
 hdiskspace.h:243
 hdiskspace.h:244
 hdiskspace.h:245
 hdiskspace.h:246
 hdiskspace.h:247
 hdiskspace.h:248
 hdiskspace.h:249
 hdiskspace.h:250
 hdiskspace.h:251
 hdiskspace.h:252
 hdiskspace.h:253
 hdiskspace.h:254
 hdiskspace.h:255
 hdiskspace.h:256
 hdiskspace.h:257
 hdiskspace.h:258
 hdiskspace.h:259
 hdiskspace.h:260
 hdiskspace.h:261
 hdiskspace.h:262
 hdiskspace.h:263
 hdiskspace.h:264
 hdiskspace.h:265
 hdiskspace.h:266
 hdiskspace.h:267
 hdiskspace.h:268
 hdiskspace.h:269
 hdiskspace.h:270
 hdiskspace.h:271
 hdiskspace.h:272
 hdiskspace.h:273
 hdiskspace.h:274
 hdiskspace.h:275
 hdiskspace.h:276
 hdiskspace.h:277
 hdiskspace.h:278
 hdiskspace.h:279
 hdiskspace.h:280
 hdiskspace.h:281
 hdiskspace.h:282
 hdiskspace.h:283
 hdiskspace.h:284
 hdiskspace.h:285
 hdiskspace.h:286
 hdiskspace.h:287
 hdiskspace.h:288
 hdiskspace.h:289
 hdiskspace.h:290
 hdiskspace.h:291
 hdiskspace.h:292
 hdiskspace.h:293
 hdiskspace.h:294
 hdiskspace.h:295
 hdiskspace.h:296
 hdiskspace.h:297
 hdiskspace.h:298
 hdiskspace.h:299
 hdiskspace.h:300
 hdiskspace.h:301
 hdiskspace.h:302
 hdiskspace.h:303
 hdiskspace.h:304
 hdiskspace.h:305
 hdiskspace.h:306
 hdiskspace.h:307
 hdiskspace.h:308
 hdiskspace.h:309
 hdiskspace.h:310
 hdiskspace.h:311
 hdiskspace.h:312
 hdiskspace.h:313
 hdiskspace.h:314
 hdiskspace.h:315
 hdiskspace.h:316
 hdiskspace.h:317
 hdiskspace.h:318
 hdiskspace.h:319
 hdiskspace.h:320
 hdiskspace.h:321
 hdiskspace.h:322
 hdiskspace.h:323
 hdiskspace.h:324
 hdiskspace.h:325
 hdiskspace.h:326
 hdiskspace.h:327
 hdiskspace.h:328
 hdiskspace.h:329
 hdiskspace.h:330
 hdiskspace.h:331
 hdiskspace.h:332
 hdiskspace.h:333
 hdiskspace.h:334
 hdiskspace.h:335
 hdiskspace.h:336
 hdiskspace.h:337
 hdiskspace.h:338
 hdiskspace.h:339
 hdiskspace.h:340
 hdiskspace.h:341
 hdiskspace.h:342
 hdiskspace.h:343
 hdiskspace.h:344
 hdiskspace.h:345
 hdiskspace.h:346
 hdiskspace.h:347
 hdiskspace.h:348
 hdiskspace.h:349
 hdiskspace.h:350
 hdiskspace.h:351
 hdiskspace.h:352
 hdiskspace.h:353
 hdiskspace.h:354
 hdiskspace.h:355
 hdiskspace.h:356
 hdiskspace.h:357
 hdiskspace.h:358
 hdiskspace.h:359
 hdiskspace.h:360
 hdiskspace.h:361
 hdiskspace.h:362
 hdiskspace.h:363
 hdiskspace.h:364
 hdiskspace.h:365
 hdiskspace.h:366
 hdiskspace.h:367
 hdiskspace.h:368
 hdiskspace.h:369
 hdiskspace.h:370
 hdiskspace.h:371
 hdiskspace.h:372
 hdiskspace.h:373
 hdiskspace.h:374
 hdiskspace.h:375
 hdiskspace.h:376
 hdiskspace.h:377
 hdiskspace.h:378
 hdiskspace.h:379