readwrite.c File Reference

#include <windows.h>
#include <stdio.h>
#include "nfs41_ops.h"
#include "name_cache.h"
#include "upcall.h"
#include "daemon_debug.h"
#include "util.h"

Include dependency graph for readwrite.c:

Go to the source code of this file.

Macros
#define	MAX_WRITE_RETRIES   6

Functions
static int	parse_rw (unsigned char *buffer, uint32_t length, nfs41_upcall *upcall)
static int	read_from_mds (IN nfs41_upcall *upcall, IN stateid_arg *stateid)
static int	read_from_pnfs (IN nfs41_upcall *upcall, IN stateid_arg *stateid)
static int	handle_read (nfs41_upcall *upcall)
static int	write_to_mds (IN nfs41_upcall *upcall, IN stateid_arg *stateid)
static int	write_to_pnfs (IN nfs41_upcall *upcall, IN stateid_arg *stateid)
static int	handle_write (nfs41_upcall *upcall)
static int	marshall_rw (unsigned char *buffer, uint32_t *length, nfs41_upcall *upcall)

Variables
const stateid4	special_read_stateid
const nfs41_upcall_op	nfs41_op_read
const nfs41_upcall_op	nfs41_op_write

Macro Definition Documentation

MAX_WRITE_RETRIES

#define MAX_WRITE_RETRIES   6

Definition at line 33 of file readwrite.c.

Function Documentation

handle_read()

static int handle_read ( nfs41_upcall *  upcall )

static

Definition at line 138 of file readwrite.c.

{
    readwrite_upcall_args *args = &upcall->args.rw;
    stateid_arg stateid;
    ULONG pnfs_bytes_read = 0;
    int status = NO_ERROR;
 
    nfs41_open_stateid_arg(upcall->state_ref, &stateid);
 
#ifdef PNFS_ENABLE_READ
    status = read_from_pnfs(upcall, &stateid);
 
    if (status == NO_ERROR || status == ERROR_HANDLE_EOF)
        goto out;
 
    if (args->out_len) {
        pnfs_bytes_read = args->out_len;
        args->out_len = 0;
 
        args->offset += pnfs_bytes_read;
        args->buffer += pnfs_bytes_read;
        args->len -= pnfs_bytes_read;
    }
#endif
 
    status = read_from_mds(upcall, &stateid);
 
    args->out_len += pnfs_bytes_read;
out:
    return status;
}

handle_write()

static int handle_write ( nfs41_upcall *  upcall )

static

Definition at line 274 of file readwrite.c.

{
    readwrite_upcall_args *args = &upcall->args.rw;
    stateid_arg stateid;
    uint32_t pnfs_bytes_written = 0;
    int status;
 
    nfs41_open_stateid_arg(upcall->state_ref, &stateid);
 
#ifdef PNFS_ENABLE_WRITE
    status = write_to_pnfs(upcall, &stateid);
    if (args->out_len) {
        pnfs_bytes_written = args->out_len;
        args->out_len = 0;
 
        args->offset += pnfs_bytes_written;
        args->buffer += pnfs_bytes_written;
        args->len -= pnfs_bytes_written;
 
        if (args->len == 0)
            goto out;
    }
#endif
 
    status = write_to_mds(upcall, &stateid);
out:
    args->out_len += pnfs_bytes_written;
    return status;
}

marshall_rw()

static int marshall_rw ( unsigned char *  buffer, uint32_t *  length, nfs41_upcall *  upcall  )

static

Definition at line 304 of file readwrite.c.

{
    readwrite_upcall_args *args = &upcall->args.rw;
    int status;
    status = safe_write(&buffer, length, &args->out_len, sizeof(args->out_len));
    if (status) goto out;
    status = safe_write(&buffer, length, &args->ctime, sizeof(args->ctime));
out:
    return status;
}

parse_rw()

static int parse_rw ( unsigned char *  buffer, uint32_t  length, nfs41_upcall *  upcall  )

static

Definition at line 39 of file readwrite.c.

{
    int status;
    readwrite_upcall_args *args = &upcall->args.rw;
 
    status = safe_read(&buffer, &length, &args->len, sizeof(args->len));
    if (status) goto out;
    status = safe_read(&buffer, &length, &args->offset, sizeof(args->offset));
    if (status) goto out;
    status = safe_read(&buffer, &length, &args->buffer, sizeof(args->buffer));
    if (status) goto out;
 
    dprintf(1, "parsing %s len=%lu offset=%llu buf=%p\n", 
            opcode2string(upcall->opcode), args->len, args->offset, args->buffer);
out:
    return status;
}

read_from_mds()

static int read_from_mds ( IN nfs41_upcall *  upcall, IN stateid_arg *  stateid  )

static

Definition at line 58 of file readwrite.c.

{
    nfs41_session *session = upcall->state_ref->session;
    nfs41_path_fh *file = &upcall->state_ref->file;
    readwrite_upcall_args *args = &upcall->args.rw;
    int status = 0;
    bool_t eof;
    unsigned char *p = args->buffer;
    ULONG to_rcv = args->len, reloffset = 0, len = 0;
    const uint32_t maxreadsize = max_read_size(session, &file->fh);
 
    if (to_rcv > maxreadsize)
        dprintf(1, "handle_nfs41_read: reading %d in chunks of %d\n",
            to_rcv, maxreadsize);
 
    while(to_rcv > 0) {
        uint32_t bytes_read = 0, chunk = min(to_rcv, maxreadsize);
 
        status = nfs41_read(session, file, stateid, args->offset + reloffset, chunk, 
                p, &bytes_read, &eof);
        if (status == NFS4ERR_OPENMODE && !len) {
            stateid->type = STATEID_SPECIAL;
            memcpy(&stateid->stateid, &special_read_stateid, sizeof(stateid4));
            continue;
        } else if (status && !len) {
            status = nfs_to_windows_error(status, ERROR_NET_WRITE_FAULT);
            goto out;
        }
 
        p += bytes_read;
        to_rcv -= bytes_read;
        len += bytes_read;
        args->offset += bytes_read;
        if (status) {
            status = NO_ERROR;
            break;
        }
        if (eof) {
            if (!len)
                status = ERROR_HANDLE_EOF;
            break;
        }
    }
out:
    args->out_len = len;
    return status;
}

