path: root/xlators/protocol/server/src/server-helpers.c

/*
  Copyright (c) 2006-2009 Gluster, Inc. <http://www.gluster.com>
  This file is part of GlusterFS.

  GlusterFS 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 3 of the License,
  or (at your option) any later version.

  GlusterFS is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this program.  If not, see
  <http://www.gnu.org/licenses/>.
*/

#ifndef _CONFIG_H
#define _CONFIG_H
#include "config.h"
#endif

#include "server-protocol.h"
#include "server-helpers.h"


/* server_loc_fill - derive a loc_t for a given inode number
 *
 * NOTE: make sure that @loc is empty, because any pointers it holds with reference will
 *       be leaked after returning from here.
 */
int
server_loc_fill (loc_t *loc, server_state_t *state,
                 ino_t ino, ino_t par,
                 const char *name, const char *path)
{
        inode_t *inode = NULL;
        inode_t *parent = NULL;
        int32_t  ret = -1;
        char    *dentry_path = NULL;


        GF_VALIDATE_OR_GOTO ("server", loc, out);
        GF_VALIDATE_OR_GOTO ("server", state, out);
        GF_VALIDATE_OR_GOTO ("server", path, out);

        /* anything beyond this point is success */
        ret = 0;
        loc->ino = ino;
        inode = loc->inode;
        if (inode == NULL) {
                if (ino)
                        inode = inode_search (state->itable, ino, NULL);

                if ((inode == NULL) &&
                    (par && name))
                        inode = inode_search (state->itable, par, name);

                loc->inode = inode;
                if (inode)
                        loc->ino = inode->ino;
        }

        parent = loc->parent;
        if (parent == NULL) {
                if (inode)
                        parent = inode_parent (inode, par, name);
                else
                        parent = inode_search (state->itable, par, NULL);
                loc->parent = parent;
        }

        if (name && parent) {
                ret = inode_path (parent, name, &dentry_path);
                if (ret < 0) {
                        gf_log (state->bound_xl->name, GF_LOG_DEBUG,
                                "failed to build path for %"PRId64"/%s: %s",
                                parent->ino, name, strerror (-ret));
                }
        } else if (inode) {
                ret = inode_path (inode, NULL, &dentry_path);
                if (ret < 0) {
                        gf_log (state->bound_xl->name, GF_LOG_DEBUG,
                                "failed to build path for %"PRId64": %s",
                                inode->ino, strerror (-ret));
                }
        }

        if (dentry_path) {
                if (strcmp (dentry_path, path)) {
                        gf_log (state->bound_xl->name, GF_LOG_DEBUG,
                                "paths differ for inode(%"PRId64"): "
                                "client path = %s. dentry path = %s",
                                ino, path, dentry_path);
                }

                loc->path = dentry_path;
                loc->name = strrchr (loc->path, '/');
                if (loc->name)
                        loc->name++;
        } else {
                loc->path = strdup (path);
                loc->name = strrchr (loc->path, '/');
                if (loc->name)
                        loc->name++;
        }

out:
        return ret;
}

/*
 * stat_to_str - convert struct stat to a ASCII string
 * @stbuf: struct stat pointer
 *
 * not for external reference
 */
