super.c

lustre 1.6.5 source code

/* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
 * vim:expandtab:shiftwidth=8:tabstop=8:
 *
 * Lustre Light Super operations
 *
 *  Copyright (c) 2002-2004 Cluster File Systems, Inc.
 *
 *   This file is part of Lustre, http://www.lustre.org.
 *
 *   Lustre is free software; you can redistribute it and/or
 *   modify it under the terms of version 2 of the GNU General Public
 *   License as published by the Free Software Foundation.
 *
 *   Lustre 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 Lustre; if not, write to the Free Software
 *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */

#define DEBUG_SUBSYSTEM S_LLITE

#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <time.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/queue.h>
#ifndef __CYGWIN__
# include <sys/statvfs.h>
#else
# include <sys/statfs.h>
#endif

#include <sysio.h>
#ifdef HAVE_XTIO_H
#include <xtio.h>
#endif
#include <fs.h>
#include <mount.h>
#include <inode.h>
#ifdef HAVE_FILE_H
#include <file.h>
#endif

#undef LIST_HEAD

#include "llite_lib.h"

#ifndef MAY_EXEC
#define MAY_EXEC        1
#define MAY_WRITE       2
#define MAY_READ        4
#endif

#define S_IXUGO (S_IXUSR|S_IXGRP|S_IXOTH)

static int ll_permission(struct inode *inode, int mask)
{
        struct intnl_stat *st = llu_i2stat(inode);
        mode_t mode = st->st_mode;

        if (current->fsuid == st->st_uid)
                mode >>= 6;
        else if (in_group_p(st->st_gid))
                mode >>= 3;

        if ((mode & mask & (MAY_READ|MAY_WRITE|MAY_EXEC)) == mask)
                return 0;

        if ((mask & (MAY_READ|MAY_WRITE)) ||
            (st->st_mode & S_IXUGO))
                if (capable(CAP_DAC_OVERRIDE))
                        return 0;

        if (mask == MAY_READ ||
            (S_ISDIR(st->st_mode) && !(mask & MAY_WRITE))) {
                if (capable(CAP_DAC_READ_SEARCH))
                        return 0;
        }

        return -EACCES;
}

static void llu_fsop_gone(struct filesys *fs)
{
        struct llu_sb_info *sbi = (struct llu_sb_info *) fs->fs_private;
        struct obd_device *obd = class_exp2obd(sbi->ll_mdc_exp);
        int next = 0;
        ENTRY;

        list_del(&sbi->ll_conn_chain);
        obd_unregister_lock_cancel_cb(sbi->ll_osc_exp,
                                      llu_extent_lock_cancel_cb);
        obd_disconnect(sbi->ll_osc_exp);
        obd_disconnect(sbi->ll_mdc_exp);

        while ((obd = class_devices_in_group(&sbi->ll_sb_uuid, &next)) != NULL)
                class_manual_cleanup(obd);

        OBD_FREE(sbi, sizeof(*sbi));

        liblustre_wait_idle();
        EXIT;
}

static struct inode_ops llu_inode_ops;

void llu_update_inode(struct inode *inode, struct mds_body *body,
                      struct lov_stripe_md *lsm)
{
        struct llu_inode_info *lli = llu_i2info(inode);
        struct intnl_stat *st = llu_i2stat(inode);

        LASSERT ((lsm != NULL) == ((body->valid & OBD_MD_FLEASIZE) != 0));
        if (lsm != NULL) {
                if (lli->lli_smd == NULL) {
                        lli->lli_smd = lsm;
                        lli->lli_maxbytes = lsm->lsm_maxbytes;
                        if (lli->lli_maxbytes > PAGE_CACHE_MAXBYTES)
                                lli->lli_maxbytes = PAGE_CACHE_MAXBYTES;
                } else {
                        if (lov_stripe_md_cmp(lli->lli_smd, lsm)) {
                                CERROR("lsm mismatch for inode %lld\n",
                                       (long long)st->st_ino);
                                LBUG();
                        }
                }
        }

        if (body->valid & OBD_MD_FLID)
                st->st_ino = body->ino;
        if (body->valid & OBD_MD_FLATIME &&
            body->atime > LTIME_S(st->st_atime))
                LTIME_S(st->st_atime) = body->atime;
        
