diff options
36 files changed, 47 insertions, 5232 deletions
diff --git a/sys/amd64/amd64/autoconf.c b/sys/amd64/amd64/autoconf.c index a9dbc8526fb4..e40bda18552a 100644 --- a/sys/amd64/amd64/autoconf.c +++ b/sys/amd64/amd64/autoconf.c @@ -34,7 +34,7 @@ * SUCH DAMAGE. * * from: @(#)autoconf.c 7.1 (Berkeley) 5/9/91 - * $Id: autoconf.c,v 1.83 1998/01/09 03:20:53 eivind Exp $ + * $Id: autoconf.c,v 1.84 1998/01/24 02:54:12 eivind Exp $ */ /* @@ -48,7 +48,6 @@ #include "opt_bootp.h" #include "opt_ffs.h" #include "opt_cd9660.h" -#include "opt_lfs.h" #include "opt_mfs.h" #include "opt_nfs.h" @@ -370,24 +369,6 @@ cpu_rootconf() } #endif -#if defined(LFS) || defined(LFS_ROOT) - if (!mountrootfsname) { - if (bootverbose) - printf("Considering LFS root f/s.\n"); - mountrootfsname = "lfs"; - /* - * Ignore the -a flag if this kernel isn't compiled - * with a generic root/swap configuration: if we skip - * setroot() and we aren't a generic kernel, chaos - * will ensue because setconf() will be a no-op. - * (rootdev is always initialized to NODEV in a - * generic configuration, so we test for that.) - */ - if ((boothowto & RB_ASKNAME) == 0 || rootdev != NODEV) - setroot(); - } -#endif - if (!mountrootfsname) { panic("Nobody wants to mount my root for me"); } diff --git a/sys/conf/NOTES b/sys/conf/NOTES index 8f6249127e86..6f3cdfef2b67 100644 --- a/sys/conf/NOTES +++ b/sys/conf/NOTES @@ -2,7 +2,7 @@ # LINT -- config file for checking all the sources, tries to pull in # as much of the source tree as it can. # -# $Id: LINT,v 1.395 1998/01/25 03:55:47 eivind Exp $ +# $Id: LINT,v 1.396 1998/01/26 06:33:48 julian Exp $ # # NB: You probably don't want to try running a kernel built from this # file. Instead, you should start from GENERIC, and add options from @@ -424,11 +424,11 @@ options TCPDEBUG # # Only the root, /usr, and /tmp filesystems need be statically # compiled; everything else will be automatically loaded at mount -# time. (Exception: the UFS family---FFS, MFS, and LFS---cannot +# time. (Exception: the UFS family---FFS, and MFS --- cannot # currently be demand-loaded.) Some people still prefer to statically # compile other filesystems as well. # -# NB: The LFS, PORTAL, and UNION filesystems are known to be buggy, +# NB: The PORTAL, and UNION filesystems are known to be buggy, # and WILL panic your system if you attempt to do anything with them. # They are included here as an incentive for some enterprising soul to # sit down and fix them. @@ -443,7 +443,6 @@ options NFS #Network File System options "CD9660" #ISO 9660 filesystem options FDESC #File descriptor filesystem options KERNFS #Kernel filesystem -#options LFS #Log filesystem options MFS #Memory File System options MSDOSFS #MS DOS File System options NULLFS #NULL filesystem @@ -453,7 +452,6 @@ options UMAPFS #UID map filesystem options UNION #Union filesystem options "CD9660_ROOT" #CD-ROM usable as root device options FFS_ROOT #FFS usable as root device -#options LFS_ROOT #LFS usable as root device options NFS_ROOT #NFS usable as root device # This DEVFS is experimental but seems to work options DEVFS #devices filesystem diff --git a/sys/conf/files b/sys/conf/files index 098fdad62461..59da1772412a 100644 --- a/sys/conf/files +++ b/sys/conf/files @@ -412,17 +412,6 @@ ufs/ffs/ffs_vfsops.c optional ffs ufs/ffs/ffs_vfsops.c optional mfs ufs/ffs/ffs_vnops.c optional ffs ufs/ffs/ffs_vnops.c optional mfs -ufs/lfs/lfs_alloc.c optional lfs -ufs/lfs/lfs_balloc.c optional lfs -ufs/lfs/lfs_bio.c optional lfs -ufs/lfs/lfs_cksum.c optional lfs -ufs/lfs/lfs_debug.c optional lfs -ufs/lfs/lfs_inode.c optional lfs -ufs/lfs/lfs_segment.c optional lfs -ufs/lfs/lfs_subr.c optional lfs -ufs/lfs/lfs_syscalls.c optional lfs -ufs/lfs/lfs_vfsops.c optional lfs -ufs/lfs/lfs_vnops.c optional lfs ufs/mfs/mfs_vfsops.c optional mfs ufs/mfs/mfs_vnops.c optional mfs ufs/ufs/ufs_bmap.c standard diff --git a/sys/conf/options b/sys/conf/options index 0f24d1e9fc2a..c0742f6f28bf 100644 --- a/sys/conf/options +++ b/sys/conf/options @@ -1,4 +1,4 @@ -# $Id: options,v 1.49 1998/01/25 04:23:29 eivind Exp $ +# $Id: options,v 1.50 1998/01/26 18:31:18 julian Exp $ # Format: # Option name filename @@ -48,7 +48,6 @@ UMAPFS opt_dontuse.h # unavailable for the LKM-based versions. CD9660 FFS -LFS NFS # The above static dependencies are planned removed, with a @@ -57,7 +56,6 @@ NFS # they won't make any difference yet). CD9660_ROOT opt_cd9660.h FFS_ROOT opt_ffs.h -LFS_ROOT opt_lfs.h NFS_ROOT opt_nfs.h # Multi-session CD-Rs might require a huge amount of time in order to diff --git a/sys/gnu/ext2fs/ext2_mount.h b/sys/gnu/ext2fs/ext2_mount.h index ee7963190c89..c62b736034f5 100644 --- a/sys/gnu/ext2fs/ext2_mount.h +++ b/sys/gnu/ext2fs/ext2_mount.h @@ -31,7 +31,7 @@ * SUCH DAMAGE. * * @(#)ufsmount.h 8.6 (Berkeley) 3/30/95 - * $Id: ufsmount.h,v 1.11 1997/10/16 10:50:27 phk Exp $ + * $Id: ufsmount.h,v 1.12 1997/10/16 20:32:40 phk Exp $ */ #ifndef _UFS_UFS_UFSMOUNT_H_ @@ -77,12 +77,10 @@ struct ufsmount { struct vnode *um_devvp; /* block device mounted vnode */ union { /* pointer to superblock */ - struct lfs *lfs; /* LFS */ struct fs *fs; /* FFS */ struct ext2_sb_info *e2fs; /* EXT2FS */ } ufsmount_u; #define um_fs ufsmount_u.fs -#define um_lfs ufsmount_u.lfs #define um_e2fs ufsmount_u.e2fs #define um_e2fsb ufsmount_u.e2fs->s_es diff --git a/sys/gnu/ext2fs/inode.h b/sys/gnu/ext2fs/inode.h index 161de4bc9440..f2fd0f25fa5e 100644 --- a/sys/gnu/ext2fs/inode.h +++ b/sys/gnu/ext2fs/inode.h @@ -36,7 +36,7 @@ * SUCH DAMAGE. * * @(#)inode.h 8.9 (Berkeley) 5/14/95 - * $Id: inode.h,v 1.18 1997/10/17 12:36:19 phk Exp $ + * $Id: inode.h,v 1.19 1997/12/05 13:43:47 jkh Exp $ */ #ifndef _UFS_UFS_INODE_H_ @@ -70,11 +70,9 @@ struct inode { union { /* Associated filesystem. */ struct fs *fs; /* FFS */ - struct lfs *lfs; /* LFS */ struct ext2_sb_info *e2fs; /* EXT2FS */ } inode_u; #define i_fs inode_u.fs -#define i_lfs inode_u.lfs #define i_e2fs inode_u.e2fs struct dquot *i_dquot[MAXQUOTAS]; /* Dquot structures. */ u_quad_t i_modrev; /* Revision level for NFS lease. */ diff --git a/sys/gnu/fs/ext2fs/ext2_mount.h b/sys/gnu/fs/ext2fs/ext2_mount.h index ee7963190c89..c62b736034f5 100644 --- a/sys/gnu/fs/ext2fs/ext2_mount.h +++ b/sys/gnu/fs/ext2fs/ext2_mount.h @@ -31,7 +31,7 @@ * SUCH DAMAGE. * * @(#)ufsmount.h 8.6 (Berkeley) 3/30/95 - * $Id: ufsmount.h,v 1.11 1997/10/16 10:50:27 phk Exp $ + * $Id: ufsmount.h,v 1.12 1997/10/16 20:32:40 phk Exp $ */ #ifndef _UFS_UFS_UFSMOUNT_H_ @@ -77,12 +77,10 @@ struct ufsmount { struct vnode *um_devvp; /* block device mounted vnode */ union { /* pointer to superblock */ - struct lfs *lfs; /* LFS */ struct fs *fs; /* FFS */ struct ext2_sb_info *e2fs; /* EXT2FS */ } ufsmount_u; #define um_fs ufsmount_u.fs -#define um_lfs ufsmount_u.lfs #define um_e2fs ufsmount_u.e2fs #define um_e2fsb ufsmount_u.e2fs->s_es diff --git a/sys/gnu/fs/ext2fs/inode.h b/sys/gnu/fs/ext2fs/inode.h index 161de4bc9440..f2fd0f25fa5e 100644 --- a/sys/gnu/fs/ext2fs/inode.h +++ b/sys/gnu/fs/ext2fs/inode.h @@ -36,7 +36,7 @@ * SUCH DAMAGE. * * @(#)inode.h 8.9 (Berkeley) 5/14/95 - * $Id: inode.h,v 1.18 1997/10/17 12:36:19 phk Exp $ + * $Id: inode.h,v 1.19 1997/12/05 13:43:47 jkh Exp $ */ #ifndef _UFS_UFS_INODE_H_ @@ -70,11 +70,9 @@ struct inode { union { /* Associated filesystem. */ struct fs *fs; /* FFS */ - struct lfs *lfs; /* LFS */ struct ext2_sb_info *e2fs; /* EXT2FS */ } inode_u; #define i_fs inode_u.fs -#define i_lfs inode_u.lfs #define i_e2fs inode_u.e2fs struct dquot *i_dquot[MAXQUOTAS]; /* Dquot structures. */ u_quad_t i_modrev; /* Revision level for NFS lease. */ diff --git a/sys/i386/conf/LINT b/sys/i386/conf/LINT index 8f6249127e86..6f3cdfef2b67 100644 --- a/sys/i386/conf/LINT +++ b/sys/i386/conf/LINT @@ -2,7 +2,7 @@ # LINT -- config file for checking all the sources, tries to pull in # as much of the source tree as it can. # -# $Id: LINT,v 1.395 1998/01/25 03:55:47 eivind Exp $ +# $Id: LINT,v 1.396 1998/01/26 06:33:48 julian Exp $ # # NB: You probably don't want to try running a kernel built from this # file. Instead, you should start from GENERIC, and add options from @@ -424,11 +424,11 @@ options TCPDEBUG # # Only the root, /usr, and /tmp filesystems need be statically # compiled; everything else will be automatically loaded at mount -# time. (Exception: the UFS family---FFS, MFS, and LFS---cannot +# time. (Exception: the UFS family---FFS, and MFS --- cannot # currently be demand-loaded.) Some people still prefer to statically # compile other filesystems as well. # -# NB: The LFS, PORTAL, and UNION filesystems are known to be buggy, +# NB: The PORTAL, and UNION filesystems are known to be buggy, # and WILL panic your system if you attempt to do anything with them. # They are included here as an incentive for some enterprising soul to # sit down and fix them. @@ -443,7 +443,6 @@ options NFS #Network File System options "CD9660" #ISO 9660 filesystem options FDESC #File descriptor filesystem options KERNFS #Kernel filesystem -#options LFS #Log filesystem options MFS #Memory File System options MSDOSFS #MS DOS File System options NULLFS #NULL filesystem @@ -453,7 +452,6 @@ options UMAPFS #UID map filesystem options UNION #Union filesystem options "CD9660_ROOT" #CD-ROM usable as root device options FFS_ROOT #FFS usable as root device -#options LFS_ROOT #LFS usable as root device options NFS_ROOT #NFS usable as root device # This DEVFS is experimental but seems to work options DEVFS #devices filesystem diff --git a/sys/i386/conf/NOTES b/sys/i386/conf/NOTES index 8f6249127e86..6f3cdfef2b67 100644 --- a/sys/i386/conf/NOTES +++ b/sys/i386/conf/NOTES @@ -2,7 +2,7 @@ # LINT -- config file for checking all the sources, tries to pull in # as much of the source tree as it can. # -# $Id: LINT,v 1.395 1998/01/25 03:55:47 eivind Exp $ +# $Id: LINT,v 1.396 1998/01/26 06:33:48 julian Exp $ # # NB: You probably don't want to try running a kernel built from this # file. Instead, you should start from GENERIC, and add options from @@ -424,11 +424,11 @@ options TCPDEBUG # # Only the root, /usr, and /tmp filesystems need be statically # compiled; everything else will be automatically loaded at mount -# time. (Exception: the UFS family---FFS, MFS, and LFS---cannot +# time. (Exception: the UFS family---FFS, and MFS --- cannot # currently be demand-loaded.) Some people still prefer to statically # compile other filesystems as well. # -# NB: The LFS, PORTAL, and UNION filesystems are known to be buggy, +# NB: The PORTAL, and UNION filesystems are known to be buggy, # and WILL panic your system if you attempt to do anything with them. # They are included here as an incentive for some enterprising soul to # sit down and fix them. @@ -443,7 +443,6 @@ options NFS #Network File System options "CD9660" #ISO 9660 filesystem options FDESC #File descriptor filesystem options KERNFS #Kernel filesystem -#options LFS #Log filesystem options MFS #Memory File System options MSDOSFS #MS DOS File System options NULLFS #NULL filesystem @@ -453,7 +452,6 @@ options UMAPFS #UID map filesystem options UNION #Union filesystem options "CD9660_ROOT" #CD-ROM usable as root device options FFS_ROOT #FFS usable as root device -#options LFS_ROOT #LFS usable as root device options NFS_ROOT #NFS usable as root device # This DEVFS is experimental but seems to work options DEVFS #devices filesystem diff --git a/sys/i386/i386/autoconf.c b/sys/i386/i386/autoconf.c index a9dbc8526fb4..e40bda18552a 100644 --- a/sys/i386/i386/autoconf.c +++ b/sys/i386/i386/autoconf.c @@ -34,7 +34,7 @@ * SUCH DAMAGE. * * from: @(#)autoconf.c 7.1 (Berkeley) 5/9/91 - * $Id: autoconf.c,v 1.83 1998/01/09 03:20:53 eivind Exp $ + * $Id: autoconf.c,v 1.84 1998/01/24 02:54:12 eivind Exp $ */ /* @@ -48,7 +48,6 @@ #include "opt_bootp.h" #include "opt_ffs.h" #include "opt_cd9660.h" -#include "opt_lfs.h" #include "opt_mfs.h" #include "opt_nfs.h" @@ -370,24 +369,6 @@ cpu_rootconf() } #endif -#if defined(LFS) || defined(LFS_ROOT) - if (!mountrootfsname) { - if (bootverbose) - printf("Considering LFS root f/s.\n"); - mountrootfsname = "lfs"; - /* - * Ignore the -a flag if this kernel isn't compiled - * with a generic root/swap configuration: if we skip - * setroot() and we aren't a generic kernel, chaos - * will ensue because setconf() will be a no-op. - * (rootdev is always initialized to NODEV in a - * generic configuration, so we test for that.) - */ - if ((boothowto & RB_ASKNAME) == 0 || rootdev != NODEV) - setroot(); - } -#endif - if (!mountrootfsname) { panic("Nobody wants to mount my root for me"); } diff --git a/sys/kern/init_main.c b/sys/kern/init_main.c index 03f707ccca9c..7cdb77ac71d5 100644 --- a/sys/kern/init_main.c +++ b/sys/kern/init_main.c @@ -39,7 +39,7 @@ * SUCH DAMAGE. * * @(#)init_main.c 8.9 (Berkeley) 1/21/94 - * $Id: init_main.c,v 1.79 1997/12/14 02:10:12 dyson Exp $ + * $Id: init_main.c,v 1.80 1998/01/22 17:29:44 dyson Exp $ */ #include "opt_devfs.h" @@ -139,8 +139,7 @@ SYSINIT(placeholder, SI_SUB_DUMMY,SI_ORDER_ANY, NULL, NULL) * This allows simple addition of new kernel subsystems that require * boot time initialization. It also allows substitution of subsystem * (for instance, a scheduler, kernel profiler, or VM system) by object - * module. Finally, it allows for optional "kernel threads", like an LFS - * cleaner. + * module. Finally, it allows for optional "kernel threads". */ void main(framep) diff --git a/sys/kern/init_sysent.c b/sys/kern/init_sysent.c index f95255aa5025..4697d70249cb 100644 --- a/sys/kern/init_sysent.c +++ b/sys/kern/init_sysent.c @@ -2,7 +2,7 @@ * System call switch table. * * DO NOT EDIT-- this file is automatically generated. - * created from Id: syscalls.master,v 1.44 1997/10/26 20:27:51 phk Exp + * created from Id: syscalls.master,v 1.46 1998/01/24 02:54:35 eivind Exp */ #include "opt_compat.h" @@ -203,17 +203,10 @@ struct sysent sysent[] = { { 1, (sy_call_t *)setgid }, /* 181 = setgid */ { 1, (sy_call_t *)setegid }, /* 182 = setegid */ { 1, (sy_call_t *)seteuid }, /* 183 = seteuid */ -#ifdef LFS - { 3, (sy_call_t *)lfs_bmapv }, /* 184 = lfs_bmapv */ - { 3, (sy_call_t *)lfs_markv }, /* 185 = lfs_markv */ - { 2, (sy_call_t *)lfs_segclean }, /* 186 = lfs_segclean */ - { 2, (sy_call_t *)lfs_segwait }, /* 187 = lfs_segwait */ -#else - { 0, (sy_call_t *)nosys }, /* 184 = nosys */ - { 0, (sy_call_t *)nosys }, /* 185 = nosys */ - { 0, (sy_call_t *)nosys }, /* 186 = nosys */ - { 0, (sy_call_t *)nosys }, /* 187 = nosys */ -#endif + { 0, (sy_call_t *)nosys }, /* 184 = lfs_bmapv */ + { 0, (sy_call_t *)nosys }, /* 185 = lfs_markv */ + { 0, (sy_call_t *)nosys }, /* 186 = lfs_segclean */ + { 0, (sy_call_t *)nosys }, /* 187 = lfs_segwait */ { 2, (sy_call_t *)stat }, /* 188 = stat */ { 2, (sy_call_t *)fstat }, /* 189 = fstat */ { 2, (sy_call_t *)lstat }, /* 190 = lstat */ diff --git a/sys/kern/syscalls.c b/sys/kern/syscalls.c index 68645dff762d..09bd89085822 100644 --- a/sys/kern/syscalls.c +++ b/sys/kern/syscalls.c @@ -2,7 +2,7 @@ * System call names. * * DO NOT EDIT-- this file is automatically generated. - * created from Id: syscalls.master,v 1.44 1997/10/26 20:27:51 phk Exp + * created from Id: syscalls.master,v 1.46 1998/01/24 02:54:35 eivind Exp */ char *syscallnames[] = { @@ -190,17 +190,10 @@ char *syscallnames[] = { "setgid", /* 181 = setgid */ "setegid", /* 182 = setegid */ "seteuid", /* 183 = seteuid */ -#ifdef LFS - "lfs_bmapv", /* 184 = lfs_bmapv */ - "lfs_markv", /* 185 = lfs_markv */ - "lfs_segclean", /* 186 = lfs_segclean */ - "lfs_segwait", /* 187 = lfs_segwait */ -#else - "#184", /* 184 = nosys */ - "#185", /* 185 = nosys */ - "#186", /* 186 = nosys */ - "#187", /* 187 = nosys */ -#endif + "#184", /* 184 = lfs_bmapv */ + "#185", /* 185 = lfs_markv */ + "#186", /* 186 = lfs_segclean */ + "#187", /* 187 = lfs_segwait */ "stat", /* 188 = stat */ "fstat", /* 189 = fstat */ "lstat", /* 190 = lstat */ diff --git a/sys/kern/syscalls.master b/sys/kern/syscalls.master index d2998e212271..43a5a9b4ba0b 100644 --- a/sys/kern/syscalls.master +++ b/sys/kern/syscalls.master @@ -1,4 +1,4 @@ - $Id: syscalls.master,v 1.45 1998/01/01 17:07:46 alex Exp $ + $Id: syscalls.master,v 1.46 1998/01/24 02:54:35 eivind Exp $ ; from: @(#)syscalls.master 8.2 (Berkeley) 1/13/94 ; ; System call name/number master file. @@ -24,8 +24,6 @@ ; #ifdef's, etc. may be included, and are copied to the output files. -#include "opt_lfs.h" - #include <sys/param.h> #include <sys/sysent.h> #include <sys/sysproto.h> @@ -280,21 +278,10 @@ 181 STD POSIX { int setgid(gid_t gid); } 182 STD BSD { int setegid(gid_t egid); } 183 STD BSD { int seteuid(uid_t euid); } -#ifdef LFS -184 STD BSD { int lfs_bmapv(struct fsid **fsidp, \ - struct block_info *blkiov, int blkcnt); } -185 STD BSD { int lfs_markv(struct fsid **fsidp, \ - struct block_info *blkiov, int blkcnt); } -186 STD BSD { int lfs_segclean(struct fsid **fsidp, \ - u_long segment); } -187 STD BSD { int lfs_segwait(struct fsid **fsidp, \ - struct timeval *tv); } -#else -184 UNIMPL BSD nosys -185 UNIMPL BSD nosys -186 UNIMPL BSD nosys -187 UNIMPL BSD nosys -#endif +184 UNIMPL BSD lfs_bmapv +185 UNIMPL BSD lfs_markv +186 UNIMPL BSD lfs_segclean +187 UNIMPL BSD lfs_segwait 188 STD POSIX { int stat(char *path, struct stat *ub); } 189 STD POSIX { int fstat(int fd, struct stat *sb); } 190 STD POSIX { int lstat(char *path, struct stat *ub); } diff --git a/sys/sys/syscall-hide.h b/sys/sys/syscall-hide.h index b940734314f8..42fb3a4095bd 100644 --- a/sys/sys/syscall-hide.h +++ b/sys/sys/syscall-hide.h @@ -2,7 +2,7 @@ * System call hiders. * * DO NOT EDIT-- this file is automatically generated. - * created from Id: syscalls.master,v 1.44 1997/10/26 20:27:51 phk Exp + * created from Id: syscalls.master,v 1.46 1998/01/24 02:54:35 eivind Exp */ HIDE_POSIX(fork) @@ -162,17 +162,10 @@ HIDE_BSD(ntp_adjtime) HIDE_POSIX(setgid) HIDE_BSD(setegid) HIDE_BSD(seteuid) -#ifdef LFS HIDE_BSD(lfs_bmapv) HIDE_BSD(lfs_markv) HIDE_BSD(lfs_segclean) HIDE_BSD(lfs_segwait) -#else -HIDE_BSD(nosys) -HIDE_BSD(nosys) -HIDE_BSD(nosys) -HIDE_BSD(nosys) -#endif HIDE_POSIX(stat) HIDE_POSIX(fstat) HIDE_POSIX(lstat) diff --git a/sys/sys/syscall.h b/sys/sys/syscall.h index 8ddfe85d29af..b01e8910af06 100644 --- a/sys/sys/syscall.h +++ b/sys/sys/syscall.h @@ -2,7 +2,7 @@ * System call numbers. * * DO NOT EDIT-- this file is automatically generated. - * created from Id: syscalls.master,v 1.44 1997/10/26 20:27:51 phk Exp + * created from Id: syscalls.master,v 1.46 1998/01/24 02:54:35 eivind Exp */ #define SYS_syscall 0 @@ -170,10 +170,6 @@ #define SYS_setgid 181 #define SYS_setegid 182 #define SYS_seteuid 183 -#define SYS_lfs_bmapv 184 -#define SYS_lfs_markv 185 -#define SYS_lfs_segclean 186 -#define SYS_lfs_segwait 187 #define SYS_stat 188 #define SYS_fstat 189 #define SYS_lstat 190 diff --git a/sys/sys/sysproto.h b/sys/sys/sysproto.h index 7f89cb8d157e..1429083c331e 100644 --- a/sys/sys/sysproto.h +++ b/sys/sys/sysproto.h @@ -2,7 +2,7 @@ * System call prototypes. * * DO NOT EDIT-- this file is automatically generated. - * created from Id: syscalls.master,v 1.44 1997/10/26 20:27:51 phk Exp + * created from Id: syscalls.master,v 1.46 1998/01/24 02:54:35 eivind Exp */ #ifndef _SYS_SYSPROTO_H_ @@ -246,7 +246,7 @@ struct getpagesize_args { int dummy; }; struct msync_args { - caddr_t addr; + void * addr; size_t len; int flags; }; @@ -263,16 +263,16 @@ struct ovadvise_args { int anom; }; struct munmap_args { - caddr_t addr; + void * addr; size_t len; }; struct mprotect_args { - caddr_t addr; + const void * addr; size_t len; int prot; }; struct madvise_args { - caddr_t addr; + void * addr; size_t len; int behav; }; @@ -549,27 +549,6 @@ struct setegid_args { struct seteuid_args { uid_t euid; }; -#ifdef LFS -struct lfs_bmapv_args { - struct fsid ** fsidp; - struct block_info * blkiov; - int blkcnt; -}; -struct lfs_markv_args { - struct fsid ** fsidp; - struct block_info * blkiov; - int blkcnt; -}; -struct lfs_segclean_args { - struct fsid ** fsidp; - u_long segment; -}; -struct lfs_segwait_args { - struct fsid ** fsidp; - struct timeval * tv; -}; -#else -#endif struct stat_args { char * path; struct stat * ub; @@ -638,11 +617,11 @@ struct sysctl_args { size_t newlen; }; struct mlock_args { - caddr_t addr; + const void * addr; size_t len; }; struct munlock_args { - caddr_t addr; + const void * addr; size_t len; }; struct utrace_args { @@ -736,7 +715,7 @@ struct nanosleep_args { struct timespec * rmtp; }; struct minherit_args { - caddr_t addr; + void * addr; size_t len; int inherit; }; @@ -967,13 +946,6 @@ int ntp_adjtime __P((struct proc *, struct ntp_adjtime_args *)); int setgid __P((struct proc *, struct setgid_args *)); int setegid __P((struct proc *, struct setegid_args *)); int seteuid __P((struct proc *, struct seteuid_args *)); -#ifdef LFS -int lfs_bmapv __P((struct proc *, struct lfs_bmapv_args *)); -int lfs_markv __P((struct proc *, struct lfs_markv_args *)); -int lfs_segclean __P((struct proc *, struct lfs_segclean_args *)); -int lfs_segwait __P((struct proc *, struct lfs_segwait_args *)); -#else -#endif int stat __P((struct proc *, struct stat_args *)); int fstat __P((struct proc *, struct fstat_args *)); int lstat __P((struct proc *, struct lstat_args *)); @@ -1071,7 +1043,7 @@ struct getkerninfo_args { int arg; }; struct ommap_args { - caddr_t addr; + void * addr; int len; int prot; int flags; @@ -1157,9 +1129,6 @@ struct ogetdirentries_args { u_int count; long * basep; }; -#ifdef LFS -#else -#endif int ocreat __P((struct proc *, struct ocreat_args *)); int olseek __P((struct proc *, struct olseek_args *)); int ostat __P((struct proc *, struct ostat_args *)); diff --git a/sys/ufs/lfs/README b/sys/ufs/lfs/README deleted file mode 100644 index 724b18fb9ea5..000000000000 --- a/sys/ufs/lfs/README +++ /dev/null @@ -1,139 +0,0 @@ -# @(#)README 8.1 (Berkeley) 6/11/93 - -The file system is reasonably stable, but incomplete. There are -places where cleaning performance can be improved dramatically (see -comments in lfs_syscalls.c). For details on the implementation, -performance and why garbage collection always wins, see Dr. Margo -Seltzer's thesis available for anonymous ftp from toe.cs.berkeley.edu, -in the directory pub/personal/margo/thesis.ps.Z, or the January 1993 -USENIX paper. - -Missing Functionality: - Multiple block sizes and/or fragments are not yet implemented. - ----------- -The disk is laid out in segments. The first segment starts 8K into the -disk (the first 8K is used for boot information). Each segment is composed -of the following: - - An optional super block - One or more groups of: - segment summary - 0 or more data blocks - 0 or more inode blocks - -The segment summary and inode/data blocks start after the super block (if -present), and grow toward the end of the segment. - - _______________________________________________ - | | | | | - | summary | data/inode | summary | data/inode | - | block | blocks | block | blocks | ... - |_________|____________|_________|____________| - -The data/inode blocks following a summary block are described by the -summary block. In order to permit the segment to be written in any order -and in a forward direction only, a checksum is calculated across the -blocks described by the summary. Additionally, the summary is checksummed -and timestamped. Both of these are intended for recovery; the former is -to make it easy to determine that it *is* a summary block and the latter -is to make it easy to determine when recovery is finished for partially -written segments. These checksums are also used by the cleaner. - - Summary block (detail) - ________________ - | sum cksum | - | data cksum | - | next segment | - | timestamp | - | FINFO count | - | inode count | - | flags | - |______________| - | FINFO-1 | 0 or more file info structures, identifying the - | . | blocks in the segment. - | . | - | . | - | FINFO-N | - | inode-N | - | . | - | . | - | . | 0 or more inode daddr_t's, identifying the inode - | inode-1 | blocks in the segment. - |______________| - -Inode blocks are blocks of on-disk inodes in the same format as those in -the FFS. However, spare[0] contains the inode number of the inode so we -can find a particular inode on a page. They are packed page_size / -sizeof(inode) to a block. Data blocks are exactly as in the FFS. Both -inodes and data blocks move around the file system at will. - -The file system is described by a super-block which is replicated and -occurs as the first block of the first and other segments. (The maximum -number of super-blocks is MAXNUMSB). Each super-block maintains a list -of the disk addresses of all the super-blocks. The super-block maintains -a small amount of checkpoint information, essentially just enough to find -the inode for the IFILE (fs->lfs_idaddr). - -The IFILE is visible in the file system, as inode number IFILE_INUM. It -contains information shared between the kernel and various user processes. - - Ifile (detail) - ________________ - | cleaner info | Cleaner information per file system. (Page - | | granularity.) - |______________| - | segment | Space available and last modified times per - | usage table | segment. (Page granularity.) - |______________| - | IFILE-1 | Per inode status information: current version #, - | . | if currently allocated, last access time and - | . | current disk address of containing inode block. - | . | If current disk address is LFS_UNUSED_DADDR, the - | IFILE-N | inode is not in use, and it's on the free list. - |______________| - - -First Segment at Creation Time: -_____________________________________________________________ -| | | | | | | | -| 8K pad | Super | summary | inode | ifile | root | l + f | -| | block | | block | | dir | dir | -|________|_______|_________|_______|_______|_______|_______| - ^ - Segment starts here. - -Some differences from the Sprite LFS implementation. - -1. The LFS implementation placed the ifile metadata and the super block - at fixed locations. This implementation replicates the super block - and puts each at a fixed location. The checkpoint data is divided into - two parts -- just enough information to find the IFILE is stored in - two of the super blocks, although it is not toggled between them as in - the Sprite implementation. (This was deliberate, to avoid a single - point of failure.) The remaining checkpoint information is treated as - a regular file, which means that the cleaner info, the segment usage - table and the ifile meta-data are stored in normal log segments. - (Tastes great, less filling...) - -2. The segment layout is radically different in Sprite; this implementation - uses something a lot like network framing, where data/inode blocks are - written asynchronously, and a checksum is used to validate any set of - summary and data/inode blocks. Sprite writes summary blocks synchronously - after the data/inode blocks have been written and the existence of the - summary block validates the data/inode blocks. This permits us to write - everything contiguously, even partial segments and their summaries, whereas - Sprite is forced to seek (from the end of the data inode to the summary - which lives at the end of the segment). Additionally, writing the summary - synchronously should cost about 1/2 a rotation per summary. - -3. Sprite LFS distinguishes between different types of blocks in the segment. - Other than inode blocks and data blocks, we don't. - -4. Sprite LFS traverses the IFILE looking for free blocks. We maintain a - free list threaded through the IFILE entries. - -5. The cleaner runs in user space, as opposed to kernel space. It shares - information with the kernel by reading/writing the IFILE and through - cleaner specific system calls. - diff --git a/sys/ufs/lfs/TODO b/sys/ufs/lfs/TODO deleted file mode 100644 index ace8f5eaef6c..000000000000 --- a/sys/ufs/lfs/TODO +++ /dev/null @@ -1,116 +0,0 @@ -# @(#)TODO 8.1 (Berkeley) 6/11/93 - -NOTE: Changed the lookup on a page of inodes to search from the back -in case the same inode gets written twice on the same page. - -Make sure that if you are writing a file, but not all the blocks -make it into a single segment, that you do not write the inode in -that segment. - -Keith: - Why not delete the lfs_bmapv call, just mark everything dirty - that isn't deleted/truncated? Get some numbers about - what percentage of the stuff that the cleaner thinks - might be live is live. If it's high, get rid of lfs_bmapv. - - There is a nasty problem in that it may take *more* room to write - the data to clean a segment than is returned by the new segment - because of indirect blocks in segment 2 being dirtied by the data - being copied into the log from segment 1. The suggested solution - at this point is to detect it when we have no space left on the - filesystem, write the extra data into the last segment (leaving - no clean ones), make it a checkpoint and shut down the file system - for fixing by a utility reading the raw partition. Argument is - that this should never happen and is practically impossible to fix - since the cleaner would have to theoretically build a model of the - entire filesystem in memory to detect the condition occurring. - A file coalescing cleaner will help avoid the problem, and one - that reads/writes from the raw disk could fix it. - -DONE Currently, inodes are being flushed to disk synchronously upon - creation -- see ufs_makeinode. However, only the inode - is flushed, the directory "name" is written using VOP_BWRITE, - so it's not synchronous. Possible solutions: 1: get some - ordering in the writes so that inode/directory entries get - stuffed into the same segment. 2: do both synchronously - 3: add Mendel's information into the stream so we log - creation/deletion of inodes. 4: do some form of partial - segment when changing the inode (creation/deletion/rename). -DONE Fix i_block increment for indirect blocks. - If the file system is tar'd, extracted on top of another LFS, the - IFILE ain't worth diddly. Is the cleaner writing the IFILE? - If not, let's make it read-only. -DONE Delete unnecessary source from utils in main-line source tree. -DONE Make sure that we're counting meta blocks in the inode i_block count. - Overlap the version and nextfree fields in the IFILE -DONE Vinvalbuf (Kirk): - Why writing blocks that are no longer useful? - Are the semantics of close such that blocks have to be flushed? - How specify in the buf chain the blocks that don't need - to be written? (Different numbering of indirect blocks.) - -Margo: - Change so that only search one sector of inode block file for the - inode by using sector addresses in the ifile instead of - logical disk addresses. - Fix the use of the ifile version field to use the generation - number instead. -DONE Unmount; not doing a bgetvp (VHOLD) in lfs_newbuf call. -DONE Document in the README file where the checkpoint information is - on disk. - Variable block sizes (Margo/Keith). - Switch the byte accounting to sector accounting. -DONE Check lfs.h and make sure that the #defines/structures are all - actually needed. -DONE Add a check in lfs_segment.c so that if the segment is empty, - we don't write it. - Need to keep vnode v_numoutput up to date for pending writes? -DONE USENIX paper (Carl/Margo). - - -Evelyn: - lfsck: If delete a file that's being executed, the version number - isn't updated, and lfsck has to figure this out; case is the same as if have an inode that no directory references, - so the file should be reattached into lost+found. - Recovery/fsck. - -Carl: - Investigate: clustering of reads (if blocks in the segment are ordered, - should read them all) and writes (McVoy paper). - Investigate: should the access time be part of the IFILE: - pro: theoretically, saves disk writes - con: cacheing inodes should obviate this advantage - the IFILE is already humongous - Cleaner. - Port to OSF/1 (Carl/Keith). - Currently there's no notion of write error checking. - + Failed data/inode writes should be rescheduled (kernel level - bad blocking). - + Failed superblock writes should cause selection of new - superblock for checkpointing. - -FUTURE FANTASIES: ============ - -+ unrm, versioning -+ transactions -+ extended cleaner policies (hot/cold data, data placement) - -============================== -Problem with the concept of multiple buffer headers referencing the segment: -Positives: - Don't lock down 1 segment per file system of physical memory. - Don't copy from buffers to segment memory. - Don't tie down the bus to transfer 1M. - Works on controllers supporting less than large transfers. - Disk can start writing immediately instead of waiting 1/2 rotation - and the full transfer. -Negatives: - Have to do segment write then segment summary write, since the latter - is what verifies that the segment is okay. (Is there another way - to do this?) -============================== - -The algorithm for selecting the disk addresses of the super-blocks -has to be available to the user program which checks the file system. - -(Currently in newfs, becomes a common subroutine.) diff --git a/sys/ufs/lfs/lfs.h b/sys/ufs/lfs/lfs.h deleted file mode 100644 index fa0fed74a702..000000000000 --- a/sys/ufs/lfs/lfs.h +++ /dev/null @@ -1,397 +0,0 @@ -/*- - * Copyright (c) 1991, 1993 - * The Regents of the University of California. 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. - * 3. All advertising materials mentioning features or use of this software - * must display the following acknowledgement: - * This product includes software developed by the University of - * California, Berkeley and its contributors. - * 4. Neither the name of the University nor the names of its contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``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 THE REGENTS OR CONTRIBUTORS 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. - * - * @(#)lfs.h 8.9 (Berkeley) 5/8/95 - * $Id: lfs.h,v 1.9 1997/02/22 09:47:15 peter Exp $ - */ - -#ifndef _UFS_LFS_LFS_H_ -#define _UFS_LFS_LFS_H_ - -#define LFS_LABELPAD 8192 /* LFS label size */ -#define LFS_SBPAD 8192 /* LFS superblock size */ - -/* - * XXX - * This is a kluge and NEEDS to go away. - * - * Right now, ufs code handles most of the calls for directory operations - * such as create, mkdir, link, etc. As a result VOP_UPDATE is being - * called with waitfor set (since ffs does these things synchronously). - * Since LFS does not want to do these synchronously, we treat the last - * argument to lfs_update as a set of flags. If LFS_SYNC is set, then - * the update should be synchronous, if not, do it asynchronously. - * Unfortunately, this means that LFS won't work with NFS yet because - * NFS goes through paths that will make normal calls to ufs which will - * call lfs with a last argument of 1. - */ -#define LFS_SYNC 0x02 - -/* On-disk and in-memory checkpoint segment usage structure. */ -typedef struct segusage SEGUSE; -struct segusage { - u_int32_t su_nbytes; /* number of live bytes */ - u_int32_t su_lastmod; /* SEGUSE last modified timestamp */ - u_int16_t su_nsums; /* number of summaries in segment */ - u_int16_t su_ninos; /* number of inode blocks in seg */ - -#define SEGUSE_ACTIVE 0x01 /* segment is currently being written */ -#define SEGUSE_DIRTY 0x02 /* segment has data in it */ -#define SEGUSE_SUPERBLOCK 0x04 /* segment contains a superblock */ - u_int32_t su_flags; -}; - -#define SEGUPB(fs) (1 << (fs)->lfs_sushift) -#define SEGTABSIZE_SU(fs) \ - (((fs)->lfs_nseg + SEGUPB(fs) - 1) >> (fs)->lfs_sushift) - -/* On-disk file information. One per file with data blocks in the segment. */ -typedef struct finfo FINFO; -struct finfo { - u_int32_t fi_nblocks; /* number of blocks */ - u_int32_t fi_version; /* version number */ - u_int32_t fi_ino; /* inode number */ - u_int32_t fi_lastlength; /* length of last block in array */ - ufs_daddr_t fi_blocks[1]; /* array of logical block numbers */ -}; - -/* On-disk and in-memory super block. */ -struct lfs { -#define LFS_MAGIC 0x070162 - u_int32_t lfs_magic; /* magic number */ -#define LFS_VERSION 1 - u_int32_t lfs_version; /* version number */ - - u_int32_t lfs_size; /* number of blocks in fs */ - u_int32_t lfs_ssize; /* number of blocks per segment */ - u_int32_t lfs_dsize; /* number of disk blocks in fs */ - u_int32_t lfs_bsize; /* file system block size */ - u_int32_t lfs_fsize; /* size of frag blocks in fs */ - u_int32_t lfs_frag; /* number of frags in a block in fs */ - -/* Checkpoint region. */ - ino_t lfs_free; /* start of the free list */ - u_int32_t lfs_bfree; /* number of free disk blocks */ - u_int32_t lfs_nfiles; /* number of allocated inodes */ - int32_t lfs_avail; /* blocks available for writing */ - u_int32_t lfs_uinodes; /* inodes in cache not yet on disk */ - ufs_daddr_t lfs_idaddr; /* inode file disk address */ - ino_t lfs_ifile; /* inode file inode number */ - ufs_daddr_t lfs_lastseg; /* address of last segment written */ - ufs_daddr_t lfs_nextseg; /* address of next segment to write */ - ufs_daddr_t lfs_curseg; /* current segment being written */ - ufs_daddr_t lfs_offset; /* offset in curseg for next partial */ - ufs_daddr_t lfs_lastpseg; /* address of last partial written */ - u_int32_t lfs_tstamp; /* time stamp */ - -/* These are configuration parameters. */ - u_int32_t lfs_minfree; /* minimum percentage of free blocks */ - -/* These fields can be computed from the others. */ - u_int64_t lfs_maxfilesize; /* maximum representable file size */ - u_int32_t lfs_dbpseg; /* disk blocks per segment */ - u_int32_t lfs_inopb; /* inodes per block */ - u_int32_t lfs_ifpb; /* IFILE entries per block */ - u_int32_t lfs_sepb; /* SEGUSE entries per block */ - u_int32_t lfs_nindir; /* indirect pointers per block */ - u_int32_t lfs_nseg; /* number of segments */ - u_int32_t lfs_nspf; /* number of sectors per fragment */ - u_int32_t lfs_cleansz; /* cleaner info size in blocks */ - u_int32_t lfs_segtabsz; /* segment table size in blocks */ - - u_int32_t lfs_segmask; /* calculate offset within a segment */ - u_int32_t lfs_segshift; /* fast mult/div for segments */ - u_int64_t lfs_bmask; /* calc block offset from file offset */ - u_int32_t lfs_bshift; /* calc block number from file offset */ - u_int64_t lfs_ffmask; /* calc frag offset from file offset */ - u_int32_t lfs_ffshift; /* fast mult/div for frag from file */ - u_int64_t lfs_fbmask; /* calc frag offset from block offset */ - u_int32_t lfs_fbshift; /* fast mult/div for frag from block */ - u_int32_t lfs_fsbtodb; /* fsbtodb and dbtofsb shift constant */ - u_int32_t lfs_sushift; /* fast mult/div for segusage table */ - - int32_t lfs_maxsymlinklen; /* max length of an internal symlink */ - -#define LFS_MIN_SBINTERVAL 5 /* minimum superblock segment spacing */ -#define LFS_MAXNUMSB 10 /* superblock disk offsets */ - ufs_daddr_t lfs_sboffs[LFS_MAXNUMSB]; - -/* Checksum -- last valid disk field. */ - u_int32_t lfs_cksum; /* checksum for superblock checking */ - -/* These fields are set at mount time and are meaningless on disk. */ - struct segment *lfs_sp; /* current segment being written */ - struct vnode *lfs_ivnode; /* vnode for the ifile */ - u_long lfs_seglock; /* single-thread the segment writer */ - pid_t lfs_lockpid; /* pid of lock holder */ - u_long lfs_iocount; /* number of ios pending */ - u_long lfs_writer; /* don't allow any dirops to start */ - u_long lfs_dirops; /* count of active directory ops */ - u_long lfs_doifile; /* Write ifile blocks on next write */ - u_long lfs_nactive; /* Number of segments since last ckp */ - int8_t lfs_fmod; /* super block modified flag */ - int8_t lfs_clean; /* file system is clean flag */ - int8_t lfs_ronly; /* mounted read-only flag */ - int8_t lfs_flags; /* currently unused flag */ - u_char lfs_fsmnt[MNAMELEN]; /* name mounted on */ - - int32_t lfs_pad[40]; /* round to 512 bytes */ -}; - -/* - * Inode 0: out-of-band inode number - * Inode 1: IFILE inode number - * Inode 2: root inode - * Inode 3: lost+found inode number - */ -#define LFS_UNUSED_INUM 0 /* out of band inode number */ -#define LFS_IFILE_INUM 1 /* IFILE inode number */ -#define LOSTFOUNDINO 3 /* lost+found inode number */ -#define LFS_FIRST_INUM 4 /* first free inode number */ - -/* Address calculations for metadata located in the inode */ -#define S_INDIR(fs) -NDADDR -#define D_INDIR(fs) (S_INDIR(fs) - NINDIR(fs) - 1) -#define T_INDIR(fs) (D_INDIR(fs) - NINDIR(fs) * NINDIR(fs) - 1) - -/* Unassigned disk address. */ -#define UNASSIGNED -1 - -/* Unused logical block number */ -#define LFS_UNUSED_LBN -1 - -typedef struct ifile IFILE; -struct ifile { - u_int32_t if_version; /* inode version number */ -#define LFS_UNUSED_DADDR 0 /* out-of-band daddr */ - ufs_daddr_t if_daddr; /* inode disk address */ - ino_t if_nextfree; /* next-unallocated inode */ -}; - -/* - * Cleaner information structure. This resides in the ifile and is used - * to pass information between the cleaner and the kernel. - */ -typedef struct _cleanerinfo { - u_int32_t clean; /* K: number of clean segments */ - u_int32_t dirty; /* K: number of dirty segments */ -} CLEANERINFO; - -#define CLEANSIZE_SU(fs) \ - ((sizeof(CLEANERINFO) + (fs)->lfs_bsize - 1) >> (fs)->lfs_bshift) - -/* - * All summary blocks are the same size, so we can always read a summary - * block easily from a segment. - */ -#define LFS_SUMMARY_SIZE 512 - -/* On-disk segment summary information */ -typedef struct segsum SEGSUM; -struct segsum { - u_int32_t ss_sumsum; /* check sum of summary block */ - u_int32_t ss_datasum; /* check sum of data */ - u_int32_t ss_magic; /* segment summary magic number */ -#define SS_MAGIC 0x061561 - ufs_daddr_t ss_next; /* next segment */ - u_int32_t ss_create; /* creation time stamp */ - u_int16_t ss_nfinfo; /* number of file info structures */ - u_int16_t ss_ninos; /* number of inodes in summary */ - -#define SS_DIROP 0x01 /* segment begins a dirop */ -#define SS_CONT 0x02 /* more partials to finish this write*/ - u_int16_t ss_flags; /* used for directory operations */ - u_int16_t ss_pad; /* extra space */ - /* FINFO's and inode daddr's... */ -}; - -/* NINDIR is the number of indirects in a file system block. */ -#define NINDIR(fs) ((fs)->lfs_nindir) - -/* INOPB is the number of inodes in a secondary storage block. */ -#define INOPB(fs) ((fs)->lfs_inopb) - -#define blksize(fs, ip, lbn) \ - (((lbn) >= NDADDR || (ip)->i_size >= ((lbn) + 1) << (fs)->lfs_bshift) \ - ? (fs)->lfs_bsize \ - : (fragroundup(fs, blkoff(fs, (ip)->i_size)))) -#define blkoff(fs, loc) ((int)((loc) & (fs)->lfs_bmask)) -#define fragoff(fs, loc) /* calculates (loc % fs->lfs_fsize) */ \ - ((int)((loc) & (fs)->lfs_ffmask)) -#define fsbtodb(fs, b) ((b) << (fs)->lfs_fsbtodb) -#define dbtofsb(fs, b) ((b) >> (fs)->lfs_fsbtodb) -#define fragstodb(fs, b) ((b) << (fs)->lfs_fsbtodb - (fs)->lfs_fbshift) -#define dbtofrags(fs, b) ((b) >> (fs)->lfs_fsbtodb - (fs)->lfs_fbshift) -#define lblkno(fs, loc) ((loc) >> (fs)->lfs_bshift) -#define lblktosize(fs, blk) ((blk) << (fs)->lfs_bshift) -#define numfrags(fs, loc) /* calculates (loc / fs->lfs_fsize) */ \ - ((loc) >> (fs)->lfs_ffshift) -#define blkroundup(fs, size) /* calculates roundup(size, fs->lfs_bsize) */ \ - ((int)(((size) + (fs)->lfs_bmask) & (~(fs)->lfs_bmask))) -#define fragroundup(fs, size) /* calculates roundup(size, fs->lfs_fsize) */ \ - ((int)(((size) + (fs)->lfs_ffmask) & (~(fs)->lfs_ffmask))) -#define fragstoblks(fs, frags) /* calculates (frags / fs->lfs_frag) */ \ - ((frags) >> (fs)->lfs_fbshift) -#define blkstofrags(fs, blks) /* calculates (blks * fs->lfs_frag) */ \ - ((blks) << (fs)->lfs_fbshift) -#define fragnum(fs, fsb) /* calculates (fsb % fs->lfs_frag) */ \ - ((fsb) & ((fs)->lfs_frag - 1)) -#define blknum(fs, fsb) /* calculates rounddown(fsb, fs->lfs_frag) */ \ - ((fsb) &~ ((fs)->lfs_frag - 1)) -#define dblksize(fs, dip, lbn) \ - (((lbn) >= NDADDR || (dip)->di_size >= ((lbn) + 1) << (fs)->lfs_bshift)\ - ? (fs)->lfs_bsize \ - : (fragroundup(fs, blkoff(fs, (dip)->di_size)))) -#define datosn(fs, daddr) /* disk address to segment number */ \ - (((daddr) - (fs)->lfs_sboffs[0]) / fsbtodb((fs), (fs)->lfs_ssize)) -#define sntoda(fs, sn) /* segment number to disk address */ \ - ((ufs_daddr_t)((sn) * ((fs)->lfs_ssize << (fs)->lfs_fsbtodb) + \ - (fs)->lfs_sboffs[0])) - -/* Read in the block with the cleaner info from the ifile. */ -#define LFS_CLEANERINFO(CP, F, BP) { \ - VTOI((F)->lfs_ivnode)->i_flag |= IN_ACCESS; \ - if (bread((F)->lfs_ivnode, \ - (ufs_daddr_t)0, (F)->lfs_bsize, NOCRED, &(BP))) \ - panic("lfs: ifile read"); \ - (CP) = (CLEANERINFO *)(BP)->b_data; \ -} - -/* Read in the block with a specific inode from the ifile. */ -#define LFS_IENTRY(IP, F, IN, BP) { \ - int _e; \ - VTOI((F)->lfs_ivnode)->i_flag |= IN_ACCESS; \ - if (_e = bread((F)->lfs_ivnode, \ - (IN) / (F)->lfs_ifpb + (F)->lfs_cleansz + (F)->lfs_segtabsz,\ - (F)->lfs_bsize, NOCRED, &(BP))) \ - panic("lfs: ifile read %d", _e); \ - (IP) = (IFILE *)(BP)->b_data + (IN) % (F)->lfs_ifpb; \ -} - -/* Read in the block with a specific segment usage entry from the ifile. */ -#define LFS_SEGENTRY(SP, F, IN, BP) { \ - int _e; \ - VTOI((F)->lfs_ivnode)->i_flag |= IN_ACCESS; \ - _e = bread((F)->lfs_ivnode, \ - ((IN) >> (F)->lfs_sushift) + (F)->lfs_cleansz, \ - (F)->lfs_bsize, NOCRED, &(BP)); \ - if (_e) \ - panic("lfs: ifile read: %d", _e); \ - (SP) = (SEGUSE *)(BP)->b_data + ((IN) & (F)->lfs_sepb - 1); \ -} -#ifdef CC_WALL -/* The above ^^^^^^^^^^^^^^^^^^^^^^^^^^^ - * looks like a potential bug to me. - */ -#endif - -/* - * Determine if there is enough room currently available to write db - * disk blocks. We need enough blocks for the new blocks, the current, - * inode blocks, a summary block, plus potentially the ifile inode and - * the segment usage table, plus an ifile page. - */ -#define LFS_FITS(fs, db) \ - ((int32_t)((db + ((fs)->lfs_uinodes + INOPB((fs))) / \ - INOPB((fs)) + fsbtodb(fs, 1) + LFS_SUMMARY_SIZE / DEV_BSIZE + \ - (fs)->lfs_segtabsz)) < (fs)->lfs_avail) - -/* Determine if a buffer belongs to the ifile */ -#define IS_IFILE(bp) (VTOI(bp->b_vp)->i_number == LFS_IFILE_INUM) - -/* - * Structures used by lfs_bmapv and lfs_markv to communicate information - * about inodes and data blocks. - */ -typedef struct block_info { - ino_t bi_inode; /* inode # */ - ufs_daddr_t bi_lbn; /* logical block w/in file */ - ufs_daddr_t bi_daddr; /* disk address of block */ - time_t bi_segcreate; /* origin segment create time */ - int bi_version; /* file version number */ - void *bi_bp; /* data buffer */ - int bi_size; /* size of the block (if fragment) */ -} BLOCK_INFO; - -/* In-memory description of a segment about to be written. */ -struct segment { - struct lfs *fs; /* file system pointer */ - struct buf **bpp; /* pointer to buffer array */ - struct buf **cbpp; /* pointer to next available bp */ - struct buf **start_bpp; /* pointer to first bp in this set */ - struct buf *ibp; /* buffer pointer to inode page */ - struct finfo *fip; /* current fileinfo pointer */ - struct vnode *vp; /* vnode being gathered */ - void *segsum; /* segment summary info */ - u_int32_t ninodes; /* number of inodes in this segment */ - u_int32_t seg_bytes_left; /* bytes left in segment */ - u_int32_t sum_bytes_left; /* bytes left in summary block */ - u_int32_t seg_number; /* number of this segment */ - ufs_daddr_t *start_lbp; /* beginning lbn for this set */ - -#define SEGM_CKP 0x01 /* doing a checkpoint */ -#define SEGM_CLEAN 0x02 /* cleaner call; don't sort */ -#define SEGM_SYNC 0x04 /* wait for segment */ - u_int16_t seg_flags; /* run-time flags for this segment */ -}; - -#define ISSPACE(F, BB, C) \ - (((C)->cr_uid == 0 && (F)->lfs_bfree >= (BB)) || \ - ((C)->cr_uid != 0 && IS_FREESPACE(F, BB))) - -#define IS_FREESPACE(F, BB) \ - ((F)->lfs_bfree > ((F)->lfs_dsize * (F)->lfs_minfree / 100 + (BB))) - -#define ISSPACE_XXX(F, BB) \ - ((F)->lfs_bfree >= (BB)) - -#define DOSTATS -#ifdef DOSTATS -/* Statistics Counters */ -struct lfs_stats { - u_int segsused; - u_int psegwrites; - u_int psyncwrites; - u_int pcleanwrites; - u_int blocktot; - u_int cleanblocks; - u_int ncheckpoints; - u_int nwrites; - u_int nsync_writes; - u_int wait_exceeded; - u_int write_exceeded; - u_int flush_invoked; -}; -extern struct lfs_stats lfs_stats; -#endif - -#endif diff --git a/sys/ufs/lfs/lfs_alloc.c b/sys/ufs/lfs/lfs_alloc.c deleted file mode 100644 index 269bb75556e1..000000000000 --- a/sys/ufs/lfs/lfs_alloc.c +++ /dev/null @@ -1,252 +0,0 @@ -/* - * Copyright (c) 1991, 1993, 1995 - * The Regents of the University of California. 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. - * 3. All advertising materials mentioning features or use of this software - * must display the following acknowledgement: - * This product includes software developed by the University of - * California, Berkeley and its contributors. - * 4. Neither the name of the University nor the names of its contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``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 THE REGENTS OR CONTRIBUTORS 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. - * - * @(#)lfs_alloc.c 8.7 (Berkeley) 5/14/95 - * $Id: lfs_alloc.c,v 1.19 1997/10/16 11:58:30 phk Exp $ - */ - -#include "opt_quota.h" - -#include <sys/param.h> -#include <sys/systm.h> -#include <sys/kernel.h> -#include <sys/buf.h> -#include <sys/vnode.h> -#include <sys/mount.h> -#include <sys/malloc.h> - -#include <vm/vm.h> -#include <vm/vm_extern.h> - -#include <ufs/ufs/quota.h> -#include <ufs/ufs/inode.h> -#include <ufs/ufs/ufsmount.h> -#include <ufs/ufs/ufs_extern.h> - -#include <ufs/lfs/lfs.h> -#include <ufs/lfs/lfs_extern.h> - -/* Allocate a new inode. */ -/* ARGSUSED */ -int -lfs_valloc(pvp, mode, cred, vpp) - struct vnode *pvp; - int mode; - struct ucred *cred; - struct vnode **vpp; -{ - struct lfs *fs; - struct buf *bp; - struct ifile *ifp; - struct inode *ip; - struct vnode *vp; - ufs_daddr_t blkno; - ino_t new_ino; - u_long i, max; - int error; - - /* Get the head of the freelist. */ - fs = VTOI(pvp)->i_lfs; - new_ino = fs->lfs_free; -#ifdef ALLOCPRINT - printf("lfs_ialloc: allocate inode %d\n", new_ino); -#endif - - /* - * Remove the inode from the free list and write the new start - * of the free list into the superblock. - */ - LFS_IENTRY(ifp, fs, new_ino, bp); - if (ifp->if_daddr != LFS_UNUSED_DADDR) - panic("lfs_ialloc: inuse inode on the free list"); - fs->lfs_free = ifp->if_nextfree; - brelse(bp); - - /* Extend IFILE so that the next lfs_valloc will succeed. */ - if (fs->lfs_free == LFS_UNUSED_INUM) { - vp = fs->lfs_ivnode; - ip = VTOI(vp); - blkno = lblkno(fs, ip->i_size); - lfs_balloc(vp, 0, fs->lfs_bsize, blkno, &bp); - ip->i_size += fs->lfs_bsize; - vnode_pager_setsize(vp, (u_long)ip->i_size); - - i = (blkno - fs->lfs_segtabsz - fs->lfs_cleansz) * - fs->lfs_ifpb; - fs->lfs_free = i; - max = i + fs->lfs_ifpb; - for (ifp = (struct ifile *)bp->b_data; i < max; ++ifp) { - ifp->if_version = 1; - ifp->if_daddr = LFS_UNUSED_DADDR; - ifp->if_nextfree = ++i; - } - ifp--; - ifp->if_nextfree = LFS_UNUSED_INUM; - if (error = VOP_BWRITE(bp)) - return (error); - } - - /* Create a vnode to associate with the inode. */ - if (error = lfs_vcreate(pvp->v_mount, new_ino, &vp)) - return (error); - - - ip = VTOI(vp); - /* Zero out the direct and indirect block addresses. */ - bzero(&ip->i_din, sizeof(struct dinode)); - ip->i_din.di_inumber = new_ino; - - /* Set a new generation number for this inode. */ - if (ip->i_gen == 0 || ++ip->i_gen == 0) - ip->i_gen = random() / 2 + 1; - - /* Insert into the inode hash table. */ - ufs_ihashins(ip); - - if (error = ufs_vinit(vp->v_mount, lfs_specop_p, LFS_FIFOOPS, &vp)) { - vput(vp); - *vpp = NULL; - return (error); - } - - *vpp = vp; - vp->v_flag |= VDIROP; - VREF(ip->i_devvp); - - /* Set superblock modified bit and increment file count. */ - fs->lfs_fmod = 1; - ++fs->lfs_nfiles; - return (0); -} - -/* Create a new vnode/inode pair and initialize what fields we can. */ -int -lfs_vcreate(mp, ino, vpp) - struct mount *mp; - ino_t ino; - struct vnode **vpp; -{ - struct inode *ip; - struct ufsmount *ump; - int error, i; - - /* - * Do the MALLOC before the getnewvnode since doing so afterward - * might cause a bogus v_data pointer to get dereferenced - * elsewhere if MALLOC should block. - */ - MALLOC(ip, struct inode *, sizeof(struct inode), M_LFSNODE, M_WAITOK); - - /* Create the vnode. */ - if (error = getnewvnode(VT_LFS, mp, lfs_vnodeop_p, vpp)) { - *vpp = NULL; - FREE(ip, M_LFSNODE); - return (error); - } - - /* Get a pointer to the private mount structure. */ - ump = VFSTOUFS(mp); - - /* Initialize the inode. */ - lockinit(&ip->i_lock, PINOD, "lfsinode", 0, 0); - (*vpp)->v_data = ip; - ip->i_vnode = *vpp; - ip->i_devvp = ump->um_devvp; - ip->i_flag = IN_MODIFIED; - ip->i_dev = ump->um_dev; - ip->i_number = ip->i_din.di_inumber = ino; - ip->i_lfs = ump->um_lfs; -#ifdef QUOTA - for (i = 0; i < MAXQUOTAS; i++) - ip->i_dquot[i] = NODQUOT; -#endif - ip->i_lockf = 0; - ip->i_diroff = 0; - ip->i_mode = 0; - ip->i_size = 0; - ip->i_blocks = 0; - ++ump->um_lfs->lfs_uinodes; - return (0); -} - -/* Free an inode. */ -/* ARGUSED */ -int -lfs_vfree(pvp, ino, mode) - struct vnode *pvp; - ino_t ino; - int mode; -{ - SEGUSE *sup; - struct buf *bp; - struct ifile *ifp; - struct inode *ip; - struct lfs *fs; - ufs_daddr_t old_iaddr; - - /* Get the inode number and file system. */ - ip = VTOI(pvp); - fs = ip->i_lfs; - ino = ip->i_number; - if (ip->i_flag & IN_MODIFIED) { - --fs->lfs_uinodes; - ip->i_flag &= - ~(IN_ACCESS | IN_CHANGE | IN_MODIFIED | IN_UPDATE); - } - /* - * Set the ifile's inode entry to unused, increment its version number - * and link it into the free chain. - */ - LFS_IENTRY(ifp, fs, ino, bp); - old_iaddr = ifp->if_daddr; - ifp->if_daddr = LFS_UNUSED_DADDR; - ++ifp->if_version; - ifp->if_nextfree = fs->lfs_free; - fs->lfs_free = ino; - (void) VOP_BWRITE(bp); - - if (old_iaddr != LFS_UNUSED_DADDR) { - LFS_SEGENTRY(sup, fs, datosn(fs, old_iaddr), bp); -#ifdef DIAGNOSTIC - if (sup->su_nbytes < sizeof(struct dinode)) - panic("lfs_vfree: negative byte count (segment %d)", - datosn(fs, old_iaddr)); -#endif - sup->su_nbytes -= sizeof(struct dinode); - (void) VOP_BWRITE(bp); - } - - /* Set superblock modified bit and decrement file count. */ - fs->lfs_fmod = 1; - --fs->lfs_nfiles; - return (0); -} diff --git a/sys/ufs/lfs/lfs_balloc.c b/sys/ufs/lfs/lfs_balloc.c deleted file mode 100644 index dfa3dcf73de8..000000000000 --- a/sys/ufs/lfs/lfs_balloc.c +++ /dev/null @@ -1,245 +0,0 @@ -/* - * Copyright (c) 1989, 1991, 1993 - * The Regents of the University of California. 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. - * 3. All advertising materials mentioning features or use of this software - * must display the following acknowledgement: - * This product includes software developed by the University of - * California, Berkeley and its contributors. - * 4. Neither the name of the University nor the names of its contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``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 THE REGENTS OR CONTRIBUTORS 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. - * - * @(#)lfs_balloc.c 8.4 (Berkeley) 5/8/95 - * $Id: lfs_balloc.c,v 1.12 1997/05/25 04:57:11 peter Exp $ - */ -#include <sys/param.h> -#include <sys/systm.h> -#include <sys/buf.h> -#include <sys/proc.h> -#include <sys/vnode.h> -#include <sys/mount.h> - -#include <vm/vm.h> -#include <vm/vm_extern.h> - -#include <ufs/ufs/quota.h> -#include <ufs/ufs/inode.h> -#include <ufs/ufs/ufsmount.h> -#include <ufs/ufs/ufs_extern.h> - -#include <ufs/lfs/lfs.h> -#include <ufs/lfs/lfs_extern.h> - -static int lfs_fragextend(struct vnode *vp, int osize, int nsize, daddr_t lbn, - struct buf **bpp); - -int -lfs_balloc(vp, offset, iosize, lbn, bpp) - struct vnode *vp; - int offset; - u_long iosize; - ufs_daddr_t lbn; - struct buf **bpp; -{ - struct buf *ibp, *bp; - struct inode *ip; - struct lfs *fs; - struct indir indirs[NIADDR+2]; - ufs_daddr_t daddr, lastblock; - int bb; /* number of disk blocks in a block disk blocks */ - int error, frags, i, nsize, osize, num; - - ip = VTOI(vp); - fs = ip->i_lfs; - - /* - * Three cases: it's a block beyond the end of file, it's a block in - * the file that may or may not have been assigned a disk address or - * we're writing an entire block. Note, if the daddr is unassigned, - * the block might still have existed in the cache (if it was read - * or written earlier). If it did, make sure we don't count it as a - * new block or zero out its contents. If it did not, make sure - * we allocate any necessary indirect blocks. - * If we are writing a block beyond the end of the file, we need to - * check if the old last block was a fragment. If it was, we need - * to rewrite it. - */ - - *bpp = NULL; - if (error = ufs_bmaparray(vp, lbn, &daddr, &indirs[0], &num, NULL, NULL )) - return (error); - - /* Check for block beyond end of file and fragment extension needed. */ - lastblock = lblkno(fs, ip->i_size); - if (lastblock < NDADDR && lastblock < lbn) { - osize = blksize(fs, ip, lastblock); - if (osize < fs->lfs_bsize && osize > 0) { - if (error = lfs_fragextend(vp, osize, fs->lfs_bsize, - lastblock, &bp)) - return(error); - ip->i_size = (lastblock + 1) * fs->lfs_bsize; - vnode_pager_setsize(vp, (u_long)ip->i_size); - ip->i_flag |= IN_CHANGE | IN_UPDATE; - VOP_BWRITE(bp); - } - } - - bb = VFSTOUFS(vp->v_mount)->um_seqinc; - if (daddr == UNASSIGNED) - /* May need to allocate indirect blocks */ - for (i = 1; i < num; ++i) - if (!indirs[i].in_exists) { - ibp = getblk(vp, indirs[i].in_lbn, fs->lfs_bsize, - 0, 0); - if (!(ibp->b_flags & (B_DONE | B_DELWRI))) { - if (!ISSPACE(fs, bb, curproc->p_ucred)){ - ibp->b_flags |= B_INVAL; - brelse(ibp); - error = ENOSPC; - } else { - ip->i_blocks += bb; - ip->i_lfs->lfs_bfree -= bb; - vfs_bio_clrbuf(ibp); - error = VOP_BWRITE(ibp); - } - } else - panic ("Indirect block should not exist"); - - if (!ISSPACE(fs, bb, curproc->p_ucred)){ - ibp->b_flags |= B_INVAL; - brelse(ibp); - return(ENOSPC); - } else { - ip->i_blocks += bb; - ip->i_lfs->lfs_bfree -= bb; - clrbuf(ibp); - if(error = VOP_BWRITE(ibp)) - return(error); - } - } - - /* - * If the block we are writing is a direct block, it's the last - * block in the file, and offset + iosize is less than a full - * block, we can write one or more fragments. There are two cases: - * the block is brand new and we should allocate it the correct - * size or it already exists and contains some fragments and - * may need to extend it. - */ - if (lbn < NDADDR && lblkno(fs, ip->i_size) == lbn) { - nsize = fragroundup(fs, offset + iosize); - frags = numfrags(fs, nsize); - bb = fragstodb(fs, frags); - if (lblktosize(fs, lbn) == ip->i_size) - /* Brand new block or fragment */ - *bpp = bp = getblk(vp, lbn, nsize, 0, 0); - else { - /* Extend existing block */ - if (error = lfs_fragextend(vp, (int)blksize(fs, ip, lbn), - nsize, lbn, &bp)) - return(error); - *bpp = bp; - } - } else { - /* - * Get the existing block from the cache either because the - * block is 1) not a direct block or because it's not the last - * block in the file. - */ - frags = dbtofrags(fs, bb); - *bpp = bp = getblk(vp, lbn, blksize(fs, ip, lbn), 0, 0); - } - - /* - * The block we are writing may be a brand new block - * in which case we need to do accounting (i.e. check - * for free space and update the inode number of blocks. - */ - if (!(bp->b_flags & (B_CACHE | B_DONE | B_DELWRI))) { - if (daddr == UNASSIGNED) - if (!ISSPACE(fs, bb, curproc->p_ucred)) { - bp->b_flags |= B_INVAL; - brelse(bp); - return(ENOSPC); - } else { - ip->i_blocks += bb; - ip->i_lfs->lfs_bfree -= bb; - if (iosize != fs->lfs_bsize) - vfs_bio_clrbuf(bp); - } - else if (iosize == fs->lfs_bsize) - /* Optimization: I/O is unnecessary. */ - bp->b_blkno = daddr; - else { - /* - * We need to read the block to preserve the - * existing bytes. - */ - bp->b_blkno = daddr; - bp->b_flags |= B_READ; - vfs_busy_pages(bp, 0); - VOP_STRATEGY(bp); - return(biowait(bp)); - } - } - return (0); -} - -static int -lfs_fragextend(vp, osize, nsize, lbn, bpp) - struct vnode *vp; - int osize; - int nsize; - daddr_t lbn; - struct buf **bpp; -{ - struct inode *ip; - struct lfs *fs; - long bb; - int error; - - ip = VTOI(vp); - fs = ip->i_lfs; - bb = (long)fragstodb(fs, numfrags(fs, nsize - osize)); - if (!ISSPACE(fs, bb, curproc->p_ucred)) { - return(ENOSPC); - } - - if (error = bread(vp, lbn, osize, NOCRED, bpp)) { - brelse(*bpp); - return(error); - } -#ifdef QUOTA - if (error = chkdq(ip, bb, curproc->p_ucred, 0)) { - brelse(*bpp); - return (error); - } -#endif - ip->i_blocks += bb; - ip->i_flag |= IN_CHANGE | IN_UPDATE; - fs->lfs_bfree -= fragstodb(fs, numfrags(fs, (nsize - osize))); - allocbuf(*bpp, nsize); - bzero((char *)((*bpp)->b_data) + osize, (u_int)(nsize - osize)); - return(0); -} diff --git a/sys/ufs/lfs/lfs_bio.c b/sys/ufs/lfs/lfs_bio.c deleted file mode 100644 index ad7b39125248..000000000000 --- a/sys/ufs/lfs/lfs_bio.c +++ /dev/null @@ -1,202 +0,0 @@ -/* - * Copyright (c) 1991, 1993 - * The Regents of the University of California. 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. - * 3. All advertising materials mentioning features or use of this software - * must display the following acknowledgement: - * This product includes software developed by the University of - * California, Berkeley and its contributors. - * 4. Neither the name of the University nor the names of its contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``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 THE REGENTS OR CONTRIBUTORS 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. - * - * @(#)lfs_bio.c 8.10 (Berkeley) 6/10/95 - * $Id: lfs_bio.c,v 1.13 1997/06/15 17:56:46 dyson Exp $ - */ - -#include <sys/param.h> -#include <sys/systm.h> -#include <sys/proc.h> -#include <sys/buf.h> -#include <sys/vnode.h> -#include <sys/mount.h> -#include <sys/kernel.h> - -#include <ufs/ufs/quota.h> -#include <ufs/ufs/inode.h> -#include <ufs/ufs/ufsmount.h> - -#include <ufs/lfs/lfs.h> -#include <ufs/lfs/lfs_extern.h> - -static void lfs_flush __P((void)); - -/* - * LFS block write function. - * - * XXX - * No write cost accounting is done. - * This is almost certainly wrong for synchronous operations and NFS. - */ -int lfs_allclean_wakeup; /* Cleaner wakeup address. */ -int locked_queue_count; /* XXX Count of locked-down buffers. */ -static int lfs_writing; /* Set if already kicked off a writer - because of buffer space */ -/* -#define WRITE_THRESHHOLD ((nbuf >> 2) - 10) -#define WAIT_THRESHHOLD ((nbuf >> 1) - 10) -*/ -#define WAIT_THRESHHOLD (nbuf - (nbuf >> 2) - 10) -#define WRITE_THRESHHOLD ((nbuf >> 1) - 10) -#define LFS_BUFWAIT 2 - -int -lfs_bwrite(ap) - struct vop_bwrite_args /* { - struct buf *a_bp; - } */ *ap; -{ - register struct buf *bp = ap->a_bp; - struct lfs *fs; - struct inode *ip; - int db, error, s; - - /* - * Set the delayed write flag and use reassignbuf to move the buffer - * from the clean list to the dirty one. - * - * Set the B_LOCKED flag and unlock the buffer, causing brelse to move - * the buffer onto the LOCKED free list. This is necessary, otherwise - * getnewbuf() would try to reclaim the buffers using bawrite, which - * isn't going to work. - * - * XXX we don't let meta-data writes run out of space because they can - * come from the segment writer. We need to make sure that there is - * enough space reserved so that there's room to write meta-data - * blocks. - */ - if (!(bp->b_flags & B_LOCKED)) { - fs = VFSTOUFS(bp->b_vp->v_mount)->um_lfs; - db = fragstodb(fs, numfrags(fs, bp->b_bcount)); - while (!LFS_FITS(fs, db) && !IS_IFILE(bp) && - bp->b_lblkno > 0) { - /* Out of space, need cleaner to run */ - wakeup(&lfs_allclean_wakeup); - wakeup(&fs->lfs_nextseg); - error = tsleep(&fs->lfs_avail, PCATCH | PUSER, - "cleaner", 0); - if (error) { - brelse(bp); - return (error); - } - } - ip = VTOI((bp)->b_vp); - if (!(ip->i_flag & IN_MODIFIED)) - ++fs->lfs_uinodes; - ip->i_flag |= IN_CHANGE | IN_MODIFIED | IN_UPDATE; - fs->lfs_avail -= db; - ++locked_queue_count; - ++numdirtybuffers; - bp->b_flags |= B_DELWRI | B_LOCKED; - bp->b_flags &= ~(B_READ | B_ERROR); - s = splbio(); - reassignbuf(bp, bp->b_vp); - splx(s); - } - brelse(bp); - return (0); -} - -/* - * XXX - * This routine flushes buffers out of the B_LOCKED queue when LFS has too - * many locked down. Eventually the pageout daemon will simply call LFS - * when pages need to be reclaimed. Note, we have one static count of locked - * buffers, so we can't have more than a single file system. To make this - * work for multiple file systems, put the count into the mount structure. - */ -static void -lfs_flush() -{ - register struct mount *mp, *nmp; - struct proc *p = curproc; /* XXX */ - -#ifdef DOSTATS - ++lfs_stats.write_exceeded; -#endif - if (lfs_writing) - return; - lfs_writing = 1; - simple_lock(&mountlist_slock); - for (mp = mountlist.cqh_first; mp != (void *)&mountlist; mp = nmp) { - if (vfs_busy(mp, LK_NOWAIT, &mountlist_slock, p)) { - nmp = mp->mnt_list.cqe_next; - continue; - } - if (mp->mnt_stat.f_type == lfs_mount_type && - (mp->mnt_flag & MNT_RDONLY) == 0 && - !((((struct ufsmount *)mp->mnt_data))->ufsmount_u.lfs)->lfs_dirops ) { - /* - * We set the queue to 0 here because we are about to - * write all the dirty buffers we have. If more come - * in while we're writing the segment, they may not - * get written, so we want the count to reflect these - * new writes after the segwrite completes. - */ -#ifdef DOSTATS - ++lfs_stats.flush_invoked; -#endif - lfs_segwrite(mp, 0); - } - simple_lock(&mountlist_slock); - nmp = mp->mnt_list.cqe_next; - vfs_unbusy(mp, p); - } - simple_unlock(&mountlist_slock); - lfs_writing = 0; -} - -int -lfs_check(vp, blkno) - struct vnode *vp; - ufs_daddr_t blkno; -{ - int error; - - error = 0; - if (incore(vp, blkno)) - return (0); - if (locked_queue_count > WRITE_THRESHHOLD) - lfs_flush(); - - /* If out of buffers, wait on writer */ - while (locked_queue_count > WAIT_THRESHHOLD) { -#ifdef DOSTATS - ++lfs_stats.wait_exceeded; -#endif - error = tsleep(&locked_queue_count, PCATCH | PUSER, "buffers", - hz * LFS_BUFWAIT); - } - - return (error); -} diff --git a/sys/ufs/lfs/lfs_cksum.c b/sys/ufs/lfs/lfs_cksum.c deleted file mode 100644 index c1c627edb3f9..000000000000 --- a/sys/ufs/lfs/lfs_cksum.c +++ /dev/null @@ -1,69 +0,0 @@ -/*- - * Copyright (c) 1991, 1993 - * The Regents of the University of California. 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. - * 3. All advertising materials mentioning features or use of this software - * must display the following acknowledgement: - * This product includes software developed by the University of - * California, Berkeley and its contributors. - * 4. Neither the name of the University nor the names of its contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``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 THE REGENTS OR CONTRIBUTORS 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. - * - * @(#)lfs_cksum.c 8.2 (Berkeley) 10/9/94 - * $Id: lfs_cksum.c,v 1.7 1997/02/22 09:47:18 peter Exp $ - */ - -#ifdef KERNEL -#include <sys/param.h> -#include <sys/mount.h> -#include <sys/vnode.h> - -#include <ufs/lfs/lfs.h> -#else -#include <sys/types.h> -#endif - -#include <ufs/lfs/lfs_extern.h> - -/* - * Simple, general purpose, fast checksum. Data must be short-aligned. - * Returns a u_long in case we ever want to do something more rigorous. - * - * XXX - * Use the TCP/IP checksum instead. - */ -u_long -cksum(str, len) - register void *str; - register size_t len; -{ - register u_long sum; - - len &= ~(sizeof(u_short) - 1); - for (sum = 0; len; len -= sizeof(u_short)) { - sum ^= *(u_short *)str; - str = (void *)((u_short *)str + 1); - } - return (sum); -} diff --git a/sys/ufs/lfs/lfs_debug.c b/sys/ufs/lfs/lfs_debug.c deleted file mode 100644 index 7dc47a2fcbe4..000000000000 --- a/sys/ufs/lfs/lfs_debug.c +++ /dev/null @@ -1,139 +0,0 @@ -/* - * Copyright (c) 1991, 1993 - * The Regents of the University of California. 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. - * 3. All advertising materials mentioning features or use of this software - * must display the following acknowledgement: - * This product includes software developed by the University of - * California, Berkeley and its contributors. - * 4. Neither the name of the University nor the names of its contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``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 THE REGENTS OR CONTRIBUTORS 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. - * - * @(#)lfs_debug.c 8.1 (Berkeley) 6/11/93 - * $Id: lfs_debug.c,v 1.6 1997/02/22 09:47:19 peter Exp $ - */ - -#ifdef DEBUG -#include <sys/param.h> -#include <sys/systm.h> -#include <sys/mount.h> - -#include <ufs/ufs/quota.h> -#include <ufs/ufs/inode.h> -#include <ufs/lfs/lfs.h> - -static void lfs_dump_dinode __P((struct dinode *dip)); -static void lfs_dump_super __P((struct lfs *lfsp)); - -static void -lfs_dump_super(lfsp) - struct lfs *lfsp; -{ - int i; - - (void)printf("%s%lx\t%s%lx\t%s%d\t%s%d\n", - "magic ", lfsp->lfs_magic, - "version ", lfsp->lfs_version, - "size ", lfsp->lfs_size, - "ssize ", lfsp->lfs_ssize); - (void)printf("%s%d\t%s%d\t%s%d\t%s%d\n", - "dsize ", lfsp->lfs_dsize, - "bsize ", lfsp->lfs_bsize, - "fsize ", lfsp->lfs_fsize, - "frag ", lfsp->lfs_frag); - - (void)printf("%s%d\t%s%d\t%s%d\t%s%d\n", - "minfree ", lfsp->lfs_minfree, - "inopb ", lfsp->lfs_inopb, - "ifpb ", lfsp->lfs_ifpb, - "nindir ", lfsp->lfs_nindir); - - (void)printf("%s%d\t%s%d\t%s%d\t%s%d\n", - "nseg ", lfsp->lfs_nseg, - "nspf ", lfsp->lfs_nspf, - "cleansz ", lfsp->lfs_cleansz, - "segtabsz ", lfsp->lfs_segtabsz); - - (void)printf("%s%lx\t%s%d\t%s%lx\t%s%d\n", - "segmask ", lfsp->lfs_segmask, - "segshift ", lfsp->lfs_segshift, - "bmask ", lfsp->lfs_bmask, - "bshift ", lfsp->lfs_bshift); - - (void)printf("%s%lx\t%s%d\t%s%lx\t%s%d\n", - "ffmask ", lfsp->lfs_ffmask, - "ffshift ", lfsp->lfs_ffshift, - "fbmask ", lfsp->lfs_fbmask, - "fbshift ", lfsp->lfs_fbshift); - - (void)printf("%s%d\t%s%d\t%s%lx\t%s%qx\n", - "sushift ", lfsp->lfs_sushift, - "fsbtodb ", lfsp->lfs_fsbtodb, - "cksum ", lfsp->lfs_cksum, - "maxfilesize ", lfsp->lfs_maxfilesize); - - (void)printf("Superblock disk addresses:"); - for (i = 0; i < LFS_MAXNUMSB; i++) - (void)printf(" %lx", lfsp->lfs_sboffs[i]); - (void)printf("\n"); - - (void)printf("Checkpoint Info\n"); - (void)printf("%s%d\t%s%lx\t%s%d\n", - "free ", lfsp->lfs_free, - "idaddr ", lfsp->lfs_idaddr, - "ifile ", lfsp->lfs_ifile); - (void)printf("%s%lx\t%s%d\t%s%lx\t%s%lx\t%s%lx\t%s%lx\n", - "bfree ", lfsp->lfs_bfree, - "nfiles ", lfsp->lfs_nfiles, - "lastseg ", lfsp->lfs_lastseg, - "nextseg ", lfsp->lfs_nextseg, - "curseg ", lfsp->lfs_curseg, - "offset ", lfsp->lfs_offset); - (void)printf("tstamp %lx\n", lfsp->lfs_tstamp); -} - -static void -lfs_dump_dinode(dip) - struct dinode *dip; -{ - int i; - - (void)printf("%s%u\t%s%d\t%s%u\t%s%u\t%s%lu\n", - "mode ", dip->di_mode, - "nlink ", dip->di_nlink, - "uid ", dip->di_uid, - "gid ", dip->di_gid, - "size ", dip->di_size); - (void)printf("inum %ld\n", dip->di_inumber); - (void)printf("Direct Addresses\n"); - for (i = 0; i < NDADDR; i++) { - (void)printf("\t%lx", dip->di_db[i]); - if ((i % 6) == 5) - (void)printf("\n"); - } - for (i = 0; i < NIADDR; i++) - (void)printf("\t%lx", dip->di_ib[i]); - (void)printf("\n"); -} -#endif /* DEBUG */ diff --git a/sys/ufs/lfs/lfs_extern.h b/sys/ufs/lfs/lfs_extern.h deleted file mode 100644 index d930f4db979e..000000000000 --- a/sys/ufs/lfs/lfs_extern.h +++ /dev/null @@ -1,97 +0,0 @@ -/*- - * Copyright (c) 1991, 1993, 1994 - * The Regents of the University of California. 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. - * 3. All advertising materials mentioning features or use of this software - * must display the following acknowledgement: - * This product includes software developed by the University of - * California, Berkeley and its contributors. - * 4. Neither the name of the University nor the names of its contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``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 THE REGENTS OR CONTRIBUTORS 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. - * - * @(#)lfs_extern.h 8.6 (Berkeley) 5/8/95 - * $Id: lfs_extern.h,v 1.18 1997/10/16 10:49:44 phk Exp $ - */ - -#ifndef _UFS_LFS_LFS_EXTERN_H_ -#define _UFS_LFS_LFS_EXTERN_H_ - -#ifdef KERNEL - -#ifdef MALLOC_DECLARE -MALLOC_DECLARE(M_LFSNODE); -MALLOC_DECLARE(M_SEGMENT); /* XXX should be M_LFSSEGMENT ?? */ -#endif - -struct inode; -struct mount; -struct nameidata; - -int lfs_balloc __P((struct vnode *, int, u_long, ufs_daddr_t, struct buf **)); -int lfs_blkatoff __P((struct vnode *, off_t, char **, struct buf **)); -int lfs_bwrite __P((struct vop_bwrite_args *)); -int lfs_check __P((struct vnode *, ufs_daddr_t)); -void lfs_free_buffer __P((caddr_t, int)); -int lfs_gatherblock __P((struct segment *, struct buf *, int *)); -struct dinode * - lfs_ifind __P((struct lfs *, ino_t, struct dinode *)); -int lfs_init __P((struct vfsconf *)); -int lfs_initseg __P((struct lfs *)); -int lfs_makeinode __P((int, struct nameidata *, struct inode **)); -int lfs_mountroot __P((void)); -struct buf * - lfs_newbuf __P((struct vnode *, ufs_daddr_t, size_t)); -void lfs_seglock __P((struct lfs *, unsigned long flags)); -void lfs_segunlock __P((struct lfs *)); -int lfs_segwrite __P((struct mount *, int)); -#define lfs_sysctl ((int (*) __P((int *, u_int, void *, size_t *, void *, \ - size_t, struct proc *)))eopnotsupp) -int lfs_truncate __P((struct vnode *, off_t, int, struct ucred *, struct proc *)); -int lfs_update __P((struct vnode *, struct timeval *, struct timeval *, int)); -void lfs_updatemeta __P((struct segment *)); -int lfs_valloc __P((struct vnode *, int, struct ucred *, struct vnode **)); -int lfs_vcreate __P((struct mount *, ino_t, struct vnode **)); -int lfs_vfree __P((struct vnode *, ino_t, int)); -int lfs_vflush __P((struct vnode *)); -int lfs_vref __P((struct vnode *)); -void lfs_vunref __P((struct vnode *)); -int lfs_writeinode __P((struct lfs *, struct segment *, struct inode *)); -int lfs_writeseg __P((struct lfs *, struct segment *)); -void lfs_writesuper __P((struct lfs *)); - -extern int lfs_allclean_wakeup; -extern int lfs_mount_type; -extern int locked_queue_count; -extern vop_t **lfs_vnodeop_p; -extern vop_t **lfs_specop_p; -extern vop_t **lfs_fifoop_p; -#define LFS_FIFOOPS lfs_fifoop_p - -#endif /* KERNEL */ - -__BEGIN_DECLS -u_long cksum __P((void *, size_t)); /* XXX */ -__END_DECLS - -#endif /* !_UFS_LFS_LFS_EXTERN_H_ */ diff --git a/sys/ufs/lfs/lfs_inode.c b/sys/ufs/lfs/lfs_inode.c deleted file mode 100644 index 39edcae76253..000000000000 --- a/sys/ufs/lfs/lfs_inode.c +++ /dev/null @@ -1,378 +0,0 @@ -/* - * Copyright (c) 1986, 1989, 1991, 1993 - * The Regents of the University of California. 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. - * 3. All advertising materials mentioning features or use of this software - * must display the following acknowledgement: - * This product includes software developed by the University of - * California, Berkeley and its contributors. - * 4. Neither the name of the University nor the names of its contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``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 THE REGENTS OR CONTRIBUTORS 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. - * - * @(#)lfs_inode.c 8.9 (Berkeley) 5/8/95 - * $Id: lfs_inode.c,v 1.19 1997/10/16 10:49:47 phk Exp $ - */ - -#include "opt_quota.h" - -#include <sys/param.h> -#include <sys/systm.h> -#include <sys/mount.h> -#include <sys/buf.h> -#include <sys/vnode.h> -#include <sys/kernel.h> - -#include <vm/vm.h> -#include <vm/vm_extern.h> - -#include <ufs/ufs/quota.h> -#include <ufs/ufs/inode.h> -#include <ufs/ufs/ufsmount.h> -#include <ufs/ufs/ufs_extern.h> - -#include <ufs/lfs/lfs.h> -#include <ufs/lfs/lfs_extern.h> - -/* Search a block for a specific dinode. */ -struct dinode * -lfs_ifind(fs, ino, dip) - struct lfs *fs; - ino_t ino; - register struct dinode *dip; -{ - register int cnt; - register struct dinode *ldip; - - for (cnt = INOPB(fs), ldip = dip + (cnt - 1); cnt--; --ldip) - if (ldip->di_inumber == ino) - return (ldip); - - panic("lfs_ifind: dinode %u not found", ino); - /* NOTREACHED */ -} - -int -lfs_update(vp, access, modify, waitfor) - struct vnode *vp; - struct timeval *access; - struct timeval *modify; - int waitfor; -{ - struct inode *ip; - int error; - - if (vp->v_mount->mnt_flag & MNT_RDONLY){ - return (0); - } - ip = VTOI(vp); - /* XXX - * We used to just return here. Now we make sure to check if - * we were called by lfs_fsync, since in this case, the inode - * may have been written to disk without all buffers connected - * with the vnode being flushed. It seems really suspicious - * that this could happen since from what I understand of the - * intended semantics, one of these flags should be set if there - * are still dirty buffers. Compare to how ffs_fsync/ffs_update - * work together and you'll see what I mean. - */ - if (((ip->i_flag & (IN_ACCESS|IN_CHANGE|IN_MODIFIED|IN_UPDATE)) == 0) - && (vp->v_dirtyblkhd.lh_first == NULL)) - return(0); - - if (ip->i_flag & IN_ACCESS) - ip->i_atime = access->tv_sec; - if (ip->i_flag & IN_UPDATE) { - ip->i_mtime = modify->tv_sec; - (ip)->i_modrev++; - } - if (ip->i_flag & IN_CHANGE) - ip->i_ctime = time.tv_sec; - ip->i_flag &= ~(IN_ACCESS | IN_CHANGE | IN_UPDATE); - - if (!(ip->i_flag & IN_MODIFIED)) - ++(VFSTOUFS(vp->v_mount)->um_lfs->lfs_uinodes); - ip->i_flag |= IN_MODIFIED; - - /* If sync, push back the vnode and any dirty blocks it may have. */ - error = (waitfor & LFS_SYNC ? lfs_vflush(vp) : 0); - if(waitfor & LFS_SYNC && vp->v_dirtyblkhd.lh_first != NULL) - panic("lfs_update: dirty bufs"); - return( error ); - -} - -/* Update segment usage information when removing a block. */ -#define UPDATE_SEGUSE \ - if (lastseg != -1) { \ - LFS_SEGENTRY(sup, fs, lastseg, sup_bp); \ - if (num > sup->su_nbytes) \ - panic("lfs_truncate: negative bytes in segment %d", \ - lastseg); \ - sup->su_nbytes -= num; \ - e1 = VOP_BWRITE(sup_bp); \ - fragsreleased += numfrags(fs, num); \ - } - -#define SEGDEC(S) { \ - if (daddr != 0) { \ - if (lastseg != (seg = datosn(fs, daddr))) { \ - UPDATE_SEGUSE; \ - num = (S); \ - lastseg = seg; \ - } else \ - num += (S); \ - } \ -} - -/* - * Truncate the inode ip to at most length size. Update segment usage - * table information. - */ -/* ARGSUSED */ -int -lfs_truncate(vp, length, flags, cred, p) - struct vnode *vp; - off_t length; - int flags; - struct ucred *cred; - struct proc *p; -{ - register struct indir *inp; - register int i; - register ufs_daddr_t *daddrp; - struct buf *bp, *sup_bp; - struct timeval tv; - struct ifile *ifp; - struct inode *ip; - struct lfs *fs; - struct indir a[NIADDR + 2], a_end[NIADDR + 2]; - SEGUSE *sup; - ufs_daddr_t daddr, lastblock, lbn, olastblock; - ufs_daddr_t oldsize_lastblock, oldsize_newlast, newsize; - long off, a_released, fragsreleased, i_released; - int e1, e2, depth, lastseg, num, offset, seg, freesize; - - ip = VTOI(vp); - gettime(&tv); - if (vp->v_type == VLNK && vp->v_mount->mnt_maxsymlinklen > 0) { -#ifdef DIAGNOSTIC - if (length != 0) - panic("lfs_truncate: partial truncate of symlink"); -#endif - bzero((char *)&ip->i_shortlink, (u_int)ip->i_size); - ip->i_size = 0; - ip->i_flag |= IN_CHANGE | IN_UPDATE; - return (UFS_UPDATE(vp, &tv, &tv, 0)); - } - vnode_pager_setsize(vp, (u_long)length); - - fs = ip->i_lfs; - - /* If length is larger than the file, just update the times. */ - if (ip->i_size <= length) { - ip->i_flag |= IN_CHANGE | IN_UPDATE; - return (UFS_UPDATE(vp, &tv, &tv, 0)); - } - - /* - * Calculate index into inode's block list of last direct and indirect - * blocks (if any) which we want to keep. Lastblock is 0 when the - * file is truncated to 0. - */ - lastblock = lblkno(fs, length + fs->lfs_bsize - 1); - olastblock = lblkno(fs, ip->i_size + fs->lfs_bsize - 1) - 1; - - /* - * Update the size of the file. If the file is not being truncated to - * a block boundry, the contents of the partial block following the end - * of the file must be zero'ed in case it ever become accessable again - * because of subsequent file growth. For this part of the code, - * oldsize_newlast refers to the old size of the new last block in the file. - */ - offset = blkoff(fs, length); - lbn = lblkno(fs, length); - oldsize_newlast = blksize(fs, ip, lbn); - - /* Now set oldsize to the current size of the current last block */ - oldsize_lastblock = blksize(fs, ip, olastblock); - if (offset == 0) - ip->i_size = length; - else { -#ifdef QUOTA - if (e1 = getinoquota(ip)) - return (e1); -#endif - if (e1 = bread(vp, lbn, oldsize_newlast, NOCRED, &bp)) - return (e1); - ip->i_size = length; - newsize = blksize(fs, ip, lbn); - bzero((char *)bp->b_data + offset, (u_int)(newsize - offset)); - allocbuf(bp, newsize); - if (e1 = VOP_BWRITE(bp)) - return (e1); - } - /* - * Modify sup->su_nbyte counters for each deleted block; keep track - * of number of blocks removed for ip->i_blocks. - */ - fragsreleased = 0; - num = 0; - lastseg = -1; - - for (lbn = olastblock; lbn >= lastblock;) { - /* XXX use run length from bmap array to make this faster */ - ufs_bmaparray(vp, lbn, &daddr, a, &depth, NULL, NULL); - if (lbn == olastblock) { - for (i = NIADDR + 2; i--;) - a_end[i] = a[i]; - freesize = oldsize_lastblock; - } else - freesize = fs->lfs_bsize; - - switch (depth) { - case 0: /* Direct block. */ - daddr = ip->i_db[lbn]; - SEGDEC(freesize); - ip->i_db[lbn] = 0; - --lbn; - break; -#ifdef DIAGNOSTIC - case 1: /* An indirect block. */ - panic("lfs_truncate: ufs_bmaparray returned depth 1"); - /* NOTREACHED */ -#endif - default: /* Chain of indirect blocks. */ - inp = a + --depth; - if (inp->in_off > 0 && lbn != lastblock) { - lbn -= inp->in_off < lbn - lastblock ? - inp->in_off : lbn - lastblock; - break; - } - for (; depth && (inp->in_off == 0 || lbn == lastblock); - --inp, --depth) { - if (bread(vp, - inp->in_lbn, fs->lfs_bsize, NOCRED, &bp)) - panic("lfs_truncate: bread bno %d", - inp->in_lbn); - daddrp = (ufs_daddr_t *)bp->b_data + - inp->in_off; - for (i = inp->in_off; - i++ <= a_end[depth].in_off;) { - daddr = *daddrp++; - SEGDEC(freesize); - } - a_end[depth].in_off = NINDIR(fs) - 1; - if (inp->in_off == 0) - brelse (bp); - else { - bzero((ufs_daddr_t *)bp->b_data + - inp->in_off, fs->lfs_bsize - - inp->in_off * sizeof(ufs_daddr_t)); - if (e1 = VOP_BWRITE(bp)) - return (e1); - } - } - if (depth == 0 && a[1].in_off == 0) { - off = a[0].in_off; - daddr = ip->i_ib[off]; - SEGDEC(freesize); - ip->i_ib[off] = 0; - } - if (lbn == lastblock || lbn <= NDADDR) - --lbn; - else { - lbn -= NINDIR(fs); - if (lbn < lastblock) - lbn = lastblock; - } - } - } - UPDATE_SEGUSE; - - /* If truncating the file to 0, update the version number. */ - if (length == 0) { - LFS_IENTRY(ifp, fs, ip->i_number, bp); - ++ifp->if_version; - (void) VOP_BWRITE(bp); - } - -#ifdef DIAGNOSTIC - if (ip->i_blocks < fragstodb(fs, fragsreleased)) { - printf("lfs_truncate: frag count < 0\n"); - fragsreleased = dbtofrags(fs, ip->i_blocks); - panic("lfs_truncate: frag count < 0\n"); - } -#endif - ip->i_blocks -= fragstodb(fs, fragsreleased); - fs->lfs_bfree += fragstodb(fs, fragsreleased); - ip->i_flag |= IN_CHANGE | IN_UPDATE; - /* - * Traverse dirty block list counting number of dirty buffers - * that are being deleted out of the cache, so that the lfs_avail - * field can be updated. - */ - a_released = 0; - i_released = 0; - for (bp = vp->v_dirtyblkhd.lh_first; bp; bp = bp->b_vnbufs.le_next) - if (bp->b_flags & B_LOCKED) { - a_released += numfrags(fs, bp->b_bcount); - /* - * XXX - * When buffers are created in the cache, their block - * number is set equal to their logical block number. - * If that is still true, we are assuming that the - * blocks are new (not yet on disk) and weren't - * counted above. However, there is a slight chance - * that a block's disk address is equal to its logical - * block number in which case, we'll get an overcounting - * here. - */ - if (bp->b_blkno == bp->b_lblkno) - i_released += numfrags(fs, bp->b_bcount); - } - fragsreleased = i_released; -#ifdef DIAGNOSTIC - if (fragsreleased > dbtofrags(fs, ip->i_blocks)) { - printf("lfs_inode: Warning! %s\n", - "more frags released from inode than are in inode"); - fragsreleased = dbtofrags(fs, ip->i_blocks); - panic("lfs_inode: Warning. More frags released\n"); - } -#endif - fs->lfs_bfree += fragstodb(fs, fragsreleased); - ip->i_blocks -= fragstodb(fs, fragsreleased); -#ifdef DIAGNOSTIC - if (length == 0 && ip->i_blocks != 0) { - printf("lfs_inode: Warning! %s%ld%s\n", - "Truncation to zero, but ", ip->i_blocks, - " blocks left on inode"); - panic("lfs_inode"); - } -#endif - fs->lfs_avail += fragstodb(fs, a_released); - e1 = vinvalbuf(vp, (length > 0) ? V_SAVE : 0, cred, p, - 0, 0); - e2 = UFS_UPDATE(vp, &tv, &tv, 0); - return (e1 ? e1 : e2 ? e2 : 0); -} diff --git a/sys/ufs/lfs/lfs_segment.c b/sys/ufs/lfs/lfs_segment.c deleted file mode 100644 index 3916d17ed4fc..000000000000 --- a/sys/ufs/lfs/lfs_segment.c +++ /dev/null @@ -1,1248 +0,0 @@ -/* - * Copyright (c) 1991, 1993 - * The Regents of the University of California. 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. - * 3. All advertising materials mentioning features or use of this software - * must display the following acknowledgement: - * This product includes software developed by the University of - * California, Berkeley and its contributors. - * 4. Neither the name of the University nor the names of its contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``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 THE REGENTS OR CONTRIBUTORS 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. - * - * @(#)lfs_segment.c 8.10 (Berkeley) 6/10/95 - * $Id: lfs_segment.c,v 1.26 1997/12/02 21:07:17 phk Exp $ - */ - -#include <sys/param.h> -#include <sys/systm.h> -#include <sys/kernel.h> -#include <sys/buf.h> -#include <sys/proc.h> -#include <sys/vnode.h> -#include <sys/malloc.h> -#include <sys/mount.h> - -#include <ufs/ufs/quota.h> -#include <ufs/ufs/inode.h> -#include <ufs/ufs/ufsmount.h> -#include <ufs/ufs/ufs_extern.h> - -#include <ufs/lfs/lfs.h> -#include <ufs/lfs/lfs_extern.h> - -extern int count_lock_queue __P((void)); -static caddr_t lfs_alloc_buffer __P((int size)); -static void lfs_reclaim_buffers __P((void)); - -#define MAX_ACTIVE 10 -#define MAX_IO_BUFS 256 -#define MAX_IO_SIZE (1024*512) -static int lfs_total_io_size; -static int lfs_total_io_count; -static volatile int lfs_total_free_count; -static int lfs_free_needed; -static int lfs_in_buffer_reclaim; -static struct lfs_freebuf { - int size; - caddr_t address; -} lfs_freebufs[MAX_IO_BUFS]; - -void -lfs_free_buffer( caddr_t address, int size) { - lfs_freebufs[lfs_total_free_count].address = address; - lfs_freebufs[lfs_total_free_count].size = size; - ++lfs_total_free_count; - if( lfs_free_needed) { - wakeup((caddr_t) &lfs_free_needed); - lfs_free_needed = 0; - } -} - -static void -lfs_reclaim_buffers() { - int i,s; - int reclaimed = 0; - if( lfs_in_buffer_reclaim) - return; - lfs_in_buffer_reclaim = 1; - s = splhigh(); - for(i=0;i<lfs_total_free_count;i++) { - reclaimed = 1; - if( lfs_freebufs[i].address ){ - splx(s); - free(lfs_freebufs[i].address, M_SEGMENT); - s = splhigh(); - } - lfs_total_io_size -= lfs_freebufs[i].size; - lfs_total_io_count -= 1; - } - lfs_in_buffer_reclaim = 0; - lfs_total_free_count = 0; - splx(s); - if( reclaimed) { - wakeup((caddr_t) &lfs_free_needed); - } -} - -static caddr_t -lfs_alloc_buffer(int size) { - int s; - caddr_t rtval; - if( lfs_total_free_count) - lfs_reclaim_buffers(); - s = splhigh(); /* XXX can't this just be splbio?? */ - while( ((lfs_total_io_count+1) >= MAX_IO_BUFS) || - (lfs_total_io_size >= MAX_IO_SIZE)) { - lfs_free_needed = 1; - tsleep(&lfs_free_needed, PRIBIO, "lfsalc", 0); - splx(s); - lfs_reclaim_buffers(); - s = splhigh(); - } - splx(s); - lfs_total_io_size += size; - lfs_total_io_count += 1; - rtval = malloc(size, M_SEGMENT, M_WAITOK); - return rtval; -} - - -/* - * Determine if it's OK to start a partial in this segment, or if we need - * to go on to a new segment. - */ -#define LFS_PARTIAL_FITS(fs) \ - ((fs)->lfs_dbpseg - ((fs)->lfs_offset - (fs)->lfs_curseg) > \ - 1 << (fs)->lfs_fsbtodb) - -static void lfs_callback __P((struct buf *)); -static void lfs_gather __P((struct lfs *, struct segment *, - struct vnode *, int (*) __P((struct lfs *, struct buf *)))); -void lfs_iset __P((struct inode *, ufs_daddr_t, time_t)); -static int lfs_match_data __P((struct lfs *, struct buf *)); -static int lfs_match_dindir __P((struct lfs *, struct buf *)); -static int lfs_match_indir __P((struct lfs *, struct buf *)); -#ifdef TRIPLE -static int lfs_match_tindir __P((struct lfs *, struct buf *)); -#endif -static void lfs_newseg __P((struct lfs *)); -static void lfs_shellsort __P((struct buf **, ufs_daddr_t *, register int)); -static void lfs_supercallback __P((struct buf *)); -static void lfs_writefile __P((struct lfs *, struct segment *, struct vnode *)); -static void lfs_writevnodes __P((struct lfs *fs, struct mount *mp, - struct segment *sp, int dirops)); - -/* Statistics Counters */ -#define DOSTATS -struct lfs_stats lfs_stats; - -/* op values to lfs_writevnodes */ -#define VN_REG 0 -#define VN_DIROP 1 -#define VN_EMPTY 2 - -/* - * Ifile and meta data blocks are not marked busy, so segment writes MUST be - * single threaded. Currently, there are two paths into lfs_segwrite, sync() - * and getnewbuf(). They both mark the file system busy. Lfs_vflush() - * explicitly marks the file system busy. So lfs_segwrite is safe. I think. - */ - -int - -lfs_vflush(vp) - struct vnode *vp; -{ - struct inode *ip; - struct lfs *fs; - struct segment *sp; - int error; - - fs = VFSTOUFS(vp->v_mount)->um_lfs; - /* XXX - * lfs_segwrite uses lfs_writevnodes to flush dirty vnodes. - * lfs_writevnodes (by way of a check with lfs_vref) passes over - * locked vnodes. Since we usually come here with vp locked, anytime - * we just happen to call lfs_vflush and we are past the "MAX_ACTIVE" - * threshold, we used to call lfs_seqwrite and assume it would take - * care of the problem... but of course it didn't. Now the question - * remains, is this the right thing to do, or should lfs_seqwrite or - * lfs_writevnodes be fixed to handle locked vnodes?? - */ - if (fs->lfs_nactive > MAX_ACTIVE){ - error = lfs_segwrite(vp->v_mount, SEGM_SYNC|SEGM_CKP); - if(error) - return(error); - } - - lfs_seglock(fs, SEGM_SYNC); - sp = fs->lfs_sp; - - ip = VTOI(vp); - - if (vp->v_dirtyblkhd.lh_first == NULL) - lfs_writevnodes(fs, vp->v_mount, sp, VN_EMPTY); - - do { - do { - if (vp->v_dirtyblkhd.lh_first != NULL) - lfs_writefile(fs, sp, vp); - } while (lfs_writeinode(fs, sp, ip)); - - } while (lfs_writeseg(fs, sp) && ip->i_number == LFS_IFILE_INUM); - - if (vp->v_dirtyblkhd.lh_first != NULL) - panic("lfs_vflush: dirty bufs!!!"); - -#ifdef DOSTATS - ++lfs_stats.nwrites; - if (sp->seg_flags & SEGM_SYNC) - ++lfs_stats.nsync_writes; - if (sp->seg_flags & SEGM_CKP) - ++lfs_stats.ncheckpoints; -#endif - lfs_segunlock(fs); - return (0); -} - -static void -lfs_writevnodes(fs, mp, sp, op) - struct lfs *fs; - struct mount *mp; - struct segment *sp; - int op; -{ - struct inode *ip; - struct vnode *vp; - -/* BEGIN HACK */ -#define VN_OFFSET (((u_char *)&vp->v_mntvnodes.le_next) - (u_char *)vp) -#define BACK_VP(VP) ((struct vnode *)(((u_char *)VP->v_mntvnodes.le_prev) - VN_OFFSET)) -#define BEG_OF_VLIST ((struct vnode *)(((u_char *)&mp->mnt_vnodelist.lh_first) - VN_OFFSET)) - -/* Find last vnode. */ -loop: for (vp = mp->mnt_vnodelist.lh_first; - vp && vp->v_mntvnodes.le_next != NULL; - vp = vp->v_mntvnodes.le_next); - for (; vp && vp != BEG_OF_VLIST; vp = BACK_VP(vp)) { -/* END HACK */ -/* -loop: - for (vp = mp->mnt_vnodelist.lh_first; - vp != NULL; - vp = vp->v_mntvnodes.le_next) { -*/ - /* - * If the vnode that we are about to sync is no longer - * associated with this mount point, start over. - */ - if (vp->v_mount != mp) - goto loop; - - /* XXX ignore dirops for now - if (op == VN_DIROP && !(vp->v_flag & VDIROP) || - op != VN_DIROP && (vp->v_flag & VDIROP)) - continue; - */ - - if (op == VN_EMPTY && vp->v_dirtyblkhd.lh_first) - continue; - - if (vp->v_type == VNON) - continue; - - if (lfs_vref(vp)) - continue; - - /* - * Write the inode/file if dirty and it's not the - * the IFILE. - */ - ip = VTOI(vp); - if ((ip->i_flag & - (IN_ACCESS | IN_CHANGE | IN_MODIFIED | IN_UPDATE) || - vp->v_dirtyblkhd.lh_first != NULL) && - ip->i_number != LFS_IFILE_INUM) { - if (vp->v_dirtyblkhd.lh_first != NULL) - lfs_writefile(fs, sp, vp); - (void) lfs_writeinode(fs, sp, ip); - } - vp->v_flag &= ~VDIROP; - lfs_vunref(vp); - } -} - -int -lfs_segwrite(mp, flags) - struct mount *mp; - int flags; /* Do a checkpoint. */ -{ - struct proc *p = curproc; /* XXX */ - struct buf *bp; - struct inode *ip; - struct lfs *fs; - struct segment *sp; - struct vnode *vp; - SEGUSE *segusep; - ufs_daddr_t ibno; - CLEANERINFO *cip; - int clean, do_ckp, error, i; - - fs = VFSTOUFS(mp)->um_lfs; - - /* - * If we have fewer than 2 clean segments, wait until cleaner - * writes. - */ - do { - LFS_CLEANERINFO(cip, fs, bp); - clean = cip->clean; - brelse(bp); - if (clean <= 2 || fs->lfs_avail <= 0) { - printf("lfs_segwrite: ran out of clean segments, waiting for cleaner\n"); - wakeup(&lfs_allclean_wakeup); - wakeup(&fs->lfs_nextseg); - if (error = tsleep(&fs->lfs_avail, PRIBIO + 1, - "lfs writer", 0)) - return (error); - } - } while (clean <= 2 || fs->lfs_avail <= 0); - - /* - * Allocate a segment structure and enough space to hold pointers to - * the maximum possible number of buffers which can be described in a - * single summary block. - */ - do_ckp = flags & SEGM_CKP || fs->lfs_nactive > MAX_ACTIVE; - lfs_seglock(fs, flags | (do_ckp ? SEGM_CKP : 0)); - sp = fs->lfs_sp; - - lfs_writevnodes(fs, mp, sp, VN_REG); - - /* XXX ignore ordering of dirops for now */ - /* XXX - fs->lfs_writer = 1; - if (fs->lfs_dirops && (error = - tsleep(&fs->lfs_writer, PRIBIO + 1, "lfs writer", 0))) { - free(sp->bpp, M_SEGMENT); - free(sp, M_SEGMENT); - fs->lfs_writer = 0; - return (error); - } - - lfs_writevnodes(fs, mp, sp, VN_DIROP); - */ - - /* - * If we are doing a checkpoint, mark everything since the - * last checkpoint as no longer ACTIVE. - */ - if (do_ckp) - for (ibno = fs->lfs_cleansz + fs->lfs_segtabsz; - --ibno >= fs->lfs_cleansz; ) { - if (bread(fs->lfs_ivnode, ibno, fs->lfs_bsize, - NOCRED, &bp)) - - panic("lfs: ifile read"); - segusep = (SEGUSE *)bp->b_data; - for (i = fs->lfs_sepb; i--; segusep++) - segusep->su_flags &= ~SEGUSE_ACTIVE; - - error = VOP_BWRITE(bp); - } - - if (do_ckp || fs->lfs_doifile) { -redo: - vp = fs->lfs_ivnode; - while (vget(vp, LK_EXCLUSIVE, p)) - continue; - ip = VTOI(vp); - if (vp->v_dirtyblkhd.lh_first != NULL) - lfs_writefile(fs, sp, vp); - (void)lfs_writeinode(fs, sp, ip); - vput(vp); - if (lfs_writeseg(fs, sp) && do_ckp) - goto redo; - } else - (void) lfs_writeseg(fs, sp); - - /* - * If the I/O count is non-zero, sleep until it reaches zero. At the - * moment, the user's process hangs around so we can sleep. - */ - /* XXX ignore dirops for now - fs->lfs_writer = 0; - fs->lfs_doifile = 0; - wakeup(&fs->lfs_dirops); - */ - -#ifdef DOSTATS - ++lfs_stats.nwrites; - if (sp->seg_flags & SEGM_SYNC) - ++lfs_stats.nsync_writes; - if (sp->seg_flags & SEGM_CKP) - ++lfs_stats.ncheckpoints; -#endif - lfs_segunlock(fs); - return (0); -} - -/* - * Write the dirty blocks associated with a vnode. - */ -static void -lfs_writefile(fs, sp, vp) - struct lfs *fs; - struct segment *sp; - struct vnode *vp; -{ - struct buf *bp; - struct finfo *fip; - IFILE *ifp; - - if (sp->seg_bytes_left < fs->lfs_bsize || - sp->sum_bytes_left < sizeof(struct finfo)) - (void) lfs_writeseg(fs, sp); - - sp->sum_bytes_left -= sizeof(struct finfo) - sizeof(ufs_daddr_t); - ++((SEGSUM *)(sp->segsum))->ss_nfinfo; - - fip = sp->fip; - fip->fi_nblocks = 0; - fip->fi_ino = VTOI(vp)->i_number; - LFS_IENTRY(ifp, fs, fip->fi_ino, bp); - fip->fi_version = ifp->if_version; - brelse(bp); - - /* - * It may not be necessary to write the meta-data blocks at this point, - * as the roll-forward recovery code should be able to reconstruct the - * list. - */ - lfs_gather(fs, sp, vp, lfs_match_data); - lfs_gather(fs, sp, vp, lfs_match_indir); - lfs_gather(fs, sp, vp, lfs_match_dindir); -#ifdef TRIPLE - lfs_gather(fs, sp, vp, lfs_match_tindir); -#endif - - fip = sp->fip; - if (fip->fi_nblocks != 0) { - sp->fip = - (struct finfo *)((caddr_t)fip + sizeof(struct finfo) + - sizeof(ufs_daddr_t) * (fip->fi_nblocks - 1)); - sp->start_lbp = &sp->fip->fi_blocks[0]; - } else { - sp->sum_bytes_left += sizeof(struct finfo) - sizeof(ufs_daddr_t); - --((SEGSUM *)(sp->segsum))->ss_nfinfo; - } -} - -int -lfs_writeinode(fs, sp, ip) - struct lfs *fs; - struct segment *sp; - struct inode *ip; -{ - struct buf *bp, *ibp; - IFILE *ifp; - SEGUSE *sup; - ufs_daddr_t daddr; - ino_t ino; - int error, i, ndx; - int redo_ifile = 0; - - if (!(ip->i_flag & (IN_ACCESS | IN_CHANGE | IN_MODIFIED | IN_UPDATE))) - return(0); - - /* Allocate a new inode block if necessary. */ - if (sp->ibp == NULL) { - /* Allocate a new segment if necessary. */ - if (sp->seg_bytes_left < fs->lfs_bsize || - sp->sum_bytes_left < sizeof(ufs_daddr_t)) - (void) lfs_writeseg(fs, sp); - - /* Get next inode block. */ - daddr = fs->lfs_offset; - fs->lfs_offset += fsbtodb(fs, 1); - sp->ibp = *sp->cbpp++ = - lfs_newbuf(VTOI(fs->lfs_ivnode)->i_devvp, daddr, - fs->lfs_bsize); - /* Zero out inode numbers */ - for (i = 0; i < INOPB(fs); ++i) - ((struct dinode *)sp->ibp->b_data)[i].di_inumber = 0; - ++sp->start_bpp; - fs->lfs_avail -= fsbtodb(fs, 1); - /* Set remaining space counters. */ - sp->seg_bytes_left -= fs->lfs_bsize; - sp->sum_bytes_left -= sizeof(ufs_daddr_t); - ndx = LFS_SUMMARY_SIZE / sizeof(ufs_daddr_t) - - sp->ninodes / INOPB(fs) - 1; - ((ufs_daddr_t *)(sp->segsum))[ndx] = daddr; - } - - /* Update the inode times and copy the inode onto the inode page. */ - if (ip->i_flag & IN_MODIFIED) - --fs->lfs_uinodes; - ITIMES(ip, &time, &time); - ip->i_flag &= ~(IN_ACCESS | IN_CHANGE | IN_MODIFIED | IN_UPDATE); - bp = sp->ibp; - ((struct dinode *)bp->b_data)[sp->ninodes % INOPB(fs)] = ip->i_din; - /* Increment inode count in segment summary block. */ - ++((SEGSUM *)(sp->segsum))->ss_ninos; - - /* If this page is full, set flag to allocate a new page. */ - if (++sp->ninodes % INOPB(fs) == 0) - sp->ibp = NULL; - - /* - * If updating the ifile, update the super-block. Update the disk - * address and access times for this inode in the ifile. - */ - ino = ip->i_number; - if (ino == LFS_IFILE_INUM) { - daddr = fs->lfs_idaddr; - fs->lfs_idaddr = bp->b_blkno; - } else { - LFS_IENTRY(ifp, fs, ino, ibp); - daddr = ifp->if_daddr; - ifp->if_daddr = bp->b_blkno; - error = VOP_BWRITE(ibp); - } - - /* - * No need to update segment usage if there was no former inode address - * or if the last inode address is in the current partial segment. - */ - if (daddr != LFS_UNUSED_DADDR && - !(daddr >= fs->lfs_lastpseg && daddr <= bp->b_blkno)) { - LFS_SEGENTRY(sup, fs, datosn(fs, daddr), bp); -#ifdef DIAGNOSTIC - if (sup->su_nbytes < sizeof(struct dinode)) { - /* XXX -- Change to a panic. */ - printf("lfs: negative bytes (segment %ld)\n", - datosn(fs, daddr)); - panic("negative bytes"); - } -#endif - sup->su_nbytes -= sizeof(struct dinode); - redo_ifile = - (ino == LFS_IFILE_INUM && !(bp->b_flags & B_GATHERED)); - error = VOP_BWRITE(bp); - } - return (redo_ifile); -} - -int -lfs_gatherblock(sp, bp, sptr) - struct segment *sp; - struct buf *bp; - int *sptr; -{ - struct lfs *fs; - int version; - - /* - * If full, finish this segment. We may be doing I/O, so - * release and reacquire the splbio(). - */ -#ifdef DIAGNOSTIC - if (sp->vp == NULL) - panic ("lfs_gatherblock: Null vp in segment"); -#endif - fs = sp->fs; - if (sp->sum_bytes_left < sizeof(ufs_daddr_t) || - sp->seg_bytes_left < bp->b_bcount) { - if (sptr) - splx(*sptr); - lfs_updatemeta(sp); - - version = sp->fip->fi_version; - (void) lfs_writeseg(fs, sp); - - sp->fip->fi_version = version; - sp->fip->fi_ino = VTOI(sp->vp)->i_number; - /* Add the current file to the segment summary. */ - ++((SEGSUM *)(sp->segsum))->ss_nfinfo; - sp->sum_bytes_left -= - sizeof(struct finfo) - sizeof(ufs_daddr_t); - - if (sptr) - *sptr = splbio(); - return(1); - } - - /* Insert into the buffer list, update the FINFO block. */ - bp->b_flags |= B_GATHERED; - *sp->cbpp++ = bp; - sp->fip->fi_blocks[sp->fip->fi_nblocks++] = bp->b_lblkno; - - sp->sum_bytes_left -= sizeof(ufs_daddr_t); - sp->seg_bytes_left -= bp->b_bcount; - return(0); -} - -static void -lfs_gather(fs, sp, vp, match) - struct lfs *fs; - struct segment *sp; - struct vnode *vp; - int (*match) __P((struct lfs *, struct buf *)); -{ - struct buf *bp; - int s; - - sp->vp = vp; - s = splbio(); -/* This is a hack to see if ordering the blocks in LFS makes a difference. */ -/* BEGIN HACK */ -#define BUF_OFFSET (((u_char *)&bp->b_vnbufs.le_next) - (u_char *)bp) -#define BACK_BUF(BP) ((struct buf *)(((u_char *)BP->b_vnbufs.le_prev) - BUF_OFFSET)) -#define BEG_OF_LIST ((struct buf *)(((u_char *)&vp->v_dirtyblkhd.lh_first) - BUF_OFFSET)) - - -/*loop: for (bp = vp->v_dirtyblkhd.lh_first; bp; bp = bp->b_vnbufs.le_next) {*/ -/* Find last buffer. */ -loop: for (bp = vp->v_dirtyblkhd.lh_first; bp && bp->b_vnbufs.le_next != NULL; - bp = bp->b_vnbufs.le_next); - for (; bp && bp != BEG_OF_LIST; bp = BACK_BUF(bp)) { -/* END HACK */ - if (bp->b_flags & B_BUSY || !match(fs, bp) || - bp->b_flags & B_GATHERED) - continue; -#ifdef DIAGNOSTIC - if (!(bp->b_flags & B_DELWRI)) - panic("lfs_gather: bp not B_DELWRI"); - if (!(bp->b_flags & B_LOCKED)) - panic("lfs_gather: bp not B_LOCKED"); -#endif - if (lfs_gatherblock(sp, bp, &s)) - goto loop; - } - splx(s); - lfs_updatemeta(sp); - sp->vp = NULL; -} - - -/* - * Update the metadata that points to the blocks listed in the FINFO - * array. - */ -void -lfs_updatemeta(sp) - struct segment *sp; -{ - SEGUSE *sup; - struct buf *bp; - struct lfs *fs; - struct vnode *vp; - struct indir a[NIADDR + 2], *ap; - struct inode *ip; - ufs_daddr_t daddr, lbn, off; - int error, i, nblocks, num; - - vp = sp->vp; - nblocks = &sp->fip->fi_blocks[sp->fip->fi_nblocks] - sp->start_lbp; - if (nblocks < 0) - panic("This is a bad thing\n"); - if (vp == NULL || nblocks == 0) - return; - - /* Sort the blocks. */ - if (!(sp->seg_flags & SEGM_CLEAN)) - lfs_shellsort(sp->start_bpp, sp->start_lbp, nblocks); - - /* - * Record the length of the last block in case it's a fragment. - * If there are indirect blocks present, they sort last. An - * indirect block will be lfs_bsize and its presence indicates - * that you cannot have fragments. - */ - sp->fip->fi_lastlength = sp->start_bpp[nblocks - 1]->b_bcount; - - /* - * Assign disk addresses, and update references to the logical - * block and the segment usage information. - */ - fs = sp->fs; - for (i = nblocks; i--; ++sp->start_bpp) { - lbn = *sp->start_lbp++; - (*sp->start_bpp)->b_blkno = off = fs->lfs_offset; - fs->lfs_offset += - fragstodb(fs, numfrags(fs, (*sp->start_bpp)->b_bcount)); - - if (error = ufs_bmaparray(vp, lbn, &daddr, a, &num, NULL, NULL)) - panic("lfs_updatemeta: ufs_bmaparray %d", error); - ip = VTOI(vp); - switch (num) { - case 0: - ip->i_db[lbn] = off; - break; - case 1: - ip->i_ib[a[0].in_off] = off; - break; - default: - ap = &a[num - 1]; - if (bread(vp, ap->in_lbn, fs->lfs_bsize, NOCRED, &bp)) - panic("lfs_updatemeta: bread bno %d", - ap->in_lbn); - /* - * Bread may create a new indirect block which needs - * to get counted for the inode. - */ - if (bp->b_blkno == -1 && !(bp->b_flags & B_CACHE)) { - ip->i_blocks += fsbtodb(fs, 1); - fs->lfs_bfree -= fragstodb(fs, fs->lfs_frag); - } - ((ufs_daddr_t *)bp->b_data)[ap->in_off] = off; - VOP_BWRITE(bp); - } - - /* Update segment usage information. */ - if (daddr != UNASSIGNED && - !(daddr >= fs->lfs_lastpseg && daddr <= off)) { - LFS_SEGENTRY(sup, fs, datosn(fs, daddr), bp); -#ifdef DIAGNOSTIC - if (sup->su_nbytes < (*sp->start_bpp)->b_bcount) { - /* XXX -- Change to a panic. */ - printf("lfs: negative bytes (segment %ld)\n", - datosn(fs, daddr)); - printf("lfs: bp = 0x%x, addr = 0x%x\n", - bp, bp->b_data); - panic ("Negative Bytes"); - } -#endif - sup->su_nbytes -= (*sp->start_bpp)->b_bcount; - error = VOP_BWRITE(bp); - } - } -} - -/* - * Start a new segment. - */ -int -lfs_initseg(fs) - struct lfs *fs; -{ - struct segment *sp; - SEGUSE *sup; - SEGSUM *ssp; - struct buf *bp; - int repeat; - - sp = fs->lfs_sp; - - repeat = 0; - /* Advance to the next segment. */ - if (!LFS_PARTIAL_FITS(fs)) { - /* Wake up any cleaning procs waiting on this file system. */ - wakeup(&lfs_allclean_wakeup); - wakeup(&fs->lfs_nextseg); - - lfs_newseg(fs); - repeat = 1; - fs->lfs_offset = fs->lfs_curseg; - sp->seg_number = datosn(fs, fs->lfs_curseg); - sp->seg_bytes_left = fs->lfs_dbpseg * DEV_BSIZE; - - /* - * If the segment contains a superblock, update the offset - * and summary address to skip over it. - */ - LFS_SEGENTRY(sup, fs, sp->seg_number, bp); - if (sup->su_flags & SEGUSE_SUPERBLOCK) { - fs->lfs_offset += LFS_SBPAD / DEV_BSIZE; - sp->seg_bytes_left -= LFS_SBPAD; - } - brelse(bp); - } else { - sp->seg_number = datosn(fs, fs->lfs_curseg); - sp->seg_bytes_left = (fs->lfs_dbpseg - - (fs->lfs_offset - fs->lfs_curseg)) * DEV_BSIZE; - } - fs->lfs_lastpseg = fs->lfs_offset; - - sp->fs = fs; - sp->ibp = NULL; - sp->ninodes = 0; - - /* Get a new buffer for SEGSUM and enter it into the buffer list. */ - sp->cbpp = sp->bpp; - *sp->cbpp = lfs_newbuf(VTOI(fs->lfs_ivnode)->i_devvp, fs->lfs_offset, - LFS_SUMMARY_SIZE); - sp->segsum = (*sp->cbpp)->b_data; - bzero(sp->segsum, LFS_SUMMARY_SIZE); - sp->start_bpp = ++sp->cbpp; - fs->lfs_offset += LFS_SUMMARY_SIZE / DEV_BSIZE; - - /* Set point to SEGSUM, initialize it. */ - ssp = sp->segsum; - ssp->ss_next = fs->lfs_nextseg; - ssp->ss_nfinfo = ssp->ss_ninos = 0; - ssp->ss_magic = SS_MAGIC; - - /* Set pointer to first FINFO, initialize it. */ - sp->fip = (struct finfo *)((caddr_t)sp->segsum + sizeof(SEGSUM)); - sp->fip->fi_nblocks = 0; - sp->start_lbp = &sp->fip->fi_blocks[0]; - sp->fip->fi_lastlength = 0; - - sp->seg_bytes_left -= LFS_SUMMARY_SIZE; - sp->sum_bytes_left = LFS_SUMMARY_SIZE - sizeof(SEGSUM); - - return(repeat); -} - -/* - * Return the next segment to write. - */ -static void -lfs_newseg(fs) - struct lfs *fs; -{ - CLEANERINFO *cip; - SEGUSE *sup; - struct buf *bp; - int curseg, isdirty, sn; - - LFS_SEGENTRY(sup, fs, datosn(fs, fs->lfs_nextseg), bp); - sup->su_flags |= SEGUSE_DIRTY | SEGUSE_ACTIVE; - sup->su_nbytes = 0; - sup->su_nsums = 0; - sup->su_ninos = 0; - (void) VOP_BWRITE(bp); - - LFS_CLEANERINFO(cip, fs, bp); - --cip->clean; - ++cip->dirty; - (void) VOP_BWRITE(bp); - - fs->lfs_lastseg = fs->lfs_curseg; - fs->lfs_curseg = fs->lfs_nextseg; - for (sn = curseg = datosn(fs, fs->lfs_curseg);;) { - sn = (sn + 1) % fs->lfs_nseg; - if (sn == curseg) - panic("lfs_nextseg: no clean segments"); - LFS_SEGENTRY(sup, fs, sn, bp); - isdirty = sup->su_flags & SEGUSE_DIRTY; - brelse(bp); - if (!isdirty) - break; - } - - ++fs->lfs_nactive; - fs->lfs_nextseg = sntoda(fs, sn); -#ifdef DOSTATS - ++lfs_stats.segsused; -#endif -} - -int -lfs_writeseg(fs, sp) - struct lfs *fs; - struct segment *sp; -{ - struct buf **bpp, *bp, *cbp; - SEGUSE *sup; - SEGSUM *ssp; - dev_t i_dev; - u_long *datap, *dp; - int do_again, i, nblocks, s; - u_short ninos; - char *p; - - /* - * If there are no buffers other than the segment summary to write - * and it is not a checkpoint, don't do anything. On a checkpoint, - * even if there aren't any buffers, you need to write the superblock. - */ - if ((nblocks = sp->cbpp - sp->bpp) == 1) - return (0); - - /* Update the segment usage information. */ - LFS_SEGENTRY(sup, fs, sp->seg_number, bp); - - /* Loop through all blocks, except the segment summary. */ - for (bpp = sp->bpp; ++bpp < sp->cbpp; ) - sup->su_nbytes += (*bpp)->b_bcount; - - ssp = (SEGSUM *)sp->segsum; - - ninos = (ssp->ss_ninos + INOPB(fs) - 1) / INOPB(fs); - sup->su_nbytes += ssp->ss_ninos * sizeof(struct dinode); - sup->su_nbytes += LFS_SUMMARY_SIZE; - sup->su_lastmod = time.tv_sec; - sup->su_ninos += ninos; - ++sup->su_nsums; - do_again = !(bp->b_flags & B_GATHERED); - (void)VOP_BWRITE(bp); - /* - * Compute checksum across data and then across summary; the first - * block (the summary block) is skipped. Set the create time here - * so that it's guaranteed to be later than the inode mod times. - * - * XXX - * Fix this to do it inline, instead of malloc/copy. - */ - datap = dp = malloc(nblocks * sizeof(u_long), M_SEGMENT, M_WAITOK); - for (bpp = sp->bpp, i = nblocks - 1; i--;) { - if ((*++bpp)->b_flags & B_INVAL) { - if (copyin((*bpp)->b_saveaddr, dp++, sizeof(u_long))) - panic("lfs_writeseg: copyin failed"); - } else - *dp++ = ((u_long *)(*bpp)->b_data)[0]; - } - ssp->ss_create = time.tv_sec; - ssp->ss_datasum = cksum(datap, (nblocks - 1) * sizeof(u_long)); - ssp->ss_sumsum = - cksum(&ssp->ss_datasum, LFS_SUMMARY_SIZE - sizeof(ssp->ss_sumsum)); - free(datap, M_SEGMENT); -#ifdef DIAGNOSTIC - if (fs->lfs_bfree < fsbtodb(fs, ninos) + LFS_SUMMARY_SIZE / DEV_BSIZE) - panic("lfs_writeseg: No diskspace for summary"); -#endif - fs->lfs_bfree -= (fsbtodb(fs, ninos) + LFS_SUMMARY_SIZE / DEV_BSIZE); - - i_dev = VTOI(fs->lfs_ivnode)->i_dev; - - /* - * When we simply write the blocks we lose a rotation for every block - * written. To avoid this problem, we allocate memory in chunks, copy - * the buffers into the chunk and write the chunk. DFLTPHYS is the - * largest size I/O devices can handle. - * When the data is copied to the chunk, turn off the the B_LOCKED bit - * and brelse the buffer (which will move them to the LRU list). Add - * the B_CALL flag to the buffer header so we can count I/O's for the - * checkpoints and so we can release the allocated memory. - * - * XXX - * This should be removed if the new virtual memory system allows us to - * easily make the buffers contiguous in kernel memory and if that's - * fast enough. - */ - for (bpp = sp->bpp, i = nblocks; i;) { - cbp = lfs_newbuf(VTOI(fs->lfs_ivnode)->i_devvp, - (*bpp)->b_blkno, DFLTPHYS); - cbp->b_dev = i_dev; - cbp->b_flags |= B_ASYNC | B_BUSY; - cbp->b_bcount = 0; - - s = splbio(); - ++fs->lfs_iocount; - for (p = cbp->b_data; i && cbp->b_bcount < DFLTPHYS; i--) { - bp = *bpp; - if (bp->b_bcount > (DFLTPHYS - cbp->b_bcount)) - break; - bpp++; - - /* - * Fake buffers from the cleaner are marked as B_INVAL. - * We need to copy the data from user space rather than - * from the buffer indicated. - * XXX == what do I do on an error? - */ - if (bp->b_flags & B_INVAL) { - if (copyin(bp->b_saveaddr, p, bp->b_bcount)) - panic("lfs_writeseg: copyin failed"); - } else - bcopy(bp->b_data, p, bp->b_bcount); - p += bp->b_bcount; - cbp->b_bcount += bp->b_bcount; - if (bp->b_flags & B_LOCKED) - --locked_queue_count; - if (bp->b_flags & (B_DELWRI|B_LOCKED)) { - --numdirtybuffers; - if (needsbuffer) - vfs_bio_need_satisfy(); - } - bp->b_flags &= ~(B_ERROR | B_READ | B_DELWRI | - B_LOCKED | B_GATHERED); - if (bp->b_flags & B_CALL) { - /* if B_CALL, it was created with newbuf */ - if (!(bp->b_flags & B_INVAL)) - lfs_free_buffer( bp->b_data, roundup( bp->b_bufsize, DEV_BSIZE)); - relpbuf(bp); - } else { - bremfree(bp); - bp->b_flags |= B_DONE; - reassignbuf(bp, bp->b_vp); - brelse(bp); - } - } - ++cbp->b_vp->v_numoutput; - splx(s); - /* - * XXXX This is a gross and disgusting hack. Since these - * buffers are physically addressed, they hang off the - * device vnode (devvp). As a result, they have no way - * of getting to the LFS superblock or lfs structure to - * keep track of the number of I/O's pending. So, I am - * going to stuff the fs into the saveaddr field of - * the buffer (yuk). - */ - cbp->b_saveaddr = (caddr_t)fs; - VOP_STRATEGY(cbp); - } - /* - * XXX - * Vinvalbuf can move locked buffers off the locked queue - * and we have no way of knowing about this. So, after - * doing a big write, we recalculate how many bufers are - * really still left on the locked queue. - */ - locked_queue_count = count_lock_queue(); - wakeup(&locked_queue_count); -#ifdef DOSTATS - ++lfs_stats.psegwrites; - lfs_stats.blocktot += nblocks - 1; - if (fs->lfs_sp->seg_flags & SEGM_SYNC) - ++lfs_stats.psyncwrites; - if (fs->lfs_sp->seg_flags & SEGM_CLEAN) { - ++lfs_stats.pcleanwrites; - lfs_stats.cleanblocks += nblocks - 1; - } -#endif - return (lfs_initseg(fs) || do_again); -} - -void -lfs_writesuper(fs) - struct lfs *fs; -{ - struct buf *bp; - dev_t i_dev; - int s; - - i_dev = VTOI(fs->lfs_ivnode)->i_dev; - - /* Checksum the superblock and copy it into a buffer. */ - fs->lfs_cksum = cksum(fs, sizeof(struct lfs) - sizeof(fs->lfs_cksum)); - bp = lfs_newbuf(VTOI(fs->lfs_ivnode)->i_devvp, fs->lfs_sboffs[0], - LFS_SBPAD); - *(struct lfs *)bp->b_data = *fs; - - /* XXX Toggle between first two superblocks; for now just write first */ - bp->b_dev = i_dev; - bp->b_flags |= B_BUSY | B_CALL | B_ASYNC; - if (bp->b_flags & (B_DELWRI|B_LOCKED)) { - --numdirtybuffers; - if (needsbuffer) - vfs_bio_need_satisfy(); - } - bp->b_flags &= ~(B_DONE | B_ERROR | B_READ | B_DELWRI); - bp->b_iodone = lfs_supercallback; - s = splbio(); - ++bp->b_vp->v_numoutput; - splx(s); - VOP_STRATEGY(bp); -} - -/* - * Logical block number match routines used when traversing the dirty block - * chain. - */ -static int -lfs_match_data(fs, bp) - struct lfs *fs; - struct buf *bp; -{ - return (bp->b_lblkno >= 0); -} - -static int -lfs_match_indir(fs, bp) - struct lfs *fs; - struct buf *bp; -{ - int lbn; - - lbn = bp->b_lblkno; - return (lbn < 0 && (-lbn - NDADDR) % NINDIR(fs) == 0); -} - -static int -lfs_match_dindir(fs, bp) - struct lfs *fs; - struct buf *bp; -{ - int lbn; - - lbn = bp->b_lblkno; - return (lbn < 0 && (-lbn - NDADDR) % NINDIR(fs) == 1); -} - -#ifdef TRIPLE -static int -lfs_match_tindir(fs, bp) - struct lfs *fs; - struct buf *bp; -{ - int lbn; - - lbn = bp->b_lblkno; - return (lbn < 0 && (-lbn - NDADDR) % NINDIR(fs) == 2); -} -#endif - -/* - * Allocate a new buffer header. - */ -struct buf * -lfs_newbuf(vp, daddr, size) - struct vnode *vp; - ufs_daddr_t daddr; - size_t size; -{ - struct buf *bp; - size_t nbytes; - - nbytes = roundup(size, DEV_BSIZE); - bp = getpbuf(); - if (nbytes) - bp->b_data = lfs_alloc_buffer( nbytes); - bp->b_bufsize = size; - bp->b_bcount = size; - bp->b_lblkno = daddr; - bp->b_blkno = daddr; - bp->b_error = 0; - bp->b_resid = 0; - bp->b_iodone = lfs_callback; - bp->b_flags |= B_BUSY | B_CALL | B_NOCACHE; - return (bp); -} - -static void -lfs_callback(bp) - struct buf *bp; -{ - struct lfs *fs; - - fs = (struct lfs *)bp->b_saveaddr; -#ifdef DIAGNOSTIC - if (fs->lfs_iocount == 0) - panic("lfs_callback: zero iocount"); -#endif - if (--fs->lfs_iocount == 0) - wakeup(&fs->lfs_iocount); - - lfs_free_buffer( bp->b_data, roundup( bp->b_bufsize, DEV_BSIZE)); - relpbuf(bp); - -} - -static void -lfs_supercallback(bp) - struct buf *bp; -{ - if( bp->b_data) - lfs_free_buffer( bp->b_data, roundup( bp->b_bufsize, DEV_BSIZE)); - relpbuf(bp); -} - -/* - * Shellsort (diminishing increment sort) from Data Structures and - * Algorithms, Aho, Hopcraft and Ullman, 1983 Edition, page 290; - * see also Knuth Vol. 3, page 84. The increments are selected from - * formula (8), page 95. Roughly O(N^3/2). - */ -/* - * This is our own private copy of shellsort because we want to sort - * two parallel arrays (the array of buffer pointers and the array of - * logical block numbers) simultaneously. Note that we cast the array - * of logical block numbers to a unsigned in this routine so that the - * negative block numbers (meta data blocks) sort AFTER the data blocks. - */ -static void -lfs_shellsort(bp_array, lb_array, nmemb) - struct buf **bp_array; - ufs_daddr_t *lb_array; - register int nmemb; -{ - static int __rsshell_increments[] = { 4, 1, 0 }; - register int incr, *incrp, t1, t2; - struct buf *bp_temp; - u_long lb_temp; - - for (incrp = __rsshell_increments; incr = *incrp++;) - for (t1 = incr; t1 < nmemb; ++t1) - for (t2 = t1 - incr; t2 >= 0;) - if (lb_array[t2] > lb_array[t2 + incr]) { - lb_temp = lb_array[t2]; - lb_array[t2] = lb_array[t2 + incr]; - lb_array[t2 + incr] = lb_temp; - bp_temp = bp_array[t2]; - bp_array[t2] = bp_array[t2 + incr]; - bp_array[t2 + incr] = bp_temp; - t2 -= incr; - } else - break; -} - -/* - * Check VXLOCK. Return 1 if the vnode is locked. Otherwise, vget it. - */ -int -lfs_vref(vp) - register struct vnode *vp; -{ - struct proc *p = curproc; /* XXX */ - - if ((vp->v_flag & VXLOCK) || /* XXX */ - (vp->v_usecount == 0 && - vp->v_flag & VDOOMED)) - return(1); - return (vget(vp, 0, p)); -} - -/* - * This is vrele except that we do not want to VOP_INACTIVE this vnode. We - * inline vrele here to avoid the vn_lock and VOP_INACTIVE call at the end. - * - * XXX: this is positively disgusting and blatantly wrong, and may not - * even work these days :-( /phk - */ -void -lfs_vunref(vp) - register struct vnode *vp; -{ - struct proc *p = curproc; /* XXX */ - extern struct simplelock vnode_free_list_slock; /* XXX */ - extern TAILQ_HEAD(freelst, vnode) vnode_free_list; /* XXX */ - - simple_lock(&vp->v_interlock); - vp->v_usecount--; - if (vp->v_usecount > 0) { - simple_unlock(&vp->v_interlock); - return; - } - /* - * insert at tail of LRU list - */ - simple_lock(&vnode_free_list_slock); - TAILQ_INSERT_TAIL(&vnode_free_list, vp, v_freelist); - simple_unlock(&vnode_free_list_slock); - simple_unlock(&vp->v_interlock); -} diff --git a/sys/ufs/lfs/lfs_subr.c b/sys/ufs/lfs/lfs_subr.c deleted file mode 100644 index ad4fbcc12c3b..000000000000 --- a/sys/ufs/lfs/lfs_subr.c +++ /dev/null @@ -1,184 +0,0 @@ -/* - * Copyright (c) 1991, 1993 - * The Regents of the University of California. 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. - * 3. All advertising materials mentioning features or use of this software - * must display the following acknowledgement: - * This product includes software developed by the University of - * California, Berkeley and its contributors. - * 4. Neither the name of the University nor the names of its contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``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 THE REGENTS OR CONTRIBUTORS 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. - * - * @(#)lfs_subr.c 8.4 (Berkeley) 5/8/95 - * $Id: lfs_subr.c,v 1.11 1997/08/02 14:33:21 bde Exp $ - */ - -#include <sys/param.h> -#include <sys/systm.h> -#include <sys/vnode.h> -#include <sys/buf.h> -#include <sys/mount.h> -#include <sys/malloc.h> -#include <sys/proc.h> - -#include <ufs/ufs/quota.h> -#include <ufs/ufs/inode.h> -#include <ufs/lfs/lfs.h> -#include <ufs/lfs/lfs_extern.h> - -/* - * Return buffer with the contents of block "offset" from the beginning of - * directory "ip". If "res" is non-zero, fill it in with a pointer to the - * remaining space in the directory. - */ -int -lfs_blkatoff(vp, offset, res, bpp) - struct vnode *vp; - off_t offset; - char **res; - struct buf **bpp; -{ - register struct lfs *fs; - struct inode *ip; - struct buf *bp; - ufs_daddr_t lbn; - int bsize, error; - - ip = VTOI(vp); - fs = ip->i_lfs; - lbn = lblkno(fs, offset); - bsize = blksize(fs, ip, lbn); - - *bpp = NULL; - if (error = bread(vp, lbn, bsize, NOCRED, &bp)) { - brelse(bp); - return (error); - } - if (res) - *res = (char *)bp->b_data + blkoff(fs, offset); - *bpp = bp; - return (0); -} - - -/* - * lfs_seglock -- - * Single thread the segment writer. - */ -void -lfs_seglock(fs, flags) - struct lfs *fs; - unsigned long flags; -{ - struct segment *sp; - int s; - - if (fs->lfs_seglock) - if (fs->lfs_lockpid == curproc->p_pid) { - ++fs->lfs_seglock; - fs->lfs_sp->seg_flags |= flags; - return; - } else while (fs->lfs_seglock) - (void)tsleep(&fs->lfs_seglock, PRIBIO + 1, - "lfs seglock", 0); - - /* XXX RACE CONDITION????? */ - fs->lfs_seglock = 1; - fs->lfs_lockpid = curproc->p_pid; - - sp = fs->lfs_sp = malloc(sizeof(struct segment), M_SEGMENT, M_WAITOK); - sp->bpp = malloc(((LFS_SUMMARY_SIZE - sizeof(SEGSUM)) / - sizeof(ufs_daddr_t) + 1) * sizeof(struct buf *), - M_SEGMENT, M_WAITOK); - sp->seg_flags = flags; - sp->vp = NULL; - (void) lfs_initseg(fs); - - /* - * Keep a cumulative count of the outstanding I/O operations. If the - * disk drive catches up with us it could go to zero before we finish, - * so we artificially increment it by one until we've scheduled all of - * the writes we intend to do. - */ - s = splbio(); - ++fs->lfs_iocount; - splx(s); -} -/* - * lfs_segunlock -- - * Single thread the segment writer. - */ -void -lfs_segunlock(fs) - struct lfs *fs; -{ - struct segment *sp; - unsigned long sync, ckp; - int s; - - if (fs->lfs_seglock == 1) { - - sp = fs->lfs_sp; - sync = sp->seg_flags & SEGM_SYNC; - ckp = sp->seg_flags & SEGM_CKP; - if (sp->bpp != sp->cbpp) { - /* Free allocated segment summary */ - fs->lfs_offset -= LFS_SUMMARY_SIZE / DEV_BSIZE; - lfs_free_buffer((*sp->bpp)->b_data, roundup((*sp->bpp)->b_bufsize, DEV_BSIZE)); - relpbuf(*sp->bpp); - } else - printf ("unlock to 0 with no summary"); - free(sp->bpp, M_SEGMENT); - free(sp, M_SEGMENT); - - /* - * If the I/O count is non-zero, sleep until it reaches zero. - * At the moment, the user's process hangs around so we can - * sleep. - */ - s = splbio(); - --fs->lfs_iocount; - /* - * We let checkpoints happen asynchronously. That means - * that during recovery, we have to roll forward between - * the two segments described by the first and second - * superblocks to make sure that the checkpoint described - * by a superblock completed. - */ - if (sync && fs->lfs_iocount) - (void)tsleep(&fs->lfs_iocount, PRIBIO + 1, "lfs vflush", 0); - splx(s); - if (ckp) { - fs->lfs_nactive = 0; - lfs_writesuper(fs); - } - --fs->lfs_seglock; - fs->lfs_lockpid = 0; - wakeup(&fs->lfs_seglock); - } else if (fs->lfs_seglock == 0) { - panic ("Seglock not held"); - } else { - --fs->lfs_seglock; - } -} diff --git a/sys/ufs/lfs/lfs_syscalls.c b/sys/ufs/lfs/lfs_syscalls.c deleted file mode 100644 index f575f34fa7c9..000000000000 --- a/sys/ufs/lfs/lfs_syscalls.c +++ /dev/null @@ -1,582 +0,0 @@ -/*- - * Copyright (c) 1991, 1993, 1994 - * The Regents of the University of California. 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. - * 3. All advertising materials mentioning features or use of this software - * must display the following acknowledgement: - * This product includes software developed by the University of - * California, Berkeley and its contributors. - * 4. Neither the name of the University nor the names of its contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``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 THE REGENTS OR CONTRIBUTORS 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. - * - * @(#)lfs_syscalls.c 8.10 (Berkeley) 5/14/95 - * $Id: lfs_syscalls.c,v 1.20 1997/11/06 19:29:51 phk Exp $ - */ - -#include "opt_lfs.h" /* XXX: Indicate bogus header dependency */ - -#include <sys/param.h> -#include <sys/systm.h> -#include <sys/sysproto.h> -#include <sys/proc.h> -#include <sys/buf.h> -#include <sys/mount.h> -#include <sys/vnode.h> -#include <sys/malloc.h> -#include <sys/kernel.h> - -#include <ufs/ufs/quota.h> -#include <ufs/ufs/inode.h> -#include <ufs/ufs/ufsmount.h> -#include <ufs/ufs/ufs_extern.h> - -#include <ufs/lfs/lfs.h> -#include <ufs/lfs/lfs_extern.h> -#define BUMP_FIP(SP) \ - (SP)->fip = (FINFO *) (&(SP)->fip->fi_blocks[(SP)->fip->fi_nblocks]) - -#define INC_FINFO(SP) ++((SEGSUM *)((SP)->segsum))->ss_nfinfo -#define DEC_FINFO(SP) --((SEGSUM *)((SP)->segsum))->ss_nfinfo - -/* - * Before committing to add something to a segment summary, make sure there - * is enough room. S is the bytes added to the summary. - */ -#define CHECK_SEG(s) \ -if (sp->sum_bytes_left < (s)) { \ - (void) lfs_writeseg(fs, sp); \ -} -static struct buf *lfs_fakebuf __P((struct vnode *, int, size_t, caddr_t)); -static int lfs_fastvget __P((struct mount *, ino_t, daddr_t, struct vnode **, - struct dinode *)); - -int debug_cleaner = 0; -int clean_vnlocked = 0; -int clean_inlocked = 0; - -/* - * lfs_markv: - * - * This will mark inodes and blocks dirty, so they are written into the log. - * It will block until all the blocks have been written. The segment create - * time passed in the block_info and inode_info structures is used to decide - * if the data is valid for each block (in case some process dirtied a block - * or inode that is being cleaned between the determination that a block is - * live and the lfs_markv call). - * - * 0 on success - * -1/errno is return on error. - */ -#ifndef _SYS_SYSPROTO_H_ -struct lfs_markv_args { - fsid_t *fsidp; /* file system */ - BLOCK_INFO *blkiov; /* block array */ - int blkcnt; /* count of block array entries */ -}; -#endif -int -lfs_markv(p, uap) - struct proc *p; - struct lfs_markv_args *uap; -{ - struct segment *sp; - BLOCK_INFO *blkp; - IFILE *ifp; - struct buf *bp, **bpp; - struct inode *ip = 0; - struct lfs *fs; - struct mount *mntp; - struct vnode *vp; - fsid_t fsid; - void *start; - ino_t lastino; - ufs_daddr_t b_daddr, v_daddr; - u_long bsize; - int cnt, error; - - if (error = suser(p->p_ucred, &p->p_acflag)) - return (error); - - if (error = copyin(uap->fsidp, &fsid, sizeof(fsid_t))) - return (error); - if ((mntp = vfs_getvfs(&fsid)) == NULL) - return (EINVAL); - - cnt = uap->blkcnt; - start = malloc(cnt * sizeof(BLOCK_INFO), M_SEGMENT, M_WAITOK); - if (error = copyin(uap->blkiov, start, cnt * sizeof(BLOCK_INFO))) - goto err1; - - /* Mark blocks/inodes dirty. */ - fs = VFSTOUFS(mntp)->um_lfs; - bsize = fs->lfs_bsize; - error = 0; - - lfs_seglock(fs, SEGM_SYNC | SEGM_CLEAN); - sp = fs->lfs_sp; - for (v_daddr = LFS_UNUSED_DADDR, lastino = LFS_UNUSED_INUM, - blkp = start; cnt--; ++blkp) { - /* - * Get the IFILE entry (only once) and see if the file still - * exists. - */ - if (lastino != blkp->bi_inode) { - if (lastino != LFS_UNUSED_INUM) { - /* Finish up last file */ - if (sp->fip->fi_nblocks == 0) { - DEC_FINFO(sp); - sp->sum_bytes_left += - sizeof(FINFO) - sizeof(ufs_daddr_t); - } else { - lfs_updatemeta(sp); - BUMP_FIP(sp); - } - - lfs_writeinode(fs, sp, ip); - lfs_vunref(vp); - } - - /* Start a new file */ - CHECK_SEG(sizeof(FINFO)); - sp->sum_bytes_left -= sizeof(FINFO) - sizeof(ufs_daddr_t); - INC_FINFO(sp); - sp->start_lbp = &sp->fip->fi_blocks[0]; - sp->vp = NULL; - sp->fip->fi_version = blkp->bi_version; - sp->fip->fi_nblocks = 0; - sp->fip->fi_ino = blkp->bi_inode; - lastino = blkp->bi_inode; - if (blkp->bi_inode == LFS_IFILE_INUM) - v_daddr = fs->lfs_idaddr; - else { - LFS_IENTRY(ifp, fs, blkp->bi_inode, bp); - v_daddr = ifp->if_daddr; - brelse(bp); - } - if (v_daddr == LFS_UNUSED_DADDR) - continue; - - /* Get the vnode/inode. */ - if (lfs_fastvget(mntp, blkp->bi_inode, v_daddr, &vp, - blkp->bi_lbn == LFS_UNUSED_LBN ? - blkp->bi_bp : NULL)) { -#ifdef DIAGNOSTIC - printf("lfs_markv: VFS_VGET failed (%ld)\n", - blkp->bi_inode); - panic("lfs_markv VFS_VGET FAILED"); -#endif - lastino = LFS_UNUSED_INUM; - v_daddr = LFS_UNUSED_DADDR; - continue; - } - sp->vp = vp; - ip = VTOI(vp); - } else if (v_daddr == LFS_UNUSED_DADDR) - continue; - - /* If this BLOCK_INFO didn't contain a block, keep going. */ - if (blkp->bi_lbn == LFS_UNUSED_LBN) - continue; - if (VOP_BMAP(vp, blkp->bi_lbn, NULL, &b_daddr, NULL, NULL) || - b_daddr != blkp->bi_daddr) - continue; - /* - * If we got to here, then we are keeping the block. If it - * is an indirect block, we want to actually put it in the - * buffer cache so that it can be updated in the finish_meta - * section. If it's not, we need to allocate a fake buffer - * so that writeseg can perform the copyin and write the buffer. - */ - if (blkp->bi_lbn >= 0) /* Data Block */ - bp = lfs_fakebuf(vp, blkp->bi_lbn, bsize, - blkp->bi_bp); - else { - bp = getblk(vp, blkp->bi_lbn, bsize, 0, 0); - if (!(bp->b_flags & (B_DELWRI | B_DONE | B_CACHE)) && - (error = copyin(blkp->bi_bp, bp->b_data, - blkp->bi_size))) - goto err2; - if (error = VOP_BWRITE(bp)) - goto err2; - } - while (lfs_gatherblock(sp, bp, NULL)); - } - if (sp->vp) { - if (sp->fip->fi_nblocks == 0) { - DEC_FINFO(sp); - sp->sum_bytes_left += - sizeof(FINFO) - sizeof(ufs_daddr_t); - } else - lfs_updatemeta(sp); - - lfs_writeinode(fs, sp, ip); - lfs_vunref(vp); - } - (void) lfs_writeseg(fs, sp); - lfs_segunlock(fs); - free(start, M_SEGMENT); - return (error); - -/* - * XXX - * If we come in to error 2, we might have indirect blocks that were - * updated and now have bad block pointers. I don't know what to do - * about this. - */ - -err2: lfs_vunref(vp); - /* Free up fakebuffers */ - for (bpp = --sp->cbpp; bpp >= sp->bpp; --bpp) - if ((*bpp)->b_flags & B_CALL) { - relpbuf(*bpp); - } else - brelse(*bpp); - lfs_segunlock(fs); -err1: - free(start, M_SEGMENT); - return (error); -} - -/* - * lfs_bmapv: - * - * This will fill in the current disk address for arrays of blocks. - * - * 0 on success - * -1/errno is return on error. - */ -#ifndef _SYS_SYSPROTO_H_ -struct lfs_bmapv_args { - fsid_t *fsidp; /* file system */ - BLOCK_INFO *blkiov; /* block array */ - int blkcnt; /* count of block array entries */ -}; -#endif -int -lfs_bmapv(p, uap) - struct proc *p; - struct lfs_bmapv_args *uap; -{ - BLOCK_INFO *blkp; - struct mount *mntp; - struct ufsmount *ump; - struct vnode *vp; - fsid_t fsid; - void *start; - ufs_daddr_t daddr; - int cnt, error, step; - - if (error = suser(p->p_ucred, &p->p_acflag)) - return (error); - - if (error = copyin(uap->fsidp, &fsid, sizeof(fsid_t))) - return (error); - if ((mntp = vfs_getvfs(&fsid)) == NULL) - return (EINVAL); - - cnt = uap->blkcnt; - start = blkp = malloc(cnt * sizeof(BLOCK_INFO), M_SEGMENT, M_WAITOK); - if (error = copyin(uap->blkiov, blkp, cnt * sizeof(BLOCK_INFO))) { - free(blkp, M_SEGMENT); - return (error); - } - - for (step = cnt; step--; ++blkp) { - if (blkp->bi_lbn == LFS_UNUSED_LBN) - continue; - /* - * A regular call to VFS_VGET could deadlock - * here. Instead, we try an unlocked access. - */ - ump = VFSTOUFS(mntp); - if ((vp = - ufs_ihashlookup(ump->um_dev, blkp->bi_inode)) != NULL) { - if (VOP_BMAP(vp, blkp->bi_lbn, NULL, &daddr, NULL, NULL)) - daddr = LFS_UNUSED_DADDR; - } else if (VFS_VGET(mntp, blkp->bi_inode, &vp)) - daddr = LFS_UNUSED_DADDR; - else { - if (VOP_BMAP(vp, blkp->bi_lbn, NULL, &daddr, NULL, NULL)) - daddr = LFS_UNUSED_DADDR; - vput(vp); - } - blkp->bi_daddr = daddr; - } - copyout(start, uap->blkiov, cnt * sizeof(BLOCK_INFO)); - free(start, M_SEGMENT); - return (0); -} - -/* - * lfs_segclean: - * - * Mark the segment clean. - * - * 0 on success - * -1/errno is return on error. - */ -#ifndef _SYS_SYSPROTO_H_ -struct lfs_segclean_args { - fsid_t *fsidp; /* file system */ - u_long segment; /* segment number */ -}; -#endif -int -lfs_segclean(p, uap) - struct proc *p; - struct lfs_segclean_args *uap; -{ - CLEANERINFO *cip; - SEGUSE *sup; - struct buf *bp; - struct mount *mntp; - struct lfs *fs; - fsid_t fsid; - int error; - - if (error = suser(p->p_ucred, &p->p_acflag)) - return (error); - - if (error = copyin(uap->fsidp, &fsid, sizeof(fsid_t))) - return (error); - if ((mntp = vfs_getvfs(&fsid)) == NULL) - return (EINVAL); - - fs = VFSTOUFS(mntp)->um_lfs; - - if (datosn(fs, fs->lfs_curseg) == uap->segment) - return (EBUSY); - - LFS_SEGENTRY(sup, fs, uap->segment, bp); - if (sup->su_flags & SEGUSE_ACTIVE) { - brelse(bp); - return (EBUSY); - } - fs->lfs_avail += fsbtodb(fs, fs->lfs_ssize) - 1; - fs->lfs_bfree += (sup->su_nsums * LFS_SUMMARY_SIZE / DEV_BSIZE) + - sup->su_ninos * btodb(fs->lfs_bsize); - sup->su_flags &= ~SEGUSE_DIRTY; - (void) VOP_BWRITE(bp); - - LFS_CLEANERINFO(cip, fs, bp); - ++cip->clean; - --cip->dirty; - (void) VOP_BWRITE(bp); - wakeup(&fs->lfs_avail); - return (0); -} - -/* - * lfs_segwait: - * - * This will block until a segment in file system fsid is written. A timeout - * in milliseconds may be specified which will awake the cleaner automatically. - * An fsid of -1 means any file system, and a timeout of 0 means forever. - * - * 0 on success - * 1 on timeout - * -1/errno is return on error. - */ -#ifndef _SYS_SYSPROTO_H_ -struct lfs_segwait_args { - fsid_t *fsidp; /* file system */ - struct timeval *tv; /* timeout */ -}; -#endif -int -lfs_segwait(p, uap) - struct proc *p; - struct lfs_segwait_args *uap; -{ - struct mount *mntp; - struct timeval atv; - fsid_t fsid; - void *addr; - u_long timeout; - int error, s; - - if (error = suser(p->p_ucred, &p->p_acflag)) { - return (error); -} -#ifdef WHEN_QUADS_WORK - if (error = copyin(uap->fsidp, &fsid, sizeof(fsid_t))) - return (error); - if (fsid == (fsid_t)-1) - addr = &lfs_allclean_wakeup; - else { - if ((mntp = vfs_getvfs(&fsid)) == NULL) - return (EINVAL); - addr = &VFSTOUFS(mntp)->um_lfs->lfs_nextseg; - } -#else - if (error = copyin(uap->fsidp, &fsid, sizeof(fsid_t))) - return (error); - if ((mntp = vfs_getvfs(&fsid)) == NULL) - addr = &lfs_allclean_wakeup; - else - addr = &VFSTOUFS(mntp)->um_lfs->lfs_nextseg; -#endif - - if (uap->tv) { - if (error = copyin(uap->tv, &atv, sizeof(struct timeval))) - return (error); - if (itimerfix(&atv)) - return (EINVAL); - s = splclock(); - timevaladd(&atv, &time); - timeout = hzto(&atv); - splx(s); - } else - timeout = 0; - - error = tsleep(addr, PCATCH | PUSER, "segment", timeout); - return (error == ERESTART ? EINTR : 0); -} - -/* - * VFS_VGET call specialized for the cleaner. The cleaner already knows the - * daddr from the ifile, so don't look it up again. If the cleaner is - * processing IINFO structures, it may have the ondisk inode already, so - * don't go retrieving it again. - */ -static int -lfs_fastvget(mp, ino, daddr, vpp, dinp) - struct mount *mp; - ino_t ino; - ufs_daddr_t daddr; - struct vnode **vpp; - struct dinode *dinp; -{ - register struct inode *ip; - struct vnode *vp; - struct ufsmount *ump; - struct buf *bp; - dev_t dev; - int error; - - ump = VFSTOUFS(mp); - dev = ump->um_dev; - /* - * This is playing fast and loose. Someone may have the inode - * locked, in which case they are going to be distinctly unhappy - * if we trash something. - */ - if ((*vpp = ufs_ihashlookup(dev, ino)) != NULL) { - lfs_vref(*vpp); - if ((*vpp)->v_flag & VXLOCK) - clean_vnlocked++; - ip = VTOI(*vpp); - if (lockstatus(&ip->i_lock)) - clean_inlocked++; - if (!(ip->i_flag & IN_MODIFIED)) - ++ump->um_lfs->lfs_uinodes; - ip->i_flag |= IN_MODIFIED; - return (0); - } - - /* Allocate new vnode/inode. */ - if (error = lfs_vcreate(mp, ino, &vp)) { - *vpp = NULL; - return (error); - } - - /* - * Put it onto its hash chain and lock it so that other requests for - * this inode will block if they arrive while we are sleeping waiting - * for old data structures to be purged or for the contents of the - * disk portion of this inode to be read. - */ - ip = VTOI(vp); - ufs_ihashins(ip); - - /* - * XXX - * This may not need to be here, logically it should go down with - * the i_devvp initialization. - * Ask Kirk. - */ - ip->i_lfs = ump->um_lfs; - - /* Read in the disk contents for the inode, copy into the inode. */ - if (dinp) - if (error = copyin(dinp, &ip->i_din, sizeof(struct dinode))) - return (error); - else { - if (error = bread(ump->um_devvp, daddr, - (int)ump->um_lfs->lfs_bsize, NOCRED, &bp)) { - /* - * The inode does not contain anything useful, so it - * would be misleading to leave it on its hash chain. - * Iput() will return it to the free list. - */ - ufs_ihashrem(ip); - - /* Unlock and discard unneeded inode. */ - lfs_vunref(vp); - brelse(bp); - *vpp = NULL; - return (error); - } - ip->i_din = - *lfs_ifind(ump->um_lfs, ino, (struct dinode *)bp->b_data); - brelse(bp); - } - - /* - * Initialize the vnode from the inode, check for aliases. In all - * cases re-init ip, the underlying vnode/inode may have changed. - */ - if (error = ufs_vinit(mp, lfs_specop_p, LFS_FIFOOPS, &vp)) { - lfs_vunref(vp); - *vpp = NULL; - return (error); - } - /* - * Finish inode initialization now that aliasing has been resolved. - */ - ip->i_devvp = ump->um_devvp; - ip->i_flag |= IN_MODIFIED; - ++ump->um_lfs->lfs_uinodes; - VREF(ip->i_devvp); - *vpp = vp; - return (0); -} -static struct buf * -lfs_fakebuf(vp, lbn, size, uaddr) - struct vnode *vp; - int lbn; - size_t size; - caddr_t uaddr; -{ - struct buf *bp; - - bp = lfs_newbuf(vp, lbn, 0); - bp->b_saveaddr = uaddr; - bp->b_bufsize = size; - bp->b_bcount = size; - bp->b_flags |= B_INVAL; - return (bp); -} - - diff --git a/sys/ufs/lfs/lfs_vfsops.c b/sys/ufs/lfs/lfs_vfsops.c deleted file mode 100644 index 4fc5c0ff3be7..000000000000 --- a/sys/ufs/lfs/lfs_vfsops.c +++ /dev/null @@ -1,737 +0,0 @@ -/* - * Copyright (c) 1989, 1991, 1993, 1994 - * The Regents of the University of California. 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. - * 3. All advertising materials mentioning features or use of this software - * must display the following acknowledgement: - * This product includes software developed by the University of - * California, Berkeley and its contributors. - * 4. Neither the name of the University nor the names of its contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``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 THE REGENTS OR CONTRIBUTORS 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. - * - * @(#)lfs_vfsops.c 8.20 (Berkeley) 6/10/95 - * $Id: lfs_vfsops.c,v 1.26 1997/10/16 20:32:37 phk Exp $ - */ - -#include "opt_quota.h" - -#include <sys/param.h> -#include <sys/systm.h> -#include <sys/namei.h> -#include <sys/proc.h> -#include <sys/kernel.h> -#include <sys/vnode.h> -#include <sys/malloc.h> -#include <sys/mount.h> -#include <sys/buf.h> -#include <sys/fcntl.h> -#include <sys/disklabel.h> - -#include <miscfs/specfs/specdev.h> - -#include <ufs/ufs/quota.h> -#include <ufs/ufs/inode.h> -#include <ufs/ufs/ufsmount.h> -#include <ufs/ufs/ufs_extern.h> - -#include <ufs/lfs/lfs.h> -#include <ufs/lfs/lfs_extern.h> - -MALLOC_DEFINE(M_LFSNODE, "LFS node", "LFS vnode private part"); -MALLOC_DEFINE(M_SEGMENT, "LFS segment", "Segment for LFS"); - -static int lfs_fhtovp __P((struct mount *, struct fid *, struct sockaddr *, - struct vnode **, int *, struct ucred **)); -static int lfs_mount __P((struct mount *, char *, caddr_t, - struct nameidata *, struct proc *)); -static int lfs_mountfs __P((struct vnode *, struct mount *, struct proc *)); -static int lfs_statfs __P((struct mount *, struct statfs *, struct proc *)); -static int lfs_sync __P((struct mount *, int, struct ucred *, struct proc *)); -static int lfs_unmount __P((struct mount *, int, struct proc *)); -static int lfs_vget __P((struct mount *, ino_t, struct vnode **)); -static int lfs_vptofh __P((struct vnode *, struct fid *)); - -struct vfsops lfs_vfsops = { - lfs_mount, - ufs_start, - lfs_unmount, - ufs_root, - ufs_quotactl, - lfs_statfs, - lfs_sync, - lfs_vget, - lfs_fhtovp, - lfs_vptofh, - lfs_init, -#ifdef notyet - lfs_sysctl, -#endif -}; - -VFS_SET(lfs_vfsops, lfs, MOUNT_LFS, 0); - -/* - * Called by main() when ufs is going to be mounted as root. - */ -int -lfs_mountroot() -{ - struct fs *fs; - struct mount *mp; - struct proc *p = curproc; /* XXX */ - int error; - - if ((error = bdevvp(rootdev, &rootvp))) { - printf("lfs_mountroot: can't find rootvp"); - return (error); - } - if (error = vfs_rootmountalloc("lfs", "root_device", &mp)) - return (error); - if (error = lfs_mountfs(rootvp, mp, p)) { - mp->mnt_vfc->vfc_refcount--; - vfs_unbusy(mp, p); - free(mp, M_MOUNT); - return (error); - } - simple_lock(&mountlist_slock); - CIRCLEQ_INSERT_HEAD(&mountlist, mp, mnt_list); - simple_unlock(&mountlist_slock); - (void)lfs_statfs(mp, &mp->mnt_stat, p); - vfs_unbusy(mp, p); - return (0); -} - -/* - * lfs_mount - * - * Called when mounting local physical media - * - * PARAMETERS: - * mountroot - * mp mount point structure - * path NULL (flag for root mount!!!) - * data <unused> - * ndp <unused> - * p process (user credentials check [statfs]) - * - * mount - * mp mount point structure - * path path to mount point - * data pointer to argument struct in user space - * ndp mount point namei() return (used for - * credentials on reload), reused to look - * up block device. - * p process (user credentials check) - * - * RETURNS: 0 Success - * !0 error number (errno.h) - * - * LOCK STATE: - * - * ENTRY - * mount point is locked - * EXIT - * mount point is locked - * - * NOTES: - * A NULL path can be used for a flag since the mount - * system call will fail with EFAULT in copyinstr in - * namei() if it is a genuine NULL from the user. - * - * Root mounts are not currently supported. - */ -static int -lfs_mount(mp, path, data, ndp, p) - register struct mount *mp; - char *path; - caddr_t data; - struct nameidata *ndp; - struct proc *p; -{ - struct vnode *devvp; - struct ufs_args args; - struct ufsmount *ump = 0; - register struct lfs *fs; /* LFS */ - u_int size; - int err; - mode_t accessmode; - - /* - * Use NULL path to flag a root mount - */ - if( path == NULL) { - /* - *** - * Mounting root file system - *** - */ - - /* XXX -- implement*/ - panic("lfs_mount: NULL path not implemented"); - } - - /* - *** - * Mounting non-root file system or updating a file system - *** - */ - - /* copy in user arguments*/ - if (err = copyin(data, (caddr_t)&args, sizeof (struct ufs_args))) - goto error_1; - - /* Until LFS can do NFS right. XXX */ - if (args.export.ex_flags & MNT_EXPORTED) { - err = EINVAL; - goto error_1; - } - - /* - * If updating, check whether changing from read-only to - * read/write; if there is no device name, that's all we do. - */ - if (mp->mnt_flag & MNT_UPDATE) { - ump = VFSTOUFS(mp); - if (fs->lfs_ronly && (mp->mnt_kern_flag & MNTK_WANTRDWR)) { - /* - * If upgrade to read-write by non-root, then verify - * that user has necessary permissions on the device. - */ - if (p->p_ucred->cr_uid != 0) { - vn_lock(ump->um_devvp, LK_EXCLUSIVE | LK_RETRY, - p); - if (err = VOP_ACCESS(ump->um_devvp, - VREAD | VWRITE, p->p_ucred, p)) { - VOP_UNLOCK(ump->um_devvp, 0, p); - return (err); - } - VOP_UNLOCK(ump->um_devvp, 0, p); - } - fs->lfs_ronly = 0; - } - if (args.fspec == 0) { - /* - * Process export requests. Jumping to "success" - * will return the vfs_export() error code. - */ - err = vfs_export(mp, &ump->um_export, &args.export); - goto success; - } - } - /* - * Not an update, or updating the name: look up the name - * and verify that it refers to a sensible block device. - */ - NDINIT(ndp, LOOKUP, FOLLOW, UIO_USERSPACE, args.fspec, p); - if (err = namei(ndp)) - goto error_1; - devvp = ndp->ni_vp; - if (devvp->v_type != VBLK) { - err = ENOTBLK; - goto error_2; - } - if (major(devvp->v_rdev) >= nblkdev) { - err = ENXIO; - goto error_2; - } - /* - * If mount by non-root, then verify that user has necessary - * permissions on the device. - */ - if (p->p_ucred->cr_uid != 0) { - accessmode = VREAD; - if ((mp->mnt_flag & MNT_RDONLY) == 0) - accessmode |= VWRITE; - vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY, p); - if (err = VOP_ACCESS(devvp, accessmode, p->p_ucred, p)) { - vput(devvp); - return (err); - } - VOP_UNLOCK(devvp, 0, p); - } - if ((mp->mnt_flag & MNT_UPDATE) == 0) - err = lfs_mountfs(devvp, mp, p); /* LFS */ - else { - if (devvp != ump->um_devvp) - err = EINVAL; /* needs translation */ - else - vrele(devvp); - } - if (err) { - goto error_2; - } - ump = VFSTOUFS(mp); - fs = ump->um_lfs; /* LFS */ -#ifdef NOTLFS /* LFS */ - (void) copyinstr(path, fs->fs_fsmnt, sizeof(fs->fs_fsmnt) - 1, &size); - bzero(fs->fs_fsmnt + size, sizeof(fs->fs_fsmnt) - size); - bcopy((caddr_t)fs->fs_fsmnt, (caddr_t)mp->mnt_stat.f_mntonname, - MNAMELEN); - (void) copyinstr(args.fspec, mp->mnt_stat.f_mntfromname, MNAMELEN - 1, - &size); - bzero(mp->mnt_stat.f_mntfromname + size, MNAMELEN - size); - (void) ufs_statfs(mp, &mp->mnt_stat, p); -#else - (void)copyinstr(path, fs->lfs_fsmnt, sizeof(fs->lfs_fsmnt) - 1, &size); - bzero(fs->lfs_fsmnt + size, sizeof(fs->lfs_fsmnt) - size); - bcopy((caddr_t)fs->lfs_fsmnt, (caddr_t)mp->mnt_stat.f_mntonname, - MNAMELEN); - (void) copyinstr(args.fspec, mp->mnt_stat.f_mntfromname, MNAMELEN - 1, - &size); - bzero(mp->mnt_stat.f_mntfromname + size, MNAMELEN - size); - (void) lfs_statfs(mp, &mp->mnt_stat, p); -#endif - - - -error_2: /* error with devvp held*/ - - /* release devvp before failing*/ - vrele(devvp); - -error_1: /* no state to back out*/ - -success: - return( err); -} - -/* - * Common code for mount and mountroot - * LFS specific - */ -static int -lfs_mountfs(devvp, mp, p) - register struct vnode *devvp; - struct mount *mp; - struct proc *p; -{ - register struct lfs *fs; - register struct ufsmount *ump; - struct vnode *vp; - struct buf *bp; - struct partinfo dpart; - dev_t dev; - int error, i, ronly, size; - struct ucred *cred; - - cred = p ? p->p_ucred : NOCRED; - /* - * Disallow multiple mounts of the same device. - * Disallow mounting of a device that is currently in use - * (except for root, which might share swap device for miniroot). - * Flush out any old buffers remaining from a previous use. - */ - if (error = vfs_mountedon(devvp)) - return (error); - if (vcount(devvp) > 1 && devvp != rootvp) - return (EBUSY); - if (error = vinvalbuf(devvp, V_SAVE, cred, p, 0, 0)) - return (error); - - ronly = (mp->mnt_flag & MNT_RDONLY) != 0; - if (error = VOP_OPEN(devvp, ronly ? FREAD : FREAD|FWRITE, FSCRED, p)) - return (error); - - if (VOP_IOCTL(devvp, DIOCGPART, (caddr_t)&dpart, FREAD, cred, p) != 0) - size = DEV_BSIZE; - else { - size = dpart.disklab->d_secsize; -#ifdef NEVER_USED - dpart.part->p_fstype = FS_LFS; - dpart.part->p_fsize = fs->lfs_fsize; /* frag size */ - dpart.part->p_frag = fs->lfs_frag; /* frags per block */ - dpart.part->p_cpg = fs->lfs_segshift; /* segment shift */ -#endif - } - - /* Don't free random space on error. */ - bp = NULL; - ump = NULL; - - /* Read in the superblock. */ - if (error = bread(devvp, LFS_LABELPAD / size, LFS_SBPAD, cred, &bp)) - goto out; - fs = (struct lfs *)bp->b_data; - - /* Check the basics. */ - if (fs->lfs_magic != LFS_MAGIC || fs->lfs_bsize > MAXBSIZE || - fs->lfs_bsize < sizeof(struct lfs)) { - error = EINVAL; /* XXX needs translation */ - goto out; - } - - /* Allocate the mount structure, copy the superblock into it. */ - ump = (struct ufsmount *)malloc(sizeof *ump, M_UFSMNT, M_WAITOK); - bzero(ump, sizeof *ump); - ump->um_malloctype = M_LFSNODE; - ump->um_blkatoff = lfs_blkatoff; - ump->um_truncate = lfs_truncate; - ump->um_update = lfs_update; - ump->um_valloc = lfs_valloc; - ump->um_vfree = lfs_vfree; - fs = ump->um_lfs = malloc(sizeof(struct lfs), M_UFSMNT, M_WAITOK); - bcopy(bp->b_data, fs, sizeof(struct lfs)); - if (sizeof(struct lfs) < LFS_SBPAD) /* XXX why? */ - bp->b_flags |= B_INVAL; - brelse(bp); - bp = NULL; - - /* Set up the I/O information */ - fs->lfs_iocount = 0; - - /* Set up the ifile and lock aflags */ - fs->lfs_doifile = 0; - fs->lfs_writer = 0; - fs->lfs_dirops = 0; - fs->lfs_seglock = 0; - - /* Set the file system readonly/modify bits. */ - fs->lfs_ronly = ronly; - if (ronly == 0) - fs->lfs_fmod = 1; - - /* Initialize the mount structure. */ - dev = devvp->v_rdev; - mp->mnt_data = (qaddr_t)ump; - mp->mnt_stat.f_fsid.val[0] = (long)dev; - mp->mnt_stat.f_fsid.val[1] = lfs_mount_type; - mp->mnt_maxsymlinklen = fs->lfs_maxsymlinklen; - mp->mnt_flag |= MNT_LOCAL; - ump->um_mountp = mp; - ump->um_dev = dev; - ump->um_devvp = devvp; - ump->um_bptrtodb = 0; - ump->um_seqinc = 1 << fs->lfs_fsbtodb; - ump->um_nindir = fs->lfs_nindir; - for (i = 0; i < MAXQUOTAS; i++) - ump->um_quotas[i] = NULLVP; - devvp->v_specflags |= SI_MOUNTEDON; - - /* - * We use the ifile vnode for almost every operation. Instead of - * retrieving it from the hash table each time we retrieve it here, - * artificially increment the reference count and keep a pointer - * to it in the incore copy of the superblock. - */ - if (error = VFS_VGET(mp, LFS_IFILE_INUM, &vp)) - goto out; - fs->lfs_ivnode = vp; - VREF(vp); - vput(vp); - - return (0); -out: - if (bp) - brelse(bp); - (void)VOP_CLOSE(devvp, ronly ? FREAD : FREAD|FWRITE, cred, p); - if (ump) { - free(ump->um_lfs, M_UFSMNT); - free(ump, M_UFSMNT); - mp->mnt_data = (qaddr_t)0; - } - return (error); -} - -/* - * unmount system call - */ -static int -lfs_unmount(mp, mntflags, p) - struct mount *mp; - int mntflags; - struct proc *p; -{ - register struct ufsmount *ump; - register struct lfs *fs; - int i, error, flags, ronly; - - flags = 0; - if (mntflags & MNT_FORCE) - flags |= FORCECLOSE; - - ump = VFSTOUFS(mp); - fs = ump->um_lfs; -#ifdef QUOTA - if (mp->mnt_flag & MNT_QUOTA) { - if (error = vflush(mp, fs->lfs_ivnode, SKIPSYSTEM|flags)) - return (error); - for (i = 0; i < MAXQUOTAS; i++) { - if (ump->um_quotas[i] == NULLVP) - continue; - quotaoff(p, mp, i); - } - /* - * Here we fall through to vflush again to ensure - * that we have gotten rid of all the system vnodes. - */ - } -#endif - if (error = vflush(mp, fs->lfs_ivnode, flags)) - return (error); - fs->lfs_clean = 1; - if (error = VFS_SYNC(mp, 1, p->p_ucred, p)) - return (error); - if (fs->lfs_ivnode->v_dirtyblkhd.lh_first) - panic("lfs_unmount: still dirty blocks on ifile vnode"); - vrele(fs->lfs_ivnode); - vgone(fs->lfs_ivnode); - - ronly = fs->lfs_ronly; - ump->um_devvp->v_specflags &= ~SI_MOUNTEDON; - error = VOP_CLOSE(ump->um_devvp, - ronly ? FREAD : FREAD|FWRITE, NOCRED, p); - vrele(ump->um_devvp); - free(fs, M_UFSMNT); - free(ump, M_UFSMNT); - mp->mnt_data = (qaddr_t)0; - mp->mnt_flag &= ~MNT_LOCAL; - return (error); -} - -/* - * Get file system statistics. - */ -static int -lfs_statfs(mp, sbp, p) - struct mount *mp; - register struct statfs *sbp; - struct proc *p; -{ - register struct lfs *fs; - register struct ufsmount *ump; - - ump = VFSTOUFS(mp); - fs = ump->um_lfs; - if (fs->lfs_magic != LFS_MAGIC) - panic("lfs_statfs: magic"); - sbp->f_bsize = fs->lfs_fsize; - sbp->f_iosize = fs->lfs_bsize; - sbp->f_blocks = dbtofrags(fs,fs->lfs_dsize); - sbp->f_bfree = dbtofrags(fs, fs->lfs_bfree); - /* - * To compute the available space. Subtract the minimum free - * from the total number of blocks in the file system. Set avail - * to the smaller of this number and fs->lfs_bfree. - */ - sbp->f_bavail = fs->lfs_dsize * (100 - fs->lfs_minfree) / 100; - sbp->f_bavail = - sbp->f_bavail > fs->lfs_bfree ? fs->lfs_bfree : sbp->f_bavail; - sbp->f_bavail = dbtofrags(fs, sbp->f_bavail); - sbp->f_files = fs->lfs_nfiles; - sbp->f_ffree = sbp->f_bfree * INOPB(fs); - if (sbp != &mp->mnt_stat) { - sbp->f_type = mp->mnt_vfc->vfc_typenum; - bcopy((caddr_t)mp->mnt_stat.f_mntonname, - (caddr_t)&sbp->f_mntonname[0], MNAMELEN); - bcopy((caddr_t)mp->mnt_stat.f_mntfromname, - (caddr_t)&sbp->f_mntfromname[0], MNAMELEN); - } - return (0); -} - -/* - * Go through the disk queues to initiate sandbagged IO; - * go through the inodes to write those that have been modified; - * initiate the writing of the super block if it has been modified. - * - * Note: we are always called with the filesystem marked `MPBUSY'. - */ -static int -lfs_sync(mp, waitfor, cred, p) - struct mount *mp; - int waitfor; - struct ucred *cred; - struct proc *p; -{ - int error; - - /* All syncs must be checkpoints until roll-forward is implemented. */ - error = lfs_segwrite(mp, SEGM_CKP | (waitfor ? SEGM_SYNC : 0)); -#ifdef QUOTA - qsync(mp); -#endif - return (error); -} - -/* - * Look up an LFS dinode number to find its incore vnode. If not already - * in core, read it in from the specified device. Return the inode locked. - * Detection and handling of mount points must be done by the calling routine. - */ -static int -lfs_vget(mp, ino, vpp) - struct mount *mp; - ino_t ino; - struct vnode **vpp; -{ - register struct lfs *fs; - register struct inode *ip; - struct buf *bp; - struct ifile *ifp; - struct vnode *vp; - struct ufsmount *ump; - ufs_daddr_t daddr; - dev_t dev; - int error; - - ump = VFSTOUFS(mp); - dev = ump->um_dev; - if ((*vpp = ufs_ihashget(dev, ino)) != NULL) - return (0); - - /* Translate the inode number to a disk address. */ - fs = ump->um_lfs; - if (ino == LFS_IFILE_INUM) - daddr = fs->lfs_idaddr; - else { - LFS_IENTRY(ifp, fs, ino, bp); - daddr = ifp->if_daddr; - brelse(bp); - if (daddr == LFS_UNUSED_DADDR) - return (ENOENT); - } - - /* Allocate new vnode/inode. */ - if (error = lfs_vcreate(mp, ino, &vp)) { - *vpp = NULL; - return (error); - } - - /* - * Put it onto its hash chain and lock it so that other requests for - * this inode will block if they arrive while we are sleeping waiting - * for old data structures to be purged or for the contents of the - * disk portion of this inode to be read. - */ - ip = VTOI(vp); - ufs_ihashins(ip); - - /* - * XXX - * This may not need to be here, logically it should go down with - * the i_devvp initialization. - * Ask Kirk. - */ - ip->i_lfs = ump->um_lfs; - - /* Read in the disk contents for the inode, copy into the inode. */ - if (error = - bread(ump->um_devvp, daddr, (int)fs->lfs_bsize, NOCRED, &bp)) { - /* - * The inode does not contain anything useful, so it would - * be misleading to leave it on its hash chain. With mode - * still zero, it will be unlinked and returned to the free - * list by vput(). - */ - vput(vp); - brelse(bp); - *vpp = NULL; - return (error); - } - ip->i_din = *lfs_ifind(fs, ino, (struct dinode *)bp->b_data); - brelse(bp); - - /* - * Initialize the vnode from the inode, check for aliases. In all - * cases re-init ip, the underlying vnode/inode may have changed. - */ - if (error = ufs_vinit(mp, lfs_specop_p, LFS_FIFOOPS, &vp)) { - vput(vp); - *vpp = NULL; - return (error); - } - /* - * Finish inode initialization now that aliasing has been resolved. - */ - ip->i_devvp = ump->um_devvp; - VREF(ip->i_devvp); - *vpp = vp; - return (0); -} - -/* - * File handle to vnode - * - * Have to be really careful about stale file handles: - * - check that the inode number is valid - * - call lfs_vget() to get the locked inode - * - check for an unallocated inode (i_mode == 0) - * - check that the given client host has export rights and return - * those rights via. exflagsp and credanonp - * - * XXX - * use ifile to see if inode is allocated instead of reading off disk - * what is the relationship between my generational number and the NFS - * generational number. - */ -static int -lfs_fhtovp(mp, fhp, nam, vpp, exflagsp, credanonp) - register struct mount *mp; - struct fid *fhp; - struct sockaddr *nam; - struct vnode **vpp; - int *exflagsp; - struct ucred **credanonp; -{ - register struct ufid *ufhp; - - ufhp = (struct ufid *)fhp; - if (ufhp->ufid_ino < ROOTINO) - return (ESTALE); - return (ufs_check_export(mp, ufhp, nam, vpp, exflagsp, credanonp)); -} - -/* - * Vnode pointer to File handle - */ -/* ARGSUSED */ -static int -lfs_vptofh(vp, fhp) - struct vnode *vp; - struct fid *fhp; -{ - register struct inode *ip; - register struct ufid *ufhp; - - ip = VTOI(vp); - ufhp = (struct ufid *)fhp; - ufhp->ufid_len = sizeof(struct ufid); - ufhp->ufid_ino = ip->i_number; - ufhp->ufid_gen = ip->i_gen; - return (0); -} - -/* - * Initialize the filesystem, most work done by ufs_init. - */ -int lfs_mount_type; - -int -lfs_init(vfsp) - struct vfsconf *vfsp; -{ - - lfs_mount_type = vfsp->vfc_typenum; - return (ufs_init(vfsp)); -} diff --git a/sys/ufs/lfs/lfs_vnops.c b/sys/ufs/lfs/lfs_vnops.c deleted file mode 100644 index 12da60f67e44..000000000000 --- a/sys/ufs/lfs/lfs_vnops.c +++ /dev/null @@ -1,232 +0,0 @@ -/* - * Copyright (c) 1986, 1989, 1991, 1993, 1995 - * The Regents of the University of California. 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. - * 3. All advertising materials mentioning features or use of this software - * must display the following acknowledgement: - * This product includes software developed by the University of - * California, Berkeley and its contributors. - * 4. Neither the name of the University nor the names of its contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``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 THE REGENTS OR CONTRIBUTORS 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. - * - * @(#)lfs_vnops.c 8.13 (Berkeley) 6/10/95 - * $Id: lfs_vnops.c,v 1.29 1997/10/16 20:32:37 phk Exp $ - */ - -#include <sys/param.h> -#include <sys/systm.h> -#include <sys/resourcevar.h> -#include <sys/signalvar.h> -#include <sys/kernel.h> -#include <sys/stat.h> -#include <sys/buf.h> -#include <sys/proc.h> -#include <sys/mount.h> -#include <sys/vnode.h> - -#include <vm/vm.h> -#include <vm/vm_prot.h> -#include <vm/vm_page.h> -#include <vm/vm_extern.h> - -#include <ufs/ufs/quota.h> -#include <ufs/ufs/inode.h> -#include <ufs/ufs/ufsmount.h> -#include <ufs/ufs/ufs_extern.h> - -#include <ufs/lfs/lfs.h> -#include <ufs/lfs/lfs_extern.h> - -static int lfs_close __P((struct vop_close_args *)); -static int lfs_fsync __P((struct vop_fsync_args *)); -static int lfs_getattr __P((struct vop_getattr_args *)); -static int lfs_inactive __P((struct vop_inactive_args *)); -static int lfs_read __P((struct vop_read_args *)); -static int lfs_write __P((struct vop_write_args *)); - - -/* Global vfs data structures for lfs. */ -vop_t **lfs_vnodeop_p; -static struct vnodeopv_entry_desc lfs_vnodeop_entries[] = { - { &vop_default_desc, (vop_t *) ufs_vnoperate }, - { &vop_bwrite_desc, (vop_t *) lfs_bwrite }, - { &vop_close_desc, (vop_t *) lfs_close }, - { &vop_fsync_desc, (vop_t *) lfs_fsync }, - { &vop_getattr_desc, (vop_t *) lfs_getattr }, - { &vop_read_desc, (vop_t *) lfs_read }, - { &vop_write_desc, (vop_t *) lfs_write }, - { &vop_lookup_desc, (vop_t *) ufs_lookup }, - { NULL, NULL } -}; -static struct vnodeopv_desc lfs_vnodeop_opv_desc = - { &lfs_vnodeop_p, lfs_vnodeop_entries }; - -vop_t **lfs_specop_p; -static struct vnodeopv_entry_desc lfs_specop_entries[] = { - { &vop_default_desc, (vop_t *) ufs_vnoperatespec }, - { &vop_bwrite_desc, (vop_t *) lfs_bwrite }, - { &vop_getattr_desc, (vop_t *) lfs_getattr }, - { NULL, NULL } -}; -static struct vnodeopv_desc lfs_specop_opv_desc = - { &lfs_specop_p, lfs_specop_entries }; - -vop_t **lfs_fifoop_p; -static struct vnodeopv_entry_desc lfs_fifoop_entries[] = { - { &vop_default_desc, (vop_t *) ufs_vnoperatefifo }, - { &vop_bwrite_desc, (vop_t *) lfs_bwrite }, - { &vop_getattr_desc, (vop_t *) lfs_getattr }, - { NULL, NULL } -}; -static struct vnodeopv_desc lfs_fifoop_opv_desc = - { &lfs_fifoop_p, lfs_fifoop_entries }; - -VNODEOP_SET(lfs_vnodeop_opv_desc); -VNODEOP_SET(lfs_specop_opv_desc); -VNODEOP_SET(lfs_fifoop_opv_desc); - -#define LFS_READWRITE -#include <ufs/ufs/ufs_readwrite.c> -#undef LFS_READWRITE - -/* - * Synch an open file. - */ -/* ARGSUSED */ -static int -lfs_fsync(ap) - struct vop_fsync_args /* { - struct vnode *a_vp; - struct ucred *a_cred; - int a_waitfor; - struct proc *a_p; - } */ *ap; -{ - struct timeval tv; - int error; - - gettime(&tv); - error = (UFS_UPDATE(ap->a_vp, &tv, &tv, - ap->a_waitfor == MNT_WAIT ? LFS_SYNC : 0)); - if(ap->a_waitfor == MNT_WAIT && ap->a_vp->v_dirtyblkhd.lh_first != NULL) - panic("lfs_fsync: dirty bufs"); - return( error ); -} - -/* - * These macros are used to bracket UFS directory ops, so that we can - * identify all the pages touched during directory ops which need to - * be ordered and flushed atomically, so that they may be recovered. - */ -#define SET_DIROP(fs) { \ - if ((fs)->lfs_writer) \ - tsleep(&(fs)->lfs_dirops, PRIBIO + 1, "lfs_dirop", 0); \ - ++(fs)->lfs_dirops; \ - (fs)->lfs_doifile = 1; \ -} - -#define SET_ENDOP(fs) { \ - --(fs)->lfs_dirops; \ - if (!(fs)->lfs_dirops) \ - wakeup(&(fs)->lfs_writer); \ -} - -#define MARK_VNODE(dvp) (dvp)->v_flag |= VDIROP - - -/* XXX hack to avoid calling ITIMES in getattr */ -static int -lfs_getattr(ap) - struct vop_getattr_args /* { - struct vnode *a_vp; - struct vattr *a_vap; - struct ucred *a_cred; - struct proc *a_p; - } */ *ap; -{ - register struct vnode *vp = ap->a_vp; - register struct inode *ip = VTOI(vp); - register struct vattr *vap = ap->a_vap; - /* - * Copy from inode table - */ - vap->va_fsid = ip->i_dev; - vap->va_fileid = ip->i_number; - vap->va_mode = ip->i_mode & ~IFMT; - vap->va_nlink = ip->i_nlink; - vap->va_uid = ip->i_uid; - vap->va_gid = ip->i_gid; - vap->va_rdev = (dev_t)ip->i_rdev; - vap->va_size = ip->i_din.di_size; - vap->va_atime.tv_sec = ip->i_atime; - vap->va_atime.tv_nsec = ip->i_atimensec; - vap->va_mtime.tv_sec = ip->i_mtime; - vap->va_mtime.tv_nsec = ip->i_mtimensec; - vap->va_ctime.tv_sec = ip->i_ctime; - vap->va_ctime.tv_nsec = ip->i_ctimensec; - vap->va_flags = ip->i_flags; - vap->va_gen = ip->i_gen; - /* this doesn't belong here */ - if (vp->v_type == VBLK) - vap->va_blocksize = BLKDEV_IOSIZE; - else if (vp->v_type == VCHR) - vap->va_blocksize = MAXBSIZE; - else - vap->va_blocksize = vp->v_mount->mnt_stat.f_iosize; - vap->va_bytes = dbtob(ip->i_blocks); - vap->va_type = vp->v_type; - vap->va_filerev = ip->i_modrev; - return (0); -} -/* - * Close called - * - * XXX -- we were using ufs_close, but since it updates the - * times on the inode, we might need to bump the uinodes - * count. - */ -/* ARGSUSED */ -static int -lfs_close(ap) - struct vop_close_args /* { - struct vnode *a_vp; - int a_fflag; - struct ucred *a_cred; - struct proc *a_p; - } */ *ap; -{ - register struct vnode *vp = ap->a_vp; - register struct inode *ip = VTOI(vp); - int mod; - - simple_lock(&vp->v_interlock); - if (vp->v_usecount > 1) { - mod = ip->i_flag & IN_MODIFIED; - ITIMES(ip, &time, &time); - if (!mod && ip->i_flag & IN_MODIFIED) - ip->i_lfs->lfs_uinodes++; - } - simple_unlock(&vp->v_interlock); - return (0); -} diff --git a/sys/ufs/ufs/inode.h b/sys/ufs/ufs/inode.h index 161de4bc9440..f2fd0f25fa5e 100644 --- a/sys/ufs/ufs/inode.h +++ b/sys/ufs/ufs/inode.h @@ -36,7 +36,7 @@ * SUCH DAMAGE. * * @(#)inode.h 8.9 (Berkeley) 5/14/95 - * $Id: inode.h,v 1.18 1997/10/17 12:36:19 phk Exp $ + * $Id: inode.h,v 1.19 1997/12/05 13:43:47 jkh Exp $ */ #ifndef _UFS_UFS_INODE_H_ @@ -70,11 +70,9 @@ struct inode { union { /* Associated filesystem. */ struct fs *fs; /* FFS */ - struct lfs *lfs; /* LFS */ struct ext2_sb_info *e2fs; /* EXT2FS */ } inode_u; #define i_fs inode_u.fs -#define i_lfs inode_u.lfs #define i_e2fs inode_u.e2fs struct dquot *i_dquot[MAXQUOTAS]; /* Dquot structures. */ u_quad_t i_modrev; /* Revision level for NFS lease. */ diff --git a/sys/ufs/ufs/ufs_readwrite.c b/sys/ufs/ufs/ufs_readwrite.c index e00c3c5aae02..395d6bd8714d 100644 --- a/sys/ufs/ufs/ufs_readwrite.c +++ b/sys/ufs/ufs/ufs_readwrite.c @@ -31,20 +31,9 @@ * SUCH DAMAGE. * * @(#)ufs_readwrite.c 8.11 (Berkeley) 5/8/95 - * $Id: ufs_readwrite.c,v 1.39 1998/01/06 05:24:04 dyson Exp $ + * $Id: ufs_readwrite.c,v 1.40 1998/01/22 17:30:22 dyson Exp $ */ -#ifdef LFS_READWRITE -#define BLKSIZE(a, b, c) blksize(a, b, c) -#define FS struct lfs -#define I_FS i_lfs -#define READ lfs_read -#define READ_S "lfs_read" -#define WRITE lfs_write -#define WRITE_S "lfs_write" -#define fs_bsize lfs_bsize -#define fs_maxfilesize lfs_maxfilesize -#else #define BLKSIZE(a, b, c) blksize(a, b, c) #define FS struct fs #define I_FS i_fs @@ -52,7 +41,6 @@ #define READ_S "ffs_read" #define WRITE ffs_write #define WRITE_S "ffs_write" -#endif #include <vm/vm.h> #include <vm/vm_object.h> @@ -147,11 +135,6 @@ READ(ap) if (bytesinfile < xfersize) xfersize = bytesinfile; -#ifdef LFS_READWRITE - (void)lfs_check(vp, lbn); - error = cluster_read(vp, ip->i_size, lbn, - size, NOCRED, uio->uio_resid, seqcount, &bp); -#else if (lblktosize(fs, nextlbn) >= ip->i_size) error = bread(vp, lbn, size, NOCRED, &bp); else if ((vp->v_mount->mnt_flag & MNT_NOCLUSTERR) == 0) @@ -163,7 +146,6 @@ READ(ap) size, &nextlbn, &nextsize, 1, NOCRED, &bp); } else error = bread(vp, lbn, size, NOCRED, &bp); -#endif if (error) { brelse(bp); bp = NULL; @@ -291,10 +273,6 @@ WRITE(ap) if (uio->uio_offset + xfersize > ip->i_size) vnode_pager_setsize(vp, uio->uio_offset + xfersize); -#ifdef LFS_READWRITE - (void)lfs_check(vp, lbn); - error = lfs_balloc(vp, blkoffset, xfersize, lbn, &bp); -#else if (fs->fs_bsize > xfersize) flags |= B_CLRBUF; else @@ -302,7 +280,6 @@ WRITE(ap) error = ffs_balloc(ip, lbn, blkoffset + xfersize, ap->a_cred, &bp, flags); -#endif if (error) break; @@ -325,9 +302,6 @@ WRITE(ap) error = uiomove((char *)bp->b_data + blkoffset, (int)xfersize, uio); -#ifdef LFS_READWRITE - (void)VOP_BWRITE(bp); -#else if (ioflag & IO_VMIO) bp->b_flags |= B_RELBUF; @@ -344,7 +318,6 @@ WRITE(ap) bp->b_flags |= B_CLUSTEROK; bdwrite(bp); } -#endif if (error || xfersize == 0) break; ip->i_flag |= IN_CHANGE | IN_UPDATE; @@ -373,7 +346,6 @@ WRITE(ap) return (error); } -#ifndef LFS_READWRITE /* * get page routine @@ -526,4 +498,3 @@ ffs_getpages(ap) return (rtval); } -#endif diff --git a/sys/ufs/ufs/ufsmount.h b/sys/ufs/ufs/ufsmount.h index ee7963190c89..c62b736034f5 100644 --- a/sys/ufs/ufs/ufsmount.h +++ b/sys/ufs/ufs/ufsmount.h @@ -31,7 +31,7 @@ * SUCH DAMAGE. * * @(#)ufsmount.h 8.6 (Berkeley) 3/30/95 - * $Id: ufsmount.h,v 1.11 1997/10/16 10:50:27 phk Exp $ + * $Id: ufsmount.h,v 1.12 1997/10/16 20:32:40 phk Exp $ */ #ifndef _UFS_UFS_UFSMOUNT_H_ @@ -77,12 +77,10 @@ struct ufsmount { struct vnode *um_devvp; /* block device mounted vnode */ union { /* pointer to superblock */ - struct lfs *lfs; /* LFS */ struct fs *fs; /* FFS */ struct ext2_sb_info *e2fs; /* EXT2FS */ } ufsmount_u; #define um_fs ufsmount_u.fs -#define um_lfs ufsmount_u.lfs #define um_e2fs ufsmount_u.e2fs #define um_e2fsb ufsmount_u.e2fs->s_es |