char *
stat_to_str (struct stat *stbuf)
{
        int   ret = 0;
        char *tmp_buf = NULL;

        uint64_t dev = stbuf->st_dev;
        uint64_t ino = stbuf->st_ino;
        uint32_t mode = stbuf->st_mode;
        uint32_t nlink = stbuf->st_nlink;
        uint32_t uid = stbuf->st_uid;
        uint32_t gid = stbuf->st_gid;
        uint64_t rdev = stbuf->st_rdev;
        uint64_t size = stbuf->st_size;
        uint32_t blksize = stbuf->st_blksize;
        uint64_t blocks = stbuf->st_blocks;
        uint32_t atime = stbuf->st_atime;
        uint32_t mtime = stbuf->st_mtime;
        uint32_t ctime = stbuf->st_ctime;

        uint32_t atime_nsec = ST_ATIM_NSEC(stbuf);
        uint32_t mtime_nsec = ST_MTIM_NSEC(stbuf);
        uint32_t ctime_nsec = ST_CTIM_NSEC(stbuf);


        ret = asprintf (&tmp_buf,
                        GF_STAT_PRINT_FMT_STR,
                        dev,
                        ino,
                        mode,
                        nlink,
                        uid,
                        gid,
                        rdev,
                        size,
                        blksize,
                        blocks,
                        atime,
                        atime_nsec,
                        mtime,
                        mtime_nsec,
                        ctime,
                        ctime_nsec);
        if (-1 == ret) {
                gf_log ("protocol/server", GF_LOG_DEBUG,
                        "asprintf failed while setting up stat buffer string");
                return NULL;
        }
        return tmp_buf;
}


void
server_loc_wipe (loc_t *loc)
{
        if (loc->parent) {
                inode_unref (loc->parent);
                loc->parent = NULL;
        }

        if (loc->inode) {
                inode_unref (loc->inode);
                loc->inode = NULL;
        }

        if (loc->path)
                FREE (loc->path);
}


void
server_resolve_wipe (server_resolve_t *resolve)
{
        struct resolve_comp *comp = NULL;
        int                  i = 0;

        if (resolve->path)
                FREE (resolve->path);

        if (resolve->bname)
                FREE (resolve->bname);

        if (resolve->resolved)
                FREE (resolve->resolved);

        loc_wipe (&resolve->deep_loc);

        comp = resolve->components;
        if (comp) {
                for (i = 0; comp[i].basename; i++) {
                        if (comp[i].inode)
                                inode_unref (comp[i].inode);
                }
                FREE (resolve->components);
        }
}


void
free_state (server_state_t *state)
{
        if (state->trans) {
                transport_unref (state->trans);
                state->trans = NULL;
        }

        if (state->fd) {
                fd_unref (state->fd);
                state->fd = NULL;
        }

        if (state->iobref) {
                iobref_unref (state->iobref);
                state->iobref = NULL;
        }

        if (state->iobuf) {
                iobuf_unref (state->iobuf);
                state->iobuf = NULL;
        }

        if (state->dict) {
                dict_unref (state->dict);
                state->dict = NULL;
        }

        if (state->volume)
                FREE (state->volume);

        if (state->name)
                FREE (state->name);

        server_loc_wipe (&state->loc);
        server_loc_wipe (&state->loc2);

        server_resolve_wipe (&state->resolve);
        server_resolve_wipe (&state->resolve2);

        FREE (state);
}


call_frame_t *
server_copy_frame (call_frame_t *frame)
{
        call_frame_t *new_frame = NULL;
        server_state_t *state = NULL, *new_state = NULL;

        state = frame->root->state;

        new_frame = copy_frame (frame);

        new_state = CALLOC (1, sizeof (server_state_t));

        new_frame->root->op    = frame->root->op;
        new_frame->root->type  = frame->root->type;
        new_frame->root->trans = state->trans;
        new_frame->root->state = new_state;

        new_state->bound_xl = state->bound_xl;
        new_state->trans    = transport_ref (state->trans);
        new_state->itable   = state->itable;

        new_state->resolve.fd_no  = -1;
        new_state->resolve2.fd_no = -1;

        return new_frame;
}


int
gf_add_locker (struct _lock_table *table, const char *volume,
               loc_t *loc, fd_t *fd, pid_t pid)
{
        int32_t         ret = -1;
        struct _locker *new = NULL;
        uint8_t         dir = 0;

        new = CALLOC (1, sizeof (struct _locker));
        if (new == NULL) {
                gf_log ("server", GF_LOG_ERROR,
                        "failed to allocate memory for \'struct _locker\'");
                goto out;
        }
        INIT_LIST_HEAD (&new->lockers);

        new->volume = strdup (volume);

        if (fd == NULL) {
                loc_copy (&new->loc, loc);
                dir = S_ISDIR (new->loc.inode->st_mode);
        } else {
                new->fd = fd_ref (fd);
                dir = S_ISDIR (fd->inode->st_mode);
        }

        new->pid = pid;

        LOCK (&table->lock);
        {
                if (dir)
                        list_add_tail (&new->lockers, &table->dir_lockers);
                else
                        list_add_tail (&new->lockers, &table->file_lockers);
        }
        UNLOCK (&table->lock);
out:
        return ret;
}


