d/freebsd-dev
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
9feff969a0
freebsd-dev/sys/tools/vnode_if.awk

520 lines
14 KiB
Awk
Raw Normal View History

Return vnode_if back to its AWK roots. It became a Perl script in rev 1.20. This removes one more dependence on perl for the kernel build.
2002-03-01 01:20:23 +00:00
#!/usr/bin/awk -f
Update this to be able to output ASSERT_VOP_(UN)LOCKED() based on the lock specifications in kern/vnode_if.src. At present, this do not distinguish between exclusive and shared locks, and the kernel is so full of bugs in this area that running with auto-generation of assertions enabled makes DEBUG_VFS_LOCKS totally useless for anybody that has used it for anything prior to outputting automated assertions. Due to this, I made vnode_if.sh only output locking assertions if you have the environment variable DEBUG_ALL_VFS_LOCKS set to "YES". In order to actually use the assertions, you need to also add "options DEBUG_VFS_LOCKS" to your kernel config file. Urged to commit by: phk
1999-09-26 18:31:51 +00:00
/* -> /*- for license, minor formatting changes
2005-01-07 02:29:27 +00:00
#-
sys: further adoption of SPDX licensing ID tags. Mainly focus on files that use BSD 3-Clause license. The Software Package Data Exchange (SPDX) group provides a specification to make it easier for automated tools to detect and summarize well known opensource licenses. We are gradually adopting the specification, noting that the tags are considered only advisory and do not, in any way, superceed or replace the license texts. Special thanks to Wind River for providing access to "The Duke of Highlander" tool: an older (2014) run over FreeBSD tree was useful as a starting point.
2017-11-20 19:43:44 +00:00
# SPDX-License-Identifier: BSD-3-Clause
#
BSD 4.4 Lite Kernel Sources
1994-05-24 10:09:53 +00:00
# Copyright (c) 1992, 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.
Renumber copyright clause 4 Renumber cluase 4 to 3, per what everybody else did when BSD granted them permission to remove clause 3. My insistance on keeping the same numbering for legal reasons is too pedantic, so give up on that point. Submitted by: Jan Schaumann <jschauma@stevens.edu> Pull Request: https://github.com/freebsd/freebsd/pull/96
2017-02-28 23:42:47 +00:00
# 3. Neither the name of the University nor the names of its contributors
BSD 4.4 Lite Kernel Sources
1994-05-24 10:09:53 +00:00
# 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.
/* -> /*- for license, minor formatting changes
2005-01-07 02:29:27 +00:00
BSD 4.4 Lite Kernel Sources
1994-05-24 10:09:53 +00:00
#
# @(#)vnode_if.sh 8.1 (Berkeley) 6/10/93
$Id$ -> $FreeBSD$
1999-08-28 01:08:13 +00:00
# $FreeBSD$
BSD 4.4 Lite Kernel Sources
1994-05-24 10:09:53 +00:00
#
# Script to produce VFS front-end sugar.
#
Update usage comment to match reality.
2006-05-26 07:13:26 +00:00
# usage: vnode_if.awk <srcfile> [-c | -h | -p | -q]
Return vnode_if back to its AWK roots. It became a Perl script in rev 1.20. This removes one more dependence on perl for the kernel build.
2002-03-01 01:20:23 +00:00
# (where <srcfile> is currently /sys/kern/vnode_if.src)
Update usage comment to match reality.
2006-05-26 07:13:26 +00:00
# The source file must have a .src extension
BSD 4.4 Lite Kernel Sources
1994-05-24 10:09:53 +00:00
#
Return vnode_if back to its AWK roots. It became a Perl script in rev 1.20. This removes one more dependence on perl for the kernel build.
2002-03-01 01:20:23 +00:00
function usage()
{
Back when VOP_* was introduced, we did not have new-style struct initializations but we did have lofty goals and big ideals. Adjust to more contemporary circumstances and gain type checking. Replace the entire vop_t frobbing thing with properly typed structures. The only casualty is that we can not add a new VOP_ method with a loadable module. History has not given us reason to belive this would ever be feasible in the the first place. Eliminate in toto VOCALL(), vop_t, VNODEOP_SET() etc. Give coda correct prototypes and function definitions for all vop_()s. Generate a bit more data from the vnode_if.src file: a struct vop_vector and protype typedefs for all vop methods. Add a new vop_bypass() and make vop_default be a pointer to another struct vop_vector. Remove a lot of vfs_init since vop_vector is ready to use from the compiler. Cast various vop_mumble() to void * with uppercase name, for instance VOP_PANIC, VOP_NULL etc. Implement VCALL() by making vdesc_offset the offsetof() the relevant function pointer in vop_vector. This is disgusting but since the code is generated by a script comparatively safe. The alternative for nullfs etc. would be much worse. Fix up all vnode method vectors to remove casts so they become typesafe. (The bulk of this is generated by scripts)
2004-12-01 23:16:38 +00:00
print "usage: vnode_if.awk <srcfile> [-c|-h|-p|-q]";
Return vnode_if back to its AWK roots. It became a Perl script in rev 1.20. This removes one more dependence on perl for the kernel build.
2002-03-01 01:20:23 +00:00
exit 1;
Update this to be able to output ASSERT_VOP_(UN)LOCKED() based on the lock specifications in kern/vnode_if.src. At present, this do not distinguish between exclusive and shared locks, and the kernel is so full of bugs in this area that running with auto-generation of assertions enabled makes DEBUG_VFS_LOCKS totally useless for anybody that has used it for anything prior to outputting automated assertions. Due to this, I made vnode_if.sh only output locking assertions if you have the environment variable DEBUG_ALL_VFS_LOCKS set to "YES". In order to actually use the assertions, you need to also add "options DEBUG_VFS_LOCKS" to your kernel config file. Urged to commit by: phk
1999-09-26 18:31:51 +00:00
}
BSD 4.4 Lite Kernel Sources
1994-05-24 10:09:53 +00:00
Return vnode_if back to its AWK roots. It became a Perl script in rev 1.20. This removes one more dependence on perl for the kernel build.
2002-03-01 01:20:23 +00:00
function die(msg, what)
{
- Add two checks for syntax errors - Improve error reporting - Remove redundant conditionals
2006-05-30 21:13:28 +00:00
printf srcfile "(" fnr "): " > "/dev/stderr";
Return vnode_if back to its AWK roots. It became a Perl script in rev 1.20. This removes one more dependence on perl for the kernel build.
2002-03-01 01:20:23 +00:00
printf msg "\n", what > "/dev/stderr";
exit 1;
Use a seperate -c and -h mode. The vnode_if.c file is compiled only into the kernel while the vnode_if.h header is a bunch of inlines to call the code that is in the kernel. Generating the .h file on the fly is kinda bogus because it has to match the one compiled into the kernel. IMHO we should have kern/vnode_if.c and sys/vnode_if.h committed in the tree but that's another battle.
1999-12-12 16:43:05 +00:00
}
BSD 4.4 Lite Kernel Sources
1994-05-24 10:09:53 +00:00
Return vnode_if back to its AWK roots. It became a Perl script in rev 1.20. This removes one more dependence on perl for the kernel build.
2002-03-01 01:20:23 +00:00
function t_spc(type)
{
# Append a space if the type is not a pointer
return (type ~ /\*$/) ? type : type " ";
Use a seperate -c and -h mode. The vnode_if.c file is compiled only into the kernel while the vnode_if.h header is a bunch of inlines to call the code that is in the kernel. Generating the .h file on the fly is kinda bogus because it has to match the one compiled into the kernel. IMHO we should have kern/vnode_if.c and sys/vnode_if.h committed in the tree but that's another battle.
1999-12-12 16:43:05 +00:00
}
BSD 4.4 Lite Kernel Sources
1994-05-24 10:09:53 +00:00
Return vnode_if back to its AWK roots. It became a Perl script in rev 1.20. This removes one more dependence on perl for the kernel build.
2002-03-01 01:20:23 +00:00
# These are just for convenience ...
function printc(s) {print s > cfile;}
function printh(s) {print s > hfile;}
Back when VOP_* was introduced, we did not have new-style struct initializations but we did have lofty goals and big ideals. Adjust to more contemporary circumstances and gain type checking. Replace the entire vop_t frobbing thing with properly typed structures. The only casualty is that we can not add a new VOP_ method with a loadable module. History has not given us reason to belive this would ever be feasible in the the first place. Eliminate in toto VOCALL(), vop_t, VNODEOP_SET() etc. Give coda correct prototypes and function definitions for all vop_()s. Generate a bit more data from the vnode_if.src file: a struct vop_vector and protype typedefs for all vop methods. Add a new vop_bypass() and make vop_default be a pointer to another struct vop_vector. Remove a lot of vfs_init since vop_vector is ready to use from the compiler. Cast various vop_mumble() to void * with uppercase name, for instance VOP_PANIC, VOP_NULL etc. Implement VCALL() by making vdesc_offset the offsetof() the relevant function pointer in vop_vector. This is disgusting but since the code is generated by a script comparatively safe. The alternative for nullfs etc. would be much worse. Fix up all vnode method vectors to remove casts so they become typesafe. (The bulk of this is generated by scripts)
2004-12-01 23:16:38 +00:00
function printp(s) {print s > pfile;}
function printq(s) {print s > qfile;}
Return vnode_if back to its AWK roots. It became a Perl script in rev 1.20. This removes one more dependence on perl for the kernel build.
2002-03-01 01:20:23 +00:00
Change the generated VOP_ macro implementations to improve type checking and KASSERT coverage. After this check there is only one "nasty" cast in this code but there is a KASSERT to protect against the wrong argument structure behind that cast. Un-inlining the meat of VOP_FOO() saves 35kB of text segment on a typical kernel with no change in performance. We also now run the checking and tracing on VOP's which have been layered by nullfs, umapfs, deadfs or unionfs. Add new (non-inline) VOP_FOO_AP() functions which take a "struct foo_args" argument and does everything the VOP_FOO() macros used to do with checks and debugging code. Add KASSERT to VOP_FOO_AP() check for argument type being correct. Slim down VOP_FOO() inline functions to just stuff arguments into the struct foo_args and call VOP_FOO_AP(). Put function pointer to VOP_FOO_AP() into vop_foo_desc structure and make VCALL() use it instead of the current offsetoff() hack. Retire vcall() which implemented the offsetoff() Make deadfs and unionfs use VOP_FOO_AP() calls instead of VCALL(), we know which specific call we want already. Remove unneeded arguments to VCALL() in nullfs and umapfs bypass functions. Remove unused vdesc_offset and VOFFSET(). Generally improve style/readability of the generated code.
2005-01-13 07:53:01 +00:00
function add_debug_code(name, arg, pos, ind)
Return vnode_if back to its AWK roots. It became a Perl script in rev 1.20. This removes one more dependence on perl for the kernel build.
2002-03-01 01:20:23 +00:00
{
The assertions generated to test VFS locking never included checks for vnodes reached through double indirection (i.e. **vpp). This is worked-around by special-casing the identifier "vpp" (adding one level of indirection). The alternative fix mentioned in the PR had required substantial changes to this script. In case there are locking violations that had been hidden without this patch, they may suddenly show up, now ... This change does not affect code compiled without DEBUG_VFS_LOCKS. PR: kern/46652
2003-06-20 12:15:37 +00:00
if (arg == "vpp")
Change the generated VOP_ macro implementations to improve type checking and KASSERT coverage. After this check there is only one "nasty" cast in this code but there is a KASSERT to protect against the wrong argument structure behind that cast. Un-inlining the meat of VOP_FOO() saves 35kB of text segment on a typical kernel with no change in performance. We also now run the checking and tracing on VOP's which have been layered by nullfs, umapfs, deadfs or unionfs. Add new (non-inline) VOP_FOO_AP() functions which take a "struct foo_args" argument and does everything the VOP_FOO() macros used to do with checks and debugging code. Add KASSERT to VOP_FOO_AP() check for argument type being correct. Slim down VOP_FOO() inline functions to just stuff arguments into the struct foo_args and call VOP_FOO_AP(). Put function pointer to VOP_FOO_AP() into vop_foo_desc structure and make VCALL() use it instead of the current offsetoff() hack. Retire vcall() which implemented the offsetoff() Make deadfs and unionfs use VOP_FOO_AP() calls instead of VCALL(), we know which specific call we want already. Remove unneeded arguments to VCALL() in nullfs and umapfs bypass functions. Remove unused vdesc_offset and VOFFSET(). Generally improve style/readability of the generated code.
2005-01-13 07:53:01 +00:00
star = "*";
else
star = "";
Don't check the state of the vnode interlock if the specification says that the lock should not be checked. Skip the lock assertion checks for *vpp or any other pointer to a vnode pointer if vpp (or equivalent) is NULL.
2003-06-22 21:20:06 +00:00
if (lockdata[name, arg, pos] && (lockdata[name, arg, pos] != "-")) {
Change the generated VOP_ macro implementations to improve type checking and KASSERT coverage. After this check there is only one "nasty" cast in this code but there is a KASSERT to protect against the wrong argument structure behind that cast. Un-inlining the meat of VOP_FOO() saves 35kB of text segment on a typical kernel with no change in performance. We also now run the checking and tracing on VOP's which have been layered by nullfs, umapfs, deadfs or unionfs. Add new (non-inline) VOP_FOO_AP() functions which take a "struct foo_args" argument and does everything the VOP_FOO() macros used to do with checks and debugging code. Add KASSERT to VOP_FOO_AP() check for argument type being correct. Slim down VOP_FOO() inline functions to just stuff arguments into the struct foo_args and call VOP_FOO_AP(). Put function pointer to VOP_FOO_AP() into vop_foo_desc structure and make VCALL() use it instead of the current offsetoff() hack. Retire vcall() which implemented the offsetoff() Make deadfs and unionfs use VOP_FOO_AP() calls instead of VCALL(), we know which specific call we want already. Remove unneeded arguments to VCALL() in nullfs and umapfs bypass functions. Remove unused vdesc_offset and VOFFSET(). Generally improve style/readability of the generated code.
2005-01-13 07:53:01 +00:00
printc(ind"ASSERT_VI_UNLOCKED("star"a->a_"arg", \""uname"\");");
Return vnode_if back to its AWK roots. It became a Perl script in rev 1.20. This removes one more dependence on perl for the kernel build.
2002-03-01 01:20:23 +00:00
# Add assertions for locking
- Add automatic post vop debug checks. These work in both the success and failure cases.
2002-07-30 08:52:00 +00:00
if (lockdata[name, arg, pos] == "L")
Change the generated VOP_ macro implementations to improve type checking and KASSERT coverage. After this check there is only one "nasty" cast in this code but there is a KASSERT to protect against the wrong argument structure behind that cast. Un-inlining the meat of VOP_FOO() saves 35kB of text segment on a typical kernel with no change in performance. We also now run the checking and tracing on VOP's which have been layered by nullfs, umapfs, deadfs or unionfs. Add new (non-inline) VOP_FOO_AP() functions which take a "struct foo_args" argument and does everything the VOP_FOO() macros used to do with checks and debugging code. Add KASSERT to VOP_FOO_AP() check for argument type being correct. Slim down VOP_FOO() inline functions to just stuff arguments into the struct foo_args and call VOP_FOO_AP(). Put function pointer to VOP_FOO_AP() into vop_foo_desc structure and make VCALL() use it instead of the current offsetoff() hack. Retire vcall() which implemented the offsetoff() Make deadfs and unionfs use VOP_FOO_AP() calls instead of VCALL(), we know which specific call we want already. Remove unneeded arguments to VCALL() in nullfs and umapfs bypass functions. Remove unused vdesc_offset and VOFFSET(). Generally improve style/readability of the generated code.
2005-01-13 07:53:01 +00:00
printc(ind"ASSERT_VOP_LOCKED(" star "a->a_"arg", \""uname"\");");
- Add automatic post vop debug checks. These work in both the success and failure cases.
2002-07-30 08:52:00 +00:00
else if (lockdata[name, arg, pos] == "U")
Change the generated VOP_ macro implementations to improve type checking and KASSERT coverage. After this check there is only one "nasty" cast in this code but there is a KASSERT to protect against the wrong argument structure behind that cast. Un-inlining the meat of VOP_FOO() saves 35kB of text segment on a typical kernel with no change in performance. We also now run the checking and tracing on VOP's which have been layered by nullfs, umapfs, deadfs or unionfs. Add new (non-inline) VOP_FOO_AP() functions which take a "struct foo_args" argument and does everything the VOP_FOO() macros used to do with checks and debugging code. Add KASSERT to VOP_FOO_AP() check for argument type being correct. Slim down VOP_FOO() inline functions to just stuff arguments into the struct foo_args and call VOP_FOO_AP(). Put function pointer to VOP_FOO_AP() into vop_foo_desc structure and make VCALL() use it instead of the current offsetoff() hack. Retire vcall() which implemented the offsetoff() Make deadfs and unionfs use VOP_FOO_AP() calls instead of VCALL(), we know which specific call we want already. Remove unneeded arguments to VCALL() in nullfs and umapfs bypass functions. Remove unused vdesc_offset and VOFFSET(). Generally improve style/readability of the generated code.
2005-01-13 07:53:01 +00:00
printc(ind"ASSERT_VOP_UNLOCKED(" star "a->a_"arg", \""uname"\");");
- Add the character "E" to the understood lock types. This means the VOP requires an exclusive lock. Sponsored by: Isilon Systems, Inc.
2005-04-11 15:15:03 +00:00
else if (lockdata[name, arg, pos] == "E")
printc(ind"ASSERT_VOP_ELOCKED(" star "a->a_"arg", \""uname"\");");
Return vnode_if back to its AWK roots. It became a Perl script in rev 1.20. This removes one more dependence on perl for the kernel build.
2002-03-01 01:20:23 +00:00
else if (0) {
# XXX More checks!
}
BSD 4.4 Lite Kernel Sources
1994-05-24 10:09:53 +00:00
}
Return vnode_if back to its AWK roots. It became a Perl script in rev 1.20. This removes one more dependence on perl for the kernel build.
2002-03-01 01:20:23 +00:00
}
Update this to be able to output ASSERT_VOP_(UN)LOCKED() based on the lock specifications in kern/vnode_if.src. At present, this do not distinguish between exclusive and shared locks, and the kernel is so full of bugs in this area that running with auto-generation of assertions enabled makes DEBUG_VFS_LOCKS totally useless for anybody that has used it for anything prior to outputting automated assertions. Due to this, I made vnode_if.sh only output locking assertions if you have the environment variable DEBUG_ALL_VFS_LOCKS set to "YES". In order to actually use the assertions, you need to also add "options DEBUG_VFS_LOCKS" to your kernel config file. Urged to commit by: phk
1999-09-26 18:31:51 +00:00
vfs: inline vops if there are no pre/post associated calls This removes a level of indirection from frequently used methods, most notably VOP_LOCK1 and VOP_UNLOCK1. Tested by: pho
2020-07-30 15:50:51 +00:00
function add_debugpre(name)
{
if (lockdata[name, "debugpre"]) {
printc("#ifdef DEBUG_VFS_LOCKS");
printc("\t"lockdata[name, "debugpre"]"(a);");
printc("#endif");
}
}
function add_debugpost(name)
{
if (lockdata[name, "debugpost"]) {
printc("#ifdef DEBUG_VFS_LOCKS");
printc("\t"lockdata[name, "debugpost"]"(a, rc);");
printc("#endif");
}
}
Allow EVFILT_VNODE events to work on every filesystem type, not just UFS by: - Making the pre and post hooks for the VOP functions work even when DEBUG_VFS_LOCKS is not defined. - Moving the KNOTE activations into the corresponding VOP hooks. - Creating a MNTK_NOKNOTE flag for the mnt_kern_flag field of struct mount that permits filesystems to disable the new behavior. - Creating a default VOP_KQFILTER function: vfs_kqfilter() My benchmarks have not revealed any performance degradation. Reviewed by: jeff, bde Approved by: rwatson, jmg (kqueue changes), grehan (mentor)
2005-06-09 20:20:31 +00:00
function add_pre(name)
Add a new configuration directive that inserts calls to debugging functions in the VOP inlines. This is intended to replace the simple locking specifications for calls that have more complicated behavior such as rename and lookup. The syntax of the new entries is: #! name pre/post function If the function is marked 'pre' it is executed prior to calling the VOP and takes a pointer to a struct vop_{name}_args as it's only parameter. If the function is marked 'post' it is executed after the VOP call and takes a pointer to a struct vop_{name}_args as it's first parameter and the integer return value from the vop as the second paramter.
2002-07-06 03:46:36 +00:00
{
- Use 'options DEBUG_VFS_LOCKS' instead of the DEBUG_ALL_VFS_LOCKS environment variable to enable the lock verifiction code.
2002-07-07 06:39:36 +00:00
if (lockdata[name, "pre"]) {
Change the generated VOP_ macro implementations to improve type checking and KASSERT coverage. After this check there is only one "nasty" cast in this code but there is a KASSERT to protect against the wrong argument structure behind that cast. Un-inlining the meat of VOP_FOO() saves 35kB of text segment on a typical kernel with no change in performance. We also now run the checking and tracing on VOP's which have been layered by nullfs, umapfs, deadfs or unionfs. Add new (non-inline) VOP_FOO_AP() functions which take a "struct foo_args" argument and does everything the VOP_FOO() macros used to do with checks and debugging code. Add KASSERT to VOP_FOO_AP() check for argument type being correct. Slim down VOP_FOO() inline functions to just stuff arguments into the struct foo_args and call VOP_FOO_AP(). Put function pointer to VOP_FOO_AP() into vop_foo_desc structure and make VCALL() use it instead of the current offsetoff() hack. Retire vcall() which implemented the offsetoff() Make deadfs and unionfs use VOP_FOO_AP() calls instead of VCALL(), we know which specific call we want already. Remove unneeded arguments to VCALL() in nullfs and umapfs bypass functions. Remove unused vdesc_offset and VOFFSET(). Generally improve style/readability of the generated code.
2005-01-13 07:53:01 +00:00
printc("\t"lockdata[name, "pre"]"(a);");
Add a new configuration directive that inserts calls to debugging functions in the VOP inlines. This is intended to replace the simple locking specifications for calls that have more complicated behavior such as rename and lookup. The syntax of the new entries is: #! name pre/post function If the function is marked 'pre' it is executed prior to calling the VOP and takes a pointer to a struct vop_{name}_args as it's only parameter. If the function is marked 'post' it is executed after the VOP call and takes a pointer to a struct vop_{name}_args as it's first parameter and the integer return value from the vop as the second paramter.
2002-07-06 03:46:36 +00:00
}
}
Allow EVFILT_VNODE events to work on every filesystem type, not just UFS by: - Making the pre and post hooks for the VOP functions work even when DEBUG_VFS_LOCKS is not defined. - Moving the KNOTE activations into the corresponding VOP hooks. - Creating a MNTK_NOKNOTE flag for the mnt_kern_flag field of struct mount that permits filesystems to disable the new behavior. - Creating a default VOP_KQFILTER function: vfs_kqfilter() My benchmarks have not revealed any performance degradation. Reviewed by: jeff, bde Approved by: rwatson, jmg (kqueue changes), grehan (mentor)
2005-06-09 20:20:31 +00:00
function add_post(name)
Add a new configuration directive that inserts calls to debugging functions in the VOP inlines. This is intended to replace the simple locking specifications for calls that have more complicated behavior such as rename and lookup. The syntax of the new entries is: #! name pre/post function If the function is marked 'pre' it is executed prior to calling the VOP and takes a pointer to a struct vop_{name}_args as it's only parameter. If the function is marked 'post' it is executed after the VOP call and takes a pointer to a struct vop_{name}_args as it's first parameter and the integer return value from the vop as the second paramter.
2002-07-06 03:46:36 +00:00
{
- Use 'options DEBUG_VFS_LOCKS' instead of the DEBUG_ALL_VFS_LOCKS environment variable to enable the lock verifiction code.
2002-07-07 06:39:36 +00:00
if (lockdata[name, "post"]) {
Change the generated VOP_ macro implementations to improve type checking and KASSERT coverage. After this check there is only one "nasty" cast in this code but there is a KASSERT to protect against the wrong argument structure behind that cast. Un-inlining the meat of VOP_FOO() saves 35kB of text segment on a typical kernel with no change in performance. We also now run the checking and tracing on VOP's which have been layered by nullfs, umapfs, deadfs or unionfs. Add new (non-inline) VOP_FOO_AP() functions which take a "struct foo_args" argument and does everything the VOP_FOO() macros used to do with checks and debugging code. Add KASSERT to VOP_FOO_AP() check for argument type being correct. Slim down VOP_FOO() inline functions to just stuff arguments into the struct foo_args and call VOP_FOO_AP(). Put function pointer to VOP_FOO_AP() into vop_foo_desc structure and make VCALL() use it instead of the current offsetoff() hack. Retire vcall() which implemented the offsetoff() Make deadfs and unionfs use VOP_FOO_AP() calls instead of VCALL(), we know which specific call we want already. Remove unneeded arguments to VCALL() in nullfs and umapfs bypass functions. Remove unused vdesc_offset and VOFFSET(). Generally improve style/readability of the generated code.
2005-01-13 07:53:01 +00:00
printc("\t"lockdata[name, "post"]"(a, rc);");
Add a new configuration directive that inserts calls to debugging functions in the VOP inlines. This is intended to replace the simple locking specifications for calls that have more complicated behavior such as rename and lookup. The syntax of the new entries is: #! name pre/post function If the function is marked 'pre' it is executed prior to calling the VOP and takes a pointer to a struct vop_{name}_args as it's only parameter. If the function is marked 'post' it is executed after the VOP call and takes a pointer to a struct vop_{name}_args as it's first parameter and the integer return value from the vop as the second paramter.
2002-07-06 03:46:36 +00:00
}
}
vfs: inline vops if there are no pre/post associated calls This removes a level of indirection from frequently used methods, most notably VOP_LOCK1 and VOP_UNLOCK1. Tested by: pho
2020-07-30 15:50:51 +00:00
function can_inline(name)
{
if (lockdata[name, "pre"])
return 0;
if (lockdata[name, "post"])
return 0;
return 1;
}
Return vnode_if back to its AWK roots. It became a Perl script in rev 1.20. This removes one more dependence on perl for the kernel build.
2002-03-01 01:20:23 +00:00
function find_arg_with_type (type)
{
for (jj = 0; jj < numargs; jj++) {
if (types[jj] == type) {
return "VOPARG_OFFSETOF(struct " \
name "_args,a_" args[jj] ")";
}
BSD 4.4 Lite Kernel Sources
1994-05-24 10:09:53 +00:00
}
Return vnode_if back to its AWK roots. It became a Perl script in rev 1.20. This removes one more dependence on perl for the kernel build.
2002-03-01 01:20:23 +00:00
return "VDESC_NO_OFFSET";
}
BSD 4.4 Lite Kernel Sources
1994-05-24 10:09:53 +00:00
Return vnode_if back to its AWK roots. It became a Perl script in rev 1.20. This removes one more dependence on perl for the kernel build.
2002-03-01 01:20:23 +00:00
BEGIN{
Update this to be able to output ASSERT_VOP_(UN)LOCKED() based on the lock specifications in kern/vnode_if.src. At present, this do not distinguish between exclusive and shared locks, and the kernel is so full of bugs in this area that running with auto-generation of assertions enabled makes DEBUG_VFS_LOCKS totally useless for anybody that has used it for anything prior to outputting automated assertions. Due to this, I made vnode_if.sh only output locking assertions if you have the environment variable DEBUG_ALL_VFS_LOCKS set to "YES". In order to actually use the assertions, you need to also add "options DEBUG_VFS_LOCKS" to your kernel config file. Urged to commit by: phk
1999-09-26 18:31:51 +00:00
Return vnode_if back to its AWK roots. It became a Perl script in rev 1.20. This removes one more dependence on perl for the kernel build.
2002-03-01 01:20:23 +00:00
# Process the command line
for (i = 1; i < ARGC; i++) {
arg = ARGV[i];
Back when VOP_* was introduced, we did not have new-style struct initializations but we did have lofty goals and big ideals. Adjust to more contemporary circumstances and gain type checking. Replace the entire vop_t frobbing thing with properly typed structures. The only casualty is that we can not add a new VOP_ method with a loadable module. History has not given us reason to belive this would ever be feasible in the the first place. Eliminate in toto VOCALL(), vop_t, VNODEOP_SET() etc. Give coda correct prototypes and function definitions for all vop_()s. Generate a bit more data from the vnode_if.src file: a struct vop_vector and protype typedefs for all vop methods. Add a new vop_bypass() and make vop_default be a pointer to another struct vop_vector. Remove a lot of vfs_init since vop_vector is ready to use from the compiler. Cast various vop_mumble() to void * with uppercase name, for instance VOP_PANIC, VOP_NULL etc. Implement VCALL() by making vdesc_offset the offsetof() the relevant function pointer in vop_vector. This is disgusting but since the code is generated by a script comparatively safe. The alternative for nullfs etc. would be much worse. Fix up all vnode method vectors to remove casts so they become typesafe. (The bulk of this is generated by scripts)
2004-12-01 23:16:38 +00:00
if (arg !~ /^-[chpq]+$/ && arg !~ /\.src$/)
Return vnode_if back to its AWK roots. It became a Perl script in rev 1.20. This removes one more dependence on perl for the kernel build.
2002-03-01 01:20:23 +00:00
usage();
if (arg ~ /^-.*c/)
cfile = "vnode_if.c";
if (arg ~ /^-.*h/)
hfile = "vnode_if.h";
Back when VOP_* was introduced, we did not have new-style struct initializations but we did have lofty goals and big ideals. Adjust to more contemporary circumstances and gain type checking. Replace the entire vop_t frobbing thing with properly typed structures. The only casualty is that we can not add a new VOP_ method with a loadable module. History has not given us reason to belive this would ever be feasible in the the first place. Eliminate in toto VOCALL(), vop_t, VNODEOP_SET() etc. Give coda correct prototypes and function definitions for all vop_()s. Generate a bit more data from the vnode_if.src file: a struct vop_vector and protype typedefs for all vop methods. Add a new vop_bypass() and make vop_default be a pointer to another struct vop_vector. Remove a lot of vfs_init since vop_vector is ready to use from the compiler. Cast various vop_mumble() to void * with uppercase name, for instance VOP_PANIC, VOP_NULL etc. Implement VCALL() by making vdesc_offset the offsetof() the relevant function pointer in vop_vector. This is disgusting but since the code is generated by a script comparatively safe. The alternative for nullfs etc. would be much worse. Fix up all vnode method vectors to remove casts so they become typesafe. (The bulk of this is generated by scripts)
2004-12-01 23:16:38 +00:00
if (arg ~ /^-.*p/)
pfile = "vnode_if_newproto.h";
if (arg ~ /^-.*q/)
qfile = "vnode_if_typedef.h";
Return vnode_if back to its AWK roots. It became a Perl script in rev 1.20. This removes one more dependence on perl for the kernel build.
2002-03-01 01:20:23 +00:00
if (arg ~ /\.src$/)
srcfile = arg;
}
ARGC = 1;
Back when VOP_* was introduced, we did not have new-style struct initializations but we did have lofty goals and big ideals. Adjust to more contemporary circumstances and gain type checking. Replace the entire vop_t frobbing thing with properly typed structures. The only casualty is that we can not add a new VOP_ method with a loadable module. History has not given us reason to belive this would ever be feasible in the the first place. Eliminate in toto VOCALL(), vop_t, VNODEOP_SET() etc. Give coda correct prototypes and function definitions for all vop_()s. Generate a bit more data from the vnode_if.src file: a struct vop_vector and protype typedefs for all vop methods. Add a new vop_bypass() and make vop_default be a pointer to another struct vop_vector. Remove a lot of vfs_init since vop_vector is ready to use from the compiler. Cast various vop_mumble() to void * with uppercase name, for instance VOP_PANIC, VOP_NULL etc. Implement VCALL() by making vdesc_offset the offsetof() the relevant function pointer in vop_vector. This is disgusting but since the code is generated by a script comparatively safe. The alternative for nullfs etc. would be much worse. Fix up all vnode method vectors to remove casts so they become typesafe. (The bulk of this is generated by scripts)
2004-12-01 23:16:38 +00:00
if (!cfile && !hfile && !pfile && !qfile)
Return vnode_if back to its AWK roots. It became a Perl script in rev 1.20. This removes one more dependence on perl for the kernel build.
2002-03-01 01:20:23 +00:00
exit 0;
if (!srcfile)
usage();
Avoid literal @generated tag in file-generating scripts We don't want the generator itself tagged as a generated file. Reviewed by: cem Sponsored by: The FreeBSD Foundation Differential Revision: https://reviews.freebsd.org/D20182
2019-05-08 13:35:51 +00:00
# Avoid a literal generated file tag here.
generated = "@" "generated";
Return vnode_if back to its AWK roots. It became a Perl script in rev 1.20. This removes one more dependence on perl for the kernel build.
2002-03-01 01:20:23 +00:00
common_head = \
"/*\n" \
Avoid literal @generated tag in file-generating scripts We don't want the generator itself tagged as a generated file. Reviewed by: cem Sponsored by: The FreeBSD Foundation Differential Revision: https://reviews.freebsd.org/D20182
2019-05-08 13:35:51 +00:00
" * This file is " generated " automatically.\n" \
Return vnode_if back to its AWK roots. It became a Perl script in rev 1.20. This removes one more dependence on perl for the kernel build.
2002-03-01 01:20:23 +00:00
" * Do not modify anything in here by hand.\n" \
" *\n" \
" * Created from $FreeBSD$\n" \
" */\n" \
"\n";
Back when VOP_* was introduced, we did not have new-style struct initializations but we did have lofty goals and big ideals. Adjust to more contemporary circumstances and gain type checking. Replace the entire vop_t frobbing thing with properly typed structures. The only casualty is that we can not add a new VOP_ method with a loadable module. History has not given us reason to belive this would ever be feasible in the the first place. Eliminate in toto VOCALL(), vop_t, VNODEOP_SET() etc. Give coda correct prototypes and function definitions for all vop_()s. Generate a bit more data from the vnode_if.src file: a struct vop_vector and protype typedefs for all vop methods. Add a new vop_bypass() and make vop_default be a pointer to another struct vop_vector. Remove a lot of vfs_init since vop_vector is ready to use from the compiler. Cast various vop_mumble() to void * with uppercase name, for instance VOP_PANIC, VOP_NULL etc. Implement VCALL() by making vdesc_offset the offsetof() the relevant function pointer in vop_vector. This is disgusting but since the code is generated by a script comparatively safe. The alternative for nullfs etc. would be much worse. Fix up all vnode method vectors to remove casts so they become typesafe. (The bulk of this is generated by scripts)
2004-12-01 23:16:38 +00:00
if (pfile) {
printp(common_head)
printp("struct vop_vector {")
printp("\tstruct vop_vector\t*vop_default;")
printp("\tvop_bypass_t\t*vop_bypass;")
}
if (qfile) {
printq(common_head)
}
if (hfile) {
Return vnode_if back to its AWK roots. It became a Perl script in rev 1.20. This removes one more dependence on perl for the kernel build.
2002-03-01 01:20:23 +00:00
printh(common_head "extern struct vnodeop_desc vop_default_desc;");
Back when VOP_* was introduced, we did not have new-style struct initializations but we did have lofty goals and big ideals. Adjust to more contemporary circumstances and gain type checking. Replace the entire vop_t frobbing thing with properly typed structures. The only casualty is that we can not add a new VOP_ method with a loadable module. History has not given us reason to belive this would ever be feasible in the the first place. Eliminate in toto VOCALL(), vop_t, VNODEOP_SET() etc. Give coda correct prototypes and function definitions for all vop_()s. Generate a bit more data from the vnode_if.src file: a struct vop_vector and protype typedefs for all vop methods. Add a new vop_bypass() and make vop_default be a pointer to another struct vop_vector. Remove a lot of vfs_init since vop_vector is ready to use from the compiler. Cast various vop_mumble() to void * with uppercase name, for instance VOP_PANIC, VOP_NULL etc. Implement VCALL() by making vdesc_offset the offsetof() the relevant function pointer in vop_vector. This is disgusting but since the code is generated by a script comparatively safe. The alternative for nullfs etc. would be much worse. Fix up all vnode method vectors to remove casts so they become typesafe. (The bulk of this is generated by scripts)
2004-12-01 23:16:38 +00:00
printh("#include \"vnode_if_typedef.h\"")
printh("#include \"vnode_if_newproto.h\"")
}
Return vnode_if back to its AWK roots. It became a Perl script in rev 1.20. This removes one more dependence on perl for the kernel build.
2002-03-01 01:20:23 +00:00
if (cfile) {
printc(common_head \
"#include <sys/param.h>\n" \
Allow EVFILT_VNODE events to work on every filesystem type, not just UFS by: - Making the pre and post hooks for the VOP functions work even when DEBUG_VFS_LOCKS is not defined. - Moving the KNOTE activations into the corresponding VOP hooks. - Creating a MNTK_NOKNOTE flag for the mnt_kern_flag field of struct mount that permits filesystems to disable the new behavior. - Creating a default VOP_KQFILTER function: vfs_kqfilter() My benchmarks have not revealed any performance degradation. Reviewed by: jeff, bde Approved by: rwatson, jmg (kqueue changes), grehan (mentor)
2005-06-09 20:20:31 +00:00
"#include <sys/event.h>\n" \
Add SDT DTrace probes for VFS vnode operations in the vfs:vop provider namespace. These are inserted dynamically into the VOP_..._AP() functions created from vnode_if.src. Each VOP has entry and return probes, as arg0 the primary vnode, arg1 the vnode operation argument structure pointer, providing access to IN and OUT arguments, and for return probes, arg2 the return value. MFC after: 1 month Sponsored by: Google, Inc.
2009-03-29 03:30:15 +00:00
"#include <sys/kernel.h>\n" \
Allow EVFILT_VNODE events to work on every filesystem type, not just UFS by: - Making the pre and post hooks for the VOP functions work even when DEBUG_VFS_LOCKS is not defined. - Moving the KNOTE activations into the corresponding VOP hooks. - Creating a MNTK_NOKNOTE flag for the mnt_kern_flag field of struct mount that permits filesystems to disable the new behavior. - Creating a default VOP_KQFILTER function: vfs_kqfilter() My benchmarks have not revealed any performance degradation. Reviewed by: jeff, bde Approved by: rwatson, jmg (kqueue changes), grehan (mentor)
2005-06-09 20:20:31 +00:00
"#include <sys/mount.h>\n" \
Add SDT DTrace probes for VFS vnode operations in the vfs:vop provider namespace. These are inserted dynamically into the VOP_..._AP() functions created from vnode_if.src. Each VOP has entry and return probes, as arg0 the primary vnode, arg1 the vnode operation argument structure pointer, providing access to IN and OUT arguments, and for return probes, arg2 the return value. MFC after: 1 month Sponsored by: Google, Inc.
2009-03-29 03:30:15 +00:00
"#include <sys/sdt.h>\n" \
Further refine the handling of stop signals in the NFS client. The changes in r246417 were incomplete as they did not add explicit calls to sigdeferstop() around all the places that previously passed SBDRY to _sleep(). In addition, nfs_getcacheblk() could trigger a write RPC from getblk() resulting in sigdeferstop() recursing. Rather than manually deferring stop signals in specific places, change the VFS_*() and VOP_*() methods to defer stop signals for filesystems which request this behavior via a new VFCF_SBDRY flag. Note that this has to be a VFC flag rather than a MNTK flag so that it works properly with VFS_MOUNT() when the mount is not yet fully constructed. For now, only the NFS clients are set this new flag in VFS_SET(). A few other related changes: - Add an assertion to ensure that TDF_SBDRY doesn't leak to userland. - When a lookup request uses VOP_READLINK() to follow a symlink, mark the request as being on behalf of the thread performing the lookup (cnp_thread) rather than using a NULL thread pointer. This causes NFS to properly handle signals during this VOP on an interruptible mount. PR: kern/176179 Reported by: Russell Cattelan (sigdeferstop() recursion) Reviewed by: kib MFC after: 1 month
2013-02-21 19:02:50 +00:00
"#include <sys/signalvar.h>\n" \
include systm.h in vnode_if.c so that panic is defined when we're doing DEBUG_ALL_VFS_LOCKS.
2002-05-04 02:35:13 +00:00
"#include <sys/systm.h>\n" \
Return vnode_if back to its AWK roots. It became a Perl script in rev 1.20. This removes one more dependence on perl for the kernel build.
2002-03-01 01:20:23 +00:00
"#include <sys/vnode.h>\n" \
"\n" \
Add SDT DTrace probes for VFS vnode operations in the vfs:vop provider namespace. These are inserted dynamically into the VOP_..._AP() functions created from vnode_if.src. Each VOP has entry and return probes, as arg0 the primary vnode, arg1 the vnode operation argument structure pointer, providing access to IN and OUT arguments, and for return probes, arg2 the return value. MFC after: 1 month Sponsored by: Google, Inc.
2009-03-29 03:30:15 +00:00
"SDT_PROVIDER_DECLARE(vfs);\n" \
"\n" \
Return vnode_if back to its AWK roots. It became a Perl script in rev 1.20. This removes one more dependence on perl for the kernel build.
2002-03-01 01:20:23 +00:00
"struct vnodeop_desc vop_default_desc = {\n" \
" \"default\",\n" \
" 0,\n" \
Only call sigdeferstop() for NFS. Use bypass to catch any NFS VOP dispatch and route it through the wrapper which does sigdeferstop() and then dispatches original VOP. NFS does not need a bypass below it, which is not supported. The vop offset in the vop_vector is added since otherwise it is impossible to get vop_op_t from the internal table, and I did not wanted to create the layered fs only to wrap NFS VOPs. VFS_OP()s wrap is straightforward. Requested and reviewed by: mjg (previous version) Tested by: pho Sponsored by: The FreeBSD Foundation Differential revision: https://reviews.freebsd.org/D17658
2018-10-23 21:43:41 +00:00
" 0,\n" \
Eradicate caddr_t from the VFS API.
2005-12-14 00:49:52 +00:00
" (vop_bypass_t *)vop_panic,\n" \
Return vnode_if back to its AWK roots. It became a Perl script in rev 1.20. This removes one more dependence on perl for the kernel build.
2002-03-01 01:20:23 +00:00
" NULL,\n" \
" VDESC_NO_OFFSET,\n" \
" VDESC_NO_OFFSET,\n" \
" VDESC_NO_OFFSET,\n" \
" VDESC_NO_OFFSET,\n" \
"};\n");
}
while ((getline < srcfile) > 0) {
- Add two checks for syntax errors - Improve error reporting - Remove redundant conditionals
2006-05-30 21:13:28 +00:00
fnr++;
Return vnode_if back to its AWK roots. It became a Perl script in rev 1.20. This removes one more dependence on perl for the kernel build.
2002-03-01 01:20:23 +00:00
if (NF == 0)
continue;
Assertion code specifications are introduced using special character sequences that are distinct from comments. %% is used for argument locks; %! for pre- and post-conditions.
2006-05-30 20:49:54 +00:00
if ($1 ~ /^%%/) {
- Add two checks for syntax errors - Improve error reporting - Remove redundant conditionals
2006-05-30 21:13:28 +00:00
if (NF != 6 ||
Make vnode_if.awk parse vnode operations with underscores, like VOP_FOO_BAR. Reviewed by: kib MFC after: 1 week
2012-02-21 19:35:59 +00:00
$2 !~ /^[a-z_]+$/ || $3 !~ /^[a-z]+$/ ||
- Add two checks for syntax errors - Improve error reporting - Remove redundant conditionals
2006-05-30 21:13:28 +00:00
$4 !~ /^.$/ || $5 !~ /^.$/ || $6 !~ /^.$/) {
die("Invalid %s construction", "%%");
Return vnode_if back to its AWK roots. It became a Perl script in rev 1.20. This removes one more dependence on perl for the kernel build.
2002-03-01 01:20:23 +00:00
continue;
- Add two checks for syntax errors - Improve error reporting - Remove redundant conditionals
2006-05-30 21:13:28 +00:00
}
Return vnode_if back to its AWK roots. It became a Perl script in rev 1.20. This removes one more dependence on perl for the kernel build.
2002-03-01 01:20:23 +00:00
lockdata["vop_" $2, $3, "Entry"] = $4;
lockdata["vop_" $2, $3, "OK"] = $5;
lockdata["vop_" $2, $3, "Error"] = $6;
continue;
Update this to be able to output ASSERT_VOP_(UN)LOCKED() based on the lock specifications in kern/vnode_if.src. At present, this do not distinguish between exclusive and shared locks, and the kernel is so full of bugs in this area that running with auto-generation of assertions enabled makes DEBUG_VFS_LOCKS totally useless for anybody that has used it for anything prior to outputting automated assertions. Due to this, I made vnode_if.sh only output locking assertions if you have the environment variable DEBUG_ALL_VFS_LOCKS set to "YES". In order to actually use the assertions, you need to also add "options DEBUG_VFS_LOCKS" to your kernel config file. Urged to commit by: phk
1999-09-26 18:31:51 +00:00
}
Return vnode_if back to its AWK roots. It became a Perl script in rev 1.20. This removes one more dependence on perl for the kernel build.
2002-03-01 01:20:23 +00:00
Assertion code specifications are introduced using special character sequences that are distinct from comments. %% is used for argument locks; %! for pre- and post-conditions.
2006-05-30 20:49:54 +00:00
if ($1 ~ /^%!/) {
- Add two checks for syntax errors - Improve error reporting - Remove redundant conditionals
2006-05-30 21:13:28 +00:00
if (NF != 4 ||
vfs: inline vops if there are no pre/post associated calls This removes a level of indirection from frequently used methods, most notably VOP_LOCK1 and VOP_UNLOCK1. Tested by: pho
2020-07-30 15:50:51 +00:00
($3 != "pre" && $3 != "post" &&
$3 != "debugpre" && $3 != "debugpost")) {
- Add two checks for syntax errors - Improve error reporting - Remove redundant conditionals
2006-05-30 21:13:28 +00:00
die("Invalid %s construction", "%!");
Add a new configuration directive that inserts calls to debugging functions in the VOP inlines. This is intended to replace the simple locking specifications for calls that have more complicated behavior such as rename and lookup. The syntax of the new entries is: #! name pre/post function If the function is marked 'pre' it is executed prior to calling the VOP and takes a pointer to a struct vop_{name}_args as it's only parameter. If the function is marked 'post' it is executed after the VOP call and takes a pointer to a struct vop_{name}_args as it's first parameter and the integer return value from the vop as the second paramter.
2002-07-06 03:46:36 +00:00
continue;
- Add two checks for syntax errors - Improve error reporting - Remove redundant conditionals
2006-05-30 21:13:28 +00:00
}
Add a new configuration directive that inserts calls to debugging functions in the VOP inlines. This is intended to replace the simple locking specifications for calls that have more complicated behavior such as rename and lookup. The syntax of the new entries is: #! name pre/post function If the function is marked 'pre' it is executed prior to calling the VOP and takes a pointer to a struct vop_{name}_args as it's only parameter. If the function is marked 'post' it is executed after the VOP call and takes a pointer to a struct vop_{name}_args as it's first parameter and the integer return value from the vop as the second paramter.
2002-07-06 03:46:36 +00:00
lockdata["vop_" $2, $3] = $4;
continue;
}
- Add two checks for syntax errors - Improve error reporting - Remove redundant conditionals
2006-05-30 21:13:28 +00:00
if ($1 ~ /^#/)
Add a new configuration directive that inserts calls to debugging functions in the VOP inlines. This is intended to replace the simple locking specifications for calls that have more complicated behavior such as rename and lookup. The syntax of the new entries is: #! name pre/post function If the function is marked 'pre' it is executed prior to calling the VOP and takes a pointer to a struct vop_{name}_args as it's only parameter. If the function is marked 'post' it is executed after the VOP call and takes a pointer to a struct vop_{name}_args as it's first parameter and the integer return value from the vop as the second paramter.
2002-07-06 03:46:36 +00:00
continue;
Return vnode_if back to its AWK roots. It became a Perl script in rev 1.20. This removes one more dependence on perl for the kernel build.
2002-03-01 01:20:23 +00:00
# Get the function name.
name = $1;
uname = toupper(name);
- Automatically generate and insert KTR points in all VOPs.
2002-09-23 05:50:07 +00:00
Return vnode_if back to its AWK roots. It became a Perl script in rev 1.20. This removes one more dependence on perl for the kernel build.
2002-03-01 01:20:23 +00:00
# Get the function arguments.
for (numargs = 0; ; ++numargs) {
if ((getline < srcfile) <= 0) {
die("Unable to read through the arguments for \"%s\"",
name);
Update this to be able to output ASSERT_VOP_(UN)LOCKED() based on the lock specifications in kern/vnode_if.src. At present, this do not distinguish between exclusive and shared locks, and the kernel is so full of bugs in this area that running with auto-generation of assertions enabled makes DEBUG_VFS_LOCKS totally useless for anybody that has used it for anything prior to outputting automated assertions. Due to this, I made vnode_if.sh only output locking assertions if you have the environment variable DEBUG_ALL_VFS_LOCKS set to "YES". In order to actually use the assertions, you need to also add "options DEBUG_VFS_LOCKS" to your kernel config file. Urged to commit by: phk
1999-09-26 18:31:51 +00:00
}
- Add two checks for syntax errors - Improve error reporting - Remove redundant conditionals
2006-05-30 21:13:28 +00:00
fnr++;
Return vnode_if back to its AWK roots. It became a Perl script in rev 1.20. This removes one more dependence on perl for the kernel build.
2002-03-01 01:20:23 +00:00
if ($1 ~ /^\};/)
break;
# Delete comments, if any.
gsub (/\/\*.*\*\//, "");
# Condense whitespace and delete leading/trailing space.
gsub(/[[:space:]]+/, " ");
sub(/^ /, "");
sub(/ $/, "");
# Pick off direction.
if ($1 != "INOUT" && $1 != "IN" && $1 != "OUT")
die("No IN/OUT direction for \"%s\".", $0);
dirs[numargs] = $1;
sub(/^[A-Z]* /, "");
if ((reles[numargs] = $1) == "WILLRELE")
sub(/^[A-Z]* /, "");
else
reles[numargs] = "WONTRELE";
# kill trailing ;
if (sub(/;$/, "") < 1)
die("Missing end-of-line ; in \"%s\".", $0);
# pick off variable name
if ((argp = match($0, /[A-Za-z0-9_]+$/)) < 1)
die("Missing var name \"a_foo\" in \"%s\".", $0);
args[numargs] = substr($0, argp);
$0 = substr($0, 1, argp - 1);
# what is left must be type
# remove trailing space (if any)
sub(/ $/, "");
types[numargs] = $0;
Update this to be able to output ASSERT_VOP_(UN)LOCKED() based on the lock specifications in kern/vnode_if.src. At present, this do not distinguish between exclusive and shared locks, and the kernel is so full of bugs in this area that running with auto-generation of assertions enabled makes DEBUG_VFS_LOCKS totally useless for anybody that has used it for anything prior to outputting automated assertions. Due to this, I made vnode_if.sh only output locking assertions if you have the environment variable DEBUG_ALL_VFS_LOCKS set to "YES". In order to actually use the assertions, you need to also add "options DEBUG_VFS_LOCKS" to your kernel config file. Urged to commit by: phk
1999-09-26 18:31:51 +00:00
}
- Add new machine parsable KTR macros for timing events. - Use this new format to automatically handle syscalls and VOPs. This changes the earlier format but is still human readable. Sponsored by: EMC / Isilon Storage Division
2012-12-19 20:10:00 +00:00
if (numargs > 4)
ctrargs = 4;
- Automatically generate and insert KTR points in all VOPs.
2002-09-23 05:50:07 +00:00
else
ctrargs = numargs;
Fix build on ARM (and probably other platforms)
2012-12-28 06:52:53 +00:00
ctrstr = ctrargs "(KTR_VOP, \"VOP\", \"" uname "\", (uintptr_t)a,\n\t ";
- Add new machine parsable KTR macros for timing events. - Use this new format to automatically handle syscalls and VOPs. This changes the earlier format but is still human readable. Sponsored by: EMC / Isilon Storage Division
2012-12-19 20:10:00 +00:00
ctrstr = ctrstr "\"" args[0] ":0x%jX\", (uintptr_t)a->a_" args[0];
Change the generated VOP_ macro implementations to improve type checking and KASSERT coverage. After this check there is only one "nasty" cast in this code but there is a KASSERT to protect against the wrong argument structure behind that cast. Un-inlining the meat of VOP_FOO() saves 35kB of text segment on a typical kernel with no change in performance. We also now run the checking and tracing on VOP's which have been layered by nullfs, umapfs, deadfs or unionfs. Add new (non-inline) VOP_FOO_AP() functions which take a "struct foo_args" argument and does everything the VOP_FOO() macros used to do with checks and debugging code. Add KASSERT to VOP_FOO_AP() check for argument type being correct. Slim down VOP_FOO() inline functions to just stuff arguments into the struct foo_args and call VOP_FOO_AP(). Put function pointer to VOP_FOO_AP() into vop_foo_desc structure and make VCALL() use it instead of the current offsetoff() hack. Retire vcall() which implemented the offsetoff() Make deadfs and unionfs use VOP_FOO_AP() calls instead of VCALL(), we know which specific call we want already. Remove unneeded arguments to VCALL() in nullfs and umapfs bypass functions. Remove unused vdesc_offset and VOFFSET(). Generally improve style/readability of the generated code.
2005-01-13 07:53:01 +00:00
for (i = 1; i < ctrargs; ++i)
- Add new machine parsable KTR macros for timing events. - Use this new format to automatically handle syscalls and VOPs. This changes the earlier format but is still human readable. Sponsored by: EMC / Isilon Storage Division
2012-12-19 20:10:00 +00:00
ctrstr = ctrstr ", \"" args[i] ":0x%jX\", a->a_" args[i];
- Automatically generate and insert KTR points in all VOPs.
2002-09-23 05:50:07 +00:00
ctrstr = ctrstr ");";
Use a seperate -c and -h mode. The vnode_if.c file is compiled only into the kernel while the vnode_if.h header is a bunch of inlines to call the code that is in the kernel. Generating the .h file on the fly is kinda bogus because it has to match the one compiled into the kernel. IMHO we should have kern/vnode_if.c and sys/vnode_if.h committed in the tree but that's another battle.
1999-12-12 16:43:05 +00:00
Back when VOP_* was introduced, we did not have new-style struct initializations but we did have lofty goals and big ideals. Adjust to more contemporary circumstances and gain type checking. Replace the entire vop_t frobbing thing with properly typed structures. The only casualty is that we can not add a new VOP_ method with a loadable module. History has not given us reason to belive this would ever be feasible in the the first place. Eliminate in toto VOCALL(), vop_t, VNODEOP_SET() etc. Give coda correct prototypes and function definitions for all vop_()s. Generate a bit more data from the vnode_if.src file: a struct vop_vector and protype typedefs for all vop methods. Add a new vop_bypass() and make vop_default be a pointer to another struct vop_vector. Remove a lot of vfs_init since vop_vector is ready to use from the compiler. Cast various vop_mumble() to void * with uppercase name, for instance VOP_PANIC, VOP_NULL etc. Implement VCALL() by making vdesc_offset the offsetof() the relevant function pointer in vop_vector. This is disgusting but since the code is generated by a script comparatively safe. The alternative for nullfs etc. would be much worse. Fix up all vnode method vectors to remove casts so they become typesafe. (The bulk of this is generated by scripts)
2004-12-01 23:16:38 +00:00
if (pfile) {
printp("\t"name"_t\t*"name";")
}
if (qfile) {
printq("struct "name"_args;")
printq("typedef int "name"_t(struct "name"_args *);\n")
}
Return vnode_if back to its AWK roots. It became a Perl script in rev 1.20. This removes one more dependence on perl for the kernel build.
2002-03-01 01:20:23 +00:00
if (hfile) {
# Print out the vop_F_args structure.
Rather than casting through a (void *) to avoid the aliasing warning, do things correctly from an aliasing perspective. Put the vop_generic_args element as the first element for all the vop_*_args and adjust the code to take the address of that instead of the structure. OK'd based on a vague description by: phk
2004-12-13 07:23:34 +00:00
printh("struct "name"_args {\n\tstruct vop_generic_args a_gen;");
Return vnode_if back to its AWK roots. It became a Perl script in rev 1.20. This removes one more dependence on perl for the kernel build.
2002-03-01 01:20:23 +00:00
for (i = 0; i < numargs; ++i)
printh("\t" t_spc(types[i]) "a_" args[i] ";");
printh("};");
Change the generated VOP_ macro implementations to improve type checking and KASSERT coverage. After this check there is only one "nasty" cast in this code but there is a KASSERT to protect against the wrong argument structure behind that cast. Un-inlining the meat of VOP_FOO() saves 35kB of text segment on a typical kernel with no change in performance. We also now run the checking and tracing on VOP's which have been layered by nullfs, umapfs, deadfs or unionfs. Add new (non-inline) VOP_FOO_AP() functions which take a "struct foo_args" argument and does everything the VOP_FOO() macros used to do with checks and debugging code. Add KASSERT to VOP_FOO_AP() check for argument type being correct. Slim down VOP_FOO() inline functions to just stuff arguments into the struct foo_args and call VOP_FOO_AP(). Put function pointer to VOP_FOO_AP() into vop_foo_desc structure and make VCALL() use it instead of the current offsetoff() hack. Retire vcall() which implemented the offsetoff() Make deadfs and unionfs use VOP_FOO_AP() calls instead of VCALL(), we know which specific call we want already. Remove unneeded arguments to VCALL() in nullfs and umapfs bypass functions. Remove unused vdesc_offset and VOFFSET(). Generally improve style/readability of the generated code.
2005-01-13 07:53:01 +00:00
printh("");
Return vnode_if back to its AWK roots. It became a Perl script in rev 1.20. This removes one more dependence on perl for the kernel build.
2002-03-01 01:20:23 +00:00
# Print out extern declaration.
printh("extern struct vnodeop_desc " name "_desc;");
Change the generated VOP_ macro implementations to improve type checking and KASSERT coverage. After this check there is only one "nasty" cast in this code but there is a KASSERT to protect against the wrong argument structure behind that cast. Un-inlining the meat of VOP_FOO() saves 35kB of text segment on a typical kernel with no change in performance. We also now run the checking and tracing on VOP's which have been layered by nullfs, umapfs, deadfs or unionfs. Add new (non-inline) VOP_FOO_AP() functions which take a "struct foo_args" argument and does everything the VOP_FOO() macros used to do with checks and debugging code. Add KASSERT to VOP_FOO_AP() check for argument type being correct. Slim down VOP_FOO() inline functions to just stuff arguments into the struct foo_args and call VOP_FOO_AP(). Put function pointer to VOP_FOO_AP() into vop_foo_desc structure and make VCALL() use it instead of the current offsetoff() hack. Retire vcall() which implemented the offsetoff() Make deadfs and unionfs use VOP_FOO_AP() calls instead of VCALL(), we know which specific call we want already. Remove unneeded arguments to VCALL() in nullfs and umapfs bypass functions. Remove unused vdesc_offset and VOFFSET(). Generally improve style/readability of the generated code.
2005-01-13 07:53:01 +00:00
printh("");
Return vnode_if back to its AWK roots. It became a Perl script in rev 1.20. This removes one more dependence on perl for the kernel build.
2002-03-01 01:20:23 +00:00
Change the generated VOP_ macro implementations to improve type checking and KASSERT coverage. After this check there is only one "nasty" cast in this code but there is a KASSERT to protect against the wrong argument structure behind that cast. Un-inlining the meat of VOP_FOO() saves 35kB of text segment on a typical kernel with no change in performance. We also now run the checking and tracing on VOP's which have been layered by nullfs, umapfs, deadfs or unionfs. Add new (non-inline) VOP_FOO_AP() functions which take a "struct foo_args" argument and does everything the VOP_FOO() macros used to do with checks and debugging code. Add KASSERT to VOP_FOO_AP() check for argument type being correct. Slim down VOP_FOO() inline functions to just stuff arguments into the struct foo_args and call VOP_FOO_AP(). Put function pointer to VOP_FOO_AP() into vop_foo_desc structure and make VCALL() use it instead of the current offsetoff() hack. Retire vcall() which implemented the offsetoff() Make deadfs and unionfs use VOP_FOO_AP() calls instead of VCALL(), we know which specific call we want already. Remove unneeded arguments to VCALL() in nullfs and umapfs bypass functions. Remove unused vdesc_offset and VOFFSET(). Generally improve style/readability of the generated code.
2005-01-13 07:53:01 +00:00
# Print out function prototypes.
printh("int " uname "_AP(struct " name "_args *);");
Add VOP_FOO_APV() which takes a pointer to the vop_vector. This allows stacked or partitioned filesystems to say "Continue the normal resolution from here", for instace from FFS to UFS. Use VNASSERT() instead of KASSERT().
2005-02-08 12:54:32 +00:00
printh("int " uname "_APV(struct vop_vector *vop, struct " name "_args *);");
Change the generated VOP_ macro implementations to improve type checking and KASSERT coverage. After this check there is only one "nasty" cast in this code but there is a KASSERT to protect against the wrong argument structure behind that cast. Un-inlining the meat of VOP_FOO() saves 35kB of text segment on a typical kernel with no change in performance. We also now run the checking and tracing on VOP's which have been layered by nullfs, umapfs, deadfs or unionfs. Add new (non-inline) VOP_FOO_AP() functions which take a "struct foo_args" argument and does everything the VOP_FOO() macros used to do with checks and debugging code. Add KASSERT to VOP_FOO_AP() check for argument type being correct. Slim down VOP_FOO() inline functions to just stuff arguments into the struct foo_args and call VOP_FOO_AP(). Put function pointer to VOP_FOO_AP() into vop_foo_desc structure and make VCALL() use it instead of the current offsetoff() hack. Retire vcall() which implemented the offsetoff() Make deadfs and unionfs use VOP_FOO_AP() calls instead of VCALL(), we know which specific call we want already. Remove unneeded arguments to VCALL() in nullfs and umapfs bypass functions. Remove unused vdesc_offset and VOFFSET(). Generally improve style/readability of the generated code.
2005-01-13 07:53:01 +00:00
printh("");
Return vnode_if back to its AWK roots. It became a Perl script in rev 1.20. This removes one more dependence on perl for the kernel build.
2002-03-01 01:20:23 +00:00
printh("static __inline int " uname "(");
for (i = 0; i < numargs; ++i) {
printh("\t" t_spc(types[i]) args[i] \
(i < numargs - 1 ? "," : ")"));
}
Change the generated VOP_ macro implementations to improve type checking and KASSERT coverage. After this check there is only one "nasty" cast in this code but there is a KASSERT to protect against the wrong argument structure behind that cast. Un-inlining the meat of VOP_FOO() saves 35kB of text segment on a typical kernel with no change in performance. We also now run the checking and tracing on VOP's which have been layered by nullfs, umapfs, deadfs or unionfs. Add new (non-inline) VOP_FOO_AP() functions which take a "struct foo_args" argument and does everything the VOP_FOO() macros used to do with checks and debugging code. Add KASSERT to VOP_FOO_AP() check for argument type being correct. Slim down VOP_FOO() inline functions to just stuff arguments into the struct foo_args and call VOP_FOO_AP(). Put function pointer to VOP_FOO_AP() into vop_foo_desc structure and make VCALL() use it instead of the current offsetoff() hack. Retire vcall() which implemented the offsetoff() Make deadfs and unionfs use VOP_FOO_AP() calls instead of VCALL(), we know which specific call we want already. Remove unneeded arguments to VCALL() in nullfs and umapfs bypass functions. Remove unused vdesc_offset and VOFFSET(). Generally improve style/readability of the generated code.
2005-01-13 07:53:01 +00:00
printh("{");
printh("\tstruct " name "_args a;");
printh("");
Get rid of the VDESC() macro while the pot is boiling anyway, it is only used from generate files now, so we might as well generate the right stuff from the start.
2005-01-13 08:05:20 +00:00
printh("\ta.a_gen.a_desc = &" name "_desc;");
Return vnode_if back to its AWK roots. It became a Perl script in rev 1.20. This removes one more dependence on perl for the kernel build.
2002-03-01 01:20:23 +00:00
for (i = 0; i < numargs; ++i)
printh("\ta.a_" args[i] " = " args[i] ";");
vfs: inline vops if there are no pre/post associated calls This removes a level of indirection from frequently used methods, most notably VOP_LOCK1 and VOP_UNLOCK1. Tested by: pho
2020-07-30 15:50:51 +00:00
if (can_inline(name)) {
printh("\n#if !defined(DEBUG_VFS_LOCKS) && !defined(INVARIANTS) && !defined(KTR)");
printh("\tif (!SDT_PROBES_ENABLED())");
printh("\t\treturn (" args[0]"->v_op->"name"(&a));");
printh("\telse");
printh("\t\treturn (" uname "_APV("args[0]"->v_op, &a));");
printh("#else");
}
Add VOP_FOO_APV() which takes a pointer to the vop_vector. This allows stacked or partitioned filesystems to say "Continue the normal resolution from here", for instace from FFS to UFS. Use VNASSERT() instead of KASSERT().
2005-02-08 12:54:32 +00:00
printh("\treturn (" uname "_APV("args[0]"->v_op, &a));");
vfs: inline vops if there are no pre/post associated calls This removes a level of indirection from frequently used methods, most notably VOP_LOCK1 and VOP_UNLOCK1. Tested by: pho
2020-07-30 15:50:51 +00:00
if (can_inline(name))
printh("#endif");
- Add automatic post vop debug checks. These work in both the success and failure cases.
2002-07-30 08:52:00 +00:00
printh("}");
Change the generated VOP_ macro implementations to improve type checking and KASSERT coverage. After this check there is only one "nasty" cast in this code but there is a KASSERT to protect against the wrong argument structure behind that cast. Un-inlining the meat of VOP_FOO() saves 35kB of text segment on a typical kernel with no change in performance. We also now run the checking and tracing on VOP's which have been layered by nullfs, umapfs, deadfs or unionfs. Add new (non-inline) VOP_FOO_AP() functions which take a "struct foo_args" argument and does everything the VOP_FOO() macros used to do with checks and debugging code. Add KASSERT to VOP_FOO_AP() check for argument type being correct. Slim down VOP_FOO() inline functions to just stuff arguments into the struct foo_args and call VOP_FOO_AP(). Put function pointer to VOP_FOO_AP() into vop_foo_desc structure and make VCALL() use it instead of the current offsetoff() hack. Retire vcall() which implemented the offsetoff() Make deadfs and unionfs use VOP_FOO_AP() calls instead of VCALL(), we know which specific call we want already. Remove unneeded arguments to VCALL() in nullfs and umapfs bypass functions. Remove unused vdesc_offset and VOFFSET(). Generally improve style/readability of the generated code.
2005-01-13 07:53:01 +00:00
printh("");
Use a seperate -c and -h mode. The vnode_if.c file is compiled only into the kernel while the vnode_if.h header is a bunch of inlines to call the code that is in the kernel. Generating the .h file on the fly is kinda bogus because it has to match the one compiled into the kernel. IMHO we should have kern/vnode_if.c and sys/vnode_if.h committed in the tree but that's another battle.
1999-12-12 16:43:05 +00:00
}
Update this to be able to output ASSERT_VOP_(UN)LOCKED() based on the lock specifications in kern/vnode_if.src. At present, this do not distinguish between exclusive and shared locks, and the kernel is so full of bugs in this area that running with auto-generation of assertions enabled makes DEBUG_VFS_LOCKS totally useless for anybody that has used it for anything prior to outputting automated assertions. Due to this, I made vnode_if.sh only output locking assertions if you have the environment variable DEBUG_ALL_VFS_LOCKS set to "YES". In order to actually use the assertions, you need to also add "options DEBUG_VFS_LOCKS" to your kernel config file. Urged to commit by: phk
1999-09-26 18:31:51 +00:00
Return vnode_if back to its AWK roots. It became a Perl script in rev 1.20. This removes one more dependence on perl for the kernel build.
2002-03-01 01:20:23 +00:00
if (cfile) {
vfs: flatten vop vectors This eliminates the following loop from all VOP calls: while(vop != NULL && \ vop->vop_spare2 == NULL && vop->vop_bypass == NULL) vop = vop->vop_default; Reviewed by: jeff Tesetd by: pho Differential Revision: https://reviews.freebsd.org/D22738
2019-12-16 00:06:22 +00:00
funcarr[name] = 1;
Return vnode_if back to its AWK roots. It became a Perl script in rev 1.20. This removes one more dependence on perl for the kernel build.
2002-03-01 01:20:23 +00:00
# Print out the vop_F_vp_offsets structure. This all depends
# on naming conventions and nothing else.
printc("static int " name "_vp_offsets[] = {");
# as a side effect, figure out the releflags
releflags = "";
vpnum = 0;
for (i = 0; i < numargs; i++) {
if (types[i] == "struct vnode *") {
printc("\tVOPARG_OFFSETOF(struct " name \
"_args,a_" args[i] "),");
if (reles[i] == "WILLRELE") {
releflags = releflags \
"|VDESC_VP" vpnum "_WILLRELE";
}
vpnum++;
}
}
Update this to be able to output ASSERT_VOP_(UN)LOCKED() based on the lock specifications in kern/vnode_if.src. At present, this do not distinguish between exclusive and shared locks, and the kernel is so full of bugs in this area that running with auto-generation of assertions enabled makes DEBUG_VFS_LOCKS totally useless for anybody that has used it for anything prior to outputting automated assertions. Due to this, I made vnode_if.sh only output locking assertions if you have the environment variable DEBUG_ALL_VFS_LOCKS set to "YES". In order to actually use the assertions, you need to also add "options DEBUG_VFS_LOCKS" to your kernel config file. Urged to commit by: phk
1999-09-26 18:31:51 +00:00
Return vnode_if back to its AWK roots. It became a Perl script in rev 1.20. This removes one more dependence on perl for the kernel build.
2002-03-01 01:20:23 +00:00
sub(/^\|/, "", releflags);
printc("\tVDESC_NO_OFFSET");
printc("};");
Add SDT DTrace probes for VFS vnode operations in the vfs:vop provider namespace. These are inserted dynamically into the VOP_..._AP() functions created from vnode_if.src. Each VOP has entry and return probes, as arg0 the primary vnode, arg1 the vnode operation argument structure pointer, providing access to IN and OUT arguments, and for return probes, arg2 the return value. MFC after: 1 month Sponsored by: Google, Inc.
2009-03-29 03:30:15 +00:00
printc("\n");
dtrace sdt: remove the ugly sname parameter of SDT_PROBE_DEFINE In its stead use the Solaris / illumos approach of emulating '-' (dash) in probe names with '__' (two consecutive underscores). Reviewed by: markj MFC after: 3 weeks
2013-11-26 08:46:27 +00:00
printc("SDT_PROBE_DEFINE2(vfs, vop, " name ", entry, \"struct vnode *\", \"struct " name "_args *\");\n");
printc("SDT_PROBE_DEFINE3(vfs, vop, " name ", return, \"struct vnode *\", \"struct " name "_args *\", \"int\");\n");
Add SDT DTrace probes for VFS vnode operations in the vfs:vop provider namespace. These are inserted dynamically into the VOP_..._AP() functions created from vnode_if.src. Each VOP has entry and return probes, as arg0 the primary vnode, arg1 the vnode operation argument structure pointer, providing access to IN and OUT arguments, and for return probes, arg2 the return value. MFC after: 1 month Sponsored by: Google, Inc.
2009-03-29 03:30:15 +00:00
Change the generated VOP_ macro implementations to improve type checking and KASSERT coverage. After this check there is only one "nasty" cast in this code but there is a KASSERT to protect against the wrong argument structure behind that cast. Un-inlining the meat of VOP_FOO() saves 35kB of text segment on a typical kernel with no change in performance. We also now run the checking and tracing on VOP's which have been layered by nullfs, umapfs, deadfs or unionfs. Add new (non-inline) VOP_FOO_AP() functions which take a "struct foo_args" argument and does everything the VOP_FOO() macros used to do with checks and debugging code. Add KASSERT to VOP_FOO_AP() check for argument type being correct. Slim down VOP_FOO() inline functions to just stuff arguments into the struct foo_args and call VOP_FOO_AP(). Put function pointer to VOP_FOO_AP() into vop_foo_desc structure and make VCALL() use it instead of the current offsetoff() hack. Retire vcall() which implemented the offsetoff() Make deadfs and unionfs use VOP_FOO_AP() calls instead of VCALL(), we know which specific call we want already. Remove unneeded arguments to VCALL() in nullfs and umapfs bypass functions. Remove unused vdesc_offset and VOFFSET(). Generally improve style/readability of the generated code.
2005-01-13 07:53:01 +00:00
# Print out function.
printc("\nint\n" uname "_AP(struct " name "_args *a)");
printc("{");
Add VOP_FOO_APV() which takes a pointer to the vop_vector. This allows stacked or partitioned filesystems to say "Continue the normal resolution from here", for instace from FFS to UFS. Use VNASSERT() instead of KASSERT().
2005-02-08 12:54:32 +00:00
printc("");
printc("\treturn(" uname "_APV(a->a_" args[0] "->v_op, a));");
printc("}");
printc("\nint\n" uname "_APV(struct vop_vector *vop, struct " name "_args *a)");
printc("{");
Change the generated VOP_ macro implementations to improve type checking and KASSERT coverage. After this check there is only one "nasty" cast in this code but there is a KASSERT to protect against the wrong argument structure behind that cast. Un-inlining the meat of VOP_FOO() saves 35kB of text segment on a typical kernel with no change in performance. We also now run the checking and tracing on VOP's which have been layered by nullfs, umapfs, deadfs or unionfs. Add new (non-inline) VOP_FOO_AP() functions which take a "struct foo_args" argument and does everything the VOP_FOO() macros used to do with checks and debugging code. Add KASSERT to VOP_FOO_AP() check for argument type being correct. Slim down VOP_FOO() inline functions to just stuff arguments into the struct foo_args and call VOP_FOO_AP(). Put function pointer to VOP_FOO_AP() into vop_foo_desc structure and make VCALL() use it instead of the current offsetoff() hack. Retire vcall() which implemented the offsetoff() Make deadfs and unionfs use VOP_FOO_AP() calls instead of VCALL(), we know which specific call we want already. Remove unneeded arguments to VCALL() in nullfs and umapfs bypass functions. Remove unused vdesc_offset and VOFFSET(). Generally improve style/readability of the generated code.
2005-01-13 07:53:01 +00:00
printc("\tint rc;");
printc("");
Add VOP_FOO_APV() which takes a pointer to the vop_vector. This allows stacked or partitioned filesystems to say "Continue the normal resolution from here", for instace from FFS to UFS. Use VNASSERT() instead of KASSERT().
2005-02-08 12:54:32 +00:00
printc("\tVNASSERT(a->a_gen.a_desc == &" name "_desc, a->a_" args[0]",");
printc("\t (\"Wrong a_desc in " name "(%p, %p)\", a->a_" args[0]", a));");
printc("\tVNASSERT(vop != NULL, a->a_" args[0]", (\"No "name"(%p, %p)\", a->a_" args[0]", a));")
- Add new machine parsable KTR macros for timing events. - Use this new format to automatically handle syscalls and VOPs. This changes the earlier format but is still human readable. Sponsored by: EMC / Isilon Storage Division
2012-12-19 20:10:00 +00:00
printc("\tKTR_START" ctrstr);
vfs: inline vops if there are no pre/post associated calls This removes a level of indirection from frequently used methods, most notably VOP_LOCK1 and VOP_UNLOCK1. Tested by: pho
2020-07-30 15:50:51 +00:00
add_debugpre(name);
Allow EVFILT_VNODE events to work on every filesystem type, not just UFS by: - Making the pre and post hooks for the VOP functions work even when DEBUG_VFS_LOCKS is not defined. - Moving the KNOTE activations into the corresponding VOP hooks. - Creating a MNTK_NOKNOTE flag for the mnt_kern_flag field of struct mount that permits filesystems to disable the new behavior. - Creating a default VOP_KQFILTER function: vfs_kqfilter() My benchmarks have not revealed any performance degradation. Reviewed by: jeff, bde Approved by: rwatson, jmg (kqueue changes), grehan (mentor)
2005-06-09 20:20:31 +00:00
add_pre(name);
vfs: allow tail call optimisation in vops in the common case Most frequently used vops boil down to checking SDT probes, doing the call and checking again. There is no vop_post/pre in their case but the check after the call prevents tail call optimisation from taking place. Instead, check once upfront. Kernels with debug or vops with non-empty vop_post still don't short circuit. Reviewed by: kib Tested by: pho Differential Revision: https://reviews.freebsd.org/D22739
2019-12-16 00:07:51 +00:00
for (i = 0; i < numargs; ++i)
add_debug_code(name, args[i], "Entry", "\t");
vfs: stop null checking routines in vop wrappers Calls to vop_bypass pass the same argument, but type casted to something else. Thus by replacing NULL routines with vop_bypass we avoid a runtime check. Reviewed by: kib Differential Revision: https://reviews.freebsd.org/D23357
2020-01-26 00:41:38 +00:00
printc("\tif (!SDT_PROBES_ENABLED()) {");
Change the generated VOP_ macro implementations to improve type checking and KASSERT coverage. After this check there is only one "nasty" cast in this code but there is a KASSERT to protect against the wrong argument structure behind that cast. Un-inlining the meat of VOP_FOO() saves 35kB of text segment on a typical kernel with no change in performance. We also now run the checking and tracing on VOP's which have been layered by nullfs, umapfs, deadfs or unionfs. Add new (non-inline) VOP_FOO_AP() functions which take a "struct foo_args" argument and does everything the VOP_FOO() macros used to do with checks and debugging code. Add KASSERT to VOP_FOO_AP() check for argument type being correct. Slim down VOP_FOO() inline functions to just stuff arguments into the struct foo_args and call VOP_FOO_AP(). Put function pointer to VOP_FOO_AP() into vop_foo_desc structure and make VCALL() use it instead of the current offsetoff() hack. Retire vcall() which implemented the offsetoff() Make deadfs and unionfs use VOP_FOO_AP() calls instead of VCALL(), we know which specific call we want already. Remove unneeded arguments to VCALL() in nullfs and umapfs bypass functions. Remove unused vdesc_offset and VOFFSET(). Generally improve style/readability of the generated code.
2005-01-13 07:53:01 +00:00
printc("\t\trc = vop->"name"(a);")
vfs: allow tail call optimisation in vops in the common case Most frequently used vops boil down to checking SDT probes, doing the call and checking again. There is no vop_post/pre in their case but the check after the call prevents tail call optimisation from taking place. Instead, check once upfront. Kernels with debug or vops with non-empty vop_post still don't short circuit. Reviewed by: kib Tested by: pho Differential Revision: https://reviews.freebsd.org/D22739
2019-12-16 00:07:51 +00:00
printc("\t} else {")
printc("\t\tSDT_PROBE2(vfs, vop, " name ", entry, a->a_" args[0] ", a);");
vfs: stop null checking routines in vop wrappers Calls to vop_bypass pass the same argument, but type casted to something else. Thus by replacing NULL routines with vop_bypass we avoid a runtime check. Reviewed by: kib Differential Revision: https://reviews.freebsd.org/D23357
2020-01-26 00:41:38 +00:00
printc("\t\trc = vop->"name"(a);")
vfs: allow tail call optimisation in vops in the common case Most frequently used vops boil down to checking SDT probes, doing the call and checking again. There is no vop_post/pre in their case but the check after the call prevents tail call optimisation from taking place. Instead, check once upfront. Kernels with debug or vops with non-empty vop_post still don't short circuit. Reviewed by: kib Tested by: pho Differential Revision: https://reviews.freebsd.org/D22739
2019-12-16 00:07:51 +00:00
printc("\t\tSDT_PROBE3(vfs, vop, " name ", return, a->a_" args[0] ", a, rc);");
printc("\t}")
Change the generated VOP_ macro implementations to improve type checking and KASSERT coverage. After this check there is only one "nasty" cast in this code but there is a KASSERT to protect against the wrong argument structure behind that cast. Un-inlining the meat of VOP_FOO() saves 35kB of text segment on a typical kernel with no change in performance. We also now run the checking and tracing on VOP's which have been layered by nullfs, umapfs, deadfs or unionfs. Add new (non-inline) VOP_FOO_AP() functions which take a "struct foo_args" argument and does everything the VOP_FOO() macros used to do with checks and debugging code. Add KASSERT to VOP_FOO_AP() check for argument type being correct. Slim down VOP_FOO() inline functions to just stuff arguments into the struct foo_args and call VOP_FOO_AP(). Put function pointer to VOP_FOO_AP() into vop_foo_desc structure and make VCALL() use it instead of the current offsetoff() hack. Retire vcall() which implemented the offsetoff() Make deadfs and unionfs use VOP_FOO_AP() calls instead of VCALL(), we know which specific call we want already. Remove unneeded arguments to VCALL() in nullfs and umapfs bypass functions. Remove unused vdesc_offset and VOFFSET(). Generally improve style/readability of the generated code.
2005-01-13 07:53:01 +00:00
printc("\tif (rc == 0) {");
for (i = 0; i < numargs; ++i)
add_debug_code(name, args[i], "OK", "\t\t");
printc("\t} else {");
for (i = 0; i < numargs; ++i)
add_debug_code(name, args[i], "Error", "\t\t");
printc("\t}");
Allow EVFILT_VNODE events to work on every filesystem type, not just UFS by: - Making the pre and post hooks for the VOP functions work even when DEBUG_VFS_LOCKS is not defined. - Moving the KNOTE activations into the corresponding VOP hooks. - Creating a MNTK_NOKNOTE flag for the mnt_kern_flag field of struct mount that permits filesystems to disable the new behavior. - Creating a default VOP_KQFILTER function: vfs_kqfilter() My benchmarks have not revealed any performance degradation. Reviewed by: jeff, bde Approved by: rwatson, jmg (kqueue changes), grehan (mentor)
2005-06-09 20:20:31 +00:00
add_post(name);
vfs: inline vops if there are no pre/post associated calls This removes a level of indirection from frequently used methods, most notably VOP_LOCK1 and VOP_UNLOCK1. Tested by: pho
2020-07-30 15:50:51 +00:00
add_debugpost(name);
- Add new machine parsable KTR macros for timing events. - Use this new format to automatically handle syscalls and VOPs. This changes the earlier format but is still human readable. Sponsored by: EMC / Isilon Storage Division
2012-12-19 20:10:00 +00:00
printc("\tKTR_STOP" ctrstr);
Change the generated VOP_ macro implementations to improve type checking and KASSERT coverage. After this check there is only one "nasty" cast in this code but there is a KASSERT to protect against the wrong argument structure behind that cast. Un-inlining the meat of VOP_FOO() saves 35kB of text segment on a typical kernel with no change in performance. We also now run the checking and tracing on VOP's which have been layered by nullfs, umapfs, deadfs or unionfs. Add new (non-inline) VOP_FOO_AP() functions which take a "struct foo_args" argument and does everything the VOP_FOO() macros used to do with checks and debugging code. Add KASSERT to VOP_FOO_AP() check for argument type being correct. Slim down VOP_FOO() inline functions to just stuff arguments into the struct foo_args and call VOP_FOO_AP(). Put function pointer to VOP_FOO_AP() into vop_foo_desc structure and make VCALL() use it instead of the current offsetoff() hack. Retire vcall() which implemented the offsetoff() Make deadfs and unionfs use VOP_FOO_AP() calls instead of VCALL(), we know which specific call we want already. Remove unneeded arguments to VCALL() in nullfs and umapfs bypass functions. Remove unused vdesc_offset and VOFFSET(). Generally improve style/readability of the generated code.
2005-01-13 07:53:01 +00:00
printc("\treturn (rc);");
printc("}\n");
Return vnode_if back to its AWK roots. It became a Perl script in rev 1.20. This removes one more dependence on perl for the kernel build.
2002-03-01 01:20:23 +00:00
# Print out the vnodeop_desc structure.
printc("struct vnodeop_desc " name "_desc = {");
# printable name
printc("\t\"" name "\",");
# flags
vppwillrele = "";
for (i = 0; i < numargs; i++) {
if (types[i] == "struct vnode **" && \
reles[i] == "WILLRELE") {
vppwillrele = "|VDESC_VPP_WILLRELE";
}
}
Update this to be able to output ASSERT_VOP_(UN)LOCKED() based on the lock specifications in kern/vnode_if.src. At present, this do not distinguish between exclusive and shared locks, and the kernel is so full of bugs in this area that running with auto-generation of assertions enabled makes DEBUG_VFS_LOCKS totally useless for anybody that has used it for anything prior to outputting automated assertions. Due to this, I made vnode_if.sh only output locking assertions if you have the environment variable DEBUG_ALL_VFS_LOCKS set to "YES". In order to actually use the assertions, you need to also add "options DEBUG_VFS_LOCKS" to your kernel config file. Urged to commit by: phk
1999-09-26 18:31:51 +00:00
Return vnode_if back to its AWK roots. It became a Perl script in rev 1.20. This removes one more dependence on perl for the kernel build.
2002-03-01 01:20:23 +00:00
if (!releflags)
releflags = "0";
printc("\t" releflags vppwillrele ",");
Only call sigdeferstop() for NFS. Use bypass to catch any NFS VOP dispatch and route it through the wrapper which does sigdeferstop() and then dispatches original VOP. NFS does not need a bypass below it, which is not supported. The vop offset in the vop_vector is added since otherwise it is impossible to get vop_op_t from the internal table, and I did not wanted to create the layered fs only to wrap NFS VOPs. VFS_OP()s wrap is straightforward. Requested and reviewed by: mjg (previous version) Tested by: pho Sponsored by: The FreeBSD Foundation Differential revision: https://reviews.freebsd.org/D17658
2018-10-23 21:43:41 +00:00
# index in struct vop_vector
printc("\t__offsetof(struct vop_vector, " name "),");
Change the generated VOP_ macro implementations to improve type checking and KASSERT coverage. After this check there is only one "nasty" cast in this code but there is a KASSERT to protect against the wrong argument structure behind that cast. Un-inlining the meat of VOP_FOO() saves 35kB of text segment on a typical kernel with no change in performance. We also now run the checking and tracing on VOP's which have been layered by nullfs, umapfs, deadfs or unionfs. Add new (non-inline) VOP_FOO_AP() functions which take a "struct foo_args" argument and does everything the VOP_FOO() macros used to do with checks and debugging code. Add KASSERT to VOP_FOO_AP() check for argument type being correct. Slim down VOP_FOO() inline functions to just stuff arguments into the struct foo_args and call VOP_FOO_AP(). Put function pointer to VOP_FOO_AP() into vop_foo_desc structure and make VCALL() use it instead of the current offsetoff() hack. Retire vcall() which implemented the offsetoff() Make deadfs and unionfs use VOP_FOO_AP() calls instead of VCALL(), we know which specific call we want already. Remove unneeded arguments to VCALL() in nullfs and umapfs bypass functions. Remove unused vdesc_offset and VOFFSET(). Generally improve style/readability of the generated code.
2005-01-13 07:53:01 +00:00
# function to call
Eradicate caddr_t from the VFS API.
2005-12-14 00:49:52 +00:00
printc("\t(vop_bypass_t *)" uname "_AP,");
Return vnode_if back to its AWK roots. It became a Perl script in rev 1.20. This removes one more dependence on perl for the kernel build.
2002-03-01 01:20:23 +00:00
# vp offsets
printc("\t" name "_vp_offsets,");
# vpp (if any)
printc("\t" find_arg_with_type("struct vnode **") ",");
# cred (if any)
printc("\t" find_arg_with_type("struct ucred *") ",");
# thread (if any)
printc("\t" find_arg_with_type("struct thread *") ",");
# componentname
printc("\t" find_arg_with_type("struct componentname *") ",");
# transport layer information
Nuke vnodeop_desc.vdesc_transports, which has been unused since the dawn of time (or the inception of ncvs, whichever came last)
2005-12-14 00:15:11 +00:00
printc("};\n");
Return vnode_if back to its AWK roots. It became a Perl script in rev 1.20. This removes one more dependence on perl for the kernel build.
2002-03-01 01:20:23 +00:00
}
Update this to be able to output ASSERT_VOP_(UN)LOCKED() based on the lock specifications in kern/vnode_if.src. At present, this do not distinguish between exclusive and shared locks, and the kernel is so full of bugs in this area that running with auto-generation of assertions enabled makes DEBUG_VFS_LOCKS totally useless for anybody that has used it for anything prior to outputting automated assertions. Due to this, I made vnode_if.sh only output locking assertions if you have the environment variable DEBUG_ALL_VFS_LOCKS set to "YES". In order to actually use the assertions, you need to also add "options DEBUG_VFS_LOCKS" to your kernel config file. Urged to commit by: phk
1999-09-26 18:31:51 +00:00
}
vfs: flatten vop vectors This eliminates the following loop from all VOP calls: while(vop != NULL && \ vop->vop_spare2 == NULL && vop->vop_bypass == NULL) vop = vop->vop_default; Reviewed by: jeff Tesetd by: pho Differential Revision: https://reviews.freebsd.org/D22738
2019-12-16 00:06:22 +00:00
if (cfile) {
printc("void");
printc("vfs_vector_op_register(struct vop_vector *orig_vop)");
printc("{");
printc("\tstruct vop_vector *vop;");
printc("");
printc("\tif (orig_vop->registered)");
printc("\t\tpanic(\"%s: vop_vector %p already registered\",")
printc("\t\t __func__, orig_vop);");
printc("");
for (name in funcarr) {
printc("\tvop = orig_vop;");
printc("\twhile (vop != NULL && \\");
printc("\t vop->"name" == NULL && vop->vop_bypass == NULL)")
printc("\t\tvop = vop->vop_default;")
printc("\tif (vop != NULL)");
printc("\t\torig_vop->"name" = vop->"name";");
printc("");
}
printc("\tvop = orig_vop;");
printc("\twhile (vop != NULL && vop->vop_bypass == NULL)")
printc("\t\tvop = vop->vop_default;")
printc("\tif (vop != NULL)");
printc("\t\torig_vop->vop_bypass = vop->vop_bypass;");
printc("");
vfs: stop null checking routines in vop wrappers Calls to vop_bypass pass the same argument, but type casted to something else. Thus by replacing NULL routines with vop_bypass we avoid a runtime check. Reviewed by: kib Differential Revision: https://reviews.freebsd.org/D23357
2020-01-26 00:41:38 +00:00
for (name in funcarr) {
printc("\tif (orig_vop->"name" == NULL)");
printc("\t\torig_vop->"name" = (void *)orig_vop->vop_bypass;");
}
printc("");
vfs: flatten vop vectors This eliminates the following loop from all VOP calls: while(vop != NULL && \ vop->vop_spare2 == NULL && vop->vop_bypass == NULL) vop = vop->vop_default; Reviewed by: jeff Tesetd by: pho Differential Revision: https://reviews.freebsd.org/D22738
2019-12-16 00:06:22 +00:00
printc("\torig_vop->registered = true;");
printc("}")
}
if (hfile) {
printh("void vfs_vector_op_register(struct vop_vector *orig_vop);");
}
if (pfile) {
printp("\tbool\tregistered;")
Back when VOP_* was introduced, we did not have new-style struct initializations but we did have lofty goals and big ideals. Adjust to more contemporary circumstances and gain type checking. Replace the entire vop_t frobbing thing with properly typed structures. The only casualty is that we can not add a new VOP_ method with a loadable module. History has not given us reason to belive this would ever be feasible in the the first place. Eliminate in toto VOCALL(), vop_t, VNODEOP_SET() etc. Give coda correct prototypes and function definitions for all vop_()s. Generate a bit more data from the vnode_if.src file: a struct vop_vector and protype typedefs for all vop methods. Add a new vop_bypass() and make vop_default be a pointer to another struct vop_vector. Remove a lot of vfs_init since vop_vector is ready to use from the compiler. Cast various vop_mumble() to void * with uppercase name, for instance VOP_PANIC, VOP_NULL etc. Implement VCALL() by making vdesc_offset the offsetof() the relevant function pointer in vop_vector. This is disgusting but since the code is generated by a script comparatively safe. The alternative for nullfs etc. would be much worse. Fix up all vnode method vectors to remove casts so they become typesafe. (The bulk of this is generated by scripts)
2004-12-01 23:16:38 +00:00
printp("};")
vfs: flatten vop vectors This eliminates the following loop from all VOP calls: while(vop != NULL && \ vop->vop_spare2 == NULL && vop->vop_bypass == NULL) vop = vop->vop_default; Reviewed by: jeff Tesetd by: pho Differential Revision: https://reviews.freebsd.org/D22738
2019-12-16 00:06:22 +00:00
}
Back when VOP_* was introduced, we did not have new-style struct initializations but we did have lofty goals and big ideals. Adjust to more contemporary circumstances and gain type checking. Replace the entire vop_t frobbing thing with properly typed structures. The only casualty is that we can not add a new VOP_ method with a loadable module. History has not given us reason to belive this would ever be feasible in the the first place. Eliminate in toto VOCALL(), vop_t, VNODEOP_SET() etc. Give coda correct prototypes and function definitions for all vop_()s. Generate a bit more data from the vnode_if.src file: a struct vop_vector and protype typedefs for all vop methods. Add a new vop_bypass() and make vop_default be a pointer to another struct vop_vector. Remove a lot of vfs_init since vop_vector is ready to use from the compiler. Cast various vop_mumble() to void * with uppercase name, for instance VOP_PANIC, VOP_NULL etc. Implement VCALL() by making vdesc_offset the offsetof() the relevant function pointer in vop_vector. This is disgusting but since the code is generated by a script comparatively safe. The alternative for nullfs etc. would be much worse. Fix up all vnode method vectors to remove casts so they become typesafe. (The bulk of this is generated by scripts)
2004-12-01 23:16:38 +00:00
Return vnode_if back to its AWK roots. It became a Perl script in rev 1.20. This removes one more dependence on perl for the kernel build.
2002-03-01 01:20:23 +00:00
if (hfile)
close(hfile);
if (cfile)
close(cfile);
Back when VOP_* was introduced, we did not have new-style struct initializations but we did have lofty goals and big ideals. Adjust to more contemporary circumstances and gain type checking. Replace the entire vop_t frobbing thing with properly typed structures. The only casualty is that we can not add a new VOP_ method with a loadable module. History has not given us reason to belive this would ever be feasible in the the first place. Eliminate in toto VOCALL(), vop_t, VNODEOP_SET() etc. Give coda correct prototypes and function definitions for all vop_()s. Generate a bit more data from the vnode_if.src file: a struct vop_vector and protype typedefs for all vop methods. Add a new vop_bypass() and make vop_default be a pointer to another struct vop_vector. Remove a lot of vfs_init since vop_vector is ready to use from the compiler. Cast various vop_mumble() to void * with uppercase name, for instance VOP_PANIC, VOP_NULL etc. Implement VCALL() by making vdesc_offset the offsetof() the relevant function pointer in vop_vector. This is disgusting but since the code is generated by a script comparatively safe. The alternative for nullfs etc. would be much worse. Fix up all vnode method vectors to remove casts so they become typesafe. (The bulk of this is generated by scripts)
2004-12-01 23:16:38 +00:00
if (pfile)
close(pfile);
Return vnode_if back to its AWK roots. It became a Perl script in rev 1.20. This removes one more dependence on perl for the kernel build.
2002-03-01 01:20:23 +00:00
close(srcfile);
Update this to be able to output ASSERT_VOP_(UN)LOCKED() based on the lock specifications in kern/vnode_if.src. At present, this do not distinguish between exclusive and shared locks, and the kernel is so full of bugs in this area that running with auto-generation of assertions enabled makes DEBUG_VFS_LOCKS totally useless for anybody that has used it for anything prior to outputting automated assertions. Due to this, I made vnode_if.sh only output locking assertions if you have the environment variable DEBUG_ALL_VFS_LOCKS set to "YES". In order to actually use the assertions, you need to also add "options DEBUG_VFS_LOCKS" to your kernel config file. Urged to commit by: phk
1999-09-26 18:31:51 +00:00
exit 0;
}
Reference in New Issue Copy Permalink