cregit-Linux how code gets into the kernel

Release 4.10 fs/afs/server.c

Directory: fs/afs
/* AFS server record management
 * Copyright (C) 2002, 2007 Red Hat, Inc. All Rights Reserved.
 * Written by David Howells (
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version
 * 2 of the License, or (at your option) any later version.

#include <linux/sched.h>
#include <linux/slab.h>
#include "internal.h"

static unsigned afs_server_timeout = 10;	
/* server timeout in seconds */

static void afs_reap_server(struct work_struct *);

/* tree of all the servers, indexed by IP address */

static struct rb_root afs_servers = RB_ROOT;
static DEFINE_RWLOCK(afs_servers_lock);

/* LRU list of all the servers not currently in use */
static LIST_HEAD(afs_server_graveyard);
static DEFINE_SPINLOCK(afs_server_graveyard_lock);
static DECLARE_DELAYED_WORK(afs_server_reaper, afs_reap_server);

 * install a server record in the master tree

static int afs_install_server(struct afs_server *server) { struct afs_server *xserver; struct rb_node **pp, *p; int ret; _enter("%p", server); write_lock(&afs_servers_lock); ret = -EEXIST; pp = &afs_servers.rb_node; p = NULL; while (*pp) { p = *pp; _debug("- consider %p", p); xserver = rb_entry(p, struct afs_server, master_rb); if (server->addr.s_addr < xserver->addr.s_addr) pp = &(*pp)->rb_left; else if (server->addr.s_addr > xserver->addr.s_addr) pp = &(*pp)->rb_right; else goto error; } rb_link_node(&server->master_rb, p, pp); rb_insert_color(&server->master_rb, &afs_servers); ret = 0; error: write_unlock(&afs_servers_lock); return ret; }


david howellsdavid howells17497.21%266.67%
andrew mortonandrew morton52.79%133.33%

/* * allocate a new server record */
static struct afs_server *afs_alloc_server(struct afs_cell *cell, const struct in_addr *addr) { struct afs_server *server; _enter(""); server = kzalloc(sizeof(struct afs_server), GFP_KERNEL); if (server) { atomic_set(&server->usage, 1); server->cell = cell; INIT_LIST_HEAD(&server->link); INIT_LIST_HEAD(&server->grave); init_rwsem(&server->sem); spin_lock_init(&server->fs_lock); server->fs_vnodes = RB_ROOT; server->cb_promises = RB_ROOT; spin_lock_init(&server->cb_lock); init_waitqueue_head(&server->cb_break_waitq); INIT_DELAYED_WORK(&server->cb_break_work, afs_dispatch_give_up_callbacks); memcpy(&server->addr, addr, sizeof(struct in_addr)); server->addr.s_addr = addr->s_addr; _leave(" = %p{%d}", server, atomic_read(&server->usage)); } else { _leave(" = NULL [nomem]"); } return server; }


david howellsdavid howells17191.94%240.00%
denis kirjanovdenis kirjanov94.84%120.00%
andrew mortonandrew morton52.69%120.00%
yan burmanyan burman10.54%120.00%

/* * get an FS-server record for a cell */
struct afs_server *afs_lookup_server(struct afs_cell *cell, const struct in_addr *addr) { struct afs_server *server, *candidate; _enter("%p,%pI4", cell, &addr->s_addr); /* quick scan of the list to see if we already have the server */ read_lock(&cell->servers_lock); list_for_each_entry(server, &cell->servers, link) { if (server->addr.s_addr == addr->s_addr) goto found_server_quickly; } read_unlock(&cell->servers_lock); candidate = afs_alloc_server(cell, addr); if (!candidate) { _leave(" = -ENOMEM"); return ERR_PTR(-ENOMEM); } write_lock(&cell->servers_lock); /* check the cell's server list again */ list_for_each_entry(server, &cell->servers, link) { if (server->addr.s_addr == addr->s_addr) goto found_server; } _debug("new"); server = candidate; if (afs_install_server(server) < 0) goto server_in_two_cells; afs_get_cell(cell); list_add_tail(&server->link, &cell->servers); write_unlock(&cell->servers_lock); _leave(" = %p{%d}", server, atomic_read(&server->usage)); return server; /* found a matching server quickly */ found_server_quickly: _debug("found quickly"); afs_get_server(server); read_unlock(&cell->servers_lock); no_longer_unused: if (!list_empty(&server->grave)) { spin_lock(&afs_server_graveyard_lock); list_del_init(&server->grave); spin_unlock(&afs_server_graveyard_lock); } _leave(" = %p{%d}", server, atomic_read(&server->usage)); return server; /* found a matching server on the second pass */ found_server: _debug("found"); afs_get_server(server); write_unlock(&cell->servers_lock); kfree(candidate); goto no_longer_unused; /* found a server that seems to be in two cells */ server_in_two_cells: write_unlock(&cell->servers_lock); kfree(candidate); printk(KERN_NOTICE "kAFS: Server %pI4 appears to be in two cells\n", addr); _leave(" = -EEXIST"); return ERR_PTR(-EEXIST); }


