From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 8672747668A for ; Wed, 29 Jul 2026 11:36:50 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=198.137.202.133 ARC-Seal:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1785325016; cv=none; b=GExxLBAqXdAE0YBc0yi+Nsp72ZWmQsQR3oMIqfsPvVCf6jOWquOhbXYSMs4bthIQXD1WamPVNqEuOS6MZu2prOOso5bG4vOMNYGQZJ62OSRbHPXbzMeHO/15kQc/2uhjnTGtJyPr4whQ+zwrPpMLkydT7aUpxf3SV/5nR33+rzc= ARC-Message-Signature:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1785325016; c=relaxed/simple; bh=zXRJ12fBfoAOavEa2RpynAIeP8mAnL6i+nViIetwEqo=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=hvsRR20kp8N8A3OdekAtyjIvgyRsDaTvMXJnGE05gqWU3z4e6CxI/RDqarnSfDe71NeVLQksdxIISScrAYvB/4xDlbwojJ2pTBuDzR568+mrmxiVcw/XY8h8Fl7G3FpBFVcV2Y01ua8QMl2cRpHVvxvLpOepnPRLicyLlS1f0zI= ARC-Authentication-Results:i=1; smtp.subspace.kernel.org; dmarc=fail (p=none dis=none) header.from=lst.de; spf=none smtp.mailfrom=bombadil.srs.infradead.org; dkim=pass (2048-bit key) header.d=infradead.org header.i=@infradead.org header.b=clULEm2K; arc=none smtp.client-ip=198.137.202.133 Authentication-Results: smtp.subspace.kernel.org; dmarc=fail (p=none dis=none) header.from=lst.de Authentication-Results: smtp.subspace.kernel.org; spf=none smtp.mailfrom=bombadil.srs.infradead.org Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=infradead.org header.i=@infradead.org header.b="clULEm2K" DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=infradead.org; s=bombadil.20210309; h=Content-Transfer-Encoding: MIME-Version:References:In-Reply-To:Message-ID:Date:Subject:Cc:To:From:Sender :Reply-To:Content-Type:Content-ID:Content-Description; bh=V6u9Md+mAxcx5fy18sdPMbRpYxTUD9KOeuBSvn4/vdc=; b=clULEm2KpCvTcgH5sjwMf0bqFR 55zAZ3mP6vgq22s3qwswYl6nAPSOJNKaHO8+i0C++/TDBKlOPLeOS72z6xpF3JG9eRuZ6DqpXo5yg QVMapDBTEo49Af/C2uX5qVkM66ZhbyyOWV6AJAQHjrgRw/XT6Ys6Ccn+l3LBiUBHLDwQZwqqyUbUb oPT4cct1CTdi9rP1Pag9R80WTuhN7ATW3CfNuFh5S4zyQHwaJk994rBiGMaVsOK63Jj0n/EYXrQWv Oc8WNo7TLvUDRltEJwFx8i9uzmR35lrfLo6YYXRlkj83TOBvEXuoU73GdHzqOgEGjQJHer6psTn8y KlXkctJA==; Received: from 85-127-110-197.dsl.dynamic.surfer.at ([85.127.110.197] helo=localhost) by bombadil.infradead.org with esmtpsa (Exim 4.99.1 #2 (Red Hat Linux)) id 1wp2af-00000007kU1-3uxJ; Wed, 29 Jul 2026 11:36:50 +0000 From: Christoph Hellwig To: Christian Brauner Cc: =?UTF-8?q?Krzysztof=20B=C5=82aszkowski?= , linux-fsdevel@vger.kernel.org Subject: [PATCH] freevxfs: remove the driver Date: Wed, 29 Jul 2026 13:36:40 +0200 Message-ID: <20260729113643.2255419-2-hch@lst.de> X-Mailer: git-send-email 2.53.0 In-Reply-To: <20260729113643.2255419-1-hch@lst.de> References: <20260729113643.2255419-1-hch@lst.de> Precedence: bulk X-Mailing-List: linux-fsdevel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-SRS-Rewrite: SMTP reverse-path rewritten from by bombadil.infradead.org. See http://www.infradead.org/rpr.html Providing compatibility to various old-school Unix systems from the 1990s was fun 25 years ago, but today it just attracts automated bug checkers that have no point in something like this used for retro-computing. As there as only one known users (and contributor) in the last 15 years, drop it. Anyone who needs to access such a file system can stay on an older kernel, or maintain the code out of tree as it doesn't require anything fancy. Signed-off-by: Christoph Hellwig --- MAINTAINERS | 6 - fs/Kconfig | 1 - fs/Makefile | 1 - fs/freevxfs/Kconfig | 27 --- fs/freevxfs/Makefile | 9 - fs/freevxfs/vxfs.h | 257 ---------------------------- fs/freevxfs/vxfs_bmap.c | 272 ------------------------------ fs/freevxfs/vxfs_dir.h | 68 -------- fs/freevxfs/vxfs_extern.h | 49 ------ fs/freevxfs/vxfs_fshead.c | 166 ------------------ fs/freevxfs/vxfs_fshead.h | 43 ----- fs/freevxfs/vxfs_immed.c | 53 ------ fs/freevxfs/vxfs_inode.c | 314 ---------------------------------- fs/freevxfs/vxfs_inode.h | 169 ------------------- fs/freevxfs/vxfs_lookup.c | 273 ------------------------------ fs/freevxfs/vxfs_olt.c | 105 ------------ fs/freevxfs/vxfs_olt.h | 120 ------------- fs/freevxfs/vxfs_subr.c | 152 ----------------- fs/freevxfs/vxfs_super.c | 347 -------------------------------------- 19 files changed, 2432 deletions(-) delete mode 100644 fs/freevxfs/Kconfig delete mode 100644 fs/freevxfs/Makefile delete mode 100644 fs/freevxfs/vxfs.h delete mode 100644 fs/freevxfs/vxfs_bmap.c delete mode 100644 fs/freevxfs/vxfs_dir.h delete mode 100644 fs/freevxfs/vxfs_extern.h delete mode 100644 fs/freevxfs/vxfs_fshead.c delete mode 100644 fs/freevxfs/vxfs_fshead.h delete mode 100644 fs/freevxfs/vxfs_immed.c delete mode 100644 fs/freevxfs/vxfs_inode.c delete mode 100644 fs/freevxfs/vxfs_inode.h delete mode 100644 fs/freevxfs/vxfs_lookup.c delete mode 100644 fs/freevxfs/vxfs_olt.c delete mode 100644 fs/freevxfs/vxfs_olt.h delete mode 100644 fs/freevxfs/vxfs_subr.c delete mode 100644 fs/freevxfs/vxfs_super.c diff --git a/MAINTAINERS b/MAINTAINERS index 2f9472c1a090..5518b5bc3efa 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -10565,12 +10565,6 @@ L: linuxppc-dev@lists.ozlabs.org S: Orphan F: drivers/usb/phy/phy-fsl-usb* -FREEVXFS FILESYSTEM -M: Christoph Hellwig -S: Maintained -W: ftp://ftp.openlinux.org/pub/people/hch/vxfs -F: fs/freevxfs/ - FREEZER M: "Rafael J. Wysocki" R: Pavel Machek diff --git a/fs/Kconfig b/fs/Kconfig index cf6ae64776e6..6e7e63afae2b 100644 --- a/fs/Kconfig +++ b/fs/Kconfig @@ -321,7 +321,6 @@ source "fs/jffs2/Kconfig" source "fs/ubifs/Kconfig" source "fs/cramfs/Kconfig" source "fs/squashfs/Kconfig" -source "fs/freevxfs/Kconfig" source "fs/minix/Kconfig" source "fs/omfs/Kconfig" source "fs/hpfs/Kconfig" diff --git a/fs/Makefile b/fs/Makefile index 89a8a9d207d1..ac0d1c00523f 100644 --- a/fs/Makefile +++ b/fs/Makefile @@ -80,7 +80,6 @@ obj-$(CONFIG_ISO9660_FS) += isofs/ obj-$(CONFIG_HFSPLUS_FS) += hfsplus/ # Before hfs to find wrapped HFS+ obj-$(CONFIG_HFS_FS) += hfs/ obj-$(CONFIG_ECRYPT_FS) += ecryptfs/ -obj-$(CONFIG_VXFS_FS) += freevxfs/ obj-$(CONFIG_NFS_FS) += nfs/ obj-$(CONFIG_EXPORTFS) += exportfs/ obj-$(CONFIG_NFSD) += nfsd/ diff --git a/fs/freevxfs/Kconfig b/fs/freevxfs/Kconfig deleted file mode 100644 index 912107ebea6f..000000000000 --- a/fs/freevxfs/Kconfig +++ /dev/null @@ -1,27 +0,0 @@ -# SPDX-License-Identifier: GPL-2.0-only -config VXFS_FS - tristate "FreeVxFS file system support (VERITAS VxFS(TM) compatible)" - depends on BLOCK - select BUFFER_HEAD - help - FreeVxFS is a file system driver that support the VERITAS VxFS(TM) - file system format. VERITAS VxFS(TM) is the standard file system - of SCO UnixWare (and possibly others) and optionally available - for Sunsoft Solaris, HP-UX and many other operating systems. However - these particular OS implementations of vxfs may differ in on-disk - data endianness and/or superblock offset. The vxfs module has been - tested with SCO UnixWare and HP-UX B.10.20 (pa-risc 1.1 arch.) - Currently only readonly access is supported and VxFX versions - 2, 3 and 4. Tests were performed with HP-UX VxFS version 3. - - NOTE: the file system type as used by mount(1), mount(2) and - fstab(5) is 'vxfs' as it describes the file system format, not - the actual driver. - - There is a userspace utility for HP-UX logical volumes which makes - creating HP-UX logical volumes easy from HP-UX disk block device file - or regular file with image of the disk. See: - https://sourceforge.net/projects/linux-vxfs/ - - To compile this as a module, choose M here: the module will be - called freevxfs. If unsure, say N. diff --git a/fs/freevxfs/Makefile b/fs/freevxfs/Makefile deleted file mode 100644 index e6ee59291521..000000000000 --- a/fs/freevxfs/Makefile +++ /dev/null @@ -1,9 +0,0 @@ -# SPDX-License-Identifier: GPL-2.0-only -# -# VxFS Makefile -# - -obj-$(CONFIG_VXFS_FS) += freevxfs.o - -freevxfs-objs := vxfs_bmap.o vxfs_fshead.o vxfs_immed.o vxfs_inode.o \ - vxfs_lookup.o vxfs_olt.o vxfs_subr.o vxfs_super.o diff --git a/fs/freevxfs/vxfs.h b/fs/freevxfs/vxfs.h deleted file mode 100644 index bffd156d6434..000000000000 --- a/fs/freevxfs/vxfs.h +++ /dev/null @@ -1,257 +0,0 @@ -/* SPDX-License-Identifier: GPL-2.0-only */ -/* - * Copyright (c) 2000-2001 Christoph Hellwig. - * Copyright (c) 2016 Krzysztof Blaszkowski - */ -#ifndef _VXFS_SUPER_H_ -#define _VXFS_SUPER_H_ - -/* - * Veritas filesystem driver - superblock structure. - * - * This file contains the definition of the disk and core - * superblocks of the Veritas Filesystem. - */ -#include - -/* - * Superblock magic number (vxfs_super->vs_magic). - */ -#define VXFS_SUPER_MAGIC 0xa501FCF5 - -/* - * The root inode. - */ -#define VXFS_ROOT_INO 2 - -/* - * Num of entries in free extent array - */ -#define VXFS_NEFREE 32 - -enum vxfs_byte_order { - VXFS_BO_LE, - VXFS_BO_BE, -}; - -typedef __u16 __bitwise __fs16; -typedef __u32 __bitwise __fs32; -typedef __u64 __bitwise __fs64; - -/* - * VxFS superblock (disk). - */ -struct vxfs_sb { - /* - * Readonly fields for the version 1 superblock. - * - * Lots of this fields are no more used by version 2 - * and never filesystems. - */ - __fs32 vs_magic; /* Magic number */ - __fs32 vs_version; /* VxFS version */ - __fs32 vs_ctime; /* create time - secs */ - __fs32 vs_cutime; /* create time - usecs */ - __fs32 __unused1; /* unused */ - __fs32 __unused2; /* unused */ - __fs32 vs_old_logstart; /* obsolete */ - __fs32 vs_old_logend; /* obsolete */ - __fs32 vs_bsize; /* block size */ - __fs32 vs_size; /* number of blocks */ - __fs32 vs_dsize; /* number of data blocks */ - __fs32 vs_old_ninode; /* obsolete */ - __fs32 vs_old_nau; /* obsolete */ - __fs32 __unused3; /* unused */ - __fs32 vs_old_defiextsize; /* obsolete */ - __fs32 vs_old_ilbsize; /* obsolete */ - __fs32 vs_immedlen; /* size of immediate data area */ - __fs32 vs_ndaddr; /* number of direct extentes */ - __fs32 vs_firstau; /* address of first AU */ - __fs32 vs_emap; /* offset of extent map in AU */ - __fs32 vs_imap; /* offset of inode map in AU */ - __fs32 vs_iextop; /* offset of ExtOp. map in AU */ - __fs32 vs_istart; /* offset of inode list in AU */ - __fs32 vs_bstart; /* offset of fdblock in AU */ - __fs32 vs_femap; /* aufirst + emap */ - __fs32 vs_fimap; /* aufirst + imap */ - __fs32 vs_fiextop; /* aufirst + iextop */ - __fs32 vs_fistart; /* aufirst + istart */ - __fs32 vs_fbstart; /* aufirst + bstart */ - __fs32 vs_nindir; /* number of entries in indir */ - __fs32 vs_aulen; /* length of AU in blocks */ - __fs32 vs_auimlen; /* length of imap in blocks */ - __fs32 vs_auemlen; /* length of emap in blocks */ - __fs32 vs_auilen; /* length of ilist in blocks */ - __fs32 vs_aupad; /* length of pad in blocks */ - __fs32 vs_aublocks; /* data blocks in AU */ - __fs32 vs_maxtier; /* log base 2 of aublocks */ - __fs32 vs_inopb; /* number of inodes per blk */ - __fs32 vs_old_inopau; /* obsolete */ - __fs32 vs_old_inopilb; /* obsolete */ - __fs32 vs_old_ndiripau; /* obsolete */ - __fs32 vs_iaddrlen; /* size of indirect addr ext. */ - __fs32 vs_bshift; /* log base 2 of bsize */ - __fs32 vs_inoshift; /* log base 2 of inobp */ - __fs32 vs_bmask; /* ~( bsize - 1 ) */ - __fs32 vs_boffmask; /* bsize - 1 */ - __fs32 vs_old_inomask; /* old_inopilb - 1 */ - __fs32 vs_checksum; /* checksum of V1 data */ - - /* - * Version 1, writable - */ - __fs32 vs_free; /* number of free blocks */ - __fs32 vs_ifree; /* number of free inodes */ - __fs32 vs_efree[VXFS_NEFREE]; /* number of free extents by size */ - __fs32 vs_flags; /* flags ?!? */ - __u8 vs_mod; /* filesystem has been changed */ - __u8 vs_clean; /* clean FS */ - __fs16 __unused4; /* unused */ - __fs32 vs_firstlogid; /* mount time log ID */ - __fs32 vs_wtime; /* last time written - sec */ - __fs32 vs_wutime; /* last time written - usec */ - __u8 vs_fname[6]; /* FS name */ - __u8 vs_fpack[6]; /* FS pack name */ - __fs32 vs_logversion; /* log format version */ - __u32 __unused5; /* unused */ - - /* - * Version 2, Read-only - */ - __fs32 vs_oltext[2]; /* OLT extent and replica */ - __fs32 vs_oltsize; /* OLT extent size */ - __fs32 vs_iauimlen; /* size of inode map */ - __fs32 vs_iausize; /* size of IAU in blocks */ - __fs32 vs_dinosize; /* size of inode in bytes */ - __fs32 vs_old_dniaddr; /* indir levels per inode */ - __fs32 vs_checksum2; /* checksum of V2 RO */ - - /* - * Actually much more... - */ -}; - - -/* - * In core superblock filesystem private data for VxFS. - */ -struct vxfs_sb_info { - struct vxfs_sb *vsi_raw; /* raw (on disk) superblock */ - struct buffer_head *vsi_bp; /* buffer for raw superblock*/ - struct inode *vsi_fship; /* fileset header inode */ - struct inode *vsi_ilist; /* inode list inode */ - struct inode *vsi_stilist; /* structural inode list inode */ - u_long vsi_iext; /* initial inode list */ - ino_t vsi_fshino; /* fileset header inode */ - daddr_t vsi_oltext; /* OLT extent */ - daddr_t vsi_oltsize; /* OLT size */ - enum vxfs_byte_order byte_order; -}; - -static inline u16 fs16_to_cpu(struct vxfs_sb_info *sbi, __fs16 a) -{ - if (sbi->byte_order == VXFS_BO_BE) - return be16_to_cpu((__force __be16)a); - else - return le16_to_cpu((__force __le16)a); -} - -static inline u32 fs32_to_cpu(struct vxfs_sb_info *sbi, __fs32 a) -{ - if (sbi->byte_order == VXFS_BO_BE) - return be32_to_cpu((__force __be32)a); - else - return le32_to_cpu((__force __le32)a); -} - -static inline u64 fs64_to_cpu(struct vxfs_sb_info *sbi, __fs64 a) -{ - if (sbi->byte_order == VXFS_BO_BE) - return be64_to_cpu((__force __be64)a); - else - return le64_to_cpu((__force __le64)a); -} - -/* - * File modes. File types above 0xf000 are vxfs internal only, they should - * not be passed back to higher levels of the system. vxfs file types must - * never have one of the regular file type bits set. - */ -enum vxfs_mode { - VXFS_ISUID = 0x00000800, /* setuid */ - VXFS_ISGID = 0x00000400, /* setgid */ - VXFS_ISVTX = 0x00000200, /* sticky bit */ - VXFS_IREAD = 0x00000100, /* read */ - VXFS_IWRITE = 0x00000080, /* write */ - VXFS_IEXEC = 0x00000040, /* exec */ - - VXFS_IFIFO = 0x00001000, /* Named pipe */ - VXFS_IFCHR = 0x00002000, /* Character device */ - VXFS_IFDIR = 0x00004000, /* Directory */ - VXFS_IFNAM = 0x00005000, /* Xenix device ?? */ - VXFS_IFBLK = 0x00006000, /* Block device */ - VXFS_IFREG = 0x00008000, /* Regular file */ - VXFS_IFCMP = 0x00009000, /* Compressed file ?!? */ - VXFS_IFLNK = 0x0000a000, /* Symlink */ - VXFS_IFSOC = 0x0000c000, /* Socket */ - - /* VxFS internal */ - VXFS_IFFSH = 0x10000000, /* Fileset header */ - VXFS_IFILT = 0x20000000, /* Inode list */ - VXFS_IFIAU = 0x30000000, /* Inode allocation unit */ - VXFS_IFCUT = 0x40000000, /* Current usage table */ - VXFS_IFATT = 0x50000000, /* Attr. inode */ - VXFS_IFLCT = 0x60000000, /* Link count table */ - VXFS_IFIAT = 0x70000000, /* Indirect attribute file */ - VXFS_IFEMR = 0x80000000, /* Extent map reorg file */ - VXFS_IFQUO = 0x90000000, /* BSD quota file */ - VXFS_IFPTI = 0xa0000000, /* "Pass through" inode */ - VXFS_IFLAB = 0x11000000, /* Device label file */ - VXFS_IFOLT = 0x12000000, /* OLT file */ - VXFS_IFLOG = 0x13000000, /* Log file */ - VXFS_IFEMP = 0x14000000, /* Extent map file */ - VXFS_IFEAU = 0x15000000, /* Extent AU file */ - VXFS_IFAUS = 0x16000000, /* Extent AU summary file */ - VXFS_IFDEV = 0x17000000, /* Device config file */ - -}; - -#define VXFS_TYPE_MASK 0xfffff000 - -#define VXFS_IS_TYPE(ip,type) (((ip)->vii_mode & VXFS_TYPE_MASK) == (type)) -#define VXFS_ISFIFO(x) VXFS_IS_TYPE((x),VXFS_IFIFO) -#define VXFS_ISCHR(x) VXFS_IS_TYPE((x),VXFS_IFCHR) -#define VXFS_ISDIR(x) VXFS_IS_TYPE((x),VXFS_IFDIR) -#define VXFS_ISNAM(x) VXFS_IS_TYPE((x),VXFS_IFNAM) -#define VXFS_ISBLK(x) VXFS_IS_TYPE((x),VXFS_IFBLK) -#define VXFS_ISLNK(x) VXFS_IS_TYPE((x),VXFS_IFLNK) -#define VXFS_ISREG(x) VXFS_IS_TYPE((x),VXFS_IFREG) -#define VXFS_ISCMP(x) VXFS_IS_TYPE((x),VXFS_IFCMP) -#define VXFS_ISSOC(x) VXFS_IS_TYPE((x),VXFS_IFSOC) - -#define VXFS_ISFSH(x) VXFS_IS_TYPE((x),VXFS_IFFSH) -#define VXFS_ISILT(x) VXFS_IS_TYPE((x),VXFS_IFILT) - -/* - * Inmode organisation types. - */ -enum { - VXFS_ORG_NONE = 0, /* Inode has *no* format ?!? */ - VXFS_ORG_EXT4 = 1, /* Ext4 */ - VXFS_ORG_IMMED = 2, /* All data stored in inode */ - VXFS_ORG_TYPED = 3, /* Typed extents */ -}; - -#define VXFS_IS_ORG(ip,org) ((ip)->vii_orgtype == (org)) -#define VXFS_ISNONE(ip) VXFS_IS_ORG((ip), VXFS_ORG_NONE) -#define VXFS_ISEXT4(ip) VXFS_IS_ORG((ip), VXFS_ORG_EXT4) -#define VXFS_ISIMMED(ip) VXFS_IS_ORG((ip), VXFS_ORG_IMMED) -#define VXFS_ISTYPED(ip) VXFS_IS_ORG((ip), VXFS_ORG_TYPED) - -/* - * Get filesystem private data from VFS superblock. - */ -#define VXFS_SBI(sbp) \ - ((struct vxfs_sb_info *)(sbp)->s_fs_info) - -#endif /* _VXFS_SUPER_H_ */ diff --git a/fs/freevxfs/vxfs_bmap.c b/fs/freevxfs/vxfs_bmap.c deleted file mode 100644 index 1b8216eb1d90..000000000000 --- a/fs/freevxfs/vxfs_bmap.c +++ /dev/null @@ -1,272 +0,0 @@ -// SPDX-License-Identifier: GPL-2.0-only -/* - * Copyright (c) 2000-2001 Christoph Hellwig. - */ - -/* - * Veritas filesystem driver - filesystem to disk block mapping. - */ -#include -#include -#include - -#include "vxfs.h" -#include "vxfs_inode.h" -#include "vxfs_extern.h" - - -#ifdef DIAGNOSTIC -static void -vxfs_typdump(struct vxfs_typed *typ) -{ - printk(KERN_DEBUG "type=%Lu ", typ->vt_hdr >> VXFS_TYPED_TYPESHIFT); - printk("offset=%Lx ", typ->vt_hdr & VXFS_TYPED_OFFSETMASK); - printk("block=%x ", typ->vt_block); - printk("size=%x\n", typ->vt_size); -} -#endif - -/** - * vxfs_bmap_ext4 - do bmap for ext4 extents - * @ip: pointer to the inode we do bmap for - * @bn: logical block. - * - * Description: - * vxfs_bmap_ext4 performs the bmap operation for inodes with - * ext4-style extents (which are much like the traditional UNIX - * inode organisation). - * - * Returns: - * The physical block number on success, else Zero. - */ -static daddr_t -vxfs_bmap_ext4(struct inode *ip, long bn) -{ - struct super_block *sb = ip->i_sb; - struct vxfs_inode_info *vip = VXFS_INO(ip); - struct vxfs_sb_info *sbi = VXFS_SBI(sb); - unsigned long bsize = sb->s_blocksize; - u32 indsize = fs32_to_cpu(sbi, vip->vii_ext4.ve4_indsize); - int i; - - if (indsize > sb->s_blocksize) - goto fail_size; - - for (i = 0; i < VXFS_NDADDR; i++) { - struct direct *d = vip->vii_ext4.ve4_direct + i; - if (bn >= 0 && bn < fs32_to_cpu(sbi, d->size)) - return (bn + fs32_to_cpu(sbi, d->extent)); - bn -= fs32_to_cpu(sbi, d->size); - } - - if ((bn / (indsize * indsize * bsize / 4)) == 0) { - struct buffer_head *buf; - daddr_t bno; - __fs32 *indir; - - buf = sb_bread(sb, - fs32_to_cpu(sbi, vip->vii_ext4.ve4_indir[0])); - if (!buf || !buffer_mapped(buf)) - goto fail_buf; - - indir = (__fs32 *)buf->b_data; - bno = fs32_to_cpu(sbi, indir[(bn / indsize) % (indsize * bn)]) + - (bn % indsize); - - brelse(buf); - return bno; - } else - printk(KERN_WARNING "no matching indir?"); - - return 0; - -fail_size: - printk("vxfs: indirect extent too big!\n"); -fail_buf: - return 0; -} - -/** - * vxfs_bmap_indir - recursion for vxfs_bmap_typed - * @ip: pointer to the inode we do bmap for - * @indir: indirect block we start reading at - * @size: size of the typed area to search - * @block: partially result from further searches - * - * Description: - * vxfs_bmap_indir reads a &struct vxfs_typed at @indir - * and performs the type-defined action. - * - * Returns: - * The physical block number on success, else Zero. - * - * Note: - * Kernelstack is rare. Unrecurse? - */ -static daddr_t -vxfs_bmap_indir(struct inode *ip, long indir, int size, long block) -{ - struct vxfs_sb_info *sbi = VXFS_SBI(ip->i_sb); - struct buffer_head *bp = NULL; - daddr_t pblock = 0; - int i; - - for (i = 0; i < size * VXFS_TYPED_PER_BLOCK(ip->i_sb); i++) { - struct vxfs_typed *typ; - int64_t off; - - bp = sb_bread(ip->i_sb, - indir + (i / VXFS_TYPED_PER_BLOCK(ip->i_sb))); - if (!bp || !buffer_mapped(bp)) - return 0; - - typ = ((struct vxfs_typed *)bp->b_data) + - (i % VXFS_TYPED_PER_BLOCK(ip->i_sb)); - off = fs64_to_cpu(sbi, typ->vt_hdr) & VXFS_TYPED_OFFSETMASK; - - if (block < off) { - brelse(bp); - continue; - } - - switch ((u_int32_t)(fs64_to_cpu(sbi, typ->vt_hdr) >> - VXFS_TYPED_TYPESHIFT)) { - case VXFS_TYPED_INDIRECT: - pblock = vxfs_bmap_indir(ip, - fs32_to_cpu(sbi, typ->vt_block), - fs32_to_cpu(sbi, typ->vt_size), - block - off); - if (pblock == -2) - break; - goto out; - case VXFS_TYPED_DATA: - if ((block - off) >= fs32_to_cpu(sbi, typ->vt_size)) - break; - pblock = fs32_to_cpu(sbi, typ->vt_block) + block - off; - goto out; - case VXFS_TYPED_INDIRECT_DEV4: - case VXFS_TYPED_DATA_DEV4: { - struct vxfs_typed_dev4 *typ4 = - (struct vxfs_typed_dev4 *)typ; - - printk(KERN_INFO "\n\nTYPED_DEV4 detected!\n"); - printk(KERN_INFO "block: %llu\tsize: %lld\tdev: %d\n", - fs64_to_cpu(sbi, typ4->vd4_block), - fs64_to_cpu(sbi, typ4->vd4_size), - fs32_to_cpu(sbi, typ4->vd4_dev)); - goto fail; - } - default: - printk(KERN_ERR "%s:%d vt_hdr %llu\n", __func__, - __LINE__, fs64_to_cpu(sbi, typ->vt_hdr)); - BUG(); - } - brelse(bp); - } - -fail: - pblock = 0; -out: - brelse(bp); - return (pblock); -} - -/** - * vxfs_bmap_typed - bmap for typed extents - * @ip: pointer to the inode we do bmap for - * @iblock: logical block - * - * Description: - * Performs the bmap operation for typed extents. - * - * Returns: - * The physical block number on success, else Zero. - */ -static daddr_t -vxfs_bmap_typed(struct inode *ip, long iblock) -{ - struct vxfs_inode_info *vip = VXFS_INO(ip); - struct vxfs_sb_info *sbi = VXFS_SBI(ip->i_sb); - daddr_t pblock = 0; - int i; - - for (i = 0; i < VXFS_NTYPED; i++) { - struct vxfs_typed *typ = vip->vii_org.typed + i; - u64 hdr = fs64_to_cpu(sbi, typ->vt_hdr); - int64_t off = (hdr & VXFS_TYPED_OFFSETMASK); - -#ifdef DIAGNOSTIC - vxfs_typdump(typ); -#endif - if (iblock < off) - continue; - switch ((u32)(hdr >> VXFS_TYPED_TYPESHIFT)) { - case VXFS_TYPED_INDIRECT: - pblock = vxfs_bmap_indir(ip, - fs32_to_cpu(sbi, typ->vt_block), - fs32_to_cpu(sbi, typ->vt_size), - iblock - off); - if (pblock == -2) - break; - return (pblock); - case VXFS_TYPED_DATA: - if ((iblock - off) < fs32_to_cpu(sbi, typ->vt_size)) - return (fs32_to_cpu(sbi, typ->vt_block) + - iblock - off); - break; - case VXFS_TYPED_INDIRECT_DEV4: - case VXFS_TYPED_DATA_DEV4: { - struct vxfs_typed_dev4 *typ4 = - (struct vxfs_typed_dev4 *)typ; - - printk(KERN_INFO "\n\nTYPED_DEV4 detected!\n"); - printk(KERN_INFO "block: %llu\tsize: %lld\tdev: %d\n", - fs64_to_cpu(sbi, typ4->vd4_block), - fs64_to_cpu(sbi, typ4->vd4_size), - fs32_to_cpu(sbi, typ4->vd4_dev)); - return 0; - } - default: - WARN_ON_ONCE(1); - return 0; - } - } - - return 0; -} - -/** - * vxfs_bmap1 - vxfs-internal bmap operation - * @ip: pointer to the inode we do bmap for - * @iblock: logical block - * - * Description: - * vxfs_bmap1 perfoms a logical to physical block mapping - * for vxfs-internal purposes. - * - * Returns: - * The physical block number on success, else Zero. - */ -daddr_t -vxfs_bmap1(struct inode *ip, long iblock) -{ - struct vxfs_inode_info *vip = VXFS_INO(ip); - - if (VXFS_ISEXT4(vip)) - return vxfs_bmap_ext4(ip, iblock); - if (VXFS_ISTYPED(vip)) - return vxfs_bmap_typed(ip, iblock); - if (VXFS_ISNONE(vip)) - goto unsupp; - if (VXFS_ISIMMED(vip)) - goto unsupp; - - printk(KERN_WARNING "vxfs: inode %llu has no valid orgtype (%x)\n", - ip->i_ino, vip->vii_orgtype); - BUG(); - -unsupp: - printk(KERN_WARNING "vxfs: inode %llu has an unsupported orgtype (%x)\n", - ip->i_ino, vip->vii_orgtype); - return 0; -} diff --git a/fs/freevxfs/vxfs_dir.h b/fs/freevxfs/vxfs_dir.h deleted file mode 100644 index 8c67627f2a3d..000000000000 --- a/fs/freevxfs/vxfs_dir.h +++ /dev/null @@ -1,68 +0,0 @@ -/* SPDX-License-Identifier: GPL-2.0-only */ -/* - * Copyright (c) 2000-2001 Christoph Hellwig. - */ -#ifndef _VXFS_DIR_H_ -#define _VXFS_DIR_H_ - -/* - * Veritas filesystem driver - directory structure. - * - * This file contains the definition of the vxfs directory format. - */ - - -/* - * VxFS directory block header. - * - * This entry is the head of every filesystem block in a directory. - * It is used for free space management and additionally includes - * a hash for speeding up directory search (lookup). - * - * The hash may be empty and in fact we do not use it all in the - * Linux driver for now. - */ -struct vxfs_dirblk { - __fs16 d_free; /* free space in dirblock */ - __fs16 d_nhash; /* no of hash chains */ - __fs16 d_hash[]; /* hash chain */ -}; - -/* - * VXFS_NAMELEN is the maximum length of the d_name field - * of an VxFS directory entry. - */ -#define VXFS_NAMELEN 256 - -/* - * VxFS directory entry. - */ -struct vxfs_direct { - __fs32 d_ino; /* inode number */ - __fs16 d_reclen; /* record length */ - __fs16 d_namelen; /* d_name length */ - __fs16 d_hashnext; /* next hash entry */ - char d_name[VXFS_NAMELEN]; /* name */ -}; - -/* - * VXFS_DIRPAD defines the directory entry boundaries, is _must_ be - * a multiple of four. - * VXFS_NAMEMIN is the length of a directory entry with a NULL d_name. - * VXFS_DIRROUND is an internal macros that rounds a length to a value - * usable for directory sizes. - * VXFS_DIRLEN calculates the directory entry size for an entry with - * a d_name with size len. - */ -#define VXFS_DIRPAD 4 -#define VXFS_NAMEMIN offsetof(struct vxfs_direct, d_name) -#define VXFS_DIRROUND(len) ((VXFS_DIRPAD + (len) - 1) & ~(VXFS_DIRPAD -1)) -#define VXFS_DIRLEN(len) (VXFS_DIRROUND(VXFS_NAMEMIN + (len))) - -/* - * VXFS_DIRBLKOV is the overhead of a specific dirblock. - */ -#define VXFS_DIRBLKOV(sbi, dbp) \ - ((sizeof(short) * fs16_to_cpu(sbi, dbp->d_nhash)) + 4) - -#endif /* _VXFS_DIR_H_ */ diff --git a/fs/freevxfs/vxfs_extern.h b/fs/freevxfs/vxfs_extern.h deleted file mode 100644 index 3a2180c5e208..000000000000 --- a/fs/freevxfs/vxfs_extern.h +++ /dev/null @@ -1,49 +0,0 @@ -/* SPDX-License-Identifier: GPL-2.0-only */ -/* - * Copyright (c) 2000-2001 Christoph Hellwig. - */ -#ifndef _VXFS_EXTERN_H_ -#define _VXFS_EXTERN_H_ - -/* - * Veritas filesystem driver - external prototypes. - * - * This file contains prototypes for all vxfs functions used - * outside their respective source files. - */ - - -struct kmem_cache; -struct super_block; -struct vxfs_inode_info; -struct inode; - - -/* vxfs_bmap.c */ -extern daddr_t vxfs_bmap1(struct inode *, long); - -/* vxfs_fshead.c */ -extern int vxfs_read_fshead(struct super_block *); - -/* vxfs_inode.c */ -extern const struct address_space_operations vxfs_immed_aops; -extern void vxfs_dumpi(struct vxfs_inode_info *, ino_t); -extern struct inode *vxfs_blkiget(struct super_block *, u_long, ino_t); -extern struct inode *vxfs_stiget(struct super_block *, ino_t); -extern struct inode *vxfs_iget(struct super_block *, ino_t); -extern void vxfs_evict_inode(struct inode *); - -/* vxfs_lookup.c */ -extern const struct inode_operations vxfs_dir_inode_ops; -extern const struct file_operations vxfs_dir_operations; - -/* vxfs_olt.c */ -extern int vxfs_read_olt(struct super_block *, u_long); - -/* vxfs_subr.c */ -extern const struct address_space_operations vxfs_aops; -extern struct page * vxfs_get_page(struct address_space *, u_long); -extern void vxfs_put_page(struct page *); -extern struct buffer_head * vxfs_bread(struct inode *, int); - -#endif /* _VXFS_EXTERN_H_ */ diff --git a/fs/freevxfs/vxfs_fshead.c b/fs/freevxfs/vxfs_fshead.c deleted file mode 100644 index e6ab8bdf7a6c..000000000000 --- a/fs/freevxfs/vxfs_fshead.c +++ /dev/null @@ -1,166 +0,0 @@ -// SPDX-License-Identifier: GPL-2.0-only -/* - * Copyright (c) 2000-2001 Christoph Hellwig. - * Copyright (c) 2016 Krzysztof Blaszkowski - */ - -/* - * Veritas filesystem driver - fileset header routines. - */ -#include -#include -#include -#include -#include - -#include "vxfs.h" -#include "vxfs_inode.h" -#include "vxfs_extern.h" -#include "vxfs_fshead.h" - - -#ifdef DIAGNOSTIC -static void -vxfs_dumpfsh(struct vxfs_fsh *fhp) -{ - printk("\n\ndumping fileset header:\n"); - printk("----------------------------\n"); - printk("version: %u\n", fhp->fsh_version); - printk("fsindex: %u\n", fhp->fsh_fsindex); - printk("iauino: %u\tninodes:%u\n", - fhp->fsh_iauino, fhp->fsh_ninodes); - printk("maxinode: %u\tlctino: %u\n", - fhp->fsh_maxinode, fhp->fsh_lctino); - printk("nau: %u\n", fhp->fsh_nau); - printk("ilistino[0]: %u\tilistino[1]: %u\n", - fhp->fsh_ilistino[0], fhp->fsh_ilistino[1]); -} -#endif - -/** - * vxfs_getfsh - read fileset header into memory - * @ip: the (fake) fileset header inode - * @which: 0 for the structural, 1 for the primary fsh. - * - * Description: - * vxfs_getfsh reads either the structural or primary fileset header - * described by @ip into memory. - * - * Returns: - * The fileset header structure on success, else Zero. - */ -static struct vxfs_fsh * -vxfs_getfsh(struct inode *ip, int which) -{ - struct buffer_head *bp; - - bp = vxfs_bread(ip, which); - if (bp) { - struct vxfs_fsh *fhp; - - if (!(fhp = kmalloc_obj(*fhp))) - goto out; - memcpy(fhp, bp->b_data, sizeof(*fhp)); - - put_bh(bp); - return (fhp); - } -out: - brelse(bp); - return NULL; -} - -/** - * vxfs_read_fshead - read the fileset headers - * @sbp: superblock to which the fileset belongs - * - * Description: - * vxfs_read_fshead will fill the inode and structural inode list in @sb. - * - * Returns: - * Zero on success, else a negative error code (-EINVAL). - */ -int -vxfs_read_fshead(struct super_block *sbp) -{ - struct vxfs_sb_info *infp = VXFS_SBI(sbp); - struct vxfs_fsh *pfp, *sfp; - struct vxfs_inode_info *vip; - - infp->vsi_fship = vxfs_blkiget(sbp, infp->vsi_iext, infp->vsi_fshino); - if (!infp->vsi_fship) { - printk(KERN_ERR "vxfs: unable to read fsh inode\n"); - return -EINVAL; - } - - vip = VXFS_INO(infp->vsi_fship); - if (!VXFS_ISFSH(vip)) { - printk(KERN_ERR "vxfs: fsh list inode is of wrong type (%x)\n", - vip->vii_mode & VXFS_TYPE_MASK); - goto out_iput_fship; - } - -#ifdef DIAGNOSTIC - printk("vxfs: fsh inode dump:\n"); - vxfs_dumpi(vip, infp->vsi_fshino); -#endif - - sfp = vxfs_getfsh(infp->vsi_fship, 0); - if (!sfp) { - printk(KERN_ERR "vxfs: unable to get structural fsh\n"); - goto out_iput_fship; - } - -#ifdef DIAGNOSTIC - vxfs_dumpfsh(sfp); -#endif - - pfp = vxfs_getfsh(infp->vsi_fship, 1); - if (!pfp) { - printk(KERN_ERR "vxfs: unable to get primary fsh\n"); - goto out_free_sfp; - } - -#ifdef DIAGNOSTIC - vxfs_dumpfsh(pfp); -#endif - - infp->vsi_stilist = vxfs_blkiget(sbp, infp->vsi_iext, - fs32_to_cpu(infp, sfp->fsh_ilistino[0])); - if (!infp->vsi_stilist) { - printk(KERN_ERR "vxfs: unable to get structural list inode\n"); - goto out_free_pfp; - } - if (!VXFS_ISILT(VXFS_INO(infp->vsi_stilist))) { - printk(KERN_ERR "vxfs: structural list inode is of wrong type (%x)\n", - VXFS_INO(infp->vsi_stilist)->vii_mode & VXFS_TYPE_MASK); - goto out_iput_stilist; - } - - infp->vsi_ilist = vxfs_stiget(sbp, fs32_to_cpu(infp, pfp->fsh_ilistino[0])); - if (!infp->vsi_ilist) { - printk(KERN_ERR "vxfs: unable to get inode list inode\n"); - goto out_iput_stilist; - } - if (!VXFS_ISILT(VXFS_INO(infp->vsi_ilist))) { - printk(KERN_ERR "vxfs: inode list inode is of wrong type (%x)\n", - VXFS_INO(infp->vsi_ilist)->vii_mode & VXFS_TYPE_MASK); - goto out_iput_ilist; - } - - kfree(pfp); - kfree(sfp); - return 0; - - out_iput_ilist: - iput(infp->vsi_ilist); - out_iput_stilist: - iput(infp->vsi_stilist); - out_free_pfp: - kfree(pfp); - out_free_sfp: - kfree(sfp); - out_iput_fship: - iput(infp->vsi_fship); - return -EINVAL; -} diff --git a/fs/freevxfs/vxfs_fshead.h b/fs/freevxfs/vxfs_fshead.h deleted file mode 100644 index dfd2147599c4..000000000000 --- a/fs/freevxfs/vxfs_fshead.h +++ /dev/null @@ -1,43 +0,0 @@ -/* SPDX-License-Identifier: GPL-2.0-only */ -/* - * Copyright (c) 2000-2001 Christoph Hellwig. - * Copyright (c) 2016 Krzysztof Blaszkowski - */ -#ifndef _VXFS_FSHEAD_H_ -#define _VXFS_FSHEAD_H_ - -/* - * Veritas filesystem driver - fileset header structures. - * - * This file contains the physical structure of the VxFS - * fileset header. - */ - - -/* - * Fileset header - */ -struct vxfs_fsh { - __fs32 fsh_version; /* fileset header version */ - __fs32 fsh_fsindex; /* fileset index */ - __fs32 fsh_time; /* modification time - sec */ - __fs32 fsh_utime; /* modification time - usec */ - __fs32 fsh_extop; /* extop flags */ - __fs32 fsh_ninodes; /* allocated inodes */ - __fs32 fsh_nau; /* number of IAUs */ - __fs32 fsh_old_ilesize; /* old size of ilist */ - __fs32 fsh_dflags; /* flags */ - __fs32 fsh_quota; /* quota limit */ - __fs32 fsh_maxinode; /* maximum inode number */ - __fs32 fsh_iauino; /* IAU inode */ - __fs32 fsh_ilistino[2]; /* ilist inodes */ - __fs32 fsh_lctino; /* link count table inode */ - - /* - * Slightly more fields follow, but they - * a) are not of any interest for us, and - * b) differ a lot in different vxfs versions/ports - */ -}; - -#endif /* _VXFS_FSHEAD_H_ */ diff --git a/fs/freevxfs/vxfs_immed.c b/fs/freevxfs/vxfs_immed.c deleted file mode 100644 index ed51fcd34757..000000000000 --- a/fs/freevxfs/vxfs_immed.c +++ /dev/null @@ -1,53 +0,0 @@ -// SPDX-License-Identifier: GPL-2.0-only -/* - * Copyright (c) 2000-2001 Christoph Hellwig. - */ - -/* - * Veritas filesystem driver - support for 'immed' inodes. - */ -#include -#include - -#include "vxfs.h" -#include "vxfs_extern.h" -#include "vxfs_inode.h" - -/** - * vxfs_immed_read_folio - read part of an immed inode into pagecache - * @fp: file context (unused) - * @folio: folio to fill in. - * - * Description: - * vxfs_immed_read_folio reads a part of the immed area of the - * file that hosts @folio into the pagecache. - * - * Returns: - * Zero on success, else a negative error code. - * - * Locking status: - * @folio is locked and will be unlocked. - */ -static int vxfs_immed_read_folio(struct file *fp, struct folio *folio) -{ - struct vxfs_inode_info *vip = VXFS_INO(folio->mapping->host); - void *src = vip->vii_immed.vi_immed + folio_pos(folio); - unsigned long i; - - for (i = 0; i < folio_nr_pages(folio); i++) { - memcpy_to_page(folio_page(folio, i), 0, src, PAGE_SIZE); - src += PAGE_SIZE; - } - - folio_mark_uptodate(folio); - folio_unlock(folio); - - return 0; -} - -/* - * Address space operations for immed files and directories. - */ -const struct address_space_operations vxfs_immed_aops = { - .read_folio = vxfs_immed_read_folio, -}; diff --git a/fs/freevxfs/vxfs_inode.c b/fs/freevxfs/vxfs_inode.c deleted file mode 100644 index 21fc94b98209..000000000000 --- a/fs/freevxfs/vxfs_inode.c +++ /dev/null @@ -1,314 +0,0 @@ -// SPDX-License-Identifier: GPL-2.0-only -/* - * Copyright (c) 2000-2001 Christoph Hellwig. - * Copyright (c) 2016 Krzysztof Blaszkowski - */ - -/* - * Veritas filesystem driver - inode routines. - */ -#include -#include -#include -#include -#include -#include - -#include "vxfs.h" -#include "vxfs_inode.h" -#include "vxfs_extern.h" - - -#ifdef DIAGNOSTIC -/* - * Dump inode contents (partially). - */ -void -vxfs_dumpi(struct vxfs_inode_info *vip, ino_t ino) -{ - printk(KERN_DEBUG "\n\n"); - if (ino) - printk(KERN_DEBUG "dumping vxfs inode %ld\n", ino); - else - printk(KERN_DEBUG "dumping unknown vxfs inode\n"); - - printk(KERN_DEBUG "---------------------------\n"); - printk(KERN_DEBUG "mode is %x\n", vip->vii_mode); - printk(KERN_DEBUG "nlink:%u, uid:%u, gid:%u\n", - vip->vii_nlink, vip->vii_uid, vip->vii_gid); - printk(KERN_DEBUG "size:%Lx, blocks:%u\n", - vip->vii_size, vip->vii_blocks); - printk(KERN_DEBUG "orgtype:%u\n", vip->vii_orgtype); -} -#endif - -/** - * vxfs_transmod - mode for a VxFS inode - * @vip: VxFS inode - * - * Description: - * vxfs_transmod returns a Linux mode_t for a given - * VxFS inode structure. - */ -static __inline__ umode_t -vxfs_transmod(struct vxfs_inode_info *vip) -{ - umode_t ret = vip->vii_mode & ~VXFS_TYPE_MASK; - - if (VXFS_ISFIFO(vip)) - ret |= S_IFIFO; - if (VXFS_ISCHR(vip)) - ret |= S_IFCHR; - if (VXFS_ISDIR(vip)) - ret |= S_IFDIR; - if (VXFS_ISBLK(vip)) - ret |= S_IFBLK; - if (VXFS_ISLNK(vip)) - ret |= S_IFLNK; - if (VXFS_ISREG(vip)) - ret |= S_IFREG; - if (VXFS_ISSOC(vip)) - ret |= S_IFSOCK; - - return (ret); -} - -static inline void dip2vip_cpy(struct vxfs_sb_info *sbi, - struct vxfs_inode_info *vip, struct vxfs_dinode *dip) -{ - struct inode *inode = &vip->vfs_inode; - - vip->vii_mode = fs32_to_cpu(sbi, dip->vdi_mode); - vip->vii_nlink = fs32_to_cpu(sbi, dip->vdi_nlink); - vip->vii_uid = fs32_to_cpu(sbi, dip->vdi_uid); - vip->vii_gid = fs32_to_cpu(sbi, dip->vdi_gid); - vip->vii_size = fs64_to_cpu(sbi, dip->vdi_size); - vip->vii_atime = fs32_to_cpu(sbi, dip->vdi_atime); - vip->vii_autime = fs32_to_cpu(sbi, dip->vdi_autime); - vip->vii_mtime = fs32_to_cpu(sbi, dip->vdi_mtime); - vip->vii_mutime = fs32_to_cpu(sbi, dip->vdi_mutime); - vip->vii_ctime = fs32_to_cpu(sbi, dip->vdi_ctime); - vip->vii_cutime = fs32_to_cpu(sbi, dip->vdi_cutime); - vip->vii_orgtype = dip->vdi_orgtype; - - vip->vii_blocks = fs32_to_cpu(sbi, dip->vdi_blocks); - vip->vii_gen = fs32_to_cpu(sbi, dip->vdi_gen); - - if (VXFS_ISDIR(vip)) - vip->vii_dotdot = fs32_to_cpu(sbi, dip->vdi_dotdot); - else if (!VXFS_ISREG(vip) && !VXFS_ISLNK(vip)) - vip->vii_rdev = fs32_to_cpu(sbi, dip->vdi_rdev); - - /* don't endian swap the fields that differ by orgtype */ - memcpy(&vip->vii_org, &dip->vdi_org, sizeof(vip->vii_org)); - - inode->i_mode = vxfs_transmod(vip); - i_uid_write(inode, (uid_t)vip->vii_uid); - i_gid_write(inode, (gid_t)vip->vii_gid); - - set_nlink(inode, vip->vii_nlink); - inode->i_size = vip->vii_size; - - inode_set_atime(inode, vip->vii_atime, 0); - inode_set_ctime(inode, vip->vii_ctime, 0); - inode_set_mtime(inode, vip->vii_mtime, 0); - - inode->i_blocks = vip->vii_blocks; - inode->i_generation = vip->vii_gen; -} - -/** - * vxfs_blkiget - find inode based on extent # - * @sbp: superblock of the filesystem we search in - * @extent: number of the extent to search - * @ino: inode number to search - * - * Description: - * vxfs_blkiget searches inode @ino in the filesystem described by - * @sbp in the extent @extent. - * Returns the matching VxFS inode on success, else a NULL pointer. - * - * NOTE: - * While __vxfs_iget uses the pagecache vxfs_blkiget uses the - * buffercache. This function should not be used outside the - * read_super() method, otherwise the data may be incoherent. - */ -struct inode * -vxfs_blkiget(struct super_block *sbp, u_long extent, ino_t ino) -{ - struct buffer_head *bp; - struct inode *inode; - u_long block, offset; - - inode = new_inode(sbp); - if (!inode) - return NULL; - inode->i_ino = get_next_ino(); - - block = extent + ((ino * VXFS_ISIZE) / sbp->s_blocksize); - offset = ((ino % (sbp->s_blocksize / VXFS_ISIZE)) * VXFS_ISIZE); - bp = sb_bread(sbp, block); - - if (bp && buffer_mapped(bp)) { - struct vxfs_inode_info *vip = VXFS_INO(inode); - struct vxfs_dinode *dip; - - dip = (struct vxfs_dinode *)(bp->b_data + offset); - dip2vip_cpy(VXFS_SBI(sbp), vip, dip); - vip->vfs_inode.i_mapping->a_ops = &vxfs_aops; -#ifdef DIAGNOSTIC - vxfs_dumpi(vip, ino); -#endif - brelse(bp); - return inode; - } - - printk(KERN_WARNING "vxfs: unable to read block %ld\n", block); - brelse(bp); - iput(inode); - return NULL; -} - -/** - * __vxfs_iget - generic find inode facility - * @ilistp: inode list - * @vip: VxFS inode to fill in - * @ino: inode number - * - * Description: - * Search the for inode number @ino in the filesystem - * described by @sbp. Use the specified inode table (@ilistp). - * Returns the matching inode on success, else an error code. - */ -static int -__vxfs_iget(struct inode *ilistp, struct vxfs_inode_info *vip, ino_t ino) -{ - struct page *pp; - u_long offset; - - offset = (ino % (PAGE_SIZE / VXFS_ISIZE)) * VXFS_ISIZE; - pp = vxfs_get_page(ilistp->i_mapping, ino * VXFS_ISIZE / PAGE_SIZE); - - if (!IS_ERR(pp)) { - struct vxfs_dinode *dip; - caddr_t kaddr = (char *)page_address(pp); - - dip = (struct vxfs_dinode *)(kaddr + offset); - dip2vip_cpy(VXFS_SBI(ilistp->i_sb), vip, dip); - vip->vfs_inode.i_mapping->a_ops = &vxfs_aops; -#ifdef DIAGNOSTIC - vxfs_dumpi(vip, ino); -#endif - vxfs_put_page(pp); - return 0; - } - - printk(KERN_WARNING "vxfs: error on page 0x%p for inode %ld\n", - pp, (unsigned long)ino); - return PTR_ERR(pp); -} - -/** - * vxfs_stiget - find inode using the structural inode list - * @sbp: VFS superblock - * @ino: inode # - * - * Description: - * Find inode @ino in the filesystem described by @sbp using - * the structural inode list. - * Returns the matching inode on success, else a NULL pointer. - */ -struct inode * -vxfs_stiget(struct super_block *sbp, ino_t ino) -{ - struct inode *inode; - int error; - - inode = new_inode(sbp); - if (!inode) - return NULL; - inode->i_ino = get_next_ino(); - - error = __vxfs_iget(VXFS_SBI(sbp)->vsi_stilist, VXFS_INO(inode), ino); - if (error) { - iput(inode); - return NULL; - } - - return inode; -} - -/** - * vxfs_iget - get an inode - * @sbp: the superblock to get the inode for - * @ino: the number of the inode to get - * - * Description: - * vxfs_read_inode creates an inode, reads the disk inode for @ino and fills - * in all relevant fields in the new inode. - */ -struct inode * -vxfs_iget(struct super_block *sbp, ino_t ino) -{ - struct vxfs_inode_info *vip; - const struct address_space_operations *aops; - struct inode *ip; - int error; - - ip = iget_locked(sbp, ino); - if (!ip) - return ERR_PTR(-ENOMEM); - if (!(inode_state_read_once(ip) & I_NEW)) - return ip; - - vip = VXFS_INO(ip); - error = __vxfs_iget(VXFS_SBI(sbp)->vsi_ilist, vip, ino); - if (error) { - iget_failed(ip); - return ERR_PTR(error); - } - - if (VXFS_ISIMMED(vip)) - aops = &vxfs_immed_aops; - else - aops = &vxfs_aops; - - if (S_ISREG(ip->i_mode)) { - ip->i_fop = &generic_ro_fops; - ip->i_mapping->a_ops = aops; - } else if (S_ISDIR(ip->i_mode)) { - ip->i_op = &vxfs_dir_inode_ops; - ip->i_fop = &vxfs_dir_operations; - ip->i_mapping->a_ops = aops; - } else if (S_ISLNK(ip->i_mode)) { - if (!VXFS_ISIMMED(vip)) { - ip->i_op = &page_symlink_inode_operations; - inode_nohighmem(ip); - ip->i_mapping->a_ops = &vxfs_aops; - } else { - ip->i_op = &simple_symlink_inode_operations; - ip->i_link = vip->vii_immed.vi_immed; - nd_terminate_link(ip->i_link, ip->i_size, - sizeof(vip->vii_immed.vi_immed) - 1); - } - } else - init_special_inode(ip, ip->i_mode, old_decode_dev(vip->vii_rdev)); - - unlock_new_inode(ip); - return ip; -} - -/** - * vxfs_evict_inode - remove inode from main memory - * @ip: inode to discard. - * - * Description: - * vxfs_evict_inode() is called on the final iput and frees the private - * inode area. - */ -void -vxfs_evict_inode(struct inode *ip) -{ - truncate_inode_pages_final(&ip->i_data); - clear_inode(ip); -} diff --git a/fs/freevxfs/vxfs_inode.h b/fs/freevxfs/vxfs_inode.h deleted file mode 100644 index 1e9e138d2b33..000000000000 --- a/fs/freevxfs/vxfs_inode.h +++ /dev/null @@ -1,169 +0,0 @@ -/* SPDX-License-Identifier: GPL-2.0-only */ -/* - * Copyright (c) 2000-2001 Christoph Hellwig. - * Copyright (c) 2016 Krzysztof Blaszkowski - */ -#ifndef _VXFS_INODE_H_ -#define _VXFS_INODE_H_ - -/* - * Veritas filesystem driver - inode structure. - * - * This file contains the definition of the disk and core - * inodes of the Veritas Filesystem. - */ - - -#define VXFS_ISIZE 0x100 /* Inode size */ - -#define VXFS_NDADDR 10 /* Number of direct addrs in inode */ -#define VXFS_NIADDR 2 /* Number of indirect addrs in inode */ -#define VXFS_NIMMED 96 /* Size of immediate data in inode */ -#define VXFS_NTYPED 6 /* Num of typed extents */ - -#define VXFS_TYPED_OFFSETMASK (0x00FFFFFFFFFFFFFFULL) -#define VXFS_TYPED_TYPEMASK (0xFF00000000000000ULL) -#define VXFS_TYPED_TYPESHIFT 56 - -#define VXFS_TYPED_PER_BLOCK(sbp) \ - ((sbp)->s_blocksize / sizeof(struct vxfs_typed)) - -/* - * Possible extent descriptor types for %VXFS_ORG_TYPED extents. - */ -enum { - VXFS_TYPED_INDIRECT = 1, - VXFS_TYPED_DATA = 2, - VXFS_TYPED_INDIRECT_DEV4 = 3, - VXFS_TYPED_DATA_DEV4 = 4, -}; - -/* - * Data stored immediately in the inode. - */ -struct vxfs_immed { - __u8 vi_immed[VXFS_NIMMED]; -}; - -struct vxfs_ext4 { - __fs32 ve4_spare; /* ?? */ - __fs32 ve4_indsize; /* Indirect extent size */ - __fs32 ve4_indir[VXFS_NIADDR]; /* Indirect extents */ - struct direct { /* Direct extents */ - __fs32 extent; /* Extent number */ - __fs32 size; /* Size of extent */ - } ve4_direct[VXFS_NDADDR]; -}; - -struct vxfs_typed { - __fs64 vt_hdr; /* Header, 0xTTOOOOOOOOOOOOOO; T=type,O=offs */ - __fs32 vt_block; /* Extent block */ - __fs32 vt_size; /* Size in blocks */ -}; - -struct vxfs_typed_dev4 { - __fs64 vd4_hdr; /* Header, 0xTTOOOOOOOOOOOOOO; T=type,O=offs */ - __fs64 vd4_block; /* Extent block */ - __fs64 vd4_size; /* Size in blocks */ - __fs32 vd4_dev; /* Device ID */ - __u8 __pad1; -}; - -/* - * The inode as contained on the physical device. - */ -struct vxfs_dinode { - __fs32 vdi_mode; - __fs32 vdi_nlink; /* Link count */ - __fs32 vdi_uid; /* UID */ - __fs32 vdi_gid; /* GID */ - __fs64 vdi_size; /* Inode size in bytes */ - __fs32 vdi_atime; /* Last time accessed - sec */ - __fs32 vdi_autime; /* Last time accessed - usec */ - __fs32 vdi_mtime; /* Last modify time - sec */ - __fs32 vdi_mutime; /* Last modify time - usec */ - __fs32 vdi_ctime; /* Create time - sec */ - __fs32 vdi_cutime; /* Create time - usec */ - __u8 vdi_aflags; /* Allocation flags */ - __u8 vdi_orgtype; /* Organisation type */ - __fs16 vdi_eopflags; - __fs32 vdi_eopdata; - union { - __fs32 rdev; - __fs32 dotdot; - struct { - __u32 reserved; - __fs32 fixextsize; - } i_regular; - struct { - __fs32 matchino; - __fs32 fsetindex; - } i_vxspec; - __u64 align; - } vdi_ftarea; - __fs32 vdi_blocks; /* How much blocks does inode occupy */ - __fs32 vdi_gen; /* Inode generation */ - __fs64 vdi_version; /* Version */ - union { - struct vxfs_immed immed; - struct vxfs_ext4 ext4; - struct vxfs_typed typed[VXFS_NTYPED]; - } vdi_org; - __fs32 vdi_iattrino; -}; - -#define vdi_rdev vdi_ftarea.rdev -#define vdi_dotdot vdi_ftarea.dotdot -#define vdi_fixextsize vdi_ftarea.regular.fixextsize -#define vdi_matchino vdi_ftarea.vxspec.matchino -#define vdi_fsetindex vdi_ftarea.vxspec.fsetindex - -#define vdi_immed vdi_org.immed -#define vdi_ext4 vdi_org.ext4 -#define vdi_typed vdi_org.typed - - -/* - * The inode as represented in the main memory. - */ -struct vxfs_inode_info { - struct inode vfs_inode; - - __u32 vii_mode; - __u32 vii_nlink; /* Link count */ - __u32 vii_uid; /* UID */ - __u32 vii_gid; /* GID */ - __u64 vii_size; /* Inode size in bytes */ - __u32 vii_atime; /* Last time accessed - sec */ - __u32 vii_autime; /* Last time accessed - usec */ - __u32 vii_mtime; /* Last modify time - sec */ - __u32 vii_mutime; /* Last modify time - usec */ - __u32 vii_ctime; /* Create time - sec */ - __u32 vii_cutime; /* Create time - usec */ - __u8 vii_orgtype; /* Organisation type */ - union { - __u32 rdev; - __u32 dotdot; - } vii_ftarea; - __u32 vii_blocks; /* How much blocks does inode occupy */ - __u32 vii_gen; /* Inode generation */ - union { - struct vxfs_immed immed; - struct vxfs_ext4 ext4; - struct vxfs_typed typed[VXFS_NTYPED]; - } vii_org; -}; - -#define vii_rdev vii_ftarea.rdev -#define vii_dotdot vii_ftarea.dotdot - -#define vii_immed vii_org.immed -#define vii_ext4 vii_org.ext4 -#define vii_typed vii_org.typed - -static inline struct vxfs_inode_info *VXFS_INO(struct inode *inode) -{ - return container_of(inode, struct vxfs_inode_info, vfs_inode); -} - -#endif /* _VXFS_INODE_H_ */ diff --git a/fs/freevxfs/vxfs_lookup.c b/fs/freevxfs/vxfs_lookup.c deleted file mode 100644 index 138e08de976e..000000000000 --- a/fs/freevxfs/vxfs_lookup.c +++ /dev/null @@ -1,273 +0,0 @@ -// SPDX-License-Identifier: GPL-2.0-only -/* - * Copyright (c) 2000-2001 Christoph Hellwig. - * Copyright (c) 2016 Krzysztof Blaszkowski - */ - -/* - * Veritas filesystem driver - lookup and other directory related code. - */ -#include -#include -#include -#include -#include -#include -#include - -#include "vxfs.h" -#include "vxfs_dir.h" -#include "vxfs_inode.h" -#include "vxfs_extern.h" - -/* - * Number of VxFS blocks per page. - */ -#define VXFS_BLOCK_PER_PAGE(sbp) ((PAGE_SIZE / (sbp)->s_blocksize)) - - -static struct dentry * vxfs_lookup(struct inode *, struct dentry *, unsigned int); -static int vxfs_readdir(struct file *, struct dir_context *); - -const struct inode_operations vxfs_dir_inode_ops = { - .lookup = vxfs_lookup, -}; - -const struct file_operations vxfs_dir_operations = { - .llseek = generic_file_llseek, - .read = generic_read_dir, - .iterate_shared = vxfs_readdir, - .setlease = generic_setlease, -}; - - -/** - * vxfs_find_entry - find a mathing directory entry for a dentry - * @ip: directory inode - * @dp: dentry for which we want to find a direct - * @ppp: gets filled with the page the return value sits in - * - * Description: - * vxfs_find_entry finds a &struct vxfs_direct for the VFS directory - * cache entry @dp. @ppp will be filled with the page the return - * value resides in. - * - * Returns: - * The wanted direct on success, else a NULL pointer. - */ -static struct vxfs_direct * -vxfs_find_entry(struct inode *ip, struct dentry *dp, struct page **ppp) -{ - u_long bsize = ip->i_sb->s_blocksize; - const char *name = dp->d_name.name; - int namelen = dp->d_name.len; - loff_t limit = VXFS_DIRROUND(ip->i_size); - struct vxfs_direct *de_exit = NULL; - loff_t pos = 0; - struct vxfs_sb_info *sbi = VXFS_SBI(ip->i_sb); - - while (pos < limit) { - struct page *pp; - char *kaddr; - int pg_ofs = pos & ~PAGE_MASK; - - pp = vxfs_get_page(ip->i_mapping, pos >> PAGE_SHIFT); - if (IS_ERR(pp)) - return NULL; - kaddr = (char *)page_address(pp); - - while (pg_ofs < PAGE_SIZE && pos < limit) { - struct vxfs_direct *de; - - if ((pos & (bsize - 1)) < 4) { - struct vxfs_dirblk *dbp = - (struct vxfs_dirblk *) - (kaddr + (pos & ~PAGE_MASK)); - int overhead = VXFS_DIRBLKOV(sbi, dbp); - - pos += overhead; - pg_ofs += overhead; - } - de = (struct vxfs_direct *)(kaddr + pg_ofs); - - if (!de->d_reclen) { - pos += bsize - 1; - pos &= ~(bsize - 1); - break; - } - - pg_ofs += fs16_to_cpu(sbi, de->d_reclen); - pos += fs16_to_cpu(sbi, de->d_reclen); - if (!de->d_ino) - continue; - - if (namelen != fs16_to_cpu(sbi, de->d_namelen)) - continue; - if (!memcmp(name, de->d_name, namelen)) { - *ppp = pp; - de_exit = de; - break; - } - } - if (!de_exit) - vxfs_put_page(pp); - else - break; - } - - return de_exit; -} - -/** - * vxfs_inode_by_name - find inode number for dentry - * @dip: directory to search in - * @dp: dentry we search for - * - * Description: - * vxfs_inode_by_name finds out the inode number of - * the path component described by @dp in @dip. - * - * Returns: - * The wanted inode number on success, else Zero. - */ -static ino_t -vxfs_inode_by_name(struct inode *dip, struct dentry *dp) -{ - struct vxfs_direct *de; - struct page *pp; - ino_t ino = 0; - - de = vxfs_find_entry(dip, dp, &pp); - if (de) { - ino = fs32_to_cpu(VXFS_SBI(dip->i_sb), de->d_ino); - kunmap(pp); - put_page(pp); - } - - return (ino); -} - -/** - * vxfs_lookup - lookup pathname component - * @dip: dir in which we lookup - * @dp: dentry we lookup - * @flags: lookup flags - * - * Description: - * vxfs_lookup tries to lookup the pathname component described - * by @dp in @dip. - * - * Returns: - * A NULL-pointer on success, else a negative error code encoded - * in the return pointer. - */ -static struct dentry * -vxfs_lookup(struct inode *dip, struct dentry *dp, unsigned int flags) -{ - struct inode *ip = NULL; - ino_t ino; - - if (dp->d_name.len > VXFS_NAMELEN) - return ERR_PTR(-ENAMETOOLONG); - - ino = vxfs_inode_by_name(dip, dp); - if (ino) - ip = vxfs_iget(dip->i_sb, ino); - return d_splice_alias(ip, dp); -} - -/** - * vxfs_readdir - read a directory - * @fp: the directory to read - * @ctx: dir_context for filldir/readdir - * - * Description: - * vxfs_readdir fills @retp with directory entries from @fp - * using the VFS supplied callback @filler. - * - * Returns: - * Zero. - */ -static int -vxfs_readdir(struct file *fp, struct dir_context *ctx) -{ - struct inode *ip = file_inode(fp); - struct super_block *sbp = ip->i_sb; - u_long bsize = sbp->s_blocksize; - loff_t pos, limit; - struct vxfs_sb_info *sbi = VXFS_SBI(sbp); - - if (ctx->pos == 0) { - if (!dir_emit_dot(fp, ctx)) - goto out; - ctx->pos++; - } - if (ctx->pos == 1) { - if (!dir_emit(ctx, "..", 2, VXFS_INO(ip)->vii_dotdot, DT_DIR)) - goto out; - ctx->pos++; - } - - limit = VXFS_DIRROUND(ip->i_size); - if (ctx->pos > limit) - goto out; - - pos = ctx->pos & ~3L; - - while (pos < limit) { - struct page *pp; - char *kaddr; - int pg_ofs = pos & ~PAGE_MASK; - int rc = 0; - - pp = vxfs_get_page(ip->i_mapping, pos >> PAGE_SHIFT); - if (IS_ERR(pp)) - return -ENOMEM; - - kaddr = (char *)page_address(pp); - - while (pg_ofs < PAGE_SIZE && pos < limit) { - struct vxfs_direct *de; - - if ((pos & (bsize - 1)) < 4) { - struct vxfs_dirblk *dbp = - (struct vxfs_dirblk *) - (kaddr + (pos & ~PAGE_MASK)); - int overhead = VXFS_DIRBLKOV(sbi, dbp); - - pos += overhead; - pg_ofs += overhead; - } - de = (struct vxfs_direct *)(kaddr + pg_ofs); - - if (!de->d_reclen) { - pos += bsize - 1; - pos &= ~(bsize - 1); - break; - } - - pg_ofs += fs16_to_cpu(sbi, de->d_reclen); - pos += fs16_to_cpu(sbi, de->d_reclen); - if (!de->d_ino) - continue; - - rc = dir_emit(ctx, de->d_name, - fs16_to_cpu(sbi, de->d_namelen), - fs32_to_cpu(sbi, de->d_ino), - DT_UNKNOWN); - if (!rc) { - /* the dir entry was not read, fix pos. */ - pos -= fs16_to_cpu(sbi, de->d_reclen); - break; - } - } - vxfs_put_page(pp); - if (!rc) - break; - } - - ctx->pos = pos | 2; - -out: - return 0; -} diff --git a/fs/freevxfs/vxfs_olt.c b/fs/freevxfs/vxfs_olt.c deleted file mode 100644 index 23f35187c289..000000000000 --- a/fs/freevxfs/vxfs_olt.c +++ /dev/null @@ -1,105 +0,0 @@ -// SPDX-License-Identifier: GPL-2.0-only -/* - * Copyright (c) 2000-2001 Christoph Hellwig. - */ - -/* - * Veritas filesystem driver - object location table support. - */ -#include -#include -#include - -#include "vxfs.h" -#include "vxfs_olt.h" -#include "vxfs_extern.h" - - -static inline void -vxfs_get_fshead(struct vxfs_oltfshead *fshp, struct vxfs_sb_info *infp) -{ - BUG_ON(infp->vsi_fshino); - infp->vsi_fshino = fs32_to_cpu(infp, fshp->olt_fsino[0]); -} - -static inline void -vxfs_get_ilist(struct vxfs_oltilist *ilistp, struct vxfs_sb_info *infp) -{ - BUG_ON(infp->vsi_iext); - infp->vsi_iext = fs32_to_cpu(infp, ilistp->olt_iext[0]); -} - -static inline u_long -vxfs_oblock(struct super_block *sbp, daddr_t block, u_long bsize) -{ - BUG_ON(sbp->s_blocksize % bsize); - return (block * (sbp->s_blocksize / bsize)); -} - - -/** - * vxfs_read_olt - read olt - * @sbp: superblock of the filesystem - * @bsize: blocksize of the filesystem - * - * Description: - * vxfs_read_olt reads the olt of the filesystem described by @sbp - * into main memory and does some basic setup. - * - * Returns: - * Zero on success, else a negative error code. - */ -int -vxfs_read_olt(struct super_block *sbp, u_long bsize) -{ - struct vxfs_sb_info *infp = VXFS_SBI(sbp); - struct buffer_head *bp; - struct vxfs_olt *op; - char *oaddr, *eaddr; - - bp = sb_bread(sbp, vxfs_oblock(sbp, infp->vsi_oltext, bsize)); - if (!bp || !bp->b_data) - goto fail; - - op = (struct vxfs_olt *)bp->b_data; - if (fs32_to_cpu(infp, op->olt_magic) != VXFS_OLT_MAGIC) { - printk(KERN_NOTICE "vxfs: ivalid olt magic number\n"); - goto fail; - } - - /* - * It is in theory possible that vsi_oltsize is > 1. - * I've not seen any such filesystem yet and I'm lazy.. --hch - */ - if (infp->vsi_oltsize > 1) { - printk(KERN_NOTICE "vxfs: oltsize > 1 detected.\n"); - printk(KERN_NOTICE "vxfs: please notify hch@infradead.org\n"); - goto fail; - } - - oaddr = bp->b_data + fs32_to_cpu(infp, op->olt_size); - eaddr = bp->b_data + (infp->vsi_oltsize * sbp->s_blocksize); - - while (oaddr < eaddr) { - struct vxfs_oltcommon *ocp = - (struct vxfs_oltcommon *)oaddr; - - switch (fs32_to_cpu(infp, ocp->olt_type)) { - case VXFS_OLT_FSHEAD: - vxfs_get_fshead((struct vxfs_oltfshead *)oaddr, infp); - break; - case VXFS_OLT_ILIST: - vxfs_get_ilist((struct vxfs_oltilist *)oaddr, infp); - break; - } - - oaddr += fs32_to_cpu(infp, ocp->olt_size); - } - - brelse(bp); - return (infp->vsi_fshino && infp->vsi_iext) ? 0 : -EINVAL; - -fail: - brelse(bp); - return -EINVAL; -} diff --git a/fs/freevxfs/vxfs_olt.h b/fs/freevxfs/vxfs_olt.h deleted file mode 100644 index 53afba08d617..000000000000 --- a/fs/freevxfs/vxfs_olt.h +++ /dev/null @@ -1,120 +0,0 @@ -/* SPDX-License-Identifier: GPL-2.0-only */ -/* - * Copyright (c) 2000-2001 Christoph Hellwig. - */ -#ifndef _VXFS_OLT_H_ -#define _VXFS_OLT_H_ - -/* - * Veritas filesystem driver - Object Location Table data structures. - * - * This file contains definitions for the Object Location Table used - * by the Veritas Filesystem version 2 and newer. - */ - - -/* - * OLT magic number (vxfs_olt->olt_magic). - */ -#define VXFS_OLT_MAGIC 0xa504FCF5 - -/* - * VxFS OLT entry types. - */ -enum { - VXFS_OLT_FREE = 1, - VXFS_OLT_FSHEAD = 2, - VXFS_OLT_CUT = 3, - VXFS_OLT_ILIST = 4, - VXFS_OLT_DEV = 5, - VXFS_OLT_SB = 6 -}; - -/* - * VxFS OLT header. - * - * The Object Location Table header is placed at the beginning of each - * OLT extent. It is used to fing certain filesystem-wide metadata, e.g. - * the initial inode list, the fileset header or the device configuration. - */ -struct vxfs_olt { - __fs32 olt_magic; /* magic number */ - __fs32 olt_size; /* size of this entry */ - __fs32 olt_checksum; /* checksum of extent */ - __u32 __unused1; /* ??? */ - __fs32 olt_mtime; /* time of last mod. (sec) */ - __fs32 olt_mutime; /* time of last mod. (usec) */ - __fs32 olt_totfree; /* free space in OLT extent */ - __fs32 olt_extents[2]; /* addr of this extent, replica */ - __fs32 olt_esize; /* size of this extent */ - __fs32 olt_next[2]; /* addr of next extent, replica */ - __fs32 olt_nsize; /* size of next extent */ - __u32 __unused2; /* align to 8 byte boundary */ -}; - -/* - * VxFS common OLT entry (on disk). - */ -struct vxfs_oltcommon { - __fs32 olt_type; /* type of this record */ - __fs32 olt_size; /* size of this record */ -}; - -/* - * VxFS free OLT entry (on disk). - */ -struct vxfs_oltfree { - __fs32 olt_type; /* type of this record */ - __fs32 olt_fsize; /* size of this free record */ -}; - -/* - * VxFS initial-inode list (on disk). - */ -struct vxfs_oltilist { - __fs32 olt_type; /* type of this record */ - __fs32 olt_size; /* size of this record */ - __fs32 olt_iext[2]; /* initial inode list, replica */ -}; - -/* - * Current Usage Table - */ -struct vxfs_oltcut { - __fs32 olt_type; /* type of this record */ - __fs32 olt_size; /* size of this record */ - __fs32 olt_cutino; /* inode of current usage table */ - __u8 __pad; /* unused, 8 byte align */ -}; - -/* - * Inodes containing Superblock, Intent log and OLTs - */ -struct vxfs_oltsb { - __fs32 olt_type; /* type of this record */ - __fs32 olt_size; /* size of this record */ - __fs32 olt_sbino; /* inode of superblock file */ - __u32 __unused1; /* ??? */ - __fs32 olt_logino[2]; /* inode of log file,replica */ - __fs32 olt_oltino[2]; /* inode of OLT, replica */ -}; - -/* - * Inode containing device configuration + it's replica - */ -struct vxfs_oltdev { - __fs32 olt_type; /* type of this record */ - __fs32 olt_size; /* size of this record */ - __fs32 olt_devino[2]; /* inode of device config files */ -}; - -/* - * Fileset header - */ -struct vxfs_oltfshead { - __fs32 olt_type; /* type number */ - __fs32 olt_size; /* size of this record */ - __fs32 olt_fsino[2]; /* inodes of fileset header */ -}; - -#endif /* _VXFS_OLT_H_ */ diff --git a/fs/freevxfs/vxfs_subr.c b/fs/freevxfs/vxfs_subr.c deleted file mode 100644 index f439877ea6e8..000000000000 --- a/fs/freevxfs/vxfs_subr.c +++ /dev/null @@ -1,152 +0,0 @@ -// SPDX-License-Identifier: GPL-2.0-only -/* - * Copyright (c) 2000-2001 Christoph Hellwig. - */ - -/* - * Veritas filesystem driver - shared subroutines. - */ -#include -#include -#include -#include - -#include "vxfs_extern.h" - - -static int vxfs_read_folio(struct file *, struct folio *); -static sector_t vxfs_bmap(struct address_space *, sector_t); - -const struct address_space_operations vxfs_aops = { - .read_folio = vxfs_read_folio, - .bmap = vxfs_bmap, -}; - -inline void -vxfs_put_page(struct page *pp) -{ - kunmap(pp); - put_page(pp); -} - -/** - * vxfs_get_page - read a page into memory. - * @mapping: mapping to read from - * @n: page number - * - * Description: - * vxfs_get_page reads the @n th page of @ip into the pagecache. - * - * Returns: - * The wanted page on success, else a NULL pointer. - */ -struct page * -vxfs_get_page(struct address_space *mapping, u_long n) -{ - struct page * pp; - - pp = read_mapping_page(mapping, n, NULL); - - if (!IS_ERR(pp)) { - kmap(pp); - /** if (!PageChecked(pp)) **/ - /** vxfs_check_page(pp); **/ - } - - return (pp); -} - -/** - * vxfs_bread - read buffer for a give inode,block tuple - * @ip: inode - * @block: logical block - * - * Description: - * The vxfs_bread function reads block no @block of - * @ip into the buffercache. - * - * Returns: - * The resulting &struct buffer_head. - */ -struct buffer_head * -vxfs_bread(struct inode *ip, int block) -{ - struct buffer_head *bp; - daddr_t pblock; - - pblock = vxfs_bmap1(ip, block); - bp = sb_bread(ip->i_sb, pblock); - - return (bp); -} - -/** - * vxfs_getblk - locate buffer for given inode,block tuple - * @ip: inode - * @iblock: logical block - * @bp: buffer skeleton - * @create: %TRUE if blocks may be newly allocated. - * - * Description: - * The vxfs_getblk function fills @bp with the right physical - * block and device number to perform a lowlevel read/write on - * it. - * - * Returns: - * Zero on success, else a negativ error code (-EIO). - */ -static int -vxfs_getblk(struct inode *ip, sector_t iblock, - struct buffer_head *bp, int create) -{ - daddr_t pblock; - - pblock = vxfs_bmap1(ip, iblock); - if (pblock != 0) { - map_bh(bp, ip->i_sb, pblock); - return 0; - } - - return -EIO; -} - -/** - * vxfs_read_folio - read one page synchronously into the pagecache - * @file: file context (unused) - * @folio: folio to fill in. - * - * Description: - * The vxfs_read_folio routine reads @folio synchronously into the - * pagecache. - * - * Returns: - * Zero on success, else a negative error code. - * - * Locking status: - * @folio is locked and will be unlocked. - */ -static int vxfs_read_folio(struct file *file, struct folio *folio) -{ - return block_read_full_folio(folio, vxfs_getblk); -} - -/** - * vxfs_bmap - perform logical to physical block mapping - * @mapping: logical to physical mapping to use - * @block: logical block (relative to @mapping). - * - * Description: - * Vxfs_bmap find out the corresponding phsical block to the - * @mapping, @block pair. - * - * Returns: - * Physical block number on success, else Zero. - * - * Locking status: - * We are under the bkl. - */ -static sector_t -vxfs_bmap(struct address_space *mapping, sector_t block) -{ - return generic_block_bmap(mapping, block, vxfs_getblk); -} diff --git a/fs/freevxfs/vxfs_super.c b/fs/freevxfs/vxfs_super.c deleted file mode 100644 index d7d847d75c3d..000000000000 --- a/fs/freevxfs/vxfs_super.c +++ /dev/null @@ -1,347 +0,0 @@ -// SPDX-License-Identifier: GPL-2.0-only -/* - * Copyright (c) 2000-2001 Christoph Hellwig. - * Copyright (c) 2016 Krzysztof Blaszkowski - */ - -/* - * Veritas filesystem driver - superblock related routines. - */ -#include -#include - -#include -#include -#include -#include -#include -#include -#include -#include - -#include "vxfs.h" -#include "vxfs_extern.h" -#include "vxfs_dir.h" -#include "vxfs_inode.h" - - -MODULE_AUTHOR("Christoph Hellwig, Krzysztof Blaszkowski"); -MODULE_DESCRIPTION("Veritas Filesystem (VxFS) driver"); -MODULE_LICENSE("Dual BSD/GPL"); - -static struct kmem_cache *vxfs_inode_cachep; - -/** - * vxfs_put_super - free superblock resources - * @sbp: VFS superblock. - * - * Description: - * vxfs_put_super frees all resources allocated for @sbp - * after the last instance of the filesystem is unmounted. - */ - -static void -vxfs_put_super(struct super_block *sbp) -{ - struct vxfs_sb_info *infp = VXFS_SBI(sbp); - - iput(infp->vsi_fship); - iput(infp->vsi_ilist); - iput(infp->vsi_stilist); - - brelse(infp->vsi_bp); - kfree(infp); -} - -/** - * vxfs_statfs - get filesystem information - * @dentry: VFS dentry to locate superblock - * @bufp: output buffer - * - * Description: - * vxfs_statfs fills the statfs buffer @bufp with information - * about the filesystem described by @dentry. - * - * Returns: - * Zero. - * - * Locking: - * No locks held. - * - * Notes: - * This is everything but complete... - */ -static int -vxfs_statfs(struct dentry *dentry, struct kstatfs *bufp) -{ - struct vxfs_sb_info *infp = VXFS_SBI(dentry->d_sb); - struct vxfs_sb *raw_sb = infp->vsi_raw; - u64 id = huge_encode_dev(dentry->d_sb->s_bdev->bd_dev); - - bufp->f_type = VXFS_SUPER_MAGIC; - bufp->f_bsize = dentry->d_sb->s_blocksize; - bufp->f_blocks = fs32_to_cpu(infp, raw_sb->vs_dsize); - bufp->f_bfree = fs32_to_cpu(infp, raw_sb->vs_free); - bufp->f_bavail = 0; - bufp->f_files = 0; - bufp->f_ffree = fs32_to_cpu(infp, raw_sb->vs_ifree); - bufp->f_fsid = u64_to_fsid(id); - bufp->f_namelen = VXFS_NAMELEN; - - return 0; -} - -static int vxfs_reconfigure(struct fs_context *fc) -{ - sync_filesystem(fc->root->d_sb); - fc->sb_flags |= SB_RDONLY; - return 0; -} - -static struct inode *vxfs_alloc_inode(struct super_block *sb) -{ - struct vxfs_inode_info *vi; - - vi = alloc_inode_sb(sb, vxfs_inode_cachep, GFP_KERNEL); - if (!vi) - return NULL; - inode_init_once(&vi->vfs_inode); - return &vi->vfs_inode; -} - -static void vxfs_free_inode(struct inode *inode) -{ - kmem_cache_free(vxfs_inode_cachep, VXFS_INO(inode)); -} - -static const struct super_operations vxfs_super_ops = { - .alloc_inode = vxfs_alloc_inode, - .free_inode = vxfs_free_inode, - .evict_inode = vxfs_evict_inode, - .put_super = vxfs_put_super, - .statfs = vxfs_statfs, -}; - -static int vxfs_try_sb_magic(struct super_block *sbp, struct fs_context *fc, - unsigned blk, __fs32 magic) -{ - struct buffer_head *bp; - struct vxfs_sb *rsbp; - struct vxfs_sb_info *infp = VXFS_SBI(sbp); - int silent = fc->sb_flags & SB_SILENT; - int rc = -ENOMEM; - - bp = sb_bread(sbp, blk); - do { - if (!bp || !buffer_mapped(bp)) { - if (!silent) { - warnf(fc, - "vxfs: unable to read disk superblock at %u", - blk); - } - break; - } - - rc = -EINVAL; - rsbp = (struct vxfs_sb *)bp->b_data; - if (rsbp->vs_magic != magic) { - if (!silent) - infof(fc, - "vxfs: WRONG superblock magic %08x at %u", - rsbp->vs_magic, blk); - break; - } - - rc = 0; - infp->vsi_raw = rsbp; - infp->vsi_bp = bp; - } while (0); - - if (rc) { - infp->vsi_raw = NULL; - infp->vsi_bp = NULL; - brelse(bp); - } - - return rc; -} - -/** - * vxfs_fill_super - read superblock into memory and initialize filesystem - * @sbp: VFS superblock (to fill) - * @fc: filesytem context - * - * Description: - * We are called on the first mount of a filesystem to read the - * superblock into memory and do some basic setup. - * - * Returns: - * The superblock on success, else %NULL. - * - * Locking: - * We are under @sbp->s_lock. - */ -static int vxfs_fill_super(struct super_block *sbp, struct fs_context *fc) -{ - struct vxfs_sb_info *infp; - struct vxfs_sb *rsbp; - u_long bsize; - struct inode *root; - int ret = -EINVAL; - int silent = fc->sb_flags & SB_SILENT; - u32 j; - - sbp->s_flags |= SB_RDONLY; - - infp = kzalloc_obj(*infp); - if (!infp) { - warnf(fc, "vxfs: unable to allocate incore superblock"); - return -ENOMEM; - } - - bsize = sb_min_blocksize(sbp, BLOCK_SIZE); - if (!bsize) { - warnf(fc, "vxfs: unable to set blocksize"); - goto out; - } - - sbp->s_op = &vxfs_super_ops; - sbp->s_fs_info = infp; - sbp->s_time_min = 0; - sbp->s_time_max = U32_MAX; - - if (!vxfs_try_sb_magic(sbp, fc, 1, - (__force __fs32)cpu_to_le32(VXFS_SUPER_MAGIC))) { - /* Unixware, x86 */ - infp->byte_order = VXFS_BO_LE; - } else if (!vxfs_try_sb_magic(sbp, fc, 8, - (__force __fs32)cpu_to_be32(VXFS_SUPER_MAGIC))) { - /* HP-UX, parisc */ - infp->byte_order = VXFS_BO_BE; - } else { - if (!silent) - infof(fc, "vxfs: can't find superblock."); - goto out; - } - - rsbp = infp->vsi_raw; - j = fs32_to_cpu(infp, rsbp->vs_version); - if ((j < 2 || j > 4) && !silent) { - infof(fc, "vxfs: unsupported VxFS version (%d)", j); - goto out; - } - -#ifdef DIAGNOSTIC - printk(KERN_DEBUG "vxfs: supported VxFS version (%d)\n", j); - printk(KERN_DEBUG "vxfs: blocksize: %d\n", - fs32_to_cpu(infp, rsbp->vs_bsize)); -#endif - - sbp->s_magic = fs32_to_cpu(infp, rsbp->vs_magic); - - infp->vsi_oltext = fs32_to_cpu(infp, rsbp->vs_oltext[0]); - infp->vsi_oltsize = fs32_to_cpu(infp, rsbp->vs_oltsize); - - j = fs32_to_cpu(infp, rsbp->vs_bsize); - if (!sb_set_blocksize(sbp, j)) { - warnf(fc, "vxfs: unable to set final block size"); - goto out; - } - - if (vxfs_read_olt(sbp, bsize)) { - warnf(fc, "vxfs: unable to read olt"); - goto out; - } - - if (vxfs_read_fshead(sbp)) { - warnf(fc, "vxfs: unable to read fshead"); - goto out; - } - - root = vxfs_iget(sbp, VXFS_ROOT_INO); - if (IS_ERR(root)) { - ret = PTR_ERR(root); - goto out; - } - sbp->s_root = d_make_root(root); - if (!sbp->s_root) { - warnf(fc, "vxfs: unable to get root dentry."); - goto out_free_ilist; - } - - return 0; - -out_free_ilist: - iput(infp->vsi_fship); - iput(infp->vsi_ilist); - iput(infp->vsi_stilist); -out: - brelse(infp->vsi_bp); - kfree(infp); - return ret; -} - -/* - * The usual module blurb. - */ -static int vxfs_get_tree(struct fs_context *fc) -{ - return get_tree_bdev(fc, vxfs_fill_super); -} - -static const struct fs_context_operations vxfs_context_ops = { - .get_tree = vxfs_get_tree, - .reconfigure = vxfs_reconfigure, -}; - -static int vxfs_init_fs_context(struct fs_context *fc) -{ - fc->ops = &vxfs_context_ops; - - return 0; -} - -static struct file_system_type vxfs_fs_type = { - .owner = THIS_MODULE, - .name = "vxfs", - .kill_sb = kill_block_super, - .fs_flags = FS_REQUIRES_DEV, - .init_fs_context = vxfs_init_fs_context, -}; -MODULE_ALIAS_FS("vxfs"); /* makes mount -t vxfs autoload the module */ -MODULE_ALIAS("vxfs"); - -static int __init -vxfs_init(void) -{ - int rv; - - vxfs_inode_cachep = kmem_cache_create_usercopy("vxfs_inode", - sizeof(struct vxfs_inode_info), 0, - SLAB_RECLAIM_ACCOUNT, - offsetof(struct vxfs_inode_info, vii_immed.vi_immed), - sizeof_field(struct vxfs_inode_info, - vii_immed.vi_immed), - NULL); - if (!vxfs_inode_cachep) - return -ENOMEM; - rv = register_filesystem(&vxfs_fs_type); - if (rv < 0) - kmem_cache_destroy(vxfs_inode_cachep); - return rv; -} - -static void __exit -vxfs_cleanup(void) -{ - unregister_filesystem(&vxfs_fs_type); - /* - * Make sure all delayed rcu free inodes are flushed before we - * destroy cache. - */ - rcu_barrier(); - kmem_cache_destroy(vxfs_inode_cachep); -} - -module_init(vxfs_init); -module_exit(vxfs_cleanup); -- 2.53.0