int
gf_del_locker (struct _lock_table *table, const char *volume,
               loc_t *loc, fd_t *fd, pid_t pid)
{
        struct _locker    *locker = NULL;
        struct _locker    *tmp = NULL;
        int32_t            ret = 0;
        uint8_t            dir = 0;
        struct list_head  *head = NULL;
        struct list_head   del;

        INIT_LIST_HEAD (&del);

        if (fd) {
                dir = S_ISDIR (fd->inode->st_mode);
        } else {
                dir = S_ISDIR (loc->inode->st_mode);
        }

        LOCK (&table->lock);
        {
                if (dir) {
                        head = &table->dir_lockers;
                } else {
                        head = &table->file_lockers;
                }

                list_for_each_entry_safe (locker, tmp, head, lockers) {
                        if (locker->fd && fd &&
                            (locker->fd == fd) && (locker->pid == pid)
                            && !strcmp (locker->volume, volume)) {
                                list_move_tail (&locker->lockers, &del);
                        } else if (locker->loc.inode &&
                                   loc &&
                                   (locker->loc.inode == loc->inode) &&
                                   (locker->pid == pid)
                                   && !strcmp (locker->volume, volume)) {
                                list_move_tail (&locker->lockers, &del);
                        }
                }
        }
        UNLOCK (&table->lock);

        tmp = NULL;
        locker = NULL;

        list_for_each_entry_safe (locker, tmp, &del, lockers) {
                list_del_init (&locker->lockers);
                if (locker->fd)
                        fd_unref (locker->fd);
                else
                        loc_wipe (&locker->loc);

                free (locker->volume);
                free (locker);
        }

        return ret;
}


int
gf_direntry_to_bin (dir_entry_t *head, char *buffer)
{
        dir_entry_t   *trav = NULL;
        uint32_t       len = 0;
        uint32_t       this_len = 0;
        size_t         buflen = -1;
        char          *ptr = NULL;
        char          *tmp_buf = NULL;

        trav = head->next;
        while (trav) {
                len += strlen (trav->name);
                len += 1;
                len += strlen (trav->link);
                len += 1; /* for '\n' */
                len += 256; // max possible for statbuf;
                trav = trav->next;
        }

        ptr = buffer;
        trav = head->next;
        while (trav) {
                tmp_buf = stat_to_str (&trav->buf);
                /* tmp_buf will have \n before \0 */

                this_len = sprintf (ptr, "%s/%s%s\n",
                                    trav->name, tmp_buf,
                                    trav->link);

                FREE (tmp_buf);
                trav = trav->next;
                ptr += this_len;
        }

        buflen = strlen (buffer);

        return buflen;
}


static struct _lock_table *
gf_lock_table_new (void)
{
        struct _lock_table *new = NULL;

        new = CALLOC (1, sizeof (struct _lock_table));
        if (new == NULL) {
                gf_log ("server-protocol", GF_LOG_CRITICAL,
                        "failed to allocate memory for new lock table");
                goto out;
        }
        INIT_LIST_HEAD (&new->dir_lockers);
        INIT_LIST_HEAD (&new->file_lockers);
        LOCK_INIT (&new->lock);
out:
        return new;
}


