765 lines
22 KiB
JavaScript
765 lines
22 KiB
JavaScript
/**
|
|
** ==============================
|
|
** O O O OOOO
|
|
** O O O O O O
|
|
** O O O O O O
|
|
** OOOO OOOO O OOO OOOO
|
|
** O O O O O O O
|
|
** O O O O O O O
|
|
** OOOO OOOO O O OOOO
|
|
** ==============================
|
|
** Dr. Stefan Bosse http://www.bsslab.de
|
|
**
|
|
** COPYRIGHT: THIS SOFTWARE, EXECUTABLE AND SOURCE CODE IS OWNED
|
|
** BY THE AUTHOR(S).
|
|
** THIS SOURCE CODE MAY NOT BE COPIED, EXTRACTED,
|
|
** MODIFIED, OR OTHERWISE USED IN A CONTEXT
|
|
** OUTSIDE OF THE SOFTWARE SYSTEM.
|
|
**
|
|
** $AUTHORS: Stefan Bosse
|
|
** $INITIAL: (C) 2006-2017 bLAB
|
|
** $CREATED: 7-1-15 by sbosse.
|
|
** $VERSION: 1.2.2
|
|
**
|
|
** $INFO:
|
|
**
|
|
* Embedded Virtual Atomic Fileysystem Server
|
|
* Files and i-nodes are stored in memory.
|
|
*
|
|
**
|
|
** $ENDOFINFO
|
|
*/
|
|
|
|
"use strict";
|
|
|
|
var log = 0;
|
|
|
|
var util = Require('util');
|
|
var Io = Require('com/io');
|
|
var Net = Require('./network');
|
|
var Status = Net.Status;
|
|
var Command = Net.Command;
|
|
var Rights = Net.Rights;
|
|
var Std = Require('dos/std');
|
|
var Sch = Require('dos/scheduler');
|
|
var Buf = Require('dos/buf');
|
|
var Rpc = Require('dos/rpc');
|
|
var Fcache = Require('dos/fcache');
|
|
var Flist = Require('dos/freelist');
|
|
var Fs = Require('fs');
|
|
var Comp = Require('com/compat');
|
|
var String = Comp.string;
|
|
var Array = Comp.array;
|
|
var Perv = Comp.pervasives;
|
|
var Hashtbl = Comp.hashtbl;
|
|
var assert = Comp.assert;
|
|
var div = Comp.div;
|
|
var Afs = Require('dos/afs_srv_common');
|
|
var Afs_file_state = Afs.Afs_file_state;
|
|
var Afs_commit_flag= Afs.Afs_commit_flag;
|
|
|
|
/**
|
|
*
|
|
* @param {rpc} rpc
|
|
* @constructor
|
|
* @typedef {{rpc,afs_super,stats,files:afs_file [],live_table,block:function,to_block:function,of_block:function,
|
|
* live_set:function,live_get:function,live_read:function,live_write:function}} afs_server_emb~obj
|
|
* @see afs_server_emb~obj
|
|
* @see afs_server_emb~meth
|
|
* @see afs_server_rpc~meth
|
|
*/
|
|
var afs_server_emb = function (rpc) {
|
|
this.rpc=rpc;
|
|
this.afs_super=Afs.Afs_super();
|
|
/**
|
|
* Statistics
|
|
* @type {{op_touch: number, op_age: number, op_destroy: number, op_read: number, op_modify: number, op_create: number, op_sync: number, op_commit: number}}
|
|
*/
|
|
this.stats = {
|
|
op_touch:0,
|
|
op_age:0,
|
|
op_destroy:0,
|
|
op_read:0,
|
|
op_modify:0,
|
|
op_create:0,
|
|
op_sync:0,
|
|
op_commit:0
|
|
};
|
|
/**
|
|
*
|
|
* @type {afs_file []}
|
|
*/
|
|
this.files=[];
|
|
|
|
this.live_table=[];
|
|
|
|
this.block=undefined;
|
|
this.to_block=undefined;
|
|
this.of_block=undefined;
|
|
|
|
/*
|
|
** Exported Live table operations
|
|
*/
|
|
this.live_set=function(){};
|
|
this.live_get=function(){};
|
|
this.live_read=function(){};
|
|
this.live_write=function(){};
|
|
|
|
|
|
};
|
|
var AfsRpc = Require('dos/afs_srv_rpc');
|
|
//afs_server.prototype=new AfsRpc.afs_server_rpc();
|
|
afs_server_emb.prototype.afs_create_file=AfsRpc.afs_server_rpc.prototype.afs_create_file;
|
|
afs_server_emb.prototype.afs_read_file=AfsRpc.afs_server_rpc.prototype.afs_read_file;
|
|
afs_server_emb.prototype.afs_file_size=AfsRpc.afs_server_rpc.prototype.afs_file_size;
|
|
afs_server_emb.prototype.afs_touch_file=AfsRpc.afs_server_rpc.prototype.afs_touch_file;
|
|
afs_server_emb.prototype.afs_age_file=AfsRpc.afs_server_rpc.prototype.afs_age_file;
|
|
afs_server_emb.prototype.afs_insert_data=AfsRpc.afs_server_rpc.prototype.afs_insert_data;
|
|
afs_server_emb.prototype.afs_delete_data=AfsRpc.afs_server_rpc.prototype.afs_delete_data;
|
|
afs_server_emb.prototype.afs_destroy_file=AfsRpc.afs_server_rpc.prototype.afs_destroy_file;
|
|
afs_server_emb.prototype.afs_info=AfsRpc.afs_server_rpc.prototype.afs_info;
|
|
afs_server_emb.prototype.afs_exit=AfsRpc.afs_server_rpc.prototype.afs_exit;
|
|
afs_server_emb.prototype.afs_stat=AfsRpc.afs_server_rpc.prototype.afs_stat;
|
|
afs_server_emb.prototype.afs_create_fs=AfsRpc.afs_server_rpc.prototype.afs_create_fs;
|
|
afs_server_emb.prototype.afs_open_fs=AfsRpc.afs_server_rpc.prototype.afs_open_fs;
|
|
afs_server_emb.prototype.afs_start_server=AfsRpc.afs_server_rpc.prototype.afs_start_server;
|
|
|
|
/**
|
|
* @typedef {{
|
|
* read_file:afs_server.read_file,
|
|
* modify_file:afs_server.modify_file,
|
|
* modify_size:afs_server.modify_size,
|
|
* commit_file:afs_server.commit_file,
|
|
* read_inode:afs_server.read_inode,
|
|
* create_inode:afs_server.create_inode,
|
|
* delete_inode:afs_server.delete_inode,
|
|
* modify_inode:afs_server.modify_inode,
|
|
* read_super:afs_server.read_super,
|
|
* age:afs_server.age,
|
|
* touch:afs_server.touch,
|
|
* time:afs_server.time,
|
|
* acquire_file:afs_server.acquire_file,
|
|
* release_file:afs_server.release_file,
|
|
* get_freeobjnum:afs_server.get_freeobjnum,
|
|
* create_fs:afs_server.create_fs,
|
|
* open_fs:afs_server.open_fs
|
|
* }} afs_server_emb~meth
|
|
*/
|
|
|
|
/**
|
|
** Read a file specified by its object number (index) number.
|
|
** Physical reads only if not cached already.
|
|
**
|
|
** off: Logical File offset [bytes]
|
|
** size: [bytes]#
|
|
*
|
|
* @param {afs_file} file
|
|
* @param {number} off
|
|
* @param {number} size
|
|
* @param {buffer} buf
|
|
* @returns {(Status.STD_OK|*)}
|
|
*/
|
|
afs_server_emb.prototype.read_file =function (file,off,size,buf) {
|
|
var self = this;
|
|
self.stats.op_read++;
|
|
var disk = file.ff_disk;
|
|
if ((off+size)>= file.ff_size) return Status.STD_ARGBAD;
|
|
Buf.buf_blit(buf,off,disk,off,size);
|
|
return Status.STD_OK;
|
|
};
|
|
|
|
/** Modify data of a file. In the case, the (offset+size)
|
|
** fragment exceeds the current file size, the file size
|
|
** must be increased with afs_modify_size first.
|
|
**
|
|
** off: Logical File offset [bytes]
|
|
** size: [bytes]
|
|
*
|
|
* @param {afs_file} file
|
|
* @param {number} off in bytes
|
|
* @param {number} size in bytes
|
|
* @param {buffer} buf
|
|
* @returns {(Status.STD_OK|*)}
|
|
*/
|
|
afs_server_emb.prototype.modify_file =function (file,off,size,buf) {
|
|
var self = this;
|
|
self.stats.op_modify++;
|
|
var disk = file.ff_disk;
|
|
if ((off+size)>= file.ff_size) return Status.STD_ARGBAD;
|
|
Buf.buf_blit(disk,off,buf,off,size);
|
|
return Status.STD_OK;
|
|
};
|
|
|
|
/** Modify size of file.
|
|
* @param {afs_file} file
|
|
* @param {number} newsize in bytes
|
|
* @returns {(Status.STD_OK|*)}
|
|
*/
|
|
afs_server_emb.prototype.modify_size = function (file,newsize) {
|
|
var self = this;
|
|
var stat=Status.STD_OK;
|
|
self.stats.op_modify++;
|
|
var disk = file.ff_disk;
|
|
if (file.ff_size > newsize) {
|
|
file.ff_size=newsize;
|
|
Buf.buf_shrink(disk,newsize);
|
|
} else if (file.ff_size < newsize) {
|
|
file.ff_size=newsize;
|
|
Buf.buf_expand(disk,newsize);
|
|
if (disk.length != newsize) stat=Status.STD_NOSPACE;
|
|
}
|
|
return stat;
|
|
};
|
|
|
|
/** Commit a file to the disk.
|
|
** The flag argument specifies the way: immediately
|
|
** (AFS_SAFETY) or later (AFS_COMMIT) by the cache module if any.
|
|
*
|
|
* @param {afs_file} file
|
|
* @param {(Afs_commit_flag.AFS_UNCOMMIT|*)} flag
|
|
* @returns {(Status.STD_OK|*)}
|
|
*/
|
|
afs_server_emb.prototype.commit_file =function (file,flag) {
|
|
var self = this;
|
|
var stat;
|
|
self.stats.op_commit++;
|
|
/*
|
|
** Nothing to do here?
|
|
*/
|
|
stat=Status.STD_OK;
|
|
file.ff_state=Afs_file_state.FF_locked;
|
|
return stat;
|
|
};
|
|
|
|
/** Read an i-node
|
|
*
|
|
* @param {number} obj - i-node number
|
|
* @returns {{stat:(Status.STD_OK|*),file:afs_file}}
|
|
*/
|
|
|
|
afs_server_emb.prototype.read_inode =function (obj) {
|
|
var self=this;
|
|
var file = undefined;
|
|
if (obj < 0 || obj > self.afs_super.afs_nused)
|
|
return {stat:Status.STD_ARGBAD,file:undefined};
|
|
file=self.files[obj];
|
|
if (file==undefined)
|
|
return {stat:Status.STD_NOTFOUND,file:undefined};
|
|
if (file.ff_objnum != obj) {
|
|
Io.out('[AFS] invalid inode number (got '+file.ff_objnum+', expected '+obj);
|
|
throw Status.STD_SYSERR;
|
|
}
|
|
if (file.ff_state != Afs_file_state.FF_invalid) {
|
|
var tf = self.live_get(obj);
|
|
file.ff_live=tf.time;
|
|
file.ff_modified=false;
|
|
return {
|
|
stat: Status.STD_OK,
|
|
file: file
|
|
}
|
|
} else
|
|
return {stat:Status.STD_NOTFOUND,file:undefined}
|
|
};
|
|
|
|
/** Create a new i-node with initial afs_file.
|
|
** A true final flag indicates that the file size
|
|
** is final and not initial (afs_req_create with
|
|
** AFS_COMMIT/SAFETY flag set).
|
|
*
|
|
* @param {afs_file} file
|
|
* @param {boolean} final
|
|
* @returns {(Status.STD_OK|*)}
|
|
*/
|
|
afs_server_emb.prototype.create_inode = function (file,final) {
|
|
var self = this;
|
|
var stat=Status.STD_OK;
|
|
/*
|
|
** Be aware: initial file size can be zero!
|
|
*/
|
|
var fbsize = file.ff_size==0?self.afs_super.afs_block_size:self.block(file.ff_size);
|
|
self.stats.op_create++;
|
|
self.afs_super.lock();
|
|
file.ff_disk=Buf.Buffer(fbsize);
|
|
self.live_set(file.ff_objnum,Afs.AFS_MAXLIVE,1);
|
|
return stat;
|
|
};
|
|
|
|
/**
|
|
** Delete an i-node (file); free used disk space, if any.
|
|
*
|
|
* @param {afs_file} file
|
|
* @returns {Status.STD_OK|*}
|
|
*/
|
|
afs_server_emb.prototype.delete_inode =function (file) {
|
|
var self = this;
|
|
var stat = Status.STD_OK;
|
|
|
|
self.stats.op_destroy++;
|
|
self.live_set(file.ff_objnum, 0, 0);
|
|
file.ff_disk=undefined;
|
|
self.afs_super.lock();
|
|
self.afs_super.afs_nused--;
|
|
self.afs_super.unlock();
|
|
return stat;
|
|
};
|
|
|
|
/**
|
|
** Modify an i-node, for example the ff_live field was changed.
|
|
*
|
|
* @param file
|
|
* @returns {Status.STD_OK|*}
|
|
*/
|
|
afs_server_emb.prototype.modify_inode =function (file) {
|
|
var self = this;
|
|
var stat = status.STD_OK;
|
|
return stat;
|
|
};
|
|
|
|
/**
|
|
*
|
|
* @returns {{stat: number, super: afs_super}}
|
|
*/
|
|
afs_server_emb.prototype.read_super =function () {
|
|
var self=this;
|
|
return {stat:Status.STD_OK,super:self.afs_super};
|
|
};
|
|
|
|
/**
|
|
** Age a file. Return true if i-node is in use, and the new live time.
|
|
*
|
|
* @param {number} obj
|
|
* @returns {*[]} -- [flag,cur]
|
|
*/
|
|
afs_server_emb.prototype.age =function (obj) {
|
|
var self=this;
|
|
var cur,flag;
|
|
self.afs_super.lock();
|
|
var lf = self.live_get(obj);
|
|
flag=lf.flag;
|
|
cur=lf.time;
|
|
if (flag==1 && cur>1) {
|
|
cur=cur-1;
|
|
self.stats.op_age++;
|
|
self.live_set(obj,cur,flag);
|
|
} else if (flag==1) {
|
|
cur=0;
|
|
self.stats.op_age++;
|
|
self.live_set(obj,cur,flag);
|
|
}
|
|
self.afs_super.unlock();
|
|
return [flag,cur]
|
|
};
|
|
|
|
afs_server_emb.prototype.touch =function (file) {
|
|
var self=this;
|
|
self.stats.op_touch++;
|
|
self.live_set(file.ff_objnum,Afs.AFS_MAXLIVE,1);
|
|
file.ff_live=Afs.AFS_MAXLIVE;
|
|
};
|
|
|
|
|
|
/**
|
|
** Get the current system time in 10s units
|
|
*
|
|
* @returns {number}
|
|
*/
|
|
afs_server_emb.prototype.time =function () {
|
|
var self=this;
|
|
return div(Perv.time(),10);
|
|
};
|
|
|
|
|
|
/**
|
|
** Acquire and lock a file with object number 'obj'. A
|
|
** release_file call must follow this operation. [BLOCKING]
|
|
*
|
|
*
|
|
* @param {number} obj
|
|
* @param {function((Status.STD_OK|*),afs_file|undefined)} callback
|
|
*/
|
|
afs_server_emb.prototype.acquire_file = function (obj,callback) {
|
|
var self=this;
|
|
var file=undefined;
|
|
var stat=Status.STD_OK;
|
|
Sch.ScheduleBlock([
|
|
function () {self.afs_super.lock();},
|
|
function () {
|
|
if (obj>self.afs_super.afs_nfiles) {
|
|
self.afs_super.unlock();
|
|
throw Status.STD_ARGBAD;
|
|
} else {
|
|
var sf = self.read_inode(obj);
|
|
stat=sf.stat;
|
|
if (sf.stat==Status.STD_OK && sf.file.ff_state!=Afs_file_state.FF_invalid) {
|
|
file=sf.file;
|
|
file.lock();
|
|
} else stat=Status.STD_NOTFOUND;
|
|
}
|
|
},
|
|
function () {
|
|
self.afs_super.unlock();
|
|
callback(stat,file);
|
|
}
|
|
],function (e) {
|
|
callback(e,undefined);
|
|
});
|
|
};
|
|
|
|
/**
|
|
** Release an acquired file.
|
|
** Commit the file with specified flag argument -
|
|
** the way to commit the file. A zero value shows no
|
|
** modifications.
|
|
*
|
|
*
|
|
* @param {afs_file} file
|
|
* @param {(Afs_commit_flag.AFS_UNCOMMIT|*)} flag
|
|
* @returns {(Status.STD_OK|*)}
|
|
*/
|
|
afs_server_emb.prototype.release_file =function (file,flag) {
|
|
var self=this;
|
|
var stat=Status.STD_OK;
|
|
try {
|
|
if (file==undefined) throw Status.STD_SYSERR;
|
|
if ((flag & (Afs_commit_flag.AFS_COMMIT | Afs_commit_flag.AFS_SAFETY)) != 0) {
|
|
file.ff_state=((flag & Afs_commit_flag.AFS_SAFETY) == Afs_commit_flag.AFS_SAFETY)?
|
|
Afs_file_state.FF_locked:Afs_file_state.FF_commit;
|
|
file.ff_modified=true;
|
|
/*
|
|
** Commit the file.
|
|
*/
|
|
stat=self.commit_file(file,flag);
|
|
if (stat != Status.STD_OK) {
|
|
file.unlock();
|
|
throw stat;
|
|
}
|
|
}
|
|
if (file.ff_modified) stat=self.modify_inode(file);
|
|
file.unlock();
|
|
return stat;
|
|
} catch(e) {
|
|
if (typeof e == 'number') return e;
|
|
throw Error(e);
|
|
}
|
|
};
|
|
|
|
/**
|
|
** Return a free object number of the AFS table (index).
|
|
** Note: protect this function with the server lock until
|
|
** the file creation is finished.
|
|
*
|
|
*
|
|
* @returns {number}
|
|
*/
|
|
afs_server_emb.prototype.get_freeobjnum = function () {
|
|
var self = this;
|
|
/*
|
|
** First check the free objnums list. If empty, use nextfree at the
|
|
** end of the directory table.
|
|
*/
|
|
self.afs_super.afs_nused = self.afs_super.afs_nused + 1;
|
|
var next;
|
|
Array.match(self.afs_super.afs_freeobjnums, function (hd, tl) {
|
|
self.afs_super.afs_freeobjnums = tl;
|
|
next = hd;
|
|
}, function () {
|
|
var objnum = self.afs_super.afs_nextfree;
|
|
|
|
if (objnum + 1 == self.afs_super.afs_nfiles)
|
|
Perv.failwith('AFS: TODO: out of file table slots');
|
|
|
|
self.afs_super.afs_nextfree = objnum + 1;
|
|
next = objnum;
|
|
});
|
|
return next;
|
|
|
|
};
|
|
|
|
/**
|
|
* Create a new file system
|
|
*
|
|
* @param {string} label
|
|
* @param {number} ninodes
|
|
* @param {number} blocksize
|
|
* @param {number} nblocks
|
|
* @param {string} part_inode
|
|
* @param {string} part_data
|
|
* @param {boolean} overwrite
|
|
* @returns {(Status.STD_OK|*)}
|
|
*/
|
|
|
|
afs_server_emb.prototype.create_fs = function (label,ninodes,blocksize,nblocks,part_inode,part_data,overwrite) {
|
|
var i, n;
|
|
var stat=Status.STD_OK;
|
|
Io.out('[AFS] Creating Atomic filesystem...');
|
|
Io.out('[AFS] Blocksize: ' + blocksize + ' [bytes]');
|
|
Io.out('[AFS] Number of total blocks: ' + nblocks);
|
|
Io.out('[AFS] Number of total inodes: ' + ninodes);
|
|
|
|
|
|
/*
|
|
** First create a server port and derive the public port.
|
|
*/
|
|
var priv_port = Net.uniqport();
|
|
var pub_port = Net.prv2pub(priv_port);
|
|
var checkfield = Net.uniqport();
|
|
Io.out('[AFS] Private Port: ' + Net.Print.port(priv_port));
|
|
Io.out('[AFS] Public Port: ' + Net.Print.port(pub_port));
|
|
Io.out('[AFS] Checkfield: ' + Net.Print.port(checkfield));
|
|
Io.out('[AFS] Writing live table... ');
|
|
|
|
/*
|
|
** The lifetime table. It's a fixed size bit-field table build with
|
|
** a string of sufficient size.
|
|
**
|
|
** Assumption: Maximal Live time value < 128, therefore
|
|
** 7 bit are used for each object. The MSB is
|
|
** the used flag (=1 -> inode used).
|
|
**
|
|
** The first entry (obj=0) is used for the lock status
|
|
** of the live table.
|
|
*/
|
|
var live_size = ninodes+1;
|
|
var live_table = Buf.Buffer();
|
|
var live_off = Afs.DEF_BLOCK_SIZE + (ninodes*Afs.DEF_INODE_SIZE);
|
|
|
|
function live_set (obj,time,flag) {
|
|
Buf.buf_set(live_table, obj, ((time & 0x7f) | ((flag << 7) & 0x80)));
|
|
}
|
|
function live_write () {
|
|
/*
|
|
** Unlock the live table
|
|
*/
|
|
live_set(0,0,1);
|
|
}
|
|
for(i=0;i<=ninodes;i++) {
|
|
live_set(i,Afs.AFS_MAXLIVE,0);
|
|
}
|
|
live_write();
|
|
|
|
Buf.buf_pad(live_table,live_size);
|
|
this.afs_super=Afs.Afs_super(label,ninodes,0,[],0,priv_port,pub_port,checkfield,blocksize,nblocks);
|
|
|
|
return stat;
|
|
};
|
|
|
|
/**
|
|
** Open the file system (two partitions, UNIX files)
|
|
**
|
|
** part_inode: Partition A path and name
|
|
** part_data: Partition B path and name
|
|
** cache: Cache parameters
|
|
**
|
|
**
|
|
**
|
|
*
|
|
* @param {string} part_inode
|
|
* @param {string} part_data
|
|
* @param cache_params
|
|
* @returns {(Status.STD_OK|*)}
|
|
*/
|
|
|
|
afs_server_emb.prototype.open_fs = function (part_inode,part_data,cache_params) {
|
|
var self = this;
|
|
var stat = Status.STD_OK;
|
|
var n, i, j, pos;
|
|
|
|
self.afs_super.afs_freeobjnums = [];
|
|
|
|
Io.out('[AFS] Opening Atomic filesystem...');
|
|
Io.out(' AFS: Label = "' + self.afs_super.afs_name + '"');
|
|
Io.out(' AFS: Maximal number of files (inodes) = ' + self.afs_super.afs_nfiles);
|
|
Io.out(' AFS: Blocksize = ' + self.afs_super.afs_block_size + ' bytes');
|
|
Io.out(' AFS: Total number of blocks = ' + self.afs_super.afs_nblocks);
|
|
Io.out(' AFS: Filesystem size = ' + (self.afs_super.afs_nblocks * self.afs_super.afs_block_size) +
|
|
' bytes (' + div(div(self.afs_super.afs_nblocks * self.afs_super.afs_block_size, 1024), 1024) + ' MB)');
|
|
/*
|
|
** The live time table. It's a fixed size bit field table build with
|
|
** a string of sufficient size.
|
|
**
|
|
** Assumption: Maximal Live time value < 128, therefore
|
|
** 7 bit are used for each object. The MSB is
|
|
** the used flag (=1 -> inode used).
|
|
**
|
|
** The first entry (obj=0) is used for the lock status
|
|
** of the live table.
|
|
*/
|
|
var ninodes = self.afs_super.afs_nfiles;
|
|
var live_size = self.afs_super.afs_nfiles;
|
|
var live_table = Buf.Buffer();
|
|
var live_off = Afs.DEF_BLOCK_SIZE + (ninodes * Afs.DEF_INODE_SIZE);
|
|
|
|
/**
|
|
*
|
|
* @param {number} obj
|
|
* @param {number} time
|
|
* @param {number} flag
|
|
*/
|
|
function live_set(obj, time, flag) {
|
|
Buf.buf_set(live_table, obj, ((time & 0x7f) | ((flag << 7) & 0x80)));
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @param {number} obj
|
|
* @returns {{time: number, flag: number}}
|
|
*/
|
|
function live_get(obj) {
|
|
var v = Buf.buf_get(live_table, obj);
|
|
return {time: (v & 0x7f), flag: ((v & 0x80) >> 7)}
|
|
}
|
|
|
|
function live_read() {
|
|
var live = live_get(0);
|
|
if (live.time == 0 && live.flag == 1) {
|
|
/*
|
|
** Now lock the live table. After a server crash,
|
|
** the restarted server will found the lock and must
|
|
** discard the live table. All server objects got
|
|
** the maximal live time!
|
|
*/
|
|
live_set(0, 1, 1);
|
|
return Status.STD_OK;
|
|
} else return Status.STD_ARGBAD;
|
|
}
|
|
|
|
function live_write() {
|
|
/*
|
|
** Unlock the live table
|
|
*/
|
|
live_set(0, 0, 1);
|
|
return Status.STD_OK;
|
|
}
|
|
|
|
self.live_set = live_set;
|
|
self.live_get = live_get;
|
|
self.live_read = live_read;
|
|
self.live_write = live_write;
|
|
|
|
/*
|
|
** Read the live table
|
|
*/
|
|
Io.out('[AFS] Reading the live time table...');
|
|
stat = live_read();
|
|
if (stat == Status.STD_ARGBAD) {
|
|
Io.out('[AFS] found locked live table: Reinitialize...');
|
|
for (i = 0; i < ninodes - 1; i++) {
|
|
live_set(i, Afs.AFS_MAXLIVE, 0);
|
|
}
|
|
} else if (stat == Status.STD_IOERR) {
|
|
Io.out('[AFS] IO Error.');
|
|
Io.close(self.part_fd_A);
|
|
Io.close(self.part_fd_B);
|
|
throw Status.STD_IOERR;
|
|
}
|
|
Io.out('[AFS] Ok.');
|
|
|
|
/*
|
|
** Round up the value x to block_size
|
|
*/
|
|
|
|
function block(x) {
|
|
return Afs.ceil_block_bytes(x, self.afs_super.afs_block_size);
|
|
}
|
|
|
|
function to_block(x) {
|
|
return div(x, self.afs_super.afs_block_size);
|
|
}
|
|
|
|
function of_block(x) {
|
|
return (x * self.afs_super.afs_block_size);
|
|
}
|
|
|
|
self.block = block;
|
|
self.to_block = to_block;
|
|
self.of_block = of_block;
|
|
|
|
var freeino = [];
|
|
var firstfree = (-1);
|
|
var nextfree = (-1);
|
|
var nused = 0;
|
|
var bused = 0;
|
|
|
|
for (i = 1; i < self.afs_super.afs_nfiles; i++) {
|
|
var file = self.files[i];
|
|
if (file==undefined) continue;
|
|
if (nextfree != -1 && nextfree != (i - 1)) {
|
|
for (j = firstfree; j <= nextfree; j++) {
|
|
freeino.push(j);
|
|
}
|
|
firstfree = i;
|
|
nextfree = i;
|
|
} else {
|
|
|
|
nextfree = i;
|
|
if (firstfree == -1) {
|
|
firstfree = i;
|
|
}
|
|
}
|
|
if (file.ff_state != Afs_file_state.FF_locked) {
|
|
live_set(i, 0, 0);
|
|
if (file.ff_state == Afs_file_state.FF_unlocked ||
|
|
file.ff_state == Afs_file_state.FF_commit) {
|
|
Io.out('[AFS] Unlocked/uncommitted file found. Destroy it: #' + file.ff_objnum+' size='+file.ff_size);
|
|
file.ff_state= Afs_file_state.FF_invalid;
|
|
file.ff_disk=undefined;
|
|
file.ff_size=0;
|
|
}
|
|
} else {
|
|
var tf = live_get(i);
|
|
live_set(i, tf.time, 1);
|
|
nused++;
|
|
bused=bused+self.block(file.ff_size);
|
|
}
|
|
}
|
|
if (nextfree != -1 && nextfree < (self.afs_super.afs_nfiles - 1)) {
|
|
|
|
/*
|
|
** There are only used i-nodes at the end of the i-node table.
|
|
*/
|
|
for (j = firstfree; j <= nextfree; j++) {
|
|
freeino.push(j);
|
|
}
|
|
nextfree = -1;
|
|
} else if (firstfree == 0 && nextfree == (self.afs_super.afs_nfiles - 1)) {
|
|
|
|
/*
|
|
** Empty filesystem.
|
|
*/
|
|
nextfree = 1;
|
|
} else if (firstfree > 0) {
|
|
|
|
/*
|
|
** There are free i-nodes at the end of the i-node table.
|
|
*/
|
|
nextfree = firstfree;
|
|
}
|
|
|
|
Io.out('[AFS] Found ' + usedn + ' valid file(s)');
|
|
|
|
|
|
self.afs_super.afs_nused = nused;
|
|
self.afs_super.afs_freeobjnums = freeino;
|
|
self.afs_super.afs_nextfree = nextfree;
|
|
|
|
Io.out('[AFS] Found ' + self.afs_super.afs_nused + ' used Inode(s)');
|
|
Io.out('[AFS] Total used space: ' + (bused * self.afs_super.afs_block_size) +
|
|
' bytes (' + div(div(bused * self.afs_super.afs_block_size, 1024), 1024) + ' MB)');
|
|
|
|
return stat;
|
|
};
|
|
|
|
module.exports = {
|
|
|
|
/**
|
|
*
|
|
* @param {rpcint} rpc
|
|
* @returns {afs_server_emb}
|
|
*/
|
|
Server: function(rpc) {
|
|
var obj = new afs_server_emb(rpc);
|
|
Object.preventExtensions(obj);
|
|
return obj;
|
|
}
|
|
};
|