        /* mtime is always updated with ctime, but can be set in past.
           As write and utime(2) may happen within 1 second, and utime's
           mtime has a priority over write's one, so take mtime from mds 
           for the same ctimes. */
        if (body->valid & OBD_MD_FLCTIME &&
            body->ctime >= LTIME_S(st->st_ctime)) {
                LTIME_S(st->st_ctime) = body->ctime;
                if (body->valid & OBD_MD_FLMTIME)
                        LTIME_S(st->st_mtime) = body->mtime;
        }
        if (body->valid & OBD_MD_FLMODE)
                st->st_mode = (st->st_mode & S_IFMT)|(body->mode & ~S_IFMT);
        if (body->valid & OBD_MD_FLTYPE)
                st->st_mode = (st->st_mode & ~S_IFMT)|(body->mode & S_IFMT);
        if (S_ISREG(st->st_mode))
                st->st_blksize = min(2UL * PTLRPC_MAX_BRW_SIZE, LL_MAX_BLKSIZE);
        else
                st->st_blksize = 4096;
        if (body->valid & OBD_MD_FLUID)
                st->st_uid = body->uid;
        if (body->valid & OBD_MD_FLGID)
                st->st_gid = body->gid;
        if (body->valid & OBD_MD_FLNLINK)
                st->st_nlink = body->nlink;
        if (body->valid & OBD_MD_FLRDEV)
                st->st_rdev = body->rdev;
        if (body->valid & OBD_MD_FLSIZE)
                st->st_size = body->size;
        if (body->valid & OBD_MD_FLBLOCKS)
                st->st_blocks = body->blocks;
        if (body->valid & OBD_MD_FLFLAGS)
                lli->lli_st_flags = body->flags;
        if (body->valid & OBD_MD_FLGENER)
                lli->lli_st_generation = body->generation;

        /* fillin fid */
        if (body->valid & OBD_MD_FLID)
                lli->lli_fid.id = body->ino;
        if (body->valid & OBD_MD_FLGENER)
                lli->lli_fid.generation = body->generation;
        if (body->valid & OBD_MD_FLTYPE)
                lli->lli_fid.f_type = body->mode & S_IFMT;
}

void obdo_to_inode(struct inode *dst, struct obdo *src, obd_flag valid)
{
        struct llu_inode_info *lli = llu_i2info(dst);
        struct intnl_stat *st = llu_i2stat(dst);

        valid &= src->o_valid;

        if (valid & (OBD_MD_FLCTIME | OBD_MD_FLMTIME))
                CDEBUG(D_INODE,"valid "LPX64", cur time %lu/%lu, new %lu/%lu\n",
                       src->o_valid,
                       LTIME_S(st->st_mtime), LTIME_S(st->st_ctime),
                       (long)src->o_mtime, (long)src->o_ctime);

        if (valid & OBD_MD_FLATIME)
                LTIME_S(st->st_atime) = src->o_atime;
        if (valid & OBD_MD_FLMTIME)
                LTIME_S(st->st_mtime) = src->o_mtime;
        if (valid & OBD_MD_FLCTIME && src->o_ctime > LTIME_S(st->st_ctime))
                LTIME_S(st->st_ctime) = src->o_ctime;
        if (valid & OBD_MD_FLSIZE)
                st->st_size = src->o_size;
        if (valid & OBD_MD_FLBLOCKS) /* allocation of space */
                st->st_blocks = src->o_blocks;
        if (valid & OBD_MD_FLBLKSZ)
                st->st_blksize = src->o_blksize;
        if (valid & OBD_MD_FLTYPE)
                st->st_mode = (st->st_mode & ~S_IFMT) | (src->o_mode & S_IFMT);
        if (valid & OBD_MD_FLMODE)
                st->st_mode = (st->st_mode & S_IFMT) | (src->o_mode & ~S_IFMT);
        if (valid & OBD_MD_FLUID)
                st->st_uid = src->o_uid;
        if (valid & OBD_MD_FLGID)
                st->st_gid = src->o_gid;
        if (valid & OBD_MD_FLFLAGS)
                lli->lli_st_flags = src->o_flags;
        if (valid & OBD_MD_FLGENER)
                lli->lli_st_generation = src->o_generation;
}

#define S_IRWXUGO       (S_IRWXU|S_IRWXG|S_IRWXO)
#define S_IALLUGO       (S_ISUID|S_ISGID|S_ISVTX|S_IRWXUGO)

