* Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved.
* Use is subject to license terms.
*
- * Copyright (c) 2011, 2012, Intel Corporation.
+ * Copyright (c) 2011, 2013, Intel Corporation.
*/
/*
* This file is part of Lustre, http://www.lustre.org/
#define DEBUG_SUBSYSTEM S_LLITE
+#include <assert.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stddef.h>
#include <stdlib.h>
+#include <stdio.h>
#include <string.h>
-#include <assert.h>
#include <time.h>
-#include <sys/types.h>
+#include <unistd.h>
+#include <sys/ioctl.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 <sys/types.h>
+#include <libcfs/libcfs.h>
+#include <lustre/lustre_idl.h>
+#include <liblustre.h>
+#include <lclient.h>
+#include <lustre_dlm.h>
+#include <lustre_export.h>
+#include <lustre_lite.h>
+#include <lustre_mdc.h>
+#include <lustre_net.h>
+#include <lustre_req_layout.h>
+#include <lustre_ver.h>
+#include <obd.h>
+#include <obd_class.h>
+#include <obd_support.h>
#include "llite_lib.h"
#ifndef MAY_EXEC
struct intnl_stat *st = llu_i2stat(inode);
mode_t mode = st->st_mode;
- if (current->fsuid == st->st_uid)
- mode >>= 6;
- else if (cfs_curproc_is_in_groups(st->st_gid))
- mode >>= 3;
+ 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;
}
}
-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;
-
- LASSERTF(!(valid & (OBD_MD_FLTYPE | OBD_MD_FLGENER | OBD_MD_FLFID |
- OBD_MD_FLID | OBD_MD_FLGROUP)),
- "object "LPU64"/"LPU64", valid %x\n",
- src->o_id, src->o_seq, valid);
-
- if (valid & (OBD_MD_FLCTIME | OBD_MD_FLMTIME))
- CDEBUG(D_INODE,"valid "LPX64", cur time "CFS_TIME_T"/"CFS_TIME_T
- ", 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;
-}
-
/**
* Performs the getattr on the inode and updates its fields.
* If @sync != 0, perform the getattr under the server-side lock.
OBD_MD_FLMTIME | OBD_MD_FLCTIME |
OBD_MD_FLSIZE;
- obdo_refresh_inode(inode, oinfo.oi_oa, oinfo.oi_oa->o_valid);
- CDEBUG(D_INODE, "objid "LPX64" size %llu, blocks %llu, "
- "blksize %llu\n", oinfo.oi_oa->o_id,
+ obdo_refresh_inode(inode, oinfo.oi_oa, oinfo.oi_oa->o_valid);
+ CDEBUG(D_INODE, "objid "DOSTID" size %llu, blocks %llu, "
+ "blksize %llu\n", POSTID(&oinfo.oi_oa->o_oi),
(long long unsigned)llu_i2stat(inode)->st_size,
(long long unsigned)llu_i2stat(inode)->st_blocks,
(long long unsigned)llu_i2stat(inode)->st_blksize);
struct intnl_stat *st = llu_i2stat(inode);
ENTRY;
- if (!inode) {
- CERROR("REPORT THIS LINE TO PETER\n");
- RETURN(0);
- }
-
if (!llu_have_md_lock(inode, MDS_INODELOCK_UPDATE)) {
struct lustre_md md;
struct ptlrpc_request *req = NULL;
return LDLM_ITER_CONTINUE;
}
-void llu_clear_inode(struct inode *inode)
+static void llu_clear_inode(struct inode *inode)
{
struct llu_inode_info *lli = llu_i2info(inode);
struct llu_sb_info *sbi = llu_i2sbi(inode);
EXIT;
}
-void llu_iop_gone(struct inode *inode)
+static void llu_iop_gone(struct inode *inode)
{
struct llu_inode_info *lli = llu_i2info(inode);
ENTRY;
st->st_mtime = attr->ia_mtime;
if (ia_valid & ATTR_CTIME)
st->st_ctime = attr->ia_ctime;
- if (ia_valid & ATTR_MODE) {
- st->st_mode = attr->ia_mode;
- if (!cfs_curproc_is_in_groups(st->st_gid) &&
- !cfs_capable(CFS_CAP_FSETID))
- st->st_mode &= ~S_ISGID;
- }
+ if (ia_valid & ATTR_MODE) {
+ st->st_mode = attr->ia_mode;
+ if (!in_group_p(st->st_gid) &&
+ !cfs_capable(CFS_CAP_FSETID))
+ st->st_mode &= ~S_ISGID;
+ }
/* mark_inode_dirty(inode); */
return error;
}
int cmd,
struct file_lock *file_lock)
{
- struct llu_inode_info *lli = llu_i2info(ino);
- struct intnl_stat *st = llu_i2stat(ino);
- struct ldlm_res_id res_id =
- { .name = {fid_seq(&lli->lli_fid),
- fid_oid(&lli->lli_fid),
- fid_ver(&lli->lli_fid),
- LDLM_FLOCK} };
- struct ldlm_enqueue_info einfo = { LDLM_FLOCK, 0, NULL,
- ldlm_flock_completion_ast, NULL, NULL, file_lock };
-
- struct lustre_handle lockh = {0};
- ldlm_policy_data_t flock;
+ struct llu_inode_info *lli = llu_i2info(ino);
+ struct ldlm_res_id res_id =
+ { .name = {fid_seq(&lli->lli_fid),
+ fid_oid(&lli->lli_fid),
+ fid_ver(&lli->lli_fid),
+ LDLM_FLOCK} };
+ struct ldlm_enqueue_info einfo = {
+ .ei_type = LDLM_FLOCK,
+ .ei_mode = 0,
+ .ei_cb_cp = ldlm_flock_completion_ast,
+ .ei_cbdata = file_lock,
+ };
+ struct intnl_stat *st = llu_i2stat(ino);
+ struct lustre_handle lockh = {0};
+ ldlm_policy_data_t flock;
__u64 flags = 0;
- int rc;
+ int rc;
CDEBUG(D_VFSTRACE, "VFS Op:inode=%llu file_lock=%p\n",
(unsigned long long)st->st_ino, file_lock);
if (lmv->desc.ld_tgt_count < 1)
RETURN(rc = -ENODEV);
- if (lmv->tgts[0] && lmv->tgts[0]->ltd_exp != NULL)
+ if (lmv->tgts[0] != NULL && lmv->tgts[0]->ltd_exp != NULL)
rc = ldlm_cli_enqueue(lmv->tgts[0]->ltd_exp, NULL,
&einfo, &res_id, &flock, &flags,
NULL, 0, LVB_T_NONE, &lockh, 0);
LASSERT(sizeof(lum) == sizeof(*lump));
LASSERT(sizeof(lum.lmm_objects[0]) ==
sizeof(lump->lmm_objects[0]));
- if (cfs_copy_from_user(&lum, lump, sizeof(lum)))
+ if (copy_from_user(&lum, lump, sizeof(lum)))
return(-EFAULT);
switch (lum.lmm_magic) {
}
static int llu_lov_setstripe_ea_info(struct inode *ino, int flags,
- struct lov_user_md *lum, int lum_size)
+ struct lov_user_md *lum, int lum_size)
{
- struct llu_sb_info *sbi = llu_i2sbi(ino);
- struct llu_inode_info *lli = llu_i2info(ino);
- struct lookup_intent oit = {.it_op = IT_OPEN, .it_flags = flags};
- struct ldlm_enqueue_info einfo = { LDLM_IBITS, LCK_CR,
- llu_md_blocking_ast, ldlm_completion_ast, NULL, NULL, NULL };
- struct ptlrpc_request *req = NULL;
- struct lustre_md md;
- struct md_op_data data = {{ 0 }};
- struct lustre_handle lockh;
- int rc = 0;
- ENTRY;
+ struct llu_sb_info *sbi = llu_i2sbi(ino);
+ struct llu_inode_info *lli = llu_i2info(ino);
+ struct lookup_intent oit = {.it_op = IT_OPEN, .it_flags = flags};
+ struct ldlm_enqueue_info einfo = {
+ .ei_type = LDLM_IBITS,
+ .ei_mode = LCK_CR,
+ .ei_cb_bl = llu_md_blocking_ast,
+ .ei_cb_cp = ldlm_completion_ast,
+ };
+ struct ptlrpc_request *req = NULL;
+ struct lustre_md md;
+ struct md_op_data data = {{ 0 }};
+ struct lustre_handle lockh;
+ int rc = 0;
+ ENTRY;
if (lli->lli_has_smd) {
- CDEBUG(D_IOCTL, "stripe already exists for ino "DFID"\n",
- PFID(&lli->lli_fid));
- return -EEXIST;
- }
+ CDEBUG(D_IOCTL, "stripe already exists for ino "DFID"\n",
+ PFID(&lli->lli_fid));
+ return -EEXIST;
+ }
llu_prep_md_op_data(&data, NULL, ino, NULL, 0, O_RDWR,
LUSTRE_OPC_ANY);
LASSERT(sizeof(lum) == sizeof(*lump));
LASSERT(sizeof(lum.lmm_objects[0]) == sizeof(lump->lmm_objects[0]));
- if (cfs_copy_from_user(&lum, lump, sizeof(lum)))
+ if (copy_from_user(&lum, lump, sizeof(lum)))
RETURN(-EFAULT);
rc = llu_lov_setstripe_ea_info(ino, flags, &lum, sizeof(lum));
return 0;
}
-struct filesys_ops llu_filesys_ops =
-{
- fsop_gone: llu_fsop_gone,
+static struct filesys_ops llu_filesys_ops = {
+ .fsop_gone = llu_fsop_gone,
};
struct inode *llu_iget(struct filesys *fs, struct lustre_md *md)
OBD_FREE(osc, strlen(lprof->lp_dt) + instlen + 2);
if (mdc)
OBD_FREE(mdc, strlen(lprof->lp_md) + instlen + 2);
- OBD_FREE(sbi, sizeof(*sbi));
+ if (err != 0)
+ OBD_FREE(sbi, sizeof(*sbi));
liblustre_wait_idle();
return err;
}
struct fssw_ops llu_fssw_ops = {
- llu_fsswop_mount
+ .fsswop_mount = llu_fsswop_mount,
};
static struct inode_ops llu_inode_ops = {
- inop_lookup: llu_iop_lookup,
- inop_getattr: llu_iop_getattr,
- inop_setattr: llu_iop_setattr,
- inop_filldirentries: llu_iop_filldirentries,
- inop_mkdir: llu_iop_mkdir_raw,
- inop_rmdir: llu_iop_rmdir_raw,
- inop_symlink: llu_iop_symlink_raw,
- inop_readlink: llu_iop_readlink,
- inop_open: llu_iop_open,
- inop_close: llu_iop_close,
- inop_link: llu_iop_link_raw,
- inop_unlink: llu_iop_unlink_raw,
- inop_rename: llu_iop_rename_raw,
- inop_pos: llu_iop_pos,
- inop_read: llu_iop_read,
- inop_write: llu_iop_write,
- inop_iodone: llu_iop_iodone,
- inop_fcntl: llu_iop_fcntl,
- inop_sync: llu_iop_sync,
- inop_datasync: llu_iop_datasync,
- inop_ioctl: llu_iop_ioctl,
- inop_mknod: llu_iop_mknod_raw,
+ .inop_lookup = llu_iop_lookup,
+ .inop_getattr = llu_iop_getattr,
+ .inop_setattr = llu_iop_setattr,
+ .inop_filldirentries = llu_iop_filldirentries,
+ .inop_mkdir = llu_iop_mkdir_raw,
+ .inop_rmdir = llu_iop_rmdir_raw,
+ .inop_symlink = llu_iop_symlink_raw,
+ .inop_readlink = llu_iop_readlink,
+ .inop_open = llu_iop_open,
+ .inop_close = llu_iop_close,
+ .inop_link = llu_iop_link_raw,
+ .inop_unlink = llu_iop_unlink_raw,
+ .inop_rename = llu_iop_rename_raw,
+ .inop_pos = llu_iop_pos,
+ .inop_read = llu_iop_read,
+ .inop_write = llu_iop_write,
+ .inop_iodone = llu_iop_iodone,
+ .inop_fcntl = llu_iop_fcntl,
+ .inop_sync = llu_iop_sync,
+ .inop_datasync = llu_iop_datasync,
+ .inop_ioctl = llu_iop_ioctl,
+ .inop_mknod = llu_iop_mknod_raw,
#ifdef _HAVE_STATVFS
- inop_statvfs: llu_iop_statvfs,
+ .inop_statvfs = llu_iop_statvfs,
#endif
- inop_gone: llu_iop_gone,
+ .inop_gone = llu_iop_gone,
};
git://git.whamcloud.com / fs / lustre-release.git / blobdiff