fdisk/exec/fdisk.lua

@@ -1,30 +0,0 @@
-local tA = {...}
-local fdisk = {}
-local addr = component.get(table.remove(tA, 1))
-assert(addr, "drive not found")
-local cmd = table.remove(tA, 1) or "show"
-
-function fdisk.show()
- local ts = component.invoke(addr, component.type(addr) == "tape_drive" and "getSize" or "getCapacity")
- local cs = ts / 512
- print(string.format("Drive %s - %iKiB, %0.0f sectors:", addr:sub(1,8), ts//1024,cs))
- print(" #  Name                 Type Start   Len   End")
- for k,v in ipairs(require("diskpart").getPartitions(addr)) do
-  print(string.format("%2i: %-20s %4s %5i %5i %5i",k,v[1],v[2],v[3],v[4],(v[3] + v[4])-1))
- end
-end
-function fdisk.del(i)
- local pt = require("diskpart").getPartitions(addr)
- table.remove(pt, i)
- require("diskpart").setPartitions(addr, pt)
- fdisk.show()
-end
-function fdisk.add(name, ftype, start, len)
- local pt = require("diskpart").getPartitions(addr)
- pt[#pt+1] = {name, ftype, start, len}
- require("diskpart").setPartitions(addr, pt)
- fdisk.show()
-end
-
-assert(fdisk[cmd], "unknown command")
-fdisk[cmd](table.unpack(tA))

fdisk/package.cfg

@@ -1,4 +0,0 @@
-{["name"]="fdisk",
- ["description"]="Partition management utility",
- ["authors"]="Izaya",
- ["dependencies"]={"diskpart"}}

partman/package.cfg

@@ -1,4 +1,4 @@
 {["name"]="partman",
  ["description"]="Partition vcomponent management daemon",
  ["authors"]="Izaya",
- ["dependencies"]={"vcomponent", "diskpart"}}
+ ["dependencies"]={"vcomponent"}}

partman/service/partman.lua

@@ -1,32 +1,13 @@
 local diskpart = require "diskpart"
 local vcomponent = require "vcomponent"
 local partman = {}
-partman.fstypes = {"rtfs"}
 local run = true
 
-local function attachPartition(addr)
- syslog("Finding filesystem that will mount "..addr)
- for _,n in ipairs(partman.fstypes) do
-  local w,l = pcall(require,string.format("fs.%s",n))
-  if w then
-   syslog("Trying "..n)
-   local w, f = pcall(l.mount,addr)
-   if w then
-    syslog(n.." successful!")
-    vcomponent.register(string.format("%s/%s",addr,n), "filesystem",f)
-    break
-   end
-  end
- end
-end
-
-local function attachDrive(addr)
+local function attach(addr)
  for k,v in ipairs(diskpart.getPartitions(addr)) do
   if v[4] > 0 then
    syslog(string.format("Registering vcomponent for partition %s/%i",addr,k))
    vcomponent.register(string.format("%s/%i",addr,k), "partition", diskpart.proxyPartition(addr, k))
-   syslog("Attempting to mount a filesystem...")
-   attachPartition(string.format("%s/%i",addr,k))
   end
  end
 end
@@ -35,16 +16,16 @@ function partman.start()
  run = true
  os.spawn(function()
   for a,_ in component.list("drive") do
-   attachDrive(a)
+   attach(a)
   end
   while run do
    local tE = {coroutine.yield()}
    if tE[1] == "component_added" and tE[3] == "drive" then
-    attachDrive(tE[2])
+    attach(tE[2])
    elseif tE[1] == "component_removed" and tE[3] == "drive" then
-    for a,t in component.list() do
-     if (t == "partition" or t == "filesystem") and a:sub(1,tE[2]:len()) == tE[2] then
-      syslog("Removing "..t.." vcomponent "..a)
+    for a,t in component.list("partition") do
+     if a:sub(1,tE[2]:len()) == tE[2] then
+      syslog("Removing partition vcomponent "..a)
       vcomponent.unregister(a)
      end
     end

rtfs-v0/package.cfg

@@ -1,4 +0,0 @@
-{["name"]="rtfs-v0",
- ["description"]="RT-11 filesystem clone",
- ["authors"]="Izaya",
- ["dependencies"]={"rtfs"}}

rtfs/exec/rtfsboot.lua

@@ -1,30 +0,0 @@
-local diskpart = require "diskpart"
-local rtfs = require "rtfs"
-local tA = {...}
-local fsname,fname = fs.resolve(tA[1])
-
-local drive, part = fs.address(tA[1]):match("([%x%-]+)/(%d)")
-part=tonumber(part)
-print(drive,part,fname)
-local m = rtfs.mount(drive.."/"..part)
-local np = {fname, "boot", 0, 0}
-for i, tp, ex, st, sl, n in m:allIEntries() do
- if tp == 9 and n == fname then
-  assert(ex == 0, "boot file cannot be fragmented")
-  np[3], np[4] = st, math.ceil(sl/512)
- end
-end
-local allparts = diskpart.getPartitions(drive)
-local pindex = #allparts+1
-np[3] = np[3] - (allparts[part][3] - 1)
-for k,v in ipairs(allparts) do
- if v[2] == "boot" then
-  pindex = k
-  break
- end
-end
-allparts[pindex] = np
-for k,v in ipairs(allparts) do
- print(k, table.unpack(v))
-end
-diskpart.setPartitions(drive, allparts)

rtfs/lib/fs/rtfs/init.lua

@@ -1,66 +0,0 @@
-local cache = (package.loaded["fs.rtfs"] or {}).cache or {hitsR=0, hitsW=0, missesR=0, missesW=0}
-local proxy = {}
-local rtfs = {proxy=proxy, cache=cache}
-local sbformat = ">c4I2I8c18" -- "rtfs" magic, version, index size in entries, label. label length subject to change.
-
-rtfs.cacheSize = computer.totalMemory() // 1024 // 16
-
--- data mangling functions
-function rtfs.fnormalize(s)
- return table.concat(fs.segments(s),"/")
-end
-function proxy:log(message,level)
- syslog(message,level or syslog.debug,"rtfs:"..self.label)
-end
-
-
--- just for ease-of-use
-function rtfs.getProxy(addr)
- if type(addr) == "string" then
-  return component.proxy(component.get(addr,"partition") or component.get(addr) or addr)
- end
- return addr
-end
-
--- cache stuff
-local function cacheClean()
- while #cache > rtfs.cacheSize do
-  table.remove(cache, 1)
- end
-end
-function proxy:cachedRead(s)
- for k,v in ipairs(cache) do
-  if v[1] == self.d.address and v[2] == s then
-   rtfs.cache.hitsR = rtfs.cache.hitsR + 1
-   return v[3]
-  end
- end
- cache[#cache + 1] = {self.d.address, s, self.d.readSector(s)}
- rtfs.cache.missesR = rtfs.cache.missesR + 1
- cacheClean()
- return cache[#cache][3]
-end
-function proxy:cachedWrite(s,d)
- for k,v in ipairs(cache) do
-  if v[1] == self.d.address and v[2] == s then
-   table.remove(cache, k)
-  end
- end
- cache[#cache + 1] = {self.d.address, s, d}
- cacheClean()
- return self.d.writeSector(s,d)
-end
-
-function rtfs.mount(a)
- local d = rtfs.getProxy(a)
- local magic, version = string.unpack(sbformat, d.readSector(1))
- assert(magic == "rtfs","not an rtfs filesystem")
- local w, l = pcall(require, string.format("fs.rtfs.v%i", version))
- if w then return l.mount(a) end
- error("incompatible rtfs version")
-end
-function rtfs.format(a,l)
- return require("fs.rtfs.v1").format(a,l)
-end
-
-return rtfs

rtfs/lib/fs/rtfs/v1.lua

@@ -1,508 +0,0 @@
-local common = require "fs.rtfs"
-local rtfs, proxy = {}, setmetatable({},{__index=common.proxy})
-local ieformat = ">I2I8I8c46" -- type (4 bits) and index (12 bits), start sector (32 bits), lenth in bytes (32 bits), name/path (46 bytes)
-local sbformat = ">c4I2I8c18" -- "rtfs" magic, version, index size in entries, label. label length subject to change.
-local iesize = string.packsize(ieformat)
-local ftypes = {
- empty = 0,
- dfile = 1,
- dfext = 2,
- ddir = 3,
- ddex = 4,
- dtfile = 5,
- dtext = 6,
- dlink = 7,
- unused = 8,
- file = 9,
- fext = 10,
- dir = 11,
- dex = 12,
- tfile = 13,
- text = 14,
- link = 15
-}
-
--- 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", 1, 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))}
- local et, ex = rt[1]>>12, rt[1]&0x1FF
- rt[4] = rt[4]:gsub("\0","")
- rt[5] = nil
- return et, ex, table.unpack(rt,2)
-end
-function proxy:writeIEntry(n,et,ex,es,el,en) -- index, type, extent index, extent start, extent length, extent name
- local ne = string.pack(ieformat, (et<<12) | (ex & 0x1FF), es, el, en)
- local sector, sstart, send = self:cSOI(n)
- -- check if there's an extent in the way of this entry
- while self:findIEntry(nil,nil,nil,nil,nil,sector) do
-  self:log("auto-compact triggered")
-  -- compactIndex will shrink the extent if it is safe to overwrite (deleted, free, etc)
-  n = self:compactIndex(n) or self.isize + 1
-  local newn = n == self.isize + 1
-  -- if that fails, because it can't be shrunk, we need to move it ourselves
-  local fi, ft = self:findIEntry(nil,nil,nil,nil,nil,sector)
-  if fi and ft[1] > ftypes.unused then
-   self:log("auto-compact unsuccessful, trying to relocate extent")
-   -- try to find a suitable free space
-   local lfi, lfis = self:bestFree()
-   local lf = {self:readIEntry(lfi)}
-   -- if it's not big enough, give up.
-   assert(lf[4] >= ft[4], "unable to relocate extent to write index entry")
-   -- if it is, create an extent structure at the end of the free space
-   local de = {ft[1], ft[2], lf[3] + lf[4]//self.blockSize - math.ceil(ft[4]/self.blockSize), ft[4], ft[5]}
-   lf[4] = lf[4] - (math.ceil(ft[4] / self.blockSize) * self.blockSize)
-   -- move the data to the new extent
-   for i = 0, ft[4]//self.blockSize do
-    self:writeExtent(de, i, self:readExtent(ft, i))
-   end
-   -- overwrite the old entries, which shouldn't get us back here
-   self:writeIEntry(fi, table.unpack(de))
-   self:writeIEntry(lfi, table.unpack(lf))
-   -- and finally, make a new entry for the now old data, sans one sector
-   self:writeIEntry(self:nextEntry(), ft[1]-8, ft[2], ft[3], ft[4] - self.blockSize, ft[5])
-  end
-  -- if the aim was to make a new entry, update n so it will do so
-  n = newn and self.isize + 1 or n
-  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))
- return 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
-
--- for debugging
-function proxy:dumpIndex()
- local t = {}
- for i, tp, ei, st, sl, n in self:allIEntries() do
-  t[#t+1] = {i,tp,ei,st,sl,(st+math.ceil(sl/self.blockSize))-1,n}
- end
- table.sort(t, function(a,b) return a[4] < b[4] end)
- print(" # ty ext# init      len  end name")
- for k,v in ipairs(t) do
-  if k % 23 == 0 then
-   io.read()
-   print(" # ty ext# init      len  end name")
-  end
-  print(string.format("%2i  %1x %4i %4i %8i %4i %s",table.unpack(v)))
- end
-end
-
--- index searching
-function proxy:findIEntry(et,ex,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, ix, st, sl, n in self:allIEntries() do
-  local sf = st + math.ceil(sl/self.blockSize) - 1
-  if (et or tp) == tp and (ex or ix) == ix 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 in self:allIEntries() do
-  if tp == ftypes.unused then
-   ni = i
-   break
-  end
- end
- return ni
-end
-
--- extent allocation
-function proxy:bestFree(last)
- local ri, sri
- local bs, sbs = 0, 0
- if last then
-  ri, rs = self:findIEntry(nil,nil,last[3]+math.ceil(last[4]/self.blockSize))
-  if ri and rs and rs[1] <= ftypes.ddex then
-   return ri, false, true
-  end
- end
- for i, tp, ei, st, sl, n in self:allIEntries() do
-  if tp <= ftypes.ddex 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:allocateExtent(name, etype, ei, esize, last)
- etype, ei, esize = etype or ftypes.tfile, ei or 0, math.ceil(math.max(4096,esize or self.capacity / 256)/self.blockSize)*self.blockSize
- self:compactIndex()
- local lfi,lfis,lfext = self:bestFree(last)
- local lf = {self:readIEntry(lfi)}
- local esize = math.min(esize, lf[4])
- local lfs, es = lf[4]//self.blockSize, esize//self.blockSize
- -- if biggest available area, split and put extent in the middle
- if lfis then
-  local new = {etype, ei, lf[3] + math.floor(lfs/2), esize, name}
-  lf[4] = math.floor(lfs/2) * self.blockSize
-  local free = {ftypes.empty, 0, new[3] + es, lfs*self.blockSize - new[4] - lf[4], ""}
-  self:writeIEntry(lfi, table.unpack(lf))
-  self:writeIEntry(self:nextEntry(), table.unpack(new))
-  self:writeIEntry(self:nextEntry(), table.unpack(free))
-  return self:findIEntry(etype, ei, nil, nil, name)
- else -- otherwise, put it at the start
-  local new = {etype, ei, lf[3], esize, name}
-  local free = {ftypes.empty, 0, new[3] + es, lfs*self.blockSize - new[4], ""}
-  local efi, eff
-  if last then
-   last={table.unpack(last)}
-   efi, eff = self:findIEntry(table.unpack(last))
-  end
-  -- if a previous entry was provided and the name matches, continue the extent
-  if lfext and efi and name == eff[5] then
-   last[4] = math.ceil((last[4] + new[4]) / self.blockSize) * self.blockSize
-   new = last
-   self:writeIEntry(efi, table.unpack(new))
-   self:writeIEntry(lfi, table.unpack(free))
-   lfi=efi
-  -- failing that, replace the free space entry with the new extent and
-  -- write a new free space entry
-  else
-   self:writeIEntry(lfi, table.unpack(new))
-   self:writeIEntry(self:nextEntry(), table.unpack(free))
-  end
-  return lfi, new, lfext and new[4]
- end
- return false
-end
-
-function proxy:writeExtent(ft, o, d) -- write a sector to an extent
- assert(o >= 0 and o < (ft[4]//self.blockSize) + 1, "out of range")
- assert(#d <= self.blockSize, "block too large")
- return self.d.writeSector(ft[3] + o, d .. ("\0"):rep(self.blockSize - #d))
-end
-function proxy:readExtent(ft, o) -- read a sector from an extent
- assert(o >= 0 and o < (ft[4]//self.blockSize) + 1, "out of range")
- return self.d.readSector(ft[3] + o):sub(1, math.min(self.blockSize, ft[4] - (o*self.blockSize)))
-end
-
-function proxy:openHandle(name, mode, fmt)
- name, fmt = fnormalize(name), fmt or {ftypes.file, ftypes.fext, ftypes.tfile, ftypes.text}
- local handle, xt = {aft={},fmt=fmt,buffer="",bytes=0}
- for c in mode:gmatch(".") do
-  handle[c] = true
- end
- local fi, oft = self:findIEntry(fmt[1], nil, nil, nil, name)
- if handle.r then
-  if not fi then
-   return false, "file not found"
-  end
-  handle.ft, handle.aft[1] = oft, oft
- elseif handle.w or handle.a then
-  if handle.a and fi then
-   local lfi, lf = self:findIEntry(fmt[2], oft[2], nil, nil, oft[5])
-   fi, handle.ft, xt = self:allocateExtent(name, fmt[4], oft[2] + 1, nil, lf or oft)
-   -- if in append mode, put the file extent into the "all extents" table to be updated later
-   handle.aft[1], handle.bytes = oft, xt and (lfi and lf[4] or oft[4]) or 0
-   -- read the last sector into the write buffer so it can be written back to disk with new data
-   -- then rewind the counter so it does get written
-   if handle.bytes%self.blockSize ~= 0 then
-    handle.buffer = self:readExtent(lf or oft, handle.bytes//512)
-    handle.bytes = handle.bytes - #handle.buffer
-   end
-  else
-   -- allocate the new extent to write into
-   fi, handle.ft = self:allocateExtent(name, fmt[3])
-  end
-  handle.aft[#handle.aft+(xt and 0 or 1)] = handle.ft
- end
- local ni = #self.handles+1
- self.handles[ni] = handle
- return ni
-end
-
-function proxy:closeHandle(h)
- local handle = self.handles[h]
- if handle.w or handle.a then
-  -- flush the buffer just in case
-  self:writeHandle(h, "", true)
-  local fs = handle.ft[4] - handle.bytes
-  -- update each index entry 
-  self:compactIndex()
-  -- mark any old entries with a matching name as deleted when not appending
-  if not handle.a then
-   for i, tp, ei, st, sl, n in self:allIEntries() do
-    if n == handle.aft[1][5] and tp > 8 then
-     self:writeIEntry(i, tp-8, ei, st, sl, n)
-    end
-   end
-  end
-  for k,v in ipairs(handle.aft) do
-   local fi, ft = self:findIEntry(table.unpack(v))
-   self:writeIEntry(fi,
-    -- determine if it's the file or extent part
-    (v[1] == handle.fmt[3] or v[1] == handle.fmt[1]) and handle.fmt[1] or handle.fmt[2],
-    -- file part wants the number of extents, extents want their index
-    (v[1] == handle.fmt[3] or v[1] == handle.fmt[1]) and handle.ft[2] or v[2],
-    -- the rest is fine as is, unless it's the last item
-    v[3], v == handle.ft and handle.bytes or v[4], v[5]
-   )
-  end
-  if fs > self.blockSize then
-   self:writeIEntry(self:nextEntry(), ftypes.empty, 0, handle.ft[3] + math.ceil(handle.bytes / self.blockSize), (fs//self.blockSize)*self.blockSize, "")
-   self:compactIndex()
-  end
- end
- self.handles[h] = nil
-end
-
-function proxy:writeHandle(h,d,f)
- local handle = self.handles[h]
- assert(handle.w or handle.a, "file not open in writable mode")
- handle.buffer = handle.buffer .. d
- local rv
- -- only attempt to write when there's enough data, or forced
- while #handle.buffer >= self.blockSize or f do 
-  f = false
-  -- allocate a new extent if this one is full
-  if handle.bytes >= handle.ft[4] then
-   local fi, ft, xt = self:allocateExtent(handle.ft[5], handle.fmt[4], handle.ft[2] + 1, nil, handle.ft)
-   if xt then
-    handle.aft[#handle.aft], handle.ft = ft, ft
-   else
-    handle.aft[#handle.aft+1], handle.ft, handle.bytes = ft, ft, 0
-   end
-  end
-  -- write a block and increment the counter
-  local wb = handle.buffer:sub(1, self.blockSize)
-  handle.buffer = handle.buffer:sub(self.blockSize + 1)
-  rv = self:writeExtent(handle.ft, handle.bytes//self.blockSize, wb)
-  handle.bytes = handle.bytes + #wb
- end
- return rv
-end
-
-function proxy:readHandle(h)
- local handle = self.handles[h]
- assert(handle.r, "file not open in read mode")
- -- if there's no more data in the extent, find the next
- if handle.bytes >= handle.ft[4] then
-  local ce = handle.ft[1] == handle.fmt[2] and handle.ft[2] or 0
-  if ce >= handle.aft[1][2] then
-   return nil
-  end
-  local fi, ft = self:findIEntry(handle.fmt[2], ce + 1, nil, nil, handle.ft[5])
-  handle.aft[#handle.aft+1], handle.ft, handle.bytes = ft, ft, 0
- end
- local rb = self:readExtent(handle.ft, handle.bytes//512)
- handle.bytes = handle.bytes + #rb
- return rb
-end
-
-function proxy:compactIndex(ti)
- -- compact contingous free space
- for i, tp, ei, st, sl, n in self:allIEntries() do
-  if tp <= ftypes.ddex then
-   sl=math.max(sl/self.blockSize)
-   local ni, nt = self:findIEntry(nil,nil,st+sl)
-   if ni and nt and nt[1] <= ftypes.ddex then
-    self:writeIEntry(i,tp,ei,st,(sl*self.blockSize)+nt[4],n)
-    self:writeIEntry(ni,ftypes.unused,0,0,0,"")
-   elseif tp <= ftypes.ddex and sl < 1 then
-    self:writeIEntry(i,ftypes.unused,0,0,0,"")
-   end
-  end
- end
- local ri
- -- reverse walk the index to find holes
- for i = self.isize, 1, -1 do
-  local ne = self:nextEntry() or self.isize
-  local ft = {self:readIEntry(i)}
-  if ne < i then
-   self:writeIEntry(ne, table.unpack(ft))
-   self:setISize(i-1)
-   ri = (ti == i) and ne or ri
-  end 
- end
-
- -- resize space at end of disk
- local li, ls, lt = 0, 0, nil
- for i, tp, ei, st, sl, n in self:allIEntries() do
-  sl=math.max(sl/self.blockSize)
-  if st+sl > ls then
-   li, ls = i, st+sl
-   lt = {tp, ei, st, sl, n}
-  end
- end
- if lt[1] <= ftypes.text then
-  local lastsec = (self.capacity / self.blockSize) - math.ceil(self.isize / (self.blockSize / iesize))
-  self:writeIEntry(li, lt[1], lt[2], lt[3], (lastsec - lt[3])*self.blockSize, lt[5])
- end
- return ri
-end
-
-function rtfs.mount(p)
- local d = common.getProxy(p)
- local p = setmetatable({}, {__index=proxy})
- p.d = d
- p.fstype, p.version, p.isize, p.label = string.unpack(sbformat,d.readSector(1))
- assert(p.fstype == "rtfs", "incorrect magic")
- assert(p.version == 1, "incompatible rtfs version")
- p.d = d
- p.cache, p.handles = {}, {}
- p.cacheHits, p.cacheMisses = 0, 0
- p.blockSize, p.capacity, p.label = d.getSectorSize(), d.getCapacity(), p.label:gsub("\0","")
-
- -- FS proxy functions
- function p.exists(name)
-  name = fnormalize(name)
-  for i, tp, ex, st, sl, n in p:allIEntries() do
-   if (tp == ftypes.file or tp == ftypes.dir) and n == name then
-    return true
-   end
-  end
- end
- function p.isDirectory(name)
-  name = fnormalize(name)
-  return name == "" and true or p:findIEntry(ftypes.dir, nil, nil, nil, name) ~= nil
- end
- function p.size(name)
-  name = fnormalize(name)
-  local rv = 0
-  for i, tp, ex, st, sl, n in p:allIEntries() do
-   if n == name and tp > ftypes.unused then
-    rv = rv + sl
-   end
-  end
-  return rv
- end
- function p.spaceUsed()
-  local c = 0
-  for i, tp, ex, st, sl, n in p:allIEntries() do
-   if tp > ftypes.unused then
-    c = c + sl
-   end
-  end
-  return c
- 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, ex, 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.dir) and pn == name then
-    rt[#rt+1] = fn .. ((tp == ftypes.dir and "/") or "")
-   end
-  end
-  return rt
- end
- function p.makeDirectory(name)
-  name = fnormalize(name)
-  if #name < 1 or p:findIEntry(nil,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.dir, 0, 0, 0, name)
---  p:setISize(math.max(p.isize, ni))
-  return true
- end
-
- function p.remove(name)
-  name = fnormalize(name)
-  for i, tp, ex, st, sl, n in p:allIEntries() do
-   if n == name and tp > ftypes.unused then
-    p:writeIEntry(i, tp-8, ex, st, sl, n)
-   end
-  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.dir or ftypes.file, nil, nil, to)
-   ft[5] = 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:openHandle(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(p, label)
- local d = common.getProxy(p)
- print(d.address)
- d.writeSector(1, string.pack(sbformat,"rtfs", 1, 1, label or ""))
- rtfs.mount(d):writeIEntry(1, ftypes.empty, 0, 2, d.getCapacity() - (d.getSectorSize() * 2), "")
-end
-
-return rtfs

rtfs/lib/rtfs.lua

@@ -1,5 +1,6 @@
-local common = require "fs.rtfs"
-local rtfs, proxy = {}, setmetatable({},{__index=common.proxy})
+local rtfs, internal = {}, {}
+local proxy = {}
+proxy.cacheSize = 8
 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.
@@ -17,7 +18,9 @@ function proxy:log(message,level)
 end
 
 -- data mangling functions
-local fnormalize = common.fnormalize
+local function fnormalize(s)
+ return table.concat(fs.segments(s),"/")
+end
 function proxy:cSOI(n)
  n=n-1
  local ms = self.capacity / self.blockSize
@@ -28,6 +31,42 @@ function proxy:cSOI(n)
  return ms - s, so+1, eo
 end
 
+-- just for ease-of-use
+local function getProxy(addr)
+ if type(addr) == "string" then
+  return component.proxy(component.get(addr,"partition") or component.get(addr) or addr)
+ end
+ return addr
+end
+
+-- cache stuff
+function proxy:cacheClean()
+ while #self.cache > self.cacheSize do
+  table.remove(self.cache, 1)
+ end
+end
+function proxy:cachedRead(s)
+ for k,v in ipairs(self.cache) do
+  if v[1] == s then
+   self.cacheHits = self.cacheHits + 1
+   return v[2]
+  end
+ end
+ self.cache[#self.cache + 1] = {s, self.d.readSector(s)}
+ self.cacheMisses = self.cacheMisses + 1
+ return self.cache[#self.cache][2]
+end
+function proxy:cachedWrite(s,d)
+ for k,v in ipairs(self.cache) do
+  if v[1] == s then
+   table.remove(self.cache, k)
+  end
+ end
+ self.cache[#self.cache + 1] = {s, d}
+ self:cacheClean()
+ return self.d.writeSector(s,d)
+end
+
 -- superblock stuff
 function proxy:updateSB()
  self:cachedWrite(1,string.pack(sbformat, "rtfs", 0, self.isize, self.label))
@@ -373,7 +412,7 @@ end
 ----------
 
 function rtfs.mount(d)
- d=common.getProxy(d)
+ d=getProxy(d)
  local p = setmetatable({}, {__index=proxy})
  local magic, version, isize, label = string.unpack(sbformat,d.readSector(1))
  assert(magic == "rtfs", "incorrect magic")
@@ -497,7 +536,7 @@ function rtfs.mount(d)
 end
 
 function rtfs.format(d,label)
- d=common.getProxy(d)
+ d=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, "")

rtfsman/package.cfg

@@ -0,0 +1,4 @@
+{["name"]="rtfsman",
+ ["description"]="rtfs auto-attach daemon",
+ ["authors"]="Izaya",
+ ["dependencies"]={"vcomponent"}}

rtfsman/service/rtfsman.lua

@@ -0,0 +1,38 @@
+local vcomponent = require "vcomponent"
+local rtfs = require "rtfs"
+local rtfsman = {}
+rtfsman.filesystems = {}
+local run = true
+
+local function attach(addr)
+ local w, e = pcall(rtfs.mount,component.proxy(addr))
+ if w then
+  syslog("rtfs filesystem found on " .. addr)
+  rtfsman.filesystems[addr] = true
+  vcomponent.register(addr .. "/rtfs", "filesystem", e)
+ end
+end
+
+function rtfsman.start()
+ run = true
+ return os.spawn(function()
+  for a,_ in component.list("partition") do
+   attach(a)
+  end
+  while run do
+   local tE = {coroutine.yield()}
+   if tE[1] == "component_added" and tE[3] == "partition" then
+    attach(tE[2])
+   elseif tE[1] == "component_removed" and rtfsman.filesystems[tE[2]] and tE[3] == "partition" then
+    syslog("Un-registering rtfs filesystem on " .. tE[2])
+    vcomponent.unregister(tE[2] .. "/rtfs")
+    rtfsman.filesystems[tE[2]] = nil
+   end
+  end
+ end,"rtfs-manager")
+end
+function rtfsman.stop()
+ run = false
+end
+
+return rtfsman