* Copyright (c) 2002, 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/
* a header lu_dirpage which describes the start/end hash, and whether this
* page is empty (contains no dir entry) or hash collide with next page.
* After client receives reply, several pages will be integrated into dir page
- * in CFS_PAGE_SIZE (if CFS_PAGE_SIZE greater than LU_PAGE_SIZE), and the
- * lu_dirpage for this integrated page will be adjusted.
+ * in PAGE_CACHE_SIZE (if PAGE_CACHE_SIZE greater than LU_PAGE_SIZE), and the
+ * lu_dirpage for this integrated page will be adjusted. See
+ * lmv_adjust_dirpages().
*
*/
/* returns the page unlocked, but with a reference */
static int ll_dir_filler(void *_hash, struct page *page0)
{
- struct inode *inode = page0->mapping->host;
- int hash64 = ll_i2sbi(inode)->ll_flags & LL_SBI_64BIT_HASH;
- struct obd_export *exp = ll_i2sbi(inode)->ll_md_exp;
- struct ptlrpc_request *request;
- struct mdt_body *body;
- struct md_op_data *op_data;
+ struct inode *inode = page0->mapping->host;
+ int hash64 = ll_i2sbi(inode)->ll_flags & LL_SBI_64BIT_HASH;
+ struct obd_export *exp = ll_i2sbi(inode)->ll_md_exp;
+ struct ptlrpc_request *request;
+ struct mdt_body *body;
+ struct md_op_data *op_data;
__u64 hash = *((__u64 *)_hash);
- struct page **page_pool;
- struct page *page;
-#ifndef HAVE_ADD_TO_PAGE_CACHE_LRU
- struct pagevec lru_pvec;
-#endif
- struct lu_dirpage *dp;
- int max_pages = ll_i2sbi(inode)->ll_md_brw_size >> CFS_PAGE_SHIFT;
- int nrdpgs = 0; /* number of pages read actually */
- int npages;
- int i;
- int rc;
- ENTRY;
+ struct page **page_pool;
+ struct page *page;
+ struct lu_dirpage *dp;
+ int max_pages = ll_i2sbi(inode)->ll_md_brw_size >> PAGE_CACHE_SHIFT;
+ int nrdpgs = 0; /* number of pages read actually */
+ int npages;
+ int i;
+ int rc;
+ ENTRY;
- CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p) hash "LPU64"\n",
- inode->i_ino, inode->i_generation, inode, hash);
+ CDEBUG(D_VFSTRACE, "VFS Op:inode="DFID"(%p) hash "LPU64"\n",
+ PFID(ll_inode2fid(inode)), inode, hash);
LASSERT(max_pages > 0 && max_pages <= MD_MAX_BRW_PAGES);
- OBD_ALLOC(page_pool, sizeof(page) * max_pages);
- if (page_pool != NULL) {
- page_pool[0] = page0;
- } else {
- page_pool = &page0;
- max_pages = 1;
- }
- for (npages = 1; npages < max_pages; npages++) {
- page = page_cache_alloc_cold(inode->i_mapping);
- if (!page)
- break;
- page_pool[npages] = page;
- }
+ op_data = ll_prep_md_op_data(NULL, inode, NULL, NULL, 0, 0,
+ LUSTRE_OPC_ANY, NULL);
+ if (IS_ERR(op_data))
+ RETURN(PTR_ERR(op_data));
+
+ OBD_ALLOC(page_pool, sizeof(page) * max_pages);
+ if (page_pool != NULL) {
+ page_pool[0] = page0;
+ } else {
+ page_pool = &page0;
+ max_pages = 1;
+ }
+ for (npages = 1; npages < max_pages; npages++) {
+ page = page_cache_alloc_cold(inode->i_mapping);
+ if (!page)
+ break;
+ page_pool[npages] = page;
+ }
- op_data = ll_prep_md_op_data(NULL, inode, NULL, NULL, 0, 0,
- LUSTRE_OPC_ANY, NULL);
- op_data->op_npages = npages;
- op_data->op_offset = hash;
- rc = md_readpage(exp, op_data, page_pool, &request);
- ll_finish_md_op_data(op_data);
- if (rc == 0) {
- body = req_capsule_server_get(&request->rq_pill, &RMF_MDT_BODY);
- /* Checked by mdc_readpage() */
- LASSERT(body != NULL);
+ op_data->op_npages = npages;
+ op_data->op_offset = hash;
+ rc = md_readpage(exp, op_data, page_pool, &request);
+ ll_finish_md_op_data(op_data);
+ if (rc == 0) {
+ body = req_capsule_server_get(&request->rq_pill, &RMF_MDT_BODY);
+ /* Checked by mdc_readpage() */
+ LASSERT(body != NULL);
- if (body->valid & OBD_MD_FLSIZE)
- cl_isize_write(inode, body->size);
+ if (body->valid & OBD_MD_FLSIZE)
+ cl_isize_write(inode, body->size);
- nrdpgs = (request->rq_bulk->bd_nob_transferred+CFS_PAGE_SIZE-1)
- >> CFS_PAGE_SHIFT;
- SetPageUptodate(page0);
- }
- unlock_page(page0);
- ptlrpc_req_finished(request);
+ nrdpgs = (request->rq_bulk->bd_nob_transferred +
+ PAGE_CACHE_SIZE - 1) >> PAGE_CACHE_SHIFT;
+ SetPageUptodate(page0);
+ }
+ unlock_page(page0);
+ ptlrpc_req_finished(request);
- CDEBUG(D_VFSTRACE, "read %d/%d pages\n", nrdpgs, npages);
+ CDEBUG(D_VFSTRACE, "read %d/%d pages\n", nrdpgs, npages);
- ll_pagevec_init(&lru_pvec, 0);
- for (i = 1; i < npages; i++) {
- unsigned long offset;
- int ret;
+ for (i = 1; i < npages; i++) {
+ unsigned long offset;
+ int ret;
- page = page_pool[i];
+ page = page_pool[i];
- if (rc < 0 || i >= nrdpgs) {
- page_cache_release(page);
- continue;
- }
+ if (rc < 0 || i >= nrdpgs) {
+ page_cache_release(page);
+ continue;
+ }
- SetPageUptodate(page);
+ SetPageUptodate(page);
- dp = cfs_kmap(page);
- hash = le64_to_cpu(dp->ldp_hash_start);
- cfs_kunmap(page);
+ dp = kmap(page);
+ hash = le64_to_cpu(dp->ldp_hash_start);
+ kunmap(page);
- offset = hash_x_index(hash, hash64);
+ offset = hash_x_index(hash, hash64);
prefetchw(&page->flags);
ret = add_to_page_cache_lru(page, inode->i_mapping, offset,
GFP_KERNEL);
- if (ret == 0) {
- unlock_page(page);
- if (ll_pagevec_add(&lru_pvec, page) == 0)
- ll_pagevec_lru_add_file(&lru_pvec);
- } else {
- CDEBUG(D_VFSTRACE, "page %lu add to page cache failed:"
- " %d\n", offset, ret);
- }
- page_cache_release(page);
- }
- ll_pagevec_lru_add_file(&lru_pvec);
+ if (ret == 0)
+ unlock_page(page);
+ else
+ CDEBUG(D_VFSTRACE, "page %lu add to page cache failed:"
+ " %d\n", offset, ret);
+ page_cache_release(page);
+ }
- if (page_pool != &page0)
- OBD_FREE(page_pool, sizeof(struct page *) * max_pages);
- EXIT;
- return rc;
+ if (page_pool != &page0)
+ OBD_FREE(page_pool, sizeof(struct page *) * max_pages);
+
+ RETURN(rc);
}
static void ll_check_page(struct inode *dir, struct page *page)
struct page *page;
int found;
- TREE_READ_LOCK_IRQ(mapping);
+ spin_lock_irq(&mapping->tree_lock);
found = radix_tree_gang_lookup(&mapping->page_tree,
(void **)&page, offset, 1);
if (found > 0) {
struct lu_dirpage *dp;
page_cache_get(page);
- TREE_READ_UNLOCK_IRQ(mapping);
+ spin_unlock_irq(&mapping->tree_lock);
/*
* In contrast to find_lock_page() we are sure that directory
* page cannot be truncated (while DLM lock is held) and,
* In fact, page cannot be locked here at all, because
* ll_dir_filler() does synchronous io.
*/
- wait_on_page(page);
- if (PageUptodate(page)) {
- dp = cfs_kmap(page);
+ wait_on_page_locked(page);
+ if (PageUptodate(page)) {
+ dp = kmap(page);
if (BITS_PER_LONG == 32 && hash64) {
*start = le64_to_cpu(dp->ldp_hash_start) >> 32;
*end = le64_to_cpu(dp->ldp_hash_end) >> 32;
}
} else {
- TREE_READ_UNLOCK_IRQ(mapping);
+ spin_unlock_irq(&mapping->tree_lock);
page = NULL;
}
return page;
rc = md_lock_match(ll_i2sbi(dir)->ll_md_exp, LDLM_FL_BLOCK_GRANTED,
ll_inode2fid(dir), LDLM_IBITS, &policy, mode, &lockh);
if (!rc) {
- struct ldlm_enqueue_info einfo = {.ei_type = LDLM_IBITS,
- .ei_mode = mode,
- .ei_cb_bl =
- ll_md_blocking_ast,
- .ei_cb_cp =
- ldlm_completion_ast,
- .ei_cb_gl = NULL,
- .ei_cb_wg = NULL,
- .ei_cbdata = NULL};
+ struct ldlm_enqueue_info einfo = {
+ .ei_type = LDLM_IBITS,
+ .ei_mode = mode,
+ .ei_cb_bl = ll_md_blocking_ast,
+ .ei_cb_cp = ldlm_completion_ast,
+ };
struct lookup_intent it = { .it_op = IT_READDIR };
struct ptlrpc_request *request;
struct md_op_data *op_data;
- op_data = ll_prep_md_op_data(NULL, dir, NULL, NULL, 0, 0,
- LUSTRE_OPC_ANY, NULL);
+ op_data = ll_prep_md_op_data(NULL, dir, dir, NULL, 0, 0,
+ LUSTRE_OPC_ANY, NULL);
if (IS_ERR(op_data))
return (void *)op_data;
return ERR_PTR(rc);
}
- CDEBUG(D_INODE, "setting lr_lvb_inode to inode %p (%lu/%u)\n",
- dir, dir->i_ino, dir->i_generation);
+ CDEBUG(D_INODE, "setting lr_lvb_inode to inode "DFID"(%p)\n",
+ PFID(ll_inode2fid(dir)), dir);
md_set_lock_data(ll_i2sbi(dir)->ll_md_exp,
&it.d.lustre.it_lock_handle, dir, NULL);
} else {
GOTO(out_unlock, page);
}
- wait_on_page(page);
- (void)kmap(page);
- if (!PageUptodate(page)) {
- CERROR("page not updated: "DFID" at "LPU64": rc %d\n",
- PFID(ll_inode2fid(dir)), hash, -5);
- goto fail;
- }
+ wait_on_page_locked(page);
+ (void)kmap(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)) {
struct inode *inode = filp->f_dentry->d_inode;
struct ll_file_data *lfd = LUSTRE_FPRIVATE(filp);
struct ll_sb_info *sbi = ll_i2sbi(inode);
- __u64 pos = lfd->lfd_pos;
+ __u64 pos;
int hash64 = sbi->ll_flags & LL_SBI_64BIT_HASH;
int api32 = ll_need_32bit_api(sbi);
int rc;
#endif
ENTRY;
- CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p) pos %lu/%llu "
- " 32bit_api %d\n", inode->i_ino, inode->i_generation,
+ if (lfd != NULL)
+ pos = lfd->lfd_pos;
+ else
+ pos = 0;
+
+ CDEBUG(D_VFSTRACE, "VFS Op:inode="DFID"(%p) pos %lu/%llu "
+ " 32bit_api %d\n", PFID(ll_inode2fid(inode)),
inode, (unsigned long)pos, i_size_read(inode), api32);
if (pos == MDS_DIR_END_OFF)
GOTO(out, rc = 0);
rc = ll_dir_read(inode, &pos, cookie, filldir);
- lfd->lfd_pos = pos;
+ if (lfd != NULL)
+ lfd->lfd_pos = pos;
if (pos == MDS_DIR_END_OFF) {
if (api32)
filp->f_pos = LL_DIR_END_OFF_32BIT;
}
filp->f_version = inode->i_version;
#ifdef HAVE_TOUCH_ATIME_1ARG
+#ifdef HAVE_F_PATH_MNT
+ path.mnt = filp->f_path.mnt;
+#else
path.mnt = filp->f_vfsmnt;
+#endif
path.dentry = filp->f_dentry;
touch_atime(&path);
#else
op_data->op_cli_flags |= CLI_SET_MEA;
err = md_create(sbi->ll_md_exp, op_data, lump, sizeof(*lump), mode,
- cfs_curproc_fsuid(), cfs_curproc_fsgid(),
+ current_fsuid(), current_fsgid(),
cfs_curproc_cap_pack(), 0, &request);
ll_finish_md_op_data(op_data);
if (err)
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,
- inode->i_generation, rc);
+ CDEBUG(D_INFO, "md_getattr failed on inode "
+ DFID": rc %d\n", PFID(ll_inode2fid(inode)), rc);
GOTO(out, rc);
}
}
/* Read current file data version */
- rc = ll_data_version(inode, &data_version, 1);
+ rc = ll_data_version(inode, &data_version, LL_DV_RD_FLUSH);
iput(inode);
if (rc != 0) {
CDEBUG(D_HSM, "Could not read file data version of "
}
progress:
+ /* On error, the request should be considered as completed */
+ if (hpk.hpk_errval > 0)
+ hpk.hpk_flags |= HP_FLAG_COMPLETED;
rc = obd_iocontrol(LL_IOC_HSM_PROGRESS, sbi->ll_md_exp, sizeof(hpk),
&hpk, NULL);
GOTO(progress, rc = PTR_ERR(inode));
}
- rc = ll_data_version(inode, &data_version,
- copy->hc_hai.hai_action == HSMA_ARCHIVE);
+ rc = ll_data_version(inode, &data_version, LL_DV_RD_FLUSH);
iput(inode);
if (rc) {
CDEBUG(D_HSM, "Could not read file data version. "
"Request could not be confirmed.\n");
if (hpk.hpk_errval == 0)
- hpk.hpk_errval = rc;
+ hpk.hpk_errval = -rc;
GOTO(progress, rc);
}
}
-static int copy_and_ioctl(int cmd, struct obd_export *exp, void *data, int len)
+static int copy_and_ioctl(int cmd, struct obd_export *exp,
+ const void __user *data, size_t size)
{
- void *ptr;
- int rc;
+ void *copy;
+ 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;
+ OBD_ALLOC(copy, size);
+ if (copy == NULL)
+ return -ENOMEM;
+
+ if (copy_from_user(copy, data, size)) {
+ rc = -EFAULT;
+ goto out;
+ }
+
+ rc = obd_iocontrol(cmd, exp, size, copy, NULL);
+out:
+ OBD_FREE(copy, size);
+
+ return rc;
}
static int quotactl_ioctl(struct ll_sb_info *sbi, struct if_quotactl *qctl)
sbi->ll_flags & LL_SBI_RMT_CLIENT)
RETURN(-EPERM);
break;
- case Q_GETQUOTA:
- 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))
- RETURN(-EPERM);
+ case Q_GETQUOTA:
+ if (((type == USRQUOTA && current_euid() != id) ||
+ (type == GRPQUOTA && !in_egroup_p(id))) &&
+ (!cfs_capable(CFS_CAP_SYS_ADMIN) ||
+ sbi->ll_flags & LL_SBI_RMT_CLIENT))
+ RETURN(-EPERM);
break;
case Q_GETINFO:
break;
RETURN(rc);
}
+static char *
+ll_getname(const char __user *filename)
+{
+ int ret = 0, len;
+ char *tmp = __getname();
+
+ if (!tmp)
+ return ERR_PTR(-ENOMEM);
+
+ len = strncpy_from_user(tmp, filename, PATH_MAX);
+ if (len == 0)
+ ret = -ENOENT;
+ else if (len > PATH_MAX)
+ ret = -ENAMETOOLONG;
+
+ if (ret) {
+ __putname(tmp);
+ tmp = ERR_PTR(ret);
+ }
+ return tmp;
+}
+
+#define ll_putname(filename) __putname(filename)
+
static long ll_dir_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
struct inode *inode = file->f_dentry->d_inode;
int rc = 0;
ENTRY;
- CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p), cmd=%#x\n",
- inode->i_ino, inode->i_generation, inode, cmd);
+ CDEBUG(D_VFSTRACE, "VFS Op:inode="DFID"(%p), cmd=%#x\n",
+ PFID(ll_inode2fid(inode)), inode, cmd);
/* asm-ppc{,64} declares TCGETS, et. al. as type 't' not 'T' */
if (_IOC_TYPE(cmd) == 'T' || _IOC_TYPE(cmd) == 't') /* tty ioctls */
LASSERT(sizeof(lumv3.lmm_objects[0]) ==
sizeof(lumv3p->lmm_objects[0]));
/* first try with v1 which is smaller than v3 */
- if (cfs_copy_from_user(lumv1, lumv1p, sizeof(*lumv1)))
+ if (copy_from_user(lumv1, lumv1p, sizeof(*lumv1)))
RETURN(-EFAULT);
if ((lumv1->lmm_magic == LOV_USER_MAGIC_V3) ) {
- if (cfs_copy_from_user(&lumv3, lumv3p, sizeof(lumv3)))
+ if (copy_from_user(&lumv3, lumv3p, sizeof(lumv3)))
RETURN(-EFAULT);
}
* on 2.4, we use OBD_CONNECT_LVB_TYPE to detect whether the
* server will support REINT_RMENTRY XXX*/
if (!(exp_connect_flags(sbi->ll_md_exp) & OBD_CONNECT_LVB_TYPE))
- return -ENOTSUPP;
+ RETURN(-ENOTSUPP);
- filename = getname((const char *)arg);
+ filename = ll_getname((const char *)arg);
if (IS_ERR(filename))
RETURN(PTR_ERR(filename));
rc = ll_rmdir_entry(inode, filename, namelen);
out_rmdir:
if (filename)
- putname(filename);
+ ll_putname(filename);
RETURN(rc);
}
case LL_IOC_LOV_SWAP_LAYOUTS:
if (cmd == IOC_MDC_GETFILEINFO ||
cmd == IOC_MDC_GETFILESTRIPE) {
- filename = getname((const char *)arg);
+ filename = ll_getname((const char *)arg);
if (IS_ERR(filename))
RETURN(PTR_ERR(filename));
lmdp = (struct lov_user_mds_data *)arg;
lump = &lmdp->lmd_lmm;
}
- if (cfs_copy_to_user(lump, lmm, lmmsize)) {
- if (cfs_copy_to_user(lump, lmm, sizeof(*lump)))
+ if (copy_to_user(lump, lmm, lmmsize)) {
+ if (copy_to_user(lump, lmm, sizeof(*lump)))
GOTO(out_req, rc = -EFAULT);
rc = -EOVERFLOW;
}
st.st_gid = body->gid;
st.st_rdev = body->rdev;
st.st_size = body->size;
- st.st_blksize = CFS_PAGE_SIZE;
+ st.st_blksize = PAGE_CACHE_SIZE;
st.st_blocks = body->blocks;
st.st_atime = body->atime;
st.st_mtime = body->mtime;
st.st_ino = inode->i_ino;
lmdp = (struct lov_user_mds_data *)arg;
- if (cfs_copy_to_user(&lmdp->lmd_st, &st, sizeof(st)))
+ if (copy_to_user(&lmdp->lmd_st, &st, sizeof(st)))
GOTO(out_req, rc = -EFAULT);
}
out_req:
ptlrpc_req_finished(request);
if (filename)
- putname(filename);
+ ll_putname(filename);
return rc;
}
case IOC_LOV_GETINFO: {
if (rc)
RETURN(rc);
- OBD_ALLOC_LARGE(lmm, lmmsize);
- if (cfs_copy_from_user(lmm, lum, lmmsize))
- GOTO(free_lmm, rc = -EFAULT);
+ OBD_ALLOC_LARGE(lmm, lmmsize);
+ if (lmm == NULL)
+ RETURN(-ENOMEM);
+
+ if (copy_from_user(lmm, lum, lmmsize))
+ GOTO(free_lmm, rc = -EFAULT);
switch (lmm->lmm_magic) {
case LOV_USER_MAGIC_V1:
if (rc)
GOTO(free_lsm, rc);
- if (cfs_copy_to_user(&lumd->lmd_st, &st, sizeof(st)))
+ if (copy_to_user(&lumd->lmd_st, &st, sizeof(st)))
GOTO(free_lsm, rc = -EFAULT);
EXIT;
NULL);
if (rc) {
CDEBUG(D_QUOTA, "mdc ioctl %d failed: %d\n", cmd, rc);
- if (cfs_copy_to_user((void *)arg, check,
+ if (copy_to_user((void *)arg, check,
sizeof(*check)))
- CDEBUG(D_QUOTA, "cfs_copy_to_user failed\n");
+ CDEBUG(D_QUOTA, "copy_to_user failed\n");
GOTO(out_poll, rc);
}
NULL);
if (rc) {
CDEBUG(D_QUOTA, "osc ioctl %d failed: %d\n", cmd, rc);
- if (cfs_copy_to_user((void *)arg, check,
+ if (copy_to_user((void *)arg, check,
sizeof(*check)))
- CDEBUG(D_QUOTA, "cfs_copy_to_user failed\n");
+ CDEBUG(D_QUOTA, "copy_to_user failed\n");
GOTO(out_poll, rc);
}
out_poll:
if (!qctl_20)
GOTO(out_quotactl_18, rc = -ENOMEM);
- if (cfs_copy_from_user(qctl_18, (void *)arg, sizeof(*qctl_18)))
+ if (copy_from_user(qctl_18, (void *)arg, sizeof(*qctl_18)))
GOTO(out_quotactl_20, rc = -ENOMEM);
QCTL_COPY(qctl_20, qctl_18);
QCTL_COPY(qctl_18, qctl_20);
qctl_18->obd_uuid = qctl_20->obd_uuid;
- if (cfs_copy_to_user((void *)arg, qctl_18,
+ if (copy_to_user((void *)arg, qctl_18,
sizeof(*qctl_18)))
rc = -EFAULT;
}
if (!qctl)
RETURN(-ENOMEM);
- if (cfs_copy_from_user(qctl, (void *)arg, sizeof(*qctl)))
+ if (copy_from_user(qctl, (void *)arg, sizeof(*qctl)))
GOTO(out_quotactl, rc = -EFAULT);
rc = quotactl_ioctl(sbi, qctl);
- if (rc == 0 && cfs_copy_to_user((void *)arg,qctl,sizeof(*qctl)))
+ if (rc == 0 && copy_to_user((void *)arg, qctl, sizeof(*qctl)))
rc = -EFAULT;
out_quotactl:
inode == inode->i_sb->s_root->d_inode) {
struct ll_file_data *fd = LUSTRE_FPRIVATE(file);
- LASSERT(fd != NULL);
- rc = rct_add(&sbi->ll_rct, cfs_curproc_pid(), arg);
- if (!rc)
- fd->fd_flags |= LL_FILE_RMTACL;
- RETURN(rc);
+ LASSERT(fd != NULL);
+ rc = rct_add(&sbi->ll_rct, current_pid(), arg);
+ if (!rc)
+ fd->fd_flags |= LL_FILE_RMTACL;
+ RETURN(rc);
} else
RETURN(0);
}
int count, vallen;
struct obd_export *exp;
- if (cfs_copy_from_user(&count, (int *)arg, sizeof(int)))
+ if (copy_from_user(&count, (int *)arg, sizeof(int)))
RETURN(-EFAULT);
/* get ost count when count is zero, get mdt count otherwise */
RETURN(rc);
}
- if (cfs_copy_to_user((int *)arg, &count, sizeof(int)))
+ if (copy_to_user((int *)arg, &count, sizeof(int)))
RETURN(-EFAULT);
RETURN(0);
}
case LL_IOC_PATH2FID:
- if (cfs_copy_to_user((void *)arg, ll_inode2fid(inode),
+ if (copy_to_user((void *)arg, ll_inode2fid(inode),
sizeof(struct lu_fid)))
RETURN(-EFAULT);
RETURN(0);
RETURN(-ENOMEM);
/* We don't know the true size yet; copy the fixed-size part */
- if (cfs_copy_from_user(hur, (void *)arg, sizeof(*hur))) {
+ if (copy_from_user(hur, (void *)arg, sizeof(*hur))) {
OBD_FREE_PTR(hur);
RETURN(-EFAULT);
}
/* Compute the whole struct size */
totalsize = hur_len(hur);
OBD_FREE_PTR(hur);
+
+ /* Make sure the size is reasonable */
+ if (totalsize >= MDS_MAXREQSIZE)
+ RETURN(-E2BIG);
+
OBD_ALLOC_LARGE(hur, totalsize);
if (hur == NULL)
RETURN(-ENOMEM);
/* Copy the whole struct */
- if (cfs_copy_from_user(hur, (void *)arg, totalsize)) {
+ if (copy_from_user(hur, (void *)arg, totalsize)) {
OBD_FREE_LARGE(hur, totalsize);
RETURN(-EFAULT);
}
- rc = obd_iocontrol(cmd, ll_i2mdexp(inode), totalsize,
- hur, NULL);
+ if (hur->hur_request.hr_action == HUA_RELEASE) {
+ const struct lu_fid *fid;
+ struct inode *f;
+ int i;
+
+ for (i = 0; i < hur->hur_request.hr_itemcount; i++) {
+ fid = &hur->hur_user_item[i].hui_fid;
+ f = search_inode_for_lustre(inode->i_sb, fid);
+ if (IS_ERR(f)) {
+ rc = PTR_ERR(f);
+ break;
+ }
+
+ rc = ll_hsm_release(f);
+ iput(f);
+ if (rc != 0)
+ break;
+ }
+ } else {
+ rc = obd_iocontrol(cmd, ll_i2mdexp(inode), totalsize,
+ hur, NULL);
+ }
OBD_FREE_LARGE(hur, totalsize);
struct hsm_progress_kernel hpk;
struct hsm_progress hp;
- if (cfs_copy_from_user(&hp, (void *)arg, sizeof(hp)))
+ if (copy_from_user(&hp, (void *)arg, sizeof(hp)))
RETURN(-EFAULT);
hpk.hpk_fid = hp.hp_fid;
RETURN(rc);
}
case LL_IOC_HSM_CT_START:
+ if (!cfs_capable(CFS_CAP_SYS_ADMIN))
+ RETURN(-EPERM);
+
rc = copy_and_ioctl(cmd, sbi->ll_md_exp, (void *)arg,
sizeof(struct lustre_kernelcomm));
RETURN(rc);
OBD_ALLOC_PTR(copy);
if (copy == NULL)
RETURN(-ENOMEM);
- if (cfs_copy_from_user(copy, (char *)arg, sizeof(*copy))) {
+ if (copy_from_user(copy, (char *)arg, sizeof(*copy))) {
OBD_FREE_PTR(copy);
RETURN(-EFAULT);
}
rc = ll_ioc_copy_start(inode->i_sb, copy);
- if (cfs_copy_to_user((char *)arg, copy, sizeof(*copy)))
+ if (copy_to_user((char *)arg, copy, sizeof(*copy)))
rc = -EFAULT;
OBD_FREE_PTR(copy);
OBD_ALLOC_PTR(copy);
if (copy == NULL)
RETURN(-ENOMEM);
- if (cfs_copy_from_user(copy, (char *)arg, sizeof(*copy))) {
+ if (copy_from_user(copy, (char *)arg, sizeof(*copy))) {
OBD_FREE_PTR(copy);
RETURN(-EFAULT);
}
rc = ll_ioc_copy_end(inode->i_sb, copy);
- if (cfs_copy_to_user((char *)arg, copy, sizeof(*copy)))
+ if (copy_to_user((char *)arg, copy, sizeof(*copy)))
rc = -EFAULT;
OBD_FREE_PTR(copy);
git://git.whamcloud.com / fs / lustre-release.git / blobdiff