/* Checked by mdc_readpage() */
LASSERT(body != NULL);
- if (body->valid & OBD_MD_FLSIZE) {
- ll_inode_size_lock(inode, 0);
- i_size_write(inode, body->size);
- ll_inode_size_unlock(inode, 0);
- }
+ if (body->valid & OBD_MD_FLSIZE)
+ cl_isize_write(inode, body->size);
SetPageUptodate(page);
}
ptlrpc_req_finished(request);
if (request)
ptlrpc_req_finished(request);
if (rc < 0) {
- CERROR("lock enqueue: rc: %d\n", rc);
+ CERROR("lock enqueue: "DFID" at "LPU64": rc %d\n",
+ PFID(ll_inode2fid(dir)), hash, rc);
return ERR_PTR(rc);
}
} else {
ldlm_lock_dump_handle(D_OTHER, &lockh);
page = ll_dir_page_locate(dir, hash, &start, &end);
- if (IS_ERR(page))
+ if (IS_ERR(page)) {
+ CERROR("dir page locate: "DFID" at "LPU64": rc %ld\n",
+ PFID(ll_inode2fid(dir)), hash, PTR_ERR(page));
GOTO(out_unlock, page);
+ }
if (page != NULL) {
/*
* entries with smaller hash values. Stale page should
* be invalidated, and new one fetched.
*/
- CWARN("Stale readpage page %p: "LPX64" != "LPX64"\n",
- page, hash, start);
+ CDEBUG(D_OTHER, "Stale readpage page %p: "LPX64" != "LPX64"\n",
+ page, hash, start);
ll_release_page(page, hash, start, end);
} else {
GOTO(hash_collision, page);
page = read_cache_page(mapping, hash_x_index((unsigned long)hash),
(filler_t*)mapping->a_ops->readpage, NULL);
- if (IS_ERR(page))
+ if (IS_ERR(page)) {
+ CERROR("read cache page: "DFID" at "LPU64": rc %ld\n",
+ PFID(ll_inode2fid(dir)), hash, PTR_ERR(page));
GOTO(out_unlock, page);
+ }
wait_on_page(page);
(void)kmap(page);
- if (!PageUptodate(page))
+ if (!PageUptodate(page)) {
+ CERROR("page not updated: "DFID" at "LPU64": rc %d\n",
+ PFID(ll_inode2fid(dir)), hash, -5);
goto fail;
+ }
if (!PageChecked(page))
ll_check_page(dir, page);
- if (PageError(page))
+ if (PageError(page)) {
+ CERROR("page error: "DFID" at "LPU64": rc %d\n",
+ PFID(ll_inode2fid(dir)), hash, -5);
goto fail;
+ }
hash_collision:
dp = page_address(page);
{
struct inode *inode = filp->f_dentry->d_inode;
struct ll_inode_info *info = ll_i2info(inode);
- struct ll_sb_info *sbi = ll_i2sbi(inode);
__u64 pos = filp->f_pos;
struct page *page;
struct ll_dir_chain chain;
fid = ent->lde_fid;
name = ent->lde_name;
fid_le_to_cpu(&fid, &fid);
- ino = ll_fid_build_ino(sbi, &fid);
+ ino = cl_fid_build_ino(&fid);
type = ll_dirent_type_get(ent);
done = filldir(cookie, name, namelen,
(loff_t)hash, ino, type);
char *fsname = NULL, *param = NULL;
int lum_size;
- /*
- * This is coming from userspace, so should be in
- * local endian. But the MDS would like it in little
- * endian, so we swab it before we send it.
- */
- switch (lump->lmm_magic) {
- case LOV_USER_MAGIC_V1: {
- if (lump->lmm_magic != cpu_to_le32(LOV_USER_MAGIC_V1))
- lustre_swab_lov_user_md_v1(lump);
+ if (lump != NULL) {
+ /*
+ * This is coming from userspace, so should be in
+ * local endian. But the MDS would like it in little
+ * endian, so we swab it before we send it.
+ */
+ switch (lump->lmm_magic) {
+ case LOV_USER_MAGIC_V1: {
+ if (lump->lmm_magic != cpu_to_le32(LOV_USER_MAGIC_V1))
+ lustre_swab_lov_user_md_v1(lump);
+ lum_size = sizeof(struct lov_user_md_v1);
+ break;
+ }
+ case LOV_USER_MAGIC_V3: {
+ if (lump->lmm_magic != cpu_to_le32(LOV_USER_MAGIC_V3))
+ lustre_swab_lov_user_md_v3(
+ (struct lov_user_md_v3 *)lump);
+ lum_size = sizeof(struct lov_user_md_v3);
+ break;
+ }
+ default: {
+ CDEBUG(D_IOCTL, "bad userland LOV MAGIC:"
+ " %#08x != %#08x nor %#08x\n",
+ lump->lmm_magic, LOV_USER_MAGIC_V1,
+ LOV_USER_MAGIC_V3);
+ RETURN(-EINVAL);
+ }
+ }
+ } else {
lum_size = sizeof(struct lov_user_md_v1);
- break;
- }
- case LOV_USER_MAGIC_V3: {
- if (lump->lmm_magic != cpu_to_le32(LOV_USER_MAGIC_V3))
- lustre_swab_lov_user_md_v3((struct lov_user_md_v3 *)lump);
- lum_size = sizeof(struct lov_user_md_v3);
- break;
- }
- default: {
- CDEBUG(D_IOCTL, "bad userland LOV MAGIC:"
- " %#08x != %#08x nor %#08x\n",
- lump->lmm_magic, LOV_USER_MAGIC_V1,
- LOV_USER_MAGIC_V3);
- RETURN(-EINVAL);
- }
}
op_data = ll_prep_md_op_data(NULL, inode, NULL, NULL, 0, 0,
fsname = ll_get_fsname(inode);
/* Set root stripesize */
sprintf(param, "%s-MDT0000.lov.stripesize=%u", fsname,
- lump->lmm_stripe_size);
+ lump ? le32_to_cpu(lump->lmm_stripe_size) : 0);
rc = ll_send_mgc_param(mgc->u.cli.cl_mgc_mgsexp, param);
if (rc)
goto end;
/* Set root stripecount */
sprintf(param, "%s-MDT0000.lov.stripecount=%hd", fsname,
- lump->lmm_stripe_count);
+ lump ? le16_to_cpu(lump->lmm_stripe_count) : 0);
rc = ll_send_mgc_param(mgc->u.cli.cl_mgc_mgsexp, param);
if (rc)
goto end;
/* Set root stripeoffset */
sprintf(param, "%s-MDT0000.lov.stripeoffset=%hd", fsname,
- lump->lmm_stripe_offset);
+ lump ? le16_to_cpu(lump->lmm_stripe_offset) :
+ (typeof(lump->lmm_stripe_offset))(-1));
rc = ll_send_mgc_param(mgc->u.cli.cl_mgc_mgsexp, param);
if (rc)
goto end;
struct lov_mds_md *lmm = NULL;
struct ptlrpc_request *req = NULL;
int rc, lmmsize;
- struct obd_capa *oc;
+ struct md_op_data *op_data;
rc = ll_get_max_mdsize(sbi, &lmmsize);
if (rc)
RETURN(rc);
- oc = ll_mdscapa_get(inode);
- rc = md_getattr(sbi->ll_md_exp, ll_inode2fid(inode),
- oc, OBD_MD_FLEASIZE | OBD_MD_FLDIREA,
- lmmsize, &req);
- capa_put(oc);
+ op_data = ll_prep_md_op_data(NULL, inode, NULL, NULL,
+ 0, lmmsize, LUSTRE_OPC_ANY,
+ NULL);
+ if (op_data == NULL)
+ RETURN(-ENOMEM);
+
+ op_data->op_valid = OBD_MD_FLEASIZE | OBD_MD_FLDIREA;
+ rc = md_getattr(sbi->ll_md_exp, op_data, &req);
+ ll_finish_md_op_data(op_data);
if (rc < 0) {
CDEBUG(D_INFO, "md_getattr failed on inode "
"%lu/%u: rc %d\n", inode->i_ino,
return rc;
}
+/*
+ * Get MDT index for the inode.
+ */
+int ll_get_mdt_idx(struct inode *inode)
+{
+ struct ll_sb_info *sbi = ll_i2sbi(inode);
+ struct md_op_data *op_data;
+ int rc, mdtidx;
+ ENTRY;
+
+ op_data = ll_prep_md_op_data(NULL, inode, NULL, NULL, 0,
+ 0, LUSTRE_OPC_ANY, NULL);
+ if (op_data == NULL)
+ RETURN(-ENOMEM);
+
+ op_data->op_valid |= OBD_MD_MDTIDX;
+ rc = md_getattr(sbi->ll_md_exp, op_data, NULL);
+ mdtidx = op_data->op_mds;
+ ll_finish_md_op_data(op_data);
+ if (rc < 0) {
+ CDEBUG(D_INFO, "md_getattr_name: %d\n", rc);
+ RETURN(rc);
+ }
+ return mdtidx;
+}
+
+static int copy_and_ioctl(int cmd, struct obd_export *exp, void *data, int len)
+{
+ void *ptr;
+ int rc;
+
+ OBD_ALLOC(ptr, len);
+ if (ptr == NULL)
+ return -ENOMEM;
+ if (cfs_copy_from_user(ptr, data, len)) {
+ OBD_FREE(ptr, len);
+ return -EFAULT;
+ }
+ rc = obd_iocontrol(cmd, exp, len, data, NULL);
+ OBD_FREE(ptr, len);
+ return rc;
+}
+
static int ll_dir_ioctl(struct inode *inode, struct file *file,
unsigned int cmd, unsigned long arg)
{
struct ll_sb_info *sbi = ll_i2sbi(inode);
struct obd_ioctl_data *data;
+ int rc = 0;
ENTRY;
CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p), cmd=%#x\n",
ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_IOCTL, 1);
switch(cmd) {
- case EXT3_IOC_GETFLAGS:
- case EXT3_IOC_SETFLAGS:
+ case FSFILT_IOC_GETFLAGS:
+ case FSFILT_IOC_SETFLAGS:
RETURN(ll_iocontrol(inode, file, cmd, arg));
- case EXT3_IOC_GETVERSION_OLD:
- case EXT3_IOC_GETVERSION:
+ case FSFILT_IOC_GETVERSION_OLD:
+ case FSFILT_IOC_GETVERSION:
RETURN(put_user(inode->i_generation, (int *)arg));
/* We need to special case any other ioctls we want to handle,
* to send them to the MDS/OST as appropriate and to properly
* network encode the arg field.
- case EXT3_IOC_SETVERSION_OLD:
- case EXT3_IOC_SETVERSION:
+ case FSFILT_IOC_SETVERSION_OLD:
+ case FSFILT_IOC_SETVERSION:
*/
+ case LL_IOC_GET_MDTIDX: {
+ int mdtidx;
+
+ mdtidx = ll_get_mdt_idx(inode);
+ if (mdtidx < 0)
+ RETURN(mdtidx);
+
+ if (put_user((int)mdtidx, (int*)arg))
+ RETURN(-EFAULT);
+
+ return 0;
+ }
case IOC_MDC_LOOKUP: {
struct ptlrpc_request *request = NULL;
- int namelen, rc, len = 0;
+ int namelen, len = 0;
char *buf = NULL;
char *filename;
- struct obd_capa *oc;
+ struct md_op_data *op_data;
rc = obd_ioctl_getdata(&buf, &len, (void *)arg);
if (rc)
data = (void *)buf;
filename = data->ioc_inlbuf1;
- namelen = data->ioc_inllen1;
+ namelen = strlen(filename);
if (namelen < 1) {
CDEBUG(D_INFO, "IOC_MDC_LOOKUP missing filename\n");
- GOTO(out, rc = -EINVAL);
+ GOTO(out_free, rc = -EINVAL);
}
- oc = ll_mdscapa_get(inode);
- rc = md_getattr_name(sbi->ll_md_exp, ll_inode2fid(inode), oc,
- filename, namelen, OBD_MD_FLID, 0,
- ll_i2suppgid(inode), &request);
- capa_put(oc);
+ op_data = ll_prep_md_op_data(NULL, inode, NULL, filename, namelen,
+ 0, LUSTRE_OPC_ANY, NULL);
+ if (op_data == NULL)
+ GOTO(out_free, rc = -ENOMEM);
+
+ op_data->op_valid = OBD_MD_FLID;
+ rc = md_getattr_name(sbi->ll_md_exp, op_data, &request);
+ ll_finish_md_op_data(op_data);
if (rc < 0) {
CDEBUG(D_INFO, "md_getattr_name: %d\n", rc);
- GOTO(out, rc);
+ GOTO(out_free, rc);
}
-
ptlrpc_req_finished(request);
-
EXIT;
- out:
+out_free:
obd_ioctl_freedata(buf, len);
return rc;
}
struct lov_user_md_v1 *lumv1p = (struct lov_user_md_v1 *)arg;
struct lov_user_md_v3 *lumv3p = (struct lov_user_md_v3 *)arg;
- int rc = 0;
int set_default = 0;
LASSERT(sizeof(lumv3) == sizeof(*lumv3p));
LASSERT(sizeof(lumv3.lmm_objects[0]) ==
sizeof(lumv3p->lmm_objects[0]));
/* first try with v1 which is smaller than v3 */
- if (copy_from_user(lumv1, lumv1p, sizeof(*lumv1)))
+ if (cfs_copy_from_user(lumv1, lumv1p, sizeof(*lumv1)))
RETURN(-EFAULT);
if (lumv1->lmm_magic == LOV_USER_MAGIC_V3) {
- if (copy_from_user(&lumv3, lumv3p, sizeof(lumv3)))
+ if (cfs_copy_from_user(&lumv3, lumv3p, sizeof(lumv3)))
RETURN(-EFAULT);
}
struct lov_mds_md *lmm = NULL;
struct mdt_body *body;
char *filename = NULL;
- int rc, lmmsize;
+ int lmmsize;
if (cmd == IOC_MDC_GETFILEINFO ||
cmd == IOC_MDC_GETFILESTRIPE) {
lmdp = (struct lov_user_mds_data *)arg;
lump = &lmdp->lmd_lmm;
}
- if (copy_to_user(lump, lmm, lmmsize))
- GOTO(out_lmm, rc = -EFAULT);
+ if (cfs_copy_to_user(lump, lmm, lmmsize))
+ GOTO(out_req, rc = -EFAULT);
skip_lmm:
if (cmd == IOC_MDC_GETFILEINFO || cmd == LL_IOC_MDC_GETINFO) {
struct lov_user_mds_data *lmdp;
st.st_ino = inode->i_ino;
lmdp = (struct lov_user_mds_data *)arg;
- if (copy_to_user(&lmdp->lmd_st, &st, sizeof(st)))
- GOTO(out_lmm, rc = -EFAULT);
+ if (cfs_copy_to_user(&lmdp->lmd_st, &st, sizeof(st)))
+ GOTO(out_req, rc = -EFAULT);
}
EXIT;
- out_lmm:
- if (lmm && lmm->lmm_magic == LOV_MAGIC_JOIN)
- OBD_FREE(lmm, lmmsize);
out_req:
ptlrpc_req_finished(request);
if (filename)
struct lov_mds_md *lmm;
int lmmsize;
lstat_t st;
- int rc;
lumd = (struct lov_user_mds_data *)arg;
lum = &lumd->lmd_lmm;
RETURN(rc);
OBD_ALLOC(lmm, lmmsize);
- if (copy_from_user(lmm, lum, lmmsize))
+ if (cfs_copy_from_user(lmm, lum, lmmsize))
GOTO(free_lmm, rc = -EFAULT);
switch (lmm->lmm_magic) {
if (rc < 0)
GOTO(free_lmm, rc = -ENOMEM);
- rc = obd_checkmd(sbi->ll_dt_exp, sbi->ll_md_exp, lsm);
- if (rc)
- GOTO(free_lsm, rc);
-
/* Perform glimpse_size operation. */
memset(&st, 0, sizeof(st));
if (rc)
GOTO(free_lsm, rc);
- if (copy_to_user(&lumd->lmd_st, &st, sizeof(st)))
+ if (cfs_copy_to_user(&lumd->lmd_st, &st, sizeof(st)))
GOTO(free_lsm, rc = -EFAULT);
EXIT;
char *buf = NULL;
char *str;
int len = 0;
- int rc;
rc = obd_ioctl_getdata(&buf, &len, (void *)arg);
if (rc)
if (!rc) {
str = req_capsule_server_get(&req->rq_pill,
&RMF_STRING);
- if (copy_to_user(data->ioc_pbuf1, str, data->ioc_plen1))
+ if (cfs_copy_to_user(data->ioc_pbuf1, str,
+ data->ioc_plen1))
rc = -EFAULT;
}
ptlrpc_req_finished(req);
}
case OBD_IOC_QUOTACHECK: {
struct obd_quotactl *oqctl;
- int rc, error = 0;
+ int error = 0;
if (!cfs_capable(CFS_CAP_SYS_ADMIN) ||
sbi->ll_flags & LL_SBI_RMT_CLIENT)
}
case OBD_IOC_POLL_QUOTACHECK: {
struct if_quotacheck *check;
- int rc;
if (!cfs_capable(CFS_CAP_SYS_ADMIN) ||
sbi->ll_flags & LL_SBI_RMT_CLIENT)
NULL);
if (rc) {
CDEBUG(D_QUOTA, "mdc ioctl %d failed: %d\n", cmd, rc);
- if (copy_to_user((void *)arg, check, sizeof(*check)))
+ if (cfs_copy_to_user((void *)arg, check,
+ sizeof(*check)))
rc = -EFAULT;
GOTO(out_poll, rc);
}
NULL);
if (rc) {
CDEBUG(D_QUOTA, "osc ioctl %d failed: %d\n", cmd, rc);
- if (copy_to_user((void *)arg, check, sizeof(*check)))
+ if (cfs_copy_to_user((void *)arg, check,
+ sizeof(*check)))
rc = -EFAULT;
GOTO(out_poll, rc);
}
}
case OBD_IOC_QUOTACTL: {
struct if_quotactl *qctl;
- int cmd, type, id, valid, rc = 0;
+ int cmd, type, id, valid;
OBD_ALLOC_PTR(qctl);
if (!qctl)
RETURN(-ENOMEM);
- if (copy_from_user(qctl, (void *)arg, sizeof(*qctl)))
+ if (cfs_copy_from_user(qctl, (void *)arg, sizeof(*qctl)))
GOTO(out_quotactl, rc = -EFAULT);
cmd = qctl->qc_cmd;
GOTO(out_quotactl, rc = -EPERM);
break;
case Q_GETQUOTA:
- if (((type == USRQUOTA && current->euid != id) ||
+ if (((type == USRQUOTA && cfs_curproc_euid() != id) ||
(type == GRPQUOTA && !in_egroup_p(id))) &&
(!cfs_capable(CFS_CAP_SYS_ADMIN) ||
sbi->ll_flags & LL_SBI_RMT_CLIENT))
}
}
- if (copy_to_user((void *)arg, qctl, sizeof(*qctl)))
+ if (cfs_copy_to_user((void *)arg, qctl, sizeof(*qctl)))
rc = -EFAULT;
out_quotactl:
struct obd_device *obd = class_exp2obd(sbi->ll_dt_exp);
if (!obd)
RETURN(-EFAULT);
- if (copy_to_user((void *)arg, obd->obd_name,
- strlen(obd->obd_name) + 1))
+ if (cfs_copy_to_user((void *)arg, obd->obd_name,
+ strlen(obd->obd_name) + 1))
RETURN (-EFAULT);
RETURN(0);
}
if (sbi->ll_flags & LL_SBI_RMT_CLIENT &&
inode == inode->i_sb->s_root->d_inode) {
struct ll_file_data *fd = LUSTRE_FPRIVATE(file);
- int rc;
LASSERT(fd != NULL);
rc = rct_add(&sbi->ll_rct, cfs_curproc_pid(), arg);
case LL_IOC_GETOBDCOUNT: {
int count;
- if (copy_from_user(&count, (int *)arg, sizeof(int)))
+ if (cfs_copy_from_user(&count, (int *)arg, sizeof(int)))
RETURN(-EFAULT);
if (!count) {
count = lmv->desc.ld_tgt_count;
}
- if (copy_to_user((int *)arg, &count, sizeof(int)))
+ if (cfs_copy_to_user((int *)arg, &count, sizeof(int)))
RETURN(-EFAULT);
RETURN(0);
}
case LL_IOC_PATH2FID:
- if (copy_to_user((void *)arg, &ll_i2info(inode)->lli_fid,
- sizeof(struct lu_fid)))
+ if (cfs_copy_to_user((void *)arg, ll_inode2fid(inode),
+ sizeof(struct lu_fid)))
RETURN(-EFAULT);
RETURN(0);
- case OBD_IOC_CHANGELOG_CLEAR: {
- struct ioc_changelog_clear *icc;
- int rc;
-
- OBD_ALLOC_PTR(icc);
- if (icc == NULL)
- RETURN(-ENOMEM);
- if (copy_from_user(icc, (void *)arg, sizeof(*icc)))
- GOTO(icc_free, rc = -EFAULT);
-
- rc = obd_iocontrol(cmd, sbi->ll_md_exp, sizeof(*icc), icc,NULL);
-
-icc_free:
- OBD_FREE_PTR(icc);
+ case OBD_IOC_CHANGELOG_SEND:
+ case OBD_IOC_CHANGELOG_CLEAR:
+ rc = copy_and_ioctl(cmd, sbi->ll_md_exp, (void *)arg,
+ sizeof(struct ioc_changelog));
RETURN(rc);
- }
case OBD_IOC_FID2PATH:
RETURN(ll_fid2path(ll_i2mdexp(inode), (void *)arg));
+ case LL_IOC_HSM_CT_START:
+ rc = copy_and_ioctl(cmd, sbi->ll_md_exp, (void *)arg,
+ sizeof(struct lustre_kernelcomm));
+ RETURN(rc);
default:
RETURN(obd_iocontrol(cmd, sbi->ll_dt_exp,0,NULL,(void *)arg));
git://git.whamcloud.com / fs / lustre-release.git / blobdiff