// État + logique métier. Tailles en octets. const S = { devs: {}, order: [], pools: {}, sel: null }; const U = { B: 1, K: 1024, M: 1024 ** 2, G: 1024 ** 3, T: 1024 ** 4 }; const FS = ['ext4', 'btrfs', 'xfs', 'vfat', 'ntfs', 'zfs', 'swap']; let seq = 0; const uid = () => 'x' + (++seq) + Math.random().toString(36).slice(2, 6); const unitOf = b => b >= U.T ? ['T', U.T] : b >= U.G ? ['G', U.G] : b >= U.M ? ['M', U.M] : ['K', U.K]; const num = (x, d) => String(+x.toFixed(d)).replace('.', ','); const fmtIEC = b => { const [u, v] = unitOf(b); return num(b / v, 2) + ' ' + u + 'io'; }; const fmtLsblk = b => { const [u, v] = unitOf(b); return num(b / v, 1) + u; }; const sz = x => { // "463,2G" | 1234 | "1234" -> octets if (typeof x === 'number') return x; const m = String(x).match(/^([\d.,]+)\s*([BKMGT])?/i); return m ? parseFloat(m[1].replace(',', '.')) * U[(m[2] || 'B').toUpperCase()] : 0; }; const diskOf = d => d.kind === 'disk' ? d : d.kind === 'part' ? S.devs[d.parent] : null; const free = d => d.size - d.children.reduce((a, c) => a + S.devs[c].size, 0); function mk(o) { const d = { id: uid(), fstype: '', label: '', used: null, mounts: [], children: [], rm: '0', ro: '0', ...o }; S.devs[d.id] = d; return d; } const nextNvmeMinor = () => 1 + Math.max(-1, ...Object.values(S.devs).filter(d => d.majmin.startsWith('259:')).map(d => +d.majmin.split(':')[1])); function addDisk(size, media) { const names = Object.values(S.devs).filter(d => d.kind === 'disk').map(d => d.name); let i = 0, name, majmin; if (media === 'nvme') { while (names.includes(`nvme${i}n1`)) i++; name = `nvme${i}n1`; majmin = '259:' + nextNvmeMinor(); } else { while (names.includes('sd' + String.fromCharCode(97 + i))) i++; name = 'sd' + String.fromCharCode(97 + i); majmin = '8:' + i * 16; } const d = mk({ kind: 'disk', name, size, majmin, rm: media === 'sd' ? '0' : '0' }); S.order.push(d.id); return d; } function addPart(disk, size, fstype) { if (disk.pool) dissolvePool(disk.pool); disk.fstype = ''; disk.mounts = []; // disque entier -> partitionné const n = 1 + Math.max(0, ...disk.children.map(c => parseInt(S.devs[c].name.match(/(\d+)$/)[1]))); const nv = disk.name.startsWith('nvme'); const base = +disk.majmin.split(':')[1]; const p = mk({ kind: 'part', name: disk.name + (nv ? 'p' : '') + n, size, parent: disk.id, fstype, majmin: nv ? '259:' + nextNvmeMinor() : '8:' + (base + n) }); disk.children.push(p.id); return p; } function setFs(d, fstype, label) { d.fstype = fstype; d.label = label; d.mounts = []; d.used = null; } function addMount(d, mp, subvol) { if (!d.fstype || d.fstype === 'swap') return 'Formate d\'abord (hors swap).'; if (!mp.startsWith('/')) return 'Le point de montage doit commencer par /.'; if (Object.values(S.devs).some(x => x.mounts.some(m => m.mp === mp))) return `${mp} est déjà monté.`; d.mounts.push({ mp, subvol }); return ''; } const RAID_MIN = { 0: 2, 1: 2, 5: 3, 6: 4, 10: 4 }; const typeOf = d => d.kind === 'raid' ? 'raid' + d.level : d.kind; const eligible = () => Object.values(S.devs).filter(d => (d.kind === 'part' || (d.kind === 'disk' && !d.children.length)) && !d.mounts.length && d.fstype !== 'swap' && d.fstype !== 'linux_raid_member' && !d.pool); function addRaid(ids, level) { if (ids.length < RAID_MIN[level]) return `RAID ${level} : au moins ${RAID_MIN[level]} membres.`; if (level === 10 && ids.length % 2) return 'RAID 10 : nombre pair de membres.'; const s = ids.map(i => S.devs[i].size), min = Math.min(...s), n = s.length; const size = level === 0 ? s.reduce((a, b) => a + b, 0) : level === 1 ? min : level === 5 ? min * (n - 1) : level === 6 ? min * (n - 2) : min * n / 2; const names = Object.values(S.devs).map(d => d.name); let i = 0; while (names.includes('md' + i)) i++; const r = mk({ kind: 'raid', name: 'md' + i, level, size, majmin: '9:' + i, members: ids }); ids.forEach(m => { S.devs[m].fstype = 'linux_raid_member'; }); S.sel = r.id; return ''; } const freeMembers = r => r.members.forEach(m => { const x = S.devs[m]; if (x && x.fstype === 'linux_raid_member') x.fstype = ''; }); function dropRaids(id) { Object.values(S.devs).filter(r => r.kind === 'raid' && r.members.includes(id)).forEach(r => { freeMembers(r); delete S.devs[r.id]; }); } // Pool btrfs multi-périphériques : pas de mdX, tous les membres sont "btrfs", // le montage n'est affiché que sur le membre principal (comme lsblk). const BTRFS_MIN = { single: 2, raid0: 2, raid1: 2, raid1c3: 3, raid10: 4, raid5: 2, raid6: 3 }; const host = d => d.pool ? S.devs[S.pools[d.pool].primary] : d; function addPool(ids, profile, label) { if (ids.length < BTRFS_MIN[profile]) return `btrfs ${profile} : au moins ${BTRFS_MIN[profile]} périphériques.`; const s = ids.map(i => S.devs[i].size), sum = s.reduce((a, b) => a + b, 0), max = Math.max(...s); const usable = { single: sum, raid0: sum, raid1: Math.min(sum / 2, sum - max), raid1c3: Math.min(sum / 3, (sum - max) / 2), raid10: sum / 2, raid5: sum - max, raid6: sum - 2 * max }[profile]; const id = 'pool' + uid(); S.pools[id] = { id, profile, label, usable, members: ids, primary: ids[0] }; ids.forEach(i => { const d = S.devs[i]; d.fstype = 'btrfs'; d.pool = id; d.label = label; d.mounts = []; d.used = null; }); S.sel = ids[0]; return ''; } function dissolvePool(pid) { const p = S.pools[pid]; if (!p) return; p.members.forEach(m => { const d = S.devs[m]; if (d) { d.fstype = ''; d.pool = null; d.label = ''; d.mounts = []; } }); delete S.pools[pid]; } function dropPool(id) { const d = S.devs[id]; if (d && d.pool) dissolvePool(d.pool); } function delDev(id) { const d = S.devs[id]; if (!d) return; if (d.kind === 'raid') freeMembers(d); else { dropRaids(id); dropPool(id); } if (d.kind === 'disk') { d.children.forEach(c => { dropRaids(c); dropPool(c); delete S.devs[c]; }); S.order = S.order.filter(x => x !== id); } else if (d.kind === 'part' && S.devs[d.parent]) S.devs[d.parent].children = S.devs[d.parent].children.filter(x => x !== id); delete S.devs[id]; S.sel = null; } // Lignes de l'arbre lsblk (1 ligne par point de montage, comme le vrai lsblk) // all=true : un pool btrfs affiche ses montages sur chaque membre (all=false : comme le vrai lsblk, membre principal seul) const mountTexts = (d, all) => d.fstype === 'swap' ? ['[SWAP]'] : (all ? host(d) : d).mounts.map(m => m.mp); function rows(all = true) { const out = []; const add = (d, name, pfx) => { const m = mountTexts(d, all); out.push({ d, name, mount: m[0] || '' }); m.slice(1).forEach(x => out.push({ d, name: pfx, mount: x, cont: true })); }; const raids = (d, ind) => Object.values(S.devs).filter(r => r.kind === 'raid' && r.members.includes(d.id)).forEach(r => add(r, ind + '└─' + r.name, '')); S.order.forEach(id => { const d = S.devs[id]; add(d, d.name, ''); raids(d, ''); d.children.forEach((c, i) => { const last = i === d.children.length - 1, p = S.devs[c]; add(p, (last ? '└─' : '├─') + p.name, last ? '' : '│'); raids(p, last ? ' ' : '│ '); }); }); return out; } const save = () => { try { localStorage.setItem('lsblk-mgr', JSON.stringify({ devs: S.devs, order: S.order, pools: S.pools })); } catch (e) {} }; const load = () => { try { const j = JSON.parse(localStorage.getItem('lsblk-mgr')); if (j && j.devs) { S.devs = j.devs; S.order = j.order; S.pools = j.pools || {}; S.sel = S.order[0] || null; } } catch (e) {} };