david howellsdavid howells33797.40%250.00%
andrew mortonandrew morton61.73%125.00%
harvey harrisonharvey harrison30.87%125.00%

/* * look up a server by its IP address */
struct afs_server *afs_find_server(const struct sockaddr_rxrpc *srx) { struct afs_server *server = NULL; struct rb_node *p; struct in_addr addr = srx->transport.sin.sin_addr; _enter("{%d,%pI4}", srx->, &addr.s_addr); if (srx-> != AF_INET) { WARN(true, "AFS does not yes support non-IPv4 addresses\n"); return NULL; } read_lock(&afs_servers_lock); p = afs_servers.rb_node; while (p) { server = rb_entry(p, struct afs_server, master_rb); _debug("- consider %p", p); if (addr.s_addr < server->addr.s_addr) { p = p->rb_left; } else if (addr.s_addr > server->addr.s_addr) { p = p->rb_right; } else { afs_get_server(server); goto found; } } server = NULL; found: read_unlock(&afs_servers_lock); ASSERTIFCMP(server, server->addr.s_addr, ==, addr.s_addr); _leave(" = %p", server); return server; }


david howellsdavid howells19998.03%466.67%
andrew mortonandrew morton31.48%116.67%
harvey harrisonharvey harrison10.49%116.67%

/* * destroy a server record * - removes from the cell list */
void afs_put_server(struct afs_server *server) { if (!server) return; _enter("%p{%d}", server, atomic_read(&server->usage)); _debug("PUT SERVER %d", atomic_read(&server->usage)); ASSERTCMP(atomic_read(&server->usage), >, 0); if (likely(!atomic_dec_and_test(&server->usage))) { _leave(""); return; } afs_flush_callback_breaks(server); spin_lock(&afs_server_graveyard_lock); if (atomic_read(&server->usage) == 0) { list_move_tail(&server->grave, &afs_server_graveyard); server->time_of_death = get_seconds(); queue_delayed_work(afs_wq, &afs_server_reaper, afs_server_timeout * HZ); } spin_unlock(&afs_server_graveyard_lock); _leave(" [dead]"); }


david howellsdavid howells14195.92%350.00%
tejun heotejun heo32.04%116.67%
andrew mortonandrew morton21.36%116.67%
akinobu mitaakinobu mita10.68%116.67%

/* * destroy a dead server */
static void afs_destroy_server(struct afs_server *server) { _enter("%p", server); ASSERTIF(server->cb_break_head != server->cb_break_tail, delayed_work_pending(&server->cb_break_work)); ASSERTCMP(server->fs_vnodes.rb_node, ==, NULL); ASSERTCMP(server->cb_promises.rb_node, ==, NULL); ASSERTCMP(server->cb_break_head, ==, server->cb_break_tail); ASSERTCMP(atomic_read(&server->cb_break_n), ==, 0); afs_put_cell(server->cell); kfree(server); }


david howellsdavid howells10097.09%375.00%
andrew mortonandrew morton32.91%125.00%

/* * reap dead server records */
static void afs_reap_server(struct work_struct *work) { LIST_HEAD(corpses); struct afs_server *server; unsigned long delay, expiry; time_t now; now = get_seconds(); spin_lock(&afs_server_graveyard_lock); while (!list_empty(&afs_server_graveyard)) { server = list_entry(, struct afs_server, grave); /* the queue is ordered most dead first */ expiry = server->time_of_death + afs_server_timeout; if (expiry > now) { delay = (expiry - now) * HZ; mod_delayed_work(afs_wq, &afs_server_reaper, delay); break; } write_lock(&server->cell->servers_lock); write_lock(&afs_servers_lock); if (atomic_read(&server->usage) > 0) { list_del_init(&server->grave); } else { list_move_tail(&server->grave, &corpses); list_del_init(&server->link); rb_erase(&server->master_rb, &afs_servers); } write_unlock(&afs_servers_lock); write_unlock(&server->cell->servers_lock); } spin_unlock(&afs_server_graveyard_lock); /* now reap the corpses we've extracted */ while (!list_empty(&corpses)) { server = list_entry(, struct afs_server, grave); list_del(&server->grave); afs_destroy_server(server); } }


david howellsdavid howells23197.88%240.00%
tejun heotejun heo31.27%240.00%
andrew mortonandrew morton20.85%120.00%

/* * discard all the server records for rmmod */
void __exit afs_purge_servers(void) { afs_server_timeout = 0; mod_delayed_work(afs_wq, &afs_server_reaper, 0); }


david howellsdavid howells1986.36%250.00%
tejun heotejun heo313.64%250.00%

Overall Contributors

david howellsdavid howells143796.38%640.00%
andrew mortonandrew morton261.74%16.67%
tejun heotejun heo90.60%213.33%
denis kirjanovdenis kirjanov90.60%16.67%
harvey harrisonharvey harrison40.27%16.67%
thomas gleixnerthomas gleixner30.20%16.67%
adrian bunkadrian bunk10.07%16.67%
yan burmanyan burman10.07%16.67%
akinobu mitaakinobu mita10.07%16.67%
Directory: fs/afs
Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.