69天探索操作系统-第49天：探索网络文件系统 (NFS)内部 - 模拟RPC和缓存一致性

1. 介绍

网络文件系统（NFS）允许多个客户端通过网络访问共享文件，就像它们存储在本地一样。NFS 广泛用于分布式系统，以在不同机器之间提供无缝的文件共享。提供的代码实现了核心的 NFS 结构，如用于文件句柄的 nfs_fhandle_t 和用于文件属性的 nfs_attr_t。这些结构对于在分布式环境中管理文件元数据和操作至关重要。

nfs_cache_entry_t 结构表示一个缓存文件条目，包括文件句柄、路径、属性和数据。缓存对于通过减少对服务器的远程过程调用（RPC）来提高性能至关重要。模拟器使用这些结构来管理文件操作、缓存数据和确保客户端之间的一致性。

2.RPC 框架

远程过程调用（RPC）框架是NFS的核心，它使客户端能够在远程服务器上执行程序。nfs_rpc_context_t结构定义了RPC上下文，包括程序、版本、程序号和服务器地址。nfs_rpc_call函数处理RPC通信，使用clntudp_create函数创建基于UDP的RPC客户端。

typedef struct {
    uint32_t procedure;
    uint32_t version;
    uint32_t program;
    struct sockaddr_in server_addr;
    int timeout;
} nfs_rpc_context_t;

enum nfs_procedure {
    NFS_NULL = 0,
    NFS_GETATTR = 1,
    NFS_SETATTR = 2,
    NFS_LOOKUP = 3,
    NFS_READ = 6,
    NFS_WRITE = 7,
    NFS_CREATE = 8,
    NFS_REMOVE = 9,
    NFS_RENAME = 11
};

static int nfs_rpc_call(nfs_rpc_context_t *ctx,
                       void *args,
                       void *result) {
    CLIENT *client;
    enum clnt_stat status;
    struct timeval tv;

    tv.tv_sec = ctx->timeout;
    tv.tv_usec = 0;

    client = clntudp_create(&ctx->server_addr,
                           ctx->program,
                           ctx->version,
                           tv,
                           &ctx->socket);

    if (!client)
        return -ETIMEDOUT;

    status = clnt_call(client,
                      ctx->procedure,
                      (xdrproc_t)xdr_args,
                      args,
                      (xdrproc_t)xdr_result,
                      result,
                      tv);

    clnt_destroy(client);
    return (status == RPC_SUCCESS) ? 0 : -EIO;
}

nfs_rpc_call 函数向服务器发送 RPC 请求并等待响应。如果调用成功，则返回 0；否则，返回错误代码。该框架允许客户端通过向服务器发出 RPC 调用来执行文件操作，如读取和写入。

3. 文件操作

文件操作，如读取和写入，是通过nfs_context_t结构实现的，该结构包括RPC上下文和缓存。nfs_read函数在向服务器发出RPC调用之前，会检查缓存中是否有请求的数据。如果数据不在缓存中或已过期，它会从服务器获取数据并更新缓存。

typedef struct {
    nfs_rpc_context_t *rpc;
    nfs_cache_entry_t *cache;
    pthread_mutex_t lock;
} nfs_context_t;

static int nfs_read(nfs_context_t *ctx,
                   nfs_fhandle_t *fh,
                   void *buffer,
                   size_t size,
                   off_t offset) {
    struct nfs_read_args args = {
        .fh = *fh,
        .offset = offset,
        .count = size
    };
    struct nfs_read_res result;
    int ret;

    pthread_mutex_lock(&ctx->lock);

    nfs_cache_entry_t *entry = find_cache_entry(ctx->cache, fh);
    if (entry && is_cache_valid(entry)) {
        memcpy(buffer, entry->data + offset, size);
        update_cache_access(entry);
        pthread_mutex_unlock(&ctx->lock);
        return size;
    }

    // Perform RPC call
    ret = nfs_rpc_call(ctx->rpc, &args, &result);
    if (ret == 0) {
        memcpy(buffer, result.data, result.count);
        update_cache(ctx->cache, fh, result.data, result.count);
    }

    pthread_mutex_unlock(&ctx->lock);
    return ret == 0 ? result.count : ret;
}

nfs_write 函数首先更新缓存，然后向服务器发送 RPC 调用以写入数据。这确保了缓存与服务器数据保持一致。

