Question

我正在寻找一种在linux中生成短读取的方法，因此我可以对它们周围的处理代码进行单元测试。

我有许多方法在较低级别调用pread / pread64来从文件系统中的文件中读取。这些设计用于处理发生短读取的情况（读取的字节数小于请求的数量）。

我见过发生短读取的情况（跨网络文件系统）。

理想情况下，我可以创建一个允许读取N个字节的文件，然后会发生M字节的短读取，然后按预期进行正常读取。这将允许单元测试指向文件/文件系统。

谢谢！

Answer 1

如果您知道要拦截的库调用，则可以使用LD_PRELOAD加载的共享对象插入调用。

shortread.c：

#include <sys/types.h>
#include <dlfcn.h>

#define MAX_FDS 1024

static int short_read_array[ MAX_FDS ];

// #define these to match your system's values
// (need to be really careful with header files since
// getting open() declared would make things very
// difficult - just try this with open( const char *, int, ...);
// declared to see what I mean...)
#define O_RDONLY 0
#define O_WRONLY 1
#define O_RDWR 2

// note that the mode bits for read/write are
// not a bitwise-or - they are distinct values
#define MODE_BITS 3

// it's much easier to *NOT* even deal with the
// fact that open() is a varargs function
// but that means probably having to do some
// typedef's and #defines to get this to compile

// typedef some function points to make things easier
typedef int ( *open_ptr_t )( const char *name, int flags, mode_t mode );
typedef ssize_t ( *read_ptr_t )( int fd, void *buf, size_t bytes );
typedef int ( *close_ptr_t )( int fd );

// function points to the real IO library calls
static open_ptr_t real_open = NULL;
static read_ptr_t real_read = NULL;
static close_ptr_t real_close = NULL;

// this will return non-zero if 'filename' is a file
// to cause short reads on
static int shortReadsOnFd( const char *filename )
{
    // add logic here based on the file name to
    // return non-zero if you want to do
    // short reads on this file
    //
    // return( 1 );
    return( 0 );
}

// interpose on open()
int open( const char *filename, int flags, mode_t mode )
{
    static pthread_mutex_t open_mutex = PTHREAD_MUTEX_INITIALIZER;
    int fd;

    pthread_mutex_lock( &open_mutex );
    if ( NULL == real_open )
    {
        real_open = dlsym( RTLD_NEXT, "open" );
    }
    pthread_mutex_unlock( &open_mutex );

    fd = real_open( filename, flags, mode );
    if ( ( -1 == fd ) || ( fd >= MAX_FDS ) )
    {
        return( fd );
    }

    int mode_bits = flags & MODE_BITS;

    // if the file can be read from, check if this is a file
    // to do short reads on
    if ( ( O_RDONLY == mode_bits ) || ( O_RDWR == mode_bits ) )
    {
        short_read_array[ fd ] = shortReadsOnFd( filename );
    }

    return( fd );
}

ssize_t read( int fd, void *buffer, size_t bytes )
{
    static pthread_mutex_t read_mutex = PTHREAD_MUTEX_INITIALIZER;

    if ( ( fd < MAX_FDS ) && ( short_read_array[ fd ] ) )
    {
        // read less bytes than the caller asked for
        bytes /= 2;
        if ( 0 == bytes )
        {
            bytes = 1;
        }
    }

    pthread_mutex_lock( &read_mutex );
    if ( NULL == real_read )
    {
        real_read = dlsym( RTLD_NEXT, "read" );
    }
    pthread_mutex_unlock( &read_mutex );

    return( real_read( fd, buffer, bytes ) );
}

int close( int fd )
{
    static pthread_mutex_t close_mutex = PTHREAD_MUTEX_INITIALIZER;

    pthread_mutex_lock( &close_mutex );
    if ( NULL == real_close )
    {
        real_close = dlsym( RTLD_NEXT, "close" );
    }
    pthread_mutex_unlock( &close_lock );

    if ( fd < MAX_FDS )
    {
        short_read_array[ fd ] = 0;
    }

    return( real_close( fd ) );
}

编译类似：

gcc -shared [-m32|-m64] shortread.c -o libshortread.so

然后：

export LD_PRELOAD=/path/to/libshortread.so

对这样的LD_PRELOAD要非常小心 - 进程树中的所有进程都将被强制加载库。如果必须加载64位库，32位进程将无法运行，64位进程将被强制尝试加载32位库。你可以在上面的源代码中添加一个init函数来删除LD_PRELOAD环境变量（或将其设置为无害的东西）来控制它。

如果任何应用程序使用O_DIRECT的{{1}}标志，您可能也需要小心。修改正在读取的字节数可能会破坏某些Linux文件系统和/或实现的直接IO，因为只支持页面大小的IO操作。

此代码仅处理open()。您可能还需要处理read()。还有creat()，pread()，readat()和aio_read()，（甚至可能还有其他一些我目前无法回想起的其他人），尽管如此。不可否认，不太可能。并注意处理大文件的32位进程。自从我处理了这些问题以来已经有一段时间了，但我记得这可能会变得难看。

另一个警告是，lio_listio()和fopen()之类的调用可能无法调用fread()和open()库调用，并且可能会直接发出相关的系统调用。在这种情况下，您无法轻松修改这些调用的行为。插入可以读取read()等数据的基于STDIO的整个调用系列，如果不打破这些内容，可能会非常困难。

如果您知道您的应用程序是单线程的，您可以删除互斥锁。

Answer 2

最后，我使用mkfifo()找到了解决方案。

我创建命名管道然后将编写器连接到它（并最终将其包装在JNI库中以便从Java中使用）。然后可以告诉异步写入器在正确的时间写入数据，此时连接的读取器只获取可用/写入的字节而不是请求的总数。

寻找一种强制在linux中进行简短读取的方法

2 个答案: