PsychOSPackages/rtfs-v0/lib/fs/rtfs/v0.lua

507 lines
15 KiB
Lua

local common = require "fs.rtfs"
local rtfs, proxy = {}, setmetatable({},{__index=common.proxy})
local ieformat = ">BI8I8c47" -- ftype, start, len, name
local iesize = string.packsize(ieformat)
local sbformat = ">c4I2I8c18" -- "rtfs" magic, version, index size in entries, label. label length subject to change.
local ftypes = {
unused = 0x00,
empty = 0x01,
file = 0x10,
tfile = 0x11,
dfile = 0x12,
directory = 0x20,
}
function proxy:log(message,level)
syslog(message,level or syslog.debug,"rtfs:"..self.label)
end
-- data mangling functions
local fnormalize = common.fnormalize
function proxy:cSOI(n)
n=n-1
local ms = self.capacity / self.blockSize
local ePS = self.blockSize // iesize
local s = n // ePS
local so = self.blockSize - iesize - ((n % ePS) * iesize)
local eo = so + iesize
return ms - s, so+1, eo
end
-- superblock stuff
function proxy:updateSB()
self:cachedWrite(1,string.pack(sbformat, "rtfs", 0, self.isize, self.label))
end
function proxy:setISize(n)
if self.isize ~= n then
self.isize = n
self:updateSB()
end
end
-- index I/O
function proxy:readIEntry(n)
local sector, sstart, send = self:cSOI(n)
local rt = {string.unpack(ieformat,self:cachedRead(sector):sub(sstart, send))}
rt[4] = rt[4]:gsub("\0","")
rt[5] = nil
return table.unpack(rt)
end
function proxy:writeIEntry(n,et,es,el,en)
local ne = string.pack(ieformat, et, es, el, en)
local sector, sstart, send = self:cSOI(n)
local fi, ft = self:findIEntry(nil,nil,nil,nil,sector)
if fi then
self:log("auto-compact triggered")
if not (ft[1] == ftypes.empty or ft[1] == ftypes.dfile or ftypes[1] == ftypes.tfile) then
self:log("automatic defragment triggered from:" .. debug.traceback())
assert(not self.runningDefragment, "recursive defragment triggered")
self:defragment()
end
n = self:compactIndex(n) or self.isize + 1
sector, sstart, send = self:cSOI(n)
end
local pes = self:cachedRead(sector)
local ns = pes:sub(1, sstart - 1) .. ne .. pes:sub(send + 1)
self:cachedWrite(sector, ns)
self:setISize(math.max(self.isize, n))
end
function proxy:allIEntries()
local i = 0
return function()
if i < self.isize then
i = i + 1
return i, self:readIEntry(i)
end
return nil
end
end
-- index maintenance
function proxy:compactIndex(ti) -- number -- number -- Compact the index, optionally returning the new index of *ti*.
while self.runningCompact do -- wait for any existing compact run to complete
coroutine.yield()
end
self.runningCompact = true
-- look for contingous free space
local ri
for i, tp, st, sl, n in self:allIEntries() do
if tp == ftypes.empty or tp == ftypes.dfile then
local ni, nt = self:findIEntry(nil,st+sl)
if ni and nt then
if nt[1] == ftypes.empty or nt[1] == ftypes.dfile then
self:writeIEntry(i,tp,st,sl+nt[3],n)
self:writeIEntry(ni,ftypes.unused,0,0,"")
end
end
end
end
-- reverse walk to move any unused indexes
for i = self.isize, 1, -1 do
local ne = self:nextEntry() or self.isize
local ft = {self:readIEntry(i)}
if ne < i then
-- modify any open handles to point at the new index
for k,v in pairs(self.handles) do
if v.fi == i then
v.fi = ne
end
end
self:writeIEntry(ne, table.unpack(ft))
ri = (ti == i) and ne or ri -- track the requested index
elseif ft[1] ~= ftypes.unused then
self:setISize(i)
break
end
end
-- resize the free space / tentative file at the end of the FS to match the index size
local li, ls = 0, 0
local lt
for i, tp, st, sl, n in self:allIEntries() do
if st+sl > ls then
li, ls = i, st+sl
lt = {tp, st, sl, n}
end
end
if lt[1] == ftypes.empty or lt[1] == ftypes.dfile or lt[1] == ftypes.tfile then
local lastsec = (self.capacity / self.blockSize) - math.ceil(self.isize / (self.blockSize / iesize))
self:writeIEntry(li, lt[1], lt[2], lastsec - lt[2] - 1, lt[4])
-- modify the file handle in memory, if applicable
if lt[1] == ftypes.tfile then
for k,v in ipairs(self.handles) do
if v.fi == li then
v.ft[3] = lastsec - lt[2]
v.maxWrite = v.ft[3] * self.blockSize
end
end
end
end
self.runningCompact = false
return ri
end
-- mostly just for debugging
function proxy:dumpIndex()
print(" # ty init len end name")
for i, tp, st, sl, n in self:allIEntries() do
print(string.format("%2i %2i %4i %4i %4i %s",i,tp,st,sl,st+sl-1, n))
end
end
-- index searching
function proxy:findIEntry(et,es,el,en,ef) -- number number number string number -- Find an entry matching all provided parameters and ignoring any not specified.
local ri, rt
for i, tp, st, sl, n in self:allIEntries() do
local sf = st + sl - 1
if (et or tp) == tp and (es or st) == st and (el or sl) == sl and (en or n) == n and (ef or sf) == sf then
ri, rt = i, {self:readIEntry(i)}
break
end
end
return ri, rt
end
function proxy:nextEntry()
local ni = self.isize+1
for i, tp, st, sl, n in self:allIEntries() do
if tp == ftypes.unused or tp == ftypes.dfile then
ni = i
break
end
end
return ni
end
-- file allocation
function proxy:bestFree()
local ri, sri
local bs, sbs = 0, 0
for i, tp, st, sl, n in self:allIEntries() do
if tp == ftypes.empty or tp == ftypes.dfile then
if sl > bs then
sri, sbs = ri, bs
ri, bs = i, sl
end
end
end
return bs/2 > sbs and ri or sri, bs/2 > sbs
end
function proxy:allocateNew(name)
self:compactIndex()
local lfi,lfis = self:bestFree()
local lf = {self:readIEntry(lfi)}
local new
if lfis then
new = {ftypes.tfile, lf[2] + math.floor(lf[3]/2), math.ceil(lf[3]/2), name}
lf[3] = math.floor(lf[3] / 2)
self:writeIEntry(lfi, table.unpack(lf))
local ni = self:nextEntry()
self:writeIEntry(ni, table.unpack(new))
self:setISize(math.max(ni,self.isize))
return self:findIEntry(ftypes.tfile,nil,nil,name)
-- return ni, new
else
new = {ftypes.tfile, lf[2], lf[3], name}
self:writeIEntry(lfi, table.unpack(new))
return lfi, new
end
return false
end
function proxy:relocateBlocks(start, len, dest, loud)
local ot = os.getTimeout()
os.setTimeout(0.00001) -- disable coroutine.yield's delay
io.write(loud and "\27[s" or "")
for i = 0, len-1 do
local buffer = self.d.readSector(start+i)
self.d.writeSector(dest+i, buffer)
io.write(loud and string.format("\27[u\27[2K%i/%i %i -> %i", i+1, len, start+i, dest+i) or "")
coroutine.yield()
end
io.write(loud and " done!\n" or "")
os.setTimeout(ot)
return true
end
function proxy:relocateFile(n,dest,loud)
local ft = {self:readIEntry(n)}
-- modify any writing handles to write to the destination before doing anything
local realLen
for k,v in pairs(self.handles) do
if v.ft[1] == n and (v.w or v.a) then
v.ft[2] = dest
realLen = v.currentSector
end
end
self:relocateBlocks(ft[2],realLen or ft[3],dest,loud)
local w, e = pcall(self.writeIEntry,self,n,ft[1],dest,ft[3],ft[4])
-- modify any reading handles to read from the destination after moving the data
for k,v in pairs(self.handles) do
if v.ft[1] == n and v.r then
v.ft[2] = dest
end
end
return w, {ft[1], dest, ft[3], ft[4]}
end
function proxy:defragment(loud)
while self.runningDefragment do
coroutine.yield()
end
self.runningDefragment = true
for i, tp, _, _, _ in self:allIEntries() do
if tp == ftypes.empty or tp == ftypes.dfile then
self:writeIEntry(i, ftypes.unused, 0, 0, "")
end
end
local ftab = {}
local fsec, lsec = 2, (self.capacity / self.blockSize) - math.ceil(self.isize / (self.blockSize / iesize))
for i, tp, st, sl, n in self:allIEntries() do
if tp ~= ftypes.empty and tp ~= ftypes.dfile and sl > 0 then
ftab[#ftab+1] = {i, tp, st, sl, n}
end
end
-- sort files in order of their start sector
table.sort(ftab, function(a,b)
return a[3] < b[3]
end)
-- move files closer to the start if applicable
local deferred = {}
for k, ft in ipairs(ftab) do
io.write(loud and string.format("%i/%i: %s\n",k,#ftab,ft[5]) or "")
if ft[3] ~= fsec then
local w, dt = self:relocateFile(ft[1], fsec, loud)
deferred[#deferred+1] = (not w and dt) or nil
end
fsec = fsec + ft[4]
end
self:writeIEntry(self:nextEntry(), ftypes.empty, fsec, lsec-fsec, "")
for k,v in ipairs(deferred) do
self:writeIEntry(self:nextEntry(), table.unpack(v))
end
self.runningDefragment = false
end
-- handle management
function proxy:openFile(name,mode)
name = fnormalize(name)
local handle = {}
for c in mode:gmatch(".") do
handle[c] = true
end
local fi,ft = self:findIEntry(ftypes.file, nil, nil, name)
if handle.r then
if not fi then
return false, "file not found"
end
handle.currentSector, handle.fi, handle.ft = 0, fi, ft
elseif handle.w or handle.a then
handle.writeBuffer, handle.writeCounter = "", 0
local oft = ft
fi, ft = self:allocateNew(name)
if oft and handle.a then
assert(ft[3] >= oft[3], "no extent large enough for relocated file")
handle.writeBuffer = self.d.readSector(oft[2] + oft[3] - 1):gsub("\0+$","")
handle.currentSector, handle.writeCounter = oft[3]-1, ((oft[3]-1) * 512) + #handle.writeBuffer
self:log(string.format("appending %s, CS: %i, WC: %i, WB: %i", name, handle.currentSector, handle.writeCounter, #handle.writeBuffer))
self:relocateBlocks(oft[2], oft[3], ft[2])
end
handle.fi, handle.ft, handle.maxWrite, handle.writeCounter, handle.currentSector = fi, ft, ft[3] * self.blockSize, handle.writeCounter or 0, handle.currentSector or 0
end
self.handles[#self.handles+1] = handle
return #self.handles
end
function proxy:closeHandle(h)
local handle = self.handles[h]
if handle.w or handle.a then
local ft = handle.ft
self.d.writeSector(ft[2] + handle.currentSector, handle.writeBuffer .. ("\0"):rep(self.blockSize - #handle.writeBuffer))
local fs = ft[3] - math.ceil(handle.writeCounter / self.blockSize)
local ni, nt = self:findIEntry(nil, ft[2] + ft[3])
if ni and (nt[1] == ftypes.empty or nt[1] == ftypes.dfile) then
fs = fs + nt[3]
else
ni = self:nextEntry()
end
while self:findIEntry(ftypes.file,nil,nil,ft[4]) do
local di, dt = self:findIEntry(ftypes.file, nil, nil, ft[4])
dt[1] = ftypes.dfile
self:writeIEntry(di, table.unpack(dt))
self:log(string.format("marking entry %i for %s as deleted", di, dt[4]))
end
ft[1], ft[3] = ftypes.file, math.ceil(handle.writeCounter / self.blockSize)
self:writeIEntry(handle.fi, table.unpack(ft))
self:writeIEntry(ni, ftypes.empty, ft[2] + ft[3], fs, "")
self:setISize(math.max(handle.fi,ni,self.isize))
end
self.handles[h] = nil
return true
end
-- handle I/O
function proxy:writeHandle(h,s)
local handle = self.handles[h]
if s:len() + handle.writeCounter > handle.maxWrite then
self:log("no space left in extent", syslog.error)
return false, "no space left in extent"
end
handle.writeCounter = handle.writeCounter + s:len()
handle.writeBuffer = handle.writeBuffer .. s
while #handle.writeBuffer > self.blockSize do
self.d.writeSector(handle.ft[2] + handle.currentSector, handle.writeBuffer:sub(1,self.blockSize))
handle.currentSector = handle.currentSector + 1
handle.writeBuffer = handle.writeBuffer:sub(self.blockSize+1)
end
return true
end
function proxy:readHandle(h,s)
local handle, rb = self.handles[h]
if handle.currentSector < handle.ft[3] - 1 then
local rb = self.d.readSector(handle.ft[2] + handle.currentSector)
elseif handle.currentSector == handle.ft[3] - 1 then
local rb = self.d.readSector(handle.ft[2] + handle.currentSector):gsub("\0+$","")
else
return nil
end
handle.currentSector = handle.currentSector + 1
return rb
end
-- primarily for debugging
function proxy:getHandle(h)
return self.handles[h]
end
----------
function rtfs.mount(d)
d=common.getProxy(d)
local p = setmetatable({}, {__index=proxy})
local magic, version, isize, label = string.unpack(sbformat,d.readSector(1))
assert(magic == "rtfs", "incorrect magic")
p.d = d
p.fstype = "rtfs"
p.cache, p.handles = {}, {}
p.cacheHits, p.cacheMisses = 0, 0
p.blockSize, p.capacity, p.label, p.isize = d.getSectorSize(), d.getCapacity(), label:gsub("\0",""), isize
-- FS proxy functions
function p.exists(name)
name = fnormalize(name)
for i, tp, st, sl, n in p:allIEntries() do
if (tp == ftypes.file or tp == ftypes.directory) and n == name then
return true
end
end
end
function p.isDirectory(name)
name = fnormalize(name)
return name == "" and true or p:findIEntry(ftypes.directory, nil, nil, name) ~= nil
end
function p.size(name)
name = fnormalize(name)
local fi, ft = p:findIEntry(ftypes.file, nil, nil, name)
if not fi and ft then return 0 end
return ft[3] * p.blockSize
end
function p.spaceUsed()
local c = 0
for i, tp, st, sl, n in p:allIEntries() do
if tp == ftypes.file then
c = c + sl
end
end
return c*p.blockSize
end
function p.spaceTotal()
return p.capacity - (math.ceil(p.isize / (p.blockSize / iesize))*p.blockSize) - p.blockSize
end
p.isReadOnly = p.d.isReadOnly
function p.list(name)
name = fnormalize(name)
local rt = {}
for i, tp, st, sl, n in p:allIEntries() do
local seg = fs.segments(n)
local pn = table.concat(seg,"/",1,#seg-1)
local fn = seg[#seg]
if (tp == ftypes.file or tp == ftypes.directory) and pn == name then
rt[#rt+1] = fn .. ((tp == ftypes.directory and "/") or "")
end
end
return rt
end
function p.makeDirectory(name)
name = fnormalize(name)
if #name < 1 or p:findIEntry(nil,nil,nil,name) then return false end
local seg = fs.segments(name)
for j = 1, #seg-1 do
p.makeDirectory(table.concat(seg, "/", 1, j))
end
if not p.isDirectory(table.concat(seg,"/",1,#seg-1)) then return false end
local ni = p:nextEntry()
p:writeIEntry(ni, ftypes.directory, 0, 0, name)
p:setISize(math.max(p.isize, ni))
return true
end
function p.remove(name)
name = fnormalize(name)
local fi, ft = p:findIEntry(ftypes.file, nil, nil, name)
if fi then
ft[1] = ftypes.dfile
p:writeIEntry(fi, table.unpack(ft))
end
local fi, ft = p:findIEntry(ftypes.directory, nil, nil, name)
if fi then
for _,f in ipairs(p.list(name)) do
p.remove(name.."/"..f)
end
p:writeIEntry(fi, ftypes.unused, 0, 0, "")
end
end
function p.rename(from, to)
from, to = fnormalize(from), fnormalize(to)
if p.exists(from) then
if p.exists(to) then
p.remove(to)
end
local fi, ft = p:findIEntry(p.isDirectory(name) and ftypes.directory or ftypes.file, nil, nil, to)
ft[4] = to
p:writeIEntry(fi, table.unpack(ft))
end
end
function p.lastModified()
return 0
end
function p.open(name, mode)
name, mode = fnormalize(name), mode or "r"
return p:openFile(name, mode)
end
function p.write(h,v)
return p:writeHandle(h,v)
end
function p.read(h,v)
return p:readHandle(h,v)
end
function p.close(h)
return p:closeHandle(h)
end
function p.getLabel()
return p.label
end
function p.setLabel(label)
p.label = label
p:updateSB()
end
return p
end
function rtfs.format(d,label)
d=common.getProxy(d)
print(d.address)
d.writeSector(1, string.pack(sbformat,"rtfs", 0, 1, label or ""))
rtfs.mount(d):writeIEntry(1, ftypes.empty, 2, (d.getCapacity() / d.getSectorSize()) - 2, "")
end
return rtfs