int
do_lock_table_cleanup (xlator_t *this, server_connection_t *conn,
                       call_frame_t *frame, struct _lock_table *ltable)
{
        struct list_head  file_lockers, dir_lockers;
        call_frame_t     *tmp_frame = NULL;
        struct flock      flock = {0, };
        xlator_t         *bound_xl = NULL;
        struct _locker   *locker = NULL, *tmp = NULL;
        int               ret = -1;

        bound_xl = conn->bound_xl;
        INIT_LIST_HEAD (&file_lockers);
        INIT_LIST_HEAD (&dir_lockers);

        LOCK (&ltable->lock);
        {
                list_splice_init (&ltable->file_lockers,
                                  &file_lockers);

                list_splice_init (&ltable->dir_lockers, &dir_lockers);
        }
        UNLOCK (&ltable->lock);

        free (ltable);

        flock.l_type  = F_UNLCK;
        flock.l_start = 0;
        flock.l_len   = 0;
        list_for_each_entry_safe (locker,
                                  tmp, &file_lockers, lockers) {
                tmp_frame = copy_frame (frame);
                if (tmp_frame == NULL) {
                        gf_log (this->name, GF_LOG_ERROR,
                                "out of memory");
                        goto out;
                }
                /*
                   pid = 0 is a special case that tells posix-locks
                   to release all locks from this transport
                */
                tmp_frame->root->pid = 0;
                tmp_frame->root->trans = conn;

                if (locker->fd) {
                        STACK_WIND (tmp_frame, server_nop_cbk,
                                    bound_xl,
                                    bound_xl->fops->finodelk,
                                    locker->volume,
                                    locker->fd, F_SETLK, &flock);
                        fd_unref (locker->fd);
                } else {
                        STACK_WIND (tmp_frame, server_nop_cbk,
                                    bound_xl,
                                    bound_xl->fops->inodelk,
                                    locker->volume,
                                    &(locker->loc), F_SETLK, &flock);
                        loc_wipe (&locker->loc);
                }

                free (locker->volume);

                list_del_init (&locker->lockers);
                free (locker);
        }

        tmp = NULL;
        locker = NULL;
        list_for_each_entry_safe (locker, tmp, &dir_lockers, lockers) {
                tmp_frame = copy_frame (frame);

                tmp_frame->root->pid = 0;
                tmp_frame->root->trans = conn;

                if (locker->fd) {
                        STACK_WIND (tmp_frame, server_nop_cbk,
                                    bound_xl,
                                    bound_xl->fops->fentrylk,
                                    locker->volume,
                                    locker->fd, NULL,
                                    ENTRYLK_UNLOCK, ENTRYLK_WRLCK);
                        fd_unref (locker->fd);
                } else {
                        STACK_WIND (tmp_frame, server_nop_cbk,
                                    bound_xl,
                                    bound_xl->fops->entrylk,
                                    locker->volume,
                                    &(locker->loc), NULL,
                                    ENTRYLK_UNLOCK, ENTRYLK_WRLCK);
                        loc_wipe (&locker->loc);
                }

                free (locker->volume);

                list_del_init (&locker->lockers);
                free (locker);
        }
        ret = 0;

out:
        return ret;
}


static int
server_connection_cleanup_flush_cbk (call_frame_t *frame, void *cookie,
                                     xlator_t *this, int32_t op_ret,
                                     int32_t op_errno)
{
        fd_t *fd = NULL;

        fd = frame->local;

        fd_unref (fd);
        frame->local = NULL;

        STACK_DESTROY (frame->root);
        return 0;
}


int
do_fd_cleanup (xlator_t *this, server_connection_t *conn, call_frame_t *frame,
               fdentry_t *fdentries, int fd_count)
{
        fd_t               *fd = NULL;
        int                 i = 0, ret = -1;
        call_frame_t       *tmp_frame = NULL;
        xlator_t           *bound_xl = NULL;

        bound_xl = conn->bound_xl;
        for (i = 0;i < fd_count; i++) {
                fd = fdentries[i].fd;

                if (fd != NULL) {
                        tmp_frame = copy_frame (frame);
                        if (tmp_frame == NULL) {
                                gf_log (this->name, GF_LOG_ERROR,
                                        "out of memory");
                                goto out;
                        }
                        tmp_frame->local = fd;

                        tmp_frame->root->pid = 0;
                        tmp_frame->root->trans = conn;
                        tmp_frame->root->lk_owner = 0;
                        STACK_WIND (tmp_frame,
                                    server_connection_cleanup_flush_cbk,
                                    bound_xl, bound_xl->fops->flush, fd);
                }
        }

        FREE (fdentries);
        ret = 0;

out:
        return ret;
}

