Archive-Team
/
zfs
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 103 Wiki Activity

Eliminate runtime function pointer mods in autotools checks 

PaX/GrSecurity patched kernels implement a dialect of C that relies on a
GCC plugin for enforcement. A basic idea in this dialect is that
function pointers in structures should not change during runtime.
This causes code that modifies function pointers at runtime to fail to
compile in many instances. The autotools checks rely on whether or
not small test cases compile against a given kernel. Some
autotools checks assume some default case if other cases fail. When one
of these autotools checks tests a PaX/GrSecurity patched kernel by
modifying a function pointer at runtime, the default case will be used.

Early detection of such situations is possible by relying on compiler
warnings, which are compiler errors when --enable-debug is used.
Unfortunately, very few people build ZFS with --enable-debug. The more
common situation is that these issues manifest themselves as runtime
failures in the form of NULL pointer exceptions.

Previous patches that addressed such issues with PaX/GrSecurity
compatibility largely relied on rewriting autotools checks to avoid
runtime function pointer modification or the addition of PaX/GrSecurity
specific checks. This patch takes the previous work to its logical
conclusion by eliminating the use of runtime function pointer
modification. This permits the removal of PaX-specific autotools checks
in favor of ones that work across all supported kernels.

This should resolve issues that were reported to occur with
PaX/GrSecurity-patched Linux 3.7.5 kernels on Gentoo Linux.

https://bugs.gentoo.org/show_bug.cgi?id=457176

We should be able to prevent future regressions in PaX/GrSecurity
compatibility by ensuring that all changes to ZFSOnLinux avoid runtime
function pointer modification. At the same time, this does not solve the
issue of silent failures triggering default cases in the autotools
check, which is what permitted these regressions to become runtime
failures in the first place. This will need to be addressed in a future
patch.

Reported-by: Marcin Mirosław <bug@mejor.pl>
Signed-off-by: Richard Yao <ryao@cs.stonybrook.edu>
Signed-off-by: Brian Behlendorf <behlendorf1@llnl.gov>
Closes #1300
This commit is contained in:
Richard Yao 2013-02-14 18:54:04 -05:00 committed by Brian Behlendorf
parent 8128bd89fb
commit c38367c73f
10 changed files with 113 additions and 150 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

25
config/kernel-bdev-block-device-operations.m4
View File

