Hard Disk

local disk = io.open("/dev/storage1")
local free = sys.ioctl(sys.fileno(disk), "getCapacity") - sys.ioctl(sys.fileno(disk), "getUsed")

-- Back up a directory onto another disk, keeping the last few copies, as a nightly backup job does.
--
-- usage: lua disk-backup.lua [directory [disk]]
--   directory  what to back up (default /home)
--   disk       the backup disk's name in /dev (default storage1): an hfs disk, which mcos mounts
--              by itself when it joins the bus (a disk in SATA slot 1 at /mnt/sata/1)
--
-- Each run copies the directory to backup/1, backup/2... on the disk, and then removes the oldest
-- copies beyond KEEP. Before it copies anything, it asks the disk itself, through ioctls on its /dev
-- file (getCapacity, getUsed), whether the copy fits, so a backup that can't fit is refused whole.
local sys = require("sys")
local fs = require("fs")

local KEEP = 3 -- copies kept on the disk
local ENTRY = 512 -- what a disk counts for each file and directory, on top of its bytes
local FOLDER = "backup" -- where the copies go, on the disk

local from, diskname = ...
from = from or "/home"
diskname = diskname or "storage1"

local function die(...)
  io.stderr:write("disk-backup: ", ...)
  io.stderr:write("\n")
  os.exit(1)
end

-- The disk, as the kernel knows it, and where it's mounted.
local device
for _, d in ipairs(sys.devices()) do
  if d.name == diskname then
    device = d
  end
end
if not device or device.type ~= "storage" then
  die(diskname, ": not a disk")
end
local mountpoint
for _, mount in ipairs(sys.mounts()) do
  if mount.source == device.path or mount.source == device.id then
    mountpoint = mount.path
  end
end
if not mountpoint then
  die(diskname, ": not mounted (a raw disk has no files: format it hfs)")
end

-- What a tree takes on a disk: its files' bytes, and an entry for each file and directory.
local function size(path)
  local stat = assert(sys.stat(path))
  if stat.type ~= "directory" then
    return ENTRY + stat.size
  end
  local total = ENTRY
  for _, entry in ipairs(assert(fs.list(path))) do
    total = total + size(fs.join(path, entry.name))
  end
  return total
end

-- Ask the disk how much room it has.
local disk = assert(io.open("/dev/" .. diskname))
local fd = sys.fileno(disk)
local capacity = assert(sys.ioctl(fd, "getCapacity"))
local used = assert(sys.ioctl(fd, "getUsed"))
disk:close()

local needed = size(from)
if needed > capacity - used then
  die(from, " needs ", needed, " bytes; ", diskname, " has ", capacity - used, " free")
end