int
do_connection_cleanup (xlator_t *this, server_connection_t *conn,
                       struct _lock_table *ltable, fdentry_t *fdentries, int fd_count)
{
        int             ret = 0;
        int             saved_ret = 0;
        call_frame_t   *frame = NULL;
        server_state_t *state = NULL;

        frame = create_frame (this, this->ctx->pool);
        if (frame == NULL) {
                gf_log (this->name, GF_LOG_ERROR, "out of memory");
                goto out;
        }

        saved_ret = do_lock_table_cleanup (this, conn, frame, ltable);

        if (fdentries != NULL) {
                ret = do_fd_cleanup (this, conn, frame, fdentries, fd_count);
        }

        state = CALL_STATE (frame);
        if (state)
                free (state);

        STACK_DESTROY (frame->root);

        if (saved_ret || ret) {
                ret = -1;
        }

out:
        return ret;
}


int
server_connection_cleanup (xlator_t *this, server_connection_t *conn, transport_t *trans)
{
        char                do_cleanup = 0;
        struct _lock_table *ltable = NULL;
        fdentry_t          *fdentries = NULL;
        uint32_t            fd_count = 0;
        int                 ret = 0;
        int                 i = 0;

        if (conn == NULL) {
                goto out;
        }

        pthread_mutex_lock (&conn->lock);
        {
                for (i = 0; i < TRANSPORTS_PER_SERVER_CONN; i++) {
                        if (conn->transports[i] == trans) {
                                conn->transports[i] = NULL;
                                transport_unref (trans);
                        }
                }
                conn->active_transports--;
                if (conn->active_transports == 0) {
                        if (conn->ltable) {
                                ltable = conn->ltable;
                                conn->ltable = gf_lock_table_new ();
                        }

                        if (conn->fdtable) {
                                fdentries = gf_fd_fdtable_get_all_fds (conn->fdtable,
                                                                       &fd_count);
                        }
                        do_cleanup = 1;
                }
        }
        pthread_mutex_unlock (&conn->lock);

        if (do_cleanup && conn->bound_xl)
                ret = do_connection_cleanup (this, conn, ltable, fdentries, fd_count);

out:
        return ret;
}


