op_data->op_attr.ia_mtime = inode->i_mtime;
op_data->op_attr.ia_ctime = inode->i_ctime;
op_data->op_attr.ia_size = i_size_read(inode);
- op_data->op_attr.ia_valid |= ATTR_MODE | ATTR_ATIME | ATTR_ATIME_SET |
- ATTR_MTIME | ATTR_MTIME_SET |
- ATTR_CTIME | ATTR_CTIME_SET;
+ op_data->op_attr.ia_valid |= (ATTR_MODE | ATTR_ATIME | ATTR_ATIME_SET |
+ ATTR_MTIME | ATTR_MTIME_SET |
+ ATTR_CTIME);
+ op_data->op_xvalid |= OP_XVALID_CTIME_SET;
op_data->op_attr_blocks = inode->i_blocks;
op_data->op_attr_flags = ll_inode_to_ext_flags(inode->i_flags);
if (ll_file_test_flag(ll_i2info(inode), LLIF_PROJECT_INHERIT))
op_data->op_attr_flags |= LUSTRE_PROJINHERIT_FL;
- op_data->op_handle = och->och_fh;
+ op_data->op_open_handle = och->och_open_handle;
if (och->och_flags & FMODE_WRITE &&
ll_file_test_and_clear_flag(ll_i2info(inode), LLIF_DATA_MODIFIED))
case MDS_CLOSE_LAYOUT_MERGE:
/* merge blocks from the victim inode */
op_data->op_attr_blocks += ((struct inode *)data)->i_blocks;
- op_data->op_attr.ia_valid |= ATTR_SIZE | ATTR_BLOCKS;
+ op_data->op_attr.ia_valid |= ATTR_SIZE;
+ op_data->op_xvalid |= OP_XVALID_BLOCKS;
case MDS_CLOSE_LAYOUT_SPLIT:
case MDS_CLOSE_LAYOUT_SWAP: {
struct split_param *sp = data;
LASSERT(data != NULL);
op_data->op_attr_blocks +=
ioc->lil_count * op_data->op_attr_blocks;
- op_data->op_attr.ia_valid |= ATTR_SIZE | ATTR_BLOCKS;
+ op_data->op_attr.ia_valid |= ATTR_SIZE;
+ op_data->op_xvalid |= OP_XVALID_BLOCKS;
op_data->op_bias |= MDS_CLOSE_RESYNC_DONE;
op_data->op_lease_handle = och->och_lease_handle;
op_data->op_bias |= MDS_HSM_RELEASE;
op_data->op_data_version = *(__u64 *)data;
op_data->op_lease_handle = och->och_lease_handle;
- op_data->op_attr.ia_valid |= ATTR_SIZE | ATTR_BLOCKS;
+ op_data->op_attr.ia_valid |= ATTR_SIZE;
+ op_data->op_xvalid |= OP_XVALID_BLOCKS;
break;
default:
}
if (!(op_data->op_attr.ia_valid & ATTR_SIZE))
- op_data->op_attr.ia_valid |= MDS_ATTR_LSIZE;
- if (!(op_data->op_attr.ia_valid & ATTR_BLOCKS))
- op_data->op_attr.ia_valid |= MDS_ATTR_LBLOCKS;
+ op_data->op_xvalid |= OP_XVALID_LAZYSIZE;
+ if (!(op_data->op_xvalid & OP_XVALID_BLOCKS))
+ op_data->op_xvalid |= OP_XVALID_LAZYBLOCKS;
rc = md_close(md_exp, op_data, och->och_mod, &req);
if (rc != 0 && rc != -EINTR)
out:
md_clear_open_replay_data(md_exp, och);
- och->och_fh.cookie = DEAD_HANDLE_MAGIC;
+ och->och_open_handle.cookie = DEAD_HANDLE_MAGIC;
OBD_FREE_PTR(och);
ptlrpc_req_finished(req); /* This is close request */
struct page *vmpage;
struct niobuf_remote *rnb;
char *data;
- struct lu_env *env;
- struct cl_io *io;
- __u16 refcheck;
struct lustre_handle lockh;
struct ldlm_lock *lock;
unsigned long index, start;
struct niobuf_local lnb;
- int rc;
bool dom_lock = false;
ENTRY;
dom_lock = ldlm_has_dom(lock);
LDLM_LOCK_PUT(lock);
}
-
if (!dom_lock)
RETURN_EXIT;
- env = cl_env_get(&refcheck);
- if (IS_ERR(env))
- RETURN_EXIT;
-
if (!req_capsule_has_field(&req->rq_pill, &RMF_NIOBUF_INLINE,
RCL_SERVER))
- GOTO(out_env, rc = -ENODATA);
+ RETURN_EXIT;
rnb = req_capsule_server_get(&req->rq_pill, &RMF_NIOBUF_INLINE);
- data = (char *)rnb + sizeof(*rnb);
-
if (rnb == NULL || rnb->rnb_len == 0)
- GOTO(out_env, rc = 0);
+ RETURN_EXIT;
CDEBUG(D_INFO, "Get data buffer along with open, len %i, i_size %llu\n",
rnb->rnb_len, i_size_read(inode));
- io = vvp_env_thread_io(env);
- io->ci_obj = obj;
- io->ci_ignore_layout = 1;
- rc = cl_io_init(env, io, CIT_MISC, obj);
- if (rc)
- GOTO(out_io, rc);
+ data = (char *)rnb + sizeof(*rnb);
lnb.lnb_file_offset = rnb->rnb_offset;
start = lnb.lnb_file_offset / PAGE_SIZE;
LASSERT(lnb.lnb_file_offset % PAGE_SIZE == 0);
lnb.lnb_page_offset = 0;
do {
- struct cl_page *clp;
-
lnb.lnb_data = data + (index << PAGE_SHIFT);
lnb.lnb_len = rnb->rnb_len - (index << PAGE_SHIFT);
if (lnb.lnb_len > PAGE_SIZE)
PTR_ERR(vmpage));
break;
}
- lock_page(vmpage);
- if (vmpage->mapping == NULL) {
- unlock_page(vmpage);
- put_page(vmpage);
- /* page was truncated */
- GOTO(out_io, rc = -ENODATA);
- }
- clp = cl_page_find(env, obj, vmpage->index, vmpage,
- CPT_CACHEABLE);
- if (IS_ERR(clp)) {
- unlock_page(vmpage);
- put_page(vmpage);
- GOTO(out_io, rc = PTR_ERR(clp));
- }
-
- /* export page */
- cl_page_export(env, clp, 1);
- cl_page_put(env, clp);
- unlock_page(vmpage);
put_page(vmpage);
index++;
} while (rnb->rnb_len > (index << PAGE_SHIFT));
- rc = 0;
EXIT;
-out_io:
- cl_io_fini(env, io);
-out_env:
- cl_env_put(env, &refcheck);
}
static int ll_intent_file_open(struct dentry *de, void *lmm, int lmmsize,
struct mdt_body *body;
body = req_capsule_server_get(&it->it_request->rq_pill, &RMF_MDT_BODY);
- och->och_fh = body->mbo_handle;
+ och->och_open_handle = body->mbo_open_handle;
och->och_fid = body->mbo_fid1;
och->och_lease_handle.cookie = it->it_lock_handle;
och->och_magic = OBD_CLIENT_HANDLE_MAGIC;
if (file->f_flags & O_TRUNC)
oit.it_flags |= FMODE_WRITE;
- /* kernel only call f_op->open in dentry_open. filp_open calls
- * dentry_open after call to open_namei that checks permissions.
- * Only nfsd_open call dentry_open directly without checking
- * permissions and because of that this code below is safe. */
- if (oit.it_flags & (FMODE_WRITE | FMODE_READ))
- oit.it_flags |= MDS_OPEN_OWNEROVERRIDE;
+ /* kernel only call f_op->open in dentry_open. filp_open calls
+ * dentry_open after call to open_namei that checks permissions.
+ * Only nfsd_open call dentry_open directly without checking
+ * permissions and because of that this code below is safe.
+ */
+ if (oit.it_flags & (FMODE_WRITE | FMODE_READ))
+ oit.it_flags |= MDS_OPEN_OWNEROVERRIDE;
/* We do not want O_EXCL here, presumably we opened the file
* already? XXX - NFS implications? */
* if it has an open lock in cache already.
*/
static int ll_lease_och_acquire(struct inode *inode, struct file *file,
- struct lustre_handle *old_handle)
+ struct lustre_handle *old_open_handle)
{
struct ll_inode_info *lli = ll_i2info(inode);
struct ll_file_data *fd = LUSTRE_FPRIVATE(file);
*och_p = NULL;
}
- *old_handle = fd->fd_och->och_fh;
+ *old_open_handle = fd->fd_och->och_open_handle;
EXIT;
out_unlock:
struct ll_sb_info *sbi = ll_i2sbi(inode);
struct md_op_data *op_data;
struct ptlrpc_request *req = NULL;
- struct lustre_handle old_handle = { 0 };
+ struct lustre_handle old_open_handle = { 0 };
struct obd_client_handle *och = NULL;
int rc;
int rc2;
if (!(fmode & file->f_mode) || (file->f_mode & FMODE_EXEC))
RETURN(ERR_PTR(-EPERM));
- rc = ll_lease_och_acquire(inode, file, &old_handle);
+ rc = ll_lease_och_acquire(inode, file, &old_open_handle);
if (rc)
RETURN(ERR_PTR(rc));
}
GOTO(out, rc = PTR_ERR(op_data));
/* To tell the MDT this openhandle is from the same owner */
- op_data->op_handle = old_handle;
+ op_data->op_open_handle = old_open_handle;
it.it_flags = fmode | open_flags;
it.it_flags |= MDS_OPEN_LOCK | MDS_OPEN_BY_FID | MDS_OPEN_LEASE;
if (rc)
GOTO(out, rc);
- op_data->op_handle = och->och_lease_handle;
+ op_data->op_lease_handle = och->och_lease_handle;
rc = md_file_resync(sbi->ll_md_exp, op_data);
if (rc)
GOTO(out, rc);
inode_lock(inode);
- rc = ll_setattr_raw(file_dentry(file), attr, true);
+ rc = ll_setattr_raw(file_dentry(file), attr, 0, true);
if (rc == -ENODATA)
rc = 0;
struct iattr ia = {
.ia_valid = ATTR_ATIME | ATTR_ATIME_SET |
ATTR_MTIME | ATTR_MTIME_SET |
- ATTR_CTIME | ATTR_CTIME_SET,
+ ATTR_CTIME,
.ia_atime = {
.tv_sec = lfu->lfu_atime_sec,
.tv_nsec = lfu->lfu_atime_nsec,
RETURN(-EINVAL);
inode_lock(inode);
- rc = ll_setattr_raw(file_dentry(file), &ia, false);
+ rc = ll_setattr_raw(file_dentry(file), &ia, OP_XVALID_CTIME_SET,
+ false);
inode_unlock(inode);
RETURN(rc);
int rc = 0;
struct fsxattr fsxattr;
struct cl_object *obj;
+ struct iattr *attr;
int flags;
/* only root could change project ID */
if (copy_from_user(&fsxattr,
(const struct fsxattr __user *)arg,
sizeof(fsxattr)))
- GOTO(out_fsxattr1, rc = -EFAULT);
+ GOTO(out_fsxattr, rc = -EFAULT);
flags = ll_xflags_to_inode_flags(fsxattr.fsx_xflags);
op_data->op_attr_flags = ll_inode_to_ext_flags(flags);
if (fsxattr.fsx_xflags & FS_XFLAG_PROJINHERIT)
op_data->op_attr_flags |= LUSTRE_PROJINHERIT_FL;
op_data->op_projid = fsxattr.fsx_projid;
- op_data->op_attr.ia_valid |= (MDS_ATTR_PROJID | ATTR_ATTR_FLAG);
+ op_data->op_xvalid |= OP_XVALID_PROJID | OP_XVALID_FLAGS;
rc = md_setattr(ll_i2sbi(inode)->ll_md_exp, op_data, NULL,
0, &req);
ptlrpc_req_finished(req);
-
+ if (rc)
+ GOTO(out_fsxattr, rc);
+ ll_update_inode_flags(inode, op_data->op_attr_flags);
obj = ll_i2info(inode)->lli_clob;
- if (obj) {
- struct iattr *attr;
+ if (obj == NULL)
+ GOTO(out_fsxattr, rc);
- ll_update_inode_flags(inode, op_data->op_attr_flags);
- OBD_ALLOC_PTR(attr);
- if (attr == NULL)
- GOTO(out_fsxattr1, rc = -ENOMEM);
- attr->ia_valid = ATTR_ATTR_FLAG;
- rc = cl_setattr_ost(obj, attr, fsxattr.fsx_xflags);
+ OBD_ALLOC_PTR(attr);
+ if (attr == NULL)
+ GOTO(out_fsxattr, rc = -ENOMEM);
- OBD_FREE_PTR(attr);
- }
-out_fsxattr1:
+ rc = cl_setattr_ost(obj, attr, OP_XVALID_FLAGS,
+ fsxattr.fsx_xflags);
+ OBD_FREE_PTR(attr);
+out_fsxattr:
ll_finish_md_op_data(op_data);
RETURN(rc);
}
if (!child_inode)
RETURN(-ENOENT);
+ if (!(exp_connect_flags2(ll_i2sbi(parent)->ll_md_exp) &
+ OBD_CONNECT2_DIR_MIGRATE)) {
+ if (le32_to_cpu(lum->lum_stripe_count) > 1 ||
+ ll_i2info(child_inode)->lli_lsm_md) {
+ CERROR("%s: MDT doesn't support stripe directory "
+ "migration!\n",
+ ll_get_fsname(parent->i_sb, NULL, 0));
+ GOTO(out_iput, rc = -EOPNOTSUPP);
+ }
+ }
+
/*
* lfs migrate command needs to be blocked on the client
* by checking the migrate FID against the FID of the
if (rc != 0)
GOTO(out_close, rc);
- op_data->op_handle = och->och_fh;
+ op_data->op_open_handle = och->och_open_handle;
op_data->op_data_version = data_version;
op_data->op_lease_handle = och->och_lease_handle;
op_data->op_bias |= MDS_CLOSE_MIGRATE;
obd_mod_put(och->och_mod);
md_clear_open_replay_data(ll_i2sbi(parent)->ll_md_exp,
och);
- och->och_fh.cookie = DEAD_HANDLE_MAGIC;
+ och->och_open_handle.cookie = DEAD_HANDLE_MAGIC;
OBD_FREE_PTR(och);
och = NULL;
}