static int nfs_write(nfs_context_t *ctx,
                    nfs_fhandle_t *fh,
                    const void *buffer,
                    size_t size,
                    off_t offset) {
    struct nfs_write_args args = {
        .fh = *fh,
        .offset = offset,
        .count = size,
        .data = (void *)buffer
    };
    struct nfs_write_res result;
    int ret;

    pthread_mutex_lock(&ctx->lock);

    // Update cache before write
    nfs_cache_entry_t *entry = find_cache_entry(ctx->cache, fh);
    if (entry) {
        update_cache_data(entry, buffer, offset, size);
        entry->dirty = true;
    }

    ret = nfs_rpc_call(ctx->rpc, &args, &result);

    pthread_mutex_unlock(&ctx->lock);
    return ret == 0 ? result.count : ret;
}

这些函数确保文件操作高效且一致，利用缓存来最小化RPC调用。

4. 缓存管理

缓存管理对于优化NFS性能至关重要。nfs_cache_t结构管理缓存，包括最大条目数、最大大小和当前大小。nfs_cache_init函数初始化缓存，而nfs_cache_evict函数在缓存超出其限制时移除过时或最近最少使用的条目。

typedef struct {
    size_t max_entries;
    size_t max_size;
    size_t current_size;
    struct list_head entries;
    pthread_mutex_t lock;
} nfs_cache_t;

static nfs_cache_t* nfs_cache_init(size_t max_entries, size_t max_size) {
    nfs_cache_t *cache = malloc(sizeof(nfs_cache_t));
    if (!cache)
        return NULL;

    cache->max_entries = max_entries;
    cache->max_size = max_size;
    cache->current_size = 0;
    INIT_LIST_HEAD(&cache->entries);
    pthread_mutex_init(&cache->lock, NULL);

    return cache;
}

static void nfs_cache_evict(nfs_cache_t *cache) {
    nfs_cache_entry_t *entry, *tmp;

    list_for_each_entry_safe(entry, tmp, &cache->entries, cache_list) {
        if (cache->current_size <= cache->max_size)
            break;

        if (entry->dirty)
            flush_cache_entry(entry);

        cache->current_size -= entry->data_size;
        list_del(&entry->cache_list);
        free_cache_entry(entry);
    }
}

nfs_cache_add 函数向缓存中添加新条目，必要时清除旧条目。这确保了缓存在其大小限制内，同时提供对频繁使用数据的快速访问。

5. 一致性协议

一致性是分布式文件系统中的一个主要挑战。nfs_consistency_t结构跟踪缓存数据的版本和有效性。check_consistency函数比较缓存数据的修改时间与服务器数据，以确定缓存是否已过时。

typedef struct {
    uint64_t version;
    struct timespec validity;
    bool weak_consistency;
} nfs_consistency_t;

static int check_consistency(nfs_context_t *ctx,
                           nfs_cache_entry_t *entry) {
    struct nfs_getattr_args args = {
        .fh = entry->fh
    };
    struct nfs_getattr_res result;
    int ret;

    ret = nfs_rpc_call(ctx->rpc, &args, &result);
    if (ret)
        return ret;

    if (result.attr.mtime.tv_sec > entry->attr.mtime.tv_sec) {
        // Cache is stale
        invalidate_cache_entry(entry);
        return -ESTALE;
    }

    return 0;
}

update_consistency 函数更新缓存条目的版本和有效性，确保缓存与服务器数据保持一致。

6.安全实现

在分布式环境中，安全性对于保护数据至关重要。nfs_auth_t 结构定义了认证机制，包括基于系统和基于 Kerberos 的认证。setup_security 函数根据指定的机制配置 RPC 客户端的认证句柄。

typedef struct {
    uint32_t auth_type;
    union {
        struct {
            uint32_t uid;
            uint32_t gid;
            uint32_t stamp;
        } sys;
        struct {
            char *principal;
            char *instance;
            char *realm;
        } krb;
    } auth;
} nfs_auth_t;

static int setup_security(nfs_context_t *ctx, nfs_auth_t *auth) {
    AUTH *auth_handle;

    switch (auth->auth_type) {
        case AUTH_SYS:
            auth_handle = authunix_create(hostname,
                                        auth->auth.sys.uid,
                                        auth->auth.sys.gid,
                                        0, NULL);
            break;

        case AUTH_KRB:
            auth_handle = authkerb_create(auth->auth.krb.principal,
                                        auth->auth.krb.instance,
                                        auth->auth.krb.realm);
            break;

        default:
            return -EINVAL;
    }

    if (!auth_handle)
        return -ENOMEM;

    ctx->rpc->client->cl_auth = auth_handle;
    return 0;
}

此实现确保只有授权客户端才能访问文件系统，从而保护敏感数据免受未授权访问。

7. 错误处理

错误处理对于确保NFS的可靠性至关重要。nfs_error_t结构定义了错误代码、消息和重试参数。handle_nfs_error函数处理错误，例如过期的文件句柄或超时，并确定是否应重试操作。