int
server_connection_destroy (xlator_t *this, server_connection_t *conn)
{
        call_frame_t       *frame = NULL, *tmp_frame = NULL;
        xlator_t           *bound_xl = NULL;
        int32_t             ret = -1;
        server_state_t     *state = NULL;
        struct list_head    file_lockers;
        struct list_head    dir_lockers;
        struct _lock_table *ltable = NULL;
        struct _locker     *locker = NULL, *tmp = NULL;
        struct flock        flock = {0,};
        fd_t               *fd = NULL;
        int32_t             i = 0;
        fdentry_t          *fdentries = NULL;
        uint32_t             fd_count = 0;

        if (conn == NULL) {
                ret = 0;
                goto out;
        }

        bound_xl = (xlator_t *) (conn->bound_xl);

        if (bound_xl) {
                /* trans will have ref_count = 1 after this call, but its
                   ok since this function is called in
                   GF_EVENT_TRANSPORT_CLEANUP */
                frame = create_frame (this, this->ctx->pool);

                pthread_mutex_lock (&(conn->lock));
                {
                        if (conn->ltable) {
                                ltable = conn->ltable;
                                conn->ltable = NULL;
                        }
                }
                pthread_mutex_unlock (&conn->lock);

                INIT_LIST_HEAD (&file_lockers);
                INIT_LIST_HEAD (&dir_lockers);

                LOCK (&ltable->lock);
                {
                        list_splice_init (&ltable->file_lockers,
                                          &file_lockers);

                        list_splice_init (&ltable->dir_lockers, &dir_lockers);
                }
                UNLOCK (&ltable->lock);
                free (ltable);

                flock.l_type  = F_UNLCK;
                flock.l_start = 0;
                flock.l_len   = 0;
                list_for_each_entry_safe (locker,
                                          tmp, &file_lockers, lockers) {
                        tmp_frame = copy_frame (frame);
                        /*
                           pid = 0 is a special case that tells posix-locks
                           to release all locks from this transport
                        */
                        tmp_frame->root->pid = 0;
                        tmp_frame->root->trans = conn;

                        if (locker->fd) {
                                STACK_WIND (tmp_frame, server_nop_cbk,
                                            bound_xl,
                                            bound_xl->fops->finodelk,
                                            locker->volume,
                                            locker->fd, F_SETLK, &flock);
                                fd_unref (locker->fd);
                        } else {
                                STACK_WIND (tmp_frame, server_nop_cbk,
                                            bound_xl,
                                            bound_xl->fops->inodelk,
                                            locker->volume,
                                            &(locker->loc), F_SETLK, &flock);
                                loc_wipe (&locker->loc);
                        }

                        free (locker->volume);

                        list_del_init (&locker->lockers);
                        free (locker);
                }

                tmp = NULL;
                locker = NULL;
                list_for_each_entry_safe (locker, tmp, &dir_lockers, lockers) {
                        tmp_frame = copy_frame (frame);

                        tmp_frame->root->pid = 0;
                        tmp_frame->root->trans = conn;

                        if (locker->fd) {
                                STACK_WIND (tmp_frame, server_nop_cbk,
                                            bound_xl,
                                            bound_xl->fops->fentrylk,
                                            locker->volume,
                                            locker->fd, NULL,
                                            ENTRYLK_UNLOCK, ENTRYLK_WRLCK);
                                fd_unref (locker->fd);
                        } else {
                                STACK_WIND (tmp_frame, server_nop_cbk,
                                            bound_xl,
                                            bound_xl->fops->entrylk,
                                            locker->volume,
                                            &(locker->loc), NULL,
                                            ENTRYLK_UNLOCK, ENTRYLK_WRLCK);
                                loc_wipe (&locker->loc);
                        }

                        free (locker->volume);

                        list_del_init (&locker->lockers);
                        free (locker);
                }

                pthread_mutex_lock (&(conn->lock));
                {
                        if (conn->fdtable) {
                                fdentries = gf_fd_fdtable_get_all_fds (conn->fdtable,
                                                                       &fd_count);
                                gf_fd_fdtable_destroy (conn->fdtable);
                                conn->fdtable = NULL;
                        }
                }
                pthread_mutex_unlock (&conn->lock);

                if (fdentries != NULL) {
                        for (i = 0; i < fd_count; i++) {
                                fd = fdentries[i].fd;
                                if (fd != NULL) {
                                        tmp_frame = copy_frame (frame);
                                        tmp_frame->local = fd;

                                        STACK_WIND (tmp_frame,
                                                    server_connection_cleanup_flush_cbk,
                                                    bound_xl,
                                                    bound_xl->fops->flush,
                                                    fd);
                                }
                        }
                        FREE (fdentries);
                }
        }

        if (frame) {
                state = CALL_STATE (frame);
                if (state)
                        free (state);
                STACK_DESTROY (frame->root);
        }

        gf_log (this->name, GF_LOG_INFO, "destroyed connection of %s",
                conn->id);

        FREE (conn->id);
        FREE (conn);

out:
        return ret;
}