void obdo_from_inode(struct obdo *dst, struct inode *src, obd_flag valid)
{
        struct llu_inode_info *lli = llu_i2info(src);
        struct intnl_stat *st = llu_i2stat(src);
        obd_flag newvalid = 0;

        if (valid & (OBD_MD_FLCTIME | OBD_MD_FLMTIME))
                CDEBUG(D_INODE, "valid %x, new time %lu/%lu\n",
                       valid, LTIME_S(st->st_mtime),
                       LTIME_S(st->st_ctime));

        if (valid & OBD_MD_FLATIME) {
                dst->o_atime = LTIME_S(st->st_atime);
                newvalid |= OBD_MD_FLATIME;
        }
        if (valid & OBD_MD_FLMTIME) {
                dst->o_mtime = LTIME_S(st->st_mtime);
                newvalid |= OBD_MD_FLMTIME;
        }
        if (valid & OBD_MD_FLCTIME) {
                dst->o_ctime = LTIME_S(st->st_ctime);
                newvalid |= OBD_MD_FLCTIME;
        }
        if (valid & OBD_MD_FLSIZE) {
                dst->o_size = st->st_size;
                newvalid |= OBD_MD_FLSIZE;
        }
        if (valid & OBD_MD_FLBLOCKS) {  /* allocation of space (x512 bytes) */
                dst->o_blocks = st->st_blocks;
                newvalid |= OBD_MD_FLBLOCKS;
        }
        if (valid & OBD_MD_FLBLKSZ) {   /* optimal block size */
                dst->o_blksize = st->st_blksize;
                newvalid |= OBD_MD_FLBLKSZ;
        }
        if (valid & OBD_MD_FLTYPE) {
                dst->o_mode = (dst->o_mode & S_IALLUGO)|(st->st_mode & S_IFMT);
                newvalid |= OBD_MD_FLTYPE;
        }
        if (valid & OBD_MD_FLMODE) {
                dst->o_mode = (dst->o_mode & S_IFMT)|(st->st_mode & S_IALLUGO);
                newvalid |= OBD_MD_FLMODE;
        }
        if (valid & OBD_MD_FLUID) {
                dst->o_uid = st->st_uid;
                newvalid |= OBD_MD_FLUID;
        }
        if (valid & OBD_MD_FLGID) {
                dst->o_gid = st->st_gid;
                newvalid |= OBD_MD_FLGID;
        }
        if (valid & OBD_MD_FLFLAGS) {
                dst->o_flags = lli->lli_st_flags;
                newvalid |= OBD_MD_FLFLAGS;
        }
        if (valid & OBD_MD_FLGENER) {
                dst->o_generation = lli->lli_st_generation;
                newvalid |= OBD_MD_FLGENER;
        }
        if (valid & OBD_MD_FLFID) {
                dst->o_fid = st->st_ino;
                newvalid |= OBD_MD_FLFID;
        }

        dst->o_valid |= newvalid;
}

/*
 * really does the getattr on the inode and updates its fields
 */
int llu_inode_getattr(struct inode *inode, struct lov_stripe_md *lsm)
{
        struct llu_inode_info *lli = llu_i2info(inode);
        struct obd_export *exp = llu_i2obdexp(inode);
        struct ptlrpc_request_set *set;
        struct obd_info oinfo = { { { 0 } } };
        struct obdo oa = { 0 };
        obd_flag refresh_valid;
        int rc;
        ENTRY;

        LASSERT(lsm);
        LASSERT(lli);

        oinfo.oi_md = lsm;
        oinfo.oi_oa = &oa;
        oa.o_id = lsm->lsm_object_id;
        oa.o_mode = S_IFREG;
        oa.o_valid = OBD_MD_FLID | OBD_MD_FLTYPE | OBD_MD_FLSIZE |
                OBD_MD_FLBLOCKS | OBD_MD_FLBLKSZ | OBD_MD_FLMTIME |
                OBD_MD_FLCTIME;

        set = ptlrpc_prep_set();
        if (set == NULL) {
                CERROR ("ENOMEM allocing request set\n");
                rc = -ENOMEM;
        } else {
                rc = obd_getattr_async(exp, &oinfo, set);
                if (rc == 0)
                        rc = ptlrpc_set_wait(set);
                ptlrpc_set_destroy(set);
        }
        if (rc)
                RETURN(rc);

        refresh_valid = OBD_MD_FLBLOCKS | OBD_MD_FLBLKSZ | OBD_MD_FLMTIME |
                        OBD_MD_FLCTIME | OBD_MD_FLSIZE;

        obdo_refresh_inode(inode, &oa, refresh_valid);

        RETURN(0);
}

static struct inode* llu_new_inode(struct filesys *fs,
                                   struct ll_fid *fid)
{
        struct inode *inode;
        struct llu_inode_info *lli;
        struct intnl_stat st = {
                .st_dev  = 0,
#ifndef AUTOMOUNT_FILE_NAME
                .st_mode = fid->f_type & S_IFMT,
#else
                .st_mode = fid->f_type /* all of the bits! */
#endif
                .st_uid  = geteuid(),
                .st_gid  = getegid(),
        };

        OBD_ALLOC(lli, sizeof(*lli));
        if (!lli)
                return NULL;

        /* initialize lli here */
        lli->lli_sbi = llu_fs2sbi(fs);
        lli->lli_smd = NULL;
        lli->lli_symlink_name = NULL;
        lli->lli_flags = 0;
        lli->lli_maxbytes = (__u64)(~0UL);
        lli->lli_file_data = NULL;

        lli->lli_sysio_fid.fid_data = &lli->lli_fid;
        lli->lli_sysio_fid.fid_len = sizeof(lli->lli_fid);
        lli->lli_fid = *fid;

        /* file identifier is needed by functions like _sysio_i_find() */
        inode = _sysio_i_new(fs, &lli->lli_sysio_fid,
                             &st, 0, &llu_inode_ops, lli);

        if (!inode)
                OBD_FREE(lli, sizeof(*lli));

        return inode;
}

static int llu_have_md_lock(struct inode *inode, __u64 lockpart)
{
        struct llu_sb_info *sbi = llu_i2sbi(inode);
        struct llu_inode_info *lli = llu_i2info(inode);
        struct lustre_handle lockh;
        struct ldlm_res_id res_id = { .name = {0} };
        struct obd_device *obddev;
        ldlm_policy_data_t policy = { .l_inodebits = { lockpart } };
        int flags;
        ENTRY;

        LASSERT(inode);