-/* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
- * vim:expandtab:shiftwidth=8:tabstop=8:
- *
+/*
* GPL HEADER START
*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
/*
* Copyright (c) 2002, 2010, Oracle and/or its affiliates. All rights reserved.
* Use is subject to license terms.
- */
-/*
- * Copyright (c) 2011 Whamcloud, Inc.
+ *
+ * Copyright (c) 2011, 2012, Whamcloud, Inc.
*/
/*
* This file is part of Lustre, http://www.lustre.org/
och_usecount = &lli->lli_open_fd_read_count;
}
- cfs_down(&lli->lli_och_sem);
+ cfs_mutex_lock(&lli->lli_och_mutex);
if (*och_usecount) { /* There are still users of this handle, so
skip freeing it. */
- cfs_up(&lli->lli_och_sem);
+ cfs_mutex_unlock(&lli->lli_och_mutex);
RETURN(0);
}
och=*och_p;
*och_p = NULL;
- cfs_up(&lli->lli_och_sem);
+ cfs_mutex_unlock(&lli->lli_och_mutex);
if (och) { /* There might be a race and somebody have freed this och
already */
struct inode *inode = file->f_dentry->d_inode;
ldlm_policy_data_t policy = {.l_inodebits={MDS_INODELOCK_OPEN}};
- cfs_down(&lli->lli_och_sem);
+ cfs_mutex_lock(&lli->lli_och_mutex);
if (fd->fd_omode & FMODE_WRITE) {
lockmode = LCK_CW;
LASSERT(lli->lli_open_fd_write_count);
LASSERT(lli->lli_open_fd_read_count);
lli->lli_open_fd_read_count--;
}
- cfs_up(&lli->lli_och_sem);
+ cfs_mutex_unlock(&lli->lli_och_mutex);
if (!md_lock_match(md_exp, flags, ll_inode2fid(inode),
LDLM_IBITS, &policy, lockmode,
/* The last ref on @file, maybe not the the owner pid of statahead.
* Different processes can open the same dir, "ll_opendir_key" means:
* it is me that should stop the statahead thread. */
- if (lli->lli_opendir_key == fd && lli->lli_opendir_pid != 0)
+ if (S_ISDIR(inode->i_mode) && lli->lli_opendir_key == fd &&
+ lli->lli_opendir_pid != 0)
ll_stop_statahead(inode, lli->lli_opendir_key);
if (inode->i_sb->s_root == file->f_dentry) {
RETURN(0);
}
- if (lsm)
- lov_test_and_clear_async_rc(lsm);
- lli->lli_async_rc = 0;
+ if (!S_ISDIR(inode->i_mode)) {
+ if (lsm)
+ lov_test_and_clear_async_rc(lsm);
+ lli->lli_async_rc = 0;
+ }
rc = ll_md_close(sbi->ll_md_exp, inode, file);
/* Open a file, and (for the very first open) create objects on the OSTs at
* this time. If opened with O_LOV_DELAY_CREATE, then we don't do the object
- * creation or open until ll_lov_setstripe() ioctl is called. We grab
- * lli_open_sem to ensure no other process will create objects, send the
- * stripe MD to the MDS, or try to destroy the objects if that fails.
+ * creation or open until ll_lov_setstripe() ioctl is called.
*
* If we already have the stripe MD locally then we don't request it in
* md_open(), by passing a lmm_size = 0.
fd->fd_file = file;
if (S_ISDIR(inode->i_mode)) {
cfs_spin_lock(&lli->lli_sa_lock);
- if (lli->lli_opendir_key == NULL && lli->lli_opendir_pid == 0) {
- LASSERT(lli->lli_sai == NULL);
+ if (lli->lli_opendir_key == NULL && lli->lli_sai == NULL &&
+ lli->lli_opendir_pid == 0) {
lli->lli_opendir_key = fd;
lli->lli_opendir_pid = cfs_curproc_pid();
opendir_set = 1;
och_usecount = &lli->lli_open_fd_read_count;
}
- cfs_down(&lli->lli_och_sem);
+ cfs_mutex_lock(&lli->lli_och_mutex);
if (*och_p) { /* Open handle is present */
if (it_disposition(it, DISP_OPEN_OPEN)) {
/* Well, there's extra open request that we do not need,
let's close it somehow. This will decref request. */
rc = it_open_error(DISP_OPEN_OPEN, it);
if (rc) {
- cfs_up(&lli->lli_och_sem);
+ cfs_mutex_unlock(&lli->lli_och_mutex);
GOTO(out_openerr, rc);
}
ll_release_openhandle(file->f_dentry, it);
- lprocfs_counter_incr(ll_i2sbi(inode)->ll_stats,
- LPROC_LL_OPEN);
}
(*och_usecount)++;
rc = ll_local_open(file, it, fd, NULL);
if (rc) {
(*och_usecount)--;
- cfs_up(&lli->lli_och_sem);
+ cfs_mutex_unlock(&lli->lli_och_mutex);
GOTO(out_openerr, rc);
}
} else {
/* We cannot just request lock handle now, new ELC code
means that one of other OPEN locks for this file
could be cancelled, and since blocking ast handler
- would attempt to grab och_sem as well, that would
+ would attempt to grab och_mutex as well, that would
result in a deadlock */
- cfs_up(&lli->lli_och_sem);
+ cfs_mutex_unlock(&lli->lli_och_mutex);
it->it_create_mode |= M_CHECK_STALE;
rc = ll_intent_file_open(file, NULL, 0, it);
it->it_create_mode &= ~M_CHECK_STALE;
LASSERT(it_disposition(it, DISP_ENQ_OPEN_REF));
- ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_OPEN, 1);
rc = ll_local_open(file, it, fd, *och_p);
if (rc)
GOTO(out_och_free, rc);
}
- cfs_up(&lli->lli_och_sem);
+ cfs_mutex_unlock(&lli->lli_och_mutex);
fd = NULL;
- /* Must do this outside lli_och_sem lock to prevent deadlock where
+ /* Must do this outside lli_och_mutex lock to prevent deadlock where
different kind of OPEN lock for this same inode gets cancelled
by ldlm_cancel_lru */
if (!S_ISREG(inode->i_mode))
*och_p = NULL; /* OBD_FREE writes some magic there */
(*och_usecount)--;
}
- cfs_up(&lli->lli_och_sem);
+ cfs_mutex_unlock(&lli->lli_och_mutex);
out_openerr:
if (opendir_set != 0)
ll_stop_statahead(inode, lli->lli_opendir_key);
if (fd != NULL)
ll_file_data_put(fd);
+ } else {
+ ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_OPEN, 1);
}
return rc;
OBD_MD_FLSIZE | OBD_MD_FLBLOCKS |
OBD_MD_FLBLKSZ | OBD_MD_FLATIME |
OBD_MD_FLMTIME | OBD_MD_FLCTIME |
- OBD_MD_FLGROUP | OBD_MD_FLEPOCH;
+ OBD_MD_FLGROUP | OBD_MD_FLEPOCH |
+ OBD_MD_FLDATAVERSION;
oinfo.oi_capa = capa;
if (sync) {
oinfo.oi_oa->o_valid |= OBD_MD_FLFLAGS;
if (rc == 0)
oinfo.oi_oa->o_valid &= (OBD_MD_FLBLOCKS | OBD_MD_FLBLKSZ |
OBD_MD_FLATIME | OBD_MD_FLMTIME |
- OBD_MD_FLCTIME | OBD_MD_FLSIZE);
+ OBD_MD_FLCTIME | OBD_MD_FLSIZE |
+ OBD_MD_FLDATAVERSION);
RETURN(rc);
}
if (rc == 0) {
obdo_refresh_inode(inode, obdo, obdo->o_valid);
CDEBUG(D_INODE,
- "objid "LPX64" size %Lu, blocks %llu, blksize %lu\n",
+ "objid "LPX64" size %llu, blocks %llu, blksize %lu\n",
lli->lli_smd->lsm_object_id, i_size_read(inode),
(unsigned long long)inode->i_blocks,
(unsigned long)ll_inode_blksize(inode));
if (cl_io_rw_init(env, io, iot, *ppos, count) == 0) {
struct vvp_io *vio = vvp_env_io(env);
struct ccc_io *cio = ccc_env_io(env);
- int write_sem_locked = 0;
+ int write_mutex_locked = 0;
cio->cui_fd = LUSTRE_FPRIVATE(file);
vio->cui_io_subtype = args->via_io_subtype;
#endif
if ((iot == CIT_WRITE) &&
!(cio->cui_fd->fd_flags & LL_FILE_GROUP_LOCKED)) {
- if(cfs_down_interruptible(&lli->lli_write_sem))
+ if (cfs_mutex_lock_interruptible(&lli->
+ lli_write_mutex))
GOTO(out, result = -ERESTARTSYS);
- write_sem_locked = 1;
+ write_mutex_locked = 1;
} else if (iot == CIT_READ) {
cfs_down_read(&lli->lli_trunc_sem);
}
LBUG();
}
result = cl_io_loop(env, io);
- if (write_sem_locked)
- cfs_up(&lli->lli_write_sem);
+ if (write_mutex_locked)
+ cfs_mutex_unlock(&lli->lli_write_mutex);
else if (args->via_io_subtype == IO_NORMAL && iot == CIT_READ)
cfs_up_read(&lli->lli_trunc_sem);
} else {
oa->o_nlink = ost_idx;
oa->o_flags |= OBD_FL_RECREATE_OBJS;
oa->o_valid = OBD_MD_FLID | OBD_MD_FLFLAGS | OBD_MD_FLGROUP;
- obdo_from_inode(oa, inode, &ll_i2info(inode)->lli_fid, OBD_MD_FLTYPE |
- OBD_MD_FLATIME | OBD_MD_FLMTIME | OBD_MD_FLCTIME);
+ obdo_from_inode(oa, inode, OBD_MD_FLTYPE | OBD_MD_FLATIME |
+ OBD_MD_FLMTIME | OBD_MD_FLCTIME);
+ obdo_set_parent_fid(oa, &ll_i2info(inode)->lli_fid);
memcpy(lsm2, lsm, lsm_size);
- rc = obd_create(exp, oa, &lsm2, &oti);
+ rc = obd_create(NULL, exp, oa, &lsm2, &oti);
OBD_FREE_LARGE(lsm2, lsm_size);
GOTO(out, rc);
op_data = ll_prep_md_op_data(NULL, inode, NULL, filename,
strlen(filename), lmmsize,
LUSTRE_OPC_ANY, NULL);
- if (op_data == NULL)
- RETURN(-ENOMEM);
+ if (IS_ERR(op_data))
+ RETURN(PTR_ERR(op_data));
op_data->op_valid = OBD_MD_FLEASIZE | OBD_MD_FLDIREA;
rc = md_getattr_name(sbi->ll_md_exp, op_data, &req);
fm_key.oa.o_seq = lsm->lsm_object_seq;
fm_key.oa.o_valid = OBD_MD_FLID | OBD_MD_FLGROUP;
- obdo_from_inode(&fm_key.oa, inode, &ll_i2info(inode)->lli_fid,
- OBD_MD_FLSIZE);
+ obdo_from_inode(&fm_key.oa, inode, OBD_MD_FLSIZE);
+ obdo_set_parent_fid(&fm_key.oa, &ll_i2info(inode)->lli_fid);
/* If filesize is 0, then there would be no objects for mapping */
if (fm_key.oa.o_size == 0) {
fiemap->fm_mapped_extents = 0;
memcpy(&fm_key.fiemap, fiemap, sizeof(*fiemap));
- rc = obd_get_info(exp, sizeof(fm_key), &fm_key, &vallen, fiemap, lsm);
+ rc = obd_get_info(NULL, exp, sizeof(fm_key), &fm_key, &vallen,
+ fiemap, lsm);
if (rc)
CERROR("obd_get_info failed: rc = %d\n", rc);
RETURN(rc);
}
-#ifdef HAVE_UNLOCKED_IOCTL
+/*
+ * Read the data_version for inode.
+ *
+ * This value is computed using stripe object version on OST.
+ * Version is computed using server side locking.
+ *
+ * @param extent_lock Take extent lock. Not needed if a process is already
+ * holding the OST object group locks.
+ */
+static int ll_data_version(struct inode *inode, __u64 *data_version,
+ int extent_lock)
+{
+ struct lov_stripe_md *lsm = ll_i2info(inode)->lli_smd;
+ struct ll_sb_info *sbi = ll_i2sbi(inode);
+ struct obdo *obdo = NULL;
+ int rc;
+ ENTRY;
+
+ /* If no stripe, we consider version is 0. */
+ if (!lsm) {
+ *data_version = 0;
+ CDEBUG(D_INODE, "No object for inode\n");
+ RETURN(0);
+ }
+
+ OBD_ALLOC_PTR(obdo);
+ if (obdo == NULL)
+ RETURN(-ENOMEM);
+
+ rc = ll_lsm_getattr(lsm, sbi->ll_dt_exp, NULL, obdo, 0, extent_lock);
+ if (!rc) {
+ if (!(obdo->o_valid & OBD_MD_FLDATAVERSION))
+ rc = -EOPNOTSUPP;
+ else
+ *data_version = obdo->o_data_version;
+ }
+
+ OBD_FREE_PTR(obdo);
+
+ RETURN(rc);
+}
+
long ll_file_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
struct inode *inode = file->f_dentry->d_inode;
-#else
-int ll_file_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
- unsigned long arg)
-{
-#endif
struct ll_file_data *fd = LUSTRE_FPRIVATE(file);
int flags;
+
ENTRY;
CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p),cmd=%x\n", inode->i_ino,
}
case OBD_IOC_FID2PATH:
RETURN(ll_fid2path(ll_i2mdexp(inode), (void *)arg));
+ case LL_IOC_DATA_VERSION: {
+ struct ioc_data_version idv;
+ int rc;
+
+ if (cfs_copy_from_user(&idv, (char *)arg, sizeof(idv)))
+ RETURN(-EFAULT);
+
+ rc = ll_data_version(inode, &idv.idv_version,
+ !(idv.idv_flags & LL_DV_NOFLUSH));
+
+ if (rc == 0 &&
+ cfs_copy_to_user((char *) arg, &idv, sizeof(idv)))
+ RETURN(-EFAULT);
+
+ RETURN(rc);
+ }
case LL_IOC_GET_MDTIDX: {
int mdtidx;
RETURN(0);
}
-
+ case OBD_IOC_GETDTNAME:
+ case OBD_IOC_GETMDNAME:
+ RETURN(ll_get_obd_name(inode, cmd, arg));
default: {
int err;
ENTRY;
retval = offset + ((origin == 2) ? i_size_read(inode) :
(origin == 1) ? file->f_pos : 0);
- CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p), to=%Lu=%#Lx(%s)\n",
+ CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p), to=%llu=%#llx(%s)\n",
inode->i_ino, inode->i_generation, inode, retval, retval,
origin == 2 ? "SEEK_END": origin == 1 ? "SEEK_CUR" : "SEEK_SET");
ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_LLSEEK, 1);
if (origin == 2) { /* SEEK_END */
- int nonblock = 0, rc;
-
- if (file->f_flags & O_NONBLOCK)
- nonblock = LDLM_FL_BLOCK_NOWAIT;
+ int rc;
- rc = cl_glimpse_size(inode);
+ rc = ll_glimpse_size(inode);
if (rc != 0)
RETURN(rc);
struct lov_stripe_md *lsm = lli->lli_smd;
int rc, err;
+ LASSERT(!S_ISDIR(inode->i_mode));
+
/* the application should know write failure already. */
if (lli->lli_write_rc)
return 0;
return rc ? -EIO : 0;
}
+/**
+ * Called to make sure a portion of file has been written out.
+ * if @local_only is not true, it will send OST_SYNC RPCs to ost.
+ */
+int cl_sync_file_range(struct inode *inode, loff_t start, loff_t end)
+{
+ struct cl_env_nest nest;
+ struct lu_env *env;
+ struct cl_io *io;
+ struct obd_capa *capa = NULL;
+ struct cl_fsync_io *fio;
+ int result;
+ ENTRY;
+
+ env = cl_env_nested_get(&nest);
+ if (IS_ERR(env))
+ RETURN(PTR_ERR(env));
+
+ capa = ll_osscapa_get(inode, CAPA_OPC_OSS_WRITE);
+
+ io = ccc_env_thread_io(env);
+ io->ci_obj = cl_i2info(inode)->lli_clob;
+
+ /* initialize parameters for sync */
+ fio = &io->u.ci_fsync;
+ fio->fi_capa = capa;
+ fio->fi_start = start;
+ fio->fi_end = end;
+ fio->fi_fid = ll_inode2fid(inode);
+
+ if (cl_io_init(env, io, CIT_FSYNC, io->ci_obj) == 0)
+ result = cl_io_loop(env, io);
+ else
+ result = io->ci_result;
+ cl_io_fini(env, io);
+ cl_env_nested_put(&nest, env);
+
+ capa_put(capa);
+
+ RETURN(result);
+}
+
+#ifdef HAVE_FILE_FSYNC_4ARGS
+int ll_fsync(struct file *file, loff_t start, loff_t end, int data)
+#elif defined(HAVE_FILE_FSYNC_2ARGS)
+int ll_fsync(struct file *file, int data)
+#else
int ll_fsync(struct file *file, struct dentry *dentry, int data)
+#endif
{
- struct inode *inode = dentry->d_inode;
+ struct inode *inode = file->f_dentry->d_inode;
struct ll_inode_info *lli = ll_i2info(inode);
struct lov_stripe_md *lsm = lli->lli_smd;
struct ptlrpc_request *req;
/* catch async errors that were recorded back when async writeback
* failed for pages in this mapping. */
- err = lli->lli_async_rc;
- lli->lli_async_rc = 0;
- if (rc == 0)
- rc = err;
- if (lsm) {
- err = lov_test_and_clear_async_rc(lsm);
+ if (!S_ISDIR(inode->i_mode)) {
+ err = lli->lli_async_rc;
+ lli->lli_async_rc = 0;
if (rc == 0)
rc = err;
+ if (lsm) {
+ err = lov_test_and_clear_async_rc(lsm);
+ if (rc == 0)
+ rc = err;
+ }
}
oc = ll_mdscapa_get(inode);
ptlrpc_req_finished(req);
if (data && lsm) {
- struct obd_info *oinfo;
-
- OBD_ALLOC_PTR(oinfo);
- if (!oinfo)
- RETURN(rc ? rc : -ENOMEM);
- OBDO_ALLOC(oinfo->oi_oa);
- if (!oinfo->oi_oa) {
- OBD_FREE_PTR(oinfo);
- RETURN(rc ? rc : -ENOMEM);
- }
- oinfo->oi_oa->o_id = lsm->lsm_object_id;
- oinfo->oi_oa->o_seq = lsm->lsm_object_seq;
- oinfo->oi_oa->o_valid = OBD_MD_FLID | OBD_MD_FLGROUP;
- obdo_from_inode(oinfo->oi_oa, inode, &ll_i2info(inode)->lli_fid,
- OBD_MD_FLTYPE | OBD_MD_FLATIME |
- OBD_MD_FLMTIME | OBD_MD_FLCTIME |
- OBD_MD_FLGROUP);
- oinfo->oi_md = lsm;
- oinfo->oi_capa = ll_osscapa_get(inode, CAPA_OPC_OSS_WRITE);
- err = obd_sync_rqset(ll_i2sbi(inode)->ll_dt_exp, oinfo, 0,
- OBD_OBJECT_EOF);
- capa_put(oinfo->oi_capa);
+ err = cl_sync_file_range(inode, 0, OBD_OBJECT_EOF);
if (!rc)
rc = err;
- OBDO_FREE(oinfo->oi_oa);
- OBD_FREE_PTR(oinfo);
- lli->lli_write_rc = err < 0 ? : 0;
+ lli->lli_write_rc = rc < 0 ? rc : 0;
}
RETURN(rc);
einfo.ei_mode = LCK_PW;
break;
default:
- CERROR("unknown fcntl lock type: %d\n", file_lock->fl_type);
- RETURN (-EINVAL);
+ CDEBUG(D_INFO, "Unknown fcntl lock type: %d\n",
+ file_lock->fl_type);
+ RETURN (-ENOTSUPP);
}
switch (cmd) {
if ((file_lock->fl_flags & FL_FLOCK) &&
(rc == 0 || file_lock->fl_type == F_UNLCK))
- ll_flock_lock_file_wait(file, file_lock, (cmd == F_SETLKW));
-#ifdef HAVE_F_OP_FLOCK
+ flock_lock_file_wait(file, file_lock);
if ((file_lock->fl_flags & FL_POSIX) &&
(rc == 0 || file_lock->fl_type == F_UNLCK) &&
!(flags & LDLM_FL_TEST_LOCK))
posix_lock_file_wait(file, file_lock);
-#endif
RETURN(rc);
}
{
struct inode *inode = dentry->d_inode;
struct ptlrpc_request *req = NULL;
- struct ll_sb_info *sbi;
struct obd_export *exp;
int rc = 0;
ENTRY;
CERROR("REPORT THIS LINE TO PETER\n");
RETURN(0);
}
- sbi = ll_i2sbi(inode);
CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p),name=%s\n",
inode->i_ino, inode->i_generation, inode, dentry->d_name.name);
op_data = ll_prep_md_op_data(NULL, inode, NULL, NULL,
0, ealen, LUSTRE_OPC_ANY,
NULL);
- if (op_data == NULL)
- RETURN(-ENOMEM);
+ if (IS_ERR(op_data))
+ RETURN(PTR_ERR(op_data));
op_data->op_valid = valid;
/* Once OBD_CONNECT_ATTRFID is not supported, we can't find one
RETURN(0);
}
- /* cl_glimpse_size will prefer locally cached writes if they extend
+ /* ll_glimpse_size will prefer locally cached writes if they extend
* the file */
if (rc == 0)
- rc = cl_glimpse_size(inode);
+ rc = ll_glimpse_size(inode);
RETURN(rc);
}
#endif
-static
-int lustre_check_acl(struct inode *inode, int mask)
+static int
+#ifdef HAVE_GENERIC_PERMISSION_4ARGS
+lustre_check_acl(struct inode *inode, int mask, unsigned int flags)
+#else
+lustre_check_acl(struct inode *inode, int mask)
+#endif
{
#ifdef CONFIG_FS_POSIX_ACL
struct ll_inode_info *lli = ll_i2info(inode);
int rc;
ENTRY;
+#ifdef HAVE_GENERIC_PERMISSION_4ARGS
+ if (flags & IPERM_FLAG_RCU)
+ return -ECHILD;
+#endif
cfs_spin_lock(&lli->lli_lock);
acl = posix_acl_dup(lli->lli_posix_acl);
cfs_spin_unlock(&lli->lli_lock);
#endif
}
-#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,10))
-#ifndef HAVE_INODE_PERMISION_2ARGS
-int ll_inode_permission(struct inode *inode, int mask, struct nameidata *nd)
+#ifdef HAVE_GENERIC_PERMISSION_4ARGS
+int ll_inode_permission(struct inode *inode, int mask, unsigned int flags)
#else
+# ifdef HAVE_INODE_PERMISION_2ARGS
int ll_inode_permission(struct inode *inode, int mask)
+# else
+int ll_inode_permission(struct inode *inode, int mask, struct nameidata *nd)
+# endif
#endif
{
int rc = 0;
return lustre_check_remote_perm(inode, mask);
ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_INODE_PERM, 1);
- rc = generic_permission(inode, mask, lustre_check_acl);
+ rc = ll_generic_permission(inode, mask, flags, lustre_check_acl);
RETURN(rc);
}
-#else
-int ll_inode_permission(struct inode *inode, int mask, struct nameidata *nd)
-{
- int mode = inode->i_mode;
- int rc;
-
- CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p), mask %o\n",
- inode->i_ino, inode->i_generation, inode, mask);
-
- if (ll_i2sbi(inode)->ll_flags & LL_SBI_RMT_CLIENT)
- return lustre_check_remote_perm(inode, mask);
-
- ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_INODE_PERM, 1);
-
- if ((mask & MAY_WRITE) && IS_RDONLY(inode) &&
- (S_ISREG(mode) || S_ISDIR(mode) || S_ISLNK(mode)))
- return -EROFS;
- if ((mask & MAY_WRITE) && IS_IMMUTABLE(inode))
- return -EACCES;
- if (cfs_curproc_fsuid() == inode->i_uid) {
- mode >>= 6;
- } else if (1) {
- if (((mode >> 3) & mask & S_IRWXO) != mask)
- goto check_groups;
- rc = lustre_check_acl(inode, mask);
- if (rc == -EAGAIN)
- goto check_groups;
- if (rc == -EACCES)
- goto check_capabilities;
- return rc;
- } else {
-check_groups:
- if (cfs_curproc_is_in_groups(inode->i_gid))
- mode >>= 3;
- }
- if ((mode & mask & S_IRWXO) == mask)
- return 0;
-
-check_capabilities:
- if (!(mask & MAY_EXEC) ||
- (inode->i_mode & S_IXUGO) || S_ISDIR(inode->i_mode))
- if (cfs_capable(CFS_CAP_DAC_OVERRIDE))
- return 0;
-
- if (cfs_capable(CFS_CAP_DAC_READ_SEARCH) && ((mask == MAY_READ) ||
- (S_ISDIR(inode->i_mode) && !(mask & MAY_WRITE))))
- return 0;
-
- return -EACCES;
-}
-#endif
#ifdef HAVE_FILE_READV
#define READ_METHOD readv
.READ_METHOD = READ_FUNCTION,
.write = ll_file_write,
.WRITE_METHOD = WRITE_FUNCTION,
-#ifdef HAVE_UNLOCKED_IOCTL
.unlocked_ioctl = ll_file_ioctl,
-#else
- .ioctl = ll_file_ioctl,
-#endif
.open = ll_file_open,
.release = ll_file_release,
.mmap = ll_file_mmap,
.READ_METHOD = READ_FUNCTION,
.write = ll_file_write,
.WRITE_METHOD = WRITE_FUNCTION,
-#ifdef HAVE_UNLOCKED_IOCTL
.unlocked_ioctl = ll_file_ioctl,
-#else
- .ioctl = ll_file_ioctl,
-#endif
.open = ll_file_open,
.release = ll_file_release,
.mmap = ll_file_mmap,
#endif
.fsync = ll_fsync,
.flush = ll_flush,
-#ifdef HAVE_F_OP_FLOCK
.flock = ll_file_flock,
-#endif
.lock = ll_file_flock
};
.READ_METHOD = READ_FUNCTION,
.write = ll_file_write,
.WRITE_METHOD = WRITE_FUNCTION,
-#ifdef HAVE_UNLOCKED_IOCTL
.unlocked_ioctl = ll_file_ioctl,
-#else
- .ioctl = ll_file_ioctl,
-#endif
.open = ll_file_open,
.release = ll_file_release,
.mmap = ll_file_mmap,
#endif
.fsync = ll_fsync,
.flush = ll_flush,
-#ifdef HAVE_F_OP_FLOCK
.flock = ll_file_noflock,
-#endif
.lock = ll_file_noflock
};
git://git.whamcloud.com / fs / lustre-release.git / blobdiff