server_connection_t *
server_connection_get (xlator_t *this, const char *id, transport_t *trans)
{
        server_connection_t *conn = NULL;
        server_connection_t *trav = NULL;
        server_conf_t       *conf = NULL;
        int                  i = 0;

        conf = this->private;

        pthread_mutex_lock (&conf->mutex);
        {
                list_for_each_entry (trav, &conf->conns, list) {
                        if (!strcmp (id, trav->id)) {
                                conn = trav;
                                break;
                        }
                }

                if (!conn) {
                        conn = (void *) CALLOC (1, sizeof (*conn));

                        conn->id = strdup (id);
                        conn->fdtable = gf_fd_fdtable_alloc ();
                        conn->ltable  = gf_lock_table_new ();

                        pthread_mutex_init (&conn->lock, NULL);

                        list_add (&conn->list, &conf->conns);
                }
                if (conn->active_transports == TRANSPORTS_PER_SERVER_CONN) {
                        gf_log (this->name, GF_LOG_DEBUG,
                                "Maximum number of connections allowed is %d",
                                TRANSPORTS_PER_SERVER_CONN);
                        goto unlock;
                }

                for (i = 0; i < TRANSPORTS_PER_SERVER_CONN; i++) {
                        if (!conn->transports[i])
                                break;
                }

                if (i == TRANSPORTS_PER_SERVER_CONN) {
                        gf_log (this->name, GF_LOG_DEBUG,
                                "Could not find a vacant slot");
                        goto unlock;
                }

                conn->transports[i] = transport_ref (trans);

                conn->ref++;
                conn->active_transports++;
        }
unlock:
        pthread_mutex_unlock (&conf->mutex);

        return conn;
}


void
server_connection_put (xlator_t *this, server_connection_t *conn)
{
        server_conf_t       *conf = NULL;
        server_connection_t *todel = NULL;

        if (conn == NULL) {
                goto out;
        }

        conf = this->private;

        pthread_mutex_lock (&conf->mutex);
        {
                conn->ref--;

                if (!conn->ref) {
                        list_del_init (&conn->list);
                        todel = conn;
                }
        }
        pthread_mutex_unlock (&conf->mutex);

        if (todel) {
                server_connection_destroy (this, todel);
        }

out:
        return;
}

void
server_child_down (xlator_t *this, xlator_t *bound_xl)
{
        server_conf_t       *conf = NULL;
        server_connection_t *trav = NULL;
        transport_t         *trans = NULL;
        int                  subvol_idx = 0;
        int                  i = 0;
        xlator_list_t       *xltrav = NULL;

        conf = this->private;

        if (conf == NULL)
                return;

        xltrav = this->children;

        while (xltrav) {
                if (xltrav->xlator == bound_xl)
                        break;
                xltrav = xltrav->next;
                subvol_idx++;
        }
        gf_log (this->name, GF_LOG_DEBUG,
                "subvolume %s(%d) went down", bound_xl->name, subvol_idx);

        conf->subvol_list[subvol_idx] = 0;

        pthread_mutex_lock (&conf->mutex);
        {
                list_for_each_entry (trav, &conf->conns, list) {
                        if (bound_xl == trav->bound_xl) {
                                gf_log (this->name, GF_LOG_DEBUG,
                                        "disonnecting conn=%p", trav);
                                for (i = 0; i < TRANSPORTS_PER_SERVER_CONN; i++)
                                {
                                        trans = trav->transports[i];
                                        if (trans == NULL)
                                                continue;
                                        gf_log (this->name, GF_LOG_DEBUG,
                                                "disconnecting %p(%d)",
                                                trans, i);
                                        transport_disconnect (trans);
                                }
                        }
                }
        }
        pthread_mutex_unlock (&conf->mutex);
}

void
server_child_up (xlator_t *this, xlator_t *bound_xl)
{
        server_conf_t       *conf = NULL;
        int                  subvol_idx = 0;
        xlator_list_t       *xltrav = NULL;

        conf = this->private;

        if (conf == NULL)
                return;

        xltrav = this->children;

        while (xltrav) {
                if (bound_xl == xltrav->xlator) {
                        break;
                }
                subvol_idx++;
                xltrav = xltrav->next;
        }

        gf_log (this->name, GF_LOG_DEBUG,
                "subvolume %s(%d) came up", bound_xl->name, subvol_idx);

        conf->subvol_list[subvol_idx] = 1;
}