-- The copies there now, oldest first.
local folder = fs.join(mountpoint, FOLDER)
assert(fs.mkdir(folder, true))
local copies = {}
for _, entry in ipairs(assert(fs.list(folder))) do
  local n = tonumber(entry.name)
  if n and entry.type == "directory" then
    copies[#copies + 1] = n
  end
end
table.sort(copies)

local number = (copies[#copies] or 0) + 1
local to = fs.join(folder, tostring(number))
assert(fs.copy(from, to, true))
copies[#copies + 1] = number
print("backed up " .. from .. " to " .. to .. " (" .. needed .. " bytes)")

while #copies > KEEP do
  local oldest = fs.join(folder, tostring(table.remove(copies, 1)))
  assert(fs.remove(oldest, true))
  print("removed " .. oldest)
end

-- A log kept on a raw disk, with no filesystem: lines are added at the end, and read back in order.
--
-- usage: lua disk-raw-log.lua add [disk]     adds each line of standard input
--        lua disk-raw-log.lua show [disk]    writes every line kept, oldest first
--        lua disk-raw-log.lua clear [disk]   empties it
-- disk is the raw disk's name in /dev (default storage1).
--
-- A raw disk's /dev file is its bytes, from offset 0 to its capacity, as a Linux block device's:
-- read, written and sought anywhere. This log keeps a 16-byte header at offset 0 saying how many
-- bytes of lines follow it ("rawlog " and eight digits), and the lines right after. A disk never
-- written is all zeros, which reads as an empty log.
local sys = require("sys")

local HEADER = 16 -- bytes of the header, at offset 0
local MAGIC = "rawlog " -- how a header starts
local CHUNK = 4096 -- the most a disk's read gives at once

local command, diskname = ...
diskname = diskname or "storage1"

local function die(...)
  io.stderr:write("disk-raw-log: ", ...)
  io.stderr:write("\n")
  os.exit(1)
end

local fd, why = sys.open("/dev/" .. diskname, "r+")
if not fd then
  die(diskname, ": ", why)
end
local mode = sys.ioctl(fd, "getMode")
if mode ~= "raw" then
  die(diskname, " is ", tostring(mode), ": wipe it raw first (a Disk Station's wipe)")
end
local capacity = assert(sys.ioctl(fd, "getCapacity"))

-- Bytes from an offset, as many as asked (a read gives at most CHUNK).
local function readat(offset, n)
  assert(sys.lseek(fd, offset, "set"))
  local parts = {}
  while n > 0 do
    local data = assert(sys.read(fd, math.min(n, CHUNK)))
    if data == "" then
      break -- the disk's end
    end
    parts[#parts + 1] = data
    n = n - #data
  end
  return table.concat(parts)
end

local function writeat(offset, data)
  assert(sys.lseek(fd, offset, "set"))
  assert(sys.write(fd, data))
end

-- How many bytes of lines there are (0 for a disk that holds no log yet).
local function length()
  local header = readat(0, HEADER)
  return tonumber(header:match("^" .. MAGIC .. "(%d+)\n")) or 0
end

local function setlength(n)
  writeat(0, string.format("%s%08d\n", MAGIC, n))
end

if command == "add" then
  local at = length()
  for line in io.lines() do
    local record = line .. "\n"
    if HEADER + at + #record > capacity then
      die(diskname, " is full")
    end
    writeat(HEADER + at, record)
    at = at + #record
    setlength(at) -- (after each line: a log cut short still holds every line it says it has)
  end
elseif command == "show" then
  local left, offset = length(), HEADER
  while left > 0 do
    local data = readat(offset, math.min(left, CHUNK))
    io.write(data)
    offset, left = offset + #data, left - #data
  end
elseif command == "clear" then
  setlength(0)
else
  die("usage: disk-raw-log.lua add|show|clear [disk]")
end
sys.close(fd)

-- Watch a disk's directories for changes, whoever makes them (this computer, another one on the
-- same disk, a Disk Station), and log each one with the world's time.
--
-- usage: lua disk-watch.lua [log [directory...]] &
--   log        where the lines go (default /home/disk-watch.log)
--   directory  what to watch (default /mnt/sata/1, the disk in SATA slot 1)
--
-- A disk reports every change made on it, and mcos turns its reports into inotify notices, in the
-- paths it's mounted at: "CREATE /mnt/sata/1/photos", "MODIFY ...", "DELETE ...", a rename as
-- "MOVED_FROM" and "MOVED_TO", and "OVERFLOW" when notices were lost or the disk was formatted.
-- Watching a directory reports its entries too. The read blocks until a notice comes: no time is
-- used while nothing happens.
local sys = require("sys")

local args = {...}
local logname = args[1] or "/home/disk-watch.log"
local watched = {table.unpack(args, 2)}
if #watched == 0 then
  watched = {"/mnt/sata/1"}
end

local fd = assert(sys.inotify())
for _, path in ipairs(watched) do
  assert(sys.watch(fd, path))
end

local pending = "" -- a notice read only in part, waiting for its end
while true do
  local data = assert(sys.read(fd)) -- blocks until there are notices
  pending = pending .. data
  local lines = {}
  for notice in pending:gmatch("([^\n]*)\n") do
    lines[#lines + 1] = os.date("%T ") .. notice .. "\n"
  end
  pending = pending:match("[^\n]*$")
  if #lines > 0 then
    local log = assert(io.open(logname, "a")) -- (opened and closed each time: a disk's file shows
    log:write(table.concat(lines)) --          its writes at close)
    log:close()
  end
end

-- Survey every disk on the bus: its format, how full it is, and what's at its root, asked of each
-- disk directly through ioctls on its /dev file, mounted or not.
--
-- usage: lua disk-survey.lua
--
-- A device file's ioctls are its device's methods, by name: getMode, getCapacity and getUsed work on
-- any disk; list and stat on an hfs one (a raw disk refuses them: it has no files). Paths given to
-- them are the disk's own, from its root, whatever mcos mounts it as.
local sys = require("sys")

local KIB = 1024

-- One disk's lines.
local function survey(device)
  local disk, why = io.open("/dev/" .. device.name)
  if not disk then
    return device.name .. ": " .. why .. "\n"
  end
  local fd = sys.fileno(disk)
  local mode = assert(sys.ioctl(fd, "getMode"))
  local capacity = assert(sys.ioctl(fd, "getCapacity"))
  local used = assert(sys.ioctl(fd, "getUsed"))
  local lines = {string.format("%s %s %s %d/%d KiB used%s", device.name, device.path or device.id, mode,
    used // KIB, capacity // KIB, device.label and (" \"" .. device.label .. "\"") or "")}
  if mode == "hfs" then
    for _, entry in ipairs(assert(sys.ioctl(fd, "list", "/", true))) do
      local stat = sys.ioctl(fd, "stat", "/" .. entry.name, true) -- (true: a link itself)
      if entry.type == "directory" then
        lines[#lines + 1] = "  " .. entry.name .. "/"
      elseif entry.type == "link" then
        lines[#lines + 1] = "  " .. entry.name .. " -> " .. stat.link
      else
        lines[#lines + 1] = string.format("  %s %d", entry.name, stat.size)
      end
    end
  end
  disk:close()
  return table.concat(lines, "\n") .. "\n"
end

for _, device in ipairs(sys.devices()) do
  if device.type == "storage" then
    io.write(survey(device))
  end
end