d/freebsd-nq
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
d694059f1e
freebsd-nq/tools/diag/prtblknos/prtblknos.c

313 lines
8.2 KiB
C
Raw Normal View History

This is a little C-program that can be used to print out the list of blocks used by a requested list of inodes. For example, to list the blocks referenced by your kernel: guest_12 % df / Filesystem 1K-blocks Used Avail Capacity Mounted on /dev/gpt/rootfs 20307196 10707336 7975288 57% / guest_12 % ls -i /boot/kernel/kernel 160603 /boot/kernel/kernel guest_12 % ./prtblknos /dev/gpt/rootfs 160603 160603: lbn 0-7 blkno 3217584-3217647 lbn 8-11 blkno 3217864-3217895 distance 216 First-level indirect, blkno 3217896-3217903 distance 0 lbn 12-19 blkno 3217904-3217967 distance 8 lbn 20-75 blkno 3251816-3252263 distance 33848 lbn 76-83 blkno 3252368-3252431 distance 104 lbn 84-91 blkno 3252464-3252527 distance 32 lbn 92-852 blkno 3252896-3258983 distance 368 Each contiguous range of blocks is printed on a line. The distance metric is the size of the gap from the end of the previous set of blocks to the beginning of the next set of blocks. Short distances are desirable.
2018-02-09 19:10:46 +00:00
/*
* Copyright (c) 1998, 2003, 2013, 2018 Marshall Kirk McKusick.
* All Rights Reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY MARSHALL KIRK MCKUSICK ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL MARSHALL KIRK MCKUSICK BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* $FreeBSD$
*/
#include <sys/param.h>
#include <ufs/ffs/fs.h>
#include <err.h>
#include <stdio.h>
Split tools/diag/prtblknos into two parts: main.c - opens disk and processes the argument list of inodes to be printed prtblknos.c - prints out the list of blocks used by an inode This change allows the fsdb program to import prtblknos() to use when printing out the set of blocks used by an inode. This program was switched to using the libufs library to ease its integration with fsdb and any other filesystem utility that might want to use it in the future.
2018-04-08 06:52:58 +00:00
#include <libufs.h>
This is a little C-program that can be used to print out the list of blocks used by a requested list of inodes. For example, to list the blocks referenced by your kernel: guest_12 % df / Filesystem 1K-blocks Used Avail Capacity Mounted on /dev/gpt/rootfs 20307196 10707336 7975288 57% / guest_12 % ls -i /boot/kernel/kernel 160603 /boot/kernel/kernel guest_12 % ./prtblknos /dev/gpt/rootfs 160603 160603: lbn 0-7 blkno 3217584-3217647 lbn 8-11 blkno 3217864-3217895 distance 216 First-level indirect, blkno 3217896-3217903 distance 0 lbn 12-19 blkno 3217904-3217967 distance 8 lbn 20-75 blkno 3251816-3252263 distance 33848 lbn 76-83 blkno 3252368-3252431 distance 104 lbn 84-91 blkno 3252464-3252527 distance 32 lbn 92-852 blkno 3252896-3258983 distance 368 Each contiguous range of blocks is printed on a line. The distance metric is the size of the gap from the end of the previous set of blocks to the beginning of the next set of blocks. Short distances are desirable.
2018-02-09 19:10:46 +00:00
union dinode {
Split tools/diag/prtblknos into two parts: main.c - opens disk and processes the argument list of inodes to be printed prtblknos.c - prints out the list of blocks used by an inode This change allows the fsdb program to import prtblknos() to use when printing out the set of blocks used by an inode. This program was switched to using the libufs library to ease its integration with fsdb and any other filesystem utility that might want to use it in the future.
2018-04-08 06:52:58 +00:00
struct ufs1_dinode dp1;
struct ufs2_dinode dp2;
This is a little C-program that can be used to print out the list of blocks used by a requested list of inodes. For example, to list the blocks referenced by your kernel: guest_12 % df / Filesystem 1K-blocks Used Avail Capacity Mounted on /dev/gpt/rootfs 20307196 10707336 7975288 57% / guest_12 % ls -i /boot/kernel/kernel 160603 /boot/kernel/kernel guest_12 % ./prtblknos /dev/gpt/rootfs 160603 160603: lbn 0-7 blkno 3217584-3217647 lbn 8-11 blkno 3217864-3217895 distance 216 First-level indirect, blkno 3217896-3217903 distance 0 lbn 12-19 blkno 3217904-3217967 distance 8 lbn 20-75 blkno 3251816-3252263 distance 33848 lbn 76-83 blkno 3252368-3252431 distance 104 lbn 84-91 blkno 3252464-3252527 distance 32 lbn 92-852 blkno 3252896-3258983 distance 368 Each contiguous range of blocks is printed on a line. The distance metric is the size of the gap from the end of the previous set of blocks to the beginning of the next set of blocks. Short distances are desirable.
2018-02-09 19:10:46 +00:00
};
Split tools/diag/prtblknos into two parts: main.c - opens disk and processes the argument list of inodes to be printed prtblknos.c - prints out the list of blocks used by an inode This change allows the fsdb program to import prtblknos() to use when printing out the set of blocks used by an inode. This program was switched to using the libufs library to ease its integration with fsdb and any other filesystem utility that might want to use it in the future.
2018-04-08 06:52:58 +00:00
void prtblknos(struct uufsd *disk, union dinode *dp);
This is a little C-program that can be used to print out the list of blocks used by a requested list of inodes. For example, to list the blocks referenced by your kernel: guest_12 % df / Filesystem 1K-blocks Used Avail Capacity Mounted on /dev/gpt/rootfs 20307196 10707336 7975288 57% / guest_12 % ls -i /boot/kernel/kernel 160603 /boot/kernel/kernel guest_12 % ./prtblknos /dev/gpt/rootfs 160603 160603: lbn 0-7 blkno 3217584-3217647 lbn 8-11 blkno 3217864-3217895 distance 216 First-level indirect, blkno 3217896-3217903 distance 0 lbn 12-19 blkno 3217904-3217967 distance 8 lbn 20-75 blkno 3251816-3252263 distance 33848 lbn 76-83 blkno 3252368-3252431 distance 104 lbn 84-91 blkno 3252464-3252527 distance 32 lbn 92-852 blkno 3252896-3258983 distance 368 Each contiguous range of blocks is printed on a line. The distance metric is the size of the gap from the end of the previous set of blocks to the beginning of the next set of blocks. Short distances are desirable.
2018-02-09 19:10:46 +00:00
Fix incorrect output for a file consisting of a single full-size block followed by a discontiguous fragment. Add checks for unallocated inodes and inodes with unknown mode types. Cleanup variable declarations by changing from type `int' to types like ufs_lbn_t, ufs2_daddr_t, etc. Reported by: bde
2018-04-19 22:43:55 +00:00
static const char *distance(struct fs *, ufs2_daddr_t, ufs2_daddr_t);
static void printblk(struct fs *, ufs_lbn_t, ufs2_daddr_t, int, ufs_lbn_t);
static void indirprt(struct uufsd *, int, ufs_lbn_t, ufs_lbn_t, ufs2_daddr_t,
ufs_lbn_t);
This is a little C-program that can be used to print out the list of blocks used by a requested list of inodes. For example, to list the blocks referenced by your kernel: guest_12 % df / Filesystem 1K-blocks Used Avail Capacity Mounted on /dev/gpt/rootfs 20307196 10707336 7975288 57% / guest_12 % ls -i /boot/kernel/kernel 160603 /boot/kernel/kernel guest_12 % ./prtblknos /dev/gpt/rootfs 160603 160603: lbn 0-7 blkno 3217584-3217647 lbn 8-11 blkno 3217864-3217895 distance 216 First-level indirect, blkno 3217896-3217903 distance 0 lbn 12-19 blkno 3217904-3217967 distance 8 lbn 20-75 blkno 3251816-3252263 distance 33848 lbn 76-83 blkno 3252368-3252431 distance 104 lbn 84-91 blkno 3252464-3252527 distance 32 lbn 92-852 blkno 3252896-3258983 distance 368 Each contiguous range of blocks is printed on a line. The distance metric is the size of the gap from the end of the previous set of blocks to the beginning of the next set of blocks. Short distances are desirable.
2018-02-09 19:10:46 +00:00
Split tools/diag/prtblknos into two parts: main.c - opens disk and processes the argument list of inodes to be printed prtblknos.c - prints out the list of blocks used by an inode This change allows the fsdb program to import prtblknos() to use when printing out the set of blocks used by an inode. This program was switched to using the libufs library to ease its integration with fsdb and any other filesystem utility that might want to use it in the future.
2018-04-08 06:52:58 +00:00
void
prtblknos(disk, dp)
struct uufsd *disk;
union dinode *dp;
This is a little C-program that can be used to print out the list of blocks used by a requested list of inodes. For example, to list the blocks referenced by your kernel: guest_12 % df / Filesystem 1K-blocks Used Avail Capacity Mounted on /dev/gpt/rootfs 20307196 10707336 7975288 57% / guest_12 % ls -i /boot/kernel/kernel 160603 /boot/kernel/kernel guest_12 % ./prtblknos /dev/gpt/rootfs 160603 160603: lbn 0-7 blkno 3217584-3217647 lbn 8-11 blkno 3217864-3217895 distance 216 First-level indirect, blkno 3217896-3217903 distance 0 lbn 12-19 blkno 3217904-3217967 distance 8 lbn 20-75 blkno 3251816-3252263 distance 33848 lbn 76-83 blkno 3252368-3252431 distance 104 lbn 84-91 blkno 3252464-3252527 distance 32 lbn 92-852 blkno 3252896-3258983 distance 368 Each contiguous range of blocks is printed on a line. The distance metric is the size of the gap from the end of the previous set of blocks to the beginning of the next set of blocks. Short distances are desirable.
2018-02-09 19:10:46 +00:00
{
Fix incorrect output for a file consisting of a single full-size block followed by a discontiguous fragment. Add checks for unallocated inodes and inodes with unknown mode types. Cleanup variable declarations by changing from type `int' to types like ufs_lbn_t, ufs2_daddr_t, etc. Reported by: bde
2018-04-19 22:43:55 +00:00
int i, mode, frags;
ufs_lbn_t lbn, lastlbn, len, blksperindir;
This is a little C-program that can be used to print out the list of blocks used by a requested list of inodes. For example, to list the blocks referenced by your kernel: guest_12 % df / Filesystem 1K-blocks Used Avail Capacity Mounted on /dev/gpt/rootfs 20307196 10707336 7975288 57% / guest_12 % ls -i /boot/kernel/kernel 160603 /boot/kernel/kernel guest_12 % ./prtblknos /dev/gpt/rootfs 160603 160603: lbn 0-7 blkno 3217584-3217647 lbn 8-11 blkno 3217864-3217895 distance 216 First-level indirect, blkno 3217896-3217903 distance 0 lbn 12-19 blkno 3217904-3217967 distance 8 lbn 20-75 blkno 3251816-3252263 distance 33848 lbn 76-83 blkno 3252368-3252431 distance 104 lbn 84-91 blkno 3252464-3252527 distance 32 lbn 92-852 blkno 3252896-3258983 distance 368 Each contiguous range of blocks is printed on a line. The distance metric is the size of the gap from the end of the previous set of blocks to the beginning of the next set of blocks. Short distances are desirable.
2018-02-09 19:10:46 +00:00
ufs2_daddr_t blkno;
Split tools/diag/prtblknos into two parts: main.c - opens disk and processes the argument list of inodes to be printed prtblknos.c - prints out the list of blocks used by an inode This change allows the fsdb program to import prtblknos() to use when printing out the set of blocks used by an inode. This program was switched to using the libufs library to ease its integration with fsdb and any other filesystem utility that might want to use it in the future.
2018-04-08 06:52:58 +00:00
struct fs *fs;
off_t size;
fs = (struct fs *)&disk->d_sb;
Check the inode type and only attempt to print block lists for regular files, directories, and symbolic links that require external storage. Correct the handling of files with holes and files that have one or more large blocks and end with a fragment. Reported by: bde
2018-04-18 22:24:44 +00:00
if (fs->fs_magic == FS_UFS1_MAGIC) {
Split tools/diag/prtblknos into two parts: main.c - opens disk and processes the argument list of inodes to be printed prtblknos.c - prints out the list of blocks used by an inode This change allows the fsdb program to import prtblknos() to use when printing out the set of blocks used by an inode. This program was switched to using the libufs library to ease its integration with fsdb and any other filesystem utility that might want to use it in the future.
2018-04-08 06:52:58 +00:00
size = dp->dp1.di_size;
Check the inode type and only attempt to print block lists for regular files, directories, and symbolic links that require external storage. Correct the handling of files with holes and files that have one or more large blocks and end with a fragment. Reported by: bde
2018-04-18 22:24:44 +00:00
mode = dp->dp1.di_mode;
} else {
Split tools/diag/prtblknos into two parts: main.c - opens disk and processes the argument list of inodes to be printed prtblknos.c - prints out the list of blocks used by an inode This change allows the fsdb program to import prtblknos() to use when printing out the set of blocks used by an inode. This program was switched to using the libufs library to ease its integration with fsdb and any other filesystem utility that might want to use it in the future.
2018-04-08 06:52:58 +00:00
size = dp->dp2.di_size;
Check the inode type and only attempt to print block lists for regular files, directories, and symbolic links that require external storage. Correct the handling of files with holes and files that have one or more large blocks and end with a fragment. Reported by: bde
2018-04-18 22:24:44 +00:00
mode = dp->dp2.di_mode;
}
switch (mode & IFMT) {
Fix incorrect output for a file consisting of a single full-size block followed by a discontiguous fragment. Add checks for unallocated inodes and inodes with unknown mode types. Cleanup variable declarations by changing from type `int' to types like ufs_lbn_t, ufs2_daddr_t, etc. Reported by: bde
2018-04-19 22:43:55 +00:00
default:
printf("unknown inode type 0%d\n", (mode & IFMT));
return;
case 0:
printf("unallocated inode\n");
return;
Check the inode type and only attempt to print block lists for regular files, directories, and symbolic links that require external storage. Correct the handling of files with holes and files that have one or more large blocks and end with a fragment. Reported by: bde
2018-04-18 22:24:44 +00:00
case IFIFO:
printf("fifo\n");
return;
case IFCHR:
printf("character device\n");
return;
case IFBLK:
printf("block device\n");
Split tools/diag/prtblknos into two parts: main.c - opens disk and processes the argument list of inodes to be printed prtblknos.c - prints out the list of blocks used by an inode This change allows the fsdb program to import prtblknos() to use when printing out the set of blocks used by an inode. This program was switched to using the libufs library to ease its integration with fsdb and any other filesystem utility that might want to use it in the future.
2018-04-08 06:52:58 +00:00
return;
Check the inode type and only attempt to print block lists for regular files, directories, and symbolic links that require external storage. Correct the handling of files with holes and files that have one or more large blocks and end with a fragment. Reported by: bde
2018-04-18 22:24:44 +00:00
case IFSOCK:
printf("socket\n");
return;
case IFWHT:
printf("whiteout\n");
return;
case IFLNK:
if (size == 0) {
printf("empty symbolic link\n");
return;
}
if (size < fs->fs_maxsymlinklen) {
printf("symbolic link referencing %s\n",
(fs->fs_magic == FS_UFS1_MAGIC) ?
(char *)dp->dp1.di_db :
(char *)dp->dp2.di_db);
return;
}
printf("symbolic link\n");
break;
case IFREG:
if (size == 0) {
printf("empty file\n");
return;
}
Fix incorrect output for a file consisting of a single full-size block followed by a discontiguous fragment. Add checks for unallocated inodes and inodes with unknown mode types. Cleanup variable declarations by changing from type `int' to types like ufs_lbn_t, ufs2_daddr_t, etc. Reported by: bde
2018-04-19 22:43:55 +00:00
printf("regular file, size %jd\n", (intmax_t)size);
Check the inode type and only attempt to print block lists for regular files, directories, and symbolic links that require external storage. Correct the handling of files with holes and files that have one or more large blocks and end with a fragment. Reported by: bde
2018-04-18 22:24:44 +00:00
break;
case IFDIR:
if (size == 0) {
printf("empty directory\n");
return;
}
Fix incorrect output for a file consisting of a single full-size block followed by a discontiguous fragment. Add checks for unallocated inodes and inodes with unknown mode types. Cleanup variable declarations by changing from type `int' to types like ufs_lbn_t, ufs2_daddr_t, etc. Reported by: bde
2018-04-19 22:43:55 +00:00
printf("directory, size %jd\n", (intmax_t)size);
Check the inode type and only attempt to print block lists for regular files, directories, and symbolic links that require external storage. Correct the handling of files with holes and files that have one or more large blocks and end with a fragment. Reported by: bde
2018-04-18 22:24:44 +00:00
break;
This is a little C-program that can be used to print out the list of blocks used by a requested list of inodes. For example, to list the blocks referenced by your kernel: guest_12 % df / Filesystem 1K-blocks Used Avail Capacity Mounted on /dev/gpt/rootfs 20307196 10707336 7975288 57% / guest_12 % ls -i /boot/kernel/kernel 160603 /boot/kernel/kernel guest_12 % ./prtblknos /dev/gpt/rootfs 160603 160603: lbn 0-7 blkno 3217584-3217647 lbn 8-11 blkno 3217864-3217895 distance 216 First-level indirect, blkno 3217896-3217903 distance 0 lbn 12-19 blkno 3217904-3217967 distance 8 lbn 20-75 blkno 3251816-3252263 distance 33848 lbn 76-83 blkno 3252368-3252431 distance 104 lbn 84-91 blkno 3252464-3252527 distance 32 lbn 92-852 blkno 3252896-3258983 distance 368 Each contiguous range of blocks is printed on a line. The distance metric is the size of the gap from the end of the previous set of blocks to the beginning of the next set of blocks. Short distances are desirable.
2018-02-09 19:10:46 +00:00
}
Fix incorrect output for a file consisting of a single full-size block followed by a discontiguous fragment. Add checks for unallocated inodes and inodes with unknown mode types. Cleanup variable declarations by changing from type `int' to types like ufs_lbn_t, ufs2_daddr_t, etc. Reported by: bde
2018-04-19 22:43:55 +00:00
lastlbn = howmany(size, fs->fs_bsize);
len = lastlbn < UFS_NDADDR ? lastlbn : UFS_NDADDR;
Split tools/diag/prtblknos into two parts: main.c - opens disk and processes the argument list of inodes to be printed prtblknos.c - prints out the list of blocks used by an inode This change allows the fsdb program to import prtblknos() to use when printing out the set of blocks used by an inode. This program was switched to using the libufs library to ease its integration with fsdb and any other filesystem utility that might want to use it in the future.
2018-04-08 06:52:58 +00:00
for (i = 0; i < len; i++) {
Fix incorrect output for a file consisting of a single full-size block followed by a discontiguous fragment. Add checks for unallocated inodes and inodes with unknown mode types. Cleanup variable declarations by changing from type `int' to types like ufs_lbn_t, ufs2_daddr_t, etc. Reported by: bde
2018-04-19 22:43:55 +00:00
if (i < lastlbn - 1)
Split tools/diag/prtblknos into two parts: main.c - opens disk and processes the argument list of inodes to be printed prtblknos.c - prints out the list of blocks used by an inode This change allows the fsdb program to import prtblknos() to use when printing out the set of blocks used by an inode. This program was switched to using the libufs library to ease its integration with fsdb and any other filesystem utility that might want to use it in the future.
2018-04-08 06:52:58 +00:00
frags = fs->fs_frag;
else
frags = howmany(size % fs->fs_bsize,
fs->fs_fsize);
if (fs->fs_magic == FS_UFS1_MAGIC)
blkno = dp->dp1.di_db[i];
else
blkno = dp->dp2.di_db[i];
Fix incorrect output for a file consisting of a single full-size block followed by a discontiguous fragment. Add checks for unallocated inodes and inodes with unknown mode types. Cleanup variable declarations by changing from type `int' to types like ufs_lbn_t, ufs2_daddr_t, etc. Reported by: bde
2018-04-19 22:43:55 +00:00
printblk(fs, i, blkno, frags, lastlbn);
This is a little C-program that can be used to print out the list of blocks used by a requested list of inodes. For example, to list the blocks referenced by your kernel: guest_12 % df / Filesystem 1K-blocks Used Avail Capacity Mounted on /dev/gpt/rootfs 20307196 10707336 7975288 57% / guest_12 % ls -i /boot/kernel/kernel 160603 /boot/kernel/kernel guest_12 % ./prtblknos /dev/gpt/rootfs 160603 160603: lbn 0-7 blkno 3217584-3217647 lbn 8-11 blkno 3217864-3217895 distance 216 First-level indirect, blkno 3217896-3217903 distance 0 lbn 12-19 blkno 3217904-3217967 distance 8 lbn 20-75 blkno 3251816-3252263 distance 33848 lbn 76-83 blkno 3252368-3252431 distance 104 lbn 84-91 blkno 3252464-3252527 distance 32 lbn 92-852 blkno 3252896-3258983 distance 368 Each contiguous range of blocks is printed on a line. The distance metric is the size of the gap from the end of the previous set of blocks to the beginning of the next set of blocks. Short distances are desirable.
2018-02-09 19:10:46 +00:00
}
Split tools/diag/prtblknos into two parts: main.c - opens disk and processes the argument list of inodes to be printed prtblknos.c - prints out the list of blocks used by an inode This change allows the fsdb program to import prtblknos() to use when printing out the set of blocks used by an inode. This program was switched to using the libufs library to ease its integration with fsdb and any other filesystem utility that might want to use it in the future.
2018-04-08 06:52:58 +00:00
blksperindir = 1;
Fix incorrect output for a file consisting of a single full-size block followed by a discontiguous fragment. Add checks for unallocated inodes and inodes with unknown mode types. Cleanup variable declarations by changing from type `int' to types like ufs_lbn_t, ufs2_daddr_t, etc. Reported by: bde
2018-04-19 22:43:55 +00:00
len = lastlbn - UFS_NDADDR;
Split tools/diag/prtblknos into two parts: main.c - opens disk and processes the argument list of inodes to be printed prtblknos.c - prints out the list of blocks used by an inode This change allows the fsdb program to import prtblknos() to use when printing out the set of blocks used by an inode. This program was switched to using the libufs library to ease its integration with fsdb and any other filesystem utility that might want to use it in the future.
2018-04-08 06:52:58 +00:00
lbn = UFS_NDADDR;
for (i = 0; len > 0 && i < UFS_NIADDR; i++) {
if (fs->fs_magic == FS_UFS1_MAGIC)
blkno = dp->dp1.di_ib[i];
else
blkno = dp->dp2.di_ib[i];
Fix incorrect output for a file consisting of a single full-size block followed by a discontiguous fragment. Add checks for unallocated inodes and inodes with unknown mode types. Cleanup variable declarations by changing from type `int' to types like ufs_lbn_t, ufs2_daddr_t, etc. Reported by: bde
2018-04-19 22:43:55 +00:00
indirprt(disk, i, blksperindir, lbn, blkno, lastlbn);
Split tools/diag/prtblknos into two parts: main.c - opens disk and processes the argument list of inodes to be printed prtblknos.c - prints out the list of blocks used by an inode This change allows the fsdb program to import prtblknos() to use when printing out the set of blocks used by an inode. This program was switched to using the libufs library to ease its integration with fsdb and any other filesystem utility that might want to use it in the future.
2018-04-08 06:52:58 +00:00
blksperindir *= NINDIR(fs);
lbn += blksperindir;
len -= blksperindir;
This is a little C-program that can be used to print out the list of blocks used by a requested list of inodes. For example, to list the blocks referenced by your kernel: guest_12 % df / Filesystem 1K-blocks Used Avail Capacity Mounted on /dev/gpt/rootfs 20307196 10707336 7975288 57% / guest_12 % ls -i /boot/kernel/kernel 160603 /boot/kernel/kernel guest_12 % ./prtblknos /dev/gpt/rootfs 160603 160603: lbn 0-7 blkno 3217584-3217647 lbn 8-11 blkno 3217864-3217895 distance 216 First-level indirect, blkno 3217896-3217903 distance 0 lbn 12-19 blkno 3217904-3217967 distance 8 lbn 20-75 blkno 3251816-3252263 distance 33848 lbn 76-83 blkno 3252368-3252431 distance 104 lbn 84-91 blkno 3252464-3252527 distance 32 lbn 92-852 blkno 3252896-3258983 distance 368 Each contiguous range of blocks is printed on a line. The distance metric is the size of the gap from the end of the previous set of blocks to the beginning of the next set of blocks. Short distances are desirable.
2018-02-09 19:10:46 +00:00
}
Split tools/diag/prtblknos into two parts: main.c - opens disk and processes the argument list of inodes to be printed prtblknos.c - prints out the list of blocks used by an inode This change allows the fsdb program to import prtblknos() to use when printing out the set of blocks used by an inode. This program was switched to using the libufs library to ease its integration with fsdb and any other filesystem utility that might want to use it in the future.
2018-04-08 06:52:58 +00:00
/* dummy print to flush out last extent */
Fix incorrect output for a file consisting of a single full-size block followed by a discontiguous fragment. Add checks for unallocated inodes and inodes with unknown mode types. Cleanup variable declarations by changing from type `int' to types like ufs_lbn_t, ufs2_daddr_t, etc. Reported by: bde
2018-04-19 22:43:55 +00:00
printblk(fs, lastlbn, 0, frags, 0);
This is a little C-program that can be used to print out the list of blocks used by a requested list of inodes. For example, to list the blocks referenced by your kernel: guest_12 % df / Filesystem 1K-blocks Used Avail Capacity Mounted on /dev/gpt/rootfs 20307196 10707336 7975288 57% / guest_12 % ls -i /boot/kernel/kernel 160603 /boot/kernel/kernel guest_12 % ./prtblknos /dev/gpt/rootfs 160603 160603: lbn 0-7 blkno 3217584-3217647 lbn 8-11 blkno 3217864-3217895 distance 216 First-level indirect, blkno 3217896-3217903 distance 0 lbn 12-19 blkno 3217904-3217967 distance 8 lbn 20-75 blkno 3251816-3252263 distance 33848 lbn 76-83 blkno 3252368-3252431 distance 104 lbn 84-91 blkno 3252464-3252527 distance 32 lbn 92-852 blkno 3252896-3258983 distance 368 Each contiguous range of blocks is printed on a line. The distance metric is the size of the gap from the end of the previous set of blocks to the beginning of the next set of blocks. Short distances are desirable.
2018-02-09 19:10:46 +00:00
}
Split tools/diag/prtblknos into two parts: main.c - opens disk and processes the argument list of inodes to be printed prtblknos.c - prints out the list of blocks used by an inode This change allows the fsdb program to import prtblknos() to use when printing out the set of blocks used by an inode. This program was switched to using the libufs library to ease its integration with fsdb and any other filesystem utility that might want to use it in the future.
2018-04-08 06:52:58 +00:00
static void
indirprt(disk, level, blksperindir, lbn, blkno, lastlbn)
struct uufsd *disk;
This is a little C-program that can be used to print out the list of blocks used by a requested list of inodes. For example, to list the blocks referenced by your kernel: guest_12 % df / Filesystem 1K-blocks Used Avail Capacity Mounted on /dev/gpt/rootfs 20307196 10707336 7975288 57% / guest_12 % ls -i /boot/kernel/kernel 160603 /boot/kernel/kernel guest_12 % ./prtblknos /dev/gpt/rootfs 160603 160603: lbn 0-7 blkno 3217584-3217647 lbn 8-11 blkno 3217864-3217895 distance 216 First-level indirect, blkno 3217896-3217903 distance 0 lbn 12-19 blkno 3217904-3217967 distance 8 lbn 20-75 blkno 3251816-3252263 distance 33848 lbn 76-83 blkno 3252368-3252431 distance 104 lbn 84-91 blkno 3252464-3252527 distance 32 lbn 92-852 blkno 3252896-3258983 distance 368 Each contiguous range of blocks is printed on a line. The distance metric is the size of the gap from the end of the previous set of blocks to the beginning of the next set of blocks. Short distances are desirable.
2018-02-09 19:10:46 +00:00
int level;
Fix incorrect output for a file consisting of a single full-size block followed by a discontiguous fragment. Add checks for unallocated inodes and inodes with unknown mode types. Cleanup variable declarations by changing from type `int' to types like ufs_lbn_t, ufs2_daddr_t, etc. Reported by: bde
2018-04-19 22:43:55 +00:00
ufs_lbn_t blksperindir;
ufs_lbn_t lbn;
This is a little C-program that can be used to print out the list of blocks used by a requested list of inodes. For example, to list the blocks referenced by your kernel: guest_12 % df / Filesystem 1K-blocks Used Avail Capacity Mounted on /dev/gpt/rootfs 20307196 10707336 7975288 57% / guest_12 % ls -i /boot/kernel/kernel 160603 /boot/kernel/kernel guest_12 % ./prtblknos /dev/gpt/rootfs 160603 160603: lbn 0-7 blkno 3217584-3217647 lbn 8-11 blkno 3217864-3217895 distance 216 First-level indirect, blkno 3217896-3217903 distance 0 lbn 12-19 blkno 3217904-3217967 distance 8 lbn 20-75 blkno 3251816-3252263 distance 33848 lbn 76-83 blkno 3252368-3252431 distance 104 lbn 84-91 blkno 3252464-3252527 distance 32 lbn 92-852 blkno 3252896-3258983 distance 368 Each contiguous range of blocks is printed on a line. The distance metric is the size of the gap from the end of the previous set of blocks to the beginning of the next set of blocks. Short distances are desirable.
2018-02-09 19:10:46 +00:00
ufs2_daddr_t blkno;
Fix incorrect output for a file consisting of a single full-size block followed by a discontiguous fragment. Add checks for unallocated inodes and inodes with unknown mode types. Cleanup variable declarations by changing from type `int' to types like ufs_lbn_t, ufs2_daddr_t, etc. Reported by: bde
2018-04-19 22:43:55 +00:00
ufs_lbn_t lastlbn;
This is a little C-program that can be used to print out the list of blocks used by a requested list of inodes. For example, to list the blocks referenced by your kernel: guest_12 % df / Filesystem 1K-blocks Used Avail Capacity Mounted on /dev/gpt/rootfs 20307196 10707336 7975288 57% / guest_12 % ls -i /boot/kernel/kernel 160603 /boot/kernel/kernel guest_12 % ./prtblknos /dev/gpt/rootfs 160603 160603: lbn 0-7 blkno 3217584-3217647 lbn 8-11 blkno 3217864-3217895 distance 216 First-level indirect, blkno 3217896-3217903 distance 0 lbn 12-19 blkno 3217904-3217967 distance 8 lbn 20-75 blkno 3251816-3252263 distance 33848 lbn 76-83 blkno 3252368-3252431 distance 104 lbn 84-91 blkno 3252464-3252527 distance 32 lbn 92-852 blkno 3252896-3258983 distance 368 Each contiguous range of blocks is printed on a line. The distance metric is the size of the gap from the end of the previous set of blocks to the beginning of the next set of blocks. Short distances are desirable.
2018-02-09 19:10:46 +00:00
{
char indir[MAXBSIZE];
Split tools/diag/prtblknos into two parts: main.c - opens disk and processes the argument list of inodes to be printed prtblknos.c - prints out the list of blocks used by an inode This change allows the fsdb program to import prtblknos() to use when printing out the set of blocks used by an inode. This program was switched to using the libufs library to ease its integration with fsdb and any other filesystem utility that might want to use it in the future.
2018-04-08 06:52:58 +00:00
struct fs *fs;
Fix incorrect output for a file consisting of a single full-size block followed by a discontiguous fragment. Add checks for unallocated inodes and inodes with unknown mode types. Cleanup variable declarations by changing from type `int' to types like ufs_lbn_t, ufs2_daddr_t, etc. Reported by: bde
2018-04-19 22:43:55 +00:00
ufs_lbn_t i, last;
This is a little C-program that can be used to print out the list of blocks used by a requested list of inodes. For example, to list the blocks referenced by your kernel: guest_12 % df / Filesystem 1K-blocks Used Avail Capacity Mounted on /dev/gpt/rootfs 20307196 10707336 7975288 57% / guest_12 % ls -i /boot/kernel/kernel 160603 /boot/kernel/kernel guest_12 % ./prtblknos /dev/gpt/rootfs 160603 160603: lbn 0-7 blkno 3217584-3217647 lbn 8-11 blkno 3217864-3217895 distance 216 First-level indirect, blkno 3217896-3217903 distance 0 lbn 12-19 blkno 3217904-3217967 distance 8 lbn 20-75 blkno 3251816-3252263 distance 33848 lbn 76-83 blkno 3252368-3252431 distance 104 lbn 84-91 blkno 3252464-3252527 distance 32 lbn 92-852 blkno 3252896-3258983 distance 368 Each contiguous range of blocks is printed on a line. The distance metric is the size of the gap from the end of the previous set of blocks to the beginning of the next set of blocks. Short distances are desirable.
2018-02-09 19:10:46 +00:00
Split tools/diag/prtblknos into two parts: main.c - opens disk and processes the argument list of inodes to be printed prtblknos.c - prints out the list of blocks used by an inode This change allows the fsdb program to import prtblknos() to use when printing out the set of blocks used by an inode. This program was switched to using the libufs library to ease its integration with fsdb and any other filesystem utility that might want to use it in the future.
2018-04-08 06:52:58 +00:00
fs = (struct fs *)&disk->d_sb;
Check the inode type and only attempt to print block lists for regular files, directories, and symbolic links that require external storage. Correct the handling of files with holes and files that have one or more large blocks and end with a fragment. Reported by: bde
2018-04-18 22:24:44 +00:00
if (blkno == 0) {
printblk(fs, lbn, blkno,
blksperindir * NINDIR(fs) * fs->fs_frag, lastlbn);
return;
}
Split tools/diag/prtblknos into two parts: main.c - opens disk and processes the argument list of inodes to be printed prtblknos.c - prints out the list of blocks used by an inode This change allows the fsdb program to import prtblknos() to use when printing out the set of blocks used by an inode. This program was switched to using the libufs library to ease its integration with fsdb and any other filesystem utility that might want to use it in the future.
2018-04-08 06:52:58 +00:00
printblk(fs, lbn, blkno, fs->fs_frag, -level);
This is a little C-program that can be used to print out the list of blocks used by a requested list of inodes. For example, to list the blocks referenced by your kernel: guest_12 % df / Filesystem 1K-blocks Used Avail Capacity Mounted on /dev/gpt/rootfs 20307196 10707336 7975288 57% / guest_12 % ls -i /boot/kernel/kernel 160603 /boot/kernel/kernel guest_12 % ./prtblknos /dev/gpt/rootfs 160603 160603: lbn 0-7 blkno 3217584-3217647 lbn 8-11 blkno 3217864-3217895 distance 216 First-level indirect, blkno 3217896-3217903 distance 0 lbn 12-19 blkno 3217904-3217967 distance 8 lbn 20-75 blkno 3251816-3252263 distance 33848 lbn 76-83 blkno 3252368-3252431 distance 104 lbn 84-91 blkno 3252464-3252527 distance 32 lbn 92-852 blkno 3252896-3258983 distance 368 Each contiguous range of blocks is printed on a line. The distance metric is the size of the gap from the end of the previous set of blocks to the beginning of the next set of blocks. Short distances are desirable.
2018-02-09 19:10:46 +00:00
/* read in the indirect block. */
In addition to the existing argument format: prtblknos filesystem_device inode ... add an additional argument format: prtblknos file which is more convenient than figuring out the filesystem and inode number for "file". When given a list of multiple inodes, rather than exiting the program on an error with one of them, skip over it and continue with the next one. Submitted by: bde
2018-04-18 23:08:10 +00:00
if (bread(disk, fsbtodb(fs, blkno), indir, fs->fs_bsize) == -1) {
warn("Read of indirect block %jd failed", (intmax_t)blkno);
/* List the unreadable part as a hole */
printblk(fs, lbn, 0,
blksperindir * NINDIR(fs) * fs->fs_frag, lastlbn);
return;
}
Split tools/diag/prtblknos into two parts: main.c - opens disk and processes the argument list of inodes to be printed prtblknos.c - prints out the list of blocks used by an inode This change allows the fsdb program to import prtblknos() to use when printing out the set of blocks used by an inode. This program was switched to using the libufs library to ease its integration with fsdb and any other filesystem utility that might want to use it in the future.
2018-04-08 06:52:58 +00:00
last = howmany(lastlbn - lbn, blksperindir) < NINDIR(fs) ?
howmany(lastlbn - lbn, blksperindir) : NINDIR(fs);
This is a little C-program that can be used to print out the list of blocks used by a requested list of inodes. For example, to list the blocks referenced by your kernel: guest_12 % df / Filesystem 1K-blocks Used Avail Capacity Mounted on /dev/gpt/rootfs 20307196 10707336 7975288 57% / guest_12 % ls -i /boot/kernel/kernel 160603 /boot/kernel/kernel guest_12 % ./prtblknos /dev/gpt/rootfs 160603 160603: lbn 0-7 blkno 3217584-3217647 lbn 8-11 blkno 3217864-3217895 distance 216 First-level indirect, blkno 3217896-3217903 distance 0 lbn 12-19 blkno 3217904-3217967 distance 8 lbn 20-75 blkno 3251816-3252263 distance 33848 lbn 76-83 blkno 3252368-3252431 distance 104 lbn 84-91 blkno 3252464-3252527 distance 32 lbn 92-852 blkno 3252896-3258983 distance 368 Each contiguous range of blocks is printed on a line. The distance metric is the size of the gap from the end of the previous set of blocks to the beginning of the next set of blocks. Short distances are desirable.
2018-02-09 19:10:46 +00:00
if (blksperindir == 1) {
for (i = 0; i < last; i++) {
Split tools/diag/prtblknos into two parts: main.c - opens disk and processes the argument list of inodes to be printed prtblknos.c - prints out the list of blocks used by an inode This change allows the fsdb program to import prtblknos() to use when printing out the set of blocks used by an inode. This program was switched to using the libufs library to ease its integration with fsdb and any other filesystem utility that might want to use it in the future.
2018-04-08 06:52:58 +00:00
if (fs->fs_magic == FS_UFS1_MAGIC)
This is a little C-program that can be used to print out the list of blocks used by a requested list of inodes. For example, to list the blocks referenced by your kernel: guest_12 % df / Filesystem 1K-blocks Used Avail Capacity Mounted on /dev/gpt/rootfs 20307196 10707336 7975288 57% / guest_12 % ls -i /boot/kernel/kernel 160603 /boot/kernel/kernel guest_12 % ./prtblknos /dev/gpt/rootfs 160603 160603: lbn 0-7 blkno 3217584-3217647 lbn 8-11 blkno 3217864-3217895 distance 216 First-level indirect, blkno 3217896-3217903 distance 0 lbn 12-19 blkno 3217904-3217967 distance 8 lbn 20-75 blkno 3251816-3252263 distance 33848 lbn 76-83 blkno 3252368-3252431 distance 104 lbn 84-91 blkno 3252464-3252527 distance 32 lbn 92-852 blkno 3252896-3258983 distance 368 Each contiguous range of blocks is printed on a line. The distance metric is the size of the gap from the end of the previous set of blocks to the beginning of the next set of blocks. Short distances are desirable.
2018-02-09 19:10:46 +00:00
blkno = ((ufs1_daddr_t *)indir)[i];
else
blkno = ((ufs2_daddr_t *)indir)[i];
Split tools/diag/prtblknos into two parts: main.c - opens disk and processes the argument list of inodes to be printed prtblknos.c - prints out the list of blocks used by an inode This change allows the fsdb program to import prtblknos() to use when printing out the set of blocks used by an inode. This program was switched to using the libufs library to ease its integration with fsdb and any other filesystem utility that might want to use it in the future.
2018-04-08 06:52:58 +00:00
printblk(fs, lbn + i, blkno, fs->fs_frag, lastlbn);
This is a little C-program that can be used to print out the list of blocks used by a requested list of inodes. For example, to list the blocks referenced by your kernel: guest_12 % df / Filesystem 1K-blocks Used Avail Capacity Mounted on /dev/gpt/rootfs 20307196 10707336 7975288 57% / guest_12 % ls -i /boot/kernel/kernel 160603 /boot/kernel/kernel guest_12 % ./prtblknos /dev/gpt/rootfs 160603 160603: lbn 0-7 blkno 3217584-3217647 lbn 8-11 blkno 3217864-3217895 distance 216 First-level indirect, blkno 3217896-3217903 distance 0 lbn 12-19 blkno 3217904-3217967 distance 8 lbn 20-75 blkno 3251816-3252263 distance 33848 lbn 76-83 blkno 3252368-3252431 distance 104 lbn 84-91 blkno 3252464-3252527 distance 32 lbn 92-852 blkno 3252896-3258983 distance 368 Each contiguous range of blocks is printed on a line. The distance metric is the size of the gap from the end of the previous set of blocks to the beginning of the next set of blocks. Short distances are desirable.
2018-02-09 19:10:46 +00:00
}
return;
}
for (i = 0; i < last; i++) {
Split tools/diag/prtblknos into two parts: main.c - opens disk and processes the argument list of inodes to be printed prtblknos.c - prints out the list of blocks used by an inode This change allows the fsdb program to import prtblknos() to use when printing out the set of blocks used by an inode. This program was switched to using the libufs library to ease its integration with fsdb and any other filesystem utility that might want to use it in the future.
2018-04-08 06:52:58 +00:00
if (fs->fs_magic == FS_UFS1_MAGIC)
This is a little C-program that can be used to print out the list of blocks used by a requested list of inodes. For example, to list the blocks referenced by your kernel: guest_12 % df / Filesystem 1K-blocks Used Avail Capacity Mounted on /dev/gpt/rootfs 20307196 10707336 7975288 57% / guest_12 % ls -i /boot/kernel/kernel 160603 /boot/kernel/kernel guest_12 % ./prtblknos /dev/gpt/rootfs 160603 160603: lbn 0-7 blkno 3217584-3217647 lbn 8-11 blkno 3217864-3217895 distance 216 First-level indirect, blkno 3217896-3217903 distance 0 lbn 12-19 blkno 3217904-3217967 distance 8 lbn 20-75 blkno 3251816-3252263 distance 33848 lbn 76-83 blkno 3252368-3252431 distance 104 lbn 84-91 blkno 3252464-3252527 distance 32 lbn 92-852 blkno 3252896-3258983 distance 368 Each contiguous range of blocks is printed on a line. The distance metric is the size of the gap from the end of the previous set of blocks to the beginning of the next set of blocks. Short distances are desirable.
2018-02-09 19:10:46 +00:00
blkno = ((ufs1_daddr_t *)indir)[i];
else
blkno = ((ufs2_daddr_t *)indir)[i];
Split tools/diag/prtblknos into two parts: main.c - opens disk and processes the argument list of inodes to be printed prtblknos.c - prints out the list of blocks used by an inode This change allows the fsdb program to import prtblknos() to use when printing out the set of blocks used by an inode. This program was switched to using the libufs library to ease its integration with fsdb and any other filesystem utility that might want to use it in the future.
2018-04-08 06:52:58 +00:00
indirprt(disk, level - 1, blksperindir / NINDIR(fs),
This is a little C-program that can be used to print out the list of blocks used by a requested list of inodes. For example, to list the blocks referenced by your kernel: guest_12 % df / Filesystem 1K-blocks Used Avail Capacity Mounted on /dev/gpt/rootfs 20307196 10707336 7975288 57% / guest_12 % ls -i /boot/kernel/kernel 160603 /boot/kernel/kernel guest_12 % ./prtblknos /dev/gpt/rootfs 160603 160603: lbn 0-7 blkno 3217584-3217647 lbn 8-11 blkno 3217864-3217895 distance 216 First-level indirect, blkno 3217896-3217903 distance 0 lbn 12-19 blkno 3217904-3217967 distance 8 lbn 20-75 blkno 3251816-3252263 distance 33848 lbn 76-83 blkno 3252368-3252431 distance 104 lbn 84-91 blkno 3252464-3252527 distance 32 lbn 92-852 blkno 3252896-3258983 distance 368 Each contiguous range of blocks is printed on a line. The distance metric is the size of the gap from the end of the previous set of blocks to the beginning of the next set of blocks. Short distances are desirable.
2018-02-09 19:10:46 +00:00
lbn + blksperindir * i, blkno, lastlbn);
}
}
Fix incorrect output for a file consisting of a single full-size block followed by a discontiguous fragment. Add checks for unallocated inodes and inodes with unknown mode types. Cleanup variable declarations by changing from type `int' to types like ufs_lbn_t, ufs2_daddr_t, etc. Reported by: bde
2018-04-19 22:43:55 +00:00
static const char *
Split tools/diag/prtblknos into two parts: main.c - opens disk and processes the argument list of inodes to be printed prtblknos.c - prints out the list of blocks used by an inode This change allows the fsdb program to import prtblknos() to use when printing out the set of blocks used by an inode. This program was switched to using the libufs library to ease its integration with fsdb and any other filesystem utility that might want to use it in the future.
2018-04-08 06:52:58 +00:00
distance(fs, lastblk, firstblk)
struct fs *fs;
Fix incorrect output for a file consisting of a single full-size block followed by a discontiguous fragment. Add checks for unallocated inodes and inodes with unknown mode types. Cleanup variable declarations by changing from type `int' to types like ufs_lbn_t, ufs2_daddr_t, etc. Reported by: bde
2018-04-19 22:43:55 +00:00
ufs2_daddr_t lastblk;
ufs2_daddr_t firstblk;
This is a little C-program that can be used to print out the list of blocks used by a requested list of inodes. For example, to list the blocks referenced by your kernel: guest_12 % df / Filesystem 1K-blocks Used Avail Capacity Mounted on /dev/gpt/rootfs 20307196 10707336 7975288 57% / guest_12 % ls -i /boot/kernel/kernel 160603 /boot/kernel/kernel guest_12 % ./prtblknos /dev/gpt/rootfs 160603 160603: lbn 0-7 blkno 3217584-3217647 lbn 8-11 blkno 3217864-3217895 distance 216 First-level indirect, blkno 3217896-3217903 distance 0 lbn 12-19 blkno 3217904-3217967 distance 8 lbn 20-75 blkno 3251816-3252263 distance 33848 lbn 76-83 blkno 3252368-3252431 distance 104 lbn 84-91 blkno 3252464-3252527 distance 32 lbn 92-852 blkno 3252896-3258983 distance 368 Each contiguous range of blocks is printed on a line. The distance metric is the size of the gap from the end of the previous set of blocks to the beginning of the next set of blocks. Short distances are desirable.
2018-02-09 19:10:46 +00:00
{
Fix incorrect output for a file consisting of a single full-size block followed by a discontiguous fragment. Add checks for unallocated inodes and inodes with unknown mode types. Cleanup variable declarations by changing from type `int' to types like ufs_lbn_t, ufs2_daddr_t, etc. Reported by: bde
2018-04-19 22:43:55 +00:00
ufs2_daddr_t delta;
This is a little C-program that can be used to print out the list of blocks used by a requested list of inodes. For example, to list the blocks referenced by your kernel: guest_12 % df / Filesystem 1K-blocks Used Avail Capacity Mounted on /dev/gpt/rootfs 20307196 10707336 7975288 57% / guest_12 % ls -i /boot/kernel/kernel 160603 /boot/kernel/kernel guest_12 % ./prtblknos /dev/gpt/rootfs 160603 160603: lbn 0-7 blkno 3217584-3217647 lbn 8-11 blkno 3217864-3217895 distance 216 First-level indirect, blkno 3217896-3217903 distance 0 lbn 12-19 blkno 3217904-3217967 distance 8 lbn 20-75 blkno 3251816-3252263 distance 33848 lbn 76-83 blkno 3252368-3252431 distance 104 lbn 84-91 blkno 3252464-3252527 distance 32 lbn 92-852 blkno 3252896-3258983 distance 368 Each contiguous range of blocks is printed on a line. The distance metric is the size of the gap from the end of the previous set of blocks to the beginning of the next set of blocks. Short distances are desirable.
2018-02-09 19:10:46 +00:00
int firstcg, lastcg;
static char buf[100];
if (lastblk == 0)
return ("");
delta = firstblk - lastblk - 1;
Split tools/diag/prtblknos into two parts: main.c - opens disk and processes the argument list of inodes to be printed prtblknos.c - prints out the list of blocks used by an inode This change allows the fsdb program to import prtblknos() to use when printing out the set of blocks used by an inode. This program was switched to using the libufs library to ease its integration with fsdb and any other filesystem utility that might want to use it in the future.
2018-04-08 06:52:58 +00:00
firstcg = dtog(fs, firstblk);
lastcg = dtog(fs, lastblk);
This is a little C-program that can be used to print out the list of blocks used by a requested list of inodes. For example, to list the blocks referenced by your kernel: guest_12 % df / Filesystem 1K-blocks Used Avail Capacity Mounted on /dev/gpt/rootfs 20307196 10707336 7975288 57% / guest_12 % ls -i /boot/kernel/kernel 160603 /boot/kernel/kernel guest_12 % ./prtblknos /dev/gpt/rootfs 160603 160603: lbn 0-7 blkno 3217584-3217647 lbn 8-11 blkno 3217864-3217895 distance 216 First-level indirect, blkno 3217896-3217903 distance 0 lbn 12-19 blkno 3217904-3217967 distance 8 lbn 20-75 blkno 3251816-3252263 distance 33848 lbn 76-83 blkno 3252368-3252431 distance 104 lbn 84-91 blkno 3252464-3252527 distance 32 lbn 92-852 blkno 3252896-3258983 distance 368 Each contiguous range of blocks is printed on a line. The distance metric is the size of the gap from the end of the previous set of blocks to the beginning of the next set of blocks. Short distances are desirable.
2018-02-09 19:10:46 +00:00
if (firstcg == lastcg) {
snprintf(buf, 100, " distance %jd", (intmax_t)delta);
return (&buf[0]);
}
snprintf(buf, 100, " cg %d blk %jd to cg %d blk %jd",
Add (intmax_t) type casts to some printf parameters to keep i386 happy.
2018-04-08 07:18:29 +00:00
lastcg, (intmax_t)dtogd(fs, lastblk), firstcg,
(intmax_t)dtogd(fs, firstblk));
This is a little C-program that can be used to print out the list of blocks used by a requested list of inodes. For example, to list the blocks referenced by your kernel: guest_12 % df / Filesystem 1K-blocks Used Avail Capacity Mounted on /dev/gpt/rootfs 20307196 10707336 7975288 57% / guest_12 % ls -i /boot/kernel/kernel 160603 /boot/kernel/kernel guest_12 % ./prtblknos /dev/gpt/rootfs 160603 160603: lbn 0-7 blkno 3217584-3217647 lbn 8-11 blkno 3217864-3217895 distance 216 First-level indirect, blkno 3217896-3217903 distance 0 lbn 12-19 blkno 3217904-3217967 distance 8 lbn 20-75 blkno 3251816-3252263 distance 33848 lbn 76-83 blkno 3252368-3252431 distance 104 lbn 84-91 blkno 3252464-3252527 distance 32 lbn 92-852 blkno 3252896-3258983 distance 368 Each contiguous range of blocks is printed on a line. The distance metric is the size of the gap from the end of the previous set of blocks to the beginning of the next set of blocks. Short distances are desirable.
2018-02-09 19:10:46 +00:00
return (&buf[0]);
}
Fix incorrect output for a file consisting of a single full-size block followed by a discontiguous fragment. Add checks for unallocated inodes and inodes with unknown mode types. Cleanup variable declarations by changing from type `int' to types like ufs_lbn_t, ufs2_daddr_t, etc. Reported by: bde
2018-04-19 22:43:55 +00:00
static const char *indirname[UFS_NIADDR] = { "First", "Second", "Third" };
This is a little C-program that can be used to print out the list of blocks used by a requested list of inodes. For example, to list the blocks referenced by your kernel: guest_12 % df / Filesystem 1K-blocks Used Avail Capacity Mounted on /dev/gpt/rootfs 20307196 10707336 7975288 57% / guest_12 % ls -i /boot/kernel/kernel 160603 /boot/kernel/kernel guest_12 % ./prtblknos /dev/gpt/rootfs 160603 160603: lbn 0-7 blkno 3217584-3217647 lbn 8-11 blkno 3217864-3217895 distance 216 First-level indirect, blkno 3217896-3217903 distance 0 lbn 12-19 blkno 3217904-3217967 distance 8 lbn 20-75 blkno 3251816-3252263 distance 33848 lbn 76-83 blkno 3252368-3252431 distance 104 lbn 84-91 blkno 3252464-3252527 distance 32 lbn 92-852 blkno 3252896-3258983 distance 368 Each contiguous range of blocks is printed on a line. The distance metric is the size of the gap from the end of the previous set of blocks to the beginning of the next set of blocks. Short distances are desirable.
2018-02-09 19:10:46 +00:00
Split tools/diag/prtblknos into two parts: main.c - opens disk and processes the argument list of inodes to be printed prtblknos.c - prints out the list of blocks used by an inode This change allows the fsdb program to import prtblknos() to use when printing out the set of blocks used by an inode. This program was switched to using the libufs library to ease its integration with fsdb and any other filesystem utility that might want to use it in the future.
2018-04-08 06:52:58 +00:00
static void
Fix incorrect output for a file consisting of a single full-size block followed by a discontiguous fragment. Add checks for unallocated inodes and inodes with unknown mode types. Cleanup variable declarations by changing from type `int' to types like ufs_lbn_t, ufs2_daddr_t, etc. Reported by: bde
2018-04-19 22:43:55 +00:00
printblk(fs, lbn, blkno, numfrags, lastlbn)
Split tools/diag/prtblknos into two parts: main.c - opens disk and processes the argument list of inodes to be printed prtblknos.c - prints out the list of blocks used by an inode This change allows the fsdb program to import prtblknos() to use when printing out the set of blocks used by an inode. This program was switched to using the libufs library to ease its integration with fsdb and any other filesystem utility that might want to use it in the future.
2018-04-08 06:52:58 +00:00
struct fs *fs;
Fix incorrect output for a file consisting of a single full-size block followed by a discontiguous fragment. Add checks for unallocated inodes and inodes with unknown mode types. Cleanup variable declarations by changing from type `int' to types like ufs_lbn_t, ufs2_daddr_t, etc. Reported by: bde
2018-04-19 22:43:55 +00:00
ufs_lbn_t lbn;
This is a little C-program that can be used to print out the list of blocks used by a requested list of inodes. For example, to list the blocks referenced by your kernel: guest_12 % df / Filesystem 1K-blocks Used Avail Capacity Mounted on /dev/gpt/rootfs 20307196 10707336 7975288 57% / guest_12 % ls -i /boot/kernel/kernel 160603 /boot/kernel/kernel guest_12 % ./prtblknos /dev/gpt/rootfs 160603 160603: lbn 0-7 blkno 3217584-3217647 lbn 8-11 blkno 3217864-3217895 distance 216 First-level indirect, blkno 3217896-3217903 distance 0 lbn 12-19 blkno 3217904-3217967 distance 8 lbn 20-75 blkno 3251816-3252263 distance 33848 lbn 76-83 blkno 3252368-3252431 distance 104 lbn 84-91 blkno 3252464-3252527 distance 32 lbn 92-852 blkno 3252896-3258983 distance 368 Each contiguous range of blocks is printed on a line. The distance metric is the size of the gap from the end of the previous set of blocks to the beginning of the next set of blocks. Short distances are desirable.
2018-02-09 19:10:46 +00:00
ufs2_daddr_t blkno;
Fix incorrect output for a file consisting of a single full-size block followed by a discontiguous fragment. Add checks for unallocated inodes and inodes with unknown mode types. Cleanup variable declarations by changing from type `int' to types like ufs_lbn_t, ufs2_daddr_t, etc. Reported by: bde
2018-04-19 22:43:55 +00:00
int numfrags;
ufs_lbn_t lastlbn;
This is a little C-program that can be used to print out the list of blocks used by a requested list of inodes. For example, to list the blocks referenced by your kernel: guest_12 % df / Filesystem 1K-blocks Used Avail Capacity Mounted on /dev/gpt/rootfs 20307196 10707336 7975288 57% / guest_12 % ls -i /boot/kernel/kernel 160603 /boot/kernel/kernel guest_12 % ./prtblknos /dev/gpt/rootfs 160603 160603: lbn 0-7 blkno 3217584-3217647 lbn 8-11 blkno 3217864-3217895 distance 216 First-level indirect, blkno 3217896-3217903 distance 0 lbn 12-19 blkno 3217904-3217967 distance 8 lbn 20-75 blkno 3251816-3252263 distance 33848 lbn 76-83 blkno 3252368-3252431 distance 104 lbn 84-91 blkno 3252464-3252527 distance 32 lbn 92-852 blkno 3252896-3258983 distance 368 Each contiguous range of blocks is printed on a line. The distance metric is the size of the gap from the end of the previous set of blocks to the beginning of the next set of blocks. Short distances are desirable.
2018-02-09 19:10:46 +00:00
{
static int seq;
Fix incorrect output for a file consisting of a single full-size block followed by a discontiguous fragment. Add checks for unallocated inodes and inodes with unknown mode types. Cleanup variable declarations by changing from type `int' to types like ufs_lbn_t, ufs2_daddr_t, etc. Reported by: bde
2018-04-19 22:43:55 +00:00
static ufs2_daddr_t totfrags, lastindirblk, lastblk, firstblk;
This is a little C-program that can be used to print out the list of blocks used by a requested list of inodes. For example, to list the blocks referenced by your kernel: guest_12 % df / Filesystem 1K-blocks Used Avail Capacity Mounted on /dev/gpt/rootfs 20307196 10707336 7975288 57% / guest_12 % ls -i /boot/kernel/kernel 160603 /boot/kernel/kernel guest_12 % ./prtblknos /dev/gpt/rootfs 160603 160603: lbn 0-7 blkno 3217584-3217647 lbn 8-11 blkno 3217864-3217895 distance 216 First-level indirect, blkno 3217896-3217903 distance 0 lbn 12-19 blkno 3217904-3217967 distance 8 lbn 20-75 blkno 3251816-3252263 distance 33848 lbn 76-83 blkno 3252368-3252431 distance 104 lbn 84-91 blkno 3252464-3252527 distance 32 lbn 92-852 blkno 3252896-3258983 distance 368 Each contiguous range of blocks is printed on a line. The distance metric is the size of the gap from the end of the previous set of blocks to the beginning of the next set of blocks. Short distances are desirable.
2018-02-09 19:10:46 +00:00
if (lastlbn <= 0)
goto flush;
if (seq == 0) {
Fix incorrect output for a file consisting of a single full-size block followed by a discontiguous fragment. Add checks for unallocated inodes and inodes with unknown mode types. Cleanup variable declarations by changing from type `int' to types like ufs_lbn_t, ufs2_daddr_t, etc. Reported by: bde
2018-04-19 22:43:55 +00:00
seq = howmany(numfrags, fs->fs_frag);
totfrags = numfrags;
This is a little C-program that can be used to print out the list of blocks used by a requested list of inodes. For example, to list the blocks referenced by your kernel: guest_12 % df / Filesystem 1K-blocks Used Avail Capacity Mounted on /dev/gpt/rootfs 20307196 10707336 7975288 57% / guest_12 % ls -i /boot/kernel/kernel 160603 /boot/kernel/kernel guest_12 % ./prtblknos /dev/gpt/rootfs 160603 160603: lbn 0-7 blkno 3217584-3217647 lbn 8-11 blkno 3217864-3217895 distance 216 First-level indirect, blkno 3217896-3217903 distance 0 lbn 12-19 blkno 3217904-3217967 distance 8 lbn 20-75 blkno 3251816-3252263 distance 33848 lbn 76-83 blkno 3252368-3252431 distance 104 lbn 84-91 blkno 3252464-3252527 distance 32 lbn 92-852 blkno 3252896-3258983 distance 368 Each contiguous range of blocks is printed on a line. The distance metric is the size of the gap from the end of the previous set of blocks to the beginning of the next set of blocks. Short distances are desirable.
2018-02-09 19:10:46 +00:00
firstblk = blkno;
return;
}
if (lbn == 0) {
Fix incorrect output for a file consisting of a single full-size block followed by a discontiguous fragment. Add checks for unallocated inodes and inodes with unknown mode types. Cleanup variable declarations by changing from type `int' to types like ufs_lbn_t, ufs2_daddr_t, etc. Reported by: bde
2018-04-19 22:43:55 +00:00
seq = howmany(numfrags, fs->fs_frag);
totfrags = numfrags;
This is a little C-program that can be used to print out the list of blocks used by a requested list of inodes. For example, to list the blocks referenced by your kernel: guest_12 % df / Filesystem 1K-blocks Used Avail Capacity Mounted on /dev/gpt/rootfs 20307196 10707336 7975288 57% / guest_12 % ls -i /boot/kernel/kernel 160603 /boot/kernel/kernel guest_12 % ./prtblknos /dev/gpt/rootfs 160603 160603: lbn 0-7 blkno 3217584-3217647 lbn 8-11 blkno 3217864-3217895 distance 216 First-level indirect, blkno 3217896-3217903 distance 0 lbn 12-19 blkno 3217904-3217967 distance 8 lbn 20-75 blkno 3251816-3252263 distance 33848 lbn 76-83 blkno 3252368-3252431 distance 104 lbn 84-91 blkno 3252464-3252527 distance 32 lbn 92-852 blkno 3252896-3258983 distance 368 Each contiguous range of blocks is printed on a line. The distance metric is the size of the gap from the end of the previous set of blocks to the beginning of the next set of blocks. Short distances are desirable.
2018-02-09 19:10:46 +00:00
lastblk = 0;
firstblk = blkno;
lastindirblk = 0;
return;
}
if (lbn < lastlbn && ((firstblk == 0 && blkno == 0) ||
(firstblk == BLK_NOCOPY && blkno == BLK_NOCOPY) ||
(firstblk == BLK_SNAP && blkno == BLK_SNAP) ||
Check the inode type and only attempt to print block lists for regular files, directories, and symbolic links that require external storage. Correct the handling of files with holes and files that have one or more large blocks and end with a fragment. Reported by: bde
2018-04-18 22:24:44 +00:00
blkno == firstblk + seq * fs->fs_frag)) {
Fix incorrect output for a file consisting of a single full-size block followed by a discontiguous fragment. Add checks for unallocated inodes and inodes with unknown mode types. Cleanup variable declarations by changing from type `int' to types like ufs_lbn_t, ufs2_daddr_t, etc. Reported by: bde
2018-04-19 22:43:55 +00:00
seq += howmany(numfrags, fs->fs_frag);
totfrags += numfrags;
This is a little C-program that can be used to print out the list of blocks used by a requested list of inodes. For example, to list the blocks referenced by your kernel: guest_12 % df / Filesystem 1K-blocks Used Avail Capacity Mounted on /dev/gpt/rootfs 20307196 10707336 7975288 57% / guest_12 % ls -i /boot/kernel/kernel 160603 /boot/kernel/kernel guest_12 % ./prtblknos /dev/gpt/rootfs 160603 160603: lbn 0-7 blkno 3217584-3217647 lbn 8-11 blkno 3217864-3217895 distance 216 First-level indirect, blkno 3217896-3217903 distance 0 lbn 12-19 blkno 3217904-3217967 distance 8 lbn 20-75 blkno 3251816-3252263 distance 33848 lbn 76-83 blkno 3252368-3252431 distance 104 lbn 84-91 blkno 3252464-3252527 distance 32 lbn 92-852 blkno 3252896-3258983 distance 368 Each contiguous range of blocks is printed on a line. The distance metric is the size of the gap from the end of the previous set of blocks to the beginning of the next set of blocks. Short distances are desirable.
2018-02-09 19:10:46 +00:00
return;
}
flush:
if (seq == 0)
goto prtindir;
if (firstblk <= BLK_SNAP) {
if (seq == 1)
Fix incorrect output for a file consisting of a single full-size block followed by a discontiguous fragment. Add checks for unallocated inodes and inodes with unknown mode types. Cleanup variable declarations by changing from type `int' to types like ufs_lbn_t, ufs2_daddr_t, etc. Reported by: bde
2018-04-19 22:43:55 +00:00
printf("\tlbn %jd %s\n", (intmax_t)(lbn - seq),
This is a little C-program that can be used to print out the list of blocks used by a requested list of inodes. For example, to list the blocks referenced by your kernel: guest_12 % df / Filesystem 1K-blocks Used Avail Capacity Mounted on /dev/gpt/rootfs 20307196 10707336 7975288 57% / guest_12 % ls -i /boot/kernel/kernel 160603 /boot/kernel/kernel guest_12 % ./prtblknos /dev/gpt/rootfs 160603 160603: lbn 0-7 blkno 3217584-3217647 lbn 8-11 blkno 3217864-3217895 distance 216 First-level indirect, blkno 3217896-3217903 distance 0 lbn 12-19 blkno 3217904-3217967 distance 8 lbn 20-75 blkno 3251816-3252263 distance 33848 lbn 76-83 blkno 3252368-3252431 distance 104 lbn 84-91 blkno 3252464-3252527 distance 32 lbn 92-852 blkno 3252896-3258983 distance 368 Each contiguous range of blocks is printed on a line. The distance metric is the size of the gap from the end of the previous set of blocks to the beginning of the next set of blocks. Short distances are desirable.
2018-02-09 19:10:46 +00:00
firstblk == 0 ? "hole" :
firstblk == BLK_NOCOPY ? "nocopy" :
"snapblk");
else
Fix incorrect output for a file consisting of a single full-size block followed by a discontiguous fragment. Add checks for unallocated inodes and inodes with unknown mode types. Cleanup variable declarations by changing from type `int' to types like ufs_lbn_t, ufs2_daddr_t, etc. Reported by: bde
2018-04-19 22:43:55 +00:00
printf("\tlbn %jd-%jd %s\n",
(intmax_t)lbn - seq, (intmax_t)lbn - 1,
This is a little C-program that can be used to print out the list of blocks used by a requested list of inodes. For example, to list the blocks referenced by your kernel: guest_12 % df / Filesystem 1K-blocks Used Avail Capacity Mounted on /dev/gpt/rootfs 20307196 10707336 7975288 57% / guest_12 % ls -i /boot/kernel/kernel 160603 /boot/kernel/kernel guest_12 % ./prtblknos /dev/gpt/rootfs 160603 160603: lbn 0-7 blkno 3217584-3217647 lbn 8-11 blkno 3217864-3217895 distance 216 First-level indirect, blkno 3217896-3217903 distance 0 lbn 12-19 blkno 3217904-3217967 distance 8 lbn 20-75 blkno 3251816-3252263 distance 33848 lbn 76-83 blkno 3252368-3252431 distance 104 lbn 84-91 blkno 3252464-3252527 distance 32 lbn 92-852 blkno 3252896-3258983 distance 368 Each contiguous range of blocks is printed on a line. The distance metric is the size of the gap from the end of the previous set of blocks to the beginning of the next set of blocks. Short distances are desirable.
2018-02-09 19:10:46 +00:00
firstblk == 0 ? "hole" :
firstblk == BLK_NOCOPY ? "nocopy" :
"snapblk");
} else if (seq == 1) {
Fix incorrect output for a file consisting of a single full-size block followed by a discontiguous fragment. Add checks for unallocated inodes and inodes with unknown mode types. Cleanup variable declarations by changing from type `int' to types like ufs_lbn_t, ufs2_daddr_t, etc. Reported by: bde
2018-04-19 22:43:55 +00:00
if (totfrags == 1)
printf("\tlbn %jd blkno %jd%s\n", (intmax_t)(lbn - seq),
Split tools/diag/prtblknos into two parts: main.c - opens disk and processes the argument list of inodes to be printed prtblknos.c - prints out the list of blocks used by an inode This change allows the fsdb program to import prtblknos() to use when printing out the set of blocks used by an inode. This program was switched to using the libufs library to ease its integration with fsdb and any other filesystem utility that might want to use it in the future.
2018-04-08 06:52:58 +00:00
(intmax_t)firstblk, distance(fs, lastblk, firstblk));
This is a little C-program that can be used to print out the list of blocks used by a requested list of inodes. For example, to list the blocks referenced by your kernel: guest_12 % df / Filesystem 1K-blocks Used Avail Capacity Mounted on /dev/gpt/rootfs 20307196 10707336 7975288 57% / guest_12 % ls -i /boot/kernel/kernel 160603 /boot/kernel/kernel guest_12 % ./prtblknos /dev/gpt/rootfs 160603 160603: lbn 0-7 blkno 3217584-3217647 lbn 8-11 blkno 3217864-3217895 distance 216 First-level indirect, blkno 3217896-3217903 distance 0 lbn 12-19 blkno 3217904-3217967 distance 8 lbn 20-75 blkno 3251816-3252263 distance 33848 lbn 76-83 blkno 3252368-3252431 distance 104 lbn 84-91 blkno 3252464-3252527 distance 32 lbn 92-852 blkno 3252896-3258983 distance 368 Each contiguous range of blocks is printed on a line. The distance metric is the size of the gap from the end of the previous set of blocks to the beginning of the next set of blocks. Short distances are desirable.
2018-02-09 19:10:46 +00:00
else
Fix incorrect output for a file consisting of a single full-size block followed by a discontiguous fragment. Add checks for unallocated inodes and inodes with unknown mode types. Cleanup variable declarations by changing from type `int' to types like ufs_lbn_t, ufs2_daddr_t, etc. Reported by: bde
2018-04-19 22:43:55 +00:00
printf("\tlbn %jd blkno %jd-%jd%s\n",
(intmax_t)(lbn - seq), (intmax_t)firstblk,
(intmax_t)(firstblk + totfrags - 1),
Split tools/diag/prtblknos into two parts: main.c - opens disk and processes the argument list of inodes to be printed prtblknos.c - prints out the list of blocks used by an inode This change allows the fsdb program to import prtblknos() to use when printing out the set of blocks used by an inode. This program was switched to using the libufs library to ease its integration with fsdb and any other filesystem utility that might want to use it in the future.
2018-04-08 06:52:58 +00:00
distance(fs, lastblk, firstblk));
Fix incorrect output for a file consisting of a single full-size block followed by a discontiguous fragment. Add checks for unallocated inodes and inodes with unknown mode types. Cleanup variable declarations by changing from type `int' to types like ufs_lbn_t, ufs2_daddr_t, etc. Reported by: bde
2018-04-19 22:43:55 +00:00
lastblk = firstblk + totfrags - 1;
This is a little C-program that can be used to print out the list of blocks used by a requested list of inodes. For example, to list the blocks referenced by your kernel: guest_12 % df / Filesystem 1K-blocks Used Avail Capacity Mounted on /dev/gpt/rootfs 20307196 10707336 7975288 57% / guest_12 % ls -i /boot/kernel/kernel 160603 /boot/kernel/kernel guest_12 % ./prtblknos /dev/gpt/rootfs 160603 160603: lbn 0-7 blkno 3217584-3217647 lbn 8-11 blkno 3217864-3217895 distance 216 First-level indirect, blkno 3217896-3217903 distance 0 lbn 12-19 blkno 3217904-3217967 distance 8 lbn 20-75 blkno 3251816-3252263 distance 33848 lbn 76-83 blkno 3252368-3252431 distance 104 lbn 84-91 blkno 3252464-3252527 distance 32 lbn 92-852 blkno 3252896-3258983 distance 368 Each contiguous range of blocks is printed on a line. The distance metric is the size of the gap from the end of the previous set of blocks to the beginning of the next set of blocks. Short distances are desirable.
2018-02-09 19:10:46 +00:00
} else {
Fix incorrect output for a file consisting of a single full-size block followed by a discontiguous fragment. Add checks for unallocated inodes and inodes with unknown mode types. Cleanup variable declarations by changing from type `int' to types like ufs_lbn_t, ufs2_daddr_t, etc. Reported by: bde
2018-04-19 22:43:55 +00:00
printf("\tlbn %jd-%jd blkno %jd-%jd%s\n", (intmax_t)(lbn - seq),
(intmax_t)(lbn - 1), (intmax_t)firstblk,
(intmax_t)(firstblk + totfrags - 1),
Split tools/diag/prtblknos into two parts: main.c - opens disk and processes the argument list of inodes to be printed prtblknos.c - prints out the list of blocks used by an inode This change allows the fsdb program to import prtblknos() to use when printing out the set of blocks used by an inode. This program was switched to using the libufs library to ease its integration with fsdb and any other filesystem utility that might want to use it in the future.
2018-04-08 06:52:58 +00:00
distance(fs, lastblk, firstblk));
Fix incorrect output for a file consisting of a single full-size block followed by a discontiguous fragment. Add checks for unallocated inodes and inodes with unknown mode types. Cleanup variable declarations by changing from type `int' to types like ufs_lbn_t, ufs2_daddr_t, etc. Reported by: bde
2018-04-19 22:43:55 +00:00
lastblk = firstblk + totfrags - 1;
This is a little C-program that can be used to print out the list of blocks used by a requested list of inodes. For example, to list the blocks referenced by your kernel: guest_12 % df / Filesystem 1K-blocks Used Avail Capacity Mounted on /dev/gpt/rootfs 20307196 10707336 7975288 57% / guest_12 % ls -i /boot/kernel/kernel 160603 /boot/kernel/kernel guest_12 % ./prtblknos /dev/gpt/rootfs 160603 160603: lbn 0-7 blkno 3217584-3217647 lbn 8-11 blkno 3217864-3217895 distance 216 First-level indirect, blkno 3217896-3217903 distance 0 lbn 12-19 blkno 3217904-3217967 distance 8 lbn 20-75 blkno 3251816-3252263 distance 33848 lbn 76-83 blkno 3252368-3252431 distance 104 lbn 84-91 blkno 3252464-3252527 distance 32 lbn 92-852 blkno 3252896-3258983 distance 368 Each contiguous range of blocks is printed on a line. The distance metric is the size of the gap from the end of the previous set of blocks to the beginning of the next set of blocks. Short distances are desirable.
2018-02-09 19:10:46 +00:00
}
if (lastlbn > 0 || blkno == 0) {
seq = 1;
Fix incorrect output for a file consisting of a single full-size block followed by a discontiguous fragment. Add checks for unallocated inodes and inodes with unknown mode types. Cleanup variable declarations by changing from type `int' to types like ufs_lbn_t, ufs2_daddr_t, etc. Reported by: bde
2018-04-19 22:43:55 +00:00
totfrags = numfrags;
This is a little C-program that can be used to print out the list of blocks used by a requested list of inodes. For example, to list the blocks referenced by your kernel: guest_12 % df / Filesystem 1K-blocks Used Avail Capacity Mounted on /dev/gpt/rootfs 20307196 10707336 7975288 57% / guest_12 % ls -i /boot/kernel/kernel 160603 /boot/kernel/kernel guest_12 % ./prtblknos /dev/gpt/rootfs 160603 160603: lbn 0-7 blkno 3217584-3217647 lbn 8-11 blkno 3217864-3217895 distance 216 First-level indirect, blkno 3217896-3217903 distance 0 lbn 12-19 blkno 3217904-3217967 distance 8 lbn 20-75 blkno 3251816-3252263 distance 33848 lbn 76-83 blkno 3252368-3252431 distance 104 lbn 84-91 blkno 3252464-3252527 distance 32 lbn 92-852 blkno 3252896-3258983 distance 368 Each contiguous range of blocks is printed on a line. The distance metric is the size of the gap from the end of the previous set of blocks to the beginning of the next set of blocks. Short distances are desirable.
2018-02-09 19:10:46 +00:00
firstblk = blkno;
return;
}
prtindir:
Split tools/diag/prtblknos into two parts: main.c - opens disk and processes the argument list of inodes to be printed prtblknos.c - prints out the list of blocks used by an inode This change allows the fsdb program to import prtblknos() to use when printing out the set of blocks used by an inode. This program was switched to using the libufs library to ease its integration with fsdb and any other filesystem utility that might want to use it in the future.
2018-04-08 06:52:58 +00:00
if (seq != 0 && (fs->fs_metaspace == 0 || lastindirblk == 0))
This is a little C-program that can be used to print out the list of blocks used by a requested list of inodes. For example, to list the blocks referenced by your kernel: guest_12 % df / Filesystem 1K-blocks Used Avail Capacity Mounted on /dev/gpt/rootfs 20307196 10707336 7975288 57% / guest_12 % ls -i /boot/kernel/kernel 160603 /boot/kernel/kernel guest_12 % ./prtblknos /dev/gpt/rootfs 160603 160603: lbn 0-7 blkno 3217584-3217647 lbn 8-11 blkno 3217864-3217895 distance 216 First-level indirect, blkno 3217896-3217903 distance 0 lbn 12-19 blkno 3217904-3217967 distance 8 lbn 20-75 blkno 3251816-3252263 distance 33848 lbn 76-83 blkno 3252368-3252431 distance 104 lbn 84-91 blkno 3252464-3252527 distance 32 lbn 92-852 blkno 3252896-3258983 distance 368 Each contiguous range of blocks is printed on a line. The distance metric is the size of the gap from the end of the previous set of blocks to the beginning of the next set of blocks. Short distances are desirable.
2018-02-09 19:10:46 +00:00
lastindirblk = lastblk;
printf("%s-level indirect, blkno %jd-%jd%s\n", indirname[-lastlbn],
Fix incorrect output for a file consisting of a single full-size block followed by a discontiguous fragment. Add checks for unallocated inodes and inodes with unknown mode types. Cleanup variable declarations by changing from type `int' to types like ufs_lbn_t, ufs2_daddr_t, etc. Reported by: bde
2018-04-19 22:43:55 +00:00
(intmax_t)blkno, (intmax_t)(blkno + numfrags - 1),
Split tools/diag/prtblknos into two parts: main.c - opens disk and processes the argument list of inodes to be printed prtblknos.c - prints out the list of blocks used by an inode This change allows the fsdb program to import prtblknos() to use when printing out the set of blocks used by an inode. This program was switched to using the libufs library to ease its integration with fsdb and any other filesystem utility that might want to use it in the future.
2018-04-08 06:52:58 +00:00
distance(fs, lastindirblk, blkno));
Fix incorrect output for a file consisting of a single full-size block followed by a discontiguous fragment. Add checks for unallocated inodes and inodes with unknown mode types. Cleanup variable declarations by changing from type `int' to types like ufs_lbn_t, ufs2_daddr_t, etc. Reported by: bde
2018-04-19 22:43:55 +00:00
lastindirblk = blkno + numfrags - 1;
Split tools/diag/prtblknos into two parts: main.c - opens disk and processes the argument list of inodes to be printed prtblknos.c - prints out the list of blocks used by an inode This change allows the fsdb program to import prtblknos() to use when printing out the set of blocks used by an inode. This program was switched to using the libufs library to ease its integration with fsdb and any other filesystem utility that might want to use it in the future.
2018-04-08 06:52:58 +00:00
if (fs->fs_metaspace == 0)
This is a little C-program that can be used to print out the list of blocks used by a requested list of inodes. For example, to list the blocks referenced by your kernel: guest_12 % df / Filesystem 1K-blocks Used Avail Capacity Mounted on /dev/gpt/rootfs 20307196 10707336 7975288 57% / guest_12 % ls -i /boot/kernel/kernel 160603 /boot/kernel/kernel guest_12 % ./prtblknos /dev/gpt/rootfs 160603 160603: lbn 0-7 blkno 3217584-3217647 lbn 8-11 blkno 3217864-3217895 distance 216 First-level indirect, blkno 3217896-3217903 distance 0 lbn 12-19 blkno 3217904-3217967 distance 8 lbn 20-75 blkno 3251816-3252263 distance 33848 lbn 76-83 blkno 3252368-3252431 distance 104 lbn 84-91 blkno 3252464-3252527 distance 32 lbn 92-852 blkno 3252896-3258983 distance 368 Each contiguous range of blocks is printed on a line. The distance metric is the size of the gap from the end of the previous set of blocks to the beginning of the next set of blocks. Short distances are desirable.
2018-02-09 19:10:46 +00:00
lastblk = lastindirblk;
seq = 0;
}
Reference in New Issue Copy Permalink