typedef struct {
    int error_code;
    const char *message;
    bool retry_allowed;
    int retry_count;
    int retry_delay;
} nfs_error_t;

static int handle_nfs_error(nfs_context_t *ctx,
                          nfs_error_t *error) {
    switch (error->error_code) {
        case ESTALE:
            // Handle stale file handle
            invalidate_cache(ctx->cache, error->fh);
            return -ESTALE;

        case ETIMEDOUT:
            if (error->retry_allowed &&
                error->retry_count < MAX_RETRIES) {
                sleep(error->retry_delay);
                error->retry_count++;
                return 1; // Retry operation
            }
            break;

        case EACCES:
            // Handle authentication failure
            return refresh_credentials(ctx);
    }

    return error->error_code;
}

该功能确保系统能够从瞬时错误中恢复，从而提高其可靠性和健壮性。

8.性能优化

性能优化对于确保NFS满足现代应用的需求至关重要。nfs_perf_params_t结构定义了预读、写后和并发操作的参数。optimize_read_ahead函数预取数据以减少延迟，而handle_write_behind函数将脏缓存条目刷新到服务器。

typedef struct {
    size_t read_ahead_size;
    size_t write_behind_size;
    int max_concurrent_ops;
    bool async_writes;
} nfs_perf_params_t;

static int optimize_read_ahead(nfs_context_t *ctx,
                             nfs_fhandle_t *fh,
                             off_t offset) {
    nfs_cache_entry_t *entry;
    size_t read_size;

    entry = find_cache_entry(ctx->cache, fh);
    if (!entry || offset >= entry->attr.size)
        return 0;

    read_size = min(ctx->params.read_ahead_size,
                   entry->attr.size - offset);

    return prefetch_data(ctx, fh, offset, read_size);
}

static int handle_write_behind(nfs_context_t *ctx) {
    nfs_cache_entry_t *entry, *tmp;
    int ret = 0;

    list_for_each_entry_safe(entry, tmp, &ctx->cache->entries, cache_list) {
        if (entry->dirty) {
            ret = flush_cache_entry(entry);
            if (ret)
                break;
        }
    }

    return ret;
}

这些优化确保了即使在重负载下，NFS也能提供高性能。

9.监控系统

监控系统跟踪关键性能指标，如读写操作、缓存命中/未命中和RPC调用。nfs_stats_t结构存储这些指标，update_stats函数在文件操作期间更新它们。print_stats函数显示这些指标，提供对系统性能的洞察。

typedef struct {
    uint64_t read_ops;
    uint64_t write_ops;
    uint64_t cache_hits;
    uint64_t cache_misses;
    uint64_t rpc_calls;
    uint64_t rpc_retries;
    struct timespec uptime;
} nfs_stats_t;

static void update_stats(nfs_context_t *ctx,
                        enum nfs_stat_type type) {
    pthread_mutex_lock(&ctx->stats_lock);

    switch (type) {
        case STAT_READ:
            ctx->stats.read_ops++;
            break;
        case STAT_WRITE:
            ctx->stats.write_ops++;
            break;
        case STAT_CACHE_HIT:
            ctx->stats.cache_hits++;
            break;
        case STAT_CACHE_MISS:
            ctx->stats.cache_misses++;
            break;
        case STAT_RPC:
            ctx->stats.rpc_calls++;
            break;
    }

    pthread_mutex_unlock(&ctx->stats_lock);
}

static void print_stats(nfs_context_t *ctx) {
    nfs_stats_t stats;

    pthread_mutex_lock(&ctx->stats_lock);
    memcpy(&stats, &ctx->stats, sizeof(stats));
    pthread_mutex_unlock(&ctx->stats_lock);

    printf("NFS Statistics:\n");
    printf("Read Operations: %lu\n", stats.read_ops);
    printf("Write Operations: %lu\n", stats.write_ops);
    printf("Cache Hit Ratio: %.2f%%\n",
           (float)stats.cache_hits / (stats.cache_hits + stats.cache_misses) * 100);
    printf("RPC Calls: %lu\n", stats.rpc_calls);
    printf("RPC Retries: %lu\n", stats.rpc_retries);
}

该监控系统帮助管理员识别性能瓶颈并优化系统。

10.总结

实现网络文件系统需要对RPC通信、缓存策略、一致性协议和安全机制进行仔细的研究。提供的代码展示了健壮的NFS实现所需的关键组件，包括文件操作、缓存管理和性能优化。通过精心设计和实现这些机制，开发人员可以创建高效且安全的分布式文件系统。