Referenced by handle_read().

read_from_pnfs()

static int read_from_pnfs ( IN nfs41_upcall *  upcall, IN stateid_arg *  stateid  )

static

Definition at line 108 of file readwrite.c.

{
    readwrite_upcall_args *args = &upcall->args.rw;
    pnfs_layout_state *layout;
    enum pnfs_status pnfsstat;
    int status = NO_ERROR;
 
    if (pnfs_layout_state_open(upcall->state_ref, &layout)) {
        status = ERROR_NOT_SUPPORTED;
        goto out;
    }
 
    pnfsstat = pnfs_read(upcall->root_ref, upcall->state_ref, stateid, layout, 
        args->offset, args->len, args->buffer, &args->out_len);
    switch (pnfsstat) {
    case PNFS_SUCCESS:
        break;
    case PNFS_READ_EOF:
        status = ERROR_HANDLE_EOF;
        break;
    default:
        status = ERROR_READ_FAULT;
        break;
    }
out:
    return status;
}

Referenced by handle_read().

write_to_mds()

static int write_to_mds ( IN nfs41_upcall *  upcall, IN stateid_arg *  stateid  )

static

Definition at line 172 of file readwrite.c.

{
    nfs41_session *session = upcall->state_ref->session;
    nfs41_path_fh *file = &upcall->state_ref->file;
    readwrite_upcall_args *args = &upcall->args.rw;
    nfs41_write_verf verf;
    enum stable_how4 stable, committed;
    unsigned char *p;
    const uint32_t maxwritesize = max_write_size(session, &file->fh);
    uint32_t to_send, reloffset, len;
    int status = 0;
    /* on write verifier mismatch, retry N times before failing */
    uint32_t retries = MAX_WRITE_RETRIES;
    nfs41_file_info info = { 0 };
 
retry_write:
    p = args->buffer;
    to_send = args->len;
    reloffset = 0;
    len = 0;
    stable = to_send <= maxwritesize ? FILE_SYNC4 : UNSTABLE4;
    committed = FILE_SYNC4;
 
    if (to_send > maxwritesize)
        dprintf(1, "handle_nfs41_write: writing %d in chunks of %d\n",
            to_send, maxwritesize);
 
    while(to_send > 0) {
        uint32_t bytes_written = 0, chunk = min(to_send, maxwritesize);
 
        status = nfs41_write(session, file, stateid, p, chunk,
            args->offset + reloffset, stable, &bytes_written, &verf, &info);
        if (status && !len)
            goto out;
        p += bytes_written;
        to_send -= bytes_written;
        len += bytes_written;
        reloffset += bytes_written;
        if (status) {
            status = 0;
            break;
        }
        if (!verify_write(&verf, &committed)) {
            if (retries--) goto retry_write;
            goto out_verify_failed;
        }
    }
    if (committed != FILE_SYNC4) {
        dprintf(1, "sending COMMIT for offset=%d and len=%d\n", args->offset, len);
        status = nfs41_commit(session, file, args->offset, len, 1, &verf, &info);
        if (status)
            goto out;
 
        if (!verify_commit(&verf)) {
            if (retries--) goto retry_write;
            goto out_verify_failed;
        }
    } else if (stable == UNSTABLE4) {
        nfs41_file_info info;
        bitmap4 attr_request; 
        nfs41_superblock_getattr_mask(file->fh.superblock, &attr_request);
        status = nfs41_getattr(session, file, &attr_request, &info);
        if (status)
            goto out;
    }
    args->ctime = info.change;
out:
    args->out_len = len;
    return nfs_to_windows_error(status, ERROR_NET_WRITE_FAULT);
 
out_verify_failed:
    len = 0;
    status = NFS4ERR_IO;
    goto out;
}

Referenced by handle_write().

write_to_pnfs()

static int write_to_pnfs ( IN nfs41_upcall *  upcall, IN stateid_arg *  stateid  )

static

Definition at line 250 of file readwrite.c.

{
    readwrite_upcall_args *args = &upcall->args.rw;
    pnfs_layout_state *layout;
    int status = NO_ERROR;
    nfs41_file_info info = { 0 };
 
    if (pnfs_layout_state_open(upcall->state_ref, &layout)) {
        status = ERROR_NOT_SUPPORTED;
        goto out;
    }
 
    if (pnfs_write(upcall->root_ref, upcall->state_ref, stateid, layout, 
            args->offset, args->len, args->buffer, &args->out_len, &info)) {
        status = ERROR_WRITE_FAULT;
        goto out;
    }
    args->ctime = info.change;
out:
    return status;
}

Referenced by handle_write().

Variable Documentation

nfs41_op_read

const nfs41_upcall_op nfs41_op_read

Initial value:

= {
    parse_rw,
    handle_read,
    marshall_rw
}

Definition at line 316 of file readwrite.c.

nfs41_op_write

const nfs41_upcall_op nfs41_op_write

Initial value:

= {
    parse_rw,
    handle_write,
    marshall_rw
}

Definition at line 321 of file readwrite.c.

special_read_stateid

const stateid4 special_read_stateid

Initial value:

= {0xffffffff, 
    {0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}}

Definition at line 36 of file readwrite.c.

Referenced by read_from_mds().