@ -7,24 +7,23 @@ AC_DEFUN([ZFS_AC_KERNEL_BDEV_BLOCK_DEVICE_OPERATIONS], [
EXTRA_KCFLAGS="${NO_UNUSED_BUT_SET_VARIABLE}" EXTRA_KCFLAGS="${NO_UNUSED_BUT_SET_VARIABLE}"
ZFS_LINUX_TRY_COMPILE([ ZFS_LINUX_TRY_COMPILE([
#include <linux/blkdev.h> #include <linux/blkdev.h>
],[
int (*blk_open) (struct block_device *, fmode_t) = NULL; int blk_open(struct block_device *bdev, fmode_t mode)
int (*blk_release) (struct gendisk *, fmode_t) = NULL; { return 0; }
int (*blk_ioctl) (struct block_device *, fmode_t, int blk_release(struct gendisk *g, fmode_t mode) { return 0; }
unsigned, unsigned long) = NULL; int blk_ioctl(struct block_device *bdev, fmode_t mode,
int (*blk_compat_ioctl) (struct block_device *, fmode_t, unsigned x, unsigned long y) { return 0; }
unsigned, unsigned long) = NULL; int blk_compat_ioctl(struct block_device * bdev, fmode_t mode,
struct block_device_operations blk_ops = { unsigned x, unsigned long y) { return 0; }
static const struct block_device_operations
bops __attribute__ ((unused)) = {
.open = blk_open, .open = blk_open,
.release = blk_release, .release = blk_release,
.ioctl = blk_ioctl, .ioctl = blk_ioctl,
.compat_ioctl = blk_compat_ioctl, .compat_ioctl = blk_compat_ioctl,
}; };
],[
blk_ops.open(NULL, 0);
blk_ops.release(NULL, 0);
blk_ops.ioctl(NULL, 0, 0, 0);
blk_ops.compat_ioctl(NULL, 0, 0, 0);
],[ ],[
AC_MSG_RESULT(struct block_device) AC_MSG_RESULT(struct block_device)
AC_DEFINE(HAVE_BDEV_BLOCK_DEVICE_OPERATIONS, 1, AC_DEFINE(HAVE_BDEV_BLOCK_DEVICE_OPERATIONS, 1,

8
config/kernel-bio-end-io-t-args.m4
View File

@ -11,11 +11,11 @@ AC_DEFUN([ZFS_AC_KERNEL_BIO_END_IO_T_ARGS], [
AC_MSG_CHECKING([whether bio_end_io_t wants 2 args]) AC_MSG_CHECKING([whether bio_end_io_t wants 2 args])
ZFS_LINUX_TRY_COMPILE([ ZFS_LINUX_TRY_COMPILE([
#include <linux/bio.h> #include <linux/bio.h>
],[
void (*wanted_end_io)(struct bio *, int) = NULL;
bio_end_io_t *local_end_io __attribute__ ((unused));
local_end_io = wanted_end_io; void wanted_end_io(struct bio *bio, int x) { return; }
bio_end_io_t *end_io __attribute__ ((unused)) = wanted_end_io;
],[
],[ ],[
AC_MSG_RESULT(yes) AC_MSG_RESULT(yes)
AC_DEFINE(HAVE_2ARGS_BIO_END_IO_T, 1, AC_DEFINE(HAVE_2ARGS_BIO_END_IO_T, 1,

15
config/kernel-create-nameidata.m4
View File

@ -5,17 +5,20 @@ AC_DEFUN([ZFS_AC_KERNEL_CREATE_NAMEIDATA], [
AC_MSG_CHECKING([whether iops->create() takes struct nameidata]) AC_MSG_CHECKING([whether iops->create() takes struct nameidata])
ZFS_LINUX_TRY_COMPILE([ ZFS_LINUX_TRY_COMPILE([
#include <linux/fs.h> #include <linux/fs.h>
],[
#ifdef HAVE_MKDIR_UMODE_T #ifdef HAVE_MKDIR_UMODE_T
int (*inode_create) (struct inode *,struct dentry *, int inode_create(struct inode *inode ,struct dentry *dentry,
umode_t, struct nameidata *) = NULL; umode_t umode, struct nameidata *nidata) { return 0; }
#else #else
int (*inode_create) (struct inode *,struct dentry *, int inode_create(struct inode *inode,struct dentry *dentry,
int, struct nameidata *) = NULL; int umode, struct nameidata * nidata) { return 0; }
#endif #endif
struct inode_operations iops __attribute__ ((unused)) = {
static const struct inode_operations
iops __attribute__ ((unused)) = {
.create = inode_create, .create = inode_create,
}; };
],[
],[ ],[
AC_MSG_RESULT(yes) AC_MSG_RESULT(yes)
AC_DEFINE(HAVE_CREATE_NAMEIDATA, 1, AC_DEFINE(HAVE_CREATE_NAMEIDATA, 1,

10
config/kernel-dentry-operations.m4
View File

@ -5,11 +5,15 @@ AC_DEFUN([ZFS_AC_KERNEL_D_REVALIDATE_NAMEIDATA], [
AC_MSG_CHECKING([whether dops->d_revalidate() takes struct nameidata]) AC_MSG_CHECKING([whether dops->d_revalidate() takes struct nameidata])
ZFS_LINUX_TRY_COMPILE([ ZFS_LINUX_TRY_COMPILE([
#include <linux/dcache.h> #include <linux/dcache.h>
],[
int (*revalidate) (struct dentry *, struct nameidata *) = NULL; int revalidate (struct dentry *dentry,
struct dentry_operations dops __attribute__ ((unused)) = { struct nameidata *nidata) { return 0; }
static const struct dentry_operations
dops __attribute__ ((unused)) = {
.d_revalidate = revalidate, .d_revalidate = revalidate,
}; };
],[
],[ ],[
AC_MSG_RESULT(yes) AC_MSG_RESULT(yes)
AC_DEFINE(HAVE_D_REVALIDATE_NAMEIDATA, 1, AC_DEFINE(HAVE_D_REVALIDATE_NAMEIDATA, 1,

11
config/kernel-dirty-inode.m4
View File

@ -8,11 +8,14 @@ AC_DEFUN([ZFS_AC_KERNEL_DIRTY_INODE_WITH_FLAGS], [
AC_MSG_CHECKING([whether sops->dirty_inode() wants flags]) AC_MSG_CHECKING([whether sops->dirty_inode() wants flags])
ZFS_LINUX_TRY_COMPILE([ ZFS_LINUX_TRY_COMPILE([
#include <linux/fs.h> #include <linux/fs.h>
],[
void (*dirty_inode) (struct inode *, int) = NULL;
struct super_operations sops __attribute__ ((unused));
sops.dirty_inode = dirty_inode; void dirty_inode(struct inode *a, int b) { return; }
static const struct super_operations
sops __attribute__ ((unused)) = {
.dirty_inode = dirty_inode,
};
],[
],[ ],[
AC_MSG_RESULT([yes]) AC_MSG_RESULT([yes])
AC_DEFINE(HAVE_DIRTY_INODE_WITH_FLAGS, 1, AC_DEFINE(HAVE_DIRTY_INODE_WITH_FLAGS, 1,

45
config/kernel-fallocate.m4
View File

@ -5,11 +5,15 @@ AC_DEFUN([ZFS_AC_KERNEL_FILE_FALLOCATE], [
AC_MSG_CHECKING([whether fops->fallocate() exists]) AC_MSG_CHECKING([whether fops->fallocate() exists])
ZFS_LINUX_TRY_COMPILE([ ZFS_LINUX_TRY_COMPILE([
#include <linux/fs.h> #include <linux/fs.h>
],[
long (*fallocate) (struct file *, int, loff_t, loff_t) = NULL; long test_fallocate(struct file *file, int mode,
struct file_operations fops __attribute__ ((unused)) = { loff_t offset, loff_t len) { return 0; }
.fallocate = fallocate,
static const struct file_operations
fops __attribute__ ((unused)) = {
.fallocate = test_fallocate,
}; };
],[
],[ ],[
AC_MSG_RESULT(yes) AC_MSG_RESULT(yes)
AC_DEFINE(HAVE_FILE_FALLOCATE, 1, [fops->fallocate() exists]) AC_DEFINE(HAVE_FILE_FALLOCATE, 1, [fops->fallocate() exists])
@ -25,11 +29,15 @@ AC_DEFUN([ZFS_AC_KERNEL_INODE_FALLOCATE], [
AC_MSG_CHECKING([whether iops->fallocate() exists]) AC_MSG_CHECKING([whether iops->fallocate() exists])
ZFS_LINUX_TRY_COMPILE([ ZFS_LINUX_TRY_COMPILE([
#include <linux/fs.h> #include <linux/fs.h>
],[
long (*fallocate) (struct inode *, int, loff_t, loff_t) = NULL; long test_fallocate(struct inode *inode, int mode,
struct inode_operations fops __attribute__ ((unused)) = { loff_t offset, loff_t len) { return 0; }
.fallocate = fallocate,
static const struct inode_operations
fops __attribute__ ((unused)) = {
.fallocate = test_fallocate,
}; };
],[
],[ ],[
AC_MSG_RESULT(yes) AC_MSG_RESULT(yes)
AC_DEFINE(HAVE_INODE_FALLOCATE, 1, [fops->fallocate() exists]) AC_DEFINE(HAVE_INODE_FALLOCATE, 1, [fops->fallocate() exists])
@ -38,26 +46,6 @@ AC_DEFUN([ZFS_AC_KERNEL_INODE_FALLOCATE], [
]) ])
]) ])
dnl #
dnl # PaX Linux 2.6.38 - 3.x API
dnl #
AC_DEFUN([ZFS_AC_PAX_KERNEL_FILE_FALLOCATE], [
AC_MSG_CHECKING([whether fops->fallocate() exists])
ZFS_LINUX_TRY_COMPILE([
#include <linux/fs.h>
],[
long (*fallocate) (struct file *, int, loff_t, loff_t) = NULL;
struct file_operations_no_const fops __attribute__ ((unused)) = {
.fallocate = fallocate,
};
],[
AC_MSG_RESULT(yes)
AC_DEFINE(HAVE_FILE_FALLOCATE, 1, [fops->fallocate() exists])
],[
AC_MSG_RESULT(no)
])
])
dnl # dnl #
dnl # The fallocate callback was moved from the inode_operations dnl # The fallocate callback was moved from the inode_operations
dnl # structure to the file_operations structure. dnl # structure to the file_operations structure.
@ -65,5 +53,4 @@ dnl #
AC_DEFUN([ZFS_AC_KERNEL_FALLOCATE], [ AC_DEFUN([ZFS_AC_KERNEL_FALLOCATE], [
ZFS_AC_KERNEL_FILE_FALLOCATE ZFS_AC_KERNEL_FILE_FALLOCATE
ZFS_AC_KERNEL_INODE_FALLOCATE ZFS_AC_KERNEL_INODE_FALLOCATE
ZFS_AC_PAX_KERNEL_FILE_FALLOCATE
]) ])

91
config/kernel-fsync.m4
View File

@ -4,11 +4,15 @@ dnl #
AC_DEFUN([ZFS_AC_KERNEL_FSYNC_WITH_DENTRY], [ AC_DEFUN([ZFS_AC_KERNEL_FSYNC_WITH_DENTRY], [
ZFS_LINUX_TRY_COMPILE([ ZFS_LINUX_TRY_COMPILE([
#include <linux/fs.h> #include <linux/fs.h>
],[
int (*fsync) (struct file *, struct dentry *, int) = NULL;
struct file_operations fops __attribute__ ((unused));
fops.fsync = fsync; int test_fsync(struct file *f, struct dentry *dentry, int x)
{ return 0; }
static const struct file_operations
fops __attribute__ ((unused)) = {
.fsync = test_fsync,
};
],[
],[ ],[
AC_MSG_RESULT([dentry]) AC_MSG_RESULT([dentry])
AC_DEFINE(HAVE_FSYNC_WITH_DENTRY, 1, AC_DEFINE(HAVE_FSYNC_WITH_DENTRY, 1,
@ -23,11 +27,14 @@ dnl #
AC_DEFUN([ZFS_AC_KERNEL_FSYNC_WITHOUT_DENTRY], [ AC_DEFUN([ZFS_AC_KERNEL_FSYNC_WITHOUT_DENTRY], [
ZFS_LINUX_TRY_COMPILE([ ZFS_LINUX_TRY_COMPILE([
#include <linux/fs.h> #include <linux/fs.h>
],[
int (*fsync) (struct file *, int) = NULL;
struct file_operations fops __attribute__ ((unused));
fops.fsync = fsync; int test_fsync(struct file *f, int x) { return 0; }
static const struct file_operations
fops __attribute__ ((unused)) = {
.fsync = test_fsync,
};
],[
],[ ],[
AC_MSG_RESULT([no dentry]) AC_MSG_RESULT([no dentry])
AC_DEFINE(HAVE_FSYNC_WITHOUT_DENTRY, 1, AC_DEFINE(HAVE_FSYNC_WITHOUT_DENTRY, 1,
@ -42,68 +49,15 @@ dnl #
AC_DEFUN([ZFS_AC_KERNEL_FSYNC_RANGE], [ AC_DEFUN([ZFS_AC_KERNEL_FSYNC_RANGE], [
ZFS_LINUX_TRY_COMPILE([ ZFS_LINUX_TRY_COMPILE([
#include <linux/fs.h> #include <linux/fs.h>
],[
int (*fsync) (struct file *, loff_t, loff_t, int) = NULL;
struct file_operations fops __attribute__ ((unused));
fops.fsync = fsync; int test_fsync(struct file *f, loff_t a, loff_t b, int c)
],[ { return 0; }
AC_MSG_RESULT([range])
AC_DEFINE(HAVE_FSYNC_RANGE, 1,
[fops->fsync() with range])
],[
])
])
dnl # static const struct file_operations
dnl # PaX Linux 2.6.x - 2.6.34 API fops __attribute__ ((unused)) = {
dnl # .fsync = test_fsync,
AC_DEFUN([ZFS_AC_PAX_KERNEL_FSYNC_WITH_DENTRY], [ };
ZFS_LINUX_TRY_COMPILE([
#include <linux/fs.h>
],[ ],[
int (*fsync) (struct file *, struct dentry *, int) = NULL;
file_operations_no_const fops __attribute__ ((unused));
fops.fsync = fsync;
],[
AC_MSG_RESULT([dentry])
AC_DEFINE(HAVE_FSYNC_WITH_DENTRY, 1,
[fops->fsync() with dentry])
],[
])
])
dnl #
dnl # PaX Linux 2.6.35 - Linux 3.0 API
dnl #
AC_DEFUN([ZFS_AC_PAX_KERNEL_FSYNC_WITHOUT_DENTRY], [
ZFS_LINUX_TRY_COMPILE([
#include <linux/fs.h>
],[
int (*fsync) (struct file *, int) = NULL;
file_operations_no_const fops __attribute__ ((unused));
fops.fsync = fsync;
],[
AC_MSG_RESULT([no dentry])
AC_DEFINE(HAVE_FSYNC_WITHOUT_DENTRY, 1,
[fops->fsync() without dentry])
],[
])
])
dnl #
dnl # PaX Linux 3.1 - 3.x API
dnl #
AC_DEFUN([ZFS_AC_PAX_KERNEL_FSYNC_RANGE], [
ZFS_LINUX_TRY_COMPILE([
#include <linux/fs.h>
],[
int (*fsync) (struct file *, loff_t, loff_t, int) = NULL;
file_operations_no_const fops __attribute__ ((unused));
fops.fsync = fsync;
],[ ],[
AC_MSG_RESULT([range]) AC_MSG_RESULT([range])
AC_DEFINE(HAVE_FSYNC_RANGE, 1, AC_DEFINE(HAVE_FSYNC_RANGE, 1,
@ -117,7 +71,4 @@ AC_DEFUN([ZFS_AC_KERNEL_FSYNC], [
ZFS_AC_KERNEL_FSYNC_WITH_DENTRY ZFS_AC_KERNEL_FSYNC_WITH_DENTRY
ZFS_AC_KERNEL_FSYNC_WITHOUT_DENTRY ZFS_AC_KERNEL_FSYNC_WITHOUT_DENTRY
ZFS_AC_KERNEL_FSYNC_RANGE ZFS_AC_KERNEL_FSYNC_RANGE
ZFS_AC_PAX_KERNEL_FSYNC_WITH_DENTRY
ZFS_AC_PAX_KERNEL_FSYNC_WITHOUT_DENTRY
ZFS_AC_PAX_KERNEL_FSYNC_RANGE
]) ])

12
config/kernel-lookup-nameidata.m4
View File

@ -5,12 +5,16 @@ AC_DEFUN([ZFS_AC_KERNEL_LOOKUP_NAMEIDATA], [
AC_MSG_CHECKING([whether iops->lookup() takes struct nameidata]) AC_MSG_CHECKING([whether iops->lookup() takes struct nameidata])
ZFS_LINUX_TRY_COMPILE([ ZFS_LINUX_TRY_COMPILE([
#include <linux/fs.h> #include <linux/fs.h>
],[
struct dentry * (*inode_lookup) (struct inode *,struct dentry *, struct dentry *inode_lookup(struct inode *inode,
struct nameidata *) = NULL; struct dentry *dentry, struct nameidata *nidata)
struct inode_operations iops __attribute__ ((unused)) = { { return NULL; }
static const struct inode_operations iops
__attribute__ ((unused)) = {
.lookup = inode_lookup, .lookup = inode_lookup,
}; };
],[
],[ ],[
AC_MSG_RESULT(yes) AC_MSG_RESULT(yes)
AC_DEFINE(HAVE_LOOKUP_NAMEIDATA, 1, AC_DEFINE(HAVE_LOOKUP_NAMEIDATA, 1,

10
config/kernel-mkdir-umode-t.m4
View File

@ -10,11 +10,15 @@ AC_DEFUN([ZFS_AC_KERNEL_MKDIR_UMODE_T], [
AC_MSG_CHECKING([whether iops->create()/mkdir()/mknod() take umode_t]) AC_MSG_CHECKING([whether iops->create()/mkdir()/mknod() take umode_t])
ZFS_LINUX_TRY_COMPILE([ ZFS_LINUX_TRY_COMPILE([
#include <linux/fs.h> #include <linux/fs.h>
],[
int (*mkdir) (struct inode *,struct dentry *,umode_t) = NULL; int mkdir(struct inode *inode, struct dentry *dentry,
struct inode_operations iops __attribute__ ((unused)) = { umode_t umode) { return 0; }
static const struct inode_operations
iops __attribute__ ((unused)) = {
.mkdir = mkdir, .mkdir = mkdir,
}; };
],[
],[ ],[
AC_MSG_RESULT(yes) AC_MSG_RESULT(yes)
AC_DEFINE(HAVE_MKDIR_UMODE_T, 1, AC_DEFINE(HAVE_MKDIR_UMODE_T, 1,

32
config/kernel-shrink.m4
View File

@ -8,14 +8,17 @@ AC_DEFUN([ZFS_AC_KERNEL_SHRINK], [
AC_MSG_CHECKING([whether super_block has s_shrink]) AC_MSG_CHECKING([whether super_block has s_shrink])
ZFS_LINUX_TRY_COMPILE([ ZFS_LINUX_TRY_COMPILE([
#include <linux/fs.h> #include <linux/fs.h>
],[
int (*shrink)(struct shrinker *, struct shrink_control *sc) int shrink(struct shrinker *s, struct shrink_control *sc)
__attribute__ ((unused)) = NULL; { return 0; }
struct super_block sb __attribute__ ((unused)) = {
static const struct super_block
sb __attribute__ ((unused)) = {
.s_shrink.shrink = shrink, .s_shrink.shrink = shrink,
.s_shrink.seeks = DEFAULT_SEEKS, .s_shrink.seeks = DEFAULT_SEEKS,
.s_shrink.batch = 0, .s_shrink.batch = 0,
}; };
],[
],[ ],[
AC_MSG_RESULT(yes) AC_MSG_RESULT(yes)
AC_DEFINE(HAVE_SHRINK, 1, [struct super_block has s_shrink]) AC_DEFINE(HAVE_SHRINK, 1, [struct super_block has s_shrink])
@ -29,12 +32,14 @@ AC_DEFUN([ZFS_AC_KERNEL_NR_CACHED_OBJECTS], [
AC_MSG_CHECKING([whether sops->nr_cached_objects() exists]) AC_MSG_CHECKING([whether sops->nr_cached_objects() exists])
ZFS_LINUX_TRY_COMPILE([ ZFS_LINUX_TRY_COMPILE([
#include <linux/fs.h> #include <linux/fs.h>
],[
int (*nr_cached_objects)(struct super_block *) int nr_cached_objects(struct super_block *sb) { return 0; }
__attribute__ ((unused)) = NULL;
struct super_operations sops __attribute__ ((unused)) = { static const struct super_operations
sops __attribute__ ((unused)) = {
.nr_cached_objects = nr_cached_objects, .nr_cached_objects = nr_cached_objects,
}; };
],[
],[ ],[
AC_MSG_RESULT(yes) AC_MSG_RESULT(yes)
AC_DEFINE(HAVE_NR_CACHED_OBJECTS, 1, AC_DEFINE(HAVE_NR_CACHED_OBJECTS, 1,
@ -48,12 +53,15 @@ AC_DEFUN([ZFS_AC_KERNEL_FREE_CACHED_OBJECTS], [
AC_MSG_CHECKING([whether sops->free_cached_objects() exists]) AC_MSG_CHECKING([whether sops->free_cached_objects() exists])
ZFS_LINUX_TRY_COMPILE([ ZFS_LINUX_TRY_COMPILE([
#include <linux/fs.h> #include <linux/fs.h>
],[
void (*free_cached_objects)(struct super_block *, int) void free_cached_objects(struct super_block *sb, int x)
__attribute__ ((unused)) = NULL; { return; }
struct super_operations sops __attribute__ ((unused)) = {
static const struct super_operations
sops __attribute__ ((unused)) = {
.free_cached_objects = free_cached_objects, .free_cached_objects = free_cached_objects,
}; };
],[
],[ ],[
AC_MSG_RESULT(yes) AC_MSG_RESULT(yes)
AC_DEFINE(HAVE_FREE_CACHED_OBJECTS, 1, AC_DEFINE(HAVE_FREE_CACHED_OBJECTS, 1,